mimx11xx_acmp.h

#ifndef  __MIMX11XX_ACMP_H
#define  __MIMX11XX_ACMP_H
/*NB_REVISION*/
 
/*NB_COPYRIGHT*/
 
#include <predef.h>
#include <sim.h>
 
#define ACMP_MAX_INPUTS 4
#define ACMP_FAST_CLK_MIN_DIV 2
#define ACMP_INT_DAC_CH 0x6
#define ACMP_IRQ_DEF_PRIO 4
 
class MIMX_ACMP {
public:
    typedef void (*IrqHandler_t)(MIMX_ACMP &, uint32_t status);
    enum class eFastClock : uint8_t {
        OSC_RC_48M_DIV2 = 0,
        OSC_24M         = 1,
        OSC_400M        = 2,
        OSC_RC_16M      = 3,
        SYS_PLL3_CLK    = 4,
        SYS_PLL1_DIV5   = 5,
        AUDIO_PLL_CLK   = 6,
        SYS_PLL2_PFD3   = 7
    };
    enum class eHyst : uint8_t {
        Hyst_5mv   = 0,
        Hyst_10mv  = 1,
        Hyst_20mv  = 2,
        Hyst_30mv  = 3,
    };
 
    enum class eSamplePeriod : uint8_t {
        Samp_1  = 0,
        Samp_2  = 1,
        Samp_4  = 2,
        Samp_8  = 3,
        Samp_16 = 4,
        Samp_32 = 5,
        Samp_64 = 6,
        Samp_256= 7,
    };
 
private:
    static IrqHandler_t irqCb[];
 
    CMP_Type   &cmp;
 
    static void sIrqHandler();
//    void IrqHandler();
 
    MIMX_ACMP(CMP_Type *acmp);
 
public:
 
    MIMX_ACMP(uint32_t moduleIdx, uint16_t PosCh, uint16_t NegCh, uint8_t DacVal = 0,
            int OutPol = 0, uint8_t filtPer = 0, uint8_t filtCount = 0,
            eSamplePeriod sampPer = eSamplePeriod::Samp_16,
            eHyst hyst = eHyst::Hyst_5mv);
 
    uint32_t HwIdx();
 
    void Enable();
    void Disable();
 
    void SetInputs(uint8_t PosCh, uint8_t NegCh);
    void SetPosInput(uint8_t ch);
    void SetNegInput(uint8_t ch);
    uint8_t GetPosInput();
    uint8_t GetNegInput();
    void SetDacVal(uint8_t dacVal);
    uint8_t GetDacVal();
    void SetOutputPolarity(int pol);
    int GetOutputPolarity();
    IrqHandler_t RegisterIsr(IrqHandler_t handler);
    IrqHandler_t SetIrqPrio(uint8_t prio);
    void EnableIrq(bool falling = true, bool rising = true);
    void DisableIrq(bool falling = true, bool rising = true);
 
    void SetFilter(uint8_t period, uint8_t count);
    void SetFilterPeriod(uint8_t period);
    void SetFilterCount(uint8_t count);
    uint8_t GetFilterPeriod();
    uint8_t GetFilterCount();
 
    bool GetState();
};
 
inline void
MIMX_ACMP::Enable()
    { cmp.C0 |= CMP_C0_EN(1); }
 
inline void
MIMX_ACMP::Disable()
    { cmp.C0 &= ~CMP_C0_EN_MASK; }
 
inline void
MIMX_ACMP::SetInputs(uint8_t PosCh, uint8_t NegCh)
{
    cmp.C1 = (cmp.C1 & ~(CMP_C1_PSEL_MASK | CMP_C1_MSEL_MASK))
        | CMP_C1_PSEL((PosCh & 0xF)+1) | CMP_C1_MSEL((NegCh & 0xF)+1);
}
 
inline void
MIMX_ACMP::SetPosInput(uint8_t ch)
    { cmp.C1 = (cmp.C1 & ~CMP_C1_PSEL_MASK) | CMP_C1_PSEL((ch & 0xF)+1); }
 
inline void
MIMX_ACMP::SetNegInput(uint8_t ch)
    { cmp.C1 = (cmp.C1 & ~CMP_C1_MSEL_MASK) | CMP_C1_MSEL((ch & 0xF)+1); }
 
inline uint8_t
MIMX_ACMP::GetPosInput()
    { return ((cmp.C1 & CMP_C1_PSEL_MASK)>>CMP_C1_PSEL_SHIFT)-1; }
 
inline uint8_t
MIMX_ACMP::GetNegInput()
    { return ((cmp.C1 & CMP_C1_MSEL_MASK)>>CMP_C1_MSEL_SHIFT)-1; }
 
inline void
MIMX_ACMP::SetDacVal(uint8_t dacVal)
{
    cmp.C1 = (cmp.C1 & ~CMP_C1_VOSEL_MASK) | CMP_C1_DACEN(1) | CMP_C1_VRSEL(1)
        | CMP_C1_DMODE(1) | CMP_C1_VOSEL(dacVal);
}
 
inline uint8_t
MIMX_ACMP::GetDacVal()
    { return ((cmp.C1 & CMP_C1_VOSEL_MASK) >> CMP_C1_VOSEL_SHIFT); }
 
inline void
MIMX_ACMP::SetOutputPolarity(int pol)
    { (pol < 0) ? (cmp.C0 |= CMP_C0_INVT_MASK) : (cmp.C0 &= ~CMP_C0_INVT_MASK); }
 
inline int
MIMX_ACMP::GetOutputPolarity()
    { return (cmp.C0 & CMP_C0_INVT_MASK) ? -1 : 1; }
 
inline void
MIMX_ACMP::EnableIrq(bool falling, bool rising)
    { cmp.C0 |= (falling ? CMP_C0_IEF_MASK : 0) | (rising ? CMP_C0_IER_MASK : 0); }
 
inline void
MIMX_ACMP::DisableIrq(bool falling, bool rising)
    { cmp.C0 &= ~((falling ? CMP_C0_IEF_MASK : 0) | (rising ? CMP_C0_IER_MASK : 0)); }
 
inline void
MIMX_ACMP::SetFilter(uint8_t period, uint8_t count)
{
    cmp.C0 = (cmp.C0 & ~(CMP_C0_FPR_MASK | CMP_C0_FILTER_CNT_MASK | CMP_C0_COS_MASK))
        | CMP_C0_FPR(period) | CMP_C0_FILTER_CNT((count > 7)?7:count)
        | CMP_C0_COS(!period || !count);
}
 
inline void
MIMX_ACMP::SetFilterPeriod(uint8_t period)
{
    cmp.C0 = (cmp.C0 & ~(CMP_C0_FPR_MASK | CMP_C0_COS_MASK))
        | CMP_C0_FPR(period)
        | CMP_C0_COS(!period || !(cmp.C0 & CMP_C0_FILTER_CNT_MASK));
}
 
inline void
MIMX_ACMP::SetFilterCount(uint8_t count)
{
    cmp.C0 = (cmp.C0 & ~(CMP_C0_FILTER_CNT_MASK| CMP_C0_COS_MASK))
        | CMP_C0_FILTER_CNT(count)
        | CMP_C0_COS(!count || !(cmp.C0 & CMP_C0_FPR_MASK));
}
 
inline uint8_t
MIMX_ACMP::GetFilterPeriod()
    { return (cmp.C0 & CMP_C0_FPR_MASK) >> CMP_C0_FPR_SHIFT; }
 
inline uint8_t
MIMX_ACMP::GetFilterCount()
    { return (cmp.C0 & CMP_C0_FILTER_CNT_MASK) >> CMP_C0_FILTER_CNT_SHIFT; }
 
inline bool
MIMX_ACMP::GetState()
    { return (cmp.C0 & CMP_C0_COUT_MASK) != 0; }
 
 
#endif   /* ----- #ifndef __MIMX11XX_ACMP_H  ----- */