interner RTC oder externer

#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;

}

/*********************************************************************

 * 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);

rtccRes res=RtccInit();