Master_BMS/BMS Master/Sources/BMS_Error_Stack.c

/*
 * BMS_Error_Stack.c
 *
 *  Created on: Oct 10, 2016
 *      Author: le8041
 */

#include "BMS_Master.h"


uint32_t ErrorStackPushSlaveError(MASTER_CAN0_STRUCT_t* s,uint8_t slaveNr,uint32_t ErrorCode,uint8_t CellNr,uint8_t ErrorClass) {
	BMS_ERROR_STATE_t TempError;
	TempError.Slave.CellNr=CellNr;
	TempError.Slave.ErrorType=ErrorCode;
	TempError.Slave.SubsystemNr=slaveNr;
	TempError.Slave.active=TRUE;
	if(ErrorClass==BMS_ERROR_CLASS_1) {
		if (ErrorStackCheckBufferForError(s,TempError.Word,ErrorClass)) {
			// Error has already been stored
			return TRUE;
		}
		// Error has not been recorded yet
		s->ErrorBuffer.ES1_Error[s->ErrorBuffer.ES1_ErrorCounter].Word=TempError.Word;
		// write FRAM
		write_fram_write_error(TempError.Word,BMS_ERROR_CLASS_1,s->ErrorBuffer.ES1_ErrorCounter);
		s->ErrorBuffer.ES1_ErrorCounter++;
		return TRUE;
	}
	else if(ErrorClass == BMS_ERROR_CLASS_2){
		// write Error Buffer 2
		if (ErrorStackCheckBufferForError(s,TempError.Word,ErrorClass)) {
			// Error has already been stored
			return TRUE;
		}
		// Error has not been recorded yet
		s->ErrorBuffer.ES2_Error[s->ErrorBuffer.ES2_ErrorCounter].Word=TempError.Word;
		// write FRAM
		write_fram_write_error(TempError.Word,BMS_ERROR_CLASS_2,s->ErrorBuffer.ES2_ErrorCounter);
		s->ErrorBuffer.ES2_New_Error=TRUE;
		s->ErrorBuffer.ES2_ErrorCounter++;
		return TRUE;
	}
	else {
		// write Error Buffer 3
		if (ErrorStackCheckBufferForError(s,TempError.Word,ErrorClass)) {
			// Error has already been stored
			return TRUE;
		}
		// Error has not been recorded yet
		s->ErrorBuffer.ES3_Error[s->ErrorBuffer.ES3_ErrorCounter].Word=TempError.Word;
		// write FRAM
		write_fram_write_error(TempError.Word,BMS_ERROR_CLASS_3,s->ErrorBuffer.ES3_ErrorCounter);
		s->ErrorBuffer.ES3_ErrorCounter++;
		return TRUE;	
	}
	return TRUE;
}

uint32_t ErrorStackPushUiError(MASTER_CAN0_STRUCT_t* s,uint32_t ErrorCode,uint8_t ErrorClass) {
	BMS_ERROR_STATE_t TempError;
		TempError.UI.ErrorCode=ErrorCode;
		TempError.UI.SubsystemNr=BMS_ERROR_UI_ID;
		TempError.UI.active=TRUE;
		if(ErrorClass==BMS_ERROR_CLASS_1) {
			if (ErrorStackCheckBufferForError(s,TempError.Word,ErrorClass)) {
				// Error has already been stored
				return TRUE;
			}
			// Error has not been recorded yet
			s->ErrorBuffer.ES1_Error[s->ErrorBuffer.ES1_ErrorCounter].Word=TempError.Word;
			// write FRAM
			write_fram_write_error(TempError.Word,BMS_ERROR_CLASS_1,s->ErrorBuffer.ES1_ErrorCounter);
			s->ErrorBuffer.ES1_ErrorCounter++;
			return TRUE;
		}
		else if(ErrorClass == BMS_ERROR_CLASS_2){
			// write Error Buffer 2
			if (ErrorStackCheckBufferForError(s,TempError.Word,ErrorClass)) {
				// Error has already been stored
				return TRUE;
			}
			// Error has not been recorded yet
			s->ErrorBuffer.ES2_Error[s->ErrorBuffer.ES2_ErrorCounter].Word=TempError.Word;
			// write FRAM
			write_fram_write_error(TempError.Word,BMS_ERROR_CLASS_2,s->ErrorBuffer.ES2_ErrorCounter);
			s->ErrorBuffer.ES2_ErrorCounter++;
			return TRUE;
		}
		else {
			// write Error Buffer 3
			if (ErrorStackCheckBufferForError(s,TempError.Word,ErrorClass)) {
				// Error has already been stored
				return TRUE;
			}
			// Error has not been recorded yet
			s->ErrorBuffer.ES3_Error[s->ErrorBuffer.ES3_ErrorCounter].Word=TempError.Word;
			// write FRAM
			write_fram_write_error(TempError.Word,BMS_ERROR_CLASS_3,s->ErrorBuffer.ES3_ErrorCounter);
			s->ErrorBuffer.ES3_ErrorCounter++;
			return TRUE;	
		}
		return TRUE;
}

uint32_t ErrorStackPushMasterError(MASTER_CAN0_STRUCT_t* s,uint32_t ErrorCode,uint8_t ErrorClass) {
	BMS_ERROR_STATE_t TempError;
		TempError.Master.ErrorCode=ErrorCode;
		TempError.Master.SubsystemNr=BMS_ERROR_MASTER_ID;
		TempError.Master.active=TRUE;
		
		
		if(ErrorClass==BMS_ERROR_CLASS_1) {
			if (ErrorStackCheckBufferForError(s,TempError.Word,ErrorClass)) {
				// Error has already been stored
				return TRUE;
			}
			// Error has not been recorded yet
			s->ErrorBuffer.ES1_Error[s->ErrorBuffer.ES1_ErrorCounter].Word=TempError.Word;
			// write FRAM
			write_fram_write_error(TempError.Word,BMS_ERROR_CLASS_1,s->ErrorBuffer.ES1_ErrorCounter);
			s->ErrorBuffer.ES1_ErrorCounter++;
			return TRUE;
		}
		else if(ErrorClass == BMS_ERROR_CLASS_2){
			// write Error Buffer 2
			if (ErrorStackCheckBufferForError(s,TempError.Word,ErrorClass)) {
				// Error has already been stored
				return TRUE;
			}
			// Error has not been recorded yet
			s->ErrorBuffer.ES2_Error[s->ErrorBuffer.ES2_ErrorCounter].Word=TempError.Word;
			// write FRAM
			write_fram_write_error(TempError.Word,BMS_ERROR_CLASS_2,s->ErrorBuffer.ES2_ErrorCounter);
			// set new error flag
			s->ErrorBuffer.ES2_New_Error=TRUE;
			s->ErrorBuffer.ES2_ErrorCounter++;
			return TRUE;
		}
		else {
			// write Error Buffer 3
			if (ErrorStackCheckBufferForError(s,TempError.Word,ErrorClass)) {
				// Error has already been stored
				return TRUE;
			}
			// Error has not been recorded yet
			s->ErrorBuffer.ES3_Error[s->ErrorBuffer.ES3_ErrorCounter].Word=TempError.Word;
			// write FRAM
			write_fram_write_error(TempError.Word,BMS_ERROR_CLASS_3,s->ErrorBuffer.ES3_ErrorCounter);
			s->ErrorBuffer.ES3_ErrorCounter++;
			return TRUE;	
		}
		return TRUE;
}

uint32_t ErrorStackGenerateStatusPkg(uint8_t* targetBuffer,uint8_t* ErrorCode) {
	uint32_t id=CAN1_TX_BATTERY_STATUS;
	uint8_t* id_addr=(uint8_t*)&id;
	// generate ID
	shuffle_lsb_msb_can1((uint8_t*)&id);
	targetBuffer[0]=id_addr[0];
	targetBuffer[1]=id_addr[1];
	targetBuffer[2]=id_addr[2];
	targetBuffer[3]=id_addr[3];
	targetBuffer[4]=ErrorCode[3];
	targetBuffer[5]=ErrorCode[2];
	targetBuffer[6]=ErrorCode[1];
	targetBuffer[7]=ErrorCode[0];
	return TRUE;
}

/*
 * @brief check if error is already in Error buffer
 * @return True if error is already stroed
 * @return FALSE errhr has not been stred yet
 */

uint32_t ErrorStackCheckBufferForError(MASTER_CAN0_STRUCT_t* s,uint32_t ErrorWord,uint8_t ErrorClass) {
	uint8_t i;
	if(ErrorClass==BMS_ERROR_CLASS_1) {
		// check Error Buffer 1
		for(i=0;i<(s->ErrorBuffer.ES1_ErrorCounter);i++ ) {
			if(s->ErrorBuffer.ES1_Error[i].Word == ErrorWord) {
				return TRUE; // Error has been detected before
			}
		}
		return FALSE;
	}
	else if(ErrorClass==BMS_ERROR_CLASS_2) {
		// check Error Buffer 2
		for(i=0;i<(s->ErrorBuffer.ES2_ErrorCounter);i++ ) {
			if(s->ErrorBuffer.ES2_Error[i].Word == ErrorWord) {
				return TRUE; // Error has been detected before
			}
		}
		return FALSE;
	}
	else  {
		// check Error Buffer 3
		//get Error Code from latest entry		
		for(i=0;i<(s->ErrorBuffer.ES3_ErrorCounter);i++ ) {
			if(s->ErrorBuffer.ES3_Error[i].Word == ErrorWord) {
				return TRUE; // Error has been detected before
			}
		}
		return FALSE;
	}
}

/*
 * @brief check if active errors  remain
 * @return true = error is active
 * @return false = error not active
 */

uint32_t ErrorStackCheckForActiveErrors(MASTER_CAN0_STRUCT_t* s,uint8_t ErrorClass) {
	uint8_t i;
	if(ErrorClass==BMS_ERROR_CLASS_1) {
		for(i=0;i<s->ErrorBuffer.ES1_ErrorCounter;i++) {
			if(s->ErrorBuffer.ES1_Error[i].Word & 0x00000001) {
				// Error is active
				if(s->ErrorBuffer.ES1_Error_Recovery[i].recoveryPending == FALSE) {
					return TRUE;
				}
				else {
					// error recovery is in progress
					// return no error
					if(s->ErrorBuffer.ES1_Error[i].Master.SubsystemNr==BMS_ERROR_MASTER_ID) {
						// Error is master Error
						BMS_Clear_Error_State_Master(s,&(s->ErrorBuffer.ES1_Error[i]),i,ErrorClass); 
					}
					else if(s->ErrorBuffer.ES1_Error[i].Master.SubsystemNr==BMS_ERROR_UI_ID) {
							// Error is UI Error						
					}
					else{
						// Error is Slave Error
						BMS_Clear_Error_State_Slave(s,&(s->ErrorBuffer.ES1_Error[i])) ;
					}
					return FALSE;
				}
			}
		}
		// no Active Error
		return FALSE;
	}
	else if(ErrorClass==BMS_ERROR_CLASS_2) {
		for(i=0;i<s->ErrorBuffer.ES2_ErrorCounter;i++) {
			if(s->ErrorBuffer.ES2_Error[i].Word & 0x00000001) {
				// Error is active
				if(s->ErrorBuffer.ES2_Error_Recovery[i].recoveryPending == FALSE || s->ErrorBuffer.ES2_New_Error == TRUE) {
					return TRUE;
				}
				else {
					// error recovery is in progress
					// return no error
					if(s->ErrorBuffer.ES2_Error[i].Master.SubsystemNr==BMS_ERROR_MASTER_ID) {
						// Error is master Error
						BMS_Clear_Error_State_Master(s,&(s->ErrorBuffer.ES2_Error[i]),i,ErrorClass); 
					}
					else if(s->ErrorBuffer.ES2_Error[i].Master.SubsystemNr==BMS_ERROR_UI_ID) {
							// Error is UI Error						
					}
					else{
						// Error is Slave Error
						BMS_Clear_Error_State_Slave(s,&(s->ErrorBuffer.ES2_Error[i])) ;
					}
					return FALSE;
				}
			}
		}
		// no Active Error
		return FALSE;		
	}
	else {
		for(i=0;i<s->ErrorBuffer.ES3_ErrorCounter;i++) {
			if(s->ErrorBuffer.ES3_Error[i].Word & 0x00000001) {
				// Error is active
				return TRUE;
			}
		}
		// no Active Error
		return FALSE;		
	}
	
}
uint32_t ErrorStackClearBuffer(MASTER_CAN0_STRUCT_t* s) {
	uint8_t i;
	for(i=0;i<BMS_ERROR_ERROR_STACK_SIZE;i++) {
		s->ErrorBuffer.ES1_Error[i].Word=0;
		s->ErrorBuffer.ES2_Error[i].Word=0;
		s->ErrorBuffer.ES3_Error[i].Word=0;
	}
}

/*
 * @ brief check if error recovery is pending
 * if pending return TRUE else return FALSE
 */
uint32_t ErrorStackCheckifUmin1ErrorRecoveryPending(MASTER_CAN0_STRUCT_t* s) {
	uint8_t i;
	for(i=0;i< BMS_ERROR_ERROR_STACK_SIZE;i++) {
		if(s->ErrorBuffer.ES1_Error[i].Master.active && s->ErrorBuffer.ES1_Error[i].Master.ErrorCode==BMS_ERROR_STACK_MASTER_UMIN_1 ) {
			if(s->ErrorBuffer.ES1_Error_Recovery[i].recoveryPending==TRUE) {
				return TRUE;
			}
		}
	}
	// no pending umin1 error recovery
	return FALSE;
}

/*
 * @ brief check if error recovery is pending
 * if pending return TRUE else return FALSE
 */
uint32_t ErrorStackCheckifUmin2ErrorRecoveryPending(MASTER_CAN0_STRUCT_t* s) {
	uint8_t i;
	for(i=0;i< BMS_ERROR_ERROR_STACK_SIZE;i++) {
		if(s->ErrorBuffer.ES2_Error[i].Master.active && s->ErrorBuffer.ES2_Error[i].Master.ErrorCode==BMS_ERROR_STACK_MASTER_UMIN_2 ) {
			if(s->ErrorBuffer.ES2_Error_Recovery[i].recoveryPending==TRUE) {
				return TRUE;
			}
		}
	}
	// no pending umin1 error recovery
	return FALSE;
}

/*
 * @ brief check if error recovery is pending
 * if pending return TRUE else return FALSE
 */
uint32_t ErrorStackCheckifAnyErrorRecoveryPending(MASTER_CAN0_STRUCT_t* s) {
	uint8_t i;
	for(i=0;i< BMS_ERROR_ERROR_STACK_SIZE;i++) {
		if(s->ErrorBuffer.ES1_Error_Recovery[i].recoveryPending==TRUE) {
			return TRUE;
		}
		if(s->ErrorBuffer.ES2_Error_Recovery[i].recoveryPending==TRUE) {
			return TRUE;
		}
	}
	// no pending umin1 error recovery
	return FALSE;
}