/* * SPDX-FileCopyrightText: 2022-2024 Espressif Systems (Shanghai) CO LTD * * SPDX-License-Identifier: Apache-2.0 */ #include "freertos/FreeRTOS.h" #include "freertos/event_groups.h" #include "esp_err.h" #include "esp_log.h" #include "esp_check.h" #include "driver/i2c.h" #include "esp_lcd_panel_io.h" #include "esp_lcd_panel_ops.h" #include "esp_lcd_panel_rgb.h" #include "esp_lvgl_port.h" #include "lv_demos.h" #include "esp_wifi.h" #include "esp_event.h" #include "nvs_flash.h" #include "mqtt_client.h" #include "esp_lcd_touch_gt911.h" /* LCD size */ #define EXAMPLE_LCD_H_RES (800) #define EXAMPLE_LCD_V_RES (480) /* LCD settings */ #define EXAMPLE_LCD_LVGL_FULL_REFRESH (0) #define EXAMPLE_LCD_LVGL_DIRECT_MODE (1) #define EXAMPLE_LCD_LVGL_AVOID_TEAR (1) #define EXAMPLE_LCD_RGB_BOUNCE_BUFFER_MODE (1) #define EXAMPLE_LCD_DRAW_BUFF_DOUBLE (0) #define EXAMPLE_LCD_DRAW_BUFF_HEIGHT (100) #define EXAMPLE_LCD_RGB_BUFFER_NUMS (2) #define EXAMPLE_LCD_RGB_BOUNCE_BUFFER_HEIGHT (10) /* LCD pins */ #define EXAMPLE_LCD_GPIO_VSYNC (GPIO_NUM_41) #define EXAMPLE_LCD_GPIO_HSYNC (GPIO_NUM_39) #define EXAMPLE_LCD_GPIO_DE (GPIO_NUM_40) #define EXAMPLE_LCD_GPIO_PCLK (GPIO_NUM_42) #define EXAMPLE_LCD_GPIO_DISP (GPIO_NUM_NC) #define EXAMPLE_LCD_GPIO_DATA0 (GPIO_NUM_8) #define EXAMPLE_LCD_GPIO_DATA1 (GPIO_NUM_3) #define EXAMPLE_LCD_GPIO_DATA2 (GPIO_NUM_46) #define EXAMPLE_LCD_GPIO_DATA3 (GPIO_NUM_9) #define EXAMPLE_LCD_GPIO_DATA4 (GPIO_NUM_1) #define EXAMPLE_LCD_GPIO_DATA5 (GPIO_NUM_5) #define EXAMPLE_LCD_GPIO_DATA6 (GPIO_NUM_6) #define EXAMPLE_LCD_GPIO_DATA7 (GPIO_NUM_7) #define EXAMPLE_LCD_GPIO_DATA8 (GPIO_NUM_15) #define EXAMPLE_LCD_GPIO_DATA9 (GPIO_NUM_16) #define EXAMPLE_LCD_GPIO_DATA10 (GPIO_NUM_4) #define EXAMPLE_LCD_GPIO_DATA11 (GPIO_NUM_45) #define EXAMPLE_LCD_GPIO_DATA12 (GPIO_NUM_48) #define EXAMPLE_LCD_GPIO_DATA13 (GPIO_NUM_47) #define EXAMPLE_LCD_GPIO_DATA14 (GPIO_NUM_21) #define EXAMPLE_LCD_GPIO_DATA15 (GPIO_NUM_14) /* Touch settings */ #define EXAMPLE_TOUCH_I2C_NUM (0) #define EXAMPLE_TOUCH_I2C_CLK_HZ (400000) /* LCD touch pins */ #define EXAMPLE_TOUCH_I2C_SCL (GPIO_NUM_18) #define EXAMPLE_TOUCH_I2C_SDA (GPIO_NUM_17) #define EXAMPLE_LCD_PANEL_35HZ_RGB_TIMING() \ { \ .pclk_hz = 18 * 1000 * 1000, \ .h_res = EXAMPLE_LCD_H_RES, \ .v_res = EXAMPLE_LCD_V_RES, \ .hsync_pulse_width = 40, \ .hsync_back_porch = 40, \ .hsync_front_porch = 48, \ .vsync_pulse_width = 23, \ .vsync_back_porch = 32, \ .vsync_front_porch = 13, \ .flags.pclk_active_neg = true, \ } static const char *TAG = "EXAMPLE"; // LVGL image declare LV_IMG_DECLARE(esp_logo) /* LCD IO and panel */ static esp_lcd_panel_handle_t lcd_panel = NULL; static esp_lcd_touch_handle_t touch_handle = NULL; /* LVGL display and touch */ static lv_display_t *lvgl_disp = NULL; static lv_indev_t *lvgl_touch_indev = NULL; static esp_err_t app_lcd_init(void) { esp_err_t ret = ESP_OK; /* LCD initialization */ ESP_LOGI(TAG, "Initialize RGB panel"); esp_lcd_rgb_panel_config_t panel_conf = { .clk_src = LCD_CLK_SRC_PLL160M, .psram_trans_align = 64, .data_width = 16, .bits_per_pixel = 16, .de_gpio_num = EXAMPLE_LCD_GPIO_DE, .pclk_gpio_num = EXAMPLE_LCD_GPIO_PCLK, .vsync_gpio_num = EXAMPLE_LCD_GPIO_VSYNC, .hsync_gpio_num = EXAMPLE_LCD_GPIO_HSYNC, .disp_gpio_num = EXAMPLE_LCD_GPIO_DISP, .data_gpio_nums = { EXAMPLE_LCD_GPIO_DATA0, EXAMPLE_LCD_GPIO_DATA1, EXAMPLE_LCD_GPIO_DATA2, EXAMPLE_LCD_GPIO_DATA3, EXAMPLE_LCD_GPIO_DATA4, EXAMPLE_LCD_GPIO_DATA5, EXAMPLE_LCD_GPIO_DATA6, EXAMPLE_LCD_GPIO_DATA7, EXAMPLE_LCD_GPIO_DATA8, EXAMPLE_LCD_GPIO_DATA9, EXAMPLE_LCD_GPIO_DATA10, EXAMPLE_LCD_GPIO_DATA11, EXAMPLE_LCD_GPIO_DATA12, EXAMPLE_LCD_GPIO_DATA13, EXAMPLE_LCD_GPIO_DATA14, EXAMPLE_LCD_GPIO_DATA15, }, .timings = EXAMPLE_LCD_PANEL_35HZ_RGB_TIMING(), .flags.fb_in_psram = 1, .num_fbs = EXAMPLE_LCD_RGB_BUFFER_NUMS, #if EXAMPLE_LCD_RGB_BOUNCE_BUFFER_MODE .bounce_buffer_size_px = EXAMPLE_LCD_H_RES * EXAMPLE_LCD_RGB_BOUNCE_BUFFER_HEIGHT, #endif }; ESP_GOTO_ON_ERROR(esp_lcd_new_rgb_panel(&panel_conf, &lcd_panel), err, TAG, "RGB init failed"); ESP_GOTO_ON_ERROR(esp_lcd_panel_init(lcd_panel), err, TAG, "LCD init failed"); return ret; err: if (lcd_panel) { esp_lcd_panel_del(lcd_panel); } return ret; } static esp_err_t app_touch_init(void) { /* Initilize I2C */ const i2c_config_t i2c_conf = { .mode = I2C_MODE_MASTER, .sda_io_num = EXAMPLE_TOUCH_I2C_SDA, .sda_pullup_en = GPIO_PULLUP_DISABLE, .scl_io_num = EXAMPLE_TOUCH_I2C_SCL, .scl_pullup_en = GPIO_PULLUP_DISABLE, .master.clk_speed = EXAMPLE_TOUCH_I2C_CLK_HZ }; ESP_RETURN_ON_ERROR(i2c_param_config(EXAMPLE_TOUCH_I2C_NUM, &i2c_conf), TAG, "I2C configuration failed"); ESP_RETURN_ON_ERROR(i2c_driver_install(EXAMPLE_TOUCH_I2C_NUM, i2c_conf.mode, 0, 0, 0), TAG, "I2C initialization failed"); /* Initialize touch HW */ const esp_lcd_touch_config_t tp_cfg = { .x_max = EXAMPLE_LCD_H_RES, .y_max = EXAMPLE_LCD_V_RES, .rst_gpio_num = GPIO_NUM_NC, .int_gpio_num = GPIO_NUM_NC, .levels = { .reset = 0, .interrupt = 0, }, .flags = { .swap_xy = 0, .mirror_x = 0, .mirror_y = 0, }, }; 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_RETURN_ON_ERROR(esp_lcd_new_panel_io_i2c((esp_lcd_i2c_bus_handle_t)EXAMPLE_TOUCH_I2C_NUM, &tp_io_config, &tp_io_handle), TAG, ""); return esp_lcd_touch_new_i2c_gt911(tp_io_handle, &tp_cfg, &touch_handle); } static esp_err_t app_lvgl_init(void) { /* Initialize LVGL */ const lvgl_port_cfg_t lvgl_cfg = { .task_priority = 4, /* LVGL task priority */ .task_stack = 6144, /* LVGL task stack size */ .task_affinity = -1, /* LVGL task pinned to core (-1 is no affinity) */ .task_max_sleep_ms = 500, /* Maximum sleep in LVGL task */ .timer_period_ms = 5 /* LVGL timer tick period in ms */ }; ESP_RETURN_ON_ERROR(lvgl_port_init(&lvgl_cfg), TAG, "LVGL port initialization failed"); uint32_t buff_size = EXAMPLE_LCD_H_RES * EXAMPLE_LCD_DRAW_BUFF_HEIGHT; #if EXAMPLE_LCD_LVGL_FULL_REFRESH || EXAMPLE_LCD_LVGL_DIRECT_MODE buff_size = EXAMPLE_LCD_H_RES * EXAMPLE_LCD_V_RES; #endif /* Add LCD screen */ ESP_LOGD(TAG, "Add LCD screen"); const lvgl_port_display_cfg_t disp_cfg = { .panel_handle = lcd_panel, .buffer_size = buff_size, .double_buffer = EXAMPLE_LCD_DRAW_BUFF_DOUBLE, .hres = EXAMPLE_LCD_H_RES, .vres = EXAMPLE_LCD_V_RES, .monochrome = false, #if LVGL_VERSION_MAJOR >= 9 .color_format = LV_COLOR_FORMAT_RGB565, #endif .rotation = { .swap_xy = false, .mirror_x = false, .mirror_y = false, }, .flags = { .buff_dma = false, .buff_spiram = false, #if EXAMPLE_LCD_LVGL_FULL_REFRESH .full_refresh = true, #elif EXAMPLE_LCD_LVGL_DIRECT_MODE .direct_mode = true, #endif #if LVGL_VERSION_MAJOR >= 9 .swap_bytes = false, #endif } }; const lvgl_port_display_rgb_cfg_t rgb_cfg = { .flags = { #if EXAMPLE_LCD_RGB_BOUNCE_BUFFER_MODE .bb_mode = true, #else .bb_mode = false, #endif #if EXAMPLE_LCD_LVGL_AVOID_TEAR .avoid_tearing = true, #else .avoid_tearing = false, #endif } }; lvgl_disp = lvgl_port_add_disp_rgb(&disp_cfg, &rgb_cfg); /* Add touch input (for selected screen) */ const lvgl_port_touch_cfg_t touch_cfg = { .disp = lvgl_disp, .handle = touch_handle, }; lvgl_touch_indev = lvgl_port_add_touch(&touch_cfg); return ESP_OK; } static void _app_button_cb(lv_event_t *e) { lv_disp_rotation_t rotation = lv_disp_get_rotation(lvgl_disp); rotation++; if (rotation > LV_DISPLAY_ROTATION_270) { rotation = LV_DISPLAY_ROTATION_0; } /* LCD HW rotation */ lv_disp_set_rotation(lvgl_disp, rotation); } static void app_main_display(void) { lv_obj_t *scr = lv_scr_act(); /* Your LVGL objects code here .... */ /* Create image */ lv_obj_t *img_logo = lv_img_create(scr); lv_img_set_src(img_logo, &esp_logo); lv_obj_align(img_logo, LV_ALIGN_TOP_MID, 0, 20); /* Label */ lv_obj_t *label = lv_label_create(scr); lv_obj_set_width(label, EXAMPLE_LCD_H_RES); lv_obj_set_style_text_align(label, LV_TEXT_ALIGN_CENTER, 0); #if LVGL_VERSION_MAJOR == 8 lv_label_set_recolor(label, true); lv_label_set_text(label, "#FF0000 "LV_SYMBOL_BELL" Hello world Espressif and LVGL "LV_SYMBOL_BELL"#\n#FF9400 "LV_SYMBOL_WARNING" For simplier initialization, use BSP "LV_SYMBOL_WARNING" #"); #else lv_label_set_text(label, LV_SYMBOL_BELL" Hello world Espressif and LVGL "LV_SYMBOL_BELL"\n "LV_SYMBOL_WARNING" For simplier initialization, use BSP "LV_SYMBOL_WARNING); #endif lv_obj_align(label, LV_ALIGN_CENTER, 0, 20); /* Button */ lv_obj_t *btn = lv_btn_create(scr); label = lv_label_create(btn); lv_label_set_text_static(label, "Rotate screen"); lv_obj_align(btn, LV_ALIGN_BOTTOM_MID, 0, -30); lv_obj_add_event_cb(btn, _app_button_cb, LV_EVENT_CLICKED, NULL); } char tempExtStr[6]; char tempIntStr[6]; char hauteurCuveStr[6]; lv_subject_t tempIntSubj; lv_subject_t tempExtSubj; lv_subject_t hauteurCuveSubj; char *upEvent = "monter"; char *downEvent = "descendre"; char* topicTempExt="house/temp/282A802600008059"; esp_mqtt_client_handle_t client; static void event_handler(lv_event_t *e) { lv_event_code_t code = lv_event_get_code(e); lv_obj_t *obj = (lv_obj_t *)lv_event_get_target(e); char *evtData = (char *)lv_event_get_user_data(e); switch (code) { case LV_EVENT_PRESSED: // LV_LOG_USER("%s was pressed\n", evtData); break; case LV_EVENT_CLICKED: ESP_LOGI(TAG, "%s was clicked\n", evtData); esp_mqtt_client_publish(client,"volets", evtData,0,0,0); break; case LV_EVENT_LONG_PRESSED: LV_LOG_USER("%s was long pressed\n", evtData); break; case LV_EVENT_LONG_PRESSED_REPEAT: LV_LOG_USER("%s was long press repeat\n", evtData); break; default: break; } } void draw_ihm() { lv_subject_init_string(&tempExtSubj, tempExtStr, NULL, 6, "--"); lv_subject_init_string(&tempIntSubj, tempIntStr, NULL, 6, "--"); lv_subject_init_string(&hauteurCuveSubj, hauteurCuveStr, NULL, 6, "--"); // keys.clear(); lv_obj_clean(lv_scr_act()); static lv_style_t style_btn; lv_style_init(&style_btn); // lv_style_set_bg_color(&style_btn, lv_color_hex(0x115588)); // lv_style_set_bg_opa(&style_btn, LV_OPA_50); // lv_style_set_border_width(&style_btn, 2); // lv_style_set_border_color(&style_btn, lv_color_black()); lv_style_set_width(&style_btn, 120); lv_style_set_height(&style_btn, 120); // Un style pour les conteneurs (température, cuve ...) static lv_style_t style_container; lv_style_init(&style_container); lv_style_set_pad_all(&style_container, 5); // lv_style_set_height(&style_container,LV_SIZE_CONTENT); lv_style_set_height(&style_container, 80); lv_style_set_width(&style_container, 130); lv_style_set_bg_color(&style_container, lv_palette_lighten(LV_PALETTE_BLUE_GREY, 4)); lv_style_set_align(&style_container, LV_ALIGN_BOTTOM_LEFT); lv_style_set_flex_cross_place(&style_container, LV_FLEX_ALIGN_END); static lv_style_t style_lbvValue; lv_style_init(&style_lbvValue); lv_style_set_text_font(&style_lbvValue, &lv_font_montserrat_26); lv_obj_set_flex_flow(lv_screen_active(), LV_FLEX_FLOW_ROW); lv_obj_set_style_pad_column(lv_screen_active(), 1, 0); /*Create a container with COLUMN flex direction*/ lv_obj_t *cont_col = lv_obj_create(lv_screen_active()); lv_obj_set_style_pad_all(cont_col, 5, 0); lv_obj_set_size(cont_col, 250, 480); lv_obj_align(cont_col, LV_ALIGN_TOP_LEFT, 0, 0); lv_obj_set_flex_flow(cont_col, LV_FLEX_FLOW_COLUMN); /*Create a container with COLUMN flex direction*/ lv_obj_t *cont_col2 = lv_obj_create(lv_screen_active()); lv_obj_set_style_pad_all(cont_col2, 5, 0); lv_obj_set_flex_align(cont_col2, LV_FLEX_ALIGN_CENTER, LV_FLEX_ALIGN_CENTER, LV_FLEX_ALIGN_CENTER); lv_obj_set_height(cont_col2, 480); lv_obj_set_width(cont_col2, LV_SIZE_CONTENT); lv_obj_align_to(cont_col2, cont_col, LV_ALIGN_OUT_TOP_RIGHT, 0, 0); lv_obj_set_flex_flow(cont_col2, LV_FLEX_FLOW_COLUMN); lv_obj_t *label1 = lv_label_create(cont_col); lv_label_set_text(label1, "Temperatures"); lv_obj_set_pos(label1, 0, 0); /*Create a container with COLUMN flex direction*/ lv_obj_t *cont_tempExt = lv_obj_create(cont_col); lv_obj_add_style(cont_tempExt, &style_container, 0); // lv_obj_set_height(cont_tempExt,50); lv_obj_set_flex_flow(cont_tempExt, LV_FLEX_FLOW_ROW); lv_obj_t *lblExt = lv_label_create(cont_tempExt); lv_label_set_text(lblExt, "ext."); lv_obj_t *lblTempExt = lv_label_create(cont_tempExt); lv_obj_add_style(lblTempExt, &style_lbvValue, 0); lv_label_set_text(lblTempExt, ""); lv_label_bind_text(lblTempExt, &tempExtSubj, "%s °C"); /*Create a container with COLUMN flex direction*/ lv_obj_t *cont_tempInt = lv_obj_create(cont_col); lv_obj_add_style(cont_tempInt, &style_container, 0); // lv_obj_set_height(cont_tempInt,50); lv_obj_set_flex_flow(cont_tempInt, LV_FLEX_FLOW_ROW); lv_obj_t *lblInt = lv_label_create(cont_tempInt); lv_label_set_text(lblInt, "int."); lv_obj_t *lblTempInt = lv_label_create(cont_tempInt); lv_obj_add_style(lblTempInt, &style_lbvValue, 0); lv_label_set_text(lblTempInt, ""); lv_label_bind_text(lblTempInt, &tempIntSubj, "%s °C"); /*Create a container with COLUMN flex direction*/ lv_obj_t *cont_Cuve = lv_obj_create(cont_col); lv_obj_add_style(cont_Cuve, &style_container, 0); lv_obj_set_flex_flow(cont_Cuve, LV_FLEX_FLOW_ROW_WRAP); // lv_obj_set_height(cont_Cuve,80); lv_obj_t *lblHauteurEau = lv_label_create(cont_Cuve); lv_label_set_text(lblHauteurEau, "Cuve: "); lv_obj_t *lblHauteurCuve = lv_label_create(cont_Cuve); lv_obj_add_style(lblHauteurCuve, &style_lbvValue, 0); lv_label_bind_text(lblHauteurCuve, &hauteurCuveSubj, "%s cm"); lv_obj_t *btnUp = lv_button_create(cont_col2); lv_obj_add_style(btnUp, &style_btn, 0); lv_obj_add_event_cb(btnUp, event_handler, LV_EVENT_ALL, upEvent); lv_obj_align(btnUp, LV_ALIGN_CENTER, 0, -40); lv_obj_remove_flag(btnUp, LV_OBJ_FLAG_PRESS_LOCK); lv_obj_t *label = lv_label_create(btnUp); lv_label_set_text(label, LV_SYMBOL_UP); lv_obj_center(label); lv_obj_t *btnDwn = lv_button_create(cont_col2); lv_obj_add_style(btnDwn, &style_btn, 0); lv_obj_add_event_cb(btnDwn, event_handler, LV_EVENT_ALL, downEvent); lv_obj_align(btnDwn, LV_ALIGN_CENTER, 0, -40); lv_obj_remove_flag(btnDwn, LV_OBJ_FLAG_PRESS_LOCK); label = lv_label_create(btnDwn); lv_label_set_text(label, LV_SYMBOL_DOWN); lv_obj_center(label); } /* The examples use WiFi configuration that you can set via project configuration menu If you'd rather not, just change the below entries to strings with the config you want - ie #define EXAMPLE_WIFI_SSID "mywifissid" */ #define EXAMPLE_ESP_WIFI_SSID "wifimms3" #define EXAMPLE_ESP_WIFI_PASS "mmswifi0611" #define EXAMPLE_ESP_MAXIMUM_RETRY 5 #if CONFIG_ESP_WPA3_SAE_PWE_HUNT_AND_PECK #define ESP_WIFI_SAE_MODE WPA3_SAE_PWE_HUNT_AND_PECK #define EXAMPLE_H2E_IDENTIFIER "" #elif CONFIG_ESP_WPA3_SAE_PWE_HASH_TO_ELEMENT #define ESP_WIFI_SAE_MODE WPA3_SAE_PWE_HASH_TO_ELEMENT #define EXAMPLE_H2E_IDENTIFIER CONFIG_ESP_WIFI_PW_ID #elif CONFIG_ESP_WPA3_SAE_PWE_BOTH #define ESP_WIFI_SAE_MODE WPA3_SAE_PWE_BOTH #define EXAMPLE_H2E_IDENTIFIER CONFIG_ESP_WIFI_PW_ID #endif #if CONFIG_ESP_WIFI_AUTH_OPEN #define ESP_WIFI_SCAN_AUTH_MODE_THRESHOLD WIFI_AUTH_OPEN #elif CONFIG_ESP_WIFI_AUTH_WEP #define ESP_WIFI_SCAN_AUTH_MODE_THRESHOLD WIFI_AUTH_WEP #elif CONFIG_ESP_WIFI_AUTH_WPA_PSK #define ESP_WIFI_SCAN_AUTH_MODE_THRESHOLD WIFI_AUTH_WPA_PSK #elif CONFIG_ESP_WIFI_AUTH_WPA2_PSK #define ESP_WIFI_SCAN_AUTH_MODE_THRESHOLD WIFI_AUTH_WPA2_PSK #elif CONFIG_ESP_WIFI_AUTH_WPA_WPA2_PSK #define ESP_WIFI_SCAN_AUTH_MODE_THRESHOLD WIFI_AUTH_WPA_WPA2_PSK #elif CONFIG_ESP_WIFI_AUTH_WPA3_PSK #define ESP_WIFI_SCAN_AUTH_MODE_THRESHOLD WIFI_AUTH_WPA3_PSK #elif CONFIG_ESP_WIFI_AUTH_WPA2_WPA3_PSK #define ESP_WIFI_SCAN_AUTH_MODE_THRESHOLD WIFI_AUTH_WPA2_WPA3_PSK #elif CONFIG_ESP_WIFI_AUTH_WAPI_PSK #define ESP_WIFI_SCAN_AUTH_MODE_THRESHOLD WIFI_AUTH_WAPI_PSK #endif /* FreeRTOS event group to signal when we are connected*/ static EventGroupHandle_t s_wifi_event_group; /* The event group allows multiple bits for each event, but we only care about two events: * - we are connected to the AP with an IP * - we failed to connect after the maximum amount of retries */ #define WIFI_CONNECTED_BIT BIT0 #define WIFI_FAIL_BIT BIT1 static int s_retry_num = 0; static void wifi_event_handler(void* arg, esp_event_base_t event_base, int32_t event_id, void* event_data) { if (event_base == WIFI_EVENT && event_id == WIFI_EVENT_STA_START) { esp_wifi_connect(); } else if (event_base == WIFI_EVENT && event_id == WIFI_EVENT_STA_DISCONNECTED) { if (s_retry_num < EXAMPLE_ESP_MAXIMUM_RETRY) { esp_wifi_connect(); s_retry_num++; ESP_LOGI(TAG, "retry to connect to the AP"); } else { xEventGroupSetBits(s_wifi_event_group, WIFI_FAIL_BIT); } ESP_LOGI(TAG,"connect to the AP fail"); } else if (event_base == IP_EVENT && event_id == IP_EVENT_STA_GOT_IP) { ip_event_got_ip_t* event = (ip_event_got_ip_t*) event_data; ESP_LOGI(TAG, "got ip:" IPSTR, IP2STR(&event->ip_info.ip)); s_retry_num = 0; xEventGroupSetBits(s_wifi_event_group, WIFI_CONNECTED_BIT); } } void wifi_init_sta(void) { s_wifi_event_group = xEventGroupCreate(); ESP_ERROR_CHECK(esp_netif_init()); ESP_ERROR_CHECK(esp_event_loop_create_default()); esp_netif_create_default_wifi_sta(); wifi_init_config_t cfg = WIFI_INIT_CONFIG_DEFAULT(); ESP_ERROR_CHECK(esp_wifi_init(&cfg)); esp_event_handler_instance_t instance_any_id; esp_event_handler_instance_t instance_got_ip; ESP_ERROR_CHECK(esp_event_handler_instance_register(WIFI_EVENT, ESP_EVENT_ANY_ID, &wifi_event_handler, NULL, &instance_any_id)); ESP_ERROR_CHECK(esp_event_handler_instance_register(IP_EVENT, IP_EVENT_STA_GOT_IP, &wifi_event_handler, NULL, &instance_got_ip)); wifi_config_t wifi_config = { .sta = { .ssid = EXAMPLE_ESP_WIFI_SSID, .password = EXAMPLE_ESP_WIFI_PASS, /* Authmode threshold resets to WPA2 as default if password matches WPA2 standards (pasword len => 8). * If you want to connect the device to deprecated WEP/WPA networks, Please set the threshold value * to WIFI_AUTH_WEP/WIFI_AUTH_WPA_PSK and set the password with length and format matching to * WIFI_AUTH_WEP/WIFI_AUTH_WPA_PSK standards. */ .threshold.authmode = ESP_WIFI_SCAN_AUTH_MODE_THRESHOLD, .sae_pwe_h2e = ESP_WIFI_SAE_MODE, .sae_h2e_identifier = EXAMPLE_H2E_IDENTIFIER, }, }; ESP_ERROR_CHECK(esp_wifi_set_mode(WIFI_MODE_STA) ); ESP_ERROR_CHECK(esp_wifi_set_config(WIFI_IF_STA, &wifi_config) ); ESP_ERROR_CHECK(esp_wifi_start() ); ESP_LOGI(TAG, "wifi_init_sta finished."); /* Waiting until either the connection is established (WIFI_CONNECTED_BIT) or connection failed for the maximum * number of re-tries (WIFI_FAIL_BIT). The bits are set by event_handler() (see above) */ EventBits_t bits = xEventGroupWaitBits(s_wifi_event_group, WIFI_CONNECTED_BIT | WIFI_FAIL_BIT, pdFALSE, pdFALSE, portMAX_DELAY); /* xEventGroupWaitBits() returns the bits before the call returned, hence we can test which event actually * happened. */ if (bits & WIFI_CONNECTED_BIT) { ESP_LOGI(TAG, "connected to ap SSID:%s password:%s", EXAMPLE_ESP_WIFI_SSID, EXAMPLE_ESP_WIFI_PASS); } else if (bits & WIFI_FAIL_BIT) { ESP_LOGI(TAG, "Failed to connect to SSID:%s, password:%s", EXAMPLE_ESP_WIFI_SSID, EXAMPLE_ESP_WIFI_PASS); } else { ESP_LOGE(TAG, "UNEXPECTED EVENT"); } } static void log_error_if_nonzero(const char *message, int error_code) { if (error_code != 0) { ESP_LOGE(TAG, "Last error %s: 0x%x", message, error_code); } } /* * @brief Event handler registered to receive MQTT events * * This function is called by the MQTT client event loop. * * @param handler_args user data registered to the event. * @param base Event base for the handler(always MQTT Base in this example). * @param event_id The id for the received event. * @param event_data The data for the event, esp_mqtt_event_handle_t. */ static void mqtt_event_handler(void *handler_args, esp_event_base_t base, int32_t event_id, void *event_data) { ESP_LOGD(TAG, "Event dispatched from event loop base=%s, event_id=%" PRIi32 "", base, event_id); esp_mqtt_event_handle_t event = event_data; esp_mqtt_client_handle_t client = event->client; int msg_id; switch ((esp_mqtt_event_id_t)event_id) { case MQTT_EVENT_CONNECTED: ESP_LOGI(TAG, "MQTT_EVENT_CONNECTED"); msg_id = esp_mqtt_client_publish(client, "/topic/qos1", "data_3", 0, 1, 0); ESP_LOGI(TAG, "sent publish successful, msg_id=%d", msg_id); msg_id = esp_mqtt_client_subscribe(client, topicTempExt, 0); ESP_LOGI(TAG, "sent subscribe successful, msg_id=%d", msg_id); msg_id = esp_mqtt_client_subscribe(client, "/topic/qos1", 1); ESP_LOGI(TAG, "sent subscribe successful, msg_id=%d", msg_id); msg_id = esp_mqtt_client_unsubscribe(client, "/topic/qos1"); ESP_LOGI(TAG, "sent unsubscribe successful, msg_id=%d", msg_id); break; case MQTT_EVENT_DISCONNECTED: ESP_LOGI(TAG, "MQTT_EVENT_DISCONNECTED"); break; case MQTT_EVENT_SUBSCRIBED: ESP_LOGI(TAG, "MQTT_EVENT_SUBSCRIBED, msg_id=%d", event->msg_id); msg_id = esp_mqtt_client_publish(client, "/topic/qos0", "data", 0, 0, 0); ESP_LOGI(TAG, "sent publish successful, msg_id=%d", msg_id); break; case MQTT_EVENT_UNSUBSCRIBED: ESP_LOGI(TAG, "MQTT_EVENT_UNSUBSCRIBED, msg_id=%d", event->msg_id); break; case MQTT_EVENT_PUBLISHED: ESP_LOGI(TAG, "MQTT_EVENT_PUBLISHED, msg_id=%d", event->msg_id); break; case MQTT_EVENT_DATA: ESP_LOGI(TAG, "MQTT_EVENT_DATA"); printf("TOPIC=%.*s\r\n", event->topic_len, event->topic); printf("DATA=%.*s\r\n", event->data_len, event->data); lv_subject_copy_string(&tempExtSubj, event->data); break; case MQTT_EVENT_ERROR: ESP_LOGI(TAG, "MQTT_EVENT_ERROR"); if (event->error_handle->error_type == MQTT_ERROR_TYPE_TCP_TRANSPORT) { log_error_if_nonzero("reported from esp-tls", event->error_handle->esp_tls_last_esp_err); log_error_if_nonzero("reported from tls stack", event->error_handle->esp_tls_stack_err); log_error_if_nonzero("captured as transport's socket errno", event->error_handle->esp_transport_sock_errno); ESP_LOGI(TAG, "Last errno string (%s)", strerror(event->error_handle->esp_transport_sock_errno)); } break; default: ESP_LOGI(TAG, "Other event id:%d", event->event_id); break; } } static void mqtt_app_start(void) { esp_mqtt_client_config_t mqtt_cfg = { .broker.address.uri = "mqtt://192.168.0.10", }; #if CONFIG_BROKER_URL_FROM_STDIN char line[128]; if (strcmp(mqtt_cfg.broker.address.uri, "FROM_STDIN") == 0) { int count = 0; printf("Please enter url of mqtt broker\n"); while (count < 128) { int c = fgetc(stdin); if (c == '\n') { line[count] = '\0'; break; } else if (c > 0 && c < 127) { line[count] = c; ++count; } vTaskDelay(10 / portTICK_PERIOD_MS); } mqtt_cfg.broker.address.uri = line; printf("Broker url: %s\n", line); } else { ESP_LOGE(TAG, "Configuration mismatch: wrong broker url"); abort(); } #endif /* CONFIG_BROKER_URL_FROM_STDIN */ client = esp_mqtt_client_init(&mqtt_cfg); /* The last argument may be used to pass data to the event handler, in this example mqtt_event_handler */ esp_mqtt_client_register_event(client, ESP_EVENT_ANY_ID, mqtt_event_handler, NULL); esp_mqtt_client_start(client); } void app_main(void) { /* LCD HW initialization */ ESP_ERROR_CHECK(app_lcd_init()); /* Touch initialization */ ESP_ERROR_CHECK(app_touch_init()); /* LVGL initialization */ ESP_ERROR_CHECK(app_lvgl_init()); //Initialize NVS esp_err_t ret = nvs_flash_init(); if (ret == ESP_ERR_NVS_NO_FREE_PAGES || ret == ESP_ERR_NVS_NEW_VERSION_FOUND) { ESP_ERROR_CHECK(nvs_flash_erase()); ret = nvs_flash_init(); } ESP_ERROR_CHECK(ret); ESP_LOGI(TAG, "ESP_WIFI_MODE_STA"); wifi_init_sta(); mqtt_app_start(); /* Show LVGL objects */ lvgl_port_lock(0); //app_main_display(); draw_ihm(); lvgl_port_unlock(); }