fsl_enc.h

/*
 * Copyright (c) 2015, Freescale Semiconductor, Inc.
 * Copyright 2016-2021 NXP
 * All rights reserved.
 *
 * SPDX-License-Identifier: BSD-3-Clause
 */
 
#ifndef _FSL_ENC_H_
#define _FSL_ENC_H_
 
#include "fsl_common.h"
 
/*******************************************************************************
 * Definitions
 ******************************************************************************/
#define FSL_ENC_DRIVER_VERSION (MAKE_VERSION(2, 1, 0))
 
enum _enc_interrupt_enable
{
    kENC_HOMETransitionInterruptEnable  = (1U << 0U), 
    kENC_INDEXPulseInterruptEnable      = (1U << 1U), 
    kENC_WatchdogTimeoutInterruptEnable = (1U << 2U), 
    kENC_PositionCompareInerruptEnable  = (1U << 3U), 
#if !(defined(FSL_FEATURE_ENC_HAS_NO_CTRL2_SAB_INT) && FSL_FEATURE_ENC_HAS_NO_CTRL2_SAB_INT)
    kENC_SimultBothPhaseChangeInterruptEnable =
        (1U << 4U), 
#endif
    kENC_PositionRollOverInterruptEnable  = (1U << 5U), 
    kENC_PositionRollUnderInterruptEnable = (1U << 6U), 
};
 
enum _enc_status_flags
{
    kENC_HOMETransitionFlag  = (1U << 0U), 
    kENC_INDEXPulseFlag      = (1U << 1U), 
    kENC_WatchdogTimeoutFlag = (1U << 2U), 
    kENC_PositionCompareFlag = (1U << 3U), 
#if !(defined(FSL_FEATURE_ENC_HAS_NO_CTRL2_SAB_INT) && FSL_FEATURE_ENC_HAS_NO_CTRL2_SAB_INT)
    kENC_SimultBothPhaseChangeFlag = (1U << 4U), 
#endif
    kENC_PositionRollOverFlag   = (1U << 5U), 
    kENC_PositionRollUnderFlag  = (1U << 6U), 
    kENC_LastCountDirectionFlag = (1U << 7U), 
};
 
enum _enc_signal_status_flags
{
    kENC_RawHOMEStatusFlag       = ENC_IMR_HOME_MASK,  
    kENC_RawINDEXStatusFlag      = ENC_IMR_INDEX_MASK, 
    kENC_RawPHBStatusFlag        = ENC_IMR_PHB_MASK,   
    kENC_RawPHAEXStatusFlag      = ENC_IMR_PHA_MASK,   
    kENC_FilteredHOMEStatusFlag  = ENC_IMR_FHOM_MASK,  
    kENC_FilteredINDEXStatusFlag = ENC_IMR_FIND_MASK,  
    kENC_FilteredPHBStatusFlag   = ENC_IMR_FPHB_MASK,  
    kENC_FilteredPHAStatusFlag   = ENC_IMR_FPHA_MASK,  
};
 
typedef enum _enc_home_trigger_mode
{
    kENC_HOMETriggerDisabled = 0U, 
    kENC_HOMETriggerOnRisingEdge,  
    kENC_HOMETriggerOnFallingEdge, 
} enc_home_trigger_mode_t;
 
typedef enum _enc_index_trigger_mode
{
    kENC_INDEXTriggerDisabled = 0U, 
    kENC_INDEXTriggerOnRisingEdge,  
    kENC_INDEXTriggerOnFallingEdge, 
} enc_index_trigger_mode_t;
 
typedef enum _enc_decoder_work_mode
{
    kENC_DecoderWorkAsNormalMode = 0U,      
    kENC_DecoderWorkAsSignalPhaseCountMode, 
} enc_decoder_work_mode_t;
 
typedef enum _enc_position_match_mode
{
    kENC_POSMATCHOnPositionCounterEqualToComapreValue = 0U, 
    kENC_POSMATCHOnReadingAnyPositionCounter, 
} enc_position_match_mode_t;
 
typedef enum _enc_revolution_count_condition
{
    kENC_RevolutionCountOnINDEXPulse = 0U, 
    kENC_RevolutionCountOnRollOverModulus, 
} enc_revolution_count_condition_t;
 
typedef enum _enc_self_test_direction
{
    kENC_SelfTestDirectionPositive = 0U, 
    kENC_SelfTestDirectionNegative,      
} enc_self_test_direction_t;
 
#if (defined(FSL_FEATURE_ENC_HAS_CTRL3) && FSL_FEATURE_ENC_HAS_CTRL3)
typedef enum _enc_prescaler
{
    kENC_ClockDiv1     = 0,
    kENC_ClockDiv2     = 1,
    kENC_ClockDiv4     = 2,
    kENC_ClockDiv8     = 3,
    kENC_ClockDiv16    = 4,
    kENC_ClockDiv32    = 5,
    kENC_ClockDiv64    = 6,
    kENC_ClockDiv128   = 7,
    kENC_ClockDiv256   = 8,
    kENC_ClockDiv512   = 9,
    kENC_ClockDiv1024  = 10,
    kENC_ClockDiv2048  = 11,
    kENC_ClockDiv4096  = 12,
    kENC_ClockDiv8192  = 13,
    kENC_ClockDiv16384 = 14,
    kENC_ClockDiv32768 = 15,
} enc_prescaler_t;
#endif
 
typedef struct _enc_config
{
    /* Basic counter. */
    bool enableReverseDirection;             
    enc_decoder_work_mode_t decoderWorkMode; 
    /* Signal detection. */
    enc_home_trigger_mode_t HOMETriggerMode;   
    enc_index_trigger_mode_t INDEXTriggerMode; 
    bool enableTRIGGERClearPositionCounter;    
    bool enableTRIGGERClearHoldPositionCounter; 
    /* Watchdog. */
    bool enableWatchdog;           
    uint16_t watchdogTimeoutValue; 
    /* Filter for PHASEA, PHASEB, INDEX and HOME. */
    uint16_t filterCount; 
    uint16_t filterSamplePeriod; 
    /* Position compare. */
    enc_position_match_mode_t positionMatchMode; 
    uint32_t positionCompareValue;               
    /* Modulus counting. */
    enc_revolution_count_condition_t revolutionCountCondition; 
    bool enableModuloCountMode;                                
    uint32_t positionModulusValue; 
    uint32_t positionInitialValue; 
#if (defined(FSL_FEATURE_ENC_HAS_CTRL3) && FSL_FEATURE_ENC_HAS_CTRL3)
    /* Prescaler. */
    bool enablePeriodMeasurementFunction; 
    enc_prescaler_t prescalerValue;       
#endif
} enc_config_t;
 
typedef struct _enc_self_test_config
{
    enc_self_test_direction_t signalDirection; 
    uint16_t signalCount;  
    uint16_t signalPeriod; 
} enc_self_test_config_t;
 
#if defined(__cplusplus)
extern "C" {
#endif
 
/*******************************************************************************
 * API
 ******************************************************************************/
 
void ENC_Init(ENC_Type *base, const enc_config_t *config);
 
void ENC_Deinit(ENC_Type *base);
 
void ENC_GetDefaultConfig(enc_config_t *config);
 
void ENC_DoSoftwareLoadInitialPositionValue(ENC_Type *base);
 
void ENC_SetSelfTestConfig(ENC_Type *base, const enc_self_test_config_t *config);
 
void ENC_EnableWatchdog(ENC_Type *base, bool enable);
 
void ENC_SetInitialPositionValue(ENC_Type *base, uint32_t value);
 
/* @} */
 
uint32_t ENC_GetStatusFlags(ENC_Type *base);
 
void ENC_ClearStatusFlags(ENC_Type *base, uint32_t mask);
 
static inline uint16_t ENC_GetSignalStatusFlags(ENC_Type *base)
{
    return base->IMR;
}
/* @} */
 
void ENC_EnableInterrupts(ENC_Type *base, uint32_t mask);
 
void ENC_DisableInterrupts(ENC_Type *base, uint32_t mask);
 
uint32_t ENC_GetEnabledInterrupts(ENC_Type *base);
 
/* @} */
 
uint32_t ENC_GetPositionValue(ENC_Type *base);
 
uint32_t ENC_GetHoldPositionValue(ENC_Type *base);
 
static inline uint16_t ENC_GetPositionDifferenceValue(ENC_Type *base)
{
    return base->POSD;
}
 
static inline uint16_t ENC_GetHoldPositionDifferenceValue(ENC_Type *base)
{
    return base->POSDH;
}
 
static inline uint16_t ENC_GetRevolutionValue(ENC_Type *base)
{
    return base->REV;
}
 
static inline uint16_t ENC_GetHoldRevolutionValue(ENC_Type *base)
{
    return base->REVH;
}
 
#if (defined(FSL_FEATURE_ENC_HAS_LASTEDGE) && FSL_FEATURE_ENC_HAS_LASTEDGE)
static inline uint16_t ENC_GetLastEdgeTimeValue(ENC_Type *base)
{
    return base->LASTEDGE;
}
 
static inline uint16_t ENC_GetHoldLastEdgeTimeValue(ENC_Type *base)
{
    return base->LASTEDGEH;
}
#endif
 
#if (defined(FSL_FEATURE_ENC_HAS_POSDPER) && FSL_FEATURE_ENC_HAS_POSDPER)
static inline uint16_t ENC_GetPositionDifferencePeriodValue(ENC_Type *base)
{
    return base->POSDPER;
}
 
static inline uint16_t ENC_GetPositionDifferencePeriodBufferValue(ENC_Type *base)
{
    return base->POSDPERBFR;
}
 
static inline uint16_t ENC_GetHoldPositionDifferencePeriodValue(ENC_Type *base)
{
    return base->POSDPERH;
}
#endif
/* @} */
 
#if defined(__cplusplus)
}
#endif
 
/* @} */
 
#endif /* _FSL_ENC_H_ */