Skip to content

Instantly share code, notes, and snippets.

/WORLD_IR_CODES.h

Created February 20, 2018 19:23
Show Gist options
  • Star 0 You must be signed in to star a gist
  • Fork 0 You must be signed in to fork a gist
  • Save anonymous/8c24f625cf802f58e0b2102dc8a6a0de to your computer and use it in GitHub Desktop.
Save anonymous/8c24f625cf802f58e0b2102dc8a6a0de to your computer and use it in GitHub Desktop.
Download ZIP
Arduino TV-B-Gone sourcecode
Raw
main.h
/*
Last Updated: 22 Oct. 2016
By Gabriel Staples, http://www.ElectricRCAircraftGuy.com
-My contact info is available by clicking the "Contact Me" tab at the top of my website.
*/
#include <avr/pgmspace.h>
// The TV-B-Gone for Arduino can use either the EU (European Union) or the NA (North America) database of POWER CODES
// EU is for Europe, Middle East, Australia, New Zealand, and some countries in Africa and South America
// NA is for North America, Asia, and the rest of the world not covered by EU
// Two regions!
#define NA 1 //set by a HIGH on REGIONSWITCH pin
#define EU 0 //set by a LOW on REGIONSWITCH pin
// What pins do what
#define LED LED_BUILTIN //LED indicator pin (usually 13)
#define IRLED 3 //the IR sender LED
#define TRIGGER 2 //the button pin; NB: this pin is "hard-coded" in the sleepNow() function in the primary .ino file by means of using external interrupt 0, which is hard-wired to pin 2
#define REGIONSWITCH 5 //HIGH (1) = NA, LOW (0) = EU; Pin 5 (REGIONSWITCH) is HIGH (via in input pullup resistor) for North America, or you (the user) must wire it to ground to set the codes for Europe.
// Lets us calculate the size of the NA/EU databases
#define NUM_ELEM(x) (sizeof (x) / sizeof (*(x)));
// set define to 0 to turn off debug output
#define DEBUG 0
#define DEBUGP(x) if (DEBUG == 1) { x ; }
// Shortcut to insert single, non-optimized-out nop
#define NOP __asm__ __volatile__ ("nop")
// Tweak this if neccessary to change timing
// -for 8MHz Arduinos, a good starting value is 11
// -for 16MHz Arduinos, a good starting value is 25
#define DELAY_CNT 25
// Makes the codes more readable. the OCRA is actually
// programmed in terms of 'periods' not 'freqs' - that
// is, the inverse!
#define freq_to_timerval(x) (F_CPU / 8 / x - 1)
// The structure of compressed code entries
struct IrCode {
uint8_t timer_val;
uint8_t numpairs;
uint8_t bitcompression;
uint16_t const *times;
uint8_t const *codes;
};
Raw
tvbgone.ino
#include "WORLD_IR_CODES.h"
#include <avr/sleep.h>
void xmitCodeElement(uint16_t ontime, uint16_t offtime, uint8_t PWM_code );
void quickflashLEDx( uint8_t x );
void delay_ten_us(uint16_t us);
void quickflashLED( void );
uint8_t read_bits(uint8_t count);
#define putstring_nl(s) Serial.println(s)
#define putstring(s) Serial.print(s)
#define putnum_ud(n) Serial.print(n, DEC)
#define putnum_uh(n) Serial.print(n, HEX)
#define MAX_WAIT_TIME 65535 //tens of us (ie: 655.350ms)
extern const IrCode* const NApowerCodes[] PROGMEM;
extern const IrCode* const EUpowerCodes[] PROGMEM;
extern uint8_t num_NAcodes, num_EUcodes;
void xmitCodeElement(uint16_t ontime, uint16_t offtime, uint8_t PWM_code )
{
TCNT2 = 0;
if(PWM_code) {
pinMode(IRLED, OUTPUT);
// Fast PWM, setting top limit, divide by 8
// Output to pin 3
TCCR2A = _BV(COM2A0) | _BV(COM2B1) | _BV(WGM21) | _BV(WGM20);
TCCR2B = _BV(WGM22) | _BV(CS21);
}
else {
digitalWrite(IRLED, HIGH);
}
delay_ten_us(ontime);
TCCR2A = 0;
TCCR2B = 0;
digitalWrite(IRLED, LOW);
delay_ten_us(offtime);
}
uint8_t bitsleft_r = 0;
uint8_t bits_r=0;
PGM_P code_ptr;
// we cant read more than 8 bits at a time so dont try!
uint8_t read_bits(uint8_t count)
{
uint8_t i;
uint8_t tmp=0;
// we need to read back count bytes
for (i=0; i<count; i++) {
// check if the 8-bit buffer we have has run out
if (bitsleft_r == 0) {
// in which case we read a new byte in
bits_r = pgm_read_byte(code_ptr++);
// and reset the buffer size (8 bites in a byte)
bitsleft_r = 8;
}
// remove one bit
bitsleft_r--;
// and shift it off of the end of 'bits_r'
tmp |= (((bits_r >> (bitsleft_r)) & 1) << (count-1-i));
}
// return the selected bits in the LSB part of tmp
return tmp;
}
#define BUTTON_PRESSED 0
uint16_t ontime, offtime;
uint8_t i,num_codes;
uint8_t region;
void setup()
{
Serial.begin(9600);
TCCR2A = 0;
TCCR2B = 0;
digitalWrite(LED, LOW);
digitalWrite(IRLED, LOW);
pinMode(LED, OUTPUT);
pinMode(IRLED, OUTPUT);
pinMode(REGIONSWITCH, INPUT_PULLUP);
pinMode(TRIGGER, INPUT_PULLUP);
delay_ten_us(5000); //50ms (5000x10 us) delay: let everything settle for a bit
region = EU;
DEBUGP(putstring_nl("EU"));
// Debug output: indicate how big our database is
DEBUGP(putstring("\n\rNA Codesize: ");
putnum_ud(num_NAcodes);
);
DEBUGP(putstring("\n\rEU Codesize: ");
putnum_ud(num_EUcodes);
);
// Tell the user what region we're in - 3 flashes is NA, 6 is EU
if (region == NA)
quickflashLEDx(3);
else //region == EU
quickflashLEDx(6);
}
void sendAllCodes()
{
bool endingEarly = false; //will be set to true if the user presses the button during code-sending
// determine region from REGIONSWITCH: 1 = NA, 0 = EU (defined in main.h)
region = EU;
num_codes = num_EUcodes;
// for every POWER code in our collection
for (i=0 ; i<num_codes; i++)
{
PGM_P data_ptr;
// print out the code # we are about to transmit
DEBUGP(putstring("\n\r\n\rCode #: ");
putnum_ud(i));
// point to next POWER code, from the right database
if (region == NA) {
data_ptr = (PGM_P)pgm_read_word(NApowerCodes+i);
}
else {
data_ptr = (PGM_P)pgm_read_word(EUpowerCodes+i);
}
// print out the address in ROM memory we're reading
DEBUGP(putstring("\n\rAddr: ");
putnum_uh((uint16_t)data_ptr));
// Read the carrier frequency from the first byte of code structure
const uint8_t freq = pgm_read_byte(data_ptr++);
// set OCR for Timer1 to output this POWER code's carrier frequency
OCR2A = freq;
OCR2B = freq / 3; // 33% duty cycle
// Print out the frequency of the carrier and the PWM settings
DEBUGP(putstring("\n\rOCR1: ");
putnum_ud(freq);
);
DEBUGP(uint16_t x = (freq+1) * 2;
putstring("\n\rFreq: ");
putnum_ud(F_CPU/x);
);
// Get the number of pairs, the second byte from the code struct
const uint8_t numpairs = pgm_read_byte(data_ptr++);
DEBUGP(putstring("\n\rOn/off pairs: ");
putnum_ud(numpairs));
// Get the number of bits we use to index into the timer table
// This is the third byte of the structure
const uint8_t bitcompression = pgm_read_byte(data_ptr++);
DEBUGP(putstring("\n\rCompression: ");
putnum_ud(bitcompression);
putstring("\n\r"));
// Get pointer (address in memory) to pulse-times table
// The address is 16-bits (2 byte, 1 word)
PGM_P time_ptr = (PGM_P)pgm_read_word(data_ptr);
data_ptr+=2;
code_ptr = (PGM_P)pgm_read_word(data_ptr);
// Transmit all codeElements for this POWER code
// (a codeElement is an onTime and an offTime)
// transmitting onTime means pulsing the IR emitters at the carrier
// frequency for the length of time specified in onTime
// transmitting offTime means no output from the IR emitters for the
// length of time specified in offTime
//DEVELOPMENTAL TESTING:
#if 0
// print out all of the pulse pairs
for (uint8_t k=0; k<numpairs; k++) {
uint8_t ti;
ti = (read_bits(bitcompression)) * 4;
// read the onTime and offTime from the program memory
ontime = pgm_read_word(time_ptr+ti);
offtime = pgm_read_word(time_ptr+ti+2);
DEBUGP(putstring("\n\rti = ");
putnum_ud(ti>>2);
putstring("\tPair = ");
putnum_ud(ontime));
DEBUGP(putstring("\t");
putnum_ud(offtime));
}
continue;
#endif
// For EACH pair in this code....
cli();
for (uint8_t k=0; k<numpairs; k++) {
uint16_t ti;
// Read the next 'n' bits as indicated by the compression variable
// The multiply by 4 because there are 2 timing numbers per pair
// and each timing number is one word long, so 4 bytes total!
ti = (read_bits(bitcompression)) * 4;
// read the onTime and offTime from the program memory
ontime = pgm_read_word(time_ptr+ti); // read word 1 - ontime
offtime = pgm_read_word(time_ptr+ti+2); // read word 2 - offtime
// transmit this codeElement (ontime and offtime)
xmitCodeElement(ontime, offtime, (freq!=0));
}
sei();
//Flush remaining bits, so that next code starts
//with a fresh set of 8 bits.
bitsleft_r=0;
// visible indication that a code has been output.
quickflashLED();
// delay 205 milliseconds before transmitting next POWER code
delay_ten_us(20500);
// if user is pushing (holding down) TRIGGER button, stop transmission early
if (digitalRead(TRIGGER) == BUTTON_PRESSED)
{
endingEarly = true;
delay_ten_us(50000); //500ms delay
quickflashLEDx(4);
//pause for ~1.3 sec to give the user time to release the button so that the code sequence won't immediately start again.
delay_ten_us(MAX_WAIT_TIME); // wait 655.350ms
delay_ten_us(MAX_WAIT_TIME); // wait 655.350ms
break; //exit the POWER code "for" loop
}
} //end of POWER code for loop
if (endingEarly==false)
{
//pause for ~1.3 sec, then flash the visible LED 8 times to indicate that we're done
delay_ten_us(MAX_WAIT_TIME); // wait 655.350ms
delay_ten_us(MAX_WAIT_TIME); // wait 655.350ms
quickflashLEDx(8);
}
} //end of sendAllCodes
void loop()
{
sleepNow();
//Super "ghetto" (but decent enough for this application) button debouncing:
//-if the user pushes the Trigger button, then wait a while to let the button stop bouncing, then start transmission of all POWER codes
if (digitalRead(TRIGGER) == BUTTON_PRESSED)
{
delay_ten_us(50000); // delay 500ms to give the user time to release the button before the code sequence begins
sendAllCodes();
}
}
/****************************** LED AND DELAY FUNCTIONS ********/
// This function delays the specified number of 10 microseconds
// it is 'hardcoded' and is calibrated by adjusting DELAY_CNT
// in main.h Unless you are changing the crystal from 8MHz, dont
// mess with this.
//-due to uint16_t datatype, max delay is 65535 tens of microseconds, or 655350 us, or 655.350 ms.
//-NB: DELAY_CNT has been increased in main.h from 11 to 25 (last I checked) in order to allow this function
// to work properly with 16MHz Arduinos now (instead of 8MHz).
void delay_ten_us(uint16_t us) {
uint8_t timer;
while (us != 0) {
// for 8MHz we want to delay 80 cycles per 10 microseconds
// this code is tweaked to give about that amount.
for (timer=0; timer <= DELAY_CNT; timer++) {
NOP;
NOP;
}
NOP;
us--;
}
}
// This function quickly pulses the visible LED (connected to PB0, pin 5)
// This will indicate to the user that a code is being transmitted
void quickflashLED( void ) {
digitalWrite(LED, HIGH);
delay_ten_us(3000); // 30 ms ON-time delay
digitalWrite(LED, LOW);
}
// This function just flashes the visible LED a couple times, used to
// tell the user what region is selected
void quickflashLEDx( uint8_t x ) {
quickflashLED();
while(--x) {
delay_ten_us(25000); // 250 ms OFF-time delay between flashes
quickflashLED();
}
}
/****************************** SLEEP and WAKE FUNCTIONS ********/
// from kaqkjz:
// http://www.ka1kjz.com/561/adding-sleep-to-tv-b-gone-code/
void sleepNow()
{
set_sleep_mode(TRIGGER); // sleep mode is set here
sleep_enable(); // enables the sleep bit in the mcucr register
attachInterrupt(0, wakeUpNow, LOW); // use interrupt 0 (pin 2) and run function
// wakeUpNow when pin 2 gets LOW
sleep_mode(); // here the device is actually put to sleep!!
// THE PROGRAM CONTINUES FROM HERE ON WAKE
sleep_disable(); // first thing after waking, disable sleep
detachInterrupt(0); // disables int 0 as the wakeupnow code will
// not be executed during normal runtime
}
void wakeUpNow()
{
// any needed wakeup code can be placed here
}
Raw
WORLD_IR_CODES.h
/*
TV-B-Gone for Arduino version 0.001
Ported to Arduino by Ken Shirriff, Dec 3, 2009
http://arcfn.com
The original code is:
TV-B-Gone Firmware version 1.2
for use with ATtiny85v and v1.2 hardware
(c) Mitch Altman + Limor Fried 2009
*/
//Codes captured from Generation 3 TV-B-Gone by Limor Fried & Mitch Altman
//table of POWER codes
#include "main.h"
const uint16_t code_na000Times[] PROGMEM = {
60, 60,
60, 2700,
120, 60,
240, 60,
};
const uint8_t code_na000Codes[] PROGMEM = {
0xE2,
0x20,
0x80,
0x78,
0x88,
0x20,
0x10,
};
const struct IrCode code_na000Code PROGMEM = {
freq_to_timerval(38400),
26, // # of pairs
2, // # of bits per index
code_na000Times,
code_na000Codes
};
const uint16_t code_na001Times[] PROGMEM = {
50, 100,
50, 200,
50, 800,
400, 400,
};
const uint8_t code_na001Codes[] PROGMEM = {
0xD5,
0x41,
0x11,
0x00,
0x14,
0x44,
0x6D,
0x54,
0x11,
0x10,
0x01,
0x44,
0x45,
};
const struct IrCode code_na001Code PROGMEM = {
freq_to_timerval(57143),
52, // # of pairs
2, // # of bits per index
code_na001Times,
code_na001Codes
};
const uint16_t code_na002Times[] PROGMEM = {
42, 46,
42, 133,
42, 7519,
347, 176,
347, 177,
};
const uint8_t code_na002Codes[] PROGMEM = {
0x60,
0x80,
0x00,
0x00,
0x00,
0x08,
0x00,
0x00,
0x00,
0x20,
0x00,
0x00,
0x04,
0x12,
0x48,
0x04,
0x12,
0x48,
0x2A,
0x02,
0x00,
0x00,
0x00,
0x00,
0x20,
0x00,
0x00,
0x00,
0x80,
0x00,
0x00,
0x10,
0x49,
0x20,
0x10,
0x49,
0x20,
0x80,
};
const struct IrCode code_na002Code PROGMEM = {
freq_to_timerval(37037),
100, // # of pairs
3, // # of bits per index
code_na002Times,
code_na002Codes
};
const uint16_t code_na003Times[] PROGMEM = {
26, 185,
27, 80,
27, 185,
27, 4549,
};
const uint8_t code_na003Codes[] PROGMEM = {
0x15,
0x5A,
0x65,
0x67,
0x95,
0x65,
0x9A,
0x9B,
0x95,
0x5A,
0x65,
0x67,
0x95,
0x65,
0x9A,
0x99,
};
const struct IrCode code_na003Code PROGMEM = {
freq_to_timerval(38610),
64, // # of pairs
2, // # of bits per index
code_na003Times,
code_na003Codes
};
const uint16_t code_na004Times[] PROGMEM = {
55, 57,
55, 170,
55, 3949,
55, 9623,
56, 0,
898, 453,
900, 226,
};
const uint8_t code_na004Codes[] PROGMEM = {
0xA0,
0x00,
0x01,
0x04,
0x92,
0x48,
0x20,
0x80,
0x40,
0x04,
0x12,
0x09,
0x2B,
0x3D,
0x00,
};
const struct IrCode code_na004Code PROGMEM = {
freq_to_timerval(38610),
38, // # of pairs
3, // # of bits per index
code_na004Times,
code_na004Codes
};
const uint16_t code_na005Times[] PROGMEM = {
88, 90,
88, 91,
88, 181,
88, 8976,
177, 91,
};
const uint8_t code_na005Codes[] PROGMEM = {
0x10,
0x92,
0x49,
0x46,
0x33,
0x09,
0x24,
0x94,
0x60,
};
const struct IrCode code_na005Code PROGMEM = {
freq_to_timerval(35714),
24, // # of pairs
3, // # of bits per index
code_na005Times,
code_na005Codes
};
const uint16_t code_na006Times[] PROGMEM = {
50, 62,
50, 172,
50, 4541,
448, 466,
450, 465,
};
const uint8_t code_na006Codes[] PROGMEM = {
0x64,
0x90,
0x00,
0x04,
0x90,
0x00,
0x00,
0x80,
0x00,
0x04,
0x12,
0x49,
0x2A,
0x12,
0x40,
0x00,
0x12,
0x40,
0x00,
0x02,
0x00,
0x00,
0x10,
0x49,
0x24,
0x90,
};
const struct IrCode code_na006Code PROGMEM = {
freq_to_timerval(38462),
68, // # of pairs
3, // # of bits per index
code_na006Times,
code_na006Codes
};
const uint16_t code_na007Times[] PROGMEM = {
49, 49,
49, 50,
49, 410,
49, 510,
49, 12107,
};
const uint8_t code_na007Codes[] PROGMEM = {
0x09,
0x94,
0x53,
0x29,
0x94,
0xD9,
0x85,
0x32,
0x8A,
0x65,
0x32,
0x9B,
0x20,
};
const struct IrCode code_na007Code PROGMEM = {
freq_to_timerval(39216),
34, // # of pairs
3, // # of bits per index
code_na007Times,
code_na007Codes
};
const uint16_t code_na008Times[] PROGMEM = {
56, 58,
56, 170,
56, 4011,
898, 450,
900, 449,
};
const uint8_t code_na008Codes[] PROGMEM = {
0x64,
0x00,
0x49,
0x00,
0x92,
0x00,
0x20,
0x82,
0x01,
0x04,
0x10,
0x48,
0x2A,
0x10,
0x01,
0x24,
0x02,
0x48,
0x00,
0x82,
0x08,
0x04,
0x10,
0x41,
0x20,
0x90,
};
const struct IrCode code_na008Code PROGMEM = {
freq_to_timerval(38462),
68, // # of pairs
3, // # of bits per index
code_na008Times,
code_na008Codes
};
const uint16_t code_na009Times[] PROGMEM = {
53, 56,
53, 171,
53, 3950,
53, 9599,
898, 451,
900, 226,
};
const uint8_t code_na009Codes[] PROGMEM = {
0x84,
0x90,
0x00,
0x20,
0x80,
0x08,
0x00,
0x00,
0x09,
0x24,
0x92,
0x40,
0x0A,
0xBA,
0x40,
};
const struct IrCode code_na009Code PROGMEM = {
freq_to_timerval(38462),
38, // # of pairs
3, // # of bits per index
code_na009Times,
code_na009Codes
};
const uint16_t code_na010Times[] PROGMEM = {
51, 55,
51, 158,
51, 2286,
841, 419,
};
const uint8_t code_na010Codes[] PROGMEM = {
0xD4,
0x00,
0x15,
0x10,
0x25,
0x00,
0x05,
0x44,
0x09,
0x40,
0x01,
0x51,
0x01,
};
const struct IrCode code_na010Code PROGMEM = {
freq_to_timerval(38462),
52, // # of pairs
2, // # of bits per index
code_na010Times,
code_na010Codes
};
const uint16_t code_na011Times[] PROGMEM = {
55, 55,
55, 172,
55, 4039,
55, 9348,
56, 0,
884, 442,
885, 225,
};
const uint8_t code_na011Codes[] PROGMEM = {
0xA0,
0x00,
0x41,
0x04,
0x92,
0x08,
0x24,
0x90,
0x40,
0x00,
0x02,
0x09,
0x2B,
0x3D,
0x00,
};
const struct IrCode code_na011Code PROGMEM = {
freq_to_timerval(38462),
38, // # of pairs
3, // # of bits per index
code_na011Times,
code_na011Codes
};
const uint16_t code_na012Times[] PROGMEM = {
81, 87,
81, 254,
81, 3280,
331, 336,
331, 337,
};
const uint8_t code_na012Codes[] PROGMEM = {
0x64,
0x12,
0x08,
0x24,
0x00,
0x08,
0x20,
0x10,
0x09,
0x2A,
0x10,
0x48,
0x20,
0x90,
0x00,
0x20,
0x80,
0x40,
0x24,
0x90,
};
const struct IrCode code_na012Code PROGMEM = {
freq_to_timerval(38462),
52, // # of pairs
3, // # of bits per index
code_na012Times,
code_na012Codes
};
const uint16_t code_na013Times[] PROGMEM = {
53, 55,
53, 167,
53, 2304,
53, 9369,
893, 448,
895, 447,
};
const uint8_t code_na013Codes[] PROGMEM = {
0x80,
0x12,
0x40,
0x04,
0x00,
0x09,
0x00,
0x12,
0x41,
0x24,
0x82,
0x01,
0x00,
0x10,
0x48,
0x24,
0xAA,
0xE8,
};
const struct IrCode code_na013Code PROGMEM = {
freq_to_timerval(38462),
48, // # of pairs
3, // # of bits per index
code_na013Times,
code_na013Codes
};
/* Duplicate timing table, same as na004 !
const uint16_t code_na014Times[] PROGMEM = {
55, 57,
55, 170,
55, 3949,
55, 9623,
56, 0,
898, 453,
900, 226,
};
*/
const uint8_t code_na014Codes[] PROGMEM = {
0xA0,
0x00,
0x09,
0x04,
0x92,
0x40,
0x24,
0x80,
0x00,
0x00,
0x12,
0x49,
0x2B,
0x3D,
0x00,
};
const struct IrCode code_na014Code PROGMEM = {
freq_to_timerval(38462),
38, // # of pairs
3, // # of bits per index
code_na004Times,
code_na014Codes
};
/* Duplicate timing table, same as na004 !
const uint16_t code_na015Times[] PROGMEM = {
55, 57,
55, 170,
55, 3949,
55, 9623,
56, 0,
898, 453,
900, 226,
};
*/
const uint8_t code_na015Codes[] PROGMEM = {
0xA0,
0x80,
0x01,
0x04,
0x12,
0x48,
0x24,
0x00,
0x00,
0x00,
0x92,
0x49,
0x2B,
0x3D,
0x00,
};
const struct IrCode code_na015Code PROGMEM = {
freq_to_timerval(38462),
38, // # of pairs
3, // # of bits per index
code_na004Times,
code_na015Codes
};
const uint16_t code_na016Times[] PROGMEM = {
28, 90,
28, 211,
28, 2507,
};
const uint8_t code_na016Codes[] PROGMEM = {
0x54,
0x04,
0x10,
0x00,
0x95,
0x01,
0x04,
0x00,
0x10,
};
const struct IrCode code_na016Code PROGMEM = {
freq_to_timerval(34483),
34, // # of pairs
2, // # of bits per index
code_na016Times,
code_na016Codes
};
const uint16_t code_na017Times[] PROGMEM = {
56, 57,
56, 175,
56, 4150,
56, 9499,
898, 227,
898, 449,
};
const uint8_t code_na017Codes[] PROGMEM = {
0xA0,
0x02,
0x48,
0x04,
0x90,
0x01,
0x20,
0x80,
0x40,
0x04,
0x12,
0x09,
0x2A,
0x38,
0x00,
};
const struct IrCode code_na017Code PROGMEM = {
freq_to_timerval(40000),
38, // # of pairs
3, // # of bits per index
code_na017Times,
code_na017Codes
};
const uint16_t code_na018Times[] PROGMEM = {
51, 55,
51, 161,
51, 2566,
849, 429,
849, 430,
};
const uint8_t code_na018Codes[] PROGMEM = {
0x60,
0x82,
0x08,
0x24,
0x10,
0x41,
0x00,
0x12,
0x40,
0x04,
0x80,
0x09,
0x2A,
0x02,
0x08,
0x20,
0x90,
0x41,
0x04,
0x00,
0x49,
0x00,
0x12,
0x00,
0x24,
0xA8,
0x08,
0x20,
0x82,
0x41,
0x04,
0x10,
0x01,
0x24,
0x00,
0x48,
0x00,
0x92,
0xA0,
0x20,
0x82,
0x09,
0x04,
0x10,
0x40,
0x04,
0x90,
0x01,
0x20,
0x02,
0x48,
};
const struct IrCode code_na018Code PROGMEM = {
freq_to_timerval(38462),
136, // # of pairs
3, // # of bits per index
code_na018Times,
code_na018Codes
};
const uint16_t code_na019Times[] PROGMEM = {
40, 42,
40, 124,
40, 4601,
325, 163,
326, 163,
};
const uint8_t code_na019Codes[] PROGMEM = {
0x60,
0x10,
0x40,
0x04,
0x80,
0x09,
0x00,
0x00,
0x00,
0x00,
0x10,
0x00,
0x20,
0x10,
0x00,
0x20,
0x80,
0x00,
0x0A,
0x00,
0x41,
0x00,
0x12,
0x00,
0x24,
0x00,
0x00,
0x00,
0x00,
0x40,
0x00,
0x80,
0x40,
0x00,
0x82,
0x00,
0x00,
0x00,
};
const struct IrCode code_na019Code PROGMEM = {
freq_to_timerval(38462),
100, // # of pairs
3, // # of bits per index
code_na019Times,
code_na019Codes
};
const uint16_t code_na020Times[] PROGMEM = {
60, 55,
60, 163,
60, 4099,
60, 9698,
61, 0,
898, 461,
900, 230,
};
const uint8_t code_na020Codes[] PROGMEM = {
0xA0,
0x10,
0x00,
0x04,
0x82,
0x49,
0x20,
0x02,
0x00,
0x04,
0x90,
0x49,
0x2B,
0x3D,
0x00,
};
const struct IrCode code_na020Code PROGMEM = {
freq_to_timerval(38462),
38, // # of pairs
3, // # of bits per index
code_na020Times,
code_na020Codes
};
const uint16_t code_na021Times[] PROGMEM = {
48, 52,
48, 160,
48, 400,
48, 2335,
799, 400,
};
const uint8_t code_na021Codes[] PROGMEM = {
0x80,
0x10,
0x40,
0x08,
0x82,
0x08,
0x01,
0xC0,
0x08,
0x20,
0x04,
0x41,
0x04,
0x00,
0x00,
};
const struct IrCode code_na021Code PROGMEM = {
freq_to_timerval(38462),
38, // # of pairs
3, // # of bits per index
code_na021Times,
code_na021Codes
};
const uint16_t code_na022Times[] PROGMEM = {
53, 60,
53, 175,
53, 4463,
53, 9453,
892, 450,
895, 225,
};
const uint8_t code_na022Codes[] PROGMEM = {
0x80,
0x02,
0x40,
0x00,
0x02,
0x40,
0x00,
0x00,
0x01,
0x24,
0x92,
0x48,
0x0A,
0xBA,
0x00,
};
const struct IrCode code_na022Code PROGMEM = {
freq_to_timerval(38462),
38, // # of pairs
3, // # of bits per index
code_na022Times,
code_na022Codes
};
const uint16_t code_na023Times[] PROGMEM = {
48, 52,
48, 409,
48, 504,
48, 10461,
};
const uint8_t code_na023Codes[] PROGMEM = {
0xA1,
0x18,
0x61,
0xA1,
0x18,
0x7A,
0x11,
0x86,
0x1A,
0x11,
0x86,
};
const struct IrCode code_na023Code PROGMEM = {
freq_to_timerval(40000),
44, // # of pairs
2, // # of bits per index
code_na023Times,
code_na023Codes
};
const uint16_t code_na024Times[] PROGMEM = {
58, 60,
58, 2569,
118, 60,
237, 60,
238, 60,
};
const uint8_t code_na024Codes[] PROGMEM = {
0x69,
0x24,
0x10,
0x40,
0x03,
0x12,
0x48,
0x20,
0x80,
0x00,
};
const struct IrCode code_na024Code PROGMEM = {
freq_to_timerval(38462),
26, // # of pairs
3, // # of bits per index
code_na024Times,
code_na024Codes
};
const uint16_t code_na025Times[] PROGMEM = {
84, 90,
84, 264,
84, 3470,
346, 350,
347, 350,
};
const uint8_t code_na025Codes[] PROGMEM = {
0x64,
0x92,
0x49,
0x00,
0x00,
0x00,
0x00,
0x02,
0x49,
0x2A,
0x12,
0x49,
0x24,
0x00,
0x00,
0x00,
0x00,
0x09,
0x24,
0x90,
};
const struct IrCode code_na025Code PROGMEM = {
freq_to_timerval(38462),
52, // # of pairs
3, // # of bits per index
code_na025Times,
code_na025Codes
};
const uint16_t code_na026Times[] PROGMEM = {
49, 49,
49, 50,
49, 410,
49, 510,
49, 12582,
};
const uint8_t code_na026Codes[] PROGMEM = {
0x09,
0x94,
0x53,
0x65,
0x32,
0x99,
0x85,
0x32,
0x8A,
0x6C,
0xA6,
0x53,
0x20,
};
const struct IrCode code_na026Code PROGMEM = {
freq_to_timerval(39216),
34, // # of pairs
3, // # of bits per index
code_na026Times,
code_na026Codes
};
/* Duplicate timing table, same as na001 !
const uint16_t code_na027Times[] PROGMEM = {
50, 100,
50, 200,
50, 800,
400, 400,
};
*/
const uint8_t code_na027Codes[] PROGMEM = {
0xC5,
0x41,
0x11,
0x10,
0x14,
0x44,
0x6C,
0x54,
0x11,
0x11,
0x01,
0x44,
0x44,
};
const struct IrCode code_na027Code PROGMEM = {
freq_to_timerval(57143),
52, // # of pairs
2, // # of bits per index
code_na001Times,
code_na027Codes
};
const uint16_t code_na028Times[] PROGMEM = {
118, 121,
118, 271,
118, 4750,
258, 271,
};
const uint8_t code_na028Codes[] PROGMEM = {
0xC4,
0x45,
0x14,
0x04,
0x6C,
0x44,
0x51,
0x40,
0x44,
};
const struct IrCode code_na028Code PROGMEM = {
freq_to_timerval(38610),
36, // # of pairs
2, // # of bits per index
code_na028Times,
code_na028Codes
};
const uint16_t code_na029Times[] PROGMEM = {
88, 90,
88, 91,
88, 181,
177, 91,
177, 8976,
};
const uint8_t code_na029Codes[] PROGMEM = {
0x0C,
0x92,
0x53,
0x46,
0x16,
0x49,
0x29,
0xA2,
0xC0,
};
const struct IrCode code_na029Code PROGMEM = {
freq_to_timerval(35842),
22, // # of pairs
3, // # of bits per index
code_na029Times,
code_na029Codes
};
/* Duplicate timing table, same as na009 !
const uint16_t code_na030Times[] PROGMEM = {
53, 56,
53, 171,
53, 3950,
53, 9599,
898, 451,
900, 226,
};
*/
const uint8_t code_na030Codes[] PROGMEM = {
0x80,
0x00,
0x41,
0x04,
0x12,
0x08,
0x20,
0x00,
0x00,
0x04,
0x92,
0x49,
0x2A,
0xBA,
0x00,
};
const struct IrCode code_na030Code PROGMEM = {
freq_to_timerval(38462),
38, // # of pairs
3, // # of bits per index
code_na009Times,
code_na030Codes
};
const uint16_t code_na031Times[] PROGMEM = {
88, 89,
88, 90,
88, 179,
88, 8977,
177, 90,
};
const uint8_t code_na031Codes[] PROGMEM = {
0x06,
0x12,
0x49,
0x46,
0x32,
0x61,
0x24,
0x94,
0x60,
};
const struct IrCode code_na031Code PROGMEM = {
freq_to_timerval(35842),
24, // # of pairs
3, // # of bits per index
code_na031Times,
code_na031Codes
};
/* Duplicate timing table, same as na009 !
const uint16_t code_na032Times[] PROGMEM = {
53, 56,
53, 171,
53, 3950,
53, 9599,
898, 451,
900, 226,
};
*/
const uint8_t code_na032Codes[] PROGMEM = {
0x80,
0x00,
0x41,
0x04,
0x12,
0x08,
0x20,
0x80,
0x00,
0x04,
0x12,
0x49,
0x2A,
0xBA,
0x00,
};
const struct IrCode code_na032Code PROGMEM = {
freq_to_timerval(38462),
38, // # of pairs
3, // # of bits per index
code_na009Times,
code_na032Codes
};
const uint16_t code_na033Times[] PROGMEM = {
40, 43,
40, 122,
40, 5297,
334, 156,
336, 155,
};
const uint8_t code_na033Codes[] PROGMEM = {
0x60,
0x10,
0x40,
0x04,
0x80,
0x09,
0x00,
0x00,
0x00,
0x00,
0x10,
0x00,
0x20,
0x82,
0x00,
0x20,
0x00,
0x00,
0x0A,
0x00,
0x41,
0x00,
0x12,
0x00,
0x24,
0x00,
0x00,
0x00,
0x00,
0x40,
0x00,
0x82,
0x08,
0x00,
0x80,
0x00,
0x00,
0x00,
};
const struct IrCode code_na033Code PROGMEM = {
freq_to_timerval(38462),
100, // # of pairs
3, // # of bits per index
code_na033Times,
code_na033Codes
};
/* Duplicate timing table, same as na004 !
const uint16_t code_na034Times[] PROGMEM = {
55, 57,
55, 170,
55, 3949,
55, 9623,
56, 0,
898, 453,
900, 226,
};
*/
const uint8_t code_na034Codes[] PROGMEM = {
0xA0,
0x00,
0x41,
0x04,
0x92,
0x08,
0x24,
0x92,
0x48,
0x00,
0x00,
0x01,
0x2B,
0x3D,
0x00,
};
const struct IrCode code_na034Code PROGMEM = {
freq_to_timerval(38462),
38, // # of pairs
3, // # of bits per index
code_na004Times,
code_na034Codes
};
const uint16_t code_na035Times[] PROGMEM = {
96, 93,
97, 93,
97, 287,
97, 3431,
};
const uint8_t code_na035Codes[] PROGMEM = {
0x16,
0x66,
0x5D,
0x59,
0x99,
0x50,
};
const struct IrCode code_na035Code PROGMEM = {
freq_to_timerval(41667),
22, // # of pairs
2, // # of bits per index
code_na035Times,
code_na035Codes
};
const uint16_t code_na036Times[] PROGMEM = {
82, 581,
84, 250,
84, 580,
85, 0,
};
const uint8_t code_na036Codes[] PROGMEM = {
0x15,
0x9A,
0x9C,
};
const struct IrCode code_na036Code PROGMEM = {
freq_to_timerval(37037),
11, // # of pairs
2, // # of bits per index
code_na036Times,
code_na036Codes
};
const uint16_t code_na037Times[] PROGMEM = {
39, 263,
164, 163,
514, 164,
};
const uint8_t code_na037Codes[] PROGMEM = {
0x80,
0x45,
0x00,
};
const struct IrCode code_na037Code PROGMEM = {
freq_to_timerval(41667),
11, // # of pairs
2, // # of bits per index
code_na037Times,
code_na037Codes
};
/* Duplicate timing table, same as na017 !
const uint16_t code_na038Times[] PROGMEM = {
56, 57,
56, 175,
56, 4150,
56, 9499,
898, 227,
898, 449,
};
*/
const uint8_t code_na038Codes[] PROGMEM = {
0xA4,
0x10,
0x40,
0x00,
0x82,
0x09,
0x20,
0x80,
0x40,
0x04,
0x12,
0x09,
0x2A,
0x38,
0x40,
};
const struct IrCode code_na038Code PROGMEM = {
freq_to_timerval(40000),
38, // # of pairs
3, // # of bits per index
code_na017Times,
code_na038Codes
};
const uint16_t code_na039Times[] PROGMEM = {
113, 101,
688, 2707,
};
const uint8_t code_na039Codes[] PROGMEM = {
0x11,
};
const struct IrCode code_na039Code PROGMEM = {
freq_to_timerval(40000),
4, // # of pairs
2, // # of bits per index
code_na039Times,
code_na039Codes
};
const uint16_t code_na040Times[] PROGMEM = {
113, 101,
113, 201,
113, 2707,
};
const uint8_t code_na040Codes[] PROGMEM = {
0x06,
0x04,
};
const struct IrCode code_na040Code PROGMEM = {
freq_to_timerval(40000),
8, // # of pairs
2, // # of bits per index
code_na040Times,
code_na040Codes
};
const uint16_t code_na041Times[] PROGMEM = {
58, 62,
58, 2746,
117, 62,
242, 62,
};
const uint8_t code_na041Codes[] PROGMEM = {
0xE2,
0x20,
0x80,
0x78,
0x88,
0x20,
0x00,
};
const struct IrCode code_na041Code PROGMEM = {
freq_to_timerval(76923),
26, // # of pairs
2, // # of bits per index
code_na041Times,
code_na041Codes
};
const uint16_t code_na042Times[] PROGMEM = {
54, 65,
54, 170,
54, 4099,
54, 8668,
899, 226,
899, 421,
};
const uint8_t code_na042Codes[] PROGMEM = {
0xA4,
0x80,
0x00,
0x20,
0x82,
0x49,
0x00,
0x02,
0x00,
0x04,
0x90,
0x49,
0x2A,
0x38,
0x40,
};
const struct IrCode code_na042Code PROGMEM = {
freq_to_timerval(40000),
38, // # of pairs
3, // # of bits per index
code_na042Times,
code_na042Codes
};
const uint16_t code_na043Times[] PROGMEM = {
43, 120,
43, 121,
43, 3491,
131, 45,
};
const uint8_t code_na043Codes[] PROGMEM = {
0x15,
0x75,
0x56,
0x55,
0x75,
0x54,
};
const struct IrCode code_na043Code PROGMEM = {
freq_to_timerval(40000),
24, // # of pairs
2, // # of bits per index
code_na043Times,
code_na043Codes
};
const uint16_t code_na044Times[] PROGMEM = {
51, 51,
51, 160,
51, 4096,
51, 9513,
431, 436,
883, 219,
};
const uint8_t code_na044Codes[] PROGMEM = {
0x84,
0x90,
0x00,
0x00,
0x02,
0x49,
0x20,
0x80,
0x00,
0x04,
0x12,
0x49,
0x2A,
0xBA,
0x40,
};
const struct IrCode code_na044Code PROGMEM = {
freq_to_timerval(40000),
38, // # of pairs
3, // # of bits per index
code_na044Times,
code_na044Codes
};
const uint16_t code_na045Times[] PROGMEM = {
58, 53,
58, 167,
58, 4494,
58, 9679,
455, 449,
456, 449,
};
const uint8_t code_na045Codes[] PROGMEM = {
0x80,
0x90,
0x00,
0x00,
0x90,
0x00,
0x04,
0x92,
0x00,
0x00,
0x00,
0x49,
0x2A,
0x97,
0x48,
};
const struct IrCode code_na045Code PROGMEM = {
freq_to_timerval(38462),
40, // # of pairs
3, // # of bits per index
code_na045Times,
code_na045Codes
};
const uint16_t code_na046Times[] PROGMEM = {
51, 277,
52, 53,
52, 105,
52, 277,
52, 2527,
52, 12809,
103, 54,
};
const uint8_t code_na046Codes[] PROGMEM = {
0x0B,
0x12,
0x63,
0x44,
0x92,
0x6B,
0x44,
0x92,
0x50,
};
const struct IrCode code_na046Code PROGMEM = {
freq_to_timerval(29412),
23, // # of pairs
3, // # of bits per index
code_na046Times,
code_na046Codes
};
/* Duplicate timing table, same as na017 !
const uint16_t code_na047Times[] PROGMEM = {
56, 57,
56, 175,
56, 4150,
56, 9499,
898, 227,
898, 449,
};
*/
const uint8_t code_na047Codes[] PROGMEM = {
0xA0,
0x00,
0x40,
0x04,
0x92,
0x09,
0x24,
0x92,
0x09,
0x20,
0x00,
0x40,
0x0A,
0x38,
0x00,
};
const struct IrCode code_na047Code PROGMEM = {
freq_to_timerval(40000),
38, // # of pairs
3, // # of bits per index
code_na017Times,
code_na047Codes
};
/* Duplicate timing table, same as na044 !
const uint16_t code_na048Times[] PROGMEM = {
51, 51,
51, 160,
51, 4096,
51, 9513,
431, 436,
883, 219,
};
*/
const uint8_t code_na048Codes[] PROGMEM = {
0x80,
0x00,
0x00,
0x04,
0x92,
0x49,
0x24,
0x92,
0x00,
0x00,
0x00,
0x49,
0x2A,
0xBA,
0x00,
};
const struct IrCode code_na048Code PROGMEM = {
freq_to_timerval(40000),
38, // # of pairs
3, // # of bits per index
code_na044Times,
code_na048Codes
};
const uint16_t code_na049Times[] PROGMEM = {
274, 854,
274, 1986,
};
const uint8_t code_na049Codes[] PROGMEM = {
0x14,
0x11,
0x40,
};
const struct IrCode code_na049Code PROGMEM = {
freq_to_timerval(45455),
11, // # of pairs
2, // # of bits per index
code_na049Times,
code_na049Codes
};
const uint16_t code_na050Times[] PROGMEM = {
80, 88,
80, 254,
80, 3750,
359, 331,
};
const uint8_t code_na050Codes[] PROGMEM = {
0xC0,
0x00,
0x01,
0x55,
0x55,
0x52,
0xC0,
0x00,
0x01,
0x55,
0x55,
0x50,
};
const struct IrCode code_na050Code PROGMEM = {
freq_to_timerval(55556),
48, // # of pairs
2, // # of bits per index
code_na050Times,
code_na050Codes
};
/* Duplicate timing table, same as na017 !
const uint16_t code_na051Times[] PROGMEM = {
56, 57,
56, 175,
56, 4150,
56, 9499,
898, 227,
898, 449,
};
*/
const uint8_t code_na051Codes[] PROGMEM = {
0xA0,
0x10,
0x01,
0x24,
0x82,
0x48,
0x00,
0x02,
0x40,
0x04,
0x90,
0x09,
0x2A,
0x38,
0x00,
};
const struct IrCode code_na051Code PROGMEM = {
freq_to_timerval(40000),
38, // # of pairs
3, // # of bits per index
code_na017Times,
code_na051Codes
};
/* Duplicate timing table, same as na017 !
const uint16_t code_na052Times[] PROGMEM = {
56, 57,
56, 175,
56, 4150,
56, 9499,
898, 227,
898, 449,
};
*/
const uint8_t code_na052Codes[] PROGMEM = {
0xA4,
0x90,
0x48,
0x00,
0x02,
0x01,
0x20,
0x80,
0x40,
0x04,
0x12,
0x09,
0x2A,
0x38,
0x40,
};
const struct IrCode code_na052Code PROGMEM = {
freq_to_timerval(40000),
38, // # of pairs
3, // # of bits per index
code_na017Times,
code_na052Codes
};
const uint16_t code_na053Times[] PROGMEM = {
51, 232,
51, 512,
51, 792,
51, 2883,
};
const uint8_t code_na053Codes[] PROGMEM = {
0x22,
0x21,
0x40,
0x1C,
0x88,
0x85,
0x00,
0x40,
};
const struct IrCode code_na053Code PROGMEM = {
freq_to_timerval(55556),
30, // # of pairs
2, // # of bits per index
code_na053Times,
code_na053Codes
};
/* Duplicate timing table, same as na053 !
const uint16_t code_na054Times[] PROGMEM = {
51, 232,
51, 512,
51, 792,
51, 2883,
};
*/
const uint8_t code_na054Codes[] PROGMEM = {
0x22,
0x20,
0x15,
0x72,
0x22,
0x01,
0x54,
};
const struct IrCode code_na054Code PROGMEM = {
freq_to_timerval(55556),
28, // # of pairs
2, // # of bits per index
code_na053Times,
code_na054Codes
};
const uint16_t code_na055Times[] PROGMEM = {
3, 10,
3, 20,
3, 30,
3, 12778,
};
const uint8_t code_na055Codes[] PROGMEM = {
0x81,
0x51,
0x14,
0xB8,
0x15,
0x11,
0x44,
};
const struct IrCode code_na055Code PROGMEM = {
0, // Non-pulsed code
27, // # of pairs
2, // # of bits per index
code_na055Times,
code_na055Codes
};
const uint16_t code_na056Times[] PROGMEM = {
55, 193,
57, 192,
57, 384,
58, 0,
};
const uint8_t code_na056Codes[] PROGMEM = {
0x2A,
0x57,
};
const struct IrCode code_na056Code PROGMEM = {
freq_to_timerval(37175),
8, // # of pairs
2, // # of bits per index
code_na056Times,
code_na056Codes
};
const uint16_t code_na057Times[] PROGMEM = {
45, 148,
46, 148,
46, 351,
46, 2781,
};
const uint8_t code_na057Codes[] PROGMEM = {
0x2A,
0x5D,
0xA9,
0x60,
};
const struct IrCode code_na057Code PROGMEM = {
freq_to_timerval(40000),
14, // # of pairs
2, // # of bits per index
code_na057Times,
code_na057Codes
};
const uint16_t code_na058Times[] PROGMEM = {
22, 101,
22, 219,
23, 101,
23, 219,
31, 218,
};
const uint8_t code_na058Codes[] PROGMEM = {
0x8D,
0xA4,
0x08,
0x04,
0x04,
0x92,
0x4C,
};
const struct IrCode code_na058Code PROGMEM = {
freq_to_timerval(33333),
18, // # of pairs
3, // # of bits per index
code_na058Times,
code_na058Codes
};
/* Duplicate timing table, same as na017 !
const uint16_t code_na059Times[] PROGMEM = {
56, 57,
56, 175,
56, 4150,
56, 9499,
898, 227,
898, 449,
};
*/
const uint8_t code_na059Codes[] PROGMEM = {
0xA4,
0x12,
0x09,
0x00,
0x80,
0x40,
0x20,
0x10,
0x40,
0x04,
0x82,
0x09,
0x2A,
0x38,
0x40,
};
const struct IrCode code_na059Code PROGMEM = {
freq_to_timerval(40000),
38, // # of pairs
3, // # of bits per index
code_na017Times,
code_na059Codes
};
/* Duplicate timing table, same as na017 !
const uint16_t code_na060Times[] PROGMEM = {
56, 57,
56, 175,
56, 4150,
56, 9499,
898, 227,
898, 449,
};
*/
const uint8_t code_na060Codes[] PROGMEM = {
0xA0,
0x00,
0x08,
0x04,
0x92,
0x41,
0x24,
0x00,
0x40,
0x00,
0x92,
0x09,
0x2A,
0x38,
0x00,
};
const struct IrCode code_na060Code PROGMEM = {
freq_to_timerval(40000),
38, // # of pairs
3, // # of bits per index
code_na017Times,
code_na060Codes
};
/* Duplicate timing table, same as na017 !
const uint16_t code_na061Times[] PROGMEM = {
56, 57,
56, 175,
56, 4150,
56, 9499,
898, 227,
898, 449,
};
*/
const uint8_t code_na061Codes[] PROGMEM = {
0xA0,
0x00,
0x08,
0x24,
0x92,
0x41,
0x04,
0x82,
0x00,
0x00,
0x10,
0x49,
0x2A,
0x38,
0x00,
};
const struct IrCode code_na061Code PROGMEM = {
freq_to_timerval(40000),
38, // # of pairs
3, // # of bits per index
code_na017Times,
code_na061Codes
};
/* Duplicate timing table, same as na017 !
const uint16_t code_na062Times[] PROGMEM = {
56, 57,
56, 175,
56, 4150,
56, 9499,
898, 227,
898, 449,
};
*/
const uint8_t code_na062Codes[] PROGMEM = {
0xA0,
0x02,
0x08,
0x04,
0x90,
0x41,
0x24,
0x82,
0x00,
0x00,
0x10,
0x49,
0x2A,
0x38,
0x00,
};
const struct IrCode code_na062Code PROGMEM = {
freq_to_timerval(40000),
38, // # of pairs
3, // # of bits per index
code_na017Times,
code_na062Codes
};
/* Duplicate timing table, same as na017 !
const uint16_t code_na063Times[] PROGMEM = {
56, 57,
56, 175,
56, 4150,
56, 9499,
898, 227,
898, 449,
};
*/
const uint8_t code_na063Codes[] PROGMEM = {
0xA4,
0x92,
0x49,
0x20,
0x00,
0x00,
0x04,
0x92,
0x48,
0x00,
0x00,
0x01,
0x2A,
0x38,
0x40,
};
const struct IrCode code_na063Code PROGMEM = {
freq_to_timerval(40000),
38, // # of pairs
3, // # of bits per index
code_na017Times,
code_na063Codes
};
/* Duplicate timing table, same as na001 !
const uint16_t code_na064Times[] PROGMEM = {
50, 100,
50, 200,
50, 800,
400, 400,
};
*/
const uint8_t code_na064Codes[] PROGMEM = {
0xC0,
0x01,
0x51,
0x55,
0x54,
0x04,
0x2C,
0x00,
0x15,
0x15,
0x55,
0x40,
0x40,
};
const struct IrCode code_na064Code PROGMEM = {
freq_to_timerval(57143),
52, // # of pairs
2, // # of bits per index
code_na001Times,
code_na064Codes
};
const uint16_t code_na065Times[] PROGMEM = {
48, 98,
48, 197,
98, 846,
395, 392,
1953, 392,
};
const uint8_t code_na065Codes[] PROGMEM = {
0x84,
0x92,
0x01,
0x24,
0x12,
0x00,
0x04,
0x80,
0x08,
0x09,
0x92,
0x48,
0x04,
0x90,
0x48,
0x00,
0x12,
0x00,
0x20,
0x26,
0x49,
0x20,
0x12,
0x41,
0x20,
0x00,
0x48,
0x00,
0x80,
0x80,
};
const struct IrCode code_na065Code PROGMEM = {
freq_to_timerval(59172),
78, // # of pairs
3, // # of bits per index
code_na065Times,
code_na065Codes
};
const uint16_t code_na066Times[] PROGMEM = {
38, 276,
165, 154,
415, 155,
742, 154,
};
const uint8_t code_na066Codes[] PROGMEM = {
0xC0,
0x45,
0x02,
0x01,
0x14,
0x08,
0x04,
0x50,
0x00,
};
const struct IrCode code_na066Code PROGMEM = {
freq_to_timerval(38462),
33, // # of pairs
2, // # of bits per index
code_na066Times,
code_na066Codes
};
/* Duplicate timing table, same as na044 !
const uint16_t code_na067Times[] PROGMEM = {
51, 51,
51, 160,
51, 4096,
51, 9513,
431, 436,
883, 219,
};
*/
const uint8_t code_na067Codes[] PROGMEM = {
0x80,
0x02,
0x49,
0x24,
0x90,
0x00,
0x00,
0x80,
0x00,
0x04,
0x12,
0x49,
0x2A,
0xBA,
0x00,
};
const struct IrCode code_na067Code PROGMEM = {
freq_to_timerval(40000),
38, // # of pairs
3, // # of bits per index
code_na044Times,
code_na067Codes
};
const uint16_t code_na068Times[] PROGMEM = {
43, 121,
43, 9437,
130, 45,
131, 45,
};
const uint8_t code_na068Codes[] PROGMEM = {
0x8C,
0x30,
0x0D,
0xCC,
0x30,
0x0C,
};
const struct IrCode code_na068Code PROGMEM = {
freq_to_timerval(40000),
24, // # of pairs
2, // # of bits per index
code_na068Times,
code_na068Codes
};
/* Duplicate timing table, same as na017 !
const uint16_t code_na069Times[] PROGMEM = {
56, 57,
56, 175,
56, 4150,
56, 9499,
898, 227,
898, 449,
};
*/
const uint8_t code_na069Codes[] PROGMEM = {
0xA0,
0x00,
0x00,
0x04,
0x92,
0x49,
0x24,
0x82,
0x00,
0x00,
0x10,
0x49,
0x2A,
0x38,
0x00,
};
const struct IrCode code_na069Code PROGMEM = {
freq_to_timerval(40000),
38, // # of pairs
3, // # of bits per index
code_na017Times,
code_na069Codes
};
const uint16_t code_na070Times[] PROGMEM = {
27, 76,
27, 182,
27, 183,
27, 3199,
};
const uint8_t code_na070Codes[] PROGMEM = {
0x40,
0x02,
0x08,
0xA2,
0xE0,
0x00,
0x82,
0x28,
0x40,
};
const struct IrCode code_na070Code PROGMEM = {
freq_to_timerval(38462),
33, // # of pairs
2, // # of bits per index
code_na070Times,
code_na070Codes
};
const uint16_t code_na071Times[] PROGMEM = {
37, 181,
37, 272,
};
const uint8_t code_na071Codes[] PROGMEM = {
0x11,
0x40,
};
const struct IrCode code_na071Code PROGMEM = {
freq_to_timerval(55556),
8, // # of pairs
2, // # of bits per index
code_na071Times,
code_na071Codes
};
/* Duplicate timing table, same as na042 !
const uint16_t code_na072Times[] PROGMEM = {
54, 65,
54, 170,
54, 4099,
54, 8668,
899, 226,
899, 421,
};
*/
const uint8_t code_na072Codes[] PROGMEM = {
0xA0,
0x90,
0x00,
0x00,
0x90,
0x00,
0x00,
0x10,
0x40,
0x04,
0x82,
0x09,
0x2A,
0x38,
0x00,
};
const struct IrCode code_na072Code PROGMEM = {
freq_to_timerval(40000),
38, // # of pairs
3, // # of bits per index
code_na042Times,
code_na072Codes
};
/* Duplicate timing table, same as na017 !
const uint16_t code_na073Times[] PROGMEM = {
56, 57,
56, 175,
56, 4150,
56, 9499,
898, 227,
898, 449,
};
*/
const uint8_t code_na073Codes[] PROGMEM = {
0xA0,
0x82,
0x08,
0x24,
0x10,
0x41,
0x00,
0x00,
0x00,
0x24,
0x92,
0x49,
0x0A,
0x38,
0x00,
};
const struct IrCode code_na073Code PROGMEM = {
freq_to_timerval(40000),
38, // # of pairs
3, // # of bits per index
code_na017Times,
code_na073Codes
};
/* Duplicate timing table, same as na017 !
const uint16_t code_na074Times[] PROGMEM = {
56, 57,
56, 175,
56, 4150,
56, 9499,
898, 227,
898, 449,
};
*/
const uint8_t code_na074Codes[] PROGMEM = {
0xA4,
0x00,
0x41,
0x00,
0x92,
0x08,
0x20,
0x02,
0x00,
0x04,
0x90,
0x49,
0x2A,
0x38,
0x40,
};
const struct IrCode code_na074Code PROGMEM = {
freq_to_timerval(40000),
38, // # of pairs
3, // # of bits per index
code_na017Times,
code_na074Codes
};
const uint16_t code_na075Times[] PROGMEM = {
51, 98,
51, 194,
102, 931,
390, 390,
390, 391,
};
const uint8_t code_na075Codes[] PROGMEM = {
0x60,
0x00,
0x01,
0x04,
0x10,
0x49,
0x24,
0x82,
0x08,
0x2A,
0x00,
0x00,
0x04,
0x10,
0x41,
0x24,
0x92,
0x08,
0x20,
0xA0,
};
const struct IrCode code_na075Code PROGMEM = {
freq_to_timerval(41667),
52, // # of pairs
3, // # of bits per index
code_na075Times,
code_na075Codes
};
/* Duplicate timing table, same as na017 !
const uint16_t code_na076Times[] PROGMEM = {
56, 57,
56, 175,
56, 4150,
56, 9499,
898, 227,
898, 449,
};
*/
const uint8_t code_na076Codes[] PROGMEM = {
0xA0,
0x92,
0x09,
0x04,
0x00,
0x40,
0x20,
0x10,
0x40,
0x04,
0x82,
0x09,
0x2A,
0x38,
0x00,
};
const struct IrCode code_na076Code PROGMEM = {
freq_to_timerval(40000),
38, // # of pairs
3, // # of bits per index
code_na017Times,
code_na076Codes
};
/* Duplicate timing table, same as na031 !
const uint16_t code_na077Times[] PROGMEM = {
88, 89,
88, 90,
88, 179,
88, 8977,
177, 90,
};
*/
const uint8_t code_na077Codes[] PROGMEM = {
0x10,
0xA2,
0x62,
0x31,
0x98,
0x51,
0x31,
0x18,
0x00,
};
const struct IrCode code_na077Code PROGMEM = {
freq_to_timerval(35714),
22, // # of pairs
3, // # of bits per index
code_na031Times,
code_na077Codes
};
const uint16_t code_na078Times[] PROGMEM = {
40, 275,
160, 154,
480, 155,
};
const uint8_t code_na078Codes[] PROGMEM = {
0x80,
0x45,
0x04,
0x01,
0x14,
0x10,
0x04,
0x50,
0x40,
};
const struct IrCode code_na078Code PROGMEM = {
freq_to_timerval(38462),
34, // # of pairs
2, // # of bits per index
code_na078Times,
code_na078Codes
};
/* Duplicate timing table, same as na017 !
const uint16_t code_na079Times[] PROGMEM = {
56, 57,
56, 175,
56, 4150,
56, 9499,
898, 227,
898, 449,
};
*/
const uint8_t code_na079Codes[] PROGMEM = {
0xA0,
0x82,
0x08,
0x24,
0x10,
0x41,
0x04,
0x90,
0x08,
0x20,
0x02,
0x41,
0x0A,
0x38,
0x00,
};
const struct IrCode code_na079Code PROGMEM = {
freq_to_timerval(40000),
38, // # of pairs
3, // # of bits per index
code_na017Times,
code_na079Codes
};
/* Duplicate timing table, same as na055 !
const uint16_t code_na080Times[] PROGMEM = {
3, 10,
3, 20,
3, 30,
3, 12778,
};
*/
const uint8_t code_na080Codes[] PROGMEM = {
0x81,
0x50,
0x40,
0xB8,
0x15,
0x04,
0x08,
};
const struct IrCode code_na080Code PROGMEM = {
0, // Non-pulsed code
27, // # of pairs
2, // # of bits per index
code_na055Times,
code_na080Codes
};
const uint16_t code_na081Times[] PROGMEM = {
48, 52,
48, 409,
48, 504,
48, 9978,
};
const uint8_t code_na081Codes[] PROGMEM = {
0x18,
0x46,
0x18,
0x68,
0x47,
0x18,
0x46,
0x18,
0x68,
0x44,
};
const struct IrCode code_na081Code PROGMEM = {
freq_to_timerval(40000),
40, // # of pairs
2, // # of bits per index
code_na081Times,
code_na081Codes
};
const uint16_t code_na082Times[] PROGMEM = {
88, 89,
88, 90,
88, 179,
88, 8888,
177, 90,
177, 179,
};
const uint8_t code_na082Codes[] PROGMEM = {
0x0A,
0x12,
0x49,
0x2A,
0xB2,
0xA1,
0x24,
0x92,
0xA8,
};
const struct IrCode code_na082Code PROGMEM = {
freq_to_timerval(35714),
24, // # of pairs
3, // # of bits per index
code_na082Times,
code_na082Codes
};
/* Duplicate timing table, same as na031 !
const uint16_t code_na083Times[] PROGMEM = {
88, 89,
88, 90,
88, 179,
88, 8977,
177, 90,
};
*/
const uint8_t code_na083Codes[] PROGMEM = {
0x10,
0x92,
0x49,
0x46,
0x33,
0x09,
0x24,
0x94,
0x60,
};
const struct IrCode code_na083Code PROGMEM = {
freq_to_timerval(35714),
24, // # of pairs
3, // # of bits per index
code_na031Times,
code_na083Codes
};
const uint16_t code_na084Times[] PROGMEM = {
41, 43,
41, 128,
41, 7476,
336, 171,
338, 169,
};
const uint8_t code_na084Codes[] PROGMEM = {
0x60,
0x80,
0x00,
0x00,
0x00,
0x08,
0x00,
0x00,
0x40,
0x20,
0x00,
0x00,
0x04,
0x12,
0x48,
0x04,
0x12,
0x08,
0x2A,
0x02,
0x00,
0x00,
0x00,
0x00,
0x20,
0x00,
0x01,
0x00,
0x80,
0x00,
0x00,
0x10,
0x49,
0x20,
0x10,
0x48,
0x20,
0x80,
};
const struct IrCode code_na084Code PROGMEM = {
freq_to_timerval(37037),
100, // # of pairs
3, // # of bits per index
code_na084Times,
code_na084Codes
};
const uint16_t code_na085Times[] PROGMEM = {
55, 60,
55, 165,
55, 2284,
445, 437,
448, 436,
};
const uint8_t code_na085Codes[] PROGMEM = {
0x64,
0x00,
0x00,
0x00,
0x00,
0x40,
0x00,
0x80,
0xA1,
0x00,
0x00,
0x00,
0x00,
0x10,
0x00,
0x20,
0x10,
};
const struct IrCode code_na085Code PROGMEM = {
freq_to_timerval(38462),
44, // # of pairs
3, // # of bits per index
code_na085Times,
code_na085Codes
};
const uint16_t code_na086Times[] PROGMEM = {
42, 46,
42, 126,
42, 6989,
347, 176,
347, 177,
};
const uint8_t code_na086Codes[] PROGMEM = {
0x60,
0x82,
0x08,
0x20,
0x82,
0x41,
0x04,
0x92,
0x00,
0x20,
0x80,
0x40,
0x00,
0x90,
0x40,
0x04,
0x00,
0x41,
0x2A,
0x02,
0x08,
0x20,
0x82,
0x09,
0x04,
0x12,
0x48,
0x00,
0x82,
0x01,
0x00,
0x02,
0x41,
0x00,
0x10,
0x01,
0x04,
0x80,
};
const struct IrCode code_na086Code PROGMEM = {
freq_to_timerval(37175),
100, // # of pairs
3, // # of bits per index
code_na086Times,
code_na086Codes
};
const uint16_t code_na087Times[] PROGMEM = {
56, 69,
56, 174,
56, 4165,
56, 9585,
880, 222,
880, 435,
};
const uint8_t code_na087Codes[] PROGMEM = {
0xA0,
0x02,
0x40,
0x04,
0x90,
0x09,
0x20,
0x02,
0x00,
0x04,
0x90,
0x49,
0x2A,
0x38,
0x00,
};
const struct IrCode code_na087Code PROGMEM = {
freq_to_timerval(38462),
38, // # of pairs
3, // # of bits per index
code_na087Times,
code_na087Codes
};
/* Duplicate timing table, same as na009 !
const uint16_t code_na088Times[] PROGMEM = {
53, 56,
53, 171,
53, 3950,
53, 9599,
898, 451,
900, 226,
};
*/
const uint8_t code_na088Codes[] PROGMEM = {
0x80,
0x00,
0x40,
0x04,
0x12,
0x08,
0x04,
0x92,
0x40,
0x00,
0x00,
0x09,
0x2A,
0xBA,
0x00,
};
const struct IrCode code_na088Code PROGMEM = {
freq_to_timerval(38610),
38, // # of pairs
3, // # of bits per index
code_na009Times,
code_na088Codes
};
/* Duplicate timing table, same as na004 !
const uint16_t code_na089Times[] PROGMEM = {
55, 57,
55, 170,
55, 3949,
55, 9623,
56, 0,
898, 453,
900, 226,
};
*/
const uint8_t code_na089Codes[] PROGMEM = {
0xA0,
0x02,
0x00,
0x04,
0x90,
0x49,
0x20,
0x80,
0x40,
0x04,
0x12,
0x09,
0x2B,
0x3D,
0x00,
};
const struct IrCode code_na089Code PROGMEM = {
freq_to_timerval(38462),
38, // # of pairs
3, // # of bits per index
code_na004Times,
code_na089Codes
};
const uint16_t code_na090Times[] PROGMEM = {
88, 90,
88, 91,
88, 181,
88, 8976,
177, 91,
177, 181,
};
const uint8_t code_na090Codes[] PROGMEM = {
0x10,
0xAB,
0x11,
0x8C,
0xC2,
0xAC,
0x46,
0x00,
};
const struct IrCode code_na090Code PROGMEM = {
freq_to_timerval(35714),
20, // # of pairs
3, // # of bits per index
code_na090Times,
code_na090Codes
};
const uint16_t code_na091Times[] PROGMEM = {
48, 100,
48, 200,
48, 1050,
400, 400,
};
const uint8_t code_na091Codes[] PROGMEM = {
0xD5,
0x41,
0x51,
0x40,
0x14,
0x04,
0x2D,
0x54,
0x15,
0x14,
0x01,
0x40,
0x41,
};
const struct IrCode code_na091Code PROGMEM = {
freq_to_timerval(58824),
52, // # of pairs
2, // # of bits per index
code_na091Times,
code_na091Codes
};
const uint16_t code_na092Times[] PROGMEM = {
54, 56,
54, 170,
54, 4927,
451, 447,
};
const uint8_t code_na092Codes[] PROGMEM = {
0xD1,
0x00,
0x11,
0x00,
0x04,
0x00,
0x11,
0x55,
0x6D,
0x10,
0x01,
0x10,
0x00,
0x40,
0x01,
0x15,
0x55,
};
const struct IrCode code_na092Code PROGMEM = {
freq_to_timerval(38462),
68, // # of pairs
2, // # of bits per index
code_na092Times,
code_na092Codes
};
const uint16_t code_na093Times[] PROGMEM = {
55, 57,
55, 167,
55, 4400,
895, 448,
897, 447,
};
const uint8_t code_na093Codes[] PROGMEM = {
0x60,
0x90,
0x00,
0x20,
0x80,
0x00,
0x04,
0x02,
0x01,
0x00,
0x90,
0x48,
0x2A,
0x02,
0x40,
0x00,
0x82,
0x00,
0x00,
0x10,
0x08,
0x04,
0x02,
0x41,
0x20,
0x80,
};
const struct IrCode code_na093Code PROGMEM = {
freq_to_timerval(38462),
68, // # of pairs
3, // # of bits per index
code_na093Times,
code_na093Codes
};
/* Duplicate timing table, same as na005 !
const uint16_t code_na094Times[] PROGMEM = {
88, 90,
88, 91,
88, 181,
88, 8976,
177, 91,
};
*/
const uint8_t code_na094Codes[] PROGMEM = {
0x10,
0x94,
0x62,
0x31,
0x98,
0x4A,
0x31,
0x18,
0x00,
};
const struct IrCode code_na094Code PROGMEM = {
freq_to_timerval(35714),
22, // # of pairs
3, // # of bits per index
code_na005Times,
code_na094Codes
};
const uint16_t code_na095Times[] PROGMEM = {
56, 58,
56, 174,
56, 4549,
56, 9448,
440, 446,
};
const uint8_t code_na095Codes[] PROGMEM = {
0x80,
0x02,
0x00,
0x00,
0x02,
0x00,
0x04,
0x82,
0x00,
0x00,
0x10,
0x49,
0x2A,
0x17,
0x08,
};
const struct IrCode code_na095Code PROGMEM = {
freq_to_timerval(38462),
40, // # of pairs
3, // # of bits per index
code_na095Times,
code_na095Codes
};
/* Duplicate timing table, same as na009 !
const uint16_t code_na096Times[] PROGMEM = {
53, 56,
53, 171,
53, 3950,
53, 9599,
898, 451,
900, 226,
};
*/
const uint8_t code_na096Codes[] PROGMEM = {
0x80,
0x80,
0x40,
0x04,
0x92,
0x49,
0x20,
0x92,
0x00,
0x04,
0x00,
0x49,
0x2A,
0xBA,
0x00,
};
const struct IrCode code_na096Code PROGMEM = {
freq_to_timerval(38462),
38, // # of pairs
3, // # of bits per index
code_na009Times,
code_na096Codes
};
/* Duplicate timing table, same as na009 !
const uint16_t code_na097Times[] PROGMEM = {
53, 56,
53, 171,
53, 3950,
53, 9599,
898, 451,
900, 226,
};
*/
const uint8_t code_na097Codes[] PROGMEM = {
0x84,
0x80,
0x00,
0x24,
0x10,
0x41,
0x00,
0x80,
0x01,
0x24,
0x12,
0x48,
0x0A,
0xBA,
0x40,
};
const struct IrCode code_na097Code PROGMEM = {
freq_to_timerval(38462),
38, // # of pairs
3, // # of bits per index
code_na009Times,
code_na097Codes
};
/* Duplicate timing table, same as na004 !
const uint16_t code_na098Times[] PROGMEM = {
55, 57,
55, 170,
55, 3949,
55, 9623,
56, 0,
898, 453,
900, 226,
};
*/
const uint8_t code_na098Codes[] PROGMEM = {
0xA0,
0x00,
0x00,
0x04,
0x92,
0x49,
0x24,
0x00,
0x41,
0x00,
0x92,
0x08,
0x2B,
0x3D,
0x00,
};
const struct IrCode code_na098Code PROGMEM = {
freq_to_timerval(38462),
38, // # of pairs
3, // # of bits per index
code_na004Times,
code_na098Codes
};
/* Duplicate timing table, same as na009 !
const uint16_t code_na099Times[] PROGMEM = {
53, 56,
53, 171,
53, 3950,
53, 9599,
898, 451,
900, 226,
};
*/
const uint8_t code_na099Codes[] PROGMEM = {
0x80,
0x00,
0x00,
0x04,
0x12,
0x48,
0x24,
0x00,
0x00,
0x00,
0x92,
0x49,
0x2A,
0xBA,
0x00,
};
const struct IrCode code_na099Code PROGMEM = {
freq_to_timerval(38462),
38, // # of pairs
3, // # of bits per index
code_na009Times,
code_na099Codes
};
const uint16_t code_na100Times[] PROGMEM = {
43, 171,
45, 60,
45, 170,
54, 2301,
};
const uint8_t code_na100Codes[] PROGMEM = {
0x29,
0x59,
0x65,
0x55,
0xEA,
0x56,
0x59,
0x55,
0x70,
};
const struct IrCode code_na100Code PROGMEM = {
freq_to_timerval(35842),
34, // # of pairs
2, // # of bits per index
code_na100Times,
code_na100Codes
};
/* Duplicate timing table, same as na004 !
const uint16_t code_na101Times[] PROGMEM = {
55, 57,
55, 170,
55, 3949,
55, 9623,
56, 0,
898, 453,
900, 226,
};
*/
const uint8_t code_na101Codes[] PROGMEM = {
0xA0,
0x00,
0x09,
0x04,
0x92,
0x40,
0x20,
0x00,
0x00,
0x04,
0x92,
0x49,
0x2B,
0x3D,
0x00,
};
const struct IrCode code_na101Code PROGMEM = {
freq_to_timerval(38462),
38, // # of pairs
3, // # of bits per index
code_na004Times,
code_na101Codes
};
const uint16_t code_na102Times[] PROGMEM = {
86, 87,
86, 258,
86, 3338,
346, 348,
348, 347,
};
const uint8_t code_na102Codes[] PROGMEM = {
0x64,
0x02,
0x08,
0x00,
0x02,
0x09,
0x04,
0x12,
0x49,
0x0A,
0x10,
0x08,
0x20,
0x00,
0x08,
0x24,
0x10,
0x49,
0x24,
0x10,
};
const struct IrCode code_na102Code PROGMEM = {
freq_to_timerval(40000),
52, // # of pairs
3, // # of bits per index
code_na102Times,
code_na102Codes
};
/* Duplicate timing table, same as na045 !
const uint16_t code_na103Times[] PROGMEM = {
58, 53,
58, 167,
58, 4494,
58, 9679,
455, 449,
456, 449,
};
*/
const uint8_t code_na103Codes[] PROGMEM = {
0x80,
0x02,
0x00,
0x00,
0x02,
0x00,
0x04,
0x92,
0x00,
0x00,
0x00,
0x49,
0x2A,
0x97,
0x48,
};
const struct IrCode code_na103Code PROGMEM = {
freq_to_timerval(38462),
40, // # of pairs
3, // # of bits per index
code_na045Times,
code_na103Codes
};
/* Duplicate timing table, same as na017 !
const uint16_t code_na104Times[] PROGMEM = {
56, 57,
56, 175,
56, 4150,
56, 9499,
898, 227,
898, 449,
};
*/
const uint8_t code_na104Codes[] PROGMEM = {
0xA4,
0x00,
0x49,
0x00,
0x92,
0x00,
0x20,
0x02,
0x00,
0x04,
0x90,
0x49,
0x2A,
0x38,
0x40,
};
const struct IrCode code_na104Code PROGMEM = {
freq_to_timerval(40000),
38, // # of pairs
3, // # of bits per index
code_na017Times,
code_na104Codes
};
/* Duplicate timing table, same as na017 !
const uint16_t code_na105Times[] PROGMEM = {
56, 57,
56, 175,
56, 4150,
56, 9499,
898, 227,
898, 449,
};
*/
const uint8_t code_na105Codes[] PROGMEM = {
0xA4,
0x80,
0x00,
0x20,
0x12,
0x49,
0x04,
0x92,
0x49,
0x20,
0x00,
0x00,
0x0A,
0x38,
0x40,
};
const struct IrCode code_na105Code PROGMEM = {
freq_to_timerval(40000),
38, // # of pairs
3, // # of bits per index
code_na017Times,
code_na105Codes
};
/* Duplicate timing table, same as na044 !
const uint16_t code_na106Times[] PROGMEM = {
51, 51,
51, 160,
51, 4096,
51, 9513,
431, 436,
883, 219,
};
*/
const uint8_t code_na106Codes[] PROGMEM = {
0x80,
0x02,
0x00,
0x04,
0x90,
0x49,
0x24,
0x92,
0x00,
0x00,
0x00,
0x49,
0x2A,
0xBA,
0x00,
};
const struct IrCode code_na106Code PROGMEM = {
freq_to_timerval(40000),
38, // # of pairs
3, // # of bits per index
code_na044Times,
code_na106Codes
};
/* Duplicate timing table, same as na045 !
const uint16_t code_na107Times[] PROGMEM = {
58, 53,
58, 167,
58, 4494,
58, 9679,
455, 449,
456, 449,
};
*/
const uint8_t code_na107Codes[] PROGMEM = {
0x80,
0x00,
0x00,
0x00,
0x00,
0x00,
0x04,
0x92,
0x00,
0x00,
0x00,
0x49,
0x2A,
0x97,
0x48,
};
const struct IrCode code_na107Code PROGMEM = {
freq_to_timerval(38462),
40, // # of pairs
3, // # of bits per index
code_na045Times,
code_na107Codes
};
/* Duplicate timing table, same as na045 !
const uint16_t code_na108Times[] PROGMEM = {
58, 53,
58, 167,
58, 4494,
58, 9679,
455, 449,
456, 449,
};
*/
const uint8_t code_na108Codes[] PROGMEM = {
0x80,
0x90,
0x40,
0x00,
0x90,
0x40,
0x04,
0x92,
0x00,
0x00,
0x00,
0x49,
0x2A,
0x97,
0x48,
};
const struct IrCode code_na108Code PROGMEM = {
freq_to_timerval(38462),
40, // # of pairs
3, // # of bits per index
code_na045Times,
code_na108Codes
};
const uint16_t code_na109Times[] PROGMEM = {
58, 61,
58, 211,
58, 9582,
73, 4164,
883, 211,
1050, 494,
};
const uint8_t code_na109Codes[] PROGMEM = {
0xA0,
0x00,
0x08,
0x24,
0x92,
0x41,
0x00,
0x82,
0x00,
0x04,
0x10,
0x49,
0x2E,
0x28,
0x00,
};
const struct IrCode code_na109Code PROGMEM = {
freq_to_timerval(40000),
38, // # of pairs
3, // # of bits per index
code_na109Times,
code_na109Codes
};
/* Duplicate timing table, same as na017 !
const uint16_t code_na110Times[] PROGMEM = {
56, 57,
56, 175,
56, 4150,
56, 9499,
898, 227,
898, 449,
};
*/
const uint8_t code_na110Codes[] PROGMEM = {
0xA4,
0x80,
0x00,
0x20,
0x12,
0x49,
0x00,
0x02,
0x00,
0x04,
0x90,
0x49,
0x2A,
0x38,
0x40,
};
const struct IrCode code_na110Code PROGMEM = {
freq_to_timerval(40161),
38, // # of pairs
3, // # of bits per index
code_na017Times,
code_na110Codes
};
/* Duplicate timing table, same as na044 !
const uint16_t code_na111Times[] PROGMEM = {
51, 51,
51, 160,
51, 4096,
51, 9513,
431, 436,
883, 219,
};
*/
const uint8_t code_na111Codes[] PROGMEM = {
0x84,
0x92,
0x49,
0x20,
0x00,
0x00,
0x04,
0x92,
0x00,
0x00,
0x00,
0x49,
0x2A,
0xBA,
0x40,
};
const struct IrCode code_na111Code PROGMEM = {
freq_to_timerval(40000),
38, // # of pairs
3, // # of bits per index
code_na044Times,
code_na111Codes
};
/* Duplicate timing table, same as na004 !
const uint16_t code_na112Times[] PROGMEM = {
55, 57,
55, 170,
55, 3949,
55, 9623,
56, 0,
898, 453,
900, 226,
};
*/
const uint8_t code_na112Codes[] PROGMEM = {
0xA4,
0x00,
0x00,
0x00,
0x92,
0x49,
0x24,
0x00,
0x00,
0x00,
0x92,
0x49,
0x2B,
0x3D,
0x00,
};
const struct IrCode code_na112Code PROGMEM = {
freq_to_timerval(38462),
38, // # of pairs
3, // # of bits per index
code_na004Times,
code_na112Codes
};
const uint16_t code_na113Times[] PROGMEM = {
56, 54,
56, 166,
56, 3945,
896, 442,
896, 443,
};
const uint8_t code_na113Codes[] PROGMEM = {
0x60,
0x00,
0x00,
0x20,
0x02,
0x09,
0x04,
0x02,
0x01,
0x00,
0x90,
0x48,
0x2A,
0x00,
0x00,
0x00,
0x80,
0x08,
0x24,
0x10,
0x08,
0x04,
0x02,
0x41,
0x20,
0x80,
};
const struct IrCode code_na113Code PROGMEM = {
freq_to_timerval(40000),
68, // # of pairs
3, // # of bits per index
code_na113Times,
code_na113Codes
};
const uint16_t code_na114Times[] PROGMEM = {
44, 50,
44, 147,
44, 447,
44, 2236,
791, 398,
793, 397,
};
const uint8_t code_na114Codes[] PROGMEM = {
0x84,
0x10,
0x40,
0x08,
0x82,
0x08,
0x01,
0xD2,
0x08,
0x20,
0x04,
0x41,
0x04,
0x00,
0x40,
};
const struct IrCode code_na114Code PROGMEM = {
freq_to_timerval(40000),
38, // # of pairs
3, // # of bits per index
code_na114Times,
code_na114Codes
};
const uint16_t code_na115Times[] PROGMEM = {
81, 86,
81, 296,
81, 3349,
328, 331,
329, 331,
};
const uint8_t code_na115Codes[] PROGMEM = {
0x60,
0x82,
0x00,
0x20,
0x80,
0x41,
0x04,
0x90,
0x41,
0x2A,
0x02,
0x08,
0x00,
0x82,
0x01,
0x04,
0x12,
0x41,
0x04,
0x80,
};
const struct IrCode code_na115Code PROGMEM = {
freq_to_timerval(40000),
52, // # of pairs
3, // # of bits per index
code_na115Times,
code_na115Codes
};
/* Duplicate timing table, same as na017 !
const uint16_t code_na116Times[] PROGMEM = {
56, 57,
56, 175,
56, 4150,
56, 9499,
898, 227,
898, 449,
};
*/
const uint8_t code_na116Codes[] PROGMEM = {
0xA0,
0x00,
0x40,
0x04,
0x92,
0x09,
0x24,
0x00,
0x40,
0x00,
0x92,
0x09,
0x2A,
0x38,
0x00,
};
const struct IrCode code_na116Code PROGMEM = {
freq_to_timerval(40000),
38, // # of pairs
3, // # of bits per index
code_na017Times,
code_na116Codes
};
const uint16_t code_na117Times[] PROGMEM = {
49, 54,
49, 158,
49, 420,
49, 2446,
819, 420,
821, 419,
};
const uint8_t code_na117Codes[] PROGMEM = {
0x84,
0x00,
0x00,
0x08,
0x12,
0x40,
0x01,
0xD2,
0x00,
0x00,
0x04,
0x09,
0x20,
0x00,
0x40,
};
const struct IrCode code_na117Code PROGMEM = {
freq_to_timerval(41667),
38, // # of pairs
3, // # of bits per index
code_na117Times,
code_na117Codes
};
/* Duplicate timing table, same as na044 !
const uint16_t code_na118Times[] PROGMEM = {
51, 51,
51, 160,
51, 4096,
51, 9513,
431, 436,
883, 219,
};
*/
const uint8_t code_na118Codes[] PROGMEM = {
0x84,
0x90,
0x49,
0x20,
0x02,
0x00,
0x04,
0x92,
0x00,
0x00,
0x00,
0x49,
0x2A,
0xBA,
0x40,
};
const struct IrCode code_na118Code PROGMEM = {
freq_to_timerval(40000),
38, // # of pairs
3, // # of bits per index
code_na044Times,
code_na118Codes
};
const uint16_t code_na119Times[] PROGMEM = {
55, 63,
55, 171,
55, 4094,
55, 9508,
881, 219,
881, 438,
};
const uint8_t code_na119Codes[] PROGMEM = {
0xA0,
0x10,
0x00,
0x04,
0x82,
0x49,
0x20,
0x02,
0x00,
0x04,
0x90,
0x49,
0x2A,
0x38,
0x00,
};
const struct IrCode code_na119Code PROGMEM = {
freq_to_timerval(55556),
38, // # of pairs
3, // # of bits per index
code_na119Times,
code_na119Codes
};
/* Duplicate timing table, same as na017 !
const uint16_t code_na120Times[] PROGMEM = {
56, 57,
56, 175,
56, 4150,
56, 9499,
898, 227,
898, 449,
};
*/
const uint8_t code_na120Codes[] PROGMEM = {
0xA0,
0x12,
0x00,
0x04,
0x80,
0x49,
0x24,
0x92,
0x40,
0x00,
0x00,
0x09,
0x2A,
0x38,
0x00,
};
const struct IrCode code_na120Code PROGMEM = {
freq_to_timerval(40000),
38, // # of pairs
3, // # of bits per index
code_na017Times,
code_na120Codes
};
/* Duplicate timing table, same as na017 !
const uint16_t code_na121Times[] PROGMEM = {
56, 57,
56, 175,
56, 4150,
56, 9499,
898, 227,
898, 449,
};
*/
const uint8_t code_na121Codes[] PROGMEM = {
0xA0,
0x00,
0x40,
0x04,
0x92,
0x09,
0x20,
0x02,
0x00,
0x04,
0x90,
0x49,
0x2A,
0x38,
0x00,
};
const struct IrCode code_na121Code PROGMEM = {
freq_to_timerval(40000),
38, // # of pairs
3, // # of bits per index
code_na017Times,
code_na121Codes
};
const uint16_t code_na122Times[] PROGMEM = {
80, 95,
80, 249,
80, 3867,
81, 0,
329, 322,
};
const uint8_t code_na122Codes[] PROGMEM = {
0x80,
0x00,
0x00,
0x00,
0x12,
0x49,
0x24,
0x90,
0x0A,
0x80,
0x00,
0x00,
0x00,
0x12,
0x49,
0x24,
0x90,
0x0B,
};
const struct IrCode code_na122Code PROGMEM = {
freq_to_timerval(52632),
48, // # of pairs
3, // # of bits per index
code_na122Times,
code_na122Codes
};
/* Duplicate timing table, same as na017 !
const uint16_t code_na123Times[] PROGMEM = {
56, 57,
56, 175,
56, 4150,
56, 9499,
898, 227,
898, 449,
};
*/
const uint8_t code_na123Codes[] PROGMEM = {
0xA0,
0x02,
0x48,
0x04,
0x90,
0x01,
0x20,
0x12,
0x40,
0x04,
0x80,
0x09,
0x2A,
0x38,
0x00,
};
const struct IrCode code_na123Code PROGMEM = {
freq_to_timerval(40000),
38, // # of pairs
3, // # of bits per index
code_na017Times,
code_na123Codes
};
const uint16_t code_na124Times[] PROGMEM = {
54, 56,
54, 151,
54, 4092,
54, 8677,
900, 421,
901, 226,
};
const uint8_t code_na124Codes[] PROGMEM = {
0x80,
0x00,
0x48,
0x04,
0x92,
0x01,
0x20,
0x00,
0x00,
0x04,
0x92,
0x49,
0x2A,
0xBA,
0x00,
};
const struct IrCode code_na124Code PROGMEM = {
freq_to_timerval(40000),
38, // # of pairs
3, // # of bits per index
code_na124Times,
code_na124Codes
};
/* Duplicate timing table, same as na119 !
const uint16_t code_na125Times[] PROGMEM = {
55, 63,
55, 171,
55, 4094,
55, 9508,
881, 219,
881, 438,
};
*/
const uint8_t code_na125Codes[] PROGMEM = {
0xA0,
0x02,
0x48,
0x04,
0x90,
0x01,
0x20,
0x80,
0x40,
0x04,
0x12,
0x09,
0x2A,
0x38,
0x00,
};
const struct IrCode code_na125Code PROGMEM = {
freq_to_timerval(55556),
38, // # of pairs
3, // # of bits per index
code_na119Times,
code_na125Codes
};
/* Duplicate timing table, same as na017 !
const uint16_t code_na126Times[] PROGMEM = {
56, 57,
56, 175,
56, 4150,
56, 9499,
898, 227,
898, 449,
};
*/
const uint8_t code_na126Codes[] PROGMEM = {
0xA4,
0x10,
0x00,
0x20,
0x82,
0x49,
0x00,
0x02,
0x00,
0x04,
0x90,
0x49,
0x2A,
0x38,
0x40,
};
const struct IrCode code_na126Code PROGMEM = {
freq_to_timerval(40000),
38, // # of pairs
3, // # of bits per index
code_na017Times,
code_na126Codes
};
const uint16_t code_na127Times[] PROGMEM = {
114, 100,
115, 100,
115, 200,
115, 2706,
};
const uint8_t code_na127Codes[] PROGMEM = {
0x1B,
0x59,
};
const struct IrCode code_na127Code PROGMEM = {
freq_to_timerval(25641),
8, // # of pairs
2, // # of bits per index
code_na127Times,
code_na127Codes
};
/* Duplicate timing table, same as na102 !
const uint16_t code_na128Times[] PROGMEM = {
86, 87,
86, 258,
86, 3338,
346, 348,
348, 347,
};
*/
const uint8_t code_na128Codes[] PROGMEM = {
0x60,
0x02,
0x08,
0x00,
0x02,
0x49,
0x04,
0x12,
0x49,
0x0A,
0x00,
0x08,
0x20,
0x00,
0x09,
0x24,
0x10,
0x49,
0x24,
0x00,
};
const struct IrCode code_na128Code PROGMEM = {
freq_to_timerval(40000),
52, // # of pairs
3, // # of bits per index
code_na102Times,
code_na128Codes
};
/* Duplicate timing table, same as na017 !
const uint16_t code_na129Times[] PROGMEM = {
56, 57,
56, 175,
56, 4150,
56, 9499,
898, 227,
898, 449,
};
*/
const uint8_t code_na129Codes[] PROGMEM = {
0xA4,
0x92,
0x49,
0x20,
0x00,
0x00,
0x00,
0x02,
0x00,
0x04,
0x90,
0x49,
0x2A,
0x38,
0x40,
};
const struct IrCode code_na129Code PROGMEM = {
freq_to_timerval(40000),
38, // # of pairs
3, // # of bits per index
code_na017Times,
code_na129Codes
};
const uint16_t code_na130Times[] PROGMEM = {
88, 90,
88, 258,
88, 2247,
358, 349,
358, 350,
};
const uint8_t code_na130Codes[] PROGMEM = {
0x64,
0x00,
0x08,
0x24,
0x82,
0x09,
0x24,
0x10,
0x01,
0x0A,
0x10,
0x00,
0x20,
0x92,
0x08,
0x24,
0x90,
0x40,
0x04,
0x10,
};
const struct IrCode code_na130Code PROGMEM = {
freq_to_timerval(37037),
52, // # of pairs
3, // # of bits per index
code_na130Times,
code_na130Codes
};
/* Duplicate timing table, same as na042 !
const uint16_t code_na131Times[] PROGMEM = {
54, 65,
54, 170,
54, 4099,
54, 8668,
899, 226,
899, 421,
};
*/
const uint8_t code_na131Codes[] PROGMEM = {
0xA0,
0x10,
0x40,
0x04,
0x82,
0x09,
0x24,
0x82,
0x40,
0x00,
0x10,
0x09,
0x2A,
0x38,
0x00,
};
const struct IrCode code_na131Code PROGMEM = {
freq_to_timerval(40000),
38, // # of pairs
3, // # of bits per index
code_na042Times,
code_na131Codes
};
const uint16_t code_na132Times[] PROGMEM = {
28, 106,
28, 238,
28, 370,
28, 1173,
};
const uint8_t code_na132Codes[] PROGMEM = {
0x22,
0x20,
0x00,
0x17,
0x22,
0x20,
0x00,
0x14,
};
const struct IrCode code_na132Code PROGMEM = {
freq_to_timerval(83333),
32, // # of pairs
2, // # of bits per index
code_na132Times,
code_na132Codes
};
const uint16_t code_na133Times[] PROGMEM = {
13, 741,
15, 489,
15, 740,
17, 4641,
18, 0,
};
const uint8_t code_na133Codes[] PROGMEM = {
0x09,
0x24,
0x49,
0x48,
0xB4,
0x92,
0x44,
0x94,
0x8C,
};
const struct IrCode code_na133Code PROGMEM = {
freq_to_timerval(41667),
24, // # of pairs
3, // # of bits per index
code_na133Times,
code_na133Codes
};
/* Duplicate timing table, same as na113 !
const uint16_t code_na134Times[] PROGMEM = {
56, 54,
56, 166,
56, 3945,
896, 442,
896, 443,
};
*/
const uint8_t code_na134Codes[] PROGMEM = {
0x60,
0x90,
0x00,
0x24,
0x10,
0x00,
0x04,
0x92,
0x00,
0x00,
0x00,
0x49,
0x2A,
0x02,
0x40,
0x00,
0x90,
0x40,
0x00,
0x12,
0x48,
0x00,
0x00,
0x01,
0x24,
0x80,
};
const struct IrCode code_na134Code PROGMEM = {
freq_to_timerval(40000),
68, // # of pairs
3, // # of bits per index
code_na113Times,
code_na134Codes
};
const uint16_t code_na135Times[] PROGMEM = {
53, 59,
53, 171,
53, 2301,
892, 450,
895, 448,
};
const uint8_t code_na135Codes[] PROGMEM = {
0x60,
0x12,
0x49,
0x00,
0x00,
0x09,
0x00,
0x00,
0x49,
0x24,
0x80,
0x00,
0x00,
0x12,
0x49,
0x24,
0xA8,
0x01,
0x24,
0x90,
0x00,
0x00,
0x90,
0x00,
0x04,
0x92,
0x48,
0x00,
0x00,
0x01,
0x24,
0x92,
0x48,
};
const struct IrCode code_na135Code PROGMEM = {
freq_to_timerval(38462),
88, // # of pairs
3, // # of bits per index
code_na135Times,
code_na135Codes
};
const uint16_t code_na136Times[] PROGMEM = {
53, 59,
53, 171,
53, 2301,
55, 0,
892, 450,
895, 448,
};
const uint8_t code_na136Codes[] PROGMEM = {
0x84,
0x82,
0x49,
0x00,
0x00,
0x00,
0x20,
0x00,
0x49,
0x24,
0x80,
0x00,
0x00,
0x12,
0x49,
0x24,
0xAA,
0x48,
0x24,
0x90,
0x00,
0x00,
0x02,
0x00,
0x04,
0x92,
0x48,
0x00,
0x00,
0x01,
0x24,
0x92,
0x4B,
};
const struct IrCode code_na136Code PROGMEM = {
freq_to_timerval(38610),
88, // # of pairs
3, // # of bits per index
code_na136Times,
code_na136Codes
};
const uint16_t code_eu000Times[] PROGMEM = {
43, 47,
43, 91,
43, 8324,
88, 47,
133, 133,
264, 90,
264, 91,
};
const uint8_t code_eu000Codes[] PROGMEM = {
0xA4,
0x08,
0x00,
0x00,
0x00,
0x00,
0x64,
0x2C,
0x40,
0x80,
0x00,
0x00,
0x00,
0x06,
0x41,
};
const struct IrCode code_eu000Code PROGMEM = {
freq_to_timerval(35714),
40, // # of pairs
3, // # of bits per index
code_eu000Times,
code_eu000Codes
};
const uint16_t code_eu001Times[] PROGMEM = {
47, 265,
51, 54,
51, 108,
51, 263,
51, 2053,
51, 11647,
100, 109,
};
const uint8_t code_eu001Codes[] PROGMEM = {
0x04,
0x92,
0x49,
0x26,
0x35,
0x89,
0x24,
0x9A,
0xD6,
0x24,
0x92,
0x48,
};
const struct IrCode code_eu001Code PROGMEM = {
freq_to_timerval(30303),
31, // # of pairs
3, // # of bits per index
code_eu001Times,
code_eu001Codes
};
const uint16_t code_eu002Times[] PROGMEM = {
43, 206,
46, 204,
46, 456,
46, 3488,
};
const uint8_t code_eu002Codes[] PROGMEM = {
0x1A,
0x56,
0xA6,
0xD6,
0x95,
0xA9,
0x90,
};
const struct IrCode code_eu002Code PROGMEM = {
freq_to_timerval(33333),
26, // # of pairs
2, // # of bits per index
code_eu002Times,
code_eu002Codes
};
/* Duplicate timing table, same as na000 !
const uint16_t code_eu003Times[] PROGMEM = {
58, 60,
58, 2687,
118, 60,
237, 60,
238, 60,
};
*/
/*
const uint8_t code_eu003Codes[] PROGMEM = {
0x68,
0x20,
0x80,
0x40,
0x03,
0x10,
0x41,
0x00,
0x80,
0x00,
};
const struct IrCode code_eu003Code PROGMEM = {
freq_to_timerval(38462),
26, // # of pairs
3, // # of bits per index
code_na000Times,
code_eu003Codes
};// Duplicate IR Code - same as na000
*/
const uint16_t code_eu004Times[] PROGMEM = {
44, 45,
44, 131,
44, 7462,
346, 176,
346, 178,
};
const uint8_t code_eu004Codes[] PROGMEM = {
0x60,
0x80,
0x00,
0x00,
0x00,
0x08,
0x00,
0x00,
0x00,
0x20,
0x00,
0x00,
0x04,
0x12,
0x48,
0x04,
0x12,
0x48,
0x2A,
0x02,
0x00,
0x00,
0x00,
0x00,
0x20,
0x00,
0x00,
0x00,
0x80,
0x00,
0x00,
0x10,
0x49,
0x20,
0x10,
0x49,
0x20,
0x80,
};
const struct IrCode code_eu004Code PROGMEM = {
freq_to_timerval(37037),
100, // # of pairs
3, // # of bits per index
code_eu004Times,
code_eu004Codes
};// Duplicate IR Code? Similar to NA002
const uint16_t code_eu005Times[] PROGMEM = {
24, 190,
25, 80,
25, 190,
25, 4199,
25, 4799,
};
const uint8_t code_eu005Codes[] PROGMEM = {
0x04,
0x92,
0x52,
0x28,
0x92,
0x8C,
0x44,
0x92,
0x89,
0x45,
0x24,
0x53,
0x44,
0x92,
0x52,
0x28,
0x92,
0x8C,
0x44,
0x92,
0x89,
0x45,
0x24,
0x51,
};
const struct IrCode code_eu005Code PROGMEM = {
freq_to_timerval(38610),
64, // # of pairs
3, // # of bits per index
code_eu005Times,
code_eu005Codes
};
const uint16_t code_eu006Times[] PROGMEM = {
53, 63,
53, 172,
53, 4472,
54, 0,
455, 468,
};
const uint8_t code_eu006Codes[] PROGMEM = {
0x84,
0x90,
0x00,
0x04,
0x90,
0x00,
0x00,
0x80,
0x00,
0x04,
0x12,
0x49,
0x2A,
0x12,
0x40,
0x00,
0x12,
0x40,
0x00,
0x02,
0x00,
0x00,
0x10,
0x49,
0x24,
0xB0,
};
const struct IrCode code_eu006Code PROGMEM = {
freq_to_timerval(38462),
68, // # of pairs
3, // # of bits per index
code_eu006Times,
code_eu006Codes
};
const uint16_t code_eu007Times[] PROGMEM = {
50, 54,
50, 159,
50, 2307,
838, 422,
};
const uint8_t code_eu007Codes[] PROGMEM = {
0xD4,
0x00,
0x15,
0x10,
0x25,
0x00,
0x05,
0x44,
0x09,
0x40,
0x01,
0x51,
0x01,
};
const struct IrCode code_eu007Code PROGMEM = {
freq_to_timerval(38462),
52, // # of pairs
2, // # of bits per index
code_eu007Times,
code_eu007Codes
};// Duplicate IR Code? - Similar to NA010
/* Duplicate timing table, same as na004 !
const uint16_t code_eu008Times[] PROGMEM = {
55, 57,
55, 170,
55, 3949,
55, 9623,
56, 0,
898, 453,
900, 226,
};
*/
const uint8_t code_eu008Codes[] PROGMEM = {
0xA0,
0x00,
0x41,
0x04,
0x92,
0x08,
0x24,
0x90,
0x40,
0x00,
0x02,
0x09,
0x2B,
0x3D,
0x00,
};
const struct IrCode code_eu008Code PROGMEM = {
freq_to_timerval(38462),
38, // # of pairs
3, // # of bits per index
code_na004Times,
code_eu008Codes
};
/* Duplicate timing table, same as na005 !
const uint16_t code_eu009Times[] PROGMEM = {
88, 90,
88, 91,
88, 181,
88, 8976,
177, 91,
};
*/
/*
const uint8_t code_eu009Codes[] PROGMEM = {
0x10,
0x92,
0x49,
0x46,
0x33,
0x09,
0x24,
0x94,
0x60,
};
const struct IrCode code_eu009Code PROGMEM = {
freq_to_timerval(35714),
24, // # of pairs
3, // # of bits per index
code_na005Times,
code_eu009Codes
};// Duplicate IR Code - same as na005
*/
/* Duplicate timing table, same as na004 !
const uint16_t code_eu010Times[] PROGMEM = {
55, 57,
55, 170,
55, 3949,
55, 9623,
56, 0,
898, 453,
900, 226,
};
*/
/*
const uint8_t code_eu010Codes[] PROGMEM = {
0xA0,
0x00,
0x01,
0x04,
0x92,
0x48,
0x20,
0x80,
0x40,
0x04,
0x12,
0x09,
0x2B,
0x3D,
0x00,
};
const struct IrCode code_eu010Code PROGMEM = {
freq_to_timerval(38462),
38, // # of pairs
3, // # of bits per index
code_na004Times,
code_eu010Codes
};// Duplicate IR Code - same as NA004
*/
/* Duplicate timing table, same as na009 !
const uint16_t code_eu011Times[] PROGMEM = {
53, 56,
53, 171,
53, 3950,
53, 9599,
898, 451,
900, 226,
};
*/
const uint8_t code_eu011Codes[] PROGMEM = {
0x84,
0x00,
0x48,
0x04,
0x02,
0x01,
0x04,
0x80,
0x09,
0x00,
0x12,
0x40,
0x2A,
0xBA,
0x40,
};
const struct IrCode code_eu011Code PROGMEM = {
freq_to_timerval(38462),
38, // # of pairs
3, // # of bits per index
code_na009Times,
code_eu011Codes
};
const uint16_t code_eu012Times[] PROGMEM = {
46, 206,
46, 459,
46, 3447,
};
const uint8_t code_eu012Codes[] PROGMEM = {
0x05,
0x01,
0x51,
0x81,
0x40,
0x54,
0x40,
};
const struct IrCode code_eu012Code PROGMEM = {
freq_to_timerval(33445),
26, // # of pairs
2, // # of bits per index
code_eu012Times,
code_eu012Codes
};
const uint16_t code_eu013Times[] PROGMEM = {
53, 59,
53, 171,
53, 2302,
895, 449,
};
const uint8_t code_eu013Codes[] PROGMEM = {
0xD4,
0x55,
0x00,
0x00,
0x40,
0x15,
0x54,
0x00,
0x01,
0x55,
0x56,
0xD4,
0x55,
0x00,
0x00,
0x40,
0x15,
0x54,
0x00,
0x01,
0x55,
0x55,
};
const struct IrCode code_eu013Code PROGMEM = {
freq_to_timerval(38462),
88, // # of pairs
2, // # of bits per index
code_eu013Times,
code_eu013Codes
};
/* Duplicate timing table, same as na021 !
const uint16_t code_eu014Times[] PROGMEM = {
48, 52,
48, 160,
48, 400,
48, 2335,
799, 400,
};
*/
/*
const uint8_t code_eu014Codes[] PROGMEM = {
0x80,
0x10,
0x40,
0x08,
0x82,
0x08,
0x01,
0xC0,
0x08,
0x20,
0x04,
0x41,
0x04,
0x00,
0x00,
};
const struct IrCode code_eu014Code PROGMEM = {
freq_to_timerval(38462),
38, // # of pairs
3, // # of bits per index
code_na021Times,
code_eu014Codes
};// Duplicate IR Code - same as NA021
*/
const uint16_t code_eu015Times[] PROGMEM = {
53, 54,
53, 156,
53, 2542,
851, 425,
853, 424,
};
const uint8_t code_eu015Codes[] PROGMEM = {
0x60,
0x82,
0x08,
0x24,
0x10,
0x41,
0x00,
0x12,
0x40,
0x04,
0x80,
0x09,
0x2A,
0x02,
0x08,
0x20,
0x90,
0x41,
0x04,
0x00,
0x49,
0x00,
0x12,
0x00,
0x24,
0xA8,
0x08,
0x20,
0x82,
0x41,
0x04,
0x10,
0x01,
0x24,
0x00,
0x48,
0x00,
0x92,
0xA0,
0x20,
0x82,
0x09,
0x04,
0x10,
0x40,
0x04,
0x90,
0x01,
0x20,
0x02,
0x48,
};
const struct IrCode code_eu015Code PROGMEM = {
freq_to_timerval(38462),
136, // # of pairs
3, // # of bits per index
code_eu015Times,
code_eu015Codes
};// Duplicate IR Code? - Similar to NA018
const uint16_t code_eu016Times[] PROGMEM = {
28, 92,
28, 213,
28, 214,
28, 2771,
};
const uint8_t code_eu016Codes[] PROGMEM = {
0x68,
0x08,
0x20,
0x00,
0xEA,
0x02,
0x08,
0x00,
0x10,
};
const struct IrCode code_eu016Code PROGMEM = {
freq_to_timerval(33333),
34, // # of pairs
2, // # of bits per index
code_eu016Times,
code_eu016Codes
};
const uint16_t code_eu017Times[] PROGMEM = {
15, 844,
16, 557,
16, 844,
16, 5224,
};
const uint8_t code_eu017Codes[] PROGMEM = {
0x1A,
0x9A,
0x9B,
0x9A,
0x9A,
0x99,
};
const struct IrCode code_eu017Code PROGMEM = {
freq_to_timerval(33333),
24, // # of pairs
2, // # of bits per index
code_eu017Times,
code_eu017Codes
};
/* Duplicate timing table, same as na004 !
const uint16_t code_eu018Times[] PROGMEM = {
55, 57,
55, 170,
55, 3949,
55, 9623,
56, 0,
898, 453,
900, 226,
};
*/
const uint8_t code_eu018Codes[] PROGMEM = {
0xA0,
0x02,
0x48,
0x04,
0x90,
0x01,
0x20,
0x12,
0x40,
0x04,
0x80,
0x09,
0x2B,
0x3D,
0x00,
};
const struct IrCode code_eu018Code PROGMEM = {
freq_to_timerval(38462),
38, // # of pairs
3, // # of bits per index
code_na004Times,
code_eu018Codes
};
const uint16_t code_eu019Times[] PROGMEM = {
50, 54,
50, 158,
50, 418,
50, 2443,
843, 418,
};
const uint8_t code_eu019Codes[] PROGMEM = {
0x80,
0x80,
0x00,
0x08,
0x12,
0x40,
0x01,
0xC0,
0x40,
0x00,
0x04,
0x09,
0x20,
0x00,
0x00,
};
const struct IrCode code_eu019Code PROGMEM = {
freq_to_timerval(38462),
38, // # of pairs
3, // # of bits per index
code_eu019Times,
code_eu019Codes
};
const uint16_t code_eu020Times[] PROGMEM = {
48, 301,
48, 651,
48, 1001,
48, 3001,
};
const uint8_t code_eu020Codes[] PROGMEM = {
0x22,
0x20,
0x00,
0x01,
0xC8,
0x88,
0x00,
0x00,
0x40,
};
const struct IrCode code_eu020Code PROGMEM = {
freq_to_timerval(35714),
34, // # of pairs
2, // # of bits per index
code_eu020Times,
code_eu020Codes
};
/* Duplicate timing table, same as na009 !
const uint16_t code_eu021Times[] PROGMEM = {
53, 56,
53, 171,
53, 3950,
53, 9599,
898, 451,
900, 226,
};
*/
const uint8_t code_eu021Codes[] PROGMEM = {
0x84,
0x80,
0x00,
0x20,
0x82,
0x49,
0x00,
0x02,
0x00,
0x04,
0x90,
0x49,
0x2A,
0xBA,
0x40,
};
const struct IrCode code_eu021Code PROGMEM = {
freq_to_timerval(38462),
38, // # of pairs
3, // # of bits per index
code_na009Times,
code_eu021Codes
};
/* Duplicate timing table, same as na004 !
const uint16_t code_eu022Times[] PROGMEM = {
55, 57,
55, 170,
55, 3949,
55, 9623,
56, 0,
898, 453,
900, 226,
};
*/
const uint8_t code_eu022Codes[] PROGMEM = {
0xA4,
0x80,
0x41,
0x00,
0x12,
0x08,
0x24,
0x90,
0x40,
0x00,
0x02,
0x09,
0x2B,
0x3D,
0x00,
};
const struct IrCode code_eu022Code PROGMEM = {
freq_to_timerval(38462),
38, // # of pairs
3, // # of bits per index
code_na004Times,
code_eu022Codes
};
/* Duplicate timing table, same as na022 !
const uint16_t code_eu023Times[] PROGMEM = {
53, 60,
53, 175,
53, 4463,
53, 9453,
892, 450,
895, 225,
};
*/
/*
const uint8_t code_eu023Codes[] PROGMEM = {
0x80,
0x02,
0x40,
0x00,
0x02,
0x40,
0x00,
0x00,
0x01,
0x24,
0x92,
0x48,
0x0A,
0xBA,
0x00,
};
const struct IrCode code_eu023Code PROGMEM = {
freq_to_timerval(38462),
38, // # of pairs
3, // # of bits per index
code_na022Times,
code_eu023Codes
};// Duplicate IR Code - Same as NA022
*/
/* Duplicate timing table, same as na004 !
const uint16_t code_eu024Times[] PROGMEM = {
55, 57,
55, 170,
55, 3949,
55, 9623,
56, 0,
898, 453,
900, 226,
};
*/
const uint8_t code_eu024Codes[] PROGMEM = {
0xA0,
0x02,
0x48,
0x04,
0x90,
0x01,
0x20,
0x00,
0x40,
0x04,
0x92,
0x09,
0x2B,
0x3D,
0x00,
};
const struct IrCode code_eu024Code PROGMEM = {
freq_to_timerval(38462),
38, // # of pairs
3, // # of bits per index
code_na004Times,
code_eu024Codes
};
const uint16_t code_eu025Times[] PROGMEM = {
49, 52,
49, 102,
49, 250,
49, 252,
49, 2377,
49, 12009,
100, 52,
100, 102,
};
const uint8_t code_eu025Codes[] PROGMEM = {
0x47,
0x00,
0x23,
0x3C,
0x01,
0x59,
0xE0,
0x04,
};
const struct IrCode code_eu025Code PROGMEM = {
freq_to_timerval(31250),
21, // # of pairs
3, // # of bits per index
code_eu025Times,
code_eu025Codes
};
const uint16_t code_eu026Times[] PROGMEM = {
14, 491,
14, 743,
14, 4926,
};
const uint8_t code_eu026Codes[] PROGMEM = {
0x55,
0x40,
0x42,
0x55,
0x40,
0x41,
};
const struct IrCode code_eu026Code PROGMEM = {
freq_to_timerval(38462),
24, // # of pairs
2, // # of bits per index
code_eu026Times,
code_eu026Codes
};
/* Duplicate timing table, same as na004 !
const uint16_t code_eu027Times[] PROGMEM = {
55, 57,
55, 170,
55, 3949,
55, 9623,
56, 0,
898, 453,
900, 226,
};
*/
const uint8_t code_eu027Codes[] PROGMEM = {
0xA0,
0x82,
0x08,
0x24,
0x10,
0x41,
0x04,
0x10,
0x01,
0x20,
0x82,
0x48,
0x0B,
0x3D,
0x00,
};
const struct IrCode code_eu027Code PROGMEM = {
freq_to_timerval(38462),
38, // # of pairs
3, // # of bits per index
code_na004Times,
code_eu027Codes
};
const uint16_t code_eu028Times[] PROGMEM = {
47, 267,
50, 55,
50, 110,
50, 265,
50, 2055,
50, 12117,
100, 57,
};
const uint8_t code_eu028Codes[] PROGMEM = {
0x04,
0x92,
0x49,
0x26,
0x34,
0x72,
0x24,
0x9A,
0xD1,
0xC8,
0x92,
0x48,
};
const struct IrCode code_eu028Code PROGMEM = {
freq_to_timerval(30303),
31, // # of pairs
3, // # of bits per index
code_eu028Times,
code_eu028Codes
};
const uint16_t code_eu029Times[] PROGMEM = {
50, 50,
50, 99,
50, 251,
50, 252,
50, 1445,
50, 11014,
102, 49,
102, 98,
};
const uint8_t code_eu029Codes[] PROGMEM = {
0x47,
0x00,
0x00,
0x00,
0x00,
0x04,
0x64,
0x62,
0x00,
0xE0,
0x00,
0x2B,
0x23,
0x10,
0x07,
0x00,
0x00,
0x80,
};
const struct IrCode code_eu029Code PROGMEM = {
freq_to_timerval(34483),
46, // # of pairs
3, // # of bits per index
code_eu029Times,
code_eu029Codes
};
/* Duplicate timing table, same as na004 !
const uint16_t code_eu030Times[] PROGMEM = {
55, 57,
55, 170,
55, 3949,
55, 9623,
56, 0,
898, 453,
900, 226,
};
*/
const uint8_t code_eu030Codes[] PROGMEM = {
0xA0,
0x10,
0x00,
0x04,
0x82,
0x49,
0x20,
0x02,
0x00,
0x04,
0x90,
0x49,
0x2B,
0x3D,
0x00,
};
const struct IrCode code_eu030Code PROGMEM = {
freq_to_timerval(38462),
38, // # of pairs
3, // # of bits per index
code_na004Times,
code_eu030Codes
};// Duplicate IR Code? - Smilar to NA020
const uint16_t code_eu031Times[] PROGMEM = {
53, 53,
53, 160,
53, 1697,
838, 422,
};
const uint8_t code_eu031Codes[] PROGMEM = {
0xD5,
0x50,
0x15,
0x11,
0x65,
0x54,
0x05,
0x44,
0x59,
0x55,
0x01,
0x51,
0x15,
};
const struct IrCode code_eu031Code PROGMEM = {
freq_to_timerval(38462),
52, // # of pairs
2, // # of bits per index
code_eu031Times,
code_eu031Codes
};
const uint16_t code_eu032Times[] PROGMEM = {
49, 205,
49, 206,
49, 456,
49, 3690,
};
const uint8_t code_eu032Codes[] PROGMEM = {
0x1A,
0x56,
0xA5,
0xD6,
0x95,
0xA9,
0x40,
};
const struct IrCode code_eu032Code PROGMEM = {
freq_to_timerval(33333),
26, // # of pairs
2, // # of bits per index
code_eu032Times,
code_eu032Codes
};
const uint16_t code_eu033Times[] PROGMEM = {
48, 150,
50, 149,
50, 347,
50, 2936,
};
const uint8_t code_eu033Codes[] PROGMEM = {
0x2A,
0x5D,
0xA9,
0x60,
};
const struct IrCode code_eu033Code PROGMEM = {
freq_to_timerval(38462),
14, // # of pairs
2, // # of bits per index
code_eu033Times,
code_eu033Codes
};
/* Duplicate timing table, same as na004 !
const uint16_t code_eu034Times[] PROGMEM = {
55, 57,
55, 170,
55, 3949,
55, 9623,
56, 0,
898, 453,
900, 226,
};
*/
const uint8_t code_eu034Codes[] PROGMEM = {
0xA0,
0x02,
0x40,
0x04,
0x90,
0x09,
0x20,
0x02,
0x00,
0x04,
0x90,
0x49,
0x2B,
0x3D,
0x00,
};
const struct IrCode code_eu034Code PROGMEM = {
freq_to_timerval(38462),
38, // # of pairs
3, // # of bits per index
code_na004Times,
code_eu034Codes
};
/* Duplicate timing table, same as na005 !
const uint16_t code_eu035Times[] PROGMEM = {
88, 90,
88, 91,
88, 181,
88, 8976,
177, 91,
};
*/
/*
const uint8_t code_eu035Codes[] PROGMEM = {
0x10,
0x92,
0x49,
0x46,
0x33,
0x09,
0x24,
0x94,
0x60,
};
const struct IrCode code_eu035Code PROGMEM = {
freq_to_timerval(35714),
24, // # of pairs
3, // # of bits per index
code_na005Times,
code_eu035Codes
};// Duplicate IR Code - same as eu009!
*/
/* Duplicate timing table, same as na004 !
const uint16_t code_eu036Times[] PROGMEM = {
55, 57,
55, 170,
55, 3949,
55, 9623,
56, 0,
898, 453,
900, 226,
};
*/
const uint8_t code_eu036Codes[] PROGMEM = {
0xA4,
0x00,
0x49,
0x00,
0x92,
0x00,
0x20,
0x02,
0x00,
0x04,
0x90,
0x49,
0x2B,
0x3D,
0x00,
};
const struct IrCode code_eu036Code PROGMEM = {
freq_to_timerval(38462),
38, // # of pairs
3, // # of bits per index
code_na004Times,
code_eu036Codes
};
const uint16_t code_eu037Times[] PROGMEM = {
14, 491,
14, 743,
14, 5178,
};
const uint8_t code_eu037Codes[] PROGMEM = {
0x45,
0x50,
0x02,
0x45,
0x50,
0x01,
};
const struct IrCode code_eu037Code PROGMEM = {
freq_to_timerval(38462),
24, // # of pairs
2, // # of bits per index
code_eu037Times,
code_eu037Codes
};
const uint16_t code_eu038Times[] PROGMEM = {
3, 1002,
3, 1495,
3, 3059,
};
const uint8_t code_eu038Codes[] PROGMEM = {
0x05,
0x60,
0x54,
};
const struct IrCode code_eu038Code PROGMEM = {
0, // Non-pulsed code
11, // # of pairs
2, // # of bits per index
code_eu038Times,
code_eu038Codes
};
const uint16_t code_eu039Times[] PROGMEM = {
13, 445,
13, 674,
13, 675,
13, 4583,
};
const uint8_t code_eu039Codes[] PROGMEM = {
0x6A,
0x82,
0x83,
0xAA,
0x82,
0x81,
};
const struct IrCode code_eu039Code PROGMEM = {
freq_to_timerval(40161),
24, // # of pairs
2, // # of bits per index
code_eu039Times,
code_eu039Codes
};
const uint16_t code_eu040Times[] PROGMEM = {
85, 89,
85, 264,
85, 3402,
347, 350,
348, 350,
};
const uint8_t code_eu040Codes[] PROGMEM = {
0x60,
0x90,
0x40,
0x20,
0x80,
0x40,
0x20,
0x90,
0x41,
0x2A,
0x02,
0x41,
0x00,
0x82,
0x01,
0x00,
0x82,
0x41,
0x04,
0x80,
};
const struct IrCode code_eu040Code PROGMEM = {
freq_to_timerval(35714),
52, // # of pairs
3, // # of bits per index
code_eu040Times,
code_eu040Codes
};
const uint16_t code_eu041Times[] PROGMEM = {
46, 300,
49, 298,
49, 648,
49, 997,
49, 3056,
};
const uint8_t code_eu041Codes[] PROGMEM = {
0x0C,
0xB2,
0xCA,
0x49,
0x13,
0x0B,
0x2C,
0xB2,
0x92,
0x44,
0xB0,
};
const struct IrCode code_eu041Code PROGMEM = {
freq_to_timerval(33333),
28, // # of pairs
3, // # of bits per index
code_eu041Times,
code_eu041Codes
};
/* Duplicate timing table, same as na009 !
const uint16_t code_eu042Times[] PROGMEM = {
53, 56,
53, 171,
53, 3950,
53, 9599,
898, 451,
900, 226,
};
*/
const uint8_t code_eu042Codes[] PROGMEM = {
0x80,
0x00,
0x00,
0x24,
0x92,
0x09,
0x00,
0x82,
0x00,
0x04,
0x10,
0x49,
0x2A,
0xBA,
0x00,
};
const struct IrCode code_eu042Code PROGMEM = {
freq_to_timerval(38462),
38, // # of pairs
3, // # of bits per index
code_na009Times,
code_eu042Codes
};
const uint16_t code_eu043Times[] PROGMEM = {
1037, 4216,
1040, 0,
};
const uint8_t code_eu043Codes[] PROGMEM = {
0x10,
};
const struct IrCode code_eu043Code PROGMEM = {
freq_to_timerval(41667),
2, // # of pairs
2, // # of bits per index
code_eu043Times,
code_eu043Codes
};
/* Duplicate timing table, same as na004 !
const uint16_t code_eu044Times[] PROGMEM = {
55, 57,
55, 170,
55, 3949,
55, 9623,
56, 0,
898, 453,
900, 226,
};
*/
const uint8_t code_eu044Codes[] PROGMEM = {
0xA0,
0x02,
0x01,
0x04,
0x90,
0x48,
0x20,
0x00,
0x00,
0x04,
0x92,
0x49,
0x2B,
0x3D,
0x00,
};
const struct IrCode code_eu044Code PROGMEM = {
freq_to_timerval(38462),
38, // # of pairs
3, // # of bits per index
code_na004Times,
code_eu044Codes
};
const uint16_t code_eu045Times[] PROGMEM = {
152, 471,
154, 156,
154, 469,
154, 2947,
};
const uint8_t code_eu045Codes[] PROGMEM = {
0x16,
0xE5,
0x90,
};
const struct IrCode code_eu045Code PROGMEM = {
freq_to_timerval(41667),
10, // # of pairs
2, // # of bits per index
code_eu045Times,
code_eu045Codes
};
const uint16_t code_eu046Times[] PROGMEM = {
15, 493,
16, 493,
16, 698,
16, 1414,
};
const uint8_t code_eu046Codes[] PROGMEM = {
0x16,
0xAB,
0x56,
0xA9,
};
const struct IrCode code_eu046Code PROGMEM = {
freq_to_timerval(34602),
16, // # of pairs
2, // # of bits per index
code_eu046Times,
code_eu046Codes
};
const uint16_t code_eu047Times[] PROGMEM = {
3, 496,
3, 745,
3, 1488,
};
const uint8_t code_eu047Codes[] PROGMEM = {
0x41,
0x24,
0x12,
0x41,
0x00,
};
const struct IrCode code_eu047Code PROGMEM = {
0, // Non-pulsed code
17, // # of pairs
2, // # of bits per index
code_eu047Times,
code_eu047Codes
};
/* Duplicate timing table, same as na009 !
const uint16_t code_eu048Times[] PROGMEM = {
53, 56,
53, 171,
53, 3950,
53, 9599,
898, 451,
900, 226,
};
*/
const uint8_t code_eu048Codes[] PROGMEM = {
0x80,
0x00,
0x00,
0x24,
0x82,
0x49,
0x04,
0x80,
0x40,
0x00,
0x12,
0x09,
0x2A,
0xBA,
0x00,
};
const struct IrCode code_eu048Code PROGMEM = {
freq_to_timerval(38462),
38, // # of pairs
3, // # of bits per index
code_na009Times,
code_eu048Codes
};
const uint16_t code_eu049Times[] PROGMEM = {
55, 55,
55, 167,
55, 4577,
55, 9506,
448, 445,
450, 444,
};
const uint8_t code_eu049Codes[] PROGMEM = {
0x80,
0x92,
0x00,
0x00,
0x92,
0x00,
0x00,
0x10,
0x40,
0x04,
0x82,
0x09,
0x2A,
0x97,
0x48,
};
const struct IrCode code_eu049Code PROGMEM = {
freq_to_timerval(38462),
40, // # of pairs
3, // # of bits per index
code_eu049Times,
code_eu049Codes
};
const uint16_t code_eu050Times[] PROGMEM = {
91, 88,
91, 267,
91, 3621,
361, 358,
361, 359,
};
const uint8_t code_eu050Codes[] PROGMEM = {
0x60,
0x00,
0x00,
0x00,
0x12,
0x49,
0x24,
0x92,
0x42,
0x80,
0x00,
0x00,
0x00,
0x12,
0x49,
0x24,
0x92,
0x40,
};
const struct IrCode code_eu050Code PROGMEM = {
freq_to_timerval(33333),
48, // # of pairs
3, // # of bits per index
code_eu050Times,
code_eu050Codes
};
const uint16_t code_eu051Times[] PROGMEM = {
84, 88,
84, 261,
84, 3360,
347, 347,
347, 348,
};
const uint8_t code_eu051Codes[] PROGMEM = {
0x60,
0x82,
0x00,
0x20,
0x80,
0x41,
0x04,
0x90,
0x41,
0x2A,
0x02,
0x08,
0x00,
0x82,
0x01,
0x04,
0x12,
0x41,
0x04,
0x80,
};
const struct IrCode code_eu051Code PROGMEM = {
freq_to_timerval(38462),
52, // # of pairs
3, // # of bits per index
code_eu051Times,
code_eu051Codes
};// Duplicate IR Code? - Similar to NA115
const uint16_t code_eu052Times[] PROGMEM = {
16, 838,
17, 558,
17, 839,
17, 6328,
};
const uint8_t code_eu052Codes[] PROGMEM = {
0x1A,
0x9A,
0x9B,
0x9A,
0x9A,
0x99,
};
const struct IrCode code_eu052Code PROGMEM = {
freq_to_timerval(31250),
24, // # of pairs
2, // # of bits per index
code_eu052Times,
code_eu052Codes
};// Duplicate IR Code? - Similar to EU017
/* Duplicate timing table, same as eu046 !
const uint16_t code_eu053Times[] PROGMEM = {
15, 493,
16, 493,
16, 698,
16, 1414,
};
*/
const uint8_t code_eu053Codes[] PROGMEM = {
0x26,
0xAB,
0x66,
0xAA,
};
const struct IrCode code_eu053Code PROGMEM = {
freq_to_timerval(34483),
16, // # of pairs
2, // # of bits per index
code_eu046Times,
code_eu053Codes
};
const uint16_t code_eu054Times[] PROGMEM = {
49, 53,
49, 104,
49, 262,
49, 264,
49, 8030,
100, 103,
};
const uint8_t code_eu054Codes[] PROGMEM = {
0x40,
0x1A,
0x23,
0x00,
0xD0,
0x80,
};
const struct IrCode code_eu054Code PROGMEM = {
freq_to_timerval(31250),
14, // # of pairs
3, // # of bits per index
code_eu054Times,
code_eu054Codes
};
/* Duplicate timing table, same as na009 !
const uint16_t code_eu055Times[] PROGMEM = {
53, 56,
53, 171,
53, 3950,
53, 9599,
898, 451,
900, 226,
};
*/
const uint8_t code_eu055Codes[] PROGMEM = {
0x80,
0x00,
0x00,
0x20,
0x92,
0x49,
0x00,
0x02,
0x40,
0x04,
0x90,
0x09,
0x2A,
0xBA,
0x00,
};
const struct IrCode code_eu055Code PROGMEM = {
freq_to_timerval(38462),
38, // # of pairs
3, // # of bits per index
code_na009Times,
code_eu055Codes
};
const uint16_t code_eu056Times[] PROGMEM = {
112, 107,
113, 107,
677, 2766,
};
const uint8_t code_eu056Codes[] PROGMEM = {
0x26,
};
const struct IrCode code_eu056Code PROGMEM = {
freq_to_timerval(38462),
4, // # of pairs
2, // # of bits per index
code_eu056Times,
code_eu056Codes
};
/* Duplicate timing table, same as na004 !
const uint16_t code_eu057Times[] PROGMEM = {
55, 57,
55, 170,
55, 3949,
55, 9623,
56, 0,
898, 453,
900, 226,
};
*/
/*
const uint8_t code_eu057Codes[] PROGMEM = {
0xA0,
0x00,
0x41,
0x04,
0x92,
0x08,
0x20,
0x02,
0x00,
0x04,
0x90,
0x49,
0x2B,
0x3D,
0x00,
};
const struct IrCode code_eu057Code PROGMEM = {
freq_to_timerval(38462),
38, // # of pairs
3, // # of bits per index
code_na004Times,
code_eu057Codes
}; // Duplicate IR code - same as EU008
*/
/* Duplicate timing table, same as na009 !
const uint16_t code_eu058Times[] PROGMEM = {
53, 56,
53, 171,
53, 3950,
53, 9599,
898, 451,
900, 226,
};
*/
const uint8_t code_eu058Codes[] PROGMEM = {
0x80,
0x00,
0x00,
0x24,
0x10,
0x49,
0x00,
0x82,
0x00,
0x04,
0x10,
0x49,
0x2A,
0xBA,
0x00,
};
const struct IrCode code_eu058Code PROGMEM = {
freq_to_timerval(38462),
38, // # of pairs
3, // # of bits per index
code_na009Times,
code_eu058Codes
};
const uint16_t code_eu059Times[] PROGMEM = {
310, 613,
310, 614,
622, 8312,
};
const uint8_t code_eu059Codes[] PROGMEM = {
0x26,
};
const struct IrCode code_eu059Code PROGMEM = {
freq_to_timerval(41667),
4, // # of pairs
2, // # of bits per index
code_eu059Times,
code_eu059Codes
};// Duplicate IR Code? - Similar to EU056
const uint16_t code_eu060Times[] PROGMEM = {
50, 158,
53, 51,
53, 156,
53, 2180,
};
const uint8_t code_eu060Codes[] PROGMEM = {
0x25,
0x59,
0x9A,
0x5A,
0xE9,
0x56,
0x66,
0x96,
0xA0,
};
const struct IrCode code_eu060Code PROGMEM = {
freq_to_timerval(38462),
34, // # of pairs
2, // # of bits per index
code_eu060Times,
code_eu060Codes
};
/* Duplicate timing table, same as na005 !
const uint16_t code_eu061Times[] PROGMEM = {
88, 90,
88, 91,
88, 181,
88, 8976,
177, 91,
};
*/
const uint8_t code_eu061Codes[] PROGMEM = {
0x10,
0x92,
0x54,
0x24,
0xB3,
0x09,
0x25,
0x42,
0x48,
};
const struct IrCode code_eu061Code PROGMEM = {
freq_to_timerval(35714),
24, // # of pairs
3, // # of bits per index
code_na005Times,
code_eu061Codes
};
/* Duplicate timing table, same as eu060 !
const uint16_t code_eu062Times[] PROGMEM = {
50, 158,
53, 51,
53, 156,
53, 2180,
};
*/
const uint8_t code_eu062Codes[] PROGMEM = {
0x25,
0x99,
0x9A,
0x5A,
0xE9,
0x66,
0x66,
0x96,
0xA0,
};
const struct IrCode code_eu062Code PROGMEM = {
freq_to_timerval(38462),
34, // # of pairs
2, // # of bits per index
code_eu060Times,
code_eu062Codes
};
/* Duplicate timing table, same as na009 !
const uint16_t code_eu063Times[] PROGMEM = {
53, 56,
53, 171,
53, 3950,
53, 9599,
898, 451,
900, 226,
};
*/
const uint8_t code_eu063Codes[] PROGMEM = {
0x80,
0x00,
0x00,
0x24,
0x90,
0x41,
0x00,
0x82,
0x00,
0x04,
0x10,
0x49,
0x2A,
0xBA,
0x00,
};
const struct IrCode code_eu063Code PROGMEM = {
freq_to_timerval(38462),
38, // # of pairs
3, // # of bits per index
code_na009Times,
code_eu063Codes
};
const uint16_t code_eu064Times[] PROGMEM = {
47, 267,
50, 55,
50, 110,
50, 265,
50, 2055,
50, 12117,
100, 57,
100, 112,
};
const uint8_t code_eu064Codes[] PROGMEM = {
0x04,
0x92,
0x49,
0x26,
0x32,
0x51,
0xCB,
0xD6,
0x4A,
0x39,
0x72,
};
const struct IrCode code_eu064Code PROGMEM = {
freq_to_timerval(30395),
29, // # of pairs
3, // # of bits per index
code_eu064Times,
code_eu064Codes
};
const uint16_t code_eu065Times[] PROGMEM = {
47, 267,
50, 55,
50, 110,
50, 265,
50, 2055,
50, 12117,
100, 112,
};
const uint8_t code_eu065Codes[] PROGMEM = {
0x04,
0x92,
0x49,
0x26,
0x32,
0x4A,
0x38,
0x9A,
0xC9,
0x28,
0xE2,
0x48,
};
const struct IrCode code_eu065Code PROGMEM = {
freq_to_timerval(30303),
31, // # of pairs
3, // # of bits per index
code_eu065Times,
code_eu065Codes
};
/* Duplicate timing table, same as eu049 !
const uint16_t code_eu066Times[] PROGMEM = {
55, 55,
55, 167,
55, 4577,
55, 9506,
448, 445,
450, 444,
};
*/
const uint8_t code_eu066Codes[] PROGMEM = {
0x84,
0x82,
0x00,
0x04,
0x82,
0x00,
0x00,
0x82,
0x00,
0x04,
0x10,
0x49,
0x2A,
0x87,
0x41,
};
const struct IrCode code_eu066Code PROGMEM = {
freq_to_timerval(38462),
40, // # of pairs
3, // # of bits per index
code_eu049Times,
code_eu066Codes
};
const uint16_t code_eu067Times[] PROGMEM = {
94, 473,
94, 728,
102, 1637,
};
const uint8_t code_eu067Codes[] PROGMEM = {
0x41,
0x24,
0x12,
};
const struct IrCode code_eu067Code PROGMEM = {
freq_to_timerval(38462),
12, // # of pairs
2, // # of bits per index
code_eu067Times,
code_eu067Codes
};
const uint16_t code_eu068Times[] PROGMEM = {
49, 263,
50, 54,
50, 108,
50, 263,
50, 2029,
50, 10199,
100, 110,
};
const uint8_t code_eu068Codes[] PROGMEM = {
0x04,
0x92,
0x49,
0x26,
0x34,
0x49,
0x38,
0x9A,
0xD1,
0x24,
0xE2,
0x48,
};
const struct IrCode code_eu068Code PROGMEM = {
freq_to_timerval(38610),
31, // # of pairs
3, // # of bits per index
code_eu068Times,
code_eu068Codes
};
const uint16_t code_eu069Times[] PROGMEM = {
4, 499,
4, 750,
4, 4999,
};
const uint8_t code_eu069Codes[] PROGMEM = {
0x05,
0x54,
0x06,
0x05,
0x54,
0x04,
};
const struct IrCode code_eu069Code PROGMEM = {
0, // Non-pulsed code
23, // # of pairs
2, // # of bits per index
code_eu069Times,
code_eu069Codes
};
/* Duplicate timing table, same as eu069 !
const uint16_t code_eu070Times[] PROGMEM = {
4, 499,
4, 750,
4, 4999,
};
*/
const uint8_t code_eu070Codes[] PROGMEM = {
0x14,
0x54,
0x06,
0x14,
0x54,
0x04,
};
const struct IrCode code_eu070Code PROGMEM = {
0, // Non-pulsed code
23, // # of pairs
2, // # of bits per index
code_eu069Times,
code_eu070Codes
};
const uint16_t code_eu071Times[] PROGMEM = {
14, 491,
14, 743,
14, 4422,
};
const uint8_t code_eu071Codes[] PROGMEM = {
0x45,
0x44,
0x56,
0x45,
0x44,
0x55,
};
const struct IrCode code_eu071Code PROGMEM = {
freq_to_timerval(38462),
24, // # of pairs
2, // # of bits per index
code_eu071Times,
code_eu071Codes
};
const uint16_t code_eu072Times[] PROGMEM = {
5, 568,
5, 854,
5, 4999,
};
const uint8_t code_eu072Codes[] PROGMEM = {
0x55,
0x45,
0x46,
0x55,
0x45,
0x44,
};
const struct IrCode code_eu072Code PROGMEM = {
0, // Non-pulsed code
23, // # of pairs
2, // # of bits per index
code_eu072Times,
code_eu072Codes
};
/* Duplicate timing table, same as eu046 !
const uint16_t code_eu073Times[] PROGMEM = {
15, 493,
16, 493,
16, 698,
16, 1414,
};
*/
const uint8_t code_eu073Codes[] PROGMEM = {
0x19,
0x57,
0x59,
0x55,
};
const struct IrCode code_eu073Code PROGMEM = {
freq_to_timerval(34483),
16, // # of pairs
2, // # of bits per index
code_eu046Times,
code_eu073Codes
};
/* Duplicate timing table, same as na031 !
const uint16_t code_eu074Times[] PROGMEM = {
88, 89,
88, 90,
88, 179,
88, 8977,
177, 90,
};
*/
const uint8_t code_eu074Codes[] PROGMEM = {
0x04,
0x92,
0x49,
0x28,
0xC6,
0x49,
0x24,
0x92,
0x51,
0x80,
};
const struct IrCode code_eu074Code PROGMEM = {
freq_to_timerval(35714),
26, // # of pairs
3, // # of bits per index
code_na031Times,
code_eu074Codes
};
const uint16_t code_eu075Times[] PROGMEM = {
6, 566,
6, 851,
6, 5474,
};
const uint8_t code_eu075Codes[] PROGMEM = {
0x05,
0x45,
0x46,
0x05,
0x45,
0x44,
};
const struct IrCode code_eu075Code PROGMEM = {
0, // Non-pulsed code
23, // # of pairs
2, // # of bits per index
code_eu075Times,
code_eu075Codes
};
const uint16_t code_eu076Times[] PROGMEM = {
14, 843,
16, 555,
16, 841,
16, 4911,
};
const uint8_t code_eu076Codes[] PROGMEM = {
0x2A,
0x9A,
0x9B,
0xAA,
0x9A,
0x9A,
};
const struct IrCode code_eu076Code PROGMEM = {
freq_to_timerval(38462),
24, // # of pairs
2, // # of bits per index
code_eu076Times,
code_eu076Codes
};
/* Duplicate timing table, same as eu028 !
const uint16_t code_eu077Times[] PROGMEM = {
47, 267,
50, 55,
50, 110,
50, 265,
50, 2055,
50, 12117,
100, 57,
};
*/
const uint8_t code_eu077Codes[] PROGMEM = {
0x04,
0x92,
0x49,
0x26,
0x32,
0x51,
0xC8,
0x9A,
0xC9,
0x47,
0x22,
0x48,
};
const struct IrCode code_eu077Code PROGMEM = {
freq_to_timerval(30303),
31, // # of pairs
3, // # of bits per index
code_eu028Times,
code_eu077Codes
};
const uint16_t code_eu078Times[] PROGMEM = {
6, 925,
6, 1339,
6, 2098,
6, 2787,
};
const uint8_t code_eu078Codes[] PROGMEM = {
0x90,
0x0D,
0x00,
};
const struct IrCode code_eu078Code PROGMEM = {
0, // Non-pulsed code
12, // # of pairs
2, // # of bits per index
code_eu078Times,
code_eu078Codes
};
const uint16_t code_eu079Times[] PROGMEM = {
53, 59,
53, 170,
53, 4359,
892, 448,
893, 448,
};
const uint8_t code_eu079Codes[] PROGMEM = {
0x60,
0x00,
0x00,
0x24,
0x80,
0x09,
0x04,
0x92,
0x00,
0x00,
0x00,
0x49,
0x2A,
0x00,
0x00,
0x00,
0x92,
0x00,
0x24,
0x12,
0x48,
0x00,
0x00,
0x01,
0x24,
0x80,
};
const struct IrCode code_eu079Code PROGMEM = {
freq_to_timerval(38462),
68, // # of pairs
3, // # of bits per index
code_eu079Times,
code_eu079Codes
};
const uint16_t code_eu080Times[] PROGMEM = {
55, 57,
55, 167,
55, 4416,
895, 448,
897, 447,
};
const uint8_t code_eu080Codes[] PROGMEM = {
0x60,
0x00,
0x00,
0x20,
0x10,
0x09,
0x04,
0x02,
0x01,
0x00,
0x90,
0x48,
0x2A,
0x00,
0x00,
0x00,
0x80,
0x40,
0x24,
0x10,
0x08,
0x04,
0x02,
0x41,
0x20,
0x80,
};
const struct IrCode code_eu080Code PROGMEM = {
freq_to_timerval(38462),
68, // # of pairs
3, // # of bits per index
code_eu080Times,
code_eu080Codes
};
const uint16_t code_eu081Times[] PROGMEM = {
26, 185,
27, 80,
27, 185,
27, 4249,
};
const uint8_t code_eu081Codes[] PROGMEM = {
0x1A,
0x5A,
0x65,
0x67,
0x9A,
0x65,
0x9A,
0x9B,
0x9A,
0x5A,
0x65,
0x67,
0x9A,
0x65,
0x9A,
0x9B,
0x9A,
0x5A,
0x65,
0x65,
};
const struct IrCode code_eu081Code PROGMEM = {
freq_to_timerval(38462),
80, // # of pairs
2, // # of bits per index
code_eu081Times,
code_eu081Codes
};
const uint16_t code_eu082Times[] PROGMEM = {
51, 56,
51, 162,
51, 2842,
848, 430,
850, 429,
};
const uint8_t code_eu082Codes[] PROGMEM = {
0x60,
0x82,
0x08,
0x24,
0x10,
0x41,
0x04,
0x82,
0x40,
0x00,
0x10,
0x09,
0x2A,
0x02,
0x08,
0x20,
0x90,
0x41,
0x04,
0x12,
0x09,
0x00,
0x00,
0x40,
0x24,
0x80,
};
const struct IrCode code_eu082Code PROGMEM = {
freq_to_timerval(40000),
68, // # of pairs
3, // # of bits per index
code_eu082Times,
code_eu082Codes
};
const uint16_t code_eu083Times[] PROGMEM = {
16, 559,
16, 847,
16, 5900,
17, 559,
17, 847,
};
const uint8_t code_eu083Codes[] PROGMEM = {
0x0E,
0x38,
0x21,
0x82,
0x26,
0x20,
0x82,
0x48,
0x23,
};
const struct IrCode code_eu083Code PROGMEM = {
freq_to_timerval(33333),
24, // # of pairs
3, // # of bits per index
code_eu083Times,
code_eu083Codes
};
const uint16_t code_eu084Times[] PROGMEM = {
16, 484,
16, 738,
16, 739,
16, 4795,
};
const uint8_t code_eu084Codes[] PROGMEM = {
0x6A,
0xA0,
0x03,
0xAA,
0xA0,
0x01,
};
const struct IrCode code_eu084Code PROGMEM = {
freq_to_timerval(38462),
24, // # of pairs
2, // # of bits per index
code_eu084Times,
code_eu084Codes
};
const uint16_t code_eu085Times[] PROGMEM = {
48, 52,
48, 160,
48, 400,
48, 2120,
799, 400,
};
const uint8_t code_eu085Codes[] PROGMEM = {
0x84,
0x82,
0x40,
0x08,
0x92,
0x48,
0x01,
0xC2,
0x41,
0x20,
0x04,
0x49,
0x24,
0x00,
0x40,
};
const struct IrCode code_eu085Code PROGMEM = {
freq_to_timerval(38462),
38, // # of pairs
3, // # of bits per index
code_eu085Times,
code_eu085Codes
};
const uint16_t code_eu086Times[] PROGMEM = {
16, 851,
17, 554,
17, 850,
17, 851,
17, 4847,
};
const uint8_t code_eu086Codes[] PROGMEM = {
0x45,
0x86,
0x5B,
0x05,
0xC6,
0x5B,
0x05,
0xB0,
0x42,
};
const struct IrCode code_eu086Code PROGMEM = {
freq_to_timerval(33333),
24, // # of pairs
3, // # of bits per index
code_eu086Times,
code_eu086Codes
};
const uint16_t code_eu087Times[] PROGMEM = {
14, 491,
14, 743,
14, 5126,
};
const uint8_t code_eu087Codes[] PROGMEM = {
0x55,
0x50,
0x02,
0x55,
0x50,
0x01,
};
const struct IrCode code_eu087Code PROGMEM = {
freq_to_timerval(38462),
24, // # of pairs
2, // # of bits per index
code_eu087Times,
code_eu087Codes
};
const uint16_t code_eu088Times[] PROGMEM = {
14, 491,
14, 743,
14, 4874,
};
const uint8_t code_eu088Codes[] PROGMEM = {
0x45,
0x54,
0x42,
0x45,
0x54,
0x41,
};
const struct IrCode code_eu088Code PROGMEM = {
freq_to_timerval(38462),
24, // # of pairs
2, // # of bits per index
code_eu088Times,
code_eu088Codes
};
/* Duplicate timing table, same as na021 !
const uint16_t code_eu089Times[] PROGMEM = {
48, 52,
48, 160,
48, 400,
48, 2335,
799, 400,
};
*/
const uint8_t code_eu089Codes[] PROGMEM = {
0x84,
0x10,
0x40,
0x08,
0x82,
0x08,
0x01,
0xC2,
0x08,
0x20,
0x04,
0x41,
0x04,
0x00,
0x40,
};
const struct IrCode code_eu089Code PROGMEM = {
freq_to_timerval(38462),
38, // # of pairs
3, // # of bits per index
code_na021Times,
code_eu089Codes
};
const uint16_t code_eu090Times[] PROGMEM = {
3, 9,
3, 19,
3, 29,
3, 39,
3, 9968,
};
const uint8_t code_eu090Codes[] PROGMEM = {
0x60,
0x00,
0x88,
0x00,
0x02,
0xE3,
0x00,
0x04,
0x40,
0x00,
0x16,
};
const struct IrCode code_eu090Code PROGMEM = {
0, // Non-pulsed code
29, // # of pairs
3, // # of bits per index
code_eu090Times,
code_eu090Codes
};
const uint16_t code_eu091Times[] PROGMEM = {
15, 138,
15, 446,
15, 605,
15, 6565,
};
const uint8_t code_eu091Codes[] PROGMEM = {
0x80,
0x01,
0x00,
0x2E,
0x00,
0x04,
0x00,
0xA0,
};
const struct IrCode code_eu091Code PROGMEM = {
freq_to_timerval(38462),
30, // # of pairs
2, // # of bits per index
code_eu091Times,
code_eu091Codes
};
const uint16_t code_eu092Times[] PROGMEM = {
48, 50,
48, 148,
48, 149,
48, 1424,
};
const uint8_t code_eu092Codes[] PROGMEM = {
0x48,
0x80,
0x0E,
0x22,
0x00,
0x10,
};
const struct IrCode code_eu092Code PROGMEM = {
freq_to_timerval(40000),
22, // # of pairs
2, // # of bits per index
code_eu092Times,
code_eu092Codes
};
const uint16_t code_eu093Times[] PROGMEM = {
87, 639,
88, 275,
88, 639,
};
const uint8_t code_eu093Codes[] PROGMEM = {
0x15,
0x9A,
0x94,
};
const struct IrCode code_eu093Code PROGMEM = {
freq_to_timerval(35714),
11, // # of pairs
2, // # of bits per index
code_eu093Times,
code_eu093Codes
};
const uint16_t code_eu094Times[] PROGMEM = {
3, 8,
3, 18,
3, 24,
3, 38,
3, 9969,
};
const uint8_t code_eu094Codes[] PROGMEM = {
0x60,
0x80,
0x88,
0x00,
0x00,
0xE3,
0x04,
0x04,
0x40,
0x00,
0x06,
};
const struct IrCode code_eu094Code PROGMEM = {
0, // Non-pulsed code
29, // # of pairs
3, // # of bits per index
code_eu094Times,
code_eu094Codes
};
/* Duplicate timing table, same as eu046 !
const uint16_t code_eu095Times[] PROGMEM = {
15, 493,
16, 493,
16, 698,
16, 1414,
};
*/
const uint8_t code_eu095Codes[] PROGMEM = {
0x2A,
0xAB,
0x6A,
0xAA,
};
const struct IrCode code_eu095Code PROGMEM = {
freq_to_timerval(34483),
16, // # of pairs
2, // # of bits per index
code_eu046Times,
code_eu095Codes
};
const uint16_t code_eu096Times[] PROGMEM = {
13, 608,
14, 141,
14, 296,
14, 451,
14, 606,
14, 608,
14, 6207,
};
const uint8_t code_eu096Codes[] PROGMEM = {
0x04,
0x94,
0x4B,
0x24,
0x95,
0x35,
0x24,
0xA2,
0x59,
0x24,
0xA8,
0x40,
};
const struct IrCode code_eu096Code PROGMEM = {
freq_to_timerval(38462),
30, // # of pairs
3, // # of bits per index
code_eu096Times,
code_eu096Codes
};
/* Duplicate timing table, same as eu046 !
const uint16_t code_eu097Times[] PROGMEM = {
15, 493,
16, 493,
16, 698,
16, 1414,
};
*/
const uint8_t code_eu097Codes[] PROGMEM = {
0x19,
0xAB,
0x59,
0xA9,
};
const struct IrCode code_eu097Code PROGMEM = {
freq_to_timerval(34483),
16, // # of pairs
2, // # of bits per index
code_eu046Times,
code_eu097Codes
};
const uint16_t code_eu098Times[] PROGMEM = {
3, 8,
3, 18,
3, 28,
3, 12731,
};
const uint8_t code_eu098Codes[] PROGMEM = {
0x80,
0x01,
0x00,
0xB8,
0x55,
0x10,
0x08,
};
const struct IrCode code_eu098Code PROGMEM = {
0, // Non-pulsed code
27, // # of pairs
2, // # of bits per index
code_eu098Times,
code_eu098Codes
};
const uint16_t code_eu099Times[] PROGMEM = {
46, 53,
46, 106,
46, 260,
46, 1502,
46, 10962,
93, 53,
93, 106,
};
const uint8_t code_eu099Codes[] PROGMEM = {
0x46,
0x80,
0x00,
0x00,
0x00,
0x03,
0x44,
0x52,
0x00,
0x00,
0x0C,
0x22,
0x22,
0x90,
0x00,
0x00,
0x60,
0x80,
};
const struct IrCode code_eu099Code PROGMEM = {
freq_to_timerval(35714),
46, // # of pairs
3, // # of bits per index
code_eu099Times,
code_eu099Codes
};
/* Duplicate timing table, same as eu098 !
const uint16_t code_eu100Times[] PROGMEM = {
3, 8,
3, 18,
3, 28,
3, 12731,
};
*/
const uint8_t code_eu100Codes[] PROGMEM = {
0x80,
0x04,
0x00,
0xB8,
0x55,
0x40,
0x08,
};
const struct IrCode code_eu100Code PROGMEM = {
0, // Non-pulsed code
27, // # of pairs
2, // # of bits per index
code_eu098Times,
code_eu100Codes
};
const uint16_t code_eu101Times[] PROGMEM = {
14, 491,
14, 743,
14, 4674,
};
const uint8_t code_eu101Codes[] PROGMEM = {
0x55,
0x50,
0x06,
0x55,
0x50,
0x05,
};
const struct IrCode code_eu101Code PROGMEM = {
freq_to_timerval(38462),
24, // # of pairs
2, // # of bits per index
code_eu101Times,
code_eu101Codes
};
/* Duplicate timing table, same as eu087 !
const uint16_t code_eu102Times[] PROGMEM = {
14, 491,
14, 743,
14, 5126,
};
*/
const uint8_t code_eu102Codes[] PROGMEM = {
0x45,
0x54,
0x02,
0x45,
0x54,
0x01,
};
const struct IrCode code_eu102Code PROGMEM = {
freq_to_timerval(38462),
24, // # of pairs
2, // # of bits per index
code_eu087Times,
code_eu102Codes
};
const uint16_t code_eu103Times[] PROGMEM = {
44, 815,
45, 528,
45, 815,
45, 5000,
};
const uint8_t code_eu103Codes[] PROGMEM = {
0x29,
0x9A,
0x9B,
0xA9,
0x9A,
0x9A,
};
const struct IrCode code_eu103Code PROGMEM = {
freq_to_timerval(34483),
24, // # of pairs
2, // # of bits per index
code_eu103Times,
code_eu103Codes
};
const uint16_t code_eu104Times[] PROGMEM = {
14, 491,
14, 743,
14, 5881,
};
const uint8_t code_eu104Codes[] PROGMEM = {
0x44,
0x40,
0x02,
0x44,
0x40,
0x01,
};
const struct IrCode code_eu104Code PROGMEM = {
freq_to_timerval(38462),
24, // # of pairs
2, // # of bits per index
code_eu104Times,
code_eu104Codes
};
/* Duplicate timing table, same as na009 !
const uint16_t code_eu105Times[] PROGMEM = {
53, 56,
53, 171,
53, 3950,
53, 9599,
898, 451,
900, 226,
};
*/
const uint8_t code_eu105Codes[] PROGMEM = {
0x84,
0x10,
0x00,
0x20,
0x90,
0x01,
0x00,
0x80,
0x40,
0x04,
0x12,
0x09,
0x2A,
0xBA,
0x40,
};
const struct IrCode code_eu105Code PROGMEM = {
freq_to_timerval(38610),
38, // # of pairs
3, // # of bits per index
code_na009Times,
code_eu105Codes
};
const uint16_t code_eu106Times[] PROGMEM = {
48, 246,
50, 47,
50, 94,
50, 245,
50, 1488,
50, 10970,
100, 47,
100, 94,
};
const uint8_t code_eu106Codes[] PROGMEM = {
0x0B,
0x12,
0x49,
0x24,
0x92,
0x49,
0x8D,
0x1C,
0x89,
0x27,
0xFC,
0xAB,
0x47,
0x22,
0x49,
0xFF,
0x2A,
0xD1,
0xC8,
0x92,
0x7F,
0xC9,
0x00,
};
const struct IrCode code_eu106Code PROGMEM = {
freq_to_timerval(38462),
59, // # of pairs
3, // # of bits per index
code_eu106Times,
code_eu106Codes
};
const uint16_t code_eu107Times[] PROGMEM = {
16, 847,
16, 5900,
17, 559,
17, 846,
17, 847,
};
const uint8_t code_eu107Codes[] PROGMEM = {
0x62,
0x08,
0xA0,
0x8A,
0x19,
0x04,
0x08,
0x40,
0x83,
};
const struct IrCode code_eu107Code PROGMEM = {
freq_to_timerval(33333),
24, // # of pairs
3, // # of bits per index
code_eu107Times,
code_eu107Codes
};
const uint16_t code_eu108Times[] PROGMEM = {
14, 491,
14, 743,
14, 4622,
};
const uint8_t code_eu108Codes[] PROGMEM = {
0x45,
0x54,
0x16,
0x45,
0x54,
0x15,
};
const struct IrCode code_eu108Code PROGMEM = {
freq_to_timerval(38462),
24, // # of pairs
2, // # of bits per index
code_eu108Times,
code_eu108Codes
};
const uint16_t code_eu109Times[] PROGMEM = {
24, 185,
27, 78,
27, 183,
27, 1542,
};
const uint8_t code_eu109Codes[] PROGMEM = {
0x19,
0x95,
0x5E,
0x66,
0x55,
0x50,
};
const struct IrCode code_eu109Code PROGMEM = {
freq_to_timerval(38462),
22, // # of pairs
2, // # of bits per index
code_eu109Times,
code_eu109Codes
};
const uint16_t code_eu110Times[] PROGMEM = {
56, 55,
56, 168,
56, 4850,
447, 453,
448, 453,
};
const uint8_t code_eu110Codes[] PROGMEM = {
0x64,
0x10,
0x00,
0x04,
0x10,
0x00,
0x00,
0x80,
0x00,
0x04,
0x12,
0x49,
0x2A,
0x10,
0x40,
0x00,
0x10,
0x40,
0x00,
0x02,
0x00,
0x00,
0x10,
0x49,
0x24,
0x90,
};
const struct IrCode code_eu110Code PROGMEM = {
freq_to_timerval(38462),
68, // # of pairs
3, // # of bits per index
code_eu110Times,
code_eu110Codes
};
const uint16_t code_eu111Times[] PROGMEM = {
49, 52,
49, 250,
49, 252,
49, 2377,
49, 12009,
100, 52,
100, 102,
};
const uint8_t code_eu111Codes[] PROGMEM = {
0x22,
0x80,
0x1A,
0x18,
0x01,
0x10,
0xC0,
0x02,
};
const struct IrCode code_eu111Code PROGMEM = {
freq_to_timerval(31250),
21, // # of pairs
3, // # of bits per index
code_eu111Times,
code_eu111Codes
};
const uint16_t code_eu112Times[] PROGMEM = {
55, 55,
55, 167,
55, 5023,
55, 9506,
448, 445,
450, 444,
};
const uint8_t code_eu112Codes[] PROGMEM = {
0x80,
0x02,
0x00,
0x00,
0x02,
0x00,
0x04,
0x92,
0x00,
0x00,
0x00,
0x49,
0x2A,
0x97,
0x48,
};
const struct IrCode code_eu112Code PROGMEM = {
freq_to_timerval(38462),
40, // # of pairs
3, // # of bits per index
code_eu112Times,
code_eu112Codes
};
/* Duplicate timing table, same as eu054 !
const uint16_t code_eu113Times[] PROGMEM = {
49, 53,
49, 104,
49, 262,
49, 264,
49, 8030,
100, 103,
};
*/
const uint8_t code_eu113Codes[] PROGMEM = {
0x46,
0x80,
0x23,
0x34,
0x00,
0x80,
};
const struct IrCode code_eu113Code PROGMEM = {
freq_to_timerval(31250),
14, // # of pairs
3, // # of bits per index
code_eu054Times,
code_eu113Codes
};
/* Duplicate timing table, same as eu028 !
const uint16_t code_eu114Times[] PROGMEM = {
47, 267,
50, 55,
50, 110,
50, 265,
50, 2055,
50, 12117,
100, 57,
};
*/
const uint8_t code_eu114Codes[] PROGMEM = {
0x04,
0x92,
0x49,
0x26,
0x34,
0x71,
0x44,
0x9A,
0xD1,
0xC5,
0x12,
0x48,
};
const struct IrCode code_eu114Code PROGMEM = {
freq_to_timerval(30303),
31, // # of pairs
3, // # of bits per index
code_eu028Times,
code_eu114Codes
};
const uint16_t code_eu115Times[] PROGMEM = {
48, 98,
48, 196,
97, 836,
395, 388,
1931, 389,
};
const uint8_t code_eu115Codes[] PROGMEM = {
0x84,
0x92,
0x01,
0x24,
0x12,
0x00,
0x04,
0x80,
0x08,
0x09,
0x92,
0x48,
0x04,
0x90,
0x48,
0x00,
0x12,
0x00,
0x20,
0x26,
0x49,
0x20,
0x12,
0x41,
0x20,
0x00,
0x48,
0x00,
0x82,
};
const struct IrCode code_eu115Code PROGMEM = {
freq_to_timerval(58824),
77, // # of pairs
3, // # of bits per index
code_eu115Times,
code_eu115Codes
};
const uint16_t code_eu116Times[] PROGMEM = {
3, 9,
3, 31,
3, 42,
3, 10957,
};
const uint8_t code_eu116Codes[] PROGMEM = {
0x80,
0x01,
0x00,
0x2E,
0x00,
0x04,
0x00,
0x80,
};
const struct IrCode code_eu116Code PROGMEM = {
0, // Non-pulsed code
29, // # of pairs
2, // # of bits per index
code_eu116Times,
code_eu116Codes
};
const uint16_t code_eu117Times[] PROGMEM = {
49, 53,
49, 262,
49, 264,
49, 8030,
100, 103,
};
const uint8_t code_eu117Codes[] PROGMEM = {
0x22,
0x00,
0x1A,
0x10,
0x00,
0x40,
};
const struct IrCode code_eu117Code PROGMEM = {
freq_to_timerval(31250),
14, // # of pairs
3, // # of bits per index
code_eu117Times,
code_eu117Codes
};
const uint16_t code_eu118Times[] PROGMEM = {
44, 815,
45, 528,
45, 815,
45, 4713,
};
const uint8_t code_eu118Codes[] PROGMEM = {
0x2A,
0x9A,
0x9B,
0xAA,
0x9A,
0x9A,
};
const struct IrCode code_eu118Code PROGMEM = {
freq_to_timerval(34483),
24, // # of pairs
2, // # of bits per index
code_eu118Times,
code_eu118Codes
};
const uint16_t code_eu119Times[] PROGMEM = {
14, 491,
14, 743,
14, 5430,
};
const uint8_t code_eu119Codes[] PROGMEM = {
0x44,
0x44,
0x02,
0x44,
0x44,
0x01,
};
const struct IrCode code_eu119Code PROGMEM = {
freq_to_timerval(38462),
24, // # of pairs
2, // # of bits per index
code_eu119Times,
code_eu119Codes
};
const uint16_t code_eu120Times[] PROGMEM = {
19, 78,
21, 27,
21, 77,
21, 3785,
22, 0,
};
const uint8_t code_eu120Codes[] PROGMEM = {
0x09,
0x24,
0x92,
0x49,
0x12,
0x4A,
0x24,
0x92,
0x49,
0x24,
0x92,
0x49,
0x24,
0x94,
0x89,
0x69,
0x24,
0x92,
0x49,
0x22,
0x49,
0x44,
0x92,
0x49,
0x24,
0x92,
0x49,
0x24,
0x92,
0x91,
0x30,
};
const struct IrCode code_eu120Code PROGMEM = {
freq_to_timerval(38462),
82, // # of pairs
3, // # of bits per index
code_eu120Times,
code_eu120Codes
};
/* Duplicate timing table, same as eu051 !
const uint16_t code_eu121Times[] PROGMEM = {
84, 88,
84, 261,
84, 3360,
347, 347,
347, 348,
};
*/
const uint8_t code_eu121Codes[] PROGMEM = {
0x64,
0x00,
0x09,
0x24,
0x00,
0x09,
0x24,
0x00,
0x09,
0x2A,
0x10,
0x00,
0x24,
0x90,
0x00,
0x24,
0x90,
0x00,
0x24,
0x90,
};
const struct IrCode code_eu121Code PROGMEM = {
freq_to_timerval(38462),
52, // # of pairs
3, // # of bits per index
code_eu051Times,
code_eu121Codes
};
/* Duplicate timing table, same as eu120 !
const uint16_t code_eu122Times[] PROGMEM = {
19, 78,
21, 27,
21, 77,
21, 3785,
22, 0,
};
*/
const uint8_t code_eu122Codes[] PROGMEM = {
0x04,
0xA4,
0x92,
0x49,
0x22,
0x49,
0x48,
0x92,
0x49,
0x24,
0x92,
0x49,
0x24,
0x94,
0x89,
0x68,
0x94,
0x92,
0x49,
0x24,
0x49,
0x29,
0x12,
0x49,
0x24,
0x92,
0x49,
0x24,
0x92,
0x91,
0x30,
};
const struct IrCode code_eu122Code PROGMEM = {
freq_to_timerval(38462),
82, // # of pairs
3, // # of bits per index
code_eu120Times,
code_eu122Codes
};
const uint16_t code_eu123Times[] PROGMEM = {
13, 490,
13, 741,
13, 742,
13, 5443,
};
const uint8_t code_eu123Codes[] PROGMEM = {
0x6A,
0xA0,
0x0B,
0xAA,
0xA0,
0x09,
};
const struct IrCode code_eu123Code PROGMEM = {
freq_to_timerval(40000),
24, // # of pairs
2, // # of bits per index
code_eu123Times,
code_eu123Codes
};
const uint16_t code_eu124Times[] PROGMEM = {
50, 54,
50, 158,
50, 407,
50, 2153,
843, 407,
};
const uint8_t code_eu124Codes[] PROGMEM = {
0x80,
0x10,
0x40,
0x08,
0x92,
0x48,
0x01,
0xC0,
0x08,
0x20,
0x04,
0x49,
0x24,
0x00,
0x00,
};
const struct IrCode code_eu124Code PROGMEM = {
freq_to_timerval(38462),
38, // # of pairs
3, // # of bits per index
code_eu124Times,
code_eu124Codes
};
const uint16_t code_eu125Times[] PROGMEM = {
55, 56,
55, 168,
55, 3929,
56, 0,
882, 454,
884, 452,
};
const uint8_t code_eu125Codes[] PROGMEM = {
0x84,
0x80,
0x00,
0x20,
0x82,
0x49,
0x00,
0x02,
0x00,
0x04,
0x90,
0x49,
0x2A,
0x92,
0x00,
0x00,
0x82,
0x09,
0x24,
0x00,
0x08,
0x00,
0x12,
0x41,
0x24,
0xB0,
};
const struct IrCode code_eu125Code PROGMEM = {
freq_to_timerval(38462),
68, // # of pairs
3, // # of bits per index
code_eu125Times,
code_eu125Codes
};
/* Duplicate timing table, same as na004 !
const uint16_t code_eu126Times[] PROGMEM = {
55, 57,
55, 170,
55, 3949,
55, 9623,
56, 0,
898, 453,
900, 226,
};
*/
const uint8_t code_eu126Codes[] PROGMEM = {
0xA0,
0x00,
0x00,
0x04,
0x92,
0x49,
0x20,
0x00,
0x00,
0x04,
0x92,
0x49,
0x2B,
0x3D,
0x00,
};
const struct IrCode code_eu126Code PROGMEM = {
freq_to_timerval(38462),
38, // # of pairs
3, // # of bits per index
code_na004Times,
code_eu126Codes
};
/* Duplicate timing table, same as eu087 !
const uint16_t code_eu127Times[] PROGMEM = {
14, 491,
14, 743,
14, 5126,
};
*/
const uint8_t code_eu127Codes[] PROGMEM = {
0x44,
0x40,
0x56,
0x44,
0x40,
0x55,
};
const struct IrCode code_eu127Code PROGMEM = {
freq_to_timerval(38462),
24, // # of pairs
2, // # of bits per index
code_eu087Times,
code_eu127Codes
};
const uint16_t code_eu128Times[] PROGMEM = {
152, 471,
154, 156,
154, 469,
154, 782,
154, 2947,
};
const uint8_t code_eu128Codes[] PROGMEM = {
0x05,
0xC4,
0x59,
};
const struct IrCode code_eu128Code PROGMEM = {
freq_to_timerval(41667),
8, // # of pairs
3, // # of bits per index
code_eu128Times,
code_eu128Codes
};
const uint16_t code_eu129Times[] PROGMEM = {
50, 50,
50, 99,
50, 251,
50, 252,
50, 1449,
50, 11014,
102, 49,
102, 98,
};
const uint8_t code_eu129Codes[] PROGMEM = {
0x47,
0x00,
0x00,
0x00,
0x00,
0x00,
0x8C,
0x8C,
0x40,
0x03,
0xF1,
0xEB,
0x23,
0x10,
0x00,
0xFC,
0x74,
};
const struct IrCode code_eu129Code PROGMEM = {
freq_to_timerval(38462),
45, // # of pairs
3, // # of bits per index
code_eu129Times,
code_eu129Codes
};
/* Duplicate timing table, same as eu129 !
const uint16_t code_eu130Times[] PROGMEM = {
50, 50,
50, 99,
50, 251,
50, 252,
50, 1449,
50, 11014,
102, 49,
102, 98,
};
*/
const uint8_t code_eu130Codes[] PROGMEM = {
0x47,
0x00,
0x00,
0x00,
0x00,
0x00,
0x8C,
0x8C,
0x40,
0x03,
0xE3,
0xEB,
0x23,
0x10,
0x00,
0xF8,
0xF4,
};
const struct IrCode code_eu130Code PROGMEM = {
freq_to_timerval(38462),
45, // # of pairs
3, // # of bits per index
code_eu129Times,
code_eu130Codes
};
const uint16_t code_eu131Times[] PROGMEM = {
14, 491,
14, 743,
14, 4170,
};
const uint8_t code_eu131Codes[] PROGMEM = {
0x55,
0x55,
0x42,
0x55,
0x55,
0x41,
};
const struct IrCode code_eu131Code PROGMEM = {
freq_to_timerval(38462),
24, // # of pairs
2, // # of bits per index
code_eu131Times,
code_eu131Codes
};
/* Duplicate timing table, same as eu069 !
const uint16_t code_eu132Times[] PROGMEM = {
4, 499,
4, 750,
4, 4999,
};
*/
const uint8_t code_eu132Codes[] PROGMEM = {
0x05,
0x50,
0x06,
0x05,
0x50,
0x04,
};
const struct IrCode code_eu132Code PROGMEM = {
0, // Non-pulsed code
23, // # of pairs
2, // # of bits per index
code_eu069Times,
code_eu132Codes
};
/* Duplicate timing table, same as eu071 !
const uint16_t code_eu133Times[] PROGMEM = {
14, 491,
14, 743,
14, 4422,
};
*/
const uint8_t code_eu133Codes[] PROGMEM = {
0x55,
0x54,
0x12,
0x55,
0x54,
0x11,
};
const struct IrCode code_eu133Code PROGMEM = {
freq_to_timerval(38462),
24, // # of pairs
2, // # of bits per index
code_eu071Times,
code_eu133Codes
};
const uint16_t code_eu134Times[] PROGMEM = {
13, 490,
13, 741,
13, 742,
13, 5939,
};
const uint8_t code_eu134Codes[] PROGMEM = {
0x40,
0x0A,
0x83,
0x80,
0x0A,
0x81,
};
const struct IrCode code_eu134Code PROGMEM = {
freq_to_timerval(40000),
24, // # of pairs
2, // # of bits per index
code_eu134Times,
code_eu134Codes
};
const uint16_t code_eu135Times[] PROGMEM = {
6, 566,
6, 851,
6, 5188,
};
const uint8_t code_eu135Codes[] PROGMEM = {
0x54,
0x45,
0x46,
0x54,
0x45,
0x44,
};
const struct IrCode code_eu135Code PROGMEM = {
0, // Non-pulsed code
23, // # of pairs
2, // # of bits per index
code_eu135Times,
code_eu135Codes
};
/* Duplicate timing table, same as na004 !
const uint16_t code_eu136Times[] PROGMEM = {
55, 57,
55, 170,
55, 3949,
55, 9623,
56, 0,
898, 453,
900, 226,
};
*/
const uint8_t code_eu136Codes[] PROGMEM = {
0xA0,
0x00,
0x00,
0x04,
0x92,
0x49,
0x24,
0x00,
0x00,
0x00,
0x92,
0x49,
0x2B,
0x3D,
0x00,
};
const struct IrCode code_eu136Code PROGMEM = {
freq_to_timerval(38462),
38, // # of pairs
3, // # of bits per index
code_na004Times,
code_eu136Codes
};
const uint16_t code_eu137Times[] PROGMEM = {
86, 91,
87, 90,
87, 180,
87, 8868,
88, 0,
174, 90,
};
const uint8_t code_eu137Codes[] PROGMEM = {
0x14,
0x95,
0x4A,
0x35,
0x9A,
0x4A,
0xA5,
0x1B,
0x00,
};
const struct IrCode code_eu137Code PROGMEM = {
freq_to_timerval(35714),
22, // # of pairs
3, // # of bits per index
code_eu137Times,
code_eu137Codes
};
const uint16_t code_eu138Times[] PROGMEM = {
4, 1036,
4, 1507,
4, 3005,
};
const uint8_t code_eu138Codes[] PROGMEM = {
0x05,
0x60,
0x54,
};
const struct IrCode code_eu138Code PROGMEM = {
0, // Non-pulsed code
11, // # of pairs
2, // # of bits per index
code_eu138Times,
code_eu138Codes
};
const uint16_t code_eu139Times[] PROGMEM = {
0, 0,
14, 141,
14, 452,
14, 607,
14, 6310,
};
const uint8_t code_eu139Codes[] PROGMEM = {
0x64,
0x92,
0x4A,
0x24,
0x92,
0xE3,
0x24,
0x92,
0x51,
0x24,
0x96,
0x00,
};
const struct IrCode code_eu139Code PROGMEM = {
0, // Non-pulsed code
30, // # of pairs
3, // # of bits per index
code_eu139Times,
code_eu139Codes
};
////////////////////////////////////////////////////////////////
//const PROGMEM array (called "NApowerCodes") of const pointers to IrCode structs
//-otherwise stated: "declare NApowerCodes as PROGMEM array of const pointers to const IrCode structs"
//-to confirm this, go to http://cdecl.org/ and paste "const int* const NApowerCodes[]", and you'll
// see it means "declare NApowerCodes as array of const pointer to const int"
const IrCode* const NApowerCodes[] PROGMEM = {
&code_na000Code,
&code_na001Code,
&code_na002Code,
&code_na003Code,
&code_na004Code,
&code_na005Code,
&code_na006Code,
&code_na007Code,
&code_na008Code,
&code_na009Code,
&code_na010Code,
&code_na011Code,
&code_na012Code,
&code_na013Code,
&code_na014Code,
&code_na015Code,
&code_na016Code,
&code_na017Code,
&code_na018Code,
&code_na019Code,
&code_na020Code,
&code_na021Code,
&code_na022Code,
&code_na023Code,
&code_na024Code,
&code_na025Code,
&code_na026Code,
&code_na027Code,
&code_na028Code,
&code_na029Code,
&code_na030Code,
&code_na031Code,
&code_na032Code,
&code_na033Code,
&code_na034Code,
&code_na035Code,
&code_na036Code,
&code_na037Code,
&code_na038Code,
&code_na039Code,
&code_na040Code,
&code_na041Code,
&code_na042Code,
&code_na043Code,
&code_na044Code,
&code_na045Code,
&code_na046Code,
&code_na047Code,
&code_na048Code,
&code_na049Code,
&code_na050Code,
&code_na051Code,
&code_na052Code,
&code_na053Code,
&code_na054Code,
&code_na055Code,
&code_na056Code,
&code_na057Code,
&code_na058Code,
&code_na059Code,
&code_na060Code,
&code_na061Code,
&code_na062Code,
&code_na063Code,
&code_na064Code,
&code_na065Code,
&code_na066Code,
&code_na067Code,
&code_na068Code,
&code_na069Code,
&code_na070Code,
&code_na071Code,
&code_na072Code,
&code_na073Code,
&code_na074Code,
&code_na075Code,
&code_na076Code,
&code_na077Code,
&code_na078Code,
&code_na079Code,
&code_na080Code,
&code_na081Code,
&code_na082Code,
&code_na083Code,
&code_na084Code,
&code_na085Code,
&code_na086Code,
&code_na087Code,
&code_na088Code,
&code_na089Code,
&code_na090Code,
&code_na091Code,
&code_na092Code,
&code_na093Code,
&code_na094Code,
&code_na095Code,
&code_na096Code,
&code_na097Code,
&code_na098Code,
&code_na099Code,
&code_na100Code,
&code_na101Code,
&code_na102Code,
&code_na103Code,
&code_na104Code,
&code_na105Code,
&code_na106Code,
&code_na107Code,
&code_na108Code,
&code_na109Code,
&code_na110Code,
&code_na111Code,
&code_na112Code,
&code_na113Code,
&code_na114Code,
&code_na115Code,
&code_na116Code,
&code_na117Code,
&code_na118Code,
&code_na119Code,
&code_na120Code,
&code_na121Code,
&code_na122Code,
&code_na123Code,
&code_na124Code,
&code_na125Code,
&code_na126Code,
&code_na127Code,
&code_na128Code,
&code_na129Code,
&code_na130Code,
&code_na131Code,
&code_na132Code,
&code_na133Code,
&code_na134Code,
&code_na135Code,
&code_na136Code,
};
const IrCode* const EUpowerCodes[] PROGMEM = {
&code_eu000Code,
&code_eu001Code,
&code_eu002Code,
&code_na000Code, // same as &code_eu003Code
&code_eu004Code,
&code_eu005Code,
&code_eu006Code,
&code_eu007Code,
&code_eu008Code,
&code_na005Code, // same as &code_eu009Code
&code_na004Code, // same as &code_eu010Code
&code_eu011Code,
&code_eu012Code,
&code_eu013Code,
&code_na021Code, // same as &code_eu014Code
&code_eu015Code,
&code_eu016Code,
&code_eu017Code,
&code_eu018Code,
&code_eu019Code,
&code_eu020Code,
&code_eu021Code,
&code_eu022Code,
&code_na022Code, // same as &code_eu023Code
&code_eu024Code,
&code_eu025Code,
&code_eu026Code,
&code_eu027Code,
&code_eu028Code,
&code_eu029Code,
&code_eu030Code,
&code_eu031Code,
&code_eu032Code,
&code_eu033Code,
&code_eu034Code,
//&code_eu035Code, same as eu009
&code_eu036Code,
&code_eu037Code,
&code_eu038Code,
&code_eu039Code,
&code_eu040Code,
&code_eu041Code,
&code_eu042Code,
&code_eu043Code,
&code_eu044Code,
&code_eu045Code,
&code_eu046Code,
&code_eu047Code,
&code_eu048Code,
&code_eu049Code,
&code_eu050Code,
&code_eu051Code,
&code_eu052Code,
&code_eu053Code,
&code_eu054Code,
&code_eu055Code,
&code_eu056Code,
//&code_eu057Code, same as eu008
&code_eu058Code,
&code_eu059Code,
&code_eu060Code,
&code_eu061Code,
&code_eu062Code,
&code_eu063Code,
&code_eu064Code,
&code_eu065Code,
&code_eu066Code,
&code_eu067Code,
&code_eu068Code,
&code_eu069Code,
&code_eu070Code,
&code_eu071Code,
&code_eu072Code,
&code_eu073Code,
&code_eu074Code,
&code_eu075Code,
&code_eu076Code,
&code_eu077Code,
&code_eu078Code,
&code_eu079Code,
&code_eu080Code,
&code_eu081Code,
&code_eu082Code,
&code_eu083Code,
&code_eu084Code,
&code_eu085Code,
&code_eu086Code,
&code_eu087Code,
&code_eu088Code,
&code_eu089Code,
&code_eu090Code,
&code_eu091Code,
&code_eu092Code,
&code_eu093Code,
&code_eu094Code,
&code_eu095Code,
&code_eu096Code,
&code_eu097Code,
&code_eu098Code,
&code_eu099Code,
&code_eu100Code,
&code_eu101Code,
&code_eu102Code,
&code_eu103Code,
&code_eu104Code,
&code_eu105Code,
&code_eu106Code,
&code_eu107Code,
&code_eu108Code,
&code_eu109Code,
&code_eu110Code,
&code_eu111Code,
&code_eu112Code,
&code_eu113Code,
&code_eu114Code,
&code_eu115Code,
&code_eu116Code,
&code_eu117Code,
&code_eu118Code,
&code_eu119Code,
&code_eu120Code,
&code_eu121Code,
&code_eu122Code,
&code_eu123Code,
&code_eu124Code,
&code_eu125Code,
&code_eu126Code,
&code_eu127Code,
&code_eu128Code,
&code_eu129Code,
&code_eu130Code,
&code_eu131Code,
&code_eu132Code,
&code_eu133Code,
&code_eu134Code,
&code_eu135Code,
&code_eu136Code,
&code_eu137Code,
&code_eu138Code,
&code_eu139Code,
};
uint8_t num_NAcodes = NUM_ELEM(NApowerCodes);
uint8_t num_EUcodes = NUM_ELEM(EUpowerCodes);
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment