migrate code to AS7, including fucked up arduino import

arduino as a library will not build with -flto. I can't figure it out. so we
waste some space compared to what platformio was building. oh well. there's
still over 1K of space left for programs.

fw/HackSpaceCon_AS7/Arduino/megatinycore/api/ArduinoAPI.h

@@ -0,0 +1,54 @@
+/*
+  Arduino API main include
+  Copyright (c) 2016 Arduino LLC. 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 ARDUINO_API_H
+#define ARDUINO_API_H
+
+// version 1.0.0
+#define ARDUINO_API_VERSION 10000
+
+#include "Binary.h"
+
+#ifdef __cplusplus
+  #include "Client.h"
+  #include "HardwareI2C.h"
+  #include "HardwareSerial.h"
+  #include "IPAddress.h"
+  #include "Print.h"
+  #include "Printable.h"
+  #include "PluggableUSB.h"
+  #include "Server.h"
+  #include "String.h"
+  #include "Stream.h"
+  #include "Udp.h"
+  #include "USBAPI.h"
+  #include "WCharacter.h"
+#endif
+
+/* Standard C library includes */
+#include <stdlib.h>
+#include <stdint.h>
+#include <stdbool.h>
+#include <string.h>
+#include <math.h>
+
+// Misc Arduino core functions
+#include "Common.h"
+
+#endif

fw/HackSpaceCon_AS7/Arduino/megatinycore/api/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

fw/HackSpaceCon_AS7/Arduino/megatinycore/api/Client.h

@@ -0,0 +1,44 @@
+/*
+  Client.h - Base class that provides Client
+  Copyright (c) 2011 Adrian McEwen.  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
+*/
+
+#pragma once
+
+#include "Stream.h"
+#include "IPAddress.h"
+
+class Client : public Stream {
+
+  public:
+    virtual int connect(IPAddress ip, uint16_t port) = 0;
+    virtual int connect(const char *host, uint16_t port) = 0;
+    virtual size_t write(uint8_t) = 0;
+    virtual size_t write(const uint8_t *buf, size_t size) = 0;
+    virtual int available() = 0;
+    virtual int read() = 0;
+    virtual int read(uint8_t *buf, size_t size) = 0;
+    virtual int peek() = 0;
+    virtual void flush() = 0;
+    virtual void stop() = 0;
+    virtual uint8_t connected() = 0;
+    virtual operator bool() = 0;
+  protected:
+    uint8_t *rawIPAddress(IPAddress &addr) {
+      return addr.raw_address();
+    };
+};

fw/HackSpaceCon_AS7/Arduino/megatinycore/api/Common.cpp

@@ -0,0 +1,13 @@
+#include "Common.h"
+
+/* C++ prototypes */
+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;
+}
+
+uint16_t makeWord(uint16_t w) {
+  return w;
+}
+uint16_t makeWord(uint8_t h, uint8_t l) {
+  return (h << 8) | l;
+}

fw/HackSpaceCon_AS7/Arduino/megatinycore/api/Common.h

@@ -0,0 +1,195 @@
+#include <stdint.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void yield(void);
+
+#define LOW              0    /* used for digitalWrite(), digitalRead(), openDrain() and attachInterrupt() */
+#define HIGH             1    /* used for digitalWrite(), digitalRead(). There is no option for HIGH level interrupt provided by the hardware */
+#define FLOATING         HIGH /* Not in official API - used for openDrain, while making clear what you're doing */
+#define CHANGE           4    /* used for attachInterrupt() */
+#define FALLING          2    /* used for attachInterrupt() */
+#define RISING           3    /* used for attachInterrupt() */
+#define INPUT            0    /* used for pinMode() */
+#define OUTPUT           1    /* used for pinMode() */
+#define INPUT_PULLUP     2    /* used for pinMode() */
+#define LSBFIRST         0    /* used for shiftIn/shiftOut */
+#define MSBFIRST         1    /* used for shiftIn/shiftOut */
+
+
+#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        0x00
+#define DISPLAY       0x01
+
+#define min(a,b) \
+  ({ __typeof__ (a) _a = (a); \
+    __typeof__ (b) _b = (b); \
+    _a < _b ? _a : _b; })
+
+#define max(a,b) \
+  ({ __typeof__ (a) _a = (a); \
+    __typeof__ (b) _b = (b); \
+    _a > _b ? _a : _b; })
+
+#ifndef constrain
+#define constrain(x,low,high)   ({  \
+  __typeof__ (x)    _x = (x);           \
+  __typeof__ (low)  _l = (low);         \
+  __typeof__ (high) _h = (high);        \
+  _x < _l ? _l : _x > _h ? _h :_x ;})
+#endif
+
+#ifndef radians
+#define radians(deg) ((deg)*DEG_TO_RAD)
+#endif
+
+#ifndef degrees
+#define degrees(rad) ((rad)*RAD_TO_DEG)
+#endif
+
+#ifndef sq
+#define sq(x)        ({ __typeof__ (x) _x = (x); _x * _x; })
+#endif
+
+
+/* This is sorta silly. But normal round() builtin is bulkier and returns a float while arduino code written for other platforms will expect
+integer types... This also has the same concerns about sideffects as before - except they're less likely to show up when
+starting from a float. Who does meFloat++? Certainly not as many as do constrain(myInt++,minval,maxval);
+*/
+
+#ifndef round
+#define round(x)     ({ __typeof__ (x) _x = (x);  _x >= 0 ? (long)(_x + 0.5) : (long)(_x - 0.5 );})
+#endif
+
+/* In the end, it is probably better to do this manually rather than using round(). Why?
+
+* If you know the value you're starting with is positive, you can skip the first test and just add 0.5 and cast to integer type - saves space.
+* You can use the minimum size datatypes (wthis casts things to 4-byte values. Maybe the thing your rounding is, say -50.0 to 50.0 you can cast to a single byte for more compact code
+* You can choose which of the rounding strategies you wish to use. Because there are not less than TEN DIFFERENT STRATEGIES TO ROUND NUMBERS
+* Any of these approaches will result in smaller code:
+* For example, rounding a number you know ought to fit a 16 bit unsigned datatype easily, you might do:
+* uint16_t roundedval = (uint16_t) (floatval + 0.5)
+*
+* Even better, avoid using floats in the first place. Why are you using them? sometimes you really don't have much of a choice, other times
+* you very definitely do. This is particularly true with ADC readings, for example say you're using to 4.096 Volt reference, and you
+* want to measure and print out a voltage.
+uint32_t reading = analogReadEnh(adc_pin, 12);  //where adc_pin is just the pin number being read
+float temp = reading;
+Serial.print(temp/1000); // 4.096v reference, and 12 bit accuracy (ie, 0-4095). So each LSB is 1 mv so dividing by 1000 gets volts.
+Serial.println('V'); //print out the units too
+3.2k on a 1626/
+Or you could do:
+uint32_t reading = analogReadEnh(adc_pin, 12); // same analog reading
+Serial.print(reading/1000) //volts
+Serial.print('.'); //decimal point
+Serial.print(reading%1000) //millivolts
+Serial.println('V'); //print out the units too
+// This would print the same thing, only without any floating point derived error... weighing in at 2k of flash.
+
+// And just doing this saves another 100 bytes:
+uint32_t reading = analogReadEnh(1, 12);  //where adc_pin is just the pin number being read
+Serial.print((uint16_t)reading);
+Serial.println("mV");
+
+
+* Yeah the last one is kind of a copoout,  but not only is it flash-efficient, it also runs *much* faster, because division,
+* be it floating point or otherwise, is sloowwwwwwww on AVR. But the fact that there are better ways to round than round()
+* was not an excuse for it being broken like that.
+*/
+
+
+
+typedef void (*voidFuncPtr)(void);
+
+// interrupts() / noInterrupts() must be defined by the core
+
+// a bunch of really silly hand-holding macros!
+#define lowByte(w)  ((uint8_t) ((w)    &  0xff))
+#define highByte(w) ((uint8_t) ((w)    >>    8))
+#define  bitRead(value, bit) (((value) >> (bit)) & 0x01)
+#define   bitSet(value, bit)  ((value) |= (1UL << (bit)))
+#define bitClear(value, bit)  ((value) &= ~(1UL << (bit)))
+#define bitWrite(value, bit, bitvalue) (bitvalue ? bitSet(value, bit) : bitClear(value, bit))
+#ifndef bit
+#define bit(b) (1UL << (b))
+#endif
+
+#if defined(DISCOURAGE_NONSTANDARD_TYPES) && DISCOURAGE_NONSTANDARD_TYPES
+typedef bool      boolean __attribute__ ((deprecated("a 'boolean' is called a 'bool' in standard C - suggest using standard type name")));
+typedef uint8_t   byte __attribute__ ((deprecated("a 'byte' is an 'unsigned char' (may be more than 8 bits on non-AVR) or 'uint8_t' (always 8 bits) in standard C - suggest using one of these standard types.")));
+typedef uint16_t  word __attribute__ ((deprecated("a 'word' is an 'unsigned int' (may be more than 16 bits on non-AVR) or 'uint15_t' (always 16 bits) in standard C - suggest using one of these standard types.")));
+#else
+typedef bool      boolean;
+typedef uint8_t   byte;
+typedef uint16_t  word;
+#endif
+void init(void);
+void initVariant(void);
+
+int atexit(void (*func)()) __attribute__((weak));
+int main() __attribute__((weak));
+
+#ifdef EXTENDED_PIN_MODE
+// Platforms who want to declare more than 256 pins need to define EXTENDED_PIN_MODE globally
+typedef uint32_t pin_size_t;
+#else
+typedef uint8_t pin_size_t;
+#endif
+
+void    pinMode(         pin_size_t pinNumber, uint8_t mode);
+void    digitalWrite(    pin_size_t pinNumber, uint8_t val);
+int8_t  digitalRead(     pin_size_t pinNumber);
+void    analogWrite(     pin_size_t pinNumber, int value);
+int     analogRead(      pin_size_t pinNumber);
+void    analogReference(         uint8_t mode);
+bool    analogReadResolution(     uint8_t res);
+
+unsigned long millis(void);
+unsigned long micros(void);
+
+void delay(unsigned long);
+void delayMicroseconds(unsigned int us);
+unsigned long     pulseIn(pin_size_t pin, uint8_t state, unsigned long timeout);
+unsigned long pulseInLong(pin_size_t pin, uint8_t state, unsigned long timeout);
+
+void   shiftOut(pin_size_t dataPin, pin_size_t clockPin, uint8_t bitOrder, uint8_t val);
+uint8_t shiftIn(pin_size_t dataPin, pin_size_t clockPin, uint8_t bitOrder);
+
+void attachInterrupt(pin_size_t interruptNumber, voidFuncPtr callback, uint8_t mode);
+void detachInterrupt(pin_size_t interruptNumber);
+
+void setup(void);
+void loop(void);
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
+
+#ifdef __cplusplus
+  /* C++ prototypes */
+  uint16_t makeWord(uint16_t w);
+  uint16_t makeWord(byte h, byte 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);
+
+  // WMath prototypes
+  long random(long);
+  long random(long, long);
+  void randomSeed(unsigned long);
+  long map(long, long, long, long, long);
+
+#endif // __cplusplus

fw/HackSpaceCon_AS7/Arduino/megatinycore/api/HardwareI2C.h

@@ -0,0 +1,45 @@
+/*
+  Copyright (c) 2016 Arduino LLC.  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
+*/
+/* THIS FILE IS NOT USED BY ANY PART OF megaTinyCore
+ * Wire subclasses Stream directly, saving a large amount of flash
+ * The overhead was additive, and made the Wire.h unusable 2/4k parts.
+ */
+
+#pragma once
+
+#include <inttypes.h>
+#include "Stream.h"
+
+class HardwareI2C : public Stream {
+  public:
+    virtual void begin() = 0;
+    virtual void begin(uint8_t address) = 0;
+    virtual void end() = 0;
+
+    virtual void setClock(uint32_t freq) = 0;
+
+    virtual void beginTransmission(uint8_t address) = 0;
+    virtual uint8_t endTransmission(bool stopBit) = 0;
+    virtual uint8_t endTransmission(void) = 0;
+
+    virtual uint8_t requestFrom(uint8_t address, size_t len, bool stopBit) = 0;
+    virtual uint8_t requestFrom(uint8_t address, size_t len) = 0;
+
+    virtual void onReceive(void(*)(int)) = 0;
+    virtual void onRequest(void(*)(void)) = 0;
+};

fw/HackSpaceCon_AS7/Arduino/megatinycore/api/HardwareSerial.h

@@ -0,0 +1,54 @@
+/*
+  Copyright (c) 2016 Arduino LLC.  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
+
+  Modified Spence Konde 2021 - constants removed.
+  Modified Spence Konde 2022 - commemt out the entire class. .
+*/
+
+//#prama never
+/*
+
+#pragma once
+
+#include <inttypes.h>
+#include "Stream.h"
+
+// XXX: Those constants should be defined as const int / enums?
+// XXX: shall we use namespaces too?
+// Spence: Screw that noise!
+// We do not have flash to waste, this code will be run with parts that have only 4k of flash
+// so using an integer to hold settings, and then REARRANGING THE BITS AT RUNTIME,
+// when they are ALL LOCATED NEXT TO EACH OTHER ON THE SAME BYTE is madness!
+// See UART_constants.h
+
+class HardwareSerial : public Stream {
+  public:
+    virtual void begin(unsigned long) = 0;
+    virtual void begin(unsigned long baudrate, uint16_t config) = 0;
+    virtual void end() = 0;
+    virtual int available(void) = 0;
+    virtual int peek(void) = 0;
+    virtual int read(void) = 0;
+    virtual void flush(void) = 0;
+    virtual size_t write(uint8_t) = 0;
+    using Print::write; // pull in write(str) and write(buf, size) from Print
+    virtual operator bool() = 0;
+};
+
+// XXX: Are we keeping the serialEvent API?
+// Spence: Apparently not.
+*/

fw/HackSpaceCon_AS7/Arduino/megatinycore/api/IPAddress.cpp

@@ -0,0 +1,101 @@
+/*
+  IPAddress.cpp - Base class that provides IPAddress
+  Copyright (c) 2011 Adrian McEwen.  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
+*/
+
+#include "IPAddress.h"
+#include "Print.h"
+
+IPAddress::IPAddress() {
+  _address.dword = 0;
+}
+
+IPAddress::IPAddress(uint8_t first_octet, uint8_t second_octet, uint8_t third_octet, uint8_t fourth_octet) {
+  _address.bytes[0] = first_octet;
+  _address.bytes[1] = second_octet;
+  _address.bytes[2] = third_octet;
+  _address.bytes[3] = fourth_octet;
+}
+
+IPAddress::IPAddress(uint32_t address) {
+  _address.dword = address;
+}
+
+IPAddress::IPAddress(const uint8_t *address) {
+  memcpy(_address.bytes, address, sizeof(_address.bytes));
+}
+
+bool IPAddress::fromString(const char *address) {
+  // TODO: add support for "a", "a.b", "a.b.c" formats
+
+  uint16_t acc = 0; // Accumulator
+  uint8_t dots = 0;
+
+  while (*address) {
+    char c = *address++;
+    if (c >= '0' && c <= '9') {
+      acc = acc * 10 + (c - '0');
+      if (acc > 255) {
+        // Value out of [0..255] range
+        return false;
+      }
+    } else if (c == '.') {
+      if (dots == 3) {
+        // Too much dots (there must be 3 dots)
+        return false;
+      }
+      _address.bytes[dots++] = acc;
+      acc = 0;
+    } else {
+      // Invalid char
+      return false;
+    }
+  }
+
+  if (dots != 3) {
+    // Too few dots (there must be 3 dots)
+    return false;
+  }
+  _address.bytes[3] = acc;
+  return true;
+}
+
+IPAddress &IPAddress::operator = (const uint8_t *address) {
+  memcpy(_address.bytes, address, sizeof(_address.bytes));
+  return *this;
+}
+
+IPAddress &IPAddress::operator = (uint32_t address) {
+  _address.dword = address;
+  return *this;
+}
+
+bool IPAddress::operator==(const uint8_t *addr) const {
+  return memcmp(addr, _address.bytes, sizeof(_address.bytes)) == 0;
+}
+
+size_t IPAddress::printTo(Print &p) const {
+  size_t n = 0;
+  for (int i = 0; i < 3; i++) {
+    n += p.print(_address.bytes[i], DEC);
+    n += p.print('.');
+  }
+  n += p.print(_address.bytes[3], DEC);
+  return n;
+}
+
+const IPAddress INADDR_NONE(0, 0, 0, 0);

fw/HackSpaceCon_AS7/Arduino/megatinycore/api/IPAddress.h

@@ -0,0 +1,87 @@
+/*
+  IPAddress.h - Base class that provides IPAddress
+  Copyright (c) 2011 Adrian McEwen.  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
+*/
+
+#pragma once
+
+#include <stdint.h>
+#include "Printable.h"
+#include "String.h"
+
+// A class to make it easier to handle and pass around IP addresses
+
+class IPAddress : public Printable {
+private:
+    union {
+      uint8_t bytes[4];  // IPv4 address
+      uint32_t dword;
+    } _address;
+
+    // Access the raw byte array containing the address.  Because this returns a pointer
+    // to the internal structure rather than a copy of the address this function should only
+    // be used when you know that the usage of the returned uint8_t* will be transient and not
+    // stored.
+    uint8_t *raw_address() {
+      return _address.bytes;
+    };
+
+  public:
+    // Constructors
+    IPAddress();
+    IPAddress(uint8_t first_octet, uint8_t second_octet, uint8_t third_octet, uint8_t fourth_octet);
+    IPAddress(uint32_t address);
+    IPAddress(const uint8_t *address);
+
+    bool fromString(const char *address);
+    bool fromString(const String &address) {
+      return fromString(address.c_str());
+    }
+
+    // Overloaded cast operator to allow IPAddress objects to be used where a pointer
+    // to a four-byte uint8_t array is expected
+    operator uint32_t() const {
+      return _address.dword;
+    };
+    bool operator==(const IPAddress &addr) const {
+      return _address.dword == addr._address.dword;
+    };
+    bool operator==(const uint8_t *addr) const;
+
+    // Overloaded index operator to allow getting and setting individual octets of the address
+    uint8_t operator[](int index) const {
+      return _address.bytes[index];
+    };
+    uint8_t &operator[](int index) {
+      return _address.bytes[index];
+    };
+
+    // Overloaded copy operators to allow initialisation of IPAddress objects from other types
+    IPAddress &operator = (const uint8_t *address);
+    IPAddress &operator = (uint32_t address);
+
+    virtual size_t printTo(Print &p) const;
+
+    friend class EthernetClass;
+    friend class UDP;
+    friend class Client;
+    friend class Server;
+    friend class DhcpClass;
+    friend class DNSClient;
+};
+
+extern const IPAddress INADDR_NONE;

fw/HackSpaceCon_AS7/Arduino/megatinycore/api/PluggableUSB.cpp

@@ -0,0 +1,95 @@
+/*
+  PluggableUSB.cpp
+  Copyright (c) 2015 Arduino LLC
+
+  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
+*/
+
+#include "USBAPI.h"
+#include "PluggableUSB.h"
+
+int PluggableUSB_::getInterface(uint8_t *interfaceCount) {
+  int sent = 0;
+  PluggableUSBModule *node;
+  for (node = rootNode; node; node = node->next) {
+    int res = node->getInterface(interfaceCount);
+    if (res < 0) {
+      return -1;
+    }
+    sent += res;
+  }
+  return sent;
+}
+
+int PluggableUSB_::getDescriptor(USBSetup &setup) {
+  PluggableUSBModule *node;
+  for (node = rootNode; node; node = node->next) {
+    int ret = node->getDescriptor(setup);
+    // ret!=0 -> request has been processed
+    if (ret) {
+      return ret;
+    }
+  }
+  return 0;
+}
+
+void PluggableUSB_::getShortName(char *iSerialNum) {
+  PluggableUSBModule *node;
+  for (node = rootNode; node; node = node->next) {
+    iSerialNum += node->getShortName(iSerialNum);
+  }
+  *iSerialNum = 0;
+}
+
+bool PluggableUSB_::setup(USBSetup &setup) {
+  PluggableUSBModule *node;
+  for (node = rootNode; node; node = node->next) {
+    if (node->setup(setup)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+bool PluggableUSB_::plug(PluggableUSBModule *node) {
+  if ((lastEp + node->numEndpoints) > totalEP) {
+    return false;
+  }
+
+  if (!rootNode) {
+    rootNode = node;
+  } else {
+    PluggableUSBModule *current = rootNode;
+    while (current->next) {
+      current = current->next;
+    }
+    current->next = node;
+  }
+
+  node->pluggedInterface = lastIf;
+  node->pluggedEndpoint = lastEp;
+  lastIf += node->numInterfaces;
+  for (uint8_t i = 0; i < node->numEndpoints; i++) {
+    *(unsigned int *)(epBuffer(lastEp)) = node->endpointType[i];
+    lastEp++;
+  }
+  return true;
+  // restart USB layer???
+}
+
+PluggableUSB_ &PluggableUSB() {
+  static PluggableUSB_ obj;
+  return obj;
+}

fw/HackSpaceCon_AS7/Arduino/megatinycore/api/PluggableUSB.h

@@ -0,0 +1,78 @@
+/*
+  PluggableUSB.h
+  Copyright (c) 2015 Arduino LLC
+
+  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 PUSB_h
+#define PUSB_h
+
+#include "USBAPI.h"
+#include <stdint.h>
+#include <stddef.h>
+
+// core need to define
+void *epBuffer(unsigned int n); // -> returns a pointer to the Nth element of the EP buffer structure
+
+class PluggableUSBModule {
+  public:
+    PluggableUSBModule(uint8_t numEps, uint8_t numIfs, unsigned int *epType) :
+      numEndpoints(numEps), numInterfaces(numIfs), endpointType(epType)
+    { }
+
+  protected:
+    virtual bool setup(USBSetup &setup) = 0;
+    virtual int getInterface(uint8_t *interfaceCount) = 0;
+    virtual int getDescriptor(USBSetup &setup) = 0;
+    virtual uint8_t getShortName(char *name) {
+      name[0] = 'A' + pluggedInterface;
+      return 1;
+    }
+
+    uint8_t pluggedInterface;
+    uint8_t pluggedEndpoint;
+
+    const uint8_t numEndpoints;
+    const uint8_t numInterfaces;
+    const unsigned int *endpointType;
+
+    PluggableUSBModule *next = NULL;
+
+    friend class PluggableUSB_;
+};
+
+class PluggableUSB_ {
+  public:
+    PluggableUSB_();
+    bool plug(PluggableUSBModule *node);
+    int getInterface(uint8_t *interfaceCount);
+    int getDescriptor(USBSetup &setup);
+    bool setup(USBSetup &setup);
+    void getShortName(char *iSerialNum);
+
+  private:
+    uint8_t lastIf;
+    uint8_t lastEp;
+    PluggableUSBModule *rootNode;
+    uint8_t totalEP;
+};
+
+// Replacement for global singleton.
+// This function prevents static-initialization-order-fiasco
+// https://isocpp.org/wiki/faq/ctors#static-init-order-on-first-use
+PluggableUSB_ &PluggableUSB();
+
+#endif

fw/HackSpaceCon_AS7/Arduino/megatinycore/api/Print.cpp

@@ -0,0 +1,285 @@
+/*
+  Copyright (c) 2014 Arduino.  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
+*/
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <math.h>
+
+#include "Print.h"
+
+// Public Methods //////////////////////////////////////////////////////////////
+
+/* default implementation: may be overridden */
+size_t Print::write(const uint8_t *buffer, size_t size) {
+  size_t n = 0;
+  while (size--) {
+    if (write(*buffer++)) {
+      n++;
+    } else {
+      break;
+    }
+  }
+  return n;
+}
+
+size_t Print::print(const __FlashStringHelper *ifsh) {
+  #if defined(__AVR__)
+  PGM_P p = reinterpret_cast<PGM_P>(ifsh);
+  size_t n = 0;
+  while (1) {
+    unsigned char c = pgm_read_byte(p++);
+    if (c == 0) {
+      break;
+    }
+    if (write(c)) {
+      n++;
+    } else {
+      break;
+    }
+  }
+  return n;
+  #else
+  return print(reinterpret_cast<const char *>(ifsh));
+  #endif
+}
+
+size_t Print::print(const String &s) {
+  return write(s.c_str(), s.length());
+}
+
+size_t Print::print(const char str[]) {
+  return write(str);
+}
+
+size_t Print::print(char c) {
+  return write(c);
+}
+
+size_t Print::print(unsigned char b, int base) {
+  return print((unsigned long) b, base);
+}
+
+size_t Print::print(int n, int base) {
+  return print((long) n, base);
+}
+
+size_t Print::print(unsigned int n, int base) {
+  return print((unsigned long) n, base);
+}
+
+size_t Print::print(long n, int base) {
+  if (base == 0) {
+    return write(n);
+  } else if (base == 10) {
+    if (n < 0) {
+      int t = print('-');
+      n = -n;
+      return printNumber(n, 10) + t;
+    }
+    return printNumber(n, 10);
+  } else {
+    return printNumber(n, base);
+  }
+}
+
+size_t Print::print(unsigned long n, int base) {
+  if (base == 0) {
+    return write(n);
+  } else {
+    return printNumber(n, base);
+  }
+}
+
+size_t Print::print(double n, int digits) {
+  return printFloat(n, digits);
+}
+
+size_t Print::println(const __FlashStringHelper *ifsh) {
+  size_t n = print(ifsh);
+  n += println();
+  return n;
+}
+
+size_t Print::print(const Printable &x) {
+  return x.printTo(*this);
+}
+
+size_t Print::println(void) {
+  return write("\r\n");
+}
+
+size_t Print::println(const String &s) {
+  size_t n = print(s);
+  n += println();
+  return n;
+}
+
+size_t Print::println(const char c[]) {
+  size_t n = print(c);
+  n += println();
+  return n;
+}
+
+size_t Print::println(char c) {
+  size_t n = print(c);
+  n += println();
+  return n;
+}
+
+size_t Print::println(unsigned char b, int base) {
+  size_t n = print(b, base);
+  n += println();
+  return n;
+}
+
+size_t Print::println(int num, int base) {
+  size_t n = print(num, base);
+  n += println();
+  return n;
+}
+
+size_t Print::println(unsigned int num, int base) {
+  size_t n = print(num, base);
+  n += println();
+  return n;
+}
+
+size_t Print::println(long num, int base) {
+  size_t n = print(num, base);
+  n += println();
+  return n;
+}
+
+size_t Print::println(unsigned long num, int base) {
+  size_t n = print(num, base);
+  n += println();
+  return n;
+}
+
+size_t Print::println(double num, int digits) {
+  size_t n = print(num, digits);
+  n += println();
+  return n;
+}
+
+size_t Print::println(const Printable &x) {
+  size_t n = print(x);
+  n += println();
+  return n;
+}
+
+// Custom implementation of printf borrowed from the teensy core files
+static int16_t printf_putchar(char c, FILE *fp) {
+  ((class Print *)(fdev_get_udata(fp)))->write((uint8_t)c);
+  return 0;
+}
+
+int16_t Print::printf(const char *format, ...) {
+  FILE f;
+  va_list ap;
+
+  fdev_setup_stream(&f, printf_putchar, NULL, _FDEV_SETUP_WRITE);
+  fdev_set_udata(&f, this);
+  va_start(ap, format);
+  return vfprintf(&f, format, ap);
+}
+
+int16_t Print::printf(const __FlashStringHelper *format, ...) {
+  FILE f;
+  va_list ap;
+
+  fdev_setup_stream(&f, printf_putchar, NULL, _FDEV_SETUP_WRITE);
+  fdev_set_udata(&f, this);
+  va_start(ap, format);
+  return vfprintf_P(&f, (const char *)format, ap);
+}
+
+// Private Methods /////////////////////////////////////////////////////////////
+
+size_t Print::printNumber(unsigned long n, uint8_t base) {
+  char buf[8 * sizeof(long) + 1]; // Assumes 8-bit chars plus zero byte.
+  char *str = &buf[sizeof(buf) - 1];
+
+  *str = '\0';
+
+  // prevent crash if called with base == 1
+  if (base < 2) {
+    base = 10;
+  }
+
+  do {
+    char c = n % base;
+    n /= base;
+
+    *--str = c < 10 ? c + '0' : c + 'A' - 10;
+  } while (n);
+
+  return write(str);
+}
+
+size_t Print::printFloat(double number, uint8_t digits) {
+  size_t n = 0;
+
+  if (isnan(number)) {
+    return print("nan");
+  }
+  if (isinf(number)) {
+    return print("inf");
+  }
+  if (number > 4294967040.0) {
+    return print("ovf");  // constant determined empirically
+  }
+  if (number < -4294967040.0) {
+    return print("ovf");  // constant determined empirically
+  }
+
+  // Handle negative numbers
+  if (number < 0.0) {
+    n += print('-');
+    number = -number;
+  }
+
+  // Round correctly so that print(1.999, 2) prints as "2.00"
+  double rounding = 0.5;
+  for (uint8_t i = 0; i < digits; ++i) {
+    rounding /= 10.0;
+  }
+
+  number += rounding;
+
+  // Extract the integer part of the number and print it
+  unsigned long int_part = (unsigned long)number;
+  double remainder = number - (double)int_part;
+  n += print(int_part);
+
+  // Print the decimal point, but only if there are digits beyond
+  if (digits > 0) {
+    n += print(".");
+  }
+
+  // Extract digits from the remainder one at a time
+  while (digits-- > 0) {
+    remainder *= 10.0;
+    unsigned int toPrint = (unsigned int)remainder;
+    n += print(toPrint);
+    remainder -= toPrint;
+  }
+
+  return n;
+}

fw/HackSpaceCon_AS7/Arduino/megatinycore/api/Print.h

@@ -0,0 +1,96 @@
+/*
+  Copyright (c) 2016 Arduino LLC.  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
+*/
+
+#pragma once
+
+#include <inttypes.h>
+#include <stdio.h> // for size_t
+
+#include "String.h"
+#include "Printable.h"
+
+#define DEC 10
+#define HEX 16
+#define OCT 8
+#define BIN 2
+
+class Print {
+  private:
+    int write_error;
+    size_t printNumber(unsigned long, uint8_t);
+    size_t printFloat(double, uint8_t);
+  protected:
+    void setWriteError(int err = 1) {
+      write_error = err;
+    }
+  public:
+    Print() : write_error(0) {}
+
+    int getWriteError() {
+      return write_error;
+    }
+    void clearWriteError() {
+      setWriteError(0);
+    }
+
+    virtual size_t write(uint8_t) = 0;
+    size_t write(const char *str) {
+      if (str == NULL) {
+        return 0;
+      }
+      return write((const uint8_t *)str, strlen(str));
+    }
+    virtual size_t write(const uint8_t *buffer, size_t size);
+    size_t write(const char *buffer, size_t size) {
+      return write((const uint8_t *)buffer, size);
+    }
+
+    // default to zero, meaning "a single write may block"
+    // should be overridden by subclasses with buffering
+    virtual int availableForWrite() { return 0; }
+
+    size_t print(const __FlashStringHelper *);
+    size_t print(const String &);
+    size_t print(const char[]);
+    size_t print(char);
+    size_t print(unsigned char, int = DEC);
+    size_t print(int, int = DEC);
+    size_t print(unsigned int, int = DEC);
+    size_t print(long, int = DEC);
+    size_t print(unsigned long, int = DEC);
+    size_t print(double, int = 2);
+    size_t print(const Printable &);
+
+    size_t println(const __FlashStringHelper *);
+    size_t println(const String &s);
+    size_t println(const char[]);
+    size_t println(char);
+    size_t println(unsigned char, int = DEC);
+    size_t println(int, int = DEC);
+    size_t println(unsigned int, int = DEC);
+    size_t println(long, int = DEC);
+    size_t println(unsigned long, int = DEC);
+    size_t println(double, int = 2);
+    size_t println(const Printable &);
+    size_t println(void);
+
+    int16_t printf(const char *format, ...) __attribute__ ((format (printf, 2, 3)));
+    int16_t printf(const __FlashStringHelper *format, ...);
+
+    virtual void flush() { /* Empty implementation for backward compatibility */ }
+};

fw/HackSpaceCon_AS7/Arduino/megatinycore/api/Printable.h

@@ -0,0 +1,34 @@
+/*
+  Copyright (c) 2016 Arduino LLC.  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
+*/
+
+#pragma once
+
+#include <stdlib.h>
+
+class Print;
+
+/** The Printable class provides a way for new classes to allow themselves to be printed.
+    By deriving from Printable and implementing the printTo method, it will then be possible
+    for users to print out instances of this class by passing them into the usual
+    Print::print and Print::println methods.
+*/
+
+class Printable {
+  public:
+    virtual size_t printTo(Print &p) const = 0;
+};

fw/HackSpaceCon_AS7/Arduino/megatinycore/api/RingBuffer.cpp

@@ -0,0 +1,106 @@
+/*
+  Copyright (c) 2014 Arduino.  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
+*/
+
+#include "RingBuffer.h"
+#include <string.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+RingBuffer::RingBuffer(rb_index_type size) : size(size) {
+  _aucBuffer = (uint8_t *)malloc(size);
+  memset(_aucBuffer, 0, size) ;
+  clear();
+}
+
+void RingBuffer::store_char(uint8_t c) {
+  rb_index_type i = nextIndex(_iHead);
+
+  // if we should be storing the received character into the location
+  // just before the tail (meaning that the head would advance to the
+  // current location of the tail), we're about to overflow the buffer
+  // and so we don't write the character or advance the head.
+  if (i != _iTail) {
+    if (_iHead < size) {
+      _aucBuffer[_iHead] = c ;
+    } else {
+      additionalBuffer[_iHead - size] = c;
+    }
+    _iHead = i ;
+  }
+}
+
+void RingBuffer::clear() {
+  _iHead = 0;
+  _iTail = 0;
+}
+
+int RingBuffer::read_char() {
+  if (_iTail == _iHead) {
+    return -1;
+  }
+
+  uint8_t value;
+  if (_iTail < size) {
+    value  = _aucBuffer[_iTail];
+  } else {
+    value = additionalBuffer[_iTail - size];
+  }
+  _iTail = nextIndex(_iTail);
+
+  return value;
+}
+
+int RingBuffer::available() {
+  int delta = _iHead - _iTail;
+
+  if (delta < 0) {
+    return size + additionalSize + delta;
+  } else {
+    return delta;
+  }
+}
+
+int RingBuffer::availableForStore() {
+  int delta = _iHead - _iTail;
+  if (delta >= 0) {
+    return size + additionalSize - 1 - delta;
+  } else {
+    return -delta - 1;
+  }
+}
+
+
+int RingBuffer::peek() {
+  if (_iTail == _iHead) {
+    return -1;
+  }
+
+  if (_iTail < size) {
+    return _aucBuffer[_iTail];
+  } else {
+    return additionalBuffer[_iTail - size];
+  }
+}
+
+rb_index_type RingBuffer::nextIndex(rb_index_type index) {
+  return (rb_index_type)(index + 1) % (size + additionalSize);
+}
+
+bool RingBuffer::isFull() {
+  return (nextIndex(_iHead) == _iTail);
+}

fw/HackSpaceCon_AS7/Arduino/megatinycore/api/RingBuffer.h

@@ -0,0 +1,62 @@
+/*
+  Copyright (c) 2014 Arduino.  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 _RING_BUFFER_
+#define _RING_BUFFER_
+
+#include <stdint.h>
+
+// Define constants and variables for buffering incoming serial data.  We're
+// using a ring buffer (I think), in which head is the index of the location
+// to which to write the next incoming character and tail is the index of the
+// location from which to read.
+
+#define RINGBUFFER_HAS_ADDITIONAL_STORAGE_API
+
+#ifdef RINGBUFFER_FORCE_SMALL_SIZE
+  typedef uint8_t rb_index_type;
+#else
+  typedef unsigned int rb_index_type;
+#endif
+
+class RingBuffer {
+  public:
+    RingBuffer(rb_index_type size = 64) ;
+    void store_char(uint8_t c) ;
+    void clear();
+    int read_char();
+    int available();
+    int availableForStore();
+    int peek();
+    bool isFull();
+    void addStorage(uint8_t *_buffer, rb_index_type _size) {
+      additionalSize = _size;
+      additionalBuffer = _buffer;
+    };
+
+  private:
+    rb_index_type nextIndex(rb_index_type index);
+    uint8_t *additionalBuffer;
+    int additionalSize = 0;
+    rb_index_type size;
+    uint8_t *_aucBuffer;
+    volatile rb_index_type _iHead ;
+    volatile rb_index_type _iTail ;
+};
+
+#endif /* _RING_BUFFER_ */

fw/HackSpaceCon_AS7/Arduino/megatinycore/api/Server.h

@@ -0,0 +1,27 @@
+/*
+  Server.h - Base class that provides Server
+  Copyright (c) 2011 Adrian McEwen.  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
+*/
+
+#pragma once
+
+#include "Print.h"
+
+class Server : public Print {
+  public:
+    virtual void begin() = 0;
+};

fw/HackSpaceCon_AS7/Arduino/megatinycore/api/Stream.cpp

@@ -0,0 +1,358 @@
+/*
+  Stream.cpp - adds parsing methods to Stream class
+  Copyright (c) 2008 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
+
+  Created July 2011
+  parsing functions based on TextFinder library by Michael Margolis
+
+  findMulti/findUntil routines written by Jim Leonard/Xuth
+*/
+#include "util/delay.h"
+
+#include "Common.h"
+#include "Stream.h"
+
+
+#define PARSE_TIMEOUT 1000  // default number of milli-seconds to wait
+/*
+__attribute__ ((inline)) void wait_250_clocks() {
+  for (uint8_t i = 0; i < 245; i++) {
+    NOP();
+  }
+}
+*/
+
+int Stream::timedRead() {
+  #if !defined(MILLIS_USE_TIMERNONE)
+    int c;
+    unsigned long startMillis = millis(); //formerly, this was a member variable! Eating 4 bytes of ram for no bloody reason.
+    do {
+      c = read();
+      if (c >= 0) {
+        return c;
+      }
+    } while (millis() - startMillis < _timeout);
+    return -1;     // -1 indicates timeout
+  #else
+    int c;
+    for (uint32_t i = 0; i < _timeout; i++) {
+      c = read();
+      if (c >= 0) {
+        return c;
+      }
+      _delay_us(980); //not 1000, b/c compensation for the rest
+    }
+    return -1;     // -1 indicates timeout
+  #endif
+}
+
+// private method to peek stream with timeout
+int Stream::timedPeek() {
+  #if !defined(MILLIS_USE_TIMERNONE)
+    int c;
+    unsigned long startMillis = millis();
+    do {
+      c = peek();
+      if (c >= 0) {
+        return c;
+      }
+    } while (millis() - startMillis < _timeout);
+    return -1;     // -1 indicates timeout
+  #else
+    int c;
+    for (uint32_t i = 0; i < _timeout; i++) {
+      c = read();
+      if (c >= 0) {
+        return c;
+      }
+      _delay_us(980); //not 1000, b/c compensation for the rest
+    }
+    return -1;     // -1 indicates timeout
+  #endif
+}
+
+// returns peek of the next digit in the stream or -1 if timeout
+// discards non-numeric characters
+int Stream::peekNextDigit(LookaheadMode lookahead, bool detectDecimal) {
+  int c;
+  while (1) {
+    c = timedPeek();
+
+    if (c < 0 ||
+        c == '-' ||
+        (c >= '0' && c <= '9') ||
+        (detectDecimal && c == '.')) {
+      return c;
+    }
+
+    switch (lookahead) {
+      case SKIP_NONE: return -1; // Fail code.
+      case SKIP_WHITESPACE:
+        switch (c) {
+          case ' ': // fall-through
+          case '\t':
+          case '\r':
+          case '\n': break;
+          default: return -1; // Fail code.
+        }
+      case SKIP_ALL:
+        break;
+    }
+    read();  // discard non-numeric
+  }
+}
+
+// Public Methods
+//////////////////////////////////////////////////////////////
+
+void Stream::setTimeout(unsigned long timeout) { // sets the maximum number of milliseconds to wait
+  _timeout = timeout;
+}
+
+// find returns true if the target string is found
+bool  Stream::find(char *target) {
+  return findUntil(target, strlen(target), NULL, 0);
+}
+
+// reads data from the stream until the target string of given length is found
+// returns true if target string is found, false if timed out
+bool Stream::find(char *target, size_t length) {
+  return findUntil(target, length, NULL, 0);
+}
+
+// as find but search ends if the terminator string is found
+bool  Stream::findUntil(char *target, char *terminator) {
+  return findUntil(target, strlen(target), terminator, strlen(terminator));
+}
+
+// reads data from the stream until the target string of the given length is found
+// search terminated if the terminator string is found
+// returns true if target string is found, false if terminated or timed out
+bool Stream::findUntil(char *target, size_t targetLen, char *terminator, size_t termLen) {
+  if (terminator == NULL) {
+    MultiTarget t[1] = {{target, targetLen, 0}};
+    return findMulti(t, 1) == 0 ? true : false;
+  } else {
+    MultiTarget t[2] = {{target, targetLen, 0}, {terminator, termLen, 0}};
+    return findMulti(t, 2) == 0 ? true : false;
+  }
+}
+
+// returns the first valid (long) integer value from the current position.
+// lookahead determines how parseInt looks ahead in the stream.
+// See LookaheadMode enumeration at the top of the file.
+// Lookahead is terminated by the first character that is not a valid part of an integer.
+// Once parsing commences, 'ignore' will be skipped in the stream.
+long Stream::parseInt(LookaheadMode lookahead, char ignore) {
+  bool isNegative = false;
+  long value = 0;
+  int c;
+
+  c = peekNextDigit(lookahead, false);
+  // ignore non numeric leading characters
+  if (c < 0) {
+    return 0;  // zero returned if timeout
+  }
+
+  do {
+    if (c == ignore)
+      ; // ignore this character
+    else if (c == '-') {
+      isNegative = true;
+    } else if (c >= '0' && c <= '9') {   // is c a digit?
+      value = value * 10 + c - '0';
+    }
+    read();  // consume the character we got with peek
+    c = timedPeek();
+  } while ((c >= '0' && c <= '9') || c == ignore);
+
+  if (isNegative) {
+    value = -value;
+  }
+  return value;
+}
+
+// as parseInt but returns a floating point value
+float Stream::parseFloat(LookaheadMode lookahead, char ignore) {
+  bool isNegative = false;
+  bool isFraction = false;
+  long value = 0;
+  int c;
+  float fraction = 1.0;
+
+  c = peekNextDigit(lookahead, true);
+  // ignore non numeric leading characters
+  if (c < 0) {
+    return 0;  // zero returned if timeout
+  }
+
+  do {
+    if (c == ignore)
+      ; // ignore
+    else if (c == '-') {
+      isNegative = true;
+    } else if (c == '.') {
+      isFraction = true;
+    } else if (c >= '0' && c <= '9')  {   // is c a digit?
+      value = value * 10 + c - '0';
+      if (isFraction) {
+        fraction *= 0.1;
+      }
+    }
+    read();  // consume the character we got with peek
+    c = timedPeek();
+  } while ((c >= '0' && c <= '9')  || (c == '.' && !isFraction) || c == ignore);
+
+  if (isNegative) {
+    value = -value;
+  }
+  if (isFraction) {
+    return value * fraction;
+  } else {
+    return value;
+  }
+}
+
+// read characters from stream into buffer
+// terminates if length characters have been read, or timeout (see setTimeout)
+// returns the number of characters placed in the buffer
+// the buffer is NOT null terminated.
+//
+size_t Stream::readBytes(char *buffer, size_t length) {
+  size_t count = 0;
+  while (count < length) {
+    int c = timedRead();
+    if (c < 0) {
+      break;
+    }
+    *buffer++ = (char)c;
+    count++;
+  }
+  return count;
+}
+
+
+// as readBytes with terminator character
+// terminates if length characters have been read, timeout, or if the terminator character  detected
+// returns the number of characters placed in the buffer (0 means no valid data found)
+
+size_t Stream::readBytesUntil(char terminator, char *buffer, size_t length) {
+  if (length < 1) {
+    return 0;
+  }
+  size_t index = 0;
+  while (index < length) {
+    int c = timedRead();
+    if (c < 0 || c == terminator) {
+      break;
+    }
+    *buffer++ = (char)c;
+    index++;
+  }
+  return index; // return number of characters, not including null terminator
+}
+
+String Stream::readString() {
+  String ret;
+  int c = timedRead();
+  while (c >= 0) {
+    ret += (char)c;
+    c = timedRead();
+  }
+  return ret;
+}
+
+String Stream::readStringUntil(char terminator) {
+  String ret;
+  int c = timedRead();
+  while (c >= 0 && c != terminator) {
+    ret += (char)c;
+    c = timedRead();
+  }
+  return ret;
+}
+
+int Stream::findMulti(struct Stream::MultiTarget *targets, int tCount) {
+  // any zero length target string automatically matches and would make
+  // a mess of the rest of the algorithm.
+  for (struct MultiTarget *t = targets; t < targets + tCount; ++t) {
+    if (t->len <= 0) {
+      return t - targets;
+    }
+  }
+
+  while (1) {
+    int c = timedRead();
+    if (c < 0) {
+      return -1;
+    }
+
+    for (struct MultiTarget *t = targets; t < targets + tCount; ++t) {
+      // the simple case is if we match, deal with that first.
+      if (c == t->str[t->index]) {
+        if (++t->index == t->len) {
+          return t - targets;
+        } else {
+          continue;
+        }
+      }
+
+      // if not we need to walk back and see if we could have matched further
+      // down the stream (ie '1112' doesn't match the first position in '11112'
+      // but it will match the second position so we can't just reset the current
+      // index to 0 when we find a mismatch.
+      if (t->index == 0) {
+        continue;
+      }
+
+      int origIndex = t->index;
+      do {
+        --t->index;
+        // first check if current char works against the new current index
+        if (c != t->str[t->index]) {
+          continue;
+        }
+
+        // if it's the only char then we're good, nothing more to check
+        if (t->index == 0) {
+          t->index++;
+          break;
+        }
+
+        // otherwise we need to check the rest of the found string
+        int diff = origIndex - t->index;
+        size_t i;
+        for (i = 0; i < t->index; ++i) {
+          if (t->str[i] != t->str[i + diff]) {
+            break;
+          }
+        }
+
+        // if we successfully got through the previous loop then our current
+        // index is good.
+        if (i == t->index) {
+          t->index++;
+          break;
+        }
+
+        // otherwise we just try the next index
+      } while (t->index);
+    }
+  }
+  // unreachable
+  return -1;
+}

fw/HackSpaceCon_AS7/Arduino/megatinycore/api/Stream.h

@@ -0,0 +1,149 @@
+/*
+  Stream.h - base class for character-based streams.
+  Copyright (c) 2010 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
+
+  parsing functions based on TextFinder library by Michael Margolis
+*/
+
+#pragma once
+
+#include <inttypes.h>
+#include "Print.h"
+
+// compatibility macros for testing
+/*
+  #define   getInt()            parseInt()
+  #define   getInt(ignore)      parseInt(ignore)
+  #define   getFloat()          parseFloat()
+  #define   getFloat(ignore)    parseFloat(ignore)
+  #define   getString(pre_string, post_string, buffer, length)
+  readBytesBetween(pre_string, terminator, buffer, length)
+*/
+
+// This enumeration provides the lookahead options for parseInt(), parseFloat()
+// The rules set out here are used until either the first valid character is found
+// or a time out occurs due to lack of input.
+enum LookaheadMode {
+  SKIP_ALL,       // All invalid characters are ignored.
+  SKIP_NONE,      // Nothing is skipped, and the stream is not touched unless the first waiting character is valid.
+  SKIP_WHITESPACE // Only tabs, spaces, line feeds & carriage returns are skipped.
+};
+
+#define NO_IGNORE_CHAR  '\x01' // a char not found in a valid ASCII numeric field
+
+class Stream : public Print {
+  protected:
+    unsigned long _timeout;      // number of milliseconds to wait for the next char before aborting timed read
+    //unsigned long _startMillis;  // Formerly used for timer measurement. Unnecessary. Removed and assembly dependent on the class structure adjusted.
+    int timedRead();    // private method to read stream with timeout
+    int timedPeek();    // private method to peek stream with timeout
+    int peekNextDigit(LookaheadMode lookahead, bool detectDecimal); // returns the next numeric digit in the stream or -1 if timeout
+
+  public:
+    virtual int available() = 0;
+    virtual int read() = 0;
+    virtual int peek() = 0;
+    virtual void flush() = 0;
+
+    Stream() {
+      _timeout = 1000;
+    }
+
+    // parsing methods
+
+    void setTimeout(unsigned long timeout);  // sets maximum milliseconds to wait for stream data, default is 1 second
+    unsigned long getTimeout(void) {
+      return _timeout;
+    }
+
+    bool find(char * target);   // reads data from the stream until the target string is found
+    bool find(uint8_t * target) {
+      return find((char *) target);
+    }
+    // returns true if target string is found, false if timed out (see setTimeout)
+
+    bool find(char * target, size_t length);   // reads data from the stream until the target string of given length is found
+    bool find(uint8_t * target, size_t length) {
+      return find((char *) target, length);
+    }
+    // returns true if target string is found, false if timed out
+
+    bool find(char target) {
+      return find(&target, 1);
+    }
+
+    bool findUntil(char * target, char *terminator);   // as find but search ends if the terminator string is found
+    bool findUntil(uint8_t * target, char *terminator) {
+      return findUntil((char *) target, terminator);
+    }
+
+    bool findUntil(char * target, size_t targetLen, char *terminate, size_t termLen);   // as above but search ends if the terminate string is found
+    bool findUntil(uint8_t * target, size_t targetLen, char *terminate, size_t termLen) {
+      return findUntil((char *) target, targetLen, terminate, termLen);
+    }
+
+    long parseInt(LookaheadMode lookahead = SKIP_ALL, char ignore = NO_IGNORE_CHAR);
+    // returns the first valid (long) integer value from the current position.
+    // lookahead determines how parseInt looks ahead in the stream.
+    // See LookaheadMode enumeration at the top of the file.
+    // Lookahead is terminated by the first character that is not a valid part of an integer.
+    // Once parsing commences, 'ignore' will be skipped in the stream.
+
+    float parseFloat(LookaheadMode lookahead = SKIP_ALL, char ignore = NO_IGNORE_CHAR);
+    // float version of parseInt
+
+    size_t readBytes(char * buffer, size_t length);  // read chars from stream into buffer
+    size_t readBytes(uint8_t * buffer, size_t length) {
+      return readBytes((char *) buffer, length);
+    }
+    // terminates if length characters have been read or timeout (see setTimeout)
+    // returns the number of characters placed in the buffer (0 means no valid data found)
+
+    size_t readBytesUntil(char terminator, char *buffer, size_t length);  // as readBytes with terminator character
+    size_t readBytesUntil(char terminator, uint8_t *buffer, size_t length) {
+      return readBytesUntil(terminator, (char *)buffer, length);
+    }
+    // terminates if length characters have been read, timeout, or if the terminator character  detected
+    // returns the number of characters placed in the buffer (0 means no valid data found)
+
+    // Arduino String functions to be added here
+    String readString();
+    String readStringUntil(char terminator);
+
+  protected:
+    long parseInt(char ignore) {
+      return parseInt(SKIP_ALL, ignore);
+    }
+    float parseFloat(char ignore) {
+      return parseFloat(SKIP_ALL, ignore);
+    }
+    // These overload exists for compatibility with any class that has derived
+    // Stream and used parseFloat/Int with a custom ignore character. To keep
+    // the public API simple, these overload remains protected.
+
+    struct MultiTarget {
+      const char * str;  // string you're searching for
+      size_t len;       // length of string you're searching for
+      size_t index;     // index used by the search routine.
+    };
+
+    // This allows you to search for an arbitrary number of strings.
+    // Returns index of the target that is found first or -1 if timeout occurs.
+    int findMulti(struct MultiTarget * targets, int tCount);
+};
+
+#undef NO_IGNORE_CHAR

fw/HackSpaceCon_AS7/Arduino/megatinycore/api/String.cpp

@@ -0,0 +1,815 @@
+/*
+  String library for Wiring & Arduino
+  ...mostly rewritten by Paul Stoffregen...
+  Copyright (c) 2009-10 Hernando Barragan.  All rights reserved.
+  Copyright 2011, Paul Stoffregen, paul@pjrc.com
+
+  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
+*/
+
+#include "String.h"
+#include "itoa.h"
+#include "deprecated-avr-comp/avr/dtostrf.h"
+
+/*********************************************/
+/*  Constructors                             */
+/*********************************************/
+
+String::String(const char *cstr) {
+  init();
+  if (cstr) {
+    copy(cstr, strlen(cstr));
+  }
+}
+
+String::String(const String &value) {
+  init();
+  *this = value;
+}
+
+String::String(const __FlashStringHelper *pstr) {
+  init();
+  *this = pstr;
+}
+
+#if __cplusplus >= 201103L || defined(__GXX_EXPERIMENTAL_CXX0X__)
+String::String(String &&rval) {
+  init();
+  move(rval);
+}
+String::String(StringSumHelper &&rval) {
+  init();
+  move(rval);
+}
+#endif
+
+String::String(char c) {
+  init();
+  char buf[2];
+  buf[0] = c;
+  buf[1] = 0;
+  *this = buf;
+}
+
+String::String(unsigned char value, unsigned char base) {
+  init();
+  char buf[1 + 8 * sizeof(unsigned char)];
+  utoa(value, buf, base);
+  *this = buf;
+}
+
+String::String(int value, unsigned char base) {
+  init();
+  char buf[2 + 8 * sizeof(int)];
+  itoa(value, buf, base);
+  *this = buf;
+}
+
+String::String(unsigned int value, unsigned char base) {
+  init();
+  char buf[1 + 8 * sizeof(unsigned int)];
+  utoa(value, buf, base);
+  *this = buf;
+}
+
+String::String(long value, unsigned char base) {
+  init();
+  char buf[2 + 8 * sizeof(long)];
+  ltoa(value, buf, base);
+  *this = buf;
+}
+
+String::String(unsigned long value, unsigned char base) {
+  init();
+  char buf[1 + 8 * sizeof(unsigned long)];
+  ultoa(value, buf, base);
+  *this = buf;
+}
+
+String::String(float value, unsigned char decimalPlaces) {
+  init();
+  char buf[33];
+  *this = dtostrf(value, (decimalPlaces + 2), decimalPlaces, buf);
+}
+
+String::String(double value, unsigned char decimalPlaces) {
+  init();
+  char buf[33];
+  *this = dtostrf(value, (decimalPlaces + 2), decimalPlaces, buf);
+}
+
+String::~String() {
+  free(buffer);
+}
+
+/*********************************************/
+/*  Memory Management                        */
+/*********************************************/
+
+inline void String::init(void) {
+  buffer = NULL;
+  capacity = 0;
+  len = 0;
+}
+
+void String::invalidate(void) {
+  if (buffer) {
+    free(buffer);
+  }
+  buffer = NULL;
+  capacity = len = 0;
+}
+
+unsigned char String::reserve(unsigned int size) {
+  if (buffer && capacity >= size) {
+    return 1;
+  }
+  if (changeBuffer(size)) {
+    if (len == 0) {
+      buffer[0] = 0;
+    }
+    return 1;
+  }
+  return 0;
+}
+
+unsigned char String::changeBuffer(unsigned int maxStrLen) {
+  char *newbuffer = (char *)realloc(buffer, maxStrLen + 1);
+  if (newbuffer) {
+    buffer = newbuffer;
+    capacity = maxStrLen;
+    return 1;
+  }
+  return 0;
+}
+
+/*********************************************/
+/*  Copy and Move                            */
+/*********************************************/
+
+String &String::copy(const char *cstr, unsigned int length) {
+  if (!reserve(length)) {
+    invalidate();
+    return *this;
+  }
+  len = length;
+  strcpy(buffer, cstr);
+  return *this;
+}
+
+String &String::copy(const __FlashStringHelper *pstr, unsigned int length) {
+  if (!reserve(length)) {
+    invalidate();
+    return *this;
+  }
+  len = length;
+  strcpy_P(buffer, (PGM_P)pstr);
+  return *this;
+}
+
+#if __cplusplus >= 201103L || defined(__GXX_EXPERIMENTAL_CXX0X__)
+void String::move(String &rhs) {
+  if (buffer) {
+    if (rhs && capacity >= rhs.len) {
+      strcpy(buffer, rhs.buffer);
+      len = rhs.len;
+      rhs.len = 0;
+      return;
+    } else {
+      free(buffer);
+    }
+  }
+  buffer = rhs.buffer;
+  capacity = rhs.capacity;
+  len = rhs.len;
+  rhs.buffer = NULL;
+  rhs.capacity = 0;
+  rhs.len = 0;
+}
+#endif
+
+String &String::operator = (const String &rhs) {
+  if (this == &rhs) {
+    return *this;
+  }
+
+  if (rhs.buffer) {
+    copy(rhs.buffer, rhs.len);
+  } else {
+    invalidate();
+  }
+
+  return *this;
+}
+
+#if __cplusplus >= 201103L || defined(__GXX_EXPERIMENTAL_CXX0X__)
+String &String::operator = (String &&rval) {
+  if (this != &rval) {
+    move(rval);
+  }
+  return *this;
+}
+
+String &String::operator = (StringSumHelper &&rval) {
+  if (this != &rval) {
+    move(rval);
+  }
+  return *this;
+}
+#endif
+
+String &String::operator = (const char *cstr) {
+  if (cstr) {
+    copy(cstr, strlen(cstr));
+  } else {
+    invalidate();
+  }
+
+  return *this;
+}
+
+String &String::operator = (const __FlashStringHelper *pstr) {
+  if (pstr) {
+    copy(pstr, strlen_P((PGM_P)pstr));
+  } else {
+    invalidate();
+  }
+
+  return *this;
+}
+
+/*********************************************/
+/*  concat                                   */
+/*********************************************/
+
+unsigned char String::concat(const String &s) {
+  return concat(s.buffer, s.len);
+}
+
+unsigned char String::concat(const char *cstr, unsigned int length) {
+  unsigned int newlen = len + length;
+  if (!cstr) {
+    return 0;
+  }
+  if (length == 0) {
+    return 1;
+  }
+  if (!reserve(newlen)) {
+    return 0;
+  }
+  strcpy(buffer + len, cstr);
+  len = newlen;
+  return 1;
+}
+
+unsigned char String::concat(const char *cstr) {
+  if (!cstr) {
+    return 0;
+  }
+  return concat(cstr, strlen(cstr));
+}
+
+unsigned char String::concat(char c) {
+  char buf[2];
+  buf[0] = c;
+  buf[1] = 0;
+  return concat(buf, 1);
+}
+
+unsigned char String::concat(unsigned char num) {
+  char buf[1 + 3 * sizeof(unsigned char)];
+  itoa(num, buf, 10);
+  return concat(buf, strlen(buf));
+}
+
+unsigned char String::concat(int num) {
+  char buf[2 + 3 * sizeof(int)];
+  itoa(num, buf, 10);
+  return concat(buf, strlen(buf));
+}
+
+unsigned char String::concat(unsigned int num) {
+  char buf[1 + 3 * sizeof(unsigned int)];
+  utoa(num, buf, 10);
+  return concat(buf, strlen(buf));
+}
+
+unsigned char String::concat(long num) {
+  char buf[2 + 3 * sizeof(long)];
+  ltoa(num, buf, 10);
+  return concat(buf, strlen(buf));
+}
+
+unsigned char String::concat(unsigned long num) {
+  char buf[1 + 3 * sizeof(unsigned long)];
+  ultoa(num, buf, 10);
+  return concat(buf, strlen(buf));
+}
+
+unsigned char String::concat(float num) {
+  char buf[20];
+  char *string = dtostrf(num, 4, 2, buf);
+  return concat(string, strlen(string));
+}
+
+unsigned char String::concat(double num) {
+  char buf[20];
+  char *string = dtostrf(num, 4, 2, buf);
+  return concat(string, strlen(string));
+}
+
+unsigned char String::concat(const __FlashStringHelper *str) {
+  if (!str) {
+    return 0;
+  }
+  int length = strlen_P((const char *) str);
+  if (length == 0) {
+    return 1;
+  }
+  unsigned int newlen = len + length;
+  if (!reserve(newlen)) {
+    return 0;
+  }
+  strcpy_P(buffer + len, (const char *) str);
+  len = newlen;
+  return 1;
+}
+
+/*********************************************/
+/*  Concatenate                              */
+/*********************************************/
+
+StringSumHelper &operator + (const StringSumHelper &lhs, const String &rhs) {
+  StringSumHelper &a = const_cast<StringSumHelper &>(lhs);
+  if (!a.concat(rhs.buffer, rhs.len)) {
+    a.invalidate();
+  }
+  return a;
+}
+
+StringSumHelper &operator + (const StringSumHelper &lhs, const char *cstr) {
+  StringSumHelper &a = const_cast<StringSumHelper &>(lhs);
+  if (!cstr || !a.concat(cstr, strlen(cstr))) {
+    a.invalidate();
+  }
+  return a;
+}
+
+StringSumHelper &operator + (const StringSumHelper &lhs, char c) {
+  StringSumHelper &a = const_cast<StringSumHelper &>(lhs);
+  if (!a.concat(c)) {
+    a.invalidate();
+  }
+  return a;
+}
+
+StringSumHelper &operator + (const StringSumHelper &lhs, unsigned char num) {
+  StringSumHelper &a = const_cast<StringSumHelper &>(lhs);
+  if (!a.concat(num)) {
+    a.invalidate();
+  }
+  return a;
+}
+
+StringSumHelper &operator + (const StringSumHelper &lhs, int num) {
+  StringSumHelper &a = const_cast<StringSumHelper &>(lhs);
+  if (!a.concat(num)) {
+    a.invalidate();
+  }
+  return a;
+}
+
+StringSumHelper &operator + (const StringSumHelper &lhs, unsigned int num) {
+  StringSumHelper &a = const_cast<StringSumHelper &>(lhs);
+  if (!a.concat(num)) {
+    a.invalidate();
+  }
+  return a;
+}
+
+StringSumHelper &operator + (const StringSumHelper &lhs, long num) {
+  StringSumHelper &a = const_cast<StringSumHelper &>(lhs);
+  if (!a.concat(num)) {
+    a.invalidate();
+  }
+  return a;
+}
+
+StringSumHelper &operator + (const StringSumHelper &lhs, unsigned long num) {
+  StringSumHelper &a = const_cast<StringSumHelper &>(lhs);
+  if (!a.concat(num)) {
+    a.invalidate();
+  }
+  return a;
+}
+
+StringSumHelper &operator + (const StringSumHelper &lhs, float num) {
+  StringSumHelper &a = const_cast<StringSumHelper &>(lhs);
+  if (!a.concat(num)) {
+    a.invalidate();
+  }
+  return a;
+}
+
+StringSumHelper &operator + (const StringSumHelper &lhs, double num) {
+  StringSumHelper &a = const_cast<StringSumHelper &>(lhs);
+  if (!a.concat(num)) {
+    a.invalidate();
+  }
+  return a;
+}
+
+StringSumHelper &operator + (const StringSumHelper &lhs, const __FlashStringHelper *rhs) {
+  StringSumHelper &a = const_cast<StringSumHelper &>(lhs);
+  if (!a.concat(rhs)) {
+    a.invalidate();
+  }
+  return a;
+}
+
+/*********************************************/
+/*  Comparison                               */
+/*********************************************/
+
+int String::compareTo(const String &s) const {
+  if (!buffer || !s.buffer) {
+    if (s.buffer && s.len > 0) {
+      return 0 - *(unsigned char *)s.buffer;
+    }
+    if (buffer && len > 0) {
+      return *(unsigned char *)buffer;
+    }
+    return 0;
+  }
+  return strcmp(buffer, s.buffer);
+}
+
+unsigned char String::equals(const String &s2) const {
+  return (len == s2.len && compareTo(s2) == 0);
+}
+
+unsigned char String::equals(const char *cstr) const {
+  if (len == 0) {
+    return (cstr == NULL || *cstr == 0);
+  }
+  if (cstr == NULL) {
+    return buffer[0] == 0;
+  }
+  return strcmp(buffer, cstr) == 0;
+}
+
+unsigned char String::operator<(const String &rhs) const {
+  return compareTo(rhs) < 0;
+}
+
+unsigned char String::operator>(const String &rhs) const {
+  return compareTo(rhs) > 0;
+}
+
+unsigned char String::operator<=(const String &rhs) const {
+  return compareTo(rhs) <= 0;
+}
+
+unsigned char String::operator>=(const String &rhs) const {
+  return compareTo(rhs) >= 0;
+}
+
+unsigned char String::equalsIgnoreCase(const String &s2) const {
+  if (this == &s2) {
+    return 1;
+  }
+  if (len != s2.len) {
+    return 0;
+  }
+  if (len == 0) {
+    return 1;
+  }
+  const char *p1 = buffer;
+  const char *p2 = s2.buffer;
+  while (*p1) {
+    if (tolower(*p1++) != tolower(*p2++)) {
+      return 0;
+    }
+  }
+  return 1;
+}
+
+unsigned char String::startsWith(const String &s2) const {
+  if (len < s2.len) {
+    return 0;
+  }
+  return startsWith(s2, 0);
+}
+
+unsigned char String::startsWith(const String &s2, unsigned int offset) const {
+  if (offset > len - s2.len || !buffer || !s2.buffer) {
+    return 0;
+  }
+  return strncmp(&buffer[offset], s2.buffer, s2.len) == 0;
+}
+
+unsigned char String::endsWith(const String &s2) const {
+  if (len < s2.len || !buffer || !s2.buffer) {
+    return 0;
+  }
+  return strcmp(&buffer[len - s2.len], s2.buffer) == 0;
+}
+
+/*********************************************/
+/*  Character Access                         */
+/*********************************************/
+
+char String::charAt(unsigned int loc) const {
+  return operator[](loc);
+}
+
+void String::setCharAt(unsigned int loc, char c) {
+  if (loc < len) {
+    buffer[loc] = c;
+  }
+}
+
+char &String::operator[](unsigned int index) {
+  static char dummy_writable_char;
+  if (index >= len || !buffer) {
+    dummy_writable_char = 0;
+    return dummy_writable_char;
+  }
+  return buffer[index];
+}
+
+char String::operator[](unsigned int index) const {
+  if (index >= len || !buffer) {
+    return 0;
+  }
+  return buffer[index];
+}
+
+void String::getBytes(unsigned char *buf, unsigned int bufsize, unsigned int index) const {
+  if (!bufsize || !buf) {
+    return;
+  }
+  if (index >= len) {
+    buf[0] = 0;
+    return;
+  }
+  unsigned int n = bufsize - 1;
+  if (n > len - index) {
+    n = len - index;
+  }
+  strncpy((char *)buf, buffer + index, n);
+  buf[n] = 0;
+}
+
+/*********************************************/
+/*  Search                                   */
+/*********************************************/
+
+int String::indexOf(char c) const {
+  return indexOf(c, 0);
+}
+
+int String::indexOf(char ch, unsigned int fromIndex) const {
+  if (fromIndex >= len) {
+    return -1;
+  }
+  const char *temp = strchr(buffer + fromIndex, ch);
+  if (temp == NULL) {
+    return -1;
+  }
+  return temp - buffer;
+}
+
+int String::indexOf(const String &s2) const {
+  return indexOf(s2, 0);
+}
+
+int String::indexOf(const String &s2, unsigned int fromIndex) const {
+  if (fromIndex >= len) {
+    return -1;
+  }
+  const char *found = strstr(buffer + fromIndex, s2.buffer);
+  if (found == NULL) {
+    return -1;
+  }
+  return found - buffer;
+}
+
+int String::lastIndexOf(char theChar) const {
+  return lastIndexOf(theChar, len - 1);
+}
+
+int String::lastIndexOf(char ch, unsigned int fromIndex) const {
+  if (fromIndex >= len) {
+    return -1;
+  }
+  char tempchar = buffer[fromIndex + 1];
+  buffer[fromIndex + 1] = '\0';
+  char *temp = strrchr(buffer, ch);
+  buffer[fromIndex + 1] = tempchar;
+  if (temp == NULL) {
+    return -1;
+  }
+  return temp - buffer;
+}
+
+int String::lastIndexOf(const String &s2) const {
+  return lastIndexOf(s2, len - s2.len);
+}
+
+int String::lastIndexOf(const String &s2, unsigned int fromIndex) const {
+  if (s2.len == 0 || len == 0 || s2.len > len) {
+    return -1;
+  }
+  if (fromIndex >= len) {
+    fromIndex = len - 1;
+  }
+  int found = -1;
+  for (char *p = buffer; p <= buffer + fromIndex; p++) {
+    p = strstr(p, s2.buffer);
+    if (!p) {
+      break;
+    }
+    if ((unsigned int)(p - buffer) <= fromIndex) {
+      found = p - buffer;
+    }
+  }
+  return found;
+}
+
+String String::substring(unsigned int left, unsigned int right) const {
+  if (left > right) {
+    unsigned int temp = right;
+    right = left;
+    left = temp;
+  }
+  String out;
+  if (left >= len) {
+    return out;
+  }
+  if (right > len) {
+    right = len;
+  }
+  char temp = buffer[right];  // save the replaced character
+  buffer[right] = '\0';
+  out = buffer + left;  // pointer arithmetic
+  buffer[right] = temp;  // restore character
+  return out;
+}
+
+/*********************************************/
+/*  Modification                             */
+/*********************************************/
+
+void String::replace(char find, char replace) {
+  if (!buffer) {
+    return;
+  }
+  for (char *p = buffer; *p; p++) {
+    if (*p == find) {
+      *p = replace;
+    }
+  }
+}
+
+void String::replace(const String &find, const String &replace) {
+  if (len == 0 || find.len == 0) {
+    return;
+  }
+  int diff = replace.len - find.len;
+  char *readFrom = buffer;
+  char *foundAt;
+  if (diff == 0) {
+    while ((foundAt = strstr(readFrom, find.buffer)) != NULL) {
+      memcpy(foundAt, replace.buffer, replace.len);
+      readFrom = foundAt + replace.len;
+    }
+  } else if (diff < 0) {
+    char *writeTo = buffer;
+    while ((foundAt = strstr(readFrom, find.buffer)) != NULL) {
+      unsigned int n = foundAt - readFrom;
+      memcpy(writeTo, readFrom, n);
+      writeTo += n;
+      memcpy(writeTo, replace.buffer, replace.len);
+      writeTo += replace.len;
+      readFrom = foundAt + find.len;
+      len += diff;
+    }
+    strcpy(writeTo, readFrom);
+  } else {
+    unsigned int size = len; // compute size needed for result
+    while ((foundAt = strstr(readFrom, find.buffer)) != NULL) {
+      readFrom = foundAt + find.len;
+      size += diff;
+    }
+    if (size == len) {
+      return;
+    }
+    if (size > capacity && !changeBuffer(size)) {
+      return;  // XXX: tell user!
+    }
+    int index = len - 1;
+    while (index >= 0 && (index = lastIndexOf(find, index)) >= 0) {
+      readFrom = buffer + index + find.len;
+      memmove(readFrom + diff, readFrom, len - (readFrom - buffer));
+      len += diff;
+      buffer[len] = 0;
+      memcpy(buffer + index, replace.buffer, replace.len);
+      index--;
+    }
+  }
+}
+
+void String::remove(unsigned int index) {
+  // Pass the biggest integer as the count. The remove method
+  // below will take care of truncating it at the end of the
+  // string.
+  remove(index, (unsigned int) -1);
+}
+
+void String::remove(unsigned int index, unsigned int count) {
+  if (index >= len) {
+    return;
+  }
+  if (count <= 0) {
+    return;
+  }
+  if (count > len - index) {
+    count = len - index;
+  }
+  char *writeTo = buffer + index;
+  len = len - count;
+  strncpy(writeTo, buffer + index + count, len - index);
+  buffer[len] = 0;
+}
+
+void String::toLowerCase(void) {
+  if (!buffer) {
+    return;
+  }
+  for (char *p = buffer; *p; p++) {
+    *p = tolower(*p);
+  }
+}
+
+void String::toUpperCase(void) {
+  if (!buffer) {
+    return;
+  }
+  for (char *p = buffer; *p; p++) {
+    *p = toupper(*p);
+  }
+}
+
+void String::trim(void) {
+  if (!buffer || len == 0) {
+    return;
+  }
+  char *begin = buffer;
+  while (isspace(*begin)) {
+    begin++;
+  }
+  char *end = buffer + len - 1;
+  while (isspace(*end) && end >= begin) {
+    end--;
+  }
+  len = end + 1 - begin;
+  if (begin > buffer) {
+    memcpy(buffer, begin, len);
+  }
+  buffer[len] = 0;
+}
+
+/*********************************************/
+/*  Parsing / Conversion                     */
+/*********************************************/
+
+long String::toInt(void) const {
+  if (buffer) {
+    return atol(buffer);
+  }
+  return 0;
+}
+
+float String::toFloat(void) const {
+  return float(toDouble());
+}
+
+double String::toDouble(void) const {
+  if (buffer) {
+    return atof(buffer);
+  }
+  return 0;
+}

fw/HackSpaceCon_AS7/Arduino/megatinycore/api/String.h

@@ -0,0 +1,290 @@
+/*
+  String library for Wiring & Arduino
+  ...mostly rewritten by Paul Stoffregen...
+  Copyright (c) 2009-10 Hernando Barragan.  All right reserved.
+  Copyright 2011, Paul Stoffregen, paul@pjrc.com
+
+  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
+*/
+
+#pragma once
+
+#ifdef __cplusplus
+
+#include <stdlib.h>
+#include <string.h>
+#include <ctype.h>
+#if defined(__AVR__)
+  #include "avr/pgmspace.h"
+#else
+  #include "deprecated-avr-comp/avr/pgmspace.h"
+#endif
+
+// When compiling programs with this class, the following gcc parameters
+// dramatically increase performance and memory (RAM) efficiency, typically
+// with little or no increase in code size.
+//     -felide-constructors
+//     -std=c++0x
+
+class __FlashStringHelper;
+#define F(string_literal) (reinterpret_cast<const __FlashStringHelper *>(PSTR(string_literal)))
+
+
+
+// An inherited class for holding the result of a concatenation.  These
+// result objects are assumed to be writable by subsequent concatenations.
+class StringSumHelper;
+
+// The string class
+class String {
+    // use a function pointer to allow for "if (s)" without the
+    // complications of an operator bool(). for more information, see:
+    // http://www.artima.com/cppsource/safebool.html
+    typedef void (String::*StringIfHelperType)() const;
+    void StringIfHelper() const {}
+
+  public:
+    // constructors
+    // creates a copy of the initial value.
+    // if the initial value is null or invalid, or if memory allocation
+    // fails, the string will be marked as invalid (i.e. "if (s)" will
+    // be false).
+    String(const char *cstr = "");
+    String(const String &str);
+    String(const __FlashStringHelper *str);
+    #if __cplusplus >= 201103L || defined(__GXX_EXPERIMENTAL_CXX0X__)
+    String(String &&rval);
+    String(StringSumHelper &&rval);
+    #endif
+    explicit String(char c);
+    explicit String(unsigned char, unsigned char base = 10);
+    explicit String(int, unsigned char base = 10);
+    explicit String(unsigned int, unsigned char base = 10);
+    explicit String(long, unsigned char base = 10);
+    explicit String(unsigned long, unsigned char base = 10);
+    explicit String(float, unsigned char decimalPlaces = 2);
+    explicit String(double, unsigned char decimalPlaces = 2);
+    ~String(void);
+
+    // memory management
+    // return true on success, false on failure (in which case, the string
+    // is left unchanged).  reserve(0), if successful, will validate an
+    // invalid string (i.e., "if (s)" will be true afterwards)
+    unsigned char reserve(unsigned int size);
+    inline unsigned int length(void) const {
+      return len;
+    }
+
+    // creates a copy of the assigned value.  if the value is null or
+    // invalid, or if the memory allocation fails, the string will be
+    // marked as invalid ("if (s)" will be false).
+    String &operator = (const String &rhs);
+    String &operator = (const char *cstr);
+    String &operator = (const __FlashStringHelper *str);
+    #if __cplusplus >= 201103L || defined(__GXX_EXPERIMENTAL_CXX0X__)
+    String &operator = (String &&rval);
+    String &operator = (StringSumHelper &&rval);
+    #endif
+
+    // concatenate (works w/ built-in types)
+
+    // returns true on success, false on failure (in which case, the string
+    // is left unchanged).  if the argument is null or invalid, the
+    // concatenation is considered unsuccessful.
+    unsigned char concat(const String &str);
+    unsigned char concat(const char *cstr);
+    unsigned char concat(char c);
+    unsigned char concat(unsigned char c);
+    unsigned char concat(int num);
+    unsigned char concat(unsigned int num);
+    unsigned char concat(long num);
+    unsigned char concat(unsigned long num);
+    unsigned char concat(float num);
+    unsigned char concat(double num);
+    unsigned char concat(const __FlashStringHelper *str);
+
+    // if there's not enough memory for the concatenated value, the string
+    // will be left unchanged (but this isn't signalled in any way)
+    String &operator += (const String &rhs)  {
+      concat(rhs);
+      return (*this);
+    }
+    String &operator += (const char *cstr)   {
+      concat(cstr);
+      return (*this);
+    }
+    String &operator += (char c)     {
+      concat(c);
+      return (*this);
+    }
+    String &operator += (unsigned char num)    {
+      concat(num);
+      return (*this);
+    }
+    String &operator += (int num)      {
+      concat(num);
+      return (*this);
+    }
+    String &operator += (unsigned int num)   {
+      concat(num);
+      return (*this);
+    }
+    String &operator += (long num)     {
+      concat(num);
+      return (*this);
+    }
+    String &operator += (unsigned long num)  {
+      concat(num);
+      return (*this);
+    }
+    String &operator += (float num)    {
+      concat(num);
+      return (*this);
+    }
+    String &operator += (double num)   {
+      concat(num);
+      return (*this);
+    }
+    String &operator += (const __FlashStringHelper *str) {
+      concat(str);
+      return (*this);
+    }
+
+    friend StringSumHelper &operator + (const StringSumHelper &lhs, const String &rhs);
+    friend StringSumHelper &operator + (const StringSumHelper &lhs, const char *cstr);
+    friend StringSumHelper &operator + (const StringSumHelper &lhs, char c);
+    friend StringSumHelper &operator + (const StringSumHelper &lhs, unsigned char num);
+    friend StringSumHelper &operator + (const StringSumHelper &lhs, int num);
+    friend StringSumHelper &operator + (const StringSumHelper &lhs, unsigned int num);
+    friend StringSumHelper &operator + (const StringSumHelper &lhs, long num);
+    friend StringSumHelper &operator + (const StringSumHelper &lhs, unsigned long num);
+    friend StringSumHelper &operator + (const StringSumHelper &lhs, float num);
+    friend StringSumHelper &operator + (const StringSumHelper &lhs, double num);
+    friend StringSumHelper &operator + (const StringSumHelper &lhs, const __FlashStringHelper *rhs);
+
+    // comparison (only works w/ Strings and "strings")
+    operator StringIfHelperType() const {
+      return buffer ? &String::StringIfHelper : 0;
+    }
+    int compareTo(const String &s) const;
+    unsigned char equals(const String &s) const;
+    unsigned char equals(const char *cstr) const;
+    unsigned char operator == (const String &rhs) const {
+      return equals(rhs);
+    }
+    unsigned char operator == (const char *cstr) const {
+      return equals(cstr);
+    }
+    unsigned char operator != (const String &rhs) const {
+      return !equals(rhs);
+    }
+    unsigned char operator != (const char *cstr) const {
+      return !equals(cstr);
+    }
+    unsigned char operator < (const String &rhs) const;
+    unsigned char operator > (const String &rhs) const;
+    unsigned char operator <= (const String &rhs) const;
+    unsigned char operator >= (const String &rhs) const;
+    unsigned char equalsIgnoreCase(const String &s) const;
+    unsigned char startsWith(const String &prefix) const;
+    unsigned char startsWith(const String &prefix, unsigned int offset) const;
+    unsigned char endsWith(const String &suffix) const;
+
+    // character access
+    char charAt(unsigned int index) const;
+    void setCharAt(unsigned int index, char c);
+    char operator [](unsigned int index) const;
+    char &operator [](unsigned int index);
+    void getBytes(unsigned char *buf, unsigned int bufsize, unsigned int index = 0) const;
+    void toCharArray(char *buf, unsigned int bufsize, unsigned int index = 0) const {
+      getBytes((unsigned char *)buf, bufsize, index);
+    }
+    const char *c_str() const {
+      return buffer;
+    }
+    char *begin() {
+      return buffer;
+    }
+    char *end() {
+      return buffer + length();
+    }
+    const char *begin() const {
+      return c_str();
+    }
+    const char *end() const {
+      return c_str() + length();
+    }
+
+    // search
+    int indexOf(char ch) const;
+    int indexOf(char ch, unsigned int fromIndex) const;
+    int indexOf(const String &str) const;
+    int indexOf(const String &str, unsigned int fromIndex) const;
+    int lastIndexOf(char ch) const;
+    int lastIndexOf(char ch, unsigned int fromIndex) const;
+    int lastIndexOf(const String &str) const;
+    int lastIndexOf(const String &str, unsigned int fromIndex) const;
+    String substring(unsigned int beginIndex) const {
+      return substring(beginIndex, len);
+    };
+    String substring(unsigned int beginIndex, unsigned int endIndex) const;
+
+    // modification
+    void replace(char find, char replace);
+    void replace(const String &find, const String &replace);
+    void remove(unsigned int index);
+    void remove(unsigned int index, unsigned int count);
+    void toLowerCase(void);
+    void toUpperCase(void);
+    void trim(void);
+
+    // parsing/conversion
+    long toInt(void) const;
+    float toFloat(void) const;
+    double toDouble(void) const;
+
+  protected:
+    char *buffer;         // the actual char array
+    unsigned int capacity;  // the array length minus one (for the '\0')
+    unsigned int len;       // the String length (not counting the '\0')
+  protected:
+    void init(void);
+    void invalidate(void);
+    unsigned char changeBuffer(unsigned int maxStrLen);
+    unsigned char concat(const char *cstr, unsigned int length);
+
+    // copy and move
+    String &copy(const char *cstr, unsigned int length);
+    String &copy(const __FlashStringHelper *pstr, unsigned int length);
+    #if __cplusplus >= 201103L || defined(__GXX_EXPERIMENTAL_CXX0X__)
+    void move(String &rhs);
+    #endif
+};
+
+class StringSumHelper : public String {
+  public:
+    StringSumHelper(const String &s) : String(s) {}
+    StringSumHelper(const char *p) : String(p) {}
+    StringSumHelper(char c) : String(c) {}
+    StringSumHelper(unsigned char num) : String(num) {}
+    StringSumHelper(int num) : String(num) {}
+    StringSumHelper(unsigned int num) : String(num) {}
+    StringSumHelper(long num) : String(num) {}
+    StringSumHelper(unsigned long num) : String(num) {}
+    StringSumHelper(float num) : String(num) {}
+    StringSumHelper(double num) : String(num) {}
+};
+
+#endif  // __cplusplus

fw/HackSpaceCon_AS7/Arduino/megatinycore/api/USBAPI.h

@@ -0,0 +1,57 @@
+/*
+  USBAPI.h
+  Copyright (c) 2005-2014 Arduino.  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 __USBAPI__
+#define __USBAPI__
+
+#include <stdint.h>
+
+
+//  Low level API
+
+typedef struct __attribute__((packed))
+{
+  union {
+    uint8_t bmRequestType;
+    struct {
+      uint8_t direction : 5;
+      uint8_t type : 2;
+      uint8_t transferDirection : 1;
+    };
+  };
+  uint8_t   bRequest;
+  uint8_t   wValueL;
+  uint8_t   wValueH;
+  uint16_t  wIndex;
+  uint16_t  wLength;
+} USBSetup;
+
+
+int USB_SendControl(uint8_t flags, const void* d, int len);
+int USB_RecvControl(void* d, int len);
+int USB_RecvControlLong(void* d, int len);
+
+uint8_t USB_Available(uint8_t ep);
+uint8_t USB_SendSpace(uint8_t ep);
+int USB_Send(uint8_t ep, const void* data, int len);  // blocking
+int USB_Recv(uint8_t ep, void* data, int len);    // non-blocking
+int USB_Recv(uint8_t ep);             // non-blocking
+void USB_Flush(uint8_t ep);
+
+#endif

fw/HackSpaceCon_AS7/Arduino/megatinycore/api/Udp.h

@@ -0,0 +1,87 @@
+/*
+ *  Udp.cpp: Library to send/receive UDP packets.
+ *
+ * NOTE: UDP is fast, but has some important limitations (thanks to Warren Gray for mentioning these)
+ * 1) UDP does not guarantee the order in which assembled UDP packets are received. This
+ * might not happen often in practice, but in larger network topologies, a UDP
+ * packet can be received out of sequence.
+ * 2) UDP does not guard against lost packets - so packets *can* disappear without the sender being
+ * aware of it. Again, this may not be a concern in practice on small local networks.
+ * For more information, see http://www.cafeaulait.org/course/week12/35.html
+ *
+ * MIT License:
+ * Copyright (c) 2008 Bjoern Hartmann
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ *
+ * bjoern@cs.stanford.edu 12/30/2008
+ */
+
+#pragma once
+
+#include "Stream.h"
+#include "IPAddress.h"
+
+class UDP : public Stream {
+
+  public:
+    virtual uint8_t begin(uint16_t) = 0; // initialize, start listening on specified port. Returns 1 if successful, 0 if there are no sockets available to use
+    virtual void stop() = 0; // Finish with the UDP socket
+
+    // Sending UDP packets
+
+    // Start building up a packet to send to the remote host specific in ip and port
+    // Returns 1 if successful, 0 if there was a problem with the supplied IP address or port
+    virtual int beginPacket(IPAddress ip, uint16_t port) = 0;
+    // Start building up a packet to send to the remote host specific in host and port
+    // Returns 1 if successful, 0 if there was a problem resolving the hostname or port
+    virtual int beginPacket(const char *host, uint16_t port) = 0;
+    // Finish off this packet and send it
+    // Returns 1 if the packet was sent successfully, 0 if there was an error
+    virtual int endPacket() = 0;
+    // Write a single byte into the packet
+    virtual size_t write(uint8_t) = 0;
+    // Write size bytes from buffer into the packet
+    virtual size_t write(const uint8_t *buffer, size_t size) = 0;
+
+    // Start processing the next available incoming packet
+    // Returns the size of the packet in bytes, or 0 if no packets are available
+    virtual int parsePacket() = 0;
+    // Number of bytes remaining in the current packet
+    virtual int available() = 0;
+    // Read a single byte from the current packet
+    virtual int read() = 0;
+    // Read up to len bytes from the current packet and place them into buffer
+    // Returns the number of bytes read, or 0 if none are available
+    virtual int read(unsigned char *buffer, size_t len) = 0;
+    // Read up to len characters from the current packet and place them into buffer
+    // Returns the number of characters read, or 0 if none are available
+    virtual int read(char *buffer, size_t len) = 0;
+    // Return the next byte from the current packet without moving on to the next byte
+    virtual int peek() = 0;
+    virtual void flush() = 0; // Finish reading the current packet
+
+    // Return the IP address of the host who sent the current incoming packet
+    virtual IPAddress remoteIP() = 0;
+    // Return the port of the host who sent the current incoming packet
+    virtual uint16_t remotePort() = 0;
+  protected:
+    uint8_t *rawIPAddress(IPAddress &addr) {
+      return addr.raw_address();
+    };
+};

fw/HackSpaceCon_AS7/Arduino/megatinycore/api/WCharacter.h

@@ -0,0 +1,152 @@
+/*
+  WCharacter.h - Character utility functions for Wiring & Arduino
+  Copyright (c) 2010 Hernando Barragan.  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 Character_h
+#define Character_h
+
+#include <ctype.h>
+
+// WCharacter.h prototypes
+inline bool isAlphaNumeric(int c) __attribute__((always_inline));
+inline bool isAlpha(int c) __attribute__((always_inline));
+inline bool isAscii(int c) __attribute__((always_inline));
+inline bool isWhitespace(int c) __attribute__((always_inline));
+inline bool isControl(int c) __attribute__((always_inline));
+inline bool isDigit(int c) __attribute__((always_inline));
+inline bool isGraph(int c) __attribute__((always_inline));
+inline bool isLowerCase(int c) __attribute__((always_inline));
+inline bool isPrintable(int c) __attribute__((always_inline));
+inline bool isPunct(int c) __attribute__((always_inline));
+inline bool isSpace(int c) __attribute__((always_inline));
+inline bool isUpperCase(int c) __attribute__((always_inline));
+inline bool isHexadecimalDigit(int c) __attribute__((always_inline));
+inline int toAscii(int c) __attribute__((always_inline));
+inline int toLowerCase(int c) __attribute__((always_inline));
+inline int toUpperCase(int c)__attribute__((always_inline));
+
+
+// Checks for an alphanumeric character.
+// It is equivalent to (isalpha(c) || isdigit(c)).
+inline bool isAlphaNumeric(int c) {
+  return (isalnum(c) == 0 ? false : true);
+}
+
+
+// Checks for an alphabetic character.
+// It is equivalent to (isupper(c) || islower(c)).
+inline bool isAlpha(int c) {
+  return (isalpha(c) == 0 ? false : true);
+}
+
+
+// Checks whether c is a 7-bit unsigned char value
+// that fits into the ASCII character set.
+inline bool isAscii(int c) {
+  return (isascii(c) == 0 ? false : true);
+}
+
+
+// Checks for a blank character, that is, a space or a tab.
+inline bool isWhitespace(int c) {
+  return (isblank(c) == 0 ? false : true);
+}
+
+
+// Checks for a control character.
+inline bool isControl(int c) {
+  return (iscntrl(c) == 0 ? false : true);
+}
+
+
+// Checks for a digit (0 through 9).
+inline bool isDigit(int c) {
+  return (isdigit(c) == 0 ? false : true);
+}
+
+
+// Checks for any printable character except space.
+inline bool isGraph(int c) {
+  return (isgraph(c) == 0 ? false : true);
+}
+
+
+// Checks for a lower-case character.
+inline bool isLowerCase(int c) {
+  return (islower(c) == 0 ? false : true);
+}
+
+
+// Checks for any printable character including space.
+inline bool isPrintable(int c) {
+  return (isprint(c) == 0 ? false : true);
+}
+
+
+// Checks for any printable character which is not a space
+// or an alphanumeric character.
+inline bool isPunct(int c) {
+  return (ispunct(c) == 0 ? false : true);
+}
+
+
+// Checks for white-space characters. For the avr-libc library,
+// these are: space, formfeed ('\f'), newline ('\n'), carriage
+// return ('\r'), horizontal tab ('\t'), and vertical tab ('\v').
+inline bool isSpace(int c) {
+  return (isspace(c) == 0 ? false : true);
+}
+
+
+// Checks for an uppercase letter.
+inline bool isUpperCase(int c) {
+  return (isupper(c) == 0 ? false : true);
+}
+
+
+// Checks for a hexadecimal digits, i.e. one of 0 1 2 3 4 5 6 7
+// 8 9 a b c d e f A B C D E F.
+inline bool isHexadecimalDigit(int c) {
+  return (isxdigit(c) == 0 ? false : true);
+}
+
+
+// Converts c to a 7-bit unsigned char value that fits into the
+// ASCII character set, by clearing the high-order bits.
+inline int toAscii(int c) {
+  return toascii(c);
+}
+
+
+// Warning:
+// Many people will be unhappy if you use this function.
+// This function will convert accented letters into random
+// characters.
+
+// Converts the letter c to lower case, if possible.
+inline int toLowerCase(int c) {
+  return tolower(c);
+}
+
+
+// Converts the letter c to upper case, if possible.
+inline int toUpperCase(int c) {
+  return toupper(c);
+}
+
+#endif

fw/HackSpaceCon_AS7/Arduino/megatinycore/api/deprecated-avr-comp/avr/dtostrf.c.impl

@@ -0,0 +1,36 @@
+/*
+  dtostrf - Emulation for dtostrf function from avr-libc
+  Copyright (c) 2016 Arduino LLC.  All rights 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
+*/
+
+// This is a default implementation for dtostrf function.
+// This file should be used if the standard lib doesn't provide an
+// implementation of dtostrf.
+
+// Create a file called "dtostrf.c" with the following include:
+// #include "api/deprecated-avr-comp/avr/dtostrf.c.impl"
+
+#include <stdio.h>
+
+char *dtostrf (double val, signed char width, unsigned char prec, char *sout) {
+  asm(".global _printf_float");
+
+  char fmt[20];
+  sprintf(fmt, "%%%d.%df", width, prec);
+  sprintf(sout, fmt, val);
+  return sout;
+}

fw/HackSpaceCon_AS7/Arduino/megatinycore/api/deprecated-avr-comp/avr/dtostrf.h

@@ -0,0 +1,34 @@
+/*
+  dtostrf - Emulation for dtostrf function from avr-libc
+  Copyright (c) 2015 Arduino LLC.  All rights 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
+*/
+
+#pragma once
+
+#if !defined(ARDUINO_ARCH_AVR)
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+char *dtostrf(double val, signed char width, unsigned char prec, char *sout);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

fw/HackSpaceCon_AS7/Arduino/megatinycore/api/deprecated-avr-comp/avr/interrupt.h

@@ -0,0 +1,23 @@
+/*
+  Copyright (c) 2015 Arduino LCC.  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
+*/
+
+/*
+  Empty file.
+  This file is here to allow compatibility with sketches (made for AVR)
+  that includes <AVR/interrupt.h>
+*/

fw/HackSpaceCon_AS7/Arduino/megatinycore/api/deprecated-avr-comp/avr/pgmspace.h

@@ -0,0 +1,122 @@
+/*
+  pgmspace.h - Definitions for compatibility with AVR pgmspace macros
+
+  Copyright (c) 2015 Arduino LLC
+
+  Based on work of Paul Stoffregen on Teensy 3 (http://pjrc.com)
+
+  Permission is hereby granted, free of charge, to any person obtaining a copy
+  of this software and associated documentation files (the "Software"), to deal
+  in the Software without restriction, including without limitation the rights
+  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+  copies of the Software, and to permit persons to whom the Software is
+  furnished to do so, subject to the following conditions:
+
+  The above copyright notice and this permission notice shall be included in
+  all copies or substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+  THE SOFTWARE
+*/
+
+#ifndef __PGMSPACE_H_
+#define __PGMSPACE_H_ 1
+
+#include <inttypes.h>
+
+#define PROGMEM
+#define PGM_P  const char *
+#define PSTR(str) (str)
+
+#define _SFR_BYTE(n) (n)
+
+typedef void prog_void;
+typedef char prog_char;
+typedef unsigned char prog_uchar;
+typedef int8_t prog_int8_t;
+typedef uint8_t prog_uint8_t;
+typedef int16_t prog_int16_t;
+typedef uint16_t prog_uint16_t;
+typedef int32_t prog_int32_t;
+typedef uint32_t prog_uint32_t;
+typedef int64_t prog_int64_t;
+typedef uint64_t prog_uint64_t;
+
+typedef const void *int_farptr_t;
+typedef const void *uint_farptr_t;
+
+#define memchr_P(s, c, n) memchr((s), (c), (n))
+#define memcmp_P(s1, s2, n) memcmp((s1), (s2), (n))
+#define memccpy_P(dest, src, c, n) memccpy((dest), (src), (c), (n))
+#define memcpy_P(dest, src, n) memcpy((dest), (src), (n))
+#define memmem_P(haystack, haystacklen, needle, needlelen) memmem((haystack), (haystacklen), (needle), (needlelen))
+#define memrchr_P(s, c, n) memrchr((s), (c), (n))
+#define strcat_P(dest, src) strcat((dest), (src))
+#define strchr_P(s, c) strchr((s), (c))
+#define strchrnul_P(s, c) strchrnul((s), (c))
+#define strcmp_P(a, b) strcmp((a), (b))
+#define strcpy_P(dest, src) strcpy((dest), (src))
+#define strcasecmp_P(s1, s2) strcasecmp((s1), (s2))
+#define strcasestr_P(haystack, needle) strcasestr((haystack), (needle))
+#define strcspn_P(s, accept) strcspn((s), (accept))
+#define strlcat_P(s1, s2, n) strlcat((s1), (s2), (n))
+#define strlcpy_P(s1, s2, n) strlcpy((s1), (s2), (n))
+#define strlen_P(a) strlen((a))
+#define strnlen_P(s, n) strnlen((s), (n))
+#define strncmp_P(s1, s2, n) strncmp((s1), (s2), (n))
+#define strncasecmp_P(s1, s2, n) strncasecmp((s1), (s2), (n))
+#define strncat_P(s1, s2, n) strncat((s1), (s2), (n))
+#define strncpy_P(s1, s2, n) strncpy((s1), (s2), (n))
+#define strpbrk_P(s, accept) strpbrk((s), (accept))
+#define strrchr_P(s, c) strrchr((s), (c))
+#define strsep_P(sp, delim) strsep((sp), (delim))
+#define strspn_P(s, accept) strspn((s), (accept))
+#define strstr_P(a, b) strstr((a), (b))
+#define strtok_P(s, delim) strtok((s), (delim))
+#define strtok_rP(s, delim, last) strtok((s), (delim), (last))
+
+#define strlen_PF(a) strlen((a))
+#define strnlen_PF(src, len) strnlen((src), (len))
+#define memcpy_PF(dest, src, len) memcpy((dest), (src), (len))
+#define strcpy_PF(dest, src) strcpy((dest), (src))
+#define strncpy_PF(dest, src, len) strncpy((dest), (src), (len))
+#define strcat_PF(dest, src) strcat((dest), (src))
+#define strlcat_PF(dest, src, len) strlcat((dest), (src), (len))
+#define strncat_PF(dest, src, len) strncat((dest), (src), (len))
+#define strcmp_PF(s1, s2) strcmp((s1), (s2))
+#define strncmp_PF(s1, s2, n) strncmp((s1), (s2), (n))
+#define strcasecmp_PF(s1, s2) strcasecmp((s1), (s2))
+#define strncasecmp_PF(s1, s2, n) strncasecmp((s1), (s2), (n))
+#define strstr_PF(s1, s2) strstr((s1), (s2))
+#define strlcpy_PF(dest, src, n) strlcpy((dest), (src), (n))
+#define memcmp_PF(s1, s2, n) memcmp((s1), (s2), (n))
+
+#define sprintf_P(s, f, ...) sprintf((s), (f), __VA_ARGS__)
+#define snprintf_P(s, f, ...) snprintf((s), (f), __VA_ARGS__)
+
+#define pgm_read_byte(addr) (*(const unsigned char *)(addr))
+#define pgm_read_word(addr) (*(const unsigned short *)(addr))
+#define pgm_read_dword(addr) (*(const unsigned long *)(addr))
+#define pgm_read_float(addr) (*(const float *)(addr))
+#define pgm_read_ptr(addr) (*(const void *)(addr))
+
+#define pgm_read_byte_near(addr) pgm_read_byte(addr)
+#define pgm_read_word_near(addr) pgm_read_word(addr)
+#define pgm_read_dword_near(addr) pgm_read_dword(addr)
+#define pgm_read_float_near(addr) pgm_read_float(addr)
+#define pgm_read_ptr_near(addr) pgm_read_ptr(addr)
+
+#define pgm_read_byte_far(addr) pgm_read_byte(addr)
+#define pgm_read_word_far(addr) pgm_read_word(addr)
+#define pgm_read_dword_far(addr) pgm_read_dword(addr)
+#define pgm_read_float_far(addr) pgm_read_float(addr)
+#define pgm_read_ptr_far(addr) pgm_read_ptr(addr)
+
+#define pgm_get_far_address(addr) (&(addr))
+
+#endif

fw/HackSpaceCon_AS7/Arduino/megatinycore/api/deprecated/Client.h

@@ -0,0 +1,23 @@
+/*
+  Copyright (c) 2016 Arduino LLC.  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
+*/
+
+// including Client.h is deprecated, for all future projects use Arduino.h instead
+
+// This include is added for compatibility, it will be remove on the next
+// major release of the API
+#include "../Client.h"

fw/HackSpaceCon_AS7/Arduino/megatinycore/api/deprecated/IPAddress.h

@@ -0,0 +1,23 @@
+/*
+  Copyright (c) 2016 Arduino LLC.  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
+*/
+
+// including IPAddress.h is deprecated, for all future projects use Arduino.h instead
+
+// This include is added for compatibility, it will be remove on the next
+// major release of the API
+#include "../IPAddress.h"

fw/HackSpaceCon_AS7/Arduino/megatinycore/api/deprecated/Print.h

@@ -0,0 +1,23 @@
+/*
+  Copyright (c) 2016 Arduino LLC.  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
+*/
+
+// including Print.h is deprecated, for all future projects use Arduino.h instead
+
+// This include is added for compatibility, it will be remove on the next
+// major release of the API
+#include "../Print.h"

fw/HackSpaceCon_AS7/Arduino/megatinycore/api/deprecated/Printable.h

@@ -0,0 +1,23 @@
+/*
+  Copyright (c) 2016 Arduino LLC.  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
+*/
+
+// including Printable.h is deprecated, for all future projects use Arduino.h instead
+
+// This include is added for compatibility, it will be remove on the next
+// major release of the API
+#include "../Printable.h"

fw/HackSpaceCon_AS7/Arduino/megatinycore/api/deprecated/Server.h

@@ -0,0 +1,23 @@
+/*
+  Copyright (c) 2016 Arduino LLC.  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
+*/
+
+// including Server.h is deprecated, for all future projects use Arduino.h instead
+
+// This include is added for compatibility, it will be remove on the next
+// major release of the API
+#include "../Server.h"

fw/HackSpaceCon_AS7/Arduino/megatinycore/api/deprecated/Stream.h

@@ -0,0 +1,23 @@
+/*
+  Copyright (c) 2016 Arduino LLC.  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
+*/
+
+// including Stream.h is deprecated, for all future projects use Arduino.h instead
+
+// This include is added for compatibility, it will be remove on the next
+// major release of the API
+#include "../Stream.h"

fw/HackSpaceCon_AS7/Arduino/megatinycore/api/deprecated/Udp.h

@@ -0,0 +1,23 @@
+/*
+  Copyright (c) 2016 Arduino LLC.  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
+*/
+
+// including Udp.h is deprecated, for all future projects use Arduino.h instead
+
+// This include is added for compatibility, it will be remove on the next
+// major release of the API
+#include "../Udp.h"

fw/HackSpaceCon_AS7/Arduino/megatinycore/api/deprecated/WString.h

@@ -0,0 +1,23 @@
+/*
+  Copyright 2016, Arduino LLC.  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
+*/
+
+// including WString.h is deprecated, for all future projects use Arduino.h instead
+
+// This include is added for compatibility, it will be remove on the next
+// major release of the API
+#include "../String.h"

fw/HackSpaceCon_AS7/Arduino/megatinycore/api/itoa.h

@@ -0,0 +1,36 @@
+/*
+  Copyright (c) 2016 Arduino LLC.  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
+*/
+
+#pragma once
+
+// Standard C functions required in Arduino API
+// If these functions are not provided by the standard library, the
+// core should supply an implementation of them.
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern char *itoa(int value, char *string, int radix);
+extern char *ltoa(long value, char *string, int radix);
+extern char *utoa(unsigned value, char *string, int radix);
+extern char *ultoa(unsigned long value, char *string, int radix);
+
+#ifdef __cplusplus
+} // extern "C"
+#endif