Updated zh_vector

Updated zh_espnow
Updated zh_config
2024-05-30 08:44:36 +03:00 · 2024-05-30 08:43:41 +03:00 · 2024-05-30 08:41:47 +03:00 · 2024-05-29 14:44:38 +03:00 · 2024-05-29 14:14:14 +03:00 · 2024-05-29 14:10:21 +03:00
22 changed files with 298 additions and 350 deletions
--- a/components/zh_config/include/zh_config.h
+++ b/components/zh_config/include/zh_config.h
@@ -450,10 +450,10 @@ typedef struct // Structure for data exchange between ESP-NOW devices.
                ha_binary_sensor_device_class_t binary_sensor_device_class; // Binary sensor type supported by the Home Assistant. @note Used to prepare a correct configuration message for Home Assistant MQTT discovery. For details see https://www.home-assistant.io/integrations/binary_sensor.
                ha_on_off_type_t payload_on;                                // The payload that represents ON state.
                ha_on_off_type_t payload_off;                               // The payload that represents OFF state.
-                uint16_t expire_after;                                      // If set, it defines the number of seconds after the sensors state expires, if its not updated. After expiry, the sensors state becomes unavailable.
-                uint16_t off_delay;                                         // For sensors that only send on state updates (like PIRs), this variable sets a delay in seconds after which the sensors state will be updated back to off.
+                uint16_t expire_after;                                      // If set, it defines the number of seconds after the sensor’s state expires, if it’s not updated. After expiry, the sensor’s state becomes unavailable.
+                uint16_t off_delay;                                         // For sensors that only send on state updates (like PIRs), this variable sets a delay in seconds after which the sensor’s state will be updated back to off.
                bool enabled_by_default;                                    // Flag which defines if the entity should be enabled when first added.
-                bool force_update;                                          // Sends update events (which results in update of state objects last_changed) even if the sensors state hasnt changed. Useful if you want to have meaningful value graphs in history or want to create an automation that triggers on every incoming state message (not only when the sensors new state is different to the current one).
+                bool force_update;                                          // Sends update events (which results in update of state object’s last_changed) even if the sensor’s state hasn’t changed. Useful if you want to have meaningful value graphs in history or want to create an automation that triggers on every incoming state message (not only when the sensor’s new state is different to the current one).
                uint8_t qos;                                                // The maximum QoS level to be used when receiving and publishing messages.
                bool retain;                                                // If the published message should have the retain flag on or not.
            } binary_sensor_config_message;
@@ -462,10 +462,10 @@ typedef struct // Structure for data exchange between ESP-NOW devices.
                uint8_t unique_id;                            // An ID that uniquely identifies this sensor device. @note The ID will look like this - "MAC-X" (for example 64-B7-08-31-00-A8-1). @attention If two sensors have the same unique ID, Home Assistant will raise an exception.
                ha_sensor_device_class_t sensor_device_class; // Sensor type supported by the Home Assistant. @note Used to prepare a correct configuration message for Home Assistant MQTT discovery. For details see https://www.home-assistant.io/integrations/sensor.
                char unit_of_measurement[5];                  // Defines the units of measurement of the sensor, if any.
-                uint8_t suggested_display_precision;          // The number of decimals which should be used in the sensors state after rounding.
-                uint16_t expire_after;                        // If set, it defines the number of seconds after the sensors state expires, if its not updated. After expiry, the sensors state becomes unavailable.
+                uint8_t suggested_display_precision;          // The number of decimals which should be used in the sensor’s state after rounding.
+                uint16_t expire_after;                        // If set, it defines the number of seconds after the sensor’s state expires, if it’s not updated. After expiry, the sensor’s state becomes unavailable.
                bool enabled_by_default;                      // Flag which defines if the entity should be enabled when first added.
-                bool force_update;                            // Sends update events (which results in update of state objects last_changed) even if the sensors state hasnt changed. Useful if you want to have meaningful value graphs in history or want to create an automation that triggers on every incoming state message (not only when the sensors new state is different to the current one).
+                bool force_update;                            // Sends update events (which results in update of state object’s last_changed) even if the sensor’s state hasn’t changed. Useful if you want to have meaningful value graphs in history or want to create an automation that triggers on every incoming state message (not only when the sensor’s new state is different to the current one).
                uint8_t qos;                                  // The maximum QoS level to be used when receiving and publishing messages.
                bool retain;                                  // If the published message should have the retain flag on or not.
            } sensor_config_message;
@@ -571,8 +571,10 @@ typedef struct // Structure for data exchange between ESP-NOW devices.
        {
            struct // Tertiary structure for transfer from ESP-NOW node to ESP-NOW gateway system information for OTA update initialization.
            {
-                char app_name[32];    // Firmware application name.
-                char app_version[32]; // Firmware application version.
+                zh_device_type_t device_type; // ESP-NOW device type.
+                char app_name[32];            // Firmware application name.
+                char app_version[32];         // Firmware application version.
+                uint8_t mac_addr[6];          // ESP-NOW node MAC address.
            } espnow_ota_data;
            struct // Tertiary structure for transfer from ESP-NOW gateway to ESP-NOW node OTA update data.
            {
--- a/components/zh_dht/README.md
+++ b/components/zh_dht/README.md
@@ -13,7 +13,7 @@ In an existing project, run the following command to install the component:

 ```text
 cd ../your_project/components
-git clone https://github.com/aZholtikov/zh_dht.git
+git clone http://git.zh.com.ru/alexey.zholtikov/zh_dht.git
 ```

 In the application, add the component:
@@ -29,7 +29,7 @@ Reading the sensor:
 ```c
 #include "zh_dht.h"

-void app_main(void)
+void app_main()
 {
 	zh_dht_handle_t dht_handle = zh_dht_init(ZH_DHT22, GPIO_NUM_5);
 	float humidity;
--- a/components/zh_dht/include/zh_dht.h
+++ b/components/zh_dht/include/zh_dht.h
@@ -24,9 +24,9 @@ extern "C"
 	 */
 	typedef enum
 	{
-		ZH_DHT11, ///< Sensor type DHT11.
-		ZH_DHT22  ///< Sensor type DHT22 or AM2302.
-	} zh_dht_sensor_type_t;
+		ZH_DHT11, ///< Sensor type DHT11
+		ZH_DHT22  ///< Sensor type DHT22 or AM2302
+	} __attribute__((packed)) zh_dht_sensor_type_t;

 	/**
 	 * @brief Unique handle of the sensor.
@@ -34,33 +34,34 @@ extern "C"
 	 */
 	typedef struct
 	{
-		uint8_t sensor_pin;				  ///< Sensor GPIO connection. @note
-		zh_dht_sensor_type_t sensor_type; ///< Sensor type. @note
-	} zh_dht_handle_t;
+		uint8_t sensor_pin;				  ///< Sensor GPIO connection
+		zh_dht_sensor_type_t sensor_type; ///< Sensor type
+	} __attribute__((packed)) zh_dht_handle_t;

 	/**
-	 * @brief Initialize DHT sensor.
+	 * @brief      Initialize DHT sensor.
 	 *
-	 * @param[in] sensor_type Sensor type.
-	 * @param[in] sensor_pin Sensor connection gpio.
+	 * @param[in]  sensor_type  Sensor type (ZH_DHT11 or ZH_DHT22).
+	 * @param[in]  sensor_pin   Sensor connection gpio.
 	 *
-	 * @return Handle of the sensor
+	 * @return
+	 *              - Handle of the sensor.
 	 */
 	zh_dht_handle_t zh_dht_init(const zh_dht_sensor_type_t sensor_type, const uint8_t sensor_pin);

 	/**
-	 * @brief Read DHT sensor.
+	 * @brief      Read DHT sensor.
 	 *
-	 * @param[in] dht_handle Pointer for handle of the sensor.
-	 * @param[out] humidity Pointer for DHT sensor reading data of humidity.
-	 * @param[out] temperature Pointer for DHT sensor reading data of temperature.
+	 * @param[in]   dht_handle   Pointer for handle of the sensor.
+	 * @param[out]  humidity     Pointer for DHT sensor reading data of humidity.
+	 * @param[out]  temperature  Pointer for DHT sensor reading data of temperature.
 	 *
 	 * @return
-	 *              - ESP_OK if read was success
-	 *              - ESP_ERR_INVALID_ARG if parameter error
-	 *              - ESP_ERR_INVALID_RESPONSE if the bus is busy
-	 *              - ESP_ERR_TIMEOUT if operation timeout
-	 *              - ESP_ERR_INVALID_CRC if check CRC is fail
+	 *				- ESP_OK if read was success
+	 *				- ESP_ERR_INVALID_ARG if parameter error
+	 *				- ESP_ERR_INVALID_RESPONSE if the bus is busy
+	 *				- ESP_ERR_TIMEOUT if operation timeout
+	 *				- ESP_ERR_INVALID_CRC if check CRC is fail
 	 */
 	esp_err_t zh_dht_read(const zh_dht_handle_t *dht_handle, float *humidity, float *temperature);

--- a/components/zh_dht/version.txt
+++ b/components/zh_dht/version.txt
@@ -1 +1 @@
-1.0.0
+1.2.6
--- a/components/zh_dht/zh_dht.c
+++ b/components/zh_dht/zh_dht.c
@@ -1,7 +1,6 @@
 /**
 * @file
 * The main code of the zh_dht component.
- *
 */

 #include "zh_dht.h"
@@ -28,10 +27,10 @@ static esp_err_t _read_bit(const zh_dht_handle_t *dht_handle, bool *bit);
 zh_dht_handle_t zh_dht_init(const zh_dht_sensor_type_t sensor_type, const uint8_t sensor_pin)
 {
 	ESP_LOGI(TAG, "DHT initialization begin.");
-	zh_dht_handle_t zh_dht_handle = {
-		.sensor_type = sensor_type,
-		.sensor_pin = sensor_pin};
-	gpio_config_t config = {0};
+	zh_dht_handle_t zh_dht_handle;
+	zh_dht_handle.sensor_type = sensor_type;
+	zh_dht_handle.sensor_pin = sensor_pin;
+	gpio_config_t config;
 	config.intr_type = GPIO_INTR_DISABLE;
 	config.mode = GPIO_MODE_INPUT;
 	config.pin_bit_mask = (1ULL << sensor_pin);
--- a/components/zh_ds18b20/README.md
+++ b/components/zh_ds18b20/README.md
@@ -7,7 +7,7 @@

 ## Dependencies

-1. [zh_onewire](https://github.com/aZholtikov/zh_onewire.git)
+1. [zh_onewire](http://git.zh.com.ru/alexey.zholtikov/zh_onewire.git)

 ## [Function description](http://zh-ds18b20.zh.com.ru)

@@ -17,8 +17,8 @@ In an existing project, run the following command to install the components:

 ```text
 cd ../your_project/components
-git clone https://github.com/aZholtikov/zh_onewire.git
-git clone https://github.com/aZholtikov/zh_ds18b20.git
+git clone http://git.zh.com.ru/alexey.zholtikov/zh_onewire.git
+git clone http://git.zh.com.ru/alexey.zholtikov/zh_ds18b20.git
 ```

 In the application, add the component:
@@ -36,10 +36,8 @@ One or more 1-Wire DS18B20 sensors on bus:

 void app_main(void)
 {
-    esp_log_level_set("zh_onewire", ESP_LOG_NONE);
-    esp_log_level_set("zh_ds18b20", ESP_LOG_NONE);
-    uint8_t *rom = NULL;
-    float temperature = 0.0;
+    uint8_t *rom;
+    float temperature;
    zh_onewire_init(GPIO_NUM_5);
    if (zh_onewire_reset() != ESP_OK)
    {
--- a/components/zh_ds18b20/include/zh_ds18b20.h
+++ b/components/zh_ds18b20/include/zh_ds18b20.h
@@ -17,18 +17,18 @@ extern "C"
 #endif

    /**
-     * @brief Read temperature from a specific 1-Wire device on bus.
+     * @brief      Read temperature from a specific 1-Wire device on bus.
     *
-     * @param[in] device Pointer to a buffer containing an eight-byte rom value. Can be NULL if only one 1-Wire device is present on the bus.
+     * @param[in]  device        Pointer to a buffer containing an eight-byte rom value. Can be NULL if only one 1-Wire device is present on the bus.
     * 
-     * @param[out] temperature Pointer to a buffer containing the received temperature.
+     * @param[out]  temperature  Pointer to a buffer containing the received temperature.
     * 
-     * @attention 1-Wire bus must be initialized first. @code zh_onewire_init(GPIO_NUM_X) @endcode
+     * @attention   1-Wire bus must be initialized first. @code zh_onewire_init(GPIO_NUM_X) @endcode
     *
     * @return
     *              - ESP_OK if read was successful
     *              - ESP_FAIL if any error
-     *              - ESP_ERR_INVALID_CRC if check CRC is fail
+     *              - ESP_ERR_INVALID_CRC if case an read error
     */
    esp_err_t zh_ds18b20_read(const uint8_t *device, float *temperature);

--- a/components/zh_ds18b20/version.txt
+++ b/components/zh_ds18b20/version.txt
@@ -1 +1 @@
-1.0.0
+1.3.2
--- a/components/zh_ds18b20/zh_ds18b20.c
+++ b/components/zh_ds18b20/zh_ds18b20.c
@@ -1,7 +1,6 @@
 /**
 * @file
 * The main code of the zh_ds18b20 component.
- *
 */

 #include "zh_ds18b20.h"
--- a/components/zh_espnow/include/zh_espnow.h
+++ b/components/zh_espnow/include/zh_espnow.h
@@ -31,8 +31,7 @@
        .stack_size = 2048,             \
        .queue_size = 32,               \
        .wifi_interface = WIFI_IF_STA,  \
-        .wifi_channel = 1,              \
-        .attempts = 3                   \
+        .wifi_channel = 1               \
    }

 #ifdef __cplusplus
@@ -54,7 +53,6 @@ extern "C"
        uint8_t queue_size;              ///< Queue size for task for the ESP-NOW messages processing. @note The size depends on the number of messages to be processed. It is not recommended to set the value less than 16.
        wifi_interface_t wifi_interface; ///< WiFi interface (STA or AP) used for ESP-NOW operation. @note The MAC address of the device depends on the selected WiFi interface.
        uint8_t wifi_channel;            ///< Wi-Fi channel uses to send/receive ESP-NOW data. @note Values from 1 to 14.
-        uint8_t attempts;                ///< Maximum number of attempts to send a message. @note It is not recommended to set a value greater than 5.
    } zh_espnow_init_config_t;

    /// \cond
--- a/components/zh_espnow/version.txt
+++ b/components/zh_espnow/version.txt
@@ -1 +1 @@
-1.0.3
+1.0.0
--- a/components/zh_espnow/zh_espnow.c
+++ b/components/zh_espnow/zh_espnow.c
@@ -1,7 +1,7 @@
 /**
 * @file
 * The main code of the zh_espnow component.
- *
+ * 
 */

 #include "zh_espnow.h"
@@ -13,7 +13,7 @@
 /// \endcond

 static void _send_cb(const uint8_t *mac_addr, esp_now_send_status_t status);
-#if defined CONFIG_IDF_TARGET_ESP8266 || ESP_IDF_VERSION_MAJOR == 4
+#ifdef CONFIG_IDF_TARGET_ESP8266
 static void _recv_cb(const uint8_t *mac_addr, const uint8_t *data, int data_len);
 #else
 static void _recv_cb(const esp_now_recv_info_t *esp_now_info, const uint8_t *data, int data_len);
@@ -27,7 +27,6 @@ static QueueHandle_t _queue_handle = {0};
 static TaskHandle_t _processing_task_handle = {0};
 static zh_espnow_init_config_t _init_config = {0};
 static bool _is_initialized = false;
-static uint8_t _attempts = 0;

 /// \cond
 typedef struct
@@ -62,22 +61,11 @@ esp_err_t zh_espnow_init(const zh_espnow_init_config_t *config)
        ESP_LOGE(TAG, "ESP-NOW initialization fail. WiFi channel.");
        return ESP_ERR_INVALID_ARG;
    }
-    esp_err_t err = esp_wifi_set_channel(_init_config.wifi_channel, WIFI_SECOND_CHAN_NONE);
-    if (err == ESP_ERR_WIFI_NOT_INIT || err == ESP_ERR_WIFI_NOT_STARTED)
+    if (esp_wifi_set_channel(_init_config.wifi_channel, WIFI_SECOND_CHAN_NONE) != ESP_OK)
    {
        ESP_LOGE(TAG, "ESP-NOW initialization fail. WiFi not initialized.");
        return ESP_ERR_WIFI_NOT_INIT;
    }
-    else if (err == ESP_FAIL)
-    {
-        uint8_t prim = 0;
-        wifi_second_chan_t sec = 0;
-        esp_wifi_get_channel(&prim, &sec);
-        if (prim != _init_config.wifi_channel)
-        {
-            ESP_LOGW(TAG, "ESP-NOW initialization warning. The device is connected to the router. Channel %d will be used for ESP-NOW.", prim);
-        }
-    }
    _event_group_handle = xEventGroupCreate();
    _queue_handle = xQueueCreate(_init_config.queue_size, sizeof(_queue_t));
    if (esp_now_init() != ESP_OK || esp_now_register_send_cb(_send_cb) != ESP_OK || esp_now_register_recv_cb(_recv_cb) != ESP_OK)
@@ -176,7 +164,7 @@ esp_err_t zh_espnow_send(const uint8_t *target, const uint8_t *data, const uint8
    }
    if (xQueueSend(_queue_handle, &queue, portTICK_PERIOD_MS) != pdTRUE)
    {
-        ESP_LOGE(TAG, "ESP-NOW message processing task internal error at line %d.", __LINE__);
+        ESP_LOGE(TAG, "ESP-NOW message processing task internal error.");
        return ESP_FAIL;
    }
    return ESP_OK;
@@ -194,13 +182,13 @@ static void _send_cb(const uint8_t *mac_addr, esp_now_send_status_t status)
    }
 }

-#if defined CONFIG_IDF_TARGET_ESP8266 || ESP_IDF_VERSION_MAJOR == 4
+#ifdef CONFIG_IDF_TARGET_ESP8266
 static void _recv_cb(const uint8_t *mac_addr, const uint8_t *data, int data_len)
 #else
 static void _recv_cb(const esp_now_recv_info_t *esp_now_info, const uint8_t *data, int data_len)
 #endif
 {
-#if defined CONFIG_IDF_TARGET_ESP8266 || ESP_IDF_VERSION_MAJOR == 4
+#ifdef CONFIG_IDF_TARGET_ESP8266
    ESP_LOGI(TAG, "Adding incoming ESP-NOW data from MAC %02X:%02X:%02X:%02X:%02X:%02X to queue begin.", MAC2STR(mac_addr));
 #else
    ESP_LOGI(TAG, "Adding incoming ESP-NOW data from MAC %02X:%02X:%02X:%02X:%02X:%02X to queue begin.", MAC2STR(esp_now_info->src_addr));
@@ -212,7 +200,7 @@ static void _recv_cb(const esp_now_recv_info_t *esp_now_info, const uint8_t *dat
    }
    _queue_t queue = {0};
    queue.id = ON_RECV;
-#if defined CONFIG_IDF_TARGET_ESP8266 || ESP_IDF_VERSION_MAJOR == 4
+#ifdef CONFIG_IDF_TARGET_ESP8266
    memcpy(queue.data.mac_addr, mac_addr, 6);
 #else
    memcpy(queue.data.mac_addr, esp_now_info->src_addr, 6);
@@ -233,14 +221,14 @@ static void _recv_cb(const esp_now_recv_info_t *esp_now_info, const uint8_t *dat
    memset(queue.data.payload, 0, data_len);
    memcpy(queue.data.payload, data, data_len);
    queue.data.payload_len = data_len;
-#if defined CONFIG_IDF_TARGET_ESP8266 || ESP_IDF_VERSION_MAJOR == 4
+#ifdef CONFIG_IDF_TARGET_ESP8266
    ESP_LOGI(TAG, "Adding incoming ESP-NOW data from MAC %02X:%02X:%02X:%02X:%02X:%02X to queue success.", MAC2STR(mac_addr));
 #else
    ESP_LOGI(TAG, "Adding incoming ESP-NOW data from MAC %02X:%02X:%02X:%02X:%02X:%02X to queue success.", MAC2STR(esp_now_info->src_addr));
 #endif
    if (xQueueSend(_queue_handle, &queue, portTICK_PERIOD_MS) != pdTRUE)
    {
-        ESP_LOGE(TAG, "ESP-NOW message processing task internal error at line %d.", __LINE__);
+        ESP_LOGE(TAG, "ESP-NOW message processing task internal error.");
    }
 }

@@ -289,8 +277,6 @@ static void _processing(void *pvParameter)
            }
            memset(on_send, 0, sizeof(zh_espnow_event_on_send_t));
            memcpy(on_send->mac_addr, queue.data.mac_addr, 6);
-        SEND:
-            ++_attempts;
            err = esp_now_send(queue.data.mac_addr, queue.data.payload, queue.data.payload_len);
            if (err == ESP_ERR_ESPNOW_NO_MEM)
            {
@@ -319,22 +305,16 @@ static void _processing(void *pvParameter)
            {
                ESP_LOGI(TAG, "Confirmation message received. ESP-NOW message to MAC %02X:%02X:%02X:%02X:%02X:%02X sent success.", MAC2STR(queue.data.mac_addr));
                on_send->status = ZH_ESPNOW_SEND_SUCCESS;
-                _attempts = 0;
            }
            else
            {
-                if (_attempts < _init_config.attempts)
-                {
-                    goto SEND;
-                }
                ESP_LOGE(TAG, "Confirmation message not received. ESP-NOW message to MAC %02X:%02X:%02X:%02X:%02X:%02X sent fail.", MAC2STR(queue.data.mac_addr));
                on_send->status = ZH_ESPNOW_SEND_FAIL;
-                _attempts = 0;
            }
            ESP_LOGI(TAG, "Outgoing ESP-NOW data to MAC %02X:%02X:%02X:%02X:%02X:%02X processed success.", MAC2STR(queue.data.mac_addr));
            if (esp_event_post(ZH_ESPNOW, ZH_ESPNOW_ON_SEND_EVENT, on_send, sizeof(zh_espnow_event_on_send_t), portTICK_PERIOD_MS) != ESP_OK)
            {
-                ESP_LOGE(TAG, "ESP-NOW message processing task internal error at line %d.", __LINE__);
+                ESP_LOGE(TAG, "ESP-NOW message processing task internal error.");
            }
            heap_caps_free(queue.data.payload);
            esp_now_del_peer(peer->peer_addr);
@@ -347,7 +327,7 @@ static void _processing(void *pvParameter)
            ESP_LOGI(TAG, "Incoming ESP-NOW data from MAC %02X:%02X:%02X:%02X:%02X:%02X processed success.", MAC2STR(queue.data.mac_addr));
            if (esp_event_post(ZH_ESPNOW, ZH_ESPNOW_ON_RECV_EVENT, recv_data, recv_data->data_len + 7, portTICK_PERIOD_MS) != ESP_OK)
            {
-                ESP_LOGE(TAG, "ESP-NOW message processing task internal error at line %d.", __LINE__);
+                ESP_LOGE(TAG, "ESP-NOW message processing task internal error.");
            }
            break;
        default:
--- a/components/zh_network/README.md
+++ b/components/zh_network/README.md
@@ -21,8 +21,9 @@
 ## Attention

 1. The definition of ZH_NETWORK_MAX_MESSAGE_SIZE in the zh_network.h can be changed between 1 and 218. Smaller size - higher transmission speed. All devices on the network must have the same ZH_NETWORK_MAX_MESSAGE_SIZE.
-2. For correct work at ESP-NOW + STA mode your WiFi router must be set on channel 1.
-3. The ZHNetwork and the zh_network are incompatible.
+2. For correct operation in ESP-NOW + STA mode, your WiFi router must be set to the same channel as ESP-NOW.
+3. All devices on the network must have the same WiFi channel.
+4. The ZHNetwork and the zh_network are incompatible.

 ## Testing

@@ -84,7 +85,7 @@ typedef struct
 void app_main(void)
 {
    esp_log_level_set("zh_vector", ESP_LOG_NONE);
-    esp_log_level_set("zh_network", ESP_LOG_NONE);
+    // esp_log_level_set("zh_network", ESP_LOG_NONE);
    nvs_flash_init();
    esp_netif_init();
    esp_event_loop_create_default();
--- a/components/zh_network/include/zh_network.h
+++ b/components/zh_network/include/zh_network.h
@@ -35,6 +35,7 @@
 * @note Value range from 1 to 218. Smaller size - higher transmission speed.
 *
 * @attention All devices on the network must have the same ZH_NETWORK_MAX_MESSAGE_SIZE.
+ *
 */
 #define ZH_NETWORK_MAX_MESSAGE_SIZE 218

@@ -51,7 +52,8 @@
        .max_waiting_time = 1000,        \
        .id_vector_size = 100,           \
        .route_vector_size = 100,        \
-        .wifi_interface = WIFI_IF_STA    \
+        .wifi_interface = WIFI_IF_STA,   \
+        .wifi_channel = 1                \
    }

 #ifdef __cplusplus
@@ -64,7 +66,9 @@ extern "C"
     *
     * @note Before initialize ESP-NOW interface recommend initialize zh_network_init_config_t structure with default values.
     *
-     * @code zh_network_init_config_t config = ZH_NETWORK_INIT_CONFIG_DEFAULT() @endcode
+     * @code
+     *       zh_network_init_config_t config = ZH_NETWORK_INIT_CONFIG_DEFAULT()
+     * @endcode
     */
    typedef struct
    {
@@ -76,7 +80,8 @@ extern "C"
        uint16_t id_vector_size;         ///< Maximum size of unique ID of received messages. @note If the size is exceeded, the first value will be deleted. Minimum recommended value: number of planned nodes in the network + 10%.
        uint16_t route_vector_size;      ///< The maximum size of the routing table. @note If the size is exceeded, the first route will be deleted. Minimum recommended value: number of planned nodes in the network + 10%.
        wifi_interface_t wifi_interface; ///< WiFi interface (STA or AP) used for ESP-NOW operation. @note The MAC address of the device depends on the selected WiFi interface.
-    } zh_network_init_config_t;
+        uint8_t wifi_channel;            ///< Wi-Fi channel uses to send/receive ESPNOW data. @note Values from 1 to 14.
+    } __attribute__((packed)) zh_network_init_config_t;

    /// \cond
    ESP_EVENT_DECLARE_BASE(ESP_EVENT_BASE);
@@ -90,7 +95,7 @@ extern "C"
    {
        ZH_NETWORK_ON_RECV_EVENT, ///< The event when the ESP-NOW message was received.
        ZH_NETWORK_ON_SEND_EVENT  ///< The event when the ESP-NOW message was sent.
-    } zh_network_event_type_t;
+    } __attribute__((packed)) zh_network_event_type_t;

    /**
     * @brief Enumeration of possible status of sent ESP-NOW message.
@@ -100,18 +105,19 @@ extern "C"
    {
        ZH_NETWORK_SEND_SUCCESS, ///< If ESP-NOW message was sent success.
        ZH_NETWORK_SEND_FAIL     ///< If ESP-NOW message was sent fail.
-    } zh_network_on_send_event_type_t;
+    } __attribute__((packed)) zh_network_on_send_event_type_t;

    /**
     * @brief Structure for sending data to the event handler when an ESP-NOW message was sent.
     *
     * @note Should be used with ZH_NETWORK event base and ZH_NETWORK_ON_SEND_EVENT event.
+     *
     */
    typedef struct
    {
        uint8_t mac_addr[6];                    ///< MAC address of the device to which the ESP-NOW message was sent. @note
        zh_network_on_send_event_type_t status; ///< Status of sent ESP-NOW message. @note
-    } zh_network_event_on_send_t;
+    } __attribute__((packed)) zh_network_event_on_send_t;

    /**
     * @brief Structure for sending data to the event handler when an ESP-NOW message was received.
@@ -123,16 +129,18 @@ extern "C"
        uint8_t mac_addr[6]; ///< MAC address of the sender ESP-NOW message. @note
        uint8_t *data;       ///< Pointer to the data of the received ESP-NOW message. @note
        uint8_t data_len;    ///< Size of the received ESP-NOW message. @note
-    } zh_network_event_on_recv_t;
+    } __attribute__((packed)) zh_network_event_on_recv_t;

    /**
-     * @brief Initialize ESP-NOW interface.
+     * @brief      Initialize ESP-NOW interface.
     *
-     * @note Before initialize ESP-NOW interface recommend initialize zh_network_init_config_t structure with default values.
+     * @note       Before initialize ESP-NOW interface recommend initialize zh_network_init_config_t structure with default values.
     *
-     * @code zh_network_init_config_t config = ZH_NETWORK_INIT_CONFIG_DEFAULT() @endcode
+     * @code
+     *             zh_network_init_config_t config = ZH_NETWORK_INIT_CONFIG_DEFAULT()
+     * @endcode
     *
-     * @param[in] config Pointer to ESP-NOW initialized configuration structure. Can point to a temporary variable.
+     * @param[in]  config  Pointer to ESP-NOW initialized configuration structure. Can point to a temporary variable.
     *
     * @return
     *              - ESP_OK if initialization was success
@@ -140,10 +148,10 @@ extern "C"
     *              - ESP_ERR_WIFI_NOT_INIT if WiFi is not initialized
     *              - ESP_FAIL if any internal error
     */
-    esp_err_t zh_network_init(zh_network_init_config_t *config);
+    esp_err_t zh_network_init(const zh_network_init_config_t *config);

    /**
-     * @brief Deinitialize ESP-NOW interface.
+     * @brief      Deinitialize ESP-NOW interface.
     *
     * @return
     *              - ESP_OK if deinitialization was success
@@ -152,11 +160,11 @@ extern "C"
    esp_err_t zh_network_deinit(void);

    /**
-     * @brief Send ESP-NOW data.
+     * @brief      Send ESP-NOW data.
     *
-     * @param[in] target Pointer to a buffer containing an eight-byte target MAC. Can be NULL for broadcast.
-     * @param[in] data Pointer to a buffer containing the data for send.
-     * @param[in] data_len Sending data length.
+     * @param[in]  target    Pointer to a buffer containing an eight-byte target MAC. Can be NULL for broadcast.
+     * @param[in]  data      Pointer to a buffer containing the data for send.
+     * @param[in]  data_len  Sending data length.
     *
     * @note The function will return an ESP_ERR_INVALID_STATE error if less than 50% of the size set at initialization remains in the message queue.
     *
@@ -164,7 +172,7 @@ extern "C"
     *              - ESP_OK if sent was success
     *              - ESP_ERR_INVALID_ARG if parameter error
     *              - ESP_ERR_INVALID_STATE if queue for outgoing data is almost full
-     *              - ESP_FAIL if ESP-NOW is not initialized
+     *              - ESP_FAIL if ESP-NOW is not initialized or any internal error
     */
    esp_err_t zh_network_send(const uint8_t *target, const uint8_t *data, const uint8_t data_len);

--- a/components/zh_network/version.txt
+++ b/components/zh_network/version.txt
@@ -1 +1 @@
-1.0.0
+1.4.4
--- a/components/zh_network/zh_network.c
+++ b/components/zh_network/zh_network.c
@@ -21,7 +21,7 @@ static void _processing(void *pvParameter);

 static const char *TAG = "zh_network";

-static EventGroupHandle_t _send_cb_status_event_group_handle = {0};
+static EventGroupHandle_t _event_group_handle = {0};
 static QueueHandle_t _queue_handle = {0};
 static TaskHandle_t _processing_task_handle = {0};
 static SemaphoreHandle_t _id_vector_mutex = {0};
@@ -34,53 +34,47 @@ static const uint8_t _broadcast_mac[6] = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF};
 static bool _is_initialized = false;

 /// \cond
-typedef enum
-{
-    BROADCAST,
-    UNICAST,
-    DELIVERY_CONFIRM,
-    SEARCH_REQUEST,
-    SEARCH_RESPONSE
-} message_type_t;
-
-typedef struct
-{
-    message_type_t message_type;
-    uint32_t network_id;
-    uint32_t message_id;
-    uint32_t confirm_id;
-    uint8_t original_target_mac[6];
-    uint8_t original_sender_mac[6];
-    uint8_t sender_mac[6];
-    uint8_t data[ZH_NETWORK_MAX_MESSAGE_SIZE];
-    uint8_t data_len;
-} data_t;
-
 typedef struct
 {
    uint8_t original_target_mac[6];
    uint8_t intermediate_target_mac[6];
-} routing_table_t;
-
-typedef enum
-{
-    TO_SEND,
-    ON_RECV,
-    WAIT_ROUTE,
-    WAIT_RESPONSE,
-} queue_id_t;
+} __attribute__((packed)) _routing_table_t;

 typedef struct
 {
-    queue_id_t id;
    uint64_t time;
-    data_t data;
-} queue_t;
+    enum
+    {
+        TO_SEND,
+        ON_RECV,
+        WAIT_ROUTE,
+        WAIT_RESPONSE,
+    } id;
+    struct
+    {
+        enum
+        {
+            BROADCAST,
+            UNICAST,
+            DELIVERY_CONFIRM,
+            SEARCH_REQUEST,
+            SEARCH_RESPONSE
+        } message_type;
+        uint32_t network_id;
+        uint32_t message_id;
+        uint32_t confirm_id;
+        uint8_t original_target_mac[6];
+        uint8_t original_sender_mac[6];
+        uint8_t sender_mac[6];
+        uint8_t payload[ZH_NETWORK_MAX_MESSAGE_SIZE];
+        uint8_t payload_len;
+    } data;
+} __attribute__((packed)) _queue_t;

 ESP_EVENT_DEFINE_BASE(ZH_NETWORK);
 /// \endcond

-esp_err_t zh_network_init(zh_network_init_config_t *config)
+esp_err_t zh_network_init(const zh_network_init_config_t *config)
 {
    ESP_LOGI(TAG, "ESP-NOW initialization begin.");
    if (config == NULL)
@@ -88,12 +82,18 @@ esp_err_t zh_network_init(zh_network_init_config_t *config)
        ESP_LOGE(TAG, "ESP-NOW initialization fail. Invalid argument.");
        return ESP_ERR_INVALID_ARG;
    }
-    if (esp_wifi_set_channel(1, WIFI_SECOND_CHAN_NONE) == ESP_ERR_WIFI_NOT_INIT)
+    _init_config = *config;
+    if (_init_config.wifi_channel < 1 || _init_config.wifi_channel > 14)
+    {
+        ESP_LOGE(TAG, "ESP-NOW initialization fail. WiFi channel.");
+        return ESP_ERR_INVALID_ARG;
+    }
+    if (esp_wifi_set_channel(_init_config.wifi_channel, WIFI_SECOND_CHAN_NONE) == ESP_ERR_WIFI_NOT_INIT)
    {
        ESP_LOGE(TAG, "ESP-NOW initialization fail. WiFi not initialized.");
        return ESP_ERR_WIFI_NOT_INIT;
    }
-    if (sizeof(data_t) > ESP_NOW_MAX_DATA_LEN)
+    if ((sizeof(_queue_t) - 12) > ESP_NOW_MAX_DATA_LEN)
    {
        ESP_LOGE(TAG, "ESP-NOW initialization fail. The maximum value of the transmitted data size is incorrect.");
        return ESP_ERR_INVALID_ARG;
@@ -106,11 +106,10 @@ esp_err_t zh_network_init(zh_network_init_config_t *config)
    {
        esp_read_mac(_self_mac, ESP_MAC_WIFI_SOFTAP);
    }
-    _init_config = *config;
-    _send_cb_status_event_group_handle = xEventGroupCreate();
-    _queue_handle = xQueueCreate(_init_config.queue_size, sizeof(queue_t));
+    _event_group_handle = xEventGroupCreate();
+    _queue_handle = xQueueCreate(_init_config.queue_size, sizeof(_queue_t));
    zh_vector_init(&_id_vector, sizeof(uint32_t), false);
-    zh_vector_init(&_route_vector, sizeof(routing_table_t), false);
+    zh_vector_init(&_route_vector, sizeof(_routing_table_t), false);
    zh_vector_init(&_response_vector, sizeof(uint32_t), false);
    _id_vector_mutex = xSemaphoreCreateMutex();
    if (esp_now_init() != ESP_OK || esp_now_register_send_cb(_send_cb) != ESP_OK || esp_now_register_recv_cb(_recv_cb) != ESP_OK)
@@ -136,7 +135,7 @@ esp_err_t zh_network_deinit(void)
        ESP_LOGE(TAG, "ESP-NOW deinitialization fail. ESP-NOW not initialized.");
        return ESP_FAIL;
    }
-    vEventGroupDelete(_send_cb_status_event_group_handle);
+    vEventGroupDelete(_event_group_handle);
    vQueueDelete(_queue_handle);
    esp_now_unregister_send_cb();
    esp_now_unregister_recv_cb();
@@ -175,32 +174,31 @@ esp_err_t zh_network_send(const uint8_t *target, const uint8_t *data, const uint
        ESP_LOGW(TAG, "Adding outgoing ESP-NOW data to queue fail. Queue is almost full.");
        return ESP_ERR_INVALID_STATE;
    }
-    queue_t queue = {0};
+    _queue_t queue = {0};
    queue.id = TO_SEND;
-    data_t *send_data = &queue.data;
-    send_data->network_id = _init_config.network_id;
-    send_data->message_id = abs(esp_random()); // It is not clear why esp_random() sometimes gives negative values.
-    memcpy(send_data->original_sender_mac, &_self_mac, 6);
+    queue.data.network_id = _init_config.network_id;
+    queue.data.message_id = abs(esp_random()); // It is not clear why esp_random() sometimes gives negative values.
+    memcpy(queue.data.original_sender_mac, _self_mac, 6);
    if (target == NULL)
    {
-        send_data->message_type = BROADCAST;
-        memcpy(send_data->original_target_mac, &_broadcast_mac, 6);
+        queue.data.message_type = BROADCAST;
+        memcpy(queue.data.original_target_mac, _broadcast_mac, 6);
    }
    else
    {
-        if (memcmp(target, &_broadcast_mac, 6) != 0)
+        if (memcmp(target, _broadcast_mac, 6) != 0)
        {
-            send_data->message_type = UNICAST;
-            memcpy(send_data->original_target_mac, target, 6);
+            queue.data.message_type = UNICAST;
+            memcpy(queue.data.original_target_mac, target, 6);
        }
        else
        {
-            send_data->message_type = BROADCAST;
-            memcpy(send_data->original_target_mac, &_broadcast_mac, 6);
+            queue.data.message_type = BROADCAST;
+            memcpy(queue.data.original_target_mac, _broadcast_mac, 6);
        }
    }
-    memcpy(&send_data->data, data, data_len);
-    send_data->data_len = data_len;
+    memcpy(queue.data.payload, data, data_len);
+    queue.data.payload_len = data_len;
    if (target == NULL)
    {
        ESP_LOGI(TAG, "Adding outgoing ESP-NOW data to MAC FF:FF:FF:FF:FF:FF to queue success.");
@@ -212,6 +210,7 @@ esp_err_t zh_network_send(const uint8_t *target, const uint8_t *data, const uint
    if (xQueueSend(_queue_handle, &queue, portTICK_PERIOD_MS) != pdTRUE)
    {
        ESP_LOGE(TAG, "ESP-NOW message processing task internal error.");
+        return ESP_FAIL;
    }
    return ESP_OK;
 }
@@ -220,11 +219,11 @@ static void _send_cb(const uint8_t *mac_addr, esp_now_send_status_t status)
 {
    if (status == ESP_NOW_SEND_SUCCESS)
    {
-        xEventGroupSetBits(_send_cb_status_event_group_handle, DATA_SEND_SUCCESS);
+        xEventGroupSetBits(_event_group_handle, DATA_SEND_SUCCESS);
    }
    else
    {
-        xEventGroupSetBits(_send_cb_status_event_group_handle, DATA_SEND_FAIL);
+        xEventGroupSetBits(_event_group_handle, DATA_SEND_FAIL);
    }
 }

@@ -244,10 +243,12 @@ static void _recv_cb(const esp_now_recv_info_t *esp_now_info, const uint8_t *dat
        ESP_LOGW(TAG, "Adding incoming ESP-NOW data to queue fail. Queue is almost full.");
        return;
    }
-    if (data_len == sizeof(data_t))
+    if (data_len == sizeof(_queue_t) - 12)
    {
-        data_t *recv_data = (data_t *)data;
-        if (memcmp(&recv_data->network_id, &_init_config.network_id, sizeof(recv_data->network_id)) != 0)
+        _queue_t queue = {0};
+        queue.id = ON_RECV;
+        memcpy(&queue.data, data, data_len);
+        if (memcmp(&queue.data.network_id, &_init_config.network_id, sizeof(queue.data.network_id)) != 0)
        {
            ESP_LOGW(TAG, "Adding incoming ESP-NOW data to queue fail. Incorrect mesh network ID.");
            return;
@@ -255,7 +256,7 @@ static void _recv_cb(const esp_now_recv_info_t *esp_now_info, const uint8_t *dat
        for (uint16_t i = 0; i < zh_vector_get_size(&_id_vector); ++i)
        {
            uint32_t *message_id = zh_vector_get_item(&_id_vector, i);
-            if (memcmp(&recv_data->message_id, message_id, sizeof(recv_data->message_id)) == 0)
+            if (memcmp(&queue.data.message_id, message_id, sizeof(queue.data.message_id)) == 0)
            {
                ESP_LOGW(TAG, "Adding incoming ESP-NOW data to queue fail. Repeat message received.");
                return;
@@ -263,21 +264,17 @@ static void _recv_cb(const esp_now_recv_info_t *esp_now_info, const uint8_t *dat
        }
        if (xSemaphoreTake(_id_vector_mutex, portTICK_PERIOD_MS) == pdTRUE)
        {
-            zh_vector_push_back(&_id_vector, &recv_data->message_id);
+            zh_vector_push_back(&_id_vector, &queue.data.message_id);
            if (zh_vector_get_size(&_id_vector) > _init_config.id_vector_size)
            {
                zh_vector_delete_item(&_id_vector, 0);
            }
            xSemaphoreGive(_id_vector_mutex);
        }
-        queue_t queue = {0};
-        queue.id = ON_RECV;
-        recv_data = &queue.data;
-        memcpy(recv_data, data, data_len);
 #ifdef CONFIG_IDF_TARGET_ESP8266
-        memcpy(recv_data->sender_mac, mac_addr, 6);
+        memcpy(queue.data.sender_mac, mac_addr, 6);
 #else
-        memcpy(recv_data->sender_mac, esp_now_info->src_addr, 6);
+        memcpy(queue.data.sender_mac, esp_now_info->src_addr, 6);
 #endif
 #ifdef CONFIG_IDF_TARGET_ESP8266
        ESP_LOGI(TAG, "Adding incoming ESP-NOW data from MAC %02X:%02X:%02X:%02X:%02X:%02X to queue success.", MAC2STR(mac_addr));
@@ -297,11 +294,10 @@ static void _recv_cb(const esp_now_recv_info_t *esp_now_info, const uint8_t *dat

 static void _processing(void *pvParameter)
 {
-    queue_t queue = {0};
+    _queue_t queue = {0};
    while (xQueueReceive(_queue_handle, &queue, portMAX_DELAY) == pdTRUE)
    {
        bool flag = false;
-        data_t *data = &queue.data;
        switch (queue.id)
        {
        case TO_SEND:
@@ -315,14 +311,14 @@ static void _processing(void *pvParameter)
            }
            memset(peer, 0, sizeof(esp_now_peer_info_t));
            peer->ifidx = _init_config.wifi_interface;
-            if (data->message_type == BROADCAST || data->message_type == SEARCH_REQUEST || data->message_type == SEARCH_RESPONSE)
+            if (queue.data.message_type == BROADCAST || queue.data.message_type == SEARCH_REQUEST || queue.data.message_type == SEARCH_RESPONSE)
            {
-                memcpy(peer->peer_addr, &_broadcast_mac, 6);
-                if (memcmp(data->original_sender_mac, &_self_mac, 6) == 0)
+                memcpy(peer->peer_addr, _broadcast_mac, 6);
+                if (memcmp(queue.data.original_sender_mac, _self_mac, 6) == 0)
                {
                    if (xSemaphoreTake(_id_vector_mutex, portTICK_PERIOD_MS) == pdTRUE)
                    {
-                        zh_vector_push_back(&_id_vector, &data->message_id);
+                        zh_vector_push_back(&_id_vector, &queue.data.message_id);
                        if (zh_vector_get_size(&_id_vector) > _init_config.id_vector_size)
                        {
                            zh_vector_delete_item(&_id_vector, 0);
@@ -336,8 +332,8 @@ static void _processing(void *pvParameter)
                ESP_LOGI(TAG, "Checking routing table to MAC %02X:%02X:%02X:%02X:%02X:%02X.", MAC2STR(queue.data.original_target_mac));
                for (uint16_t i = 0; i < zh_vector_get_size(&_route_vector); ++i)
                {
-                    routing_table_t *routing_table = zh_vector_get_item(&_route_vector, i);
-                    if (memcmp(data->original_target_mac, routing_table->original_target_mac, 6) == 0)
+                    _routing_table_t *routing_table = zh_vector_get_item(&_route_vector, i);
+                    if (memcmp(queue.data.original_target_mac, routing_table->original_target_mac, 6) == 0)
                    {
                        memcpy(peer->peer_addr, routing_table->intermediate_target_mac, 6);
                        flag = true;
@@ -348,7 +344,7 @@ static void _processing(void *pvParameter)
                if (flag == false)
                {
                    ESP_LOGI(TAG, "Routing to MAC %02X:%02X:%02X:%02X:%02X:%02X not found.", MAC2STR(queue.data.original_target_mac));
-                    if (data->message_type == UNICAST)
+                    if (queue.data.message_type == UNICAST)
                    {
                        ESP_LOGI(TAG, "Unicast message from MAC %02X:%02X:%02X:%02X:%02X:%02X to MAC %02X:%02X:%02X:%02X:%02X:%02X transferred to routing waiting list.", MAC2STR(queue.data.original_sender_mac), MAC2STR(queue.data.original_target_mac));
                    }
@@ -364,11 +360,11 @@ static void _processing(void *pvParameter)
                    }
                    ESP_LOGI(TAG, "System message for routing request from MAC %02X:%02X:%02X:%02X:%02X:%02X to MAC %02X:%02X:%02X:%02X:%02X:%02X added to queue.", MAC2STR(queue.data.original_sender_mac), MAC2STR(queue.data.original_target_mac));
                    queue.id = TO_SEND;
-                    data->message_type = SEARCH_REQUEST;
-                    memcpy(data->original_sender_mac, &_self_mac, 6);
-                    data->data_len = 0;
-                    memset(data->data, 0, ZH_NETWORK_MAX_MESSAGE_SIZE);
-                    data->message_id = abs(esp_random()); // It is not clear why esp_random() sometimes gives negative values.
+                    queue.data.message_type = SEARCH_REQUEST;
+                    memcpy(queue.data.original_sender_mac, _self_mac, 6);
+                    queue.data.payload_len = 0;
+                    memset(queue.data.payload, 0, ZH_NETWORK_MAX_MESSAGE_SIZE);
+                    queue.data.message_id = abs(esp_random()); // It is not clear why esp_random() sometimes gives negative values.
                    ESP_LOGI(TAG, "Outgoing ESP-NOW data from MAC %02X:%02X:%02X:%02X:%02X:%02X to MAC %02X:%02X:%02X:%02X:%02X:%02X processed success.", MAC2STR(queue.data.original_sender_mac), MAC2STR(queue.data.original_target_mac));
                    if (xQueueSendToFront(_queue_handle, &queue, portTICK_PERIOD_MS) != pdTRUE)
                    {
@@ -393,20 +389,20 @@ static void _processing(void *pvParameter)
                break;
            }
            memset(on_send, 0, sizeof(zh_network_event_on_send_t));
-            memcpy(on_send->mac_addr, data->original_target_mac, 6);
-            if (esp_now_send((uint8_t *)peer->peer_addr, (uint8_t *)data, sizeof(data_t)) != ESP_OK)
+            memcpy(on_send->mac_addr, queue.data.original_target_mac, 6);
+            if (esp_now_send((uint8_t *)peer->peer_addr, (uint8_t *)&queue.data, sizeof(_queue_t) - 12) != ESP_OK)
            {
                ESP_LOGE(TAG, "ESP-NOW message processing task internal error.");
                heap_caps_free(peer);
                heap_caps_free(on_send);
                break;
            }
-            EventBits_t bit = xEventGroupWaitBits(_send_cb_status_event_group_handle, DATA_SEND_SUCCESS | DATA_SEND_FAIL, pdTRUE, pdFALSE, 50 / portTICK_PERIOD_MS);
+            EventBits_t bit = xEventGroupWaitBits(_event_group_handle, DATA_SEND_SUCCESS | DATA_SEND_FAIL, pdTRUE, pdFALSE, 50 / portTICK_PERIOD_MS);
            if ((bit & DATA_SEND_SUCCESS) != 0)
            {
-                if (memcmp(data->original_sender_mac, &_self_mac, 6) == 0)
+                if (memcmp(queue.data.original_sender_mac, _self_mac, 6) == 0)
                {
-                    if (data->message_type == BROADCAST)
+                    if (queue.data.message_type == BROADCAST)
                    {
                        ESP_LOGI(TAG, "Broadcast message from MAC %02X:%02X:%02X:%02X:%02X:%02X to MAC %02X:%02X:%02X:%02X:%02X:%02X sent success.", MAC2STR(queue.data.original_sender_mac), MAC2STR(queue.data.original_target_mac));
                        on_send->status = ZH_NETWORK_SEND_SUCCESS;
@@ -416,22 +412,22 @@ static void _processing(void *pvParameter)
                            ESP_LOGE(TAG, "ESP-NOW message processing task internal error.");
                        }
                    }
-                    if (data->message_type == SEARCH_REQUEST)
+                    if (queue.data.message_type == SEARCH_REQUEST)
                    {
                        ESP_LOGI(TAG, "System message for routing request from MAC %02X:%02X:%02X:%02X:%02X:%02X to MAC %02X:%02X:%02X:%02X:%02X:%02X sent success.", MAC2STR(queue.data.original_sender_mac), MAC2STR(queue.data.original_target_mac));
                        ESP_LOGI(TAG, "Outgoing ESP-NOW data from MAC %02X:%02X:%02X:%02X:%02X:%02X to MAC %02X:%02X:%02X:%02X:%02X:%02X processed success.", MAC2STR(queue.data.original_sender_mac), MAC2STR(queue.data.original_target_mac));
                    }
-                    if (data->message_type == SEARCH_RESPONSE)
+                    if (queue.data.message_type == SEARCH_RESPONSE)
                    {
                        ESP_LOGI(TAG, "System message for routing response from MAC %02X:%02X:%02X:%02X:%02X:%02X to MAC %02X:%02X:%02X:%02X:%02X:%02X sent success.", MAC2STR(queue.data.original_sender_mac), MAC2STR(queue.data.original_target_mac));
                        ESP_LOGI(TAG, "Outgoing ESP-NOW data from MAC %02X:%02X:%02X:%02X:%02X:%02X to MAC %02X:%02X:%02X:%02X:%02X:%02X processed success.", MAC2STR(queue.data.original_sender_mac), MAC2STR(queue.data.original_target_mac));
                    }
-                    if (data->message_type == DELIVERY_CONFIRM)
+                    if (queue.data.message_type == DELIVERY_CONFIRM)
                    {
                        ESP_LOGI(TAG, "System message for message receiving confirmation from MAC %02X:%02X:%02X:%02X:%02X:%02X to MAC %02X:%02X:%02X:%02X:%02X:%02X via MAC %02X:%02X:%02X:%02X:%02X:%02X sent success.", MAC2STR(queue.data.original_sender_mac), MAC2STR(queue.data.original_target_mac), MAC2STR(peer->peer_addr));
                        ESP_LOGI(TAG, "Outgoing ESP-NOW data from MAC %02X:%02X:%02X:%02X:%02X:%02X to MAC %02X:%02X:%02X:%02X:%02X:%02X processed success.", MAC2STR(queue.data.original_sender_mac), MAC2STR(queue.data.original_target_mac));
                    }
-                    if (data->message_type == UNICAST)
+                    if (queue.data.message_type == UNICAST)
                    {
                        ESP_LOGI(TAG, "Unicast message from MAC %02X:%02X:%02X:%02X:%02X:%02X to MAC %02X:%02X:%02X:%02X:%02X:%02X via MAC %02X:%02X:%02X:%02X:%02X:%02X sent success.", MAC2STR(queue.data.original_sender_mac), MAC2STR(queue.data.original_target_mac), MAC2STR(peer->peer_addr));
                        ESP_LOGI(TAG, "Unicast message from MAC %02X:%02X:%02X:%02X:%02X:%02X to MAC %02X:%02X:%02X:%02X:%02X:%02X transferred to confirmation message waiting list.", MAC2STR(queue.data.original_sender_mac), MAC2STR(queue.data.original_target_mac));
@@ -446,27 +442,27 @@ static void _processing(void *pvParameter)
                }
                else
                {
-                    if (data->message_type == BROADCAST)
+                    if (queue.data.message_type == BROADCAST)
                    {
                        ESP_LOGI(TAG, "Broadcast message from MAC %02X:%02X:%02X:%02X:%02X:%02X to MAC %02X:%02X:%02X:%02X:%02X:%02X sent success.", MAC2STR(queue.data.original_sender_mac), MAC2STR(queue.data.original_target_mac));
                        ESP_LOGI(TAG, "Outgoing ESP-NOW data from MAC %02X:%02X:%02X:%02X:%02X:%02X to MAC %02X:%02X:%02X:%02X:%02X:%02X processed success.", MAC2STR(queue.data.original_sender_mac), MAC2STR(queue.data.original_target_mac));
                    }
-                    if (data->message_type == SEARCH_REQUEST)
+                    if (queue.data.message_type == SEARCH_REQUEST)
                    {
                        ESP_LOGI(TAG, "System message for routing request from MAC %02X:%02X:%02X:%02X:%02X:%02X to MAC %02X:%02X:%02X:%02X:%02X:%02X sent success.", MAC2STR(queue.data.original_sender_mac), MAC2STR(queue.data.original_target_mac));
                        ESP_LOGI(TAG, "Outgoing ESP-NOW data from MAC %02X:%02X:%02X:%02X:%02X:%02X to MAC %02X:%02X:%02X:%02X:%02X:%02X processed success.", MAC2STR(queue.data.original_sender_mac), MAC2STR(queue.data.original_target_mac));
                    }
-                    if (data->message_type == SEARCH_RESPONSE)
+                    if (queue.data.message_type == SEARCH_RESPONSE)
                    {
                        ESP_LOGI(TAG, "System message for routing response from MAC %02X:%02X:%02X:%02X:%02X:%02X to MAC %02X:%02X:%02X:%02X:%02X:%02X sent success.", MAC2STR(queue.data.original_sender_mac), MAC2STR(queue.data.original_target_mac));
                        ESP_LOGI(TAG, "Outgoing ESP-NOW data from MAC %02X:%02X:%02X:%02X:%02X:%02X to MAC %02X:%02X:%02X:%02X:%02X:%02X processed success.", MAC2STR(queue.data.original_sender_mac), MAC2STR(queue.data.original_target_mac));
                    }
-                    if (data->message_type == DELIVERY_CONFIRM)
+                    if (queue.data.message_type == DELIVERY_CONFIRM)
                    {
                        ESP_LOGI(TAG, "System message for message receiving confirmation from MAC %02X:%02X:%02X:%02X:%02X:%02X to MAC %02X:%02X:%02X:%02X:%02X:%02X via MAC %02X:%02X:%02X:%02X:%02X:%02X sent success.", MAC2STR(queue.data.original_sender_mac), MAC2STR(queue.data.original_target_mac), MAC2STR(peer->peer_addr));
                        ESP_LOGI(TAG, "Outgoing ESP-NOW data from MAC %02X:%02X:%02X:%02X:%02X:%02X to MAC %02X:%02X:%02X:%02X:%02X:%02X processed success.", MAC2STR(queue.data.original_sender_mac), MAC2STR(queue.data.original_target_mac));
                    }
-                    if (data->message_type == UNICAST)
+                    if (queue.data.message_type == UNICAST)
                    {
                        ESP_LOGI(TAG, "Unicast message from MAC %02X:%02X:%02X:%02X:%02X:%02X to MAC %02X:%02X:%02X:%02X:%02X:%02X via MAC %02X:%02X:%02X:%02X:%02X:%02X sent success.", MAC2STR(queue.data.original_sender_mac), MAC2STR(queue.data.original_target_mac), MAC2STR(peer->peer_addr));
                        ESP_LOGI(TAG, "Outgoing ESP-NOW data from MAC %02X:%02X:%02X:%02X:%02X:%02X to MAC %02X:%02X:%02X:%02X:%02X:%02X processed success.", MAC2STR(queue.data.original_sender_mac), MAC2STR(queue.data.original_target_mac));
@@ -475,22 +471,22 @@ static void _processing(void *pvParameter)
            }
            else
            {
-                if (memcmp(data->original_target_mac, &_broadcast_mac, 6) != 0)
+                if (memcmp(queue.data.original_target_mac, _broadcast_mac, 6) != 0)
                {
                    ESP_LOGI(TAG, "Routing to MAC %02X:%02X:%02X:%02X:%02X:%02X via MAC %02X:%02X:%02X:%02X:%02X:%02X is incorrect.", MAC2STR(queue.data.original_target_mac), MAC2STR(peer->peer_addr));
                    for (uint16_t i = 0; i < zh_vector_get_size(&_route_vector); ++i)
                    {
-                        routing_table_t *routing_table = zh_vector_get_item(&_route_vector, i);
-                        if (memcmp(data->original_target_mac, routing_table->original_target_mac, 6) == 0)
+                        _routing_table_t *routing_table = zh_vector_get_item(&_route_vector, i);
+                        if (memcmp(queue.data.original_target_mac, routing_table->original_target_mac, 6) == 0)
                        {
                            zh_vector_delete_item(&_route_vector, i);
                        }
                    }
-                    if (data->message_type == UNICAST)
+                    if (queue.data.message_type == UNICAST)
                    {
                        ESP_LOGI(TAG, "Unicast message from MAC %02X:%02X:%02X:%02X:%02X:%02X to MAC %02X:%02X:%02X:%02X:%02X:%02X transferred to routing waiting list.", MAC2STR(queue.data.original_sender_mac), MAC2STR(queue.data.original_target_mac));
                    }
-                    if (data->message_type == DELIVERY_CONFIRM)
+                    if (queue.data.message_type == DELIVERY_CONFIRM)
                    {
                        ESP_LOGI(TAG, "System message for message receiving confirmation from MAC %02X:%02X:%02X:%02X:%02X:%02X to MAC %02X:%02X:%02X:%02X:%02X:%02X transferred to routing waiting list.", MAC2STR(queue.data.original_sender_mac), MAC2STR(queue.data.original_target_mac));
                    }
@@ -502,11 +498,11 @@ static void _processing(void *pvParameter)
                    }
                    ESP_LOGI(TAG, "System message for routing request to MAC %02X:%02X:%02X:%02X:%02X:%02X added to queue.", MAC2STR(queue.data.original_target_mac));
                    queue.id = TO_SEND;
-                    data->message_type = SEARCH_REQUEST;
-                    memcpy(data->original_sender_mac, &_self_mac, 6);
-                    data->data_len = 0;
-                    memset(data->data, 0, ZH_NETWORK_MAX_MESSAGE_SIZE);
-                    data->message_id = abs(esp_random()); // It is not clear why esp_random() sometimes gives negative values.
+                    queue.data.message_type = SEARCH_REQUEST;
+                    memcpy(queue.data.original_sender_mac, _self_mac, 6);
+                    queue.data.payload_len = 0;
+                    memset(queue.data.payload, 0, ZH_NETWORK_MAX_MESSAGE_SIZE);
+                    queue.data.message_id = abs(esp_random()); // It is not clear why esp_random() sometimes gives negative values.
                    ESP_LOGI(TAG, "Outgoing ESP-NOW data from MAC %02X:%02X:%02X:%02X:%02X:%02X to MAC %02X:%02X:%02X:%02X:%02X:%02X processed success.", MAC2STR(queue.data.original_sender_mac), MAC2STR(queue.data.original_target_mac));
                    if (xQueueSendToFront(_queue_handle, &queue, portTICK_PERIOD_MS) != pdTRUE)
                    {
@@ -520,7 +516,7 @@ static void _processing(void *pvParameter)
            break;
        case ON_RECV:
            ESP_LOGI(TAG, "Incoming ESP-NOW data from MAC %02X:%02X:%02X:%02X:%02X:%02X to MAC %02X:%02X:%02X:%02X:%02X:%02X processing begin.", MAC2STR(queue.data.original_sender_mac), MAC2STR(queue.data.original_target_mac));
-            switch (data->message_type)
+            switch (queue.data.message_type)
            {
            case BROADCAST:
                ESP_LOGI(TAG, "Broadcast message from MAC %02X:%02X:%02X:%02X:%02X:%02X to MAC %02X:%02X:%02X:%02X:%02X:%02X is received.", MAC2STR(queue.data.original_sender_mac), MAC2STR(queue.data.original_target_mac));
@@ -532,9 +528,9 @@ static void _processing(void *pvParameter)
                    break;
                }
                memset(on_recv, 0, sizeof(zh_network_event_on_recv_t));
-                memcpy(on_recv->mac_addr, data->original_sender_mac, 6);
-                on_recv->data_len = data->data_len;
-                on_recv->data = heap_caps_malloc(data->data_len, MALLOC_CAP_8BIT);
+                memcpy(on_recv->mac_addr, queue.data.original_sender_mac, 6);
+                on_recv->data_len = queue.data.payload_len;
+                on_recv->data = heap_caps_malloc(queue.data.payload_len, MALLOC_CAP_8BIT);
                if (on_recv->data == NULL)
                {
                    ESP_LOGE(TAG, "ESP-NOW message processing task internal error.");
@@ -542,8 +538,8 @@ static void _processing(void *pvParameter)
                    heap_caps_free(on_recv->data);
                    break;
                }
-                memset(on_recv->data, 0, data->data_len);
-                memcpy(on_recv->data, data->data, data->data_len);
+                memset(on_recv->data, 0, queue.data.payload_len);
+                memcpy(on_recv->data, queue.data.payload, queue.data.payload_len);
                ESP_LOGI(TAG, "Broadcast message from MAC %02X:%02X:%02X:%02X:%02X:%02X to MAC %02X:%02X:%02X:%02X:%02X:%02X added to queue for resend to all nodes.", MAC2STR(queue.data.original_sender_mac), MAC2STR(queue.data.original_target_mac));
                ESP_LOGI(TAG, "Incoming ESP-NOW data from MAC %02X:%02X:%02X:%02X:%02X:%02X to MAC %02X:%02X:%02X:%02X:%02X:%02X processed success.", MAC2STR(queue.data.original_sender_mac), MAC2STR(queue.data.original_target_mac));
                if (esp_event_post(ZH_NETWORK, ZH_NETWORK_ON_RECV_EVENT, on_recv, sizeof(zh_network_event_on_recv_t) + on_recv->data_len + sizeof(on_recv->data_len), portTICK_PERIOD_MS) != ESP_OK)
@@ -559,7 +555,7 @@ static void _processing(void *pvParameter)
                break;
            case UNICAST:
                ESP_LOGI(TAG, "Unicast message from MAC %02X:%02X:%02X:%02X:%02X:%02X to MAC %02X:%02X:%02X:%02X:%02X:%02X is received.", MAC2STR(queue.data.original_sender_mac), MAC2STR(queue.data.original_target_mac));
-                if (memcmp(data->original_target_mac, &_self_mac, 6) == 0)
+                if (memcmp(queue.data.original_target_mac, _self_mac, 6) == 0)
                {
                    zh_network_event_on_recv_t *on_recv = heap_caps_malloc(sizeof(zh_network_event_on_recv_t), MALLOC_CAP_8BIT);
                    if (on_recv == NULL)
@@ -569,9 +565,9 @@ static void _processing(void *pvParameter)
                        break;
                    }
                    memset(on_recv, 0, sizeof(zh_network_event_on_recv_t));
-                    memcpy(on_recv->mac_addr, data->original_sender_mac, 6);
-                    on_recv->data_len = data->data_len;
-                    on_recv->data = heap_caps_malloc(data->data_len, MALLOC_CAP_8BIT);
+                    memcpy(on_recv->mac_addr, queue.data.original_sender_mac, 6);
+                    on_recv->data_len = queue.data.payload_len;
+                    on_recv->data = heap_caps_malloc(queue.data.payload_len, MALLOC_CAP_8BIT);
                    if (on_recv->data == NULL)
                    {
                        ESP_LOGE(TAG, "ESP-NOW message processing task internal error.");
@@ -579,8 +575,8 @@ static void _processing(void *pvParameter)
                        heap_caps_free(on_recv->data);
                        break;
                    }
-                    memset(on_recv->data, 0, data->data_len);
-                    memcpy(on_recv->data, data->data, data->data_len);
+                    memset(on_recv->data, 0, queue.data.payload_len);
+                    memcpy(on_recv->data, queue.data.payload, queue.data.payload_len);
                    ESP_LOGI(TAG, "Incoming ESP-NOW data from MAC %02X:%02X:%02X:%02X:%02X:%02X to MAC %02X:%02X:%02X:%02X:%02X:%02X processed success.", MAC2STR(queue.data.original_sender_mac), MAC2STR(queue.data.original_target_mac));
                    if (esp_event_post(ZH_NETWORK, ZH_NETWORK_ON_RECV_EVENT, on_recv, sizeof(zh_network_event_on_recv_t) + on_recv->data_len + sizeof(on_recv->data_len), portTICK_PERIOD_MS) != ESP_OK)
                    {
@@ -588,13 +584,13 @@ static void _processing(void *pvParameter)
                    }
                    heap_caps_free(on_recv);
                    queue.id = TO_SEND;
-                    data->message_type = DELIVERY_CONFIRM;
-                    memcpy(data->original_target_mac, data->original_sender_mac, 6);
-                    memcpy(data->original_sender_mac, &_self_mac, 6);
-                    data->data_len = 0;
-                    memset(data->data, 0, ZH_NETWORK_MAX_MESSAGE_SIZE);
-                    data->confirm_id = data->message_id;
-                    data->message_id = abs(esp_random()); // It is not clear why esp_random() sometimes gives negative values.
+                    queue.data.message_type = DELIVERY_CONFIRM;
+                    memcpy(queue.data.original_target_mac, queue.data.original_sender_mac, 6);
+                    memcpy(queue.data.original_sender_mac, _self_mac, 6);
+                    queue.data.payload_len = 0;
+                    memset(queue.data.payload, 0, ZH_NETWORK_MAX_MESSAGE_SIZE);
+                    queue.data.confirm_id = queue.data.message_id;
+                    queue.data.message_id = abs(esp_random()); // It is not clear why esp_random() sometimes gives negative values.
                    if (xQueueSendToFront(_queue_handle, &queue, portTICK_PERIOD_MS) != pdTRUE)
                    {
                        ESP_LOGE(TAG, "ESP-NOW message processing task internal error.");
@@ -611,9 +607,9 @@ static void _processing(void *pvParameter)
                break;
            case DELIVERY_CONFIRM:
                ESP_LOGI(TAG, "System message for message receiving confirmation from MAC %02X:%02X:%02X:%02X:%02X:%02X to MAC %02X:%02X:%02X:%02X:%02X:%02X is received.", MAC2STR(queue.data.original_sender_mac), MAC2STR(queue.data.original_target_mac));
-                if (memcmp(data->original_target_mac, &_self_mac, 6) == 0)
+                if (memcmp(queue.data.original_target_mac, _self_mac, 6) == 0)
                {
-                    zh_vector_push_back(&_response_vector, &data->confirm_id);
+                    zh_vector_push_back(&_response_vector, &queue.data.confirm_id);
                    if (zh_vector_get_size(&_response_vector) > _init_config.queue_size)
                    {
                        zh_vector_delete_item(&_response_vector, 0);
@@ -633,32 +629,32 @@ static void _processing(void *pvParameter)
                ESP_LOGI(TAG, "System message for routing request from MAC %02X:%02X:%02X:%02X:%02X:%02X to MAC %02X:%02X:%02X:%02X:%02X:%02X is received.", MAC2STR(queue.data.original_sender_mac), MAC2STR(queue.data.original_target_mac));
                for (uint16_t i = 0; i < zh_vector_get_size(&_route_vector); ++i)
                {
-                    routing_table_t *routing_table = zh_vector_get_item(&_route_vector, i);
-                    if (memcmp(data->original_target_mac, routing_table->original_target_mac, 6) == 0)
+                    _routing_table_t *routing_table = zh_vector_get_item(&_route_vector, i);
+                    if (memcmp(queue.data.original_target_mac, routing_table->original_target_mac, 6) == 0)
                    {
                        zh_vector_delete_item(&_route_vector, i);
                    }
                }
                { // Just to avoid the compiler warning.
-                    routing_table_t routing_table = {0};
-                    memcpy(&routing_table.original_target_mac, data->original_sender_mac, 6);
-                    memcpy(&routing_table.intermediate_target_mac, data->sender_mac, 6);
+                    _routing_table_t routing_table = {0};
+                    memcpy(routing_table.original_target_mac, queue.data.original_sender_mac, 6);
+                    memcpy(routing_table.intermediate_target_mac, queue.data.sender_mac, 6);
                    zh_vector_push_back(&_route_vector, &routing_table);
                }
                if (zh_vector_get_size(&_route_vector) > _init_config.route_vector_size)
                {
                    zh_vector_delete_item(&_route_vector, 0);
                }
-                if (memcmp(data->original_target_mac, &_self_mac, 6) == 0)
+                if (memcmp(queue.data.original_target_mac, _self_mac, 6) == 0)
                {
                    ESP_LOGI(TAG, "System message for routing response from MAC %02X:%02X:%02X:%02X:%02X:%02X to MAC %02X:%02X:%02X:%02X:%02X:%02X added to the queue.", MAC2STR(queue.data.original_target_mac), MAC2STR(queue.data.original_sender_mac));
                    queue.id = TO_SEND;
-                    data->message_type = SEARCH_RESPONSE;
-                    memcpy(data->original_target_mac, data->original_sender_mac, 6);
-                    memcpy(data->original_sender_mac, &_self_mac, 6);
-                    data->data_len = 0;
-                    memset(data->data, 0, ZH_NETWORK_MAX_MESSAGE_SIZE);
-                    data->message_id = abs(esp_random()); // It is not clear why esp_random() sometimes gives negative values.
+                    queue.data.message_type = SEARCH_RESPONSE;
+                    memcpy(queue.data.original_target_mac, queue.data.original_sender_mac, 6);
+                    memcpy(queue.data.original_sender_mac, _self_mac, 6);
+                    queue.data.payload_len = 0;
+                    memset(queue.data.payload, 0, ZH_NETWORK_MAX_MESSAGE_SIZE);
+                    queue.data.message_id = abs(esp_random()); // It is not clear why esp_random() sometimes gives negative values.
                    ESP_LOGI(TAG, "Incoming ESP-NOW data from MAC %02X:%02X:%02X:%02X:%02X:%02X to MAC %02X:%02X:%02X:%02X:%02X:%02X processed success.", MAC2STR(queue.data.original_sender_mac), MAC2STR(queue.data.original_target_mac));
                    if (xQueueSendToFront(_queue_handle, &queue, portTICK_PERIOD_MS) != pdTRUE)
                    {
@@ -678,23 +674,23 @@ static void _processing(void *pvParameter)
                ESP_LOGI(TAG, "System message for routing response from MAC %02X:%02X:%02X:%02X:%02X:%02X to MAC %02X:%02X:%02X:%02X:%02X:%02X is received.", MAC2STR(queue.data.original_sender_mac), MAC2STR(queue.data.original_target_mac));
                for (uint16_t i = 0; i < zh_vector_get_size(&_route_vector); ++i)
                {
-                    routing_table_t *routing_table = zh_vector_get_item(&_route_vector, i);
-                    if (memcmp(data->original_target_mac, routing_table->original_target_mac, 6) == 0)
+                    _routing_table_t *routing_table = zh_vector_get_item(&_route_vector, i);
+                    if (memcmp(queue.data.original_target_mac, routing_table->original_target_mac, 6) == 0)
                    {
                        zh_vector_delete_item(&_route_vector, i);
                    }
                }
                { // Just to avoid the compiler warning.
-                    routing_table_t routing_table = {0};
-                    memcpy(&routing_table.original_target_mac, data->original_sender_mac, 6);
-                    memcpy(&routing_table.intermediate_target_mac, data->sender_mac, 6);
+                    _routing_table_t routing_table = {0};
+                    memcpy(routing_table.original_target_mac, queue.data.original_sender_mac, 6);
+                    memcpy(routing_table.intermediate_target_mac, queue.data.sender_mac, 6);
                    zh_vector_push_back(&_route_vector, &routing_table);
                }
                if (zh_vector_get_size(&_route_vector) > _init_config.route_vector_size)
                {
                    zh_vector_delete_item(&_route_vector, 0);
                }
-                if (memcmp(data->original_target_mac, &_self_mac, 6) != 0)
+                if (memcmp(queue.data.original_target_mac, _self_mac, 6) != 0)
                {
                    ESP_LOGI(TAG, "System message for routing response from MAC %02X:%02X:%02X:%02X:%02X:%02X to MAC %02X:%02X:%02X:%02X:%02X:%02X added to queue for resend to all nodes.", MAC2STR(queue.data.original_sender_mac), MAC2STR(queue.data.original_target_mac));
                    ESP_LOGI(TAG, "Incoming ESP-NOW data from MAC %02X:%02X:%02X:%02X:%02X:%02X to MAC %02X:%02X:%02X:%02X:%02X:%02X processed success.", MAC2STR(queue.data.original_sender_mac), MAC2STR(queue.data.original_target_mac));
@@ -715,7 +711,7 @@ static void _processing(void *pvParameter)
            for (uint16_t i = 0; i < zh_vector_get_size(&_response_vector); ++i)
            {
                uint32_t *message_id = zh_vector_get_item(&_response_vector, i);
-                if (memcmp(&data->message_id, message_id, sizeof(data->message_id)) == 0)
+                if (memcmp(&queue.data.message_id, message_id, sizeof(queue.data.message_id)) == 0)
                {
                    zh_vector_delete_item(&_response_vector, i);
                    zh_network_event_on_send_t *on_send = heap_caps_malloc(sizeof(zh_network_event_on_send_t), MALLOC_CAP_8BIT);
@@ -726,7 +722,7 @@ static void _processing(void *pvParameter)
                        break;
                    }
                    memset(on_send, 0, sizeof(zh_network_event_on_send_t));
-                    memcpy(on_send->mac_addr, data->original_target_mac, 6);
+                    memcpy(on_send->mac_addr, queue.data.original_target_mac, 6);
                    on_send->status = ZH_NETWORK_SEND_SUCCESS;
                    ESP_LOGI(TAG, "Unicast message from MAC %02X:%02X:%02X:%02X:%02X:%02X to MAC %02X:%02X:%02X:%02X:%02X:%02X sent success.", MAC2STR(queue.data.original_sender_mac), MAC2STR(queue.data.original_target_mac));
                    ESP_LOGI(TAG, "Unicast message from MAC %02X:%02X:%02X:%02X:%02X:%02X to MAC %02X:%02X:%02X:%02X:%02X:%02X removed from confirmation message waiting list.", MAC2STR(queue.data.original_sender_mac), MAC2STR(queue.data.original_target_mac));
@@ -744,7 +740,7 @@ static void _processing(void *pvParameter)
                if ((esp_timer_get_time() / 1000 - queue.time) > _init_config.max_waiting_time)
                {
                    ESP_LOGW(TAG, "Time for waiting confirmation message from MAC %02X:%02X:%02X:%02X:%02X:%02X is expired.", MAC2STR(queue.data.original_target_mac));
-                    if (memcmp(data->original_sender_mac, &_self_mac, 6) == 0)
+                    if (memcmp(queue.data.original_sender_mac, _self_mac, 6) == 0)
                    {
                        zh_network_event_on_send_t *on_send = heap_caps_malloc(sizeof(zh_network_event_on_send_t), MALLOC_CAP_8BIT);
                        if (on_send == NULL)
@@ -754,7 +750,7 @@ static void _processing(void *pvParameter)
                            break;
                        }
                        memset(on_send, 0, sizeof(zh_network_event_on_send_t));
-                        memcpy(on_send->mac_addr, data->original_target_mac, 6);
+                        memcpy(on_send->mac_addr, queue.data.original_target_mac, 6);
                        on_send->status = ZH_NETWORK_SEND_FAIL;
                        ESP_LOGE(TAG, "Unicast message from MAC %02X:%02X:%02X:%02X:%02X:%02X to MAC %02X:%02X:%02X:%02X:%02X:%02X sent fail.", MAC2STR(queue.data.original_sender_mac), MAC2STR(queue.data.original_target_mac));
                        ESP_LOGI(TAG, "Unicast message from MAC %02X:%02X:%02X:%02X:%02X:%02X to MAC %02X:%02X:%02X:%02X:%02X:%02X removed from confirmation message waiting list.", MAC2STR(queue.data.original_sender_mac), MAC2STR(queue.data.original_target_mac));
@@ -775,15 +771,15 @@ static void _processing(void *pvParameter)
        case WAIT_ROUTE:
            for (uint16_t i = 0; i < zh_vector_get_size(&_route_vector); ++i)
            {
-                routing_table_t *routing_table = zh_vector_get_item(&_route_vector, i);
-                if (memcmp(data->original_target_mac, routing_table->original_target_mac, 6) == 0)
+                _routing_table_t *routing_table = zh_vector_get_item(&_route_vector, i);
+                if (memcmp(queue.data.original_target_mac, routing_table->original_target_mac, 6) == 0)
                {
                    ESP_LOGI(TAG, "Routing to MAC %02X:%02X:%02X:%02X:%02X:%02X is received.", MAC2STR(queue.data.original_target_mac));
-                    if (data->message_type == UNICAST)
+                    if (queue.data.message_type == UNICAST)
                    {
                        ESP_LOGI(TAG, "Unicast message from MAC %02X:%02X:%02X:%02X:%02X:%02X to MAC %02X:%02X:%02X:%02X:%02X:%02X removed from routing waiting list and added to queue.", MAC2STR(queue.data.original_sender_mac), MAC2STR(queue.data.original_target_mac));
                    }
-                    if (data->message_type == DELIVERY_CONFIRM)
+                    if (queue.data.message_type == DELIVERY_CONFIRM)
                    {
                        ESP_LOGI(TAG, "System message for message receiving confirmation from MAC %02X:%02X:%02X:%02X:%02X:%02X to MAC %02X:%02X:%02X:%02X:%02X:%02X removed from routing waiting list and added to queue.", MAC2STR(queue.data.original_sender_mac), MAC2STR(queue.data.original_target_mac));
                    }
@@ -801,7 +797,7 @@ static void _processing(void *pvParameter)
                if ((esp_timer_get_time() / 1000 - queue.time) > _init_config.max_waiting_time)
                {
                    ESP_LOGW(TAG, "Time for waiting routing to MAC %02X:%02X:%02X:%02X:%02X:%02X is expired.", MAC2STR(queue.data.original_target_mac));
-                    if (memcmp(data->original_sender_mac, &_self_mac, 6) == 0)
+                    if (memcmp(queue.data.original_sender_mac, _self_mac, 6) == 0)
                    {
                        zh_network_event_on_send_t *on_send = heap_caps_malloc(sizeof(zh_network_event_on_send_t), MALLOC_CAP_8BIT);
                        if (on_send == NULL)
@@ -811,7 +807,7 @@ static void _processing(void *pvParameter)
                            break;
                        }
                        memset(on_send, 0, sizeof(zh_network_event_on_send_t));
-                        memcpy(on_send->mac_addr, data->original_target_mac, 6);
+                        memcpy(on_send->mac_addr, queue.data.original_target_mac, 6);
                        on_send->status = ZH_NETWORK_SEND_FAIL;
                        ESP_LOGE(TAG, "Unicast message from MAC %02X:%02X:%02X:%02X:%02X:%02X to MAC %02X:%02X:%02X:%02X:%02X:%02X sent fail.", MAC2STR(queue.data.original_sender_mac), MAC2STR(queue.data.original_target_mac));
                        ESP_LOGI(TAG, "Unicast message from MAC %02X:%02X:%02X:%02X:%02X:%02X to MAC %02X:%02X:%02X:%02X:%02X:%02X removed from routing waiting list.", MAC2STR(queue.data.original_sender_mac), MAC2STR(queue.data.original_target_mac));
@@ -823,11 +819,11 @@ static void _processing(void *pvParameter)
                    }
                    else
                    {
-                        if (data->message_type == UNICAST)
+                        if (queue.data.message_type == UNICAST)
                        {
                            ESP_LOGI(TAG, "Unicast message from MAC %02X:%02X:%02X:%02X:%02X:%02X to MAC %02X:%02X:%02X:%02X:%02X:%02X removed from routing waiting list.", MAC2STR(queue.data.original_sender_mac), MAC2STR(queue.data.original_target_mac));
                        }
-                        if (data->message_type == DELIVERY_CONFIRM)
+                        if (queue.data.message_type == DELIVERY_CONFIRM)
                        {
                            ESP_LOGI(TAG, "System message for message receiving confirmation from MAC %02X:%02X:%02X:%02X:%02X:%02X to MAC %02X:%02X:%02X:%02X:%02X:%02X removed from routing waiting list.", MAC2STR(queue.data.original_sender_mac), MAC2STR(queue.data.original_target_mac));
                        }
--- a/components/zh_onewire/README.md
+++ b/components/zh_onewire/README.md
@@ -13,7 +13,7 @@ In an existing project, run the following command to install the component:

 ```text
 cd ../your_project/components
-git clone https://github.com/aZholtikov/zh_onewire.git
+git clone http://git.zh.com.ru/alexey.zholtikov/zh_onewire.git
 ```

 In the application, add the component:
--- a/components/zh_onewire/include/zh_onewire.h
+++ b/components/zh_onewire/include/zh_onewire.h
@@ -20,9 +20,9 @@ extern "C"
 #endif

    /**
-     * @brief Initialize 1-Wire interface.
+     * @brief      Initialize 1-Wire interface.
     *
-     * @param[in] pin 1-Wire bus gpio connection.
+     * @param[in]  pin  1-Wire bus gpio connection.
     *
     * @return
     *              - ESP_OK if initialization was successful
@@ -31,61 +31,59 @@ extern "C"
    esp_err_t zh_onewire_init(const uint8_t pin);

    /**
-     * @brief Reset command for all 1-Wire devices on bus.
+     * @brief      Reset command for all 1-Wire devices on bus.
     *
     * @return
     *              - ESP_OK if reset was successful
-     *              - ESP_ERR_INVALID_STATE if 1-Wire bus not initialized
     *              - ESP_ERR_INVALID_RESPONSE if the bus is busy
     *              - ESP_ERR_TIMEOUT if there are no 1-Wire devices available on the bus or the devices are not responding
     */
    esp_err_t zh_onewire_reset(void);

    /**
-     * @brief Send one byte to 1-Wire device.
+     * @brief      Send one byte to 1-Wire device.
+     *
+     * @param[in]  byte  Byte value.
     *
-     * @param[in] byte Byte value.
     */
    void zh_onewire_send_byte(uint8_t byte);

    /**
-     * @brief Read one byte from 1-Wire device.
+     * @brief      Read one byte from 1-Wire device.
     *
-     * @return Byte value
+     * @return
+     *              - Byte value
     */
    uint8_t zh_onewire_read_byte(void);

    /**
-     * @brief Initialize the bus master to address all 1-Wire devices on the bus.
+     * @brief      Initializes the bus master to address all 1-Wire devices on the bus.
     *
     * @return
     *              - ESP_OK if initialization was successful
-     *              - ESP_ERR_INVALID_STATE if 1-Wire bus not initialized
     *              - ESP_FAIL if there are no 1-Wire devices available on the bus or the devices are not responding
     */
    esp_err_t zh_onewire_skip_rom(void);

    /**
-     * @brief Read rom value if only one 1-Wire device is present on the bus.
+     * @brief      Read rom value if only one 1-Wire device is present on the bus.
     *
-     * @param[out] buf Pointer to a buffer containing an eight-byte rom value.
+     * @param[out]  buf  Pointer to a buffer containing an eight-byte rom value.
     *
     * @return
     *              - ESP_OK if read was successful
-     *              - ESP_ERR_INVALID_STATE if 1-Wire bus not initialized
     *              - ESP_FAIL if there are no 1-Wire devices available on the bus or the devices are not responding
     *              - ESP_ERR_INVALID_CRC if more than one 1-Wire device is present on the bus
     */
    esp_err_t zh_onewire_read_rom(uint8_t *buf);

    /**
-     * @brief Initialize the bus master to address a specific 1-Wire device on bus.
+     * @brief      Initialize the bus master to address a specific 1-Wire device on bus.
     *
-     * @param[in] data Pointer to a buffer containing an eight-byte rom value.
+     * @param[in]  data  Pointer to a buffer containing an eight-byte rom value.
     *
     * @return
     *              - ESP_OK if initialization was successful
-     *              - ESP_ERR_INVALID_STATE if 1-Wire bus not initialized
     *              - ESP_FAIL if there are no 1-Wire devices available on the bus or the devices are not responding
     */
    esp_err_t zh_onewire_match_rom(const uint8_t *data);
@@ -95,18 +93,17 @@ extern "C"
     *
     * @return
     *              - ESP_OK if initialization was successful
-     *              - ESP_ERR_INVALID_STATE if 1-Wire bus not initialized
     */
    esp_err_t zh_onewire_search_rom_init(void);

    /**
-     * @brief Search next 1-Wire device on bus.
+     * @brief      Search next 1-Wire device on bus.
     *
-     * @attention Initialize search 1-Wire devices on bus must be initialized first. @code zh_onewire_search_rom_init() @endcode
+     * @attention  Initialize search 1-Wire devices on bus must be initialized first. @code zh_onewire_search_rom_init() @endcode
     *
     * @return
     *              - Pointer to a buffer containing an eight-byte rom value
-     *              - NULL if the search is terminated or if there are no 1-Wire devices available on the bus or the devices are not responding or if 1-Wire bus not initialized
+     *              - NULL if the search is terminated or if there are no 1-Wire devices available on the bus or the devices are not responding
     */
    uint8_t *zh_onewire_search_rom_next(void);

--- a/components/zh_onewire/version.txt
+++ b/components/zh_onewire/version.txt
@@ -1 +1 @@
-1.0.0
+1.1.4
--- a/components/zh_onewire/zh_onewire.c
+++ b/components/zh_onewire/zh_onewire.c
@@ -1,7 +1,6 @@
 /**
 * @file
 * The main code of the zh_onewire component.
- *
 */

 #include "zh_onewire.h"
@@ -39,7 +38,6 @@ static const char *TAG = "zh_onewire";
 static uint8_t _pin;
 static uint8_t _rom[8];
 static uint8_t _rom_fork_bit = 0xFF;
-static bool _is_initialized = false;

 static const uint8_t _rom_crc_table[] = {
    0x00, 0x5e, 0xbc, 0xe2, 0x61, 0x3f, 0xdd, 0x83, 0xc2, 0x9c, 0x7e, 0x20, 0xa3, 0xfd, 0x1f, 0x41,
@@ -74,7 +72,6 @@ esp_err_t zh_onewire_init(const uint8_t pin)
        ESP_LOGE(TAG, "Onewire initialization fail. Incorrect GPIO number.");
        return ESP_ERR_INVALID_ARG;
    }
-    _is_initialized = true;
    ESP_LOGI(TAG, "Onewire initialization success.");
    return ESP_OK;
 }
@@ -82,11 +79,6 @@ esp_err_t zh_onewire_init(const uint8_t pin)
 esp_err_t zh_onewire_reset(void)
 {
    ESP_LOGI(TAG, "Onewire reset begin.");
-    if (_is_initialized == false)
-    {
-        ESP_LOGE(TAG, "Onewire reset fail. Onewire not initialized.");
-        return ESP_ERR_INVALID_STATE;
-    }
    if (gpio_get_level(_pin) != 1)
    {
        ESP_LOGE(TAG, "Onewire reset fail. Bus is busy.");
@@ -137,11 +129,6 @@ void zh_onewire_send_byte(uint8_t byte)
 esp_err_t zh_onewire_skip_rom(void)
 {
    ESP_LOGI(TAG, "Onewire skip ROM begin.");
-    if (_is_initialized == false)
-    {
-        ESP_LOGE(TAG, "Onewire skip ROM fail. Onewire not initialized.");
-        return ESP_ERR_INVALID_STATE;
-    }
    if (zh_onewire_reset() != ESP_OK)
    {
        ESP_LOGE(TAG, "Onewire skip ROM fail.");
@@ -155,11 +142,6 @@ esp_err_t zh_onewire_skip_rom(void)
 esp_err_t zh_onewire_read_rom(uint8_t *buf)
 {
    ESP_LOGI(TAG, "Onewire read ROM begin.");
-    if (_is_initialized == false)
-    {
-        ESP_LOGE(TAG, "Onewire read ROM fail. Onewire not initialized.");
-        return ESP_ERR_INVALID_STATE;
-    }
    if (zh_onewire_reset() != ESP_OK)
    {
        ESP_LOGE(TAG, "Onewire read ROM fail.");
@@ -185,11 +167,6 @@ esp_err_t zh_onewire_read_rom(uint8_t *buf)
 esp_err_t zh_onewire_match_rom(const uint8_t *data)
 {
    ESP_LOGI(TAG, "Onewire match ROM begin.");
-    if (_is_initialized == false)
-    {
-        ESP_LOGE(TAG, "Onewire match ROM fail. Onewire not initialized.");
-        return ESP_ERR_INVALID_STATE;
-    }
    if (zh_onewire_reset() != ESP_OK)
    {
        ESP_LOGE(TAG, "Onewire match ROM fail.");
@@ -206,10 +183,6 @@ esp_err_t zh_onewire_match_rom(const uint8_t *data)

 esp_err_t zh_onewire_search_rom_init(void)
 {
-    if (_is_initialized == false)
-    {
-        return ESP_ERR_INVALID_STATE;
-    }
    for (uint8_t i = 0; i < 8; ++i)
    {
        _rom[i] = 0;
@@ -221,11 +194,6 @@ esp_err_t zh_onewire_search_rom_init(void)
 uint8_t *zh_onewire_search_rom_next(void)
 {
    ESP_LOGI(TAG, "Onewire search ROM begin.");
-    if (_is_initialized == false)
-    {
-        ESP_LOGE(TAG, "Onewire search ROM fail. Onewire not initialized.");
-        return NULL;
-    }
    if (_rom_fork_bit == 0xFF)
    {
        ESP_LOGE(TAG, "Onewire search ROM not initialized.");
--- a/main/zh_espnow_sensor.c
+++ b/main/zh_espnow_sensor.c
@@ -418,6 +418,7 @@ void zh_send_sensor_status_message_task(void *pvParameter)
 void zh_espnow_event_handler(void *arg, esp_event_base_t event_base, int32_t event_id, void *event_data)
 {
    sensor_config_t *sensor_config = arg;
+    zh_espnow_data_t data = {0};
    switch (event_id)
    {
 #ifdef CONFIG_NETWORK_TYPE_DIRECT
@@ -435,14 +436,14 @@ void zh_espnow_event_handler(void *arg, esp_event_base_t event_base, int32_t eve
            goto ZH_NETWORK_EVENT_HANDLER_EXIT;
        }
 #endif
-        zh_espnow_data_t *data = (zh_espnow_data_t *)recv_data->data;
-        switch (data->device_type)
+        memcpy(&data, recv_data->data, recv_data->data_len);
+        switch (data.device_type)
        {
        case ZHDT_GATEWAY:
-            switch (data->payload_type)
+            switch (data.payload_type)
            {
            case ZHPT_KEEP_ALIVE:
-                if (data->payload_data.keep_alive_message.online_status == ZH_ONLINE)
+                if (data.payload_data.keep_alive_message.online_status == ZH_ONLINE)
                {
                    if (sensor_config->gateway_is_available == false)
                    {
@@ -471,31 +472,31 @@ void zh_espnow_event_handler(void *arg, esp_event_base_t event_base, int32_t eve
                }
                break;
            case ZHPT_HARDWARE:
-                sensor_config->hardware_config.sensor_type = data->payload_data.config_message.sensor_hardware_config_message.sensor_type;
-                sensor_config->hardware_config.sensor_pin_1 = data->payload_data.config_message.sensor_hardware_config_message.sensor_pin_1;
-                sensor_config->hardware_config.sensor_pin_2 = data->payload_data.config_message.sensor_hardware_config_message.sensor_pin_2;
-                sensor_config->hardware_config.power_pin = data->payload_data.config_message.sensor_hardware_config_message.power_pin;
-                sensor_config->hardware_config.measurement_frequency = data->payload_data.config_message.sensor_hardware_config_message.measurement_frequency;
-                sensor_config->hardware_config.battery_power = data->payload_data.config_message.sensor_hardware_config_message.battery_power;
+                sensor_config->hardware_config.sensor_type = data.payload_data.config_message.sensor_hardware_config_message.sensor_type;
+                sensor_config->hardware_config.sensor_pin_1 = data.payload_data.config_message.sensor_hardware_config_message.sensor_pin_1;
+                sensor_config->hardware_config.sensor_pin_2 = data.payload_data.config_message.sensor_hardware_config_message.sensor_pin_2;
+                sensor_config->hardware_config.power_pin = data.payload_data.config_message.sensor_hardware_config_message.power_pin;
+                sensor_config->hardware_config.measurement_frequency = data.payload_data.config_message.sensor_hardware_config_message.measurement_frequency;
+                sensor_config->hardware_config.battery_power = data.payload_data.config_message.sensor_hardware_config_message.battery_power;
                zh_save_config(sensor_config);
                esp_restart();
                break;
            case ZHPT_UPDATE:;
                const esp_app_desc_t *app_info = get_app_description();
                sensor_config->update_partition = esp_ota_get_next_update_partition(NULL);
-                strcpy(data->payload_data.ota_message.espnow_ota_data.app_version, app_info->version);
+                strcpy(data.payload_data.ota_message.espnow_ota_data.app_version, app_info->version);
 #ifdef CONFIG_IDF_TARGET_ESP8266
                char *app_name = (char *)heap_caps_malloc(strlen(app_info->project_name) + 6, MALLOC_CAP_8BIT);
                memset(app_name, 0, strlen(app_info->project_name) + 6);
                sprintf(app_name, "%s.app%d", app_info->project_name, sensor_config->update_partition->subtype - ESP_PARTITION_SUBTYPE_APP_OTA_0 + 1);
-                strcpy(data->payload_data.ota_message.espnow_ota_data.app_name, app_name);
+                strcpy(data.payload_data.ota_message.espnow_ota_data.app_name, app_name);
                heap_caps_free(app_name);
 #else
-                strcpy(data->payload_data.ota_message.espnow_ota_data.app_name, app_info->project_name);
+                strcpy(data.payload_data.ota_message.espnow_ota_data.app_name, app_info->project_name);
 #endif
-                data->device_type = ZHDT_SENSOR;
-                data->payload_type = ZHPT_UPDATE;
-                zh_send_message(sensor_config->gateway_mac, (uint8_t *)data, sizeof(zh_espnow_data_t));
+                data.device_type = ZHDT_SENSOR;
+                data.payload_type = ZHPT_UPDATE;
+                zh_send_message(sensor_config->gateway_mac, (uint8_t *)&data, sizeof(zh_espnow_data_t));
                break;
            case ZHPT_UPDATE_BEGIN:
 #ifdef CONFIG_IDF_TARGET_ESP8266
@@ -504,19 +505,19 @@ void zh_espnow_event_handler(void *arg, esp_event_base_t event_base, int32_t eve
                esp_ota_begin(sensor_config->update_partition, OTA_SIZE_UNKNOWN, (esp_ota_handle_t *)&sensor_config->update_handle);
 #endif
                sensor_config->ota_message_part_number = 1;
-                data->device_type = ZHDT_SENSOR;
-                data->payload_type = ZHPT_UPDATE_PROGRESS;
-                zh_send_message(sensor_config->gateway_mac, (uint8_t *)data, sizeof(zh_espnow_data_t));
+                data.device_type = ZHDT_SENSOR;
+                data.payload_type = ZHPT_UPDATE_PROGRESS;
+                zh_send_message(sensor_config->gateway_mac, (uint8_t *)&data, sizeof(zh_espnow_data_t));
                break;
            case ZHPT_UPDATE_PROGRESS:
-                if (sensor_config->ota_message_part_number == data->payload_data.ota_message.espnow_ota_message.part)
+                if (sensor_config->ota_message_part_number == data.payload_data.ota_message.espnow_ota_message.part)
                {
                    ++sensor_config->ota_message_part_number;
-                    esp_ota_write(sensor_config->update_handle, (const void *)data->payload_data.ota_message.espnow_ota_message.data, data->payload_data.ota_message.espnow_ota_message.data_len);
+                    esp_ota_write(sensor_config->update_handle, (const void *)data.payload_data.ota_message.espnow_ota_message.data, data.payload_data.ota_message.espnow_ota_message.data_len);
                }
-                data->device_type = ZHDT_SENSOR;
-                data->payload_type = ZHPT_UPDATE_PROGRESS;
-                zh_send_message(sensor_config->gateway_mac, (uint8_t *)data, sizeof(zh_espnow_data_t));
+                data.device_type = ZHDT_SENSOR;
+                data.payload_type = ZHPT_UPDATE_PROGRESS;
+                zh_send_message(sensor_config->gateway_mac, (uint8_t *)&data, sizeof(zh_espnow_data_t));
                break;
            case ZHPT_UPDATE_ERROR:
                esp_ota_end(sensor_config->update_handle);
@@ -524,15 +525,15 @@ void zh_espnow_event_handler(void *arg, esp_event_base_t event_base, int32_t eve
            case ZHPT_UPDATE_END:
                if (esp_ota_end(sensor_config->update_handle) != ESP_OK)
                {
-                    data->device_type = ZHDT_SENSOR;
-                    data->payload_type = ZHPT_UPDATE_FAIL;
-                    zh_send_message(sensor_config->gateway_mac, (uint8_t *)data, sizeof(zh_espnow_data_t));
+                    data.device_type = ZHDT_SENSOR;
+                    data.payload_type = ZHPT_UPDATE_FAIL;
+                    zh_send_message(sensor_config->gateway_mac, (uint8_t *)&data, sizeof(zh_espnow_data_t));
                    break;
                }
                esp_ota_set_boot_partition(sensor_config->update_partition);
-                data->device_type = ZHDT_SENSOR;
-                data->payload_type = ZHPT_UPDATE_SUCCESS;
-                zh_send_message(sensor_config->gateway_mac, (uint8_t *)data, sizeof(zh_espnow_data_t));
+                data.device_type = ZHDT_SENSOR;
+                data.payload_type = ZHPT_UPDATE_SUCCESS;
+                zh_send_message(sensor_config->gateway_mac, (uint8_t *)&data, sizeof(zh_espnow_data_t));
                vTaskDelay(1000 / portTICK_PERIOD_MS);
                esp_restart();
                break;
--- a/version.txt
+++ b/version.txt
@@ -1 +1 @@
-1.0.1
+1.0.0
Author	SHA1	Message	Date
Alexey Zholtikov	bb0a99ac2b	Updated zh_vector	2024-05-30 08:44:36 +03:00
Alexey Zholtikov	e2078e46b1	Updated zh_espnow	2024-05-30 08:43:41 +03:00
Alexey Zholtikov	4433e03320	Updated zh_config	2024-05-30 08:41:47 +03:00
Alexey Zholtikov	a58048b14a	Updated version of zh_config	2024-05-29 14:44:38 +03:00
Alexey Zholtikov	3d18e539da	Updated one comment	2024-05-29 14:14:14 +03:00
Alexey Zholtikov	cb30d73628	Added new major version of zh_config. Changed main code to support the new version of zh_config	2024-05-29 14:10:21 +03:00
Alexey Zholtikov	187226cf6d	Updated some comments	2024-05-29 11:11:09 +03:00
@@ -1 +1 @@
 .0.0
 .2.6
@@ -1 +1 @@
 .0.0
 .3.2
@@ -1 +1 @@
 .0.3
 .0.0
@@ -1 +1 @@
 .0.0
 .4.4
@@ -1 +1 @@
 .0.0
 .1.4
@@ -1 +1 @@
 .0.1
 .0.0