190 lines
5.8 KiB
C
190 lines
5.8 KiB
C
/*
|
|
* Copyright (c) 2022, Shenzhen CVA Innovation CO.,LTD
|
|
* All rights reserved.
|
|
*
|
|
* Shenzhen CVA Innovation CO.,LTD (CVA chip) is supplying this file for use
|
|
* exclusively with CVA's microcontroller products. This file can be freely
|
|
* distributed within development tools that are supporting such microcontroller
|
|
* products.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED "AS IS". NO WARRANTIES, WHETHER EXPRESS, IMPLIED
|
|
* OR STATUTORY, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF
|
|
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE APPLY TO THIS SOFTWARE.
|
|
* CVA SHALL NOT, IN ANY CIRCUMSTANCES, BE LIABLE FOR SPECIAL, INCIDENTAL,
|
|
* OR CONSEQUENTIAL DAMAGES, FOR ANY REASON WHATSOEVER.
|
|
*/
|
|
|
|
#ifndef _TRIGGER_H_
|
|
#define _TRIGGER_H_
|
|
|
|
/*! \brief Contains public interface to various functions related
|
|
* to the Trigger object
|
|
*/
|
|
|
|
/*******************************************************************************
|
|
* the includes
|
|
******************************************************************************/
|
|
|
|
#include <stdint.h>
|
|
#include <stdbool.h>
|
|
#include "common/iqmath/iqmath.h"
|
|
#include "common/sort/compare.h"
|
|
|
|
#ifdef __cplusplus
|
|
extern "C" {
|
|
#endif
|
|
|
|
/*******************************************************************************
|
|
* the defines
|
|
******************************************************************************/
|
|
|
|
/*******************************************************************************
|
|
* the typedefs
|
|
******************************************************************************/
|
|
|
|
/*! \brief The definition of Compare mode
|
|
*/
|
|
typedef enum
|
|
{
|
|
TRIGGER_COMPTYPE_OVER,
|
|
TRIGGER_COMPTYPE_UNDER,
|
|
} Trigger_CompModeType;
|
|
|
|
/*! \brief The definition of parameters of Trigger class
|
|
*/
|
|
typedef struct _Trigger_ParamsType_
|
|
{
|
|
Trigger_CompModeType compType;
|
|
_iq threshold;
|
|
_iq recoverValue;
|
|
uint16_t trigCntMax;
|
|
uint16_t recoverCntMax;
|
|
bool isRecoverable;
|
|
} Trigger_ParamsType;
|
|
|
|
/*! \brief The definition of Trigger prototype
|
|
*/
|
|
typedef struct _TriggerType_
|
|
{
|
|
_iq input; /*!< Input: The input for scan */
|
|
|
|
_iq threshold; /*!< Parameter: The threshold for compare */
|
|
_iq recoverValue; /*!< Parameter: The recover value that will reverse trigger */
|
|
uint16_t trigCntMax; /*!< Parameter: The max counts for the compare */
|
|
uint16_t recoverCntMax; /*!< Parameter: The max counts for the recover */
|
|
bool isRecoverable; /*!< Parameter: Whether the trigger can be recovered */
|
|
|
|
uint16_t trigCnt; /*!< Internal Variable: The count for the compare */
|
|
uint16_t recoverCnt; /*!< Internal Variable: The count for the recover */
|
|
bool (*comp)(_iq, _iq); /*!< Internal Variable: The compare function pointer */
|
|
bool (*recover)(_iq, _iq); /*!< Internal Variable: The recover function pointer */
|
|
|
|
bool compSatisfied; /*!< Output: Whether compare satisfied without debounce */
|
|
bool isTriggered; /*!< Output: Whether it's triggered based on compare and debounce */
|
|
} TriggerType;
|
|
|
|
/*******************************************************************************
|
|
* the globals
|
|
******************************************************************************/
|
|
|
|
/*******************************************************************************
|
|
* the function prototypes
|
|
******************************************************************************/
|
|
|
|
/*! \brief The initialization of Trigger
|
|
*
|
|
* This function initializes the trigger instance
|
|
*
|
|
* \param[in] obj : pointer to Trigger instance
|
|
* \param[in] pParams : pointer to the parameters
|
|
*/
|
|
static inline void Trigger_Init(TriggerType *obj, const Trigger_ParamsType *pParams)
|
|
{
|
|
obj->trigCntMax = pParams->trigCntMax;
|
|
obj->recoverCntMax = pParams->recoverCntMax;
|
|
obj->threshold = pParams->threshold;
|
|
obj->recoverValue = pParams->recoverValue;
|
|
obj->isRecoverable = pParams->isRecoverable;
|
|
if(pParams->compType == TRIGGER_COMPTYPE_OVER)
|
|
{
|
|
obj->comp = Compare_GreaterThan;
|
|
obj->recover = Compare_SmallerThan;
|
|
}
|
|
else if(pParams->compType == TRIGGER_COMPTYPE_UNDER)
|
|
{
|
|
obj->comp = Compare_SmallerThan;
|
|
obj->recover = Compare_GreaterThan;
|
|
}
|
|
|
|
obj->trigCnt = 0;
|
|
obj->recoverCnt = 0;
|
|
obj->compSatisfied = false;
|
|
obj->isTriggered = false;
|
|
}
|
|
|
|
/*! \brief Run the trigger algorithm
|
|
*
|
|
* This function runs the trigger algorithm
|
|
*
|
|
* \param[in] obj : pointer to Trigger instance
|
|
*/
|
|
static inline void Trigger_Run(TriggerType *obj)
|
|
{
|
|
if(obj->comp(obj->input, obj->threshold))
|
|
{
|
|
obj->compSatisfied = true;
|
|
obj->recoverCnt = 0;
|
|
if(obj->trigCnt < obj->trigCntMax)
|
|
{
|
|
obj->trigCnt++;
|
|
}
|
|
if(obj->trigCnt >= obj->trigCntMax)
|
|
{
|
|
obj->isTriggered = true;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
obj->compSatisfied = false;
|
|
obj->trigCnt = 0;
|
|
if(obj->isRecoverable)
|
|
{
|
|
if(obj->recover(obj->input, obj->recoverValue))
|
|
{
|
|
if(obj->recoverCnt < obj->recoverCntMax)
|
|
{
|
|
obj->recoverCnt++;
|
|
}
|
|
if(obj->recoverCnt >= obj->recoverCntMax)
|
|
{
|
|
obj->isTriggered = false;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
obj->recoverCnt = 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/*! \brief Reset the trigger instance
|
|
*
|
|
* This function reset the trigger to the initial state
|
|
*
|
|
* \param[in] obj : pointer to Trigger instance
|
|
*/
|
|
static inline void Trigger_Reset(TriggerType *obj)
|
|
{
|
|
obj->trigCnt = 0;
|
|
obj->recoverCnt = 0;
|
|
obj->compSatisfied = false;
|
|
obj->isTriggered = false;
|
|
}
|
|
|
|
#ifdef __cplusplus
|
|
}
|
|
#endif /* extern "C" */
|
|
|
|
#endif /* _TRIGGER_H_ */
|