Pronto.h

Go to the documentation of this file.

 
// Maintainer note:
// Make sure that this class does not use floating point arithmetics.
 
#pragma once
 
#include "InfraredTypes.h"
#include "IrSignal.h"
#include "Board.h"
 
class Pronto {
public:
    static constexpr unsigned int digitsInProntoNumber      = 4U;
    static constexpr unsigned int numbersInPreamble         = 4U;
 
private:
    static constexpr unsigned int bitsInHexadecimal         = 4U;
    static constexpr unsigned int hexMask                   = 0xFU;
    static constexpr uint16_t learnedToken                  = 0x0000U;
    static constexpr uint16_t learnedNonModulatedToken      = 0x0100U;
    static constexpr uint32_t referenceFrequency            = 4145146UL;
    static constexpr uint16_t fallbackFrequencyCode         = 0x0040U; // To use with frequency = 0;
    static constexpr frequency_t fallbackFrequency          = 64767U; // To use with frequency = 0;
    static constexpr uint32_t microsecondsInSeconds         = 1000000UL;
 
    Pronto() = delete;
 
    static microseconds_t* mkSequence(const uint16_t *data, size_t pairs, microseconds_t timebase);
 
    static frequency_t toFrequency(uint16_t code);
 
    static uint16_t toFrequencyCode(frequency_t frequency);
 
    static frequency_t effectiveFrequency(frequency_t frequency);
 
    static microseconds_t toTimebase(frequency_t frequency_t);
 
    static size_t lengthHexString(size_t introLength, size_t repeatLength);
 
    static char* prelude(frequency_t frequency, size_t introLength, size_t repeatLength);
 
    static char hexDigit(unsigned int x);
 
    static void appendChar(char *result, unsigned int& index, char ch);
 
    static void appendDuration(char *result, unsigned int& index, uint16_t duration, microseconds_t timebase);
 
    static void appendDigit(char *result, unsigned int& index, unsigned int number);
 
    static void appendNumber(char *result, unsigned int& index, uint16_t number);
 
    static void appendSequence(char *result, unsigned int& index, const microseconds_t *data, size_t length, microseconds_t timebase);
 
    static void appendSequence(char *result, unsigned int& index, const IrSequence& irSequence, microseconds_t timebase);
 
    static void dumpSequence(Stream& stream, const microseconds_t *data, size_t length, microseconds_t timebase);
 
    static void dumpDuration(Stream& stream, microseconds_t duration, microseconds_t timebase);
 
    static void dumpNumber(Stream& stream, uint16_t number);
 
    static void dumpDigit(Stream& stream, unsigned int number);
 
public:
    static IrSignal *parse(const uint16_t *data, size_t size);
 
    static IrSignal *parse(const char *str);
 
#if HAS_FLASH_READ || defined(DOXYGEN)
    static IrSignal *parse_PF(const uint_farptr_t str);
 
    static IrSignal *parse_PF(const char * ptr);
 
    static IrSignal *parse(const __FlashStringHelper *str);
#endif
 
    static char* toProntoHex(const IrSignal& irSignal) {
        return toProntoHex(irSignal.getIntro(), irSignal.getRepeat(), irSignal.getFrequency());
    }
 
    static char* toProntoHex(const IrSequence& introSequence, const IrSequence& repeatSequence = IrSequence::emptyInstance, frequency_t frequency = IrSignal::defaultFrequency) {
        return toProntoHex(introSequence.getDurations(), introSequence.getLength(), repeatSequence.getDurations(), repeatSequence.getLength(), frequency);
    }
 
    static char* toProntoHex(const microseconds_t* introData, size_t introLength, frequency_t frequency = IrSignal::defaultFrequency) {
        return toProntoHex(introData, introLength, nullptr, 0, frequency);
    }
 
    static char* toProntoHex(const microseconds_t* introData, size_t introLength, const microseconds_t* repeatData = nullptr, size_t repeatLength = 0, frequency_t frequency = IrSignal::defaultFrequency);
 
    static void dump(Stream& stream, const IrSignal& irSignal) {
        return dump(stream, irSignal.getIntro(), irSignal.getRepeat(), irSignal.getFrequency());
    }
 
    static void dump(Stream& stream, const IrSequence& introSequence, const IrSequence& repeatSequence = IrSequence::emptyInstance, frequency_t frequency = IrSignal::defaultFrequency) {
        return dump(stream, introSequence.getDurations(), introSequence.getLength(), repeatSequence.getDurations(), repeatSequence.getLength(), frequency);
    }
 
    static void dump(Stream& stream, const microseconds_t* introData, size_t introLength, const microseconds_t* repeatData = nullptr, size_t repeatLength = 0, frequency_t frequency = IrSignal::defaultFrequency);
};