sensor/accelerometer/bma/SensorBMA422.hpp

Go to the documentation of this file.

 
#pragma once
 
#include "../../../SensorBuildOpt.h"
#if !SENSORLIB_EXCLUDE_BMA422
 
#include "SensorBMA4XX.hpp"
#include "../../../bosch/bma4xx/bma422_an.h"
 
class SensorBMA422 : public SensorBMA4XX
{
public:
 
    struct EventCallbacks {
        std::function<void(void)> onAnyMotion = nullptr;                     
        std::function<void(void)> onNoMotion = nullptr;                      
        std::function<void(AccelerometerData &)> onDataReady = nullptr;      
    };
 
    SensorBMA422() : SensorBMA4XX(), _status(0)
    {
        _remap_reg_offset = BMA422_AN_AXES_REMAP_START_ADDR;
    }
 
    using SensorBMA4XX::MotionAxesConfig;
 
    ~SensorBMA422() = default;
 
    BMA4XXCapability::Capability getCapabilities() const override
    {
        return BMA4XXCapability::Capability::SupportDataReady
               | BMA4XXCapability::Capability::SupportAnyMotion
               | BMA4XXCapability::Capability::SupportNoMotion
               | BMA4XXCapability::Capability::SupportAxisRemap;
    }
 
    void setOnAnyMotionCallback(std::function<void(void)> cb)
    {
        callbacks.onAnyMotion = std::move(cb);
    }
 
    void setOnNoMotionCallback(std::function<void(void)> cb)
    {
        callbacks.onNoMotion = std::move(cb);
    }
 
    void setOnDataReadyCallback(std::function<void(AccelerometerData)> cb)
    {
        callbacks.onDataReady = std::move(cb);
    }
 
    void setCallbacks(const EventCallbacks &cbs)
    {
        callbacks = cbs;
    }
 
    EventCallbacks &getCallbacks()
    {
        return callbacks;
    }
 
    const EventCallbacks &getCallbacks() const
    {
        return callbacks;
    }
 
    bool enableDataReady(bool enable = true, InterruptPinMap pin_map = InterruptPinMap::PIN1) override
    {
        return enableInterrupt(pin_map, BMA4_DATA_RDY_INT, enable);
    }
 
    bool enableAnyMotionDetection(const MotionAxesConfig &cfg, bool enable,
                                  bool interrupt_enable = false,
                                  InterruptPinMap pin_map = InterruptPinMap::PIN1) override
    {
        int8_t rslt = 0;
        struct bma422_an_any_no_mot_config any_mot_config = { 0, 0, 0};
 
        rslt = bma422_an_get_any_mot_config(&any_mot_config, dev.get());
        if (rslt != 0) {
            SENSORLIB_LOG_E("bma422_an_get_any_mot_config failed");
            return false;
        }
 
        any_mot_config.axes_en = 0x00;
        if (enable) {
            if (cfg.x_axis) any_mot_config.axes_en |= BMA422_AN_X_AXIS_EN;
            if (cfg.y_axis) any_mot_config.axes_en |= BMA422_AN_Y_AXIS_EN;
            if (cfg.z_axis) any_mot_config.axes_en |= BMA422_AN_Z_AXIS_EN;
        }
 
        if (!enableInterrupt(pin_map, BMA422_AN_ANY_MOT_INT, interrupt_enable)) {
            return false;
        }
 
        rslt = bma422_an_set_any_mot_config(&any_mot_config, dev.get());
        return rslt == 0;
    }
 
    bool enableNoMotionDetection(const MotionAxesConfig &cfg, bool enable,
                                 bool interrupt_enable = false,
                                 InterruptPinMap pin_map = InterruptPinMap::PIN1) override
    {
        int8_t rslt = 0;
        struct bma422_an_any_no_mot_config no_mot_config = { 0, 0, 0};
        rslt = bma422_an_get_no_mot_config(&no_mot_config, dev.get());
        if (rslt != 0) {
            SENSORLIB_LOG_E("bma422_an_get_no_mot_config failed");
            return false;
        }
        no_mot_config.axes_en = 0x00;
        if (enable) {
            if (cfg.x_axis) no_mot_config.axes_en |= BMA422_AN_X_AXIS_EN;
            if (cfg.y_axis) no_mot_config.axes_en |= BMA422_AN_Y_AXIS_EN;
            if (cfg.z_axis) no_mot_config.axes_en |= BMA422_AN_Z_AXIS_EN;
        }
 
        if (!enableInterrupt(pin_map, BMA422_AN_NO_MOT_INT, interrupt_enable)) {
            return false;
        }
 
        rslt = bma422_an_set_no_mot_config(&no_mot_config, dev.get());
        return rslt == 0;
    }
 
    bool configNoMotion(uint16_t threshold, uint16_t duration) override
    {
        return configMotion(false, threshold, duration);
    }
 
    bool configAnyMotion(uint16_t threshold, uint16_t duration) override
    {
        return configMotion(true, threshold, duration);
    }
 
    bool configMotion(bool any_motion, uint16_t threshold, uint16_t duration) override
    {
        int8_t rslt = 0;
 
        if (threshold > 16380) {  // Max threshold based on 0.48mg resolution for 16g range
            SENSORLIB_LOG_E("Threshold %u exceeds recommended maximum (16380)", threshold);
        }
 
        if (duration > 16383) {  // Maximum 14-bit value
            SENSORLIB_LOG_E("Duration %u exceeds recommended maximum (16383)", duration);
        }
 
        struct bma422_an_any_no_mot_config any_mot_config = {0, 0, 0};
 
        if (any_motion) {
            rslt = bma422_an_get_any_mot_config(&any_mot_config, dev.get());
            if (rslt != 0) {
                SENSORLIB_LOG_E("bma422_an_get_any_mot_config failed");
                return false;
            }
        } else {
            rslt = bma422_an_get_no_mot_config(&any_mot_config, dev.get());
            if (rslt != 0) {
                SENSORLIB_LOG_E("bma422_an_get_no_mot_config failed");
                return false;
            }
        }
 
        any_mot_config.threshold = threshold;
        any_mot_config.duration = duration;
 
        SENSORLIB_LOG_D("Configuring motion detection: threshold=%u LSB (%.2f mG), duration=%u LSB (%.2f ms at 50Hz)",
                        threshold, threshold * 0.48f,
                        duration, duration * 20.0f);
 
        if (any_motion) {
            if (bma422_an_set_any_mot_config(&any_mot_config, dev.get()) != 0) {
                SENSORLIB_LOG_E("Failed to configure any-motion detection");
                return false;
            }
        } else {
            if (bma422_an_set_no_mot_config(&any_mot_config, dev.get()) != 0) {
                SENSORLIB_LOG_E("Failed to configure no-motion detection");
                return false;
            }
        }
        return true;
    }
 
 
    bool configAnyMotionInPhysicalUnits(float threshold_mg, float duration_ms) override
    {
        uint16_t threshold_lsb = static_cast<uint16_t>(threshold_mg / 0.48f + 0.5f);
        uint16_t duration_lsb = static_cast<uint16_t>(duration_ms / 20.0f + 0.5f);
 
        SENSORLIB_LOG_D("Converting: %.2f mg -> %u LSB, %.2f ms -> %u LSB",
                        threshold_mg, threshold_lsb, duration_ms, duration_lsb);
 
        return configAnyMotion(threshold_lsb, duration_lsb);
    }
 
 
    bool configNoMotionInPhysicalUnits(float threshold_mg, float duration_ms) override
    {
        uint16_t threshold_lsb = static_cast<uint16_t>(threshold_mg / 0.48f + 0.5f);
        uint16_t duration_lsb = static_cast<uint16_t>(duration_ms / 20.0f + 0.5f);
 
        SENSORLIB_LOG_D("Converting: %.2f mg -> %u LSB, %.2f ms -> %u LSB",
                        threshold_mg, threshold_lsb, duration_ms, duration_lsb);
 
        return configNoMotion(threshold_lsb, duration_lsb);
    }
 
    bool getAnyMotionConfig(float &threshold_mg, float &duration_ms)
    {
        struct bma422_an_any_no_mot_config any_mot_config;
        if (bma422_an_get_any_mot_config(&any_mot_config, dev.get()) != 0) {
            SENSORLIB_LOG_E("Failed to read motion configuration");
            return false;
        }
 
        threshold_mg = any_mot_config.threshold * 0.48f;
        duration_ms = any_mot_config.duration * 20.0f;
 
        SENSORLIB_LOG_D("Current config: threshold=%u LSB (%.2f mg), duration=%u LSB (%.2f ms)",
                        any_mot_config.threshold, threshold_mg,
                        any_mot_config.duration, duration_ms);
 
        return true;
    }
 
    bool getNoMotionConfig(float &threshold_mg, float &duration_ms)
    {
        struct bma422_an_any_no_mot_config no_mot_config;
        if (bma422_an_get_no_mot_config(&no_mot_config, dev.get()) != 0) {
            SENSORLIB_LOG_E("Failed to read no-motion configuration");
            return false;
        }
 
        threshold_mg = no_mot_config.threshold * 0.48f;
        duration_ms = no_mot_config.duration * 20.0f;
 
        SENSORLIB_LOG_D("Current no-motion config: threshold=%u LSB (%.2f mg), duration=%u LSB (%.2f ms)",
                        no_mot_config.threshold, threshold_mg,
                        no_mot_config.duration, duration_ms);
 
        return true;
    }
 
    void update() override
    {
        if (bma4_read_int_status(&_status, dev.get()) != 0) {
            return;
        }
 
        if (_status == 0) {
            return;
        }
 
        if ((_status & BMA422_AN_ANY_MOT_INT) && callbacks.onAnyMotion) {
            callbacks.onAnyMotion();
        }
 
        if ((_status & BMA422_AN_NO_MOT_INT) && callbacks.onNoMotion) {
            callbacks.onNoMotion();
        }
 
        if ((_status & BMA4_ACCEL_DATA_RDY_INT) && callbacks.onDataReady) {
            AccelerometerData data;
            if (readData(data)) {
                callbacks.onDataReady(data);
            }
        }
 
        _status = 0;
    }
 
private:
    bool boschInitImpl() override
    {
        int8_t rslt = bma422_an_init(dev.get());
        if ( rslt != 0 ) {
            SENSORLIB_LOG_E("bma422_an_init failed with code %d", rslt);
            return false;
        }
        rslt = bma422_an_write_config_file(dev.get());
        if (rslt != 0) {
            SENSORLIB_LOG_E("bma422_an_write_config_file failed with code %d", rslt);
            return false;
        }
        return true;
    }
protected:
    EventCallbacks callbacks;
    uint16_t _status;
};
 
#endif