arduino_ci 0.3.0 → 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 "Wire.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

@@ -113,3 +113,10 @@ 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

@@ -44,19 +44,19 @@ class HardwareSerial : public StreamTape
     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

data/cpp/arduino/IPAddress.h

@@ -0,0 +1,59 @@
+#pragma once
+
+#include <stdint.h>
+
+class IPAddress {
+private:
+  union {
+    uint8_t bytes[4];
+    uint32_t dword;
+    operator uint8_t *() const { return (uint8_t *)bytes; }
+  } _address;
+
+public:
+  // Constructors
+  IPAddress() : IPAddress(0, 0, 0, 0) {}
+  IPAddress(uint8_t octet1, uint8_t octet2, uint8_t octet3, uint8_t octet4) {
+    _address.bytes[0] = octet1;
+    _address.bytes[1] = octet2;
+    _address.bytes[2] = octet3;
+    _address.bytes[3] = octet4;
+  }
+  IPAddress(uint32_t dword) { _address.dword = dword; }
+  IPAddress(const uint8_t bytes[]) {
+    _address.bytes[0] = bytes[0];
+    _address.bytes[1] = bytes[1];
+    _address.bytes[2] = bytes[2];
+    _address.bytes[3] = bytes[3];
+  }
+  IPAddress(unsigned long dword) { _address.dword = (uint32_t)dword; }
+
+  // Accessors
+  uint32_t asWord() const { return _address.dword; }
+  uint8_t *raw_address() { return _address.bytes; }
+
+  // Comparisons
+  bool operator==(const IPAddress &rhs) const {
+    return _address.dword == rhs.asWord();
+  }
+
+  bool operator!=(const IPAddress &rhs) const {
+    return _address.dword != rhs.asWord();
+  }
+
+  // Indexing
+  uint8_t operator[](int index) const { return _address.bytes[index]; }
+  uint8_t &operator[](int index) { return _address.bytes[index]; }
+
+  // Conversions
+  operator uint32_t() const { return _address.dword; };
+
+  friend class EthernetClass;
+  friend class UDP;
+  friend class Client;
+  friend class Server;
+  friend class DhcpClass;
+  friend class DNSClient;
+};
+
+const IPAddress INADDR_NONE(0, 0, 0, 0);