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

esp-event event handler unregister function causes memory leak

Browse Source
This commit is contained in:
Alex Lisitsyn
2025-02-18 19:09:45 +08:00
parent 4b07c64437
commit 0a96f62ed6
6 changed files with 94 additions and 66 deletions
Download Patch File Download Diff File Expand all files Collapse all files

38
modbus/mb_ports/tcp/port_tcp_driver.c
View File

@ -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,

39
modbus/mb_ports/tcp/port_tcp_driver.h
View File

@ -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);

38
modbus/mb_ports/tcp/port_tcp_master.c
View File

@ -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

37
modbus/mb_ports/tcp/port_tcp_slave.c
View File

@ -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);

4
test_apps/physical_tests/main/test_modbus_tcp_comm_master_slave.c
View File

@ -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

4
test_apps/physical_tests/pytest_mb_comm_multi_dev.py
View File

@ -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)