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

lib/treppe/FSMTreppe/FSMTreppe.cpp

@@ -1,178 +0,0 @@
-//
-// 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.22
-// Simulink Coder version         : 9.5 (R2021a) 14-Nov-2020
-// C/C++ source code generated on : Fri Jul  2 17:45:36 2021
-//
-// Target selection: ert.tlc
-// Embedded hardware selection: ARM Compatible->ARM Cortex-M
-// Code generation objectives: Unspecified
-// Validation result: Not run
-//
-#include "FSMTreppe.h"
-#include "FSMTreppe_private.h"
-
-// Named constants for Chart: '<Root>/FSMTreppe'
-const uint8_T FSMTreppe_IN_animation_down = 1U;
-const uint8_T FSMTreppe_IN_animation_up = 2U;
-const uint8_T FSMTreppe_IN_idle = 3U;
-
-// Model step function
-void FSMTreppeModelClass::step()
-{
-  // Chart: '<Root>/FSMTreppe' incorporates:
-  //   Inport: '<Root>/anim_finished'
-  //   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_idle;
-
-    // Outport: '<Root>/anim_active'
-    FSMTreppe_Y.anim_active = 0U;
-    FSMTreppe_DW.got_sensor = 0U;
-    FSMTreppe_DW.got_anim_finished = 0U;
-    FSMTreppe_DW.finished_up = 0U;
-    FSMTreppe_DW.finished_dn = 0U;
-  } else {
-    switch (FSMTreppe_DW.is_c3_FSMTreppe) {
-     case FSMTreppe_IN_animation_down:
-      // Outport: '<Root>/anim_active'
-      FSMTreppe_Y.anim_active = 2U;
-      if ((FSMTreppe_DW.finished_dn == 1) || (FSMTreppe_DW.temporalCounter_i1 >=
-           300U)) {
-        FSMTreppe_DW.is_c3_FSMTreppe = FSMTreppe_IN_idle;
-
-        // Outport: '<Root>/anim_active'
-        FSMTreppe_Y.anim_active = 0U;
-        FSMTreppe_DW.got_sensor = 0U;
-        FSMTreppe_DW.got_anim_finished = 0U;
-        FSMTreppe_DW.finished_up = 0U;
-        FSMTreppe_DW.finished_dn = 0U;
-      } else {
-        if (FSMTreppe_U.sensor_unten) {
-          FSMTreppe_DW.got_sensor = 1U;
-        }
-
-        if (FSMTreppe_U.anim_finished) {
-          FSMTreppe_DW.got_anim_finished = 1U;
-        }
-
-        if ((FSMTreppe_DW.got_anim_finished == 1) && (FSMTreppe_DW.got_sensor ==
-             1)) {
-          FSMTreppe_DW.finished_dn = 1U;
-        }
-      }
-      break;
-
-     case FSMTreppe_IN_animation_up:
-      // Outport: '<Root>/anim_active'
-      FSMTreppe_Y.anim_active = 1U;
-      if ((FSMTreppe_DW.finished_up == 1) || (FSMTreppe_DW.temporalCounter_i1 >=
-           300U)) {
-        FSMTreppe_DW.is_c3_FSMTreppe = FSMTreppe_IN_idle;
-
-        // Outport: '<Root>/anim_active'
-        FSMTreppe_Y.anim_active = 0U;
-        FSMTreppe_DW.got_sensor = 0U;
-        FSMTreppe_DW.got_anim_finished = 0U;
-        FSMTreppe_DW.finished_up = 0U;
-        FSMTreppe_DW.finished_dn = 0U;
-      } else {
-        if (FSMTreppe_U.sensor_oben) {
-          FSMTreppe_DW.got_sensor = 1U;
-        }
-
-        if (FSMTreppe_U.anim_finished) {
-          FSMTreppe_DW.got_anim_finished = 1U;
-        }
-
-        if ((FSMTreppe_DW.got_anim_finished == 1) && (FSMTreppe_DW.got_sensor ==
-             1)) {
-          FSMTreppe_DW.finished_up = 1U;
-        }
-      }
-      break;
-
-     default:
-      // Outport: '<Root>/anim_active'
-      // case IN_idle:
-      FSMTreppe_Y.anim_active = 0U;
-      if (FSMTreppe_U.sensor_oben) {
-        FSMTreppe_DW.is_c3_FSMTreppe = FSMTreppe_IN_animation_down;
-        FSMTreppe_DW.temporalCounter_i1 = 0U;
-
-        // Outport: '<Root>/anim_active'
-        FSMTreppe_Y.anim_active = 2U;
-        FSMTreppe_DW.got_sensor = 0U;
-        FSMTreppe_DW.got_anim_finished = 0U;
-        FSMTreppe_DW.finished_dn = 0U;
-      } else if (FSMTreppe_U.sensor_unten) {
-        FSMTreppe_DW.is_c3_FSMTreppe = FSMTreppe_IN_animation_up;
-        FSMTreppe_DW.temporalCounter_i1 = 0U;
-
-        // Outport: '<Root>/anim_active'
-        FSMTreppe_Y.anim_active = 1U;
-        FSMTreppe_DW.got_sensor = 0U;
-        FSMTreppe_DW.got_anim_finished = 0U;
-        FSMTreppe_DW.finished_up = 0U;
-      }
-      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(),
-  FSMTreppe_M()
-{
-  // Currently there is no constructor body generated.
-}
-
-// Destructor
-FSMTreppeModelClass::~FSMTreppeModelClass()
-{
-  // Currently there is no destructor body generated.
-}
-
-// Real-Time Model get method
-FSMTreppeModelClass::RT_MODEL_FSMTreppe_T * FSMTreppeModelClass::getRTM()
-{
-  return (&FSMTreppe_M);
-}
-
-//
-// File trailer for generated code.
-//
-// [EOF]
-//

lib/treppe/FSMTreppe/FSMTreppe_private.h

@@ -1,28 +0,0 @@
-//
-// 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_private.h
-//
-// Code generated for Simulink model 'FSMTreppe'.
-//
-// Model version                  : 1.22
-// Simulink Coder version         : 9.5 (R2021a) 14-Nov-2020
-// C/C++ source code generated on : Fri Jul  2 17:45:36 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_private_h_
-#define RTW_HEADER_FSMTreppe_private_h_
-#include "rtwtypes.h"
-#endif                                 // RTW_HEADER_FSMTreppe_private_h_
-
-//
-// File trailer for generated code.
-//
-// [EOF]
-//

lib/treppe/FSMTreppe/ert_main.cpp

@@ -1,109 +0,0 @@
-//
-// 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: ert_main.cpp
-//
-// Code generated for Simulink model 'FSMTreppe'.
-//
-// Model version                  : 1.22
-// Simulink Coder version         : 9.5 (R2021a) 14-Nov-2020
-// C/C++ source code generated on : Fri Jul  2 17:45:36 2021
-//
-// Target selection: ert.tlc
-// Embedded hardware selection: ARM Compatible->ARM Cortex-M
-// Code generation objectives: Unspecified
-// Validation result: Not run
-//
-#include <stddef.h>
-#include <stdio.h>                // This ert_main.c example uses printf/fflush
-#include "FSMTreppe.h"                 // Model's header file
-#include "rtwtypes.h"
-
-static FSMTreppeModelClass FSMTreppe_Obj;// Instance of model class
-
-//
-// Associating rt_OneStep with a real-time clock or interrupt service routine
-// is what makes the generated code "real-time".  The function rt_OneStep is
-// always associated with the base rate of the model.  Subrates are managed
-// by the base rate from inside the generated code.  Enabling/disabling
-// interrupts and floating point context switches are target specific.  This
-// example code indicates where these should take place relative to executing
-// the generated code step function.  Overrun behavior should be tailored to
-// your application needs.  This example simply sets an error status in the
-// real-time model and returns from rt_OneStep.
-//
-void rt_OneStep(void);
-void rt_OneStep(void)
-{
-  static boolean_T OverrunFlag = false;
-
-  // Disable interrupts here
-
-  // Check for overrun
-  if (OverrunFlag) {
-    rtmSetErrorStatus(FSMTreppe_Obj.getRTM(), "Overrun");
-    return;
-  }
-
-  OverrunFlag = true;
-
-  // Save FPU context here (if necessary)
-  // Re-enable timer or interrupt here
-  // Set model inputs here
-
-  // Step the model
-  FSMTreppe_Obj.step();
-
-  // Get model outputs here
-
-  // Indicate task complete
-  OverrunFlag = false;
-
-  // Disable interrupts here
-  // Restore FPU context here (if necessary)
-  // Enable interrupts here
-}
-
-//
-// The example "main" function illustrates what is required by your
-// application code to initialize, execute, and terminate the generated code.
-// Attaching rt_OneStep to a real-time clock is target specific.  This example
-// illustrates how you do this relative to initializing the model.
-//
-int_T main(int_T argc, const char *argv[])
-{
-  // Unused arguments
-  (void)(argc);
-  (void)(argv);
-
-  // Initialize model
-  FSMTreppe_Obj.initialize();
-
-  // Attach rt_OneStep to a timer or interrupt service routine with
-  //  period 0.01 seconds (the model's base sample time) here.  The
-  //  call syntax for rt_OneStep is
-  //
-  //   rt_OneStep();
-
-  printf("Warning: The simulation will run forever. "
-         "Generated ERT main won't simulate model step behavior. "
-         "To change this behavior select the 'MAT-file logging' option.\n");
-  fflush((NULL));
-  while (rtmGetErrorStatus(FSMTreppe_Obj.getRTM()) == (NULL)) {
-    //  Perform other application tasks here
-  }
-
-  // Disable rt_OneStep() here
-
-  // Terminate model
-  FSMTreppe_Obj.terminate();
-  return 0;
-}
-
-//
-// File trailer for generated code.
-//
-// [EOF]
-//

lib/treppe/FSMTreppe/rtwtypes.h

@@ -1,160 +0,0 @@
-//
-// 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: rtwtypes.h
-//
-// Code generated for Simulink model 'FSMTreppe'.
-//
-// Model version                  : 1.22
-// Simulink Coder version         : 9.5 (R2021a) 14-Nov-2020
-// C/C++ source code generated on : Fri Jul  2 17:45:36 2021
-//
-// Target selection: ert.tlc
-// Embedded hardware selection: ARM Compatible->ARM Cortex-M
-// Code generation objectives: Unspecified
-// Validation result: Not run
-//
-
-#ifndef RTWTYPES_H
-#define RTWTYPES_H
-
-// Logical type definitions
-#if (!defined(__cplusplus))
-#ifndef false
-#define false                          (0U)
-#endif
-
-#ifndef true
-#define true                           (1U)
-#endif
-#endif
-
-//=======================================================================*
-//  Target hardware information
-//    Device type: ARM Compatible->ARM Cortex-M
-//    Number of bits:     char:   8    short:   16    int:  32
-//                        long:  32
-//                        native word size:  32
-//    Byte ordering: LittleEndian
-//    Signed integer division rounds to: Zero
-//    Shift right on a signed integer as arithmetic shift: on
-// =======================================================================
-
-//=======================================================================*
-//  Fixed width word size data types:                                     *
-//    int8_T, int16_T, int32_T     - signed 8, 16, or 32 bit integers     *
-//    uint8_T, uint16_T, uint32_T  - unsigned 8, 16, or 32 bit integers   *
-//    real32_T, real64_T           - 32 and 64 bit floating point numbers *
-// =======================================================================
-typedef signed char int8_T;
-typedef unsigned char uint8_T;
-typedef short int16_T;
-typedef unsigned short uint16_T;
-typedef int int32_T;
-typedef unsigned int uint32_T;
-typedef float real32_T;
-typedef double real64_T;
-
-//===========================================================================*
-//  Generic type definitions: boolean_T, char_T, byte_T, int_T, uint_T,       *
-//                            real_T, time_T, ulong_T.                        *
-// ===========================================================================
-typedef double real_T;
-typedef double time_T;
-typedef unsigned char boolean_T;
-typedef int int_T;
-typedef unsigned int uint_T;
-typedef unsigned long ulong_T;
-typedef char char_T;
-typedef unsigned char uchar_T;
-typedef char_T byte_T;
-
-//===========================================================================*
-//  Complex number type definitions                                           *
-// ===========================================================================
-#define CREAL_T
-
-typedef struct {
-  real32_T re;
-  real32_T im;
-} creal32_T;
-
-typedef struct {
-  real64_T re;
-  real64_T im;
-} creal64_T;
-
-typedef struct {
-  real_T re;
-  real_T im;
-} creal_T;
-
-#define CINT8_T
-
-typedef struct {
-  int8_T re;
-  int8_T im;
-} cint8_T;
-
-#define CUINT8_T
-
-typedef struct {
-  uint8_T re;
-  uint8_T im;
-} cuint8_T;
-
-#define CINT16_T
-
-typedef struct {
-  int16_T re;
-  int16_T im;
-} cint16_T;
-
-#define CUINT16_T
-
-typedef struct {
-  uint16_T re;
-  uint16_T im;
-} cuint16_T;
-
-#define CINT32_T
-
-typedef struct {
-  int32_T re;
-  int32_T im;
-} cint32_T;
-
-#define CUINT32_T
-
-typedef struct {
-  uint32_T re;
-  uint32_T im;
-} cuint32_T;
-
-//=======================================================================*
-//  Min and Max:                                                          *
-//    int8_T, int16_T, int32_T     - signed 8, 16, or 32 bit integers     *
-//    uint8_T, uint16_T, uint32_T  - unsigned 8, 16, or 32 bit integers   *
-// =======================================================================
-#define MAX_int8_T                     ((int8_T)(127))
-#define MIN_int8_T                     ((int8_T)(-128))
-#define MAX_uint8_T                    ((uint8_T)(255U))
-#define MAX_int16_T                    ((int16_T)(32767))
-#define MIN_int16_T                    ((int16_T)(-32768))
-#define MAX_uint16_T                   ((uint16_T)(65535U))
-#define MAX_int32_T                    ((int32_T)(2147483647))
-#define MIN_int32_T                    ((int32_T)(-2147483647-1))
-#define MAX_uint32_T                   ((uint32_T)(0xFFFFFFFFU))
-
-// Block D-Work pointer type
-typedef void * pointer_T;
-
-#endif                                 // RTWTYPES_H
-
-//
-// File trailer for generated code.
-//
-// [EOF]
-//

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

@@ -7,9 +7,9 @@
 //
 // Code generated for Simulink model 'FSMTreppe'.
 //
-// Model version                  : 1.22
+// Model version                  : 1.28
 // Simulink Coder version         : 9.5 (R2021a) 14-Nov-2020
-// C/C++ source code generated on : Fri Jul  2 17:45:36 2021
+// 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
@@ -18,17 +18,8 @@
 //
 #ifndef RTW_HEADER_FSMTreppe_h_
 #define RTW_HEADER_FSMTreppe_h_
-#include "rtwtypes.h"
-#include "FSMTreppe_types.h"
 
-// Macros for accessing real-time model data structure
+#include <stdint.h>
-#ifndef rtmGetErrorStatus
-#define rtmGetErrorStatus(rtm)         ((rtm)->errorStatus)
-#endif
-
-#ifndef rtmSetErrorStatus
-#define rtmSetErrorStatus(rtm, val)    ((rtm)->errorStatus = (val))
-#endif
 
 // Class declaration for model FSMTreppe
 class FSMTreppeModelClass {
@@ -36,30 +27,24 @@ class FSMTreppeModelClass {
  public:
   // Block states (default storage) for system '<Root>'
   struct DW_FSMTreppe_T {
-    uint16_T temporalCounter_i1;       // '<Root>/FSMTreppe'
+    uint16_t temporalCounter_i1;       // '<Root>/FSMTreppe'
-    uint8_T is_active_c3_FSMTreppe;    // '<Root>/FSMTreppe'
+    uint8_t is_active_c3_FSMTreppe;    // '<Root>/FSMTreppe'
-    uint8_T is_c3_FSMTreppe;           // '<Root>/FSMTreppe'
+    uint8_t is_c3_FSMTreppe;           // '<Root>/FSMTreppe'
-    uint8_T got_anim_finished;         // '<Root>/FSMTreppe'
-    uint8_T finished_up;               // '<Root>/FSMTreppe'
-    uint8_T finished_dn;               // '<Root>/FSMTreppe'
-    uint8_T got_sensor;                // '<Root>/FSMTreppe'
   };
 
   // External inputs (root inport signals with default storage)
   struct ExtU_FSMTreppe_T {
-    boolean_T sensor_unten;            // '<Root>/sensor_unten'
+    bool sensor_unten;            // '<Root>/sensor_unten'
-    boolean_T sensor_oben;             // '<Root>/sensor_oben'
+    bool sensor_oben;             // '<Root>/sensor_oben'
-    boolean_T anim_finished;           // '<Root>/anim_finished'
+    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 anim_active;               // '<Root>/anim_active'
+    uint8_t laufrichtung;              // '<Root>/laufrichtung'
-  };
+    uint8_t status;                    // '<Root>/status'
-
+    uint8_t dimmrichtung;              // '<Root>/dimmrichtung'
-  // Real-time Model Data Structure
-  struct RT_MODEL_FSMTreppe_T {
-    const char_T * volatile errorStatus;
   };
 
   // model initialize function
@@ -93,9 +78,6 @@ class FSMTreppeModelClass {
     return FSMTreppe_Y;
   }
 
-  // Real-Time Model get method
-  FSMTreppeModelClass::RT_MODEL_FSMTreppe_T * getRTM();
-
   // private data and function members
  private:
   // Block states
@@ -106,9 +88,6 @@ class FSMTreppeModelClass {
 
   // External outputs
   ExtY_FSMTreppe_T FSMTreppe_Y;
-
-  // Real-Time Model
-  RT_MODEL_FSMTreppe_T FSMTreppe_M;
 };
 
 //-

lib/treppe/treppe.cpp

@@ -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){
-    setTick(0);
-    setAnAus(1);
-    setDirection(1);
-    setState(1);
   }
 
-  if(current_sensor_state[1] && !last_sensor_state[1] && state == 0){
+  fsm_inputs.ldr_schwelle = true;
-    setTick(0);
+  fsm_inputs.sensor_oben =  read_sensor(SENSOR_OBEN);
-    setAnAus(0);
+  fsm_inputs.sensor_unten = read_sensor(SENSOR_UNTEN);
-    setDirection(0);
+  fsm_inputs.anim_beendet = static_cast<bool>(finish);
-    setState(1);
-  }
 
-  // first switch - off approach, use timer later
+  FSMTreppe_Obj.setExternalInputs(&fsm_inputs);
-  if(!current_sensor_state[0] && last_sensor_state[0] && state == 1){
+  FSMTreppe_Obj.step();
-    setTick(ticks_treppe);
+  fsm_outputs = FSMTreppe_Obj.getExternalOutputs();
-    setAnAus(1);
+  print_state_on_change();
-    setDirection(1);
-    setState(0);
-  }
 
-  if(!current_sensor_state[1] && last_sensor_state[1] && state == 1){
+  direction = fsm_outputs.laufrichtung;
-    setTick(ticks_treppe);
+  state = fsm_outputs.dimmrichtung;
-    setAnAus(1);
-    setDirection(0);
-    setState(0);
-  }
 
-  last_sensor_state[0] = current_sensor_state[0];
+  // setTick(ticks_treppe);
-  last_sensor_state[1] = current_sensor_state[1];
+  // setAnAus(1);
+  // setDirection(0);
+  // setState(0);
   
   ledsequence();
-  //Serial.printf("LDR: %f\n", ((float)analogRead(A0))/1023.*3.68);
 }
 
 

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