Master_BMS/BMS Master/Sources/BMS_CAN0_gen_test_data.c

/*
 * BMS_CAN0_gen_test_data.c
 * @brief functions to generate fake values to test startup and error routines without actual CAN commuication
 *  Created on: May 17, 2016
 *      Author: uacqk
 */



#include "BMS_Master.h"
/*
 * @brief function to generate a fake slave with fake data
 * @param s pointer to fake slave structure
 * @param default_voltage voltage to initialize cells
 * @param default_temperature to initialize cells
 * @param default_UBat voltage measured by UI-Board
 * @param default_UBat current measured by UI-Board
 */
void gen_data_initSlave(MASTER_CAN0_STRUCT_t* s, uint16_t default_voltage, int8_t default_temperature, uint16_t default_Ubat, uint16_t default_Ibat) {
	uint8_t slaveNr=0;
	uint8_t cellNr=0;
	uint8_t telegramNr=0;
	BMS_CAN0_SLAVE_t* Slave;
	for(slaveNr=0;slaveNr<CAN0_MAX_NR_OF_SLAVES;slaveNr++) {
		Slave=&(s->Slave[slaveNr]);
		for(cellNr=0;cellNr<MAX_SLAVE_CELLS;cellNr++) {
			Slave->CellVoltage[cellNr]=default_voltage;
			Slave->CellTemp[cellNr]=default_temperature;
		}
		for(telegramNr=0;telegramNr<CAN0_NR_OF_TELEGRAMS;telegramNr++) {
			Slave->SlaveAliveCnt[telegramNr]=0;
		}
		Slave->HeatSinkTemp=default_temperature;
		Slave->Set_Mode=BMS_SLAVE_RUN;
		Slave->SlaveError=0;
		Slave->SlaveMode=BMS_SLAVE_RUN;
		Slave->MuxCounter=0;

	}
	s->UI_Board.Checksum=0;
	s->UI_Board.Ubatt=default_Ubat;
	s->UI_Board.Ibatt=default_Ibat;		
}

void gen_data_setUbatt(MASTER_CAN0_STRUCT_t* s) {
	uint8_t slaveNr=0;
	BMS_CAN0_SLAVE_t* Slave;
	uint16_t Uges=0;
	uint8_t cellNr=0;
	for(slaveNr=0;slaveNr<CAN0_MAX_NR_OF_SLAVES-1;slaveNr++){
		
		if(s->Slave[slaveNr].SlaveConnectionState != NOT_CONNECTED) {
			Slave=&(s->Slave[slaveNr]);
			for(cellNr=0;cellNr<MAX_SLAVE_CELLS;cellNr++) {
				if(Slave->CellConnectionState[cellNr]==CELL_CONNECTED) {
					Uges+=Slave->CellVoltage[cellNr];
				}
			}
		}
	}
	s->UI_Board.Ubatt=Uges;
}

/*
 * @brief function to fill CAN RX Buffer 0 with test data
 * @param	s pointer to test data
 * @param   rx_ptr pointer to data receive Buffer
 */
void gen_data_generate_CAN0_RX0_Telegram(BMS_CAN0_SLAVE_t* Slave,SLAVE_X0_5_BMS_TELEGRAM* rx_ptr) {


	rx_ptr->SlaveAlive=(Slave->SlaveAliveCnt[0]);
	rx_ptr->Vcell0=Slave->CellVoltage[0] >> 3;
	rx_ptr->Vcell1=Slave->CellVoltage[1];
	rx_ptr->Vcell2=Slave->CellVoltage[2];
	rx_ptr->Vcell3=Slave->CellVoltage[3];
}

/*
 * @brief function to fill CAN RX Buffer 0 with test data
 * @param	s pointer to test data
 * @param   rx_ptr pointer to data receive Buffer
 */
void gen_data_generate_CAN0_RX1_Telegram(BMS_CAN0_SLAVE_t* Slave,SLAVE_X0_5_BMS_TELEGRAM* rx_ptr) {
	rx_ptr->SlaveAlive=Slave->SlaveAliveCnt[1];
	rx_ptr->Vcell0=Slave->CellVoltage[4] >> 3;
	rx_ptr->Vcell1=Slave->CellVoltage[5];
	rx_ptr->Vcell2=Slave->CellVoltage[6];
	rx_ptr->Vcell3=Slave->CellVoltage[7];
}
/*
 * @brief function to fill CAN RX Buffer 0 with test data
 * @param	s pointer to test data
 * @param   rx_ptr pointer to data receive Buffer
 */
void gen_data_generate_CAN0_RX2_Telegram(BMS_CAN0_SLAVE_t* Slave,SLAVE_X0_5_BMS_TELEGRAM* rx_ptr) {
	rx_ptr->SlaveAlive=Slave->SlaveAliveCnt[2];
	rx_ptr->Vcell0=Slave->CellVoltage[8] >> 3;
	rx_ptr->Vcell1=Slave->CellVoltage[9];
	rx_ptr->Vcell2=Slave->CellVoltage[10];
	rx_ptr->Vcell3=Slave->CellVoltage[11];
}
/*
 * @brief function to fill CAN RX Buffer 0 with test data
 * @param	s pointer to test data
 * @param   rx_ptr pointer to data receive Buffer
 */
void gen_data_generate_CAN0_RX3_Telegram(BMS_CAN0_SLAVE_t* Slave,SLAVE_X0_5_BMS_TELEGRAM* rx_ptr) {
	rx_ptr->SlaveAlive=Slave->SlaveAliveCnt[3];
	rx_ptr->Vcell0=Slave->CellVoltage[12]>> 3;
	rx_ptr->Vcell1=Slave->CellVoltage[13];
	rx_ptr->Vcell2=Slave->CellVoltage[14];
	rx_ptr->Vcell3=Slave->CellVoltage[15];
}

/*
 * @brief function to fill CAN RX Buffer 0 with test data
 * @param	s pointer to test data
 * @param   rx_ptr pointer to data receive Buffer
 */
void gen_data_generate_CAN0_RX4_Telegram(BMS_CAN0_SLAVE_t* Slave,SLAVE_X0_5_BMS_TELEGRAM* rx_ptr) {
	rx_ptr->SlaveAlive=Slave->SlaveAliveCnt[4];
	rx_ptr->Vcell0=Slave->CellVoltage[16]>> 3;
	rx_ptr->Vcell1=Slave->CellVoltage[17];
	rx_ptr->Vcell2=Slave->CellVoltage[18];
	rx_ptr->Vcell3=Slave->CellVoltage[19];
}

/*
 * @brief function to fill CAN RX Buffer 0 with test data
 * @param	s pointer to test data
 * @param   rx_ptr pointer to data receive Buffer
 */
void gen_data_generate_CAN0_RX5_Telegram(BMS_CAN0_SLAVE_t* Slave,SLAVE_X0_5_BMS_TELEGRAM* rx_ptr) {
	rx_ptr->SlaveAlive=Slave->SlaveAliveCnt[5];
	rx_ptr->Vcell0=Slave->CellVoltage[20]>> 3;
	rx_ptr->Vcell1=Slave->CellVoltage[21];
	rx_ptr->Vcell2=Slave->CellVoltage[22];
	rx_ptr->Vcell3=Slave->CellVoltage[23];
}

void gen_data_generate_CAN0_RX6_Telegram(BMS_CAN0_SLAVE_t* Slave,SLAVE_X6_BMS_TELEGRAM* rx_ptr) {
	rx_ptr->SlaveAlive=Slave->SlaveAliveCnt[6];
	rx_ptr->SlaveError=Slave->SlaveError;
	rx_ptr->SlaveMode=Slave->SlaveMode;
}

void gen_data_generate_CAN0_RX7_Telegram(BMS_CAN0_SLAVE_t* Slave,SLAVE_X7_BMS_TELEGRAM* rx_ptr) {
	uint8_t MuxCounter=rx_ptr->MuxCounter;
	rx_ptr->SlaveAlive=Slave->SlaveAliveCnt[7];
	rx_ptr->TempHeatSink=Slave->HeatSinkTemp;
	rx_ptr->TempSens0=Slave->CellTemp[MuxCounter*4+0];
	rx_ptr->TempSens1=Slave->CellTemp[MuxCounter*4+1];
	rx_ptr->TempSens2=Slave->CellTemp[MuxCounter*4+2];
	rx_ptr->TempSens3=Slave->CellTemp[MuxCounter*4+3];	                            
}



void gen_data_generate_CAN0_UI_Telegram(BMS_CAN0_SLAVE_t* Slave,BMS_CAN0_UI_t* UI_Board,SLAVE_UI_BMS_TELEGRAM* rx_ptr){
	rx_ptr->Checksum=UI_Board->Checksum;
	rx_ptr->Ibatt=UI_Board->Ibatt;
	rx_ptr->Ubatt=UI_Board->Ubatt;
	rx_ptr->UIAlive=Slave->SlaveAliveCnt[0];
	rx_ptr->UIMode=Slave->SlaveMode;

}