Kompilacja programu z arduino na esphome

Witam. Nie wiem gdzie ten temat umieścić więc tutaj go dam :). napisałem sobie program w arduino do mierzenia temperatur pod esp wemos d1 mini. Programik działa tylko chciałbym go przerobić pod Homa i za bardzo nie wiem jak to zrobić. jak ktoś ma jakieś pomysły to proszę o pomoc.

Program z arduino

#include <Wire.h>

#include <LiquidCrystal_I2C.h>

#include <OneWire.h>

#include <DallasTemperature.h>

#define ONE_WIRE_BUS 5
#define SENSORS_NUM 8

OneWire oneWire(ONE_WIRE_BUS);

DallasTemperature sensors(&oneWire);

const byte address[SENSORS_NUM][8] PROGMEM = {
0x28, 0xDE, 0x9E, 0X79, 0xA2, 0x1, 0x3, 0x78,
0x28, 0xE, 0xDF, 0x17, 0x1, 0x0, 0x0, 0x29

};

//LiquidCrystal_I2C lcd(0x27, 20, 2); // W zależności od użytej biblioteki…
LiquidCrystal_I2C lcd(0x4E / 2, 2, 1, 0, 4, 5, 6, 7, 3, POSITIVE);

byte skull_1[8] = { B00000, B00001, B00011, B00011, B00011, B00010, B01011, B11001 };
byte skull_2[8] = { B11111, B11111, B11111, B11111, B01110, B00100, B01110, B11011 };
byte skull_3[8] = { B00000, B10000, B11000, B11000, B11000, B01000, B11010, B10011 };
byte skull_4[8] = { B00100, B00000, B00000, B00001, B00001, B00100, B11000, B01000 };
byte skull_5[8] = { B11111, B10101, B00000, B01010, B11111, B11111, B00000, B00000 };
byte skull_6[8] = { B00100, B00000, B00000, B10000, B10000, B00100, B00011, B00010 };// set the LCD address to 0x27 for a 16 chars and 2 line display

void setup()
{

 // Prepare LCD
lcd.begin(20, 2);
lcd.createChar(1, skull_1);
lcd.createChar(2, skull_2);
lcd.createChar(3, skull_3);
lcd.createChar(4, skull_4);
lcd.createChar(5, skull_5);
lcd.createChar(6, skull_6);
lcd.clear();

// Start up screen
{
    lcd.setCursor(1, 0);
    lcd.write(1);
    lcd.write(2);
    lcd.write(3);
    lcd.setCursor(1, 1);
    lcd.write(4);
    lcd.write(5);
    lcd.write(6);
 
    
    lcd.setCursor(20 - 4, 0);
    lcd.write(1);
    lcd.write(2);
    lcd.write(3);
    lcd.setCursor(20 - 4, 1);
    lcd.write(4);
    lcd.write(5);
    lcd.write(6);

lcd.backlight(); //Turns backlight on
sensors.begin();
lcd.setCursor(0,0);

    lcd.setCursor(5, 0);
    lcd.print("Basenmierz");
    delay(3000);

    lcd.setCursor(6, 1);
    lcd.print(" :) ");

    delay(3000);
    
}

}

void loop()
{
sensors.requestTemperatures();

//Read first sensor
float temp = sensors.getTempCByIndex(0);

//Print first sensor results
lcd.setCursor (0, 0 );
lcd.print("Temp solara “);
lcd.print(temp);
lcd.print(” ");

//Read second sensor
temp = sensors.getTempCByIndex(1);

//Print second sensor result
lcd.setCursor (0, 1 );
lcd.print("Temp wody “);
lcd.print(temp);
lcd.print(” ");

//Wait 0.1 sec
delay(100);
}

Coś kombinowałem, ma problem z wyświetlaczem (esp powinno wyświetlać temperatury na wyświetlaczu i wysyłać do homa) . Wyświetlacz to oled taki :https://www.soselectronic.pl/products/winstar/weh002002arpp5n00001-161193?vat=1

code z homa do tego programu moje wypociny hehe :slight_smile:

esphome:
  name: basen
  platform: ESP8266
  board: d1_mini
  
  
  
wifi:
  networks:
  - ssid: "Bokhkjhkbi"
    password: "pufocekkhjk182"
  
  

  # Enable fallback hotspot (captive portal) in case wifi connection fails
  ap:
    ssid: "Basen Fallback Hotspot"
    password: "LIP4UmoU9Azs"

captive_portal:

# Enable logging
logger:

# Enable Home Assistant API
api:
  password: "1234567890"

ota:
  password: "1234567890"

i2c:
  sda: D2
  scl: D1

dallas:
  - pin: D7


  
  
sensor:
  - platform: dallas
    address: 0xFA02189245736F25
    id: tempdallas
    name: "Temperatura Dallas"
    on_value_range:
        - above: 68 # Włączenie alarmu gdy osiągnie zadaną temeraturę
          then:
            - switch.turn_off: buzer
            - switch.turn_on: czerwona
  
        - below:  67 # Wyączenie alarmu gdy osiągnie zadaną temeraturę
          then:
            - switch.turn_on: buzer
            - switch.turn_on: czerwona
  
  
  
#    internal: true 
    
display:
  - platform: lcd_pcf8574
    dimensions: 20x2
    address: 0x4E
    lambda: |-
       it.printf(0, 0, "Temperatura:%.1f", id(tempdallas).state);
       it.printf(0, 1, "Alarm   = >60.0:%.2f", id(tempdallas).state);

# DIOAD LED CZEROWNA OD ALARMU       
##output:
#  - platform: esp8266_pwm
#    id: led_alarm
#    pin: D4
    
switch:
  - platform: gpio
    pin: D3
    name: "Alarm"
    id: buzer
    
    
  - platform: gpio
    pin: D0
    name: "czerwona"
    id: czerwona
    
binary_sensor:
  - platform: gpio
    pin: 16
    name: "Przycisk LED Alarm"
    on_press:
      then:
        - switch.toggle: buzer 

# Example configuration entry
status_led:
  pin: GPIO2

Skorzystaj ze strony projektu ESPHome i uzupełnij plik YAML o swoje komponenty.

Nie podałeś jakie czujniki ale domyślam się, że DS18B20:

Dokładnie dallas 18b20 na stronie esp nie ma mojego oleda…

Więc nie jest to popularny model, proponuję sprawdzić na stronie Tasmota jako alternatywa dla ESPHome. Inna filozofia projektu ale nie znaczy, że gorsza.
Link poniżej przy założeniu, że wyświetlacz chodzi po magistrali I2C:

https://tasmota.github.io/docs/I2CDevices/

tak chodzi chodzi po i2c Niestety nie ma go tam…

Pozostanie więc chyba stworzenie własnego komponentu tego wyświetlacza w ESPHome:

Ja bym chociaż spróbował użyć biblioteki pierwotnie stworzonej dla Hitachi HD44780 i kompatybilnych pracujących w powiązaniu z konwerterem I2C->GPIO PCF8574

edit: ślepy jestem, bo właśnie z niej korzystasz :stuck_out_tongue:
czyli pozostaje przeanalizować jak się różni obsługa tego wyświetlacza od HD44780 i opracować (lub zmodyfikować istniejącą) bibliotekę (na bazie porównania), albo wymienić wyświetlacz na taki, który pracuje zgodnie z HD44780

Od biedy możesz też zajrzeć tam i dodać prośbę o obsługę tego wyświetlacza (ale im więcej zrobisz sam, tym większe są szanse na taką obsługę w przyszłości)

niestety z tego co widzę, to nie jest jakiś ultrapopularny model, a jego kontroler wydaje się nie być w miarę standardowy (w stosunku do HD44780+PCF8574)
edit: chyba zmyliła mnie definicja własnych znaków - ta trupia czacha mnie rozjechała :smiley:

Na początku nie chciało mi to na tym PCF 8574chodzić ale pokombinowałem i wreszcie działa dzięki za pomoc :grinning:

@andrzej04 - podziel się kodem yaml dla potomnych…

To byłoby fajnie gdybyś opisał gdzie leżał błąd, bo już podejrzewałem, że ktoś wypuścił wyświetlacze znakowe niekompatybilne z “niepisanym standardem” HD44780 (ta konstrukcja ma jakieś 40 lat “na karku”)

@andrzej04 Nie wiem czemu usunąłeś post, bo nie znamy przyczyny problemu z wyświetlaczem.
(Jakkolwiek obsługa wyświetlacza tekstowego w ESPHome nie jest chyba aż tak elastyczna, by definiować własne znaki, nigdy się nad tym nie zastanawiałem, bo oprócz wyświetlaczy w pełni graficznych wykorzystywałem dotąd tylko 7-segmentowe)

Natomiast odpowiedź na niezadane pytanie to:

Jeszcze raz zamieszczam mój program przeglądnę to co wysłał szopen, ale jakby ktoś odrazu wiedział jak zrobić te zakresy to byłbym wdzięczny


  esphome:
  name: basen
  platform: ESP8266
  board: d1_mini
      
  # Enable logging
logger:
  
# Enable Home Assistant API
api:
  password: "1234567890"

ota:
  password: "1234567890"

  
wifi:
  networks:
  - ssid: "Bobiouiouio"
    password: "pufocek182iouiouiouio"
    
 
   # Optional manual IP

  

  # Enable fallback hotspot (captive portal) in case wifi connection fails
  ap:
    ssid: "Basen Fallback Hotspot"
    password: "LIP4UmoU9Azs"

captive_portal:


i2c:
  sda: D2
  scl: D1
  scan: True 

dallas:
  - pin: D7
    update_interval: 1s


  
  
sensor:
  - platform: dallas
    address: 0x413C01E076AB1B28
    id: tempdallas
    name: "woda" #1
    on_value_range:
        - above: 27 
          then:
            - switch.turn_off: woda
            
  
        - below:  40 
          then:
            - switch.turn_on: woda
            
  
  - platform: dallas
    address: 0x0D3C01E0760A1D28
    name: "Woda" #2
    id: basen
    
  
    
            

  
  
  
 
display:
  - platform: lcd_pcf8574
    dimensions: 20x2
    address: 0x27
    lambda: |-
    
    
    
       it.printf(0, 0, "Temperatura Wody:%.1f", id(tempdallas).state);
       it.printf(0, 1, "Temperatura  Sola:%.2f", id(basen).state);


switch:
  - platform: gpio
    pin: D5
    name: "Pompa"
    id: woda
    
    

binary_sensor:
  - platform: gpio
    pin: 16
    name: "Przycisk"
    on_press:
      then:
        - switch.toggle: woda 

# Example configuration entry
status_led:
  pin: GPIO2

Ale pytanie jest wciąż niezadane - odwołujesz się do posta, który skasowałeś…
(kojarzę, że chodziło chyba o jakąś automatyzację, ale post mi dosłownie tylko mignął, a nawet nie miałem czasu go poczytać), przecież programik w arduino nie robił nic ponad wyświetlanie mierzonej temperatury i rysowanie czaszek…

Nie wspominasz też jak naprawiłeś problem z wyświetlaczem, a generalnie po to jest forum by dzielić się wiedzą (nawet jeśli popełniłeś jakiś błąd, to nie jest wstydem się do niego przyznać - ludzie zwykle popełniają te same błędy, a sam go nie zauważyłem jeśli jest gdzieś wyżej).

Wprawdzie OLEDy wydają mi się kiepskim pomysłem, bo mają problemy z trwałością (wypalają się przy ciągłej pracy) i np. sam wolałbym jednak standardowy LCD, to może jednak ktoś chciałby wykorzystać wyświetlacze alfanumeryczne OLED Winstar i może jest jakaś cenna wskazówka dla takiego potencjalnego czytelnika?

Kolejne kwestie - programik się rozrasta i dokładasz coraz więcej sprzętu, ale możesz doprowadzić do konfliktu wyprowadzeń - zwróć uwagę na “pinologię” - raz stosujesz nazewnictwo SoC (GPIOxx), a innym razem aliasy dla konkretnej płytki (Dxx)

Skoro wiadomo, że to Wemos D1 Mini
https://www.wemos.cc/en/latest/d1/d1_mini.html
albo tu ładniejszy obrazek

Akurat w tym wypadku GPIO2 to D4 czyli takiego konfliktu póki co nie ma, ale ten pin nie powinien być wykorzystany w zastosowaniach które potencjalnie ciągną go do masy (to może powodować problem z bootowaniem) chociaż tu akurat jest wbudowany LED onboard, więc problemu być nie powinno.

1 Like

OK powtarzam pytanie. Program działa, ale nie tak jak bym chciał ponieważ założenie moje jest takie że ma się włączać jak jest np 29 i mniej stopni a wyłańczać gdy jest np 30 i więcej. Program działa tak że. jak jest np 25 to się przekaźnik nie włącza sie gdy jest 29=> to program się włąńcza ale jak osiągnie temp np 31,01> to przekaźnik nadal działa wyłańcza się gdy temperatura spada samoistnie np 32 dojdzie do równych 30,00 to w tedy się przekażnik wyłańcza ale gdy spadnie do 29 to się już nie załączy od nowa. Pasowało by zrobić w esphome dwa zakresy jeden gdy temperatura jest <=29 (włączenie przekaźnika)drugi zakres gdy temperatura jest =>30 (wyłączenie).

Jeśli chodzi o ten wyświetlacz to zmieniłem adres konwentera i2c i oczywiście podałem ilość lini i wierszy jaka miałem reszta bez zmian

Zamiast tworzyć własne rozwiazanie może lepiej skorzystać z gotowego w HA

Ośmielę się udzielić kilku porad dla lepszej komunikacji i sukcesu zadanego pytania:

Zdania złożone w języku polskim
Interpunkcja

I na pewno będzie łatwiej czytającym dotrzeć do końca.

1 Like

Hej
Na wstępie zaznaczę, że nie analizowałem Twojego kodu i póki co nie mam zamiaru ponieważ od różnego rodzaju code review piany chodzę :slight_smile:

Masz tutaj wycinek mojego kodu do obsługi akwarium, lecz tutaj skupiłem się tylko i wyłącznie jak mam zorganizowaną obsługę badania temperatury wody i reakcji na grzałki.
image

api:
  services:
    #Temperatura minimlna  
    - service: set_temperature_min
      variables:
        temperature_min: float
      then:
        - lambda: |-
            id(temp_min) = temperature_min;
            id(s_temp_min).publish_state(temperature_min);
            ESP_LOGD("debug", "temperature_min=%f", temperature_min);
    #Temperatura maksymalna
    - service: set_temperature_max
      variables:
        temperature_max: float
      then:
        - lambda: |-
            id(temp_max) = temperature_max;
            id(s_temp_max).publish_state(temperature_max);
            ESP_LOGD("debug", "temperature_max=%f", temperature_max);
    #Temperatura offset
    - service: set_temperature_offset
      variables:
        temperature_offset: float
      then:
        - lambda: |-
            id(temp_offset) = temperature_offset;
            id(s_temp_offset).publish_state(temperature_offset);
            ESP_LOGD("debug", "temperature_offset=%f", temperature_offset);

globals:
  - id: temp_min
    type: float
    restore_value: true
    initial_value: "24.0"
  - id: temp_max
    type: float
    restore_value: true
    initial_value: "25.0"
  - id: temp_offset
    type: float
    restore_value: true
    initial_value: "0.8"

dallas:
  - pin: 27

sensor:
  - platform: dallas
    id: t1
    address: 0x050517A23E2DFF28
    resolution: 11
    name: "Temperatura wody"
    filters:
      - lambda: return x + id(temp_offset);
    on_raw_value:
      - lambda: |-
          ESP_LOGD("debug", "temp=%f, temperature_min=%f, temperature_max=%f", (id(t1).raw_state + id(temp_offset)), id(temp_min), id(temp_max));
          if ((id(t1).raw_state + id(temp_offset)) <= id(temp_min)) {
              id(grzalka1).turn_on();
              id(grzalka2).turn_on();
          }
          if ((id(t1).raw_state + id(temp_offset)) >= id(temp_max)) {
            id(grzalka1).turn_off();
            id(grzalka2).turn_off();
          }

  #Temperatura minimalna
  - platform: template
    id: s_temp_min
    name: "Temperatura minimalna"
    lambda: |-
      return id(temp_min);
    update_interval: 600s
    device_class: "temperature"
    unit_of_measurement: "°C"
  #Temperatura maksymalna
  - platform: template
    id: s_temp_max
    name: "Temperatura maksymalna"
    lambda: |-
      return id(temp_max);
    update_interval: 600s
    device_class: "temperature"
    unit_of_measurement: "°C"
  #Temperatura offset
  - platform: template
    id: s_temp_offset
    name: "Temperatura offset"
    lambda: |-
      return id(temp_offset);
    update_interval: 600s
    device_class: "temperature"
    unit_of_measurement: "°C"

switch:
  #grzalka 1
  - platform: gpio
    id: grzalka1
    name: "Grzałka 1"
    pin: 5
    restore_mode: ALWAYS_OFF
    icon: mdi:radiator
  #grzalka 2
  - platform: gpio
    id: grzalka2
    name: "Grzałka 2"
    pin: 17
    restore_mode: ALWAYS_OFF
    icon: mdi:radiator

Teraz parę wyjaśnień:
Offest to jest wartość dodana (może być ujemna) do odczytanej temperatury z czujnika dallas, niestety nie są one dokładne i w moim przypadku muszę dodawać 0,8 stopnia.

Sekcja services: tutaj są serwisy za pomocą których możemy ustawić temperaturę minimalna, maksymalna np. z poziomu HA.
image
Za pomocą pomocników jak i automatyzacji (w moim przypadku node-red) przekazujemy do esphome konkretne wartości.

Dodatkowo mam skonfigurowane sensory tych ustawianych wartości (może nadmiarowo)
image
lecz za pomocą nich widzę czy rzeczywiście została ustawiona wartość.

Mam nadzieję, że coś uda Ci się skorzystać z mojego kodu i odniesiesz pełen sukces :slight_smile:
Pozdrawiam

P.S.
Dla wtajemniczonych. Tak wiem w nowej wersji esphome wprowadzili number lecz póki co nie spełnia moich oczekiwań, poczekam na poprawki.