sensor/accelerometer/bma/SensorBMA456H.hpp

Go to the documentation of this file.

 
#pragma once
 
#include "../../../SensorBuildOpt.h"
#if !SENSORLIB_EXCLUDE_BMA456H
 
#include "SensorBMA4XX.hpp"
#include "../../../bosch/bma4xx/bma456h.h"
 
class SensorBMA456H : public SensorBMA4XX
{
public:
 
    struct EventCallbacks {
        std::function<void(TapType)> onTap = nullptr;                     
        std::function<void()> onStepDetected = nullptr;                   
        std::function<void(uint32_t)> onStepCount = nullptr;              
        std::function<void(ActivityType)> onActivity = nullptr;           
        std::function<void(void)> onAnyMotion = nullptr;                     
        std::function<void(void)> onNoMotion = nullptr;                      
        std::function<void(AccelerometerData &)> onDataReady = nullptr;   
    };
 
    SensorBMA456H() : SensorBMA4XX(), _status(0)
    {
        _remap_reg_offset = BMA456H_AXES_REMAP_OFFSET;
    }
 
    using SensorBMA4XX::MotionAxesConfig;
 
    BMA4XXCapability::Capability getCapabilities() const override
    {
        return BMA4XXCapability::Capability::SupportDataReady
               | BMA4XXCapability::Capability::SupportAnyMotion
               | BMA4XXCapability::Capability::SupportNoMotion
               | BMA4XXCapability::Capability::SupportTap
               | BMA4XXCapability::Capability::SupportStepDetector
               | BMA4XXCapability::Capability::SupportStepCounter
               | BMA4XXCapability::Capability::SupportActivity
               | BMA4XXCapability::Capability::SupportAxisRemap;
    }
 
    ~SensorBMA456H() = default;
 
    void setOnTapCallback(std::function<void(TapType)> cb)
    {
        callbacks.onTap = std::move(cb);
    }
 
    void setOnStepDetectedCallback(std::function<void()> cb)
    {
        callbacks.onStepDetected = std::move(cb);
    }
 
    void setOnStepCountCallback(std::function<void(uint32_t)> cb)
    {
        callbacks.onStepCount = std::move(cb);
    }
 
    void setOnActivityCallback(std::function<void(ActivityType)> cb)
    {
        callbacks.onActivity = std::move(cb);
    }
 
    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 enableFeature(uint16_t feature, bool enable)
    {
        if (feature & BMA456H_STEP_COUNTER_EN) {
            if (bma456h_step_detector_enable(BMA4_ENABLE, dev.get()) != 0) {
                SENSORLIB_LOG_E("bma456h_step_detector_enable failed");
                return false;
            }
        }
        if (bma456h_feature_enable(feature, enable, dev.get()) != 0) {
            SENSORLIB_LOG_E("bma456h_feature_enable failed");
            return false;
        }
        return true;
    }
 
    bool enableDataReady(bool enable = true, InterruptPinMap pin_map = InterruptPinMap::PIN1) override
    {
        return enableInterrupt(pin_map, BMA4_DATA_RDY_INT, enable);
    }
 
    bool enableStepCounter(bool enable, uint16_t step_counter_wm = 1, bool reset_counter = false) override
    {
 
        if (bma456h_step_counter_set_watermark(step_counter_wm, dev.get()) != 0) {
            SENSORLIB_LOG_E("Failed to set step counter watermark");
            return false;
        }
 
        if (reset_counter) {
            if (bma456h_reset_step_counter(dev.get()) != 0) {
                SENSORLIB_LOG_E("Failed to reset step counter");
                return false;
            }
        }
        return enableFeature(BMA456H_STEP_COUNTER_EN, enable);
    }
 
    bool getStepCounterWatermark(uint16_t &step_counter_wm) const
    {
        return bma456h_step_counter_get_watermark(&step_counter_wm, dev.get()) == 0;
    }
 
    bool enableStepDetector(bool enable, bool interrupt_enable = false,
                            InterruptPinMap pin_map = InterruptPinMap::PIN1) override
    {
        if (!enableInterrupt(pin_map, BMA456H_STEP_CNTR_INT, interrupt_enable)) {
            return false;
        }
        return enableFeature(BMA456H_STEP_DETECTOR_EN, enable);
    }
 
    bool enableTapDetector(bool enable, bool interrupt_enable = false,
                           InterruptPinMap pin_map = InterruptPinMap::PIN1) override
    {
        if (!enableInterrupt(pin_map, BMA456H_TAP_OUT_INT, interrupt_enable)) {
            return false;
        }
        return enableFeature(BMA456H_SINGLE_TAP_EN | BMA456H_DOUBLE_TAP_EN | BMA456H_TRIPLE_TAP_EN, enable);
    }
 
    bool enableActivityRecognition(bool enable, bool interrupt_enable = false,
                                   InterruptPinMap pin_map = InterruptPinMap::PIN1) override
    {
        if (!enableInterrupt(pin_map, BMA456H_ACTIVITY_INT, interrupt_enable)) {
            return false;
        }
        return enableFeature(BMA456H_STEP_ACTIVITY_EN, enable);
    }
 
    bool enableAnyMotionDetection(const MotionAxesConfig &cfg, bool enable,
                                  bool interrupt_enable = false,
                                  InterruptPinMap pin_map = InterruptPinMap::PIN1) override
    {
        uint16_t interrupt_sources = 0;
        uint16_t feature = 0;
        if (cfg.x_axis) feature |= BMA456H_ANY_MOTION_X_AXIS_EN;
        if (cfg.y_axis) feature |= BMA456H_ANY_MOTION_Y_AXIS_EN;
        if (cfg.z_axis) feature |= BMA456H_ANY_MOTION_Z_AXIS_EN;
 
        if (cfg.x_axis || cfg.y_axis || cfg.z_axis) {
            interrupt_sources |= BMA456H_ANY_MOT_INT;
        }
 
        if (!enableInterrupt(pin_map, BMA456H_ANY_MOT_INT, interrupt_enable)) {
            return false;
        }
        return enableFeature(feature, enable);
    }
 
 
    bool enableNoMotionDetection(const MotionAxesConfig &cfg, bool enable,
                                 bool interrupt_enable = false,
                                 InterruptPinMap pin_map = InterruptPinMap::PIN1) override
    {
        uint16_t feature = 0;
        if (cfg.x_axis) feature |= BMA456H_NO_MOTION_X_AXIS_EN;
        if (cfg.y_axis) feature |= BMA456H_NO_MOTION_Y_AXIS_EN;
        if (cfg.z_axis) feature |= BMA456H_NO_MOTION_Z_AXIS_EN;
 
        if (!enableInterrupt(pin_map, BMA456H_NO_MOT_INT, interrupt_enable)) {
            return false;
        }
        return enableFeature(feature, enable);
    }
 
    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 bma456h_any_no_mot_config any_mot_config = {0, 0, 0, 0};
 
        if (any_motion) {
            rslt = bma456h_get_any_mot_config(&any_mot_config, dev.get());
            if (rslt != 0) {
                SENSORLIB_LOG_E("bma456h_an_get_any_mot_config failed");
                return false;
            }
        } else {
            rslt = bma456h_get_no_mot_config(&any_mot_config, dev.get());
            if (rslt != 0) {
                SENSORLIB_LOG_E("bma456h_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 (bma456h_set_any_mot_config(&any_mot_config, dev.get()) != 0) {
                SENSORLIB_LOG_E("Failed to configure any-motion detection");
                return false;
            }
        } else {
            if (bma456h_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 bma456h_any_no_mot_config any_mot_config;
        if (bma456h_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 bma456h_any_no_mot_config no_mot_config;
        if (bma456h_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;
    }
 
    uint32_t getStepCount()
    {
        uint32_t step_count = 0;
        if (bma456h_step_counter_output(&step_count, dev.get()) != 0) {
            SENSORLIB_LOG_E("Failed to read step count");
            return 0;
        }
        return step_count;
    }
 
    bool resetStepCounter()
    {
        return bma456h_reset_step_counter(dev.get()) == 0;
    }
 
    ActivityType getActivityType()
    {
        bma456h_out_state  activity_type = {0, 0, 0, 0};
        if (bma456h_output_state(&activity_type, dev.get()) != 0) {
            SENSORLIB_LOG_E("bma456h_get_activity_type failed");
            return ActivityType::UNKNOWN;
        }
        return static_cast<ActivityType>(activity_type.activity_type);
    }
 
    TapType getTapType()
    {
        bma456h_out_state tap_type = { 0, 0, 0, 0 };
        if (bma456h_output_state(&tap_type, dev.get()) != 0) {
            SENSORLIB_LOG_E("bma456h_get_tap_type failed");
            return TapType::NO_TAP;
        }
        if (tap_type.triple_tap) {
            return TapType::TRIPLE_TAP;
        } else if (tap_type.double_tap) {
            return TapType::DOUBLE_TAP;
        } else if (tap_type.single_tap) {
            return TapType::SINGLE_TAP;
        }
        return TapType::NO_TAP;
    }
 
    void update() override
    {
        if (bma4_read_int_status(&_status, dev.get()) != 0) {
            return;
        }
 
        if (_status == 0) {
            return;
        }
 
        if ((_status & BMA456H_TAP_OUT_INT) && callbacks.onTap) {
            callbacks.onTap(getTapType());
        }
 
        if ((_status & BMA456H_STEP_CNTR_INT) && callbacks.onStepDetected) {
            callbacks.onStepDetected();
            if (callbacks.onStepCount) {
                uint32_t step_count = 0;
                if (bma456h_step_counter_output(&step_count, dev.get()) == 0) {
                    callbacks.onStepCount(static_cast<uint32_t>(step_count));
                }
            }
        }
 
        if ((_status & BMA456H_ACTIVITY_INT) && callbacks.onActivity) {
            callbacks.onActivity(getActivityType());
        }
 
        if ((_status & BMA456H_ANY_MOT_INT) && callbacks.onAnyMotion) {
            callbacks.onAnyMotion();
        }
 
        if ((_status & BMA456H_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 = bma456h_init(dev.get());
        if ( rslt != 0 ) {
            SENSORLIB_LOG_E("bma456h_init failed with code %d", rslt);
            return false;
        }
        rslt = bma456h_write_config_file(dev.get());
        if (rslt != 0) {
            SENSORLIB_LOG_E("bma456h_write_config_file failed with code %d", rslt);
            return false;
        }
        return true;
    }
protected:
    EventCallbacks callbacks;
    uint16_t _status;
};
 
#endif