Add shiftIn and shiftOut

Author: ianfixes

CHANGELOG.md

@@ -15,6 +15,7 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 - `assertNAN()` and `assertNotNAN()` for comparing floats to `NaN`
 - `assertion()`, `ReporterTAP.onAssert()`, and `testBehaviorExp` macro to handle simple expression evaluation (is true, is false, etc)
 - `Wire.resetMocks()` and documentation
+- `shiftIn()` and `shiftOut()`
 
 ### Changed
 - Rubocop expected syntax downgraded from ruby 2.6 to 2.5

SampleProjects/TestSomething/test/godmode.cpp

@@ -222,6 +222,66 @@ unittest(spi) {
   assertEqual("LMNOe", String(inBuf));
 }
 
+unittest(shift_in) {
+
+  uint8_t dataPin = 2;
+  uint8_t clockPin = 3;
+  uint8_t input;
+  bool actualClock[16];
+  uint8_t originalSize;
+
+  // verify data
+  state->reset();
+  state->digitalPin[dataPin].fromAscii("|", true); // 0111 1100
+  originalSize = state->digitalPin[clockPin].historySize();
+
+  input = shiftIn(dataPin, clockPin, MSBFIRST);
+  assertEqual(0x7C, (uint)input);                  // 0111 1100
+  assertEqual('|', input);                         // 0111 1100
+  assertEqual((uint)'|', (uint)input);             // 0111 1100
+
+  // now verify clock
+  assertEqual(16, state->digitalPin[clockPin].historySize() - originalSize);
+  int numMoved = state->digitalPin[clockPin].toArray(actualClock, 16);
+  assertEqual(16, numMoved);
+  for (int i = 0; i < 16; ++i) assertEqual(i % 2, actualClock[i]);
+
+  state->reset();
+  state->digitalPin[dataPin].fromAscii("|", true); // 0111 1100
+  input = shiftIn(dataPin, clockPin, LSBFIRST);    //          <- note the LSB/MSB flip
+  assertEqual(0x3E, (uint)input);                  // 0011 1110
+  assertEqual('>', input);                         // 0011 1110
+  assertEqual((uint)'>', (uint)input);             // 0011 1110
+
+  // test setting MSB
+  state->reset();
+  state->digitalPin[dataPin].fromAscii("U", true); // 0101 0101
+  input = shiftIn(dataPin, clockPin, LSBFIRST);    //          <- note the LSB/MSB flip
+  assertEqual(0xAA, (uint)input);                  // 1010 1010
+}
+
+unittest(shift_out) {
+
+  uint8_t dataPin = 2;
+  uint8_t clockPin = 3;
+  uint8_t output;
+  bool actualClock[16];
+  uint8_t originalSize;
+
+  state->reset();
+  originalSize = state->digitalPin[clockPin].historySize();
+  shiftOut(dataPin, clockPin, MSBFIRST, '|');
+  assertEqual("|", state->digitalPin[dataPin].toAscii(1, true));
+  assertEqual(16, state->digitalPin[clockPin].historySize() - originalSize);
+  int numMoved = state->digitalPin[clockPin].toArray(actualClock, 16);
+  for (int i = 0; i < 16; ++i) assertEqual(i % 2, actualClock[i]);
+
+  state->reset();
+  shiftOut(dataPin, clockPin, LSBFIRST, '|');
+  assertEqual(">", state->digitalPin[dataPin].toAscii(1, true));
+
+}
+
 
 #ifdef HAVE_HWSERIAL0
 

cpp/arduino/Godmode.h

@@ -173,8 +173,65 @@ void attachInterrupt(uint8_t interrupt, void ISR(void), uint8_t mode);
 void detachInterrupt(uint8_t interrupt);
 
 // TODO: issue #26 to track the commanded state here
-inline void tone(uint8_t _pin, unsigned int frequency, unsigned long duration = 0) {}
-inline void noTone(uint8_t _pin) {}
+inline void tone(uint8_t _pin, unsigned int frequency, unsigned long duration = 0) { throw "Not Yet Implemented"; }
+inline void noTone(uint8_t _pin) { throw "Not Yet Implemented"; }
+inline uint8_t pulseIn(uint8_t _pin, uint8_t _value, uint32_t _timeout) { throw "Not Yet Implemented"; }
+inline uint8_t pulseIn(uint8_t pin, uint8_t value) { return pulseIn(pin, value, (uint32_t) 1000000); }
+inline uint32_t pulseInLong(uint8_t _pin, uint8_t _value, uint32_t _timeout) { throw "Not Yet Implemented"; }
+inline uint32_t pulseInLong(uint8_t pin, uint8_t value) { return pulseInLong(pin, value, (uint32_t) 1000000); }
+
+/**
+ * Shifts in a byte of data one bit at a time.
+ *
+ * Starts from either the most (i.e. the leftmost) or least (rightmost)
+ * significant bit. For each bit, the clock pin is pulled high, the next bit is
+ * read from the data line, and then the clock pin is taken low.
+ *
+ * @param dataPin the pin on which to input each bit
+ * @param clockPin the pin to toggle to signal a read from dataPin
+ * @param bitOrder which order to shift in the bits; either MSBFIRST or LSBFIRST. B=Bit, not byte
+ *
+ * @return The value read
+ */
+inline uint8_t shiftIn(uint8_t dataPin, uint8_t clockPin, bool bitOrder) {
+  bool mFirst = bitOrder == MSBFIRST;
+  uint8_t ret = 0x00;
+  for (uint8_t i = 0, mask = (bitOrder == MSBFIRST ? 0x80 : 0x01); i < 8; ++i) {
+    digitalWrite(clockPin, HIGH);
+    uint8_t setBit = mFirst ? 0x80 : 0x01;
+    uint8_t val = (mFirst ? (setBit >> i) : (setBit << i));
+    ret = ret | (digitalRead(dataPin) ? val : 0x00);
+    digitalWrite(clockPin, LOW);
+  }
+  return ret;
+}
+
+/**
+ * Shifts out a byte of data one bit at a time.
+ *
+ * Starts from either the most (i.e. the leftmost) or least (rightmost)
+ * significant bit. Each bit is written in turn to a data pin, after which a
+ * clock pin is pulsed (taken high, then low) to indicate that the bit is
+ * available.
+ *
+ * @param dataPin the pin on which to input each bit
+ * @param clockPin the pin to toggle to signal a write from dataPin
+ * @param bitOrder which order to shift in the bits; either MSBFIRST or LSBFIRST. B=Bit, not byte
+ * @param value the data to shift out
+ *
+ * @return The value read
+ */
+inline void shiftOut(uint8_t dataPin, uint8_t clockPin, bool bitOrder, uint8_t value) {
+  bool mFirst = bitOrder == MSBFIRST;
+  uint8_t ret = 0x00;
+  for (uint8_t i = 0, mask = (bitOrder == MSBFIRST ? 0x80 : 0x01); i < 8; ++i) {
+    uint8_t setBit = mFirst ? 0x80 : 0x01;
+    uint8_t val = (mFirst ? (setBit >> i) : (setBit << i));
+    digitalWrite(dataPin, (value & val) ? HIGH : LOW);
+    digitalWrite(clockPin, HIGH);
+    digitalWrite(clockPin, LOW);
+  }
+}
 
 // These definitions allow the following to compile (see issue #193):
 // https://github.com/arduino-libraries/Ethernet/blob/master/src/utility/w5100.h:341