battery_soc_sensor.hpp

Go to the documentation of this file.

#ifndef BATTERY_SOC_SENSOR_HPP
#define BATTERY_SOC_SENSOR_HPP

#include <string>
#include <vector>
#include <memory>
#include <chrono>

#include "util/executor/executor.hpp"
#include "../sensor_impl.hpp"

namespace kallisto {
namespace hardware {

class BatterySocSensor : public SensorImpl, public bluetooth::BluetoothDispatcher::NotificationListener {
private:
    static const std::vector<unsigned char> IDENTIFIERS; //Holds the available instances identifiers
    static const std::vector<std::string> SERVICE_UUIDS; //Holds the service UUIDS that holds the sensor characteristics
    static const std::vector<std::string> DATA_CHAR_UUIDS; //Holds the data characteristic UUIDs
    static const unsigned char MANUFACTURER_DATA_TYPE; //Type used in manufacturer data to identify a sensor of this type

    //Constants to populate the sensor data
    static const std::string NAME;
    static const std::string VENDOR;
    static const std::string STRING_TYPE;
    static const float MAX_RANGE;
    static const float RESOLUTION;
    static const float POWER;
    static const std::chrono::microseconds MIN_DELAY;
    static const std::chrono::microseconds MAX_DELAY;

    InternalSensorEventListener m_listener; //Holder for the sensor callback
    kallisto::util::Executor m_executor{"BatterySoc", 1};
protected:
    BatterySocSensor(std::string name, std::string address, std::string vendor, unsigned int version, SensorType type, std::string string_type,
                             ReportingMode reporting_mode, unsigned int identifier, float max_range, float resolution, float power, std::chrono::microseconds min_delay,
                             std::chrono::microseconds max_delay, util::Executor& event_dispatcher, bluetooth::BluetoothDispatcher& bluetooth_dispatcher);

    error::KallistoDetailedResult start(std::map<std::string, const void*> parameters, InternalSensorEventListener internal_listener);

    error::KallistoDetailedResult update(std::map<std::string, const void*> parameters);

    std::map<std::string, const void*> getParameters();

    error::KallistoDetailedResult stop(bool link_loss);

    void onNotification(std::string address, std::string service_uuid, std::string characteristic_uuid, const std::vector<unsigned char>& values);

public:
    ~BatterySocSensor();

    BatterySocSensor(BatterySocSensor const&) = delete;

    void operator=(BatterySocSensor const&) = delete;

    static bool isAvailable(unsigned int identifier, const std::map<uint16_t, std::vector<uint8_t> >& manufacturer_data);

    static bool isAvailable(unsigned int identifier, bluetooth::BluetoothDispatcher& bluetooth_dispatcher);

    static std::vector<std::unique_ptr<SensorImpl> > build(std::string address, util::Executor& event_dispatcher,
                                                           bluetooth::BluetoothDispatcher& bluetooth_dispatcher,
                                                           const std::map<uint16_t, std::vector<uint8_t> >& manufacturer_data);
};

} /* namespace hardware */
} /* namespace kallisto */

#endif // BATTERY_SOC_HPP