unit_ak8963_data.hpp

Go to the documentation of this file.

/*
 * SPDX-FileCopyrightText: 2026 M5Stack Technology CO LTD
 *
 * SPDX-License-Identifier: MIT
 */
#ifndef M5_UNIT_IMU_UNIT_UNIT_AK8963_DATA_HPP
#define M5_UNIT_IMU_UNIT_UNIT_AK8963_DATA_HPP
 
#include <array>
#include <cstdint>
#include <cmath>
 
namespace m5 {
namespace unit {
namespace ak8963 {
 
enum class Mode : uint8_t {
    PowerDown = 0x00,  
    Single    = 0x01,  
    Cont8Hz   = 0x02,  
    Cont100Hz = 0x06,  
    SelfTest  = 0x08,  
    FuseRom   = 0x0F,  
};
 
enum class MeasurementMode : uint8_t {
    Cont8Hz   = 0x02,  
    Cont100Hz = 0x06,  
};
 
enum class OutputBit : uint8_t {
    Bit14 = 0x00,  
    Bit16 = 0x10,  
};
 
constexpr uint32_t interval_ms(const MeasurementMode mode)
{
    return (mode == MeasurementMode::Cont8Hz) ? 125U : 10U;
}
 
constexpr uint8_t cntl1_value(const MeasurementMode mode, const OutputBit bit)
{
    return static_cast<uint8_t>(static_cast<uint8_t>(bit) | static_cast<uint8_t>(mode));
}
 
constexpr float RAW_UT_PER_LSB{4912.0f / 32760.0f};
constexpr float RAW_UT_PER_LSB_14BIT{4912.0f / 8190.0f};
constexpr float OUTPUT_LSB_PER_UT{16.0f};
 
struct Data {
    std::array<uint8_t, 8> raw{};  
    std::array<uint8_t, 3> asa{};  
 
    inline bool drdy() const
    {
        return (raw[0] & 0x01) != 0;
    }
    inline bool dor() const
    {
        return (raw[0] & 0x02) != 0;
    }
    inline bool overflow() const
    {
        return (raw[7] & 0x08) != 0;
    }
    inline bool bit16() const
    {
        return (raw[7] & 0x10) != 0;
    }
    inline int16_t x_raw() const
    {
        return static_cast<int16_t>((raw[2] << 8) | raw[1]);
    }
    inline int16_t y_raw() const
    {
        return static_cast<int16_t>((raw[4] << 8) | raw[3]);
    }
    inline int16_t z_raw() const
    {
        return static_cast<int16_t>((raw[6] << 8) | raw[5]);
    }
 
    inline int32_t adj_x() const
    {
        return adjust(x_raw(), asa[0]);
    }
    inline int32_t adj_y() const
    {
        return adjust(y_raw(), asa[1]);
    }
    inline int32_t adj_z() const
    {
        return adjust(z_raw(), asa[2]);
    }
 
private:
    inline int32_t adjust(const int16_t raw_axis, const uint8_t asa_axis) const
    {
        // Hadj = raw * (ASA + 128) / 256, then rescale to 16 LSB/µT. The sensitivity comes from the
        // sample's own BITM bit, so a 14bit sample is scaled by 0.6µT/LSB even if the chip has been
        // switched to 16bit since
        const float ut = raw_axis * ((asa_axis + 128) / 256.0f) * (bit16() ? RAW_UT_PER_LSB : RAW_UT_PER_LSB_14BIT);
        return static_cast<int32_t>(lroundf(ut * OUTPUT_LSB_PER_UT));
    }
};
 
}  // namespace ak8963
}  // namespace unit
}  // namespace m5
#endif