IrSignal.h

Go to the documentation of this file.

#pragma once
 
#include "InfraredTypes.h"
#include "IrSequence.h"
#include "version.h"
 
class IrSignal {
public:
    static constexpr frequency_t defaultFrequency = 38000U;
    static constexpr frequency_t invalidFrequency = static_cast<frequency_t>(-1);
    static constexpr dutycycle_t noDutyCycle = static_cast<dutycycle_t>(-1);
    static constexpr dutycycle_t defaultDutyCycle = noDutyCycle;
    static constexpr const char *version = VERSION;
 
private:
    // Maintainer note: the members being const prohibits assignment operators.
    // Alternatively, the members can be made non-const and assignments allowed.
    const frequency_t frequency = defaultFrequency;
    const dutycycle_t dutyCycle = defaultDutyCycle;
    const IrSequence intro;
    const IrSequence repeat;
    const IrSequence ending;
 
public:
    IrSignal() {};
    IrSignal(const IrSignal& orig) = default;
    IrSignal(IrSignal&& orig) = default;
    IrSignal& operator=(const IrSignal& rhs) = default;
    IrSignal& operator=(IrSignal&& rhs) = default;
 
    virtual ~IrSignal() = default;
 
    IrSignal(const microseconds_t *intro, size_t lengthIntro,
            const microseconds_t *repeat, size_t lengthRepeat,
            const microseconds_t *ending, size_t lengthEnding,
            frequency_t frequency = defaultFrequency,
            dutycycle_t dutyCycle = defaultDutyCycle);
 
    IrSignal(const microseconds_t *intro, size_t lengthIntro,
            const microseconds_t *repeat, size_t lengthRepeat,
            frequency_t frequency = defaultFrequency,
            dutycycle_t dutyCycle = defaultDutyCycle);
 
    IrSignal(const IrSequence& intro, const IrSequence& repeat, const IrSequence& ending,
            frequency_t frequency = defaultFrequency, dutycycle_t dutyCycle = defaultDutyCycle);
 
    IrSignal(IrSequence&& intro, IrSequence&& repeat, IrSequence&& ending,
            frequency_t frequency = defaultFrequency, dutycycle_t dutyCycle = defaultDutyCycle);
 
    IrSignal(const IrSequence& intro, const IrSequence& repeat,
            frequency_t frequency = defaultFrequency, dutycycle_t dutyCycle = defaultDutyCycle);
 
    IrSignal(IrSequence&& intro, IrSequence&& repeat,
            frequency_t frequency = defaultFrequency, dutycycle_t dutyCycle = defaultDutyCycle);
 
    static IrSignal* readFlash(const microseconds_t *intro, size_t lengthIntro,
            const microseconds_t *repeat, size_t lengthRepeat,
            const microseconds_t *ending, size_t lengthEnding,
            frequency_t frequency = defaultFrequency,
            dutycycle_t dutyCycle = defaultDutyCycle);
 
    static IrSignal* readFlash(const microseconds_t *intro, size_t lengthIntro,
            const microseconds_t *repeat, size_t lengthRepeat,
            frequency_t frequency = defaultFrequency,
            dutycycle_t dutyCycle = defaultDutyCycle);
 
    frequency_t getFrequency() const {
        return frequency;
    }
 
    dutycycle_t getDutyCycle() const {
        return dutyCycle;
    }
 
    const IrSequence& getEnding() const {
        return ending;
    }
 
    const IrSequence& getRepeat() const {
        return repeat;
    }
 
    const IrSequence& getIntro() const {
        return intro;
    }
 
    operator bool() const { return intro || repeat || ending; }
 
    void dump(Stream& stream, bool usingSigns = false) const;
 
    void dumpWithSigns(Stream& stream) const {
        dump(stream, true);
    };
 
    bool dumpFrequency(Stream& stream) const {
        return dumpFrequency(stream, frequency);
    };
 
    static bool dumpFrequency(Stream& stream, frequency_t frequency);
 
    bool dumpDutyCycle(Stream& stream) const {
        return dumpDutyCycle(stream, dutyCycle);
    }
 
    static bool dumpDutyCycle(Stream& stream, dutycycle_t dutyCycle);
 
    unsigned int noRepetitions(unsigned int noSends) const {
        return noSends == 0 ? 0
                : intro ? noSends -1 : noSends;
    }
};