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

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

Defines
#define	MAX_VOLTAGE   28000
#define	MAX_CURRENT   75
#define	MINDEL   100
#define	TPC_R   393.4
#define	IOFF   -0.1718
#define	GPIB_ADDR_0   4
#define	DEMAND_CHANGED   (1<<0)
#define	RAMP_UP   (1<<1)
#define	RAMP_DOWN   (1<<2)
#define	HV_LIMIT_CHANGED   (1<<3)
#define	CUR_LIMIT_CHANGED   (1<<4)
#define	CUR_LIMIT_BYPASS   (1<<7)
#define	STATUS_RAMP_UP   (1<<0)
#define	STATUS_RAMP_DOWN   (1<<1)
#define	STATUS_VLIMIT   (1<<2)
#define	STATUS_ILIMIT   (1<<3)
#define	STATUS_LOWCUR   (1<<4)
#define	STATUS_HICUR   (1<<5)
Functions
void	user_write (unsigned char index) reentrant
unsigned char	send (unsigned char adr, char *str)
unsigned char	send_byte (unsigned char b)
unsigned char	enter (unsigned char adr, char *str, unsigned char maxlen)
void	set_voltage_limit (float value)
void	set_hv (float value) reentrant
void	read_hvi (void)
void	ramp_hv (void)
void	set_current_limit (float value)
void	user_init (unsigned char init)
unsigned char	user_read (unsigned char index)
unsigned char	user_func (unsigned char *data_in, unsigned char *data_out)
void	user_loop (void)
Variables
unsigned char idata	_n_sub_addr = 1
char code	node_name [] = "CCBERTAN410"
char xdata	svn_rev_code [] = "$Rev: 1399 $"
unsigned char idata	chn_bits = 0
int	Ibypass = 0
float xdata	u_actual
unsigned long xdata	t_ramp
char xdata	str [32]
char xdata *	buf
unsigned char xdata	tiwp
struct {
unsigned char   status
float   u_demand
float   u_meas
float   i_meas
unsigned int   ramp_up
unsigned int   ramp_down
float   u_limit
float   i_limit
char   warning [32]
char   date [24]
unsigned char   gpib_adr
unsigned long   mytime
}	user_data
MSCB_INFO_VAR code	vars []
MSCB_INFO_VAR *	variables = vars
SYS_INFO	sys_info

---

Define Documentation

#define CUR_LIMIT_BYPASS   (1<<7)

#define CUR_LIMIT_CHANGED   (1<<4)

#define DEMAND_CHANGED   (1<<0)

#define GPIB_ADDR_0   4

#define HV_LIMIT_CHANGED   (1<<3)

#define IOFF   -0.1718

#define MAX_CURRENT   75

#define MAX_VOLTAGE   28000

#define MINDEL   100

#define RAMP_DOWN   (1<<2)

#define RAMP_UP   (1<<1)

#define STATUS_HICUR   (1<<5)

#define STATUS_ILIMIT   (1<<3)

#define STATUS_LOWCUR   (1<<4)

#define STATUS_RAMP_DOWN   (1<<1)

#define STATUS_RAMP_UP   (1<<0)

#define STATUS_VLIMIT   (1<<2)

#define TPC_R   393.4

---

Function Documentation

unsigned char enter	(	unsigned char	adr,
		char *	str,
		unsigned char	maxlen
	)

{
   unsigned long t;
   unsigned char i, flag;
   unsigned int j;

  /*---- address cycle ----*/
//   GPIB_REN = 0;
   GPIB_ATN = 0;                // assert attention
   send_byte(0x3F);             // unlisten
   send_byte(0x5F);             // untalk
   send_byte(0x20 | 21);        // listen 21
   send_byte(0x40 | adr);       // talk device
   GPIB_ATN = 1;                // remove attention

  /*---- data cycles ----*/

   GPIB_NDAC = 0;               // init NDAC line

   for(i=0;i<maxlen;i++) str[i] = 0;
   
   for (i = 0; i < maxlen; i++) {
      yield();

      GPIB_NRFD = 1;            // signal ready for data

      /* wait 1s for DAV go low */
      t = time();
      do {
         if (GPIB_DAV == 0)
            break;

         yield();

      } while (time() - t < 100);

      if (GPIB_DAV == 1) {
         GPIB_NDAC = 1;
         GPIB_NRFD = 1;
         GPIB_REN = 1;
         return 0;           // timeout
      }

      GPIB_NRFD = 0;            // signal busy

      str[i] = ~GPIB_DATA;      // read negated data

      flag = GPIB_EOI;          // read EOI flag

      GPIB_NDAC = 1;            // signal acknowledge

      /* wait for DAV go high */
      for (j = 0; j < 1000; j++) {
        delay_us(10);
        if (GPIB_DAV == 1)
          break;
      }
      GPIB_NDAC = 0;            // remove acknowledge

      if (flag == 0)            // stop if end of data
         break;
   }

   GPIB_NDAC = 1;               // release handshake lines
   GPIB_NRFD = 1;

   /* stop talker */
   GPIB_ATN = 0;                // assert attention
   send_byte(0x3F);             // unlisten
   send_byte(0x5F);             // untalk
   GPIB_ATN = 1;                // remove attention
   GPIB_REN = 1;
   return i;
}

void ramp_hv

(

void

)

{
   int delta;

   /* only process ramping when HV is on and not tripped */
   if (!(user_data.status & STATUS_ILIMIT)) {

      if (chn_bits & DEMAND_CHANGED) {
         /* start ramping */

         if (user_data.u_demand > u_actual &&
             user_data.ramp_up > 0) {
            /* ramp up */
            chn_bits |= RAMP_UP;
            chn_bits &= ~RAMP_DOWN;
            user_data.status |= STATUS_RAMP_UP;
            user_data.status &= ~STATUS_RAMP_DOWN;
            chn_bits &= ~DEMAND_CHANGED;
         }

         if (user_data.u_demand < u_actual &&
             user_data.ramp_down > 0) {
            /* ramp down */
            chn_bits &= ~RAMP_UP;
            chn_bits |= RAMP_DOWN;
            user_data.status &= ~STATUS_RAMP_UP;
            user_data.status |= STATUS_RAMP_DOWN;
            chn_bits &= ~DEMAND_CHANGED;
         }

         /* remember start time */
         t_ramp = time();
      }
      /* ramp up */
      if (chn_bits & RAMP_UP) {
         delta = time() - t_ramp;  // delta is milli-seconds since last ramp step
         if (delta > MINDEL) {
            u_actual += (float) user_data.ramp_up;
            // u_actual is now the new setting voltage
            if (u_actual >= user_data.u_demand) {
               // Set the final requested voltage.               
               u_actual = user_data.u_demand;
               chn_bits &= ~RAMP_UP;
               user_data.status &= ~STATUS_RAMP_UP;
            }

            set_hv(u_actual);
            t_ramp = time();
         }
      }

      /* ramp down */
      if (chn_bits & RAMP_DOWN) {
         delta = time() - t_ramp;  // delta is milli-seconds since last ramp step
         if (delta > MINDEL) {
            u_actual -= (float) user_data.ramp_down;
            // u_actual is now the new setting voltage
            if (u_actual <= user_data.u_demand) {
               // finish ramping 
               // Set the final requested voltage.               
               u_actual = user_data.u_demand;
               chn_bits &= ~RAMP_DOWN;
               user_data.status &= ~STATUS_RAMP_DOWN;
            }

            set_hv(u_actual);
            t_ramp = time();
         }
      }
   }
}

void read_hvi

(

void

)

{
  float hv, current;

  sprintf (str, "T0");
  send (user_data.gpib_adr, str);

  tiwp = enter(user_data.gpib_adr, str, sizeof(str));
/*
  if (tiwp) {
    DISABLE_INTERRUPTS;
    sprintf (user_data.warning, str);
    ENABLE_INTERRUPTS;
  } 
*/

//-PAA For test
//  sprintf(str, "N V12.345K 987.54U");

  if (Ibypass) {
    DISABLE_INTERRUPTS;
    sprintf (user_data.warning, "Warning! Current Limit bypassed");
    ENABLE_INTERRUPTS;
    return;
  }
  hv  =  str[8] - 48;
  hv += (str[7] - 48)*10;
  hv += (str[6] - 48)*100;
  hv += (str[4] - 48)*1000;
  hv += (str[3] - 48)*10000;
 
  current  = (str[17] - 48)/100;
  current += (str[16] - 48)/10;
  current += (str[14] - 48);
  current += (str[13] - 48)*10;
  current += (str[12] - 48)*100;

  if (hv < 0) hv = 0;
  if (current < 0) current = 0;

  // Catch false reading. if both are reading 0
  // there is certainly a readout error
  // // ((hv != 0) || (current != 0))
  // First use the return string length

  if (tiwp == 0) return;
  DISABLE_INTERRUPTS;
  user_data.u_meas = hv;
  user_data.i_meas = current;
  ENABLE_INTERRUPTS;
  
  // Publish locally new readback voltage for ramping
  u_actual = hv;

  if ( current >= user_data.i_limit )  {
    user_data.status |= STATUS_ILIMIT;
  } else {
    user_data.status &= ~STATUS_ILIMIT;
  }

  if ( current > ((1.1 *  hv/TPC_R) + IOFF) ) {
    sprintf (user_data.warning, "Warning High I (%6.3f)", current);
    DISABLE_INTERRUPTS;
    user_data.status |=  STATUS_HICUR;
    user_data.status &= ~STATUS_LOWCUR;
    ENABLE_INTERRUPTS;
  } else if ( current < ((0.9 * hv/TPC_R) +IOFF) ) {
    sprintf (user_data.warning, "Warn-Low I (%6.3f)", current);
    DISABLE_INTERRUPTS;
    user_data.status |=  STATUS_LOWCUR;
    user_data.status &= ~STATUS_HICUR;
    ENABLE_INTERRUPTS;
  } else {
    sprintf (user_data.warning, "current OK");
    DISABLE_INTERRUPTS;
    user_data.status &= ~STATUS_HICUR;
    user_data.status &= ~STATUS_LOWCUR;
    ENABLE_INTERRUPTS;
  }
}

unsigned char send	(	unsigned char	adr,
		char *	str
	)

{
   int i; //, len;
   char s;

  /*---- address cycle ----*/

//   GPIB_REN = 0;
   GPIB_ATN = 0;                // assert attention
   send_byte(0x3F);             // unlisten
   send_byte(0x5F);             // untalk
   send_byte(0x20 | adr);       // listen device
   send_byte(0x40 | 21);        // talk 21
   GPIB_ATN = 1;                // remove attention

  /*---- data cycles ----*/
//   len = strlen(str);
   for (i = 0; str[i] > 0; i++) {
      s = send_byte(str[i]);
      GPIB_REN = 1;
      if (s == 0) return 0;
   }

   GPIB_EOI = 0;
   send_byte(0x0A);             // NL
   GPIB_EOI = 1;
   GPIB_REN = 1;

   return i;
}

unsigned char send_byte

(

unsigned char

b

)

{
   unsigned int i;

//   yield();

   /* wait for NRFD go high */
   for (i = 0; i < 1000; i++)
      if (GPIB_NRFD == 1)
         break;

   if (GPIB_NRFD == 0)
      return 0;

   GPIB_DATA = ~b;              // negate
   delay_us(10);                // setup time, let signals settle
   GPIB_DAV = 0;

   /* wait for NDAC go high */
   for (i = 0; i < 1000; i++) {
      delay_us(10);
      if (GPIB_NDAC == 1)
         break;
   }

   if (GPIB_NDAC == 0) {
      GPIB_DAV = 1;
      GPIB_DATA = 0xFF;
      return 0;                 // timeout
   }

   GPIB_DAV = 1;
   GPIB_DATA = 0xFF;            // prepare for input

   /* wait for NRFD go high */
   for (i = 0; i < 1000; i++)
      if (GPIB_NRFD == 1)
         break;

   if (GPIB_NRFD == 0)
      return 0;

   return 1;
}

void set_current_limit

(

float

value

)

{
  // Set the current limit

  sprintf (str, "L%06.3fUG", value);
  send (user_data.gpib_adr, str);
  delay_ms(2);

  return;
}

void set_hv

(

float

value

)

{
  if (value > user_data.u_limit)   // check for limit
  {
    value = user_data.u_limit;
    user_data.status |= STATUS_VLIMIT;
  } 
  else
  {
    user_data.status &= ~STATUS_VLIMIT;
  }

  sprintf (str, "P%06.3fKG", value/1000);
  send (user_data.gpib_adr, str);
}

void set_voltage_limit

(

float

value

)

{
  // Set the voltage limit

  sprintf (str, "L%06.3fKG", value/1000);
  send (user_data.gpib_adr, str);
  delay_ms(2);

  return;
}

unsigned char user_func	(	unsigned char *	data_in,
		unsigned char *	data_out
	)

{
   /* echo input data */
   data_out[0] = data_in[0];
   data_out[1] = data_in[1];
   return 2;
}

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

)

{
   if (index == 1) {
      /* indicate new demand voltage */
      chn_bits |= DEMAND_CHANGED;
   }

   /* Bypass limit */
   if (index == 0) {
        if (user_data.status == CUR_LIMIT_BYPASS)
          Ibypass = (Ibypass == 1) ? 0 : 1;
   }

   /* check voltage limit */
   if (index == 6) {
      if (user_data.u_limit > MAX_VOLTAGE) {
         user_data.u_limit = MAX_VOLTAGE;
      }
      chn_bits |= HV_LIMIT_CHANGED;
   }

   /* check current limit */
   if (index == 7) {
      if (user_data.i_limit > MAX_CURRENT) {
         user_data.i_limit = MAX_CURRENT;
      }
      chn_bits |= CUR_LIMIT_CHANGED;
   }
}

---

Variable Documentation

unsigned char idata _n_sub_addr = 1

char xdata * buf

unsigned char idata chn_bits = 0

char date[24]

unsigned char gpib_adr

float i_limit

float i_meas

int Ibypass = 0

unsigned long mytime

char code node_name[] = "CCBERTAN410"

unsigned int ramp_down

unsigned int ramp_up

unsigned char status

char xdata str[32]

char xdata svn_rev_code[] = "$Rev: 1399 $"

SYS_INFO sys_info

unsigned long xdata t_ramp

unsigned char xdata tiwp

float xdata u_actual

float u_demand

float u_limit

float u_meas

struct { ... } user_data

MSCB_INFO_VAR* variables = vars

MSCB_INFO_VAR code vars[]

Initial value:

 {

   1, UNIT_BYTE,            0, 0,           0, "Status",  &user_data.status,      
   4, UNIT_VOLT,            0, 0, MSCBF_FLOAT, "Udemand", &user_data.u_demand,    
   4, UNIT_VOLT,            0, 0, MSCBF_FLOAT, "Umeas",   &user_data.u_meas,      
   4, UNIT_AMPERE, PRFX_MICRO, 0, MSCBF_FLOAT, "Imeas",   &user_data.i_meas,      
   2, UNIT_VOLT,            0, 0,           0, "RampUp",  &user_data.ramp_up,     
   2, UNIT_VOLT,            0, 0,           0, "RampDown",&user_data.ramp_down,   
   4, UNIT_VOLT,            0, 0, MSCBF_FLOAT, "Ulimit",  &user_data.u_limit,     
   4, UNIT_AMPERE, PRFX_MICRO, 0, MSCBF_FLOAT, "Ilimit",  &user_data.i_limit,     
  32, UNIT_STRING,          0, 0,           0, "warning", &user_data.warning,     



   1, UNIT_BYTE,            0, 0, MSCBF_HIDDEN, "GPIB Adr",&user_data.gpib_adr,   



   0
}

char warning[32]

---