Master_BMS/BMS Master/Sources/BMS_Can_ID_init.c

/*
 * BMS_Can_ID_init.c
 *
 *  Created on: Nov 30, 2016
 *      Author: le8041
 */

#include "BMS_Master.h"

/*
 * reads startup config from FRAM and copies it into RAM
 */

uint32_t BMS_Can_ID_init_init_startupConfig (MASTER_CAN0_STRUCT_t* s) {
	uint8_t i;
	uint16_t FRAM_Slave_Can_Id_valid;
	s->startupConfig.state.Bit.SOC_Initialized=FALSE;
	read_fram_word(&FRAM_Slave_Can_Id_valid,3,BMS_SLAVE_CAN_ID_VALID);       // read VALID Flag from FRAM
	s->startupConfig.state.Bit.Slave_Can_Id_valid=FRAM_Slave_Can_Id_valid;   // store VALID Flag to DRAM
	s->startupConfig.fsmState=BMS_CAN_ID_SEARCH_INIT;
	
	for(i=0;i<CAN0_MAX_NR_OF_SLAVES;i++) {
		s->startupConfig.SlaveConfig[i].CanId=0;
		s->startupConfig.SlaveConfig[i].SerialNr[0]='N';
	}
	return TRUE;
}

uint32_t BMS_Can_ID_init_recofigure_CAN_IDs(MASTER_CAN0_STRUCT_t* s) {
	uint8_t SlaveNummer;
	uint8_t MasterAlive=0;
	uint8_t SetMode = 16; // This is stand By mode
	uint32_t Balancer = 0; // no balancing during startup
	uint64_t StartTime =0;
	uint16_t IDSEARCH = 1;
//	uint16_t LFT;
	uint8_t k=0;
	
	uint8_t  RxSlave=0;
	
	//Give CAN IDs to Slaves
	
	//Step 0 Bring all Slaves to Reset Mode
	for(SlaveNummer=0;SlaveNummer<CAN0_MAX_NR_OF_SLAVES -1;SlaveNummer++)
	{
		// schreibe Telegram im Reset Mode an alle möglichen Slaves CAn ID 0x100 - 0x1F0
		CAN_Tx_MasterX_BMS(s, SlaveNummer, MasterAlive, SetMode, Balancer );  //SetMode(X) = 0b00001 (=StandBy), Balancer = 0 (=OFF)
		StartTime = Global_1msCounter;
		while( (Global_1msCounter-StartTime) < 200 )
		{};	//wait 200ms
	}
	
	//Step A
	//Transmit cstring "IDSEARCH" to Slave over CAN IDE 0x300 
	CAN_Tx_System300( IDSEARCH );	//start
	
	
	StartTime = Global_1msCounter;
	while( (Global_1msCounter-StartTime) < 20 )
	{} //wait 20ms
	
	SlaveNummer=0;
	//Step B
	// Transmitt Zero String over CAN ID 10A
	// Slave Answers with Serial Number
	do {
		RxSlave = 0;
		// schicke Master Telegram an CAN ID 0
		CAN_Tx_MasterXA();
		StartTime = Global_1msCounter;
		while( ((Global_1msCounter-StartTime)<5000 ) && (SlaveNummer < 16) )   //0.23ms * 2^16
		{
			//warte auf Antwort von Slave
			if( CAN0_check_serial_nr_rec_Can_init(s ,SlaveNummer))    //CAN_Rx_SlaveXA_Master
			{	
				// Slave hat mit serien nummer geantwortet
				// here convert Short form of Slave ID to Long Form
				// to be done
//				LFT = (uint16_t)gSerNrShort[gAnzSlave][0] + ( (uint16_t)gSerNrShort[gAnzSlave][1] << 8); 
//				gSerNrLong[gAnzSlave][ 0] = (uint8_t)((LFT % 10) + 0x30); LFT = LFT / 10;
//				gSerNrLong[gAnzSlave][ 1] = (uint8_t)((LFT % 10) + 0x30); LFT = LFT / 10;
//				gSerNrLong[gAnzSlave][ 2] = (uint8_t)((LFT % 10) + 0x30); LFT = LFT / 10;
//				gSerNrLong[gAnzSlave][ 3] = (uint8_t)((LFT % 10) + 0x30);
//				gSerNrLong[gAnzSlave][ 4] =  gSerNrShort[gAnzSlave][2];
//				gSerNrLong[gAnzSlave][ 5] = (gSerNrShort[gAnzSlave][3] % 10) + 0x30;
//				gSerNrLong[gAnzSlave][ 6] = (gSerNrShort[gAnzSlave][3] / 10) + 0x30;
//				gSerNrLong[gAnzSlave][ 7] =  gSerNrShort[gAnzSlave][4]; // das hier enthält die CAN ID
//				gSerNrLong[gAnzSlave][ 8] = (gSerNrShort[gAnzSlave][5] % 10) + 0x30;
//				gSerNrLong[gAnzSlave][ 9] = (gSerNrShort[gAnzSlave][5] / 10) + 0x30;
//				gSerNrLong[gAnzSlave][10] =  0x30;
//				gSerNrLong[gAnzSlave][11] =  gSerNrShort[gAnzSlave][6];
				
				// !! here copy to FRAM !!
				SlaveNummer++;
				RxSlave++;
			}
		}
		
		for(k=SlaveNummer-RxSlave; k<SlaveNummer; k++)
		{
			StartTime = Global_1msCounter;
			s->startupConfig.SlaveConfig[k].SerialNr[7]=(k<<4); // damit aus CAN IC 3 can ID 0x30 wird
			CAN_Tx_System30A( &(s->startupConfig.SlaveConfig[k].SerialNr[0]) );// übertrage Seriennummer + CAN ID an Slave
			while( (Global_1msCounter-StartTime) < 20 )
			{} //wait 20ms
		}
	} while( RxSlave );	
	
	// Set Slave Config Accordingly
	
	for(k=0;k<SlaveNummer;k++) {
		s->Slave[k].SlaveConnectionState=CONNECTED;
	}
	
	// calculate max Battery voltage
	s->startupConfig.maxBatteryVoltage = (float)(SlaveNummer * MAX_SLAVE_CELLS * BMS_SLAVE_MAX_CELL_VOLTAGE / 1000.0) ;
	// calculate min Battery voltage
	s->startupConfig.minBatteryVoltage = (float)(SlaveNummer * MAX_SLAVE_CELLS * BMS_SLAVE_MIN_CELL_VOLTAGE /1000.0);
	
}

uint32_t BMS_Can_ID_init_fsm (MASTER_CAN0_STRUCT_t* s) {
	uint16_t Adr_FRAM = BMS_SERNR;
	uint16_t FRAM_NrOfSlaves;
	uint8_t  FRAM_BMS_SERNR;
	uint8_t *ptrFRAM;
	uint8_t  SlaveNr;
	uint8_t  CompStatus;
	uint8_t  i;
	
	switch (s->startupConfig.fsmState) {
		case BMS_CAN_ID_SEARCH_INIT:
			if(s->startupConfig.state.Bit.Slave_Can_Id_valid == TRUE) {
				// CAN Ids valid
				s->startupConfig.fsmState=BMS_CAN_ID_SEARCH_CHECK_COMMUNICATION;
				return BMS_CAN_ID_INIT_RETURN_RUNNING;
			}
			else {
				s->startupConfig.fsmState=BMS_CAN_ID_SEARCH_RECONFIGURE_CAN0_IDS;
				return BMS_CAN_ID_INIT_RETURN_RUNNING;
			}
		break;
		case BMS_CAN_ID_SEARCH_CHECK_COMMUNICATION:
			// not implemented yet
			BMS_Can_ID_init_recofigure_CAN_IDs(s);                  // Complete ID scan first
			s->NrOfSlaves= get_nr_of_connected_slaves(s);           // get NrOfSlaves from actual scan
			read_fram_word(&FRAM_NrOfSlaves,3,BMS_SLAVE_ANZ);       // read NrOfSlaves from FRAM (past scan)
			if(FRAM_NrOfSlaves != s->NrOfSlaves)                    // if actual and past scan not match
				return BMS_CAN_ID_INIT_RETURN_ERROR;                // show error
			
			for(SlaveNr=0; SlaveNr<FRAM_NrOfSlaves; SlaveNr++){     // for all Slave present
				ptrFRAM = (uint8_t *)BMS_SERNR;                     // Pointer to Start of SERNR Data
				while( ptrFRAM < (uint8_t *)((BMS_SERNR + (8 * BMS_SERNR)))){ // loop 
					CompStatus = TRUE;
					for(i=0; i<8; i++){
						read_fram_byte(&FRAM_BMS_SERNR,3,(const volatile unsigned short)ptrFRAM);
						if(s->startupConfig.SlaveConfig[SlaveNr].SerialNr[i] != FRAM_BMS_SERNR)
							CompStatus=FALSE;
						ptrFRAM++;
					}
					if( CompStatus == TRUE){
						ptrFRAM = (uint8_t *) (BMS_SERNR + (8 * BMS_SERNR));
					}
				}
				if(CompStatus == FALSE)
					return BMS_CAN_ID_INIT_RETURN_ERROR;
			}
			s->startupConfig.state.Bit.Slave_Can_Id_valid = TRUE;
			write_fram_word(s->startupConfig.state.Bit.Slave_Can_Id_valid,3,BMS_SLAVE_CAN_ID_VALID);			
			write_fram_word(s->NrOfSlaves,3,BMS_SLAVE_ANZ);
			for(SlaveNr=0; SlaveNr<s->NrOfSlaves; SlaveNr++){
				for(i=0; i<8; i++){
					write_fram_byte(s->startupConfig.SlaveConfig[SlaveNr].SerialNr[i],3,Adr_FRAM);
			        Adr_FRAM++;
			    }
			} 
			return BMS_CAN_ID_INIT_RETURN_COMPLETE;
		break;
		case BMS_CAN_ID_SEARCH_RECONFIGURE_CAN0_IDS:
			// start CAN ID reconfiguration
			BMS_Can_ID_init_recofigure_CAN_IDs(s);
			s->NrOfSlaves= get_nr_of_connected_slaves(s);
			s->startupConfig.state.Bit.Slave_Can_Id_valid = TRUE;
            write_fram_word(s->startupConfig.state.Bit.Slave_Can_Id_valid,3,BMS_SLAVE_CAN_ID_VALID);			
            write_fram_word(s->NrOfSlaves,3,BMS_SLAVE_ANZ);
            for(SlaveNr=0; SlaveNr<s->NrOfSlaves; SlaveNr++){
               for(i=0; i<8; i++){
            	   write_fram_byte(s->startupConfig.SlaveConfig[SlaveNr].SerialNr[i],3,Adr_FRAM);
            	   Adr_FRAM++;
               }
            } 
			return BMS_CAN_ID_INIT_RETURN_COMPLETE;
		break;
		default:
			return BMS_CAN_ID_INIT_RETURN_ERROR;
		break;
	}
}