Kód: Vybrat vše
substitutions:
device_name: thetlacitko
hw_ver: "0.7"
sw_ver: "0.2.2"
additional_delay: "1150ms" #HA 2022.12 bud reaguje pomaleji, nebo musi projit vsechny hodnoty pres mqtt, delsi pauza pred vypnutim
# "The Tlačítko": Hardware: Napájení pro ESP8266 je spínáno přes high side mosfet s pomocnými obvody řešícími nabíjení,
# měření napětí baterie (GPIO12 ovládá připojení odporového děliče), jeho výstup lze pak měřit na A0.
# detekci připojené nabíječky (GPIO13)
# detekci dalších stisků napájecího tlačítka (GPIO14)
# a především možnost vypnutí napájení (GPIO15) samotným ESP8266
# GPIO4 a GPIO5 jsou využity pro I2C komunikaci
# 1) s displejem
# 2) externím RTC RV-3028-C7 (se spotřebou v řádech nA) pro další možnost zapnutí (není v této verzi SW implementováno)
#
# logika tlačítka:
# ----------------
# Fyzicky jde zapnout stiskem tlačítka. Start nějakou dobu trvá, tlačítko v okamžiku připojení k wifi+mqtt již nemusí být stlačené. Přesto musím dát vědět HA že tlačítko bylo stisknuto. Mělo by snad stačit MQTT s QOS=1
# Stav fyzického ftlacitko se zrcadlí do tlacitko(template), právě kromě startu, kdy je toto chování blokováno (viz globals) abych nebyl při programové simulaci prvního stisku rušen stavem fyzického ftlacitko.
#
# Při startu zkontroluji proč ESP vlastně startuje
# - bylo zapnuto napájením - odešle mqtt simulaci stisk tlačítka
# - probudilo se z deepsleep - nic neodesílá
# - restart po OTA - nic neodesílá
#
# logika napájení:
# ----------------
# Zapnutí tlačítkem, senzorem, časovačem atd. Zapínací pulz musí být dostatečně dlouhý
# - switch hold_on musím zapnout co nejdříve aby si napájení zachovalo i při uvolnění napájecího tlačítka
# - D8 (GPIO15) použitý na "hold_on" by někde v této části zapojení snad mohl jít přidat kondenzátor aby mi podržel přes 110ms "glitch" původní stav https://rabbithole.wwwdotorg.org/2017/03/28/esp8266-gpio.html
#
# Podmínky vypnutí:
# po vyhodnocení "logika tlačítka" a případném odeslání mqtt simulace tlačítka
# pokud
# nechci flashovat (není nastavený mqtt topic ota_mode)
# a
# nejsem napájený z USB (binary senzor usb_zapojeno)
# hodím ESP na chvíli do deep_sleep kde je procesor vypnutý a JEN ZŮSTANE ZOBRAZOVAT poslední DISPLEJ (<10mA)
# po probuzení z deep_sleep zařízení vypnu shozením "switch hold_on"
#
# ota_mode - mqtt switch - definovaný v HA configuration.yaml, NE TADY! - tlačítko si jej samo vypne po skončení flashování
#
# displej 0.49" I2C SSD1306 64x32 - automatickou aktualizaci vypínám, aktualizuji především "ručně" na základě "on_value" u komponentů které na displeji zobrazuji
#
# font_ikony:
# Preview https://pictogrammers.github.io/@mdi/font/7.0.96/
# Download: https://cdnjs.com/libraries/MaterialDesign-Webfont/7.0.96
#
##################################################### mqtt switch ota_mode - zapsat do configuration.yaml HA ################################
# mqtt:
# switch:
# - command_topic: "thetlacitko/ota"
# state_topic: "thetlacitko/ota"
# unique_id: thetlacitko_ota
# name: "theTlacitko OTA Mode"
# icon: "mdi:upload"
# retain: true
############################################################################################################################################
esphome:
name: ${device_name}
platform: esp8266
board: esp12e
platformio_options:
board_build.f_cpu: 80000000L
on_boot:
- priority: 900.0
then:
- lambda: |-
// id(cpu_speed) = ESP.getCpuFreqMHz() ;
// id(${device_name}_wake_up_reason) = esp_sleep_get_wakeup_cause(); //jen ESP32, pro ESP8266 nepoužitelné.
id(wake_up_reason) = ESP.getResetInfoPtr()->reason; //hledal jsem řešení celý den. int. 4 - po OTA, 5- po deepsleep, 6- power_on
- priority: 750.0
then:
# Přidržet napájení co nejdříve, tady už jsou piny inicializované, ale je to "pocitově -neměřeno- daleko dříve" než proběhne nastavení dle "restore_mode: ALWAYS_ON" u komponenty
- switch.turn_on: ${device_name}_hold_on
# Blokovat kopírování stavu z fyzického na template tlačítko - protože startuji tak se buď vypnu po deepsleep - tedy tlačítko mne nezajímá, nebo startuji po zapnutí a tedy musím nasimulovat stisk virtuálního programově
# Odblokuji až
- globals.set:
id: blokovano_fyzicke_tlacitko
value: '1'
# inicializuji virtualni senzory pouzite jako vystupy stavu tlacitka
- lambda: |-
id(oneclick).publish_state(false);
id(doubleclick).publish_state(false);
id(clickhold).publish_state(false);
- priority: 300.0 # vypnutí zařízení nebo okamzite zobrazeni display
then:
- if:
condition:
lambda: 'return ((id(wake_up_reason) == 5)||(id(wake_up_reason) == 4));' #teoreticky by stacilo !=6, ale nezkoumal jsem ostatní hodnoty.
then: # //po deepsleep kdy se jen zobrazoval display vypni napájení (nebo po flashnutí)
- switch.turn_off: ${device_name}_hold_on
else:
- component.update: ${device_name}_counter_stisku
- switch.turn_on: ${device_name}_zmer_baterii
- component.update: ${device_name}_bat
- component.update: mydisplay
- script.execute: inicializace
# případná změna hesla pro OTA
# - lambda: |-
# id(${device_name}_ota).set_auth_password("NoveOtaHeslo");
# Enable/disable logging
logger:
deassert_rts_dtr: true
baud_rate: 0
level: NONE
# level: VERY_VERBOSE #default jen debug
# Enable Home Assistant API
# API je pro věci s deep_sleep apod. nepoužitelné, půjdeme přes MQTT - request #46 otevřený od února 2019 https://github.com/esphome/feature-requests/milestone/2
# api:
# encryption:
# key: "294fVK6XAxWGYn5tnz2pQZMP4+ojX4xpbKjlG+uFa4Q="
ota:
safe_mode: false
password: !secret ota_password
id: ${device_name}_ota
on_end:
then:
- lambda: |-
id(ota_mode) = 0;
- mqtt.publish:
topic: $device_name/ota
payload: 'OFF'
retain: true
- component.update: mydisplay
wifi:
ssid: !secret wifi_ssid
password: !secret wifi_password
power_save_mode: NONE
fast_connect: true
manual_ip: #šetřím pár ms vynecháním DHCP
static_ip: 192.168.199.230
gateway: 192.168.199.1
subnet: 255.255.255.0
dns1: 192.168.199.2
# Enable fallback hotspot (captive portal) in case wifi connection fails
ap: {}
# Nechame ho jako device_name a bez hesla, jinak:
# ssid: "${device_name} Fallback Hotspot"
# password: "dfN8BKOvThhg"
captive_portal:
button:
- platform: safe_mode
name: "${device_name} Restart (Safe Mode)"
mqtt:
id: mqtt_cli
# broker: !secret broker
broker: !secret brokerip #šetřím pár ms vynecháním DNS
username: !secret broker_user
password: !secret broker_pw
discovery_object_id_generator: device_name
# log_topic: null
discovery: true
reboot_timeout: 30s
# birth necham default, will zakazu, u každého senzoru který chci vidět jako nedostupný pak musím nastavit availability topic ručně
# pokud bych will nezakázal, nastaví availability topic automaticky - pro všechno - v rámci discovery
# birth_message:
will_message:
on_message: #Zjistím stav HA MQTT switche povolujícího OTA
- topic: $device_name/ota
payload: 'ON'
then:
- lambda: |-
id(ota_mode) = 1;
- topic: $device_name/ota
payload: 'OFF'
then:
- lambda: |-
id(ota_mode) = 0;
globals:
- id: wake_up_reason
type: int
restore_value: no
initial_value: '0'
- id: pocet_stisku
type: int
restore_value: no
initial_value: '0'
- id: ota_mode
type: int
restore_value: no
initial_value: '0'
- id: blokovano_fyzicke_tlacitko
type: int
initial_value: '1'
- id: rucni_zakaz_spanku #asi pres drzeni tlacitka nebo neco podobneho TODO!
# 1) porovnam zda je drzeno fyzicke tlacitko jeste i v dobe kdy jsem pripojen na mqtt
# 2) druhym dlouhym drzenim zase zarizeni vypnu
type: int
initial_value: '0'
restore_value: False
script: #skript je vykonavan synchronne, narozdil od logiky komponent
- id: inicializace
mode: single
then:
- component.update: hw_version
- component.update: sw_version
- wait_until: mqtt.connected
- delay: 50ms
- mqtt.publish:
topic: "$device_name/status"
payload: "online"
retain: true
- lambda: |-
id(mqtt_cli).subscribe("$device_name/ota", [=](const std::string &topic, const std::string &payload) {
id(ota_mode) = (payload.compare("ON") == 0);
});
#nasimuluji stisk tlacitka, o dalsi se postara samo ve svem on state kodu.
# Spoléhám se na to že MQTT si zprávy řadí do fronty a s nastaveným QOS1 je vždy odešle
# Pokud by tohle bylo nespolehlivé tak
# to celé přepíšu logikou wait until subscribe payload = state || timeout - a když timeout tak párkrát opakuj nebo vyhodím chybu že mqtt nefunguje TODO!!!
# Stavy odeslat jako Prostě vypnuto/zapnuto/vypnuto. Navíc k tomu musím potlačit případné "zapnuto" fyzického tlačítka (jen čekat dokud se neuvolní) předtím než povolím kopírování fyzické - virtual pokud by jej někdo ještě stále držel.
#
- if: #CCekej dokud není při startu uvolněno fyzické tlačítko, ale minimálně 50ms než odešleš že bylo uvolněno.
condition:
- binary_sensor.is_off: ${device_name}_ftlacitko
then: # Pokud v tomto okamziku kdy uz jsem pripojen na mqtt uz neni drzeno tlacitko tak odeslu virtualni stisk, povolim kopirovani stavu (kdyby byl zakazany spanek) a pripadne se vypnu pres deepsleep
- delay: 50ms #chvilku pockam, jinak se nic pres mqtt nestihne poslat pred usnutim
- lambda:
id(${device_name}_tlacitko).publish_state(true);
- component.update: mydisplay
- delay: 50ms
- lambda:
id(${device_name}_tlacitko).publish_state(false);
- globals.set: #odblokuji kopírování stavu fyzického ftlacitko na tlacitko
id: blokovano_fyzicke_tlacitko
value: '0'
- if:
condition:
- lambda: 'return id(spanek_povolen).state;'
then:
- delay: 150ms #Netuším jak zkontrolovat zda fronta mqtt zpráv je prázdná, raději počkám. Možná přes subscribe topic porovnat zprávu zpět? TODO!
- delay: $additional_delay #HA 2022.12 reaguje pomaleji
- deep_sleep.enter: spanek
else: #Porad jeste drzim tlacitko, pockam nez ho pustim, povolim kopirovani stavu, zakazu spanek, a hlavnbe zadny virtualni stisk neodesilam
- wait_until:
condition:
- binary_sensor.is_off: ${device_name}_tlacitko
- globals.set:
id: rucni_zakaz_spanku
value: 'true'
- globals.set:
id: blokovano_fyzicke_tlacitko
value: 'false'
interval: #Pokud jsem "on a nespavec" tak měř baterii každých 5s
- interval: 5s
then:
- if:
condition:
- lambda: 'return id(spanek_povolen).state == false;'
then:
- switch.turn_on: ${device_name}_zmer_baterii
- component.update: ${device_name}_bat
# - switch.toggle: ${device_name}_blueLED
# HW a SW verze - pokud budu mít na síti více tlačítek tak mohu chtít OTA jen pro některé - přidat více ota přepínačů do HA a v tomto SW je detekovat
text_sensor:
- platform: template
name: "HW Version"
id: hw_version
lambda: 'return std::string("${hw_ver}");'
update_interval: never
- platform: template
name: "SW Version"
id: sw_version
lambda: 'return std::string("${sw_ver}");'
update_interval: never
sensor:
- platform: adc
pin: A0
id: ${device_name}_bat
device_class: voltage
name: "${device_name} napětí baterie"
accuracy_decimals: 2
unit_of_measurement: "V"
update_interval: never
filters:
- multiply: 4.2
on_value:
- switch.turn_off: ${device_name}_zmer_baterii
- component.update: mydisplay
# availability:
# topic: "$device_name/status"
- platform: template
name: "${device_name} počet stisků"
id: ${device_name}_counter_stisku
icon: mdi:counter
accuracy_decimals: 0
lambda: |-
return (id(pocet_stisku));
unit_of_measurement: ""
update_interval: never
# availability:
# topic: "$device_name/status"
- platform: template
name: "${device_name} Kdo mne budi"
id: ${device_name}_kdo_mne_budi
accuracy_decimals: 0
lambda: |-
return (id(wake_up_reason));
# availability:
# topic: "$device_name/status"
- platform: uptime
device_class: duration
name: ${device_name} Uptime Sensor
id: ${device_name}_time_since_boot
update_interval: 60s # 60s je default
availability:
topic: "$device_name/status"
- platform: template
name: "${device_name} procent baterie"
id: bat_pct
accuracy_decimals: 0
unit_of_measurement: "%"
device_class: battery
lambda: return id(${device_name}_bat).state ;
filters:
- calibrate_polynomial:
degree: 3
datapoints:
- 0.00 -> 0.0
# - 2.97 -> 0.0 #umře
# - 3.15 -> 0.0 #nestartuje občas spolehlivě
- 3.20 -> 0.0
- 3.28 -> 10.0
- 3.33 -> 20.0
- 3.40 -> 30.0
- 3.48 -> 40.0
- 3.57 -> 50.0
- 3.65 -> 60.0
- 3.72 -> 70.0
- 3.80 -> 80.0
- 3.88 -> 90.0
- 4.15 -> 95.0
- 4.20 -> 100.0
- lambda: |-
if (x <= 100) {
return x;
} else {
return 100;
}
- platform: wifi_signal
id: wifisignal
name: "WiFi Signal Sensor"
update_interval: 1s # default 60s, neni nejlepší nápad nechat internal:false a nízký update interval - zbytečný provoz mqtt
internal: true
on_value:
then:
- component.update: mydisplay
binary_sensor:
- platform: gpio
name: "${device_name} ftlacitko"
id: ${device_name}_ftlacitko
pin:
number: GPIO14
inverted: false
mode:
input: true
pullup: false
filters:
- delayed_on: 30ms
- delayed_off: 30ms
# pripadne dalsi akce - https://esphome.io/components/binary_sensor/index.html#binary-sensor-on-click
# availability:
# topic: "$device_name/status"
- platform: template
name: "${device_name} tlacitko"
id: ${device_name}_tlacitko
lambda: |-
if (id(blokovano_fyzicke_tlacitko) == 0) {
return id(${device_name}_ftlacitko).state ;
} else {
return id(${device_name}_tlacitko).state;
}
on_press: #falling edge
then:
- component.update: mydisplay
# on_click: #leading edge //tohle nejde pouzit v automatizacich HA, neexistuje on_click, musel by se navazat switch template - a vlastne proc ne - rozlisime akce podle click, double, triple... uvidim jak to pujde v kombinaci s prvnim simulovanym stiskem = TODO!!!
# to je ale kravina - na jeden double click jsou ZÁROVEŇ dva on click - musím na to jít přes multiclick.
# on_click:
# # pocet stisku spise pri on_click presunout do kodu pro oneclick template switch
# # Togle vynechat pokud budu pouzivat on_press
# then:
# - lambda: |-
# id(pocet_stisku)++;
# id(oneclick).toggle();
# - component.update: ${device_name}_counter_stisku
# - component.update: mydisplay
on_release:
then:
- component.update: mydisplay
# on_double_click:
# min_length: 50ms
# max_length: 350ms
# then:
# - lambda: 'id(doubleclick).toggle();'
# # - switch.turn_off: ${device_name}_hold_on
on_multi_click:
- timing:
- ON for at most 1s
- OFF for at most 0.3s
- ON for at most 1s
- OFF for at least 0.2s
then:
- if: #reverzace prislusneho virtualniho vystupu, byt by vzdy mela byt false - vystup si stav temer okamzite obraci na false - simuluje button - zjednoduseni automatizaci
condition:
- binary_sensor.is_on: doubleclick
then:
- lambda: id(doubleclick).publish_state(false);
else:
- lambda: id(doubleclick).publish_state(true);
- timing:
- ON for at most 1s
- OFF for at least 0.5s
then:
- if:
condition:
- binary_sensor.is_on: oneclick
then:
- lambda: id(oneclick).publish_state(false);
else:
- lambda: id(oneclick).publish_state(true);
- timing:
- ON for at least 3s
then:
- if:
condition:
- binary_sensor.is_on: clickhold
then:
- lambda: id(clickhold).publish_state(false);
else:
- lambda: id(clickhold).publish_state(true);
on_state:
then:
- mqtt.publish:
topic: "${device_name}/binary_sensor/${device_name}_tlacitko/state"
payload: id(${device_name}_tlacitko).state
qos: 1 # Pokud stačí QOS 0 tak celý mqtt.publish blok lze vynechat
- platform: gpio
name: "${device_name} usb_zapojeno"
id: ${device_name}_usb_zapojeno
pin:
number: GPIO13
inverted: false
mode:
input: true
pullup: false
availability:
topic: "$device_name/status"
- platform: template
internal: false
name: "${device_name} spánek povolen"
id: spanek_povolen
# publish_initial_state: True
lambda: |-
return (
(id(${device_name}_usb_zapojeno).state == false) && !(id(ota_mode)) && (id(wake_up_reason) != 5 && !(id(rucni_zakaz_spanku))));
on_press:
then:
- deep_sleep.allow: spanek
- component.update: mydisplay
on_release:
then:
- deep_sleep.prevent: spanek
- component.update: mydisplay
availability:
topic: "$device_name/status"
##################################### virtualni vystupy z tlacitka
- platform: template
name: oneclick
id: oneclick
publish_initial_state: True
on_press:
then:
- lambda: id(pocet_stisku)++;
- component.update: ${device_name}_counter_stisku
- component.update: mydisplay
- delay: 150ms
- lambda: id(oneclick).publish_state(false);
- platform: template
name: doubleclick
id: doubleclick
publish_initial_state: True
on_press:
then:
- delay: 50ms
- lambda: id(doubleclick).publish_state(false);
- platform: template
name: clickhold
id: clickhold
publish_initial_state: True
on_press:
then:
- delay: 50ms
- lambda: id(clickhold).publish_state(false);
- if:
condition:
- lambda: 'return id(rucni_zakaz_spanku);'
then:
- globals.set:
id: rucni_zakaz_spanku
value: 'false'
- component.update: mydisplay
- delay: 50ms
- deep_sleep.enter: spanek # mozna zakomentovat, nepujdeme rovnou, co kdyz je ota nebo usb? Ale pokud povazuji podrzeni za chtene vypnuti (logicke ?) tak vypnu rovnou nezavisle na ostatnich podminkach
else:
- deep_sleep.prevent: spanek
##############################################
switch:
- platform: gpio
pin: GPIO15
name: "${device_name} Hold on"
id: ${device_name}_hold_on
restore_mode: ALWAYS_ON
- platform: gpio
pin:
number: GPIO2 #nepouzivat 14 - shodi naapeti R13-R14 na 0.7V
mode: output
id: blueLED
restore_mode: ALWAYS_OFF
- platform: gpio
name: "${device_name} změř"
id: ${device_name}_zmer_baterii
pin:
number: GPIO12
inverted: false
mode:
output: true
pullup: false
internal: true
restore_mode: ALWAYS_OFF
availability:
topic: "$device_name/status"
font:
- file: "fonts/arial.ttf"
id: pismo
size: 14
- file: "fonts/materialdesignicons-webfont.ttf"
id: ikony
size: 16
glyphs: [
# Wifi
'', # F092F mdi-wifi-strength-outline
'', # F091F mdi-wifi-strength-1
'', # F0922 mdi-wifi-strength-2
'', # F0925 mdi-wifi-strength-3
'', # F0928 mdi-wifi-strength-4
# Battery
'', # F10CD mdi-battery-alert-variant-outline
'', # F007A mdi-battery-10
'', # F007B mdi-battery-20
'', # F007C mdi-battery-30
'', # F007D mdi-battery-40
'', # F007E mdi-battery-50
'', # F007F mdi-battery-60
'', # F0080 mdi-battery-70
'', # F0081 mdi-battery-80
'', # F0082 mdi-battery-90
'', # F0079 mdi-battery 100
'', # F089F mdi-battery-charging-outline
'', # F089C mdi-battery-charging-10
'', # F0086 mdi-battery-charging-20
'', # F0087 mdi-battery-charging-30
'', # F0088 mdi-battery-charging-40
'', # F089D mdi-battery-charging-50
'', # F0089 mdi-battery-charging-60
'', # F089E mdi-battery-charging-70
'', # F008A mdi-battery-charging-80
'', # F008B mdi-battery-charging-90
'', # F0085 mdi-battery-charging-100
# Button
'', # mdi-gesture-tap-button
'', # mdi-gesture-tap-hold
'', # F0199 mdi-counter
'', # F0E9F mdi-electric-switch
'', # F10D9 mdi-electric-switch-closed
'', # F044A mdi-record
'', # F0EC2 mdi-record-circle
'', # F0EC3 mdi-record-circle-outline
'', # F043D mdi-radiobox-blank
'', # F043E mdi-radiobox-marked
# MQTT connection
'', # F0318 mdi-lan-connect
'', # F0319 mdi-lan-disconnect
# OTA
'', # F137E mdi-auto-download
'', # F01DA mdi-download
# Spanek
'', # F04B2 mdi-sleep
'', # F04B3 mdi-sleep-off
]
i2c:
sda: GPIO4
scl: GPIO5
display:
- platform: ssd1306_i2c
model: "SSD1306 64x32"
# reset_pin: D0
flip_x: false
flip_y: false
rotation: 180
address: 0x3C
id: mydisplay
update_interval: never #normalne 1s, never = rucne
lambda: |-
int x, y, zmod;
// Print time in HH:MM format
// it.strftime(0, 0, id(pismo), "%H:%M", id(esptime).now());
// it.printf(0,20, id(pismo), "stisku: %g, %d", id(${device_name}_counter_stisku).state, id(wake_up_reason));
//it.printf(0,20, id(pismo), "bat: %.2f V", id(${device_name}_bat).state);
//it.printf(0, 18, id(ikony), id(${device_name}_tlacitko).state ? COLOR_ON : COLOR_OFF, TextAlign::TOP_LEFT, "%s", (id(mqtt_cli)->is_connected()) ? "" : "");
it.printf(0, 18, id(ikony), id(${device_name}_tlacitko).state ? COLOR_ON : COLOR_OFF, TextAlign::TOP_LEFT, "%s", "" );
it.print(30,19, id(ikony), TextAlign::TOP_LEFT,"");
it.printf(63,18, id(pismo), TextAlign::TOP_RIGHT,"%g", id(${device_name}_counter_stisku).state);
// ted oddelit linkou a vykreslit horni stavovy radek #####################################################################
it.line(0, 16, 63, 16);
//ikona stavu MQTT
x = 17, y=0;
// it.printf(x, y, id(ikony), TextAlign::TOP_LEFT, "%s", (id(mqtt_cli)->is_connected()) ? "" : "");
it.printf(x, y, id(ikony), (id(mqtt_cli)->is_connected()) ? COLOR_ON : COLOR_OFF, TextAlign::TOP_LEFT, "%s", "");
//ikona stavu OTA
x=34, y=0;
if (id(ota_mode)) {
it.print(x, y, id(ikony), TextAlign::TOP_LEFT, "");
} else {
it.printf(x, y, id(ikony), TextAlign::TOP_LEFT, "%s", (id(spanek_povolen).state) ? "" : "");
}
// WiFi Signal Strenght
if(id(wifisignal).has_state()) {
// it.printf(0,10, id(pismo), " %.0f db", id(wifisignal).state);
x = 0, y = 0;
if (id(wifisignal).state >= -50) {
//Excellent
it.print(x, y, id(ikony), TextAlign::TOP_LEFT, "");
// ESP_LOGI("WiFi", "Exellent");
} else if (id(wifisignal).state >= -60) {
//Good
it.print(x, y, id(ikony), TextAlign::TOP_LEFT, "");
// ESP_LOGI("WiFi", "Good");
} else if (id(wifisignal).state >= -67) {
//Fair
it.print(x, y, id(ikony), TextAlign::TOP_LEFT, "");
// ESP_LOGI("WiFi", "Fair");
} else if (id(wifisignal).state >= -70) {
//Weak
it.print(x, y, id(ikony), TextAlign::TOP_LEFT, "");
// ESP_LOGI("WiFi", "Weak");
} else {
//Unlikely working signal
it.print(x, y, id(ikony), TextAlign::TOP_LEFT, "");
// ESP_LOGI("WiFi", "Unlikely");
}
}
/**/
/* Battery Voltage Discharging */
if(id(bat_pct).has_state() && !(id(${device_name}_usb_zapojeno).state) ) {
x = 63, y = 0;
if (id(bat_pct).state >= 97) {
// 100 %
it.print(x, y, id(ikony), TextAlign::TOP_RIGHT, "");
} else if (id(bat_pct).state >= 90) {
// 90 %
it.print(x, y, id(ikony), TextAlign::TOP_RIGHT, "");
} else if (id(bat_pct).state >= 80) {
// 80%
it.print(x, y, id(ikony), TextAlign::TOP_RIGHT, "");
} else if (id(bat_pct).state >= 70) {
// 70%
it.print(x, y, id(ikony), TextAlign::TOP_RIGHT, "");
} else if (id(bat_pct).state >= 60) {
// 60%
it.print(x, y, id(ikony), TextAlign::TOP_RIGHT, "");
} else if (id(bat_pct).state >= 50) {
// 50%
it.print(x, y, id(ikony), TextAlign::TOP_RIGHT, "");
} else if (id(bat_pct).state >= 40) {
// 40%
it.print(x, y, id(ikony), TextAlign::TOP_RIGHT, "");
} else if (id(bat_pct).state >= 30) {
// 30%
it.print(x, y, id(ikony), TextAlign::TOP_RIGHT, "");
} else if (id(bat_pct).state >= 20) {
// 20%
it.print(x, y, id(ikony), TextAlign::TOP_RIGHT, "");
} else if (id(bat_pct).state >= 10) {
// 10%
it.print(x, y, id(ikony), TextAlign::TOP_RIGHT, "");
} else {
// 0%
it.print(x, y, id(ikony), TextAlign::TOP_RIGHT, "");
}
}
/* Battery Voltage Charging */
if(id(bat_pct).has_state() && (id(${device_name}_usb_zapojeno).state)) {
x = 63, y = 0;
if (id(bat_pct).state >= 97) {
// 100 %
it.print(x, y, id(ikony), TextAlign::TOP_RIGHT, "");
} else if (id(bat_pct).state >= 90) {
// 90 %
it.print(x, y, id(ikony), TextAlign::TOP_RIGHT, "");
} else if (id(bat_pct).state >= 80) {
// 80%
it.print(x, y, id(ikony), TextAlign::TOP_RIGHT, "");
} else if (id(bat_pct).state >= 70) {
// 70%
it.print(x, y, id(ikony), TextAlign::TOP_RIGHT, "");
} else if (id(bat_pct).state >= 60) {
// 60%
it.print(x, y, id(ikony), TextAlign::TOP_RIGHT, "");
} else if (id(bat_pct).state >= 50) {
// 50%
it.print(x, y, id(ikony), TextAlign::TOP_RIGHT, "");
} else if (id(bat_pct).state >= 40) {
// 40%
it.print(x, y, id(ikony), TextAlign::TOP_RIGHT, "");
} else if (id(bat_pct).state >= 30) {
// 30%
it.print(x, y, id(ikony), TextAlign::TOP_RIGHT, "");
} else if (id(bat_pct).state >= 20) {
// 20%
it.print(x, y, id(ikony), TextAlign::TOP_RIGHT, "");
} else if (id(bat_pct).state >= 10) {
// 10%
it.print(x, y, id(ikony), TextAlign::TOP_RIGHT, "");
} else {
// 0%
it.print(x, y, id(ikony), TextAlign::TOP_RIGHT, "");
}
}
deep_sleep: # spánek je využit jen na to aby chvíli zůstaly zobrazené údaje na displeji před shozením napájení
id: spanek
run_duration: 30s
sleep_duration: 2s