Reverted RC5 and RC6 to old decode method.

Author: ArminJo

README.md

@@ -12,7 +12,7 @@ Available as Arduino library "IRremote"
 This library enables you to send and receive using infra-red signals on an Arduino.
 
 # API
-A Doxygen documentation of the sources is available on [project homepage](https://arduino-irremote.github.io/Arduino-IRremote/).
+A Doxygen documentation of the sources is available on the [project homepage](https://arduino-irremote.github.io/Arduino-IRremote/).
 
 # Installation
 Click on the LibraryManager badge above to see the [instructions](https://www.ardu-badge.com/IRremote/zip).
@@ -82,7 +82,7 @@ If you do not know which protocol your IR transmitter uses, you have several cho
  the old [IRLib](https://github.com/cyborg5/IRLib) and [Infrared4Arduino](https://github.com/bengtmartensson/Infrared4Arduino).
 - To **increase strength of sent output signal** you can increase the current through the send diode, and/or use 2 diodes in series,
  since one IR diode requires only 1.5 volt.
- - The line #include "ATtinySerialOut.h" in PinDefinitionsAndMore.h (requires the library to be installed) saves 370 bytes program space and 38 bytes RAM for **Digispark boards** as well as enables serial output at 8MHz.
+ - The line \#include "ATtinySerialOut.h" in PinDefinitionsAndMore.h (requires the library to be installed) saves 370 bytes program space and 38 bytes RAM for **Digispark boards** as well as enables serial output at 8MHz.
  - The default software generated PWM has **problems on ATtinies running with 8 MHz**. The PWM frequency is around 30 instead of 38 kHz and RC6 is not reliable. You can switch to timer PWM generation by `#define SEND_PWM_BY_TIMER`.
 
 # Examples

examples/UnitTest/UnitTest.ino

@@ -105,7 +105,10 @@ void checkReceive(uint16_t aSentAddress, uint16_t aSentCommand) {
 // Print a short summary of received data
         IrReceiver.printIRResultShort(&Serial);
 
-        if (IrReceiver.decodedIRData.protocol == UNKNOWN || digitalRead(DEBUG_BUTTON_PIN) == LOW) {
+        if (IrReceiver.decodedIRData.flags & IRDATA_FLAGS_WAS_OVERFLOW) {
+            IrReceiver.decodedIRData.flags = false; // yes we have recognized the flag :-)
+            Serial.println(F("Overflow detected"));
+        } else if (IrReceiver.decodedIRData.protocol == UNKNOWN || digitalRead(DEBUG_BUTTON_PIN) == LOW) {
             // We have an unknown protocol, print more info
             IrReceiver.printIRResultRawFormatted(&Serial, true);
         } else {
@@ -325,7 +328,6 @@ void loop() {
 //    IrSender.sendLegoPowerFunctions(sAddress, sCommand, LEGO_MODE_COMBO, true);
 //    checkReceive(sAddress, sCommand); // never has success for Lego protocol :-(
 //    delay(DELAY_AFTER_SEND);
-
     /*
      * Force buffer overflow
      */

src/IRReceive.cpp.h

@@ -31,8 +31,6 @@
  ************************************************************************************
  */
 
-//#define DEBUG
-
 /** \addtogroup Receiving Receiving IR data for multiple protocols
  * @{
  */
@@ -586,112 +584,76 @@ bool IRrecv::decodePulseDistanceData(uint8_t aNumberOfBits, uint8_t aStartOffset
     return true;
 }
 
-//#  define DBG_PRINT(...)    Serial.print(__VA_ARGS__)
-//#  define DBG_PRINTLN(...)  Serial.println(__VA_ARGS__)
-//#  define TRACE_PRINT(...)    Serial.print(__VA_ARGS__)
-//#  define TRACE_PRINTLN(...)  Serial.println(__VA_ARGS__)
+/*
+ * Static variables for the getBiphaselevel function
+ */
+uint8_t sBiphaseDecodeRawbuffOffset;// Index into raw timing array
+uint16_t sCurrentTimingIntervals;   // Number of aBiphaseTimeUnit intervals of the current rawbuf[sBiphaseDecodeRawbuffOffset] timing.
+uint8_t sUsedTimingIntervals;       // Number of already used intervals of sCurrentTimingIntervals.
+uint16_t sBiphaseTimeUnit;
+
+void IRrecv::initBiphaselevel(uint8_t aRCDecodeRawbuffOffset, uint16_t aBiphaseTimeUnit) {
+    sBiphaseDecodeRawbuffOffset = aRCDecodeRawbuffOffset;
+    sBiphaseTimeUnit = aBiphaseTimeUnit;
+    sUsedTimingIntervals = 0;
+}
+
 /**
- * Decode Biphase protocols
- * We "regenerate" the clock and check changes on the significant clock transition
- * We assume that the transition from (aStartOffset -1) to aStartOffset is a significant clock transition
- *
- * The first bit is assumed as start bit and excluded for result
+ * Gets the level of one time interval (aBiphaseTimeUnit) at a time from the raw buffer.
+ * The RC5/6 decoding is easier if the data is broken into time intervals.
+ * E.g. if the buffer has mark for 2 time intervals and space for 1,
+ * successive calls to getBiphaselevel will return 1, 1, 0.
  *
- * Input is     IrReceiver.decodedIRData.rawDataPtr->rawbuf[]
- * Output is    IrReceiver.decodedIRData.decodedRawData
- *
- * @param aStartOffset must point to a mark
- * @return true if decoding was successful
+ *               _   _   _   _   _   _   _   _   _   _   _   _   _
+ *         _____| |_| |_| |_| |_| |_| |_| |_| |_| |_| |_| |_| |_| |
+ *                ^   ^   ^   ^   ^   ^   ^   ^   ^   ^   ^   ^   ^    Significant clock edge
+ *               _     _   _   ___   _     ___     ___   _   - Mark
+ * Data    _____| |___| |_| |_|   |_| |___|   |___|   |_| |  - Data starts with a mark->space bit
+ *                1   0   0   0   1   1   0   1   0   1   1  - Space
+ * A mark to space at a significant clock edge results in a 1
+ * A space to mark at a significant clock edge results in a 0 (for RC6)
+ * Returns current level [MARK or SPACE] or -1 for error (measured time interval is not a multiple of sBiphaseTimeUnit).
  */
-bool IRrecv::decodeBiPhaseData(uint8_t aNumberOfBits, uint8_t aStartOffset, uint8_t aValueOfSpaceToMarkTransition,
-        uint16_t aBiphaseTimeUnit) {
+uint8_t IRrecv::getBiphaselevel() {
+    uint8_t tLevelOfCurrentInterval; // 0 (SPACE) or 1 (MARK)
 
-    uint16_t *tRawBufPointer = &decodedIRData.rawDataPtr->rawbuf[aStartOffset];
-    bool tCheckMark = aStartOffset & 1;
-    uint_fast8_t tClockCount = 0; // assume that first transition is significant
-    aValueOfSpaceToMarkTransition &= 1; // only 0 or 1 are valid
-    uint32_t tDecodedData = 0;
-
-    for (uint_fast8_t tBitIndex = 0; tBitIndex < aNumberOfBits;) {
-        if (tCheckMark) {
-            /*
-             *  Check mark and determine current (and next) bit value
-             */
-            if (matchMark(*tRawBufPointer, aBiphaseTimeUnit)) {
-                // we have a transition here from space to mark
-                tClockCount++;
-                // for BiPhaseCode, we have a transition at every odd clock count.
-                if (tClockCount & 1) {
-                    // valid clock edge
-                    tDecodedData = (tDecodedData << 1) | aValueOfSpaceToMarkTransition;
-                    TRACE_PRINT(aValueOfSpaceToMarkTransition);
-                    tBitIndex++;
-                }
-            } else if (matchMark(*tRawBufPointer, 2 * aBiphaseTimeUnit)) {
-                tClockCount = 0; // can reset clock count here
-                // We have a double length mark this includes two valid clock edges
-                tDecodedData = (tDecodedData << 1) | aValueOfSpaceToMarkTransition;
-                TRACE_PRINT(aValueOfSpaceToMarkTransition);
-
-                tBitIndex++;
+    if (sBiphaseDecodeRawbuffOffset >= decodedIRData.rawDataPtr->rawlen) {
+        return SPACE;  // After end of recorded buffer, assume space.
+    }
 
-            } else {
-                /*
-                 * Use TRACE_PRINT here, since this normally checks the length of the start bit and therefore will happen very often
-                 */
-                TRACE_PRINT(F("Mark="));
-                TRACE_PRINT(*tRawBufPointer * MICROS_PER_TICK);
-                TRACE_PRINT(F(" is not "));
-                TRACE_PRINT(aBiphaseTimeUnit);
-                TRACE_PRINT(F(" or "));
-                TRACE_PRINT(2 * aBiphaseTimeUnit);
-                TRACE_PRINT(' ');
-                return false;
-            }
+    tLevelOfCurrentInterval = (sBiphaseDecodeRawbuffOffset) & 1; // on odd rawbuf offsets we have mark timings
 
+    /*
+     * Setup data if sUsedTimingIntervals is 0
+     */
+    if (sUsedTimingIntervals == 0) {
+        uint16_t tCurrentTimingWith = decodedIRData.rawDataPtr->rawbuf[sBiphaseDecodeRawbuffOffset];
+        uint16_t tMarkExcessCorrection = (tLevelOfCurrentInterval == MARK) ? MARK_EXCESS_MICROS : -MARK_EXCESS_MICROS;
+
+        if (matchTicks(tCurrentTimingWith, (sBiphaseTimeUnit) + tMarkExcessCorrection)) {
+            sCurrentTimingIntervals = 1;
+        } else if (matchTicks(tCurrentTimingWith, (2 * sBiphaseTimeUnit) + tMarkExcessCorrection)) {
+            sCurrentTimingIntervals = 2;
+        } else if (matchTicks(tCurrentTimingWith, (3 * sBiphaseTimeUnit) + tMarkExcessCorrection)) {
+            sCurrentTimingIntervals = 3;
         } else {
-            /*
-             * Check space - simulate last not recorded space
-             */
-            if (tRawBufPointer == &decodedIRData.rawDataPtr->rawbuf[decodedIRData.rawDataPtr->rawlen]
-                    || matchSpace(*tRawBufPointer, aBiphaseTimeUnit)) {
-                // we have a transition here from mark to space
-                tClockCount++;
-                if (tClockCount & 1) {
-                    // valid clock edge
-                    tDecodedData = (tDecodedData << 1) | (aValueOfSpaceToMarkTransition ^ 1);
-                    TRACE_PRINT((aValueOfSpaceToMarkTransition ^ 1));
-                    tBitIndex++;
-                }
-            } else if (matchSpace(*tRawBufPointer, 2 * aBiphaseTimeUnit)) {
-                // We have a double length space -> current bit value is 0 and changes to 1
-                tClockCount = 0;                // can reset clock count here
-                // We have a double length mark this includes two valid clock edges
-                if (tBitIndex == 0) {
-                    TRACE_PRINT('S'); // do not put start bit into data
-                } else {
-                    tDecodedData = (tDecodedData << 1) | (aValueOfSpaceToMarkTransition ^ 1);
-                    TRACE_PRINT((aValueOfSpaceToMarkTransition ^ 1));
-                }
-                tBitIndex++;
-            } else {
-                DBG_PRINT(F("Space="));
-                DBG_PRINT(*tRawBufPointer * MICROS_PER_TICK);
-                DBG_PRINT(F(" is not "));
-                DBG_PRINT(aBiphaseTimeUnit);
-                DBG_PRINT(F(" or "));
-                DBG_PRINT(2 * aBiphaseTimeUnit);
-                DBG_PRINT(' ');
-                return false;
-            }
+            return -1;
         }
-        tRawBufPointer++;
-        tCheckMark = !tCheckMark;
+    }
 
+    // We use another interval from tCurrentTimingIntervals
+    sUsedTimingIntervals++;
+
+    // keep track of current timing offset
+    if (sUsedTimingIntervals >= sCurrentTimingIntervals) {
+        // we have used all intervals of current timing, switch to next timing value
+        sUsedTimingIntervals = 0;
+        sBiphaseDecodeRawbuffOffset++;
     }
-    TRACE_PRINTLN("");
-    decodedIRData.decodedRawData = tDecodedData;
-    return true;
+
+    TRACE_PRINTLN(tLevelOfCurrentInterval);
+
+    return tLevelOfCurrentInterval;
 }
 
 #if defined(DECODE_HASH)
@@ -979,12 +941,12 @@ void IRrecv::printIRResultShort(Print *aSerial) {
 }
 
 /**
- * Function to print protocol, address, command,raw data and repeat flag of IrReceiver.decodedIRData in one short line.
+ * Function to print protocol number, address, command, raw data and repeat flag of IrReceiver.decodedIRData in one short line.
  * @param aSerial The Print object on which to write, for Arduino you can use &Serial.
  */
 void IRrecv::printIRResultMinimal(Print *aSerial) {
     aSerial->print(F("P="));
-    aSerial->print(getProtocolString(decodedIRData.protocol));
+    aSerial->print(decodedIRData.protocol);
     if (decodedIRData.protocol == UNKNOWN) {
 #if defined(DECODE_HASH)
         aSerial->print(F(" #=0x"));
@@ -1311,7 +1273,7 @@ ISR () // for functions definitions which are called by separate (board specific
 //    switch (irparams.StateForISR) {
 //......................................................................
     if (irparams.StateForISR == IR_REC_STATE_IDLE) { // In the middle of a gap
-        if (irdata == MARK) {
+        if (irdata == INPUT_MARK) {
             // check if we did not start in the middle of an command by checking the minimum length of leading space
             if (irparams.TickCounterForISR > RECORD_GAP_TICKS) {
                 // Gap just ended; Record gap duration + start recording transmission
@@ -1328,7 +1290,7 @@ ISR () // for functions definitions which are called by separate (board specific
         }
 
     } else if (irparams.StateForISR == IR_REC_STATE_MARK) {  // Timing Mark
-        if (irdata != MARK) {   // Mark ended; Record time
+        if (irdata != INPUT_MARK) {   // Mark ended; Record time
 #if defined(IR_MEASURE_TIMING) && defined(IR_TIMING_TEST_PIN)
 //            digitalWriteFast(IR_TIMING_TEST_PIN, HIGH); // 2 clock cycles
 #endif
@@ -1338,7 +1300,7 @@ ISR () // for functions definitions which are called by separate (board specific
         }
 
     } else if (irparams.StateForISR == IR_REC_STATE_SPACE) {  // Timing Space
-        if (irdata == MARK) {  // Space just ended; Record time
+        if (irdata == INPUT_MARK) {  // Space just ended; Record time
             if (irparams.rawlen >= RAW_BUFFER_LENGTH) {
                 // Flag up a read OverflowFlag; Stop the State Machine
                 irparams.OverflowFlag = true;
@@ -1369,14 +1331,14 @@ ISR () // for functions definitions which are called by separate (board specific
 #if defined(IR_MEASURE_TIMING) && defined(IR_TIMING_TEST_PIN)
 //        digitalWriteFast(IR_TIMING_TEST_PIN, HIGH); // 2 clock cycles
 #endif
-        if (irdata == MARK) {
+        if (irdata == INPUT_MARK) {
             irparams.TickCounterForISR = 0;  // Reset gap TickCounterForISR, to prepare for call of resume()
         }
     }
 
 #if !defined(DISABLE_LED_FEEDBACK_FOR_RECEIVE)
     if (FeedbackLEDControl.LedFeedbackEnabled) {
-        setFeedbackLED(irdata == MARK);
+        setFeedbackLED(irdata == INPUT_MARK);
     }
 #endif
 

src/IRSend.cpp.h

@@ -29,7 +29,7 @@
  *
  ************************************************************************************
  */
-//#define DEBUG
+
 #include "IRremoteInt.h"
 
 __attribute((error("Version > 3.0.1"))) void UsageError(const char *details);

src/IRremote.h

@@ -3,9 +3,10 @@
  *
  * @brief Public API to the library.
  *
- *
+ * @code
  * !!! All the macro values defined here can be overwritten with values,    !!!
  * !!! the user defines in its source code BEFORE the #include <IRremote.h> !!!
+ * @endcode
  *
  * This file is part of Arduino-IRremote https://github.com/Arduino-IRremote/Arduino-IRremote.
  *
@@ -89,6 +90,8 @@
 #warning "The macros DECODE_XXX no longer require a value. Decoding is now switched by defining / non defining the macro."
 #endif
 
+//#define DEBUG // Activate this for lots of lovely debug output from the IRremote core.
+
 /**
  * For better readability of code
  */
@@ -136,12 +139,10 @@
 //#define IR_INPUT_IS_ACTIVE_HIGH
 #ifdef IR_INPUT_IS_ACTIVE_HIGH
 // IR detector output is active high
-#define MARK   1 ///< Sensor output for a mark ("flash")
-#define SPACE  0 ///< Sensor output for a space ("gap")
+#define INPUT_MARK   1 ///< Sensor output for a mark ("flash")
 #else
 // IR detector output is active low
-#define MARK   0 ///< Sensor output for a mark ("flash")
-#define SPACE  1 ///< Sensor output for a space ("gap")
+#define INPUT_MARK   0 ///< Sensor output for a mark ("flash")
 #endif
 /****************************************************
  *                     SENDING

src/IRremoteInt.h

@@ -41,6 +41,9 @@
 #error RAW_BUFFER_LENGTH must be even, since the array consists of space / mark pairs.
 #endif
 
+#define MARK   1
+#define SPACE  0
+
 /*
  * Try to activate it, if you have legacy code to compile with version >= 3
  */
@@ -78,7 +81,7 @@ struct irparams_struct {
     uint16_t rawbuf[RAW_BUFFER_LENGTH]; ///< raw data / tick counts per mark/space, first entry is the length of the gap between previous and current command
 };
 
-//#define DEBUG // Activate this for lots of lovely debug output.
+//#define DEBUG // Activate this for lots of lovely debug output from the IRremote core and all protocol decoders.
 /*
  * Debug directives
  */
@@ -147,7 +150,7 @@ struct IRData {
     uint16_t address;           ///< Decoded address
     uint16_t command;           ///< Decoded command
     uint16_t extra;             ///< Used by MagiQuest and for Kaseikyo unknown vendor ID
-    uint8_t numberOfBits; ///< Number of bits received for data (address + command + parity) - to determine protocol length if different length are possible (currently only Sony).
+    uint8_t numberOfBits;       ///< Number of bits received for data (address + command + parity) - to determine protocol length if different length are possible.
     uint8_t flags;              ///< See IRDATA_FLAGS_* definitions above
     uint32_t decodedRawData;    ///< Up to 32 bit decoded raw data, used for sendRaw functions.
     irparams_struct *rawDataPtr; ///< Pointer of the raw timing data to be decoded. Mainly the data buffer filled by receiving ISR.
@@ -219,9 +222,12 @@ class IRrecv {
     bool decodePulseWidthData(uint8_t aNumberOfBits, uint8_t aStartOffset, uint16_t aOneMarkMicros, uint16_t aZeroMarkMicros,
             uint16_t aBitSpaceMicros, bool aMSBfirst);
 
-    bool decodeBiPhaseData(uint8_t aNumberOfBits, uint8_t aStartOffset, uint8_t aValueOfSpaceToMarkTransition,
+    bool decodeBiPhaseData(uint_fast8_t aNumberOfBits, uint_fast8_t aStartOffset, uint_fast8_t aStartClockCount, uint_fast8_t aValueOfSpaceToMarkTransition,
             uint16_t aBiphaseTimeUnit);
 
+    void initBiphaselevel(uint8_t aRCDecodeRawbuffOffset, uint16_t aBiphaseTimeUnit);
+    uint8_t getBiphaselevel();
+
     /*
      * All standard (decode address + command) protocol decoders
      */
@@ -271,6 +277,8 @@ class IRrecv {
     uint8_t repeatCount;        // Used e.g. for Denon decode for autorepeat decoding.
 };
 
+extern uint8_t sBiphaseDecodeRawbuffOffset; //
+
 /*
  * Mark & Space matching functions
  */

src/ir_BoseWave.cpp

@@ -6,10 +6,14 @@
  *  This file is part of Arduino-IRremote https://github.com/Arduino-IRremote/Arduino-IRremote.
  *
  */
+#include <Arduino.h>
 
-//#define DEBUG // Activate this for lots of lovely debug output.
-#include "IRremoteInt.h"
+//#define DEBUG // Activate this for lots of lovely debug output from this decoder.
+#include "IRremoteInt.h" // evaluates the DEBUG for DBG_PRINT
 
+/** \addtogroup Decoder Decoders and encoders for different protocols
+ * @{
+ */
 //==============================================================================
 //                           BBBB    OOO    SSSS  EEEEE
 //                           B   B  O   O  S      E
@@ -123,3 +127,5 @@ bool IRrecv::decodeBoseWave() {
 
     return true;
 }
+
+/** @}*/