From 0a96f62ed672fd2aed33eaa3b00c6ed6fdfe149c Mon Sep 17 00:00:00 2001 From: Alex Lisitsyn Date: Tue, 18 Feb 2025 19:09:45 +0800 Subject: [PATCH] esp-event event handler unregister function causes memory leak --- modbus/mb_ports/tcp/port_tcp_driver.c | 38 ++++++++++++------ modbus/mb_ports/tcp/port_tcp_driver.h | 39 +++++++++++++------ modbus/mb_ports/tcp/port_tcp_master.c | 38 +++++++++--------- modbus/mb_ports/tcp/port_tcp_slave.c | 37 ++++++++---------- .../main/test_modbus_tcp_comm_master_slave.c | 4 +- .../pytest_mb_comm_multi_dev.py | 4 +- 6 files changed, 94 insertions(+), 66 deletions(-) diff --git a/modbus/mb_ports/tcp/port_tcp_driver.c b/modbus/mb_ports/tcp/port_tcp_driver.c index 49a38fb..ca5cc01 100644 --- a/modbus/mb_ports/tcp/port_tcp_driver.c +++ b/modbus/mb_ports/tcp/port_tcp_driver.c @@ -153,31 +153,40 @@ static esp_err_t mb_drv_event_loop_deinit(void *ctx) return err; } -esp_err_t mb_drv_register_handler(void *ctx, mb_driver_event_t event, mb_event_handler_fp fp) +esp_err_t mb_drv_register_handler(void *ctx, mb_driver_event_num_t event_num, mb_event_handler_fp fp) { port_driver_t *pdrv_ctx = MB_GET_DRV_PTR(ctx); esp_err_t ret = ESP_ERR_INVALID_STATE; + mb_driver_event_t event = MB_EVENT_FROM_NUM(event_num); - ESP_LOGD(TAG, "%p, event 0x%x, register.", pdrv_ctx, (int)event); + ESP_LOGD(TAG, "%p, event #%d, 0x%x, register.", pdrv_ctx, (int)event_num, (int)event); + MB_RETURN_ON_FALSE((pdrv_ctx->event_handler[event_num] == NULL), ESP_ERR_INVALID_ARG, + TAG, "%p, event handler %p, for event %x, is not empty.", pdrv_ctx, pdrv_ctx->event_handler[event_num], (int)event); ret = esp_event_handler_instance_register_with(mb_drv_loop_handle, MB_EVENT_BASE(ctx), event, - fp, ctx, &pdrv_ctx->event_handler); - MB_RETURN_ON_FALSE((ret == ESP_OK), ESP_ERR_INVALID_STATE , - TAG, "%p, event handler %p, registration error.", pdrv_ctx, pdrv_ctx->event_handler); + fp, ctx, &pdrv_ctx->event_handler[event_num]); + ESP_LOGD(TAG, "%p, registered event handler %p, event 0x%x", pdrv_ctx, pdrv_ctx->event_handler[event_num], (int)event); + MB_RETURN_ON_FALSE((ret == ESP_OK), ESP_ERR_INVALID_STATE, + TAG, "%p, event handler %p, registration error.", pdrv_ctx, pdrv_ctx->event_handler[event_num]); return ESP_OK; } -esp_err_t mb_drv_unregister_handler(void *ctx, mb_driver_event_t event) +esp_err_t mb_drv_unregister_handler(void *ctx, mb_driver_event_num_t event_num) { port_driver_t *pdrv_ctx = MB_GET_DRV_PTR(ctx); esp_err_t ret = ESP_ERR_INVALID_STATE; - ESP_LOGD(TAG, "%p, event handler %p, event 0x%x, unregister.", pdrv_ctx, pdrv_ctx->event_handler, (int)event); + mb_driver_event_t event = MB_EVENT_FROM_NUM(event_num); + + ESP_LOGD(TAG, "%p, event handler %p, event 0x%x, unregister.", pdrv_ctx, pdrv_ctx->event_handler[event_num], (int)event); + MB_RETURN_ON_FALSE((pdrv_ctx->event_handler[event_num]), ESP_ERR_INVALID_ARG, + TAG, "%p, event handler %p, for event %x, is incorrect.", pdrv_ctx, pdrv_ctx->event_handler[event_num], (int)event); ret = esp_event_handler_instance_unregister_with(mb_drv_loop_handle, - MB_EVENT_BASE(ctx), (int32_t)event, pdrv_ctx->event_handler); - MB_RETURN_ON_FALSE((ret == ESP_OK), ESP_ERR_INVALID_STATE , - TAG, "%p, event handler %p, unregister error.", pdrv_ctx, pdrv_ctx->event_handler); + MB_EVENT_BASE(ctx), (int32_t)event, pdrv_ctx->event_handler[event_num]); + pdrv_ctx->event_handler[event_num] = NULL; + MB_RETURN_ON_FALSE((ret == ESP_OK), ESP_ERR_INVALID_STATE , + TAG, "%p, event handler %p, instance unregister with, error = %d", pdrv_ctx, pdrv_ctx->event_handler[event_num], (int)ret); return ESP_OK; } @@ -666,6 +675,7 @@ esp_err_t mb_drv_register(port_driver_t **ctx) { port_driver_t driver_config = MB_DRIVER_CONFIG_DEFAULT; esp_err_t ret = ESP_ERR_INVALID_STATE; + int i = 0; port_driver_t *pctx = (port_driver_t *)calloc(1, sizeof(port_driver_t)); MB_GOTO_ON_FALSE((pctx), ESP_ERR_NO_MEM, error, TAG, "%p, driver allocation fail.", pctx); @@ -673,13 +683,17 @@ esp_err_t mb_drv_register(port_driver_t **ctx) CRITICAL_SECTION_INIT(pctx->lock); - // create and initialize modbus driver conetext structure + // create and initialize modbus driver context structure pctx->mb_nodes = calloc(MB_MAX_FDS, sizeof(mb_node_info_t *)); MB_GOTO_ON_FALSE((pctx->mb_nodes), ESP_ERR_NO_MEM, error, TAG, "%p, node allocation fail.", pctx); - for (int i = 0; i < MB_MAX_FDS; i++) { + for (i = 0; i < MB_MAX_FDS; i++) { pctx->mb_nodes[i] = NULL; } + // initialization of event handlers + for (i = 0; i < MB_EVENT_COUNT; i++) { + pctx->event_handler[i] = NULL; + } ret = init_event_fd((void *)pctx); MB_GOTO_ON_FALSE((ret == ESP_OK), ESP_ERR_INVALID_STATE , error, diff --git a/modbus/mb_ports/tcp/port_tcp_driver.h b/modbus/mb_ports/tcp/port_tcp_driver.h index 8707742..c2b4113 100644 --- a/modbus/mb_ports/tcp/port_tcp_driver.h +++ b/modbus/mb_ports/tcp/port_tcp_driver.h @@ -139,16 +139,31 @@ typedef struct _port_driver port_driver_t; atomic_store(&(((mb_node_info_t *)pnode)->addr_info.state), node_state); \ } while(0) +#define MB_EVENT_FROM_NUM(event_num) ((mb_driver_event_t)(1 << (event_num))) + +typedef enum _mb_event_num { + MB_EVENT_READY_NUM = 0, + MB_EVENT_OPEN_NUM = 1, + MB_EVENT_RESOLVE_NUM = 2, + MB_EVENT_CONNECT_NUM = 3, + MB_EVENT_SEND_DATA_NUM = 4, + MB_EVENT_RECV_DATA_NUM = 5, + MB_EVENT_ERROR_NUM = 6, + MB_EVENT_CLOSE_NUM = 7, + MB_EVENT_TIMEOUT_NUM = 8, + MB_EVENT_COUNT = 9 +} mb_driver_event_num_t; + typedef enum _mb_driver_event { - MB_EVENT_READY = 0x0001, - MB_EVENT_OPEN = 0x0002, - MB_EVENT_RESOLVE = 0x0004, - MB_EVENT_CONNECT = 0x0008, - MB_EVENT_SEND_DATA = 0x0010, - MB_EVENT_RECV_DATA = 0x0020, - MB_EVENT_ERROR = 0x0040, - MB_EVENT_CLOSE = 0x0080, - MB_EVENT_TIMEOUT = 0x0100 + MB_EVENT_READY = (1 << MB_EVENT_READY_NUM), + MB_EVENT_OPEN = (1 << MB_EVENT_OPEN_NUM), + MB_EVENT_RESOLVE = (1 << MB_EVENT_RESOLVE_NUM), + MB_EVENT_CONNECT = (1 << MB_EVENT_CONNECT_NUM), + MB_EVENT_SEND_DATA = (1 << MB_EVENT_SEND_DATA_NUM), + MB_EVENT_RECV_DATA = (1 << MB_EVENT_RECV_DATA_NUM), + MB_EVENT_ERROR = (1 << MB_EVENT_ERROR_NUM), + MB_EVENT_CLOSE = (1 << MB_EVENT_CLOSE_NUM), + MB_EVENT_TIMEOUT =(1 << MB_EVENT_TIMEOUT_NUM) } mb_driver_event_t; typedef struct { @@ -234,7 +249,7 @@ typedef struct _port_driver { EventGroupHandle_t status_flags_hdl; /*!< status bits to control nodes states */ TaskHandle_t mb_tcp_task_handle; /*!< TCP/UDP handling task handle */ esp_event_loop_handle_t event_loop_hdl; /*!< event loop handle */ - esp_event_handler_instance_t event_handler; /*!< event handler instance */ + esp_event_handler_instance_t event_handler[MB_EVENT_COUNT]; /*!< event handler instance */ char *loop_name; /*!< name for event loop used as base */ mb_driver_event_cb_t event_cbs; //LIST_HEAD(mb_uid_info_, mb_uid_entry_s) node_list; /*!< node address information list */ @@ -313,9 +328,9 @@ void mb_drv_set_cb(void *ctx, void *conn_cb, void *arg); mb_status_flags_t mb_drv_wait_status_flag(void *ctx, mb_status_flags_t mask, TickType_t ticks); -esp_err_t mb_drv_register_handler(void *ctx, mb_driver_event_t event, mb_event_handler_fp fp); +esp_err_t mb_drv_register_handler(void *ctx, mb_driver_event_num_t event, mb_event_handler_fp fp); -esp_err_t mb_drv_unregister_handler(void *ctx, mb_driver_event_t event); +esp_err_t mb_drv_unregister_handler(void *ctx, mb_driver_event_num_t event); void mb_drv_check_suspend_shutdown(void *ctx); diff --git a/modbus/mb_ports/tcp/port_tcp_master.c b/modbus/mb_ports/tcp/port_tcp_master.c index 54c3be2..28709e7 100644 --- a/modbus/mb_ports/tcp/port_tcp_master.c +++ b/modbus/mb_ports/tcp/port_tcp_master.c @@ -33,31 +33,31 @@ static esp_err_t mbm_port_tcp_register_handlers(void *ctx) port_driver_t *pdrv_ctx = MB_GET_DRV_PTR(ctx); esp_err_t ret = ESP_ERR_INVALID_STATE; - ret = mb_drv_register_handler(pdrv_ctx, MB_EVENT_READY, mbm_on_ready); + ret = mb_drv_register_handler(pdrv_ctx, MB_EVENT_READY_NUM, mbm_on_ready); MB_RETURN_ON_FALSE((ret == ESP_OK), MB_EINVAL, TAG, "%x, mb tcp port event registration failed.", (int)MB_EVENT_READY); - ret = mb_drv_register_handler(pdrv_ctx, MB_EVENT_OPEN, mbm_on_open); + ret = mb_drv_register_handler(pdrv_ctx, MB_EVENT_OPEN_NUM, mbm_on_open); MB_RETURN_ON_FALSE((ret == ESP_OK), MB_EINVAL, TAG, "%x, mb tcp port event registration failed.", (int)MB_EVENT_OPEN); - ret = mb_drv_register_handler(pdrv_ctx, MB_EVENT_RESOLVE, mbm_on_resolve); + ret = mb_drv_register_handler(pdrv_ctx, MB_EVENT_RESOLVE_NUM, mbm_on_resolve); MB_RETURN_ON_FALSE((ret == ESP_OK), MB_EINVAL, TAG, "%x, mb tcp port event registration failed.", (int)MB_EVENT_RESOLVE); - ret = mb_drv_register_handler(pdrv_ctx, MB_EVENT_CONNECT, mbm_on_connect); + ret = mb_drv_register_handler(pdrv_ctx, MB_EVENT_CONNECT_NUM, mbm_on_connect); MB_RETURN_ON_FALSE((ret == ESP_OK), MB_EINVAL, TAG, "%x, mb tcp port event registration failed.", (int)MB_EVENT_CONNECT); - ret = mb_drv_register_handler(pdrv_ctx, MB_EVENT_ERROR, mbm_on_error); + ret = mb_drv_register_handler(pdrv_ctx, MB_EVENT_ERROR_NUM, mbm_on_error); MB_RETURN_ON_FALSE((ret == ESP_OK), MB_EINVAL, TAG, "%x, mb tcp port event registration failed.", (int)MB_EVENT_ERROR); - ret = mb_drv_register_handler(pdrv_ctx, MB_EVENT_SEND_DATA, mbm_on_send_data); + ret = mb_drv_register_handler(pdrv_ctx, MB_EVENT_SEND_DATA_NUM, mbm_on_send_data); MB_RETURN_ON_FALSE((ret == ESP_OK), MB_EINVAL, TAG, "%x, mb tcp port event registration failed.", (int)MB_EVENT_SEND_DATA); - ret = mb_drv_register_handler(pdrv_ctx, MB_EVENT_RECV_DATA, mbm_on_recv_data); + ret = mb_drv_register_handler(pdrv_ctx, MB_EVENT_RECV_DATA_NUM, mbm_on_recv_data); MB_RETURN_ON_FALSE((ret == ESP_OK), MB_EINVAL, TAG, "%x, mb tcp port event registration failed.", (int)MB_EVENT_RECV_DATA); - ret = mb_drv_register_handler(pdrv_ctx, MB_EVENT_CLOSE, mbm_on_close); + ret = mb_drv_register_handler(pdrv_ctx, MB_EVENT_CLOSE_NUM, mbm_on_close); MB_RETURN_ON_FALSE((ret == ESP_OK), MB_EINVAL, TAG, "%x, mb tcp port event registration failed.", (int)MB_EVENT_CLOSE); - ret = mb_drv_register_handler(pdrv_ctx, MB_EVENT_TIMEOUT, mbm_on_timeout); + ret = mb_drv_register_handler(pdrv_ctx, MB_EVENT_TIMEOUT_NUM, mbm_on_timeout); MB_RETURN_ON_FALSE((ret == ESP_OK), MB_EINVAL, TAG, "%x, mb tcp port event registration failed.", (int)MB_EVENT_TIMEOUT); return ESP_OK; @@ -69,31 +69,31 @@ static esp_err_t mbm_port_tcp_unregister_handlers(void *ctx) esp_err_t ret = ESP_ERR_INVALID_STATE; ESP_LOGD(TAG, "%p, event handler %p, unregister.", pdrv_ctx, pdrv_ctx->event_handler); - ret = mb_drv_unregister_handler(pdrv_ctx, MB_EVENT_READY); + ret = mb_drv_unregister_handler(pdrv_ctx, MB_EVENT_READY_NUM); MB_RETURN_ON_FALSE((ret == ESP_OK), MB_EINVAL, TAG, "%x, mb tcp port event registration failed.", (int)MB_EVENT_READY); - ret = mb_drv_unregister_handler(pdrv_ctx, MB_EVENT_OPEN); + ret = mb_drv_unregister_handler(pdrv_ctx, MB_EVENT_OPEN_NUM); MB_RETURN_ON_FALSE((ret == ESP_OK), MB_EINVAL, TAG, "%x, mb tcp port event registration failed.", (int)MB_EVENT_OPEN); - ret = mb_drv_unregister_handler(pdrv_ctx, MB_EVENT_RESOLVE); + ret = mb_drv_unregister_handler(pdrv_ctx, MB_EVENT_RESOLVE_NUM); MB_RETURN_ON_FALSE((ret == ESP_OK), MB_EINVAL, TAG, "%x, mb tcp port event registration failed.", (int)MB_EVENT_RESOLVE); - ret = mb_drv_unregister_handler(pdrv_ctx, MB_EVENT_CONNECT); + ret = mb_drv_unregister_handler(pdrv_ctx, MB_EVENT_CONNECT_NUM); MB_RETURN_ON_FALSE((ret == ESP_OK), MB_EINVAL, TAG, "%x, mb tcp port event registration failed.", (int)MB_EVENT_CONNECT); - ret = mb_drv_unregister_handler(pdrv_ctx, MB_EVENT_ERROR); + ret = mb_drv_unregister_handler(pdrv_ctx, MB_EVENT_ERROR_NUM); MB_RETURN_ON_FALSE((ret == ESP_OK), MB_EINVAL, TAG, "%x, mb tcp port event registration failed.", (int)MB_EVENT_ERROR); - ret = mb_drv_unregister_handler(pdrv_ctx, MB_EVENT_SEND_DATA); + ret = mb_drv_unregister_handler(pdrv_ctx, MB_EVENT_SEND_DATA_NUM); MB_RETURN_ON_FALSE((ret == ESP_OK), MB_EINVAL, TAG, "%x, mb tcp port event registration failed.", (int)MB_EVENT_SEND_DATA); - ret = mb_drv_unregister_handler(pdrv_ctx, MB_EVENT_RECV_DATA); + ret = mb_drv_unregister_handler(pdrv_ctx, MB_EVENT_RECV_DATA_NUM); MB_RETURN_ON_FALSE((ret == ESP_OK), MB_EINVAL, TAG, "%x, mb tcp port event registration failed.", (int)MB_EVENT_RECV_DATA); - ret = mb_drv_unregister_handler(pdrv_ctx, MB_EVENT_CLOSE); + ret = mb_drv_unregister_handler(pdrv_ctx, MB_EVENT_CLOSE_NUM); MB_RETURN_ON_FALSE((ret == ESP_OK), MB_EINVAL, TAG, "%x, mb tcp port event registration failed.", (int)MB_EVENT_CLOSE); - ret = mb_drv_unregister_handler(pdrv_ctx, MB_EVENT_TIMEOUT); + ret = mb_drv_unregister_handler(pdrv_ctx, MB_EVENT_TIMEOUT_NUM); MB_RETURN_ON_FALSE((ret == ESP_OK), MB_EINVAL, TAG, "%x, mb tcp port event registration failed.", (int)MB_EVENT_TIMEOUT); return ESP_OK; @@ -189,7 +189,7 @@ void mbm_port_tcp_delete(mb_port_base_t *inst) mbm_tcp_port_t *port_obj = __containerof(inst, mbm_tcp_port_t, base); esp_err_t err = MB_EILLSTATE; err = mbm_port_tcp_unregister_handlers(port_obj->pdriver); - MB_RETURN_ON_FALSE((err == ESP_OK), ;, TAG, "mb tcp port invalid arguments."); + MB_RETURN_ON_FALSE((err == ESP_OK), ;, TAG, "mb tcp port can not unregister handlers."); #ifdef MB_MDNS_IS_INCLUDED port_stop_mdns_service(&port_obj->pdriver->dns_name); #endif diff --git a/modbus/mb_ports/tcp/port_tcp_slave.c b/modbus/mb_ports/tcp/port_tcp_slave.c index 43a619b..a4417cd 100644 --- a/modbus/mb_ports/tcp/port_tcp_slave.c +++ b/modbus/mb_ports/tcp/port_tcp_slave.c @@ -41,28 +41,28 @@ static esp_err_t mbs_port_tcp_register_handlers(void *ctx) port_driver_t *pdrv_ctx = MB_GET_DRV_PTR(ctx); esp_err_t ret = ESP_ERR_INVALID_STATE; - ret = mb_drv_register_handler(pdrv_ctx, MB_EVENT_READY, mbs_on_ready); + ret = mb_drv_register_handler(pdrv_ctx, MB_EVENT_READY_NUM, mbs_on_ready); MB_RETURN_ON_FALSE((ret == ESP_OK), MB_EINVAL, TAG, "%x, mb tcp port event registration failed.", (int)MB_EVENT_READY); - ret = mb_drv_register_handler(pdrv_ctx, MB_EVENT_OPEN, mbs_on_open); + ret = mb_drv_register_handler(pdrv_ctx, MB_EVENT_OPEN_NUM, mbs_on_open); MB_RETURN_ON_FALSE((ret == ESP_OK), MB_EINVAL, TAG, "%x, mb tcp port event registration failed.", (int)MB_EVENT_OPEN); - ret = mb_drv_register_handler(pdrv_ctx, MB_EVENT_CONNECT, mbs_on_connect); + ret = mb_drv_register_handler(pdrv_ctx, MB_EVENT_CONNECT_NUM, mbs_on_connect); MB_RETURN_ON_FALSE((ret == ESP_OK), MB_EINVAL, TAG, "%x, mb tcp port event registration failed.", (int)MB_EVENT_CONNECT); - ret = mb_drv_register_handler(pdrv_ctx, MB_EVENT_ERROR, mbs_on_error); + ret = mb_drv_register_handler(pdrv_ctx, MB_EVENT_ERROR_NUM, mbs_on_error); MB_RETURN_ON_FALSE((ret == ESP_OK), MB_EINVAL, TAG, "%x, mb tcp port event registration failed.", (int)MB_EVENT_ERROR); - ret = mb_drv_register_handler(pdrv_ctx, MB_EVENT_SEND_DATA, mbs_on_send_data); + ret = mb_drv_register_handler(pdrv_ctx, MB_EVENT_SEND_DATA_NUM, mbs_on_send_data); MB_RETURN_ON_FALSE((ret == ESP_OK), MB_EINVAL, TAG, "%x, mb tcp port event registration failed.", (int)MB_EVENT_SEND_DATA); - ret = mb_drv_register_handler(pdrv_ctx, MB_EVENT_RECV_DATA, mbs_on_recv_data); + ret = mb_drv_register_handler(pdrv_ctx, MB_EVENT_RECV_DATA_NUM, mbs_on_recv_data); MB_RETURN_ON_FALSE((ret == ESP_OK), MB_EINVAL, TAG, "%x, mb tcp port event registration failed.", (int)MB_EVENT_RECV_DATA); - ret = mb_drv_register_handler(pdrv_ctx, MB_EVENT_CLOSE, mbs_on_close); + ret = mb_drv_register_handler(pdrv_ctx, MB_EVENT_CLOSE_NUM, mbs_on_close); MB_RETURN_ON_FALSE((ret == ESP_OK), MB_EINVAL, TAG, "%x, mb tcp port event registration failed.", (int)MB_EVENT_CLOSE); - ret = mb_drv_register_handler(pdrv_ctx, MB_EVENT_TIMEOUT, mbs_on_timeout); + ret = mb_drv_register_handler(pdrv_ctx, MB_EVENT_TIMEOUT_NUM, mbs_on_timeout); MB_RETURN_ON_FALSE((ret == ESP_OK), MB_EINVAL, TAG, "%x, mb tcp port event registration failed.", (int)MB_EVENT_TIMEOUT); return ESP_OK; @@ -74,25 +74,25 @@ static esp_err_t mbs_port_tcp_unregister_handlers(void *ctx) esp_err_t ret = ESP_ERR_INVALID_STATE; ESP_LOGD(TAG, "%p, event handler %p, unregister.", pdrv_ctx, pdrv_ctx->event_handler); - ret = mb_drv_unregister_handler(pdrv_ctx, MB_EVENT_READY); + ret = mb_drv_unregister_handler(pdrv_ctx, MB_EVENT_READY_NUM); MB_RETURN_ON_FALSE((ret == ESP_OK), MB_EINVAL, TAG, "%x, mb tcp port event registration failed.", (int)MB_EVENT_READY); - ret = mb_drv_unregister_handler(pdrv_ctx, MB_EVENT_OPEN); + ret = mb_drv_unregister_handler(pdrv_ctx, MB_EVENT_OPEN_NUM); MB_RETURN_ON_FALSE((ret == ESP_OK), MB_EINVAL, TAG, "%x, mb tcp port event registration failed.", (int)MB_EVENT_OPEN); - ret = mb_drv_unregister_handler(pdrv_ctx, MB_EVENT_CONNECT); + ret = mb_drv_unregister_handler(pdrv_ctx, MB_EVENT_CONNECT_NUM); MB_RETURN_ON_FALSE((ret == ESP_OK), MB_EINVAL, TAG, "%x, mb tcp port event registration failed.", (int)MB_EVENT_CONNECT); - ret = mb_drv_unregister_handler(pdrv_ctx, MB_EVENT_SEND_DATA); + ret = mb_drv_unregister_handler(pdrv_ctx, MB_EVENT_SEND_DATA_NUM); MB_RETURN_ON_FALSE((ret == ESP_OK), MB_EINVAL, TAG, "%x, mb tcp port event registration failed.", (int)MB_EVENT_SEND_DATA); - ret = mb_drv_unregister_handler(pdrv_ctx, MB_EVENT_RECV_DATA); + ret = mb_drv_unregister_handler(pdrv_ctx, MB_EVENT_RECV_DATA_NUM); MB_RETURN_ON_FALSE((ret == ESP_OK), MB_EINVAL, TAG, "%x, mb tcp port event registration failed.", (int)MB_EVENT_RECV_DATA); - ret = mb_drv_unregister_handler(pdrv_ctx, MB_EVENT_CLOSE); + ret = mb_drv_unregister_handler(pdrv_ctx, MB_EVENT_CLOSE_NUM); MB_RETURN_ON_FALSE((ret == ESP_OK), MB_EINVAL, TAG, "%x, mb tcp port event registration failed.", (int)MB_EVENT_CLOSE); - ret = mb_drv_unregister_handler(pdrv_ctx, MB_EVENT_TIMEOUT); + ret = mb_drv_unregister_handler(pdrv_ctx, MB_EVENT_TIMEOUT_NUM); MB_RETURN_ON_FALSE((ret == ESP_OK), MB_EINVAL, TAG, "%x, mb tcp port event registration failed.", (int)MB_EVENT_TIMEOUT); return ESP_OK; @@ -158,10 +158,8 @@ error: #endif if (ptcp && ptcp->pdriver) { - if (ptcp->pdriver->event_handler) - { + if (ptcp->pdriver->event_handler[0]) { mbs_port_tcp_unregister_handlers(ptcp->pdriver); - ptcp->pdriver->event_handler = NULL; } (void)mb_drv_unregister(ptcp->pdriver); CRITICAL_SECTION_CLOSE(ptcp->base.lock); @@ -182,10 +180,9 @@ void mbs_port_tcp_delete(mb_port_base_t *inst) #endif if (port_obj && port_obj->pdriver) { - if (port_obj->pdriver->event_handler) + if (port_obj->pdriver->event_handler[0]) { mbs_port_tcp_unregister_handlers(port_obj->pdriver); - port_obj->pdriver->event_handler = NULL; } (void)mb_drv_unregister(port_obj->pdriver); CRITICAL_SECTION_CLOSE(port_obj->base.lock); diff --git a/test_apps/physical_tests/main/test_modbus_tcp_comm_master_slave.c b/test_apps/physical_tests/main/test_modbus_tcp_comm_master_slave.c index c3df360..61f1cf6 100644 --- a/test_apps/physical_tests/main/test_modbus_tcp_comm_master_slave.c +++ b/test_apps/physical_tests/main/test_modbus_tcp_comm_master_slave.c @@ -201,11 +201,13 @@ static void test_modbus_tcp_master(void) void *pnetif = NULL; TEST_ASSERT_TRUE(test_tcp_services_init(&pnetif) == ESP_OK); TEST_ASSERT_NOT_NULL(pnetif); + test_common_start(); ESP_LOGI(TAG, "Master TCP is started (%s).", __func__); unity_wait_for_signal("Slave_ready"); + // Initialize and start Modbus controller mb_communication_info_t tcp_master_cfg_1 = { .tcp_opts.port = TEST_TCP_PORT_NUM1, @@ -235,7 +237,7 @@ static void test_modbus_tcp_master(void) /* * Modbus TCP multi device test case */ -TEST_CASE_MULTIPLE_DEVICES("Modbus TCP multi device master - slave case.", "[modbus][test_env=multi_dut_modbus_tcp]", +TEST_CASE_MULTIPLE_DEVICES("Modbus TCP multi device master - slave case.", "[modbus][test_env=multi_dut_modbus_tcp]", test_modbus_tcp_slave, test_modbus_tcp_master); #endif \ No newline at end of file diff --git a/test_apps/physical_tests/pytest_mb_comm_multi_dev.py b/test_apps/physical_tests/pytest_mb_comm_multi_dev.py index d712f14..b9ddca7 100644 --- a/test_apps/physical_tests/pytest_mb_comm_multi_dev.py +++ b/test_apps/physical_tests/pytest_mb_comm_multi_dev.py @@ -10,7 +10,7 @@ from pytest_embedded_idf import CaseTester def test_modbus_comm_multi_dev_serial(case_tester) -> None: # type: ignore for case in case_tester.test_menu: if case.attributes.get('test_env', 'multi_dut_modbus_serial') == 'multi_dut_modbus_serial': - print(case.name) + print(f'Test case: {case.name}') case_tester.run_multi_dev_case(case=case, reset=True) @pytest.mark.esp32 @@ -19,5 +19,5 @@ def test_modbus_comm_multi_dev_serial(case_tester) -> None: # typ def test_modbus_comm_multi_dev_tcp(case_tester) -> None: # type: ignore for case in case_tester.test_menu: if case.attributes.get('test_env', 'multi_dut_modbus_tcp') == 'multi_dut_modbus_tcp': - print(case.name) + print(f'Test case: {case.name}') case_tester.run_multi_dev_case(case=case, reset=True) \ No newline at end of file