interner RTC oder externer

[Sven der Schreckliche (Gast)]

Hallo,

ich habe hier das PIC32 Ethernet Starter kit (bestückt mit PIC32MX795) 
und möchte gerne den internen RTC nutzen.

Ich habe noch nie mit einer RTC gearbeitet und mir fehlt auch ein wenig 
das Hintergrundwissen dazu. Trotzdem wäre es schön erst einmal Datum, 
Zeit etc. auf einem Display darstellen zu können.
Hierfür habe ich mir das RTCC_Code Example von Microchip angeguckt, 
welches sich zwar compilieren lässt, aber beim debuggen immer in einer 
Schleife hängen bleibt. Diese Schleife scheint zu überprüfen, ob die 
Clock des RTC überhaupt läuft.

Irgendetwas scheint also noch faul zu sein. Es gibt noch einen RTCC Pin 
am PIC. Wofür genau ist dieser da und wie muss dieser beschaltet werden, 
um den internen RTC zu nutzen?

Ich habe einmal das Blockdiagramm des RTCs angehangen.

Danke für jeglichen Input

[H. D. (lactobacillus)]

Einen Quarz hast du?

[Sven der Schreckliche (Gast)]

H. D. schrieb:
> Einen Quarz hast du?

Kann man da nicht einfach den primären Oszillator für nutzen.

Wenn ich das richtig sehe fehlt auf dem Starterkit ein externer 
Sekundäroszillator (32.768 kHz). Dieser scheint standardmäßig nicht auf 
dem Board verbaut zu sein. Ist dieser unabdingbar für den internen RTC?

[Rainer (Gast)]

Ich kenn den PIC32 nicht wirklich, aber laut deinem angehängten Diagramm 
gibt es beim PIC32 auch einen internen 32kHz Oszillator.
Hast du bei deinem Beispiel mal nachgesehen ob hier der interne 
Oszillator auch ausgewählt wird?

Gruß
Rainer

[WehOhWeh (Gast)]

Die externe lohnt nur, wenn du den µC irgendwann abschalten willst, und 
das Batteriegepuffert weiterlaufen muss, oder wenn du keinen Clock hast.

Sonst würde ich die interne nehmen. Das hat den Vorteil, dass das 
Auslesen der Uhrzeit nur aus ein paar Registerzugriffen besteht, bei der 
externen braucht man I2C und wasweisich noch dazu.

Dazu kommen die Alarminterrupts, die sehr praktisch sind.

Kommst du an SOSCI heran? In dem Fall könntest du dir die 32768 Hz 
mittels Timer erzeugen und auf den SOSCI-Eingang draufgeben. Wenn man an 
beide drankommt (SOSCI + SOSCO), kann man auch einfach eine Uhrenquarz 
dranhängen - von einem kaputten Mainboard oder ähnlichem.

Falls gewünscht, kann ich dir heute Abend ein Beispiel für einen 
PIC32MX470 zukommen lassen, das sollte sich leicht portieren lassen. Ich 
habe es selber geschrieben, weil ich das Beispiel von Microchip nicht 
verstanden habe ;-)

Sonst kannst du ja eine DS1337 über I2C oder ähnliches nehmen.

[Sven der Schreckliche (Gast)]

Hallo Rainer,
Hallo WehOhWeh.

Vielen Dank für Eure Hilfe. Ein Beispiel für den PIC32MX470 wäre sehr 
nett. Danke dafür.

Ich poste hier mal das Microchip Beispiel. Wie gesagt lässt es sich 
compilieren, aber ich bleibe stets an der markierten Stelle hängen:

#include <plib.h>
#include "time_date.X/displaytech.h"

#if defined (__32MX360F512L__) || (__32MX460F512L__) || (__32MX795F512L__) || (__32MX430F064L__) || (__32MX450F256L__) || (__32MX470F512L__)
// Configuration Bit settings
// SYSCLK = 80 MHz (8MHz Crystal / FPLLIDIV * FPLLMUL / FPLLODIV)
// PBCLK = 80 MHz (SYSCLK / FPBDIV)
// Primary Osc w/PLL (XT+,HS+,EC+PLL)
// WDT OFF
// Other options are don't care
#pragma config FPLLMUL = MUL_20, FPLLIDIV = DIV_2, FPLLODIV = DIV_1, FWDTEN = OFF
#pragma config POSCMOD = HS, FNOSC = PRIPLL, FPBDIV = DIV_1
#define SYS_FREQ (80000000L)



//  local function prototypes
int CheckRtccRunning(int secWait);

/*********************************************************************
 * Function:        int main(void)
 *
 * PreCondition:    None
 *
 * Input:           None
 *
 * Output:          1 if everything went on ok, 0 if failed
 *
 * Side Effects:    None
 *
 * Overview:        The function is an example of using the RTCC device.

 * Note:            None
 ********************************************************************/
int main(void)
{
  rtccTime  tm, tm1;      // time structure
  rtccDate  dt, dt1;      // date structure

  // Configure the device for maximum performance but do not change the PBDIV
  // Given the options, this function will change the flash wait states, RAM
  // wait state and enable prefetch cache but will not change the PBDIV.
  // The PBDIV value is already set via the pragma FPBDIV option above..
  SYSTEMConfig(SYS_FREQ, SYS_CFG_WAIT_STATES | SYS_CFG_PCACHE);

//***************************************************************
// Pins für 16/2 Display und Initialisierung
//***************************************************************

    button_in;
    RS_OUT;
    E_OUT;
    DB7_OUT;
    DB7_0;
    DB6_OUT;
    DB6_0;
    DB5_OUT;
    DB5_0;
    DB4_OUT;
    DB4_0;
    E_0;

    DelayMs(100);
    lcd_init();



  RtccInit();      // init the RTCC
  while(RtccGetClkStat()!=RTCC_CLK_ON); //  ->  HIER BLEIBT DAS PROGRAMM IN DER SCHLEIFE HAENGEN

// wait for the SOSC to be actually running and RTCC to have its clock source
              // could wait here at most 32ms



  // when using the RtccSetTimeDate() function, the write operation is enabled if needed and then restored to the initial value
  // so that we don't have to worry about calling RtccWrEnable()/RtccWrDisable() functions

  // let's start setting the current date
  {
    // one way to do it
    tm.l=0;
    tm.sec=0x30;
    tm.min=0x07;
    tm.hour=0x10;

    dt.wday=2;
    dt.mday=0x16;
    dt.mon=0x01;
    dt.year=0x07;
    RtccSetTimeDate(tm.l, dt.l);
  }
  // however, much easier to do it should be:
  RtccSetTimeDate(0x10073000, 0x07011602);  // time is MSb: hour, min, sec, rsvd. date is MSb: year, mon, mday, wday.
                        // please note that the rsvd field has to be 0 in the time field!

  // NOTE: at this point the writes to the RTCC time and date registers are disabled

  // we can also read the time and date
  tm1.l=RtccGetTime();
  dt1.l=RtccGetDate();
  // can check that the time and date are the ones we just set
  if(tm.hour!=tm1.hour ||tm.min!=tm1.min)
  {
    return 0;
  }
  if(dt.l!=dt1.l)    // check for proper date
  {
    return 0;
  }
  // we can read the time and date in a single operation
  RtccGetTimeDate(&tm1, &dt1);

  // now that we know the RTCC clock is up and running, it's easier to start from fresh:
  RtccOpen(tm.l, dt.l, 0);  // set time, date and calibration in a single operation

  // check that the RTCC is running
  if(!CheckRtccRunning(3))
  {
    return 0;
  }

  // another way to see the RTCC is tunning: check the SYNC bit
  while(RtccGetSync());  // wait sync to be low
  while(!RtccGetSync());  // wait to be high
  while(RtccGetSync());  // wait sync to be low again


  // other RTCC operations

  // adjust the RTCC timing
  RtccSetCalibration(200);  // value to calibrate with at each minute

  // enabling the RTCC output pin
  RtccSelectPulseOutput(1);    // select the seconds clock pulse as the function of the RTCC output pin
  RtccSelectPulseOutput(0);    // select the alarm pulse as the function of the RTCC output pin
  RtccOutputEnable(1);      // enable the Output pin of the RTCC
        set_cursor(0, 1);
            lcd_out("24 Bit AD: ");
            integerintoasciiconverter(RtccGetTime());
        while(1)
        {

        }


}



/*********************************************************************
 * Function:        int CheckRtccRunning(int secWait)
 *
 * PreCondition:    None
 *
 * Input:           None
 *
 * Output:          1(true) if test succeeded, 0(FALSE) otherwise
 *
 * Side Effects:    None
 *
 * Overview:        The function checks that the RTCC has the clock enabled and counts the time.
 *
 * Note:            None
 ********************************************************************/
int CheckRtccRunning(int secWait)
{
  #define  WAIT_FOR_SEC_TMO  1100      // how many ms to wait for the RTCC seconds count to change

  rtccTime  t0, t1;
  int    fail;
  int    secCnt;
  unsigned int  tStart;


  
  for(secCnt=0, fail=0; secCnt<secWait; secCnt++)
  {
    tStart=ReadCoreTimer();
    t0.l=RtccGetTime();
    do
    {
      t1.l=RtccGetTime();
    }while((t1.sec == t0.sec) && (ReadCoreTimer()-tStart) < (SYS_FREQ/2000)*WAIT_FOR_SEC_TMO);  // wait seconds change

    if(t1.sec==t0.sec)
    {
      fail=1;
      break;  // failed
    }
  }
  
  return !fail;
}

Ich habe jetzt keinen externen Quarz an das Board angehangen!

Es ist auf dem Starterkit aber ein (Connector Y3) Footprint vorgesehen, 
um einen externen sekundären Oszillator anzuhängen. Dies müßten SOSC1 
und SOSCO sein. Dieser ist aber nicht bestückt.

Meine Frage ist jetzt, ob ich zunächst einen ähnlichen Oszillator 
anlöten muss um das RTC Modul auslesen zu können?

Danke nochmal an Alle für die Hilfe!

[X4U (Gast)]

Sven der Schreckliche schrieb:
> Ich habe jetzt keinen externen Quarz an das Board angehangen!

Das muss du dem Pic auch sagen (über ein config register).

Main clock läuft mit 20 Mhz, also gibt es vermutlich einen internen 32 
kHz Oszillator. Interne sind aber per se ungenau (sonst würde niemand 
externe Quarze nutzen). Ein Prozent sind da schon sehr gut, was auf 36 
Sekunden pro Stunde hinaus läuft.

[Frank (Gast)]

Zeig mal die RtccInit().
Irgendwo muss ja gesagt werden ob der interne oder der externe Clock 
genutzt werden soll.

[Sven der Schreckliche (Gast)]

Frank schrieb:
> Zeig mal die RtccInit().

/*********************************************************************
 * Function:        rtccRes RtccInit(void)
 *
 * PreCondition:    None
 *
 * Input:           None
 *
 * Output:          RTCC_CLK_ON if the RTCC clock is actually running
 *           a clock status code otherwise
 *
 * Side Effects:    None
 *
 * Overview:        The function initializes the RTCC device. It starts the RTCC clock,
 *           enables the RTCC and disables RTCC write. Disables the Alarm and the OE.
 *           Clears the alarm interrupt flag and disables the alarm interrupt.
 *
 * Note:            It usually takes 4x256 clock cycles (approx 31.2 ms) for the oscillator signal to be available
 *           to the RTCC. The user must make sure that the clock is actually running using RtccGetClkStat()
 *           before expecting the RTCC to count.
 *
 * Example:      rtccRes res=RtccInit();
 ********************************************************************/
rtccRes    RtccInit(void);

/*********************************************************************
 * Function:        rtccRes RtccOpen((unsigned long tm, unsigned long dt, int drift)
 *
 * PreCondition:    tm an unsigned long containing the fields of a valid rtccTime structure:
 *             - sec:  BCD codification, 00-59
 *             - min:  BCD codification, 00-59
 *             - hour: BCD codification, 00-24
 *       dt is an unsigned long conatining the valid fields of a rtccDate structure:
 *             - wday:  BCD codification, 00-06
 *             - mday: BCD codification, 01-31
 *             - mon: BCD codification, 01-12
 *             - year: BCD codification, 00-99
 *       drift has to fit into signed 10 bits representation
 *
 * Input:             tm - the time value to be set
 *       dt - the date value to be set
 *       drift  - value to be added/subtracted to perform calibration
 *
 * Output:          RTCC_CLK_ON if the RTCC clock is actually running
 *           a clock status code otherwise
 *
 * Side Effects:    None
 *
 * Overview:        The function initializes the RTCC device. It starts the RTCC clock, sets the desired time and calibration
 *           and enables the RTCC. Disables the Alarm and the OE and further RTCC writes.
 *           Clears the alarm interrupt flag and disables the alarm interrupt.
 *
 * Note:            It usually takes 4x256 clock cycles (approx 31.2 ms) for the oscillator signal to be available
 *           to the RTCC. The user must make sure that the clock is actually running using RtccGetClkStat()
 *           before expecting the RTCC to count.
 *
 * Example:    rtccDate dt; dt.wday=05; dt.mday=0x28; dt.mon=0x2; dt.year=0;
 *       rtccTime tm; tm.sec=0x15; tm.min=0x30; tm.hour=01;
 *       rtccRes res=RtccOpen(tm.l, dt.l, 10);
 *           or
 *       rtccRes res=RtccOpen(0x01301500, 0x00022805, 10);
 ********************************************************************/
rtccRes    RtccOpen(unsigned long tm, unsigned long dt, int drift);

[Frank (Gast)]

>The user must make sure that the clock is actually running using 
>RtccGetClkStat() before expecting the RTCC to count.

[Frank (Gast)]

Debug mal und schau was

rtccRes res=RtccInit();

zurück gibt.

[Sven der Schreckliche (Gast)]

Frank schrieb:
> Debug mal und schau wasrtccRes res=RtccInit();
> zurück gibt.

es wird

RTCC_SOSC_NRDY,      // SOSC not running

zurückgegeben.

Er scheint also den sekundären Quarz zu erwarten, welcher bei mir ja 
nicht bestückt ist.

Habe jetzt einfach mal einen bestellt.

[WehOhWeh (Gast)]

anbei das Beispiel für den MX470.

Das ist halt nicht konfigurierbar wie die Microchip Libs, sondern deckt 
nur meinen Bedarf ab (Alarm, RTCC, Zeit setztn / lesen). Ich hab das vor 
langer, langer Zeit für einen PIC24 geschrieben und dann portiert. Es 
erhebt keinen Anspruch auf Eleganz :-)

Relevant sind die RTCC.* files, in "GlobalDefinitions.h" sind nur 2 
defines und ein paar typedefs relevant.

Ich verwende immer ein Struct namens TIME für die Zeiten, die Funktionen 
bekommen einen Pointer da drauf.

initrtcc();
Das macht die RTCC an. Clock ist SOSC, ich hab einen Uhrenquarz dran.

GetTimeDate(Time *Output);
liest Zeit und Datum aus und schreibt sie in Output

SetTimeDate(Time *IN);
stellt die Zeit
Warnung:
Da ist ein while ohne Timeout drin. Das will man vielleicht nachrüsten.
Ich brauch es nicht, weil ohne funktionerende RTCC geht bei mir nichts, 
nicht mal das Display.

SetAlarm(Time *IN, uint8_t interval, uint8_t ena);
Sinnvoll für den Interrupt, man kann einen Alarm setzen. Getestet habe 
ich (mangels Geduld) nur 1s, 10s, 1min.
Das interval ist das Setting für AMASK (siehe Datenblatt PIC).
mit g_enable schaltet man den Interrupt ein, mit g_disable aus.
Auch hier, ein Timeout fehlt.

void __ISR(_RTCC_VECTOR,ipl6) _RTCCInterrupt(void)
Die ISR. Die setzt nur ein Jobflag. Alles weitere passiert in einem 
Eventhandler.

Für die Funktion kann ich nicht garantieren, es läuft aber seit >1Jahr 
in meiner Wetterstation.

[Sven der Schreckliche (Gast)]

Hallo WehOhWeh,

recht herzlichen Dank. Ich werde am WE versuchen direkt versuchen das 
auf meinen PIC zu implementieren. Sehr nett und nicht 
selbstverständlich, dass Du mir hier deinen Code zur Verfügung stellst!

[Peter D. (peda)]

Ich benutze als RTC einfach einen 1s Timerinterrupt, der eine 32Bit 
Variable hochzählt.
Damit lassen sich sehr einfach Zeiten vergleichen, z.B. für Steuerungen.
Und nur zur Anzeige für den Menschen gibt es eine Routine zur 
Umwandlung.
Bei einem 32Bitter muß man den Zugriff auf die Zeit-Variable nichtmal 
mehr atomar kapseln.

[Sven der Schreckliche (Gast)]

Ich habe doie RTC Clock (intern) jetzt implementiert. Ich bräuchte jetzt 
natürlich noch eine Pufferbatterie etc. weiß Jemand welche man dafür am 
besten beim PIC Starterkit nutzt, an welche Pins etc.?