diff --git a/main/CMakeLists.txt b/main/CMakeLists.txt index 593c759..ea208d2 100644 --- a/main/CMakeLists.txt +++ b/main/CMakeLists.txt @@ -1,3 +1,3 @@ idf_build_get_property(project_dir PROJECT_DIR) -idf_component_register(SRCS "zh_espnow_open_sensor_esp32.c" +idf_component_register(SRCS "zh_espnow_open_sensor.c" INCLUDE_DIRS ".") \ No newline at end of file diff --git a/main/Kconfig.projbuild b/main/Kconfig.projbuild new file mode 100644 index 0000000..d72ec00 --- /dev/null +++ b/main/Kconfig.projbuild @@ -0,0 +1,15 @@ +menu "ZH ESP-NOW Open Sensor Configuration" + + choice SENSOR_TYPE + prompt "Sensor type" + help + Sensor type. + default SENSOR_TYPE_WINDOW + config SENSOR_TYPE_WINDOW + bool "WINDOW" + config SENSOR_TYPE_DOOR + bool "DOOR" + + endchoice + +endmenu \ No newline at end of file diff --git a/main/zh_espnow_open_sensor_esp32.c b/main/zh_espnow_open_sensor.c similarity index 51% rename from main/zh_espnow_open_sensor_esp32.c rename to main/zh_espnow_open_sensor.c index 0eb4106..287e310 100644 --- a/main/zh_espnow_open_sensor_esp32.c +++ b/main/zh_espnow_open_sensor.c @@ -10,23 +10,34 @@ #include "zh_espnow.h" #include "zh_config.h" -#define ZH_MESSAGE_TASK_PRIORITY 2 -#define ZH_MESSAGE_STACK_SIZE 2048 +#define ZH_UART_TASK_PRIORITY 6 +#define ZH_UART_STACK_SIZE 2048 +#define ZH_UART_BUFF_SIZE 1024 +#define ZH_UART_QUEUE_SIZE 10 +#define ZH_UART_NUM 0 -static uint8_t s_relay_status = OFF; +static uint8_t s_sensor_type = HAST_NONE; +static uint8_t s_open_status = HAONOFT_OPEN; +static uint8_t s_battery_status = HAONOFT_LOW; static uint8_t s_gateway_mac[6] = {0}; static bool s_gateway_is_available = false; -// static TaskHandle_t s_switch_attributes_message_task = {0}; -// static TaskHandle_t s_switch_config_message_task = {0}; -// static TaskHandle_t s_switch_keep_alive_message_task = {0}; -// static TaskHandle_t s_switch_status_message_task = {0}; - static const esp_partition_t *s_update_partition = NULL; static esp_ota_handle_t s_update_handle = 0; static uint16_t s_ota_message_part_number = 0; +static QueueHandle_t s_zh_uart_queue = {0}; + +static const char s_initial_message[] = {0x55, 0xAA, 0x00, 0x01, 0x00, 0x00, 0x00}; +static const char s_connected_message[] = {0x55, 0xAA, 0x00, 0x02, 0x00, 0x01, 0x04, 0x06}; +static const char s_setting_message[] = {0x55, 0xAA, 0x00, 0x03, 0x00, 0x00, 0x02}; +static const char s_confirmation_message[] = {0x55, 0xAA, 0x00, 0x08, 0x00, 0x01, 0x00, 0x08}; + +static void s_uart_processing_task(void *pvParameter); + +static void s_zh_load_config(void); +static void s_zh_save_config(void); static void s_zh_load_status(void); static void s_zh_save_status(void); @@ -38,13 +49,19 @@ static void s_zh_espnow_event_handler(void *arg, esp_event_base_t event_base, in void app_main(void) { +#if CONFIG_SENSOR_TYPE_WINDOW + s_sensor_type = HAST_WINDOW; +#elif CONFIG_SENSOR_TYPE_DOOR + s_sensor_type = HAST_DOOR; +#endif const esp_partition_t *running = esp_ota_get_running_partition(); esp_ota_img_states_t ota_state = {0}; esp_ota_get_state_partition(running, &ota_state); nvs_flash_init(); esp_netif_init(); esp_event_loop_create_default(); - s_zh_load_status(); + // s_zh_load_config(); + // s_zh_load_status(); wifi_init_config_t wifi_init_config = WIFI_INIT_CONFIG_DEFAULT(); esp_wifi_init(&wifi_init_config); esp_wifi_set_mode(WIFI_MODE_STA); @@ -52,15 +69,109 @@ void app_main(void) zh_espnow_init_config_t zh_espnow_init_config = ZH_ESPNOW_INIT_CONFIG_DEFAULT(); zh_espnow_init(&zh_espnow_init_config); esp_event_handler_instance_register(ZH_ESPNOW, ESP_EVENT_ANY_ID, &s_zh_espnow_event_handler, NULL, NULL); + xTaskCreatePinnedToCore(&s_uart_processing_task, "s_uart_processing_tack", ZH_UART_STACK_SIZE, NULL, ZH_UART_TASK_PRIORITY, NULL, tskNO_AFFINITY); s_zh_send_sensor_config_message(); s_zh_send_sensor_attributes_message(); - s_zh_send_sensor_status_message(); + uart_write_bytes(ZH_UART_NUM, &s_initial_message, sizeof(s_initial_message)); if (ota_state == ESP_OTA_IMG_PENDING_VERIFY) { + vTaskDelay(100 / portTICK_PERIOD_MS); esp_ota_mark_app_valid_cancel_rollback(); } } +static void s_uart_processing_task(void *pvParameter) +{ + uart_config_t uart_config = { + .baud_rate = 115200, + .data_bits = UART_DATA_8_BITS, + .parity = UART_PARITY_DISABLE, + .stop_bits = UART_STOP_BITS_1, + .flow_ctrl = UART_HW_FLOWCTRL_DISABLE, + .source_clk = UART_SCLK_DEFAULT, + }; + uart_driver_install(ZH_UART_NUM, ZH_UART_BUFF_SIZE, ZH_UART_BUFF_SIZE, ZH_UART_QUEUE_SIZE, &s_zh_uart_queue, 0); + uart_param_config(ZH_UART_NUM, &uart_config); + uart_set_pin(ZH_UART_NUM, UART_PIN_NO_CHANGE, UART_PIN_NO_CHANGE, UART_PIN_NO_CHANGE, UART_PIN_NO_CHANGE); + uint8_t *data = (uint8_t *)calloc(1, ZH_UART_BUFF_SIZE); + uart_event_t event = {0}; + for (;;) + { + if (xQueueReceive(s_zh_uart_queue, (void *)&event, (TickType_t)portMAX_DELAY)) + { + switch (event.type) + { + case UART_DATA: + uart_read_bytes(ZH_UART_NUM, data, event.size, portMAX_DELAY); + if (data[0] == 0x55 && data[3] == 0x01) // MCU system information. + { + uart_write_bytes(ZH_UART_NUM, &s_connected_message, sizeof(s_connected_message)); + } + if (data[0] == 0x55 && data[3] == 0x03) // Message for switching to setting mode. + { + uart_write_bytes(ZH_UART_NUM, &s_setting_message, sizeof(s_setting_message)); + } + if (data[0] == 0x55 && data[3] == 0x08) // Sensor status message. + { + if (data[7] == 0x01) // Battery status. + { + // Serial.write(confirmationMessage, sizeof(confirmationMessage)); + // Serial.flush(); + s_zh_send_sensor_status_message(); + uart_write_bytes(ZH_UART_NUM, &s_confirmation_message, sizeof(s_confirmation_message)); + } + if (data[7] == 0x02) // Sensor position. + { + // esp_now_payload_data_t outgoingData{ENDT_SENSOR, ENPT_STATE}; + // DynamicJsonDocument json(sizeof(esp_now_payload_data_t::message)); + // if (receivedBytes[17] == 0x01) + // json["state"] = "OPEN"; + // if (receivedBytes[17] == 0x00) + // json["state"] = "CLOSED"; + // json["battery"] = round((double(system_get_vdd33()) / 1000) * 100) / 100; + // serializeJsonPretty(json, outgoingData.message); + // char temp[sizeof(esp_now_payload_data_t)]{0}; + // memcpy(&temp, &outgoingData, sizeof(esp_now_payload_data_t)); + // myNet.sendBroadcastMessage(temp); + // semaphore = true; + s_zh_send_sensor_status_message(); + uart_write_bytes(ZH_UART_NUM, &s_confirmation_message, sizeof(s_confirmation_message)); + } + } + break; + default: + break; + } + } + } + free(data); + vTaskDelete(NULL); +} + +static void s_zh_load_config(void) +{ + nvs_handle_t nvs_handle = 0; + nvs_open("config", NVS_READWRITE, &nvs_handle); + uint8_t config_is_present = 0; + if (nvs_get_u8(nvs_handle, "present", &config_is_present) == ESP_ERR_NVS_NOT_FOUND) + { + nvs_set_u8(nvs_handle, "present", 0xFE); + nvs_close(nvs_handle); + s_zh_save_config(); + return; + } + nvs_get_u8(nvs_handle, "sensor_type", &s_sensor_type); + nvs_close(nvs_handle); +} + +static void s_zh_save_config(void) +{ + nvs_handle_t nvs_handle = 0; + nvs_open("config", NVS_READWRITE, &nvs_handle); + nvs_set_u8(nvs_handle, "sensor_type", s_sensor_type); + nvs_close(nvs_handle); +} + static void s_zh_load_status(void) { nvs_handle_t nvs_handle = 0; @@ -73,7 +184,8 @@ static void s_zh_load_status(void) s_zh_save_status(); return; } - nvs_get_u8(nvs_handle, "relay_state", &s_relay_status); + nvs_get_u8(nvs_handle, "open_state", &s_open_status); + nvs_get_u8(nvs_handle, "battery_state", &s_battery_status); nvs_close(nvs_handle); } @@ -81,7 +193,8 @@ static void s_zh_save_status(void) { nvs_handle_t nvs_handle = 0; nvs_open("status", NVS_READWRITE, &nvs_handle); - nvs_set_u8(nvs_handle, "relay_state", s_relay_status); + nvs_set_u8(nvs_handle, "open_state", s_open_status); + nvs_set_u8(nvs_handle, "battery_state", s_battery_status); nvs_close(nvs_handle); } @@ -107,33 +220,42 @@ static void s_zh_send_sensor_attributes_message(void) static void s_zh_send_sensor_config_message(void) { - zh_switch_config_message_t switch_config_message = {0}; - switch_config_message.unique_id = 1; - switch_config_message.device_class = HASWDC_SWITCH; - switch_config_message.payload_on = HAONOFT_ON; - switch_config_message.payload_off = HAONOFT_OFF; - switch_config_message.enabled_by_default = true; - switch_config_message.optimistic = false; - switch_config_message.qos = 2; - switch_config_message.retain = true; + zh_binary_sensor_config_message_t binary_sensor_config_message = {0}; + binary_sensor_config_message.unique_id = 1; + binary_sensor_config_message.binary_sensor_device_class = (s_sensor_type == HAST_WINDOW) ? HABSDC_WINDOW : HABSDC_DOOR; + binary_sensor_config_message.payload_on = HAONOFT_OPEN; + binary_sensor_config_message.payload_off = HAONOFT_CLOSE; + binary_sensor_config_message.enabled_by_default = true; + binary_sensor_config_message.force_update = true; + binary_sensor_config_message.qos = 2; + binary_sensor_config_message.retain = true; zh_config_message_t config_message = {0}; - config_message = (zh_config_message_t)switch_config_message; + config_message = (zh_config_message_t)binary_sensor_config_message; zh_espnow_data_t data = {0}; - data.device_type = ZHDT_SWITCH; + data.device_type = ZHDT_BINARY_SENSOR; data.payload_type = ZHPT_CONFIG; data.payload_data = (zh_payload_data_t)config_message; zh_espnow_send(NULL, (uint8_t *)&data, sizeof(zh_espnow_data_t)); + binary_sensor_config_message.unique_id = 2; + binary_sensor_config_message.binary_sensor_device_class = HABSDC_BATTERY; + binary_sensor_config_message.payload_on = HAONOFT_LOW; + binary_sensor_config_message.payload_off = HAONOFT_HIGH; + config_message = (zh_config_message_t)binary_sensor_config_message; + data.payload_data = (zh_payload_data_t)config_message; + zh_espnow_send(NULL, (uint8_t *)&data, sizeof(zh_espnow_data_t)); } static void s_zh_send_sensor_status_message(void) { - zh_switch_status_message_t switch_status_message = {0}; + zh_binary_sensor_status_message_t binary_sensor_status_message = {0}; + binary_sensor_status_message.sensor_type = s_sensor_type; + binary_sensor_status_message.open = s_open_status; + binary_sensor_status_message.battery = s_battery_status; zh_status_message_t status_message = {0}; + status_message = (zh_status_message_t)binary_sensor_status_message; zh_espnow_data_t data = {0}; - data.device_type = ZHDT_SWITCH; + data.device_type = ZHDT_BINARY_SENSOR; data.payload_type = ZHPT_STATE; - switch_status_message.status = (s_relay_status == ON) ? HAONOFT_ON : HAONOFT_OFF; - status_message = (zh_status_message_t)switch_status_message; data.payload_data = (zh_payload_data_t)status_message; zh_espnow_send(NULL, (uint8_t *)&data, sizeof(zh_espnow_data_t)); } diff --git a/version.txt b/version.txt index 72f9fa8..afaf360 100644 --- a/version.txt +++ b/version.txt @@ -1 +1 @@ -0.2.4 \ No newline at end of file +1.0.0 \ No newline at end of file