/home/daqweb/fgddaq/c8051/mscbutil.c File Reference

#include <intrins.h>
#include <string.h>
#include <stdio.h>
#include "mscbemb.h"

Defines
#define	DEFAULT_WATCHDOG_TIMEOUT   10
Functions
unsigned char	crc8 (unsigned char *buffer, int len) reentrant
unsigned char	crc8_add (unsigned char crc, unsigned int c)
void	uart_init (unsigned char port, unsigned char baud)
void	sysclock_reset (void)
void	sysclock_init (void)
void	led_int ()
void	tcp_timer (void)
void	watchdog_int (void)
void	led_mode (unsigned char led, unsigned char flag) reentrant
void	led_blink (unsigned char led, unsigned char n, int interval) reentrant
void	led_set (unsigned char led, unsigned char flag) reentrant
unsigned long	time (void)
unsigned long	uptime (void)
void	watchdog_refresh (unsigned char from_interrupt) reentrant
void	watchdog_enable (unsigned char timeout)
void	watchdog_disable (void)
void	delay_ms (unsigned int ms)
void	delay_us (unsigned int us)
void	eeprom_read (void *dst, unsigned char len, unsigned short *offset)
void	eeprom_write (void *src, unsigned char len, unsigned short *offset)
void	eeprom_erase (void)
void	eeprom_flash (void)
unsigned char	eeprom_retrieve (unsigned char flag)
Variables
SYS_INFO	sys_info
MSCB_INFO_VAR *	variables
unsigned char idata	_n_sub_addr
unsigned char idata	_var_size
unsigned char idata	_flkey
unsigned char code	crc8_data []
static unsigned long	_systime
static unsigned long	_uptime
static unsigned char	_uptime_cnt
struct {
unsigned char   mode
unsigned char   timer
unsigned char   interval
unsigned char   n
}	leds [N_LED]
unsigned short	watchdog_timer
unsigned char	watchdog_timeout = DEFAULT_WATCHDOG_TIMEOUT
bit	watchdog_on

---

Define Documentation

#define DEFAULT_WATCHDOG_TIMEOUT   10

---

Function Documentation

unsigned char crc8	(	unsigned char *	buffer,
		int	len
	)

         : crc8

  Purpose: Calculate 8-bit cyclic redundancy checksum for a full
           buffer

  Input:
    unsigned char *data     data buffer
    int len                 data length in bytes


  Function value:
    unsighend char          CRC-8 code

\********************************************************************/
{
   int i;
   unsigned char crc8_code, index;

   crc8_code = 0;
   for (i = 0; i < len; i++) {
      index = buffer[i] ^ crc8_code;
      crc8_code = crc8_data[index];
   }

   return crc8_code;
}

unsigned char crc8_add	(	unsigned char	crc,
		unsigned int	c
	)

         : crc8_add

  Purpose: Single calculation for 8-bit cyclic redundancy checksum

  Input:
    unsigned char crc       running crc
    unsigned char c         new character


  Function value:
    unsighend char          CRC-8 code

\********************************************************************/
{
   unsigned char index;

   index = c ^ crc;
   return crc8_data[index];
}

void delay_ms

(

unsigned int

ms

)

{
   unsigned int i;

   for (i = 0; i < ms; i++) {
      delay_us(1000);
      watchdog_refresh(1);
   }
}

void delay_us

(

unsigned int

us

)

{
#if defined(CPU_C8051F120) || defined(CPU_C8051F310) || defined(CPU_C8051F410)
   unsigned char j;
#endif

   unsigned char i;
   unsigned int remaining_us;

   if (us <= 250) {
      for (i = (unsigned char) us; i > 0; i--) {
#if defined(SCS_210)
         _nop_();
         for (j=3 ; j>0 ; j--)
            _nop_();
#elif defined(CPU_C8051F120)
         for (j=22 ; j>0 ; j--)
             _nop_();
#elif defined(CPU_C8051F310) || defined(CPU_C8051F410)
         _nop_();
         for (j=3 ; j>0 ; j--)
            _nop_();
#elif defined(CPU_C8051F320)
         _nop_();
         _nop_();
#else
         _nop_();
#endif
      }
   } else {
      remaining_us = us;
      while (remaining_us > 250) {
         delay_us(250);
         remaining_us -= 250;
      }
      if (us > 0)
         delay_us(remaining_us);
   }
}

void eeprom_erase

(

void

)

         : eeprom_erase

  Purpose: Erase parameter EEPROM page

\********************************************************************/
{
   unsigned char idata i;
   unsigned char xdata * idata p;
   unsigned int tmp;
   if (_flkey != 0xF1)
      return;

   DISABLE_INTERRUPTS;
   watchdog_disable();

#ifdef CPU_C8051F120
   SFRPAGE = LEGACY_PAGE;
#endif

//-PAA
   RSTSRC = 0x06; // Enable Missing Clock & VDDMON as reset

#if defined(CPU_C8051F000)
   FLSCL = (FLSCL & 0xF0) | 0x08;       // set timer for 11.052 MHz clock
#elif defined(CPU_C8051F020) || defined(CPU_C8051F120)
   FLSCL = FLSCL | 1;                   // enable flash writes
#endif
   PSCTL = 0x03;                        // allow write and erase

#if defined(CPU_C8051F310) || defined(CPU_C8051F320) || defined(CPU_C8051F410)
   p = EEPROM_OFFSET;
   for (i=0 ; i<N_EEPROM_PAGE ; i++) {
      FLKEY = 0xA5;                        // write flash key code
      FLKEY = _flkey;
#if defined(CPU_c8051F410)
   VDM0CN = 0xA0;
   RSTSRC = 0x02; 
#endif
   *p = 0;                              // erase page
      watchdog_refresh(1);
      p += 512;
   }
#else
   p = EEPROM_OFFSET;
   for (i=0 ; i<N_EEPROM_PAGE ; i++) {
      *p = 0; // erase page
      watchdog_refresh(1);
      p += 512;
   }
#endif

   PSCTL = 0x00;                        // don't allow write
   FLSCL = FLSCL & 0xF0;

   ENABLE_INTERRUPTS;
   watchdog_enable(0);
}

void eeprom_flash

(

void

)

         : eeprom_flash

  Purpose: Write system and user parameters to EEPROM

\********************************************************************/
{
   unsigned char i, adr;
   unsigned short magic, offset;

   eeprom_erase();

   offset = 0;

   // system info (node address etc...)
   eeprom_write(&sys_info, sizeof(SYS_INFO), &offset);

   // magic
   magic = 0x1234;
   eeprom_write(&magic, 2, &offset);

   // user channel variables
   for (adr = 0 ; adr < _n_sub_addr ; adr++)
      for (i = 0; variables[i].width; i++)
         eeprom_write((char *)variables[i].ud + _var_size*adr,
                      variables[i].width, &offset);

   // magic
   magic = 0x1234;
   eeprom_write(&magic, 2, &offset);

   _flkey = 0;
}

void eeprom_read	(	void *	dst,
		unsigned char	len,
		unsigned short *	offset
	)

         : eeprom_read

  Purpose: Read from internal EEPROM

  Input:
    unsigned char idata *dst    Destination in IDATA memory
    unsigned char len           Number of bytes to copy
    unsigend char *offset       Offset in EEPROM in bytes, gets
                                adjusted after read

\********************************************************************/
{
   unsigned char i;
   unsigned char code *p;
   unsigned char *d;

   watchdog_refresh(1);

   p = EEPROM_OFFSET + *offset;        // read from 128-byte EEPROM page
   d = dst;

   for (i = 0; i < len; i++)
      d[i] = p[i];

   *offset += len;
}

unsigned char eeprom_retrieve

(

unsigned char

flag

)

         : eeprom_retrieve

  Purpose: Retrieve system and user parameters from EEPROM

\********************************************************************/
{
   unsigned char i, adr, status;
   unsigned short magic, offset;

   offset = 0;
   status = 0;

   // system info (node address etc...)
   eeprom_read(&sys_info, sizeof(SYS_INFO), &offset);

   // check for first magic
   eeprom_read(&magic, 2, &offset);
   if (magic == 0x1234)
      status |= (1 << 0);

   // user channel variables
   if (flag) {
      for (adr = 0 ; adr < _n_sub_addr ; adr++)
         for (i = 0; variables[i].width; i++)
            eeprom_read((char *)variables[i].ud + _var_size*adr,
                        variables[i].width, &offset);
   
      // check for second magic
      eeprom_read(&magic, 2, &offset);
      if (magic == 0x1234)
         status |= (1 << 1);
   } else
      status |= (1 << 1);

   return status;
}

void eeprom_write	(	void *	src,
		unsigned char	len,
		unsigned short *	offset
	)

         : eeprom_write

  Purpose: Read from internal EEPROM

  Input:
    unsigned char idata *src    Source in IDATA memory
    unsigned char len           Number of bytes to copy
    unsigend char offset        Offset in EEPROM in bytes, gets
                                adjusted after write

\********************************************************************/
{
   unsigned char xdata * idata p;      // xdata pointer causes MOVX command
   unsigned char idata i, b;
   unsigned char * idata s;

   if (_flkey != 0xF1)
      return;

   watchdog_disable();
   DISABLE_INTERRUPTS;

#ifdef CPU_C8051F120
   SFRPAGE = LEGACY_PAGE;
#endif

//-PAA
   RSTSRC = 0x06; // Enable Missing Clock & VDDMON as reset

#if defined(CPU_C8051F000)
   FLSCL = (FLSCL & 0xF0) | 0x08;  // set timer for 11.052 MHz clock
#elif defined(CPU_C8051F020) || defined(CPU_C8051F120)
   FLSCL = FLSCL | 1;           // enable flash writes
#endif
   PSCTL = 0x01;                // allow write

   p = EEPROM_OFFSET + *offset;
   s = src;

   for (i = 0; i < len; i++) {  // write data
      b = *s++;

#if defined(CPU_C8051F310) || defined(CPU_C8051F320) || defined(CPU_C8051F410)
      FLKEY = 0xA5;             // write flash key code
      FLKEY = _flkey;
#endif

#if defined(CPU_c8051F410)
   VDM0CN = 0xA0;
   RSTSRC = 0x02; 
#endif
      *p++ = b;
   }

   PSCTL = 0x00;                // don't allow write
   FLSCL = FLSCL & 0xF0;

   *offset += len;

   ENABLE_INTERRUPTS;
   watchdog_enable(0);
}

void led_blink	(	unsigned char	led,
		unsigned char	n,
		int	interval
	)

         : blink led

  Purpose: Blink primary or secondary LED for a couple of times

  Input:
    int led               0 for primary, 1 for secondary, ...
    int interval          Blink interval in ms
    int n                 Number of blinks

\********************************************************************/
{
   if (led < N_LED) {
      if (leds[led].n == 0 && leds[led].timer == 0) {
         leds[led].n = n*2+1;
         leds[led].interval = interval / 10;
         leds[led].timer = 0;
      }
   }
}

void led_int

(

)

{
unsigned char led_i;

   /* manage blinking LEDs */
   for (led_i=0 ; led_i<N_LED ; led_i++) {
      if (leds[led_i].n > 0 && leds[led_i].timer == 0) {
         if ((leds[led_i].n & 1) && leds[led_i].n > 1)
            led_set(led_i, LED_ON);
         else
            led_set(led_i, LED_OFF);

         leds[led_i].n--;
         if (leds[led_i].n)
            leds[led_i].timer = leds[led_i].interval;
      }

      if (leds[led_i].timer)
         leds[led_i].timer--;

      if (leds[led_i].n == 0)
         led_set(led_i, LED_OFF);
   }
}

void led_mode	(	unsigned char	led,
		unsigned char	flag
	)

         : led_mode

  Purpose: Set LED mode

  Input:
    int led               0 for primary, 1 for secondary
    int flag              Noninverted (0) / Inverted (1)

\********************************************************************/
{
   if (led < N_LED)
      leds[led].mode = flag;
}

void led_set	(	unsigned char	led,
		unsigned char	flag
	)

{
   /* invert on/off if mode == 1 */
   if (led < N_LED && leds[led].mode)
      flag = !flag;

#ifdef LED_0
   if (led == 0)
      led_0 = flag;
#endif
#ifdef LED_1
   if (led == 1)
      led_1 = flag;
#endif
#ifdef LED_2
   if (led == 2)
      led_2 = flag;
#endif
#ifdef LED_3
   if (led == 3)
      led_3 = flag;
#endif
#ifdef LED_4
   if (led == 4)
      led_4 = flag;
#endif
#ifdef LED_5
   if (led == 5)
      led_5 = flag;
#endif
#ifdef LED_6
   if (led == 6)
      led_6 = flag;
#endif
#ifdef LED_7
   if (led == 7)
      led_7 = flag;
#endif
#ifdef LED_8
   if (led == 8)
      led_8 = flag;
#endif
#ifdef LED_9
   if (led == 9)
      led_9 = flag;
#endif
}

void sysclock_init

(

void

)

         : sysclock_init

  Purpose: Initial sytem clock via timer 0

*********************************************************************/
{
   EA = 1;                      // general interrupt enable
   ET0 = 1;                     // Enable Timer 0 interrupt
   PT1 = 0;                     // Interrupt priority low

#ifdef CPU_C8051F120
   SFRPAGE = TIMER01_PAGE;
#endif

   TMOD = (TMOD & 0x0F) | 0x01; // 16-bit counter
#if defined(SCS_210)
   CKCON = 0x02;                // use SYSCLK/48
   TH0 = 0xEC;                  // load initial value (24.5 MHz SYSCLK)
#elif defined(CPU_C8051F120)
   CKCON = 0x02;                // use SYSCLK/48 (98 MHz SYSCLK)
   TH0 = 0xAF;                  // load initial value
#elif defined(CPU_C8051F310) || defined(CPU_C8051F410)
   CKCON = 0x00;                // use SYSCLK/12
   TH0 = 0xAF;                  // load initial value (24.5 MHz SYSCLK)
#else
   CKCON = 0x00;                // use SYSCLK/12
   TH0 = 0xDB;                  // load initial value
#endif

   TL0 = 0x00;
   TR0 = 1;                     // start timer 0

   sysclock_reset();
}

void sysclock_reset

(

void

)

         : sysclock_reset

  Purpose: Reset system clock and uptime counter

*********************************************************************/
{
   unsigned char i;

   _systime = 0;
   _uptime = 0;
   _uptime_cnt = 100;

   for (i=0 ; i<N_LED ; i++) {
     leds[i].mode = 0;
     leds[i].timer = 0;
     leds[i].interval = 0;
     leds[i].n = 0;
   }
}

void tcp_timer

(

void

)

unsigned long time

(

void

)

         : time

  Purpose: Return system time in units of 10ms

\********************************************************************/
{
   unsigned long t;

   DISABLE_INTERRUPTS;
   t = _systime;
   ENABLE_INTERRUPTS;
   return t;
}

void uart_init	(	unsigned char	port,
		unsigned char	baud
	)

         : uart_init

  Purpose: Initialize serial interface, user Timer 1 for UART0 and
           (optionally) Timer 2 (4 for F020) for UART1

  Input:
    unsigned char baud
      1:    2400
      2:    4800
      3:    9600
      4:   19200
      5:   28800
      6:   38400
      7:   57600
      8:  115200
      9:  172800
     10:  345600

\********************************************************************/
{
#if defined (CPU_C8051F310) || defined(CPU_C8051F410)          // 24.5 MHz
   unsigned char code baud_table[] =
     {0x100 - 0,    //  N/A
      0x100 - 0,    //  N/A
      0x100 - 0,    //  N/A
      0x100 - 0,    //  N/A
      0x100 - 0,    //  N/A
      0x100 - 0,    //  N/A
      0x100 - 213,  //  57600
      0x100 - 106,  // 115200
      0x100 - 71,   // 172800
      0x100 - 35 }; // 345600
#elif defined(CPU_C8051F320)          // 12 MHz
   unsigned char code baud_table[] =
     {0x100 - 0,    //  N/A
      0x100 - 0,    //  N/A
      0x100 - 0,    //  N/A
      0x100 - 0,    //  N/A
      0x100 - 208,  //  28800
      0x100 - 156,  //  38400
      0x100 - 104,  //  57600
      0x100 - 52,   // 115200
      0x100 - 35,   // 172800  2% error
      0x100 - 17 }; // 345600  2% error
#elif defined(SCS_210)                // 24.5 MHz
   unsigned char code baud_table[] =  // UART0 via timer 2
     {0x100 - 0,    //  N/A
      0x100 - 0,    //  N/A
      0x100 - 160,  //   9600  0.3% error
      0x100 - 80,   //  19200  0.3% error
      0x100 - 53,   //  28800  0.3% error
      0x100 - 40,   //  38400  0.3% error
      0x100 - 27,   //  57600  1.5% error
      0x100 - 13,   // 115200  2.2% error
      0x100 - 9,    // 172800  1.5% error
      0x100 - 0 };  // N/A
   unsigned char code baud_table1[] = // UART1 via timer 1
     {0x100 - 106,  //   2400  0.3% error
      0x100 - 53,   //   4800  0.3% error
      0x100 - 27,   //   9600  1.5% error
      0x100 - 13,   //  19200  2.2% error
      0x100 - 9,    //  28800  1.5% error
      0x100 - 7,    //  38400  5.1% error
      0x100 - 0,    //  N/A
      0x100 - 0,    //  N/A
      0x100 - 0,    //  N/A
      0x100 - 0};   //  N/A
#elif defined(SUBM_260)                // 49 MHz
   unsigned char code baud_table[] =  // UART0 via timer 2
     {0xFB, 0x100 - 252,  //   2400
      0xFD, 0x100 - 126,  //   4800
      0xFE, 0x100 - 63,   //   9600
      0xFF, 0x100 - 160,  //  19200  0.3% error
      0xFF, 0x100 - 106,  //  28800  0.3% error
      0xFF, 0x100 - 80,   //  38400  0.3% error
      0xFF, 0x100 - 53,   //  57600  0.3% error
      0xFF, 0x100 - 27,   // 115200  1.5% error
      0xFF, 0x100 - 18,   // 172800  1.5% error
      0xFF, 0x100 - 9 };  // 345600  1.5% error
#elif defined(CPU_C8051F120)          // 98 MHz
   unsigned char code baud_table[] =  // UART0 via timer 2
     {0x100 - 0,    //  N/A
      0x100 - 0,    //  N/A
      0x100 - 0,    //  N/A
      0x100 - 0,    //  N/A
      0x100 - 213,  //  28800  0.2% error
      0x100 - 160,  //  38400  0.3% error
      0x100 - 106,  //  57600  0.3% error
      0x100 - 53,   // 115200  0.3% error
      0x100 - 35,   // 172800  1.3% error
      0x100 - 18 }; // 345600  1.6% error
#if defined(UART1_MSCB) || defined(UART1_DEVICE)
   unsigned char code baud_table1[] = // UART1 via timer 1
     {0x100 - 0,    //  N/A
      0x100 - 212,  //   4800  0.3% error
      0x100 - 106,  //   9600  0.3% error
      0x100 - 53,   //  19200  0.3% error
      0x100 - 35,   //  28800  1.3% error
      0x100 - 27,   //  38400  1.6% error
      0x100 - 18,   //  57600  1.6% error
      0x100 - 9,    // 115200  1.6% error
      0x100 - 6,    // 172800  1.6% error
      0x100 - 3 };  // 345600  1.6% error
#endif
#else                                 // 11.0592 MHz
   unsigned char code baud_table[] =
     {0x100 - 144,  //   2400
      0x100 - 72,   //   4800
      0x100 - 36,   //   9600
      0x100 - 18,   //  19200
      0x100 - 12,   //  28800
      0x100 - 9,    //  38400
      0x100 - 6,    //  57600
      0x100 - 3,    // 115200
      0x100 - 2,    // 172800
      0x100 - 1 };  // 345600
#endif

   if (port == 0) { /*---- UART0 ----*/

#ifdef CPU_C8051F120
      SFRPAGE = UART0_PAGE;
#endif

      SCON0 = 0xD0;                // Mode 3, 9 bit, receive enable

#ifdef CPU_C8051F120

      SFRPAGE = UART0_PAGE;
      SSTA0 = 0x15;                // User Timer 2 for baud rate, div2 disabled

      SFRPAGE = TMR2_PAGE;
      TMR2CF = 0x08;               // use system clock for timer 2
#ifdef SUBM_260
      RCAP2H = baud_table[(baud - 1)*2];    // load high byte
      RCAP2L = baud_table[(baud - 1)*2+1];  // load low byte
#else
      RCAP2H = 0xFF;
      RCAP2L = baud_table[baud - 1];
#endif
      TMR2CN = 0x04;               // start timer 2
      SFRPAGE = UART0_PAGE;

#else // CPU_C8051F120

      TMOD  = (TMOD & 0x0F)| 0x20; // Timer 1 8-bit counter with auto reload

#if defined(CPU_C8051F310) || defined(CPU_C8051F320) || defined(CPU_C8051F410)
      CKCON |= 0x08;               // use system clock
#else
      T2CON &= ~30;                // User Timer 1 for baud rate
      CKCON |= 0x10;               // use system clock
#endif

      TH1 = baud_table[baud - 1];  // load initial values
      TR1 = 1;                     // start timer 1

#endif // CPU_C8051F120

      ES0 = 1;                     // enable serial interrupt
      PS0 = 0;                     // serial interrupt low priority


#if defined(UART1_MSCB) || defined(UART1_DEVICE)

   } else { /*---- UART1 ----*/

#if defined(CPU_C8051F020)
      SCON1 = 0x50;                // Mode 1, 8 bit, receive enable

      T4CON = 0x34;                // timer 4 RX+TX mode
      RCAP4H = 0xFF;
      RCAP4L = baud_table[baud - 1];

      EIE2 |= 0x40;                // enable serial interrupt
      EIP2 &= ~0x40;               // serial interrupt low priority


#elif defined(SCS_210)             // 24.5 MHz
      SFRPAGE = UART1_PAGE;
      SCON1 = 0x50;                // Mode 1, 8 bit, receive enable

      SFRPAGE = TIMER01_PAGE;
      TMOD  = (TMOD & 0x0F)| 0x20; // Timer 1 8-bit counter with auto reload
      CKCON = 0x02;                // use SYSCLK/48 (needed by timer 0)

      TH1 = baud_table1[baud - 1];
      TR1 = 1;                     // start timer 1

      EIE2 |= 0x40;                // enable serial interrupt
      EIP2 &= ~0x40;               // serial interrupt low priority
#elif defined(CPU_C8051F120)       // 98 MHz
      SFRPAGE = UART1_PAGE;
#ifdef UART1_MSCB
      SCON1 = 0xD0;                // Mode 3, 9 bit, receive enable
#else
      SCON1 = 0x50;                // Mode 1, 8 bit, receive enable
#endif

      SFRPAGE = TIMER01_PAGE;
      TMOD  = (TMOD & 0x0F)| 0x20; // Timer 1 8-bit counter with auto reload
      CKCON = 0x02;                // use SYSCLK/48 (needed by timer 0)

      TH1 = baud_table1[baud - 1];
      TR1 = 1;                     // start timer 1

      EIE2 |= 0x40;                // enable serial interrupt
      EIP2 |= 0x40;                // serial interrupt high priority, needed in order not
                                   // to loose data during UART0 communication
#endif

      uart1_init_buffer();
#endif // defined(UART1_MSCB) || defined(UART1_DEVICE)
   }

   EA = 1;                         // general interrupt enable
}

unsigned long uptime

(

void

)

         : uptime

  Purpose: Return system uptime in seconds

\********************************************************************/
{
   unsigned long t;

   DISABLE_INTERRUPTS;
   t = _uptime;
   ENABLE_INTERRUPTS;
   return t;
}

void watchdog_disable

(

void

)

         : watchdog_disable

  Purpose: Disables watchdog

\********************************************************************/
{
#ifdef USE_WATCHDOG
   watchdog_on = 0;
   watchdog_timer = 0;
#endif

#if defined(CPU_C8051F310) || defined(CPU_C8051F320) || defined(CPU_C8051F410)
   PCA0MD = 0x00;
#else
   WDTCN  = 0xDE;
   WDTCN  = 0xAD;
#endif
}

void watchdog_enable

(

unsigned char

timeout

)

         : watchdog_enable

  Purpose: Enables watchdog

  Input:
    unsigned char timeout    Watchdog timeout in seconds

\********************************************************************/
{
   if (timeout);
#ifdef USE_WATCHDOG

   watchdog_on = 1;
   watchdog_timer = 0;
   if (timeout)
      watchdog_timeout = timeout;
   else
      watchdog_timeout = DEFAULT_WATCHDOG_TIMEOUT;

#ifndef EXT_WATCHDOG
#if defined(CPU_C8051F310) || defined(CPU_C8051F320) || defined(CPU_C8051F410)
#if defined(CPU_C8051F410)
   PCA0MD   = 0x00;             // disable watchdog
   PCA0CPL5 = 255;              // 65.5 msec @ 12 MHz
   PCA0MD   = 0x40;             // enable watchdog
   PCA0CPH5 = 0x00;             // reset watchdog

   RSTSRC   = 0x06;             // enable missing clock detector and 
#else                                // VDD monitor as reset source
   PCA0MD   = 0x00;             // disable watchdog
   PCA0CPL4 = 255;              // 65.5 msec @ 12 MHz
   PCA0MD   = 0x40;             // enable watchdog
   PCA0CPH4 = 0x00;             // reset watchdog

   RSTSRC   = 0x06;             // enable missing clock detector and 
                                // VDD monitor as reset source
#endif
#else /* CPU_C8051F310 */

   WDTCN    = 0x07;             // 95 msec (11.052 MHz) / 21msec (49 MHz)
   WDTCN    = 0xA5;             // start watchdog

#if defined(CPU_C8051F120)
   SFRPAGE = LEGACY_PAGE;
   RSTSRC  = 0x06;              // enable missing clock detector & VDDMON
#else
   OSCICN |= 0x80;              // enable missing clock detector
   RSTSRC  = 0x0B;              // enable reset pin and watchdog reset & VDDMON
#endif

#endif /* not CPU_C8051F310 */
#endif /* not EXT_WATCHDOG */
#endif /* USE_WATCHDOG */
}

void watchdog_int

(

void

)

         : timer0_int

  Purpose: Timer 0 interrupt routine for 100Hz system clock

           Reload value = 0x10000 - 0.01 / (11059200/12)

\********************************************************************/
{
#ifdef SUBM_260
   tcp_timer();
#else /* SUBM_260 */

#if defined(SCS_210)
   TH0 = 0xEC;                  // for 24.5 MHz clock / 48
#elif defined(CPU_C8051F120)
   TH0 = 0xAF;                  // for 98 MHz clock   / 48
#elif defined(CPU_C8051F310) || defined(CPU_C8051F410)
   TH0 = 0xAF;                  // for 24.5 MHz clock / 12 
#else
   TH0 = 0xDC;                  // reload timer values, let LSB freely run
#endif

#endif /* !SUBM_260 */
   _systime++;                  // increment system time
   _uptime_cnt--;
   if (_uptime_cnt == 0) {      // once every second
      _uptime++;
      _uptime_cnt = 100;
   }
   
   led_int();
   watchdog_int();
}

void watchdog_refresh

(

unsigned char

from_interrupt

)

         : watchdog_refresh

  Purpose: Resets watchdog, has to be called regularly, otherwise
           the watchdog issues a reset. If called from an interrupt
           routine, just reset the hardware watchdog, but not the
           watchdog timer. Reset the watchdog timer only when called
           from the user loop, to ensure that the main user loop
           is running.

  Input:
    unsigned char from_interrupt  0 if called from normal user loop,
                                  1 if called from interrupt routine


\********************************************************************/
{
   if (from_interrupt);

#ifdef USE_WATCHDOG
   if (from_interrupt == 0)
      watchdog_timer = 0;

   if (watchdog_on && watchdog_timer < watchdog_timeout*100) {

#ifdef EXT_WATCHDOG
      EXT_WATCHDOG_PIN = !EXT_WATCHDOG_PIN;
#else
#if defined(CPU_C8051F310) || defined(CPU_C8051F320) || defined(CPU_C8051F410)
#if defined(CPU_C8051F410)
      PCA0CPH5 = 0x00;
#else
      PCA0CPH4 = 0x00;
#endif
#else
      WDTCN = 0xA5;
#endif
#endif // EXT_WATCHDOG

   }
   
#endif
}

---

Variable Documentation

unsigned char idata _flkey

unsigned char idata _n_sub_addr

unsigned long _systime [static]

unsigned long _uptime [static]

unsigned char _uptime_cnt [static]

unsigned char idata _var_size

unsigned char code crc8_data[]

unsigned char interval

struct { ... } leds[N_LED]

unsigned char mode

unsigned char n

SYS_INFO sys_info

unsigned char timer

MSCB_INFO_VAR* variables

bit watchdog_on

unsigned char watchdog_timeout = DEFAULT_WATCHDOG_TIMEOUT

unsigned short watchdog_timer

---