Sensor.hpp

Go to the documentation of this file.

/*
 * This file is part of the DUDS project. It is subject to the BSD-style
 * license terms in the LICENSE file found in the top-level directory of this
 * distribution and at https://github.com/jjackowski/duds/blob/master/LICENSE.
 * No part of DUDS, including this file, may be copied, modified, propagated,
 * or distributed except according to the terms contained in the LICENSE file.
 *
 * Copyright (C) 2024  Jeff Jackowski
 */
#ifndef SENSOR_HPP
#define SENSOR_HPP

#include <duds/Something.hpp>
#include <duds/data/Measurement.hpp>

namespace duds { namespace hardware { namespace devices {

template<class SVT, class SQT, class TVT, class TQT>
class GenericDevice;

/*
Consider conversion of voltage to another unit.
Make function that can return Unit used in a GenericValue, or a Measurement
    containing a GenericValue.
*/

template<class SVT, class SQT, class TVT, class TQT>
class GenericSensor : public Something {
    friend class GenericDevice<SVT, SQT, TVT, TQT>;
public:
    typedef GenericDevice<SVT, SQT, TVT, TQT>  Device;
    typedef std::shared_ptr<Device>  DeviceSptr;
    typedef std::weak_ptr<Device>  DeviceWptr;
    typedef duds::data::GenericMeasurement<SVT, SQT, TVT, TQT>  Measurement;
    typedef std::shared_ptr<Measurement>  MeasurementSptr;
    typedef std::shared_ptr<const Measurement>  ConstMeasurementSptr;
private:
    Device *dev;
    ConstMeasurementSptr meas;
    unsigned int idx;
protected:
    struct Token { };
public:
    GenericSensor(Device *pdev, Token) : dev(pdev) { }
    GenericSensor(
        Device *pdev,
        const boost::uuids::uuid &id,
        unsigned int i,
        Token
    ) : Something(id), dev(pdev), idx(i) { }
    static std::shared_ptr< GenericSensor <SVT, SQT, TVT, TQT> > make(
        Device *pdev
    ) {
        return std::make_shared< GenericSensor <SVT, SQT, TVT, TQT> >(
            pdev, Token()
        );
    }
    static std::shared_ptr< GenericSensor <SVT, SQT, TVT, TQT> > make(
        Device *pdev,
        const boost::uuids::uuid &id,
        unsigned int i
    ) {
        return std::make_shared< GenericSensor <SVT, SQT, TVT, TQT> >(
            pdev, id, i, Token()
        );
    }
    unsigned int index() const {
        return idx;
    }
    DeviceSptr device() const {
        Device *d = dev;
        if (d) {
            return d->sharedPtr();
        }
        return DeviceSptr();
    }
    ConstMeasurementSptr &measurement() const {
        return meas;
    }
};

typedef GenericSensor<
    duds::data::GenericValue,
    double,
    duds::time::interstellar::NanoTime,
    float
> Sensor;

typedef std::shared_ptr<Sensor>  SensorSptr;
typedef std::weak_ptr<Sensor>  SensorWptr;

} } }

#endif        //  #ifndef SENSOR_HPP