Exemple #1
0
int DaewooProtocol::generateStandardCommand(
  const PIRKeyBits &pkb,
  PIRInfraredLED &led)
{
  int duration = 0;

  // First, the "header" pulse:
  led.addPair(headerPulse, headerSpace);
  duration += (headerPulse + headerSpace);

  // The address data:
  duration += pushReverseBits(preData, led);

  // The Daewoo mid-train marker:
  led.addPair(midPulse, midSpace);
  duration += (midPulse + midSpace);

  // The command data:
  duration += pushReverseBits(pkb.firstCode, led);

  // Finally add the "trail":
  led.addSingle(trailerPulse);
  duration += trailerPulse;

  return duration;
}
int KathreinProtocol::generateStandardCommand(
  const PIRKeyBits &pkb,
  PIRInfraredLED &led)
{
  int duration = 0;

  // First, the "header" pulse:
  led.addPair(headerPulse, headerSpace);
  duration += (headerPulse + headerSpace);

  // Kathrein protocol has four bits of address and eight bits of command.
  // As in NEC protocol, the address and command are complemented.
  // - "preData" should contain the 4-bit address
  // - "firstCode" should contain the 8-bit command
  duration += pushReverseBits(preData, led);
  duration += pushInvertedReverseBits(preData, led);
  duration += pushReverseBits(pkb.firstCode, led);
  duration += pushInvertedReverseBits(pkb.firstCode, led);

  // Finally add the "trail":
  led.addSingle(trailerPulse);
  duration += trailerPulse;

  return duration;
}
Exemple #3
0
int AiwaProtocol::generateStandardCommand(
  const PIRKeyBits &pkb,
  PIRInfraredLED &led)
{
  int duration = 0;

  // First, the "header" pulse:
  led.addPair(headerPulse, headerSpace);
  duration += (headerPulse + headerSpace);

  // From the information I've got, the "address" portion of the Aiwa protocol
  // might be split into 8-bit device and 5-bit subdevice subsections, but
  // for now, I'm just lumping both into a single 13-bit address value.
  // The command is an 8-bit value.
  // As with NEC, the address is sent LSB first, then inverted LSB first,
  // then the command is sent LSB first, then inverted LSB first.
  duration += pushReverseBits(preData, led);
  duration += pushInvertedReverseBits(preData, led);
  duration += pushReverseBits(pkb.firstCode, led);
  duration += pushInvertedReverseBits(pkb.firstCode, led);

  // Finally add the "trail":
  led.addSingle(trailerPulse);
  duration += trailerPulse;

  return duration;
}
Exemple #4
0
int ProtonProtocol::generateStandardCommand(
  const PIRKeyBits &pkb,
  PIRInfraredLED &led)
{
  int duration = 0;

  // First, the "header" pulse:
  led.addPair(headerPulse, headerSpace);
  duration += (headerPulse + headerSpace);

  // The Proton protocol contains an 8 bit address and an 8 bit command,
  // in LSB order.  Between these two is a gap made up of a 500 usec pulse
  // and a 4000 usec space.
  // - "preData" should contain the address.
  // - "firstCode" should contain the command.

  duration += pushReverseBits(preData, led);

  led.addPair(500, 4000);
  duration += 4500;

  duration += pushReverseBits(pkb.firstCode, led);

  // Finally add the "trail":
  led.addSingle(trailerPulse);
  duration += trailerPulse;

  return duration;
}
Exemple #5
0
int DenonProtocol::generateRepeatCommand(
  const PIRKeyBits &pkb,
  PIRInfraredLED &led)
{
  int duration = 0;

  // The address should be 5 bits long, and the control data 8 bits.
  // For the repeat, the control data is inverted.
  // Both are sent in LSB order.
  duration += pushReverseBits(pkb.firstCode, led);
  duration += pushInvertedReverseBits(pkb.secondCode, led);

  // Next, two One bits are sent (the inverse of the normal command):
  led.addPair(onePulse, oneSpace);
  duration += onePulse + oneSpace;

  led.addPair(onePulse, oneSpace);
  duration += onePulse + oneSpace;

  // Finally add the "trail":
  led.addSingle(trailerPulse);
  duration += trailerPulse;

  return duration;
}
int MitsubishiProtocol::generateCommand(
  const PIRKeyBits &pkb,
  PIRInfraredLED &led)
{
  int duration = 0;

  // For this protocol, the device code and command code are both 8 bits,
  // and sent in LSB order:
  duration += pushReverseBits(preData, led);
  duration += pushReverseBits(pkb.firstCode, led);

  // Finally add the "trail" bit:
  led.addSingle(trailerPulse);
  duration += trailerPulse;

  return duration;
}
Exemple #7
0
int NECProtocol::generateStandardCommand(
    const PIRKeyBits &pkb,
    PIRInfraredLED &led)
{
    int duration = 0;

    // First, the "header" pulse:
    led.addPair(headerPulse, headerSpace);
    duration += (headerPulse + headerSpace);

    // Now, check the encoding format:
    if (isExtendedNEC)
    {
        // In extended NEC, the address has been extended to 16 bits, and is only
        // sent once.  The command portion stays the same.
        // - "preData" should contain 16-bit value
        // - "bits" should contain 8-bit value
        duration += pushReverseBits(preData, led);
        duration += pushReverseBits(pkb.firstCode, led);
        duration += pushInvertedReverseBits(pkb.firstCode, led);
    }
    else
    {
        // Standard NEC is made up of an eight-bit "address" and an eight-bit
        // "command".  First the address bits are sent (in reverse order), then
        // the address bits are inverted and sent again (in reverse order).
        // Next, we do the same to the command bits.
        // - "preData" should contain 8-bit value
        // - "bits" should contain 8-bit value
        duration += pushReverseBits(preData, led);
        duration += pushInvertedReverseBits(preData, led);
        duration += pushReverseBits(pkb.firstCode, led);
        duration += pushInvertedReverseBits(pkb.firstCode, led);
    }

    // Finally add the "trail":
    led.addSingle(trailerPulse);
    duration += trailerPulse;

    return duration;
}
int PanasonicProtocol::generateStandardCommand(
  const PIRKeyBits &pkb,
  PIRInfraredLED &led)
{
  int duration = 0;

  // First, the header pulse:
  led.addPair(headerPulse, headerSpace);
  duration += (headerPulse + headerSpace);

  // Similar to the "Kaseikyo" protocol, this protocol is 48 bits long.
  // In this case, the first 16 bits are a fixed value (defining the
  // manufacturer?).  Next comes eight bits for the "device", eight more
  // bits for the "subdevice", and then eight bits for the "command".
  // Finally, the last eight bits are a checksum generated by x-oring the
  // device, subdevice, and command bytes.

  // The 16 manufacturer code bits:
  duration += pushReverseBits(preData, led);

  // The eight device bits:
  duration += pushReverseBits(pkb.firstCode, led);

  // The eight subdevice bits:
  duration += pushReverseBits(pkb.secondCode, led);

  // The eight command bits:
  duration += pushReverseBits(pkb.thirdCode, led);

  // Finally, the checksum:
  CommandSequence checksum;
  generateChecksum(pkb.firstCode, pkb.secondCode, pkb.thirdCode, checksum);
  duration += pushReverseBits(checksum, led);

  // Add the trailer pulse:
  led.addSingle(trailerPulse);
  duration += trailerPulse;

  return duration;
}
Exemple #9
0
int F12Protocol::generateRepeatableCommand(
  const PIRKeyBits &pkb,
  PIRInfraredLED &led)
{
  int duration = 0;

  // In the F12 protocol, the device code has 3 bits, and the command has 8
  // (sort of).  In reality, bits 4, 5, and 6 are "mode" bits, but it seems
  // 5 and 6 get pushed into the two least significant bits of the command
  // by the sources I've got (the command being sent in LSB mode).  This
  // method is only for "repeatable" commands, so bit 4 is always going to
  // be "1".
  // 
  // - "preData" contains 3-bit device code.
  // - "pkb.firstCode" contains 8-bit command code.
  duration += pushReverseBits(preData, led);
  led.addPair(onePulse, oneSpace);
  duration += (onePulse + oneSpace);
  duration += pushReverseBits(pkb.firstCode, led);

  return duration;
}
Exemple #10
0
int NECXProtocol::generateStandardCommand(
  const PIRKeyBits &pkb,
  PIRInfraredLED &led)
{
  int duration = 0;

  // First, the "header" pulse:
  led.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, led);
  duration += pushReverseBits(pkb.firstCode, led);
  duration += pushInvertedReverseBits(pkb.firstCode, led);

  // Finally add the "trail":
  led.addSingle(trailerPulse);
  duration += trailerPulse;

  return duration;
}
Exemple #11
0
int DenonProtocol::generateCommand(
  const PIRKeyBits &pkb,
  PIRInfraredLED &led)
{
  int duration = 0;

  // The address should be 5 bits long, and the control data 8 bits.
  // Both are sent in LSB order.
  duration += pushReverseBits(pkb.firstCode, led);
  duration += pushReverseBits(pkb.secondCode, led);

  // Next, two Zero bits are sent:
  led.addPair(zeroPulse, zeroSpace);
  duration += zeroPulse + zeroSpace;

  led.addPair(zeroPulse, zeroSpace);
  duration += zeroPulse + zeroSpace;

  // Finally add the "trail":
  led.addSingle(trailerPulse);
  duration += trailerPulse;

  return duration;
}
void SamsungACProtocol::generateTimerCommand(
  PIRInfraredLED &led)
{
  // First, the "header" pulse:
  led.addPair(headerPulse, headerSpace);

  // Next, the "address" information (12 bits):
  pushReverseBits(preData, led);

  // The checksum (4 bits):
  CommandSequence checksum;
  calculateTimerChecksum(checksum);
  pushReverseBits(checksum, led);

  // Push an 0xF to indicate this is a timer command.
  pushBits(timerHeader, led);

  // if this is an off timer, push the time, otherwise 0:
  if (timerCommandType == 0x4)
  {
    pushReverseBits(timerMinutes, led);
    pushReverseBits(timerHours, led);
  }
  else
  {
    pushBits(emptyTimer, led);
  }

  // if this is an on timer, push the time, otherwise 0:
  if (timerCommandType == 0x2)
  {
    pushReverseBits(timerMinutes, led);
    pushReverseBits(timerHours, led);
  }
  else
  {
    pushBits(emptyTimer, led);
  }

  // This is a hack to add in 4 bits of 0:
  pushBits(fourBitZero, led);

  // Push the timer command type:
  pushReverseBits(timerOption, led);

  // Finish off the command:
  pushBits(timerFooter, led);

  // Add the "trail":
  led.addSingle(trailerPulse);
}
void SamsungACProtocol::generateCommand(
  PIRInfraredLED &led)
{
  // First, the "header" pulse:
  led.addPair(headerPulse, headerSpace);

  // Next, the "address" information (12 bits):
  pushReverseBits(preData, led);

  // Now, the fun part.  We'll need to construct a massive command, containing
  // all the state information for the air conditioner.

  // First, calculate and push the checksum (4 bits):
  CommandSequence checksum;
  calculateChecksum(checksum);
  pushReverseBits(checksum, led);

  // Next, push the swing mode (8 bits):
  pushReverseBits(swing, led);

  // Next, the turbo mode (8 bits):
  pushReverseBits(turbo, led);

  // Next, the temperature (8 bits):
  pushReverseBits(temperature, led);

  // Next, the fan (4 bits):
  pushReverseBits(fan, led);

  // Next, the mode (4 bits):
  pushReverseBits(mode, led);

  // Next, "air clean" (4 bits):
  pushReverseBits(airclean, led);

  // Next, power (4 bits):
  pushReverseBits(power, led);

  // Finally add the "trail":
  led.addSingle(trailerPulse);
}
int KathreinProtocol::generateRepeatCommand(
  const PIRKeyBits &pkb,
  PIRInfraredLED &led)
{
  int duration = 0;

  // First, the "header" pulse:
  led.addPair(headerPulse, headerSpace);
  duration += (headerPulse + headerSpace);

  // The Kathrein repeat block contains the 8-bit command and nothing else:
  duration += pushReverseBits(pkb.firstCode, led);

  // Finally add the "trail":
  led.addSingle(trailerPulse);
  duration += trailerPulse;

  return duration;
}
Exemple #15
0
int BoseProtocol::generateStandardCommand(
  const PIRKeyBits &pkb,
  PIRInfraredLED &led)
{
  int duration = 0;

  // First, the "header" pulse:
  led.addPair(headerPulse, headerSpace);
  duration += (headerPulse + headerSpace);

  // The Bose protocol uses 1/2 of the NEC protocol; it has the command
  // portion, but no device address portion.  So, we only need to reverse
  // the command, then invert and reverse the command:
  duration += pushReverseBits(pkb.firstCode, led);
  duration += pushInvertedReverseBits(pkb.firstCode, led);

  // Finally add the "trail":
  led.addSingle(trailerPulse);
  duration += trailerPulse;

  return duration;
}
Exemple #16
0
int GIProtocol::generateStandardCommand(
  const PIRKeyBits &pkb,
  PIRInfraredLED &led)
{
  int duration = 0;

  // First, the "header" pulse:
  led.addPair(headerPulse, headerSpace);
  duration += (headerPulse + headerSpace);

  // The GI protocol consists of a 4-bit device code and an 8-bit command.
  // These are sent in reverse order.  Finally, a checksum is added at the
  // end.  I am lacking enough information to calculate the checksum right
  // now, so I'm going to dump all 16 bits into the "firstCode" in MSB
  // order, and reverse them here:

  duration += pushReverseBits(pkb.firstCode, led);

  // Finally add the "trail":
  led.addSingle(trailerPulse);
  duration += trailerPulse;

  return duration;
}