PwmReader.h

Go to the documentation of this file.

/****
 * PwmReader.h
 *
 * Copyright 2021 mikee47 <mike@sillyhouse.net>
 *
 * This file is part of the Sming-MHZ19 Library
 *
 * This library 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, version 3 or later.
 *
 * This library 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 library.
 * If not, see <https://www.gnu.org/licenses/>.
 *
 ****/

#pragma once

#include "common.h"
#include <cstdint>
#include <esp_attr.h>
#include <Delegate.h>
#include <muldiv.h>

namespace MHZ19
{
class PwmReader
{
public:
    // Ignore measurements with cycle times outside (CYCLE_MS +/- TOLERANCE)
    static constexpr uint16_t CYCLE_MS{1004};
    static constexpr uint16_t CYCLE_TOLERANCE{250};

    using Callback = Delegate<void(uint16_t ppm)>;

    union Pulse {
        struct {
            uint16_t low;
            uint16_t high;
        };
        uint32_t value;

        uint16_t getCycleTime() const
        {
            return low + high;
        }

        bool isValid() const
        {
            auto cycleTime = getCycleTime();
            return low > 2 && high > 2 && cycleTime >= (CYCLE_MS - CYCLE_TOLERANCE) &&
                   cycleTime <= (CYCLE_MS + CYCLE_TOLERANCE);
        }

        uint16_t calculatePpm(DetectionRange range)
        {
            return isValid() ? muldiv(high, uint16_t(range), getCycleTime()) : 0;
        }
    };

    ~PwmReader()
    {
        end();
    }

    void begin(uint8_t pin, DetectionRange range);

    void end();

    uint16_t getMeasurement() const;

    void setCallback(Callback callback)
    {
        this->callback = callback;
    }

    bool suspend();

    bool resume();

private:
    enum class State {
        disabled,
        enabled,
        suspended,
    };

    static void IRAM_ATTR staticInterruptHandler()
    {
        return self->interruptHandler();
    }

    void interruptHandler();

    static void staticCallback(uint32_t value);

    static PwmReader* self;
    uint32_t isrTicks{0};
    Pulse isrPulse{};
    volatile Pulse reading{};
    Callback callback;
    DetectionRange range;
    uint8_t pin;
    State state{State::disabled};
};

unsigned pwmRead(uint8_t pwmPin, DetectionRange range);

} // namespace MHZ19