BMS_Slave/ProjectSource/BMS_Slave_RCT/BMS_CAN.c

/*********************************************************************
 *
 *                  BMS_CAN File
 *
 *********************************************************************
 * FileName:        BMS_CAN.c
 * Processor:       PIC18F45K80
 * Compiler:        Microchip C18 v3.41
 * Company:         KIT - CN - IPE
 *
 * Author           Date         Comment
 *~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 * Reiling V.       04.04.2012   Release
 * Reiling V.       24.05.2012   Change CAN_Init() Input Parameter
 *                               Add CAN_Rx_Overrun, CAN_Rx_Passiv,
 *                               CAN_Rx_Warning, CAN_Tx_Passiv,
 *                               CAN_Tx_Warning;
 * Reiling V.       30.05.2012   TimeOut for Tx and Rx implemented
 * Reiling V.       07.11.2012   All Temp. transmit CAN_ID 0x402 add
 *
 *********************************************************************/

#include "BMS_Slave.h"


/*********************************************************************
*
*                             Globals
*
*********************************************************************/
static CAN_MAILBOX gCAN_MAILBOX[11];
static uint8_t     gCAN_Data[8];
static uint8_t     gCAN_Rx_Overrun;
extern SERIAL_NR_t  gSerial;
extern uint8_t  STATE_STATUS;
extern uint16_t gEvent;
extern uint16_t adc_value;
ERROR_flags gERROR = {0,0,0,0,0,0,0};




/*********************************************************************
 * Function:        void CAN_Init( CAN_CONFIG *config )
 *
 * Overview:        API Function
 *                  Use this function to initialize ECAN module
 *
 * PreCondition:    None
 *
 * Input:           config
 *
 * Output:          return: CAN_OK / CAN_NOK
 *
 * Side Effects:    change CAN_Mailbox
 **********************************************************************/
int8_t CAN_Init( CAN_CONFIG *config )
{
    // Enter CAN module into config mode
    ECANSetOperationMode(ECAN_OP_MODE_CONFIG);

    // Enter CAN module into Mode 1
    ECANSetFunctionalMode(ECAN_MODE_1);

    // Initialize CAN Timing
    // 1 Mbps @ 64Mhz
    // BRP = 2, Propagation Delay =1, Phase Segment 1 = 8, Phase Segment 2 = 6
    // SJW = 1, Multiple bit sampling is on


    BRGCON1 = ((config->SJW-1) << 6) | (config->BRP-1);
    BRGCON2 = (config->PHSEG2_MODE << 7)      | \
              (config->BUS_SAMPLE_MODE << 6)  | \
              ((config->PHSEG1-1) << 3)       | \
              (config->PROPSEG-1);
    BRGCON3 = (config->WAKEUP_MODE << 7)      |
              (config->FILTER_MODE << 6)      |
              (config->PHSEG2-1);
   
    // Setup Programmable buffers
    //  B0 is a receive buffer AND B2,B3,B4,B5 are Transmit buffers
    ECANSetBnTxRxMode(B0, ECAN_BUFFER_RX);

    // Initialize Receive Masks
    //  The first mask is used to accepts 0x100 Master Frame
    ECANSetRXM0Value(0x07FF, ECAN_MSG_STD);

    // Enable Filters
    // Only using first three filters, so the rest can be disabled.
    RXFCON0 = 0;           //First disable all Filters
    RXFCON1 = 0;           //First disable all Filters
    ECANSetRXF0Value(0x100 + config->SlaveNo, ECAN_MSG_STD);        // Master --> SlaveID Frame

    // Assign Filters to Masks
    //  Only two mask are used
    ECANLinkRXF0Thru3ToMask(ECAN_RXM0, 0xFF, 0xFF, 0xFF);


    // Assign Filters to Buffers
    //  Have the first buffer only accept the first filter, the second buffer accept
    //  the second filter, and the third buffer accept the third filter.
    ECANLinkRXF0F1ToBuffer(RXB0, 0xFF);     //Assign Filter 0 to RXB0, and Filter 1 to RXB1
    ECANLinkRXF2F3ToBuffer(0xFF, 0xFF);     //Assign Filter 2 to B0

    // Enable Port C Pin 2 for CAN capture
    CIOCON = 0x20;           //CANCAP on

    // Enter CAN module into normal mode
    ECANSetOperationMode(ECAN_OP_MODE_NORMAL);

    // Set Receive Mode for buffers
    RXB0CON = 0x00;
    RXB1CON = 0x00;
    B0CON   = 0x00;

    Load_Mailbox( config->SlaveNo );

    return CAN_OK;
}



/*********************************************************************
 * Function:        int8_t CAN_Init_Mailbox( CAN_MAILBOX *mbox)
 *
 * Overview:        API Function
 *                  Use this function to initialize CAN Mailbox
 *
 * PreCondition:    None
 *
 * Input:           *mbox
 *
 * Output:          return: CAN_OK / CAN_NOK
 *
 * Side Effects:    change CAN_Mailbox
 **********************************************************************/
int8_t CAN_Init_Mailbox( CAN_MAILBOX *mbox)
{
  uint8_t   i = mbox->BOX_No;

  gCAN_MAILBOX[i].BOX_No            = i;
  gCAN_MAILBOX[i].CAN_Id            = mbox->CAN_Id;
  gCAN_MAILBOX[i].DLC               = mbox->DLC;
  gCAN_MAILBOX[i].ACCEPTANCE_FILTER = mbox->ACCEPTANCE_FILTER;

  return CAN_OK;
}



/*********************************************************************
 * Function:        int8_t CAN_Write( CAN_MAILBOX *mbox, uint8_t *data )
 *
 * Overview:        API Function
 *                  Use this function to write Data to CAN Bus
 *
 * PreCondition:    None
 *
 * Input:           *mbox, *data
 *
 * Output:          return: CAN_OK / CAN_NOK
 *
 * Side Effects:    None
 **********************************************************************/
int8_t CAN_Write( CAN_MAILBOX *mbox, uint8_t *data )
{
  int8_t  CAN_Status_Tx = CAN_NOK;
  uint8_t i=0;

  // 50 Fehlversuche entspricht 5,5ms oder CAN_Tx_Voltage von 8 Slaves
  for(i=0;i<CAN_Tx_TimeOut;i++)
  {
    CAN_Status_Tx = ECANSendMessage( mbox->CAN_Id, data, mbox->DLC, ECAN_TX_STD_FRAME);
    if(CAN_Status_Tx)   // wenn Tx complete
      break;            // break loop

    Delay100TCYx(11);   // loop time ca 0,1ms => 1 CAN Telegramm bei 1MBaud
  }
  return CAN_Status_Tx;
}



/*********************************************************************
 * Function:        int8_t CAN_Read( uint8_t MailBoxNo, uint8_t *data )
 *
 * Overview:        API Function
 *                  Use this function to read Data from CAN Bus
 *
 * PreCondition:    None
 *
 * Input:           *mbox, *data
 *
 * Output:          return: CAN_OK / CAN_NOK
 *
 * Side Effects:    change Data
 **********************************************************************/
int8_t CAN_Read( CAN_MAILBOX *mbox, uint8_t *data )
{
  ECAN_RX_MSG_FLAGS flags;
  int8_t            CAN_Status_Rx = CAN_NOK;

  CAN_Status_Rx = ECANReceiveMessage( &mbox->CAN_Id, data, &mbox->DLC, &flags);
  gCAN_Rx_Overrun = (flags & ECAN_RX_OVERFLOW);
      
  return CAN_Status_Rx;
}



/*********************************************************************
 * Function:        int8_t CAN_Write_Voltage( void )
 *
 * Overview:        Use this function to write Voltage Frames to CAN
 *
 * PreCondition:    None
 *
 * Input:           None
 *
 * Output:          return: CAN_OK / CAN_NOK
 *
 * Side Effects:    None
 **********************************************************************/
int8_t CAN_Write_Voltage( void )
{
  int8_t   i=0;
  int8_t   CAN_Status_Voltage = CAN_NOK;
  int16_t  copyVoltage = 0;

  for(i=0; i<6; i++)                            // loop all 6 Voltage Frame
  {
    copyVoltage = LTC_GetVoltage(4*i+0);
    gCAN_Data[0] = ( (gCounter << 5)& 0xE0 );
    gCAN_Data[0] = ( (gCAN_Data[0]) | (copyVoltage >> 8) );
    gCAN_Data[1] = (copyVoltage & 0xFF);
    copyVoltage  = LTC_GetVoltage(4*i+1);
    gCAN_Data[2] = (copyVoltage >> 8);
    gCAN_Data[3] = (copyVoltage & 0xFF);
    copyVoltage  = LTC_GetVoltage(4*i+2);
    gCAN_Data[4] = (copyVoltage >> 8);
    gCAN_Data[5] = (copyVoltage & 0xFF);
    copyVoltage  = LTC_GetVoltage(4*i+3);
    gCAN_Data[6] = (copyVoltage >> 8);
    gCAN_Data[7] = (copyVoltage & 0xFF);

    // Send one Frame
    CAN_Status_Voltage = CAN_Write( &gCAN_MAILBOX[1+i], &gCAN_Data[0] );
  }

  return CAN_Status_Voltage;
}



/*********************************************************************
 * Function:        int8_t CAN_Write_Temperature( void )
 *
 * Overview:        Use this function to write Temperature Frames to CAN
 *
 * PreCondition:    None
 *
 * Input:           None
 *
 * Output:          return: CAN_OK / CAN_NOK
 *
 * Side Effects:    None
 **********************************************************************/
int8_t CAN_Write_Temperature( void )
{
  LTC_STATUS    LTC_Status;
  int8_t        CAN_Status_Temperature = CAN_NOK;
  int8_t        BoardTemp;

  LTC_GetHeatSink( &LTC_Status );

  BoardTemp = LTC_Status.HeatSinkTemperature;

  if( !((BoardTemp > BAL_TEMP_MIN) && (BoardTemp < BAL_TEMP_MAX)) )
  {
      gERROR.LIMITBOARDTEMP = 1;
  }

  gCAN_Data[0] = (( gCounter << 5 ) + (MuxCounter << 2) );      // formating dataC
  gCAN_Data[1] = BoardTemp;
  gCAN_Data[2] = LTC_GetTemperature(0 + 4 * MuxCounter);
  gCAN_Data[3] = LTC_GetTemperature(1 + 4 * MuxCounter);
  gCAN_Data[4] = LTC_GetTemperature(2 + 4 * MuxCounter);
  gCAN_Data[5] = LTC_GetTemperature(3 + 4 * MuxCounter);
  gCAN_Data[6] = 0;
  gCAN_Data[7] = 0;
 
  // Send first Frame
  CAN_Status_Temperature = CAN_Write( &gCAN_MAILBOX[8], &gCAN_Data[0] );

  return CAN_Status_Temperature;
}

/*********************************************************************
 * Function:        int8_t CAN_Read_Master( void )
 *
 * Overview:        Use this function to read Data from Master
 *
 * PreCondition:    None
 *
 * Input:           None
 *
 * Output:          return: CAN_OK / CAN_NOK
 *
 * Side Effects:    None
 **********************************************************************/
int8_t CAN_Read_Master( void )
{
  uint8_t   data[8];                        // Datenpuffer & Pufferlaenge
  int8_t    CAN_Status = CAN_NOK;

  if(CAN_Read(&gCAN_MAILBOX[0], &data[0]))  // lese CAN aus
  {
      CAN_Status = CAN_OK;
      LATE ^= 1;                              // wenn CAN RX toggle LED_0

      Alive_Master = ( (data[0] & 0xE0) >> 5 );
      SlaveMode = ( data[0] & 0x1F );

      Check_Alive_Master =  Alive_Master;
      Check_Alive_Master++;

      if(Check_Alive_Master >= MAX_ALIVE)
      {
          Check_Alive_Master = 0;
      }
  }

  return CAN_Status;
}
/*********************************************************************
 * Function:        int8_t CAN_Read_Balancing( void )
 *
 * Overview:        Use this function to read Balancing Frames from CAN
 *
 * PreCondition:    None
 *
 * Input:           None
 *
 * Output:          return: CAN_OK / CAN_NOK
 *
 * Side Effects:    change Data
 **********************************************************************/
int8_t CAN_Read_Balancing( void )
{
  uint8_t   data[8];                        // Datenpuffer & Pufferlaenge
  int8_t    CAN_Status_Balancing = CAN_NOK;

  if(CAN_Read(&gCAN_MAILBOX[0], &data[0]))  // lese CAN aus
  {
    CAN_Status_Balancing = CAN_OK;
    PIR5bits.RXBnIF = 0;

    LATE ^= 1;                              // wenn CAN RX toggle LED_0

    Alive_Master = ( (data[0] & 0xE0) >> 5 );
    SlaveMode = ( data[0] & 0x1F );

    if( Alive_Master == Check_Alive_Master)
    {
        Check_Alive_Master++;

    }
    else
    {
        Check_Alive_Master =  Alive_Master;
        Check_Alive_Master++;

        Count_Error_Master++;               // Set Count Error
    }

    if(Check_Alive_Master >= MAX_ALIVE)
    {
        Check_Alive_Master = 0;
    }

    // Balancing
    CAN_BAL = data[3];                      // Build 24 Bit Balancing Flag
    CAN_BAL = (CAN_BAL << 8) + data[2];
    CAN_BAL = (CAN_BAL << 8) + data[1];
  }
  
  return CAN_Status_Balancing;
}

/*********************************************************************
 * Function:        int8_t CAN_Read_System( void )
 *
 * Overview:        Use this function to system initialization
 *
 * PreCondition:    None
 *
 * Input:           None
 *
 * Output:          return: CAN_OK / CAN_NOK
 *
 * Side Effects:    change ID, readout seriescode
 **********************************************************************/
int8_t CAN_Read_System( void )
{
  uint8_t               data[8];                    // Datenpuffer & Pufferlaenge
  uint8_t               IDSEARCH_check = 0x03;      // XOR Checksum for IDSEARCH
  uint8_t               SERNRPRG_check = 0x00;      // XOR Checksum for SERNRPRG
  uint8_t               GETSERNR_check = 0x0E;      // XOR Checksum for GETSERNR
  uint8_t               CHECK_temp = 0;
  int8_t                CAN_Status_System = CAN_NOK;
  uint8_t               DLC = 8;
  uint32_t              id=0;
  ECAN_RX_MSG_FLAGS     flags;
  uint8_t               i;
  uint8_t               DATA_temp[8];

  CAN_Status_System = ECANReceiveMessage( &id, data, &DLC, &flags);
  gCAN_Rx_Overrun = (flags & ECAN_RX_OVERFLOW);

  // Request with ID 0x300 from Master for IDsearch or to programm new Serialcode
  if(id == 0x300)
  {
     // XOR Checksum calculation
     // 'IDSEARCH' => 0x49 ^ 0x44 ^ 0x53 ^ 0x45 ^ 0x41 ^ 0x52 ^ 0x43 ^ 0x48 = 0x03
     // 'SERNRPRG' => 0x53 ^ 0x45 ^ 0x52 ^ 0x4E ^ 0x52 ^ 0x50 ^ 0x4F ^ 0x47 = 0x00
     // 'GETSERNR' => 0x47 ^ 0x45 ^ 0x54 ^ 0x53 ^ 0x45 ^ 0x52 ^ 0x4E ^ 0x52 = 0x0E
     CHECK_temp = data[0] ^ data[1] ^ data[2] ^ data[3] ^ data[4] ^ data[5] ^ data[6] ^ data[7];

     if(CHECK_temp == IDSEARCH_check)
      {
          STATE_STATUS = SYSTEM_IDSEARCH;
          gSerial.EE_BYTE.SLAVE_ID = 0x00;              // Clear Canid
          Load_Mailbox( gSerial.EE_BYTE.SLAVE_ID );     // new slave ID canbox initialization
          ECANSetRXM0Value(0xDF5, ECAN_MSG_STD);        // activate 0x10A and 0x30A Frame
      }
     else if(CHECK_temp == SERNRPRG_check)
     {
         STATE_STATUS = SYSTEM_SERNRPRG;
         ECANSetRXM0Value(0xDF6, ECAN_MSG_STD);        // activate 0x308 and 0x309 Frame
     }
     else if(CHECK_temp == GETSERNR_check)
     {
         STATE_STATUS = SYSTEM_GETSERNR;
     }
  }

switch(STATE_STATUS)
        {
            case SYSTEM_IDSEARCH:
                    // Request with ID 0x10A from Master to reply with ID 0x20A from Slave
                    if(id == 0x10A)
                    {
                        CAN_Write_System();
                    }

                    // Request with ID 0x30A from Master to save the new serialcode and deactivate
                    // the IDs 0x10A and 0x30A
                    if(id == 0x30A)
                    {
                        //Get Data from Master and save to DATA_temp
                        for(i = 0; i < DLC; i++)
                        {
                            DATA_temp[i] = data[i];
                        }

                        if( (gSerial.EE_BYTE.LFT_1  == DATA_temp[0]) &&
                            (gSerial.EE_BYTE.LFT_2  == DATA_temp[1]) &&
                            (gSerial.EE_BYTE.LIEF   == DATA_temp[2]) &&
                            (gSerial.EE_BYTE.EE_REV == DATA_temp[4]) )
                        {
                            Load_Mailbox( DATA_temp[7] );                 // new slave ID canbox initialization
                            ECANSetRXM0Value(0xDFF, ECAN_MSG_STD);        // deactivate 0x10A and 0x30A Frame

                            EEwrite_new(0x0D, DATA_temp[7]);              // write new data to EEPROM

                            // Restart main programm
                            SlaveMode = INITIALISATION_MODE;
                            STATE_STATUS = RUN_SLAVE;
                        }
                    }
            break;
            case SYSTEM_SERNRPRG:
                   // Request with ID 0x308 and 0x309 from System to save the new Serialcode
                    if( (id == 0x308) | (id == 0x309))
                    {
                        //Get Data from Master and save to DATA_temp
                        for(i = 0; i < DLC; i++)
                        {
                            DATA_temp[i] = data[i];
                        }
                        if(id == 0x308)
                        {
                             EEwrite(EE_308_a, &DATA_temp[0] );      // Write initialization data to EEPROM
                        }
                        else if(id == 0x309)
                        {
                            EEwrite(EE_309_a, &DATA_temp[0] );      // Write initialization data to EEPROM

                            // Restart main programm
                            SlaveMode = INITIALISATION_MODE;
                            STATE_STATUS = RUN_SLAVE;
                        }
                    }
            break;
            case SYSTEM_GETSERNR:
                 // Reply with ID 0x2XA from Slave to Master
                CAN_Write_System();

                // Restart main programm
                SlaveMode = INITIALISATION_MODE;
                STATE_STATUS = RUN_SLAVE;

                break;
            default:
            break;
        }

  return CAN_Status_System;
}

/*********************************************************************
 * Function:        int8_t CAN_Write_System( void )
 *
 * Overview:        Use this function to write Serialframe to Master
 *
 * PreCondition:    None
 *
 * Input:           None
 *
 * Output:          return: CAN_OK / CAN_NOK
 *
 * Side Effects:    None
 **********************************************************************/
int8_t CAN_Write_System( void )
{
  int8_t    CAN_Status_System = CAN_NOK;
  uint16_t  DELAY_t = 0;
  uint16_t  i_time = 0;
  uint8_t   Delay_256us = 4;

    gCAN_Data[0]= gSerial.EE_BYTE.LFT_1;
    gCAN_Data[1]= gSerial.EE_BYTE.LFT_2;
    gCAN_Data[2]= gSerial.EE_BYTE.LIEF;
    gCAN_Data[3]= gSerial.EE_BYTE.BAU_1;
    gCAN_Data[4]= gSerial.EE_BYTE.EE_REV;
    gCAN_Data[5]= gSerial.EE_BYTE.FAM_1;
    gCAN_Data[6]= gSerial.EE_BYTE.GERAET;
    gCAN_Data[7]= gSerial.EE_BYTE.LAEN;

    // LFT1(LSB) and LFT2(MSB) to 16 Bit DELAY_t value
    DELAY_t = gSerial.EE_BYTE.LFT_2;
    DELAY_t = DELAY_t << 8;
    DELAY_t = DELAY_t | gSerial.EE_BYTE.LFT_1;
    // Delay_t 0 - 9999 --> 1 - 10000
    DELAY_t++;

    // Generate delay time with 8 Bit Delay1KTCYx(Delay_256us) function
    while(i_time <= DELAY_t )
    {
        Delay1KTCYx(Delay_256us);
        i_time++;
    }
    
    CAN_Status_System = CAN_Write( &gCAN_MAILBOX[9], &gCAN_Data[0] );
  
  return CAN_Status_System;
}



/*********************************************************************
 * Function:        int8_t CAN_Write_Status( void )
 *
 * Overview:        Use this function to write Status Frames to CAN
 *
 * PreCondition:    None
 *
 * Input:           None
 *
 * Output:          return: CAN_OK / CAN_NOK
 *
 * Side Effects:    None
 **********************************************************************/
int8_t CAN_Write_Status( void )
{
  LTC_STATUS  LTC_Status;
  int8_t      CAN_Status_Status = CAN_NOK;

  gERROR.SLAVE_SPI = 0;
  gERROR.SLAVE_TIMING = 0;
  gERROR.SLAVE_HARDWARE = 0;

  LTC_GetStatus( &LTC_Status );                         // read LTC Status

  gERROR.SLAVE_TIMING = (LTC_Status.LTC_StatusSlave & 0x40) >> 6;

  if (LTC_Status.LTC_SelfTest >= 0x0001)
  {
      gERROR.SLAVE_HARDWARE = 1;
  }

  gCAN_Data[0] = 0x00;
  gCAN_Data[0] = (( gCounter << 5 ) + SlaveMode );
  gCAN_Data[1] = 0x00;
  gCAN_Data[1] =  (gERROR.LIMITVOLTAGE << 6);
  gCAN_Data[1] |= (gERROR.SLAVE_SPI << 5);              // Onboard comunication Fail
  gCAN_Data[1] |= (gERROR.SLAVE_TIMING << 4);           // Measure Timing Error
  gCAN_Data[1] |= (gERROR.SLAVE_HARDWARE << 3);         // ADC / MUX / REF Error
  gCAN_Data[1] |= (gERROR.LIMITBOARDTEMP << 2);
  gCAN_Data[1] |= (gERROR.LIMITCELLTEMP << 1);
  gCAN_Data[1] |= (gERROR.LIMITCELLVOLTAGE);
  gCAN_Data[2] = (adc_value >> 8);
  gCAN_Data[3] = (adc_value & 0xFF);
  gCAN_Data[4] = 0;
  gCAN_Data[5] = 0;
  gCAN_Data[6] = 0;
  gCAN_Data[7] = 0;

  // send one Status Frame
  CAN_Status_Status = CAN_Write( &gCAN_MAILBOX[7], &gCAN_Data[0] );

  return CAN_Status_Status;
}



/*********************************************************************
 * Function:        int8_t Load_Mailbox( uint8_t SlaveNo )
 *
 * Overview:        Use this function to initialize all CAN Mailboxes
 *
 * PreCondition:    None
 *
 * Input:           SlaveNo
 *
 * Output:          return: CAN_OK / CAN_NOK
 *
 * Side Effects:    change CAN_Mailbox
 **********************************************************************/
int8_t Load_Mailbox( uint8_t SlaveNo )
{
  gCAN_MAILBOX[0].BOX_No = 0;              // Balancing Frame 1
  gCAN_MAILBOX[0].CAN_Id = 0x100+SlaveNo;
  gCAN_MAILBOX[0].DLC    = 5;
  gCAN_MAILBOX[0].ACCEPTANCE_FILTER = 0x100+SlaveNo;

  gCAN_MAILBOX[1].BOX_No = 1;              // Voltage Frame 1
  gCAN_MAILBOX[1].CAN_Id = 0x200+SlaveNo;
  gCAN_MAILBOX[1].DLC    = 8;
  gCAN_MAILBOX[1].ACCEPTANCE_FILTER = 0;

  gCAN_MAILBOX[2].BOX_No = 2;              // Voltage Frame 2
  gCAN_MAILBOX[2].CAN_Id = 0x201+SlaveNo;
  gCAN_MAILBOX[2].DLC    = 8;
  gCAN_MAILBOX[2].ACCEPTANCE_FILTER = 0;

  gCAN_MAILBOX[3].BOX_No = 3;              // Voltage Frame 3
  gCAN_MAILBOX[3].CAN_Id = 0x202+SlaveNo;
  gCAN_MAILBOX[3].DLC    = 8;
  gCAN_MAILBOX[3].ACCEPTANCE_FILTER = 0;

  gCAN_MAILBOX[4].BOX_No = 4;              // Voltage Frame 4
  gCAN_MAILBOX[4].CAN_Id = 0x203+SlaveNo;
  gCAN_MAILBOX[4].DLC    = 8;
  gCAN_MAILBOX[4].ACCEPTANCE_FILTER = 0;

  gCAN_MAILBOX[5].BOX_No = 5;              // Voltage Frame 5
  gCAN_MAILBOX[5].CAN_Id = 0x204+SlaveNo;
  gCAN_MAILBOX[5].DLC    = 8;
  gCAN_MAILBOX[5].ACCEPTANCE_FILTER = 0;

  gCAN_MAILBOX[6].BOX_No = 6;              // Voltage Frame 6
  gCAN_MAILBOX[6].CAN_Id = 0x205+SlaveNo;
  gCAN_MAILBOX[6].DLC    = 8;
  gCAN_MAILBOX[6].ACCEPTANCE_FILTER = 0;

  gCAN_MAILBOX[7].BOX_No = 7;              // Status Frame
  gCAN_MAILBOX[7].CAN_Id = 0x206+SlaveNo;
  gCAN_MAILBOX[7].DLC    = 8;
  gCAN_MAILBOX[7].ACCEPTANCE_FILTER = 0;

  gCAN_MAILBOX[8].BOX_No = 8;              // Temperature Frame
  gCAN_MAILBOX[8].CAN_Id = 0x207+SlaveNo;
  gCAN_MAILBOX[8].DLC    = 8;
  gCAN_MAILBOX[8].ACCEPTANCE_FILTER = 0;

  gCAN_MAILBOX[9].BOX_No = 8;              // Serialcode Frame
  gCAN_MAILBOX[9].CAN_Id = 0x20A+SlaveNo;
  gCAN_MAILBOX[9].DLC    = 8;
  gCAN_MAILBOX[9].ACCEPTANCE_FILTER = 0;



  return CAN_OK;
}