added denpendecies and base firmware

firmware/lib/Automaton-1.0.2/.clang-format

@@ -0,0 +1,7 @@
+Language:        Cpp
+BasedOnStyle: Google
+IndentWidth: 2
+UseTab:          Never
+ColumnLimit:     160
+SpacesInParentheses: true
+AllowShortFunctionsOnASingleLine: false

firmware/lib/Automaton-1.0.2/.gitignore

@@ -0,0 +1,4 @@
+*.hex
+*.swp
+*.dox
+.development

firmware/lib/Automaton-1.0.2/LICENSE

@@ -0,0 +1,24 @@
+
+
+The MIT License (MIT)
+
+Copyright (c) 2015-2016, J.P. van der Landen
+
+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.
+

firmware/lib/Automaton-1.0.2/README.md

@@ -0,0 +1,5 @@
+# Automaton
+
+Automaton - Reactive State Machine Framework for Arduino
+
+Read the [Wiki](https://github.com/tinkerspy/Automaton/wiki) for more information.

firmware/lib/Automaton-1.0.2/examples/blink/blink.ino

@@ -0,0 +1,58 @@
+#include <Automaton.h>
+
+class Atm_blink : public Machine {
+
+  public:
+    Atm_blink( void ) : Machine() {};
+
+    short pin;
+    atm_timer_millis timer;
+
+    enum { IDLE, LED_ON, LED_OFF }; // STATES
+    enum { EVT_TIMER, EVT_ON, EVT_OFF, ELSE }; // EVENTS
+    enum { ENT_ON, ENT_OFF }; // ACTIONS
+
+    Atm_blink & begin( int attached_pin, uint32_t blinkrate ) {
+      const static state_t state_table[] PROGMEM = {
+        /*            ON_ENTER    ON_LOOP  ON_EXIT  EVT_TIMER  EVT_ON  EVT_OFF  ELSE */
+        /* IDLE    */  ENT_OFF,        -1,      -1,        -1, LED_ON,      -1,   -1,
+        /* LED_ON  */   ENT_ON,        -1,      -1,   LED_OFF,     -1,    IDLE,   -1,
+        /* LED_OFF */  ENT_OFF,        -1,      -1,    LED_ON,     -1,    IDLE,   -1,
+      };
+      Machine::begin( state_table, ELSE );
+      pin = attached_pin;
+      timer.set( blinkrate );
+      pinMode( pin, OUTPUT );
+      return *this;
+    }
+
+    int event( int id ) {
+      switch ( id ) {
+        case EVT_TIMER :
+          return timer.expired( this );
+      }
+      return 0;
+    }
+
+    void action( int id ) {
+      switch ( id ) {
+        case ENT_ON :
+          digitalWrite( pin, HIGH );
+          return;
+        case ENT_OFF :
+          digitalWrite( pin, LOW );
+          return;
+      }
+    }
+};
+
+Atm_blink led;
+
+void setup() {
+  led.begin( 4, 200 );        // Setup a blink machine on pin 4
+  led.trigger( led.EVT_ON );  // Turn it on
+}
+
+void loop() {
+  led.cycle();
+}

firmware/lib/Automaton-1.0.2/examples/blink_modular/Atm_blink.cpp

@@ -0,0 +1,42 @@
+#include "Atm_blink.h"
+	
+Atm_blink & Atm_blink::begin( int attached_pin, uint32_t blinkrate ) {
+  const static state_t state_table[] PROGMEM = {
+    /*            ON_ENTER    ON_LOOP  ON_EXIT  EVT_TIMER  EVT_ON  EVT_OFF  ELSE */
+    /* IDLE    */  ENT_OFF,        -1,      -1,        -1, LED_ON,      -1,   -1,
+    /* LED_ON  */   ENT_ON,        -1,      -1,   LED_OFF,     -1,    IDLE,   -1,
+    /* LED_OFF */  ENT_OFF,        -1,      -1,    LED_ON,     -1,    IDLE,   -1,
+  };
+  Machine::begin( state_table, ELSE );
+  pin = attached_pin; 
+  timer.set( blinkrate ); 
+  pinMode( pin, OUTPUT ); 
+  return *this;          
+}
+
+int Atm_blink::event( int id ) {
+  switch ( id ) {
+  	case EVT_TIMER :
+  	  return timer.expired( this );        
+   }
+   return 0;
+}
+
+void Atm_blink::action( int id ) {
+  switch ( id ) {
+  	case ENT_ON :
+  	  digitalWrite( pin, HIGH );
+  	  return;
+  	case ENT_OFF :
+  	  digitalWrite( pin, LOW );
+  	  return;
+   }
+}
+
+Atm_blink & Atm_blink::trace( Stream & stream ) {
+  Machine::setTrace( &stream, atm_serial_debug::trace,
+    "BLINK\0EVT_TIMER\0EVT_ON\0EVT_OFF\0ELSE\0IDLE\0LED_ON\0LED_OFF" );
+  return *this;
+}
+
+

firmware/lib/Automaton-1.0.2/examples/blink_modular/Atm_blink.h

@@ -0,0 +1,21 @@
+#pragma once
+
+#include <Automaton.h>
+
+class Atm_blink: public Machine {
+
+  public:
+    Atm_blink( void ) : Machine() {};
+
+    short pin;     
+    atm_timer_millis timer;
+
+    enum { IDLE, LED_ON, LED_OFF }; // STATES
+    enum { EVT_TIMER, EVT_ON, EVT_OFF, ELSE }; // EVENTS
+    enum { ENT_ON, ENT_OFF }; // ACTIONS
+	
+    Atm_blink & begin( int attached_pin, uint32_t blinkrate );
+    Atm_blink & trace( Stream & stream );
+    int event( int id ); 
+    void action( int id ); 
+};

firmware/lib/Automaton-1.0.2/examples/blink_modular/blink_modular.ino

@@ -0,0 +1,14 @@
+#include <Automaton.h>
+#include "Atm_blink.h"
+
+Atm_blink led;
+
+void setup() {
+  led.begin( 4, 200 );        // Setup a blink machine on pin 4
+  led.trigger( led.EVT_ON );  // Turn it on
+}
+
+void loop() {
+  automaton.run();
+}
+

firmware/lib/Automaton-1.0.2/examples/button/button.ino

@@ -0,0 +1,34 @@
+#include <Automaton.h>
+
+// Start by creating a bunch of state machines
+
+Atm_led led1, led2, led3; // Three Automaton led machines
+Atm_button btn; // An Automaton button machine
+Atm_fan fan; // To split the trigger in 3
+
+void setup() {
+  // Initialize the led machines at different rates
+  led1.begin( 4 ).blink( 100, 100 );
+  led2.begin( 5 ).blink( 200, 200 );
+  led3.begin( 6 ).blink( 400, 400 );
+
+  // Send one event to many
+  fan.begin()
+    .onInput( led1, led1.EVT_TOGGLE_BLINK )
+    .onInput( led2, led2.EVT_TOGGLE_BLINK )
+    .onInput( led3, led3.EVT_TOGGLE_BLINK );
+      
+  // Button triggers the fan
+  btn.begin( 2 ) 
+    .onPress( fan, fan.EVT_INPUT );
+  
+  // Start the blinking
+  fan.trigger( fan.EVT_INPUT );
+}
+
+// Run the app from the Arduino loop()
+// Press the button to toggle the leds on and off
+
+void loop() {
+  automaton.run();
+}

firmware/lib/Automaton-1.0.2/examples/fade/fade.ino

@@ -0,0 +1,18 @@
+#include <Automaton.h>
+
+int led1Pin = 5;
+int led2Pin = 6;
+
+Atm_fade led1, led2;
+
+void setup() {
+  led1.begin( led1Pin ).blink( 200 ).fade( 5 );
+  led2.begin( led2Pin ).blink( 500 ).fade( 10 );
+  led1.start();
+  led2.start();
+}
+
+void loop() {
+  led1.cycle();
+  led2.cycle();
+}

firmware/lib/Automaton-1.0.2/examples/frere_jacques/frere_jacques.ino

@@ -0,0 +1,39 @@
+#include <Automaton.h>
+#include "musical_notes.h"
+
+// Playback 'Frere Jacques' with button trigger and speed control 
+
+Atm_player player;
+Atm_button button;
+Atm_analog speed;
+
+int pattern[] = { 
+  _G4, _N04, 0, _A4, _N04, 0, _B4, _N04, 0, _G4, _N04, 0, // Frere Jacques
+  _G4, _N04, 0, _A4, _N04, 0, _B4, _N04, 0, _G4, _N04, 0, 
+  _B4, _N04, 0, _C5, _N04, 0, _D5, _N04, _N04, // Dormez vous?
+  _B4, _N04, 0, _C5, _N04, 0, _D5, _N04, _N04, 
+  _D5, _N08, 0, _E5, _N08, 0, _D5, _N08, 0, _C5, _N08, 0, _B4, _N04, 0, _G4, _N04, 0, // Sonnez les matines 
+  _D5, _N08, 0, _E5, _N08, 0, _D5, _N08, 0, _C5, _N08, 0, _B4, _N04, 0, _G4, _N04, 0, 
+  _G4, _N04, 0, _D4, _N04, 0, _G4, _N04, _N04, // Ding dang dong
+  _G4, _N04, 0, _D4, _N04, 0, _G4, _N04, _N04,
+};
+
+void setup() {
+  player.begin( 19 ) // A passive buzzer or speaker on pin 19
+    .play( pattern, sizeof( pattern ) )
+    .repeat( -1 );
+
+  button.begin( 2 ) // A button on pin 2 toggles playback on and off
+    .onPress( player, player.EVT_TOGGLE );
+
+  speed.begin( A0 ) // An analog pot on pin A0 controls playback speed
+    .range( 50, 300 ) // From 50% to 300% of original speed
+    .onChange( []( int idx, int v, int up ) {
+      player.speed( v );    
+    });
+}
+
+void loop() {
+  automaton.run();
+}
+

firmware/lib/Automaton-1.0.2/examples/frere_jacques/musical_notes.h

@@ -0,0 +1,77 @@
+#pragma once
+
+// Note durations in milliseconds
+
+#define _N01 1600 
+#define _N02 800  
+#define _N04 400  
+#define _N08 200  
+#define _N16 100  
+
+// Tone frequencies
+
+#define _C3  130
+#define _Db3 138
+#define _D3  146
+#define _Eb3 155
+#define _E3  164
+#define _F3  174
+#define _Gb3 185
+#define _G3  196
+#define _Ab3 207
+#define _A3  220
+#define _Bb3 233
+#define _B3  246
+
+#define _C4  261
+#define _Db4 277
+#define _D4  293
+#define _Eb4 311
+#define _E4  329
+#define _F4  349
+#define _Gb4 369
+#define _G4  392
+#define _Ab4 415
+#define _A4  440
+#define _Bb4 466
+#define _B4  493
+
+#define _C5  523
+#define _Db5 544
+#define _D5  587
+#define _Eb5 622
+#define _E5  659
+#define _F5  698
+#define _Gb5 739
+#define _G5  783
+#define _Ab5 830
+#define _A5  880
+#define _Bb5 932
+#define _B5  987
+
+#define _C6  1046
+#define _Db6 1108
+#define _D6  1174
+#define _Eb6 1244
+#define _E6  1318
+#define _F6  1396
+#define _Gb6 1479
+#define _G6  1567
+#define _Ab6 1661
+#define _A6  1760
+#define _Bb6 1864
+#define _B6  1975
+
+#define _C7  2093
+#define _Db7 2217
+#define _D7  2349
+#define _Eb7 2489
+#define _E7  2637
+#define _F7  2794
+#define _Gb7 2960
+#define _G7  3136
+#define _Ab7 3322
+#define _A7  3520
+#define _Bb7 3729
+#define _B7  3951
+

firmware/lib/Automaton-1.0.2/examples/knight_rider1/knight_rider1.ino

@@ -0,0 +1,46 @@
+#include <Automaton.h>
+
+Atm_led led[6];
+Atm_timer timer;
+Atm_step step;
+Atm_analog pot;
+
+// Timer drives step sequencer in sweep mode, step sequencer blinks leds.
+
+short event = Atm_led::EVT_BLINK;
+static short pin_list[] = { 4, 5, 6, 7, 8, 9 };
+int blink_time = 70;
+int interval_time = 50;
+
+void setup() {
+  // Initialize the step sequencer
+
+  step.begin()
+    .trigger( Atm_step::EVT_SWEEP );
+      
+  // Add the timer
+  timer.begin( interval_time )
+    .onTimer( step, Atm_step::EVT_STEP )
+    .repeat( ATM_COUNTER_OFF );
+  
+  // Add the leds and link them to the step sequencer
+  for ( short i = 0; i <= 5; i++ ) {
+    led[i].begin( pin_list[i] )
+      .blink( blink_time, 1, 1 ); 
+    step.onStep( i, led[i], event );
+  }
+
+  pot.begin( A0 )
+    .range( 10, 200 )
+    .onChange( [] ( int idx, int v, int up ) {
+      timer.interval( v );
+    });
+      
+  // Move last led from step 5 to step 7 to make sweep work properly!
+  step.onStep( 5 ).onStep( 9, led[5], event );
+  timer.start();
+}
+
+void loop() {
+  automaton.run();
+}

firmware/lib/Automaton-1.0.2/examples/knight_rider2/Atm_sweep.cpp

@@ -0,0 +1,65 @@
+#include <Automaton.h>
+#include "Atm_sweep.h"
+
+Atm_sweep & Atm_sweep::begin( int p0, int p1, int p2, int p3, int p4, int p5 ) {
+  const static state_t state_table[] PROGMEM = {
+    /*          ON_ENTER    ON_LOOP  ON_EXIT  EVT_TIMER   EVT_START  EVT_STOP  EVT_TOGGLE, ELSE */
+    /* IDLE  */  ENT_OFF, ATM_SLEEP,      -1,        -1,         U0,     IDLE,         U0,   -1,
+    /* U0    */   ENT_L0,        -1, ENT_OFF,        U1,         -1,     IDLE,       IDLE,   -1,
+    /* U1    */   ENT_L1,        -1, ENT_OFF,        U2,         -1,     IDLE,       IDLE,   -1,
+    /* U2    */   ENT_L2,        -1, ENT_OFF,        U3,         -1,     IDLE,       IDLE,   -1,
+    /* U3    */   ENT_L3,        -1, ENT_OFF,        U4,         -1,     IDLE,       IDLE,   -1,
+    /* U4    */   ENT_L4,        -1, ENT_OFF,        U5,         -1,     IDLE,       IDLE,   -1,
+    /* U5    */   ENT_L5,        -1, ENT_OFF,        D4,         -1,     IDLE,       IDLE,   -1,
+    /* D4    */   ENT_L4,        -1, ENT_OFF,        D3,         -1,     IDLE,       IDLE,   -1,
+    /* D3    */   ENT_L3,        -1, ENT_OFF,        D2,         -1,     IDLE,       IDLE,   -1,
+    /* D2    */   ENT_L2,        -1, ENT_OFF,        D1,         -1,     IDLE,       IDLE,   -1,
+    /* D1    */   ENT_L1,        -1, ENT_OFF,        D0,         -1,     IDLE,       IDLE,   -1,
+    /* D0    */   ENT_L0,        -1, ENT_OFF,        U0,         -1,     IDLE,       IDLE,   -1,
+  };
+  Machine::begin( state_table, ELSE );
+  pin[0] = p0;  pin[1] = p1;  pin[2] = p2;
+  pin[3] = p3;  pin[4] = p4;  pin[5] = p5;
+  timer.set( 200 );
+  for ( uint8_t i = 0; i <= 5; i++ ) {
+    pinMode( pin[i], OUTPUT );
+  }
+  return *this;
+}
+
+Atm_sweep & Atm_sweep::speed( uint32_t v ) {
+  timer.set( v );
+  return *this;
+}
+
+int Atm_sweep::event( int id ) {
+  switch ( id ) {
+    case EVT_TIMER :
+      return timer.expired( this );
+  }
+  return 0;
+}
+
+void Atm_sweep::action( int id ) {
+  switch ( id ) {
+    case ENT_L0 : return digitalWrite( pin[0], HIGH );
+    case ENT_L1 : return digitalWrite( pin[1], HIGH );
+    case ENT_L2 : return digitalWrite( pin[2], HIGH );
+    case ENT_L3 : return digitalWrite( pin[3], HIGH );
+    case ENT_L4 : return digitalWrite( pin[4], HIGH );
+    case ENT_L5 : return digitalWrite( pin[5], HIGH );
+    case ENT_OFF :
+      for ( uint8_t i = 0; i <= 5; i++ ) {
+        digitalWrite( pin[i], LOW );
+      }
+      return;
+  }
+}
+
+Atm_sweep & Atm_sweep::trace( Stream & stream ) {
+  Machine::setTrace( &stream, atm_serial_debug::trace,
+       "SWEEP\0EVT_TIMER\0EVT_START\0EVT_STOP\0ELSE\0"
+       "IDLE\0U0\0U1\0U2\0U3\0U4\0U5\0D4\0D3\0D2\0D1\0D0" );
+  return *this;
+}
+

firmware/lib/Automaton-1.0.2/examples/knight_rider2/Atm_sweep.h

@@ -0,0 +1,24 @@
+#pragma once
+
+#include <Automaton.h>
+
+class Atm_sweep: public Machine {
+
+  public:
+    Atm_sweep( void ) : Machine() {};
+
+    enum { IDLE, U0, U1, U2, U3, U4, U5, D4, D3, D2, D1, D0 };
+    enum { EVT_TIMER, EVT_START, EVT_STOP, EVT_TOGGLE, ELSE };
+    enum { ENT_L0, ENT_L1, ENT_L2, ENT_L3, ENT_L4, ENT_L5, ENT_OFF  };
+
+    Atm_sweep & begin( int p1, int p2, int p3, int p4, int p5, int p6 );
+    Atm_sweep & speed( uint32_t v );
+    Atm_sweep & trace( Stream & stream );
+    
+  private:  
+    short pin[6];
+    atm_timer_millis timer;
+
+    int event( int id );
+    void action( int id );
+};

firmware/lib/Automaton-1.0.2/examples/knight_rider2/knight_rider2.ino

@@ -0,0 +1,20 @@
+#include <Automaton.h>
+#include "Atm_sweep.h"
+
+Atm_sweep sweep;
+Atm_button button;
+
+void setup() {
+
+  sweep.begin( 4, 5, 6, 7, 8, 9 )
+    .speed( 50 ) 
+    .trigger( sweep.EVT_START );
+
+  button.begin( 2 )
+    .onPress( sweep, sweep.EVT_TOGGLE );
+      
+}
+
+void loop() {
+  automaton.run();
+}

firmware/lib/Automaton-1.0.2/examples/knight_rider3/knight_rider3.ino

@@ -0,0 +1,37 @@
+#include <Automaton.h>
+
+Atm_player player; // A player machine
+
+const int ledPinMin = 4; // Use pins 4..9
+const int ledPinMax = 9; 
+
+int pattern[] = {  // Bitmapped pattern
+  B00100000, 100, 0, 
+  B00010000, 100, 0, 
+  B00001000, 100, 0, 
+  B00000100, 100, 0, 
+  B00000010, 100, 0, 
+  B00000001, 100, 0, 
+  B00000010, 100, 0, 
+  B00000100, 100, 0, 
+  B00001000, 100, 0, 
+  B00010000, 100, 0, 
+};
+
+void setup() {
+  player.begin() 
+    .play( pattern, sizeof( pattern ) ) //  Set up the pattern
+    .onNote( true, []( int idx, int v, int up ) { // Called on every note
+      for ( int i = ledPinMin; i <= ledPinMax; i++ ) {
+        pinMode( i, OUTPUT ); // LED on/off according to bit  
+        digitalWrite( i, v & ( 1 << ( i - ledPinMin ) ) ? HIGH : LOW ); 
+      }    
+    })
+    .repeat( -1 ) // Repeat forever
+    .start(); // Kickoff!
+}
+
+void loop() {
+  automaton.run();
+}
+

firmware/lib/Automaton-1.0.2/examples/led_fuel_gauge/led_fuel_gauge.ino

@@ -0,0 +1,28 @@
+#include <Automaton.h>
+
+// Turning a pot on A0 will change a led gauge on pins 4, 5, 6, 7, 8, 9
+
+Atm_comparator cmp;
+Atm_led led[6];
+Atm_step step;
+
+static uint16_t threshold_list[] = { 100, 300, 500, 700, 900, 1000 }; 
+static short pin_list[] = { 4, 5, 6, 7, 8, 9 };
+
+void setup() {
+    
+  cmp.begin( A0, 50 )
+    .threshold( threshold_list, sizeof( threshold_list ), true )
+    .onChange( true, step, Atm_step::EVT_STEP )
+    .onChange( false, step, Atm_step::EVT_BACK );
+      
+  step.begin();
+  for ( short i = 0; i <= 5; i++ ) {
+    led[i].begin( pin_list[i] );
+    step.onStep( i, led[i], Atm_led::EVT_TOGGLE );    
+  }
+}
+
+void loop() {
+  automaton.run();
+}

firmware/lib/Automaton-1.0.2/examples/led_test/led_test.ino

@@ -0,0 +1,25 @@
+#include <Automaton.h>
+
+// This example demonstrates running state machines logging their state changes to the serial port
+
+int ledPin = LED_BUILTIN;
+int buttonPin = 2;
+
+Atm_led led;
+Atm_button button;
+
+void setup() {
+  Serial.begin( 9600 );
+  led.trace( Serial );
+  button.trace( Serial );
+  
+  led.begin( ledPin )
+    .blink( 1000 ); 
+  
+  button.begin( buttonPin )
+    .onPress( led, led.EVT_TOGGLE );
+}
+
+void loop() {
+  automaton.run();
+}

firmware/lib/Automaton-1.0.2/examples/nuclear_missile_launcher/nuclear_missile_launcher.ino

@@ -0,0 +1,57 @@
+#include <Automaton.h>
+
+// Safe controller for a Nuclear Missile Launcher
+
+Atm_led countdown, ignition;
+Atm_button button1, button2;
+Atm_bit bit1, bit2;
+Atm_timer timer1, timer2;
+Atm_controller ctrl;
+
+const int pinButton1 = 2;
+const int pinButton2 = 3;
+const int pinCountdownLed = 8;
+const int pinIgnitionLed = 9;
+const int buttonIntervalMax = 2000;
+const int countdownCount = 10;
+const int countdownFlashOn = 100;
+const int countdownFlashOff = 900;
+
+void setup() {
+  // Self resetting button 1
+  button1.begin( pinButton1 )
+    .onPress( bit1, bit1.EVT_ON );
+
+  timer1.begin( buttonIntervalMax )
+    .onTimer( bit1, bit1.EVT_OFF );
+
+  bit1.begin( false ).led( 4 )
+    .onChange( true, timer1, timer1.EVT_START );
+ 
+  // Self resetting button 2
+  button2.begin( pinButton2 )
+    .onPress( bit2, bit2.EVT_ON );
+
+  timer2.begin( buttonIntervalMax )
+    .onTimer( bit2, bit2.EVT_OFF );
+
+  bit2.begin( false ).led( 5 )
+    .onChange( true, timer2, timer2.EVT_START );
+      
+  // Controller
+  ctrl.begin( false )
+    .IF( bit1 ).AND( bit2 )
+    .onChange( true, countdown, countdown.EVT_BLINK );
+    
+  // Countdown led
+  countdown.begin( pinCountdownLed )
+    .blink( countdownFlashOn, countdownFlashOff, countdownCount )
+    .onFinish( ignition, ignition.EVT_ON );
+      
+  // Ignition
+  ignition.begin( pinIgnitionLed ); 
+}
+
+void loop() {
+  automaton.run();
+}

firmware/lib/Automaton-1.0.2/examples/sos1/sos1.ino

@@ -0,0 +1,33 @@
+#include <Automaton.h>
+
+Atm_led led;
+
+const int pin = 4;
+const int dotTime = 100;
+const int dashTime = 300;
+const int waitTime = 200;
+const int longwaitTime = 500;
+const int longerwaitTime = 1000;
+
+void setup() {
+  led.begin( pin );
+}
+
+void loop() {
+  // Set the led to blink 3 times and trigger it
+  led.blink( dotTime, waitTime, 3 ).start();
+  
+  // Loop until the blinking has finished
+  while ( led.cycle().state() ); 
+    
+  // Cycle idly for a while
+  led.cycle( longwaitTime );
+       
+  led.blink( dashTime, waitTime, 3 ).start();
+  while ( led.cycle().state() );
+  led.cycle( longwaitTime );  
+   
+  led.blink( dotTime, waitTime, 3 ).start();
+  while ( led.cycle().state() );
+  led.cycle( longerwaitTime );   
+}

firmware/lib/Automaton-1.0.2/examples/sos2/sos2.ino

@@ -0,0 +1,38 @@
+#include <Automaton.h>
+
+Atm_led dot, dash;
+Atm_timer stepTimer;
+Atm_step step;
+
+const int pin = 4;
+const int dotTime = 100;
+const int dashTime = 300;
+const int waitTime = 200;
+const int longwaitTime = 300;
+const int longerwaitTime = 1000;
+
+void setup() {
+  
+  // Define two leds (patterns)
+  dot.begin( pin ).blink(  dotTime, waitTime, 3 );
+  dash.begin( pin ).blink( dashTime, waitTime, 3 );
+  
+  // Define a timer
+  stepTimer.begin( 1700 ).repeat( ATM_COUNTER_OFF );
+  
+  // Define a step sequencer and link it to the leds we defined earlier
+  step.begin()
+    .onStep( 0,  dot, Atm_led::EVT_BLINK )
+    .onStep( 1, dash, Atm_led::EVT_BLINK )
+    .onStep( 2,  dot, Atm_led::EVT_BLINK );
+      
+  // Set up the timer to drive the step sequencer
+  stepTimer.onTimer( step, Atm_step::EVT_STEP );  
+  
+  // Start the timer
+  stepTimer.start();
+}
+
+void loop() {
+  automaton.run();
+}

firmware/lib/Automaton-1.0.2/examples/sos3/sos3.ino

@@ -0,0 +1,38 @@
+#include <Automaton.h>
+
+Atm_led led[3];
+Atm_timer timer[3];
+
+const int pin = 4;
+const int dotTime = 100;
+const int dashTime = 300;
+const int waitTime = 200;
+const int longwaitTime = 300;
+const int longerwaitTime = 1000;
+
+void setup() {
+
+  led[0].begin( pin )
+    .blink(  dotTime, waitTime, 3 ) 
+    .onFinish( timer[0], Atm_timer::EVT_START );
+  timer[0].begin( longwaitTime ) 
+    .onTimer( led[1], Atm_led::EVT_BLINK );
+
+  led[1].begin( pin )
+    .blink( dashTime, waitTime, 3 ) 
+    .onFinish( timer[1], Atm_timer::EVT_START );
+  timer[1].begin( longwaitTime )
+    .onTimer( led[2], Atm_led::EVT_BLINK );
+
+  led[2].begin( pin )
+    .blink(  dotTime, waitTime, 3 ) 
+    .onFinish( timer[2], Atm_timer::EVT_START );
+  timer[2].begin( longerwaitTime )
+    .onTimer( led[0], Atm_led::EVT_BLINK );    
+
+  led[0].start();
+}
+
+void loop() {
+  automaton.run();
+}

firmware/lib/Automaton-1.0.2/extras/update.sh

@@ -0,0 +1,12 @@
+#!/bin/sh -x
+
+clang-format -i src/*.h src/*.cpp src/*.hpp
+
+(
+chmod -x *.cpp *.hpp *.h *.ino
+chmod -x */*.cpp */*.hpp */*.h */*.ino
+chmod -x */*/*.cpp */*/*.hpp */*/*.h */*/*.ino
+) 2> /dev/null
+
+git add .
+

firmware/lib/Automaton-1.0.2/keywords.txt

@@ -0,0 +1,174 @@
+Atm_controller	KEYWORD1
+AND	KEYWORD2
+IF	KEYWORD2
+OR	KEYWORD2
+XOR	KEYWORD2
+begin	KEYWORD2
+led	KEYWORD2
+onChange	KEYWORD2
+onInput	KEYWORD2
+trace	KEYWORD2
+Atm_player	KEYWORD1
+begin	KEYWORD2
+onFinish	KEYWORD2
+onNote	KEYWORD2
+pitch	KEYWORD2
+play	KEYWORD2
+repeat	KEYWORD2
+speed	KEYWORD2
+start	KEYWORD2
+state	KEYWORD2
+stop	KEYWORD2
+toggle	KEYWORD2
+trace	KEYWORD2
+trigger	KEYWORD2
+atm_counter	KEYWORD1
+decrement	KEYWORD2
+expired	KEYWORD2
+set	KEYWORD2
+Atm_bit	KEYWORD1
+begin	KEYWORD2
+input	KEYWORD2
+led	KEYWORD2
+off	KEYWORD2
+on	KEYWORD2
+onChange	KEYWORD2
+onInput	KEYWORD2
+refresh	KEYWORD2
+toggle	KEYWORD2
+trace	KEYWORD2
+atm_connector::union ::	KEYWORD1
+atm_connector	KEYWORD1
+logOp	KEYWORD2
+mode	KEYWORD2
+pull	KEYWORD2
+push	KEYWORD2
+relOp	KEYWORD2
+set	KEYWORD2
+atm_connector::union 	KEYWORD1
+atm_connector::union ::::union 	KEYWORD1
+atm_serial_debug	KEYWORD1
+trace	KEYWORD2
+Atm_encoder	KEYWORD1
+begin	KEYWORD2
+onChange	KEYWORD2
+range	KEYWORD2
+set	KEYWORD2
+state	KEYWORD2
+trace	KEYWORD2
+Atm_timer	KEYWORD1
+begin	KEYWORD2
+interval	KEYWORD2
+interval_millis	KEYWORD2
+interval_seconds	KEYWORD2
+left	KEYWORD2
+onFinish	KEYWORD2
+onTimer	KEYWORD2
+repeat	KEYWORD2
+start	KEYWORD2
+stop	KEYWORD2
+toggle	KEYWORD2
+trace	KEYWORD2
+Atm_fade	KEYWORD1
+begin	KEYWORD2
+blink	KEYWORD2
+fade	KEYWORD2
+off	KEYWORD2
+on	KEYWORD2
+onFinish	KEYWORD2
+pause	KEYWORD2
+repeat	KEYWORD2
+start	KEYWORD2
+toggle	KEYWORD2
+toggleBlink	KEYWORD2
+trace	KEYWORD2
+atm_timer_millis	KEYWORD1
+expired	KEYWORD2
+set	KEYWORD2
+Atm_analog	KEYWORD1
+average	KEYWORD2
+begin	KEYWORD2
+onChange	KEYWORD2
+range	KEYWORD2
+set	KEYWORD2
+state	KEYWORD2
+trace	KEYWORD2
+Atm_comparator	KEYWORD1
+average	KEYWORD2
+begin	KEYWORD2
+onChange	KEYWORD2
+read_sample	KEYWORD2
+skip	KEYWORD2
+state	KEYWORD2
+threshold	KEYWORD2
+trace	KEYWORD2
+Automaton	KEYWORD1
+add	KEYWORD2
+delay	KEYWORD2
+run	KEYWORD2
+Appliance	KEYWORD1
+component	KEYWORD2
+run	KEYWORD2
+Factory	KEYWORD1
+add	KEYWORD2
+cycle	KEYWORD2
+Atm_fan	KEYWORD1
+begin	KEYWORD2
+onInput	KEYWORD2
+state	KEYWORD2
+trace	KEYWORD2
+trigger	KEYWORD2
+Atm_button	KEYWORD1
+autoPress	KEYWORD2
+begin	KEYWORD2
+debounce	KEYWORD2
+longPress	KEYWORD2
+onPress	KEYWORD2
+onRelease	KEYWORD2
+repeat	KEYWORD2
+trace	KEYWORD2
+Atm_command	KEYWORD1
+arg	KEYWORD2
+begin	KEYWORD2
+list	KEYWORD2
+lookup	KEYWORD2
+onCommand	KEYWORD2
+separator	KEYWORD2
+trace	KEYWORD2
+Atm_digital	KEYWORD1
+begin	KEYWORD2
+led	KEYWORD2
+onChange	KEYWORD2
+state	KEYWORD2
+trace	KEYWORD2
+Machine	KEYWORD1
+action	KEYWORD2
+cycle	KEYWORD2
+event	KEYWORD2
+sleep	KEYWORD2
+state	KEYWORD2
+trigger	KEYWORD2
+Atm_step	KEYWORD1
+begin	KEYWORD2
+onStep	KEYWORD2
+state	KEYWORD2
+trace	KEYWORD2
+Atm_led	KEYWORD1
+begin	KEYWORD2
+blink	KEYWORD2
+brighten	KEYWORD2
+brightness	KEYWORD2
+fade	KEYWORD2
+lead	KEYWORD2
+levels	KEYWORD2
+off	KEYWORD2
+on	KEYWORD2
+onFinish	KEYWORD2
+pause	KEYWORD2
+range	KEYWORD2
+repeat	KEYWORD2
+start	KEYWORD2
+toggle	KEYWORD2
+toggleBlink	KEYWORD2
+trace	KEYWORD2
+trigger	KEYWORD2

firmware/lib/Automaton-1.0.2/library.json

@@ -0,0 +1,19 @@
+{
+    "name": "Automaton",
+    "version": "1.0.2",
+    "keywords": "state, machine",
+    "description": "A multi tasking table driven finite state machine framework for Arduino",
+    "authors":
+    {
+        "name": "Tinkerspy",
+        "email": "tinkerspy@myown.mailcan.com",
+        "url": "https://github.com/tinkerspy"
+    },
+    "repository":
+    {
+        "type": "git",
+        "url": "https://github.com/tinkerspy/Automaton"
+    },
+    "frameworks": "arduino",
+    "platforms": "atmelavr"
+}

firmware/lib/Automaton-1.0.2/library.properties

@@ -0,0 +1,9 @@
+name=Automaton
+version=1.0.2
+author=Tinkerspy <tinkerspy@myown.mailcan.com>
+maintainer=Tinkerspy <tinkerspy@myown.mailcan.com>
+sentence=A multi tasking table driven finite state machine framework
+paragraph=An event driven framework that allows you to create Arduino applications that consist of concurrently running state machines interacting with each other. Use the bundled machines or create your own following the tutorial. Contains reusable bundled machines for handling leds (fade & blink), buttons, serial commands, analog input (with moving average), pulses and timers and more.
+category=Other
+url=https://github.com/tinkerspy/Automaton/wiki
+architectures=*

firmware/lib/Automaton-1.0.2/src/Atm_analog.cpp

@@ -0,0 +1,108 @@
+#include "Atm_analog.hpp"
+
+Atm_analog& Atm_analog::begin( int attached_pin, int samplerate /* = 50 */ ) {
+  // clang-format off
+  const static state_t state_table[] PROGMEM = {
+    /*              ON_ENTER    ON_LOOP  ON_EXIT  EVT_TRIGGER  EVT_TIMER   ELSE */
+    /* IDLE   */          -1,        -1,      -1,          -1,   SAMPLE,    -1,
+    /* SAMPLE */  ENT_SAMPLE,        -1,      -1,        SEND,       -1,  IDLE,
+    /* SEND   */    ENT_SEND,        -1,      -1,          -1,       -1,  IDLE,
+  };
+  // clang-format on
+  Machine::begin( state_table, ELSE );
+  pin = attached_pin;
+  timer.set( samplerate );
+  return *this;
+}
+
+int Atm_analog::event( int id ) {
+  switch ( id ) {
+    case EVT_TIMER:
+      return timer.expired( this );
+    case EVT_TRIGGER:
+      return v_previous != v_sample;
+  }
+  return 0;
+}
+
+void Atm_analog::action( int id ) {
+  switch ( id ) {
+    case ENT_SAMPLE:
+      v_previous = v_sample;
+      v_sample = sample();
+      return;
+    case ENT_SEND:
+      v_sample = sample();
+      onchange.push( v_sample, v_sample > v_previous );
+      return;
+  }
+}
+
+Atm_analog& Atm_analog::range( int toLow, int toHigh ) {
+  this->toLow = toLow;
+  this->toHigh = toHigh;
+  return *this;
+}
+
+Atm_analog& Atm_analog::set( int value ) {  // Dummy method
+  return *this;
+}
+
+Atm_analog& Atm_analog::onChange( Machine& machine, int event /* = 0 */ ) {
+  this->onchange.set( &machine, event );
+  return *this;
+}
+
+Atm_analog& Atm_analog::onChange( atm_cb_push_t callback, int idx /* = 0 */ ) {
+  onchange.set( callback, idx );
+  return *this;
+}
+
+int Atm_analog::read_sample() {
+  return analogRead( pin );
+}
+
+int Atm_analog::avg() {
+  uint16_t v = read_sample();
+  avg_buf_total = avg_buf_total + v - avg_buf[avg_buf_head];
+  avg_buf[avg_buf_head] = v;
+  if ( avg_buf_head + 1 >= avg_buf_size ) {
+    avg_buf_head = 0;
+  } else {
+    avg_buf_head++;
+  }
+  return avg_buf_total / avg_buf_size;
+}
+
+int Atm_analog::sample() {
+  int v = avg_buf_size > 0 ? avg() : read_sample();
+  if ( toHigh || toLow ) {
+    return map( v, 0, 1023, toLow, toHigh );
+  } else {
+    return v;
+  }
+}
+
+int Atm_analog::state( void ) {
+  return sample();
+}
+
+Atm_analog& Atm_analog::average( uint16_t* v, uint16_t size ) {
+  avg_buf = v;
+  avg_buf_size = size / sizeof( uint16_t );
+  avg_buf_head = 0;
+  avg_buf_total = 0;
+  for ( uint16_t i = 0; i < avg_buf_size; i++ ) {
+    avg_buf[i] = read_sample();
+    avg_buf_total += avg_buf[i];
+  }
+  return *this;
+}
+
+Atm_analog& Atm_analog::trace( Stream& stream ) {
+  setTrace( &stream, atm_serial_debug::trace,
+            "ANALOG\0EVT_TRIGGER\0EVT_TIMER\0ELSE\0"
+            "IDLE\0SAMPLE\0SEND" );
+
+  return *this;
+}

firmware/lib/Automaton-1.0.2/src/Atm_analog.hpp

@@ -0,0 +1,37 @@
+#pragma once
+
+#include <Automaton.h>
+
+class Atm_analog : public Machine {
+ public:
+  enum { IDLE, SAMPLE, SEND };            // STATES
+  enum { EVT_TRIGGER, EVT_TIMER, ELSE };  // EVENTS
+
+  Atm_analog( void ) : Machine(){};
+  Atm_analog& begin( int attached_pin, int sampleRate = 50 );
+  Atm_analog& average( uint16_t* v, uint16_t size );
+  Atm_analog& trace( Stream& stream );
+  int state( void );
+  Atm_analog& range( int toLow, int toHigh );
+  Atm_analog& onChange( Machine& machine, int event = 0 );
+  Atm_analog& onChange( atm_cb_push_t callback, int idx = 0 );
+  Atm_analog& set( int value );
+
+ private:
+  enum { ENT_SAMPLE, ENT_SEND };  // ACTIONS
+  short pin;
+  atm_timer_millis timer;
+  int v_sample, v_threshold, v_previous;
+  atm_connector onchange;
+  uint16_t* avg_buf;
+  uint16_t avg_buf_size;
+  uint16_t avg_buf_head;
+  uint32_t avg_buf_total;
+  int toLow, toHigh;
+
+  int avg();
+  int sample();
+  virtual int read_sample();
+  int event( int id );
+  void action( int id );
+};

firmware/lib/Automaton-1.0.2/src/Atm_bit.cpp

@@ -0,0 +1,115 @@
+#include "Atm_bit.hpp"
+
+Atm_bit& Atm_bit::begin( bool initialState /* = false */ ) {
+  // clang-format off
+  const static state_t state_table[] PROGMEM = {
+    /*                ON_ENTER    ON_LOOP  ON_EXIT  EVT_ON  EVT_OFF  EVT_TOGGLE EVT_INPUT EVT_REFRESH ELSE */
+    /* OFF     */      ENT_OFF, ATM_SLEEP,      -1,     ON,      -1,         ON,      OFF,   REFR_OFF,  -1,
+    /* ON      */       ENT_ON, ATM_SLEEP,      -1,     -1,     OFF,        OFF,       ON,    REFR_ON,  -1,
+    /* REFR_ON */  ENT_REFR_ON,        -1,      -1,     -1,      -1,         -1,       -1,         -1,  ON,
+    /* REFR_OFF*/ ENT_REFR_OFF,        -1,      -1,     -1,      -1,         -1,       -1,         -1, OFF,
+  };
+  // clang-format on
+  Machine::begin( state_table, ELSE );
+  last_state = -1;
+  state( initialState ? ON : OFF );
+  indicator = -1;
+  cycle();
+  return *this;
+}
+
+int Atm_bit::event( int id ) {
+  return 0;
+}
+
+void Atm_bit::action( int id ) {
+  switch ( id ) {
+    case ENT_OFF:
+      if ( last_state != -1 ) connector[last_state == current ? ON_INPUT_FALSE : ON_CHANGE_FALSE].push( state() );
+      if ( indicator > -1 ) digitalWrite( indicator, !LOW != !indicatorActiveLow );
+      last_state = current;
+      return;
+    case ENT_ON:
+      if ( last_state != -1 ) connector[last_state == current ? ON_INPUT_TRUE : ON_CHANGE_TRUE].push( state() );
+      if ( indicator > -1 ) digitalWrite( indicator, !HIGH != !indicatorActiveLow );
+      last_state = current;
+      return;
+    case ENT_REFR_ON:
+      connector[ON_CHANGE_TRUE].push( ON );
+      last_state = -1;
+      return;      
+    case ENT_REFR_OFF:
+      connector[ON_CHANGE_FALSE].push( OFF );
+      last_state = -1;
+      return;      
+  }
+}
+
+Atm_bit& Atm_bit::on( void ) {
+  trigger( EVT_ON );
+  return *this;
+}
+
+Atm_bit& Atm_bit::off( void ) {
+  trigger( EVT_OFF );
+  return *this;
+}
+
+Atm_bit& Atm_bit::toggle( void ) {
+  trigger( EVT_TOGGLE );
+  return *this;
+}
+
+Atm_bit& Atm_bit::input( void ) {
+  trigger( EVT_INPUT );
+  return *this;
+}
+
+Atm_bit& Atm_bit::refresh( void ) {
+  trigger( EVT_REFRESH );
+  return *this;
+}
+
+Atm_bit& Atm_bit::led( int led, bool activeLow /* = false */ ) {
+  indicator = led;
+  indicatorActiveLow = activeLow;
+  pinMode( indicator, OUTPUT );
+  return *this;
+}
+
+Atm_bit& Atm_bit::onChange( atm_cb_push_t callback, int idx /* = 0 */ ) {
+  connector[ON_CHANGE_FALSE].set( callback, idx );
+  connector[ON_CHANGE_TRUE].set( callback, idx );
+  return *this;
+}
+
+Atm_bit& Atm_bit::onChange( Machine& machine, int event /* = 0 */ ) {
+  connector[ON_CHANGE_FALSE].set( &machine, event );
+  connector[ON_CHANGE_TRUE].set( &machine, event );
+  return *this;
+}
+
+Atm_bit& Atm_bit::onChange( bool status, atm_cb_push_t callback, int idx /* = 0 */ ) {
+  connector[status ? ON_CHANGE_TRUE : ON_CHANGE_FALSE].set( callback, idx );
+  return *this;
+}
+
+Atm_bit& Atm_bit::onChange( bool status, Machine& machine, int event /* = 0 */ ) {
+  connector[status ? ON_CHANGE_TRUE : ON_CHANGE_FALSE].set( &machine, event );
+  return *this;
+}
+
+Atm_bit& Atm_bit::onInput( bool status, atm_cb_push_t callback, int idx /* = 0 */ ) {
+  connector[status ? ON_INPUT_TRUE : ON_INPUT_FALSE].set( callback, idx );
+  return *this;
+}
+
+Atm_bit& Atm_bit::onInput( bool status, Machine& machine, int event /* = 0 */ ) {
+  connector[status ? ON_INPUT_TRUE : ON_INPUT_FALSE].set( &machine, event );
+  return *this;
+}
+
+Atm_bit& Atm_bit::trace( Stream& stream ) {
+  Machine::setTrace( &stream, atm_serial_debug::trace, "BIT\0EVT_ON\0EVT_OFF\0EVT_TOGGLE\0EVT_INPUT\0EVT_REFRESH\0ELSE\0OFF\0ON\0REFR_ON\0REFR_OFF" );
+  return *this;
+}

firmware/lib/Automaton-1.0.2/src/Atm_bit.hpp

@@ -0,0 +1,36 @@
+#pragma once
+
+#include <Automaton.h>
+
+class Atm_bit : public Machine {
+ public:
+  enum { OFF, ON, REFR_ON, REFR_OFF };                                       // STATES
+  enum { EVT_ON, EVT_OFF, EVT_TOGGLE, EVT_INPUT, EVT_REFRESH, ELSE };  // EVENTS
+
+  Atm_bit( void ) : Machine(){};
+  Atm_bit& begin( bool initialState = false );
+  Atm_bit& onChange( atm_cb_push_t callback, int idx = 0 );
+  Atm_bit& onChange( Machine& machine, int event = 0 );
+  Atm_bit& onChange( bool status, atm_cb_push_t callback, int idx = 0 );
+  Atm_bit& onChange( bool status, Machine& machine, int event = 0 );
+  Atm_bit& onInput( bool status, atm_cb_push_t callback, int idx = 0 );
+  Atm_bit& onInput( bool status, Machine& machine, int event = 0 );
+  Atm_bit& led( int led, bool activeLow = false );
+  Atm_bit& on( void );
+  Atm_bit& off( void );
+  Atm_bit& toggle( void );
+  Atm_bit& input( void );
+  Atm_bit& refresh( void );
+  Atm_bit& trace( Stream& stream );
+
+ private:
+  enum { ENT_ON, ENT_OFF, ENT_REFR_ON, ENT_REFR_OFF };                                                              // ACTIONS
+  enum { ON_CHANGE_FALSE, ON_CHANGE_TRUE, ON_INPUT_FALSE, ON_INPUT_TRUE, _CONN_SIZE_ };  // CONNECTORS
+  state_t last_state;
+  atm_connector connector[_CONN_SIZE_];
+  int8_t indicator;
+  bool indicatorActiveLow;
+
+  int event( int id );
+  void action( int id );
+};

firmware/lib/Automaton-1.0.2/src/Atm_button.cpp

@@ -0,0 +1,153 @@
+#include "Atm_button.hpp"
+
+// Add option for button press callback (for reading i2c buttons etc)
+
+Atm_button& Atm_button::begin( int attached_pin ) {
+  // clang-format off
+  const static state_t state_table[] PROGMEM = {
+    /* Standard Mode: press/repeat */
+    /*                  ON_ENTER  ON_LOOP       ON_EXIT  EVT_LMODE  EVT_TIMER  EVT_DELAY  EVT_REPEAT EVT_PRESS  EVT_RELEASE  EVT_COUNTER   EVT_AUTO  ELSE */
+    /* IDLE     */            -1,      -1,           -1,     LIDLE,        -1,        -1,         -1,     WAIT,          -1,          -1,   AUTO_ST,   -1,
+    /* WAIT     */            -1,      -1,           -1,        -1,   PRESSED,        -1,         -1,       -1,        IDLE,          -1,        -1,    -1,
+    /* PRESSED  */     ENT_PRESS,      -1,           -1,        -1,        -1,    REPEAT,         -1,       -1,     RELEASE,          -1,        -1,    -1,
+    /* REPEAT   */     ENT_PRESS,      -1,           -1,        -1,        -1,        -1,     REPEAT,       -1,     RELEASE,          -1,        -1,    -1,
+    /* RELEASE  */   ENT_RELEASE,      -1,           -1,        -1,        -1,        -1,         -1,       -1,          -1,          -1,        -1,  IDLE,
+    /* Long Press Mode: press/long press */	
+    /* LIDLE    */            -1,      -1,           -1,        -1,        -1,        -1,         -1,    LWAIT,          -1,          -1,        -1,    -1,
+    /* LWAIT    */    ENT_LSTART,      -1,           -1,        -1,  LPRESSED,        -1,         -1,       -1,       LIDLE,          -1,        -1,    -1,
+    /* LPRESSED */    ENT_LCOUNT,      -1,           -1,        -1,        -1,  LPRESSED,         -1,       -1,    LRELEASE,    WRELEASE,        -1,    -1,
+    /* LRELEASE */  ENT_LRELEASE,      -1, EXT_WRELEASE,        -1,        -1,        -1,         -1,       -1,          -1,          -1,        -1, LIDLE,
+    /* WRELEASE */  ENT_LRELEASE,      -1, EXT_WRELEASE,        -1,        -1,        -1,         -1,       -1,       LIDLE,          -1,        -1,    -1,
+    /* AUTO_ST   */      ENT_AUTO,      -1,           -1,        -1,        -1,        -1,         -1,       -1,          -1,          -1,        -1,  IDLE,
+  };
+  // clang-format on
+  Machine::begin( state_table, ELSE );
+  pin = attached_pin;
+  counter_longpress.set( 0 );
+  timer_debounce.set( DEBOUNCE );
+  timer_delay.set( ATM_TIMER_OFF );
+  timer_repeat.set( ATM_TIMER_OFF );
+  timer_auto.set( ATM_TIMER_OFF );
+  pinMode( pin, INPUT_PULLUP );
+  return *this;
+}
+
+int Atm_button::event( int id ) {
+  switch ( id ) {
+    case EVT_LMODE:
+      return counter_longpress.value > 0;
+    case EVT_TIMER:
+      return timer_debounce.expired( this );
+    case EVT_DELAY:
+      return timer_delay.expired( this );
+    case EVT_REPEAT:
+      return timer_repeat.expired( this );
+    case EVT_AUTO:
+      return timer_auto.expired( this );
+    case EVT_PRESS:
+      return !digitalRead( pin );
+    case EVT_RELEASE:
+      return digitalRead( pin );
+    case EVT_COUNTER:
+      return counter_longpress.expired();
+  }
+  return 0;
+}
+
+void Atm_button::action( int id ) {
+  int press;
+  switch ( id ) {
+    case ENT_PRESS:
+      onpress.push( auto_press );
+      longpress[0].push( 1 );
+      return;
+    case ENT_AUTO:
+      onpress.push( 1 );
+      longpress[0].push( 1 );
+      return;
+    case ENT_RELEASE:
+    case EXT_WRELEASE:
+      onrelease.push( 0 );
+      return;
+    case ENT_LSTART:
+      counter_longpress.set( longpress_max );
+      return;
+    case ENT_LCOUNT:
+      counter_longpress.decrement();
+      press = ( longpress_max - counter_longpress.value );
+      if ( onpress.mode() == atm_connector::MODE_PUSHCB ) {
+        onpress.push( press * -1 );
+      }
+      return;
+    case ENT_LRELEASE:
+      press = ( longpress_max - counter_longpress.value );
+      onpress.push( press );
+      if ( press == 1 || press == 2 ) {
+        longpress[press-1].push( press );
+      } 
+      return;
+  }
+}
+
+Atm_button& Atm_button::onPress( atm_cb_push_t callback, int idx /* = 0 */ ) {
+  onpress.set( callback, idx );
+  return *this;
+}
+
+Atm_button& Atm_button::onPress( Machine& machine, int event /* = 0 */ ) {
+  onpress.set( &machine, event );
+  return *this;
+}
+
+Atm_button& Atm_button::onPress( int id, atm_cb_push_t callback, int idx /* = 0 */ ) {
+  if ( id == 1 || id == 2 )
+    longpress[id-1].set( callback, idx );
+  return *this;
+}
+
+Atm_button& Atm_button::onPress( int id, Machine& machine, int event /* = 0 */ ) {
+  if ( id == 1 || id == 2 )
+    longpress[id-1].set( &machine, event );
+  return *this;
+}
+
+Atm_button& Atm_button::onRelease( atm_cb_push_t callback, int idx /* = 0 */ ) {
+  onrelease.set( callback, idx );
+  return *this;
+}
+
+Atm_button& Atm_button::onRelease( Machine& machine, int event /* = 0 */ ) {
+  onrelease.set( &machine, event );
+  return *this;
+}
+
+Atm_button& Atm_button::debounce( int delay ) {
+  timer_debounce.set( delay );
+  return *this;
+}
+
+Atm_button& Atm_button::longPress( int max, int delay ) {
+  longpress_max = max;
+  counter_longpress.set( longpress_max );
+  timer_delay.set( delay );
+  return *this;
+}
+
+Atm_button& Atm_button::repeat( int delay /* = 500 */, int speed /* = 50 */ ) {
+  timer_delay.set( delay );
+  timer_repeat.set( speed );
+  return *this;
+}
+
+Atm_button& Atm_button::autoPress( int delay, int press /* = 1 */ ) {
+  auto_press = press;
+  timer_auto.set( delay );
+  return *this;
+}
+
+Atm_button& Atm_button::trace( Stream& stream ) {
+  setTrace( &stream, atm_serial_debug::trace,
+            "BUTTON\0EVT_LMODE\0EVT_TIMER\0EVT_DELAY\0EVT_REPEAT\0EVT_PRESS\0EVT_RELEASE\0EVT_COUNTER\0EVT_"
+            "AUTO_ST\0ELSE\0IDLE\0WAIT\0PRESSED\0REPEAT\0RELEASE\0LIDLE\0LWAIT\0LPRESSED\0LRELEASE\0WRELEASE\0AUTO" );
+  return *this;
+}

firmware/lib/Automaton-1.0.2/src/Atm_button.hpp

@@ -0,0 +1,38 @@
+#pragma once
+
+#include <Automaton.h>
+
+class Atm_button : public Machine {
+ public:
+  enum { IDLE, WAIT, PRESSED, REPEAT, RELEASE, LIDLE, LWAIT, LPRESSED, LRELEASE, WRELEASE, AUTO_ST };
+  enum { EVT_LMODE, EVT_TIMER, EVT_DELAY, EVT_REPEAT, EVT_PRESS, EVT_RELEASE, EVT_COUNTER, EVT_AUTO, ELSE };
+  enum { BTN_PASS4 = -4, BTN_PASS3 = -3, BTN_PASS2 = -2, BTN_PASS1 = -1, BTN_RELEASE = 0, BTN_PRESS1 = 1, BTN_PRESS2 = 2, BTN_PRESS3 = 3, BTN_PRESS4 = 4 };
+
+  Atm_button( void ) : Machine(){};
+  Atm_button& begin( int attached_pin );
+  Atm_button& trace( Stream& stream );
+  Atm_button& onPress( atm_cb_push_t callback, int idx = 0 );
+  Atm_button& onPress( Machine& machine, int event = 0 );
+  Atm_button& onPress( int id, atm_cb_push_t callback, int idx = 0 );
+  Atm_button& onPress( int id, Machine& machine, int event = 0 );
+  Atm_button& onRelease( atm_cb_push_t callback, int idx = 0 );
+  Atm_button& onRelease( Machine& machine, int event = 0 );
+  Atm_button& debounce( int delay );
+  Atm_button& longPress( int max, int delay );
+  Atm_button& repeat( int delay = 500, int speed = 50 );
+  Atm_button& autoPress( int delay, int press = 1 );
+
+ protected:
+  enum { ENT_PRESS, ENT_RELEASE, ENT_LSTART, ENT_LCOUNT, ENT_LRELEASE, EXT_WRELEASE, ENT_AUTO };
+  static const int DEBOUNCE = 5;
+  atm_connector onpress, onrelease;
+  atm_connector longpress[2];
+  short pin;
+  atm_timer_millis timer_debounce, timer_delay, timer_repeat, timer_auto;
+  atm_counter counter_longpress;
+  int longpress_max;
+  int auto_press = 1;
+
+  int event( int id );
+  void action( int id );
+};

firmware/lib/Automaton-1.0.2/src/Atm_command.cpp

@@ -0,0 +1,106 @@
+#include "Atm_command.hpp"
+
+Atm_command& Atm_command::begin( Stream& stream, char buffer[], int size ) {
+  // clang-format off
+  const static state_t state_table[] PROGMEM = {
+    /*                  ON_ENTER    ON_LOOP    ON_EXIT  EVT_INPUT   EVT_EOL   ELSE */
+    /* IDLE     */            -1,        -1,        -1,  READCHAR,       -1,    -1,
+    /* READCHAR */  ENT_READCHAR,        -1,        -1,  READCHAR,     SEND,    -1,
+    /* SEND     */      ENT_SEND,        -1,        -1,        -1,       -1,  IDLE,
+  };
+  // clang-format on
+  Machine::begin( state_table, ELSE );
+  this->stream = &stream;
+  this->buffer = buffer;
+  bufsize = size;
+  bufptr = 0;
+  separatorChar = " ";
+  lastch = '\0';
+  return *this;
+}
+
+int Atm_command::event( int id ) {
+  switch ( id ) {
+    case EVT_INPUT:
+      return stream->available();
+    case EVT_EOL:
+      return buffer[bufptr - 1] == '\n' || buffer[bufptr - 1] == '\r' || bufptr >= bufsize;
+  }
+  return 0;
+}
+
+void Atm_command::action( int id ) {
+  switch ( id ) {
+    case ENT_READCHAR:
+      if ( stream->available() ) {
+        char ch = stream->read();
+        if ( strchr( separatorChar, ch ) == NULL ) {
+          buffer[bufptr++] = ch;
+          lastch = ch;
+        } else {
+          if ( lastch != '\0' ) buffer[bufptr++] = '\0';
+          lastch = '\0';
+        }
+      }
+      return;
+    case ENT_SEND:
+      buffer[--bufptr] = '\0';
+      oncommand.push( lookup( 0, commands ) );
+      lastch = '\0';
+      bufptr = 0;
+      return;
+  }
+}
+
+Atm_command& Atm_command::onCommand( atm_cb_push_t callback, int idx /* = 0 */ ) {
+  oncommand.set( callback, idx );
+  return *this;
+}
+
+Atm_command& Atm_command::list( const char* cmds ) {
+  commands = cmds;
+  return *this;
+}
+
+Atm_command& Atm_command::separator( const char sep[] ) {
+  separatorChar = sep;
+  return *this;
+}
+
+char* Atm_command::arg( int id ) {
+  int cnt = 0;
+  int i;
+  if ( id == 0 ) return buffer;
+  for ( i = 0; i < bufptr; i++ ) {
+    if ( buffer[i] == '\0' ) {
+      if ( ++cnt == id ) {
+        i++;
+        break;
+      }
+    }
+  }
+  return &buffer[i];
+}
+
+int Atm_command::lookup( int id, const char* cmdlist ) {
+  int cnt = 0;
+  char* arg = this->arg( id );
+  char* a = arg;
+  while ( cmdlist[0] != '\0' ) {
+    while ( cmdlist[0] != '\0' && toupper( cmdlist[0] ) == toupper( a[0] ) ) {
+      cmdlist++;
+      a++;
+    }
+    if ( a[0] == '\0' && ( cmdlist[0] == ' ' || cmdlist[0] == '\0' ) ) return cnt;
+    while ( cmdlist[0] != ' ' && cmdlist[0] != '\0' ) cmdlist++;
+    cmdlist++;
+    a = arg;
+    cnt++;
+  }
+  return -1;
+}
+
+Atm_command& Atm_command::trace( Stream& stream ) {
+  setTrace( &stream, atm_serial_debug::trace, "COMMAND\0EVT_INPUT\0EVT_EOL\0ELSE\0IDLE\0READCHAR\0SEND" );
+  return *this;
+}

firmware/lib/Automaton-1.0.2/src/Atm_command.hpp

@@ -0,0 +1,32 @@
+#pragma once
+
+#include <Automaton.h>
+
+class Atm_command : public Machine {
+ public:
+  enum { IDLE, READCHAR, SEND };
+  enum { EVT_INPUT, EVT_EOL, ELSE };
+
+  Atm_command( void ) : Machine(){};
+  Atm_command& begin( Stream& stream, char buffer[], int size );
+  Atm_command& trace( Stream& stream );
+  Atm_command& onCommand( atm_cb_push_t callback, int idx = 0 );
+  Atm_command& list( const char* cmds );
+
+  Atm_command& separator( const char sep[] );
+  int lookup( int id, const char* cmdlist );
+  char* arg( int id );
+
+ private:
+  enum { ENT_READCHAR, ENT_SEND };
+  atm_connector oncommand;
+  Stream* stream;
+  char* buffer;
+  int bufsize, bufptr;
+  char eol, lastch;
+  const char* separatorChar;
+  const char* commands;
+
+  int event( int id );
+  void action( int id );
+};

firmware/lib/Automaton-1.0.2/src/Atm_comparator.cpp

@@ -0,0 +1,173 @@
+#include "Atm_comparator.hpp"
+
+Atm_comparator& Atm_comparator::begin( int attached_pin, int samplerate /* = 50 */ ) {
+  // clang-format off
+  const static state_t state_table[] PROGMEM = {
+    /*              ON_ENTER    ON_LOOP  ON_EXIT  EVT_TRIGGER EVT_TIMER   ELSE */
+    /* IDLE   */          -1,        -1,      -1,           -1,   SAMPLE,    -1,
+    /* SAMPLE */  ENT_SAMPLE,        -1,      -1,         SEND,       -1,  IDLE,
+    /* SEND   */    ENT_SEND,        -1,      -1,           -1,       -1,  IDLE,
+  };
+  // clang-format on
+  Machine::begin( state_table, ELSE );
+  pin = attached_pin;
+  timer.set( samplerate );
+  bitmap_sample = 0;
+  bitmap_previous = 0;
+  skip_mode = 0;
+  return *this;
+}
+
+int Atm_comparator::event( int id ) {
+  switch ( id ) {
+    case EVT_TRIGGER:
+      if ( bitmap_diff ) {
+        return 1;
+      }
+      return 0;
+    case EVT_TIMER:
+      return timer.expired( this );
+  }
+  return 0;
+}
+
+void Atm_comparator::action( int id ) {
+  switch ( id ) {
+    case ENT_SAMPLE:
+      v_previous = v_sample;
+      bitmap_previous = bitmap_sample;
+      v_sample = sample();
+      bitmap( v_sample );
+      return;
+    case ENT_SEND:
+      int final_step = -1;
+      if ( v_sample >= v_previous ) {
+        for ( uint16_t i = 0; i < p_threshold_size; i++ ) {
+          if ( ( bitmap_diff >> i ) & 1 ) {
+            if ( skip_mode == 0 ) {
+              onup.push( i, 1 );
+            } else {
+              final_step = i;
+            }
+          }
+        }
+      } else {
+        for ( int i = p_threshold_size; i >= 0; i-- ) {
+          if ( ( bitmap_diff >> i ) & 1 ) {
+            if ( skip_mode == 0 ) {
+              ondown.push( i, 0 );
+            } else {
+              final_step = i;
+            }
+          }
+        }
+      }
+      if ( final_step > -1 ) {
+        if ( v_sample >= v_previous ) {
+          onup.push( final_step, 0 );
+        } else {
+          ondown.push( final_step, 0 );
+        }
+      }
+      return;
+  }
+}
+
+Atm_comparator& Atm_comparator::onChange( atm_cb_push_t callback, int idx /* = 0 */ ) {
+  onup.set( callback, idx );
+  ondown.set( callback, idx );
+  return *this;
+}
+
+Atm_comparator& Atm_comparator::onChange( Machine& machine, int event /* = 0 */ ) {
+  onup.set( &machine, event );
+  ondown.set( &machine, event );
+  return *this;
+}
+
+Atm_comparator& Atm_comparator::onChange( bool status, atm_cb_push_t callback, int idx /* = 0 */ ) {
+  if ( status ) {
+    onup.set( callback, idx );
+  } else {
+    ondown.set( callback, idx );
+  }
+  return *this;
+}
+
+Atm_comparator& Atm_comparator::onChange( bool status, Machine& machine, int event /* = 0 */ ) {
+  if ( status ) {
+    onup.set( &machine, event );
+  } else {
+    ondown.set( &machine, event );
+  }
+  return *this;
+}
+
+Atm_comparator& Atm_comparator::skip() {
+  skip_mode = 1;
+  return *this;
+}
+
+int Atm_comparator::read_sample() {
+  return analogRead( pin );
+}
+
+int Atm_comparator::avg() {
+  uint16_t v = read_sample();
+  avg_buf_total = avg_buf_total + v - avg_buf[avg_buf_head];
+  avg_buf[avg_buf_head] = v;
+  if ( avg_buf_head + 1 >= avg_buf_size ) {
+    avg_buf_head = 0;
+  } else {
+    avg_buf_head++;
+  }
+  return avg_buf_total / avg_buf_size;
+}
+
+int Atm_comparator::sample() {
+  return avg_buf_size > 0 ? avg() : read_sample();
+}
+
+int Atm_comparator::state( void ) {
+  return v_sample;
+}
+
+Atm_comparator& Atm_comparator::threshold( uint16_t* v, uint16_t size, bool catchUp /* = false */ ) {
+  p_threshold = v;
+  p_threshold_size = size / sizeof( uint16_t );
+  if ( !catchUp ) {
+    v_sample = sample();
+    bitmap( v_sample );
+    v_previous = v_sample;
+    bitmap_previous = bitmap_sample;
+  }
+  return *this;
+}
+
+Atm_comparator& Atm_comparator::average( uint16_t* v, uint16_t size ) {
+  avg_buf = v;
+  avg_buf_size = size / sizeof( uint16_t );
+  avg_buf_head = 0;
+  avg_buf_total = 0;
+  for ( uint16_t i = 0; i < avg_buf_size; i++ ) {
+    avg_buf[i] = read_sample();
+    avg_buf_total += avg_buf[i];
+  }
+  return *this;
+}
+
+Atm_comparator& Atm_comparator::bitmap( uint16_t v ) {
+  bitmap_sample = 0;
+  for ( uint8_t i = 0; i < p_threshold_size; i++ ) {
+    if ( v >= p_threshold[i] ) bitmap_sample |= ( 1 << i );
+  }
+  bitmap_diff = bitmap_sample ^ bitmap_previous;
+  return *this;
+}
+
+Atm_comparator& Atm_comparator::trace( Stream& stream ) {
+  setTrace( &stream, atm_serial_debug::trace,
+            "EVT_TRIGGER\0EVT_TIMER\0ELSE\0"
+            "IDLE\0SAMPLE\0SEND" );
+  return *this;
+}

firmware/lib/Automaton-1.0.2/src/Atm_comparator.hpp

@@ -0,0 +1,43 @@
+#pragma once
+
+#include <Automaton.h>
+
+class Atm_comparator : public Machine {
+ public:
+  enum { IDLE, SAMPLE, SEND };            // STATES
+  enum { EVT_TRIGGER, EVT_TIMER, ELSE };  // EVENTS
+
+  Atm_comparator( void ) : Machine(){};
+  Atm_comparator& begin( int attached_pin, int sampleRate = 50 );
+  Atm_comparator& threshold( uint16_t* v, uint16_t size, bool catchUp = false );
+  Atm_comparator& average( uint16_t* v, uint16_t size );
+  Atm_comparator& skip();
+  Atm_comparator& onChange( atm_cb_push_t callback, int idx = 0 );
+  Atm_comparator& onChange( Machine& machine, int event = 0 );
+  Atm_comparator& onChange( bool status, atm_cb_push_t callback, int idx = 0 );
+  Atm_comparator& onChange( bool status, Machine& machine, int event = 0 );
+  int state( void );
+  virtual int read_sample();
+  Atm_comparator& trace( Stream& stream );
+
+ private:
+  enum { ENT_SAMPLE, ENT_SEND };  // ACTIONS
+  short pin;
+  atm_timer_millis timer;
+  int v_sample, v_threshold, v_previous;
+  uint64_t bitmap_sample, bitmap_previous, bitmap_diff;
+  uint16_t* p_threshold;  // Max 64 values
+  uint16_t p_threshold_size;
+  uint16_t* avg_buf;
+  uint16_t avg_buf_size;
+  uint16_t avg_buf_head;
+  uint32_t avg_buf_total;
+  atm_connector onup, ondown;
+  int skip_mode;
+
+  int avg();
+  Atm_comparator& bitmap( uint16_t v );
+  int sample();
+  int event( int id );
+  void action( int id );
+};

firmware/lib/Automaton-1.0.2/src/Atm_controller.cpp

@@ -0,0 +1,177 @@
+#include "Atm_controller.hpp"
+
+const char Atm_controller::relOps[8] = "0=!<>-+";
+
+Atm_controller& Atm_controller::begin( bool initialState /* = false */ ) {
+  // clang-format off
+  const static state_t state_table[] PROGMEM = {
+    /*              ON_ENTER    ON_LOOP  ON_EXIT  EVT_ON  EVT_OFF  EVT_INPUT ELSE */
+    /* OFF     */    ENT_OFF,        -1,      -1,     ON,      -1,       OFF,  -1,
+    /* ON      */     ENT_ON,        -1,      -1,     -1,     OFF,        ON,  -1,
+  };
+  // clang-format on
+  Machine::begin( state_table, ELSE );
+  last_state = -1;
+  state( initialState ? ON : OFF );
+  indicator = -1;
+  return *this;
+}
+
+int Atm_controller::event( int id ) {
+  switch ( id ) {
+    case EVT_ON:
+      return eval_all();
+    case EVT_OFF:
+      return !eval_all();
+  }
+  return 0;
+}
+
+void Atm_controller::action( int id ) {
+  switch ( id ) {
+    case ENT_OFF:
+      connector[last_state == current ? ON_INPUT_FALSE : ON_CHANGE_FALSE].push( state() );
+      if ( indicator > -1 ) digitalWrite( indicator, !LOW != !indicatorActiveLow );
+      last_state = current;
+      return;
+    case ENT_ON:
+      if ( last_state != -1 ) connector[( last_state == current ) ? ON_INPUT_TRUE : ON_CHANGE_TRUE].push( state() );
+      if ( indicator > -1 ) digitalWrite( indicator, !HIGH != !indicatorActiveLow );
+      last_state = current;
+      return;
+  }
+}
+
+bool Atm_controller::eval_one( atm_connector& connector ) {
+  switch ( connector.relOp() ) {
+    case atm_connector::REL_EQ:
+      return connector.pull() == connector.event;
+    case atm_connector::REL_NEQ:
+      return connector.pull() != connector.event;
+    case atm_connector::REL_LT:
+      return connector.pull() < connector.event;
+    case atm_connector::REL_GT:
+      return connector.pull() > connector.event;
+    case atm_connector::REL_LTE:
+      return connector.pull() <= connector.event;
+    case atm_connector::REL_GTE:
+      return connector.pull() >= connector.event;
+  }
+  return connector.pull();
+}
+
+bool Atm_controller::eval_all() {
+  bool r = eval_one( operand[0] );
+  for ( uint8_t i = 1; i < ATM_CONDITION_OPERAND_MAX; i++ ) {
+    if ( operand[i].mode() ) {
+      switch ( operand[i].logOp() ) {
+        case atm_connector::LOG_AND:
+          r = r && eval_one( operand[i] );
+          break;
+        case atm_connector::LOG_OR:
+          r = r || eval_one( operand[i] );
+          break;
+        case atm_connector::LOG_XOR:
+          r = !r != !eval_one( operand[i] );
+          break;
+      }
+    }
+  }
+  return r;
+}
+
+Atm_controller& Atm_controller::led( int led, bool activeLow /* = false */ ) {
+  indicator = led;
+  indicatorActiveLow = activeLow;
+  pinMode( indicator, OUTPUT );
+  return *this;
+}
+
+Atm_controller& Atm_controller::onChange( bool status, atm_cb_push_t callback, int idx /* = 0 */ ) {
+  connector[status ? ON_CHANGE_TRUE : ON_CHANGE_FALSE].set( callback, idx );
+  return *this;
+}
+
+Atm_controller& Atm_controller::onChange( bool status, Machine& machine, int event /* = 0 */ ) {
+  connector[status ? ON_CHANGE_TRUE : ON_CHANGE_FALSE].set( &machine, event );
+  return *this;
+}
+
+Atm_controller& Atm_controller::onChange( atm_cb_push_t callback, int idx /* = 0 */ ) {
+  connector[ON_CHANGE_TRUE].set( callback, idx );
+  connector[ON_CHANGE_FALSE].set( callback, idx );
+  return *this;
+}
+
+Atm_controller& Atm_controller::onChange( Machine& machine, int event /* = 0 */ ) {
+  connector[ON_CHANGE_TRUE].set( &machine, event );
+  connector[ON_CHANGE_FALSE].set( &machine, event );
+  return *this;
+}
+
+Atm_controller& Atm_controller::onInput( bool status, atm_cb_push_t callback, int idx /* = 0 */ ) {
+  connector[status ? ON_INPUT_TRUE : ON_INPUT_FALSE].set( callback, idx );
+  return *this;
+}
+
+Atm_controller& Atm_controller::onInput( bool status, Machine& machine, int event /* = 0 */ ) {
+  connector[status ? ON_INPUT_TRUE : ON_INPUT_FALSE].set( &machine, event );
+  return *this;
+}
+
+Atm_controller& Atm_controller::IF( Machine& machine, char relOp /* = '>' */, int match /* = 0 */ ) {
+  return OP( atm_connector::LOG_AND, machine, relOp, match );
+}
+
+Atm_controller& Atm_controller::IF( atm_cb_pull_t callback, int idx /* = 0 */ ) {
+  return OP( atm_connector::LOG_AND, callback, idx );
+}
+
+Atm_controller& Atm_controller::AND( Machine& machine, char relOp /* = '>' */, int match /* = 0 */ ) {
+  return OP( atm_connector::LOG_AND, machine, relOp, match );
+}
+
+Atm_controller& Atm_controller::AND( atm_cb_pull_t callback, int idx /* = 0 */ ) {
+  return OP( atm_connector::LOG_AND, callback, idx );
+}
+
+Atm_controller& Atm_controller::OR( Machine& machine, char relOp /* = '>' */, int match /* = 0 */ ) {
+  return OP( atm_connector::LOG_OR, machine, relOp, match );
+}
+
+Atm_controller& Atm_controller::OR( atm_cb_pull_t callback, int idx /* = 0 */ ) {
+  return OP( atm_connector::LOG_OR, callback, idx );
+}
+
+Atm_controller& Atm_controller::XOR( Machine& machine, char relOp /* = '>' */, int match /* = 0 */ ) {
+  return OP( atm_connector::LOG_XOR, machine, relOp, match );
+}
+
+Atm_controller& Atm_controller::XOR( atm_cb_pull_t callback, int idx /* = 0 */ ) {
+  return OP( atm_connector::LOG_XOR, callback, idx );
+}
+
+Atm_controller& Atm_controller::OP( char logOp, Machine& machine, char relOp, int match ) {
+  for ( uint8_t i = 0; i < ATM_CONDITION_OPERAND_MAX; i++ ) {
+    if ( operand[i].mode() == atm_connector::MODE_NULL ) {  // Pick the first free slot
+      operand[i].set( &machine, match, logOp, (int)( strchr( relOps, relOp ) - relOps ) );
+      break;
+    }
+  }
+  return *this;
+}
+
+Atm_controller& Atm_controller::OP( char logOp, atm_cb_pull_t callback, int idx ) {
+  for ( uint8_t i = 0; i < ATM_CONDITION_OPERAND_MAX; i++ ) {
+    if ( operand[i].mode() == atm_connector::MODE_NULL ) {  // Pick the first free slot
+      operand[i].set( callback, idx );
+      break;
+    }
+  }
+  return *this;
+}
+
+Atm_controller& Atm_controller::trace( Stream& stream ) {
+  Machine::setTrace( &stream, atm_serial_debug::trace, "CONTROLLER\0EVT_ON\0EVT_OFF\0EVT_INPUT\0ELSE\0OFF\0ON" );
+  return *this;
+}

firmware/lib/Automaton-1.0.2/src/Atm_controller.hpp

@@ -0,0 +1,47 @@
+#pragma once
+
+#include <Automaton.h>
+
+#define ATM_CONDITION_OPERAND_MAX 4
+
+class Atm_controller : public Machine {
+ public:
+  enum { OFF, ON };                           // STATES
+  enum { EVT_ON, EVT_OFF, EVT_INPUT, ELSE };  // EVENTS
+
+  Atm_controller( void ) : Machine(){};
+  Atm_controller& begin( bool initialState = false );
+  Atm_controller& onChange( bool status, atm_cb_push_t callback, int idx = 0 );
+  Atm_controller& onChange( bool status, Machine& machine, int event = 0 );
+  Atm_controller& onChange( atm_cb_push_t callback, int idx = 0 );
+  Atm_controller& onChange( Machine& machine, int event = 0 );
+  Atm_controller& onInput( bool status, atm_cb_push_t callback, int idx = 0 );
+  Atm_controller& onInput( bool status, Machine& machine, int event = 0 );
+  Atm_controller& IF( Machine& machine, char relOp = '>', int match = 0 );
+  Atm_controller& IF( atm_cb_pull_t callback, int idx = 0 );
+  Atm_controller& AND( Machine& machine, char relOp = '>', int match = 0 );
+  Atm_controller& AND( atm_cb_pull_t callback, int idx = 0 );
+  Atm_controller& OR( Machine& machine, char relOp = '>', int match = 0 );
+  Atm_controller& OR( atm_cb_pull_t callback, int idx = 0 );
+  Atm_controller& XOR( Machine& machine, char relOp = '>', int match = 0 );
+  Atm_controller& XOR( atm_cb_pull_t callback, int idx = 0 );
+  Atm_controller& led( int led, bool activeLow = false );
+  Atm_controller& trace( Stream& stream );
+
+ private:
+  enum { ENT_ON, ENT_OFF };                                                              // ACTIONS
+  enum { ON_CHANGE_FALSE, ON_CHANGE_TRUE, ON_INPUT_FALSE, ON_INPUT_TRUE, _CONN_SIZE_ };  // CONNECTORS
+  state_t last_state;
+  atm_connector connector[_CONN_SIZE_];
+  atm_connector operand[ATM_CONDITION_OPERAND_MAX];
+  int8_t indicator;
+  bool indicatorActiveLow;
+  const static char relOps[];
+
+  int event( int id );
+  void action( int id );
+  Atm_controller& OP( char logOp, Machine& machine, char relOp, int match );
+  Atm_controller& OP( char logOp, atm_cb_pull_t callback, int idx );
+  bool eval_one( atm_connector& connector );
+  bool eval_all();
+};

firmware/lib/Automaton-1.0.2/src/Atm_digital.cpp

@@ -0,0 +1,84 @@
+#include "Atm_digital.hpp"
+
+Atm_digital& Atm_digital::begin( int pin, int debounce /* = 20 */, bool activeLow /* = false */, bool pullUp /* = false */ ) {
+  // clang-format off
+  const static state_t state_table[] PROGMEM = {
+    /*              ON_ENTER    ON_LOOP      ON_EXIT  EVT_TIMER   EVT_HIGH  EVT_LOW   ELSE */
+    /* IDLE    */         -1,        -1,          -1,        -1,     WAITH,      -1,    -1,
+    /* WAITH   */         -1,        -1,          -1,     VHIGH,        -1,    IDLE,    -1,
+    /* VHIGH   */   ENT_HIGH,        -1,          -1,        -1,        -1,   WAITL,    -1, 
+    /* WAITL   */         -1,        -1,          -1,      VLOW,     VHIGH,      -1,    -1,
+    /* VLOW    */    ENT_LOW,        -1,          -1,        -1,        -1,      -1,  IDLE,
+  };
+  // clang-format on
+  Machine::begin( state_table, ELSE );
+  this->pin = pin;
+  this->activeLow = activeLow;
+  timer.set( debounce );
+  indicator = -1;
+  pinMode( pin, pullUp ? INPUT_PULLUP : INPUT );
+  return *this;
+}
+
+int Atm_digital::event( int id ) {
+  switch ( id ) {
+    case EVT_TIMER:
+      return timer.expired( this );
+    case EVT_HIGH:
+      return ( !digitalRead( pin ) != !activeLow );  // XOR
+    case EVT_LOW:
+      return !( !digitalRead( pin ) != !activeLow );
+  }
+  return 0;
+}
+
+void Atm_digital::action( int id ) {
+  switch ( id ) {
+    case ENT_HIGH:
+      connection[ON_CHANGE_TRUE].push( state() );
+      if ( indicator > -1 ) digitalWrite( indicator, !HIGH != !indicatorActiveLow );
+      return;
+    case ENT_LOW:
+      connection[ON_CHANGE_FALSE].push( state() );
+      if ( indicator > -1 ) digitalWrite( indicator, !LOW != !indicatorActiveLow );
+      return;
+  }
+}
+
+int Atm_digital::state( void ) {
+  return ( current == VHIGH || current == WAITL );
+}
+
+Atm_digital& Atm_digital::led( int led, bool activeLow /* = false */ ) {
+  indicator = led;
+  indicatorActiveLow = activeLow;
+  pinMode( indicator, OUTPUT );
+  return *this;
+}
+
+Atm_digital& Atm_digital::onChange( bool status, atm_cb_push_t callback, int idx /* = 0 */ ) {
+  connection[status ? ON_CHANGE_TRUE : ON_CHANGE_FALSE].set( callback, idx );
+  return *this;
+}
+
+Atm_digital& Atm_digital::onChange( bool status, Machine& machine, int event /* = 0 */ ) {
+  connection[status ? ON_CHANGE_TRUE : ON_CHANGE_FALSE].set( &machine, event );
+  return *this;
+}
+
+Atm_digital& Atm_digital::onChange( atm_cb_push_t callback, int idx /* = 0 */ ) {
+  connection[ON_CHANGE_FALSE].set( callback, idx );
+  connection[ON_CHANGE_TRUE].set( callback, idx );
+  return *this;
+}
+
+Atm_digital& Atm_digital::onChange( Machine& machine, int event /* = 0 */ ) {
+  connection[ON_CHANGE_FALSE].set( &machine, event );
+  connection[ON_CHANGE_TRUE].set( &machine, event );
+  return *this;
+}
+
+Atm_digital& Atm_digital::trace( Stream& stream ) {
+  setTrace( &stream, atm_serial_debug::trace, "DIGITAL\0EVT_TIMER\0EVT_HIGH\0EVT_LOW\0ELSE\0IDLE\0WAITH\0VHIGH\0WAITL\0VLOW" );
+  return *this;
+}

firmware/lib/Automaton-1.0.2/src/Atm_digital.hpp

@@ -0,0 +1,35 @@
+#pragma once
+
+#include <Automaton.h>
+
+// Digital pin with a minimum duration in ms
+// On detection another machine is messaged or a callback is fired
+
+class Atm_digital : public Machine {
+ public:
+  enum { IDLE, WAITH, VHIGH, WAITL, VLOW };     // STATES
+  enum { EVT_TIMER, EVT_HIGH, EVT_LOW, ELSE };  // EVENTS
+
+  Atm_digital( void ) : Machine(){};
+  Atm_digital& begin( int pin, int debounce = 20, bool activeLow = false, bool pullUp = false );
+  int state( void );
+  Atm_digital& onChange( bool status, atm_cb_push_t callback, int idx = 0 );
+  Atm_digital& onChange( bool status, Machine& machine, int event = 0 );
+  Atm_digital& onChange( atm_cb_push_t callback, int idx = 0 );
+  Atm_digital& onChange( Machine& machine, int event = 0 );
+  Atm_digital& led( int led, bool activeLow = false );
+  Atm_digital& trace( Stream& stream );
+
+ private:
+  enum { ENT_HIGH, ENT_LOW };                             // ACTIONS
+  enum { ON_CHANGE_FALSE, ON_CHANGE_TRUE, _CONN_SIZE_ };  // CONNECTORS
+  short pin;
+  atm_timer_millis timer;
+  bool activeLow;
+  atm_connector connection[_CONN_SIZE_];
+  int8_t indicator;
+  bool indicatorActiveLow;
+
+  int event( int id );
+  void action( int id );
+};

firmware/lib/Automaton-1.0.2/src/Atm_encoder.cpp

@@ -0,0 +1,142 @@
+#include "Atm_encoder.hpp"
+#include <limits.h>
+
+// Loosely based on https://www.circuitsathome.com/mcu/reading-rotary-encoder-on-arduino (Oleg Mazurov)
+
+const char Atm_encoder::enc_states[16] = {0, (char)-1, 1, 0, 1, 0, 0, (char)-1, (char)-1, 0, 0, 1, 0, 1, (char)-1, 0};
+
+Atm_encoder& Atm_encoder::begin( int pin1, int pin2, int divider /* = 1 */ ) {
+  // clang-format off
+  const static state_t state_table[] PROGMEM = {
+    /*          ON_ENTER     ON_LOOP  ON_EXIT  EVT_UP  EVT_DOWN  ELSE */
+    /* IDLE  */       -1,    LP_IDLE,      -1,     UP,     DOWN,   -1,
+    /* UP    */   ENT_UP,         -1,      -1,     -1,       -1, IDLE,
+    /* DOWN  */ ENT_DOWN,         -1,      -1,     -1,       -1, IDLE,
+  };
+  // clang-format on
+  Machine::begin( state_table, ELSE );
+  this->pin1 = pin1;
+  this->pin2 = pin2;
+  this->divider = divider;
+  pinMode( pin1, INPUT );
+  pinMode( pin2, INPUT );
+  digitalWrite( pin1, HIGH );
+  digitalWrite( pin2, HIGH );
+  min = INT_MIN;
+  max = INT_MAX;
+  value = 0;
+  return *this;
+}
+
+int Atm_encoder::event( int id ) {
+  switch ( id ) {
+    case EVT_UP:
+      return enc_direction == +1 && ( enc_counter % divider == 0 );
+    case EVT_DOWN:
+      return enc_direction == -1 && ( enc_counter % divider == 0 );
+  }
+  return 0;
+}
+
+void Atm_encoder::action( int id ) {
+  switch ( id ) {
+    case LP_IDLE:
+      enc_bits = ( ( enc_bits << 2 ) | ( digitalRead( pin1 ) << 1 ) | ( digitalRead( pin2 ) ) ) & 0x0f;
+      enc_direction = enc_states[enc_bits];
+      if ( enc_direction != 0 ) {
+        enc_counter = enc_counter + enc_direction;
+        if ( ( enc_counter != 0 ) && ( enc_counter % divider == 0 ) ) {
+          if ( !count( enc_direction ) ) {
+            enc_direction = 0;
+          }
+        }
+      }
+      return;
+    case ENT_UP:
+      onup.push( state(), 1 );
+      return;
+    case ENT_DOWN:
+      ondown.push( state(), 0 );
+      return;
+  }
+}
+
+Atm_encoder& Atm_encoder::range( int min, int max, bool wrap /* = false */ ) {
+  if ( min > max ) {
+    range_invert = true;
+    this->min = max;
+    this->max = min;
+  } else {
+    range_invert = false;
+    this->min = min;
+    this->max = max;
+  }
+  this->wrap = wrap;
+  if ( value < min || value > max ) {
+    value = min;
+  }
+  return *this;
+}
+
+Atm_encoder& Atm_encoder::set( int value ) {
+  this->value = range_invert ? map( value, min, max, max, min ) : value;
+  return *this;
+}
+
+Atm_encoder& Atm_encoder::onChange( Machine& machine, int event /* = 0 */ ) {
+  onup.set( &machine, event );
+  ondown.set( &machine, event );
+  return *this;
+}
+
+Atm_encoder& Atm_encoder::onChange( atm_cb_push_t callback, int idx /* = 0 */ ) {
+  onup.set( callback, idx );
+  ondown.set( callback, idx );
+  return *this;
+}
+
+Atm_encoder& Atm_encoder::onChange( bool status, Machine& machine, int event /* = 0 */ ) {
+  if ( status ) {
+    onup.set( &machine, event );
+  } else {
+    ondown.set( &machine, event );
+  }
+  return *this;
+}
+
+Atm_encoder& Atm_encoder::onChange( bool status, atm_cb_push_t callback, int idx /* = 0 */ ) {
+  if ( status ) {
+    onup.set( callback, idx );
+  } else {
+    ondown.set( callback, idx );
+  }
+  return *this;
+}
+
+int Atm_encoder::state( void ) {
+  return range_invert ? map( value, min, max, max, min ) : value;
+}
+
+bool Atm_encoder::count( int direction ) {
+  if ( (long)value + direction > max ) {
+    if ( wrap ) {
+      value = min;
+    } else {
+      return false;
+    }
+  } else if ( (long)value + direction < min ) {
+    if ( wrap ) {
+      value = max;
+    } else {
+      return false;
+    }
+  } else {
+    value += direction;
+  }
+  return true;
+}
+
+Atm_encoder& Atm_encoder::trace( Stream& stream ) {
+  Machine::setTrace( &stream, atm_serial_debug::trace, "ENCODER\0EVT_UP\0EVT_DOWN\0ELSE\0IDLE\0UP\0DOWN" );
+  return *this;
+}

firmware/lib/Automaton-1.0.2/src/Atm_encoder.hpp

@@ -0,0 +1,36 @@
+#pragma once
+
+#include <Automaton.h>
+
+class Atm_encoder : public Machine {
+ public:
+  enum { IDLE, UP, DOWN };          // STATES
+  enum { EVT_UP, EVT_DOWN, ELSE };  // EVENTS
+
+  Atm_encoder( void ) : Machine(){};
+  Atm_encoder& begin( int pin1, int pin2, int divider = 1 );
+  Atm_encoder& trace( Stream& stream );
+  Atm_encoder& onChange( Machine& machine, int event = 0 );
+  Atm_encoder& onChange( atm_cb_push_t callback, int idx = 0 );
+  Atm_encoder& onChange( bool status, Machine& machine, int event = 0 );
+  Atm_encoder& onChange( bool status, atm_cb_push_t callback, int idx = 0 );
+  int state( void );
+  Atm_encoder& range( int min, int max, bool wrap = false );
+  Atm_encoder& set( int value );
+
+ private:
+  enum { LP_IDLE, ENT_UP, ENT_DOWN };  // ACTIONS
+  short pin1, pin2;
+  const static char enc_states[];
+  uint8_t enc_bits;
+  int8_t enc_counter;
+  int8_t enc_direction;
+  int divider;
+  int value, min, max;
+  bool wrap, range_invert;
+  atm_connector onup, ondown;
+
+  bool count( int direction );
+  int event( int id );
+  void action( int id );
+};

firmware/lib/Automaton-1.0.2/src/Atm_fade.cpp

@@ -0,0 +1,152 @@
+#include "Atm_fade.hpp"
+
+Atm_fade& Atm_fade::begin( int attached_pin ) {
+  // clang-format off
+  const static state_t state_table[] PROGMEM = {
+    /*               ON_ENTER    ON_LOOP       ON_EXIT  EVT_CNT_FADE EVT_TM_FADE   EVT_TM_ON  EVT_TM_OFF   EVT_CNT_RPT  EVT_ON EVT_OFF EVT_BLINK  EVT_TOGGLE  EVT_TOGGLE_BLINK    ELSE  */
+    /* IDLE   */      ENT_OFF, ATM_SLEEP,           -1,           -1,         -1,         -1,         -1,           -1,OSTARTU,   IDLE,    START,    OSTARTU,            START,     -1,  // LED off
+    /* ON     */       ENT_ON, ATM_SLEEP,           -1,           -1,         -1,         -1,         -1,           -1,     -1,OSTARTD,    START,    OSTARTD,          OSTARTD,     -1,  // LED on
+    /* START  */      ENT_OFF,        -1,           -1,           -1,         -1,         -1,         -1,           -1,OSTARTU,   IDLE,    START,       IDLE,             IDLE, STARTU,  // Start fading
+    /* STARTU */    ENT_START,        -1,           -1,           -1,         -1,         -1,         UP,           -1,OSTARTU,   IDLE,    START,       IDLE,             IDLE,     -1,  
+    /* UP     */       ENT_UP,        -1,           -1,       STARTD,         UP,         -1,         -1,           -1,OSTARTU,   IDLE,    START,       IDLE,             IDLE,     -1,
+    /* STARTD */    ENT_START,        -1,           -1,           -1,         -1,       DOWN,         -1,           -1,OSTARTU,   IDLE,    START,       IDLE,             IDLE,     -1,
+    /* DOWN   */     ENT_DOWN,        -1,           -1,       REPEAT,       DOWN,         -1,         -1,           -1,OSTARTU,   IDLE,    START,       IDLE,             IDLE,     -1,
+    /* REPEAT */   ENT_REPEAT,        -1,           -1,           -1,         -1,         -1,         -1,         DONE,OSTARTU,   IDLE,    START,       IDLE,             IDLE, STARTU,
+    /* DONE   */     ENT_DONE,        -1,           -1,           -1,         -1,         -1,         -1,           -1,     -1,     -1,       -1,         -1,               -1,   IDLE,
+    /* OSTARTU*/    ENT_START,        -1,           -1,           -1,         -1,         -1,         -1,           -1,     -1,   IDLE,    START,       IDLE,             IDLE,    OUP,  
+    /* OUP    */       ENT_UP,        -1,           -1,           ON,        OUP,         -1,         -1,           -1,     -1,   IDLE,    START,       IDLE,             IDLE,     -1,
+    /* OSTARTD*/    ENT_START,        -1,           -1,           -1,         -1,         -1,         -1,           -1,OSTARTU,   IDLE,    START,       IDLE,             IDLE,  ODOWN,
+    /* ODOWN  */     ENT_DOWN,        -1,           -1,         IDLE,      ODOWN,         -1,         -1,           -1,OSTARTU,   IDLE,    START,       IDLE,             IDLE,     -1,
+
+  };
+  // clang-format on
+  Machine::begin( state_table, ELSE );
+  pin = attached_pin;
+  pinMode( pin, OUTPUT );
+  timer_fade.set( 0 );   // Number of ms per slope step (slope duration: rate * 32 ms)
+  timer_on.set( 500 );   // Plateau between slopes (in which led is fully on)
+  timer_off.set( 500 );  // Pause between slopes (in which led is fully off)
+  counter_fade.set( SLOPE_SIZE );
+  counter_repeat.set( ATM_COUNTER_OFF );
+  repeat_count = ATM_COUNTER_OFF;
+  return *this;
+}
+
+Atm_fade& Atm_fade::blink( uint32_t duration, uint32_t pause_duration, uint16_t repeat_count /* = ATM_COUNTER_OFF */ ) {
+  blink( duration );  // Time in which led is fully on
+  pause( pause_duration );
+  repeat( repeat_count );
+  return *this;
+}
+
+Atm_fade& Atm_fade::blink( uint32_t duration ) {
+  timer_on.set( duration );  // Plateau between slopes (in which led is fully on)
+  return *this;
+}
+
+Atm_fade& Atm_fade::blink( void ) {
+  trigger( EVT_BLINK );
+  return *this;
+}
+
+Atm_fade& Atm_fade::pause( uint32_t duration ) {  // Pause between slopes (in which led is fully off)
+  timer_off.set( duration ? duration : 1 );       // Make sure off_timer is never 0 (work around)
+  return *this;
+}
+
+Atm_fade& Atm_fade::fade( int fade ) {
+  timer_fade.set( fade >= 0 ? fade : ATM_TIMER_OFF );  // Number of ms per slope step (slope duration: rate * 32 ms)
+  return *this;
+}
+
+Atm_fade& Atm_fade::repeat( uint16_t repeat ) {
+  counter_repeat.set( repeat_count = repeat );
+  return *this;
+}
+
+int Atm_fade::event( int id ) {
+  switch ( id ) {
+    case EVT_TM_FADE:
+      return timer_fade.expired( this );
+    case EVT_TM_ON:
+      return timer_on.expired( this );
+    case EVT_TM_OFF:
+      return timer_off.expired( this );
+    case EVT_CNT_FADE:
+      return counter_fade.expired();
+    case EVT_CNT_RPT:
+      return counter_repeat.expired();
+  }
+  return 0;
+}
+
+void Atm_fade::action( int id ) {
+  switch ( id ) {
+    case ENT_ON:
+      analogWrite( pin, 255 );
+      return;
+    case ENT_REPEAT:
+      counter_repeat.decrement();
+      return;
+    case ENT_OFF:
+      counter_repeat.set( repeat_count );
+      analogWrite( pin, 0 );
+      return;
+    case ENT_START:
+      counter_fade.set( SLOPE_SIZE );
+      return;
+    case ENT_UP:
+      analogWrite( pin, slope[SLOPE_SIZE - counter_fade.value] );
+      counter_fade.decrement();
+      return;
+    case ENT_DOWN:
+      analogWrite( pin, slope[counter_fade.value - 1] );
+      counter_fade.decrement();
+      return;
+    case ENT_DONE:
+      onfinish.push( 0 );
+      return;    
+  }
+}
+
+Atm_fade& Atm_fade::on( void ) {
+  trigger( EVT_ON );
+  return *this;
+}
+
+Atm_fade& Atm_fade::off( void ) {
+  trigger( EVT_OFF );
+  return *this;
+}
+
+Atm_fade& Atm_fade::toggle( void ) {
+  trigger( EVT_TOGGLE );
+  return *this;
+}
+
+Atm_fade& Atm_fade::toggleBlink( void ) {
+  trigger( EVT_TOGGLE_BLINK );
+  return *this;
+}
+
+Atm_fade& Atm_fade::start( void ) {
+  trigger( EVT_BLINK );
+  return *this;
+}
+
+Atm_fade& Atm_fade::onFinish( Machine& machine, int event /* = 0 */ ) {
+  onfinish.set( &machine, event );
+  return *this;
+}
+
+Atm_fade& Atm_fade::onFinish( atm_cb_push_t callback, int idx /* = 0 */ ) {
+  onfinish.set( callback, idx );
+  return *this;
+}
+
+Atm_fade& Atm_fade::trace( Stream& stream ) {
+  setTrace( &stream, atm_serial_debug::trace,
+            "FADE\0EVT_CNT_FADE\0EVT_TM_FADE\0EVT_TM_ON\0EVT_TM_OFF\0EVT_CNT_RPT\0EVT_ON\0EVT_OFF\0EVT_BLINK\0EVT_TOGGLE\0EVT_TOGGLE_BLINK\0ELSE\0"
+            "IDLE\0ON\0START\0STARTU\0UP\0STARTD\0DOWN\0REPEAT\0DONE\0OSTARTU\0OUP\0OSTARTD\0ODOWN" );
+  return *this;
+}

firmware/lib/Automaton-1.0.2/src/Atm_fade.hpp

@@ -0,0 +1,39 @@
+#pragma once
+
+#include <Automaton.h>
+
+class Atm_fade : public Machine {
+ public:
+  enum { IDLE, ON, START, STARTU, UP, STARTD, DOWN, REPEAT, DONE, OSTARTU, OUP, OSTARTD, ODOWN };
+  enum { EVT_CNT_FADE, EVT_TM_FADE, EVT_TM_ON, EVT_TM_OFF, EVT_CNT_RPT, EVT_ON, EVT_OFF, EVT_BLINK, EVT_TOGGLE, EVT_TOGGLE_BLINK, ELSE };
+  enum { EVT_START = EVT_BLINK };
+
+  Atm_fade( void ) : Machine(){};
+  Atm_fade& begin( int attached_pin );
+  Atm_fade& trace( Stream& stream );
+  Atm_fade& blink( uint32_t duration, uint32_t pause_duration, uint16_t repeat_count = ATM_COUNTER_OFF );
+  Atm_fade& blink( uint32_t duration );
+  Atm_fade& blink( void );
+  Atm_fade& pause( uint32_t duration );
+  Atm_fade& fade( int fade );
+  Atm_fade& repeat( uint16_t repeat );
+  Atm_fade& on( void );
+  Atm_fade& off( void );
+  Atm_fade& toggle( void );
+  Atm_fade& toggleBlink( void );
+  Atm_fade& start( void );
+  Atm_fade& onFinish( Machine& machine, int event = 0 );
+  Atm_fade& onFinish( atm_cb_push_t callback, int idx = 0 );
+
+ private:
+  enum { ENT_REPEAT, ENT_OFF, ENT_ON, ENT_UP, ENT_DOWN, ENT_START, ENT_DONE };
+  static const uint8_t SLOPE_SIZE = 32;
+  uint8_t slope[SLOPE_SIZE] = {0, 0, 1, 1, 2, 2, 3, 4, 5, 6, 7, 8, 10, 12, 15, 18, 22, 26, 31, 37, 44, 54, 63, 76, 90, 108, 127, 153, 180, 217, 230, 255};
+  short pin;
+  uint16_t repeat_count;
+  atm_connector onfinish;
+  atm_timer_millis timer_fade, timer_on, timer_off;
+  atm_counter counter_fade, counter_repeat;
+  int event( int id );
+  void action( int id );
+};

firmware/lib/Automaton-1.0.2/src/Atm_fan.cpp

@@ -0,0 +1,87 @@
+
+#include "Atm_fan.hpp"
+
+/* Add optional parameters for the state machine to begin()
+ * Add extra initialization code
+ */
+
+Atm_fan& Atm_fan::begin() {
+  // clang-format off
+  const static state_t state_table[] PROGMEM = {
+    /*          ON_ENTER    ON_LOOP  ON_EXIT  EVT_INPUT  ELSE */
+    /*  IDLE */       -1, ATM_SLEEP,      -1,      SEND,   -1,
+    /*  SEND */ ENT_SEND,        -1,      -1,        -1, IDLE,
+  };
+  // clang-format on
+  Machine::begin( state_table, ELSE );
+  return *this;
+}
+
+/* Add C++ code for each internally handled event (input)
+ * The code must return 1 to trigger the event
+ */
+
+int Atm_fan::event( int id ) {
+  switch ( id ) {
+    case EVT_INPUT:
+      return 0;
+  }
+  return 0;
+}
+
+/* Add C++ code for each action
+ * This generates the 'output' for the state machine
+ */
+
+void Atm_fan::action( int id ) {
+  switch ( id ) {
+    case ENT_SEND:
+      push( connectors, ON_INPUT | ATM_BROADCAST, 4, 1, 1 );
+      return;
+  }
+}
+
+/* Optionally override the default trigger() method
+ * Control how your machine processes triggers
+ */
+
+Atm_fan& Atm_fan::trigger( int event ) {
+  Machine::trigger( event );
+  return *this;
+}
+
+/* Optionally override the default state() method
+ * Control what the machine returns when another process requests its state
+ */
+
+int Atm_fan::state( void ) {
+  return Machine::state();
+}
+
+/* Nothing customizable below this line
+ ************************************************************************************************
+*/
+
+/* onInput() push connector variants ( slots 4, autostore 1, broadcast 1 )
+ *
+ * Usage in action() handler: push( connectors, ON_INPUT | ATM_BROADCAST, 4, v, up );
+ */
+
+Atm_fan& Atm_fan::onInput( Machine& machine, int event ) {
+  onPush( connectors, ON_INPUT, -1, 4, 0, machine, event );
+  return *this;
+}
+
+Atm_fan& Atm_fan::onInput( atm_cb_push_t callback, int idx ) {
+  onPush( connectors, ON_INPUT, -1, 4, 0, callback, idx );
+  return *this;
+}
+
+/* State trace method
+ * Sets the symbol table and the default logging method for serial monitoring
+ */
+
+Atm_fan& Atm_fan::trace( Stream& stream ) {
+  Machine::setTrace( &stream, atm_serial_debug::trace, "FAN\0EVT_INPUT\0ELSE\0IDLE\0SEND" );
+  return *this;
+}

firmware/lib/Automaton-1.0.2/src/Atm_fan.hpp

@@ -0,0 +1,51 @@
+#pragma once
+
+#include <Automaton.h>
+
+class Atm_fan : public Machine {
+ public:
+  enum { IDLE, SEND };       // STATES
+  enum { EVT_INPUT, ELSE };  // EVENTS
+  Atm_fan( void ) : Machine(){};
+  Atm_fan& begin( void );
+  Atm_fan& trace( Stream& stream );
+  Atm_fan& trigger( int event );
+  int state( void );
+  Atm_fan& onInput( Machine& machine, int event = 0 );
+  Atm_fan& onInput( atm_cb_push_t callback, int idx = 0 );
+
+ private:
+  enum { ENT_SEND };                // ACTIONS
+  enum { ON_INPUT, CONN_MAX = 4 };  // CONNECTORS
+  atm_connector connectors[CONN_MAX];
+  int event( int id );
+  void action( int id );
+};
+
+/*
+Automaton::ATML::begin - Automaton Markup Language
+
+<?xml version="1.0" encoding="UTF-8"?>
+<machines>
+  <machine name="Atm_fan">
+    <states>
+      <IDLE index="0" sleep="1">
+        <EVT_INPUT>SEND</EVT_INPUT>
+      </IDLE>
+      <SEND index="1" on_enter="ENT_SEND">
+        <ELSE>IDLE</ELSE>
+      </SEND>
+    </states>
+    <events>
+      <EVT_INPUT index="0"/>
+    </events>
+    <connectors>
+      <INPUT autostore="1" broadcast="1" dir="PUSH" slots="4"/>
+    </connectors>
+    <methods>
+    </methods>
+  </machine>
+</machines>
+
+Automaton::ATML::end
+*/

firmware/lib/Automaton-1.0.2/src/Atm_led.cpp

@@ -0,0 +1,241 @@
+#include "Atm_led.hpp"
+
+Atm_led& Atm_led::begin( int attached_pin, bool activeLow ) {
+  // clang-format off
+  static const state_t state_table[] PROGMEM = {
+    /*               ON_ENTER    ON_LOOP    ON_EXIT  EVT_ON_TIMER  EVT_OFF_TIMER EVT_WT_TIMER EVT_COUNTER  EVT_ON  EVT_OFF  EVT_BLINK  EVT_TOGGLE  EVT_TOGGLE_BLINK   ELSE */
+    /* IDLE      */  ENT_INIT, ATM_SLEEP,        -1,           -1,            -1,          -1,         -1,  WT_ON,      -1,  WT_START,         ON,         WT_START,    -1, // LED off
+    /* ON        */    ENT_ON, ATM_SLEEP,        -1,           -1,            -1,          -1,         -1,     -1,     OFF,  WT_START,        OFF,              OFF,    -1, // LED on
+    /* START     */    ENT_ON,        -1,        -1,    BLINK_OFF,            -1,          -1,         -1,  WT_ON,     OFF,        -1,        OFF,              OFF,    -1, // Start blinking
+    /* BLINK_OFF */   ENT_OFF,        -1,        -1,           -1,          LOOP,          -1,         -1,  WT_ON,     OFF,        -1,        OFF,              OFF,    -1,
+    /* LOOP      */        -1,        -1,        -1,           -1,            -1,          -1,       DONE,  WT_ON,     OFF,        -1,        OFF,              OFF, START,    
+    /* DONE      */        -1,        -1, EXT_CHAIN,           -1,           OFF,          -1,         -1,  WT_ON,     OFF,  WT_START,        OFF,              OFF,    -1, // Wait after last blink
+    /* OFF       */   ENT_OFF,        -1,        -1,           -1,            -1,          -1,         -1,  WT_ON,     OFF,  WT_START,         -1,               -1,  IDLE, // All off -> IDLE
+    /* WT_ON     */        -1,        -1,        -1,           -1,            -1,          ON,         -1,  WT_ON,     OFF,  WT_START,         -1,               -1,    -1, // LEAD for ON
+    /* WT_START  */        -1,        -1,        -1,           -1,            -1,       START,         -1,  WT_ON,     OFF,  WT_START,         -1,               -1,    -1, // LEAD for BLINK
+  }; 
+  // clang-format on
+  Machine::begin( state_table, ELSE );
+  pin = attached_pin;
+  this->activeLow = activeLow;
+  level = 255;
+  toLow = 0;
+  toHigh = 255;
+  wrap = false;
+  pinMode( pin, OUTPUT );
+  digitalWrite( pin, activeLow ? HIGH : LOW );
+  on_timer.set( 500 );
+  off_timer.set( 500 );
+  pwm( 512, 1 );
+  lead_timer.set( 0 );
+  repeat_count = ATM_COUNTER_OFF;
+  counter.set( repeat_count );
+  while ( state() != 0 ) cycle();
+  return *this;
+}
+
+Atm_led& Atm_led::pwm( uint16_t width, float freq ) {
+
+    if ( freq > -1 ) {	
+		this->freq = freq;
+	} else {
+		freq = this->freq;
+	}
+	this->width = width;
+	float cycle_width = 1000 / freq;
+	on_timer.set( cycle_width / 1024 * this->width );
+	off_timer.set( cycle_width / 1024 * ( 1024 - this->width ) );
+	return *this;
+}
+
+Atm_led& Atm_led::frequency( float freq ) {
+
+	this->freq = freq;
+	float cycle_width = 1000 / freq;
+	on_timer.set( cycle_width / 1024 * this->width );
+	off_timer.set( cycle_width / 1024 * ( 1024 - this->width ) );
+	return *this;
+}
+
+int Atm_led::event( int id ) {
+  switch ( id ) {
+    case EVT_ON_TIMER:
+      return on_timer.expired( this );
+    case EVT_OFF_TIMER:
+      return off_timer.expired( this );
+    case EVT_WT_TIMER:
+      return lead_timer.expired( this );
+    case EVT_COUNTER:
+      return counter.expired();
+  }
+  return 0;
+}
+
+void Atm_led::action( int id ) {
+  switch ( id ) {
+    case ENT_INIT:
+      counter.set( repeat_count );
+      return;
+    case ENT_ON:
+      if ( on_timer.value > 0 ) { // Never turn if on_timer is zero (duty cycle 0 must be dark)
+        if ( activeLow ) {
+          digitalWrite( pin, LOW );
+        } else {
+          if ( level == toHigh ) {
+            digitalWrite( pin, HIGH );
+          } else {
+            analogWrite( pin, mapLevel( level ) );
+          }
+        }
+      }
+      return;
+    case ENT_OFF:
+      counter.decrement();
+      if ( !activeLow ) {
+        digitalWrite( pin, LOW );
+      } else {
+        if ( level == toHigh ) {
+          digitalWrite( pin, HIGH );
+        } else {
+          analogWrite( pin, mapLevel( level ) );
+        }
+      }
+      return;
+    case EXT_CHAIN:
+      onfinish.push( 0 );
+      return;
+  }
+}
+
+int Atm_led::mapLevel( int level ) {
+  if ( levelMapSize ) {
+    return levelMap[level];
+  } else {
+    return map( level, toLow, toHigh, 0, 255 );
+  }
+}
+
+Atm_led& Atm_led::on( void ) {
+  trigger( EVT_ON );
+  return *this;
+}
+
+Atm_led& Atm_led::off( void ) {
+  trigger( EVT_OFF );
+  return *this;
+}
+
+Atm_led& Atm_led::toggle( void ) {
+  trigger( EVT_TOGGLE );
+  return *this;
+}
+
+Atm_led& Atm_led::toggleBlink( void ) {
+  trigger( EVT_TOGGLE_BLINK );
+  return *this;
+}
+
+Atm_led& Atm_led::start( void ) {
+  trigger( EVT_BLINK );
+  return *this;
+}
+
+Atm_led& Atm_led::onFinish( Machine& machine, int event /* = 0 */ ) {
+  onfinish.set( &machine, event );
+  return *this;
+}
+
+Atm_led& Atm_led::onFinish( atm_cb_push_t callback, int idx /* = 0 */ ) {
+  onfinish.set( callback, idx );
+  return *this;
+}
+
+Atm_led& Atm_led::blink( uint32_t duration, uint32_t pause_duration, uint16_t repeat_count /* = ATM_COUNTER_OFF */ ) {
+  blink( duration );  // Time in which led is fully on
+  pause( pause_duration );
+  repeat( repeat_count );
+  return *this;
+}
+
+Atm_led& Atm_led::blink( uint32_t duration ) {
+  on_timer.set( duration );  // Time in which led is fully on
+  return *this;
+}
+
+Atm_led& Atm_led::blink( void ) {
+  trigger( EVT_BLINK );
+  return *this;
+}
+
+Atm_led& Atm_led::range( int toLow, int toHigh, bool wrap /* = false */ ) {
+  this->toLow = toLow; 
+  this->toHigh = toHigh; 
+  this->wrap = wrap;
+  level = toHigh;
+  return *this;
+}
+
+Atm_led& Atm_led::levels( unsigned char* map, int mapsize, bool wrap /* = false */ ) {
+  this->levelMap = map;
+  levelMapSize = mapsize;
+  range( 0, mapsize - 1, wrap );
+  return *this;
+}
+
+Atm_led& Atm_led::pause( uint32_t duration ) {  // Time in which led is fully off
+  off_timer.set( duration ? duration : 1 );     // Make sure off_timer is never 0 (work around)
+  return *this;
+}
+
+Atm_led& Atm_led::fade( int fade ) {
+  return *this;
+}  // Dummy for method compatibility with Atm_fade
+
+Atm_led& Atm_led::lead( uint32_t ms ) {
+  lead_timer.set( ms );
+  return *this;
+} 
+
+Atm_led& Atm_led::repeat( uint16_t repeat ) {
+  counter.set( repeat_count = repeat );
+  return *this;
+}
+
+int Atm_led::brightness( int level /* = -1 */ ) {
+  if ( level > -1 ) {
+    this->level = level;
+    if ( current == ON || current == START ) {
+      analogWrite( pin, mapLevel( level ) );
+    }
+  }
+  return this->level;
+}
+
+int Atm_led::brighten( int v ) {
+  if ( abs( v ) == 1 ) {
+    int br = (int)this->level + v;
+    if ( br > toHigh ) 
+      br = wrap ? toLow : toHigh;
+    if ( br < toLow ) 
+      br = wrap ? toHigh : toLow;
+    brightness( br );
+  }
+  return this->level;
+}
+
+Atm_led& Atm_led::trigger( int event ) {
+  if ( event > ELSE ) {
+    brighten( event == EVT_BRUP ? 1 : -1 );
+  } else {
+    Machine::trigger( event );
+  }
+  return *this;
+}
+
+Atm_led& Atm_led::trace( Stream& stream ) {
+  setTrace( &stream, atm_serial_debug::trace,
+            "LED\0EVT_ON_TIMER\0EVT_OFF_TIMER\0EVT_WT_TIMER\0EVT_COUNTER\0EVT_ON\0EVT_OFF\0EVT_"
+            "BLINK\0EVT_TOGGLE\0EVT_TOGGLE_BLINK\0ELSE\0"
+            "IDLE\0ON\0START\0BLINK_OFF\0LOOP\0DONE\0OFF\0WT_ON\0WT_START" );
+  return *this;
+}

firmware/lib/Automaton-1.0.2/src/Atm_led.hpp

@@ -0,0 +1,56 @@
+#pragma once
+
+#include <Automaton.h>
+
+class Atm_led : public Machine {
+ public:
+  enum { IDLE, ON, START, BLINK_OFF, LOOP, DONE, OFF, WT_ON, WT_START };
+  enum { EVT_ON_TIMER, EVT_OFF_TIMER, EVT_WT_TIMER, EVT_COUNTER, EVT_ON, EVT_OFF, EVT_BLINK, EVT_TOGGLE, EVT_TOGGLE_BLINK, ELSE, EVT_BRUP, EVT_BRDN }; // BRUP/BRDN pseudo
+  enum { EVT_START = EVT_BLINK };
+
+  Atm_led( void ) : Machine(){};
+  Atm_led& begin( int attached_pin, bool activeLow = false );
+  Atm_led& blink( void );
+  Atm_led& blink( uint32_t duration );
+  Atm_led& blink( uint32_t duration, uint32_t pause_duration, uint16_t repeat_count = ATM_COUNTER_OFF );
+  Atm_led& pwm( uint16_t width, float freq = -1 );
+  Atm_led& frequency( float freq ); 
+  Atm_led& pause( uint32_t duration );
+  Atm_led& fade( int fade );
+  Atm_led& lead( uint32_t ms );
+  Atm_led& repeat( uint16_t repeat );
+  int brightness( int level = -1 );
+  Atm_led& on( void );
+  Atm_led& off( void );
+  Atm_led& toggle( void );
+  Atm_led& toggleBlink( void );
+  Atm_led& start( void );
+  Atm_led& trace( Stream& stream );
+  Atm_led& onFinish( Machine& machine, int event = 0 );
+  Atm_led& onFinish( atm_cb_push_t callback, int idx = 0 );
+  Atm_led& range( int toLow, int toHigh, bool wrap = false );
+  Atm_led& levels( unsigned char* map, int mapsize, bool wrap = false );
+  int brighten( int v = 1 );
+  Atm_led& trigger( int event );
+
+ private:
+  enum { ENT_INIT, ENT_ON, ENT_OFF, EXT_CHAIN };
+  uint8_t level;
+  short pin;
+  bool activeLow;
+  uint8_t toHigh, toLow;
+  bool wrap;
+  uint16_t repeat_count;
+  uint16_t width;
+  float freq;
+  atm_timer_millis on_timer, off_timer, lead_timer;
+  atm_counter counter;
+  atm_connector onfinish;
+  unsigned char* levelMap;
+  int levelMapSize;  
+  int mapLevel( int level );
+
+
+  int event( int id );
+  void action( int id );
+};

firmware/lib/Automaton-1.0.2/src/Atm_player.cpp

@@ -0,0 +1,242 @@
+#include "Atm_player.hpp"
+
+/* Add optional parameters for the state machine to begin()
+ * Add extra initialization code
+ */
+
+Atm_player& Atm_player::begin( int pin /* = - 1 */ ) {
+  // clang-format off
+  const static state_t state_table[] PROGMEM = {
+    /*             ON_ENTER    ON_LOOP  ON_EXIT  EVT_START  EVT_STOP  EVT_TOGGLE  EVT_TIMER  EVT_EOPAT  EVT_REPEAT   ELSE */
+    /*   IDLE */   ENT_IDLE, ATM_SLEEP,      -1,     START,       -1,      START,        -1,        -1,         -1,    -1,
+    /*  START */  ENT_START,        -1,      -1,        -1,       -1,         -1,        -1,        -1,         -1, SOUND,
+    /*  SOUND */  ENT_SOUND,        -1,      -1,        -1,     IDLE,       IDLE,     QUIET,        -1,         -1,    -1,
+    /*  QUIET */  ENT_QUIET,        -1,      -1,        -1,     IDLE,       IDLE,      NEXT,        -1,         -1,    -1,
+    /*   NEXT */   ENT_NEXT,        -1,      -1,        -1,     IDLE,       IDLE,        -1,    REPEAT,         -1, SOUND,
+    /* REPEAT */ ENT_REPEAT,        -1,      -1,        -1,     IDLE,       IDLE,        -1,        -1,     FINISH, START,
+    /* FINISH */ ENT_FINISH,        -1,      -1,        -1,     IDLE,         -1,        -1,        -1,       IDLE, START,
+  };
+  // clang-format on
+  Machine::begin( state_table, ELSE );
+  Atm_player::pin = pin;
+  speed( 100 );
+  pitch( 100 );
+  repeat( 1 );
+  play( 880, 50 );
+  return *this;
+}
+
+/* Add C++ code for each event (input)
+ * The code must return 1 if the event should be triggered
+ */
+
+int Atm_player::event( int id ) {
+  switch ( id ) {
+    case EVT_START:
+      return 0;
+    case EVT_TIMER:
+      return timer.expired( this );
+    case EVT_EOPAT:
+      if ( patternwidth == 32 ) {
+        return ( step * 3 * sizeof( uint32_t ) ) >= patternsize;
+      } else {
+        return ( step * 3 * sizeof( int ) ) >= patternsize;
+      }
+    case EVT_REPEAT:
+      return counter_repeat.expired();
+  }
+  return 0;
+}
+
+/* Add C++ code for each action
+ * This generates the 'output' for the state machine
+ */
+
+void Atm_player::action( int id ) {
+  switch ( id ) {
+    case ENT_FINISH:
+      push( connectors, ON_FINISH, 0, 0, 0 );
+      return;
+    case ENT_IDLE:
+#ifndef ATM_PLAYER_DISABLE_TONE    
+      if ( pin >= 0 ) noTone( pin );  // Tone takes up 7 bytes extra SRAM
+#endif
+      counter_repeat.set( repeatCount );
+      return;
+    case ENT_START:
+      step = 0;
+      counter_repeat.decrement();
+      return;
+    case ENT_SOUND:
+      if ( patternwidth == 32 ) {
+        uint32_t v = pattern32[step * 3] * (uint32_t)pitchFactor;
+        push( connectors, ON_NOTE, true, v & 0xFFFF, v >> 16 & 0xFFFF );
+#ifndef ATM_PLAYER_DISABLE_TONE    
+        if ( pin >= 0 ) tone( pin, pattern32[step * 3] * pitchFactor );
+#endif
+        timer.set( pattern32[step * 3 + 1] * speedFactor );
+      } else {
+        push( connectors, ON_NOTE, true, pattern16[step * 3] * pitchFactor, 1 );
+#ifndef ATM_PLAYER_DISABLE_TONE    
+        if ( pin >= 0 ) tone( pin, pattern16[step * 3] * pitchFactor );
+#endif
+        timer.set( pattern16[step * 3 + 1] * speedFactor );        
+      }
+      return;
+    case ENT_QUIET:
+      if ( patternwidth == 32 ) {
+        uint32_t v = pattern32[step * 3] * (uint32_t)pitchFactor;
+        push( connectors, ON_NOTE, false, v & 0xFFFF, v >> 16 & 0xFFFF );
+#ifndef ATM_PLAYER_DISABLE_TONE    
+        if ( pin >= 0 ) noTone( pin );
+#endif        
+        timer.set( pattern32[step * 3 + 2] * speedFactor );
+      } else {
+        push( connectors, ON_NOTE, false, pattern16[step * 3] * pitchFactor, 0 );
+#ifndef ATM_PLAYER_DISABLE_TONE    
+        if ( pin >= 0 ) noTone( pin );
+#endif
+        timer.set( pattern16[step * 3 + 2] * speedFactor );
+      }
+      return;
+    case ENT_NEXT:
+      step++;
+      return;
+    case ENT_REPEAT:
+      return;
+  }
+}
+
+/* How many times to repeat the pattern
+ *
+ */
+
+Atm_player& Atm_player::repeat( uint16_t v /* = -1 */) {
+  counter_repeat.set( repeatCount = v );
+  return *this;
+}
+
+Atm_player& Atm_player::speed( float v ) {
+  speedFactor = 100 / v;
+  return *this;
+}
+
+Atm_player& Atm_player::pitch( float v ) {
+  pitchFactor = v / 100;
+  return *this;
+}
+
+Atm_player& Atm_player::start( void ) {
+  trigger( EVT_START );
+  return *this;
+}
+
+Atm_player& Atm_player::stop( void ) {
+  trigger( EVT_STOP );
+  return *this;
+}
+
+Atm_player& Atm_player::toggle( void ) {
+  trigger( EVT_TOGGLE );
+  return *this;
+}
+
+/* Sets the pattern and pattern length (in bytes)
+ *
+ */
+
+Atm_player& Atm_player::play( int* pat, int patsize ) {
+  patternwidth = 16;
+  pattern16 = pat;
+  patternsize = patsize;
+  counter_repeat.set( repeatCount );
+  step = 0;
+  return *this;
+}
+
+Atm_player& Atm_player::play( uint32_t* pat, int patsize ) {
+  patternwidth = 32;
+  pattern32 = pat;
+  patternsize = patsize;
+  counter_repeat.set( repeatCount );
+  step = 0;
+  return *this;
+}
+
+Atm_player& Atm_player::play( int freq, int period, int pause /* = 0 */ ) {
+  patternwidth = 16;
+  stub[0] = freq;
+  stub[1] = period;
+  stub[2] = pause;
+  pattern16 = stub;
+  patternsize = 3 * sizeof( int );
+  step = 0;
+  return *this;
+}
+
+/* Optionally override the default trigger() method
+ * Control what triggers your machine can and cannot process
+ */
+
+Atm_player& Atm_player::trigger( int event ) {
+  Machine::trigger( event );
+  return *this;
+}
+
+/* Optionally override the default state() method
+ * Control what the machine returns when another process requests its state()
+ */
+
+int Atm_player::state( void ) {
+  return Machine::state();
+}
+
+/* Nothing customizable below this line
+ ************************************************************************************************
+*/
+
+/* onFinish() push connector variants ( slots 1, autostore 0, broadcast 0 )
+ *
+ * Usage in action() handler: push( connectors, ON_FINISH, 0, v, up)
+ */
+
+Atm_player& Atm_player::onFinish( Machine& machine, int event ) {
+  onPush( connectors, ON_FINISH, 0, 1, 1, machine, event );
+  return *this;
+}
+Atm_player& Atm_player::onFinish( atm_cb_push_t callback, int idx ) {
+  onPush( connectors, ON_FINISH, 0, 1, 1, callback, idx );
+  return *this;
+}
+
+/* onNote() push connector variants ( slots 2, autostore 0, broadcast 0 )
+ *
+ * Usage in action() handler: push( connectors, ON_NOTE, sub, v, up)
+ */
+
+Atm_player& Atm_player::onNote( Machine& machine, int event ) {
+  onPush( connectors, ON_NOTE, 0, 2, 1, machine, event );
+  return *this;
+}
+Atm_player& Atm_player::onNote( atm_cb_push_t callback, int idx ) {
+  onPush( connectors, ON_NOTE, 0, 2, 1, callback, idx );
+  return *this;
+}
+Atm_player& Atm_player::onNote( int sub, Machine& machine, int event ) {
+  onPush( connectors, ON_NOTE, sub, 2, 0, machine, event );
+  return *this;
+}
+Atm_player& Atm_player::onNote( int sub, atm_cb_push_t callback, int idx ) {
+  onPush( connectors, ON_NOTE, sub, 2, 0, callback, idx );
+  return *this;
+}
+
+/* State trace method
+ * Sets the symbol table and the default logging method for serial monitoring
+ */
+
+Atm_player& Atm_player::trace( Stream& stream ) {
+  Machine::setTrace( &stream, atm_serial_debug::trace,
+                     "PLAYER\0EVT_START\0EVT_STOP\0EVT_TOGGLE\0EVT_TIMER\0EVT_EOPAT\0EVT_REPEAT\0ELSE\0IDLE\0START\0SOUND\0QUIET\0NEXT\0REPEAT\0FINISH" );
+  return *this;
+}

firmware/lib/Automaton-1.0.2/src/Atm_player.hpp

@@ -0,0 +1,112 @@
+#pragma once
+
+#include <Automaton.h>
+
+#if defined( _VARIANT_ARDUINO_DUE_X ) || defined( ARDUINO_FEATHER52 ) 
+#define ATM_PLAYER_DISABLE_TONE
+#endif
+
+class Atm_player : public Machine {
+ public:
+  enum { IDLE, START, SOUND, QUIET, NEXT, REPEAT, FINISH };                          // STATES
+  enum { EVT_START, EVT_STOP, EVT_TOGGLE, EVT_TIMER, EVT_EOPAT, EVT_REPEAT, ELSE };  // EVENTS
+  Atm_player( void ) : Machine(){};
+  Atm_player& begin( int pin = -1 );
+  Atm_player& trace( Stream& stream );
+  Atm_player& trigger( int event );
+  int state( void );
+  Atm_player& play( int* pat, int size );
+  Atm_player& play( uint32_t* pat, int size );
+  Atm_player& play( int freq, int period, int pause = 0 );
+  Atm_player& repeat( uint16_t v = -1 );
+  Atm_player& speed( float v );
+  Atm_player& pitch( float v );
+  Atm_player& start( void );
+  Atm_player& stop( void );
+  Atm_player& toggle( void );
+  Atm_player& onFinish( Machine& machine, int event = 0 );
+  Atm_player& onFinish( atm_cb_push_t callback, int idx = 0 );
+  Atm_player& onNote( Machine& machine, int event = 0 );
+  Atm_player& onNote( atm_cb_push_t callback, int idx = 0 );
+  Atm_player& onNote( int sub, Machine& machine, int event = 0 );
+  Atm_player& onNote( int sub, atm_cb_push_t callback, int idx = 0 );
+
+ private:
+  int pin;
+  int* pattern16; // Can also be 32 bit on some hardware (teensy 3.x)
+  uint32_t* pattern32;
+  uint16_t patternsize;
+  uint8_t patternwidth;
+  int step;
+  uint16_t repeatCount;
+  float speedFactor, pitchFactor;
+  int stub[3];
+  atm_timer_millis timer;
+  atm_counter counter_repeat;
+  enum { ENT_IDLE, ENT_START, ENT_SOUND, ENT_QUIET, ENT_NEXT, ENT_REPEAT, ENT_FINISH };  // ACTIONS
+  enum { ON_FINISH, ON_NOTE, CONN_MAX = 3 };                                             // CONNECTORS
+  atm_connector connectors[CONN_MAX];
+  int event( int id );
+  void action( int id );
+};
+
+/*
+Automaton::ATML::begin - Automaton Markup Language
+
+<?xml version="1.0" encoding="UTF-8"?>
+<machines>
+  <machine name="Atm_player">
+    <states>
+      <IDLE index="0" sleep="1" on_enter="ENT_IDLE">
+        <EVT_START>START</EVT_START>
+        <EVT_TOGGLE>START</EVT_TOGGLE>
+      </IDLE>
+      <START index="1" on_enter="ENT_START">
+        <ELSE>SOUND</ELSE>
+      </START>
+      <SOUND index="2" on_enter="ENT_SOUND">
+        <EVT_STOP>IDLE</EVT_STOP>
+        <EVT_TOGGLE>IDLE</EVT_TOGGLE>
+        <EVT_TIMER>QUIET</EVT_TIMER>
+      </SOUND>
+      <QUIET index="3" on_enter="ENT_QUIET">
+        <EVT_STOP>IDLE</EVT_STOP>
+        <EVT_TOGGLE>IDLE</EVT_TOGGLE>
+        <EVT_TIMER>NEXT</EVT_TIMER>
+      </QUIET>
+      <NEXT index="4" on_enter="ENT_NEXT">
+        <EVT_STOP>IDLE</EVT_STOP>
+        <EVT_TOGGLE>IDLE</EVT_TOGGLE>
+        <EVT_EOPAT>REPEAT</EVT_EOPAT>
+        <ELSE>SOUND</ELSE>
+      </NEXT>
+      <REPEAT index="5" on_enter="ENT_REPEAT">
+        <EVT_STOP>IDLE</EVT_STOP>
+        <EVT_TOGGLE>IDLE</EVT_TOGGLE>
+        <EVT_REPEAT>FINISH</EVT_REPEAT>
+        <ELSE>START</ELSE>
+      </REPEAT>
+      <FINISH index="6" on_enter="ENT_FINISH">
+        <EVT_REPEAT>IDLE</EVT_REPEAT>
+        <ELSE>START</ELSE>
+      </FINISH>
+    </states>
+    <events>
+      <EVT_START index="0"/>
+      <EVT_STOP index="1"/>
+      <EVT_TOGGLE index="2"/>
+      <EVT_TIMER index="3"/>
+      <EVT_EOPAT index="4"/>
+      <EVT_REPEAT index="5"/>
+    </events>
+    <connectors>
+      <FINISH autostore="0" broadcast="0" dir="PUSH" slots="1"/>
+      <NOTE autostore="0" broadcast="0" dir="PUSH" slots="2"/>
+    </connectors>
+    <methods>
+    </methods>
+  </machine>
+</machines>
+
+Automaton::ATML::end
+*/

firmware/lib/Automaton-1.0.2/src/Atm_step.cpp

@@ -0,0 +1,109 @@
+#include "Atm_step.hpp"
+
+Atm_step& Atm_step::begin( void ) {
+  // clang-format off
+  const static state_t state_table[] PROGMEM = { 
+    /*            ON_ENTER  ON_LOOP  ON_EXIT  EVT_STEP  EVT_BACK  EVT_SWEEP  EVT_LINEAR   ELSE */
+    /* LINEAR  */       -1,      -1,      -1,       S0,       R9,     SWEEP,     LINEAR,    -1,
+    /* S0      */   ENT_S0,      -1,      -1,       S1,       R0,     SWEEP,     LINEAR,    -1, // Linear
+    /* S1      */   ENT_S1,      -1,      -1,       S2,       R1,     SWEEP,     LINEAR,    -1,
+    /* S2      */   ENT_S2,      -1,      -1,       S3,       R2,     SWEEP,     LINEAR,    -1,
+    /* S3      */   ENT_S3,      -1,      -1,       S4,       R3,     SWEEP,     LINEAR,    -1,
+    /* S4      */   ENT_S4,      -1,      -1,       S5,       R4,     SWEEP,     LINEAR,    -1,
+    /* S5      */   ENT_S5,      -1,      -1,       S6,       R5,     SWEEP,     LINEAR,    -1,
+    /* S6      */   ENT_S6,      -1,      -1,       S7,       R6,     SWEEP,     LINEAR,    -1,
+    /* S7      */   ENT_S7,      -1,      -1,       S8,       R7,     SWEEP,     LINEAR,    -1,
+    /* S8      */   ENT_S8,      -1,      -1,       S9,       R8,     SWEEP,     LINEAR,    -1,
+    /* S9      */   ENT_S9,      -1,      -1,       S0,       R9,     SWEEP,     LINEAR,    -1,
+    /* R0      */   ENT_S0,      -1,      -1,       S0,       R9,     SWEEP,     LINEAR,    -1, // Linear R
+    /* R1      */   ENT_S1,      -1,      -1,       S1,       R0,     SWEEP,     LINEAR,    -1,
+    /* R2      */   ENT_S2,      -1,      -1,       S2,       R1,     SWEEP,     LINEAR,    -1,
+    /* R3      */   ENT_S3,      -1,      -1,       S3,       R2,     SWEEP,     LINEAR,    -1,
+    /* R4      */   ENT_S4,      -1,      -1,       S4,       R3,     SWEEP,     LINEAR,    -1,
+    /* R5      */   ENT_S5,      -1,      -1,       S5,       R4,     SWEEP,     LINEAR,    -1,
+    /* R6      */   ENT_S6,      -1,      -1,       S6,       R5,     SWEEP,     LINEAR,    -1,
+    /* R7      */   ENT_S7,      -1,      -1,       S7,       R6,     SWEEP,     LINEAR,    -1,    
+    /* R8      */   ENT_S8,      -1,      -1,       S8,       R7,     SWEEP,     LINEAR,    -1,
+    /* R9      */   ENT_S9,      -1,      -1,       S9,       R8,     SWEEP,     LINEAR,    -1,
+    /* SWEEP   */       -1,      -1,      -1,       X0,       X0,     SWEEP,     LINEAR,    -1,
+    /* X0      */   ENT_S0,      -1,      -1,       X1,       X1,     SWEEP,     LINEAR,    -1, // Sweep
+    /* X1      */   ENT_S1,      -1,      -1,       X2,       X2,     SWEEP,     LINEAR,    -1,
+    /* X2      */   ENT_S2,      -1,      -1,       X3,       X3,     SWEEP,     LINEAR,    -1,
+    /* X3      */   ENT_S3,      -1,      -1,       X4,       X4,     SWEEP,     LINEAR,    -1,
+    /* X4      */   ENT_S4,      -1,      -1,       X5,       X5,     SWEEP,     LINEAR,    -1,
+    /* X5      */   ENT_S5,      -1,      -1,       X6,       X6,     SWEEP,     LINEAR,    -1,
+    /* X6      */   ENT_S6,      -1,      -1,       X7,       X7,     SWEEP,     LINEAR,    -1,
+    /* X7      */   ENT_S7,      -1,      -1,       X8,       X8,     SWEEP,     LINEAR,    -1,
+    /* X8      */   ENT_S8,      -1,      -1,       X9,       X9,     SWEEP,     LINEAR,    -1,
+    /* X9      */   ENT_S9,      -1,      -1,       XA,       XA,     SWEEP,     LINEAR,    -1,
+    /* XA      */   ENT_S8,      -1,      -1,       XB,       XB,     SWEEP,     LINEAR,    -1,
+    /* XB      */   ENT_S7,      -1,      -1,       XC,       XC,     SWEEP,     LINEAR,    -1,
+    /* XC      */   ENT_S6,      -1,      -1,       XD,       XD,     SWEEP,     LINEAR,    -1,
+    /* XD      */   ENT_S5,      -1,      -1,       XE,       XE,     SWEEP,     LINEAR,    -1,
+    /* XE      */   ENT_S4,      -1,      -1,       XF,       XF,     SWEEP,     LINEAR,    -1,
+    /* XF      */   ENT_S3,      -1,      -1,       XG,       XG,     SWEEP,     LINEAR,    -1,
+    /* XG      */   ENT_S2,      -1,      -1,       XH,       XH,     SWEEP,     LINEAR,    -1,
+    /* XH      */   ENT_S1,      -1,      -1,       X0,       X0,     SWEEP,     LINEAR,    -1,
+  };
+  // clang-format on
+  Machine::begin( state_table, ELSE );
+  return *this;
+}
+
+int Atm_step::event( int id ) {
+  int on_enter = read_state( state_table + ( current * state_width ) + ATM_ON_ENTER );
+  switch ( id ) {
+    case EVT_STEP:
+      return ( current < R0 || current > R9 ) && ( on_enter > -1 ) && ( connector[on_enter].mode() == 0 );
+    case EVT_BACK:
+      return ( current >= R0 && current <= R9 ) && ( on_enter > -1 ) && ( connector[on_enter].mode() == 0 );
+  }
+  return 0;
+}
+
+void Atm_step::action( int id ) {
+  if ( id > -1 ) {
+    if ( connector[id].mode() ) {
+      connector[id].push( id );
+      onstep.push( id );
+    }
+  }
+}
+
+Atm_step& Atm_step::onStep( uint8_t id ) {
+  connector[id].mode_flags = atm_connector::MODE_NULL;
+  return *this;
+}
+
+Atm_step& Atm_step::onStep( uint8_t id, atm_cb_push_t callback, int idx /* = 0 */ ) {
+  connector[id].set( callback, idx );
+  return *this;
+}
+
+Atm_step& Atm_step::onStep( uint8_t id, Machine& machine, int event /* = 0 */ ) {
+  connector[id].set( &machine, event );
+  return *this;
+}
+
+Atm_step& Atm_step::onStep( atm_cb_push_t callback, int idx /* = 0 */ ) {
+  onstep.set( callback, idx );
+  return *this;
+}
+
+Atm_step& Atm_step::onStep( Machine& machine, int event /* = 0 */ ) {
+  onstep.set( &machine, event );
+  return *this;
+}
+
+int Atm_step::state( void ) {
+  int on_enter = read_state( state_table + ( current * state_width ) + ATM_ON_ENTER );
+  return on_enter;
+}
+
+Atm_step& Atm_step::trace( Stream& stream ) {
+  setTrace( &stream, atm_serial_debug::trace,
+            "STEP\0EVT_STEP\0EVT_BACK\0EVT_SWEEP\0EVT_LINEAR\0ELSE\0"
+            "LINEAR\0S0\0S1\0S2\0S3\0S4\0S5\0S6\0S7\0S8\0S9\0R0\0R1\0R2\0R3\0R4\0R5\0R6\0R7\0R8\0R9\0"
+            "SWEEP\0X0\0X1\0X2\0X3\0X4\0X5\0X6\0X7\0X8\0X9\0XA\0XB\0XC\0XD\0XE\0XF\0XG\0XH" );
+  return *this;
+}

firmware/lib/Automaton-1.0.2/src/Atm_step.hpp

@@ -0,0 +1,31 @@
+#pragma once
+
+#include <Automaton.h>
+
+#define ATM_STEP_MAX 10
+
+class Atm_step : public Machine {
+ public:
+  // clang-format off
+  enum { LINEAR, S0, S1, S2, S3, S4, S5, S6, S7, S8, S9, R0, R1, R2, R3, R4, R5, R6, R7, R8, R9,
+         SWEEP, X0, X1, X2, X3, X4, X5, X6, X7, X8, X9, XA, XB, XC, XD, XE, XF, XG, XH }; 
+  enum { EVT_STEP, EVT_BACK, EVT_SWEEP, EVT_LINEAR, ELSE };
+  // clang-format on
+
+  Atm_step( void ) : Machine(){};
+  Atm_step& begin( void );
+  int state( void );
+  Atm_step& trace( Stream& stream );
+  Atm_step& onStep( uint8_t idx );  // fix id -> step???
+  Atm_step& onStep( uint8_t id, atm_cb_push_t callback, int idx = 0 );
+  Atm_step& onStep( uint8_t id, Machine& machine, int event = 0 );
+  Atm_step& onStep( atm_cb_push_t callback, int idx = 0 );
+  Atm_step& onStep( Machine& machine, int event = 0 );
+
+ private:
+  enum { ENT_S0, ENT_S1, ENT_S2, ENT_S3, ENT_S4, ENT_S5, ENT_S6, ENT_S7, ENT_S8, ENT_S9 };
+  atm_connector connector[ATM_STEP_MAX];
+  atm_connector onstep;
+  int event( int id );
+  void action( int id );
+};

firmware/lib/Automaton-1.0.2/src/Atm_timer.cpp

@@ -0,0 +1,133 @@
+#include "Atm_timer.hpp"
+
+// Timer class that handles intervals from 1 millisecond up to 136 years
+// Combined with repeat( 65534 ) that makes a maximum of 8.9 million years
+
+#define DIVIDER 86400  // Number of seconds in a 24h day
+
+Atm_timer& Atm_timer::begin( uint32_t ms /* = ATM_TIMER_OFF */, uint16_t repeats /* = 1 */ ) {
+  // clang-format off
+  const static state_t state_table[] PROGMEM = {
+    /*               ON_ENTER    ON_LOOP    ON_EXIT  EVT_DAYCNT  EVT_DAYTIMER  EVT_MSTIMER  EVT_REPCNT  EVT_STOP  EVT_START  EVT_TOGGLE   ELSE */
+    /* IDLE    */          -1, ATM_SLEEP,        -1,         -1,           -1,          -1,         -1,       -1,     START,      START,    -1,
+    /* START   */   ENT_START,        -1,        -1,         -1,           -1,          -1,         -1,       -1,     WAITD,         -1, WAITD,  
+    /* WAITD   */          -1,        -1, EXT_WAITD,     WAITMS,        WAITD,          -1,         -1,     IDLE,     START,       IDLE,    -1,
+    /* WAITMS  */          -1,        -1,        -1,         -1,           -1,     TRIGGER,         -1,     IDLE,     START,       IDLE,    -1,
+    /* TRIGGER */ ENT_TRIGGER,        -1,        -1,         -1,           -1,          -1,     FINISH,     IDLE,     START,       IDLE, START,
+    /* FINISH  */  ENT_FINISH,        -1,        -1,         -1,           -1,          -1,         -1,       -1,     START,         -1,  IDLE,
+  };
+  // clang-format on
+  Machine::begin( state_table, ELSE );
+  daytimer.set( (uint32_t)DIVIDER * 1000 );  // Always set to one day
+  mstimer.set( ms );
+  daycounter.set( days = 0 );
+  repeat( repeat_cnt = repeats );
+  return *this;
+}
+
+int Atm_timer::event( int id ) {
+  switch ( id ) {
+    case EVT_REPCNT:
+      return repcounter.expired();
+    case EVT_DAYCNT:
+      return daycounter.expired();
+    case EVT_MSTIMER:
+      return mstimer.expired( this );
+    case EVT_DAYTIMER:
+      return daytimer.expired( this );
+  }
+  return 0;
+}
+
+void Atm_timer::action( int id ) {
+  switch ( id ) {
+    case ENT_START:
+      daycounter.set( days );
+      return;
+    case EXT_WAITD:
+      daycounter.decrement();
+      return;
+    case ENT_TRIGGER:
+      abscounter++;
+      repcounter.decrement();
+      ontimer.push( repcounter.value, abscounter );
+      return;
+    case ENT_FINISH:
+      onfinish.push( 0 );
+      repcounter.set( repeat_cnt );
+      abscounter = 0;
+      return;
+  }
+}
+
+Atm_timer& Atm_timer::onTimer( atm_cb_push_t callback, int idx /* = 0 */ ) {
+  ontimer.set( callback, idx );
+  return *this;
+}
+
+Atm_timer& Atm_timer::onTimer( Machine& machine, int event /* = 0 */ ) {
+  ontimer.set( &machine, event );
+  return *this;
+}
+
+Atm_timer& Atm_timer::onFinish( atm_cb_push_t callback, int idx /* = 0 */ ) {
+  onfinish.set( callback, idx );
+  return *this;
+}
+
+Atm_timer& Atm_timer::onFinish( Machine& machine, int event /* = 0 */ ) {
+  onfinish.set( &machine, event );
+  return *this;
+}
+
+Atm_timer& Atm_timer::interval_seconds( uint32_t v ) {
+  days = v / ( (uint32_t)DIVIDER );
+  daycounter.set( days );                                      // Determine how many days -> days => Set day counter
+  mstimer.set( ( v - ( (uint32_t)days * DIVIDER ) ) * 1000 );  // And how many milliseconds left
+  return *this;
+}
+
+Atm_timer& Atm_timer::interval_millis( uint32_t v ) {
+  days = 0;
+  daycounter.set( days );
+  mstimer.set( v );
+  return *this;
+}
+
+Atm_timer& Atm_timer::interval( uint32_t v ) {
+  return interval_millis( v );
+}
+
+Atm_timer& Atm_timer::repeat( uint16_t v /* = ATM_COUNTER_OFF */ ) {
+  repeat_cnt = v;
+  repcounter.set( v );
+  return *this;
+}
+
+uint32_t Atm_timer::left() {
+  uint32_t r = daycounter.value * DIVIDER;
+  r += mstimer.value - ( millis() - state_millis );
+  return current == WAITD || current == WAITMS ? r : 0;
+}
+
+Atm_timer& Atm_timer::start( void ) {
+  trigger( EVT_START );
+  return *this;
+}
+
+Atm_timer& Atm_timer::stop( void ) {
+  trigger( EVT_STOP );
+  return *this;
+}
+
+Atm_timer& Atm_timer::toggle( void ) {
+  trigger( EVT_TOGGLE );
+  return *this;
+}
+
+Atm_timer& Atm_timer::trace( Stream& stream ) {
+  setTrace( &stream, atm_serial_debug::trace,
+            "TIMER\0EVT_DAYCNT\0EVT_DAYTIMER\0EVT_MSTIMER\0EVT_REPCNT\0EVT_OFF\0EVT_START\0EVT_TOGGLE\0"
+            "ELSE\0IDLE\0START\0WAITD\0WAITMS\0TRIGGER\0FINISH" );
+  return *this;
+}

firmware/lib/Automaton-1.0.2/src/Atm_timer.hpp

@@ -0,0 +1,40 @@
+#pragma once
+
+#include <Automaton.h>
+
+class Atm_timer : public Machine {
+ public:
+  enum { IDLE, START, WAITD, WAITMS, TRIGGER, FINISH };
+  enum { EVT_DAYCNT, EVT_DAYTIMER, EVT_MSTIMER, EVT_REPCNT, EVT_STOP, EVT_START, EVT_TOGGLE, ELSE }; // EVT_PAUSE, EVT_RESUME
+
+  Atm_timer( void ) : Machine(){};
+  Atm_timer& begin( uint32_t ms = 0, uint16_t repeats = 1 );
+  Atm_timer& trace( Stream& stream );
+  Atm_timer& onTimer( atm_cb_push_t callback, int idx = 0 );
+  Atm_timer& onTimer( Machine& machine, int event = 0 );
+  Atm_timer& onFinish( atm_cb_push_t callback, int idx = 0 );
+  Atm_timer& onFinish( Machine& machine, int event = 0 );
+  Atm_timer& interval_seconds( uint32_t v );
+  Atm_timer& interval_millis( uint32_t v );
+  Atm_timer& interval( uint32_t v );
+  uint32_t left();
+  Atm_timer& repeat( uint16_t v = ATM_COUNTER_OFF );
+  Atm_timer& start( void );
+  Atm_timer& stop( void );
+  Atm_timer& toggle( void );
+//  Atm_timer& pause( void ); TODO
+//  Atm_timer& resume( void );
+  
+
+ private:
+  enum { ENT_START, ENT_TRIGGER, EXT_WAITD, ENT_FINISH };
+  atm_timer_millis daytimer, mstimer;
+  atm_counter daycounter, repcounter;
+  uint32_t abscounter;
+  uint16_t days;
+  uint16_t repeat_cnt;
+  atm_connector ontimer, onfinish;
+
+  int event( int id );
+  void action( int id );
+};

firmware/lib/Automaton-1.0.2/src/Automaton.cpp

@@ -0,0 +1,72 @@
+/*
+  Automaton.cpp - Reactive State Machine Framework for Arduino.
+  Published under the MIT License (MIT), Copyright (c) 2015-2016, J.P. van der Landen
+*/
+
+#include "Automaton.h"
+
+Automaton automaton;  // The global automaton machine container/scheduler
+
+/*
+ * The Automaton class is a simple scheduler for running State Machines
+ *
+ *********************************************************************************************
+ *
+ * Automaton::add( machine ) - Adds a State Machine object to the container
+ *
+ */
+
+Automaton& Automaton::add( Machine& machine, bool force /* = true */ ) {
+  if ( ( machine.flags & ATM_SLINK_FLAG ) == 0 || force ) {
+    machine.inventory_next = inventory_root;
+    inventory_root = &machine;
+    machine.flags |= ATM_SLINK_FLAG;
+  }
+  return *this;
+}
+
+/*
+ * Automaton::run() - Runs the appliance
+ *
+ * executes one cycle of each machine and exits
+ *
+ */
+
+Automaton& Automaton::run( void ) {
+  Machine* m;
+  m = inventory_root;
+  while ( m ) {
+    if ( ( m->flags & ( ATM_SLEEP_FLAG | ATM_CYCLE_FLAG ) ) == 0 ) m->cycle();
+    // Move to the next machine
+    m = m->inventory_next;
+  }
+  return *this;
+}
+
+Automaton& Automaton::delay( uint32_t time ) {
+  uint32_t cycle_start = millis();
+  do {
+    run();
+  } while ( millis() - cycle_start < time );
+  return *this;
+}
+
+Appliance& Appliance::component( Machine& machine ) {
+  Automaton::add( machine );
+  return *this;
+}
+
+Appliance& Appliance::run( uint32_t time /* = 0 */ ) {
+  Automaton::delay( time );
+  return *this;
+}
+
+Factory& Factory::add( Machine& machine ) {
+  Automaton::add( machine );
+  return *this;
+}
+
+Factory& Factory::cycle( uint32_t time /* = 0 */ ) {
+  Automaton::delay( time );
+  return *this;
+}

firmware/lib/Automaton-1.0.2/src/Automaton.h

@@ -0,0 +1,99 @@
+/*
+  Automaton.h - Reactive State Machine Framework for Arduino.
+  Published under the MIT License (MIT), Copyright (c) 2015-2016, J.P. van der Landen
+*/
+
+#pragma once
+
+#include "Arduino.h"
+
+typedef int8_t state_t;
+
+const uint8_t ATM_SLEEP_FLAG = B00000001;
+const uint8_t ATM_CYCLE_FLAG = B00000010;
+const uint8_t ATM_SLINK_FLAG = B00000100;
+const uint8_t ATM_USR1_FLAG = B00010000;
+const uint8_t ATM_USR2_FLAG = B00100000;
+const uint8_t ATM_USR3_FLAG = B01000000;
+const uint8_t ATM_USR4_FLAG = B10000000;
+const uint8_t ATM_USR_FLAGS = B11110000;
+const uint8_t ATM_BROADCAST = B10000000;
+
+#define read_state( addr ) ( state_t ) pgm_read_byte_near( addr )
+
+#define B2INT( hibyte, lobyte ) ((int)( hibyte << 8 | lobyte ))
+#define B4INT( byte4, byte3, byte2, byte1) ((uint32_t)( (uint32_t)byte4 << 24 | (uint32_t)byte3 << 16 | (uint32_t)byte2 << 8 | (uint32_t)byte1 ))
+
+class Machine;
+class Automaton;
+
+extern Automaton automaton;
+
+typedef void ( *swcb_sym_t )( Stream* stream, Machine& machine, const char label[], const char current[], const char next[], const char trigger[],
+                              uint32_t runtime, uint32_t cycles );
+
+const uint8_t ATM_UP = 1;
+const uint8_t ATM_DOWN = 0;
+
+const state_t ATM_NOP = -1;
+const state_t ATM_SLEEP = -2;
+const state_t ATM_ON_SWITCH = -3;
+const state_t ATM_ON_ENTER = 0;
+const state_t ATM_ON_LOOP = 1;
+const state_t ATM_ON_EXIT = 2;
+
+const uint32_t ATM_TIMER_OFF = 0xffffffff;  // This timer value never expires
+const uint16_t ATM_COUNTER_OFF = 0xffff;    // This counter value never expires
+
+class Automaton {
+ public:
+  Automaton& add( Machine& machine, bool force = true );
+  Automaton& delay( uint32_t time );
+  Automaton& run( void );
+
+ private:
+  Machine* inventory_root;
+  void runTiny( void );
+};
+
+// For backward compatibility with 'the old way': Appliance app/app.component()/app.run()
+
+class Appliance : Automaton {
+ public:
+  Appliance& component( Machine& machine );
+  Appliance& run( uint32_t time = 0 );
+};
+
+class Factory : Automaton {
+ public:
+  Factory& add( Machine& machine );
+  Factory& cycle( uint32_t time = 0 );
+};
+
+// Support classes
+
+#include <atm_connector.hpp>
+#include <atm_timer_millis.hpp>
+#include <atm_counter.hpp>
+#include <atm_serial_debug.hpp>
+
+// Main framework classes
+
+#include <Machine.hpp>
+
+// Bundled state machines (components)
+
+#include <Atm_analog.hpp>
+#include <Atm_bit.hpp>
+#include <Atm_button.hpp>
+#include <Atm_command.hpp>
+#include <Atm_comparator.hpp>
+#include <Atm_controller.hpp>
+#include <Atm_digital.hpp>
+#include <Atm_encoder.hpp>
+#include <Atm_fade.hpp>
+#include <Atm_led.hpp>
+#include <Atm_fan.hpp>
+#include <Atm_step.hpp>
+#include <Atm_player.hpp>
+#include <Atm_timer.hpp>

firmware/lib/Automaton-1.0.2/src/Machine.cpp

@@ -0,0 +1,255 @@
+/*
+  Automaton.cpp - Reactive State Machine Framework for Arduino.
+  Published under the MIT License (MIT), Copyright (c) 2015-2016, J.P. van der Landen
+*/
+
+#include "Automaton.h"
+
+/* The Machine class is a base class for creating and running State Machines
+ *
+ *********************************************************************************************
+ *
+ * Machine::state( void ) - Retrieves the current state for the machine
+ *
+ * (may be overridden by a subclass in which case it may return something else, like a value )
+ */
+
+int Machine::state() {
+  return current;
+}
+
+/*
+ * Machine::state( state ) - Sets the next state for the machine
+ *
+ */
+
+Machine& Machine::state( int state ) {
+  next = state;
+  last_trigger = -1;
+  flags &= ~ATM_SLEEP_FLAG;
+  return *this;
+}
+
+/*
+ * Machine::trigger( evt ) - Triggers an event for the machine
+ *
+ * The machine is cycled for maximum of 8 times until it is actively listening for the event
+ * Then the event is triggered followed by two more cycles to process the event and the
+ * following state change.
+ *
+ */
+
+Machine& Machine::trigger( int evt /* = 0 */ ) {
+  int new_state;
+  int max_cycle = 8;
+  do {
+    flags &= ~ATM_SLEEP_FLAG;
+    cycle();
+    new_state = read_state( state_table + ( current * state_width ) + evt + ATM_ON_EXIT + 1 );
+  } while ( --max_cycle && ( new_state == -1 || next_trigger != -1 ) );
+  if ( new_state > -1 ) {
+    next_trigger = evt;
+    flags &= ~ATM_SLEEP_FLAG;
+    cycle();  // Pick up the trigger
+    flags &= ~ATM_SLEEP_FLAG;
+    cycle();  // Process the state change
+  }
+  return *this;
+}
+
+/*
+ * Machine::setTrace( stream, callback, symbols ) - Sets up state tracing for the machine
+ *
+ * Connects a stream object, a callback (atm_serial_debug) and a symbol table (string) to the object
+ *
+ */
+
+Machine& Machine::setTrace( Stream* stream, swcb_sym_t callback, const char symbols[] ) {
+  callback_trace = callback;
+  stream_trace = stream;
+  this->symbols = symbols;
+  return *this;
+}
+
+/*
+ * Machine::sleep( v ) - Sets or returns the current sleep flag setting
+ *
+ */
+
+uint8_t Machine::sleep( int8_t v /* = 1 */ ) {
+  if ( v > -1 ) flags = v ? flags | ATM_SLEEP_FLAG : flags & ~ATM_SLEEP_FLAG;
+  return ( flags & ATM_SLEEP_FLAG ) > 0;
+}
+
+/*
+ * Machine::begin( state_table, width ) - Initializes the state table and sets the sleep flag
+ *
+ */
+
+Machine& Machine::begin( const state_t* tbl, int width ) {
+  state_table = tbl;
+  state_width = ATM_ON_EXIT + width + 2;
+  flags &= ~ATM_SLEEP_FLAG;
+  automaton.add( *this, false );
+  current = -1;
+  next = 0;
+  next_trigger = -1;
+  return *this;
+}
+
+/*
+ * Machine::onPush( connectors, id, sub, slots, multi, dest, arg ) - Registers a connector destination
+ *
+ * connectors Connector table
+ * id         Connector id
+ * sub        Connector sub id (for multi-slot connectors)
+ * slots      Number of slots reserved for this connector
+ * multi      Register multiple (all) slots in one call
+ * dest       Destination: Machine object or callback
+ * arg        Argument for machine (event) or callback (idx)
+ *
+ */
+
+void Machine::onPush( atm_connector connectors[], int id, int sub, int slots, int fill, Machine& machine, int event ) {
+  if ( sub == -1 ) {  // auto store
+    sub = 0;
+    for ( int i = 0; i < slots; i++ ) {
+      if ( connectors[id + i].mode() == 0 ) {  // Find a free slot
+        sub = i;
+      }
+    }
+  }
+  if ( slots > 1 && fill ) {
+    for ( int i = 0; i < slots; i++ ) {
+      connectors[id + i].set( &machine, event );
+    }
+  } else {
+    connectors[id + sub].set( &machine, event );
+  }
+}
+
+void Machine::onPush( atm_connector connectors[], int id, int sub, int slots, int fill, atm_cb_push_t callback, int idx ) {
+  if ( sub == -1 ) {  // auto store
+    sub = 0;
+    for ( int i = 0; i < slots; i++ ) {
+      if ( connectors[id + i].mode() == 0 ) {  // Find a free slot
+        sub = i;
+      }
+    }
+  }
+  if ( slots > 1 && fill ) {
+    for ( int i = 0; i < slots; i++ ) {
+      connectors[id + i].set( callback, idx );
+    }
+  } else {
+    connectors[id + sub].set( callback, idx );
+  }
+}
+
+/*
+ * Machine::push( connectors, id, sub, v, up ) - Pushes an action through the specified connector
+ *
+ * connectors Connector table
+ * id         Connector id
+ * sub        Connector sub id (for multi-slot connectors)
+ * v          Value to pass to a callback as 'v'
+ * up         Value to pass to a callback as 'up'
+ *
+ */
+
+void Machine::push( atm_connector connectors[], int id, int sub, int v, int up ) {
+  if ( ( id & ATM_BROADCAST ) > 0 ) {
+    id = id & ~ATM_BROADCAST;
+    for ( int i = id; i < sub; i++ ) {
+      connectors[id + i].push( v, up );
+    }
+  } else {
+    connectors[id + sub].push( v, up );
+  }
+}
+
+/*
+ * Machine::mapSymbol( id, map ) - Maps a number ( event/state ) to a symbol
+ *
+ * 0        Machine class name (e.g. LED)
+ * 1..ELSE  Event name (e.g. EVT_TIMER)
+ * ELSE..   State name (e.g. IDLE)
+ *
+ */
+
+const char* Machine::mapSymbol( int id, const char map[] ) {
+  int cnt = 0;
+  int i = 0;
+  if ( id == -1 ) return "*NONE*";
+  if ( id == 0 ) return map;
+  while ( 1 ) {
+    if ( map[i] == '\0' && ++cnt == id ) {
+      i++;
+      break;
+    }
+    i++;
+  }
+  return &map[i];
+}
+
+/*
+ * Machine::cycle( time ) - Executes one cycle of a State Machine
+ *
+ * For every state change:
+ * - Calls the ON_SWITCH action
+ * - Calls the state trace function (if connected)
+ * - Calls the previous state's ON_EXIT action
+ * - Changes the active state (current) to the new
+ * - Calls the new state's ON_ENTER action
+ *
+ * For every 'normal' cycle:
+ * - Executes the ON_LOOP action
+ * - Scans the event columns in the current table and calls active events
+ *
+ * If the 'time' argument is given, loops until that time has passed
+ * otherwise executes only one cycle of the machine
+ */
+
+Machine& Machine::cycle( uint32_t time /* = 0 */ ) {
+  uint32_t cycle_start = millis();
+  do {
+    if ( ( flags & ( ATM_SLEEP_FLAG | ATM_CYCLE_FLAG ) ) == 0 ) {
+      cycles++;
+      flags |= ATM_CYCLE_FLAG;
+      if ( next != -1 ) {
+        action( ATM_ON_SWITCH );
+        if ( callback_trace ) {
+          callback_trace( stream_trace, *this, symbols, mapSymbol( current == -1 ? current : current + state_width - ATM_ON_EXIT, symbols ),
+                          mapSymbol( next == -1 ? next : next + state_width - ATM_ON_EXIT, symbols ),
+                          mapSymbol( last_trigger == -1 ? -1 : last_trigger + 1, symbols ), millis() - state_millis, cycles );
+        }
+        if ( current > -1 ) action( read_state( state_table + ( current * state_width ) + ATM_ON_EXIT ) );
+        current = next;
+        next = -1;
+        state_millis = millis();
+        action( read_state( state_table + ( current * state_width ) + ATM_ON_ENTER ) );
+        if ( read_state( state_table + ( current * state_width ) + ATM_ON_LOOP ) == ATM_SLEEP ) {
+          flags |= ATM_SLEEP_FLAG;
+        } else {
+          flags &= ~ATM_SLEEP_FLAG;
+        }
+        cycles = 0;
+      }
+      state_t i = read_state( state_table + ( current * state_width ) + ATM_ON_LOOP );
+      if ( i != -1 ) {
+        action( i );
+      }
+      for ( i = ATM_ON_EXIT + 1; i < state_width; i++ ) {
+        state_t next_state = read_state( state_table + ( current * state_width ) + i );
+        if ( ( next_state != -1 ) && ( i == state_width - 1 || event( i - ATM_ON_EXIT - 1 ) || next_trigger == i - ATM_ON_EXIT - 1 ) ) {
+          state( next_state );
+          last_trigger = i - ATM_ON_EXIT - 1;
+          next_trigger = -1;
+          break;
+        }
+      }
+      flags &= ~ATM_CYCLE_FLAG;
+    }
+  } while ( millis() - cycle_start < time );
+  return *this;
+}

firmware/lib/Automaton-1.0.2/src/Machine.hpp

@@ -0,0 +1,39 @@
+/*
+  Automaton.h - Reactive State Machine Framework for Arduino.
+  Published under the MIT License (MIT), Copyright (c) 2015-2016, J.P. van der Landen
+*/
+
+#pragma once
+
+class Machine {
+ public:
+  virtual int state( void );
+  virtual Machine& trigger( int evt = 0 );
+  Machine& cycle( uint32_t time = 0 );
+  uint32_t state_millis;
+  uint8_t flags = ATM_SLEEP_FLAG;
+  state_t next_trigger = -1;
+  uint8_t sleep( int8_t v = -1 );
+  virtual int event( int id ) = 0;  // Pure virtual methods -> make this an abstract class
+  virtual void action( int id ) = 0;
+  Machine* inventory_next;
+
+ protected:
+  Machine& state( int state );
+  Machine& begin( const state_t tbl[], int width );
+  const char* mapSymbol( int id, const char map[] );
+  Machine& setTrace( Stream* stream, swcb_sym_t callback, const char symbols[] );
+  void onPush( atm_connector connectors[], int id, int sub, int slots, int fill, Machine& machine, int event );
+  void onPush( atm_connector connectors[], int id, int sub, int slots, int fill, atm_cb_push_t callback, int idx );
+  void push( atm_connector connectors[], int id, int sub, int v, int up );
+
+  const state_t* state_table;
+  state_t next;
+  state_t current = -1;
+  state_t last_trigger = -1;
+  const char* symbols;
+  uint8_t state_width;
+  swcb_sym_t callback_trace;
+  Stream* stream_trace;
+  uint32_t cycles;
+};

firmware/lib/Automaton-1.0.2/src/atm_connector.cpp

@@ -0,0 +1,112 @@
+/*
+  Automaton.cpp - Reactive State Machine Framework for Arduino.
+  Published under the MIT License (MIT), Copyright (c) 2015-2016, J.P. van der Landen
+*/
+
+#include "Automaton.h"
+
+/*
+ * The atm_connector class facilitates creating push and pull connections between
+ * State Machines.
+ *
+ *********************************************************************************************
+ *
+ * push( v, up, overrideCallback ) - Calls a machine's trigger method or a callback
+ *
+ * Will return false if a callback is configured while the overrideCallback arg was specified
+ */
+
+bool atm_connector::push( int v /* = 0 */, int up /* = 0 */, bool overrideCallback /* = false */ ) {
+  switch ( mode_flags & B00000111 ) {
+    case MODE_PUSHCB:
+      if ( overrideCallback ) {
+        return false;
+      } else {
+        if ( push_callback ) {
+          ( *push_callback )( callback_idx, v, up );
+        }
+      }
+      return true;
+    case MODE_MACHINE:
+      if ( machine != 0 ) {
+        machine->trigger( event );
+      }
+      return true;
+  }
+  return true;
+}
+
+/*
+ * pull( v, up, def_value ) - Calls a machine's state method or a callback
+ *
+ */
+
+int atm_connector::pull( int v /* = 0 */, int up /* = 0 */, bool def_value /* = false */ ) {
+  switch ( mode_flags & B00000111 ) {
+    case MODE_PULLCB:
+      return ( *pull_callback )( callback_idx );
+    case MODE_MACHINE:
+      return machine->state();
+  }
+  return def_value;
+}
+
+/*
+ * logOp() Returns the logical operator part of the mode_flags byte
+ *
+ */
+
+int8_t atm_connector::logOp( void ) {
+  return ( mode_flags & B00011000 ) >> 3;
+}
+
+/*
+ * logOp() Returns the relational operator part of the mode_flags byte
+ *
+ */
+
+int8_t atm_connector::relOp( void ) {
+  return ( mode_flags & B11100000 ) >> 5;
+}
+
+/*
+ * set( callback, idx, logOp, relOp ) - Configures a connector object as a push callback
+ *
+ */
+
+void atm_connector::set( atm_cb_push_t callback, int idx, int8_t logOp /* = 0 */, int8_t relOp /* = 0 */ ) {
+  mode_flags = MODE_PUSHCB | ( logOp << 3 ) | ( relOp << 5 );
+  push_callback = callback;
+  callback_idx = idx;
+}
+
+/*
+ * set( callback, idx, logOp, relOp ) - Configures a connector object as a pull callback
+ *
+ */
+
+void atm_connector::set( atm_cb_pull_t callback, int idx, int8_t logOp /* = 0 */, int8_t relOp /* = 0 */ ) {
+  mode_flags = MODE_PULLCB | ( logOp << 3 ) | ( relOp << 5 );
+  pull_callback = callback;
+  callback_idx = idx;
+}
+
+/*
+ * set( callback, idx, logOp, relOp ) - Configures a connector object as a machine connector (calls trigger)
+ *
+ */
+
+void atm_connector::set( Machine* m, int evt, int8_t logOp /* = 0 */, int8_t relOp /* = 0 */ ) {
+  mode_flags = MODE_MACHINE | ( logOp << 3 ) | ( relOp << 5 );
+  machine = m;
+  event = evt;
+}
+
+/*
+ * mode() - Returns the mode part of the mode_flags byte
+ *
+ */
+
+int8_t atm_connector::mode( void ) {
+  return mode_flags & B00000111;
+}

firmware/lib/Automaton-1.0.2/src/atm_connector.hpp

@@ -0,0 +1,37 @@
+#pragma once
+
+#include "Arduino.h"
+
+typedef void ( *atm_cb_push_t )( int idx, int v, int up );
+typedef bool ( *atm_cb_pull_t )( int idx );
+
+class atm_connector {
+ public:
+  enum { MODE_NULL, MODE_PUSHCB, MODE_PULLCB, MODE_MACHINE };            // bits 0, 1, 2 - Mode
+  enum { LOG_AND, LOG_OR, LOG_XOR };                                     // bits 3, 4    - Logical operator
+  enum { REL_NULL, REL_EQ, REL_NEQ, REL_LT, REL_GT, REL_LTE, REL_GTE };  // bits 5, 6, 7 - Relational operator
+  uint8_t mode_flags;
+  union {
+    struct {
+      union {
+        atm_cb_push_t push_callback;
+        atm_cb_pull_t pull_callback;
+      };
+      int callback_idx;  // +2 = 5 bytes per connector/object
+    };
+    struct {
+      union {
+        Machine* machine;
+      };
+      int event;
+    };
+  };
+  void set( Machine* m, int evt, int8_t logOp = 0, int8_t relOp = 0 );
+  void set( atm_cb_push_t callback, int idx, int8_t logOp = 0, int8_t relOp = 0 );
+  void set( atm_cb_pull_t callback, int idx, int8_t logOp = 0, int8_t relOp = 0 );
+  bool push( int v = 0, int up = 0, bool overrideCallback = false );  // returns false (only) if callback is set!
+  int pull( int v = 0, int up = 0, bool def_value = false );
+  int8_t logOp( void );
+  int8_t relOp( void );
+  int8_t mode( void );
+};

firmware/lib/Automaton-1.0.2/src/atm_counter.cpp

@@ -0,0 +1,33 @@
+/*
+  Automaton - Reactive State Machine Framework for Arduino.
+  Published under the MIT License (MIT), Copyright (c) 2015-2016, J.P. van der Landen
+*/
+
+#include "Automaton.h"
+
+/*
+ * atm_counter::set( v ) - Sets a countdown counter to 'v'
+ *
+ */
+
+void atm_counter::set( uint16_t v ) {
+  value = v;
+}
+
+/*
+ * atm_counter::decrement() - Decrements a countdown counter
+ *
+ */
+
+uint16_t atm_counter::decrement( void ) {
+  return value > 0 && value != ATM_COUNTER_OFF ? --value : 0;
+}
+
+/*
+ * atm_counter::expired() - Checks a countdown counter for expiry (== 0)
+ *
+ */
+
+uint8_t atm_counter::expired() {
+  return value == ATM_COUNTER_OFF ? 0 : ( value > 0 ? 0 : 1 );
+}

firmware/lib/Automaton-1.0.2/src/atm_counter.hpp

@@ -0,0 +1,16 @@
+/*
+ *   Automaton.h - Reactive State Machine Framework for Arduino.
+ *     Published under the MIT License (MIT), Copyright (c) 2015-2016, J.P. van der Landen
+ *     */
+
+#pragma once
+
+#include "Arduino.h"
+
+class atm_counter {
+ public:
+  uint16_t value;
+  void set( uint16_t v );
+  uint8_t expired( void );
+  uint16_t decrement( void );
+};

firmware/lib/Automaton-1.0.2/src/atm_serial_debug.hpp

@@ -0,0 +1,31 @@
+/*
+ * Automaton.h - Reactive State Machine Framework for Arduino.
+ * Published under the MIT License (MIT), Copyright (c) 2015-2016, J.P. van der Landen
+ */
+
+#pragma once
+
+#include "Arduino.h"
+
+class atm_serial_debug {  // It seems necessary to put this code in .h to keep it from being compiled in unnecessarily
+ public:
+  static void trace( Stream* stream, Machine& machine, const char label[], const char current[], const char next[], const char trigger[], uint32_t runtime,
+                     uint32_t cycles ) {
+    stream->print( millis() );
+    stream->print( " Switch " );
+    stream->print( label );
+    stream->print( "@" );
+    stream->print( (long)&machine, HEX );
+    stream->print( " from " );
+    stream->print( current );
+    stream->print( " to " );
+    stream->print( next );
+    stream->print( " on " );
+    stream->print( trigger );
+    stream->print( " (" );
+    stream->print( cycles );
+    stream->print( " cycles in " );
+    stream->print( runtime );
+    stream->println( " ms)" );
+  }
+};

firmware/lib/Automaton-1.0.2/src/atm_timer_millis.cpp

@@ -0,0 +1,21 @@
+
+#include "Automaton.h"
+
+/*
+ * atm_timer_millis::set( v ) - Sets a millis timer to 'v'
+ *
+ */
+
+void atm_timer_millis::set( uint32_t v ) {
+  value = v;
+}
+
+/*
+ * atm_timer_millis::expired( this ) - Checks a millis timer for expiry (== 0)
+ * This is a rollover-safe 32 bit unsigned integer comparison
+ *
+ */
+
+int atm_timer_millis::expired( Machine* machine ) {
+  return value == ATM_TIMER_OFF ? 0 : millis() - machine->state_millis >= value;
+}

firmware/lib/Automaton-1.0.2/src/atm_timer_millis.hpp

@@ -0,0 +1,15 @@
+/*
+ *   Automaton - Reactive State Machine Framework for Arduino.
+ *   Published under the MIT License (MIT), Copyright (c) 2015-2016, J.P. van der Landen
+ */
+
+#pragma once
+
+#include "Arduino.h"
+
+class atm_timer_millis {
+ public:
+  uint32_t value;
+  void set( uint32_t v );
+  int expired( Machine* machine );
+};

firmware/lib/TeensyStep/LICENCE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2017 Lutz Niggl
+
+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.

firmware/lib/TeensyStep/README.md

@@ -0,0 +1,28 @@
+# TeensyStep V2 - Fast Stepper Library for PJRC Teensy boards
+
+Please note: This is version 2 of the library. This version has a new user interface. The version 1 is still available in the branch [Version-1](https://github.com/luni64/TeensyStep/tree/Version-1).
+
+
+## Detailed Documentation can be found here [https://luni64.github.io/TeensyStep/](https://luni64.github.io/TeensyStep/)
+
+
+## Purpose of the Library
+**TeensyStep** is an efficient Arduino library compatible with Teensy 3.0, 3.1, 3.2, 3.5 and 3.6. The library is able to handle synchronous and independent movement and continuous rotation of steppers with pulse rates of up to 300'000 steps per second. The following table shows a summary of the **TeensyStep** specification:
+
+| Description                                | Specification             | Default          |
+|:-------------------------------------------|:-------------------------:|:----------------:|
+| Motor speed / pulse rate                   |1 - 300'000 stp/s          |   800 stp/s      |
+| Acceleration                               | 0 - 500'000 stp/s^2       |   2500 stp/s^2   |
+| Pull in speed                              | 50-10'000 stp/s           | 100 stp/s |
+| Synchronous movement of motors             | up to 10                  | -                |
+| Independent movement of motors             | 4 groups of 1 to 10 motors| -                |
+| Settable step pulse polarity               | Active HIGH or LOW        | Active HIGH      |
+| Settable step pulse width                  | 1-100µs                   | 5µs              |
+| Settable direction signal polarity         | cw / ccw                  | cw               |
+
+Here a quick demonstration video showing two motors running in sync with 160'000 steps/sec
+
+<a href="http://www.youtube.com/watch?feature=player_embedded&v=Fzt75I_Zi14
+" target="_blank"><img src="http://img.youtube.com/vi/Fzt75I_Zi14/0.jpg" 
+alt="IMAGE ALT TEXT HERE" width="600" height="450" border="10" /></a>
+

firmware/lib/TeensyStep/examples/Applications/Winder/Winder.cpp

@@ -0,0 +1,77 @@
+#include "Winder.h"
+
+Winder::Winder(Stepper &_spindle, Stepper &_feeder)
+    : spindle(_spindle), feeder(_feeder), feederCtrl(5, 1000), spindleCtrl(5, 1000)
+{    
+}
+
+Winder& Winder::setSpindleParams(unsigned stepsPerRev, unsigned acc)
+{
+    spindleStpPerRev = stepsPerRev;
+    spindleAcc =  acc;
+
+    spindle.setMaxSpeed(1);   // -> parameter of overrideSpeed equals real speed
+    spindle.setAcceleration(spindleAcc);
+
+    oldSpindleSpeed = 0.0f;
+    oldPitch = 1.0f;
+   
+    return *this;
+}
+
+Winder& Winder::setFeederParams(unsigned stpPerMM, unsigned acc)
+{
+    feederStpPerMM = stpPerMM;
+    feederAcc = acc;
+
+    feeder.setMaxSpeed(1); 
+    feeder.setAcceleration(spindleAcc);
+
+    return *this;
+}
+
+void Winder::begin() 
+{
+    pitchFactor = (float)feederStpPerMM / spindleStpPerRev;
+    
+    // startup controllers   
+    feederCtrl.rotateAsync(feeder);
+    feederCtrl.overrideSpeed(0.0f);
+    
+    spindleCtrl.rotateAsync(spindle);
+    spindleCtrl.overrideSpeed(0.0f);   
+}
+
+void Winder::setSpindleSpeed(float rpm)
+{
+    targetSpindleSpeed = rpm / 60.0f * spindleStpPerRev;
+}
+
+void Winder::setPitch(float pitch)
+{
+    if(pitch > 0) targetPitch = pitch;
+}
+
+void Winder::updateSpeeds()
+{   
+    float targetFeederSpeed =  targetPitch * pitchFactor * targetSpindleSpeed;
+
+    if(targetSpindleSpeed != oldSpindleSpeed)  // if target speed changed -> update all
+    {
+        oldSpindleSpeed = targetSpindleSpeed;
+
+        float feederAccFactor = targetPitch * pitchFactor;
+
+        //Serial.println(feederAccFactor);
+
+        feederCtrl.overrideAcceleration(feederAccFactor);
+        feederCtrl.overrideSpeed(targetFeederSpeed);
+        spindleCtrl.overrideSpeed(targetSpindleSpeed);
+    }
+    else if(targetPitch != oldPitch)           // if only target pitch changed, update feeder speed only
+    {        
+        oldPitch = targetPitch;
+        feederCtrl.overrideAcceleration(feederAcc / spindleAcc);
+        feederCtrl.overrideSpeed(targetFeederSpeed);
+    }
+}

firmware/lib/TeensyStep/examples/Applications/Winder/Winder.h

@@ -0,0 +1,34 @@
+#pragma once
+
+#include "TeensyStep.h"
+ 
+class Winder
+{
+public:
+    Winder(Stepper &spindle, Stepper &feeder);
+
+    void begin();
+
+    Winder &setSpindleParams(unsigned stpPerRev, unsigned acceleration);  // steps per spindle revolution & acceleration in stp/s^2
+    Winder &setFeederParams(unsigned stpPerMM, unsigned acceleration);    // steps to move the feeder 1mm, acceleration for pitch trimming 
+
+    void setSpindleSpeed(float rpm);  // changes the spindle speed to the given rpm
+    void setPitch(float pitch_in_mm); // changes the winder pitch to the given value
+    void updateSpeeds();
+
+    inline int getCurSpindleSpeed() { return spindleCtrl.isRunning() ? spindleCtrl.getCurrentSpeed() : 0; }
+    inline int getCurFeederSpeed() { return feederCtrl.isRunning() ? feederCtrl.getCurrentSpeed() : 0; }
+    inline float getCurPitch(){return (float)getCurFeederSpeed()/getCurSpindleSpeed()/pitchFactor; }
+
+protected:
+    Stepper &spindle;
+    Stepper &feeder;
+
+    unsigned spindleStpPerRev, spindleAcc, feederStpPerMM, feederAcc;
+    float pitchFactor;
+
+    float targetSpindleSpeed, targetPitch;
+    float oldSpindleSpeed, oldPitch;
+
+    RotateControl feederCtrl, spindleCtrl;
+};

firmware/lib/TeensyStep/examples/Applications/Winder/Winder.ino

@@ -0,0 +1,77 @@
+#include "Encoder.h"
+#include "TeensyStep.h"
+#include "Winder.h"
+
+constexpr unsigned feederStpPerMM = 200 * 8 * 5.0f * 0.8f; // e.g. fullstep/rev * microstepping * leadscrew pitch * gearRatio
+constexpr unsigned spindleStpPerRev = 200 * 16;            // e.g. fullstep/rev * microstepping
+constexpr unsigned spindleAcceleration = 15000;
+
+Stepper spindle(0, 1);
+Stepper feeder(2, 3);
+Winder winder(spindle, feeder); 
+
+float pitch = 0.2; //mm
+
+Encoder trimmer(5, 6);
+int oldTrimmerVal = 0;
+
+IntervalTimer printTimer;                                  // used to print out current speeds in the background
+
+void setup()
+{
+  while (!Serial && millis() < 500);
+
+  // setup background printing
+  printTimer.begin(printCurrent, 25000);
+  printTimer.priority(255); // lowest priority, we don't want to disturb stepping
+
+  // setup the winder
+  winder
+      .setSpindleParams(spindleStpPerRev, spindleAcceleration)
+      .setFeederParams(feederStpPerMM, 50000)
+      .begin();
+
+  // startup the winder
+  winder.setSpindleSpeed(600); // spindle speed in rpm
+  winder.setPitch(0.2f);       // pitch in mm
+  winder.updateSpeeds();       // apply new settings
+  delay(3000);
+}
+
+void loop()
+{
+  // read in the trimmer and adjust the pitch (+/- 0.01 per encoder detent)
+  int trimmerVal = trimmer.read(); 
+  if (trimmerVal != oldTrimmerVal)
+  {
+    oldTrimmerVal = trimmerVal;
+    pitch = 0.2f + trimmerVal / 400.0f;  // e.g. 0.01 per 4 encoder steps
+    winder.setPitch(pitch);
+    winder.updateSpeeds();
+  }
+
+  if (millis() > 15000)                 // stop the spindle after 15s
+  {
+    winder.setSpindleSpeed(0);
+    winder.updateSpeeds();
+    while (1)
+      yield();                          // stop sketch here
+  }
+
+  delay(50);                            // dont overrun the winder by sending new values to often. 
+}
+
+// helpers ----------------------------------------------
+
+void printCurrent()
+{
+  unsigned t = millis();
+  unsigned feederSpeed = winder.getCurFeederSpeed();
+  unsigned spindleSpeed = winder.getCurSpindleSpeed();
+  float curPitch = winder.getCurPitch();
+
+  if (spindleSpeed != 0 || feederSpeed != 0)
+  {
+      Serial.printf("%d\t%i\t%i\t%.3f\t%.3f\n", t, spindleSpeed, feederSpeed, curPitch, pitch);     
+  }
+}

firmware/lib/TeensyStep/examples/Applications/Winder/readme.md

@@ -0,0 +1 @@
+To be done

firmware/lib/TeensyStep/examples/HelloStepper/HelloStepper.ino

@@ -0,0 +1,33 @@
+/*==========================================================================
+ * This is a minimal sketch showing the usage of TeensyStep
+ *  
+ * STEP Pulses on Pin 2    (can be any pin)
+ * DIR  Signall on Pin 3   (can be any pin)
+ * 
+ * The target position is set to 1000 steps relative to the
+ * current position. The move command of the controller 
+ * moves the motor to the target position.  
+ *  
+ * Default parameters are 
+ * Speed:          800 steps/s
+ * Acceleration:  2500 steps/s^2
+ * 
+ * (slow, but good to start with since they will work on any normal stepper)
+ *
+ ===========================================================================*/
+
+#include "TeensyStep.h"
+
+Stepper motor(2, 3);       // STEP pin: 2, DIR pin: 3
+StepControl controller;    // Use default settings 
+
+void setup()
+{
+}
+
+void loop() 
+{
+  motor.setTargetRel(1000);  // Set target position to 1000 steps from current position
+  controller.move(motor);    // Do the move
+  delay(500);
+}

firmware/lib/TeensyStep/examples/Interfacing/Interfacing.ino

@@ -0,0 +1,147 @@
+/*----------------------------------------------------------
+This example demonstrates how to use the serial interface and
+digital IO while the controller moves a motor in
+the background.
+
+The following serial commands are implemented
+   m: move motor
+   s: start stop sequence
+   e: emergency stop
+   h: help
+
+Additionally a pin can be used to stop the motor
+
+------------------------------------------------------------*/
+#include "TeensyStep.h"
+
+// stepper and  controller
+constexpr int stpPin = 0, dirPin = 1;
+Stepper motor(stpPin, dirPin);
+StepControl controller;
+
+// pin to stop the motor, connect a push button to this pin
+constexpr int stopPin = 2;
+
+// stopwatches 
+elapsedMillis displayStopwatch = 0;  // timing the display of the current position
+elapsedMillis blinkStopwatch = 0;    // timing the heartbeat LED
+elapsedMillis debounceTimer = 0;     // debouncing input pins
+
+int lastPos = 0;
+
+void handlePins();
+void handleCommands();
+
+void setup()
+{
+    while (!Serial);
+    Serial.println("Simple Serial Stepper Example");    
+    Serial.println("(type h for help)");
+    
+
+    motor.setMaxSpeed(5000);
+    motor.setAcceleration(50000);
+
+    pinMode(LED_BUILTIN, OUTPUT);
+    pinMode(stopPin, INPUT_PULLUP);  // touch the pin with GND to stop the motor
+}
+
+
+void loop()
+{
+    // handle incomming commands on the serial interface ------------------
+    handleCommands();
+
+    // handle input from pins ---------------------------------------------
+    handlePins();
+
+    // display the current motor position every 20ms ----------------------
+    if (displayStopwatch > 20)
+    {
+        displayStopwatch = 0;
+
+        int currentPos = motor.getPosition();
+        if (currentPos != lastPos)  // only display if it changed
+        {
+            lastPos = currentPos;
+            Serial.println(currentPos);
+        }
+    }
+
+    // the usual heartbeat ------------------------------------------------
+    if (blinkStopwatch > 250)
+    {
+        blinkStopwatch = 0;
+        digitalWriteFast(LED_BUILTIN, !digitalReadFast(LED_BUILTIN)); // toggle LED
+    }
+}
+
+
+//------------------------------------------------
+// Very simple command interface on USB-Serial:
+// m : starts the motor
+// s : starts stop sequence
+// e : emergency stop
+
+void handleCommands()
+{
+    if (Serial.available() > 0)                 // skip if the serial buffer is empty
+    {
+        char cmd = Serial.read();               // get one char from the buffer...
+        switch (cmd)                            // ... and analyze it
+        {
+        case 'm':                               // move command
+            if (!controller.isRunning())        // skip move command if motor is running already
+            {
+                motor.setTargetRel(20000);
+                controller.moveAsync(motor);
+                Serial.println("Started motor movement");
+            }
+            else
+            {
+                Serial.println("Ignored, motor is already running");
+            }
+            break;
+
+        case 's':                               // stop command
+            controller.stopAsync();             // initiate stopping procedure
+            Serial.println("Stopping motor");
+            break;
+
+        case 'e':                               // emergency stop command
+            controller.emergencyStop();
+            Serial.println("Emergency Stop");
+            break;
+
+        case 'h':                               // help / usage command
+        case 'u':
+            Serial.println("\nUsage:");
+            Serial.println("  m: move motor");
+            Serial.println("  s: start stop sequence");
+            Serial.println("  e: emergency stop");
+            Serial.println("  h: display this help");            
+            break;
+
+        default:
+            break;
+        }
+    }
+}
+
+
+//------------------------------------------------
+// Connect a pushbutton to the stop pin. 
+// Stop command will be issued when pin is 
+// pulled to GND.
+// Only very simple debouncing implemented. Use "debounce2.h" or 
+// similar for a real application
+
+void handlePins()
+{    
+    if (controller.isRunning() && !digitalReadFast(stopPin) && debounceTimer > 200)
+    {
+        debounceTimer = 0;                   
+        controller.stopAsync();              // initiate stopping procedure
+        Serial.println("Stopping motor");
+    }
+}

firmware/lib/TeensyStep/examples/MultipleSteppers/MultipleSteppers.ino

@@ -0,0 +1,75 @@
+/*==========================================================================
+ * The sketch shows how to move more than one motor. 
+ * 
+ * If more than one motor is moved by one controller all motors will arrive at 
+ * their targets at the same time. E.g., if the motors are part of a 
+ * x/y transport system, the transport move on a straight diagonal line to the
+ * target coordinates.
+ * 
+ * The sketch also shows examples how the motor properties are set up
+ *
+ * A 1/16 microstep driver is assumed. You probably want to adjust speed, 
+ * acceleration and distances if you are using a driver with another microstep 
+ * resolution.
+ ===========================================================================*/
+
+#include "TeensyStep.h"
+
+Stepper motor_1(2, 3);   //STEP pin =  2, DIR pin = 3
+Stepper motor_2(9,10);   //STEP pin =  9, DIR pin = 10
+Stepper motor_3(14,15);  //STEP pin = 14, DIR pin = 15
+
+StepControl controller;
+
+void setup()
+{
+  // setup the motors 
+   motor_1
+    .setMaxSpeed(50000)       // steps/s
+    .setAcceleration(200000); // steps/s^2 
+  
+  motor_2
+    .setMaxSpeed(50000)       // steps/s
+    .setAcceleration(200000); // steps/s^2 
+  motor_3
+    //.setPullInSpeed(300)      // steps/s     currently deactivated...
+    .setMaxSpeed(10000)       // steps/s
+    .setAcceleration(50000)   // steps/s^2     
+    .setStepPinPolarity(LOW); // driver expects active low pulses
+}
+
+void loop() 
+{  
+  constexpr int spr = 16*200;  // 3200 steps per revolution
+  
+  // lets shake    
+  for(int i = 0; i < 5; i++)
+  {
+    motor_1.setTargetRel(spr/4); // 1/4 revolution
+    controller.move(motor_1);  
+
+    motor_1.setTargetRel(-spr/4);
+    controller.move(motor_1);  
+  }
+  delay(500);
+  
+  // move motor_1 to absolute position (10 revolutions from zero)
+  // move motor_2 half a revolution forward  
+  // both motors will arrive their target positions at the same time
+  motor_1.setTargetAbs(10*spr);
+  motor_2.setTargetRel(spr/2);
+  controller.move(motor_1, motor_2);
+
+  // now move motor_2 together with motor_3
+  motor_2.setTargetRel(300);
+  motor_3.setTargetRel(-800);
+  controller.move(motor_2, motor_3);
+
+  // move all motors back to their start positions
+  motor_1.setTargetAbs(0);
+  motor_2.setTargetAbs(0);
+  motor_3.setTargetAbs(0);
+  controller.move(motor_1, motor_2, motor_3);
+ 
+  delay(1000);
+}

firmware/lib/TeensyStep/examples/Path_Following/RoseFunctionFollower/RoseFunctionFollower.ino

@@ -0,0 +1,97 @@
+#include "Arduino.h"
+#include "TeensyStep.h"
+
+//spindle settings
+constexpr unsigned rpm = 15;
+constexpr unsigned spindleSPR = 6400;                    // stp per rev
+constexpr unsigned spindleSpeed = rpm * spindleSPR / 60; // stp/sec
+constexpr unsigned spindleStepPin = 1;
+constexpr unsigned spindleDirPin = 2;
+
+//slide settings
+constexpr unsigned slideAmplitude = 10000; // stp
+constexpr unsigned slideSpeed = 35000;     //stp/sec
+constexpr unsigned slideStepPin = 3;
+constexpr unsigned slideDirPin = 4;
+
+//accuracy
+IntervalTimer tickTimer;
+constexpr unsigned recalcPeriod = 25'000; //µs  period for calculation of new target points. Straight lines between those points.
+constexpr float dt = recalcPeriod / 1E6;  // seconds
+
+// rose fuction
+constexpr int n = 5;
+constexpr int d = 8;
+constexpr float k = (float)n / d;
+
+float slideFunc(float spindleAngle)
+{
+  float phi = fmodf(spindleAngle * k, TWO_PI);
+  return slideAmplitude * cosf(phi);
+}
+
+// TeensyStep
+RotateControl slideController;
+RotateControl spindleController;
+
+Stepper spindle(spindleStepPin, spindleDirPin);
+Stepper slide(slideStepPin, slideDirPin);
+
+
+//------------------------------------------------------------------------------------
+// tick()
+//
+// This function is called periodically with period recalcPeriod. 
+// It calculates 
+//  1) a new target value for the slide depending on the spindle angle
+//  2) the new speed for the spindle so that it will reach the target until it is called again
+
+void tick()
+{
+  float spindleAngle = spindle.getPosition() * (TWO_PI / spindleSPR); //convert steps to angle
+  float slidePosition = slide.getPosition();
+  float slideTarget = slideFunc(spindleAngle);
+
+  float newSpeed = (slideTarget - slidePosition) / dt; // speed to reach target in given delta t (neglecting acceleration)
+  float speedFac = newSpeed / slideSpeed;              // transform in relative factor (-1.0 .. 1.0)
+
+  slideController.overrideSpeed(speedFac);             // set new speed
+}
+
+void setup()
+{
+  pinMode(LED_BUILTIN, OUTPUT);
+ 
+  while (!Serial && millis() < 1000);
+
+  spindle
+      .setMaxSpeed(spindleSpeed)
+      .setAcceleration(50000);
+
+  slide
+      .setMaxSpeed(slideSpeed)
+      .setAcceleration(150000)
+      .setPosition(slideFunc(0)); // set start position of counter
+
+  spindleController.rotateAsync(spindle); // let the spindle run with constant speed
+  slideController.rotateAsync(slide);
+  slideController.overrideSpeed(0); // start with stopped slide
+  tick();
+
+  // use a timer to periodically calculate new targets for the slide
+  tickTimer.priority(255); // lowest priority, potentially long caclulations need to be interruptable by TeensyStep
+  tickTimer.begin(tick, recalcPeriod);
+}
+
+void loop()
+{
+  digitalWriteFast(LED_BUILTIN, !digitalReadFast(LED_BUILTIN));
+
+  // print current values of spindle angle [rad] and slide position [steps]
+  float phi = spindle.getPosition() * (TWO_PI / spindleSPR);
+  int32_t r = slide.getPosition();
+
+  Serial.printf("%f\t%d\n", phi, r);
+
+  delay(20);
+}

firmware/lib/TeensyStep/examples/StepperArray/StepperArray.ino

@@ -0,0 +1,37 @@
+#include <TeensyStep.h>
+
+Stepper M1(0, 1), M2(2, 3), M3(4, 5), M4(6, 7), M5(8, 9), M6(10, 11); // create 6 motors
+StepControl controller;
+
+void setup() 
+{
+  pinMode(LED_BUILTIN,OUTPUT);
+  delay(100);
+  
+  Stepper* motorSet_A[] = {&M1, &M2, &M5, &M6  };  // define an array of pointers to motors 1,2,5 and 6
+  M1.setTargetAbs(200);                            // set targets for the motors
+  M2.setTargetAbs(-500);   
+  M5.setTargetAbs(-100);
+  M6.setTargetAbs(30);  
+  controller.move(motorSet_A);                     // move all motors in the array to their targets
+
+  delay(500);                                      // just to generate a nice output on the logic analyzer
+ 
+  Stepper* motorSet_B[] = {&M1, &M3, &M4};         // another set of motors;
+  M1.setTargetAbs(-110);
+  M3.setTargetAbs(50);   
+  M4.setTargetAbs(230);
+  controller.move(motorSet_B);                     // move set B to target
+
+  delay(500);                                      // just to generate a nice output on the logic analyzer
+ 
+  for (int i = 0; i < 4; i++) {                    // loop through all motors in motorSet_A...
+    motorSet_A[i]->setTargetAbs(0);                // ... set targets to 0...
+  }
+  controller.move(motorSet_A);                     // ... and move home
+}
+
+void loop(){
+  digitalWriteFast(LED_BUILTIN,!digitalReadFast(LED_BUILTIN));
+  delay(100);
+}

firmware/lib/TeensyStep/examples/StepperArray/readme.md

@@ -0,0 +1,3 @@
+This example shows the usage of more than 3 motors. Here a screenshot of the step pulses generated by the sketch.
+
+![Alt text](/media/stepperArray.png?raw=true "Sketch output")

firmware/lib/TeensyStep/keywords.txt

@@ -0,0 +1,19 @@
+########################################################
+# Syntax Coloring Map for SparkFun LSM6DS3 IMU Library #
+########################################################
+# Class
+###################################################################
+
+
+###################################################################
+# Methods and Functions
+###################################################################
+
+begin	KEYWORD2
+Trigger	KEYWORD2
+AddChannel	KEYWORD2
+
+###################################################################
+# Constants
+###################################################################
+

firmware/lib/TeensyStep/library.json

@@ -0,0 +1,21 @@
+{
+  "name": "TeensyStep",
+  "keywords": "teensy, stepper, motor, high-speed",
+  "description": "High speed stepper driver for teensy boards (T3.0 - T3.6)",
+  "repository":
+  {
+    "type": "git",
+    "url": "https://github.com/luni64/TeensyStep"
+  },
+  "authors":
+  {
+    "name": "Lutz Niggl",
+    "email": "lutz.niggl@lunoptics.com",
+    "url": "https://github.com/luni64",
+    "maintainer": true
+  },
+  "homepage": "https://luni64.github.io/TeensyStep",
+  "version": "2.1",
+  "frameworks": "arduino",
+  "platforms": "Teensy"
+}

firmware/lib/TeensyStep/library.properties

@@ -0,0 +1,10 @@
+name=TeensyStep
+version=2.1
+author=Lutz Niggl <lutz.niggl@lunoptics.com>
+maintainer=Lutz Niggl <lutz.niggl@lunoptics.com>
+sentence=High speed stepper driver for PJRC Teensy boards (T3.0 - T3.6)
+paragraph= Step rates up to 300000stp/sec. Accelerated and synchronized movement of up to 10 steppers. Due to the low processor load it can easily be used togehter with sensors, displays, serial communication ...
+category=Device Control
+url=https://luni64.github.io/TeensyStep/
+architectures=*
+includes=TeensyStep.h

firmware/lib/TeensyStep/src/ErrorHandler.cpp

@@ -0,0 +1,56 @@
+#include "ErrorHandler.h"
+#include <Arduino.h>
+
+namespace TeensyStep
+{    
+    static Stream* stream;   
+
+    static void vHandler(int module, int code)
+    {       
+        const char* mod;
+        const char* txt;
+
+        switch ((errModule)module)
+        {
+            case errModule::PIT: //----------------------------------------
+                mod = "PIT";
+                switch ((pitErr)code)
+                {
+                    case pitErr::outOfTimers: txt = "No timer available"; break;
+                    case pitErr::argErr:      txt = "BUG, argument error"; break;
+                    case pitErr::notAllocated:txt = "BUG, timer not allocated"; break;
+                    default:                  txt = "unknown"; break;
+                }                
+                break;           
+
+            case errModule::MC: //------------------------------------------
+                mod = "CTRL";
+                switch ((mcErr)code)
+                {
+                    case mcErr::alrdyMoving:  txt = "Started while moving"; break;
+                    default:                  txt = "unknown"; break;
+                }                
+                break;
+
+            default: //------------------------------------------------------
+                mod = "unknown";
+                txt = "unknown";
+                break;
+        }
+        stream->printf("ERR M%iC%i: %s (%s)\n", module, code, txt, mod);
+
+        while (true)
+        {
+            digitalWriteFast(LED_BUILTIN, !digitalReadFast(LED_BUILTIN));
+            delay(50);
+        }
+    }
+
+    errCallback_t* verboseHandler(Stream& s)
+    {
+        stream = &s;
+        return vHandler;
+    }
+
+    errCallback_t* ErrorHandler::callback = nullptr;
+}

firmware/lib/TeensyStep/src/ErrorHandler.h

@@ -0,0 +1,45 @@
+#pragma once
+#include "Stream.h"
+
+namespace TeensyStep
+{
+    using errCallback_t = void(int, int);
+
+    enum class errModule;
+    enum class pitERR;
+
+    class ErrorHandler
+    {
+     public:
+        static int error(errModule module, int code)
+        {            
+            if (callback != nullptr) callback((int)module, code);
+            return code;
+        }
+        static void attachCallback(errCallback_t* cb) { callback = cb; }
+
+     protected:
+        static errCallback_t* callback;
+    };
+
+    extern errCallback_t* verboseHandler(Stream&);
+
+    enum class errModule {
+        PIT = 1,
+        MC,
+        RB 
+    };
+
+    enum class pitErr {
+        OK,
+        argErr,
+        notAllocated,
+        outOfTimers,
+        
+    };
+
+    enum class mcErr {
+        OK,
+        alrdyMoving,        
+    };
+}

firmware/lib/TeensyStep/src/MotorControlBase.h

@@ -0,0 +1,179 @@
+#pragma once
+
+#include "ErrorHandler.h"
+#include "Stepper.h"
+#include "timer/TF_Handler.h"
+
+namespace TeensyStep{
+
+    enum ErrCode {
+        err_OK,
+        err_movment_not_possible,
+        err_too_much_motors
+    };
+
+    using ErrFunc = void (*)(ErrCode);
+
+    constexpr int MaxMotors = 10;
+
+    template <typename TimerField>
+    class MotorControlBase : TF_Handler, ErrorHandler
+    {
+     public:
+        bool isOk() const { return OK; }
+        bool isRunning() const;
+        bool isAllocated() const;
+        int getCurrentSpeed() const;
+
+        void emergencyStop() { timerField.end(); }
+
+        virtual ~MotorControlBase();
+
+        void attachErrorFunction(ErrFunc ef) { errFunc = ef; }
+
+     protected:
+        TimerField timerField;
+        MotorControlBase(unsigned pulseWidth, unsigned accUpdatePeriod);
+
+        template <size_t N>
+        void attachStepper(Stepper* (&motors)[N]);
+        template <typename... Steppers>
+        void attachStepper(Stepper& stepper, Steppers&... steppers);
+        void attachStepper(Stepper& stepper);
+
+        void stepTimerISR();
+        void pulseTimerISR();
+
+        Stepper* motorList[MaxMotors + 1];
+        Stepper* leadMotor;
+
+        void (*callback)() = nullptr;
+        ErrFunc errFunc = nullptr;
+        inline void Error(ErrCode e)
+        {
+            if (errFunc != nullptr) errFunc(e);
+        }
+
+        bool OK = false;
+
+        unsigned mCnt;
+
+        enum class Mode {
+            target,
+            notarget
+        } mode = Mode::notarget;
+
+        uint32_t accUpdatePeriod;
+        uint32_t pulseWidth;
+
+        inline mcErr err(mcErr code) const { return (mcErr)error(errModule::MC, (int)code); }
+
+        MotorControlBase(const MotorControlBase&) = delete;
+        MotorControlBase& operator=(const MotorControlBase&) = delete;
+    };
+
+    // Implementation ============================================================================
+
+    template <typename t>
+    bool MotorControlBase<t>::isRunning() const
+    {
+        return timerField.stepTimerIsRunning();
+    }
+
+    template <typename t>
+    bool MotorControlBase<t>::isAllocated() const
+    {
+        return timerField.stepTimerIsAllocated();
+    }
+
+    template <typename t>
+    int MotorControlBase<t>::getCurrentSpeed() const
+    {
+        return timerField.getStepFrequency();
+    }
+
+    template <typename t>
+    MotorControlBase<t>::MotorControlBase(unsigned pulseWidth, unsigned accUpdatePeriod)
+        : timerField(this), mCnt(0)
+    {        
+        timerField.setPulseWidth(pulseWidth);
+        timerField.setAccUpdatePeriod(accUpdatePeriod);
+        this->accUpdatePeriod = accUpdatePeriod;
+        this->pulseWidth = pulseWidth;
+    }
+
+    template <typename t>
+    MotorControlBase<t>::~MotorControlBase()
+    {
+        if (OK)
+            emergencyStop();
+    }
+
+    template <typename t>
+    void MotorControlBase<t>::stepTimerISR()
+    {
+        leadMotor->doStep(); // move master motor
+
+        Stepper** slave = motorList;
+        while (*(++slave) != nullptr) // move slave motors if required (https://en.wikipedia.org/wiki/Bresenham)
+        {
+            if ((*slave)->B >= 0)
+            {
+                (*slave)->doStep();
+                (*slave)->B -= leadMotor->A;
+            }
+            (*slave)->B += (*slave)->A;
+        }
+        timerField.triggerDelay(); // start delay line to dactivate all step pins
+
+        if (mode == Mode::target && (leadMotor->current == leadMotor->target)) // stop timer and call callback if we reached target
+        {
+            //timerField.stepTimerStop();
+            timerField.endAfterPulse();
+            if (callback != nullptr)
+                callback();
+        }
+    }
+
+    template <typename t>
+    void MotorControlBase<t>::pulseTimerISR()
+    {
+        Stepper** motor = motorList;
+        while ((*motor) != nullptr)
+        {
+            (*motor++)->clearStepPin();
+        }
+    }
+
+    template <typename t>
+    void MotorControlBase<t>::attachStepper(Stepper& stepper)
+    {
+        motorList[mCnt++] = &stepper;
+        motorList[mCnt] = nullptr;
+        mCnt = 0;
+    }
+
+    template <typename t>
+    template <typename... Steppers>
+    void MotorControlBase<t>::attachStepper(Stepper& stepper, Steppers&... steppers)
+    {
+        static_assert(sizeof...(steppers) < MaxMotors, "Too many motors used. Please increase MaxMotors in file MotorControlBase.h");
+
+        motorList[this->mCnt++] = &stepper;
+        attachStepper(steppers...);
+    }
+
+    template <typename t>
+    template <size_t N>
+    void MotorControlBase<t>::attachStepper(Stepper* (&motors)[N])
+    {
+        static_assert(N <= MaxMotors, "Too many motors used. Please increase MaxMotors in file MotorControlBase.h");
+
+        for (size_t i = 0; i < N; i++)
+        {
+            this->motorList[i] = motors[i];
+        }
+        this->motorList[N] = nullptr;
+    }
+
+} // namespace TeensyStep

firmware/lib/TeensyStep/src/RotateControlBase.h

@@ -0,0 +1,169 @@
+#pragma once
+
+#include "MotorControlBase.h"
+#include "core_pins.h"
+#include <algorithm>
+
+namespace TeensyStep
+{
+    template <typename Accelerator, typename TimerField>
+    class RotateControlBase : public TeensyStep::MotorControlBase<TimerField>
+    {
+     public:
+        RotateControlBase(unsigned pulseWidth = 5, unsigned accUpdatePeriod = 5000);
+
+        // Non-blocking movements ----------------
+        template <typename... Steppers>
+        void rotateAsync(Steppers&... steppers);
+
+        template <size_t N>
+        void rotateAsync(Stepper* (&motors)[N]);
+
+        void stopAsync();
+
+        // Blocking movements --------------------
+        void stop();
+
+        void overrideSpeed(float speedFac);
+        void overrideAcceleration(float accFac);
+
+     protected:
+        void doRotate(int N, float speedFactor = 1.0);
+        void accTimerISR();
+
+        Accelerator accelerator;
+
+        RotateControlBase(const RotateControlBase&) = delete;
+        RotateControlBase& operator=(const RotateControlBase&) = delete;
+
+        bool isStopping = false;
+    };
+
+    // Implementation *************************************************************************************************
+
+    template <typename a, typename t>
+    RotateControlBase<a, t>::RotateControlBase(unsigned pulseWidth, unsigned accUpdatePeriod)
+        : MotorControlBase<t>(pulseWidth, accUpdatePeriod)
+    {
+        this->mode = MotorControlBase<t>::Mode::notarget;
+    }
+
+    template <typename a, typename t>
+    void RotateControlBase<a, t>::doRotate(int N, float speedFactor)
+    {
+        if(this->isRunning())
+        {
+            this->err(mcErr::alrdyMoving);
+            return;
+        }
+
+        //Calculate Bresenham parameters ----------------------------------------------------------------
+        std::sort(this->motorList, this->motorList + N, Stepper::cmpVmax);
+        this->leadMotor = this->motorList[0];
+
+        if (this->leadMotor->vMax == 0)
+            return;
+
+        this->leadMotor->currentSpeed = 0;
+
+        this->leadMotor->A = std::abs(this->leadMotor->vMax);
+        for (int i = 1; i < N; i++)
+        {
+            this->motorList[i]->A = std::abs(this->motorList[i]->vMax);
+            this->motorList[i]->B = 2 * this->motorList[i]->A - this->leadMotor->A;
+        }
+        uint32_t acceleration = (*std::min_element(this->motorList, this->motorList + N, Stepper::cmpAcc))->a; // use the lowest acceleration for the move
+
+        // Start moving----------------------------------------------------------------------------------------------
+        isStopping = false;
+        this->timerField.begin();
+        accelerator.prepareRotation(this->leadMotor->current, this->leadMotor->vMax, acceleration, this->accUpdatePeriod, speedFactor);
+        this->timerField.accTimerStart();
+    }
+
+    // ISR -----------------------------------------------------------------------------------------------------------
+
+    template <typename a, typename t>
+    void RotateControlBase<a, t>::accTimerISR()
+    {
+        int32_t newSpeed = accelerator.updateSpeed(this->leadMotor->current); // get new speed for the leading motor
+
+        if (isStopping && newSpeed == 0)
+        {
+            this->timerField.end();
+            this->leadMotor->currentSpeed = 0;
+            isStopping = false;
+            return;
+        }
+
+        if (this->leadMotor->currentSpeed == newSpeed)
+        {
+            return; // nothing changed, just keep running
+        }
+
+        int dir = newSpeed >= 0 ? 1 : -1; // direction changed? -> toggle direction of all motors
+        if (dir != this->leadMotor->dir)
+        {
+            Stepper** motor = this->motorList;
+            while ((*motor) != nullptr)
+            {
+                (*motor++)->toggleDir();
+            }
+            delayMicroseconds(this->pulseWidth); // dir signal need some lead time
+        }
+
+        this->timerField.setStepFrequency(std::abs(newSpeed)); // speed changed, update timer
+        this->leadMotor->currentSpeed = newSpeed;
+    }
+
+    // ROTATE Commands -------------------------------------------------------------------------------
+
+    template <typename a, typename t>
+    template <typename... Steppers>
+    void RotateControlBase<a, t>::rotateAsync(Steppers&... steppers)
+    {
+        this->attachStepper(steppers...);
+        doRotate(sizeof...(steppers));
+    }
+
+    template <typename a, typename t>
+    template <size_t N>
+    void RotateControlBase<a, t>::rotateAsync(Stepper* (&steppers)[N])
+    {
+        this->attachStepper(steppers);
+        doRotate(N);
+    }
+
+    template <typename a, typename t>
+    void RotateControlBase<a, t>::overrideSpeed(float factor)
+    {
+        isStopping = false;
+        accelerator.overrideSpeed(factor);
+    }
+
+    template <typename a, typename t>
+    void RotateControlBase<a, t>::overrideAcceleration(float factor)
+    {
+        accelerator.overrideAcceleration(factor);
+    }
+
+    template <typename a, typename t>
+    void RotateControlBase<a, t>::stopAsync()
+    {
+        if (!isStopping)
+        {
+            isStopping = true;
+            accelerator.initiateStopping(this->leadMotor->current);
+        }
+    }
+
+    template <typename a, typename t>
+    void RotateControlBase<a, t>::stop()
+    {
+        stopAsync();
+        while (this->isRunning())
+        {
+            delay(1);
+        }
+    }
+}

firmware/lib/TeensyStep/src/StepControlBase.h

@@ -0,0 +1,182 @@
+#pragma once
+
+#include "MotorControlBase.h"
+#include <algorithm>
+
+namespace TeensyStep
+{
+
+    template <typename Accelerator, typename TimerField>
+    class StepControlBase : public MotorControlBase<TimerField>
+    {
+     public:
+        StepControlBase(unsigned pulseWidth = 5, unsigned accUpdatePeriod = 5000);
+
+        // Non-blocking movements ------------------------------------------
+
+        // Move variadic param list of stepper references e.g. moveAsync(m1,m2,m3,m5)
+        template <typename... Steppers>
+        void moveAsync(Steppers&... steppers) { moveAsync(1.0f, steppers...); }
+
+        // Move variadic param list of stepper references with speed override e.g. moveAsync(0.2f,m1,m2,m3,m5)
+        template <typename... Steppers>
+        void moveAsync(float speedOverride, Steppers&... steppers);
+
+        // Move array of stepper pointers with speed override
+        template <size_t N>
+        void moveAsync(float speedOverride, Stepper* (&steppers)[N]);
+
+        // Move array of stepper pointers
+        template <size_t N>
+        void moveAsync(Stepper* (&steppers)[N]) { moveAsync(1.0f, steppers); }
+
+        // non blocking stop command
+        void stopAsync();
+
+        // Blocking movements ----------------------------------------------
+
+        // Move variadic param list of stepper references e.g. move(m1,m2,m3,m5)
+        template <typename... Steppers>
+        void move(Steppers&... steppers) { move(1.0f, steppers...); }
+
+        // Move variadic param list of stepper references with speed override. E.g., move(0.5f, m1,m2,m3,m5)
+        template <typename... Steppers>
+        void move(float speedOverride, Steppers&... steppers);
+
+        // Move array of stepper pointers
+        template <size_t N>
+        void move(Stepper* (&steppers)[N]) { move(1.0f, steppers); }
+
+        // Move array of stepper pointers with speed override
+        template <size_t N>
+        void move(float speedOverride, Stepper* (&steppers)[N]);
+
+        // blocking stop command
+        void stop();
+
+        // Misc ---------------------------------------------------------
+
+        // set callback function to be called when target is reached
+        void setCallback(void (*_callback)()) { this->callback = _callback; }
+
+     protected:
+        void accTimerISR();
+
+        void doMove(int N, float speedOverride = 1.0f);
+
+        Accelerator accelerator;
+
+        StepControlBase(const StepControlBase&) = delete;
+        StepControlBase& operator=(const StepControlBase&) = delete;
+    };
+
+    // Implementation *************************************************************************************************
+
+    template <typename a, typename t>
+    StepControlBase<a, t>::StepControlBase(unsigned pulseWidth, unsigned accUpdatePeriod)
+        : MotorControlBase<t>(pulseWidth, accUpdatePeriod)
+    {
+        this->mode = MotorControlBase<t>::Mode::target;
+    }
+
+    template <typename a, typename t>
+    void StepControlBase<a, t>::doMove(int N, float speedOverride)
+    {
+        //Calculate Bresenham parameters -------------------------------------
+        std::sort(this->motorList, this->motorList + N, Stepper::cmpDelta); // The motor which does most steps leads the movement, move to top of list
+        this->leadMotor = this->motorList[0];
+
+        for (int i = 1; i < N; i++)
+        {
+            this->motorList[i]->B = 2 * this->motorList[i]->A - this->leadMotor->A;
+        }
+
+        // Calculate acceleration parameters --------------------------------
+        uint32_t targetSpeed = std::abs((*std::min_element(this->motorList, this->motorList + N, Stepper::cmpVmin))->vMax) * speedOverride; // use the lowest max frequency for the move, scale by relSpeed
+        uint32_t pullInSpeed = this->leadMotor->vPullIn;
+        uint32_t pullOutSpeed = this->leadMotor->vPullOut;
+        uint32_t acceleration = (*std::min_element(this->motorList, this->motorList + N, Stepper::cmpAcc))->a; // use the lowest acceleration for the move
+
+        if (this->leadMotor->A == 0 || targetSpeed == 0) return;
+
+        // Start move--------------------------
+        this->timerField.begin();
+
+        this->timerField.setStepFrequency(accelerator.prepareMovement(this->leadMotor->current, this->leadMotor->target, targetSpeed, pullInSpeed, pullOutSpeed, acceleration));
+        this->timerField.stepTimerStart();
+        this->timerField.accTimerStart();
+    }
+
+    // ISR -----------------------------------------------------------------------------------------------------------
+
+    template <typename a, typename t>
+    void StepControlBase<a, t>::accTimerISR()
+    {
+        if (this->isRunning())
+        {
+            this->timerField.setStepFrequency(accelerator.updateSpeed(this->leadMotor->current));
+        }
+    }
+
+    // Non blocking movements ---------------------------------------------------------------------------------------
+
+    template <typename a, typename t>
+    template <typename... Steppers>
+    void StepControlBase<a, t>::moveAsync(float speedOverride, Steppers&... steppers)
+    {
+        this->attachStepper(steppers...);
+        doMove(sizeof...(steppers), speedOverride);
+    }
+
+    template <typename a, typename t>
+    template <size_t N>
+    void StepControlBase<a, t>::moveAsync(float speedOverride, Stepper* (&motors)[N]) //move up to maxMotors motors synchronously
+    {
+        this->attachStepper(motors);
+        doMove(N, speedOverride);
+    }
+
+    template <typename a, typename t>
+    void StepControlBase<a, t>::stopAsync()
+    {
+        if (this->isRunning())
+        {
+            uint32_t newTarget = accelerator.initiateStopping(this->leadMotor->current);
+            this->leadMotor->target = this->leadMotor->current + this->leadMotor->dir * newTarget;
+        }
+    }
+
+    // Blocking movmenents -------------------------------------------------------------------------------------------------
+
+    template <typename a, typename t>
+    template <typename... Steppers>
+    void StepControlBase<a, t>::move(float speedOverride, Steppers&... steppers)
+    {
+        moveAsync(speedOverride, steppers...);
+        while (this->timerField.stepTimerIsRunning())
+        {
+            delay(1);
+        }
+    }
+
+    template <typename a, typename t>
+    template <size_t N>
+    void StepControlBase<a, t>::move(float speedOverride, Stepper* (&motors)[N])
+    {
+        moveAsync(speedOverride, motors);
+        while (this->isRunning())
+        {
+            delay(1);
+        }
+    }
+
+    template <typename a, typename t>
+    void StepControlBase<a, t>::stop()
+    {
+        stopAsync();
+        while (this->isRunning())
+        {
+            delay(1);
+        }
+    }
+}

firmware/lib/TeensyStep/src/Stepper.cpp

@@ -0,0 +1,97 @@
+#include "Stepper.h"
+#include "core_pins.h"
+
+namespace TeensyStep
+{
+    Stepper::Stepper(const int _stepPin, const int _dirPin)
+        : current(0), stepPin(_stepPin), dirPin(_dirPin)
+    {
+        setStepPinPolarity(HIGH);
+        setInverseRotation(false);
+        setAcceleration(aDefault);
+        setMaxSpeed(vMaxDefault);
+        setPullInSpeed(vPullInOutDefault);
+
+        pinMode(stepPin, OUTPUT);
+        pinMode(dirPin, OUTPUT);
+    }
+
+    Stepper& Stepper::setStepPinPolarity(int polarity)
+    {
+        // Calculate adresses of bitbanded pin-set and pin-clear registers
+        uint32_t pinRegAddr = (uint32_t)digital_pin_to_info_PGM[stepPin].reg; //GPIO_PDOR
+        uint32_t* pinSetReg = (uint32_t*)(pinRegAddr + 4 * 32);               //GPIO_PSOR = GPIO_PDOR + 4
+        uint32_t* pinClearReg = (uint32_t*)(pinRegAddr + 8 * 32);             //GPIO_PCOR = GPIO_PDOR + 8
+
+        // Assign registers according to step option
+        if (polarity == LOW)
+        {
+            stepPinActiveReg = pinClearReg;
+            stepPinInactiveReg = pinSetReg;
+        } else
+        {
+            stepPinActiveReg = pinSetReg;
+            stepPinInactiveReg = pinClearReg;
+        }
+        clearStepPin(); // set step pin to inactive state
+        return *this;
+    }
+
+    Stepper& Stepper::setInverseRotation(bool reverse)
+    {
+        // Calculate adresses of bitbanded pin-set and pin-clear registers
+        uint32_t pinRegAddr = (uint32_t)digital_pin_to_info_PGM[dirPin].reg; //GPIO_PDOR
+        uint32_t* pinSetReg = (uint32_t*)(pinRegAddr + 4 * 32);              //GPIO_PSOR = GPIO_PDOR + 4
+        uint32_t* pinClearReg = (uint32_t*)(pinRegAddr + 8 * 32);            //GPIO_PCOR = GPIO_PDOR + 8
+
+        if (reverse)
+        {
+            dirPinCwReg = pinClearReg;
+            dirPinCcwReg = pinSetReg;
+        } else
+        {
+            dirPinCwReg = pinSetReg;
+            dirPinCcwReg = pinClearReg;
+        }
+        return *this;
+    }
+
+    Stepper& Stepper::setAcceleration(uint32_t a) // steps/s^2
+    {
+        this->a = std::min(aMax, a);
+        return *this;
+    }
+
+    Stepper& Stepper::setMaxSpeed(int32_t speed)
+    {
+        setDir(speed >= 0 ? 1 : -1);
+        vMax = std::min(vMaxMax, std::max(-vMaxMax, speed));
+        return *this;
+    }
+
+    Stepper& Stepper::setPullInSpeed(int32_t speed)
+    {
+        vPullIn = vPullOut = std::abs(speed);
+        return *this;
+    }
+
+    Stepper& Stepper::setPullInOutSpeed(int32_t pullInSpeed, int32_t pullOutSpeed)
+    {
+        vPullIn = std::abs(pullInSpeed);
+        vPullOut = std::abs(pullOutSpeed);
+
+        return *this;
+    }
+
+    void Stepper::setTargetAbs(int32_t target)
+    {
+        setTargetRel(target - current);
+    }
+
+    void Stepper::setTargetRel(int32_t delta)
+    {
+        setDir(delta < 0 ? -1 : 1);
+        target = current + delta;
+        A = std::abs(delta);
+    }
+}

firmware/lib/TeensyStep/src/Stepper.h

@@ -0,0 +1,97 @@
+#pragma once
+
+#include <algorithm>
+#include <cstdint>
+
+namespace TeensyStep
+{
+
+    class Stepper
+    {
+        static constexpr int32_t vMaxMax = 300000;   // largest speed possible (steps/s)
+        static constexpr uint32_t aMax = 500000;     // speed up to 500kHz within 1 s (steps/s^2)
+        static constexpr uint32_t vMaxDefault = 800; // should work with every motor (1 rev/sec in 1/4-step mode)
+        static constexpr uint32_t vPullInOutDefault = 100;
+        static constexpr uint32_t aDefault = 2500; // reasonably low (~0.5s for reaching the default speed)
+
+     public:
+        Stepper(const int StepPin, const int DirPin);
+
+        Stepper& setMaxSpeed(int32_t speed);                                  // steps/s
+        Stepper& setPullInSpeed(int32_t speed);                               // steps/s
+        Stepper& setPullInOutSpeed(int32_t pullInpeed, int32_t pullOutSpeed); // steps/s
+        Stepper& setAcceleration(uint32_t _a);                                // steps/s^2
+
+        Stepper& setStepPinPolarity(int p);  // HIGH -> positive pulses, LOW -> negative pulses
+        Stepper& setInverseRotation(bool b); // Change polarity of the dir pulse
+
+        void setTargetAbs(int32_t pos);   // Set target position absolute
+        void setTargetRel(int32_t delta); // Set target position relative to current position
+
+        inline int32_t getPosition() const { return current; }
+        inline void setPosition(int32_t pos) { current = pos; }
+        int32_t dir;
+
+     protected:
+        inline void doStep();
+        inline void clearStepPin() const;
+
+        inline void setDir(int d);
+        inline void toggleDir();
+
+        volatile int32_t current;
+        volatile int32_t currentSpeed;
+        volatile int32_t target;
+
+        int32_t A, B; // Bresenham paramters
+        int32_t vMax;
+        int32_t vPullIn, vPullOut;
+        uint32_t a;
+
+        // compare functions
+        static bool cmpDelta(const Stepper* a, const Stepper* b) { return a->A > b->A; }
+        static bool cmpAcc(const Stepper* a, const Stepper* b) { return a->a < b->a; }
+        static bool cmpVmin(const Stepper* a, const Stepper* b) { return std::abs(a->vMax) < std::abs(b->vMax); }
+        static bool cmpVmax(const Stepper* a, const Stepper* b) { return std::abs(a->vMax) > std::abs(b->vMax); }
+
+        // Pin & Dir registers
+        volatile uint32_t* stepPinActiveReg;
+        volatile uint32_t* stepPinInactiveReg;
+        volatile uint32_t* dirPinCwReg;
+        volatile uint32_t* dirPinCcwReg;
+        const int stepPin, dirPin;
+
+        // Friends
+        template <typename a, typename t>
+        friend class StepControlBase;
+
+        template <typename a, typename t>
+        friend class RotateControlBase;
+
+        template <typename t>
+        friend class MotorControlBase;
+    };
+
+    // Inline implementation -----------------------------------------
+
+    void Stepper::doStep()
+    {
+        *stepPinActiveReg = 1;
+        current += dir;
+    }
+    void Stepper::clearStepPin() const
+    {
+        *stepPinInactiveReg = 1;
+    }
+
+    void Stepper::setDir(int d)
+    {
+        dir = d;
+        dir == 1 ? * dirPinCwReg = 1 : * dirPinCcwReg = 1;
+    }
+
+    void Stepper::toggleDir()
+    {
+        setDir(-dir);
+    }
+}

firmware/lib/TeensyStep/src/TeensyStep.h

@@ -0,0 +1,60 @@
+#pragma once
+
+#include "RotateControlBase.h"
+#include "StepControlBase.h"
+#include "Stepper.h"
+#include "accelerators/LinRotAccelerator.h"
+#include "accelerators/LinStepAccelerator.h"
+#include "version.h"
+//#include "accelerators/SinRotAccelerator.h"
+
+#include "timer/generic/TimerField.h"
+
+// TEENSY 3.0 - Teensy 3.6 ==================================================================================
+
+#if defined(__MK20DX128__) || defined(__MK20DX256__) || defined(__MK64FX512__) || defined(__MK66FX1M0__)
+#include "timer/teensy3/TimerField2.h"
+
+// TEENSY 4 ================================================================================================
+
+#elif defined(__IMXRT1052__)
+#include "timer/teensy4/TimerField.h"
+
+//STM32 ====================================================================================================
+
+#elif defined(__STM32_TBD__)
+#include "timers/STM32/TimerField.h"
+
+//Some other hardware ======================================================================================
+
+#elif defined(__someHardware_TBD__)
+#include "timers/someHardware/TimerField2.h"
+#endif
+
+// Linear acceleration -----------------------------------------------------------------------------------------
+
+//using MotorControl = TeensyStep::MotorControlBase<TimerField>;
+
+using RotateControl = TeensyStep::RotateControlBase<LinRotAccelerator, TimerField>;
+using StepControl = TeensyStep::StepControlBase<LinStepAccelerator, TimerField>;
+
+using StepControlTick = TeensyStep::StepControlBase<LinStepAccelerator, TickTimerField>;
+using RotateControlTick = TeensyStep::RotateControlBase<LinStepAccelerator, TickTimerField>;
+
+// Sine acceleration -------------------------------------------------------------------------------------------
+
+// template <unsigned stepPulseWidth = defPW, unsigned accUpdatePeriod = defAP>
+// using RotateControlSin = RotateControlBase<SinRotAccelerator, TimerField>;
+
+//template <unsigned p = defPW, unsigned a>
+//using StepControlSin = StepControlBase<SinStepAccelerator, p, a>;
+
+// Generic ==========================================================================================
+
+// template <unsigned stepPulseWidth = defPW, unsigned accUpdatePeriod = defAP>
+// using RotateControl_tick = RotateControlBase<LinRotAccelerator, stepPulseWidth, accUpdatePeriod>;
+
+// template <unsigned stepPulseWidth = defPW, unsigned a = defAP>
+// using StepControl_tick = StepControlBase<LinStepAccelerator, stepPulseWidth, a>;
+
+using Stepper = TeensyStep::Stepper;

firmware/lib/TeensyStep/src/accelerators/LinRotAccelerator.h

@@ -0,0 +1,87 @@
+#pragma once
+
+
+#include "Arduino.h"
+
+
+class LinRotAccelerator
+{
+public:
+    inline void prepareRotation(int32_t currentPosition, int32_t targetSpeed, uint32_t acceleration, uint32_t accUpdatePeriod, float speedFactor = 1.0);
+    inline int32_t updateSpeed(int32_t currentPosition);
+    inline int32_t initiateStopping(int32_t currentPosition);
+    inline void overrideSpeed(float factor);
+    inline void overrideAcceleration(float factor);
+
+    LinRotAccelerator() = default;
+
+protected:
+    LinRotAccelerator(const LinRotAccelerator &) = delete;
+    LinRotAccelerator &operator=(const LinRotAccelerator &) = delete;
+
+    // int32_t v_tgt, v_cur;
+    // int32_t v_tgt_orig, dv_orig, dv;
+
+    float v_tgt, v_cur;
+    float v_tgt_orig, dv_orig, dv_cur, dv;
+};
+
+// Inline Implementation =====================================================================================================
+
+void LinRotAccelerator::prepareRotation(int32_t currentPosition, int32_t targetSpeed, uint32_t a, uint32_t accUpdatePeriod, float speedFactor)
+{
+    v_tgt_orig = targetSpeed;
+    dv_orig = ((float)a * accUpdatePeriod) / 1E6;
+    v_cur = 0;
+
+    overrideAcceleration(1.0f);
+    overrideSpeed(speedFactor);
+}
+
+void LinRotAccelerator::overrideSpeed(float factor)
+{
+    //Serial.printf("a:------ %d\n", a);
+
+    noInterrupts();
+    v_tgt = v_tgt_orig * factor;
+    dv = v_tgt > v_cur ? dv_cur : -dv_cur;
+    interrupts();
+}
+
+void LinRotAccelerator::overrideAcceleration(float factor)
+{
+    //Serial.printf("a:------ %d\n", a);
+    if (factor > 0)
+    {
+        noInterrupts();
+        dv_cur = dv_orig * factor;
+        dv *= factor;
+        interrupts();
+    }
+}
+
+int32_t LinRotAccelerator::updateSpeed(int32_t curPos)
+{
+    if (v_cur == v_tgt)
+        return (int32_t)v_tgt; // already at target, keep spinning with target frequency
+
+    v_cur += dv;
+    v_cur = dv > 0.0f ? std::min(v_tgt, v_cur) : std::max(v_tgt, v_cur);
+
+    return (int32_t)v_cur;
+}
+
+int32_t LinRotAccelerator::initiateStopping(int32_t curPos)
+{
+    overrideSpeed(0);
+    return 0;
+}
+
+// void LinRotAccelerator::eStop()
+// {
+//     noInterrupts();
+//     v_cur = 0.0f;
+//     v_tgt = 0.0f;
+//     interrupts();
+// }
+