cleanup

src/CMakeLists.txt

@@ -1,5 +1,6 @@
 # This file was automatically generated for projects
 # without default 'CMakeLists.txt' file.
+add_compile_options(" -Wno-unused-variable -Wno-unused-function -Wno-error")
 
 FILE(GLOB_RECURSE app_sources ${CMAKE_SOURCE_DIR}/src/*.*)
 

src/MyBLEServer.cpp

@@ -0,0 +1,80 @@
+#include "MyBLEServer.hpp"
+#include "config.hpp"
+
+#include "tlc.hpp"
+#include <EEPROM.h>
+#include <string>
+
+MyServerCallbacks::MyServerCallbacks(bool * connectionState) {
+    _BLEClientConnected = connectionState;
+}
+
+void MyServerCallbacks::onConnect(BLEServer * pServer) {
+    // Serial.println("Callback connected");
+
+    deviceConnected = true;
+    *_BLEClientConnected = true;
+}
+
+void MyServerCallbacks::onDisconnect(BLEServer * pServer) {
+    *_BLEClientConnected = false;
+    deviceConnected = false;
+}
+
+bool MyServerCallbacks::getConnectionState() {
+    return *_BLEClientConnected;
+}
+
+MyAlarmCallback::MyAlarmCallback(enum Alarm * alarm, enum Dimmer * dimmer) {
+    this->alarmFired = alarm;
+    this->dimmerState = dimmer;
+}
+void MyAlarmCallback::onWrite(BLECharacteristic * pCharacteristic) {
+    String value = pCharacteristic->getValue().c_str();
+
+    if (value.compareTo("X") == 0) {
+        // Serial.println("found X");
+        // Serial.println(deviceConnected);
+        *this->alarmFired = ALARM_1KM;
+    }
+    else if (value.compareTo("XX") == 0) {
+        // Serial.println("found XX");
+        // alarmFired_500m = 1;
+        *alarmFired = ALARM_500M;
+    }
+    else if (value.compareTo("XXX") == 0) {
+        // Serial.println("found XXX");
+        // alarmFired_300m = 1;
+        *alarmFired = ALARM_300M;
+    }
+    else if (value.compareTo("XXXX") == 0) {
+        // Serial.println("found XXXX");
+        // alarmFired_100m = 1;
+        *alarmFired = ALARM_100M;
+    }
+    else if (value.compareTo("brighter") == 0) {
+        // Serial.println("found brighter");
+        // alarmFired_100m = 1;
+        // alarmFired = ALARM_100M;
+        // state = 0;
+        // brightnessFired = BRIGHTER;
+        *dimmerState = BRIGHTNESS_UP;
+    }
+    else if (value.compareTo("darker") == 0) {
+        // Serial.println("found darker");
+        // alarmFired_100m = 1;
+        // alarmFired = ALARM_100M;
+        // state = 0;
+        // brightnessFired = DARKER;
+        *dimmerState = BRIGHTNESS_DOWN;
+    }
+    else if (value.compareTo("U") == 0) {
+        // reboot in WifiMode
+        // Serial.println("Found U");
+        EEPROM.write(MODE_ADDRESS, MODE_WIFI);
+        EEPROM.commit();
+
+        // reboot
+        ESP.restart();
+    }
+}

src/MyBLEServer.hpp

@@ -0,0 +1,29 @@
+#ifndef MYBLESERVER_H
+#define MYBLESERVER_H
+#include "BLEServer.h"
+#include "datatypes.hpp"
+#include "tlc.hpp"
+
+class MyServerCallbacks : public BLEServerCallbacks {
+public:
+    MyServerCallbacks(bool *);
+    bool getConnectionState();
+    void onConnect(BLEServer * pServer);
+    void onDisconnect(BLEServer * pServer);
+
+private:
+    bool * _BLEClientConnected;
+    bool deviceConnected = false;
+};
+
+class MyAlarmCallback : public BLECharacteristicCallbacks {
+public:
+    MyAlarmCallback(enum Alarm *, enum Dimmer *);
+
+private:
+    void onWrite(BLECharacteristic * pCharacteristic);
+    enum Alarm * alarmFired;
+    enum Dimmer * dimmerState;
+};
+
+#endif

src/config.hpp

@@ -1,7 +1,7 @@
 #ifndef CONFIG_H
 #define CONFIG_H
 // uncommend for very first flash
-// #define FIRST_BOOT 
+// #define FIRST_BOOT
 
 // #define ALARM_LED GPIO_NUM_2
 #define ALARM_LED GPIO_NUM_3
@@ -15,5 +15,4 @@
 
 #define NUM_LEDS 7 // do not touch
 
-
 #endif

src/main.cpp

@@ -1,17 +1,17 @@
-#include <Arduino.h>
-#include <string>
 #include "HWCDC.h"
 #include "esp32-hal-gpio.h"
 #include "esp32-hal.h"
 #include "freertos/portmacro.h"
 #include "hal/gpio_types.h"
 #include "secrets.hpp"
+#include <Arduino.h>
 #include <EEPROM.h>
 #include <cstdint>
+#include <string>
 
 #include "freertos/FreeRTOS.h"
-#include "freertos/task.h"
 #include "freertos/queue.h"
+#include "freertos/task.h"
 
 #include <BLE2902.h>
 #include <BLEDevice.h>
@@ -23,19 +23,18 @@
 #include <WiFi.h>
 #include <WiFiUdp.h>
 
-#include <driver/rmt.h>
+#include "MyBLEServer.hpp"
-#include "tlc.hpp"
 #include "config.hpp"
 #include "datatypes.hpp"
+#include "tlc.hpp"
+#include <driver/rmt.h>
 
 // both lines are useless, when using rmt mode
 int pTime = 3; // in useconds
-int tCycle = pTime * 6; // time for one bit. Per datasheet tCycle is between 0.33 useconds and 10 useconds
+int tCycle =
+    pTime * 6; // time for one bit. Per datasheet tCycle is between 0.33 useconds and 10 useconds
 
-//#define TESTMODE 1
+// #define TESTMODE 1
-
-const char * ssid = SECRET_SSID;
-const char * password = SECRET_PASS;
 
 bool _BLEClientConnected = false;
 
@@ -46,136 +45,39 @@ BLEDescriptor AlarmLevelDescriptor(BLEUUID((uint16_t)0x2901));
 // BLEServer * pServer = NULL;
 // bool volatile deviceConnected = false;
 bool volatile oldDeviceConnected = false;
-// uint32_t value = 0;
 
-enum NET_MODE mode;
+void displayWarning(void * params);
-
-void displayWarning( void * params);
 void dimmer(void * params);
 
 enum Alarm alarmFired = NO_ALARM;
 enum Dimmer dimmerState = NO_DIMMER;
 
+// class MyServerCallbacks : public BLEServerCallbacks {
+//     bool deviceConnected = false;
 
+//     void onConnect(BLEServer * pServer) {
+//         Serial.println("Callback connected");
 
-class MyServerCallbacks : public BLEServerCallbacks {
+//         deviceConnected = true;
-    bool deviceConnected = false;
+//         _BLEClientConnected = true;
+//     };
 
-    void onConnect(BLEServer * pServer) {
+//     void onDisconnect(BLEServer * pServer) {
-        Serial.println("Callback connected");
+//         _BLEClientConnected = false;
-        
+//         deviceConnected = false;
-        
+//     }
-        deviceConnected = true;
-        _BLEClientConnected = true;
-    };
 
-    void onDisconnect(BLEServer * pServer) {
+// public:
-        _BLEClientConnected = false;
+//     bool getConnectionState() { return deviceConnected; }
-        deviceConnected = false;
+// };
-    }
-    public:
-    bool getConnectionState(){
-        return deviceConnected;
-    }
-};
 
-bool brighter = false;
+void InitBLE(BLEServer * pServer, MyServerCallbacks * serverCallback,
-bool darker = false;
+             MyAlarmCallback * myAlarmCallback) {
-
-enum Alarm saveFiredAlarm;
-uint8_t saveAlarmState;
-
-int state = 0;
-
-byte brightnessState = 0;
-
-Cockpit cockpit(ALARM_PIN, NUM_LEDS, pTime, tCycle, brightnessState);
-
-TaskHandle_t thDisplayWarning;
-
-struct taskParams pvParams = {
-    .cockpit = &cockpit, 
-    .alarmFired = &alarmFired, 
-    .dimmerState = &dimmerState, 
-    .thDisplayWarning = &thDisplayWarning
-};
-
-// var to count to with state for different distances
-int stateLimit = 50;
-
-// save state of buttons
-bool brightnessUpPressed = false;
-bool brightnessDownPressed = false;
-
-enum Brightness brightnessFired = NO_CHANGE;
-
-
-
-class MyAlarmCallback : public BLECharacteristicCallbacks {
-    void onWrite(BLECharacteristic * pCharacteristic) {
-        String value = pCharacteristic->getValue().c_str();
-
-        if (value.compareTo("X") == 0) {
-            Serial.println("found X");
-            // Serial.println(deviceConnected);
-            alarmFired = ALARM_1KM;
-            state = 0;
-        }
-        else if (value.compareTo("XX") == 0) {
-            Serial.println("found XX");
-            // alarmFired_500m = 1;
-            alarmFired = ALARM_500M;
-            state = 0;
-        }
-        else if (value.compareTo("XXX") == 0) {
-            Serial.println("found XXX");
-            // alarmFired_300m = 1;
-            alarmFired = ALARM_300M;
-            state = 0;
-        }
-        else if (value.compareTo("XXXX") == 0) {
-            Serial.println("found XXXX");
-            // alarmFired_100m = 1;
-            alarmFired = ALARM_100M;
-            state = 0;
-        }
-        else if (value.compareTo("brighter") == 0) {
-            Serial.println("found brighter");
-            // alarmFired_100m = 1;
-            // alarmFired = ALARM_100M;
-            // state = 0;
-            // brightnessFired = BRIGHTER;
-            dimmerState = BRIGHTNESS_UP;
-
-        }
-        else if (value.compareTo("darker") == 0) {
-            Serial.println("found darker");
-            // alarmFired_100m = 1;
-            // alarmFired = ALARM_100M;
-            // state = 0;
-            // brightnessFired = DARKER;
-            dimmerState = BRIGHTNESS_DOWN;
-
-        }
-        else if (value.compareTo("U") == 0) {
-            // reboot in WifiMode
-            Serial.println("Found U");
-            EEPROM.write(MODE_ADDRESS, MODE_WIFI);
-            EEPROM.commit();
-
-            // reboot
-            ESP.restart();
-        }
-    }
-};
-
-void InitBLE(BLEServer *pServer, MyServerCallbacks *   serverCallback, MyAlarmCallback * myAlarmCallback) {
     BLEDevice::init("OilCheck");
     pServer = BLEDevice::createServer();
 
     Serial.println("Start BLE");
 
-    
     pServer->setCallbacks(serverCallback);
 
     // Create BLE Service
@@ -196,32 +98,28 @@ void InitBLE(BLEServer *pServer, MyServerCallbacks *   serverCallback, MyAlarmCa
     pAdvertising->addServiceUUID(AlarmService);
     pAdvertising->setScanResponse(true);
     BLEDevice::startAdvertising();
-    
 }
 
-volatile int ctr = 0;
-hw_timer_t * timer = NULL;
-portMUX_TYPE timerMux = portMUX_INITIALIZER_UNLOCKED;
-
-void IRAM_ATTR onTimer() {
-    portENTER_CRITICAL_ISR(&timerMux);
-    ctr++;
-    portEXIT_CRITICAL_ISR(&timerMux);
-}
-
-// volatile int pc = 0;
-
 // Create the BLE Server
-BLEServer * pServer = NULL; 
+BLEServer * pServer = NULL;
-MyServerCallbacks *serverCallback = new MyServerCallbacks();
+MyServerCallbacks * serverCallback = new MyServerCallbacks(&_BLEClientConnected);
-MyAlarmCallback * myAlarmCallback = new MyAlarmCallback();
+MyAlarmCallback * myAlarmCallback = new MyAlarmCallback(&alarmFired, &dimmerState);
 
+enum NET_MODE mode;
+byte brightnessState = 0;
+Cockpit cockpit(ALARM_PIN, NUM_LEDS, pTime, tCycle, brightnessState);
+
+TaskHandle_t thDisplayWarning;
+struct taskParams pvParams = {.cockpit = &cockpit,
+                              .alarmFired = &alarmFired,
+                              .dimmerState = &dimmerState,
+                              .thDisplayWarning = &thDisplayWarning};
 void setup() {
 
     // //setup GPIO
     pinMode(BRIGHTER_PIN, INPUT_PULLUP);
     pinMode(DARKER_PIN, INPUT_PULLUP);
-    pinMode(GPIO_NUM_10, INPUT); // former Alarm pin    
+    pinMode(GPIO_NUM_10, INPUT); // former Alarm pin
 
     Serial.begin(9600);
     delay(1000);
@@ -232,25 +130,16 @@ void setup() {
     Serial.println("Hallo Welt");
 
     EEPROM.begin(EEPROM_SIZE);
-    #if defined(FIRST_BOOT)
+#if defined(FIRST_BOOT)
     // needs to be uncommend for very first boot
-        EEPROM.write(MODE_ADDRESS, MODE_BLE);
+    EEPROM.write(MODE_ADDRESS, MODE_BLE);
-        EEPROM.commit();
+    EEPROM.commit();
-    #endif
+#endif
 
     mode = static_cast<enum NET_MODE>(EEPROM.read(MODE_ADDRESS));
-    // mode = MODE_WIFI;
 
     if (mode == MODE_BLE) {
 
-        // upcounting timer 1MHz
-        timer = timerBegin(1, 80, true);
-        timerAttachInterrupt(timer, &onTimer, true);
-        timerAlarmWrite(timer, 100000, true);
-        timerAlarmEnable(timer);
-
-       
-
         rmt_config_t config = RMT_DEFAULT_CONFIG_TX(ALARM_PIN, RMT_CHANNEL_0);
         config.clk_div = 160; // 80
         config.tx_config.carrier_en = false;
@@ -259,21 +148,20 @@ void setup() {
         ESP_ERROR_CHECK(rmt_driver_install(config.channel, 0, 0));
 
         InitBLE(pServer, serverCallback, myAlarmCallback);
-    
+
-        xTaskCreate(displayWarning, "Warning", 1000, &pvParams, tskIDLE_PRIORITY, &thDisplayWarning);
+        xTaskCreate(displayWarning, "Warning", 1000, &pvParams, tskIDLE_PRIORITY,
+                    &thDisplayWarning);
         xTaskCreate(dimmer, "Dimmer", 10000, &pvParams, tskIDLE_PRIORITY, NULL);
-    
     }
     else if (mode == MODE_WIFI) {
         // boot next time into ble mode
-
         EEPROM.write(MODE_ADDRESS, MODE_BLE);
         EEPROM.commit();
 
-        // delay(3000);
-
         Serial.println("Booting in Wifimode");
         WiFi.mode(WIFI_STA);
+        const char * ssid = SECRET_SSID;
+        const char * password = SECRET_PASS;
         WiFi.begin(ssid, password);
         while (WiFi.waitForConnectResult() != WL_CONNECTED) {
             Serial.println("Connection Failed! ");
@@ -319,13 +207,6 @@ void setup() {
         Serial.println("Ready");
         Serial.print("IP address: ");
         Serial.println(WiFi.localIP());
-    //     // WiFi.mode(WIFI_STA);
-    //     WiFi.begin(ssid, password);
-    //     while (WiFi.waitForConnectResult() != WL_CONNECTED) {
-    //         delay(3000);
-    //         break;
-    //     }
-    //     ArduinoOTA.begin();
     }
 }
 
@@ -336,57 +217,49 @@ void loop() {
         // Serial.print("WIFI");
     }
     else {
-       
+
-        vTaskDelay(100/portTICK_PERIOD_MS);
+        vTaskDelay(100 / portTICK_PERIOD_MS);
 
         if (serverCallback->getConnectionState()) {
-         
         }
         // disconnecting
         if (!serverCallback->getConnectionState() && oldDeviceConnected) {
-            delay(500);                  // give the bluetooth stack the chance to get things ready
+            delay(500);                  // give the bluetooth stack the chance to get thingsready
-            pServer->startAdvertising(); // restart advertising
+            pServer->startAdvertising(); // restart advertising Serial.println("startadvertising ");
-            Serial.println("start advertising");
             oldDeviceConnected = serverCallback->getConnectionState();
         }
         // connecting
         if (serverCallback->getConnectionState() && !oldDeviceConnected) {
             // do stuff here on connecting
             oldDeviceConnected = serverCallback->getConnectionState();
-            
+
-            Color c[] = {
+            Color c[] = {Cockpit::YELLOW, Cockpit::RED,   Cockpit::PURPLE, Cockpit::BLUE,
-                Cockpit::YELLOW, 
+                         Cockpit::CYAN,   Cockpit::GREEN, Cockpit::YELLOW, Cockpit::RED,
-                Cockpit::RED,
+                         Cockpit::PURPLE, Cockpit::BLUE,  Cockpit::CYAN,   Cockpit::GREEN};
-                Cockpit::PURPLE,
-                Cockpit::BLUE,
-                Cockpit::CYAN,
-                Cockpit::GREEN,
-                Cockpit::YELLOW, 
-                Cockpit::RED,
-                Cockpit::PURPLE,
-                Cockpit::BLUE,
-                Cockpit::CYAN,
-                Cockpit::GREEN
-            };
             // for(int i = 0; i < 36; i++){
             //     // cockpit.knightRiderAdvanced(red, i);
             //     // cockpit.outToIn(red, i);
             //     cockpit.outToInMulticolor(c, 6, i);
             //     // cockpit.knightRiderColored(i, red);
-            //     ESP_ERROR_CHECK(rmt_write_items(RMT_CHANNEL_0, cockpit.led_data, sizeof(cockpit.led_data) / sizeof(rmt_item32_t), true));
+            //     ESP_ERROR_CHECK(rmt_write_items(RMT_CHANNEL_0, cockpit.led_data,
-            //     delay(100);
+            //     sizeof(cockpit.led_data) / sizeof(rmt_item32_t), true)); delay(100);
             // }
-            for(int i = 0; i < 50; i++){
+            for (int i = 0; i < 49; i++) {
                 // cockpit.knightRiderAdvanced(red, i);
                 // cockpit.outToIn(red, i);
                 cockpit.inToOutMulticolor(c, 12, i);
+                // cockpit.speedUpBounce(c[0], i);
                 // cockpit.knightRiderColored(i, red);
-                ESP_ERROR_CHECK(rmt_write_items(RMT_CHANNEL_0, cockpit.led_data, sizeof(cockpit.led_data) / sizeof(rmt_item32_t), true));
+                ESP_ERROR_CHECK(rmt_write_items(RMT_CHANNEL_0, cockpit.led_data,
+                                                sizeof(cockpit.led_data) / sizeof(rmt_item32_t),
+                                                true));
+                // uint8_t myDelay = uint8_t(7 / 250.0 * i - 14 / 5.0 * i + 100);
                 delay(100);
             }
             delay(10);
             cockpit.turnOffLeds();
-            ESP_ERROR_CHECK(rmt_write_items(RMT_CHANNEL_0, cockpit.led_data, sizeof(cockpit.led_data) / sizeof(rmt_item32_t), true));
+            ESP_ERROR_CHECK(rmt_write_items(RMT_CHANNEL_0, cockpit.led_data,
+                                            sizeof(cockpit.led_data) / sizeof(rmt_item32_t), true));
         }
     }
 }

src/tasks.cpp

@@ -1,13 +1,13 @@
+#include "tasks.hpp"
 #include "Arduino.h"
 #include "config.hpp"
-#include "tasks.hpp"
-#include "tlc.hpp"
 #include "datatypes.hpp"
+#include "tlc.hpp"
 
-void displayWarning( void * params){
+void displayWarning(void * params) {
-    struct taskParams *myParams = (struct taskParams*)params;
+    struct taskParams * myParams = (struct taskParams *)params;
-    Cockpit *cp = myParams->cockpit;
+    Cockpit * cp = myParams->cockpit;
-    enum Alarm *alarm = myParams->alarmFired;
+    enum Alarm * alarm = myParams->alarmFired;
     enum Alarm alarmStatebefore = NO_ALARM;
     uint8_t alarmStateChanged = 0;
 
@@ -16,135 +16,140 @@ void displayWarning( void * params){
     alarmStatebefore = *alarm;
     while (true) {
 
-        if(*alarm != alarmStatebefore){
+        if (*alarm != alarmStatebefore) {
             alarmStateChanged = 1;
         }
-        else{
+        else {
             alarmStateChanged = 0;
         }
 
         switch (*alarm) {
-            case NO_ALARM:
+        case NO_ALARM:
-                vTaskDelay(100/portTICK_PERIOD_MS);
+            vTaskDelay(100 / portTICK_PERIOD_MS);
             break;
-            case ALARM_100M:
+        case ALARM_100M:
-                if(alarmStateChanged){
+            if (alarmStateChanged) {
-                    alarmStatebefore = ALARM_100M;
+                alarmStatebefore = ALARM_100M;
-                    statePreload = 30;
+                statePreload = 30;
-
+            }
-                }
+            cp->flashing(Cockpit::WHITE, statePreload);
-                cp->flashing(Cockpit::WHITE, statePreload);
+            ESP_ERROR_CHECK(rmt_write_items(RMT_CHANNEL_0, cp->led_data,
-                ESP_ERROR_CHECK(rmt_write_items(RMT_CHANNEL_0, cp->led_data, sizeof(cp->led_data) / sizeof(rmt_item32_t), true));
+                                            sizeof(cp->led_data) / sizeof(rmt_item32_t), true));
-                statePreload--;
+            statePreload--;
-                if(statePreload == 0){
+            if (statePreload == 0) {
-                    *alarm = NO_ALARM;
+                *alarm = NO_ALARM;
-                        alarmStatebefore = NO_ALARM;
+                alarmStatebefore = NO_ALARM;
-                }
+            }
-                vTaskDelay(300/portTICK_PERIOD_MS);
+            vTaskDelay(300 / portTICK_PERIOD_MS);
-                break;
-            case ALARM_300M:
-                if(alarmStateChanged){
-                    alarmStatebefore = ALARM_300M;
-                    statePreload = 20;
-                }
-                cp->flashing(Cockpit::ORANGE, statePreload);
-                ESP_ERROR_CHECK(rmt_write_items(RMT_CHANNEL_0, cp->led_data, sizeof(cp->led_data) / sizeof(rmt_item32_t), true));
-                statePreload--;
-                if(statePreload == 0){
-                    *alarm = NO_ALARM;
-                    alarmStatebefore = NO_ALARM;
-                }
-                vTaskDelay(500/portTICK_PERIOD_MS);
-                break;
-            case ALARM_500M:
-                // Serial.print("Alarm 500");
-                if(alarmStateChanged){
-                        alarmStatebefore = ALARM_500M;
-                        statePreload = 20;
-                    }
-                    cp->flashing(Cockpit::GREEN, statePreload);
-                    ESP_ERROR_CHECK(rmt_write_items(RMT_CHANNEL_0, cp->led_data, sizeof(cp->led_data) / sizeof(rmt_item32_t), true));
-                    statePreload--;
-                    if(statePreload == 0){
-                        *alarm = NO_ALARM;
-                        alarmStatebefore = NO_ALARM;
-                    }
-                    vTaskDelay(500/portTICK_PERIOD_MS);
-                break;
             break;
-            case ALARM_1KM:
+        case ALARM_300M:
-                if(alarmStateChanged){
+            if (alarmStateChanged) {
-                    alarmStatebefore = ALARM_1KM;
+                alarmStatebefore = ALARM_300M;
-                    statePreload = 20;
+                statePreload = 20;
-                    // statePreload = 120;
+            }
-                }
+            cp->flashing(Cockpit::ORANGE, statePreload);
-                // cp->flashing(orange, statePreload);
+            ESP_ERROR_CHECK(rmt_write_items(RMT_CHANNEL_0, cp->led_data,
-                // cp->colorfade(statePreload);
+                                            sizeof(cp->led_data) / sizeof(rmt_item32_t), true));
-                cp->flashing(Cockpit::BLUE, statePreload);
+            statePreload--;
-
+            if (statePreload == 0) {
-                ESP_ERROR_CHECK(rmt_write_items(RMT_CHANNEL_0, cp->led_data, sizeof(cp->led_data) / sizeof(rmt_item32_t), true));
+                *alarm = NO_ALARM;
-                statePreload--;
+                alarmStatebefore = NO_ALARM;
-                if(statePreload == 0){
+            }
-                    *alarm = NO_ALARM;
+            vTaskDelay(500 / portTICK_PERIOD_MS);
-                    alarmStatebefore = NO_ALARM;
-                    cp->turnOffLeds();
-                    ESP_ERROR_CHECK(rmt_write_items(RMT_CHANNEL_0, cp->led_data, sizeof(cp->led_data) / sizeof(rmt_item32_t), true));
-                }
-                vTaskDelay(500/portTICK_PERIOD_MS);
             break;
-            default:
+        case ALARM_500M:
-                vTaskDelay(1000/portTICK_PERIOD_MS);
+            // Serial.print("Alarm 500");
+            if (alarmStateChanged) {
+                alarmStatebefore = ALARM_500M;
+                statePreload = 20;
+            }
+            cp->flashing(Cockpit::GREEN, statePreload);
+            ESP_ERROR_CHECK(rmt_write_items(RMT_CHANNEL_0, cp->led_data,
+                                            sizeof(cp->led_data) / sizeof(rmt_item32_t), true));
+            statePreload--;
+            if (statePreload == 0) {
+                *alarm = NO_ALARM;
+                alarmStatebefore = NO_ALARM;
+            }
+            vTaskDelay(500 / portTICK_PERIOD_MS);
+            break;
+            break;
+        case ALARM_1KM:
+            if (alarmStateChanged) {
+                alarmStatebefore = ALARM_1KM;
+                statePreload = 20;
+                // statePreload = 120;
+            }
+            // cp->flashing(orange, statePreload);
+            // cp->colorfade(statePreload);
+            cp->flashing(Cockpit::BLUE, statePreload);
 
+            ESP_ERROR_CHECK(rmt_write_items(RMT_CHANNEL_0, cp->led_data,
+                                            sizeof(cp->led_data) / sizeof(rmt_item32_t), true));
+            statePreload--;
+            if (statePreload == 0) {
+                *alarm = NO_ALARM;
+                alarmStatebefore = NO_ALARM;
+                cp->turnOffLeds();
+                ESP_ERROR_CHECK(rmt_write_items(RMT_CHANNEL_0, cp->led_data,
+                                                sizeof(cp->led_data) / sizeof(rmt_item32_t), true));
+            }
+            vTaskDelay(500 / portTICK_PERIOD_MS);
+            break;
+        default:
+            vTaskDelay(1000 / portTICK_PERIOD_MS);
         }
         // Serial.println(uxTaskGetStackHighWaterMark(NULL));
     }
 }
 
-void dimmer(void * params){
+void dimmer(void * params) {
-    struct taskParams *myParams = (struct taskParams*)params;
+    struct taskParams * myParams = (struct taskParams *)params;
-    Cockpit *cp = myParams->cockpit;
+    Cockpit * cp = myParams->cockpit;
-    enum Dimmer *dimmerState = myParams->dimmerState;
+    enum Dimmer * dimmerState = myParams->dimmerState;
 
-    TaskHandle_t *thDisplayWarning = myParams->thDisplayWarning;
+    TaskHandle_t * thDisplayWarning = myParams->thDisplayWarning;
 
     uint8_t brighterPressed = 0;
     uint8_t darkerPressed = 0;
-    uint8_t ctrBrightnessChanged = 0; 
+    uint8_t ctrBrightnessChanged = 0;
 
     while (1) {
-    
+
-        if((gpio_get_level(BRIGHTER_PIN) == 0 && brighterPressed == 0) || *dimmerState == BRIGHTNESS_UP){
+        if ((gpio_get_level(BRIGHTER_PIN) == 0 && brighterPressed == 0) ||
+            *dimmerState == BRIGHTNESS_UP) {
             // brighter
             brighterPressed = 1;
             ctrBrightnessChanged = 10;
             *dimmerState = NO_DIMMER;
 
-            if(eTaskGetState(*thDisplayWarning) != eTaskState::eDeleted){
+            if (eTaskGetState(*thDisplayWarning) != eTaskState::eDeleted) {
                 vTaskSuspend(*thDisplayWarning);
-                
             }
             cp->brightnessUp();
             cp->displayBrightness();
-            ESP_ERROR_CHECK(rmt_write_items(RMT_CHANNEL_0, cp->led_data, sizeof(cp->led_data) / sizeof(rmt_item32_t), true));
+            ESP_ERROR_CHECK(rmt_write_items(RMT_CHANNEL_0, cp->led_data,
+                                            sizeof(cp->led_data) / sizeof(rmt_item32_t), true));
         }
         if (gpio_get_level(BRIGHTER_PIN) == 1 && brighterPressed == 1) {
             // brighter button released
             brighterPressed = 0;
         }
 
-        if((gpio_get_level(DARKER_PIN) == 0 && darkerPressed == 0) || *dimmerState == BRIGHTNESS_DOWN){
+        if ((gpio_get_level(DARKER_PIN) == 0 && darkerPressed == 0) ||
+            *dimmerState == BRIGHTNESS_DOWN) {
             // darker
             darkerPressed = 1;
             ctrBrightnessChanged = 10;
             *dimmerState = NO_DIMMER;
 
-            if(eTaskGetState(*thDisplayWarning) != eTaskState::eDeleted){
+            if (eTaskGetState(*thDisplayWarning) != eTaskState::eDeleted) {
                 vTaskSuspend(*thDisplayWarning);
-                
             }
             cp->brightnessDown();
             cp->displayBrightness();
-            ESP_ERROR_CHECK(rmt_write_items(RMT_CHANNEL_0, cp->led_data, sizeof(cp->led_data) / sizeof(rmt_item32_t), true));
+            ESP_ERROR_CHECK(rmt_write_items(RMT_CHANNEL_0, cp->led_data,
+                                            sizeof(cp->led_data) / sizeof(rmt_item32_t), true));
         }
         if (gpio_get_level(DARKER_PIN) == 1 && darkerPressed == 1) {
             // darker button released
@@ -152,20 +157,24 @@ void dimmer(void * params){
         }
 
         vTaskDelay(100 / portTICK_PERIOD_MS);
-        
+
-        if (ctrBrightnessChanged > 0){
+        if (ctrBrightnessChanged > 0) {
             ctrBrightnessChanged--;
 
-            if(ctrBrightnessChanged == 0){
+            if (ctrBrightnessChanged == 0) {
                 // check if there are suspended tasks
-                if(eTaskGetState(*thDisplayWarning) == eTaskState::eSuspended){
+                if (eTaskGetState(*thDisplayWarning) == eTaskState::eSuspended) {
                     cp->turnOffLeds();
-                    ESP_ERROR_CHECK(rmt_write_items(RMT_CHANNEL_0, cp->led_data, sizeof(cp->led_data) / sizeof(rmt_item32_t), true));
+                    ESP_ERROR_CHECK(rmt_write_items(RMT_CHANNEL_0, cp->led_data,
+                                                    sizeof(cp->led_data) / sizeof(rmt_item32_t),
+                                                    true));
                     vTaskResume(*thDisplayWarning);
                 }
-                else{
+                else {
                     cp->turnOffLeds();
-                    ESP_ERROR_CHECK(rmt_write_items(RMT_CHANNEL_0, cp->led_data, sizeof(cp->led_data) / sizeof(rmt_item32_t), true));
+                    ESP_ERROR_CHECK(rmt_write_items(RMT_CHANNEL_0, cp->led_data,
+                                                    sizeof(cp->led_data) / sizeof(rmt_item32_t),
+                                                    true));
                 }
             }
         }

src/tlc.hpp

@@ -5,8 +5,9 @@
 #include "Arduino.h"
 #include <stdint.h>
 #define INVERSE_MODE
-#include <inttypes.h>
 #include "driver/rmt.h"
+#include <inttypes.h>
+
 #define BUFFER_SIZE 1818
 // #include "config.h"
 
@@ -17,95 +18,80 @@
 
 class Cockpit;
 
-enum Colors {
+enum Colors { BLUE, RED, GREEN };
-    BLUE,
+typedef struct Color {
-    RED,
-    GREEN
-};
-typedef struct Color{
     uint8_t blue;
     uint8_t red;
     uint8_t green;
 } Color;
 
-enum Alarm {
+enum Alarm { ALARM_1KM, ALARM_500M, ALARM_300M, ALARM_100M, NO_ALARM };
-    ALARM_1KM,
-    ALARM_500M,
-    ALARM_300M,
-    ALARM_100M,
-    NO_ALARM
-};
 
-enum Dimmer {
+enum Dimmer { BRIGHTNESS_UP, BRIGHTNESS_DOWN, NO_DIMMER };
-    BRIGHTNESS_UP,
-    BRIGHTNESS_DOWN,
-    NO_DIMMER
-};
 
-enum Brightness{
+enum Brightness { BRIGHTER, DARKER, NO_CHANGE };
-    BRIGHTER,
-    DARKER,
-    NO_CHANGE
-};
 
-class Cockpit{
+class Cockpit {
-    private:
+private:
     // byte brightness[7] = {5, 10, 20, 50, 70, 90, 100};
     // min value 0, max value 255
     uint8_t brightness[NUM_LEDS] = {6, 25, 50, 127, 178, 229, 255};
     uint8_t brightnessState;
-    uint8_t pTime; 
+    uint8_t pTime;
     uint8_t tCycle;
     uint8_t leds; // amout of leds
     // int pin; // pin connected to uC
     gpio_num_t pin;
-    // uint8_t stateLEDs[LEDS][COLOR_CHANNELS] = {{0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}};
+    // uint8_t stateLEDs[LEDS][COLOR_CHANNELS] = {{0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0,
-    Color stateLEDs[NUM_LEDS] = {{0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}};
+    // 0}, {0, 0, 0}, {0, 0, 0}};
+    Color stateLEDs[NUM_LEDS] = {{0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0},
+                                 {0, 0, 0}, {0, 0, 0}, {0, 0, 0}};
     Color scaleBrightness(Color color, uint8_t additionDimm = 100);
     void setColorLed(Color color, uint8_t led);
-    
-    public:
-        static Color ORANGE;
-        static Color RED;
-        static Color BLUE;
-        static Color GREEN;
-        static Color CYAN;
-        static Color WHITE;
-        static Color BLACK;
-        static Color YELLOW;
-        static Color PURPLE;
-        
-		int cp;
-		bool buffer[BUFFER_SIZE];
-		rmt_item32_t led_data[BUFFER_SIZE];
-        Cockpit(gpio_num_t pin, int leds, int pTime, int tCycle, uint8_t brightness);
-        void setBrightnessState(int brightness, int state);
-        void brightnessUp();
-        void brightnessDown();
-        void displayBrightness(Color color = {.blue=255, .red=0, .green=0});
-		void turnOffLeds();
-		// void knightRider(int state);
-        void knightRiderAdvanced(Color color, int state);
-        void colorfade(int state);
-        void fillFromLeft(Color color, int state);
-        // void fillFromRight(Color color, int state);
 
-		void flashing(Color color, int state);
+public:
-		void alternating(Color color, int state, int frequencyDivider);
+    static Color ORANGE;
-        void outToIn(Color, int state);
+    static Color RED;
-        void outToInMulticolor(Color color[], uint8_t colors, int state);
+    static Color BLUE;
-        void inToOutMulticolor(Color color[], uint8_t colors, int state);
+    static Color GREEN;
+    static Color CYAN;
+    static Color WHITE;
+    static Color BLACK;
+    static Color YELLOW;
+    static Color PURPLE;
 
-		void writeLEDs();
+    int cp;
-		void writeLED(uint8_t ledNum);
+    bool buffer[BUFFER_SIZE];
-		void writeZero();
+    rmt_item32_t led_data[BUFFER_SIZE];
-		void writeOne();
+    Cockpit(gpio_num_t pin, int leds, int pTime, int tCycle, uint8_t brightness);
-		void writeCommTimer();
+    void setBrightnessState(int brightness, int state);
-		void writeCommand();
+    void brightnessUp();
-		//end of sequence (for a single driver chip)
+    void brightnessDown();
-		void waitEOS();
+    void displayBrightness(Color color = {.blue = 255, .red = 0, .green = 0});
-		//grayscale latch (for the end of a chain of driver chips)
+    void turnOffLeds();
-		void waitGSLAT();
+    // void knightRider(int state);
-		void writeData(uint8_t data);
+    void knightRiderAdvanced(Color color, int state);
+    void colorfade(int state);
+    void fillFromLeft(Color color, int state);
+    // void fillFromRight(Color color, int state);
+    void speedUpBounce(Color color, int state);
+
+    void flashing(Color color, int state);
+    void alternating(Color color, int state, int frequencyDivider);
+    void outToIn(Color, int state);
+    void outToInMulticolor(Color color[], uint8_t colors, int state);
+    void inToOutMulticolor(Color color[], uint8_t colors, int state);
+
+    void writeLEDs();
+    void writeLED(uint8_t ledNum);
+    void writeZero();
+    void writeOne();
+    void writeCommTimer();
+    void writeCommand();
+    // end of sequence (for a single driver chip)
+    void waitEOS();
+    // grayscale latch (for the end of a chain of driver chips)
+    void waitGSLAT();
+    void writeData(uint8_t data);
 };
 #endif