Master_BMS/BMS Master/Sources/BMS_Startup.c

/*
 * BMS_Startup.c
 *
 *  Created on: Oct 19, 2016
 *      Author: le8041
 */

#include "BMS_Master.h"


/*
 * @brief writes 8 bit byte to FRAM
 */

uint32_t write_fram_byte(uint8_t byte,uint32_t timeout,const vuint16_t Addr) {
	uint32_t timestamp=Global_1msCounter;
	FRAM_trigger_write(Addr, (vuint8_t *const)&byte,1);
	while(Fram_S.Flags.B.JobFinished ==0 ) {
		FRAM_update(0);
		if(timestamp + timeout < Global_1msCounter) {
			// timeout
			return FALSE;
		}
	}
	
	Fram_S.Flags.B.JobFinished =0;
	return TRUE;
}
 
/*
 * @brief writes 16bit word to FRAM
 */

uint32_t write_fram_word(uint16_t word,uint32_t timeout,const vuint16_t Addr) {
	uint32_t timestamp=Global_1msCounter;
	FRAM_trigger_write(Addr, (vuint8_t *const)&word,2);
	while(Fram_S.Flags.B.JobFinished ==0 ) {
		FRAM_update(0);
		if(timestamp + timeout < Global_1msCounter) {
			// timeout
			return FALSE;
		}
	}
	
	Fram_S.Flags.B.JobFinished =0;
	return TRUE;
}

/*
 * @brief writes 32bit float to FRAM
 */

uint32_t write_fram_float(float float_value,uint32_t timeout,const vuint16_t Addr) {
	uint32_t timestamp=Global_1msCounter;
	FRAM_trigger_write(Addr, (vuint8_t *const)&float_value,4);
	while(Fram_S.Flags.B.JobFinished ==0 ) {
		FRAM_update(0);
		if(timestamp + timeout < Global_1msCounter) {
			// timeout
			return FALSE;
		}
	}
	
	Fram_S.Flags.B.JobFinished =0;
	return TRUE;
}

/*
 * @brief writes 32bit word to FRAM
 */

uint32_t write_fram_uint32(uint32_t word,uint32_t timeout,const vuint16_t Addr) {
	uint32_t timestamp=Global_1msCounter;
	FRAM_trigger_write(Addr, (vuint8_t *const)&word,4);
	while(Fram_S.Flags.B.JobFinished ==0 ) {
		FRAM_update(0);
		if(timestamp + timeout < Global_1msCounter) {
			// timeout
			return FALSE;
		}
	}
	
	Fram_S.Flags.B.JobFinished =0;
	return TRUE;
}

uint32_t read_fram_byte(uint8_t* word,uint32_t timeout,const vuint16_t Addr) {
	uint32_t timestamp=Global_1msCounter;
	FRAM_trigger_read(Addr, (vuint8_t *const)word,2);
	while(Fram_S.Flags.B.JobFinished ==0 ) {
		FRAM_update(0);
		if(timestamp + timeout < Global_1msCounter) {
			// timeout
			return FALSE;
		}
	}
	
	Fram_S.Flags.B.JobFinished =0;
	return TRUE;
}

uint32_t read_fram_word(uint16_t* word,uint32_t timeout,const vuint16_t Addr) {
	uint32_t timestamp=Global_1msCounter;
	FRAM_trigger_read(Addr, (vuint8_t *const)word,2);
	while(Fram_S.Flags.B.JobFinished ==0 ) {
		FRAM_update(0);
		if(timestamp + timeout < Global_1msCounter) {
			// timeout
			return FALSE;
		}
	}
	
	Fram_S.Flags.B.JobFinished =0;
	return TRUE;
}

uint32_t read_fram_uint32(uint32_t* word,uint32_t timeout,const vuint16_t Addr) {
	uint32_t timestamp=Global_1msCounter;
	FRAM_trigger_read(Addr, (vuint8_t *const)word,4);
	while(Fram_S.Flags.B.JobFinished ==0 ) {
		FRAM_update(0);
		if(timestamp + timeout < Global_1msCounter) {
			// timeout
			return FALSE;
		}
	}
	
	Fram_S.Flags.B.JobFinished =0;
	return TRUE;
}



uint32_t read_fram_float(float* word,uint32_t timeout,const vuint16_t Addr) {
	uint32_t timestamp=Global_1msCounter;
	FRAM_trigger_read(Addr, (vuint8_t *const)word,4);
	while(Fram_S.Flags.B.JobFinished ==0 ) {
		FRAM_update(0);
		if(timestamp + timeout < Global_1msCounter) {
			// timeout
			return FALSE;
		}
	}
	
	Fram_S.Flags.B.JobFinished =0;
	return TRUE;
}



uint32_t read_fram_get_startup_state(MASTER_CAN0_STRUCT_t* s) {
	uint32_t ret;
	ret = read_fram_word(&(s->startupConfig.state.word),5,BMS_STARTUP_MODE_ADDR);
	if(ret == FALSE) {
		// FRAM READ FAIL
		s->startupConfig.state.word=0;
		return FALSE;
	}
	else {
		return TRUE;
	}
}



float read_fram_get_SoC() {
	float SoC=-1.0;
	read_fram_float(&SoC,3,BMS_STARTUP_SOC) ;
	return SoC;
}

uint32_t write_fram_set_SoC(float SoC) {
	return write_fram_float(SoC,3,BMS_STARTUP_SOC); 
}

uint32_t write_fram_set_startup_state(MASTER_CAN0_STRUCT_t* s) {
	return write_fram_word(s->startupConfig.state.word,3,BMS_STARTUP_MODE_ADDR);
}

uint32_t write_fram_clear_startup_state() {
	return write_fram_word((0),5,BMS_STARTUP_MODE_ADDR);
}

uint32_t write_fram_write_error(uint32_t Error,uint8_t ErrorLevel,uint8_t ErrorNr) {
	uint16_t addr;
	if(ErrorLevel == BMS_ERROR_CLASS_1) {
		// write Error Buffer 1
		addr=BMS_ERROR_BUFFER1_OFFSET+sizeof(uint32_t)*ErrorNr;
		return write_fram_uint32(Error,5,addr);
	}
	else if( ErrorLevel == BMS_ERROR_CLASS_2) {
		// write Error Buffer 2
		addr=BMS_ERROR_BUFFER2_OFFSET+sizeof(uint32_t)*ErrorNr;
		return write_fram_uint32(Error,5,addr);
	}
	else {
		// write Error Buffer 3
		addr=BMS_ERROR_BUFFER3_OFFSET+sizeof(uint32_t)*ErrorNr;
		return write_fram_uint32(Error,5,addr);
	}
}


uint32_t read_fram_read_error_buffer(MASTER_CAN0_STRUCT_t* s) {
	uint8_t i;
	uint32_t Error;
	uint16_t addr;
	uint32_t return_value=0;
	// read Error buffer 1
	addr=BMS_ERROR_BUFFER1_OFFSET;
	for(i=0;i<BMS_ERROR_ERROR_STACK_SIZE;i++) {
		return_value=read_fram_uint32(&(s->ErrorBuffer.ES1_Error[i].Word),5,addr) ;
		// increment Pointer
		addr=addr+sizeof(Error);
		// check if last Error entry reached
		if(s->ErrorBuffer.ES1_Error[i].Word == 0) {
			// no errors any more
			s->ErrorBuffer.ES1_ErrorCounter=i;
			break;
		}
	}
	
	// read Error buffer 2
	addr=BMS_ERROR_BUFFER2_OFFSET;
	for(i=0;i<BMS_ERROR_ERROR_STACK_SIZE;i++) {
		return_value=read_fram_uint32(&(s->ErrorBuffer.ES2_Error[i].Word),5,addr) ;
		// increment Pointer
		addr=addr+sizeof(Error);
		// check if last Error entry reached
		if(s->ErrorBuffer.ES2_Error[i].Word == 0) {
			// no errors any more
			s->ErrorBuffer.ES2_ErrorCounter=i;
			break;
		}
	}
	
	// read Error buffer 3
	addr=BMS_ERROR_BUFFER3_OFFSET;
	for(i=0;i<BMS_ERROR_ERROR_STACK_SIZE;i++) {
		return_value=read_fram_uint32(&(s->ErrorBuffer.ES3_Error[i].Word),5,addr) ;
		// increment Pointer
		addr=addr+sizeof(Error);
		// check if last Error entry reached
		if(s->ErrorBuffer.ES3_Error[i].Word == 0) {
			// no errors any more
			s->ErrorBuffer.ES3_ErrorCounter=i;
			break;
		}
	}
}

uint32_t write_fram_clear_error_buffer(MASTER_CAN0_STRUCT_t* s) {
	uint8_t i;
	uint32_t Error;
	uint16_t addr;
	uint32_t Return_Value;
	uint32_t test=100;
	// clear Error buffer 1
	addr=BMS_ERROR_BUFFER1_OFFSET;
	for(i=0;i<BMS_ERROR_ERROR_STACK_SIZE;i++) {
		Return_Value=write_fram_uint32(0,5,addr) ;
		
		read_fram_uint32(&test,5,addr) ;
		addr=addr+sizeof(uint32_t);
	}
	
	// read Error buffer 2
	addr=BMS_ERROR_BUFFER2_OFFSET;
	for(i=0;i<BMS_ERROR_ERROR_STACK_SIZE;i++) {
		Return_Value=write_fram_uint32(0,5,addr) ;
		addr=addr+sizeof(uint32_t);
	}
	
	// read Error buffer 3
	addr=BMS_ERROR_BUFFER3_OFFSET;
	for(i=0;i<BMS_ERROR_ERROR_STACK_SIZE;i++) {
		Return_Value=write_fram_uint32(0,5,addr) ;
		addr=addr+sizeof(uint32_t);
	}
}