STM23F10x battery powered RTC reset

[kremsy (Gast)]

Hallo Leute,

Habe ein STM32F10x Discovery Board mit einer Battery für die dauernde 
fortsetzung der echtzeituhr.

Wie im Beispiel wird so die Zeit bei 25.00 (0Uhr) zureückgesetzt:

      /* Reset RTC Counter when Time is 23:59:59 */
      if (RTC_GetCounter() == 0x0001517F)
      {
         RTC_SetCounter(0x0);
         /* Wait until last write operation on RTC registers has finished */
         RTC_WaitForLastTask();
      }

Aber es wird nicht zurückgesetzt während es Batteriebetrieben ist, gibt 
es eine möglichkeit dass das auch zurückgesetzt wird während das system 
im Batterie betrieb läuft?

mfg kremsy

[holger (Gast)]

>Aber es wird nicht zurückgesetzt während es Batteriebetrieben ist, gibt
>es eine möglichkeit dass das auch zurückgesetzt wird während das system
>im Batterie betrieb läuft?

Wenn wer im Batteriebetrieb läuft? Nur die RTC?
Dann geht das nicht.

[kremsy (Gast)]

Will einfach dass wenn jetzt 24h Poweroff is die zeit noch stimmt.

Kann man zum Beispiel den Zählwert beim wechsel in den batterymode 
sichern oder sowas?

[holger (Gast)]

>Will einfach dass wenn jetzt 24h Poweroff is die zeit noch stimmt.

Das tut sie. Die RTC zählt einfach nur weiter als einen Tag.
Wenn du sie ausliest und nur eine 24h Anzeige willst dann machst du
halt:

      time = RTC_GetCounter() % 86400;

[kremsy (Gast)]

time = RTC_GetCounter() % 86400; kann nicht ganz stimmen.

bsp. 80000%86400=80000

Sinnvoller wäre RTC_GetCounter()/3600 % 86400; das stimmt aber auch nur 
für die ersten 24h.

Man bräuchte irgenteine formel um von RTC_GetCounter() ein vielfaches 
der stunden in 24 rauszubekommen.

[kremsy (Gast)]

Ah habs verstanden, stunden sind einfach (RTC_GetCounter()%86400)/3600 
;).

[Matthias K. (matthiask)]

Ich habe es damals so gelöst wie in dem Programmsnip. Man bekommt damit 
die Anzahl der Tage raus, wo der RTC lief und kann auch gleich noch ein 
Datum mitführen. Das ist jedoch nur ein Programmauszug als Denkanstoß. 
Für Datum kommt man an der Nutzung der BKP Register nicht herum.

#define RTC_SEKUNDEN_TAG 86400      /* Sekunden pro Tag */

// ***********************************************************************
// RTC Datumskorrektur nach Netzausfall
// ***********************************************************************
void rtc_datumskorrektur (void) {
uint16_t tage;

  zeit.counter_temp = RTC_GetCounter();   // RTC Sekundenzähler
 
  if ((zeit.counter_temp / RTC_SEKUNDEN_TAG) != 0) {
    // Mindestens 1 Datumsübertrag
    for(tage = 0; tage < (zeit.counter_temp / RTC_SEKUNDEN_TAG); tage++) {
      rtc_inc_datum(); // Datum um einen Tag erhöhen
    }
    RTC_SetCounter(zeit.counter_temp % RTC_SEKUNDEN_TAG);
  }
}

...

// ***********************************************************************
// RTC Datum um einen Tag erhöhen
// Überträge auf Monat und Jahr
// Schaltjahr (4-Jahresregel Regel) wird beachtet
// ***********************************************************************
void rtc_inc_datum(void) {
uint8_t temp_tage;

  // Wochentag aktualisieren
  if (zeit.wo_tag < 6) {
    // Wochentag erhöhen
    zeit.wo_tag++;
  } else {
    zeit.wo_tag = 0;
  }

  // Anzahl der Tage des Monats
  switch (zeit.monat) {
    case  2: // Monat Februar mit 28 Tagen ggf. mit Schaltjahr 29
             temp_tage = 28;
             // Schaltjahr Prüfung
             if (!(zeit.jahr % 4)) {
               // Schaltjahr (nur 4-Jahres-Zyklus Regel beachtet)
               // 400/100 Regel erst wieder im Jahr 2100 von Bedeutung!!!
               temp_tage = 29;
             }
             break;
    case  4: // Monate mit 30 Tagen
    case  6:
    case  9:
    case 11: // April, Juni, September, November
             temp_tage = 30;
             break;
    default: // Monate mit 31 Tagen (alle nicht mit case ausselektierten!)
             // Januar, März, Mai, Juli, August, Oktober, Dezember
             temp_tage = 31;
  }

  // Datum aktualisieren
  if (zeit.tag < temp_tage) {
    // Tag erhöhen
    zeit.tag++;
  } else {
    // neuer Monat
    zeit.tag = 1; // Tag = 1
    if (zeit.monat < 12) {
      // Monat erhöhen
      zeit.monat++;
    } else {
      // neues Jahr
      zeit.monat = 1;
      zeit.jahr++;
    }
  }
}

[kremsy (Gast)]

void RTC_Cyclic_1Sec(void)
{
    char res[2];
    uint32_t time;
    time = RTC_GetCounter() % 86400;
      /* Reset RTC Counter when Time is 23:59:59 */
     // if (RTC_GetCounter() == 0x0001517F)
      if (time == 0 && RTC_GetCounter()!=0)
      {
         RTC_SetCounter(0x0);
         /* Wait until last write operation on RTC registers has finished */
         RTC_WaitForLastTask();
      }
    if(TimeDisplay==1)
    {
      lcd_setcursor(2,2);  
      UTIL_uint2str(res, (time / 3600) , 2, 0 );  //hour
      lcd_string(res);
      LCD_Data(':');
      UTIL_uint2str(res, (time / 3600) / 60, 2, 1 );  //min
      lcd_string(res);
      LCD_Data(':');
      UTIL_uint2str(res, (time / 3600) % 60, 2, 1 ); //sec
      lcd_string(res);
      TimeDisplay=0;
    }
}

liefter 0:0:0 am display seit ich das mit der time so gemacht habe.

Jemand ne ahnung was falsch ist?

[kremsy (Gast)]

Danke matthias für deinen tollen Denkanstoß, werds mir bei gelegenheit 
näher anschaun. das BKP register nutze ich sowiso schon, von daher kein 
Problem.

Aber versteh grad net wo mein Denkfehler im aktuellen code liegt.

[kremsy (Gast)]

Ah wahrscheinlich brauchts nur nen typcast.

[kremsy (Gast)]

void RTC_Cyclic_1Sec(void)
{
    char res[2];
      /* Reset RTC Counter when Time is 23:59:59 */
      if (RTC_GetCounter() == 0x0001517F)
      {
         RTC_SetCounter(0x0);
         /* Wait until last write operation on RTC registers has finished */
         RTC_WaitForLastTask();
      }
    if(TimeDisplay==1)
    {
      lcd_setcursor(2,2);  
      UTIL_uint2str(res, (RTC_GetCounter() %86400) , 2, 0 );  //hour
      lcd_string(res);
      LCD_Data(':');
      UTIL_uint2str(res, (RTC_GetCounter() %3600) / 60, 2, 1 );  //min
      lcd_string(res);
      LCD_Data(':');
      UTIL_uint2str(res, (RTC_GetCounter() %3600) % 60, 2, 1 ); //sec
      lcd_string(res);
      TimeDisplay=0;
    }
}

Wohl zuviel geändert ;)

Neue code der funktionieren sollte:
void RTC_Cyclic_1Sec(void)
{
    char res[2];
     uint32_t time;
      time = RTC_GetCounter() % 86400;
        /* Reset RTC Counter when Time is 23:59:59 */
       // if (RTC_GetCounter() == 0x0001517F)
        if (time == 0 && RTC_GetCounter()!=0)
        {
           RTC_SetCounter(0x0);
           /* Wait until last write operation on RTC registers has finished */
           RTC_WaitForLastTask();
        }
    if(TimeDisplay==1)
    {
      lcd_setcursor(2,2);  
      UTIL_uint2str(res, (time /3600) , 2, 0 );  //hour
      lcd_string(res);
      LCD_Data(':');
      UTIL_uint2str(res, (time %3600) / 60, 2, 1 );  //min
      lcd_string(res);
      LCD_Data(':');
      UTIL_uint2str(res, (time %3600) % 60, 2, 1 ); //sec
      lcd_string(res);
      TimeDisplay=0;
    }
}

[Matthias K. (matthiask)]

Klappt es nun?

Ich mache die Zeit- und Datumaufbereitung generell im Interrupt 
(RTC_IRQHandler) und stelle es alles in einer Struktur dem Hauptprogramm 
zur Verfügung. Dort erfolgt auch die Anzeige auf LCD oder TFT.

etwas so:

//***********************************************************************************************
// RTC Interrupt-Handler
// Laufzeiten: 5us / Sekunde (100us für kompletten Jahreswechsel)
// bei 72MHz
//***********************************************************************************************
void RTC_IRQHandler (void) {
unsigned char temp_tage;

  if (RTC_GetITStatus(RTC_IT_SEC) != RESET) {
    // RTC neue Sekunde
    RTC_ClearITPendingBit(RTC_IT_SEC);      // Sekunden-Interrupft-Flag löschen
    RTC_WaitForLastTask();                  // auf RTC-Bereitschaft warten

    zeit.counter_temp = RTC_GetCounter();   // RTC Sekundenzähler
    RTC_WaitForLastTask();

    // Prüfung auf Datumswechsel (24:00:00)
    if (zeit.counter_temp == RTC_SEKUNDEN_TAG) {
      RTC_SetCounter(0x1);                  // RTC Sekundenzähler zurücksetzen
      RTC_WaitForLastTask();
      zeit.counter_temp = 0;

      // Wochentag aktualisieren
      if (zeit.wo_tag < 6) {
        // Wochentag erhöhen
        zeit.wo_tag++;
      } else {
        zeit.wo_tag = 0;
      }

      // Anzahl der Tage des Monats
      switch (zeit.monat) {
        case  2: // Monat Februar mit 28 Tagen ggf. mit Schaltjahr 29
                 temp_tage = 28;
                 // Schaltjahr Prüfung
                 if (!(zeit.jahr % 4)) {
                   // Schaltjahr (nur 4-Jahres-Zyklus Regel beachtet)
                   // 400/100 Regel erst wieder im Jahr 2100 von Bedeutung!!!
                   temp_tage = 29;
                 }
                 break;
        case  4: // Monate mit 30 Tagen
        case  6:
        case  9:
        case 11: // April, Juni, September, November
                 temp_tage = 30;
                 break;
        default: // Monate mit 31 Tagen (alle nicht mit case ausselektierten!)
                 // Januar, März, Mai, Juli, August, Oktober, Dezember
                 temp_tage = 31;
      }

      // Datum aktualisieren
      if (zeit.tag < temp_tage) {
        // Tag erhöhen
        zeit.tag++;
      } else {
        // neuer Monat
        zeit.tag = 1; // Tag = 1
        if (zeit.monat < 12) {
          // Monat erhöhen
          zeit.monat++;
        } else {
          // neues Jahr
          zeit.monat = 1;
          zeit.jahr++;
        }
      }
    }

    // Uhrzeit aktualisieren
    zeit.stunde  = zeit.counter_temp / 3600;
    zeit.minute  = (zeit.counter_temp % 3600) / 60;
    zeit.sekunde = (zeit.counter_temp % 3600) % 60;

    // Backupregister aktualisieren
    BKP_WriteBackupRegister(BKP_DR2, zeit.tag);
    BKP_WriteBackupRegister(BKP_DR3, zeit.monat);
    BKP_WriteBackupRegister(BKP_DR4, zeit.jahr);
    BKP_WriteBackupRegister(BKP_DR5, zeit.wo_tag);
    BKP_WriteBackupRegister(BKP_DR6, zeit.mesz);

    // Meldung an das Hauptprogramm, dass neue Zeit vorhanden ist.
    zeit.update = 1;
  }
}

.....

// Systemzeit-Struktur
struct zeit_struc {
  volatile uint32_t counter_temp;   // RTC-Counter (Snap)
  volatile uint16_t jahr;           // Jahr 4 stellen
  volatile uint8_t  monat;          // Monat 1-12
  volatile uint8_t  tag;            // Tag 1-31
  volatile uint8_t  stunde;         // 0-23
  volatile uint8_t  minute;         // 0-59
  volatile uint8_t  sekunde;        // 0-59
  volatile uint8_t  wo_tag;         // 0-6
  volatile uint8_t  mesz;           // Sommerzeit 1=MESZ(Sommerzeit) 0=MEZ(Winter)
  volatile uint8_t  update;         // 1=Neue Sekunde
  volatile uint8_t  set;            // 1=Uhrzeit stellen
};
struct zeit_struc zeit;      // Systemzeit Variablen

[kremsy (Gast)]

Jap klappt alles, wenn ich Zeit habe werde ich es vielleicht auch so 
Umsetzen wie du ;).