Coldbox/TECware
0
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

v08 - add error handling

Browse Source
This commit is contained in:
pique_n
2024-10-18 10:54:47 +02:00
parent dc2dedf822
commit 2fbc3b3023
14 changed files with 3030 additions and 191 deletions
Download Patch File Download Diff File Expand all files Collapse all files

37
Core/Application/INIT_Initialization.c
View File

@ -153,27 +153,40 @@ BOOL INIT_boCreateTask( VOID )
//-------------------------------------------------------------------------------------------------
PRIVATE VOID vTask( PVOID arg )
{
UNUSED( arg );
UNUSED( arg );
BOOL boOK = TRUE;
boOK &= ERRH_boInitializeModule();
boOK &= USFL_boInitializeModule();
boOK &= VARH_boInitializeModule();
BOOL boOK = TRUE;
boOK &= DIPO_boInitializeModule();
boOK &= ANPI_boInitializeModule();
uint32_t reset_flags = RCC->CSR;
boOK &= ERRH_boInitializeModule();
boOK &= USFL_boInitializeModule();
boOK &= VARH_boInitializeModule();
if (reset_flags & RCC_CSR_IWDGRSTF) {
// This was IWDG
ERRH_vSetError(HARDFAULT_ERROR_MASK | HARDFAULT_ERROR_IWDG);
}else if (reset_flags & RCC_CSR_SFTRSTF) {
// Software reset (NVIC_SystemReset or by debugger)
ERRH_vSetError(HARDFAULT_ERROR_MASK | HARDFAULT_ERROR_SWRST);
}
boOK &= DIPO_boInitializeModule();
boOK &= ANPI_boInitializeModule();
boOK &= ANPO_boInitializeModule();
boOK &= SPID_boInitializeModule();
boOK &= ADCD_boInitializeModule();
boOK &= SPID_boInitializeModule();
boOK &= ADCD_boInitializeModule();
boOK &= TEMP_boInitializeModule();
boOK &= CAND_boInitializeModule();
boOK &= PECO_boInitializeModule();
boOK &= MAIN_boInitializeModule();
boOK &= PECO_boInitializeModule();
boOK &= MAIN_boInitializeModule();
if( !boOK ){
osKernelLock(); // lock kernel to prevent task switch
PECO_Enable( FALSE );
while( 1 ){ // Toggle Error LED fast
DIPO_vToggleOutput( DIPO_eLED );
DELAY_MS( 100 );

132
Core/Application/MAIN_MainApplication.c
View File

@ -43,6 +43,8 @@
#include "../Drivers/ANPI_AnalogPortsIn.h"
#include "../Drivers/ANPO_AnalogPortsOut.h"
#include "../Drivers/ERRH_ErrorHandler.h"
// Toolbox
#include "../Toolbox/UTIL_Utility.h"
@ -57,7 +59,7 @@
//=================================================================================================
/* Software Version */
#define SW_VERSION 7
#define SW_VERSION 8
#define MSG_QUEUE_SIZE 8
@ -206,14 +208,14 @@ BOOL MAIN_boInitializeModule( VOID )
boOK &= ( ( m_pstEventID = osEventFlagsNew( &stEventAttribute ) ) == NULL ) ? FALSE : TRUE;
boOK &= ( ( m_pstThreadID = osThreadNew( vTask, NULL, &stTaskAttribute ) ) == NULL ) ? FALSE : TRUE;
boOK &= ( ( m_pstCANRxMsgQueueID = osMessageQueueNew( MSG_QUEUE_SIZE, sizeof( CAND_Message ), &stCANRxMsgQueueAttribute ) ) == NULL ) ? FALSE : TRUE;
boOK &= ( ( m_pstCANRxMsgQueueID = osMessageQueueNew( MSG_QUEUE_SIZE, sizeof( CAND_Message ), &stCANRxMsgQueueAttribute ) ) == NULL ) ? FALSE : TRUE;
boOK &= ( m_pstUpdateTimer = osTimerNew( vEventCallback, osTimerPeriodic, (PVOID)EVENT_TIMER_UPDATE, &stTimerAttribute ) ) == NULL ? FALSE : TRUE;
boOK &= ( m_pstWatchdogTimer = osTimerNew( vEventCallback, osTimerPeriodic, (PVOID)EVENT_WATCHDOG, &stWatchdogTimerAttribute ) ) == NULL ? FALSE : TRUE;
boOK &= (osTimerStart( m_pstUpdateTimer, 1000 ) == osOK ) ? TRUE : FALSE;
boOK &= (osTimerStart( m_pstWatchdogTimer, WATCHDOG ) == osOK ) ? TRUE : FALSE;
CAND_vSetRxCallback( vMsgRxCallback );
CAND_vSetRxCallback( vMsgRxCallback );
return( boOK );
}
@ -244,77 +246,81 @@ PRIVATE VOID vTask( PVOID arg )
if( u32Flags & EVENT_NEW_MESSAGE ) { // New message from CAN
CAND_Message stMessage;
osMessageQueueGet( m_pstCANRxMsgQueueID, &stMessage, NULL, 0 ); // get message from queue
osMessageQueueGet( m_pstCANRxMsgQueueID, &stMessage, NULL, 0 ); // get message from queue
U8 u8Register = stMessage.au8Data[0];
U8 u8Type = stMessage.u8Type;
U8 u8Register = stMessage.au8Data[0];
U8 u8Type = stMessage.u8Type;
if( u8Type == MESSAGE_TYPE_READ ){ // Message type read
if( u8Type == MESSAGE_TYPE_READ ){ // Message type read
if( u8Register >= VARH_eNumberOfVariables ){ // check register
// send register not found
au8Buffer[0] = 0xFF;
CAND_boSendMessage( au8Buffer, 1, stMessage.boIsPrivate, stMessage.u8Type );
} else {
VARH_UVariable uVariable = VARH_uGetVariableData(u8Register); // get data
au8Buffer[0] = u8Register;
UTIL_vMemCopy(&uVariable, &au8Buffer[1], 4); // copy data in buffer
if( u8Register >= VARH_eNumberOfVariables ){ // check register
// send register not found
ERRH_vSetError(MAIN_ERROR_MASK | MAIN_ERROR_REG_NOT_FOUND);
CAND_boSendMessage( au8Buffer, 5, stMessage.boIsPrivate, stMessage.u8Type );
}
} else if( u8Type == MESSAGE_TYPE_WRITE ){ // Message type write
VARH_UVariable uData;
UTIL_vMemCopy(&stMessage.au8Data[1], &uData, 4);
au8Buffer[0] = 0xFF;
CAND_boSendMessage( au8Buffer, 1, stMessage.boIsPrivate, stMessage.u8Type );
} else {
VARH_UVariable uVariable = VARH_uGetVariableData(u8Register); // get data
au8Buffer[0] = u8Register;
UTIL_vMemCopy(&uVariable, &au8Buffer[1], 4); // copy data in buffer
VARH_vSetVariableData(u8Register, uData);
} else if( u8Type == MESSAGE_TYPE_COMMAND ){ // Message type command
CAND_boSendMessage( au8Buffer, 5, stMessage.boIsPrivate, stMessage.u8Type );
}
switch (u8Register)
{
case COMMAND_ON:
PECO_Enable( TRUE );
break;
case COMMAND_OFF:
PECO_Enable( FALSE );
break;
case COMMAND_WATCHDOG:
osTimerStart( m_pstWatchdogTimer, WATCHDOG );
break;
case COMMAND_CLEAR_ERROR:
VARH_vSetVariableDataFromSystemU32( VARH_eError, 0x00000000 );
break;
case COMMAND_REBOOT:
PECO_Enable( FALSE );
HAL_NVIC_SystemReset();
break;
case COMMAND_GET_SW_VERSION:
au8Buffer[0] = COMMAND_GET_SW_VERSION;
au8Buffer[1] = SW_VERSION;
CAND_boSendMessage( au8Buffer, 2, stMessage.boIsPrivate, stMessage.u8Type );
break;
case COMMAND_SAVE_VARIABLES:
VARH_vSaveVariablestoFlash();
// @TODO Error handling Flash Save
break;
case COMMAND_LOAD_VARIABLES:
VARH_vLoadVariablesfromFlash();
break;
default:
break;
}
}
}
} else if( u8Type == MESSAGE_TYPE_WRITE ){ // Message type write
VARH_UVariable uData;
UTIL_vMemCopy(&stMessage.au8Data[1], &uData, 4);
VARH_vSetVariableData(u8Register, uData);
} else if( u8Type == MESSAGE_TYPE_COMMAND ){ // Message type command
switch (u8Register)
{
case COMMAND_ON:
PECO_Enable( TRUE );
break;
case COMMAND_OFF:
PECO_Enable( FALSE );
break;
case COMMAND_WATCHDOG:
osTimerStart( m_pstWatchdogTimer, WATCHDOG );
break;
case COMMAND_CLEAR_ERROR:
ERRH_vClearError();
break;
case COMMAND_REBOOT:
PECO_Enable( FALSE );
HAL_NVIC_SystemReset();
break;
case COMMAND_GET_SW_VERSION:
au8Buffer[0] = COMMAND_GET_SW_VERSION;
au8Buffer[1] = SW_VERSION;
CAND_boSendMessage( au8Buffer, 2, stMessage.boIsPrivate, stMessage.u8Type );
break;
case COMMAND_SAVE_VARIABLES:
if(!VARH_vSaveVariablestoFlash()){
ERRH_vSetError(MAIN_ERROR_MASK | MAIN_ERROR_SAVE_FLASH);
}
break;
case COMMAND_LOAD_VARIABLES:
VARH_vLoadVariablesfromFlash();
break;
default:
ERRH_vSetError(MAIN_ERROR_MASK | MAIN_ERROR_CMD_NOT_FOUND);
break;
}
}
}
if( u32Flags & EVENT_TIMER_UPDATE )
{
{
DIPO_vToggleOutput( DIPO_eLED );
}
if( u32Flags & EVENT_WATCHDOG )
{
if( u32Flags & EVENT_WATCHDOG )
{
PECO_Enable( FALSE );
// TODO: WATCHDOG: what else?
// ERRH_vSetError(MAIN_ERROR_MASK | MAIN_ERROR_WATCHDOG);
}
}
@ -339,7 +345,7 @@ PRIVATE VOID vEventCallback( PVOID pvData )
//-------------------------------------------------------------------------------------------------
PRIVATE VOID vMsgRxCallback( CAND_Message stMessage )
{
osMessageQueuePut( m_pstCANRxMsgQueueID, &stMessage, 0, 0 );
osMessageQueuePut( m_pstCANRxMsgQueueID, &stMessage, 0, 0 );
osEventFlagsSet( m_pstEventID, EVENT_NEW_MESSAGE );
}

10
Core/Application/PECO_PeltierController.c
View File

@ -33,6 +33,8 @@
// Application
#include "../Application/VARH_VariableHandler.h"
#include "ERRH_ErrorHandler.h"
// Driver
#include "ANPO_AnalogPortsOut.h"
#include "DIPO_DigitalPorts.h"
@ -56,7 +58,7 @@
#define EVENT_FLAGS_ALL (EVENT_TIMER_UPDATE)
#define MAX_POWER_PELTIER 100
#define MAX_POWER_PELTIER 110 // safety for pid regulations
//=================================================================================================
// Section: MACROS
@ -234,9 +236,9 @@ VOID vTask(PVOID arg)
FLOAT power = VARH_flGetVariableData(VARH_ePeltier_P);
if(power > MAX_POWER_PELTIER){
PECO_Enable(FALSE);
ERRH_vSetError(PELTIER_ERROR_MASK | PELTIER_ERROR_MAX_POWER);
}
// PID Regelung
FLOAT Kp = VARH_flGetVariableData(VARH_ePID_kp);
@ -285,11 +287,11 @@ VOID vTask(PVOID arg)
d_prev = D;
i_prev = I;
boSetPeltierVoltage(Uout); // set the output
if(!boSetPeltierVoltage(Uout)) ERRH_vSetError(PELTIER_ERROR_MASK | PELTIER_ERROR_SETVOLTAGE_PID); // set the output
}
else if (VARH_u32GetVariableData(VARH_eMode) == PECO_eConst_Voltage)
{
boSetPeltierVoltage(VARH_flGetVariableData(VARH_eControlVoltage)); // set the output
if(!boSetPeltierVoltage(VARH_flGetVariableData(VARH_eControlVoltage))) ERRH_vSetError(PELTIER_ERROR_MASK | PELTIER_ERROR_SETVOLTAGE); // set the output
// reset PID Vars
error_prev = 0;

13
Core/Application/VARH_VariableHandler.c
View File

@ -32,6 +32,8 @@
#include "USFL_UserFlash.h"
#include "ERRH_ErrorHandler.h"
// Toolbox
#include "../Toolbox/UTIL_Utility.h"
@ -153,7 +155,7 @@ BOOL VARH_boInitializeModule( VOID )
{
BOOL boOK = TRUE;
boOK &= ( ( m_pstMutexID = osMutexNew( &m_stMutexAttr ) ) == NULL ) ? FALSE : TRUE;
boOK &= ( ( m_pstMutexID = osMutexNew( &m_stMutexAttr ) ) == NULL ) ? FALSE : TRUE;
VARH_vSetAllVariablesToInitData();
@ -172,11 +174,14 @@ VOID VARH_vSetVariableData( U8 u8Variable, VARH_UVariable uData )
// check parameters
if( m_astVarInfo[u8Variable].u8Flags & VARH_FLAGINFO_READONLY )
{
return;
ERRH_vSetError(VARH_ERROR_MASK | VARH_ERROR_READONLY);
return;
}
osMutexAcquire( m_pstMutexID, osWaitForever ); // aquire mutex
if( boCheckRange( u8Variable, uData ) ) { m_auVariable[u8Variable].uData = uData; } // store new value
if( boCheckRange( u8Variable, uData ) ) {
m_auVariable[u8Variable].uData = uData; // store new value
} else ERRH_vSetError(VARH_ERROR_MASK | VARH_ERROR_OUTOFRANGE);
osMutexRelease( m_pstMutexID ); // release mutex
}
@ -231,6 +236,7 @@ VOID VARH_vSetVariableDataFromSystem( U8 u8Variable, VARH_UVariable uData )
if( !boCheckRange( u8Variable, uData ) )
{
m_auVariable[u8Variable].u8Flags |= VARH_FLAG_OUTOFRANGE; // check the value
ERRH_vSetError(VARH_ERROR_MASK | VARH_ERROR_OUTOFRANGE_INT);
}
m_auVariable[u8Variable].uData = uData; // store new value
osMutexRelease( m_pstMutexID ); // release mutex
@ -401,6 +407,7 @@ VOID VARH_vLoadVariablesfromFlash( VOID )
}
}
if( !boOK ){
ERRH_vSetError(VARH_ERROR_MASK | VARH_ERROR_LOAD_FLASH);
for( U8 u8Var = 0; u8Var < VARH_eNumberOfVariables; u8Var++ )
{
if( (m_astVarInfo[u8Var].u8Flags & VARH_FLAGINFO_FLASH) == VARH_FLAGINFO_FLASH ){

3
Core/Drivers/ADCD_AdcDriver.c
View File

@ -204,9 +204,6 @@ BOOL ADCD_boInitializeModule( VOID )
boOK &= boWriteReg( REG_CONFIG, (U16) CONFIG | CONFIG_FAULTSTATCLEAR, FALSE );
DIPO_vResetOutput( DIPO_eCS_Water );
/** @todo read back configuration */
osMutexRelease( m_pstMutexID );
return( boOK );

30
Core/Drivers/ANPI_AnalogPortsIn.c
View File

@ -36,6 +36,8 @@
// Drivers
#include "PECO_PeltierController.h"
#include "ERRH_ErrorHandler.h"
// Toolbox
#include "../Toolbox/UTIL_Utility.h"
@ -316,30 +318,12 @@ void HAL_ADC_ConvHalfCpltCallback( ADC_HandleTypeDef* hadc )
//-------------------------------------------------------------------------------------------------
void HAL_ADC_ErrorCallback( ADC_HandleTypeDef* hadc )
{
// TODO: Error Handling
if( hadc->ErrorCode == HAL_ADC_ERROR_NONE )
{
if( hadc->ErrorCode == HAL_ADC_ERROR_NONE ){
ERRH_vSetError(AI_DMA_ERROR_MASK | hadc->DMA_Handle->ErrorCode);
} else {
ERRH_vSetError(AI_ERROR_MASK | hadc->ErrorCode);
}
}
if( hadc->ErrorCode == HAL_ADC_ERROR_INTERNAL )
{
}
if( hadc->ErrorCode == HAL_ADC_ERROR_OVR )
{
}
if( hadc->ErrorCode == HAL_ADC_ERROR_DMA )
{
}
if( hadc->DMA_Handle->ErrorCode & HAL_DMA_ERROR_TE )
{
}
}

6
Core/Drivers/CAND_CanDriver.c
View File

@ -38,6 +38,8 @@
// Driver
#include "DIPO_DigitalPorts.h"
#include "ERRH_ErrorHandler.h"
// include STM32 drivers
#include "stm32l4xx_hal.h"
@ -258,8 +260,8 @@ void HAL_CAN_RxFifo0MsgPendingCallback( CAN_HandleTypeDef *hcan ){
// Returns: None
//-------------------------------------------------------------------------------------------------
void HAL_CAN_ErrorCallback( CAN_HandleTypeDef *hcan ){
// U32 u32Error = hcan->ErrorCode;
/** TODO: Can Error Handling */
U32 u32Error = hcan->ErrorCode;
ERRH_vSetError(CAN_ERROR_MASK | u32Error);
}

21
Core/Drivers/ERRH_ErrorHandler.c
View File

@ -31,6 +31,7 @@
//=================================================================================================
#include "ERRH_ErrorHandler.h"
#include "VARH_VariableHandler.h"
// Toolbox
#include "../Toolbox/UTIL_Utility.h"
@ -106,12 +107,30 @@ BOOL ERRH_boInitializeModule( VOID )
{
BOOL boOK = TRUE;
// nothing to do yet in init
return( boOK );
}
VOID ERRH_vClearError( VOID )
{
VARH_vSetVariableDataFromSystemU32( VARH_eError, NO_ERROR );
}
VOID ERRH_vSetError( U32 u32Error )
{
VARH_vSetVariableDataFromSystemU32( VARH_eError, u32Error );
}
U32 ERRH_u32GetError( VOID )
{
return( VARH_u32GetVariableData( VARH_eError ) );
}

103
Core/Drivers/ERRH_ErrorHandler.h
View File

@ -48,30 +48,124 @@ extern "C" {
// CAN Errors
#define CAN_ERROR_MASK 0x01000000
// #define HAL_CAN_ERROR_NONE (0x00000000U) /*!< No error */
// #define HAL_CAN_ERROR_EWG (0x00000001U) /*!< Protocol Error Warning */
// #define HAL_CAN_ERROR_EPV (0x00000002U) /*!< Error Passive */
// #define HAL_CAN_ERROR_BOF (0x00000004U) /*!< Bus-off error */
// #define HAL_CAN_ERROR_STF (0x00000008U) /*!< Stuff error */
// #define HAL_CAN_ERROR_FOR (0x00000010U) /*!< Form error */
// #define HAL_CAN_ERROR_ACK (0x00000020U) /*!< Acknowledgment error */
// #define HAL_CAN_ERROR_BR (0x00000040U) /*!< Bit recessive error */
// #define HAL_CAN_ERROR_BD (0x00000080U) /*!< Bit dominant error */
// #define HAL_CAN_ERROR_CRC (0x00000100U) /*!< CRC error */
// #define HAL_CAN_ERROR_RX_FOV0 (0x00000200U) /*!< Rx FIFO0 overrun error */
// #define HAL_CAN_ERROR_RX_FOV1 (0x00000400U) /*!< Rx FIFO1 overrun error */
// #define HAL_CAN_ERROR_TX_ALST0 (0x00000800U) /*!< TxMailbox 0 transmit failure due to arbitration lost */
// #define HAL_CAN_ERROR_TX_TERR0 (0x00001000U) /*!< TxMailbox 0 transmit failure due to transmit error */
// #define HAL_CAN_ERROR_TX_ALST1 (0x00002000U) /*!< TxMailbox 1 transmit failure due to arbitration lost */
// #define HAL_CAN_ERROR_TX_TERR1 (0x00004000U) /*!< TxMailbox 1 transmit failure due to transmit error */
// #define HAL_CAN_ERROR_TX_ALST2 (0x00008000U) /*!< TxMailbox 2 transmit failure due to arbitration lost */
// #define HAL_CAN_ERROR_TX_TERR2 (0x00010000U) /*!< TxMailbox 2 transmit failure due to transmit error */
// #define HAL_CAN_ERROR_TIMEOUT (0x00020000U) /*!< Timeout error */
// #define HAL_CAN_ERROR_NOT_INITIALIZED (0x00040000U) /*!< Peripheral not initialized */
// #define HAL_CAN_ERROR_NOT_READY (0x00080000U) /*!< Peripheral not ready */
// #define HAL_CAN_ERROR_NOT_STARTED (0x00100000U) /*!< Peripheral not started */
// #define HAL_CAN_ERROR_PARAM (0x00200000U) /*!< Parameter error */
// #define HAL_CAN_ERROR_INTERNAL (0x00800000U) /*!< Internal error */
// SPI Errors
#define SPI_ERROR_MASK 0x02000000
// ADC Errors
// #define HAL_SPI_ERROR_NONE (0x00000000U) /*!< No error */
// #define HAL_SPI_ERROR_MODF (0x00000001U) /*!< MODF error */
// #define HAL_SPI_ERROR_CRC (0x00000002U) /*!< CRC error */
// #define HAL_SPI_ERROR_OVR (0x00000004U) /*!< OVR error */
// #define HAL_SPI_ERROR_FRE (0x00000008U) /*!< FRE error */
// #define HAL_SPI_ERROR_DMA (0x00000010U) /*!< DMA transfer error */
// #define HAL_SPI_ERROR_FLAG (0x00000020U) /*!< Error on RXNE/TXE/BSY/FTLVL/FRLVL Flag */
// #define HAL_SPI_ERROR_ABORT (0x00000040U) /*!< Error during SPI Abort procedure */
// Analog In Errors
#define AI_ERROR_MASK 0x03000000
// #define HAL_ADC_ERROR_NONE (0x00U) /*!< No error */
// #define HAL_ADC_ERROR_INTERNAL (0x01U) /*!< ADC peripheral internal error (problem of clocking,
// enable/disable, erroneous state, ...) */
// #define HAL_ADC_ERROR_OVR (0x02U) /*!< Overrun error */
// #define HAL_ADC_ERROR_DMA (0x04U) /*!< DMA transfer error */
// #define HAL_ADC_ERROR_JQOVF (0x08U) /*!< Injected context queue overflow error */
#define AI_DMA_ERROR_MASK 0x04000000
// #define HAL_DMA_ERROR_NONE 0x00000000U /*!< No error */
// #define HAL_DMA_ERROR_TE 0x00000001U /*!< Transfer error */
// #define HAL_DMA_ERROR_NO_XFER 0x00000004U /*!< Abort requested with no Xfer ongoing */
// #define HAL_DMA_ERROR_TIMEOUT 0x00000020U /*!< Timeout error */
// #define HAL_DMA_ERROR_NOT_SUPPORTED 0x00000100U /*!< Not supported mode */
// #define HAL_DMA_ERROR_SYNC 0x00000200U /*!< DMAMUX sync overrun error */
// #define HAL_DMA_ERROR_REQGEN 0x00000400U /*!< DMAMUX request generator overrun error */
// Temperature Errors
#define TEMP_ERROR_MASK 0x05000000
// Userflash Errors
#define TEMP_ERROR_SENSORM_MASK 0x00100000
#define TEMP_ERROR_SENSORW_MASK 0x00200000
#define TEMP_ERROR_SPI_FAILURE 0x00010000
#define TEMP_ERROR_GENERAL_FAILURE 0x00020000
#define TEMP_ERROR_SENSOR_FAILURE 0x00040000
// #define ADCD_FAULT_HIGHTHRESH 0x80
// #define ADCD_FAULT_LOWTHRESH 0x40
// #define ADCD_FAULT_REFINLOW 0x20
// #define ADCD_FAULT_REFINHIGH 0x10
// #define ADCD_FAULT_RTDINLOW 0x08
// #define ADCD_FAULT_OVUV 0x04
// Variable Handler Errors
#define VARH_ERROR_MASK 0x06000000
#define VARH_ERROR_INVALID_VARIABLE 0x00000001
#define VARH_ERROR_INVALID_DATA 0x00000002
#define VARH_ERROR_READONLY 0x00000004
#define VARH_ERROR_OUTOFRANGE 0x00000008
#define VARH_ERROR_OUTOFRANGE_INT 0x00000010
#define VARH_ERROR_LOAD_FLASH 0x00000020 // Error while loading from flash -> sets all variables to default
// Peltier Controller Errors
#define PELTIER_ERROR_MASK 0x07000000
#define PELTIER_ERROR_SETVOLTAGE 0x00000001
#define PELTIER_ERROR_SETVOLTAGE_PID 0x00000002
#define PELTIER_ERROR_MAX_POWER 0x00000004
// Main Application Errors
#define MAIN_ERROR_MASK 0x08000000
#define MAIN_ERROR_REG_NOT_FOUND 0x00000001
#define MAIN_ERROR_CMD_NOT_FOUND 0x00000002
#define MAIN_ERROR_SAVE_FLASH 0x00000004
#define MAIN_ERROR_WATCHDOG 0x00000008 // not implemented
// HardFault Errors
#define HARDFAULT_ERROR_MASK 0x09000000
#define HARDFAULT_ERROR_IWDG 0x00000001
#define HARDFAULT_ERROR_SWRST 0x00000002 // Software Reset (if any hardfault occurs or user requests it via command)
//=================================================================================================
// Section: MACROS
// Description: Definition of global macros (visible by all modules).
@ -115,6 +209,9 @@ extern "C" {
//=================================================================================================
BOOL ERRH_boInitializeModule( VOID );
VOID ERRH_vSetError( U32 u32Error );
U32 ERRH_u32GetError( VOID );
VOID ERRH_vClearError( VOID );
#ifdef __cplusplus
}

72
Core/Drivers/SPID_SpiDriver.c
View File

@ -41,6 +41,8 @@
// Drivers
#include "DIPO_DigitalPorts.h"
#include "ERRH_ErrorHandler.h"
// include STM32 drivers
#include "stm32l4xx_hal.h"
@ -173,14 +175,6 @@ BOOL SPID_boSend( SPID_StHandle* pstHandle )
BOOL boOK;
U32 u32Flags = 0;
#if defined(PDEF_FUNCTION_PARAMETER_CHECK_ENABLED) && PDEF_FUNCTION_PARAMETER_CHECK_ENABLED == TRUE
if( pstHandle == NULL || pstHandle->enSPI >= SPID_eNumberOfSPIs )
{
ELOG_ADD_LOG( ELOG_eInvalidFunctionParameter );
return( FALSE );
}
#endif
osMutexAcquire( m_astSPI[pstHandle->enSPI].pstMutexID, osWaitForever );
// clear all flags
@ -214,14 +208,6 @@ BOOL SPID_boSendReceive( SPID_StHandle* pstHandle )
{
BOOL boOK;
U32 u32Flags = 0;
#if defined(PDEF_FUNCTION_PARAMETER_CHECK_ENABLED) && PDEF_FUNCTION_PARAMETER_CHECK_ENABLED == TRUE
if( pstHandle == NULL || pstHandle->enSPI >= SPID_eNumberOfSPIs )
{
ELOG_ADD_LOG( ELOG_eInvalidFunctionParameter );
return( FALSE );
}
#endif
osMutexAcquire( m_astSPI[pstHandle->enSPI].pstMutexID, osWaitForever );
@ -257,13 +243,6 @@ BOOL SPID_boSendReceive( SPID_StHandle* pstHandle )
//-------------------------------------------------------------------------------------------------
VOID HAL_SPI_TxRxCpltCallback( SPI_HandleTypeDef *hspi )
{
#if defined(PDEF_FUNCTION_PARAMETER_CHECK_ENABLED) && PDEF_FUNCTION_PARAMETER_CHECK_ENABLED == TRUE
if( hspi == NULL )
{
ELOG_ADD_LOG( ELOG_eInvalidFunctionParameter );
return;
}
#endif
SPID_EnSPIs enSPI = enGetSPI( hspi );
osEventFlagsSet( m_pstEventID, m_astSPI[enSPI].u32SPICompleteFlag );
@ -277,13 +256,6 @@ VOID HAL_SPI_TxRxCpltCallback( SPI_HandleTypeDef *hspi )
//-------------------------------------------------------------------------------------------------
VOID HAL_SPI_TxCpltCallback( SPI_HandleTypeDef *hspi )
{
#if defined(PDEF_FUNCTION_PARAMETER_CHECK_ENABLED) && PDEF_FUNCTION_PARAMETER_CHECK_ENABLED == TRUE
if( hspi == NULL )
{
ELOG_ADD_LOG( ELOG_eInvalidFunctionParameter );
return;
}
#endif
SPID_EnSPIs enSPI = enGetSPI( hspi );
osEventFlagsSet( m_pstEventID, m_astSPI[enSPI].u32SPICompleteFlag );
@ -297,13 +269,6 @@ VOID HAL_SPI_TxCpltCallback( SPI_HandleTypeDef *hspi )
//-------------------------------------------------------------------------------------------------
VOID HAL_SPI_RxCpltCallback( SPI_HandleTypeDef *hspi )
{
#if defined(PDEF_FUNCTION_PARAMETER_CHECK_ENABLED) && PDEF_FUNCTION_PARAMETER_CHECK_ENABLED == TRUE
if( hspi == NULL )
{
ELOG_ADD_LOG( ELOG_eInvalidFunctionParameter );
return;
}
#endif
SPID_EnSPIs enSPI = enGetSPI( hspi );
osEventFlagsSet( m_pstEventID, m_astSPI[enSPI].u32SPICompleteFlag );
@ -317,31 +282,7 @@ VOID HAL_SPI_RxCpltCallback( SPI_HandleTypeDef *hspi )
//-------------------------------------------------------------------------------------------------
VOID HAL_SPI_ErrorCallback( SPI_HandleTypeDef *hspi )
{
#if defined(PDEF_FUNCTION_PARAMETER_CHECK_ENABLED) && PDEF_FUNCTION_PARAMETER_CHECK_ENABLED == TRUE
if( hspi == NULL )
{
ELOG_ADD_LOG( ELOG_eInvalidFunctionParameter );
return;
}
#endif
// check rx overrun error
if( hspi->ErrorCode & HAL_SPI_ERROR_OVR )
{
//ELOG_ADD_LOG( ELOG_eSPIOverrunError );
}
// check rx dma transfer error
if( hspi->hdmarx->ErrorCode & HAL_DMA_ERROR_TE )
{
//ELOG_ADD_LOG( ELOG_eDMAHTransferError );
}
// check tx dma transfer error
if( hspi->hdmatx->ErrorCode & HAL_DMA_ERROR_TE )
{
//ELOG_ADD_LOG( ELOG_eDMAHTransferError );
}
ERRH_vSetError(SPI_ERROR_MASK | hspi->ErrorCode);
SPID_EnSPIs enSPI = enGetSPI( hspi );
osEventFlagsSet( m_pstEventID, m_astSPI[enSPI].u32SPIErrorFlag );
@ -355,13 +296,6 @@ VOID HAL_SPI_ErrorCallback( SPI_HandleTypeDef *hspi )
//-------------------------------------------------------------------------------------------------
PRIVATE SPID_EnSPIs enGetSPI( SPI_HandleTypeDef* pstSPI )
{
#if defined(PDEF_FUNCTION_PARAMETER_CHECK_ENABLED) && PDEF_FUNCTION_PARAMETER_CHECK_ENABLED == TRUE
if( pstSPI == NULL )
{
ELOG_ADD_LOG( ELOG_eInvalidFunctionParameter );
ASRT_ASSERT( FALSE );
}
#endif
for( U8 u8Cnt = 0; u8Cnt < SPID_eNumberOfSPIs; u8Cnt++ )
{

26
Core/Drivers/TEMP_Temperature.c
View File

@ -36,6 +36,8 @@
// Toolbox
#include "../Toolbox/UTIL_Utility.h"
#include "ERRH_ErrorHandler.h"
// Drivers
#include "ADCD_AdcDriver.h"
@ -161,11 +163,13 @@ PRIVATE VOID vTask( PVOID arg )
flTempData[ADCD_eWater] = flConvertADCData( u16ADC_data );
} else {
if( (u8error & ADCD_STATUS_DATA_ERROR) == ADCD_STATUS_DATA_ERROR ){
BOOL boFatal = TRUE;
if( (u8error & ADCD_FAULT_HIGHTHRESH) == ADCD_FAULT_HIGHTHRESH ){
flTempData[ADCD_eWater] = 4200.0f;
boFatal &= FALSE;
}else if( (u8error & ADCD_FAULT_LOWTHRESH) == ADCD_FAULT_LOWTHRESH ){
flTempData[ADCD_eWater] = -273.16f;
boFatal &= FALSE;
}else if( (u8error & ADCD_FAULT_REFINLOW) == ADCD_FAULT_REFINLOW ){
flTempData[ADCD_eWater] = -273.16f;
}else if( (u8error & ADCD_FAULT_REFINHIGH) == ADCD_FAULT_REFINHIGH ){
@ -178,19 +182,21 @@ PRIVATE VOID vTask( PVOID arg )
flTempData[ADCD_eWater] = -273.16f;
}
if(boFatal) ERRH_vSetError(TEMP_ERROR_MASK | TEMP_ERROR_SENSORW_MASK | TEMP_ERROR_SENSOR_FAILURE | u8error);
/** @todo call error handler temp data */
} else if( (u8error & ADCD_SPI_FAILURE) == ADCD_SPI_FAILURE ){
flTempData[ADCD_eWater] = -273.16f;
/** @todo call error handler onchip spi failure */
ERRH_vSetError(TEMP_ERROR_MASK | TEMP_ERROR_SENSORW_MASK | TEMP_ERROR_SPI_FAILURE);
} else {
flTempData[ADCD_eWater] = -273.16f;
ERRH_vSetError(TEMP_ERROR_MASK | TEMP_ERROR_SENSORW_MASK | TEMP_ERROR_GENERAL_FAILURE);
}
u8error = 0;
boOK = TRUE;
}
@ -203,11 +209,13 @@ PRIVATE VOID vTask( PVOID arg )
flTempData[ADCD_eModule] = flConvertADCData( u16ADC_data );
} else {
if( (u8error & ADCD_STATUS_DATA_ERROR) == ADCD_STATUS_DATA_ERROR ){
BOOL boFatal = TRUE;
if( (u8error & ADCD_FAULT_HIGHTHRESH) == ADCD_FAULT_HIGHTHRESH ){
flTempData[ADCD_eModule] = 4200.0f;
boFatal &= FALSE;
}else if( (u8error & ADCD_FAULT_LOWTHRESH) == ADCD_FAULT_LOWTHRESH ){
flTempData[ADCD_eModule] = -273.16f;
boFatal &= FALSE;
}else if( (u8error & ADCD_FAULT_REFINLOW) == ADCD_FAULT_REFINLOW ){
flTempData[ADCD_eModule] = -273.16f;
}else if( (u8error & ADCD_FAULT_REFINHIGH) == ADCD_FAULT_REFINHIGH ){
@ -219,16 +227,18 @@ PRIVATE VOID vTask( PVOID arg )
} else {
flTempData[ADCD_eModule] = -273.16f;
}
/** @todo call error handler temp data */
if(boFatal) ERRH_vSetError(TEMP_ERROR_MASK | TEMP_ERROR_SENSORM_MASK | TEMP_ERROR_SENSOR_FAILURE | u8error);
} else if( (u8error & ADCD_SPI_FAILURE) == ADCD_SPI_FAILURE ){
flTempData[ADCD_eModule] = -273.16f;
/** @todo call error handler onchip spi failure */
ERRH_vSetError(TEMP_ERROR_MASK | TEMP_ERROR_SENSORM_MASK | TEMP_ERROR_SPI_FAILURE);
} else {
flTempData[ADCD_eModule] = -273.16f;
ERRH_vSetError(TEMP_ERROR_MASK | TEMP_ERROR_SENSORM_MASK | TEMP_ERROR_GENERAL_FAILURE);
}

4
Core/Src/main.c
View File

@ -30,6 +30,7 @@
/* Private includes ----------------------------------------------------------*/
/* USER CODE BEGIN Includes */
#include "../Application/INIT_Initialization.h"
#include "../Application/PECO_PeltierController.h"
/* USER CODE END Includes */
/* Private typedef -----------------------------------------------------------*/
@ -692,6 +693,9 @@ void Error_Handler(void)
{
/* USER CODE BEGIN Error_Handler_Debug */
PECO_Enable( FALSE );
HAL_NVIC_SystemReset();
/* User can add his own implementation to report the HAL error return state */
__disable_irq();

15
Core/Src/stm32l4xx_it.c
View File

@ -25,6 +25,7 @@
#include "task.h"
/* Private includes ----------------------------------------------------------*/
/* USER CODE BEGIN Includes */
#include "../Application/PECO_PeltierController.h"
/* USER CODE END Includes */
/* Private typedef -----------------------------------------------------------*/
@ -77,6 +78,8 @@ extern SPI_HandleTypeDef hspi1;
void NMI_Handler(void)
{
/* USER CODE BEGIN NonMaskableInt_IRQn 0 */
PECO_Enable( FALSE );
HAL_NVIC_SystemReset();
/* USER CODE END NonMaskableInt_IRQn 0 */
/* USER CODE BEGIN NonMaskableInt_IRQn 1 */
@ -93,6 +96,9 @@ void HardFault_Handler(void)
{
/* USER CODE BEGIN HardFault_IRQn 0 */
PECO_Enable( FALSE );
HAL_NVIC_SystemReset();
/* USER CODE END HardFault_IRQn 0 */
while (1)
{
@ -108,6 +114,9 @@ void MemManage_Handler(void)
{
/* USER CODE BEGIN MemoryManagement_IRQn 0 */
PECO_Enable( FALSE );
HAL_NVIC_SystemReset();
/* USER CODE END MemoryManagement_IRQn 0 */
while (1)
{
@ -123,6 +132,9 @@ void BusFault_Handler(void)
{
/* USER CODE BEGIN BusFault_IRQn 0 */
PECO_Enable( FALSE );
HAL_NVIC_SystemReset();
/* USER CODE END BusFault_IRQn 0 */
while (1)
{
@ -138,6 +150,9 @@ void UsageFault_Handler(void)
{
/* USER CODE BEGIN UsageFault_IRQn 0 */
PECO_Enable( FALSE );
HAL_NVIC_SystemReset();
/* USER CODE END UsageFault_IRQn 0 */
while (1)
{