TECware/Core/Application/VARH_VariableHandler.c
2021-12-10 09:00:22 +01:00

539 lines
25 KiB
C

//=================================================================================================
//
// Company: Paul Scherrer Institut
// 5232 Villigen PSI
// Switzerland
//
//-------------------------------------------------------------------------------------------------
//
// Project: Peltier Controller V2
// Author: Noah Piqué (noah.pique@psi.ch)
//
//-------------------------------------------------------------------------------------------------
//
// Module: Variable Handler
// Filename: VARH_VariableHandler.c
// Date: Handled by Subversion (version control system)
// Revision: Handled by Subversion (version control system)
// History: Handled by Subversion (version control system)
//
//-------------------------------------------------------------------------------------------------
//
// Description: This source file contains all functions dealing with variables
//
//=================================================================================================
//=================================================================================================
// Section: INCLUDES
// Description: List of required include files.
//=================================================================================================
#include "../PDEF_ProjectDefinitions.h"
#include "VARH_VariableHandler.h"
// Toolbox
#include "../Toolbox/ASRT_Assert.h"
#include "../Toolbox/UTIL_Utility.h"
#include "cmsis_os2.h"
//=================================================================================================
// Section: DEFINITIONS
// Description: Definition of local constants (visible by this module only).
//=================================================================================================
// define the number of notifications according the need
#define NUMBER_OF_NOTIFICATOINS 1
//=================================================================================================
// Section: MACROS
// Description: Definition of local macros (visible by this module only).
//=================================================================================================
//=================================================================================================
// Section: ENUMERATIONS
// Description: Definition of local enumerations (visible by this module only).
//=================================================================================================
//=================================================================================================
// Section: STRUCTURES
// Description: Definition of local Structures (visible by this module only).
//=================================================================================================
typedef struct
{
VARH_pfnNotification pfnCallback;
PVOID pvArgument;
} StNotification;
typedef struct
{
VARH_pfnRangeCheck pfnCallback;
PVOID pvArgument;
} StRangeCheck;
//=================================================================================================
// Section: LOCAL VARIABLES
// Description: Definition of local variables (visible by this module only).
//=================================================================================================
LOCAL VARH_UVariable m_auVariable[VARH_eNumberOfVariables];
LOCAL StNotification m_astNotifications[VARH_eNumberOfVariables][VARH_eNumberOfNotificationTypes][NUMBER_OF_NOTIFICATOINS] = { 0 };
LOCAL StRangeCheck m_astRangeCheck[VARH_eNumberOfVariables] = { 0 };
LOCAL osMutexId_t m_pstMutexID = NULL;
//=================================================================================================
// Section: LOCAL CONSTANTS
// Description: Definition of local constants (visible by this module only).
//=================================================================================================
LOCAL CONST VARH_StVarInfo m_astVarInfo[VARH_eNumberOfVariables] =
{
{"Status", VARH_FLAG_READONLY, VARH_eUnitByte, VARH_ePrefixNone, (VARH_UVariable)TRUE}, // VARH_eEnable,
{"VoltageRef En", VARH_FLAG_NONE, VARH_eUnitBoolean, VARH_ePrefixNone, (VARH_UVariable)FALSE}, // VARH_eSetMode,
{"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,
};
LOCAL CONST osMutexAttr_t m_stMutexAttr =
{
"VARH_Mutex", // human readable mutex name
osMutexRecursive | osMutexPrioInherit, // attr_bits
NULL, // memory for control block
0U // size for control block
};
//=================================================================================================
// Section: LOCAL FUNCTIONS (PROTOTYPES)
// Description: Definition of local functions (visible by this module only).
//=================================================================================================
PRIVATE VOID vSetVariablesToInitDataCallback( PVOID pvData );
PRIVATE VOID vCallNotifications( U8 u8Variable, VARH_UVariable uOldData, VARH_UVariable uNewData );
PRIVATE BOOL boCheckRange( U8 u8Variable, VARH_UVariable uNewData );
PRIVATE BOOL boRising( U8 u8Variable, VARH_UVariable uOldData, VARH_UVariable uNewData );
PRIVATE BOOL boFalling( U8 u8Variable, VARH_UVariable uOldData, VARH_UVariable uNewData );
PRIVATE BOOL boNewValue( U8 u8Variable, VARH_UVariable uOldData, VARH_UVariable uNewData );
//=================================================================================================
// Section: EXTERNAL FUNCTIONS
// Description: Definition of external (global) functions.
//=================================================================================================
//=================================================================================================
// Section: EXTERNAL VARIABLES
// Description: Definition of external (global) variables.
//=================================================================================================
//=================================================================================================
// Section: GLOBAL FUNCTIONS
// Description: Definition (implementation) of global functions.
//=================================================================================================
//-------------------------------------------------------------------------------------------------
// Function: VARH_boInitializeModule
// Description: Initializes the module. Function must be called once immediately after power-up.
// Parameters: BOOL boInitConfig
// Returns: Boolean TRUE if successful
//-------------------------------------------------------------------------------------------------
BOOL VARH_boInitializeModule( BOOL boInitConfig )
{
ASRT_STATIC_ASSERT( VARH_eNumberOfVariables <= 255 );
BOOL boOK = TRUE;
boOK &= ((m_pstMutexID = osMutexNew( &m_stMutexAttr )) == NULL) ? FALSE : TRUE;
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();
}
return( boOK );
}
//-------------------------------------------------------------------------------------------------
// Function: VARH_boRegisterNotification
// Description: Registers a notification to the specified variable
// Parameters: U8 u8Variable
// VARH_EnNotification enNotification
// VARH_pfnNotification pfnCallback
// PVOID pvCallbackArgument
// Returns: Boolean TRUE if register of Callback was successful, otherwise FALSE
//-------------------------------------------------------------------------------------------------
BOOL VARH_boRegisterNotification( U8 u8Variable, VARH_EnNotification enNotification, VARH_pfnNotification pfnCallback, PVOID pvCallbackArgument )
{
// check parameters
#if defined(PDEF_FUNCTION_PARAMETER_CHECK_ENABLED) && PDEF_FUNCTION_PARAMETER_CHECK_ENABLED == TRUE
if( enNotification >= VARH_eNumberOfNotificationTypes || pfnCallback == NULL)
{
return( FALSE );
}
#endif
for( U8 u8Notification = 0; u8Notification < NUMBER_OF_NOTIFICATOINS; u8Notification++ )
{
if( m_astNotifications[u8Variable][enNotification][u8Notification].pfnCallback == NULL )
{
m_astNotifications[u8Variable][enNotification][u8Notification].pfnCallback = pfnCallback;
m_astNotifications[u8Variable][enNotification][u8Notification].pvArgument = pvCallbackArgument;
return( TRUE );
}
}
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
// Description: Sets the Variable Data
// Parameters: VARH_EnVariables enVariable
// VARH_UVariable uData
// Returns: None
//-------------------------------------------------------------------------------------------------
VOID VARH_vSetVariableData( U8 u8Variable, VARH_UVariable uData )
{
osMutexAcquire( m_pstMutexID, osWaitForever ); // aquire mutex
VARH_UVariable uOldValue = m_auVariable[u8Variable]; // remember old value
if( boCheckRange( u8Variable, uData ) ) { m_auVariable[u8Variable] = uData; } // store new value
vCallNotifications( u8Variable, uOldValue, m_auVariable[u8Variable] ); // call notifications
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
// Description: Clears the bit specified with the bitmask in the specified variable
// Parameters: U8 u8Variable
// U32 u32BitMask
// Returns: None
//-------------------------------------------------------------------------------------------------
VOID VARH_vClearBit( U8 u8Variable, U32 u32BitMask )
{
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
// check parameters
if( m_astVarInfo[u8Variable].u8Flags & VARH_FLAG_READONLY )
{
return;
}
VARH_UVariable uOldValue = m_auVariable[u8Variable]; // remember old value
if( boCheckRange( u8Variable, uData ) ) { m_auVariable[u8Variable] = uData; } // store new value
vCallNotifications( u8Variable, uOldValue, m_auVariable[u8Variable] ); // call notifications
osMutexRelease( m_pstMutexID ); // release mutex
}
//-------------------------------------------------------------------------------------------------
// Function: VARH_u32GetVariableData
// Description: Gets the Variable Data
// Parameters: U8 u8Variable
// Returns: VARH_UVariable
//-------------------------------------------------------------------------------------------------
VARH_UVariable VARH_uGetVariableData( U8 u8Variable )
{
osMutexAcquire( m_pstMutexID, osWaitForever ); // aquire mutex
VARH_UVariable uVar = m_auVariable[u8Variable];
osMutexRelease( m_pstMutexID ); // release mutex
return( uVar );
}
//-------------------------------------------------------------------------------------------------
// Function: VARH_u32GetVariableDataFromMSCB
// Description: Gets the Variable Data from MSCB Protocol
// Only use this function from MSCB interpreter
// Parameters: U8 u8Variable
// PVOID pvData
// SDEF_EnByteOrder enByteOrder
// Returns: Number of elements copied
//-------------------------------------------------------------------------------------------------
VARH_UVariable VARH_u32GetVariableDataFromClient( U8 u8Variable )
{
osMutexAcquire( m_pstMutexID, osWaitForever ); // aquire mutex
VARH_UVariable uVar = m_auVariable[u8Variable];
osMutexRelease( m_pstMutexID ); // release mutex
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
// Description: Sets the variable to its initial data
// Parameters: U8 u8Variable
// Returns: None
//-------------------------------------------------------------------------------------------------
VOID VARH_vSetVariableToInitData( U8 u8Variable )
{
osMutexAcquire( m_pstMutexID, osWaitForever ); // aquire mutex
VARH_vSetVariableData( u8Variable, m_astVarInfo[u8Variable].uInitData );
osMutexRelease( m_pstMutexID ); // release mutex
}
//-------------------------------------------------------------------------------------------------
// Function: VARH_vSetAllVariablesToInitData
// Description: Sets all variables to its initial data
// Parameters: VARH_EnVariables enVariable
// Returns: None
//-------------------------------------------------------------------------------------------------
VOID VARH_vSetAllVariablesToInitData( VOID )
{
for( U16 u16Var = 0; u16Var < VARH_eNumberOfVariables; u16Var++ )
{
VARH_vSetVariableToInitData( u16Var );
}
}
//-------------------------------------------------------------------------------------------------
// 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
// Descriptionn: Definition (implementation) of local functions.
//=================================================================================================
//-------------------------------------------------------------------------------------------------
// Function: vCallNotifications
// Description: Calls the notification callback functions
// Parameters: U8 u8Variable
// VARH_UVariable uOldData
// VARH_UVariable uNewData
// Returns: None
//-------------------------------------------------------------------------------------------------
PRIVATE VOID vCallNotifications( U8 u8Variable, VARH_UVariable uOldData, VARH_UVariable uNewData )
{
for( U8 u8Notification = 0; u8Notification < NUMBER_OF_NOTIFICATOINS; u8Notification++ )
{
if( m_astNotifications[u8Variable][VARH_eWrite][u8Notification].pfnCallback != NULL )
{
m_astNotifications[u8Variable][VARH_eWrite][u8Notification].pfnCallback( m_astNotifications[u8Variable][VARH_eWrite][u8Notification].pvArgument );
}
if( boNewValue( u8Variable, uOldData, uNewData ) )
{
if( m_astNotifications[u8Variable][VARH_eNewValue][u8Notification].pfnCallback != NULL )
{
m_astNotifications[u8Variable][VARH_eNewValue][u8Notification].pfnCallback( m_astNotifications[u8Variable][VARH_eNewValue][u8Notification].pvArgument );
}
}
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 );
}
}
}
}
//-------------------------------------------------------------------------------------------------
// Function: boCheckRange
// Description: Checks the range of the variable
// Parameters: U8 u8Variable
// VARH_UVariable uNewData
// Returns: TRUE, if the value is in the range, otherwise FALSE
//-------------------------------------------------------------------------------------------------
PRIVATE BOOL boCheckRange( U8 u8Variable, VARH_UVariable uNewData )
{
if( m_astRangeCheck[u8Variable].pfnCallback == NULL )
{
return( TRUE );
}
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 );
}
//-------------------------------------------------------------------------------------------------
// Function: boNewValue
// Description: returns True, if there is a new value for this variable
// Parameters: U8 u8Variable
// VARH_UVariable uOldData
// VARH_UVariable uNewData
// Returns: None
//-------------------------------------------------------------------------------------------------
PRIVATE BOOL boNewValue( U8 u8Variable, VARH_UVariable uOldData, VARH_UVariable uNewData )
{
UNUSED( u8Variable );
return( uNewData.u32Val != uOldData.u32Val ? TRUE : FALSE);
}