Bang & Olufsen support plus higher precision and frequency PWM generation

src/IRrecv.cpp

@@ -1185,6 +1185,10 @@ bool IRrecv::decode(decode_results *results, irparams_t *save,
     DPRINTLN("Attempting York decode");
     if (decodeYork(results, offset, kYorkBits)) return true;
 #endif  // DECODE_YORK
+#if DECODE_BANG_OLUFSEN
+    DPRINTLN("Attempting Bang & Olufsen decode");
+    if (decodeBangOlufsen(results, offset)) return true;
+#endif  // DECODE_BANG_OLUFSEN
   // Typically new protocols are added above this line.
   }
 #if DECODE_HASH

src/IRrecv.h

@@ -883,6 +883,12 @@ class IRrecv {
                   const uint16_t kYorkBits,
                   const bool strict = true);
 #endif  // DECODE_YORK
+#if DECODE_BANG_OLUFSEN
+  bool decodeBangOlufsen(decode_results *results,
+                  uint16_t offset = kStartOffset,
+                  const uint16_t nbits = kBangOlufsenBits,
+                  const bool strict = false);
+#endif  // DECODE_BANG_OLUFSEN
 };
 
 #endif  // IRRECV_H_

src/IRremoteESP8266.h

@@ -952,6 +952,13 @@
 #define SEND_YORK           _IR_ENABLE_DEFAULT_
 #endif  // SEND_YORK
 
+#ifndef DECODE_BANG_OLUFSEN
+#define DECODE_BANG_OLUFSEN          _IR_ENABLE_DEFAULT_
+#endif  // DECODE_BANG_OLUFSEN
+#ifndef SEND_BANG_OLUFSEN
+#define SEND_BANG_OLUFSEN            _IR_ENABLE_DEFAULT_
+#endif  // SEND_BANG_OLUFSEN
+
 #if (DECODE_ARGO || DECODE_DAIKIN || DECODE_FUJITSU_AC || DECODE_GREE || \
      DECODE_KELVINATOR || DECODE_MITSUBISHI_AC || DECODE_TOSHIBA_AC || \
      DECODE_TROTEC || DECODE_HAIER_AC || DECODE_HITACHI_AC || \
@@ -1137,8 +1144,9 @@ enum decode_type_t {
   WOWWEE,
   CARRIER_AC84,  // 125
   YORK,
+  BANG_OLUFSEN,
   // Add new entries before this one, and update it to point to the last entry.
-  kLastDecodeType = YORK,
+  kLastDecodeType = BANG_OLUFSEN,
 };
 
 // Message lengths & required repeat values
@@ -1435,6 +1443,7 @@ const uint16_t kRhossDefaultRepeat = 0;
 const uint16_t kClimaButlerBits = 52;
 const uint16_t kYorkBits = 136;
 const uint16_t kYorkStateLength = 17;
+const uint16_t kBangOlufsenBits = 16;
 
 
 // Legacy defines. (Deprecated)

src/IRsend.cpp

@@ -26,7 +26,7 @@
 ///  i.e. If not, assume a 100% duty cycle. Ignore attempts to change the
 ///  duty cycle etc.
 IRsend::IRsend(uint16_t IRsendPin, bool inverted, bool use_modulation)
-    : IRpin(IRsendPin), periodOffset(kPeriodOffset) {
+    : IRpin(IRsendPin) {
   if (inverted) {
     outputOn = LOW;
     outputOff = HIGH;
@@ -68,15 +68,12 @@ void IRsend::ledOn() {
 /// @param[in] use_offset Should we use the calculated offset or not?
 /// @return nr. of uSeconds.
 /// @note (T = 1/f)
-uint32_t IRsend::calcUSecPeriod(uint32_t hz, bool use_offset) {
+uint32_t IRsend::calcUSecPeriod(uint32_t hz) {
   if (hz == 0) hz = 1;  // Avoid Zero hz. Divide by Zero is nasty.
   uint32_t period =
       (1000000UL + hz / 2) / hz;  // The equiv of round(1000000/hz).
-  // Apply the offset and ensure we don't result in a <= 0 value.
-  if (use_offset)
-    return std::max((uint32_t)1, period + periodOffset);
-  else
-    return std::max((uint32_t)1, period);
+  // Ensure we don't result in a <= 0 value.
+  return std::max((uint32_t)1, period);
 }
 
 /// Set the output frequency modulation and duty cycle.
@@ -101,11 +98,34 @@ void IRsend::enableIROut(uint32_t freq, uint8_t duty) {
 #ifdef UNIT_TEST
   _freq_unittest = freq;
 #endif  // UNIT_TEST
+
+#ifndef UNIT_TEST
+  _fractionalBits = 14;
+
+  // Maximum signed value that fits.
+  uint32_t maxValue = 0x7FFF >> _fractionalBits;
+  uint32_t period = calcUSecPeriod(freq);
+
+  // Decrement the number of fractional bits until the period fits.
+  while (maxValue < period)
+  {
+    --_fractionalBits;
+    maxValue = 0x7FFF >> _fractionalBits;
+  }
+
+  uint32_t fixedPointPeriod = ((1000000ULL << _fractionalBits) + freq / 2) / freq;
+
+  // Nr. of uSeconds the LED will be on per pulse.
+  onTimePeriod = (fixedPointPeriod * _dutycycle) / kDutyMax;
+  // Nr. of uSeconds the LED will be off per pulse.
+  offTimePeriod = fixedPointPeriod - onTimePeriod;
+#else
   uint32_t period = calcUSecPeriod(freq);
   // Nr. of uSeconds the LED will be on per pulse.
   onTimePeriod = (period * _dutycycle) / kDutyMax;
   // Nr. of uSeconds the LED will be off per pulse.
   offTimePeriod = period - onTimePeriod;
+#endif
 }
 
 #if ALLOW_DELAY_CALLS
@@ -166,6 +186,58 @@ uint16_t IRsend::mark(uint16_t usec) {
   // Not simple, so do it assuming frequency modulation.
   uint16_t counter = 0;
   IRtimer usecTimer = IRtimer();
+#ifndef UNIT_TEST
+#if SEND_BANG_OLUFSEN && ESP8266 && F_CPU < 160000000L
+  // Free running loop to attempt to get close to the 455 kHz required by Bang & Olufsen.
+  // Define BANG_OLUFSEN_CHECK_MODULATION temporarily to test frequency and time.
+  // Runs at ~300 kHz on an 80 MHz ESP8266.
+  // This is far from ideal but works if the transmitter is close enough.
+  uint32_t periodUInt = (onTimePeriod + offTimePeriod) >> _fractionalBits;
+  periodUInt = std::max(uint32_t(1), periodUInt);
+  if (periodUInt <= 5) {
+    uint32_t nextCheck = usec / periodUInt / 2; // Assume we can at least run for this number of periods.
+    for (;;) {  // nextStop is not updated in this loop.
+      ledOn();
+      ledOff();
+      counter++;
+      if (counter >= nextCheck) {
+        uint32_t now = usecTimer.elapsed();
+        int32_t timeLeft = usec - now;
+        if (timeLeft <= 1) {
+          return counter;
+        }
+        uint32_t periodsToEnd = counter * timeLeft / now;
+        // Check again when we are half way closer to the end.
+        nextCheck = (periodsToEnd >> 2) + counter;
+      }
+    }
+  }
+#endif
+
+  // Use absolute time for zero drift (but slightly uneven period).
+  // Using IRtimer.elapsed() instead of _delayMicroseconds is better for short period times.
+  // Maxed out at ~190 kHz on an 80 MHz ESP8266.
+  // Maxed out at ~460 kHz on ESP32.
+  uint32_t nextStop = 0; // Must be 32 bits to not overflow when usec is near max.
+  while ((nextStop >> _fractionalBits) < usec) {  // Loop until we've met/exceeded our required time.
+    ledOn();
+    nextStop += onTimePeriod;
+    uint32_t nextStopUInt = std::min(nextStop >> _fractionalBits, uint32_t(usec));
+    while(usecTimer.elapsed() < nextStopUInt);
+    ledOff();
+    counter++;
+    nextStop += offTimePeriod;
+    nextStopUInt = std::min(nextStop >> _fractionalBits, uint32_t(usec));
+    uint32_t now = usecTimer.elapsed();
+    int32_t delay = nextStopUInt - now;
+    if (delay > 0) {
+      while(usecTimer.elapsed() < nextStopUInt);
+    } else {
+      // This means we ran past nextStop and need to reset to actual time to avoid playing catch-up with a far too short period.
+      nextStop = (now << _fractionalBits) + (offTimePeriod >> 1);
+    }
+  }
+#else
   // Cache the time taken so far. This saves us calling time, and we can be
   // assured that we can't have odd math problems. i.e. unsigned under/overflow.
   uint32_t elapsed = usecTimer.elapsed();
@@ -184,6 +256,7 @@ uint16_t IRsend::mark(uint16_t usec) {
         std::min(usec - elapsed - onTimePeriod, (uint32_t)offTimePeriod));
     elapsed = usecTimer.elapsed();  // Update & recache the actual elapsed time.
   }
+#endif
   return counter;
 }
 
@@ -207,7 +280,7 @@ void IRsend::space(uint32_t time) {
 int8_t IRsend::calibrate(uint16_t hz) {
   if (hz < 1000)  // Were we given kHz? Supports the old call usage.
     hz *= 1000;
-  periodOffset = 0;  // Turn off any existing offset while we calibrate.
+  int8_t periodOffset = 0;
   enableIROut(hz);
   IRtimer usecTimer = IRtimer();  // Start a timer *just* before we do the call.
   uint16_t pulses = mark(UINT16_MAX);  // Generate a PWM of 65,535 us. (Max.)
@@ -798,6 +871,8 @@ uint16_t IRsend::defaultBits(const decode_type_t protocol) {
       return kXmpBits;
     case YORK:
       return kYorkBits;
+    case BANG_OLUFSEN:
+      return kBangOlufsenBits;
     // No default amount of bits.
     case FUJITSU_AC:
     case MWM:
@@ -838,6 +913,11 @@ bool IRsend::send(const decode_type_t type, const uint64_t data,
       sendArris(data, nbits, min_repeat);
       break;
 #endif  // SEND_ARRIS
+#if SEND_BANG_OLUFSEN
+    case BANG_OLUFSEN:
+      sendBangOlufsen(data, nbits, min_repeat);
+      break;
+#endif  // SEND_BANG_OLUFSEN
 #if SEND_BOSE
     case BOSE:
       sendBose(data, nbits, min_repeat);

src/IRsend.h

@@ -21,17 +21,6 @@
 // Constants
 // Offset (in microseconds) to use in Period time calculations to account for
 // code excution time in producing the software PWM signal.
-#if defined(ESP32)
-// Calculated on a generic ESP-WROOM-32 board with v3.2-18 SDK @ 240MHz
-const int8_t kPeriodOffset = -2;
-#elif (defined(ESP8266) && F_CPU == 160000000L)  // NOLINT(whitespace/parens)
-// Calculated on an ESP8266 NodeMCU v2 board using:
-// v2.6.0 with v2.5.2 ESP core @ 160MHz
-const int8_t kPeriodOffset = -2;
-#else  // (defined(ESP8266) && F_CPU == 160000000L)
-// Calculated on ESP8266 Wemos D1 mini using v2.4.1 with v2.4.0 ESP core @ 40MHz
-const int8_t kPeriodOffset = -5;
-#endif  // (defined(ESP8266) && F_CPU == 160000000L)
 const uint8_t kDutyDefault = 50;  // Percentage
 const uint8_t kDutyMax = 100;     // Percentage
 // delayMicroseconds() is only accurate to 16383us.
@@ -885,6 +874,15 @@ class IRsend {
                     const uint16_t nbytes = kYorkStateLength,
                     const uint16_t repeat = kNoRepeat);
 #endif  // SEND_YORK
+#if SEND_BANG_OLUFSEN
+  void sendBangOlufsen(const uint64_t data,
+                       const uint16_t nbits = kBangOlufsenBits,
+                       const uint16_t repeat = kNoRepeat);
+  void sendBangOlufsenRaw(const uint64_t rawData,
+                          const uint16_t bits,
+                          const bool datalink,
+                          const bool backToBack);
+#endif  // SEND_BANG_OLUFSEN
 
  protected:
 #ifdef UNIT_TEST
@@ -905,13 +903,13 @@ class IRsend {
 #else
   uint32_t _freq_unittest;
 #endif  // UNIT_TEST
-  uint16_t onTimePeriod;
-  uint16_t offTimePeriod;
+  uint16_t onTimePeriod; // Fixed point.
+  uint16_t offTimePeriod; // Fixed point.
+  uint8_t _fractionalBits; // Number of fractional bits in on/offTimePeriod.
   uint16_t IRpin;
-  int8_t periodOffset;
   uint8_t _dutycycle;
   bool modulation;
-  uint32_t calcUSecPeriod(uint32_t hz, bool use_offset = true);
+  uint32_t calcUSecPeriod(uint32_t hz);
 #if SEND_SONY
   void _sendSony(const uint64_t data, const uint16_t nbits,
                  const uint16_t repeat, const uint16_t freq);

src/IRtext.cpp

@@ -555,6 +555,8 @@ IRTEXT_CONST_BLOB_DECL(kAllProtocolNamesStr) {
             D_STR_CARRIER_AC84, D_STR_UNSUPPORTED) "\x0"
     COND(DECODE_YORK || SEND_YORK,
             D_STR_YORK, D_STR_UNSUPPORTED) "\x0"
+    COND(DECODE_BANG_OLUFSEN || SEND_BANG_OLUFSEN,
+            D_STR_BANG_OLUFSEN, D_STR_UNSUPPORTED) "\x0"
     ///< New protocol (macro) strings should be added just above this line.
     "\x0"  ///< This string requires double null termination.
 };

src/IRtimer.cpp

@@ -31,10 +31,7 @@ uint32_t IRtimer::elapsed() {
 #else
   uint32_t now = _IRtimer_unittest_now;
 #endif
-  if (start <= now)      // Check if the system timer has wrapped.
-    return now - start;  // No wrap.
-  else
-    return UINT32_MAX - start + now;  // Has wrapped.
+  return now - start;  // Wrap safe.
 }
 
 /// Add time to the timer to simulate elapsed time.
@@ -64,10 +61,7 @@ uint32_t TimerMs::elapsed() {
 #else
   uint32_t now = _TimerMs_unittest_now;
 #endif
-  if (start <= now)      // Check if the system timer has wrapped.
-    return now - start;  // No wrap.
-  else
-    return UINT32_MAX - start + now;  // Has wrapped.
+  return now - start;  // Wrap safe.
 }
 
 /// Add time to the timer to simulate elapsed time.

src/IRutils.cpp

@@ -262,8 +262,8 @@ String resultToSourceCode(const decode_results * const results) {
   //   "uint32_t address = 0xDEADBEEF;\n"
   //   "uint32_t command = 0xDEADBEEF;\n"
   //   "uint64_t data = 0xDEADBEEFDEADBEEF;" = ~116 chars max.
-  output.reserve(55 + (length * 7) + hasState ? 25 + (results->bits / 8) * 6
-                                              : 116);
+  output.reserve(55 + (length * 7) + (hasState ? 25 + (results->bits / 8) * 6
+                                               : 116));
   // Start declaration
   output += F("uint16_t ");  // variable type
   output += F("rawData[");   // array name

src/ir_Airwell.cpp

@@ -14,7 +14,7 @@ const uint8_t kAirwellOverhead = 4;
 const uint16_t kAirwellHalfClockPeriod = 950;  // uSeconds
 const uint16_t kAirwellHdrMark = 3 * kAirwellHalfClockPeriod;  // uSeconds
 const uint16_t kAirwellHdrSpace = 3 * kAirwellHalfClockPeriod;  // uSeconds
-const uint16_t kAirwellFooterMark = 5 * kAirwellHalfClockPeriod;  // uSeconds
+//const uint16_t kAirwellFooterMark = 5 * kAirwellHalfClockPeriod;  // uSeconds
 
 using irutils::addBoolToString;
 using irutils::addModeToString;