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

#include <stdio.h>
#include <math.h>
#include "mscbemb.h"
#include "feb64.h"
#include "Devices/pca_internal.h"
#include "Devices/adc_internal.h"

Functions
void	publishCtlCsr (void)
void	publishErr (bit errbit)
void	publishAll ()
void	PublishVariable (float xdata *pvarDest, float varSrce, bit errbit)
void	updateAdc2Table (void)
unsigned int	NodeAdd_get (void)
float	read_voltage (unsigned char channel, unsigned int *rvalue, float coeff, float offset, unsigned char gain)
void	switchonoff (unsigned char command)
void	user_init (unsigned char init)
void	user_write (unsigned char index) reentrant
unsigned char	user_read (unsigned char index)
unsigned char	user_func (unsigned char *data_in, unsigned char *data_out)
void	user_loop (void)
Variables
char code	node_name [] = "FEB64"
char idata	svn_rev_code [] = "$Rev: 1185 $"
unsigned char idata	_n_sub_addr = 1
int xdata	k
int xdata	calState = 0
int xdata	calCount = 0
float xdata	calNumber = 10.0
char xdata	calQpumpSave = 0
char xdata	calSwSave = 0
unsigned long xdata	currentTime = 0
unsigned long xdata	sstTime = 0
unsigned long xdata	sstExtTime = 0
unsigned long xdata	calTime = 0
unsigned char xdata	status
unsigned char xdata	channel
unsigned char xdata	chipAdd
unsigned char xdata	chipChan
unsigned char xdata	BiasIndex
unsigned char xdata	AsumIndex
unsigned char xdata	NodeOK = 0
unsigned char bdata	bChange
sbit	bCPupdoitNOW = bChange ^ 0
sbit	bDacdoitNOW = bChange ^ 1
sbit	PCA_Flag = bChange ^ 2
sbit	LTC2600_Flag = bChange ^ 3
sbit	LTC1665_Flag = bChange ^ 4
sbit	LTC1669_Flag = bChange ^ 5
sbit	EEP_CTR_Flag = bChange ^ 6
sbit	CAsum_Flag = bChange ^ 7
sbit	DACRESETN = P1 ^ 0
sbit	PCARESETN = P1 ^ 2
sbit	ASUM_SYNC = P1 ^ 7
sbit	ASUM_TESTN = P1 ^ 6
sbit	ASUM_PWDN = P1 ^ 5
sbit	REG_EN = P3 ^ 2
MSCB_INFO_VAR code	vars []
MSCB_INFO_VAR *	variables = vars
SYS_INFO	sys_info

---

Function Documentation

unsigned int NodeAdd_get

(

void

)

{
  unsigned int xdata crate_add=0;
  char xdata pca_add=0;

  PCA9539_Read(BACKPLANE_READ, &pca_add, 1);
  // C C C C C C 0 B B is the MSCB Addr[8..0], 9 bits
  // Modifying what the board reads from the PCA
  // Externally, the crate address are reversed
  crate_add= ((~pca_add)<<1)  & 0x01F8;
  // Internally, the board address are not reversed
/*3 was in te laptop version but not in the SVN
  if (crate_add == 504) {
    // expect a SMB bus problem
    // Try to reset
    SFRPAGE = SMB0_PAGE;
    ENSMB = 0;      // Disable SMB
    delay_us(100);  // pause 
    SFRPAGE = CONFIG_PAGE;
    PCA9539_Init(); //PCA General I/O (Bias Enables and Backplane Addr) initialization
    delay_us(10);
    PCA9539_WriteByte(BIAS_OUTPUT_ENABLE);
*/
//    P1MDOUT |= 0x04;  // PCARESETN in PP
//    delay_us(100);
//    PCARESETN = 0;
//    delay_us(10);
//    PCARESETN = 1;
//  }
  return (crate_add | ((pca_add) & 0x0003));
}

void publishAll

(

)

                  {
  user_data.control = rCTL;
  user_data.status  = rCSR;
  user_data.error   = rESR;
  ENABLE_INTERRUPTS;
}

void publishCtlCsr

(

void

)

                         {
  DISABLE_INTERRUPTS;
  user_data.control = rCTL;
  user_data.status  = rCSR;
  ENABLE_INTERRUPTS;
}

void publishErr

(

bit

errbit

)

                            {
    DISABLE_INTERRUPTS;
    errbit = ON;
    user_data.error   = rESR;
    ENABLE_INTERRUPTS;
}

void PublishVariable	(	float xdata *	pvarDest,
		float	varSrce,
		bit	errbit
	)

                                                                        {
  DISABLE_INTERRUPTS;
  *pvarDest = varSrce;
  if (errbit) user_data.error = rESR;
  errbit = 0;
  ENABLE_INTERRUPTS;
}

float read_voltage	(	unsigned char	channel,
		unsigned int *	rvalue,
		float	coeff,
		float	offset,
		unsigned char	gain
	)

{
  unsigned int  xdata i;
  float         xdata voltage;
  unsigned int  xdata rawbin;
  unsigned long xdata rawsum = 0;

  // Averaging on 10 measurements for now.
  for (i=0 ; i<10 ; i++) {
    rawbin = adc_read(channel, gain);
    rawsum += rawbin;
    yield();
  }

  /* convert to V */
  *rvalue =  rawsum/10;
  voltage = (float)  *rvalue;                  // averaging
  voltage = (float)  voltage / 1024.0 * INT_VREF;  // conversion
  if ( channel != TCHANNEL)
    voltage = voltage * coeff + offset;

  return voltage;
}

void switchonoff

(

unsigned char

command

)

{
  char xdata i;
  char xdata swConversion;
  if(command==ON)
  {
    //-----------------------------------------------------------------------------
    // Enable the voltage regulator to power the card
    SFRPAGE  = CONFIG_PAGE;
    P3MDOUT |= 0x04;  // Set Vreg enable to PP
    REG_EN = ON;

    //-----------------------------------------------------------------------------
    // Setup the ASUM ports (P1.7, 6, 5)
    P1MDOUT |= 0xE0;  // Sync, Test, PowerDwnN Push-pull

    // Pulse the serializer (ASUM)
    ASUM_PWDN  = 1;    // Power UP
    delay_ms(1000);
    ASUM_SYNC = 1;     // Issue sync words.
    delay_us(100);     // Wait sometime.
    ASUM_TESTN = 1;    // Choose Non test mode. (TEST=neg true)
    ASUM_SYNC = 0;     // Negate the sync process.

    //-----------------------------------------------------------------------------
    // uC Charge Pump frequency setup
    pca_operation(Q_PUMP_INIT);  // Charge Pump initialization (crossbar settings)
    //Sept 09 default Qpump ON at Power up
    pca_operation(Q_PUMP_ON);

//    sprintf(user_data.warning, "No Trip");

#ifdef _LTC1665_
    //-----------------------------------------------------------------------------
    // SPI Dac (Bias voltages, 64 channels)
    // SST and PCARESETN is maintained ==1 and PP
    // P1.7:ASUMSync .6:ASUMTestn .5:ASUMPWDn .4:ASUMCSn | .3:SST_DRV2 .2:PCARESETN .1:SST_DRV1 .0:DACRESETN 
    SFRPAGE  = CONFIG_PAGE;
    P2MDOUT |= 0x18; // Set SPI_MOSI and SPI_SCK in PP
    P0MDOUT |= 0xC0; // Set BIAS_DAC_CSn1 and BIAS_DAC_CSn2 in PP
    P3MDOUT |= 0x63; // Set BIAS_DAC_CSn3,4,5,6 in PP
    P2MDOUT |= 0x60; // Set BIAS_DAC_CSn7,8 in PP
    P1MDOUT |= 0x01; // Set DACRESETN in PP
    DACRESETN  = 1;
    LTC1665_Init();
#endif

#ifdef _LTC2600_
    //-----------------------------------------------------------------------------
    // SPI ASUM DAC (8 channels)
    SFRPAGE  = CONFIG_PAGE;
    P2MDOUT |= 0x18;  // Set SPI_MOSI and SPI_SCK in PP
    P1MDOUT |= 0x10;  // Set SUM_DAC_CSn in PP
    LTC2600_Init();
#endif

#ifdef _ExtEEPROM_
    //-----------------------------------------------------------------------------
    //SPI ExtEEPROM
    SFRPAGE  = CONFIG_PAGE;
    P2MDOUT |= 0x18; // Set SPI_MOSI and SPI_SCK in PP
    P3MDOUT |= 0x80; // Set RAM_CSn in PP
    P2MDOUT &= ~0x01; // Set RAM_WPn in OD
    ExtEEPROM_Init();
#endif

#ifdef _LTC1669_
    //-----------------------------------------------------------------------------
    // SMB Charge Pump DAC
    LTC1669_Init(); //I2C DAC initialization
#endif

#ifdef _LTC2497_
    LTC2497_Init();
#endif

#ifdef _LTC2495_
    LTC2495_Init();
#endif

#ifdef _ADT7486A_
    //SST and PCARESETN is maintained ==1 and PP
    // P1.7:ASUMSync .6:ASUMTestn .5:ASUMPWDn .4:ASUMCSn | .3:SST_DRV2 .2:PCARESETN .1:SST_DRV1 .0:DACRESETN 
    SFRPAGE = CONFIG_PAGE;
    P1MDOUT |= 0x08; // Set SST_DRV2 in PP
#endif

#ifdef _PCA9539_
    //-----------------------------------------------------------------------------
    // SMB Bias Voltage switches
    SFRPAGE = CONFIG_PAGE;
    P1MDOUT |= 0x04;  // PCARESETN in PP
    PCA9539_Init(); //PCA General I/O (Bias Enables and Backplane Addr) initialization
    delay_us(10);
    PCA9539_WriteByte(BIAS_OUTPUT_ENABLE);
    delay_us(10);
    swConversion = user_data.swBias;
    PCA9539_Conversion(&swConversion);
    PCA9539_WriteByte(BIAS_WRITE, ~swConversion);
    delay_us(10);
    PCA9539_WriteByte(BACKPLANE_INPUT_ENABLE);
    delay_us(10);
#endif

    // Activate charge pump dac settings
    LTC1669_Flag = ON;

    // Activate 64 bias dac settings
    // user_data contains correct values, force update 
    // by setting mirror to 0xff 
    for(i=0;i<64;i++) ltc1665mirror[i] = 0xFF;

    // Needs power for DAC update, by now it should be ON
    // Force DAC updates
    LTC1665_Flag = ON;


    // Activate the 8 Asum dac settings
    // user_data contains correct values, force update 
    // by setting mirror to 0x00 
    for(i=0;i<8;i++) ltc2600mirror[i] = 0xFFFF;

    // Needs power for DAC update, by now it should be ON
    // Force DAC updates
    LTC2600_Flag = ON;
  }
  else if(command==OFF) {
    pca_operation(Q_PUMP_OFF);   // Initially turn it off

    // Switch all the ports to open drain except for...
    SFRPAGE  = CONFIG_PAGE;

    //Ram_CSn maintained in PP set it to High
    // P3.7:RAMCSn   .6:CSn5      .5:CSn4     .4:SPARE5  | .3:SPARE4   .2:REG_EN    .1:CSn3     .0:CSn2 
    P3MDOUT = 0x80;
    P3 &= 0x80;

    // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
    // Needs to stay on for JTAG debug access!
    // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
    REG_EN  = OFF;   // Shutdown All Regulators 

    //SPI communication for EEPROM is maintained
    // P2.7:SPARE1   .6:CSn7      .5:CSn6     .4:SPIMOSI | .3:SPISCK   .2:RAMHLDn   .1:SPIMISO  .0:RAMWPn 
    P2MDOUT &= 0x1F; // Set OD
    P2 &= 0x0F;

    //SST and PCARESETN is maintained high and PP
    // P1.7:ASUMSync .6:ASUMTestn .5:ASUMPWDn .4:ASUMCSn | .3:SST_DRV2 .2:PCARESETN .1:SST_DRV1 .0:DACRESETN 
    P1MDOUT  &= ~0xF9;  // in OD
    PCARESETN = 1;
    P1 |= 0x06;  // SST2, PCARESETN set High

    // mscb communication
    // P0.7:CSn1     .6:CSn0      .5:485TXEN  .4:QPUMPCLK| .3:SMBCLK   .2:SMBDAT    .1:Rx       .0:Tx 
    P0MDOUT &= 0xE0;  // Set OD, Keep RS484_ENABLE uin PP
    P0 &= ~0xC0;  // Set CS1,0 to Low
  }
}

void updateAdc2Table

(

void

)

{
  int i, j;
  for(i=0;i<16;i++) {
    if (adc2mscb_table[i].current) {
      j = adc2mscb_table[i].mscbIdx;
      adc2mscb_table[i].Offst = (signed int) eepage.iBiasOffset[j];
    } else {
      j = adc2mscb_table[i].mscbIdx;
      adc2mscb_table[i].Offst = (signed int) eepage.vBiasOffset[j];
    }
  }
}

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;
  float xdata temperature;
  // Inititialize local variables

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

  //-----------------------------------------------------------------------------
  // default settings, set only when uC-EEPROM is being erased and written
  if(init) {
    user_data.control    = 0x00;    // Turn off the charge pump
    user_data.status     = 0x80;    // Shutdown state
    user_data.swBias     = 0x00;    // Turn off all the switches
    user_data.rQpump     = 0x00;    // Set to the lowest scale
    for(i=0;i<8;i++) {
      user_data.rAsum[i] = 0x80;
      user_data.Temp[i]  = 0.0;
    }
    for(i=0;i<64;i++) {
      user_data.rBias[i] = 0xFF;    // Set the DAC to lowest value
      ltc1665mirror[i]      = 0xFF;
    }
  }
  sys_info.group_addr  = 100;
//  sprintf(user_data.warning, "No Trip");

  //-----------------------------------------------------------------------------
  // Local Flags
  bChange = 0;

  //-----------------------------------------------------------------------------
  // Initial setting for communication and overall ports (if needed).
  SFRPAGE  = CONFIG_PAGE;
  P0MDOUT |= 0x20;   // add RS485_ENABLE in push-pull

  //-----------------------------------------------------------------------------
  // uC Miscellaneous ADCs (V/I Monitoring)
  adc_internal_init();

  //-----------------------------------------------------------------------------
  //SPI ExtEEPROM
#ifdef _ExtEEPROM_
  SFRPAGE  = CONFIG_PAGE;
  P2MDOUT |= 0x18;  // Set SPI_MOSI and SPI_SCK in PP
  P2MDOUT &= ~0x01; // Set RAM_WPn in OD
  P3MDOUT |= 0x80;  // Set RAM_CSn in PP
  ExtEEPROM_Init();
#endif

  //-----------------------------------------------------------------------------
  // Reset LTC1665 (DACx8), Reset PCA9539 (PIO)
  //SST and PCARESETN is maintained ==1 and PP
  // P1.7:ASUMSync .6:ASUMTestn .5:ASUMPWDn .4:ASUMCSn | .3:SST_DRV2 .2:PCARESETN .1:SST_DRV1 .0:DACRESETN 
  SFRPAGE  = CONFIG_PAGE;
  P1MDOUT |= 0x5;   // PIO/DACRESETN in PP
  DACRESETN = 1;    // No reset 
  PCARESETN = 1;    // No reset

  //-----------------------------------------------------------------------------
  // Initialize PCA for address reading and switch settings
#ifdef _PCA9539_
  SFRPAGE = CONFIG_PAGE;
//  P1MDOUT |= 0x08;
  PCA9539_Init(); //PCA General I/O (Bias Enables and Backplane Addr) initialization
  delay_us(10);
  //Write to the PCA register for setting 0.x to output
  PCA9539_WriteByte(BIAS_OUTPUT_ENABLE);
  delay_us(10);
  //Set the port pins to high
  PCA9539_WriteByte(BIAS_ENABLE);
  delay_us(10);
  //Write to the PCA register for setting 1.x to input
  PCA9539_WriteByte(BACKPLANE_INPUT_ENABLE);
  delay_us(10);
  
  // Get Node Address from PCA
//  sys_info.node_addr   = NodeAdd_get();
#endif

  //-----------------------------------------------------------------------------
  // EEPROM memory Initialization/Retrieval
#ifdef _ExtEEPROM_
  //Read only the serial number from the protected page
  // (without the iBiasOffset)Protected page starts from 0x600, serial number is located in 0x690
  // (with the iBiasOffset) Protected page starts from 0x600, serial number is located in 0x6B0
  ExtEEPROM_Read(SERIALN_ADD,(unsigned char xdata *)&eepage.SerialN, SERIALN_LENGTH);
  user_data.SerialN = eepage.SerialN;
  sys_info.node_addr = 500 + (eepage.SerialN - 76300000);

  //Read all other settings from page 0(non-protected)
  ExtEEPROM_Read(PageAddr[0], (unsigned char xdata *)&eepage, PAGE_SIZE);
  DISABLE_INTERRUPTS;
  for(i=0;i<8;i++) {
    user_data.rAsum[i] = eepage.rasum[i];
    ltc2600mirror[i] = eepage.rasum[i];
  }
  for(i=0;i<64;i++) {
    user_data.rBias[i] = eepage.rbias[i];
    ltc1665mirror[i] = eepage.rbias[i];
  }
  user_data.rQpump = (unsigned int) (eepage.rqpump & 0x3FF);
  user_data.swBias = eepage.SWbias;
  ENABLE_INTERRUPTS;

  // Update adc2mscb_table[adcChannel].Offst values for current ONLY
  updateAdc2Table();
#endif

  //-----------------------------------------------------------------------------
  // SST Temperatures, setting temperature offsets
#ifdef _ADT7486A_
  SFRPAGE  = CONFIG_PAGE;
  P1MDOUT |= 0x0A; // Set SST_DRV1/2 in PP
  // External 4 SST devices
  SFRPAGE  = CPT1_PAGE;
  CPT1CN  |= 0x80; // Enable the Comparator 1
  CPT1MD   = 0x03; //Comparator1 Mode Selection
  // Local 1 SST device
  SFRPAGE  = CPT0_PAGE;
  CPT0CN  |= 0x80; // Enable the Comparator 0
  CPT0MD   = 0x03; //Comparator0 Mode Selection
 //Use default, adequate TYP (CP1 Response Time, no edge triggered interrupt)

  ADT7486A_Init(SST_LINE1); //  external devices
  ADT7486A_Init(SST_LINE2); //  local devices

  for (channel=0;channel < NCHANNEL_ADT7486A; channel++){
    ADT7486A_Cmd(ADT7486A_addrArray[channel]
    , SetExt1Offset
      , ((int)eepage.ext1offset[channel]>>8)
      , (int)eepage.ext1offset[channel]
    , SST_LINE1
      , &temperature); //NW
    delay_us(100);

  }
  for (channel=0;channel < NCHANNEL_ADT7486A; channel++){
    ADT7486A_Cmd(ADT7486A_addrArray[channel]
    , SetExt2Offset
      , ((int)eepage.ext2offset[channel]>>8)
      , (int)eepage.ext2offset[channel]
    , SST_LINE1
      , &temperature); //NW
    delay_us(100);
  }

  // Missing offset loading for local SST devices.
#endif

  //-----------------------------------------------------------------------------
  // Turn off the card before the timer expires
  switchonoff(OFF);

  //-----------------------------------------------------------------------------
  // Final steps
  rESR = 0x0000;              // No error!
  rEER = 0x00;                    // Active page 0, To be written or read page 0
  rCTL = 0;                       // Reset control
  rCSR = 0x00;                    // Initial CSR
  user_data.error      = rESR;    // Default Error register //NW
  user_data.eepage     = rEER;    // Default EE page
  user_data.status     = rCSR;    // Shutdown state
  user_data.control    = 0x80;    // Manual Shutdown
  user_data.watchdog   = 0;       // Watchdog counter for debugging purpose
  for(i=0;i<8;i++){
    user_data.VBMon[i] = 0;
    user_data.IBMon[i] = 0;
    user_data.rVBMon[i] = 0;
    user_data.rIBMon[i] = 0;
    user_data.Temp[i]  = -128.0;
    user_data.eepValue = 0.0;
    user_data.eeCtrSet = 0;
  }

  // Debug pin on SPARE1
  P2MDOUT |= 0x80;  P2 |= 0x80;  // Timing port in PP = 0
}

void user_loop

(

void

)

                     {
  static unsigned char xdata eeprom_flag = CLEAR;
  static char xdata adcChannel = 0;
  float xdata volt, temperature, adc_value, ftemp;
  float* xdata pfData;
  float* xdata eep_address;
  unsigned long xdata mask;
  signed long xdata result;
  unsigned int xdata eeptemp_addr, *rpfData, rvolt, i;
  unsigned char xdata * eeptemp_source;
  unsigned char xdata swConversion, eep_request;
  char xdata ltc1665_index, ltc1665_chipChan, ltc1665_chipAdd;
  char xdata ltc2600_index;
  char xdata str[32];

  timing=1;

//  if (!NodeOK && uptime()) {
    // Get Node Address from PCA
//    sys_info.node_addr   = NodeAdd_get();
    user_data.geoadd = NodeAdd_get();
//    NodeOK = 1;
//  }

  //External ADC for REV0 cards
  //-----------------------------------------------------------------------------
#ifdef _LTC2497_
  LTC2497_StartConversion(ADDR_LTC2497, adcChannel);
  // Make sure the result is valid!
  if(!LTC2497_ReadConversion(ADDR_LTC2497, adcChannel, &result)) {
    result = CONVER_FAC1;
  }
  adc_value = ((float)((result) + CONVER_FAC1) * (float)(EXT_VREF / CONVER_FAC2));
  adc_value = (adc_value * adc2mscb_table[adcChannel].Coef + adc2mscb_table[adcChannel].Offst);

  DISABLE_INTERRUPTS;
  if(adc2mscb_table[adcChannel].current) {
    user_data.IBMon[adc2mscb_table[adcChannel].mscbIdx] = adc_value;
    user_data.rIBMon[adc2mscb_table[adcChannel].mscbIdx] = result;
  } else {
    user_data.VBMon[adc2mscb_table[adcChannel].mscbIdx] = adc_value;
    user_data.rVBMon[adc2mscb_table[adcChannel].mscbIdx] = result;
  }
  ENABLE_INTERRUPTS;

  adcChannel++;
  adcChannel %= N_RB_CHANNEL;

#endif

  //-----------------------------------------------------------------------------
  // External ADC for REV1 cards
  // Increment channel per user_loop
#ifdef _LTC2495_

  LTC2495_StartConversion(ADDR_LTC2495, adcChannel, adc2mscb_table[adcChannel].gain);

  if(!LTC2495_ReadConversion(ADDR_LTC2495, adcChannel, &result, adc2mscb_table[adcChannel].gain)) {
    result = -CONVER_FAC1;
  }

  adc_value = ((float)((result - adc2mscb_table[adcChannel].Offst)) * (float)(EXT_VREF / CONVER_FAC2));
  adc_value = (adc_value * adc2mscb_table[adcChannel].Coef) ;
  //dividing by the gain
  adc_value /= pow(2, (adc2mscb_table[adcChannel].gain + adc2mscb_table[adcChannel].current));
  DISABLE_INTERRUPTS;
  if(adc2mscb_table[adcChannel].current) {
    user_data.IBMon[adc2mscb_table[adcChannel].mscbIdx] = adc_value;
    user_data.rIBMon[adc2mscb_table[adcChannel].mscbIdx] = result;
  } else {
    user_data.VBMon[adc2mscb_table[adcChannel].mscbIdx] = adc_value;
    user_data.rVBMon[adc2mscb_table[adcChannel].mscbIdx] = result;
  }
  ENABLE_INTERRUPTS;

  adcChannel++;                 // increment channel
  adcChannel %= N_RB_CHANNEL;   // modulus 16

#endif

  //-----------------------------------------------------------------------------
  // Checking switches flag for toggling the switches
#ifdef _PCA9539_
  if(PCA_Flag) {
    swConversion = user_data.swBias;
    PCA9539_Conversion(&swConversion);
    PCA9539_WriteByte(BIAS_WRITE, ~swConversion);
    PCA_Flag = CLEAR;
  }
#endif

  //-----------------------------------------------------------------------------
  // Checking DAC charge pump flag for adjusting the charge pump voltage
#ifdef _LTC1669_
  if(LTC1669_Flag) {
    LTC1669_SetDAC(ADDR_LTC1669, LTC1669_INT_BG_REF, user_data.rQpump);
    LTC1669_Flag = CLEAR;
  }
#endif

  //-----------------------------------------------------------------------------
  // Power Up based on CTL bit
  if (CPup) {
    rCSR = user_data.status;
    rESR = 0x0000;   // Reset error status at each Power UP
    // Clear Status
    SsS = OFF;
    DISABLE_INTERRUPTS;
    user_data.status  = rCSR;
    user_data.error   = rESR;
    ENABLE_INTERRUPTS;
    // Power up Card
    switchonoff(ON);
    delay_ms(100);
    // Force Check on Voltage during loop
    bCPupdoitNOW = ON;
    // Wait for Check before setting SPup
    // Reset Action
    CPup = CLEAR;  // rCTL not updated yet, publish state after U/I check
  } // Power Up

#ifdef _ADT7486A_
  //-----------------------------------------------------------------------------
  // Temperature reading/monitoring based on time for internal temperature
  // Board Temperature
  if ( bCPupdoitNOW || ((uptime() - sstTime) > SST_TIME)) {

    for (channel=0;channel < NCHANNEL_ADT7486A; channel++) {
      if(!ADT7486A_Cmd(ADT7486A_addrArray[channel], GetIntTemp, SST_LINE1, &temperature)) {
         RdssT = CLEAR;
        if (temperature > eepage.uuCTlimit) IntssTT = ON;
        PublishVariable(&(user_data.ssTemp[channel]), temperature, IntssTT);
      } else publishErr(RdssT);
    }  // For loop
    sstTime = uptime();
  }  // Internal temperature

  yield();

  //-----------------------------------------------------------------------------
  // Temperature reading/monitoring based on time for external temperature
  // FGD Temperature
  if (bCPupdoitNOW || ((uptime() - sstExtTime) > SST_TIME)) {

    for (channel=0;channel < NCHANNEL_ADT7486A; channel++) {
      if(!ADT7486A_Cmd(ADT7486A_addrArray[channel], GetExt1Temp, SST_LINE1, &temperature)) {
        RdssT = CLEAR;
        if (temperature > eepage.uSSTlimit) ExtssTT = ON;
        PublishVariable(&(user_data.Temp[(channel*2)]), temperature, ExtssTT);
      } else publishErr(RdssT);
    } // For loop 1

    for (channel=0;channel < NCHANNEL_ADT7486A; channel++) {
      if(!ADT7486A_Cmd(ADT7486A_addrArray[channel], GetExt2Temp, SST_LINE1, &temperature)) {
        RdssT = CLEAR;
        if (temperature > eepage.uSSTlimit) ExtssTT = ON;
        PublishVariable(&(user_data.Temp[(channel*2)+1]), temperature, ExtssTT);
      } else publishErr(RdssT);
    }  // For loop 2

   yield();
 
  //-----------------------------------------------------------------------------
  // Local board temperature reading (top board, ADC
  rCSR = user_data.status;
  if (SPup) {
    pcbssTT = OFF;
    if(!ADT7486A_Cmd(ADT7486A_ADDR4, GetExt1Temp, SST_LINE2, &temperature)) {
      RdssT = CLEAR;
      if (temperature > eepage.uuCTlimit) pcbssTT = ON;
//      if (pcbssTT) sprintf (user_data.warning, "Last Trip ASIC Temp: %6.3f [%6.3f]", temperature, eepage.uuCTlimit);
      PublishVariable(&(user_data.afterTemp), temperature, pcbssTT);
    } else publishErr(RdssT);

    if(!ADT7486A_Cmd(ADT7486A_ADDR4, GetExt2Temp, SST_LINE2, &temperature)) {
      RdssT = CLEAR;
      if (temperature > eepage.uuCTlimit) pcbssTT = ON;
//      if (pcbssTT) sprintf (user_data.warning, "Last Trip ADC Temp: %6.3f [%6.3f]", temperature, eepage.uuCTlimit);
      PublishVariable(&(user_data.adcTemp), temperature, pcbssTT);
    } else publishErr(RdssT);

    if(!ADT7486A_Cmd(ADT7486A_ADDR4, GetIntTemp, SST_LINE2, &temperature)) {
      RdssT = CLEAR;
      if (temperature > eepage.uuCTlimit) pcbssTT = ON;
//      if (pcbssTT) sprintf (user_data.warning, "Last Trip Vreg Temp: %6.3f [%6.3f]", temperature, eepage.uuCTlimit);
      PublishVariable(&(user_data.regTemp), temperature, pcbssTT);
    } else publishErr(RdssT);
  }  // SPup
//-PAA remove code to prevent overwriting the temp in case the power is off due to over limit.
//  else {
//    PublishVariable(&(user_data.adcTemp), -128.0, pcbssTT);
//    PublishVariable(&(user_data.afterTemp), -128.0, pcbssTT);
//    PublishVariable(&(user_data.regTemp), -128.0, pcbssTT);
//  }  // Not SPup

  // ext Temp error not yet published...
  sstExtTime = uptime();
} // External Temperature
#endif

  //-----------------------------------------------------------------------------
  // Periodic check and After power up
  // uCtemperature, Voltage and Current readout
  if ( bCPupdoitNOW || ((uptime() - currentTime) > 1)) {
    //-----------------------------------------------------------------------------
    // uC Temperature reading/monitoring based on time
    // Read uC temperature, set error if temp out of range
    volt = read_voltage(TCHANNEL, &rvolt, 0, 0, IntGAIN1 );
    /* convert to deg. C */
    temperature = 1000 * (volt - 0.776) / 2.86;   // Needs calibration
    /* strip to 0.1 digits */
    temperature = ((int) (temperature * 10 + 0.5)) / 10.0;
    if ((temperature < eepage.luCTlimit) || (temperature > eepage.uuCTlimit)) uCT = ON; // out of range
    PublishVariable(&(user_data.uCTemp), temperature, uCT);

    //-----------------------------------------------------------------------------
    // Internal ADCs monitoring Voltages and Currents based on time
    // All U/I except Qpump, set error if value out of range
    pfData  = &(user_data.VBias);
    rpfData = &(user_data.rVBias);
    // Skip Current limit check if Ccurrent has been set (rCTL:0x4)
    for (channel=0 ; channel<INTERNAL_N_CHN ; channel++) {
      volt = read_voltage(channel, &rvolt, iadc_table[channel].coeff
                                         , iadc_table[channel].offset
                                         , iadc_table[channel].gain );
      DISABLE_INTERRUPTS;
      pfData[channel] = volt;
      rpfData[channel] = rvolt;
      ENABLE_INTERRUPTS;
      mask = (1<<channel); 

      // Check for Qpump Voltage ON (> 40V), set error if value out of range
      if (channel == 0)
        if ((volt < eepage.lVIlimit[channel])) SqPump = OFF;
        else SqPump = ON;

      // Skip the first two channels(charge pump)
      if ((channel > 1)) {  // Skip vQ, I
        if ((volt < eepage.lVIlimit[channel]) || (volt > eepage.uVIlimit[channel])) {
           rESR |= mask; // out of range
           sprintf (str, "Last Trip: %6.3f [%6.3f /", volt, eepage.lVIlimit[channel]);
//           sprintf(user_data.warning, "%s%6.3f] (min/max)", str, eepage.uVIlimit[channel]);
        }
      } // skip v/iQ channel
    }  // for loop

    // U/I error not yet published ...

    // update time for next loop
    currentTime = uptime();
  }  // Voltage, Current & Temperature test

  //-----------------------------------------------------------------------------
  // Finally take action based on ERROR register
  if (rESR & (VOLTAGE_MASK | BTEMPERATURE_MASK | CURRENT_MASK)) {   // 
    SPup = SqPump = OFF;
    switchonoff(OFF);
    SsS = ON;
  } else if (bCPupdoitNOW) {
    bCPupdoitNOW = OFF;   // Reset flag coming from PowerUp sequence
    SsS = SmSd = OFF;
    LTC2600_Flag = LTC1665_Flag = bDacdoitNOW = ON; // Allow & force DACs reload
    SPup = ON; // Set status ON
  }

  // Publish Control, Error and Status for all the bdoitNOW actions.
  publishAll();

  //-----------------------------------------------------------------------------
  // Checking ASUM flag for updating the asum values
#ifdef _LTC2600_
  rCSR = user_data.status;    
  if(SPup && LTC2600_Flag) {
    for(ltc2600_index=0; ltc2600_index < 8; ltc2600_index++) {
      if(bDacdoitNOW || (ltc2600mirror[ltc2600_index] != user_data.rAsum[ltc2600_index])) {
        LTC2600_Cmd(WriteTo_Update, LTC2600_LOAD[ltc2600_index], user_data.rAsum[ltc2600_index]);
        ltc2600mirror[ltc2600_index] = user_data.rBias[ltc2600_index];
      }
    }
    LTC2600_Flag = CLEAR;
  }
#endif

  //-----------------------------------------------------------------------------
  // Checking APD flag for updating the APD dacs
#ifdef _LTC1665_
  // Get current status of the Card, don't update DAC in case of no Power, keep flag up
  rCSR = user_data.status;    
  if(SPup && LTC1665_Flag) {
    for(ltc1665_index=0; ltc1665_index<64; ltc1665_index++) {
      if(bDacdoitNOW || (ltc1665mirror[ltc1665_index] != user_data.rBias[ltc1665_index])) {
        ltc1665_chipChan = (ltc1665_index / 8) + 1;
        ltc1665_chipAdd  = (ltc1665_index % 8) + 1;
        LTC1665_Cmd(ltc1665_chipAdd, user_data.rBias[ltc1665_index] , ltc1665_chipChan);
        ltc1665mirror[ltc1665_index] = user_data.rBias[ltc1665_index];
      }
    }
    //LTC1665_Cmd(chipAdd,user_data.rBias[BiasIndex] ,chipChan);
    LTC1665_Flag = CLEAR;
  }
#endif

  //
  // Reset the force DAC setting when coming from CPup or Restore 
  bDacdoitNOW = OFF;

  //-----------------------------------------------------------------------------
  // Set Manual Shutdown based on Index
  if (CmSd) {
    rCSR = user_data.status;
    SmSd = ON;  // Set Manual Shutdown
    pca_operation(Q_PUMP_OFF);
    switchonoff(OFF);
    SPup = SqPump = OFF;   // Clear Qpump and card status
    CmSd = CLEAR;          // Reset action
    publishCtlCsr();       // Publish Registers state
  } // Manual Shutdown

  //-----------------------------------------------------------------------------
  // Toggle  Asum counter ON/OFF based on Index
  if (CAsum) {
    if (ASUM_TESTN) ASUM_TESTN = OFF;
    else            ASUM_TESTN = ON;
    SAsum = ASUM_TESTN;   // Set status based on port pin state
    CAsum = CLEAR;        // Reset Action
    publishCtlCsr();      // Publish Registers state
  } // Asum

  //-----------------------------------------------------------------------------
  // Checking the eeprom control flag
  if (EEP_CTR_Flag) {
    //Checking for the special instruction
    if (user_data.eeCtrSet & EEP_CTRL_KEY) {
      // Valid index range
      if( (int)(user_data.eeCtrSet & 0x000000ff) >= EEP_RW_IDX) {
        // Float area from EEP_RW_IDX, count in Float size, No upper limit specified!
        eep_address = (float*)&eepage + (user_data.eeCtrSet & 0x000000ff);
        //Checking for the write request
        if (user_data.eeCtrSet & EEP_CTRL_WRITE){
          *eep_address = user_data.eepValue;  // Copy user_data into eepage structure
          //Checking for the read request
        } else if (user_data.eeCtrSet & EEP_CTRL_READ) {
          DISABLE_INTERRUPTS;
          user_data.eepValue = *eep_address;  // Publish eep value in user_data
          ENABLE_INTERRUPTS;
        } else {
          // Tell the user that inappropriate task has been requested
          DISABLE_INTERRUPTS;
          user_data.eeCtrSet = EEP_CTRL_INVAL_REQ;
          ENABLE_INTERRUPTS;
        }
      } else {
        DISABLE_INTERRUPTS;
        user_data.eeCtrSet = EEP_CTRL_OFF_RANGE;
        ENABLE_INTERRUPTS;
      }
    } else {
      // Tell the user that invalid key has been provided
      DISABLE_INTERRUPTS;
      user_data.eeCtrSet = EEP_CTRL_INVAL_KEY;
      ENABLE_INTERRUPTS;
    }
    EEP_CTR_Flag = CLEAR;
  }  // if eep

  //-----------------------------------------------------------------------------
  // EEPROM Save procedure based on CTL bit
#ifdef _ExtEEPROM_
  if (CeeS) {
    // Check if we are here for the first time
    if (!eeprom_flag) {  // first in
      rCSR = user_data.status;

      // Update eepage with the current user_data variables
      for(i=0;i<8;i++)  eepage.rasum[i] = user_data.rAsum[i];
      for(i=0;i<64;i++) eepage.rbias[i] = user_data.rBias[i];
      eepage.rqpump = ((unsigned int) user_data.rQpump & 0x3FF);
      eepage.SWbias = user_data.swBias;

      //Temporary store the first address of page
      eeptemp_addr = PageAddr[(unsigned char)(user_data.eepage & 0x07)];
      //Temporary store the first address of data which has to be written
      eeptemp_source = (unsigned char xdata *)&eepage;
    }

    // EEPROM clear request
    if (CeeClr)  eep_request = WRITE_EEPROM;   //---PAA--- WAS CLEAR BUT WILL ERASE EEPROM!
    else         eep_request = WRITE_EEPROM;

    status = ExtEEPROM_Write_Clear (eeptemp_addr
                                         , &eeptemp_source
                                         , PAGE_SIZE
                                         , eep_request
                                         , &eeprom_flag);

    if (status == DONE) {
      SeeS = DONE;
      eeprom_flag = CLEAR;
      CeeS = CLEAR;
      //Set the active page
      user_data.eepage |= ((user_data.eepage & 0x07) << 5);
    } else  SeeS = FAILED;

    publishCtlCsr();      // Publish Registers state
  } // eep Save

  //-----------------------------------------------------------------------------
  // EEPROM Restore procedure based on CTL bit
  if (CeeR) {
    rCSR = user_data.status;
    // Read the active page
    status = ExtEEPROM_Read (PageAddr[(unsigned char)(user_data.eepage & 0x07)]
                          , (unsigned char xdata *) &eepage, PAGE_SIZE);
    if (status == DONE) {
      SeeR = DONE;
 
      // Publish user_data new settings
      DISABLE_INTERRUPTS;
      for(i=0;i<8;i++)  user_data.rAsum[i] = ltc2600mirror[i] = eepage.rasum[i];
      for(i=0;i<64;i++) user_data.rBias[i] = ltc1665mirror[i] = eepage.rbias[i];
      user_data.rQpump = (unsigned int) (eepage.rqpump & 0x3FF);
      user_data.swBias = eepage.SWbias;
      ENABLE_INTERRUPTS;

      LTC2600_Flag = LTC1665_Flag = bDacdoitNOW = ON; // Allow & force DACs reload

      // Update adc2mscb_table[adcChannel].Offst values for current and offset
      updateAdc2Table();
    } else  SeeR = FAILED;

    CeeR = CLEAR;       // Reset action
    publishCtlCsr();    // Publish Registers state
  }  // eep Restore
#endif

  //-----------------------------------------------------------------------------
  // Auto calibration for the iBiasOffset
  if (Ccal) {
    switch (calState) {
    case 10:
      // Check Card ON Qpump ON to start with:
      rCSR = user_data.status;
      if (SPup && SqPump && (user_data.swBias == 0xff)) {
        Scal = ON;
        // Publish Registers state
        DISABLE_INTERRUPTS;
        user_data.status  = rCSR;
        ENABLE_INTERRUPTS;
        calState = 15;
      } else { 
        SeeS = CLEAR;
        Ccal = CLEAR;
        Scal = OFF;
        calState = 0;   // unknown state
        // Publish Registers state
        publishCtlCsr();
      }
      break;
    case 15:
      // Remember previous rQpump & Switch and set Cal value
      calQpumpSave = user_data.rQpump;
      calSwSave    = user_data.swBias;
#ifdef _LTC1669_
      LTC1669_SetDAC(ADDR_LTC1669, LTC1669_INT_BG_REF, eepage.calQpump);
#endif
      // Reset eePage Offset array
      for (k=0;k<8;k++) eepage.iBiasOffset[k] = 0.0;
      calState = 30;
      // Reset calTime to current time
      calTime = uptime();
      break;
    case 30:
      // Wait 10 seconds
      if ((uptime() - calTime) > 10) {
        calCount = 0;
        calState = 40;
      }
      break;
    case 40:
      // Read Offset N times
      if (calCount < calNumber) {
        if (adcChannel == 0) {
          calCount++;
          for (k=0;k<8;k++) eepage.iBiasOffset[k] += (float) user_data.rIBMon[k];
        }
      } else calState = 50;
      break;
    case 50:
      // Compute average
      for (k=0;k<8;k++) {
        ftemp = eepage.iBiasOffset[k] / calNumber;
        eepage.iBiasOffset[k] = ftemp;
      }
      // Update ADC Table
      updateAdc2Table();
      calState = 60;
      break;
    case 60:
      // Restore Qpump value
#ifdef _LTC1669_
      LTC1669_SetDAC(ADDR_LTC1669, LTC1669_INT_BG_REF, calQpumpSave);
#endif
      // Clear the Calibration command
      Ccal = CLEAR;
      calState = 0;   // unknown state
      Scal = OFF;
      // eepage written to EEprom
      CeeS = ON;
      // Publish Registers state
      publishCtlCsr();
      break;
    default:
      break;
    }
    DISABLE_INTERRUPTS;
    SFRPAGE = SMB0_PAGE;
    user_data.debugsmb = SMB0STA;
    ENABLE_INTERRUPTS;
  }  // Calibration

  //-----------------------------------------------------------------------------
  // General loop delay
  DISABLE_INTERRUPTS;
  user_data.debugsmb = smbdebug;
  ENABLE_INTERRUPTS;
  timing=0;
  delay_ms(10);

}  // End of User loop

unsigned char user_read

(

unsigned char

index

)

{
  if (index == 0) {
  }
  return 0;
}

void user_write

(

unsigned char

index

)

{

  // In case of you changing common control bit (ex. EXT/IN switch bit)
  // the change should be distributed to other channels.
  rCSR = user_data.status;
  if (index == IDXCTL) {
    rCTL = user_data.control;
    if (Ccal) calState = 10;
  } // IDXCTL

  //
  // -- Index Bias Dac
  if (index == IDXBSWITCH) {
#ifdef _PCA9539_
    if (!SsS) PCA_Flag = 1;  // !Shutdown
#endif
  }

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

  // -- ASUM Threshold DACs
  if ((index >= FIRST_ASUM) && (index < LAST_ASUM)) {
#ifdef _LTC2600_
    // Update Bias Dac voltages as requested by bit5 of control register
    if (!SsS) LTC2600_Flag = 1;  // !Shutdown
#endif
  }
  //
  // -- Index Bias Dac
  if ((index >= FIRST_BIAS) && (index < LAST_BIAS)) {
#ifdef _LTC1665_
    if (!SsS) LTC1665_Flag = 1;  // Shutdown
#endif
  }
  //
  // --- Index Qpump DAC
#ifdef _LTC1669_  //SqPump && 
  if((index == IDXQVOLT) && !SsS) LTC1669_Flag = 1;   // Qpump on and !Shutdown
#endif

  //
  // --- ASum Hidden Register
  if (index == IDXASUM_CTL) {
    //-PAA- At boot the Sync is high for 1sec while power is up
    // to shutdown sync w 145 0x4
    // to restart       w 145 0x5 (Sync + pwd)
    //                  w 145 0x4 (sync = 0)
    ASUM_SYNC   =  user_data.asumCtl & 0x1;
    ASUM_TESTN  = (user_data.asumCtl & 0x2) >> 1;
    ASUM_PWDN   = (user_data.asumCtl & 0x4) >> 2;
  }
}

---

Variable Documentation

unsigned char idata _n_sub_addr = 1

sbit ASUM_PWDN = P1 ^ 5

sbit ASUM_SYNC = P1 ^ 7

sbit ASUM_TESTN = P1 ^ 6

unsigned char xdata AsumIndex

unsigned char bdata bChange

sbit bCPupdoitNOW = bChange ^ 0

sbit bDacdoitNOW = bChange ^ 1

unsigned char xdata BiasIndex

int xdata calCount = 0

float xdata calNumber = 10.0

char xdata calQpumpSave = 0

int xdata calState = 0

char xdata calSwSave = 0

unsigned long xdata calTime = 0

sbit CAsum_Flag = bChange ^ 7

unsigned char xdata channel

unsigned char xdata chipAdd

unsigned char xdata chipChan

unsigned long xdata currentTime = 0

sbit DACRESETN = P1 ^ 0

sbit EEP_CTR_Flag = bChange ^ 6

int xdata k

sbit LTC1665_Flag = bChange ^ 4

sbit LTC1669_Flag = bChange ^ 5

sbit LTC2600_Flag = bChange ^ 3

char code node_name[] = "FEB64"

unsigned char xdata NodeOK = 0

sbit PCA_Flag = bChange ^ 2

sbit PCARESETN = P1 ^ 2

sbit REG_EN = P3 ^ 2

unsigned long xdata sstExtTime = 0

unsigned long xdata sstTime = 0

unsigned char xdata status

char idata svn_rev_code[] = "$Rev: 1185 $"

SYS_INFO sys_info

MSCB_INFO_VAR* variables = vars

MSCB_INFO_VAR code vars[]

---