zero duty cycle fix

.gitignore

@@ -1,8 +1,6 @@
 .pio
-.vscode/.browse.c_cpp.db*
+.vscode
-.vscode/c_cpp_properties.json
+compress
-.vscode/launch.json
-.vscode/ipch
 platformio.ini
 include/wifi_credentials.h
 include/*.gz.h

.gitmodules

@@ -0,0 +1,3 @@
+[submodule "lib/PCA9685-Arduino"]
+	path = lib/PCA9685-Arduino
+	url = https://github.com/NachtRaveVL/PCA9685-Arduino

.vscode/settings.json

@@ -1,5 +1,52 @@
 {
     "files.associations": {
-        "random": "cpp"
+        "random": "cpp",
+        "array": "cpp",
+        "*.tcc": "cpp",
+        "deque": "cpp",
+        "list": "cpp",
+        "string": "cpp",
+        "unordered_map": "cpp",
+        "vector": "cpp",
+        "string_view": "cpp",
+        "memory": "cpp",
+        "ranges": "cpp",
+        "initializer_list": "cpp",
+        "utility": "cpp",
+        "atomic": "cpp",
+        "bit": "cpp",
+        "cctype": "cpp",
+        "clocale": "cpp",
+        "cmath": "cpp",
+        "compare": "cpp",
+        "concepts": "cpp",
+        "cstdarg": "cpp",
+        "cstddef": "cpp",
+        "cstdint": "cpp",
+        "cstdio": "cpp",
+        "cstdlib": "cpp",
+        "cstring": "cpp",
+        "cwchar": "cpp",
+        "cwctype": "cpp",
+        "map": "cpp",
+        "set": "cpp",
+        "exception": "cpp",
+        "algorithm": "cpp",
+        "functional": "cpp",
+        "iterator": "cpp",
+        "memory_resource": "cpp",
+        "numeric": "cpp",
+        "optional": "cpp",
+        "system_error": "cpp",
+        "tuple": "cpp",
+        "type_traits": "cpp",
+        "iosfwd": "cpp",
+        "limits": "cpp",
+        "new": "cpp",
+        "ostream": "cpp",
+        "stdexcept": "cpp",
+        "streambuf": "cpp",
+        "cinttypes": "cpp",
+        "typeinfo": "cpp"
     }
 }

README.md

@@ -17,5 +17,23 @@ https://arduino-esp8266.readthedocs.io/en/latest/ota_updates/readme.html
 ```
 
 ##### platformio.ini
-change IP of esp8266 accordingly
+see templ_platformio_ini
-IP gets printed on Serial Monitor after first Upload
+
+```ini
+[env:<BOARD>]
+platform = espressif8266
+board = <BOARD>
+framework = arduino
+monitor_speed = 115200
+
+extra_scripts = pre:extra_script.py
+
+; stuff for OTA 
+; https://docs.platformio.org/en/latest/platforms/espressif8266.html#over-the-air-ota-update
+upload_protocol = espota
+upload_port = <IPADRESS>
+upload_flags =
+  --port=8266
+  --auth=admin
+```
+

create_gz_files.py

@@ -1,3 +1,4 @@
+#!/usr/bin/python3
 
 import os, gzip
 # https://www.mischianti.org/2020/10/26/web-server-with-esp8266-and-esp32-byte-array-gzipped-pages-and-spiffs-2/
@@ -27,8 +28,11 @@ def convert_to_gzip(src, out, f):
             f_out.write(top.encode(encoding='utf-8'))
 
 
-src='include/http/'
+src='data/'
-out='include/'
+out='compress/'
+
+if not 'compress' in os.listdir():
+    os.mkdir('compress')
 
 for f in os.listdir(src):
     convert_to_gzip(src, out, f)

data/index.html

@@ -0,0 +1,67 @@
+<!DOCTYPE html>
+<html>
+
+<head>
+  <title>ESP8266 Treppenlicht</title>
+  <!-- main style sheet -->
+  <link href="/favicon.png" rel="icon" type="image/png" sizes="10x10">
+  <link href="/style.css" rel="stylesheet" type="text/css">
+</head>
+
+<body>
+  <div class="kopfzeile" style="text-align: center;">
+    <b>Treppenlicht</b>
+  </div>
+
+  <div class="ueberschrift">
+    Helligkeit
+    <!--<label id="label_pwm">
+      </label>-->
+      <div class="slider">
+        <input type="range" class="regler" id="helligkeit" name="rangeInput" min="0" max="100" value="50"
+          oninput="amount1.value=helligkeit.value">
+        <br>
+        <output name="amount1" id="amount1" for="helligkeit">50</output>
+      </div>
+  </div>
+  <div class="ueberschrift">
+    Helligkeit bei Dunkelheit
+    <!--<label id="label_pwm_dark">
+      </label>-->
+      <div class="slider">
+        <input type="range" class="regler" id="helligkeit_dunkel" name="rangeInput" min="0" max="100" value="50"
+          oninput="amount2.value=helligkeit_dunkel.value">
+        <br>
+        <output name="amount2" id="amount2" for="helligkeit_dunkel">50</output>
+      </div>
+  </div>
+
+  <div class="ueberschrift">
+    Laufgeschwindigkeit
+    <!--<label id="label_geschwindigkeit">
+      </label>-->
+          <div class="slider">
+            <input type="range" class="regler" id="geschwindigkeit" name="rangeInput" min="0" max="100" value="50"
+              oninput="amount3.value=geschwindigkeit.value">
+            <br>
+            <output name="amount3" id="amount3" for="geschwindigkeit">50</output>
+          </div>
+  </div>
+
+  <div class="ueberschrift">
+    Licht-An-Zeit
+    <!--  <label id="label_time">
+        </label>-->
+        <div class="slider">
+          <input type="range" class="regler" id="time" name="rangeInput" min="0" max="100" value="50"
+            oninput="amount4.value=time.value">
+          <br>
+          <output name="amount4" id="amount4" for="time">50</output>
+        </div>
+  </div>
+
+</body>
+
+<script src="/input.js"></script>
+
+</html>

data/input.js

@@ -0,0 +1,8 @@
+var slider = document.getElementById("range1");
+var output = document.getElementById("l_pwm");
+output.innerHTML = slider.value; // Display the default slider value
+
+// Update the current slider value (each time you drag the slider handle)
+slider.oninput = function() {
+  output.innerHTML = this.value;
+}

data/style.css

@@ -0,0 +1,106 @@
+html {
+  font-size: 16px;
+  font-family: sans-serif, Arial, Helvetica;
+  background-color: #d4d4d4;
+  height: 100%;
+  background-image: url('Background.png');
+  background-repeat: repeat;
+  background-size: 150% 150%;
+}
+
+body {
+  height: 100%;
+  margin: 0 auto;
+  border: none;
+  border-radius: 3;
+}
+
+.topbar {
+  padding: 1em;
+  background-color: #1f1f1f;
+  color: white;
+  font-size: x-large;
+  text-align: center;
+}
+
+.ueberschrift{
+  color: #ffffff;
+  font-size: 50px;
+  width: 100%;
+  text-align: center;
+}
+
+.regler{
+
+  -webkit-appearance: none;
+  height: 30px;
+  width: 100%;
+  border-radius: 20px;
+  outline: black;
+  background-color: rgb(176, 188, 228);
+}
+.regler::-webkit-slider-thumb{
+  -webkit-appearance: none;
+  appearance: none;
+  width: 5%;
+  height: 20px;
+  border-radius: 10px;
+  background-color: rgb(107, 122, 192);
+  cursor:pointer;
+}
+input[type=range]::-webkit-slider-thumb{
+  -webkit-appearance: none;
+  border:none;
+  height: 30px;
+  width: 4%;
+  border-radius: 30px;
+}
+.slider {
+  width: 100%;
+}
+
+.kopfzeile{
+  color: #1f1f1f;
+  font-size: 50px;
+  width: 100%;
+  background-color: #8d8a8a;
+}
+
+
+
+
+/*-------------------------------------------------------*/
+
+
+/*Switch:
+.switch {
+  position: relative;
+  display: inline-block;
+  width: 60px;
+  height: 34px;
+}
+
+Hide default HTML checkbox
+.switch input {
+  opacity: 0;
+  width: 0;
+  height: 0;
+}
+*/
+/* The slider */
+
+
+/*input:checked + .slider {
+  background-color: #04AA6D;
+}
+
+input:focus + .slider {
+  box-shadow: 0 0 1px #04AA6D;
+}*/
+/*
+input:checked + .slider:before {
+  -webkit-transform: translateX(26px);
+  -ms-transform: translateX(26px);
+  transform: translateX(26px);
+}
+

doku.md

@@ -0,0 +1,74 @@
+Hardware Timer didnt work https://github.com/khoih-prog/ESP8266TimerInterrupt#why-using-isr-based-hardware-timer-interrupt-is-better
+
+=> Software Timer https://ullisroboterseite.de/esp8266-timing.html#timer
+
+
+
+
+### __Zum aktivieren von GDBStub:__
+```c
+#include <GDBStub.h>
+
+...
+
+void setup() {
+  Serial.begin(460800);
+  gdbstub_init();
+```
+
+### __Achtung !__
+GDB muss dafür compiled werden
+GDB-Version aus Arduino Toolchain hat Support
+
+```sh
+$ ./start_xtensa_gdb_stub.sh
+```
+
+### __Achtung !__
+Don`t forget __\r__
+
+ESP-OTA wird von ufw oder Defender geblockt.
+- Windows -> Python needs to be granted with rights
+- Linux -> open udp port in ufw -> 
+
+```sh
+platform.ini 
+upload_flags =
+  --host-port <PORT>
+...
+$ sudo ufw allow tcp/<PORT>
+```
+
+
+```c++
+server.streamFile(f, mime::getContentType(SRH::_path), requestMethod);
+
+=====>
+
+const String& p = SRH::_path;
+if(p.endsWith(".gzip")) {
+    server.sendHeader("Content-Encoding", "gzip");
+    server.streamFile(f, mime::getContentType(p.substring(0, p.length()-5)), requestMethod);
+}
+else
+    server.streamFile(f, mime::getContentType(SRH::_path), requestMethod);
+```
+
+LED_sequence_v1:
+TODO: 
+- disable led stripes after defined time (webserver paramter?)
+- define what to do if people enter stairs from different directions
+- CAUTION: Sensor-Deadtime at LEAST 8 seconds
+- --> switch off with person leaving stairs might not be possible
+
+Webserver on v0.3.0 now working with LittleFS
+TODO:
+- check dir for files automatic
+- move handleNotFound to httpserver.h
+- maybe compress files ?
+
+
+LED Flickering issue
+https://github.com/NachtRaveVL/PCA9685-Arduino/issues/15
+
+PlatformIO Library veraltet

include/filesys.h

@@ -0,0 +1,16 @@
+#ifndef __FILESYS_H
+#define __FILESYS_H
+
+#include <LittleFS.h>
+
+bool mount_fs();
+bool format_fs();
+
+void ls(const char * dirname);
+void readFile(const char * path);
+void writeFile(const char * path, const char * message);
+void appendFile(const char * path, const char * message);
+void renameFile(const char * path1, const char * path2);
+void deleteFile(const char * path);
+
+#endif // __FILESYS_H

include/http/index.html

@@ -1,23 +0,0 @@
-<!DOCTYPE html>
-<html>
-  <head>
-    <meta charset="utf-8">
-    <title>My test page</title>
-    <link href="http://fonts.googleapis.com/css?family=Open+Sans" rel="stylesheet" type="text/css">
-    <link href="styles/style.css" rel="stylesheet" type="text/css">
-  </head>
-  <body>
-    <h1>Mozilla is cool</h1>
-    <p>At Mozilla, we’re a global community of</p>
-
-    <ul> <!-- changed to list in the tutorial -->
-      <li>technologists</li>
-      <li>thinkers</li>
-      <li>builders</li>
-    </ul>
-
-    <p>working together to keep the Internet alive and accessible, so people worldwide can be informed contributors and creators of the Web. We believe this act of human collaboration across an open platform is essential to individual growth and our collective future.</p>
-
-    <p>Read the <a href="https://www.mozilla.org/en-US/about/manifesto/">Mozilla Manifesto</a> to learn even more about the values and principles that guide the pursuit of our mission.</p>
-  </body>
-</html>

include/http/style.css

@@ -1,41 +0,0 @@
-html {
-  font-size: 10px;
-  font-family: 'Open Sans', sans-serif;
-}
-
-
-h1 {
-  font-size: 60px;
-  text-align: center;
-}
-
-p, li {
-  font-size: 16px;
-  line-height: 2;
-  letter-spacing: 1px;
-}
-
-
-html {
-  background-color: #00539F;
-}
-
-body {
-  width: 600px;
-  margin: 0 auto;
-  background-color: #FF9500;
-  padding: 0 20px 20px 20px;
-  border: 5px solid black;
-}
-
-h1 {
-  margin: 0;
-  padding: 20px 0;
-  color: #00539F;
-  text-shadow: 3px 3px 1px black;
-}
-
-img {
-  display: block;
-  margin: 0 auto;
-}

include/httpserver.h

@@ -0,0 +1,48 @@
+#ifndef __HTTPSERVER_H
+#define __HTTPSERVER_H
+
+#include "filesys.h"
+#include <ESP8266WebServer.h>
+
+
+class HTTPServer : public ESP8266WebServer {
+private:
+    const char* rootDir;
+ 
+    bool addRootFileHandler();
+    bool formatFS() {
+        return format_fs();
+    }
+    void listRoot() {
+        ls(rootDir);
+    }
+
+public:
+    HTTPServer(const int _port, const char* _rootDir) :
+       ESP8266WebServer(_port), rootDir(_rootDir)
+    { }
+    ~HTTPServer() 
+    {
+        Serial.printf("[HTTPServer] shut down ...\n\r");
+    }
+
+    bool start() {
+        if(!mount_fs())
+            return false;
+        Serial.printf("[HTTPServer] LittleFS mounted !\n\r");
+
+        Serial.printf("[HTTPServer] root:\n\r");
+        this->listRoot();
+        Serial.printf("\n\r");
+
+        if( this->addRootFileHandler() ){
+            this->begin();
+            Serial.printf("[HTTPServer] Server active on Port 80 !\n\r");
+            return true;
+        }
+        Serial.printf("[HTTPServer] Not starting Server, something went wrong !\n\r");
+        return false;
+    }
+};
+
+#endif // __HTTPSERVER_H

include/index.html.gz.h

@@ -1,61 +0,0 @@
-// filename: index.html.gz.h
-#define index_html_gz_len 573
-const char index_html_gz[] = {
- 0x1F, 0x8B, 0x08, 0x00, 0xB4, 0x6E, 0xC7, 0x60, 0x02, 0xFF, 
- 0x8D, 0x53, 0xCB, 0x8E, 0xD4, 0x30, 0x10, 0xBC, 0x23, 0xF1, 
- 0x0F, 0xBD, 0xB9, 0xB2, 0x13, 0x6B, 0x6F, 0x08, 0x65, 0x82, 
- 0x10, 0x70, 0xE0, 0x30, 0x5A, 0xC4, 0x82, 0x10, 0x47, 0xC7, 
- 0xE9, 0x24, 0xD6, 0x38, 0x6E, 0xCB, 0x6E, 0x6F, 0x18, 0x4E, 
- 0xFC, 0x06, 0xBF, 0xC7, 0x97, 0xD0, 0xCE, 0x64, 0x16, 0x56, 
- 0x70, 0xE0, 0x92, 0x87, 0xAB, 0x1F, 0x55, 0xD5, 0xED, 0xE6, 
- 0xEA, 0xCD, 0xED, 0xEB, 0x8F, 0x5F, 0xDE, 0xBF, 0x85, 0x89, 
- 0x67, 0xD7, 0x3E, 0x7D, 0xD2, 0x6C, 0x6F, 0x80, 0x66, 0x42, 
- 0xDD, 0xAF, 0x5F, 0xF2, 0x3D, 0x23, 0x6B, 0x30, 0x93, 0x8E, 
- 0x09, 0x79, 0x5F, 0x65, 0x1E, 0x76, 0xCF, 0xAB, 0x0B, 0xC6, 
- 0x96, 0x1D, 0xB6, 0x87, 0x13, 0x30, 0x26, 0x86, 0xA0, 0x47, 
- 0x6C, 0xD4, 0xF9, 0x6C, 0x0B, 0x70, 0xD6, 0x1F, 0x61, 0x8A, 
- 0x38, 0xEC, 0xAB, 0x89, 0x39, 0xBC, 0x50, 0x6A, 0x20, 0xCF, 
- 0xA9, 0x1E, 0x89, 0x46, 0x87, 0x3A, 0xD8, 0x54, 0x1B, 0x9A, 
- 0x95, 0x49, 0xE9, 0xE5, 0xA0, 0x67, 0xEB, 0x4E, 0xFB, 0xDB, 
- 0x80, 0xFE, 0xD9, 0x9D, 0xF6, 0xA9, 0x82, 0x88, 0x6E, 0x5F, 
- 0x25, 0x3E, 0x39, 0x4C, 0x13, 0x22, 0x57, 0xC0, 0xA7, 0x80, 
- 0xFB, 0x8A, 0xF1, 0x2B, 0x97, 0x8C, 0xEA, 0x1F, 0x4D, 0xCE, 
- 0xD1, 0x6A, 0x7D, 0xD5, 0x25, 0xE6, 0xFF, 0x8A, 0x34, 0xEA, 
- 0x41, 0x71, 0xD3, 0x51, 0x7F, 0xBA, 0x54, 0x9E, 0x6E, 0xDA, 
- 0x03, 0x7D, 0xB3, 0xCE, 0x69, 0xB0, 0x09, 0x0C, 0x91, 0x93, 
- 0xC8, 0x9B, 0x0B, 0x1A, 0xDA, 0x57, 0x0C, 0x1B, 0x7E, 0x0D, 
- 0x0B, 0xFE, 0xFC, 0xFE, 0x23, 0x22, 0x68, 0x18, 0x1D, 0x75, 
- 0xDA, 0x49, 0xF8, 0x3C, 0x67, 0x6F, 0xF9, 0x04, 0x34, 0x34, 
- 0x2A, 0x48, 0xD6, 0x96, 0x97, 0x5D, 0x0B, 0xCD, 0xD5, 0x6E, 
- 0x57, 0x5C, 0xF5, 0x23, 0xF6, 0xC0, 0x04, 0xCE, 0x8A, 0x81, 
- 0xD6, 0x03, 0x4F, 0x08, 0x9C, 0x99, 0xA2, 0x95, 0x0A, 0xBB, 
- 0xDD, 0xD6, 0x6A, 0x15, 0xD9, 0x32, 0x9A, 0xC9, 0x93, 0xA3, 
- 0x51, 0x62, 0x53, 0xA3, 0xE4, 0xE4, 0x11, 0x3A, 0x89, 0x0D, 
- 0x18, 0xFF, 0x06, 0xBA, 0x6C, 0x5D, 0xFF, 0x18, 0x68, 0x54, 
- 0x76, 0xBF, 0xF9, 0x84, 0x76, 0xA1, 0x78, 0xB4, 0x7E, 0x14, 
- 0x22, 0x23, 0x0A, 0x83, 0x58, 0x18, 0x1D, 0x11, 0xC3, 0x4A, 
- 0xE7, 0x9D, 0x67, 0x8C, 0x1E, 0x19, 0xB4, 0xB3, 0xF7, 0xA2, 
- 0xCF, 0xF7, 0xA0, 0x8D, 0xC1, 0x94, 0x6C, 0xE7, 0xF0, 0x1A, 
- 0x12, 0x41, 0x40, 0x0A, 0x0E, 0x41, 0xAA, 0xB8, 0x7E, 0xB1, 
- 0x3D, 0x82, 0xD1, 0x1E, 0x3A, 0x14, 0x3D, 0x03, 0xC5, 0x59, 
- 0x04, 0x1A, 0x19, 0x7A, 0xB4, 0x5D, 0xD1, 0x95, 0xD6, 0x02, 
- 0x26, 0xA2, 0x5E, 0x7F, 0x68, 0x58, 0x7B, 0x7C, 0xC6, 0xAE, 
- 0x96, 0x87, 0x24, 0x39, 0x8B, 0xD2, 0x44, 0xC4, 0x48, 0xA0, 
- 0xE1, 0x82, 0x4F, 0x79, 0x96, 0x72, 0x86, 0xC4, 0xE5, 0x8E, 
- 0xA2, 0x66, 0x4B, 0x5E, 0xA0, 0x48, 0xA9, 0x94, 0x02, 0x92, 
- 0x7D, 0x81, 0xE0, 0x34, 0x97, 0x56, 0x65, 0x4A, 0x42, 0x0C, 
- 0x3D, 0x17, 0xFB, 0x44, 0x84, 0xF5, 0xBD, 0xBD, 0xB7, 0x7D, 
- 0x96, 0xBF, 0x31, 0xD2, 0xC2, 0xD3, 0xDA, 0x9D, 0x72, 0x5C, 
- 0xEB, 0xA1, 0xE1, 0xA2, 0x68, 0xC8, 0x9C, 0x23, 0xD6, 0x8F, 
- 0x66, 0x14, 0xDA, 0x0F, 0xB2, 0x11, 0x2B, 0xB7, 0x46, 0xFF, 
- 0xB1, 0xC1, 0x49, 0x56, 0x78, 0x59, 0x96, 0x7A, 0x3E, 0x8F, 
- 0xBD, 0xA6, 0x38, 0x2A, 0xF4, 0xBB, 0x4F, 0x77, 0x4A, 0xC8, 
- 0x65, 0x56, 0x42, 0xD5, 0x0E, 0x72, 0x19, 0x48, 0x55, 0x0F, 
- 0xAB, 0x73, 0xB8, 0x9C, 0x35, 0x4A, 0xB7, 0xEB, 0xB0, 0x51, 
- 0x47, 0x0F, 0xA2, 0xD3, 0xC3, 0x4C, 0x65, 0x65, 0x4A, 0xEA, 
- 0xDA, 0xEB, 0x5E, 0xBB, 0x8C, 0x67, 0x8B, 0x42, 0xB4, 0xDE, 
- 0x58, 0xF1, 0x35, 0x09, 0xA2, 0x19, 0xC6, 0x5C, 0x9C, 0x2D, 
- 0x41, 0x21, 0xC7, 0x94, 0xED, 0xEA, 0x4D, 0x51, 0x32, 0x5B, 
- 0x19, 0x05, 0xF9, 0x8D, 0x7F, 0x19, 0xEE, 0xB6, 0xC2, 0xB2, 
- 0xAB, 0xE7, 0x1B, 0xFD, 0x0B, 0xD0, 0xF5, 0x7E, 0xB7, 0xEB, 
- 0x03, 0x00, 0x00};

include/ota.h

@@ -0,0 +1,52 @@
+#ifndef __OTA_H
+#define __OTA_H
+
+#include <ESP8266WiFi.h>
+#include <WiFiUdp.h>
+#include <ArduinoOTA.h>
+
+void ota_setup() {
+  ArduinoOTA.setPort(8266);
+  ArduinoOTA.setHostname("ESP_Treppenlicht");
+  ArduinoOTA.setPassword("admin");
+  // Password can be set with it's md5 value as well
+  // MD5(admin) = 21232f297a57a5a743894a0e4a801fc3
+  // ArduinoOTA.setPasswordHash("21232f297a57a5a743894a0e4a801fc3");
+
+  ArduinoOTA.onStart([]() {
+    String type;
+    if (ArduinoOTA.getCommand() == U_FLASH) {
+      type = "sketch";
+    } else { // U_FS
+      type = "filesystem";
+    }
+
+    // NOTE: if updating FS this would be the place to unmount FS using FS.end()
+    Serial.println("Start updating " + type);
+  });
+  ArduinoOTA.onEnd([]() {
+    Serial.println("\nEnd");
+  });
+  ArduinoOTA.onProgress([](unsigned int progress, unsigned int total) {
+    Serial.printf("Progress: %u%%\r", (progress / (total / 100)));
+  });
+  ArduinoOTA.onError([](ota_error_t error) {
+    Serial.printf("Error[%u]: ", error);
+    if (error == OTA_AUTH_ERROR) {
+      Serial.println("Auth Failed");
+    } else if (error == OTA_BEGIN_ERROR) {
+      Serial.println("Begin Failed");
+    } else if (error == OTA_CONNECT_ERROR) {
+      Serial.println("Connect Failed");
+    } else if (error == OTA_RECEIVE_ERROR) {
+      Serial.println("Receive Failed");
+    } else if (error == OTA_END_ERROR) {
+      Serial.println("End Failed");
+    }
+  });
+  ArduinoOTA.begin();
+
+}
+
+
+#endif // __OTA_H

include/pwm.h

@@ -0,0 +1,44 @@
+#pragma once
+
+#include "PCA9685.h"
+
+#define SENSOR1 15
+#define SENSOR2 12
+
+#define INT_TIME 20         // interrupt intervall [ms]
+class Treppe {
+    private:
+    uint8_t stairs;
+    uint16_t time_per_stair = 200;          // dimmtime per stair [ms]
+    uint16_t idle_brightness = 0;
+    uint16_t active_brightness = 1048;
+
+    uint8_t direction = 0;
+    uint8_t switch_direction = 0;
+    uint8_t state = 0;
+    uint8_t switch_state = 0;
+    uint8_t finish = 1;
+
+    // initialize with i2c-Address 0, use Wire Library
+    PCA9685 pwmController;     
+    uint8_t softstart_led(uint8_t led, uint16_t startval, uint16_t stopval);
+    void ledsequence();
+
+    public:
+    Treppe(uint8_t _stairs) : stairs(_stairs){}
+    void task();        // call periodically
+
+    void setup();
+
+    // Parameter section
+    uint16_t setIdle(uint16_t _idle_brightness);
+    uint16_t setActive(uint16_t _active_brightness);
+    uint16_t setTime(uint16_t _time_per_stair);
+
+    // Runtime Parameter section
+    uint8_t setDirection(uint8_t _direction);
+    uint8_t setState(uint8_t _state);
+
+    uint8_t getState() { return state;};
+    uint8_t getDirection() {return direction;};
+};

include/style.css.gz.h

@@ -1,32 +0,0 @@
-// filename: style.css.gz.h
-#define style_css_gz_len 283
-const char style_css_gz[] = {
- 0x1F, 0x8B, 0x08, 0x00, 0xB4, 0x6E, 0xC7, 0x60, 0x02, 0xFF, 
- 0x75, 0x51, 0xC1, 0x8A, 0xC3, 0x20, 0x10, 0xBD, 0x17, 0xFA, 
- 0x0F, 0x03, 0x7B, 0xE8, 0xA5, 0x82, 0x6D, 0x49, 0xA1, 0xF6, 
- 0x9E, 0x6B, 0x0F, 0xFB, 0x05, 0x26, 0x1A, 0x33, 0xAC, 0xD1, 
- 0xA0, 0x96, 0xB6, 0xBB, 0xEC, 0xBF, 0xEF, 0x24, 0xA9, 0x59, 
- 0x4A, 0x76, 0x11, 0x15, 0x9E, 0xEF, 0xBD, 0x79, 0x33, 0xB6, 
- 0xA9, 0xB3, 0xF0, 0xB5, 0x5E, 0x01, 0x34, 0xDE, 0x25, 0x16, 
- 0xF1, 0x53, 0x0B, 0xD8, 0xF1, 0xFE, 0x7E, 0x9E, 0xB1, 0x46, 
- 0x76, 0x68, 0x1F, 0x02, 0x36, 0x97, 0x5E, 0x3B, 0x78, 0x97, 
- 0x2E, 0x6E, 0xB6, 0x10, 0xE9, 0x62, 0x51, 0x07, 0x6C, 0x88, 
- 0xF8, 0xBD, 0x5E, 0x0D, 0xAB, 0xDD, 0x2D, 0x9C, 0x8E, 0xD9, 
- 0x29, 0xE9, 0x7B, 0x62, 0xD2, 0xA2, 0x71, 0x02, 0x6A, 0xED, 
- 0x92, 0x0E, 0x59, 0xD7, 0x6F, 0xC1, 0xE2, 0x32, 0xC2, 0xF1, 
- 0x29, 0xB4, 0xE8, 0x34, 0x6B, 0x35, 0x9A, 0x36, 0x09, 0xD8, 
- 0x4F, 0x90, 0x4E, 0xA4, 0x67, 0xB1, 0x97, 0x35, 0x3A, 0x43, 
- 0xDC, 0x91, 0x9A, 0x43, 0xCC, 0x0D, 0x55, 0xB2, 0xFE, 0x30, 
- 0xC1, 0x5F, 0x9D, 0x62, 0xB5, 0xB7, 0x3E, 0x08, 0x78, 0xE3, 
- 0xBC, 0x38, 0x9C, 0xCA, 0x4C, 0xAE, 0xBC, 0x7A, 0x4C, 0xD4, 
- 0x1B, 0xAA, 0xD4, 0x0E, 0x69, 0x73, 0xDC, 0x4E, 0x06, 0x83, 
- 0x14, 0x95, 0x83, 0xBC, 0x26, 0x7F, 0xFE, 0xC7, 0xAE, 0x2C, 
- 0x4F, 0x05, 0xE7, 0xE3, 0x6B, 0x2F, 0x95, 0x1A, 0xC3, 0x70, 
- 0xD8, 0x93, 0xC9, 0xEF, 0x31, 0x69, 0x7D, 0x50, 0x9A, 0x14, 
- 0x05, 0x81, 0xD1, 0x5B, 0x54, 0x50, 0x59, 0xB2, 0xCB, 0x41, 
- 0xF2, 0xE0, 0xE6, 0xAA, 0xAF, 0x96, 0xA3, 0xD7, 0x84, 0x2D, 
- 0x1A, 0x79, 0x4E, 0x36, 0xB6, 0x52, 0xF9, 0x9B, 0x80, 0x03, 
- 0x31, 0x87, 0x4D, 0x23, 0x79, 0x2D, 0x81, 0x9D, 0x99, 0x6A, 
- 0x28, 0x8C, 0xBD, 0x95, 0xF4, 0x9D, 0x95, 0xF5, 0xE3, 0xF3, 
- 0x1F, 0xCD, 0x92, 0xE2, 0x07, 0x5A, 0x7D, 0xE2, 0xF6, 0x18, 
- 0x02, 0x00, 0x00};

includeindex.html.gz.h

@@ -1,44 +0,0 @@
-
-    // filename: include/http/index.html.gz.h
-    // uncompressed: index.html, gzip: 622
-    #define index_html_gz 622
-    const char index_html_gz[] = {
- 0x1F, 0x8B, 0x08, 0x00, 0x22, 0x7E, 0xC2, 0x60, 0x02, 0xFF, 0x8D, 0x54, 0xCD, 0x6E, 0xD4, 0x30, 
- 0x10, 0xBE, 0xF3, 0x14, 0x43, 0xAE, 0x74, 0x63, 0xF5, 0x86, 0xAA, 0x6C, 0x10, 0x82, 0x22, 0x71, 
- 0xA8, 0x8A, 0x68, 0x11, 0xE2, 0xE8, 0x38, 0x93, 0xC4, 0xAA, 0xE3, 0xB1, 0xEC, 0x71, 0xB7, 0xCB, 
- 0x89, 0xD7, 0xE0, 0xF5, 0x78, 0x12, 0xC6, 0xCE, 0xB6, 0x2A, 0xEA, 0x85, 0x4B, 0x12, 0xCF, 0xDF, 
- 0xF7, 0x7D, 0x33, 0xE3, 0x74, 0xAF, 0x3F, 0x5E, 0x7F, 0xB8, 0xFD, 0xF1, 0xE5, 0x12, 0x16, 0x5E, 
- 0x5D, 0xFF, 0xAA, 0xDB, 0x5E, 0x00, 0xDD, 0x82, 0x7A, 0x2C, 0x1F, 0xF2, 0xB9, 0x22, 0x6B, 0x30, 
- 0x8B, 0x8E, 0x09, 0x79, 0xDF, 0x64, 0x9E, 0x76, 0x6F, 0x9B, 0x93, 0x8B, 0x2D, 0x3B, 0xEC, 0xAF, 
- 0x8E, 0xC0, 0x98, 0x18, 0x82, 0x9E, 0xB1, 0x53, 0x9B, 0x6D, 0xF3, 0x3B, 0xEB, 0xEF, 0x60, 0x89, 
- 0x38, 0xED, 0x9B, 0x85, 0x39, 0x5C, 0x28, 0x35, 0x91, 0xE7, 0xD4, 0xCE, 0x44, 0xB3, 0x43, 0x1D, 
- 0x6C, 0x6A, 0x0D, 0xAD, 0xCA, 0xA4, 0xF4, 0x6E, 0xD2, 0xAB, 0x75, 0xC7, 0xFD, 0x75, 0x40, 0xFF, 
- 0xE6, 0x46, 0xFB, 0xD4, 0x40, 0x44, 0xB7, 0x6F, 0x12, 0x1F, 0x1D, 0xA6, 0x05, 0x91, 0x1B, 0xE0, 
- 0x63, 0xC0, 0x7D, 0xC3, 0xF8, 0xC0, 0x25, 0xA3, 0x79, 0x89, 0xB1, 0x05, 0xAB, 0xFA, 0x6A, 0x4B, 
- 0xC8, 0x7F, 0xD5, 0xE8, 0xD4, 0xA3, 0xD8, 0x6E, 0xA0, 0xF1, 0x78, 0x2A, 0xBB, 0x9C, 0xF7, 0x57, 
- 0xF4, 0xD3, 0x3A, 0xA7, 0xC1, 0x26, 0x30, 0x44, 0x4E, 0xE2, 0xCE, 0x4F, 0x4E, 0xBB, 0xCE, 0x90, 
- 0xA2, 0xD9, 0x37, 0x76, 0x15, 0xCD, 0x49, 0x4D, 0x56, 0xF0, 0xE9, 0xA1, 0x0D, 0x7E, 0x6E, 0x40, 
- 0x3B, 0x69, 0xD3, 0xED, 0x82, 0xF0, 0x69, 0xB3, 0x82, 0xA3, 0x99, 0x2E, 0x40, 0xC3, 0xE4, 0x44, 
- 0xA3, 0x9F, 0xA1, 0xD8, 0x52, 0x8E, 0x91, 0xB2, 0x1F, 0xCB, 0x99, 0x25, 0xF6, 0x52, 0x47, 0x5E, 
- 0x5A, 0xE1, 0xB3, 0x01, 0x84, 0xFE, 0x3D, 0xC3, 0x09, 0xFF, 0x0C, 0x0E, 0xF8, 0xE7, 0xD7, 0xEF, 
- 0x88, 0x52, 0x62, 0x76, 0x34, 0x68, 0x27, 0x74, 0xD6, 0x35, 0x7B, 0xCB, 0x47, 0xA0, 0xA9, 0x53, 
- 0xE1, 0x31, 0x2B, 0xBB, 0x1E, 0xBA, 0xD7, 0xBB, 0x5D, 0x99, 0x96, 0x9F, 0x71, 0x04, 0x26, 0x70, 
- 0x56, 0x26, 0x63, 0x7D, 0x05, 0xE1, 0xCC, 0x14, 0xAD, 0xE4, 0xEF, 0x76, 0x9B, 0x90, 0xDA, 0xBE, 
- 0x9E, 0xD1, 0x2C, 0x9E, 0x84, 0xA5, 0x84, 0xA6, 0x4E, 0x89, 0xE5, 0xB9, 0x73, 0x91, 0xFE, 0x62, 
- 0x7C, 0x61, 0x1F, 0xB2, 0x75, 0xE3, 0x3F, 0xF6, 0x4E, 0x09, 0xFE, 0x13, 0xFF, 0x03, 0xC5, 0xBB, 
- 0x2A, 0x8E, 0x66, 0x14, 0xEC, 0x58, 0xB8, 0xDC, 0x21, 0x86, 0x4A, 0xE4, 0xB3, 0x67, 0x8C, 0x1E, 
- 0x59, 0x7A, 0x65, 0xEF, 0x45, 0x97, 0x1F, 0x41, 0x1B, 0x83, 0x29, 0xD9, 0xC1, 0xE1, 0x19, 0x24, 
- 0x82, 0x80, 0x14, 0x1C, 0x82, 0x54, 0x71, 0xE3, 0xC1, 0x8E, 0x08, 0x46, 0x7B, 0x18, 0x50, 0x94, 
- 0x4C, 0x14, 0x57, 0x91, 0x66, 0x64, 0x91, 0xA2, 0x1D, 0x8A, 0xA2, 0x54, 0x0B, 0x98, 0x88, 0xBA, 
- 0x1E, 0x68, 0xAA, 0x18, 0xDF, 0x71, 0x68, 0xE5, 0x21, 0x49, 0xCE, 0xA2, 0x80, 0x88, 0x10, 0x09, 
- 0x34, 0x5C, 0xFC, 0x4B, 0x5E, 0xA5, 0x9C, 0x21, 0xE9, 0xEE, 0x40, 0x51, 0xB3, 0x25, 0x2F, 0xAE, 
- 0x48, 0xA9, 0x94, 0x02, 0x92, 0x1D, 0x84, 0xE0, 0x34, 0x17, 0xA8, 0x32, 0x7D, 0x21, 0x86, 0x9E, 
- 0x4B, 0xE3, 0x44, 0x84, 0x95, 0xA1, 0xDD, 0xDB, 0x31, 0xCB, 0x69, 0x8E, 0x74, 0xE0, 0xA5, 0xA2, 
- 0x53, 0x8E, 0xB5, 0x1E, 0x1A, 0x2E, 0x8A, 0xA6, 0xCC, 0x39, 0x62, 0xFB, 0x6C, 0x36, 0xA1, 0xFF, 
- 0x2A, 0x5B, 0x56, 0x99, 0x75, 0xFA, 0xD9, 0x9D, 0x48, 0x72, 0x29, 0x0E, 0x87, 0x43, 0xBB, 0x6E, 
- 0xC3, 0x6E, 0x29, 0xCE, 0x0A, 0xFD, 0xEE, 0xDB, 0x8D, 0x12, 0x6A, 0x99, 0x95, 0x10, 0xB5, 0x93, 
- 0xDC, 0x2E, 0x52, 0xCD, 0xD3, 0x42, 0x5E, 0x3D, 0xDA, 0x3A, 0xA5, 0xFB, 0x3A, 0x64, 0xD4, 0xD1, 
- 0x83, 0xA8, 0xF4, 0xB0, 0x52, 0x59, 0x94, 0x92, 0x5A, 0xB1, 0xEE, 0xB5, 0xCB, 0xB8, 0x35, 0x28, 
- 0x44, 0xEB, 0x8D, 0x95, 0xAE, 0x26, 0xF1, 0x68, 0x86, 0x39, 0x97, 0xBE, 0x96, 0xA0, 0x90, 0x63, 
- 0xCA, 0xB6, 0x76, 0xA6, 0xE8, 0x58, 0xAD, 0x0C, 0x82, 0xFC, 0xC6, 0xBE, 0xCC, 0x75, 0xBB, 0x16, 
- 0xB2, 0xFF, 0xF5, 0xEF, 0xF0, 0x17, 0x2C, 0x3C, 0x3D, 0x28, 0x35, 0x04, 0x00, 0x00};

platformio.ini

@@ -1,30 +0,0 @@
-; PlatformIO Project Configuration File
-;
-;   Build options: build flags, source filter
-;   Upload options: custom upload port, speed and extra flags
-;   Library options: dependencies, extra library storages
-;   Advanced options: extra scripting
-;
-; Please visit documentation for the other options and examples
-; https://docs.platformio.org/page/projectconf.html
-
-[env:esp01_1m]
-platform = espressif8266
-board = esp01_1m
-framework = arduino
-monitor_speed = 115200
-
-extra_scripts = pre:extra_script.py
-
-; stuff for OTA 
-; https://docs.platformio.org/en/latest/platforms/espressif8266.html#over-the-air-ota-update
-upload_protocol = espota
-upload_port = 192.168.10.94
-upload_flags =
-  --port=8266
-  --auth=admin
-
-lib_deps =
-
-  # The exact version
-  ottowinter/PCA9685 16-Channel PWM Driver Module Library @ 1.2.9

scripts/gdboptions

@@ -0,0 +1,17 @@
+set remote hardware-breakpoint-limit 1
+set remote hardware-watchpoint-limit 1
+set remote interrupt-on-connect on
+set remote kill-packet off
+set remote symbol-lookup-packet off
+set remote verbose-resume-packet off
+mem 0x20000000 0x3fefffff ro cache
+mem 0x3ff00000 0x3fffffff rw
+mem 0x40000000 0x400fffff ro cache
+mem 0x40100000 0x4013ffff rw cache
+mem 0x40140000 0x5fffffff ro cache
+mem 0x60000000 0x60001fff rw
+set serial baud 460800
+
+file .pio/build/debug/firmware.elf
+target remote /dev/ttyUSB0
+thb loop 

src/filesys.cpp

@@ -0,0 +1,130 @@
+#include "filesys.h"
+
+// listDir("/");
+// deleteFile("/hello.txt");
+// writeFile("/hello.txt", "Hello ");
+// appendFile("/hello.txt", "World!\n\r");
+// readFile("/hello.txt");
+// listDir("/");
+
+FSInfo fsinfo;
+
+bool mount_fs() {
+  if(!LittleFS.begin()) {
+    Serial.println("[ERROR] LittleFS.info(), reset ...");
+    return false;
+  }
+
+  if(!LittleFS.info(fsinfo)) {
+    Serial.println("[ERROR] LittleFS.info(), reset ...");
+    return false;
+  }
+
+  printf("Filesystem opened:\n\r");
+  printf("\ttotalBytes:\t%d\n\r",     fsinfo.totalBytes);
+  printf("\tusedBytes:\t%d\n\r",      fsinfo.usedBytes);
+  printf("\tblockSize:\t%d\n\r",      fsinfo.blockSize);
+  printf("\tpageSize:\t%d\n\r",       fsinfo.pageSize);
+  printf("\tmaxOpenFiles:\t%d\n\r",   fsinfo.maxOpenFiles);
+  printf("\tmaxPathLength:\t%d\n\r",  fsinfo.maxPathLength);
+  printf("\n\r");
+
+  return true;
+}
+
+bool format_fs() {
+  printf("Formatting FS ! \n\r");
+  return LittleFS.format();
+}
+
+void ls(const char * dirname) {
+  Serial.printf("ls -l %s\n\r", dirname);
+  Dir root = LittleFS.openDir(dirname);
+
+  while (root.next()) {
+    File file = root.openFile("r");
+
+    time_t lw = file.getLastWrite();
+    struct tm * tmstruct = localtime(&lw);
+    Serial.printf("%8d  %02d %02d %02d:%02d  %s\n\r",
+        file.size(), 
+        tmstruct->tm_mon + 1, 
+        tmstruct->tm_mday,
+        tmstruct->tm_hour,
+        tmstruct->tm_min,
+        root.fileName().c_str());
+    file.close();
+  }
+  Serial.println();
+}
+
+void readFile(const char * path) {
+  Serial.printf("Reading file: %s\n\r", path);
+
+  File file = LittleFS.open(path, "r");
+  if (!file) {
+    Serial.println("Failed to open file for reading");
+    return;
+  }
+
+  Serial.print("Read from file: ");
+  while (file.available()) {
+    Serial.write(file.read());
+  }
+  file.close();
+}
+
+void writeFile(const char * path, const char * message) {
+  Serial.printf("Writing file: %s\n\r", path);
+
+  File file = LittleFS.open(path, "w");
+  if (!file) {
+    Serial.println("Failed to open file for writing");
+    return;
+  }
+  if (file.print(message)) {
+    Serial.println("File written");
+  } else {
+    Serial.println("Write failed");
+  }
+  delay(2000); // Make sure the CREATE and LASTWRITE times are different
+  file.close();
+}
+
+void appendFile(const char * path, const char * message) {
+  Serial.printf("Appending to file: %s\n\r", path);
+
+  File file = LittleFS.open(path, "a");
+  if (!file) {
+    Serial.println("Failed to open file for appending");
+    return;
+  }
+  if(file.print(message)) {
+    Serial.println("Message appended");
+  } else {
+    Serial.println("Append failed");
+  }
+  file.close();
+}
+
+void renameFile(const char * path1, const char * path2) {
+  Serial.printf("Renaming file %s to %s\n\r", path1, path2);
+  if (LittleFS.rename(path1, path2)) {
+    Serial.println("File renamed");
+  } else {
+    Serial.println("Rename failed");
+  }
+}
+
+void deleteFile(const char * path) {
+  Serial.printf("Deleting file: %s\n\r", path);
+  if (LittleFS.remove(path)) {
+    Serial.println("File deleted");
+  } else {
+    Serial.println("Delete failed");
+  }
+}
+
+
+
+ 

src/httpserver.cpp

@@ -0,0 +1,17 @@
+#include "httpserver.h"
+
+
+bool HTTPServer::addRootFileHandler() {
+
+  // //experimental, see doku.md
+  // server.serveStatic("/compressed", LittleFS, "/compressed.html.gzip");
+
+  this->serveStatic("", LittleFS, "/index.html");
+  this->serveStatic("/", LittleFS, "/index.html");
+  this->serveStatic("/#", LittleFS, "/index.html");
+  this->serveStatic("/style.css", LittleFS, "/style.css");
+  this->serveStatic("/input.js", LittleFS, "/input.js");
+  this->serveStatic("/favicon.png", LittleFS, "/favicon.png");
+
+  return true;
+}

src/main.cpp

@@ -1,71 +1,89 @@
 #include <Arduino.h>
-#include <Wire.h>
 
-#include "wifi_credentials.h"
+#ifdef WITH_DEBUGGING_ON
+#include <GDBStub.h> // debugging support via GDBStub over UART
+#endif
+
 #include "PCA9685.h"
-
+extern "C" { 
-// Änderung
+  #include "user_interface.h" 
+}
 // OTA & WEB
-#include <ESP8266WiFi.h>
+#include "ota.h"
-#include <WiFiUdp.h>
+#include "wifi_credentials.h"
-#include <ArduinoOTA.h>
+#include "httpserver.h"
 
-#include <ESP8266WebServer.h>
+// BOARD
-#include <WiFiClient.h> // evtl weghauen ?
+#define ESP12_LED 2
+#define NODEMCU_LED 16
 
-#include "index.html.gz.h"
+// PWM
-#include "style.css.gz.h"
+#include "pwm.h"
-// images are possible
+os_timer_t timer1;
-// maybe check out FS <- SPIFFS
+uint8_t timer_flag = 0;
+Treppe stairs(13);
 
+// WIFI
 const char* ssid = STASSID;
 const char* password = STAPSK;
 
-const int led = 13;
-ESP8266WebServer server(80);
 
-void handleRootGz() {
+void timerCallback(void *pArg)
-    const char* dataType = "text/html";
+{
-    server.sendHeader(F("Content-Encoding"), F("gzip"));
+  *((int *) pArg) += 1;
-    server.send(200, dataType, (const char*)index_html_gz, index_html_gz_len);
+  stairs.task();
 }
 
-void handleCssGz() {
+// HTTP
-    const char* dataType = "text/css";
+void handleNotFound();
-    server.sendHeader(F("Content-Encoding"), F("gzip"));
+HTTPServer httpServer(80, "/");
-    server.send(200, dataType, (const char*)style_css_gz, style_css_gz_len);
+
-}
+uint32_t _t=0;
+#define SP_US(_str,_a) Serial.print(_str); Serial.print(" took: "); Serial.print(_a); Serial.println("us")
+#define TIMEIF_US(_f, _l, _str) _t=micros(); _f; _t=micros()-_t; if(_t > _l) { SP_US(_str, _t); }
+// ===============================================
 
 
 void handleNotFound() {
-  digitalWrite(led, 1);
   String message = "File Not Found\n\n";
   message += "URI: ";
-  message += server.uri();
+  message += httpServer.uri();
   message += "\nMethod: ";
-  message += (server.method() == HTTP_GET) ? "GET" : "POST";
+  message += (httpServer.method() == HTTP_GET) ? "GET" : "POST";
   message += "\nArguments: ";
-  message += server.args();
+  message += httpServer.args();
   message += "\n";
 
-  for (uint8_t i = 0; i < server.args(); i++) {
+  for (uint8_t i = 0; i < httpServer.args(); i++) {
-    message += " " + server.argName(i) + ": " + server.arg(i) + "\n";
+    message += " " + httpServer.argName(i) + ": " + httpServer.arg(i) + "\n";
   }
 
-  server.send(404, "text/plain", message);
+  httpServer.send(404, "text/plain", message);
-  digitalWrite(led, 0);
 }
 
+void setup() {
+#ifdef WITH_DEBUGGING_ON
+  Serial.begin(460800);
+  gdbstub_init();
+#else
+  Serial.begin(115200);
+#endif
 
-void setup_webserver() {
+  Serial.println(F("Booting ...."));
-  pinMode(led, OUTPUT);
-  digitalWrite(led, 0);
-  Serial.println("");
 
-  // Wait for connection
+  pinMode(NODEMCU_LED, OUTPUT);
-  while (WiFi.status() != WL_CONNECTED) {
+  pinMode(ESP12_LED, OUTPUT);
-    delay(500);
+
-    Serial.print(".");
+  Wire.begin();                       // Wire must be started first
+  Wire.setClock(1000000);              // Supported baud rates are 100kHz, 400kHz, and 1000kHz
+
+  WiFi.mode(WIFI_STA);
+  WiFi.begin(ssid, password);
+
+  while (WiFi.waitForConnectResult() != WL_CONNECTED) {
+    Serial.println("Connection Failed! Rebooting...");
+    delay(5000);
+    ESP.restart();
   }
 
   Serial.println("");
@@ -74,97 +92,20 @@ void setup_webserver() {
   Serial.print("IP address: ");
   Serial.println(WiFi.localIP());
 
-  //server.on("/", handleRoot);
+  ota_setup();
-  server.on("/", handleRootGz);
-  server.on("/styles/style.css", handleCssGz);
-  server.onNotFound(handleNotFound);
 
-  server.begin();
+  httpServer.start();
-  Serial.println("HTTP server started");
+  httpServer.onNotFound(handleNotFound);
+  Serial.println("HTTP server started !");
+
+  stairs.setup();
+  Serial.println("PCA9685 connected !");
+
+  os_timer_setfn(&timer1, timerCallback, &timer_flag);
+  os_timer_arm(&timer1, 20, true);
 }
 
-
-
-PCA9685 pwmController;   
-
-void setup() {
-  Serial.begin(115200);
-  Serial.println("Booting");
-  WiFi.mode(WIFI_STA);
-  WiFi.begin(ssid, password);
-
-  Wire.begin();                       // Wire must be started first
-  Wire.setClock(400000);              // Supported baud rates are 100kHz, 400kHz, and 1000kHz
-
-  while (WiFi.waitForConnectResult() != WL_CONNECTED) {
-    Serial.println("Connection Failed! Rebooting...");
-    delay(5000);
-    ESP.restart();
-  }
-
-  // setup OTA
-  ArduinoOTA.setPort(8266);
-  ArduinoOTA.setHostname("ESP_Treppenlicht");
-  ArduinoOTA.setPassword("admin");
-  // Password can be set with it's md5 value as well
-  // MD5(admin) = 21232f297a57a5a743894a0e4a801fc3
-  // ArduinoOTA.setPasswordHash("21232f297a57a5a743894a0e4a801fc3");
-
-  ArduinoOTA.onStart([]() {
-    String type;
-    if (ArduinoOTA.getCommand() == U_FLASH) {
-      type = "sketch";
-    } else { // U_FS
-      type = "filesystem";
-    }
-
-    // NOTE: if updating FS this would be the place to unmount FS using FS.end()
-    Serial.println("Start updating " + type);
-  });
-  ArduinoOTA.onEnd([]() {
-    Serial.println("\nEnd");
-  });
-  ArduinoOTA.onProgress([](unsigned int progress, unsigned int total) {
-    Serial.printf("Progress: %u%%\r", (progress / (total / 100)));
-  });
-  ArduinoOTA.onError([](ota_error_t error) {
-    Serial.printf("Error[%u]: ", error);
-    if (error == OTA_AUTH_ERROR) {
-      Serial.println("Auth Failed");
-    } else if (error == OTA_BEGIN_ERROR) {
-      Serial.println("Begin Failed");
-    } else if (error == OTA_CONNECT_ERROR) {
-      Serial.println("Connect Failed");
-    } else if (error == OTA_RECEIVE_ERROR) {
-      Serial.println("Receive Failed");
-    } else if (error == OTA_END_ERROR) {
-      Serial.println("End Failed");
-    }
-  });
-  ArduinoOTA.begin();
-  Serial.println("Ready");
-  Serial.print("IP address: ");
-  Serial.println(WiFi.localIP());
-
-  setup_webserver();
-
-  pwmController.resetDevices();       // Software resets all PCA9685 devices on Wire line
-
-  pwmController.init(B000000);        // Address pins A5-A0 set to B000000
-  pwmController.setPWMFrequency(200); // Default is 200Hz, supports 24Hz to 1526Hz
-
-    pwmController.setChannelPWM(0, 128 << 4); // Set PWM to 128/255, but in 4096 land
-
-    Serial.println(pwmController.getChannelPWM(0)); // Should output 2048, which is 128 << 4
-  
-}
-
-uint32_t t;
-#define SP_US(_str,_a) Serial.print(_str); Serial.print(" took: "); Serial.print(_a); Serial.println("µs")
-#define TIMEIF_US(_str,_f, _l) t=micros(); _f; t=micros()-t; if(t > _l) { SP_US(_str, t); }
-
 void loop() {
-  TIMEIF_US("OTA", ArduinoOTA.handle(), 20000);
+  TIMEIF_US(ArduinoOTA.handle(), 1000, "OTA");
-  
+  TIMEIF_US(httpServer.handleClient(), 1000, "HTTP");
-  TIMEIF_US("HTTP", server.handleClient(), 20000);
 }

src/pwm.cpp

@@ -0,0 +1,183 @@
+#include "pwm.h"
+
+uint8_t Treppe::softstart_led(uint8_t led, uint16_t startval, uint16_t stopval){
+    /*
+  softstart task
+
+  - get's called at regular intervals (1ms at the moment)
+  - dimms single led (0 - 15, PCA9685 outputs) with linear intervals vom startval to stopval
+  - calculates pwm steps depending on startval, stopval and timeinterval
+  - -> results in constanst speed
+  - returns 1 if led dimming is running
+  - returns 0 if led dimming is finished
+
+  */
+
+    static uint8_t lastled = 255;
+    static float current_pwm = 0;
+    static float stepsize = 1.0;
+    if(led != lastled){
+      pwmController.setChannelPWM(led, (uint16_t)startval);
+      lastled = led;
+      current_pwm = startval;
+      stepsize = INT_TIME*abs(stopval - startval)/(float)time_per_stair;      // only valid at 1ms function call interval
+      return 1;
+    }
+    
+    if(startval > stopval){
+      current_pwm -= stepsize;
+    }
+    else {
+      current_pwm += stepsize;
+    }
+    Serial.println((uint16_t)current_pwm);
+    pwmController.setChannelPWM(led, (uint16_t)current_pwm);
+    if(current_pwm > stopval - stepsize && current_pwm < stopval + stepsize){
+      if(stopval == 0) pwmController.setChannelPWM(led, 0);
+      return 0;
+    } 
+    return 1;
+}
+
+void Treppe::ledsequence(){
+  static int8_t led = 0;
+  static uint16_t brightness = 0;
+  static uint16_t lastbrightness = 0;
+  static uint16_t status = 0;
+  uint16_t status_build = 0;
+  status_build |= direction << 8;
+  status_build |= state;
+  if(status_build != status){                 // check if any parameter changed
+    finish = 0;                               // set state unfinished -> start action
+    if(direction) led = 0;                    // reset led counter depending of direction
+    else          led = stairs-1;
+    if(state){
+      brightness = active_brightness;           // set brightness value depending of on/off
+      lastbrightness = idle_brightness;
+    }     
+    else{
+      brightness = idle_brightness;
+      lastbrightness = active_brightness;
+    }          
+    status = status_build;                    // set parameter memory
+    Serial.print("----Status Changed! onoff: ");
+    Serial.print(state);
+    Serial.print(" dir: ");
+    Serial.println(direction);
+
+  }
+  if(!finish){                                // finish == 0 -> action pending
+      if(!softstart_led(led,lastbrightness, brightness)){
+        Serial.print("one LED finished: ");
+        Serial.print(led);
+        Serial.print(" last: ");
+        Serial.print(lastbrightness);
+        Serial.print(" curr: ");
+        Serial.println(brightness);
+        if(direction){
+          led++;
+          if(led >= stairs) {
+            finish = 1;
+            //lastbrightness = brightness;
+            }
+        } 
+        else{
+           led--;
+           if(led < 0){
+             //lastbrightness = brightness;
+             finish = 1;
+            }
+        }
+      }
+  }
+}
+
+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.setPWMFrequency(200);
+    pwmController.setAllChannelsPWM(idle_brightness);
+
+    pinMode(SENSOR1, INPUT);
+    pinMode(SENSOR2, INPUT);
+    Serial.println("Hello from Treppe");
+    Serial.print("Treppe: initial parameters: stairs=");
+    Serial.println(stairs);
+}
+void Treppe::task(){
+
+  if(finish){
+    direction = switch_direction;
+    state = switch_state;
+  }  
+  static uint8_t last_sensor_state[2] = {0,0}; 
+  uint8_t current_sensor_state[2] = {0,0};
+  current_sensor_state[0] = digitalRead(SENSOR1);
+  current_sensor_state[1] = digitalRead(SENSOR2);
+  
+  if(current_sensor_state[0] && !last_sensor_state[0] && state == 0){
+    setDirection(1);
+    setState(1);
+  }
+
+  if(current_sensor_state[1] && !last_sensor_state[1] && state == 0){
+    setDirection(0);
+    setState(1);
+  }
+
+  // first switch - off approach, use timer later
+  if(!current_sensor_state[0] && last_sensor_state[0] && state == 1){
+    setDirection(1);
+    setState(0);
+  }
+
+  if(!current_sensor_state[1] && last_sensor_state[1] && state == 1){
+    setDirection(0);
+    setState(0);
+  }
+
+  last_sensor_state[0] = current_sensor_state[0];
+  last_sensor_state[1] = current_sensor_state[1];
+  ledsequence();
+
+}
+
+uint16_t Treppe::setIdle(uint16_t _idle_brightness){
+    idle_brightness = _idle_brightness;
+    Serial.println("Treppe: idle brightness changed!");
+    return idle_brightness;
+}
+uint16_t Treppe::setActive(uint16_t _active_brightness){
+    active_brightness = _active_brightness;
+    Serial.println("Treppe: active brightness changed!");
+    return active_brightness;
+}
+uint16_t Treppe::setTime(uint16_t _time_per_stair){
+    time_per_stair = _time_per_stair;
+    Serial.println("Treppe: time changed!");
+    return time_per_stair;
+}
+
+uint8_t Treppe::setDirection(uint8_t _direction){
+    switch_direction = _direction;
+    Serial.println("Treppe: Direction changed!");
+    if(finish) Serial.println("apply direction request immediately");
+    else  Serial.println("currently active, dir change afterwards");
+    // to do: implement state command variable to determine dimm-state
+    return switch_direction;
+}
+
+uint8_t Treppe::setState(uint8_t _state){
+    if(state == _state) return 1;
+    else{
+        switch_state = _state;
+        Serial.println("Treppe: State Request changed!");
+        if(finish) Serial.println("apply state request immediately");
+        else Serial.println("currently active, state changes after activity");
+    }  
+    return 0;
+}

start_xtensa_gdb_stub.sh

@@ -0,0 +1,6 @@
+#!/bin/bash
+GDB_PATH=~/.arduino15/packages/esp8266/tools/xtensa-lx106-elf-gcc/3.0.0-newlib4.0.0-gnu23-48f7b08/bin/xtensa-lx106-elf-gdb
+
+cd ..
+echo "Starting gdb"
+$GDB_PATH -x scripts/gdboptions

templ_platformio_ini

@@ -0,0 +1,45 @@
+; PlatformIO Project Configuration File
+;
+;   Build options: build flags, source filter
+;   Upload options: custom upload port, speed and extra flags
+;   Library options: dependencies, extra library storages
+;   Advanced options: extra scripting
+;
+; Please visit documentation for the other options and examples
+; https://docs.platformio.org/page/projectconf.html
+
+[env]
+platform = espressif8266
+board = nodemcuv2
+framework = arduino
+
+; for http files
+board_build.filesystem = littlefs
+board_build.ldscript = eagle.flash.4m1m.ld
+extra_scripts = pre:create_gz_files.py
+
+monitor_speed = 115200
+
+[env:serial]
+upload_protocol = esptool
+upload_speed = 921600
+
+[env:ota]
+; OTA => https://docs.platformio.org/en/latest/platforms/espressif8266.html#over-the-air-ota-update
+upload_protocol = espota
+upload_port = <!! IP ADDRESS !!>
+upload_flags =
+  --port=8266
+  --host_port=<!! PORT !!>
+  --auth=admin
+
+[env:debug]
+; look at doku.md
+build_flags = -DWITH_DEBUGGING_ON -Os -g3 -ggdb3
+upload_protocol = esptool
+upload_speed = 921600
+
+
+
+
+

test/test_main.cpp

@@ -0,0 +1,40 @@
+#include <Arduino.h>
+#include <unity.h>
+
+String STR_TO_TEST;
+
+void setUp(void) {
+    // set stuff up here
+    STR_TO_TEST = "Hello, world!";
+}
+
+void tearDown(void) {
+    // clean stuff up here
+    STR_TO_TEST = "";
+}
+
+void test_led_builtin_pin_number(void) {
+    TEST_ASSERT_EQUAL(2, LED_BUILTIN);
+}
+
+void test_string_concat(void) {
+    String hello = "Hello, ";
+    String world = "world!";
+    TEST_ASSERT_EQUAL_STRING(STR_TO_TEST.c_str(), (hello + world).c_str());
+}
+
+
+void setup()
+{
+    delay(2000); // service delay
+    UNITY_BEGIN();
+
+    RUN_TEST(test_led_builtin_pin_number);
+    RUN_TEST(test_string_concat);
+
+    UNITY_END(); // stop unit testing
+}
+
+void loop()
+{
+}

webtest.cmd

@@ -0,0 +1,2 @@
+CD .\data
+py.exe -m http.server

webtest.sh

@@ -0,0 +1,2 @@
+cd data
+python3 -m http.server