8 double timebase = prontoFreqConst * data[1];
12 frequency = toFrequency(data[1]);
14 case learnedNonModulatedToken:
20 size_t introPairs = data[2];
21 size_t repetitionPairs = data[3];
22 if (numbersInPreamble + 2*(introPairs + repetitionPairs) != size)
25 IrSequence *intro = mkSequence(data + numbersInPreamble, introPairs, timebase);
26 IrSequence *repeat = mkSequence(data + numbersInPreamble + 2*introPairs, repetitionPairs, timebase);
39 size_t len = strlen(str)/(digitsInProntoNumber + 1) + 1;
41 unsigned int index = 0;
43 char *endptr[1] = { NULL };
45 long x = strtol(p, endptr, 16);
46 data[index++] = (uint16_t) x;
49 return parse(data, index);
52 #if defined(ARDUINO) & defined(ARDUINO_ARCH_AVR) 55 size_t length = strlen_PF((uint_farptr_t)str);
56 char copy[length + 1];
57 strcpy_PF(copy, (uint_farptr_t)str);
62 IrSequence *Pronto::mkSequence(
const uint16_t* data,
size_t noPairs,
double timebase) {
64 for (
unsigned int i = 0; i < 2*noPairs; i++) {
65 uint32_t duration = (uint32_t) (data[i] * timebase);
68 return new IrSequence(durations, 2*noPairs,
false);
75 Pronto::prontoInt Pronto::toFrequencyCode(
frequency_t frequency) {
76 return (prontoInt) (prontoConst / frequency);
79 size_t Pronto::lengthHexString(
size_t introLength,
size_t repeatLength) {
80 return (digitsInProntoNumber + 1) * (numbersInPreamble + introLength + repeatLength);
83 char Pronto::hexDigit(
unsigned int x) {
84 return (
char) (x <= 9 ? (
'0' + x) : (
'A' + (x - 10)));
87 unsigned int Pronto::appendChar(
char *result,
unsigned int index,
char ch) {
93 unsigned int Pronto::appendDigit(
char *result,
unsigned int index,
unsigned int number) {
94 return appendChar(result, index, hexDigit(number));
97 unsigned int Pronto::appendNumber(
char *result,
unsigned int index, prontoInt number) {
98 for (
unsigned int i = 0; i < digitsInProntoNumber; i++) {
99 unsigned int shifts = bitsInHexadecimal * (digitsInProntoNumber - 1 - i);
100 index = appendDigit(result, index, (number >> shifts) & hexMask);
102 return appendChar(result, index,
' ');
106 return appendNumber(result, index, (
unsigned int)(1E-6 * duration * frequency + 0.5));
109 unsigned int Pronto::appendSequence(
char *result,
unsigned int index,
const microseconds_t *data,
size_t length,
frequency_t frequency) {
110 frequency_t effectiveFrequency = frequency > 0 ? frequency : fallbackFrequency;
111 for (
unsigned int i = 0; i < length; i++)
112 index = appendDuration(result, index, data[i], effectiveFrequency);
116 unsigned int Pronto::appendSequence(
char *result,
unsigned int index,
const IrSequence& irSequence,
frequency_t frequency) {
120 char* Pronto::setup(
frequency_t frequency,
size_t introLength,
size_t repeatLength) {
121 char *result =
new char[lengthHexString(introLength, repeatLength)];
122 unsigned int index = 0;
123 index = appendNumber(result, index, frequency > 0 ? learnedToken : learnedNonModulatedToken);
124 index = appendNumber(result, index, toFrequencyCode(frequency));
125 index = appendNumber(result, index, introLength / 2);
126 index = appendNumber(result, index, repeatLength / 2);
131 char *result = setup(frequency, length, 0);
132 unsigned int index = charsInPreamble;
133 index = appendSequence(result, index, data, length, frequency);
134 appendChar(result, index - 1,
'\0');
144 unsigned int index = charsInPreamble;
147 appendChar(result, index - 1,
'\0');
uint16_t microseconds_t
Type for durations in micro seconds.
uint32_t frequency_t
Type for modulation frequency in Hz.
#define MICROSECONDS_T_MAX
Largest microseconds_t number possible.
const microseconds_t * getDurations() const
frequency_t getFrequency() const
const IrSequence & getIntro() const
This class models an IR signal with intro-, repeat-, and ending sequences.
size_t getLength() const
Returns the length of the data.
static IrSignal * parse(const uint16_t *data, size_t size)
Function for parsing its input data into an IrSignal.
const IrSequence & getRepeat() const
This class consists of a vector of durations.
static char * toProntoHex(const IrSignal &irSignal)
Function for generating a Pronto Hex string from the argument.