vcs.maemo.org Git - pierogi/blob - protocols/panasonicoldprotocol.cpp

   1 #include "panasonicoldprotocol.h"
   2
   3 #include "pirrx51hardware.h"
   4
   5 #include "pirexception.h"
   6
   7 #include <QMutex>
   8 extern bool commandInFlight;
   9 extern QMutex commandIFMutex;
  10
  11 // The "Panasonic Old" protocol appears to have the following features:
  12 // A "zero" is encoded with an 833 usec pulse, 833 usec space.
  13 // A "one" is encoded with an 833 usec pulse, and 3*833 (2499) usec space.
  14 // The header is a 3332 usec pulse, 3332 usec space.
  15 // Commands end with a trailing 833 usec pulse.
  16 // When repeating, the entire command is re-sent.
  17 // Each command runs for approximately 105000 usec (need to check this)
  18 // The carrier frequency might be 57.6 kHz.
  19
  20 PanasonicOldProtocol::PanasonicOldProtocol(
  21   QObject *guiObject,
  22   unsigned int index)
  23   : SpaceProtocol(
  24       guiObject, index,
  25       833, 833,
  26       833, 2499,
  27       3332, 3332,
  28       833,
  29       105000, true)
  30 {
  31 }
  32
  33
  34 void PanasonicOldProtocol::startSendingCommand(
  35   unsigned int threadableID,
  36   PIRKeyName command)
  37 {
  38   // Exceptions here are problematic; I'll try to weed them out by putting the
  39   // whole thing in a try/catch block:
  40   try
  41   {
  42     // First, check if we are meant to be the recipient of this command:
  43     if (threadableID != id) return;
  44
  45     clearRepeatFlag();
  46
  47     KeycodeCollection::const_iterator i = keycodes.find(command);
  48
  49     // Do we even have this key defined?
  50     if (i == keycodes.end())
  51     {
  52       QMutexLocker cifLocker(&commandIFMutex);
  53       commandInFlight = false;
  54       return;
  55 //      std::string s = "Tried to send a non-existent command.\n";
  56 //      throw PIRException(s);
  57     }
  58
  59     // construct the device:
  60     PIRRX51Hardware rx51device(carrierFrequency, dutyCycle);
  61
  62     int repeatCount = 0;
  63     int commandDuration = 0;
  64     while (repeatCount < MAX_REPEAT_COUNT)
  65     {
  66       commandDuration = generateStandardCommand((*i).second, rx51device);
  67
  68       // Now, tell the device to send the whole command:
  69       rx51device.sendCommandToDevice();
  70
  71       // sleep until the next repetition of command:
  72       sleepUntilRepeat(commandDuration);
  73
  74       // Check whether we've reached the minimum required number of repetitons:
  75       if (repeatCount >= minimumRepetitions)
  76       {
  77         // Check whether we've been asked to stop:
  78         if (checkRepeatFlag())
  79         {
  80           break;
  81 /*
  82           QMutexLocker cifLocker(&commandIFMutex);
  83           commandInFlight = false;
  84           return;
  85 */
  86         }
  87       }
  88
  89       ++repeatCount;
  90     }
  91
  92     QMutexLocker cifLocker(&commandIFMutex);
  93     commandInFlight = false;
  94   }
  95   catch (PIRException e)
  96   {
  97     // inform the gui:
  98     emit commandFailed(e.getError().c_str());
  99   }
 100 }
 101
 102
 103 int PanasonicOldProtocol::generateStandardCommand(
 104   const PIRKeyBits &pkb,
 105   PIRRX51Hardware &rx51device)
 106 {
 107   int duration = 0;
 108
 109   // First, the header pulse:
 110   rx51device.addPair(headerPulse, headerSpace);
 111   duration += (headerPulse + headerSpace);
 112
 113   // Supposedly, this protocol uses 5 bits of address and 6 bits of command,
 114   // but it looks like the address can be variable.  So, I'm going to treat
 115   // them as more-or-less two separate sets of command data.
 116   //
 117   // It is laid out as follows:
 118   // 1) the five bits of "address" data
 119   // 2) the six bits of command data
 120   // 3) repeat of the five bits of address data, inverted
 121   // 4) repeat of the six bits of command data, inverted
 122
 123   duration += pushReverseBits(pkb.firstCode, rx51device);
 124   duration += pushReverseBits(pkb.secondCode, rx51device);
 125   duration += pushInvertedReverseBits(pkb.firstCode, rx51device);
 126   duration += pushInvertedReverseBits(pkb.secondCode, rx51device);
 127
 128   // Add the trailer pulse:
 129   rx51device.addSingle(trailerPulse);
 130   duration += trailerPulse;
 131
 132   return duration;
 133 }