<h3>Media Tab</h3>
<p>Many of the most important playback commands are represented on this tab.
-Play, pause, and stop are the most common ones, along with "Reverse" (often
-called "Rewind") and Fast Forward. A variety of other less common navigation
-controls are included, along with the "eject" command.</p>
+"Play", "Pause", and "Stop" are the most common ones, along with "Reverse"
+(often called rewind) and "Fast Forward". A variety of other less common
+navigation controls are included, along with the "Eject" command.</p>
<h3>Misc Tab</h3>
addControlledDevice(Apple_Make, "Mac Mini", Computer_Device);
// Set up the threadable object:
- NECProtocol *np = new NECProtocol(
- guiObject,
- index,
- 574, 547, // zero pulse, zero space
- 574, 1668, // one pulse, one space
- 37600, // gap
- false); // gap is not constant length
+ threadableProtocol = new NECProtocol(guiObject, index);
- threadableProtocol = np;
-
- np->setHeaderPair(9000, 4500);
- np->setTrailerPulse(567);
- np->setRepeatPair(9000, 2250);
-
- np->setPreData(0x77e1, 16);
- np->setPostData(0xc5, 8);
-
- // Finally, add the keys:
+ setPreData(0x77e1, 16);
+ setPostData(0xc5, 8);
// Menu oriented:
addKey("menu", Menu_Key, 0x40, 8);
--- /dev/null
+#include "denon.h"
+#include "necprotocol.h"
+
+// This whole set of Denon keysets is a mess. Need to clean it up!!!
+
+DenonDVD1::DenonDVD1(
+ QObject *guiObject,
+ unsigned int index)
+ : PIRKeysetMetaData(
+ "DVD Keyset 1",
+ Denon_Make,
+ index)
+{
+ addControlledDevice(Denon_Make, "DVD-1930", DVD_Device);
+
+ NECProtocol *np = new NECProtocol(
+ guiObject,
+ index,
+ 349, 647,
+ 349, 1689,
+ 65002, true); // 43802 between?
+
+ threadableProtocol = np;
+
+ np->setElevenBitToggle(true);
+
+ np->setTrailerPulse(349);
+
+// np->setCarrierFrequency(26500); //?
+
+ addKey("POWER_ON", Unmapped_Key, 0x0A34, 15);
+ addKey("POWER_OFF", Unmapped_Key, 0x300C, 15);
+ addKey("MODE", Unmapped_Key, 0x08E4, 15);
+ addKey("OPEN_CLOSE", Eject_Key, 0x0824, 15);
+ addKey("A_B_REPEAT", Unmapped_Key, 0x0974, 15);
+ addKey("REPEAT", Unmapped_Key, 0x08A4, 15);
+ addKey("RANDOM", Unmapped_Key, 0x0954, 15);
+ addKey("ZOOM", Unmapped_Key, 0x13E4, 15);
+ addKey("CLEAR", Clear_Key, 0x0B14, 15);
+ addKey("1", One_Key, 0x0904, 15);
+ addKey("2", Two_Key, 0x0B04, 15);
+ addKey("3", Three_Key, 0x0884, 15);
+ addKey("4", Four_Key, 0x0A84, 15);
+ addKey("5", Five_Key, 0x0984, 15);
+ addKey("6", Six_Key, 0x0B84, 15);
+ addKey("7", Seven_Key, 0x0844, 15);
+ addKey("8", Eight_Key, 0x0A44, 15);
+ addKey("9", Nine_Key, 0x0944, 15);
+ addKey("0", Zero_Key, 0x0A04, 15);
+ addKey("10+", DoubleDigit_Key, 0x08C4, 15);
+ addKey("ANGLE", Unmapped_Key, 0x0BC4, 15);
+ addKey("SUBTITLE", Captions_Key, 0x0AC4, 15);
+ addKey("AUDIO", Language_Key, 0x09C4, 15);
+ addKey("DISPLAY", Info_Key, 0x0B94, 15);
+ addKey("MENU", DiscMenu_Key, 0x0A24, 15);
+ addKey("TOP_MENU", DiscTitle_Key, 0x0AF4, 15);
+ addKey("UP", Up_Key, 0x08D4, 15);
+ addKey("DOWN", Down_Key, 0x0AD4, 15);
+ addKey("LEFT", Left_Key, 0x0BD4, 15);
+ addKey("RIGHT", Right_Key, 0x09D4, 15);
+ addKey("ENTER", Select_Key, 0x0B74, 15);
+ addKey("RETURN", Exit_Key, 0x0924, 15);
+ addKey("SETUP", Menu_Key, 0x08F4, 15);
+ addKey("SEARCH_MODE", Unmapped_Key, 0x11E4, 15);
+ addKey("SKIP_DOWN", Next_Key, 0x0A64, 15);
+ addKey("SKIP_UP", Previous_Key, 0x0864, 15);
+ addKey("FAST_REVERSE", Rewind_Key, 0x0B64, 15);
+ addKey("STOP", Stop_Key, 0x0A14, 15);
+ addKey("PLAY", Play_Key, 0x0814, 15);
+ addKey("FAST_FORWARD", FastForward_Key, 0x0964, 15);
+ addKey("PAUSE", Pause_Key, 0x0AE4, 15);
+ addKey("GROUP", Unmapped_Key, 0x33FC, 15);
+ addKey("SACD_SETUP", Unmapped_Key, 0x09F8, 15);
+ addKey("PAGE+", Unmapped_Key, 0x31FC, 15);
+ addKey("PAGE-", Unmapped_Key, 0x32FC, 15);
+}
+
+
+DenonDVD2::DenonDVD2(
+ QObject *guiObject,
+ unsigned int index)
+ : PIRKeysetMetaData(
+ "DVD Keyset 2",
+ Denon_Make,
+ index)
+{
+ addControlledDevice(Denon_Make, "DVD-2500", DVD_Device);
+
+ NECProtocol *np = new NECProtocol(
+ guiObject,
+ index,
+ 400, 500,
+ 400, 1400,
+ 43000, false);
+
+ threadableProtocol = np;
+
+ np->setHeaderPair(3500, 1800);
+ np->setTrailerPulse(400);
+
+ setPreData(0x40040D00, 32);
+
+ addKey("Power", Power_Key, 0xBCB1, 16);
+ addKey("Open/Close", Eject_Key, 0x808D, 16);
+ addKey("Stop", Stop_Key, 0x000D, 16);
+ addKey("Pause", Pause_Key, 0x606D, 16);
+ addKey("Play", Play_Key, 0x505D, 16);
+ addKey("SkipBack", Previous_Key, 0x929F, 16);
+ addKey("SkipFwd", Next_Key, 0x525F, 16);
+ addKey("Rev", Rewind_Key, 0x202D, 16);
+ addKey("Fwd", FastForward_Key, 0xA0AD, 16);
+ addKey("Title", DiscTitle_Key, 0xD9D4, 16);
+ addKey("Menu", DiscMenu_Key, 0x010C, 16);
+ addKey("Display", Info_Key, 0x4944, 16);
+ addKey("Return", Exit_Key, 0x818C, 16);
+ addKey("Up", Up_Key, 0xA1AC, 16);
+ addKey("Down", Down_Key, 0x616C, 16);
+ addKey("Right", Right_Key, 0x111C, 16);
+ addKey("Left", Left_Key, 0xE1EC, 16);
+ addKey("Select", Select_Key, 0x414C, 16);
+ addKey("Subtitle", Captions_Key, 0x8984, 16);
+ addKey("Audio", Language_Key, 0xCCC1, 16);
+ addKey("Angle", Unmapped_Key, 0x0904, 16);
+ addKey("Marker", Unmapped_Key, 0x717C, 16);
+ addKey("PlayMode", Unmapped_Key, 0xB1BC, 16);
+ addKey("RepeatMode", Unmapped_Key, 0x313C, 16);
+ addKey("A-B_Repeat", Unmapped_Key, 0x121F, 16);
+ addKey("Setup", Menu_Key, 0x2924, 16);
+ addKey("Clear", Clear_Key, 0xC1CC, 16);
+ addKey("VSS", Unmapped_Key, 0x7974, 16);
+ addKey("1", One_Key, 0x0805, 16);
+ addKey("2", Two_Key, 0x8885, 16);
+ addKey("3", Three_Key, 0x4845, 16);
+ addKey("4", Four_Key, 0xC8C5, 16);
+ addKey("5", Five_Key, 0x2825, 16);
+ addKey("6", Six_Key, 0xA8A5, 16);
+ addKey("7", Seven_Key, 0x6865, 16);
+ addKey("8", Eight_Key, 0xE8E5, 16);
+ addKey("9", Nine_Key, 0x1815, 16);
+ addKey("0", Zero_Key, 0x9895, 16);
+ addKey(">=10", DoubleDigit_Key, 0x919C, 16);
+}
+
+
+DenonDVD3::DenonDVD3(
+ QObject *guiObject,
+ unsigned int index)
+ : PIRKeysetMetaData(
+ "DVD Keyset 3 (odd)",
+ Denon_Make,
+ index)
+{
+ addControlledDevice(Denon_Make, "dvd-1000", DVD_Device);
+
+ NECProtocol *np = new NECProtocol(
+ guiObject,
+ index,
+ 275, 776,
+ 275, 1829,
+ 67389, true);
+
+ threadableProtocol = np;
+
+ np->setElevenBitToggle(true);
+
+ np->setTrailerPulse(275);
+
+// np->setCarrierFrequency(32000);
+
+ addKey("power", Power_Key, 0x09CB, 15);
+ addKey("1", One_Key, 0x0AFB, 15);
+ addKey("2", Two_Key, 0x0B04, 15);
+ addKey("3", Three_Key, 0x0884, 15);
+ addKey("4", Four_Key, 0x097B, 15);
+ addKey("5", Five_Key, 0x0A7B, 15);
+ addKey("6", Six_Key, 0x0B84, 15);
+ addKey("7", Seven_Key, 0x0844, 15);
+ addKey("8", Eight_Key, 0x0A44, 15);
+ addKey("9", Nine_Key, 0x0ABB, 15);
+ addKey("0", Zero_Key, 0x09FB, 15);
+ addKey("10", Unmapped_Key, 0x0B3B, 15);
+ addKey("clear", Clear_Key, 0x08EB, 15);
+ addKey("skip-", Previous_Key, 0x099B, 15);
+ addKey("skip+", Next_Key, 0x0B9B, 15);
+ addKey("slow-", Unmapped_Key, 0x089B, 15);
+ addKey("slow+", Unmapped_Key, 0x0A9B, 15);
+ addKey("stop", Stop_Key, 0x09EB, 15);
+ addKey("pause", Pause_Key, 0x091B, 15);
+ addKey("play", Play_Key, 0x0814, 15);
+ addKey("title", DiscTitle_Key, 0x090B, 15);
+ addKey("menu", DiscMenu_Key, 0x09DB, 15);
+ addKey("return", Exit_Key, 0x0ADB, 15);
+ addKey("display", Info_Key, 0x086B, 15);
+ addKey("select", Select_Key, 0x088B, 15);
+ addKey("arrow-up", Up_Key, 0x0B2B, 15);
+ addKey("arrow-down", Down_Key, 0x092B, 15);
+ addKey("arrow-left", Left_Key, 0x082B, 15);
+ addKey("arrow-right", Right_Key, 0x0A2B, 15);
+ addKey("subtitle", Captions_Key, 0x093B, 15);
+ addKey("audio", Language_Key, 0x0A3B, 15);
+ addKey("angle", Unmapped_Key, 0x083B, 15);
+ addKey("setup", Menu_Key, 0x0B0B, 15);
+ addKey("repeat", Repeat_Key, 0x0B5B, 15);
+ addKey("repeat-ab", Unmapped_Key, 0x0A8B, 15);
+ addKey("random", Random_Key, 0x0AAB, 15);
+ addKey("call", Unmapped_Key, 0x0A0B, 15);
+ addKey("program", Program_Key, 0x0AEB, 15);
+ addKey("open-close", Eject_Key, 0x0BDB, 15);
+ addKey("ntsc-pal", Unmapped_Key, 0x084B, 15);
+}
+
+
+DenonReceiver1::DenonReceiver1(
+ QObject *guiObject,
+ unsigned int index)
+ : PIRKeysetMetaData(
+ "Receiver Keyset 1",
+ Denon_Make,
+ index)
+{
+ addControlledDevice(Denon_Make, "avr-1708", Audio_Device);
+
+ NECProtocol *np = new NECProtocol(
+ guiObject,
+ index,
+ 400, 700,
+ 400, 1700,
+ 67000, true);
+
+ threadableProtocol = np;
+
+ np->setElevenBitToggle(true);
+
+ np->setTrailerPulse(400);
+
+ addKey("On", Unmapped_Key, 0x221C, 15);
+ addKey("Off", Unmapped_Key, 0x211C, 15);
+ addKey("DVD_HDP", Unmapped_Key, 0x231C, 15); // "SRC_DVD"
+ addKey("TV_CBL", Unmapped_Key, 0x224C, 15);
+ addKey("VCR", Unmapped_Key, 0x22CC, 15);
+ addKey("Play", Play_Key, 0x10E8, 15);
+ addKey("Stop", Stop_Key, 0x11E8, 15);
+ addKey("Skip_Favorite", Favorites_Key, 0x13A8, 15);
+ addKey("Pause", Pause_Key, 0x1328, 15);
+ addKey("Volume_up", VolumeUp_Key, 0x223C, 15);
+ addKey("Volume_down", VolumeDown_Key, 0x213C, 15);
+ addKey("Rewind", Rewind_Key, 0x1368, 15);
+ addKey("Forward", FastForward_Key, 0x1168, 15);
+ addKey("Setup", Menu_Key, 0x206C, 15);
+ addKey("Mute", Mute_Key, 0x203C, 15);
+ addKey("Night_Audio", Unmapped_Key, 0x1064, 15);
+ addKey("Display", Info_Key, 0x23EC, 15); // "onscreen"
+ addKey("Enter", Select_Key, 0x201C, 15);
+ addKey("Left", Left_Key, 0x1BF8, 15);
+ addKey("Up", Up_Key, 0x1B14, 15);
+ addKey("Right", Right_Key, 0x22EC, 15);
+ addKey("Down", Down_Key, 0x1894, 15);
+ addKey("Return", Exit_Key, 0x21EC, 15);
+ addKey("Dimmer", Unmapped_Key, 0x1BEC, 15);
+}
+
+
+DenonReceiver1a::DenonReceiver1a(
+ QObject *guiObject,
+ unsigned int index)
+ : DenonReceiver1(guiObject, index)
+{
+ setKeysetName("Receiver Keyset 1a");
+
+ addControlledDevice(Denon_Make, "AVR-1610", Audio_Device);
+
+ // This keyset may need work, see denon/RC-1120
+ addKey("SRC_TV", Unmapped_Key, 0x21B3, 15);
+ addKey("SRC_TUNNER", Unmapped_Key, 0x228C, 15);
+ addKey("SRC_VAUX", Unmapped_Key, 0x20CC, 15);
+ addKey("SRC_HDP", Unmapped_Key, 0x214C, 15);
+ addKey("SRC_DVR", Unmapped_Key, 0x2233, 15);
+ addKey("SRC_VCR", Unmapped_Key, 0x2133, 15);
+ addKey("SRC_SATCBL", Unmapped_Key, 0x204C, 15);
+ addKey("BTN_VSEL", Unmapped_Key, 0x2393, 15);
+ addKey("BTN_INPUT_MODE", Unmapped_Key, 0x19B4, 15);
+ addKey("BTN_MULTEQ", Unmapped_Key, 0x111B, 15);
+ addKey("BTN_HDMI_CONTROL", Unmapped_Key, 0x182B, 15);
+ addKey("BTN_UP", Up_Key, 0x18EB, 15);
+ addKey("BTN_DOWN", Down_Key, 0x1894, 15);
+ addKey("BTN_SKIP", Unmapped_Key, 0x18CC, 15);
+ addKey("BTN_STOP", Stop_Key, 0x1BAC, 15);
+ addKey("BTN_PAUSE", Pause_Key, 0x1ACC, 15);
+ addKey("BTN_PLAY", Play_Key, 0x186C, 15);
+ addKey("FAST_REVERSE", Rewind_Key, 0x1A93, 15);
+ addKey("FAST_FORWARD", FastForward_Key, 0x1A6C, 15);
+ addKey("BTN_PREV", Previous_Key, 0x1AAC, 15);
+ addKey("BTN_NEXT", Next_Key, 0x19AC, 15);
+ addKey("BTN_STD", Unmapped_Key, 0x2363, 15);
+ addKey("PAGE_DN", Unmapped_Key, 0x1813, 15);
+ addKey("PAGE_UP", Unmapped_Key, 0x21EC, 15);
+ addKey("BTN_STD_CINEMA", Unmapped_Key, 0x115B, 15);
+ addKey("BTN_STD_MUSIC", Unmapped_Key, 0x125B, 15);
+ addKey("BTN_SIMU", Unmapped_Key, 0x219C, 15);
+}
+
+
+DenonReceiver1b::DenonReceiver1b(
+ QObject *guiObject,
+ unsigned int index)
+ : DenonReceiver1(guiObject, index)
+{
+ setKeysetName("Receiver Keyset 1b");
+
+ addControlledDevice(Denon_Make, "avr-3300", Audio_Device);
+
+ addKey("vol+", VolumeUp_Key, 0x21C3, 15);
+ addKey("channel+", ChannelUp_Key, 0x19AC, 15);
+ addKey("channel-", ChannelDown_Key, 0x1AAC, 15);
+ addKey("setup", Menu_Key, 0x1814, 15);
+ addKey("params", Unmapped_Key, 0x1A14, 15);
+ addKey("input-mode", Unmapped_Key, 0x19B4, 15);
+ addKey("analog", Unmapped_Key, 0x20EC, 15);
+ addKey("ext.in", Unmapped_Key, 0x1AB4, 15);
+ addKey("output", Unmapped_Key, 0x1A94, 15);
+ addKey("multi", Unmapped_Key, 0x236C, 15);
+}
+
+
+DenonReceiver1c::DenonReceiver1c(
+ QObject *guiObject,
+ unsigned int index)
+ : DenonReceiver1(guiObject, index)
+{
+ setKeysetName("Receiver Keyset 1c");
+
+ addControlledDevice(Denon_Make, "AVR-1602", Audio_Device);
+ addControlledDevice(Denon_Make, "AVR-1802", Audio_Device);
+ addControlledDevice(Denon_Make, "AVR-1803", Audio_Device);
+
+ addKey("ONE", One_Key, 0x230C, 15);
+ addKey("TWO", Two_Key, 0x208C, 15);
+ addKey("THREE", Three_Key, 0x231C, 15);
+ addKey("FOUR", Four_Key, 0x20CC, 15);
+ addKey("FIVE", Five_Key, 0x22CC, 15);
+ addKey("SIX", Six_Key, 0x21CC, 15);
+ addKey("SEVEN", Seven_Key, 0x224C, 15);
+ addKey("EIGHT", Eight_Key, 0x19B4, 15);
+ addKey("NINE", Nine_Key, 0x212C, 15);
+ addKey("ZERO", Zero_Key, 0x228C, 15);
+ addKey("RCVR_SURROUND_MODE", Unmapped_Key, 0x219C, 15);
+ addKey("RCVR_CHANNEL+", ChannelUp_Key, 0x19AC, 15);
+ addKey("RCVR_CHANNEL-", ChannelDown_Key, 0x1AAC, 15);
+ addKey("VIDEO_SELECT", Unmapped_Key, 0x206C, 15);
+ addKey("CD_DISC_SKIP", Unmapped_Key, 0x0B58, 15);
+ addKey("CD_PLAY", Unmapped_Key, 0x08E8, 15);
+ addKey("CD_PAUSE", Unmapped_Key, 0x0AE8, 15);
+ addKey("CD_NEXT", Unmapped_Key, 0x0868, 15);
+ addKey("CD_PREV", Unmapped_Key, 0x0A68, 15);
+ addKey("CD_STOP", Unmapped_Key, 0x09E8, 15);
+ addKey("CD_REW", Unmapped_Key, 0x0B68, 15);
+ addKey("CD_FFW", Unmapped_Key, 0x0968, 15);
+ addKey("SYSTEM", Menu_Key, 0x1814, 15);
+ addKey("RCVR_SURROUND", Surround_Key, 0x1A14, 15);
+// addKey("RCVR_CH_SELECT", Select_Key, 0x201C, 15);
+ addKey("RCVR_T_TONE", Unmapped_Key, 0x215C, 15);
+ addKey("RCVR_STATUS", Info_Key, 0x21EC, 15);
+}
+
+
+DenonReceiver2::DenonReceiver2(
+ QObject *guiObject,
+ unsigned int index)
+ : PIRKeysetMetaData(
+ "Receiver Keyset 2",
+ Denon_Make,
+ index)
+{
+ NECProtocol *np = new NECProtocol(
+ guiObject,
+ index,
+ 315, 740,
+ 315, 1812,
+ 45920, false);
+
+ threadableProtocol = np;
+
+ np->setElevenBitToggle(true);
+
+ np->setTrailerPulse(315);
+
+ addKey("amp_power", Power_Key, 0x67D7, 15);
+ addKey("amp_vol-down", VolumeDown_Key, 0x6737, 15);
+ addKey("amp_vol-up", VolumeUp_Key, 0x6537, 15);
+ addKey("amp_tape", Unmapped_Key, 0x6517, 15);
+ addKey("amp_aux/video", Unmapped_Key, 0x6497, 15);
+ addKey("amp_tuner", Unmapped_Key, 0x6597, 15);
+ addKey("amp_cd", Unmapped_Key, 0x6697, 15);
+ addKey("amp_phono", Unmapped_Key, 0x6797, 15);
+ addKey("tun_1", Unmapped_Key, 0x66F7, 15);
+ addKey("tun_2", Unmapped_Key, 0x64F7, 15);
+ addKey("tun_3", Unmapped_Key, 0x6777, 15);
+ addKey("tun_4", Unmapped_Key, 0x6577, 15);
+ addKey("tun_5", Unmapped_Key, 0x6677, 15);
+ addKey("tun_6", Unmapped_Key, 0x6477, 15);
+ addKey("tun_7", Unmapped_Key, 0x67B7, 15);
+ addKey("tun_8", Unmapped_Key, 0x65B7, 15);
+ addKey("tun_shift", Unmapped_Key, 0x66B7, 15);
+ addKey("cd_pause", Pause_Key, 0x76E8, 15);
+ addKey("cd_stop", Stop_Key, 0x7617, 15);
+ addKey("cd_play", Play_Key, 0x7717, 15);
+ addKey("cd_rew", Rewind_Key, 0x7497, 15);
+ addKey("cd_ff", FastForward_Key, 0x7697, 15);
+ addKey("cd_prev", Previous_Key, 0x7597, 15);
+ addKey("cd_next", Next_Key, 0x7797, 15);
+ addKey("CD_RANDOM", Random_Key, 0x76A7, 15);
+ addKey("CD_REPEAT", Repeat_Key, 0x7757, 15);
+ addKey("CD_SKIP", Unmapped_Key, 0x74A7, 15);
+ addKey("tape_pause", Unmapped_Key, 0x6D17, 15);
+ addKey("tape_stop", Unmapped_Key, 0x6E17, 15);
+ addKey("tape_playrev", Unmapped_Key, 0x6C57, 15);
+ addKey("tape_play", Unmapped_Key, 0x6F17, 15);
+ addKey("tape_rec", Unmapped_Key, 0x6C17, 15);
+ addKey("tape_a/b", Unmapped_Key, 0x6CD7, 15);
+ addKey("tape_rew", Unmapped_Key, 0x6C97, 15);
+ addKey("tape_ff", Unmapped_Key, 0x6E97, 15);
+}
+
+
+DenonReceiver2a::DenonReceiver2a(
+ QObject *guiObject,
+ unsigned int index)
+ : DenonReceiver2(guiObject, index)
+{
+ setKeysetName("Receiver Keyset 2a");
+
+ addControlledDevice(Denon_Make, "PMA-425R", Audio_Device);
+
+ addKey("AMP_TAPE2", Unmapped_Key, 0x5E9B, 15);
+ addKey("AMP_TAPE1", Unmapped_Key, 0x5D9B, 15);
+ addKey("AMP_AUX", Unmapped_Key, 0x5F7B, 15);
+ addKey("AMP_TUNER", Unmapped_Key, 0x5CE3, 15);
+ addKey("AMP_CD", Unmapped_Key, 0x5EFB, 15);
+ addKey("AMP_PHONO", Unmapped_Key, 0x5DFB, 15);
+ addKey("AMP_VOL_UP", VolumeUp_Key, 0x5D3B, 15);
+ addKey("AMP_VOL_DOWN", VolumeDown_Key, 0x5F3B, 15);
+ addKey("AMP_POWER", Power_Key, 0x5FDB, 15);
+ addKey("AMP_MUTE", Mute_Key, 0x5CBB, 15);
+ addKey("TUN_CH_UP", ChannelUp_Key, 0x6653, 15);
+ addKey("TUN_CH_DOWN", ChannelDown_Key, 0x6553, 15);
+}
+
+
+DenonReceiver3::DenonReceiver3(
+ QObject *guiObject,
+ unsigned int index)
+ : PIRKeysetMetaData(
+ "Receiver Keyset 3",
+ Denon_Make,
+ index)
+{
+ addControlledDevice(Denon_Make, "PMA-480R", Audio_Device);
+
+ NECProtocol *np = new NECProtocol(
+ guiObject,
+ index,
+ 400, 600,
+ 400, 1700,
+ 67400, true);
+
+ threadableProtocol = np;
+
+ np->setElevenBitToggle(true);
+
+ np->setTrailerPulse(400);
+
+ addKey("TUNER", Unmapped_Key, 0x1AEC, 15);
+ addKey("DECK", Unmapped_Key, 0x12B8, 15);
+ addKey("CD", Unmapped_Key, 0x0B38, 15);
+ addKey("CD_PLAY", Play_Key, 0x08E8, 15);
+ addKey("CD_PAUSE", Pause_Key, 0x0AE8, 15);
+ addKey("CD_STOP", Stop_Key, 0x09E8, 15);
+ addKey("CD_REW", Rewind_Key, 0x0B68, 15);
+ addKey("CD_FF", FastForward_Key, 0x0968, 15);
+ addKey("CD_BACK", Previous_Key, 0x0A68, 15);
+ addKey("CD_NEXT", Next_Key, 0x0868, 15);
+ addKey("DISC1", Unmapped_Key, 0x0898, 15);
+ addKey("DISC2", Unmapped_Key, 0x0A98, 15);
+ addKey("DISC3", Unmapped_Key, 0x0998, 15);
+ addKey("DISC4", Unmapped_Key, 0x0B98, 15);
+ addKey("DISC5", Unmapped_Key, 0x0858, 15);
+ addKey("DISC6", Unmapped_Key, 0x0A58, 15);
+ addKey("REPEAT", Repeat_Key, 0x08A8, 15);
+ addKey("TAPE_A/B", Unmapped_Key, 0x1328, 15);
+ addKey("TAPE_PAUSE", Unmapped_Key, 0x12E8, 15);
+ addKey("TAPE_STOP", Unmapped_Key, 0x11E8, 15);
+ addKey("TAPE_REC", Unmapped_Key, 0x13E8, 15);
+ addKey("TAPE_REW", Unmapped_Key, 0x1368, 15);
+ addKey("TAPE_FF", Unmapped_Key, 0x1168, 15);
+ addKey("TAPE_PLAY_REV", Unmapped_Key, 0x13A8, 15);
+ addKey("TAPE_PLAY", Unmapped_Key, 0x10E8, 15);
+ addKey("TUNER_UP", ChannelUp_Key, 0x1AAC, 15);
+ addKey("TUNER_DOWN", ChannelDown_Key, 0x19AC, 15);
+ addKey("AMP_POWER", Power_Key, 0x2024, 15);
+ addKey("AMP_CD", Unmapped_Key, 0x2104, 15);
+ addKey("AMP_PHONO", Unmapped_Key, 0x2204, 15);
+ addKey("AMP_AUX", Unmapped_Key, 0x2084, 15);
+ addKey("AMP_TUNER", Unmapped_Key, 0x2304, 15);
+ addKey("AMP_TAPE-2", Unmapped_Key, 0x2164, 15);
+ addKey("AMP_TAPE-1", Unmapped_Key, 0x2264, 15);
+ addKey("AMP_MUTING", Mute_Key, 0x20BB, 15);
+ addKey("AMP_VOL_UP", VolumeUp_Key, 0x22C4, 15);
+ addKey("AMP_VOL_DOWN", VolumeDown_Key, 0x20C4, 15);
+}
+
+
+DenonReceiver3a::DenonReceiver3a(
+ QObject *guiObject,
+ unsigned int index)
+ : DenonReceiver3(guiObject, index)
+{
+ setKeysetName("Receiver Keyset 3a");
+
+ addControlledDevice(Denon_Make, "DRA-385RD", Audio_Device);
+
+ addKey("random", Random_Key, 0x0958, 15);
+ addKey("repeat", Repeat_Key, 0x0B57, 15);
+ addKey("disksk", Unmapped_Key, 0x0B58, 15);
+ addKey("panel", Info_Key, 0x19F8, 15);
+ addKey("tape_mon", Unmapped_Key, 0x18E8, 15);
+ addKey("tape2", Unmapped_Key, 0x19E8, 15);
+ addKey("tape1", Unmapped_Key, 0x1AE8, 15);
+ addKey("video", Unmapped_Key, 0x1B28, 15);
+ addKey("tuner", Unmapped_Key, 0x1A68, 15);
+ addKey("cd", Unmapped_Key, 0x1968, 15);
+ addKey("phono", Unmapped_Key, 0x1868, 15);
+ addKey("preset+", Unmapped_Key, 0x1A37, 15);
+ addKey("preset-", Unmapped_Key, 0x1BC8, 15);
+ addKey("volup", VolumeUp_Key, 0x1937, 15);
+ addKey("voldwn", VolumeDown_Key, 0x18C8, 15);
+}
+
+
+DenonReceiver4::DenonReceiver4(
+ QObject *guiObject,
+ unsigned int index)
+ : PIRKeysetMetaData(
+ "Receiver Keyset 4",
+ Denon_Make,
+ index)
+{
+ addControlledDevice(Denon_Make, "AVR-600 RD", Audio_Device);
+
+ NECProtocol *np = new NECProtocol(
+ guiObject,
+ index,
+ 561, 489,
+ 561, 1543,
+ 67329, true);
+
+ threadableProtocol = np;
+
+ np->setTrailerPulse(561);
+
+ addKey("POWER", Power_Key, 0xA20C, 16);
+ addKey("UP", Up_Key, 0x99AC, 16);
+ addKey("DOWN", Down_Key, 0x9AAC, 16);
+ addKey("TUNER", Unmapped_Key, 0xA28C, 16);
+ addKey("CD", Unmapped_Key, 0xA08C, 16);
+ addKey("PHONO", Unmapped_Key, 0xA30C, 16);
+ addKey("VCR", Unmapped_Key, 0xA2CC, 16);
+ addKey("TV", Unmapped_Key, 0xA14C, 16);
+ addKey("TAPE", Unmapped_Key, 0xA12C, 16);
+ addKey("STEREO", Unmapped_Key, 0xA39C, 16);
+ addKey("MODE", Unmapped_Key, 0xA19C, 16);
+ addKey("TESTTONE", Unmapped_Key, 0xA15C, 16);
+ addKey("DELAY", Unmapped_Key, 0xA25C, 16);
+ addKey("MUTE", Mute_Key, 0xA03C, 16);
+ addKey("PANEL", Info_Key, 0xA1EC, 16);
+ addKey("CENTER_UP", Unmapped_Key, 0xA2BC, 16);
+ addKey("CENTER_DOWN", Unmapped_Key, 0xA1BC, 16);
+ addKey("REAR_UP", Unmapped_Key, 0xA33C, 16);
+ addKey("REAR_DOWN", Unmapped_Key, 0xA0BC, 16);
+ addKey("VOL_UP", VolumeUp_Key, 0xA23C, 16);
+ addKey("VOL_DOWN", VolumeDown_Key, 0xA13C, 16);
+}
+
+
+DenonReceiver5::DenonReceiver5(
+ QObject *guiObject,
+ unsigned int index)
+ : PIRKeysetMetaData(
+ "Receiver Keyset 5",
+ Denon_Make,
+ index)
+{
+ addControlledDevice(Denon_Make, "AVR-700RD", Audio_Device);
+ addControlledDevice(Denon_Make, "RC-841", Audio_Device);
+
+ NECProtocol *np = new NECProtocol(
+ guiObject,
+ index,
+ 336, 715,
+ 336, 1769,
+ 67376, true);
+
+ threadableProtocol = np;
+
+ np->setElevenBitToggle(true);
+
+ np->setTrailerPulse(337);
+
+ addKey("Power", Power_Key, 0x220C, 15);
+ addKey("CD_Disc_Skip_Plus", Unmapped_Key, 0x0B58, 15);
+ addKey("CD_Stop", Stop_Key, 0x09E8, 15);
+ addKey("CD_Play", Play_Key, 0x08E8, 15);
+ addKey("CD_Prev", Previous_Key, 0x0A68, 15);
+ addKey("CD_Pause", Pause_Key, 0x0AE8, 15);
+ addKey("CD_Next", Next_Key, 0x0868, 15);
+ addKey("Preset_Up", Unmapped_Key, 0x19AC, 15);
+ addKey("Preset_Down", Unmapped_Key, 0x1AAC, 15);
+ addKey("Shift", Unmapped_Key, 0x1ACC, 15);
+ addKey("Tuner", Unmapped_Key, 0x228C, 15);
+ addKey("CD", Unmapped_Key, 0x208C, 15);
+ addKey("Phono", Unmapped_Key, 0x230C, 15);
+ addKey("VCR", Unmapped_Key, 0x22CC, 15);
+ addKey("DVD_TV", Unmapped_Key, 0x214C, 15);
+ addKey("NoName1", Unmapped_Key, 0x20CC, 15);
+ addKey("DAT_Tape", Unmapped_Key, 0x212C, 15);
+ addKey("Stereo", Unmapped_Key, 0x239C, 15);
+ addKey("Mode", Unmapped_Key, 0x219C, 15);
+ addKey("Test_Tone", Unmapped_Key, 0x215C, 15);
+ addKey("Delay", Unmapped_Key, 0x225C, 15);
+ addKey("CenterVolumeUp", Unmapped_Key, 0x22BC, 15);
+ addKey("CenterVolumeDown", Unmapped_Key, 0x21BC, 15);
+ addKey("RearVolumeUp", Unmapped_Key, 0x233C, 15);
+ addKey("RearVolumeDown", Unmapped_Key, 0x20BC, 15);
+ addKey("Muting", Mute_Key, 0x203C, 15);
+ addKey("NoName2", Unmapped_Key, 0x23EC, 15);
+ addKey("Panel", Info_Key, 0x21EC, 15);
+ addKey("MasterVolumeUp", VolumeUp_Key, 0x223C, 15);
+ addKey("MasterVolumeDown", VolumeDown_Key, 0x213C, 15);
+ addKey("Deck_PlayLeft", Unmapped_Key, 0x13A8, 15);
+ addKey("Deck_Stop", Unmapped_Key, 0x11E8, 15);
+ addKey("Deck_PlayRight", Unmapped_Key, 0x10E8, 15);
+ addKey("Deck_Rewind", Unmapped_Key, 0x1368, 15);
+ addKey("Deck_A_B", Unmapped_Key, 0x1328, 15);
+ addKey("Deck_FastForward", Unmapped_Key, 0x1168, 15);
+}
+
+
+DenonAudio1::DenonAudio1(
+ QObject *guiObject,
+ unsigned int index)
+ : PIRKeysetMetaData(
+ "Audio Keyset 1",
+ Denon_Make,
+ index)
+{
+ addControlledDevice(Denon_Make, "HiFi 110", Audio_Device);
+ addControlledDevice(Denon_Make, "DRM-550", Audio_Device);
+ addControlledDevice(Denon_Make, "DCD-335", Audio_Device);
+ addControlledDevice(Denon_Make, "DRA-275RD", Audio_Device);
+ addControlledDevice(Denon_Make, "UD-M30", Audio_Device);
+
+ NECProtocol *np = new NECProtocol(
+ guiObject,
+ index,
+ 300, 750,
+ 300, 1800,
+ 67500, true);
+
+ threadableProtocol = np;
+
+ np->setElevenBitToggle(true);
+
+ np->setTrailerPulse(300);
+
+ addKey("KEY_POWER", Power_Key, 0x1828, 15); // "aus"
+ addKey("KEY_SLEEP", Sleep_Key, 0x1938, 15);
+ addKey("KEY_FN", Unmapped_Key, 0x1BE8, 15); // "func"
+ addKey("KEY_STOP", Stop_Key, 0x09E8, 15); // "CD_STOP"
+ addKey("KEY_PLAY", Play_Key, 0x08E8, 15); // "cdplay"
+ addKey("KEY_PAUSE", Pause_Key, 0x0AE8, 15); // "cdpause"
+ addKey("KEY_REWIND", Rewind_Key, 0x0B68, 15); // "cdfrew"
+ addKey("KEY_FORWARD", FastForward_Key, 0x0968, 15); // "cdffwd"
+ addKey("KEY_PREVIOUS", Previous_Key, 0x0A68, 15); // "cdrew", "cdprevtrack"
+ addKey("KEY_NEXT", Next_Key, 0x0868, 15); // "cdfwd", "cdnexttrack"
+ addKey("KEY_1", One_Key, 0x0908, 15);
+ addKey("KEY_2", Two_Key, 0x0B08, 15);
+ addKey("KEY_3", Three_Key, 0x0888, 15);
+ addKey("KEY_4", Four_Key, 0x0A88, 15);
+ addKey("KEY_5", Five_Key, 0x0988, 15);
+ addKey("KEY_6", Six_Key, 0x0B88, 15);
+ addKey("KEY_7", Seven_Key, 0x0BB7, 15);
+ addKey("KEY_8", Eight_Key, 0x0A48, 15);
+ addKey("KEY_9", Nine_Key, 0x0948, 15);
+ addKey("10", Zero_Key, 0x0B48, 15);
+ addKey("+10", DoubleDigit_Key, 0x08C8, 15);
+ addKey("DIRECT", Unmapped_Key, 0x0BA8, 15); // "direct"
+ addKey("KEY_PROGRAM", Program_Key, 0x0AC8, 15);
+ addKey("KEY_CANCEL", Clear_Key, 0x0A28, 15); // "cancel", "CD_CANCEL"
+ addKey("TUNER BAND", Unmapped_Key, 0x1BAC, 15);
+ addKey("TUNER KEY_DOWN", ChannelDown_Key, 0x196C, 15);
+ addKey("TUNER KEY_UP", ChannelUp_Key, 0x1A6C, 15);
+ addKey("CT", Unmapped_Key, 0x1B2C, 15); // "TUNER_CT"
+ addKey("RDS", Unmapped_Key, 0x192C, 15); // "TUNER_RDS"
+ addKey("PRESET DOWN", Down_Key, 0x1BC8, 15); // "dwn"
+ addKey("PRESET UP", Up_Key, 0x19C8, 15); // "up"
+ addKey("TAPE REW", Unmapped_Key, 0x13A8, 15); // "TAPE_PLAY_REV"
+ addKey("TAPE FWD", Unmapped_Key, 0x10E8, 15); // "TAPE_PLAY_FORW"
+ addKey("TAPE FAST REW", Unmapped_Key, 0x1368, 15); // "TAPE_REW"
+ addKey("TAPE FAST FWD", Unmapped_Key, 0x1168, 15); // "TAPE_FORW"
+ addKey("TAPE STOP", Unmapped_Key, 0x11E8, 15);
+ addKey("TAPE 2 REW", Unmapped_Key, 0x1398, 15);
+ addKey("TAPE 2 FWD", Unmapped_Key, 0x10D8, 15);
+ addKey("TAPE 2 FAST REW", Unmapped_Key, 0x1358, 15);
+ addKey("TAPE 2 FAST FWD", Unmapped_Key, 0x1158, 15);
+ addKey("TAPE 2 STOP", Unmapped_Key, 0x11D8, 15);
+ addKey("KEY_RECORD", Record_Key, 0x13D8, 15);
+ addKey("SDB", Unmapped_Key, 0x095C, 15);
+ addKey("KEY_VOLUMEDOWN", VolumeDown_Key, 0x18C8, 15);
+ addKey("KEY_VOLUMEUP", VolumeUp_Key, 0x1AC8, 15);
+ addKey("cdskip", Unmapped_Key, 0x0B58, 15);
+ addKey("tuner", Unmapped_Key, 0x1A68, 15);
+ addKey("repeat", Repeat_Key, 0x08A8, 15); // "CD_REPEAT"
+ addKey("random", Random_Key, 0x0958, 15); // "CD_RANDOM"
+ addKey("programm", Program_Key, 0x0AC8, 15);
+ addKey("edit", Unmapped_Key, 0x0838, 15); // "CD_EDIT"
+ addKey("time", Unmapped_Key, 0x0B28, 15); // "CD_TIME"
+ addKey("reset", Reset_Key, 0x10A8, 15);
+ addKey("remain", Unmapped_Key, 0x10B8, 15);
+ addKey("tapesize", Unmapped_Key, 0x1018, 15);
+ addKey("revmode", Unmapped_Key, 0x1118, 15);
+ addKey("memo", Unmapped_Key, 0x1A2C, 15);
+ addKey("pty", Unmapped_Key, 0x18AC, 15); // "TUNER_PTY"
+ addKey("panel", Info_Key, 0x19EC, 15);
+ addKey("eon", Unmapped_Key, 0x1BBC, 15);
+ addKey("auto_space", Unmapped_Key, 0x0A18, 15);
+ addKey("auto_edit", Unmapped_Key, 0x0B18, 15);
+ addKey("open_close", Eject_Key, 0x0828, 15);
+ addKey("fader", Unmapped_Key, 0x09B8, 15);
+ addKey("pitch-", Unmapped_Key, 0x0878, 15);
+ addKey("pitch+", Unmapped_Key, 0x0BB8, 15);
+ addKey("peak", Unmapped_Key, 0x0BD8, 15);
+ addKey("TAPE_AB", Unmapped_Key, 0x1328, 15);
+ addKey("TAPE_PAUSE", Unmapped_Key, 0x12E8, 15);
+ addKey("RCVR_PANEL", Info_Key, 0x19F8, 15);
+ addKey("RCVR_TAPE_MON", Unmapped_Key, 0x18E8, 15);
+ addKey("RCVR_TAPE2", Unmapped_Key, 0x19E8, 15);
+ addKey("RCVR_TAPE1", Unmapped_Key, 0x1AE8, 15);
+ addKey("RCVR_VIDEO", Unmapped_Key, 0x1B28, 15);
+ addKey("RCVR_TUNER", Unmapped_Key, 0x1A68, 15);
+ addKey("RCVR_CD", Unmapped_Key, 0x1A97, 15);
+ addKey("RCVR_PHONO", Unmapped_Key, 0x1868, 15);
+}
+
+
+DenonAudio1a::DenonAudio1a(
+ QObject *guiObject,
+ unsigned int index)
+ : DenonAudio1(guiObject, index)
+{
+ setKeysetName("Audio Keyset 1a");
+
+ addControlledDevice(Denon_Make, "UCD-F07", Audio_Device);
+ addControlledDevice(Denon_Make, "UDR-F07", Audio_Device);
+ addControlledDevice(Denon_Make, "UDRA-F07", Audio_Device);
+
+ addKey("rec", Record_Key, 0x13E8, 15);
+ addKey("side_a/b", Unmapped_Key, 0x0B28, 15);
+ addKey("cdstop", Stop_Key, 0x0A17, 15);
+}
+
+
+DenonAudio1b::DenonAudio1b(
+ QObject *guiObject,
+ unsigned int index)
+ : DenonAudio1(guiObject, index)
+{
+ setKeysetName("Audio Keyset 1b");
+
+ addControlledDevice(Denon_Make, "DCD-1015", Audio_Device);
+ addControlledDevice(Denon_Make, "DCD-655", Audio_Device);
+
+ addKey("vol_down", VolumeDown_Key, 0x0BC8, 15);
+ addKey("vol_up", VolumeUp_Key, 0x09C8, 15);
+ addKey("display", Info_Key, 0x0AB8, 15);
+}
+
+
+DenonAudio1c::DenonAudio1c(
+ QObject *guiObject,
+ unsigned int index)
+ : DenonAudio1b(guiObject, index)
+{
+ setKeysetName("Audio Keyset 1c (odd)");
+
+ addControlledDevice(Denon_Make, "DCM-260", Audio_Device);
+
+ addKey("RANDOM", Random_Key, 0x0AA7, 15);
+ addKey("2", Two_Key, 0x08F7, 15);
+ addKey("DISC_SELECT", Unmapped_Key, 0x0918, 15);
+// addKey("DISC_SKIP+", Unmapped_Key, 0x0B58, 15); // already in parent...
+ addKey("DISC_SKIP-", Unmapped_Key, 0x0A27, 15); // not in parent
+ addKey("|<<", Previous_Key, 0x0997, 15);
+}
+
+
+DenonAudio1d::DenonAudio1d(
+ QObject *guiObject,
+ unsigned int index)
+ : DenonAudio1(guiObject, index)
+{
+ setKeysetName("Audio Keyset 1d");
+
+ addControlledDevice(Denon_Make, "UDRA-M7", Audio_Device);
+ addControlledDevice(Denon_Make, "UPA-F88", Audio_Device);
+ addControlledDevice(Denon_Make, "UCD-F88", Audio_Device);
+ addControlledDevice(Denon_Make, "UDR-F88", Audio_Device);
+ addControlledDevice(Denon_Make, "UTU-F88", Audio_Device);
+ addControlledDevice(Denon_Make, "RC-846", Audio_Device);
+
+ addKey("TAPE_REC", Record_Key, 0x13E8, 15);
+ addKey("MD_PLAY", Unmapped_Key, 0x311C, 15);
+ addKey("MD_STOP", Unmapped_Key, 0x321C, 15);
+ addKey("MD_REC", Unmapped_Key, 0x329C, 15);
+ addKey("MD_SEARCH_NEXT", Unmapped_Key, 0x325C, 15);
+ addKey("MD_SEARCH_PREVIOUS", Unmapped_Key, 0x315C, 15);
+}
+
+
+DenonAudio2::DenonAudio2(
+ QObject *guiObject,
+ unsigned int index)
+ : PIRKeysetMetaData(
+ "Audio Keyset 2",
+ Denon_Make,
+ index)
+{
+ addControlledDevice(Denon_Make, "D-C30", Audio_Device);
+
+ threadableProtocol = new NECProtocol(guiObject, index);
+
+ setPreData(0xDA25, 16);
+
+ addKey("Power", Power_Key, 0x00FF, 16);
+ addKey("Tuner_Band", Unmapped_Key, 0xE01F, 16);
+ addKey("EQ_Pattern", Unmapped_Key, 0x8877, 16);
+ addKey("Open/Close", Eject_Key, 0x18E7, 16);
+ addKey("1", One_Key, 0xB24D, 16);
+ addKey("2", Two_Key, 0x728D, 16);
+ addKey("3", Three_Key, 0xF20D, 16);
+ addKey("4", Four_Key, 0x0AF5, 16);
+ addKey("5", Five_Key, 0x8A75, 16);
+ addKey("6", Six_Key, 0x4AB5, 16);
+ addKey("7", Seven_Key, 0xCA35, 16);
+ addKey("8", Eight_Key, 0x2AD5, 16);
+ addKey("9", Nine_Key, 0xAA55, 16);
+ addKey("10", Unmapped_Key, 0x6A95, 16);
+ addKey("0/11", Zero_Key, 0xDA25, 16);
+ addKey("10+/12", DoubleDigit_Key, 0xEA15, 16);
+ addKey("Record_Pause", Unmapped_Key, 0xF807, 16);
+ addKey("Play_Backward", Unmapped_Key, 0x4B87, 16);
+ addKey("Stop", Unmapped_Key, 0xB847, 16);
+ addKey("Play_Forward", Unmapped_Key, 0x9867, 16);
+ addKey("A.Edit", Unmapped_Key, 0x20DF, 16);
+ addKey("Fast_Rewind", Unmapped_Key, 0x38C7, 16);
+ addKey("Fast_Forward", Unmapped_Key, 0xD827, 16);
+ addKey("Tape_1/2", Unmapped_Key, 0x906F, 16);
+ addKey("Remain", Unmapped_Key, 0xC03F, 16);
+ addKey("Random", Random_Key, 0x5AA5, 16);
+ addKey("Prog", Program_Key, 0x6897, 16);
+ addKey("Disc", Unmapped_Key, 0x7A85, 16);
+ addKey("Skip_Backward", Previous_Key, 0xA857, 16);
+ addKey("Skip_Forward", Next_Key, 0x28D7, 16);
+ addKey("CD_Stop", Stop_Key, 0xC837, 16);
+ addKey("CD_Play", Play_Key, 0x48B7, 16);
+ addKey("P.Mode", Unmapped_Key, 0xD02F, 16);
+ addKey("Repeat", Repeat_Key, 0xE817, 16);
+ addKey("Volume_Down", VolumeDown_Key, 0x40BF, 16);
+ addKey("Volume_Up", VolumeUp_Key, 0x807F, 16);
+}
+
+
+DenonAudio3::DenonAudio3(
+ QObject *guiObject,
+ unsigned int index)
+ : PIRKeysetMetaData(
+ "Audio Keyset 3",
+ Denon_Make,
+ index)
+{
+ NECProtocol *np = new NECProtocol(
+ guiObject,
+ index,
+ 336, 717,
+ 336, 1773,
+ 67458, true);
+
+ threadableProtocol = np;
+
+ np->setElevenBitToggle(true);
+
+ np->setTrailerPulse(336);
+
+ addKey("open_close", Eject_Key, 0x8828, 15);
+ addKey("call", Unmapped_Key, 0x8928, 15);
+ addKey("prog", Program_Key, 0x8B08, 15);
+ addKey("direct", Unmapped_Key, 0x8BA8, 15);
+ addKey("1", One_Key, 0x8908, 15);
+ addKey("2", Two_Key, 0x8B08, 15);
+ addKey("3", Three_Key, 0x8888, 15);
+ addKey("4", Four_Key, 0x8A88, 15);
+ addKey("5", Five_Key, 0x8988, 15);
+ addKey("6", Six_Key, 0x8B88, 15);
+ addKey("7", Seven_Key, 0x8848, 15);
+ addKey("8", Eight_Key, 0x8A48, 15);
+ addKey("9", Nine_Key, 0x8948, 15);
+ addKey("10", Zero_Key, 0x8B48, 15);
+ addKey("+10", DoubleDigit_Key, 0x88C8, 15);
+ addKey("play", Play_Key, 0x88E8, 15);
+ addKey("vol_up", VolumeUp_Key, 0x89C8, 15);
+ addKey("vol_down", VolumeDown_Key, 0x8BC8, 15);
+ addKey("pause", Pause_Key, 0x8AE8, 15);
+ addKey("stop", Stop_Key, 0x89E8, 15);
+ addKey("a_space", Unmapped_Key, 0x8A18, 15);
+ addKey("all", Unmapped_Key, 0x88A8, 15);
+ addKey("a-b", Unmapped_Key, 0x8AA8, 15);
+ addKey("rewind", Rewind_Key, 0x8B68, 15);
+ addKey("wind", FastForward_Key, 0x8968, 15);
+ addKey("prev", Previous_Key, 0x8A68, 15);
+ addKey("next", Next_Key, 0x8868, 15);
+}
+
+
+DenonAudio4::DenonAudio4(
+ QObject *guiObject,
+ unsigned int index)
+ : PIRKeysetMetaData(
+ "Audio Keyset 4",
+ Denon_Make,
+ index)
+{
+ addControlledDevice(Denon_Make, "DMD-800", Audio_Device);
+
+ NECProtocol *np = new NECProtocol(
+ guiObject,
+ index,
+ 275, 775,
+ 275, 1900,
+ 43000, false);
+
+ threadableProtocol = np;
+
+ np->setElevenBitToggle(true);
+
+ np->setTrailerPulse(275);
+
+ addKey("EJECT", Eject_Key, 0x319C, 15);
+ addKey("POWER", Power_Key, 0x301C, 15);
+ addKey("PLAY", Play_Key, 0x311C, 15);
+ addKey("PAUSE", Pause_Key, 0x331C, 15);
+ addKey("STOP", Stop_Key, 0x321C, 15);
+ addKey("REC", Record_Key, 0x329C, 15);
+ addKey("1", One_Key, 0x320C, 15);
+ addKey("2", Two_Key, 0x310C, 15);
+ addKey("3", Three_Key, 0x330C, 15);
+ addKey("4", Four_Key, 0x308C, 15);
+ addKey("5", Five_Key, 0x328C, 15);
+ addKey("6", Six_Key, 0x318C, 15);
+ addKey("7", Seven_Key, 0x338C, 15);
+ addKey("8", Eight_Key, 0x304C, 15);
+ addKey("9", Nine_Key, 0x324C, 15);
+ addKey("10", Zero_Key, 0x314C, 15);
+ addKey("+10", DoubleDigit_Key, 0x305C, 15);
+ addKey("CALL", Unmapped_Key, 0x31BC, 15);
+ addKey("PREV_TRACK", Previous_Key, 0x315C, 15);
+ addKey("NEXT_TRACK", Next_Key, 0x325C, 15);
+ addKey("BACK", Replay_Key, 0x30DC, 15);
+ addKey("FORWARD", Advance_Key, 0x335C, 15);
+ addKey("CLEAR", Clear_Key, 0x33EC, 15);
+ addKey("PROG", Program_Key, 0x303C, 15);
+ addKey("REPEAT", Repeat_Key, 0x323C, 15);
+ addKey("RANDOM", Random_Key, 0x333C, 15);
+ addKey("EDIT", Unmapped_Key, 0x33DC, 15);
+ addKey("ENTER", Select_Key, 0x31EC, 15);
+ addKey("TIME", Unmapped_Key, 0x30BC, 15);
+ addKey("CHAR", Unmapped_Key, 0x32EC, 15);
+ addKey("TITLE", Unmapped_Key, 0x32BC, 15);
+}
+
+
+DenonAudio5::DenonAudio5(
+ QObject *guiObject,
+ unsigned int index)
+ : PIRKeysetMetaData(
+ "Audio Keyset 5",
+ Denon_Make,
+ index)
+{
+ addControlledDevice(Denon_Make, "D-G1MD", Audio_Device);
+
+ threadableProtocol = new NECProtocol(guiObject, index);
+
+ setPreData(0x4040, 16);
+
+ addKey("fm/am", Unmapped_Key, 0x00FF, 16);
+ addKey("tape", Unmapped_Key, 0x10EF, 16);
+ addKey("cd", Unmapped_Key, 0x08F7, 16);
+ addKey("md", Unmapped_Key, 0x02FD, 16);
+ addKey("aux", Unmapped_Key, 0x18E7, 16);
+ addKey("rds", Unmapped_Key, 0x807F, 16);
+ addKey("pty", Unmapped_Key, 0x906F, 16);
+ addKey("ct", Unmapped_Key, 0x8877, 16);
+ addKey("rt", Unmapped_Key, 0x9867, 16);
+ addKey("fmmode", Unmapped_Key, 0x827D, 16);
+ addKey("1", One_Key, 0x40BF, 16);
+ addKey("2", Two_Key, 0x50AF, 16);
+ addKey("3", Three_Key, 0x48B7, 16);
+ addKey("4", Four_Key, 0x58A7, 16);
+ addKey("5", Five_Key, 0x42BD, 16);
+ addKey("6", Six_Key, 0xC03F, 16);
+ addKey("7", Seven_Key, 0xD02F, 16);
+ addKey("8", Eight_Key, 0xC837, 16);
+ addKey("9", Nine_Key, 0xD827, 16);
+ addKey("0", Zero_Key, 0xC23D, 16);
+ addKey("+10", DoubleDigit_Key, 0x20DF, 16);
+ addKey("+100", PlusOneHundred_Key, 0x30CF, 16);
+ addKey("clock", Unmapped_Key, 0x28D7, 16);
+ addKey("timer", Unmapped_Key, 0x38C7, 16);
+ addKey("sleep", Sleep_Key, 0x22DD, 16);
+ addKey("set", Unmapped_Key, 0xA25D, 16);
+ addKey("mdrec", Unmapped_Key, 0xA05F, 16);
+ addKey("pickrec", Unmapped_Key, 0xB04F, 16);
+ addKey("checkspace", Unmapped_Key, 0xA857, 16);
+ addKey("clear", Clear_Key, 0xB847, 16);
+ addKey("enter", Enter_Key, 0x629D, 16);
+ addKey("recmute", Unmapped_Key, 0x609F, 16);
+ addKey("revmode", Unmapped_Key, 0x708F, 16);
+ addKey("dolby", Unmapped_Key, 0x6897, 16);
+ addKey("5modesrs", Surround_Key, 0xE21D, 16);
+ addKey("edit", Unmapped_Key, 0xE01F, 16);
+ addKey("editcancel", Unmapped_Key, 0xF00F, 16);
+ addKey("titleinput", Unmapped_Key, 0x7887, 16);
+ addKey("titlesearch", Unmapped_Key, 0x12ED, 16);
+ addKey("edit", Unmapped_Key, 0xE01F, 16);
+ addKey("repeat", Repeat_Key, 0x52AD, 16);
+ addKey("random", Random_Key, 0xD22D, 16);
+ addKey("prog", Program_Key, 0xE817, 16);
+ addKey("vol-", VolumeDown_Key, 0xF807, 16);
+ addKey("vol+", VolumeUp_Key, 0x926D, 16);
+ addKey("power", Power_Key, 0x32CD, 16);
+ addKey("mute", Mute_Key, 0xF20D, 16);
+ addKey("bass", Unmapped_Key, 0x0AF5, 16);
+ addKey("eqmode", Unmapped_Key, 0x728D, 16);
+ addKey("timedisp", Info_Key, 0xB24D, 16);
+ addKey("forward", FastForward_Key, 0x8A75, 16);
+ addKey("prev", Previous_Key, 0x4AB5, 16);
+ addKey("stop", Stop_Key, 0xEA15, 16);
+ addKey("next", Next_Key, 0xCA35, 16);
+ addKey("backward", Rewind_Key, 0x6A95, 16);
+}
--- /dev/null
+#ifndef DENON_H
+#define DENON_H
+
+#include "pirkeysetmetadata.h"
+#include <QObject>
+
+class DenonDVD1: public PIRKeysetMetaData
+{
+public:
+ DenonDVD1(
+ QObject *guiObject,
+ unsigned int index);
+};
+
+class DenonDVD2: public PIRKeysetMetaData
+{
+public:
+ DenonDVD2(
+ QObject *guiObject,
+ unsigned int index);
+};
+
+class DenonDVD3: public PIRKeysetMetaData
+{
+public:
+ DenonDVD3(
+ QObject *guiObject,
+ unsigned int index);
+};
+
+class DenonReceiver1: public PIRKeysetMetaData
+{
+public:
+ DenonReceiver1(
+ QObject *guiObject,
+ unsigned int index);
+};
+
+class DenonReceiver1a: public DenonReceiver1
+{
+public:
+ DenonReceiver1a(
+ QObject *guiObject,
+ unsigned int index);
+};
+
+class DenonReceiver1b: public DenonReceiver1
+{
+public:
+ DenonReceiver1b(
+ QObject *guiObject,
+ unsigned int index);
+};
+
+class DenonReceiver1c: public DenonReceiver1
+{
+public:
+ DenonReceiver1c(
+ QObject *guiObject,
+ unsigned int index);
+};
+
+class DenonReceiver2: public PIRKeysetMetaData
+{
+public:
+ DenonReceiver2(
+ QObject *guiObject,
+ unsigned int index);
+};
+
+class DenonReceiver2a: public DenonReceiver2
+{
+public:
+ DenonReceiver2a(
+ QObject *guiObject,
+ unsigned int index);
+};
+
+class DenonReceiver3: public PIRKeysetMetaData
+{
+public:
+ DenonReceiver3(
+ QObject *guiObject,
+ unsigned int index);
+};
+
+class DenonReceiver3a: public DenonReceiver3
+{
+public:
+ DenonReceiver3a(
+ QObject *guiObject,
+ unsigned int index);
+};
+
+class DenonReceiver4: public PIRKeysetMetaData
+{
+public:
+ DenonReceiver4(
+ QObject *guiObject,
+ unsigned int index);
+};
+
+class DenonReceiver5: public PIRKeysetMetaData
+{
+public:
+ DenonReceiver5(
+ QObject *guiObject,
+ unsigned int index);
+};
+
+class DenonAudio1: public PIRKeysetMetaData
+{
+public:
+ DenonAudio1(
+ QObject *guiObject,
+ unsigned int index);
+};
+
+class DenonAudio1a: public DenonAudio1
+{
+public:
+ DenonAudio1a(
+ QObject *guiObject,
+ unsigned int index);
+};
+
+class DenonAudio1b: public DenonAudio1
+{
+public:
+ DenonAudio1b(
+ QObject *guiObject,
+ unsigned int index);
+};
+
+class DenonAudio1c: public DenonAudio1b
+{
+public:
+ DenonAudio1c(
+ QObject *guiObject,
+ unsigned int index);
+};
+
+class DenonAudio1d: public DenonAudio1
+{
+public:
+ DenonAudio1d(
+ QObject *guiObject,
+ unsigned int index);
+};
+
+class DenonAudio2: public PIRKeysetMetaData
+{
+public:
+ DenonAudio2(
+ QObject *guiObject,
+ unsigned int index);
+};
+
+class DenonAudio3: public PIRKeysetMetaData
+{
+public:
+ DenonAudio3(
+ QObject *guiObject,
+ unsigned int index);
+};
+
+class DenonAudio4: public PIRKeysetMetaData
+{
+public:
+ DenonAudio4(
+ QObject *guiObject,
+ unsigned int index);
+};
+
+class DenonAudio5: public PIRKeysetMetaData
+{
+public:
+ DenonAudio5(
+ QObject *guiObject,
+ unsigned int index);
+};
+
+#endif // DENON_H
index,
931, 836,
969,
- 113205, 2);
+ 113205, true);
threadableProtocol = rp;
- rp->setPreData(0x10, 5);
-
rp->setToggleBit(2);
+ setPreData(0x10, 5);
+
addKey("i", Unmapped_Key, 0x35, 8);
addKey("a", Unmapped_Key, 0x37, 8);
addKey("b", Unmapped_Key, 0x36, 8);
{
addControlledDevice(GoldStar_Make, "105-210A", TV_Device);
- NECProtocol *np = new NECProtocol(
- guiObject,
- index,
- 600, 500,
- 600, 1600,
- 10800, true);
+ threadableProtocol = new NECProtocol(guiObject, index);
- threadableProtocol = np;
-
- np->setHeaderPair(9000, 4500);
- np->setTrailerPulse(600);
- np->setRepeatPair(9000, 2250);
-
- np->setPreData(0x20DF, 16);
+ setPreData(0x20DF, 16);
addKey("power", Power_Key, 0x10EF, 16);
addKey("mute", Mute_Key, 0x906F, 16);
addKey("volup", VolumeUp_Key, 0x40BF, 16);
addKey("voldown", VolumeDown_Key, 0xC03F, 16);
addKey("ok", Select_Key, 0x22DD, 16);
-// addKey("ok", Enter_Key, 0x22DD, 16);
addKey("prup", Up_Key, 0x00FF, 16);
addKey("voldown", Left_Key, 0xC03F, 16);
addKey("volup", Right_Key, 0x40BF, 16);
threadableProtocol = rp;
- rp->setPreData(0x40, 7);
+ setPreData(0x40, 7);
rp->setToggleBit(2);
addControlledDevice(GoldStar_Make, "GSE-Q204P", VCR_Device);
addControlledDevice(GoldStar_Make, "QUISY 500", VCR_Device);
- NECProtocol *np = new NECProtocol(
- guiObject,
- index,
- 600, 500,
- 600, 1600,
- 108000, true);
-
- threadableProtocol = np;
-
- np->setHeaderPair(9000, 4500);
- np->setTrailerPulse(600);
- np->setRepeatPair(9000, 2250);
+ threadableProtocol = new NECProtocol(guiObject, index);
- np->setPreData(0x7689, 16);
+ setPreData(0x7689, 16);
addKey("power", Power_Key, 0x28D7, 16);
addKey("eject", Eject_Key, 0x00FF, 16);
np->setRepeatPair(600, 1600);
np->setRepeatNeedsHeader(true);
- np->setPreData(0x0808, 16);
- np->setPostData(0x1, 1);
+ setPreData(0x0808, 16);
+ setPostData(0x1, 1);
addKey("power", Power_Key, 0x3C43, 15);
addKey("mute", Mute_Key, 0x7C03, 15);
#include "hauppauge.h"
#include "rc5protocol.h"
-HauppaugeGeneric::HauppaugeGeneric(
+HauppaugePCTV1::HauppaugePCTV1(
QObject *guiObject,
unsigned int index)
: PIRKeysetMetaData(
- "Generic Remote",
+ "PCTV Keyset 1",
Hauppauge_Make,
index)
{
+ addControlledDevice(Hauppauge_Make, "PVR 350", Computer_Device);
+
RC5Protocol *rp = new RC5Protocol(
guiObject,
index,
- 950, 820, // biphase pulse
- 1000, // lead pulse
+ 900, 900, // biphase pulse
+ 900, // lead pulse
114000, true); // constant-length gap
threadableProtocol = rp;
- rp->setPreData(0x17, 5);
-
rp->setToggleBit(2);
- addKey("Power", Power_Key, 0xBD, 8);
- addKey("Go", Unmapped_Key, 0xBB, 8);
- addKey("TV", Unmapped_Key, 0x9C, 8);
- addKey("Videos", Unmapped_Key, 0x98, 8);
- addKey("Music", Unmapped_Key, 0x99, 8);
- addKey("Pictures", Unmapped_Key, 0x9A, 8);
- addKey("Guide", Unmapped_Key, 0x9B, 8);
- addKey("Radio", Unmapped_Key, 0x8C, 8);
- addKey("Up", Up_Key, 0x94, 8);
- addKey("Down", Down_Key, 0x95, 8);
- addKey("Left", Left_Key, 0x96, 8);
- addKey("Right", Right_Key, 0x97, 8);
- addKey("Ok", Enter_Key, 0xA5, 8);
- addKey("Ok", Select_Key, 0xA5, 8);
- addKey("Back/Exit", Exit_Key, 0x9F, 8);
- addKey("Menu/i", Menu_Key, 0x8D, 8);
- addKey("Vol+", VolumeUp_Key, 0x90, 8);
- addKey("Vol-", VolumeDown_Key, 0x91, 8);
- addKey("Prev.Ch", PrevChannel_Key, 0x92, 8);
- addKey("Mute", Mute_Key, 0x8F, 8);
- addKey("Ch+", ChannelUp_Key, 0xA0, 8);
- addKey("Ch-", ChannelDown_Key, 0xA1, 8);
- addKey("Record", Record_Key, 0xB7, 8);
- addKey("Stop", Stop_Key, 0xB6, 8);
- addKey("Rewind", Rewind_Key, 0xB2, 8);
- addKey("Play", Play_Key, 0xB5, 8);
- addKey("Forward", FastForward_Key, 0xB4, 8);
- addKey("Replay/SkipBackward", Replay_Key, 0xA4, 8);
- addKey("Pause", Pause_Key, 0xB0, 8);
- addKey("SkipForward", Advance_Key, 0x9E, 8);
- addKey("1", One_Key, 0x81, 8);
- addKey("2", Two_Key, 0x82, 8);
- addKey("3", Three_Key, 0x83, 8);
- addKey("4", Four_Key, 0x84, 8);
- addKey("5", Five_Key, 0x85, 8);
- addKey("6", Six_Key, 0x86, 8);
- addKey("7", Seven_Key, 0x87, 8);
- addKey("8", Eight_Key, 0x88, 8);
- addKey("9", Nine_Key, 0x89, 8);
- addKey("0", Zero_Key, 0x80, 8);
- addKey("Asterix", Unmapped_Key, 0x8A, 8);
- addKey("sub/cc", Captions_Key, 0x8E, 8);
- addKey("Red", Red_Key, 0x8B, 8);
- addKey("Green", Green_Key, 0xAE, 8);
- addKey("Yellow", Yellow_Key, 0xB8, 8);
- addKey("Blue", Blue_Key, 0xA9, 8);
+ setPreData(0x5E, 7);
+
+ addKey("Power", Power_Key, 0x3D, 6);
+ addKey("Go", Unmapped_Key, 0x3B, 6);
+ addKey("TV", Unmapped_Key, 0x1C, 6);
+ addKey("Videos", Unmapped_Key, 0x18, 6);
+ addKey("Music", Unmapped_Key, 0x19, 6);
+ addKey("Pictures", Unmapped_Key, 0x1A, 6);
+ addKey("Guide", Unmapped_Key, 0x1B, 6);
+ addKey("Radio", Unmapped_Key, 0x0C, 6);
+ addKey("Up", Up_Key, 0x14, 6);
+ addKey("Down", Down_Key, 0x15, 6);
+ addKey("Left", Left_Key, 0x16, 6);
+ addKey("Right", Right_Key, 0x17, 6);
+ addKey("Ok", Select_Key, 0x25, 6);
+ addKey("Back/Exit", Exit_Key, 0x1F, 6);
+ addKey("Menu/i", Menu_Key, 0x0D, 6);
+ addKey("Vol+", VolumeUp_Key, 0x10, 6);
+ addKey("Vol-", VolumeDown_Key, 0x11, 6);
+ addKey("Prev.Ch", PrevChannel_Key, 0x12, 6);
+ addKey("Mute", Mute_Key, 0x0F, 6);
+ addKey("Ch+", ChannelUp_Key, 0x20, 6);
+ addKey("Ch-", ChannelDown_Key, 0x21, 6);
+ addKey("Record", Record_Key, 0x37, 6);
+ addKey("Stop", Stop_Key, 0x36, 6);
+ addKey("Rewind", Rewind_Key, 0x32, 6);
+ addKey("Play", Play_Key, 0x35, 6);
+ addKey("Forward", FastForward_Key, 0x34, 6);
+ addKey("Replay/SkipBackward", Replay_Key, 0x24, 6);
+ addKey("Pause", Pause_Key, 0x30, 6);
+ addKey("SkipForward", Advance_Key, 0x1E, 6);
+ addKey("0", Zero_Key, 0x00, 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("Asterix", Unmapped_Key, 0x0A, 6);
+ addKey("sub/cc", Captions_Key, 0x0E, 6); // "Recordings"
+ addKey("Red", Red_Key, 0x0B, 6);
+ addKey("Green", Green_Key, 0x2E, 6);
+ addKey("Yellow", Yellow_Key, 0x38, 6);
+ addKey("Blue", Blue_Key, 0x29, 6);
+}
+
+
+HauppaugePCTV1a::HauppaugePCTV1a(
+ QObject *guiObject,
+ unsigned int index)
+ : HauppaugePCTV1(guiObject, index)
+{
+ setKeysetName("PCTV Keyset 1a");
+
+ addControlledDevice(Hauppauge_Make, "WinTV-HVR-950Q", Computer_Device);
+
+ setPreData(0x5D, 7);
+}
+
+
+HauppaugePCTV1b::HauppaugePCTV1b(
+ QObject *guiObject,
+ unsigned int index)
+ : HauppaugePCTV1(guiObject, index)
+{
+ setKeysetName("PCTV Keyset 1b");
+
+ addControlledDevice(Hauppauge_Make, "MVP", Computer_Device);
+
+ setPreData(0x43, 7);
+
+ addKey("KEY_FN_1", Unmapped_Key, 0x0C, 6);
+ addKey("KEY_FN_2", Unmapped_Key, 0x3C, 6);
+}
+
+
+HauppaugePCTV1c::HauppaugePCTV1c(
+ QObject *guiObject,
+ unsigned int index)
+ : HauppaugePCTV1(guiObject, index)
+{
+ setKeysetName("PCTV Keyset 1c");
+
+ addControlledDevice(Hauppauge_Make, "PVR 250", Computer_Device);
+// addControlledDevice(Hauppauge_Make, "PVR 350", Computer_Device);
+
+ setPreData(0x5F, 7);
+
+ addKey("blank", Unmapped_Key, 0x0C, 6);
+ addKey("full", Unmapped_Key, 0x3C, 6);
}
// Based on LIRC Sony_RM-V302-DVD010 config file
-HauppaugeTV1::HauppaugeTV1(
+HauppaugePCTV2::HauppaugePCTV2(
QObject *guiObject,
unsigned int index)
: PIRKeysetMetaData(
- "TV Keyset 1",
+ "PCTV Keyset 2",
Hauppauge_Make,
index)
{
- addControlledDevice(Hauppauge_Make, "PVR-250", TV_Device);
+ addControlledDevice(Hauppauge_Make, "PVR-250", Computer_Device);
RC5Protocol *rp = new RC5Protocol(
guiObject,
index,
- 889, 889,
- 889,
- 113792, true);
+ 900, 900,
+ 900,
+ 114000, true);
threadableProtocol = rp;
addKey("STOP", Stop_Key, 0x1520, 13);
}
+
+/*
+// Translation of DSR-0095 config file
+HauppaugePCTV3::HauppaugePCTV3(
+ QObject *guiObject,
+ unsigned int index)
+ : PIRKeysetMetaData(
+ "PCTV Keyset 3",
+ Hauppauge_Make,
+ index)
+{
+ RC5Protocol *rp = new RC5Protocol(
+ guiObject,
+ index,
+ 900, 900,
+ 900,
+ 114000, true);
+
+ threadableProtocol = rp;
+
+ rp->setToggleBit(2);
+
+ rp->setPreData(0x17, 5);
+
+ addKey("home", Unmapped_Key, 0x7B, 8);
+ addKey("choice", Unmapped_Key, 0x5B, 8);
+ addKey("stop", Stop_Key, 0x77, 8);
+}
+*/
#define HAUPPAUGE_H
#include "pirkeysetmetadata.h"
-
#include <QObject>
-class HauppaugeGeneric: public PIRKeysetMetaData
+class HauppaugePCTV1: public PIRKeysetMetaData
+{
+public:
+ HauppaugePCTV1(
+ QObject *guiObject,
+ unsigned int index);
+};
+
+class HauppaugePCTV1a: public HauppaugePCTV1
+{
+public:
+ HauppaugePCTV1a(
+ QObject *guiObject,
+ unsigned int index);
+};
+
+class HauppaugePCTV1b: public HauppaugePCTV1
{
public:
- HauppaugeGeneric(
+ HauppaugePCTV1b(
QObject *guiObject,
unsigned int index);
};
+class HauppaugePCTV1c: public HauppaugePCTV1
+{
+public:
+ HauppaugePCTV1c(
+ QObject *guiObject,
+ unsigned int index);
+};
-class HauppaugeTV1: public PIRKeysetMetaData
+class HauppaugePCTV2: public PIRKeysetMetaData
{
public:
- HauppaugeTV1(
+ HauppaugePCTV2(
QObject *guiObject,
unsigned int index);
};
--- /dev/null
+#include "hitachi.h"
+#include "necprotocol.h"
+
+HitachiTV1::HitachiTV1(
+ QObject *guiObject,
+ unsigned int index)
+ : PIRKeysetMetaData(
+ "TV Keyset 1",
+ Hitachi_Make,
+ index)
+{
+ threadableProtocol = new NECProtocol(guiObject, index);
+
+ setPreData(0x0AF5, 16);
+
+ addKey("1", One_Key, 0xB04F, 16);
+ addKey("2", Two_Key, 0x708F, 16);
+ addKey("3", Three_Key, 0xF00F, 16);
+ addKey("4", Four_Key, 0x38C7, 16);
+ addKey("5", Five_Key, 0xB847, 16);
+ addKey("6", Six_Key, 0x7887, 16);
+ addKey("7", Seven_Key, 0xF807, 16);
+ addKey("8", Eight_Key, 0x20DF, 16);
+ addKey("9", Nine_Key, 0xA05F, 16);
+ addKey("0", Zero_Key, 0x30CF, 16);
+ addKey("ch_down", ChannelDown_Key, 0x18E7, 16);
+ addKey("ch_up", ChannelUp_Key, 0x9867, 16);
+ addKey("recall", PrevChannel_Key, 0x08F7, 16);
+ addKey("tv/video", Input_Key, 0x906F, 16); // "AV"
+ addKey("power", Power_Key, 0xE817, 16);
+ addKey("vol_up", VolumeUp_Key, 0x48B7, 16);
+ addKey("vol_down", VolumeDown_Key, 0xA857, 16);
+ addKey("timer", Sleep_Key, 0x8877, 16);
+ addKey("return", Exit_Key, 0x22DD, 16);
+ addKey("mute", Mute_Key, 0xD02F, 16);
+ addKey("krasn", Unmapped_Key, 0xDA25, 16);
+ addKey("zelen", Unmapped_Key, 0x7A85, 16);
+ addKey("Reveal", Unmapped_Key, 0xBA45, 16); // "jolt"
+ addKey("zelen", Unmapped_Key, 0x3AC5, 16);
+ addKey("OK", Select_Key, 0xC23D, 16);
+ addKey("FWD", FastForward_Key, 0xF609, 16);
+ addKey("REV", Rewind_Key, 0xB649, 16);
+ addKey("PLAY", Play_Key, 0xD629, 16);
+ addKey("STOP", Stop_Key, 0x36C9, 16);
+ addKey("HELP", Info_Key, 0x58A7, 16);
+ addKey("CH", Unmapped_Key, 0xC837, 16);
+ addKey("MENU", Menu_Key, 0x02FD, 16);
+ addKey("PSCAN100HZ", Unmapped_Key, 0xB24D, 16);
+ addKey("X", Unmapped_Key, 0x2AD5, 16);
+ addKey("3D-SOUND", Surround_Key, 0xD827, 16);
+ addKey("UP", Up_Key, 0x0EF1, 16);
+ addKey("DOWN", Down_Key, 0x8E71, 16);
+ addKey("CH_I/II", Unmapped_Key, 0x10EF, 16);
+ addKey("TV/TEXT", Unmapped_Key, 0x6699, 16);
+ addKey("SOUND", SoundMode_Key, 0xF20D, 16);
+ addKey("Picture", PictureMode_Key, 0xE619, 16);
+ addKey("Red", Red_Key, 0x32CD, 16);
+ addKey("SUB", Unmapped_Key, 0xA25D, 16);
+ addKey("U.N.L", Unmapped_Key, 0x629D, 16);
+ addKey("HOLD", Unmapped_Key, 0xE21D, 16);
+ addKey("Cancel", Clear_Key, 0x16E9, 16);
+ addKey("Store", Unmapped_Key, 0x28D7, 16);
+ addKey("Language", Language_Key, 0x609F, 16);
+}
+
+
+HitachiTV1a::HitachiTV1a(
+ QObject *guiObject,
+ unsigned int index)
+ : HitachiTV1(guiObject, index)
+{
+ setKeysetName("TV Keyset 1a");
+
+ addKey("menu", Menu_Key, 0xCA35, 16);
+}
+
+HitachiTV1b::HitachiTV1b(
+ QObject *guiObject,
+ unsigned int index)
+ : HitachiTV1a(guiObject, index)
+{
+ setKeysetName("TV Keyset 1b");
+
+ addKey("Sound+", VolumeUp_Key, 0x4EB1, 16);
+ addKey("Sound-", VolumeDown_Key, 0xCE31, 16);
+ addKey("Timer", Sleep_Key, 0xD629, 16);
+}
+
+
+HitachiTV1c::HitachiTV1c(
+ QObject *guiObject,
+ unsigned int index)
+ : HitachiTV1(guiObject, index)
+{
+ setKeysetName("TV Keyset 1c");
+
+ addControlledDevice(Hitachi_Make, "57F510", TV_Device);
+
+ addKey("LastChannel", PrevChannel_Key, 0x50AF, 16);
+ addKey("Info", Info_Key, 0x08F7, 16);
+ addKey("Input1", Unmapped_Key, 0x847B, 16);
+ addKey("Input2", Unmapped_Key, 0x44BB, 16);
+ addKey("Input3", Unmapped_Key, 0xC43B, 16);
+ addKey("Input4", Unmapped_Key, 0x24DB, 16);
+ addKey("ChannelUp", Unmapped_Key, 0x14EB, 16); // these four are odd
+ addKey("ChannelDown", Unmapped_Key, 0x946B, 16); // duplicate?
+ addKey("VolumeDown", Unmapped_Key, 0x54AB, 16); // maybe pip?
+ addKey("VolumeUp", Unmapped_Key, 0xD42B, 16); // doesn't make sense
+ addKey("SELECT", Select_Key, 0x748B, 16);
+ addKey("CC", Captions_Key, 0xEC13, 16);
+ addKey("FavouriteChannel", Favorites_Key, 0x1CE3, 16);
+ addKey("1080i/540p", Unmapped_Key, 0x3CC3, 16);
+ addKey("Input5", Unmapped_Key, 0xBC43, 16);
+ addKey("PowerON", Unmapped_Key, 0x7C83, 16);
+ addKey("PowerOFF", Unmapped_Key, 0xFC03, 16);
+ addKey("Menu", Menu_Key, 0xCA35, 16);
+ addKey("PIP", PIP_Key, 0x1AE5, 16);
+ addKey("Day/Night", Unmapped_Key, 0x7A85, 16);
+ addKey("Freeze/Pause", Unmapped_Key, 0x8679, 16);
+ addKey("EXIT", Exit_Key, 0x26D9, 16);
+ addKey("16:9", Unmapped_Key, 0xA659, 16);
+ addKey("16:9Zoom", Unmapped_Key, 0x6699, 16);
+ addKey("4:3Standard", Unmapped_Key, 0xE619, 16);
+ addKey("4:3Expanded", Unmapped_Key, 0x16E9, 16);
+ addKey("4:3Zoom1", Unmapped_Key, 0x9669, 16);
+ addKey("4:3Zoom2", Unmapped_Key, 0x56A9, 16);
+ addKey("540p", Unmapped_Key, 0xD629, 16);
+ addKey("1080i", Unmapped_Key, 0x36C9, 16);
+ addKey("Aspect", AspectRatio_Key, 0xF609, 16);
+ addKey("ArrowRight", Right_Key, 0x4EB1, 16);
+ addKey("ArrowLeft", Left_Key, 0xCE31, 16);
+ addKey("DayMode", Unmapped_Key, 0x2ED1, 16);
+ addKey("NightMode", Unmapped_Key, 0xAE51, 16);
+ addKey("AntennaA", Unmapped_Key, 0x6E91, 16);
+ addKey("AntennaB", Unmapped_Key, 0xEE11, 16);
+ addKey("CC", Unmapped_Key, 0x1EE1, 16); // Another CC key?
+ addKey("Guide", Guide_Key, 0xAC53, 16);
+ // Many more codes available in LIRC's hitachi/CLU4341UG2 config file
+}
+
+
+HitachiProjector::HitachiProjector(
+ QObject *guiObject,
+ unsigned int index)
+ : PIRKeysetMetaData(
+ "Projector Keyset",
+ Hitachi_Make,
+ index)
+{
+ threadableProtocol = new NECProtocol(guiObject, index);
+
+ setPreData(0xE1A2, 16);
+
+ addKey("Power", Power_Key, 0xE817, 16);
+ addKey("PageUp", Unmapped_Key, 0x0BF4, 16);
+ addKey("PageDown", Unmapped_Key, 0x8B74, 16);
+ addKey("Home", Unmapped_Key, 0xAB54, 16);
+ addKey("End", Unmapped_Key, 0x6B94, 16);
+ addKey("Enter", Select_Key, 0x847B, 16);
+ addKey("Left", Left_Key, 0x748B, 16);
+ addKey("Right", Right_Key, 0x54AB, 16);
+ addKey("Up", Up_Key, 0x14EB, 16);
+ addKey("Down", Down_Key, 0x34CB, 16);
+ addKey("Menu", Menu_Key, 0x04FB, 16);
+ addKey("Reset", Reset_Key, 0x44BB, 16);
+ addKey("Esc", Unmapped_Key, 0x2BD4, 16);
+ addKey("Position", Unmapped_Key, 0x0CF3, 16);
+ addKey("Freeze", Unmapped_Key, 0x2DD2, 16);
+ addKey("Keystone", Unmapped_Key, 0x6D92, 16);
+ addKey("Search", Unmapped_Key, 0x58A7, 16);
+ addKey("RGB", PictureMode_Key, 0x18E7, 16);
+ addKey("Video", Unmapped_Key, 0x9867, 16);
+ addKey("Aspect", AspectRatio_Key, 0x5EA1, 16);
+ addKey("MagnifyOn", Unmapped_Key, 0x0DF2, 16);
+ addKey("MagnifyOff", Unmapped_Key, 0xCD32, 16);
+ addKey("Volume", Unmapped_Key, 0xCA35, 16);
+ addKey("Mute", Mute_Key, 0x4AB5, 16);
+ addKey("Auto", Unmapped_Key, 0x24DB, 16);
+ addKey("Blank", Unmapped_Key, 0x827D, 16);
+}
+
+
+HitachiDVD1::HitachiDVD1(
+ QObject *guiObject,
+ unsigned int index)
+ : PIRKeysetMetaData(
+ "DVD Keyset 1",
+ Hitachi_Make,
+ index)
+{
+ threadableProtocol = new NECProtocol(guiObject, index);
+
+ setPreData(0x01C4, 16);
+
+ addKey("Power", Power_Key, 0x50AF, 16);
+ addKey("Surround", Surround_Key, 0xBA45, 16);
+ addKey("SearchMode", Unmapped_Key, 0x7C83, 16);
+ addKey("OpenClose", Eject_Key, 0x906F, 16);
+ addKey("ABRepeat", Unmapped_Key, 0x04FB, 16);
+ addKey("1", One_Key, 0xB04F, 16);
+ addKey("2", Two_Key, 0x708F, 16);
+ addKey("3", Three_Key, 0xF00F, 16);
+ addKey("4", Four_Key, 0x38C7, 16);
+ addKey("5", Five_Key, 0xB847, 16);
+ addKey("6", Six_Key, 0x7887, 16);
+ addKey("7", Seven_Key, 0xF807, 16);
+ addKey("8", Eight_Key, 0x20DF, 16);
+ addKey("9", Nine_Key, 0xA05F, 16);
+ addKey("0", Zero_Key, 0x30CF, 16);
+ addKey("Repeat", Unmapped_Key, 0x00FF, 16);
+ addKey("Mode", Unmapped_Key, 0xB44B, 16);
+ addKey("Zoom", Unmapped_Key, 0xDC23, 16);
+ addKey("Clear", Clear_Key, 0x9867, 16);
+ addKey("+10", DoubleDigit_Key, 0x08F7, 16);
+ addKey("Angle", Unmapped_Key, 0x54AB, 16);
+ addKey("Subtitle", Captions_Key, 0xD42B, 16);
+ addKey("Audio", Language_Key, 0x34CB, 16);
+ addKey("Display", Info_Key, 0xD02F, 16);
+ addKey("Menu", DiscMenu_Key, 0xE01F, 16);
+ addKey("TopMenu", DiscTitle_Key, 0x609F, 16);
+ addKey("Up", Up_Key, 0x44BB, 16);
+ addKey("Left", Left_Key, 0x24DB, 16);
+ addKey("Enter", Select_Key, 0x649B, 16);
+ addKey("Right", Right_Key, 0xA45B, 16);
+ addKey("Down", Down_Key, 0xC43B, 16);
+ addKey("Return", Exit_Key, 0xE41B, 16);
+ addKey("Setup", Menu_Key, 0x10EF, 16);
+ addKey("DiscNav", Guide_Key, 0x4CB3, 16);
+ addKey("Prev", Previous_Key, 0xC03F, 16);
+ addKey("Next", Next_Key, 0x40BF, 16);
+ addKey("Stop", Stop_Key, 0xD827, 16);
+ addKey("Play", Play_Key, 0x28D7, 16);
+ addKey("Rew", Rewind_Key, 0x48B7, 16);
+ addKey("Pause", Pause_Key, 0x58A7, 16);
+ addKey("FF", FastForward_Key, 0x8877, 16);
+}
+
+
+HitachiAudio1::HitachiAudio1(
+ QObject *guiObject,
+ unsigned int index)
+ : PIRKeysetMetaData(
+ "Audio Keyset 1",
+ Hitachi_Make,
+ index)
+{
+ addControlledDevice(Hitachi_Make, "FX-7", Audio_Device);
+ addControlledDevice(Hitachi_Make, "FX-77", Audio_Device);
+
+ threadableProtocol = new NECProtocol(guiObject, index);
+
+ setPreData(0xDA25, 16);
+
+ addKey("1", One_Key, 0xB24D, 16);
+ addKey("2", Two_Key, 0x728D, 16);
+ addKey("3", Three_Key, 0xF20D, 16);
+ addKey("4", Four_Key, 0x0AF5, 16);
+ addKey("5", Five_Key, 0x8A75, 16);
+ addKey("6", Six_Key, 0x4AB5, 16);
+ addKey("7", Seven_Key, 0xCA35, 16);
+ addKey("8", Eight_Key, 0x2AD5, 16);
+ addKey("9", Nine_Key, 0xAA55, 16);
+ addKey("10", Unmapped_Key, 0x6A95, 16);
+ addKey("0/11", Zero_Key, 0xDA25, 16);
+ addKey("10+/12", DoubleDigit_Key, 0xEA15, 16);
+ addKey("CD_SKIP_BACK", Previous_Key, 0xA857, 16);
+ addKey("CD_SKIP_FWD", Next_Key, 0x28D7, 16);
+ addKey("CD_STOP", Stop_Key, 0xC837, 16);
+ addKey("CD_PLAY/PAUSE", Play_Key, 0x48B7, 16);
+ addKey("CD_PLAY/PAUSE", Pause_Key, 0x48B7, 16);
+ addKey("CD_PROG", Program_Key, 0x6897, 16);
+ addKey("CASSETTE_PLAY_BACK", Unmapped_Key, 0x58A7, 16);
+ addKey("CASSETTE_STOP", Unmapped_Key, 0xB847, 16);
+ addKey("CASSETTE_PLAY_FORWARD", Unmapped_Key, 0x9867, 16);
+ addKey("CASSETTE_REC", Record_Key, 0xF807, 16);
+ addKey("CASSETTE_TAPE_1/2", Unmapped_Key, 0x906F, 16);
+ addKey("CASSETTE_REW", Unmapped_Key, 0x38C7, 16);
+ addKey("CASSETTE_FFW", Unmapped_Key, 0xD827, 16);
+ addKey("VOLUME_DOWN", VolumeDown_Key, 0x40BF, 16);
+ addKey("VOLUME_UP", VolumeUp_Key, 0x807F, 16);
+ addKey("TUNER_BAND", Input_Key, 0xE01F, 16);
+ addKey("POWER", Power_Key, 0x00FF, 16);
+}
+
+
+HitachiVCR1::HitachiVCR1(
+ QObject *guiObject,
+ unsigned int index)
+ : PIRKeysetMetaData(
+ "VCR Keyset 1",
+ Hitachi_Make,
+ index)
+{
+ threadableProtocol = new NECProtocol(guiObject, index);
+
+ setPreData(0x06F9, 16);
+
+ addKey("Power", Power_Key, 0xE817, 16);
+ addKey("Eject", Eject_Key, 0x9C63, 16);
+ addKey("VCR/TV", Input_Key, 0x6897, 16);
+ addKey("P+", ChannelUp_Key, 0x9867, 16);
+ addKey("P-", ChannelDown_Key, 0x18E7, 16);
+ addKey("Play", Play_Key, 0x28D7, 16);
+ addKey("FF", FastForward_Key, 0x906F, 16);
+ addKey("Rew", Rewind_Key, 0x50AF, 16);
+ addKey("Stop", Stop_Key, 0xD02F, 16);
+ addKey("Pause", Pause_Key, 0x58A7, 16);
+ addKey("Step", StepForward_Key, 0x08F7, 16);
+ addKey("SpinRight", Right_Key, 0xFE01, 16);
+ addKey("SpinLeft", Left_Key, 0x7E81, 16);
+ addKey("Enter", Select_Key, 0x22DD, 16);
+ addKey("TransAux", Unmapped_Key, 0x2CD3, 16); // "AVX"
+ addKey("1", One_Key, 0xB04F, 16);
+ addKey("2", Two_Key, 0x708F, 16);
+ addKey("3", Three_Key, 0xF00F, 16);
+ addKey("4", Four_Key, 0x38C7, 16);
+ addKey("5", Five_Key, 0xB847, 16);
+ addKey("6", Six_Key, 0x7887, 16);
+ addKey("7", Seven_Key, 0xF807, 16);
+ addKey("8", Eight_Key, 0x20DF, 16);
+ addKey("9", Nine_Key, 0xA05F, 16);
+ addKey("0", Zero_Key, 0x30CF, 16);
+ addKey("Menu", Menu_Key, 0x02FD, 16);
+ addKey("Disp", Info_Key, 0x42BD, 16);
+ addKey("Index", Unmapped_Key, 0xA25D, 16);
+ addKey("SP/LP", VHSSpeed_Key, 0x0CF3, 16);
+ addKey("Count/Clock", Unmapped_Key, 0x629D, 16);
+ addKey("CLEAR", Reset_Key, 0x827D, 16); // "reset", "0000"
+ addKey("Slow", Unmapped_Key, 0x8877, 16);
+ addKey("CH1/2", Unmapped_Key, 0xA857, 16); // "CHANNEL"
+ addKey("A.DUB", Unmapped_Key, 0x34CB, 16);
+ addKey("V.DUB", Unmapped_Key, 0x5CA3, 16);
+ addKey("Tracking+", TrackingPlus_Key, 0x00FF, 16);
+ addKey("Tracking-", TrackingMinus_Key, 0x807F, 16);
+ addKey("100/ENT", PlusOneHundred_Key, 0x609F, 16);
+ addKey("-", Unmapped_Key, 0xC03F, 16);
+ addKey("+", Unmapped_Key, 0x40BF, 16);
+ addKey("GO-TO", Unmapped_Key, 0x619E, 16);
+ addKey("FRAME+", Unmapped_Key, 0xBE41, 16); // This is for jog/shuttle!
+ addKey("FRAME-", Unmapped_Key, 0x7E81, 16); // I'll get the other j/s later
+ // For more Jog/Shuttle see LIRC hitachi/VT-RM783E
+ addKey("tracking_auto", AutoTracking_Key, 0x7C83, 16);
+}
--- /dev/null
+#ifndef HITACHI_H
+#define HITACHI_H
+
+#include "pirkeysetmetadata.h"
+#include <QObject>
+
+class HitachiTV1: public PIRKeysetMetaData
+{
+public:
+ HitachiTV1(
+ QObject *guiObject,
+ unsigned int index);
+};
+
+class HitachiTV1a: public HitachiTV1
+{
+public:
+ HitachiTV1a(
+ QObject *guiObject,
+ unsigned int index);
+};
+
+class HitachiTV1b: public HitachiTV1a
+{
+public:
+ HitachiTV1b(
+ QObject *guiObject,
+ unsigned int index);
+};
+
+class HitachiTV1c: public HitachiTV1
+{
+public:
+ HitachiTV1c(
+ QObject *guiObject,
+ unsigned int index);
+};
+
+class HitachiProjector: public PIRKeysetMetaData
+{
+public:
+ HitachiProjector(
+ QObject *guiObject,
+ unsigned int index);
+};
+
+class HitachiDVD1: public PIRKeysetMetaData
+{
+public:
+ HitachiDVD1(
+ QObject *guiObject,
+ unsigned int index);
+};
+
+class HitachiAudio1: public PIRKeysetMetaData
+{
+public:
+ HitachiAudio1(
+ QObject *guiObject,
+ unsigned int index);
+};
+
+class HitachiVCR1: public PIRKeysetMetaData
+{
+public:
+ HitachiVCR1(
+ QObject *guiObject,
+ unsigned int index);
+};
+
+#endif // HITACHI_H
np->setHeaderPair(525, 6045);
np->setTrailerPulse(450);
- np->setPostData(0x000, 10);
-
// np->setMinimumRepetitions(6);
np->setFullHeadlessRepeat(true);
np->setCarrierFrequency(56000);
np->setDutyCycle(32);
+ setPostData(0x000, 10);
+
addKey("info", Info_Key, 0x0, 6);
addKey("power_on", Unmapped_Key, 0x1, 6);
addKey("power", Power_Key, 0x2, 6);
np->setTrailerPulse(600);
- np->setPreData(0xC2, 8);
+ setPreData(0xC2, 8);
addKey("power", Power_Key, 0xD0, 8);
addKey("play", Play_Key, 0x30, 8);
{
setKeysetName("VCR (alt) keyset 1b");
- NECProtocol *np = dynamic_cast<NECProtocol *>(threadableProtocol);
- np->setPreData(0xCA, 8);
+ setPreData(0xCA, 8);
}
np->setTrailerPulse(600);
np->setFullHeadlessRepeat(true);
- np->setPreData(0xC2, 8);
+ setPreData(0xC2, 8);
addKey("power", Power_Key, 0xD0, 8);
addKey("play", Play_Key, 0x30, 8);
{
setKeysetName("VCR (alt) keyset 2b");
- NECProtocol *np = dynamic_cast<NECProtocol *>(threadableProtocol);
- np->setPreData(0xCA, 8);
+ setPreData(0xCA, 8);
}
np->setTrailerPulse(600);
- np->setPreData(0xC0, 8);
+ setPreData(0xC0, 8);
addKey("Power", Power_Key, 0xE8, 8);
addKey("Vol+", VolumeUp_Key, 0x78, 8);
np->setTrailerPulse(600);
np->setFullHeadlessRepeat(true);
- np->setPreData(0xC0, 8);
+ setPreData(0xC0, 8);
addKey("Power", Power_Key, 0xE8, 8);
addKey("Vol+", VolumeUp_Key, 0x78, 8);
np->setFullHeadlessRepeat(true);
- np->setPreData(0xC9, 8);
+ setPreData(0xC9, 8);
addKey("1", One_Key, 0x84, 8);
addKey("2", Two_Key, 0x44, 8);
np->setFullHeadlessRepeat(true);
- np->setPreData(0xF1, 8);
+ setPreData(0xF1, 8);
addKey("Power", Power_Key, 0x71, 8); // "Att"
addKey("Sound", Mute_Key, 0xB1, 8); // "SCM"
np->setFullHeadlessRepeat(true);
- np->setPreData(0xF9, 8);
+ setPreData(0xF9, 8);
addKey("stop", Stop_Key, 0x8E, 8); // "CD_STOP" "stop_clear"
addKey("stop", Clear_Key, 0x8E, 8); // "CD_STOP" "stop_clear"
LG_Make,
index)
{
- NECProtocol *np = new NECProtocol(
- guiObject,
- index,
- 600, 500,
- 600, 1600,
- 107753, true);
-
- threadableProtocol = np;
+ threadableProtocol = new NECProtocol(guiObject, index);
- np->setHeaderPair(9000, 4500);
- np->setTrailerPulse(600);
- np->setRepeatPair(9000, 2250);
-
- np->setPreData(0x20DF, 16);
-
-// np->setMinimumRepetitions(2);
+ setPreData(0x20DF, 16);
addKey("power", Power_Key, 0x10EF, 16);
addKey("input", Input_Key, 0xD02F, 16);
threadableProtocol = rp;
- rp->setPreData(0x10, 5);
-
rp->setToggleBit(2);
+ setPreData(0x10, 5);
+
addKey("POWER", Power_Key, 0x0C, 8);
addKey("DRP", Unmapped_Key, 0x14, 8);
addKey("TVAV", Unmapped_Key, 0x38, 8);
np->setRepeatPair(531, 1710);
np->setRepeatNeedsHeader(true);
- np->setPreData(0x3434, 16);
+ setPreData(0x3434, 16);
// np->setMinimumRepetitions(1);
np->setRepeatPair(600, 550);
np->setRepeatNeedsHeader(true);
- np->setPreData(0xB4B4, 16);
+ setPreData(0xB4B4, 16);
// np->setMinimumRepetitions(3);
LG_Make,
index)
{
- NECProtocol *np = new NECProtocol(
- guiObject,
- index,
- 600, 550,
- 600, 1650,
- 107753, true);
-
- threadableProtocol = np;
-
- np->setHeaderPair(9000, 4500);
- np->setTrailerPulse(600);
- np->setRepeatPair(9000, 2250);
+ threadableProtocol = new NECProtocol(guiObject, index);
- np->setPreData(0x7689, 16);
+ setPreData(0x7689, 16);
addKey("power", Power_Key, 0x28D7, 16);
addKey("rew", Rewind_Key, 0x40BF, 16);
np->setTrailerPulse(300);
- np->setPreData(0xE2, 8);
-
// np->setMinimumRepetitions(1);
+ setPreData(0xE2, 8);
+
addKey("POWER", Power_Key, 0x40, 8);
addKey("0", Zero_Key, 0x90, 8);
addKey("1", One_Key, 0x00, 8);
np->setTrailerPulse(300);
- np->setPreData(0xEA, 8);
-
// np->setMinimumRepetitions(1);
+ setPreData(0xEA, 8);
+
addKey("POWER", Power_Key, 0x40, 8);
addKey("CH-", ChannelDown_Key, 0x48, 8);
addKey("CH+", ChannelUp_Key, 0x50, 8);
// np->setMinimumRepetitions(3);
- np->setPreData(0x6, 3);
+ setPreData(0x6, 3);
addKey("Power", Power_Key, 0x1A2, 12);
addKey("1", One_Key, 0x202, 12);
np->setHeaderPair(4000, 1600);
np->setTrailerPulse(400);
- np->setPreData(0x80080A86, 32);
-
// np->setMinimumRepetitions(4);
np->setCarrierFrequency(36000);
+ setPreData(0x80080A86, 32);
+
addKey("POWER", Power_Key, 0xFDBB, 16);
addKey("VOL+", VolumeUp_Key, 0x0D4B, 16);
addKey("VOL-", VolumeDown_Key, 0x4DCB, 16);
np->setHeaderPair(9148, 4424);
np->setTrailerPulse(667);
- np->setPreData(0x8156, 16);
+ setPreData(0x8156, 16);
addKey("Power", Power_Key, 0x48B7, 16);
addKey("PRG", Unmapped_Key, 0x38C7, 16);
np->setHeaderPair(3565, 1700);
np->setTrailerPulse(500);
- np->setPreData(0x40040140, 32);
+ setPreData(0x40040140, 32);
addKey("POWER", Power_Key, 0xBDFC, 16);
addKey("CH+", ChannelUp_Key, 0xEDAC, 16);
np->setHeaderPair(3500, 1700);
np->setTrailerPulse(500);
- np->setPreData(0x400401, 24);
-
// np->setMinRepeat(1);
+ setPreData(0x400401, 24);
+
addKey("POWER", Power_Key, 0x00BCBD, 24);
addKey("MUTE", Mute_Key, 0x004C4D, 24);
addKey("PICTURE", Unmapped_Key, 0x006061, 24);
np->setHeaderPair(3600, 1650);
np->setTrailerPulse(550);
- np->setPreData(0x400409, 24);
+ setPreData(0x400409, 24);
addKey("POWER", Power_Key, 0x00BCB5, 24);
addKey("PROGRAMME^", ChannelUp_Key, 0x002C25, 24);
np->setHeaderPair(3500, 1650);
np->setTrailerPulse(500);
- np->setPreData(0x40040D00, 32);
+ setPreData(0x40040D00, 32);
addKey("POWER", Power_Key, 0xBCB1, 16);
addKey("PLAY", Play_Key, 0x505D, 16);
np->setHeaderPair(4000, 1600);
np->setTrailerPulse(400);
- np->setPreData(0x40040543, 32);
-
// np->setMinimumRepetitions(1);
+ setPreData(0x40040543, 32);
+
addKey("power", Power_Key, 0xFDBB, 16);
addKey("tape", Unmapped_Key, 0x3573, 16);
addKey("1", One_Key, 0x094F, 16);
--- /dev/null
+#include "pinnacle.h"
+#include "rc5protocol.h"
+
+PinnaclePCTV1::PinnaclePCTV1(
+ QObject *guiObject,
+ unsigned int index)
+ : PIRKeysetMetaData(
+ "PCTV Keyset 1",
+ Pinnacle_Make,
+ index)
+{
+ 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);
+}
+
+
+PinnaclePCTV2::PinnaclePCTV2(
+ QObject *guiObject,
+ unsigned int index)
+ : PIRKeysetMetaData(
+ "PCTV Keyset 2",
+ Pinnacle_Make,
+ index)
+{
+ 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);
+}
+
+
+PinnaclePCTV3::PinnaclePCTV3(
+ QObject *guiObject,
+ unsigned int index)
+ : PIRKeysetMetaData(
+ "PCTV Keyset 3",
+ Pinnacle_Make,
+ index)
+{
+ 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);
+}
--- /dev/null
+#ifndef PINNACLE_H
+#define PINNACLE_H
+
+#include "pirkeysetmetadata.h"
+#include <QObject>
+
+class PinnaclePCTV1: public PIRKeysetMetaData
+{
+public:
+ PinnaclePCTV1(
+ QObject *guiObject,
+ unsigned int index);
+};
+
+class PinnaclePCTV2: public PIRKeysetMetaData
+{
+public:
+ PinnaclePCTV2(
+ QObject *guiObject,
+ unsigned int index);
+};
+
+class PinnaclePCTV3: public PIRKeysetMetaData
+{
+public:
+ PinnaclePCTV3(
+ QObject *guiObject,
+ unsigned int index);
+};
+
+#endif // PINNACLE_H
Raite_Make,
index)
{
- NECProtocol *np = new NECProtocol(
- guiObject,
- index,
- 600, 500,
- 600, 1600,
- 107823, true);
+ threadableProtocol = new NECProtocol(guiObject, index);
- threadableProtocol = np;
-
- np->setHeaderPair(9000, 4500);
- np->setTrailerPulse(600);
- np->setRepeatPair(9000, 2250);
-
- np->setPreData(0x04FB, 16);
+ setPreData(0x04FB, 16);
addKey("mute", Mute_Key, 0xC03F, 16);
addKey("1", One_Key, 0xC837, 16);
np->setHeaderPair(4000, 4000);
np->setTrailerPulse(500);
- np->setPreData(0xF, 4);
-
// np->setMinimumRepetitions(1);
+ setPreData(0xF, 4);
+
addKey("vol-left", VolumeDown_Key, 0x2E0D1, 20);
addKey("vol-right", VolumeUp_Key, 0x2F0D0, 20);
addKey("mute", Mute_Key, 0x3F0C0, 20);
np->setHeaderPair(17355, 3978);
np->setTrailerPulse(897);
- np->setPreData(0xF, 4);
+ setPreData(0xF, 4);
addKey("off", Unmapped_Key, 0x3B0C4, 20);
addKey("on", Unmapped_Key, 0x3A0C5, 20);
np->setHeaderPair(4000, 4000);
np->setTrailerPulse(500);
- np->setPreData(0x4, 4);
+ setPreData(0x4, 4);
addKey("aux1_power", Power_Key, 0x2ABD5, 20);
addKey("skip", Advance_Key, 0x53BAC, 20);
np->setHeaderPair(4000, 4000);
np->setTrailerPulse(500);
- np->setPreData(0xC, 4);
+ setPreData(0xC, 4);
addKey("aux-on-off", Power_Key, 0x3B3C4, 20);
addKey("aux-mute", Mute_Key, 0x3F3C0, 20);
np->setHeaderPair(4000, 4000);
np->setTrailerPulse(500);
- np->setPreData(0xE, 4);
-
// np->setMinimumRepetitions(1);
+ setPreData(0xE, 4);
+
addKey("vcr1-on-off", Power_Key, 0x2A1D5, 20);
addKey("vcr1-who", Unmapped_Key, 0x6119E, 20);
addKey("vcr1-ch+", ChannelUp_Key, 0x2D1D2, 20);
np->setHeaderPair(4000, 4000);
np->setTrailerPulse(500);
- np->setPreData(0xD, 4);
+ setPreData(0xD, 4);
addKey("vcr2-on-off", Power_Key, 0x2A2D5, 20);
addKey("vcr2-who", Unmapped_Key, 0x6129E, 20);
np->setHeaderPair(4000, 4000);
np->setTrailerPulse(500);
- np->setPreData(0x5, 4);
+ setPreData(0x5, 4);
addKey("dvd-on-off", Power_Key, 0x2AAD5, 20);
addKey("dvd-who", Unmapped_Key, 0x61A9E, 20);
np->setHeaderPair(4000, 4000);
np->setTrailerPulse(500);
- np->setPreData(0x7, 4);
+ setPreData(0x7, 4);
addKey("on-off", Power_Key, 0x2A8D5, 20);
addKey("who", Unmapped_Key, 0x6189E, 20); // "cc", "-"
np->setHeaderPair(525, 6045);
np->setTrailerPulse(450);
- np->setPostData(0x000, 10);
-
// np->setMinimumRepetitions(6);
np->setFullHeadlessRepeat(true);
np->setCarrierFrequency(56000);
np->setDutyCycle(32);
+ setPostData(0x000, 10);
+
addKey("info", Info_Key, 0x0, 6);
addKey("power_on", Unmapped_Key, 0x1, 6);
addKey("power", Power_Key, 0x2, 6);
Sagem_Make,
index)
{
- NECProtocol *np = new NECProtocol(
- guiObject,
- index,
- 600, 500,
- 600, 1600,
- 108000, true);
+ threadableProtocol = new NECProtocol(guiObject, index);
- threadableProtocol = np;
-
- np->setHeaderPair(9000, 4500);
- np->setTrailerPulse(600);
- np->setRepeatPair(9000, 2250);
-
-// np->setMinimumRepetitions(1);
-
- np->setPreData(0xE17A, 16);
+ setPreData(0xE17A, 16);
addKey("Power", Power_Key, 0x48B7, 16);
addKey("P+", ChannelUp_Key, 0x08F7, 16);
{
addControlledDevice(Samsung_Make, "SyncMaster 192MP", TV_Device);
addControlledDevice(Samsung_Make, "LN32C530F1FXZA", TV_Device);
+ addControlledDevice(Samsung_Make, "UE46B6000VPXZG", TV_Device); // ?
NECProtocol *np = new NECProtocol(
guiObject,
np->setHeaderPair(4500, 4500);
np->setTrailerPulse(600);
- np->setPreData(0xE0E0, 16);
+ setPreData(0xE0E0, 16);
addKey("Power", Power_Key, 0x40BF, 16);
addKey("Channel Up", ChannelUp_Key, 0x48B7, 16);
np->setHeaderPair(4500, 4500);
np->setTrailerPulse(600);
- np->setPreData(0xA0A0, 16);
+ setPreData(0xA0A0, 16);
addKey("Power", Power_Key, 0x40BF, 16);
addKey("Eject", Eject_Key, 0x04FB, 16);
np->setTrailerPulse(600);
np->setRepeatPair(9000, 4500);
- np->setPreData(0x198133F, 26);
+ setPreData(0x198133F, 26);
addKey("power", Power_Key, 0x8976, 16);
addKey("open_close", Eject_Key, 0x31CE, 16);
np->setHeaderPair(4500, 4500);
np->setTrailerPulse(600);
- np->setPreData(0xC2CA, 16);
+ setPreData(0xC2CA, 16);
addKey("1", One_Key, 0x827D, 16);
addKey("2", Two_Key, 0x42BD, 16);
np->setHeaderPair(4500, 4500);
np->setTrailerPulse(600);
- np->setPreData(0x804, 12);
+ setPreData(0x804, 12);
// np->setMinimumRepetitions(1);
QObject *guiObject,
unsigned int index)
: PIRKeysetMetaData(
- "VCR Keyset 1",
+ "VCR(/DVD) Keyset 1",
Sanyo_Make,
index)
{
addControlledDevice(Sanyo_Make, "DVW-5000", VCR_Device);
addControlledDevice(Sanyo_Make, "DVW-5000", DVD_Device);
- NECProtocol *np = new NECProtocol(
- guiObject,
- index,
- 627, 500, // values for zero
- 627, 1626, // values for one
- 108754, true); // constant-length gap
+ threadableProtocol = new NECProtocol(guiObject, index);
- threadableProtocol = np;
+ setPreData(0x8C73, 16);
- np->setHeaderPair(9000, 4500);
- np->setTrailerPulse(626);
- np->setRepeatPair(9000, 2250);
-
- np->setPreData(0x8C73, 16);
-
- // Add keys:
addKey("Power", Power_Key, 0xDA25, 16);
addKey("1", One_Key, 0x20DF, 16);
addKey("2", Two_Key, 0xA05F, 16);
}
+SanyoDVD1::SanyoDVD1(
+ QObject *guiObject,
+ unsigned int index)
+ : PIRKeysetMetaData(
+ "DVD Keyset 1",
+ Sanyo_Make,
+ index)
+{
+ addControlledDevice(Sanyo_Make, "DVD-SL25", DVD_Device);
+
+ threadableProtocol = new NECProtocol(guiObject, index);
+
+ setPreData(0x3C23, 16);
+
+ addKey("On", Power_Key, 0x00FF, 16);
+ addKey("LastMemo", Unmapped_Key, 0xF40B, 16);
+ addKey("PictureMode", PictureMode_Key, 0x5CA3, 16);
+ addKey("OpenClose", Eject_Key, 0x807F, 16);
+ addKey("ProgramRandom", Random_Key, 0x9C63, 16);
+ addKey("Repeat", Repeat_Key, 0xAC53, 16);
+ addKey("ABRepeat", Unmapped_Key, 0x6C93, 16);
+ addKey("OnScreen", Unmapped_Key, 0xC03F, 16);
+ addKey("Zoom", Unmapped_Key, 0xDC23, 16);
+ addKey("Angle", Unmapped_Key, 0x10EF, 16);
+ addKey("AngleReplay", Unmapped_Key, 0x906F, 16);
+ addKey("SubtitleChange", Unmapped_Key, 0xA05F, 16);
+ addKey("Setup", Menu_Key, 0x40BF, 16);
+ addKey("Menu", DiscMenu_Key, 0xE01F, 16);
+ addKey("SubtitleOnOff", Captions_Key, 0x52AD, 16);
+ addKey("Audio", Language_Key, 0x50AF, 16);
+ addKey("Up", Up_Key, 0xD02F, 16);
+ addKey("Down", Down_Key, 0x30CF, 16);
+ addKey("Left", Left_Key, 0xB04F, 16);
+ addKey("Right", Right_Key, 0x708F, 16);
+ addKey("Enter", Select_Key, 0xF00F, 16);
+ addKey("TopMenu", DiscTitle_Key, 0x609F, 16);
+ addKey("Return", Exit_Key, 0x08F7, 16);
+ addKey("RevSlow", StepBack_Key, 0x34CB, 16);
+ addKey("FwdSlow", StepForward_Key, 0x946B, 16);
+ addKey("PauseStep", Pause_Key, 0x04FB, 16);
+ addKey("Stop", Stop_Key, 0x7887, 16);
+ addKey("Play", Play_Key, 0xF807, 16);
+ addKey("Prev", Previous_Key, 0x44BB, 16);
+ addKey("Next", Next_Key, 0x847B, 16);
+ addKey("Rev", Rewind_Key, 0x649B, 16);
+ addKey("Fwd", FastForward_Key, 0xC43B, 16);
+ addKey("1", One_Key, 0x8877, 16);
+ addKey("2", Two_Key, 0x48B7, 16);
+ addKey("3", Three_Key, 0xC837, 16);
+ addKey("4", Four_Key, 0x28D7, 16);
+ addKey("5", Five_Key, 0xA857, 16);
+ addKey("6", Six_Key, 0x6897, 16);
+ addKey("7", Seven_Key, 0xE817, 16);
+ addKey("8", Eight_Key, 0x18E7, 16);
+ addKey("9", Nine_Key, 0x9867, 16);
+ addKey("0", Zero_Key, 0x58A7, 16);
+ addKey("Clear", Clear_Key, 0x38C7, 16);
+ addKey("SearchMode", Unmapped_Key, 0x1CE3, 16);
+}
+
+
SanyoTV1::SanyoTV1(
QObject *guiObject,
unsigned int index)
Sanyo_Make,
index)
{
- addControlledDevice(Sanyo_Make, "DP32746", TV_Device);
-
- NECProtocol *np = new NECProtocol(
- guiObject,
- index,
- 600, 1600, // zero
- 600, 500, // one
- 40000, false); // gap, not constant length
-
- threadableProtocol = np;
-
- np->setHeaderPair(9000, 4500);
- np->setTrailerPulse(600);
- np->setRepeatPair(9000, 2250);
-
- np->setPreData(0xE31C, 16);
-
- addKey("Power", Power_Key, 0xB748, 16);
-// addKey("audio_mode", Language_Key, 0xC738, 16); // might be wrong
- addKey("1", One_Key, 0x7F80, 16);
- addKey("2", Two_Key, 0xBF40, 16);
- addKey("3", Three_Key, 0x3FC0, 16);
- addKey("4", Four_Key, 0xDF20, 16);
- addKey("5", Five_Key, 0x5FA0, 16);
- addKey("6", Six_Key, 0x9F60, 16);
- addKey("7", Seven_Key, 0x1FE0, 16);
- addKey("8", Eight_Key, 0xEF10, 16);
- addKey("9", Nine_Key, 0x6F90, 16);
- addKey("0", Zero_Key, 0xFF00, 16);
- addKey("Channel Up", ChannelUp_Key, 0xAF50, 16);
- addKey("Channel Down", ChannelDown_Key, 0x2FD0, 16);
- addKey("Volume Up", VolumeUp_Key, 0x8F70, 16);
- addKey("Volume Down", VolumeDown_Key, 0x0FF0, 16);
- addKey("Mute", Mute_Key, 0xE718, 16);
- addKey("Display", Info_Key, 0xCF30, 16);
- addKey("Menu", Menu_Key, 0x17E8, 16);
-// addKey("Enter", Enter_Key, 0xA758, 16);
- addKey("Enter", Select_Key, 0xA758, 16);
- addKey("Closed Captions", Captions_Key, 0x7788, 16);
- addKey("Video Mode", Input_Key, 0x37C8, 16);
- addKey("Sleep", Sleep_Key, 0x4FB0, 16);
- addKey("Recall", PrevChannel_Key, 0x6798, 16);
- addKey("PIP", PIP_Key, 0x25DA, 16);
- addKey("Swap", PIPSwap_Key, 0x45BA, 16);
- addKey("Red", Red_Key, 0x6D92, 16);
- addKey("Green", Green_Key, 0xAD52, 16);
- addKey("Yellow", Yellow_Key, 0x2DD2, 16);
- addKey("Blue", Blue_Key, 0xCD32, 16);
- addKey("Reset", Reset_Key, 0xC738, 16);
- addKey("Menu +", Up_Key, 0x8778, 16); // menu +
- addKey("Menu -", Down_Key, 0x07F8, 16); // menu -
-// addKey("image", AspectRatio_Key, 0x7788, 16);
- addKey("Digicon", Guide_Key, 0x47B8, 16);
+ addControlledDevice(Sanyo_Make, "CTP-6791P", TV_Device);
+
+ threadableProtocol = new NECProtocol(guiObject, index);
+
+ setPreData(0x1CE3, 16);
+
+ addKey("Power", Power_Key, 0x48B7, 16);
+ addKey("audio_mode", SoundMode_Key, 0x38C7, 16); // "auto"
+ addKey("video_mode", PictureMode_Key, 0xC837, 16);
+ addKey("1", One_Key, 0x807F, 16);
+ addKey("2", Two_Key, 0x40BF, 16);
+ addKey("3", Three_Key, 0xC03F, 16);
+ addKey("4", Four_Key, 0x20DF, 16);
+ addKey("5", Five_Key, 0xA05F, 16);
+ addKey("6", Six_Key, 0x609F, 16);
+ addKey("7", Seven_Key, 0xE01F, 16);
+ addKey("8", Eight_Key, 0x10EF, 16);
+ addKey("9", Nine_Key, 0x906F, 16);
+ addKey("0", Zero_Key, 0x00FF, 16);
+ addKey("Channel Up", ChannelUp_Key, 0x50AF, 16);
+ addKey("Channel Down", ChannelDown_Key, 0xD02F, 16);
+ addKey("Volume Up", VolumeUp_Key, 0x708F, 16);
+ addKey("Volume Down", VolumeDown_Key, 0xF00F, 16);
+ addKey("Mute", Mute_Key, 0x18E7, 16);
+ addKey("Display", Info_Key, 0x30CF, 16);
+ addKey("image", AspectRatio_Key, 0x8877, 16);
+ addKey("Menu", Menu_Key, 0xE817, 16); // "setup"
+ addKey("Enter", Select_Key, 0x58A7, 16); // "F/OK"
+ addKey("Sleep", Sleep_Key, 0xB04F, 16);
+ addKey("Recall", PrevChannel_Key, 0x9867, 16);
+ addKey("PIP", PIP_Key, 0xDA25, 16);
+ addKey("Swap", PIPSwap_Key, 0xBA45, 16);
+ addKey("Red", Red_Key, 0x926D, 16);
+ addKey("Green", Green_Key, 0x52AD, 16);
+ addKey("Yellow", Yellow_Key, 0xD22D, 16);
+ addKey("Blue", Blue_Key, 0x32CD, 16);
+ addKey("Menu +", Up_Key, 0x7887, 16);
+ addKey("Menu -", Down_Key, 0xF807, 16);
+ addKey("Digicon", Guide_Key, 0xB847, 16);
+ addKey("TV", Input_Key, 0x28D7, 16); // tv/video
+}
+
+
+SanyoTV1a::SanyoTV1a(
+ QObject *guiObject,
+ unsigned int index)
+ : SanyoTV1(guiObject, index)
+{
+ setKeysetName("TV Keyset 1a");
+
+ addControlledDevice(Sanyo_Make, "28LN4-C", TV_Device);
+ addControlledDevice(Sanyo_Make, "28CN7F", TV_Device);
+ addControlledDevice(Sanyo_Make, "C21EF44", TV_Device);
+ addControlledDevice(Sanyo_Make, "C25EG64", TV_Device);
+ addControlledDevice(Sanyo_Make, "C28EH64", TV_Device);
+// addControlledDevice(Sanyo_Make, "CED3011PV", TV_Device);
+// addControlledDevice(Sanyo_Make, "CEM6011PV", TV_Device);
+// addControlledDevice(Sanyo_Make, "DP32746", TV_Device);
+
+ addKey("POWER", Power_Key, 0x38C7, 16);
+ addKey("WIDE", AspectRatio_Key, 0xC23D, 16);
+ addKey("-/--", DoubleDigit_Key, 0x50AF, 16);
+ addKey("CS", Unmapped_Key, 0xD02F, 16); // 2-
+ addKey("OSD", Info_Key, 0x18E7, 16); // "SYMBOL_1
+ addKey("NORMAL", Unmapped_Key, 0x8877, 16); // "SYMBOL_2"
+ addKey("MUTE", Mute_Key, 0xA857, 16);
+ addKey("P--P", Unmapped_Key, 0xB847, 16); // "ALTERNATE"
+ addKey("MENU", Menu_Key, 0x8A75, 16);
+ addKey("P+", ChannelUp_Key, 0x30CF, 16);
+ addKey("UP", Up_Key, 0x30CF, 16);
+ addKey("P-", ChannelDown_Key, 0xB04F, 16);
+ addKey("DOWN", Down_Key, 0xB04F, 16);
+ addKey("VOL-", VolumeDown_Key, 0xE817, 16);
+ addKey("LEFT", Left_Key, 0xE817, 16);
+ addKey("VOL+", VolumeUp_Key, 0x6897, 16);
+ addKey("RIGHT", Right_Key, 0x6897, 16);
+ addKey("CLOCK", Sleep_Key, 0x9867, 16); // "SLEEP/ON-TIMER/TEXT_CANCEL"
+ addKey("EXPAND", Unmapped_Key, 0x6A95, 16); // "SYMBOL_4" teletext
+ addKey("SHRINK", Unmapped_Key, 0x728D, 16); // "SYMBOL_5" teletext
+ addKey("TXT/TV", Unmapped_Key, 0x629D, 16); // teletext
+ addKey("A-B", Language_Key, 0x02FD, 16); //?
+}
+
+
+SanyoTV1b::SanyoTV1b(
+ QObject *guiObject,
+ unsigned int index)
+ : SanyoTV1(guiObject, index)
+{
+ setKeysetName("TV Keyset 1b");
+
+ addKey("Reset", Reset_Key, 0x38C7, 16);
+ addKey("Closed Captions", Captions_Key, 0x8877, 16);
}
-SanyoTV2::SanyoTV2(
+SanyoTV1c::SanyoTV1c(
+ QObject *guiObject,
+ unsigned int index)
+ : SanyoTV1(guiObject, index)
+{
+ setKeysetName("TV Keyset 1c");
+
+ addKey("tv/vid", Input_Key, 0xC837, 16);
+}
+
+
+SanyoTV1d::SanyoTV1d(
+ QObject *guiObject,
+ unsigned int index)
+ : SanyoTV1a(guiObject, index)
+{
+ setKeysetName("TV Keyset 1d");
+
+ addKey("prg_scan", Scan_Key, 0x08F7, 16);
+ addKey("tuning_<", ChannelDown_Key, 0xC837, 16);
+ addKey("tuning_>", ChannelUp_Key, 0x48B7, 16);
+ addKey("colour_<", Unmapped_Key, 0xD827, 16);
+ addKey("colour_>", Unmapped_Key, 0x58A7, 16);
+ addKey("bright_<", Unmapped_Key, 0xF807, 16);
+ addKey("bright_>", Unmapped_Key, 0x7887, 16);
+ addKey("contrast_<", Unmapped_Key, 0xF00F, 16);
+ addKey("contrast_>", Unmapped_Key, 0x708F, 16);
+ addKey("clear_screen", Unmapped_Key, 0x18E7, 16);
+}
+
+
+SanyoProjector::SanyoProjector(
QObject *guiObject,
unsigned int index)
: PIRKeysetMetaData(
- "TV Keyset 2",
+ "Projector Keyset 1",
Sanyo_Make,
index)
{
- NECProtocol *np = new NECProtocol(
- guiObject,
- index,
- 600, 1600,
- 600, 500,
- 40000, false);
-
- threadableProtocol = np;
-
- np->setHeaderPair(9000, 4500);
- np->setTrailerPulse(600);
- np->setRepeatPair(9000, 2250);
-
- np->setPreData(0xE31C, 16);
-
- addKey("POWER", Power_Key, 0xC738, 16);
- addKey("TV", Unmapped_Key, 0xD728, 16);
- addKey("WIDE", AspectRatio_Key, 0x3DC2, 16);
- addKey("1", One_Key, 0x7F80, 16);
- addKey("2", Two_Key, 0xBF40, 16);
- addKey("3", Three_Key, 0x3FC0, 16);
- addKey("4", Four_Key, 0xDF20, 16);
- addKey("5", Five_Key, 0x5FA0, 16);
- addKey("6", Six_Key, 0x9F60, 16);
- addKey("7", Seven_Key, 0x1FE0, 16);
- addKey("8", Eight_Key, 0xEF10, 16);
- addKey("9", Nine_Key, 0x6F90, 16);
- addKey("0", Zero_Key, 0xFF00, 16);
- addKey("-/--", DoubleDigit_Key, 0xAF50, 16);
- addKey("CS", Unmapped_Key, 0x2FD0, 16);
- addKey("SYMBOL_1", Unmapped_Key, 0xE718, 16);
- addKey("SYMBOL_2", Unmapped_Key, 0x7788, 16);
- addKey("MUTE", Mute_Key, 0x57A8, 16);
- addKey("P--P", Unmapped_Key, 0x47B8, 16);
- addKey("F/OK", Unmapped_Key, 0xA758, 16);
- addKey("MENU", Menu_Key, 0x758A, 16);
- addKey("VOL-", VolumeDown_Key, 0x17E8, 16);
- addKey("VOL+", VolumeUp_Key, 0x9768, 16);
- addKey("P+", ChannelUp_Key, 0xCF30, 16);
- addKey("P-", ChannelDown_Key, 0x4FB0, 16);
- addKey("RED", Red_Key, 0x6D92, 16);
- addKey("GREEN", Green_Key, 0xAD52, 16);
- addKey("YELLOW", Yellow_Key, 0x2DD2, 16);
- addKey("BLUE", Blue_Key, 0xCD32, 16);
- addKey("SYMBOL_3", Unmapped_Key, 0x6798, 16);
- addKey("SYMBOL_4", Unmapped_Key, 0x956A, 16);
- addKey("SYMBOL_5", Unmapped_Key, 0x8D72, 16);
- addKey("TXT/TV", Unmapped_Key, 0x9D62, 16);
- addKey("A-B", Language_Key, 0xFD02, 16);
+ addControlledDevice(Sanyo_Make, "PLV-Z1", Other_Device);
+
+ threadableProtocol = new NECProtocol(guiObject, index);
+
+ setPreData(0x0C, 8);
+
+ addKey("ONOFF0", Power_Key, 0xF300FF, 24);
+ addKey("ONOFF1", Unmapped_Key, 0x73FF00, 24);
+ addKey("AUTO_PC_ADJ", Unmapped_Key, 0xF3916E, 24);
+ addKey("MENU", Menu_Key, 0xF338C7, 24);
+ addKey("SCREEN", Unmapped_Key, 0xF341BE, 24);
+ addKey("INPUT", Input_Key, 0xF3A05F, 24);
+ addKey("IMAGE", Unmapped_Key, 0xF330CF, 24);
+ addKey("AUTO", Unmapped_Key, 0xF3FC03, 24);
+ addKey("COMPOSITE", Unmapped_Key, 0xF3BC43, 24);
+ addKey("S-VIDEO", Unmapped_Key, 0xF37C83, 24);
+ addKey("COMPONENT", Unmapped_Key, 0xF3C13E, 24);
+ addKey("NOSHOW", Unmapped_Key, 0xF3D12E, 24);
+ addKey("KEYSTONE_UP", Unmapped_Key, 0xF3718E, 24);
+ addKey("KEYSTONE_DOWN", Unmapped_Key, 0xF3F10E, 24);
+ addKey("IMAGE_1", One_Key, 0xF30AF5, 24);
+ addKey("IMAGE_2", Two_Key, 0xF38A75, 24);
+ addKey("IMAGE_3", Three_Key, 0xF36A95, 24);
+ addKey("IMAGE_4", Four_Key, 0xF3EA15, 24);
+ addKey("SELECT", Select_Key, 0xF3F00F, 24);
+ addKey("LEFT", Left_Key, 0xF37887, 24);
+ addKey("RIGHT", Right_Key, 0xF3B847, 24);
+ addKey("UP", Up_Key, 0xF331CE, 24);
+ addKey("DOWN", Down_Key, 0xF3B14E, 24);
}
+
unsigned int index);
};
+class SanyoDVD1: public PIRKeysetMetaData
+{
+public:
+ SanyoDVD1(
+ QObject *guiObject,
+ unsigned int index);
+};
+
class SanyoTV1: public PIRKeysetMetaData
{
public:
unsigned int index);
};
-class SanyoTV2: public PIRKeysetMetaData
+class SanyoTV1a: public SanyoTV1
+{
+public:
+ SanyoTV1a(
+ QObject *guiObject,
+ unsigned int index);
+};
+
+class SanyoTV1b: public SanyoTV1
+{
+public:
+ SanyoTV1b(
+ QObject *guiObject,
+ unsigned int index);
+};
+
+class SanyoTV1c: public SanyoTV1
+{
+public:
+ SanyoTV1c(
+ QObject *guiObject,
+ unsigned int index);
+};
+
+class SanyoTV1d: public SanyoTV1a
+{
+public:
+ SanyoTV1d(
+ QObject *guiObject,
+ unsigned int index);
+};
+
+class SanyoProjector: public PIRKeysetMetaData
{
public:
- SanyoTV2(
+ SanyoProjector(
QObject *guiObject,
unsigned int index);
};
threadableProtocol = np;
+ np->setElevenBitToggle(true);
+
np->setTrailerPulse(350);
// np->setMinimumRepetitions(1);
threadableProtocol = np;
+ np->setElevenBitToggle(true);
+
np->setTrailerPulse(400);
// np->setMinimumRepetitions(1);
threadableProtocol = np;
+ np->setElevenBitToggle(true);
+
np->setTrailerPulse(350);
// np->setMinimumRepetitions(9);
np->setHeaderPair(2400, 600);
- np->setPostData(0xC, 6);
-
// np->setMinimumRepetitions(2);
+ setPostData(0xC, 6);
+
addKey("VIDEO1", Unmapped_Key, 0x22, 7);
addKey("VIDEO2", Unmapped_Key, 0x3C, 7);
addKey("VIDEO3", Unmapped_Key, 0x21, 7);
np->setHeaderPair(2412, 588);
- np->setPostData(0x7, 4);
+ setPostData(0x7, 4);
addKey("PLAY", Play_Key, 0x59, 7);
addKey("STOP", Stop_Key, 0x71, 7);
np->setHeaderPair(2400, 600);
np->setTrailerPulse(1200);
- np->setPostData(0x08, 5);
-
// np->setMinimumRepetitions(2);
+ setPostData(0x08, 5);
+
addKey("|<<", Previous_Key, 0x03, 6);
addKey(">>|", Next_Key, 0x23, 6);
addKey("<<", Rewind_Key, 0x33, 6);
np->setHeaderPair(2400, 600);
- np->setPostData(0x07, 5);
-
// np->setMinimumRepetitions(2);
np->setCarrierFrequency(40000);
+ setPostData(0x07, 5);
+
addKey("1", One_Key, 0x00, 7);
addKey("2", Two_Key, 0x40, 7);
addKey("3", Three_Key, 0x20, 7);
Toshiba_Make,
index)
{
- NECProtocol *np = new NECProtocol(
- guiObject,
- index,
- 600, 539,
- 600, 1672,
- 108000, true);
+ threadableProtocol = new NECProtocol(guiObject, index);
- threadableProtocol = np;
-
- np->setHeaderPair(9000, 4500);
- np->setTrailerPulse(600);
- np->setRepeatPair(9000, 2250);
-
- np->setPreData(0x02FD, 16);
+ setPreData(0x02FD, 16);
addKey("POWER", Power_Key, 0x48B7, 16);
addKey("1", One_Key, 0x807F, 16);
Toshiba_Make,
index)
{
- NECProtocol *np = new NECProtocol(
- guiObject,
- index,
- 600, 525,
- 600, 1650,
- 108000, true);
-
- threadableProtocol = np;
+ threadableProtocol = new NECProtocol(guiObject, index);
- np->setHeaderPair(9000, 4500);
- np->setTrailerPulse(600);
- np->setRepeatPair(9000, 2250);
-
- np->setPreData(0x22DD, 16);
+ setPreData(0x22DD, 16);
addKey("power", Power_Key, 0x48B7, 16);
addKey("1", One_Key, 0x807F, 16);
Toshiba_Make,
index)
{
- NECProtocol *np = new NECProtocol(
- guiObject,
- index,
- 600, 539,
- 600, 1672,
- 108000, true);
-
- threadableProtocol = np;
-
- np->setHeaderPair(9000, 4500);
- np->setTrailerPulse(600);
- np->setRepeatPair(9000, 2250);
+ threadableProtocol = new NECProtocol(guiObject, index);
- np->setPreData(0xA25D, 16);
+ setPreData(0xA25D, 16);
addKey("power", Power_Key, 0x48B7, 16);
addKey("1", One_Key, 0x807F, 16);
np->setHeaderPair(9000, 4500);
np->setTrailerPulse(600);
- np->setPreData(0x807F, 16);
+ setPreData(0x807F, 16);
addKey("KEY_1", One_Key, 0x8877, 16);
addKey("KEY_2", Two_Key, 0x48B7, 16);
Yamaha_Make,
index)
{
- NECProtocol *np = new NECProtocol(
- guiObject,
- index,
- 600, 500,
- 600, 1600,
- 107782, true);
+ threadableProtocol = new NECProtocol(guiObject, index);
- threadableProtocol = np;
-
- np->setHeaderPair(9000, 4500);
- np->setTrailerPulse(600);
-
-// np->setMinimumRepetitions(3);
-
- np->setPreData(0x3EC1, 16);
+ setPreData(0x3EC1, 16);
addKey("title", DiscTitle_Key, 0x8D72, 16);
addKey("menu", DiscMenu_Key, 0x4DB2, 16);
Yamaha_Make,
index)
{
- NECProtocol *np = new NECProtocol(
- guiObject,
- index,
- 600, 500,
- 600, 1600,
- 107823, true);
+ threadableProtocol = new NECProtocol(guiObject, index);
- threadableProtocol = np;
-
- np->setHeaderPair(9000, 4500);
- np->setTrailerPulse(600);
- np->setRepeatPair(9000, 2250);
-
- np->setPreData(0x9E61, 16);
+ setPreData(0x9E61, 16);
addKey("SYNCHRO", Unmapped_Key, 0x1AE5, 16); // "DIRECT_OUT"
addKey("DIMMER", Unmapped_Key, 0x7887, 16); // "MODE"
Yamaha_Make,
index)
{
- NECProtocol *np = new NECProtocol(
- guiObject,
- index,
- 600, 500,
- 600, 1600,
- 107500, true);
-
- threadableProtocol = np;
+ threadableProtocol = new NECProtocol(guiObject, index);
- np->setHeaderPair(9000, 4500);
- np->setTrailerPulse(600);
- np->setRepeatPair(9000, 2250);
-
-// np->setMinimumRepetitions(1);
-
- np->setPreData(0x5EA1, 16);
+ setPreData(0x5EA1, 16);
addKey("Power", Power_Key, 0xF807, 16); // "STANDBY"
addKey("mute", Mute_Key, 0x38C7, 16); // "-20DB"
Yamaha_Make,
index)
{
- NECProtocol *np = new NECProtocol(
- guiObject,
- index,
- 600, 500,
- 600, 1600,
- 38500, false);
-
- threadableProtocol = np;
+ threadableProtocol = new NECProtocol(guiObject, index);
- np->setHeaderPair(9000, 4500);
- np->setTrailerPulse(600);
- np->setRepeatPair(9000, 2250);
-
- np->setPreData(0xFE01, 16);
+ setPreData(0xFE01, 16);
addKey("PLAY", Play_Key, 0x00FF, 16);
addKey("STOP", Stop_Key, 0xC03F, 16);
Yamaha_Make,
index)
{
- NECProtocol *np = new NECProtocol(
- guiObject,
- index,
- 600, 500,
- 600, 1600,
- 50000, false);
-
- threadableProtocol = np;
+ threadableProtocol = new NECProtocol(guiObject, index);
- np->setHeaderPair(9000, 4500);
- np->setTrailerPulse(600);
- np->setRepeatPair(9000, 2250);
-
- np->setPreData(0x857A, 16);
+ setPreData(0x857A, 16);
addKey("CD_PLAY", Play_Key, 0xF708, 16);
addKey("CD_PAUSE/STOP", Pause_Key, 0xF609, 16);
Yamaha_Make,
index)
{
- NECProtocol *np = new NECProtocol(
- guiObject,
- index,
- 600, 500,
- 600, 1600,
- 40000, false);
-
- threadableProtocol = np;
-
- np->setHeaderPair(9000, 4500);
- np->setTrailerPulse(600);
+ threadableProtocol = new NECProtocol(guiObject, index);
- np->setPreData(0xA25D, 16);
+ setPreData(0xA25D, 16);
addKey("Power", Power_Key, 0x48B7, 16);
addKey("Rewind", Rewind_Key, 0x9867, 16);
Yamaha_Make,
index)
{
- NECProtocol *np = new NECProtocol(
- guiObject,
- index,
- 600, 500,
- 600, 1600,
- 40000, false);
+ threadableProtocol = new NECProtocol(guiObject, index);
- threadableProtocol = np;
-
- np->setHeaderPair(9000, 4500);
- np->setTrailerPulse(600);
- np->setRepeatPair(9000, 2250);
-
- np->setPreData(0x8B74, 16);
+ setPreData(0x8B74, 16);
addKey("A/B/C/D/E", Unmapped_Key, 0xB04F, 16);
addKey("1", One_Key, 0x708F, 16);
Yamaha_Make,
index)
{
- NECProtocol *np = new NECProtocol(
- guiObject,
- index,
- 600, 500,
- 600, 1600,
- 40000, false);
-
- threadableProtocol = np;
+ threadableProtocol = new NECProtocol(guiObject, index);
- np->setHeaderPair(9000, 4500);
- np->setTrailerPulse(600);
- np->setRepeatPair(9000, 2250);
-
- np->setPreData(0x1EE1, 16);
+ setPreData(0x1EE1, 16);
addKey("1", One_Key, 0x8877, 16);
addKey("2", Two_Key, 0x48B7, 16);
Yamaha_Make,
index)
{
- NECProtocol *np = new NECProtocol(
- guiObject,
- index,
- 600, 500,
- 600, 1600,
- 41609, false);
-
- threadableProtocol = np;
-
- np->setHeaderPair(9000, 4500);
- np->setTrailerPulse(600);
- np->setRepeatPair(9000, 2250);
+ threadableProtocol = new NECProtocol(guiObject, index);
- np->setPreData(0x20DF, 16);
+ setPreData(0x20DF, 16);
addKey("1", One_Key, 0x8877, 16);
addKey("2", Two_Key, 0x48B7, 16);
Yamaha_Make,
index)
{
- NECProtocol *np = new NECProtocol(
- guiObject,
- index,
- 600, 500,
- 600, 1600,
- 40000, false);
-
- threadableProtocol = np;
-
- np->setHeaderPair(9000, 4500);
- np->setTrailerPulse(600);
- np->setRepeatPair(9000, 2250);
+ threadableProtocol = new NECProtocol(guiObject, index);
- np->setPreData(0xDE21, 16);
+ setPreData(0xDE21, 16);
addKey("POWER", Power_Key, 0x01FE, 16);
addKey("VOL+", VolumeUp_Key, 0x41BE, 16);
{
addControlledDevice(Zenith_Make, "C32V37", TV_Device);
- NECProtocol *np = new NECProtocol(
- guiObject,
- index,
- 581, 528,
- 581, 1663,
- 106773, true);
+ threadableProtocol = new NECProtocol(guiObject, index);
- threadableProtocol = np;
-
- np->setHeaderPair(9000, 4500);
- np->setTrailerPulse(581);
- np->setRepeatPair(9000, 2250);
-
- np->setPreData(0x20DF, 16);
+ setPreData(0x20DF, 16);
addKey("power", Power_Key, 0x10EF, 16);
addKey("tv/video", Input_Key, 0xD02F, 16);
extern bool commandInFlight;
extern QMutex commandIFMutex;
+// The official NEC protocol, as I understand it, has the following attributes:
+// A "zero" is encoded with a 560 usec pulse, 560 usec space.
+// A "one" is encoded with a 560 usec pulse, and 3*560 (1680) usec space.
+// The header is a 9000 usec pulse, 4500 usec space.
+// Commands end with a trailing 560 usec pulse.
+// A repeat block is a 9000 usec pulse, 2250 usec space, then trailing pulse.
+// Each command runs for 110000 usec before another can be executed.
+
+// For standard NEC, use this constructor:
+NECProtocol::NECProtocol(
+ QObject *guiObject,
+ unsigned int index)
+ : PIRProtocol(guiObject, index, 110000, true),
+ zeroPulse(560),
+ zeroSpace(560),
+ onePulse(560),
+ oneSpace(1680),
+ headerPulse(9000),
+ headerSpace(4500),
+ hasHeaderPair(true),
+ trailerPulse(560),
+ hasTrailerPulse(true),
+ repeatPulse(9000),
+ repeatSpace(2250),
+ hasRepeatPair(true),
+ repeatNeedsHeader(false),
+ fullHeadlessRepeat(false),
+ elevenBitToggle(false)
+{
+}
+
+// For non-standard NEC, use this constructor:
NECProtocol::NECProtocol(
QObject *guiObject,
unsigned int index,
zeroSpace(zSpace),
onePulse(oPulse),
oneSpace(oSpace),
- hasTrailerPulse(false),
hasHeaderPair(false),
+ hasTrailerPulse(false),
hasRepeatPair(false),
repeatNeedsHeader(false),
- fullHeadlessRepeat(false)
+ fullHeadlessRepeat(false),
+ elevenBitToggle(false)
{
}
fullHeadlessRepeat = flag;
}
-void NECProtocol::setPreData(
- unsigned long data,
- unsigned int bits)
-{
- appendToBitSeq(preData, data, bits);
-}
-
-void NECProtocol::setPostData(
- unsigned long data,
- unsigned int bits)
+void NECProtocol::setElevenBitToggle(
+ bool flag)
{
- appendToBitSeq(postData, data, bits);
+ elevenBitToggle = flag;
}
void NECProtocol::startSendingCommand(
{
commandDuration = generateHeadlessCommand((*i).second, rx51device);
}
+ else if (elevenBitToggle && (repeatCount % 2))
+ {
+ commandDuration = generateToggledCommand((*i).second, rx51device);
+ }
else
{
commandDuration = generateStandardCommand((*i).second, rx51device);
}
+// NOTE! The following is a special command to toggle the last eleven bits
+// of the fifteen-bit commands used by Denon, Sharp, and a few others. It
+// assumes the command sequence will contain all fifteen bits. If this
+// is not the case, it will work incorrectly!
+int NECProtocol::generateToggledCommand(
+ const CommandSequence &bits,
+ PIRRX51Hardware &rx51device)
+{
+ int duration = 0;
+
+ CommandSequence::const_iterator i = bits.begin();
+
+ int bitcount = 0;
+ // First 4 bits:
+ while ((bitcount < 4) && (i != bits.end()))
+ {
+ if (*i)
+ {
+ // Send pulse for "one":
+ rx51device.addPair(onePulse, oneSpace);
+ duration += (onePulse + oneSpace);
+ }
+ else
+ {
+ // Send pulse for "zero":
+ rx51device.addPair(zeroPulse, zeroSpace);
+ duration += (zeroPulse + zeroSpace);
+ }
+ ++i;
+ ++bitcount;
+ }
+
+ // Now, invert the last eleven bits:
+ while (i != bits.end())
+ {
+ if (*i)
+ {
+ // Send pulse for "zero":
+ rx51device.addPair(zeroPulse, zeroSpace);
+ duration += (zeroPulse + zeroSpace);
+ }
+ else
+ {
+ // Send pulse for "one":
+ rx51device.addPair(onePulse, oneSpace);
+ duration += (onePulse + oneSpace);
+ }
+ ++i;
+ }
+
+ // Add trail on end:
+ if (hasTrailerPulse)
+ {
+ rx51device.addSingle(trailerPulse);
+ duration += trailerPulse;
+ }
+
+ return duration;
+}
+
+
int NECProtocol::pushBits(
const CommandSequence &bits,
PIRRX51Hardware &rx51device)
// command and the start of the next, and others specify each command be
// started at a precise interval (so the spacing between the end of one
// and the start of another may vary).
+
+ // Constructor for standard NEC:
+ NECProtocol(
+ QObject *guiObject,
+ unsigned int index);
+
+ // Constructor for non-standard NEC:
NECProtocol(
QObject *guiObject,
unsigned int index,
unsigned int pulse,
unsigned int space);
- void setPreData(
- unsigned long data,
- unsigned int bits);
-
- void setPostData(
- unsigned long data,
- unsigned int bits);
-
void setRepeatNeedsHeader(
bool flag);
void setFullHeadlessRepeat(
bool flag);
+ void setElevenBitToggle(
+ bool flag);
+
public slots:
void startSendingCommand(
unsigned int threadableID,
unsigned int onePulse;
unsigned int oneSpace;
+ // Some administrative data that most NEC Protocol remotes have:
+ unsigned int headerPulse;
+ unsigned int headerSpace;
+ bool hasHeaderPair;
+
// A tailing on-request, not followed by a specific off time:
unsigned int trailerPulse;
bool hasTrailerPulse;
// Each remote key has a unique command sequence:
// KeyCommandMap commands;
- // Some administrative data that most NEC Protocol remotes have:
- unsigned int headerPulse;
- unsigned int headerSpace;
- bool hasHeaderPair;
-
- // More administrative data wrapped around the actual command:
- CommandSequence preData;
- CommandSequence postData;
-
// A pulse that means "repeat the last command":
unsigned int repeatPulse;
unsigned int repeatSpace;
bool hasRepeatPair;
bool repeatNeedsHeader; // Put the header ahead of the repeat pulse
bool fullHeadlessRepeat; // Repeat full command but without header
+ bool elevenBitToggle; // A few remotes toggle the last eleven bits on repeat
int generateStandardCommand(
const CommandSequence &bits,
int generateRepeatCommand(
PIRRX51Hardware &device);
+ int generateToggledCommand(
+ const CommandSequence &bits,
+ PIRRX51Hardware &device);
+
int pushBits(
const CommandSequence &bits,
PIRRX51Hardware &device);
pirdevicetypenames.cpp \
keysets/raite.cpp \
keysets/sagem.cpp \
- keysets/yamaha.cpp
+ keysets/yamaha.cpp \
+ keysets/hitachi.cpp \
+ keysets/denon.cpp \
+ keysets/pinnacle.cpp
HEADERS += mainwindow.h \
pirkeynames.h \
necprotocol.h \
pirdevicetypenames.h \
keysets/raite.h \
keysets/sagem.h \
- keysets/yamaha.h
+ keysets/yamaha.h \
+ keysets/hitachi.h \
+ keysets/denon.h \
+ keysets/pinnacle.h
FORMS += mainwindow.ui \
pirdocumentationform.ui \
piraboutform.ui \
www/PierogiIcon.png \
www/SelectKeysetWindow.png \
www/UtilityTab.png \
- qtc_packaging/debian_fremantle/postrm
+ qtc_packaging/debian_fremantle/postrm.needsfixing
RESOURCES += \
PierogiResources.qrc
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE QtCreatorProject>
-<!-- Written by Qt Creator 2.4.0, 2012-01-19T19:30:41. -->
+<!-- Written by Qt Creator 2.4.0, 2012-01-23T09:52:06. -->
<qtcreator>
<data>
<variable>ProjectExplorer.Project.ActiveTarget</variable>
<value type="QString" key="ProjectExplorer.ProcessStep.Arguments">dpkg-buildpackage -sa -S -uc -us</value>
<value type="QString" key="ProjectExplorer.ProcessStep.Command">/Users/john/QtSDK/Maemo/4.6.2/bin/mad</value>
<value type="bool" key="ProjectExplorer.ProcessStep.Enabled">false</value>
- <value type="QString" key="ProjectExplorer.ProcessStep.WorkingDirectory">/Users/john/Develop/n900/pierogi-0.1.4</value>
+ <value type="QString" key="ProjectExplorer.ProcessStep.WorkingDirectory">/Users/john/Develop/n900/pierogi-0.1.5</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" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">MaemoMountAndInstallDeployStep</value>
<valuelist type="QVariantList" key="Qt4ProjectManager.MaemoRunConfiguration.LastDeployedFiles">
+ <value type="QString">/Users/john/Develop/n900/pierogi-build-maemo-Qt_for_Fremantle_PR1_3_Devices__Qt_SDK__Release/pierogi_0_1_5_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_4_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_3_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_2_armel.deb</value>
<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">192.168.0.15</value>
<value type="QString">localhost</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>
</valuelist>
<valuelist type="QVariantList" key="Qt4ProjectManager.MaemoRunConfiguration.LastDeployedTimes">
- <value type="QDateTime">2012-01-18T19:44:56</value>
+ <value type="QDateTime">2012-01-23T09:47:37</value>
+ <value type="QDateTime">2012-01-19T22:18:07</value>
<value type="QDateTime">2012-01-17T13:21:05</value>
<value type="QDateTime">2012-01-17T12:19:28</value>
<value type="QDateTime">2012-01-17T00:15:23</value>
devices[DVD_Device] = "DVD";
devices[Audio_Device] = "Audio";
devices[Computer_Device] = "Computer";
+ devices[Other_Device] = "Other";
}
const char *PIRDeviceTypeMgr::getDeviceString(
VCR_Device,
DVD_Device,
Audio_Device,
- Computer_Device
+ Computer_Device,
+ Other_Device
};
typedef std::set<PIRDeviceTypeName> PIRDeviceTypeCollection;
Advance_Key,
Replay_Key,
Eject_Key,
+ Random_Key,
+ Repeat_Key,
// Menu control:
Menu_Key,
Up_Key,
#include "pirkeysetmanager.h"
#include "pirkeysetmetadata.h"
#include "keysets/apple.h"
+#include "keysets/denon.h"
#include "keysets/ei.h"
#include "keysets/goldstar.h"
#include "keysets/hauppauge.h"
+#include "keysets/hitachi.h"
#include "keysets/jvc.h"
#include "keysets/lg.h"
#include "keysets/mitsubishi.h"
#include "keysets/nokia.h"
#include "keysets/panasonic.h"
+#include "keysets/pinnacle.h"
#include "keysets/raite.h"
#include "keysets/rca.h"
#include "keysets/sagem.h"
#include "keysets/westinghouse.h"
#include "keysets/yamaha.h"
#include "keysets/zenith.h"
-//#include "protocol.h"
#include "pirmakenames.h"
#include "pirexception.h"
#include <QObject>
-//#include <QMetaType>
// I'll be handling the threading of the keyset commands in this object:
#include <QMutex>
// Create the keysets. Ugly! This needs to be worked on!
populateKeyset(new AppleWhiteRemote(guiObject, counter++));
+ populateKeyset(new DenonDVD1(guiObject, counter++));
+ populateKeyset(new DenonDVD2(guiObject, counter++));
+ populateKeyset(new DenonDVD3(guiObject, counter++));
+ populateKeyset(new DenonReceiver1(guiObject, counter++));
+ populateKeyset(new DenonReceiver1a(guiObject, counter++));
+ populateKeyset(new DenonReceiver1b(guiObject, counter++));
+ populateKeyset(new DenonReceiver1c(guiObject, counter++));
+ populateKeyset(new DenonReceiver2(guiObject, counter++));
+ populateKeyset(new DenonReceiver2a(guiObject, counter++));
+ populateKeyset(new DenonReceiver3(guiObject, counter++));
+ populateKeyset(new DenonReceiver3a(guiObject, counter++));
+ populateKeyset(new DenonReceiver4(guiObject, counter++));
+ populateKeyset(new DenonReceiver5(guiObject, counter++));
+ populateKeyset(new DenonAudio1(guiObject, counter++));
+ populateKeyset(new DenonAudio1a(guiObject, counter++));
+ populateKeyset(new DenonAudio1b(guiObject, counter++));
+ populateKeyset(new DenonAudio1c(guiObject, counter++));
+ populateKeyset(new DenonAudio1d(guiObject, counter++));
+ populateKeyset(new DenonAudio2(guiObject, counter++));
+ populateKeyset(new DenonAudio3(guiObject, counter++));
+ populateKeyset(new DenonAudio4(guiObject, counter++));
+ populateKeyset(new DenonAudio5(guiObject, counter++));
+
populateKeyset(new EiKeyset(guiObject, counter++));
populateKeyset(new GoldStarTV1(guiObject, counter++));
populateKeyset(new GoldStarVCR1d(guiObject, counter++));
populateKeyset(new GoldStarCD1(guiObject, counter++));
- populateKeyset(new HauppaugeGeneric(guiObject, counter++));
- populateKeyset(new HauppaugeTV1(guiObject, counter++));
+ populateKeyset(new HauppaugePCTV1(guiObject, counter++));
+ populateKeyset(new HauppaugePCTV1a(guiObject, counter++));
+ populateKeyset(new HauppaugePCTV1b(guiObject, counter++));
+ populateKeyset(new HauppaugePCTV1c(guiObject, counter++));
+ populateKeyset(new HauppaugePCTV2(guiObject, counter++));
populateKeyset(new JVCSat1(guiObject, counter++));
populateKeyset(new JVCSat2(guiObject, counter++));
populateKeyset(new PanasonicAudio1(guiObject, counter++));
populateKeyset(new PanasonicAudio1a(guiObject, counter++));
+ populateKeyset(new PinnaclePCTV1(guiObject, counter++));
+ populateKeyset(new PinnaclePCTV2(guiObject, counter++));
+ populateKeyset(new PinnaclePCTV3(guiObject, counter++));
+
populateKeyset(new RaiteDVD1(guiObject, counter++));
populateKeyset(new RCATV1(guiObject, counter++));
populateKeyset(new SamsungDVD2(guiObject, counter++));
populateKeyset(new SamsungAC1(guiObject, counter++));
- populateKeyset(new SanyoTV1(guiObject, counter++));
- populateKeyset(new SanyoTV2(guiObject, counter++));
populateKeyset(new SanyoVCR1(guiObject, counter++));
+ populateKeyset(new SanyoDVD1(guiObject, counter++));
+ populateKeyset(new SanyoTV1(guiObject, counter++));
+ populateKeyset(new SanyoTV1a(guiObject, counter++));
+ populateKeyset(new SanyoTV1b(guiObject, counter++));
+ populateKeyset(new SanyoTV1c(guiObject, counter++));
+ populateKeyset(new SanyoTV1d(guiObject, counter++));
+ populateKeyset(new SanyoProjector(guiObject, counter++));
populateKeyset(new SharpTV1(guiObject, counter++));
populateKeyset(new SharpTV1a(guiObject, counter++));
}
+void PIRKeysetMetaData::setPreData(
+ unsigned long data,
+ unsigned int bits)
+{
+ threadableProtocol->setPreData(data, bits);
+}
+
+
+void PIRKeysetMetaData::setPostData(
+ unsigned long data,
+ unsigned int bits)
+{
+ threadableProtocol->setPostData(data, bits);
+}
+
+
PIRMakeName PIRKeysetMetaData::getMake()
{
return make;
unsigned long data,
unsigned int bits);
+ void setPreData(
+ unsigned long data,
+ unsigned int bits);
+
+ void setPostData(
+ unsigned long data,
+ unsigned int bits);
+
KeyCollection keys;
DeviceCollection controlledDevices;
{
makes[Any_Make] = "Any";
makes[Apple_Make] = "Apple";
+ makes[Denon_Make] = "Denon";
makes[Ei_Make] = "Ei";
makes[GoldStar_Make] = "GoldStar";
makes[Hauppauge_Make] = "Hauppauge";
+ makes[Hitachi_Make] = "Hitachi";
makes[JVC_Make] = "JVC";
makes[LG_Make] = "LG";
makes[Mitsubishi_Make] = "Mitsubishi";
makes[Nokia_Make] = "Nokia";
- makes[Philips_Make] = "Philips";
makes[Panasonic_Make] = "Panasonic";
+ makes[Philips_Make] = "Philips";
+ makes[Pinnacle_Make] = "Pinnacle Systems";
makes[Raite_Make] = "Raite";
makes[RCA_Make] = "RCA";
makes[Sagem_Make] = "Sagem";
enum PIRMakeName{
Any_Make,
Apple_Make,
+ Denon_Make,
Ei_Make,
GoldStar_Make,
Hauppauge_Make,
+ Hitachi_Make,
JVC_Make,
LG_Make,
Mitsubishi_Make,
Nokia_Make,
Panasonic_Make,
Philips_Make,
+ Pinnacle_Make,
Raite_Make,
RCA_Make,
Sagem_Make,
unsigned long command,
unsigned int bits)
{
+ // First, if key already exists, clear it out:
+ KeycodeCollection::iterator i = keycodes.find(key);
+ if (i != keycodes.end())
+ {
+ i->second.clear();
+ }
+
appendToBitSeq(keycodes[key], command, bits);
}
}
+void PIRProtocol::setPreData(
+ unsigned long data,
+ unsigned int bits)
+{
+ // If the container is not empty, first clear it out:
+ if (!preData.empty())
+ {
+ preData.clear();
+ }
+
+ appendToBitSeq(preData, data, bits);
+}
+
+
+void PIRProtocol::setPostData(
+ unsigned long data,
+ unsigned int bits)
+{
+ // If the container is not empty, first clear it out:
+ if (!postData.empty())
+ {
+ postData.clear();
+ }
+
+ appendToBitSeq(postData, data, bits);
+}
+
+
bool PIRProtocol::isCommandSupported(
PIRKeyName command)
{
void setMinimumRepetitions(
unsigned int minrep);
+ void setPreData(
+ unsigned long data,
+ unsigned int bits);
+
+ void setPostData(
+ unsigned long data,
+ unsigned int bits);
+
public slots:
virtual void startSendingCommand(
unsigned int threadableID,
bool isConstantLength;
int gap;
+ // More administrative data wrapped around the actual command:
+ CommandSequence preData;
+ CommandSequence postData;
+
// Some remotes require a minimum number of repetitions:
+ // Note: thinking about removing this -- don't know if it is needed
int minimumRepetitions;
unsigned int id;
</sizepolicy>
</property>
<property name="text">
- <string>Make</string>
+ <string>Make:</string>
</property>
</widget>
</item>
+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.
+
+ -- John Pietrzak <jpietrzak8@gmail.com> Mon, 23 Jan 2012 09:50:25 -0500
+
+pierogi (0.1.5) unstable; urgency=low
+ * Fixed a design flaw allowing user to queue up unlimited number of commands.
+
+ -- John Pietrzak <jpietrzak8@gmail.com> Fri, 20 Jan 2012 00:00:29 -0500
+
pierogi (0.1.4) unstable; urgency=low
* I think uninstall is working now. So, Initial Release time!
+++ /dev/null
-#!/bin/sh
-
-rm -f /etc/sudoers.d/pierogi.sudoers
-
-update-sudoers
-
-exit 0
--- /dev/null
+#!/bin/sh
+
+rm -f /etc/sudoers.d/pierogi.sudoers
+
+update-sudoers
+
+exit 0
}
-void RC5Protocol::setPreData(
- unsigned long data,
- unsigned int bits)
-{
- appendToBitSeq(preData, data, bits);
-}
-
-
void RC5Protocol::setToggleBit(
unsigned int bit)
{
#include "pirrx51hardware.h"
//
-// The RC5 protocol is apparently quite a bit older than the NEC protocol, but
-// not as widespread. Still, it continues to be in use, as I've seen
-// by my Elgato "Eye TV" remote control.
+// The RC5 protocol is not as widespread as the NEC protocol, but still
+// somewhat popular. Philips, the inventor, uses it extensively.
//
class RC5Protocol: public PIRProtocol
unsigned int pulse,
unsigned int space);
- void setPreData(
- unsigned long data,
- unsigned int bits);
-
void setToggleBit(
unsigned int bit);
unsigned int headerSpace;
bool hasHeaderPair;
- CommandSequence preData;
-// CommandSequence postData;
-
-// int trail;
-
// 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.
<img src="MediaTab.png">
<p>Many of the most important playback commands are represented on this tab.
-Play, pause, and stop are the most common ones, along with "Reverse" (often
-called "Rewind") and Fast Forward. A variety of other less common navigation
-controls are included, along with the "eject" command.</p>
+"Play", "Pause", and "Stop" are the most common ones, along with "Reverse"
+(often called rewind) and "Fast Forward". A variety of other less common
+navigation controls are included, along with the "Eject" command.</p>
<h3>Misc Tab</h3>
projects / pierogi / commitdiff