Log In
New Account
  
Home My Page Project Cloud Code Snippets Project Openings Pierogi
Summary Forums Tracker Lists Tasks Docs News SCM Files
authorJohn Pietrzak <john@pietrzak.org>
Wed, 25 Jan 2012 18:49:18 +0000 (13:49 -0500)
committerJohn Pietrzak <john@pietrzak.org>
Wed, 25 Jan 2012 18:49:18 +0000 (13:49 -0500)
I've finally put together an implementation of the RC6 protocol.  The task
was made much easier by simply chucking the LIRC code and writing my own
implementation -- the LIRC system is just overly convoluted.  Alongside this,
the Philips keyset has finally been completed (along with keysets for
Magnavox and TiVo).  Also, I've done some general cleanup of the protocol
code.

31 files changed:
keysets/ei.cpp
keysets/goldstar.cpp
keysets/hauppauge.cpp
keysets/jvc.cpp
keysets/lg.cpp
keysets/magnavox.cpp [new file with mode: 0644]
keysets/magnavox.h [new file with mode: 0644]
keysets/philips.cpp [new file with mode: 0644]
keysets/philips.h [new file with mode: 0644]
keysets/pinnacle.cpp
keysets/samsung.cpp
keysets/sharp.cpp
keysets/tivo.cpp [new file with mode: 0644]
keysets/tivo.h [new file with mode: 0644]
keysets/toshiba.cpp
keysets/toshiba.h
mainwindow.cpp
pierogi.pro
pierogi.pro.user
pirdevicetypenames.cpp
pirdevicetypenames.h
pirkeynames.h
pirkeysetmanager.cpp
pirkeysetmanager.h
pirmakenames.cpp
pirmakenames.h
qtc_packaging/debian_fremantle/changelog
rc5protocol.cpp
rc5protocol.h
rc6protocol.cpp [new file with mode: 0644]
rc6protocol.h [new file with mode: 0644]

index 29685a2..f0ea158 100644 (file)
@@ -16,61 +16,50 @@ EiKeyset::EiKeyset(
   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);
 }
index b3d344a..e7d7996 100644 (file)
@@ -56,18 +56,7 @@ GoldStarTV2::GoldStarTV2(
       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);
index 92f076d..988cbc3 100644 (file)
@@ -11,18 +11,7 @@ HauppaugePCTV1::HauppaugePCTV1(
 {
   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);
@@ -129,16 +118,7 @@ HauppaugePCTV2::HauppaugePCTV2(
 {
   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);
index 034c948..3b5c3e5 100644 (file)
@@ -5,7 +5,7 @@ JVCSat1::JVCSat1(
   QObject *guiObject,
   unsigned int index)
   : PIRKeysetMetaData(
-      "Satellite (Dish Network) Keyset 1",
+      "Sat (Dish) Keyset 1",
       JVC_Make,
       index)
 {
@@ -72,7 +72,7 @@ JVCSat2::JVCSat2(
   QObject *guiObject,
   unsigned int index)
   : PIRKeysetMetaData(
-      "Satellite (Dish Network) Keyset 2",
+      "Sat (Dish) Keyset 2",
       JVC_Make,
       index)
 {
@@ -781,7 +781,7 @@ JVCPortableAudio1::JVCPortableAudio1(
   QObject *guiObject,
   unsigned int index)
   : PIRKeysetMetaData(
-      "Portable Audio Keyset 1",
+      "Audio Keyset 1",
       JVC_Make,
       index)
 {
@@ -855,7 +855,7 @@ JVCPortableAudio1a::JVCPortableAudio1a(
   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);
@@ -869,7 +869,7 @@ JVCPortableAudio1b::JVCPortableAudio1b(
   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);
@@ -929,7 +929,7 @@ JVCPortableAudio2::JVCPortableAudio2(
   QObject *guiObject,
   unsigned int index)
   : PIRKeysetMetaData(
-      "Portable Audio Keyset 2",
+      "Audio Keyset 2",
       JVC_Make,
       index)
 {
index b6cc8cc..68c7660 100644 (file)
@@ -148,62 +148,51 @@ LGTV2::LGTV2(
       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);
 }
 
 
@@ -214,10 +203,10 @@ LGTV2a::LGTV2a(
 {
   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);
 }
 
 
@@ -228,11 +217,11 @@ LGTV2b::LGTV2b(
 {
   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
 }
 
 
diff --git a/keysets/magnavox.cpp b/keysets/magnavox.cpp
new file mode 100644 (file)
index 0000000..cc0a4bd
--- /dev/null
@@ -0,0 +1,212 @@
+#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);
+}
diff --git a/keysets/magnavox.h b/keysets/magnavox.h
new file mode 100644 (file)
index 0000000..354f364
--- /dev/null
@@ -0,0 +1,39 @@
+#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
diff --git a/keysets/philips.cpp b/keysets/philips.cpp
new file mode 100644 (file)
index 0000000..24eb176
--- /dev/null
@@ -0,0 +1,1268 @@
+#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);
+}
diff --git a/keysets/philips.h b/keysets/philips.h
new file mode 100644 (file)
index 0000000..1da9635
--- /dev/null
@@ -0,0 +1,272 @@
+#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
index c8bd921..cf49c53 100644 (file)
@@ -11,45 +11,34 @@ PinnaclePCTV1::PinnaclePCTV1(
 {
   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);
 }
 
 
@@ -63,44 +52,33 @@ PinnaclePCTV2::PinnaclePCTV2(
 {
   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);
 }
 
 
@@ -114,59 +92,48 @@ PinnaclePCTV3::PinnaclePCTV3(
 {
   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);
 }
index e4f26e0..c3f4edc 100644 (file)
@@ -196,16 +196,7 @@ SamsungTV2::SamsungTV2(
       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);
index f2fbe4f..2c0199c 100644 (file)
@@ -1,6 +1,6 @@
 #include "sharp.h"
 #include "necprotocol.h"
-#include "pirmakenames.h"
+//#include "pirmakenames.h"
 
 SharpTV1::SharpTV1(
   QObject *guiObject,
diff --git a/keysets/tivo.cpp b/keysets/tivo.cpp
new file mode 100644 (file)
index 0000000..2747f54
--- /dev/null
@@ -0,0 +1,117 @@
+#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);
+}
diff --git a/keysets/tivo.h b/keysets/tivo.h
new file mode 100644 (file)
index 0000000..3f5ec23
--- /dev/null
@@ -0,0 +1,47 @@
+#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
index f57f00d..61c3924 100644 (file)
@@ -1,6 +1,6 @@
 #include "toshiba.h"
 #include "necprotocol.h"
-#include "pirmakenames.h"
+//#include "pirmakenames.h"
 
 ToshibaTV1::ToshibaTV1(
   QObject *guiObject,
@@ -10,6 +10,8 @@ ToshibaTV1::ToshibaTV1(
       Toshiba_Make,
       index)
 {
+  addControlledDevice(Toshiba_Make, "21S03D", TV_Device);
+
   threadableProtocol = new NECProtocol(guiObject, index);
 
   setPreData(0x02FD, 16);
@@ -26,7 +28,7 @@ ToshibaTV1::ToshibaTV1(
   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);
@@ -50,7 +52,7 @@ ToshibaTV1::ToshibaTV1(
   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
@@ -79,13 +81,12 @@ ToshibaTV1::ToshibaTV1(
   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);
 }
 
 
@@ -96,7 +97,10 @@ ToshibaTV1a::ToshibaTV1a(
 {
   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);
 }
 
 
@@ -146,7 +150,7 @@ ToshibaTV1d::ToshibaTV1d(
   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);
@@ -170,6 +174,22 @@ ToshibaTV1e::ToshibaTV1e(
 }
 
 
+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)
index 30dc517..a33a775 100644 (file)
@@ -52,6 +52,14 @@ public:
     unsigned int index);
 };
 
+class ToshibaTV1f: public ToshibaTV1
+{
+public:
+  ToshibaTV1f(
+    QObject *guiObject,
+    unsigned int index);
+};
+
 class ToshibaVCR1: public PIRKeysetMetaData
 {
 public:
index 21fc3ba..beeec77 100644 (file)
@@ -1026,7 +1026,7 @@ void MainWindow::finalCleanup()
 
 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;
@@ -1043,7 +1043,7 @@ void MainWindow::on_addKeysetButton_clicked()
     ++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);
@@ -1053,7 +1053,7 @@ void MainWindow::on_addKeysetButton_clicked()
   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");
@@ -1061,7 +1061,7 @@ void MainWindow::on_addKeysetButton_clicked()
 
   settings.beginWriteArray("favorites");
   settings.setArrayIndex(favSettingsSize);
-  settings.setValue("keylistID", currentKeyset);
+  settings.setValue("keysetID", currentKeyset);
   settings.endArray();
 }
 
@@ -1096,7 +1096,7 @@ void MainWindow::on_removeKeysetButton_clicked()
       ui->favoriteKeysetsWidget->item(index));
 
     settings.setArrayIndex(index);
-    settings.setValue("keylistID", kwi->getID());
+    settings.setValue("keysetID", kwi->getID());
     ++index;
   }
   settings.endArray();
@@ -1116,14 +1116,21 @@ void MainWindow::populateFavorites()
   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;
   }
 
index 317764c..bced6d8 100644 (file)
@@ -64,7 +64,11 @@ SOURCES += main.cpp mainwindow.cpp \
     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 \
@@ -103,7 +107,11 @@ HEADERS += mainwindow.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 \
index 1f6fb5a..f226505 100644 (file)
@@ -1,6 +1,6 @@
 <?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>
@@ -79,7 +79,7 @@
       <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>
index 32d8cf0..1ebb9e6 100644 (file)
@@ -4,6 +4,7 @@ PIRDeviceTypeMgr::PIRDeviceTypeMgr()
 {
   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";
index 1606841..e64a8fb 100644 (file)
@@ -9,6 +9,7 @@
 enum PIRDeviceTypeName {
   Any_Device,
   TV_Device,
+  Sat_Device,
   VCR_Device,
   DVD_Device,
   Audio_Device,
index 2d4aeec..49e20ee 100644 (file)
@@ -71,6 +71,7 @@ enum PIRKeyName{
   PIPSource_Key,
   PIPChannelUp_Key,
   PIPChannelDown_Key,
+  PIPPause_Key,
   // DVD / Blue-ray / etc. keys:
   DiscTitle_Key,
   DiscMenu_Key,
index 29eefd5..b00bd50 100644 (file)
@@ -8,9 +8,11 @@
 #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"
@@ -19,6 +21,7 @@
 #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"
@@ -131,6 +134,11 @@ PIRKeysetManager::PIRKeysetManager(
   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++));
@@ -154,6 +162,40 @@ PIRKeysetManager::PIRKeysetManager(
   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++));
@@ -234,12 +276,19 @@ PIRKeysetManager::PIRKeysetManager(
   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++));
@@ -299,8 +348,17 @@ PIRKeysetManager::~PIRKeysetManager()
 }
 
 
+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];
@@ -312,7 +370,7 @@ bool PIRKeysetManager::hasKey(
 
 
 PIRMakeName PIRKeysetManager::getMake(
-  int keysetID)
+  unsigned int keysetID)
 {
   PIRKeysetMetaData *meta = keysetsInfo[keysetID];
 
@@ -323,7 +381,7 @@ PIRMakeName PIRKeysetManager::getMake(
 
 
 QString PIRKeysetManager::getDisplayName(
-  int keysetID)
+  unsigned int keysetID)
 {
   PIRKeysetMetaData *meta = keysetsInfo[keysetID];
 
@@ -366,7 +424,7 @@ void PIRKeysetManager::populateGuiWidget(
 
 void PIRKeysetManager::populateDeviceTypes(
   PIRKeysetWidgetItem *kwi,
-  int keysetID)
+  unsigned int keysetID)
 {
   // Pass the buck:  (Need to check for bad keysetID here?)
   keysetsInfo[keysetID]->populateDeviceTypes(kwi);
index e610ef6..66f0f56 100644 (file)
@@ -27,19 +27,22 @@ public:
   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:
index 777151f..95c6476 100644 (file)
@@ -11,6 +11,7 @@ PIRMakeMgr::PIRMakeMgr()
   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";
@@ -23,6 +24,7 @@ PIRMakeMgr::PIRMakeMgr()
   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";
index a99054b..eb3145e 100644 (file)
@@ -15,6 +15,7 @@ enum PIRMakeName{
   Hitachi_Make,
   JVC_Make,
   LG_Make,
+  Magnavox_Make,
   Mitsubishi_Make,
   Nokia_Make,
   Panasonic_Make,
@@ -27,6 +28,7 @@ enum PIRMakeName{
   Sanyo_Make,
   Sharp_Make,
   Sony_Make,
+  Tivo_Make,
   Toshiba_Make,
   Westinghouse_Make,
   Yamaha_Make,
index bd6ba46..a60d7d4 100644 (file)
@@ -1,3 +1,8 @@
+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.
 
index 3df1687..5fa1d08 100644 (file)
@@ -9,35 +9,26 @@ extern QMutex commandIFMutex;
 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);
 }
 
 
@@ -71,26 +62,33 @@ void RC5Protocol::startSendingCommand(
     {
       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;
@@ -102,18 +100,14 @@ void RC5Protocol::startSendingCommand(
       // 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;
@@ -130,98 +124,185 @@ void RC5Protocol::startSendingCommand(
 }
 
 
-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;
 }
index dacea76..10e2fb2 100644 (file)
 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(
@@ -34,26 +30,24 @@ public slots:
     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;
 
diff --git a/rc6protocol.cpp b/rc6protocol.cpp
new file mode 100644 (file)
index 0000000..dcdaee6
--- /dev/null
@@ -0,0 +1,240 @@
+#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;
+}
diff --git a/rc6protocol.h b/rc6protocol.h
new file mode 100644 (file)
index 0000000..f5b9198
--- /dev/null
@@ -0,0 +1,41 @@
+#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 

Terms of Use    Privacy Policy    Contribution Guidelines    Feedback

Powered By GForge Collaborative Development Environment