arduino_ci 0.1.3 → 0.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a38212612227d3adec2b30ed2303de39f506f12a31c06b2205ee1e703dccfbb6
-  data.tar.gz: '033169c0b7531d90c089296cf3cd5b708995bb2e89db068813fa515ab0022b17'
+  metadata.gz: b23f7b008729652fa65a7e3ed99bd86e703d847ccb13b56d8483eb557242633c
+  data.tar.gz: bcb9729486d9326e45cb07b8f3c61311f9fd61290460548c0d6130eb7986a521
 SHA512:
-  metadata.gz: 7def94f0fe1d00fc32ccac118766da3cc8272f69b19123eaca24b78592e171b99687cead667c7506acb4e62f7b0445f141ed6ca716053b9d78061d66b5fafd19
-  data.tar.gz: af306adce91faa99e433a8006de72aa0a04a0d5f06e47187672f7d6db07254e6850c374684753e45708ce3e53cee7dd51dfffa17e63c4f58d15a20ee1e72513c
+  metadata.gz: 047e0f22cfc56a8802817ef49f5bac03c6037b755d4d36651661a7bba0a46590765867233f8c8e488cc414180dee89e385745e788036558a1eff04c1216f90cc
+  data.tar.gz: 962d9c99d23d4bb341663cc1a3b222f3272badbcffdf774c7efce449e930fbafc2be3a55d27e1edabc0d09066bf94575e5d19e1d147355fe60bcf7ede38b46e8

data/README.md

@@ -1,6 +1,6 @@
 [![Gem Version](https://badge.fury.io/rb/arduino_ci.svg)](https://rubygems.org/gems/arduino_ci)
 [![Build Status](https://travis-ci.org/ifreecarve/arduino_ci.svg)](https://travis-ci.org/ifreecarve/arduino_ci)
-[![Documentation](http://img.shields.io/badge/docs-rdoc.info-blue.svg)](http://www.rubydoc.info/gems/arduino_ci/0.1.3)
+[![Documentation](http://img.shields.io/badge/docs-rdoc.info-blue.svg)](http://www.rubydoc.info/gems/arduino_ci/0.1.4)
 
 # ArduinoCI Ruby gem (`arduino_ci`)
 
@@ -49,6 +49,82 @@ unittest_main()
 This test defines one `unittest` (a macro provided by `ArduionUnitTests.h`), called `your_test_name`, which makes some assertions on the target library.  The `unittest_main()` is a macro for the `int main()` boilerplate required for unit testing.
 
 
+### Using `GODMODE`
+
+Complete control of the Arduino environment is available in your unit tests through a construct called `GODMODE()`.
+
+```C++
+unittest(example_godmode_stuff)
+{
+  GodmodeState* state = GODMODE();   // get access to the state
+  state->reset();                    // does a full reset of the state.
+  state->resetClock();               //  - you can reset just the clock (to zero)
+  state->resetPins();                //  - or just the pins
+  state->micros = 1;                 // manually set the clock such that micros() returns 1
+  state->digitalPin[4];              // stores the commanded state of digital pin 4
+  state->digitalPin[4] = HIGH;       // digitalRead(4) will now return HIGH
+  state->analogPin[3];               // stores the commanded state of analog pin 3
+  state->analogPin[3] = 99;          // analogRead(3) will now return 99
+}
+```
+
+A more complicated example: working with serial port IO.  Let's say I have the following function:
+
+```C++
+void smartLightswitchSerialHandler(int pin) {
+  if (Serial.available() > 0) {
+    int incomingByte = Serial.read();
+    int val = incomingByte == '0' ? LOW : HIGH;
+    Serial.print("Ack ");
+    digitalWrite(pin, val);
+    Serial.print(String(pin));
+    Serial.print(" ");
+    Serial.print((char)incomingByte);
+  }
+}
+```
+
+This function has 3 side effects: it drains the serial port's receive buffer, affects a pin, and puts data in the serial port's send buffer.  Or, if the receive buffer is empty, it does nothing at all.
+
+```C++
+unittest(does_nothing_if_no_data)
+{
+    // configure initial state
+    GodmodeState* state = GODMODE();
+    int myPin = 3;
+    state->serialPort[0].dataIn = "";
+    state->serialPort[0].dataOut = "";
+    state->digitalPin[myPin] = LOW;
+
+    // execute action
+    smartLightswitchSerialHandler(myPin);
+
+    // assess final state
+    assertEqual(LOW, state->digitalPin[myPin]);
+    assertEqual("", state->serialPort[0].dataIn);
+    assertEqual("", state->serialPort[0].dataOut);
+}
+
+unittest(two_flips)
+{
+    GodmodeState* state = GODMODE();
+    int myPin = 3;
+    state->serialPort[0].dataIn = "10junk";
+    state->serialPort[0].dataOut = "";
+    state->digitalPin[myPin] = LOW;
+    smartLightswitchSerialHandler(myPin);
+    assertEqual(HIGH, state->digitalPin[myPin]);
+    assertEqual("0junk", state->serialPort[0].dataIn);
+    assertEqual("Ack 3 1", state->serialPort[0].dataOut);
+
+    state->serialPort[0].dataOut = "";
+    smartLightswitchSerialHandler(myPin);
+    assertEqual(LOW, state->digitalPin[myPin]);
+    assertEqual("junk", state->serialPort[0].dataIn);
+    assertEqual("Ack 3 0", state->serialPort[0].dataOut);
+}
+```
+
 ## More Documentation
 
 This software is in alpha.  But [SampleProjects/DoSomething](SampleProjects/DoSomething) has a decent writeup and is a good bare-bones example of all the features.

data/cpp/arduino/Arduino.cpp

@@ -1,13 +1,23 @@
 #include "Arduino.h"
+#include "Godmode.h"
 
-struct unit_test_state godmode = {
-  0, // micros
-};
 
-unsigned long millis() {
-  return godmode.micros / 1000;
+void digitalWrite(unsigned char pin, unsigned char val) {
+  GodmodeState* godmode = GODMODE();
+  godmode->digitalPin[pin] = val;
 }
 
-unsigned long micros() {
-  return godmode.micros;
+int digitalRead(unsigned char pin) {
+  GodmodeState* godmode = GODMODE();
+  return godmode->digitalPin[pin];
+}
+
+int analogRead(unsigned char pin) {
+  GodmodeState* godmode = GODMODE();
+  return godmode->analogPin[pin];
+}
+
+void analogWrite(unsigned char pin, int val) {
+  GodmodeState* godmode = GODMODE();
+  godmode->analogPin[pin] = val;
 }

data/cpp/arduino/Arduino.h

@@ -5,15 +5,161 @@ Mock Arduino.h library.
 Where possible, variable names from the Arduino library are used to avoid conflicts
 
 */
+// Chars and strings
 
+#include "ArduinoDefines.h"
 
+#include "WCharacter.h"
+#include "WString.h"
+#include "Print.h"
+#include "Stream.h"
+#include "HardwareSerial.h"
 
+typedef bool boolean;
+typedef uint8_t byte;
+
+#include "binary.h"
+
+// Math and Trig
 #include "AvrMath.h"
 
-struct unit_test_state {
-  unsigned long micros;
-};
+#include "Godmode.h"
+
+
+// Bits and Bytes
+#define bit(b) (1UL << (b))
+#define bitClear(value, bit) ((value) &= ~(1UL << (bit)))
+#define bitRead(value, bit) (((value) >> (bit)) & 0x01)
+#define bitSet(value, bit) ((value) |= (1UL << (bit)))
+#define bitWrite(value, bit, bitvalue) (bitvalue ? bitSet(value, bit) : bitClear(value, bit))
+#define highByte(w) ((uint8_t) ((w) >> 8))
+#define lowByte(w) ((uint8_t) ((w) & 0xff))
+
+// Arduino defines this
+#define _NOP() do { 0; } while (0)
+
+// might as well use that NO-op macro for these, while unit testing
+// you need interrupts? interrupt yourself
+#define yield() _NOP()
+#define interrupts() _NOP()
+#define noInterrupts() _NOP()
+#define attachInterrupt(...) _NOP()
+#define detachInterrupt(...) _NOP()
+
+
+// TODO: correctly establish this per-board!
+#define F_CPU 1000000UL
+#define clockCyclesPerMicrosecond() ( F_CPU / 1000000L )
+#define clockCyclesToMicroseconds(a) ( (a) / clockCyclesPerMicrosecond() )
+#define microsecondsToClockCycles(a) ( (a) * clockCyclesPerMicrosecond() )
+
+typedef unsigned int word;
+
+#define bit(b) (1UL << (b))
+
+// io pins
+#define pinMode(...) _NOP()
+#define analogReference(...) _NOP()
+
+void digitalWrite(uint8_t, uint8_t);
+int digitalRead(uint8_t);
+int analogRead(uint8_t);
+void analogWrite(uint8_t, int);
+#define analogReadResolution(...) _NOP()
+#define analogWriteResolution(...) _NOP()
+
+
+/*
+unsigned long pulseIn(uint8_t pin, uint8_t state, unsigned long timeout);
+unsigned long pulseInLong(uint8_t pin, uint8_t state, unsigned long timeout);
+
+void shiftOut(uint8_t dataPin, uint8_t clockPin, uint8_t bitOrder, uint8_t val);
+uint8_t shiftIn(uint8_t dataPin, uint8_t clockPin, uint8_t bitOrder);
+
+*/
+
+// Get the bit location within the hardware port of the given virtual pin.
+// This comes from the pins_*.c file for the active board configuration.
+
+#define analogInPinToBit(P) (P)
+#define digitalPinToInterrupt(P) (P)
+
+/*
+// On the ATmega1280, the addresses of some of the port registers are
+// greater than 255, so we can't store them in uint8_t's.
+extern const uint16_t PROGMEM port_to_mode_PGM[];
+extern const uint16_t PROGMEM port_to_input_PGM[];
+extern const uint16_t PROGMEM port_to_output_PGM[];
+
+extern const uint8_t PROGMEM digital_pin_to_port_PGM[];
+// extern const uint8_t PROGMEM digital_pin_to_bit_PGM[];
+extern const uint8_t PROGMEM digital_pin_to_bit_mask_PGM[];
+extern const uint8_t PROGMEM digital_pin_to_timer_PGM[];
+
+// Get the bit location within the hardware port of the given virtual pin.
+// This comes from the pins_*.c file for the active board configuration.
+//
+// These perform slightly better as macros compared to inline functions
+//
+#define digitalPinToPort(P) ( pgm_read_byte( digital_pin_to_port_PGM + (P) ) )
+#define digitalPinToBitMask(P) ( pgm_read_byte( digital_pin_to_bit_mask_PGM + (P) ) )
+#define digitalPinToTimer(P) ( pgm_read_byte( digital_pin_to_timer_PGM + (P) ) )
+#define analogInPinToBit(P) (P)
+#define portOutputRegister(P) ( (volatile uint8_t *)( pgm_read_word( port_to_output_PGM + (P))) )
+#define portInputRegister(P) ( (volatile uint8_t *)( pgm_read_word( port_to_input_PGM + (P))) )
+#define portModeRegister(P) ( (volatile uint8_t *)( pgm_read_word( port_to_mode_PGM + (P))) )
+
+*/
+
+
+/* TODO
+#include "WString.h"
+#include "HardwareSerial.h"
+#include "USBAPI.h"
+*/
+
+// uint16_t makeWord(uint16_t w);
+// uint16_t makeWord(byte h, byte l);
+inline unsigned int makeWord(unsigned int w) { return w; }
+inline unsigned int makeWord(unsigned char h, unsigned char l) { return (h << 8) | l; }
+
+#define word(...) makeWord(__VA_ARGS__)
+
+unsigned long pulseIn(uint8_t pin, uint8_t state, unsigned long timeout = 1000000L);
+unsigned long pulseInLong(uint8_t pin, uint8_t state, unsigned long timeout = 1000000L);
+
+void tone(uint8_t _pin, unsigned int frequency, unsigned long duration = 0);
+void noTone(uint8_t _pin);
+
+
+// BIG TODO ON THIS ONE
+// $ find . | grep pins_
+// ./arduino-1.8.5/hardware/arduino/avr/variants/circuitplay32u4/pins_arduino.h
+// ./arduino-1.8.5/hardware/arduino/avr/variants/eightanaloginputs/pins_arduino.h
+// ./arduino-1.8.5/hardware/arduino/avr/variants/ethernet/pins_arduino.h
+// ./arduino-1.8.5/hardware/arduino/avr/variants/gemma/pins_arduino.h
+// ./arduino-1.8.5/hardware/arduino/avr/variants/leonardo/pins_arduino.h
+// ./arduino-1.8.5/hardware/arduino/avr/variants/mega/pins_arduino.h
+// ./arduino-1.8.5/hardware/arduino/avr/variants/micro/pins_arduino.h
+// ./arduino-1.8.5/hardware/arduino/avr/variants/robot_control/pins_arduino.h
+// ./arduino-1.8.5/hardware/arduino/avr/variants/robot_motor/pins_arduino.h
+// ./arduino-1.8.5/hardware/arduino/avr/variants/standard/pins_arduino.h
+// ./arduino-1.8.5/hardware/arduino/avr/variants/yun/pins_arduino.h
+// #include "pins_arduino.h"
+
+
+
+/*
+
+
+// Communication
+serial
+stream
+
+// USB
+Keyboard
+Mouse
+
+*/
 
-unsigned long millis();
 
-unsigned long micros();

data/cpp/arduino/ArduinoDefines.h

@@ -0,0 +1,90 @@
+#pragma once
+
+#define HIGH 0x1
+#define LOW  0x0
+
+#define INPUT 0x0
+#define OUTPUT 0x1
+#define INPUT_PULLUP 0x2
+
+#define PI 3.1415926535897932384626433832795
+#define HALF_PI 1.5707963267948966192313216916398
+#define TWO_PI 6.283185307179586476925286766559
+#define DEG_TO_RAD 0.017453292519943295769236907684886
+#define RAD_TO_DEG 57.295779513082320876798154814105
+#define EULER 2.718281828459045235360287471352
+
+#define SERIAL  0x0
+#define DISPLAY 0x1
+
+#define LSBFIRST 0
+#define MSBFIRST 1
+
+#define CHANGE 1
+#define FALLING 2
+#define RISING 3
+
+#if defined(__AVR_ATtiny24__) || defined(__AVR_ATtiny44__) || defined(__AVR_ATtiny84__)
+  #define DEFAULT 0
+  #define EXTERNAL 1
+  #define INTERNAL1V1 2
+  #define INTERNAL INTERNAL1V1
+#elif defined(__AVR_ATtiny25__) || defined(__AVR_ATtiny45__) || defined(__AVR_ATtiny85__)
+  #define DEFAULT 0
+  #define EXTERNAL 4
+  #define INTERNAL1V1 8
+  #define INTERNAL INTERNAL1V1
+  #define INTERNAL2V56 9
+  #define INTERNAL2V56_EXTCAP 13
+#else
+#if defined(__AVR_ATmega1280__) || defined(__AVR_ATmega2560__) || defined(__AVR_ATmega1284__) || defined(__AVR_ATmega1284P__) || defined(__AVR_ATmega644__) || defined(__AVR_ATmega644A__) || defined(__AVR_ATmega644P__) || defined(__AVR_ATmega644PA__)
+#define INTERNAL1V1 2
+#define INTERNAL2V56 3
+#else
+#define INTERNAL 3
+#endif
+#define DEFAULT 1
+#define EXTERNAL 0
+#endif
+
+#define NOT_A_PIN 0
+#define NOT_A_PORT 0
+
+#define NOT_AN_INTERRUPT -1
+
+#ifdef ARDUINO_MAIN
+#define PA 1
+#define PB 2
+#define PC 3
+#define PD 4
+#define PE 5
+#define PF 6
+#define PG 7
+#define PH 8
+#define PJ 10
+#define PK 11
+#define PL 12
+#endif
+
+#define NOT_ON_TIMER 0
+#define TIMER0A 1
+#define TIMER0B 2
+#define TIMER1A 3
+#define TIMER1B 4
+#define TIMER1C 5
+#define TIMER2  6
+#define TIMER2A 7
+#define TIMER2B 8
+
+#define TIMER3A 9
+#define TIMER3B 10
+#define TIMER3C 11
+#define TIMER4A 12
+#define TIMER4B 13
+#define TIMER4C 14
+#define TIMER4D 15
+#define TIMER5A 16
+#define TIMER5B 17
+#define TIMER5C 18
+
+#include "include/io.h"

data/cpp/arduino/AvrMath.h

@@ -1,37 +1,27 @@
-//#include <math.h>
 #pragma once
+#include <math.h>
 
-template <typename A> inline A abs(A x) { return x > 0 ? x : -x; }
+#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)
 
-//max
-template <typename A> inline float max(A a, float b) { return a > b ? a : b; }
-template <typename A> inline float max(float a, A b) { return a > b ? a : b; }
-template <typename A, typename B> inline long max(A a, B b) { return a > b ? a : b; }
+#ifdef abs
+#undef abs
+#endif
+#define abs(x) ((x)>0?(x):-(x))
 
-//min
-template <typename A> inline float min(A a, float b) { return a < b ? a : b; }
-template <typename A> inline float min(float a, A b) { return a < b ? a : b; }
-template <typename A, typename B> inline long min(A a, B b) { return a < b ? a : b; }
+#ifdef max
+#undef max
+#endif
+#define max(a,b) ((a)>(b)?(a):(b))
 
-//constrain
-template <typename A> inline A constrain(A x, A a, A b)         { return max(a, min(b, x)); }
+#ifdef min
+#undef min
+#endif
+#define min(a,b) ((a)<(b)?(a):(b))
 
-//map
-template <typename A> inline A map(A x, A in_min, A in_max, A out_min, A out_max)
-{
-  return (x - in_min) * (out_max - out_min) / (in_max - in_min) + out_min;
-}
+#define sq(x) ((x)*(x))
 
-//sq
-template <typename A> A inline sq(A x) { return x * x; }
+#define radians(deg) ((deg)*DEG_TO_RAD)
+#define degrees(rad) ((rad)*RAD_TO_DEG)
 
-// ??? too lazy to sort these now
-//pow
-//sqrt
-
-// http://www.ganssle.com/approx.htm
-// http://www.ganssle.com/approx/sincos.cpp
-//cos
-//sin
-//tan