add the ability to examine a pin's history as an array or as ascii

Author: ianfixes

CHANGELOG.md

@@ -8,6 +8,7 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 ### Added
 - Yaml files can have either `.yml` or `.yaml` extensions
 - Yaml files support select/reject critera for paths of unit tests for targeted testing
+- Pins now track history and can report it in Ascii (big- or little-endian) for digital sequences
 
 ### Changed
 - Unit test executables print to STDERR just in case there are segfaults.  Uh, just in case I ever write any.

README.md

@@ -127,6 +127,61 @@ unittest(two_flips)
 }
 ```
 
+Of course, it's possible that your code might flip the bit more than once in a function.  For that scenario, you may want to examine the history of a pin's commanded outputs:
+
+```C++
+unittest(pin_history)
+{
+  GodmodeState* state = GODMODE();
+  int myPin = 3;
+  state->reset();            // pin will start LOW
+  digitalWrite(myPin, HIGH);
+  digitalWrite(myPin, LOW);
+  digitalWrite(myPin, LOW);
+  digitalWrite(myPin, HIGH);
+  digitalWrite(myPin, HIGH);
+
+  assertEqual(6, state->digitalPin[1].size());
+  bool expected[6] = {LOW, HIGH, LOW, LOW, HIGH, HIGH};
+  bool actual[6];
+
+  // move history queue into an array because at the moment, reading
+  // the history is destructive -- it's a linked-list queue.  this
+  // means that if toArray or hasElements fails, the queue will be in
+  // an unknown state and you should reset it before continuing with
+  // other tests
+  int numMoved = state->digitalPin[myPin].toArray(actual, 6);
+  assertEqual(6, numMoved);
+
+  // verify each element
+  for (int i = 0; i < 6; ++i) {
+    assertEqual(expected[i], actual[i]);
+  }
+```
+
+Finally, there are some cases where you want to use a pin as a serial port.  There are history functions for that too.
+
+```C++
+  int myPin = 3;
+
+  // digitial history as serial data, big-endian
+  bool bigEndian = true;
+  bool binaryAscii[24] = {
+    0, 1, 0, 1, 1, 0, 0, 1,  // Y
+    0, 1, 1, 0, 0, 1, 0, 1,  // e
+    0, 1, 1, 1, 0, 0, 1, 1   // s
+  };
+
+  // "send" these bits
+  for (int i = 0; i < 24; digitalWrite(myPin, binaryAscii[i++]));
+
+  // The first bit in the history is the initial value, which we will ignore
+  int offset = 1;
+
+  // We should be able to parse the bits as ascii
+  assertEqual("Yes", state->digitalPin[myPin].toAscii(offset, bigEndian));
+```
+
 ## More Documentation
 
 This software is in alpha.  But [SampleProjects/DoSomething](SampleProjects/DoSomething) has a decent writeup and is a good bare-bones example of all the features.

SampleProjects/TestSomething/test/good-godmode.cpp

@@ -65,6 +65,68 @@ unittest(pins)
   assertEqual(56, analogRead(1));
 }
 
+unittest(pin_history)
+{
+  GodmodeState* state = GODMODE();
+  state->reset();
+
+  // history for digital pin
+  digitalWrite(1, HIGH);
+  digitalWrite(1, LOW);
+  digitalWrite(1, LOW);
+  digitalWrite(1, HIGH);
+  digitalWrite(1, HIGH);
+
+  assertEqual(6, state->digitalPin[1].size());
+  bool expectedD[6] = {LOW, HIGH, LOW, LOW, HIGH, HIGH};
+  bool actualD[6];
+  int numMoved = state->digitalPin[1].toArray(actualD, 6);
+  assertEqual(6, numMoved);
+
+  for (int i = 0; i < 6; ++i) {
+    assertEqual(expectedD[i], actualD[i]);
+  }
+
+  // history for analog pin
+  analogWrite(1, 11);
+  analogWrite(1, 22);
+  analogWrite(1, 33);
+  analogWrite(1, 44);
+  analogWrite(1, 55);
+
+  assertEqual(6, state->analogPin[1].size());
+  int expectedA[6] = {0, 11, 22, 33, 44, 55};
+  int actualA[6];
+  numMoved = state->analogPin[1].toArray(actualA, 6);
+  assertEqual(6, numMoved);
+
+  for (int i = 0; i < 6; ++i) {
+    assertEqual(expectedA[i], actualA[i]);
+  }
+
+  // digitial history as serial data, big-endian
+  bool binaryAscii[24] = {
+    0, 1, 0, 1, 1, 0, 0, 1,
+    0, 1, 1, 0, 0, 1, 0, 1,
+    0, 1, 1, 1, 0, 0, 1, 1
+  };
+
+  for (int i = 0; i < 24; digitalWrite(2, binaryAscii[i++]));
+
+  assertEqual("Yes", state->digitalPin[2].toAscii(1, true));
+
+  // digitial history as serial data, little-endian
+  bool binaryAscii2[16] = {
+    0, 1, 1, 1, 0, 0, 1, 0,
+    1, 1, 1, 1, 0, 1, 1, 0
+  };
+
+  for (int i = 0; i < 16; digitalWrite(3, binaryAscii2[i++]));
+
+  assertEqual("No", state->digitalPin[3].toAscii(1, false));
+
+}
+
 #ifdef HAVE_HWSERIAL0
 
   void smartLightswitchSerialHandler(int pin) {

cpp/arduino/AvrMath.h

@@ -4,20 +4,7 @@
 #define constrain(x,l,h) ((x)<(l)?(l):((x)>(h)?(h):(x)))
 #define map(x,inMin,inMax,outMin,outMax) (((x)-(inMin))*((outMax)-(outMin))/((inMax)-(inMin))+outMin)
 
-#ifdef abs
-#undef abs
-#endif
-#define abs(x) ((x)>0?(x):-(x))
-
-#ifdef max
-#undef max
-#endif
-#define max(a,b) ((a)>(b)?(a):(b))
-
-#ifdef min
-#undef min
-#endif
-#define min(a,b) ((a)<(b)?(a):(b))
+#include "Forced.h"
 
 #define sq(x) ((x)*(x))
 

cpp/arduino/Forced.h

@@ -0,0 +1,17 @@
+// Stuff where we very explicitly override std C++
+// Note lack of "pragma once"
+
+#ifdef abs
+#undef abs
+#endif
+#define abs(x) ((x)>0?(x):-(x))
+
+#ifdef max
+#undef max
+#endif
+#define max(a,b) ((a)>(b)?(a):(b))
+
+#ifdef min
+#undef min
+#endif
+#define min(a,b) ((a)<(b)?(a):(b))

cpp/arduino/Godmode.h

@@ -2,6 +2,7 @@
 #include "ArduinoDefines.h"
 #include <avr/io.h>
 #include "WString.h"
+#include "PinHistory.h"
 
 #define MOCK_PINS_COUNT 256
 
@@ -29,14 +30,14 @@ class GodmodeState {
     unsigned long micros;
     unsigned long seed;
     // not going to put pinmode here unless its really needed. can't think of why it would be
-    bool digitalPin[MOCK_PINS_COUNT];
-    int analogPin[MOCK_PINS_COUNT];
+    PinHistory<bool> digitalPin[MOCK_PINS_COUNT];
+    PinHistory<int> analogPin[MOCK_PINS_COUNT];
     struct PortDef serialPort[NUM_SERIAL_PORTS];
 
     void resetPins() {
       for (int i = 0; i < MOCK_PINS_COUNT; ++i) {
-        digitalPin[i] = LOW;
-        analogPin[i] = 0;
+        digitalPin[i].reset(LOW);
+        analogPin[i].reset(0);
       }
     }
 
@@ -54,7 +55,6 @@ class GodmodeState {
       return NUM_SERIAL_PORTS;
     }
 
-
     GodmodeState()
     {
       reset();

cpp/arduino/PinHistory.h

@@ -0,0 +1,80 @@
+#pragma once
+#include <queue>
+#include "Forced.h"
+
+// pins with history.
+template <typename T>
+class PinHistory {
+private:
+  std::queue<T> q;
+
+  void clear() { while (!q.empty()) q.pop(); }
+
+public:
+  PinHistory() {}
+
+  void reset(T val) {
+    clear();
+    q.push(val);
+  }
+
+  unsigned int size() { return q.size(); }
+
+  operator T() const { return q.back(); }
+
+  T &operator=(const T i) {
+    q.push(i);
+    return q.back();
+  }
+
+  // destructively move elements to an array, up to a given length
+  // return the number of elements moved
+  int toArray(T* arr, unsigned int length) {
+    int ret = 0;
+    for (int i = 0; i < length && q.size(); ++i) {
+      arr[i] = q.front();
+      q.pop();
+      ++ret;
+    }
+    return ret;
+  }
+
+  // destructively see if the array matches the elements in the queue
+  bool hasElements(T* arr, unsigned int length) {
+    int i;
+    for (i = 0; i < length && q.size(); ++i) {
+      if (q.front() != arr[i]) return false;
+      q.pop();
+    }
+    return i == length;
+  }
+
+  // destructively convert the pin history to a string as if it was Serial comms
+  // start from offset, consider endianness
+  String toAscii(unsigned int offset, bool bigEndian) {
+    String ret = "";
+
+    while (offset) {
+      q.pop();
+      --offset;
+    }
+
+    if (offset) return ret;
+
+    // 8 chars at a time, form up
+    while (q.size() >= 8) {
+      unsigned char acc = 0x00;
+      for (int i = 0; i < 8; ++i) {
+        int shift = bigEndian ? 7 - i : i;
+        T val = q.front();
+        unsigned char bit = val ? 0x1 : 0x0;
+        acc |= (bit << shift);
+        q.pop();
+      }
+      ret.append(String((char)acc));
+    }
+
+    return ret;
+  }
+};
+