espressif/esp-modbus
1
0
Fork 1
mirror of https://github.com/espressif/esp-modbus.git synced 2025-08-01 03:14:29 +02:00
Code Issues Packages Projects Releases Wiki Activity

fix format warnings

Browse Source
This commit is contained in:
Alexey Lapshin
2022-07-06 16:30:55 +04:00
parent 0faa194efd
commit d5f4157fdc
9 changed files with 71 additions and 71 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
freemodbus/common/esp_modbus_slave.c
View File

@@ -252,7 +252,7 @@ static esp_err_t mbc_slave_send_param_info(mb_event_group_t par_type, uint16_t m
par_info.mb_offset = mb_offset; par_info.mb_offset = mb_offset;
BaseType_t status = xQueueSend(mbs_opts->mbs_notification_queue_handle, &par_info, MB_PAR_INFO_TOUT); BaseType_t status = xQueueSend(mbs_opts->mbs_notification_queue_handle, &par_info, MB_PAR_INFO_TOUT);
if (pdTRUE == status) { if (pdTRUE == status) {
ESP_LOGD(TAG, "Queue send parameter info (type, address, size): %d, 0x%.4x, %d", ESP_LOGD(TAG, "Queue send parameter info (type, address, size): %d, 0x%.4" PRIx32 ", %d",
par_type, (uint32_t)par_address, par_size); par_type, (uint32_t)par_address, par_size);
error = ESP_OK; error = ESP_OK;
} else if (errQUEUE_FULL == status) { } else if (errQUEUE_FULL == status) {

8
freemodbus/port/portevent_m.c
View File

@@ -149,7 +149,7 @@ xMBMasterPortEventGet( eMBMasterEventType* eEvent )
xEventGroupSetBits( xEventGroupMasterConfirmHdl, *eEvent ); xEventGroupSetBits( xEventGroupMasterConfirmHdl, *eEvent );
xEventHappened = TRUE; xEventHappened = TRUE;
} else { } else {
ESP_LOGE(MB_PORT_TAG,"%s: Incorrect event triggered = %d.", __func__, uxBits); ESP_LOGE(MB_PORT_TAG,"%s: Incorrect event triggered = %" PRIu32 ".", __func__, uxBits);
*eEvent = (eMBMasterEventType)uxBits; *eEvent = (eMBMasterEventType)uxBits;
xEventHappened = FALSE; xEventHappened = FALSE;
} }
@@ -181,7 +181,7 @@ BOOL xMBMasterRunResTake( LONG lTimeOut )
pdFALSE, // Don't wait for both bits, either bit will do. pdFALSE, // Don't wait for both bits, either bit will do.
lTimeOut); // Resource wait timeout. lTimeOut); // Resource wait timeout.
MB_PORT_CHECK((uxBits == MB_EVENT_RESOURCE), FALSE , "Take resource failure."); MB_PORT_CHECK((uxBits == MB_EVENT_RESOURCE), FALSE , "Take resource failure.");
ESP_LOGD(MB_PORT_TAG,"%s:Take resource (%x) (%lu ticks).", __func__, uxBits, lTimeOut); ESP_LOGD(MB_PORT_TAG,"%s:Take resource (%" PRIu32 ") (%lu ticks).", __func__, uxBits, lTimeOut);
return TRUE; return TRUE;
} }
@@ -193,7 +193,7 @@ void vMBMasterRunResRelease( void )
{ {
EventBits_t uxBits = xEventGroupSetBits( xResourceMasterHdl, MB_EVENT_RESOURCE ); EventBits_t uxBits = xEventGroupSetBits( xResourceMasterHdl, MB_EVENT_RESOURCE );
MB_PORT_CHECK((uxBits == MB_EVENT_RESOURCE), ; , "Resource release failure."); MB_PORT_CHECK((uxBits == MB_EVENT_RESOURCE), ; , "Resource release failure.");
ESP_LOGD(MB_PORT_TAG,"%s: Release resource (%x).", __func__, uxBits); ESP_LOGD(MB_PORT_TAG,"%s: Release resource (%" PRIx32 ").", __func__, uxBits);
} }
/** /**
@@ -297,7 +297,7 @@ eMBMasterReqErrCode eMBMasterWaitRequestFinish( void ) {
eErrStatus = MB_MRE_EXE_FUN; eErrStatus = MB_MRE_EXE_FUN;
} }
} else { } else {
ESP_LOGE(MB_PORT_TAG,"%s: Incorrect event or timeout xRecvedEvent = 0x%x", __func__, uxBits); ESP_LOGE(MB_PORT_TAG,"%s: Incorrect event or timeout xRecvedEvent = 0x%" PRIx32, __func__, uxBits);
// https://github.com/espressif/esp-idf/issues/5275 // https://github.com/espressif/esp-idf/issues/5275
// if a no event is received, that means vMBMasterPortEventClose() // if a no event is received, that means vMBMasterPortEventClose()
// has been closed, so event group has been deleted by FreeRTOS, which // has been closed, so event group has been deleted by FreeRTOS, which

2
freemodbus/port/portserial_m.c
View File

@@ -96,7 +96,7 @@ static USHORT usMBMasterPortSerialRxPoll(size_t xEventSize)
// The buffer is transferred into Modbus stack and is not needed here any more // The buffer is transferred into Modbus stack and is not needed here any more
uart_flush_input(ucUartNumber); uart_flush_input(ucUartNumber);
ESP_LOGD(TAG, "Received data: %d(bytes in buffer)\n", (uint32_t)usCnt); ESP_LOGD(TAG, "Received data: %" PRIu32 "(bytes in buffer)\n", (uint32_t)usCnt);
#if !CONFIG_FMB_TIMER_PORT_ENABLED #if !CONFIG_FMB_TIMER_PORT_ENABLED
vMBMasterSetCurTimerMode(MB_TMODE_T35); vMBMasterSetCurTimerMode(MB_TMODE_T35);
pxMBMasterPortCBTimerExpired(); pxMBMasterPortCBTimerExpired();

12
freemodbus/serial_master/modbus_controller/mbc_serial_master.c
View File

@@ -71,12 +71,12 @@ static esp_err_t mbc_serial_master_setup(void* comm_info)
const mb_master_comm_info_t* comm_info_ptr = (mb_master_comm_info_t*)comm_info; const mb_master_comm_info_t* comm_info_ptr = (mb_master_comm_info_t*)comm_info;
// Check communication options // Check communication options
MB_MASTER_CHECK(((comm_info_ptr->mode == MB_MODE_RTU) || (comm_info_ptr->mode == MB_MODE_ASCII)), MB_MASTER_CHECK(((comm_info_ptr->mode == MB_MODE_RTU) || (comm_info_ptr->mode == MB_MODE_ASCII)),
ESP_ERR_INVALID_ARG, "mb incorrect mode = (0x%x).", ESP_ERR_INVALID_ARG, "mb incorrect mode = (0x%" PRIx32 ").",
(uint32_t)comm_info_ptr->mode); (uint32_t)comm_info_ptr->mode);
MB_MASTER_CHECK((comm_info_ptr->port <= UART_NUM_MAX), ESP_ERR_INVALID_ARG, MB_MASTER_CHECK((comm_info_ptr->port <= UART_NUM_MAX), ESP_ERR_INVALID_ARG,
"mb wrong port to set = (0x%x).", (uint32_t)comm_info_ptr->port); "mb wrong port to set = (0x%" PRIx32 ").", (uint32_t)comm_info_ptr->port);
MB_MASTER_CHECK((comm_info_ptr->parity <= UART_PARITY_ODD), ESP_ERR_INVALID_ARG, MB_MASTER_CHECK((comm_info_ptr->parity <= UART_PARITY_ODD), ESP_ERR_INVALID_ARG,
"mb wrong parity option = (0x%x).", (uint32_t)comm_info_ptr->parity); "mb wrong parity option = (0x%" PRIx32 ").", (uint32_t)comm_info_ptr->parity);
// Save the communication options // Save the communication options
mbm_opts->mbm_comm = *(mb_communication_info_t*)comm_info_ptr; mbm_opts->mbm_comm = *(mb_communication_info_t*)comm_info_ptr;
return ESP_OK; return ESP_OK;
@@ -101,7 +101,7 @@ static esp_err_t mbc_serial_master_start(void)
"mb stack initialization failure, eMBInit() returns (0x%x).", status); "mb stack initialization failure, eMBInit() returns (0x%x).", status);
status = eMBMasterEnable(); status = eMBMasterEnable();
MB_MASTER_CHECK((status == MB_ENOERR), ESP_ERR_INVALID_STATE, MB_MASTER_CHECK((status == MB_ENOERR), ESP_ERR_INVALID_STATE,
"mb stack set slave ID failure, eMBMasterEnable() returned (0x%x).", (uint32_t)status); "mb stack set slave ID failure, eMBMasterEnable() returned (0x%" PRIx32 ").", (uint32_t)status);
// Set the mbcontroller start flag // Set the mbcontroller start flag
EventBits_t flag = xEventGroupSetBits(mbm_opts->mbm_event_group, EventBits_t flag = xEventGroupSetBits(mbm_opts->mbm_event_group,
(EventBits_t)MB_EVENT_STACK_STARTED); (EventBits_t)MB_EVENT_STACK_STARTED);
@@ -130,7 +130,7 @@ static esp_err_t mbc_serial_master_destroy(void)
(void)vEventGroupDelete(mbm_opts->mbm_event_group); (void)vEventGroupDelete(mbm_opts->mbm_event_group);
mb_error = eMBMasterClose(); mb_error = eMBMasterClose();
MB_MASTER_CHECK((mb_error == MB_ENOERR), ESP_ERR_INVALID_STATE, MB_MASTER_CHECK((mb_error == MB_ENOERR), ESP_ERR_INVALID_STATE,
"mb stack close failure returned (0x%x).", (uint32_t)mb_error); "mb stack close failure returned (0x%" PRIx32 ").", (uint32_t)mb_error);
free(mbm_interface_ptr); // free the memory allocated for options free(mbm_interface_ptr); // free the memory allocated for options
vMBPortSetMode((UCHAR)MB_PORT_INACTIVE); vMBPortSetMode((UCHAR)MB_PORT_INACTIVE);
mbm_interface_ptr = NULL; mbm_interface_ptr = NULL;
@@ -675,7 +675,7 @@ esp_err_t mbc_serial_master_create(void** handler)
if (status != pdPASS) { if (status != pdPASS) {
vTaskDelete(mbm_opts->mbm_task_handle); vTaskDelete(mbm_opts->mbm_task_handle);
MB_MASTER_CHECK((status == pdPASS), ESP_ERR_NO_MEM, MB_MASTER_CHECK((status == pdPASS), ESP_ERR_NO_MEM,
"mb controller task creation error, xTaskCreate() returns (0x%x).", "mb controller task creation error, xTaskCreate() returns (0x%" PRIx32 ").",
(uint32_t)status); (uint32_t)status);
} }
MB_MASTER_ASSERT(mbm_opts->mbm_task_handle != NULL); // The task is created but handle is incorrect MB_MASTER_ASSERT(mbm_opts->mbm_task_handle != NULL); // The task is created but handle is incorrect

14
freemodbus/serial_slave/modbus_controller/mbc_serial_slave.c
View File

@@ -59,15 +59,15 @@ static esp_err_t mbc_serial_slave_setup(void* comm_info)
mb_slave_options_t* mbs_opts = &mbs_interface_ptr->opts; mb_slave_options_t* mbs_opts = &mbs_interface_ptr->opts;
mb_slave_comm_info_t* comm_settings = (mb_slave_comm_info_t*)comm_info; mb_slave_comm_info_t* comm_settings = (mb_slave_comm_info_t*)comm_info;
MB_SLAVE_CHECK(((comm_settings->mode == MB_MODE_RTU) || (comm_settings->mode == MB_MODE_ASCII)), MB_SLAVE_CHECK(((comm_settings->mode == MB_MODE_RTU) || (comm_settings->mode == MB_MODE_ASCII)),
ESP_ERR_INVALID_ARG, "mb incorrect mode = (0x%x).", ESP_ERR_INVALID_ARG, "mb incorrect mode = (0x%" PRIx32 ").",
(uint32_t)comm_settings->mode); (uint32_t)comm_settings->mode);
MB_SLAVE_CHECK((comm_settings->slave_addr <= MB_ADDRESS_MAX), MB_SLAVE_CHECK((comm_settings->slave_addr <= MB_ADDRESS_MAX),
ESP_ERR_INVALID_ARG, "mb wrong slave address = (0x%x).", ESP_ERR_INVALID_ARG, "mb wrong slave address = (0x%" PRIx32 ").",
(uint32_t)comm_settings->slave_addr); (uint32_t)comm_settings->slave_addr);
MB_SLAVE_CHECK((comm_settings->port < UART_NUM_MAX), ESP_ERR_INVALID_ARG, MB_SLAVE_CHECK((comm_settings->port < UART_NUM_MAX), ESP_ERR_INVALID_ARG,
"mb wrong port to set = (0x%x).", (uint32_t)comm_settings->port); "mb wrong port to set = (0x%" PRIx32 ").", (uint32_t)comm_settings->port);
MB_SLAVE_CHECK((comm_settings->parity <= UART_PARITY_ODD), ESP_ERR_INVALID_ARG, MB_SLAVE_CHECK((comm_settings->parity <= UART_PARITY_ODD), ESP_ERR_INVALID_ARG,
"mb wrong parity option = (0x%x).", (uint32_t)comm_settings->parity); "mb wrong parity option = (0x%" PRIx32 ").", (uint32_t)comm_settings->parity);
// Set communication options of the controller // Set communication options of the controller
mbs_opts->mbs_comm = *(mb_communication_info_t*)comm_settings; mbs_opts->mbs_comm = *(mb_communication_info_t*)comm_settings;
@@ -95,7 +95,7 @@ static esp_err_t mbc_serial_slave_start(void)
"mb stack initialization failure, eMBInit() returns (0x%x).", status); "mb stack initialization failure, eMBInit() returns (0x%x).", status);
status = eMBEnable(); status = eMBEnable();
MB_SLAVE_CHECK((status == MB_ENOERR), ESP_ERR_INVALID_STATE, MB_SLAVE_CHECK((status == MB_ENOERR), ESP_ERR_INVALID_STATE,
"mb stack set slave ID failure, eMBEnable() returned (0x%x).", (uint32_t)status); "mb stack set slave ID failure, eMBEnable() returned (0x%" PRIx32 ").", (uint32_t)status);
// Set the mbcontroller start flag // Set the mbcontroller start flag
EventBits_t flag = xEventGroupSetBits(mbs_opts->mbs_event_group, EventBits_t flag = xEventGroupSetBits(mbs_opts->mbs_event_group,
(EventBits_t)MB_EVENT_STACK_STARTED); (EventBits_t)MB_EVENT_STACK_STARTED);
@@ -163,7 +163,7 @@ static esp_err_t mbc_serial_slave_destroy(void)
(void)vEventGroupDelete(mbs_opts->mbs_event_group); (void)vEventGroupDelete(mbs_opts->mbs_event_group);
mb_error = eMBClose(); mb_error = eMBClose();
MB_SLAVE_CHECK((mb_error == MB_ENOERR), ESP_ERR_INVALID_STATE, MB_SLAVE_CHECK((mb_error == MB_ENOERR), ESP_ERR_INVALID_STATE,
"mb stack close failure returned (0x%x).", (uint32_t)mb_error); "mb stack close failure returned (0x%" PRIx32 ").", (uint32_t)mb_error);
mbs_interface_ptr = NULL; mbs_interface_ptr = NULL;
vMBPortSetMode((UCHAR)MB_PORT_INACTIVE); vMBPortSetMode((UCHAR)MB_PORT_INACTIVE);
return ESP_OK; return ESP_OK;
@@ -213,7 +213,7 @@ esp_err_t mbc_serial_slave_create(void** handler)
if (status != pdPASS) { if (status != pdPASS) {
vTaskDelete(mbs_opts->mbs_task_handle); vTaskDelete(mbs_opts->mbs_task_handle);
MB_SLAVE_CHECK((status == pdPASS), ESP_ERR_NO_MEM, MB_SLAVE_CHECK((status == pdPASS), ESP_ERR_NO_MEM,
"mb controller task creation error, xTaskCreate() returns (0x%x).", "mb controller task creation error, xTaskCreate() returns (0x%" PRIx32 ").",
(uint32_t)status); (uint32_t)status);
} }
MB_SLAVE_ASSERT(mbs_opts->mbs_task_handle != NULL); // The task is created but handle is incorrect MB_SLAVE_ASSERT(mbs_opts->mbs_task_handle != NULL); // The task is created but handle is incorrect

8
freemodbus/tcp_master/modbus_controller/mbc_tcp_master.c
View File

@@ -120,7 +120,7 @@ static esp_err_t mbc_tcp_master_setup(void* comm_info)
const mb_communication_info_t* comm_info_ptr = (mb_communication_info_t*)comm_info; const mb_communication_info_t* comm_info_ptr = (mb_communication_info_t*)comm_info;
// Check communication options // Check communication options
MB_MASTER_CHECK((comm_info_ptr->ip_mode == MB_MODE_TCP), MB_MASTER_CHECK((comm_info_ptr->ip_mode == MB_MODE_TCP),
ESP_ERR_INVALID_ARG, "mb incorrect mode = (0x%x).", ESP_ERR_INVALID_ARG, "mb incorrect mode = (0x%" PRIx32 ").",
(uint32_t)comm_info_ptr->ip_mode); (uint32_t)comm_info_ptr->ip_mode);
MB_MASTER_CHECK((comm_info_ptr->ip_addr != NULL), MB_MASTER_CHECK((comm_info_ptr->ip_addr != NULL),
ESP_ERR_INVALID_ARG, "mb wrong slave ip address table."); ESP_ERR_INVALID_ARG, "mb wrong slave ip address table.");
@@ -159,7 +159,7 @@ static esp_err_t mbc_tcp_master_start(void)
status = eMBMasterEnable(); status = eMBMasterEnable();
MB_MASTER_CHECK((status == MB_ENOERR), ESP_ERR_INVALID_STATE, MB_MASTER_CHECK((status == MB_ENOERR), ESP_ERR_INVALID_STATE,
"mb stack enable failure, eMBMasterEnable() returned (0x%x).", (uint32_t)status); "mb stack enable failure, eMBMasterEnable() returned (0x%" PRIx32 ").", (uint32_t)status);
// Add slave IP address for each slave to initialize connection // Add slave IP address for each slave to initialize connection
mb_slave_addr_entry_t *p_slave_info; mb_slave_addr_entry_t *p_slave_info;
@@ -194,7 +194,7 @@ static esp_err_t mbc_tcp_master_destroy(void)
MB_MASTER_CHECK((mb_error == MB_ENOERR), ESP_ERR_INVALID_STATE, "mb stack disable failure."); MB_MASTER_CHECK((mb_error == MB_ENOERR), ESP_ERR_INVALID_STATE, "mb stack disable failure.");
mb_error = eMBMasterClose(); mb_error = eMBMasterClose();
MB_MASTER_CHECK((mb_error == MB_ENOERR), ESP_ERR_INVALID_STATE, MB_MASTER_CHECK((mb_error == MB_ENOERR), ESP_ERR_INVALID_STATE,
"mb stack close failure returned (0x%x).", (uint32_t)mb_error); "mb stack close failure returned (0x%" PRIx32 ").", (uint32_t)mb_error);
// Stop polling by clearing correspondent bit in the event group // Stop polling by clearing correspondent bit in the event group
xEventGroupClearBits(mbm_opts->mbm_event_group, xEventGroupClearBits(mbm_opts->mbm_event_group,
(EventBits_t)MB_EVENT_STACK_STARTED); (EventBits_t)MB_EVENT_STACK_STARTED);
@@ -782,7 +782,7 @@ esp_err_t mbc_tcp_master_create(void** handler)
if (status != pdPASS) { if (status != pdPASS) {
vTaskDelete(mbm_opts->mbm_task_handle); vTaskDelete(mbm_opts->mbm_task_handle);
MB_MASTER_CHECK((status == pdPASS), ESP_ERR_NO_MEM, MB_MASTER_CHECK((status == pdPASS), ESP_ERR_NO_MEM,
"mb controller task creation error, xTaskCreate() returns (0x%x).", "mb controller task creation error, xTaskCreate() returns (0x%" PRIx32 ").",
(uint32_t)status); (uint32_t)status);
} }
MB_MASTER_ASSERT(mbm_opts->mbm_task_handle != NULL); // The task is created but handle is incorrect MB_MASTER_ASSERT(mbm_opts->mbm_task_handle != NULL); // The task is created but handle is incorrect

4
freemodbus/tcp_slave/modbus_controller/mbc_tcp_slave.c
View File

@@ -82,7 +82,7 @@ static esp_err_t mbc_tcp_slave_start(void)
status = eMBEnable(); status = eMBEnable();
MB_SLAVE_CHECK((status == MB_ENOERR), ESP_ERR_INVALID_STATE, MB_SLAVE_CHECK((status == MB_ENOERR), ESP_ERR_INVALID_STATE,
"mb TCP stack start failure, eMBEnable() returned (0x%x).", (uint32_t)status); "mb TCP stack start failure, eMBEnable() returned (0x%" PRIx32 ").", (uint32_t)status);
// Set the mbcontroller start flag // Set the mbcontroller start flag
EventBits_t flag = xEventGroupSetBits(mbs_opts->mbs_event_group, EventBits_t flag = xEventGroupSetBits(mbs_opts->mbs_event_group,
(EventBits_t)MB_EVENT_STACK_STARTED); (EventBits_t)MB_EVENT_STACK_STARTED);
@@ -188,7 +188,7 @@ esp_err_t mbc_tcp_slave_create(void** handler)
if (status != pdPASS) { if (status != pdPASS) {
vTaskDelete(mbs_opts->mbs_task_handle); vTaskDelete(mbs_opts->mbs_task_handle);
MB_SLAVE_CHECK((status == pdPASS), ESP_ERR_NO_MEM, MB_SLAVE_CHECK((status == pdPASS), ESP_ERR_NO_MEM,
"mb controller task creation error, xTaskCreate() returns (0x%x).", "mb controller task creation error, xTaskCreate() returns (0x%" PRIx32 ").",
(uint32_t)status); (uint32_t)status);
} }

48
test/tcp/mb_tcp_master/main/tcp_master.c
View File

@@ -155,7 +155,7 @@ char* master_scan_addr(int* index, char* buffer)
} }
} }
#else #else
buf_cnt = sscanf(buffer, "IP%d="IPV6STR, index, &a[0], &a[1], &a[2], &a[3], &a[4], &a[5], &a[6], &a[7]); buf_cnt = sscanf(buffer, "IP%" PRIu32 "="IPV6STR, index, &a[0], &a[1], &a[2], &a[3], &a[4], &a[5], &a[6], &a[7]);
if (buf_cnt == 9) { if (buf_cnt == 9) {
if (-1 == asprintf(&ip_str, IPV6STR, a[0], a[1], a[2], a[3], a[4], a[5], a[6], a[7])) { if (-1 == asprintf(&ip_str, IPV6STR, a[0], a[1], a[2], a[3], a[4], a[5], a[6], a[7])) {
abort(); abort();
@@ -301,7 +301,7 @@ static esp_err_t master_resolve_slave(uint8_t short_addr, mdns_result_t* result,
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_%02X", 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: %" PRIu32 "", short_addr);
abort(); abort();
} }
for (; r ; r = r->next) { for (; r ; r = r->next) {
@@ -362,7 +362,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: %" PRIu32 ", sl_addr: %" PRIu32 ", 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;
@@ -378,7 +378,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: %" PRIu32 ", sl_addr: %" PRIu32 ", 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) {
@@ -386,12 +386,12 @@ 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: %" PRIu32 ", sl_addr: %" PRIu32 ", set to IP: [%s]",
i, slave_addr, ip_table[ip_index]); i, slave_addr, ip_table[ip_index]);
cid_resolve_cnt++; cid_resolve_cnt++;
} }
} }
ESP_LOGI(TAG, "Resolved %d cids, with %d IP addresses", cid_resolve_cnt, ip_index); ESP_LOGI(TAG, "Resolved %" PRIu32 " cids, with %" PRIu32 " IP addresses", cid_resolve_cnt, ip_index);
return cid_resolve_cnt; return cid_resolve_cnt;
} }
@@ -500,7 +500,7 @@ 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 #%d %s (%s) value = (0x%08" PRIx32 ") read successful.",
param_descriptor->cid, param_descriptor->cid,
(char*)param_descriptor->param_key, (char*)param_descriptor->param_key,
(char*)param_descriptor->param_units, (char*)param_descriptor->param_units,
@@ -512,7 +512,7 @@ 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 #%d %s (%s) value = (0x%08" PRIx32 "), write successful.",
param_descriptor->cid, param_descriptor->cid,
(char*)param_descriptor->param_key, (char*)param_descriptor->param_key,
(char*)param_descriptor->param_units, (char*)param_descriptor->param_units,
@@ -539,7 +539,7 @@ 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 #%d %s (%s) value = %f (0x%" PRIx32 ") read successful.",
param_descriptor->cid, param_descriptor->cid,
(char*)param_descriptor->param_key, (char*)param_descriptor->param_key,
(char*)param_descriptor->param_units, (char*)param_descriptor->param_units,
@@ -598,17 +598,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%" PRIx32 ").",
(uint32_t)result); (uint32_t)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%" PRIx32 ").",
(uint32_t)result); (uint32_t)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%" PRIx32 ").",
(uint32_t)result); (uint32_t)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
@@ -620,13 +620,13 @@ static esp_err_t init_services(mb_tcp_addr_type_t ip_addr_type)
result = example_connect(); result = example_connect();
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%" PRIx32 ").",
(uint32_t)result); (uint32_t)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%" PRIx32 ").",
(uint32_t)result); (uint32_t)result);
#endif #endif
#if CONFIG_MB_MDNS_IP_RESOLVER #if CONFIG_MB_MDNS_IP_RESOLVER
@@ -635,7 +635,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: %" PRIu32 " out of %" PRIu32 ".", res, 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;
} }
@@ -660,22 +660,22 @@ static esp_err_t destroy_services(void)
err = example_disconnect(); err = example_disconnect();
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%" PRIx32 ").",
(uint32_t)err); (uint32_t)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%" PRIx32 ").",
(uint32_t)err); (uint32_t)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%" PRIx32 ").",
(uint32_t)err); (uint32_t)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%" PRIx32 ").",
(uint32_t)err); (uint32_t)err);
return err; return err;
} }
@@ -691,26 +691,26 @@ static esp_err_t master_init(mb_communication_info_t* comm_info)
"mb controller initialization fail."); "mb controller initialization fail.");
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%" PRIx32 ").",
(uint32_t)err); (uint32_t)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%" PRIx32 ").",
(uint32_t)err); (uint32_t)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%" PRIx32 ").",
(uint32_t)err); (uint32_t)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%" PRIx32 ").",
(uint32_t)err); (uint32_t)err);
vTaskDelay(5); vTaskDelay(5);
return err; return err;
@@ -721,7 +721,7 @@ static esp_err_t master_destroy(void)
esp_err_t err = mbc_master_destroy(); esp_err_t err = mbc_master_destroy();
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%" PRIx32 ").",
(uint32_t)err); (uint32_t)err);
ESP_LOGI(TAG, "Modbus master stack destroy..."); ESP_LOGI(TAG, "Modbus master stack destroy...");
return err; return err;

44
test/tcp/mb_tcp_slave/main/tcp_slave.c
View File

@@ -174,7 +174,7 @@ 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:%" PRIu32 ", TYPE:%" PRIu32 ", INST_ADDR:0x%.4" PRIx32 ", SIZE:%" PRIu32,
rw_str, rw_str,
(uint32_t)reg_info.time_stamp, (uint32_t)reg_info.time_stamp,
(uint32_t)reg_info.mb_offset, (uint32_t)reg_info.mb_offset,
@@ -192,7 +192,7 @@ 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:%" PRIu32 ", TYPE:%" PRIu32 ", INST_ADDR:0x%.4" PRIx32 ", SIZE:%" PRIu32,
(uint32_t)reg_info.time_stamp, (uint32_t)reg_info.time_stamp,
(uint32_t)reg_info.mb_offset, (uint32_t)reg_info.mb_offset,
(uint32_t)reg_info.type, (uint32_t)reg_info.type,
@@ -200,7 +200,7 @@ static void slave_operation_func(void *arg)
(uint32_t)reg_info.size); (uint32_t)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:%" PRIu32 ", TYPE:%" PRIu32 ", INST_ADDR:0x%.4" PRIx32 ", SIZE:%" PRIu32,
(uint32_t)reg_info.time_stamp, (uint32_t)reg_info.time_stamp,
(uint32_t)reg_info.mb_offset, (uint32_t)reg_info.mb_offset,
(uint32_t)reg_info.type, (uint32_t)reg_info.type,
@@ -208,7 +208,7 @@ static void slave_operation_func(void *arg)
(uint32_t)reg_info.size); (uint32_t)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:%" PRIu32 ", TYPE:%" PRIu32 ", INST_ADDR:0x%.4" PRIx32 ", SIZE:%" PRIu32,
rw_str, rw_str,
(uint32_t)reg_info.time_stamp, (uint32_t)reg_info.time_stamp,
(uint32_t)reg_info.mb_offset, (uint32_t)reg_info.mb_offset,
@@ -232,17 +232,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%" PRIx32 ").",
(uint32_t)result); (uint32_t)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%" PRIx32 ").",
(uint32_t)result); (uint32_t)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%" PRIx32 ").",
(uint32_t)result); (uint32_t)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
@@ -254,13 +254,13 @@ static esp_err_t init_services(void)
result = example_connect(); result = example_connect();
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%" PRIx32 ").",
(uint32_t)result); (uint32_t)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%" PRIx32 ").",
(uint32_t)result); (uint32_t)result);
#endif #endif
return ESP_OK; return ESP_OK;
@@ -273,22 +273,22 @@ static esp_err_t destroy_services(void)
err = example_disconnect(); err = example_disconnect();
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%" PRIx32 ").",
(uint32_t)err); (uint32_t)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%" PRIx32 ").",
(uint32_t)err); (uint32_t)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%" PRIx32 ").",
(uint32_t)err); (uint32_t)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%" PRIx32 ").",
(uint32_t)err); (uint32_t)err);
#if CONFIG_MB_MDNS_IP_RESOLVER #if CONFIG_MB_MDNS_IP_RESOLVER
stop_mdns_service(); stop_mdns_service();
@@ -316,7 +316,7 @@ static esp_err_t slave_init(mb_communication_info_t* comm_info)
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%" PRIx32 ").",
(uint32_t)err); (uint32_t)err);
// The code below initializes Modbus register area descriptors // The code below initializes Modbus register area descriptors
@@ -332,7 +332,7 @@ static esp_err_t slave_init(mb_communication_info_t* comm_info)
err = mbc_slave_set_descriptor(reg_area); err = mbc_slave_set_descriptor(reg_area);
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%" PRIx32 ").",
(uint32_t)err); (uint32_t)err);
reg_area.type = MB_PARAM_HOLDING; // Set type of register area reg_area.type = MB_PARAM_HOLDING; // Set type of register area
@@ -342,7 +342,7 @@ static esp_err_t slave_init(mb_communication_info_t* comm_info)
err = mbc_slave_set_descriptor(reg_area); err = mbc_slave_set_descriptor(reg_area);
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%" PRIx32 ").",
(uint32_t)err); (uint32_t)err);
// Initialization of Input Registers area // Initialization of Input Registers area
@@ -353,7 +353,7 @@ static esp_err_t slave_init(mb_communication_info_t* comm_info)
err = mbc_slave_set_descriptor(reg_area); err = mbc_slave_set_descriptor(reg_area);
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%" PRIx32 ").",
(uint32_t)err); (uint32_t)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;
@@ -362,7 +362,7 @@ static esp_err_t slave_init(mb_communication_info_t* comm_info)
err = mbc_slave_set_descriptor(reg_area); err = mbc_slave_set_descriptor(reg_area);
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%" PRIx32 ").",
(uint32_t)err); (uint32_t)err);
// Initialization of Coils register area // Initialization of Coils register area
@@ -373,7 +373,7 @@ static esp_err_t slave_init(mb_communication_info_t* comm_info)
err = mbc_slave_set_descriptor(reg_area); err = mbc_slave_set_descriptor(reg_area);
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%" PRIx32 ").",
(uint32_t)err); (uint32_t)err);
// Initialization of Discrete Inputs register area // Initialization of Discrete Inputs register area
@@ -384,7 +384,7 @@ static esp_err_t slave_init(mb_communication_info_t* comm_info)
err = mbc_slave_set_descriptor(reg_area); err = mbc_slave_set_descriptor(reg_area);
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%" PRIx32 ").",
(uint32_t)err); (uint32_t)err);
// Set values into known state // Set values into known state
@@ -394,7 +394,7 @@ static esp_err_t slave_init(mb_communication_info_t* comm_info)
err = mbc_slave_start(); err = mbc_slave_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,
"mbc_slave_start fail, returns(0x%x).", "mbc_slave_start fail, returns(0x%" PRIx32 ").",
(uint32_t)err); (uint32_t)err);
vTaskDelay(5); vTaskDelay(5);
return err; return err;
@@ -405,7 +405,7 @@ static esp_err_t slave_destroy(void)
esp_err_t err = mbc_slave_destroy(); esp_err_t err = mbc_slave_destroy();
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%" PRIx32 ").",
(uint32_t)err); (uint32_t)err);
return err; return err;
} }