PIT bei ATMEGA4809 macht nicht was ich gerne hätte

[Andreas N. (orangehead)]

Hallo Leute,
Ich bau grad ne lorawan Platine mit ATMEGA4809, RFM95 und 2 wasserfesten 
ds18b20 um Bodentemperaturen zu messen. Ich nutze die mcci lmic library 
und deswegen Arduino.
Dabei gehe ich gerade die gesamte Software durch um die Wachzeit des uC 
zu minimieren.
Also, beim ds18b20 muss man ihm 600ms zum auslesen geben und dabei 
wollte ich den uC schlafen legen. Während den 20 minütigen Schlafphasen 
nutze ich den PIT (Periodic interrupt timer) um die Node aus dem 
Tiefschlaf zu wecken. Ich dachte ich kann einfach den PIT prescaler auf 
PIT_DIV1024 setzen was mit dem 1k RTC grob eine Sekunde ist, passt und 
tschüss...
Falsch gedacht, offensichtlich hängt der erste Interrupt davon ab in 
welcher Zählphase der RTC grad ist und erst beim zweiten Interrupt ist 
der Intervall korrekt.
Mit den TCA und TCB kann ich keinen Interrupt auslösen der den uC aus 
dem deep sleep weckt(und hab auch kaum mal was damit gemacht)

Hat da jemand eine Ahnung wie ich die 600ms schlaf hinkriege?

Hier ein kleines blinky Beispielprogramm bei dem ich den Nano Every zum 
rumprobieren nutze

#include "settings.h"
#include <avr/io.h>
#include <avr/interrupt.h>
#include <avr/sleep.h>

void setup()
{  
  RTC_init();
  SLEEP_init();
  PORT_init();
}

void loop()
{
  blink(1);  
  SLEEP_1s();  
  sei();
  sleep_cpu();
  sei();

  blink(8);
  SLEEP_8s();
  sei();
  sleep_cpu();
  sei();
}

settings.cpp

#include "settings.h"
#include <util/delay.h>

#define F_CPU 16000000UL


void RTC_init(void) {

  uint8_t temp;
  temp = CLKCTRL.OSC32KCTRLA;
  temp &= ~CLKCTRL_ENABLE_bm;
  CPU_CCP = CCP_IOREG_gc;
  CLKCTRL.OSC32KCTRLA = temp;
  while (RTC.STATUS > 0)
  {
    ; 
  }

  RTC.CLKSEL = RTC_CLKSEL_INT1K_gc;
  RTC.PITINTCTRL = RTC_PI_bm;

  RTC.PITCTRLA = RTC_PERIOD_CYC32768_gc | RTC_PITEN_bm;

  while (RTC.PITSTATUS > 0) {
    ;
  }
}



void SLEEP_init(void) {
  SLPCTRL.CTRLA |= SLPCTRL_SMODE_PDOWN_gc;
  SLPCTRL.CTRLA |= SLPCTRL_SEN_bm;
}

void SLEEP_1s(){
  RTC.PITCTRLA = RTC_PERIOD_CYC1024_gc | RTC_PITEN_bm;;
  while (RTC.PITSTATUS > 0) {
    ;
  }
}

void SLEEP_8s(){
  RTC.PITCTRLA = RTC_PERIOD_CYC8192_gc | RTC_PITEN_bm;;
  while (RTC.PITSTATUS > 0) {
    ;
  }
}

void PORT_init(void)
{
  PORTB.DIR |= PIN5_bm;
  PORTB.OUTSET |= PIN5_bm;
}

void blink(uint8_t _num){
  for(int i = 0; i < _num; i++){
    PORTB.OUTTGL = PIN5_bm;
    _delay_ms(30);
    PORTB.OUTTGL = PIN5_bm;
    _delay_ms(30);
  }
}


ISR(RTC_PIT_vect)
{
  RTC.PITINTFLAGS = RTC_PI_bm;
}

settings.h

// settings.h

#ifndef _SETTINGS_h
#define _SETTINGS_h

void RTC_init(void);
void SLEEP_init(void);
void SLEEP_8s(void);
void SLEEP_1s(void);
void PORT_init(void);
void blink(uint8_t _num);



#endif

[neuer PIC Freund (Gast)]

> Also, beim ds18b20 muss man ihm 600ms zum auslesen geben

Wo hast du diese Information her?
Für 11 bit reichen auch 375 ms. Evtl weniger.

Kannst du nicht einfach bei 32kHz auf idle schalten, und Vollgas, wenn 
gebraucht? Die 1.5 mA für den Sensor und das HF machen den uc ja zum 
Kleinverbraucher.

[Georg M. (g_m)]

Andreas N. schrieb:
> Mit den TCA und TCB kann ich keinen Interrupt auslösen der den uC aus
> dem deep sleep weckt

Der TCA und der TCB sind nicht zum Schlafen gedacht. Aber der RTC 
verbraucht im SMODE_STDBY weniger als 2µA, und hat auch die OVF und CMP 
Interrupts.

[Veit D. (devil-elec)]

Hallo,

hast du das schon durchgearbeitet?
https://github.com/MicrochipTech/TB3213_Getting_Started_with_RTC

[S. Landolt (Gast)]

Nanu, Andreas N., "nach Diktat verreist"?

So ganz verstehe ich die Frage nicht: der PIT läuft durch, für die lange 
Pause wählt man einen Ausgang mit großem Teiler, für die 
Temperaturmessphase einen mit passend kleinem.

[Andreas N. (orangehead)]

Sorry für die lange inaktivität,hatte viel zu tun, jemand sollte mal den 
48 Stunden Tag erfinden

neuer PIC Freund schrieb im Beitrag #7129532:
>> Also, beim ds18b20 muss man ihm 600ms zum auslesen geben
>
> Wo hast du diese Information her?
> Für 11 bit reichen auch 375 ms. Evtl weniger.
>
> Kannst du nicht einfach bei 32kHz auf idle schalten, und Vollgas, wenn
> gebraucht? Die 1.5 mA für den Sensor und das HF machen den uc ja zum
> Kleinverbraucher.

Ach Sorry, du hast recht. Es waren 750ms bei 12 bit!!! 11 bit langen 
aber, also 375ms....
Wie meinst du das, die Main clock auf 32k schalten und ein 
_delay_ms(375); und dann wieder die mainclock auf vollgas?

[Andreas N. (orangehead)]

S. Landolt schrieb:
> Nanu, Andreas N., "nach Diktat verreist"?
>
> So ganz verstehe ich die Frage nicht: der PIT läuft durch, für die lange
> Pause wählt man einen Ausgang mit großem Teiler, für die
> Temperaturmessphase einen mit passend kleinem.

So dachte ich mir das ja auch.
Im Datenblatt Example 22-1. PIT Timing Diagram for PERIOD(im Anhang) 
scheint es dass der RTC erst nach einer Periode den interrupt richtig 
erkennt, eben das ist mir nicht ganz klar.
Oben in meinem Beispielprogramm blinkt die led eben nicht nach den 
eingestellten Perioden und irgenwie bin ich ratlos.

[Andreas N. (orangehead)]

Veit D. schrieb:
> Hallo,
>
> hast du das schon durchgearbeitet?
> https://github.com/MicrochipTech/TB3213_Getting_Started_with_RTC

Kapitel PIT, JUP!
Kapitel Periodic Interrup, JUP!
Kapitel Overflow Interrupt, hakt irgendwie...

[Veit D. (devil-elec)]

Hallo,

kannst du das "hakt irgendwie..." näher beschreiben?

Ich habe mir ein Bsp. genommen und etwas umgebaut. Die RTC triggert mit 
seinem Overflow den ADC mittels Event jede Sekunde, der macht eine 
Messung und in der Hauptschleife wird nur auf die Fertigmeldung des ADC 
gewartet. Das RTC Overflow funktioniert demzufolge. Im ADC Interrupt 
könnte man die RTC jedesmal stoppen und neu konfigurieren o.ä.

/*
  Programmed and tested with: Arduino IDE 1.8.19
  Board: Arduino Nano Every
  Registers Emulation: None
*/

#include <avr/interrupt.h>
#include <util/atomic.h>

struct ADC
{
  volatile unsigned int reading;
  volatile bool finish;
};
ADC adc0;

void setup()
{
  Serial.begin(250000);
  Serial.println(F("\nReset ### ###"));
  
  initRTC();
  initADC0();   // Pin 21 / PD5
  initEventSystem();
}

void loop()
{
  readingADC0();
}

void readingADC0 (void)
{
  if (adc0.finish)
  {
    unsigned int var {0};
    ATOMIC_BLOCK (ATOMIC_RESTORESTATE)
    {
      var = adc0.reading;
    }
    Serial.print("ADC0: "); Serial.print(var); Serial.print(" Digits");
    // wenn man davon ausgeht das Ub 5.0V sind ...
    const unsigned long voltage = 5000UL * var / 1024;
    Serial.print(" = "); Serial.print(voltage); Serial.println("mV");
    adc0.finish = false;
  }
}

void initADC0(void)
{
  ADC0.MUXPOS  = ADC_MUXPOS_AIN5_gc;    // select ADC0 input channel -->> Pin 21 / PD5
  ADC0.EVCTRL  = ADC_STARTEI_bm;        // enable event triggered conversion
  ADC0.INTCTRL = ADC_RESRDY_bm;         // enable 'ready' interrupt
}

void initRTC (void)
{  
  while (RTC.STATUS > 0) { ; }          // wait for all register to be synchronized
  RTC.CLKSEL = RTC_CLKSEL_INT32K_gc;    // period duration 30,518µs
  RTC.PER = 64;                         // set period -->> 1000ms / 15,625ms
  
  // RTC.CTRLA Bug, see Errata
  byte temp {0};
  temp |= RTC_PRESCALER_DIV512_gc;      // prescaler 512 -->> 30,518µs * 512 = 15,625ms
  temp |= RTC_RTCEN_bm;                 // RTC enable  
  RTC.CTRLA = temp;
}

void initEventSystem(void)
{
  EVSYS.CHANNEL7 = EVSYS_GENERATOR_RTC_OVF_gc;    // connect 'RTC OVF' to channel 7
  EVSYS.USERADC0 = EVSYS_CHANNEL_CHANNEL7_gc;     // connect generator 'RTC OVF' with user 'ADC0' via channel 7
}

ISR(ADC0_RESRDY_vect)
{
  adc0.reading = ADC0.RES;
  adc0.finish = true;
  ADC0.INTFLAGS = ADC_RESRDY_bm;          // clear result ready interrupt flag
}

[S. Landolt (Gast)]

Hier ein Muster (Programmausschnitt, in Assembler), wie ich mir den 
Ablauf vorstelle: lange Pause durch LED an C0 dargestellt, blinkt 4 s 
an, 4 s aus; Messphase durch LED an A7 dargestellt, leuchtet zu Beginn 
jeder Pause für 1 s.

    sei
main_loop:
    puti    RTC_PITCTRLA,0b0_1001_00_1      ; /1024, en
    sbi     VPORTC_OUT,0                    ; an
    sbi     VPORTA_OUT,7                    ; an
    sleep
    cbi     VPORTA_OUT,7                    ; aus
    puti    RTC_PITCTRLA,0b0_1011_00_1      ; /4096, en
    sleep
    cbi     VPORTC_OUT,0                    ; aus
    sleep
  rjmp      main_loop

[Georg M. (g_m)]

Andreas N. schrieb:
> Während den 20 minütigen Schlafphasen
> nutze ich den PIT (Periodic interrupt timer)

Beim PIT beträgt die längste Periode nur 32s. Der RTC kann wesentlich 
längere Perioden generieren.

Hier ist ein Beispielcode (getestet am ATtiny402)
Periodendauer:  ca. 10 min
LED-Leuchtdauer: ca. 0.5s

#include <avr/io.h>
#include <avr/interrupt.h>
#include <avr/sleep.h>

ISR(RTC_CNT_vect) 
{
  if(RTC.INTFLAGS & RTC_OVF_bm)
  {
    PORTA.OUTSET = PIN3_bm;               // LED on
    RTC.INTFLAGS = RTC_OVF_bm;            // clear RTC OVF interrupt flag
  }
  else if(RTC.INTFLAGS & RTC_CMP_bm)
  {
    PORTA.OUTCLR = PIN3_bm;               // LED off
    RTC.INTFLAGS = RTC_CMP_bm;            // clear RTC CMP interrupt flag
  }
}

int main(void)
{
  PORTA.DIRSET = PIN3_bm;                       // PA3 output (LED)

  RTC.CLKSEL = RTC_CLKSEL_INT1K_gc;             // 1024 Hz from OSCULP32K
  while (RTC.STATUS > 0) {}                     // wait for all register to be synchronized
  RTC.INTCTRL = RTC_OVF_bm | RTC_CMP_bm;        // enable RTC OVF and CMP interrupts
  RTC.PER = 0x4aff;                             // RTC period (10 min)
  RTC.CMP = 0x000f;                             // RTC compare value (500 ms)
  RTC.CTRLA = RTC_RUNSTDBY_bm | RTC_PRESCALER_DIV32_gc | RTC_RTCEN_bm;  // enable Run In Standby, RTC clock/32 (32Hz), enable RTC

  SLPCTRL.CTRLA = SLPCTRL_SMODE_STDBY_gc;       // select STANDBY sleep mode
  sei();                                        // enable Global Interrupts

  while(1)
  {
    sleep_mode();
  }
}

Ob die Zeile

while (RTC.STATUS > 0) {}              // wait for all register to be synchronized

wirklich notwendig ist, kann ich nicht sagen, weiß ich selbst nicht.

[Andreas N. (orangehead)]

Hallo Georg Danke dir!!
Ich spiel grad mit deinem Programm und hab versucht den unterschied 
zwischen RTC_OVF und RTC_CMP zu verstehen... im prinzip dasselbe nur 
dass OVF den RTC zurücksetzt und CMP nicht.
Das würde heissen:

-OVF
-ds18b20 start reading
-sleep
-CMP
-ds18b20 read sensor und send
-sleep

Morgen versuch ich mal ob das geht

[Andreas N. (orangehead)]

Das ding läuft!! und ich habs gleich mit PIT kombiniert und einen 
ds18b20 eingebaut. Da ist noch einiges nicht schön aufgeräumt aber es 
tut grad was es soll

Danke Danke an euch alle

#include <avr/io.h>
#include <avr/interrupt.h>
#include <avr/sleep.h>
#include <OneWire.h>

ISR(RTC_CNT_vect)
{
  if(RTC.INTFLAGS & RTC_OVF_bm)
  {
    //PORTB.OUTSET = PIN5_bm;               // LED on
    PORTB.OUTTGL = PIN5_bm;
    RTC.INTFLAGS = RTC_OVF_bm;            // clear RTC OVF interrupt flag

  }

  else if(RTC.INTFLAGS & RTC_CMP_bm)

  {

    //PORTB.OUTCLR = PIN5_bm;               // LED off
    PORTB.OUTTGL = PIN5_bm;

    RTC.INTFLAGS = RTC_CMP_bm;            // clear RTC CMP interrupt flag

  }

}

ISR(RTC_PIT_vect)
{
  /* Clear flag by writing '1': */
  RTC.PITINTFLAGS = RTC_PI_bm;
}

void setup()
{
  Serial.begin(250000);
  
  
PORTB.DIRSET = PIN5_bm;                       // PA3 output (LED)
PORTB.OUTSET = PIN5_bm;

RTC.CLKSEL = RTC_CLKSEL_INT1K_gc;             // 1024 Hz from OSCULP32K

while (RTC.STATUS > 0) {}                     // wait for all register to be synchronized

///////////PIT
RTC.PITINTCTRL = RTC_PI_bm; /* Periodic Interrupt: enabled */
RTC.PITCTRLA = RTC_PERIOD_CYC8192_gc | RTC_PITEN_bm; /* Enable: enabled */

while (RTC.PITSTATUS > 0) {
  ;
}
///////////PIT end

RTC.INTCTRL = RTC_OVF_bm;// |RTC_CMP_bm;        // enable RTC OVF and CMP interrupts

//RTC.PER = 0x4aff;                             // RTC period (10 min)
RTC.PER = 0x0020;
//RTC.CMP = 0x000f;                             // RTC compare value (500 ms)

RTC.CTRLA = RTC_RUNSTDBY_bm | RTC_PRESCALER_DIV32_gc | RTC_RTCEN_bm;  // enable Run In Standby, RTC clock/32 (32Hz), enable RTC

sei();                                        // enable Global Interrupts
}

void loop()
{
  
  startConversion(2);
  SLPCTRL.CTRLA = SLPCTRL_SMODE_STDBY_gc;
  sleep_mode();
  Serial.println("OVF wake");
  float temp = getTemperature(2);
  Serial.println(temp);
  SLPCTRL.CTRLA = SLPCTRL_SMODE_PDOWN_gc;
  sleep_mode();
  Serial.println("PIT wake");
}


void startConversion(uint8_t _pin){
  OneWire ds(_pin);
  //Tx  Master Read ROM address
  ds.reset();
  
  //Tx  "Skip ROM" command vor "temp read" command um ohne adresse messung zu starten
  ds.write(0xCC);

  //Tx  sending Temp reading command
  ds.write(0x44, 1);
}

float getTemperature(uint8_t _pin) {
  OneWire ds(_pin);
  byte data[9];
  bool present1 = 0;
  bool present2 = 0;

  //Tx  Master Reset
  ds.reset();
  
  //Tx  "Skip ROM" command vor "read scratchpad" command um ohne adresse das scratchpad zu lesen
  ds.write(0xCC);

  //Rx read Scratchpad command
  ds.write(0xBE);

  //Rx read 9 bytes
  for (int i = 0; i < 9; i++) {
    data[i] = ds.read();
  }
    
  int16_t convert = (data[1] << 8) | data[0];
  float convertToFloat = ((float)convert) / 16;
  
  return  convertToFloat;  
}