ESP8266 Treppenlichtsteuerung mit OTA zum Firmware Upload
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

treppe.cpp~HEAD 7.3KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256
  1. #include "treppe.h"
  2. uint8_t Treppe::softstart_led(uint8_t led, uint16_t startval, uint16_t stopval){
  3. /*
  4. softstart task
  5. - get's called at regular intervals (1ms at the moment)
  6. - dimms single led (0 - 15, PCA9685 outputs) with linear intervals vom startval to stopval
  7. - calculates pwm steps depending on startval, stopval and timeinterval
  8. - -> results in constanst speed
  9. - returns 1 if led dimming is running
  10. - returns 0 if led dimming is finished
  11. */
  12. static uint8_t lastled = 255;
  13. static float current_pwm = 0;
  14. static float stepsize = 0.5;
  15. if(led != lastled){
  16. pwmController.setChannelPWM(led, (uint16_t)startval);
  17. lastled = led;
  18. current_pwm = startval;
  19. stepsize = INT_TIME*abs(stopval - startval)/(float)time_per_stair; // only valid at 1ms function call interval
  20. return 1;
  21. }
  22. if(startval > stopval){
  23. current_pwm -= stepsize;
  24. }
  25. else {
  26. current_pwm += stepsize;
  27. }
  28. Serial.println((uint16_t)current_pwm);
  29. pwmController.setChannelPWM(led, (uint16_t)current_pwm);
  30. if(current_pwm > stopval - stepsize && current_pwm < stopval + stepsize){
  31. if(stopval == 0) pwmController.setChannelPWM(led, 0);
  32. return 0;
  33. }
  34. return 1;
  35. }
  36. void Treppe::ledsequence(){
  37. static int8_t led = 0;
  38. static uint16_t brightness = 0;
  39. static uint16_t lastbrightness = 0;
  40. static uint16_t status = 0;
  41. uint16_t status_build = 0;
  42. status_build |= direction << 8;
  43. status_build |= state;
  44. if(status_build != status){ // check if any parameter changed
  45. finish = 0; // set state unfinished -> start action
  46. if(direction) led = 0; // reset led counter depending of direction
  47. else led = stairs-1;
  48. if(state){
  49. brightness = active_brightness; // set brightness value depending of on/off
  50. lastbrightness = idle_brightness;
  51. }
  52. else{
  53. brightness = idle_brightness;
  54. lastbrightness = active_brightness;
  55. }
  56. status = status_build; // set parameter memory
  57. Serial.print("----Status Changed! onoff: ");
  58. Serial.print(state);
  59. Serial.print(" dir: ");
  60. Serial.println(direction);
  61. }
  62. if(!finish){ // finish == 0 -> action pending
  63. if(!softstart_led(led,lastbrightness, brightness)){
  64. Serial.print("one LED finished: ");
  65. Serial.print(led);
  66. Serial.print(" last: ");
  67. Serial.print(lastbrightness);
  68. Serial.print(" curr: ");
  69. Serial.println(brightness);
  70. if(direction){
  71. led++;
  72. if(led >= stairs) {
  73. finish = 1;
  74. //lastbrightness = brightness;
  75. }
  76. }
  77. else{
  78. led--;
  79. if(led < 0){
  80. //lastbrightness = brightness;
  81. finish = 1;
  82. }
  83. }
  84. }
  85. }
  86. }
  87. void Treppe::elelel()
  88. {
  89. if(state) {
  90. if(direction) { // aufwärts
  91. if(tick >= ticks_treppe-1) { // ziel erreicht
  92. Serial.println("[Treppe] oberster tick !");
  93. state = 0;
  94. return;
  95. }
  96. tick++; // eins hoch
  97. }
  98. else { // abwärts
  99. if(tick <= 0) { // ziel erreicht
  100. Serial.println("[Treppe] unterster tick !");
  101. state = 0;
  102. return;
  103. }
  104. tick--; // eins runter
  105. }
  106. stufe = tick / ticks_pro_stufe;
  107. float new_pwm = differenz_pwm_pro_tick * (tick - ticks_pro_stufe*stufe);
  108. if(direction)
  109. new_pwm += differenz_pwm_pro_tick;
  110. new_pwm += idle_brightness;
  111. pwmController.setChannelPWM(stufe, (uint16_t) new_pwm);
  112. Serial.printf("tick %04u, led %02d:%02u, pwm %4.1f\n",
  113. tick,
  114. stufe,
  115. (tick - ticks_pro_stufe*stufe),
  116. new_pwm
  117. );
  118. }
  119. }
  120. // if(stufe > stairs || stufe < 0 || tick < 0 || tick > ticks_treppe-1) {
  121. // Serial.println("[Treppe] ERROR, Something went wrong !");
  122. // state = 0;
  123. // return;
  124. // }
  125. void Treppe::setup(){
  126. Serial.printf("differenz_pwm_pro_tick %f\n", differenz_pwm_pro_tick);
  127. pwmController.resetDevices();
  128. <<<<<<< HEAD:lib/treppe/treppe.cpp
  129. // Deactivate PCA9685_PhaseBalancer due to LED Flickering
  130. =======
  131. // Deactive PCA9685 Phase Balancer due to LED Flickering
  132. >>>>>>> master:src/pwm.cpp
  133. // https://github.com/NachtRaveVL/PCA9685-Arduino/issues/15
  134. // see also lib/PCA9685-Arduin/PCA9685.h:204
  135. pwmController.init(PCA9685_PhaseBalancer_None);
  136. pwmController.setPWMFrequency(200);
  137. pwmController.setAllChannelsPWM(idle_brightness);
  138. pinMode(SENSOR1, INPUT);
  139. pinMode(SENSOR2, INPUT);
  140. Serial.println("Hello from Treppe");
  141. Serial.print("Treppe: initial parameters: stairs=");
  142. Serial.println(stairs);
  143. for(uint8_t i=0; i<stairs; i++) {
  144. pwmController.setChannelPWM(i, idle_brightness);
  145. }
  146. }
  147. void Treppe::task(){
  148. <<<<<<< HEAD:lib/treppe/treppe.cpp
  149. //ledsequence();
  150. elelel();
  151. =======
  152. if(finish){
  153. direction = switch_direction;
  154. state = switch_state;
  155. }
  156. static uint8_t last_sensor_state[2] = {0,0};
  157. uint8_t current_sensor_state[2] = {0,0};
  158. current_sensor_state[0] = digitalRead(SENSOR1);
  159. current_sensor_state[1] = digitalRead(SENSOR2);
  160. if(current_sensor_state[0] && !last_sensor_state[0] && state == 0){
  161. setDirection(1);
  162. setState(1);
  163. }
  164. if(current_sensor_state[1] && !last_sensor_state[1] && state == 0){
  165. setDirection(0);
  166. setState(1);
  167. }
  168. // first switch - off approach, use timer later
  169. if(!current_sensor_state[0] && last_sensor_state[0] && state == 1){
  170. setDirection(1);
  171. setState(0);
  172. }
  173. if(!current_sensor_state[1] && last_sensor_state[1] && state == 1){
  174. setDirection(0);
  175. setState(0);
  176. }
  177. last_sensor_state[0] = current_sensor_state[0];
  178. last_sensor_state[1] = current_sensor_state[1];
  179. ledsequence();
  180. >>>>>>> master:src/pwm.cpp
  181. }
  182. uint16_t Treppe::setIdle(uint16_t _idle_brightness){
  183. idle_brightness = _idle_brightness;
  184. Serial.println("Treppe: idle brightness changed!");
  185. return idle_brightness;
  186. }
  187. uint16_t Treppe::setActive(uint16_t _active_brightness){
  188. active_brightness = _active_brightness;
  189. Serial.println("Treppe: active brightness changed!");
  190. return active_brightness;
  191. }
  192. uint16_t Treppe::setTime(uint16_t _time_per_stair){
  193. time_per_stair = _time_per_stair;
  194. Serial.println("Treppe: time changed!");
  195. return time_per_stair;
  196. }
  197. uint8_t Treppe::setDirection(uint8_t _direction){
  198. <<<<<<< HEAD:lib/treppe/treppe.cpp
  199. direction = _direction;
  200. Serial.printf("Treppe: Direction: %d!\n",direction);
  201. =======
  202. switch_direction = _direction;
  203. Serial.println("Treppe: Direction changed!");
  204. if(finish) Serial.println("apply direction request immediately");
  205. else Serial.println("currently active, dir change afterwards");
  206. >>>>>>> master:src/pwm.cpp
  207. // to do: implement state command variable to determine dimm-state
  208. return switch_direction;
  209. }
  210. uint8_t Treppe::setState(uint8_t _state){
  211. if(state == _state) return 1;
  212. else{
  213. <<<<<<< HEAD:lib/treppe/treppe.cpp
  214. state = _state;
  215. Serial.printf("Treppe: State: %d!\n",state);
  216. =======
  217. switch_state = _state;
  218. Serial.println("Treppe: State Request changed!");
  219. if(finish) Serial.println("apply state request immediately");
  220. else Serial.println("currently active, state changes after activity");
  221. >>>>>>> master:src/pwm.cpp
  222. }
  223. return 0;
  224. }