1264 lines
45 KiB
C
1264 lines
45 KiB
C
#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 "meteofrance.h"
|
|
#include "esp_netif_sntp.h"
|
|
#include "esp_sntp.h"
|
|
#include <locale.h>
|
|
|
|
#include "esp_lcd_touch_gt911.h"
|
|
LV_FONT_DECLARE(montserrat_medium_12)
|
|
LV_FONT_DECLARE(montserrat_medium_18)
|
|
|
|
char *days[7]={"Dimanche","Lundi","Mardi","Mercredi","Jeudi","Vendredi","Samedi"};
|
|
char *months[12]={"Janvier","Février","Mars","Avril","Mai","Juin","Juillet","Août","Septembre","Octobre","Novembre","Décembre"};
|
|
|
|
/* 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 (1)
|
|
#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;
|
|
|
|
lv_obj_t *chart;
|
|
lv_chart_series_t *ser1;
|
|
|
|
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 = 12288,//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)
|
|
{
|
|
if(lvgl_port_lock(0)){
|
|
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);
|
|
lvgl_port_unlock();
|
|
}
|
|
}
|
|
|
|
lv_subject_t wifiStatus;
|
|
lv_subject_t mqttStatus;
|
|
lv_subject_t meteoStatus;
|
|
|
|
|
|
static void app_main_display(void)
|
|
{
|
|
|
|
lv_subject_init_int(&wifiStatus,-1);
|
|
lv_subject_init_int(&mqttStatus,-1);
|
|
lv_subject_init_int(&meteoStatus,-1);
|
|
|
|
lv_obj_t *cont_status = lv_obj_create(lv_layer_top());
|
|
lv_obj_align(cont_status,LV_ALIGN_TOP_RIGHT,0,0);
|
|
lv_obj_set_flex_flow(cont_status, LV_FLEX_FLOW_ROW);
|
|
lv_obj_set_height(cont_status,LV_SIZE_CONTENT);
|
|
lv_obj_set_width(cont_status,LV_SIZE_CONTENT);
|
|
|
|
lv_obj_t *meteoR = lv_label_create(cont_status);
|
|
lv_label_set_text(meteoR,"Refresh");
|
|
lv_label_bind_text(meteoR, &meteoStatus, "Meteo %d");
|
|
|
|
lv_obj_t *wifi = lv_label_create(cont_status);
|
|
lv_label_set_text(wifi,"Wifi Ok");
|
|
lv_label_bind_text(wifi, &wifiStatus, "Wifi %d");
|
|
|
|
|
|
lv_obj_t *mqtt = lv_label_create(cont_status);
|
|
lv_label_set_text(mqtt,"Mqtt Ok");
|
|
lv_label_bind_text(mqtt, &mqttStatus, "Mqtt %d");
|
|
|
|
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[9];
|
|
char hauteurCuveEvolStr[9];
|
|
lv_subject_t tempIntSubj;
|
|
lv_subject_t tempExtSubj;
|
|
lv_subject_t hauteurCuveSubj;
|
|
lv_subject_t hauteurCuveEvolSubj;
|
|
lv_subject_t tempD1Subj;
|
|
lv_subject_t tempD2Subj;
|
|
lv_subject_t tempD3Subj;
|
|
lv_subject_t *tmpSubj[3] = {&tempD1Subj, &tempD2Subj, &tempD3Subj};
|
|
|
|
char *upEvent = "monter";
|
|
char *downEvent = "descendre";
|
|
|
|
char *topicTempExt = "house/temp/282A802600008059";
|
|
char *topicHauteurCuve = "house/cuve/hauteur";
|
|
char *topicTempInt = "house/temp/287DCF1E00008020";
|
|
char *topicHauteurCuveEvol = "house/cuve/hauteurEvol";
|
|
|
|
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;
|
|
}
|
|
}
|
|
LV_IMAGE_DECLARE(p1j);
|
|
LV_IMAGE_DECLARE(p2j);
|
|
LV_IMAGE_DECLARE(p3j);
|
|
LV_IMAGE_DECLARE(p5bisj);
|
|
LV_IMAGE_DECLARE(p14j);
|
|
LV_IMAGE_DECLARE(p24j);
|
|
LV_IMAGE_DECLARE(p25j);
|
|
LV_IMAGE_DECLARE(p26j);
|
|
LV_IMAGE_DECLARE(p27j);
|
|
LV_IMAGE_DECLARE(p29j);
|
|
|
|
static void weatherdata_obs_cb(lv_observer_t *observer, lv_subject_t *subject)
|
|
{
|
|
// Retrieve weatherdata
|
|
struct meteoforecast_data *data = subject->value.pointer;
|
|
printffd(data);
|
|
char buff[40] = {};
|
|
// sprintf(buff,"%s %.1f %.1f", data->previsions.desc, data->previsions.min, data->previsions.max);
|
|
lv_obj_t *parent = (lv_obj_t *)(observer->target);
|
|
lv_obj_t *desc_icon = lv_obj_get_child(parent, 0);
|
|
lv_obj_t *temps = lv_obj_get_child(parent, 1);
|
|
if (strcmp(data->previsions.icon, "p1j") == 0)
|
|
{
|
|
lv_image_set_src(lv_obj_get_child(desc_icon, 0), &p1j);
|
|
}else if (strcmp(data->previsions.icon, "p2j") == 0)
|
|
{
|
|
lv_image_set_src(lv_obj_get_child(desc_icon, 0), &p2j);
|
|
}else if (strcmp(data->previsions.icon, "p3j") == 0)
|
|
{
|
|
lv_image_set_src(lv_obj_get_child(desc_icon, 0), &p3j);
|
|
}else if (strcmp(data->previsions.icon, "p5bisj") == 0)
|
|
{
|
|
lv_image_set_src(lv_obj_get_child(desc_icon, 0), &p5bisj);
|
|
}else if (strcmp(data->previsions.icon, "p14j") == 0)
|
|
{
|
|
lv_image_set_src(lv_obj_get_child(desc_icon, 0), &p14j);
|
|
}else if (strcmp(data->previsions.icon, "p24j") == 0)
|
|
{
|
|
lv_image_set_src(lv_obj_get_child(desc_icon, 0), &p24j);
|
|
}else if (strcmp(data->previsions.icon, "p25j") == 0)
|
|
{
|
|
lv_image_set_src(lv_obj_get_child(desc_icon, 0), &p25j);
|
|
}else if (strcmp(data->previsions.icon, "p26j") == 0)
|
|
{
|
|
lv_image_set_src(lv_obj_get_child(desc_icon, 0), &p26j);
|
|
}else if (strcmp(data->previsions.icon, "p27j") == 0)
|
|
{
|
|
lv_image_set_src(lv_obj_get_child(desc_icon, 0), &p27j);
|
|
}else if (strcmp(data->previsions.icon, "p29j") == 0)
|
|
{
|
|
lv_image_set_src(lv_obj_get_child(desc_icon, 0), &p29j);
|
|
}
|
|
lv_label_set_text(lv_obj_get_child(desc_icon, 1), data->previsions.desc);
|
|
lv_label_set_text_fmt(lv_obj_get_child(temps, 0), "%.1f°C", data->previsions.max);
|
|
lv_label_set_text_fmt(lv_obj_get_child(temps, 1), "%.1f°C", data->previsions.min);
|
|
}
|
|
|
|
static lv_style_t style_container;
|
|
|
|
struct weatherDay_fragment_t
|
|
{
|
|
/* IMPORTANT: don't miss this part */
|
|
lv_fragment_t base;
|
|
/* States, object references and data fields for this fragment */
|
|
int dayNr;
|
|
const char *title;
|
|
float minTemp;
|
|
float maxTemp;
|
|
};
|
|
static void weatherDay_fragment_ctor(lv_fragment_t *self, int args)
|
|
{
|
|
((struct weatherDay_fragment_t *)self)->dayNr = args;
|
|
}
|
|
|
|
static lv_style_t style_font_16;
|
|
static lv_style_t style_font_12;
|
|
|
|
static lv_obj_t *weatherDay_fragment_create_obj(lv_fragment_t *self, lv_obj_t *parent)
|
|
{
|
|
lvgl_port_lock(0);
|
|
|
|
lv_obj_t *sup = lv_obj_create(parent);
|
|
lv_obj_set_flex_flow(sup, LV_FLEX_FLOW_ROW);
|
|
lv_obj_add_style(sup, &style_container, 0);
|
|
lv_obj_set_size(sup, LV_SIZE_CONTENT, LV_SIZE_CONTENT);
|
|
|
|
static lv_style_t no_padding;
|
|
lv_style_init(&no_padding);
|
|
lv_style_set_pad_all(&no_padding, 0);
|
|
|
|
lv_obj_t *container = lv_obj_create(sup);
|
|
lv_obj_set_flex_flow(container, LV_FLEX_FLOW_COLUMN);
|
|
lv_obj_set_flex_align(container,LV_FLEX_ALIGN_CENTER,LV_FLEX_ALIGN_CENTER, LV_FLEX_ALIGN_CENTER);
|
|
lv_obj_add_style(container, &no_padding, 0);
|
|
lv_obj_set_width(container, 100);
|
|
lv_obj_set_height(container, 90);
|
|
|
|
lv_obj_t *img1 = lv_image_create(container);
|
|
lv_obj_add_style(img1, &no_padding, 0);
|
|
lv_obj_set_style_bg_color(img1,lv_palette_lighten(LV_PALETTE_BLUE_GREY, 4),0);
|
|
lv_image_set_inner_align(img1, LV_IMAGE_ALIGN_TOP_LEFT);
|
|
lv_image_set_offset_y(img1, -8);
|
|
lv_image_set_offset_x(img1, -8);
|
|
lv_obj_set_size(img1,40,40);
|
|
lv_image_set_src(img1,LV_SYMBOL_DUMMY);
|
|
//lv_obj_set_style_border_width(img1,2,0);
|
|
//lv_obj_set_style_border_color(img1, lv_palette_main(LV_PALETTE_BLUE_GREY), 0);
|
|
lv_obj_align(img1, LV_ALIGN_CENTER, 0, 0);
|
|
|
|
lv_obj_t *desc = lv_label_create(container);
|
|
lv_label_set_text(desc,"--");
|
|
lv_obj_add_style(desc, &style_font_12, 0);
|
|
|
|
lv_obj_t *container2 = lv_obj_create(sup);
|
|
lv_obj_set_width(container2, LV_SIZE_CONTENT);
|
|
lv_obj_set_height(container2, 90);
|
|
lv_obj_add_style(container2, &no_padding, 0);
|
|
lv_obj_set_style_pad_top(container2,5,0);
|
|
lv_obj_set_style_pad_bottom(container2,5,0);
|
|
lv_obj_set_flex_flow(container2, LV_FLEX_FLOW_COLUMN);
|
|
lv_obj_set_flex_align(container2, LV_FLEX_ALIGN_SPACE_BETWEEN, LV_FLEX_ALIGN_START, LV_FLEX_ALIGN_START);
|
|
|
|
static lv_style_t tempStyle;
|
|
lv_style_init(&tempStyle);
|
|
//lv_style_set_text_font(&tempStyle,¬omedium16);
|
|
|
|
lv_obj_t *max = lv_label_create(container2);
|
|
lv_label_set_text(max,"--");
|
|
lv_obj_add_style(max, &tempStyle,0);
|
|
lv_obj_add_style(max, &style_font_16, 0);
|
|
lv_obj_set_style_text_color(max,lv_color_hex(0xFF0000),0);
|
|
lv_obj_t *min = lv_label_create(container2);
|
|
lv_label_set_text(min,"--");
|
|
lv_obj_add_style(min, &tempStyle,0);
|
|
lv_obj_add_style(min, &style_font_16, 0);
|
|
lv_obj_set_style_text_color(min,lv_color_hex(0x3000FF),0);
|
|
lv_subject_add_observer_obj(tmpSubj[((struct weatherDay_fragment_t *)self)->dayNr], weatherdata_obs_cb, sup, NULL);
|
|
lvgl_port_unlock();
|
|
return container;
|
|
}
|
|
const lv_fragment_class_t sample_cls = {
|
|
/* Initialize something needed */
|
|
.constructor_cb = weatherDay_fragment_ctor,
|
|
/* Create view objects */
|
|
.create_obj_cb = weatherDay_fragment_create_obj,
|
|
/* IMPORTANT: size of your fragment struct */
|
|
.instance_size = sizeof(struct weatherDay_fragment_t),
|
|
};
|
|
|
|
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, 9, "--");
|
|
lv_subject_init_string(&hauteurCuveEvolSubj, hauteurCuveEvolStr, NULL, 9, "--");
|
|
lv_subject_init_pointer(&tempD1Subj, "--");
|
|
lv_subject_init_pointer(&tempD2Subj, "--");
|
|
lv_subject_init_pointer(&tempD3Subj, "--");
|
|
|
|
// keys.clear();
|
|
lv_obj_clean(lv_scr_act());
|
|
|
|
|
|
|
|
|
|
/*Create a Tab view object*/
|
|
lv_obj_t * tabview;
|
|
tabview = lv_tabview_create(lv_screen_active());
|
|
lv_tabview_set_tab_bar_position(tabview, LV_DIR_LEFT);
|
|
lv_tabview_set_tab_bar_size(tabview, 80);
|
|
|
|
lv_obj_set_style_bg_color(tabview, lv_palette_lighten(LV_PALETTE_RED, 2), 0);
|
|
|
|
|
|
lv_obj_t * tab_buttons = lv_tabview_get_tab_bar(tabview);
|
|
lv_obj_set_width(tab_buttons,100);
|
|
lv_obj_set_style_text_font(tab_buttons, &montserrat_medium_18, 0);
|
|
lv_obj_set_style_bg_color(tab_buttons, lv_palette_darken(LV_PALETTE_GREY, 3), 0);
|
|
lv_obj_set_style_text_color(tab_buttons, lv_palette_lighten(LV_PALETTE_GREY, 5), 0);
|
|
lv_obj_set_style_border_side(tab_buttons, LV_BORDER_SIDE_RIGHT, LV_PART_ITEMS | LV_STATE_CHECKED);
|
|
|
|
/*Add 3 tabs (the tabs are page (lv_page) and can be scrolled*/
|
|
lv_obj_t * tab1 = lv_tabview_add_tab(tabview, LV_SYMBOL_HOME);
|
|
lv_obj_t * tab2 = lv_tabview_add_tab(tabview, "Volets");
|
|
lv_obj_t * tab3 = lv_tabview_add_tab(tabview, "Météo");
|
|
lv_obj_t * tab4 = lv_tabview_add_tab(tabview, "Cuve");
|
|
lv_obj_t * tab5 = lv_tabview_add_tab(tabview, "Réglages");
|
|
|
|
lv_obj_set_style_bg_color(tab2, lv_palette_lighten(LV_PALETTE_AMBER, 3), 0);
|
|
lv_obj_set_style_bg_opa(tab2, LV_OPA_COVER, 0);
|
|
|
|
|
|
static lv_style_t style_btn;
|
|
lv_style_init(&style_btn);
|
|
|
|
lv_style_init(&style_font_16);
|
|
lv_style_set_text_font(&style_font_16, &montserrat_medium_18);
|
|
|
|
lv_style_init(&style_font_12);
|
|
lv_style_set_text_font(&style_font_12, &montserrat_medium_12);
|
|
|
|
// 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, 80);
|
|
lv_style_set_height(&style_btn, 100);
|
|
|
|
// Un style pour les conteneurs (température, cuve ...)
|
|
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, 200);
|
|
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 no_padding;
|
|
lv_style_init(&no_padding);
|
|
lv_style_set_pad_all(&no_padding, 0);
|
|
|
|
static lv_style_t style_lbvValue;
|
|
lv_style_init(&style_lbvValue);
|
|
lv_style_set_text_font(&style_lbvValue, &lv_font_montserrat_40);
|
|
|
|
lv_obj_t *supmain = tab1;
|
|
lv_obj_set_flex_flow(supmain, LV_FLEX_FLOW_COLUMN);
|
|
|
|
lv_obj_t *jour = lv_label_create(supmain);
|
|
lv_obj_add_style(jour,&style_font_16,0);
|
|
|
|
setlocale(LC_ALL, "fr_FR");
|
|
char strftime_buf[64];
|
|
time_t now = 0;
|
|
time(&now);
|
|
struct tm timeinfo = { 0 };
|
|
localtime_r(&now, &timeinfo);
|
|
sprintf(strftime_buf,"%s %d %s", days[timeinfo.tm_wday], timeinfo.tm_mday, months[timeinfo.tm_mon]);
|
|
|
|
lv_label_set_text(jour,strftime_buf);
|
|
lv_obj_align(jour, LV_ALIGN_CENTER,0,0);
|
|
|
|
lv_obj_t *main = lv_obj_create(supmain);
|
|
lv_obj_add_style(main,&no_padding,0);
|
|
lv_obj_set_size(main,LV_SIZE_CONTENT,LV_SIZE_CONTENT);
|
|
|
|
lv_obj_set_flex_flow(main, LV_FLEX_FLOW_ROW);
|
|
lv_obj_set_style_pad_column(main, 1, 0);
|
|
|
|
/*Create a container with COLUMN flex direction*/
|
|
lv_obj_t *cont_col = lv_obj_create(main);
|
|
lv_obj_set_style_pad_all(cont_col, 5, 0);
|
|
lv_obj_set_size(cont_col, 250, 400);
|
|
lv_obj_align(cont_col, LV_ALIGN_TOP_LEFT, 0, 0);
|
|
lv_obj_set_flex_flow(cont_col, LV_FLEX_FLOW_COLUMN);
|
|
lv_obj_set_flex_align(cont_col,LV_FLEX_ALIGN_CENTER,LV_FLEX_ALIGN_CENTER, LV_FLEX_ALIGN_CENTER);
|
|
|
|
/*Create a container with COLUMN flex direction*/
|
|
lv_obj_t *cont_col2 = lv_obj_create(main);
|
|
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);
|
|
|
|
/*Create a container with COLUMN flex direction*/
|
|
lv_obj_t *cont_col3 = lv_obj_create(main);
|
|
lv_obj_set_style_pad_all(cont_col3, 5, 0);
|
|
lv_obj_set_size(cont_col3, 300, 400);
|
|
lv_obj_set_flex_flow(cont_col3, LV_FLEX_FLOW_COLUMN);
|
|
lv_obj_set_flex_align(cont_col3, LV_FLEX_ALIGN_CENTER, LV_FLEX_ALIGN_CENTER, LV_FLEX_ALIGN_CENTER);
|
|
|
|
lv_obj_set_height(cont_col2, 400);
|
|
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_obj_set_style_text_font(label1, &montserrat_medium_18,0);
|
|
lv_label_set_text(label1, "Températures");
|
|
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_obj_add_style(label, &style_lbvValue, 0);
|
|
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_obj_add_style(label, &style_lbvValue, 0);
|
|
lv_label_set_text(label, LV_SYMBOL_DOWN);
|
|
lv_obj_center(label);
|
|
|
|
/*Create a chart*/
|
|
/*
|
|
chart = lv_chart_create(tab1);
|
|
lv_obj_set_size(chart, 200, 200);
|
|
lv_chart_set_type(chart, LV_CHART_TYPE_LINE); //Show lines and points too
|
|
lv_chart_set_range(chart, LV_CHART_AXIS_PRIMARY_Y, 0, 130);
|
|
ser1 = lv_chart_add_series(chart, lv_palette_main(LV_PALETTE_GREEN), LV_CHART_AXIS_PRIMARY_Y);;
|
|
ser1->y_points[0] = lv_rand(0, 40);
|
|
ser1->y_points[1] = lv_rand(0, 40);
|
|
ser1->y_points[2] = lv_rand(0, 40);
|
|
lv_chart_refresh(chart); //Required after direct set
|
|
*/
|
|
/*
|
|
lv_obj_t *tempD1Cont = lv_obj_create(cont_col3);
|
|
lv_obj_add_style(tempD1Cont, &style_container, 0);
|
|
lv_obj_t *tempD1 = lv_label_create(tempD1Cont);
|
|
lv_obj_add_style(tempD1, &style_lbvValue, 0);
|
|
lv_label_bind_text(tempD1, &tempD1Subj, "%i");
|
|
lv_subject_add_observer_obj(&tempD1Subj, weatherdata_obs_cb, tempD1, NULL);
|
|
lv_obj_t *tempD2Cont = lv_obj_create(cont_col3);
|
|
lv_obj_add_style(tempD2Cont, &style_container, 0);
|
|
lv_obj_t *tempD2 = lv_label_create(tempD2Cont);
|
|
lv_obj_add_style(tempD2, &style_lbvValue, 0);
|
|
lv_label_bind_text(tempD2, &tempD2Subj, "%i");
|
|
lv_subject_add_observer_obj(&tempD2Subj, weatherdata_obs_cb, tempD2, NULL);
|
|
|
|
lv_obj_t *tempD3Cont = lv_obj_create(cont_col3);
|
|
lv_obj_add_style(tempD3Cont, &style_container, 0);
|
|
lv_obj_t *tempD3 = lv_label_create(tempD3Cont);
|
|
lv_obj_add_style(tempD3, &style_lbvValue, 0);
|
|
lv_label_bind_text(tempD3, &tempD3Subj, "%i");
|
|
lv_subject_add_observer_obj(&tempD3Subj, weatherdata_obs_cb, tempD3, NULL);
|
|
*/
|
|
lv_fragment_manager_t *manager = lv_fragment_manager_create(NULL);
|
|
|
|
lv_fragment_t *fragment = lv_fragment_create(&sample_cls, 0);
|
|
lv_fragment_manager_add(manager, fragment, &cont_col3);
|
|
|
|
fragment = lv_fragment_create(&sample_cls, 1);
|
|
lv_fragment_manager_add(manager, fragment, &cont_col3);
|
|
|
|
fragment = lv_fragment_create(&sample_cls, 2);
|
|
lv_fragment_manager_add(manager, fragment, &cont_col3);
|
|
}
|
|
|
|
/* 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(lvgl_port_lock(0)){
|
|
lv_subject_set_int(&wifiStatus,0);
|
|
lvgl_port_unlock();
|
|
}
|
|
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)
|
|
{
|
|
if(lvgl_port_lock(0)){
|
|
lv_subject_set_int(&wifiStatus,1);
|
|
lvgl_port_unlock();
|
|
}
|
|
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);
|
|
if(lvgl_port_lock(0)){
|
|
lv_subject_set_int(&wifiStatus,1);
|
|
lvgl_port_unlock();
|
|
}
|
|
}
|
|
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);
|
|
if(lvgl_port_lock(0)){
|
|
lv_subject_set_int(&wifiStatus,0);
|
|
lvgl_port_unlock();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
ESP_LOGE(TAG, "UNEXPECTED EVENT");
|
|
if(lvgl_port_lock(0)){
|
|
lv_subject_set_int(&wifiStatus,0);
|
|
lvgl_port_unlock();
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
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);
|
|
}
|
|
}
|
|
|
|
void splitIt(char *payload, unsigned int length, float *datas)
|
|
{
|
|
char *sep = ",";
|
|
char *token;
|
|
char *saveptr1;
|
|
|
|
token = strtok_r(payload, sep, &saveptr1);
|
|
datas[0] = atoff(token);
|
|
ESP_LOGE(TAG,"%f",datas[0]);
|
|
|
|
token = strtok_r(NULL, sep, &saveptr1);
|
|
datas[1] = atoff(token);
|
|
ESP_LOGE(TAG,"%f",datas[1]);
|
|
|
|
token = strtok_r(NULL, sep, &saveptr1);
|
|
datas[2] = atoff(token);
|
|
ESP_LOGE(TAG,"%f",datas[2]);
|
|
|
|
token = strtok_r(NULL, sep, &saveptr1);
|
|
datas[3] = atoff(token);
|
|
ESP_LOGE(TAG,"%f",datas[3]);
|
|
}
|
|
|
|
/*
|
|
* @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:
|
|
if(lvgl_port_lock(0)){
|
|
lv_subject_set_int(&mqttStatus,1);
|
|
lvgl_port_unlock();
|
|
}
|
|
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, topicTempInt, 0);
|
|
ESP_LOGI(TAG, "sent subscribe successful, msg_id=%d", msg_id);
|
|
|
|
msg_id = esp_mqtt_client_subscribe(client, topicHauteurCuve, 0);
|
|
ESP_LOGI(TAG, "sent subscribe successful, msg_id=%d", msg_id);
|
|
|
|
msg_id = esp_mqtt_client_subscribe(client, topicHauteurCuveEvol, 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:
|
|
if(lvgl_port_lock(0)){
|
|
lv_subject_set_int(&mqttStatus,0);
|
|
lvgl_port_unlock();
|
|
}
|
|
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);
|
|
if (strncmp(event->topic, topicTempExt, 27) == 0)
|
|
{
|
|
lvgl_port_lock(0);
|
|
lv_subject_copy_string(&tempExtSubj, event->data);
|
|
lvgl_port_unlock();
|
|
}
|
|
else if (strncmp(event->topic, topicTempInt, 27) == 0)
|
|
{
|
|
lvgl_port_lock(0);
|
|
lv_subject_copy_string(&tempIntSubj, event->data);
|
|
lvgl_port_unlock();
|
|
}
|
|
else if (strncmp(event->topic, topicHauteurCuveEvol, 22) == 0)
|
|
{
|
|
/* float datas[4] = {};
|
|
splitIt(event->data, event->data_len, datas);
|
|
ser1->y_points[0] = 130 - (int)datas[0];
|
|
ser1->y_points[1] = 130 - (int)datas[1];
|
|
ser1->y_points[2] = 130 - (int)datas[2];
|
|
ser1->y_points[3] = 130 - (int)datas[3];
|
|
lvgl_port_lock(0);
|
|
lv_chart_refresh(chart);
|
|
lvgl_port_unlock();
|
|
*/
|
|
|
|
// lv_subject_copy_string(&hauteurCuveEvolSubj, event->data);
|
|
}
|
|
else if (strncmp(event->topic, topicHauteurCuve, 18) == 0)
|
|
{
|
|
lvgl_port_lock(0);
|
|
char *datas = NULL;
|
|
datas = (char *)malloc(event->data_len * sizeof(char));
|
|
stpncpy(datas, event->data, event->data_len);
|
|
datas[event->data_len] = '\0';
|
|
lv_subject_copy_string(&hauteurCuveSubj, datas);
|
|
lvgl_port_unlock();
|
|
}
|
|
else
|
|
{
|
|
ESP_LOGE(TAG, "None match :-(");
|
|
}
|
|
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",
|
|
.network.timeout_ms = 1000};
|
|
#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 weather_data_retreived_start()
|
|
{
|
|
ESP_LOGE(TAG,"Début recup méteo");
|
|
if(lvgl_port_lock(0)){
|
|
lv_subject_set_int(&meteoStatus,1);
|
|
lvgl_port_unlock();
|
|
}
|
|
}
|
|
|
|
void weather_data_retreived(struct meteoforecast_data datas[3])
|
|
{
|
|
// struct meteoforecast_data* weather = (meteoforecast_data*) args;
|
|
struct meteoforecast_data j1 = {};
|
|
ESP_LOGE(TAG, "debut debug");
|
|
printf("%lld\n", datas[0].datetime);
|
|
printf("%s\n", datas[0].previsions.desc);
|
|
printf("%f\n", datas[0].previsions.min);
|
|
printf("%lld\n", datas[1].datetime);
|
|
printf("%s\n", datas[1].previsions.desc);
|
|
printf("%f\n", datas[1].previsions.min);
|
|
printf("%lld\n", datas[2].datetime);
|
|
printf("%s\n", datas[2].previsions.desc);
|
|
printf("%f\n", datas[2].previsions.min);
|
|
ESP_LOGE(TAG, "fin debug");
|
|
|
|
if (lvgl_port_lock(0))
|
|
{
|
|
ESP_LOGE(TAG, "------------------------------------- Set des subjects --------------------------------");
|
|
lv_subject_set_pointer(&tempD1Subj, &datas[0]);
|
|
lv_subject_set_pointer(&tempD2Subj, &datas[1]);
|
|
lv_subject_set_pointer(&tempD3Subj, &datas[2]);
|
|
lv_subject_set_int(&meteoStatus,0);
|
|
lvgl_port_unlock();
|
|
ESP_LOGE(TAG, "------------------------------------- Fin Set des subjects --------------------------------");
|
|
}
|
|
}
|
|
static void obtain_time(void);
|
|
void time_sync_notification_cb(struct timeval *tv)
|
|
{
|
|
ESP_LOGI(TAG, "Notification of a time synchronization event");
|
|
}
|
|
|
|
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);
|
|
|
|
|
|
/* Show LVGL objects */
|
|
if(lvgl_port_lock(0)){
|
|
app_main_display();
|
|
lvgl_port_unlock();
|
|
}
|
|
ESP_LOGI(TAG, "ESP_WIFI_MODE_STA");
|
|
wifi_init_sta();
|
|
mqtt_app_start();
|
|
|
|
time_t now;
|
|
struct tm timeinfo;
|
|
time(&now);
|
|
localtime_r(&now, &timeinfo);
|
|
// Is time set? If not, tm_year will be (1970 - 1900).
|
|
if (timeinfo.tm_year < (2016 - 1900)) {
|
|
ESP_LOGI(TAG, "Time is not set yet. Connecting to WiFi and getting time over NTP.");
|
|
obtain_time();
|
|
// update 'now' variable with current time
|
|
time(&now);
|
|
}
|
|
|
|
char strftime_buf[64];
|
|
|
|
// Set timezone to Eastern Standard Time and print local time
|
|
setenv("TZ", "CET-1CEST,M3.5.0,M10.5.0/3", 1);
|
|
tzset();
|
|
localtime_r(&now, &timeinfo);
|
|
strftime(strftime_buf, sizeof(strftime_buf), "%c", &timeinfo);
|
|
|
|
on_weather_data_retrieval(weather_data_retreived);
|
|
on_weather_data_retrieval_start(weather_data_retreived_start);
|
|
initialise_weather_data_retrieval(60000);
|
|
ESP_LOGW(TAG, "Weather data retrieval initialized");
|
|
|
|
/* Show LVGL objects */
|
|
if(lvgl_port_lock(0)){
|
|
// app_main_display();
|
|
draw_ihm();
|
|
lvgl_port_unlock();
|
|
}
|
|
}
|
|
|
|
static void obtain_time(void)
|
|
{
|
|
ESP_LOGI(TAG, "Initializing and starting SNTP");
|
|
esp_sntp_config_t config = ESP_NETIF_SNTP_DEFAULT_CONFIG("pool.ntp.org");
|
|
config.sync_cb = time_sync_notification_cb; // Note: This is only needed if we want
|
|
esp_netif_sntp_init(&config);
|
|
|
|
// wait for time to be set
|
|
time_t now = 0;
|
|
struct tm timeinfo = { 0 };
|
|
int retry = 0;
|
|
const int retry_count = 15;
|
|
while (esp_netif_sntp_sync_wait(2000 / portTICK_PERIOD_MS) == ESP_ERR_TIMEOUT && ++retry < retry_count) {
|
|
ESP_LOGI(TAG, "Waiting for system time to be set... (%d/%d)", retry, retry_count);
|
|
}
|
|
time(&now);
|
|
localtime_r(&now, &timeinfo);
|
|
|
|
esp_netif_sntp_deinit();
|
|
}
|
|
|