version model 1.29 added state for inaktiv = LDR ...

.gitignore

@@ -1,5 +1,7 @@
 .pio
 .vscode
+.vscode/*
+.vscode/**
 compress
 data_gz
 platformio.ini

.vscode/extensions.json

@@ -1,7 +0,0 @@
-{
-    // See http://go.microsoft.com/fwlink/?LinkId=827846
-    // for the documentation about the extensions.json format
-    "recommendations": [
-        "platformio.platformio-ide"
-    ]
-}

.vscode/settings.json

@@ -1,53 +0,0 @@
-{
-    "files.associations": {
-        "random": "cpp",
-        "array": "cpp",
-        "*.tcc": "cpp",
-        "deque": "cpp",
-        "list": "cpp",
-        "string": "cpp",
-        "unordered_map": "cpp",
-        "vector": "cpp",
-        "string_view": "cpp",
-        "memory": "cpp",
-        "ranges": "cpp",
-        "initializer_list": "cpp",
-        "utility": "cpp",
-        "atomic": "cpp",
-        "bit": "cpp",
-        "cctype": "cpp",
-        "clocale": "cpp",
-        "cmath": "cpp",
-        "compare": "cpp",
-        "concepts": "cpp",
-        "cstdarg": "cpp",
-        "cstddef": "cpp",
-        "cstdint": "cpp",
-        "cstdio": "cpp",
-        "cstdlib": "cpp",
-        "cstring": "cpp",
-        "cwchar": "cpp",
-        "cwctype": "cpp",
-        "map": "cpp",
-        "set": "cpp",
-        "exception": "cpp",
-        "algorithm": "cpp",
-        "functional": "cpp",
-        "iterator": "cpp",
-        "memory_resource": "cpp",
-        "numeric": "cpp",
-        "optional": "cpp",
-        "system_error": "cpp",
-        "tuple": "cpp",
-        "type_traits": "cpp",
-        "iosfwd": "cpp",
-        "limits": "cpp",
-        "new": "cpp",
-        "ostream": "cpp",
-        "stdexcept": "cpp",
-        "streambuf": "cpp",
-        "cinttypes": "cpp",
-        "typeinfo": "cpp"
-    },
-    "python.pythonPath": "C:\\Users\\simon\\AppData\\Local\\Programs\\Python\\Python37\\python.exe"
-}

data/style.css

@@ -67,8 +67,6 @@ input[type=range]::-webkit-slider-thumb{
 }
 
 
-
-
 /*-------------------------------------------------------*/
 
 

lib/README

@@ -1,46 +0,0 @@
-
-This directory is intended for project specific (private) libraries.
-PlatformIO will compile them to static libraries and link into executable file.
-
-The source code of each library should be placed in a an own separate directory
-("lib/your_library_name/[here are source files]").
-
-For example, see a structure of the following two libraries `Foo` and `Bar`:
-
-|--lib
-|  |
-|  |--Bar
-|  |  |--docs
-|  |  |--examples
-|  |  |--src
-|  |     |- Bar.c
-|  |     |- Bar.h
-|  |  |- library.json (optional, custom build options, etc) https://docs.platformio.org/page/librarymanager/config.html
-|  |
-|  |--Foo
-|  |  |- Foo.c
-|  |  |- Foo.h
-|  |
-|  |- README --> THIS FILE
-|
-|- platformio.ini
-|--src
-   |- main.c
-
-and a contents of `src/main.c`:
-```
-#include <Foo.h>
-#include <Bar.h>
-
-int main (void)
-{
-  ...
-}
-
-```
-
-PlatformIO Library Dependency Finder will find automatically dependent
-libraries scanning project source files.
-
-More information about PlatformIO Library Dependency Finder
-- https://docs.platformio.org/page/librarymanager/ldf.html

lib/httpserver/httpserver.h

@@ -2,8 +2,6 @@
 
 #pragma once
 
-#include <vector>
-
 #include <ESP8266WebServer.h>
 #include <stdarg.h>
 #include "filesys.h"
@@ -27,7 +25,6 @@ private:
         ls(rootDir);
     }
 
-
 public:
     HTTPServer(const int _port, const char* _rootDir) :
        ESP8266WebServer(_port), rootDir(_rootDir)

lib/treppe/FSMTreppe2/FSMTreppe2.cpp

@@ -0,0 +1,237 @@
+//
+// Academic License - for use in teaching, academic research, and meeting
+// course requirements at degree granting institutions only.  Not for
+// government, commercial, or other organizational use.
+//
+// File: FSMTreppe.cpp
+//
+// Code generated for Simulink model 'FSMTreppe'.
+//
+// Model version                  : 1.29
+// Simulink Coder version         : 9.5 (R2021a) 14-Nov-2020
+// C/C++ source code generated on : Sat Jul  3 17:39:25 2021
+//
+// Target selection: ert.tlc
+// Embedded hardware selection: ARM Compatible->ARM Cortex-M
+// Code generation objectives: Unspecified
+// Validation result: Not run
+//
+#include "FSMTreppe2.h"
+#include <stdint.h>
+
+// Named constants for Chart: '<Root>/FSMTreppe'
+const uint8_t FSMTreppe_IN_abdimmen_hoch = 1U;
+const uint8_t FSMTreppe_IN_abdimmen_runter = 2U;
+const uint8_t FSMTreppe_IN_aufdimmen_hoch = 3U;
+const uint8_t FSMTreppe_IN_aufdimmen_runter = 4U;
+const uint8_t FSMTreppe_IN_inaktiv = 5U;
+const uint8_t FSMTreppe_IN_ruhezustand = 6U;
+const uint8_t FSMTreppe_IN_warten_hoch = 7U;
+const uint8_t FSMTreppe_IN_warten_runter = 8U;
+
+// Model step function
+void FSMTreppeModelClass::step()
+{
+  // Chart: '<Root>/FSMTreppe' incorporates:
+  //   Inport: '<Root>/anim_beendet'
+  //   Inport: '<Root>/ldr_schwelle'
+  //   Inport: '<Root>/sensor_oben'
+  //   Inport: '<Root>/sensor_unten'
+
+  if (FSMTreppe_DW.temporalCounter_i1 < 511U) {
+    FSMTreppe_DW.temporalCounter_i1 = static_cast<uint16_t>
+      (FSMTreppe_DW.temporalCounter_i1 + 1U);
+  }
+
+  if (FSMTreppe_DW.is_active_c3_FSMTreppe == 0U) {
+    FSMTreppe_DW.is_active_c3_FSMTreppe = 1U;
+    FSMTreppe_DW.is_c3_FSMTreppe = FSMTreppe_IN_inaktiv;
+
+    // Outport: '<Root>/status'
+    FSMTreppe_Y.status = 0U;
+  } else {
+    switch (FSMTreppe_DW.is_c3_FSMTreppe) {
+     case FSMTreppe_IN_abdimmen_hoch:
+      // Outport: '<Root>/dimmrichtung'
+      FSMTreppe_Y.dimmrichtung = 0U;
+
+      // Outport: '<Root>/status'
+      FSMTreppe_Y.status = 4U;
+      if (FSMTreppe_U.anim_beendet || (FSMTreppe_DW.temporalCounter_i1 >= 500U))
+      {
+        FSMTreppe_DW.is_c3_FSMTreppe = FSMTreppe_IN_ruhezustand;
+
+        // Outport: '<Root>/status'
+        FSMTreppe_Y.status = 1U;
+      }
+      break;
+
+     case FSMTreppe_IN_abdimmen_runter:
+      // Outport: '<Root>/dimmrichtung'
+      FSMTreppe_Y.dimmrichtung = 0U;
+
+      // Outport: '<Root>/status'
+      FSMTreppe_Y.status = 7U;
+      if (FSMTreppe_U.anim_beendet || (FSMTreppe_DW.temporalCounter_i1 >= 500U))
+      {
+        FSMTreppe_DW.is_c3_FSMTreppe = FSMTreppe_IN_ruhezustand;
+
+        // Outport: '<Root>/status'
+        FSMTreppe_Y.status = 1U;
+      }
+      break;
+
+     case FSMTreppe_IN_aufdimmen_hoch:
+      // Outport: '<Root>/laufrichtung'
+      FSMTreppe_Y.laufrichtung = 1U;
+
+      // Outport: '<Root>/dimmrichtung'
+      FSMTreppe_Y.dimmrichtung = 1U;
+
+      // Outport: '<Root>/status'
+      FSMTreppe_Y.status = 2U;
+      if (FSMTreppe_U.anim_beendet || (FSMTreppe_DW.temporalCounter_i1 >= 500U))
+      {
+        FSMTreppe_DW.is_c3_FSMTreppe = FSMTreppe_IN_warten_hoch;
+        FSMTreppe_DW.temporalCounter_i1 = 0U;
+
+        // Outport: '<Root>/status'
+        FSMTreppe_Y.status = 3U;
+      }
+      break;
+
+     case FSMTreppe_IN_aufdimmen_runter:
+      // Outport: '<Root>/laufrichtung'
+      FSMTreppe_Y.laufrichtung = 0U;
+
+      // Outport: '<Root>/dimmrichtung'
+      FSMTreppe_Y.dimmrichtung = 1U;
+
+      // Outport: '<Root>/status'
+      FSMTreppe_Y.status = 5U;
+      if (FSMTreppe_U.anim_beendet || (FSMTreppe_DW.temporalCounter_i1 >= 500U))
+      {
+        FSMTreppe_DW.is_c3_FSMTreppe = FSMTreppe_IN_warten_runter;
+        FSMTreppe_DW.temporalCounter_i1 = 0U;
+
+        // Outport: '<Root>/status'
+        FSMTreppe_Y.status = 6U;
+      }
+      break;
+
+     case FSMTreppe_IN_inaktiv:
+      // Outport: '<Root>/status'
+      FSMTreppe_Y.status = 0U;
+      if (FSMTreppe_U.ldr_schwelle == 1.0) {
+        FSMTreppe_DW.is_c3_FSMTreppe = FSMTreppe_IN_ruhezustand;
+
+        // Outport: '<Root>/status'
+        FSMTreppe_Y.status = 1U;
+      }
+      break;
+
+     case FSMTreppe_IN_ruhezustand:
+      // Outport: '<Root>/status'
+      FSMTreppe_Y.status = 1U;
+      if (FSMTreppe_U.sensor_unten) {
+        FSMTreppe_DW.is_c3_FSMTreppe = FSMTreppe_IN_aufdimmen_hoch;
+        FSMTreppe_DW.temporalCounter_i1 = 0U;
+
+        // Outport: '<Root>/laufrichtung'
+        FSMTreppe_Y.laufrichtung = 1U;
+
+        // Outport: '<Root>/dimmrichtung'
+        FSMTreppe_Y.dimmrichtung = 1U;
+
+        // Outport: '<Root>/status'
+        FSMTreppe_Y.status = 2U;
+      } else if (FSMTreppe_U.sensor_oben) {
+        FSMTreppe_DW.is_c3_FSMTreppe = FSMTreppe_IN_aufdimmen_runter;
+        FSMTreppe_DW.temporalCounter_i1 = 0U;
+
+        // Outport: '<Root>/laufrichtung'
+        FSMTreppe_Y.laufrichtung = 0U;
+
+        // Outport: '<Root>/dimmrichtung'
+        FSMTreppe_Y.dimmrichtung = 1U;
+
+        // Outport: '<Root>/status'
+        FSMTreppe_Y.status = 5U;
+      } else if (FSMTreppe_U.ldr_schwelle == 0.0) {
+        FSMTreppe_DW.is_c3_FSMTreppe = FSMTreppe_IN_inaktiv;
+
+        // Outport: '<Root>/status'
+        FSMTreppe_Y.status = 0U;
+      }
+      break;
+
+     case FSMTreppe_IN_warten_hoch:
+      // Outport: '<Root>/status'
+      FSMTreppe_Y.status = 3U;
+      if (FSMTreppe_U.sensor_oben || (FSMTreppe_DW.temporalCounter_i1 >= 500U))
+      {
+        FSMTreppe_DW.is_c3_FSMTreppe = FSMTreppe_IN_abdimmen_hoch;
+        FSMTreppe_DW.temporalCounter_i1 = 0U;
+
+        // Outport: '<Root>/dimmrichtung'
+        FSMTreppe_Y.dimmrichtung = 0U;
+
+        // Outport: '<Root>/status'
+        FSMTreppe_Y.status = 4U;
+      }
+      break;
+
+     default:
+      // Outport: '<Root>/status'
+      // case IN_warten_runter:
+      FSMTreppe_Y.status = 6U;
+      if (FSMTreppe_U.sensor_unten || (FSMTreppe_DW.temporalCounter_i1 >= 500U))
+      {
+        FSMTreppe_DW.is_c3_FSMTreppe = FSMTreppe_IN_abdimmen_runter;
+        FSMTreppe_DW.temporalCounter_i1 = 0U;
+
+        // Outport: '<Root>/dimmrichtung'
+        FSMTreppe_Y.dimmrichtung = 0U;
+
+        // Outport: '<Root>/status'
+        FSMTreppe_Y.status = 7U;
+      }
+      break;
+    }
+  }
+
+  // End of Chart: '<Root>/FSMTreppe'
+}
+
+// Model initialize function
+void FSMTreppeModelClass::initialize()
+{
+  // (no initialization code required)
+}
+
+// Model terminate function
+void FSMTreppeModelClass::terminate()
+{
+  // (no terminate code required)
+}
+
+// Constructor
+FSMTreppeModelClass::FSMTreppeModelClass() :
+  FSMTreppe_DW(),
+  FSMTreppe_U(),
+  FSMTreppe_Y()
+{
+  // Currently there is no constructor body generated.
+}
+
+// Destructor
+FSMTreppeModelClass::~FSMTreppeModelClass()
+{
+  // Currently there is no destructor body generated.
+}
+
+//
+// File trailer for generated code.
+//
+// [EOF]
+//

lib/treppe/FSMTreppe2/FSMTreppe2.h

@@ -0,0 +1,119 @@
+//
+// Academic License - for use in teaching, academic research, and meeting
+// course requirements at degree granting institutions only.  Not for
+// government, commercial, or other organizational use.
+//
+// File: FSMTreppe.h
+//
+// Code generated for Simulink model 'FSMTreppe'.
+//
+// Model version                  : 1.28
+// Simulink Coder version         : 9.5 (R2021a) 14-Nov-2020
+// C/C++ source code generated on : Sat Jul  3 13:50:17 2021
+//
+// Target selection: ert.tlc
+// Embedded hardware selection: ARM Compatible->ARM Cortex-M
+// Code generation objectives: Unspecified
+// Validation result: Not run
+//
+#ifndef RTW_HEADER_FSMTreppe_h_
+#define RTW_HEADER_FSMTreppe_h_
+
+#include <stdint.h>
+
+// Class declaration for model FSMTreppe
+class FSMTreppeModelClass {
+  // public data and function members
+ public:
+  // Block states (default storage) for system '<Root>'
+  struct DW_FSMTreppe_T {
+    uint16_t temporalCounter_i1;       // '<Root>/FSMTreppe'
+    uint8_t is_active_c3_FSMTreppe;    // '<Root>/FSMTreppe'
+    uint8_t is_c3_FSMTreppe;           // '<Root>/FSMTreppe'
+  };
+
+  // External inputs (root inport signals with default storage)
+  struct ExtU_FSMTreppe_T {
+    bool sensor_unten;            // '<Root>/sensor_unten'
+    bool sensor_oben;             // '<Root>/sensor_oben'
+    bool anim_beendet;            // '<Root>/anim_beendet'
+    double ldr_schwelle;               // '<Root>/ldr_schwelle'
+  };
+
+  // External outputs (root outports fed by signals with default storage)
+  struct ExtY_FSMTreppe_T {
+    uint8_t laufrichtung;              // '<Root>/laufrichtung'
+    uint8_t status;                    // '<Root>/status'
+    uint8_t dimmrichtung;              // '<Root>/dimmrichtung'
+  };
+
+  // model initialize function
+  void initialize();
+
+  // model step function
+  void step();
+
+  // model terminate function
+  void terminate();
+
+  // Constructor
+  FSMTreppeModelClass();
+
+  // Destructor
+  ~FSMTreppeModelClass();
+
+  // Root-level structure-based inputs set method
+
+  // Root inports set method
+  void setExternalInputs(const ExtU_FSMTreppe_T* pExtU_FSMTreppe_T)
+  {
+    FSMTreppe_U = *pExtU_FSMTreppe_T;
+  }
+
+  // Root-level structure-based outputs get method
+
+  // Root outports get method
+  const FSMTreppeModelClass::ExtY_FSMTreppe_T & getExternalOutputs() const
+  {
+    return FSMTreppe_Y;
+  }
+
+  // private data and function members
+ private:
+  // Block states
+  DW_FSMTreppe_T FSMTreppe_DW;
+
+  // External inputs
+  ExtU_FSMTreppe_T FSMTreppe_U;
+
+  // External outputs
+  ExtY_FSMTreppe_T FSMTreppe_Y;
+};
+
+//-
+//  The generated code includes comments that allow you to trace directly
+//  back to the appropriate location in the model.  The basic format
+//  is <system>/block_name, where system is the system number (uniquely
+//  assigned by Simulink) and block_name is the name of the block.
+//
+//  Note that this particular code originates from a subsystem build,
+//  and has its own system numbers different from the parent model.
+//  Refer to the system hierarchy for this subsystem below, and use the
+//  MATLAB hilite_system command to trace the generated code back
+//  to the parent model.  For example,
+//
+//  hilite_system('FSM_Treppenlicht/FSMTreppe')    - opens subsystem FSM_Treppenlicht/FSMTreppe
+//  hilite_system('FSM_Treppenlicht/FSMTreppe/Kp') - opens and selects block Kp
+//
+//  Here is the system hierarchy for this model
+//
+//  '<Root>' : 'FSM_Treppenlicht'
+//  '<S1>'   : 'FSM_Treppenlicht/FSMTreppe'
+
+#endif                                 // RTW_HEADER_FSMTreppe_h_
+
+//
+// File trailer for generated code.
+//
+// [EOF]
+//

lib/treppe/treppe.cpp

@@ -86,7 +86,7 @@ void Treppe::rampe()
 {
   if(state) {
     finish = 0;
-    state = 0;                    // set parameter memory
+    state = 0;// set parameter memory
   }
 
   if(!finish) {
@@ -132,10 +132,8 @@ void Treppe::rampe()
 }
 
 void Treppe::setup(){
-    Serial.printf("differenz_pwm_pro_tick %f\n", differenz_pwm_pro_tick);
 
     pwmController.resetDevices();
-    
     // Deactive PCA9685 Phase Balancer due to LED Flickering
     // https://github.com/NachtRaveVL/PCA9685-Arduino/issues/15
     // see also lib/PCA9685-Arduin/PCA9685.h:204
@@ -145,60 +143,67 @@ void Treppe::setup(){
     pwmController.setAllChannelsPWM(idle_brightness);
     
     pinMode(A0, INPUT);
-    pinMode(SENSOR1, INPUT);
+    pinMode(SENSOR_OBEN, INPUT);
-    pinMode(SENSOR2, INPUT);
+    pinMode(SENSOR_UNTEN, INPUT);
     pinMode(OE, OUTPUT);
     digitalWrite(OE, 0);
+
+    Serial.printf("differenz_pwm_pro_tick %f\n", differenz_pwm_pro_tick);
     Serial.println("Hello from Treppe");
     Serial.print("Treppe: initial parameters: stairs=");
     Serial.println(stairs);
 }
 
+void Treppe::print_state_on_change() {
+  static FSMTreppeModelClass::ExtU_FSMTreppe_T last_in;
+  static FSMTreppeModelClass::ExtY_FSMTreppe_T last_out;
+  if(
+    fsm_inputs.anim_beendet != last_in.anim_beendet || 
+    fsm_inputs.sensor_oben != last_in.sensor_oben || 
+    fsm_inputs.sensor_unten != last_in.sensor_unten ||
+    fsm_outputs.dimmrichtung != last_out.dimmrichtung || 
+    fsm_outputs.laufrichtung != last_out.laufrichtung || 
+    fsm_outputs.status != last_out.status
+  ) {
+    last_in.anim_beendet = fsm_inputs.anim_beendet;
+    last_in.sensor_oben  = fsm_inputs.sensor_oben;
+    last_in.sensor_unten = fsm_inputs.sensor_unten;
+
+    Serial.printf("FSM IN: s_u: %d, s_o: %d, beendet: %d =>", 
+      fsm_inputs.sensor_oben, fsm_inputs.sensor_unten, fsm_inputs.anim_beendet);
+    Serial.print(" step => ");
+    Serial.printf("OUT: LR: %d DR: %d ST: %d\n", 
+      fsm_outputs.laufrichtung, fsm_outputs.dimmrichtung, fsm_outputs.status);
+  }
+}
+
 void Treppe::task(){
+  //Serial.printf("LDR: %f\n", ((float)analogRead(A0))/1023.*3.68);
 
   if(finish){
     direction = switch_direction;
     state = switch_state;
   }
-  static uint8_t last_sensor_state[2] = {0,0}; 
-  uint8_t current_sensor_state[2] = {0,0};
-  current_sensor_state[0] = digitalRead(SENSOR1);
-  current_sensor_state[1] = digitalRead(SENSOR2);
 
-  if(current_sensor_state[0] && !last_sensor_state[0] && state == 0){
+  fsm_inputs.ldr_schwelle = true;
-    setTick(0);
+  fsm_inputs.sensor_oben =  read_sensor(SENSOR_OBEN);
-    setAnAus(1);
+  fsm_inputs.sensor_unten = read_sensor(SENSOR_UNTEN);
-    setDirection(1);
+  fsm_inputs.anim_beendet = static_cast<bool>(finish);
-    setState(1);
-  }
 
-  if(current_sensor_state[1] && !last_sensor_state[1] && state == 0){
+  FSMTreppe_Obj.setExternalInputs(&fsm_inputs);
-    setTick(0);
+  FSMTreppe_Obj.step();
-    setAnAus(0);
+  fsm_outputs = FSMTreppe_Obj.getExternalOutputs();
-    setDirection(0);
+  print_state_on_change();
-    setState(1);
-  }
 
-  // first switch - off approach, use timer later
+  direction = fsm_outputs.laufrichtung;
-  if(!current_sensor_state[0] && last_sensor_state[0] && state == 1){
+  state = fsm_outputs.dimmrichtung;
-    setTick(ticks_treppe);
-    setAnAus(1);
-    setDirection(1);
-    setState(0);
-  }
 
-  if(!current_sensor_state[1] && last_sensor_state[1] && state == 1){
+  // setTick(ticks_treppe);
-    setTick(ticks_treppe);
+  // setAnAus(1);
-    setAnAus(1);
+  // setDirection(0);
-    setDirection(0);
+  // setState(0);
-    setState(0);
-  }
-
-  last_sensor_state[0] = current_sensor_state[0];
-  last_sensor_state[1] = current_sensor_state[1];
   
   ledsequence();
-
 }
 
 

lib/treppe/treppe.h

@@ -1,25 +1,27 @@
 #pragma once
 
+#include "FSMTreppe/FSMTreppe2.h"
 #include "PCA9685.h"
 
-#define SENSOR1 2
+#define SENSOR_OBEN 2
-#define SENSOR2 12
+#define SENSOR_UNTEN 12
 #define OE 14
 
 #define INT_TIME 20  // interrupt intervall [ms]
 
 class Treppe {
 private:
+
     uint8_t stairs;
     uint16_t time_per_stair = 300;          // dimmtime per stair [ms]
     uint16_t idle_brightness = 100;
-    uint16_t active_brightness = 2048;
+    uint16_t active_brightness = 300;
 
     uint8_t direction = 0;
     uint8_t switch_direction = 0;
     uint8_t state = 0;
     uint8_t switch_state = 0;
-    uint8_t finish = 1;
+    bool finish = 1;
 
     // alternative
     uint32_t tick = 0;
@@ -31,21 +33,40 @@ private:
     float differenz_pwm_pro_tick = 0.0;
     // alternative
 
-
     // initialize with i2c-Address 0, use Wire Library
     PCA9685 pwmController;     
+    FSMTreppeModelClass FSMTreppe_Obj;
+    FSMTreppeModelClass::ExtU_FSMTreppe_T fsm_inputs;
+    FSMTreppeModelClass::ExtY_FSMTreppe_T fsm_outputs;
+    void print_state_on_change();
+
+    const uint8_t FSMTreppe_IN_animation_down = 1U;
+    const uint8_t FSMTreppe_IN_animation_up = 2U;
+    const uint8_t FSMTreppe_IN_idle = 3U;
+
+
     uint8_t softstart_led(uint8_t led, uint16_t startval, uint16_t stopval);
     void ledsequence();
     void rampe();
-
+    bool read_sensor(int sensor) {
+        int pegel = digitalRead(sensor);
+        return static_cast<bool>(pegel);
+    }
 public:
     Treppe(uint8_t _stairs) : stairs(_stairs){
+        FSMTreppe_Obj.initialize();
+
+
+
         ticks_pro_stufe = time_per_stair / 20; // [ms]
         ticks_treppe = ticks_pro_stufe * stairs;
 
         differenz_pwm_pro_tick = (float) (active_brightness - idle_brightness) 
                                             / (float) ticks_pro_stufe;
     }
+    ~Treppe() {
+        FSMTreppe_Obj.terminate();
+    }
 
     void setup();
     void task();        // call periodically

src/main.cpp

@@ -42,14 +42,17 @@ void timerCallback(void *pArg)
 }
 
 // ===============================================
-
+uint8_t inter = 0;
+ICACHE_RAM_ATTR void int_test(){
+  inter = 1;
+}
 
 void setup() {
 #ifdef WITH_DEBUGGING_ON
   Serial.begin(460800);
   gdbstub_init();
 #else
-  Serial.begin(115200);
+  Serial.begin(76800);
 #endif
 
   Serial.println(F("Booting ...."));
@@ -84,6 +87,8 @@ void setup() {
 
   stairs.setup();
   Serial.println("PCA9685 connected !");
+  //attachInterrupt(digitalPinToInterrupt(2), int_test, RISING);
+  //attachInterrupt(digitalPinToInterrupt(12), int_test, RISING);
 
   os_timer_setfn(&timer1, timerCallback, &timer_flag);
   os_timer_arm(&timer1, 20, true);
@@ -106,6 +111,10 @@ void loop() {
   //   stairs.setDirection(!stairs.getDirection());
   //   stairs.setState(1);
   // }
+  if(inter){
+    Serial.printf("interrupt\n");
+    inter = 0;
+  }
   if(c++%1000000 == 0)
     httpServer.logt("[%d] starting :)\n", c);