changed pwm setters and httpserver call

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) {
-    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) {
-    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,9 +49,8 @@ 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) {
@@ -65,46 +60,38 @@ void Treppe::start_animation( dimmer_t* dimmer, bool dim_type,
       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);
 }
 
-float Treppe::read_ldr()
+float Treppe::read_ldr() {
-{
   /*
   Reads Illuminance in Lux
 
@@ -191,8 +174,7 @@ float Treppe::read_ldr()
   return ldr_value;
 }
 
-bool Treppe::check_ldr()
+bool Treppe::check_ldr() {
-{
   static uint8_t active = 0;
 
 #ifdef LDRDEBUG
@@ -212,12 +194,14 @@ bool Treppe::check_ldr()
   return active;
 }
 
-void Treppe::task()
+void Treppe::task() {
-{  
 #ifdef DEBUG_TIMING
   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
@@ -257,23 +241,19 @@ void Treppe::task()
   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)
-      start_animation(&dimmer_stufen, DIM_STUFEN, parameters.active_pwm, idle_pwm_ist);
+      start_animation(&dimmer_stufen, DIM_STUFEN, parameters.active_pwm,
+                      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)
       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) {
       fsm_pend.ldr_changed = false;
       fsm_outputs.dimmrichtung = DR_AUFDIMMEN;
@@ -285,15 +265,13 @@ void Treppe::task()
     }
   }
 
-
 #ifdef DEBUG_TIMING
   Serial.print("5:");
   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
@@ -317,33 +295,39 @@ void Treppe::setup()
   Serial.printf("Treppe: stufen=%d\n", stufen);
 }
 
-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)
+  if (parameters.idle_pwm_max > parameters.active_pwm) {
-{
+    parameters.idle_pwm_max = parameters.active_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);
+  Serial.printf("Treppe: parameters.idle_pwm_max=%d\n",
-  fsm_pend.ldr_changed = true;
+                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;
   }
-void Treppe::set_time_per_stair(uint16_t _time_per_stair)
+
-{
+  if (parameters.active_pwm > 4095) {
+    parameters.idle_pwm_max = 4095;
+  }
+
+  Serial.printf("Treppe: parameters.active_pwm=%d\n", parameters.active_pwm);
+}
+
+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);
 }

lib/treppe/treppe.h

@@ -13,6 +13,8 @@
 
 #define INT_TIME 20 // interrupt intervall [ms]
 
+enum vorgabe_typ_t { VORGABE_PROZENT = 0, VORGABE_12BIT = 1 };
+
 class Treppe {
 private:
   const uint8_t stufen;
@@ -47,10 +49,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;
 
@@ -71,20 +70,14 @@ private:
     ST_WARTEN_RUNTER = 8,
     ST_ABDIMMEN_RUNTER = 9
   };
-    enum fsm_laufrichtung_t {
+  enum fsm_laufrichtung_t { LR_RUNTER = 0, LR_HOCH = 1 };
-        LR_RUNTER=0,
+  enum fsm_dimmrichtung_t { DR_ABDIMMEN = 0, DR_AUFDIMMEN = 1 };
-        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);
-    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();
 
@@ -92,21 +85,17 @@ 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 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);
 };