arduino_ci 0.1.20 → 0.4.0

data/cpp/arduino/HardwareSerial.h

@@ -1,7 +1,7 @@
 #pragma once
 
 //#include <inttypes.h>
-#include "Stream.h"
+#include "ci/StreamTape.h"
 
 // definitions neeeded for Serial.begin's config arg
 #define SERIAL_5N1 0x00
@@ -29,53 +29,34 @@
 #define SERIAL_7O2 0x3C
 #define SERIAL_8O2 0x3E
 
-class HardwareSerial : public Stream, public ObservableDataStream
+class HardwareSerial : public StreamTape
 {
-  protected:
-    String* mGodmodeDataOut;
-
   public:
-    HardwareSerial(String* dataIn, String* dataOut, unsigned long* delay): Stream(), ObservableDataStream() {
-      mGodmodeDataIn      = dataIn;
-      mGodmodeDataOut     = dataOut;
-      mGodmodeMicrosDelay = delay;
-    }
+    HardwareSerial(String* dataIn, String* dataOut, unsigned long* delay): StreamTape(dataIn, dataOut, delay) {}
+
     void begin(unsigned long baud) { begin(baud, SERIAL_8N1); }
     void begin(unsigned long baud, uint8_t config) {
       *mGodmodeMicrosDelay = 1000000 / baud;
     }
     void end() {}
 
-    // virtual int available(void);
-    // virtual int peek(void);
-    // virtual int read(void);
-    // virtual int availableForWrite(void);
-    // virtual void flush(void);
-    virtual size_t write(uint8_t aChar) {
-      mGodmodeDataOut->append(String((char)aChar));
-      advertiseByte((unsigned char)aChar);
-      return 1;
-    }
-
-    // https://stackoverflow.com/a/4271276
-    using Print::write; // pull in write(str) and write(buf, size) from Print
+    // support "if (Serial1) {}" sorts of things
     operator bool() { return true; }
-
 };
 
-#if defined(UBRRH) || defined(UBRR0H)
+#if NUM_SERIAL_PORTS >= 1
   extern HardwareSerial Serial;
   #define HAVE_HWSERIAL0
 #endif
-#if defined(UBRR1H)
+#if NUM_SERIAL_PORTS >= 2
   extern HardwareSerial Serial1;
   #define HAVE_HWSERIAL1
 #endif
-#if defined(UBRR2H)
+#if NUM_SERIAL_PORTS >= 3
   extern HardwareSerial Serial2;
   #define HAVE_HWSERIAL2
 #endif
-#if defined(UBRR3H)
+#if NUM_SERIAL_PORTS >= 4
   extern HardwareSerial Serial3;
   #define HAVE_HWSERIAL3
 #endif

data/cpp/arduino/IPAddress.h

@@ -0,0 +1,59 @@
+#pragma once
+
+#include <stdint.h>
+
+class IPAddress {
+private:
+  union {
+    uint8_t bytes[4];
+    uint32_t dword;
+    operator uint8_t *() const { return (uint8_t *)bytes; }
+  } _address;
+
+public:
+  // Constructors
+  IPAddress() : IPAddress(0, 0, 0, 0) {}
+  IPAddress(uint8_t octet1, uint8_t octet2, uint8_t octet3, uint8_t octet4) {
+    _address.bytes[0] = octet1;
+    _address.bytes[1] = octet2;
+    _address.bytes[2] = octet3;
+    _address.bytes[3] = octet4;
+  }
+  IPAddress(uint32_t dword) { _address.dword = dword; }
+  IPAddress(const uint8_t bytes[]) {
+    _address.bytes[0] = bytes[0];
+    _address.bytes[1] = bytes[1];
+    _address.bytes[2] = bytes[2];
+    _address.bytes[3] = bytes[3];
+  }
+  IPAddress(unsigned long dword) { _address.dword = (uint32_t)dword; }
+
+  // Accessors
+  uint32_t asWord() const { return _address.dword; }
+  uint8_t *raw_address() { return _address.bytes; }
+
+  // Comparisons
+  bool operator==(const IPAddress &rhs) const {
+    return _address.dword == rhs.asWord();
+  }
+
+  bool operator!=(const IPAddress &rhs) const {
+    return _address.dword != rhs.asWord();
+  }
+
+  // Indexing
+  uint8_t operator[](int index) const { return _address.bytes[index]; }
+  uint8_t &operator[](int index) { return _address.bytes[index]; }
+
+  // Conversions
+  operator uint32_t() const { return _address.dword; };
+
+  friend class EthernetClass;
+  friend class UDP;
+  friend class Client;
+  friend class Server;
+  friend class DhcpClass;
+  friend class DNSClient;
+};
+
+const IPAddress INADDR_NONE(0, 0, 0, 0);

data/cpp/arduino/MockEventQueue.h

@@ -0,0 +1,86 @@
+#pragma once
+
+template <typename T>
+class MockEventQueue {
+  public:
+    struct Event {
+      T data;
+      unsigned long micros;
+
+      Event() : data(T()), micros(0) {}
+      Event(const T &d, unsigned long const t) : data(d), micros(t) { }
+    };
+
+  private:
+    struct Node {
+      Event event;
+      Node* next;
+
+      Node(const Event &e, Node* n) : event(e), next(n) { }
+    };
+
+    Node* mFront;
+    Node* mBack;
+    unsigned long mSize;
+    T mNil;
+    unsigned long (*mGetMicros)(void);
+
+    void init(unsigned long (*getMicros)(void)) {
+      mFront = mBack = nullptr;
+      mSize = 0;
+      mGetMicros = getMicros;
+    }
+
+  public:
+    MockEventQueue(unsigned long (*getMicros)(void)): mNil() { init(getMicros); }
+    MockEventQueue(): mNil() { init(nullptr); }
+
+    MockEventQueue(const MockEventQueue<T>& q) {
+      init(q.mGetMicros);
+      for (Node* n = q.mFront; n; n = n->next) push(n->event);
+    }
+
+    void setMicrosRetriever(unsigned long (*getMicros)(void)) { mGetMicros = getMicros; }
+
+    inline unsigned long size() const { return mSize; }
+    inline bool empty() const { return 0 == mSize; }
+    inline Event front() const { return empty() ? Event(mNil, 0) : mFront->event; }
+    inline Event back() const { return empty() ?  Event(mNil, 0) : mBack->event; }
+    inline T frontData() const { return front().data; }
+    inline T backData() const { return back().data; }
+    inline unsigned long frontTime() const { return front().micros; }
+    inline unsigned long backTime() const { return back().micros; }
+
+
+    // fully formed event
+    bool push(const Event& e) {
+      Node *n = new Node(e, nullptr);
+      if (n == nullptr) return false;
+      mBack = (mFront == nullptr ? mFront : mBack->next) = n;
+      return ++mSize;
+    }
+
+    // fully specfied event
+    bool push(const T& v, unsigned long const time) {
+      Event e = {v, time};
+      return push(e);
+    }
+
+    // event needing timestamp
+    bool push(const T& v) {
+      unsigned long micros = mGetMicros == nullptr ? 0 : mGetMicros();
+      return push(v, micros);
+    }
+
+    void pop() {
+      if (empty()) return;
+      Node* n = mFront;
+      mFront = mFront->next;
+      delete n;
+      if (--mSize == 0) mBack = nullptr;
+    }
+
+    void clear() { while (!empty()) pop(); }
+
+    ~MockEventQueue() { clear(); }
+};

data/cpp/arduino/PinHistory.h

@@ -1,5 +1,5 @@
 #pragma once
-#include "ci/Queue.h"
+#include "MockEventQueue.h"
 #include "ci/ObservableDataStream.h"
 #include "WString.h"
 
@@ -7,8 +7,8 @@
 template <typename T>
 class PinHistory : public ObservableDataStream {
   private:
-    ArduinoCIQueue<T> qIn;
-    ArduinoCIQueue<T> qOut;
+    MockEventQueue<T> qIn;
+    MockEventQueue<T> qOut;
 
     void clear() {
       qOut.clear();
@@ -16,14 +16,14 @@ class PinHistory : public ObservableDataStream {
     }
 
     // enqueue ascii bits
-    void a2q(ArduinoCIQueue<T> &q, String input, bool bigEndian, bool advertise) {
+    void a2q(MockEventQueue<T> &q, String input, bool bigEndian, bool advertise) {
       // 8 chars at a time, form up
       for (int j = 0; j < input.length(); ++j) {
         for (int i = 0; i < 8; ++i) {
           int shift = bigEndian ? 7 - i : i;
           unsigned char mask = (0x01 << shift);
           q.push(mask & input[j]);
-          if (advertise) advertiseBit(q.back()); // not valid for all possible types but whatever
+          if (advertise) advertiseBit(q.backData()); // not valid for all possible types but whatever
         }
       }
     }
@@ -31,10 +31,10 @@ class PinHistory : public ObservableDataStream {
 
     // convert a queue to a string as if it was serial bits
     // start from offset, consider endianness
-    String q2a(const ArduinoCIQueue<T> &q, unsigned int offset, bool bigEndian) const {
+    String q2a(const MockEventQueue<T> &q, unsigned int offset, bool bigEndian) const {
       String ret = "";
 
-      ArduinoCIQueue<T> q2(q);
+      MockEventQueue<T> q2(q);
 
       while (offset) {
         q2.pop();
@@ -48,7 +48,7 @@ class PinHistory : public ObservableDataStream {
         unsigned char acc = 0x00;
         for (int i = 0; i < 8; ++i) {
           int shift = bigEndian ? 7 - i : i;
-          T val = q2.front();
+          T val = q2.frontData();
           unsigned char bit = val ? 0x1 : 0x0;
           acc |= (bit << shift);
           q2.pop();
@@ -59,15 +59,25 @@ class PinHistory : public ObservableDataStream {
       return ret;
     }
 
+    void init() {
+      asciiEncodingOffsetIn = 0;  // default is sensible
+      asciiEncodingOffsetOut = 1; // default is sensible
+    }
+
   public:
     unsigned int asciiEncodingOffsetIn;
     unsigned int asciiEncodingOffsetOut;
 
+    PinHistory(unsigned long (*getMicros)(void)) : ObservableDataStream(), qOut(getMicros) {
+      init();
+    }
+
     PinHistory() : ObservableDataStream() {
-      asciiEncodingOffsetIn = 0;  // default is sensible
-      asciiEncodingOffsetOut = 1; // default is sensible
+      init();
     }
 
+    void setMicrosRetriever(unsigned long (*getMicros)(void)) { qOut.setMicrosRetriever(getMicros); }
+
     void reset(T val) {
       clear();
       qOut.push(val);
@@ -79,8 +89,8 @@ class PinHistory : public ObservableDataStream {
 
     // This returns the "value" of the pin in a raw sense
     operator T() const {
-      if (!qIn.empty()) return qIn.front();
-      return qOut.back();
+      if (!qIn.empty()) return qIn.frontData();
+      return qOut.backData();
     }
 
     // this sets the value of the pin authoritatively
@@ -89,8 +99,8 @@ class PinHistory : public ObservableDataStream {
     T operator=(const T& i) {
       qIn.clear();
       qOut.push(i);
-      advertiseBit(qOut.back()); // not valid for all possible types but whatever
-      return qOut.back();
+      advertiseBit(qOut.backData()); // not valid for all possible types but whatever
+      return qOut.backData();
     }
 
     // This returns the "value" of the pin according to the queued values
@@ -98,14 +108,14 @@ class PinHistory : public ObservableDataStream {
     // then take the latest output.
     T retrieve() {
       if (!qIn.empty()) {
-        T hack_required_by_travis_ci = qIn.front();
+        T hack_required_by_travis_ci = qIn.frontData();
         qIn.pop();
         qOut.push(hack_required_by_travis_ci);
       }
-      return qOut.back();
+      return qOut.backData();
     }
 
-    // enqueue a set of elements
+    // enqueue a set of data elements
     void fromArray(T const * const arr, unsigned int length) {
       for (int i = 0; i < length; ++i) qIn.push(arr[i]);
     }
@@ -124,18 +134,48 @@ class PinHistory : public ObservableDataStream {
     // start from offset, consider endianness
     String incomingToAscii(bool bigEndian) const { return incomingToAscii(asciiEncodingOffsetIn, bigEndian); }
 
-    // convert the pin history to a string as if it was Serial comms
+    // convert the pin history data to a string as if it was Serial comms
     // start from offset, consider endianness
     String toAscii(unsigned int offset, bool bigEndian) const { return q2a(qOut, offset, bigEndian); }
 
-    // convert the pin history to a string as if it was Serial comms
+    // convert the pin history data to a string as if it was Serial comms
     // start from offset, consider endianness
     String toAscii(bool bigEndian) const { return toAscii(asciiEncodingOffsetOut, bigEndian); }
 
-    // copy elements to an array, up to a given length
+    // copy data elements to an array, up to a given length
     // return the number of elements moved
     int toArray (T* arr, unsigned int length) const {
-      ArduinoCIQueue<T> q2(qOut);
+      MockEventQueue<T> q2(qOut);  // preserve const by copying
+
+      int ret = 0;
+      for (int i = 0; i < length && q2.size(); ++i) {
+        arr[i] = q2.frontData();
+        q2.pop();
+        ++ret;
+      }
+      return ret;
+    }
+
+    // copy pin history timing to an array, up to a given length.
+    // note that this records times between calls to the pin, not between transitions
+    // return the number of elements moved
+    int toTimestampArray(unsigned long* arr, unsigned int length) const {
+      MockEventQueue<T> q2(qOut);  // preserve const by copying
+
+      int ret = 0;
+      for (int i = 0; i < length && q2.size(); ++i) {
+        arr[i] = q2.frontTime();
+        q2.pop();
+        ++ret;
+      }
+      return ret;
+    }
+
+    // copy pin history timing to an array, up to a given length.
+    // note that this records times between calls to the pin, not between transitions
+    // return the number of elements moved
+    int toEventArray(typename MockEventQueue<T>::Event* arr, unsigned int length) const {
+      MockEventQueue<T> q2(qOut);  // preserve const by copying
 
       int ret = 0;
       for (int i = 0; i < length && q2.size(); ++i) {
@@ -146,12 +186,12 @@ class PinHistory : public ObservableDataStream {
       return ret;
     }
 
-    // see if the array matches the elements in the queue
+    // see if the array matches the data of the elements in the queue
     bool hasElements (T const * const arr, unsigned int length) const {
       int i;
-      ArduinoCIQueue<T> q2(qOut);
+      MockEventQueue<T> q2(qOut);  // preserve const by copying
       for (i = 0; i < length && q2.size(); ++i) {
-        if (q2.front() != arr[i]) return false;
+        if (q2.frontData() != arr[i]) return false;
         q2.pop();
       }
       return i == length;

data/cpp/arduino/Print.h

@@ -2,6 +2,8 @@
 
 #include <stdio.h>
 #include <avr/pgmspace.h>
+
+#include "Printable.h"
 #include "WString.h"
 
 #define DEC 10
@@ -12,22 +14,17 @@
 #endif
 #define BIN 2
 
-class Print;
-
-class Printable
-{
-  public:
-    virtual size_t printTo(Print& p) const = 0;
-};
-
 class Print
 {
+  private:
+    int write_error;
+  protected:
+    void setWriteError(int err = 1) { write_error = err; }
   public:
-    Print() {}
+    Print() : write_error(0) {}
 
-    // Arduino's version of this is richer but until I see an actual error case I'm not sure how to mock
-    int getWriteError() { return 0; }
-    void clearWriteError() { }
+    int getWriteError() { return write_error; }
+    void clearWriteError() { setWriteError(0); }
     virtual int availableForWrite() { return 0; }
 
     virtual size_t write(uint8_t) = 0;

data/cpp/arduino/Printable.h

@@ -0,0 +1,8 @@
+#pragma once
+
+class Print;
+
+class Printable {
+public:
+  virtual size_t printTo(Print &p) const = 0;
+};