sensorconverter.h

Go to the documentation of this file.

 
#ifndef SEMF_INPUT_SENSOR_SENSORCONVERTER_H_
#define SEMF_INPUT_SENSOR_SENSORCONVERTER_H_
 
#include <semf/app/input/sensor/sensor.h>
#include <semf/input/sensor/hardwaresensor.h>
#include <semf/utils/core/signals/slot.h>
#include <semf/utils/processing/average.h>
 
namespace semf
{
template <typename T_RAW, typename T_CONVERTED>
class SensorConverter : public app::Sensor<T_CONVERTED>
{
public:
    SensorConverter(HardwareSensor<T_RAW>& hardwareSensor, size_t index);
    virtual ~SensorConverter() = default;
 
protected:
    virtual T_CONVERTED convert(T_RAW value) const = 0;
 
private:
    void onDataAvailable(size_t index);
    void update();
    T_CONVERTED currentValue() const override;
    T_CONVERTED averageValue() const override;
 
    HardwareSensor<T_RAW>& m_hardwareSensor;
    size_t m_index;
    SEMF_SLOT(m_onDataAvailableSlot, SensorConverter, *this, onDataAvailable, size_t);
};
 
template <typename T_RAW, typename T_CONVERTED>
SensorConverter<T_RAW, T_CONVERTED>::SensorConverter(HardwareSensor<T_RAW>& hardwareSensor, size_t index)
: m_hardwareSensor(hardwareSensor),
  m_index(index)
 
{
    m_hardwareSensor.dataAvailable.connect(m_onDataAvailableSlot);
}
 
template <typename T_RAW, typename T_CONVERTED>
void SensorConverter<T_RAW, T_CONVERTED>::onDataAvailable(size_t index)
{
    if (index == m_index)
        app::Sensor<T_CONVERTED>::dataAvailable();
}
 
template <typename T_RAW, typename T_CONVERTED>
void SensorConverter<T_RAW, T_CONVERTED>::update()
{
    m_hardwareSensor.update();
}
 
template <typename T_RAW, typename T_CONVERTED>
T_CONVERTED SensorConverter<T_RAW, T_CONVERTED>::currentValue() const
{
    return convert(m_hardwareSensor.buffer(m_index)[0]);
}
 
template <typename T_RAW, typename T_CONVERTED>
T_CONVERTED SensorConverter<T_RAW, T_CONVERTED>::averageValue() const
{
    return convert(Average<T_RAW>::value(m_hardwareSensor.buffer(m_index)));
}
} /* namespace semf */
#endif /* SEMF_INPUT_SENSOR_SENSORCONVERTER_H_ */