Update IRRemoteESP8266 version to 2.5.5

factorize IR send signal function between the 2 types of receiving
Add new IRRemoteESP8266 protocols
replace pins on mega according schema
remove unecessaries spaces

lib/IRremoteESP8266/src/ir_Pioneer.cpp

@@ -0,0 +1,143 @@
+// Copyright 2009 Ken Shirriff
+// Copyright 2017, 2018 David Conran
+// Copyright 2018 Kamil Palczewski
+
+#define __STDC_LIMIT_MACROS
+#include <stdint.h>
+#include <algorithm>
+#include "IRrecv.h"
+#include "IRsend.h"
+#include "IRutils.h"
+#include "ir_NEC.h"
+
+//                        PPPP  III  OOO  N   N EEEE EEEE RRRR
+//                        P   P  I  O   O NN  N E    E    R   R
+//                        PPPP   I  O   O N N N EEE  EEE  RRRR
+//                        P      I  O   O N  NN E    E    R R
+//                        P     III  OOO  N   N EEEE EEEE R  RR
+
+// Ref:
+//  http://adrian-kingston.com/IRFormatPioneer.htm
+
+#if SEND_PIONEER
+// Send a raw Pioneer formatted message.
+//
+// Args:
+//   data:   The message to be sent.
+//   nbits:  The number of bits of the message to be sent.
+//           Typically kPioneerBits.
+//   repeat: The number of times the command is to be repeated.
+//
+// Status: BETA / Expected to be working.
+//
+// Ref:
+//  http://adrian-kingston.com/IRFormatPioneer.htm
+void IRsend::sendPioneer(const uint64_t data, const uint16_t nbits,
+                         const uint16_t repeat) {
+  // If nbits is to big, or is odd, abort.
+  if (nbits > sizeof(data) * 8 || nbits % 2 == 1) return;
+
+  // send 1st part of the code
+  sendNEC(data >> (nbits / 2), nbits / 2, 0);
+  // send 2nd part of the code
+  sendNEC(data & (((uint64_t)1 << (nbits / 2)) - 1), nbits / 2, repeat);
+}
+
+// Calculate the raw Pioneer data code based on two NEC sub-codes
+// Args:
+//   address A 16-bit "published" NEC value.
+//   command: A 16-bit "published" NEC value.
+// Returns:
+//   A raw 64-bit Pioneer message code.
+//
+// Status: BETA / Expected to work.
+//
+// Note:
+//   Address & Command can be take from a decode result OR from the spreadsheets
+//   located at:
+//     https://www.pioneerelectronics.com/PUSA/Support/Home-Entertainment-Custom-Install/IR+Codes/A+V+Receivers
+//   where the first part is considered the address,
+//   and the second the command.
+//   e.g.
+//   "A556+AF20" is an Address of 0xA556 & a Command of 0xAF20.
+uint64_t IRsend::encodePioneer(const uint16_t address, const uint16_t command) {
+  return (((uint64_t)encodeNEC(address >> 8, address & 0xFF)) << 32) |
+         encodeNEC(command >> 8, command & 0xFF);
+}
+#endif  // SEND_PIONEER
+
+#if DECODE_PIONEER
+// Decode the supplied Pioneer message.
+//
+// Args:
+//   results: Ptr to the data to decode and where to store the decode result.
+//   nbits:   The number of data bits to expect. Typically kPioneerBits.
+//   strict:  Flag indicating if we should perform strict matching.
+// Returns:
+//   boolean: True if it can decode it, false if it can't.
+//
+// Status: BETA / Should be working. (Self decodes & real examples)
+//
+bool IRrecv::decodePioneer(decode_results *results, const uint16_t nbits,
+                           const bool strict) {
+  if (results->rawlen < 2 * (nbits + kHeader + kFooter) - 1)
+    return false;  // Can't possibly be a valid Pioneer message.
+  if (strict && nbits != kPioneerBits)
+    return false;  // Not strictly an Pioneer message.
+
+  uint64_t data = 0;
+  uint16_t offset = kStartOffset;
+
+  for (uint16_t section = 0; section < 2; section++) {
+    // Header
+    if (!matchMark(results->rawbuf[offset], kNecHdrMark)) return false;
+    // Calculate how long the lowest tick time is based on the header mark.
+    uint32_t mark_tick =
+        results->rawbuf[offset++] * kRawTick / kNecHdrMarkTicks;
+    if (!matchSpace(results->rawbuf[offset], kNecHdrSpace)) return false;
+    // Calculate how long the common tick time is based on the header space.
+    uint32_t space_tick =
+        results->rawbuf[offset++] * kRawTick / kNecHdrSpaceTicks;
+    //
+    // Data
+    match_result_t data_result = matchData(
+        &(results->rawbuf[offset]), nbits / 2, kNecBitMarkTicks * mark_tick,
+        kNecOneSpaceTicks * space_tick, kNecBitMarkTicks * mark_tick,
+        kNecZeroSpaceTicks * space_tick);
+    if (data_result.success == false) return false;
+    uint8_t command = data_result.data >> 8;
+    uint8_t command_inverted = data_result.data;
+    uint8_t address = data_result.data >> 24;
+    uint8_t address_inverted = data_result.data >> 16;
+    // Compliance
+    if (strict) {
+      if (command != (command_inverted ^ 0xFF))
+        return false;  // Command integrity failed.
+      if (address != (address_inverted ^ 0xFF))
+        return false;  // Address integrity failed.
+    }
+    data = (data << (nbits / 2)) + data_result.data;
+    offset += data_result.used;
+    // NEC-like commands and addresses are technically in LSB first order so the
+    // final versions have to be reversed.
+    uint16_t code = reverseBits((command << 8) + address, 16);
+    if (section)
+      results->command = code;
+    else
+      results->address = code;
+
+    // Footer
+    if (!matchMark(results->rawbuf[offset++], kNecBitMarkTicks * mark_tick))
+      return false;
+    if (offset < results->rawlen &&
+        !matchAtLeast(results->rawbuf[offset++], kNecMinGapTicks * space_tick))
+      return false;
+  }
+
+  // Success
+  results->bits = nbits;
+  results->value = data;
+  results->decode_type = PIONEER;
+  return true;
+}
+#endif  // DECODE_PIONEER