TMAG5273.hxx

Go to the documentation of this file.

 
#ifndef _FREERTOS_DRIVERS_COMMON_TMAG5273_HXX_
#define _FREERTOS_DRIVERS_COMMON_TMAG5273_HXX_
 
#include <fcntl.h>
#include <unistd.h>
#include <stropts.h>
#include <endian.h>
 
#include "i2c-dev.h"
#include "i2c.h"
#include "utils/Atomic.hxx"
#include "utils/logging.h"
#include "utils/macros.h"
 
class TMAG5273 : private Atomic
{
public:
    enum I2CAddress : uint8_t
    {
        ADDR_A = 0x35, 
        ADDR_B = 0x22, 
        ADDR_C = 0x78, 
        ADDR_D = 0x44, 
    };
 
    enum class DeviceID : uint8_t
    {
        UNKNOWN        = 0x00, 
        MT_40_AND_80   = 0x01, 
        MT_133_AND_266 = 0x02, 
        ERROR          = 0xFF, 
    };
 
    enum class ChannelEnable : uint8_t
    {
        ALL_OFF    = 0x00, 
        X_ENABLE   = 0x10, 
        Y_ENABLE   = 0x20, 
        XY_ENABLE  = 0x30, 
        Z_ENABLE   = 0x40, 
        XZ_ENABLE  = 0x50, 
        YZ_ENABLE  = 0x60, 
        XYZ_ENABLE = 0x70, 
        XYX_ENABLE = 0x80, 
        YXY_ENABLE = 0x90, 
        YZY_ENABLE = 0xA0, 
        XZX_ENABLE = 0xB0, 
    };
 
    enum class SleepTime : uint8_t
    {
        SLEEP_1_MSEC     = 0x00, 
        SLEEP_5_MSEC     = 0x01, 
        SLEEP_10_MSEC    = 0x02, 
        SLEEP_15_MSEC    = 0x03, 
        SLEEP_20_MSEC    = 0x04, 
        SLEEP_30_MSEC    = 0x05, 
        SLEEP_50_MSEC    = 0x06, 
        SLEEP_100_MSEC   = 0x07, 
        SLEEP_500_MSEC   = 0x08, 
        SLEEP_1000_MSEC  = 0x09, 
        SLEEP_2000_MSEC  = 0x0A, 
        SLEEP_5000_MSEC  = 0x0B, 
        SLEEP_20000_MSEC = 0x0C, 
    };
 
    enum class DeviceStatus : uint8_t
    {
        INT_N_PIN_RESET_LEVEL_MASK = 0x10,
        OSC_ERROR_MASK             = 0x08,
        INT_N_PIN_ERROR_MASK       = 0x04,
        OTP_CRC_ERROR_MASK         = 0x02,
        VCC_UV_ERROR_MASK          = 0x01,
    };
 
    enum class InterruptConfig : uint8_t
    {
        CONVERSION_COMPLETE_ENABLE = 0x80,
        THRESHOLD_ENABLE           = 0x40,
        STATE_MASK                 = 0x20,
        MODE_NONE                  = (0 << 2),
        MODE_INT_N                 = (1 << 2),
        MODE_INT_N_EXCEPT_I2C_BUSY = (2 << 2),
        MODE_SCL                   = (3 << 2),
        MODE_SCL_EXCEPT_I2C_BUSY   = (4 << 2),
        MASK_INT_N_MASK            = 0x01,
    };
 
    enum class ConversionStatus : uint8_t
    {
        SET_COUNT_MASK     = 0xE0,
        SET_COUNT_SHIFT    = 5,
        POR_MASK           = 0x10,
        DIAG_STATUS_MASK   = 0x02,
        RESULT_STATUS_MASK = 0x01,
    };
 
    enum class ConversionAverage : uint8_t
    {
        AVG_1  = (0 << 2), 
        AVG_2  = (1 << 2), 
        AVG_4  = (2 << 2), 
        AVG_8  = (3 << 2), 
        AVG_16 = (4 << 2), 
        AVG_32 = (5 << 2), 
    };
 
    enum class AngleEnable : uint8_t
    {
        OFF        = (0 << 2), 
        XY_ENABLE  = (1 << 2), 
        YZ_ENABLE  = (2 << 2), 
        XZ_ENABLE  = (3 << 2), 
    };
 
    enum class OperatingMode : uint8_t
    {
        STANDBY           = 0x00, 
        SLEEP             = 0x01, 
        CONTINUOUS        = 0x02, 
        WAKE_UP_AND_SLEEP = 0x03, 
    };
 
    TMAG5273(uint8_t address = ADDR_A)
        : i2cAddress_(address)
    { }
 
    TMAG5273(const char *i2c_path, uint8_t address = ADDR_A)
        : i2cAddress_(address)
    {
        init(i2c_path);
    }
 
    ~TMAG5273()
    {
        if (fd_ >= 0)
        {
            ::close(fd_);
        }
    }
 
    void init(const char *i2c_path)
    {
        int fd = ::open(i2c_path, O_RDWR);
        HASSERT(fd >= 0);
        init(fd);
    }
 
    void init(int i2c_fd)
    {
        fd_ = i2c_fd;
    }
 
    friend class MagSensorTest;
    friend class Input;
 
    DeviceID is_present()
    {
        uint8_t rc[3];
        // We start with a dummy read to ensure I2C is in a known state.
        register_read(TMAG5273::DEVICE_ID, rc, 3);
        if (register_read(TMAG5273::DEVICE_ID, rc, 3) < 0)
        {
            // Error reading from i2c.
            LOG(VERBOSE, "error read");
            return DeviceID::ERROR;
        }
        // mask off the reserved bits of the device ID.
        rc[0] &= DEVICE_ID_VERSION_MASK;
        if ((rc[0] != static_cast<uint8_t>(DeviceID::MT_40_AND_80) &&
             rc[0] != static_cast<uint8_t>(DeviceID::MT_133_AND_266)) ||
            rc[1] != 0x49 || rc[2] != 0x54)
        {
            LOG(VERBOSE, "read %x %x %x", rc[0], rc[1], rc[2]);
            return DeviceID::UNKNOWN;
        }
        return static_cast<DeviceID>(rc[0]);
    }
 
    DeviceStatus get_device_status()
    {
        uint8_t result;
        register_read(DEVICE_STATUS, &result, 1);
        return static_cast<DeviceStatus>(result);
    }
 
    void clr_device_status(DeviceStatus status)
    {
        register_write(DEVICE_STATUS, static_cast<uint8_t>(status));
    }
 
    void enable_channels(ChannelEnable enable)
    {
        register_modify(
            SENSOR_CONFIG_1, SCONF1_MAG_CH_MASK, static_cast<uint8_t>(enable));
    }
 
    void set_sleep_time(SleepTime t)
    {
        register_modify(SENSOR_CONFIG_1, SCONF1_SLEEP_TIME_MASK,
            static_cast<uint8_t>(t));
    }
 
    void set_interrupt_config(InterruptConfig config)
    {
        register_write(INT_CONFIG_1, static_cast<uint8_t>(config));
    }
 
    void set_operating_mode(OperatingMode mode)
    {
        register_modify(DEVICE_CONFIG_2, DCONF2_OPERATING_MODE_MASK,
            static_cast<uint8_t>(mode));
    }
 
    uint8_t get_conversion_status()
    {
        uint8_t result;
        register_read(CONV_STATUS, &result, 1);
        return result;
    }
 
    void clr_por_conversion_status()
    {
        register_write(
            CONV_STATUS, static_cast<uint8_t>(ConversionStatus::POR_MASK));
    }
 
    void set_oversampling(ConversionAverage avg)
    {
        register_modify(
            DEVICE_CONFIG_1, DCONF1_AVG_MASK, static_cast<uint8_t>(avg));
    }
 
    void set_angle_en(AngleEnable angle)
    {
        register_modify(
            SENSOR_CONFIG_2, SCONF2_ANGLE_EN_MASK, static_cast<uint8_t>(angle));
    }
 
    void set_angle_gain(uint8_t gain, bool second)
    {
        register_write(MAG_GAIN_CONFIG, gain);
        register_modify(SENSOR_CONFIG_2, SCONF2_MAG_GAIN_CH_MASK,
            second ? SCONF2_MAG_GAIN_CH_ADJ2 : SCONF2_MAG_GAIN_CH_ADJ1);
    }
 
    void set_offset_1(int8_t offset)
    {
        register_write(MAG_OFFSET_CONFIG_1, offset);
    }
 
    void set_offset_2(int8_t offset)
    {
        register_write(MAG_OFFSET_CONFIG_2, offset);
    }
 
    DeviceID get_device_id()
    {
        return static_cast<DeviceID>(
            register_read(DEVICE_ID) & DEVICE_ID_VERSION_MASK);
    }
 
    void read_conversion_results(int16_t xyz[3])
    {
        register_read(X_MSB_RESULT, (uint8_t*)xyz, 6);
        xyz[0] = be16toh(xyz[0]);
        xyz[1] = be16toh(xyz[1]);
        xyz[2] = be16toh(xyz[2]);
    }
 
    int16_t read_angle_result()
    {
        int16_t angle;
        register_read(ANGLE_RESULT_MSB, (uint8_t*)&angle, sizeof(int16_t));
        return be16toh(angle);
    }
 
private:
    enum BitMasks
    {
        DCONF1_AVG_MASK = 0b11100,
 
        DCONF2_OPERATING_MODE_MASK = 0b11,
 
        SCONF1_MAG_CH_MASK     = 0b11110000, 
        SCONF1_SLEEP_TIME_MASK = 0b00001111, 
 
        SCONF2_MAG_GAIN_CH_MASK = 1 << 4,
        SCONF2_MAG_GAIN_CH_ADJ1 = 0,
        SCONF2_MAG_GAIN_CH_ADJ2 = SCONF2_MAG_GAIN_CH_MASK,
 
        SCONF2_ANGLE_EN_MASK = 0b1100,
 
        DEVICE_ID_RESERVED_MASK = 0b11111100, 
        DEVICE_ID_VERSION_MASK  = 0b00000011, 
    };
 
    enum Registers
    {
        DEVICE_CONFIG_1 = 0x0,     // Configure Device Operation Modes
        DEVICE_CONFIG_2 = 0x1,     // Configure Device Operation Modes
        SENSOR_CONFIG_1 = 0x2,     // Sensor Device Operation Modes
        SENSOR_CONFIG_2 = 0x3,     // Sensor Device Operation Modes
        X_THR_CONFIG = 0x4,        // X Threshold Configuration
        Y_THR_CONFIG = 0x5,        // Y Threshold Configuration
        Z_THR_CONFIG = 0x6,        // Z Threshold Configuration
        T_CONFIG = 0x7,            // Temp Sensor Configuration
        INT_CONFIG_1 = 0x8,        // Configure Device Operation Modes
        MAG_GAIN_CONFIG = 0x9,     // Configure Device Operation Modes
        MAG_OFFSET_CONFIG_1 = 0xA, // Configure Device Operation Modes
        MAG_OFFSET_CONFIG_2 = 0xB, // Configure Device Operation Modes
        I2C_ADDRESS = 0xC,         // I2C Address Register
        DEVICE_ID = 0xD,           // ID for the device die
        MANUFACTURER_ID_LSB = 0xE, // Manufacturer ID lower byte
        MANUFACTURER_ID_MSB = 0xF, // Manufacturer ID upper byte
        T_MSB_RESULT = 0x10,       // Conversion Result Register
        T_LSB_RESULT = 0x11,       // Conversion Result Register
        X_MSB_RESULT = 0x12,       // Conversion Result Register
        X_LSB_RESULT = 0x13,       // Conversion Result Register
        Y_MSB_RESULT = 0x14,       // Conversion Result Register
        Y_LSB_RESULT = 0x15,       // Conversion Result Register
        Z_MSB_RESULT = 0x16,       // Conversion Result Register
        Z_LSB_RESULT = 0x17,       // Conversion Result Register
        CONV_STATUS = 0x18,        // Conversion Status Register
        ANGLE_RESULT_MSB = 0x19,   // Conversion Result Register
        ANGLE_RESULT_LSB = 0x1A,   // Conversion Result Register
        MAGNITUDE_RESULT = 0x1B,   // Conversion Result Register
        DEVICE_STATUS = 0x1C,      // Device_Diag Status Register
    };
 
    int register_read(uint8_t reg, uint8_t *data, uint16_t len)
    {
        struct i2c_msg msgs[] = {
            {.addr = i2cAddress_, .flags = 0, .len = 1, .buf = &reg},
            {.addr = i2cAddress_, .flags = I2C_M_RD, .len = len, .buf = data}};
 
        struct i2c_rdwr_ioctl_data ioctl_data = {
            .msgs = msgs, .nmsgs = ARRAYSIZE(msgs)};
 
        return ::ioctl(fd_, I2C_RDWR, &ioctl_data);
    }
 
    void register_write(uint8_t reg, const uint8_t *data, uint16_t len)
    {
        HASSERT(len <= 2);
        uint8_t dat[3];
        dat[0] = reg;
        dat[1] = data[0];
        if (len > 1)
        {
            dat[2] = data[1];
        }
        struct i2c_msg msgs[] = {{.addr = i2cAddress_,
            .flags = 0,
            .len = (uint16_t)(len + 1),
            .buf = dat}};
 
        struct i2c_rdwr_ioctl_data ioctl_data = {
            .msgs = msgs, .nmsgs = ARRAYSIZE(msgs)};
 
        ::ioctl(fd_, I2C_RDWR, &ioctl_data);
    }
 
    void register_write(uint8_t reg, uint8_t value)
    {
        register_write(reg, &value, 1);
    }
 
    uint8_t register_read(uint8_t reg)
    {
        uint8_t ret;
        register_read(reg, &ret, 1);
        return ret;
    }
 
    void register_modify(uint8_t reg, uint8_t mask, uint8_t value)
    {
        uint8_t current = register_read(reg);
        current &= ~mask;
        current |= (value & mask);
        register_write(reg, current);
    }
 
    int fd_ = -1;
    const uint8_t i2cAddress_;
};
 
inline TMAG5273::DeviceStatus operator|(
    const TMAG5273::DeviceStatus &a, const TMAG5273::DeviceStatus &b)
{
    return static_cast<TMAG5273::DeviceStatus>(
        static_cast<uint8_t>(a) | static_cast<uint8_t>(b));
}
 
inline TMAG5273::InterruptConfig operator|(
    const TMAG5273::InterruptConfig &a, const TMAG5273::InterruptConfig &b)
{
    return static_cast<TMAG5273::InterruptConfig>(
        static_cast<uint8_t>(a) | static_cast<uint8_t>(b));
}
 
#endif // _FREERTOS_DRIVERS_COMMON_TMAG5273_HXX_