Merge branch 'master' of https://git.efi.th-nuernberg.de/gitea/schmidtsi76327/ESP8266_Treppenlicht

lib/httpserver/httpserver.cpp

@@ -42,9 +42,19 @@ void HTTPServer::start_apps() {
     if (args()) {
       for (int i = 0; i < args() - 1; i++) {
         Serial.printf("%s=%s\n", argName(i).c_str(), arg(i).c_str());
-        if (argName(i).equals("range_idl_pwm")) {
+
-          treppe->set_idle_prozent(arg(i).toInt());
+        if (argName(i).equals("range_act_pwm")) {
+          treppe->set_active_pwm(arg(i).toInt(), VORGABE_PROZENT);
         }
+        else if (argName(i).equals("range_idl_pwm")) {
+          treppe->set_idle_pwm_max(arg(i).toInt(), VORGABE_PROZENT);
+        }
+        else if (argName(i).equals("range_tim_sta")) {
+        }
+        else if (argName(i).equals("range_tim_on")) {
+          
+        }
+
       }
     }
     send(200, "text/plain", "accepted");

lib/treppe/treppe.cpp

@@ -5,42 +5,38 @@
     - dimmer_tick: increment pwm jeden tick, bis anim beendet
     - return: fsm_pend.anim_beendet
 */
-bool Treppe::dimmer_tick(dimmer_t* dimmer, bool dim_type)
+bool Treppe::dimmer_tick(dimmer_t *dimmer, bool dim_type) {
-{
   dimmer->pwm += dimmer->delta_pwm;
   Serial.printf("%.0f", dimmer->pwm);
 
-  if(dim_type == DIM_STUFEN) {
+  if (dim_type == DIM_STUFEN) {
-    pwmController.setChannelPWM(dimmer->stufe, static_cast<uint16_t>(dimmer->pwm));
+    pwmController.setChannelPWM(dimmer->stufe,
+                                static_cast<uint16_t>(dimmer->pwm));
   } else { // DIM_LDR
     pwmController.setAllChannelsPWM(static_cast<uint16_t>(dimmer->pwm));
   }
 
   dimmer->tick++;
-  if (dimmer->tick < dimmer->ticks)
+  if (dimmer->tick < dimmer->ticks) {
-  {
     Serial.print("-");
     return false;
   }
   Serial.println("");
 
-  if(dim_type == DIM_LDR) {
+  if (dim_type == DIM_LDR) {
-    Serial.printf("DIM_LDR: start: %d, ziel: %d\n",
+    Serial.printf("DIM_LDR: start: %d, ziel: %d\n", dimmer->start_pwm,
-           dimmer->start_pwm, dimmer->ziel_pwm);
+                  dimmer->ziel_pwm);
     return true;
-  }
+  } else // DIM_STUFEN
-  else // DIM_STUFEN
   {
     Serial.printf("DIM_STUFEN:  stufe: %d, start: %d, ziel: %d\n",
                   dimmer->stufe, dimmer->start_pwm, dimmer->ziel_pwm);
 
-    if (fsm_outputs.laufrichtung == LR_HOCH)
+    if (fsm_outputs.laufrichtung == LR_HOCH) {
-    {
       if (dimmer->stufe >= stufen - 1)
         return true;
       dimmer->stufe++;
-    }
+    } else // LR_RUNTER
-    else // LR_RUNTER
     {
       if (dimmer->stufe <= 0)
         return true;
@@ -53,58 +49,49 @@ bool Treppe::dimmer_tick(dimmer_t* dimmer, bool dim_type)
 }
 
 // startbedingunen für animation
-void Treppe::start_animation( dimmer_t* dimmer, bool dim_type,
+void Treppe::start_animation(dimmer_t *dimmer, bool dim_type, uint16_t on_pwm,
-                              uint16_t on_pwm, uint16_t off_pwm)
+                             uint16_t off_pwm) {
-{
   fsm_pend.anim_beendet = false;
 
-  if(dim_type == DIM_STUFEN) {
+  if (dim_type == DIM_STUFEN) {
     if (fsm_outputs.laufrichtung == LR_HOCH)
       dimmer->stufe = 0;
     else
       dimmer->stufe = stufen - 1;
 
     dimmer->ticks = parameters.time_per_stair / INT_TIME; // [ms]
-  } 
+  } else {                                                // DIM_LDR
-  else { // DIM_LDR
     dimmer->ticks = parameters.time_ldr / INT_TIME;       // [ms]
   }
 
-  if (fsm_outputs.dimmrichtung == DR_AUFDIMMEN)
+  if (fsm_outputs.dimmrichtung == DR_AUFDIMMEN) {
-  {
     dimmer->start_pwm = off_pwm;
     dimmer->ziel_pwm = on_pwm;
-    dimmer->delta_pwm = (float)(on_pwm - off_pwm) 
+    dimmer->delta_pwm = (float)(on_pwm - off_pwm) / (float)dimmer->ticks;
-                          / (float)dimmer->ticks;
+  } else {
-  }
-  else
-  {
     dimmer->start_pwm = on_pwm;
     dimmer->ziel_pwm = off_pwm;
-    dimmer->delta_pwm = (float)(off_pwm - on_pwm) 
+    dimmer->delta_pwm = (float)(off_pwm - on_pwm) / (float)dimmer->ticks;
-                          / (float)dimmer->ticks;
   }
 
   dimmer->tick = 0;
   dimmer->pwm = dimmer->start_pwm;
 
   Serial.printf("stufe %d, ticks %d, delta %f, start %d, ziel %d\n",
-    dimmer->stufe, dimmer->ticks, dimmer->delta_pwm, dimmer->start_pwm, dimmer->ziel_pwm);
+                dimmer->stufe, dimmer->ticks, dimmer->delta_pwm,
+                dimmer->start_pwm, dimmer->ziel_pwm);
 }
 
-void Treppe::print_state_on_change()
+void Treppe::print_state_on_change() {
-{
   static FSMTreppeModelClass::ExtU_FSMTreppe_T last_in;
   static FSMTreppeModelClass::ExtY_FSMTreppe_T last_out;
-  if (
+  if (fsm_inputs.anim_beendet != last_in.anim_beendet ||
-      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_inputs.ldr_schwelle != last_in.ldr_schwelle ||
       fsm_outputs.dimmrichtung != last_out.dimmrichtung ||
       fsm_outputs.laufrichtung != last_out.laufrichtung ||
-      fsm_outputs.status != last_out.status)
+      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;
@@ -116,20 +103,20 @@ void Treppe::print_state_on_change()
     Serial.printf("FSM IN: s_u: %d, s_o: %d, a_b: %d, l_s: %d => ",
                   fsm_inputs.sensor_oben, fsm_inputs.sensor_unten,
                   fsm_inputs.anim_beendet, fsm_inputs.ldr_schwelle);
-    Serial.printf("OUT: LR: %d DR: %d ST: %d\n",
+    Serial.printf("OUT: LR: %d DR: %d ST: %d\n", fsm_outputs.laufrichtung,
-                  fsm_outputs.laufrichtung, fsm_outputs.dimmrichtung, fsm_outputs.status);
+                  fsm_outputs.dimmrichtung, fsm_outputs.status);
   }
 }
 
-bool Treppe::read_sensor(int sensor)
+bool Treppe::read_sensor(int sensor) {
-{
 
   /*
   reads sensors with edge detection
 
   returns true if motion was detected
   returns false if no motion was detected
-  returns false if motion was detected, but state did not change back to not detected
+  returns false if motion was detected, but state did not change back to not
+  detected
   */
   uint8_t pegel = digitalRead(sensor);
   static uint8_t pegel_alt[2] = {0, 0};
@@ -140,21 +127,17 @@ bool Treppe::read_sensor(int sensor)
   else
     index = 1;
 
-  if (pegel == 1 && pegel_alt[index] == 0)
+  if (pegel == 1 && pegel_alt[index] == 0) {
-  {
     pegel_alt[index] = pegel;
     return true;
-  }
+  } else {
-  else
-  {
     pegel_alt[index] = pegel;
     return false;
   }
-  //return static_cast<bool>(pegel);
+  // return static_cast<bool>(pegel);
 }
 
-float Treppe::read_ldr()
+float Treppe::read_ldr() {
-{
   /*
   Reads Illuminance in Lux
 
@@ -187,12 +170,11 @@ float Treppe::read_ldr()
   ldr_value = E(LDR)
   */
   float ldr_ohm = 37280.00 / analogRead(A0);
-  float ldr_value = 6526.6/(ldr_ohm*ldr_ohm);
+  float ldr_value = 6526.6 / (ldr_ohm * ldr_ohm);
   return ldr_value;
 }
 
-bool Treppe::check_ldr()
+bool Treppe::check_ldr() {
-{
   static uint8_t active = 0;
 
 #ifdef LDRDEBUG
@@ -212,18 +194,20 @@ bool Treppe::check_ldr()
   return active;
 }
 
-void Treppe::task()
+void Treppe::task() {
-{  
 #ifdef DEBUG_TIMING
-  uint32_t m=micros();
+  uint32_t m = micros();
 #endif
 
+  // TODO wenn LDR geändert => idle_pwm_soll anpassen 
+  // fsm_pend.ldr_changed = true;
+
   fsm_inputs.ldr_schwelle = check_ldr();
 
 #ifdef DEBUG_TIMING
   Serial.print("1:");
-  Serial.println(micros()-m);
+  Serial.println(micros() - m);
-  m=micros();
+  m = micros();
 #endif
 
   fsm_inputs.sensor_oben = read_sensor(SENSOR_OBEN);
@@ -232,8 +216,8 @@ void Treppe::task()
 
 #ifdef DEBUG_TIMING
   Serial.print("2:");
-  Serial.println(micros()-m);
+  Serial.println(micros() - m);
-  m=micros();
+  m = micros();
 #endif
 
   FSMTreppe_Obj.setExternalInputs(&fsm_inputs);
@@ -242,67 +226,62 @@ void Treppe::task()
 
 #ifdef DEBUG_TIMING
   Serial.print("3:");
-  Serial.println(micros()-m);
+  Serial.println(micros() - m);
-  m=micros();
+  m = micros();
 #endif
 
   print_state_on_change();
 
 #ifdef DEBUG_TIMING
   Serial.print("4:");
-  Serial.println(micros()-m);
+  Serial.println(micros() - m);
-  m=micros();
+  m = micros();
 #endif
 
-  if( fsm_outputs.status == ST_AUFDIMMEN_HOCH || 
+  if (fsm_outputs.status == ST_AUFDIMMEN_HOCH ||
       fsm_outputs.status == ST_ABDIMMEN_HOCH ||
       fsm_outputs.status == ST_AUFDIMMEN_RUNTER ||
-      fsm_outputs.status == ST_ABDIMMEN_RUNTER )
+      fsm_outputs.status == ST_ABDIMMEN_RUNTER) {
-  {
+    if (fsm_pend.anim_beendet)
-    if(fsm_pend.anim_beendet)
+      start_animation(&dimmer_stufen, DIM_STUFEN, parameters.active_pwm,
-      start_animation(&dimmer_stufen, DIM_STUFEN, parameters.active_pwm, idle_pwm_ist);
+                      idle_pwm_ist);
     else
       fsm_pend.anim_beendet = dimmer_tick(&dimmer_stufen, DIM_STUFEN);
-  }
+  } else if (fsm_outputs.status == ST_AUFDIMMEN_LDR ||
-  else if ( fsm_outputs.status == ST_AUFDIMMEN_LDR ||
+             fsm_outputs.status == ST_ABDIMMEN_LDR) {
-            fsm_outputs.status == ST_ABDIMMEN_LDR )
+    if (fsm_pend.anim_beendet)
-  {
-    if(fsm_pend.anim_beendet)
       start_animation(&dimmer_ldr, DIM_LDR, idle_pwm_ist, 0);
     else
       fsm_pend.anim_beendet = dimmer_tick(&dimmer_ldr, DIM_LDR);
-  }
+  } else if (fsm_outputs.status == ST_RUHEZUSTAND) {
-  else if ( fsm_outputs.status == ST_RUHEZUSTAND ) 
+    if (fsm_pend.ldr_changed) {
-  {
-    if ( fsm_pend.ldr_changed ) {
       fsm_pend.ldr_changed = false;
       fsm_outputs.dimmrichtung = DR_AUFDIMMEN;
       start_animation(&dimmer_ldr, DIM_LDR, idle_pwm_soll, idle_pwm_ist);
       idle_pwm_ist = idle_pwm_soll;
     }
-    if(!fsm_pend.anim_beendet) {
+    if (!fsm_pend.anim_beendet) {
       fsm_pend.anim_beendet = dimmer_tick(&dimmer_ldr, DIM_LDR);
     }
   }
 
-
 #ifdef DEBUG_TIMING
   Serial.print("5:");
-  Serial.println(micros()-m);
+  Serial.println(micros() - m);
 #endif
 }
 
-void Treppe::setup()
+void Treppe::setup() {
-{
   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
   pwmController.init(PCA9685_PhaseBalancer_None);
-  //pwmController.init(PCA9685_PhaseBalancer_Linear);
+  // pwmController.init(PCA9685_PhaseBalancer_Linear);
   pwmController.setPWMFrequency(100);
-  //pwmController.setAllChannelsPWM(idle_pwm);
+  // pwmController.setAllChannelsPWM(idle_pwm);
   
+  // WARNING: before getting Parameters of Flash, make sure plausible parameters are written in flash!
   EEPROM.get(EEP_START_ADDR, parameters);     // get Parameters of flash
   
   pinMode(13, OUTPUT);
@@ -318,40 +297,44 @@ void Treppe::setup()
 
   Serial.printf("Treppe: stufen=%d\n", stufen);
 }
-
 void Treppe::saveParam(){
   EEPROM.put(EEP_START_ADDR, parameters); // copy Parameters so "EEPROM"-section in RAM
   EEPROM.commit();                        // write "EEPROM"-section to flash
 }
 
-void Treppe::set_idle_prozent(const int prozent) 
+void Treppe::set_idle_pwm_max(const uint16_t value,
-{
+                              const vorgabe_typ_t vorgabe_typ) {
-  // future use: parameters.idle_max_pwm
+  if (vorgabe_typ == VORGABE_PROZENT) {
-  uint16_t new_pwm = parameters.active_pwm * prozent / 100;
+    parameters.idle_pwm_max = parameters.active_pwm * value / 100;
-  set_idle_pwm_max(new_pwm);
+  } else if (vorgabe_typ == VORGABE_12BIT) {
-}
+    parameters.idle_pwm_max = value;
-void Treppe::set_idle_pwm_max(const uint16_t new_pwm)
-{
-  // future use: parameters.idle_max_pwm
-  if(new_pwm > parameters.active_pwm) {
-    idle_pwm_soll = parameters.active_pwm;
-  } else {
-    idle_pwm_soll = new_pwm;
   }
 
-  Serial.printf("Treppe: idle_pwm_soll=%d\n", idle_pwm_soll);
+  if (parameters.idle_pwm_max > parameters.active_pwm) {
-  fsm_pend.ldr_changed = true;
+    parameters.idle_pwm_max = parameters.active_pwm;
-  //saveParam();        //uncomment if idle_pwm_max is used
+  }
+  saveParam();
+  Serial.printf("Treppe: parameters.idle_pwm_max=%d\n",
+                parameters.idle_pwm_max);
 }
 
-void Treppe::set_active_pwm(uint16_t _active_pwm)
+void Treppe::set_active_pwm(const uint16_t value,
-{
+                            const vorgabe_typ_t vorgabe_typ) {
-  parameters.active_pwm = _active_pwm;
+
-  Serial.printf("Treppe: active_pwm=%d\n", parameters.active_pwm);
+  if (vorgabe_typ == VORGABE_PROZENT) {
+    parameters.active_pwm = 4095 * value / 100;
+  } else if (vorgabe_typ == VORGABE_12BIT) {
+    parameters.active_pwm = value;
+  }
+
+  if (parameters.active_pwm > 4095) {
+    parameters.idle_pwm_max = 4095;
+  }
   saveParam();
+  Serial.printf("Treppe: parameters.active_pwm=%d\n", parameters.active_pwm);
 }
-void Treppe::set_time_per_stair(uint16_t _time_per_stair)
+
-{
+void Treppe::set_time_per_stair(uint16_t _time_per_stair) {
   parameters.time_per_stair = _time_per_stair;
   Serial.printf("Treppe: time_per_stair=%d\n", parameters.time_per_stair);
   saveParam();

lib/treppe/treppe.h

@@ -14,6 +14,8 @@
 
 #define INT_TIME 20 // interrupt intervall [ms]
 
+enum vorgabe_typ_t { VORGABE_PROZENT = 0, VORGABE_12BIT = 1 };
+
 #define EEP_START_ADDR 100      // define Start Address for "EEPROM" storage -> depends on size of "wifi_data"!
 
 class Treppe {
@@ -50,10 +52,7 @@ private:
     uint16_t start_pwm = 0;
     uint16_t ziel_pwm = 0;
   };
-    enum dimmer_type_t {
+  enum dimmer_type_t { DIM_STUFEN = 0, DIM_LDR = 1 };
-        DIM_STUFEN=0,
-        DIM_LDR=1
-    };
   dimmer_t dimmer_stufen;
   dimmer_t dimmer_ldr;
 
@@ -63,31 +62,25 @@ private:
   FSMTreppeModelClass::ExtU_FSMTreppe_T fsm_inputs;
   FSMTreppeModelClass::ExtY_FSMTreppe_T fsm_outputs;
   enum fsm_status_t {
-        ST_INAKTIV_LDR      =0,
+    ST_INAKTIV_LDR = 0,
-        ST_AUFDIMMEN_LDR    =1,
+    ST_AUFDIMMEN_LDR = 1,
-        ST_ABDIMMEN_LDR     =2,
+    ST_ABDIMMEN_LDR = 2,
-        ST_RUHEZUSTAND      =3,
+    ST_RUHEZUSTAND = 3,
-        ST_AUFDIMMEN_HOCH   =4,
+    ST_AUFDIMMEN_HOCH = 4,
-        ST_WARTEN_HOCH      =5,
+    ST_WARTEN_HOCH = 5,
-        ST_ABDIMMEN_HOCH    =6,
+    ST_ABDIMMEN_HOCH = 6,
-        ST_AUFDIMMEN_RUNTER =7,
+    ST_AUFDIMMEN_RUNTER = 7,
-        ST_WARTEN_RUNTER    =8,
+    ST_WARTEN_RUNTER = 8,
-        ST_ABDIMMEN_RUNTER  =9
+    ST_ABDIMMEN_RUNTER = 9
-    };
-    enum fsm_laufrichtung_t {
-        LR_RUNTER=0,
-        LR_HOCH=1
-    };
-    enum fsm_dimmrichtung_t {
-        DR_ABDIMMEN=0,
-        DR_AUFDIMMEN=1
   };
+  enum fsm_laufrichtung_t { LR_RUNTER = 0, LR_HOCH = 1 };
+  enum fsm_dimmrichtung_t { DR_ABDIMMEN = 0, DR_AUFDIMMEN = 1 };
 
   /* DIMM */
   // bool dimmer(dimmer_t* dimmer, bool dim_type);
-    bool dimmer_tick(dimmer_t* dimmer, bool dim_type);
+  bool dimmer_tick(dimmer_t *dimmer, bool dim_type);
-    void start_animation(dimmer_t* dimmer, bool dim_type,
+  void start_animation(dimmer_t *dimmer, bool dim_type, uint16_t on_pwm,
-                         uint16_t on_pwm, uint16_t off_pwm);
+                       uint16_t off_pwm);
   // void berechne_dimmer(dimmer_t* dimmer, bool dim_type);
   void print_state_on_change();
 
@@ -95,22 +88,18 @@ private:
   bool read_sensor(int sensor);
   float read_ldr();
   bool check_ldr();
+
 public:
-    Treppe(uint8_t _stufen) : stufen(_stufen){
+  Treppe(uint8_t _stufen) : stufen(_stufen) { FSMTreppe_Obj.initialize(); }
-        FSMTreppe_Obj.initialize();
+  ~Treppe() { FSMTreppe_Obj.terminate(); }
-    }
-    ~Treppe() {
-        FSMTreppe_Obj.terminate();
-    }
 
   void setup();
   void task(); // call periodically
 
   // Parameter section
   void saveParam();
-    void set_idle_prozent(int prozent);
+  void set_idle_pwm_max(const uint16_t value, const vorgabe_typ_t vorgabe_typ);
-    void set_idle_pwm_max(const uint16_t new_pwm);
+  void set_active_pwm(const uint16_t value, const vorgabe_typ_t vorgabe_typ);
-    void set_active_pwm(uint16_t _active_pwm);
   void set_time_per_stair(uint16_t _time_per_stair);
 };