feedc0de/esp-idf
1
0
Fork 0
forked from espressif/esp-idf
Code Pull Requests Activity

Merge branch 'bugfix/modbus_examples_fix_format_issues' into 'master'

Browse Source 
modbus: fix -wno-format issues in the examples

Closes IDF-6437

See merge request espressif/esp-idf!26542
This commit is contained in:
Alex Lisitsyn
2023-10-20 15:27:33 +08:00
parent e7e478205b c5b2291eea
commit 1c0631ee70
9 changed files with 236 additions and 214 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
examples/protocols/modbus/mb_example_common/include/modbus_params.h
View File

@@ -28,7 +28,8 @@ typedef struct
uint8_t discrete_input5:1; uint8_t discrete_input5:1;
uint8_t discrete_input6:1; uint8_t discrete_input6:1;
uint8_t discrete_input7:1; uint8_t discrete_input7:1;
uint8_t discrete_input_port1:8; uint8_t discrete_input_port1;
uint8_t discrete_input_port2;
} discrete_reg_params_t; } discrete_reg_params_t;
#pragma pack(pop) #pragma pack(pop)
@@ -37,6 +38,7 @@ typedef struct
{ {
uint8_t coils_port0; uint8_t coils_port0;
uint8_t coils_port1; uint8_t coils_port1;
uint8_t coils_port2;
} coil_reg_params_t; } coil_reg_params_t;
#pragma pack(pop) #pragma pack(pop)

1
examples/protocols/modbus/serial/mb_master/main/CMakeLists.txt
View File

@@ -2,4 +2,3 @@ set(PROJECT_NAME "modbus_master")
idf_component_register(SRCS "master.c" idf_component_register(SRCS "master.c"
INCLUDE_DIRS ".") INCLUDE_DIRS ".")
target_compile_options(${COMPONENT_LIB} PRIVATE "-Wno-format")

94
examples/protocols/modbus/serial/mb_master/main/master.c
View File

@@ -1,5 +1,5 @@
/* /*
* SPDX-FileCopyrightText: 2016-2022 Espressif Systems (Shanghai) CO LTD * SPDX-FileCopyrightText: 2016-2023 Espressif Systems (Shanghai) CO LTD
* *
* SPDX-License-Identifier: Apache-2.0 * SPDX-License-Identifier: Apache-2.0
*/ */
@@ -59,6 +59,7 @@ enum {
CID_HOLD_TEST_REG, CID_HOLD_TEST_REG,
CID_RELAY_P1, CID_RELAY_P1,
CID_RELAY_P2, CID_RELAY_P2,
CID_DISCR_P1,
CID_COUNT CID_COUNT
}; };
@@ -87,10 +88,12 @@ const mb_parameter_descriptor_t device_parameters[] = {
HOLD_OFFSET(holding_data2), PARAM_TYPE_FLOAT, 4, OPTS( 0, 100, 1 ), PAR_PERMS_READ_WRITE_TRIGGER }, HOLD_OFFSET(holding_data2), PARAM_TYPE_FLOAT, 4, OPTS( 0, 100, 1 ), PAR_PERMS_READ_WRITE_TRIGGER },
{ CID_HOLD_TEST_REG, STR("Test_regs"), STR("__"), MB_DEVICE_ADDR1, MB_PARAM_HOLDING, 10, 58, { CID_HOLD_TEST_REG, STR("Test_regs"), STR("__"), MB_DEVICE_ADDR1, MB_PARAM_HOLDING, 10, 58,
HOLD_OFFSET(test_regs), PARAM_TYPE_ASCII, 116, OPTS( 0, 100, 1 ), PAR_PERMS_READ_WRITE_TRIGGER }, HOLD_OFFSET(test_regs), PARAM_TYPE_ASCII, 116, OPTS( 0, 100, 1 ), PAR_PERMS_READ_WRITE_TRIGGER },
{ CID_RELAY_P1, STR("RelayP1"), STR("on/off"), MB_DEVICE_ADDR1, MB_PARAM_COIL, 0, 8, { CID_RELAY_P1, STR("RelayP1"), STR("on/off"), MB_DEVICE_ADDR1, MB_PARAM_COIL, 2, 6,
COIL_OFFSET(coils_port0), PARAM_TYPE_U16, 2, OPTS( BIT1, 0, 0 ), PAR_PERMS_READ_WRITE_TRIGGER }, COIL_OFFSET(coils_port0), PARAM_TYPE_U8, 1, OPTS( 0xAA, 0x15, 0 ), PAR_PERMS_READ_WRITE_TRIGGER },
{ CID_RELAY_P2, STR("RelayP2"), STR("on/off"), MB_DEVICE_ADDR1, MB_PARAM_COIL, 8, 8, { CID_RELAY_P2, STR("RelayP2"), STR("on/off"), MB_DEVICE_ADDR1, MB_PARAM_COIL, 10, 6,
COIL_OFFSET(coils_port1), PARAM_TYPE_U16, 2, OPTS( BIT0, 0, 0 ), PAR_PERMS_READ_WRITE_TRIGGER } COIL_OFFSET(coils_port1), PARAM_TYPE_U8, 1, OPTS( 0x55, 0x2A, 0 ), PAR_PERMS_READ_WRITE_TRIGGER },
{ CID_DISCR_P1, STR("DiscreteInpP1"), STR("on/off"), MB_DEVICE_ADDR1, MB_PARAM_DISCRETE, 2, 7,
DISCR_OFFSET(discrete_input_port1), PARAM_TYPE_U8, 1, OPTS( 0xAA, 0x15, 0 ), PAR_PERMS_READ_WRITE_TRIGGER }
}; };
// Calculate number of parameters in the table // Calculate number of parameters in the table
@@ -121,7 +124,7 @@ static void* master_get_param_data(const mb_parameter_descriptor_t* param_descri
break; break;
} }
} else { } else {
ESP_LOGE(TAG, "Wrong parameter offset for CID #%d", param_descriptor->cid); ESP_LOGE(TAG, "Wrong parameter offset for CID #%u", (unsigned)param_descriptor->cid);
assert(instance_ptr != NULL); assert(instance_ptr != NULL);
} }
return instance_ptr; return instance_ptr;
@@ -155,10 +158,10 @@ static void master_operation_func(void *arg)
err = mbc_master_get_parameter(cid, (char*)param_descriptor->param_key, err = mbc_master_get_parameter(cid, (char*)param_descriptor->param_key,
(uint8_t*)temp_data_ptr, &type); (uint8_t*)temp_data_ptr, &type);
if (err == ESP_OK) { if (err == ESP_OK) {
ESP_LOGI(TAG, "Characteristic #%d %s (%s) value = (0x%08x) read successful.", ESP_LOGI(TAG, "Characteristic #%u %s (%s) value = (0x%" PRIx32 ") read successful.",
param_descriptor->cid, param_descriptor->cid,
(char*)param_descriptor->param_key, param_descriptor->param_key,
(char*)param_descriptor->param_units, param_descriptor->param_units,
*(uint32_t*)temp_data_ptr); *(uint32_t*)temp_data_ptr);
// Initialize data of test array and write to slave // Initialize data of test array and write to slave
if (*(uint32_t*)temp_data_ptr != 0xAAAAAAAA) { if (*(uint32_t*)temp_data_ptr != 0xAAAAAAAA) {
@@ -167,37 +170,37 @@ static void master_operation_func(void *arg)
err = mbc_master_set_parameter(cid, (char*)param_descriptor->param_key, err = mbc_master_set_parameter(cid, (char*)param_descriptor->param_key,
(uint8_t*)temp_data_ptr, &type); (uint8_t*)temp_data_ptr, &type);
if (err == ESP_OK) { if (err == ESP_OK) {
ESP_LOGI(TAG, "Characteristic #%d %s (%s) value = (0x%08x), write successful.", ESP_LOGI(TAG, "Characteristic #%u %s (%s) value = (0x%" PRIx32 "), write successful.",
param_descriptor->cid, param_descriptor->cid,
(char*)param_descriptor->param_key, param_descriptor->param_key,
(char*)param_descriptor->param_units, param_descriptor->param_units,
*(uint32_t*)temp_data_ptr); *(uint32_t*)temp_data_ptr);
} else { } else {
ESP_LOGE(TAG, "Characteristic #%d (%s) write fail, err = 0x%x (%s).", ESP_LOGE(TAG, "Characteristic #%u (%s) write fail, err = 0x%x (%s).",
param_descriptor->cid, param_descriptor->cid,
(char*)param_descriptor->param_key, param_descriptor->param_key,
(int)err, (int)err,
(char*)esp_err_to_name(err)); (char*)esp_err_to_name(err));
} }
} }
} else { } else {
ESP_LOGE(TAG, "Characteristic #%d (%s) read fail, err = 0x%x (%s).", ESP_LOGE(TAG, "Characteristic #%u (%s) read fail, err = 0x%x (%s).",
param_descriptor->cid, param_descriptor->cid,
(char*)param_descriptor->param_key, param_descriptor->param_key,
(int)err, (int)err,
(char*)esp_err_to_name(err)); (char*)esp_err_to_name(err));
} }
} else { } else {
err = mbc_master_get_parameter(cid, (char*)param_descriptor->param_key, err = mbc_master_get_parameter(cid, (char*)param_descriptor->param_key,
(uint8_t*)&value, &type); (uint8_t*)temp_data_ptr, &type);
if (err == ESP_OK) { if (err == ESP_OK) {
*(float*)temp_data_ptr = value;
if ((param_descriptor->mb_param_type == MB_PARAM_HOLDING) || if ((param_descriptor->mb_param_type == MB_PARAM_HOLDING) ||
(param_descriptor->mb_param_type == MB_PARAM_INPUT)) { (param_descriptor->mb_param_type == MB_PARAM_INPUT)) {
ESP_LOGI(TAG, "Characteristic #%d %s (%s) value = %f (0x%x) read successful.", value = *(float*)temp_data_ptr;
ESP_LOGI(TAG, "Characteristic #%u %s (%s) value = %f (0x%" PRIx32 ") read successful.",
param_descriptor->cid, param_descriptor->cid,
(char*)param_descriptor->param_key, param_descriptor->param_key,
(char*)param_descriptor->param_units, param_descriptor->param_units,
value, value,
*(uint32_t*)temp_data_ptr); *(uint32_t*)temp_data_ptr);
if (((value > param_descriptor->param_opts.max) || if (((value > param_descriptor->param_opts.max) ||
@@ -206,23 +209,34 @@ static void master_operation_func(void *arg)
break; break;
} }
} else { } else {
uint16_t state = *(uint16_t*)temp_data_ptr; uint8_t state = *(uint8_t*)temp_data_ptr;
const char* rw_str = (state & param_descriptor->param_opts.opt1) ? "ON" : "OFF"; const char* rw_str = (state & param_descriptor->param_opts.opt1) ? "ON" : "OFF";
ESP_LOGI(TAG, "Characteristic #%d %s (%s) value = %s (0x%x) read successful.", if ((state & param_descriptor->param_opts.opt2) == param_descriptor->param_opts.opt2) {
ESP_LOGI(TAG, "Characteristic #%u %s (%s) value = %s (0x%" PRIx8 ") read successful.",
param_descriptor->cid, param_descriptor->cid,
(char*)param_descriptor->param_key, param_descriptor->param_key,
(char*)param_descriptor->param_units, param_descriptor->param_units,
(const char*)rw_str, (const char*)rw_str,
*(uint16_t*)temp_data_ptr); *(uint8_t*)temp_data_ptr);
} else {
ESP_LOGE(TAG, "Characteristic #%u %s (%s) value = %s (0x%" PRIx8 "), unexpected value.",
param_descriptor->cid,
param_descriptor->param_key,
param_descriptor->param_units,
(const char*)rw_str,
*(uint8_t*)temp_data_ptr);
alarm_state = true;
break;
}
if (state & param_descriptor->param_opts.opt1) { if (state & param_descriptor->param_opts.opt1) {
alarm_state = true; alarm_state = true;
break; break;
} }
} }
} else { } else {
ESP_LOGE(TAG, "Characteristic #%d (%s) read fail, err = 0x%x (%s).", ESP_LOGE(TAG, "Characteristic #%u (%s) read fail, err = 0x%x (%s).",
param_descriptor->cid, param_descriptor->cid,
(char*)param_descriptor->param_key, param_descriptor->param_key,
(int)err, (int)err,
(char*)esp_err_to_name(err)); (char*)esp_err_to_name(err));
} }
@@ -230,15 +244,13 @@ static void master_operation_func(void *arg)
vTaskDelay(POLL_TIMEOUT_TICS); // timeout between polls vTaskDelay(POLL_TIMEOUT_TICS); // timeout between polls
} }
} }
vTaskDelay(UPDATE_CIDS_TIMEOUT_TICS); // vTaskDelay(UPDATE_CIDS_TIMEOUT_TICS);
} }
if (alarm_state) { if (alarm_state) {
ESP_LOGI(TAG, "Alarm triggered by cid #%d.", ESP_LOGI(TAG, "Alarm triggered by cid #%u.", param_descriptor->cid);
param_descriptor->cid);
} else { } else {
ESP_LOGE(TAG, "Alarm is not triggered after %d retries.", ESP_LOGE(TAG, "Alarm is not triggered after %u retries.", MASTER_MAX_RETRY);
MASTER_MAX_RETRY);
} }
ESP_LOGI(TAG, "Destroy master..."); ESP_LOGI(TAG, "Destroy master...");
ESP_ERROR_CHECK(mbc_master_destroy()); ESP_ERROR_CHECK(mbc_master_destroy());
@@ -264,34 +276,30 @@ static esp_err_t master_init(void)
MB_RETURN_ON_FALSE((master_handler != NULL), ESP_ERR_INVALID_STATE, TAG, MB_RETURN_ON_FALSE((master_handler != NULL), ESP_ERR_INVALID_STATE, TAG,
"mb controller initialization fail."); "mb controller initialization fail.");
MB_RETURN_ON_FALSE((err == ESP_OK), ESP_ERR_INVALID_STATE, TAG, MB_RETURN_ON_FALSE((err == ESP_OK), ESP_ERR_INVALID_STATE, TAG,
"mb controller initialization fail, returns(0x%x).", "mb controller initialization fail, returns(0x%x).", (int)err);
(uint32_t)err);
err = mbc_master_setup((void*)&comm); err = mbc_master_setup((void*)&comm);
MB_RETURN_ON_FALSE((err == ESP_OK), ESP_ERR_INVALID_STATE, TAG, MB_RETURN_ON_FALSE((err == ESP_OK), ESP_ERR_INVALID_STATE, TAG,
"mb controller setup fail, returns(0x%x).", "mb controller setup fail, returns(0x%x).", (int)err);
(uint32_t)err);
// Set UART pin numbers // Set UART pin numbers
err = uart_set_pin(MB_PORT_NUM, CONFIG_MB_UART_TXD, CONFIG_MB_UART_RXD, err = uart_set_pin(MB_PORT_NUM, CONFIG_MB_UART_TXD, CONFIG_MB_UART_RXD,
CONFIG_MB_UART_RTS, UART_PIN_NO_CHANGE); CONFIG_MB_UART_RTS, UART_PIN_NO_CHANGE);
MB_RETURN_ON_FALSE((err == ESP_OK), ESP_ERR_INVALID_STATE, TAG, MB_RETURN_ON_FALSE((err == ESP_OK), ESP_ERR_INVALID_STATE, TAG,
"mb serial set pin failure, uart_set_pin() returned (0x%x).", (uint32_t)err); "mb serial set pin failure, uart_set_pin() returned (0x%x).", (int)err);
err = mbc_master_start(); err = mbc_master_start();
MB_RETURN_ON_FALSE((err == ESP_OK), ESP_ERR_INVALID_STATE, TAG, MB_RETURN_ON_FALSE((err == ESP_OK), ESP_ERR_INVALID_STATE, TAG,
"mb controller start fail, returns(0x%x).", "mb controller start fail, returned (0x%x).", (int)err);
(uint32_t)err);
// Set driver mode to Half Duplex // Set driver mode to Half Duplex
err = uart_set_mode(MB_PORT_NUM, UART_MODE_RS485_HALF_DUPLEX); err = uart_set_mode(MB_PORT_NUM, UART_MODE_RS485_HALF_DUPLEX);
MB_RETURN_ON_FALSE((err == ESP_OK), ESP_ERR_INVALID_STATE, TAG, MB_RETURN_ON_FALSE((err == ESP_OK), ESP_ERR_INVALID_STATE, TAG,
"mb serial set mode failure, uart_set_mode() returned (0x%x).", (uint32_t)err); "mb serial set mode failure, uart_set_mode() returned (0x%x).", (int)err);
vTaskDelay(5); vTaskDelay(5);
err = mbc_master_set_descriptor(&device_parameters[0], num_device_parameters); err = mbc_master_set_descriptor(&device_parameters[0], num_device_parameters);
MB_RETURN_ON_FALSE((err == ESP_OK), ESP_ERR_INVALID_STATE, TAG, MB_RETURN_ON_FALSE((err == ESP_OK), ESP_ERR_INVALID_STATE, TAG,
"mb controller set descriptor fail, returns(0x%x).", "mb controller set descriptor fail, returns(0x%x).", (int)err);
(uint32_t)err);
ESP_LOGI(TAG, "Modbus master stack initialized..."); ESP_LOGI(TAG, "Modbus master stack initialized...");
return err; return err;
} }

1
examples/protocols/modbus/serial/mb_slave/main/CMakeLists.txt
View File

@@ -2,4 +2,3 @@ set(PROJECT_NAME "modbus_slave")
idf_component_register(SRCS "slave.c" idf_component_register(SRCS "slave.c"
INCLUDE_DIRS ".") INCLUDE_DIRS ".")
target_compile_options(${COMPONENT_LIB} PRIVATE "-Wno-format")

42
examples/protocols/modbus/serial/mb_slave/main/slave.c
View File

@@ -1,5 +1,5 @@
/* /*
* SPDX-FileCopyrightText: 2016-2022 Espressif Systems (Shanghai) CO LTD * SPDX-FileCopyrightText: 2016-2023 Espressif Systems (Shanghai) CO LTD
* *
* SPDX-License-Identifier: Apache-2.0 * SPDX-License-Identifier: Apache-2.0
*/ */
@@ -182,13 +182,13 @@ void app_main(void)
if(event & (MB_EVENT_HOLDING_REG_WR | MB_EVENT_HOLDING_REG_RD)) { if(event & (MB_EVENT_HOLDING_REG_WR | MB_EVENT_HOLDING_REG_RD)) {
// Get parameter information from parameter queue // Get parameter information from parameter queue
ESP_ERROR_CHECK(mbc_slave_get_param_info(&reg_info, MB_PAR_INFO_GET_TOUT)); ESP_ERROR_CHECK(mbc_slave_get_param_info(&reg_info, MB_PAR_INFO_GET_TOUT));
ESP_LOGI(TAG, "HOLDING %s (%u us), ADDR:%u, TYPE:%u, INST_ADDR:0x%.4x, SIZE:%u", ESP_LOGI(TAG, "HOLDING %s (%" PRIu32 " us), ADDR:%u, TYPE:%u, INST_ADDR:0x%" PRIx32 ", SIZE:%u",
rw_str, rw_str,
(uint32_t)reg_info.time_stamp, reg_info.time_stamp,
(uint32_t)reg_info.mb_offset, (unsigned)reg_info.mb_offset,
(uint32_t)reg_info.type, (unsigned)reg_info.type,
(uint32_t)reg_info.address, (uint32_t)reg_info.address,
(uint32_t)reg_info.size); (unsigned)reg_info.size);
if (reg_info.address == (uint8_t*)&holding_reg_params.holding_data0) if (reg_info.address == (uint8_t*)&holding_reg_params.holding_data0)
{ {
portENTER_CRITICAL(&param_lock); portENTER_CRITICAL(&param_lock);
@@ -200,29 +200,29 @@ void app_main(void)
} }
} else if (event & MB_EVENT_INPUT_REG_RD) { } else if (event & MB_EVENT_INPUT_REG_RD) {
ESP_ERROR_CHECK(mbc_slave_get_param_info(&reg_info, MB_PAR_INFO_GET_TOUT)); ESP_ERROR_CHECK(mbc_slave_get_param_info(&reg_info, MB_PAR_INFO_GET_TOUT));
ESP_LOGI(TAG, "INPUT READ (%u us), ADDR:%u, TYPE:%u, INST_ADDR:0x%.4x, SIZE:%u", ESP_LOGI(TAG, "INPUT READ (%" PRIu32 " us), ADDR:%u, TYPE:%u, INST_ADDR:0x%" PRIx32 ", SIZE:%u",
(uint32_t)reg_info.time_stamp, reg_info.time_stamp,
(uint32_t)reg_info.mb_offset, (unsigned)reg_info.mb_offset,
(uint32_t)reg_info.type, (unsigned)reg_info.type,
(uint32_t)reg_info.address, (uint32_t)reg_info.address,
(uint32_t)reg_info.size); (unsigned)reg_info.size);
} else if (event & MB_EVENT_DISCRETE_RD) { } else if (event & MB_EVENT_DISCRETE_RD) {
ESP_ERROR_CHECK(mbc_slave_get_param_info(&reg_info, MB_PAR_INFO_GET_TOUT)); ESP_ERROR_CHECK(mbc_slave_get_param_info(&reg_info, MB_PAR_INFO_GET_TOUT));
ESP_LOGI(TAG, "DISCRETE READ (%u us): ADDR:%u, TYPE:%u, INST_ADDR:0x%.4x, SIZE:%u", ESP_LOGI(TAG, "DISCRETE READ (%" PRIu32 " us): ADDR:%u, TYPE:%u, INST_ADDR:0x%" PRIx32 ", SIZE:%u",
(uint32_t)reg_info.time_stamp, reg_info.time_stamp,
(uint32_t)reg_info.mb_offset, (unsigned)reg_info.mb_offset,
(uint32_t)reg_info.type, (unsigned)reg_info.type,
(uint32_t)reg_info.address, (uint32_t)reg_info.address,
(uint32_t)reg_info.size); (unsigned)reg_info.size);
} else if (event & (MB_EVENT_COILS_RD | MB_EVENT_COILS_WR)) { } else if (event & (MB_EVENT_COILS_RD | MB_EVENT_COILS_WR)) {
ESP_ERROR_CHECK(mbc_slave_get_param_info(&reg_info, MB_PAR_INFO_GET_TOUT)); ESP_ERROR_CHECK(mbc_slave_get_param_info(&reg_info, MB_PAR_INFO_GET_TOUT));
ESP_LOGI(TAG, "COILS %s (%u us), ADDR:%u, TYPE:%u, INST_ADDR:0x%.4x, SIZE:%u", ESP_LOGI(TAG, "COILS %s (%" PRIu32 " us), ADDR:%u, TYPE:%u, INST_ADDR:0x%" PRIx32 ", SIZE:%u",
rw_str, rw_str,
(uint32_t)reg_info.time_stamp, reg_info.time_stamp,
(uint32_t)reg_info.mb_offset, (unsigned)reg_info.mb_offset,
(uint32_t)reg_info.type, (unsigned)reg_info.type,
(uint32_t)reg_info.address, (uint32_t)reg_info.address,
(uint32_t)reg_info.size); (unsigned)reg_info.size);
if (coil_reg_params.coils_port1 == 0xFF) break; if (coil_reg_params.coils_port1 == 0xFF) break;
} }
} }

1
examples/protocols/modbus/tcp/mb_tcp_master/main/CMakeLists.txt
View File

@@ -2,4 +2,3 @@ set(PROJECT_NAME "modbus_tcp_master")
idf_component_register(SRCS "tcp_master.c" idf_component_register(SRCS "tcp_master.c"
INCLUDE_DIRS ".") INCLUDE_DIRS ".")
target_compile_options(${COMPONENT_LIB} PRIVATE "-Wno-format")

132
examples/protocols/modbus/tcp/mb_tcp_master/main/tcp_master.c
View File

@@ -1,5 +1,5 @@
/* /*
* SPDX-FileCopyrightText: 2016-2022 Espressif Systems (Shanghai) CO LTD * SPDX-FileCopyrightText: 2016-2023 Espressif Systems (Shanghai) CO LTD
* *
* SPDX-License-Identifier: Apache-2.0 * SPDX-License-Identifier: Apache-2.0
*/ */
@@ -11,11 +11,12 @@
#include "esp_log.h" #include "esp_log.h"
#include "esp_system.h" #include "esp_system.h"
#include "esp_wifi.h" #include "esp_wifi.h"
#include "esp_mac.h"
#include "esp_event.h" #include "esp_event.h"
#include "esp_log.h" #include "esp_log.h"
#include "nvs_flash.h" #include "nvs_flash.h"
#include "esp_netif.h" #include "esp_netif.h"
#include "esp_mac.h"
#include "mdns.h" #include "mdns.h"
#include "protocol_examples_common.h" #include "protocol_examples_common.h"
@@ -69,7 +70,7 @@ static const char *TAG = "MASTER_TEST";
// Enumeration of modbus device addresses accessed by master device // Enumeration of modbus device addresses accessed by master device
// Each address in the table is a index of TCP slave ip address in mb_communication_info_t::tcp_ip_addr table // Each address in the table is a index of TCP slave ip address in mb_communication_info_t::tcp_ip_addr table
enum { enum {
MB_DEVICE_ADDR1 = 1, // Slave address 1 MB_DEVICE_ADDR1 = 1, // Slave UID = 1
MB_DEVICE_ADDR2 = 200, MB_DEVICE_ADDR2 = 200,
MB_DEVICE_ADDR3 = 35 MB_DEVICE_ADDR3 = 35
}; };
@@ -85,6 +86,7 @@ enum {
CID_HOLD_TEST_REG, CID_HOLD_TEST_REG,
CID_RELAY_P1, CID_RELAY_P1,
CID_RELAY_P2, CID_RELAY_P2,
CID_DISCR_P1,
CID_COUNT CID_COUNT
}; };
@@ -102,7 +104,7 @@ const mb_parameter_descriptor_t device_parameters[] = {
{ CID_INP_DATA_0, STR("Data_channel_0"), STR("Volts"), MB_DEVICE_ADDR1, MB_PARAM_INPUT, 0, 2, { CID_INP_DATA_0, STR("Data_channel_0"), STR("Volts"), MB_DEVICE_ADDR1, MB_PARAM_INPUT, 0, 2,
INPUT_OFFSET(input_data0), PARAM_TYPE_FLOAT, 4, OPTS( -10, 10, 1 ), PAR_PERMS_READ_WRITE_TRIGGER }, INPUT_OFFSET(input_data0), PARAM_TYPE_FLOAT, 4, OPTS( -10, 10, 1 ), PAR_PERMS_READ_WRITE_TRIGGER },
{ CID_HOLD_DATA_0, STR("Humidity_1"), STR("%rH"), MB_DEVICE_ADDR1, MB_PARAM_HOLDING, 0, 2, { CID_HOLD_DATA_0, STR("Humidity_1"), STR("%rH"), MB_DEVICE_ADDR1, MB_PARAM_HOLDING, 0, 2,
HOLD_OFFSET(holding_data0), PARAM_TYPE_FLOAT, 4, OPTS( 0, 100, 1 ), PAR_PERMS_READ_WRITE_TRIGGER }, HOLD_OFFSET(holding_data0), PARAM_TYPE_FLOAT, 4, OPTS( 0, 1000, 1 ), PAR_PERMS_READ_WRITE_TRIGGER },
{ CID_INP_DATA_1, STR("Temperature_1"), STR("C"), MB_DEVICE_ADDR1, MB_PARAM_INPUT, 2, 2, { CID_INP_DATA_1, STR("Temperature_1"), STR("C"), MB_DEVICE_ADDR1, MB_PARAM_INPUT, 2, 2,
INPUT_OFFSET(input_data1), PARAM_TYPE_FLOAT, 4, OPTS( -40, 100, 1 ), PAR_PERMS_READ_WRITE_TRIGGER }, INPUT_OFFSET(input_data1), PARAM_TYPE_FLOAT, 4, OPTS( -40, 100, 1 ), PAR_PERMS_READ_WRITE_TRIGGER },
{ CID_HOLD_DATA_1, STR("Humidity_2"), STR("%rH"), MB_DEVICE_ADDR2, MB_PARAM_HOLDING, 2, 2, { CID_HOLD_DATA_1, STR("Humidity_2"), STR("%rH"), MB_DEVICE_ADDR2, MB_PARAM_HOLDING, 2, 2,
@@ -111,12 +113,14 @@ const mb_parameter_descriptor_t device_parameters[] = {
INPUT_OFFSET(input_data2), PARAM_TYPE_FLOAT, 4, OPTS( -40, 100, 1 ), PAR_PERMS_READ_WRITE_TRIGGER }, INPUT_OFFSET(input_data2), PARAM_TYPE_FLOAT, 4, OPTS( -40, 100, 1 ), PAR_PERMS_READ_WRITE_TRIGGER },
{ CID_HOLD_DATA_2, STR("Humidity_3"), STR("%rH"), MB_DEVICE_ADDR3, MB_PARAM_HOLDING, 4, 2, { CID_HOLD_DATA_2, STR("Humidity_3"), STR("%rH"), MB_DEVICE_ADDR3, MB_PARAM_HOLDING, 4, 2,
HOLD_OFFSET(holding_data2), PARAM_TYPE_FLOAT, 4, OPTS( 0, 100, 1 ), PAR_PERMS_READ_WRITE_TRIGGER }, HOLD_OFFSET(holding_data2), PARAM_TYPE_FLOAT, 4, OPTS( 0, 100, 1 ), PAR_PERMS_READ_WRITE_TRIGGER },
{ CID_HOLD_TEST_REG, STR("Test_regs"), STR("__"), MB_DEVICE_ADDR1, MB_PARAM_HOLDING, 8, 100, { CID_HOLD_TEST_REG, STR("Test_regs"), STR("__"), MB_DEVICE_ADDR1, MB_PARAM_HOLDING, 10, 58,
HOLD_OFFSET(test_regs), PARAM_TYPE_ASCII, 200, OPTS( 0, 100, 1 ), PAR_PERMS_READ_WRITE_TRIGGER }, HOLD_OFFSET(test_regs), PARAM_TYPE_ASCII, 116, OPTS( 0, 100, 1 ), PAR_PERMS_READ_WRITE_TRIGGER },
{ CID_RELAY_P1, STR("RelayP1"), STR("on/off"), MB_DEVICE_ADDR1, MB_PARAM_COIL, 0, 8, { CID_RELAY_P1, STR("RelayP1"), STR("on/off"), MB_DEVICE_ADDR1, MB_PARAM_COIL, 2, 6,
COIL_OFFSET(coils_port0), PARAM_TYPE_U16, 1, OPTS( BIT1, 0, 0 ), PAR_PERMS_READ_WRITE_TRIGGER }, COIL_OFFSET(coils_port0), PARAM_TYPE_U8, 1, OPTS( 0xAA, 0x15, 0 ), PAR_PERMS_READ_WRITE_TRIGGER },
{ CID_RELAY_P2, STR("RelayP2"), STR("on/off"), MB_DEVICE_ADDR1, MB_PARAM_COIL, 8, 8, { CID_RELAY_P2, STR("RelayP2"), STR("on/off"), MB_DEVICE_ADDR1, MB_PARAM_COIL, 10, 6,
COIL_OFFSET(coils_port1), PARAM_TYPE_U16, 1, OPTS( BIT0, 0, 0 ), PAR_PERMS_READ_WRITE_TRIGGER } COIL_OFFSET(coils_port1), PARAM_TYPE_U8, 1, OPTS( 0x55, 0x2A, 0 ), PAR_PERMS_READ_WRITE_TRIGGER },
{ CID_DISCR_P1, STR("DiscreteInpP1"), STR("on/off"), MB_DEVICE_ADDR1, MB_PARAM_DISCRETE, 2, 7,
DISCR_OFFSET(discrete_input_port1), PARAM_TYPE_U8, 1, OPTS( 0xAA, 0x15, 0 ), PAR_PERMS_READ_WRITE_TRIGGER }
}; };
// Calculate number of parameters in the table // Calculate number of parameters in the table
@@ -146,7 +150,7 @@ const size_t ip_table_sz = (size_t)(sizeof(slave_ip_address_table) / sizeof(slav
char* master_scan_addr(int* index, char* buffer) char* master_scan_addr(int* index, char* buffer)
{ {
char* ip_str = NULL; char* ip_str = NULL;
unsigned int a[8] = {0}; int a[8] = {0};
int buf_cnt = 0; int buf_cnt = 0;
#if !CONFIG_EXAMPLE_CONNECT_IPV6 #if !CONFIG_EXAMPLE_CONNECT_IPV6
buf_cnt = sscanf(buffer, "IP%d="IPSTR, index, &a[0], &a[1], &a[2], &a[3]); buf_cnt = sscanf(buffer, "IP%d="IPSTR, index, &a[0], &a[1], &a[2], &a[3]);
@@ -301,8 +305,8 @@ static esp_err_t master_resolve_slave(uint8_t short_addr, mdns_result_t* result,
char* slave_ip = NULL; char* slave_ip = NULL;
char slave_name[22] = {0}; char slave_name[22] = {0};
if (sprintf(slave_name, "mb_slave_tcp_%02X", short_addr) < 0) { if (sprintf(slave_name, "mb_slave_tcp_%02" PRIx8, (int)short_addr) < 0) {
ESP_LOGE(TAG, "Fail to create instance name for index: %d", short_addr); ESP_LOGE(TAG, "Fail to create instance name for index: %u", (unsigned)short_addr);
abort(); abort();
} }
for (; r ; r = r->next) { for (; r ; r = r->next) {
@@ -316,7 +320,7 @@ static esp_err_t master_resolve_slave(uint8_t short_addr, mdns_result_t* result,
if ((strcmp(r->instance_name, slave_name) == 0) && (r->port == CONFIG_FMB_TCP_PORT_DEFAULT)) { if ((strcmp(r->instance_name, slave_name) == 0) && (r->port == CONFIG_FMB_TCP_PORT_DEFAULT)) {
printf(" PTR : %s\n", r->instance_name); printf(" PTR : %s\n", r->instance_name);
if (r->txt_count) { if (r->txt_count) {
printf(" TXT : [%u] ", r->txt_count); printf(" TXT : [%u] ", (unsigned)r->txt_count);
for ( t = 0; t < r->txt_count; t++) { for ( t = 0; t < r->txt_count; t++) {
printf("%s=%s; ", r->txt[t].key, r->txt[t].value?r->txt[t].value:"NULL"); printf("%s=%s; ", r->txt[t].key, r->txt[t].value?r->txt[t].value:"NULL");
} }
@@ -324,7 +328,7 @@ static esp_err_t master_resolve_slave(uint8_t short_addr, mdns_result_t* result,
} }
slave_ip = master_get_slave_ip_str(r->addr, addr_type); slave_ip = master_get_slave_ip_str(r->addr, addr_type);
if (slave_ip) { if (slave_ip) {
ESP_LOGI(TAG, "Resolved slave %s[%s]:%u", r->hostname, slave_ip, r->port); ESP_LOGI(TAG, "Resolved slave %s[%s]:%u", r->hostname, slave_ip, (unsigned)r->port);
*resolved_ip = slave_ip; *resolved_ip = slave_ip;
return ESP_OK; return ESP_OK;
} }
@@ -341,7 +345,8 @@ static int master_create_slave_list(mdns_result_t* results, char** addr_table,
if (!results) { if (!results) {
return -1; return -1;
} }
int i, slave_addr, cid_resolve_cnt = 0; int i, cid_resolve_cnt = 0;
uint8_t slave_addr = 0;
int ip_index = 0; int ip_index = 0;
const mb_parameter_descriptor_t* pdescr = &device_parameters[0]; const mb_parameter_descriptor_t* pdescr = &device_parameters[0];
char** ip_table = addr_table; char** ip_table = addr_table;
@@ -363,7 +368,7 @@ static int master_create_slave_list(mdns_result_t* results, char** addr_table,
// Resolve new slave IP address using its short address // Resolve new slave IP address using its short address
esp_err_t err = master_resolve_slave(slave_addr, results, &slave_ip, addr_type); esp_err_t err = master_resolve_slave(slave_addr, results, &slave_ip, addr_type);
if (err != ESP_OK) { if (err != ESP_OK) {
ESP_LOGE(TAG, "Index: %d, sl_addr: %d, failed to resolve!", i, slave_addr); ESP_LOGE(TAG, "Index: %d, sl_addr: %u, failed to resolve!", i, slave_addr);
// Set correspond index to NULL indicate host not resolved // Set correspond index to NULL indicate host not resolved
ip_table[ip_index] = NULL; ip_table[ip_index] = NULL;
continue; continue;
@@ -379,7 +384,7 @@ static int master_create_slave_list(mdns_result_t* results, char** addr_table,
new_slave_entry->p_data = NULL; new_slave_entry->p_data = NULL;
LIST_INSERT_HEAD(&slave_addr_list, new_slave_entry, entries); LIST_INSERT_HEAD(&slave_addr_list, new_slave_entry, entries);
ip_table[ip_index] = slave_ip; ip_table[ip_index] = slave_ip;
ESP_LOGI(TAG, "Index: %d, sl_addr: %d, resolved to IP: [%s]", ESP_LOGI(TAG, "Index: %d, sl_addr: %u, resolved to IP: [%s]",
i, slave_addr, slave_ip); i, slave_addr, slave_ip);
cid_resolve_cnt++; cid_resolve_cnt++;
if (ip_index < addr_table_size) { if (ip_index < addr_table_size) {
@@ -387,7 +392,7 @@ static int master_create_slave_list(mdns_result_t* results, char** addr_table,
} }
} else { } else {
ip_table[ip_index] = it ? it->ip_address : ip_table[ip_index]; ip_table[ip_index] = it ? it->ip_address : ip_table[ip_index];
ESP_LOGI(TAG, "Index: %d, sl_addr: %d, set to IP: [%s]", ESP_LOGI(TAG, "Index: %d, sl_addr: %u, set to IP: [%s]",
i, slave_addr, ip_table[ip_index]); i, slave_addr, ip_table[ip_index]);
cid_resolve_cnt++; cid_resolve_cnt++;
} }
@@ -425,7 +430,7 @@ static void master_destroy_slave_list(char** table, size_t ip_table_size)
{ {
#if CONFIG_MB_MDNS_IP_RESOLVER #if CONFIG_MB_MDNS_IP_RESOLVER
slave_addr_entry_t *it; slave_addr_entry_t *it;
LIST_FOREACH(it, &slave_addr_list, entries) { while ((it = LIST_FIRST(&slave_addr_list))) {
LIST_REMOVE(it, entries); LIST_REMOVE(it, entries);
free(it); free(it);
} }
@@ -467,7 +472,7 @@ static void* master_get_param_data(const mb_parameter_descriptor_t* param_descri
break; break;
} }
} else { } else {
ESP_LOGE(TAG, "Wrong parameter offset for CID #%d", param_descriptor->cid); ESP_LOGE(TAG, "Wrong parameter offset for CID #%u", param_descriptor->cid);
assert(instance_ptr != NULL); assert(instance_ptr != NULL);
} }
return instance_ptr; return instance_ptr;
@@ -501,10 +506,10 @@ static void master_operation_func(void *arg)
err = mbc_master_get_parameter(cid, (char*)param_descriptor->param_key, err = mbc_master_get_parameter(cid, (char*)param_descriptor->param_key,
(uint8_t*)temp_data_ptr, &type); (uint8_t*)temp_data_ptr, &type);
if (err == ESP_OK) { if (err == ESP_OK) {
ESP_LOGI(TAG, "Characteristic #%d %s (%s) value = (0x%08x) read successful.", ESP_LOGI(TAG, "Characteristic #%u %s (%s) value = (0x%" PRIx32 ") read successful.",
param_descriptor->cid, param_descriptor->cid,
(char*)param_descriptor->param_key, param_descriptor->param_key,
(char*)param_descriptor->param_units, param_descriptor->param_units,
*(uint32_t*)temp_data_ptr); *(uint32_t*)temp_data_ptr);
// Initialize data of test array and write to slave // Initialize data of test array and write to slave
if (*(uint32_t*)temp_data_ptr != 0xAAAAAAAA) { if (*(uint32_t*)temp_data_ptr != 0xAAAAAAAA) {
@@ -513,23 +518,23 @@ static void master_operation_func(void *arg)
err = mbc_master_set_parameter(cid, (char*)param_descriptor->param_key, err = mbc_master_set_parameter(cid, (char*)param_descriptor->param_key,
(uint8_t*)temp_data_ptr, &type); (uint8_t*)temp_data_ptr, &type);
if (err == ESP_OK) { if (err == ESP_OK) {
ESP_LOGI(TAG, "Characteristic #%d %s (%s) value = (0x%08x), write successful.", ESP_LOGI(TAG, "Characteristic #%u %s (%s) value = (0x%" PRIx32 "), write successful.",
param_descriptor->cid, param_descriptor->cid,
(char*)param_descriptor->param_key, param_descriptor->param_key,
(char*)param_descriptor->param_units, param_descriptor->param_units,
*(uint32_t*)temp_data_ptr); *(uint32_t*)temp_data_ptr);
} else { } else {
ESP_LOGE(TAG, "Characteristic #%d (%s) write fail, err = 0x%x (%s).", ESP_LOGE(TAG, "Characteristic #%u (%s) write fail, err = 0x%x (%s).",
param_descriptor->cid, param_descriptor->cid,
(char*)param_descriptor->param_key, param_descriptor->param_key,
(int)err, (int)err,
(char*)esp_err_to_name(err)); (char*)esp_err_to_name(err));
} }
} }
} else { } else {
ESP_LOGE(TAG, "Characteristic #%d (%s) read fail, err = 0x%x (%s).", ESP_LOGE(TAG, "Characteristic #%u (%s) read fail, err = 0x%x (%s).",
param_descriptor->cid, param_descriptor->cid,
(char*)param_descriptor->param_key, param_descriptor->param_key,
(int)err, (int)err,
(char*)esp_err_to_name(err)); (char*)esp_err_to_name(err));
} }
@@ -540,10 +545,10 @@ static void master_operation_func(void *arg)
if ((param_descriptor->mb_param_type == MB_PARAM_HOLDING) || if ((param_descriptor->mb_param_type == MB_PARAM_HOLDING) ||
(param_descriptor->mb_param_type == MB_PARAM_INPUT)) { (param_descriptor->mb_param_type == MB_PARAM_INPUT)) {
value = *(float*)temp_data_ptr; value = *(float*)temp_data_ptr;
ESP_LOGI(TAG, "Characteristic #%d %s (%s) value = %f (0x%x) read successful.", ESP_LOGI(TAG, "Characteristic #%u %s (%s) value = %f (0x%" PRIx32 ") read successful.",
param_descriptor->cid, param_descriptor->cid,
(char*)param_descriptor->param_key, param_descriptor->param_key,
(char*)param_descriptor->param_units, param_descriptor->param_units,
value, value,
*(uint32_t*)temp_data_ptr); *(uint32_t*)temp_data_ptr);
if (((value > param_descriptor->param_opts.max) || if (((value > param_descriptor->param_opts.max) ||
@@ -554,21 +559,32 @@ static void master_operation_func(void *arg)
} else { } else {
uint8_t state = *(uint8_t*)temp_data_ptr; uint8_t state = *(uint8_t*)temp_data_ptr;
const char* rw_str = (state & param_descriptor->param_opts.opt1) ? "ON" : "OFF"; const char* rw_str = (state & param_descriptor->param_opts.opt1) ? "ON" : "OFF";
ESP_LOGI(TAG, "Characteristic #%d %s (%s) value = %s (0x%x) read successful.", if ((state & param_descriptor->param_opts.opt2) == param_descriptor->param_opts.opt2) {
ESP_LOGI(TAG, "Characteristic #%u %s (%s) value = %s (0x%" PRIx8 ") read successful.",
param_descriptor->cid, param_descriptor->cid,
(char*)param_descriptor->param_key, param_descriptor->param_key,
(char*)param_descriptor->param_units, param_descriptor->param_units,
(const char*)rw_str, rw_str,
*(uint8_t*)temp_data_ptr); *(uint8_t*)temp_data_ptr);
} else {
ESP_LOGE(TAG, "Characteristic #%u %s (%s) value = %s (0x%" PRIx8 "), unexpected value.",
param_descriptor->cid,
param_descriptor->param_key,
param_descriptor->param_units,
rw_str,
*(uint8_t*)temp_data_ptr);
alarm_state = true;
break;
}
if (state & param_descriptor->param_opts.opt1) { if (state & param_descriptor->param_opts.opt1) {
alarm_state = true; alarm_state = true;
break; break;
} }
} }
} else { } else {
ESP_LOGE(TAG, "Characteristic #%d (%s) read fail, err = 0x%x (%s).", ESP_LOGE(TAG, "Characteristic #%u (%s) read fail, err = 0x%x (%s).",
param_descriptor->cid, param_descriptor->cid,
(char*)param_descriptor->param_key, param_descriptor->param_key,
(int)err, (int)err,
(char*)esp_err_to_name(err)); (char*)esp_err_to_name(err));
} }
@@ -580,10 +596,9 @@ static void master_operation_func(void *arg)
} }
if (alarm_state) { if (alarm_state) {
ESP_LOGI(TAG, "Alarm triggered by cid #%d.", ESP_LOGI(TAG, "Alarm triggered by cid #%u.", param_descriptor->cid);
param_descriptor->cid);
} else { } else {
ESP_LOGE(TAG, "Alarm is not triggered after %d retries.", ESP_LOGE(TAG, "Alarm is not triggered after %u retries.",
MASTER_MAX_RETRY); MASTER_MAX_RETRY);
} }
ESP_LOGI(TAG, "Destroy master..."); ESP_LOGI(TAG, "Destroy master...");
@@ -600,17 +615,17 @@ static esp_err_t init_services(mb_tcp_addr_type_t ip_addr_type)
MB_RETURN_ON_FALSE((result == ESP_OK), ESP_ERR_INVALID_STATE, MB_RETURN_ON_FALSE((result == ESP_OK), ESP_ERR_INVALID_STATE,
TAG, TAG,
"nvs_flash_init fail, returns(0x%x).", "nvs_flash_init fail, returns(0x%x).",
(uint32_t)result); (int)result);
result = esp_netif_init(); result = esp_netif_init();
MB_RETURN_ON_FALSE((result == ESP_OK), ESP_ERR_INVALID_STATE, MB_RETURN_ON_FALSE((result == ESP_OK), ESP_ERR_INVALID_STATE,
TAG, TAG,
"esp_netif_init fail, returns(0x%x).", "esp_netif_init fail, returns(0x%x).",
(uint32_t)result); (int)result);
result = esp_event_loop_create_default(); result = esp_event_loop_create_default();
MB_RETURN_ON_FALSE((result == ESP_OK), ESP_ERR_INVALID_STATE, MB_RETURN_ON_FALSE((result == ESP_OK), ESP_ERR_INVALID_STATE,
TAG, TAG,
"esp_event_loop_create_default fail, returns(0x%x).", "esp_event_loop_create_default fail, returns(0x%x).",
(uint32_t)result); (int)result);
#if CONFIG_MB_MDNS_IP_RESOLVER #if CONFIG_MB_MDNS_IP_RESOLVER
// Start mdns service and register device // Start mdns service and register device
master_start_mdns_service(); master_start_mdns_service();
@@ -622,13 +637,13 @@ static esp_err_t init_services(mb_tcp_addr_type_t ip_addr_type)
MB_RETURN_ON_FALSE((result == ESP_OK), ESP_ERR_INVALID_STATE, MB_RETURN_ON_FALSE((result == ESP_OK), ESP_ERR_INVALID_STATE,
TAG, TAG,
"example_connect fail, returns(0x%x).", "example_connect fail, returns(0x%x).",
(uint32_t)result); (int)result);
#if CONFIG_EXAMPLE_CONNECT_WIFI #if CONFIG_EXAMPLE_CONNECT_WIFI
result = esp_wifi_set_ps(WIFI_PS_NONE); result = esp_wifi_set_ps(WIFI_PS_NONE);
MB_RETURN_ON_FALSE((result == ESP_OK), ESP_ERR_INVALID_STATE, MB_RETURN_ON_FALSE((result == ESP_OK), ESP_ERR_INVALID_STATE,
TAG, TAG,
"esp_wifi_set_ps fail, returns(0x%x).", "esp_wifi_set_ps fail, returns(0x%x).",
(uint32_t)result); (int)result);
#endif #endif
#if CONFIG_MB_MDNS_IP_RESOLVER #if CONFIG_MB_MDNS_IP_RESOLVER
int res = 0; int res = 0;
@@ -636,7 +651,7 @@ static esp_err_t init_services(mb_tcp_addr_type_t ip_addr_type)
res = master_query_slave_service("_modbus", "_tcp", ip_addr_type); res = master_query_slave_service("_modbus", "_tcp", ip_addr_type);
} }
if (res < num_device_parameters) { if (res < num_device_parameters) {
ESP_LOGE(TAG, "Could not resolve one or more slave IP addresses, resolved: %d out of %d.", res, num_device_parameters ); ESP_LOGE(TAG, "Could not resolve one or more slave IP addresses, resolved: %d out of %u.", res, (unsigned)num_device_parameters );
ESP_LOGE(TAG, "Make sure you configured all slaves according to device parameter table and they alive in the network."); ESP_LOGE(TAG, "Make sure you configured all slaves according to device parameter table and they alive in the network.");
return ESP_ERR_NOT_FOUND; return ESP_ERR_NOT_FOUND;
} }
@@ -662,22 +677,22 @@ static esp_err_t destroy_services(void)
MB_RETURN_ON_FALSE((err == ESP_OK), ESP_ERR_INVALID_STATE, MB_RETURN_ON_FALSE((err == ESP_OK), ESP_ERR_INVALID_STATE,
TAG, TAG,
"example_disconnect fail, returns(0x%x).", "example_disconnect fail, returns(0x%x).",
(uint32_t)err); (int)err);
err = esp_event_loop_delete_default(); err = esp_event_loop_delete_default();
MB_RETURN_ON_FALSE((err == ESP_OK), ESP_ERR_INVALID_STATE, MB_RETURN_ON_FALSE((err == ESP_OK), ESP_ERR_INVALID_STATE,
TAG, TAG,
"esp_event_loop_delete_default fail, returns(0x%x).", "esp_event_loop_delete_default fail, returns(0x%x).",
(uint32_t)err); (int)err);
err = esp_netif_deinit(); err = esp_netif_deinit();
MB_RETURN_ON_FALSE((err == ESP_OK || err == ESP_ERR_NOT_SUPPORTED), ESP_ERR_INVALID_STATE, MB_RETURN_ON_FALSE((err == ESP_OK || err == ESP_ERR_NOT_SUPPORTED), ESP_ERR_INVALID_STATE,
TAG, TAG,
"esp_netif_deinit fail, returns(0x%x).", "esp_netif_deinit fail, returns(0x%x).",
(uint32_t)err); (int)err);
err = nvs_flash_deinit(); err = nvs_flash_deinit();
MB_RETURN_ON_FALSE((err == ESP_OK), ESP_ERR_INVALID_STATE, MB_RETURN_ON_FALSE((err == ESP_OK), ESP_ERR_INVALID_STATE,
TAG, TAG,
"nvs_flash_deinit fail, returns(0x%x).", "nvs_flash_deinit fail, returns(0x%x).",
(uint32_t)err); (int)err);
return err; return err;
} }
@@ -693,26 +708,26 @@ static esp_err_t master_init(mb_communication_info_t* comm_info)
MB_RETURN_ON_FALSE((err == ESP_OK), ESP_ERR_INVALID_STATE, MB_RETURN_ON_FALSE((err == ESP_OK), ESP_ERR_INVALID_STATE,
TAG, TAG,
"mb controller initialization fail, returns(0x%x).", "mb controller initialization fail, returns(0x%x).",
(uint32_t)err); (int)err);
err = mbc_master_setup((void*)comm_info); err = mbc_master_setup((void*)comm_info);
MB_RETURN_ON_FALSE((err == ESP_OK), ESP_ERR_INVALID_STATE, MB_RETURN_ON_FALSE((err == ESP_OK), ESP_ERR_INVALID_STATE,
TAG, TAG,
"mb controller setup fail, returns(0x%x).", "mb controller setup fail, returns(0x%x).",
(uint32_t)err); (int)err);
err = mbc_master_set_descriptor(&device_parameters[0], num_device_parameters); err = mbc_master_set_descriptor(&device_parameters[0], num_device_parameters);
MB_RETURN_ON_FALSE((err == ESP_OK), ESP_ERR_INVALID_STATE, MB_RETURN_ON_FALSE((err == ESP_OK), ESP_ERR_INVALID_STATE,
TAG, TAG,
"mb controller set descriptor fail, returns(0x%x).", "mb controller set descriptor fail, returns(0x%x).",
(uint32_t)err); (int)err);
ESP_LOGI(TAG, "Modbus master stack initialized..."); ESP_LOGI(TAG, "Modbus master stack initialized...");
err = mbc_master_start(); err = mbc_master_start();
MB_RETURN_ON_FALSE((err == ESP_OK), ESP_ERR_INVALID_STATE, MB_RETURN_ON_FALSE((err == ESP_OK), ESP_ERR_INVALID_STATE,
TAG, TAG,
"mb controller start fail, returns(0x%x).", "mb controller start fail, returns(0x%x).",
(uint32_t)err); (int)err);
vTaskDelay(5); vTaskDelay(5);
return err; return err;
} }
@@ -723,7 +738,7 @@ static esp_err_t master_destroy(void)
MB_RETURN_ON_FALSE((err == ESP_OK), ESP_ERR_INVALID_STATE, MB_RETURN_ON_FALSE((err == ESP_OK), ESP_ERR_INVALID_STATE,
TAG, TAG,
"mbc_master_destroy fail, returns(0x%x).", "mbc_master_destroy fail, returns(0x%x).",
(uint32_t)err); (int)err);
ESP_LOGI(TAG, "Modbus master stack destroy..."); ESP_LOGI(TAG, "Modbus master stack destroy...");
return err; return err;
} }
@@ -746,7 +761,6 @@ void app_main(void)
comm_info.ip_netif_ptr = (void*)get_example_netif(); comm_info.ip_netif_ptr = (void*)get_example_netif();
ESP_ERROR_CHECK(master_init(&comm_info)); ESP_ERROR_CHECK(master_init(&comm_info));
vTaskDelay(50);
master_operation_func(NULL); master_operation_func(NULL);
ESP_ERROR_CHECK(master_destroy()); ESP_ERROR_CHECK(master_destroy());

1
examples/protocols/modbus/tcp/mb_tcp_slave/main/CMakeLists.txt
View File

@@ -2,4 +2,3 @@ set(PROJECT_NAME "modbus_tcp_slave")
idf_component_register(SRCS "tcp_slave.c" idf_component_register(SRCS "tcp_slave.c"
INCLUDE_DIRS ".") INCLUDE_DIRS ".")
target_compile_options(${COMPONENT_LIB} PRIVATE "-Wno-format")

88
examples/protocols/modbus/tcp/mb_tcp_slave/main/tcp_slave.c
View File

@@ -1,5 +1,5 @@
/* /*
* SPDX-FileCopyrightText: 2016-2022 Espressif Systems (Shanghai) CO LTD * SPDX-FileCopyrightText: 2016-2023 Espressif Systems (Shanghai) CO LTD
* *
* SPDX-License-Identifier: Apache-2.0 * SPDX-License-Identifier: Apache-2.0
*/ */
@@ -12,13 +12,13 @@
#include "esp_log.h" #include "esp_log.h"
#include "esp_system.h" #include "esp_system.h"
#include "esp_wifi.h" #include "esp_wifi.h"
#include "esp_mac.h"
#include "esp_event.h" #include "esp_event.h"
#include "esp_log.h" #include "esp_log.h"
#include "nvs_flash.h" #include "nvs_flash.h"
#include "mdns.h" #include "mdns.h"
#include "esp_netif.h" #include "esp_netif.h"
#include "esp_mac.h"
#include "protocol_examples_common.h" #include "protocol_examples_common.h"
#include "mbcontroller.h" // for mbcontroller defines and api #include "mbcontroller.h" // for mbcontroller defines and api
@@ -49,6 +49,8 @@
| MB_EVENT_COILS_WR) | MB_EVENT_COILS_WR)
#define MB_READ_WRITE_MASK (MB_READ_MASK | MB_WRITE_MASK) #define MB_READ_WRITE_MASK (MB_READ_MASK | MB_WRITE_MASK)
#define MB_SLAVE_ADDR (CONFIG_MB_SLAVE_ADDR)
static const char *TAG = "SLAVE_TEST"; static const char *TAG = "SLAVE_TEST";
static portMUX_TYPE param_lock = portMUX_INITIALIZER_UNLOCKED; static portMUX_TYPE param_lock = portMUX_INITIALIZER_UNLOCKED;
@@ -66,8 +68,6 @@ static portMUX_TYPE param_lock = portMUX_INITIALIZER_UNLOCKED;
#define MB_DEVICE_ID (uint32_t)CONFIG_FMB_CONTROLLER_SLAVE_ID #define MB_DEVICE_ID (uint32_t)CONFIG_FMB_CONTROLLER_SLAVE_ID
#endif #endif
#define MB_SLAVE_ADDR (CONFIG_MB_SLAVE_ADDR)
#define MB_MDNS_INSTANCE(pref) pref"mb_slave_tcp" #define MB_MDNS_INSTANCE(pref) pref"mb_slave_tcp"
// convert mac from binary format to string // convert mac from binary format to string
@@ -175,13 +175,13 @@ static void slave_operation_func(void *arg)
if(event & (MB_EVENT_HOLDING_REG_WR | MB_EVENT_HOLDING_REG_RD)) { if(event & (MB_EVENT_HOLDING_REG_WR | MB_EVENT_HOLDING_REG_RD)) {
// Get parameter information from parameter queue // Get parameter information from parameter queue
ESP_ERROR_CHECK(mbc_slave_get_param_info(&reg_info, MB_PAR_INFO_GET_TOUT)); ESP_ERROR_CHECK(mbc_slave_get_param_info(&reg_info, MB_PAR_INFO_GET_TOUT));
ESP_LOGI(TAG, "HOLDING %s (%u us), ADDR:%u, TYPE:%u, INST_ADDR:0x%.4x, SIZE:%u", ESP_LOGI(TAG, "HOLDING %s (%" PRIu32 " us), ADDR:%u, TYPE:%u, INST_ADDR:0x%" PRIx32 ", SIZE:%u",
rw_str, rw_str,
(uint32_t)reg_info.time_stamp, reg_info.time_stamp,
(uint32_t)reg_info.mb_offset, (unsigned)reg_info.mb_offset,
(uint32_t)reg_info.type, (unsigned)reg_info.type,
(uint32_t)reg_info.address, (uint32_t)reg_info.address,
(uint32_t)reg_info.size); (unsigned)reg_info.size);
if (reg_info.address == (uint8_t*)&holding_reg_params.holding_data0) if (reg_info.address == (uint8_t*)&holding_reg_params.holding_data0)
{ {
portENTER_CRITICAL(&param_lock); portENTER_CRITICAL(&param_lock);
@@ -193,29 +193,29 @@ static void slave_operation_func(void *arg)
} }
} else if (event & MB_EVENT_INPUT_REG_RD) { } else if (event & MB_EVENT_INPUT_REG_RD) {
ESP_ERROR_CHECK(mbc_slave_get_param_info(&reg_info, MB_PAR_INFO_GET_TOUT)); ESP_ERROR_CHECK(mbc_slave_get_param_info(&reg_info, MB_PAR_INFO_GET_TOUT));
ESP_LOGI(TAG, "INPUT READ (%u us), ADDR:%u, TYPE:%u, INST_ADDR:0x%.4x, SIZE:%u", ESP_LOGI(TAG, "INPUT READ (%" PRIu32 " us), ADDR:%u, TYPE:%u, INST_ADDR:0x%" PRIx32 ", SIZE:%u",
(uint32_t)reg_info.time_stamp, reg_info.time_stamp,
(uint32_t)reg_info.mb_offset, (unsigned)reg_info.mb_offset,
(uint32_t)reg_info.type, (unsigned)reg_info.type,
(uint32_t)reg_info.address, (uint32_t)reg_info.address,
(uint32_t)reg_info.size); (unsigned)reg_info.size);
} else if (event & MB_EVENT_DISCRETE_RD) { } else if (event & MB_EVENT_DISCRETE_RD) {
ESP_ERROR_CHECK(mbc_slave_get_param_info(&reg_info, MB_PAR_INFO_GET_TOUT)); ESP_ERROR_CHECK(mbc_slave_get_param_info(&reg_info, MB_PAR_INFO_GET_TOUT));
ESP_LOGI(TAG, "DISCRETE READ (%u us): ADDR:%u, TYPE:%u, INST_ADDR:0x%.4x, SIZE:%u", ESP_LOGI(TAG, "DISCRETE READ (%" PRIu32 " us), ADDR:%u, TYPE:%u, INST_ADDR:0x%" PRIx32 ", SIZE:%u",
(uint32_t)reg_info.time_stamp, reg_info.time_stamp,
(uint32_t)reg_info.mb_offset, (unsigned)reg_info.mb_offset,
(uint32_t)reg_info.type, (unsigned)reg_info.type,
(uint32_t)reg_info.address, (uint32_t)reg_info.address,
(uint32_t)reg_info.size); (unsigned)reg_info.size);
} else if (event & (MB_EVENT_COILS_RD | MB_EVENT_COILS_WR)) { } else if (event & (MB_EVENT_COILS_RD | MB_EVENT_COILS_WR)) {
ESP_ERROR_CHECK(mbc_slave_get_param_info(&reg_info, MB_PAR_INFO_GET_TOUT)); ESP_ERROR_CHECK(mbc_slave_get_param_info(&reg_info, MB_PAR_INFO_GET_TOUT));
ESP_LOGI(TAG, "COILS %s (%u us), ADDR:%u, TYPE:%u, INST_ADDR:0x%.4x, SIZE:%u", ESP_LOGI(TAG, "COILS %s (%" PRIu32 " us), ADDR:%u, TYPE:%u, INST_ADDR:0x%" PRIx32 ", SIZE:%u",
rw_str, rw_str,
(uint32_t)reg_info.time_stamp, reg_info.time_stamp,
(uint32_t)reg_info.mb_offset, (unsigned)reg_info.mb_offset,
(uint32_t)reg_info.type, (unsigned)reg_info.type,
(uint32_t)reg_info.address, (uint32_t)reg_info.address,
(uint32_t)reg_info.size); (unsigned)reg_info.size);
if (coil_reg_params.coils_port1 == 0xFF) break; if (coil_reg_params.coils_port1 == 0xFF) break;
} }
} }
@@ -234,17 +234,17 @@ static esp_err_t init_services(void)
MB_RETURN_ON_FALSE((result == ESP_OK), ESP_ERR_INVALID_STATE, MB_RETURN_ON_FALSE((result == ESP_OK), ESP_ERR_INVALID_STATE,
TAG, TAG,
"nvs_flash_init fail, returns(0x%x).", "nvs_flash_init fail, returns(0x%x).",
(uint32_t)result); (int)result);
result = esp_netif_init(); result = esp_netif_init();
MB_RETURN_ON_FALSE((result == ESP_OK), ESP_ERR_INVALID_STATE, MB_RETURN_ON_FALSE((result == ESP_OK), ESP_ERR_INVALID_STATE,
TAG, TAG,
"esp_netif_init fail, returns(0x%x).", "esp_netif_init fail, returns(0x%x).",
(uint32_t)result); (int)result);
result = esp_event_loop_create_default(); result = esp_event_loop_create_default();
MB_RETURN_ON_FALSE((result == ESP_OK), ESP_ERR_INVALID_STATE, MB_RETURN_ON_FALSE((result == ESP_OK), ESP_ERR_INVALID_STATE,
TAG, TAG,
"esp_event_loop_create_default fail, returns(0x%x).", "esp_event_loop_create_default fail, returns(0x%x).",
(uint32_t)result); (int)result);
#if CONFIG_MB_MDNS_IP_RESOLVER #if CONFIG_MB_MDNS_IP_RESOLVER
// Start mdns service and register device // Start mdns service and register device
start_mdns_service(); start_mdns_service();
@@ -256,13 +256,13 @@ static esp_err_t init_services(void)
MB_RETURN_ON_FALSE((result == ESP_OK), ESP_ERR_INVALID_STATE, MB_RETURN_ON_FALSE((result == ESP_OK), ESP_ERR_INVALID_STATE,
TAG, TAG,
"example_connect fail, returns(0x%x).", "example_connect fail, returns(0x%x).",
(uint32_t)result); (int)result);
#if CONFIG_EXAMPLE_CONNECT_WIFI #if CONFIG_EXAMPLE_CONNECT_WIFI
result = esp_wifi_set_ps(WIFI_PS_NONE); result = esp_wifi_set_ps(WIFI_PS_NONE);
MB_RETURN_ON_FALSE((result == ESP_OK), ESP_ERR_INVALID_STATE, MB_RETURN_ON_FALSE((result == ESP_OK), ESP_ERR_INVALID_STATE,
TAG, TAG,
"esp_wifi_set_ps fail, returns(0x%x).", "esp_wifi_set_ps fail, returns(0x%x).",
(uint32_t)result); (int)result);
#endif #endif
return ESP_OK; return ESP_OK;
} }
@@ -275,22 +275,22 @@ static esp_err_t destroy_services(void)
MB_RETURN_ON_FALSE((err == ESP_OK), ESP_ERR_INVALID_STATE, MB_RETURN_ON_FALSE((err == ESP_OK), ESP_ERR_INVALID_STATE,
TAG, TAG,
"example_disconnect fail, returns(0x%x).", "example_disconnect fail, returns(0x%x).",
(uint32_t)err); (int)err);
err = esp_event_loop_delete_default(); err = esp_event_loop_delete_default();
MB_RETURN_ON_FALSE((err == ESP_OK), ESP_ERR_INVALID_STATE, MB_RETURN_ON_FALSE((err == ESP_OK), ESP_ERR_INVALID_STATE,
TAG, TAG,
"esp_event_loop_delete_default fail, returns(0x%x).", "esp_event_loop_delete_default fail, returns(0x%x).",
(uint32_t)err); (int)err);
err = esp_netif_deinit(); err = esp_netif_deinit();
MB_RETURN_ON_FALSE((err == ESP_OK || err == ESP_ERR_NOT_SUPPORTED), ESP_ERR_INVALID_STATE, MB_RETURN_ON_FALSE((err == ESP_OK || err == ESP_ERR_NOT_SUPPORTED), ESP_ERR_INVALID_STATE,
TAG, TAG,
"esp_netif_deinit fail, returns(0x%x).", "esp_netif_deinit fail, returns(0x%x).",
(uint32_t)err); (int)err);
err = nvs_flash_deinit(); err = nvs_flash_deinit();
MB_RETURN_ON_FALSE((err == ESP_OK), ESP_ERR_INVALID_STATE, MB_RETURN_ON_FALSE((err == ESP_OK), ESP_ERR_INVALID_STATE,
TAG, TAG,
"nvs_flash_deinit fail, returns(0x%x).", "nvs_flash_deinit fail, returns(0x%x).",
(uint32_t)err); (int)err);
#if CONFIG_MB_MDNS_IP_RESOLVER #if CONFIG_MB_MDNS_IP_RESOLVER
stop_mdns_service(); stop_mdns_service();
#endif #endif
@@ -312,13 +312,14 @@ static esp_err_t slave_init(mb_communication_info_t* comm_info)
comm_info->ip_addr = NULL; // Bind to any address comm_info->ip_addr = NULL; // Bind to any address
comm_info->ip_netif_ptr = (void*)get_example_netif(); comm_info->ip_netif_ptr = (void*)get_example_netif();
comm_info->slave_uid = MB_SLAVE_ADDR;
// Setup communication parameters and start stack // Setup communication parameters and start stack
err = mbc_slave_setup((void*)comm_info); err = mbc_slave_setup((void*)comm_info);
MB_RETURN_ON_FALSE((err == ESP_OK), ESP_ERR_INVALID_STATE, MB_RETURN_ON_FALSE((err == ESP_OK), ESP_ERR_INVALID_STATE,
TAG, TAG,
"mbc_slave_setup fail, returns(0x%x).", "mbc_slave_setup fail, returns(0x%x).",
(uint32_t)err); (int)err);
// The code below initializes Modbus register area descriptors // The code below initializes Modbus register area descriptors
// for Modbus Holding Registers, Input Registers, Coils and Discrete Inputs // for Modbus Holding Registers, Input Registers, Coils and Discrete Inputs
@@ -334,7 +335,7 @@ static esp_err_t slave_init(mb_communication_info_t* comm_info)
MB_RETURN_ON_FALSE((err == ESP_OK), ESP_ERR_INVALID_STATE, MB_RETURN_ON_FALSE((err == ESP_OK), ESP_ERR_INVALID_STATE,
TAG, TAG,
"mbc_slave_set_descriptor fail, returns(0x%x).", "mbc_slave_set_descriptor fail, returns(0x%x).",
(uint32_t)err); (int)err);
reg_area.type = MB_PARAM_HOLDING; // Set type of register area reg_area.type = MB_PARAM_HOLDING; // Set type of register area
reg_area.start_offset = MB_REG_HOLDING_START_AREA1; // Offset of register area in Modbus protocol reg_area.start_offset = MB_REG_HOLDING_START_AREA1; // Offset of register area in Modbus protocol
@@ -344,7 +345,7 @@ static esp_err_t slave_init(mb_communication_info_t* comm_info)
MB_RETURN_ON_FALSE((err == ESP_OK), ESP_ERR_INVALID_STATE, MB_RETURN_ON_FALSE((err == ESP_OK), ESP_ERR_INVALID_STATE,
TAG, TAG,
"mbc_slave_set_descriptor fail, returns(0x%x).", "mbc_slave_set_descriptor fail, returns(0x%x).",
(uint32_t)err); (int)err);
// Initialization of Input Registers area // Initialization of Input Registers area
reg_area.type = MB_PARAM_INPUT; reg_area.type = MB_PARAM_INPUT;
@@ -355,7 +356,7 @@ static esp_err_t slave_init(mb_communication_info_t* comm_info)
MB_RETURN_ON_FALSE((err == ESP_OK), ESP_ERR_INVALID_STATE, MB_RETURN_ON_FALSE((err == ESP_OK), ESP_ERR_INVALID_STATE,
TAG, TAG,
"mbc_slave_set_descriptor fail, returns(0x%x).", "mbc_slave_set_descriptor fail, returns(0x%x).",
(uint32_t)err); (int)err);
reg_area.type = MB_PARAM_INPUT; reg_area.type = MB_PARAM_INPUT;
reg_area.start_offset = MB_REG_INPUT_START_AREA1; reg_area.start_offset = MB_REG_INPUT_START_AREA1;
reg_area.address = (void*)&input_reg_params.input_data4; reg_area.address = (void*)&input_reg_params.input_data4;
@@ -364,7 +365,7 @@ static esp_err_t slave_init(mb_communication_info_t* comm_info)
MB_RETURN_ON_FALSE((err == ESP_OK), ESP_ERR_INVALID_STATE, MB_RETURN_ON_FALSE((err == ESP_OK), ESP_ERR_INVALID_STATE,
TAG, TAG,
"mbc_slave_set_descriptor fail, returns(0x%x).", "mbc_slave_set_descriptor fail, returns(0x%x).",
(uint32_t)err); (int)err);
// Initialization of Coils register area // Initialization of Coils register area
reg_area.type = MB_PARAM_COIL; reg_area.type = MB_PARAM_COIL;
@@ -375,7 +376,7 @@ static esp_err_t slave_init(mb_communication_info_t* comm_info)
MB_RETURN_ON_FALSE((err == ESP_OK), ESP_ERR_INVALID_STATE, MB_RETURN_ON_FALSE((err == ESP_OK), ESP_ERR_INVALID_STATE,
TAG, TAG,
"mbc_slave_set_descriptor fail, returns(0x%x).", "mbc_slave_set_descriptor fail, returns(0x%x).",
(uint32_t)err); (int)err);
// Initialization of Discrete Inputs register area // Initialization of Discrete Inputs register area
reg_area.type = MB_PARAM_DISCRETE; reg_area.type = MB_PARAM_DISCRETE;
@@ -386,7 +387,7 @@ static esp_err_t slave_init(mb_communication_info_t* comm_info)
MB_RETURN_ON_FALSE((err == ESP_OK), ESP_ERR_INVALID_STATE, MB_RETURN_ON_FALSE((err == ESP_OK), ESP_ERR_INVALID_STATE,
TAG, TAG,
"mbc_slave_set_descriptor fail, returns(0x%x).", "mbc_slave_set_descriptor fail, returns(0x%x).",
(uint32_t)err); (int)err);
// Set values into known state // Set values into known state
setup_reg_data(); setup_reg_data();
@@ -396,7 +397,7 @@ static esp_err_t slave_init(mb_communication_info_t* comm_info)
MB_RETURN_ON_FALSE((err == ESP_OK), ESP_ERR_INVALID_STATE, MB_RETURN_ON_FALSE((err == ESP_OK), ESP_ERR_INVALID_STATE,
TAG, TAG,
"mbc_slave_start fail, returns(0x%x).", "mbc_slave_start fail, returns(0x%x).",
(uint32_t)err); (int)err);
vTaskDelay(5); vTaskDelay(5);
return err; return err;
} }
@@ -407,7 +408,7 @@ static esp_err_t slave_destroy(void)
MB_RETURN_ON_FALSE((err == ESP_OK), ESP_ERR_INVALID_STATE, MB_RETURN_ON_FALSE((err == ESP_OK), ESP_ERR_INVALID_STATE,
TAG, TAG,
"mbc_slave_destroy fail, returns(0x%x).", "mbc_slave_destroy fail, returns(0x%x).",
(uint32_t)err); (int)err);
return err; return err;
} }
@@ -420,6 +421,7 @@ void app_main(void)
ESP_ERROR_CHECK(init_services()); ESP_ERROR_CHECK(init_services());
// Set UART log level // Set UART log level
esp_log_level_set(TAG, ESP_LOG_INFO); esp_log_level_set(TAG, ESP_LOG_INFO);
mb_communication_info_t comm_info = { 0 }; mb_communication_info_t comm_info = { 0 };