//=================================================================================================
//
// 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 global variables
//
//=================================================================================================



//=================================================================================================
// Section:       INCLUDES
// Description:   List of required include files.
//=================================================================================================

#include "../PDEF_ProjectDefinitions.h"
#include "VARH_VariableHandler.h"

// Toolbox
#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_NOTIFICATIONS   2


//=================================================================================================
// 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;

//=================================================================================================
// 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_NOTIFICATIONS] = { 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] =
{ 
  { 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,
  { VARH_FLAG_READONLY | VARH_FLAG_FLOAT, (VARH_UVariable)0.0f, (VARH_UVariable)-50.0f, (VARH_UVariable)70.0f }, // VARH_eTemp_Diff,

  { VARH_FLAG_READONLY | VARH_FLAG_FLOAT, (VARH_UVariable)0.0f, (VARH_UVariable)-50.0f, (VARH_UVariable)70.0f }, // VARH_ePeltier_U,
  { VARH_FLAG_READONLY | VARH_FLAG_FLOAT, (VARH_UVariable)0.0f, (VARH_UVariable)-10.0f, (VARH_UVariable)10.0f }, // VARH_ePeltier_I,
  { VARH_FLAG_READONLY | VARH_FLAG_FLOAT, (VARH_UVariable)0.0f, (VARH_UVariable)0.0f, (VARH_UVariable)5.0f }, // VARH_ePeltier_R,
  { VARH_FLAG_READONLY | VARH_FLAG_FLOAT, (VARH_UVariable)0.0f, (VARH_UVariable)-50.0f, (VARH_UVariable)150.0f }, // VARH_ePeltier_P,

  { VARH_FLAG_READONLY | VARH_FLAG_FLOAT, (VARH_UVariable)0.0f, (VARH_UVariable)20.0f, (VARH_UVariable)30.0f }, // VARH_eSupply_U,
  { VARH_FLAG_READONLY | VARH_FLAG_FLOAT, (VARH_UVariable)0.0f, (VARH_UVariable)0.0f, (VARH_UVariable)5.0f }, // VARH_eSupply_I,
  { VARH_FLAG_READONLY | VARH_FLAG_FLOAT, (VARH_UVariable)0.0f, (VARH_UVariable)0.0f, (VARH_UVariable)150.0f }, // VARH_eSupply_P,
};


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).
//=================================================================================================

// notification functions
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 boBooleanVarCheck( U32 u32NewValue );
PRIVATE BOOL boU32VarCheck( U8 u8Variable, U32 u32NewValue );
PRIVATE BOOL boS32VarCheck( U8 u8Variable, S32 s32NewValue );
PRIVATE BOOL boFloatVarCheck( U8 u8Variable, FLOAT flNewValue );

//=================================================================================================
// 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( VOID )
{
  BOOL boOK = TRUE;

	boOK &= ((m_pstMutexID = osMutexNew( &m_stMutexAttr )) == NULL) ? FALSE : TRUE;
	  
  memset( &m_astNotifications, 0, sizeof(m_astNotifications) );                 // reset the notifications
  
  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( enNotification >= VARH_eNumberOfNotificationTypes ||  pfnCallback == NULL)
  {
    return( FALSE );
  }
  	
  for( U8 u8Notification = 0; u8Notification < NUMBER_OF_NOTIFICATIONS; 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_vSetVariableData
// Description:   Sets the Variable Data
// Parameters:    U8 u8Variable
//                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_vSetVariableDataFromMaster
// Description:   Sets the Variable Data from Master Protocol. 
//                Only use this function from Master interpreter
// Parameters:    U8 u8Variable
//                VARH_UVariable uData
// Returns:       None
//-------------------------------------------------------------------------------------------------
VOID VARH_vSetVariableDataFromMaster( 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_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 );
  }
}


//=================================================================================================
// Section:       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
// 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_NOTIFICATIONS; 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( 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 );
      }      
    }

  }
}

//-------------------------------------------------------------------------------------------------
// 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_astVarInfo[u8Variable].u8Flags & VARH_FLAG_FLOAT )
  {
    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 ) );
  }
  
}

//-------------------------------------------------------------------------------------------------
// 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( VARH_UVariable uOldData, VARH_UVariable uNewData )
{
  return( uNewData.u32Val != uOldData.u32Val ? TRUE : FALSE);
}