tle5012b_reg.hpp

Go to the documentation of this file.

 
#ifndef TLE5012B_REG_HPP
#define TLE5012B_REG_HPP
 
#include <stdint.h>
#include <stdlib.h>
#include "TLE5012b.hpp"
 
class Reg
{
    public:
 
        void *p;
 
        enum calibrationMode_t
        {
            noAutoCal = 0x0,
            mode1,          
            mode2,          
            mode3           
        };
 
        enum angleRange_t
        {
            factor1 = 0x080, 
            factor4 = 0x200, 
            factor5 = 0x040  
        };
 
        enum interfaceType_t
        {
            IIF = 0,  
            PWM,      
            HSM,      
            SPC,      
            SSC       
        };
 
        enum sensorType_t
        {
            TLE5012B_E1000= 0x0,  
            TLE5012B_E3005,       
            TLE5012B_E5000,       
            TLE5012B_E5020,       
            TLE5012B_E9000,       
        };
 
        enum Access_t
        {
            REG_ACCESS_R    = (0x01U),      
            REG_ACCESS_W    = (0x02U),      
            REG_ACCESS_RW   = (0x03U),      
            REG_ACCESS_U    = (0x04U),      
            REG_ACCESS_RU   = (0x05U),      
            REG_ACCESS_RWU  = (0x07U),      
            REG_ACCESS_RES  = (0x10U)       
        };
 
        typedef struct
        {
            uint8_t  regAccess;              
            uint16_t regAddress;             
            uint16_t mask;                   
            uint8_t  position;               
            uint8_t  resetValue;             
            uint8_t  posMap;                 
        }BitField_t;
 
        typedef struct
        {
            uint16_t regAddress;            
            uint8_t  posMap;                
        }AddressField_t;
 
        static const AddressField_t addrFields[];    
 
        enum Addr_t
        {
            REG_STAT         = (0x0000U),    
            REG_ACSTAT       = (0x0010U),    
            REG_AVAL         = (0x0020U),    
            REG_ASPD         = (0x0030U),    
            REG_AREV         = (0x0040U),    
            REG_FSYNC        = (0x0050U),    
            REG_MOD_1        = (0x0060U),    
            REG_SIL          = (0x0070U),    
            REG_MOD_2        = (0x0080U),    
            REG_MOD_3        = (0x0090U),    
            REG_OFFX         = (0x00A0U),    
            REG_OFFY         = (0x00B0U),    
            REG_SYNCH        = (0x00C0U),    
            REG_IFAB         = (0x00D0U),    
            REG_MOD_4        = (0x00E0U),    
            REG_TCO_Y        = (0x00F0U),    
            REG_ADC_X        = (0x0100U),    
            REG_ADC_Y        = (0x0110U),    
            REG_D_MAG        = (0x0140U),    
            REG_T_RAW        = (0x0150U),    
            REG_IIF_CNT      = (0x0200U),    
            REG_T25O         = (0x0300U)     
        };
 
        uint16_t regMap[MAX_NUM_REG];              
 
        Reg(void* p);
        ~Reg();
 
        // REG_STAT
        bool isStatusReset(void);
        bool isStatusWatchDog(void);
        bool isStatusVoltage(void);
        bool isStatusFuse(void);
        bool isStatusDSPU(void);
        bool isStatusOverflow(void);
        bool isStatusXYOutOfLimit(void);
        bool isStatusMagnitideOutOfLimit(void);
        bool isStatusADC(void);
        bool isStatusROM(void);
        bool isStatusGMRXY(void);
        bool isStatusGMRA(void);
        bool isStatusRead(void);
        uint8_t getSlaveNumber(void);
        void setSlaveNumber(const uint8_t snr);
 
        // REG_ACSTAT
        bool isActivationReset(void);
        void setActivationReset(void);
        void enableWatchdog(void);
        void disableWatchdog(void);
        bool isWatchdog(void);
        void enableVoltageCheck(void);
        void disableVoltageCheck(void);
        bool isVoltageCheck(void);
        void enableFuseCRC(void);
        void disableFuseCRC(void);
        bool isFuseCRC(void);
        void enableDSPUbist(void);
        void disableDSPUbist(void);
        bool isDSPUbist(void);
        void enableDSPUoverflow(void);
        void disableDSPUoverflow(void);
        bool isDSPUoverflow(void);
        void enableXYCheck(void);
        void disableXYCheck(void);
        bool isXYCheck(void);
        void enableGMRCheck(void);
        void disableGMRCheck(void);
        bool isGMRCheck(void);
        void enableADCCheck(void);
        void disableADCCheck(void);
        bool isADCCheck(void);
        void activateFirmwareReset(void);
        bool isFirmwareReset(void);
 
        // REG_AVAL
        bool isAngleValueNew(void);
        uint16_t getAngleValue(void);
 
        // REG_ASPD
        bool isSpeedValueNew(void);
        uint16_t getSpeedValue(void);
 
        // REG_AREV
        bool isNumberOfRevolutionsNew(void);
        uint16_t getNumberOfRevolutions(void);
        uint16_t getFrameCounter(void);
        void setFrameCounter(uint16_t fcnt);
 
        // REG_FSYNC
        uint16_t getFrameSyncCounter(void);
        void setFrameSyncCounter(uint16_t fsync);
        uint16_t getTemperatureValue(void);
 
        // REG_MOD_1
        void setFilterDecimation(uint8_t firmd);
        uint8_t getFilterDecimation(void);
        void setIIFMod(uint8_t iifmod);
        uint8_t getIIFMod(void);
        void holdDSPU(void);
        void releaseDSPU(void);
        bool isDSPUhold(void);
        void setInternalClock(void);
        void setExternalClock(void);
        bool statusClockSource(void);
 
        // REG_SIL
        void enableFilterParallel(void);
        void disableFilterParallel(void);
        bool isFilterParallel(void);
        void enableFilterInverted(void);
        void disableFilterInverted(void);
        bool isFilterInverted(void);
        void enableADCTestVector(void);
        void disableADCTestVector(void);
        bool isADCTestVector(void);
        void setFuseReload(void);
        bool getFulseReload(void);
        void setTestVectorX(uint8_t adctvx);
        uint8_t getTestVectorX(void);
        void setTestVectorY(uint8_t adctvs);
        uint8_t getTestVectorY(void);
 
        // REG_MOD_2
        void directionClockwise(void);
        void directionConterClockwise(void);
        bool isAngleDirection(void);
        void enablePrediction(void);
        void disablePrediction(void);
        bool isPrediction(void);
        void setAngleRange(angleRange_t range);
        angleRange_t getAngleRange(void);
        void setCalibrationMode(calibrationMode_t autocal);
        calibrationMode_t getCalibrationMode(void);
 
        // REG_MOD_3
        void enableSpikeFilter(void);
        void disableSpikeFilter(void);
        bool isSpikeFilter(void);
        void enableSSCOpenDrain(void);
        void enableSSCPushPull(void);
        bool isSSCOutputMode(void);
        void setAngleBase(uint16_t base);
        uint16_t getAngleBase(void);
        void setPadDriver(uint8_t pad);
        uint8_t getPadDriver(void);
 
        // REG_OFFX
        int16_t getOffsetX(void);
        void setOffsetX(int16_t offx);
 
        // REG_OFFY
        int16_t getOffsetY(void);
        void setOffsetY(int16_t offy);
 
        // REG_SYNCH
        void setAmplitudeSynch(int16_t synch);
        int16_t getAmplitudeSynch(void);
 
        // REG_IFAB
        void setFIRUpdateRate(bool fir);
        uint8_t getFIRUpdateRate(void);
        void enableIFABOpenDrain(void);
        void enableIFABPushPull(void);
        bool isIFABOutputMode(void);
        void setOrthogonality(int16_t ortho);
        int16_t getOrthogonality(void);
        void setHysteresisMode(uint8_t hyst);
        uint8_t getHysteresisMode(void);
 
        // REG_MOD_4
        void setInterfaceMode(interfaceType_t ifmd);
        interfaceType_t getInterfaceMode(void);
        void setIFABres(uint8_t res);
        uint8_t getIFABres(void);
        void setHSMplp(uint8_t plp);
        uint8_t getHSMplp(void);
        void setOffsetTemperatureX(int8_t tcox);
        int8_t getOffsetTemperatureX(void);
 
        // REG_TCO_Y
        void setOffsetTemperatureY(int8_t tcoy);
        int8_t getOffsetTemperatureY(void);
        void enableStartupBist(void);
        void disableStartupBist(void);
        bool isStartupBist(void);
        void setCRCpar(uint16_t crc);
        uint16_t getCRCpar(void);
 
        // REG_ADC_X REG_ADC_Y
        int16_t getADCx(void);
        int16_t getADCy(void);
 
        // REG_D_MAG
        uint16_t getVectorMagnitude(void);
        uint16_t getTemperatureRAW(void);
        bool isTemperatureToggle(void);
 
        // REG_T25O
        uint16_t getCounterIncrements(void);
        uint16_t getT25Offset(void);
 
    private:
 
        static const BitField_t     bitFields[];        
 
        enum BitFieldReg_t
        {
            REG_STAT_SRST,
            REG_STAT_SWD,
            REG_STAT_SVR,
            REG_STAT_SFUSE,
            REG_STAT_SDSPU,
            REG_STAT_SOV,
            REG_STAT_SXYOL,
            REG_STAT_SMAGOL,
            REG_STAT_RESERVED,
            REG_STAT_SADCT,
            REG_STAT_SROM,
            REG_STAT_NOGMRXY,
            REG_STAT_NOGMRA,
            REG_STAT_SNR,
            REG_STAT_RDST,
 
            REG_ACSTAT_ASRST,
            REG_ACSTAT_ASWD,
            REG_ACSTAT_ASVR,
            REG_ACSTAT_ASFUSE,
            REG_ACSTAT_ASDSPU,
            REG_ACSTAT_ASOV,
            REG_ACSTAT_ASVECXY,
            REG_ACSTAT_ASVEGMAG,
            REG_ACSTAT_RESERVED1,
            REG_ACSTAT_ASADCT,
            REG_ACSTAT_ASFRST,
            REG_ACSTAT_RESERVED2,
 
            REG_AVAL_ANGVAL,
            REG_AVAL_RDAV,
 
            REG_ASPD_ANGSPD,
            REG_ASPD_RDAS,
 
            REG_AREV_REVOL,
            REG_AREV_FCNT,
            REG_AREV_RDREV,
 
            REG_FSYNC_TEMPR,
            REG_FSYNC_FSYNC,
 
            REG_MOD_1_IIFMOD,
            REG_MOD_1_DSPUHOLD,
            REG_MOD_1_RESERVED1,
            REG_MOD_1_CLKSEL,
            REG_MOD_1_RESERVED2,
            REG_MOD_1_FIRMD,
 
            REG_SIL_ADCTVX,
            REG_SIL_ADCTVY,
            REG_SIL_ADCTVEN,
            REG_SIL_RESERVED1,
            REG_SIL_FUSEREL,
            REG_SIL_RESERVED2,
            REG_SIL_FILTINV,
            REG_SIL_FILTPAR,
 
            REG_MOD_2_AUTOCAL,
            REG_MOD_2_PREDICT,
            REG_MOD_2_ANGDIR,
            REG_MOD_2_ANGRANGE,
            REG_MOD_2_RESERVED1,
 
            REG_MOD_3_PADDRV,
            REG_MOD_3_SSCOD,
            REG_MOD_3_SPIKEF,
            REG_MOD_3_ANG_BASE,
 
            REG_OFFX_RESERVED1,
            REG_OFFX_XOFFSET,
 
            REG_OFFY_RESERVED1,
            REG_OFFY_YOFFSET,
 
            REG_SYNCH_RESERVED1,
            REG_SYNCH_SYNCH,
 
            REG_IFAB_IFADHYST,
            REG_IFAB_IFABOD,
            REG_IFAB_FIRUDR,
            REG_IFAB_ORTHO,
 
            REG_MOD_4_IFMD,
            REG_MOD_4_RESERVED1,
            REG_MOD_4_IFABRES,
            REG_MOD_4_HSMPLP,
            REG_MOD_4_TCOXT,
 
            REG_TCO_Y_CRCPAR,
            REG_TCO_Y_SBIST,
            REG_TCO_Y_TCOYT,
 
            REG_ADC_X_ADCX,
 
            REG_ADC_Y_ADCY,
 
            REG_D_MAG_MAG,
            REG_D_MAG_RESERVED1,
 
            REG_T_RAW_TRAW,
            REG_T_RAW_RESERVED1,
            REG_T_RAW_TTGL,
 
            REG_IIF_CNT_IIFCNT,
            REG_IIF_CNT_RESERVED1,
 
            REG_T25O_T250,
            REG_T25O_RESERVED1,
        };
 
        bool getBitField (BitField_t bitField, uint16_t & bitFValue);
        bool setBitField (BitField_t bitField, uint16_t bitFNewValue);
 
        void* parent_;
 
};
 
#endif /* TLE5012B_REG_HPP */