Sensor.h

Go to the documentation of this file.

/* Copyright (c) 2016-2020 Skyward Experimental Rocketry
 * Authors: Alain Carlucci, Luca Conterio, Davide Mor, Emilio Corigliano
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 */
 
#pragma once
 
#include <miosix.h>
 
#include <array>
#include <memory>
#include <type_traits>
 
#include "SensorData.h"
 
namespace Boardcore
{
 
template <class T, class ExpectedDataType>
struct checkIfProduces
    : std::is_base_of<ExpectedDataType,
                      typename std::remove_reference<
                          decltype(std::declval<T>().getLastSample())>::type>
{
};
 
class AbstractSensor
{
protected:
    SensorErrors lastError = SensorErrors::NO_ERRORS;
 
public:
    virtual ~AbstractSensor() {}
 
    virtual bool init() = 0;
 
    virtual bool selfTest() = 0;
 
    virtual void sample() = 0;
 
    SensorErrors getLastError() { return lastError; };
};
 
template <typename Data>
class Sensor : public virtual AbstractSensor
{
public:
    using DataType = Data;
 
protected:
    DataType lastSample;
 
    virtual DataType sampleImpl() = 0;
 
    // Thread safe mutex to synchronize writes and reads
    miosix::FastMutex mutex;
 
public:
    Sensor() {}
 
    Sensor(Sensor&& other) : lastSample{std::move(other.lastSample)}, mutex{} {}
 
    virtual ~Sensor() {}
 
    void sample() override
    {
        // Sampling outside of the protected zone ensures that the sampling
        // action cannot cause locks or delays
        DataType d = sampleImpl();
 
        {
            miosix::Lock<miosix::FastMutex> l(mutex);
            lastSample = d;
        }
    }
 
    virtual Data getLastSample()
    {
        miosix::Lock<miosix::FastMutex> l(mutex);
        return lastSample;
    }
};
 
template <typename Data, uint32_t FifoSize>
class SensorFIFO : public Sensor<Data>
{
    using Super = Sensor<Data>;
 
protected:
    std::array<Data, FifoSize> lastFifo;
    uint16_t lastFifoLevel          = 1;  //< number of samples in lastFifo
    uint64_t lastInterruptTimestamp = 0;
    uint64_t interruptTimestampDelta =
        0;  //< delta between previous interrupt
            // timestamp and the last received one
 
public:
    SensorFIFO() {}
 
    SensorFIFO(SensorFIFO&& other)
        : lastFifo{std::move(other.lastFifo)},
          lastFifoLevel{std::move(other.lastFifoLevel)},
          lastInterruptTimestamp{std::move(other.lastInterruptTimestamp)},
          interruptTimestampDelta{std::move(other.interruptTimestampDelta)}
    {
    }
 
    const std::array<Data, FifoSize> getLastFifo(uint16_t& lastFifoSize)
    {
        miosix::Lock<miosix::FastMutex> l(Super::mutex);
        lastFifoSize = lastFifoLevel;
        return lastFifo;
    }
 
    inline virtual void IRQupdateTimestamp(uint64_t ts)
    {
        interruptTimestampDelta = ts - lastInterruptTimestamp;
        lastInterruptTimestamp  = ts;
    }
};
 
}  // namespace Boardcore