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

added and changed the variable Handler

Browse Source
This commit is contained in:
Noah Piqué
2021-12-10 11:23:47 +01:00
parent 8672cb52c8
commit de0ddf839a
3 changed files with 116 additions and 336 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
Core/Application/INIT_Initialization.c
View File

@ -35,7 +35,7 @@
#include "INIT_Initialization.h" #include "INIT_Initialization.h"
// Application // Application
//#include "VARH_VariableHandler.h" #include "VARH_VariableHandler.h"
//#include "RTOS_RealTimeOS.h" //#include "RTOS_RealTimeOS.h"
@ -170,6 +170,7 @@ PRIVATE VOID vInitTask( PVOID arg )
// boOK &= RTOS_boInitializeModule(); // boOK &= RTOS_boInitializeModule();
boOK &= USFL_boInitializeModule(); boOK &= USFL_boInitializeModule();
boOK &= VARH_boInitializeModule();
boOK &= DIPO_boInitializeModule(); boOK &= DIPO_boInitializeModule();
boOK &= ANPI_boInitializeModule(); boOK &= ANPI_boInitializeModule();

307
Core/Application/VARH_VariableHandler.c
View File

@ -19,7 +19,7 @@
// //
//------------------------------------------------------------------------------------------------- //-------------------------------------------------------------------------------------------------
// //
// Description: This source file contains all functions dealing with variables // Description: This source file contains all functions dealing with global variables
// //
//================================================================================================= //=================================================================================================
@ -34,7 +34,6 @@
#include "VARH_VariableHandler.h" #include "VARH_VariableHandler.h"
// Toolbox // Toolbox
#include "../Toolbox/ASRT_Assert.h"
#include "../Toolbox/UTIL_Utility.h" #include "../Toolbox/UTIL_Utility.h"
#include "cmsis_os2.h" #include "cmsis_os2.h"
@ -45,7 +44,7 @@
//================================================================================================= //=================================================================================================
// define the number of notifications according the need // define the number of notifications according the need
#define NUMBER_OF_NOTIFICATOINS 1 #define NUMBER_OF_NOTIFICATIONS 2
//================================================================================================= //=================================================================================================
@ -73,20 +72,13 @@ typedef struct
PVOID pvArgument; PVOID pvArgument;
} StNotification; } StNotification;
typedef struct
{
VARH_pfnRangeCheck pfnCallback;
PVOID pvArgument;
} StRangeCheck;
//================================================================================================= //=================================================================================================
// Section: LOCAL VARIABLES // Section: LOCAL VARIABLES
// Description: Definition of local variables (visible by this module only). // Description: Definition of local variables (visible by this module only).
//================================================================================================= //=================================================================================================
LOCAL VARH_UVariable m_auVariable[VARH_eNumberOfVariables]; LOCAL VARH_UVariable m_auVariable[VARH_eNumberOfVariables];
LOCAL StNotification m_astNotifications[VARH_eNumberOfVariables][VARH_eNumberOfNotificationTypes][NUMBER_OF_NOTIFICATOINS] = { 0 }; LOCAL StNotification m_astNotifications[VARH_eNumberOfVariables][VARH_eNumberOfNotificationTypes][NUMBER_OF_NOTIFICATIONS] = { 0 };
LOCAL StRangeCheck m_astRangeCheck[VARH_eNumberOfVariables] = { 0 };
LOCAL osMutexId_t m_pstMutexID = NULL; LOCAL osMutexId_t m_pstMutexID = NULL;
@ -98,23 +90,9 @@ LOCAL osMutexId_t m_pstMutexID = NULL;
LOCAL CONST VARH_StVarInfo m_astVarInfo[VARH_eNumberOfVariables] = LOCAL CONST VARH_StVarInfo m_astVarInfo[VARH_eNumberOfVariables] =
{ {
{"Status", VARH_FLAG_READONLY, VARH_eUnitByte, VARH_ePrefixNone, (VARH_UVariable)TRUE}, // VARH_eEnable, { VARH_FLAG_READONLY | VARH_FLAG_FLOAT, (VARH_UVariable)0.0f, (VARH_UVariable)-60.0f, (VARH_UVariable)100.0f }, // VARH_eTemp_H,
{ VARH_FLAG_READONLY | VARH_FLAG_FLOAT, (VARH_UVariable)0.0f, (VARH_UVariable)-60.0f, (VARH_UVariable)100.0f }, // VARH_eTemp_C,
{"VoltageRef En", VARH_FLAG_NONE, VARH_eUnitBoolean, VARH_ePrefixNone, (VARH_UVariable)FALSE}, // VARH_eSetMode, { VARH_FLAG_READONLY | VARH_FLAG_FLOAT, (VARH_UVariable)0.0f, (VARH_UVariable)-50.0f, (VARH_UVariable)70.0f }, // VARH_eTemp_Diff,
{"Status G", VARH_FLAG_NONE, VARH_eUnitBoolean, VARH_ePrefixNone, (VARH_UVariable)FALSE}, // VARH_eInvertA,
{"Status R", VARH_FLAG_NONE, VARH_eUnitBoolean, VARH_ePrefixNone, (VARH_UVariable)FALSE}, // VARH_eInvertB,
{"Enabled G", VARH_FLAG_NONE, VARH_eUnitBoolean, VARH_ePrefixNone, (VARH_UVariable)FALSE}, // VARH_eInvertA,
{"Enabled R", VARH_FLAG_NONE, VARH_eUnitBoolean, VARH_ePrefixNone, (VARH_UVariable)FALSE}, // VARH_eInvertB,
{"Inverted G", VARH_FLAG_NONE, VARH_eUnitBoolean, VARH_ePrefixNone, (VARH_UVariable)FALSE}, // VARH_eInvertA,
{"Inverted R", VARH_FLAG_NONE, VARH_eUnitBoolean, VARH_ePrefixNone, (VARH_UVariable)FALSE}, // VARH_eInvertB,
{"Spare G", VARH_FLAG_NONE, VARH_eUnitBoolean, VARH_ePrefixNone, (VARH_UVariable)FALSE}, // VARH_eInvertA,
{"Spare R", VARH_FLAG_NONE, VARH_eUnitBoolean, VARH_ePrefixNone, (VARH_UVariable)FALSE}, // VARH_eInvertB,
{"Temp HeatSink", VARH_FLAG_FLOAT | VARH_FLAG_READONLY, VARH_eUnitCelsius, VARH_ePrefixNone, (VARH_UVariable)0.0f}, // VARH_eTempCS,
{"Temp Shunt", VARH_FLAG_FLOAT | VARH_FLAG_READONLY, VARH_eUnitCelsius, VARH_ePrefixNone, (VARH_UVariable)0.0f}, // VARH_eTempRef,
{"Temp VoltageRef", VARH_FLAG_FLOAT | VARH_FLAG_READONLY, VARH_eUnitCelsius, VARH_ePrefixNone, (VARH_UVariable)0.0f}, // VARH_eTempShunt,
{"Temp CurrentSrc", VARH_FLAG_FLOAT | VARH_FLAG_READONLY, VARH_eUnitCelsius, VARH_ePrefixNone, (VARH_UVariable)0.0f}, // VARH_eTempShunt,
}; };
@ -132,15 +110,18 @@ LOCAL CONST osMutexAttr_t m_stMutexAttr =
// Description: Definition of local functions (visible by this module only). // Description: Definition of local functions (visible by this module only).
//================================================================================================= //=================================================================================================
// notification functions
PRIVATE VOID vSetVariablesToInitDataCallback( PVOID pvData );
PRIVATE VOID vCallNotifications( U8 u8Variable, VARH_UVariable uOldData, VARH_UVariable uNewData ); PRIVATE VOID vCallNotifications( U8 u8Variable, VARH_UVariable uOldData, VARH_UVariable uNewData );
PRIVATE BOOL boNewValue( VARH_UVariable uOldData, VARH_UVariable uNewData );
// check functions
PRIVATE BOOL boCheckRange( U8 u8Variable, VARH_UVariable uNewData ); PRIVATE BOOL boCheckRange( U8 u8Variable, VARH_UVariable uNewData );
PRIVATE BOOL boRising( U8 u8Variable, VARH_UVariable uOldData, VARH_UVariable uNewData ); PRIVATE BOOL boBooleanVarCheck( U32 u32NewValue );
PRIVATE BOOL boFalling( U8 u8Variable, VARH_UVariable uOldData, VARH_UVariable uNewData ); PRIVATE BOOL boU32VarCheck( U8 u8Variable, U32 u32NewValue );
PRIVATE BOOL boNewValue( U8 u8Variable, VARH_UVariable uOldData, VARH_UVariable uNewData ); PRIVATE BOOL boS32VarCheck( U8 u8Variable, S32 s32NewValue );
PRIVATE BOOL boFloatVarCheck( U8 u8Variable, FLOAT flNewValue );
//================================================================================================= //=================================================================================================
// Section: EXTERNAL FUNCTIONS // Section: EXTERNAL FUNCTIONS
@ -167,20 +148,15 @@ PRIVATE BOOL boNewValue( U8 u8Variable, VARH_UVariable uOldData, VARH_UVariable
// Parameters: BOOL boInitConfig // Parameters: BOOL boInitConfig
// Returns: Boolean TRUE if successful // Returns: Boolean TRUE if successful
//------------------------------------------------------------------------------------------------- //-------------------------------------------------------------------------------------------------
BOOL VARH_boInitializeModule( BOOL boInitConfig ) BOOL VARH_boInitializeModule( VOID )
{ {
ASRT_STATIC_ASSERT( VARH_eNumberOfVariables <= 255 );
BOOL boOK = TRUE; BOOL boOK = TRUE;
boOK &= ((m_pstMutexID = osMutexNew( &m_stMutexAttr )) == NULL) ? FALSE : TRUE; boOK &= ((m_pstMutexID = osMutexNew( &m_stMutexAttr )) == NULL) ? FALSE : TRUE;
memset( &m_astNotifications, 0, sizeof(m_astNotifications) ); // reset the notifications memset( &m_astNotifications, 0, sizeof(m_astNotifications) ); // reset the notifications
memset( &m_astRangeCheck, 0, sizeof(m_astRangeCheck) ); // reset the function pointers
if( boInitConfig )
{
VARH_vSetAllVariablesToInitData(); VARH_vSetAllVariablesToInitData();
}
return( boOK ); return( boOK );
} }
@ -197,14 +173,12 @@ BOOL VARH_boInitializeModule( BOOL boInitConfig )
BOOL VARH_boRegisterNotification( U8 u8Variable, VARH_EnNotification enNotification, VARH_pfnNotification pfnCallback, PVOID pvCallbackArgument ) BOOL VARH_boRegisterNotification( U8 u8Variable, VARH_EnNotification enNotification, VARH_pfnNotification pfnCallback, PVOID pvCallbackArgument )
{ {
// check parameters // check parameters
#if defined(PDEF_FUNCTION_PARAMETER_CHECK_ENABLED) && PDEF_FUNCTION_PARAMETER_CHECK_ENABLED == TRUE
if( enNotification >= VARH_eNumberOfNotificationTypes || pfnCallback == NULL) if( enNotification >= VARH_eNumberOfNotificationTypes || pfnCallback == NULL)
{ {
return( FALSE ); return( FALSE );
} }
#endif
for( U8 u8Notification = 0; u8Notification < NUMBER_OF_NOTIFICATOINS; u8Notification++ ) for( U8 u8Notification = 0; u8Notification < NUMBER_OF_NOTIFICATIONS; u8Notification++ )
{ {
if( m_astNotifications[u8Variable][enNotification][u8Notification].pfnCallback == NULL ) if( m_astNotifications[u8Variable][enNotification][u8Notification].pfnCallback == NULL )
{ {
@ -217,30 +191,11 @@ BOOL VARH_boRegisterNotification( U8 u8Variable, VARH_EnNotification enNotificat
return( FALSE ); // registration not successful return( FALSE ); // registration not successful
} }
//-------------------------------------------------------------------------------------------------
// Function: VARH_boRegisterRangeCheck
// Description: Registers the range check function
// Parameters: U8 u8Variable
// VARH_pfnRangeCheck pfnCallback
// PVOID pvCallbackArgument
// Returns: Boolean TRUE if register of Callback was successful, otherwise FALSE
//-------------------------------------------------------------------------------------------------
BOOL VARH_boRegisterRangeCheck( U8 u8Variable, VARH_pfnRangeCheck pfnCallback, PVOID pvCallbackArgument )
{
if( m_astRangeCheck[u8Variable].pfnCallback == NULL )
{
m_astRangeCheck[u8Variable].pfnCallback = pfnCallback;
m_astRangeCheck[u8Variable].pvArgument = pvCallbackArgument;
return( TRUE );
}
return( FALSE );
}
//------------------------------------------------------------------------------------------------- //-------------------------------------------------------------------------------------------------
// Function: VARH_vSetVariableData // Function: VARH_vSetVariableData
// Description: Sets the Variable Data // Description: Sets the Variable Data
// Parameters: VARH_EnVariables enVariable // Parameters: U8 u8Variable
// VARH_UVariable uData // VARH_UVariable uData
// Returns: None // Returns: None
//------------------------------------------------------------------------------------------------- //-------------------------------------------------------------------------------------------------
@ -253,76 +208,16 @@ VOID VARH_vSetVariableData( U8 u8Variable, VARH_UVariable uData )
osMutexRelease( m_pstMutexID ); // release mutex osMutexRelease( m_pstMutexID ); // release mutex
} }
//-------------------------------------------------------------------------------------------------
// Function: VARH_vSetBit
// Description: Sets the bit specified with the bitmask in the specified variable
// Parameters: U8 u8Variable
// U32 u32BitMask
// Returns: None
//-------------------------------------------------------------------------------------------------
VOID VARH_vSetBit( U8 u8Variable, U32 u32BitMask )
{
osMutexAcquire( m_pstMutexID, osWaitForever ); // aquire mutex
U32 u32Data = m_auVariable[u8Variable].u32Val; // read
UTIL_SET_BIT( &u32Data, u32BitMask ); // modify
VARH_vSetVariableData( u8Variable, (VARH_UVariable) u32Data ); // write
osMutexRelease( m_pstMutexID ); // release mutex
}
//------------------------------------------------------------------------------------------------- //-------------------------------------------------------------------------------------------------
// Function: VARH_vClearBit // Function: VARH_vSetVariableDataFromMaster
// Description: Clears the bit specified with the bitmask in the specified variable // Description: Sets the Variable Data from Master Protocol.
// Only use this function from Master interpreter
// Parameters: U8 u8Variable // Parameters: U8 u8Variable
// U32 u32BitMask // VARH_UVariable uData
// Returns: None // Returns: None
//------------------------------------------------------------------------------------------------- //-------------------------------------------------------------------------------------------------
VOID VARH_vClearBit( U8 u8Variable, U32 u32BitMask ) VOID VARH_vSetVariableDataFromMaster( U8 u8Variable, VARH_UVariable uData )
{
osMutexAcquire( m_pstMutexID, osWaitForever ); // aquire mutex
U32 u32Data = m_auVariable[u8Variable].u32Val; // read
UTIL_CLEAR_BIT( &u32Data, u32BitMask ); // modify
VARH_vSetVariableData( u8Variable, (VARH_UVariable) u32Data ); // write
osMutexRelease( m_pstMutexID ); // release mutex
}
//-------------------------------------------------------------------------------------------------
// Function: VARH_u32GetBit
// Description: Gets the bits specified with the bitmask in the specified variable
// Parameters: U8 u8Variable
// U32 u32BitMask
// Returns: None
//-------------------------------------------------------------------------------------------------
U32 VARH_u32GetBit( U8 u8Variable, U32 u32BitMask )
{
osMutexAcquire( m_pstMutexID, osWaitForever ); // aquire mutex
U32 u32Ret = m_auVariable[u8Variable].u32Val & u32BitMask;
osMutexRelease( m_pstMutexID ); // release mutex
return( u32Ret );
}
//-------------------------------------------------------------------------------------------------
// Function: VARH_vIncrement
// Description: Increments the specifiend variable
// Parameters: U8 u8Variable
// Returns: None
//-------------------------------------------------------------------------------------------------
VOID VARH_vIncrement( U8 u8Variable )
{
osMutexAcquire( m_pstMutexID, osWaitForever ); // aquire mutex
VARH_vSetVariableData( u8Variable, (VARH_UVariable) m_auVariable[u8Variable].u32Val++ );
osMutexRelease( m_pstMutexID ); // release mutex
}
//-------------------------------------------------------------------------------------------------
// Function: VARH_vSetVariableDataFromClient
// Description: Sets the Variable Data from Client Protocol.
// Only use this function from Client interpreter
// Parameters: U8 u8Variable
// PVOID pvData
// SDEF_EnByteOrder enByteOrder
// Returns: None
//-------------------------------------------------------------------------------------------------
VOID VARH_vSetVariableDataFromClient( U8 u8Variable, VARH_UVariable uData )
{ {
osMutexAcquire( m_pstMutexID, osWaitForever ); // aquire mutex osMutexAcquire( m_pstMutexID, osWaitForever ); // aquire mutex
@ -353,15 +248,13 @@ VARH_UVariable VARH_uGetVariableData( U8 u8Variable )
} }
//------------------------------------------------------------------------------------------------- //-------------------------------------------------------------------------------------------------
// Function: VARH_u32GetVariableDataFromMSCB // Function: VARH_u32GetVariableDataFromMaster
// Description: Gets the Variable Data from MSCB Protocol // Description: Gets the Variable Data from Master Protocol
// Only use this function from MSCB interpreter // Only use this function from Master interpreter
// Parameters: U8 u8Variable // Parameters: U8 u8Variable
// PVOID pvData // Returns: VARH_UVariable
// SDEF_EnByteOrder enByteOrder
// Returns: Number of elements copied
//------------------------------------------------------------------------------------------------- //-------------------------------------------------------------------------------------------------
VARH_UVariable VARH_u32GetVariableDataFromClient( U8 u8Variable ) VARH_UVariable VARH_u32GetVariableDataFromMaster( U8 u8Variable )
{ {
osMutexAcquire( m_pstMutexID, osWaitForever ); // aquire mutex osMutexAcquire( m_pstMutexID, osWaitForever ); // aquire mutex
@ -371,17 +264,6 @@ VARH_UVariable VARH_u32GetVariableDataFromClient( U8 u8Variable )
return( uVar ); return( uVar );
} }
//-------------------------------------------------------------------------------------------------
// Function: VARH_pstGetVariableInfo
// Description: Gets the Variable Info
// Parameters: U8 u8Variable
// Returns: VARH_StVarInfo*
//-------------------------------------------------------------------------------------------------
CONST VARH_StVarInfo* VARH_pstGetVariableInfo( U8 u8Variable )
{
return( (CONST VARH_StVarInfo*)&m_astVarInfo[u8Variable] );
}
//------------------------------------------------------------------------------------------------- //-------------------------------------------------------------------------------------------------
// Function: VARH_vSetVariableToInitData // Function: VARH_vSetVariableToInitData
// Description: Sets the variable to its initial data // Description: Sets the variable to its initial data
@ -409,35 +291,61 @@ VOID VARH_vSetAllVariablesToInitData( VOID )
} }
} }
//-------------------------------------------------------------------------------------------------
// Function: VARH_vGetNumberOfVariables
// Description: Gets the number of used variables
// Parameters: None
// Returns: U8 number of used variables
//-------------------------------------------------------------------------------------------------
U8 VARH_u8GetNumberOfVariables( VOID )
{
return( VARH_eNumberOfVariables );
}
//-------------------------------------------------------------------------------------------------
// Function: VARH_boBooleanVarCheck
// Description: Checks the range of a boolean
// Parameters: PVOID pvCallbackData
// VARH_UVariable uNewValue
// Returns: TRUE, the variable can be written
//-------------------------------------------------------------------------------------------------
BOOL VARH_boBooleanVarCheck( PVOID pvCallbackData, VARH_UVariable uNewValue )
{
UNUSED( pvCallbackData );
return( uNewValue.u32Val > 1 ? FALSE : TRUE );
}
//================================================================================================= //=================================================================================================
// Section: LOCAL FUNCTIONS // Section: LOCAL FUNCTIONS
// Descriptionn: Definition (implementation) of local functions. // Descriptionn: Definition (implementation) of local functions.
//================================================================================================= //=================================================================================================
//-------------------------------------------------------------------------------------------------
// Function: boBooleanVarCheck
// Description: Checks the range of a boolean
// Parameters: U32 u32NewValue
// Returns: TRUE, the variable can be written
//-------------------------------------------------------------------------------------------------
PRIVATE BOOL boBooleanVarCheck( U32 u32NewValue )
{
return( u32NewValue > 1 ? FALSE : TRUE );
}
//-------------------------------------------------------------------------------------------------
// Function: boU32VarCheck
// Description: Checks the range of a U32
// Parameters: U8 u8Variable
// U32 u32NewValue
// Returns: TRUE, the variable can be written
//-------------------------------------------------------------------------------------------------
PRIVATE BOOL boU32VarCheck( U8 u8Variable, U32 u32NewValue )
{
return( m_astVarInfo[u8Variable].uMinData.u32Val < u32NewValue < m_astVarInfo[u8Variable].uMaxData.u32Val ? TRUE : FALSE );
}
//-------------------------------------------------------------------------------------------------
// Function: boS32VarCheck
// Description: Checks the range of a S32
// Parameters: U8 u8Variable
// S32 s32NewValue
// Returns: TRUE, the variable can be written
//-------------------------------------------------------------------------------------------------
PRIVATE BOOL boS32VarCheck( U8 u8Variable, S32 s32NewValue )
{
return( m_astVarInfo[u8Variable].uMinData.s32Val < s32NewValue < m_astVarInfo[u8Variable].uMaxData.s32Val ? TRUE : FALSE );
}
//-------------------------------------------------------------------------------------------------
// Function: boFloatVarCheck
// Description: Checks the range of a Float
// Parameters: U8 u8Variable
// FLOAT flNewValue
// Returns: TRUE, the variable can be written
//-------------------------------------------------------------------------------------------------
PRIVATE BOOL boFloatVarCheck( U8 u8Variable, FLOAT flNewValue )
{
return( m_astVarInfo[u8Variable].uMinData.flVal < flNewValue < m_astVarInfo[u8Variable].uMaxData.flVal ? TRUE : FALSE );
}
//------------------------------------------------------------------------------------------------- //-------------------------------------------------------------------------------------------------
// Function: vCallNotifications // Function: vCallNotifications
// Description: Calls the notification callback functions // Description: Calls the notification callback functions
@ -448,14 +356,14 @@ BOOL VARH_boBooleanVarCheck( PVOID pvCallbackData, VARH_UVariable uNewValue )
//------------------------------------------------------------------------------------------------- //-------------------------------------------------------------------------------------------------
PRIVATE VOID vCallNotifications( U8 u8Variable, VARH_UVariable uOldData, VARH_UVariable uNewData ) PRIVATE VOID vCallNotifications( U8 u8Variable, VARH_UVariable uOldData, VARH_UVariable uNewData )
{ {
for( U8 u8Notification = 0; u8Notification < NUMBER_OF_NOTIFICATOINS; u8Notification++ ) for( U8 u8Notification = 0; u8Notification < NUMBER_OF_NOTIFICATIONS; u8Notification++ )
{ {
if( m_astNotifications[u8Variable][VARH_eWrite][u8Notification].pfnCallback != NULL ) if( m_astNotifications[u8Variable][VARH_eWrite][u8Notification].pfnCallback != NULL )
{ {
m_astNotifications[u8Variable][VARH_eWrite][u8Notification].pfnCallback( m_astNotifications[u8Variable][VARH_eWrite][u8Notification].pvArgument ); m_astNotifications[u8Variable][VARH_eWrite][u8Notification].pfnCallback( m_astNotifications[u8Variable][VARH_eWrite][u8Notification].pvArgument );
} }
if( boNewValue( u8Variable, uOldData, uNewData ) ) if( boNewValue( uOldData, uNewData ) )
{ {
if( m_astNotifications[u8Variable][VARH_eNewValue][u8Notification].pfnCallback != NULL ) if( m_astNotifications[u8Variable][VARH_eNewValue][u8Notification].pfnCallback != NULL )
{ {
@ -463,21 +371,6 @@ PRIVATE VOID vCallNotifications( U8 u8Variable, VARH_UVariable uOldData, VARH_U
} }
} }
if( boRising( u8Variable, uOldData, uNewData ) )
{
if( m_astNotifications[u8Variable][VARH_eRising][u8Notification].pfnCallback != NULL )
{
m_astNotifications[u8Variable][VARH_eRising][u8Notification].pfnCallback( m_astNotifications[u8Variable][VARH_eRising][u8Notification].pvArgument );
}
}
if( boFalling( u8Variable, uOldData, uNewData ) )
{
if( m_astNotifications[u8Variable][VARH_eFalling][u8Notification].pfnCallback != NULL )
{
m_astNotifications[u8Variable][VARH_eFalling][u8Notification].pfnCallback( m_astNotifications[u8Variable][VARH_eFalling][u8Notification].pvArgument );
}
}
} }
} }
@ -490,37 +383,20 @@ PRIVATE VOID vCallNotifications( U8 u8Variable, VARH_UVariable uOldData, VARH_U
//------------------------------------------------------------------------------------------------- //-------------------------------------------------------------------------------------------------
PRIVATE BOOL boCheckRange( U8 u8Variable, VARH_UVariable uNewData ) PRIVATE BOOL boCheckRange( U8 u8Variable, VARH_UVariable uNewData )
{ {
if( m_astRangeCheck[u8Variable].pfnCallback == NULL ) if( m_astVarInfo[u8Variable].u8Flags & VARH_FLAG_FLOAT )
{ {
return( TRUE ); return( boFloatVarCheck(u8Variable, uNewData.flVal ) );
} else if( m_astVarInfo[u8Variable].u8Flags & VARH_FLAG_SIGNED )
{
return( boS32VarCheck(u8Variable, uNewData.s32Val ) );
} else if( m_astVarInfo[u8Variable].u8Flags & VARH_FLAG_BOOL )
{
return( boBooleanVarCheck( uNewData.s32Val ) );
} else
{
return( boU32VarCheck(u8Variable, uNewData.u32Val ) );
} }
return( m_astRangeCheck[u8Variable].pfnCallback( m_astRangeCheck[u8Variable].pvArgument, uNewData ) );
}
//-------------------------------------------------------------------------------------------------
// Function: boRising
// Description: returns True, if there is a rising edge on this variable (only for boolean types)
// Parameters: U8 u8Variable
// VARH_UVariable uOldData
// VARH_UVariable uNewData
// Returns: None
//-------------------------------------------------------------------------------------------------
PRIVATE BOOL boRising( U8 u8Variable, VARH_UVariable uOldData, VARH_UVariable uNewData )
{
return( uOldData.u32Val == 0 && uNewData.u32Val == 1 ? TRUE : FALSE );
}
//-------------------------------------------------------------------------------------------------
// Function: boFalling
// Description: returns True, if there is a falling edge on this variable (only for boolean types)
// Parameters: U8 u8Variable
// VARH_UVariable uOldData
// VARH_UVariable uNewData
// Returns: None
//-------------------------------------------------------------------------------------------------
PRIVATE BOOL boFalling( U8 u8Variable, VARH_UVariable uOldData, VARH_UVariable uNewData )
{
return( uOldData.u32Val == 1 && uNewData.u32Val == 0 ? TRUE : FALSE );
} }
//------------------------------------------------------------------------------------------------- //-------------------------------------------------------------------------------------------------
@ -531,8 +407,7 @@ PRIVATE BOOL boFalling( U8 u8Variable, VARH_UVariable uOldData, VARH_UVariable u
// VARH_UVariable uNewData // VARH_UVariable uNewData
// Returns: None // Returns: None
//------------------------------------------------------------------------------------------------- //-------------------------------------------------------------------------------------------------
PRIVATE BOOL boNewValue( U8 u8Variable, VARH_UVariable uOldData, VARH_UVariable uNewData ) PRIVATE BOOL boNewValue( VARH_UVariable uOldData, VARH_UVariable uNewData )
{ {
UNUSED( u8Variable );
return( uNewData.u32Val != uOldData.u32Val ? TRUE : FALSE); return( uNewData.u32Val != uOldData.u32Val ? TRUE : FALSE);
} }

126
Core/Application/VARH_VariableHandler.h
View File

@ -35,7 +35,6 @@ extern "C" {
#include "../SDEF_StandardDefinitions.h" #include "../SDEF_StandardDefinitions.h"
//================================================================================================= //=================================================================================================
// Section: DEFINITIONS // Section: DEFINITIONS
// Description: Definition of global constants (visible by all modules). // Description: Definition of global constants (visible by all modules).
@ -43,16 +42,10 @@ extern "C" {
// Flags // Flags
#define VARH_FLAG_NONE 0 // no flag #define VARH_FLAG_NONE 0 // no flag
#define VARH_FLAG_FLOAT (1<<0) // channel in floating point format #define VARH_FLAG_FLOAT (1<<0) // variable in floating point format
#define VARH_FLAG_SIGNED (1<<1) // channel is signed integer #define VARH_FLAG_SIGNED (1<<1) // variable is signed integer
#define VARH_FLAG_DATALESS (1<<2) // channel doesn't contain data; displayed on the host, but not writable #define VARH_FLAG_BOOL (1<<2) // variable is boolean
#define VARH_FLAG_HIDDEN (1<<3) // used for internal config parameters; not displayed on the host pc, but writable #define VARH_FLAG_READONLY (1<<3) // variable is readonly, master can not set variable
#define VARH_FLAG_REMIN (1<<4) // get variable from remote node on subbus
#define VARH_FLAG_REMOUT (1<<5) // send variable to remote node on subbus
#define VARH_FLAG_READONLY (1<<7) // variable is readonly, host can not set variable
#define VARH_HV_MAX (300.0f)
#define VARH_I_MAX (1000.0f)
//================================================================================================= //=================================================================================================
// Section: MACROS // Section: MACROS
@ -66,97 +59,21 @@ extern "C" {
// Description: Definition of global enumerations (visible by all modules). // Description: Definition of global enumerations (visible by all modules).
//================================================================================================= //=================================================================================================
// Units
typedef enum typedef enum
{ {
// physical units VARH_eWrite = 0, // everytime someone writes
VARH_eUnitUndefined = 0, // 00 Undefined unit VARH_eNewValue, // only if there is a new value
VARH_eUnitMeter = 1, // 01 Meter
VARH_eUnitGram = 2, // 02 Gram
VARH_eUnitSecond = 3, // 03 Second
VARH_eUnitMinute = 4, // 04 Minute
VARH_eUnitHour = 5, // 05 Hour
VARH_eUnitAmpere = 6, // 06 Ampere
VARH_eUnitKelvin = 7, // 07 Kelvin
VARH_eUnitCelsius = 8, // 08 Celsius
VARH_eUnitFarenheit = 9, // 09 Farenheit
// SI base units VARH_eNumberOfNotificationTypes, // Must be last entry
VARH_eUnitHertz = 20, // 20 Hertz
VARH_eUnitPascal = 21, // 21 Pascal
VARH_eUnitBar = 22, // 22 Bar
VARH_eUnitWatt = 23, // 23 Watt
VARH_eUnitVolt = 24, // 24 Volt
VARH_eUnitOhm = 25, // 25 Ohm
VARH_eUnitTesla = 26, // 26 Tesla
VARH_eUnitLiterPerSec = 27, // 27 Liter per second
VARH_eUnitRPM = 28, // 28 Rounds per minute
VARH_eUnitFarad = 29, // 29 Farad
VARH_eUnitJoule = 30, // 30 Joule
// computer units
VARH_eUnitBoolean = 50, // 50 Boolean
VARH_eUnitByte = 52, // 52 Byte
VARH_eUnitWord = 53, // 53 Word (16Bit)
VARH_eUnitDoubleWord = 54, // 54 Double Word (32Bit)
VARH_eUnitASCII = 55, // 55 ASCII character
VARH_eUnitString = 56, // 56 String
VARH_eUnitBaud = 57, // 57 Baud
// others
VARH_eUnitPercent = 90, // 90 Percent
VARH_eUnitPPM = 91, // 91 Parts per million
VARH_eUnitCount = 92, // 92 Count
VARH_eUnitFactor = 93, // 93 Factor
} VARH_EnUnit;
// Prefix
typedef enum
{
VARH_ePrefixPico = -12,
VARH_ePrefixNano = -9,
VARH_ePrefixMicro = -6,
VARH_ePrefixMilli = -3,
VARH_ePrefixNone = 0,
VARH_ePrefixKilo = 3,
VARH_ePrefixMega = 6,
VARH_ePrefixGiga = 9,
VARH_ePrefixTera = 12,
} VARH_EnPrefix;
typedef enum
{
VARH_eWrite = 0,
VARH_eNewValue,
VARH_eRising,
VARH_eFalling,
VARH_eNumberOfNotificationTypes,
} VARH_EnNotification; } VARH_EnNotification;
// variables // variables
typedef enum typedef enum
{ {
VARH_eStatus, VARH_eTemp_H,
VARH_eTemp_C,
VARH_eVoltageRefEn, VARH_eTemp_Diff,
VARH_eStatusG,
VARH_eStatusR,
VARH_eEnabledG,
VARH_eEnabledR,
VARH_eInvertedG,
VARH_eInvertedR,
VARH_eSpareG,
VARH_eSpareR,
VARH_eTempHeatSink,
VARH_eTempShunt,
VARH_eTempVoltageRef,
VARH_eTempCurrentSrc,
VARH_eNumberOfVariables, // Must be last entry VARH_eNumberOfVariables, // Must be last entry
} VARH_EnVariables; } VARH_EnVariables;
@ -178,11 +95,10 @@ typedef union {
typedef struct typedef struct
{ {
CHAR acName[16]; // name
U8 u8Flags; // flags U8 u8Flags; // flags
VARH_EnUnit eUnit; // unit
VARH_EnPrefix ePrefix; // prefix
VARH_UVariable uInitData; // initial Data (data is always 32 bit, at least internal) VARH_UVariable uInitData; // initial Data (data is always 32 bit, at least internal)
VARH_UVariable uMinData; // min Value for Data
VARH_UVariable uMaxData; // max Value for Data
} VARH_StVarInfo; } VARH_StVarInfo;
@ -204,38 +120,26 @@ typedef struct
// Description: Definition of functions // Description: Definition of functions
//================================================================================================= //=================================================================================================
typedef VOID (*VARH_pfnNotification)( PVOID pvData ); typedef VOID (*VARH_pfnNotification)( PVOID pvData );
typedef BOOL (*VARH_pfnRangeCheck)( PVOID pvCallbackData, VARH_UVariable uNewValue );
//================================================================================================= //=================================================================================================
// Section: GLOBAL FUNCTIONS (PROTOTYPES) // Section: GLOBAL FUNCTIONS (PROTOTYPES)
// Description: Definition of global functions (visible by all modules). // Description: Definition of global functions (visible by all modules).
//================================================================================================= //=================================================================================================
BOOL VARH_boInitializeModule( BOOL boInitConfig ); BOOL VARH_boInitializeModule( VOID );
BOOL VARH_boRegisterNotification( U8 u8Variable, VARH_EnNotification enNotification, VARH_pfnNotification pfnCallback, PVOID pvCallbackArgument ); BOOL VARH_boRegisterNotification( U8 u8Variable, VARH_EnNotification enNotification, VARH_pfnNotification pfnCallback, PVOID pvCallbackArgument );
BOOL VARH_boRegisterRangeCheck( U8 u8Variable, VARH_pfnRangeCheck pfnCallback, PVOID pvCallbackArgument );
// set data functions // set data functions
VOID VARH_vSetVariableData( U8 u8Variable, VARH_UVariable uData ); VOID VARH_vSetVariableData( U8 u8Variable, VARH_UVariable uData );
VOID VARH_vSetBit( U8 u8Variable, U32 u32BitMask ); VOID VARH_vSetVariableDataFromMaster( U8 u8Variable, VARH_UVariable uData );
U32 VARH_u32GetBit( U8 u8Variable, U32 u32BitMask );
VOID VARH_vClearBit( U8 u8Variable, U32 u32BitMask );
VOID VARH_vIncrement( U8 u8Variable );
VOID VARH_vSetVariableDataFromClient( U8 u8Variable, VARH_UVariable uData );
// get data function // get data function
VARH_UVariable VARH_uGetVariableData( U8 u8Variable ); VARH_UVariable VARH_uGetVariableData( U8 u8Variable );
VARH_UVariable VARH_u32GetVariableDataFromClient( U8 u8Variable ); VARH_UVariable VARH_u32GetVariableDataFromMaster( U8 u8Variable );
// check functions
BOOL VARH_boBooleanVarCheck( PVOID pvCallbackData, VARH_UVariable uNewValue );
CONST VARH_StVarInfo* VARH_pstGetVariableInfo( U8 u8Variable );
VOID VARH_vSetVariableToInitData( U8 u8Variable ); VOID VARH_vSetVariableToInitData( U8 u8Variable );
VOID VARH_vSetAllVariablesToInitData( VOID ); VOID VARH_vSetAllVariablesToInitData( VOID );
U8 VARH_u8GetNumberOfVariables( VOID );
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif