From 65325fe0f89de8a3070915633aed961f27536777 Mon Sep 17 00:00:00 2001 From: John Pietrzak Date: Sat, 11 Feb 2012 18:14:58 -0500 Subject: [PATCH] Moved Mute button, lots new keysets Due to popular demand, the Mute button has been moved up to the main page. Also, lots of new keysets: Admiral, Daewoo, Grundig, Logitech, Philco, Roku, and Topfield. These all need to be tested! --- keysets/admiral.cpp | 88 +++++ keysets/admiral.h | 24 ++ keysets/daewoo.cpp | 286 ++++++++++++++++ keysets/daewoo.h | 48 +++ keysets/grundig.cpp | 540 ++++++++++++++++++++++++++++++ keysets/grundig.h | 96 ++++++ keysets/lg.cpp | 35 +- keysets/lg.h | 2 - keysets/logitech.cpp | 32 ++ keysets/logitech.h | 16 + keysets/mce.cpp | 2 + keysets/philco.cpp | 44 +++ keysets/philco.h | 16 + keysets/roku.cpp | 69 ++++ keysets/roku.h | 24 ++ keysets/topfield.cpp | 131 ++++++++ keysets/topfield.h | 24 ++ mainwindow.cpp | 48 ++- mainwindow.h | 18 +- mainwindow.ui | 393 +++++++++++++--------- pierogi.pro | 22 +- pierogi.pro.user | 6 +- pirkeynames.h | 4 + pirkeysetmanager.cpp | 44 ++- pirmakenames.cpp | 7 + pirmakenames.h | 7 + protocols/daewooprotocol.cpp | 130 +++++++ protocols/daewooprotocol.h | 35 ++ protocols/necprotocol.cpp | 4 +- protocols/necxprotocol.cpp | 158 +++++++++ protocols/necxprotocol.h | 38 +++ protocols/samsungprotocol.cpp | 2 +- protocols/sharpprotocol.cpp | 2 +- qtc_packaging/debian_fremantle/changelog | 7 + qtc_packaging/debian_fremantle/control | 6 +- 35 files changed, 2181 insertions(+), 227 deletions(-) create mode 100644 keysets/admiral.cpp create mode 100644 keysets/admiral.h create mode 100644 keysets/daewoo.cpp create mode 100644 keysets/daewoo.h create mode 100644 keysets/grundig.cpp create mode 100644 keysets/grundig.h create mode 100644 keysets/logitech.cpp create mode 100644 keysets/logitech.h create mode 100644 keysets/philco.cpp create mode 100644 keysets/philco.h create mode 100644 keysets/roku.cpp create mode 100644 keysets/roku.h create mode 100644 keysets/topfield.cpp create mode 100644 keysets/topfield.h create mode 100644 protocols/daewooprotocol.cpp create mode 100644 protocols/daewooprotocol.h create mode 100644 protocols/necxprotocol.cpp create mode 100644 protocols/necxprotocol.h diff --git a/keysets/admiral.cpp b/keysets/admiral.cpp new file mode 100644 index 0000000..adcb060 --- /dev/null +++ b/keysets/admiral.cpp @@ -0,0 +1,88 @@ +#include "admiral.h" +#include "protocols/sharpprotocol.h" + +AdmiralTV1::AdmiralTV1( + QObject *guiObject, + unsigned int index) + : PIRKeysetMetaData( + "TV Keyset 1", + Admiral_Make, + index) +{ + threadableProtocol = new SharpProtocol(guiObject, index, true); + + addSharpKey("tv-1", One_Key, 0x01, 0x01); + addSharpKey("tv-2", Two_Key, 0x01, 0x02); + addSharpKey("tv-3", Three_Key, 0x01, 0x03); + addSharpKey("tv-4", Four_Key, 0x01, 0x04); + addSharpKey("tv-5", Five_Key, 0x01, 0x05); + addSharpKey("tv-6", Six_Key, 0x01, 0x06); + addSharpKey("tv-7", Seven_Key, 0x01, 0x07); + addSharpKey("tv-8", Eight_Key, 0x01, 0x08); + addSharpKey("tv-9", Nine_Key, 0x01, 0x09); + addSharpKey("tv-0", Zero_Key, 0x01, 0x0A); + addSharpKey("tv-100", PlusOneHundred_Key, 0x01, 0x0B); + + addSharpKey("tv-+", ChannelUp_Key, 0x01, 0x11); + addSharpKey("tv--", ChannelDown_Key, 0x01, 0x12); + addSharpKey("tv-input", Input_Key, 0x01, 0x13); + addSharpKey("vol+", VolumeUp_Key, 0x01, 0x14); + addSharpKey("vol-", VolumeDown_Key, 0x01, 0x15); + addSharpKey("tv-power", Power_Key, 0x01, 0x16); + addSharpKey("mute", Mute_Key, 0x01, 0x17); + addSharpKey("tv-display", Info_Key, 0x01, 0x1B); + + addSharpKey("flash", Unmapped_Key, 0x01, 0x4F); +} + + +AdmiralVCR1::AdmiralVCR1( + QObject *guiObject, + unsigned int index) + : PIRKeysetMetaData( + "VCR Keyset 1", + Admiral_Make, + index) +{ + threadableProtocol = new SharpProtocol(guiObject, index, true); + + addSharpKey("vcr-1", One_Key, 0x03, 0x01); + addSharpKey("vcr-2", Two_Key, 0x03, 0x02); + addSharpKey("vcr-3", Three_Key, 0x03, 0x03); + addSharpKey("vcr-4", Four_Key, 0x03, 0x04); + addSharpKey("vcr-5", Five_Key, 0x03, 0x05); + addSharpKey("vcr-6", Six_Key, 0x03, 0x06); + addSharpKey("vcr-7", Seven_Key, 0x03, 0x07); + addSharpKey("vcr-8", Eight_Key, 0x03, 0x08); + addSharpKey("vcr-9", Nine_Key, 0x03, 0x09); + addSharpKey("vcr-0", Zero_Key, 0x03, 0x0A); + addSharpKey("child_lock", Unmapped_Key, 0x03, 0x0D); + + addSharpKey("vcr-+", ChannelUp_Key, 0x03, 0x11); + addSharpKey("vcr--", ChannelDown_Key, 0x03, 0x12); + addSharpKey("tv/vcr", Unmapped_Key, 0x03, 0x13); + addSharpKey("vcr-power", Power_Key, 0x03, 0x16); + addSharpKey("menu", Menu_Key, 0x03, 0x1D); + addSharpKey("tape_speed", VHSSpeed_Key, 0x03, 0x1F); + + addSharpKey("ff", FastForward_Key, 0x03, 0x21); + addSharpKey("play", Play_Key, 0x03, 0x22); + addSharpKey("rew", Rewind_Key, 0x03, 0x23); + addSharpKey("pause", Pause_Key, 0x03, 0x25); + addSharpKey("stop", Stop_Key, 0x03, 0x27); + addSharpKey("rec", Record_Key, 0x03, 0x28); + addSharpKey("slow", Slow_Key, 0x03, 0x29); + addSharpKey("dpss+", Unmapped_Key, 0x03, 0x2F); + + addSharpKey("dpss-", Unmapped_Key, 0x03, 0x30); + addSharpKey("eject", Eject_Key, 0x03, 0x33); + addSharpKey("vcr-input", Input_Key, 0x03, 0x34); + + addSharpKey("auto_review", Unmapped_Key, 0x03, 0x83); + addSharpKey("cancel", Clear_Key, 0x03, 0x84); + addSharpKey("vcr-100", PlusOneHundred_Key, 0x03, 0x88); + addSharpKey("vcr-display", Info_Key, 0x03, 0x8C); + addSharpKey("on_screen", Unmapped_Key, 0x03, 0x8D); + + addSharpKey("add/erase", Unmapped_Key, 0x03, 0xB5); +} diff --git a/keysets/admiral.h b/keysets/admiral.h new file mode 100644 index 0000000..ec9b045 --- /dev/null +++ b/keysets/admiral.h @@ -0,0 +1,24 @@ +#ifndef ADMIRAL_H +#define ADMIRAL_H + +#include "pirkeysetmetadata.h" + +class QObject; + +class AdmiralTV1: public PIRKeysetMetaData +{ +public: + AdmiralTV1( + QObject *guiObject, + unsigned int index); +}; + +class AdmiralVCR1: public PIRKeysetMetaData +{ +public: + AdmiralVCR1( + QObject *guiObject, + unsigned int index); +}; + +#endif // ADMIRAL_H diff --git a/keysets/daewoo.cpp b/keysets/daewoo.cpp new file mode 100644 index 0000000..f037bde --- /dev/null +++ b/keysets/daewoo.cpp @@ -0,0 +1,286 @@ +#include "daewoo.h" +#include "protocols/rc5protocol.h" +#include "protocols/daewooprotocol.h" +#include "protocols/necprotocol.h" + +DaewooTV1::DaewooTV1( + QObject *guiObject, + unsigned int index) + : PIRKeysetMetaData( + "TV Keyset 1", + Daewoo_Make, + index) +{ + addControlledDevice(Daewoo_Make, "21T5T", TV_Device); + + threadableProtocol = new RC5Protocol(guiObject, index); + + addKey("MENU", Menu_Key, 0x0012, 13); + addKey("OK", Select_Key, 0x0017, 13); // "enter" + + addKey("0", Zero_Key, 0x1000, 13); + addKey("1", One_Key, 0x1001, 13); + addKey("2", Two_Key, 0x1002, 13); + addKey("3", Three_Key, 0x1003, 13); + addKey("4", Four_Key, 0x1004, 13); + addKey("5", Five_Key, 0x1005, 13); + addKey("6", Six_Key, 0x1006, 13); + addKey("7", Seven_Key, 0x1007, 13); + addKey("8", Eight_Key, 0x1008, 13); + addKey("9", Nine_Key, 0x1009, 13); + addKey("POWER", Power_Key, 0x100C, 13); + addKey("MUTE", Mute_Key, 0x100D, 13); + addKey("normal", Unmapped_Key, 0x100E, 13); + addKey("RECALL", PrevChannel_Key, 0x100F, 13); + + addKey("VOL+", VolumeUp_Key, 0x1010, 13); // "Right" + addKey("VOL+", Right_Key, 0x1010, 13); // "Right" + addKey("VOL-", VolumeDown_Key, 0x1011, 13); // "Left" + addKey("VOL-", Left_Key, 0x1011, 13); // "Left" + + addKey("PR+", ChannelUp_Key, 0x1020, 13); // "Up" + addKey("PR+", Up_Key, 0x1020, 13); // "Up" + addKey("PR-", ChannelDown_Key, 0x1021, 13); // "Down" + addKey("PR-", Down_Key, 0x1021, 13); // "Down" + addKey("system", Guide_Key, 0x1022, 13); // Not quite a guide + addKey("i-ii", Audio_Key, 0x1023, 13); + addKey("two_semicircles", Unmapped_Key, 0x1024, 13); + addKey("SLEEP", Sleep_Key, 0x1026, 13); + addKey("time", Unmapped_Key, 0x102A, 13); + addKey("SKIP", Unmapped_Key, 0x102D, 13); // woofer + + addKey("yellow", Yellow_Key, 0x1032, 13); // "TIME" + addKey("blue", Blue_Key, 0x1034, 13); // "MODE" + addKey("videotext_info", Unmapped_Key, 0x1035, 13); + addKey("green", Green_Key, 0x1036, 13); // "MOVE" + addKey("red", Red_Key, 0x1037, 13); // "DEL" + addKey("scartmode", AuxInput_Key, 0x1038, 13); // "IN", "Src" + addKey("Teletext", Teletext_Key, 0x103C, 13); // "PAGE", "videotextmode" + addKey("tvmode", Input_Key, 0x103F, 13); +} + + +DaewooTV2::DaewooTV2( + QObject *guiObject, + unsigned int index) + : PIRKeysetMetaData( + "TV Keyset 1", + Daewoo_Make, + index) +{ + addControlledDevice(Daewoo_Make, "DMQ-2141", TV_Device); + + threadableProtocol = new DaewooProtocol(guiObject, index); + + setPreData(0x14, 8); + + addKey("0", Zero_Key, 0x00, 8); + addKey("1", One_Key, 0x01, 8); + addKey("2", Two_Key, 0x02, 8); + addKey("3", Three_Key, 0x03, 8); + addKey("4", Four_Key, 0x04, 8); + addKey("5", Five_Key, 0x05, 8); + addKey("6", Six_Key, 0x06, 8); + addKey("7", Seven_Key, 0x07, 8); + addKey("8", Eight_Key, 0x08, 8); + addKey("9", Nine_Key, 0x09, 8); + addKey("1-", Unmapped_Key, 0x0A, 8); // sort of double digit here... + addKey("2-", Unmapped_Key, 0x0B, 8); + addKey("AFT/Band", Unmapped_Key, 0x0C, 8); // Tuner Band key? + addKey("Preset", Unmapped_Key, 0x0D, 8); + addKey("Auto_Search+", Unmapped_Key, 0x0E, 8); + addKey("Fine_Tuning+", Unmapped_Key, 0x0F, 8); + addKey("Channel_Call", Unmapped_Key, 0x10, 8); + addKey("On_Timer", Timer_Key, 0x11, 8); + addKey("Auto_Search-", Unmapped_Key, 0x12, 8); + addKey("Fine_Tuning-", Unmapped_Key, 0x13, 8); + addKey("Hour", Unmapped_Key, 0x14, 8); + addKey("Minute", Unmapped_Key, 0x15, 8); + addKey("On_Timer_Enable", Unmapped_Key, 0x16, 8); + addKey("Sleep", Sleep_Key, 0x17, 8); + addKey("Volume+", VolumeUp_Key, 0x18, 8); + addKey("Up", Up_Key, 0x19, 8); + addKey("Select", Select_Key, 0x1A, 8); + addKey("Mute", Mute_Key, 0x1B, 8); + addKey("Volume-", VolumeDown_Key, 0x1C, 8); + addKey("Down", Down_Key, 0x1D, 8); + addKey("TV/VCR", Input_Key, 0x1E, 8); + addKey("Standby", Power_Key, 0x1F, 8); + addKey("3-", Unmapped_Key, 0x28, 8); + addKey("4-", Unmapped_Key, 0x29, 8); + addKey("Channel+", ChannelUp_Key, 0x30, 8); + addKey("Channel-", ChannelDown_Key, 0x34, 8); + addKey("Skip", Unmapped_Key, 0x38, 8); + addKey("System", Menu_Key, 0x39, 8); + addKey("Q.V.", Unmapped_Key, 0x3C, 8); +} + + +DaewooDVD1::DaewooDVD1( + QObject *guiObject, + unsigned int index) + : PIRKeysetMetaData( + "DVD Keyset 1", + Daewoo_Make, + index) +{ + threadableProtocol = new DaewooProtocol(guiObject, index); + + setPreData(0x15, 8); + + addKey("NUM0", Zero_Key, 0x90, 8); + addKey("NUM1", One_Key, 0x91, 8); + addKey("NUM2", Two_Key, 0x92, 8); + addKey("NUM3", Three_Key, 0x93, 8); + addKey("NUM4", Four_Key, 0x94, 8); + addKey("NUM5", Five_Key, 0x95, 8); + addKey("NUM6", Six_Key, 0x96, 8); + addKey("NUM7", Seven_Key, 0x97, 8); + addKey("NUM8", Eight_Key, 0x98, 8); + addKey("NUM9", Nine_Key, 0x99, 8); + addKey("SYSTEM", Guide_Key, 0x9A, 8); // not quite guide + addKey("SETUP", Menu_Key, 0x9B, 8); + addKey("PAUSE", Pause_Key, 0x9C, 8); + addKey("STOP", Stop_Key, 0x9D, 8); + addKey("PLAY", Play_Key, 0x9E, 8); + addKey("FFWD", FastForward_Key, 0x9F, 8); + + addKey("REW", Rewind_Key, 0xA0, 8); + addKey("MENU", DiscMenu_Key, 0xA1, 8); + addKey("ENTER", Select_Key, 0xA2, 8); + addKey("NEXT", Next_Key, 0xA3, 8); + addKey("PREV", Previous_Key, 0xA4, 8); + addKey("POWER", Power_Key, 0xA5, 8); + addKey("SREW", StepBack_Key, 0xA6, 8); + addKey("UP", Up_Key, 0xA7, 8); + addKey("DOWN", Down_Key, 0xA8, 8); + addKey("RIGHT", Right_Key, 0xA9, 8); + addKey("LEFT", Left_Key, 0xAA, 8); + addKey("ANGLE", Angle_Key, 0xAB, 8); + addKey("CLEAR", Clear_Key, 0xAC, 8); // Might be exit key + addKey("AUDIO", Audio_Key, 0xAD, 8); + addKey("OPEN", Eject_Key, 0xAE, 8); + addKey("DISPLAY", Info_Key, 0xAF, 8); + + addKey("TITLE", DiscTitle_Key, 0xB0, 8); + addKey("ZOOM", Zoom_Key, 0xB1, 8); + addKey("AB", RepeatAB_Key, 0xB3, 8); + addKey("3D", Unmapped_Key, 0xB4, 8); + addKey("SUB", Captions_Key, 0xB5, 8); + addKey("REPEAT", Repeat_Key, 0xB8, 8); + addKey("SCART", ScartInput_Key, 0xBA, 8); + addKey("PROG", Program_Key, 0xBB, 8); + addKey("SFFWD", StepForward_Key, 0xBC, 8); + addKey("SEARCH", Unmapped_Key, 0xBE, 8); + addKey("MUTE", Mute_Key, 0xBF, 8); +} + + +DaewooVCR1::DaewooVCR1( + QObject *guiObject, + unsigned int index) + : PIRKeysetMetaData( + "VCR Keyset 1", + Daewoo_Make, + index) +{ + addControlledDevice(Daewoo_Make, "PV-200", VCR_Device); + + threadableProtocol = new NECProtocol(guiObject, index, false, true); + + setPreData(0x31, 8); + + addKey("+CH", ChannelUp_Key, 0x01, 8); + addKey("-CH", ChannelDown_Key, 0x02, 8); + addKey("1", One_Key, 0x04, 8); + addKey("2", Two_Key, 0x05, 8); + addKey("3", Three_Key, 0x06, 8); + addKey("4", Four_Key, 0x07, 8); + + addKey("5", Five_Key, 0x0C, 8); + addKey("6", Six_Key, 0x0D, 8); + addKey("7", Seven_Key, 0x0E, 8); + addKey("8", Eight_Key, 0x0F, 8); + + addKey("STOP", Stop_Key, 0x10, 8); + addKey("PAUSE/STILL", Pause_Key, 0x11, 8); + addKey("REW", Rewind_Key, 0x12, 8); + addKey("PLAY", Play_Key, 0x14, 8); + addKey("FF", FastForward_Key, 0x13, 8); + addKey("REC", Record_Key, 0x15, 8); + addKey("TYPE", Unmapped_Key, 0x18, 8); + addKey("INDEX", Unmapped_Key, 0x19, 8); + addKey("9", Nine_Key, 0x1C, 8); + addKey("0", Zero_Key, 0x1D, 8); + addKey("INPUT", Input_Key, 0x1E, 8); + + addKey("MEMORY", Memory_Key, 0x43, 8); + addKey("RESET", Reset_Key, 0x44, 8); + addKey("CLEAR", Clear_Key, 0x4A, 8); + addKey("OK", Select_Key, 0x4B, 8); // enter key? + addKey("DISPLAY", Info_Key, 0x4C, 8); + addKey("VPS/PDC", Unmapped_Key, 0x4F, 8); + + addKey("POWER", Power_Key, 0x5B, 8); + + addKey("ShowView", Unmapped_Key, 0x8C, 8); + addKey("PRESET", Unmapped_Key, 0x9E, 8); + addKey("MENU/TV", Menu_Key, 0xCA, 8); +} + + +DaewooVCR2::DaewooVCR2( + QObject *guiObject, + unsigned int index) + : PIRKeysetMetaData( + "VCR Keyset 2", + Daewoo_Make, + index) +{ + addControlledDevice(Daewoo_Make, "VQ857S", VCR_Device); + + threadableProtocol = new DaewooProtocol(guiObject, index); + + setPreData(0x15, 8); + + addKey("ch0", Zero_Key, 0x00, 8); + addKey("ch1", One_Key, 0x01, 8); + addKey("ch2", Two_Key, 0x02, 8); + addKey("ch3", Three_Key, 0x03, 8); + addKey("ch4", Four_Key, 0x04, 8); + addKey("ch5", Five_Key, 0x05, 8); + addKey("ch6", Six_Key, 0x06, 8); + addKey("ch7", Seven_Key, 0x07, 8); + addKey("ch8", Eight_Key, 0x08, 8); + addKey("ch9", Nine_Key, 0x09, 8); + addKey("stop", Stop_Key, 0x0D, 8); + addKey("play", Play_Key, 0x0E, 8); + addKey("ffwd", FastForward_Key, 0x0F, 8); + + addKey("rew", Rewind_Key, 0x10, 8); + addKey("pause", Pause_Key, 0x11, 8); + addKey("O", Unmapped_Key, 0x12, 8); + addKey("next", Next_Key, 0x13, 8); + addKey("power", Power_Key, 0x15, 8); + addKey("tv/vcr", Input_Key, 0x16, 8); + addKey("prup", ChannelUp_Key, 0x17, 8); + addKey("prdown", ChannelDown_Key, 0x18, 8); + addKey("ad", Unmapped_Key, 0x19, 8); + addKey("asel", Unmapped_Key, 0x1A, 8); + addKey("sp/lp", VHSSpeed_Key, 0x1B, 8); + addKey("svc", Unmapped_Key, 0x1C, 8); + addKey("a", Unmapped_Key, 0x1D, 8); + addKey("gt30", Unmapped_Key, 0x1E, 8); + addKey("pal/sec", Unmapped_Key, 0x1F, 8); + + addKey("eject", Eject_Key, 0x21, 8); + addKey("menu", Menu_Key, 0x22, 8); + addKey("qs", Unmapped_Key, 0x27, 8); + addKey("ok", Select_Key, 0x29, 8); + addKey("left", Left_Key, 0x31, 8); + addKey("indexup", Unmapped_Key, 0x33, 8); + addKey("right", Right_Key, 0x35, 8); + addKey("av", AuxInput_Key, 0x36, 8); + addKey("sv/v+", Unmapped_Key, 0x39, 8); + addKey("indexdown", Unmapped_Key, 0x3F, 8); +} diff --git a/keysets/daewoo.h b/keysets/daewoo.h new file mode 100644 index 0000000..29f11a8 --- /dev/null +++ b/keysets/daewoo.h @@ -0,0 +1,48 @@ +#ifndef DAEWOO_H +#define DAEWOO_H + +#include "pirkeysetmetadata.h" + +class QObject; + +class DaewooTV1: public PIRKeysetMetaData +{ +public: + DaewooTV1( + QObject *guiObject, + unsigned int index); +}; + +class DaewooTV2: public PIRKeysetMetaData +{ +public: + DaewooTV2( + QObject *guiObject, + unsigned int index); +}; + +class DaewooDVD1: public PIRKeysetMetaData +{ +public: + DaewooDVD1( + QObject *guiObject, + unsigned int index); +}; + +class DaewooVCR1: public PIRKeysetMetaData +{ +public: + DaewooVCR1( + QObject *guiObject, + unsigned int index); +}; + +class DaewooVCR2: public PIRKeysetMetaData +{ +public: + DaewooVCR2( + QObject *guiObject, + unsigned int index); +}; + +#endif // DAEWOO_H diff --git a/keysets/grundig.cpp b/keysets/grundig.cpp new file mode 100644 index 0000000..d883272 --- /dev/null +++ b/keysets/grundig.cpp @@ -0,0 +1,540 @@ +#include "grundig.h" +#include "protocols/rc5protocol.h" +#include "protocols/necxprotocol.h" +#include "protocols/necprotocol.h" + +// This one is iffy, might be another brand: +GrundigSat1::GrundigSat1( + QObject *guiObject, + unsigned int index) + : PIRKeysetMetaData( + "Satellite Keyset 1", + Grundig_Make, + index) +{ + threadableProtocol = new RC5Protocol(guiObject, index); + + addKey("Mute", Mute_Key, 0x0286, 13); + addKey("Guide", Guide_Key, 0x028F, 13); + addKey("Up", Up_Key, 0x0290, 13); + addKey("Down", Down_Key, 0x0291, 13); + addKey("Serv", Unmapped_Key, 0x0292, 13); + addKey("Exit", Exit_Key, 0x0293, 13); + addKey("Left", Left_Key, 0x0295, 13); + addKey("Right", Right_Key, 0x0296, 13); + addKey("OK", Select_Key, 0x0297, 13); + addKey("Prefer", Unmapped_Key, 0x02A1, 13); + addKey("Perso", Unmapped_Key, 0x02AA, 13); + addKey("A", Unmapped_Key, 0x02AB, 13); + addKey("B", Unmapped_Key, 0x02AC, 13); + addKey("C", Unmapped_Key, 0x02AD, 13); + addKey("D", Unmapped_Key, 0x02AE, 13); + addKey("E", Unmapped_Key, 0x02AF, 13); + + addKey("1", One_Key, 0x1281, 13); + addKey("2", Two_Key, 0x1282, 13); + addKey("3", Three_Key, 0x1283, 13); + addKey("4", Four_Key, 0x1284, 13); + addKey("5", Five_Key, 0x1285, 13); + addKey("6", Six_Key, 0x1286, 13); + addKey("7", Seven_Key, 0x1287, 13); + addKey("8", Eight_Key, 0x1288, 13); + addKey("9", Nine_Key, 0x1289, 13); + addKey("0", Zero_Key, 0x1280, 13); + addKey("Standby", Power_Key, 0x128C, 13); + addKey("Info", Info_Key, 0x128F, 13); + addKey("TV/Sat", Input_Key, 0x12A8, 13); + addKey("Plus", Unmapped_Key, 0x12AF, 13); +} + + +GrundigSat2::GrundigSat2( + QObject *guiObject, + unsigned int index) + : PIRKeysetMetaData( + "Satellite Keyset 2", + Grundig_Make, + index) +{ + addControlledDevice(Grundig_Make, "STR 7100", Sat_Device); + + threadableProtocol = new RC5Protocol(guiObject, index); + + addKey("POWER", Power_Key, 0x017B, 13); + addKey("Audio", Audio_Key, 0x00D3, 13); + addKey(">|", StepForward_Key, 0x008B, 13); + addKey("|<", StepBack_Key, 0x00BB, 13); + addKey("1", One_Key, 0x00EB, 13); + addKey("2", Two_Key, 0x016B, 13); + addKey("3", Three_Key, 0x006B, 13); + addKey("4", Four_Key, 0x01AB, 13); + addKey("5", Five_Key, 0x00AB, 13); + addKey("6", Six_Key, 0x012B, 13); + addKey("7", Seven_Key, 0x002B, 13); + addKey("8", Eight_Key, 0x01CB, 13); + addKey("9", Nine_Key, 0x00CB, 13); + addKey("0", Zero_Key, 0x01EB, 13); + addKey("i", Info_Key, 0x0093, 13); // "OSD" + addKey("MUTE", Mute_Key, 0x00FB, 13); + addKey("P+", ChannelUp_Key, 0x0153, 13); + addKey("P-", ChannelDown_Key, 0x0053, 13); + addKey("-", VolumeDown_Key, 0x00DB, 13); + addKey("+", VolumeUp_Key, 0x01DB, 13); + addKey("OK", Select_Key, 0x01FB, 13); + addKey("AUX", AuxInput_Key, 0x003B, 13); // "DiscMenu" + addKey("TXT", Teletext_Key, 0x01E3, 13); + addKey("RED", Red_Key, 0x0143, 13); + addKey("GREEN", Green_Key, 0x0103, 13); + addKey("YELLOW", Yellow_Key, 0x0043, 13); + addKey("BLUE", Blue_Key, 0x0113, 13); + addKey("COL-", ColorDown_Key, 0x009B, 13); + addKey("COL+", ColorUp_Key, 0x019B, 13); + addKey("BRIGHT-", BrightnessDown_Key, 0x005B, 13); + addKey("BRIGHT+", BrightnessUp_Key, 0x015B, 13); + addKey("TV-G", Unmapped_Key, 0x01BB, 13); +} + + +GrundigAmp1::GrundigAmp1( + QObject *guiObject, + unsigned int index) + : PIRKeysetMetaData( + "Amp Keyset 1", + Grundig_Make, + index) +{ + addControlledDevice(Grundig_Make, "FineArts Amplifier V1", Audio_Device); + + threadableProtocol = new RC5Protocol(guiObject, index); + + addKey("number_10", Zero_Key, 0x1C00, 13); + addKey("number_1", One_Key, 0x1C01, 13); + addKey("number_2", Two_Key, 0x1C02, 13); + addKey("number_3", Three_Key, 0x1C03, 13); + addKey("number_4", Four_Key, 0x1C04, 13); + addKey("number_5", Five_Key, 0x1C05, 13); + addKey("number_6", Six_Key, 0x1C06, 13); + addKey("number_7", Seven_Key, 0x1C07, 13); + addKey("number_8", Eight_Key, 0x1C08, 13); + addKey("number_9", Nine_Key, 0x1C09, 13); + addKey("mute", Mute_Key, 0x1C0D, 13); + addKey("volume_+", VolumeUp_Key, 0x1C10, 13); + addKey("volume_-", VolumeDown_Key, 0x1C11, 13); + addKey("standby", Power_Key, 0x1C3D, 13); + + addKey("tuner_up", ChannelUp_Key, 0x1C60, 13); + addKey("tuner_down", ChannelDown_Key, 0x1C61, 13); + addKey("tuner", TunerInput_Key, 0x1C7F, 13); + + addKey("tape_play_back", Unmapped_Key, 0x1CAF, 13); + addKey("tape_pause", Unmapped_Key, 0x1CB0, 13); + addKey("tape_fastrewind", Unmapped_Key, 0x1CB2, 13); + addKey("tape_fastforward", Unmapped_Key, 0x1CB4, 13); + addKey("tape_play_forward", Unmapped_Key, 0x1CB5, 13); + addKey("tape_stop", Unmapped_Key, 0x1CB6, 13); + addKey("tape_record", Unmapped_Key, 0x1CB7, 13); + addKey("tape", TapeInput_Key, 0x1CBF, 13); + + addKey("cd_fastforward", FastForward_Key, 0x1D20, 13); + addKey("cd_fastrewind", Rewind_Key, 0x1D21, 13); + addKey("cd_pause", Pause_Key, 0x1D30, 13); + addKey("cd_play", Play_Key, 0x1D35, 13); + addKey("cd_stop", Stop_Key, 0x1D36, 13); + addKey("cd", CDInput_Key, 0x1D3F, 13); + + addKey("phono", PhonoInput_Key, 0x1D7F, 13); + addKey("dsr_up", Unmapped_Key, 0x1DA0, 13); + addKey("dsr_down", Unmapped_Key, 0x1DA1, 13); + addKey("dsr_aux", AuxInput_Key, 0x1DBF, 13); + + addKey("dcc_play_back", Unmapped_Key, 0x1DEF, 13); + addKey("dcc_pause", Unmapped_Key, 0x1DF0, 13); + addKey("dcc_fastrewind", Unmapped_Key, 0x1DF2, 13); + addKey("dcc_fastforward", Unmapped_Key, 0x1DF4, 13); + addKey("dcc_play_forward", Unmapped_Key, 0x1DF5, 13); + addKey("dcc_stop", Unmapped_Key, 0x1DF6, 13); + addKey("dcc_record", Unmapped_Key, 0x1DF7, 13); + addKey("dcc", Unmapped_Key, 0x1DFF, 13); +} + + +GrundigAudio1::GrundigAudio1( + QObject *guiObject, + unsigned int index) + : PIRKeysetMetaData( + "Audio(CD) Keyset 1", + Grundig_Make, + index) +{ + addControlledDevice(Grundig_Make, "CD 8400", Audio_Device); + + threadableProtocol = new RC5Protocol(guiObject, index); + + addKey("0", Zero_Key, 0x1D00, 13); + addKey("1", One_Key, 0x1D01, 13); + addKey("2", Two_Key, 0x1D02, 13); + addKey("3", Three_Key, 0x1D03, 13); + addKey("4", Four_Key, 0x1D04, 13); + addKey("5", Five_Key, 0x1D05, 13); + addKey("6", Six_Key, 0x1D06, 13); + addKey("7", Seven_Key, 0x1D07, 13); + addKey("8", Eight_Key, 0x1D08, 13); + addKey("9", Nine_Key, 0x1D09, 13); + addKey("10+", DoubleDigit_Key, 0x1D0A, 13); // hack + addKey("20+", PlusOneHundred_Key, 0x1D0B, 13); // also hack + + addKey("repeat", Repeat_Key, 0x1D1D, 13); + + addKey("track+", Next_Key, 0x1D20, 13); + addKey("track-", Previous_Key, 0x1D21, 13); + addKey("index+", Unmapped_Key, 0x1D22, 13); + addKey("index-", Unmapped_Key, 0x1D23, 13); + addKey("store", Memory_Key, 0x1D29, 13); + addKey("scan", Scan_Key, 0x1D2B, 13); + + addKey("pause", Pause_Key, 0x1D30, 13); + addKey("skip-", Replay_Key, 0x1D32, 13); + addKey("skip+", Advance_Key, 0x1D34, 13); + addKey("play", Play_Key, 0x1D35, 13); + addKey("stop", Stop_Key, 0x1D36, 13); +} + + +GrundigAudio2::GrundigAudio2( + QObject *guiObject, + unsigned int index) + : PIRKeysetMetaData( + "Audio Keyset 2", + Grundig_Make, + index) +{ + addControlledDevice(Grundig_Make, "CDM 700", Audio_Device); + addControlledDevice(Grundig_Make, "UMS-9V", Audio_Device); + + threadableProtocol = new NECXProtocol(guiObject, index, true); + + setPreData(0xA2A2, 16); + + addKey("1", One_Key, 0x01, 8); + addKey("5", Five_Key, 0x02, 8); + addKey("9", Nine_Key, 0x03, 8); + addKey("tuning_down", ChannelDown_Key, 0x04, 8); + addKey("display", Info_Key, 0x05, 8); // "MODE_remain + addKey("on/off", Power_Key, 0x06, 8); + addKey("tuner", TunerInput_Key, 0x07, 8); + addKey("2", Two_Key, 0x09, 8); + addKey("6", Six_Key, 0x0A, 8); + addKey("0", Zero_Key, 0x0B, 8); + addKey("tuning_up", ChannelUp_Key, 0x0C, 8); + addKey("random", Random_Key, 0x0D, 8); + addKey("band", TunerBand_Key, 0x0E, 8); + addKey("cd", CDInput_Key, 0x0F, 8); + + addKey("3", Three_Key, 0x11, 8); + addKey("7", Seven_Key, 0x12, 8); + addKey("play/pause", Play_Key, 0x13, 8); + addKey("play/pause", Pause_Key, 0x13, 8); + addKey("time_program", Program_Key, 0x14, 8); // "MEMORY_clock" + addKey("intro", Unmapped_Key, 0x15, 8); + addKey("SLEEP", Sleep_Key, 0x17, 8); + addKey("4", Four_Key, 0x19, 8); + addKey("8", Eight_Key, 0x1A, 8); + addKey("stop", Stop_Key, 0x1B, 8); + addKey("repeat/scan", Repeat_Key, 0x1C, 8); + addKey("repeat/scan", Scan_Key, 0x1C, 8); + addKey("BASS", EnhancedBass_Key, 0x1D, 8); + addKey("tape", TapeInput_Key, 0x1E, 8); + addKey("TIMER", Timer_Key, 0x1F, 8); + + addKey("volume_up", VolumeUp_Key, 0x20, 8); + addKey("volume_down", VolumeDown_Key, 0x60, 8); + addKey("mute", Mute_Key, 0xA0, 8); + addKey("+10", DoubleDigit_Key, 0xE0, 8); +} + + +GrundigVCR1::GrundigVCR1( + QObject *guiObject, + unsigned int index) + : PIRKeysetMetaData( + "VCR Keyset 1", + Grundig_Make, + index) +{ + addControlledDevice(Grundig_Make, "GV 437", VCR_Device); + + threadableProtocol = new RC5Protocol(guiObject, index); + + addKey("SYSTEM", Menu_Key, 0x014A, 13); + addKey("OK", Select_Key, 0x0157, 13); + addKey("next", Next_Key, 0x0170, 13); + addKey("previous", Previous_Key, 0x0171, 13); + addKey("MONITOR", Unmapped_Key, 0x017A, 13); + addKey("tuner", TunerInput_Key, 0x017D, 13); + addKey("cass", Eject_Key, 0x017E, 13); // might be wrong + + addKey("0", Zero_Key, 0x1140, 13); + addKey("1", One_Key, 0x1141, 13); + addKey("2", Two_Key, 0x1142, 13); + addKey("3", Three_Key, 0x1143, 13); + addKey("4", Four_Key, 0x1144, 13); + addKey("5", Five_Key, 0x1145, 13); + addKey("6", Six_Key, 0x1146, 13); + addKey("7", Seven_Key, 0x1147, 13); + addKey("8", Eight_Key, 0x1148, 13); + addKey("9", Nine_Key, 0x1149, 13); + addKey("SELECT", Enter_Key, 0x114B, 13); // "selvps" + addKey("standby", Power_Key, 0x114C, 13); // "OFF" + addKey("tracking", AutoTracking_Key, 0x114E, 13); + + addKey("TIMER", Timer_Key, 0x115D, 13); + + // Just guessing at what + and - mean here: + addKey("+", ChannelUp_Key, 0x1160, 13); + addKey("-", ChannelDown_Key, 0x1161, 13); + addKey("REW", Rewind_Key, 0x1165, 13); + addKey("FF", FastForward_Key, 0x1166, 13); + + addKey("CLEAR", Clear_Key, 0x1171, 13); + addKey("PLAY", Play_Key, 0x1175, 13); + addKey("pausestop", Pause_Key, 0x1176, 13); // "STOP" + addKey("pausestop", Stop_Key, 0x1176, 13); // "STOP" + addKey("RECORD", Record_Key, 0x1177, 13); + addKey("SP/LP", VHSSpeed_Key, 0x117A, 13); +} + + +GrundigVCR1a::GrundigVCR1a( + QObject *guiObject, + unsigned int index) + : GrundigVCR1(guiObject, index) +{ + setKeysetName("VCR Keyset 1a"); + + addKey("INDEX", Unmapped_Key, 0x0170, 13); + addKey("PAUSE", Pause_Key, 0x1169, 13); +} + + +GrundigTV1::GrundigTV1( + QObject *guiObject, + unsigned int index) + : PIRKeysetMetaData( + "TV Keyset 1", + Grundig_Make, + index) +{ + addControlledDevice(Grundig_Make, "ST 55-908", TV_Device); + + threadableProtocol = new RC5Protocol(guiObject, index); + + addKey("leer", Unmapped_Key, 0x0000, 13); + addKey("POWER", Power_Key, 0x017F, 13); + addKey("1", One_Key, 0x00EF, 13); + addKey("2", Two_Key, 0x016F, 13); + addKey("3", Three_Key, 0x006F, 13); + addKey("4", Four_Key, 0x01AF, 13); + addKey("5", Five_Key, 0x00AF, 13); + addKey("6", Six_Key, 0x012F, 13); + addKey("7", Seven_Key, 0x002F, 13); + addKey("8", Eight_Key, 0x1CF, 13); + addKey("9", Nine_Key, 0x00CF, 13); + addKey("0", Zero_Key, 0x01EF, 13); + addKey("AUX2", Unmapped_Key, 0x014F, 13); + addKey("BR+", BrightnessUp_Key, 0x015F, 13); + addKey("BR-", BrightnessDown_Key, 0x005F, 13); + addKey("COLOR+", ColorUp_Key, 0x019F, 13); + addKey("COLOR-", ColorDown_Key, 0x009F, 13); + addKey("AUX", AuxInput_Key, 0x003F, 13); + addKey("I", Info_Key, 0x0097, 13); // "Info" + addKey("TXT", Teletext_Key, 0x01E7, 13); + addKey("P+", ChannelUp_Key, 0x0157, 13); + addKey("P+", Up_Key, 0x0157, 13); + addKey("VOL-", VolumeDown_Key, 0x00DF, 13); + addKey("VOL-", Left_Key, 0x00DF, 13); + addKey("OK", Select_Key, 0x01FF, 13); + addKey("VOL+", VolumeUp_Key, 0x01DF, 13); + addKey("VOL+", Right_Key, 0x01DF, 13); + addKey("P-", ChannelDown_Key, 0x0057, 13); + addKey("P-", Down_Key, 0x0057, 13); + addKey("MUTE", Mute_Key, 0x00FF, 13); + addKey("BLUE", Blue_Key, 0x0117, 13); + addKey("YELLOW", Yellow_Key, 0x0047, 13); + addKey("GREEN", Green_Key, 0x0107, 13); + addKey("RED", Red_Key, 0x0147, 13); +} + + +GrundigTV2::GrundigTV2( + QObject *guiObject, + unsigned int index) + : PIRKeysetMetaData( + "TV Keyset 2", + Grundig_Make, + index) +{ + threadableProtocol = new RC5Protocol(guiObject, index); + + addKey("P+", ChannelUp_Key, 0x0010, 13); + addKey("P+", Up_Key, 0x0010, 13); + addKey("P-", ChannelDown_Key, 0x0011, 13); + addKey("P-", Down_Key, 0x0011, 13); + addKey("info", Info_Key, 0x0012, 13); + addKey("<-", VolumeDown_Key, 0x0015, 13); + addKey("<-", Left_Key, 0x0015, 13); + addKey("+>", VolumeUp_Key, 0x0016, 13); + addKey("+>", Right_Key, 0x0016, 13); + addKey("OK", Select_Key, 0x0017, 13); + + addKey("NEXT", Next_Key, 0x0170, 13); + addKey("PREV", Previous_Key, 0x0171, 13); + + addKey("0AV", Zero_Key, 0x1000, 13); // also AV? + addKey("1", One_Key, 0x1001, 13); + addKey("2", Two_Key, 0x1002, 13); + addKey("3", Three_Key, 0x1003, 13); + addKey("4", Four_Key, 0x1004, 13); + addKey("5", Five_Key, 0x1005, 13); + addKey("6", Six_Key, 0x1006, 13); + addKey("7", Seven_Key, 0x1007, 13); + addKey("8", Eight_Key, 0x1008, 13); + addKey("9", Nine_Key, 0x1009, 13); + addKey("power", Power_Key, 0x100C, 13); + addKey("mute", Mute_Key, 0x100D, 13); + + addKey("br+", BrightnessUp_Key, 0x1012, 13); + addKey("br-", BrightnessDown_Key, 0x1013, 13); + addKey("col+", ColorUp_Key, 0x1014, 13); + addKey("col-", ColorDown_Key, 0x1015, 13); + + addKey("PC/CL", Unmapped_Key, 0x1031, 13); + + addKey("TXT", Teletext_Key, 0x115D, 13); + addKey("<<", Rewind_Key, 0x1165, 13); + addKey(">>", FastForward_Key, 0x1166, 13); + addKey("||", Pause_Key, 0x1169, 13); + addKey(">", Play_Key, 0x1175, 13); + addKey("stop", Stop_Key, 0x1176, 13); + addKey("REC", Record_Key, 0x1177, 13); +} + + +GrundigTV3::GrundigTV3( + QObject *guiObject, + unsigned int index) + : PIRKeysetMetaData( + "TV/VDR Keyset 3", + Grundig_Make, + index) +{ + threadableProtocol = new RC5Protocol(guiObject, index); + + addKey("USR4", Unmapped_Key, 0x0205, 13); + addKey("INFO", Info_Key, 0x0206, 13); + addKey("BACK", Exit_Key, 0x020F, 13); + addKey("UP", Up_Key, 0x0210, 13); + addKey("DOWN", Down_Key, 0x0211, 13); + addKey("LEFT", Left_Key, 0x0215, 13); + addKey("RIGHT", Right_Key, 0x0216, 13); + addKey("OK", Select_Key, 0x0217, 13); + + addKey("RED", Red_Key, 0x022B, 13); + addKey("GREEN", Green_Key, 0x022C, 13); + addKey("YEL", Yellow_Key, 0x022D, 13); + addKey("BLU", Blue_Key, 0x022E, 13); + addKey("USR2", Unmapped_Key, 0x0235, 13); + addKey("USR1", Unmapped_Key, 0x023E, 13); + + addKey("0", Zero_Key, 0x1200, 13); + addKey("1", One_Key, 0x1201, 13); + addKey("2", Two_Key, 0x1202, 13); + addKey("3", Three_Key, 0x1203, 13); + addKey("4", Four_Key, 0x1204, 13); + addKey("5", Five_Key, 0x1205, 13); + addKey("6", Six_Key, 0x1206, 13); + addKey("7", Seven_Key, 0x1207, 13); + addKey("8", Eight_Key, 0x1208, 13); + addKey("9", Nine_Key, 0x1209, 13); + + addKey("MUTE", Mute_Key, 0x120D, 13); + addKey("REC", Record_Key, 0x120E, 13); + addKey("VOL+", VolumeUp_Key, 0x1210, 13); + addKey("VOL-", VolumeDown_Key, 0x1211, 13); + addKey("NEXT", Next_Key, 0x121E, 13); + addKey("PREV", Previous_Key, 0x121F, 13); + addKey("CHANNEL+", ChannelUp_Key, 0x1220, 13); + addKey("CHANNEL-", ChannelDown_Key, 0x1221, 13); + addKey("CEC", Unmapped_Key, 0x1222, 13); + addKey("USR3", Unmapped_Key, 0x1223, 13); + addKey("REW", Rewind_Key, 0x122C, 13); + addKey("FF", FastForward_Key, 0x122E, 13); + + addKey("PAUSE", Pause_Key, 0x1230, 13); + addKey("PLAY", Play_Key, 0x1235, 13); + addKey("STOP", Stop_Key, 0x1236, 13); + addKey("MENU", Menu_Key, 0x123C, 13); +} + + +GrundigDVD1::GrundigDVD1( + QObject *guiObject, + unsigned int index) + : PIRKeysetMetaData( + "DVD Keyset 1", + Grundig_Make, + index) +{ + addControlledDevice(Grundig_Make, "GDV 130", DVD_Device); + + threadableProtocol = new NECProtocol(guiObject, index, false, true); + + setPreData(0x10, 8); + + addKey("POWER", Power_Key, 0x00, 8); + addKey("FF_SF", FastForward_Key, 0x01, 8); + addKey("OPEN_CLOSE", Eject_Key, 0x02, 8); + addKey("ARROW_LEFT", Left_Key, 0x03, 8); + addKey("STEP", StepForward_Key, 0x04, 8); + addKey("PREV", Previous_Key, 0x05, 8); + addKey("DISPLAY", Info_Key, 0x06, 8); + addKey("NEXT", Next_Key, 0x07, 8); + addKey("1", One_Key, 0x08, 8); + addKey("2", Two_Key, 0x09, 8); + addKey("3", Three_Key, 0x0A, 8); + addKey("ARROW_UP", Up_Key, 0x0B, 8); + addKey("FR_SR", Rewind_Key, 0x0C, 8); + addKey("SETUP", Menu_Key, 0x0D, 8); + addKey("TITLE", DiscTitle_Key, 0x0E, 8); + addKey("MENU", DiscMenu_Key, 0x0F, 8); + + addKey("4", Four_Key, 0x10, 8); + addKey("5", Five_Key, 0x11, 8); + addKey("6", Six_Key, 0x12, 8); + addKey("SELECT", Select_Key, 0x13, 8); + addKey("DIGEST", Unmapped_Key, 0x14, 8); + addKey("ANGLE", Angle_Key, 0x15, 8); + addKey("SUBTITLE", Captions_Key, 0x16, 8); + addKey("AUDIO", Audio_Key, 0x17, 8); + addKey("7", Seven_Key, 0x18, 8); + addKey("8", Eight_Key, 0x19, 8); + addKey("9", Nine_Key, 0x1A, 8); + addKey("ARROW_RIGHT", Right_Key, 0x1B, 8); + addKey("PROGRAM", Program_Key, 0x1C, 8); + addKey("VOLUME_UP", VolumeUp_Key, 0x1D, 8); + addKey("ZOOM", Zoom_Key, 0x1E, 8); + addKey("3D_SOUND", Surround_Key, 0x1F, 8); + + addKey("CLEAR", Clear_Key, 0x40, 8); + addKey("0", Zero_Key, 0x41, 8); + addKey("PCB", Unmapped_Key, 0x42, 8); + addKey("ARROW_DOWN", Down_Key, 0x43, 8); + addKey("SHUFFLE", Random_Key, 0x44, 8); + addKey("VOLUME_DOWN", VolumeDown_Key, 0x45, 8); + addKey("REPEAT", Repeat_Key, 0x46, 8); + addKey("A-B", RepeatAB_Key, 0x47, 8); + addKey("STOP/RETURN", Stop_Key, 0x48, 8); + addKey("STOP/RETURN", Exit_Key, 0x48, 8); + addKey("PLAY/PAUSE", Play_Key, 0x49, 8); + addKey("PLAY/PAUSE", Pause_Key, 0x49, 8); + addKey("MARKER", Unmapped_Key, 0x4A, 8); +} diff --git a/keysets/grundig.h b/keysets/grundig.h new file mode 100644 index 0000000..67e6a74 --- /dev/null +++ b/keysets/grundig.h @@ -0,0 +1,96 @@ +#ifndef GRUNDIG_H +#define GRUNDIG_H + +#include "pirkeysetmetadata.h" + +class QObject; + +class GrundigSat1: public PIRKeysetMetaData +{ +public: + GrundigSat1( + QObject *guiObject, + unsigned int index); +}; + +class GrundigSat2: public PIRKeysetMetaData +{ +public: + GrundigSat2( + QObject *guiObject, + unsigned int index); +}; + +class GrundigAmp1: public PIRKeysetMetaData +{ +public: + GrundigAmp1( + QObject *guiObject, + unsigned int index); +}; + +class GrundigAudio1: public PIRKeysetMetaData +{ +public: + GrundigAudio1( + QObject *guiObject, + unsigned int index); +}; + +class GrundigAudio2: public PIRKeysetMetaData +{ +public: + GrundigAudio2( + QObject *guiObject, + unsigned int index); +}; + +class GrundigVCR1: public PIRKeysetMetaData +{ +public: + GrundigVCR1( + QObject *guiObject, + unsigned int index); +}; + +class GrundigVCR1a: public GrundigVCR1 +{ +public: + GrundigVCR1a( + QObject *guiObject, + unsigned int index); +}; + +class GrundigTV1: public PIRKeysetMetaData +{ +public: + GrundigTV1( + QObject *guiObject, + unsigned int index); +}; + +class GrundigTV2: public PIRKeysetMetaData +{ +public: + GrundigTV2( + QObject *guiObject, + unsigned int index); +}; + +class GrundigTV3: public PIRKeysetMetaData +{ +public: + GrundigTV3( + QObject *guiObject, + unsigned int index); +}; + +class GrundigDVD1: public PIRKeysetMetaData +{ +public: + GrundigDVD1( + QObject *guiObject, + unsigned int index); +}; + +#endif // GRUNDIG_H diff --git a/keysets/lg.cpp b/keysets/lg.cpp index 7ed8964..0f9fbba 100644 --- a/keysets/lg.cpp +++ b/keysets/lg.cpp @@ -1,5 +1,6 @@ #include "lg.h" #include "protocols/necprotocol.h" +#include "protocols/necxprotocol.h" #include "protocols/rc5protocol.h" LGTV1::LGTV1( @@ -266,7 +267,6 @@ LGTV2b::LGTV2b( } -/* LGDisc1::LGDisc1( QObject *guiObject, unsigned int index) @@ -275,20 +275,7 @@ LGDisc1::LGDisc1( LG_Make, index) { - NECProtocol *np = new NECProtocol( - guiObject, - index, - 563, 559, - 563, 1681, - 108234, true, - Extended_NEC); - - threadableProtocol = np; - - np->setHeaderPair(4500, 4500); - np->setTrailerPulse(545); - np->setRepeatPair(531, 1710); - np->setRepeatNeedsHeader(true); + threadableProtocol = new NECXProtocol(guiObject, index, true); // setPreData(0x3434, 16); setPreData(0x2C2C, 16); @@ -354,10 +341,8 @@ LGDisc1::LGDisc1( addKey("marker", Unmapped_Key, 0xB4, 8); addKey("sleep", Sleep_Key, 0xC2, 8); } -*/ -/* LGDisc2::LGDisc2( QObject *guiObject, unsigned int index) @@ -366,20 +351,7 @@ LGDisc2::LGDisc2( LG_Make, index) { - NECProtocol *np = new NECProtocol( - guiObject, - index, - 600, 550, - 600, 1650, - 107000, true, - Extended_NEC); - - threadableProtocol = np; - - np->setHeaderPair(4500, 4500); - np->setTrailerPulse(600); - np->setRepeatPair(600, 550); - np->setRepeatNeedsHeader(true); + threadableProtocol = new NECXProtocol(guiObject, index, true); // setPreData(0xB4B4, 16); setPreData(0x2D2D, 16); @@ -447,7 +419,6 @@ LGDisc2a::LGDisc2a( addKey("KEY_YELLOW", Yellow_Key, 0x7E, 8); addKey("KEY_BLUE", Blue_Key, 0x7F, 8); } -*/ LGVCR1::LGVCR1( diff --git a/keysets/lg.h b/keysets/lg.h index dd85128..6bff901 100644 --- a/keysets/lg.h +++ b/keysets/lg.h @@ -61,7 +61,6 @@ public: unsigned int index); }; -/* class LGDisc1: public PIRKeysetMetaData { public: @@ -85,7 +84,6 @@ public: QObject *guiObject, unsigned int index); }; -*/ class LGVCR1: public PIRKeysetMetaData { diff --git a/keysets/logitech.cpp b/keysets/logitech.cpp new file mode 100644 index 0000000..0ac7f37 --- /dev/null +++ b/keysets/logitech.cpp @@ -0,0 +1,32 @@ +#include "logitech.h" +#include "protocols/necprotocol.h" + +LogitechSpeakers::LogitechSpeakers( + QObject *guiObject, + unsigned int index) + : PIRKeysetMetaData( + "Digital Speakers Keyset", + Logitech_Make, + index) +{ + threadableProtocol = new NECProtocol(guiObject, index, false, true); + + setPreData(0x08, 8); + + addKey("surround+", RearVolumeUp_Key, 0x00, 8); + addKey("sub-", WooferDown_Key, 0x01, 8); + addKey("center+", CenterVolumeUp_Key, 0x02, 8); + addKey("sub+", WooferUp_Key, 0x03, 8); + addKey("surround-", RearVolumeDown_Key, 0x04, 8); + addKey("test", Unmapped_Key, 0x05, 8); + addKey("center-", CenterVolumeDown_Key, 0x06, 8); + addKey("direct", PCInput_Key, 0x0A, 8); + addKey("optical", OpticalInput_Key, 0x0B, 8); + addKey("coax", DigitalCoaxInput_Key, 0x0C, 8); + addKey("vol-", VolumeDown_Key, 0x0E, 8); + addKey("power", Power_Key, 0x10, 8); + addKey("mute", Mute_Key, 0x16, 8); + addKey("effect", Red_Key, 0x1D, 8); + addKey("settings", Blue_Key, 0x1F, 8); + addKey("vol+", VolumeUp_Key, 0x1A, 8); +} diff --git a/keysets/logitech.h b/keysets/logitech.h new file mode 100644 index 0000000..58edd00 --- /dev/null +++ b/keysets/logitech.h @@ -0,0 +1,16 @@ +#ifndef LOGITECH_H +#define LOGITECH_H + +#include "pirkeysetmetadata.h" + +class QObject; + +class LogitechSpeakers: public PIRKeysetMetaData +{ +public: + LogitechSpeakers( + QObject *guiObject, + unsigned int index); +}; + +#endif // LOGITECH_H diff --git a/keysets/mce.cpp b/keysets/mce.cpp index 8309a66..d5c1b96 100644 --- a/keysets/mce.cpp +++ b/keysets/mce.cpp @@ -9,6 +9,8 @@ MCERemote1::MCERemote1( Microsoft_Make, index) { + addControlledDevice(Any_Make, "ASRock HT330", Computer_Device); + threadableProtocol = new MCEProtocol(guiObject, index, 0x800F); setPreData(0x04, 7); diff --git a/keysets/philco.cpp b/keysets/philco.cpp new file mode 100644 index 0000000..7c60b80 --- /dev/null +++ b/keysets/philco.cpp @@ -0,0 +1,44 @@ +#include "philco.h" +#include "protocols/necprotocol.h" + +PhilcoTV::PhilcoTV( + QObject *guiObject, + unsigned int index) + : PIRKeysetMetaData( + "TV Keyset 1", + Philco_Make, + index) +{ + threadableProtocol = new NECProtocol(guiObject, index, false, true); + + setPreData(0x50, 8); + + addKey("EIGHT", Eight_Key, 0x04, 8); + addKey("NINE", Nine_Key, 0x05, 8); + addKey("XPRESS", Unmapped_Key, 0x06, 8); + addKey("GUIDE", Guide_Key, 0x07, 8); + addKey("SAP", Audio_Key, 0x08, 8); + addKey("TVAV", Input_Key, 0x09, 8); + addKey("LASTCH", PrevChannel_Key, 0x0A, 8); + addKey("MUTE", Mute_Key, 0x0B, 8); + addKey("ZERO", Zero_Key, 0x0C, 8); + addKey("ONE", One_Key, 0x0D, 8); + addKey("TWO", Two_Key, 0x0E, 8); + addKey("THREE", Three_Key, 0x0F, 8); + + addKey("DISPLAY", Info_Key, 0x10, 8); + addKey("TIMER", Sleep_Key, 0x11, 8); + addKey("VOL+", VolumeUp_Key, 0x12, 8); + addKey("PREF", Unmapped_Key, 0x13, 8); + addKey("VOL-", VolumeDown_Key, 0x15, 8); + addKey("POWER", Power_Key, 0x17, 8); + addKey("CHANNEL-", ChannelDown_Key, 0x18, 8); + addKey("CHANNEL+", ChannelUp_Key, 0x19, 8); + addKey("FOUR", Four_Key, 0x1C, 8); + addKey("FIVE", Five_Key, 0x1D, 8); + addKey("SIX", Six_Key, 0x1E, 8); + addKey("SEVEN", Seven_Key, 0x1F, 8); + + addKey("MAGIC", Unmapped_Key, 0x5B, 8); + addKey("MENU", Menu_Key, 0x5E, 8); +} diff --git a/keysets/philco.h b/keysets/philco.h new file mode 100644 index 0000000..8245ac7 --- /dev/null +++ b/keysets/philco.h @@ -0,0 +1,16 @@ +#ifndef PHILCO_H +#define PHILCO_H + +#include "pirkeysetmetadata.h" + +class QObject; + +class PhilcoTV: public PIRKeysetMetaData +{ +public: + PhilcoTV( + QObject *guiObject, + unsigned int index); +}; + +#endif // PHILCO_H diff --git a/keysets/roku.cpp b/keysets/roku.cpp new file mode 100644 index 0000000..068a92a --- /dev/null +++ b/keysets/roku.cpp @@ -0,0 +1,69 @@ +#include "roku.h" +#include "protocols/necprotocol.h" + +RokuBox1::RokuBox1( + QObject *guiObject, + unsigned int index) + : PIRKeysetMetaData( + "Settop Box Keyset 1", + Roku_Make, + index) +{ + threadableProtocol = new NECProtocol(guiObject, index, true, false); + + setPreData(0xEFBE, 16); + + addKey("Home", Menu_Key, 0x00, 8); + addKey("Up", Up_Key, 0x01, 8); + addKey("Back", Left_Key, 0x02, 8); + addKey("Select", Select_Key, 0x03, 8); + addKey("Forward", Right_Key, 0x04, 8); + addKey("Down", Down_Key, 0x05, 8); + addKey("FastRev", Rewind_Key, 0x06, 8); + addKey("Start/Pause", Play_Key, 0x07, 8); + addKey("Start/Pause", Pause_Key, 0x07, 8); + addKey("FastFWD", FastForward_Key, 0x08, 8); +} + + +RokuBox2::RokuBox2( + QObject *guiObject, + unsigned int index) + : PIRKeysetMetaData( + "Soundbridge Keyset 1", + Roku_Make, + index) +{ + threadableProtocol = new NECProtocol(guiObject, index, false, true); + + setPreData(0x6F, 8); + + addKey("left", Left_Key, 0x10, 8); + addKey("right", Right_Key, 0x11, 8); + addKey("up", Up_Key, 0x12, 8); + addKey("down", Down_Key, 0x13, 8); + addKey("select", Select_Key, 0x14, 8); + addKey("exit", Exit_Key, 0x15, 8); + addKey("power", Power_Key, 0x16, 8); + addKey("menu", Menu_Key, 0x17, 8); + addKey("search", Unmapped_Key, 0x18, 8); + addKey("play", Play_Key, 0x19, 8); + addKey("next", Next_Key, 0x1A, 8); + addKey("prev", Previous_Key, 0x1B, 8); + addKey("pause", Pause_Key, 0x1C, 8); + addKey("add", Unmapped_Key, 0x1D, 8); + addKey("shuffle", Random_Key, 0x1E, 8); + addKey("repeat", Repeat_Key, 0x1F, 8); + + addKey("volume_up", VolumeUp_Key, 0x40, 8); + addKey("volume_down", VolumeDown_Key, 0x41, 8); + addKey("bright", Unmapped_Key, 0x42, 8); + addKey("power_on", PowerOn_Key, 0x43, 8); + addKey("power_off", PowerOff_Key, 0x44, 8); + addKey("user1", Unmapped_Key, 0x45, 8); + addKey("user2", Unmapped_Key, 0x46, 8); + addKey("user3", Unmapped_Key, 0x47, 8); + addKey("user4", Unmapped_Key, 0x48, 8); + addKey("user5", Unmapped_Key, 0x49, 8); + addKey("user6", Unmapped_Key, 0x4A, 8); +} diff --git a/keysets/roku.h b/keysets/roku.h new file mode 100644 index 0000000..9e312c9 --- /dev/null +++ b/keysets/roku.h @@ -0,0 +1,24 @@ +#ifndef ROKU_H +#define ROKU_H + +#include "pirkeysetmetadata.h" + +class QObject; + +class RokuBox1: public PIRKeysetMetaData +{ +public: + RokuBox1( + QObject *guiObject, + unsigned int index); +}; + +class RokuBox2: public PIRKeysetMetaData +{ +public: + RokuBox2( + QObject *guiObject, + unsigned int index); +}; + +#endif // ROKU_H diff --git a/keysets/topfield.cpp b/keysets/topfield.cpp new file mode 100644 index 0000000..5581b1d --- /dev/null +++ b/keysets/topfield.cpp @@ -0,0 +1,131 @@ +#include "topfield.h" +#include "protocols/necprotocol.h" + +TopfieldPVR1::TopfieldPVR1( + QObject *guiObject, + unsigned int index) + : PIRKeysetMetaData( + "PVR Keyset 1", + Topfield_Make, + index) +{ + addControlledDevice(Topfield_Make, "PVR 4000", Other_Device); + addControlledDevice(Topfield_Make, "PVR 5000", Other_Device); + + threadableProtocol = new NECProtocol(guiObject, index, false, true); + + setPreData(0x20, 8); + + addKey("Up", Up_Key, 0x00, 8); // "P+" + addKey("Up", ChannelUp_Key, 0x00, 8); // "P+" + addKey("Down", Down_Key, 0x01, 8); // "P-" + addKey("Down", ChannelDown_Key, 0x01, 8); // "P-" + addKey("Right", Right_Key, 0x02, 8); // "VOL+" + addKey("Right", VolumeUp_Key, 0x02, 8); // "VOL+" + addKey("Left", Left_Key, 0x03, 8); // "VOL-" + addKey("Left", VolumeDown_Key, 0x03, 8); // "VOL-" + addKey("Tv", Input_Key, 0x04, 8); + addKey("Audio", Audio_Key, 0x05, 8); + addKey("Pause", Pause_Key, 0x06, 8); + addKey("Subtitles", Captions_Key, 0x07, 8); + addKey("Sat", SatInput_Key, 0x08, 8); + addKey("Fav", Favorites_Key, 0x09, 8); + addKey("Power", Power_Key, 0x0A, 8); + addKey("Mute", Mute_Key, 0x0C, 8); + addKey("Green", Green_Key, 0x0D, 8); + addKey("Yellow", Yellow_Key, 0x0E, 8); + addKey("Blue", Blue_Key, 0x0F, 8); + + addKey("0", Zero_Key, 0x10, 8); + addKey("1", One_Key, 0x11, 8); + addKey("2", Two_Key, 0x12, 8); + addKey("3", Three_Key, 0x13, 8); + addKey("4", Four_Key, 0x14, 8); + addKey("5", Five_Key, 0x15, 8); + addKey("6", Six_Key, 0x16, 8); + addKey("7", Seven_Key, 0x17, 8); + addKey("8", Eight_Key, 0x18, 8); + addKey("9", Nine_Key, 0x19, 8); + addKey("Menu", Menu_Key, 0x1A, 8); + addKey("Scheudle", Guide_Key, 0x1B, 8); // "GUIDE" + addKey("Back", Exit_Key, 0x1C, 8); // "EXIT" + addKey("Info", Info_Key, 0x1D, 8); + addKey("Prev", PrevChannel_Key, 0x1E, 8); // "BACK" + addKey("Ok", Select_Key, 0x1F, 8); + + addKey("UHF", AntennaInput_Key, 0x43, 8); + addKey("Timer", Timer_Key, 0x44, 8); + addKey("FastRew", Rewind_Key, 0x45, 8); + addKey("Play", Play_Key, 0x46, 8); + addKey("Teletext", Teletext_Key, 0x47, 8); + addKey("FastFwd", FastForward_Key, 0x48, 8); + addKey("Skip", Unmapped_Key, 0x49, 8); + addKey("Stop", Stop_Key, 0x4A, 8); + addKey("Rec", Record_Key, 0x4B, 8); + addKey("White", Unmapped_Key, 0x4C, 8); + addKey("Red", Red_Key, 0x4D, 8); + + addKey("SkipLeft", Replay_Key, 0x50, 8); + addKey("Records", Unmapped_Key, 0x51, 8); // "LIST" + addKey("SkipRight", Advance_Key, 0x52,8); + addKey("Gray", Unmapped_Key, 0x5E, 8); +} + + +TopfieldSat1::TopfieldSat1( + QObject *guiObject, + unsigned int index) + : PIRKeysetMetaData( + "Sat Keyset 1", + Topfield_Make, + index) +{ + addControlledDevice(Topfield_Make, "TF4000Fi", Sat_Device); + + threadableProtocol = new NECProtocol(guiObject, index, true, true); + + setPreData(0xFF04, 16); + + addKey("P+", ChannelUp_Key, 0x00, 8); + addKey("P-", ChannelDown_Key, 0x01, 8); + addKey("V+", VolumeUp_Key, 0x02, 8); + addKey("V-", VolumeDown_Key, 0x03, 8); + addKey("TV/Radio", TunerInput_Key, 0x04, 8); + addKey("Sound", Audio_Key, 0x05, 8); + addKey("Pause", Pause_Key, 0x06, 8); + addKey("Subtitle", Captions_Key, 0x07, 8); + addKey("TV/STB", Input_Key, 0x08, 8); + addKey("FAV", Favorites_Key, 0x09, 8); + addKey("Power", Power_Key, 0x0A, 8); + addKey("Red", Red_Key, 0x0B, 8); + addKey("Mute", Mute_Key, 0x0C, 8); + addKey("Green", Green_Key, 0x0D, 8); + addKey("Yellow", Yellow_Key, 0x0E, 8); + addKey("Blue", Blue_Key, 0x0F, 8); + + addKey("0", Zero_Key, 0x10, 8); + addKey("1", One_Key, 0x11, 8); + addKey("2", Two_Key, 0x12, 8); + addKey("3", Three_Key, 0x13, 8); + addKey("4", Four_Key, 0x14, 8); + addKey("5", Five_Key, 0x15, 8); + addKey("6", Six_Key, 0x16, 8); + addKey("7", Seven_Key, 0x17, 8); + addKey("8", Eight_Key, 0x18, 8); + addKey("9", Nine_Key, 0x19, 8); + addKey("Menu", Menu_Key, 0x1A, 8); + addKey("Guide", Guide_Key, 0x1B, 8); + addKey("Exit", Exit_Key, 0x1C, 8); + addKey("Info", Info_Key, 0x1D, 8); + addKey("Recall", PrevChannel_Key, 0x1E, 8); + addKey("Ok", Select_Key, 0x1F, 8); + + addKey("M1", Unmapped_Key, 0x40, 8); + addKey("M2", Unmapped_Key, 0x41, 8); + addKey("M3", Unmapped_Key, 0x42, 8); + addKey("UHF", AntennaInput_Key, 0x43, 8); + addKey("Sleep", Sleep_Key, 0x44, 8); + addKey("Teletext", Teletext_Key, 0x47, 8); + + addKey("SAT", SatInput_Key, 0x5E, 8); +} diff --git a/keysets/topfield.h b/keysets/topfield.h new file mode 100644 index 0000000..ca9e847 --- /dev/null +++ b/keysets/topfield.h @@ -0,0 +1,24 @@ +#ifndef TOPFIELD_H +#define TOPFIELD_H + +#include "pirkeysetmetadata.h" + +class QObject; + +class TopfieldPVR1: public PIRKeysetMetaData +{ +public: + TopfieldPVR1( + QObject *guiObject, + unsigned int index); +}; + +class TopfieldSat1: public PIRKeysetMetaData +{ +public: + TopfieldSat1( + QObject *guiObject, + unsigned int index); +}; + +#endif // TOPFIELD_H diff --git a/mainwindow.cpp b/mainwindow.cpp index aa60e1b..3a88a6f 100644 --- a/mainwindow.cpp +++ b/mainwindow.cpp @@ -185,6 +185,7 @@ void MainWindow::enableButtons() emit volumeDownEnabled(myKeysets->hasKey(currentKeyset, VolumeDown_Key)); emit channelUpEnabled(myKeysets->hasKey(currentKeyset, ChannelUp_Key)); emit channelDownEnabled(myKeysets->hasKey(currentKeyset, ChannelDown_Key)); + emit muteEnabled(myKeysets->hasKey(currentKeyset, Mute_Key)); // Main tab labels: emit keysetMakeChanged( @@ -196,14 +197,15 @@ void MainWindow::enableButtons() emit greenEnabled(myKeysets->hasKey(currentKeyset, Green_Key)); emit yellowEnabled(myKeysets->hasKey(currentKeyset, Yellow_Key)); emit blueEnabled(myKeysets->hasKey(currentKeyset, Blue_Key)); + emit pictureModeEnabled(myKeysets->hasKey(currentKeyset, PictureMode_Key)); + emit soundModeEnabled(myKeysets->hasKey(currentKeyset, SoundMode_Key)); emit aspectRatioEnabled(myKeysets->hasKey(currentKeyset, AspectRatio_Key)); - emit surroundEnabled(myKeysets->hasKey(currentKeyset, Surround_Key)); +// emit surroundEnabled(myKeysets->hasKey(currentKeyset, Surround_Key)); emit audioEnabled(myKeysets->hasKey(currentKeyset, Audio_Key)); emit infoEnabled(myKeysets->hasKey(currentKeyset, Info_Key)); emit captionsEnabled(myKeysets->hasKey(currentKeyset, Captions_Key)); emit sleepEnabled(myKeysets->hasKey(currentKeyset, Sleep_Key)); emit inputEnabled(myKeysets->hasKey(currentKeyset, Input_Key)); - emit muteEnabled(myKeysets->hasKey(currentKeyset, Mute_Key)); // Keypad keys emit zeroEnabled(myKeysets->hasKey(currentKeyset, Zero_Key)); @@ -312,6 +314,16 @@ void MainWindow::on_mainVolumeDownButton_released() stopRepeating(); } +void MainWindow::on_muteButton_pressed() +{ + startRepeating(Mute_Key); +} + +void MainWindow::on_muteButton_released() +{ + stopRepeating(); +} + // Utility tab buttons: @@ -355,6 +367,26 @@ void MainWindow::on_blueButton_released() stopRepeating(); } +void MainWindow::on_pictureModeButton_pressed() +{ + startRepeating(PictureMode_Key); +} + +void MainWindow::on_pictureModeButton_released() +{ + stopRepeating(); +} + +void MainWindow::on_soundModeButton_pressed() +{ + startRepeating(PictureMode_Key); +} + +void MainWindow::on_soundModeButton_released() +{ + stopRepeating(); +} + void MainWindow::on_aspectRatioButton_pressed() { startRepeating(AspectRatio_Key); @@ -365,6 +397,7 @@ void MainWindow::on_aspectRatioButton_released() stopRepeating(); } +/* void MainWindow::on_surroundButton_pressed() { startRepeating(Surround_Key); @@ -374,6 +407,7 @@ void MainWindow::on_surroundButton_released() { stopRepeating(); } +*/ void MainWindow::on_audioButton_pressed() { @@ -425,16 +459,6 @@ void MainWindow::on_sleepButton_released() stopRepeating(); } -void MainWindow::on_muteButton_pressed() -{ - startRepeating(Mute_Key); -} - -void MainWindow::on_muteButton_released() -{ - stopRepeating(); -} - // Keypad tab buttons: diff --git a/mainwindow.h b/mainwindow.h index 1c4c1b2..238c5bd 100644 --- a/mainwindow.h +++ b/mainwindow.h @@ -48,19 +48,21 @@ signals: void volumeDownEnabled(bool); void channelUpEnabled(bool); void channelDownEnabled(bool); + void muteEnabled(bool); // Utility keys: void redEnabled(bool); void greenEnabled(bool); void yellowEnabled(bool); void blueEnabled(bool); + void pictureModeEnabled(bool); + void soundModeEnabled(bool); void aspectRatioEnabled(bool); - void surroundEnabled(bool); +// void surroundEnabled(bool); void audioEnabled(bool); void infoEnabled(bool); void captionsEnabled(bool); void inputEnabled(bool); - void muteEnabled(bool); void sleepEnabled(bool); // Keypad @@ -169,6 +171,8 @@ private slots: void on_mainVolumeUp_released(); void on_mainVolumeDownButton_pressed(); void on_mainVolumeDownButton_released(); + void on_muteButton_pressed(); + void on_muteButton_released(); // Utility tab slots: void on_redButton_pressed(); @@ -179,10 +183,14 @@ private slots: void on_yellowButton_released(); void on_blueButton_pressed(); void on_blueButton_released(); + void on_pictureModeButton_pressed(); + void on_pictureModeButton_released(); + void on_soundModeButton_pressed(); + void on_soundModeButton_released(); void on_aspectRatioButton_pressed(); void on_aspectRatioButton_released(); - void on_surroundButton_pressed(); - void on_surroundButton_released(); +// void on_surroundButton_pressed(); +// void on_surroundButton_released(); void on_audioButton_pressed(); void on_audioButton_released(); void on_infoButton_pressed(); @@ -193,8 +201,6 @@ private slots: void on_inputButton_released(); void on_sleepButton_pressed(); void on_sleepButton_released(); - void on_muteButton_pressed(); - void on_muteButton_released(); // Keypad tab slots: void on_oneButton_pressed(); diff --git a/mainwindow.ui b/mainwindow.ui index 6e5e237..8fc81c2 100644 --- a/mainwindow.ui +++ b/mainwindow.ui @@ -84,31 +84,128 @@ - - - - - 0 - 0 - - - - Qt::LeftToRight - - - Power + + + + -1 - - - :/icons/on-off_icon&48.png:/icons/on-off_icon&48.png - - - - 48 - 48 - + + 0 - + + + + + 0 + 0 + + + + Qt::LeftToRight + + + Power + + + + :/icons/on-off_icon&48.png:/icons/on-off_icon&48.png + + + + 48 + 48 + + + + + + + + Qt::Vertical + + + QSizePolicy::Minimum + + + + 20 + 20 + + + + + + + + + 0 + 0 + + + + Keyset Make + + + Qt::AlignCenter + + + + + + + + 0 + 0 + + + + Keyset Name + + + Qt::AlignCenter + + + + + + + Qt::Vertical + + + QSizePolicy::Minimum + + + + 20 + 20 + + + + + + + + + 0 + 0 + + + + Mute + + + + :/icons/sound_mute_icon&48.png:/icons/sound_mute_icon&48.png + + + + 48 + 48 + + + + + @@ -136,7 +233,7 @@ - + @@ -159,7 +256,7 @@ - + @@ -182,42 +279,6 @@ - - - - - - - 0 - 0 - - - - Keyset Make - - - Qt::AlignCenter - - - - - - - - 0 - 0 - - - - Keyset Name - - - Qt::AlignCenter - - - - - @@ -320,8 +381,8 @@ - - + + 0 @@ -329,25 +390,25 @@ - Aspect Ratio + I/II Audio - - + + - + 0 0 - Surround + Info - - + + 0 @@ -355,25 +416,25 @@ - I/II Audio + Input - - + + - + 0 0 - Info + Sleep - - + + 0 @@ -381,12 +442,12 @@ - CC / Subtitle + Aspect Ratio - - + + 0 @@ -394,12 +455,12 @@ - Input + CC / Subtitle - - + + 0 @@ -407,12 +468,12 @@ - Sleep + Sound Mode - - + + 0 @@ -420,17 +481,7 @@ - Mute - - - - :/icons/sound_mute_icon&48.png:/icons/sound_mute_icon&48.png - - - - 48 - 48 - + Picture Mode @@ -1405,8 +1456,8 @@ 222 - 683 - 334 + 399 + 393 @@ -1604,22 +1655,6 @@ MainWindow - powerEnabled(bool) - powerButton - setEnabled(bool) - - - 375 - 443 - - - 299 - 164 - - - - - MainWindow zeroEnabled(bool) zeroButton setEnabled(bool) @@ -1716,22 +1751,6 @@ MainWindow - keysetNameChanged(QString) - nameLabel - setText(QString) - - - 399 - 222 - - - 399 - 301 - - - - - MainWindow nextEnabled(bool) mediaNextButton setEnabled(bool) @@ -2004,22 +2023,6 @@ MainWindow - keysetMakeChanged(QString) - makeLabel - setText(QString) - - - 399 - 222 - - - 399 - 283 - - - - - MainWindow greenEnabled(bool) greenButton setEnabled(bool) @@ -2036,22 +2039,6 @@ MainWindow - surroundEnabled(bool) - surroundButton - setEnabled(bool) - - - 399 - 222 - - - 302 - 246 - - - - - MainWindow exitEnabled(bool) exitButton setEnabled(bool) @@ -2114,6 +2101,86 @@ + + MainWindow + keysetMakeChanged(QString) + makeLabel + setText(QString) + + + 399 + 222 + + + 399 + 283 + + + + + MainWindow + powerEnabled(bool) + powerButton + setEnabled(bool) + + + 375 + 443 + + + 299 + 164 + + + + + MainWindow + keysetNameChanged(QString) + nameLabel + setText(QString) + + + 399 + 222 + + + 399 + 301 + + + + + MainWindow + pictureModeEnabled(bool) + pictureModeButton + setEnabled(bool) + + + 399 + 239 + + + 103 + 406 + + + + + MainWindow + soundModeEnabled(bool) + soundModeButton + setEnabled(bool) + + + 399 + 239 + + + 103 + 264 + + + zeroEnabled(bool) diff --git a/pierogi.pro b/pierogi.pro index 92b1b24..3e041b1 100644 --- a/pierogi.pro +++ b/pierogi.pro @@ -85,7 +85,16 @@ SOURCES += main.cpp mainwindow.cpp \ keysets/bose.cpp \ protocols/boseprotocol.cpp \ keysets/mce.cpp \ - protocols/mceprotocol.cpp + protocols/mceprotocol.cpp \ + keysets/philco.cpp \ + keysets/roku.cpp \ + keysets/admiral.cpp \ + keysets/daewoo.cpp \ + protocols/daewooprotocol.cpp \ + keysets/grundig.cpp \ + keysets/topfield.cpp \ + keysets/logitech.cpp \ + protocols/necxprotocol.cpp HEADERS += mainwindow.h \ pirkeynames.h \ pirmakenames.h \ @@ -147,7 +156,16 @@ HEADERS += mainwindow.h \ protocols/boseprotocol.h \ keysets/bose.h \ keysets/mce.h \ - protocols/mceprotocol.h + protocols/mceprotocol.h \ + keysets/philco.h \ + keysets/roku.h \ + keysets/admiral.h \ + keysets/daewoo.h \ + protocols/daewooprotocol.h \ + keysets/grundig.h \ + keysets/topfield.h \ + keysets/logitech.h \ + protocols/necxprotocol.h FORMS += mainwindow.ui \ pirdocumentationform.ui \ piraboutform.ui \ diff --git a/pierogi.pro.user b/pierogi.pro.user index f703f80..cc0b605 100644 --- a/pierogi.pro.user +++ b/pierogi.pro.user @@ -1,6 +1,6 @@ - + ProjectExplorer.Project.ActiveTarget @@ -185,6 +185,7 @@ /Users/john/Develop/n900/pierogi-build-maemo-Qt_for_Fremantle_PR1_3_Devices__Qt_SDK__Release/pierogi_0_5_0_armel.deb /Users/john/Develop/n900/pierogi-build-maemo-Qt_for_Fremantle_PR1_3_Devices__Qt_SDK__Release/pierogi_0_1_5_armel.deb /Users/john/Develop/n900/pierogi-build-maemo-Qt_for_Fremantle_PR1_3_Devices__Qt_SDK__Release/pierogi_0_1_4_armel.deb + /Users/john/Develop/n900/pierogi-build-maemo-Qt_for_Fremantle_PR1_3_Devices__Qt_SDK__Release/pierogi_0_6_0_armel.deb /Users/john/Develop/n900/pierogi-build-maemo-Qt_for_Fremantle_PR1_3_Devices__Qt_SDK__Release/pierogi_0_1_3_armel.deb /Users/john/Develop/n900/pierogi-build-maemo-Qt_for_Fremantle_PR1_3_Devices__Qt_SDK__Release/pierogi_0_1_2_armel.deb /Users/john/Develop/n900/pierogi-build-maemo-Qt_for_Fremantle_PR1_3_Devices__Qt_SDK__Release/pierogi_0_1_1_armel.deb @@ -209,6 +210,7 @@ 192.168.0.15 192.168.0.15 192.168.0.15 + 192.168.0.15 localhost 192.168.0.15 192.168.0.15 @@ -228,11 +230,13 @@ + 2012-02-03T10:04:34 2012-01-23T09:47:37 2012-01-19T22:18:07 + 2012-02-11T18:03:15 2012-01-17T13:21:05 2012-01-17T12:19:28 2012-01-17T00:15:23 diff --git a/pirkeynames.h b/pirkeynames.h index 1a24bb9..7c50d61 100644 --- a/pirkeynames.h +++ b/pirkeynames.h @@ -41,6 +41,8 @@ enum PIRKeyName{ RearVolumeDown_Key, CenterVolumeUp_Key, CenterVolumeDown_Key, + WooferUp_Key, + WooferDown_Key, // Channel control: ChannelUp_Key, @@ -176,6 +178,8 @@ enum PIRKeyName{ CableInput_Key, SatInput_Key, DVRInput_Key, + OpticalInput_Key, + DigitalCoaxInput_Key, // "Program" Controls: Program_Key, diff --git a/pirkeysetmanager.cpp b/pirkeysetmanager.cpp index f9732f2..15d0de0 100644 --- a/pirkeysetmanager.cpp +++ b/pirkeysetmanager.cpp @@ -5,33 +5,40 @@ #include "pirkeysetwidgetitem.h" #include "keysets/acer.h" +#include "keysets/admiral.h" #include "keysets/aiwa.h" #include "keysets/apple.h" #include "keysets/bose.h" +#include "keysets/daewoo.h" #include "keysets/denon.h" #include "keysets/ei.h" #include "keysets/elgato.h" #include "keysets/goldstar.h" +#include "keysets/grundig.h" #include "keysets/hauppauge.h" #include "keysets/hitachi.h" #include "keysets/jvc.h" #include "keysets/lg.h" +#include "keysets/logitech.h" #include "keysets/magnavox.h" #include "keysets/mce.h" #include "keysets/mitsubishi.h" #include "keysets/nokia.h" #include "keysets/panasonic.h" +#include "keysets/philco.h" #include "keysets/philips.h" #include "keysets/pinnacle.h" #include "keysets/pioneer.h" #include "keysets/raite.h" #include "keysets/rca.h" +#include "keysets/roku.h" #include "keysets/sagem.h" #include "keysets/samsung.h" #include "keysets/sanyo.h" #include "keysets/sharp.h" #include "keysets/sony.h" #include "keysets/tivo.h" +#include "keysets/topfield.h" #include "keysets/toshiba.h" #include "keysets/westinghouse.h" #include "keysets/yamaha.h" @@ -60,6 +67,9 @@ PIRKeysetManager::PIRKeysetManager( populateKeyset(new AcerTV1(guiObject, counter++)); populateKeyset(new AcerPC1(guiObject, counter++)); + populateKeyset(new AdmiralTV1(guiObject, counter++)); + populateKeyset(new AdmiralVCR1(guiObject, counter++)); + populateKeyset(new AiwaVCR1(guiObject, counter++)); populateKeyset(new AiwaVCR2(guiObject, counter++)); populateKeyset(new AiwaVCR3(guiObject, counter++)); @@ -82,6 +92,12 @@ PIRKeysetManager::PIRKeysetManager( populateKeyset(new BoseRadio2(guiObject, counter++)); populateKeyset(new BoseRadio3(guiObject, counter++)); + populateKeyset(new DaewooTV1(guiObject, counter++)); + populateKeyset(new DaewooTV2(guiObject, counter++)); + populateKeyset(new DaewooDVD1(guiObject, counter++)); + populateKeyset(new DaewooVCR1(guiObject, counter++)); + populateKeyset(new DaewooVCR2(guiObject, counter++)); + populateKeyset(new DenonDVD1(guiObject, counter++)); populateKeyset(new DenonDVD2(guiObject, counter++)); populateKeyset(new DenonDVD3(guiObject, counter++)); @@ -116,6 +132,18 @@ PIRKeysetManager::PIRKeysetManager( populateKeyset(new GoldStarVCR1c(guiObject, counter++)); populateKeyset(new GoldStarCD1(guiObject, counter++)); + populateKeyset(new GrundigSat1(guiObject, counter++)); + populateKeyset(new GrundigSat2(guiObject, counter++)); + populateKeyset(new GrundigAmp1(guiObject, counter++)); + populateKeyset(new GrundigAudio1(guiObject, counter++)); + populateKeyset(new GrundigAudio2(guiObject, counter++)); + populateKeyset(new GrundigVCR1(guiObject, counter++)); + populateKeyset(new GrundigVCR1a(guiObject, counter++)); + populateKeyset(new GrundigTV1(guiObject, counter++)); + populateKeyset(new GrundigTV2(guiObject, counter++)); + populateKeyset(new GrundigTV3(guiObject, counter++)); + populateKeyset(new GrundigDVD1(guiObject, counter++)); + populateKeyset(new HauppaugePCTV1(guiObject, counter++)); populateKeyset(new HauppaugePCTV1a(guiObject, counter++)); populateKeyset(new HauppaugePCTV1b(guiObject, counter++)); @@ -159,13 +187,15 @@ PIRKeysetManager::PIRKeysetManager( populateKeyset(new LGTV2(guiObject, counter++)); populateKeyset(new LGTV2a(guiObject, counter++)); populateKeyset(new LGTV2b(guiObject, counter++)); -// populateKeyset(new LGDisc1(guiObject, counter++)); -// populateKeyset(new LGDisc2(guiObject, counter++)); -// populateKeyset(new LGDisc2a(guiObject, counter++)); + populateKeyset(new LGDisc1(guiObject, counter++)); + populateKeyset(new LGDisc2(guiObject, counter++)); + populateKeyset(new LGDisc2a(guiObject, counter++)); populateKeyset(new LGVCR1(guiObject, counter++)); populateKeyset(new LGVCR1a(guiObject, counter++)); populateKeyset(new LGVCR1b(guiObject, counter++)); + populateKeyset(new LogitechSpeakers(guiObject, counter++)); + populateKeyset(new MagnavoxDVD1(guiObject, counter++)); populateKeyset(new MagnavoxVCR1(guiObject, counter++)); populateKeyset(new MagnavoxConverterBox1(guiObject, counter++)); @@ -201,6 +231,8 @@ PIRKeysetManager::PIRKeysetManager( populateKeyset(new PanasonicDVD1a(guiObject, counter++)); populateKeyset(new PanasonicAudio1(guiObject, counter++)); + populateKeyset(new PhilcoTV(guiObject, counter++)); + populateKeyset(new PhilipsTV1(guiObject, counter++)); populateKeyset(new PhilipsTV1a(guiObject, counter++)); populateKeyset(new PhilipsTV1b(guiObject, counter++)); @@ -269,6 +301,9 @@ PIRKeysetManager::PIRKeysetManager( populateKeyset(new RCASat1(guiObject, counter++)); populateKeyset(new RCASat2(guiObject, counter++)); + populateKeyset(new RokuBox1(guiObject, counter++)); + populateKeyset(new RokuBox2(guiObject, counter++)); + populateKeyset(new SagemTVBox1(guiObject, counter++)); populateKeyset(new SagemTVBox1a(guiObject, counter++)); @@ -335,6 +370,9 @@ PIRKeysetManager::PIRKeysetManager( populateKeyset(new Tivo1c(guiObject, counter++)); populateKeyset(new Tivo1d(guiObject, counter++)); + populateKeyset(new TopfieldPVR1(guiObject, counter++)); + populateKeyset(new TopfieldSat1(guiObject, counter++)); + populateKeyset(new ToshibaTV1(guiObject, counter++)); populateKeyset(new ToshibaTV1a(guiObject, counter++)); populateKeyset(new ToshibaTV1b(guiObject, counter++)); diff --git a/pirmakenames.cpp b/pirmakenames.cpp index e272745..f74ed5d 100644 --- a/pirmakenames.cpp +++ b/pirmakenames.cpp @@ -6,33 +6,40 @@ PIRMakeMgr::PIRMakeMgr() { makes[Any_Make] = "Any"; makes[Acer_Make] = "Acer"; + makes[Admiral_Make] = "Admiral"; makes[Aiwa_Make] = "Aiwa"; makes[Apple_Make] = "Apple"; makes[Bose_Make] = "Bose"; + makes[Daewoo_Make] = "Daewoo"; makes[Denon_Make] = "Denon"; makes[Ei_Make] = "Ei"; makes[Elgato_Make] = "Elgato"; makes[GoldStar_Make] = "GoldStar"; + makes[Grundig_Make] = "Grundig"; makes[Hauppauge_Make] = "Hauppauge"; makes[Hitachi_Make] = "Hitachi"; makes[JVC_Make] = "JVC"; makes[LG_Make] = "LG"; + makes[Logitech_Make] = "Logitech"; makes[Magnavox_Make] = "Magnavox"; makes[Microsoft_Make] = "Microsoft"; makes[Mitsubishi_Make] = "Mitsubishi"; makes[Nokia_Make] = "Nokia"; makes[Panasonic_Make] = "Panasonic"; + makes[Philco_Make] = "Philco"; makes[Philips_Make] = "Philips"; makes[Pinnacle_Make] = "Pinnacle Systems"; makes[Pioneer_Make] = "Pioneer"; makes[Raite_Make] = "Raite"; makes[RCA_Make] = "RCA"; + makes[Roku_Make] = "Roku"; makes[Sagem_Make] = "Sagem"; makes[Samsung_Make] = "Samsung"; makes[Sanyo_Make] = "Sanyo"; makes[Sharp_Make] = "Sharp"; makes[Sony_Make] = "Sony"; makes[Tivo_Make] = "TiVo"; + makes[Topfield_Make] = "Topfield"; makes[Toshiba_Make] = "Toshiba"; makes[Westinghouse_Make] = "Westinghouse"; makes[Yamaha_Make] = "Yamaha"; diff --git a/pirmakenames.h b/pirmakenames.h index ff50d30..ff8e407 100644 --- a/pirmakenames.h +++ b/pirmakenames.h @@ -7,33 +7,40 @@ class QComboBox; enum PIRMakeName{ Any_Make, Acer_Make, + Admiral_Make, Aiwa_Make, Apple_Make, Bose_Make, + Daewoo_Make, Denon_Make, Ei_Make, Elgato_Make, GoldStar_Make, + Grundig_Make, Hauppauge_Make, Hitachi_Make, JVC_Make, LG_Make, + Logitech_Make, Magnavox_Make, Microsoft_Make, Mitsubishi_Make, Nokia_Make, Panasonic_Make, + Philco_Make, Philips_Make, Pinnacle_Make, Pioneer_Make, Raite_Make, RCA_Make, + Roku_Make, Sagem_Make, Samsung_Make, Sanyo_Make, Sharp_Make, Sony_Make, Tivo_Make, + Topfield_Make, Toshiba_Make, Westinghouse_Make, Yamaha_Make, diff --git a/protocols/daewooprotocol.cpp b/protocols/daewooprotocol.cpp new file mode 100644 index 0000000..24c71ff --- /dev/null +++ b/protocols/daewooprotocol.cpp @@ -0,0 +1,130 @@ +#include "daewooprotocol.h" + +#include "pirrx51hardware.h" + +#include "pirexception.h" + +// Some global communications stuff: +#include +extern bool commandInFlight; +extern QMutex commandIFMutex; + +// Daewoo is using a protocol similar to NEC, but with the distinction that +// it does not send inverted copies of the address and command, and it places +// a 550 usec pulse / 2000 usec space between the address and the command. +// Here are the fine details: +// A "zero" is encoded with a 550 usec pulse, 450 usec space. +// A "one" is encoded with a 550 usec pulse, and 1450 usec space. +// The header is a 8000 usec pulse, 4000 usec space. +// There is a mid-way marker of 550 usec pulse, 2000 usec space. +// The pulse train ends with a trailing 550 usec pulse. +// The entire train is resent for repeats. +// Each command runs for 60000 usec before another can be executed. +// The carrier frequency is 38 kHz. + +DaewooProtocol::DaewooProtocol( + QObject *guiObject, + unsigned int index) + : SpaceProtocol( + guiObject, index, + 550, 450, + 550, 1450, + 8000, 4000, + 550, + 60000, true), + midPulse(550), + midSpace(2000) +{ +} + + +void DaewooProtocol::startSendingCommand( + unsigned int threadableID, + PIRKeyName command) +{ + // Exceptions here are problematic; I'll try to weed them out by putting the + // whole thing in a try/catch block: + try + { + // First, check if we are meant to be the recipient of this command: + if (threadableID != id) return; + + clearRepeatFlag(); + + KeycodeCollection::const_iterator i = keycodes.find(command); + + // Do we even have this key defined? + if (i == keycodes.end()) + { + std::string s = "Tried to send a non-existent command.\n"; + throw PIRException(s); + } + + // construct the device: + PIRRX51Hardware rx51device(carrierFrequency, dutyCycle); + + int repeatCount = 0; + int commandDuration = 0; + while (repeatCount < MAX_REPEAT_COUNT) + { + commandDuration = generateStandardCommand((*i).second, rx51device); + + // Now, tell the device to send the whole command: + rx51device.sendCommandToDevice(); + + // sleep until the next repetition of command: + sleepUntilRepeat(commandDuration); + + // Check whether we've reached the minimum required number of repetitons: + if (repeatCount >= minimumRepetitions) + { + // Check whether we've been asked to stop: + if (checkRepeatFlag()) + { + QMutexLocker cifLocker(&commandIFMutex); + commandInFlight = false; + return; + } + } + + ++repeatCount; + } + } + catch (PIRException e) + { + // inform the gui: + emit commandFailed(e.getError().c_str()); + } + + QMutexLocker cifLocker(&commandIFMutex); + commandInFlight = false; +} + + +int DaewooProtocol::generateStandardCommand( + const PIRKeyBits &pkb, + PIRRX51Hardware &rx51device) +{ + int duration = 0; + + // First, the "header" pulse: + rx51device.addPair(headerPulse, headerSpace); + duration += (headerPulse + headerSpace); + + // The address data: + duration += pushReverseBits(preData, rx51device); + + // The Daewoo mid-train marker: + rx51device.addPair(midPulse, midSpace); + duration += (midPulse + midSpace); + + // The command data: + duration += pushReverseBits(pkb.firstCode, rx51device); + + // Finally add the "trail": + rx51device.addSingle(trailerPulse); + duration += trailerPulse; + + return duration; +} + diff --git a/protocols/daewooprotocol.h b/protocols/daewooprotocol.h new file mode 100644 index 0000000..bb3cf73 --- /dev/null +++ b/protocols/daewooprotocol.h @@ -0,0 +1,35 @@ +#ifndef DAEWOOPROTOCOL_H +#define DAEWOOPROTOCOL_H + +#include "spaceprotocol.h" + +class PIRRX51Hardware; + +// +// Daewoo is using something that looks like a simplified NEC protocol, +// lacking the inverted copy of the data that NEC sends, and with the addition +// of a marker bit sent inbetween the address and the command. +// + +class DaewooProtocol: public SpaceProtocol +{ +public: + DaewooProtocol( + QObject *guiObject, + unsigned int index); + +public slots: + void startSendingCommand( + unsigned int threadableID, + PIRKeyName command); + +private: + unsigned int midPulse; + unsigned int midSpace; + + int generateStandardCommand( + const PIRKeyBits &bits, + PIRRX51Hardware &device); +}; + +#endif // DAEWOOPROTOCOL_H diff --git a/protocols/necprotocol.cpp b/protocols/necprotocol.cpp index c29e539..9aaffbd 100644 --- a/protocols/necprotocol.cpp +++ b/protocols/necprotocol.cpp @@ -14,8 +14,10 @@ extern QMutex commandIFMutex; // 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. +// A repeat block (if used) is a 9000 usec pulse, 2250 usec space, then +// trailing pulse. // Each command runs for 110000 usec before another can be executed. +// The normal carrier frequency is 38 kHz. NECProtocol::NECProtocol( QObject *guiObject, diff --git a/protocols/necxprotocol.cpp b/protocols/necxprotocol.cpp new file mode 100644 index 0000000..1ca40e4 --- /dev/null +++ b/protocols/necxprotocol.cpp @@ -0,0 +1,158 @@ +#include "necxprotocol.h" + +#include "pirrx51hardware.h" + +#include "pirexception.h" + +// Some global communications stuff: +#include +extern bool commandInFlight; +extern QMutex commandIFMutex; + +// The NECX protocol is a slight variation of the NEC protocol. It features +// a slightly different header and a slightly different repeat mechanism. +// Most of them use the "extended" address form, so I'll just assume that all +// of them do. (It won't hurt anything.) +// Otherwise it is nearly identical: +// 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 4500 usec pulse, 4500 usec space. +// Commands end with a trailing 560 usec pulse. +// A repeat block (if used) is a 4500 usec pulse, 4500 usec space, then a 1 +// (560 usec pulse, 1680 usec space), then the trailing pulse. +// Each command runs for 110000 usec before another can be executed. +// The carrier frequency is 38 kHz. + +NECXProtocol::NECXProtocol( + QObject *guiObject, + unsigned int index, + bool srtRep) + : SpaceProtocol( + guiObject, index, + 560, 560, + 560, 1680, + 4500, 4500, + 560, + 110000, true), + isShortRepeat(srtRep) +{ +} + + +void NECXProtocol::startSendingCommand( + unsigned int threadableID, + PIRKeyName command) +{ + // Exceptions here are problematic; I'll try to weed them out by putting the + // whole thing in a try/catch block: + try + { + // First, check if we are meant to be the recipient of this command: + if (threadableID != id) return; + + clearRepeatFlag(); + + KeycodeCollection::const_iterator i = keycodes.find(command); + + // Do we even have this key defined? + if (i == keycodes.end()) + { + std::string s = "Tried to send a non-existent command.\n"; + throw PIRException(s); + } + + // construct the device: + PIRRX51Hardware rx51device(carrierFrequency, dutyCycle); + + int repeatCount = 0; + int commandDuration = 0; + while (repeatCount < MAX_REPEAT_COUNT) + { + // If we are currently repeating, and have a special "repeat signal", + // use that signal. Otherwise, generate a normal command string. + if (isShortRepeat && repeatCount) + { + commandDuration = generateRepeatCommand(rx51device); + } + else + { + commandDuration = generateStandardCommand((*i).second, rx51device); + } + + // Now, tell the device to send the whole command: + rx51device.sendCommandToDevice(); + + // sleep until the next repetition of command: + sleepUntilRepeat(commandDuration); + + // Check whether we've reached the minimum required number of repetitons: + if (repeatCount >= minimumRepetitions) + { + // Check whether we've been asked to stop: + if (checkRepeatFlag()) + { + QMutexLocker cifLocker(&commandIFMutex); + commandInFlight = false; + return; + } + } + + ++repeatCount; + } + } + catch (PIRException e) + { + // inform the gui: + emit commandFailed(e.getError().c_str()); + } + + QMutexLocker cifLocker(&commandIFMutex); + commandInFlight = false; +} + + +int NECXProtocol::generateStandardCommand( + const PIRKeyBits &pkb, + PIRRX51Hardware &rx51device) +{ + int duration = 0; + + // First, the "header" pulse: + rx51device.addPair(headerPulse, headerSpace); + duration += (headerPulse + headerSpace); + + // In NECX, the address is 16 bits, and is only sent once. The command + // portion is 8 bits, and an inverted copy is sent. + // - "preData" should contain 16-bit value + // - "bits" should contain 8-bit value + duration += pushReverseBits(preData, rx51device); + duration += pushReverseBits(pkb.firstCode, rx51device); + duration += pushInvertedReverseBits(pkb.firstCode, rx51device); + + // Finally add the "trail": + rx51device.addSingle(trailerPulse); + duration += trailerPulse; + + return duration; +} + + +int NECXProtocol::generateRepeatCommand( + PIRRX51Hardware &rx51device) +{ + int duration = 0; + + // Start with the header: + rx51device.addPair(headerPulse, headerSpace); + duration += (headerPulse + headerSpace); + + // Add a "1": + rx51device.addPair(onePulse, oneSpace); + duration += (onePulse + oneSpace); + + // Add the trailer: + rx51device.addSingle(trailerPulse); + duration += trailerPulse; + + return duration; +} diff --git a/protocols/necxprotocol.h b/protocols/necxprotocol.h new file mode 100644 index 0000000..795ef46 --- /dev/null +++ b/protocols/necxprotocol.h @@ -0,0 +1,38 @@ +#ifndef NECXPROTOCOL_H +#define NECXPROTOCOL_H + +#include "spaceprotocol.h" + +class PIRRX51Hardware; + +// +// The "NECX" protocol is a slight variation on the popular NEC protocol. +// It includes the "short repeat" feature of NEC, but implements it in a +// slightly different way. +// + +class NECXProtocol: public SpaceProtocol +{ +public: + NECXProtocol( + QObject *guiObject, + unsigned int index, + bool srtRep); + +public slots: + void startSendingCommand( + unsigned int threadableID, + PIRKeyName command); + +private: + bool isShortRepeat; + + int generateStandardCommand( + const PIRKeyBits &bits, + PIRRX51Hardware &device); + + int generateRepeatCommand( + PIRRX51Hardware &device); +}; + +#endif // NECXPROTOCOL_H diff --git a/protocols/samsungprotocol.cpp b/protocols/samsungprotocol.cpp index 6b53b3a..9c6593d 100644 --- a/protocols/samsungprotocol.cpp +++ b/protocols/samsungprotocol.cpp @@ -8,7 +8,7 @@ SamsungProtocol::SamsungProtocol( true, // extended NEC false) // doesn't use short repeat { - // Samsung doesn't use the normal header, don't ask mey why... + // Samsung doesn't use the normal header, don't ask me why... headerPulse = 4500; headerSpace = 4500; } diff --git a/protocols/sharpprotocol.cpp b/protocols/sharpprotocol.cpp index d880ef5..cecc731 100644 --- a/protocols/sharpprotocol.cpp +++ b/protocols/sharpprotocol.cpp @@ -125,7 +125,7 @@ int SharpProtocol::generateStandardCommand( duration += pushReverseBits(pkb.secondCode, rx51device); // Next, there is an "expansion" bit and a "check" bit. Not entirely sure - // what these two do. The check bit is fixed at "1". + // what these two do. The check bit is fixed at "0". if (expansionBit) { rx51device.addPair(onePulse, oneSpace); diff --git a/qtc_packaging/debian_fremantle/changelog b/qtc_packaging/debian_fremantle/changelog index f85d271..f56ade2 100644 --- a/qtc_packaging/debian_fremantle/changelog +++ b/qtc_packaging/debian_fremantle/changelog @@ -1,3 +1,10 @@ +pierogi (0.6.1) unstable; urgency=low + * Moved Mute button to main tab, brought Picture Mode and Sound Mode back up to utility tab + * Added keysets for Admiral, Daewoo, Grundig, Logitech, Philco, Roku, and Topfield + * Added several new protocols, including one that LG uses (so LG needs more testing) + + -- John Pietrzak Sat, 11 Feb 2012 18:08:31 -0500 + pierogi (0.6.0) unstable; urgency=low * My first candidate for Extras-Testing, so up to version 0.6 * Fixed some bugs in Toshiba keysets diff --git a/qtc_packaging/debian_fremantle/control b/qtc_packaging/debian_fremantle/control index 2f000e4..b455e73 100644 --- a/qtc_packaging/debian_fremantle/control +++ b/qtc_packaging/debian_fremantle/control @@ -9,10 +9,10 @@ Homepage: http://pierogi.garage.maemo.org Package: pierogi Architecture: armel Depends: ${shlibs:Depends}, ${misc:Depends} -Description: Universal Infrared Remote Control for N900 +Description: Universal Infrared (IR) Remote Control for N900 Pierogi is a Universal Infrared Remote Control app for the Nokia N900. It is independent from the LIRC server, and stores all configuration info internally. -XB-Maemo-Upgrade-Description: First Extras-Testing Candidate - Pierogi is now somewhat stable, so I will start cleaning it up for submission to Extras-Testing. Also in this update, new MCE keysets, and cleanup of Toshiba keysets. +XB-Maemo-Upgrade-Description: UI change, lots more keysets + Due to popular demand, the Mute button has been moved to the main tab. Also added lots of keysets: Admiral, Daewoo, Grundig, Logitech, Philco, Roku, and Topfield. As usual, these all need to be tested! XSBC-Bugtracker: https://garage.maemo.org/tracker/?func=add&group_id=2286&atid=7641 XB-Maemo-Display-Name: Pierogi XB-Maemo-Icon-26: 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 -- 1.7.9.5