arduino_ci 0.2.0 → 1.1.0

data/cpp/arduino/Arduino.h

@@ -9,12 +9,12 @@ Where possible, variable names from the Arduino library are used to avoid confli
 
 #include "ArduinoDefines.h"
 
+#include "IPAddress.h"
 #include "WCharacter.h"
 #include "WString.h"
 #include "Print.h"
 #include "Stream.h"
 #include "HardwareSerial.h"
-#include "SPI.h"
 
 typedef bool boolean;
 typedef uint8_t byte;

data/cpp/arduino/AvrMath.h

@@ -1,26 +1,126 @@
 #pragma once
+#include "ArduinoDefines.h"
 #include <math.h>
 
-#define constrain(x,l,h) ((x)<(l)?(l):((x)>(h)?(h):(x)))
-#define map(x,inMin,inMax,outMin,outMax) (((x)-(inMin))*((outMax)-(outMin))/((inMax)-(inMin))+outMin)
+#ifdef __cplusplus
 
-#define sq(x) ((x)*(x))
+  template <class Amt, class Low, class High>
+  auto constrain(const Amt &amt, const Low &low, const High &high)
+      -> decltype(amt < low ? low : (amt > high ? high : amt)) {
+    return (amt < low ? low : (amt > high ? high : amt));
+  }
 
-#define radians(deg) ((deg)*DEG_TO_RAD)
-#define degrees(rad) ((rad)*RAD_TO_DEG)
+  template <class X, class InMin, class InMax, class OutMin, class OutMax>
+  auto map(const X &x, const InMin &inMin, const InMax &inMax,
+          const OutMin &outMin, const OutMax &outMax)
+      -> decltype((x - inMin) * (outMax - outMin) / (inMax - inMin) + outMin) {
+    return (x - inMin) * (outMax - outMin) / (inMax - inMin) + outMin;
+  }
 
-#ifdef abs
-#undef abs
-#endif
-#define abs(x) ((x)>0?(x):-(x))
+  template <class T> auto radians(const T &deg) -> decltype(deg * DEG_TO_RAD) {
+    return deg * DEG_TO_RAD;
+  }
 
-#ifdef max
-#undef max
-#endif
-#define max(a,b) ((a)>(b)?(a):(b))
+  template <class T> auto degrees(const T &rad) -> decltype(rad * RAD_TO_DEG) {
+    return rad * RAD_TO_DEG;
+  }
 
-#ifdef min
-#undef min
-#endif
-#define min(a,b) ((a)<(b)?(a):(b))
+  template <class T> auto sq(const T &x) -> decltype(x * x) { return x * x; }
+
+  template <class T> auto abs(const T &x) -> decltype(x > 0 ? x : -x) {
+    return x > 0 ? x : -x;
+  }
+
+  template <class T, class L>
+  auto min(const T &a, const L &b) -> decltype((b < a) ? b : a) {
+    return (b < a) ? b : a;
+  }
+
+  template <class T, class L>
+  auto max(const T &a, const L &b) -> decltype((b < a) ? b : a) {
+    return (a < b) ? b : a;
+  }
+
+#else // __cplusplus
+
+  #ifdef constrain
+  #undef constrain
+  #endif
+  #define constrain(amt, low, high)                                              \
+    ({                                                                           \
+      __typeof__(amt) _amt = (amt);                                              \
+      __typeof__(low) _low = (low);                                              \
+      __typeof__(high) _high = (high);                                           \
+      (amt < low ? low : (amt > high ? high : amt));                             \
+    })
 
+  #ifdef map
+  #undef map
+  #endif
+  #define map(x, inMin, inMax, outMin, outMax)                                   \
+    ({                                                                           \
+      __typeof__(x) _x = (x);                                                    \
+      __typeof__(inMin) _inMin = (inMin);                                        \
+      __typeof__(inMax) _inMax = (inMax);                                        \
+      __typeof__(outMin) _outMin = (outMin);                                     \
+      __typeof__(outMax) _outMax = (outMax);                                     \
+      (_x - _inMin) * (_outMax - _outMin) / (_inMax - _inMin) + _outMin;         \
+    })
+
+  #ifdef radians
+  #undef radians
+  #endif
+  #define radians(deg)                                                           \
+    ({                                                                           \
+      __typeof__(deg) _deg = (deg);                                              \
+      _deg *DEG_TO_RAD;                                                          \
+    })
+
+  #ifdef degrees
+  #undef degrees
+  #endif
+  #define degrees(rad)                                                           \
+    ({                                                                           \
+      __typeof__(rad) _rad = (rad);                                              \
+      _rad *RAD_TO_DEG;                                                          \
+    })
+
+  #ifdef sq
+  #undef sq
+  #endif
+  #define sq(x)                                                                  \
+    ({                                                                           \
+      __typeof__(x) _x = (x);                                                    \
+      _x *_x;                                                                    \
+    })
+
+  #ifdef abs
+  #undef abs
+  #endif
+  #define abs(x)                                                                 \
+    ({                                                                           \
+      __typeof__(x) _x = (x);                                                    \
+      _x > 0 ? _x : -_x;                                                         \
+    })
+
+  #ifdef min
+  #undef min
+  #endif
+  #define min(a, b)                                                              \
+    ({                                                                           \
+      __typeof__(a) _a = (a);                                                    \
+      __typeof__(b) _b = (b);                                                    \
+      _a < _b ? _a : _b;                                                         \
+    })
+
+  #ifdef max
+  #undef max
+  #endif
+  #define max(a, b)                                                              \
+    ({                                                                           \
+      __typeof__(a) _a = (a);                                                    \
+      __typeof__(b) _b = (b);                                                    \
+      _a > _b ? _a : _b;                                                         \
+    })
+
+#endif

data/cpp/arduino/Client.h

@@ -0,0 +1,27 @@
+#pragma once
+
+#include <Stream.h>
+#include <IPAddress.h>
+
+class Client : public Stream {
+public:
+  Client() {
+    // The Stream mock defines a String buffer but never puts anyting in it!
+    if (!mGodmodeDataIn) {
+      mGodmodeDataIn = new String;
+    }
+  }
+  ~Client() {
+    if (mGodmodeDataIn) {
+      delete mGodmodeDataIn;
+      mGodmodeDataIn = nullptr;
+    }
+  }
+  virtual size_t write(uint8_t value) {
+    mGodmodeDataIn->concat(value);
+    return 1;
+  }
+
+protected:
+  uint8_t *rawIPAddress(IPAddress &addr) { return addr.raw_address(); }
+};

data/cpp/arduino/EEPROM.h

@@ -0,0 +1,64 @@
+#pragma once
+
+#include <cassert>
+#include <inttypes.h>
+#include <Godmode.h>
+
+// Does the current board have EEPROM?
+#ifndef EEPROM_SIZE
+  // In lieu of an "EEPROM.h not found" error for unsupported boards
+  #error "EEPROM library not available for your board"
+#endif
+
+class EEPROMClass {
+private:
+  GodmodeState* state;
+public:
+  // constructor
+  EEPROMClass() {
+    state = GODMODE();
+  }
+  // array subscript operator
+  uint8_t &operator[](const int index) {
+    assert(index < EEPROM_SIZE);
+    return state->eeprom[index];
+  }
+
+  uint8_t read(const int index) {
+    assert(index < EEPROM_SIZE);
+    return state->eeprom[index];
+  }
+
+  void write(const int index, const uint8_t value) {
+    assert(index < EEPROM_SIZE);
+    state->eeprom[index] = value;
+  }
+
+  void update(const int index, const uint8_t value) {
+    assert(index < EEPROM_SIZE);
+    state->eeprom[index] = value;
+  }
+
+  uint16_t length() { return EEPROM_SIZE; }
+
+  // read any object
+  template <typename T> T &get(const int index, T &object) {
+    uint8_t *ptr = (uint8_t *)&object;
+    for (int i = 0; i < sizeof(T); ++i) {
+      *ptr++ = read(index + i);
+    }
+    return object;
+  }
+
+  // write any object
+  template <typename T> const T &put(const int index, T &object) {
+    const uint8_t *ptr = (const uint8_t *)&object;
+    for (int i = 0; i < sizeof(T); ++i) {
+      write(index + i, *ptr++);
+    }
+    return object;
+  }
+};
+
+// global available in Godmode.cpp
+extern EEPROMClass EEPROM;

data/cpp/arduino/Godmode.cpp

@@ -1,6 +1,7 @@
 #include "Godmode.h"
 #include "HardwareSerial.h"
 #include "SPI.h"
+#include "Wire.h"
 
 GodmodeState* GODMODE() {
   return GodmodeState::getInstance();
@@ -109,3 +110,13 @@ inline std::ostream& operator << ( std::ostream& out, const PinHistory<T>& ph )
 
 // defined in SPI.h
 SPIClass SPI = SPIClass(&GODMODE()->spi.dataIn, &GODMODE()->spi.dataOut);
+
+// defined in Wire.h
+TwoWire Wire = TwoWire();
+
+#if defined(EEPROM_SIZE)
+  #include <EEPROM.h>
+  EEPROMClass EEPROM;
+#endif
+
+volatile uint8_t __ARDUINO_CI_SFR_MOCK[1024];

data/cpp/arduino/Godmode.h

@@ -1,6 +1,8 @@
 #pragma once
 #include "ArduinoDefines.h"
+#if defined(__AVR__)
 #include <avr/io.h>
+#endif
 #include "WString.h"
 #include "PinHistory.h"
 
@@ -18,16 +20,29 @@ unsigned long micros();
 
 #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
+#if (!defined NUM_SERIAL_PORTS)
+  #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
+#endif
+
+// different EEPROM implementations have different macros that leak out
+#if !defined(EEPROM_SIZE) && defined(E2END) && (E2END)
+  // public value indicates that feature is available
+  #define EEPROM_SIZE (E2END + 1)
+  // local array size
+  #define _EEPROM_SIZE EEPROM_SIZE
 #else
-  #define NUM_SERIAL_PORTS 0
+  // feature is not available but we want to have the array so other code compiles
+  #define _EEPROM_SIZE (0)
 #endif
 
 class GodmodeState {
@@ -43,6 +58,8 @@ class GodmodeState {
       uint8_t mode;
     };
 
+    uint8_t mmapPorts[MOCK_PINS_COUNT];
+
     static GodmodeState* instance;
 
   public:
@@ -54,6 +71,7 @@ class GodmodeState {
     struct PortDef serialPort[NUM_SERIAL_PORTS];
     struct InterruptDef interrupt[MOCK_PINS_COUNT]; // not sure how to get actual number
     struct PortDef spi;
+    uint8_t eeprom[_EEPROM_SIZE];
 
     void resetPins() {
       for (int i = 0; i < MOCK_PINS_COUNT; ++i) {
@@ -87,12 +105,28 @@ class GodmodeState {
       spi.readDelayMicros = 0;
     }
 
+    void resetMmapPorts() {
+      for (int i = 0; i < MOCK_PINS_COUNT; ++i) {
+        mmapPorts[i] = 1;
+      }
+    }
+
+    void resetEEPROM() {
+#if defined(EEPROM_SIZE)
+      for(int i = 0; i < EEPROM_SIZE; ++i) {
+        eeprom[i] = 255;
+      }
+#endif
+    }
+
     void reset() {
       resetClock();
       resetPins();
       resetInterrupts();
       resetPorts();
       resetSPI();
+      resetMmapPorts();
+      resetEEPROM();
       seed = 1;
     }
 
@@ -112,6 +146,9 @@ class GodmodeState {
       return instance->micros;
     }
 
+    uint8_t* pMmapPort(uint8_t port) { return &mmapPorts[port]; }
+    uint8_t mmapPortValue(uint8_t port) { return mmapPorts[port]; }
+
     // C++ 11, declare as public for better compiler error messages
     GodmodeState(GodmodeState const&) = delete;
     void operator=(GodmodeState const&) = delete;
@@ -139,5 +176,17 @@ void detachInterrupt(uint8_t interrupt);
 inline void tone(uint8_t _pin, unsigned int frequency, unsigned long duration = 0) {}
 inline void noTone(uint8_t _pin) {}
 
+// These definitions allow the following to compile (see issue #193):
+// https://github.com/arduino-libraries/Ethernet/blob/master/src/utility/w5100.h:341
+// we allow one byte per port which "wastes" 224 bytes, but makes the code easier
+#if defined(__AVR__)
+  #define digitalPinToBitMask(pin)  (1)
+  #define digitalPinToPort(pin)     (pin)
+  #define portInputRegister(port)   (GODMODE()->pMmapPort(port))
+  #define portOutputRegister(port)  (GODMODE()->pMmapPort(port))
+#else
+  // we don't (yet) support other boards
+#endif
+
 
 GodmodeState* GODMODE();

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