demodulator.h

Go to the documentation of this file.

/*
 * atMETEO - An ATmega based weather station
 * Copyright (C) 2014-2015 Christian Fetzer
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License along
 * with this program; if not, write to the Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 */

#pragma once

#include "utils.h"

namespace Sensors
{

enum class DemodulatorStatus : uint8_t {
    Complete = 0,

    Incomplete,

    OutOfRangeError
};

template <uint16_t TShortMin, uint16_t TShortMax,
          uint16_t TLongMin, uint16_t TLongMax>
struct BiphaseMark
{
    static_assert(TShortMin <= TShortMax,
                  "TShortMax must be less or equal than TShortMax");
    static_assert(TShortMax <= TLongMin,
                  "TShortMax must be less or equal than TLongMin");
    static_assert(TLongMin <= TLongMax,
                  "TLongMin must be less or equal than TLongMax");
};

template <typename Demodulator>
class DemodulatorBase
{
public:
    DemodulatorStatus addPulseWidth(uint16_t pulseWidth)
    {
        return static_cast<Demodulator *>(this)->internalAddPulseWidth(
                    pulseWidth);
    }

    bool getData() const
    {
        return m_data;
    }

    void reset()
    {
        m_data = false;
        return static_cast<Demodulator *>(this)->internalReset();
    }

protected:
    DemodulatorBase()
    {
        reset();
    }

    bool m_data;
};

template <typename TDemodulatorType>
class Demodulator;

template <
        uint16_t TShortMin, uint16_t TShortMax,
        uint16_t TLongMin, uint16_t TLongMax>
class Demodulator<BiphaseMark<TShortMin, TShortMax, TLongMin, TLongMax>>
        : public DemodulatorBase<Demodulator<
                        BiphaseMark<TShortMin, TShortMax, TLongMin, TLongMax>>>
{
    friend class DemodulatorBase<Demodulator<BiphaseMark<
                                    TShortMin, TShortMax, TLongMin, TLongMax>>>;

    DemodulatorStatus internalAddPulseWidth(uint16_t pulseWidth)
    {
        auto result = DemodulatorStatus::OutOfRangeError;

        // Long pulse
        if (isLong(pulseWidth)) {
            m_expectShort = false;  // Ignore single short pulse
            this->m_data = true;
            result = DemodulatorStatus::Complete;
        }

        // Short pulse
        else if (isShort(pulseWidth)) {

            // First short
            if (!m_expectShort) {
                m_expectShort = true;
                result = DemodulatorStatus::Incomplete;
            }

            // Second short
            else {
                m_expectShort = false;
                this->m_data = false;
                result = DemodulatorStatus::Complete;
            }
        }

        return result;
    }

    void internalReset()
    {
        m_expectShort = false;
    }

private:
    static bool isLong(uint16_t value)
    {
        return (value >= TLongMin && value < TLongMax);
    }

    static bool isShort(uint16_t value)
    {
        return (value >= TShortMin && value < TShortMax);
    }

    // For BMC, the bit value 0 is represented by two continuous short pulses.
    bool m_expectShort;
};
  // \addtogroup libsensors_demodulator

}  // namespace Sensors