Fix calculation of pause length in LEGO PF protocol

Fix #384 Integer overflow in LEGO Power Functions affects pause between messages Is rebased version of PR Arduino-IRremote#385

Author: philipphenkel

examples/LegoPowerFunctionsTests/LegoPowerFunctionsTests.ino

@@ -1,6 +1,6 @@
 /*
  * LegoPowerFunctionsTest: LEGO Power Functions Tests
- * Copyright (c) 2016 Philipp Henkel
+ * Copyright (c) 2016, 2017 Philipp Henkel
  */
 
 #include <ir_Lego_PF_BitStreamEncoder.h>
@@ -78,14 +78,14 @@ void testMessageBitCount(LegoPfBitStreamEncoder& bitStreamEncoder) {
  logTestResult(bitCount == 18);
 }
 
-boolean check(LegoPfBitStreamEncoder& bitStreamEncoder, int markDuration, int pauseDuration) {
+boolean check(LegoPfBitStreamEncoder& bitStreamEncoder, unsigned long markDuration, unsigned long pauseDuration) {
  bool result = true;
  result = result && bitStreamEncoder.getMarkDuration() == markDuration;
  result = result && bitStreamEncoder.getPauseDuration() == pauseDuration;
  return result;
 }
 
-boolean checkNext(LegoPfBitStreamEncoder& bitStreamEncoder, int markDuration, int pauseDuration) {
+boolean checkNext(LegoPfBitStreamEncoder& bitStreamEncoder, unsigned long markDuration, unsigned long pauseDuration) {
  bool result = bitStreamEncoder.next();
  result = result && check(bitStreamEncoder, markDuration, pauseDuration);
  return result;
@@ -129,16 +129,16 @@ void testMessage407Repeated(LegoPfBitStreamEncoder& bitStreamEncoder) {
  bool result = true;
  result = result && check(bitStreamEncoder, 158, 1026);
  result = result && checkDataBitsOfMessage407(bitStreamEncoder);
- result = result && checkNext(bitStreamEncoder, 158, 1026 + 5 * 16000 - 10844);
+ result = result && checkNext(bitStreamEncoder, 158, 1026L + 5L * 16000L - 10844L);
  result = result && checkNext(bitStreamEncoder, 158, 1026);
  result = result && checkDataBitsOfMessage407(bitStreamEncoder);
- result = result && checkNext(bitStreamEncoder, 158, 1026 + 5 * 16000 - 10844);
+ result = result && checkNext(bitStreamEncoder, 158, 1026L + 5L * 16000L - 10844L);
  result = result && checkNext(bitStreamEncoder, 158, 1026);
  result = result && checkDataBitsOfMessage407(bitStreamEncoder);
- result = result && checkNext(bitStreamEncoder, 158, 1026 + 8 * 16000 - 10844);
+ result = result && checkNext(bitStreamEncoder, 158, 1026L + 8L * 16000L - 10844L);
  result = result && checkNext(bitStreamEncoder, 158, 1026);
  result = result && checkDataBitsOfMessage407(bitStreamEncoder);
- result = result && checkNext(bitStreamEncoder, 158, 1026 + 8 * 16000 - 10844);
+ result = result && checkNext(bitStreamEncoder, 158, 1026L + 8L * 16000L - 10844L);
  result = result && checkNext(bitStreamEncoder, 158, 1026);
  result = result && checkDataBitsOfMessage407(bitStreamEncoder);
  result = result && checkNext(bitStreamEncoder, 158, 1026);
@@ -191,7 +191,3 @@ void testGetMessageLengthAllLow(LegoPfBitStreamEncoder& bitStreamEncoder) {
  bitStreamEncoder.reset(0x0, false);
  logTestResult(bitStreamEncoder.getMessageLength() == 9104);
 }
-
-
-
-

ir_Lego_PF_BitStreamEncoder.h

@@ -4,7 +4,7 @@
 // L E E O O
 // L EEEE E EEE O O
 // L E E E O O LEGO Power Functions
-// LLLLLL EEEEEE EEEE OOOO Copyright (c) 2016 Philipp Henkel
+// LLLLLL EEEEEE EEEE OOOO Copyright (c) 2016, 2017 Philipp Henkel
 //==============================================================================
 
 //+=============================================================================
@@ -14,25 +14,25 @@ class LegoPfBitStreamEncoder {
  private:
  uint16_t data;
  bool repeatMessage;
- int messageBitIdx;
- int repeatCount;
- int messageLength;
+ uint8_t messageBitIdx;
+ uint8_t repeatCount;
+ uint16_t messageLength;
 
+ public:
  // HIGH data bit = IR mark + high pause
  // LOW data bit = IR mark + low pause
- static const int LOW_BIT_DURATION = 421;
- static const int HIGH_BIT_DURATION = 711;
- static const int START_BIT_DURATION = 1184;
- static const int STOP_BIT_DURATION = 1184;
- static const int IR_MARK_DURATION = 158;
- static const int HIGH_PAUSE_DURATION = HIGH_BIT_DURATION - IR_MARK_DURATION;
- static const int LOW_PAUSE_DURATION = LOW_BIT_DURATION - IR_MARK_DURATION;
- static const int START_PAUSE_DURATION = START_BIT_DURATION - IR_MARK_DURATION;
- static const int STOP_PAUSE_DURATION = STOP_BIT_DURATION - IR_MARK_DURATION;
- static const int MESSAGE_BITS = 18;
- static const int MAX_MESSAGE_LENGTH = 16000;
+ static const uint16_t LOW_BIT_DURATION = 421;
+ static const uint16_t HIGH_BIT_DURATION = 711;
+ static const uint16_t START_BIT_DURATION = 1184;
+ static const uint16_t STOP_BIT_DURATION = 1184;
+ static const uint8_t IR_MARK_DURATION = 158;
+ static const uint16_t HIGH_PAUSE_DURATION = HIGH_BIT_DURATION - IR_MARK_DURATION;
+ static const uint16_t LOW_PAUSE_DURATION = LOW_BIT_DURATION - IR_MARK_DURATION;
+ static const uint16_t START_PAUSE_DURATION = START_BIT_DURATION - IR_MARK_DURATION;
+ static const uint16_t STOP_PAUSE_DURATION = STOP_BIT_DURATION - IR_MARK_DURATION;
+ static const uint8_t MESSAGE_BITS = 18;
+ static const uint16_t MAX_MESSAGE_LENGTH = 16000;
 
- public:
  void reset(uint16_t data, bool repeatMessage) {
  this->data = data;
  this->repeatMessage = repeatMessage;
@@ -43,9 +43,9 @@ class LegoPfBitStreamEncoder {
 
  int getChannelId() const { return 1 + ((data >> 12) & 0x3); }
 
- int getMessageLength() const {
+ uint16_t getMessageLength() const {
  // Sum up all marks
- int length = MESSAGE_BITS * IR_MARK_DURATION;
+ uint16_t length = MESSAGE_BITS * IR_MARK_DURATION;
 
  // Sum up all pauses
  length += START_PAUSE_DURATION;
@@ -75,9 +75,9 @@ class LegoPfBitStreamEncoder {
  }
  }
 
- int getMarkDuration() const { return IR_MARK_DURATION; }
+ uint8_t getMarkDuration() const { return IR_MARK_DURATION; }
 
- int getPauseDuration() const {
+ uint32_t getPauseDuration() const {
  if (messageBitIdx == 0)
  return START_PAUSE_DURATION;
  else if (messageBitIdx < MESSAGE_BITS - 1) {
@@ -88,26 +88,26 @@ class LegoPfBitStreamEncoder {
  }
 
  private:
- int getDataBitPause() const {
+ uint16_t getDataBitPause() const {
  const int pos = MESSAGE_BITS - 2 - messageBitIdx;
  const bool isHigh = data & (1 << pos);
  return isHigh ? HIGH_PAUSE_DURATION : LOW_PAUSE_DURATION;
  }
 
- int getStopPause() const {
+ uint32_t getStopPause() const {
  if (repeatMessage) {
  return getRepeatStopPause();
  } else {
  return STOP_PAUSE_DURATION;
  }
  }
 
- int getRepeatStopPause() const {
+ uint32_t getRepeatStopPause() const {
  if (repeatCount == 0 || repeatCount == 1) {
- return STOP_PAUSE_DURATION + 5 * MAX_MESSAGE_LENGTH - messageLength;
+ return STOP_PAUSE_DURATION + (uint32_t)5 * MAX_MESSAGE_LENGTH - messageLength;
  } else if (repeatCount == 2 || repeatCount == 3) {
  return STOP_PAUSE_DURATION
- + (6 + 2 * getChannelId()) * MAX_MESSAGE_LENGTH - messageLength;
+ + (uint32_t)(6 + 2 * getChannelId()) * MAX_MESSAGE_LENGTH - messageLength;
  } else {
  return STOP_PAUSE_DURATION;
  }