johannes/Sicherheitssystem
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

cleanup

Browse Source
This commit is contained in:
Johannes Paehr
2025-07-21 17:37:29 +02:00
parent 1ebca3056e
commit 84276dd1e5
8 changed files with 806 additions and 817 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
src/CMakeLists.txt
View File

@@ -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/*.*)

80
src/MyBLEServer.cpp Normal file
View File

@@ -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();
}
}

29
src/MyBLEServer.hpp Normal file
View File

@@ -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

3
src/config.hpp
View File

@@ -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

259
src/main.cpp
View File

@@ -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 "tlc.hpp"
#include "MyBLEServer.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
const char * ssid = SECRET_SSID;
const char * password = SECRET_PASS;
// #define TESTMODE 1
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 {
bool deviceConnected = false;
// deviceConnected = true;
// _BLEClientConnected = true;
// };
void onConnect(BLEServer * pServer) {
Serial.println("Callback connected");
deviceConnected = true;
_BLEClientConnected = true;
};
// void onDisconnect(BLEServer * pServer) {
// _BLEClientConnected = false;
// deviceConnected = false;
// }
void onDisconnect(BLEServer * pServer) {
_BLEClientConnected = false;
deviceConnected = false;
}
public:
bool getConnectionState(){
return deviceConnected;
}
};
// public:
// bool getConnectionState() { return deviceConnected; }
// };
bool brighter = false;
bool darker = false;
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) {
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;
MyServerCallbacks *serverCallback = new MyServerCallbacks();
MyAlarmCallback * myAlarmCallback = new MyAlarmCallback();
BLEServer * pServer = NULL;
MyServerCallbacks * serverCallback = new MyServerCallbacks(&_BLEClientConnected);
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.commit();
#endif
EEPROM.write(MODE_ADDRESS, MODE_BLE);
EEPROM.commit();
#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
pServer->startAdvertising(); // restart advertising
Serial.println("start advertising");
delay(500); // give the bluetooth stack the chance to get thingsready
pServer->startAdvertising(); // restart advertising Serial.println("startadvertising ");
oldDeviceConnected = serverCallback->getConnectionState();
}
// connecting
if (serverCallback->getConnectionState() && !oldDeviceConnected) {
// do stuff here on connecting
oldDeviceConnected = serverCallback->getConnectionState();
Color c[] = {
Cockpit::YELLOW,
Cockpit::RED,
Cockpit::PURPLE,
Cockpit::BLUE,
Cockpit::CYAN,
Cockpit::GREEN,
Cockpit::YELLOW,
Cockpit::RED,
Cockpit::PURPLE,
Cockpit::BLUE,
Cockpit::CYAN,
Cockpit::GREEN
};
Color c[] = {Cockpit::YELLOW, Cockpit::RED, 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));
// delay(100);
// ESP_ERROR_CHECK(rmt_write_items(RMT_CHANNEL_0, cockpit.led_data,
// 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));
}
}
}

203
src/tasks.cpp
View File

@@ -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){
struct taskParams *myParams = (struct taskParams*)params;
Cockpit *cp = myParams->cockpit;
enum Alarm *alarm = myParams->alarmFired;
void displayWarning(void * params) {
struct taskParams * myParams = (struct taskParams *)params;
Cockpit * cp = myParams->cockpit;
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:
vTaskDelay(100/portTICK_PERIOD_MS);
case NO_ALARM:
vTaskDelay(100 / portTICK_PERIOD_MS);
break;
case ALARM_100M:
if(alarmStateChanged){
alarmStatebefore = ALARM_100M;
statePreload = 30;
}
cp->flashing(Cockpit::WHITE, 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(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;
case ALARM_100M:
if (alarmStateChanged) {
alarmStatebefore = ALARM_100M;
statePreload = 30;
}
cp->flashing(Cockpit::WHITE, 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(300 / portTICK_PERIOD_MS);
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);
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;
default:
vTaskDelay(1000/portTICK_PERIOD_MS);
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:
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){
struct taskParams *myParams = (struct taskParams*)params;
Cockpit *cp = myParams->cockpit;
enum Dimmer *dimmerState = myParams->dimmerState;
void dimmer(void * params) {
struct taskParams * myParams = (struct taskParams *)params;
Cockpit * cp = myParams->cockpit;
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));
}
}
}

920
src/tlc.cpp
View File

File diff suppressed because it is too large Load Diff

128
src/tlc.hpp
View File

@@ -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 {
BLUE,
RED,
GREEN
};
typedef struct Color{
enum Colors { BLUE, RED, GREEN };
typedef struct Color {
uint8_t blue;
uint8_t red;
uint8_t green;
} Color;
enum Alarm {
ALARM_1KM,
ALARM_500M,
ALARM_300M,
ALARM_100M,
NO_ALARM
};
enum Alarm { ALARM_1KM, ALARM_500M, ALARM_300M, ALARM_100M, NO_ALARM };
enum Dimmer {
BRIGHTNESS_UP,
BRIGHTNESS_DOWN,
NO_DIMMER
};
enum Dimmer { BRIGHTNESS_UP, BRIGHTNESS_DOWN, NO_DIMMER };
enum Brightness{
BRIGHTER,
DARKER,
NO_CHANGE
};
enum Brightness { BRIGHTER, DARKER, NO_CHANGE };
class Cockpit{
private:
class Cockpit {
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}};
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}};
// 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}};
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);
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);
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;
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);
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 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