add ability to queue up pin values to be read

Author: ianfixes

CHANGELOG.md

@@ -9,6 +9,7 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 - 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
+- Pins now accept an array (or string) of input bits for providing pin values across multiple reads
 
 ### Changed
 - Unit test executables print to STDERR just in case there are segfaults.  Uh, just in case I ever write any.

README.md

@@ -70,6 +70,74 @@ unittest(example_godmode_stuff)
 }
 ```
 
+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]);
+  }
+```
+
+Reading the pin more than once per function is also a possibility.  In that case, we want to queue up a few values for the `digitalRead` or `analogRead` to find.
+
+```C++
+unittest(pin_read_history)
+{
+  GodmodeState* state = GODMODE();
+  state->reset();
+
+  int future[6] = {33, 22, 55, 11, 44, 66};
+  state->analogPin[1].fromArray(future, 6);
+  delay(1); // swallow first entry
+  for (int i = 0; i < 6; ++i)
+  {
+    assertEqual(future[i], analogRead(1));
+    assertEqual(future[i], analogRead(1));  // reading twice in the same instant produces the same value
+    delay(1);                               // advancing the instant produces the next value
+  }
+
+  // for digital pins, we have the added possibility of specifying
+  // a stream of input bytes encoded as ASCII
+  bool bigEndian = true;
+  state->digitalPin[1].fromAscii("Yo", bigEndian);
+
+  // digitial history as serial data, big-endian
+  bool expectedBits[16] = {
+    0, 1, 0, 1, 1, 0, 0, 1,  // Y
+    0, 1, 1, 0, 1, 1, 1, 1   // o
+  };
+
+  for (int i = 0; i < 16; ++i) {
+    assertEqual(expectedBits[i], digitalRead(1));
+    delay(1);
+  }
+}
+```
+
 A more complicated example: working with serial port IO.  Let's say I have the following function:
 
 ```C++
@@ -127,37 +195,8 @@ 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.
 

SampleProjects/TestSomething/test/good-godmode.cpp

@@ -45,8 +45,10 @@ unittest(pins)
   pinMode(1, OUTPUT);  // this is a no-op in unit tests.  it's just here to prove compilation
   digitalWrite(1, HIGH);
   assertEqual(HIGH, state->digitalPin[1]);
+  assertEqual(HIGH, digitalRead(1));
   digitalWrite(1, LOW);
   assertEqual(LOW, state->digitalPin[1]);
+  assertEqual(LOW, digitalRead(1));
 
   pinMode(1, INPUT);
   state->digitalPin[1] = HIGH;
@@ -65,25 +67,63 @@ unittest(pins)
   assertEqual(56, analogRead(1));
 }
 
-unittest(pin_history)
+unittest(pin_read_history)
 {
   GodmodeState* state = GODMODE();
   state->reset();
 
+  int future[6] = {33, 22, 55, 11, 44, 66};
+  state->analogPin[1].fromArray(future, 6);
+  delay(1); // swallow first entry
+  for (int i = 0; i < 6; ++i)
+  {
+    assertEqual(future[i], analogRead(1));
+    assertEqual(future[i], analogRead(1));  // test same-instant read
+    delay(1);
+  }
+
+  // assert end of history works
+  delay(1);
+  assertEqual(future[5], analogRead(1));
+
+  state->digitalPin[1].fromAscii("Yo", true);
+  // digitial history as serial data, big-endian
+  bool binaryAscii[16] = {
+    0, 1, 0, 1, 1, 0, 0, 1,
+    0, 1, 1, 0, 1, 1, 1, 1
+  };
+
+  for (int i = 0; i < 16; ++i) {
+    assertEqual(binaryAscii[i], digitalRead(1));
+    assertEqual(binaryAscii[i], digitalRead(1)); // test same-instant read
+    delay(1);
+  }
+}
+
+unittest(pin_write_history)
+{
+  GodmodeState *state = GODMODE();
+  state->reset();
+  int numMoved;
+
   // 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());
+  assertEqual(6, state->digitalPin[1].historySize());
   bool expectedD[6] = {LOW, HIGH, LOW, LOW, HIGH, HIGH};
   bool actualD[6];
-  int numMoved = state->digitalPin[1].toArray(actualD, 6);
+  numMoved = state->digitalPin[1].toArray(actualD, 6);
+  assertEqual(6, numMoved);
+  // assert non-destructive
+  numMoved = state->digitalPin[1].toArray(actualD, 6);
   assertEqual(6, numMoved);
 
-  for (int i = 0; i < 6; ++i) {
+  for (int i = 0; i < 6; ++i)
+  {
     assertEqual(expectedD[i], actualD[i]);
   }
 
@@ -94,34 +134,38 @@ unittest(pin_history)
   analogWrite(1, 44);
   analogWrite(1, 55);
 
-  assertEqual(6, state->analogPin[1].size());
+  assertEqual(6, state->analogPin[1].historySize());
   int expectedA[6] = {0, 11, 22, 33, 44, 55};
   int actualA[6];
   numMoved = state->analogPin[1].toArray(actualA, 6);
   assertEqual(6, numMoved);
+  // assert non-destructive
+  numMoved = state->analogPin[1].toArray(actualA, 6);
+  assertEqual(6, numMoved);
 
-  for (int i = 0; i < 6; ++i) {
+  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
-  };
+      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++]));
+  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
-  };
+      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++]));
+  for (int i = 0; i < 16; digitalWrite(3, binaryAscii2[i++]))
+    ;
 
   assertEqual("No", state->digitalPin[3].toAscii(1, false));
 

cpp/arduino/Arduino.cpp

@@ -9,15 +9,15 @@ void digitalWrite(unsigned char pin, unsigned char val) {
 
 int digitalRead(unsigned char pin) {
   GodmodeState* godmode = GODMODE();
-  return godmode->digitalPin[pin];
+  return godmode->digitalPin[pin].retrieve();
 }
 
-int analogRead(unsigned char pin) {
+void analogWrite(unsigned char pin, int val) {
   GodmodeState* godmode = GODMODE();
-  return godmode->analogPin[pin];
+  godmode->analogPin[pin] = val;
 }
 
-void analogWrite(unsigned char pin, int val) {
+int analogRead(unsigned char pin) {
   GodmodeState* godmode = GODMODE();
-  godmode->analogPin[pin] = val;
+  return godmode->analogPin[pin].retrieve();
 }

cpp/arduino/Godmode.cpp

@@ -60,3 +60,8 @@ long random(long vmin, long vmax)
   HardwareSerial Serial3(&godmode.serialPort[3].dataIn, &godmode.serialPort[3].dataOut, &godmode.serialPort[3].readDelayMicros);
 #endif
 
+template <typename T>
+inline std::ostream& operator << ( std::ostream& out, const PinHistory<T>& ph ) {
+  out << ph;
+  return out;
+}