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

forgot smtn in print, spaces to 4

Browse Source
This commit is contained in:
Simon Schmidt 2021-07-03 17:51:14 +02:00
parent b2ddc978b6
commit 8351a6430c
1 changed files with 197 additions and 155 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

352
lib/treppe/treppe.cpp
View File

@ -1,6 +1,7 @@
#include "treppe.h" #include "treppe.h"
uint8_t Treppe::softstart_led(uint8_t led, uint16_t startval, uint16_t stopval){ uint8_t Treppe::softstart_led(uint8_t led, uint16_t startval, uint16_t stopval)
{
/* /*
softstart task softstart task
@ -16,122 +17,147 @@ uint8_t Treppe::softstart_led(uint8_t led, uint16_t startval, uint16_t stopval){
static uint8_t lastled = 255; static uint8_t lastled = 255;
static float current_pwm = 0; static float current_pwm = 0;
static float stepsize = 1.0; static float stepsize = 1.0;
if(led != lastled){ if (led != lastled)
pwmController.setChannelPWM(led, (uint16_t)startval); {
lastled = led; pwmController.setChannelPWM(led, (uint16_t)startval);
current_pwm = startval; lastled = led;
stepsize = INT_TIME*abs(stopval - startval)/(float)time_per_stair; // only valid at 1ms function call interval current_pwm = startval;
return 1; stepsize = INT_TIME * abs(stopval - startval) / (float)time_per_stair; // only valid at 1ms function call interval
return 1;
} }
if(startval > stopval){ if (startval > stopval)
current_pwm -= stepsize; {
current_pwm -= stepsize;
} }
else { else
current_pwm += stepsize; {
current_pwm += stepsize;
} }
// Serial.println((uint16_t)current_pwm); // Serial.println((uint16_t)current_pwm);
pwmController.setChannelPWM(led, (uint16_t)current_pwm); pwmController.setChannelPWM(led, (uint16_t)current_pwm);
if(current_pwm > stopval - stepsize && current_pwm < stopval + stepsize){ if (current_pwm > stopval - stepsize && current_pwm < stopval + stepsize)
if(stopval == 0) pwmController.setChannelPWM(led, 0); {
return 0; if (stopval == 0)
} pwmController.setChannelPWM(led, 0);
return 0;
}
return 1; return 1;
} }
void Treppe::ledsequence(){ void Treppe::ledsequence()
static int8_t led = 0; {
static uint16_t brightness = 0; static int8_t led = 0;
static uint16_t lastbrightness = 0; static uint16_t brightness = 0;
static uint16_t status = 0; static uint16_t lastbrightness = 0;
uint16_t status_build = 0; static uint16_t status = 0;
status_build |= direction << 8; uint16_t status_build = 0;
status_build |= state; status_build |= direction << 8;
if(status_build != status){ // check if any parameter changed status_build |= state;
finish = 0; // set state unfinished -> start action if (status_build != status)
if(direction) led = 0; // reset led counter depending of direction { // check if any parameter changed
else led = stairs-1; finish = 0; // set state unfinished -> start action
if(state){ if (direction)
brightness = active_brightness; // set brightness value depending of on/off led = 0; // reset led counter depending of direction
lastbrightness = idle_brightness; else
} led = stairs - 1;
else{ if (state)
brightness = idle_brightness; {
lastbrightness = active_brightness; brightness = active_brightness; // set brightness value depending of on/off
} lastbrightness = idle_brightness;
status = status_build; // set parameter memory }
else
{
brightness = idle_brightness;
lastbrightness = active_brightness;
}
status = status_build; // set parameter memory
Serial.printf("----Status Changed! onoff: %d, dir: %d\n", state, direction); Serial.printf("----Status Changed! onoff: %d, dir: %d\n", state, direction);
} }
if(!finish){ // finish == 0 -> action pending if (!finish)
if(!softstart_led(led,lastbrightness, brightness)){ { // finish == 0 -> action pending
Serial.printf("one LED finished: led: %d, last: %d, curr %d\n", if (!softstart_led(led, lastbrightness, brightness))
led, lastbrightness, brightness); {
Serial.printf("one LED finished: led: %d, last: %d, curr %d\n",
if(direction){ led, lastbrightness, brightness);
led++;
if(led >= stairs) if (direction)
finish = 1; {
} led++;
else{ if (led >= stairs)
led--; finish = 1;
if(led < 0) }
finish = 1; else
} {
led--;
if (led < 0)
finish = 1;
}
}
} }
}
} }
void Treppe::rampe() void Treppe::rampe()
{ {
if(state) { if (state)
finish = 0; {
state = 0;// set parameter memory finish = 0;
} state = 0; // set parameter memory
if(!finish) {
if(direction) { // aufwärts
if(tick >= ticks_treppe-1) { // ziel erreicht
Serial.println("[Treppe] oberster tick !");
finish = 1;
return;
}
tick++; // eins hoch
}
else { // abwärts
if(tick <= 0) { // ziel erreicht
Serial.println("[Treppe] unterster tick !");
finish = 1;
return;
}
tick--; // eins runter
} }
stufe = tick / ticks_pro_stufe; if (!finish)
{
if (direction)
{ // aufwärts
if (tick >= ticks_treppe - 1)
{ // ziel erreicht
Serial.println("[Treppe] oberster tick !");
finish = 1;
return;
}
tick++; // eins hoch
}
else
{ // abwärts
if (tick <= 0)
{ // ziel erreicht
Serial.println("[Treppe] unterster tick !");
finish = 1;
return;
}
tick--; // eins runter
}
float new_pwm = 0.0; stufe = tick / ticks_pro_stufe;
if(an_aus) {
new_pwm = differenz_pwm_pro_tick * (tick - ticks_pro_stufe*stufe);
new_pwm += idle_brightness;
if(direction) new_pwm += differenz_pwm_pro_tick;
}
else {
new_pwm = active_brightness - differenz_pwm_pro_tick * (tick - ticks_pro_stufe*stufe);
new_pwm += idle_brightness;
if(direction) new_pwm -= differenz_pwm_pro_tick;
}
pwmController.setChannelPWM(stufe, (uint16_t) new_pwm); float new_pwm = 0.0;
Serial.printf("tick %04u, led %02d:%02u, pwm %4.1f\n", if (an_aus)
tick, {
stufe, new_pwm = differenz_pwm_pro_tick * (tick - ticks_pro_stufe * stufe);
(tick - ticks_pro_stufe*stufe), new_pwm += idle_brightness;
new_pwm if (direction)
); new_pwm += differenz_pwm_pro_tick;
} }
else
{
new_pwm = active_brightness - differenz_pwm_pro_tick * (tick - ticks_pro_stufe * stufe);
new_pwm += idle_brightness;
if (direction)
new_pwm -= differenz_pwm_pro_tick;
}
pwmController.setChannelPWM(stufe, (uint16_t)new_pwm);
Serial.printf("tick %04u, led %02d:%02u, pwm %4.1f\n",
tick,
stufe,
(tick - ticks_pro_stufe * stufe),
new_pwm);
}
} }
void Treppe::setup(){ void Treppe::setup()
{
pwmController.resetDevices(); pwmController.resetDevices();
// Deactive PCA9685 Phase Balancer due to LED Flickering // Deactive PCA9685 Phase Balancer due to LED Flickering
@ -141,7 +167,7 @@ void Treppe::setup(){
//pwmController.init(PCA9685_PhaseBalancer_Linear); //pwmController.init(PCA9685_PhaseBalancer_Linear);
pwmController.setPWMFrequency(100); pwmController.setPWMFrequency(100);
pwmController.setAllChannelsPWM(idle_brightness); pwmController.setAllChannelsPWM(idle_brightness);
pinMode(A0, INPUT); pinMode(A0, INPUT);
pinMode(SENSOR_OBEN, INPUT); pinMode(SENSOR_OBEN, INPUT);
pinMode(SENSOR_UNTEN, INPUT); pinMode(SENSOR_UNTEN, INPUT);
@ -154,89 +180,105 @@ void Treppe::setup(){
Serial.println(stairs); Serial.println(stairs);
} }
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; static FSMTreppeModelClass::ExtU_FSMTreppe_T last_in;
if( static FSMTreppeModelClass::ExtY_FSMTreppe_T last_out;
fsm_inputs.anim_beendet != last_in.anim_beendet || if (
fsm_inputs.sensor_oben != last_in.sensor_oben || fsm_inputs.anim_beendet != last_in.anim_beendet ||
fsm_inputs.sensor_unten != last_in.sensor_unten || fsm_inputs.sensor_oben != last_in.sensor_oben ||
fsm_outputs.dimmrichtung != last_out.dimmrichtung || fsm_inputs.sensor_unten != last_in.sensor_unten ||
fsm_outputs.laufrichtung != last_out.laufrichtung || fsm_outputs.dimmrichtung != last_out.dimmrichtung ||
fsm_outputs.status != last_out.status 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.anim_beendet = fsm_inputs.anim_beendet;
last_in.sensor_unten = fsm_inputs.sensor_unten; last_in.sensor_oben = fsm_inputs.sensor_oben;
last_in.sensor_unten = fsm_inputs.sensor_unten;
last_out.dimmrichtung = fsm_outputs.dimmrichtung;
last_out.laufrichtung = fsm_outputs.laufrichtung;
last_out.status = fsm_outputs.status;
Serial.printf("FSM IN: s_u: %d, s_o: %d, beendet: %d =>", Serial.printf("FSM IN: s_u: %d, s_o: %d, beendet: %d =>",
fsm_inputs.sensor_oben, fsm_inputs.sensor_unten, fsm_inputs.anim_beendet); fsm_inputs.sensor_oben, fsm_inputs.sensor_unten, fsm_inputs.anim_beendet);
Serial.print(" step => "); Serial.print(" step => ");
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.dimmrichtung, fsm_outputs.status); fsm_outputs.laufrichtung, fsm_outputs.dimmrichtung, fsm_outputs.status);
} }
} }
void Treppe::task(){ void Treppe::task()
//Serial.printf("LDR: %f\n", ((float)analogRead(A0))/1023.*3.68); {
//Serial.printf("LDR: %f\n", ((float)analogRead(A0))/1023.*3.68);
if(finish){ if (finish)
direction = switch_direction; {
state = switch_state; direction = switch_direction;
} state = switch_state;
}
fsm_inputs.ldr_schwelle = true; fsm_inputs.ldr_schwelle = true;
fsm_inputs.sensor_oben = read_sensor(SENSOR_OBEN); fsm_inputs.sensor_oben = read_sensor(SENSOR_OBEN);
fsm_inputs.sensor_unten = read_sensor(SENSOR_UNTEN); fsm_inputs.sensor_unten = read_sensor(SENSOR_UNTEN);
fsm_inputs.anim_beendet = static_cast<bool>(finish); fsm_inputs.anim_beendet = static_cast<bool>(finish);
FSMTreppe_Obj.setExternalInputs(&fsm_inputs); FSMTreppe_Obj.setExternalInputs(&fsm_inputs);
FSMTreppe_Obj.step(); FSMTreppe_Obj.step();
fsm_outputs = FSMTreppe_Obj.getExternalOutputs(); fsm_outputs = FSMTreppe_Obj.getExternalOutputs();
print_state_on_change(); print_state_on_change();
direction = fsm_outputs.laufrichtung; direction = fsm_outputs.laufrichtung;
state = fsm_outputs.dimmrichtung; state = fsm_outputs.dimmrichtung;
// setTick(ticks_treppe); // setTick(ticks_treppe);
// setAnAus(1); // setAnAus(1);
// setDirection(0); // setDirection(0);
// setState(0); // setState(0);
ledsequence(); ledsequence();
} }
uint16_t Treppe::setIdle(uint16_t _idle_brightness)
uint16_t Treppe::setIdle(uint16_t _idle_brightness){ {
idle_brightness = _idle_brightness; idle_brightness = _idle_brightness;
Serial.println("Treppe: idle brightness changed!"); Serial.println("Treppe: idle brightness changed!");
return idle_brightness; return idle_brightness;
} }
uint16_t Treppe::setActive(uint16_t _active_brightness){ uint16_t Treppe::setActive(uint16_t _active_brightness)
{
active_brightness = _active_brightness; active_brightness = _active_brightness;
Serial.println("Treppe: active brightness changed!"); Serial.println("Treppe: active brightness changed!");
return active_brightness; return active_brightness;
} }
uint16_t Treppe::setTime(uint16_t _time_per_stair){ uint16_t Treppe::setTime(uint16_t _time_per_stair)
{
time_per_stair = _time_per_stair; time_per_stair = _time_per_stair;
Serial.println("Treppe: time changed!"); Serial.println("Treppe: time changed!");
return time_per_stair; return time_per_stair;
} }
void Treppe::setDirection(uint8_t _direction){ void Treppe::setDirection(uint8_t _direction)
{
switch_direction = _direction; switch_direction = _direction;
Serial.printf("Treppe: switch_direction=%d!\n", switch_direction); Serial.printf("Treppe: switch_direction=%d!\n", switch_direction);
if(finish) Serial.println("apply direction request immediately"); if (finish)
else Serial.println("currently active, dir change afterwards"); Serial.println("apply direction request immediately");
else
Serial.println("currently active, dir change afterwards");
// to do: implement state command variable to determine dimm-state // to do: implement state command variable to determine dimm-state
} }
void Treppe::setState(uint8_t _state){ void Treppe::setState(uint8_t _state)
if(state == _state) return; {
else { if (state == _state)
switch_state = _state; return;
Serial.printf("Treppe: switch_state=%d!\n", switch_state); else
if(finish) Serial.println("apply state request immediately"); {
else Serial.println("currently active, state changes after activity"); switch_state = _state;
} Serial.printf("Treppe: switch_state=%d!\n", switch_state);
if (finish)
Serial.println("apply state request immediately");
else
Serial.println("currently active, state changes after activity");
}
} }