arduino_ci 0.1.3 → 0.1.4

data/cpp/arduino/Godmode.cpp

@@ -0,0 +1,62 @@
+#include "Godmode.h"
+#include "HardwareSerial.h"
+
+GodmodeState godmode = GodmodeState();
+
+GodmodeState* GODMODE() {
+  return &godmode;
+}
+
+unsigned long millis() {
+  GodmodeState* godmode = GODMODE();
+  return godmode->micros / 1000;
+}
+
+unsigned long micros() {
+  GodmodeState* godmode = GODMODE();
+  return godmode->micros;
+}
+
+void delay(unsigned long millis) {
+  GodmodeState* godmode = GODMODE();
+  godmode->micros += millis * 1000;
+}
+
+void delayMicroseconds(unsigned long micros) {
+  GodmodeState* godmode = GODMODE();
+  godmode->micros += micros;
+}
+
+
+void randomSeed(unsigned long seed)
+{
+  GodmodeState* godmode = GODMODE();
+  godmode->seed = seed;
+}
+
+long random(long vmax)
+{
+  GodmodeState* godmode = GODMODE();
+  godmode->seed += 4294967291;  // it's a prime that fits in 32 bits
+  return godmode->seed % vmax;
+}
+
+long random(long vmin, long vmax)
+{
+  return vmin < vmax ? (random(vmax - vmin) + vmin) : vmin;
+}
+
+// Serial ports
+#if defined(HAVE_HWSERIAL0)
+  HardwareSerial Serial(&godmode.serialPort[0].dataIn, &godmode.serialPort[0].dataOut, &godmode.serialPort[0].readDelayMicros);
+#endif
+#if defined(HAVE_HWSERIAL1)
+  HardwareSerial Serial1(&godmode.serialPort[1].dataIn, &godmode.serialPort[1].dataOut, &godmode.serialPort[1].readDelayMicros);
+#endif
+#if defined(HAVE_HWSERIAL2)
+  HardwareSerial Serial2(&godmode.serialPort[2].dataIn, &godmode.serialPort[2].dataOut, &godmode.serialPort[2].readDelayMicros);
+#endif
+#if defined(HAVE_HWSERIAL3)
+  HardwareSerial Serial3(&godmode.serialPort[3].dataIn, &godmode.serialPort[3].dataOut, &godmode.serialPort[3].readDelayMicros);
+#endif
+

data/cpp/arduino/Godmode.h

@@ -0,0 +1,74 @@
+#pragma once
+#include "ArduinoDefines.h"
+#include "WString.h"
+
+#define MOCK_PINS_COUNT 256
+
+#if defined(UBRR3H)
+  #define NUM_SERIAL_PORTS 4
+#elif defined(UBRR2H)
+  #define NUM_SERIAL_PORTS 3
+#elif defined(UBRR1H)
+  #define NUM_SERIAL_PORTS 2
+#elif defined(UBRRH) || defined(UBRR0H)
+  #define NUM_SERIAL_PORTS 1
+#else
+  #define NUM_SERIAL_PORTS 0
+#endif
+
+
+class GodmodeState {
+  struct PortDef {
+    String dataIn;
+    String dataOut;
+    unsigned long readDelayMicros;
+  };
+
+  public:
+    unsigned long micros;
+    unsigned long seed;
+    // not going to put pinmode here unless its really needed. can't think of why it would be
+    bool digitalPin[MOCK_PINS_COUNT];
+    int analogPin[MOCK_PINS_COUNT];
+    struct PortDef serialPort[NUM_SERIAL_PORTS];
+
+    void resetPins() {
+      for (int i = 0; i < MOCK_PINS_COUNT; ++i) {
+        digitalPin[i] = LOW;
+        analogPin[i] = 0;
+      }
+    }
+
+    void resetClock() {
+      micros = 0;
+    }
+
+    void reset() {
+      resetClock();
+      resetPins();
+      seed = 1;
+    }
+
+    GodmodeState() {
+      reset();
+      for (int i = 0; i < NUM_SERIAL_PORTS; ++i) {
+        serialPort[i] = {"", "", 0};
+      }
+    }
+
+};
+
+GodmodeState* GODMODE();
+
+// random
+void randomSeed(unsigned long seed);
+long random(long vmax);
+long random(long vmin, long vmax);
+
+
+// Time
+void delay(unsigned long millis);
+void delayMicroseconds(unsigned long micros);
+unsigned long millis();
+unsigned long micros();
+

data/cpp/arduino/HardwareSerial.h

@@ -0,0 +1,81 @@
+#pragma once
+
+//#include <inttypes.h>
+#include "Stream.h"
+
+// definitions neeeded for Serial.begin's config arg
+#define SERIAL_5N1 0x00
+#define SERIAL_6N1 0x02
+#define SERIAL_7N1 0x04
+#define SERIAL_8N1 0x06
+#define SERIAL_5N2 0x08
+#define SERIAL_6N2 0x0A
+#define SERIAL_7N2 0x0C
+#define SERIAL_8N2 0x0E
+#define SERIAL_5E1 0x20
+#define SERIAL_6E1 0x22
+#define SERIAL_7E1 0x24
+#define SERIAL_8E1 0x26
+#define SERIAL_5E2 0x28
+#define SERIAL_6E2 0x2A
+#define SERIAL_7E2 0x2C
+#define SERIAL_8E2 0x2E
+#define SERIAL_5O1 0x30
+#define SERIAL_6O1 0x32
+#define SERIAL_7O1 0x34
+#define SERIAL_8O1 0x36
+#define SERIAL_5O2 0x38
+#define SERIAL_6O2 0x3A
+#define SERIAL_7O2 0x3C
+#define SERIAL_8O2 0x3E
+
+class HardwareSerial : public Stream
+{
+  protected:
+    String* mGodmodeDataOut;
+
+  public:
+    HardwareSerial(String* dataIn, String* dataOut, unsigned long* delay): Stream() {
+      mGodmodeDataIn      = dataIn;
+      mGodmodeDataOut     = dataOut;
+      mGodmodeMicrosDelay = 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)); 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); }
+    inline size_t write(unsigned int n) { return write((uint8_t)n); }
+    inline size_t write(int n) { return write((uint8_t)n); }
+    // using Print::write; // pull in write(str) and write(buf, size) from Print
+    operator bool() { return true; }
+
+};
+
+#if defined(UBRRH) || defined(UBRR0H)
+  extern HardwareSerial Serial;
+  #define HAVE_HWSERIAL0
+#endif
+#if defined(UBRR1H)
+  extern HardwareSerial Serial1;
+  #define HAVE_HWSERIAL1
+#endif
+#if defined(UBRR2H)
+  extern HardwareSerial Serial2;
+  #define HAVE_HWSERIAL2
+#endif
+#if defined(UBRR3H)
+  extern HardwareSerial Serial3;
+  #define HAVE_HWSERIAL3
+#endif
+

data/cpp/arduino/Print.h

@@ -0,0 +1,67 @@
+#pragma once
+
+#include <stdio.h>
+#include "WString.h"
+
+#define DEC 10
+#define HEX 16
+#define OCT 8
+#ifdef BIN
+#undef BIN
+#endif
+#define BIN 2
+
+class Print;
+
+class Printable
+{
+  public:
+    virtual size_t printTo(Print& p) const = 0;
+};
+
+class Print
+{
+  public:
+    Print() {}
+
+    // 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() { }
+    virtual int availableForWrite() { return 0; }
+
+    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 n;
+      for (n = 0; size && write(*buffer++) && ++n; --size);
+      return n;
+    }
+    size_t write(const char *buffer, size_t size) { return write((const uint8_t *)buffer, size); }
+
+    size_t print(const String &s)             { return write(s.c_str(), s.length()); }
+    size_t print(const char* str)             { return print(String(str)); }
+    size_t print(char c)                      { return print(String(c)); }
+    size_t print(unsigned char b, int base)   { return print(String(b, base)); }
+    size_t print(int n, int base)             { return print(String(n, base)); }
+    size_t print(unsigned int n, int base)    { return print(String(n, base)); }
+    size_t print(long n, int base)            { return print(String(n, base)); }
+    size_t print(unsigned long n, int base)   { return print(String(n, base)); }
+    size_t print(double n, int digits)        { return print(String(n, digits)); }
+    size_t print(const Printable& x)          { return x.printTo(*this); }
+
+    size_t println(void)                        { return print("\r\n"); }
+    size_t println(const String &s)             { return print(s) + println(); }
+    size_t println(const char* c)               { return println(String(c)); }
+    size_t println(char c)                      { return println(String(c)); }
+    size_t println(unsigned char b, int base)   { return println(String(b, base)); }
+    size_t println(int num, int base)           { return println(String(num, base)); }
+    size_t println(unsigned int num, int base)  { return println(String(num, base)); }
+    size_t println(long num, int base)          { return println(String(num, base)); }
+    size_t println(unsigned long num, int base) { return println(String(num, base)); }
+    size_t println(double num, int digits)      { return println(String(num, digits)); }
+    size_t println(const Printable& x)          { return print(x) + println(); }
+
+    virtual void flush() { }
+
+};

data/cpp/arduino/Stream.h

@@ -0,0 +1,210 @@
+#pragma once
+#include "Godmode.h"
+#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.
+enum LookaheadMode{
+    SKIP_ALL,       // All invalid characters are ignored.
+    SKIP_NONE,      // Nothing is skipped, and the stream is not touched unless the first waiting character is valid.
+    SKIP_WHITESPACE // Only tabs, spaces, line feeds & carriage returns are skipped.
+};
+
+#define NO_IGNORE_CHAR  '\x01' // a char not found in a valid ASCII numeric field
+
+class Stream : public Print
+{
+  public:
+    String* mGodmodeDataIn;
+    unsigned long* mGodmodeMicrosDelay;
+
+  protected:
+    unsigned long mTimeoutMillis;
+
+    void fastforward(int pos) {
+      mGodmodeDataIn->assign(mGodmodeDataIn->substring(pos));
+    }
+
+    char fastforwardToAnyChar(LookaheadMode lookahead, String chars) {
+      char c;
+      while ((c = peek()) != -1) {
+        if (chars.find(c) != String::npos) return c;
+        if (lookahead == SKIP_NONE) return -1;
+        if (lookahead == SKIP_WHITESPACE && !isWhitespace(c)) return -1;
+        read();
+      }
+      return -1;
+    }
+
+    // int timedRead();    // read stream with timeout
+    // int timedPeek();    // peek stream with timeout
+    // int peekNextDigit(LookaheadMode lookahead, bool detectDecimal); // returns the next numeric digit in the stream or -1 if timeout
+
+  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) {
+        fastforward(1);
+        if (mGodmodeMicrosDelay) delayMicroseconds(*mGodmodeMicrosDelay);
+      }
+      return ret;
+    }
+
+    virtual size_t write(uint8_t aChar) { mGodmodeDataIn->append(String((char)aChar)); return 1; }
+
+
+    Stream() {
+      mTimeoutMillis = 1000;
+      mGodmodeMicrosDelay = NULL;
+      mGodmodeDataIn = NULL;
+    }
+
+
+    void setTimeout(unsigned long timeoutMillis) { mTimeoutMillis = timeoutMillis; };
+    unsigned long getTimeout(void) { return mTimeoutMillis; }
+
+    bool find(const String &s) {
+      long idx;
+      if ((idx = mGodmodeDataIn->find(s)) != String::npos) {
+        fastforward(idx);
+        return true;
+      }
+      return false;
+    }
+
+    bool find(char *target)                   { return find(String(target)); }
+    bool find(uint8_t *target)                { return find(String((char*)target)); }
+    bool find(char *target, size_t length)    { return find(String(string(target, length))); }
+    bool find(uint8_t *target, size_t length) { return find(String(string((char*)target, length))); }
+    bool find(char target)                    { return find(String(string(&target, 1))); }
+
+    bool findUntil(const String &target, const String &terminator) {
+      long idxTgt = mGodmodeDataIn->find(target);
+      long idxTrm = mGodmodeDataIn->find(terminator);
+      if (idxTgt == String::npos) {
+        mGodmodeDataIn->clear();
+        return false; // didn't find it
+      }
+      if (idxTrm != String::npos || idxTrm < idxTgt) {
+        fastforward(idxTrm);
+        return false;  // target found after term
+      }
+      return find(target);
+    }
+
+    bool findUntil(char *target, char *terminator)    { return findUntil(String(target), String(terminator)); }
+    bool findUntil(uint8_t *target, char *terminator) { return findUntil(String((char *)target), String(terminator)); }
+    bool findUntil(char *target, size_t targetLen, char *terminate, size_t termLen) {
+      return findUntil(String(string(target, targetLen)), String(string(terminate, termLen)));
+    }
+    bool findUntil(uint8_t *target, size_t targetLen, char *terminate, size_t termLen) {
+      return findUntil(String(string((char *)target, targetLen)), String(string(terminate, termLen)));
+    }
+
+    // returns the first valid (long) integer value from the current position.
+    // lookahead determines how parseInt looks ahead in the stream.
+    // See LookaheadMode enumeration at the top of the file.
+    // Lookahead is terminated by the first character that is not a valid part of an integer.
+    // Once parsing commences, 'ignore' will be skipped in the stream.
+    long parseInt(LookaheadMode lookahead = SKIP_ALL, char ignore = NO_IGNORE_CHAR) {
+      String digits = "1234567890";
+      if (fastforwardToAnyChar(lookahead, digits + "-") == -1) return 0;
+      String out = String((char)read()); // read unconditionally -- might be a minus
+      char c;
+      bool keepGoing = true;
+      do {
+        c = peek();
+        if (c == -1) break;
+        if (c != ignore || ignore == NO_IGNORE_CHAR) out += c;
+        keepGoing = digits.find(c) != String::npos;
+        if (!keepGoing) break;
+        read();
+      } while (true);
+      return out.toInt();
+    }
+
+    float parseFloat(LookaheadMode lookahead = SKIP_ALL, char ignore = NO_IGNORE_CHAR) {
+      String digits = "1234567890";
+      if (fastforwardToAnyChar(lookahead, digits + "-") == -1) return 0;
+      String out = String((char)read()); // read unconditionally -- might be a minus
+      String bank = digits + ".";
+      bool gotDot = false;
+      bool keepGoing = true;
+      char c;
+      do {
+        c = peek();
+        if (c == -1) break;
+        if (c == '.') {       // waiting for gotDot
+          if (gotDot) break;
+          gotDot = true;
+        }
+        if (c != ignore || ignore == NO_IGNORE_CHAR) out += c;
+        keepGoing = bank.find(c) != String::npos;
+        if (!keepGoing) break;
+        read();
+      } while (true);
+      return out.toFloat();
+    }
+
+    // read chars from stream into buffer
+    // returns the number of characters placed in the buffer (0 means no valid data found)
+    size_t readBytes(char *buffer, size_t length) {
+      size_t ret = mGodmodeDataIn->copy(buffer, length);
+      if (mGodmodeMicrosDelay) delayMicroseconds(*mGodmodeMicrosDelay * ret);
+      fastforward(ret);
+      return ret;
+    }
+
+    // read chars from stream into buffer
+    // returns the number of characters placed in the buffer (0 means no valid data found)
+    size_t readBytes(uint8_t *buffer, size_t length) { return readBytes((char *)buffer, length); }
+
+    // read chars from stream into buffer
+    // returns the number of characters placed in the buffer (0 means no valid data found)
+    size_t readBytesUntil(char terminator, char *buffer, size_t length) {
+      size_t idx = mGodmodeDataIn->find(terminator);
+      size_t howMuch = idx == String::npos ? length : min(length, idx);
+      return readBytes(buffer, howMuch);
+    }
+
+    // read chars from stream into buffer
+    // returns the number of characters placed in the buffer (0 means no valid data found)
+    size_t readBytesUntil(char terminator, uint8_t *buffer, size_t length) { return readBytesUntil(terminator, (char *)buffer, length); }
+
+    String readStringUntil(char terminator) {
+      long idxTrm = mGodmodeDataIn->find(terminator);
+      String ret;
+      if (idxTrm == String::npos) {
+        ret = String(*mGodmodeDataIn);
+        mGodmodeDataIn->clear();
+      } else {
+        ret = mGodmodeDataIn->substring(0, idxTrm + 1);
+        fastforward(idxTrm + 1);
+      }
+      return ret;
+    }
+
+    String readString() {
+      String ret(*mGodmodeDataIn);
+      mGodmodeDataIn->clear();
+      return ret;
+    }
+
+
+  protected:
+    long parseInt(char ignore) { return parseInt(SKIP_ALL, ignore); }
+    float parseFloat(char ignore) { return parseFloat(SKIP_ALL, ignore); }
+    // These overload exists for compatibility with any class that has derived
+    // Stream and used parseFloat/Int with a custom ignore character. To keep
+    // the public API simple, these overload remains protected.
+
+};
+
+#undef NO_IGNORE_CHAR
+
+