espressif/esp-modbus
1
0
Fork 1
mirror of https://github.com/espressif/esp-modbus.git synced 2025-07-31 02:47:16 +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;
BaseType_t status = xQueueSend(mbs_opts->mbs_notification_queue_handle, &par_info, MB_PAR_INFO_TOUT);
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);
error = ESP_OK;
} else if (errQUEUE_FULL == status) {

8
freemodbus/port/portevent_m.c
View File

@ -149,7 +149,7 @@ xMBMasterPortEventGet( eMBMasterEventType* eEvent )
xEventGroupSetBits( xEventGroupMasterConfirmHdl, *eEvent );
xEventHappened = TRUE;
} 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;
xEventHappened = FALSE;
}
@ -181,7 +181,7 @@ BOOL xMBMasterRunResTake( LONG lTimeOut )
pdFALSE, // Don't wait for both bits, either bit will do.
lTimeOut); // Resource wait timeout.
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;
}
@ -193,7 +193,7 @@ void vMBMasterRunResRelease( void )
{
EventBits_t uxBits = xEventGroupSetBits( xResourceMasterHdl, MB_EVENT_RESOURCE );
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;
}
} 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
// if a no event is received, that means vMBMasterPortEventClose()
// 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
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
vMBMasterSetCurTimerMode(MB_TMODE_T35);
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;
// Check communication options
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);
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 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
mbm_opts->mbm_comm = *(mb_communication_info_t*)comm_info_ptr;
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);
status = eMBMasterEnable();
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
EventBits_t flag = xEventGroupSetBits(mbm_opts->mbm_event_group,
(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);
mb_error = eMBMasterClose();
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
vMBPortSetMode((UCHAR)MB_PORT_INACTIVE);
mbm_interface_ptr = NULL;
@ -675,7 +675,7 @@ esp_err_t mbc_serial_master_create(void** handler)
if (status != pdPASS) {
vTaskDelete(mbm_opts->mbm_task_handle);
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);
}
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_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)),
ESP_ERR_INVALID_ARG, "mb incorrect mode = (0x%x).",
ESP_ERR_INVALID_ARG, "mb incorrect mode = (0x%" PRIx32 ").",
(uint32_t)comm_settings->mode);
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);
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 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
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);
status = eMBEnable();
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
EventBits_t flag = xEventGroupSetBits(mbs_opts->mbs_event_group,
(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);
mb_error = eMBClose();
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;
vMBPortSetMode((UCHAR)MB_PORT_INACTIVE);
return ESP_OK;
@ -213,7 +213,7 @@ esp_err_t mbc_serial_slave_create(void** handler)
if (status != pdPASS) {
vTaskDelete(mbs_opts->mbs_task_handle);
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);
}
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;
// Check communication options
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);
MB_MASTER_CHECK((comm_info_ptr->ip_addr != NULL),
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();
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
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_error = eMBMasterClose();
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
xEventGroupClearBits(mbm_opts->mbm_event_group,
(EventBits_t)MB_EVENT_STACK_STARTED);
@ -782,7 +782,7 @@ esp_err_t mbc_tcp_master_create(void** handler)
if (status != pdPASS) {
vTaskDelete(mbm_opts->mbm_task_handle);
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);
}
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();
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
EventBits_t flag = xEventGroupSetBits(mbs_opts->mbs_event_group,
(EventBits_t)MB_EVENT_STACK_STARTED);
@ -188,7 +188,7 @@ esp_err_t mbc_tcp_slave_create(void** handler)
if (status != pdPASS) {
vTaskDelete(mbs_opts->mbs_task_handle);
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);
}

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
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 (-1 == asprintf(&ip_str, IPV6STR, a[0], a[1], a[2], a[3], a[4], a[5], a[6], a[7])) {
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};
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();
}
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
esp_err_t err = master_resolve_slave(slave_addr, results, &slave_ip, addr_type);
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
ip_table[ip_index] = NULL;
continue;
@ -378,7 +378,7 @@ static int master_create_slave_list(mdns_result_t* results, char** addr_table,
new_slave_entry->p_data = NULL;
LIST_INSERT_HEAD(&slave_addr_list, new_slave_entry, entries);
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);
cid_resolve_cnt++;
if (ip_index < addr_table_size) {
@ -386,12 +386,12 @@ static int master_create_slave_list(mdns_result_t* results, char** addr_table,
}
} else {
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]);
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;
}
@ -500,7 +500,7 @@ static void master_operation_func(void *arg)
err = mbc_master_get_parameter(cid, (char*)param_descriptor->param_key,
(uint8_t*)temp_data_ptr, &type);
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,
(char*)param_descriptor->param_key,
(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,
(uint8_t*)temp_data_ptr, &type);
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,
(char*)param_descriptor->param_key,
(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) ||
(param_descriptor->mb_param_type == MB_PARAM_INPUT)) {
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,
(char*)param_descriptor->param_key,
(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,
TAG,
"nvs_flash_init fail, returns(0x%x).",
"nvs_flash_init fail, returns(0x%" PRIx32 ").",
(uint32_t)result);
result = esp_netif_init();
MB_RETURN_ON_FALSE((result == ESP_OK), ESP_ERR_INVALID_STATE,
TAG,
"esp_netif_init fail, returns(0x%x).",
"esp_netif_init fail, returns(0x%" PRIx32 ").",
(uint32_t)result);
result = esp_event_loop_create_default();
MB_RETURN_ON_FALSE((result == ESP_OK), ESP_ERR_INVALID_STATE,
TAG,
"esp_event_loop_create_default fail, returns(0x%x).",
"esp_event_loop_create_default fail, returns(0x%" PRIx32 ").",
(uint32_t)result);
#if CONFIG_MB_MDNS_IP_RESOLVER
// 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();
MB_RETURN_ON_FALSE((result == ESP_OK), ESP_ERR_INVALID_STATE,
TAG,
"example_connect fail, returns(0x%x).",
"example_connect fail, returns(0x%" PRIx32 ").",
(uint32_t)result);
#if CONFIG_EXAMPLE_CONNECT_WIFI
result = esp_wifi_set_ps(WIFI_PS_NONE);
MB_RETURN_ON_FALSE((result == ESP_OK), ESP_ERR_INVALID_STATE,
TAG,
"esp_wifi_set_ps fail, returns(0x%x).",
"esp_wifi_set_ps fail, returns(0x%" PRIx32 ").",
(uint32_t)result);
#endif
#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);
}
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.");
return ESP_ERR_NOT_FOUND;
}
@ -660,22 +660,22 @@ static esp_err_t destroy_services(void)
err = example_disconnect();
MB_RETURN_ON_FALSE((err == ESP_OK), ESP_ERR_INVALID_STATE,
TAG,
"example_disconnect fail, returns(0x%x).",
"example_disconnect fail, returns(0x%" PRIx32 ").",
(uint32_t)err);
err = esp_event_loop_delete_default();
MB_RETURN_ON_FALSE((err == ESP_OK), ESP_ERR_INVALID_STATE,
TAG,
"esp_event_loop_delete_default fail, returns(0x%x).",
"esp_event_loop_delete_default fail, returns(0x%" PRIx32 ").",
(uint32_t)err);
err = esp_netif_deinit();
MB_RETURN_ON_FALSE((err == ESP_OK || err == ESP_ERR_NOT_SUPPORTED), ESP_ERR_INVALID_STATE,
TAG,
"esp_netif_deinit fail, returns(0x%x).",
"esp_netif_deinit fail, returns(0x%" PRIx32 ").",
(uint32_t)err);
err = nvs_flash_deinit();
MB_RETURN_ON_FALSE((err == ESP_OK), ESP_ERR_INVALID_STATE,
TAG,
"nvs_flash_deinit fail, returns(0x%x).",
"nvs_flash_deinit fail, returns(0x%" PRIx32 ").",
(uint32_t)err);
return err;
}
@ -691,26 +691,26 @@ static esp_err_t master_init(mb_communication_info_t* comm_info)
"mb controller initialization fail.");
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%" PRIx32 ").",
(uint32_t)err);
err = mbc_master_setup((void*)comm_info);
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%" PRIx32 ").",
(uint32_t)err);
err = mbc_master_set_descriptor(&device_parameters[0], num_device_parameters);
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%" PRIx32 ").",
(uint32_t)err);
ESP_LOGI(TAG, "Modbus master stack initialized...");
err = mbc_master_start();
MB_RETURN_ON_FALSE((err == ESP_OK), ESP_ERR_INVALID_STATE,
TAG,
"mb controller start fail, returns(0x%x).",
"mb controller start fail, returns(0x%" PRIx32 ").",
(uint32_t)err);
vTaskDelay(5);
return err;
@ -721,7 +721,7 @@ static esp_err_t master_destroy(void)
esp_err_t err = mbc_master_destroy();
MB_RETURN_ON_FALSE((err == ESP_OK), ESP_ERR_INVALID_STATE,
TAG,
"mbc_master_destroy fail, returns(0x%x).",
"mbc_master_destroy fail, returns(0x%" PRIx32 ").",
(uint32_t)err);
ESP_LOGI(TAG, "Modbus master stack destroy...");
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)) {
// Get parameter information from parameter queue
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,
(uint32_t)reg_info.time_stamp,
(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) {
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.mb_offset,
(uint32_t)reg_info.type,
@ -200,7 +200,7 @@ static void slave_operation_func(void *arg)
(uint32_t)reg_info.size);
} else if (event & MB_EVENT_DISCRETE_RD) {
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.mb_offset,
(uint32_t)reg_info.type,
@ -208,7 +208,7 @@ static void slave_operation_func(void *arg)
(uint32_t)reg_info.size);
} 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_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,
(uint32_t)reg_info.time_stamp,
(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,
TAG,
"nvs_flash_init fail, returns(0x%x).",
"nvs_flash_init fail, returns(0x%" PRIx32 ").",
(uint32_t)result);
result = esp_netif_init();
MB_RETURN_ON_FALSE((result == ESP_OK), ESP_ERR_INVALID_STATE,
TAG,
"esp_netif_init fail, returns(0x%x).",
"esp_netif_init fail, returns(0x%" PRIx32 ").",
(uint32_t)result);
result = esp_event_loop_create_default();
MB_RETURN_ON_FALSE((result == ESP_OK), ESP_ERR_INVALID_STATE,
TAG,
"esp_event_loop_create_default fail, returns(0x%x).",
"esp_event_loop_create_default fail, returns(0x%" PRIx32 ").",
(uint32_t)result);
#if CONFIG_MB_MDNS_IP_RESOLVER
// Start mdns service and register device
@ -254,13 +254,13 @@ static esp_err_t init_services(void)
result = example_connect();
MB_RETURN_ON_FALSE((result == ESP_OK), ESP_ERR_INVALID_STATE,
TAG,
"example_connect fail, returns(0x%x).",
"example_connect fail, returns(0x%" PRIx32 ").",
(uint32_t)result);
#if CONFIG_EXAMPLE_CONNECT_WIFI
result = esp_wifi_set_ps(WIFI_PS_NONE);
MB_RETURN_ON_FALSE((result == ESP_OK), ESP_ERR_INVALID_STATE,
TAG,
"esp_wifi_set_ps fail, returns(0x%x).",
"esp_wifi_set_ps fail, returns(0x%" PRIx32 ").",
(uint32_t)result);
#endif
return ESP_OK;
@ -273,22 +273,22 @@ static esp_err_t destroy_services(void)
err = example_disconnect();
MB_RETURN_ON_FALSE((err == ESP_OK), ESP_ERR_INVALID_STATE,
TAG,
"example_disconnect fail, returns(0x%x).",
"example_disconnect fail, returns(0x%" PRIx32 ").",
(uint32_t)err);
err = esp_event_loop_delete_default();
MB_RETURN_ON_FALSE((err == ESP_OK), ESP_ERR_INVALID_STATE,
TAG,
"esp_event_loop_delete_default fail, returns(0x%x).",
"esp_event_loop_delete_default fail, returns(0x%" PRIx32 ").",
(uint32_t)err);
err = esp_netif_deinit();
MB_RETURN_ON_FALSE((err == ESP_OK || err == ESP_ERR_NOT_SUPPORTED), ESP_ERR_INVALID_STATE,
TAG,
"esp_netif_deinit fail, returns(0x%x).",
"esp_netif_deinit fail, returns(0x%" PRIx32 ").",
(uint32_t)err);
err = nvs_flash_deinit();
MB_RETURN_ON_FALSE((err == ESP_OK), ESP_ERR_INVALID_STATE,
TAG,
"nvs_flash_deinit fail, returns(0x%x).",
"nvs_flash_deinit fail, returns(0x%" PRIx32 ").",
(uint32_t)err);
#if CONFIG_MB_MDNS_IP_RESOLVER
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);
MB_RETURN_ON_FALSE((err == ESP_OK), ESP_ERR_INVALID_STATE,
TAG,
"mbc_slave_setup fail, returns(0x%x).",
"mbc_slave_setup fail, returns(0x%" PRIx32 ").",
(uint32_t)err);
// 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);
MB_RETURN_ON_FALSE((err == ESP_OK), ESP_ERR_INVALID_STATE,
TAG,
"mbc_slave_set_descriptor fail, returns(0x%x).",
"mbc_slave_set_descriptor fail, returns(0x%" PRIx32 ").",
(uint32_t)err);
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);
MB_RETURN_ON_FALSE((err == ESP_OK), ESP_ERR_INVALID_STATE,
TAG,
"mbc_slave_set_descriptor fail, returns(0x%x).",
"mbc_slave_set_descriptor fail, returns(0x%" PRIx32 ").",
(uint32_t)err);
// 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);
MB_RETURN_ON_FALSE((err == ESP_OK), ESP_ERR_INVALID_STATE,
TAG,
"mbc_slave_set_descriptor fail, returns(0x%x).",
"mbc_slave_set_descriptor fail, returns(0x%" PRIx32 ").",
(uint32_t)err);
reg_area.type = MB_PARAM_INPUT;
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);
MB_RETURN_ON_FALSE((err == ESP_OK), ESP_ERR_INVALID_STATE,
TAG,
"mbc_slave_set_descriptor fail, returns(0x%x).",
"mbc_slave_set_descriptor fail, returns(0x%" PRIx32 ").",
(uint32_t)err);
// 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);
MB_RETURN_ON_FALSE((err == ESP_OK), ESP_ERR_INVALID_STATE,
TAG,
"mbc_slave_set_descriptor fail, returns(0x%x).",
"mbc_slave_set_descriptor fail, returns(0x%" PRIx32 ").",
(uint32_t)err);
// 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);
MB_RETURN_ON_FALSE((err == ESP_OK), ESP_ERR_INVALID_STATE,
TAG,
"mbc_slave_set_descriptor fail, returns(0x%x).",
"mbc_slave_set_descriptor fail, returns(0x%" PRIx32 ").",
(uint32_t)err);
// 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();
MB_RETURN_ON_FALSE((err == ESP_OK), ESP_ERR_INVALID_STATE,
TAG,
"mbc_slave_start fail, returns(0x%x).",
"mbc_slave_start fail, returns(0x%" PRIx32 ").",
(uint32_t)err);
vTaskDelay(5);
return err;
@ -405,7 +405,7 @@ static esp_err_t slave_destroy(void)
esp_err_t err = mbc_slave_destroy();
MB_RETURN_ON_FALSE((err == ESP_OK), ESP_ERR_INVALID_STATE,
TAG,
"mbc_slave_destroy fail, returns(0x%x).",
"mbc_slave_destroy fail, returns(0x%" PRIx32 ").",
(uint32_t)err);
return err;
}