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

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

Defines
#define	GET_INFO_GENERAL   0
#define	GET_INFO_VARIABLE   1
#define	SIZE_8BIT   1
#define	SIZE_16BIT   2
#define	SIZE_24BIT   3
#define	SIZE_32BIT   4
#define	ADDR_NONE   0
#define	ADDR_NODE   1
#define	ADDR_GROUP   2
#define	ADDR_ALL   3
#define	SEND_BYTE(_b)
Functions
void	user_init (unsigned char init)
void	user_write (unsigned char index) reentrant
unsigned char	user_read (unsigned char index)
void	user_loop (void)
void	flash_upgrade (void)
void	send_remote_var (unsigned char i)
void	setup (void)
unsigned char	cur_sub_addr ()
void	interprete (void)
void	serial_int (void)
static void	send_byte (unsigned char d, unsigned char *crc)
static void	send_obuf (unsigned char n)
void	addr_node8 (unsigned char mode, unsigned char adr, unsigned char node_addr)
void	addr_node16 (unsigned char mode, unsigned int adr, unsigned int node_addr)
void	upgrade ()
void	yield (void)
void	main (void)
Variables
MSCB_INFO_VAR *	variables
unsigned char idata	_n_sub_addr
char code	node_name []
char code	svn_rev_main [] = "$Rev: 911 $"
bit	lcd_present
unsigned char idata	in_buf [20]
unsigned char idata	out_buf [8]
unsigned char idata	i_in
unsigned char idata	last_i_in
unsigned char idata	final_i_in
unsigned char idata	i_out
unsigned char idata	cmd_len
unsigned char idata	crc_code
unsigned char idata	addr_mode
unsigned char idata	n_variables
unsigned char idata _flkey _at_	x80
unsigned char idata n_out _at_	x81
unsigned char idata	_cur_sub_addr
unsigned char idata	_var_size
SYS_INFO	sys_info
unsigned char bdata	CSR
sbit	DEBUG_MODE = CSR ^ 0
sbit	SYNC_MODE = CSR ^ 1
sbit	FREEZE_MODE = CSR ^ 2
sbit	WD_RESET = CSR ^ 3
bit	addressed
bit	flash_param
bit	flash_program
bit	configured_addr
bit	configured_vars
bit	flash_allowed
bit	wrong_cpu

---

Define Documentation

#define ADDR_ALL   3

#define ADDR_GROUP   2

#define ADDR_NODE   1

#define ADDR_NONE   0

#define GET_INFO_GENERAL   0

#define GET_INFO_VARIABLE   1

#define SEND_BYTE

(

_b

)

Value:

TI0 = 0; \
   DELAY_US(INTERCHAR_DELAY); \
   SBUF0 = _b; \
   while (TI0 == 0);

#define SIZE_16BIT   2

#define SIZE_24BIT   3

#define SIZE_32BIT   4

#define SIZE_8BIT   1

---

Function Documentation

void addr_node16	(	unsigned char	mode,
		unsigned int	adr,
		unsigned int	node_addr
	)

{
   if (node_addr == 0xFFFF) {
      if (adr == node_addr) {
         addressed = 1;
         _cur_sub_addr = 0;
         addr_mode = mode;
      } else {
         addressed = 0;
         addr_mode = ADDR_NONE;
      }
   } else {
      if (mode == ADDR_NODE) {
         if (adr >= node_addr &&
             adr <  node_addr + _n_sub_addr) {
   
            addressed = 1;
            _cur_sub_addr = adr - node_addr;
            addr_mode = ADDR_NODE;
         } else {
            addressed = 0;
            addr_mode = ADDR_NONE;
         }
      } else if (mode == ADDR_GROUP) {
         if (adr == node_addr) {
            addressed = 1;
            _cur_sub_addr = 0;
            addr_mode = ADDR_GROUP;
         } else {
            addressed = 0;
            addr_mode = ADDR_NONE;
         }
      }
   }
}

void addr_node8	(	unsigned char	mode,
		unsigned char	adr,
		unsigned char	node_addr
	)

{
   if (mode == ADDR_NODE) {
      if (adr >= node_addr &&
          adr <  node_addr + _n_sub_addr) {

         addressed = 1;
         _cur_sub_addr = adr - node_addr;
         addr_mode = ADDR_NODE;
      } else {
         addressed = 0;
         addr_mode = ADDR_NONE;
      }
   } else if (mode == ADDR_GROUP) {
      if (adr == node_addr) {
         addressed = 1;
         _cur_sub_addr = 0;
         addr_mode = ADDR_GROUP;
      } else {
         addressed = 0;
         addr_mode = ADDR_NONE;
      }
   }
}

unsigned char cur_sub_addr

(

void

)

{
   return _cur_sub_addr;
}

void flash_upgrade

(

void

)

void interprete

(

void

)

{
   unsigned char crc, cmd, i, j, n, ch, a1, a2;
   unsigned short size;
   MSCB_INFO_VAR *pvar;
   unsigned long idata u;

   cmd = (in_buf[0] & 0xF8);    // strip length field

#ifdef CPU_C8051F120
   SFRPAGE = UART0_PAGE;        // needed for SBUF0
#endif

   switch (in_buf[0]) {
   case CMD_ADDR_NODE8:
      addr_node8(ADDR_NODE, in_buf[1], sys_info.node_addr & 0xFF);
      break;

   case CMD_ADDR_NODE16:
      addr_node16(ADDR_NODE, *(unsigned int *) &in_buf[1], sys_info.node_addr);
      break;

   case CMD_ADDR_BC:
      addressed = 1;
      addr_mode = ADDR_ALL;
      break;

   case CMD_ADDR_GRP8:
      addr_node8(ADDR_GROUP, in_buf[1], sys_info.group_addr & 0xFF);
      break;

   case CMD_ADDR_GRP16:
      addr_node16(ADDR_GROUP, *(unsigned int *) &in_buf[1], sys_info.group_addr);
      break;

   case CMD_PING8:
      addr_node8(ADDR_NODE, in_buf[1], sys_info.node_addr & 0xFF);
      if (addressed) {
         out_buf[0] = CMD_ACK;
         send_obuf(1);
      }
      break;

   case CMD_PING16:
      addr_node16(ADDR_NODE, *(unsigned int *) &in_buf[1], sys_info.node_addr);
      if (addressed) {
         out_buf[0] = CMD_ACK;
         send_obuf(1);
      }
      break;

   case CMD_INIT:
#ifdef CPU_C8051F120
      SFRPAGE = LEGACY_PAGE;
#endif

      RSTSRC = 0x12;         // force software and VDDmon as reset src
      break;

   case CMD_GET_INFO:
      /* general info */

      ES0 = 0;                  // temporarily disable serial interrupt
      crc = 0;
      RS485_ENABLE = 1;

      send_byte(CMD_ACK + 7, &crc);      // send acknowledge, variable data length
#ifdef HAVE_RTC
      send_byte(30, &crc);               // send data length
#else
      send_byte(24, &crc);               // send data length
#endif
      send_byte(PROTOCOL_VERSION, &crc); // send protocol version

      send_byte(n_variables, &crc);      // send number of variables

      send_byte(*(((unsigned char *) &sys_info.node_addr) + 0), &crc);  // send node address
      send_byte(*(((unsigned char *) &sys_info.node_addr) + 1), &crc);

      send_byte(*(((unsigned char *) &sys_info.group_addr) + 0), &crc); // send group address
      send_byte(*(((unsigned char *) &sys_info.group_addr) + 1), &crc);

      send_byte(*(((unsigned char *) &sys_info.svn_revision) + 0), &crc);   // send svn revision
      send_byte(*(((unsigned char *) &sys_info.svn_revision) + 1), &crc);

      for (i = 0; i < 16; i++)  // send node name
         send_byte(sys_info.node_name[i], &crc);

#ifdef HAVE_RTC
      for (i = 0; i < 6 ; i++)
         send_byte(rtc_bread[i], &crc);
#endif

      send_byte(crc, NULL);     // send CRC code

      DELAY_US(10);
      RS485_ENABLE = 0;
      ES0 = 1;                  // re-enable serial interrupts
      break;

   case CMD_GET_INFO + 1:
      /* send variable info */

      if (in_buf[1] < n_variables) {
         pvar = variables + in_buf[1];
                                  
         ES0 = 0;                       // temporarily disable serial interrupt
         crc = 0;
         RS485_ENABLE = 1;

         send_byte(CMD_ACK + 7, &crc);  // send acknowledge, variable data length
         send_byte(13, &crc);           // send data length
         send_byte(pvar->width, &crc);
         send_byte(pvar->unit, &crc);
         send_byte(pvar->prefix, &crc);
         send_byte(pvar->status, &crc);
         send_byte(pvar->flags, &crc);

         for (i = 0; i < 8; i++)        // send variable name
            send_byte(pvar->name[i], &crc);

         send_byte(crc, NULL);          // send CRC code

         DELAY_US(10);
         RS485_ENABLE = 0;
         ES0 = 1;                       // re-enable serial interrupts
      } else {
         /* just send dummy ack */
         out_buf[0] = CMD_ACK;
         out_buf[1] = 0;
         send_obuf(2);
      }

      break;

   case CMD_GET_UPTIME:
      /* send uptime */

      u = uptime();

      out_buf[0] = CMD_ACK + 4;
      out_buf[1] = *(((unsigned char *)&u) + 0);
      out_buf[2] = *(((unsigned char *)&u) + 1);
      out_buf[3] = *(((unsigned char *)&u) + 2);
      out_buf[4] = *(((unsigned char *)&u) + 3);
      out_buf[5] = crc8(out_buf, 5);
      send_obuf(6);
      break;

   case CMD_SET_ADDR:

      if (in_buf[1] == ADDR_SET_NODE) 
         /* complete node address */
         sys_info.node_addr = *((unsigned int *) (in_buf + 2));
      else if (in_buf[1] == ADDR_SET_HIGH)
         /* only high byte node address */
         *((unsigned char *)(&sys_info.node_addr)) = *((unsigned char *) (in_buf + 2));
      else if (in_buf[1] == ADDR_SET_GROUP)
         /* group address */
         sys_info.group_addr = *((unsigned int *) (in_buf + 2));

      /* copy address to EEPROM */
      flash_param = 1;
      _flkey = 0xF1;

      break;

   case CMD_SET_NAME:
      /* set node name in RAM */
      for (i = 0; i < 16 && i < in_buf[1]; i++)
         sys_info.node_name[i] = in_buf[2 + i];
      sys_info.node_name[15] = 0;

      /* copy address to EEPROM */
      flash_param = 1;
      _flkey = 0xF1;

      break;

   case CMD_SET_BAUD:
      led_blink(_cur_sub_addr, 1, 50);
      uart_init(0, in_buf[1]);
      break;

   case CMD_FREEZE:
      FREEZE_MODE = in_buf[1];
      break;

   case CMD_SYNC:
      SYNC_MODE = in_buf[1];
      break;

   case CMD_SET_TIME:
#ifdef HAVE_RTC
      led_blink(0, 1, 50);
      for (i=0 ; i<6 ; i++)
         rtc_bwrite[i] = in_buf[i+1];
      rtc_set = 1;
#endif
      break;

   case CMD_UPGRADE:
      if (_cur_sub_addr != 0)
         n = 2; // reject upgrade for sub address
      else if (flash_allowed == 0)
         n = 3; // upgrade not yet allowed
      else
         n = 1; // positive acknowledge

      out_buf[0] = CMD_ACK + 1;
      out_buf[1] = n;
      out_buf[2] = crc8(out_buf, 2);
      send_obuf(3);

      if (n == 1) {
         flash_program = 1;
         _flkey = 0xF1;
      }
      break;

   case CMD_FLASH:
      flash_param = 1;
      _flkey = 0xF1;
      break;

   case CMD_ECHO:
      led_blink(0, 1, 50);
      out_buf[0] = CMD_ACK + 1;
      out_buf[1] = in_buf[1];
      out_buf[2] = crc8(out_buf, 2);
      send_obuf(3);
      break;

   }

   if (cmd == CMD_READ) {
      if (in_buf[0] == CMD_READ + 1) {  // single variable
         if (in_buf[1] < n_variables) {
            n = variables[in_buf[1]].width;     // number of bytes to return

            if (variables[in_buf[1]].flags & MSCBF_DATALESS) {
               n = user_read(in_buf[1]);        // for dataless variables, user routine returns bytes
               out_buf[0] = CMD_ACK + 7;        // and places data directly in out_buf
               out_buf[1] = n;

               out_buf[2 + n] = crc8(out_buf, 2 + n);      // generate CRC code
   
               /* send result */
               send_obuf(3 + n);

            } else {

               user_read(in_buf[1]);

               ES0 = 0;            // temporarily disable serial interrupt
               crc = 0;
               RS485_ENABLE = 1;
   
               if (n > 6) {
                  /* variable length buffer */
                  send_byte(CMD_ACK + 7, &crc);       // send acknowledge, variable data length
                  send_byte(n, &crc);                 // send data length

                  for (i = 0; i < n; i++)             // copy user data
                     send_byte(((char *) variables[in_buf[1]].ud)[i+_var_size*_cur_sub_addr], &crc);
                  n++;
               } else {

                  send_byte(CMD_ACK + n, &crc);       // send acknowledge
               
                  for (i = 0; i < n; i++)             // copy user data
                     send_byte(((char *) variables[in_buf[1]].ud)[i+_var_size*_cur_sub_addr], &crc);
               }

               send_byte(crc, NULL);                  // send CRC code
   
               DELAY_US(10);
               RS485_ENABLE = 0;
               ES0 = 1;            // re-enable serial interrupts
            }
         } else {
            /* just send dummy ack to indicate error */
            out_buf[0] = CMD_ACK;
            send_obuf(1);
         }  

      } else if (in_buf[0] == CMD_READ + 2) {   // variable range

        if (in_buf[1] < n_variables && in_buf[2] < n_variables && in_buf[1] <= in_buf[2]) {
            /* calculate number of bytes to return */
            for (i = in_buf[1], size = 0; i <= in_buf[2]; i++) {
               user_read(i);
               size += variables[i].width;
            }

            ES0 = 0;            // temporarily disable serial interrupt
            crc = 0;
            RS485_ENABLE = 1;

            send_byte(CMD_ACK + 7, &crc);            // send acknowledge, variable data length
            if (size < 0x80)
               send_byte(size, &crc);                // send data length one byte
            else {
               send_byte(0x80 | size / 0x100, &crc); // send data length two bytes
               send_byte(size & 0xFF, &crc);
            }

            /* loop over all variables */
            for (i = in_buf[1]; i <= in_buf[2]; i++) {
               for (j = 0; j < variables[i].width; j++)    // send user data
                  send_byte(((char *) variables[i].ud)[j+_var_size*_cur_sub_addr], &crc); 
            }

            send_byte(crc, NULL);       // send CRC code

            DELAY_US(10);
            RS485_ENABLE = 0;
            ES0 = 1;            // re-enable serial interrupts
         } else {
            /* just send dummy ack to indicate error */
            out_buf[0] = CMD_ACK;
            send_obuf(1);
         }
      }
   }

   if (cmd == CMD_USER) {
      led_blink(_cur_sub_addr, 1, 50);
      n = user_func(in_buf + 1, out_buf + 1);
      out_buf[0] = CMD_ACK + n;
      out_buf[n + 1] = crc8(out_buf, n + 1);
      send_obuf(n+2);
   }

   if (cmd == CMD_WRITE_NA || cmd == CMD_WRITE_ACK) {

      /* blink LED once when writing data */
      if (addr_mode == ADDR_NODE)
         led_blink(_cur_sub_addr, 1, 50);
      else 
         for (i=0 ; i<_n_sub_addr ; i++)
            led_blink(i, 1, 50);

      n = in_buf[0] & 0x07;

      if (n == 0x07) {  // variable length
         j = 1;
         n = in_buf[1];
         ch = in_buf[2];
      } else {
         j = 0;
         ch = in_buf[1];
      }

      n--; // data size (minus channel)

      if (ch < n_variables) {
   
         /* don't exceed variable width */
         if (n > variables[ch].width)
            n = variables[ch].width;

         if (addr_mode == ADDR_NODE)
            a1 = a2 = _cur_sub_addr;
         else {
            a1 = 0;
            a2 = _n_sub_addr-1;
         }
            
         for (_cur_sub_addr = a1 ; _cur_sub_addr <= a2 ; _cur_sub_addr++) {
            for (i = 0; i < n; i++)
               if (!(variables[ch].flags & MSCBF_DATALESS)) {
                  if (variables[ch].unit == UNIT_STRING) {
                     if (n > 4)
                        /* copy bytes in normal order */
                        ((char *) variables[ch].ud)[i + _var_size*_cur_sub_addr] = 
                           in_buf[2 + j + i];
                     else
                        /* copy bytes in reverse order (got swapped on host) */
                        ((char *) variables[ch].ud)[i + _var_size*_cur_sub_addr] = 
                           in_buf[i_in - 2 - i];
                  } else
                     /* copy LSB bytes, needed for BYTE if DWORD is sent */
                     ((char *) variables[ch].ud)[i + _var_size*_cur_sub_addr] = 
                           in_buf[i_in - 1 - variables[ch].width + i + j];
               }
   
            user_write(ch);
         }
         _cur_sub_addr = a1; // restore previous value
   
#ifdef UART1_MSCB
         /* mark variable to be send in main loop */
         if (variables[ch].flags & MSCBF_REMOUT)
            var_to_send = ch;
#endif

         if (cmd == CMD_WRITE_ACK) {
            out_buf[0] = CMD_ACK;
            out_buf[1] = in_buf[i_in - 1];
            send_obuf(2);
         }
      } else if (ch == 0xFF) {
         CSR = in_buf[2];

         if (cmd == CMD_WRITE_ACK) {
            out_buf[0] = CMD_ACK;
            out_buf[1] = in_buf[i_in - 1];
            send_obuf(2);
         }
      }
   }
}

void main

(

void

)

{
   setup();

// Code lock code
//-PAA-
//   SFRPAGE = CONFIG_PAGE;
//   FLACL = 32;  // 32 * 1024 bytes

   do {
              yield();
      
#ifdef UART1_MSCB
      manage_remote_vars();
#endif
      
      user_loop();

   } while (1);

}

static void send_byte	(	unsigned char	d,
		unsigned char *	crc
	)			[static]

{
#ifdef CPU_C8051F120
   SFRPAGE = UART0_PAGE;
#endif

   if (crc)
      *crc = crc8_add(*crc, d);
   DELAY_US(INTERCHAR_DELAY);
   SBUF0 = d;
   watchdog_refresh(1);
   while (!TI0);
   TI0 = 0;
}

static void send_obuf

(

unsigned char

n

)

[static]

{
#ifdef CPU_C8051F120
   SFRPAGE = UART0_PAGE;
#endif

   n_out = n;
   RS485_ENABLE = 1;
   DELAY_US(INTERCHAR_DELAY);
   SBUF0 = out_buf[0];
}

void send_remote_var

(

unsigned char

i

)

void serial_int

(

void

)

{
   if (TI0) {
      /* character has been transferred */

      TI0 = 0;                   // clear TI flag

      i_out++;                   // increment output counter
      if (i_out == n_out) {
         i_out = n_out = 0;      // send buffer empty, clear pointer
         DELAY_US(10);
         RS485_ENABLE = 0;       // disable RS485 driver
      } else {
         DELAY_US(INTERCHAR_DELAY);
         SBUF0 = out_buf[i_out]; // send character
      }
   }

   if (RI0) {
      /* character has been received */

      if (!RB80 && !addressed) {
         RI0 = 0;
         i_in = 0;
         return;                // discard data if not bit9 and not addressed
      }

      RB80 = 0;
      in_buf[i_in++] = SBUF0;
      RI0 = 0;

      if (i_in == 1) {
         /* check for padding character */
         if (in_buf[0] == 0) {
            i_in = 0;
            return;
         }

         /* initialize command length if first byte */
         cmd_len = (in_buf[0] & 0x07) + 2;    // + cmd + crc
      }

      if (i_in == 2 && cmd_len == 9) {
         /* variable length command */
         cmd_len = in_buf[1] + 3;             // + cmd + N + crc
      }

      if (i_in == sizeof(in_buf)) {   // check for buffer overflow
         i_in = 0;
         return;                      // don't interprete command
      }

      if (i_in < cmd_len)             // return if command not yet complete
         return;

      if (in_buf[i_in - 1] != crc8(in_buf, i_in - 1)) {
         i_in = 0;
         return;                      // return if CRC code does not match
      }

      DELAY_US(INTERCHAR_DELAY);

      interprete();             // interprete command
      i_in = 0;
   }
}

void setup

(

void

)

{
   unsigned char adr, flags, d;
   unsigned short i;
   unsigned char *p;
                                                                                                                 
   _flkey = 0;

   /* first disable watchdog */
   watchdog_disable();

   /* Port and oscillator configuration */

#if defined(CPU_C8051F120)

   SFRPAGE   = CONFIG_PAGE;

#ifdef FEB64
   XBR0 = 0x05;                 // Enable SMBus, UART0
   XBR1 = 0x00;
   XBR2 = 0x40;                 // Enable Xbar
   P1MDOUT = 0x08;              // ResetN in PP
#else
   XBR0 = 0x04;                 // Enable UART0
   XBR1 = 0x00;
   XBR2 = 0x44;                 // Enable Xbar & UART1
#endif
#ifdef LOADER
#if defined(L_TEMP36) || defined (L_LPB)
   XBR0 = 0x04;                 // Enable SMBus, UART0
#else
   XBR0 = 0x05;                 // Enable only UART0
#endif
   XBR1 = 0x00;
   XBR2 = 0x40;                 // Enable Xbar
   P1MDOUT = 0x08;              // ResetN in PP
   RS485_ENABLE = 0;            // disable RS485 driver
//   DEBUG_PIN = 0;
#endif
#ifdef CMB
   XBR0 = 0x04;                 // Enable UART0
   XBR1 = 0x00;
   XBR2 = 0x40;                 // Enable Xbar
#endif
#ifdef TEMP36
   XBR0 = 0x04;                 // Enable UART0
   XBR1 = 0x00;
   XBR2 = 0x40;                 // Enable Xbar

        // run TEMP36 at 6.1 MHz
   SFRPAGE   = CONFIG_PAGE;
   OSCICN    = 0x81;            // divide by 4
   CLKSEL    = 0x00;            // select internal oscillator
#endif

#ifdef TREVAL_12X
   XBR1 = 0x00;                 // Sysclk (0x80) Disable
   XBR2 = 0x40;                 // UART1 Disable
   P0MDOUT |= 0x4;              // P0.2: RS485_ENABLE
   P1MDOUT = 0x60;              // P1.6..7 : Pushpull LED
   RS485_ENABLE = 0;            // disable RS485 driver
#endif

#ifdef SCS_210 // run SCS_210 at 24.5 MHz
   /* Select internal quartz oscillator */
   SFRPAGE   = LEGACY_PAGE;
   FLSCL     = 0x00;            // set flash read time for <25 MHz

   SFRPAGE   = CONFIG_PAGE;
   OSCICN    = 0x83;            // divide by 1
   CLKSEL    = 0x00;            // select internal oscillator
#else          // run SCS_1001 at 98 MHz
   /* Select internal quartz oscillator */
   SFRPAGE   = LEGACY_PAGE;
   FLSCL     = 0xB0;            // set flash read time for 100 MHz

   SFRPAGE   = CONFIG_PAGE;
   OSCICN    = 0x83;            // divide by 1
   CLKSEL    = 0x00;            // select internal oscillator

   PLL0CN    |= 0x01;                   
   PLL0DIV   = 0x01;            
   PLL0FLT   = 0x01;
   PLL0MUL   = 0x04;
   for (i = 0 ; i < 15; i++);   // Wait 5us for initialization
   PLL0CN    |= 0x02;
   for (i = 0 ; i<50000 && ((PLL0CN & 0x10) == 0) ; i++);

   CLKSEL    = 0x02;            // select PLL as sysclk src
#endif

#elif defined(CPU_C8051F020)

   XBR0 = 0x04;                 // Enable UART0 & UART1
   XBR1 = 0x00;
   XBR2 = 0x44;

   P0MDOUT = 0x01;              // P0.0: TX = Push Pull
   P1MDOUT = 0x00;              // P1: LPT
   P2MDOUT = 0x00;              // P2: LPT
   P3MDOUT = 0xE0;              // P3.5,6,7: Optocouplers

#ifdef SCS_220
   P0MDOUT |= 0x40;             // P0.6: RS485_SEC_ENABLE = Push Pull
#endif

   /* Select external quartz oscillator */
   OSCXCN = 0x67;               // Crystal mode, Power Factor 22E6
   OSCICN = 0x08;               // CLKSL=1 (external)

#elif defined(CPU_C8051F310) || defined(CPU_C8051F320) || defined(CPU_C8051F410)

   XBR0 = 0x01;                 // Enable RX/TX
   XBR1 = 0x40;                 // Enable crossbar

#ifdef SCS_320
   P0MDOUT = 0x18;              // P0.3:TX, P0.4:RS485 enable Push/Pull
#else
#ifdef CPU_C8051F410
   P0MDOUT = 0x50;              // P0.4:TX, P0.6:RS485 enable Push/Pull
#else
   P0MDOUT = 0x90;              // P0.4:TX, P0.7:RS485 enable Push/Pull
#endif

#endif
   /* Select internal quartz oscillator */
#ifdef CPU_C8051F410
   OSCICN = 0x87;               // IOSCEN=1, SYSCLK=24.5 MHz
#else
   OSCICN = 0x83;               // IOSCEN=1, SYSCLK=24.5 MHz
#endif
   CLKSEL = 0x00;               // derive SYSCLK from internal source

#else

   XBR0 = 0x04;                 // Enable RX/TX
   XBR1 = 0x00;                 //  
   XBR2 = 0x40;                 // Enable crossbar

   PRT0CF = 0x01;               // P0.0: TX = Push Pull
   PRT1CF = 0x00;               // P1
   PRT2CF = 0x00;               // P2  Open drain for 5V LCD
   PRT3CF = 0x20;               // P3.5: RS485 enable = Push Pull

   /* Select external quartz oscillator */
   OSCXCN = 0x67;               // Crystal mode, Power Factor 22E6
   OSCICN = 0x08;               // CLKSL=1 (external)

#endif

   /* start system clock */
   sysclock_init();

   /* enable watchdog with default timeout */
//   watchdog_enable(0);

   /* default LED mode */
   for (i=0 ; i<N_LED ; i++)
      led_mode(i, 1);
   
   /* initialize all memory */
   CSR = 0;
   addressed = 0;
   flash_param = 0;
   flash_program = 0;
   flash_allowed = 0;
   wrong_cpu = 0;
   _flkey = 0;

#ifdef HAVE_RTC
   rtc_set = 0;
#ifdef TEMP36                   //NW
   SFRPAGE = CONFIG_PAGE;
   P0MDOUT |= 0x60;     //Set the RTC CE to be push/pull
   P2MDOUT |= 0x10;     //Set the SCLK line to be push/pull     
        rtc_init();                     //No write protection
        rtc_write_byte(0x90,0xA5);  //Charges the supercap, uses 2k ohm resistor and 1 diode
#endif
#endif

   RS485_ENABLE = 0;
   i_in = i_out = n_out = 0;
   _cur_sub_addr = 0;
   for (i=0 ; i<sizeof(in_buf) ; i++)
      in_buf[i] = 0;
   for (i=0 ; i<sizeof(out_buf) ; i++)
      out_buf[i] = 0;

   /* check if we got reset by watchdog */
#if defined(CPU_C8051F120)
   SFRPAGE   = LEGACY_PAGE;
#endif
   WD_RESET = ((RSTSRC & 0x02) == 0 && (RSTSRC & 0x08) > 0);

   /* initialize UART(s) */
   uart_init(0, BD_115200);

#ifdef UART1_MSCB
   uart_init(1, BD_115200);
#endif

#ifdef HAVE_LCD
   lcd_setup();
#endif

#ifdef DYN_VARIABLES
   setup_variables();
#endif

   /* count variables */
   for (n_variables = _var_size = 0;; n_variables++) {
      _var_size += variables[n_variables].width;
      if (variables[n_variables].width == 0)
         break;
   }

   /* check if variables are in xdata and xdata is present */
   if (n_variables > 0) {
      p = variables[0].ud;
      d = *p;
      *p = 0x55;
      if (*p != 0x55)
         wrong_cpu = 1;
      *p = 0xAA;
      if (*p != 0xAA)
         wrong_cpu = 1;
      *p = d;
   }

   /* retrieve EEPROM data */
#ifdef CPU_C8051F120
   SFRPAGE = LEGACY_PAGE;
#endif
   if ((RSTSRC & 0x02) > 0)
      flags = eeprom_retrieve(1); // vars on cold start
   else
      flags = eeprom_retrieve(0);

   if ((flags & (1 << 0)) == 0) {
      configured_addr = 0;
   
      /* set initial values */
      sys_info.node_addr = 0xFFFF;
      sys_info.group_addr = 0xFFFF;
      memset(sys_info.node_name, 0, sizeof(sys_info.node_name));
      strncpy(sys_info.node_name, node_name, sizeof(sys_info.node_name));
   } else
      configured_addr = 1;

   /* store SVN revision */
   sys_info.svn_revision = (svn_rev_main[6]-'0')*1000+
                           (svn_rev_main[7]-'0')*100+
                           (svn_rev_main[8]-'0')*10+
                           (svn_rev_main[9]-'0');

   if ((flags & (1 << 1)) == 0) {

      /* init variables */
      for (i = 0; variables[i].width; i++)
         if (!(variables[i].flags & MSCBF_DATALESS)) {
            /* do it for each sub-address */
            for (adr = 0 ; adr < _n_sub_addr ; adr++) {
               memset((char*)variables[i].ud + _var_size*adr, 0, variables[i].width);
            }
         }

      /* call user initialization routine with initialization */
      user_init(1);

      /* write current variables to flash later in main routine */
      configured_vars = 0;
   } else {
      /* call user initialization routine without initialization */
      user_init(0);
      configured_vars = 1;
   }

   /* Blink LEDs */
   for (i=0 ; i<N_LED ; i++)
      led_blink(i, 3, 150);

}

void upgrade

(

)

{
   unsigned char cmd, page, crc, j, k;
   unsigned short i;
   unsigned char xdata *pw;
   unsigned char code *pr;

   if (_flkey != 0xF1)
      return;

   /* wait for acknowledge to be sent */
   for (i=0 ; i<10000 ; i++) {
      if (n_out == 0)
         break;
      DELAY_US(10);
   }

   /* disable all interrupts */
   EA = 0;
#if defined(CPU_C8051F120)
   SFRPAGE = UART1_PAGE;
   SCON1 &= ~0x03; // clear pending UART1 interrupts
#endif

   /* disable watchdog */
#if defined(CPU_C8051F310) || defined(CPU_C8051F320) || defined(CPU_C8051F410)
   PCA0MD = 0x00;
#else
   WDTCN = 0xDE;
   WDTCN = 0xAD;
#endif

   cmd = page = 0;

   do {

receive_cmd:

#ifdef CPU_C8051F120
      SFRPAGE = UART0_PAGE;
#endif

      /* receive command */
      while (!RI0) {
         for (i=0 ; !RI0 && i<5000 ; i++)
            DELAY_US(10);
         led_0 = !led_0;
#ifdef EXT_WATCHDOG
         EXT_WATCHDOG_PIN = !EXT_WATCHDOG_PIN;
#endif
      }

      cmd = SBUF0;
      RI0 = 0;

#ifdef EXT_WATCHDOG
      EXT_WATCHDOG_PIN = !EXT_WATCHDOG_PIN;
#endif

      /* cannot use case since it calls the C library */

      if (cmd == CMD_PING16) {

         for (i=0 ; !RI0 && i < 5000 ; i++)
            DELAY_US(10);
         if (!RI0) 
            goto receive_cmd;
         page = SBUF0; // LSB
         RI0 = 0;
         for (i=0 ; !RI0 && i < 5000 ; i++)
            DELAY_US(10);
         if (!RI0) 
            goto receive_cmd;
         page = SBUF0; // MSB
         RI0 = 0;
         for (i=0 ; !RI0 && i < 5000 ; i++)
            DELAY_US(10);
         if (!RI0) 
            goto receive_cmd;
         page = SBUF0; // CRC
         RI0 = 0;

         /* acknowledge ping, independent of own address */
         RS485_ENABLE = 1;
         SEND_BYTE(CMD_ACK);
         DELAY_US(10);
         RS485_ENABLE = 0;

      } else if (cmd == CMD_UPGRADE) {

         for (i=0 ; !RI0 && i < 5000 ; i++)
            DELAY_US(10);
         if (!RI0) 
            goto receive_cmd;
         page = SBUF0; // CRC
         RI0 = 0;

         /* acknowledge upgrade */
         RS485_ENABLE = 1;
         SEND_BYTE(CMD_ACK+1);
         SEND_BYTE(1);
         SEND_BYTE(0); // dummy CRC
         DELAY_US(10);
         RS485_ENABLE = 0;

      } else if (cmd == UCMD_ECHO) {

         RS485_ENABLE = 1;
         SEND_BYTE(CMD_ACK);
         SEND_BYTE(0); // dummy CRC, needed by subm_250
         DELAY_US(10);
         RS485_ENABLE = 0;

      } else if (cmd == UCMD_ERASE) {

         /* receive page */
         for (i=0 ; !RI0 && i < 5000 ; i++)
            DELAY_US(10);
         if (!RI0) 
            goto receive_cmd;

         page = SBUF0;
         RI0 = 0;
         crc = 0;

         led_0 = !(page & 1);

         /* erase page if not page of upgrade() function */
         if (page*512 < (unsigned int)upgrade && page*512 < EEPROM_OFFSET) {

#ifdef CPU_C8051F120
            /* for F120, only erase even pages (1024kB page size!) */
            if (page & 1)
               goto erase_ok;

            SFRPAGE = LEGACY_PAGE;
#endif

#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
   
            pw = (char xdata *) (512 * page);
   
#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
            *pw = 0;    // Initiale erase page (512 bytes)
   
#if !defined(CPU_C8051F310) && !defined(CPU_C8051F320) && !defined(CPU_C8051F410)
            FLSCL = (FLSCL & 0xF0);
#endif
            PSCTL = 0x00;

         } else {
            crc = 0xFF;            // return 'protected' flag
         }

#ifdef CPU_C8051F120
         SFRPAGE = UART0_PAGE;
#endif

#ifdef CPU_C8051F120
erase_ok:
#endif
         /* return acknowledge */
         RS485_ENABLE = 1;
         SEND_BYTE(CMD_ACK);
         SEND_BYTE(crc);
         DELAY_US(10);
         RS485_ENABLE = 0;

      } else if (cmd == UCMD_PROGRAM) {

         /* receive page */
         for (i=0 ; !RI0 && i < 5000 ; i++)
            DELAY_US(10);
         if (!RI0) 
            goto receive_cmd;
         page = SBUF0;
         RI0 = 0;

         /* receive subpage */
         for (i=0 ; !RI0 && i < 5000 ; i++)
            DELAY_US(10);
         if (!RI0) 
            goto receive_cmd;
         j = SBUF0;
         RI0 = 0;

         led_0 = page & 1;

         /* program page if not page of upgrade() function */
         if (page*512 >= (unsigned int)upgrade || page*512 >= EEPROM_OFFSET)
            goto receive_cmd;

#ifdef CPU_C8051F120
         SFRPAGE = LEGACY_PAGE;
#endif

         /* allow write */
#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 access

         pw = (char xdata *) (page*512 + j*32);

#ifdef CPU_C8051F120
         SFRPAGE = UART0_PAGE;
#endif

         /* receive 32 bytes */
         for (k = 0; k < 32; k++) {
            for (i=0 ; !RI0 && i < 5000 ; i++)
               DELAY_US(10);
            if (!RI0) 
               goto receive_cmd;

#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
            /* flash byte */
            *pw++ = SBUF0;
            RI0 = 0;
         }

#ifdef CPU_C8051F120
         SFRPAGE = LEGACY_PAGE;
#endif

         /* disable write */
#if !defined(CPU_C8051F310) && !defined(CPU_C8051F320) && !defined(CPU_C8051F410)
         FLSCL = (FLSCL & 0xF0);
#endif
         PSCTL = 0x00;

#ifdef CPU_C8051F120
         SFRPAGE = UART0_PAGE;
#endif

         RS485_ENABLE = 1;
         SEND_BYTE(CMD_ACK);
         SEND_BYTE(0);
         DELAY_US(10);
         RS485_ENABLE = 0;

      } else if (cmd == UCMD_VERIFY) {

         /* receive page */
         for (i=0 ; !RI0 && i < 5000 ; i++)
            DELAY_US(10);
         if (!RI0) 
            goto receive_cmd;

         page = SBUF0;
         RI0 = 0;

         pr = 512 * page;

         /* return simplified CRC */
         for (i = crc = 0; i < 512; i++)
            crc += *pr++;

         /* return acknowledge */
         RS485_ENABLE = 1;
         SEND_BYTE(CMD_ACK);
         SEND_BYTE(crc);
         DELAY_US(10);
         RS485_ENABLE = 0;

      } else if (cmd == UCMD_READ) {

         /* receive page */
         for (i=0 ; !RI0 && i < 5000 ; i++)
            DELAY_US(10);
         if (!RI0) 
            goto receive_cmd;
         page = SBUF0;
         RI0 = 0;

         /* receive subpage */
         for (i=0 ; !RI0 && i < 5000 ; i++)
            DELAY_US(10);
         if (!RI0) 
            goto receive_cmd;
         j = SBUF0;
         RI0 = 0;

         RS485_ENABLE = 1;

         SEND_BYTE(CMD_ACK+7);     // send acknowledge, variable data length
         SEND_BYTE(32);            // send data length

         pr = (512 * page + 32 * j);

         /* send 32 bytes */
         for (k = crc = 0 ; k<32 ; k++) {
            SEND_BYTE(*pr);
            crc += *pr++;
         }

         SEND_BYTE(crc);
         DELAY_US(10);
         RS485_ENABLE = 0;

      } else if (cmd == UCMD_REBOOT) {

#ifdef CPU_C8051F120
         SFRPAGE = LEGACY_PAGE;
#endif
         RSTSRC = 0x12;  // Force soft reset and VDDmon as reset src
      }

   } while (cmd != UCMD_RETURN);


   _flkey = 0;
   EA = 1;                      // re-enable interrupts
}

void user_init

(

unsigned char

init

)

{
  char xdata i;
  /* Format the SVN and store this code SVN revision into the system */
  for (i = 0; i < 4; i++) {
    if (svn_rev_code[6 + i] < 48) {
      svn_rev_code[6 + i] = '0';
    }
  }
  sys_info.svn_revision = (svn_rev_code[6] - '0') * 1000 +
    (svn_rev_code[7] - '0') * 100 +
    (svn_rev_code[8] - '0') * 10 +
    (svn_rev_code[9] - '0');

//      P0MDIN = 0xFF;                                          // default 0xFF all digital pins
//      P1MDIN = 0xFF;
//      P2MDIN = 0xFF;

  P0MDOUT = 0x18;                                       // Default OD 485TX, TXD
  P1MDOUT = 0x00;                                       // OD
  P2MDOUT = 0xFF;                                       // OD

  P0 = 0x03;    // default 0xFF
  P1 = 0xFF;
  P2 = 0xFF;

  /* set initial state of lines */
  GPIB_DATA = 0xFF;
  GPIB_EOI = 1;
  GPIB_DAV = 1;
  GPIB_NRFD = 1;
  GPIB_NDAC = 1;
  GPIB_IFC = 1;
  GPIB_SRQ = 1;
  GPIB_ATN = 1;
  GPIB_REN = 1;

  BUF_CLE = 0;                  // Enable buffers
  BUF_DATAE = 0;

  /* initialize GPIB */
  GPIB_IFC = 0;
  delay_ms (1);
  GPIB_IFC = 1;

  GPIB_ATN = 0;
  send_byte (0x14);             // DCL
  GPIB_ATN = 1;
  
  user_data.gpib_adr = GPIB_ADDR_0;
  
  sprintf (str, "OE2");                         // prohibit overvoltage setting
  send (user_data.gpib_adr, str);
  sprintf (str, "OC0");                         // hv supply will *not* shutdown if current overload
  send (user_data.gpib_adr, str);
  sprintf (str, "SE0");                         // enables SRQ in response to overvoltage detection
  send (user_data.gpib_adr, str);
  sprintf (str, "SC0");                         // enables SRQ in response to overcurrent detection
  send (user_data.gpib_adr, str);

  user_data.status = 0;
  if (init) {
   user_data.ramp_up = 10;
   user_data.ramp_down = 10;
   user_data.u_limit = MAX_VOLTAGE;
   user_data.i_limit = MAX_CURRENT;
  }
  sprintf (user_data.warning, "current OK");

  set_voltage_limit(user_data.u_limit);
  set_current_limit(user_data.i_limit);

  read_hvi();                                // check to see if hv is already on

  if ( user_data.u_meas < 10 )               // bertan hv must be off
  {
      user_data.u_demand = 0;
      u_actual = 0;
      set_hv(0);
  }
  else                                       // bertan hv must already be on
  {
      user_data.u_demand = user_data.u_meas; // restore to status quo
      u_actual = user_data.u_meas;
  }

#ifdef RTC_410
// Init RTC on 410
   SmaRTCInit();
#endif
}

void user_loop

(

void

)

{
  /* set voltage limit if changed */
  if (chn_bits & HV_LIMIT_CHANGED) {
    set_voltage_limit(user_data.u_limit);
    chn_bits &= ~HV_LIMIT_CHANGED;
  }

  /* set current limit if changed */
  if (chn_bits & CUR_LIMIT_CHANGED) {
    set_current_limit(user_data.i_limit);
    chn_bits &= ~CUR_LIMIT_CHANGED;
  }

  // Read Voltage and Current
  read_hvi();

  // Yield to other activities (MSCB)
//  yield();

  // Do ramping if necessary
  ramp_hv();

#ifdef RTC_410
  // RTC stuff
  ltime = SmaRTCRead();
  user_data.mytime = ltime;
  ascTime(mydate, ltime);
  sprintf(user_data.date, "%s", mydate);
#endif

  // Slow it down
  delay_ms (MINDEL);

  // Loop timing
  led_blink(0, 1, 50);
}

unsigned char user_read

(

unsigned char

index

)

{
   if (index);
   return 0;
}

void user_write

(

unsigned char

index

)

{
  rCSR = user_data.status;
  if (index == IDXCTL) {
    rCTL = user_data.control;
  } // IDXCTL

  //
  //-- EE Page function
  if (index == IDXEEP_CTL) EEP_CTR_Flag = 1;
}

void yield

(

void

)

{
   watchdog_refresh(0);

   /* output RS232 data if present */
#if defined(UART1_DEVICE)
   rs232_output();
#endif
   /* blink LED if not configured */
   if (!configured_addr)
      led_blink(0, 1, 50);

   /* blink LED if wrong CPU */
   if (wrong_cpu)
      led_blink(0, 1, 30);

   /* flash EEPROM if asked by interrupt routine, wait 3 sec
      after reboot (power might not be stable) */
   if (flash_param && flash_allowed) {
      led_blink(_cur_sub_addr, 1, 50);

      flash_param = 0;

      eeprom_flash(); 
      configured_addr = 1;
   }

   /* flash EEPROM if variables just got initialized */
   if (!configured_vars && flash_allowed) {
      _flkey = 0xF1;
      eeprom_flash();
      configured_vars = 1;
   }

   if (flash_program && flash_allowed) {
      flash_program = 0;

#ifdef HAVE_LCD
      lcd_clear();
      lcd_goto(0, 0);
      puts("    Upgrading"); 
      lcd_goto(0, 1);
      puts("    Firmware...");
#endif

      /* go to "bootloader" program */
      upgrade();
   }

#ifdef HAVE_RTC
   if (rtc_set) {
      rtc_write(rtc_bwrite);
      rtc_set = 0;
   }

   if (time() > rtc_last+90 || time() < rtc_last) {
      rtc_last = time();
      rtc_read(rtc_bread);
   }
#endif

   /* allow flash 3 sec after reboot */
   if (!flash_allowed && time() > 300)
      flash_allowed = 1;

}

---

Variable Documentation

unsigned char idata _cur_sub_addr

unsigned char idata _n_sub_addr

unsigned char idata _var_size

unsigned char idata addr_mode

bit addressed

unsigned char idata cmd_len

bit configured_addr

bit configured_vars

unsigned char idata crc_code

unsigned char bdata CSR

sbit DEBUG_MODE = CSR ^ 0

unsigned char idata final_i_in

bit flash_allowed

bit flash_param

bit flash_program

sbit FREEZE_MODE = CSR ^ 2

unsigned char idata i_in

unsigned char idata i_out

unsigned char idata in_buf[20]

unsigned char idata last_i_in

bit lcd_present

unsigned char idata n_variables

char code node_name[]

unsigned char idata out_buf[8]

char code svn_rev_main[] = "$Rev: 911 $"

sbit SYNC_MODE = CSR ^ 1

SYS_INFO sys_info

MSCB_INFO_VAR* variables

sbit WD_RESET = CSR ^ 3

bit wrong_cpu

unsigned char idata _flkey _at_ x80

unsigned char idata n_out _at_ x81

---