arduino_ci 0.1.4 → 0.1.5

data/cpp/arduino/HardwareSerial.h

@@ -29,13 +29,13 @@
 #define SERIAL_7O2 0x3C
 #define SERIAL_8O2 0x3E
 
-class HardwareSerial : public Stream
+class HardwareSerial : public Stream, public ObservableDataStream
 {
   protected:
     String* mGodmodeDataOut;
 
   public:
-    HardwareSerial(String* dataIn, String* dataOut, unsigned long* delay): Stream() {
+    HardwareSerial(String* dataIn, String* dataOut, unsigned long* delay): Stream(), ObservableDataStream() {
       mGodmodeDataIn      = dataIn;
       mGodmodeDataOut     = dataOut;
       mGodmodeMicrosDelay = delay;
@@ -51,7 +51,11 @@ class HardwareSerial : public Stream
     // virtual int read(void);
     // virtual int availableForWrite(void);
     // virtual void flush(void);
-    virtual size_t write(uint8_t aChar) { mGodmodeDataOut->append(String((char)aChar)); return 1; }
+    virtual size_t write(uint8_t aChar) {
+      mGodmodeDataOut->append(String((char)aChar));
+      advertiseByte((unsigned char)aChar);
+      return 1;
+    }
 
     inline size_t write(unsigned long n) { return write((uint8_t)n); }
     inline size_t write(long n) { return write((uint8_t)n); }

data/cpp/arduino/PinHistory.h

@@ -0,0 +1,160 @@
+#pragma once
+#include "ci/Queue.h"
+#include "ci/ObservableDataStream.h"
+#include "WString.h"
+
+// pins with history.
+template <typename T>
+class PinHistory : public ObservableDataStream {
+  private:
+    Queue<T> qIn;
+    Queue<T> qOut;
+
+    void clear() {
+      qOut.clear();
+      qIn.clear();
+    }
+
+    // enqueue ascii bits
+    void a2q(Queue<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
+        }
+      }
+    }
+
+
+    // convert a queue to a string as if it was serial bits
+    // start from offset, consider endianness
+    String q2a(const Queue<T> &q, unsigned int offset, bool bigEndian) const {
+      String ret = "";
+
+      Queue<T> q2(q);
+
+      while (offset) {
+        q2.pop();
+        --offset;
+      }
+
+      if (offset) return ret;
+
+      // 8 chars at a time, form up
+      while (q2.size() >= 8) {
+        unsigned char acc = 0x00;
+        for (int i = 0; i < 8; ++i) {
+          int shift = bigEndian ? 7 - i : i;
+          T val = q2.front();
+          unsigned char bit = val ? 0x1 : 0x0;
+          acc |= (bit << shift);
+          q2.pop();
+        }
+        ret.append(String((char)acc));
+      }
+
+      return ret;
+    }
+
+  public:
+    unsigned int asciiEncodingOffsetIn;
+    unsigned int asciiEncodingOffsetOut;
+
+    PinHistory() : ObservableDataStream() {
+      asciiEncodingOffsetIn = 0;  // default is sensible
+      asciiEncodingOffsetOut = 1; // default is sensible
+    }
+
+    void reset(T val) {
+      clear();
+      qOut.push(val);
+    }
+
+    unsigned int historySize() const { return qOut.size(); }
+
+    unsigned int queueSize() const { return qIn.size(); }
+
+    // This returns the "value" of the pin in a raw sense
+    operator T() const {
+      if (!qIn.empty()) return qIn.front();
+      return qOut.back();
+    }
+
+    // this sets the value of the pin authoritatively
+    // so if there was a queue, dump it.
+    // the actual "set" operation doesn't happen until the next read
+    const T &operator=(const T& i) {
+      qIn.clear();
+      qOut.push(i);
+      advertiseBit(qOut.back()); // not valid for all possible types but whatever
+      return qOut.back();
+    }
+
+    // This returns the "value" of the pin according to the queued values
+    // if there is input, advance it to the output.
+    // then take the latest output.
+    T retrieve() {
+      if (!qIn.empty()) {
+        T hack_required_by_travis_ci = qIn.front();
+        qIn.pop();
+        qOut.push(hack_required_by_travis_ci);
+      }
+      return qOut.back();
+    }
+
+    // enqueue a set of elements
+    void fromArray(T const * const arr, unsigned int length) {
+      for (int i = 0; i < length; ++i) qIn.push(arr[i]);
+    }
+
+    // enqueue ascii bits for future use by the retrieve() function
+    void fromAscii(String input, bool bigEndian) { a2q(qIn, input, bigEndian, false); }
+
+    // send a stream of ascii bits immediately
+    void outgoingFromAscii(String input, bool bigEndian) { a2q(qOut, input, bigEndian, true); }
+
+    // convert the queue of incoming data to a string as if it was Serial comms
+    // start from offset, consider endianness
+    String incomingToAscii(unsigned int offset, bool bigEndian) const { return q2a(qIn, offset, bigEndian); }
+
+    // convert the queue of incoming data to a string as if it was Serial comms
+    // 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
+    // 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
+    // start from offset, consider endianness
+    String toAscii(bool bigEndian) const { return toAscii(asciiEncodingOffsetOut, bigEndian); }
+
+    // copy elements to an array, up to a given length
+    // return the number of elements moved
+    int toArray (T* arr, unsigned int length) const {
+      Queue<T> q2(qOut);
+
+      int ret = 0;
+      for (int i = 0; i < length && q2.size(); ++i) {
+        arr[i] = q2.front();
+        q2.pop();
+        ++ret;
+      }
+      return ret;
+    }
+
+    // see if the array matches the elements in the queue
+    bool hasElements (T const * const arr, unsigned int length) const {
+      int i;
+      Queue<T> q2(qOut);
+      for (i = 0; i < length && q2.size(); ++i) {
+        if (q2.front() != arr[i]) return false;
+        q2.pop();
+      }
+      return i == length;
+    }
+
+};

data/cpp/arduino/Print.h

@@ -31,8 +31,10 @@ class Print
 
     virtual size_t write(uint8_t) = 0;
     size_t write(const char *str) { return str == NULL ? 0 : write((const uint8_t *)str, String(str).length()); }
-    virtual size_t write(const uint8_t *buffer, size_t size)
-    {
+
+    size_t write(const __FlashStringHelper *str) { return write((const char *)str); }
+
+    virtual size_t write(const uint8_t *buffer, size_t size) {
       size_t n;
       for (n = 0; size && write(*buffer++) && ++n; --size);
       return n;

data/cpp/arduino/SoftwareSerial.h

@@ -0,0 +1,77 @@
+#pragma once
+#include "Print.h"
+#include "Stream.h"
+#include "Godmode.h"
+
+// definitions neeeded for Serial.begin's config arg
+
+class SoftwareSerial : public Stream
+{
+  private:
+    int mPinIn;
+    int mPinOut;
+    bool mInverse;
+    bool mIsListening;
+    GodmodeState* mState;
+    unsigned long mOffset; // bits to offset stream
+    bool bigEndian;
+
+  public:
+    SoftwareSerial(uint8_t receivePin, uint8_t transmitPin, bool inverse_logic = false) {
+      mPinIn = receivePin;
+      mPinOut = transmitPin;
+      mIsListening = false;
+      mOffset = 0; // godmode starts with 1 bit in the queue
+      mState = GODMODE();
+      bigEndian = false;  // this is how serial works
+    }
+
+    ~SoftwareSerial() {};
+
+    void setGodmodeOffset(unsigned long offset) {
+      mOffset = offset;
+    }
+
+    bool listen() { return mIsListening = true; }
+    bool isListening() { return mIsListening; }
+    bool stopListening() {
+      bool ret = mIsListening;
+      mIsListening = false;
+      return ret;
+    }
+    void begin(long speed) { listen(); }
+    void end() { stopListening(); }
+    bool overflow() { return false; }
+
+    int peek() {
+      if (!isListening()) return -1;
+      String input = mState->digitalPin[mPinIn].incomingToAscii(mOffset, bigEndian);
+      if (input.empty()) return -1;
+      return input[0];
+    }
+
+    virtual int read() {
+      if (!isListening()) return -1;
+      String input = mState->digitalPin[mPinIn].incomingToAscii(mOffset, bigEndian);
+      if (input.empty()) return -1;
+      int ret = input[0];
+      for (int i = 0; i < 8; ++i) digitalRead(mPinIn);
+      return ret;
+    }
+
+    //using Print::write;
+
+    virtual size_t write(uint8_t byte) {
+      mState->digitalPin[mPinOut].outgoingFromAscii(String((char)byte), bigEndian);
+      return 1;
+    }
+
+    virtual int available() { return mState->digitalPin[mPinIn].incomingToAscii(mOffset, bigEndian).length();  }
+    virtual void flush() {}
+    operator bool() { return true; }
+
+    static inline void handle_interrupt() {};
+
+};
+
+

data/cpp/arduino/Stream.h

@@ -3,7 +3,6 @@
 #include "WString.h"
 #include "Print.h"
 
-
 // This enumeration provides the lookahead options for parseInt(), parseFloat()
 // The rules set out here are used until either the first valid character is found
 // or a time out occurs due to lack of input.
@@ -45,7 +44,9 @@ class Stream : public Print
 
   public:
     virtual int available() { return mGodmodeDataIn->length(); }
+
     virtual int peek() { return available() ? (int)((*mGodmodeDataIn)[0]) : -1; }
+
     virtual int read() {
       int ret = peek();
       if (ret != -1) {
@@ -55,6 +56,8 @@ class Stream : public Print
       return ret;
     }
 
+    using Print::write;
+
     virtual size_t write(uint8_t aChar) { mGodmodeDataIn->append(String((char)aChar)); return 1; }
 
 

data/cpp/arduino/WString.h

@@ -9,6 +9,9 @@
 
 typedef std::string string;
 
+//typedef const char __FlashStringHelper;
+class __FlashStringHelper;
+#define F(string_literal) (reinterpret_cast<const __FlashStringHelper *>(PSTR(string_literal)))
 
 // Compatibility with string class
 class String: public string
@@ -23,7 +26,7 @@ class String: public string
 
   private:
     static const char* digit(int val) {
-      const char* bank = "0123456789ABCDEF";
+      static const char* bank = "0123456789ABCDEF";
       return bank + val;
     }
 
@@ -51,10 +54,11 @@ class String: public string
 
 public:
   ~String(void) {}
+  String(const __FlashStringHelper *str): string((const char *)str) {}
   String(const char *cstr = ""): string(cstr) {}
-  String(const string &str): string(str.c_str()) {}
-  String(const String &str): string(str.c_str()) {}
-  explicit String(char c): string(&c, 1) {}
+  String(const string &str): string(str) {}
+  String(const String &str): string(str) {}
+  explicit String(char c): string(1, c) {}
 
   explicit String(unsigned char val, unsigned char base=10): string(mytoa(val, base)) {}
   explicit String(int val,           unsigned char base=10): string(mytoas(val, base)) {}
@@ -66,14 +70,15 @@ public:
   explicit String(double val, unsigned char decimalPlaces=2): string(dtoas(val, decimalPlaces)) {}
 
   String & operator = (const String &rhs) { assign(rhs); return *this; }
-  String & operator = (const char *cstr) { assign(cstr); return *this; }
-
-	unsigned char reserve(unsigned int size) { return true; } // calling reserve(size) segfaults, no idea why
+  String & operator = (const string &rhs) { assign(rhs); return *this; }
+  String & operator = (const char *cstr)  { assign(cstr); return *this; }
+  String & operator = (const char c)      { assign(1, c); return *this; }
 
+  unsigned char concat(const __FlashStringHelper *str) { append((const char *)str); return 1; }
   unsigned char concat(const String &str) { append(str); return 1; }
   unsigned char concat(const char *cstr)  { append(cstr); return 1; }
-  unsigned char concat(char c)            { append((const char*)&c, 1); return 1; }
-  unsigned char concat(unsigned char c)   { append((const char*)&c, 1); return 1; }
+  unsigned char concat(char c)            { append(1, c); return 1; }
+  unsigned char concat(unsigned char c)   { append(1, c); return 1; }
   unsigned char concat(int num)           { append(String(num)); return 1; }
   unsigned char concat(unsigned int num)  { append(String(num)); return 1; }
   unsigned char concat(long num)          { append(String(num)); return 1; }
@@ -81,6 +86,7 @@ public:
   unsigned char concat(float num)         { append(String(num)); return 1; }
   unsigned char concat(double num)        { append(String(num)); return 1; }
 
+  String & operator += (const __FlashStringHelper *rhs) { concat(rhs);  return *this; }
   String & operator += (const String &rhs) { concat(rhs);  return *this; }
   String & operator += (const char *cstr)  { concat(cstr); return *this; }
   String & operator += (char c)            { concat(c);    return *this; }