unit_sh200q.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_SH200Q_HPP
#define M5_UNIT_IMU_UNIT_UNIT_SH200Q_HPP
 
#include <M5UnitComponent.hpp>
#include <m5_utility/container/circular_buffer.hpp>
#include <memory>
#include "unit_sh200q_data.hpp"
#include "../imu/imu_data_source.hpp"
 
namespace m5 {
namespace unit {
 
class UnitSH200Q : public Component,
                   public PeriodicMeasurementAdapter<UnitSH200Q, sh200q::Data>,
                   public m5::imu::IMUDataSource {
    M5_UNIT_COMPONENT_HPP_BUILDER(UnitSH200Q, 0x6C);
 
public:
    struct config_t {
        bool start_periodic{true};
        sh200q::AccelRange accel_range{sh200q::AccelRange::G8};
        sh200q::GyroRange gyro_range{sh200q::GyroRange::DPS2000};
        sh200q::AccelOdr accel_odr{sh200q::AccelOdr::HZ256};
        sh200q::GyroOdr gyro_odr{sh200q::GyroOdr::HZ500};
        sh200q::GyroDlpf gyro_dlpf{sh200q::GyroDlpf::BW50};
    };
 
    explicit UnitSH200Q(const uint8_t addr = DEFAULT_ADDRESS);
    virtual ~UnitSH200Q()
    {
    }
 
    virtual bool begin() override;
    virtual void update(const bool force = false) override;
 
    config_t config() const
    {
        return _cfg;
    }
    void config(const config_t& cfg)
    {
        _cfg = cfg;
    }
 
    bool writeAccelRange(const sh200q::AccelRange range);
    bool writeGyroRange(const sh200q::GyroRange range);
    bool readAccelRange(sh200q::AccelRange& range);
    bool readGyroRange(sh200q::GyroRange& range);
 
    bool writeAccelOdr(const sh200q::AccelOdr odr);
    bool writeGyroOdr(const sh200q::GyroOdr odr);
    bool readAccelOdr(sh200q::AccelOdr& odr);
    bool readGyroOdr(sh200q::GyroOdr& odr);
 
    bool softReset();
 
 
    bool startPeriodicMeasurement(const sh200q::AccelRange accel_range, const sh200q::GyroRange gyro_range,
                                  const sh200q::AccelOdr accel_odr, const sh200q::GyroOdr gyro_odr,
                                  const sh200q::GyroDlpf gyro_dlpf);
    bool startPeriodicMeasurement();
    bool stopPeriodicMeasurement();
 
    virtual m5::imu::Capability imuSpec() const override
    {
        return m5::imu::Capability::Accel | m5::imu::Capability::Gyro | m5::imu::Capability::Temp;
    }
    virtual m5::imu::Capability readImuRaw(m5::imu::imu_raw_data_t& out) override;
    virtual void imuConvertParam(m5::imu::imu_convert_param_t& out) const override;
 
protected:
    bool start_periodic_measurement(const sh200q::AccelRange accel_range, const sh200q::GyroRange gyro_range,
                                    const sh200q::AccelOdr accel_odr, const sh200q::GyroOdr gyro_odr,
                                    const sh200q::GyroDlpf gyro_dlpf);
    bool start_periodic_measurement();
    bool stop_periodic_measurement();
    bool read_measurement(sh200q::Data& d);
    bool write_register8_verified(const uint8_t reg, const uint8_t val);
    bool toggle_register_bits(const uint8_t reg, const uint8_t bits);
 
    M5_UNIT_COMPONENT_PERIODIC_MEASUREMENT_ADAPTER_HPP_BUILDER(UnitSH200Q, sh200q::Data);
 
private:
    // Settings for begin(); never written to after that. What is currently on the device lives in
    // the live-state members below, so config() keeps meaning "what was configured"
    config_t _cfg{};
    // Mirrors of the registers this driver can change at runtime. imuConvertParam() needs the range
    // actually in effect (a stale factor would silently misreport every sample), and the no-argument
    // startPeriodicMeasurement() resumes from these rather than reverting to _cfg
    sh200q::AccelRange _accel_range{};
    sh200q::GyroRange _gyro_range{};
    sh200q::AccelOdr _accel_odr{};
    sh200q::GyroOdr _gyro_odr{};
    sh200q::GyroDlpf _gyro_dlpf{};
    uint32_t _pushed{}, _consumed{};  // readImuRaw pop counters (do not disturb latest()/oldest())
    std::unique_ptr<m5::container::CircularBuffer<sh200q::Data>> _data{};
};
 
namespace sh200q {
constexpr uint32_t DEFAULT_STORED_SIZE{8};
 
namespace command {
constexpr uint8_t REG_OUTPUT{0x00};       // burst: accel6 + gyro6 + temp2 (little-endian) = 14 bytes
constexpr uint8_t REG_ACC_CONFIG{0x0E};   // [7] HPF bypass / [4:3] ODR / [0] filter enable
constexpr uint8_t REG_GYRO_CONFIG{0x0F};  // [4] HPF bypass / [3:1] ODR / [0] filter enable
constexpr uint8_t REG_GYRO_DLPF{0x11};    // low bits: DLPF setting (ODR-relative bandwidth)
constexpr uint8_t REG_FIFO_CONFIG{0x12};  // [7:6] buffer mode (00 = bypass)
constexpr uint8_t REG_ACC_RANGE{0x16};    // [1:0] full scale
constexpr uint8_t REG_GYRO_RANGE{0x2B};   // [2:0] full scale
constexpr uint8_t REG_CHIP_ID{0x30};      // = 0x18
// Undocumented registers: the datasheet register map ends at 0x30. The init sequence in begin()
// mirrors the original M5StickC library (SH200Q.cpp) verbatim -- no public documentation exists
// for these, and skipping them leaves the ADC in a bad state.
constexpr uint8_t REG_ADC_RESET{0xC2};  // bit2 toggled 1 -> 0
constexpr uint8_t REG_INIT_D8{0xD8};    // bit7 toggled 1 -> 0
constexpr uint8_t REG_INIT_78{0x78};    // written 0x61 -> 0x00
constexpr uint8_t REG_SET1{0xBA};       // written 0xC0
constexpr uint8_t REG_SET2{0xCA};       // bit4 toggled 1 -> 0 ("ADC reset" in the original library)
}  // namespace command
}  // namespace sh200q
 
}  // namespace unit
}  // namespace m5
#endif