726 lines
19 KiB
C++
726 lines
19 KiB
C++
#include <lvgl.h>
|
|
#include <TFT_eSPI.h>
|
|
#include <ui.h>
|
|
#include <DHT.h>
|
|
#include <Arduino.h>
|
|
#include <Preferences.h>
|
|
#include <WiFi.h>
|
|
#include <ESP32Time.h>
|
|
#include "time.h"
|
|
|
|
Preferences preferences;
|
|
// #define DHTPIN 4 // GPIO-Pin, an den der Data-Pin des DHT11 angeschlossen ist
|
|
// #define DHTTYPE DHT11 // DHT 11
|
|
|
|
// DHT dht(DHTPIN, DHTTYPE);
|
|
const char* ntp = "fritz.box";
|
|
const int gmt_offset_sec = 3600;
|
|
const int daylight_offset_sec = 7200;
|
|
ESP32Time rtc(3600);
|
|
|
|
//Variablen für PWM
|
|
int pwm_freq = 5000;
|
|
int pwm_resolution = 8;
|
|
int pwm_light_resolution = 10;
|
|
|
|
//Variablen PWM fan
|
|
int fan_pwm_channel = 0;
|
|
int fan_pwm_pin = 14;
|
|
|
|
//Variable PWM LED1
|
|
int led1_pwm_channel = 1;
|
|
int led1_pwm_pin = 26;
|
|
|
|
//Variabke PWM LED2
|
|
int led2_pwm_channel = 2;
|
|
int led2_pwm_pin = 27;
|
|
|
|
char led1cycle[5] = "led1";
|
|
char led2cycle[5] = "led2";
|
|
char fancycle[4] = "fan";
|
|
|
|
|
|
|
|
//Variable zum Speichern des Status des Schalters
|
|
bool fan_active = false;
|
|
bool led1active = false;
|
|
bool led2active = false;
|
|
|
|
|
|
|
|
/* Ändern Sie dies auf die Auflösung Ihres Bildschirms */
|
|
static const uint16_t screenWidth = 320;
|
|
static const uint16_t screenHeight = 240;
|
|
|
|
|
|
|
|
enum { SCREENBUFFER_SIZE_PIXELS = screenWidth * screenHeight / 10 };
|
|
static lv_color_t buf [SCREENBUFFER_SIZE_PIXELS];
|
|
|
|
//TFT_eSPI tft = TFT_eSPI( screenWidth, screenHeight ); /* TFT-Instanz */
|
|
TFT_eSPI tft = TFT_eSPI();
|
|
#if LV_USE_LOG != 0
|
|
/* Serielle Debugging-Funktion */
|
|
void my_print(const char * buf)
|
|
{
|
|
Serial.printf(buf);
|
|
Serial.flush();
|
|
}
|
|
#endif
|
|
|
|
void scanWifi(lv_event_t * e)
|
|
{
|
|
|
|
lv_dropdown_clear_options(ui_wifinetlist);
|
|
int n = WiFi.scanNetworks();
|
|
if (n == 0)
|
|
{
|
|
Serial.println("no networks found");
|
|
lv_dropdown_add_option(ui_wifinetlist, "no networks found", n);
|
|
}
|
|
else
|
|
{
|
|
|
|
|
|
for (int i = 0; i < n; ++i)
|
|
{
|
|
lv_dropdown_add_option(ui_wifinetlist, WiFi.SSID(i).c_str(), i);
|
|
}
|
|
}
|
|
}
|
|
|
|
void setWifi(lv_event_t * e)
|
|
{
|
|
char ssid[32];
|
|
lv_dropdown_get_selected_str(ui_wifinetlist, ssid, sizeof(ssid));
|
|
const char * pw = (const char*)lv_textarea_get_text(ui_wifipw);
|
|
Serial.println(ssid);
|
|
Serial.println(pw);
|
|
WiFi.begin(ssid, pw);
|
|
int8_t counter;
|
|
while (WiFi.status() != WL_CONNECTED && counter != 10)
|
|
{
|
|
lv_label_set_text(ui_wifistatus, "Connecting...");
|
|
// Serial.println("AHHHHHH die Schleife");
|
|
delay(500);
|
|
++counter;
|
|
|
|
}
|
|
lv_label_set_text(ui_wifistatus, "Connected");
|
|
|
|
|
|
|
|
preferences.begin("wifi", false);
|
|
preferences.putString("ssid", ssid);
|
|
preferences.putString("pw", pw);
|
|
preferences.end();
|
|
|
|
|
|
|
|
}
|
|
|
|
void switchEventHandler(lv_event_t * e)
|
|
{
|
|
lv_obj_t *obj = (lv_obj_t *)lv_event_get_target(e);
|
|
char * user_data = (char*)lv_event_get_user_data(e);
|
|
preferences.begin("dutycycles", false);
|
|
int light_off_duty_cycle = 1024;
|
|
int fan_duty_cycle;
|
|
int led1_duty_cycle;
|
|
int led2_duty_cycle;
|
|
|
|
|
|
if(obj == ui_light1switch)
|
|
{
|
|
if (lv_obj_has_state(obj, LV_STATE_CHECKED))
|
|
{
|
|
led1_duty_cycle = preferences.getInt(user_data, 860);
|
|
led1active = true;
|
|
turnOn(led1_pwm_pin, led1_duty_cycle, ui_light1statuslbl, ui_lbllightstatus, ui_light1percent);
|
|
}
|
|
else
|
|
{
|
|
led1active = false;
|
|
turnOff(led1_pwm_pin, light_off_duty_cycle, ui_light1statuslbl, ui_lbllightstatus, ui_light1percent);
|
|
}
|
|
}
|
|
if(obj == ui_light2switch)
|
|
{
|
|
if (lv_obj_has_state(obj, LV_STATE_CHECKED))
|
|
{
|
|
led2_duty_cycle = preferences.getInt(user_data, 860);
|
|
led2active = true;
|
|
turnOn(led2_pwm_pin, led2_duty_cycle, ui_light2statuslbl, ui_lbllightstatus, ui_light2percent);
|
|
}
|
|
else
|
|
{
|
|
led2active = false;
|
|
turnOff(led2_pwm_pin, light_off_duty_cycle, ui_light2statuslbl, ui_lbllightstatus, ui_light2percent);
|
|
}
|
|
}
|
|
if(obj == ui_switchfanstatus)
|
|
{
|
|
if (lv_obj_has_state(obj, LV_STATE_CHECKED))
|
|
{
|
|
fan_duty_cycle = preferences.getInt(user_data, 76);
|
|
fan_active = true;
|
|
turnOn(fan_pwm_pin, fan_duty_cycle, ui_lblfanstatus, ui_lblfanspeed, ui_lblfanfanspeed);
|
|
}
|
|
else
|
|
{
|
|
int off_duty_cycle = 0;
|
|
fan_active = false;
|
|
turnOff(fan_pwm_pin, off_duty_cycle, ui_lblfanstatus, ui_lblfanspeed, ui_lblfanfanspeed);
|
|
}
|
|
}
|
|
preferences.end();
|
|
}
|
|
|
|
void turnOn(int pin, int duty_cycle, lv_obj_t * statuslbl, lv_obj_t * statusmainlbl, lv_obj_t * percent)
|
|
{
|
|
ledcWrite(pin, duty_cycle);
|
|
int percentage;
|
|
if (statusmainlbl == ui_lblfanspeed)
|
|
{
|
|
percentage = round((duty_cycle * 100.0) / 255.0);
|
|
lv_label_set_text_fmt(statusmainlbl, "%d%%", percentage);
|
|
lv_label_set_text_fmt(percent, "%d%%", percentage);
|
|
}
|
|
else
|
|
{
|
|
percentage = round(100 - (duty_cycle * 100.0) / 1024.0);
|
|
lv_label_set_text(statusmainlbl, "ON");
|
|
lv_label_set_text_fmt(percent, "%d%%", percentage);
|
|
}
|
|
lv_label_set_text(statuslbl, "ON");
|
|
}
|
|
|
|
void turnOff(int pin, int duty_cycle, lv_obj_t * statuslbl, lv_obj_t * statusmainlbl, lv_obj_t * percent)
|
|
{
|
|
ledcWrite(pin, duty_cycle);
|
|
if (statusmainlbl == ui_lblfanspeed) lv_label_set_text(statusmainlbl, "0%");
|
|
lv_label_set_text(statuslbl, "OFF");
|
|
lv_label_set_text_fmt(percent, "0%%");
|
|
|
|
if (led1active == false && led2active == false)
|
|
{
|
|
lv_label_set_text(statusmainlbl, "OFF");
|
|
}
|
|
}
|
|
void dimm(int pin, int duty_cycle, lv_obj_t * percent, lv_obj_t * percent2 = NULL)
|
|
{
|
|
int percentage = 0;
|
|
ledcWrite(pin, duty_cycle);
|
|
if (percent == ui_lblfanspeed)
|
|
{
|
|
percentage = round((duty_cycle * 100.0) / 255.0);
|
|
lv_label_set_text_fmt(percent2, "%d%%", percentage);
|
|
}
|
|
else
|
|
{
|
|
percentage = round(100.0 - (duty_cycle * 100.0) / 1024.0);
|
|
}
|
|
lv_label_set_text_fmt(percent, "%d%%", percentage);
|
|
|
|
}
|
|
|
|
static void dimmUpBtnEventHandler(lv_event_t * e)
|
|
{
|
|
int fan_duty_cycle = 3;
|
|
int led1_duty_cycle = -10;
|
|
int led2_duty_cycle = -10;
|
|
lv_obj_t *obj = (lv_obj_t *)lv_event_get_target(e);
|
|
char* user_data = (char*)lv_event_get_user_data(e);
|
|
preferences.begin("dutycycles", false);
|
|
Serial.println(user_data);
|
|
|
|
if (obj == ui_light1up)
|
|
{
|
|
if (led1active)
|
|
{
|
|
led1_duty_cycle += preferences.getInt(user_data, 860);
|
|
if (led1_duty_cycle <= 0) led1_duty_cycle = 0;
|
|
Serial.println(led1_duty_cycle);
|
|
preferences.putInt(user_data, led1_duty_cycle);
|
|
dimm(led1_pwm_pin, led1_duty_cycle, ui_light1percent);
|
|
}
|
|
}
|
|
if (obj == ui_light2up)
|
|
{
|
|
if (led2active)
|
|
{
|
|
led2_duty_cycle += preferences.getInt(user_data, 860);
|
|
if (led2_duty_cycle <= 0) led2_duty_cycle = 0;
|
|
Serial.println(led2_duty_cycle);
|
|
preferences.putInt(user_data, led2_duty_cycle);
|
|
dimm(led2_pwm_pin, led2_duty_cycle, ui_light2percent);
|
|
}
|
|
}
|
|
if (obj == ui_btnfanup)
|
|
{
|
|
if (fan_active)
|
|
{
|
|
fan_duty_cycle += preferences.getInt(user_data, 76);
|
|
if (fan_duty_cycle >= 255) fan_duty_cycle = 255;
|
|
Serial.println(fan_duty_cycle);
|
|
preferences.putInt(user_data, fan_duty_cycle);
|
|
dimm(fan_pwm_pin, fan_duty_cycle, ui_lblfanspeed, ui_lblfanfanspeed);
|
|
}
|
|
}
|
|
preferences.end();
|
|
}
|
|
|
|
static void dimmDownBtnEventHandler(lv_event_t * e)
|
|
{
|
|
lv_obj_t *obj = (lv_obj_t *)lv_event_get_target(e);
|
|
char* user_data = (char*)lv_event_get_user_data(e);
|
|
int fan_duty_cycle = -3;
|
|
int led1_duty_cycle = 10;
|
|
int led2_duty_cycle = 10;
|
|
preferences.begin("dutycycles", false);
|
|
Serial.println(user_data);
|
|
if (obj == ui_light1down)
|
|
{
|
|
if (led1active)
|
|
{
|
|
led1_duty_cycle += preferences.getInt(user_data);
|
|
if (led1_duty_cycle >= 860) led1_duty_cycle = 860;
|
|
Serial.println(led1_duty_cycle);
|
|
preferences.putInt(user_data, led1_duty_cycle);
|
|
dimm(led1_pwm_pin, led1_duty_cycle, ui_light1percent);
|
|
}
|
|
}
|
|
if (obj == ui_light2down)
|
|
{
|
|
if (led2active)
|
|
{
|
|
led2_duty_cycle += preferences.getInt(user_data);
|
|
if (led2_duty_cycle >= 860) led2_duty_cycle = 860;
|
|
Serial.println(led2_duty_cycle);
|
|
preferences.putInt(user_data, led2_duty_cycle);
|
|
dimm(led2_pwm_pin, led2_duty_cycle, ui_light2percent);
|
|
}
|
|
}
|
|
if (obj == ui_btnfandown)
|
|
{
|
|
if (fan_active)
|
|
{
|
|
fan_duty_cycle += preferences.getInt(user_data);
|
|
if (fan_duty_cycle <= 64) fan_duty_cycle = 64;
|
|
preferences.putInt(user_data, fan_duty_cycle);
|
|
dimm(fan_pwm_pin, fan_duty_cycle, ui_lblfanspeed, ui_lblfanfanspeed);
|
|
}
|
|
}
|
|
preferences.end();
|
|
}
|
|
|
|
|
|
/* Display aktualisieren */
|
|
void my_disp_flush (lv_display_t *disp, const lv_area_t *area, uint8_t *pixelmap)
|
|
{
|
|
uint32_t w = ( area->x2 - area->x1 + 1 );
|
|
uint32_t h = ( area->y2 - area->y1 + 1 );
|
|
|
|
if (LV_COLOR_16_SWAP) {
|
|
size_t len = lv_area_get_size( area );
|
|
lv_draw_sw_rgb565_swap( pixelmap, len );
|
|
}
|
|
tft.startWrite();
|
|
tft.setAddrWindow( area->x1, area->y1, w, h );
|
|
tft.pushColors( (uint16_t*) pixelmap, w * h, true );
|
|
tft.endWrite();
|
|
lv_disp_flush_ready( disp );
|
|
}
|
|
|
|
/* Touchpad lesen */
|
|
void my_touchpad_read (lv_indev_t * indev_driver, lv_indev_data_t * data)
|
|
{
|
|
uint16_t touchX = 0, touchY = 0;
|
|
bool touched = tft.getTouch( &touchX, &touchY, 600 );
|
|
|
|
if (!touched)
|
|
{
|
|
data->state = LV_INDEV_STATE_REL;
|
|
}
|
|
else
|
|
{
|
|
data->state = LV_INDEV_STATE_PR;
|
|
|
|
// Anpassung der Koordinaten für Rotation(3)
|
|
data->point.x = touchX;
|
|
data->point.y = touchY;
|
|
|
|
// Begrenze die Koordinaten auf die Bildschirmauflösung
|
|
if (data->point.x < 0) data->point.x = 0;
|
|
if (data->point.y < 0) data->point.y = 0;
|
|
|
|
|
|
// Debugging-Ausgaben
|
|
/*
|
|
Serial.print("Touch X: ");
|
|
Serial.print(data->point.x);
|
|
Serial.print(" | Touch Y: ");
|
|
Serial.println(data->point.y);
|
|
*/
|
|
}
|
|
}
|
|
|
|
/* Tick-Funktion für LVGL interne Timings */
|
|
static uint32_t my_tick_get_cb (void) { return millis(); }
|
|
|
|
|
|
|
|
|
|
|
|
|
|
struct tm timeinfo;
|
|
struct tm targettime = {0};
|
|
time_t realtime;
|
|
time_t target_sec;
|
|
time_t endtime;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
void setup ()
|
|
{
|
|
Serial.begin( 115200 ); /* Vorbereitung für mögliches serielles Debugging */
|
|
|
|
|
|
|
|
|
|
String LVGL_Arduino = "Hello Arduino! ";
|
|
LVGL_Arduino += String('V') + lv_version_major() + "." + lv_version_minor() + "." + lv_version_patch();
|
|
|
|
Serial.println( LVGL_Arduino );
|
|
Serial.println( "I am LVGL_Arduino" );
|
|
|
|
lv_init();
|
|
|
|
#if LV_USE_LOG != 0
|
|
lv_log_register_print_cb( my_print ); /* Registrieren der Print-Funktion für Debugging */
|
|
#endif
|
|
|
|
tft.begin(); /* TFT initialisieren */
|
|
tft.setRotation( 3 ); /* Landscape-Orientierung, gedreht */
|
|
|
|
// Setzen Sie Ihre Kalibrierungsdaten hier ein
|
|
uint16_t calData[5] = { 419, 3486, 314, 3434, 1 };
|
|
tft.setTouch(calData);
|
|
|
|
|
|
|
|
// PWM-Kanal konfigurieren
|
|
ledcAttachChannel(fan_pwm_pin, pwm_freq, pwm_resolution, fan_pwm_channel);
|
|
ledcAttachChannel(led1_pwm_pin, pwm_freq, pwm_light_resolution, led1_pwm_channel);
|
|
ledcAttachChannel(led2_pwm_pin, pwm_freq, pwm_light_resolution, led2_pwm_channel);
|
|
|
|
// Standardmäßig den Lüfter auf 0% Duty Cycle setzen
|
|
ledcWrite(fan_pwm_pin, 76);
|
|
ledcWrite(led1_pwm_pin, 255);
|
|
ledcWrite(led2_pwm_pin, 255);
|
|
|
|
static lv_disp_t* disp;
|
|
disp = lv_display_create( screenWidth, screenHeight );
|
|
lv_display_set_buffers( disp, buf, NULL, SCREENBUFFER_SIZE_PIXELS * sizeof(lv_color_t), LV_DISPLAY_RENDER_MODE_PARTIAL );
|
|
lv_display_set_flush_cb( disp, my_disp_flush );
|
|
|
|
static lv_indev_t* indev;
|
|
indev = lv_indev_create();
|
|
lv_indev_set_type( indev, LV_INDEV_TYPE_POINTER );
|
|
lv_indev_set_read_cb( indev, my_touchpad_read );
|
|
|
|
lv_tick_set_cb( my_tick_get_cb );
|
|
|
|
ui_init();
|
|
|
|
Serial.println( "Setup abgeschlossen" );
|
|
|
|
// DHT11-Sensor initialisieren
|
|
// dht.begin();
|
|
|
|
// Verknüpfung Funktionen UI
|
|
lv_obj_add_event_cb(ui_switchfanstatus, switchEventHandler, LV_EVENT_VALUE_CHANGED, fancycle); // Verknüpfen des Switches
|
|
lv_obj_add_event_cb(ui_btnfanup, dimmUpBtnEventHandler, LV_EVENT_CLICKED, fancycle); // Up-Button
|
|
lv_obj_add_event_cb(ui_btnfandown, dimmDownBtnEventHandler, LV_EVENT_CLICKED, fancycle);
|
|
lv_obj_add_event_cb(ui_light1switch, switchEventHandler, LV_EVENT_VALUE_CHANGED, led1cycle);
|
|
lv_obj_add_event_cb(ui_light2switch, switchEventHandler, LV_EVENT_VALUE_CHANGED, led2cycle);
|
|
lv_obj_add_event_cb(ui_light1up, dimmUpBtnEventHandler, LV_EVENT_CLICKED, led1cycle);
|
|
lv_obj_add_event_cb(ui_light2up, dimmUpBtnEventHandler, LV_EVENT_CLICKED, led2cycle);
|
|
lv_obj_add_event_cb(ui_light1down, dimmDownBtnEventHandler, LV_EVENT_CLICKED, led1cycle);
|
|
lv_obj_add_event_cb(ui_light2down, dimmDownBtnEventHandler, LV_EVENT_CLICKED, led2cycle);
|
|
lv_obj_add_event_cb(ui_wifibtn, scanWifi, LV_EVENT_CLICKED, NULL);
|
|
lv_obj_add_event_cb(ui_wifikeyboard, setWifi, LV_EVENT_READY, NULL);
|
|
lv_obj_add_event_cb(ui_savemode, saveModeSettings, LV_EVENT_CLICKED, NULL);
|
|
|
|
|
|
// Setze initial den Lüfter auf "Off" und den Schalter auf unchecked
|
|
lv_label_set_text(ui_lblfanstatus, "OFF");
|
|
lv_label_set_text(ui_lblfanfanspeed, "0%");
|
|
lv_label_set_text(ui_lblfanspeed, "0%");
|
|
lv_label_set_text(ui_lbllightstatus, "OFF");
|
|
lv_label_set_text(ui_light1statuslbl, "OFF");
|
|
lv_label_set_text(ui_light2statuslbl, "OFF");
|
|
|
|
//Speichern der var von DutyCycle led1, led2, fan
|
|
lv_dropdown_clear_options(ui_wifinetlist);
|
|
|
|
|
|
preferences.begin("wifi", false);
|
|
String ssid = preferences.getString("ssid", "");
|
|
String pw = preferences.getString("pw", "");
|
|
int8_t counter = 0;
|
|
if (ssid != "" && pw != "")
|
|
{
|
|
WiFi.begin(ssid.c_str(), pw.c_str());
|
|
//WiFi.begin("MeinZuhause", "D4n1e7Y4s3m1nUnd7ey7a");
|
|
while (WiFi.status() != WL_CONNECTED && counter != 20)
|
|
{
|
|
lv_label_set_text(ui_wifistatus, "Connecting...");
|
|
Serial.println("AHHHHHH die Schleife");
|
|
delay(500);
|
|
if (counter == 19)
|
|
{
|
|
ESP.restart();
|
|
}
|
|
|
|
++counter;
|
|
|
|
}
|
|
lv_label_set_text(ui_wifistatus, "Connected");
|
|
}
|
|
preferences.end();
|
|
|
|
int target_h;
|
|
int target_m;
|
|
bool lights;
|
|
preferences.begin("g_phase", false);
|
|
bool veggie = preferences.getBool("veggie");
|
|
bool flowering = preferences.getBool("flowering");
|
|
bool veggie_lights_on = preferences.getBool("veggie_on");
|
|
bool veggie_lights_off = preferences.getBool("veggie_off");
|
|
bool flower_lights_on = preferences.getBool("flower_on");
|
|
bool flower_lights_off = preferences.getBool("flower_off");
|
|
|
|
if (veggie)
|
|
{
|
|
lv_dropdown_set_selected(ui_growmode, 1);
|
|
if (veggie_lights_off)
|
|
{
|
|
target_h = preferences.getInt("veggie_start_h");
|
|
target_m = preferences.getInt("veggie_start_m");
|
|
lights = true;
|
|
}
|
|
else
|
|
{
|
|
target_h = preferences.getInt("veggie_end_h");
|
|
target_m = preferences.getInt("veggie_end_m");
|
|
lights = false;
|
|
}
|
|
}
|
|
else if (flowering)
|
|
{
|
|
lv_dropdown_set_selected(ui_growmode, 2);
|
|
|
|
}
|
|
else
|
|
{
|
|
lv_dropdown_set_selected(ui_growmode, 0);
|
|
}
|
|
|
|
int start_flower_h = preferences.getInt("flower_start_h");
|
|
int start_flower_m = preferences.getInt("flower_start_m");
|
|
int end_flower_h = preferences.getInt("flower_end_h");
|
|
int end_flower_m = preferences.getInt("flower_end_m");
|
|
preferences.end();
|
|
|
|
|
|
|
|
|
|
|
|
|
|
Serial.print("Starttime Flower: ");
|
|
Serial.print(start_flower_h);
|
|
Serial.print(":");
|
|
Serial.println(start_flower_m);
|
|
Serial.print("Endtime: ");
|
|
Serial.print(end_flower_h);
|
|
Serial.print(":");
|
|
Serial.println(end_flower_m);
|
|
|
|
|
|
|
|
|
|
|
|
configTime(gmt_offset_sec, daylight_offset_sec, ntp);
|
|
|
|
|
|
|
|
if(!getLocalTime(&timeinfo))
|
|
{
|
|
Serial.println("Failed to obtain time");
|
|
return;
|
|
}
|
|
|
|
realtime = mktime(&timeinfo);
|
|
targettime = timeinfo;
|
|
targettime.tm_hour = target_h;
|
|
targettime.tm_min = target_m;
|
|
targettime.tm_sec = 0;
|
|
|
|
target_sec = mktime(&targettime);
|
|
|
|
if (realtime >= target_sec)
|
|
{
|
|
|
|
}
|
|
Serial.println(&timeinfo, "Testtime: %A, %B %d %Y %H:%M:%S");
|
|
|
|
Serial.println(&targettime, "Testtime: %A, %B %d %Y %H:%M:%S");
|
|
|
|
|
|
|
|
|
|
|
|
lv_obj_add_event_cb(ui_growmode, setMode, LV_EVENT_VALUE_CHANGED, NULL);
|
|
|
|
WiFi.disconnect();
|
|
}
|
|
|
|
void loop ()
|
|
{
|
|
lv_timer_handler(); /* Lässt die GUI ihre Arbeit verrichten */
|
|
|
|
|
|
|
|
static unsigned long lastUpdate = 0;
|
|
const unsigned long updateInterval = 60000; //60 sekunden
|
|
static unsigned long lastUpdate2 = 0;
|
|
const unsigned long updateInterval2 = 1000;
|
|
|
|
unsigned long currentMillis = millis();
|
|
|
|
if (currentMillis - lastUpdate2 >= updateInterval2)
|
|
{
|
|
printTime();
|
|
realtime = mktime(&timeinfo);
|
|
//onTime();
|
|
lastUpdate2 = currentMillis;
|
|
|
|
}
|
|
|
|
if (currentMillis - lastUpdate >= updateInterval)
|
|
{
|
|
// if (realtime >= testtime2)
|
|
// {
|
|
|
|
|
|
|
|
// }
|
|
lastUpdate = currentMillis;
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
void onTime()
|
|
{
|
|
// testtime.tm_min += 5;
|
|
// int seconds = 60 * 5;
|
|
// testtime2 = mktime(&testtime);
|
|
// testtime2 += seconds;
|
|
|
|
// struct tm * test = gmtime(&testtime2);
|
|
// Serial.println(test, "Test: ,%A, %B %d %Y %H:%M:%S");
|
|
|
|
}
|
|
|
|
void saveModeSettings(lv_event_t * e)
|
|
{
|
|
char mode[32];
|
|
char start_h[32];
|
|
char start_m[32];
|
|
char end_h[32];
|
|
char end_m[32];
|
|
|
|
lv_dropdown_get_selected_str(ui_setmode, mode, sizeof(mode));
|
|
lv_roller_get_selected_str(ui_starthour, start_h, sizeof(start_h));
|
|
lv_roller_get_selected_str(ui_startmin, start_m, sizeof(start_h));
|
|
lv_roller_get_selected_str(ui_endhour, end_h, sizeof(end_h));
|
|
lv_roller_get_selected_str(ui_endmin, end_m, sizeof(end_h));
|
|
|
|
int start_hour = atoi(start_h);
|
|
int start_min = atoi(start_m);
|
|
int end_hour = atoi(end_h);
|
|
int end_min = atoi(end_m);
|
|
|
|
preferences.begin("g_phase", false);
|
|
if (!strncmp(mode, "Veggie", 6))
|
|
{
|
|
preferences.putInt("veggie_start_h", start_hour);
|
|
preferences.putInt("veggie_start_m", start_min);
|
|
preferences.putInt("veggie_end_h", end_hour);
|
|
preferences.putInt("veggie_end_m", end_min);
|
|
}
|
|
else if (!strncmp(mode, "Flower", 6))
|
|
{
|
|
preferences.putInt("flower_start_h", start_hour);
|
|
preferences.putInt("flower_start_m", start_min);
|
|
preferences.putInt("flower_end_h", end_hour);
|
|
preferences.putInt("flower_end_m", end_min);
|
|
}
|
|
preferences.end();
|
|
}
|
|
|
|
void setMode(lv_event_t * e)
|
|
{
|
|
char mode[8];
|
|
lv_dropdown_get_selected_str(ui_growmode, mode, sizeof(mode));
|
|
preferences.begin("g_phase", false);
|
|
if (!strncmp(mode, "Manuell", 7))
|
|
{
|
|
preferences.putBool("veggie", false);
|
|
preferences.putBool("flowering", false);
|
|
}
|
|
else if (!strncmp(mode, "Veggie", 6))
|
|
{
|
|
preferences.putBool("veggie", true);
|
|
preferences.putBool("flowering", false);
|
|
}
|
|
else
|
|
{
|
|
preferences.putBool("veggie", false);
|
|
preferences.putBool("flowering", true);
|
|
}
|
|
preferences.end();
|
|
}
|
|
|
|
|
|
|
|
void veggie()
|
|
{
|
|
|
|
}
|
|
|
|
void flowering()
|
|
{
|
|
|
|
}
|
|
|
|
|
|
void printTime()
|
|
{
|
|
struct tm timeinfo;
|
|
if(!getLocalTime(&timeinfo))
|
|
{
|
|
Serial.println("Failed to obtain time");
|
|
return;
|
|
}
|
|
char clock[80];
|
|
strftime(clock,80,"Uhrzeit: %H:%M:%S",&timeinfo);
|
|
lv_label_set_text(ui_lblclock, clock);
|
|
}
|