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

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

Functions
void	publishCtlCsr (void)
void	publishErr (bit errbit)
void	publishAll ()
void	autocalibration (float reference)
int	eepageAddrConvert (unsigned int index)
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
unsigned char idata	_n_sub_addr = 1
char code	node_name [] = "temp36"
char idata	svn_rev_code [] = "$Rev: 1180 $"
bit	EEP_CTR_Flag
bit	LTC2600_Flag
bit	REF_Flag
int xdata *	eep_address
static unsigned char	tcounter
static unsigned char xdata	eeprom_flag = CLEAR
unsigned char xdata	eeprom_wstatus
unsigned char xdata	eeprom_rstatus
unsigned int xdata	eeptemp_addr
unsigned char xdata *	eeptemp_source
unsigned char xdata	eep_request
unsigned char xdata	status
float xdata	humidity
float xdata	htemperature
unsigned int xdata	rSHTtemp1
unsigned int xdata	rSHThumi1
unsigned int xdata	rSHTtemp2
unsigned int xdata	rSHThumi2
unsigned char xdata	FCSorig1
unsigned char xdata	FCSdevi1
unsigned char xdata	FCSorig2
unsigned char xdata	FCSdevi2
unsigned char xdata	cavg = 0
unsigned char idata	channel
unsigned char idata	avgcount
unsigned char idata	numavg = 0
float xdata	average
float xdata	temperature
SYS_INFO	sys_info
MSCB_INFO_VAR code	vars []
MSCB_INFO_VAR *	variables = vars

---

Function Documentation

void autocalibration

(

float

reference

)

{
  float buffer;
  int offset, i;
  for(i=0;i<18; i++){
    //offset channel 2
     buffer=reference-user_data.AT[2*i];
     //Every increment of 16 corresponds to a quarter degree change
     buffer*=4;
     offset=(int)(buffer*16);
    eepage.ext2offset[i]=offset;  
    //offset channel 1
     buffer=reference-user_data.AT[2*i+1];
     //Every increment of 16 corresponds to a quarter degree change
     buffer*=4;
     offset=(int)(buffer*16);   
    eepage.ext1offset[i]=offset;
  }
  return;
}

int eepageAddrConvert

(

unsigned int

index

)

{
  int add;
  //if index is even
  if(!(index%2))
    add = index/2 + 18 + EEP_RW_IDX; // offset from the eepage struct
    //if index is odd
  else
    add = index/2 + EEP_RW_IDX;  // offset from the eepage struct
  return add;
}

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 = SET;
    user_data.error   = rESR;
    ENABLE_INTERRUPTS;
}

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

)

{
   unsigned char idata 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');

  if(init) {}

 // Initial setting for communication and overall ports 
 //-----------------------------------------------------------------------------
 // External EEPROM chip
#ifdef _ExtEEPROM_
   SFRPAGE  = CONFIG_PAGE;
   P2MDOUT |= 0x31; // Setting the RAM_CSn. SPI_MOSI, SPI_SCK to push pull
   P2MDOUT &= 0xFB; // Setting the RAM_WPn to open drain
   ExtEEPROM_Init();

   //Get serial number from write protected area 
   ExtEEPROM_Read  (WP_START_ADDR, (unsigned char xdata *)&eepage ,PAGE_SIZE);
   DISABLE_INTERRUPTS;
   user_data.SerialN = eepage.SerialN;
   ENABLE_INTERRUPTS;

  //Refer to the first Page of the non_protected area
   ExtEEPROM_Read  (PageAddr[0] ,(unsigned char xdata *)&eepage ,PAGE_SIZE);
   DISABLE_INTERRUPTS;
   user_data.navge = eepage.navge;
   ENABLE_INTERRUPTS;

#endif

//
// ADT7486A Init
#ifdef _ADT7486A_
   SFRPAGE  = CONFIG_PAGE;
   P0MDOUT |= 0x18; // Setting the SST_DRV (SST) to push pull
   SFRPAGE  = CPT1_PAGE;
   CPT1CN  |= 0x80; // Enable the Comparator 1
   CPT1MD   = 0x03; //Comparator1 Mode Selection
   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); //Temperature measurements related initialization
   ADT7486A_Init(SST_LINE2); 

// Setting the offset for the temperature sensors
   for (channel=0;channel < 9; channel++){
    // Set the offset for the temp01,03...17 sensors 
    ADT7486A_Cmd(ADT7486A_addrArray[channel]
            , SetExt2Offset
            , (eepage.ext2offset[channel]>>8)
            , eepage.ext2offset[channel]
            , SST_LINE1
            , &temperature);
      delay_us(100); //wait for ADT7486A
   }
   delay_us(300);
   for (channel=9;channel < 18; channel++){
    //Set the offset for the temp19,21...35 sensors
     ADT7486A_Cmd(ADT7486A_addrArray[channel-9]
               , SetExt2Offset
            , (eepage.ext2offset[channel]>>8)
            , eepage.ext2offset[channel]
            , SST_LINE2
            , &temperature);      
      delay_us(100); //wait for ADT7486A
   }                                                                   
   delay_us(300);
   for (channel=0;channel < 9; channel++){
    //Set the offset for the temp02,04...18 sensors
      ADT7486A_Cmd(ADT7486A_addrArray[channel]
               , SetExt1Offset
            , (eepage.ext1offset[channel]>>8)
            , eepage.ext1offset[channel]
            , SST_LINE1
            , &temperature);
      delay_us(100); //wait for ADT7486A
   }
   delay_us(300);
   for (channel=9;channel < 18; channel++){
    //Set the offset for the temp20,22...36 sensors
      ADT7486A_Cmd(ADT7486A_addrArray[channel-9]
               , SetExt1Offset
            , (eepage.ext1offset[channel]>>8)
            , eepage.ext1offset[channel]
            , SST_LINE2
            , &temperature);
    delay_us(100); //wait for ADT7486A
   }
   delay_us(300);
#endif

// User variables initialization
   DISABLE_INTERRUPTS
   user_data.terror[0]=0;
   user_data.terror[1]=0;
   user_data.terror[2]=0;
   user_data.terror[3]=0;
   user_data.terror[4]=0;
   user_data.status=0;
   rCTL = user_data.control=0x4;

  //temporary humidity sensor
  user_data.SHTtemp1 = 0;
  user_data.SHThumi1 = 0;
  user_data.SHTtemp2 = 0;
  user_data.SHThumi2 = 0;

   for (i=0; i<36;i ++)
      user_data.Temp[i] = 0.0;
  user_data.eepage=0;
  user_data.navge=20;
  for(i=0; i<36; i++)
  {
    user_data.AT[i]=0;
  }
  
  user_data.ref=0;

  ENABLE_INTERRUPTS
  // General Variables initialization
  EEP_CTR_Flag = 0;
  rCSR=0;

// Humidity sensor initialization
#ifdef _HUMSEN_
  SFRPAGE  = CONFIG_PAGE;
   P1MDOUT |= 0x07;
  SHT_VDD1=1;
  SHT_GND1=0;
  // Initializing the SHTxx communication
   HumiSensor_Init(humsen1);
#ifdef MORETHANONEHUM
   P3MDOUT |= 0x07;
  SHT_VDD2=1;
  SHT_GND2=0;
  HumiSensor_Init(humsen2);
#endif   
#endif

// DAC initialization
#ifdef _LTC2600_
   SFRPAGE  = CONFIG_PAGE;
   P0MDOUT |= 0x80; // Setting the SUM_DAC_CSn to push pull
   P2MDOUT |= 0x30; // Setting the SPI_MOSI and SPI_SCK to push pull
   LTC2600_Init();
#endif
}

void user_loop

(

void

)

{

#ifdef _ADT7486A_
  // Read the external temperature from each chip that is connected to SST_LINE1
  // Corresponds to Temp01,03,05...17
   for (channel=0;channel < 9; channel++){
      if(!ADT7486A_Cmd(ADT7486A_addrArray[channel]
              , GetExt2Temp
              , SST_LINE1 
              , &temperature)){
         //Clear the bit if there is no error 
         DISABLE_INTERRUPTS;
         user_data.Temp[channel*2] = temperature;
      if(channel<4)
            user_data.terror[0]   &= Terrorclear[2*channel];
      else if(channel<8)
        user_data.terror[1]   &= Terrorclear[2*(channel-4)];
      else 
        user_data.terror[2]   &= Terrorclear[2*(channel-8)];
         ENABLE_INTERRUPTS;
      } else {
      //Set the bit if there is an error
         DISABLE_INTERRUPTS;
      if(channel<4)
            user_data.terror[0]   |= Terrorset[2*channel];
      else if(channel<8)
        user_data.terror[1]   |= Terrorset[2*(channel-4)];
      else 
        user_data.terror[2]   |= Terrorset[2*(channel-8)];
         ENABLE_INTERRUPTS;
      } 
   }

  yield();

  // Read the external temperature from each chip that is connected to SST_LINE2
  // Corresponds to Temp19,21...35
  for (channel=9;channel < 18; channel++){
      if(!ADT7486A_Cmd(ADT7486A_addrArray[channel-9]
              , GetExt2Temp
              , SST_LINE2
              , &temperature)){
         
         DISABLE_INTERRUPTS;
         user_data.Temp[channel*2] = temperature;
      if(channel<12)
            user_data.terror[2]   &= Terrorclear[2*(channel-8)];
      else if(channel<16)
        user_data.terror[3]   &= Terrorclear[2*(channel-12)];
      else 
        user_data.terror[4]   &= Terrorclear[2*(channel-16)];
         ENABLE_INTERRUPTS;
      }
      else{
         DISABLE_INTERRUPTS;
      if(channel<12)
            user_data.terror[2]   |= Terrorset[2*(channel-8)];
      else if(channel<16)
        user_data.terror[3]   |= Terrorset[2*(channel-12)];
      else 
        user_data.terror[4]   |= Terrorset[2*(channel-16)];
         ENABLE_INTERRUPTS;
      }
   }
  

  yield();

   // Read the second external temperature from each chip that is connected to SST_LINE1
   // Corresponds to Temp02,04...18  
   for (channel=0;channel < 9; channel++){
      if(!ADT7486A_Cmd(ADT7486A_addrArray[channel]
              , GetExt1Temp
              , SST_LINE1
              , &temperature)){
         DISABLE_INTERRUPTS;
         user_data.Temp[(channel*2)+1] = temperature;
      if(channel<4)
            user_data.terror[0]   &= Terrorclear[2*channel+1];
      else if(channel<8)
        user_data.terror[1]   &= Terrorclear[2*(channel-4)+1];
      else 
        user_data.terror[2]   &= Terrorclear[2*(channel-8)+1];
         ENABLE_INTERRUPTS;
      }
      else{
         DISABLE_INTERRUPTS;
      if(channel<4)
            user_data.terror[0]   |= Terrorset[2*channel+1];
      else if(channel<8)
        user_data.terror[1]   |= Terrorset[2*(channel-4)+1];
      else 
        user_data.terror[2]   |= Terrorset[2*(channel-8)+1];
         ENABLE_INTERRUPTS;
      }
   }


  yield();

  // Read the second external temperature from each chip that is connected to SST_LINE2
  // Corresponds to Temp20,22,...36
  for (channel=9;channel < 18; channel++){
      if(!ADT7486A_Cmd(ADT7486A_addrArray[channel-9]
              , GetExt1Temp
              , SST_LINE2
              , &temperature)){
         DISABLE_INTERRUPTS;
         user_data.Temp[(channel*2)+1] = temperature;
      if(channel<12)
            user_data.terror[2]   &= Terrorclear[2*(channel-8)+1];
      else if(channel<16)
        user_data.terror[3]   &= Terrorclear[2*(channel-12)+1];
      else 
        user_data.terror[4]   &= Terrorclear[2*(channel-16)+1];
         ENABLE_INTERRUPTS;
      }
      else{
         DISABLE_INTERRUPTS;
      if(channel<12)
            user_data.terror[2]   |= Terrorset[2*(channel-8)+1];
      else if(channel<16)
        user_data.terror[3]   |= Terrorset[2*(channel-12)+1];
      else 
        user_data.terror[4]   |= Terrorset[2*(channel-16)+1];
         ENABLE_INTERRUPTS;
      }
   }


  yield();

   // Calculating the rolling average
   if((user_data.navge <= TAVGMAX) && (user_data.navge != 0)) {
      if(cavg == user_data.navge)
         cavg=1;
      else {
         cavg++;
         if(numavg != user_data.navge) numavg=cavg;
      }

      for(channel=0; channel<36; channel++) {
         Taverage[channel][(cavg-1)] = user_data.Temp[channel];
         average=0;
    
         for(avgcount=0; avgcount<numavg; avgcount++)
            average+=Taverage[channel][avgcount];
         average/=numavg;
         DISABLE_INTERRUPTS;
         user_data.AT[channel]=average;
         ENABLE_INTERRUPTS;
      } 
   }
#endif

#ifdef _ExtEEPROM_
  //-----------------------------------------------------------------------------
  // 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) < TEMPOFF_LAST_INDX) {
        // Float area from EEP_RW_IDX, count in Float size, No upper limit specified!
        eep_address = (int xdata *)&eepage + eepageAddrConvert((int)(user_data.eeCtrSet & 0x000000ff));
        //Checking for the write request
        if (user_data.eeCtrSet & EEP_CTRL_WRITE){
          *eep_address = user_data.eepValue;
        //Checking for the read request
        } else if (user_data.eeCtrSet & EEP_CTRL_READ) {
          DISABLE_INTERRUPTS;
          user_data.eepValue = *eep_address;
          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
  if (CeeS) {
    //Check if we are here for the first time
    if (!eeprom_flag) {  // first in
      rCSR = user_data.status;

      //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 Write/Clear request
    if (CeeClr) eep_request = CLEAR_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;
      //Set the active page
      user_data.eepage |= ((user_data.eepage & 0x07) << 5);
    } else {
      SeeS = FAILED;
    }

    CeeS = CLEAR;
    // Publish Registers state
    publishCtlCsr();
  }

  //-----------------------------------------------------------------------------
  // EEPROM Restore procedure based on CTL bit
  if (CeeR) {
    rCSR = user_data.status;

    //NW read to eepage(active page) instead of eepage2
    channel = ExtEEPROM_Read (PageAddr[(unsigned char)(user_data.eepage & 0x07)]
                                     , (unsigned char xdata *)&eepage, PAGE_SIZE);

    if (channel == DONE) SeeR = DONE;
    else  SeeR = FAILED;

    CeeR = CLEAR;
    publishCtlCsr();   // Publish Registers state
  }
#endif

//-----------------------------------------------------------------------------
// Humidity sensors
#ifdef _HUMSEN_
  //Measuring the humidity and temperature
   if(CHum){
      status = HumidSensor_Cmd (&rSHThumi1
                               ,&rSHTtemp1
                               ,&humidity
                               ,&htemperature
                               ,&FCSorig1
                               ,&FCSdevi1
                               ,humsen1);
      if (status == DONE) {   
        DISABLE_INTERRUPTS;
        user_data.SHThumi1 = humidity;
        user_data.SHTtemp1 = htemperature;
        ENABLE_INTERRUPTS;
      }
  
#ifdef MORETHANONEHUM
      status = HumidSensor_Cmd (&rSHThumi2
                               ,&rSHTtemp2
                               ,&humidity
                               ,&htemperature
                               ,&FCSorig2
                               ,&FCSdevi2
                               ,humsen2);  
      if (status == DONE) {
        DISABLE_INTERRUPTS;  
        user_data.SHThumi2 = humidity;
        user_data.SHTtemp2 = htemperature;
        ENABLE_INTERRUPTS;
      }
#endif // MORETHANONE
   }

#endif // HUMIDITY

#ifdef _LTC2600_
  //DAC
   if(LTC2600_FLAG) {
      LTC2600_Cmd(WriteTo_Update,LTC2600_LOAD[DACIndex], user_data.DAC[DACIndex]);
      LTC2600_FLAG = CLEAR;
   }
#endif
  
  if(Cref) {
    autocalibration(user_data.ref);
    Sref = 1;
    Cref = 0;
    DISABLE_INTERRUPTS;
    user_data.status=rCSR;
    user_data.control=rCTL;
    ENABLE_INTERRUPTS; 
  }

  led_blink(0, 1, 150);

}

unsigned char user_read

(

unsigned char

index

)

{
  if(index);
  return 0;
}

void user_write

(

unsigned char

index

)

{
  if (index == IDXCTL) rCTL = user_data.control;

  if (index == IDXEEP_CTL) EEP_CTR_Flag = SET;

#ifdef _LTC2600_
   if ((index >= First_DACIndex) && (index <= Last_DACIndex)) {
      DACIndex = (index - First_DACIndex);
       // Update Bias Dac voltages as requested by bit5 of control register
      LTC2600_Flag = SET;
   }
#endif

  if(index==IDXNAVG) {
    cavg = 0;
    numavg = 0;
  }   
}

---

Variable Documentation

unsigned char idata _n_sub_addr = 1

float xdata average

unsigned char idata avgcount

unsigned char xdata cavg = 0

unsigned char idata channel

int xdata* eep_address

bit EEP_CTR_Flag

unsigned char xdata eep_request

unsigned char xdata eeprom_flag = CLEAR [static]

unsigned char xdata eeprom_rstatus

unsigned char xdata eeprom_wstatus

unsigned int xdata eeptemp_addr

unsigned char xdata* eeptemp_source

unsigned char xdata FCSdevi1

unsigned char xdata FCSdevi2

unsigned char xdata FCSorig1

unsigned char xdata FCSorig2

float xdata htemperature

float xdata humidity

bit LTC2600_Flag

char code node_name[] = "temp36"

unsigned char idata numavg = 0

bit REF_Flag

unsigned int xdata rSHThumi1

unsigned int xdata rSHThumi2

unsigned int xdata rSHTtemp1

unsigned int xdata rSHTtemp2

unsigned char xdata status

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

SYS_INFO sys_info

unsigned char tcounter [static]

float xdata temperature

MSCB_INFO_VAR* variables = vars

MSCB_INFO_VAR code vars[]

---