Skocz do zawartości

Monitory HMI w użytku domowym.

SOYER

Przez SOYER,
w Programowanie

 Udostępnij

Pomocna odpowiedź

SOYER Inspirator

SOYER

Napisano
Napisano

Kolega @_LM_ w innym wątku wkleił link do tego sprzętu:

https://www.waveshare.com/esp32-s3-touch-lcd-4.htm

@_LM_konkretne pytanie jak to się je, a tak bardziej konkretnie, jak zrobić(da się?) by ten monitor pobierał dane z serwera następnie w jakiejś ładnej formie to wyświetlał, dodatkowo by na nim można było uzywać linków bezpośrednich do wysyłania komend dla serwera i sterowania domowym IoT. Mowa tu konkretnie o Supli, polski projekt open surce do automatyki domowej. To tak bardziej ambitnie.

Mniej ambitnie, da się na tym, lub czymś podobnym(i większym) zainstalować apkę androidową(supla)?

 

_LM_ Specjalista

_LM_

(edytowany)
27 minut temu, SOYER napisał:

jak to się je

hmm ja lubię popić herbatą bo strasznie twarde dziadostwo xD 

 

27 minut temu, SOYER napisał:

jak zrobić(da się?) by ten monitor pobierał dane z serwera

Ten moduł ma esp na pokładzie a co za tym idzie możesz uruchomić WiFi i po podłączeniu do sieci pobierać dane z dowolnego miejsca. 

27 minut temu, SOYER napisał:

w jakiejś ładnej formie to wyświetlał,

kwestia layoutu to tylko i wyłącznie twoja inwencja twórcza, ja do tego używam bibliotek LVGL (niestety wciąż w wersji 8 ) do budowy interfejsu programu eez - studio https://www.envox.eu/studio/studio-introduction/ choć mamy kolegę @H1M4W4R1 który używa do tego celu AI. Równie dobrze możesz użyć bibliotek adafruit gfx - ja się na nich nie znam więc się nie wypowiem. Wracając do tworzenie interfejsu, eez sstudio bardzo to ułatwia co zaprojektujesz w tym programie zostanie pokazane na wyświetlaczu.

27 minut temu, SOYER napisał:

dodatkowo by na nim można było uzywać linków bezpośrednich do wysyłania komend dla serwera i sterowania domowym IoT

Ja bym poszedł w stronę mqtt proste polecenia tam i z powrotem dają Ci kontrolę nad urządzeniem, nie wiem czy reflinki to dobry pomysł ale akurat na kwestiach webowych to się znam tylko na tyle co muszę - niewiele.

 

27 minut temu, SOYER napisał:

Mniej ambitnie, da się na tym, lub czymś podobnym(i większym) zainstalować apkę androidową(supla)?

Android na esp32? ... No chyyyyba nie? albo ja nic o tym nie wiem, z drugiej strony esp32 ma zasoby pewnie większe niż pierwsze smartphone więc kto wie... Ja nie wiem czy w takim układzie nie lepiej byłoby zakupić tablet - domyślam się że chcesz mieć sterowane coś z jednego miejsca w domu. I na nim mieć zainstalowaną aplikację suplli z dostępem do wszystkich twoich urządzeń?

Edytowano przez _LM_
  • Pomogłeś! 1
_LM_ Specjalista

_LM_

Kilka słów w temacie modułu który linkujesz: Gabarytowo mieści się do puszki ∅60 więc może służyć jednocześnie jako sterownik oświetlenia, termostat pokojowy, otwieracz drzwi, furtki. Z interfejsów ma wyprowadzone CAN RS485 I2C slot na kartę pamięci i buzzer który wkurza osoby początkujące ponieważ trzeba go wyłączyć programowo 😄 😛. Mi brakuje złącza 1Wire bo wg schematu zostały jeszcze trzy GPIO luzem ale nie wyprowadzone - a szkoda. Moduł tak na "dzień dobry" sprawia pewne trudności podczas prób z własnym oprogramowaniem ale nie są to rzeczy nie do przeskoczenia, przydaje się minimalna znajomość RTOSa albo znajomości na forbot.pl 😉 Nie wiem o czym mógłbym więcej napisać? 

  • Lubię! 2
SOYER Inspirator

SOYER

  • Autor tematu
(edytowany)

Brzmi fajnie. Nie muszę tego instalować, uważam, że telefon który jest w kieszeni jest bardziej uniwersalny. Z kolei tablet który mam na stałe podłączony na ścianie, znakomicie pełni rolę nosiciela supli, YT połączony przez bt z głośnikami. 

Jednak jest to małe, fajne i można się czegoś nauczyć i poszpanować przed kolegami;).

Pytania dodatkowe, programujemy jak zwykłe esp? Przy pomocy czego? Ardu IDE też? Jak wgrywamy, usb? Jaki próg wejścia w własny layout, np. to narzędzie  które wkleiłeś? 

Gdzie kupić? Co jeszcze trzeba kupić by coś zbudować?

Najważniejsze pytanie, jak z tym łączymy np. moduły przekaźników. Czy takie moduły muszą być fizycznie połączone z ekranem. Jak nie, to jak to pracuje? Itd…

 

Edytowano przez SOYER
_LM_ Specjalista

_LM_

3 minuty temu, SOYER napisał:

Pytania dodatkowe, programujemy jak zwykłe esp? Przy pomocy czego? Ardu IDE też? Jak wgrywamy, usb?

Tak

4 minuty temu, SOYER napisał:

Jaki próg wejścia w własny layout

Nie do końca rozumiem to pytanie, z doświadczenia wiem że najtrudniej jest przebrnąć przez inicjalizację i konfigurację wyświetlacza. Arduino mocno wspomaga ten proces - niestety ma to przełożenie na wydajność systemu chcąc więcej trzeba już trochę pogrzebać w ustawieniach freertosa. 

6 minut temu, SOYER napisał:

to narzędzie  które wkleiłeś?

To narzędzie które wkleiłem generuje wszystkie pliki interfejsu użytkownika które wcześniej wyklikałeś w programie. Na przykład budujesz termostat, robisz swój layout

 EEZ_Studio_PQzhFMkmds.thumb.png.a020aa36ca9f726ae3f60411bfc7d4a9.png

klikasz build i masz wygenerowany plik z wszystkim co potrzebne w tym interfejsie:

Code_G9igV8UhpD.thumb.png.64bbaefe863efeb84c83371ccc6348be.png

Następnie w swojej aplikacji na ESP32 musisz uruchomić wyświetlacz: 

void create_peripherials(void)     
{
    ESP_LOGI(TAG, "Initialize IOExpander bus");
    esp_log_level_set("lcd_panel.io.i2c", ESP_LOG_NONE);
    esp_log_level_set("GT911", ESP_LOG_NONE);
    const i2c_config_t i2c_conf_io = {
        .mode = I2C_MODE_MASTER,
        .sda_io_num = 8,
        .sda_pullup_en = GPIO_PULLUP_ENABLE,
        .scl_io_num = 9,
        .scl_pullup_en = GPIO_PULLUP_ENABLE,
        .master.clk_speed = 400 * 1000,
    };
    ESP_ERROR_CHECK(i2c_param_config(I2C_NUM_1, &i2c_conf_io));
    ESP_ERROR_CHECK(i2c_driver_install(I2C_NUM_1, i2c_conf_io.mode, 0, 0, 0));

    ESP_LOGI(TAG, "Initialize Touch bus");
    const i2c_config_t i2c_conf = {
        .mode = I2C_MODE_MASTER,
        .sda_io_num = EXAMPLE_PIN_NUM_TOUCH_SDA,
        .sda_pullup_en = GPIO_PULLUP_ENABLE,
        .scl_io_num = EXAMPLE_PIN_NUM_TOUCH_SCL,
        .scl_pullup_en = GPIO_PULLUP_ENABLE,
        .master.clk_speed = 400 * 1000,
    };
    ESP_ERROR_CHECK(i2c_param_config(TOUCH_HOST, &i2c_conf));
    ESP_ERROR_CHECK(i2c_driver_install(TOUCH_HOST, i2c_conf.mode, 0, 0, 0));


    // esp_io_expander_new_i2c_tca9554(I2C_NUM_1, ESP_IO_EXPANDER_I2C_TCA9554_ADDRESS_000, &io_expander);

    esp_err_t ret = esp_io_expander_new_i2c_tca9554(I2C_NUM_1, ESP_IO_EXPANDER_I2C_TCA9554_ADDRESS_000, &io_expander);

    if (ret != ESP_OK)
    {
        ESP_LOGW(TAG, "Failed to initialize IO expander with I2C_NUM_1, trying TOUCH_HOST...");

        ret = esp_io_expander_new_i2c_tca9554(TOUCH_HOST, ESP_IO_EXPANDER_I2C_TCA9554_ADDRESS_000, &io_expander);
        if (ret != ESP_OK)
        {
            ESP_LOGE(TAG, "Failed to initialize IO expander with TOUCH_HOST");
            ESP_ERROR_CHECK(i2c_driver_delete(I2C_NUM_1));
            return;
        }
    }

    esp_io_expander_set_dir(io_expander, IO_EXPANDER_PIN_NUM_5 | IO_EXPANDER_PIN_NUM_0 | IO_EXPANDER_PIN_NUM_2, IO_EXPANDER_OUTPUT);
    esp_rom_gpio_pad_select_gpio(EXAMPLE_PIN_NUM_TOUCH_INT);
    gpio_set_direction(EXAMPLE_PIN_NUM_TOUCH_INT, GPIO_MODE_OUTPUT);
    gpio_set_level(EXAMPLE_PIN_NUM_TOUCH_INT, 0);
    esp_io_expander_set_level(io_expander, IO_EXPANDER_PIN_NUM_5, 0); // (1)beep?
    esp_io_expander_set_level(io_expander, IO_EXPANDER_PIN_NUM_0, 0);
    esp_io_expander_set_level(io_expander, IO_EXPANDER_PIN_NUM_2, 0);
    vTaskDelay(pdMS_TO_TICKS(100));
    esp_io_expander_set_level(io_expander, IO_EXPANDER_PIN_NUM_5, 0);
    esp_io_expander_set_level(io_expander, IO_EXPANDER_PIN_NUM_0, 1);
    esp_io_expander_set_level(io_expander, IO_EXPANDER_PIN_NUM_2, 1);

    if (EXAMPLE_PIN_NUM_BK_LIGHT >= 0)
    {
        ESP_LOGI(TAG, "Turn off LCD backlight");
        gpio_config_t bk_gpio_config = {
            .mode = GPIO_MODE_OUTPUT,
            .pin_bit_mask = 1ULL << EXAMPLE_PIN_NUM_BK_LIGHT};
        ESP_ERROR_CHECK(gpio_config(&bk_gpio_config));
    }

    ESP_LOGI(TAG, "Install 3-wire SPI panel IO");
    spi_line_config_t line_config = {
        .cs_io_type = IO_TYPE_GPIO,
        .cs_gpio_num = EXAMPLE_LCD_IO_SPI_CS,
        .scl_io_type = IO_TYPE_GPIO,
        .scl_gpio_num = EXAMPLE_LCD_IO_SPI_SCL,
        .sda_io_type = IO_TYPE_GPIO,
        .sda_gpio_num = EXAMPLE_LCD_IO_SPI_SDA,
        .io_expander = NULL,
    };
    esp_lcd_panel_io_3wire_spi_config_t io_config = ST7701_PANEL_IO_3WIRE_SPI_CONFIG(line_config, 0);
    esp_lcd_panel_io_handle_t io_handle = NULL;
    ESP_ERROR_CHECK(esp_lcd_new_panel_io_3wire_spi(&io_config, &io_handle));

    ESP_LOGI(TAG, "Install ST7701 panel driver");
    esp_lcd_panel_handle_t lcd_handle = NULL;
    esp_lcd_rgb_panel_config_t rgb_config = {
        .clk_src = LCD_CLK_SRC_DEFAULT,
        .psram_trans_align = 64,
        .data_width = EXAMPLE_RGB_DATA_WIDTH,
        .bits_per_pixel = EXAMPLE_RGB_BIT_PER_PIXEL,
        .de_gpio_num = EXAMPLE_LCD_IO_RGB_DE,
        .pclk_gpio_num = EXAMPLE_LCD_IO_RGB_PCLK,
        .vsync_gpio_num = EXAMPLE_LCD_IO_RGB_VSYNC,
        .hsync_gpio_num = EXAMPLE_LCD_IO_RGB_HSYNC,
        .disp_gpio_num = EXAMPLE_LCD_IO_RGB_DISP,
        .data_gpio_nums = {
            EXAMPLE_LCD_IO_RGB_DATA0,
            EXAMPLE_LCD_IO_RGB_DATA1,
            EXAMPLE_LCD_IO_RGB_DATA2,
            EXAMPLE_LCD_IO_RGB_DATA3,
            EXAMPLE_LCD_IO_RGB_DATA4,
            EXAMPLE_LCD_IO_RGB_DATA5,
            EXAMPLE_LCD_IO_RGB_DATA6,
            EXAMPLE_LCD_IO_RGB_DATA7,
            EXAMPLE_LCD_IO_RGB_DATA8,
            EXAMPLE_LCD_IO_RGB_DATA9,
            EXAMPLE_LCD_IO_RGB_DATA10,
            EXAMPLE_LCD_IO_RGB_DATA11,
            EXAMPLE_LCD_IO_RGB_DATA12,
            EXAMPLE_LCD_IO_RGB_DATA13,
            EXAMPLE_LCD_IO_RGB_DATA14,
            EXAMPLE_LCD_IO_RGB_DATA15,
        },
        .timings = ST7701_480_480_PANEL_60HZ_RGB_TIMING(),
        .flags.fb_in_psram = 1,
        .num_fbs = LVGL_PORT_LCD_RGB_BUFFER_NUMS,
        .bounce_buffer_size_px = EXAMPLE_RGB_BOUNCE_BUFFER_SIZE,
    };
    rgb_config.timings.h_res = EXAMPLE_LCD_H_RES;
    rgb_config.timings.v_res = EXAMPLE_LCD_V_RES;
    st7701_vendor_config_t vendor_config = {
        .rgb_config = &rgb_config,
        .init_cmds = lcd_init_cmds, // Uncomment these line if use custom initialization commands
        .init_cmds_size = sizeof(lcd_init_cmds) / sizeof(lcd_init_cmds[0]),
        .flags = {
            .auto_del_panel_io = 0, /**
                                     * Set to 1 if panel IO is no longer needed after LCD initialization.
                                     * If the panel IO pins are sharing other pins of the RGB interface to save GPIOs,
                                     * Please set it to 1 to release the pins.
                                     */
            .mirror_by_cmd = 1,     // Set to 0 if `auto_del_panel_io` is enabled
        },
    };
    const esp_lcd_panel_dev_config_t panel_config = {
        .reset_gpio_num = EXAMPLE_LCD_IO_RST,
        .rgb_ele_order = LCD_RGB_ELEMENT_ORDER_RGB,
        .bits_per_pixel = EXAMPLE_LCD_BIT_PER_PIXEL,
        .vendor_config = &vendor_config,
    };
    ESP_ERROR_CHECK(esp_lcd_new_panel_st7701(io_handle, &panel_config, &lcd_handle));
    ESP_ERROR_CHECK(esp_lcd_panel_reset(lcd_handle));
    ESP_ERROR_CHECK(esp_lcd_panel_init(lcd_handle));
    esp_lcd_panel_disp_on_off(lcd_handle, true);

    esp_lcd_touch_handle_t tp_handle = NULL;

    esp_lcd_panel_io_handle_t tp_io_handle = NULL;
    const esp_lcd_panel_io_i2c_config_t tp_io_config = ESP_LCD_TOUCH_IO_I2C_GT911_CONFIG();

    ESP_LOGI(TAG, "Initialize I2C panel IO");
    ESP_ERROR_CHECK(esp_lcd_new_panel_io_i2c((esp_lcd_i2c_bus_handle_t)TOUCH_HOST, &tp_io_config, &tp_io_handle));

    ESP_LOGI(TAG, "Initialize touch controller GT911");
    const esp_lcd_touch_config_t tp_cfg = {
        .x_max = EXAMPLE_LCD_H_RES,
        .y_max = EXAMPLE_LCD_V_RES,
        .rst_gpio_num = EXAMPLE_PIN_NUM_TOUCH_RST,
        .int_gpio_num = EXAMPLE_PIN_NUM_TOUCH_INT,
        .levels = {
            .reset = 0,
            .interrupt = 0,
        },
        .flags = {
            .swap_xy = 0,
            .mirror_x = 0,
            .mirror_y = 0,
        },
    };
    ESP_ERROR_CHECK(esp_lcd_touch_new_i2c_gt911(tp_io_handle, &tp_cfg, &tp_handle));

    ESP_ERROR_CHECK(lvgl_port_init(lcd_handle, tp_handle));

    esp_lcd_rgb_panel_event_callbacks_t cbs = {
#if EXAMPLE_RGB_BOUNCE_BUFFER_SIZE > 0
        .on_bounce_frame_finish = rgb_lcd_on_vsync_event,
#else
        .on_vsync = rgb_lcd_on_vsync_event,
#endif
    };
    esp_lcd_rgb_panel_register_event_callbacks(lcd_handle, &cbs, NULL);
}

To jest akurat dostarczone przez biblioteki producenta więc nie potrzeba się pocić 😉 a w Arduino zapewne jest jeszcze łatwiej. Dalej, po inicjalizacji peryferii i wszystkich niezbędnych składników odpalasz główną funkcję LVGL:
  

ui_init();

Podpinasz timer biblioteki (tutaj nie zwracaj uwagi na mutexa testuję pewne funkcje) 

    while(1)
    {
              if (lvgl_port_lock(5))
          {

            // Release the mutex
            // lvgl_port_unlock(); 
               lv_timer_handler();
                ui_tick();
                
                lvgl_port_unlock();    
          }

iii jak wszystko poszło zgodnie z planem mamy ładny ekranik:

1733668401116.thumb.jpg.93f397cd655bd385ddd8bf542a95300a.jpg

 

 

 

  • Pomogłeś! 1
_LM_ Specjalista

_LM_

25 minut temu, SOYER napisał:

Gdzie kupić? Co jeszcze trzeba kupić by coś zbudować?

U czerwonych nieprzyjaciół. 

26 minut temu, SOYER napisał:

Najważniejsze pytanie, jak z tym łączymy np. moduły przekaźników. Czy takie moduły muszą być fizycznie połączone z ekranem. Jak nie, to jak to pracuje? Itd…

Za pomocą magistral CAN/MODBUS wtedy możesz użyć:

https://www.waveshare.com/modbus-rtu-relay.htm

lub bezprzewodowo za pomocą interfejsów które są normalnie dostępne z ESP32 można przez BLE, można przez ESPNOW. W końcu można dogadać się z serwerem MQTT coś jak twoja supla. 

  • Pomogłeś! 1
SOYER Inspirator

SOYER

  • Autor tematu

Pytając o próg wejścia w własny layout, byłem ciekaw czy dam radę sam to zrobić. Ja, bez zdolności programistycznych. Może faktycznie @H1M4W4R1 coś doradzi.

Zdecydowany jestem, gdzie to kupić na pewniaka?

Widzę @_LM_, że nasz sąsiad wspólny też tym handluje. elty.pl

_LM_ Specjalista

_LM_

(edytowany)
3 minuty temu, SOYER napisał:

Pytając o próg wejścia w własny layout, byłem ciekaw czy dam radę sam to zrobić.

Zainstaluj eez studio, wybierz zakładkę lvgl lub lvgl - flow i sprawdź, możesz to przetestować bez jakiegokolwiek sprzętu

Edytowano przez _LM_
  • Pomogłeś! 1
SOYER Inspirator

SOYER

  • Autor tematu
1 minutę temu, _LM_ napisał:

Nie przepadam za czerwoną zarazą CHRL

Możesz się podzielić sprawdzonym sprzedawcą? Jak nie tutaj to chociaż priv?

SOYER Inspirator

SOYER

  • Autor tematu
Przed chwilą, SOYER napisał:

Możesz się podzielić sprawdzonym sprzedawcą? Jak nie tutaj to chociaż priv?

Chyba, że masz na zbyciu…

_LM_ Specjalista

_LM_

Przed chwilą, SOYER napisał:

Możesz się podzielić sprawdzonym sprzedawcą? Jak nie tutaj to chociaż priv?

Znaczy, żeby było jasne kupiłem u komuchów bo niema innej opcji 😄 link podesłał mi @H1M4W4R1 kiedyś https://www.aliexpress.com/item/1005007582119640.html?spm=a2g0o.order_list.order_list_main.10.21ef1c24JxGg9v&gatewayAdapt=glo2pol

 

7 minut temu, SOYER napisał:

Chyba, że masz na zbyciu…

Nie 😉
 

_LM_ Specjalista

_LM_

(edytowany)

Tu możesz poczytać oraz zobaczyć możliwości biblioteki LVGL

EDIT do kosza duplikat.

Edytowano przez _LM_

Bądź aktywny - zaloguj się lub utwórz konto!

Tylko zarejestrowani użytkownicy mogą komentować zawartość tej strony

Utwórz konto w ~20 sekund!

Zarejestruj nowe konto, to proste!

Zarejestruj się »

Zaloguj się

Posiadasz własne konto? Użyj go!

Zaloguj się »
 Udostępnij
Przejdź do listy tematów
×
×
  • Utwórz nowe...