added external lib PJON - not working yet..

10 files changed, 1868 insertions, 64 deletions

diff --git a/defines.mk b/defines.mk
index 1da643e..1791377 100644
--- a/defines.mk
+++ b/defines.mk
@@ -35,6 +35,7 @@ ifeq ($(BOARD_TYPE),teensy2)
   F_USB = $(F_CPU)
   PROG := teensy
   LUFA_BOARD = TEENSY2
+  ARDUINO_BOARD = leonardo
 endif
 ifeq ($(BOARD_TYPE),teensy1pp)
   MCU := at90usb646
@@ -79,6 +80,7 @@ ifeq ($(BOARD_TYPE),hhd70dongle)
   F_USB = $(F_CPU)
   PROG := DFU
   LUFA_BOARD = NONE
+  ARDUINO_BOARD = leonardo
 endif
 ifeq ($(BOARD_TYPE),rda1846dongle)
   MCU := atmega32u4
@@ -87,6 +89,7 @@ ifeq ($(BOARD_TYPE),rda1846dongle)
   F_USB = $(F_CPU)
   PROG := DFU
   LUFA_BOARD = NONE
+  ARDUINO_BOARD = leonardo
 endif
 ifeq ($(BOARD_TYPE),culV3)
   MCU := atmega32u4
@@ -95,6 +98,7 @@ ifeq ($(BOARD_TYPE),culV3)
   F_USB = $(F_CPU)
   PROG := DFU
   LUFA_BOARD = CULV3
+  ARDUINO_BOARD = leonardo
 endif
 ifeq ($(BOARD_TYPE),slowpandongle1)
   MCU := at90usb162
@@ -111,6 +115,7 @@ ifeq ($(BOARD_TYPE),slowpandongle2)
   F_USB = $(F_CPU)
   PROG := DFU
   LUFA_BOARD = NONE
+  ARDUINO_BOARD = leonardo
 endif
 ifeq ($(BOARD_TYPE),teenstep)
   MCU := atmega32u4
@@ -119,6 +124,7 @@ ifeq ($(BOARD_TYPE),teenstep)
   F_USB = $(F_CPU)
   PROG := DFU
   LUFA_BOARD = NONE
+  ARDUINO_BOARD = leonardo
 endif
 ifeq ($(BOARD_TYPE),rhmixxx)
   MCU := at90usb1286
@@ -138,6 +144,7 @@ ifeq ($(BOARD_TYPE),arduinoUno)
   AVRDUDE_PORT := /dev/ttyUSB0
   RESET_FUNC := $(SPREADAVR_PATH)/tools/reset_arduino
   RESET_PARAM = $(AVRDUDE_PORT)
+  ARDUINO_BOARD = standard
 endif
 ifeq ($(BOARD_TYPE),arduinoNano)
   MCU := atmega328p
@@ -149,6 +156,7 @@ ifeq ($(BOARD_TYPE),arduinoNano)
   AVRDUDE_PORT := /dev/ttyUSB0
   RESET_FUNC := $(SPREADAVR_PATH)/tools/reset_arduino
   RESET_PARAM = $(AVRDUDE_PORT)
+  ARDUINO_BOARD = standard
 endif
 ifeq ($(BOARD_TYPE),arduino2009v2)
   MCU := atmega328p
@@ -160,6 +168,7 @@ ifeq ($(BOARD_TYPE),arduino2009v2)
   AVRDUDE_PORT := /dev/ttyUSB0
   RESET_FUNC := $(SPREADAVR_PATH)/tools/reset_arduino
   RESET_PARAM = $(AVRDUDE_PORT)
+  ARDUINO_BOARD = standard
 endif
 ifeq ($(BOARD_TYPE),arduino2009)
   MCU := atmega168
diff --git a/include.mk b/include.mk
index 2fb1418..d467650 100644
--- a/include.mk
+++ b/include.mk
@@ -38,7 +38,7 @@ CXX_OBJ_LIB := $(CXX_LIBS:%=lib-%.o)
 CXX_SRC_LIB := $(CXX_LIBS:%=$(LIB_DIR)/%.cpp)
 CXX_DEP_LIB := $(CXX_LIBS:%=lib-%.d)
 
-.PHONY: prepare clean clean-external distclean clean-lufa clean-fastled program erase flash reset run
+.PHONY: prepare clean clean-external distclean clean-lufa clean-fastled clean-pjon program erase flash reset run
 
 ELFFILE := $(NAME).elf
 HEXFILE := $(NAME).hex
@@ -65,6 +65,16 @@ CXXFLAGS += -DNEED_CXX_BITS
 CXXFLAGS += $(FASTLED_OPTS)
 endif
 
+ifdef PJON_PATH
+CXXFLAGS += -I$(PJON_PATH)
+CXXFLAGS += -DUSES_PJON
+CXXFLAGS += -DARDUINO=101
+ifdef ARDUINO_BOARD
+CXXFLAGS += -DARDUINO_BOARD=$(ARDUINO_BOARD)
+endif
+CXXFLAGS += $(PJON_OPTS)
+endif
+
 prepare: $(EXTERNAL_LIBS:%=build-%)
 clean-external: $(EXTERNAL_LIBS:%=clean-%)
 
@@ -116,6 +126,29 @@ clean-fastled:
 	@echo "****************************************************"
 
 
+build-pjon: libpjon.a
+
+libpjon.a: Makefile
+	@echo ""
+	@echo "****************************************************"
+	@echo "building external PJON lib ($(PJON_PATH))"
+	@echo ""
+	make -f $(SPREADAVR_PATH)/pjon.mk libpjon.a
+	make -f $(SPREADAVR_PATH)/pjon.mk clean
+	@echo ""
+	@echo "****************************************************"
+
+clean-pjon:
+	@echo ""
+	@echo "****************************************************"
+	@echo "cleaning external PJON lib ($(PJON_PATH))"
+	@echo ""
+	make -f $(SPREADAVR_PATH)/pjon.mk clean
+	rm -f libpjon.a
+	@echo ""
+	@echo "****************************************************"
+
+
 ## project-specific objects
 %.d: %.c Makefile
 	@set -e; rm -f $@; \
diff --git a/lib/Arduino.h b/lib/Arduino.h
index 4b3026b..ce50ea8 100644
--- a/lib/Arduino.h
+++ b/lib/Arduino.h
@@ -26,6 +26,7 @@
 #define Arduino_h
 
 #include <stdlib.h>
+#include <stdbool.h>
 #include <string.h>
 #include <math.h>
 
@@ -33,10 +34,14 @@
 #include <avr/io.h>
 #include <avr/interrupt.h>
 
+#include "arduino-binary.h"
+
 #ifdef __cplusplus
 extern "C"{
 #endif
 
+void yield(void);
+
 #define HIGH 0x1
 #define LOW  0x0
 
@@ -44,14 +49,12 @@ extern "C"{
 #define OUTPUT 0x1
 #define INPUT_PULLUP 0x2
 
-#define true 0x1
-#define false 0x0
-
 #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
@@ -107,28 +110,35 @@ extern "C"{
 #define bitClear(value, bit) ((value) &= ~(1UL << (bit)))
 #define bitWrite(value, bit, bitvalue) (bitvalue ? bitSet(value, bit) : bitClear(value, bit))
 
+// avr-libc defines _NOP() since 1.6.2
+#ifndef _NOP
+#define _NOP() do { __asm__ volatile ("nop"); } while (0)
+#endif
 
 typedef unsigned int word;
 
 #define bit(b) (1UL << (b))
 
-typedef uint8_t boolean;
+typedef bool boolean;
 typedef uint8_t byte;
 
 void init(void);
 
+int atexit(void (*func)()) __attribute__((weak));
+
 void pinMode(uint8_t, uint8_t);
 void digitalWrite(uint8_t, uint8_t);
-//int digitalRead(uint8_t);
-//int analogRead(uint8_t);
-//void analogReference(uint8_t mode);
-//void analogWrite(uint8_t, int);
+int digitalRead(uint8_t);
+int analogRead(uint8_t);
+void analogReference(uint8_t mode);
+void analogWrite(uint8_t, int);
 
 unsigned long millis(void);
 unsigned long micros(void);
 void delay(unsigned long);
 void delayMicroseconds(unsigned int us);
 // 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);
@@ -148,7 +158,7 @@ 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_PGM[];
 extern const uint8_t PROGMEM digital_pin_to_bit_mask_PGM[];
 extern const uint8_t PROGMEM digital_pin_to_timer_PGM[];
 
@@ -168,6 +178,8 @@ extern const uint8_t PROGMEM digital_pin_to_timer_PGM[];
 #define NOT_A_PIN 0
 #define NOT_A_PORT 0
 
+#define NOT_AN_INTERRUPT -1
+
 #ifdef ARDUINO_MAIN
 #define PA 1
 #define PB 2
@@ -187,26 +199,44 @@ extern const uint8_t PROGMEM digital_pin_to_timer_PGM[];
 #define TIMER0B 2
 #define TIMER1A 3
 #define TIMER1B 4
-#define TIMER2  5
-#define TIMER2A 6
-#define TIMER2B 7
-
-#define TIMER3A 8
-#define TIMER3B 9
-#define TIMER3C 10
-#define TIMER4A 11
-#define TIMER4B 12
-#define TIMER4C 13
-#define TIMER4D 14
-#define TIMER5A 15
-#define TIMER5B 16
-#define TIMER5C 17
+#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
 
 #ifdef __cplusplus
 } // extern "C"
 #endif
 
-// #include "pins_arduino.h"
+uint16_t makeWord(uint16_t w);
+uint16_t makeWord(byte h, byte l);
+
+#define word(...) makeWord(__VA_ARGS__)
+
+// WMath prototypes
+long random(long);
+long random(long, long);
+void randomSeed(unsigned long);
+long map(long, long, long, long, long);
+
+#if ARDUINO_BOARD == standard
+#include "arduino-pins/standard.h"
+#elif ARDUINO_BOARD == leonardo
+#include "arduino-pins/leonardo.h"
+#endif
+
+// this is from spreadspace utils to run call arduino's init function
 void arduino_init(void);
 
 #endif
diff --git a/lib/arduino-binary.h b/lib/arduino-binary.h
new file mode 100644
index 0000000..aec4c73
--- /dev/null
+++ b/lib/arduino-binary.h
@@ -0,0 +1,534 @@
+/*
+  binary.h - Definitions for binary constants
+  Copyright (c) 2006 David A. Mellis.  All right reserved.
+
+  This library is free software; you can redistribute it and/or
+  modify it under the terms of the GNU Lesser General Public
+  License as published by the Free Software Foundation; either
+  version 2.1 of the License, or (at your option) any later version.
+
+  This library is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  Lesser General Public License for more details.
+
+  You should have received a copy of the GNU Lesser General Public
+  License along with this library; if not, write to the Free Software
+  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+*/
+
+#ifndef Binary_h
+#define Binary_h
+
+#define B0 0
+#define B00 0
+#define B000 0
+#define B0000 0
+#define B00000 0
+#define B000000 0
+#define B0000000 0
+#define B00000000 0
+#define B1 1
+#define B01 1
+#define B001 1
+#define B0001 1
+#define B00001 1
+#define B000001 1
+#define B0000001 1
+#define B00000001 1
+#define B10 2
+#define B010 2
+#define B0010 2
+#define B00010 2
+#define B000010 2
+#define B0000010 2
+#define B00000010 2
+#define B11 3
+#define B011 3
+#define B0011 3
+#define B00011 3
+#define B000011 3
+#define B0000011 3
+#define B00000011 3
+#define B100 4
+#define B0100 4
+#define B00100 4
+#define B000100 4
+#define B0000100 4
+#define B00000100 4
+#define B101 5
+#define B0101 5
+#define B00101 5
+#define B000101 5
+#define B0000101 5
+#define B00000101 5
+#define B110 6
+#define B0110 6
+#define B00110 6
+#define B000110 6
+#define B0000110 6
+#define B00000110 6
+#define B111 7
+#define B0111 7
+#define B00111 7
+#define B000111 7
+#define B0000111 7
+#define B00000111 7
+#define B1000 8
+#define B01000 8
+#define B001000 8
+#define B0001000 8
+#define B00001000 8
+#define B1001 9
+#define B01001 9
+#define B001001 9
+#define B0001001 9
+#define B00001001 9
+#define B1010 10
+#define B01010 10
+#define B001010 10
+#define B0001010 10
+#define B00001010 10
+#define B1011 11
+#define B01011 11
+#define B001011 11
+#define B0001011 11
+#define B00001011 11
+#define B1100 12
+#define B01100 12
+#define B001100 12
+#define B0001100 12
+#define B00001100 12
+#define B1101 13
+#define B01101 13
+#define B001101 13
+#define B0001101 13
+#define B00001101 13
+#define B1110 14
+#define B01110 14
+#define B001110 14
+#define B0001110 14
+#define B00001110 14
+#define B1111 15
+#define B01111 15
+#define B001111 15
+#define B0001111 15
+#define B00001111 15
+#define B10000 16
+#define B010000 16
+#define B0010000 16
+#define B00010000 16
+#define B10001 17
+#define B010001 17
+#define B0010001 17
+#define B00010001 17
+#define B10010 18
+#define B010010 18
+#define B0010010 18
+#define B00010010 18
+#define B10011 19
+#define B010011 19
+#define B0010011 19
+#define B00010011 19
+#define B10100 20
+#define B010100 20
+#define B0010100 20
+#define B00010100 20
+#define B10101 21
+#define B010101 21
+#define B0010101 21
+#define B00010101 21
+#define B10110 22
+#define B010110 22
+#define B0010110 22
+#define B00010110 22
+#define B10111 23
+#define B010111 23
+#define B0010111 23
+#define B00010111 23
+#define B11000 24
+#define B011000 24
+#define B0011000 24
+#define B00011000 24
+#define B11001 25
+#define B011001 25
+#define B0011001 25
+#define B00011001 25
+#define B11010 26
+#define B011010 26
+#define B0011010 26
+#define B00011010 26
+#define B11011 27
+#define B011011 27
+#define B0011011 27
+#define B00011011 27
+#define B11100 28
+#define B011100 28
+#define B0011100 28
+#define B00011100 28
+#define B11101 29
+#define B011101 29
+#define B0011101 29
+#define B00011101 29
+#define B11110 30
+#define B011110 30
+#define B0011110 30
+#define B00011110 30
+#define B11111 31
+#define B011111 31
+#define B0011111 31
+#define B00011111 31
+#define B100000 32
+#define B0100000 32
+#define B00100000 32
+#define B100001 33
+#define B0100001 33
+#define B00100001 33
+#define B100010 34
+#define B0100010 34
+#define B00100010 34
+#define B100011 35
+#define B0100011 35
+#define B00100011 35
+#define B100100 36
+#define B0100100 36
+#define B00100100 36
+#define B100101 37
+#define B0100101 37
+#define B00100101 37
+#define B100110 38
+#define B0100110 38
+#define B00100110 38
+#define B100111 39
+#define B0100111 39
+#define B00100111 39
+#define B101000 40
+#define B0101000 40
+#define B00101000 40
+#define B101001 41
+#define B0101001 41
+#define B00101001 41
+#define B101010 42
+#define B0101010 42
+#define B00101010 42
+#define B101011 43
+#define B0101011 43
+#define B00101011 43
+#define B101100 44
+#define B0101100 44
+#define B00101100 44
+#define B101101 45
+#define B0101101 45
+#define B00101101 45
+#define B101110 46
+#define B0101110 46
+#define B00101110 46
+#define B101111 47
+#define B0101111 47
+#define B00101111 47
+#define B110000 48
+#define B0110000 48
+#define B00110000 48
+#define B110001 49
+#define B0110001 49
+#define B00110001 49
+#define B110010 50
+#define B0110010 50
+#define B00110010 50
+#define B110011 51
+#define B0110011 51
+#define B00110011 51
+#define B110100 52
+#define B0110100 52
+#define B00110100 52
+#define B110101 53
+#define B0110101 53
+#define B00110101 53
+#define B110110 54
+#define B0110110 54
+#define B00110110 54
+#define B110111 55
+#define B0110111 55
+#define B00110111 55
+#define B111000 56
+#define B0111000 56
+#define B00111000 56
+#define B111001 57
+#define B0111001 57
+#define B00111001 57
+#define B111010 58
+#define B0111010 58
+#define B00111010 58
+#define B111011 59
+#define B0111011 59
+#define B00111011 59
+#define B111100 60
+#define B0111100 60
+#define B00111100 60
+#define B111101 61
+#define B0111101 61
+#define B00111101 61
+#define B111110 62
+#define B0111110 62
+#define B00111110 62
+#define B111111 63
+#define B0111111 63
+#define B00111111 63
+#define B1000000 64
+#define B01000000 64
+#define B1000001 65
+#define B01000001 65
+#define B1000010 66
+#define B01000010 66
+#define B1000011 67
+#define B01000011 67
+#define B1000100 68
+#define B01000100 68
+#define B1000101 69
+#define B01000101 69
+#define B1000110 70
+#define B01000110 70
+#define B1000111 71
+#define B01000111 71
+#define B1001000 72
+#define B01001000 72
+#define B1001001 73
+#define B01001001 73
+#define B1001010 74
+#define B01001010 74
+#define B1001011 75
+#define B01001011 75
+#define B1001100 76
+#define B01001100 76
+#define B1001101 77
+#define B01001101 77
+#define B1001110 78
+#define B01001110 78
+#define B1001111 79
+#define B01001111 79
+#define B1010000 80
+#define B01010000 80
+#define B1010001 81
+#define B01010001 81
+#define B1010010 82
+#define B01010010 82
+#define B1010011 83
+#define B01010011 83
+#define B1010100 84
+#define B01010100 84
+#define B1010101 85
+#define B01010101 85
+#define B1010110 86
+#define B01010110 86
+#define B1010111 87
+#define B01010111 87
+#define B1011000 88
+#define B01011000 88
+#define B1011001 89
+#define B01011001 89
+#define B1011010 90
+#define B01011010 90
+#define B1011011 91
+#define B01011011 91
+#define B1011100 92
+#define B01011100 92
+#define B1011101 93
+#define B01011101 93
+#define B1011110 94
+#define B01011110 94
+#define B1011111 95
+#define B01011111 95
+#define B1100000 96
+#define B01100000 96
+#define B1100001 97
+#define B01100001 97
+#define B1100010 98
+#define B01100010 98
+#define B1100011 99
+#define B01100011 99
+#define B1100100 100
+#define B01100100 100
+#define B1100101 101
+#define B01100101 101
+#define B1100110 102
+#define B01100110 102
+#define B1100111 103
+#define B01100111 103
+#define B1101000 104
+#define B01101000 104
+#define B1101001 105
+#define B01101001 105
+#define B1101010 106
+#define B01101010 106
+#define B1101011 107
+#define B01101011 107
+#define B1101100 108
+#define B01101100 108
+#define B1101101 109
+#define B01101101 109
+#define B1101110 110
+#define B01101110 110
+#define B1101111 111
+#define B01101111 111
+#define B1110000 112
+#define B01110000 112
+#define B1110001 113
+#define B01110001 113
+#define B1110010 114
+#define B01110010 114
+#define B1110011 115
+#define B01110011 115
+#define B1110100 116
+#define B01110100 116
+#define B1110101 117
+#define B01110101 117
+#define B1110110 118
+#define B01110110 118
+#define B1110111 119
+#define B01110111 119
+#define B1111000 120
+#define B01111000 120
+#define B1111001 121
+#define B01111001 121
+#define B1111010 122
+#define B01111010 122
+#define B1111011 123
+#define B01111011 123
+#define B1111100 124
+#define B01111100 124
+#define B1111101 125
+#define B01111101 125
+#define B1111110 126
+#define B01111110 126
+#define B1111111 127
+#define B01111111 127
+#define B10000000 128
+#define B10000001 129
+#define B10000010 130
+#define B10000011 131
+#define B10000100 132
+#define B10000101 133
+#define B10000110 134
+#define B10000111 135
+#define B10001000 136
+#define B10001001 137
+#define B10001010 138
+#define B10001011 139
+#define B10001100 140
+#define B10001101 141
+#define B10001110 142
+#define B10001111 143
+#define B10010000 144
+#define B10010001 145
+#define B10010010 146
+#define B10010011 147
+#define B10010100 148
+#define B10010101 149
+#define B10010110 150
+#define B10010111 151
+#define B10011000 152
+#define B10011001 153
+#define B10011010 154
+#define B10011011 155
+#define B10011100 156
+#define B10011101 157
+#define B10011110 158
+#define B10011111 159
+#define B10100000 160
+#define B10100001 161
+#define B10100010 162
+#define B10100011 163
+#define B10100100 164
+#define B10100101 165
+#define B10100110 166
+#define B10100111 167
+#define B10101000 168
+#define B10101001 169
+#define B10101010 170
+#define B10101011 171
+#define B10101100 172
+#define B10101101 173
+#define B10101110 174
+#define B10101111 175
+#define B10110000 176
+#define B10110001 177
+#define B10110010 178
+#define B10110011 179
+#define B10110100 180
+#define B10110101 181
+#define B10110110 182
+#define B10110111 183
+#define B10111000 184
+#define B10111001 185
+#define B10111010 186
+#define B10111011 187
+#define B10111100 188
+#define B10111101 189
+#define B10111110 190
+#define B10111111 191
+#define B11000000 192
+#define B11000001 193
+#define B11000010 194
+#define B11000011 195
+#define B11000100 196
+#define B11000101 197
+#define B11000110 198
+#define B11000111 199
+#define B11001000 200
+#define B11001001 201
+#define B11001010 202
+#define B11001011 203
+#define B11001100 204
+#define B11001101 205
+#define B11001110 206
+#define B11001111 207
+#define B11010000 208
+#define B11010001 209
+#define B11010010 210
+#define B11010011 211
+#define B11010100 212
+#define B11010101 213
+#define B11010110 214
+#define B11010111 215
+#define B11011000 216
+#define B11011001 217
+#define B11011010 218
+#define B11011011 219
+#define B11011100 220
+#define B11011101 221
+#define B11011110 222
+#define B11011111 223
+#define B11100000 224
+#define B11100001 225
+#define B11100010 226
+#define B11100011 227
+#define B11100100 228
+#define B11100101 229
+#define B11100110 230
+#define B11100111 231
+#define B11101000 232
+#define B11101001 233
+#define B11101010 234
+#define B11101011 235
+#define B11101100 236
+#define B11101101 237
+#define B11101110 238
+#define B11101111 239
+#define B11110000 240
+#define B11110001 241
+#define B11110010 242
+#define B11110011 243
+#define B11110100 244
+#define B11110101 245
+#define B11110110 246
+#define B11110111 247
+#define B11111000 248
+#define B11111001 249
+#define B11111010 250
+#define B11111011 251
+#define B11111100 252
+#define B11111101 253
+#define B11111110 254
+#define B11111111 255
+
+#endif
diff --git a/lib/arduino-pins/leonardo.h b/lib/arduino-pins/leonardo.h
new file mode 100644
index 0000000..6027223
--- /dev/null
+++ b/lib/arduino-pins/leonardo.h
@@ -0,0 +1,369 @@
+/*
+  pins_arduino.h - Pin definition functions for Arduino
+  Part of Arduino - http://www.arduino.cc/
+
+  Copyright (c) 2007 David A. Mellis
+
+  This library is free software; you can redistribute it and/or
+  modify it under the terms of the GNU Lesser General Public
+  License as published by the Free Software Foundation; either
+  version 2.1 of the License, or (at your option) any later version.
+
+  This library is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  Lesser General Public License for more details.
+
+  You should have received a copy of the GNU Lesser General
+  Public License along with this library; if not, write to the
+  Free Software Foundation, Inc., 59 Temple Place, Suite 330,
+  Boston, MA  02111-1307  USA
+*/
+
+#ifndef Pins_Arduino_h
+#define Pins_Arduino_h
+
+#include <avr/pgmspace.h>
+
+// Workaround for wrong definitions in "iom32u4.h".
+// This should be fixed in the AVR toolchain.
+#undef UHCON
+#undef UHINT
+#undef UHIEN
+#undef UHADDR
+#undef UHFNUM
+#undef UHFNUML
+#undef UHFNUMH
+#undef UHFLEN
+#undef UPINRQX
+#undef UPINTX
+#undef UPNUM
+#undef UPRST
+#undef UPCONX
+#undef UPCFG0X
+#undef UPCFG1X
+#undef UPSTAX
+#undef UPCFG2X
+#undef UPIENX
+#undef UPDATX
+#undef TCCR2A
+#undef WGM20
+#undef WGM21
+#undef COM2B0
+#undef COM2B1
+#undef COM2A0
+#undef COM2A1
+#undef TCCR2B
+#undef CS20
+#undef CS21
+#undef CS22
+#undef WGM22
+#undef FOC2B
+#undef FOC2A
+#undef TCNT2
+#undef TCNT2_0
+#undef TCNT2_1
+#undef TCNT2_2
+#undef TCNT2_3
+#undef TCNT2_4
+#undef TCNT2_5
+#undef TCNT2_6
+#undef TCNT2_7
+#undef OCR2A
+#undef OCR2_0
+#undef OCR2_1
+#undef OCR2_2
+#undef OCR2_3
+#undef OCR2_4
+#undef OCR2_5
+#undef OCR2_6
+#undef OCR2_7
+#undef OCR2B
+#undef OCR2_0
+#undef OCR2_1
+#undef OCR2_2
+#undef OCR2_3
+#undef OCR2_4
+#undef OCR2_5
+#undef OCR2_6
+#undef OCR2_7
+
+#define NUM_DIGITAL_PINS  31
+#define NUM_ANALOG_INPUTS 12
+
+#define TX_RX_LED_INIT	DDRD |= (1<<5), DDRB |= (1<<0)
+#define TXLED0			PORTD |= (1<<5)
+#define TXLED1			PORTD &= ~(1<<5)
+#define RXLED0			PORTB |= (1<<0)
+#define RXLED1			PORTB &= ~(1<<0)
+
+static const uint8_t SDA = 2;
+static const uint8_t SCL = 3;
+#define LED_BUILTIN 13
+#define LED_BUILTIN_RX 17
+#define LED_BUILTIN_TX 30
+
+// Map SPI port to 'new' pins D14..D17
+static const uint8_t SS   = 17;
+static const uint8_t MOSI = 16;
+static const uint8_t MISO = 14;
+static const uint8_t SCK  = 15;
+
+// Mapping of analog pins as digital I/O
+// A6-A11 share with digital pins
+static const uint8_t A0 = 18;
+static const uint8_t A1 = 19;
+static const uint8_t A2 = 20;
+static const uint8_t A3 = 21;
+static const uint8_t A4 = 22;
+static const uint8_t A5 = 23;
+static const uint8_t A6 = 24;	// D4
+static const uint8_t A7 = 25;	// D6
+static const uint8_t A8 = 26;	// D8
+static const uint8_t A9 = 27;	// D9
+static const uint8_t A10 = 28;	// D10
+static const uint8_t A11 = 29;	// D12
+
+#define digitalPinToPCICR(p)    ((((p) >= 8 && (p) <= 11) || ((p) >= 14 && (p) <= 17) || ((p) >= A8 && (p) <= A10)) ? (&PCICR) : ((uint8_t *)0))
+#define digitalPinToPCICRbit(p) 0
+#define digitalPinToPCMSK(p)    ((((p) >= 8 && (p) <= 11) || ((p) >= 14 && (p) <= 17) || ((p) >= A8 && (p) <= A10)) ? (&PCMSK0) : ((uint8_t *)0))
+#define digitalPinToPCMSKbit(p) ( ((p) >= 8 && (p) <= 11) ? (p) - 4 : ((p) == 14 ? 3 : ((p) == 15 ? 1 : ((p) == 16 ? 2 : ((p) == 17 ? 0 : (p - A8 + 4))))))
+
+//	__AVR_ATmega32U4__ has an unusual mapping of pins to channels
+extern const uint8_t PROGMEM analog_pin_to_channel_PGM[];
+#define analogPinToChannel(P)  ( pgm_read_byte( analog_pin_to_channel_PGM + (P) ) )
+
+#define digitalPinHasPWM(p)         ((p) == 3 || (p) == 5 || (p) == 6 || (p) == 9 || (p) == 10 || (p) == 11 || (p) == 13)
+
+#define digitalPinToInterrupt(p) ((p) == 0 ? 2 : ((p) == 1 ? 3 : ((p) == 2 ? 1 : ((p) == 3 ? 0 : ((p) == 7 ? 4 : NOT_AN_INTERRUPT)))))
+
+#ifdef ARDUINO_MAIN
+
+// On the Arduino board, digital pins are also used
+// for the analog output (software PWM).  Analog input
+// pins are a separate set.
+
+// ATMEL ATMEGA32U4 / ARDUINO LEONARDO
+//
+// D0				PD2					RXD1/INT2
+// D1				PD3					TXD1/INT3
+// D2				PD1		SDA			SDA/INT1
+// D3#				PD0		PWM8/SCL	OC0B/SCL/INT0
+// D4		A6		PD4					ADC8
+// D5#				PC6		???			OC3A/#OC4A
+// D6#		A7		PD7		FastPWM		#OC4D/ADC10
+// D7				PE6					INT6/AIN0
+//
+// D8		A8		PB4					ADC11/PCINT4
+// D9#		A9		PB5		PWM16		OC1A/#OC4B/ADC12/PCINT5
+// D10#		A10		PB6		PWM16		OC1B/0c4B/ADC13/PCINT6
+// D11#				PB7		PWM8/16		0C0A/OC1C/#RTS/PCINT7
+// D12		A11		PD6					T1/#OC4D/ADC9
+// D13#				PC7		PWM10		CLK0/OC4A
+//
+// A0		D18		PF7					ADC7
+// A1		D19		PF6					ADC6
+// A2		D20 	PF5					ADC5
+// A3		D21 	PF4					ADC4
+// A4		D22		PF1					ADC1
+// A5		D23 	PF0					ADC0
+//
+// New pins D14..D17 to map SPI port to digital pins
+//
+// MISO		D14		PB3					MISO,PCINT3
+// SCK		D15		PB1					SCK,PCINT1
+// MOSI		D16		PB2					MOSI,PCINT2
+// SS		D17		PB0					RXLED,SS/PCINT0
+//
+// TXLED	D30		PD5					XCK1
+// RXLED	D17	    PB0
+// HWB				PE2					HWB
+
+// these arrays map port names (e.g. port B) to the
+// appropriate addresses for various functions (e.g. reading
+// and writing)
+const uint16_t PROGMEM port_to_mode_PGM[] = {
+	NOT_A_PORT,
+	NOT_A_PORT,
+	(uint16_t) &DDRB,
+	(uint16_t) &DDRC,
+	(uint16_t) &DDRD,
+	(uint16_t) &DDRE,
+	(uint16_t) &DDRF,
+};
+
+const uint16_t PROGMEM port_to_output_PGM[] = {
+	NOT_A_PORT,
+	NOT_A_PORT,
+	(uint16_t) &PORTB,
+	(uint16_t) &PORTC,
+	(uint16_t) &PORTD,
+	(uint16_t) &PORTE,
+	(uint16_t) &PORTF,
+};
+
+const uint16_t PROGMEM port_to_input_PGM[] = {
+	NOT_A_PORT,
+	NOT_A_PORT,
+	(uint16_t) &PINB,
+	(uint16_t) &PINC,
+	(uint16_t) &PIND,
+	(uint16_t) &PINE,
+	(uint16_t) &PINF,
+};
+
+const uint8_t PROGMEM digital_pin_to_port_PGM[] = {
+	PD, // D0 - PD2
+	PD,	// D1 - PD3
+	PD, // D2 - PD1
+	PD,	// D3 - PD0
+	PD,	// D4 - PD4
+	PC, // D5 - PC6
+	PD, // D6 - PD7
+	PE, // D7 - PE6
+	
+	PB, // D8 - PB4
+	PB,	// D9 - PB5
+	PB, // D10 - PB6
+	PB,	// D11 - PB7
+	PD, // D12 - PD6
+	PC, // D13 - PC7
+	
+	PB,	// D14 - MISO - PB3
+	PB,	// D15 - SCK - PB1
+	PB,	// D16 - MOSI - PB2
+	PB,	// D17 - SS - PB0
+	
+	PF,	// D18 - A0 - PF7
+	PF, // D19 - A1 - PF6
+	PF, // D20 - A2 - PF5
+	PF, // D21 - A3 - PF4
+	PF, // D22 - A4 - PF1
+	PF, // D23 - A5 - PF0
+	
+	PD, // D24 / D4 - A6 - PD4
+	PD, // D25 / D6 - A7 - PD7
+	PB, // D26 / D8 - A8 - PB4
+	PB, // D27 / D9 - A9 - PB5
+	PB, // D28 / D10 - A10 - PB6
+	PD, // D29 / D12 - A11 - PD6
+	PD, // D30 / TX Led - PD5
+};
+
+const uint8_t PROGMEM digital_pin_to_bit_mask_PGM[] = {
+	_BV(2), // D0 - PD2
+	_BV(3),	// D1 - PD3
+	_BV(1), // D2 - PD1
+	_BV(0),	// D3 - PD0
+	_BV(4),	// D4 - PD4
+	_BV(6), // D5 - PC6
+	_BV(7), // D6 - PD7
+	_BV(6), // D7 - PE6
+	
+	_BV(4), // D8 - PB4
+	_BV(5),	// D9 - PB5
+	_BV(6), // D10 - PB6
+	_BV(7),	// D11 - PB7
+	_BV(6), // D12 - PD6
+	_BV(7), // D13 - PC7
+	
+	_BV(3),	// D14 - MISO - PB3
+	_BV(1),	// D15 - SCK - PB1
+	_BV(2),	// D16 - MOSI - PB2
+	_BV(0),	// D17 - SS - PB0
+	
+	_BV(7),	// D18 - A0 - PF7
+	_BV(6), // D19 - A1 - PF6
+	_BV(5), // D20 - A2 - PF5
+	_BV(4), // D21 - A3 - PF4
+	_BV(1), // D22 - A4 - PF1
+	_BV(0), // D23 - A5 - PF0
+	
+	_BV(4), // D24 / D4 - A6 - PD4
+	_BV(7), // D25 / D6 - A7 - PD7
+	_BV(4), // D26 / D8 - A8 - PB4
+	_BV(5), // D27 / D9 - A9 - PB5
+	_BV(6), // D28 / D10 - A10 - PB6
+	_BV(6), // D29 / D12 - A11 - PD6
+	_BV(5), // D30 / TX Led - PD5
+};
+
+const uint8_t PROGMEM digital_pin_to_timer_PGM[] = {
+	NOT_ON_TIMER,	
+	NOT_ON_TIMER,
+	NOT_ON_TIMER,
+	TIMER0B,		/* 3 */
+	NOT_ON_TIMER,
+	TIMER3A,		/* 5 */
+	TIMER4D,		/* 6 */
+	NOT_ON_TIMER,	
+	
+	NOT_ON_TIMER,	
+	TIMER1A,		/* 9 */
+	TIMER1B,		/* 10 */
+	TIMER0A,		/* 11 */
+	
+	NOT_ON_TIMER,	
+	TIMER4A,		/* 13 */
+	
+	NOT_ON_TIMER,	
+	NOT_ON_TIMER,
+	NOT_ON_TIMER,
+	NOT_ON_TIMER,
+	NOT_ON_TIMER,
+	NOT_ON_TIMER,
+
+	NOT_ON_TIMER,
+	NOT_ON_TIMER,
+	NOT_ON_TIMER,
+	NOT_ON_TIMER,
+	NOT_ON_TIMER,
+	NOT_ON_TIMER,
+	NOT_ON_TIMER,
+	NOT_ON_TIMER,
+	NOT_ON_TIMER,
+	NOT_ON_TIMER,
+	NOT_ON_TIMER,
+};
+
+const uint8_t PROGMEM analog_pin_to_channel_PGM[] = {
+	7,	// A0				PF7					ADC7
+	6,	// A1				PF6					ADC6	
+	5,	// A2				PF5					ADC5	
+	4,	// A3				PF4					ADC4
+	1,	// A4				PF1					ADC1	
+	0,	// A5				PF0					ADC0	
+	8,	// A6		D4		PD4					ADC8
+	10,	// A7		D6		PD7					ADC10
+	11,	// A8		D8		PB4					ADC11
+	12,	// A9		D9		PB5					ADC12
+	13,	// A10		D10		PB6					ADC13
+	9	// A11		D12		PD6					ADC9
+};
+
+#endif /* ARDUINO_MAIN */
+
+// These serial port names are intended to allow libraries and architecture-neutral
+// sketches to automatically default to the correct port name for a particular type
+// of use.  For example, a GPS module would normally connect to SERIAL_PORT_HARDWARE_OPEN,
+// the first hardware serial port whose RX/TX pins are not dedicated to another use.
+//
+// SERIAL_PORT_MONITOR        Port which normally prints to the Arduino Serial Monitor
+//
+// SERIAL_PORT_USBVIRTUAL     Port which is USB virtual serial
+//
+// SERIAL_PORT_LINUXBRIDGE    Port which connects to a Linux system via Bridge library
+//
+// SERIAL_PORT_HARDWARE       Hardware serial port, physical RX & TX pins.
+//
+// SERIAL_PORT_HARDWARE_OPEN  Hardware serial ports which are open for use.  Their RX & TX
+//                            pins are NOT connected to anything by default.
+#define SERIAL_PORT_MONITOR        Serial
+#define SERIAL_PORT_USBVIRTUAL     Serial
+#define SERIAL_PORT_HARDWARE       Serial1
+#define SERIAL_PORT_HARDWARE_OPEN  Serial1
+
+// Alias SerialUSB to Serial
+#define SerialUSB SERIAL_PORT_USBVIRTUAL
+
+#endif /* Pins_Arduino_h */
diff --git a/lib/arduino-pins/standard.h b/lib/arduino-pins/standard.h
new file mode 100644
index 0000000..a3f349e
--- /dev/null
+++ b/lib/arduino-pins/standard.h
@@ -0,0 +1,236 @@
+/*
+  pins_arduino.h - Pin definition functions for Arduino
+  Part of Arduino - http://www.arduino.cc/
+
+  Copyright (c) 2007 David A. Mellis
+
+  This library is free software; you can redistribute it and/or
+  modify it under the terms of the GNU Lesser General Public
+  License as published by the Free Software Foundation; either
+  version 2.1 of the License, or (at your option) any later version.
+
+  This library is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  Lesser General Public License for more details.
+
+  You should have received a copy of the GNU Lesser General
+  Public License along with this library; if not, write to the
+  Free Software Foundation, Inc., 59 Temple Place, Suite 330,
+  Boston, MA  02111-1307  USA
+*/
+
+#ifndef Pins_Arduino_h
+#define Pins_Arduino_h
+
+#include <avr/pgmspace.h>
+
+#define NUM_DIGITAL_PINS            20
+#define NUM_ANALOG_INPUTS           6
+#define analogInputToDigitalPin(p)  ((p < 6) ? (p) + 14 : -1)
+
+#if defined(__AVR_ATmega8__)
+#define digitalPinHasPWM(p)         ((p) == 9 || (p) == 10 || (p) == 11)
+#else
+#define digitalPinHasPWM(p)         ((p) == 3 || (p) == 5 || (p) == 6 || (p) == 9 || (p) == 10 || (p) == 11)
+#endif
+
+static const uint8_t SS   = 10;
+static const uint8_t MOSI = 11;
+static const uint8_t MISO = 12;
+static const uint8_t SCK  = 13;
+
+static const uint8_t SDA = 18;
+static const uint8_t SCL = 19;
+#define LED_BUILTIN 13
+
+static const uint8_t A0 = 14;
+static const uint8_t A1 = 15;
+static const uint8_t A2 = 16;
+static const uint8_t A3 = 17;
+static const uint8_t A4 = 18;
+static const uint8_t A5 = 19;
+static const uint8_t A6 = 20;
+static const uint8_t A7 = 21;
+
+#define digitalPinToPCICR(p)    (((p) >= 0 && (p) <= 21) ? (&PCICR) : ((uint8_t *)0))
+#define digitalPinToPCICRbit(p) (((p) <= 7) ? 2 : (((p) <= 13) ? 0 : 1))
+#define digitalPinToPCMSK(p)    (((p) <= 7) ? (&PCMSK2) : (((p) <= 13) ? (&PCMSK0) : (((p) <= 21) ? (&PCMSK1) : ((uint8_t *)0))))
+#define digitalPinToPCMSKbit(p) (((p) <= 7) ? (p) : (((p) <= 13) ? ((p) - 8) : ((p) - 14)))
+
+#define digitalPinToInterrupt(p)  ((p) == 2 ? 0 : ((p) == 3 ? 1 : NOT_AN_INTERRUPT))
+
+#ifdef ARDUINO_MAIN
+
+// On the Arduino board, digital pins are also used
+// for the analog output (software PWM).  Analog input
+// pins are a separate set.
+
+// ATMEL ATMEGA8 & 168 / ARDUINO
+//
+//                  +-\/-+
+//            PC6  1|    |28  PC5 (AI 5)
+//      (D 0) PD0  2|    |27  PC4 (AI 4)
+//      (D 1) PD1  3|    |26  PC3 (AI 3)
+//      (D 2) PD2  4|    |25  PC2 (AI 2)
+// PWM+ (D 3) PD3  5|    |24  PC1 (AI 1)
+//      (D 4) PD4  6|    |23  PC0 (AI 0)
+//            VCC  7|    |22  GND
+//            GND  8|    |21  AREF
+//            PB6  9|    |20  AVCC
+//            PB7 10|    |19  PB5 (D 13)
+// PWM+ (D 5) PD5 11|    |18  PB4 (D 12)
+// PWM+ (D 6) PD6 12|    |17  PB3 (D 11) PWM
+//      (D 7) PD7 13|    |16  PB2 (D 10) PWM
+//      (D 8) PB0 14|    |15  PB1 (D 9) PWM
+//                  +----+
+//
+// (PWM+ indicates the additional PWM pins on the ATmega168.)
+
+// ATMEL ATMEGA1280 / ARDUINO
+//
+// 0-7 PE0-PE7   works
+// 8-13 PB0-PB5  works
+// 14-21 PA0-PA7 works 
+// 22-29 PH0-PH7 works
+// 30-35 PG5-PG0 works
+// 36-43 PC7-PC0 works
+// 44-51 PJ7-PJ0 works
+// 52-59 PL7-PL0 works
+// 60-67 PD7-PD0 works
+// A0-A7 PF0-PF7
+// A8-A15 PK0-PK7
+
+
+// these arrays map port names (e.g. port B) to the
+// appropriate addresses for various functions (e.g. reading
+// and writing)
+const uint16_t PROGMEM port_to_mode_PGM[] = {
+	NOT_A_PORT,
+	NOT_A_PORT,
+	(uint16_t) &DDRB,
+	(uint16_t) &DDRC,
+	(uint16_t) &DDRD,
+};
+
+const uint16_t PROGMEM port_to_output_PGM[] = {
+	NOT_A_PORT,
+	NOT_A_PORT,
+	(uint16_t) &PORTB,
+	(uint16_t) &PORTC,
+	(uint16_t) &PORTD,
+};
+
+const uint16_t PROGMEM port_to_input_PGM[] = {
+	NOT_A_PORT,
+	NOT_A_PORT,
+	(uint16_t) &PINB,
+	(uint16_t) &PINC,
+	(uint16_t) &PIND,
+};
+
+const uint8_t PROGMEM digital_pin_to_port_PGM[] = {
+	PD, /* 0 */
+	PD,
+	PD,
+	PD,
+	PD,
+	PD,
+	PD,
+	PD,
+	PB, /* 8 */
+	PB,
+	PB,
+	PB,
+	PB,
+	PB,
+	PC, /* 14 */
+	PC,
+	PC,
+	PC,
+	PC,
+	PC,
+};
+
+const uint8_t PROGMEM digital_pin_to_bit_mask_PGM[] = {
+	_BV(0), /* 0, port D */
+	_BV(1),
+	_BV(2),
+	_BV(3),
+	_BV(4),
+	_BV(5),
+	_BV(6),
+	_BV(7),
+	_BV(0), /* 8, port B */
+	_BV(1),
+	_BV(2),
+	_BV(3),
+	_BV(4),
+	_BV(5),
+	_BV(0), /* 14, port C */
+	_BV(1),
+	_BV(2),
+	_BV(3),
+	_BV(4),
+	_BV(5),
+};
+
+const uint8_t PROGMEM digital_pin_to_timer_PGM[] = {
+	NOT_ON_TIMER, /* 0 - port D */
+	NOT_ON_TIMER,
+	NOT_ON_TIMER,
+	// on the ATmega168, digital pin 3 has hardware pwm
+#if defined(__AVR_ATmega8__)
+	NOT_ON_TIMER,
+#else
+	TIMER2B,
+#endif
+	NOT_ON_TIMER,
+	// on the ATmega168, digital pins 5 and 6 have hardware pwm
+#if defined(__AVR_ATmega8__)
+	NOT_ON_TIMER,
+	NOT_ON_TIMER,
+#else
+	TIMER0B,
+	TIMER0A,
+#endif
+	NOT_ON_TIMER,
+	NOT_ON_TIMER, /* 8 - port B */
+	TIMER1A,
+	TIMER1B,
+#if defined(__AVR_ATmega8__)
+	TIMER2,
+#else
+	TIMER2A,
+#endif
+	NOT_ON_TIMER,
+	NOT_ON_TIMER,
+	NOT_ON_TIMER,
+	NOT_ON_TIMER, /* 14 - port C */
+	NOT_ON_TIMER,
+	NOT_ON_TIMER,
+	NOT_ON_TIMER,
+	NOT_ON_TIMER,
+};
+
+#endif
+
+// These serial port names are intended to allow libraries and architecture-neutral
+// sketches to automatically default to the correct port name for a particular type
+// of use.  For example, a GPS module would normally connect to SERIAL_PORT_HARDWARE_OPEN,
+// the first hardware serial port whose RX/TX pins are not dedicated to another use.
+//
+// SERIAL_PORT_MONITOR        Port which normally prints to the Arduino Serial Monitor
+//
+// SERIAL_PORT_USBVIRTUAL     Port which is USB virtual serial
+//
+// SERIAL_PORT_LINUXBRIDGE    Port which connects to a Linux system via Bridge library
+//
+// SERIAL_PORT_HARDWARE       Hardware serial port, physical RX & TX pins.
+//
+// SERIAL_PORT_HARDWARE_OPEN  Hardware serial ports which are open for use.  Their RX & TX
+//                            pins are NOT connected to anything by default.
+#define SERIAL_PORT_MONITOR   Serial
+#define SERIAL_PORT_HARDWARE  Serial
+
+#endif
diff --git a/lib/arduino-stub.cpp b/lib/arduino-stub.cpp
index 237074c..b98946d 100644
--- a/lib/arduino-stub.cpp
+++ b/lib/arduino-stub.cpp
@@ -20,10 +20,13 @@
  *  along with spreadspace avr utils. If not, see <http://www.gnu.org/licenses/>.
  */
 
+#define ARDUINO_MAIN
 #include "Arduino.h"
 
+int atexit(void (* /*func*/ )()) { return 0; }
 
 extern "C" {
+#include "stdlib.h"
 
 #ifndef cbi
 #define cbi(sfr, bit) (_SFR_BYTE(sfr) &= ~_BV(bit))
@@ -52,11 +55,8 @@ extern "C" {
   Public License along with this library; if not, write to the
   Free Software Foundation, Inc., 59 Temple Place, Suite 330,
   Boston, MA  02111-1307  USA
-
-  $Id$
 */
 
-//#include "wiring_private.h"
 
 // the prescaler is set so that timer0 ticks every 64 clock cycles, and the
 // the overflow handler is called every 256 ticks.
@@ -132,7 +132,6 @@ unsigned long micros() {
   #error TIMER 0 not defined
 #endif
 
-
 #ifdef TIFR0
   if ((TIFR0 & _BV(TOV0)) && (t < 255))
     m++;
@@ -148,75 +147,128 @@ unsigned long micros() {
 
 void delay(unsigned long ms)
 {
-  uint16_t start = (uint16_t)micros();
+  uint32_t start = micros();
 
   while (ms > 0) {
-    if (((uint16_t)micros() - start) >= 1000) {
+    yield();
+    while ( ms > 0 && (micros() - start) >= 1000) {
       ms--;
       start += 1000;
     }
   }
 }
 
-/* Delay for the given number of microseconds.  Assumes a 8 or 16 MHz clock. */
+/* Delay for the given number of microseconds.  Assumes a 1, 8, 12, 16, 20 or 24 MHz clock. */
 void delayMicroseconds(unsigned int us)
 {
+  // call = 4 cycles + 2 to 4 cycles to init us(2 for constant delay, 4 for variable)
+
   // calling avrlib's delay_us() function with low values (e.g. 1 or
   // 2 microseconds) gives delays longer than desired.
   //delay_us(us);
-#if F_CPU >= 20000000L
+#if F_CPU >= 24000000L
+  // for the 24 MHz clock for the aventurous ones, trying to overclock
+
+  // zero delay fix
+  if (!us) return; //  = 3 cycles, (4 when true)
+
+  // the following loop takes a 1/6 of a microsecond (4 cycles)
+  // per iteration, so execute it six times for each microsecond of
+  // delay requested.
+  us *= 6; // x6 us, = 7 cycles
+
+  // account for the time taken in the preceeding commands.
+  // we just burned 22 (24) cycles above, remove 5, (5*4=20)
+  // us is at least 6 so we can substract 5
+  us -= 5; //=2 cycles
+
+#elif F_CPU >= 20000000L
   // for the 20 MHz clock on rare Arduino boards
 
-  // for a one-microsecond delay, simply wait 2 cycle and return. The overhead
-  // of the function call yields a delay of exactly a one microsecond.
+  // for a one-microsecond delay, simply return.  the overhead
+  // of the function call takes 18 (20) cycles, which is 1us
   __asm__ __volatile__ (
     "nop" "\n\t"
-    "nop"); //just waiting 2 cycle
-  if (--us == 0)
-    return;
+    "nop" "\n\t"
+    "nop" "\n\t"
+    "nop"); //just waiting 4 cycles
+  if (us <= 1) return; //  = 3 cycles, (4 when true)
 
   // the following loop takes a 1/5 of a microsecond (4 cycles)
   // per iteration, so execute it five times for each microsecond of
   // delay requested.
-  us = (us<<2) + us; // x5 us
+  us = (us << 2) + us; // x5 us, = 7 cycles
 
   // account for the time taken in the preceeding commands.
-  us -= 2;
+  // we just burned 26 (28) cycles above, remove 7, (7*4=28)
+  // us is at least 10 so we can substract 7
+  us -= 7; // 2 cycles
 
 #elif F_CPU >= 16000000L
   // for the 16 MHz clock on most Arduino boards
 
   // for a one-microsecond delay, simply return.  the overhead
-  // of the function call yields a delay of approximately 1 1/8 us.
-  if (--us == 0)
-    return;
+  // of the function call takes 14 (16) cycles, which is 1us
+  if (us <= 1) return; //  = 3 cycles, (4 when true)
 
-  // the following loop takes a quarter of a microsecond (4 cycles)
+  // the following loop takes 1/4 of a microsecond (4 cycles)
   // per iteration, so execute it four times for each microsecond of
   // delay requested.
-  us <<= 2;
+  us <<= 2; // x4 us, = 4 cycles
 
   // account for the time taken in the preceeding commands.
-  us -= 2;
-#else
-  // for the 8 MHz internal clock on the ATmega168
+  // we just burned 19 (21) cycles above, remove 5, (5*4=20)
+  // us is at least 8 so we can substract 5
+  us -= 5; // = 2 cycles,
+
+#elif F_CPU >= 12000000L
+  // for the 12 MHz clock if somebody is working with USB
 
-  // for a one- or two-microsecond delay, simply return.  the overhead of
-  // the function calls takes more than two microseconds.  can't just
-  // subtract two, since us is unsigned; we'd overflow.
-  if (--us == 0)
-    return;
-  if (--us == 0)
-    return;
+  // for a 1 microsecond delay, simply return.  the overhead
+  // of the function call takes 14 (16) cycles, which is 1.5us
+  if (us <= 1) return; //  = 3 cycles, (4 when true)
 
-  // the following loop takes half of a microsecond (4 cycles)
+  // the following loop takes 1/3 of a microsecond (4 cycles)
+  // per iteration, so execute it three times for each microsecond of
+  // delay requested.
+  us = (us << 1) + us; // x3 us, = 5 cycles
+
+  // account for the time taken in the preceeding commands.
+  // we just burned 20 (22) cycles above, remove 5, (5*4=20)
+  // us is at least 6 so we can substract 5
+  us -= 5; //2 cycles
+
+#elif F_CPU >= 8000000L
+  // for the 8 MHz internal clock
+
+  // for a 1 and 2 microsecond delay, simply return.  the overhead
+  // of the function call takes 14 (16) cycles, which is 2us
+  if (us <= 2) return; //  = 3 cycles, (4 when true)
+
+  // the following loop takes 1/2 of a microsecond (4 cycles)
   // per iteration, so execute it twice for each microsecond of
   // delay requested.
-  us <<= 1;
+  us <<= 1; //x2 us, = 2 cycles
+
+  // account for the time taken in the preceeding commands.
+  // we just burned 17 (19) cycles above, remove 4, (4*4=16)
+  // us is at least 6 so we can substract 4
+  us -= 4; // = 2 cycles
+
+#else
+  // for the 1 MHz internal clock (default settings for common Atmega microcontrollers)
+
+  // the overhead of the function calls is 14 (16) cycles
+  if (us <= 16) return; //= 3 cycles, (4 when true)
+  if (us <= 25) return; //= 3 cycles, (4 when true), (must be at least 25 if we want to substract 22)
+
+  // compensate for the time taken by the preceeding and next commands (about 22 cycles)
+  us -= 22; // = 2 cycles
+  // the following loop takes 4 microseconds (4 cycles)
+  // per iteration, so execute it us/4 times
+  // us is at least 4, divided by 4 gives us 1 (no zero delay bug)
+  us >>= 2; // us div 4, = 4 cycles
 
-  // partially compensate for the time taken by the preceeding commands.
-  // we can't subtract any more than this or we'd overflow w/ small delays.
-  us--;
 #endif
 
   // busy wait
@@ -224,6 +276,7 @@ void delayMicroseconds(unsigned int us)
     "1: sbiw %0,1" "\n\t" // 2 cycles
     "brne 1b" : "=w" (us) : "0" (us) // 2 cycles
   );
+  // return = 4 cycles
 }
 
 void init()
@@ -264,8 +317,21 @@ void init()
 #else
   #error	Timer 0 overflow interrupt not set correctly
 #endif
+}
 
+/**
+ * Empty yield() hook.
+ *
+ * This function is intended to be used by library writers to build
+ * libraries or sketches that supports cooperative threads.
+ *
+ * Its defined as a weak symbol and it can be redefined to implement a
+ * real cooperative scheduler.
+ */
+static void __empty() {
+	// Empty
 }
+void yield(void) __attribute__ ((weak, alias("__empty")));
 
 } // extern "C"
 
@@ -273,3 +339,461 @@ void arduino_init(void)
 {
   init();
 }
+
+// ******************
+// this is from Arduino's wiring_digital.cpp
+
+void pinMode(uint8_t pin, uint8_t mode)
+{
+  uint8_t bit = digitalPinToBitMask(pin);
+  uint8_t port = digitalPinToPort(pin);
+  volatile uint8_t *reg, *out;
+
+  if (port == NOT_A_PIN) return;
+
+  // JWS: can I let the optimizer do this?
+  reg = portModeRegister(port);
+  out = portOutputRegister(port);
+
+  if (mode == INPUT) {
+    uint8_t oldSREG = SREG;
+                cli();
+    *reg &= ~bit;
+    *out &= ~bit;
+    SREG = oldSREG;
+  } else if (mode == INPUT_PULLUP) {
+    uint8_t oldSREG = SREG;
+                cli();
+    *reg &= ~bit;
+    *out |= bit;
+    SREG = oldSREG;
+  } else {
+    uint8_t oldSREG = SREG;
+                cli();
+    *reg |= bit;
+    SREG = oldSREG;
+  }
+}
+
+// Forcing this inline keeps the callers from having to push their own stuff
+// on the stack. It is a good performance win and only takes 1 more byte per
+// user than calling. (It will take more bytes on the 168.)
+//
+// But shouldn't this be moved into pinMode? Seems silly to check and do on
+// each digitalread or write.
+//
+// Mark Sproul:
+// - Removed inline. Save 170 bytes on atmega1280
+// - changed to a switch statment; added 32 bytes but much easier to read and maintain.
+// - Added more #ifdefs, now compiles for atmega645
+//
+//static inline void turnOffPWM(uint8_t timer) __attribute__ ((always_inline));
+//static inline void turnOffPWM(uint8_t timer)
+static void turnOffPWM(uint8_t timer)
+{
+  switch (timer)
+  {
+    #if defined(TCCR1A) && defined(COM1A1)
+    case TIMER1A:   cbi(TCCR1A, COM1A1);    break;
+    #endif
+    #if defined(TCCR1A) && defined(COM1B1)
+    case TIMER1B:   cbi(TCCR1A, COM1B1);    break;
+    #endif
+    #if defined(TCCR1A) && defined(COM1C1)
+    case TIMER1C:   cbi(TCCR1A, COM1C1);    break;
+    #endif
+
+    #if defined(TCCR2) && defined(COM21)
+    case  TIMER2:   cbi(TCCR2, COM21);      break;
+    #endif
+
+    #if defined(TCCR0A) && defined(COM0A1)
+    case  TIMER0A:  cbi(TCCR0A, COM0A1);    break;
+    #endif
+
+    #if defined(TCCR0A) && defined(COM0B1)
+    case  TIMER0B:  cbi(TCCR0A, COM0B1);    break;
+    #endif
+    #if defined(TCCR2A) && defined(COM2A1)
+    case  TIMER2A:  cbi(TCCR2A, COM2A1);    break;
+    #endif
+    #if defined(TCCR2A) && defined(COM2B1)
+    case  TIMER2B:  cbi(TCCR2A, COM2B1);    break;
+    #endif
+
+    #if defined(TCCR3A) && defined(COM3A1)
+    case  TIMER3A:  cbi(TCCR3A, COM3A1);    break;
+    #endif
+    #if defined(TCCR3A) && defined(COM3B1)
+    case  TIMER3B:  cbi(TCCR3A, COM3B1);    break;
+    #endif
+    #if defined(TCCR3A) && defined(COM3C1)
+    case  TIMER3C:  cbi(TCCR3A, COM3C1);    break;
+    #endif
+
+    #if defined(TCCR4A) && defined(COM4A1)
+    case  TIMER4A:  cbi(TCCR4A, COM4A1);    break;
+    #endif
+    #if defined(TCCR4A) && defined(COM4B1)
+    case  TIMER4B:  cbi(TCCR4A, COM4B1);    break;
+    #endif
+    #if defined(TCCR4A) && defined(COM4C1)
+    case  TIMER4C:  cbi(TCCR4A, COM4C1);    break;
+    #endif
+    #if defined(TCCR4C) && defined(COM4D1)
+    case TIMER4D:	cbi(TCCR4C, COM4D1);	break;
+    #endif
+
+    #if defined(TCCR5A)
+    case  TIMER5A:  cbi(TCCR5A, COM5A1);    break;
+    case  TIMER5B:  cbi(TCCR5A, COM5B1);    break;
+    case  TIMER5C:  cbi(TCCR5A, COM5C1);    break;
+    #endif
+  }
+}
+
+void digitalWrite(uint8_t pin, uint8_t val)
+{
+  uint8_t timer = digitalPinToTimer(pin);
+  uint8_t bit = digitalPinToBitMask(pin);
+  uint8_t port = digitalPinToPort(pin);
+  volatile uint8_t *out;
+
+  if (port == NOT_A_PIN) return;
+
+  // If the pin that support PWM output, we need to turn it off
+  // before doing a digital write.
+  if (timer != NOT_ON_TIMER) turnOffPWM(timer);
+
+  out = portOutputRegister(port);
+
+  uint8_t oldSREG = SREG;
+  cli();
+
+  if (val == LOW) {
+    *out &= ~bit;
+  } else {
+    *out |= bit;
+  }
+
+  SREG = oldSREG;
+}
+
+int digitalRead(uint8_t pin)
+{
+  uint8_t timer = digitalPinToTimer(pin);
+  uint8_t bit = digitalPinToBitMask(pin);
+  uint8_t port = digitalPinToPort(pin);
+
+  if (port == NOT_A_PIN) return LOW;
+
+  // If the pin that support PWM output, we need to turn it off
+  // before getting a digital reading.
+  if (timer != NOT_ON_TIMER) turnOffPWM(timer);
+
+  if (*portInputRegister(port) & bit) return HIGH;
+  return LOW;
+}
+
+// ******************
+// this is from Arduino's wiring_analog.cpp
+
+uint8_t analog_reference = DEFAULT;
+
+void analogReference(uint8_t mode)
+{
+  // can't actually set the register here because the default setting
+  // will connect AVCC and the AREF pin, which would cause a short if
+  // there's something connected to AREF.
+  analog_reference = mode;
+}
+
+int analogRead(uint8_t pin)
+{
+  uint8_t low, high;
+
+#if defined(analogPinToChannel)
+#if defined(__AVR_ATmega32U4__)
+  if (pin >= 18) pin -= 18; // allow for channel or pin numbers
+#endif
+  pin = analogPinToChannel(pin);
+#elif defined(__AVR_ATmega1280__) || defined(__AVR_ATmega2560__)
+  if (pin >= 54) pin -= 54; // allow for channel or pin numbers
+#elif defined(__AVR_ATmega32U4__)
+  if (pin >= 18) pin -= 18; // allow for channel or pin numbers
+#elif defined(__AVR_ATmega1284__) || defined(__AVR_ATmega1284P__) || defined(__AVR_ATmega644__) || defined(__AVR_ATmega644A__) || defined(__AVR_ATmega644P__) || defined(__AVR_ATmega644PA__)
+  if (pin >= 24) pin -= 24; // allow for channel or pin numbers
+#else
+  if (pin >= 14) pin -= 14; // allow for channel or pin numbers
+#endif
+
+#if defined(ADCSRB) && defined(MUX5)
+  // the MUX5 bit of ADCSRB selects whether we're reading from channels
+  // 0 to 7 (MUX5 low) or 8 to 15 (MUX5 high).
+  ADCSRB = (ADCSRB & ~(1 << MUX5)) | (((pin >> 3) & 0x01) << MUX5);
+#endif
+
+  // set the analog reference (high two bits of ADMUX) and select the
+  // channel (low 4 bits).  this also sets ADLAR (left-adjust result)
+  // to 0 (the default).
+#if defined(ADMUX)
+  ADMUX = (analog_reference << 6) | (pin & 0x07);
+#endif
+
+  // without a delay, we seem to read from the wrong channel
+  //delay(1);
+
+#if defined(ADCSRA) && defined(ADCL)
+  // start the conversion
+  sbi(ADCSRA, ADSC);
+
+  // ADSC is cleared when the conversion finishes
+  while (bit_is_set(ADCSRA, ADSC));
+
+  // we have to read ADCL first; doing so locks both ADCL
+  // and ADCH until ADCH is read.  reading ADCL second would
+  // cause the results of each conversion to be discarded,
+  // as ADCL and ADCH would be locked when it completed.
+  low  = ADCL;
+  high = ADCH;
+#else
+  // we dont have an ADC, return 0
+  low  = 0;
+  high = 0;
+#endif
+
+  // combine the two bytes
+  return (high << 8) | low;
+}
+
+// Right now, PWM output only works on the pins with
+// hardware support.  These are defined in the appropriate
+// pins_*.c file.  For the rest of the pins, we default
+// to digital output.
+void analogWrite(uint8_t pin, int val)
+{
+  // We need to make sure the PWM output is enabled for those pins
+  // that support it, as we turn it off when digitally reading or
+  // writing with them.  Also, make sure the pin is in output mode
+  // for consistenty with Wiring, which doesn't require a pinMode
+  // call for the analog output pins.
+  pinMode(pin, OUTPUT);
+  if (val == 0)
+  {
+    digitalWrite(pin, LOW);
+  }
+  else if (val == 255)
+  {
+    digitalWrite(pin, HIGH);
+  }
+  else
+  {
+    switch(digitalPinToTimer(pin))
+    {
+      // XXX fix needed for atmega8
+      #if defined(TCCR0) && defined(COM00) && !defined(__AVR_ATmega8__)
+      case TIMER0A:
+        // connect pwm to pin on timer 0
+        sbi(TCCR0, COM00);
+        OCR0 = val; // set pwm duty
+        break;
+      #endif
+
+      #if defined(TCCR0A) && defined(COM0A1)
+      case TIMER0A:
+        // connect pwm to pin on timer 0, channel A
+        sbi(TCCR0A, COM0A1);
+        OCR0A = val; // set pwm duty
+        break;
+      #endif
+
+      #if defined(TCCR0A) && defined(COM0B1)
+      case TIMER0B:
+        // connect pwm to pin on timer 0, channel B
+        sbi(TCCR0A, COM0B1);
+        OCR0B = val; // set pwm duty
+        break;
+      #endif
+
+      #if defined(TCCR1A) && defined(COM1A1)
+      case TIMER1A:
+        // connect pwm to pin on timer 1, channel A
+        sbi(TCCR1A, COM1A1);
+        OCR1A = val; // set pwm duty
+        break;
+      #endif
+
+      #if defined(TCCR1A) && defined(COM1B1)
+      case TIMER1B:
+        // connect pwm to pin on timer 1, channel B
+        sbi(TCCR1A, COM1B1);
+        OCR1B = val; // set pwm duty
+        break;
+      #endif
+
+      #if defined(TCCR1A) && defined(COM1C1)
+      case TIMER1C:
+        // connect pwm to pin on timer 1, channel B
+        sbi(TCCR1A, COM1C1);
+        OCR1C = val; // set pwm duty
+        break;
+      #endif
+
+      #if defined(TCCR2) && defined(COM21)
+      case TIMER2:
+        // connect pwm to pin on timer 2
+        sbi(TCCR2, COM21);
+        OCR2 = val; // set pwm duty
+        break;
+      #endif
+
+      #if defined(TCCR2A) && defined(COM2A1)
+      case TIMER2A:
+        // connect pwm to pin on timer 2, channel A
+        sbi(TCCR2A, COM2A1);
+        OCR2A = val; // set pwm duty
+        break;
+      #endif
+
+      #if defined(TCCR2A) && defined(COM2B1)
+      case TIMER2B:
+        // connect pwm to pin on timer 2, channel B
+        sbi(TCCR2A, COM2B1);
+        OCR2B = val; // set pwm duty
+        break;
+      #endif
+
+      #if defined(TCCR3A) && defined(COM3A1)
+      case TIMER3A:
+        // connect pwm to pin on timer 3, channel A
+        sbi(TCCR3A, COM3A1);
+        OCR3A = val; // set pwm duty
+        break;
+      #endif
+
+      #if defined(TCCR3A) && defined(COM3B1)
+      case TIMER3B:
+        // connect pwm to pin on timer 3, channel B
+        sbi(TCCR3A, COM3B1);
+        OCR3B = val; // set pwm duty
+        break;
+      #endif
+
+      #if defined(TCCR3A) && defined(COM3C1)
+      case TIMER3C:
+        // connect pwm to pin on timer 3, channel C
+        sbi(TCCR3A, COM3C1);
+        OCR3C = val; // set pwm duty
+        break;
+      #endif
+
+      #if defined(TCCR4A)
+      case TIMER4A:
+        //connect pwm to pin on timer 4, channel A
+        sbi(TCCR4A, COM4A1);
+        #if defined(COM4A0)		// only used on 32U4
+        cbi(TCCR4A, COM4A0);
+        #endif
+        OCR4A = val;	// set pwm duty
+        break;
+      #endif
+
+      #if defined(TCCR4A) && defined(COM4B1)
+      case TIMER4B:
+        // connect pwm to pin on timer 4, channel B
+        sbi(TCCR4A, COM4B1);
+        OCR4B = val; // set pwm duty
+        break;
+      #endif
+
+      #if defined(TCCR4A) && defined(COM4C1)
+      case TIMER4C:
+        // connect pwm to pin on timer 4, channel C
+        sbi(TCCR4A, COM4C1);
+        OCR4C = val; // set pwm duty
+        break;
+      #endif
+
+      #if defined(TCCR4C) && defined(COM4D1)
+      case TIMER4D:
+        // connect pwm to pin on timer 4, channel D
+        sbi(TCCR4C, COM4D1);
+        #if defined(COM4D0)		// only used on 32U4
+        cbi(TCCR4C, COM4D0);
+        #endif
+        OCR4D = val;	// set pwm duty
+        break;
+      #endif
+
+
+      #if defined(TCCR5A) && defined(COM5A1)
+      case TIMER5A:
+        // connect pwm to pin on timer 5, channel A
+        sbi(TCCR5A, COM5A1);
+        OCR5A = val; // set pwm duty
+        break;
+      #endif
+
+      #if defined(TCCR5A) && defined(COM5B1)
+      case TIMER5B:
+        // connect pwm to pin on timer 5, channel B
+        sbi(TCCR5A, COM5B1);
+        OCR5B = val; // set pwm duty
+        break;
+      #endif
+
+      #if defined(TCCR5A) && defined(COM5C1)
+      case TIMER5C:
+        // connect pwm to pin on timer 5, channel C
+        sbi(TCCR5A, COM5C1);
+        OCR5C = val; // set pwm duty
+        break;
+      #endif
+
+      case NOT_ON_TIMER:
+      default:
+        if (val < 128) {
+          digitalWrite(pin, LOW);
+        } else {
+          digitalWrite(pin, HIGH);
+        }
+    }
+  }
+}
+
+// ******************
+// this is from Arduino's WMath.cpp
+
+void randomSeed(unsigned long seed)
+{
+  if (seed != 0) {
+    srandom(seed);
+  }
+}
+
+long random(long howbig)
+{
+  if (howbig == 0) {
+    return 0;
+  }
+  return random() % howbig;
+}
+
+long random(long howsmall, long howbig)
+{
+  if (howsmall >= howbig) {
+    return howsmall;
+  }
+  long diff = howbig - howsmall;
+  return random(diff) + howsmall;
+}
+
+long map(long x, long in_min, long in_max, long out_min, long out_max)
+{
+  return (x - in_min) * (out_max - out_min) / (in_max - in_min) + out_min;
+}
+
+unsigned int makeWord(unsigned int w) { return w; }
+unsigned int makeWord(unsigned char h, unsigned char l) { return (h << 8) | l; }
+
+// end WMath.cpp
diff --git a/pjon.mk b/pjon.mk
new file mode 100644
index 0000000..d3c9be0
--- /dev/null
+++ b/pjon.mk
@@ -0,0 +1,43 @@
+##
+##  spreadspace avr utils
+##
+##
+##  Copyright (C) 2013-2015 Christian Pointner <equinox@spreadspace.org>
+##
+##  This file is part of spreadspace avr utils.
+##
+##  spreadspace avr utils is free software: you can redistribute it and/or modify
+##  it under the terms of the GNU General Public License as published by
+##  the Free Software Foundation, either version 3 of the License, or
+##  any later version.
+##
+##  spreadspace avr utils is distributed in the hope that it will be useful,
+##  but WITHOUT ANY WARRANTY; without even the implied warranty of
+##  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+##  GNU General Public License for more details.
+##
+##  You should have received a copy of the GNU General Public License
+##  along with spreadspace avr utils. If not, see <http://www.gnu.org/licenses/>.
+##
+
+include $(SPREADAVR_PATH)/defines.mk
+
+SRC:=$(wildcard $(PJON_PATH)/*.cpp)
+
+CXXFLAGS += -I$(PJON_PATH)
+CXXFLAGS += -DARDUINO=101
+CXXFLAGS += $(PJON_OPTS)
+ifdef ARDUINO_BOARD
+CXXFLAGS += -DARDUINO_BOARD=$(ARDUINO_BOARD)
+endif
+
+OBJ = $(SRC:%.cpp=%.o)
+
+libpjon.a: $(OBJ)
+	$(AR) $@ $(OBJ)
+
+%.o: %.cpp
+	$(CXX) -c $(CXXFLAGS) $< -o $@
+
+clean:
+	rm -f $(SRC:%.cpp=%.o)
diff --git a/usb-pjon/Makefile b/usb-pjon/Makefile
index 2848646..e9aecc2 100644
--- a/usb-pjon/Makefile
+++ b/usb-pjon/Makefile
@@ -21,12 +21,11 @@
 ##
 
 NAME := usb-pjon
-BOARD_TYPE := minimus32
+BOARD_TYPE := teensy2
 CXX_OBJ := $(NAME).o
 LIBS := util led lufa-descriptor-usbserial usbio
 CXX_LIBS := arduino-stub
-EXTERNAL_LIBS := lufa
-#EXTERNAL_LIBS := lufa pjon
+EXTERNAL_LIBS := lufa pjon
 SPREADAVR_PATH := ..
 
 PJON_PATH := $(SPREADAVR_PATH)/contrib/PJON
diff --git a/usb-pjon/usb-pjon.cpp b/usb-pjon/usb-pjon.cpp
index eb4e7f8..66d58e1 100644
--- a/usb-pjon/usb-pjon.cpp
+++ b/usb-pjon/usb-pjon.cpp
@@ -31,14 +31,36 @@
 #include "usbio.h"
 
 #include "Arduino.h"
-//#include "PJON.h"
+#include "PJON.h"
 
+PJON bus(5, 45); // Bus connection to pin 12, device id 45
+
+void error_handler(uint8_t code, uint8_t data) {
+  if(code == CONNECTION_LOST) {
+    printf("Connection with device ID %d is lost.\r\n", data);
+  }
+  if(code == PACKETS_BUFFER_FULL) {
+    printf("Packet buffer is full, has now a length of %d\r\n", data);
+    printf("Possible wrong bus configuration!\r\n");
+    printf("higher MAX_PACKETS in PJON.h if necessary.\r\n");
+  }
+  if(code == MEMORY_FULL) {
+    printf("Packet memory allocation failed. Memory is full.\r\n");
+  }
+  if(code == CONTENT_TOO_LONG) {
+    printf("Content is too long, length: %d\r\n", data);
+  }
+  if(code == ID_ACQUISITION_FAIL) {
+    printf("Can't acquire a free id %d\r\n", data);
+  }
+}
 
 void handle_cmd(uint8_t cmd)
 {
   switch(cmd) {
   case '0': led_off(); break;
   case '1': led_on(); break;
+  case 's': bus.send(44, "hello", 5); break;
   case '!': reset2bootloader(); break;
   default: printf("error\r\n"); return;
   }
@@ -55,6 +77,10 @@ int main(void)
   usbio_init();
   sei();
 
+  arduino_init();
+  bus.begin();
+  bus.set_error(error_handler);
+
   for(;;) {
     int16_t BytesReceived = usbio_bytes_received();
     while(BytesReceived > 0) {
@@ -66,5 +92,6 @@ int main(void)
     }
 
     usbio_task();
+    bus.update();
   }
 }