arduino_ci 0.1.4 → 0.1.5

data/cpp/arduino/avr/pgmspace.h

@@ -0,0 +1,94 @@
+#pragma once
+
+
+/*
+def d(var_raw)
+   var = var_raw.split("_")[0]
+   out = "#define #{var}_P(...) #{var}(__VA_ARGS__)\n"
+   IO.popen('pbcopy', 'w') { |f| f << out }
+   out
+ end
+
+text = File.open("arduino-1.8.5/hardware/tools/avr/avr/include/avr/pgmspace.h").read
+externs = text.split("\n").select {|l| l.start_with? "extern"}
+out = externs.map {|l| l.split("(")[0].split(" ")[-1].gsub("*", "") }.uniq
+out.each { |l| puts d(l) }
+*/
+
+#include <avr/io.h>
+
+#define PROGMEM
+
+#ifndef PGM_P
+#define PGM_P const char *
+#endif
+
+#ifndef PGM_VOID_P
+#define PGM_VOID_P const void *
+#endif
+
+// everything's a no-op
+#define PSTR(s) ((const char *)(s))
+#define pgm_read_byte_near(x)  (x)
+#define pgm_read_word_near(x)  (x)
+#define pgm_read_dword_near(x) (x)
+#define pgm_read_float_near(x) (x)
+#define pgm_read_ptr_near(x)   (x)
+
+#define pgm_read_byte_far(x)  (x)
+#define pgm_read_word_far(x)  (x)
+#define pgm_read_dword_far(x) (x)
+#define pgm_read_float_far(x) (x)
+#define pgm_read_ptr_far(x)   (x)
+
+
+#define pgm_read_byte(x) (x)
+#define pgm_read_word(x) (x)
+#define pgm_read_dword(x) (x)
+#define pgm_read_float(x) (x)
+#define pgm_read_ptr(x) (x)
+#define pgm_get_far_address(x) (x)
+
+#define memchr_P(...) memchr(__VA_ARGS__)
+#define memcmp_P(...) memcmp(__VA_ARGS__)
+#define memccpy_P(...) memccpy(__VA_ARGS__)
+#define memcpy_P(...) memcpy(__VA_ARGS__)
+#define memmem_P(...) memmem(__VA_ARGS__)
+#define memrchr_P(...) memrchr(__VA_ARGS__)
+#define strcat_P(...) strcat(__VA_ARGS__)
+#define strchr_P(...) strchr(__VA_ARGS__)
+#define strchrnul_P(...) strchrnul(__VA_ARGS__)
+#define strcmp_P(...) strcmp(__VA_ARGS__)
+#define strcpy_P(...) strcpy(__VA_ARGS__)
+#define strcasecmp_P(...) strcasecmp(__VA_ARGS__)
+#define strcasestr_P(...) strcasestr(__VA_ARGS__)
+#define strcspn_P(...) strcspn(__VA_ARGS__)
+#define strlcat_P(...) strlcat(__VA_ARGS__)
+#define strlcpy_P(...) strlcpy(__VA_ARGS__)
+#define strnlen_P(...) strnlen(__VA_ARGS__)
+#define strncmp_P(...) strncmp(__VA_ARGS__)
+#define strncasecmp_P(...) strncasecmp(__VA_ARGS__)
+#define strncat_P(...) strncat(__VA_ARGS__)
+#define strncpy_P(...) strncpy(__VA_ARGS__)
+#define strpbrk_P(...) strpbrk(__VA_ARGS__)
+#define strrchr_P(...) strrchr(__VA_ARGS__)
+#define strsep_P(...) strsep(__VA_ARGS__)
+#define strspn_P(...) strspn(__VA_ARGS__)
+#define strstr_P(...) strstr(__VA_ARGS__)
+#define strtok_P(...) strtok(__VA_ARGS__)
+#define strtok_P(...) strtok(__VA_ARGS__)
+#define strlen_P(...) strlen(__VA_ARGS__)
+#define strnlen_P(...) strnlen(__VA_ARGS__)
+#define memcpy_P(...) memcpy(__VA_ARGS__)
+#define strcpy_P(...) strcpy(__VA_ARGS__)
+#define strncpy_P(...) strncpy(__VA_ARGS__)
+#define strcat_P(...) strcat(__VA_ARGS__)
+#define strlcat_P(...) strlcat(__VA_ARGS__)
+#define strncat_P(...) strncat(__VA_ARGS__)
+#define strcmp_P(...) strcmp(__VA_ARGS__)
+#define strncmp_P(...) strncmp(__VA_ARGS__)
+#define strcasecmp_P(...) strcasecmp(__VA_ARGS__)
+#define strncasecmp_P(...) strncasecmp(__VA_ARGS__)
+#define strstr_P(...) strstr(__VA_ARGS__)
+#define strlcpy_P(...) strlcpy(__VA_ARGS__)
+#define memcmp_P(...) memcmp(__VA_ARGS__)

data/cpp/arduino/binary.h

@@ -1,3 +1,4 @@
+#pragma once
 /* ruby
 (1..8).each do |b|
   (0..(2**b - 1)).each do |v|

data/cpp/arduino/ci/DeviceUsingBytes.h

@@ -0,0 +1,56 @@
+#pragma once
+
+#include "ObservableDataStream.h"
+#include "Table.h"
+#include <WString.h>
+#include <Godmode.h>
+
+
+// Define a rudimentary serial device that responds to byte sequences
+//
+// The class monitors whatever stream it is observing, and builds up
+//  a buffer of the incoming data.  If/when that data matches one of
+//  the stored responses, the buffer is cleared and the response to
+//  the matched requests is sent to the handler `onMatchInput`
+//
+//  WARNING: if input is consumed and no matches are found, you are
+//    in a bad state where you can never match anything again.  @TODO
+//
+// The extender of this abstract class should provide the following:
+//   1. A set of responses using one of the provided convenience functions:
+//      * `addResponse`: request and response are taken verbatim
+//      * `addResponseLine`: request and response are appended a \n
+//      * `addResponseCRLF`: request and response are appended a \r\n
+//   2. An action `onMatchInput` -- what to do with a response when triggered
+class DeviceUsingBytes : public DataStreamObserver {
+  public:
+    String mMessage;
+    Table<String, String> mResponses;
+    GodmodeState* state;
+
+
+    DeviceUsingBytes() : DataStreamObserver(true, false) {
+      mMessage = "";
+      state = GODMODE();
+    }
+
+    virtual ~DeviceUsingBytes() {}
+
+    bool addResponse(String hear, String say) { return mResponses.add(hear, say); }
+    bool addResponseLine(String hear, String say) { return mResponses.add(hear + "\n", say + "\n"); }
+    bool addResponseCRLF(String hear, String say) { return mResponses.add(hear + "\r\n", say + "\r\n"); }
+
+    // what to do when there is a match
+    virtual void onMatchInput(String output) = 0;
+
+    virtual String observerName() const { return "DeviceUsingBytes"; }
+
+    virtual void onByte(unsigned char c) {
+      mMessage.concat(c);
+      if (mResponses.has(mMessage)) {
+        onMatchInput(mResponses.get(mMessage));
+        mMessage = "";
+      }
+    }
+};
+

data/cpp/arduino/ci/ObservableDataStream.h

@@ -0,0 +1,124 @@
+#pragma once
+
+#include "Table.h"
+#include <WString.h>
+
+
+// This pair of classes defines an Observer pattern for bits and bytes.
+// This would allow us to create "devices" that respond in "real" time
+// to Arduino outputs, in the form of altering the Arduino inputs
+//
+// e.g. replying to a serial output with serial input
+class ObservableDataStream;
+
+// datastream observers handle deliveries of bits and bytes.
+// optionally, they can turn bit events into byte events with a given endianness
+class DataStreamObserver {
+  private:
+    unsigned int  mBitPosition;   // for building the byte (mask helper)
+    unsigned char mBuildingByte;  // for storing incoming bits
+    bool          mAutoBitPack;   // whether to report the packed bits
+    bool          mBigEndian;     // bit order for byte
+
+  protected:
+    // functions that are up to the implementer to provide.
+    virtual void onBit(bool aBit) {}
+    virtual void onByte(unsigned char aByte) {}
+    virtual String observerName() const = 0;
+
+  public:
+    DataStreamObserver(bool autoBitPack, bool bigEndian)
+    {
+      mBitPosition = 0;
+      mBuildingByte = 0x00;
+      mAutoBitPack = autoBitPack;
+      mBigEndian = bigEndian;
+    }
+
+    virtual ~DataStreamObserver()  {}
+
+    // entry point for byte-related handler
+    void handleByte(unsigned char aByte) {
+      onByte(aByte);
+    }
+
+    // entry poitn for bit-related handler
+    void handleBit(bool aBit) {
+      onBit(aBit);
+
+      if (!mAutoBitPack) return;
+
+      // build the next value
+      int shift = mBigEndian ? 7 - mBitPosition : mBitPosition;
+      unsigned char val = aBit ? 0x1 : 0x0;
+      mBuildingByte |= (val << shift);
+
+      // if we roll over after incrementing, the byte is ready to ship
+      mBitPosition = (mBitPosition + 1) % 8;
+      if (mBitPosition == 0) {
+        handleByte(mBuildingByte);
+        mBuildingByte = 0x00;
+      };
+    }
+
+    // inlined after ObservableDataStream definition to fake out the compiler
+    bool attach(ObservableDataStream* source);
+    bool detach(ObservableDataStream* source);
+};
+
+// Inheritable interface for things that produce data, like pins or serial ports
+// this class allows others to subscribe for updates on these values and trigger actions
+// e.g. if you "turn on" a motor with one pin and expect to see a change in an analog pin
+class ObservableDataStream
+{
+  private:
+    Table<String, DataStreamObserver*> mObservers;
+    bool          mAdvertisingBit;
+    unsigned char mAdvertisingByte;
+
+  protected:
+    // to allow both member and non-member functions to be called, we need to trick the compiler
+    // into getting the (this) of a static function.  So the default is a work function signature
+    // that takes a second optional argument.  in this case, we use the argument.
+
+    static void workAdvertiseBit(ObservableDataStream* that, String _, DataStreamObserver* val) {
+      val->handleBit(that->mAdvertisingBit);
+    }
+
+    static void workAdvertiseByte(ObservableDataStream* that, String _, DataStreamObserver* val) {
+      val->handleByte(that->mAdvertisingByte);
+    }
+
+    // advertise functions allow the data stream to publish to observers
+
+    // update all observers with a byte value
+    void advertiseByte(unsigned char aByte) {
+      // save the value to a class variable. then use the static method with this instance
+      mAdvertisingByte = aByte;
+      mObservers.iterate(workAdvertiseByte, this);
+    }
+
+    // update all observers with a byte value
+    // build up a byte
+    // if requested, advertise the byte
+    void advertiseBit(bool aBit) {
+      // do the named thing first, of course
+      mAdvertisingBit = aBit;
+      mObservers.iterate(workAdvertiseBit, this);
+    }
+
+  public:
+    ObservableDataStream() : mObservers() {
+      mAdvertisingBit  = false; // we'll re-init on demand though
+      mAdvertisingByte = 0x07;  // we'll re-init on demand though
+    }
+
+    virtual ~ObservableDataStream() {}
+
+    bool addObserver(String name, DataStreamObserver* obs) { return mObservers.add(name, obs); }
+    bool removeObserver(String name) { return mObservers.remove(name); }
+};
+
+inline bool DataStreamObserver::attach(ObservableDataStream* source) { return source->addObserver(observerName(), this); }
+
+inline bool DataStreamObserver::detach(ObservableDataStream* source) { return source->removeObserver(observerName()); }

data/cpp/arduino/ci/Queue.h

@@ -0,0 +1,73 @@
+#pragma once
+
+template <typename T>
+class Queue {
+  private:
+    struct Node {
+      T data;
+      Node* next;
+    };
+
+    Node* mFront;
+    Node* mBack;
+    unsigned long mSize;
+    T mNil;
+
+    void init() {
+      mFront = mBack = NULL;
+      mSize = 0;
+    }
+
+  public:
+    Queue(): mNil() { init(); }
+
+    Queue(const Queue<T>& q) {
+      init();
+      for (Node* n = q.mFront; n; n = n->next) push(n->data);
+    }
+
+    inline unsigned long size() const { return mSize; }
+
+    inline bool empty() const { return 0 == mSize; }
+
+    const T& front() const { return empty() ? mNil : mFront->data; }
+
+    const T& back() const { return empty() ? mNil : mBack->data; }
+
+    bool push(const T& v)
+    {
+      Node *n = new Node;
+      if (n == NULL) return false;
+
+      n->data = v;
+      n->next = NULL;
+
+      if (mFront == NULL)
+      {
+        mFront = mBack = n;
+      } else {
+        mBack->next = n;
+        mBack = n;
+      }
+
+      ++mSize;
+      return true;
+    }
+
+    void pop() {
+      if (empty()) return;
+      if (mFront == mBack) {
+        mFront = mBack = NULL;
+      } else {
+        Node* n = mFront;
+        mFront = mFront->next;
+        delete n;
+      }
+
+      --mSize;
+    }
+
+    void clear() { while (!empty()) pop(); }
+
+    ~Queue() { clear(); }
+};