created Atm_AccelStepper

more generic stepper controler

Atm_AccelStepper.cpp

@@ -0,0 +1,265 @@
+#include "Atm_AccelStepper.h"
+
+/* Add optional parameters for the state machine to begin()
+ * Add extra initialization code
+ */
+
+Atm_AccelStepper& Atm_AccelStepper::begin(int step_pin, int dir_pin) {
+  // clang-format off
+  const static state_t state_table[] PROGMEM = {
+    /*                       ON_ENTER     ON_LOOP          ON_EXIT  EVT_DISABLE  EVT_ENABLE  EVT_ENABLED_TIMEOUT  EVT_STOP  EVT_EMERGENCY_STOP  EVT_ON_LIMIT_LOW  EVT_ON_LIMIT_HIGH  EVT_ON_TARGET  ELSE */
+    /*    DISABLED */    ENT_DISABLED,         -1,              -1,          -1,    ENABLED,                  -1,       -1,                 -1,               -1,                -1,            -1,   -1,
+    /*     ENABLED */     ENT_ENABLED,         -1,              -1,    DISABLE,         -1,            DISABLED,     STOP,               STOP,               -1,                -1,            -1,   -1,
+    /*     RUNNING */              -1, LP_RUNNING,              -1,    DISABLE,         -1,                  -1,     STOP,               STOP,        LIMIT_LOW,        LIMIT_HIGH,       ENABLED,   -1,
+    /*        STOP */              -1,         -1,              -1,    DISABLE,         -1,                  -1,     STOP,               STOP,               -1,                -1,            -1,   -1,
+    /*  HOMING_LOW */  ENT_HOMING_LOW,         -1,  EXT_HOMING_LOW,    DISABLE,         -1,                  -1,     STOP,               STOP,          ENABLED,                -1,            -1,   -1,
+    /* HOMING_HIGH */ ENT_HOMING_HIGH,         -1, EXT_HOMING_HIGH,    DISABLE,         -1,                  -1,     STOP,               STOP,               -1,           ENABLED,            -1,   -1,
+    /*   LIMIT_LOW */   ENT_LIMIT_LOW,         -1,              -1,          -1,         -1,                  -1,     STOP,               STOP,        LIMIT_LOW,                -1,            -1,   -1,
+    /*  LIMIT_HIGH */  ENT_LIMIT_HIGH,         -1,              -1,          -1,         -1,                  -1,     STOP,               STOP,               -1,        LIMIT_HIGH,            -1,   -1,
+  };
+  // clang-format on
+  Machine::begin( state_table, ELSE );
+  stepper = new AccelStepper(1, step_pin, dir_pin);
+  idle_timer.set(ATM_TIMER_OFF);
+  return *this;
+}
+
+/* Add C++ code for each internally handled event (input)
+ * The code must return 1 to trigger the event
+ */
+
+int Atm_AccelStepper::event( int id ) {
+  //updateLimitSwitch();
+  switch ( id ) {
+    case EVT_DISABLE:
+      return 0;
+    case EVT_ENABLE:
+      return 0;
+    case EVT_ENABLED_TIMEOUT:
+      return 0;
+    case EVT_STOP:
+      return 0;
+    case EVT_EMERGENCY_STOP:
+      return 0;
+    case EVT_ON_LIMIT_LOW:
+      switch(_limitLow_Mode) {
+        case 0:
+          return 0;
+        case 1: //digital INPUT
+          limitLow_State = digitalRead(_limitLow_Pin);
+          limitLow_State = _limitLow_Reversed ? !limitLow_State : limitLow_State;
+          return limitLow_State;
+        case 2:
+          int analogTemp = analogRead(_limitLow_Pin);
+          limitLow_State = _limitLow_Thresholds[0] < analogTemp && analogTemp < _limitLow_Thresholds[1];
+          limitLow_State = _limitLow_Reversed ? !limitLow_State : limitLow_State;
+          return limitLow_State;
+      }
+    case EVT_ON_LIMIT_HIGH:
+      switch(_limitHigh_Mode) {
+        case 0:
+          return 0;
+        case 1: //digital INPUT
+          limitHigh_State = digitalRead(_limitHigh_Pin);
+          limitHigh_State = _limitHigh_Reversed ? !limitHigh_State : limitHigh_State;
+          return limitHigh_State;
+        case 2:
+          int analogTemp = analogRead(_limitHigh_Pin);
+          limitHigh_State = _limitHigh_Thresholds[0] < analogTemp && analogTemp < _limitHigh_Thresholds[1];
+          limitHigh_State = _limitHigh_Reversed ? !limitHigh_State : limitHigh_State;
+          return limitHigh_State;
+      }
+    case EVT_ON_TARGET:
+      return _currentStep == _targetStep;;
+  }
+  return 0;
+}
+
+/* Add C++ code for each action
+ * This generates the 'output' for the state machine
+ *
+ * Available connectors:
+ *   push( connectors, ON_CHANGEPOSITION, 0, <v>, <up> );
+ *   push( connectors, ON_CHANGESTATE, 0, <v>, <up> );
+ *   push( connectors, ON_ONLIMITHIGH, 0, <v>, <up> );
+ *   push( connectors, ON_ONLIMITLOW, 0, <v>, <up> );
+ *   push( connectors, ON_ONTARGET, 0, <v>, <up> );
+ *   push( connectors, ON_STOP, 0, <v>, <up> );
+ */
+
+void Atm_AccelStepper::action( int id ) {
+  switch ( id ) {
+    case ENT_DISABLED:
+      return;
+    case ENT_ENABLED:
+      return;
+    case LP_RUNNING:
+      return;
+    case ENT_HOMING_LOW:
+      return;
+    case EXT_HOMING_LOW:
+      return;
+    case ENT_HOMING_HIGH:
+      return;
+    case EXT_HOMING_HIGH:
+      return;
+    case ENT_LIMIT_LOW:
+      return;
+    case ENT_LIMIT_HIGH:
+      return;
+  }
+}
+
+/* Optionally override the default trigger() method
+ * Control how your machine processes triggers
+ */
+
+Atm_AccelStepper& Atm_AccelStepper::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_AccelStepper::state( void ) {
+  return Machine::state();
+}
+
+/* Nothing customizable below this line
+ ************************************************************************************************
+*/
+
+/* Public event methods
+ *
+ */
+
+Atm_AccelStepper& Atm_AccelStepper::disable() {
+  trigger( EVT_DISABLE );
+  return *this;
+}
+
+Atm_AccelStepper& Atm_AccelStepper::enable() {
+  trigger( EVT_ENABLE );
+  return *this;
+}
+
+Atm_AccelStepper& Atm_AccelStepper::stop() {
+  trigger( EVT_STOP );
+  return *this;
+}
+
+Atm_AccelStepper& Atm_AccelStepper::emergency_stop() {
+  trigger( EVT_EMERGENCY_STOP );
+  return *this;
+}
+
+Atm_AccelStepper& Atm_AccelStepper::on_limit_low() {
+  trigger( EVT_ON_LIMIT_LOW );
+  return *this;
+}
+
+Atm_AccelStepper& Atm_AccelStepper::on_limit_high() {
+  trigger( EVT_ON_LIMIT_HIGH );
+  return *this;
+}
+
+Atm_AccelStepper& Atm_AccelStepper::on_target() {
+  trigger( EVT_ON_TARGET );
+  return *this;
+}
+
+/*
+ * onChangeposition() push connector variants ( slots 1, autostore 0, broadcast 0 )
+ */
+
+Atm_AccelStepper& Atm_AccelStepper::onChangeposition( Machine& machine, int event ) {
+  onPush( connectors, ON_CHANGEPOSITION, 0, 1, 1, machine, event );
+  return *this;
+}
+
+Atm_AccelStepper& Atm_AccelStepper::onChangeposition( atm_cb_push_t callback, int idx ) {
+  onPush( connectors, ON_CHANGEPOSITION, 0, 1, 1, callback, idx );
+  return *this;
+}
+
+/*
+ * onChangestate() push connector variants ( slots 1, autostore 0, broadcast 0 )
+ */
+
+Atm_AccelStepper& Atm_AccelStepper::onChangestate( Machine& machine, int event ) {
+  onPush( connectors, ON_CHANGESTATE, 0, 1, 1, machine, event );
+  return *this;
+}
+
+Atm_AccelStepper& Atm_AccelStepper::onChangestate( atm_cb_push_t callback, int idx ) {
+  onPush( connectors, ON_CHANGESTATE, 0, 1, 1, callback, idx );
+  return *this;
+}
+
+/*
+ * onOnlimithigh() push connector variants ( slots 1, autostore 0, broadcast 0 )
+ */
+
+Atm_AccelStepper& Atm_AccelStepper::onOnlimithigh( Machine& machine, int event ) {
+  onPush( connectors, ON_ONLIMITHIGH, 0, 1, 1, machine, event );
+  return *this;
+}
+
+Atm_AccelStepper& Atm_AccelStepper::onOnlimithigh( atm_cb_push_t callback, int idx ) {
+  onPush( connectors, ON_ONLIMITHIGH, 0, 1, 1, callback, idx );
+  return *this;
+}
+
+/*
+ * onOnlimitlow() push connector variants ( slots 1, autostore 0, broadcast 0 )
+ */
+
+Atm_AccelStepper& Atm_AccelStepper::onOnlimitlow( Machine& machine, int event ) {
+  onPush( connectors, ON_ONLIMITLOW, 0, 1, 1, machine, event );
+  return *this;
+}
+
+Atm_AccelStepper& Atm_AccelStepper::onOnlimitlow( atm_cb_push_t callback, int idx ) {
+  onPush( connectors, ON_ONLIMITLOW, 0, 1, 1, callback, idx );
+  return *this;
+}
+
+/*
+ * onOntarget() push connector variants ( slots 1, autostore 0, broadcast 0 )
+ */
+
+Atm_AccelStepper& Atm_AccelStepper::onOntarget( Machine& machine, int event ) {
+  onPush( connectors, ON_ONTARGET, 0, 1, 1, machine, event );
+  return *this;
+}
+
+Atm_AccelStepper& Atm_AccelStepper::onOntarget( atm_cb_push_t callback, int idx ) {
+  onPush( connectors, ON_ONTARGET, 0, 1, 1, callback, idx );
+  return *this;
+}
+
+/*
+ * onStop() push connector variants ( slots 1, autostore 0, broadcast 0 )
+ */
+
+Atm_AccelStepper& Atm_AccelStepper::onStop( Machine& machine, int event ) {
+  onPush( connectors, ON_STOP, 0, 1, 1, machine, event );
+  return *this;
+}
+
+Atm_AccelStepper& Atm_AccelStepper::onStop( atm_cb_push_t callback, int idx ) {
+  onPush( connectors, ON_STOP, 0, 1, 1, callback, idx );
+  return *this;
+}
+
+/* State trace method
+ * Sets the symbol table and the default logging method for serial monitoring
+ */
+
+Atm_AccelStepper& Atm_AccelStepper::trace( Stream & stream ) {
+  Machine::setTrace( &stream, atm_serial_debug::trace,
+    "ACCELSTEPPER\0EVT_DISABLE\0EVT_ENABLE\0EVT_ENABLED_TIMEOUT\0EVT_STOP\0EVT_EMERGENCY_STOP\0EVT_ON_LIMIT_LOW\0EVT_ON_LIMIT_HIGH\0EVT_ON_TARGET\0ELSE\0DISABLED\0ENABLED\0RUNNING\0STOP\0HOMING_LOW\0HOMING_HIGH\0LIMIT_LOW\0LIMIT_HIGH" );
+  return *this;
+}

Atm_AccelStepper.h

@@ -0,0 +1,159 @@
+#pragma once
+
+#include <Automaton.h>
+#include <AccelStepper.h>
+
+class Atm_AccelStepper: public Machine {
+
+ public:
+  enum { DISABLE, ENABLED, RUNNING, STOP, HOMING_LOW, HOMING_HIGH, LIMIT_LOW, LIMIT_HIGH }; // STATES
+  enum { EVT_DISABLE, EVT_ENABLE, EVT_ENABLED_TIMEOUT, EVT_STOP, EVT_EMERGENCY_STOP, EVT_ON_LIMIT_LOW, EVT_ON_LIMIT_HIGH, EVT_ON_TARGET, ELSE }; // EVENTS
+  Atm_AccelStepper( void ) : Machine() {};
+  Atm_AccelStepper& begin( int step_pin, int dir_pin );
+  Atm_AccelStepper& trace( Stream & stream );
+  Atm_AccelStepper& trigger( int event );
+  int state( void );
+  Atm_AccelStepper& onChangeposition( Machine& machine, int event = 0 );
+  Atm_AccelStepper& onChangeposition( atm_cb_push_t callback, int idx = 0 );
+  Atm_AccelStepper& onChangestate( Machine& machine, int event = 0 );
+  Atm_AccelStepper& onChangestate( atm_cb_push_t callback, int idx = 0 );
+  Atm_AccelStepper& onOnlimithigh( Machine& machine, int event = 0 );
+  Atm_AccelStepper& onOnlimithigh( atm_cb_push_t callback, int idx = 0 );
+  Atm_AccelStepper& onOnlimitlow( Machine& machine, int event = 0 );
+  Atm_AccelStepper& onOnlimitlow( atm_cb_push_t callback, int idx = 0 );
+  Atm_AccelStepper& onOntarget( Machine& machine, int event = 0 );
+  Atm_AccelStepper& onOntarget( atm_cb_push_t callback, int idx = 0 );
+  Atm_AccelStepper& onStop( Machine& machine, int event = 0 );
+  Atm_AccelStepper& onStop( atm_cb_push_t callback, int idx = 0 );
+  Atm_AccelStepper& disable( void );
+  Atm_AccelStepper& enable( void );
+  Atm_AccelStepper& stop( void );
+  Atm_AccelStepper& emergency_stop( void );
+  Atm_AccelStepper& on_limit_low( void );
+  Atm_AccelStepper& on_limit_high( void );
+  Atm_AccelStepper& on_target( void );
+
+  Atm_AccelStepper& move( long int stepRel );
+  Atm_AccelStepper& moveTo( long int stepAbs );
+  Atm_AccelStepper& homing( bool direction );
+
+  AccelStepper *stepper;
+
+  Atm_AccelStepper& setEnablePin( int enablePin );
+  Atm_AccelStepper& enableReversed( bool reverse );
+  bool enabled ;
+
+
+  Atm_AccelStepper& limitLow_set(int mode = 0, int pin = -1, int reversed=0);
+  Atm_AccelStepper& limitLow_setThresholds (int threshold_low=510, int threshold_high = 1024);
+  Atm_AccelStepper& limitHigh_set(int mode = 0, int pin = -1, int reversed=0);
+  Atm_AccelStepper& limitHigh_setThresholds (int threshold_low=510, int threshold_high = 1024);
+  bool limitLow_State;
+  bool limitHigh_State;
+
+
+ private:
+  enum { ENT_DISABLED, ENT_ENABLED, LP_RUNNING, ENT_HOMING_LOW, EXT_HOMING_LOW, ENT_HOMING_HIGH, EXT_HOMING_HIGH, ENT_LIMIT_LOW, ENT_LIMIT_HIGH }; // ACTIONS
+  enum { ON_CHANGEPOSITION, ON_CHANGESTATE, ON_ONLIMITHIGH, ON_ONLIMITLOW, ON_ONTARGET, ON_STOP, CONN_MAX }; // CONNECTORS
+  atm_connector connectors[CONN_MAX];
+  int event( int id );
+  void action( int id );
+
+  long int _currentStep = 0;
+  long int _targetStep = 0;
+  long int _maxStep ;
+
+  int _enablePin = -1;
+  bool _enableReversed = 0 ;
+  atm_timer_millis idle_timer ;
+  int IDLE_TIMEOUT_DURATION = 500000 ;
+
+  int _limitLow_Pin;
+  int _limitLow_Mode; //0 no limit, 1 digital, 2 analog with thresholds
+  bool _limitLow_Reversed ; //invert logic of limit switches
+  int _limitLow_Thresholds[2] ; //analog value  range for two analog limits
+  int _limitHigh_Pin;
+  int _limitHigh_Mode; //0 no limit, 1 digital, 2 analog with thresholds
+  bool _limitHigh_Reversed ; //invert logic of limit switches
+  int _limitHigh_Thresholds[2] ; //analog value  range for two analog limits
+  void updateLimitSwitch();
+
+};
+
+/*
+Automaton::ATML::begin - Automaton Markup Language
+
+<?xml version="1.0" encoding="UTF-8"?>
+<machines>
+  <machine name="Atm_AccelStepper">
+    <states>
+      <DISABLED index="0" on_enter="ENT_DISABLED">
+        <EVT_ENABLE>ENABLED</EVT_ENABLE>
+      </DISABLED>
+      <ENABLED index="1" on_enter="ENT_ENABLED">
+        <EVT_DISABLE>DISABLED</EVT_DISABLE>
+        <EVT_ENABLED_TIMEOUT>DISABLED</EVT_ENABLED_TIMEOUT>
+        <EVT_STOP>STOP</EVT_STOP>
+        <EVT_EMERGENCY_STOP>STOP</EVT_EMERGENCY_STOP>
+      </ENABLED>
+      <RUNNING index="2" on_loop="LP_RUNNING">
+        <EVT_DISABLE>DISABLED</EVT_DISABLE>
+        <EVT_STOP>STOP</EVT_STOP>
+        <EVT_EMERGENCY_STOP>STOP</EVT_EMERGENCY_STOP>
+        <EVT_ON_LIMIT_LOW>LIMIT_LOW</EVT_ON_LIMIT_LOW>
+        <EVT_ON_LIMIT_HIGH>LIMIT_HIGH</EVT_ON_LIMIT_HIGH>
+        <EVT_ON_TARGET>ENABLED</EVT_ON_TARGET>
+      </RUNNING>
+      <STOP index="3">
+        <EVT_DISABLE>DISABLED</EVT_DISABLE>
+        <EVT_STOP>STOP</EVT_STOP>
+        <EVT_EMERGENCY_STOP>STOP</EVT_EMERGENCY_STOP>
+      </STOP>
+      <HOMING_LOW index="4" on_enter="ENT_HOMING_LOW" on_exit="EXT_HOMING_LOW">
+        <EVT_DISABLE>DISABLED</EVT_DISABLE>
+        <EVT_STOP>STOP</EVT_STOP>
+        <EVT_EMERGENCY_STOP>STOP</EVT_EMERGENCY_STOP>
+        <EVT_ON_LIMIT_LOW>ENABLED</EVT_ON_LIMIT_LOW>
+      </HOMING_LOW>
+      <HOMING_HIGH index="5" on_enter="ENT_HOMING_HIGH" on_exit="EXT_HOMING_HIGH">
+        <EVT_DISABLE>DISABLED</EVT_DISABLE>
+        <EVT_STOP>STOP</EVT_STOP>
+        <EVT_EMERGENCY_STOP>STOP</EVT_EMERGENCY_STOP>
+        <EVT_ON_LIMIT_HIGH>ENABLED</EVT_ON_LIMIT_HIGH>
+      </HOMING_HIGH>
+      <LIMIT_LOW index="6" on_enter="ENT_LIMIT_LOW">
+        <EVT_STOP>STOP</EVT_STOP>
+        <EVT_EMERGENCY_STOP>STOP</EVT_EMERGENCY_STOP>
+        <EVT_ON_LIMIT_LOW>LIMIT_LOW</EVT_ON_LIMIT_LOW>
+      </LIMIT_LOW>
+      <LIMIT_HIGH index="7" on_enter="ENT_LIMIT_HIGH">
+        <EVT_STOP>STOP</EVT_STOP>
+        <EVT_EMERGENCY_STOP>STOP</EVT_EMERGENCY_STOP>
+        <EVT_ON_LIMIT_HIGH>LIMIT_HIGH</EVT_ON_LIMIT_HIGH>
+      </LIMIT_HIGH>
+    </states>
+    <events>
+      <EVT_DISABLE index="0" access="MIXED"/>
+      <EVT_ENABLE index="1" access="MIXED"/>
+      <EVT_ENABLED_TIMEOUT index="2" access="PRIVATE"/>
+      <EVT_STOP index="3" access="MIXED"/>
+      <EVT_EMERGENCY_STOP index="4" access="MIXED"/>
+      <EVT_ON_LIMIT_LOW index="5" access="MIXED"/>
+      <EVT_ON_LIMIT_HIGH index="6" access="MIXED"/>
+      <EVT_ON_TARGET index="7" access="MIXED"/>
+    </events>
+    <connectors>
+      <CHANGEPOSITION autostore="0" broadcast="0" dir="PUSH" slots="1"/>
+      <CHANGESTATE autostore="0" broadcast="0" dir="PUSH" slots="1"/>
+      <ONLIMITHIGH autostore="0" broadcast="0" dir="PUSH" slots="1"/>
+      <ONLIMITLOW autostore="0" broadcast="0" dir="PUSH" slots="1"/>
+      <ONTARGET autostore="0" broadcast="0" dir="PUSH" slots="1"/>
+      <STOP autostore="0" broadcast="0" dir="PUSH" slots="1"/>
+    </connectors>
+    <methods>
+    </methods>
+  </machine>
+</machines>
+
+Automaton::ATML::end
+*/

examples/Atm_AccelStepper/Atm_AccelStepper.ino

@@ -0,0 +1,21 @@
+#include <Automaton.h>
+#include "Atm_AccelStepper.h"
+
+// Basic Arduino sketch - instantiates the state machine and nothing else
+
+Atm_AccelStepper AccelStepper;
+
+void setup() {
+
+  // Serial.begin( 9600 );
+  // AccelStepper.trace( Serial );
+
+  AccelStepper.begin();
+
+}
+
+void loop() {
+  automaton.run();
+}
+
+