addControlledDevice(Ei_Make, "COLOR 56105", TV_Device);
addControlledDevice(Ei_Make, "COLOR 72105", TV_Device);
- RC5Protocol *rp = new RC5Protocol(
- guiObject,
- index,
- 931, 836,
- 969,
- 113205, true);
+ threadableProtocol = new RC5Protocol(guiObject, index, 0x40);
- threadableProtocol = rp;
-
- rp->setToggleBit(2);
-
- setPreData(0x10, 5);
-
- addKey("i", Unmapped_Key, 0x35, 8);
- addKey("a", Unmapped_Key, 0x37, 8);
- addKey("b", Unmapped_Key, 0x36, 8);
- addKey("c", Unmapped_Key, 0x32, 8);
- addKey("d", Unmapped_Key, 0x34, 8);
- addKey("Page Down", Unmapped_Key, 0x0B, 8);
- addKey("Page Up", Unmapped_Key, 0x0A, 8);
- addKey("TV in TXT", Unmapped_Key, 0x2D, 8);
- addKey("Stop TXT", Unmapped_Key, 0x29, 8);
- addKey("Time TXT", Unmapped_Key, 0x2A, 8);
- addKey("TV", Unmapped_Key, 0x3F, 8);
- addKey("TXT On", Unmapped_Key, 0x3C, 8);
- addKey("?", Unmapped_Key, 0x2C, 8);
- addKey("Zoom", Unmapped_Key, 0x2B, 8);
- addKey("Background TV", Unmapped_Key, 0x2E, 8);
- addKey("1", One_Key, 0x01, 8);
- addKey("2", Two_Key, 0x02, 8);
- addKey("3", Three_Key, 0x03, 8);
- addKey("4", Four_Key, 0x04, 8);
- addKey("5", Five_Key, 0x05, 8);
- addKey("6", Six_Key, 0x06, 8);
- addKey("7", Seven_Key, 0x07, 8);
- addKey("8", Eight_Key, 0x08, 8);
- addKey("9", Nine_Key, 0x09, 8);
- addKey("0", Zero_Key, 0x00, 8);
- addKey("LIGHT-", Unmapped_Key, 0x13, 8);
- addKey("LIGHT+", Unmapped_Key, 0x12, 8);
- addKey("COLOR-", Unmapped_Key, 0x15, 8);
- addKey("COLOR+", Unmapped_Key, 0x14, 8);
- addKey("CONTRAST-", Unmapped_Key, 0x1D, 8);
- addKey("CONTRAST+", Unmapped_Key, 0x1C, 8);
- addKey("VOLUME-", VolumeDown_Key, 0x11, 8);
- addKey("VOLUME+", VolumeUp_Key, 0x10, 8);
- addKey("->*", Unmapped_Key, 0x1E, 8);
- addKey("AV", Input_Key, 0x38, 8);
- addKey("-/--", Unmapped_Key, 0x0A, 8);
- addKey("TV_STATUS", Info_Key, 0x0F, 8);
- addKey("SLEEP", Sleep_Key, 0x26, 8);
- addKey("P<P", Unmapped_Key, 0x22, 8);
- addKey("->*<-PP", Unmapped_Key, 0x0E, 8);
- addKey("P-", ChannelDown_Key, 0x21, 8);
- addKey("P+", ChannelUp_Key, 0x20, 8);
- addKey("MUTE", Mute_Key, 0x0D, 8);
- addKey("ON-OFF", Power_Key, 0x0C, 8);
+ addKey("i", Unmapped_Key, 0x35, 6);
+ addKey("a", Unmapped_Key, 0x37, 6);
+ addKey("b", Unmapped_Key, 0x36, 6);
+ addKey("c", Unmapped_Key, 0x32, 6);
+ addKey("d", Unmapped_Key, 0x34, 6);
+ addKey("Page Down", Unmapped_Key, 0x0B, 6);
+ addKey("Page Up", Unmapped_Key, 0x0A, 6);
+ addKey("TV in TXT", Unmapped_Key, 0x2D, 6);
+ addKey("Stop TXT", Unmapped_Key, 0x29, 6);
+ addKey("Time TXT", Unmapped_Key, 0x2A, 6);
+ addKey("TV", Unmapped_Key, 0x3F, 6);
+ addKey("TXT On", Unmapped_Key, 0x3C, 6);
+ addKey("?", Unmapped_Key, 0x2C, 6);
+ addKey("Zoom", Unmapped_Key, 0x2B, 6);
+ addKey("Background TV", Unmapped_Key, 0x2E, 6);
+ addKey("1", One_Key, 0x01, 6);
+ addKey("2", Two_Key, 0x02, 6);
+ addKey("3", Three_Key, 0x03, 6);
+ addKey("4", Four_Key, 0x04, 6);
+ addKey("5", Five_Key, 0x05, 6);
+ addKey("6", Six_Key, 0x06, 6);
+ addKey("7", Seven_Key, 0x07, 6);
+ addKey("8", Eight_Key, 0x08, 6);
+ addKey("9", Nine_Key, 0x09, 6);
+ addKey("0", Zero_Key, 0x00, 6);
+ addKey("LIGHT-", Unmapped_Key, 0x13, 6);
+ addKey("LIGHT+", Unmapped_Key, 0x12, 6);
+ addKey("COLOR-", Unmapped_Key, 0x15, 6);
+ addKey("COLOR+", Unmapped_Key, 0x14, 6);
+ addKey("CONTRAST-", Unmapped_Key, 0x1D, 6);
+ addKey("CONTRAST+", Unmapped_Key, 0x1C, 6);
+ addKey("VOLUME-", VolumeDown_Key, 0x11, 6);
+ addKey("VOLUME+", VolumeUp_Key, 0x10, 6);
+ addKey("->*", Unmapped_Key, 0x1E, 6);
+ addKey("AV", Input_Key, 0x38, 6);
+ addKey("-/--", Unmapped_Key, 0x0A, 6);
+ addKey("TV_STATUS", Info_Key, 0x0F, 6);
+ addKey("SLEEP", Sleep_Key, 0x26, 6);
+ addKey("P<P", Unmapped_Key, 0x22, 6);
+ addKey("->*<-PP", Unmapped_Key, 0x0E, 6);
+ addKey("P-", ChannelDown_Key, 0x21, 6);
+ addKey("P+", ChannelUp_Key, 0x20, 6);
+ addKey("MUTE", Mute_Key, 0x0D, 6);
+ addKey("ON-OFF", Power_Key, 0x0C, 6);
}
GoldStar_Make,
index)
{
- RC5Protocol *rp = new RC5Protocol(
- guiObject,
- index,
- 899, 783,
- 962,
- 107722, true);
-
- threadableProtocol = rp;
-
- setPreData(0x40, 7);
-
- rp->setToggleBit(2);
+ threadableProtocol = new RC5Protocol(guiObject, index, 0x40);
addKey("0", Zero_Key, 0x00, 6);
addKey("1", One_Key, 0x01, 6);
{
addControlledDevice(Hauppauge_Make, "PVR 350", Computer_Device);
- RC5Protocol *rp = new RC5Protocol(
- guiObject,
- index,
- 900, 900, // biphase pulse
- 900, // lead pulse
- 114000, true); // constant-length gap
-
- threadableProtocol = rp;
-
- rp->setToggleBit(2);
-
- setPreData(0x5E, 7);
+ threadableProtocol = new RC5Protocol(guiObject, index, 0x5E);
addKey("Power", Power_Key, 0x3D, 6);
addKey("Go", Unmapped_Key, 0x3B, 6);
{
addControlledDevice(Hauppauge_Make, "PVR-250", Computer_Device);
- RC5Protocol *rp = new RC5Protocol(
- guiObject,
- index,
- 900, 900,
- 900,
- 114000, true);
-
- threadableProtocol = rp;
-
- rp->setToggleBit(2);
+ threadableProtocol = new RC5Protocol(guiObject, index, 0x54);
addKey("POWER", Power_Key, 0x150C, 13);
addKey("1", One_Key, 0x1525, 13);
QObject *guiObject,
unsigned int index)
: PIRKeysetMetaData(
- "Satellite (Dish Network) Keyset 1",
+ "Sat (Dish) Keyset 1",
JVC_Make,
index)
{
QObject *guiObject,
unsigned int index)
: PIRKeysetMetaData(
- "Satellite (Dish Network) Keyset 2",
+ "Sat (Dish) Keyset 2",
JVC_Make,
index)
{
QObject *guiObject,
unsigned int index)
: PIRKeysetMetaData(
- "Portable Audio Keyset 1",
+ "Audio Keyset 1",
JVC_Make,
index)
{
unsigned int index)
: JVCPortableAudio1(guiObject, index)
{
- setKeysetName("Portable Audio Keyset 1a");
+ setKeysetName("Audio Keyset 1a");
addKey("CD-PLAY-PAUSE", Play_Key, 0xC5BC, 16);
addKey("MD-PLAY-PAUSE", Unmapped_Key, 0xF50C, 16);
unsigned int index)
: JVCPortableAudio1(guiObject, index)
{
- setKeysetName("Portable(?) Audio Keyset 1b");
+ setKeysetName("Audio Keyset 1b");
addKey("0", Zero_Key, 0xCD06, 16); // What about "10" key here?
addKey("TUNER", Unmapped_Key, 0xC5D0, 16);
QObject *guiObject,
unsigned int index)
: PIRKeysetMetaData(
- "Portable Audio Keyset 2",
+ "Audio Keyset 2",
JVC_Make,
index)
{
LG_Make,
index)
{
- RC5Protocol *rp = new RC5Protocol(
- guiObject,
- index,
- 800, 800,
- 800,
- 107000, true);
-
- threadableProtocol = rp;
-
- rp->setToggleBit(2);
-
- setPreData(0x10, 5);
-
- addKey("POWER", Power_Key, 0x0C, 8);
- addKey("DRP", Unmapped_Key, 0x14, 8);
- addKey("TVAV", Unmapped_Key, 0x38, 8);
- addKey("TURBOSOUND", Unmapped_Key, 0x24, 8);
- addKey("TURBOPICTURE", Unmapped_Key, 0x13, 8);
- addKey("PIP", PIP_Key, 0x3A, 8);
- addKey("TEXT", Unmapped_Key, 0x3C, 8);
- addKey("PR-MINUS", Unmapped_Key, 0x37, 8);
- addKey("PR-PLUS", Unmapped_Key, 0x36, 8);
- addKey("SWAP", PIPSwap_Key, 0x32, 8);
- addKey("INPUT", Input_Key, 0x34, 8);
- addKey("MENU", Menu_Key, 0x3B, 8);
- addKey("MUTE", Mute_Key, 0x0D, 8);
- addKey("PROGUP", ChannelUp_Key, 0x20, 8);
- addKey("PROGDOWN", ChannelDown_Key, 0x21, 8);
- addKey("VOLDOWN", VolumeDown_Key, 0x11, 8);
- addKey("VOLUP", VolumeUp_Key, 0x10, 8);
- addKey("OK", Select_Key, 0x25, 8);
- addKey("1", One_Key, 0x01, 8);
- addKey("2", Two_Key, 0x02, 8);
- addKey("3", Three_Key, 0x03, 8);
- addKey("4", Four_Key, 0x04, 8);
- addKey("5", Five_Key, 0x05, 8);
- addKey("6", Six_Key, 0x06, 8);
- addKey("7", Seven_Key, 0x07, 8);
- addKey("8", Eight_Key, 0x08, 8);
- addKey("9", Nine_Key, 0x09, 8);
- addKey("0", Zero_Key, 0x00, 8);
- addKey("PSM", Unmapped_Key, 0x0E, 8); // preset picture
- addKey("SSM", Unmapped_Key, 0x16, 8); // preset sound
- addKey("POS", Unmapped_Key, 0x2D, 8); // position, "UPDATE"
- addKey("2-12PIP", Unmapped_Key, 0x35, 8); // strobe, "KEY_SHOP"
- addKey("STILL", Pause_Key, 0x29, 8); // "KEY_PAUSE", "HOLD"
- addKey("SIZE", Unmapped_Key, 0x2B, 8); // "KEY_SAVE"
- addKey("TIME", Unmapped_Key, 0x2A, 8);
- addKey("REVEAL", Unmapped_Key, 0x2C, 8); // "KEY_REDO"
- addKey("MIX", Unmapped_Key, 0x2E, 8); // "KEY_MAX"
- addKey("SLEEP", Sleep_Key, 0x3E, 8);
- addKey("LIST", Unmapped_Key, 0x0F, 8);
- addKey("I-II", DoubleDigit_Key, 0x23, 8);
- addKey("ARC", AspectRatio_Key, 0x33, 8);
- addKey("EYE", Unmapped_Key, 0x12, 8);
- addKey("KEY_MEDIA", Unmapped_Key, 0x15, 8);
+ threadableProtocol = new RC5Protocol(guiObject, index, 0x40);
+
+ addKey("POWER", Power_Key, 0x0C, 6);
+ addKey("DRP", Unmapped_Key, 0x14, 6);
+ addKey("TVAV", Unmapped_Key, 0x38, 6);
+ addKey("TURBOSOUND", Unmapped_Key, 0x24, 6);
+ addKey("TURBOPICTURE", Unmapped_Key, 0x13, 6);
+ addKey("PIP", PIP_Key, 0x3A, 6);
+ addKey("TEXT", Unmapped_Key, 0x3C, 6);
+ addKey("PR-MINUS", Unmapped_Key, 0x37, 6);
+ addKey("PR-PLUS", Unmapped_Key, 0x36, 6);
+ addKey("SWAP", PIPSwap_Key, 0x32, 6);
+ addKey("INPUT", Input_Key, 0x34, 6);
+ addKey("MENU", Menu_Key, 0x3B, 6);
+ addKey("MUTE", Mute_Key, 0x0D, 6);
+ addKey("PROGUP", ChannelUp_Key, 0x20, 6);
+ addKey("PROGDOWN", ChannelDown_Key, 0x21, 6);
+ addKey("VOLDOWN", VolumeDown_Key, 0x11, 6);
+ addKey("VOLUP", VolumeUp_Key, 0x10, 6);
+ addKey("OK", Select_Key, 0x25, 6);
+ addKey("1", One_Key, 0x01, 6);
+ addKey("2", Two_Key, 0x02, 6);
+ addKey("3", Three_Key, 0x03, 6);
+ addKey("4", Four_Key, 0x04, 6);
+ addKey("5", Five_Key, 0x05, 6);
+ addKey("6", Six_Key, 0x06, 6);
+ addKey("7", Seven_Key, 0x07, 6);
+ addKey("8", Eight_Key, 0x08, 6);
+ addKey("9", Nine_Key, 0x09, 6);
+ addKey("0", Zero_Key, 0x00, 6);
+ addKey("PSM", Unmapped_Key, 0x0E, 6); // preset picture
+ addKey("SSM", Unmapped_Key, 0x16, 6); // preset sound
+ addKey("POS", Unmapped_Key, 0x2D, 6); // position, "UPDATE"
+ addKey("2-12PIP", Unmapped_Key, 0x35, 6); // strobe, "KEY_SHOP"
+ addKey("STILL", Pause_Key, 0x29, 6); // "KEY_PAUSE", "HOLD"
+ addKey("SIZE", Unmapped_Key, 0x2B, 6); // "KEY_SAVE"
+ addKey("TIME", Unmapped_Key, 0x2A, 6);
+ addKey("REVEAL", Unmapped_Key, 0x2C, 6); // "KEY_REDO"
+ addKey("MIX", Unmapped_Key, 0x2E, 6); // "KEY_MAX"
+ addKey("SLEEP", Sleep_Key, 0x3E, 6);
+ addKey("LIST", Unmapped_Key, 0x0F, 6);
+ addKey("I-II", DoubleDigit_Key, 0x23, 6);
+ addKey("ARC", AspectRatio_Key, 0x33, 6);
+ addKey("EYE", Unmapped_Key, 0x12, 6);
+ addKey("KEY_MEDIA", Unmapped_Key, 0x15, 6);
}
{
setKeysetName("TV Keyset 2a");
- addKey("KEY_RED", Red_Key, 0x37, 8);
- addKey("KEY_GREEN", Green_Key, 0x36, 8);
- addKey("KEY_YELLOW", Yellow_Key, 0x32, 8);
- addKey("KEY_BLUE", Blue_Key, 0x34, 8);
+ addKey("KEY_RED", Red_Key, 0x37, 6);
+ addKey("KEY_GREEN", Green_Key, 0x36, 6);
+ addKey("KEY_YELLOW", Yellow_Key, 0x32, 6);
+ addKey("KEY_BLUE", Blue_Key, 0x34, 6);
}
{
setKeysetName("TV Keyset 2b");
- addKey("EYE/*", Unmapped_Key, 0x37, 8);
- addKey("I/II/*", DoubleDigit_Key, 0x36, 8);
- addKey("Q.VIEW", Unmapped_Key, 0x32, 8);
- addKey("LIST", Unmapped_Key, 0x34, 8);
- addKey("sleep", Sleep_Key, 0x26, 8); // might need separate class
+ addKey("EYE/*", Unmapped_Key, 0x37, 6);
+ addKey("I/II/*", DoubleDigit_Key, 0x36, 6);
+ addKey("Q.VIEW", Unmapped_Key, 0x32, 6);
+ addKey("LIST", Unmapped_Key, 0x34, 6);
+ addKey("sleep", Sleep_Key, 0x26, 6); // might need separate class
}
--- /dev/null
+#include "magnavox.h"
+#include "rc6protocol.h"
+#include "rc5protocol.h"
+#include "necprotocol.h"
+
+MagnavoxDVD1::MagnavoxDVD1(
+ QObject *guiObject,
+ unsigned int index)
+ : PIRKeysetMetaData(
+ "DVD Keyset 1",
+ Magnavox_Make,
+ index)
+{
+ addControlledDevice(Magnavox_Make, "MDV450", DVD_Device);
+
+ threadableProtocol = new RC6Protocol(guiObject, index, 0x04);
+
+ addKey("power", Power_Key, 0x0C, 8);
+ addKey("1", One_Key, 0x01, 8);
+ addKey("2", Two_Key, 0x02, 8);
+ addKey("3", Three_Key, 0x03, 8);
+ addKey("4", Four_Key, 0x04, 8);
+ addKey("5", Five_Key, 0x05, 8);
+ addKey("6", Six_Key, 0x06, 8);
+ addKey("7", Seven_Key, 0x07, 8);
+ addKey("8", Eight_Key, 0x08, 8);
+ addKey("9", Nine_Key, 0x09, 8);
+ addKey("0", Zero_Key, 0x00, 8);
+ addKey("title", DiscTitle_Key, 0x83, 8);
+ addKey("display", Info_Key, 0x0F, 8);
+ addKey("disc_Menu", DiscMenu_Key, 0x54, 8);
+ addKey("system_menu", Menu_Key, 0x82, 8);
+ addKey("^", Up_Key, 0x58, 8);
+ addKey("<", Left_Key, 0x5A, 8);
+ addKey(">", Right_Key, 0x5B, 8);
+ addKey("v", Down_Key, 0x5C, 8);
+ addKey("ok", Select_Key, 0x5D, 8);
+ addKey("<<", Rewind_Key, 0x21, 8);
+ addKey(">>", FastForward_Key, 0x20, 8);
+ addKey("stop", Stop_Key, 0x31, 8);
+ addKey("play", Play_Key, 0x2C, 8);
+ addKey("pause", Pause_Key, 0x30, 8);
+ addKey("subtitle", Captions_Key, 0x4B, 8);
+ addKey("angle", Unmapped_Key, 0x85, 8);
+ addKey("zoom", Unmapped_Key, 0xF7, 8);
+ addKey("audio", Unmapped_Key, 0x4E, 8);
+ addKey("repeat", Unmapped_Key, 0x1D, 8);
+ addKey("a-b", Unmapped_Key, 0x3B, 8);
+ addKey("preview", Unmapped_Key, 0xD5, 8);
+ addKey("mute", Mute_Key, 0x0D, 8);
+}
+
+
+MagnavoxVCR1::MagnavoxVCR1(
+ QObject *guiObject,
+ unsigned int index)
+ : PIRKeysetMetaData(
+ "VCR Keyset 1",
+ Magnavox_Make,
+ index)
+{
+ threadableProtocol = new RC5Protocol(guiObject, index);
+
+ addKey("Power", Power_Key, 0x114C, 13);
+ addKey("0", Zero_Key, 0x1140, 13);
+ addKey("1", One_Key, 0x1141, 13);
+ addKey("2", Two_Key, 0x1142, 13);
+ addKey("3", Three_Key, 0x1143, 13);
+ addKey("4", Four_Key, 0x1144, 13);
+ addKey("5", Five_Key, 0x1145, 13);
+ addKey("6", Six_Key, 0x1146, 13);
+ addKey("7", Seven_Key, 0x1147, 13);
+ addKey("8", Eight_Key, 0x1148, 13);
+ addKey("9", Nine_Key, 0x1149, 13);
+ addKey("OneHundred", PlusOneHundred_Key, 0x114A, 13);
+ addKey("CancelAngle", Unmapped_Key, 0x1171, 13);
+ addKey("ChMinus", ChannelDown_Key, 0x1172, 13);
+ addKey("ChPlus", ChannelUp_Key, 0x1174, 13);
+ addKey("IndexTC", Unmapped_Key, 0x0170, 13);
+ addKey("Menu", Menu_Key, 0x0152, 13);
+ addKey("News", Unmapped_Key, 0x041A, 13);
+ addKey("Night", Unmapped_Key, 0x143E, 13);
+ addKey("OK", Select_Key, 0x0157, 13);
+ addKey("Pause", Pause_Key, 0x1169, 13);
+ addKey("Rew", Rewind_Key, 0x1172, 13);
+ addKey("FF", FastForward_Key, 0x1174, 13);
+ addKey("Play", Play_Key, 0x1175, 13);
+ addKey("Stop", Stop_Key, 0x1176, 13);
+ addKey("Record", Record_Key, 0x1177, 13);
+ addKey("UP", Up_Key, 0x0150, 13);
+ addKey("DOWN", Down_Key, 0x0151, 13);
+ addKey("LEFT", Left_Key, 0x0155, 13);
+ addKey("RIGHT", Right_Key, 0x0156, 13);
+ addKey("VOL+", VolumeUp_Key, 0x1410, 13);
+ addKey("VOL-", VolumeDown_Key, 0x1411, 13);
+ addKey("Mute", Mute_Key, 0x100D, 13);
+ addKey("TvPower", Unmapped_Key, 0x100C, 13);
+ addKey("TvVolumeUp", Unmapped_Key, 0x1010, 13);
+ addKey("TvVolumeDn", Unmapped_Key, 0x1011, 13);
+ addKey("TvChUp", Unmapped_Key, 0x1020, 13);
+ addKey("TvChDn", Unmapped_Key, 0x1021, 13);
+ addKey("SkipSrch", Unmapped_Key, 0x016A, 13);
+ addKey("FrameAdvance", StepForward_Key, 0x016B, 13);
+ addKey("VcrChUp", Unmapped_Key, 0x1160, 13);
+ addKey("VcrChDn", Unmapped_Key, 0x1161, 13);
+ addKey("Menu", Menu_Key, 0x115D, 13);
+ addKey("Slow", Unmapped_Key, 0x1168, 13);
+ addKey("Status", Info_Key, 0x114F, 13);
+ addKey("Clear", Clear_Key, 0x1171, 13);
+ addKey("VarSlowUp", Unmapped_Key, 0x1166, 13);
+ addKey("VarSlowDn", Unmapped_Key, 0x1165, 13);
+ addKey("Qtr", Unmapped_Key, 0x1167, 13);
+ addKey("TrackUp", TrackingPlus_Key, 0x014D, 13);
+ addKey("TrackDn", TrackingMinus_Key, 0x014E, 13);
+ addKey("GoTo", Unmapped_Key, 0x1173, 13);
+ addKey("Memo", Unmapped_Key, 0x117B, 13);
+ addKey("Speed", VHSSpeed_Key, 0x117A, 13);
+ addKey("VcrTv", Unmapped_Key, 0x117E, 13);
+ addKey("2xPlay", Unmapped_Key, 0x116A, 13);
+}
+
+
+MagnavoxConverterBox1::MagnavoxConverterBox1(
+ QObject *guiObject,
+ unsigned int index)
+ : PIRKeysetMetaData(
+ "Settop Box Keyset 1",
+ Magnavox_Make,
+ index)
+{
+ addControlledDevice(Magnavox_Make, "TB100MG9", TV_Device);
+
+ NECProtocol *np = new NECProtocol(
+ guiObject,
+ index,
+ 894, 795,
+ 894, 2537,
+ 33751, false);
+
+ threadableProtocol = np;
+
+ np->setHeaderPair(3514, 3396);
+ np->setTrailerPulse(894);
+
+ addKey("KEY_POWER", Power_Key, 0x541ABE, 24);
+ addKey("KEY_1", One_Key, 0x57EA81, 24);
+ addKey("KEY_2", Two_Key, 0x561A9E, 24);
+ addKey("KEY_3", Three_Key, 0x551AAE, 24);
+ addKey("KEY_4", Four_Key, 0x571A8E, 24);
+ addKey("KEY_5", Five_Key, 0x549AB6, 24);
+ addKey("KEY_6", Six_Key, 0x569A96, 24);
+ addKey("KEY_7", Seven_Key, 0x559AA6, 24);
+ addKey("KEY_8", Eight_Key, 0x579A86, 24);
+ addKey("KEY_9", Nine_Key, 0x545ABA, 24);
+ addKey("KEY_0", Zero_Key, 0x565A9A, 24);
+ addKey("KEY_OK", Select_Key, 0x55DAA2, 24);
+ addKey("KEY_UP", Up_Key, 0x547AB8, 24);
+ addKey("KEY_DOWN", Down_Key, 0x567A98, 24);
+ addKey("KEY_LEFT", Left_Key, 0x578A87, 24);
+ addKey("KEY_RIGHT", Right_Key, 0x558AA7, 24);
+ addKey("KEY_CHANNELUP", ChannelUp_Key, 0x542ABD, 24);
+ addKey("KEY_CHANNELDOWN", ChannelDown_Key, 0x544ABB, 24);
+ addKey("KEY_EPG", Guide_Key, 0x54FAB0, 24);
+ addKey("KEY_AUDIO", Unmapped_Key, 0x557AA8, 24);
+ addKey("KEY_DOT", Unmapped_Key, 0x56DA92, 24);
+ addKey("KEY_SETUP", Menu_Key, 0x57DA82, 24);
+ addKey("KEY_PAUSE", Pause_Key, 0x56FA90, 24);
+ addKey("KEY_LAST", Unmapped_Key, 0x55CAA3, 24);
+ addKey("KEY_BACK", PrevChannel_Key, 0x577A88, 24);
+ addKey("KEY_DISPLAY", Info_Key, 0x57CA83, 24);
+}
+
+
+MagnavoxTV1::MagnavoxTV1(
+ QObject *guiObject,
+ unsigned int index)
+ : PIRKeysetMetaData(
+ "TV(?) Keyset 1",
+ Magnavox_Make,
+ index)
+{
+ threadableProtocol = new RC5Protocol(guiObject, index, 0x40);
+
+ addKey("Power", Power_Key, 0x0C, 6);
+ addKey("Reset", Reset_Key, 0x0E, 6);
+ addKey("Sleep", Sleep_Key, 0x26, 6);
+ addKey("Mute", Mute_Key, 0x0D, 6);
+ addKey("VolUp", VolumeUp_Key, 0x10, 6);
+ addKey("VolDown", VolumeDown_Key, 0x11, 6);
+ addKey("ChUp", ChannelUp_Key, 0x20, 6);
+ addKey("ChDown", ChannelDown_Key, 0x21, 6);
+ addKey("PrevCh", PrevChannel_Key, 0x21, 6);
+ addKey("One", One_Key, 0x01, 6);
+ addKey("Two", Two_Key, 0x02, 6);
+ addKey("Three", Three_Key, 0x03, 6);
+ addKey("Four", Four_Key, 0x04, 6);
+ addKey("Five", Five_Key, 0x05, 6);
+ addKey("Six", Six_Key, 0x06, 6);
+ addKey("Seven", Seven_Key, 0x07, 6);
+ addKey("Eight", Eight_Key, 0x08, 6);
+ addKey("Nine", Nine_Key, 0x09, 6);
+ addKey("Zero", Zero_Key, 0x00, 6);
+ addKey("Display", Info_Key, 0x2E, 6);
+ addKey("Plus", Right_Key, 0x2B, 6);
+ addKey("Minus", Left_Key, 0x2C, 6);
+ addKey("Status", Unmapped_Key, 0x0F, 6);
+ addKey("Play", Play_Key, 0x1C, 6);
+ addKey("Stop", Stop_Key, 0x1D, 6);
+ addKey("FF", FastForward_Key, 0x2B, 6);
+ addKey("Rev", Rewind_Key, 0x2C, 6);
+ addKey("Pause", Pause_Key, 0x3B, 6);
+}
--- /dev/null
+#ifndef MAGNAVOX_H
+#define MAGNAVOX_H
+
+#include "pirkeysetmetadata.h"
+#include <QObject>
+
+class MagnavoxDVD1: public PIRKeysetMetaData
+{
+public:
+ MagnavoxDVD1(
+ QObject *guiObject,
+ unsigned int index);
+};
+
+class MagnavoxVCR1: public PIRKeysetMetaData
+{
+public:
+ MagnavoxVCR1(
+ QObject *guiObject,
+ unsigned int index);
+};
+
+class MagnavoxConverterBox1: public PIRKeysetMetaData
+{
+public:
+ MagnavoxConverterBox1(
+ QObject *guiObject,
+ unsigned int index);
+};
+
+class MagnavoxTV1: public PIRKeysetMetaData
+{
+public:
+ MagnavoxTV1(
+ QObject *guiObject,
+ unsigned int index);
+};
+
+#endif // MAGNAVOX_H
--- /dev/null
+#include "philips.h"
+#include "rc5protocol.h"
+#include "rc6protocol.h"
+#include "necprotocol.h"
+
+PhilipsTV1::PhilipsTV1(
+ QObject *guiObject,
+ unsigned int index)
+ : PIRKeysetMetaData(
+ "TV Keyset 1",
+ Philips_Make,
+ index)
+{
+ addControlledDevice(Philips_Make, "HV92", TV_Device);
+ addControlledDevice(Philips_Make, "15PF4121", TV_Device);
+
+ threadableProtocol = new RC5Protocol(guiObject, index);
+
+ addKey("ON/OFF", Power_Key, 0x100C, 13);
+ addKey("1", One_Key, 0x1001, 13);
+ addKey("2", Two_Key, 0x1002, 13);
+ addKey("3", Three_Key, 0x1003, 13);
+ addKey("4", Four_Key, 0x1004, 13);
+ addKey("5", Five_Key, 0x1005, 13);
+ addKey("6", Six_Key, 0x1006, 13);
+ addKey("7", Seven_Key, 0x1007, 13);
+ addKey("8", Eight_Key, 0x1008, 13);
+ addKey("9", Nine_Key, 0x1009, 13);
+ addKey("0", Zero_Key, 0x1000, 13);
+ addKey("VOL+", VolumeUp_Key, 0x1010, 13);
+ addKey("VOL-", VolumeDown_Key, 0x1011, 13);
+ addKey("MUTE", Mute_Key, 0x100D, 13);
+ addKey("P+", ChannelUp_Key, 0x1020, 13);
+ addKey("P-", ChannelDown_Key, 0x1021, 13);
+ addKey("UP", Up_Key, 0x0010, 13);
+ addKey("DOWN", Down_Key, 0x0011, 13);
+ addKey("MENU", Menu_Key, 0x0012, 13);
+ addKey("exit", Exit_Key, 0x0013, 13);
+ addKey("LEFT", Left_Key, 0x0015, 13);
+ addKey("RIGHT", Right_Key, 0x0016, 13);
+ addKey("AV", Input_Key, 0x1038, 13); // "EXT", "SOURCE"
+ addKey("TIMER", Sleep_Key, 0x1026, 13); // "POWER-OFF", "sleep"
+ addKey("TELETEXT", Unmapped_Key, 0x0017, 13);
+ addKey("I/II", Language_Key, 0x1023, 13); // "TEXT_REVEAL", "Stereo"
+ addKey("RED", Red_Key, 0x00C8, 13);
+ addKey("GREEN", Green_Key, 0x00FB, 13);
+ addKey("YELLOW", Yellow_Key, 0x00F1, 13); // "radio"
+ addKey("BLUE", Blue_Key, 0x10F9, 13);
+ addKey("CENTER", Unmapped_Key, 0x1029, 13); // "TEXT_STOP_SEQUENCE", etc.
+ addKey("MY_AUDIO", Unmapped_Key, 0x10D2, 13);
+ addKey("EXPAND", Surround_Key, 0x1024, 13); // "STEREO", "spatial"
+ addKey("INFO", Info_Key, 0x100F, 13); // "+", "OSD"
+ addKey("TEXT_TV", Unmapped_Key, 0x103C, 13); // "TELETEXT"
+ addKey("SURF", Unmapped_Key, 0x1022, 13);
+ addKey("TEXT_CLOCK", Unmapped_Key, 0x102A, 13); // "time"
+ addKey("TEXT_ENLARGE", Unmapped_Key, 0x102B, 13); // "Reduce_Teletext"
+ addKey("PICTURE_SETTINGS", PictureMode_Key, 0x002B, 13);
+ addKey("SOUND_SETTINGS", SoundMode_Key, 0x002C, 13);
+ addKey("GAME", Unmapped_Key, 0x002E, 13);
+ addKey("1-", DoubleDigit_Key, 0x100A, 13); // -/--
+ addKey("100", PlusOneHundred_Key, 0x100A, 13);
+ addKey("TV-Dash", Dash_Key, 0x100A, 13);
+ addKey("CP", Unmapped_Key, 0x100B, 13); // "C/P"
+ addKey("pp", PrevChannel_Key, 0x100E, 13); // "GREEN"
+ addKey("BRIGHTNESS_UP", Unmapped_Key, 0x1012, 13);
+ addKey("BRIGHTNESS_DOWN", Unmapped_Key, 0x1013, 13);
+ addKey("CONTRAST_UP", Unmapped_Key, 0x1014, 13);
+ addKey("CONTRAST_DOWN", Unmapped_Key, 0x1015, 13);
+ addKey("BASS_UP", Unmapped_Key, 0x1016, 13);
+ addKey("BASS_DOWN", Unmapped_Key, 0x1017, 13);
+ addKey("TREBLE_UP", Unmapped_Key, 0x1018, 13);
+ addKey("TREBLE_DOWN", Unmapped_Key, 0x1019, 13);
+ addKey("BALANCE_RIGHT", Unmapped_Key, 0x101A, 13);
+ addKey("BALANCE_LEFT", Unmapped_Key, 0x101B, 13);
+ addKey("TT_OUT", Unmapped_Key, 0x101D, 13);
+ addKey("TT_UPDOWN", Unmapped_Key, 0x102B, 13); // "TELETEXT_RESIZE"
+ addKey("TT_X", Unmapped_Key, 0x102D, 13); // "TELETEXT_OFF"
+ addKey("TT_TV", Unmapped_Key, 0x103F, 13);
+ addKey("TT_PLAY", Unmapped_Key, 0x101E, 13);
+ addKey("TT_INFO", Unmapped_Key, 0x102C, 13); // "TELETEXT_ADDINFO"
+ addKey("TT_STOP", Unmapped_Key, 0x1029, 13);
+ addKey("TT_TIME", Unmapped_Key, 0x102A, 13);
+ addKey("TT_MIX", Unmapped_Key, 0x102E, 13);
+ addKey("TELETEXT", Unmapped_Key, 0x103C, 13);
+ // The media keys are not well described! -- config file 5373
+ addKey("RECORD", Record_Key, 0x1037, 13);
+ addKey("BACK", Unmapped_Key, 0x102F, 13);
+ addKey("STOP", Stop_Key, 0x1036, 13);
+ addKey("PLAY", Play_Key, 0x1028, 13);
+ addKey("FORWARD", Unmapped_Key, 0x1035, 13);
+ addKey("REVERSE", Unmapped_Key, 0x1033, 13);
+ addKey("SKIP", Unmapped_Key, 0x1177, 13);
+ addKey("FAST_BACK", Unmapped_Key, 0x116F, 13);
+ addKey("DOWN", Unmapped_Key, 0x1176, 13);
+ addKey("PLAY_3", Unmapped_Key, 0x1168, 13);
+ addKey("FAST_FORWARD", Unmapped_Key, 0x1175, 13);
+ addKey("SCREEN_WIDTH", AspectRatio_Key, 0x003E, 13); // "format"
+ addKey("vcr_rewind", Rewind_Key, 0x1032, 13);
+ addKey("vcr_fastforward", FastForward_Key, 0x1034, 13);
+ addKey("ambilight_power", Unmapped_Key, 0x10E3, 13);
+ addKey("ambilight_mode", Unmapped_Key, 0x10E4, 13);
+ addKey("fav", Favorites_Key, 0x0039, 13);
+ addKey(".", Unmapped_Key, 0x00F8, 13);
+ addKey("Cinema", Unmapped_Key, 0x00F9, 13);
+ addKey("PAY-TV_UP", Unmapped_Key, 0x10DC, 13);
+ addKey("PAY-TV_DOWN", Unmapped_Key, 0x10DD, 13);
+ addKey("RADIO_UP", Unmapped_Key, 0x10DE, 13);
+ addKey("RADIO_DOWN", Unmapped_Key, 0x10DF, 13);
+}
+
+
+PhilipsTV1a::PhilipsTV1a(
+ QObject *guiObject,
+ unsigned int index)
+ : PhilipsTV1(guiObject, index)
+{
+ setKeysetName("TV Keyset 1a");
+
+ addControlledDevice(Philips_Make, "17PT1563", TV_Device);
+
+ addKey("TIMER", Sleep_Key, 0x002D, 13);
+}
+
+
+PhilipsTV1b::PhilipsTV1b(
+ QObject *guiObject,
+ unsigned int index)
+ : PhilipsTV1(guiObject, index)
+{
+ setKeysetName("TV Keyset 1b");
+
+ addControlledDevice(Philips_Make, "29PT5507", TV_Device);
+
+ addKey("sound", Unmapped_Key, 0x1014, 13);
+ addKey("radio", Unmapped_Key, 0x00F1, 13);
+ addKey("screen", Unmapped_Key, 0x1015, 13);
+ addKey("rec", Record_Key, 0x002B, 13);
+ addKey("rewind", Rewind_Key, 0x002C, 13);
+ addKey("stop", Stop_Key, 0x002D, 13);
+ addKey("play", Play_Key, 0x002E, 13);
+}
+
+
+PhilipsTV1c::PhilipsTV1c(
+ QObject *guiObject,
+ unsigned int index)
+ : PhilipsTV1(guiObject, index)
+{
+ setKeysetName("TV Keyset 1c");
+
+ addKey("spatial", Unmapped_Key, 0x1024, 13);
+ addKey("stereo", Surround_Key, 0x1023, 13);
+ addKey("dbb", Unmapped_Key, 0x1016, 13);
+}
+
+
+PhilipsTV1d::PhilipsTV1d(
+ QObject *guiObject,
+ unsigned int index)
+ : PhilipsTV1(guiObject, index)
+{
+ setKeysetName("TV Keyset 1d");
+
+ addControlledDevice(Philips_Make, "47PFL7603D", TV_Device);
+ addControlledDevice(Philips_Make, "14PT1562/00", TV_Device);
+
+ addKey("NOTE_BUTTON", Unmapped_Key, 0x1014, 13); // "Tune"
+ addKey("RADIO_BUTTON", Unmapped_Key, 0x00F1, 13);
+ addKey("RED", Red_Key, 0x002B, 13);
+ addKey("GREEN", Green_Key, 0x002C, 13);
+ addKey("YELLOW", Yellow_Key, 0x002D, 13);
+ addKey("BLUE", Blue_Key, 0x002E, 13);
+ addKey("prev", PrevChannel_Key, 0x1022, 13);
+ addKey("red-", Unmapped_Key, 0x000E, 13); // "CURSOR -"
+ addKey("blue+", Unmapped_Key, 0x000D, 13); // "CURSOR +"
+ addKey("pip", PIP_Key, 0x0018, 13);
+ addKey("pip_move", PIPMove_Key, 0x0019, 13);
+ addKey("pip_source", PIPSource_Key, 0x001F, 13);
+ addKey("pip_still", PIPPause_Key, 0x0025, 13);
+ addKey("pip_switch", PIPSwap_Key, 0x001A, 13);
+ addKey("pip_prog+", PIPChannelUp_Key, 0x0026, 13);
+ addKey("pip_prog-", PIPChannelDown_Key, 0x0027, 13);
+ addKey("tvtxt_index", Unmapped_Key, 0x002F, 13);
+}
+
+
+PhilipsTV1e::PhilipsTV1e(
+ QObject *guiObject,
+ unsigned int index)
+ : PhilipsTV1(guiObject, index)
+{
+ setKeysetName("TV Keyset 1e");
+
+ addControlledDevice(Philips_Make, "28PT4455", TV_Device);
+ addControlledDevice(Philips_Make, "21PT2265", TV_Device);
+
+ addKey("smart_audio", SoundMode_Key, 0x10CB, 13);
+ addKey("smart_video", PictureMode_Key, 0x10CA, 13);
+ addKey("teletext/ok", Select_Key, 0x103C, 13);
+ addKey("red", Red_Key, 0x002B, 13);
+ addKey("green", Green_Key, 0x002C, 13);
+ addKey("yellow", Yellow_Key, 0x002D, 13);
+ addKey("blue", Blue_Key, 0x002E, 13);
+ addKey("teletext_menu", Unmapped_Key, 0x002F, 13);
+}
+
+
+PhilipsTV1f::PhilipsTV1f(
+ QObject *guiObject,
+ unsigned int index)
+ : PhilipsTV1(guiObject, index)
+{
+ setKeysetName("TV Keyset 1f");
+
+ addControlledDevice(Philips_Make, "25PT5302", TV_Device);
+
+ addKey("SETUP", Menu_Key, 0x003A, 13);
+ addKey("VOL-", VolumeDown_Key, 0x0011, 13);
+ addKey("VOL+", VolumeUp_Key, 0x0010, 13);
+ addKey("P<P", PrevChannel_Key, 0x1022, 13); // Might be wrong
+ addKey("RED", Red_Key, 0x002B, 13);
+ addKey("GREEN", Green_Key, 0x002C, 13);
+ addKey("YELLOW", Yellow_Key, 0x002D, 13);
+ addKey("BLUE", Blue_Key, 0x002E, 13);
+ addKey("GRAY", Unmapped_Key, 0x002F, 13);
+ addKey("SMARTVIDEO", PictureMode_Key, 0x10CA, 13);
+ addKey("SMARTAUDIO", SoundMode_Key, 0x10CB, 13);
+ addKey("+", Unmapped_Key, 0x0032, 13);
+ addKey("-", Unmapped_Key, 0x0033, 13);
+}
+
+
+PhilipsTV2::PhilipsTV2(
+ QObject *guiObject,
+ unsigned int index)
+ : PIRKeysetMetaData(
+ "TV Keyset 2",
+ Philips_Make,
+ index)
+{
+ addControlledDevice(Philips_Make, "28PW8506/12R", TV_Device);
+ addControlledDevice(Philips_Make, "26PFL5604H", TV_Device);
+ addControlledDevice(Philips_Make, "32PFL5403D", TV_Device);
+
+ threadableProtocol = new RC6Protocol(guiObject, index, 0x00);
+
+ addKey("Power", Power_Key, 0x0C, 8);
+ addKey("TV", Unmapped_Key, 0x9F, 8);
+ addKey("SUBTITLE", Captions_Key, 0x4B, 8);
+ addKey("TELETEXT", Unmapped_Key, 0x3C, 8);
+ addKey("SOURCE", Input_Key, 0x38, 8); // "inputselect", "external"
+ addKey("red", Red_Key, 0x6D, 8);
+ addKey("green", Green_Key, 0x6E, 8);
+ addKey("yellow", Yellow_Key, 0x6F, 8);
+ addKey("blue", Blue_Key, 0x70, 8);
+ addKey("Home", Menu_Key, 0x54, 8); // "Menu"
+ addKey("Guide", Guide_Key, 0xCC, 8); // "nextview", "EPG"
+ addKey("OPTIONS", Unmapped_Key, 0x40, 8);
+ addKey("up", Up_Key, 0x58, 8);
+ addKey("down", Down_Key, 0x59, 8);
+ addKey("left", Left_Key, 0x5A, 8);
+ addKey("right", Right_Key, 0x5B, 8);
+ addKey("OK", Select_Key, 0x5C, 8);
+ addKey("INFO", Info_Key, 0x0F, 8); // "i+"
+ addKey("<<", Rewind_Key, 0x2B, 8);
+ addKey("Play", Play_Key, 0x2C, 8);
+ addKey(">>", FastForward_Key, 0x28, 8);
+ addKey("Stop", Stop_Key, 0x31, 8); // "MHEG_Cancel"
+ addKey("Record", Record_Key, 0x37, 8);
+ addKey("Vol+", VolumeUp_Key, 0x10, 8);
+ addKey("Vol-", VolumeDown_Key, 0x11, 8);
+ addKey("Mute", Mute_Key, 0x0D, 8);
+ addKey("FORMAT", AspectRatio_Key, 0xF5, 8); // "Picture_Format", "displaymode"
+ addKey("P+", ChannelUp_Key, 0x20, 8);
+ addKey("P-", ChannelDown_Key, 0x21, 8);
+ addKey("1", One_Key, 0x01, 8);
+ addKey("2", Two_Key, 0x02, 8);
+ addKey("3", Three_Key, 0x03, 8);
+ addKey("4", Four_Key, 0x04, 8);
+ addKey("5", Five_Key, 0x05, 8);
+ addKey("6", Six_Key, 0x06, 8);
+ addKey("7", Seven_Key, 0x07, 8);
+ addKey("8", Eight_Key, 0x08, 8);
+ addKey("9", Nine_Key, 0x09, 8);
+ addKey("0", Zero_Key, 0x00, 8);
+ addKey("SOUND", SoundMode_Key, 0xF4, 8); // "smartsound"
+ addKey("PICTURE", PictureMode_Key, 0xF3, 8); // "smartdisplay"
+ addKey("InstallMenu", Unmapped_Key, 0x45, 8);
+ addKey("SurroundSound", Surround_Key, 0x71, 8); // "soundselect"
+ addKey("Time", Sleep_Key, 0x7F, 8); // "clock", "timer_programming"
+ addKey("ActiveControl", Unmapped_Key, 0x96, 8);
+ addKey("Dual_Screen", PIP_Key, 0x5D, 8); // "splitdisplay"
+ addKey("Previous_channel", PrevChannel_Key, 0x0A, 8); // "PP", "AB"
+ addKey("1st/2nd_language", Language_Key, 0x4E, 8); // "monostereo"
+ addKey("freeze", Pause_Key, 0x67, 8); // "pause"
+ addKey("zoom", Unmapped_Key, 0xE7, 8);
+}
+
+
+PhilipsTV2a::PhilipsTV2a(
+ QObject *guiObject,
+ unsigned int index)
+ : PhilipsTV2(guiObject, index)
+{
+ setKeysetName("TV Keyset 2a");
+
+ addControlledDevice(Philips_Make, "29PT8607/12", TV_Device);
+
+ addKey("tv-speed+", Unmapped_Key, 0x71, 8);
+ addKey("tv-speed-", Unmapped_Key, 0x6E, 8);
+ addKey("tv-play", Play_Key, 0x70, 8);
+ addKey("tv-stop", Stop_Key, 0x6F, 8);
+ addKey("tv-recording", Record_Key, 0x6D, 8);
+ addKey("tv-display", Info_Key, 0x3C, 8);
+ addKey("tv-teletext_submode_(J:12)", Unmapped_Key, 0x5D, 8);
+ addKey("tv-solarization", Unmapped_Key, 0xCC, 8);
+}
+
+
+PhilipsTV2b::PhilipsTV2b(
+ QObject *guiObject,
+ unsigned int index)
+ : PhilipsTV2(guiObject, index)
+{
+ setKeysetName("TV Keyset 2b");
+
+ addControlledDevice(Philips_Make, "32PFL7532D", TV_Device);
+
+ addKey("KEY_PLAY", Play_Key, 0xC1, 8);
+ addKey("KEY_FAVORITES", Favorites_Key, 0xD2, 8);
+}
+
+
+PhilipsTV3::PhilipsTV3(
+ QObject *guiObject,
+ unsigned int index)
+ : PIRKeysetMetaData(
+ "TV (settop-box) keyset 3",
+ Philips_Make,
+ index)
+{
+ addControlledDevice(Philips_Make, "DTX6372", TV_Device);
+
+ threadableProtocol = new RC6Protocol(guiObject, index, 0x28);
+
+ addKey("power", Power_Key, 0x0C, 8);
+ addKey("text", Unmapped_Key, 0x3C, 8);
+ addKey("red", Red_Key, 0x6D, 8);
+ addKey("green", Green_Key, 0x6E, 8);
+ addKey("yellow", Yellow_Key, 0x6F, 8);
+ addKey("blue", Blue_Key, 0x70, 8);
+ addKey("menu", Menu_Key, 0x54, 8);
+ addKey("wide", AspectRatio_Key, 0xD8, 8);
+ addKey("subtitle", Captions_Key, 0x4B, 8);
+ addKey("info", Info_Key, 0x0F, 8);
+ addKey("guide", Guide_Key, 0xCC, 8);
+ addKey("select", Select_Key, 0x5C, 8);
+ addKey("exit", Exit_Key, 0x83, 8);
+ addKey("up", Up_Key, 0x58, 8);
+ addKey("left", Left_Key, 0x5A, 8);
+ addKey("right", Right_Key, 0x5B, 8);
+ addKey("down", Down_Key, 0x59, 8);
+ addKey("vol+", VolumeUp_Key, 0x10, 8);
+ addKey("vol-", VolumeDown_Key, 0x11, 8);
+ addKey("p+", ChannelUp_Key, 0x20, 8);
+ addKey("p-", ChannelDown_Key, 0x21, 8);
+ addKey("mute", Mute_Key, 0x0D, 8);
+ addKey("1", One_Key, 0x01, 8);
+ addKey("2", Two_Key, 0x02, 8);
+ addKey("3", Three_Key, 0x03, 8);
+ addKey("4", Four_Key, 0x04, 8);
+ addKey("5", Five_Key, 0x05, 8);
+ addKey("6", Six_Key, 0x06, 8);
+ addKey("7", Seven_Key, 0x07, 8);
+ addKey("8", Eight_Key, 0x08, 8);
+ addKey("9", Nine_Key, 0x09, 8);
+ addKey("0", Zero_Key, 0x00, 8);
+ addKey("tv/dtv", Input_Key, 0x43, 8);
+}
+
+
+PhilipsDVD1::PhilipsDVD1(
+ QObject *guiObject,
+ unsigned int index)
+ : PIRKeysetMetaData(
+ "DVD Keyset 1",
+ Philips_Make,
+ index)
+{
+ addControlledDevice(Philips_Make, "DVD712", DVD_Device);
+ addControlledDevice(Philips_Make, "DVD722", DVD_Device);
+ addControlledDevice(Philips_Make, "DVD-724", DVD_Device);
+ addControlledDevice(Philips_Make, "DVP 3005", DVD_Device);
+
+ threadableProtocol = new RC6Protocol(guiObject, index, 0x04);
+
+ addKey("Standby", Power_Key, 0x0C, 8);
+ addKey("Forward", FastForward_Key, 0x28, 8);
+ addKey("Rewind", Rewind_Key, 0x29, 8);
+ addKey("Stop", Stop_Key, 0x31, 8);
+ addKey("Play", Play_Key, 0x2C, 8);
+ addKey("Still", Pause_Key, 0x30, 8); // "pause"
+ addKey("Subtitle", Captions_Key, 0x4B, 8);
+ addKey("Title", DiscTitle_Key, 0x71, 8);
+ addKey("Menu", DiscMenu_Key, 0x54, 8);
+ addKey("System_Menu", Menu_Key, 0x82, 8); // "setup"
+ addKey("OK", Select_Key, 0x5C, 8);
+ addKey("Left", Left_Key, 0x5A, 8);
+ addKey("Right", Right_Key, 0x5B, 8);
+ addKey("Up", Up_Key, 0x58, 8);
+ addKey("Down", Down_Key, 0x59, 8);
+ addKey("Return", Exit_Key, 0x83, 8);
+ addKey("Skip_Right", Next_Key, 0x20, 8); // "next"
+ addKey("Skip_Left", Previous_Key, 0x21, 8); // "prev"
+ addKey("Audio", Language_Key, 0x4E, 8);
+ addKey("1", One_Key, 0x01, 8);
+ addKey("2", Two_Key, 0x02, 8);
+ addKey("3", Three_Key, 0x03, 8);
+ addKey("4", Four_Key, 0x04, 8);
+ addKey("5", Five_Key, 0x05, 8);
+ addKey("6", Six_Key, 0x06, 8);
+ addKey("7", Seven_Key, 0x07, 8);
+ addKey("8", Eight_Key, 0x08, 8);
+ addKey("9", Nine_Key, 0x09, 8);
+ addKey("0", Zero_Key, 0x00, 8);
+ addKey("Display", Info_Key, 0x0F, 8);
+ addKey("Angle", Unmapped_Key, 0x85, 8);
+ addKey("Zoom", Unmapped_Key, 0xF7, 8);
+ addKey("Repeat", Repeat_Key, 0x1D, 8);
+ addKey("Repeat_AB", Unmapped_Key, 0x3B, 8);
+ addKey("Shuffle", Unmapped_Key, 0x1C, 8);
+ addKey("Scan", Unmapped_Key, 0x2A, 8);
+ addKey("Secret", Unmapped_Key, 0xEB, 8);
+ addKey("Preview", Unmapped_Key, 0xB5, 8);
+ addKey("Mute", Mute_Key, 0x0D, 8);
+ addKey("T-C", Unmapped_Key, 0xC8, 8);
+ addKey("dim", Unmapped_Key, 0x13, 8);
+ addKey("fts", Unmapped_Key, 0xFB, 8);
+ addKey("sound-mode", SoundMode_Key, 0x50, 8);
+}
+
+
+PhilipsDVD1a::PhilipsDVD1a(
+ QObject *guiObject,
+ unsigned int index)
+ : PhilipsDVD1(guiObject, index)
+{
+ setKeysetName("DVD Keyset 1a");
+
+ addControlledDevice(Philips_Make, "DVP-5982", DVD_Device);
+
+ addKey("Power", Power_Key, 0xC7, 8);
+ addKey("Play_Pause", Pause_Key, 0x2C, 8);
+ addKey("USB", Unmapped_Key, 0x7E, 8);
+}
+
+
+PhilipsDVD1b::PhilipsDVD1b(
+ QObject *guiObject,
+ unsigned int index)
+ : PhilipsDVD1(guiObject, index)
+{
+ setKeysetName("DVD Keyset 1b");
+
+ addControlledDevice(Philips_Make, "DVP-642", DVD_Device);
+
+ addKey("Title", DiscTitle_Key, 0x83, 8);
+ addKey("Forward", FastForward_Key, 0x20, 8);
+ addKey("Reverse", Rewind_Key, 0x21, 8);
+}
+
+
+PhilipsDVD1c::PhilipsDVD1c(
+ QObject *guiObject,
+ unsigned int index)
+ : PhilipsDVD1(guiObject, index)
+{
+ setKeysetName("DVD (HT) Keyset 1c");
+
+ addControlledDevice(Philips_Make, "HTS3544", DVD_Device);
+ addControlledDevice(Philips_Make, "DVP5982", DVD_Device);
+
+ addKey("power", Power_Key, 0xC7, 8);
+ addKey("disc-usb", Unmapped_Key, 0x3F, 8);
+ addKey("open-close", Eject_Key, 0x42, 8);
+ addKey("program", Program_Key, 0xFB, 8);
+ addKey("menu", DiscMenu_Key, 0xD1, 8);
+ addKey("title", DiscTitle_Key, 0x83, 8);
+ addKey("play-pause", Pause_Key, 0x2C, 8);
+ addKey("USB", Unmapped_Key, 0x7E, 8);
+}
+
+
+PhilipsDVD1d::PhilipsDVD1d(
+ QObject *guiObject,
+ unsigned int index)
+ : PhilipsDVD1(guiObject, index)
+{
+ setKeysetName("DVD Keyset 1d");
+
+ addControlledDevice(Philips_Make, "DVD 963sa", DVD_Device);
+
+ addKey("display", Info_Key, 0x48, 8);
+ addKey("ff-left", Rewind_Key, 0x21, 8);
+ addKey("ff-right", FastForward_Key, 0x20, 8);
+}
+
+
+PhilipsDVD2::PhilipsDVD2(
+ QObject *guiObject,
+ unsigned int index)
+ : PIRKeysetMetaData(
+ "DVD/BD Keyset 2",
+ Philips_Make,
+ index)
+{
+ threadableProtocol = new RC6Protocol(guiObject, index, 0x46);
+
+ addKey("power", Power_Key, 0xC7, 8);
+ addKey("topmenu", DiscTitle_Key, 0x9C, 8);
+ addKey("bonus", Unmapped_Key, 0x5D, 8);
+ addKey("repeat", Repeat_Key, 0x1D, 8);
+ addKey("hdmi", Unmapped_Key, 0xC6, 8);
+ addKey("red", Red_Key, 0x6D, 8);
+ addKey("green", Green_Key, 0x6E, 8);
+ addKey("yellow", Yellow_Key, 0x6F, 8);
+ addKey("blue", Blue_Key, 0x70, 8);
+ addKey("home", Menu_Key, 0x92, 8);
+ addKey("menu", DiscMenu_Key, 0x9A, 8);
+ addKey("options", Unmapped_Key, 0xC9, 8);
+ addKey("up", Up_Key, 0x58, 8);
+ addKey("left", Left_Key, 0x5A, 8);
+ addKey("right", Right_Key, 0x5B, 8);
+ addKey("down", Down_Key, 0x59, 8);
+ addKey("ok", Select_Key, 0x5C, 8);
+ addKey("back", Exit_Key, 0x83, 8);
+ addKey("info", Info_Key, 0x0F, 8);
+ addKey("prev", Previous_Key, 0x21, 8);
+ addKey("play", Play_Key, 0x2C, 8);
+ addKey("pause", Pause_Key, 0x30, 8);
+ addKey("next", Next_Key, 0x20, 8);
+ addKey("bwd", Rewind_Key, 0x29, 8);
+ addKey("stop", Stop_Key, 0x31, 8);
+ addKey("fwd", FastForward_Key, 0x28, 8);
+ addKey("eject", Eject_Key, 0x42, 8);
+ addKey("1", One_Key, 0x01, 8);
+ addKey("2", Two_Key, 0x02, 8);
+ addKey("3", Three_Key, 0x03, 8);
+ addKey("4", Four_Key, 0x04, 8);
+ addKey("5", Five_Key, 0x05, 8);
+ addKey("6", Six_Key, 0x06, 8);
+ addKey("7", Seven_Key, 0x07, 8);
+ addKey("8", Eight_Key, 0x08, 8);
+ addKey("9", Nine_Key, 0x09, 8);
+ addKey("0", Zero_Key, 0x00, 8);
+ addKey("subtitle", Captions_Key, 0x4B, 8);
+ addKey("audio", Language_Key, 0x4E, 8);
+}
+
+
+PhilipsDVD3::PhilipsDVD3(
+ QObject *guiObject,
+ unsigned int index)
+ : PIRKeysetMetaData(
+ "DVD Keyset 3",
+ Philips_Make,
+ index)
+{
+ addControlledDevice(Philips_Make, "DVDR3570H", DVD_Device);
+
+ threadableProtocol = new RC6Protocol(guiObject, index, 0x32);
+
+ addKey("Power", Power_Key, 0x0C, 8);
+ addKey("Edit", Unmapped_Key, 0xF1, 8);
+ addKey("LiveTV", Unmapped_Key, 0xEE, 8);
+ addKey("Disc", DiscMenu_Key, 0xD1, 8);
+ addKey("Select", Unmapped_Key, 0xC9, 8);
+ addKey("Cam", Unmapped_Key, 0xC3, 8);
+ addKey("TVGuide", Guide_Key, 0xC2, 8);
+ addKey("Home", Menu_Key, 0x92, 8);
+ addKey("HDDLIst", Unmapped_Key, 0x90, 8);
+ addKey("Back", Unmapped_Key, 0x83, 8);
+ addKey("Options", Unmapped_Key, 0x82, 8);
+ addKey("USB", Unmapped_Key, 0x7E, 8);
+ addKey("Blue", Blue_Key, 0x70, 8);
+ addKey("Yellow", Yellow_Key, 0x6F, 8);
+ addKey("Green", Green_Key, 0x6E, 8);
+ addKey("Red", Red_Key, 0x6D, 8);
+ addKey("OK", Select_Key, 0x5C, 8);
+ addKey("Right", Right_Key, 0x5B, 8);
+ addKey("Left", Left_Key, 0x5A, 8);
+ addKey("Down", Down_Key, 0x59, 8);
+ addKey("Up", Up_Key, 0x58, 8);
+ addKey("Audio", Language_Key, 0x4E, 8);
+ addKey("Subtitle", Captions_Key, 0x4B, 8);
+ addKey("Scart", Unmapped_Key, 0x43, 8);
+ addKey("Rec", Record_Key, 0x37, 8);
+ addKey("Stop", Stop_Key, 0x31, 8);
+ addKey("Play", Play_Key, 0x2C, 8);
+ addKey("Rew", Rewind_Key, 0x29, 8);
+ addKey("Ffw", FastForward_Key, 0x28, 8);
+ addKey("Prev", Previous_Key, 0x21, 8);
+ addKey("Next", Next_Key, 0x20, 8);
+ addKey("Ch-", ChannelDown_Key, 0x10, 8);
+ addKey("Ch+", ChannelUp_Key, 0x11, 8);
+ addKey("Info", Info_Key, 0x0F, 8);
+ addKey("0", Zero_Key, 0x00, 8);
+ addKey("1", One_Key, 0x01, 8);
+ addKey("2", Two_Key, 0x02, 8);
+ addKey("3", Three_Key, 0x03, 8);
+ addKey("4", Four_Key, 0x04, 8);
+ addKey("5", Five_Key, 0x05, 8);
+ addKey("6", Six_Key, 0x06, 8);
+ addKey("7", Seven_Key, 0x07, 8);
+ addKey("8", Eight_Key, 0x08, 8);
+ addKey("9", Nine_Key, 0x09, 8);
+}
+
+
+PhilipsDVD4::PhilipsDVD4(
+ QObject *guiObject,
+ unsigned int index)
+ : PIRKeysetMetaData(
+ "DVD Keyset 4",
+ Philips_Make,
+ index)
+{
+ addControlledDevice(Philips_Make, "DVDR 1000", DVD_Device);
+
+ threadableProtocol = new RC6Protocol(guiObject, index, 0x30);
+
+ addKey("Power", Power_Key, 0x0C, 8);
+ addKey("TVDVD", Input_Key, 0x43, 8);
+ addKey("STOP", Stop_Key, 0x31, 8);
+ addKey("RECORD", Record_Key, 0x37, 8);
+ addKey("PLAY", Play_Key, 0x2C, 8);
+ addKey("REWIND", Rewind_Key, 0x29, 8);
+ addKey("PAUSE", Pause_Key, 0x30, 8);
+ addKey("SLOW", Unmapped_Key, 0x22, 8);
+ addKey("FORWARD", FastForward_Key, 0x28, 8);
+ addKey("PREVIOUS", Previous_Key, 0x21, 8);
+ addKey("NEXT", Next_Key, 20, 8);
+ addKey("DISC", Unmapped_Key, 0x54, 8);
+ addKey("EDIT", Unmapped_Key, 0xCF, 8);
+ addKey("SYSTEM", Info_Key, 0x0F, 8);
+ addKey("UP", Up_Key, 0x58, 8);
+ addKey("DOWN", Down_Key, 0x59, 8);
+ addKey("LEFT", Left_Key, 0x5A, 8);
+ addKey("RIGHT", Right_Key, 0x5B, 8);
+ addKey("CLEAR", Clear_Key, 0x41, 8);
+ addKey("TIMER", Unmapped_Key, 0xFE, 8);
+ addKey("SELECT", Select_Key, 0xFA, 8);
+ addKey("PROGPLUS", ChannelUp_Key, 0x1E, 8);
+ addKey("PROGMINUS", ChannelDown_Key, 0x1F, 8);
+ addKey("1", One_Key, 0x01, 8);
+ addKey("2", Two_Key, 0x02, 8);
+ addKey("3", Three_Key, 0x03, 8);
+ addKey("4", Four_Key, 0x04, 8);
+ addKey("5", Five_Key, 0x05, 8);
+ addKey("6", Six_Key, 0x06, 8);
+ addKey("7", Seven_Key, 0x07, 8);
+ addKey("8", Eight_Key, 0x08, 8);
+ addKey("9", Nine_Key, 0x09, 8);
+ addKey("0", Zero_Key, 0x00, 8);
+ addKey("TC", Unmapped_Key, 0xC8, 8);
+ addKey("TUNER", Unmapped_Key, 0xEE, 8);
+ addKey("ZOOM", Unmapped_Key, 0xF7, 8);
+ addKey("ANGLE", Unmapped_Key, 0x85, 8);
+ addKey("SUBTITLE", Captions_Key, 0x4B, 8);
+ addKey("AUDIO", Language_Key, 0x4E, 8);
+ addKey("DIM", Unmapped_Key, 0x13, 8);
+ addKey("REPEAT", Repeat_Key, 0x1D, 8);
+ addKey("REPEATAB", Unmapped_Key, 0x3B, 8);
+ addKey("SCAN", Unmapped_Key, 0x2A, 8);
+}
+
+
+PhilipsVCR1::PhilipsVCR1(
+ QObject *guiObject,
+ unsigned int index)
+ : PIRKeysetMetaData(
+ "VCR Keyset 1",
+ Philips_Make,
+ index)
+{
+ threadableProtocol = new RC5Protocol(guiObject, index);
+
+ addKey("Standby", Power_Key, 0x114C, 13);
+ addKey("External", Input_Key, 0x1178, 13);
+ addKey("Forward", FastForward_Key, 0x1174, 13);
+ addKey("Record", Record_Key, 0x1177, 13);
+ addKey("Rewind", Rewind_Key, 0x1172, 13);
+ addKey("Stop", Stop_Key, 0x1176, 13);
+ addKey("Play", Play_Key, 0x1175, 13);
+ addKey("Timer", Unmapped_Key, 0x115D, 13);
+ addKey("OSD", Info_Key, 0x114F, 13);
+ addKey("Menu", Menu_Key, 0x0152, 13);
+ addKey("OK", Select_Key, 0x0157, 13);
+ addKey("Left", Left_Key, 0x0155, 13);
+ addKey("Right", Right_Key, 0x0156, 13);
+ addKey("Up", Up_Key, 0x0150, 13);
+ addKey("Down", Down_Key, 0x0151, 13);
+ addKey("Program+", ChannelUp_Key, 0x1160, 13);
+ addKey("Program-", ChannelDown_Key, 0x1161, 13);
+ addKey("Audio", Language_Key, 0x1163, 13);
+ addKey("Still", Pause_Key, 0x1169, 13); // "PAUSE"
+ addKey("1", One_Key, 0x1141, 13);
+ addKey("2", Two_Key, 0x1142, 13);
+ addKey("3", Three_Key, 0x1143, 13);
+ addKey("4", Four_Key, 0x1144, 13);
+ addKey("5", Five_Key, 0x1145, 13);
+ addKey("6", Six_Key, 0x1146, 13);
+ addKey("7", Seven_Key, 0x1147, 13);
+ addKey("8", Eight_Key, 0x1148, 13);
+ addKey("9", Nine_Key, 0x1149, 13);
+ addKey("0", Zero_Key, 0x1140, 13);
+ addKey("-/--", DoubleDigit_Key, 0x114A, 13);
+ addKey("100", PlusOneHundred_Key, 0x114A, 13);
+ addKey("VCR-Dash", Dash_Key, 0x114A, 13);
+ addKey("Index", Unmapped_Key, 0x0170, 13);
+ addKey("reset", Reset_Key, 0x1171, 13); // "clear"
+ addKey("play<", Unmapped_Key, 0x116F, 13);
+ addKey("x>", Unmapped_Key, 0x116A, 13); // "X2_PLAY"
+ addKey("speed", VHSSpeed_Key, 0x117A, 13); // "SP/LP"
+ addKey("Childlock", Unmapped_Key, 0x017F, 13);
+ addKey("System", Unmapped_Key, 0x094A, 13);
+ addKey("vol_dn", VolumeDown_Key, 0x1011, 13);
+ addKey("vol_up", VolumeUp_Key, 0x1010, 13);
+ addKey("F_ADV", StepForward_Key, 0x016B, 13);
+ addKey("G_CODE", Unmapped_Key, 0x0145, 13);
+ addKey("GO_TO", Unmapped_Key, 0x1173, 13);
+ addKey("SLOW", Unmapped_Key, 0x1168, 13);
+ addKey("memory", Unmapped_Key, 0x117B, 13);
+ addKey("VCR_TV", Unmapped_Key, 0x117E, 13);
+ addKey("track_up", TrackingPlus_Key, 0x014D, 13);
+ addKey("track_down", TrackingMinus_Key, 0x14E, 13);
+}
+
+
+PhilipsVCR1a::PhilipsVCR1a(
+ QObject *guiObject,
+ unsigned int index)
+ : PhilipsVCR1(guiObject, index)
+{
+ setKeysetName("VCR Keyset 1a");
+
+ addControlledDevice(Philips_Make, "VP27/55", VCR_Device);
+
+ addKey("menu", Menu_Key, 0x115D, 13);
+ addKey("eject", Eject_Key, 0x116D, 13);
+ addKey("sleep_wake", Sleep_Key, 0x1026, 13);
+ addKey("alt_ch", PrevChannel_Key, 0x1022, 13);
+ addKey("chan_prev", ChannelDown_Key, 0x1020, 13);
+ addKey("chan_next", ChannelUp_Key, 0x1021, 13);
+ addKey("mute", Mute_Key, 0x100D, 13);
+ addKey("TV-POWER", Unmapped_Key, 0x100C, 13);
+}
+
+
+PhilipsVCR1b::PhilipsVCR1b(
+ QObject *guiObject,
+ unsigned int index)
+ : PhilipsVCR1(guiObject, index)
+{
+ setKeysetName("VCR Keyset 1b");
+
+ addKey("Cassette_Eject", Eject_Key, 0x017E, 13);
+ addKey("Select", Select_Key, 0x114B, 13);
+ addKey("Rewind", Rewind_Key, 0x1165, 13);
+ addKey("Forward", FastForward_Key, 0x1166, 13);
+ addKey("Previous", Previous_Key, 0x0171, 13);
+ addKey("Next", Next_Key, 0x0170, 13);
+ addKey("Monitor", Unmapped_Key, 0x017A, 13);
+ addKey("Tuner", Unmapped_Key, 0x017D, 13);
+ addKey("Tracking", AutoTracking_Key, 0x114E, 13);
+}
+
+
+PhilipsVCR1c::PhilipsVCR1c(
+ QObject *guiObject,
+ unsigned int index)
+ : PhilipsVCR1(guiObject, index)
+{
+ setKeysetName("VCR Keyset 1c");
+
+ addKey("TIMER_REVIEW", Unmapped_Key, 0x0168, 13);
+ addKey("DATE_UP", Unmapped_Key, 0x125C, 13);
+ addKey("DATE_DOWN", Unmapped_Key, 0x125D, 13);
+ addKey("PROG_UP", Unmapped_Key, 0x1260, 13);
+ addKey("PROG_DOWN", Unmapped_Key, 0x1261, 13);
+ addKey("START_UP", Unmapped_Key, 0x125E, 13);
+ addKey("START_DOWN", Unmapped_Key, 0x125F, 13);
+ addKey("END_UP", Unmapped_Key, 0x1263, 13);
+ addKey("END_DOWN", Unmapped_Key, 0x1264, 13);
+ addKey("Tracking", AutoTracking_Key, 0x114E, 13);
+ addKey("FF", FastForward_Key, 0x1166, 13);
+ addKey("Previous", Previous_Key, 0x0171, 13);
+ addKey("Next", Next_Key, 0x0170, 13);
+ addKey("SET_CLOCK", Unmapped_Key, 0x1164, 13);
+ addKey("VPS", Unmapped_Key, 0x114B, 13);
+ addKey("Cassette", Eject_Key, 0x017E, 13);
+ addKey("DECODER", Unmapped_Key, 0x0169, 13);
+ addKey("Tuner", Unmapped_Key, 0x017D, 13);
+ addKey("Monitor", Unmapped_Key, 0x017A, 13);
+ addKey("SYSTEM", Unmapped_Key, 0x014A, 13);
+ addKey("REC_MODE", Unmapped_Key, 0x115E, 13);
+ addKey("SHOWVIEW", Unmapped_Key, 0x0145, 13);
+ addKey("DW", Unmapped_Key, 0x0144, 13); // "D/W"
+ addKey("SPEED-", Unmapped_Key, 0x1165, 13);
+ addKey("SPEED+", Unmapped_Key, 0x1166, 13);
+}
+
+
+PhilipsSat1::PhilipsSat1(
+ QObject *guiObject,
+ unsigned int index)
+ : PIRKeysetMetaData(
+ "Sat Keyset 1",
+ Philips_Make,
+ index)
+{
+ threadableProtocol = new RC5Protocol(guiObject, index);
+
+ addKey("Standby", Power_Key, 0x120C, 13);
+ addKey("External", Unmapped_Key, 0x1238, 13);
+ addKey("Menu", Menu_Key, 0x0212, 13); // "blue_on"
+ addKey("blue_off", Exit_Key, 0x0213, 13);
+ addKey("OK", Select_Key, 0x0217, 13); // "blue_ok"
+ addKey("Left", Left_Key, 0x0215, 13);
+ addKey("Right", Right_Key, 0x0216, 13);
+ addKey("Up", Up_Key, 0x0210, 13);
+ addKey("Down", Down_Key, 0x0211, 13);
+ addKey("Program+", ChannelUp_Key, 0x1220, 13);
+ addKey("Program-", ChannelDown_Key, 0x1221, 13);
+ addKey("Audio", Language_Key, 0x1223, 13); // I-II
+ addKey("1", One_Key, 0x1201, 13);
+ addKey("2", Two_Key, 0x1202, 13);
+ addKey("3", Three_Key, 0x1203, 13);
+ addKey("4", Four_Key, 0x1204, 13);
+ addKey("5", Five_Key, 0x1205, 13);
+ addKey("6", Six_Key, 0x1206, 13);
+ addKey("7", Seven_Key, 0x1207, 13);
+ addKey("8", Eight_Key, 0x1208, 13);
+ addKey("9", Nine_Key, 0x1209, 13);
+ addKey("0", Zero_Key, 0x1200, 13);
+ addKey("OSD", Info_Key, 0x120F, 13);
+ addKey("Program<", PrevChannel_Key, 0x1222, 13); // "P<P"
+ addKey("A/B", Unmapped_Key, 0x122C, 13);
+ addKey("Music_notes", Unmapped_Key, 0x0205, 13);
+ addKey("TV_ON", Unmapped_Key, 0x1001, 13);
+ addKey("TV_OFF", Unmapped_Key, 0x100C, 13);
+ addKey("Vol_+", VolumeUp_Key, 0x1010, 13);
+ addKey("Vol_-", VolumeDown_Key, 0x1011, 13);
+ addKey("Mute", Mute_Key, 0x0206, 13);
+ addKey("Screensize", AspectRatio_Key, 0x003E, 13);
+ addKey("TV/SAT", Input_Key, 0x1228, 13);
+ addKey("Play", Play_Key, 0x1175, 13);
+ addKey("Stop", Stop_Key, 0x1176, 13);
+ addKey("ffw", FastForward_Key, 0x1174, 13);
+ addKey("fbw", Rewind_Key, 0x1172, 13);
+ addKey("TV_MUTE", Unmapped_Key, 0x100D, 13);
+ addKey("TV_P-", Unmapped_Key, 0x1021, 13);
+ addKey("TV_P+", Unmapped_Key, 0x1020, 13);
+ addKey("Install", Unmapped_Key, 0x023A, 13);
+ addKey("Clock", Unmapped_Key, 0x122A, 13);
+ addKey("Clock_dotted", Unmapped_Key, 0x1226, 13);
+}
+
+
+PhilipsSat2::PhilipsSat2(
+ QObject *guiObject,
+ unsigned int index)
+ : PIRKeysetMetaData(
+ "Sat Keyset 2",
+ Philips_Make,
+ index)
+{
+ addControlledDevice(Philips_Make, "DSX-5500", Sat_Device);
+
+ threadableProtocol = new RC6Protocol(guiObject, index, 0x27);
+
+ addKey("0", Zero_Key, 0x00, 8);
+ addKey("1", One_Key, 0x01, 8);
+ addKey("2", Two_Key, 0x02, 8);
+ addKey("3", Three_Key, 0x03, 8);
+ addKey("4", Four_Key, 0x04, 8);
+ addKey("5", Five_Key, 0x05, 8);
+ addKey("6", Six_Key, 0x06, 8);
+ addKey("7", Seven_Key, 0x07, 8);
+ addKey("8", Eight_Key, 0x08, 8);
+ addKey("9", Nine_Key, 0x09, 8);
+ addKey("power", Power_Key, 0x0C, 8);
+ addKey("ch+", ChannelUp_Key, 0x20, 8);
+ addKey("ch-", ChannelDown_Key, 0x21, 8);
+ addKey("source", Input_Key, 0x43, 8);
+ addKey("menu", Menu_Key, 0x54, 8);
+ addKey("exit", Exit_Key, 0x55, 8);
+ addKey("up", Up_Key, 0x58, 8);
+ addKey("down", Down_Key, 0x59, 8);
+ addKey("left", Left_Key, 0x5A, 8);
+ addKey("right", Right_Key, 0x5B, 8);
+ addKey("OK", Select_Key, 0x5C, 8);
+ addKey("red", Red_Key, 0x6D, 8);
+ addKey("green", Green_Key, 0x6E, 8);
+ addKey("yellow", Yellow_Key, 0x6F, 8);
+ addKey("blue", Blue_Key, 0x70, 8);
+ addKey("white", Unmapped_Key, 0x71, 8);
+ addKey("back", PrevChannel_Key, 0x83, 8); // Might be wrong
+ addKey("pause", Pause_Key, 0x84, 8);
+ addKey("brackets", Unmapped_Key, 0xAF, 8);
+ addKey("info", Info_Key, 0xCB, 8);
+ addKey("guide", Guide_Key, 0xCC, 8);
+ addKey("surf", Unmapped_Key, 0xCD, 8);
+ addKey("i", Unmapped_Key, 0xFD, 8);
+}
+
+
+PhilipsSat2a::PhilipsSat2a(
+ QObject *guiObject,
+ unsigned int index)
+ : PhilipsSat2(guiObject, index)
+{
+ setKeysetName("Sat Keyset 2a");
+
+ addControlledDevice(Philips_Make, "DSX 6010/62A", Sat_Device);
+
+ addKey("ch+", ChannelUp_Key, 0x58, 8);
+ addKey("ch-", ChannelDown_Key, 0x59, 8);
+ addKey("language", Language_Key, 0x49, 8);
+ addKey("txt", Captions_Key, 0x4B, 8);
+ addKey("favorites", Favorites_Key, 0x84, 8);
+ addKey("themes", Unmapped_Key, 0xCD, 8);
+ addKey("opts", Unmapped_Key, 0xBD, 8);
+ addKey("pp", PrevChannel_Key, 0x0A, 8);
+ addKey("page+", Unmapped_Key, 0xCE, 8);
+ addKey("page-", Unmapped_Key, 0xCF, 8);
+}
+
+
+PhilipsSat3::PhilipsSat3(
+ QObject *guiObject,
+ unsigned int index)
+ : PIRKeysetMetaData(
+ "Sat Keyset 3",
+ Philips_Make,
+ index)
+{
+ addControlledDevice(Philips_Make, "DST5816/33", Sat_Device);
+
+ threadableProtocol = new RC5Protocol(guiObject, index);
+
+ addKey("INFO", Info_Key, 0x128F, 13); // "pilot"
+ addKey("EPG", Guide_Key, 0x028F, 13); // "prog"
+ addKey("UP", Up_Key, 0x0290, 13);
+ addKey("DOWN", Down_Key, 0x0291, 13);
+ addKey("LEFT", Left_Key, 0x0295, 13);
+ addKey("RIGHT", Right_Key, 0x0296, 13);
+ addKey("OK", Select_Key, 0x0297, 13);
+ addKey("1", One_Key, 0x1281, 13);
+ addKey("2", Two_Key, 0x1282, 13);
+ addKey("3", Three_Key, 0x1283, 13);
+ addKey("4", Four_Key, 0x1284, 13);
+ addKey("5", Five_Key, 0x1285, 13);
+ addKey("6", Six_Key, 0x1286, 13);
+ addKey("7", Seven_Key, 0x1287, 13);
+ addKey("8", Eight_Key, 0x1288, 13);
+ addKey("9", Nine_Key, 0x1289, 13);
+ addKey("0", Zero_Key, 0x1280, 13);
+ addKey("FRONT", Unmapped_Key, 0x02A1, 13); // "twoje"
+ addKey("BACK", Unmapped_Key, 0x0293, 13); // "av"
+ addKey("SERV", Unmapped_Key, 0x0292, 13);
+ addKey("+", Unmapped_Key, 0x12AF, 13);
+ addKey("MENU", Menu_Key, 0x02AA, 13); // "perso"
+ addKey("A", Unmapped_Key, 0x02AB, 13);
+ addKey("B", Unmapped_Key, 0x02AC, 13);
+ addKey("C", Unmapped_Key, 0x02AD, 13);
+ addKey("D", Unmapped_Key, 0x02AE, 13);
+ addKey("E", Unmapped_Key, 0x02AF, 13);
+ addKey("SOUNDOFF", Mute_Key, 0x0286, 13); // "mute"
+ addKey("TV/SAT", Input_Key, 0x12A8, 13);
+ addKey("STANDBY", Power_Key, 0x128C, 13);
+}
+
+
+PhilipsAudio1::PhilipsAudio1(
+ QObject *guiObject,
+ unsigned int index)
+ : PIRKeysetMetaData(
+ "Audio Keyset 1",
+ Philips_Make,
+ index)
+{
+ addControlledDevice(Philips_Make, "FW 530C", Audio_Device);
+ addControlledDevice(Philips_Make, "FW-P78", Audio_Device);
+ addControlledDevice(Philips_Make, "FWP73P", Audio_Device);
+ addControlledDevice(Philips_Make, "FWP78C", Audio_Device);
+ addControlledDevice(Philips_Make, "PVD0384", Audio_Device);
+ addControlledDevice(Philips_Make, "AZ2407", Audio_Device);
+ addControlledDevice(Philips_Make, "MZ7", Audio_Device);
+ addControlledDevice(Philips_Make, "AS680C", Audio_Device);
+
+ threadableProtocol = new RC5Protocol(guiObject, index);
+
+ addKey("Dynamic Bass Boost", Unmapped_Key, 0x0406, 13); // "dbb"
+ addKey("Digital Sound Control", Unmapped_Key, 0x040F, 13); // "dsc"
+ addKey("mute", Mute_Key, 0x140D, 13);
+ addKey("Vol+", VolumeUp_Key, 0x1410, 13);
+ addKey("Vol-", VolumeDown_Key, 0x1411, 13);
+ addKey("tuner_power", Power_Key, 0x144C, 13);
+ addKey("tuner_ff", ChannelUp_Key, 0x145E, 13); // "tuningR"
+ addKey("tuner_rew", ChannelDown_Key, 0x145F, 13); // "tuningL"
+ addKey("tuner_next", Next_Key, 0x1460, 13); // "presetUp"
+ addKey("tuner_previous", Previous_Key, 0x1461, 13); // "presetDown"
+ addKey("tuner_program", Program_Key, 0x047A, 13); // Create Preset
+ addKey("tuner", Input_Key, 0x147F, 13);
+ addKey("tape_power", Unmapped_Key, 0x148C, 13);
+ addKey("tape_next", Unmapped_Key, 0x14A0, 13);
+ addKey("tape_previous", Unmapped_Key, 0x14A1, 13);
+ addKey("tape_pause", Unmapped_Key, 0x14B0, 13);
+ addKey("tape_rew", Unmapped_Key, 0x14B2, 13);
+ addKey("tape_ff", Unmapped_Key, 0x14B3, 13);
+ addKey("tape_play", Unmapped_Key, 0x14B5, 13);
+ addKey("tape_stop", Unmapped_Key, 0x14B6, 13);
+ addKey("tape", Unmapped_Key, 0x14BF, 13); // "tape1-2"
+ addKey("cd_power", Unmapped_Key, 0x150C, 13);
+ addKey("cd_shuffle", Random_Key, 0x151C, 13);
+ addKey("cd_repeat", Repeat_Key, 0x151D, 13);
+ addKey("cd_next", Unmapped_Key, 0x1520, 13);
+ addKey("cd_previous", Unmapped_Key, 0x1521, 13);
+ addKey("cd_program", Unmapped_Key, 0x1524, 13);
+ addKey("cd_pause", Pause_Key, 0x1530, 13);
+ addKey("cd_rew", Rewind_Key, 0x1532, 13);
+ addKey("cd_ff", FastForward_Key, 0x1534, 13);
+ addKey("cd_play", Play_Key, 0x1535, 13);
+ addKey("cd_stop", Stop_Key, 0x1536, 13);
+ addKey("cd_1", One_Key, 0x1537, 13);
+ addKey("cd_2", Two_Key, 0x1538, 13);
+ addKey("cd_3", Three_Key, 0x1539, 13);
+ addKey("cd", Unmapped_Key, 0x153F, 13);
+ addKey("aux_power", Unmapped_Key, 0x154C, 13); // "power", "standby"
+ addKey("aux", Unmapped_Key, 0x157F, 13);
+ addKey("DPL", Unmapped_Key, 0x1425, 13);
+ addKey("SleepTimer", Sleep_Key, 0x1426, 13);
+ addKey("Rear+", Unmapped_Key, 0x0401, 13);
+ addKey("Rear-", Unmapped_Key, 0x0402, 13);
+ addKey("TestTone", Unmapped_Key, 0x0418, 13);
+ addKey("Center+", Unmapped_Key, 0x0426, 13);
+ addKey("Center-", Unmapped_Key, 0x0427, 13);
+ addKey("incredible_surround", Surround_Key, 0x0400, 13); // "inc_s"
+ addKey("osm", Unmapped_Key, 0x042C, 13);
+ addKey("vec", Unmapped_Key, 0x042B, 13);
+ addKey("TIME", Info_Key, 0x150B, 13); // "CD_DISPLAY"
+ addKey("SCAN", Unmapped_Key, 0x152B, 13);
+ addKey("OPEN/CLOSE", Eject_Key, 0x152D, 13);
+ addKey("Side", Unmapped_Key, 0x14AF, 13); // "TAPE_SIDE"
+ addKey("TIMER", Unmapped_Key, 0x142A, 13);
+ addKey("FLAT", Unmapped_Key, 0x1434, 13);
+ addKey("LOUDNESS", Unmapped_Key, 0x1432, 13);
+ addKey("BASS_UP", Unmapped_Key, 0x1416, 13);
+ addKey("BASS_DOWN", Unmapped_Key, 0x1417, 13);
+ addKey("TREBLE_UP", Unmapped_Key, 0x1418, 13);
+ addKey("TREBLE_DOWN", Unmapped_Key, 0x1419, 13);
+ addKey("BALANCE_RIGHT", Right_Key, 0x141A, 13); // "BalR"
+ addKey("BALANCE_LEFT", Left_Key, 0x141B, 13); // "BalL"
+ addKey("TUNER_DISPLAY", Unmapped_Key, 0x144F, 13);
+ addKey("CDR", Unmapped_Key, 0x16BF, 13);
+ addKey("CDR_POWER", Unmapped_Key, 0x100C, 13);
+ addKey("CDR_REPEAT", Unmapped_Key, 0x169D, 13);
+ addKey("CDR_SHUFFLE", Unmapped_Key, 0x169C, 13);
+ addKey("CDR_PROGRAM", Unmapped_Key, 0x16A4, 13);
+ addKey("CDR_DISPLAY", Unmapped_Key, 0x168B, 13);
+ addKey("CDR_PAUSE", Unmapped_Key, 0x16B0, 13);
+ addKey("CDR_PLAY", Unmapped_Key, 0x16B5, 13);
+ addKey("CDR_NEXT", Unmapped_Key, 0x16A0, 13);
+ addKey("CDR_PREV", Unmapped_Key, 0x16A1, 13);
+ addKey("CDR_STOP", Unmapped_Key, 0x16B6, 13);
+ addKey("CDR_FWD", Unmapped_Key, 0x16B4, 13);
+ addKey("CDR_BWD", Unmapped_Key, 0x16B2, 13);
+}
+
+
+PhilipsAudio1a::PhilipsAudio1a(
+ QObject *guiObject,
+ unsigned int index)
+ : PhilipsAudio1(guiObject, index)
+{
+ setKeysetName("Audio Keyset 1a");
+
+ addControlledDevice(Philips_Make, "C 380", Audio_Device);
+
+ addKey("VOL-", VolumeDown_Key, 0x1511, 13);
+ addKey("VOL+", VolumeUp_Key, 0x1510, 13);
+}
+
+
+PhilipsAudio1b::PhilipsAudio1b(
+ QObject *guiObject,
+ unsigned int index)
+ : PhilipsAudio1(guiObject, index)
+{
+ setKeysetName("Audio Keyset 1b");
+
+ addControlledDevice(Philips_Make, "FW 362", Audio_Device);
+
+ addKey("tv_power", Unmapped_Key, 0x100C, 13);
+ addKey("tv_vcr", Unmapped_Key, 0x103F, 13);
+ addKey("tape1", Unmapped_Key, 0x14AC, 13);
+ addKey("tape2", Unmapped_Key, 0x14AE, 13);
+ addKey("play", Play_Key, 0x1175, 13);
+ addKey("pause", Pause_Key, 0x1170, 13);
+ addKey("stop", Stop_Key, 0x1176, 13);
+ addKey("skip_forw", Next_Key, 0x1020, 13);
+ addKey("skip_back", Previous_Key, 0x1021, 13);
+ addKey("forw", FastForward_Key, 0x1010, 13);
+ addKey("back", Rewind_Key, 0x1011, 13);
+ addKey("disc_up", Unmapped_Key, 0x151E, 13);
+}
+
+
+PhilipsAudio2::PhilipsAudio2(
+ QObject *guiObject,
+ unsigned int index)
+ : PIRKeysetMetaData(
+ "Audio Keyset 2",
+ Philips_Make,
+ index)
+{
+ addControlledDevice(Philips_Make, "FW2104", Audio_Device);
+
+ threadableProtocol = new NECProtocol(guiObject, index);
+
+ setPreData(0x61CA, 16);
+
+ addKey("POWER", Power_Key, 0x807F, 16);
+ addKey("SLEEP", Sleep_Key, 0x30CF, 16);
+ addKey("TIMER", Unmapped_Key, 0xB04F, 16);
+ addKey("SNOOZE", Unmapped_Key, 0xD02F, 16);
+ addKey("AUX", Unmapped_Key, 0xA05F, 16);
+ addKey("1", One_Key, 0xE817, 16);
+ addKey("2", Two_Key, 0x18E7, 16);
+ addKey("3", Three_Key, 0x9867, 16);
+ addKey("4", Four_Key, 0x58A7, 16);
+ addKey("5", Five_Key, 0xD827, 16);
+ addKey("6", Six_Key, 0x38C7, 16);
+ addKey("7", Seven_Key, 0xB847, 16);
+ addKey("8", Eight_Key, 0x7887, 16);
+ addKey("9", Nine_Key, 0xF807, 16);
+ addKey("0", Zero_Key, 0x6897, 16);
+ addKey("TUN_UP", ChannelUp_Key, 0x906F, 16);
+ addKey("TUN_DOWN", ChannelDown_Key, 0x50AF, 16);
+ addKey("TAPE", Unmapped_Key, 0x40BF, 16);
+ addKey("TUNER", Unmapped_Key, 0x20DF, 16);
+ addKey("CD", Unmapped_Key, 0xC03F, 16);
+ addKey("EJECT", Eject_Key, 0x02FD, 16);
+ addKey("CANCEL", Clear_Key, 0xA857, 16);
+ addKey("MEMORY", Unmapped_Key, 0x28D7, 16);
+ addKey("CD_STOP", Stop_Key, 0x42BD, 16);
+ addKey("CD_PLAY", Play_Key, 0x827D, 16);
+ addKey("CD_REW", Rewind_Key, 0x22DD, 16);
+ addKey("CD_FW", FastForward_Key, 0xC23D, 16);
+ addKey("EDIT", Unmapped_Key, 0x12ED, 16);
+ addKey("WARP", Unmapped_Key, 0x926D, 16);
+ addKey("TIME", Unmapped_Key, 0xA25D, 16);
+ addKey("CHAIN", Unmapped_Key, 0xD22D, 16);
+ addKey("SPACE", Unmapped_Key, 0x52AD, 16);
+ addKey("INTRO", Unmapped_Key, 0xE21D, 16);
+ addKey("REP_ALL_PRG", Repeat_Key, 0x629D, 16);
+ addKey("REP_A_B", Unmapped_Key, 0xC837, 16);
+ addKey("TAPE1_REW", Unmapped_Key, 0xDA25, 16);
+ addKey("TAPE1_BACKPLAY", Unmapped_Key, 0x9A65, 16);
+ addKey("TAPE1_STOP", Unmapped_Key, 0x3AC5, 16);
+ addKey("TAPE1_PLAY", Unmapped_Key, 0x1AE5, 16);
+ addKey("TAPE1_FW", Unmapped_Key, 0x5AA5, 16);
+ addKey("TAPE2_REW", Unmapped_Key, 0x2AD5, 16);
+ addKey("TAPE2_BACKPLAY", Unmapped_Key, 0x4AB5, 16);
+ addKey("TAPE2_STOP", Unmapped_Key, 0xAA55, 16);
+ addKey("TAPE2_PLAY", Unmapped_Key, 0x8A75, 16);
+ addKey("TAPE2_FW", Unmapped_Key, 0x0AF5, 16);
+ addKey("PAUSE_RECORD", Unmapped_Key, 0x0AF5, 16);
+ addKey("MUTE", Mute_Key, 0x609F, 16);
+ addKey("VOL_UP", VolumeUp_Key, 0xE01F, 16);
+ addKey("VOL_DOWN", VolumeDown_Key, 0x10EF, 16);
+}
+
+
+// This CD control is different enough from Audio1 that I figured I should
+// give it an entirely new keyset:
+PhilipsAudio3::PhilipsAudio3(
+ QObject *guiObject,
+ unsigned int index)
+ : PIRKeysetMetaData(
+ "Audio Keyset 3",
+ Philips_Make,
+ index)
+{
+ addControlledDevice(Philips_Make, "CD723", Audio_Device);
+
+ threadableProtocol = new RC5Protocol(guiObject, index);
+
+ addKey("fade", Unmapped_Key, 0x0538, 13);
+ addKey("0", Zero_Key, 0x1500, 13);
+ addKey("1", One_Key, 0x1501, 13);
+ addKey("2", Two_Key, 0x1502, 13);
+ addKey("3", Three_Key, 0x1503, 13);
+ addKey("4", Four_Key, 0x1504, 13);
+ addKey("5", Five_Key, 0x1505, 13);
+ addKey("6", Six_Key, 0x1506, 13);
+ addKey("7", Seven_Key, 0x1507, 13);
+ addKey("8", Eight_Key, 0x1508, 13);
+ addKey("9", Nine_Key, 0x1509, 13);
+ addKey("time", Unmapped_Key, 0x150B, 13);
+ addKey("standby", Power_Key, 0x150C, 13);
+ addKey("volume+", VolumeUp_Key, 0x1510, 13);
+ addKey("volume-", VolumeDown_Key, 0x1511, 13);
+ addKey("shuffle", Random_Key, 0x151C, 13);
+ addKey("repeat", Repeat_Key, 0x151D, 13);
+ addKey("next", Next_Key, 0x1520, 13);
+ addKey("previous", Previous_Key, 0x1521, 13);
+ addKey("program", Program_Key, 0x1524, 13);
+ addKey("highlight", Unmapped_Key, 0x152B, 13); // "SCAN", "INDEX"
+ addKey("pause", Pause_Key, 0x1530, 13);
+ addKey("rewind", Rewind_Key, 0x1532, 13);
+ addKey("wind", FastForward_Key, 0x1534, 13);
+ addKey("play", Play_Key, 0x1535, 13);
+ addKey("stop", Stop_Key, 0x1536, 13);
+ addKey("OPEN/CLOSE", Eject_Key, 0x152D, 13);
+ addKey("DISC", Unmapped_Key, 0x151E, 13);
+}
+
+
+PhilipsAudio4::PhilipsAudio4(
+ QObject *guiObject,
+ unsigned int index)
+ : PIRKeysetMetaData(
+ "Audio Keyset 4",
+ Philips_Make,
+ index)
+{
+ threadableProtocol = new RC5Protocol(guiObject, index);
+
+ addKey("EJECT", Eject_Key, 0x16AD, 13);
+ addKey("INPUT", Input_Key, 0x16B8, 13);
+ addKey("DISPLAY", Info_Key, 0x168B, 13);
+ addKey("REPEAT", Repeat_Key, 0x169D, 13);
+ addKey("1", One_Key, 0x1681, 13);
+ addKey("2", Two_Key, 0x1682, 13);
+ addKey("3", Three_Key, 0x1683, 13);
+ addKey("4", Four_Key, 0x1684, 13);
+ addKey("5", Five_Key, 0x1685, 13);
+ addKey("6", Six_Key, 0x1686, 13);
+ addKey("7", Seven_Key, 0x1687, 13);
+ addKey("8", Eight_Key, 0x1688, 13);
+ addKey("9", Nine_Key, 0x1689, 13);
+ addKey("0", Zero_Key, 0x1680, 13);
+ addKey("PAUSE", Pause_Key, 0x16B0, 13);
+ addKey("STOP", Stop_Key, 0x16B6, 13);
+ addKey("PREV", Previous_Key, 0x16A1, 13);
+ addKey("PLAY", Play_Key, 0x16B5, 13);
+ addKey("NEXT", Next_Key, 0x16A0, 13);
+ addKey("REW", Rewind_Key, 0x16B2, 13);
+ addKey("FAST", Unmapped_Key, 0x16AF, 13);
+ addKey("FORW", FastForward_Key, 0x16B4, 13);
+ addKey("TRACK_INCR", Unmapped_Key, 0x06B2, 13);
+ addKey("PROGRAM", Program_Key, 0x16A4, 13);
+ addKey("FINE_TUNE", Unmapped_Key, 0x06B4, 13);
+ addKey("CD_SYNC", Unmapped_Key, 0x16A8, 13);
+ addKey("REC", Record_Key, 0x16B7, 13);
+}
--- /dev/null
+#ifndef PHILIPS_H
+#define PHILIPS_H
+
+#include "pirkeysetmetadata.h"
+
+#include <QObject>
+
+class PhilipsTV1: public PIRKeysetMetaData
+{
+public:
+ PhilipsTV1(
+ QObject *guiObject,
+ unsigned int index);
+};
+
+class PhilipsTV1a: public PhilipsTV1
+{
+public:
+ PhilipsTV1a(
+ QObject *guiObject,
+ unsigned int index);
+};
+
+class PhilipsTV1b: public PhilipsTV1
+{
+public:
+ PhilipsTV1b(
+ QObject *guiObject,
+ unsigned int index);
+};
+
+class PhilipsTV1c: public PhilipsTV1
+{
+public:
+ PhilipsTV1c(
+ QObject *guiObject,
+ unsigned int index);
+};
+
+class PhilipsTV1d: public PhilipsTV1
+{
+public:
+ PhilipsTV1d(
+ QObject *guiObject,
+ unsigned int index);
+};
+
+class PhilipsTV1e: public PhilipsTV1
+{
+public:
+ PhilipsTV1e(
+ QObject *guiObject,
+ unsigned int index);
+};
+
+class PhilipsTV1f: public PhilipsTV1
+{
+public:
+ PhilipsTV1f(
+ QObject *guiObject,
+ unsigned int index);
+};
+
+class PhilipsTV2: public PIRKeysetMetaData
+{
+public:
+ PhilipsTV2(
+ QObject *guiObject,
+ unsigned int index);
+};
+
+class PhilipsTV2a: public PhilipsTV2
+{
+public:
+ PhilipsTV2a(
+ QObject *guiObject,
+ unsigned int index);
+};
+
+class PhilipsTV2b: public PhilipsTV2
+{
+public:
+ PhilipsTV2b(
+ QObject *guiObject,
+ unsigned int index);
+};
+
+class PhilipsTV3: public PIRKeysetMetaData
+{
+public:
+ PhilipsTV3(
+ QObject *guiObject,
+ unsigned int index);
+};
+
+class PhilipsDVD1: public PIRKeysetMetaData
+{
+public:
+ PhilipsDVD1(
+ QObject *guiObject,
+ unsigned int index);
+};
+
+class PhilipsDVD1a: public PhilipsDVD1
+{
+public:
+ PhilipsDVD1a(
+ QObject *guiObject,
+ unsigned int index);
+};
+
+class PhilipsDVD1b: public PhilipsDVD1
+{
+public:
+ PhilipsDVD1b(
+ QObject *guiObject,
+ unsigned int index);
+};
+
+class PhilipsDVD1c: public PhilipsDVD1
+{
+public:
+ PhilipsDVD1c(
+ QObject *guiObject,
+ unsigned int index);
+};
+
+class PhilipsDVD1d: public PhilipsDVD1
+{
+public:
+ PhilipsDVD1d(
+ QObject *guiObject,
+ unsigned int index);
+};
+
+class PhilipsDVD2: public PIRKeysetMetaData
+{
+public:
+ PhilipsDVD2(
+ QObject *guiObject,
+ unsigned int index);
+};
+
+class PhilipsDVD3: public PIRKeysetMetaData
+{
+public:
+ PhilipsDVD3(
+ QObject *guiObject,
+ unsigned int index);
+};
+
+class PhilipsDVD4: public PIRKeysetMetaData
+{
+public:
+ PhilipsDVD4(
+ QObject *guiObject,
+ unsigned int index);
+};
+
+class PhilipsVCR1: public PIRKeysetMetaData
+{
+public:
+ PhilipsVCR1(
+ QObject *guiObject,
+ unsigned int index);
+};
+
+class PhilipsVCR1a: public PhilipsVCR1
+{
+public:
+ PhilipsVCR1a(
+ QObject *guiObject,
+ unsigned int index);
+};
+
+class PhilipsVCR1b: public PhilipsVCR1
+{
+public:
+ PhilipsVCR1b(
+ QObject *guiObject,
+ unsigned int index);
+};
+
+class PhilipsVCR1c: public PhilipsVCR1
+{
+public:
+ PhilipsVCR1c(
+ QObject *guiObject,
+ unsigned int index);
+};
+
+class PhilipsSat1: public PIRKeysetMetaData
+{
+public:
+ PhilipsSat1(
+ QObject *guiObject,
+ unsigned int index);
+};
+
+class PhilipsSat2: public PIRKeysetMetaData
+{
+public:
+ PhilipsSat2(
+ QObject *guiObject,
+ unsigned int index);
+};
+
+class PhilipsSat2a: public PhilipsSat2
+{
+public:
+ PhilipsSat2a(
+ QObject *guiObject,
+ unsigned int index);
+};
+
+class PhilipsSat3: public PIRKeysetMetaData
+{
+public:
+ PhilipsSat3(
+ QObject *guiObject,
+ unsigned int index);
+};
+
+class PhilipsAudio1: public PIRKeysetMetaData
+{
+public:
+ PhilipsAudio1(
+ QObject *guiObject,
+ unsigned int index);
+};
+
+class PhilipsAudio1a: public PhilipsAudio1
+{
+public:
+ PhilipsAudio1a(
+ QObject *guiObject,
+ unsigned int index);
+};
+
+class PhilipsAudio1b: public PhilipsAudio1
+{
+public:
+ PhilipsAudio1b(
+ QObject *guiObject,
+ unsigned int index);
+};
+
+class PhilipsAudio2: public PIRKeysetMetaData
+{
+public:
+ PhilipsAudio2(
+ QObject *guiObject,
+ unsigned int index);
+};
+
+class PhilipsAudio3: public PIRKeysetMetaData
+{
+public:
+ PhilipsAudio3(
+ QObject *guiObject,
+ unsigned int index);
+};
+
+class PhilipsAudio4: public PIRKeysetMetaData
+{
+public:
+ PhilipsAudio4(
+ QObject *guiObject,
+ unsigned int index);
+};
+
+#endif // PHILIPS_H
{
addControlledDevice(Pinnacle_Make, "800i", Computer_Device);
- RC5Protocol *rp = new RC5Protocol(
- guiObject,
- index,
- 900, 900,
- 900,
- 114000, true);
-
- threadableProtocol = rp;
-
- rp->setToggleBit(2);
-
- setPreData(0x11, 5);
-
- addKey("key_mute", Mute_Key, 0xC0, 8);
- addKey("key_menu", Menu_Key, 0xC1, 8);
- addKey("key_power", Power_Key, 0xF9, 8);
- addKey("key_volumeup", VolumeUp_Key, 0xC3, 8);
- addKey("key_volumedown", VolumeDown_Key, 0xC9, 8);
- addKey("key_channelup", ChannelUp_Key, 0xC6, 8);
- addKey("key_channeldown", ChannelDown_Key, 0xCC, 8);
- addKey("btn_1", One_Key, 0xCF, 8);
- addKey("btn_2", Two_Key, 0xD5, 8);
- addKey("btn_3", Three_Key, 0xD0, 8);
- addKey("btn_4", Four_Key, 0xD8, 8);
- addKey("btn_5", Five_Key, 0xDB, 8);
- addKey("btn_6", Six_Key, 0xDE, 8);
- addKey("btn_7", Seven_Key, 0xD1, 8);
- addKey("btn_8", Eight_Key, 0xE1, 8);
- addKey("btn_9", Nine_Key, 0xD2, 8);
- addKey("btn_0", Zero_Key, 0xE7, 8);
- addKey("key_screen", Unmapped_Key, 0xE4, 8);
- addKey("key_t", Unmapped_Key, 0xEA, 8);
- addKey("key_rewind", Rewind_Key, 0xED, 8);
- addKey("key_playpause", Play_Key, 0xF0, 8);
- addKey("key_playpause", Pause_Key, 0xF0, 8);
- addKey("key_fastforward", FastForward_Key, 0xF3, 8);
- addKey("key_record", Record_Key, 0xF6, 8);
- addKey("key_stop", Stop_Key, 0xFC, 8);
- addKey("key_question", Unmapped_Key, 0xFF, 8);
+ threadableProtocol = new RC5Protocol(guiObject, index, 0x47);
+
+ addKey("key_mute", Mute_Key, 0x00, 6);
+ addKey("key_menu", Menu_Key, 0x01, 6);
+ addKey("key_power", Power_Key, 0x39, 6);
+ addKey("key_volumeup", VolumeUp_Key, 0x03, 6);
+ addKey("key_volumedown", VolumeDown_Key, 0x09, 6);
+ addKey("key_channelup", ChannelUp_Key, 0x06, 6);
+ addKey("key_channeldown", ChannelDown_Key, 0x0C, 6);
+ addKey("btn_1", One_Key, 0x0F, 6);
+ addKey("btn_2", Two_Key, 0x15, 6);
+ addKey("btn_3", Three_Key, 0x10, 6);
+ addKey("btn_4", Four_Key, 0x18, 6);
+ addKey("btn_5", Five_Key, 0x1B, 6);
+ addKey("btn_6", Six_Key, 0x1E, 6);
+ addKey("btn_7", Seven_Key, 0x11, 6);
+ addKey("btn_8", Eight_Key, 0x21, 6);
+ addKey("btn_9", Nine_Key, 0x12, 6);
+ addKey("btn_0", Zero_Key, 0x27, 6);
+ addKey("key_screen", Unmapped_Key, 0x24, 6);
+ addKey("key_t", Unmapped_Key, 0x2A, 6);
+ addKey("key_rewind", Rewind_Key, 0x2D, 6);
+ addKey("key_playpause", Play_Key, 0x30, 6);
+ addKey("key_playpause", Pause_Key, 0x30, 6);
+ addKey("key_fastforward", FastForward_Key, 0x33, 6);
+ addKey("key_record", Record_Key, 0x36, 6);
+ addKey("key_stop", Stop_Key, 0x3C, 6);
+ addKey("key_question", Unmapped_Key, 0x3F, 6);
}
{
addControlledDevice(Pinnacle_Make, "USB Stick", Computer_Device);
- RC5Protocol *rp = new RC5Protocol(
- guiObject,
- index,
- 900, 900,
- 900,
- 114000, true);
-
- threadableProtocol = rp;
-
- rp->setToggleBit(2);
-
- setPreData(0x11, 5);
-
- addKey("play-pause", Play_Key, 0xC6, 8);
- addKey("play-pause", Pause_Key, 0xC6, 8);
- addKey("stop", Stop_Key, 0xC5, 8);
- addKey("exit", Exit_Key, 0xC3, 8);
- addKey("screen", Unmapped_Key, 0xC2, 8);
- addKey("rew", Rewind_Key, 0xC4, 8);
- addKey("ff", FastForward_Key, 0xC7, 8);
- addKey("mute", Mute_Key, 0xC0, 8);
- addKey("volup", VolumeUp_Key, 0xCB, 8);
- addKey("voldown", VolumeDown_Key, 0xCF, 8);
- addKey("ask", Unmapped_Key, 0xD4, 8);
- addKey("m", Unmapped_Key, 0xD6, 8);
- addKey("chup", ChannelUp_Key, 0xD3, 8);
- addKey("chdown", ChannelDown_Key, 0xD7, 8);
- addKey("rec", Record_Key, 0xC1, 8);
- addKey("1", One_Key, 0xC8, 8);
- addKey("2", Two_Key, 0xC9, 8);
- addKey("3", Three_Key, 0xCA, 8);
- addKey("4", Four_Key, 0xCC, 8);
- addKey("5", Five_Key, 0xCD, 8);
- addKey("6", Six_Key, 0xCE, 8);
- addKey("7", Seven_Key, 0xD0, 8);
- addKey("8", Eight_Key, 0xD1, 8);
- addKey("9", Nine_Key, 0xD2, 8);
- addKey("0", Zero_Key, 0xD5, 8);
+ threadableProtocol = new RC5Protocol(guiObject, index, 0x47);
+
+ addKey("play-pause", Play_Key, 0x06, 6);
+ addKey("play-pause", Pause_Key, 0x06, 6);
+ addKey("stop", Stop_Key, 0x05, 6);
+ addKey("exit", Exit_Key, 0x03, 6);
+ addKey("screen", Unmapped_Key, 0x02, 6);
+ addKey("rew", Rewind_Key, 0x04, 6);
+ addKey("ff", FastForward_Key, 0x07, 6);
+ addKey("mute", Mute_Key, 0x00, 6);
+ addKey("volup", VolumeUp_Key, 0x0B, 6);
+ addKey("voldown", VolumeDown_Key, 0x0F, 6);
+ addKey("ask", Unmapped_Key, 0x14, 6);
+ addKey("m", Unmapped_Key, 0x16, 6);
+ addKey("chup", ChannelUp_Key, 0x13, 6);
+ addKey("chdown", ChannelDown_Key, 0x17, 6);
+ addKey("rec", Record_Key, 0x01, 6);
+ addKey("1", One_Key, 0x08, 6);
+ addKey("2", Two_Key, 0x09, 6);
+ addKey("3", Three_Key, 0x0A, 6);
+ addKey("4", Four_Key, 0x0C, 6);
+ addKey("5", Five_Key, 0x0D, 6);
+ addKey("6", Six_Key, 0x0E, 6);
+ addKey("7", Seven_Key, 0x10, 6);
+ addKey("8", Eight_Key, 0x11, 6);
+ addKey("9", Nine_Key, 0x12, 6);
+ addKey("0", Zero_Key, 0x15, 6);
}
{
addControlledDevice(Pinnacle_Make, "110i", Computer_Device);
- RC5Protocol *rp = new RC5Protocol(
- guiObject,
- index,
- 900, 900,
- 900,
- 114000, true);
-
- threadableProtocol = rp;
-
- rp->setToggleBit(2);
-
- setPreData(0x11, 5);
-
- addKey("MUTE", Mute_Key, 0xC1, 8);
- addKey("POWER", Power_Key, 0xF9, 8);
- addKey("CTVERECSETREMIRADKY", Unmapped_Key, 0xE5, 8);
- addKey("TV", Unmapped_Key, 0xE6, 8);
- addKey("EPG", Guide_Key, 0xE7, 8);
- addKey("A_RED", Red_Key, 0xC3, 8);
- addKey("B_GREEN", Green_Key, 0xC4, 8);
- addKey("C_YELLOW", Yellow_Key, 0xC5, 8);
- addKey("OTAZNIK_BLUE", Blue_Key, 0xC6, 8);
- addKey("VOL_PLUS", VolumeUp_Key, 0xE8, 8);
- addKey("VOL_MINUS", VolumeDown_Key, 0xE9, 8);
- addKey("PINNACLE", Unmapped_Key, 0xF3, 8);
- addKey("CH_PLUS", ChannelUp_Key, 0xC8, 8);
- addKey("CH_MINUS", ChannelDown_Key, 0xC9, 8);
- addKey("UP", Up_Key, 0xCA, 8);
- addKey("LEFT", Left_Key, 0xCC, 8);
- addKey("OK", Select_Key, 0xF6, 8);
- addKey("RIGHT", Right_Key, 0xCD, 8);
- addKey("DOWN", Down_Key, 0xCB, 8);
- addKey("BACK", Exit_Key, 0xF0, 8);
- addKey("JUMP", PrevChannel_Key, 0xEA, 8);
- addKey("CTVERECVECTVERCI", Unmapped_Key, 0xC2, 8);
- addKey("PAUSE", Pause_Key, 0xE1, 8);
- addKey("RED_IN_THE_MIDDLE", Record_Key, 0xFF, 8);
- addKey("PREV", Rewind_Key, 0xE0, 8);
- addKey("PLAY", Play_Key, 0xEB, 8);
- addKey("FFORWARD", FastForward_Key, 0xE2, 8);
- addKey("BEGINNING", Previous_Key, 0xE3, 8);
- addKey("STOP", Stop_Key, 0xFC, 8);
- addKey("END", Next_Key, 0xE4, 8);
- addKey("1", One_Key, 0xCE, 8);
- addKey("2", Two_Key, 0xCF, 8);
- addKey("3", Three_Key, 0xD1, 8);
- addKey("4", Four_Key, 0xD2, 8);
- addKey("5", Five_Key, 0xD4, 8);
- addKey("6", Six_Key, 0xD5, 8);
- addKey("7", Seven_Key, 0xD7, 8);
- addKey("8", Eight_Key, 0xD8, 8);
- addKey("9", Nine_Key, 0xDA, 8);
- addKey("0", Zero_Key, 0xDD, 8);
- addKey("CAPS_NUM", Unmapped_Key, 0xDB, 8);
- addKey("DEL", Unmapped_Key, 0xDE, 8);
+ threadableProtocol = new RC5Protocol(guiObject, index, 0x47);
+
+ addKey("MUTE", Mute_Key, 0x01, 6);
+ addKey("POWER", Power_Key, 0x39, 6);
+ addKey("CTVERECSETREMIRADKY", Unmapped_Key, 0x25, 6);
+ addKey("TV", Unmapped_Key, 0x26, 6);
+ addKey("EPG", Guide_Key, 0x27, 6);
+ addKey("A_RED", Red_Key, 0x03, 6);
+ addKey("B_GREEN", Green_Key, 0x04, 6);
+ addKey("C_YELLOW", Yellow_Key, 0x05, 6);
+ addKey("OTAZNIK_BLUE", Blue_Key, 0x06, 6);
+ addKey("VOL_PLUS", VolumeUp_Key, 0x28, 6);
+ addKey("VOL_MINUS", VolumeDown_Key, 0x29, 6);
+ addKey("PINNACLE", Unmapped_Key, 0x33, 6);
+ addKey("CH_PLUS", ChannelUp_Key, 0x08, 6);
+ addKey("CH_MINUS", ChannelDown_Key, 0x09, 6);
+ addKey("UP", Up_Key, 0x0A, 6);
+ addKey("LEFT", Left_Key, 0x0C, 6);
+ addKey("OK", Select_Key, 0x36, 6);
+ addKey("RIGHT", Right_Key, 0x0D, 6);
+ addKey("DOWN", Down_Key, 0x0B, 6);
+ addKey("BACK", Exit_Key, 0x30, 6);
+ addKey("JUMP", PrevChannel_Key, 0x2A, 6);
+ addKey("CTVERECVECTVERCI", Unmapped_Key, 0x02, 6);
+ addKey("PAUSE", Pause_Key, 0x21, 6);
+ addKey("RED_IN_THE_MIDDLE", Record_Key, 0x3F, 6);
+ addKey("PREV", Rewind_Key, 0x20, 6);
+ addKey("PLAY", Play_Key, 0x2B, 6);
+ addKey("FFORWARD", FastForward_Key, 0x22, 6);
+ addKey("BEGINNING", Previous_Key, 0x23, 6);
+ addKey("STOP", Stop_Key, 0x3C, 6);
+ addKey("END", Next_Key, 0x24, 6);
+ addKey("1", One_Key, 0x0E, 6);
+ addKey("2", Two_Key, 0x0F, 6);
+ addKey("3", Three_Key, 0x11, 6);
+ addKey("4", Four_Key, 0x12, 6);
+ addKey("5", Five_Key, 0x14, 6);
+ addKey("6", Six_Key, 0x15, 6);
+ addKey("7", Seven_Key, 0x17, 6);
+ addKey("8", Eight_Key, 0x18, 6);
+ addKey("9", Nine_Key, 0x1A, 6);
+ addKey("0", Zero_Key, 0x1D, 6);
+ addKey("CAPS_NUM", Unmapped_Key, 0x1B, 6);
+ addKey("DEL", Unmapped_Key, 0x1E, 6);
}
Samsung_Make,
index)
{
- RC5Protocol *rp = new RC5Protocol(
- guiObject,
- index,
- 900, 850,
- 900,
- 110000, true);
-
- threadableProtocol = rp;
-
- rp->setToggleBit(2);
+ threadableProtocol = new RC5Protocol(guiObject, index);
addKey("1", One_Key, 0x1001, 13);
addKey("2", Two_Key, 0x1002, 13);
#include "sharp.h"
#include "necprotocol.h"
-#include "pirmakenames.h"
+//#include "pirmakenames.h"
SharpTV1::SharpTV1(
QObject *guiObject,
--- /dev/null
+#include "tivo.h"
+#include "necprotocol.h"
+
+Tivo1::Tivo1(
+ QObject *guiObject,
+ unsigned int index)
+ : PIRKeysetMetaData(
+ "Tivo Keyset 1",
+ Tivo_Make,
+ index)
+{
+ threadableProtocol = new NECProtocol(guiObject, index);
+
+ setPreData(0xA10C, 16);
+
+// setCarrierFrequency(40000);
+
+ addKey("TIVO", Power_Key, 0x000F, 16);
+ addKey("LIVETV", Unmapped_Key, 0x8807, 16);
+ addKey("UP", Up_Key, 0x2807, 16);
+ addKey("DOWN", Down_Key, 0x6807, 16);
+ addKey("RIGHT", Right_Key, 0xA807, 16);
+ addKey("LEFT", Left_Key, 0xE807, 16);
+ addKey("THUMBSDOWN", Unmapped_Key, 0x1807, 16);
+ addKey("THUMBSUP", Unmapped_Key, 0x5807, 16);
+ addKey("SELECT", Select_Key, 0x9807, 16);
+ addKey("RECORD", Record_Key, 0x040B, 16);
+ addKey("PLAY", Play_Key, 0x840B, 16);
+ addKey("CH+", ChannelUp_Key, 0x7807, 16);
+ addKey("CH-", ChannelDown_Key, 0xF807, 16);
+ addKey("REV", Rewind_Key, 0x440B, 16);
+ addKey("FWD", FastForward_Key, 0x240B, 16);
+ addKey("PAUSE", Pause_Key, 0xC40B, 16);
+ addKey("SLOW", Unmapped_Key, 0xA40B, 16);
+ addKey("REPLAY", Replay_Key, 0x640B, 16);
+ addKey("JUMPTOEND", Advance_Key, 0xE40B, 16);
+ addKey("1", One_Key, 0x140B, 16);
+ addKey("2", Two_Key, 0x940B, 16);
+ addKey("3", Three_Key, 0x540B, 16);
+ addKey("4", Four_Key, 0xD40B, 16);
+ addKey("5", Five_Key, 0x340B, 16);
+ addKey("6", Six_Key, 0xB40B, 16);
+ addKey("7", Seven_Key, 0x740B, 16);
+ addKey("8", Eight_Key, 0xF40B, 16);
+ addKey("9", Nine_Key, 0x0C03, 16);
+ addKey("0", Zero_Key, 0x8C03, 16);
+ addKey("CLEAR", Clear_Key, 0x4C03, 16);
+ addKey("ENTER/LAST", Enter_Key, 0xCC03, 16);
+ addKey("ENTER/LAST", PrevChannel_Key, 0xCC03, 16);
+ addKey("WINDOW", PIP_Key, 0x220D, 16);
+ addKey("INFO", Info_Key, 0xC807, 16);
+ addKey("GUIDE", Guide_Key, 0x6C03, 16);
+ addKey("MUTE", Mute_Key, 0xD807, 16);
+}
+
+
+Tivo1a::Tivo1a(
+ QObject *guiObject,
+ unsigned int index)
+ : Tivo1(guiObject, index)
+{
+ setKeysetName("Tivo Keyset 1a");
+
+ addKey("TIVO", Power_Key, 0xE00F, 16);
+ addKey("TVPOWER", Unmapped_Key, 0x0807, 16);
+ addKey("TVINPUT", Input_Key, 0x2C03, 16);
+ addKey("VOL+", VolumeUp_Key, 0x3807, 16);
+ addKey("VOL-", VolumeDown_Key, 0xB807, 16);
+}
+
+
+Tivo1b::Tivo1b(
+ QObject *guiObject,
+ unsigned int index)
+ : Tivo1(guiObject, index)
+{
+ setKeysetName("Tivo Keyset 1b");
+
+ addKey("tivo", Power_Key, 0xF00F, 16);
+ addKey("tvpower", Unmapped_Key, 0x48B7, 16);
+ addKey("vol+", VolumeUp_Key, 0x6897, 16);
+ addKey("vol-", VolumeDown_Key, 0xE817, 16);
+// addKey("mute", Mute_Key, 0xA857, 16); // Why two mute keys?
+ addKey("exit", Exit_Key, 0xA20D, 16);
+ addKey("list", Unmapped_Key, 0x620D, 16);
+}
+
+
+Tivo1c::Tivo1c(
+ QObject *guiObject,
+ unsigned int index)
+ : Tivo1(guiObject, index)
+{
+ setKeysetName("Tivo Keyset 1c");
+
+ addKey("TIVO", Power_Key, 0x500F, 16);
+ addKey("TV_POWER", Unmapped_Key, 0x0807, 16);
+ addKey("TV_INPUT", Input_Key, 0x2C03, 16);
+ addKey("VOL_UP", VolumeUp_Key, 0x3807, 16);
+ addKey("VOL_DOWN", VolumeDown_Key, 0xB807, 16);
+}
+
+
+Tivo1d::Tivo1d(
+ QObject *guiObject,
+ unsigned int index)
+ : Tivo1(guiObject, index)
+{
+ setKeysetName("Tivo Keyset 1d");
+
+ addKey("TIVO", Power_Key, 0x400F, 16);
+ addKey("TVPWR", Unmapped_Key, 0x0807, 16);
+ addKey("GUIDE", Guide_Key, 0x8807, 16);
+ addKey("MENU", Menu_Key, 0x4807, 16);
+ addKey("VOL+", VolumeUp_Key, 0x3807, 16);
+ addKey("VOL-", VolumeDown_Key, 0xB807, 16);
+}
--- /dev/null
+#ifndef TIVO_H
+#define TIVO_H
+
+#include "pirkeysetmetadata.h"
+#include <QObject>
+
+class Tivo1: public PIRKeysetMetaData
+{
+public:
+ Tivo1(
+ QObject *guiObject,
+ unsigned int index);
+};
+
+class Tivo1a: public Tivo1
+{
+public:
+ Tivo1a(
+ QObject *guiObject,
+ unsigned int index);
+};
+
+class Tivo1b: public Tivo1
+{
+public:
+ Tivo1b(
+ QObject *guiObject,
+ unsigned int index);
+};
+
+class Tivo1c: public Tivo1
+{
+public:
+ Tivo1c(
+ QObject *guiObject,
+ unsigned int index);
+};
+
+class Tivo1d: public Tivo1
+{
+public:
+ Tivo1d(
+ QObject *guiObject,
+ unsigned int index);
+};
+
+#endif // TIVO_H
#include "toshiba.h"
#include "necprotocol.h"
-#include "pirmakenames.h"
+//#include "pirmakenames.h"
ToshibaTV1::ToshibaTV1(
QObject *guiObject,
Toshiba_Make,
index)
{
+ addControlledDevice(Toshiba_Make, "21S03D", TV_Device);
+
threadableProtocol = new NECProtocol(guiObject, index);
setPreData(0x02FD, 16);
addKey("9", Nine_Key, 0x906F, 16);
addKey("0", Zero_Key, 0x00FF, 16);
addKey("TV", Unmapped_Key, 0x4EB1, 16);
- addKey("SCART", Unmapped_Key, 0x28D7, 16); // "AV", "inputs", "source"
+ addKey("SCART", Input_Key, 0x28D7, 16); // "AV", "inputs", "source"
addKey("CALL", Unmapped_Key, 0x6897, 16);
addKey("-/--", DoubleDigit_Key, 0xD02F, 16);
addKey("DOULBY", Unmapped_Key, 0x5AA5, 16);
addKey("exit", Exit_Key, 0x1AE5, 16);
addKey("100", PlusOneHundred_Key, 0x50AF, 16);
addKey("recall", PrevChannel_Key, 0x38C7, 16);
- addKey("tv/video", Input_Key, 0xF00F, 16); // "input"
+ addKey("tv/video", Unmapped_Key, 0xF00F, 16); // "input"
addKey("fav+", Unmapped_Key, 0x9867, 16);
addKey("reset", Reset_Key, 0x30CF, 16);
addKey("cap/text", Captions_Key, 0xEA15, 16); // Image
addKey("SEARCH", Unmapped_Key, 0xF10E, 16);
// teletext stuff:
-// addKey("TXT/MIX", Unmapped_Key, 0xE817, 16); // "ent", "ch_rtn"
-// addKey("textindex", Unmapped_Key, 0xD42B, 16);
-// addKey("textpages", Unmapped_Key, 0x34CB, 16);
-// addKey("textanswer", Unmapped_Key, 0x2AD5, 16);
-// addKey("texthold", Unmapped_Key, 0xCA35, 16);
-// addKey("textzoom", Unmapped_Key, 0xB04F, 16);
-// addKey("texttime", Unmapped_Key, 0xA857, 16);
+ addKey("TXT/MIX", Unmapped_Key, 0xE817, 16); // "ent", "ch_rtn"
+ addKey("textindex", Unmapped_Key, 0xD42B, 16);
+ addKey("textpages", Unmapped_Key, 0x34CB, 16);
+ addKey("textanswer", Unmapped_Key, 0x2AD5, 16);
+ addKey("texthold", Unmapped_Key, 0xCA35, 16);
+ addKey("textzoom", Unmapped_Key, 0xB04F, 16);
}
{
setKeysetName("TV Keyset 1a");
- addKey("enter", Select_Key, 0x01FE, 16);
+ addControlledDevice(Toshiba_Make, "27A51", TV_Device);
+
+ addKey("menu/enter", Menu_Key, 0x01FE, 16);
+ addKey("menu/enter", Select_Key, 0x01FE, 16);
}
addKey("tv/fav/radio", Favorites_Key, 0xE21D, 16); // might be wrong
addKey("info", Info_Key, 0x6897, 16); // might be wrong
addKey("subtitle", Captions_Key, 0x30CF, 16);
- addKey("stillpicture", Unmapped_Key, 0x44BB, 16);
+ addKey("stillpicture", Pause_Key, 0x44BB, 16);
addKey("24-", Unmapped_Key, 0x2AD5, 16);
addKey("page-", Unmapped_Key, 0xCA35, 16);
addKey("page+", Unmapped_Key, 0xB04F, 16);
}
+ToshibaTV1f::ToshibaTV1f(
+ QObject *guiObject,
+ unsigned int index)
+ : ToshibaTV1(guiObject, index)
+{
+ setKeysetName("TV Keyset 1f");
+
+ addControlledDevice(Toshiba_Make, "Regza AV50*", TV_Device);
+
+ addKey("back", PrevChannel_Key, 0x4AB5, 16);
+ addKey("exit", Exit_Key, 0xC23D, 16);
+ addKey("info", Info_Key, 0x6897, 16);
+ addKey("stillpicture", Pause_Key, 0x44BB, 16);
+}
+
+
ToshibaVCR1::ToshibaVCR1(
QObject *guiObject,
unsigned int index)
unsigned int index);
};
+class ToshibaTV1f: public ToshibaTV1
+{
+public:
+ ToshibaTV1f(
+ QObject *guiObject,
+ unsigned int index);
+};
+
class ToshibaVCR1: public PIRKeysetMetaData
{
public:
void MainWindow::on_addKeysetButton_clicked()
{
- // Is the current keylist already a favorite?
+ // Is the current keyset already a favorite?
int count = ui->favoriteKeysetsWidget->count();
int index = 0;
PIRKeysetWidgetItem *kwi = NULL;
++index;
}
- // Ok, add the current keylist to the favorites:
+ // Ok, add the current keyset to the favorites:
PIRMakeName make = myKeysets->getMake(currentKeyset);
QString name = makeManager.getMakeString(make);
ui->favoriteKeysetsWidget->addItem(
new PIRKeysetWidgetItem(name, currentKeyset, make));
- // And, add the keylist id to the persistent list:
+ // And, add the keyset id to the persistent list:
QSettings settings("pietrzak.org", "Pierogi");
int favSettingsSize = settings.beginReadArray("favorites");
settings.beginWriteArray("favorites");
settings.setArrayIndex(favSettingsSize);
- settings.setValue("keylistID", currentKeyset);
+ settings.setValue("keysetID", currentKeyset);
settings.endArray();
}
ui->favoriteKeysetsWidget->item(index));
settings.setArrayIndex(index);
- settings.setValue("keylistID", kwi->getID());
+ settings.setValue("keysetID", kwi->getID());
++index;
}
settings.endArray();
while (index < size)
{
settings.setArrayIndex(index);
- id = settings.value("keylistID").toInt();
- make = myKeysets->getMake(id);
- name = makeManager.getMakeString(make);
- name.append(" ");
- name.append(myKeysets->getDisplayName(id));
+ id = settings.value("keysetID").toInt();
+
+ // Sanity check: Does this keyset even exist?
+ if (myKeysets->keysetExists(id))
+ {
+ // Keyset does exist, so continue:
+ make = myKeysets->getMake(id);
+ name = makeManager.getMakeString(make);
+ name.append(" ");
+ name.append(myKeysets->getDisplayName(id));
// kwi = new PIRKeysetWidgetItem(name, id, make);
// myKeysets->populateDeviceTypes(kwi, id);
- ui->favoriteKeysetsWidget->addItem(new PIRKeysetWidgetItem(name, id, make));
+ ui->favoriteKeysetsWidget->addItem(new PIRKeysetWidgetItem(name, id, make));
+ }
+
++index;
}
keysets/yamaha.cpp \
keysets/hitachi.cpp \
keysets/denon.cpp \
- keysets/pinnacle.cpp
+ keysets/pinnacle.cpp \
+ keysets/magnavox.cpp \
+ rc6protocol.cpp \
+ keysets/philips.cpp \
+ keysets/tivo.cpp
HEADERS += mainwindow.h \
pirkeynames.h \
necprotocol.h \
keysets/yamaha.h \
keysets/hitachi.h \
keysets/denon.h \
- keysets/pinnacle.h
+ keysets/pinnacle.h \
+ keysets/magnavox.h \
+ rc6protocol.h \
+ keysets/philips.h \
+ keysets/tivo.h
FORMS += mainwindow.ui \
pirdocumentationform.ui \
piraboutform.ui \
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE QtCreatorProject>
-<!-- Written by Qt Creator 2.4.0, 2012-01-23T09:52:06. -->
+<!-- Written by Qt Creator 2.4.0, 2012-01-25T13:47:37. -->
<qtcreator>
<data>
<variable>ProjectExplorer.Project.ActiveTarget</variable>
<value type="QString" key="ProjectExplorer.ProcessStep.Arguments">dpkg-buildpackage -sa -S -uc -us</value>
<value type="QString" key="ProjectExplorer.ProcessStep.Command">/Users/john/QtSDK/Maemo/4.6.2/bin/mad</value>
<value type="bool" key="ProjectExplorer.ProcessStep.Enabled">false</value>
- <value type="QString" key="ProjectExplorer.ProcessStep.WorkingDirectory">/Users/john/Develop/n900/pierogi-0.1.5</value>
+ <value type="QString" key="ProjectExplorer.ProcessStep.WorkingDirectory">/Users/john/Develop/n900/pierogi-0.1.6</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">Custom Process Step</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">ProjectExplorer.ProcessStep</value>
<value type="QString">/Users/john/Develop/n900/pierogi-build-maemo-Qt_for_Fremantle_PR1_3_Devices__Qt_SDK__Release/pierogi_0_0_1_armel.deb</value>
<value type="QString">/Users/john/Develop/n900/pierogi-build-maemo-Qt_for_Fremantle_PR1_3_Devices__Qt_SDK__Release/pierogi_0_1_0_armel.deb</value>
<value type="QString">/Users/john/Develop/n900/pierogi-build-maemo-Qt_for_Fremantle_PR1_3_Devices__Qt_SDK__Release/pierogi_0_0_1_armel.deb</value>
+ <value type="QString">/Users/john/Develop/n900/pierogi-build-maemo-Qt_for_Fremantle_PR1_3_Devices__Qt_SDK__Release/pierogi_0_1_6_armel.deb</value>
</valuelist>
<valuelist type="QVariantList" key="Qt4ProjectManager.MaemoRunConfiguration.LastDeployedHosts">
<value type="QString">192.168.0.15</value>
<value type="QString">192.168.0.15</value>
<value type="QString">192.168.0.15</value>
<value type="QString">localhost</value>
+ <value type="QString">192.168.0.15</value>
</valuelist>
<valuelist type="QVariantList" key="Qt4ProjectManager.MaemoRunConfiguration.LastDeployedRemotePaths">
<value type="QString"></value>
<value type="QString"></value>
<value type="QString"></value>
<value type="QString"></value>
+ <value type="QString"></value>
</valuelist>
<valuelist type="QVariantList" key="Qt4ProjectManager.MaemoRunConfiguration.LastDeployedTimes">
<value type="QDateTime">2012-01-23T09:47:37</value>
<value type="QDateTime">2012-01-14T13:11:32</value>
<value type="QDateTime">2012-01-17T00:03:13</value>
<value type="QDateTime">2012-01-01T15:35:35</value>
+ <value type="QDateTime">2012-01-25T13:42:55</value>
</valuelist>
</valuemap>
<value type="int" key="ProjectExplorer.BuildStepList.StepsCount">3</value>
{
devices[Any_Device] = "Any";
devices[TV_Device] = "TV";
+ devices[Sat_Device] = "Sat Receiver";
devices[VCR_Device] = "VCR";
devices[DVD_Device] = "DVD";
devices[Audio_Device] = "Audio";
enum PIRDeviceTypeName {
Any_Device,
TV_Device,
+ Sat_Device,
VCR_Device,
DVD_Device,
Audio_Device,
PIPSource_Key,
PIPChannelUp_Key,
PIPChannelDown_Key,
+ PIPPause_Key,
// DVD / Blue-ray / etc. keys:
DiscTitle_Key,
DiscMenu_Key,
#include "keysets/hitachi.h"
#include "keysets/jvc.h"
#include "keysets/lg.h"
+#include "keysets/magnavox.h"
#include "keysets/mitsubishi.h"
#include "keysets/nokia.h"
#include "keysets/panasonic.h"
+#include "keysets/philips.h"
#include "keysets/pinnacle.h"
#include "keysets/raite.h"
#include "keysets/rca.h"
#include "keysets/sanyo.h"
#include "keysets/sharp.h"
#include "keysets/sony.h"
+#include "keysets/tivo.h"
#include "keysets/toshiba.h"
#include "keysets/westinghouse.h"
#include "keysets/yamaha.h"
populateKeyset(new LGVCR1a(guiObject, counter++));
populateKeyset(new LGVCR1b(guiObject, counter++));
+ populateKeyset(new MagnavoxDVD1(guiObject, counter++));
+ populateKeyset(new MagnavoxVCR1(guiObject, counter++));
+ populateKeyset(new MagnavoxConverterBox1(guiObject, counter++));
+ populateKeyset(new MagnavoxTV1(guiObject, counter++));
+
populateKeyset(new MitsubishiTV1(guiObject, counter++));
populateKeyset(new MitsubishiTV1a(guiObject, counter++));
populateKeyset(new MitsubishiVCR1(guiObject, counter++));
populateKeyset(new PanasonicAudio1(guiObject, counter++));
populateKeyset(new PanasonicAudio1a(guiObject, counter++));
+ populateKeyset(new PhilipsTV1(guiObject, counter++));
+ populateKeyset(new PhilipsTV1a(guiObject, counter++));
+ populateKeyset(new PhilipsTV1b(guiObject, counter++));
+ populateKeyset(new PhilipsTV1c(guiObject, counter++));
+ populateKeyset(new PhilipsTV1d(guiObject, counter++));
+ populateKeyset(new PhilipsTV1e(guiObject, counter++));
+ populateKeyset(new PhilipsTV1f(guiObject, counter++));
+ populateKeyset(new PhilipsTV2(guiObject, counter++));
+ populateKeyset(new PhilipsTV2a(guiObject, counter++));
+ populateKeyset(new PhilipsTV2b(guiObject, counter++));
+ populateKeyset(new PhilipsTV3(guiObject, counter++));
+ populateKeyset(new PhilipsDVD1(guiObject, counter++));
+ populateKeyset(new PhilipsDVD1a(guiObject, counter++));
+ populateKeyset(new PhilipsDVD1b(guiObject, counter++));
+ populateKeyset(new PhilipsDVD1c(guiObject, counter++));
+ populateKeyset(new PhilipsDVD1d(guiObject, counter++));
+ populateKeyset(new PhilipsDVD2(guiObject, counter++));
+ populateKeyset(new PhilipsDVD3(guiObject, counter++));
+ populateKeyset(new PhilipsDVD4(guiObject, counter++));
+ populateKeyset(new PhilipsVCR1(guiObject, counter++));
+ populateKeyset(new PhilipsVCR1a(guiObject, counter++));
+ populateKeyset(new PhilipsVCR1b(guiObject, counter++));
+ populateKeyset(new PhilipsVCR1c(guiObject, counter++));
+ populateKeyset(new PhilipsSat1(guiObject, counter++));
+ populateKeyset(new PhilipsSat2(guiObject, counter++));
+ populateKeyset(new PhilipsSat2a(guiObject, counter++));
+ populateKeyset(new PhilipsSat3(guiObject, counter++));
+ populateKeyset(new PhilipsAudio1(guiObject, counter++));
+ populateKeyset(new PhilipsAudio1a(guiObject, counter++));
+ populateKeyset(new PhilipsAudio1b(guiObject, counter++));
+ populateKeyset(new PhilipsAudio2(guiObject, counter++));
+ populateKeyset(new PhilipsAudio3(guiObject, counter++));
+ populateKeyset(new PhilipsAudio4(guiObject, counter++));
+
populateKeyset(new PinnaclePCTV1(guiObject, counter++));
populateKeyset(new PinnaclePCTV2(guiObject, counter++));
populateKeyset(new PinnaclePCTV3(guiObject, counter++));
populateKeyset(new SonyVCR1a(guiObject, counter++));
populateKeyset(new SonyReceiver1(guiObject, counter++));
+ populateKeyset(new Tivo1(guiObject, counter++));
+ populateKeyset(new Tivo1a(guiObject, counter++));
+ populateKeyset(new Tivo1b(guiObject, counter++));
+ populateKeyset(new Tivo1c(guiObject, counter++));
+ populateKeyset(new Tivo1d(guiObject, counter++));
+
populateKeyset(new ToshibaTV1(guiObject, counter++));
populateKeyset(new ToshibaTV1a(guiObject, counter++));
populateKeyset(new ToshibaTV1b(guiObject, counter++));
populateKeyset(new ToshibaTV1c(guiObject, counter++));
populateKeyset(new ToshibaTV1d(guiObject, counter++));
populateKeyset(new ToshibaTV1e(guiObject, counter++));
+ populateKeyset(new ToshibaTV1f(guiObject, counter++));
populateKeyset(new ToshibaVCR1(guiObject, counter++));
populateKeyset(new ToshibaVCR1a(guiObject, counter++));
populateKeyset(new ToshibaDisc1(guiObject, counter++));
}
+bool PIRKeysetManager::keysetExists(
+ unsigned int keysetID)
+{
+ PIRKeysetCollection::const_iterator i = keysetsInfo.find(keysetID);
+
+ return (i != keysetsInfo.end());
+}
+
+
bool PIRKeysetManager::hasKey(
- int keysetID,
+ unsigned int keysetID,
PIRKeyName name)
{
PIRKeysetMetaData *meta = keysetsInfo[keysetID];
PIRMakeName PIRKeysetManager::getMake(
- int keysetID)
+ unsigned int keysetID)
{
PIRKeysetMetaData *meta = keysetsInfo[keysetID];
QString PIRKeysetManager::getDisplayName(
- int keysetID)
+ unsigned int keysetID)
{
PIRKeysetMetaData *meta = keysetsInfo[keysetID];
void PIRKeysetManager::populateDeviceTypes(
PIRKeysetWidgetItem *kwi,
- int keysetID)
+ unsigned int keysetID)
{
// Pass the buck: (Need to check for bad keysetID here?)
keysetsInfo[keysetID]->populateDeviceTypes(kwi);
void populateGuiWidget(
PIRSelectKeysetForm *widget);
+ bool keysetExists(
+ unsigned int keysetID);
+
bool hasKey(
- int keysetID,
+ unsigned int keysetID,
PIRKeyName name);
PIRMakeName getMake(
- int keysetID);
+ unsigned int keysetID);
QString getDisplayName(
- int keysetID);
+ unsigned int keysetID);
void populateDeviceTypes(
PIRKeysetWidgetItem *kwi,
- int keysetID);
+ unsigned int keysetID);
private:
// This needs to be improved:
makes[Hitachi_Make] = "Hitachi";
makes[JVC_Make] = "JVC";
makes[LG_Make] = "LG";
+ makes[Magnavox_Make] = "Magnavox";
makes[Mitsubishi_Make] = "Mitsubishi";
makes[Nokia_Make] = "Nokia";
makes[Panasonic_Make] = "Panasonic";
makes[Sanyo_Make] = "Sanyo";
makes[Sharp_Make] = "Sharp";
makes[Sony_Make] = "Sony";
+ makes[Tivo_Make] = "TiVo";
makes[Toshiba_Make] = "Toshiba";
makes[Westinghouse_Make] = "Westinghouse";
makes[Yamaha_Make] = "Yamaha";
Hitachi_Make,
JVC_Make,
LG_Make,
+ Magnavox_Make,
Mitsubishi_Make,
Nokia_Make,
Panasonic_Make,
Sanyo_Make,
Sharp_Make,
Sony_Make,
+ Tivo_Make,
Toshiba_Make,
Westinghouse_Make,
Yamaha_Make,
+pierogi (0.1.7) unstable; urgency=low
+ * Finally put together RC6 codepath, and created a Philips keyset. Still not tested, though! Also, some general cleanup work on protocol classes.
+
+ -- John Pietrzak <jpietrzak8@gmail.com> Wed, 25 Jan 2012 13:46:21 -0500
+
pierogi (0.1.6) unstable; urgency=low
* Still having installation problems! For now, I'm just giving up on the postrm script; for now, users will have to live with the extra file when uninstalling.
RC5Protocol::RC5Protocol(
QObject *guiObject,
unsigned int index,
- unsigned int bPulse,
- unsigned int bSpace,
- unsigned int lPulse,
- unsigned int gSpace,
- bool iclflag)
- : PIRProtocol(guiObject, index, gSpace, iclflag),
- biphasePulse(bPulse),
- biphaseSpace(bSpace),
- leadPulse(lPulse),
+ unsigned int sevenBitControl)
+ : PIRProtocol(guiObject, index, 114000, true),
+ biphaseUnit(889),
buffer(0),
keypressCount(0)
{
+ setCarrierFrequency(36000);
+ setPreData(sevenBitControl, 7);
}
-void RC5Protocol::setHeaderPair(
- unsigned int pulse,
- unsigned int space)
-{
- headerPulse = pulse;
- headerSpace = space;
- hasHeaderPair = true;
-}
-
-
-void RC5Protocol::setToggleBit(
- unsigned int bit)
+RC5Protocol::RC5Protocol(
+ QObject *guiObject,
+ unsigned int index)
+ : PIRProtocol(guiObject, index, 114000, true),
+ biphaseUnit(889),
+ buffer(0),
+ keypressCount(0)
{
- toggleBit = bit;
+ setCarrierFrequency(36000);
}
{
int commandDuration = 0;
- // Now, throw together an RC5 protocol command string:
- buffer = 0;
- bufferContainsPulse = false;
- bufferContainsSpace = false;
-
- // Start off the first pulse with the lead, if any:
- if (leadPulse)
+ // Now, throw together an RC5 protocol command string.
+
+ if (!preData.empty())
{
- buffer = leadPulse;
- bufferContainsPulse = true;
- }
+ // For standard RC5, the "pre-data" contains the control portion,
+ // and the key contains only the 6-bit command portion.
- // Encode the bits:
- commandDuration += pushBits((*i).second, rx51device);
+ // First, construct the control portion:
+ commandDuration += pushControlBits(rx51device);
+
+ // Next, the key-command portion:
+ commandDuration += pushKeyCommandBits((*i).second, rx51device);
+ }
+ else
+ {
+ // For non-standard RC5, the entire 13 bits are stuffed into the
+ // key portion, as all of them can vary:
+ commandDuration += pushNonStandardRC5((*i).second, rx51device);
+ }
// Clear out the buffer, if necessary:
if (buffer)
{
rx51device.addSingle(buffer);
commandDuration += buffer;
+
+ // probably unnecessary cleanup of buffer:
buffer = 0;
bufferContainsSpace = false;
bufferContainsPulse = false;
// Sleep for an amount of time. (Need to make this interruptable!)
sleepUntilRepeat(commandDuration);
- // Have we satisfied the minimum number of repetitions?
- if (repeatCount >= minimumRepetitions)
+ // Have we been told to stop yet?
+ if (checkRepeatFlag())
{
- // Have we been told to stop yet?
- if (checkRepeatFlag())
- {
- // Ok, then we can quit now:
- ++keypressCount;
- QMutexLocker cifLocker(&commandIFMutex);
- commandInFlight = false;
- return;
- }
+ // Ok, then we can quit now:
+ ++keypressCount;
+ QMutexLocker cifLocker(&commandIFMutex);
+ commandInFlight = false;
+ return;
}
++repeatCount;
}
-int RC5Protocol::pushBits(
+int RC5Protocol::pushControlBits(
+ PIRRX51Hardware &rx51device)
+{
+ int duration = 0;
+
+ // Start off by pushing the lead pulse onto the buffer:
+ buffer = biphaseUnit;
+ bufferContainsPulse = true;
+ bufferContainsSpace = false;
+
+ CommandSequence::const_iterator i = preData.begin();
+
+ // Push the first bit:
+ if (i != preData.end())
+ {
+ duration += pushBit(*i, rx51device);
+ ++i;
+ }
+
+ // Toggle the second bit, if it is time to do so:
+ if (i != preData.end())
+ {
+ if (keypressCount % 2)
+ {
+ duration += pushBit(!(*i), rx51device);
+ }
+ else
+ {
+ duration += pushBit(*i, rx51device);
+ }
+
+ ++i;
+ }
+
+ // Simply push the rest of the bits:
+ while (i != preData.end())
+ {
+ pushBit(*i, rx51device);
+ ++i;
+ }
+
+ return duration;
+}
+
+
+int RC5Protocol::pushKeyCommandBits(
const CommandSequence &bits,
PIRRX51Hardware &rx51device)
{
- int bitsDuration = 0;
+ int duration = 0;
+
+ // Just push all the bits:
+ CommandSequence::const_iterator i = bits.begin();
+ while (i != bits.end())
+ {
+ duration += pushBit(*i, rx51device);
+ ++i;
+ }
+
+ return duration;
+}
- // Rather than encoding a 0 or 1 through the timing of a pulse, RC5 encodes
- // a bit by swapping the order of pulses and spaces. (This is called
- // "biphase".)
+
+int RC5Protocol::pushNonStandardRC5(
+ const CommandSequence &bits,
+ PIRRX51Hardware &rx51device)
+{
+ int duration = 0;
+
+ // Start off by pushing the lead pulse onto the buffer:
+ buffer = biphaseUnit;
+ bufferContainsPulse = true;
+ bufferContainsSpace = false;
CommandSequence::const_iterator i = bits.begin();
- int bitCount = 1;
- bool bitValue;
- while (i != bits.end())
+ // Push the first bit:
+ if (i != bits.end())
{
- bitValue = *i;
+ duration += pushBit(*i, rx51device);
+ ++i;
+ }
- if (bitCount == toggleBit) // are we on a toggled bit?
+ // Toggle the second bit, if it is time to do so:
+ if (i != bits.end())
+ {
+ if (keypressCount % 2)
{
- if (keypressCount % 2) // is it time to toggle?
- {
- bitValue = !bitValue; // then flip the bit
- }
+ duration += pushBit(!(*i), rx51device);
}
-
- if (bitValue)
+ else
{
- // We've got a "1". First add a space, then a pulse.
- if (bufferContainsSpace)
- {
- // Merge our space with the previous space, and send them to
- // the device.
- rx51device.addSingle(buffer + biphaseSpace);
- bitsDuration += (buffer + biphaseSpace);
- buffer = 0;
- bufferContainsSpace = false;
- }
- else
- {
- if (bufferContainsPulse)
- {
- // Flush the buffer:
- rx51device.addSingle(buffer);
- bitsDuration += buffer;
- buffer = 0;
- bufferContainsPulse = false;
- }
- // Add a space:
- rx51device.addSingle(biphaseSpace);
- bitsDuration += biphaseSpace;
- }
+ duration += pushBit(*i, rx51device);
+ }
- // Put a pulse into the buffer to wait.
- buffer = biphasePulse;
- bufferContainsPulse = true;
+ ++i;
+ }
+
+ // Simply push the rest of the bits:
+ while (i != bits.end())
+ {
+ pushBit(*i, rx51device);
+ ++i;
+ }
+
+ return duration;
+}
+
+
+int RC5Protocol::pushBit(
+ bool bitValue,
+ PIRRX51Hardware &device)
+{
+ unsigned int duration = 0;
+ // RC5 encodes a "0" by using a pulse followed by a space,
+ // and a "1" by using a space followed by a pulse.
+
+ if (bitValue)
+ {
+ // We've got a "1". First add a space, then a pulse.
+ if (bufferContainsSpace)
+ {
+ // Merge our space with the previous space, and send them to
+ // the device.
+ device.addSingle(buffer + biphaseUnit);
+ duration += (buffer + biphaseUnit);
+ buffer = 0;
+ bufferContainsSpace = false;
}
else
{
- // We've got a "0". First add a pulse, then a space.
if (bufferContainsPulse)
{
- // Merge our pulse with the previous one, and send them to the device:
- rx51device.addSingle(buffer + biphasePulse);
- bitsDuration += (buffer + biphasePulse);
+ // Flush the buffer:
+ device.addSingle(buffer);
+ duration += buffer;
buffer = 0;
bufferContainsPulse = false;
}
- else
+ // Add a space:
+ device.addSingle(biphaseUnit);
+ duration += biphaseUnit;
+ }
+
+ // Put a pulse into the buffer to wait.
+ buffer = biphaseUnit;
+ bufferContainsPulse = true;
+ }
+ else
+ {
+ // We've got a "0". First add a pulse, then a space.
+ if (bufferContainsPulse)
+ {
+ // Merge our pulse with the previous one, and send them to the device:
+ device.addSingle(buffer + biphaseUnit);
+ duration += (buffer + biphaseUnit);
+ buffer = 0;
+ bufferContainsPulse = false;
+ }
+ else
+ {
+ if (bufferContainsSpace)
{
- if (bufferContainsSpace)
- {
- // Flush out the buffer:
- rx51device.addSingle(buffer);
- bitsDuration += buffer;
- buffer = 0;
- bufferContainsSpace = false;
- }
-
- // Add a pulse:
- rx51device.addSingle(biphasePulse);
- bitsDuration += biphasePulse;
+ // Flush out the buffer:
+ device.addSingle(buffer);
+ duration += buffer;
+ buffer = 0;
+ bufferContainsSpace = false;
}
- // Put a space into the buffer to wait:
- buffer = biphaseSpace;
- bufferContainsSpace = true;
+ // Add a pulse:
+ device.addSingle(biphaseUnit);
+ duration += biphaseUnit;
}
- ++i;
- ++bitCount;
+ // Put a space into the buffer to wait:
+ buffer = biphaseUnit;
+ bufferContainsSpace = true;
}
- return bitsDuration;
+ return duration;
}
class RC5Protocol: public PIRProtocol
{
public:
+ // For standard RC5, the control portion will be passed in as
+ // a seven-bit value:
RC5Protocol(
QObject *guiObject,
unsigned int index,
- unsigned int bPulse,
- unsigned int bSpace,
- unsigned int lPulse,
- unsigned int gSpace,
- bool iclflag);
+ unsigned int sevenBitControl);
- void setHeaderPair(
- unsigned int pulse,
- unsigned int space);
-
- void setToggleBit(
- unsigned int bit);
+ // For extended RC5, each key must contain the entire 13 bits.
+ RC5Protocol(
+ QObject *guiObject,
+ unsigned int index);
public slots:
void startSendingCommand(
PIRKeyName command);
protected:
- unsigned int biphasePulse;
- unsigned int biphaseSpace;
+ unsigned int biphaseUnit;
- unsigned int leadPulse;
-
- unsigned int headerPulse;
- unsigned int headerSpace;
- bool hasHeaderPair;
+private:
+ int pushControlBits(
+ PIRRX51Hardware &device);
- // The original RC-5 specification marks a single bit as a "toggle bit",
- // which should be inverted on each separate keypress. This was originally
- // the third bit, but apparently some remotes invert a different bit.
- // If set to 0, then no bits are inverted.
- int toggleBit;
+ int pushKeyCommandBits(
+ const CommandSequence &bits,
+ PIRRX51Hardware &device);
-private:
- int pushBits(
+ int pushNonStandardRC5(
const CommandSequence &bits,
PIRRX51Hardware &device);
+ int pushBit(
+ bool bitValue,
+ PIRRX51Hardware &device);
+
unsigned int buffer;
int keypressCount;
--- /dev/null
+#include "rc6protocol.h"
+
+#include "pirexception.h"
+
+#include <QMutex>
+extern bool commandInFlight;
+extern QMutex commandIFMutex;
+
+// These defines might need to be turned into variables, for odd devices.
+#define HEADER_PULSE 2666
+#define HEADER_SPACE 889
+#define TRAILER_PULSE 889
+#define TRAILER_SPACE 889
+
+// I'm requiring standard RC6 initialization to include the 8-bit control
+// section:
+RC6Protocol::RC6Protocol(
+ QObject *guiObject,
+ unsigned int index,
+ unsigned int eightBitControl)
+ : PIRProtocol(guiObject, index, 108000, true),
+ biphaseUnit(444),
+ buffer(0),
+ keypressCount(0)
+{
+ setCarrierFrequency(36000);
+ setPreData(eightBitControl, 8);
+}
+
+
+void RC6Protocol::startSendingCommand(
+ unsigned int threadableID,
+ PIRKeyName command)
+{
+ try
+ {
+ // Is this command meant for us?
+ if (threadableID != id) return;
+
+ clearRepeatFlag();
+
+ KeycodeCollection::const_iterator i = keycodes.find(command);
+
+ // Sanity check:
+ if (i == keycodes.end())
+ {
+ std::string s = "Tried to send a non-existent command.\n";
+ throw PIRException(s);
+ }
+
+ PIRRX51Hardware rx51device(carrierFrequency, dutyCycle);
+
+ int repeatCount = 0;
+ while (repeatCount < MAX_REPEAT_COUNT)
+ {
+ int duration = 0;
+
+ // First, construct the "Header" segment of the pulse train. For now,
+ // I'm only supporting the "consumer electronics mode" of RC6; this code
+ // must be changed if we want to support more than that!
+ //
+ // The header involves:
+ // a) a "lead" of 2666 us pulse, 889 us space;
+ // b) a "start bit", value 1 (so 444 us pulse, 444 us space)
+ // c) three control bits, always set to 0 (so 444 us space,
+ // 444 us pulse each)
+ // d) the double-sized "trailer" bit, toggled on each keypress (so
+ // either 889 pulse 889 space, or 889 space 889 pulse)
+
+ rx51device.addSingle(HEADER_PULSE); // lead pulse
+ duration += HEADER_PULSE;
+ rx51device.addSingle(HEADER_SPACE); // lead space
+ duration += HEADER_SPACE;
+ rx51device.addSingle(biphaseUnit); // start bit pulse
+ duration += biphaseUnit;
+
+ // start bit space + control bit 1 space:
+ rx51device.addSingle(2 * biphaseUnit);
+ duration += 2 * biphaseUnit;
+ rx51device.addSingle(biphaseUnit); // bit 1 pulse;
+ duration += biphaseUnit;
+ rx51device.addSingle(biphaseUnit); // bit 2 space;
+ duration += biphaseUnit;
+ rx51device.addSingle(biphaseUnit); // bit 2 pulse;
+ duration += biphaseUnit;
+ rx51device.addSingle(biphaseUnit); // bit 3 space;
+ duration += biphaseUnit;
+
+ // Next, need to check whether we should toggle or not:
+ if (keypressCount % 2)
+ {
+ // bit 3 pulse plus long trailer bit pulse:
+ rx51device.addSingle(3 * biphaseUnit);
+ duration += 3 * biphaseUnit;
+
+ // load the trailer bit space onto the buffer:
+ buffer = 2 * biphaseUnit;
+ bufferContainsSpace = true;
+ bufferContainsPulse = false;
+ }
+ else
+ {
+ rx51device.addSingle(biphaseUnit); // bit three pulse
+ duration += biphaseUnit;
+ rx51device.addSingle(2 * biphaseUnit); // trailer bit space
+ duration += 2 * biphaseUnit;
+
+ // load the trailer bit pulse onto the buffer:
+ buffer = 2 * biphaseUnit;
+ bufferContainsPulse = true;
+ bufferContainsSpace = false;
+ }
+
+ // Now, we can start the normal buffering process:
+
+ // push any pre-data onto the device:
+ duration += pushBits(preData, rx51device);
+
+ // push the actual command:
+ duration += pushBits((*i).second, rx51device);
+
+ // Flush out the buffer, if necessary:
+ if (buffer)
+ {
+ rx51device.addSingle(buffer);
+ duration += buffer;
+ buffer = 0;
+ }
+
+ // Actually send out the command:
+ rx51device.sendCommandToDevice();
+
+ // Sleep for an amount of time. (RC6 demands an addtional 6 unit space
+ // at the end of any command...)
+ sleepUntilRepeat(duration + 6 * biphaseUnit);
+
+ // Have we been told to stop yet?
+ if (checkRepeatFlag())
+ {
+ // Yes, we can now quit repeating:
+ ++keypressCount;
+ QMutexLocker ciflocker(&commandIFMutex);
+ commandInFlight = false;
+ return;
+ }
+ }
+ }
+ catch (PIRException e)
+ {
+ emit commandFailed(e.getError().c_str());
+ }
+
+ ++keypressCount;
+ QMutexLocker cifLocker(&commandIFMutex);
+ commandInFlight = false;
+}
+
+
+int RC6Protocol::pushBits(
+ const CommandSequence &bits,
+ PIRRX51Hardware &rx51device)
+{
+ int bitsDuration = 0;
+
+ CommandSequence::const_iterator i = bits.begin();
+ bool bitValue;
+
+ while (i != bits.end())
+ {
+ bitValue = *i;
+
+ // In RC6, a "0" is represented by a space followed by a pulse,
+ // and a "1" is represented by a pulse followed by a space.
+ if (bitValue)
+ {
+ // This is a 1, so add a pulse, then a space.
+ // First, the pulse:
+ if (bufferContainsPulse)
+ {
+ rx51device.addSingle(buffer + biphaseUnit);
+ bitsDuration += (buffer + biphaseUnit);
+ buffer = 0;
+ bufferContainsPulse = false;
+ }
+ else
+ {
+ if (bufferContainsSpace)
+ {
+ // Flush the buffer:
+ rx51device.addSingle(buffer);
+ bitsDuration += buffer;
+ buffer = 0;
+ bufferContainsSpace = false;
+ }
+ // Now, add the pulse:
+ rx51device.addSingle(biphaseUnit);
+ bitsDuration += biphaseUnit;
+ }
+
+ // Next, push a space onto the buffer:
+ buffer = biphaseUnit;
+ bufferContainsSpace = true;
+ }
+ else
+ {
+ // This is a 0, so add a space, then a pulse.
+ if (bufferContainsSpace)
+ {
+ // Merge this space and the previous one, and send to device:
+ rx51device.addSingle(buffer + biphaseUnit);
+ bitsDuration += (buffer + biphaseUnit);
+ buffer = 0;
+ bufferContainsSpace = false;
+ }
+ else
+ {
+ if (bufferContainsPulse)
+ {
+ // Flush out the buffer:
+ rx51device.addSingle(buffer);
+ bitsDuration += buffer;
+ buffer = 0;
+ bufferContainsPulse = false;
+ }
+
+ // push a space onto the device:
+ rx51device.addSingle(biphaseUnit);
+ bitsDuration += biphaseUnit;
+ }
+
+ // Put a pulse into the buffer to wait:
+ buffer = biphaseUnit;
+ bufferContainsPulse = true;
+ }
+
+ ++i;
+ }
+
+ return bitsDuration;
+}
--- /dev/null
+#ifndef RC6PROTOCOL_H
+#define RC6PROTOCOL_H
+
+#include "pirprotocol.h"
+#include "pirrx51hardware.h"
+
+//
+// The RC6 protocol is a much fancier, much more complex successor to the
+// RC5 protocol. The following code does not come close to supporting
+// all the possible permutations of this protocol!
+//
+
+class RC6Protocol: public PIRProtocol
+{
+public:
+ RC6Protocol(
+ QObject *guiObject,
+ unsigned int index,
+ unsigned int eightBitControl);
+
+public slots:
+ void startSendingCommand(
+ unsigned int threadableID,
+ PIRKeyName command);
+
+protected:
+ unsigned int biphaseUnit;
+
+private:
+ int pushBits(
+ const CommandSequence &bits,
+ PIRRX51Hardware &device);
+
+ unsigned int buffer;
+ int keypressCount;
+
+ bool bufferContainsSpace;
+ bool bufferContainsPulse;
+};
+
+#endif // RC6PROTOCOL_H