changed pwm setters and httpserver call

lib/httpserver/httpserver.cpp

     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

     - 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));
+  if (dim_type == DIM_STUFEN) {
+    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",
-           dimmer->start_pwm, dimmer->ziel_pwm);
+
+  if (dim_type == DIM_LDR) {
+    Serial.printf("DIM_LDR: start: %d, ziel: %d\n", dimmer->start_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);
+                  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;
 }
 
 // startbedingunen für animation
-void Treppe::start_animation( dimmer_t* dimmer, bool dim_type,
-                              uint16_t on_pwm, uint16_t off_pwm)
-{
+void Treppe::start_animation(dimmer_t *dimmer, bool dim_type, uint16_t on_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
-    dimmer->ticks = parameters.time_ldr / INT_TIME; // [ms]
+  } 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) 
-                          / (float)dimmer->ticks;
-  }
-  else
-  {
+    dimmer->ziel_pwm = on_pwm;
+    dimmer->delta_pwm = (float)(on_pwm - off_pwm) / (float)dimmer->ticks;
+  } else {
     dimmer->start_pwm = on_pwm;
-    dimmer->ziel_pwm = off_pwm;    
-    dimmer->delta_pwm = (float)(off_pwm - on_pwm) 
-                          / (float)dimmer->ticks;
+    dimmer->ziel_pwm = off_pwm;
+    dimmer->delta_pwm = (float)(off_pwm - on_pwm) / (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 (
-      fsm_inputs.anim_beendet != last_in.anim_beendet ||
+  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_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;
     last_out.status = fsm_outputs.status;
 
     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.sensor_oben, fsm_inputs.sensor_unten,
                   fsm_inputs.anim_beendet, fsm_inputs.ldr_schwelle);
-    Serial.printf("OUT: LR: %d DR: %d ST: %d\n",
-                  fsm_outputs.laufrichtung, fsm_outputs.dimmrichtung, fsm_outputs.status);
+    Serial.printf("OUT: LR: %d DR: %d ST: %d\n", fsm_outputs.laufrichtung,
+                  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};
   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
 
   FUTURE USE : show current Illuminance on Webserver in order to calibrate
             = analogRead(A0) * (R13+R14)/(R14*1023.00)
             = analogRead(A0) * (220k+82k)/(82k*1023.00)
             = analogRead(A0) * 0.0036
-  
+
   Voltage Divider 2 (LDR, R1 || (R13+R14))
   R1 = 47k, R13+R14 = 302k -> R1||(R13+R14) = 40,67k
   Vcc/V(in1) = R(LDR) / (R1||(R13+R14))
   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
   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);
-  m=micros();
+  Serial.println(micros() - m);
+  m = micros();
 #endif
 
   fsm_inputs.sensor_oben = read_sensor(SENSOR_OBEN);
 
 #ifdef DEBUG_TIMING
   Serial.print("2:");
-  Serial.println(micros()-m);
-  m=micros();
+  Serial.println(micros() - m);
+  m = micros();
 #endif
 
   FSMTreppe_Obj.setExternalInputs(&fsm_inputs);
 
 #ifdef DEBUG_TIMING
   Serial.print("3:");
-  Serial.println(micros()-m);
-  m=micros();
+  Serial.println(micros() - m);
+  m = micros();
 #endif
 
   print_state_on_change();
 
 #ifdef DEBUG_TIMING
   Serial.print("4:");
-  Serial.println(micros()-m);
-  m=micros();
+  Serial.println(micros() - m);
+  m = micros();
 #endif
 
-  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 )
-  {
-    if(fsm_pend.anim_beendet)
-      start_animation(&dimmer_stufen, DIM_STUFEN, parameters.active_pwm, idle_pwm_ist);
+  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) {
+    if (fsm_pend.anim_beendet)
+      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 ||
-            fsm_outputs.status == ST_ABDIMMEN_LDR )
-  {
-    if(fsm_pend.anim_beendet)
+  } else if (fsm_outputs.status == ST_AUFDIMMEN_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 ) 
-  {
-    if ( fsm_pend.ldr_changed ) {
+  } else if (fsm_outputs.status == ST_RUHEZUSTAND) {
+    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);
 
   pinMode(13, OUTPUT);
   pinMode(0, OUTPUT);
   Serial.printf("Treppe: stufen=%d\n", stufen);
 }
 
-void Treppe::set_idle_prozent(const int prozent) 
-{
-  // future use: parameters.idle_max_pwm
-  uint16_t new_pwm = parameters.active_pwm * prozent / 100;
-  set_idle_pwm_max(new_pwm);
-}
+void Treppe::set_idle_pwm_max(const uint16_t value,
+                              const vorgabe_typ_t vorgabe_typ) {
+  if (vorgabe_typ == VORGABE_PROZENT) {
+    parameters.idle_pwm_max = parameters.active_pwm * value / 100;
+  } 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;
+  if (parameters.idle_pwm_max > parameters.active_pwm) {
+    parameters.idle_pwm_max = parameters.active_pwm;
   }
 
-  Serial.printf("Treppe: idle_pwm_soll=%d\n", idle_pwm_soll);
-  fsm_pend.ldr_changed = true;
+  Serial.printf("Treppe: parameters.idle_pwm_max=%d\n",
+                parameters.idle_pwm_max);
 }
 
-void Treppe::set_active_pwm(uint16_t _active_pwm)
-{
-  parameters.active_pwm = _active_pwm;
-  Serial.printf("Treppe: active_pwm=%d\n", parameters.active_pwm);
+void Treppe::set_active_pwm(const uint16_t value,
+                            const vorgabe_typ_t vorgabe_typ) {
+
+  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;
+  }
+
+  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);
 }

lib/treppe/treppe.h

 #include "FSMTreppe3/FSMTreppe3.h"
 #include "PCA9685.h"
 
-// #define LDRDEBUG  // comment in to override LDR measurement 
-#define LDR_HYS 1  // Hysteresis for switching off FSM [lux]
+// #define LDRDEBUG  // comment in to override LDR measurement
+#define LDR_HYS 1 // Hysteresis for switching off FSM [lux]
 
 #define SENSOR_OBEN 16
 #define SENSOR_UNTEN 12
 #define OE 14
 
-#define INT_TIME 20  // interrupt intervall [ms]
+#define INT_TIME 20 // interrupt intervall [ms]
+
+enum vorgabe_typ_t { VORGABE_PROZENT = 0, VORGABE_12BIT = 1 };
 
 class Treppe {
 private:
-    const uint8_t stufen;
-
-    struct stairway_param_t {
-        uint16_t time_ldr = 500;
-        uint16_t time_per_stair = 300;  // dimmtime per stair [ms]
-        uint16_t idle_pwm_max = 100;
-        uint16_t active_pwm = 2000;
-        uint16_t ldr_schwelle = 2;      // activation value for FSM [lx]
-    };
-    stairway_param_t parameters;
-
-    uint16_t idle_pwm_ist = parameters.idle_pwm_max;
-    uint16_t idle_pwm_soll = 0;
-    
-    struct fsm_pending_inputs_t {
-        bool anim_beendet = true;
-        bool sensor_unten = false;
-        bool sensor_oben = false;
-        bool ldr_changed = false;
-    };
-    fsm_pending_inputs_t fsm_pend;
-
-    struct dimmer_t {
-        uint8_t stufe = 0;
-        uint16_t ticks = 0;
-        uint16_t tick = 0;
-
-        float delta_pwm = 0.0;
-        float pwm = 0.0;
-        uint16_t start_pwm = 0;
-        uint16_t ziel_pwm = 0;
-    };
-    enum dimmer_type_t {
-        DIM_STUFEN=0,
-        DIM_LDR=1
-    };
-    dimmer_t dimmer_stufen;
-    dimmer_t dimmer_ldr;
-    
-    // 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;
-    enum fsm_status_t {
-        ST_INAKTIV_LDR      =0,
-        ST_AUFDIMMEN_LDR    =1,
-        ST_ABDIMMEN_LDR     =2,
-        ST_RUHEZUSTAND      =3,
-        ST_AUFDIMMEN_HOCH   =4,
-        ST_WARTEN_HOCH      =5,
-        ST_ABDIMMEN_HOCH    =6,
-        ST_AUFDIMMEN_RUNTER =7,
-        ST_WARTEN_RUNTER    =8,
-        ST_ABDIMMEN_RUNTER  =9
-    };
-    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);
-    void start_animation(dimmer_t* dimmer, bool dim_type,
-                         uint16_t on_pwm, uint16_t off_pwm);
-    // void berechne_dimmer(dimmer_t* dimmer, bool dim_type);
-    void print_state_on_change();
-
-    /* LDR */
-    bool read_sensor(int sensor);
-    float read_ldr();
-    bool check_ldr();
+  const uint8_t stufen;
+
+  struct stairway_param_t {
+    uint16_t time_ldr = 500;
+    uint16_t time_per_stair = 300; // dimmtime per stair [ms]
+    uint16_t idle_pwm_max = 100;
+    uint16_t active_pwm = 2000;
+    uint16_t ldr_schwelle = 2; // activation value for FSM [lx]
+  };
+  stairway_param_t parameters;
+
+  uint16_t idle_pwm_ist = parameters.idle_pwm_max;
+  uint16_t idle_pwm_soll = 0;
+
+  struct fsm_pending_inputs_t {
+    bool anim_beendet = true;
+    bool sensor_unten = false;
+    bool sensor_oben = false;
+    bool ldr_changed = false;
+  };
+  fsm_pending_inputs_t fsm_pend;
+
+  struct dimmer_t {
+    uint8_t stufe = 0;
+    uint16_t ticks = 0;
+    uint16_t tick = 0;
+
+    float delta_pwm = 0.0;
+    float pwm = 0.0;
+    uint16_t start_pwm = 0;
+    uint16_t ziel_pwm = 0;
+  };
+  enum dimmer_type_t { DIM_STUFEN = 0, DIM_LDR = 1 };
+  dimmer_t dimmer_stufen;
+  dimmer_t dimmer_ldr;
+
+  // 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;
+  enum fsm_status_t {
+    ST_INAKTIV_LDR = 0,
+    ST_AUFDIMMEN_LDR = 1,
+    ST_ABDIMMEN_LDR = 2,
+    ST_RUHEZUSTAND = 3,
+    ST_AUFDIMMEN_HOCH = 4,
+    ST_WARTEN_HOCH = 5,
+    ST_ABDIMMEN_HOCH = 6,
+    ST_AUFDIMMEN_RUNTER = 7,
+    ST_WARTEN_RUNTER = 8,
+    ST_ABDIMMEN_RUNTER = 9
+  };
+  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);
+  void start_animation(dimmer_t *dimmer, bool dim_type, uint16_t on_pwm,
+                       uint16_t off_pwm);
+  // void berechne_dimmer(dimmer_t* dimmer, bool dim_type);
+  void print_state_on_change();
+
+  /* LDR */
+  bool read_sensor(int sensor);
+  float read_ldr();
+  bool check_ldr();
+
 public:
-    Treppe(uint8_t _stufen) : stufen(_stufen){
-        FSMTreppe_Obj.initialize();
-    }
-    ~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 new_pwm);
-    void set_active_pwm(uint16_t _active_pwm);
-    void set_time_per_stair(uint16_t _time_per_stair);
+  Treppe(uint8_t _stufen) : stufen(_stufen) { FSMTreppe_Obj.initialize(); }
+  ~Treppe() { FSMTreppe_Obj.terminate(); }
+
+  void setup();
+  void task(); // call periodically
+
+  // Parameter section
+  void set_idle_pwm_max(const uint16_t value, const vorgabe_typ_t vorgabe_typ);
+  void set_active_pwm(const uint16_t value, const vorgabe_typ_t vorgabe_typ);
+  void set_time_per_stair(uint16_t _time_per_stair);
 };
 
 #endif // __TREPPE_H