arduino_ci 0.1.20 → 0.4.0

data/cpp/arduino/Arduino.h

@@ -9,13 +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"
-#include "Nullptr.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,26 @@
+#pragma once
+
+#include <Stream.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,38 +1,47 @@
 #include "Godmode.h"
 #include "HardwareSerial.h"
 #include "SPI.h"
-
-GodmodeState godmode = GodmodeState();
+#include "Wire.h"
 
 GodmodeState* GODMODE() {
-  return &godmode;
+  return GodmodeState::getInstance();
+}
+
+GodmodeState* GodmodeState::instance = nullptr;
+
+GodmodeState* GodmodeState::getInstance()
+{
+    if (instance == nullptr)
+    {
+        instance = new GodmodeState();
+        for (int i = 0; i < MOCK_PINS_COUNT; ++i) {
+          instance->digitalPin[i].setMicrosRetriever(&GodmodeState::getMicros);
+          instance->analogPin[i].setMicrosRetriever(&GodmodeState::getMicros);
+        }
+    }
+
+    return instance;
 }
 
 unsigned long millis() {
-  GodmodeState* godmode = GODMODE();
-  return godmode->micros / 1000;
+  return GODMODE()->micros / 1000;
 }
 
 unsigned long micros() {
-  GodmodeState* godmode = GODMODE();
-  return godmode->micros;
+  return GODMODE()->micros;
 }
 
 void delay(unsigned long millis) {
-  GodmodeState* godmode = GODMODE();
-  godmode->micros += millis * 1000;
+  GODMODE()->micros += millis * 1000;
 }
 
 void delayMicroseconds(unsigned long micros) {
-  GodmodeState* godmode = GODMODE();
-  godmode->micros += micros;
+  GODMODE()->micros += micros;
 }
 
-
 void randomSeed(unsigned long seed)
 {
-  GodmodeState* godmode = GODMODE();
-  godmode->seed = seed;
+  GODMODE()->seed = seed;
 }
 
 long random(long vmax)
@@ -81,16 +90,16 @@ void detachInterrupt(uint8_t interrupt) {
 
 // Serial ports
 #if defined(HAVE_HWSERIAL0)
-  HardwareSerial Serial(&godmode.serialPort[0].dataIn, &godmode.serialPort[0].dataOut, &godmode.serialPort[0].readDelayMicros);
+  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);
+  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);
+  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);
+  HardwareSerial Serial3(&GODMODE()->serialPort[3].dataIn, &GODMODE()->serialPort[3].dataOut, &GODMODE()->serialPort[3].readDelayMicros);
 #endif
 
 template <typename T>
@@ -100,4 +109,14 @@ inline std::ostream& operator << ( std::ostream& out, const PinHistory<T>& ph )
 }
 
 // defined in SPI.h
-SPIClass SPI = SPIClass(&godmode.spi.dataIn, &godmode.spi.dataOut);
+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"
 
@@ -16,32 +18,49 @@ void delayMicroseconds(unsigned long micros);
 unsigned long millis();
 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 {
-  struct PortDef {
-    String dataIn;
-    String dataOut;
-    unsigned long readDelayMicros;
-  };
+  private:
+    struct PortDef {
+      String dataIn;
+      String dataOut;
+      unsigned long readDelayMicros;
+    };
 
-  struct InterruptDef {
-    bool attached;
-    uint8_t mode;
-  };
+    struct InterruptDef {
+      bool attached;
+      uint8_t mode;
+    };
+
+    uint8_t mmapPorts[MOCK_PINS_COUNT];
+
+    static GodmodeState* instance;
 
   public:
     unsigned long micros;
@@ -52,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) {
@@ -85,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;
     }
 
@@ -98,8 +134,27 @@ class GodmodeState {
       return NUM_SERIAL_PORTS;
     }
 
-    GodmodeState()
-    {
+    // Using this for anything other than unit testing arduino_ci itself
+    // is unsupported at the moment
+    void overrideClockTruth(unsigned long (*getMicros)(void)) {
+    }
+
+    // singleton pattern
+    static GodmodeState* getInstance();
+
+    static unsigned long getMicros() {
+      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;
+
+  private:
+    GodmodeState() {
       reset();
     }
 };
@@ -121,6 +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();
-