STM32 RTC initialisieren?

[Pascal R. (pacco)]

Guten morgen,

Hab vor ein paar Tagen angefangen mich mit dem STM32 auseinander zu 
setzten. Das klappt soweit auch ganz gut.

Habe ein fertiges Board mit einem STM32F103RBT6 und einer Pufferbatterie 
für die Uhr drauf.
Dabei waren einige Beispiel Hex Files. Unter anderem auch eins für die 
Uhr. Das funktioniert auch soweit.
Nur im eigenen Programm bekomm ich das nicht so richtig hin. Sitz jetzt 
schon die ganze Nacht dran und hab fast jeden Googleeintrag dazu gelesen 
(aber nicht unbedingt verstanden :))

Jetzt mal zu den Deteils:
Programmiere mit Keil uVision4, also c was relativ neu für mich ist. Hab 
vorher recht viel mit Basic (Bascom, VB...) gemacht.

Die Zeit lese ich mit TimeVar=RTC->CNTL; aus was auch soweit 
funktioniert. Zählt zumindest im Sekundentakt hoch.
Allerdings fängt das ganze nach einem Reset immer wieder bei null an. 
Wie gesagt im Beispiel läuft die Zeit bei ausgeschaltetem Controller 
über die Pufferbatterie weiter.

Wie sieht das jetzt mit dem Einstellen oder Initialisieren der RTC aus.

Muss ich der extra sagen dass sie über VBat weiter laufen soll oder muss 
ich beim Einschalten die Zeit aus irgend einem Speicher laden?

Bin da langsam recht ratlos und wäre für Hilfe dankbar

Grüße
Pacco

[Mike R. (thesealion)]

Dann zeig uns doch mal, wie du die RTC einstellst / initialisierst.

Eigentlich zeigen die Beispiele von ST recht schön, wie man die RTC und 
die Backup Domain benutzen muss.

[Pascal R. (pacco)]

Das ganze sieht bis jetzt so aus:

/******************************************************************************/
/*                                                                            */
/*                             Real-Time Clock                                */
/*                                                                            */
/******************************************************************************/

/*******************  Bit definition for RTC_CRH register  ********************/
#define  RTC_CRH_SECIE                       ((uint8_t)0x01)               /*!<Second Interrupt Enable */
#define  RTC_CRH_ALRIE                       ((uint8_t)0x02)               /*!<Alarm Interrupt Enable */
#define  RTC_CRH_OWIE                        ((uint8_t)0x04)               /*!<OverfloW Interrupt Enable */

/*******************  Bit definition for RTC_CRL register  ********************/
#define  RTC_CRL_SECF                        ((uint8_t)0x01)               /*!<Second Flag */
#define  RTC_CRL_ALRF                        ((uint8_t)0x02)               /*!<Alarm Flag */
#define  RTC_CRL_OWF                         ((uint8_t)0x04)               /*!<OverfloW Flag */
#define  RTC_CRL_RSF                         ((uint8_t)0x08)               /*!<Registers Synchronized Flag */
#define  RTC_CRL_CNF                         ((uint8_t)0x10)               /*!<Configuration Flag */
#define  RTC_CRL_RTOFF                       ((uint8_t)0x20)               /*!<RTC operation OFF */

/*******************  Bit definition for RTC_PRLH register  *******************/
#define  RTC_PRLH_PRL                        ((uint16_t)0x000F)            /*!<RTC Prescaler Reload Value High */

/*******************  Bit definition for RTC_PRLL register  *******************/
#define  RTC_PRLL_PRL                        ((uint16_t)0xFFFF)            /*!<RTC Prescaler Reload Value Low */

/*******************  Bit definition for RTC_DIVH register  *******************/
#define  RTC_DIVH_RTC_DIV                    ((uint16_t)0x000F)            /*!<RTC Clock Divider High */

/*******************  Bit definition for RTC_DIVL register  *******************/
#define  RTC_DIVL_RTC_DIV                    ((uint16_t)0xFFFF)            /*!<RTC Clock Divider Low */

/*******************  Bit definition for RTC_CNTH register  *******************/
#define  RTC_CNTH_RTC_CNT                    ((uint16_t)0xFFFF)            /*!<RTC Counter High */

/*******************  Bit definition for RTC_CNTL register  *******************/
#define  RTC_CNTL_RTC_CNT                    ((uint16_t)0xFFFF)            /*!<RTC Counter Low */

/*******************  Bit definition for RTC_ALRH register  *******************/
#define  RTC_ALRH_RTC_ALR                    ((uint16_t)0xFFFF)            /*!<RTC Alarm High */

/*******************  Bit definition for RTC_ALRL register  *******************/
#define  RTC_ALRL_RTC_ALR                    ((uint16_t)0xFFFF)            /*!<RTC Alarm Low */

Bin mir nicht sicher ob das alles ist. Ist wie gesagt etwas neu für mich

[hp-freund (Gast)]

Mike S. schrieb:
> wie man die RTC und
> die Backup Domain benutzen muss.

http://www.coocox.org/show_exam/RTC/383.html

Das Problem ist die Initialisierung selbst.

Ab hier:
if (RTC_ReadBackupRegister(RTC_BKP_DR0) ......

wird entschieden was bei Reset passiert und ob die Uhr schon gestellt 
ist.

[./. (Gast)]

> Eigentlich zeigen die Beispiele von ST recht schön, wie man die RTC und
> die Backup Domain benutzen muss.

Das Beispiel moechte ich mal sehen.

An den interessanten Stellen haben die Examples von ST immer aufgehoert.

[Mike R. (thesealion)]

./. schrieb:
>
> Das Beispiel moechte ich mal sehen.
>
> An den interessanten Stellen haben die Examples von ST immer aufgehoert.


Was sind denn für dich die interessanten Stellen?

das hier stammt direkt aus der StdLib:

  if (BKP_ReadBackupRegister(BKP_DR1) != 0xA5A5)
  {
    /* Backup data register value is not correct or not yet programmed (when
       the first time the program is executed) */

    printf("\r\n\n RTC not yet configured....");

    /* RTC Configuration */
    RTC_Configuration();

    printf("\r\n RTC configured....");

    /* Adjust time by values entered by the user on the hyperterminal */
    Time_Adjust();

    BKP_WriteBackupRegister(BKP_DR1, 0xA5A5);
  }
  else
  {
    /* Check if the Power On Reset flag is set */
    if (RCC_GetFlagStatus(RCC_FLAG_PORRST) != RESET)
    {
      printf("\r\n\n Power On Reset occurred....");
    }
    /* Check if the Pin Reset flag is set */
    else if (RCC_GetFlagStatus(RCC_FLAG_PINRST) != RESET)
    {
      printf("\r\n\n External Reset occurred....");
    }

    printf("\r\n No need to configure RTC....");
    /* Wait for RTC registers synchronization */
    RTC_WaitForSynchro();

    /* Enable the RTC Second */
    RTC_ITConfig(RTC_IT_SEC, ENABLE);
    /* Wait until last write operation on RTC registers has finished */
    RTC_WaitForLastTask();
  }

und hier noch die dazu gehörigen Initialisierung (aus der gleichen 
Datei)

void RTC_Configuration(void)
{
  /* Enable PWR and BKP clocks */
  RCC_APB1PeriphClockCmd(RCC_APB1Periph_PWR | RCC_APB1Periph_BKP, ENABLE);

  /* Allow access to BKP Domain */
  PWR_BackupAccessCmd(ENABLE);

  /* Reset Backup Domain */
  BKP_DeInit();

  /* Enable LSE */
  RCC_LSEConfig(RCC_LSE_ON);
  /* Wait till LSE is ready */
  while (RCC_GetFlagStatus(RCC_FLAG_LSERDY) == RESET)
  {}

  /* Select LSE as RTC Clock Source */
  RCC_RTCCLKConfig(RCC_RTCCLKSource_LSE);

  /* Enable RTC Clock */
  RCC_RTCCLKCmd(ENABLE);

  /* Wait for RTC registers synchronization */
  RTC_WaitForSynchro();

  /* Wait until last write operation on RTC registers has finished */
  RTC_WaitForLastTask();

  /* Enable the RTC Second */
  RTC_ITConfig(RTC_IT_SEC, ENABLE);

  /* Wait until last write operation on RTC registers has finished */
  RTC_WaitForLastTask();

  /* Set RTC prescaler: set RTC period to 1sec */
  RTC_SetPrescaler(32767); /* RTC period = RTCCLK/RTC_PR = (32.768 KHz)/(32767+1) */

  /* Wait until last write operation on RTC registers has finished */
  RTC_WaitForLastTask();
}

Damit hat man einen Zähler, der alle Sekunde um 1 erhöht wird.
Was man jetzt damit macht, z.B. das ganze in ein Datum umrechnet, das 
bleibt jedem selbst überlassen.
Oder man muss halt schauen wie andere das gelöst haben. Das hat aber 
nicht mit der Funktion der RTC an sich zu tun.