Icu.h

Go to the documentation of this file.

/*
*
* Copyright (C) 2024 Texas Instruments Incorporated
*
* All rights reserved not granted herein.
*
* Limited License.
*
* Texas Instruments Incorporated grants a world-wide, royalty-free, non-exclusive
* license under copyrights and patents it now or hereafter owns or controls to make,
* have made, use, import, offer to sell and sell ("Utilize") this software subject to the
* terms herein.  With respect to the foregoing patent license, such license is granted
* solely to the extent that any such patent is necessary to Utilize the software alone.
* The patent license shall not apply to any combinations which include this software,
* other than combinations with devices manufactured by or for TI ("TI Devices").
* No hardware patent is licensed hereunder.
*
* Redistributions must preserve existing copyright notices and reproduce this license
* (including the above copyright notice and the disclaimer and (if applicable) source
* code license limitations below) in the documentation and/or other materials provided
* with the distribution
*
* Redistribution and use in binary form, without modification, are permitted provided
* that the following conditions are met:
*
* *       No reverse engineering, decompilation, or disassembly of this software is
* permitted with respect to any software provided in binary form.
*
* *       any redistribution and use are licensed by TI for use only with TI Devices.
*
* *       Nothing shall obligate TI to provide you with source code for the software
* licensed and provided to you in object code.
*
* If software source code is provided to you, modification and redistribution of the
* source code are permitted provided that the following conditions are met:
*
* *       any redistribution and use of the source code, including any resulting derivative
* works, are licensed by TI for use only with TI Devices.
*
* *       any redistribution and use of any object code compiled from the source code
* and any resulting derivative works, are licensed by TI for use only with TI Devices.
*
* Neither the name of Texas Instruments Incorporated nor the names of its suppliers
*
* may be used to endorse or promote products derived from this software without
* specific prior written permission.
*
* DISCLAIMER.
*
* THIS SOFTWARE IS PROVIDED BY TI AND TI'S LICENSORS "AS IS" AND ANY EXPRESS
* OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
* IN NO EVENT SHALL TI AND TI'S LICENSORS BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
* OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
* OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
* OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
 
 /*
 * Below are the global requirements which are met by this PWM
 * driver which can't be mapped to a particular source ID
 */
/*
*Design: MCAL-7113,MCAL-7128,MCAL-7064,MCAL-7118,MCAL-6917,MCAL-6972,MCAL-7091,MCAL-6931,MCAL-7048,MCAL-6960
*/
 
/*
 * Below are the PWM module's environment requirements which can't be mapped
 * to this driver
 */
/*
*Design: MCAL-7014,MCAL-7101,MCAL-6968,MCAL-7134,MCAL-7082,MCAL-7142,MCAL-7053,MCAL-7004,MCAL-7015,MCAL-7007,MCAL-6933,MCAL-7046,MCAL-6982,MCAL-7001,MCAL-7146,MCAL-6896,MCAL-7055,MCAL-7109,MCAL-7061,MCAL-6993,MCAL-7108,MCAL-7119,MCAL-6997,MCAL-7051,MCAL-6955,MCAL-7120,MCAL-6952,MCAL-7079
*/
 
#ifndef ICU_H_
#define ICU_H_
 
/* ========================================================================== */
/*                             Include Files                                  */
/* ========================================================================== */
/*
* Design: MCAL-7045,MCAL-7128,MCAL-7064,MCAL-7118,MCAL-6917,MCAL-6972,MCAL-7091,MCAL-6931,MCAL-7048,MCAL-6960
*/
#include "Std_Types.h"
#include "Icu_Cfg.h"
#include "EcuM_Cbk.h"
 
#ifdef __cplusplus
extern "C"
{
#endif
 
/* ========================================================================== */
/*                           Macros & Typedefs                                */
/* ========================================================================== */
 
#define ICU_VENDOR_ID                   ((uint16) 44U)
 
#define ICU_MODULE_ID                   ((uint16) 122U)
 
#define ICU_INSTANCE_ID                 ((uint8) 0U)
/* @} */
 
#define ICU_SW_MAJOR_VERSION   (9U)
 
#define ICU_SW_MINOR_VERSION   (1U)
 
#define ICU_SW_PATCH_VERSION   (0U)
/* @} */
 
#define ICU_AR_RELEASE_MAJOR_VERSION    (4U)
 
#define ICU_AR_RELEASE_MINOR_VERSION    (3U)
 
#define ICU_AR_RELEASE_REVISION_VERSION (1U)
/* @} */
 
#define ICU_INIT_ID                    ((uint8) 0x00U)
 
#define ICU_DEINIT_ID                  ((uint8) 0x01U)
 
#define ICU_SETMODE_ID                 ((uint8) 0x02U)
 
#define ICU_SETACTIVATIONCONDITION_ID  ((uint8) 0x05U)
 
#define ICU_DISABLENOTIFICATION_ID     ((uint8) 0x06U)
 
#define ICU_ENABLENOTIFICATION_ID      ((uint8) 0x07U)
 
#define ICU_GETINPUTSTATE_ID           ((uint8) 0x08U)
 
#define ICU_STARTTIMESTAMP_ID          ((uint8) 0x09U)
 
#define ICU_STOPTIMESTAMP_ID           ((uint8) 0x0AU)
 
#define ICU_GETTIMESTAMPINDEX_ID       ((uint8) 0x0BU)
 
#define ICU_RESETEDGECOUNT_ID          ((uint8) 0x0CU)
 
#define ICU_ENABLEEDGECOUNT_ID         ((uint8) 0x0DU)
 
#define ICU_ENABLEEDGEDETECTION_ID     ((uint8) 0x16U)
 
#define ICU_DISABLEEDGEDETECTION_ID    ((uint8) 0x17U)
 
#define ICU_DISABLEEDGECOUNT_ID        ((uint8) 0x0EU)
 
#define ICU_GETEDGENUMBERS_ID          ((uint8) 0x0FU)
 
#define ICU_STARTSIGNALMEASUREMENT_ID  ((uint8) 0x13U)
 
#define ICU_STOPSIGNALMEASUREMENT_ID   ((uint8) 0x14U)
 
#define ICU_GETTIMEELAPSED_ID          ((uint8) 0x10U)
 
#define ICU_GETDUTYCYCLEVALUES_ID      ((uint8) 0x11U)
 
#define ICU_GETVERSIONINFO_ID          ((uint8) 0x12U)
 
#define ICU_SID_REGISTER_READBACK      ((uint8) 0x18U)
/* @} */
 
/*
*Design: MCAL-7045
*/
#define ICU_E_PARAM_POINTER             ((uint8) 0x0AU)
 
#define ICU_E_PARAM_CHANNEL             ((uint8) 0x0BU)
 
#define ICU_E_PARAM_ACTIVATION          ((uint8) 0x0CU)
 
#define ICU_E_INIT_FAILED               ((uint8) 0x0DU)
 
#define ICU_E_PARAM_BUFFER_SIZE         ((uint8) 0x0EU)
 
#define ICU_E_PARAM_MODE                ((uint8) 0x0FU)
 
#define ICU_E_UNINIT                    ((uint8) 0x14U)
 
#define ICU_E_NOT_STARTED               ((uint8) 0x16U)
 
#define ICU_E_BUSY_OPERATION            ((uint8) 0x16U)
 
#define ICU_E_ALREADY_INITIALIZED       ((uint8) 0x17U)
 
#define ICU_E_PARAM_NOTIFY_INTERVAL     ((uint8) 0x18U)
 
#define ICU_E_PARAM_VINFO               ((uint8) 0x19U)
/* @} */
 
/*
*Design: MCAL-7144
*/
#define ICU_STATUS_UNINIT                   ((uint8)(0U))
 
#define ICU_STATUS_INIT                     ((uint8)(1U))
/* @} */
 
#define ICU_FALLING                         ((uint8)(0U))
 
#define ICU_RISING                          ((uint8)(1U))
 
/* ========================================================================== */
/*                         Structures and Enums                               */
/* ========================================================================== */
 
typedef enum
{
   ICU_MODE_NORMAL,
   ICU_MODE_SLEEP
} Icu_ModeType;
 
typedef enum
{
   ICU_ACTIVE,
   ICU_IDLE
} Icu_InputStateType;
 
 
typedef enum
{
   ICU_RISING_EDGE,
   ICU_FALLING_EDGE,
   ICU_BOTH_EDGES
} Icu_ActivationType;
 
typedef uint32 Icu_ValueType;
 
typedef struct
{
   Icu_ValueType ActiveTime;
   Icu_ValueType PeriodTime;
} Icu_DutyCycleType;
 
typedef uint32 Icu_IndexType;
 
typedef uint32 Icu_EdgeNumberType;
 
typedef enum
{
   ICU_MODE_SIGNAL_EDGE_DETECT,
   ICU_MODE_SIGNAL_MEASUREMENT,
   ICU_MODE_TIMESTAMP,
   ICU_MODE_EDGE_COUNTER
} Icu_MeasurementModeType;
 
typedef enum
{
   ICU_LOW_TIME,
   ICU_HIGH_TIME,
   ICU_PERIOD_TIME,
   ICU_DUTY_CYCLE
} Icu_SignalMeasurementPropertyType;
 
typedef enum
{
   ICU_LINEAR_BUFFER,
   ICU_CIRCULAR_BUFFER
} Icu_TimestampBufferType;
 
typedef void (*Icu_NotifyFuncType)(void);
 
typedef uint8 Icu_ChannelType;
 
typedef uint32 Icu_ChannelPrescalerType;
 
typedef struct
{
    Icu_ChannelType      channelId;
} Icu_ChannelConfigType_PC;
 
typedef struct Icu_ConfigType_PC_s
{
    Icu_ChannelConfigType_PC chCfg[ICU_MAX_NUM_CHANNELS];
} Icu_ConfigType_PC;
 
typedef struct {
   Icu_ActivationType          defaultStartEdge;
   Icu_MeasurementModeType     measurementMode;
   Icu_SignalMeasurementPropertyType signalMeasurementProperty;
   Icu_NotifyFuncType          notificationHandler;
   Icu_TimestampBufferType     bufferType;
   uint32                      instanceClkMHz;
   uint32                      prescaler;
} Icu_ChannelConfigType;
 
typedef struct Icu_ConfigType_s
{
    Icu_ChannelType icuMaxChannel;
    Icu_ChannelConfigType chCfg[ICU_MAX_NUM_CHANNELS];
} Icu_ConfigType;
 
#if (STD_ON == ICU_SAFETY_DIAGNOSTIC_API)
 
typedef struct
{
    /*
     * ECAP related registers
     */
     uint32 ECAP_CNTPHS;
     uint32 ECAP_ECCTL;
     uint32 ECAP_ECINT_EN_FLG;
 
} Icu_RegisterReadbackType;
#endif  /* #if (STD_ON == ICU_REGISTER_READBACK_API) */
/* @} */
 
 
 
/* ========================================================================== */
/*                          Function Declarations                             */
/* ========================================================================== */
 
 
FUNC(void, ICU_CODE) Icu_Init(
                    P2CONST(Icu_ConfigType, AUTOMATIC, ICU_PBCFG) ConfigPtr);
 
 
 
#if (STD_ON == ICU_DE_INIT_API)
 
FUNC(void, ICU_CODE) Icu_DeInit( void );
#endif
 
FUNC(void, ICU_CODE) Icu_SetActivationCondition( Icu_ChannelType Channel, Icu_ActivationType Activation );
 
FUNC(void, ICU_CODE) Icu_DisableNotification( Icu_ChannelType Channel );
 
FUNC(void, ICU_CODE) Icu_EnableNotification( Icu_ChannelType Channel );
 
 
#if (ICU_GET_INPUT_STATE_API == STD_ON)
 
FUNC(Icu_InputStateType, ICU_CODE) Icu_GetInputState( Icu_ChannelType Channel );
#endif
 
#if (ICU_TIMESTAMP_API == STD_ON)
 
FUNC(void, ICU_CODE) Icu_StartTimestamp( Icu_ChannelType Channel, Icu_ValueType* BufferPtr, uint16 BufferSize, uint16 NotifyInterval );
 
FUNC(void, ICU_CODE) Icu_StopTimestamp( Icu_ChannelType Channel );
 
FUNC(Icu_IndexType, ICU_CODE) Icu_GetTimestampIndex( Icu_ChannelType Channel );
#endif
 
#if (ICU_EDGE_COUNT_API == STD_ON)
 
FUNC(void, ICU_CODE) Icu_ResetEdgeCount( Icu_ChannelType Channel );
 
FUNC(void, ICU_CODE) Icu_EnableEdgeCount( Icu_ChannelType Channel );
 
FUNC(void, ICU_CODE) Icu_DisableEdgeCount( Icu_ChannelType Channel );
 
FUNC(Icu_EdgeNumberType, ICU_CODE) Icu_GetEdgeNumbers( Icu_ChannelType Channel );
#endif
 
#if (ICU_EDGE_DETECT_API == STD_ON)
 
FUNC(void, ICU_CODE) Icu_EnableEdgeDetection( Icu_ChannelType Channel );
 
FUNC(void, ICU_CODE) Icu_DisableEdgeDetection( Icu_ChannelType Channel );
#endif
 
#if (ICU_SIGNAL_MEASUREMENT_API == STD_ON)
 
FUNC(void, ICU_CODE) Icu_StartSignalMeasurement( Icu_ChannelType Channel );
 
FUNC(void, ICU_CODE) Icu_StopSignalMeasurement( Icu_ChannelType Channel );
#endif
 
#if (ICU_GET_TIME_ELAPSED_API == STD_ON)
 
FUNC (Icu_ValueType, ICU_CODE) Icu_GetTimeElapsed( Icu_ChannelType Channel );
#endif
 
#if (ICU_GET_DUTY_CYCLE_VALUES_API == STD_ON)
 
FUNC (void, ICU_CODE) Icu_GetDutyCycleValues( Icu_ChannelType Channel,
                    Icu_DutyCycleType* DutyCycleValues );
#endif
 
#if (ICU_GET_VERSION_INFO_API)
 
FUNC(void, ICU_CODE) Icu_GetVersionInfo(
        P2VAR(Std_VersionInfoType, AUTOMATIC, sICU_APPL_DATA) VersionInfoPtr);
 
#endif
 
#if (ICU_WAKEUP_FUNCTIONALITY_API == STD_ON)
 
FUNC(void, ICU_CODE) Icu_CheckWakeup(EcuM_WakeupSourceType WakeupSource);
#endif /* if(ICU_WAKEUP_FUNCTIONALITY_API == STD_ON) */
 
#if (ICU_DISABLEWAKEUP_API == STD_ON)
 
FUNC(void, ICU_CODE) Icu_DisableWakeup(Icu_ChannelType Channel);
#endif /* if(ICU_DISABLEWAKEUP_API == STD_ON) */
 
#if (ICU_ENABLEWAKEUP_API == STD_ON)
 
FUNC(void, ICU_CODE) Icu_EnableWakeup(Icu_ChannelType Channel);
#endif /* if(ICU_ENABLEWAKEUP_API == STD_ON) */
 
#if (ICU_SETMODE_API == STD_ON)
 
FUNC(void, ICU_CODE) Icu_SetMode(Icu_ModeType Mode);
#endif /* if (ICU_SETMODE_API == STD_ON) */
 
#if (STD_ON == ICU_SAFETY_DIAGNOSTIC_API)
FUNC(Std_ReturnType, ICU_CODE) Icu_RegisterReadback(
  Icu_ChannelType IcuChannel,
    P2VAR(Icu_RegisterReadbackType, AUTOMATIC, ICU_APPL_DATA) RegRbPtr);
#endif
 
FUNC(Icu_IndexType, ICU_CODE) Icu_GetTimeStampIndex(Icu_ChannelType Channel);
 
 
#ifdef __cplusplus
}
#endif
/* @} */
 
#endif /* ICU_H_ */
 
/* @} */