/* Last Updated: 30 Mar. 2018 By Anton Grimpelhuber (anton.grimpelhuber@gmail.com) Added discrete Samsung / NECv2 power off code_eu140Code 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[] = { 60, 60, 60, 2700, 120, 60, 240, 60, }; const uint8_t code_na000Codes[] = { 0xE2, 0x20, 0x80, 0x78, 0x88, 0x20, 0x10, }; const struct IrCode code_na000Code = { freq_to_timerval(38400), 26, // # of pairs 2, // # of bits per index code_na000Times, code_na000Codes }; const uint16_t code_na001Times[] = { 50, 100, 50, 200, 50, 800, 400, 400, }; const uint8_t code_na001Codes[] = { 0xD5, 0x41, 0x11, 0x00, 0x14, 0x44, 0x6D, 0x54, 0x11, 0x10, 0x01, 0x44, 0x45, }; const struct IrCode code_na001Code = { freq_to_timerval(57143), 52, // # of pairs 2, // # of bits per index code_na001Times, code_na001Codes }; const uint16_t code_na002Times[] = { 42, 46, 42, 133, 42, 7519, 347, 176, 347, 177, }; const uint8_t code_na002Codes[] = { 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 = { freq_to_timerval(37037), 100, // # of pairs 3, // # of bits per index code_na002Times, code_na002Codes }; const uint16_t code_na003Times[] = { 26, 185, 27, 80, 27, 185, 27, 4549, }; const uint8_t code_na003Codes[] = { 0x15, 0x5A, 0x65, 0x67, 0x95, 0x65, 0x9A, 0x9B, 0x95, 0x5A, 0x65, 0x67, 0x95, 0x65, 0x9A, 0x99, }; const struct IrCode code_na003Code = { freq_to_timerval(38610), 64, // # of pairs 2, // # of bits per index code_na003Times, code_na003Codes }; const uint16_t code_na004Times[] = { 55, 57, 55, 170, 55, 3949, 55, 9623, 56, 0, 898, 453, 900, 226, }; const uint8_t code_na004Codes[] = { 0xA0, 0x00, 0x01, 0x04, 0x92, 0x48, 0x20, 0x80, 0x40, 0x04, 0x12, 0x09, 0x2B, 0x3D, 0x00, }; const struct IrCode code_na004Code = { freq_to_timerval(38610), 38, // # of pairs 3, // # of bits per index code_na004Times, code_na004Codes }; const uint16_t code_na005Times[] = { 88, 90, 88, 91, 88, 181, 88, 8976, 177, 91, }; const uint8_t code_na005Codes[] = { 0x10, 0x92, 0x49, 0x46, 0x33, 0x09, 0x24, 0x94, 0x60, }; const struct IrCode code_na005Code = { freq_to_timerval(35714), 24, // # of pairs 3, // # of bits per index code_na005Times, code_na005Codes }; const uint16_t code_na006Times[] = { 50, 62, 50, 172, 50, 4541, 448, 466, 450, 465, }; const uint8_t code_na006Codes[] = { 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 = { freq_to_timerval(38462), 68, // # of pairs 3, // # of bits per index code_na006Times, code_na006Codes }; const uint16_t code_na007Times[] = { 49, 49, 49, 50, 49, 410, 49, 510, 49, 12107, }; const uint8_t code_na007Codes[] = { 0x09, 0x94, 0x53, 0x29, 0x94, 0xD9, 0x85, 0x32, 0x8A, 0x65, 0x32, 0x9B, 0x20, }; const struct IrCode code_na007Code = { freq_to_timerval(39216), 34, // # of pairs 3, // # of bits per index code_na007Times, code_na007Codes }; const uint16_t code_na008Times[] = { 56, 58, 56, 170, 56, 4011, 898, 450, 900, 449, }; const uint8_t code_na008Codes[] = { 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 = { freq_to_timerval(38462), 68, // # of pairs 3, // # of bits per index code_na008Times, code_na008Codes }; const uint16_t code_na009Times[] = { 53, 56, 53, 171, 53, 3950, 53, 9599, 898, 451, 900, 226, }; const uint8_t code_na009Codes[] = { 0x84, 0x90, 0x00, 0x20, 0x80, 0x08, 0x00, 0x00, 0x09, 0x24, 0x92, 0x40, 0x0A, 0xBA, 0x40, }; const struct IrCode code_na009Code = { freq_to_timerval(38462), 38, // # of pairs 3, // # of bits per index code_na009Times, code_na009Codes }; const uint16_t code_na010Times[] = { 51, 55, 51, 158, 51, 2286, 841, 419, }; const uint8_t code_na010Codes[] = { 0xD4, 0x00, 0x15, 0x10, 0x25, 0x00, 0x05, 0x44, 0x09, 0x40, 0x01, 0x51, 0x01, }; const struct IrCode code_na010Code = { freq_to_timerval(38462), 52, // # of pairs 2, // # of bits per index code_na010Times, code_na010Codes }; const uint16_t code_na011Times[] = { 55, 55, 55, 172, 55, 4039, 55, 9348, 56, 0, 884, 442, 885, 225, }; const uint8_t code_na011Codes[] = { 0xA0, 0x00, 0x41, 0x04, 0x92, 0x08, 0x24, 0x90, 0x40, 0x00, 0x02, 0x09, 0x2B, 0x3D, 0x00, }; const struct IrCode code_na011Code = { freq_to_timerval(38462), 38, // # of pairs 3, // # of bits per index code_na011Times, code_na011Codes }; const uint16_t code_na012Times[] = { 81, 87, 81, 254, 81, 3280, 331, 336, 331, 337, }; const uint8_t code_na012Codes[] = { 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 = { freq_to_timerval(38462), 52, // # of pairs 3, // # of bits per index code_na012Times, code_na012Codes }; const uint16_t code_na013Times[] = { 53, 55, 53, 167, 53, 2304, 53, 9369, 893, 448, 895, 447, }; const uint8_t code_na013Codes[] = { 0x80, 0x12, 0x40, 0x04, 0x00, 0x09, 0x00, 0x12, 0x41, 0x24, 0x82, 0x01, 0x00, 0x10, 0x48, 0x24, 0xAA, 0xE8, }; const struct IrCode code_na013Code = { 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[] = { 55, 57, 55, 170, 55, 3949, 55, 9623, 56, 0, 898, 453, 900, 226, }; */ const uint8_t code_na014Codes[] = { 0xA0, 0x00, 0x09, 0x04, 0x92, 0x40, 0x24, 0x80, 0x00, 0x00, 0x12, 0x49, 0x2B, 0x3D, 0x00, }; const struct IrCode code_na014Code = { 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[] = { 55, 57, 55, 170, 55, 3949, 55, 9623, 56, 0, 898, 453, 900, 226, }; */ const uint8_t code_na015Codes[] = { 0xA0, 0x80, 0x01, 0x04, 0x12, 0x48, 0x24, 0x00, 0x00, 0x00, 0x92, 0x49, 0x2B, 0x3D, 0x00, }; const struct IrCode code_na015Code = { freq_to_timerval(38462), 38, // # of pairs 3, // # of bits per index code_na004Times, code_na015Codes }; const uint16_t code_na016Times[] = { 28, 90, 28, 211, 28, 2507, }; const uint8_t code_na016Codes[] = { 0x54, 0x04, 0x10, 0x00, 0x95, 0x01, 0x04, 0x00, 0x10, }; const struct IrCode code_na016Code = { freq_to_timerval(34483), 34, // # of pairs 2, // # of bits per index code_na016Times, code_na016Codes }; const uint16_t code_na017Times[] = { 56, 57, 56, 175, 56, 4150, 56, 9499, 898, 227, 898, 449, }; const uint8_t code_na017Codes[] = { 0xA0, 0x02, 0x48, 0x04, 0x90, 0x01, 0x20, 0x80, 0x40, 0x04, 0x12, 0x09, 0x2A, 0x38, 0x00, }; const struct IrCode code_na017Code = { freq_to_timerval(40000), 38, // # of pairs 3, // # of bits per index code_na017Times, code_na017Codes }; const uint16_t code_na018Times[] = { 51, 55, 51, 161, 51, 2566, 849, 429, 849, 430, }; const uint8_t code_na018Codes[] = { 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 = { freq_to_timerval(38462), 136, // # of pairs 3, // # of bits per index code_na018Times, code_na018Codes }; const uint16_t code_na019Times[] = { 40, 42, 40, 124, 40, 4601, 325, 163, 326, 163, }; const uint8_t code_na019Codes[] = { 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 = { freq_to_timerval(38462), 100, // # of pairs 3, // # of bits per index code_na019Times, code_na019Codes }; const uint16_t code_na020Times[] = { 60, 55, 60, 163, 60, 4099, 60, 9698, 61, 0, 898, 461, 900, 230, }; const uint8_t code_na020Codes[] = { 0xA0, 0x10, 0x00, 0x04, 0x82, 0x49, 0x20, 0x02, 0x00, 0x04, 0x90, 0x49, 0x2B, 0x3D, 0x00, }; const struct IrCode code_na020Code = { freq_to_timerval(38462), 38, // # of pairs 3, // # of bits per index code_na020Times, code_na020Codes }; const uint16_t code_na021Times[] = { 48, 52, 48, 160, 48, 400, 48, 2335, 799, 400, }; const uint8_t code_na021Codes[] = { 0x80, 0x10, 0x40, 0x08, 0x82, 0x08, 0x01, 0xC0, 0x08, 0x20, 0x04, 0x41, 0x04, 0x00, 0x00, }; const struct IrCode code_na021Code = { freq_to_timerval(38462), 38, // # of pairs 3, // # of bits per index code_na021Times, code_na021Codes }; const uint16_t code_na022Times[] = { 53, 60, 53, 175, 53, 4463, 53, 9453, 892, 450, 895, 225, }; const uint8_t code_na022Codes[] = { 0x80, 0x02, 0x40, 0x00, 0x02, 0x40, 0x00, 0x00, 0x01, 0x24, 0x92, 0x48, 0x0A, 0xBA, 0x00, }; const struct IrCode code_na022Code = { freq_to_timerval(38462), 38, // # of pairs 3, // # of bits per index code_na022Times, code_na022Codes }; const uint16_t code_na023Times[] = { 48, 52, 48, 409, 48, 504, 48, 10461, }; const uint8_t code_na023Codes[] = { 0xA1, 0x18, 0x61, 0xA1, 0x18, 0x7A, 0x11, 0x86, 0x1A, 0x11, 0x86, }; const struct IrCode code_na023Code = { freq_to_timerval(40000), 44, // # of pairs 2, // # of bits per index code_na023Times, code_na023Codes }; const uint16_t code_na024Times[] = { 58, 60, 58, 2569, 118, 60, 237, 60, 238, 60, }; const uint8_t code_na024Codes[] = { 0x69, 0x24, 0x10, 0x40, 0x03, 0x12, 0x48, 0x20, 0x80, 0x00, }; const struct IrCode code_na024Code = { freq_to_timerval(38462), 26, // # of pairs 3, // # of bits per index code_na024Times, code_na024Codes }; const uint16_t code_na025Times[] = { 84, 90, 84, 264, 84, 3470, 346, 350, 347, 350, }; const uint8_t code_na025Codes[] = { 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 = { freq_to_timerval(38462), 52, // # of pairs 3, // # of bits per index code_na025Times, code_na025Codes }; const uint16_t code_na026Times[] = { 49, 49, 49, 50, 49, 410, 49, 510, 49, 12582, }; const uint8_t code_na026Codes[] = { 0x09, 0x94, 0x53, 0x65, 0x32, 0x99, 0x85, 0x32, 0x8A, 0x6C, 0xA6, 0x53, 0x20, }; const struct IrCode code_na026Code = { 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[] = { 50, 100, 50, 200, 50, 800, 400, 400, }; */ const uint8_t code_na027Codes[] = { 0xC5, 0x41, 0x11, 0x10, 0x14, 0x44, 0x6C, 0x54, 0x11, 0x11, 0x01, 0x44, 0x44, }; const struct IrCode code_na027Code = { freq_to_timerval(57143), 52, // # of pairs 2, // # of bits per index code_na001Times, code_na027Codes }; const uint16_t code_na028Times[] = { 118, 121, 118, 271, 118, 4750, 258, 271, }; const uint8_t code_na028Codes[] = { 0xC4, 0x45, 0x14, 0x04, 0x6C, 0x44, 0x51, 0x40, 0x44, }; const struct IrCode code_na028Code = { freq_to_timerval(38610), 36, // # of pairs 2, // # of bits per index code_na028Times, code_na028Codes }; const uint16_t code_na029Times[] = { 88, 90, 88, 91, 88, 181, 177, 91, 177, 8976, }; const uint8_t code_na029Codes[] = { 0x0C, 0x92, 0x53, 0x46, 0x16, 0x49, 0x29, 0xA2, 0xC0, }; const struct IrCode code_na029Code = { 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[] = { 53, 56, 53, 171, 53, 3950, 53, 9599, 898, 451, 900, 226, }; */ const uint8_t code_na030Codes[] = { 0x80, 0x00, 0x41, 0x04, 0x12, 0x08, 0x20, 0x00, 0x00, 0x04, 0x92, 0x49, 0x2A, 0xBA, 0x00, }; const struct IrCode code_na030Code = { freq_to_timerval(38462), 38, // # of pairs 3, // # of bits per index code_na009Times, code_na030Codes }; const uint16_t code_na031Times[] = { 88, 89, 88, 90, 88, 179, 88, 8977, 177, 90, }; const uint8_t code_na031Codes[] = { 0x06, 0x12, 0x49, 0x46, 0x32, 0x61, 0x24, 0x94, 0x60, }; const struct IrCode code_na031Code = { 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[] = { 53, 56, 53, 171, 53, 3950, 53, 9599, 898, 451, 900, 226, }; */ const uint8_t code_na032Codes[] = { 0x80, 0x00, 0x41, 0x04, 0x12, 0x08, 0x20, 0x80, 0x00, 0x04, 0x12, 0x49, 0x2A, 0xBA, 0x00, }; const struct IrCode code_na032Code = { freq_to_timerval(38462), 38, // # of pairs 3, // # of bits per index code_na009Times, code_na032Codes }; const uint16_t code_na033Times[] = { 40, 43, 40, 122, 40, 5297, 334, 156, 336, 155, }; const uint8_t code_na033Codes[] = { 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 = { 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[] = { 55, 57, 55, 170, 55, 3949, 55, 9623, 56, 0, 898, 453, 900, 226, }; */ const uint8_t code_na034Codes[] = { 0xA0, 0x00, 0x41, 0x04, 0x92, 0x08, 0x24, 0x92, 0x48, 0x00, 0x00, 0x01, 0x2B, 0x3D, 0x00, }; const struct IrCode code_na034Code = { freq_to_timerval(38462), 38, // # of pairs 3, // # of bits per index code_na004Times, code_na034Codes }; const uint16_t code_na035Times[] = { 96, 93, 97, 93, 97, 287, 97, 3431, }; const uint8_t code_na035Codes[] = { 0x16, 0x66, 0x5D, 0x59, 0x99, 0x50, }; const struct IrCode code_na035Code = { freq_to_timerval(41667), 22, // # of pairs 2, // # of bits per index code_na035Times, code_na035Codes }; const uint16_t code_na036Times[] = { 82, 581, 84, 250, 84, 580, 85, 0, }; const uint8_t code_na036Codes[] = { 0x15, 0x9A, 0x9C, }; const struct IrCode code_na036Code = { freq_to_timerval(37037), 11, // # of pairs 2, // # of bits per index code_na036Times, code_na036Codes }; const uint16_t code_na037Times[] = { 39, 263, 164, 163, 514, 164, }; const uint8_t code_na037Codes[] = { 0x80, 0x45, 0x00, }; const struct IrCode code_na037Code = { 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[] = { 56, 57, 56, 175, 56, 4150, 56, 9499, 898, 227, 898, 449, }; */ const uint8_t code_na038Codes[] = { 0xA4, 0x10, 0x40, 0x00, 0x82, 0x09, 0x20, 0x80, 0x40, 0x04, 0x12, 0x09, 0x2A, 0x38, 0x40, }; const struct IrCode code_na038Code = { freq_to_timerval(40000), 38, // # of pairs 3, // # of bits per index code_na017Times, code_na038Codes }; const uint16_t code_na039Times[] = { 113, 101, 688, 2707, }; const uint8_t code_na039Codes[] = { 0x11, }; const struct IrCode code_na039Code = { freq_to_timerval(40000), 4, // # of pairs 2, // # of bits per index code_na039Times, code_na039Codes }; const uint16_t code_na040Times[] = { 113, 101, 113, 201, 113, 2707, }; const uint8_t code_na040Codes[] = { 0x06, 0x04, }; const struct IrCode code_na040Code = { freq_to_timerval(40000), 8, // # of pairs 2, // # of bits per index code_na040Times, code_na040Codes }; const uint16_t code_na041Times[] = { 58, 62, 58, 2746, 117, 62, 242, 62, }; const uint8_t code_na041Codes[] = { 0xE2, 0x20, 0x80, 0x78, 0x88, 0x20, 0x00, }; const struct IrCode code_na041Code = { freq_to_timerval(76923), 26, // # of pairs 2, // # of bits per index code_na041Times, code_na041Codes }; const uint16_t code_na042Times[] = { 54, 65, 54, 170, 54, 4099, 54, 8668, 899, 226, 899, 421, }; const uint8_t code_na042Codes[] = { 0xA4, 0x80, 0x00, 0x20, 0x82, 0x49, 0x00, 0x02, 0x00, 0x04, 0x90, 0x49, 0x2A, 0x38, 0x40, }; const struct IrCode code_na042Code = { freq_to_timerval(40000), 38, // # of pairs 3, // # of bits per index code_na042Times, code_na042Codes }; const uint16_t code_na043Times[] = { 43, 120, 43, 121, 43, 3491, 131, 45, }; const uint8_t code_na043Codes[] = { 0x15, 0x75, 0x56, 0x55, 0x75, 0x54, }; const struct IrCode code_na043Code = { freq_to_timerval(40000), 24, // # of pairs 2, // # of bits per index code_na043Times, code_na043Codes }; const uint16_t code_na044Times[] = { 51, 51, 51, 160, 51, 4096, 51, 9513, 431, 436, 883, 219, }; const uint8_t code_na044Codes[] = { 0x84, 0x90, 0x00, 0x00, 0x02, 0x49, 0x20, 0x80, 0x00, 0x04, 0x12, 0x49, 0x2A, 0xBA, 0x40, }; const struct IrCode code_na044Code = { freq_to_timerval(40000), 38, // # of pairs 3, // # of bits per index code_na044Times, code_na044Codes }; const uint16_t code_na045Times[] = { 58, 53, 58, 167, 58, 4494, 58, 9679, 455, 449, 456, 449, }; const uint8_t code_na045Codes[] = { 0x80, 0x90, 0x00, 0x00, 0x90, 0x00, 0x04, 0x92, 0x00, 0x00, 0x00, 0x49, 0x2A, 0x97, 0x48, }; const struct IrCode code_na045Code = { freq_to_timerval(38462), 40, // # of pairs 3, // # of bits per index code_na045Times, code_na045Codes }; const uint16_t code_na046Times[] = { 51, 277, 52, 53, 52, 105, 52, 277, 52, 2527, 52, 12809, 103, 54, }; const uint8_t code_na046Codes[] = { 0x0B, 0x12, 0x63, 0x44, 0x92, 0x6B, 0x44, 0x92, 0x50, }; const struct IrCode code_na046Code = { 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[] = { 56, 57, 56, 175, 56, 4150, 56, 9499, 898, 227, 898, 449, }; */ const uint8_t code_na047Codes[] = { 0xA0, 0x00, 0x40, 0x04, 0x92, 0x09, 0x24, 0x92, 0x09, 0x20, 0x00, 0x40, 0x0A, 0x38, 0x00, }; const struct IrCode code_na047Code = { 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[] = { 51, 51, 51, 160, 51, 4096, 51, 9513, 431, 436, 883, 219, }; */ const uint8_t code_na048Codes[] = { 0x80, 0x00, 0x00, 0x04, 0x92, 0x49, 0x24, 0x92, 0x00, 0x00, 0x00, 0x49, 0x2A, 0xBA, 0x00, }; const struct IrCode code_na048Code = { freq_to_timerval(40000), 38, // # of pairs 3, // # of bits per index code_na044Times, code_na048Codes }; const uint16_t code_na049Times[] = { 274, 854, 274, 1986, }; const uint8_t code_na049Codes[] = { 0x14, 0x11, 0x40, }; const struct IrCode code_na049Code = { freq_to_timerval(45455), 11, // # of pairs 2, // # of bits per index code_na049Times, code_na049Codes }; const uint16_t code_na050Times[] = { 80, 88, 80, 254, 80, 3750, 359, 331, }; const uint8_t code_na050Codes[] = { 0xC0, 0x00, 0x01, 0x55, 0x55, 0x52, 0xC0, 0x00, 0x01, 0x55, 0x55, 0x50, }; const struct IrCode code_na050Code = { 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[] = { 56, 57, 56, 175, 56, 4150, 56, 9499, 898, 227, 898, 449, }; */ const uint8_t code_na051Codes[] = { 0xA0, 0x10, 0x01, 0x24, 0x82, 0x48, 0x00, 0x02, 0x40, 0x04, 0x90, 0x09, 0x2A, 0x38, 0x00, }; const struct IrCode code_na051Code = { 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[] = { 56, 57, 56, 175, 56, 4150, 56, 9499, 898, 227, 898, 449, }; */ const uint8_t code_na052Codes[] = { 0xA4, 0x90, 0x48, 0x00, 0x02, 0x01, 0x20, 0x80, 0x40, 0x04, 0x12, 0x09, 0x2A, 0x38, 0x40, }; const struct IrCode code_na052Code = { freq_to_timerval(40000), 38, // # of pairs 3, // # of bits per index code_na017Times, code_na052Codes }; const uint16_t code_na053Times[] = { 51, 232, 51, 512, 51, 792, 51, 2883, }; const uint8_t code_na053Codes[] = { 0x22, 0x21, 0x40, 0x1C, 0x88, 0x85, 0x00, 0x40, }; const struct IrCode code_na053Code = { 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[] = { 51, 232, 51, 512, 51, 792, 51, 2883, }; */ const uint8_t code_na054Codes[] = { 0x22, 0x20, 0x15, 0x72, 0x22, 0x01, 0x54, }; const struct IrCode code_na054Code = { freq_to_timerval(55556), 28, // # of pairs 2, // # of bits per index code_na053Times, code_na054Codes }; const uint16_t code_na055Times[] = { 3, 10, 3, 20, 3, 30, 3, 12778, }; const uint8_t code_na055Codes[] = { 0x81, 0x51, 0x14, 0xB8, 0x15, 0x11, 0x44, }; const struct IrCode code_na055Code = { 0, // Non-pulsed code 27, // # of pairs 2, // # of bits per index code_na055Times, code_na055Codes }; const uint16_t code_na056Times[] = { 55, 193, 57, 192, 57, 384, 58, 0, }; const uint8_t code_na056Codes[] = { 0x2A, 0x57, }; const struct IrCode code_na056Code = { freq_to_timerval(37175), 8, // # of pairs 2, // # of bits per index code_na056Times, code_na056Codes }; const uint16_t code_na057Times[] = { 45, 148, 46, 148, 46, 351, 46, 2781, }; const uint8_t code_na057Codes[] = { 0x2A, 0x5D, 0xA9, 0x60, }; const struct IrCode code_na057Code = { freq_to_timerval(40000), 14, // # of pairs 2, // # of bits per index code_na057Times, code_na057Codes }; const uint16_t code_na058Times[] = { 22, 101, 22, 219, 23, 101, 23, 219, 31, 218, }; const uint8_t code_na058Codes[] = { 0x8D, 0xA4, 0x08, 0x04, 0x04, 0x92, 0x4C, }; const struct IrCode code_na058Code = { 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[] = { 56, 57, 56, 175, 56, 4150, 56, 9499, 898, 227, 898, 449, }; */ const uint8_t code_na059Codes[] = { 0xA4, 0x12, 0x09, 0x00, 0x80, 0x40, 0x20, 0x10, 0x40, 0x04, 0x82, 0x09, 0x2A, 0x38, 0x40, }; const struct IrCode code_na059Code = { 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[] = { 56, 57, 56, 175, 56, 4150, 56, 9499, 898, 227, 898, 449, }; */ const uint8_t code_na060Codes[] = { 0xA0, 0x00, 0x08, 0x04, 0x92, 0x41, 0x24, 0x00, 0x40, 0x00, 0x92, 0x09, 0x2A, 0x38, 0x00, }; const struct IrCode code_na060Code = { 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[] = { 56, 57, 56, 175, 56, 4150, 56, 9499, 898, 227, 898, 449, }; */ const uint8_t code_na061Codes[] = { 0xA0, 0x00, 0x08, 0x24, 0x92, 0x41, 0x04, 0x82, 0x00, 0x00, 0x10, 0x49, 0x2A, 0x38, 0x00, }; const struct IrCode code_na061Code = { 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[] = { 56, 57, 56, 175, 56, 4150, 56, 9499, 898, 227, 898, 449, }; */ const uint8_t code_na062Codes[] = { 0xA0, 0x02, 0x08, 0x04, 0x90, 0x41, 0x24, 0x82, 0x00, 0x00, 0x10, 0x49, 0x2A, 0x38, 0x00, }; const struct IrCode code_na062Code = { 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[] = { 56, 57, 56, 175, 56, 4150, 56, 9499, 898, 227, 898, 449, }; */ const uint8_t code_na063Codes[] = { 0xA4, 0x92, 0x49, 0x20, 0x00, 0x00, 0x04, 0x92, 0x48, 0x00, 0x00, 0x01, 0x2A, 0x38, 0x40, }; const struct IrCode code_na063Code = { 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[] = { 50, 100, 50, 200, 50, 800, 400, 400, }; */ const uint8_t code_na064Codes[] = { 0xC0, 0x01, 0x51, 0x55, 0x54, 0x04, 0x2C, 0x00, 0x15, 0x15, 0x55, 0x40, 0x40, }; const struct IrCode code_na064Code = { freq_to_timerval(57143), 52, // # of pairs 2, // # of bits per index code_na001Times, code_na064Codes }; const uint16_t code_na065Times[] = { 48, 98, 48, 197, 98, 846, 395, 392, 1953, 392, }; const uint8_t code_na065Codes[] = { 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 = { freq_to_timerval(59172), 78, // # of pairs 3, // # of bits per index code_na065Times, code_na065Codes }; const uint16_t code_na066Times[] = { 38, 276, 165, 154, 415, 155, 742, 154, }; const uint8_t code_na066Codes[] = { 0xC0, 0x45, 0x02, 0x01, 0x14, 0x08, 0x04, 0x50, 0x00, }; const struct IrCode code_na066Code = { 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[] = { 51, 51, 51, 160, 51, 4096, 51, 9513, 431, 436, 883, 219, }; */ const uint8_t code_na067Codes[] = { 0x80, 0x02, 0x49, 0x24, 0x90, 0x00, 0x00, 0x80, 0x00, 0x04, 0x12, 0x49, 0x2A, 0xBA, 0x00, }; const struct IrCode code_na067Code = { freq_to_timerval(40000), 38, // # of pairs 3, // # of bits per index code_na044Times, code_na067Codes }; const uint16_t code_na068Times[] = { 43, 121, 43, 9437, 130, 45, 131, 45, }; const uint8_t code_na068Codes[] = { 0x8C, 0x30, 0x0D, 0xCC, 0x30, 0x0C, }; const struct IrCode code_na068Code = { 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[] = { 56, 57, 56, 175, 56, 4150, 56, 9499, 898, 227, 898, 449, }; */ const uint8_t code_na069Codes[] = { 0xA0, 0x00, 0x00, 0x04, 0x92, 0x49, 0x24, 0x82, 0x00, 0x00, 0x10, 0x49, 0x2A, 0x38, 0x00, }; const struct IrCode code_na069Code = { freq_to_timerval(40000), 38, // # of pairs 3, // # of bits per index code_na017Times, code_na069Codes }; const uint16_t code_na070Times[] = { 27, 76, 27, 182, 27, 183, 27, 3199, }; const uint8_t code_na070Codes[] = { 0x40, 0x02, 0x08, 0xA2, 0xE0, 0x00, 0x82, 0x28, 0x40, }; const struct IrCode code_na070Code = { freq_to_timerval(38462), 33, // # of pairs 2, // # of bits per index code_na070Times, code_na070Codes }; const uint16_t code_na071Times[] = { 37, 181, 37, 272, }; const uint8_t code_na071Codes[] = { 0x11, 0x40, }; const struct IrCode code_na071Code = { 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[] = { 54, 65, 54, 170, 54, 4099, 54, 8668, 899, 226, 899, 421, }; */ const uint8_t code_na072Codes[] = { 0xA0, 0x90, 0x00, 0x00, 0x90, 0x00, 0x00, 0x10, 0x40, 0x04, 0x82, 0x09, 0x2A, 0x38, 0x00, }; const struct IrCode code_na072Code = { 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[] = { 56, 57, 56, 175, 56, 4150, 56, 9499, 898, 227, 898, 449, }; */ const uint8_t code_na073Codes[] = { 0xA0, 0x82, 0x08, 0x24, 0x10, 0x41, 0x00, 0x00, 0x00, 0x24, 0x92, 0x49, 0x0A, 0x38, 0x00, }; const struct IrCode code_na073Code = { 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[] = { 56, 57, 56, 175, 56, 4150, 56, 9499, 898, 227, 898, 449, }; */ const uint8_t code_na074Codes[] = { 0xA4, 0x00, 0x41, 0x00, 0x92, 0x08, 0x20, 0x02, 0x00, 0x04, 0x90, 0x49, 0x2A, 0x38, 0x40, }; const struct IrCode code_na074Code = { freq_to_timerval(40000), 38, // # of pairs 3, // # of bits per index code_na017Times, code_na074Codes }; const uint16_t code_na075Times[] = { 51, 98, 51, 194, 102, 931, 390, 390, 390, 391, }; const uint8_t code_na075Codes[] = { 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 = { 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[] = { 56, 57, 56, 175, 56, 4150, 56, 9499, 898, 227, 898, 449, }; */ const uint8_t code_na076Codes[] = { 0xA0, 0x92, 0x09, 0x04, 0x00, 0x40, 0x20, 0x10, 0x40, 0x04, 0x82, 0x09, 0x2A, 0x38, 0x00, }; const struct IrCode code_na076Code = { 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[] = { 88, 89, 88, 90, 88, 179, 88, 8977, 177, 90, }; */ const uint8_t code_na077Codes[] = { 0x10, 0xA2, 0x62, 0x31, 0x98, 0x51, 0x31, 0x18, 0x00, }; const struct IrCode code_na077Code = { freq_to_timerval(35714), 22, // # of pairs 3, // # of bits per index code_na031Times, code_na077Codes }; const uint16_t code_na078Times[] = { 40, 275, 160, 154, 480, 155, }; const uint8_t code_na078Codes[] = { 0x80, 0x45, 0x04, 0x01, 0x14, 0x10, 0x04, 0x50, 0x40, }; const struct IrCode code_na078Code = { 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[] = { 56, 57, 56, 175, 56, 4150, 56, 9499, 898, 227, 898, 449, }; */ const uint8_t code_na079Codes[] = { 0xA0, 0x82, 0x08, 0x24, 0x10, 0x41, 0x04, 0x90, 0x08, 0x20, 0x02, 0x41, 0x0A, 0x38, 0x00, }; const struct IrCode code_na079Code = { 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[] = { 3, 10, 3, 20, 3, 30, 3, 12778, }; */ const uint8_t code_na080Codes[] = { 0x81, 0x50, 0x40, 0xB8, 0x15, 0x04, 0x08, }; const struct IrCode code_na080Code = { 0, // Non-pulsed code 27, // # of pairs 2, // # of bits per index code_na055Times, code_na080Codes }; const uint16_t code_na081Times[] = { 48, 52, 48, 409, 48, 504, 48, 9978, }; const uint8_t code_na081Codes[] = { 0x18, 0x46, 0x18, 0x68, 0x47, 0x18, 0x46, 0x18, 0x68, 0x44, }; const struct IrCode code_na081Code = { freq_to_timerval(40000), 40, // # of pairs 2, // # of bits per index code_na081Times, code_na081Codes }; const uint16_t code_na082Times[] = { 88, 89, 88, 90, 88, 179, 88, 8888, 177, 90, 177, 179, }; const uint8_t code_na082Codes[] = { 0x0A, 0x12, 0x49, 0x2A, 0xB2, 0xA1, 0x24, 0x92, 0xA8, }; const struct IrCode code_na082Code = { 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[] = { 88, 89, 88, 90, 88, 179, 88, 8977, 177, 90, }; */ const uint8_t code_na083Codes[] = { 0x10, 0x92, 0x49, 0x46, 0x33, 0x09, 0x24, 0x94, 0x60, }; const struct IrCode code_na083Code = { freq_to_timerval(35714), 24, // # of pairs 3, // # of bits per index code_na031Times, code_na083Codes }; const uint16_t code_na084Times[] = { 41, 43, 41, 128, 41, 7476, 336, 171, 338, 169, }; const uint8_t code_na084Codes[] = { 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 = { freq_to_timerval(37037), 100, // # of pairs 3, // # of bits per index code_na084Times, code_na084Codes }; const uint16_t code_na085Times[] = { 55, 60, 55, 165, 55, 2284, 445, 437, 448, 436, }; const uint8_t code_na085Codes[] = { 0x64, 0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0x80, 0xA1, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x20, 0x10, }; const struct IrCode code_na085Code = { freq_to_timerval(38462), 44, // # of pairs 3, // # of bits per index code_na085Times, code_na085Codes }; const uint16_t code_na086Times[] = { 42, 46, 42, 126, 42, 6989, 347, 176, 347, 177, }; const uint8_t code_na086Codes[] = { 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 = { freq_to_timerval(37175), 100, // # of pairs 3, // # of bits per index code_na086Times, code_na086Codes }; const uint16_t code_na087Times[] = { 56, 69, 56, 174, 56, 4165, 56, 9585, 880, 222, 880, 435, }; const uint8_t code_na087Codes[] = { 0xA0, 0x02, 0x40, 0x04, 0x90, 0x09, 0x20, 0x02, 0x00, 0x04, 0x90, 0x49, 0x2A, 0x38, 0x00, }; const struct IrCode code_na087Code = { 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[] = { 53, 56, 53, 171, 53, 3950, 53, 9599, 898, 451, 900, 226, }; */ const uint8_t code_na088Codes[] = { 0x80, 0x00, 0x40, 0x04, 0x12, 0x08, 0x04, 0x92, 0x40, 0x00, 0x00, 0x09, 0x2A, 0xBA, 0x00, }; const struct IrCode code_na088Code = { 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[] = { 55, 57, 55, 170, 55, 3949, 55, 9623, 56, 0, 898, 453, 900, 226, }; */ const uint8_t code_na089Codes[] = { 0xA0, 0x02, 0x00, 0x04, 0x90, 0x49, 0x20, 0x80, 0x40, 0x04, 0x12, 0x09, 0x2B, 0x3D, 0x00, }; const struct IrCode code_na089Code = { freq_to_timerval(38462), 38, // # of pairs 3, // # of bits per index code_na004Times, code_na089Codes }; const uint16_t code_na090Times[] = { 88, 90, 88, 91, 88, 181, 88, 8976, 177, 91, 177, 181, }; const uint8_t code_na090Codes[] = { 0x10, 0xAB, 0x11, 0x8C, 0xC2, 0xAC, 0x46, 0x00, }; const struct IrCode code_na090Code = { freq_to_timerval(35714), 20, // # of pairs 3, // # of bits per index code_na090Times, code_na090Codes }; const uint16_t code_na091Times[] = { 48, 100, 48, 200, 48, 1050, 400, 400, }; const uint8_t code_na091Codes[] = { 0xD5, 0x41, 0x51, 0x40, 0x14, 0x04, 0x2D, 0x54, 0x15, 0x14, 0x01, 0x40, 0x41, }; const struct IrCode code_na091Code = { freq_to_timerval(58824), 52, // # of pairs 2, // # of bits per index code_na091Times, code_na091Codes }; const uint16_t code_na092Times[] = { 54, 56, 54, 170, 54, 4927, 451, 447, }; const uint8_t code_na092Codes[] = { 0xD1, 0x00, 0x11, 0x00, 0x04, 0x00, 0x11, 0x55, 0x6D, 0x10, 0x01, 0x10, 0x00, 0x40, 0x01, 0x15, 0x55, }; const struct IrCode code_na092Code = { freq_to_timerval(38462), 68, // # of pairs 2, // # of bits per index code_na092Times, code_na092Codes }; const uint16_t code_na093Times[] = { 55, 57, 55, 167, 55, 4400, 895, 448, 897, 447, }; const uint8_t code_na093Codes[] = { 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 = { 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[] = { 88, 90, 88, 91, 88, 181, 88, 8976, 177, 91, }; */ const uint8_t code_na094Codes[] = { 0x10, 0x94, 0x62, 0x31, 0x98, 0x4A, 0x31, 0x18, 0x00, }; const struct IrCode code_na094Code = { freq_to_timerval(35714), 22, // # of pairs 3, // # of bits per index code_na005Times, code_na094Codes }; const uint16_t code_na095Times[] = { 56, 58, 56, 174, 56, 4549, 56, 9448, 440, 446, }; const uint8_t code_na095Codes[] = { 0x80, 0x02, 0x00, 0x00, 0x02, 0x00, 0x04, 0x82, 0x00, 0x00, 0x10, 0x49, 0x2A, 0x17, 0x08, }; const struct IrCode code_na095Code = { 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[] = { 53, 56, 53, 171, 53, 3950, 53, 9599, 898, 451, 900, 226, }; */ const uint8_t code_na096Codes[] = { 0x80, 0x80, 0x40, 0x04, 0x92, 0x49, 0x20, 0x92, 0x00, 0x04, 0x00, 0x49, 0x2A, 0xBA, 0x00, }; const struct IrCode code_na096Code = { 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[] = { 53, 56, 53, 171, 53, 3950, 53, 9599, 898, 451, 900, 226, }; */ const uint8_t code_na097Codes[] = { 0x84, 0x80, 0x00, 0x24, 0x10, 0x41, 0x00, 0x80, 0x01, 0x24, 0x12, 0x48, 0x0A, 0xBA, 0x40, }; const struct IrCode code_na097Code = { 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[] = { 55, 57, 55, 170, 55, 3949, 55, 9623, 56, 0, 898, 453, 900, 226, }; */ const uint8_t code_na098Codes[] = { 0xA0, 0x00, 0x00, 0x04, 0x92, 0x49, 0x24, 0x00, 0x41, 0x00, 0x92, 0x08, 0x2B, 0x3D, 0x00, }; const struct IrCode code_na098Code = { 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[] = { 53, 56, 53, 171, 53, 3950, 53, 9599, 898, 451, 900, 226, }; */ const uint8_t code_na099Codes[] = { 0x80, 0x00, 0x00, 0x04, 0x12, 0x48, 0x24, 0x00, 0x00, 0x00, 0x92, 0x49, 0x2A, 0xBA, 0x00, }; const struct IrCode code_na099Code = { freq_to_timerval(38462), 38, // # of pairs 3, // # of bits per index code_na009Times, code_na099Codes }; const uint16_t code_na100Times[] = { 43, 171, 45, 60, 45, 170, 54, 2301, }; const uint8_t code_na100Codes[] = { 0x29, 0x59, 0x65, 0x55, 0xEA, 0x56, 0x59, 0x55, 0x70, }; const struct IrCode code_na100Code = { 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[] = { 55, 57, 55, 170, 55, 3949, 55, 9623, 56, 0, 898, 453, 900, 226, }; */ const uint8_t code_na101Codes[] = { 0xA0, 0x00, 0x09, 0x04, 0x92, 0x40, 0x20, 0x00, 0x00, 0x04, 0x92, 0x49, 0x2B, 0x3D, 0x00, }; const struct IrCode code_na101Code = { freq_to_timerval(38462), 38, // # of pairs 3, // # of bits per index code_na004Times, code_na101Codes }; const uint16_t code_na102Times[] = { 86, 87, 86, 258, 86, 3338, 346, 348, 348, 347, }; const uint8_t code_na102Codes[] = { 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 = { 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[] = { 58, 53, 58, 167, 58, 4494, 58, 9679, 455, 449, 456, 449, }; */ const uint8_t code_na103Codes[] = { 0x80, 0x02, 0x00, 0x00, 0x02, 0x00, 0x04, 0x92, 0x00, 0x00, 0x00, 0x49, 0x2A, 0x97, 0x48, }; const struct IrCode code_na103Code = { 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[] = { 56, 57, 56, 175, 56, 4150, 56, 9499, 898, 227, 898, 449, }; */ const uint8_t code_na104Codes[] = { 0xA4, 0x00, 0x49, 0x00, 0x92, 0x00, 0x20, 0x02, 0x00, 0x04, 0x90, 0x49, 0x2A, 0x38, 0x40, }; const struct IrCode code_na104Code = { 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[] = { 56, 57, 56, 175, 56, 4150, 56, 9499, 898, 227, 898, 449, }; */ const uint8_t code_na105Codes[] = { 0xA4, 0x80, 0x00, 0x20, 0x12, 0x49, 0x04, 0x92, 0x49, 0x20, 0x00, 0x00, 0x0A, 0x38, 0x40, }; const struct IrCode code_na105Code = { 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[] = { 51, 51, 51, 160, 51, 4096, 51, 9513, 431, 436, 883, 219, }; */ const uint8_t code_na106Codes[] = { 0x80, 0x02, 0x00, 0x04, 0x90, 0x49, 0x24, 0x92, 0x00, 0x00, 0x00, 0x49, 0x2A, 0xBA, 0x00, }; const struct IrCode code_na106Code = { 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[] = { 58, 53, 58, 167, 58, 4494, 58, 9679, 455, 449, 456, 449, }; */ const uint8_t code_na107Codes[] = { 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x92, 0x00, 0x00, 0x00, 0x49, 0x2A, 0x97, 0x48, }; const struct IrCode code_na107Code = { 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[] = { 58, 53, 58, 167, 58, 4494, 58, 9679, 455, 449, 456, 449, }; */ const uint8_t code_na108Codes[] = { 0x80, 0x90, 0x40, 0x00, 0x90, 0x40, 0x04, 0x92, 0x00, 0x00, 0x00, 0x49, 0x2A, 0x97, 0x48, }; const struct IrCode code_na108Code = { freq_to_timerval(38462), 40, // # of pairs 3, // # of bits per index code_na045Times, code_na108Codes }; const uint16_t code_na109Times[] = { 58, 61, 58, 211, 58, 9582, 73, 4164, 883, 211, 1050, 494, }; const uint8_t code_na109Codes[] = { 0xA0, 0x00, 0x08, 0x24, 0x92, 0x41, 0x00, 0x82, 0x00, 0x04, 0x10, 0x49, 0x2E, 0x28, 0x00, }; const struct IrCode code_na109Code = { 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[] = { 56, 57, 56, 175, 56, 4150, 56, 9499, 898, 227, 898, 449, }; */ const uint8_t code_na110Codes[] = { 0xA4, 0x80, 0x00, 0x20, 0x12, 0x49, 0x00, 0x02, 0x00, 0x04, 0x90, 0x49, 0x2A, 0x38, 0x40, }; const struct IrCode code_na110Code = { 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[] = { 51, 51, 51, 160, 51, 4096, 51, 9513, 431, 436, 883, 219, }; */ const uint8_t code_na111Codes[] = { 0x84, 0x92, 0x49, 0x20, 0x00, 0x00, 0x04, 0x92, 0x00, 0x00, 0x00, 0x49, 0x2A, 0xBA, 0x40, }; const struct IrCode code_na111Code = { 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[] = { 55, 57, 55, 170, 55, 3949, 55, 9623, 56, 0, 898, 453, 900, 226, }; */ const uint8_t code_na112Codes[] = { 0xA4, 0x00, 0x00, 0x00, 0x92, 0x49, 0x24, 0x00, 0x00, 0x00, 0x92, 0x49, 0x2B, 0x3D, 0x00, }; const struct IrCode code_na112Code = { freq_to_timerval(38462), 38, // # of pairs 3, // # of bits per index code_na004Times, code_na112Codes }; const uint16_t code_na113Times[] = { 56, 54, 56, 166, 56, 3945, 896, 442, 896, 443, }; const uint8_t code_na113Codes[] = { 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 = { freq_to_timerval(40000), 68, // # of pairs 3, // # of bits per index code_na113Times, code_na113Codes }; const uint16_t code_na114Times[] = { 44, 50, 44, 147, 44, 447, 44, 2236, 791, 398, 793, 397, }; const uint8_t code_na114Codes[] = { 0x84, 0x10, 0x40, 0x08, 0x82, 0x08, 0x01, 0xD2, 0x08, 0x20, 0x04, 0x41, 0x04, 0x00, 0x40, }; const struct IrCode code_na114Code = { freq_to_timerval(40000), 38, // # of pairs 3, // # of bits per index code_na114Times, code_na114Codes }; const uint16_t code_na115Times[] = { 81, 86, 81, 296, 81, 3349, 328, 331, 329, 331, }; const uint8_t code_na115Codes[] = { 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 = { 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[] = { 56, 57, 56, 175, 56, 4150, 56, 9499, 898, 227, 898, 449, }; */ const uint8_t code_na116Codes[] = { 0xA0, 0x00, 0x40, 0x04, 0x92, 0x09, 0x24, 0x00, 0x40, 0x00, 0x92, 0x09, 0x2A, 0x38, 0x00, }; const struct IrCode code_na116Code = { freq_to_timerval(40000), 38, // # of pairs 3, // # of bits per index code_na017Times, code_na116Codes }; const uint16_t code_na117Times[] = { 49, 54, 49, 158, 49, 420, 49, 2446, 819, 420, 821, 419, }; const uint8_t code_na117Codes[] = { 0x84, 0x00, 0x00, 0x08, 0x12, 0x40, 0x01, 0xD2, 0x00, 0x00, 0x04, 0x09, 0x20, 0x00, 0x40, }; const struct IrCode code_na117Code = { 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[] = { 51, 51, 51, 160, 51, 4096, 51, 9513, 431, 436, 883, 219, }; */ const uint8_t code_na118Codes[] = { 0x84, 0x90, 0x49, 0x20, 0x02, 0x00, 0x04, 0x92, 0x00, 0x00, 0x00, 0x49, 0x2A, 0xBA, 0x40, }; const struct IrCode code_na118Code = { freq_to_timerval(40000), 38, // # of pairs 3, // # of bits per index code_na044Times, code_na118Codes }; const uint16_t code_na119Times[] = { 55, 63, 55, 171, 55, 4094, 55, 9508, 881, 219, 881, 438, }; const uint8_t code_na119Codes[] = { 0xA0, 0x10, 0x00, 0x04, 0x82, 0x49, 0x20, 0x02, 0x00, 0x04, 0x90, 0x49, 0x2A, 0x38, 0x00, }; const struct IrCode code_na119Code = { 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[] = { 56, 57, 56, 175, 56, 4150, 56, 9499, 898, 227, 898, 449, }; */ const uint8_t code_na120Codes[] = { 0xA0, 0x12, 0x00, 0x04, 0x80, 0x49, 0x24, 0x92, 0x40, 0x00, 0x00, 0x09, 0x2A, 0x38, 0x00, }; const struct IrCode code_na120Code = { 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[] = { 56, 57, 56, 175, 56, 4150, 56, 9499, 898, 227, 898, 449, }; */ const uint8_t code_na121Codes[] = { 0xA0, 0x00, 0x40, 0x04, 0x92, 0x09, 0x20, 0x02, 0x00, 0x04, 0x90, 0x49, 0x2A, 0x38, 0x00, }; const struct IrCode code_na121Code = { freq_to_timerval(40000), 38, // # of pairs 3, // # of bits per index code_na017Times, code_na121Codes }; const uint16_t code_na122Times[] = { 80, 95, 80, 249, 80, 3867, 81, 0, 329, 322, }; const uint8_t code_na122Codes[] = { 0x80, 0x00, 0x00, 0x00, 0x12, 0x49, 0x24, 0x90, 0x0A, 0x80, 0x00, 0x00, 0x00, 0x12, 0x49, 0x24, 0x90, 0x0B, }; const struct IrCode code_na122Code = { 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[] = { 56, 57, 56, 175, 56, 4150, 56, 9499, 898, 227, 898, 449, }; */ const uint8_t code_na123Codes[] = { 0xA0, 0x02, 0x48, 0x04, 0x90, 0x01, 0x20, 0x12, 0x40, 0x04, 0x80, 0x09, 0x2A, 0x38, 0x00, }; const struct IrCode code_na123Code = { freq_to_timerval(40000), 38, // # of pairs 3, // # of bits per index code_na017Times, code_na123Codes }; const uint16_t code_na124Times[] = { 54, 56, 54, 151, 54, 4092, 54, 8677, 900, 421, 901, 226, }; const uint8_t code_na124Codes[] = { 0x80, 0x00, 0x48, 0x04, 0x92, 0x01, 0x20, 0x00, 0x00, 0x04, 0x92, 0x49, 0x2A, 0xBA, 0x00, }; const struct IrCode code_na124Code = { 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[] = { 55, 63, 55, 171, 55, 4094, 55, 9508, 881, 219, 881, 438, }; */ const uint8_t code_na125Codes[] = { 0xA0, 0x02, 0x48, 0x04, 0x90, 0x01, 0x20, 0x80, 0x40, 0x04, 0x12, 0x09, 0x2A, 0x38, 0x00, }; const struct IrCode code_na125Code = { 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[] = { 56, 57, 56, 175, 56, 4150, 56, 9499, 898, 227, 898, 449, }; */ const uint8_t code_na126Codes[] = { 0xA4, 0x10, 0x00, 0x20, 0x82, 0x49, 0x00, 0x02, 0x00, 0x04, 0x90, 0x49, 0x2A, 0x38, 0x40, }; const struct IrCode code_na126Code = { freq_to_timerval(40000), 38, // # of pairs 3, // # of bits per index code_na017Times, code_na126Codes }; const uint16_t code_na127Times[] = { 114, 100, 115, 100, 115, 200, 115, 2706, }; const uint8_t code_na127Codes[] = { 0x1B, 0x59, }; const struct IrCode code_na127Code = { 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[] = { 86, 87, 86, 258, 86, 3338, 346, 348, 348, 347, }; */ const uint8_t code_na128Codes[] = { 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 = { 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[] = { 56, 57, 56, 175, 56, 4150, 56, 9499, 898, 227, 898, 449, }; */ const uint8_t code_na129Codes[] = { 0xA4, 0x92, 0x49, 0x20, 0x00, 0x00, 0x00, 0x02, 0x00, 0x04, 0x90, 0x49, 0x2A, 0x38, 0x40, }; const struct IrCode code_na129Code = { freq_to_timerval(40000), 38, // # of pairs 3, // # of bits per index code_na017Times, code_na129Codes }; const uint16_t code_na130Times[] = { 88, 90, 88, 258, 88, 2247, 358, 349, 358, 350, }; const uint8_t code_na130Codes[] = { 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 = { 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[] = { 54, 65, 54, 170, 54, 4099, 54, 8668, 899, 226, 899, 421, }; */ const uint8_t code_na131Codes[] = { 0xA0, 0x10, 0x40, 0x04, 0x82, 0x09, 0x24, 0x82, 0x40, 0x00, 0x10, 0x09, 0x2A, 0x38, 0x00, }; const struct IrCode code_na131Code = { freq_to_timerval(40000), 38, // # of pairs 3, // # of bits per index code_na042Times, code_na131Codes }; const uint16_t code_na132Times[] = { 28, 106, 28, 238, 28, 370, 28, 1173, }; const uint8_t code_na132Codes[] = { 0x22, 0x20, 0x00, 0x17, 0x22, 0x20, 0x00, 0x14, }; const struct IrCode code_na132Code = { freq_to_timerval(83333), 32, // # of pairs 2, // # of bits per index code_na132Times, code_na132Codes }; const uint16_t code_na133Times[] = { 13, 741, 15, 489, 15, 740, 17, 4641, 18, 0, }; const uint8_t code_na133Codes[] = { 0x09, 0x24, 0x49, 0x48, 0xB4, 0x92, 0x44, 0x94, 0x8C, }; const struct IrCode code_na133Code = { 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[] = { 56, 54, 56, 166, 56, 3945, 896, 442, 896, 443, }; */ const uint8_t code_na134Codes[] = { 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 = { freq_to_timerval(40000), 68, // # of pairs 3, // # of bits per index code_na113Times, code_na134Codes }; const uint16_t code_na135Times[] = { 53, 59, 53, 171, 53, 2301, 892, 450, 895, 448, }; const uint8_t code_na135Codes[] = { 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 = { freq_to_timerval(38462), 88, // # of pairs 3, // # of bits per index code_na135Times, code_na135Codes }; const uint16_t code_na136Times[] = { 53, 59, 53, 171, 53, 2301, 55, 0, 892, 450, 895, 448, }; const uint8_t code_na136Codes[] = { 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 = { freq_to_timerval(38610), 88, // # of pairs 3, // # of bits per index code_na136Times, code_na136Codes }; const uint16_t code_eu000Times[] = { 43, 47, 43, 91, 43, 8324, 88, 47, 133, 133, 264, 90, 264, 91, }; const uint8_t code_eu000Codes[] = { 0xA4, 0x08, 0x00, 0x00, 0x00, 0x00, 0x64, 0x2C, 0x40, 0x80, 0x00, 0x00, 0x00, 0x06, 0x41, }; const struct IrCode code_eu000Code = { freq_to_timerval(35714), 40, // # of pairs 3, // # of bits per index code_eu000Times, code_eu000Codes }; const uint16_t code_eu001Times[] = { 47, 265, 51, 54, 51, 108, 51, 263, 51, 2053, 51, 11647, 100, 109, }; const uint8_t code_eu001Codes[] = { 0x04, 0x92, 0x49, 0x26, 0x35, 0x89, 0x24, 0x9A, 0xD6, 0x24, 0x92, 0x48, }; const struct IrCode code_eu001Code = { freq_to_timerval(30303), 31, // # of pairs 3, // # of bits per index code_eu001Times, code_eu001Codes }; const uint16_t code_eu002Times[] = { 43, 206, 46, 204, 46, 456, 46, 3488, }; const uint8_t code_eu002Codes[] = { 0x1A, 0x56, 0xA6, 0xD6, 0x95, 0xA9, 0x90, }; const struct IrCode code_eu002Code = { 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[] = { 58, 60, 58, 2687, 118, 60, 237, 60, 238, 60, }; */ /* const uint8_t code_eu003Codes[] = { 0x68, 0x20, 0x80, 0x40, 0x03, 0x10, 0x41, 0x00, 0x80, 0x00, }; const struct IrCode code_eu003Code = { 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[] = { 44, 45, 44, 131, 44, 7462, 346, 176, 346, 178, }; const uint8_t code_eu004Codes[] = { 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 = { 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[] = { 24, 190, 25, 80, 25, 190, 25, 4199, 25, 4799, }; const uint8_t code_eu005Codes[] = { 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 = { freq_to_timerval(38610), 64, // # of pairs 3, // # of bits per index code_eu005Times, code_eu005Codes }; // This is actually power TOGGLE for Samsung TVs. Therefore followed later by new eu141, discrete OFF const uint16_t code_eu006Times[] = { 53, 63, 53, 172, 53, 4472, 54, 0, 455, 468, }; const uint8_t code_eu006Codes[] = { 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 = { freq_to_timerval(38462), 68, // # of pairs 3, // # of bits per index code_eu006Times, code_eu006Codes }; const uint16_t code_eu007Times[] = { 50, 54, 50, 159, 50, 2307, 838, 422, }; const uint8_t code_eu007Codes[] = { 0xD4, 0x00, 0x15, 0x10, 0x25, 0x00, 0x05, 0x44, 0x09, 0x40, 0x01, 0x51, 0x01, }; const struct IrCode code_eu007Code = { 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[] = { 55, 57, 55, 170, 55, 3949, 55, 9623, 56, 0, 898, 453, 900, 226, }; */ const uint8_t code_eu008Codes[] = { 0xA0, 0x00, 0x41, 0x04, 0x92, 0x08, 0x24, 0x90, 0x40, 0x00, 0x02, 0x09, 0x2B, 0x3D, 0x00, }; const struct IrCode code_eu008Code = { 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[] = { 88, 90, 88, 91, 88, 181, 88, 8976, 177, 91, }; */ /* const uint8_t code_eu009Codes[] = { 0x10, 0x92, 0x49, 0x46, 0x33, 0x09, 0x24, 0x94, 0x60, }; const struct IrCode code_eu009Code = { 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[] = { 55, 57, 55, 170, 55, 3949, 55, 9623, 56, 0, 898, 453, 900, 226, }; */ /* const uint8_t code_eu010Codes[] = { 0xA0, 0x00, 0x01, 0x04, 0x92, 0x48, 0x20, 0x80, 0x40, 0x04, 0x12, 0x09, 0x2B, 0x3D, 0x00, }; const struct IrCode code_eu010Code = { 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[] = { 53, 56, 53, 171, 53, 3950, 53, 9599, 898, 451, 900, 226, }; */ const uint8_t code_eu011Codes[] = { 0x84, 0x00, 0x48, 0x04, 0x02, 0x01, 0x04, 0x80, 0x09, 0x00, 0x12, 0x40, 0x2A, 0xBA, 0x40, }; const struct IrCode code_eu011Code = { freq_to_timerval(38462), 38, // # of pairs 3, // # of bits per index code_na009Times, code_eu011Codes }; const uint16_t code_eu012Times[] = { 46, 206, 46, 459, 46, 3447, }; const uint8_t code_eu012Codes[] = { 0x05, 0x01, 0x51, 0x81, 0x40, 0x54, 0x40, }; const struct IrCode code_eu012Code = { freq_to_timerval(33445), 26, // # of pairs 2, // # of bits per index code_eu012Times, code_eu012Codes }; const uint16_t code_eu013Times[] = { 53, 59, 53, 171, 53, 2302, 895, 449, }; const uint8_t code_eu013Codes[] = { 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 = { 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[] = { 48, 52, 48, 160, 48, 400, 48, 2335, 799, 400, }; */ /* const uint8_t code_eu014Codes[] = { 0x80, 0x10, 0x40, 0x08, 0x82, 0x08, 0x01, 0xC0, 0x08, 0x20, 0x04, 0x41, 0x04, 0x00, 0x00, }; const struct IrCode code_eu014Code = { 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[] = { 53, 54, 53, 156, 53, 2542, 851, 425, 853, 424, }; const uint8_t code_eu015Codes[] = { 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 = { 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[] = { 28, 92, 28, 213, 28, 214, 28, 2771, }; const uint8_t code_eu016Codes[] = { 0x68, 0x08, 0x20, 0x00, 0xEA, 0x02, 0x08, 0x00, 0x10, }; const struct IrCode code_eu016Code = { freq_to_timerval(33333), 34, // # of pairs 2, // # of bits per index code_eu016Times, code_eu016Codes }; const uint16_t code_eu017Times[] = { 15, 844, 16, 557, 16, 844, 16, 5224, }; const uint8_t code_eu017Codes[] = { 0x1A, 0x9A, 0x9B, 0x9A, 0x9A, 0x99, }; const struct IrCode code_eu017Code = { 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[] = { 55, 57, 55, 170, 55, 3949, 55, 9623, 56, 0, 898, 453, 900, 226, }; */ const uint8_t code_eu018Codes[] = { 0xA0, 0x02, 0x48, 0x04, 0x90, 0x01, 0x20, 0x12, 0x40, 0x04, 0x80, 0x09, 0x2B, 0x3D, 0x00, }; const struct IrCode code_eu018Code = { freq_to_timerval(38462), 38, // # of pairs 3, // # of bits per index code_na004Times, code_eu018Codes }; const uint16_t code_eu019Times[] = { 50, 54, 50, 158, 50, 418, 50, 2443, 843, 418, }; const uint8_t code_eu019Codes[] = { 0x80, 0x80, 0x00, 0x08, 0x12, 0x40, 0x01, 0xC0, 0x40, 0x00, 0x04, 0x09, 0x20, 0x00, 0x00, }; const struct IrCode code_eu019Code = { freq_to_timerval(38462), 38, // # of pairs 3, // # of bits per index code_eu019Times, code_eu019Codes }; const uint16_t code_eu020Times[] = { 48, 301, 48, 651, 48, 1001, 48, 3001, }; const uint8_t code_eu020Codes[] = { 0x22, 0x20, 0x00, 0x01, 0xC8, 0x88, 0x00, 0x00, 0x40, }; const struct IrCode code_eu020Code = { 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[] = { 53, 56, 53, 171, 53, 3950, 53, 9599, 898, 451, 900, 226, }; */ const uint8_t code_eu021Codes[] = { 0x84, 0x80, 0x00, 0x20, 0x82, 0x49, 0x00, 0x02, 0x00, 0x04, 0x90, 0x49, 0x2A, 0xBA, 0x40, }; const struct IrCode code_eu021Code = { 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[] = { 55, 57, 55, 170, 55, 3949, 55, 9623, 56, 0, 898, 453, 900, 226, }; */ const uint8_t code_eu022Codes[] = { 0xA4, 0x80, 0x41, 0x00, 0x12, 0x08, 0x24, 0x90, 0x40, 0x00, 0x02, 0x09, 0x2B, 0x3D, 0x00, }; const struct IrCode code_eu022Code = { 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[] = { 53, 60, 53, 175, 53, 4463, 53, 9453, 892, 450, 895, 225, }; */ /* const uint8_t code_eu023Codes[] = { 0x80, 0x02, 0x40, 0x00, 0x02, 0x40, 0x00, 0x00, 0x01, 0x24, 0x92, 0x48, 0x0A, 0xBA, 0x00, }; const struct IrCode code_eu023Code = { 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[] = { 55, 57, 55, 170, 55, 3949, 55, 9623, 56, 0, 898, 453, 900, 226, }; */ const uint8_t code_eu024Codes[] = { 0xA0, 0x02, 0x48, 0x04, 0x90, 0x01, 0x20, 0x00, 0x40, 0x04, 0x92, 0x09, 0x2B, 0x3D, 0x00, }; const struct IrCode code_eu024Code = { freq_to_timerval(38462), 38, // # of pairs 3, // # of bits per index code_na004Times, code_eu024Codes }; const uint16_t code_eu025Times[] = { 49, 52, 49, 102, 49, 250, 49, 252, 49, 2377, 49, 12009, 100, 52, 100, 102, }; const uint8_t code_eu025Codes[] = { 0x47, 0x00, 0x23, 0x3C, 0x01, 0x59, 0xE0, 0x04, }; const struct IrCode code_eu025Code = { freq_to_timerval(31250), 21, // # of pairs 3, // # of bits per index code_eu025Times, code_eu025Codes }; const uint16_t code_eu026Times[] = { 14, 491, 14, 743, 14, 4926, }; const uint8_t code_eu026Codes[] = { 0x55, 0x40, 0x42, 0x55, 0x40, 0x41, }; const struct IrCode code_eu026Code = { 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[] = { 55, 57, 55, 170, 55, 3949, 55, 9623, 56, 0, 898, 453, 900, 226, }; */ const uint8_t code_eu027Codes[] = { 0xA0, 0x82, 0x08, 0x24, 0x10, 0x41, 0x04, 0x10, 0x01, 0x20, 0x82, 0x48, 0x0B, 0x3D, 0x00, }; const struct IrCode code_eu027Code = { freq_to_timerval(38462), 38, // # of pairs 3, // # of bits per index code_na004Times, code_eu027Codes }; const uint16_t code_eu028Times[] = { 47, 267, 50, 55, 50, 110, 50, 265, 50, 2055, 50, 12117, 100, 57, }; const uint8_t code_eu028Codes[] = { 0x04, 0x92, 0x49, 0x26, 0x34, 0x72, 0x24, 0x9A, 0xD1, 0xC8, 0x92, 0x48, }; const struct IrCode code_eu028Code = { freq_to_timerval(30303), 31, // # of pairs 3, // # of bits per index code_eu028Times, code_eu028Codes }; const uint16_t code_eu029Times[] = { 50, 50, 50, 99, 50, 251, 50, 252, 50, 1445, 50, 11014, 102, 49, 102, 98, }; const uint8_t code_eu029Codes[] = { 0x47, 0x00, 0x00, 0x00, 0x00, 0x04, 0x64, 0x62, 0x00, 0xE0, 0x00, 0x2B, 0x23, 0x10, 0x07, 0x00, 0x00, 0x80, }; const struct IrCode code_eu029Code = { 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[] = { 55, 57, 55, 170, 55, 3949, 55, 9623, 56, 0, 898, 453, 900, 226, }; */ const uint8_t code_eu030Codes[] = { 0xA0, 0x10, 0x00, 0x04, 0x82, 0x49, 0x20, 0x02, 0x00, 0x04, 0x90, 0x49, 0x2B, 0x3D, 0x00, }; const struct IrCode code_eu030Code = { 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[] = { 53, 53, 53, 160, 53, 1697, 838, 422, }; const uint8_t code_eu031Codes[] = { 0xD5, 0x50, 0x15, 0x11, 0x65, 0x54, 0x05, 0x44, 0x59, 0x55, 0x01, 0x51, 0x15, }; const struct IrCode code_eu031Code = { freq_to_timerval(38462), 52, // # of pairs 2, // # of bits per index code_eu031Times, code_eu031Codes }; const uint16_t code_eu032Times[] = { 49, 205, 49, 206, 49, 456, 49, 3690, }; const uint8_t code_eu032Codes[] = { 0x1A, 0x56, 0xA5, 0xD6, 0x95, 0xA9, 0x40, }; const struct IrCode code_eu032Code = { freq_to_timerval(33333), 26, // # of pairs 2, // # of bits per index code_eu032Times, code_eu032Codes }; const uint16_t code_eu033Times[] = { 48, 150, 50, 149, 50, 347, 50, 2936, }; const uint8_t code_eu033Codes[] = { 0x2A, 0x5D, 0xA9, 0x60, }; const struct IrCode code_eu033Code = { 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[] = { 55, 57, 55, 170, 55, 3949, 55, 9623, 56, 0, 898, 453, 900, 226, }; */ const uint8_t code_eu034Codes[] = { 0xA0, 0x02, 0x40, 0x04, 0x90, 0x09, 0x20, 0x02, 0x00, 0x04, 0x90, 0x49, 0x2B, 0x3D, 0x00, }; const struct IrCode code_eu034Code = { 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[] = { 88, 90, 88, 91, 88, 181, 88, 8976, 177, 91, }; */ /* const uint8_t code_eu035Codes[] = { 0x10, 0x92, 0x49, 0x46, 0x33, 0x09, 0x24, 0x94, 0x60, }; const struct IrCode code_eu035Code = { 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[] = { 55, 57, 55, 170, 55, 3949, 55, 9623, 56, 0, 898, 453, 900, 226, }; */ const uint8_t code_eu036Codes[] = { 0xA4, 0x00, 0x49, 0x00, 0x92, 0x00, 0x20, 0x02, 0x00, 0x04, 0x90, 0x49, 0x2B, 0x3D, 0x00, }; const struct IrCode code_eu036Code = { freq_to_timerval(38462), 38, // # of pairs 3, // # of bits per index code_na004Times, code_eu036Codes }; const uint16_t code_eu037Times[] = { 14, 491, 14, 743, 14, 5178, }; const uint8_t code_eu037Codes[] = { 0x45, 0x50, 0x02, 0x45, 0x50, 0x01, }; const struct IrCode code_eu037Code = { freq_to_timerval(38462), 24, // # of pairs 2, // # of bits per index code_eu037Times, code_eu037Codes }; const uint16_t code_eu038Times[] = { 3, 1002, 3, 1495, 3, 3059, }; const uint8_t code_eu038Codes[] = { 0x05, 0x60, 0x54, }; const struct IrCode code_eu038Code = { 0, // Non-pulsed code 11, // # of pairs 2, // # of bits per index code_eu038Times, code_eu038Codes }; const uint16_t code_eu039Times[] = { 13, 445, 13, 674, 13, 675, 13, 4583, }; const uint8_t code_eu039Codes[] = { 0x6A, 0x82, 0x83, 0xAA, 0x82, 0x81, }; const struct IrCode code_eu039Code = { freq_to_timerval(40161), 24, // # of pairs 2, // # of bits per index code_eu039Times, code_eu039Codes }; const uint16_t code_eu040Times[] = { 85, 89, 85, 264, 85, 3402, 347, 350, 348, 350, }; const uint8_t code_eu040Codes[] = { 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 = { freq_to_timerval(35714), 52, // # of pairs 3, // # of bits per index code_eu040Times, code_eu040Codes }; const uint16_t code_eu041Times[] = { 46, 300, 49, 298, 49, 648, 49, 997, 49, 3056, }; const uint8_t code_eu041Codes[] = { 0x0C, 0xB2, 0xCA, 0x49, 0x13, 0x0B, 0x2C, 0xB2, 0x92, 0x44, 0xB0, }; const struct IrCode code_eu041Code = { 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[] = { 53, 56, 53, 171, 53, 3950, 53, 9599, 898, 451, 900, 226, }; */ const uint8_t code_eu042Codes[] = { 0x80, 0x00, 0x00, 0x24, 0x92, 0x09, 0x00, 0x82, 0x00, 0x04, 0x10, 0x49, 0x2A, 0xBA, 0x00, }; const struct IrCode code_eu042Code = { freq_to_timerval(38462), 38, // # of pairs 3, // # of bits per index code_na009Times, code_eu042Codes }; const uint16_t code_eu043Times[] = { 1037, 4216, 1040, 0, }; const uint8_t code_eu043Codes[] = { 0x10, }; const struct IrCode code_eu043Code = { 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[] = { 55, 57, 55, 170, 55, 3949, 55, 9623, 56, 0, 898, 453, 900, 226, }; */ const uint8_t code_eu044Codes[] = { 0xA0, 0x02, 0x01, 0x04, 0x90, 0x48, 0x20, 0x00, 0x00, 0x04, 0x92, 0x49, 0x2B, 0x3D, 0x00, }; const struct IrCode code_eu044Code = { freq_to_timerval(38462), 38, // # of pairs 3, // # of bits per index code_na004Times, code_eu044Codes }; const uint16_t code_eu045Times[] = { 152, 471, 154, 156, 154, 469, 154, 2947, }; const uint8_t code_eu045Codes[] = { 0x16, 0xE5, 0x90, }; const struct IrCode code_eu045Code = { freq_to_timerval(41667), 10, // # of pairs 2, // # of bits per index code_eu045Times, code_eu045Codes }; const uint16_t code_eu046Times[] = { 15, 493, 16, 493, 16, 698, 16, 1414, }; const uint8_t code_eu046Codes[] = { 0x16, 0xAB, 0x56, 0xA9, }; const struct IrCode code_eu046Code = { freq_to_timerval(34602), 16, // # of pairs 2, // # of bits per index code_eu046Times, code_eu046Codes }; const uint16_t code_eu047Times[] = { 3, 496, 3, 745, 3, 1488, }; const uint8_t code_eu047Codes[] = { 0x41, 0x24, 0x12, 0x41, 0x00, }; const struct IrCode code_eu047Code = { 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[] = { 53, 56, 53, 171, 53, 3950, 53, 9599, 898, 451, 900, 226, }; */ const uint8_t code_eu048Codes[] = { 0x80, 0x00, 0x00, 0x24, 0x82, 0x49, 0x04, 0x80, 0x40, 0x00, 0x12, 0x09, 0x2A, 0xBA, 0x00, }; const struct IrCode code_eu048Code = { freq_to_timerval(38462), 38, // # of pairs 3, // # of bits per index code_na009Times, code_eu048Codes }; const uint16_t code_eu049Times[] = { 55, 55, 55, 167, 55, 4577, 55, 9506, 448, 445, 450, 444, }; const uint8_t code_eu049Codes[] = { 0x80, 0x92, 0x00, 0x00, 0x92, 0x00, 0x00, 0x10, 0x40, 0x04, 0x82, 0x09, 0x2A, 0x97, 0x48, }; const struct IrCode code_eu049Code = { freq_to_timerval(38462), 40, // # of pairs 3, // # of bits per index code_eu049Times, code_eu049Codes }; const uint16_t code_eu050Times[] = { 91, 88, 91, 267, 91, 3621, 361, 358, 361, 359, }; const uint8_t code_eu050Codes[] = { 0x60, 0x00, 0x00, 0x00, 0x12, 0x49, 0x24, 0x92, 0x42, 0x80, 0x00, 0x00, 0x00, 0x12, 0x49, 0x24, 0x92, 0x40, }; const struct IrCode code_eu050Code = { freq_to_timerval(33333), 48, // # of pairs 3, // # of bits per index code_eu050Times, code_eu050Codes }; const uint16_t code_eu051Times[] = { 84, 88, 84, 261, 84, 3360, 347, 347, 347, 348, }; const uint8_t code_eu051Codes[] = { 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 = { 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[] = { 16, 838, 17, 558, 17, 839, 17, 6328, }; const uint8_t code_eu052Codes[] = { 0x1A, 0x9A, 0x9B, 0x9A, 0x9A, 0x99, }; const struct IrCode code_eu052Code = { 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[] = { 15, 493, 16, 493, 16, 698, 16, 1414, }; */ const uint8_t code_eu053Codes[] = { 0x26, 0xAB, 0x66, 0xAA, }; const struct IrCode code_eu053Code = { freq_to_timerval(34483), 16, // # of pairs 2, // # of bits per index code_eu046Times, code_eu053Codes }; const uint16_t code_eu054Times[] = { 49, 53, 49, 104, 49, 262, 49, 264, 49, 8030, 100, 103, }; const uint8_t code_eu054Codes[] = { 0x40, 0x1A, 0x23, 0x00, 0xD0, 0x80, }; const struct IrCode code_eu054Code = { 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[] = { 53, 56, 53, 171, 53, 3950, 53, 9599, 898, 451, 900, 226, }; */ const uint8_t code_eu055Codes[] = { 0x80, 0x00, 0x00, 0x20, 0x92, 0x49, 0x00, 0x02, 0x40, 0x04, 0x90, 0x09, 0x2A, 0xBA, 0x00, }; const struct IrCode code_eu055Code = { freq_to_timerval(38462), 38, // # of pairs 3, // # of bits per index code_na009Times, code_eu055Codes }; const uint16_t code_eu056Times[] = { 112, 107, 113, 107, 677, 2766, }; const uint8_t code_eu056Codes[] = { 0x26, }; const struct IrCode code_eu056Code = { 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[] = { 55, 57, 55, 170, 55, 3949, 55, 9623, 56, 0, 898, 453, 900, 226, }; */ /* const uint8_t code_eu057Codes[] = { 0xA0, 0x00, 0x41, 0x04, 0x92, 0x08, 0x20, 0x02, 0x00, 0x04, 0x90, 0x49, 0x2B, 0x3D, 0x00, }; const struct IrCode code_eu057Code = { 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[] = { 53, 56, 53, 171, 53, 3950, 53, 9599, 898, 451, 900, 226, }; */ const uint8_t code_eu058Codes[] = { 0x80, 0x00, 0x00, 0x24, 0x10, 0x49, 0x00, 0x82, 0x00, 0x04, 0x10, 0x49, 0x2A, 0xBA, 0x00, }; const struct IrCode code_eu058Code = { freq_to_timerval(38462), 38, // # of pairs 3, // # of bits per index code_na009Times, code_eu058Codes }; const uint16_t code_eu059Times[] = { 310, 613, 310, 614, 622, 8312, }; const uint8_t code_eu059Codes[] = { 0x26, }; const struct IrCode code_eu059Code = { 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[] = { 50, 158, 53, 51, 53, 156, 53, 2180, }; const uint8_t code_eu060Codes[] = { 0x25, 0x59, 0x9A, 0x5A, 0xE9, 0x56, 0x66, 0x96, 0xA0, }; const struct IrCode code_eu060Code = { 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[] = { 88, 90, 88, 91, 88, 181, 88, 8976, 177, 91, }; */ const uint8_t code_eu061Codes[] = { 0x10, 0x92, 0x54, 0x24, 0xB3, 0x09, 0x25, 0x42, 0x48, }; const struct IrCode code_eu061Code = { 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[] = { 50, 158, 53, 51, 53, 156, 53, 2180, }; */ const uint8_t code_eu062Codes[] = { 0x25, 0x99, 0x9A, 0x5A, 0xE9, 0x66, 0x66, 0x96, 0xA0, }; const struct IrCode code_eu062Code = { 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[] = { 53, 56, 53, 171, 53, 3950, 53, 9599, 898, 451, 900, 226, }; */ const uint8_t code_eu063Codes[] = { 0x80, 0x00, 0x00, 0x24, 0x90, 0x41, 0x00, 0x82, 0x00, 0x04, 0x10, 0x49, 0x2A, 0xBA, 0x00, }; const struct IrCode code_eu063Code = { freq_to_timerval(38462), 38, // # of pairs 3, // # of bits per index code_na009Times, code_eu063Codes }; const uint16_t code_eu064Times[] = { 47, 267, 50, 55, 50, 110, 50, 265, 50, 2055, 50, 12117, 100, 57, 100, 112, }; const uint8_t code_eu064Codes[] = { 0x04, 0x92, 0x49, 0x26, 0x32, 0x51, 0xCB, 0xD6, 0x4A, 0x39, 0x72, }; const struct IrCode code_eu064Code = { freq_to_timerval(30395), 29, // # of pairs 3, // # of bits per index code_eu064Times, code_eu064Codes }; const uint16_t code_eu065Times[] = { 47, 267, 50, 55, 50, 110, 50, 265, 50, 2055, 50, 12117, 100, 112, }; const uint8_t code_eu065Codes[] = { 0x04, 0x92, 0x49, 0x26, 0x32, 0x4A, 0x38, 0x9A, 0xC9, 0x28, 0xE2, 0x48, }; const struct IrCode code_eu065Code = { 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[] = { 55, 55, 55, 167, 55, 4577, 55, 9506, 448, 445, 450, 444, }; */ const uint8_t code_eu066Codes[] = { 0x84, 0x82, 0x00, 0x04, 0x82, 0x00, 0x00, 0x82, 0x00, 0x04, 0x10, 0x49, 0x2A, 0x87, 0x41, }; const struct IrCode code_eu066Code = { freq_to_timerval(38462), 40, // # of pairs 3, // # of bits per index code_eu049Times, code_eu066Codes }; const uint16_t code_eu067Times[] = { 94, 473, 94, 728, 102, 1637, }; const uint8_t code_eu067Codes[] = { 0x41, 0x24, 0x12, }; const struct IrCode code_eu067Code = { freq_to_timerval(38462), 12, // # of pairs 2, // # of bits per index code_eu067Times, code_eu067Codes }; const uint16_t code_eu068Times[] = { 49, 263, 50, 54, 50, 108, 50, 263, 50, 2029, 50, 10199, 100, 110, }; const uint8_t code_eu068Codes[] = { 0x04, 0x92, 0x49, 0x26, 0x34, 0x49, 0x38, 0x9A, 0xD1, 0x24, 0xE2, 0x48, }; const struct IrCode code_eu068Code = { freq_to_timerval(38610), 31, // # of pairs 3, // # of bits per index code_eu068Times, code_eu068Codes }; const uint16_t code_eu069Times[] = { 4, 499, 4, 750, 4, 4999, }; const uint8_t code_eu069Codes[] = { 0x05, 0x54, 0x06, 0x05, 0x54, 0x04, }; const struct IrCode code_eu069Code = { 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[] = { 4, 499, 4, 750, 4, 4999, }; */ const uint8_t code_eu070Codes[] = { 0x14, 0x54, 0x06, 0x14, 0x54, 0x04, }; const struct IrCode code_eu070Code = { 0, // Non-pulsed code 23, // # of pairs 2, // # of bits per index code_eu069Times, code_eu070Codes }; const uint16_t code_eu071Times[] = { 14, 491, 14, 743, 14, 4422, }; const uint8_t code_eu071Codes[] = { 0x45, 0x44, 0x56, 0x45, 0x44, 0x55, }; const struct IrCode code_eu071Code = { freq_to_timerval(38462), 24, // # of pairs 2, // # of bits per index code_eu071Times, code_eu071Codes }; const uint16_t code_eu072Times[] = { 5, 568, 5, 854, 5, 4999, }; const uint8_t code_eu072Codes[] = { 0x55, 0x45, 0x46, 0x55, 0x45, 0x44, }; const struct IrCode code_eu072Code = { 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[] = { 15, 493, 16, 493, 16, 698, 16, 1414, }; */ const uint8_t code_eu073Codes[] = { 0x19, 0x57, 0x59, 0x55, }; const struct IrCode code_eu073Code = { 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[] = { 88, 89, 88, 90, 88, 179, 88, 8977, 177, 90, }; */ const uint8_t code_eu074Codes[] = { 0x04, 0x92, 0x49, 0x28, 0xC6, 0x49, 0x24, 0x92, 0x51, 0x80, }; const struct IrCode code_eu074Code = { freq_to_timerval(35714), 26, // # of pairs 3, // # of bits per index code_na031Times, code_eu074Codes }; const uint16_t code_eu075Times[] = { 6, 566, 6, 851, 6, 5474, }; const uint8_t code_eu075Codes[] = { 0x05, 0x45, 0x46, 0x05, 0x45, 0x44, }; const struct IrCode code_eu075Code = { 0, // Non-pulsed code 23, // # of pairs 2, // # of bits per index code_eu075Times, code_eu075Codes }; const uint16_t code_eu076Times[] = { 14, 843, 16, 555, 16, 841, 16, 4911, }; const uint8_t code_eu076Codes[] = { 0x2A, 0x9A, 0x9B, 0xAA, 0x9A, 0x9A, }; const struct IrCode code_eu076Code = { 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[] = { 47, 267, 50, 55, 50, 110, 50, 265, 50, 2055, 50, 12117, 100, 57, }; */ const uint8_t code_eu077Codes[] = { 0x04, 0x92, 0x49, 0x26, 0x32, 0x51, 0xC8, 0x9A, 0xC9, 0x47, 0x22, 0x48, }; const struct IrCode code_eu077Code = { freq_to_timerval(30303), 31, // # of pairs 3, // # of bits per index code_eu028Times, code_eu077Codes }; const uint16_t code_eu078Times[] = { 6, 925, 6, 1339, 6, 2098, 6, 2787, }; const uint8_t code_eu078Codes[] = { 0x90, 0x0D, 0x00, }; const struct IrCode code_eu078Code = { 0, // Non-pulsed code 12, // # of pairs 2, // # of bits per index code_eu078Times, code_eu078Codes }; const uint16_t code_eu079Times[] = { 53, 59, 53, 170, 53, 4359, 892, 448, 893, 448, }; const uint8_t code_eu079Codes[] = { 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 = { freq_to_timerval(38462), 68, // # of pairs 3, // # of bits per index code_eu079Times, code_eu079Codes }; const uint16_t code_eu080Times[] = { 55, 57, 55, 167, 55, 4416, 895, 448, 897, 447, }; const uint8_t code_eu080Codes[] = { 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 = { freq_to_timerval(38462), 68, // # of pairs 3, // # of bits per index code_eu080Times, code_eu080Codes }; const uint16_t code_eu081Times[] = { 26, 185, 27, 80, 27, 185, 27, 4249, }; const uint8_t code_eu081Codes[] = { 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 = { freq_to_timerval(38462), 80, // # of pairs 2, // # of bits per index code_eu081Times, code_eu081Codes }; const uint16_t code_eu082Times[] = { 51, 56, 51, 162, 51, 2842, 848, 430, 850, 429, }; const uint8_t code_eu082Codes[] = { 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 = { freq_to_timerval(40000), 68, // # of pairs 3, // # of bits per index code_eu082Times, code_eu082Codes }; const uint16_t code_eu083Times[] = { 16, 559, 16, 847, 16, 5900, 17, 559, 17, 847, }; const uint8_t code_eu083Codes[] = { 0x0E, 0x38, 0x21, 0x82, 0x26, 0x20, 0x82, 0x48, 0x23, }; const struct IrCode code_eu083Code = { freq_to_timerval(33333), 24, // # of pairs 3, // # of bits per index code_eu083Times, code_eu083Codes }; const uint16_t code_eu084Times[] = { 16, 484, 16, 738, 16, 739, 16, 4795, }; const uint8_t code_eu084Codes[] = { 0x6A, 0xA0, 0x03, 0xAA, 0xA0, 0x01, }; const struct IrCode code_eu084Code = { freq_to_timerval(38462), 24, // # of pairs 2, // # of bits per index code_eu084Times, code_eu084Codes }; const uint16_t code_eu085Times[] = { 48, 52, 48, 160, 48, 400, 48, 2120, 799, 400, }; const uint8_t code_eu085Codes[] = { 0x84, 0x82, 0x40, 0x08, 0x92, 0x48, 0x01, 0xC2, 0x41, 0x20, 0x04, 0x49, 0x24, 0x00, 0x40, }; const struct IrCode code_eu085Code = { freq_to_timerval(38462), 38, // # of pairs 3, // # of bits per index code_eu085Times, code_eu085Codes }; const uint16_t code_eu086Times[] = { 16, 851, 17, 554, 17, 850, 17, 851, 17, 4847, }; const uint8_t code_eu086Codes[] = { 0x45, 0x86, 0x5B, 0x05, 0xC6, 0x5B, 0x05, 0xB0, 0x42, }; const struct IrCode code_eu086Code = { freq_to_timerval(33333), 24, // # of pairs 3, // # of bits per index code_eu086Times, code_eu086Codes }; const uint16_t code_eu087Times[] = { 14, 491, 14, 743, 14, 5126, }; const uint8_t code_eu087Codes[] = { 0x55, 0x50, 0x02, 0x55, 0x50, 0x01, }; const struct IrCode code_eu087Code = { freq_to_timerval(38462), 24, // # of pairs 2, // # of bits per index code_eu087Times, code_eu087Codes }; const uint16_t code_eu088Times[] = { 14, 491, 14, 743, 14, 4874, }; const uint8_t code_eu088Codes[] = { 0x45, 0x54, 0x42, 0x45, 0x54, 0x41, }; const struct IrCode code_eu088Code = { 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[] = { 48, 52, 48, 160, 48, 400, 48, 2335, 799, 400, }; */ const uint8_t code_eu089Codes[] = { 0x84, 0x10, 0x40, 0x08, 0x82, 0x08, 0x01, 0xC2, 0x08, 0x20, 0x04, 0x41, 0x04, 0x00, 0x40, }; const struct IrCode code_eu089Code = { freq_to_timerval(38462), 38, // # of pairs 3, // # of bits per index code_na021Times, code_eu089Codes }; const uint16_t code_eu090Times[] = { 3, 9, 3, 19, 3, 29, 3, 39, 3, 9968, }; const uint8_t code_eu090Codes[] = { 0x60, 0x00, 0x88, 0x00, 0x02, 0xE3, 0x00, 0x04, 0x40, 0x00, 0x16, }; const struct IrCode code_eu090Code = { 0, // Non-pulsed code 29, // # of pairs 3, // # of bits per index code_eu090Times, code_eu090Codes }; const uint16_t code_eu091Times[] = { 15, 138, 15, 446, 15, 605, 15, 6565, }; const uint8_t code_eu091Codes[] = { 0x80, 0x01, 0x00, 0x2E, 0x00, 0x04, 0x00, 0xA0, }; const struct IrCode code_eu091Code = { freq_to_timerval(38462), 30, // # of pairs 2, // # of bits per index code_eu091Times, code_eu091Codes }; const uint16_t code_eu092Times[] = { 48, 50, 48, 148, 48, 149, 48, 1424, }; const uint8_t code_eu092Codes[] = { 0x48, 0x80, 0x0E, 0x22, 0x00, 0x10, }; const struct IrCode code_eu092Code = { freq_to_timerval(40000), 22, // # of pairs 2, // # of bits per index code_eu092Times, code_eu092Codes }; const uint16_t code_eu093Times[] = { 87, 639, 88, 275, 88, 639, }; const uint8_t code_eu093Codes[] = { 0x15, 0x9A, 0x94, }; const struct IrCode code_eu093Code = { freq_to_timerval(35714), 11, // # of pairs 2, // # of bits per index code_eu093Times, code_eu093Codes }; const uint16_t code_eu094Times[] = { 3, 8, 3, 18, 3, 24, 3, 38, 3, 9969, }; const uint8_t code_eu094Codes[] = { 0x60, 0x80, 0x88, 0x00, 0x00, 0xE3, 0x04, 0x04, 0x40, 0x00, 0x06, }; const struct IrCode code_eu094Code = { 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[] = { 15, 493, 16, 493, 16, 698, 16, 1414, }; */ const uint8_t code_eu095Codes[] = { 0x2A, 0xAB, 0x6A, 0xAA, }; const struct IrCode code_eu095Code = { freq_to_timerval(34483), 16, // # of pairs 2, // # of bits per index code_eu046Times, code_eu095Codes }; const uint16_t code_eu096Times[] = { 13, 608, 14, 141, 14, 296, 14, 451, 14, 606, 14, 608, 14, 6207, }; const uint8_t code_eu096Codes[] = { 0x04, 0x94, 0x4B, 0x24, 0x95, 0x35, 0x24, 0xA2, 0x59, 0x24, 0xA8, 0x40, }; const struct IrCode code_eu096Code = { 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[] = { 15, 493, 16, 493, 16, 698, 16, 1414, }; */ const uint8_t code_eu097Codes[] = { 0x19, 0xAB, 0x59, 0xA9, }; const struct IrCode code_eu097Code = { freq_to_timerval(34483), 16, // # of pairs 2, // # of bits per index code_eu046Times, code_eu097Codes }; const uint16_t code_eu098Times[] = { 3, 8, 3, 18, 3, 28, 3, 12731, }; const uint8_t code_eu098Codes[] = { 0x80, 0x01, 0x00, 0xB8, 0x55, 0x10, 0x08, }; const struct IrCode code_eu098Code = { 0, // Non-pulsed code 27, // # of pairs 2, // # of bits per index code_eu098Times, code_eu098Codes }; const uint16_t code_eu099Times[] = { 46, 53, 46, 106, 46, 260, 46, 1502, 46, 10962, 93, 53, 93, 106, }; const uint8_t code_eu099Codes[] = { 0x46, 0x80, 0x00, 0x00, 0x00, 0x03, 0x44, 0x52, 0x00, 0x00, 0x0C, 0x22, 0x22, 0x90, 0x00, 0x00, 0x60, 0x80, }; const struct IrCode code_eu099Code = { 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[] = { 3, 8, 3, 18, 3, 28, 3, 12731, }; */ const uint8_t code_eu100Codes[] = { 0x80, 0x04, 0x00, 0xB8, 0x55, 0x40, 0x08, }; const struct IrCode code_eu100Code = { 0, // Non-pulsed code 27, // # of pairs 2, // # of bits per index code_eu098Times, code_eu100Codes }; const uint16_t code_eu101Times[] = { 14, 491, 14, 743, 14, 4674, }; const uint8_t code_eu101Codes[] = { 0x55, 0x50, 0x06, 0x55, 0x50, 0x05, }; const struct IrCode code_eu101Code = { 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[] = { 14, 491, 14, 743, 14, 5126, }; */ const uint8_t code_eu102Codes[] = { 0x45, 0x54, 0x02, 0x45, 0x54, 0x01, }; const struct IrCode code_eu102Code = { freq_to_timerval(38462), 24, // # of pairs 2, // # of bits per index code_eu087Times, code_eu102Codes }; const uint16_t code_eu103Times[] = { 44, 815, 45, 528, 45, 815, 45, 5000, }; const uint8_t code_eu103Codes[] = { 0x29, 0x9A, 0x9B, 0xA9, 0x9A, 0x9A, }; const struct IrCode code_eu103Code = { freq_to_timerval(34483), 24, // # of pairs 2, // # of bits per index code_eu103Times, code_eu103Codes }; const uint16_t code_eu104Times[] = { 14, 491, 14, 743, 14, 5881, }; const uint8_t code_eu104Codes[] = { 0x44, 0x40, 0x02, 0x44, 0x40, 0x01, }; const struct IrCode code_eu104Code = { 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[] = { 53, 56, 53, 171, 53, 3950, 53, 9599, 898, 451, 900, 226, }; */ const uint8_t code_eu105Codes[] = { 0x84, 0x10, 0x00, 0x20, 0x90, 0x01, 0x00, 0x80, 0x40, 0x04, 0x12, 0x09, 0x2A, 0xBA, 0x40, }; const struct IrCode code_eu105Code = { freq_to_timerval(38610), 38, // # of pairs 3, // # of bits per index code_na009Times, code_eu105Codes }; const uint16_t code_eu106Times[] = { 48, 246, 50, 47, 50, 94, 50, 245, 50, 1488, 50, 10970, 100, 47, 100, 94, }; const uint8_t code_eu106Codes[] = { 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 = { freq_to_timerval(38462), 59, // # of pairs 3, // # of bits per index code_eu106Times, code_eu106Codes }; const uint16_t code_eu107Times[] = { 16, 847, 16, 5900, 17, 559, 17, 846, 17, 847, }; const uint8_t code_eu107Codes[] = { 0x62, 0x08, 0xA0, 0x8A, 0x19, 0x04, 0x08, 0x40, 0x83, }; const struct IrCode code_eu107Code = { freq_to_timerval(33333), 24, // # of pairs 3, // # of bits per index code_eu107Times, code_eu107Codes }; const uint16_t code_eu108Times[] = { 14, 491, 14, 743, 14, 4622, }; const uint8_t code_eu108Codes[] = { 0x45, 0x54, 0x16, 0x45, 0x54, 0x15, }; const struct IrCode code_eu108Code = { freq_to_timerval(38462), 24, // # of pairs 2, // # of bits per index code_eu108Times, code_eu108Codes }; const uint16_t code_eu109Times[] = { 24, 185, 27, 78, 27, 183, 27, 1542, }; const uint8_t code_eu109Codes[] = { 0x19, 0x95, 0x5E, 0x66, 0x55, 0x50, }; const struct IrCode code_eu109Code = { freq_to_timerval(38462), 22, // # of pairs 2, // # of bits per index code_eu109Times, code_eu109Codes }; const uint16_t code_eu110Times[] = { 56, 55, 56, 168, 56, 4850, 447, 453, 448, 453, }; const uint8_t code_eu110Codes[] = { 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 = { freq_to_timerval(38462), 68, // # of pairs 3, // # of bits per index code_eu110Times, code_eu110Codes }; const uint16_t code_eu111Times[] = { 49, 52, 49, 250, 49, 252, 49, 2377, 49, 12009, 100, 52, 100, 102, }; const uint8_t code_eu111Codes[] = { 0x22, 0x80, 0x1A, 0x18, 0x01, 0x10, 0xC0, 0x02, }; const struct IrCode code_eu111Code = { freq_to_timerval(31250), 21, // # of pairs 3, // # of bits per index code_eu111Times, code_eu111Codes }; const uint16_t code_eu112Times[] = { 55, 55, 55, 167, 55, 5023, 55, 9506, 448, 445, 450, 444, }; const uint8_t code_eu112Codes[] = { 0x80, 0x02, 0x00, 0x00, 0x02, 0x00, 0x04, 0x92, 0x00, 0x00, 0x00, 0x49, 0x2A, 0x97, 0x48, }; const struct IrCode code_eu112Code = { 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[] = { 49, 53, 49, 104, 49, 262, 49, 264, 49, 8030, 100, 103, }; */ const uint8_t code_eu113Codes[] = { 0x46, 0x80, 0x23, 0x34, 0x00, 0x80, }; const struct IrCode code_eu113Code = { 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[] = { 47, 267, 50, 55, 50, 110, 50, 265, 50, 2055, 50, 12117, 100, 57, }; */ const uint8_t code_eu114Codes[] = { 0x04, 0x92, 0x49, 0x26, 0x34, 0x71, 0x44, 0x9A, 0xD1, 0xC5, 0x12, 0x48, }; const struct IrCode code_eu114Code = { freq_to_timerval(30303), 31, // # of pairs 3, // # of bits per index code_eu028Times, code_eu114Codes }; const uint16_t code_eu115Times[] = { 48, 98, 48, 196, 97, 836, 395, 388, 1931, 389, }; const uint8_t code_eu115Codes[] = { 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 = { freq_to_timerval(58824), 77, // # of pairs 3, // # of bits per index code_eu115Times, code_eu115Codes }; const uint16_t code_eu116Times[] = { 3, 9, 3, 31, 3, 42, 3, 10957, }; const uint8_t code_eu116Codes[] = { 0x80, 0x01, 0x00, 0x2E, 0x00, 0x04, 0x00, 0x80, }; const struct IrCode code_eu116Code = { 0, // Non-pulsed code 29, // # of pairs 2, // # of bits per index code_eu116Times, code_eu116Codes }; const uint16_t code_eu117Times[] = { 49, 53, 49, 262, 49, 264, 49, 8030, 100, 103, }; const uint8_t code_eu117Codes[] = { 0x22, 0x00, 0x1A, 0x10, 0x00, 0x40, }; const struct IrCode code_eu117Code = { freq_to_timerval(31250), 14, // # of pairs 3, // # of bits per index code_eu117Times, code_eu117Codes }; const uint16_t code_eu118Times[] = { 44, 815, 45, 528, 45, 815, 45, 4713, }; const uint8_t code_eu118Codes[] = { 0x2A, 0x9A, 0x9B, 0xAA, 0x9A, 0x9A, }; const struct IrCode code_eu118Code = { freq_to_timerval(34483), 24, // # of pairs 2, // # of bits per index code_eu118Times, code_eu118Codes }; const uint16_t code_eu119Times[] = { 14, 491, 14, 743, 14, 5430, }; const uint8_t code_eu119Codes[] = { 0x44, 0x44, 0x02, 0x44, 0x44, 0x01, }; const struct IrCode code_eu119Code = { freq_to_timerval(38462), 24, // # of pairs 2, // # of bits per index code_eu119Times, code_eu119Codes }; const uint16_t code_eu120Times[] = { 19, 78, 21, 27, 21, 77, 21, 3785, 22, 0, }; const uint8_t code_eu120Codes[] = { 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 = { 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[] = { 84, 88, 84, 261, 84, 3360, 347, 347, 347, 348, }; */ const uint8_t code_eu121Codes[] = { 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 = { 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[] = { 19, 78, 21, 27, 21, 77, 21, 3785, 22, 0, }; */ const uint8_t code_eu122Codes[] = { 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 = { freq_to_timerval(38462), 82, // # of pairs 3, // # of bits per index code_eu120Times, code_eu122Codes }; const uint16_t code_eu123Times[] = { 13, 490, 13, 741, 13, 742, 13, 5443, }; const uint8_t code_eu123Codes[] = { 0x6A, 0xA0, 0x0B, 0xAA, 0xA0, 0x09, }; const struct IrCode code_eu123Code = { freq_to_timerval(40000), 24, // # of pairs 2, // # of bits per index code_eu123Times, code_eu123Codes }; const uint16_t code_eu124Times[] = { 50, 54, 50, 158, 50, 407, 50, 2153, 843, 407, }; const uint8_t code_eu124Codes[] = { 0x80, 0x10, 0x40, 0x08, 0x92, 0x48, 0x01, 0xC0, 0x08, 0x20, 0x04, 0x49, 0x24, 0x00, 0x00, }; const struct IrCode code_eu124Code = { freq_to_timerval(38462), 38, // # of pairs 3, // # of bits per index code_eu124Times, code_eu124Codes }; const uint16_t code_eu125Times[] = { 55, 56, 55, 168, 55, 3929, 56, 0, 882, 454, 884, 452, }; const uint8_t code_eu125Codes[] = { 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 = { 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[] = { 55, 57, 55, 170, 55, 3949, 55, 9623, 56, 0, 898, 453, 900, 226, }; */ const uint8_t code_eu126Codes[] = { 0xA0, 0x00, 0x00, 0x04, 0x92, 0x49, 0x20, 0x00, 0x00, 0x04, 0x92, 0x49, 0x2B, 0x3D, 0x00, }; const struct IrCode code_eu126Code = { 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[] = { 14, 491, 14, 743, 14, 5126, }; */ const uint8_t code_eu127Codes[] = { 0x44, 0x40, 0x56, 0x44, 0x40, 0x55, }; const struct IrCode code_eu127Code = { freq_to_timerval(38462), 24, // # of pairs 2, // # of bits per index code_eu087Times, code_eu127Codes }; const uint16_t code_eu128Times[] = { 152, 471, 154, 156, 154, 469, 154, 782, 154, 2947, }; const uint8_t code_eu128Codes[] = { 0x05, 0xC4, 0x59, }; const struct IrCode code_eu128Code = { freq_to_timerval(41667), 8, // # of pairs 3, // # of bits per index code_eu128Times, code_eu128Codes }; const uint16_t code_eu129Times[] = { 50, 50, 50, 99, 50, 251, 50, 252, 50, 1449, 50, 11014, 102, 49, 102, 98, }; const uint8_t code_eu129Codes[] = { 0x47, 0x00, 0x00, 0x00, 0x00, 0x00, 0x8C, 0x8C, 0x40, 0x03, 0xF1, 0xEB, 0x23, 0x10, 0x00, 0xFC, 0x74, }; const struct IrCode code_eu129Code = { 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[] = { 50, 50, 50, 99, 50, 251, 50, 252, 50, 1449, 50, 11014, 102, 49, 102, 98, }; */ const uint8_t code_eu130Codes[] = { 0x47, 0x00, 0x00, 0x00, 0x00, 0x00, 0x8C, 0x8C, 0x40, 0x03, 0xE3, 0xEB, 0x23, 0x10, 0x00, 0xF8, 0xF4, }; const struct IrCode code_eu130Code = { freq_to_timerval(38462), 45, // # of pairs 3, // # of bits per index code_eu129Times, code_eu130Codes }; const uint16_t code_eu131Times[] = { 14, 491, 14, 743, 14, 4170, }; const uint8_t code_eu131Codes[] = { 0x55, 0x55, 0x42, 0x55, 0x55, 0x41, }; const struct IrCode code_eu131Code = { 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[] = { 4, 499, 4, 750, 4, 4999, }; */ const uint8_t code_eu132Codes[] = { 0x05, 0x50, 0x06, 0x05, 0x50, 0x04, }; const struct IrCode code_eu132Code = { 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[] = { 14, 491, 14, 743, 14, 4422, }; */ const uint8_t code_eu133Codes[] = { 0x55, 0x54, 0x12, 0x55, 0x54, 0x11, }; const struct IrCode code_eu133Code = { freq_to_timerval(38462), 24, // # of pairs 2, // # of bits per index code_eu071Times, code_eu133Codes }; const uint16_t code_eu134Times[] = { 13, 490, 13, 741, 13, 742, 13, 5939, }; const uint8_t code_eu134Codes[] = { 0x40, 0x0A, 0x83, 0x80, 0x0A, 0x81, }; const struct IrCode code_eu134Code = { freq_to_timerval(40000), 24, // # of pairs 2, // # of bits per index code_eu134Times, code_eu134Codes }; const uint16_t code_eu135Times[] = { 6, 566, 6, 851, 6, 5188, }; const uint8_t code_eu135Codes[] = { 0x54, 0x45, 0x46, 0x54, 0x45, 0x44, }; const struct IrCode code_eu135Code = { 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[] = { 55, 57, 55, 170, 55, 3949, 55, 9623, 56, 0, 898, 453, 900, 226, }; */ const uint8_t code_eu136Codes[] = { 0xA0, 0x00, 0x00, 0x04, 0x92, 0x49, 0x24, 0x00, 0x00, 0x00, 0x92, 0x49, 0x2B, 0x3D, 0x00, }; const struct IrCode code_eu136Code = { freq_to_timerval(38462), 38, // # of pairs 3, // # of bits per index code_na004Times, code_eu136Codes }; const uint16_t code_eu137Times[] = { 86, 91, 87, 90, 87, 180, 87, 8868, 88, 0, 174, 90, }; const uint8_t code_eu137Codes[] = { 0x14, 0x95, 0x4A, 0x35, 0x9A, 0x4A, 0xA5, 0x1B, 0x00, }; const struct IrCode code_eu137Code = { freq_to_timerval(35714), 22, // # of pairs 3, // # of bits per index code_eu137Times, code_eu137Codes }; const uint16_t code_eu138Times[] = { 4, 1036, 4, 1507, 4, 3005, }; const uint8_t code_eu138Codes[] = { 0x05, 0x60, 0x54, }; const struct IrCode code_eu138Code = { 0, // Non-pulsed code 11, // # of pairs 2, // # of bits per index code_eu138Times, code_eu138Codes }; const uint16_t code_eu139Times[] = { 0, 0, 14, 141, 14, 452, 14, 607, 14, 6310, }; const uint8_t code_eu139Codes[] = { 0x64, 0x92, 0x4A, 0x24, 0x92, 0xE3, 0x24, 0x92, 0x51, 0x24, 0x96, 0x00, }; const struct IrCode code_eu139Code = { 0, // Non-pulsed code 30, // # of pairs 3, // # of bits per index code_eu139Times, code_eu139Codes }; const uint16_t code_eu140Times[] = { 448, 448, 56, 168, 56, 56, 56, 4526, }; const uint8_t code_eu140Codes[] = { 0x15, 0xAA, 0x95, 0xAA, 0xAA, 0x5A, 0x55, 0xA5, 0xB1, 0x5A, 0xA9, 0x5A, 0xAA, 0xA5, 0xA5, 0x5A, 0x5B, }; const struct IrCode code_eu140Code = { freq_to_timerval(38462), 68, // # of pairs 2, // # of bits per index code_eu140Times, code_eu140Codes }; //////////////////////////////////////////////////////////////// //const array (called "NApowerCodes") of const pointers to IrCode structs //-otherwise stated: "declare NApowerCodes as 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[] = { &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[] = { &code_eu000Code, &code_eu001Code, &code_eu002Code, &code_na000Code, // same as &code_eu003Code &code_eu004Code, &code_eu005Code, &code_eu006Code, // toggle power, &code_eu140Code turns it off again &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_eu140Code, // counters &code_eu006Code (toggle), so out of order &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);