schmidtsi76327/ESP8266_Treppenlicht
2
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Compare commits

...

3 Commits
754da9f931 ... 472eba7977

Author SHA1 Message Date
Simon Schmidt
472eba7977 updates to state machine with print function 2021-07-03 12:48:17 +02:00
Simon Schmidt
6a398d9ba0 simulink stateflow compiling 2021-07-03 11:33:20 +02:00
Simon Schmidt
f28aa2df8b stripped out RTM Model interface and custom types from matlab 2021-07-03 11:31:46 +02:00
7 changed files with 77 additions and 356 deletions

18
lib/treppe/FSMTreppe/FSMTreppe.cpp

@ -17,12 +17,11 @@
// 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;
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()
@ -33,7 +32,7 @@ void FSMTreppeModelClass::step()
// Inport: '<Root>/sensor_unten'
if (FSMTreppe_DW.temporalCounter_i1 < 511U) {
FSMTreppe_DW.temporalCounter_i1 = static_cast<uint16_T>
FSMTreppe_DW.temporalCounter_i1 = static_cast<uint16_t>
(FSMTreppe_DW.temporalCounter_i1 + 1U);
}
@ -153,8 +152,7 @@ void FSMTreppeModelClass::terminate()
FSMTreppeModelClass::FSMTreppeModelClass() :
FSMTreppe_DW(),
FSMTreppe_U(),
FSMTreppe_Y(),
FSMTreppe_M()
FSMTreppe_Y()
{
// Currently there is no constructor body generated.
}
@ -165,12 +163,6 @@ 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.
//

44
lib/treppe/FSMTreppe/FSMTreppe.h

@ -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
#ifndef rtmGetErrorStatus
#define rtmGetErrorStatus(rtm) ((rtm)->errorStatus)
#endif
#ifndef rtmSetErrorStatus
#define rtmSetErrorStatus(rtm, val) ((rtm)->errorStatus = (val))
#endif
#include <stdint.h>
// Class declaration for model FSMTreppe
class FSMTreppeModelClass {
@ -36,30 +27,25 @@ class FSMTreppeModelClass {
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'
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'
uint16_t temporalCounter_i1; // '<Root>/FSMTreppe'
uint8_t is_active_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'
boolean_T sensor_oben; // '<Root>/sensor_oben'
boolean_T anim_finished; // '<Root>/anim_finished'
bool sensor_unten; // '<Root>/sensor_unten'
bool sensor_oben; // '<Root>/sensor_oben'
bool anim_finished; // '<Root>/anim_finished'
};
// External outputs (root outports fed by signals with default storage)
struct ExtY_FSMTreppe_T {
uint8_T anim_active; // '<Root>/anim_active'
};
// Real-time Model Data Structure
struct RT_MODEL_FSMTreppe_T {
const char_T * volatile errorStatus;
uint8_t anim_active; // '<Root>/anim_active'
};
// model initialize function
@ -93,9 +79,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 +89,6 @@ class FSMTreppeModelClass {
// External outputs
ExtY_FSMTreppe_T FSMTreppe_Y;
// Real-Time Model
RT_MODEL_FSMTreppe_T FSMTreppe_M;
};
//-

28
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]
//

109
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]
//

160
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]
//

47
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,26 +143,57 @@ void Treppe::setup(){
pwmController.setAllChannelsPWM(idle_brightness);
pinMode(A0, INPUT);
pinMode(SENSOR1, INPUT);
pinMode(SENSOR2, INPUT);
pinMode(SENSOR_OBEN, 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::task(){
void Treppe::print_state_on_change() {
static FSMTreppeModelClass::ExtU_FSMTreppe_T last_in;
static FSMTreppeModelClass::ExtY_FSMTreppe_T last_out;
if(
fsm_inputs.anim_finished != last_in.anim_finished ||
fsm_inputs.sensor_oben != last_in.sensor_oben ||
fsm_inputs.sensor_unten != last_in.sensor_unten ||
fsm_outputs.anim_active != last_out.anim_active
) {
last_in.anim_finished = fsm_inputs.anim_finished;
last_in.sensor_oben = fsm_inputs.sensor_oben;
last_in.sensor_unten = fsm_inputs.sensor_unten;
last_out.anim_active = fsm_outputs.anim_active;
Serial.printf("FSM inputs: s_u: %d, s_o: %d, an_fin: %d =>",
fsm_inputs.sensor_oben, fsm_inputs.sensor_unten, fsm_inputs.anim_finished);
Serial.print(" step => ");
Serial.printf("FSM outputs: an_act: %d\n", fsm_outputs.anim_active);
}
}
void Treppe::task(){
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);
current_sensor_state[0] = digitalRead(SENSOR_OBEN);
current_sensor_state[1] = digitalRead(SENSOR_UNTEN);
fsm_inputs.sensor_oben = read_sensor(SENSOR_OBEN);
fsm_inputs.sensor_unten = read_sensor(SENSOR_UNTEN);
fsm_inputs.anim_finished = static_cast<bool>(finish);
FSMTreppe_Obj.setExternalInputs(&fsm_inputs);
FSMTreppe_Obj.step();
fsm_outputs = FSMTreppe_Obj.getExternalOutputs();
print_state_on_change();
if(current_sensor_state[0] && !last_sensor_state[0] && state == 0){
setTick(0);
setAnAus(1);

27
lib/treppe/treppe.h

@ -1,19 +1,21 @@
#pragma once
#include "FSMTreppe/FSMTreppe.h"
#include "PCA9685.h"
#define SENSOR1 2
#define SENSOR2 12
#define SENSOR_OBEN 2
#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;
@ -31,21 +33,36 @@ 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();
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