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 ) PRIVATE VOID vTask( PVOID arg )
{ {
UNUSED( arg ); UNUSED( arg );
BOOL boOK = TRUE; BOOL boOK = TRUE;
boOK &= ERRH_boInitializeModule();
boOK &= USFL_boInitializeModule();
boOK &= VARH_boInitializeModule();
boOK &= DIPO_boInitializeModule(); uint32_t reset_flags = RCC->CSR;
boOK &= ANPI_boInitializeModule();
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 &= ANPO_boInitializeModule();
boOK &= SPID_boInitializeModule(); boOK &= SPID_boInitializeModule();
boOK &= ADCD_boInitializeModule(); boOK &= ADCD_boInitializeModule();
boOK &= TEMP_boInitializeModule(); boOK &= TEMP_boInitializeModule();
boOK &= CAND_boInitializeModule(); boOK &= CAND_boInitializeModule();
boOK &= PECO_boInitializeModule(); boOK &= PECO_boInitializeModule();
boOK &= MAIN_boInitializeModule(); boOK &= MAIN_boInitializeModule();
if( !boOK ){ if( !boOK ){
osKernelLock(); // lock kernel to prevent task switch osKernelLock(); // lock kernel to prevent task switch
PECO_Enable( FALSE );
while( 1 ){ // Toggle Error LED fast while( 1 ){ // Toggle Error LED fast
DIPO_vToggleOutput( DIPO_eLED ); DIPO_vToggleOutput( DIPO_eLED );
DELAY_MS( 100 ); DELAY_MS( 100 );

132
Core/Application/MAIN_MainApplication.c
View File

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

10
Core/Application/PECO_PeltierController.c
View File

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

13
Core/Application/VARH_VariableHandler.c
View File

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

30
Core/Drivers/ANPI_AnalogPortsIn.c
View File

@ -36,6 +36,8 @@
// Drivers // Drivers
#include "PECO_PeltierController.h" #include "PECO_PeltierController.h"
#include "ERRH_ErrorHandler.h"
// Toolbox // Toolbox
#include "../Toolbox/UTIL_Utility.h" #include "../Toolbox/UTIL_Utility.h"
@ -316,30 +318,12 @@ void HAL_ADC_ConvHalfCpltCallback( ADC_HandleTypeDef* hadc )
//------------------------------------------------------------------------------------------------- //-------------------------------------------------------------------------------------------------
void HAL_ADC_ErrorCallback( 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 // Driver
#include "DIPO_DigitalPorts.h" #include "DIPO_DigitalPorts.h"
#include "ERRH_ErrorHandler.h"
// include STM32 drivers // include STM32 drivers
#include "stm32l4xx_hal.h" #include "stm32l4xx_hal.h"
@ -258,8 +260,8 @@ void HAL_CAN_RxFifo0MsgPendingCallback( CAN_HandleTypeDef *hcan ){
// Returns: None // Returns: None
//------------------------------------------------------------------------------------------------- //-------------------------------------------------------------------------------------------------
void HAL_CAN_ErrorCallback( CAN_HandleTypeDef *hcan ){ void HAL_CAN_ErrorCallback( CAN_HandleTypeDef *hcan ){
// U32 u32Error = hcan->ErrorCode; U32 u32Error = hcan->ErrorCode;
/** TODO: Can Error Handling */ ERRH_vSetError(CAN_ERROR_MASK | u32Error);
} }

21
Core/Drivers/ERRH_ErrorHandler.c
View File

@ -31,6 +31,7 @@
//================================================================================================= //=================================================================================================
#include "ERRH_ErrorHandler.h" #include "ERRH_ErrorHandler.h"
#include "VARH_VariableHandler.h"
// Toolbox // Toolbox
#include "../Toolbox/UTIL_Utility.h" #include "../Toolbox/UTIL_Utility.h"
@ -106,12 +107,30 @@ BOOL ERRH_boInitializeModule( VOID )
{ {
BOOL boOK = TRUE; BOOL boOK = TRUE;
// nothing to do yet in init
return( boOK ); 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 // 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 // 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 // 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 // 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 // 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 // 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 // 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 // Section: MACROS
// Description: Definition of global macros (visible by all modules). // Description: Definition of global macros (visible by all modules).
@ -115,6 +209,9 @@ extern "C" {
//================================================================================================= //=================================================================================================
BOOL ERRH_boInitializeModule( VOID ); BOOL ERRH_boInitializeModule( VOID );
VOID ERRH_vSetError( U32 u32Error );
U32 ERRH_u32GetError( VOID );
VOID ERRH_vClearError( VOID );
#ifdef __cplusplus #ifdef __cplusplus
} }

72
Core/Drivers/SPID_SpiDriver.c
View File

@ -41,6 +41,8 @@
// Drivers // Drivers
#include "DIPO_DigitalPorts.h" #include "DIPO_DigitalPorts.h"
#include "ERRH_ErrorHandler.h"
// include STM32 drivers // include STM32 drivers
#include "stm32l4xx_hal.h" #include "stm32l4xx_hal.h"
@ -173,14 +175,6 @@ BOOL SPID_boSend( SPID_StHandle* pstHandle )
BOOL boOK; BOOL boOK;
U32 u32Flags = 0; 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 ); osMutexAcquire( m_astSPI[pstHandle->enSPI].pstMutexID, osWaitForever );
// clear all flags // clear all flags
@ -214,14 +208,6 @@ BOOL SPID_boSendReceive( SPID_StHandle* pstHandle )
{ {
BOOL boOK; BOOL boOK;
U32 u32Flags = 0; 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 ); osMutexAcquire( m_astSPI[pstHandle->enSPI].pstMutexID, osWaitForever );
@ -257,13 +243,6 @@ BOOL SPID_boSendReceive( SPID_StHandle* pstHandle )
//------------------------------------------------------------------------------------------------- //-------------------------------------------------------------------------------------------------
VOID HAL_SPI_TxRxCpltCallback( SPI_HandleTypeDef *hspi ) 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 ); SPID_EnSPIs enSPI = enGetSPI( hspi );
osEventFlagsSet( m_pstEventID, m_astSPI[enSPI].u32SPICompleteFlag ); 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 ) 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 ); SPID_EnSPIs enSPI = enGetSPI( hspi );
osEventFlagsSet( m_pstEventID, m_astSPI[enSPI].u32SPICompleteFlag ); 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 ) 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 ); SPID_EnSPIs enSPI = enGetSPI( hspi );
osEventFlagsSet( m_pstEventID, m_astSPI[enSPI].u32SPICompleteFlag ); 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 ) VOID HAL_SPI_ErrorCallback( SPI_HandleTypeDef *hspi )
{ {
#if defined(PDEF_FUNCTION_PARAMETER_CHECK_ENABLED) && PDEF_FUNCTION_PARAMETER_CHECK_ENABLED == TRUE ERRH_vSetError(SPI_ERROR_MASK | hspi->ErrorCode);
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 );
}
SPID_EnSPIs enSPI = enGetSPI( hspi ); SPID_EnSPIs enSPI = enGetSPI( hspi );
osEventFlagsSet( m_pstEventID, m_astSPI[enSPI].u32SPIErrorFlag ); 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 ) 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++ ) for( U8 u8Cnt = 0; u8Cnt < SPID_eNumberOfSPIs; u8Cnt++ )
{ {

26
Core/Drivers/TEMP_Temperature.c
View File

@ -36,6 +36,8 @@
// Toolbox // Toolbox
#include "../Toolbox/UTIL_Utility.h" #include "../Toolbox/UTIL_Utility.h"
#include "ERRH_ErrorHandler.h"
// Drivers // Drivers
#include "ADCD_AdcDriver.h" #include "ADCD_AdcDriver.h"
@ -161,11 +163,13 @@ PRIVATE VOID vTask( PVOID arg )
flTempData[ADCD_eWater] = flConvertADCData( u16ADC_data ); flTempData[ADCD_eWater] = flConvertADCData( u16ADC_data );
} else { } else {
if( (u8error & ADCD_STATUS_DATA_ERROR) == ADCD_STATUS_DATA_ERROR ){ if( (u8error & ADCD_STATUS_DATA_ERROR) == ADCD_STATUS_DATA_ERROR ){
BOOL boFatal = TRUE;
if( (u8error & ADCD_FAULT_HIGHTHRESH) == ADCD_FAULT_HIGHTHRESH ){ if( (u8error & ADCD_FAULT_HIGHTHRESH) == ADCD_FAULT_HIGHTHRESH ){
flTempData[ADCD_eWater] = 4200.0f; flTempData[ADCD_eWater] = 4200.0f;
boFatal &= FALSE;
}else if( (u8error & ADCD_FAULT_LOWTHRESH) == ADCD_FAULT_LOWTHRESH ){ }else if( (u8error & ADCD_FAULT_LOWTHRESH) == ADCD_FAULT_LOWTHRESH ){
flTempData[ADCD_eWater] = -273.16f; flTempData[ADCD_eWater] = -273.16f;
boFatal &= FALSE;
}else if( (u8error & ADCD_FAULT_REFINLOW) == ADCD_FAULT_REFINLOW ){ }else if( (u8error & ADCD_FAULT_REFINLOW) == ADCD_FAULT_REFINLOW ){
flTempData[ADCD_eWater] = -273.16f; flTempData[ADCD_eWater] = -273.16f;
}else if( (u8error & ADCD_FAULT_REFINHIGH) == ADCD_FAULT_REFINHIGH ){ }else if( (u8error & ADCD_FAULT_REFINHIGH) == ADCD_FAULT_REFINHIGH ){
@ -178,19 +182,21 @@ PRIVATE VOID vTask( PVOID arg )
flTempData[ADCD_eWater] = -273.16f; 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 */ /** @todo call error handler temp data */
} else if( (u8error & ADCD_SPI_FAILURE) == ADCD_SPI_FAILURE ){ } else if( (u8error & ADCD_SPI_FAILURE) == ADCD_SPI_FAILURE ){
flTempData[ADCD_eWater] = -273.16f; 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 { } else {
flTempData[ADCD_eWater] = -273.16f; flTempData[ADCD_eWater] = -273.16f;
ERRH_vSetError(TEMP_ERROR_MASK | TEMP_ERROR_SENSORW_MASK | TEMP_ERROR_GENERAL_FAILURE);
} }
u8error = 0; u8error = 0;
boOK = TRUE; boOK = TRUE;
} }
@ -203,11 +209,13 @@ PRIVATE VOID vTask( PVOID arg )
flTempData[ADCD_eModule] = flConvertADCData( u16ADC_data ); flTempData[ADCD_eModule] = flConvertADCData( u16ADC_data );
} else { } else {
if( (u8error & ADCD_STATUS_DATA_ERROR) == ADCD_STATUS_DATA_ERROR ){ if( (u8error & ADCD_STATUS_DATA_ERROR) == ADCD_STATUS_DATA_ERROR ){
BOOL boFatal = TRUE;
if( (u8error & ADCD_FAULT_HIGHTHRESH) == ADCD_FAULT_HIGHTHRESH ){ if( (u8error & ADCD_FAULT_HIGHTHRESH) == ADCD_FAULT_HIGHTHRESH ){
flTempData[ADCD_eModule] = 4200.0f; flTempData[ADCD_eModule] = 4200.0f;
boFatal &= FALSE;
}else if( (u8error & ADCD_FAULT_LOWTHRESH) == ADCD_FAULT_LOWTHRESH ){ }else if( (u8error & ADCD_FAULT_LOWTHRESH) == ADCD_FAULT_LOWTHRESH ){
flTempData[ADCD_eModule] = -273.16f; flTempData[ADCD_eModule] = -273.16f;
boFatal &= FALSE;
}else if( (u8error & ADCD_FAULT_REFINLOW) == ADCD_FAULT_REFINLOW ){ }else if( (u8error & ADCD_FAULT_REFINLOW) == ADCD_FAULT_REFINLOW ){
flTempData[ADCD_eModule] = -273.16f; flTempData[ADCD_eModule] = -273.16f;
}else if( (u8error & ADCD_FAULT_REFINHIGH) == ADCD_FAULT_REFINHIGH ){ }else if( (u8error & ADCD_FAULT_REFINHIGH) == ADCD_FAULT_REFINHIGH ){
@ -219,16 +227,18 @@ PRIVATE VOID vTask( PVOID arg )
} else { } else {
flTempData[ADCD_eModule] = -273.16f; 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 ){ } else if( (u8error & ADCD_SPI_FAILURE) == ADCD_SPI_FAILURE ){
flTempData[ADCD_eModule] = -273.16f; 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 { } else {
flTempData[ADCD_eModule] = -273.16f; 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 ----------------------------------------------------------*/ /* Private includes ----------------------------------------------------------*/
/* USER CODE BEGIN Includes */ /* USER CODE BEGIN Includes */
#include "../Application/INIT_Initialization.h" #include "../Application/INIT_Initialization.h"
#include "../Application/PECO_PeltierController.h"
/* USER CODE END Includes */ /* USER CODE END Includes */
/* Private typedef -----------------------------------------------------------*/ /* Private typedef -----------------------------------------------------------*/
@ -692,6 +693,9 @@ void Error_Handler(void)
{ {
/* USER CODE BEGIN Error_Handler_Debug */ /* 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 */ /* User can add his own implementation to report the HAL error return state */
__disable_irq(); __disable_irq();

15
Core/Src/stm32l4xx_it.c
View File

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

2749
tecware_v08.srec Normal file
View File

File diff suppressed because it is too large Load Diff