diff --git a/.gitlab-ci.yml b/.gitlab-ci.yml index cc3e1ad..c9f08a5 100644 --- a/.gitlab-ci.yml +++ b/.gitlab-ci.yml @@ -1,4 +1,5 @@ stages: + - pre_check - build - target_test - deploy @@ -18,6 +19,8 @@ variables: .options_list: # versions: # IDF_VER: ["latest", "v5.3", "v5.2", "v5.0"] + analyzers: + ANALYZER_TYPE: [gcc, clang] markers: TEST_MARKER: - "tcp" @@ -117,6 +120,7 @@ after_script: - *build_cur_folder variables: TEST_TARGETS: "esp32" + dependencies: [] artifacts: name: artifacts_${CI_JOB_NAME} paths: @@ -133,15 +137,48 @@ after_script: - "**/build*/partition_table/*.bin" - "**/idf_version_info.txt" - "**/test_dir*.txt" + - "**/warnings.txt" - $SIZE_INFO_LOCATION when: always expire_in: 3 weeks + needs: [] + +.before_static_analyzer_build: + before_script: + - pip install --upgrade pyclang + - ${IDF_PATH}/tools/idf_tools.py --non-interactive install esp-clang + - . $IDF_PATH/export.sh + +build_static_analyzer_idf_latest: + tags: + - build + stage: pre_check + extends: + - .before_static_analyzer_build + image: espressif/idf:latest + artifacts: + name: artifacts_${CI_JOB_NAME} + paths: + - "${TEST_DIR}/**/idf_version_info.txt" + - "${TEST_DIR}/**/warnings.txt" + - "${TEST_DIR}/**/sdkconfig" + when: always + expire_in: 3 weeks + parallel: + matrix: + - !reference [.options_list, analyzers] + script: + - *check_idf_ver + - cd ${TEST_DIR}/examples + - ${TEST_DIR}/tools/static_analyzer_check.sh ${ANALYZER_TYPE} + needs: [] + after_script: [] build_idf_latest: - extends: .build_pytest_template - image: espressif/idf:latest - variables: - TEST_TARGETS: "esp32 esp32s2 esp32s3 esp32c2 esp32c3 esp32c5 esp32c6 esp32h2" + extends: .build_pytest_template + image: espressif/idf:latest + variables: + TEST_TARGETS: "esp32 esp32s2 esp32s3 esp32c2 esp32c3 esp32c5 esp32c6 esp32h2" build_idf_v5.3: extends: .build_pytest_template diff --git a/CMakeLists.txt b/CMakeLists.txt index badeb70..5a75e89 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -91,4 +91,9 @@ endforeach() # target_link_options(${COMPONENT_LIB} INTERFACE -fsanitize=address) target_compile_options(${COMPONENT_LIB} PRIVATE -Wno-strict-aliasing -Wno-write-strings -Werror) +if(CONFIG_FMB_COMPILER_STATIC_ANALYZER_ENABLE AND CMAKE_C_COMPILER_ID STREQUAL "GNU") + target_compile_options(${COMPONENT_LIB} PRIVATE "-fanalyzer") + message(STATUS "Static analyzer option `-analyzer` is applied for ${COMPONENT_NAME}.") +endif() + message(STATUS "The mdns included is: ${MB_MDNS_IS_INCLUDED}") diff --git a/Kconfig b/Kconfig index 57a01cb..47f0b77 100644 --- a/Kconfig +++ b/Kconfig @@ -232,4 +232,13 @@ menu "Modbus configuration" This option defines the maximum number of Modbus command handlers for Modbus master and slave. The option can be useful to register additional commands and its handlers. + config FMB_COMPILER_STATIC_ANALYZER_ENABLE + bool "Enable compiler static analyzer for Modbus library" + default "n" + depends on IDF_TOOLCHAIN_GCC + help + Enable compiler static analyzer for Modbus library. + This is workaround to avoid false-positives for some IDF related components. + When enabled, the library files will be analysed with GCC static analyzer. + endmenu diff --git a/examples/serial/mb_serial_master/main/CMakeLists.txt b/examples/serial/mb_serial_master/main/CMakeLists.txt index ae72f36..c97034e 100644 --- a/examples/serial/mb_serial_master/main/CMakeLists.txt +++ b/examples/serial/mb_serial_master/main/CMakeLists.txt @@ -2,3 +2,9 @@ set(PROJECT_NAME "modbus_serial_master") idf_component_register(SRCS "serial_master.c" INCLUDE_DIRS ".") + +# Workaround to avoid static analysis false positives for some components. +if(CONFIG_FMB_COMPILER_STATIC_ANALYZER_ENABLE AND CMAKE_C_COMPILER_ID STREQUAL "GNU") + target_compile_options(${COMPONENT_LIB} PRIVATE "-fanalyzer") + message(STATUS "Static analyzer build for ${PROJECT_NAME}.") +endif() diff --git a/examples/serial/mb_serial_master/main/serial_master.c b/examples/serial/mb_serial_master/main/serial_master.c index 5b454df..b0e1098 100644 --- a/examples/serial/mb_serial_master/main/serial_master.c +++ b/examples/serial/mb_serial_master/main/serial_master.c @@ -56,7 +56,7 @@ #define OPTS(min_val, max_val, step_val) { .opt1 = min_val, .opt2 = max_val, .opt3 = step_val } #define EACH_ITEM(array, length) \ - (typeof(*(array)) *pitem = (array); (pitem < &((array)[length])); pitem++) + (typeof(*(array)) *item_ptr = (array); (item_ptr < &((array)[length])); item_ptr++) #define MB_CUST_DATA_LEN 100 // The length of custom command buffer @@ -259,55 +259,55 @@ static void *master_get_param_data(const mb_parameter_descriptor_t *param_descri return instance_ptr; } -#define TEST_VERIFY_VALUES(handle, pdescr, pinst) (__extension__( \ -{ \ - assert(pinst); \ - assert(pdescr); \ - uint8_t type = 0; \ - esp_err_t err = ESP_FAIL; \ - err = mbc_master_get_parameter(handle, pdescr->cid, \ - (uint8_t *)pinst, &type); \ - if (err == ESP_OK) { \ - bool is_correct = true; \ - if (pdescr->param_opts.opt3) { \ - for EACH_ITEM(pinst, pdescr->param_size / sizeof(*pitem)) { \ - if (*pitem != (typeof(*(pinst)))pdescr->param_opts.opt3) { \ - *pitem = (typeof(*(pinst)))pdescr->param_opts.opt3; \ - ESP_LOGD(TAG, "Characteristic #%d (%s), initialize to 0x%" PRIx16 ".", \ - (int)pdescr->cid, \ - (char *)pdescr->param_key, \ - (uint16_t)pdescr->param_opts.opt3); \ - is_correct = false; \ - } \ - } \ - } \ - if (!is_correct) { \ - ESP_LOGE(TAG, "Characteristic #%d (%s), initialize.", \ - (int)pdescr->cid, \ - (char *)pdescr->param_key); \ - err = mbc_master_set_parameter(handle, cid, (uint8_t *)pinst, &type); \ - if (err != ESP_OK) { \ - ESP_LOGE(TAG, "Characteristic #%d (%s) write fail, err = 0x%x (%s).", \ - (int)pdescr->cid, \ - (char *)pdescr->param_key, \ - (int)err, \ - (char *)esp_err_to_name(err)); \ - } else { \ - ESP_LOGI(TAG, "Characteristic #%d %s (%s) value = (..) write successful.", \ - (int)pdescr->cid, \ - (char *)pdescr->param_key, \ - (char *)pdescr->param_units); \ - } \ - } \ - } else { \ - ESP_LOGE(TAG, "Characteristic #%d (%s) read fail, err = 0x%x (%s).", \ - (int)pdescr->cid, \ - (char *)pdescr->param_key, \ - (int)err, \ - (char *)esp_err_to_name(err)); \ - } \ - (err); \ -} \ +#define TEST_VERIFY_VALUES(handle, descr, inst) (__extension__( \ +{ \ + assert(inst); \ + assert(descr); \ + uint8_t type = 0; \ + esp_err_t err = ESP_FAIL; \ + err = mbc_master_get_parameter(handle, descr->cid, \ + (uint8_t *)inst, &type); \ + if (err == ESP_OK) { \ + bool is_correct = true; \ + if (descr->param_opts.opt3) { \ + for EACH_ITEM(inst, descr->param_size / sizeof(*item_ptr)) { \ + if (*item_ptr != (typeof(*(inst)))descr->param_opts.opt3) { \ + *item_ptr = (typeof(*(inst)))descr->param_opts.opt3; \ + ESP_LOGD(TAG, "Characteristic #%d (%s), initialize to 0x%" PRIx16 ".", \ + (int)descr->cid, \ + (char *)descr->param_key, \ + (uint16_t)descr->param_opts.opt3); \ + is_correct = false; \ + } \ + } \ + } \ + if (!is_correct) { \ + ESP_LOGE(TAG, "Characteristic #%d (%s), initialize.", \ + (int)descr->cid, \ + (char *)descr->param_key); \ + err = mbc_master_set_parameter(handle, cid, (uint8_t *)inst, &type); \ + if (err != ESP_OK) { \ + ESP_LOGE(TAG, "Characteristic #%d (%s) write fail, err = 0x%x (%s).", \ + (int)descr->cid, \ + (char *)descr->param_key, \ + (int)err, \ + (char *)esp_err_to_name(err)); \ + } else { \ + ESP_LOGI(TAG, "Characteristic #%d %s (%s) value = (..) write successful.", \ + (int)descr->cid, \ + (char *)descr->param_key, \ + (char *)descr->param_units); \ + } \ + } \ + } else { \ + ESP_LOGE(TAG, "Characteristic #%d (%s) read fail, err = 0x%x (%s).", \ + (int)descr->cid, \ + (char *)descr->param_key, \ + (int)err, \ + (char *)esp_err_to_name(err)); \ + } \ + (err); \ +} \ )) // User operation function to read slave values and check alarm @@ -494,15 +494,15 @@ static void master_operation_func(void *arg) // This is the custom function handler for the command. // The handler is executed from the context of modbus controller event task and should be as simple as possible. // Parameters: frame_ptr - the pointer to the incoming ADU frame from slave starting from function code, -// plen - the pointer to length of the frame. After return from the handler the modbus object will +// len - the pointer to length of the frame. After return from the handler the modbus object will // handle the end of transaction according to the exception returned. -mb_exception_t my_custom_handler(void *inst, uint8_t *frame_ptr, uint16_t *plen) +mb_exception_t my_custom_handler(void *inst, uint8_t *frame_ptr, uint16_t *len) { - MB_RETURN_ON_FALSE((frame_ptr && plen && *plen && *plen < (MB_CUST_DATA_LEN - 1)), MB_EX_ILLEGAL_DATA_VALUE, TAG, + MB_RETURN_ON_FALSE((frame_ptr && len && *len && *len < (MB_CUST_DATA_LEN - 1)), MB_EX_ILLEGAL_DATA_VALUE, TAG, "incorrect custom frame buffer"); - ESP_LOGD(TAG, "Custom handler, Frame ptr: %p, len: %u", frame_ptr, *plen); + ESP_LOGD(TAG, "Custom handler, Frame ptr: %p, len: %u", frame_ptr, *len); strncpy((char *)&my_custom_data[0], (char *)&frame_ptr[1], MB_CUST_DATA_LEN); - ESP_LOG_BUFFER_HEXDUMP("CUSTOM_DATA", &my_custom_data[0], (*plen - 1), ESP_LOG_WARN); + ESP_LOG_BUFFER_HEXDUMP("CUSTOM_DATA", &my_custom_data[0], (*len - 1), ESP_LOG_WARN); return MB_EX_NONE; } @@ -539,9 +539,9 @@ static esp_err_t master_init(void) err = mbc_set_handler(master_handle, override_command, my_custom_handler); MB_RETURN_ON_FALSE((err == ESP_OK), ESP_ERR_INVALID_STATE, TAG, "could not override handler, returned (0x%x).", (int)err); - mb_fn_handler_fp phandler = NULL; - err = mbc_get_handler(master_handle, override_command, &phandler); - MB_RETURN_ON_FALSE((err == ESP_OK && phandler == my_custom_handler), ESP_ERR_INVALID_STATE, TAG, + mb_fn_handler_fp handler = NULL; + err = mbc_get_handler(master_handle, override_command, &handler); + MB_RETURN_ON_FALSE((err == ESP_OK && handler == my_custom_handler), ESP_ERR_INVALID_STATE, TAG, "could not get handler for command %d, returned (0x%x).", (int)override_command, (int)err); // Set UART pin numbers diff --git a/examples/serial/mb_serial_master/sdkconfig.ci.ascii b/examples/serial/mb_serial_master/sdkconfig.ci.ascii index 7776818..830b889 100644 --- a/examples/serial/mb_serial_master/sdkconfig.ci.ascii +++ b/examples/serial/mb_serial_master/sdkconfig.ci.ascii @@ -7,3 +7,4 @@ CONFIG_FMB_TIMER_USE_ISR_DISPATCH_METHOD=y CONFIG_FMB_EXT_TYPE_SUPPORT=y CONFIG_HEAP_POISONING_COMPREHENSIVE=y CONFIG_HEAP_TRACING_OFF=y + diff --git a/examples/serial/mb_serial_master/sdkconfig.defaults b/examples/serial/mb_serial_master/sdkconfig.defaults new file mode 100644 index 0000000..80f3665 --- /dev/null +++ b/examples/serial/mb_serial_master/sdkconfig.defaults @@ -0,0 +1,9 @@ +CONFIG_MB_COMM_MODE_ASCII=n +CONFIG_MB_COMM_MODE_RTU=y +CONFIG_MB_UART_BAUD_RATE=115200 +CONFIG_FMB_MASTER_DELAY_MS_CONVERT=200 +CONFIG_FMB_MASTER_TIMEOUT_MS_RESPOND=400 +CONFIG_FMB_TIMER_USE_ISR_DISPATCH_METHOD=y +CONFIG_FMB_EXT_TYPE_SUPPORT=y +CONFIG_HEAP_POISONING_COMPREHENSIVE=y +CONFIG_HEAP_TRACING_OFF=y diff --git a/examples/serial/mb_serial_slave/main/CMakeLists.txt b/examples/serial/mb_serial_slave/main/CMakeLists.txt index 9220403..a6f301e 100644 --- a/examples/serial/mb_serial_slave/main/CMakeLists.txt +++ b/examples/serial/mb_serial_slave/main/CMakeLists.txt @@ -1,4 +1,10 @@ -set(PROJECT_NAME "modbus_serial_slave") - idf_component_register(SRCS "serial_slave.c" INCLUDE_DIRS ".") + +set(PROJECT_NAME "modbus_serial_slave") + +# Workaround to avoid static analysis false positives for some components. +if(CONFIG_FMB_COMPILER_STATIC_ANALYZER_ENABLE AND CMAKE_C_COMPILER_ID STREQUAL "GNU") + target_compile_options(${COMPONENT_LIB} PRIVATE "-fanalyzer") + message(STATUS "Static analyzer build for ${PROJECT_NAME}.") +endif() diff --git a/examples/serial/mb_serial_slave/main/serial_slave.c b/examples/serial/mb_serial_slave/main/serial_slave.c index 0d776f7..76ab580 100644 --- a/examples/serial/mb_serial_slave/main/serial_slave.c +++ b/examples/serial/mb_serial_slave/main/serial_slave.c @@ -83,15 +83,15 @@ static void setup_reg_data(void) discrete_reg_params.discrete_input6 = 1; discrete_reg_params.discrete_input7 = 0; - holding_reg_params.holding_data0 = 1.34; - holding_reg_params.holding_data1 = 2.56; - holding_reg_params.holding_data2 = 3.78; - holding_reg_params.holding_data3 = 4.90; + holding_reg_params.holding_data0 = 1.34F; + holding_reg_params.holding_data1 = 2.56F; + holding_reg_params.holding_data2 = 3.78F; + holding_reg_params.holding_data3 = 4.90F; - holding_reg_params.holding_data4 = 5.67; - holding_reg_params.holding_data5 = 6.78; - holding_reg_params.holding_data6 = 7.79; - holding_reg_params.holding_data7 = 8.80; + holding_reg_params.holding_data4 = 5.67F; + holding_reg_params.holding_data5 = 6.78F; + holding_reg_params.holding_data6 = 7.79F; + holding_reg_params.holding_data7 = 8.80F; #if CONFIG_FMB_EXT_TYPE_SUPPORT mb_set_uint8_a((val_16_arr *)&holding_reg_params.holding_u8_a[0], (uint8_t)0x55); @@ -134,32 +134,32 @@ static void setup_reg_data(void) coil_reg_params.coils_port0 = 0x55; coil_reg_params.coils_port1 = 0xAA; - input_reg_params.input_data0 = 1.12; - input_reg_params.input_data1 = 2.34; - input_reg_params.input_data2 = 3.56; - input_reg_params.input_data3 = 4.78; + input_reg_params.input_data0 = 1.12F; + input_reg_params.input_data1 = 2.34F; + input_reg_params.input_data2 = 3.56F; + input_reg_params.input_data3 = 4.78F; - input_reg_params.input_data4 = 1.12; - input_reg_params.input_data5 = 2.34; - input_reg_params.input_data6 = 3.56; - input_reg_params.input_data7 = 4.78; + input_reg_params.input_data4 = 1.12F; + input_reg_params.input_data5 = 2.34F; + input_reg_params.input_data6 = 3.56F; + input_reg_params.input_data7 = 4.78F; } // This is a simple custom function handler for the command. // The handler is executed from the context of modbus controller event task and should be as simple as possible. // Parameters: frame_ptr - the pointer to the incoming ADU request frame from master starting from function code, -// plen - the pointer to length of the frame. The handler body can override the buffer and return the length of data. +// len - the pointer to length of the frame. The handler body can override the buffer and return the length of data. // After return from the handler the modbus object will handle the end of transaction according to the exception returned, // then builds the response frame and send it back to the master. If the whole transaction time including the response // latency exceeds the configured slave response time set in the master configuration the master will ignore the transaction. -mb_exception_t my_custom_fc_handler(void *pinst, uint8_t *frame_ptr, uint16_t *plen) +mb_exception_t my_custom_fc_handler(void *inst, uint8_t *frame_ptr, uint16_t *len) { char *str_append = ":Slave"; - MB_RETURN_ON_FALSE((frame_ptr && plen && *plen < (MB_CUST_DATA_MAX_LEN - strlen(str_append))), MB_EX_ILLEGAL_DATA_VALUE, TAG, + MB_RETURN_ON_FALSE((frame_ptr && len && *len < (MB_CUST_DATA_MAX_LEN - strlen(str_append))), MB_EX_ILLEGAL_DATA_VALUE, TAG, "incorrect custom frame"); - frame_ptr[*plen] = '\0'; + frame_ptr[*len] = '\0'; strcat((char *)&frame_ptr[1], str_append); - *plen = (strlen(str_append) + *plen); // the length of (response + command) + *len = (strlen(str_append) + *len); // the length of (response + command) return MB_EX_NONE; // Set the exception code for modbus object appropriately } @@ -200,9 +200,9 @@ void app_main(void) err = mbc_set_handler(mbc_slave_handle, custom_command, my_custom_fc_handler); MB_RETURN_ON_FALSE((err == ESP_OK), ;, TAG, "could not set or override handler, returned (0x%x).", (int)err); - mb_fn_handler_fp phandler = NULL; - err = mbc_get_handler(mbc_slave_handle, custom_command, &phandler); - MB_RETURN_ON_FALSE((err == ESP_OK && phandler == my_custom_fc_handler), ;, TAG, + mb_fn_handler_fp handler = NULL; + err = mbc_get_handler(mbc_slave_handle, custom_command, &handler); + MB_RETURN_ON_FALSE((err == ESP_OK && handler == my_custom_fc_handler), ;, TAG, "could not get handler for command %d, returned (0x%x).", (int)custom_command, (int)err); // The code below initializes Modbus register area descriptors @@ -283,7 +283,7 @@ void app_main(void) uint8_t is_running = (bool)(err == ESP_OK); // This is the way to set Slave ID fields to retrieve it by master using report slave ID command. - err = mbc_set_slave_id(mbc_slave_handle, comm_config.ser_opts.uid, is_running, (uint8_t *)&new_id_struct.length, new_id_struct.length); + err = mbc_set_slave_id(mbc_slave_handle, comm_config.ser_opts.uid, is_running, &new_id_struct.length, new_id_struct.length); if (err == ESP_OK) { ESP_LOGW("SET_SLAVE_ID", "dev_name: %s", (char*)new_id_struct.dev_name); ESP_LOG_BUFFER_HEX_LEVEL("SET_SLAVE_ID", (void*)&new_id_struct.length, new_id_struct.length, ESP_LOG_WARN); @@ -344,7 +344,10 @@ void app_main(void) (unsigned)reg_info.type, (uint32_t)reg_info.address, (unsigned)reg_info.size); - if (coil_reg_params.coils_port1 == 0xFF) break; + if (coil_reg_params.coils_port1 == 0xFF) { + ESP_LOGI(TAG, "Stop polling."); + break; + } } } // Destroy of Modbus controller on alarm diff --git a/examples/serial/mb_serial_slave/sdkconfig.ci.ascii b/examples/serial/mb_serial_slave/sdkconfig.ci.ascii index c60c2ce..67171ae 100644 --- a/examples/serial/mb_serial_slave/sdkconfig.ci.ascii +++ b/examples/serial/mb_serial_slave/sdkconfig.ci.ascii @@ -5,4 +5,4 @@ CONFIG_MB_UART_BAUD_RATE=115200 CONFIG_FMB_TIMER_USE_ISR_DISPATCH_METHOD=y CONFIG_FMB_EXT_TYPE_SUPPORT=y CONFIG_HEAP_POISONING_COMPREHENSIVE=y -CONFIG_HEAP_TRACING_OFF=y \ No newline at end of file +CONFIG_HEAP_TRACING_OFF=y diff --git a/examples/serial/mb_serial_slave/sdkconfig.defaults b/examples/serial/mb_serial_slave/sdkconfig.defaults index 57eb523..7d47de0 100644 --- a/examples/serial/mb_serial_slave/sdkconfig.defaults +++ b/examples/serial/mb_serial_slave/sdkconfig.defaults @@ -9,3 +9,4 @@ CONFIG_FMB_TIMER_USE_ISR_DISPATCH_METHOD=y CONFIG_FMB_EXT_TYPE_SUPPORT=y CONFIG_HEAP_POISONING_COMPREHENSIVE=y CONFIG_HEAP_TRACING_OFF=y + diff --git a/examples/tcp/mb_tcp_master/main/CMakeLists.txt b/examples/tcp/mb_tcp_master/main/CMakeLists.txt index 842f186..f805b3b 100644 --- a/examples/tcp/mb_tcp_master/main/CMakeLists.txt +++ b/examples/tcp/mb_tcp_master/main/CMakeLists.txt @@ -2,3 +2,9 @@ set(PROJECT_NAME "modbus_tcp_master") idf_component_register(SRCS "tcp_master.c" INCLUDE_DIRS ".") + +# Workaround to avoid static analysis false positives for some components. +if(CONFIG_FMB_COMPILER_STATIC_ANALYZER_ENABLE AND CMAKE_C_COMPILER_ID STREQUAL "GNU") + target_compile_options(${COMPONENT_LIB} PRIVATE "-fanalyzer") + message(STATUS "Static analyzer build for ${PROJECT_NAME}.") +endif() \ No newline at end of file diff --git a/examples/tcp/mb_tcp_master/main/tcp_master.c b/examples/tcp/mb_tcp_master/main/tcp_master.c index 889eef0..90869eb 100644 --- a/examples/tcp/mb_tcp_master/main/tcp_master.c +++ b/examples/tcp/mb_tcp_master/main/tcp_master.c @@ -66,7 +66,7 @@ #define OPTS(min_val, max_val, step_val) { .opt1 = min_val, .opt2 = max_val, .opt3 = step_val } #define EACH_ITEM(array, length) \ - (typeof(*(array)) *pitem = (array); (pitem < &((array)[length])); pitem++) + (typeof(*(array)) *item_ptr = (array); (item_ptr < &((array)[length])); item_ptr++) #define MB_ID_BYTE0(id) ((uint8_t)(id)) #define MB_ID_BYTE1(id) ((uint8_t)(((uint16_t)(id) >> 8) & 0xFF)) @@ -399,54 +399,54 @@ static void *master_get_param_data(const mb_parameter_descriptor_t *param_descri return instance_ptr; } -#define TEST_VERIFY_VALUES(handle, pdescr, pinst) (__extension__( \ -{ \ - assert(pinst); \ - assert(pdescr); \ - uint8_t type = 0; \ - esp_err_t err = ESP_FAIL; \ - err = mbc_master_get_parameter(handle, pdescr->cid, (uint8_t *)pinst, &type); \ - if (err == ESP_OK) { \ - bool is_correct = true; \ - if (pdescr->param_opts.opt3) { \ - for EACH_ITEM(pinst, pdescr->param_size / sizeof(*pitem)) { \ - if (*pitem != (typeof(*(pinst)))pdescr->param_opts.opt3) { \ - *pitem = (typeof(*(pinst)))pdescr->param_opts.opt3; \ - ESP_LOGD(TAG, "Characteristic #%d (%s), initialize to 0x%" PRIx16 ".", \ - (int)pdescr->cid, \ - (char *)pdescr->param_key, \ - (uint16_t)pdescr->param_opts.opt3); \ - is_correct = false; \ - } \ - } \ - } \ - if (!is_correct) { \ - ESP_LOGE(TAG, "Characteristic #%d (%s), initialize.", \ - (int)pdescr->cid, \ - (char *)pdescr->param_key); \ - err = mbc_master_set_parameter(handle, cid, (uint8_t *)pinst, &type); \ - if (err != ESP_OK) { \ - ESP_LOGE(TAG, "Characteristic #%d (%s) write fail, err = 0x%x (%s).", \ - (int)pdescr->cid, \ - (char *)pdescr->param_key, \ - (int)err, \ - (char *)esp_err_to_name(err)); \ - } else { \ - ESP_LOGI(TAG, "Characteristic #%d %s (%s) value = (..) write successful.", \ - (int)pdescr->cid, \ - (char *)pdescr->param_key, \ - (char *)pdescr->param_units); \ - } \ - } \ - } else { \ - ESP_LOGE(TAG, "Characteristic #%d (%s) read fail, err = 0x%x (%s).", \ - (int)pdescr->cid, \ - (char *)pdescr->param_key, \ - (int)err, \ - (char *)esp_err_to_name(err)); \ - } \ - (err); \ -} \ +#define TEST_VERIFY_VALUES(handle, descr, inst) (__extension__( \ +{ \ + assert(inst); \ + assert(descr); \ + uint8_t type = 0; \ + esp_err_t err = ESP_FAIL; \ + err = mbc_master_get_parameter(handle, descr->cid, (uint8_t *)inst, &type); \ + if (err == ESP_OK) { \ + bool is_correct = true; \ + if (descr->param_opts.opt3) { \ + for EACH_ITEM(inst, descr->param_size / sizeof(*item_ptr)) { \ + if (*item_ptr != (typeof(*(inst)))descr->param_opts.opt3) { \ + *item_ptr = (typeof(*(inst)))descr->param_opts.opt3; \ + ESP_LOGD(TAG, "Characteristic #%d (%s), initialize to 0x%" PRIx16 ".", \ + (int)descr->cid, \ + (char *)descr->param_key, \ + (uint16_t)descr->param_opts.opt3); \ + is_correct = false; \ + } \ + } \ + } \ + if (!is_correct) { \ + ESP_LOGE(TAG, "Characteristic #%d (%s), initialize.", \ + (int)descr->cid, \ + (char *)descr->param_key); \ + err = mbc_master_set_parameter(handle, cid, (uint8_t *)inst, &type); \ + if (err != ESP_OK) { \ + ESP_LOGE(TAG, "Characteristic #%d (%s) write fail, err = 0x%x (%s).", \ + (int)descr->cid, \ + (char *)descr->param_key, \ + (int)err, \ + (char *)esp_err_to_name(err)); \ + } else { \ + ESP_LOGI(TAG, "Characteristic #%d %s (%s) value = (..) write successful.", \ + (int)descr->cid, \ + (char *)descr->param_key, \ + (char *)descr->param_units); \ + } \ + } \ + } else { \ + ESP_LOGE(TAG, "Characteristic #%d (%s) read fail, err = 0x%x (%s).", \ + (int)descr->cid, \ + (char *)descr->param_key, \ + (int)err, \ + (char *)esp_err_to_name(err)); \ + } \ + (err); \ +} \ )) // User operation function to read slave values and check alarm @@ -684,15 +684,15 @@ static esp_err_t destroy_services(void) // This is the custom function handler for the command. // The handler is executed from the context of modbus controller event task and should be as simple as possible. // Parameters: frame_ptr - the pointer to the incoming ADU frame from slave starting from function code, -// plen - the pointer to length of the frame. After return from the handler the modbus object will +// len - the pointer to length of the frame. After return from the handler the modbus object will // handle the end of transaction according to the exception returned. -mb_exception_t my_custom_fc_handler(void *inst, uint8_t *frame_ptr, uint16_t *plen) +mb_exception_t my_custom_fc_handler(void *inst, uint8_t *frame_ptr, uint16_t *len) { - MB_RETURN_ON_FALSE((frame_ptr && plen && *plen && *plen < (MB_CUST_DATA_LEN - 1)), MB_EX_ILLEGAL_DATA_VALUE, TAG, + MB_RETURN_ON_FALSE((frame_ptr && len && *len && *len < (MB_CUST_DATA_LEN - 1)), MB_EX_ILLEGAL_DATA_VALUE, TAG, "incorrect custom frame buffer"); - ESP_LOGI(TAG, "Custom handler, Frame ptr: %p, len: %u", frame_ptr, *plen); + ESP_LOGI(TAG, "Custom handler, Frame ptr: %p, len: %u", frame_ptr, *len); strncpy((char *)&my_custom_data[0], (char *)&frame_ptr[1], MB_CUST_DATA_LEN); - ESP_LOG_BUFFER_HEXDUMP("CUSTOM_DATA", &my_custom_data[0], (*plen - 1), ESP_LOG_INFO); + ESP_LOG_BUFFER_HEXDUMP("CUSTOM_DATA", &my_custom_data[0], (*len - 1), ESP_LOG_INFO); return MB_EX_NONE; } @@ -717,9 +717,9 @@ static esp_err_t master_init(mb_communication_info_t *pcomm_info) err = mbc_set_handler(master_handle, custom_command, my_custom_fc_handler); MB_RETURN_ON_FALSE((err == ESP_OK), ESP_ERR_INVALID_STATE, TAG, "could not override handler, returned (0x%x).", (int)err); - mb_fn_handler_fp phandler = NULL; - err = mbc_get_handler(master_handle, custom_command, &phandler); - MB_RETURN_ON_FALSE((err == ESP_OK && phandler == my_custom_fc_handler), ESP_ERR_INVALID_STATE, TAG, + mb_fn_handler_fp handler = NULL; + err = mbc_get_handler(master_handle, custom_command, &handler); + MB_RETURN_ON_FALSE((err == ESP_OK && handler == my_custom_fc_handler), ESP_ERR_INVALID_STATE, TAG, "could not get handler for command %d, returned (0x%x).", (int)custom_command, (int)err); err = mbc_master_set_descriptor(master_handle, &device_parameters[0], num_device_parameters); diff --git a/examples/tcp/mb_tcp_master/sdkconfig.ci.ethernet b/examples/tcp/mb_tcp_master/sdkconfig.ci.ethernet index 8901360..0225375 100644 --- a/examples/tcp/mb_tcp_master/sdkconfig.ci.ethernet +++ b/examples/tcp/mb_tcp_master/sdkconfig.ci.ethernet @@ -34,3 +34,4 @@ CONFIG_ETH_USE_SPI_ETHERNET=n CONFIG_HEAP_POISONING_COMPREHENSIVE=y CONFIG_HEAP_TRACING_OFF=y + diff --git a/examples/tcp/mb_tcp_master/sdkconfig.ci.wifi b/examples/tcp/mb_tcp_master/sdkconfig.ci.wifi index 4f7b881..c1f520d 100644 --- a/examples/tcp/mb_tcp_master/sdkconfig.ci.wifi +++ b/examples/tcp/mb_tcp_master/sdkconfig.ci.wifi @@ -21,3 +21,4 @@ CONFIG_EXAMPLE_WIFI_PASSWORD="${CI_WIFI_PASSW}" CONFIG_HEAP_POISONING_COMPREHENSIVE=y CONFIG_HEAP_TRACING_OFF=y + diff --git a/examples/tcp/mb_tcp_slave/main/CMakeLists.txt b/examples/tcp/mb_tcp_slave/main/CMakeLists.txt index 1cf5f19..24c84a2 100644 --- a/examples/tcp/mb_tcp_slave/main/CMakeLists.txt +++ b/examples/tcp/mb_tcp_slave/main/CMakeLists.txt @@ -2,3 +2,9 @@ set(PROJECT_NAME "modbus_tcp_slave") idf_component_register(SRCS "tcp_slave.c" INCLUDE_DIRS ".") + +# Workaround to avoid static analysis false positives for some components. +if(CONFIG_FMB_COMPILER_STATIC_ANALYZER_ENABLE AND CMAKE_C_COMPILER_ID STREQUAL "GNU") + target_compile_options(${COMPONENT_LIB} PRIVATE "-fanalyzer") + message(STATUS "Static analyzer build for ${PROJECT_NAME}.") +endif() diff --git a/examples/tcp/mb_tcp_slave/main/tcp_slave.c b/examples/tcp/mb_tcp_slave/main/tcp_slave.c index 3c875b3..a141a19 100644 --- a/examples/tcp/mb_tcp_slave/main/tcp_slave.c +++ b/examples/tcp/mb_tcp_slave/main/tcp_slave.c @@ -72,15 +72,15 @@ static void setup_reg_data(void) discrete_reg_params.discrete_input6 = 1; discrete_reg_params.discrete_input7 = 0; - holding_reg_params.holding_data0 = 1.34; - holding_reg_params.holding_data1 = 2.56; - holding_reg_params.holding_data2 = 3.78; - holding_reg_params.holding_data3 = 4.90; + holding_reg_params.holding_data0 = 1.34F; + holding_reg_params.holding_data1 = 2.56F; + holding_reg_params.holding_data2 = 3.78F; + holding_reg_params.holding_data3 = 4.90F; - holding_reg_params.holding_data4 = 5.67; - holding_reg_params.holding_data5 = 6.78; - holding_reg_params.holding_data6 = 7.79; - holding_reg_params.holding_data7 = 8.80; + holding_reg_params.holding_data4 = 5.67F; + holding_reg_params.holding_data5 = 6.78F; + holding_reg_params.holding_data6 = 7.79F; + holding_reg_params.holding_data7 = 8.80F; #if CONFIG_FMB_EXT_TYPE_SUPPORT mb_set_uint8_a((val_16_arr *)&holding_reg_params.holding_u8_a[0], (uint8_t)0x55); @@ -123,14 +123,14 @@ static void setup_reg_data(void) coil_reg_params.coils_port0 = 0x55; coil_reg_params.coils_port1 = 0xAA; - input_reg_params.input_data0 = 1.12; - input_reg_params.input_data1 = 2.34; - input_reg_params.input_data2 = 3.56; - input_reg_params.input_data3 = 4.78; - input_reg_params.input_data4 = 1.12; - input_reg_params.input_data5 = 2.34; - input_reg_params.input_data6 = 3.56; - input_reg_params.input_data7 = 4.78; + input_reg_params.input_data0 = 1.12F; + input_reg_params.input_data1 = 2.34F; + input_reg_params.input_data2 = 3.56F; + input_reg_params.input_data3 = 4.78F; + input_reg_params.input_data4 = 1.12F; + input_reg_params.input_data5 = 2.34F; + input_reg_params.input_data6 = 3.56F; + input_reg_params.input_data7 = 4.78F; } static void slave_operation_func(void *arg) @@ -268,18 +268,18 @@ static esp_err_t destroy_services(void) // This is a simple custom function handler for the command. // The handler is executed from the context of modbus controller event task and should be as simple as possible. // Parameters: frame_ptr - the pointer to the incoming ADU request frame from master starting from function code, -// plen - the pointer to length of the frame. The handler body can override the buffer and return the length of data. +// len - the pointer to length of the frame. The handler body can override the buffer and return the length of data. // After return from the handler the modbus object will handle the end of transaction according to the exception returned, // then builds the response frame and send it back to the master. If the whole transaction time including the response // latency exceeds the configured slave response time set in the master configuration the master will ignore the transaction. -mb_exception_t my_custom_fc_handler(void *pinst, uint8_t *frame_ptr, uint16_t *plen) +mb_exception_t my_custom_fc_handler(void *inst, uint8_t *frame_ptr, uint16_t *len) { char *str_append = ":Slave"; - MB_RETURN_ON_FALSE((frame_ptr && plen && *plen < (MB_CUST_DATA_MAX_LEN - strlen(str_append))), MB_EX_ILLEGAL_DATA_VALUE, TAG, + MB_RETURN_ON_FALSE((frame_ptr && len && *len < (MB_CUST_DATA_MAX_LEN - strlen(str_append))), MB_EX_ILLEGAL_DATA_VALUE, TAG, "incorrect custom frame"); - frame_ptr[*plen] = '\0'; + frame_ptr[*len] = '\0'; strcat((char *)&frame_ptr[1], str_append); - *plen = (strlen(str_append) + *plen); // the length of (response + command) + *len = (strlen(str_append) + *len); // the length of (response + command) return MB_EX_NONE; // Set the exception code for modbus object appropriately } @@ -302,9 +302,9 @@ static esp_err_t slave_init(mb_communication_info_t *pcomm_info) err = mbc_set_handler(slave_handle, custom_command, my_custom_fc_handler); MB_RETURN_ON_FALSE((err == ESP_OK), ESP_ERR_INVALID_STATE, TAG, "could not set or override handler, returned (0x%x).", (int)err); - mb_fn_handler_fp phandler = NULL; - err = mbc_get_handler(slave_handle, custom_command, &phandler); - MB_RETURN_ON_FALSE((err == ESP_OK && phandler == my_custom_fc_handler), ESP_ERR_INVALID_STATE, TAG, + mb_fn_handler_fp handler = NULL; + err = mbc_get_handler(slave_handle, custom_command, &handler); + MB_RETURN_ON_FALSE((err == ESP_OK && handler == my_custom_fc_handler), ESP_ERR_INVALID_STATE, TAG, "could not get handler for command %d, returned (0x%x).", (int)custom_command, (int)err); // The code below initializes Modbus register area descriptors diff --git a/examples/tcp/mb_tcp_slave/sdkconfig.ci.ethernet b/examples/tcp/mb_tcp_slave/sdkconfig.ci.ethernet index 0bf43cd..01424b1 100644 --- a/examples/tcp/mb_tcp_slave/sdkconfig.ci.ethernet +++ b/examples/tcp/mb_tcp_slave/sdkconfig.ci.ethernet @@ -33,3 +33,4 @@ CONFIG_ETH_USE_SPI_ETHERNET=n CONFIG_HEAP_POISONING_COMPREHENSIVE=y CONFIG_HEAP_TRACING_OFF=y + diff --git a/examples/tcp/mb_tcp_slave/sdkconfig.ci.wifi b/examples/tcp/mb_tcp_slave/sdkconfig.ci.wifi index a01694b..1f05e52 100644 --- a/examples/tcp/mb_tcp_slave/sdkconfig.ci.wifi +++ b/examples/tcp/mb_tcp_slave/sdkconfig.ci.wifi @@ -20,3 +20,4 @@ CONFIG_EXAMPLE_WIFI_PASSWORD="${CI_WIFI_PASSW}" CONFIG_HEAP_POISONING_COMPREHENSIVE=y CONFIG_HEAP_TRACING_OFF=y + diff --git a/modbus/mb_controller/common/esp_modbus_common.c b/modbus/mb_controller/common/esp_modbus_common.c index 10a1d1e..6d5aa0d 100644 --- a/modbus/mb_controller/common/esp_modbus_common.c +++ b/modbus/mb_controller/common/esp_modbus_common.c @@ -13,19 +13,19 @@ static const char TAG[] __attribute__((unused)) = "MB_CONTROLLER_COMMON"; /** * Register or override command handler for the command in object command handler table */ -esp_err_t mbc_set_handler(void *ctx, uint8_t func_code, mb_fn_handler_fp phandler) +esp_err_t mbc_set_handler(void *ctx, uint8_t func_code, mb_fn_handler_fp handler) { - MB_RETURN_ON_FALSE((ctx && phandler && func_code), ESP_ERR_INVALID_STATE, TAG, + MB_RETURN_ON_FALSE((ctx && handler && func_code), ESP_ERR_INVALID_STATE, TAG, "Incorrect arguments for the function."); mb_err_enum_t ret = MB_EINVAL; mb_controller_common_t *mb_controller = (mb_controller_common_t *)(ctx); - mb_base_t *pmb_obj = (mb_base_t *)mb_controller->mb_base; - MB_RETURN_ON_FALSE(pmb_obj, ESP_ERR_INVALID_STATE, TAG, + mb_base_t *mb_obj = (mb_base_t *)mb_controller->mb_base; + MB_RETURN_ON_FALSE(mb_obj, ESP_ERR_INVALID_STATE, TAG, "Controller interface is not correctly initialized."); - if (pmb_obj->descr.is_master) { - ret = mbm_set_handler(mb_controller->mb_base, func_code, phandler); + if (mb_obj->descr.is_master) { + ret = mbm_set_handler(mb_controller->mb_base, func_code, handler); } else { - ret = mbs_set_handler(mb_controller->mb_base, func_code, phandler); + ret = mbs_set_handler(mb_controller->mb_base, func_code, handler); } return MB_ERR_TO_ESP_ERR(ret); } @@ -33,19 +33,19 @@ esp_err_t mbc_set_handler(void *ctx, uint8_t func_code, mb_fn_handler_fp phandle /** * Get command handler from the command handler table of the object */ -esp_err_t mbc_get_handler(void *ctx, uint8_t func_code, mb_fn_handler_fp *phandler) +esp_err_t mbc_get_handler(void *ctx, uint8_t func_code, mb_fn_handler_fp *handler) { - MB_RETURN_ON_FALSE((ctx && func_code && phandler), ESP_ERR_INVALID_STATE, TAG, + MB_RETURN_ON_FALSE((ctx && func_code && handler), ESP_ERR_INVALID_STATE, TAG, "Incorrect arguments for the function."); mb_err_enum_t ret = MB_EINVAL; mb_controller_common_t *mb_controller = (mb_controller_common_t *)(ctx); - mb_base_t *pmb_obj = (mb_base_t *)mb_controller->mb_base; - MB_RETURN_ON_FALSE(pmb_obj, ESP_ERR_INVALID_STATE, TAG, + mb_base_t *mb_obj = (mb_base_t *)mb_controller->mb_base; + MB_RETURN_ON_FALSE(mb_obj, ESP_ERR_INVALID_STATE, TAG, "Controller interface is not correctly initialized."); - if (pmb_obj->descr.is_master) { - ret = mbm_get_handler(mb_controller->mb_base, func_code, phandler); + if (mb_obj->descr.is_master) { + ret = mbm_get_handler(mb_controller->mb_base, func_code, handler); } else { - ret = mbs_get_handler(mb_controller->mb_base, func_code, phandler); + ret = mbs_get_handler(mb_controller->mb_base, func_code, handler); } return MB_ERR_TO_ESP_ERR(ret); } @@ -59,10 +59,10 @@ esp_err_t mbc_delete_handler(void *ctx, uint8_t func_code) "Incorrect arguments for the function."); mb_err_enum_t ret = MB_EINVAL; mb_controller_common_t *mb_controller = (mb_controller_common_t *)(ctx); - mb_base_t *pmb_obj = (mb_base_t *)mb_controller->mb_base; - MB_RETURN_ON_FALSE(pmb_obj, ESP_ERR_INVALID_STATE, TAG, + mb_base_t *mb_obj = (mb_base_t *)mb_controller->mb_base; + MB_RETURN_ON_FALSE(mb_obj, ESP_ERR_INVALID_STATE, TAG, "Controller interface is not correctly initialized."); - if (pmb_obj->descr.is_master) { + if (mb_obj->descr.is_master) { ret = mbm_delete_handler(mb_controller->mb_base, func_code); } else { ret = mbs_delete_handler(mb_controller->mb_base, func_code); @@ -73,19 +73,19 @@ esp_err_t mbc_delete_handler(void *ctx, uint8_t func_code) /** * Get number of registered command handlers for the object */ -esp_err_t mbc_get_handler_count(void *ctx, uint16_t *pcount) +esp_err_t mbc_get_handler_count(void *ctx, uint16_t *count) { - MB_RETURN_ON_FALSE((ctx && pcount), ESP_ERR_INVALID_STATE, TAG, + MB_RETURN_ON_FALSE((ctx && count), ESP_ERR_INVALID_STATE, TAG, "Controller interface is not correctly initialized."); mb_err_enum_t ret = MB_EINVAL; mb_controller_common_t *mb_controller = (mb_controller_common_t *)(ctx); - mb_base_t *pmb_obj = (mb_base_t *)mb_controller->mb_base; - MB_RETURN_ON_FALSE(pmb_obj, ESP_ERR_INVALID_STATE, TAG, + mb_base_t *mb_obj = (mb_base_t *)mb_controller->mb_base; + MB_RETURN_ON_FALSE(mb_obj, ESP_ERR_INVALID_STATE, TAG, "Controller interface is not correctly initialized."); - if (pmb_obj->descr.is_master) { - ret = mbm_get_handler_count(mb_controller->mb_base, pcount); + if (mb_obj->descr.is_master) { + ret = mbm_get_handler_count(mb_controller->mb_base, count); } else { - ret = mbs_get_handler_count(mb_controller->mb_base, pcount); + ret = mbs_get_handler_count(mb_controller->mb_base, count); } return MB_ERR_TO_ESP_ERR(ret); } \ No newline at end of file diff --git a/modbus/mb_controller/common/esp_modbus_master.c b/modbus/mb_controller/common/esp_modbus_master.c index 3c0a28d..a038571 100644 --- a/modbus/mb_controller/common/esp_modbus_master.c +++ b/modbus/mb_controller/common/esp_modbus_master.c @@ -40,10 +40,10 @@ esp_err_t mbc_master_lock(void *ctx) MB_RETURN_ON_FALSE(ctx, ESP_ERR_INVALID_STATE, TAG, "Master interface is not correctly initialized."); mbm_controller_iface_t *mbm_controller = MB_MASTER_GET_IFACE(ctx); - mb_base_t *pmb_obj = (mb_base_t *)mbm_controller->mb_base; - MB_RETURN_ON_FALSE((pmb_obj && pmb_obj->lock), ESP_ERR_INVALID_STATE, TAG, + mb_base_t *mb_obj = mbm_controller->mb_base; + MB_RETURN_ON_FALSE((mb_obj && mb_obj->lock), ESP_ERR_INVALID_STATE, TAG, "Master interface is not correctly initialized."); - CRITICAL_SECTION_LOCK(pmb_obj->lock); + CRITICAL_SECTION_LOCK(mb_obj->lock); return ESP_OK; } @@ -55,10 +55,10 @@ esp_err_t mbc_master_unlock(void *ctx) MB_RETURN_ON_FALSE(ctx, ESP_ERR_INVALID_STATE, TAG, "Master interface is not correctly initialized."); mbm_controller_iface_t *mbm_controller = MB_MASTER_GET_IFACE(ctx); - mb_base_t *pmb_obj = (mb_base_t *)mbm_controller->mb_base; - MB_RETURN_ON_FALSE((pmb_obj && pmb_obj->lock), ESP_ERR_INVALID_STATE, TAG, + mb_base_t *mb_obj = mbm_controller->mb_base; + MB_RETURN_ON_FALSE((mb_obj && mb_obj->lock), ESP_ERR_INVALID_STATE, TAG, "Master interface is not correctly initialized."); - CRITICAL_SECTION_UNLOCK(pmb_obj->lock); + CRITICAL_SECTION_UNLOCK(mb_obj->lock); return ESP_OK; } @@ -231,17 +231,17 @@ esp_err_t mbc_master_stop(void *ctx) /* ----------------------- Callback functions for Modbus stack ---------------------------------*/ // These are executed by modbus stack to read appropriate type of registers. -mb_err_enum_t mbc_reg_common_cb(mb_base_t *inst, uint8_t *pdata, uint16_t address, uint16_t bytes) +mb_err_enum_t mbc_reg_common_cb(mb_base_t *inst, uint8_t *data_ptr, uint16_t address, uint16_t bytes) { - MB_RETURN_ON_FALSE((pdata), MB_EINVAL, TAG, "incorrect parameters provided."); + MB_RETURN_ON_FALSE((data_ptr), MB_EINVAL, TAG, "incorrect parameters provided."); - mb_master_options_t *popts = MB_MASTER_GET_OPTS(MB_MASTER_GET_IFACE_FROM_BASE(inst)); - uint16_t reg_len = popts->reg_buffer_size; - uint8_t *ppar_buffer = (uint8_t *)popts->reg_buffer_ptr; // Get instance address + mb_master_options_t *opts = MB_MASTER_GET_OPTS(MB_MASTER_GET_IFACE_FROM_BASE(inst)); + uint16_t reg_len = opts->reg_buffer_size; + uint8_t *par_buffer = opts->reg_buffer_ptr; // Get instance address mb_err_enum_t status = MB_ENOERR; - if (ppar_buffer && !address && (bytes >= 2) && (((reg_len << 1) >= bytes))){ + if (par_buffer&& !address && (bytes >= 2) && (((reg_len << 1) >= bytes))){ CRITICAL_SECTION(inst->lock) { - memmove(ppar_buffer, pdata, bytes); + memmove(par_buffer, data_ptr, bytes); } } else { status = MB_ENORES; @@ -267,8 +267,8 @@ mb_err_enum_t mbc_reg_input_master_cb(mb_base_t *inst, uint8_t *reg_buffer, uint "Master stack processing error."); mb_master_options_t *mbm_opts = MB_MASTER_GET_OPTS(MB_MASTER_GET_IFACE_FROM_BASE(inst)); // Number of input registers to be transferred - uint16_t num_input_regs = (uint16_t)mbm_opts->reg_buffer_size; - uint8_t *input_reg_buf = (uint8_t *)mbm_opts->reg_buffer_ptr; // Get instance address + uint16_t num_input_regs = mbm_opts->reg_buffer_size; + uint8_t *input_reg_buf = mbm_opts->reg_buffer_ptr; // Get instance address uint16_t regs_cnt = num_regs; mb_err_enum_t status = MB_ENOERR; // If input or configuration parameters are incorrect then return an error to stack layer @@ -309,8 +309,8 @@ mb_err_enum_t mbc_reg_holding_master_cb(mb_base_t *inst, uint8_t *reg_buffer, ui { MB_RETURN_ON_FALSE((reg_buffer), MB_EINVAL, TAG, "Master stack processing error."); mb_master_options_t *mbm_opts = MB_MASTER_GET_OPTS(MB_MASTER_GET_IFACE_FROM_BASE(inst)); - uint16_t num_hold_regs = (uint16_t)mbm_opts->reg_buffer_size; - uint8_t *holding_buf = (uint8_t *)mbm_opts->reg_buffer_ptr; + uint16_t num_hold_regs = mbm_opts->reg_buffer_size; + uint8_t *holding_buf = mbm_opts->reg_buffer_ptr; mb_err_enum_t status = MB_ENOERR; uint16_t regs_cnt = num_regs; // Check input and configuration parameters for correctness @@ -349,7 +349,7 @@ mb_err_enum_t mbc_reg_holding_master_cb(mb_base_t *inst, uint8_t *reg_buffer, ui } /** - * Modbus master coils callback function. + * @brief Modbus master coils read callback function. * * @param inst interface context pointer * @param reg_buffer coils buffer @@ -359,15 +359,13 @@ mb_err_enum_t mbc_reg_holding_master_cb(mb_base_t *inst, uint8_t *reg_buffer, ui * * @return result */ -// Callback function for reading of MB Coils Registers -// mbm_reg_coils_cb_serial mb_err_enum_t mbc_reg_coils_master_cb(mb_base_t *inst, uint8_t *reg_buffer, uint16_t reg_addr, uint16_t ncoils, mb_reg_mode_enum_t mode) { MB_RETURN_ON_FALSE((reg_buffer), MB_EINVAL, TAG, "Master stack processing error."); mb_master_options_t *mbm_opts = MB_MASTER_GET_OPTS(MB_MASTER_GET_IFACE_FROM_BASE(inst)); - uint16_t num_coil_regs = (uint16_t)mbm_opts->reg_buffer_size; - uint8_t *coils_buf = (uint8_t *)mbm_opts->reg_buffer_ptr; + uint16_t num_coil_regs = mbm_opts->reg_buffer_size; + uint8_t *coils_buf = mbm_opts->reg_buffer_ptr; mb_err_enum_t status = MB_ENOERR; uint16_t reg_index; uint16_t coils_cnt = ncoils; @@ -382,7 +380,7 @@ mb_err_enum_t mbc_reg_coils_master_cb(mb_base_t *inst, uint8_t *reg_buffer, uint { while (coils_cnt > 0) { - uint8_t result = mb_util_get_bits((uint8_t *)coils_buf, reg_index - (reg_addr % 8), 1); + uint8_t result = mb_util_get_bits(coils_buf, reg_index - (reg_addr % 8), 1); mb_util_set_bits(reg_buffer, reg_index - (reg_addr % 8), 1, result); reg_index++; coils_cnt--; @@ -395,7 +393,7 @@ mb_err_enum_t mbc_reg_coils_master_cb(mb_base_t *inst, uint8_t *reg_buffer, uint while (coils_cnt > 0) { uint8_t result = mb_util_get_bits(reg_buffer, reg_index - (reg_addr % 8), 1); - mb_util_set_bits((uint8_t *)coils_buf, reg_index - (reg_addr % 8), 1, result); + mb_util_set_bits(coils_buf, reg_index - (reg_addr % 8), 1, result); reg_index++; coils_cnt--; } @@ -428,18 +426,18 @@ mb_err_enum_t mbc_reg_discrete_master_cb(mb_base_t *inst, uint8_t *reg_buffer, u { MB_RETURN_ON_FALSE((reg_buffer), MB_EINVAL, TAG, "Master stack processing error."); mb_master_options_t *mbm_opts = MB_MASTER_GET_OPTS(MB_MASTER_GET_IFACE_FROM_BASE(inst)); - uint16_t num_discr_regs = (uint16_t)mbm_opts->reg_buffer_size; - uint8_t *discr_buf = (uint8_t *)mbm_opts->reg_buffer_ptr; + uint16_t num_discr_regs = mbm_opts->reg_buffer_size; + uint8_t *discr_buf = mbm_opts->reg_buffer_ptr; mb_err_enum_t status = MB_ENOERR; uint16_t bit_index, num_reg; uint8_t *temp_discr_buf; num_reg = n_discrete; - temp_discr_buf = (uint8_t *)discr_buf; + temp_discr_buf = discr_buf; // It is already plus one in Modbus function method. reg_addr--; if ((num_discr_regs >= 1) && (discr_buf) && (n_discrete >= 1) && (n_discrete == num_discr_regs)) { - bit_index = (uint16_t)(reg_addr) % 8; // Get bit index + bit_index = (reg_addr) % 8; // Get bit index CRITICAL_SECTION(inst->lock) { while (num_reg > 0) @@ -464,265 +462,265 @@ esp_err_t mbc_master_set_param_data(void* dest, void* src, mb_descr_type_t param esp_err_t err = ESP_OK; MB_RETURN_ON_FALSE((src), ESP_ERR_INVALID_STATE, TAG,"incorrect data pointer."); MB_RETURN_ON_FALSE((dest), ESP_ERR_INVALID_STATE, TAG,"incorrect data pointer."); - void *pdest = dest; - void *psrc = src; + void *dest_ptr = dest; + void *src_ptr = src; // Transfer parameter data into value of characteristic switch(param_type) { case PARAM_TYPE_U8: - for MB_EACH_ELEM(psrc, pdest, param_size, PARAM_SIZE_U8) { - *((uint8_t *)pdest) = *((uint8_t*)psrc); + for MB_EACH_ELEM(src_ptr, dest_ptr, param_size, PARAM_SIZE_U8) { + *((uint8_t *)dest_ptr) = *((uint8_t*)src_ptr); } break; case PARAM_TYPE_U16: - for MB_EACH_ELEM(psrc, pdest, param_size, PARAM_SIZE_U16) { - *((uint16_t *)pdest) = *((uint16_t*)psrc); + for MB_EACH_ELEM(src_ptr, dest_ptr, param_size, PARAM_SIZE_U16) { + *((uint16_t *)dest_ptr) = *((uint16_t*)src_ptr); } break; case PARAM_TYPE_U32: - for MB_EACH_ELEM(psrc, pdest, param_size, PARAM_SIZE_U32) { - *((uint32_t *)pdest) = *((uint32_t*)psrc); + for MB_EACH_ELEM(src_ptr, dest_ptr, param_size, PARAM_SIZE_U32) { + *((uint32_t *)dest_ptr) = *((uint32_t*)src_ptr); } break; case PARAM_TYPE_FLOAT: - for MB_EACH_ELEM(psrc, pdest, param_size, PARAM_SIZE_FLOAT) { - *((float *)pdest) = *(float*)psrc; + for MB_EACH_ELEM(src_ptr, dest_ptr, param_size, PARAM_SIZE_FLOAT) { + *((float *)dest_ptr) = *(float*)src_ptr; } break; case PARAM_TYPE_ASCII: case PARAM_TYPE_BIN: - memcpy((void *)dest, (void*)src, (size_t)param_size); + memcpy(dest, src, param_size); break; #if CONFIG_FMB_EXT_TYPE_SUPPORT case PARAM_TYPE_I8_A: - for MB_EACH_ELEM(psrc, pdest, param_size, PARAM_SIZE_U8_REG) { - mb_set_int8_a((val_16_arr *)pdest, (*(int8_t*)psrc)); - ESP_LOGV(TAG, "Convert uint8 B[%d] 0x%04" PRIx16 " = 0x%04" PRIx16, i, *(uint16_t *)psrc, *(uint16_t *)pdest); + for MB_EACH_ELEM(src_ptr, dest_ptr, param_size, PARAM_SIZE_U8_REG) { + mb_set_int8_a((val_16_arr *)dest_ptr, (*(int8_t*)src_ptr)); + ESP_LOGV(TAG, "Convert uint8 B[%d] 0x%04" PRIx16 " = 0x%04" PRIx16, i, *(uint16_t *)src_ptr, *(uint16_t *)dest_ptr); } break; case PARAM_TYPE_I8_B: - for MB_EACH_ELEM(psrc, pdest, param_size, PARAM_SIZE_U8_REG) { - mb_set_int8_b((val_16_arr *)pdest, (int8_t)((*(uint16_t*)psrc) >> 8)); - ESP_LOGV(TAG, "Convert int8 A[%d] 0x%02" PRIx16 " = 0x%02" PRIx16, i, *(uint16_t *)psrc, *(uint16_t *)pdest); + for MB_EACH_ELEM(src_ptr, dest_ptr, param_size, PARAM_SIZE_U8_REG) { + mb_set_int8_b((val_16_arr *)dest_ptr, (int8_t)((*(uint16_t*)src_ptr) >> 8)); + ESP_LOGV(TAG, "Convert int8 A[%d] 0x%02" PRIx16 " = 0x%02" PRIx16, i, *(uint16_t *)src_ptr, *(uint16_t *)dest_ptr); } break; case PARAM_TYPE_U8_A: - for MB_EACH_ELEM(psrc, pdest, param_size, PARAM_SIZE_U8_REG) { - mb_set_uint8_a((val_16_arr *)pdest, (*(uint8_t*)psrc)); - ESP_LOGV(TAG, "Convert uint8 A[%d] 0x%02" PRIx16 " = %02" PRIx16, i, *(uint16_t *)psrc, *(uint16_t *)pdest); + for MB_EACH_ELEM(src_ptr, dest_ptr, param_size, PARAM_SIZE_U8_REG) { + mb_set_uint8_a((val_16_arr *)dest_ptr, (*(uint8_t*)src_ptr)); + ESP_LOGV(TAG, "Convert uint8 A[%d] 0x%02" PRIx16 " = %02" PRIx16, i, *(uint16_t *)src_ptr, *(uint16_t *)dest_ptr); } break; case PARAM_TYPE_U8_B: - for MB_EACH_ELEM(psrc, pdest, param_size, PARAM_SIZE_U8_REG) { - uint8_t data = (uint8_t)((*(uint16_t*)psrc) >> 8); - mb_set_uint8_b((val_16_arr *)pdest, data); - ESP_LOGV(TAG, "Convert uint8 B[%d] 0x%02" PRIx16 " = 0x%02" PRIx16, i, *(uint16_t *)psrc, *(uint16_t *)pdest); + for MB_EACH_ELEM(src_ptr, dest_ptr, param_size, PARAM_SIZE_U8_REG) { + uint8_t data = (uint8_t)((*(uint16_t*)src_ptr) >> 8); + mb_set_uint8_b((val_16_arr *)dest_ptr, data); + ESP_LOGV(TAG, "Convert uint8 B[%d] 0x%02" PRIx16 " = 0x%02" PRIx16, i, *(uint16_t *)src_ptr, *(uint16_t *)dest_ptr); } break; case PARAM_TYPE_I16_AB: - for MB_EACH_ELEM(psrc, pdest, param_size, PARAM_SIZE_I16) { - mb_set_int16_ab((val_16_arr *)pdest, *(int16_t*)psrc); - ESP_LOGV(TAG, "Convert int16 AB[%d] 0x%04" PRIx16 " = 0x%04" PRIx16, i, *(uint16_t *)psrc, *(uint16_t *)pdest); + for MB_EACH_ELEM(src_ptr, dest_ptr, param_size, PARAM_SIZE_I16) { + mb_set_int16_ab((val_16_arr *)dest_ptr, *(int16_t*)src_ptr); + ESP_LOGV(TAG, "Convert int16 AB[%d] 0x%04" PRIx16 " = 0x%04" PRIx16, i, *(uint16_t *)src_ptr, *(uint16_t *)dest_ptr); } break; case PARAM_TYPE_I16_BA: - for MB_EACH_ELEM(psrc, pdest, param_size, PARAM_SIZE_I16) { - mb_set_int16_ba((val_16_arr *)pdest, *(int16_t*)psrc); - ESP_LOGV(TAG, "Convert int16 BA[%d] 0x%04" PRIx16 " = 0x%04" PRIx16, i, *(uint16_t *)psrc, *(uint16_t *)pdest); + for MB_EACH_ELEM(src_ptr, dest_ptr, param_size, PARAM_SIZE_I16) { + mb_set_int16_ba((val_16_arr *)dest_ptr, *(int16_t*)src_ptr); + ESP_LOGV(TAG, "Convert int16 BA[%d] 0x%04" PRIx16 " = 0x%04" PRIx16, i, *(uint16_t *)src_ptr, *(uint16_t *)dest_ptr); } break; case PARAM_TYPE_U16_AB: - for MB_EACH_ELEM(psrc, pdest, param_size, PARAM_SIZE_U16) { - mb_set_uint16_ab((val_16_arr *)pdest, *(uint16_t*)psrc); - ESP_LOGV(TAG, "Convert uint16 AB[%d] 0x%02" PRIx16 " = 0x%02" PRIx16, i, *(uint16_t *)psrc, *(uint16_t *)pdest); + for MB_EACH_ELEM(src_ptr, dest_ptr, param_size, PARAM_SIZE_U16) { + mb_set_uint16_ab((val_16_arr *)dest_ptr, *(uint16_t*)src_ptr); + ESP_LOGV(TAG, "Convert uint16 AB[%d] 0x%02" PRIx16 " = 0x%02" PRIx16, i, *(uint16_t *)src_ptr, *(uint16_t *)dest_ptr); } break; case PARAM_TYPE_U16_BA: - for MB_EACH_ELEM(psrc, pdest, param_size, PARAM_SIZE_U16) { - mb_set_uint16_ba((val_16_arr *)pdest, *(uint16_t*)psrc); - ESP_LOGV(TAG, "Convert uint16 BA[%d] 0x%02" PRIx16 " = 0x%02" PRIx16, i, *(uint16_t *)psrc, *(uint16_t *)pdest); + for MB_EACH_ELEM(src_ptr, dest_ptr, param_size, PARAM_SIZE_U16) { + mb_set_uint16_ba((val_16_arr *)dest_ptr, *(uint16_t*)src_ptr); + ESP_LOGV(TAG, "Convert uint16 BA[%d] 0x%02" PRIx16 " = 0x%02" PRIx16, i, *(uint16_t *)src_ptr, *(uint16_t *)dest_ptr); } break; case PARAM_TYPE_I32_ABCD: - for MB_EACH_ELEM(psrc, pdest, param_size, PARAM_SIZE_I32) { - mb_set_int32_abcd((val_32_arr *)pdest, *(int32_t *)psrc); - ESP_LOGV(TAG, "Convert int32 ABCD[%d] 0x%04" PRIx32 " = 0x%04" PRIx32, i, *(uint32_t *)psrc, *(uint32_t *)pdest); + for MB_EACH_ELEM(src_ptr, dest_ptr, param_size, PARAM_SIZE_I32) { + mb_set_int32_abcd((val_32_arr *)dest_ptr, *(int32_t *)src_ptr); + ESP_LOGV(TAG, "Convert int32 ABCD[%d] 0x%04" PRIx32 " = 0x%04" PRIx32, i, *(uint32_t *)src_ptr, *(uint32_t *)dest_ptr); } break; case PARAM_TYPE_U32_ABCD: - for MB_EACH_ELEM(psrc, pdest, param_size, PARAM_SIZE_U32) { - mb_set_uint32_abcd((val_32_arr *)pdest, *(uint32_t *)psrc); - ESP_LOGV(TAG, "Convert uint32 ABCD[%d] 0x%04" PRIx32 " = 0x%04" PRIx32, i, *(uint32_t *)psrc, *(uint32_t *)pdest); + for MB_EACH_ELEM(src_ptr, dest_ptr, param_size, PARAM_SIZE_U32) { + mb_set_uint32_abcd((val_32_arr *)dest_ptr, *(uint32_t *)src_ptr); + ESP_LOGV(TAG, "Convert uint32 ABCD[%d] 0x%04" PRIx32 " = 0x%04" PRIx32, i, *(uint32_t *)src_ptr, *(uint32_t *)dest_ptr); } break; case PARAM_TYPE_FLOAT_ABCD: - for MB_EACH_ELEM(psrc, pdest, param_size, PARAM_SIZE_FLOAT) { - mb_set_float_abcd((val_32_arr *)pdest, *(float *)psrc); - ESP_LOGV(TAG, "Convert float ABCD[%d] 0x%04" PRIx32 " = 0x%04" PRIx32, i, *(uint32_t *)psrc, *(uint32_t *)pdest); + for MB_EACH_ELEM(src_ptr, dest_ptr, param_size, PARAM_SIZE_FLOAT) { + mb_set_float_abcd((val_32_arr *)dest_ptr, *(float *)src_ptr); + ESP_LOGV(TAG, "Convert float ABCD[%d] 0x%04" PRIx32 " = 0x%04" PRIx32, i, *(uint32_t *)src_ptr, *(uint32_t *)dest_ptr); } break; case PARAM_TYPE_I32_CDAB: - for MB_EACH_ELEM(psrc, pdest, param_size, PARAM_SIZE_I32) { - mb_set_int32_cdab((val_32_arr *)pdest, *(int32_t *)psrc); - ESP_LOGV(TAG, "Convert int32 CDAB[%d] 0x%04" PRIx32 " = 0x%04" PRIx32, i, *(uint32_t *)psrc, *(uint32_t *)pdest); + for MB_EACH_ELEM(src_ptr, dest_ptr, param_size, PARAM_SIZE_I32) { + mb_set_int32_cdab((val_32_arr *)dest_ptr, *(int32_t *)src_ptr); + ESP_LOGV(TAG, "Convert int32 CDAB[%d] 0x%04" PRIx32 " = 0x%04" PRIx32, i, *(uint32_t *)src_ptr, *(uint32_t *)dest_ptr); } break; case PARAM_TYPE_U32_CDAB: - for MB_EACH_ELEM(psrc, pdest, param_size, PARAM_SIZE_U32) { - mb_set_uint32_cdab((val_32_arr *)pdest, *(uint32_t *)psrc); - ESP_LOGV(TAG, "Convert uint32 CDAB[%d] 0x%04" PRIx32 " = 0x%04" PRIx32, i, *(uint32_t *)psrc, *(uint32_t *)pdest); + for MB_EACH_ELEM(src_ptr, dest_ptr, param_size, PARAM_SIZE_U32) { + mb_set_uint32_cdab((val_32_arr *)dest_ptr, *(uint32_t *)src_ptr); + ESP_LOGV(TAG, "Convert uint32 CDAB[%d] 0x%04" PRIx32 " = 0x%04" PRIx32, i, *(uint32_t *)src_ptr, *(uint32_t *)dest_ptr); } break; case PARAM_TYPE_FLOAT_CDAB: - for MB_EACH_ELEM(psrc, pdest, param_size, PARAM_SIZE_FLOAT) { - mb_set_float_cdab((val_32_arr *)pdest, *(float *)psrc); - ESP_LOGV(TAG, "Convert float CDAB[%d] 0x%04" PRIx32 " = 0x%04" PRIx32, i, *(uint32_t *)psrc, *(uint32_t *)pdest); + for MB_EACH_ELEM(src_ptr, dest_ptr, param_size, PARAM_SIZE_FLOAT) { + mb_set_float_cdab((val_32_arr *)dest_ptr, *(float *)src_ptr); + ESP_LOGV(TAG, "Convert float CDAB[%d] 0x%04" PRIx32 " = 0x%04" PRIx32, i, *(uint32_t *)src_ptr, *(uint32_t *)dest_ptr); } break; case PARAM_TYPE_I32_BADC: - for MB_EACH_ELEM(psrc, pdest, param_size, PARAM_SIZE_I32) { - mb_set_int32_badc((val_32_arr *)pdest, *(int32_t *)psrc); - ESP_LOGV(TAG, "Convert int32 BADC[%d] 0x%04" PRIx32 " = 0x%04" PRIx32, i, *(uint32_t *)psrc, *(uint32_t *)pdest); + for MB_EACH_ELEM(src_ptr, dest_ptr, param_size, PARAM_SIZE_I32) { + mb_set_int32_badc((val_32_arr *)dest_ptr, *(int32_t *)src_ptr); + ESP_LOGV(TAG, "Convert int32 BADC[%d] 0x%04" PRIx32 " = 0x%04" PRIx32, i, *(uint32_t *)src_ptr, *(uint32_t *)dest_ptr); } break; case PARAM_TYPE_U32_BADC: - for MB_EACH_ELEM(psrc, pdest, param_size, PARAM_SIZE_U32) { - mb_set_uint32_badc((val_32_arr *)pdest, *(uint32_t *)psrc); - ESP_LOGV(TAG, "Convert uint32 BADC[%d] 0x%04" PRIx32 " = 0x%04" PRIx32, i, *(uint32_t *)psrc, *(uint32_t *)pdest); + for MB_EACH_ELEM(src_ptr, dest_ptr, param_size, PARAM_SIZE_U32) { + mb_set_uint32_badc((val_32_arr *)dest_ptr, *(uint32_t *)src_ptr); + ESP_LOGV(TAG, "Convert uint32 BADC[%d] 0x%04" PRIx32 " = 0x%04" PRIx32, i, *(uint32_t *)src_ptr, *(uint32_t *)dest_ptr); } break; case PARAM_TYPE_FLOAT_BADC: - for MB_EACH_ELEM(psrc, pdest, param_size, PARAM_SIZE_FLOAT) { - mb_set_float_badc((val_32_arr *)pdest, *(float *)psrc); - ESP_LOGV(TAG, "Convert float BADC[%d] 0x%04" PRIx32 " = 0x%04" PRIx32, i, *(uint32_t *)psrc, *(uint32_t *)pdest); + for MB_EACH_ELEM(src_ptr, dest_ptr, param_size, PARAM_SIZE_FLOAT) { + mb_set_float_badc((val_32_arr *)dest_ptr, *(float *)src_ptr); + ESP_LOGV(TAG, "Convert float BADC[%d] 0x%04" PRIx32 " = 0x%04" PRIx32, i, *(uint32_t *)src_ptr, *(uint32_t *)dest_ptr); } break; case PARAM_TYPE_I32_DCBA: - for MB_EACH_ELEM(psrc, pdest, param_size, PARAM_SIZE_I32) { - mb_set_int32_dcba((val_32_arr *)pdest, *(int32_t *)psrc); - ESP_LOGV(TAG, "Convert int32 DCBA[%d] 0x%04" PRIx32 " = 0x%04" PRIx32, i, *(uint32_t *)psrc, *(uint32_t *)pdest); + for MB_EACH_ELEM(src_ptr, dest_ptr, param_size, PARAM_SIZE_I32) { + mb_set_int32_dcba((val_32_arr *)dest_ptr, *(int32_t *)src_ptr); + ESP_LOGV(TAG, "Convert int32 DCBA[%d] 0x%04" PRIx32 " = 0x%04" PRIx32, i, *(uint32_t *)src_ptr, *(uint32_t *)dest_ptr); } break; case PARAM_TYPE_U32_DCBA: - for MB_EACH_ELEM(psrc, pdest, param_size, PARAM_SIZE_U32) { - mb_set_uint32_dcba((val_32_arr *)pdest, *(uint32_t *)psrc); - ESP_LOGV(TAG, "Convert uint32 DCBA[%d] 0x%04" PRIx32 " = 0x%04" PRIx32, i, *(uint32_t *)psrc, *(uint32_t *)pdest); + for MB_EACH_ELEM(src_ptr, dest_ptr, param_size, PARAM_SIZE_U32) { + mb_set_uint32_dcba((val_32_arr *)dest_ptr, *(uint32_t *)src_ptr); + ESP_LOGV(TAG, "Convert uint32 DCBA[%d] 0x%04" PRIx32 " = 0x%04" PRIx32, i, *(uint32_t *)src_ptr, *(uint32_t *)dest_ptr); } break; case PARAM_TYPE_FLOAT_DCBA: - for MB_EACH_ELEM(psrc, pdest, param_size, PARAM_SIZE_FLOAT) { - mb_set_float_dcba((val_32_arr *)pdest, *(float *)psrc); - ESP_LOGV(TAG, "Convert float DCBA[%d] 0x%04" PRIx32 " = 0x%04" PRIx32, i, *(uint32_t *)psrc, *(uint32_t *)pdest); + for MB_EACH_ELEM(src_ptr, dest_ptr, param_size, PARAM_SIZE_FLOAT) { + mb_set_float_dcba((val_32_arr *)dest_ptr, *(float *)src_ptr); + ESP_LOGV(TAG, "Convert float DCBA[%d] 0x%04" PRIx32 " = 0x%04" PRIx32, i, *(uint32_t *)src_ptr, *(uint32_t *)dest_ptr); } break; case PARAM_TYPE_I64_ABCDEFGH: - for MB_EACH_ELEM(psrc, pdest, param_size, PARAM_SIZE_I64) { - mb_set_int64_abcdefgh((val_64_arr *)pdest, *(int64_t *)psrc); - ESP_LOGV(TAG, "Convert int64 ABCDEFGH[%d] 0x%" PRIx64 " = 0x%" PRIx64, i, *(uint64_t *)psrc, *(uint64_t *)pdest); + for MB_EACH_ELEM(src_ptr, dest_ptr, param_size, PARAM_SIZE_I64) { + mb_set_int64_abcdefgh((val_64_arr *)dest_ptr, *(int64_t *)src_ptr); + ESP_LOGV(TAG, "Convert int64 ABCDEFGH[%d] 0x%" PRIx64 " = 0x%" PRIx64, i, *(uint64_t *)src_ptr, *(uint64_t *)dest_ptr); } break; case PARAM_TYPE_U64_ABCDEFGH: - for MB_EACH_ELEM(psrc, pdest, param_size, PARAM_SIZE_U64) { - mb_set_uint64_abcdefgh((val_64_arr *)pdest, *(uint64_t *)psrc); - ESP_LOGV(TAG, "Convert double ABCDEFGH[%d] 0x%" PRIx64 " = 0x%" PRIx64, i, *(uint64_t *)psrc, *(uint64_t *)pdest); + for MB_EACH_ELEM(src_ptr, dest_ptr, param_size, PARAM_SIZE_U64) { + mb_set_uint64_abcdefgh((val_64_arr *)dest_ptr, *(uint64_t *)src_ptr); + ESP_LOGV(TAG, "Convert double ABCDEFGH[%d] 0x%" PRIx64 " = 0x%" PRIx64, i, *(uint64_t *)src_ptr, *(uint64_t *)dest_ptr); } break; case PARAM_TYPE_DOUBLE_ABCDEFGH: - for MB_EACH_ELEM(psrc, pdest, param_size, PARAM_SIZE_DOUBLE) { - mb_set_double_abcdefgh((val_64_arr *)pdest, *(double *)psrc); - ESP_LOGV(TAG, "Convert double ABCDEFGH[%d] 0x%" PRIx64 " = 0x%" PRIx64, i, *(uint64_t *)psrc, *(uint64_t *)pdest); + for MB_EACH_ELEM(src_ptr, dest_ptr, param_size, PARAM_SIZE_DOUBLE) { + mb_set_double_abcdefgh((val_64_arr *)dest_ptr, *(double *)src_ptr); + ESP_LOGV(TAG, "Convert double ABCDEFGH[%d] 0x%" PRIx64 " = 0x%" PRIx64, i, *(uint64_t *)src_ptr, *(uint64_t *)dest_ptr); } break; case PARAM_TYPE_I64_HGFEDCBA: - for MB_EACH_ELEM(psrc, pdest, param_size, PARAM_SIZE_I64) { - mb_set_int64_hgfedcba((val_64_arr *)pdest, *(int64_t *)psrc); - ESP_LOGV(TAG, "Convert int64 HGFEDCBA[%d] 0x%" PRIx64 " = 0x%" PRIx64, i, *(uint64_t *)psrc, *(uint64_t *)pdest); + for MB_EACH_ELEM(src_ptr, dest_ptr, param_size, PARAM_SIZE_I64) { + mb_set_int64_hgfedcba((val_64_arr *)dest_ptr, *(int64_t *)src_ptr); + ESP_LOGV(TAG, "Convert int64 HGFEDCBA[%d] 0x%" PRIx64 " = 0x%" PRIx64, i, *(uint64_t *)src_ptr, *(uint64_t *)dest_ptr); } break; case PARAM_TYPE_U64_HGFEDCBA: - for MB_EACH_ELEM(psrc, pdest, param_size, PARAM_SIZE_U64) { - mb_set_uint64_hgfedcba((val_64_arr *)pdest, *(uint64_t *)psrc); - ESP_LOGV(TAG, "Convert double HGFEDCBA[%d] 0x%" PRIx64 " = 0x%" PRIx64, i, *(uint64_t *)psrc, *(uint64_t *)pdest); + for MB_EACH_ELEM(src_ptr, dest_ptr, param_size, PARAM_SIZE_U64) { + mb_set_uint64_hgfedcba((val_64_arr *)dest_ptr, *(uint64_t *)src_ptr); + ESP_LOGV(TAG, "Convert double HGFEDCBA[%d] 0x%" PRIx64 " = 0x%" PRIx64, i, *(uint64_t *)src_ptr, *(uint64_t *)dest_ptr); } break; case PARAM_TYPE_DOUBLE_HGFEDCBA: - for MB_EACH_ELEM(psrc, pdest, param_size, PARAM_SIZE_DOUBLE) { - mb_set_double_hgfedcba((val_64_arr *)pdest, *(double *)psrc); - ESP_LOGV(TAG, "Convert double HGFEDCBA[%d] 0x%" PRIx64 " = 0x%" PRIx64, i, *(uint64_t *)psrc, *(uint64_t *)pdest); + for MB_EACH_ELEM(src_ptr, dest_ptr, param_size, PARAM_SIZE_DOUBLE) { + mb_set_double_hgfedcba((val_64_arr *)dest_ptr, *(double *)src_ptr); + ESP_LOGV(TAG, "Convert double HGFEDCBA[%d] 0x%" PRIx64 " = 0x%" PRIx64, i, *(uint64_t *)src_ptr, *(uint64_t *)dest_ptr); } break; case PARAM_TYPE_I64_GHEFCDAB: - for MB_EACH_ELEM(psrc, pdest, param_size, PARAM_SIZE_I64) { - mb_set_int64_ghefcdab((val_64_arr *)pdest, *(int64_t *)psrc); - ESP_LOGV(TAG, "Convert int64 GHEFCDAB[%d] 0x%" PRIx64 " = 0x%" PRIx64, i, *(uint64_t *)psrc, *(uint64_t *)pdest); + for MB_EACH_ELEM(src_ptr, dest_ptr, param_size, PARAM_SIZE_I64) { + mb_set_int64_ghefcdab((val_64_arr *)dest_ptr, *(int64_t *)src_ptr); + ESP_LOGV(TAG, "Convert int64 GHEFCDAB[%d] 0x%" PRIx64 " = 0x%" PRIx64, i, *(uint64_t *)src_ptr, *(uint64_t *)dest_ptr); } break; case PARAM_TYPE_U64_GHEFCDAB: - for MB_EACH_ELEM(psrc, pdest, param_size, PARAM_SIZE_U64) { - mb_set_uint64_ghefcdab((val_64_arr *)pdest, *(uint64_t *)psrc); - ESP_LOGV(TAG, "Convert uint64 GHEFCDAB[%d] 0x%" PRIx64 " = 0x%" PRIx64, i, *(uint64_t *)psrc, *(uint64_t *)pdest); + for MB_EACH_ELEM(src_ptr, dest_ptr, param_size, PARAM_SIZE_U64) { + mb_set_uint64_ghefcdab((val_64_arr *)dest_ptr, *(uint64_t *)src_ptr); + ESP_LOGV(TAG, "Convert uint64 GHEFCDAB[%d] 0x%" PRIx64 " = 0x%" PRIx64, i, *(uint64_t *)src_ptr, *(uint64_t *)dest_ptr); } break; case PARAM_TYPE_DOUBLE_GHEFCDAB: - for MB_EACH_ELEM(psrc, pdest, param_size, PARAM_SIZE_DOUBLE) { - mb_set_double_ghefcdab((val_64_arr *)pdest, *(double *)psrc); - ESP_LOGV(TAG, "Convert double GHEFCDAB[%d] 0x%" PRIx64 " = 0x%" PRIx64, i, *(uint64_t *)psrc, *(uint64_t *)pdest); + for MB_EACH_ELEM(src_ptr, dest_ptr, param_size, PARAM_SIZE_DOUBLE) { + mb_set_double_ghefcdab((val_64_arr *)dest_ptr, *(double *)src_ptr); + ESP_LOGV(TAG, "Convert double GHEFCDAB[%d] 0x%" PRIx64 " = 0x%" PRIx64, i, *(uint64_t *)src_ptr, *(uint64_t *)dest_ptr); } break; case PARAM_TYPE_I64_BADCFEHG: - for MB_EACH_ELEM(psrc, pdest, param_size, PARAM_SIZE_I64) { - mb_set_int64_badcfehg((val_64_arr *)pdest, *(int64_t *)psrc); - ESP_LOGV(TAG, "Convert int64 BADCFEHG[%d] 0x%" PRIx64 " = 0x%" PRIx64, i, *(uint64_t *)psrc, *(uint64_t *)pdest); + for MB_EACH_ELEM(src_ptr, dest_ptr, param_size, PARAM_SIZE_I64) { + mb_set_int64_badcfehg((val_64_arr *)dest_ptr, *(int64_t *)src_ptr); + ESP_LOGV(TAG, "Convert int64 BADCFEHG[%d] 0x%" PRIx64 " = 0x%" PRIx64, i, *(uint64_t *)src_ptr, *(uint64_t *)dest_ptr); } break; case PARAM_TYPE_U64_BADCFEHG: - for MB_EACH_ELEM(psrc, pdest, param_size, PARAM_SIZE_U64) { - mb_set_uint64_badcfehg((val_64_arr *)pdest, *(uint64_t *)psrc); - ESP_LOGV(TAG, "Convert uint64 BADCFEHG[%d] 0x%" PRIx64 " = 0x%" PRIx64, i, *(uint64_t *)psrc, *(uint64_t *)pdest); + for MB_EACH_ELEM(src_ptr, dest_ptr, param_size, PARAM_SIZE_U64) { + mb_set_uint64_badcfehg((val_64_arr *)dest_ptr, *(uint64_t *)src_ptr); + ESP_LOGV(TAG, "Convert uint64 BADCFEHG[%d] 0x%" PRIx64 " = 0x%" PRIx64, i, *(uint64_t *)src_ptr, *(uint64_t *)dest_ptr); } break; case PARAM_TYPE_DOUBLE_BADCFEHG: - for MB_EACH_ELEM(psrc, pdest, param_size, PARAM_SIZE_DOUBLE) { - mb_set_double_badcfehg((val_64_arr *)pdest, *(double *)psrc); - ESP_LOGV(TAG, "Convert double BADCFEHG[%d] 0x%" PRIx64 " = 0x%" PRIx64, i, *(uint64_t *)psrc, *(uint64_t *)pdest); + for MB_EACH_ELEM(src_ptr, dest_ptr, param_size, PARAM_SIZE_DOUBLE) { + mb_set_double_badcfehg((val_64_arr *)dest_ptr, *(double *)src_ptr); + ESP_LOGV(TAG, "Convert double BADCFEHG[%d] 0x%" PRIx64 " = 0x%" PRIx64, i, *(uint64_t *)src_ptr, *(uint64_t *)dest_ptr); } break; @@ -740,34 +738,34 @@ esp_err_t mbc_master_set_param_data(void* dest, void* src, mb_descr_type_t param // Supports custom command options using the PAR_PERMS_CUST_CMD permission. // The MB_PARAM_CUSTOM register type mimics the custom commands specificly handled with // custom command handlers which have to be defined in command handling table. -uint8_t mbc_master_get_command(const mb_parameter_descriptor_t *pdescr, mb_param_mode_t mode) +uint8_t mbc_master_get_command(const mb_parameter_descriptor_t *descr, mb_param_mode_t mode) { - MB_RETURN_ON_FALSE((pdescr), 0, TAG, "incorrect data pointer."); + MB_RETURN_ON_FALSE((descr), 0, TAG, "incorrect data pointer."); uint8_t command = 0; - switch(pdescr->mb_param_type) + switch(descr->mb_param_type) { case MB_PARAM_HOLDING: - command = GET_CMD(mode, pdescr->access, MB_FUNC_READ_HOLDING_REGISTER, MB_FUNC_WRITE_MULTIPLE_REGISTERS); + command = GET_CMD(mode, descr->access, MB_FUNC_READ_HOLDING_REGISTER, MB_FUNC_WRITE_MULTIPLE_REGISTERS); break; case MB_PARAM_INPUT: - command = GET_CMD(mode, pdescr->access, MB_FUNC_READ_INPUT_REGISTER, 0); + command = GET_CMD(mode, descr->access, MB_FUNC_READ_INPUT_REGISTER, 0); break; case MB_PARAM_COIL: - command = GET_CMD(mode, pdescr->access, MB_FUNC_READ_COILS, MB_FUNC_WRITE_MULTIPLE_COILS); + command = GET_CMD(mode, descr->access, MB_FUNC_READ_COILS, MB_FUNC_WRITE_MULTIPLE_COILS); break; case MB_PARAM_DISCRETE: - command = GET_CMD(mode, pdescr->access, MB_FUNC_READ_DISCRETE_INPUTS, 0); + command = GET_CMD(mode, descr->access, MB_FUNC_READ_DISCRETE_INPUTS, 0); break; case MB_PARAM_CUSTOM: - if (pdescr->access & PAR_PERMS_CUST_CMD) { + if (descr->access & PAR_PERMS_CUST_CMD) { // Use custom command in the request for read or write - command = GET_CMD(mode, pdescr->access, (uint8_t)pdescr->param_opts.cust_cmd_read, (uint8_t)pdescr->param_opts.cust_cmd_write); + command = GET_CMD(mode, descr->access, (uint8_t)descr->param_opts.cust_cmd_read, (uint8_t)descr->param_opts.cust_cmd_write); } else { command = 0; } break; default: - ESP_LOGE(TAG, "%s: Incorrect param type (%u)", __FUNCTION__, (unsigned)pdescr->mb_param_type); + ESP_LOGE(TAG, "%s: Incorrect param type (%u)", __FUNCTION__, (unsigned)descr->mb_param_type); break; } return command; diff --git a/modbus/mb_controller/common/esp_modbus_master_serial.c b/modbus/mb_controller/common/esp_modbus_master_serial.c index 967c4ba..2da7d67 100644 --- a/modbus/mb_controller/common/esp_modbus_master_serial.c +++ b/modbus/mb_controller/common/esp_modbus_master_serial.c @@ -16,21 +16,20 @@ /** * Initialization of Modbus master serial */ -esp_err_t mbc_master_create_serial(mb_communication_info_t *config, void **handler) +esp_err_t mbc_master_create_serial(mb_communication_info_t *config, void **ctx) { - void *ctx = NULL; + void *obj = NULL; esp_err_t error = ESP_ERR_NOT_SUPPORTED; switch(config->mode) { case MB_RTU: case MB_ASCII: - error = mbc_serial_master_create(config, &ctx); + error = mbc_serial_master_create(config, &obj); break; default: return ESP_ERR_NOT_SUPPORTED; } - if ((ctx) && (error == ESP_OK)) { - //mbc_master_init_iface(ctx); - *handler = ctx; + if ((obj) && (error == ESP_OK)) { + *ctx = obj; } return error; } diff --git a/modbus/mb_controller/common/esp_modbus_master_tcp.c b/modbus/mb_controller/common/esp_modbus_master_tcp.c index 9a7a5f6..e094dfa 100644 --- a/modbus/mb_controller/common/esp_modbus_master_tcp.c +++ b/modbus/mb_controller/common/esp_modbus_master_tcp.c @@ -14,13 +14,13 @@ /** * Initialization of Modbus TCP Master controller interface */ -esp_err_t mbc_master_create_tcp(mb_communication_info_t *config, void **handler) +esp_err_t mbc_master_create_tcp(mb_communication_info_t *config, void **ctx) { - void *ctx = NULL; - esp_err_t error = mbc_tcp_master_create(config, &ctx); + void *obj = NULL; + esp_err_t error = mbc_tcp_master_create(config, &obj); - if ((ctx) && (error == ESP_OK)) { - *handler = ctx; + if ((obj) && (error == ESP_OK)) { + *ctx = obj; } return error; } diff --git a/modbus/mb_controller/common/esp_modbus_slave.c b/modbus/mb_controller/common/esp_modbus_slave.c index 8538ff2..9adac93 100644 --- a/modbus/mb_controller/common/esp_modbus_slave.c +++ b/modbus/mb_controller/common/esp_modbus_slave.c @@ -116,10 +116,10 @@ esp_err_t mbc_slave_lock(void *ctx) MB_RETURN_ON_FALSE(ctx, ESP_ERR_INVALID_STATE, TAG, "Slave interface is not correctly initialized."); mbs_controller_iface_t *mbs_controller = MB_SLAVE_GET_IFACE(ctx); - mb_base_t *pmb_obj = (mb_base_t *)mbs_controller->mb_base; - MB_RETURN_ON_FALSE((pmb_obj && pmb_obj->lock), ESP_ERR_INVALID_STATE, TAG, + mb_base_t *mb_obj = mbs_controller->mb_base; + MB_RETURN_ON_FALSE((mb_obj && mb_obj->lock), ESP_ERR_INVALID_STATE, TAG, "Slave interface is not correctly initialized."); - CRITICAL_SECTION_LOCK(pmb_obj->lock); + CRITICAL_SECTION_LOCK(mb_obj->lock); return ESP_OK; } @@ -131,10 +131,10 @@ esp_err_t mbc_slave_unlock(void *ctx) MB_RETURN_ON_FALSE(ctx, ESP_ERR_INVALID_STATE, TAG, "Slave interface is not correctly initialized."); mbs_controller_iface_t *mbs_controller = MB_SLAVE_GET_IFACE(ctx); - mb_base_t *pmb_obj = (mb_base_t *)mbs_controller->mb_base; - MB_RETURN_ON_FALSE((pmb_obj && pmb_obj->lock), ESP_ERR_INVALID_STATE, TAG, + mb_base_t *mb_obj = mbs_controller->mb_base; + MB_RETURN_ON_FALSE((mb_obj && mb_obj->lock), ESP_ERR_INVALID_STATE, TAG, "Slave interface is not correctly initialized."); - CRITICAL_SECTION_UNLOCK(pmb_obj->lock); + CRITICAL_SECTION_UNLOCK(mb_obj->lock); return ESP_OK; } @@ -142,15 +142,15 @@ esp_err_t mbc_slave_unlock(void *ctx) /** * Set object ID for the Modbus controller */ -esp_err_t mbc_set_slave_id(void *ctx, uint8_t slave_addr, bool is_running, uint8_t const *pdata, uint8_t data_len) +esp_err_t mbc_set_slave_id(void *ctx, uint8_t uid, bool is_running, uint8_t const *data_ptr, uint8_t data_len) { MB_RETURN_ON_FALSE(ctx, ESP_ERR_INVALID_STATE, TAG, "Slave interface is not correctly initialized."); - mbs_controller_iface_t *pmbs_controller = MB_SLAVE_GET_IFACE(ctx); + mbs_controller_iface_t *mbs_controller = MB_SLAVE_GET_IFACE(ctx); // The Report Slave ID functionality is useful for TCP and gateway, // so the design decision is to keep this functionality for all slaves // Set the slave ID if the KConfig option is selected - mb_err_enum_t status = mbs_set_slave_id(pmbs_controller->mb_base, slave_addr, is_running, (uint8_t *)pdata, data_len); + mb_err_enum_t status = mbs_set_slave_id(mbs_controller->mb_base, uid, is_running, (uint8_t *)data_ptr, data_len); MB_RETURN_ON_FALSE((status == MB_ENOERR), ESP_ERR_INVALID_STATE, TAG, "mb stack set slave ID failure."); return MB_ERR_TO_ESP_ERR(status); } @@ -158,12 +158,12 @@ esp_err_t mbc_set_slave_id(void *ctx, uint8_t slave_addr, bool is_running, uint8 /** * Get object ID from the Modbus controller */ -esp_err_t mbc_get_slave_id(void *ctx, uint8_t const *pdata, uint8_t *pdata_len) +esp_err_t mbc_get_slave_id(void *ctx, uint8_t const *data_ptr, uint8_t *data_len) { MB_RETURN_ON_FALSE(ctx, ESP_ERR_INVALID_STATE, TAG, "Slave interface is not correctly initialized."); - mbs_controller_iface_t *pmbs_controller = MB_SLAVE_GET_IFACE(ctx); - mb_err_enum_t status = mbs_get_slave_id(pmbs_controller->mb_base, (uint8_t *)pdata, pdata_len); + mbs_controller_iface_t *mbs_controller = MB_SLAVE_GET_IFACE(ctx); + mb_err_enum_t status = mbs_get_slave_id(mbs_controller->mb_base, (uint8_t *)data_ptr, data_len); MB_RETURN_ON_FALSE((status == MB_ENOERR), ESP_ERR_INVALID_STATE, TAG, "mb stack get slave ID failure."); return MB_ERR_TO_ESP_ERR(status); } @@ -348,7 +348,7 @@ mb_err_enum_t mbc_reg_input_slave_cb(mb_base_t *inst, uint8_t *reg_buffer, uint1 address--; // address of register is already +1 mb_descr_entry_t *it = mbc_slave_find_reg_descriptor(ctx, MB_PARAM_INPUT, address, n_regs); if (it) { - uint16_t input_reg_start = (uint16_t)it->start_offset; // Get Modbus start address + uint16_t input_reg_start = it->start_offset; // Get Modbus start address uint8_t *input_buffer = (uint8_t *)it->p_data; // Get instance address uint16_t regs = n_regs; uint16_t reg_index; @@ -368,8 +368,7 @@ mb_err_enum_t mbc_reg_input_slave_cb(mb_base_t *inst, uint8_t *reg_buffer, uint1 // Send access notification (void)mbc_slave_send_param_access_notification(ctx, MB_EVENT_INPUT_REG_RD); // Send parameter info to application task - (void)mbc_slave_send_param_info(ctx, MB_EVENT_INPUT_REG_RD, address, - (uint8_t *)buffer_start, n_regs); + (void)mbc_slave_send_param_info(ctx, MB_EVENT_INPUT_REG_RD, address, buffer_start, n_regs); } else { status = MB_ENOREG; } @@ -387,8 +386,8 @@ mb_err_enum_t mbc_reg_holding_slave_cb(mb_base_t *inst, uint8_t *reg_buffer, uin address--; // address of register is already +1 mb_descr_entry_t *it = mbc_slave_find_reg_descriptor(ctx, MB_PARAM_HOLDING, address, n_regs); if (it) { - uint16_t reg_holding_start = (uint16_t)it->start_offset; // Get Modbus start address - uint8_t *holding_buffer = (uint8_t *)it->p_data; // Get instance address + uint16_t reg_holding_start = it->start_offset; // Get Modbus start address + uint8_t *holding_buffer = it->p_data; // Get instance address uint16_t regs = n_regs; reg_index = (uint16_t) (address - reg_holding_start); reg_index <<= 1; // register Address to byte address @@ -408,8 +407,7 @@ mb_err_enum_t mbc_reg_holding_slave_cb(mb_base_t *inst, uint8_t *reg_buffer, uin // Send access notification (void)mbc_slave_send_param_access_notification(ctx, MB_EVENT_HOLDING_REG_RD); // Send parameter info - (void)mbc_slave_send_param_info(ctx, MB_EVENT_HOLDING_REG_RD, address, - (uint8_t *)buffer_start, n_regs); + (void)mbc_slave_send_param_info(ctx, MB_EVENT_HOLDING_REG_RD, address, buffer_start, n_regs); } else { status = MB_EINVAL; } @@ -428,8 +426,7 @@ mb_err_enum_t mbc_reg_holding_slave_cb(mb_base_t *inst, uint8_t *reg_buffer, uin // Send access notification (void)mbc_slave_send_param_access_notification(ctx, MB_EVENT_HOLDING_REG_WR); // Send parameter info - (void)mbc_slave_send_param_info(ctx, MB_EVENT_HOLDING_REG_WR, (uint16_t)address, - (uint8_t *)buffer_start, (uint16_t)n_regs); + (void)mbc_slave_send_param_info(ctx, MB_EVENT_HOLDING_REG_WR, address, buffer_start, n_regs); } else { status = MB_EINVAL; } @@ -453,8 +450,8 @@ mb_err_enum_t mbc_reg_coils_slave_cb(mb_base_t *inst, uint8_t *reg_buffer, uint1 address--; // The address is already +1 mb_descr_entry_t *it = mbc_slave_find_reg_descriptor(ctx, MB_PARAM_COIL, address, n_coils); if (it) { - uint16_t reg_coils_start = (uint16_t)it->start_offset; // MB offset of coils - uint8_t *reg_coils_buf = (uint8_t *)it->p_data; + uint16_t reg_coils_start = it->start_offset; // MB offset of coils + uint8_t *reg_coils_buf = it->p_data; reg_index = (uint16_t) (address - it->start_offset); char *coils_data_buf = (char *)(reg_coils_buf + (reg_index >> 3)); switch (mode) { @@ -463,7 +460,7 @@ mb_err_enum_t mbc_reg_coils_slave_cb(mb_base_t *inst, uint8_t *reg_buffer, uint1 CRITICAL_SECTION(inst->lock) { while (coils > 0) { - uint8_t result = mb_util_get_bits((uint8_t *)reg_coils_buf, reg_index, 1); + uint8_t result = mb_util_get_bits(reg_coils_buf, reg_index, 1); mb_util_set_bits(reg_buffer, reg_index - (address - reg_coils_start), 1, result); reg_index++; coils--; @@ -484,7 +481,7 @@ mb_err_enum_t mbc_reg_coils_slave_cb(mb_base_t *inst, uint8_t *reg_buffer, uint1 while (coils > 0) { uint8_t result = mb_util_get_bits(reg_buffer, reg_index - (address - reg_coils_start), 1); - mb_util_set_bits((uint8_t *)reg_coils_buf, reg_index, 1, result); + mb_util_set_bits(reg_coils_buf, reg_index, 1, result); reg_index++; coils--; } @@ -519,7 +516,7 @@ mb_err_enum_t mbc_reg_discrete_slave_cb(mb_base_t *inst, uint8_t *reg_buffer, ui address--; mb_descr_entry_t *it = mbc_slave_find_reg_descriptor(ctx, MB_PARAM_DISCRETE, address, n_discrete); if (it) { - uint16_t reg_discrete_start = (uint16_t)it->start_offset; // MB offset of registers + uint16_t reg_discrete_start = it->start_offset; // MB offset of registers n_reg = (n_discrete >> 3) + 1; discrete_input_buf = (uint8_t *)it->p_data; // the storage address reg_index = (uint16_t) (address - reg_discrete_start) / 8; // Get register index in the buffer for bit number @@ -540,8 +537,7 @@ mb_err_enum_t mbc_reg_discrete_slave_cb(mb_base_t *inst, uint8_t *reg_buffer, ui *reg_buffer = *reg_buffer >> (8 - n_discrete); // Send an event to notify application task about event (void)mbc_slave_send_param_access_notification(ctx, MB_EVENT_DISCRETE_RD); - (void)mbc_slave_send_param_info(ctx, MB_EVENT_DISCRETE_RD, address, - (uint8_t *)temp_buf, n_discrete); + (void)mbc_slave_send_param_info(ctx, MB_EVENT_DISCRETE_RD, address, temp_buf, n_discrete); } else { status = MB_ENOREG; } diff --git a/modbus/mb_controller/common/esp_modbus_slave_serial.c b/modbus/mb_controller/common/esp_modbus_slave_serial.c index b28cc26..00cbd9c 100644 --- a/modbus/mb_controller/common/esp_modbus_slave_serial.c +++ b/modbus/mb_controller/common/esp_modbus_slave_serial.c @@ -17,23 +17,23 @@ /** * Initialization of Modbus Serial slave controller */ -esp_err_t mbc_slave_create_serial(mb_communication_info_t *config, void **handler) +esp_err_t mbc_slave_create_serial(mb_communication_info_t *config, void **ctx) { - void *ctx = NULL; + void *obj = NULL; esp_err_t error = ESP_ERR_NOT_SUPPORTED; switch(config->mode) { case MB_RTU: case MB_ASCII: // Call constructor function of actual port implementation - error = mbc_serial_slave_create(config, &ctx); + error = mbc_serial_slave_create(config, &obj); break; default: return ESP_ERR_NOT_SUPPORTED; } - if ((ctx) && (error == ESP_OK)) { - mbc_slave_init_iface(ctx); - *handler = ctx; + if ((obj) && (error == ESP_OK)) { + mbc_slave_init_iface(obj); + *ctx = obj; } return error; } diff --git a/modbus/mb_controller/common/esp_modbus_slave_tcp.c b/modbus/mb_controller/common/esp_modbus_slave_tcp.c index 9a1945a..6c6b644 100644 --- a/modbus/mb_controller/common/esp_modbus_slave_tcp.c +++ b/modbus/mb_controller/common/esp_modbus_slave_tcp.c @@ -15,14 +15,14 @@ /** * Initialization of Modbus TCP Slave controller */ -esp_err_t mbc_slave_create_tcp(mb_communication_info_t *config, void **handler) +esp_err_t mbc_slave_create_tcp(mb_communication_info_t *config, void **ctx) { - void *ctx = NULL; - esp_err_t error = mbc_tcp_slave_create(config, &ctx); + void *obj = NULL; + esp_err_t error = mbc_tcp_slave_create(config, &obj); - if ((ctx) && (error == ESP_OK)) { - mbc_slave_init_iface(ctx); - *handler = ctx; + if ((obj) && (error == ESP_OK)) { + mbc_slave_init_iface(obj); + *ctx = obj; } return error; } diff --git a/modbus/mb_controller/common/include/esp_modbus_common.h b/modbus/mb_controller/common/include/esp_modbus_common.h index e56bf7e..e5b1b32 100644 --- a/modbus/mb_controller/common/include/esp_modbus_common.h +++ b/modbus/mb_controller/common/include/esp_modbus_common.h @@ -159,14 +159,14 @@ typedef enum { MB_PARAM_UNKNOWN = 0xFF } mb_param_type_t; -typedef enum _mb_comm_mode mb_mode_type_t; +typedef enum mb_comm_mode_enum mb_mode_type_t; typedef struct mb_base_t mb_base_t; /*! * \brief Modbus TCP type of address for communication. */ -typedef enum _addr_type_enum mb_tcp_addr_type_t; +typedef enum addr_type_enum mb_tcp_addr_type_t; /*! * \brief Modbus TCP communication options structure. @@ -217,7 +217,7 @@ typedef struct { * * @param[in] ctx context pointer to the controller object (master or slave) * @param[in] func_code the function code for the handler - * @param[in] phandler the pointer to function handler being used for command + * @param[in] handler the pointer to function handler being used for command * * @return * - esp_err_t ESP_OK - the function handler is correctly set the handler @@ -225,21 +225,21 @@ typedef struct { * - esp_err_t ESP_ERR_INVALID_STATE - can not register non-existent handler or can not * - esp_err_t ESP_ERR_NOT_FOUND - the requested slave is not found (not connected or not configured) */ -esp_err_t mbc_set_handler(void *ctx, uint8_t func_code, mb_fn_handler_fp phandler); +esp_err_t mbc_set_handler(void *ctx, uint8_t func_code, mb_fn_handler_fp handler); /** * @brief The function gets function handler for specified command from the controller object handler table. * * @param[in] ctx context pointer to the controller object (master or slave) * @param[in] func_code the function code for the handler - * @param[out] phandler the pointer to function handler being returned + * @param[out] handler the pointer to function handler being returned * * @return * - esp_err_t ESP_OK - the function handler is returned * - esp_err_t ESP_ERR_INVALID_ARG - invalid argument of function or parameter descriptor * esp_err_t ESP_ERR_INVALID_STATE - can not register non-existent handler or incorrect configuration */ -esp_err_t mbc_get_handler(void *ctx, uint8_t func_code, mb_fn_handler_fp *phandler); +esp_err_t mbc_get_handler(void *ctx, uint8_t func_code, mb_fn_handler_fp *handler); /** * @brief The function deletes function handler for specified command from the controller object command handler table. @@ -258,14 +258,14 @@ esp_err_t mbc_delete_handler(void *ctx, uint8_t func_code); * @brief The function gets the number of registered function handlers for the controller object. * * @param[in] ctx context pointer to the controller object (master or slave) - * @param[out] pcount the pointer to returned counter + * @param[out] count the pointer to returned counter * * @return * - esp_err_t ESP_OK - the function handler is returned in the * - esp_err_t ESP_ERR_INVALID_ARG - invalid argument of function or parameter descriptor * esp_err_t ESP_ERR_INVALID_STATE - can not register non-existent handler or incorrect configuration */ -esp_err_t mbc_get_handler_count(void *ctx, uint16_t *pcount); +esp_err_t mbc_get_handler_count(void *ctx, uint16_t *count); #ifdef __cplusplus } diff --git a/modbus/mb_controller/common/include/esp_modbus_master.h b/modbus/mb_controller/common/include/esp_modbus_master.h index a93e872..2558df3 100644 --- a/modbus/mb_controller/common/include/esp_modbus_master.h +++ b/modbus/mb_controller/common/include/esp_modbus_master.h @@ -30,10 +30,10 @@ extern "C" { #define MB_MASTER_IS_ACTIVE(pctx) ((bool)(MB_MASTER_GET_IFACE(pctx)->is_active)) -#define MB_MASTER_GET_IFACE_FROM_BASE(pinst) (__extension__( \ +#define MB_MASTER_GET_IFACE_FROM_BASE(inst) (__extension__( \ { \ - MB_MASTER_ASSERT(pinst); \ - mb_base_t *pbase = (mb_base_t *)pinst; \ + MB_MASTER_ASSERT(inst); \ + mb_base_t *pbase = (mb_base_t *)inst; \ MB_RETURN_ON_FALSE(pbase->descr.parent, MB_EILLSTATE, TAG, "Master interface is not correctly initialized."); \ ((mbm_controller_iface_t*)pbase->descr.parent); \ } \ @@ -42,8 +42,8 @@ extern "C" { /*! * \brief The macro to access arrays of elements for type conversion. */ -#define MB_EACH_ELEM(psrc, pdest, arr_size, elem_size) \ -(int i = 0; (i < (arr_size / elem_size)); i++, pdest += elem_size, psrc += elem_size) +#define MB_EACH_ELEM(src_ptr, dest_ptr, arr_size, elem_size) \ +(int i = 0; (i < (arr_size / elem_size)); i++, dest_ptr += elem_size, src_ptr += elem_size) /** * @brief Request mode for parameter to use in data dictionary @@ -195,7 +195,7 @@ typedef struct { * - ESP_ERR_NOT_SUPPORTED Port type not supported * - ESP_ERR_INVALID_STATE Initialization failure */ -esp_err_t mbc_master_create_tcp(mb_communication_info_t *config, void ** ctx); +esp_err_t mbc_master_create_tcp(mb_communication_info_t *config, void **ctx); /** * @brief Initialize Modbus Master controller and stack for Serial port @@ -208,7 +208,7 @@ esp_err_t mbc_master_create_tcp(mb_communication_info_t *config, void ** ctx); * - ESP_ERR_NOT_SUPPORTED Port type not supported * - ESP_ERR_INVALID_STATE Initialization failure */ -esp_err_t mbc_master_create_serial(mb_communication_info_t *config, void ** ctx); +esp_err_t mbc_master_create_serial(mb_communication_info_t *config, void **ctx); /** * @brief Deletes Modbus controller and stack engine @@ -413,58 +413,58 @@ esp_err_t mbc_master_set_parameter_with(void *ctx, uint16_t cid, uint8_t uid, ui * * @param[in] inst the pointer of the initialized modbus base * @param[in] reg_buffer input buffer of registers - * @param[in] address - start address of register + * @param[in] reg_address - start address of register * @param[in] mode - parameter access mode (MB_REG_READ, MB_REG_WRITE) - * @param[in] n_regs - number of registers + * @param[in] num_regs - number of registers * * @return * - MB_ENOERR: Read write is successful * - MB_ENOREG: The argument is incorrect */ -mb_err_enum_t mbc_reg_holding_master_cb(mb_base_t *inst, uint8_t *reg_buffer, uint16_t address, uint16_t n_regs, mb_reg_mode_enum_t mode) __attribute__ ((weak)); +mb_err_enum_t mbc_reg_holding_master_cb(mb_base_t *inst, uint8_t *reg_buffer, uint16_t reg_address, uint16_t num_regs, mb_reg_mode_enum_t mode) __attribute__ ((weak)); /** * @brief Input register read/write callback function * * @param[in] inst the pointer of the initialized modbus base * @param[in] reg_buffer input buffer of registers - * @param[in] address - start address of register - * @param[in] n_regs - number of registers + * @param[in] reg_address - start address of register + * @param[in] num_regs - number of registers * * @return * - MB_ENOERR: Read write is successful * - MB_ENOREG: The argument is incorrect */ -mb_err_enum_t mbc_reg_input_master_cb(mb_base_t *inst, uint8_t *reg_buffer, uint16_t address, uint16_t n_regs) __attribute__ ((weak)); +mb_err_enum_t mbc_reg_input_master_cb(mb_base_t *inst, uint8_t *reg_buffer, uint16_t reg_address, uint16_t num_regs) __attribute__ ((weak)); /** * @brief Discrete register read/write callback function * * @param[in] inst the pointer of the initialized modbus base * @param[in] reg_buffer input buffer of registers - * @param[in] address - start address of register + * @param[in] reg_address - start address of register * @param[in] n_discrete - number of discrete registers * * @return * - MB_ENOERR: Read write is successful * - MB_ENOREG: The argument is incorrect */ -mb_err_enum_t mbc_reg_discrete_master_cb(mb_base_t *inst, uint8_t *reg_buffer, uint16_t address, uint16_t n_discrete) __attribute__ ((weak)); +mb_err_enum_t mbc_reg_discrete_master_cb(mb_base_t *inst, uint8_t *reg_buffer, uint16_t reg_address, uint16_t n_discrete) __attribute__ ((weak)); /** * @brief Coil register read/write callback function * * @param[in] inst the pointer of the initialized modbus base * @param[in] reg_buffer input buffer of registers - * @param[in] address - start address of register - * @param[in] n_coils - number of coil registers + * @param[in] reg_addr - start address of register + * @param[in] ncoils - number of coil registers * @param[in] mode - parameter access mode (MB_REG_READ, MB_REG_WRITE) * * @return * - MB_ENOERR: Read write is successful * - MB_ENOREG: The argument is incorrect */ -mb_err_enum_t mbc_reg_coils_master_cb(mb_base_t *inst, uint8_t *reg_buffer, uint16_t address, uint16_t n_coils, mb_reg_mode_enum_t mode) __attribute__ ((weak)); +mb_err_enum_t mbc_reg_coils_master_cb(mb_base_t *inst, uint8_t *reg_buffer, uint16_t reg_addr, uint16_t ncoils, mb_reg_mode_enum_t mode) __attribute__ ((weak)); /** * @brief The helper function to set data of parameters according to its type @@ -486,14 +486,14 @@ esp_err_t mbc_master_set_param_data(void* dest, void* src, mb_descr_type_t param /** * @brief The helper function to get supported modbus function code (command) according to parameter type * - * @param[in] pdescr the pointer to the characteristic descriptor in data dictionary + * @param[in] descr the pointer to the characteristic descriptor in data dictionary * @param[in] mode access mode for characteristic * * @return * - modbus function code, if the command is correctly configured * - 0 - invalid argument or command not found */ -uint8_t mbc_master_get_command(const mb_parameter_descriptor_t *pdescr, mb_param_mode_t mode); +uint8_t mbc_master_get_command(const mb_parameter_descriptor_t *descr, mb_param_mode_t mode); #ifdef __cplusplus diff --git a/modbus/mb_controller/common/include/esp_modbus_slave.h b/modbus/mb_controller/common/include/esp_modbus_slave.h index fad35ee..b95533b 100644 --- a/modbus/mb_controller/common/include/esp_modbus_slave.h +++ b/modbus/mb_controller/common/include/esp_modbus_slave.h @@ -35,10 +35,10 @@ extern "C" { #define MB_SLAVE_IS_ACTIVE(pctx) ((bool)(MB_SLAVE_GET_IFACE(pctx)->is_active)) -#define MB_SLAVE_GET_IFACE_FROM_BASE(pinst) (__extension__( \ +#define MB_SLAVE_GET_IFACE_FROM_BASE(inst) (__extension__( \ { \ - MB_SLAVE_ASSERT(pinst); \ - mb_base_t *pbase = (mb_base_t*)pinst; \ + MB_SLAVE_ASSERT(inst); \ + mb_base_t *pbase = (mb_base_t*)inst; \ MB_RETURN_ON_FALSE(pbase->descr.parent, MB_EILLSTATE, TAG, "Slave interface is not correctly initialized."); \ ((mbs_controller_iface_t*)pbase->descr.parent); \ } \ @@ -209,29 +209,29 @@ esp_err_t mbc_slave_set_descriptor(void *ctx, mb_register_area_descriptor_t desc * @param[in] ctx context pointer of the initialized modbus interface * @param[in] uid - unit identifier (short slave address) for Modbus slave * @param[in] is_running - Modbus slave running status - * @param[in] pdata - pointer to data buffer for extended context (vendor specific) + * @param[in] data_ptr - pointer to data buffer for extended context (vendor specific) * @param[in] data_len - length of data buffer (the length of the extended context) * * @return * - ESP_OK: The appropriate identificator is set * - ESP_ERR_INVALID_ARG: The argument is incorrect */ -esp_err_t mbc_set_slave_id(void *ctx, uint8_t uid, bool is_running, uint8_t const *pdata, uint8_t data_len); +esp_err_t mbc_set_slave_id(void *ctx, uint8_t uid, bool is_running, uint8_t const *data_ptr, uint8_t data_len); /*! \brief Get slave identificator from the modbus object. * * This function is used to get the Slave ID array for modbus object. * * \param ctx - context pointer of the initialized modbus interface - * \param pdata - the pointer to store object ID array from the modbus object - * \param[in/out] pdata_len - in: length of the allocated pdata array, + * \param data_ptr - the pointer to store object ID array from the modbus object + * \param[in/out] data_len - in: length of the allocated data_ptr array, * out: returns the actual length of object id. * returns the modbus error code = ESP_OK, if set correctly, * ESP_ERR_INVALID_RESPONSE - if the object ID is not set, - * ESP_ERR_INVALID_STATE - no space to store object ID in the pdata buffer, + * ESP_ERR_INVALID_STATE - no space to store object ID in the data_ptr buffer, * or incorrect arguments are provided */ -esp_err_t mbc_get_slave_id(void *ctx, uint8_t const *pdata, uint8_t *pdata_len); +esp_err_t mbc_get_slave_id(void *ctx, uint8_t const *data_ptr, uint8_t *data_len); #endif /** diff --git a/modbus/mb_controller/common/mb_endianness_utils.c b/modbus/mb_controller/common/mb_endianness_utils.c index f758954..06dc8e5 100644 --- a/modbus/mb_controller/common/mb_endianness_utils.c +++ b/modbus/mb_controller/common/mb_endianness_utils.c @@ -10,9 +10,9 @@ #define INLINE inline __attribute__((always_inline)) -static INLINE int16_t mb_get_int16_generic(int n0, int n1, val_16_arr *psrc) +static INLINE int16_t mb_get_int16_generic(int n0, int n1, val_16_arr *src_ptr) { - val_16_arr *pv = psrc; + val_16_arr *pv = src_ptr; union { val_16_arr arr; int16_t value; @@ -22,9 +22,9 @@ static INLINE int16_t mb_get_int16_generic(int n0, int n1, val_16_arr *psrc) return (bov.value); } -static INLINE uint16_t mb_get_uint16_generic(int n0, int n1, val_16_arr *psrc) +static INLINE uint16_t mb_get_uint16_generic(int n0, int n1, val_16_arr *src_ptr) { - val_16_arr *pv = psrc; + val_16_arr *pv = src_ptr; union { val_16_arr arr; uint16_t value; @@ -34,9 +34,9 @@ static INLINE uint16_t mb_get_uint16_generic(int n0, int n1, val_16_arr *psrc) return (bov.value); } -static INLINE uint16_t mb_set_uint16_generic(int n0, int n1, val_16_arr *pdest, uint16_t val) +static INLINE uint16_t mb_set_uint16_generic(int n0, int n1, val_16_arr *dest_ptr, uint16_t val) { - val_16_arr *pv = pdest; + val_16_arr *pv = dest_ptr; union { val_16_arr arr; uint16_t value; @@ -47,9 +47,9 @@ static INLINE uint16_t mb_set_uint16_generic(int n0, int n1, val_16_arr *pdest, return (*((uint16_t *)pv)); } -static INLINE int16_t mb_set_int16_generic(int n0, int n1, val_16_arr *pdest, int16_t val) +static INLINE int16_t mb_set_int16_generic(int n0, int n1, val_16_arr *dest_ptr, int16_t val) { - val_16_arr *pv = pdest; + val_16_arr *pv = dest_ptr; union { val_16_arr arr; int16_t value; @@ -60,9 +60,9 @@ static INLINE int16_t mb_set_int16_generic(int n0, int n1, val_16_arr *pdest, in return (*((uint16_t *)pv)); } -static INLINE uint32_t mb_get_uint32_generic(int n0, int n1, int n2, int n3, val_32_arr *psrc) +static INLINE uint32_t mb_get_uint32_generic(int n0, int n1, int n2, int n3, val_32_arr *src_ptr) { - val_32_arr *pv = psrc; + val_32_arr *pv = src_ptr; union { val_32_arr arr; uint32_t value; @@ -74,9 +74,9 @@ static INLINE uint32_t mb_get_uint32_generic(int n0, int n1, int n2, int n3, val return (bov.value); } -static INLINE int32_t mb_get_int32_generic(int n0, int n1, int n2, int n3, val_32_arr *psrc) +static INLINE int32_t mb_get_int32_generic(int n0, int n1, int n2, int n3, val_32_arr *src_ptr) { - val_32_arr *pv = psrc; + val_32_arr *pv = src_ptr; union { val_32_arr arr; int32_t value; @@ -88,9 +88,9 @@ static INLINE int32_t mb_get_int32_generic(int n0, int n1, int n2, int n3, val_3 return (bov.value); } -static INLINE float mb_get_float_generic(int n0, int n1, int n2, int n3, val_32_arr *psrc) +static INLINE float mb_get_float_generic(int n0, int n1, int n2, int n3, val_32_arr *src_ptr) { - val_32_arr *pv = psrc; + val_32_arr *pv = src_ptr; union { val_32_arr arr; float value; @@ -102,9 +102,9 @@ static INLINE float mb_get_float_generic(int n0, int n1, int n2, int n3, val_32_ return (bov.value); } -static INLINE uint32_t mb_set_int32_generic(int n0, int n1, int n2, int n3, val_32_arr *pdest, int32_t val) +static INLINE uint32_t mb_set_int32_generic(int n0, int n1, int n2, int n3, val_32_arr *dest_ptr, int32_t val) { - val_32_arr *pv = pdest; + val_32_arr *pv = dest_ptr; union { val_32_arr arr; int32_t value; @@ -117,9 +117,9 @@ static INLINE uint32_t mb_set_int32_generic(int n0, int n1, int n2, int n3, val_ return (*((uint32_t *)pv)); } -static INLINE uint32_t mb_set_uint32_generic(int n0, int n1, int n2, int n3, val_32_arr *pdest, uint32_t val) +static INLINE uint32_t mb_set_uint32_generic(int n0, int n1, int n2, int n3, val_32_arr *dest_ptr, uint32_t val) { - val_32_arr *pv = pdest; + val_32_arr *pv = dest_ptr; union { val_32_arr arr; uint32_t value; @@ -132,9 +132,9 @@ static INLINE uint32_t mb_set_uint32_generic(int n0, int n1, int n2, int n3, val return (*((uint32_t *)pv)); } -static INLINE uint32_t mb_set_float_generic(int n0, int n1, int n2, int n3, val_32_arr *pdest, float val) +static INLINE uint32_t mb_set_float_generic(int n0, int n1, int n2, int n3, val_32_arr *dest_ptr, float val) { - val_32_arr *pv = pdest; + val_32_arr *pv = dest_ptr; union { val_32_arr arr; float value; @@ -147,9 +147,9 @@ static INLINE uint32_t mb_set_float_generic(int n0, int n1, int n2, int n3, val_ return (*((uint32_t *)pv)); } -static INLINE int64_t mb_get_int64_generic(int n0, int n1, int n2, int n3, int n4, int n5, int n6, int n7, val_64_arr *psrc) +static INLINE int64_t mb_get_int64_generic(int n0, int n1, int n2, int n3, int n4, int n5, int n6, int n7, val_64_arr *src_ptr) { - val_64_arr *pv64 = psrc; + val_64_arr *pv64 = src_ptr; union { val_64_arr arr; int64_t value; @@ -165,9 +165,9 @@ static INLINE int64_t mb_get_int64_generic(int n0, int n1, int n2, int n3, int n return (bo64.value); } -static INLINE uint64_t mb_get_uint64_generic(int n0, int n1, int n2, int n3, int n4, int n5, int n6, int n7, val_64_arr *psrc) +static INLINE uint64_t mb_get_uint64_generic(int n0, int n1, int n2, int n3, int n4, int n5, int n6, int n7, val_64_arr *src_ptr) { - val_64_arr *pv64 = psrc; + val_64_arr *pv64 = src_ptr; union { val_64_arr arr; uint64_t value; @@ -183,9 +183,9 @@ static INLINE uint64_t mb_get_uint64_generic(int n0, int n1, int n2, int n3, int return (bo64.value); } -static INLINE double mb_get_double_generic(int n0, int n1, int n2, int n3, int n4, int n5, int n6, int n7, val_64_arr *psrc) +static INLINE double mb_get_double_generic(int n0, int n1, int n2, int n3, int n4, int n5, int n6, int n7, val_64_arr *src_ptr) { - val_64_arr *pv64 = psrc; + val_64_arr *pv64 = src_ptr; union { val_64_arr arr; double value; @@ -201,9 +201,9 @@ static INLINE double mb_get_double_generic(int n0, int n1, int n2, int n3, int n return (bo64.value); } -static INLINE uint64_t mb_set_int64_generic(int n0, int n1, int n2, int n3, int n4, int n5, int n6, int n7, val_64_arr *pdest, int64_t val) +static INLINE uint64_t mb_set_int64_generic(int n0, int n1, int n2, int n3, int n4, int n5, int n6, int n7, val_64_arr *dest_ptr, int64_t val) { - val_64_arr *pv = pdest; + val_64_arr *pv = dest_ptr; union { val_64_arr arr; int64_t value; @@ -220,9 +220,9 @@ static INLINE uint64_t mb_set_int64_generic(int n0, int n1, int n2, int n3, int return (*((uint64_t *)pv)); } -static INLINE uint64_t mb_set_uint64_generic(int n0, int n1, int n2, int n3, int n4, int n5, int n6, int n7, val_64_arr *pdest, uint64_t val) +static INLINE uint64_t mb_set_uint64_generic(int n0, int n1, int n2, int n3, int n4, int n5, int n6, int n7, val_64_arr *dest_ptr, uint64_t val) { - val_64_arr *pv = pdest; + val_64_arr *pv = dest_ptr; union { val_64_arr arr; uint64_t value; @@ -239,9 +239,9 @@ static INLINE uint64_t mb_set_uint64_generic(int n0, int n1, int n2, int n3, int return (*((uint64_t *)pv)); } -static INLINE uint64_t mb_set_double_generic(int n0, int n1, int n2, int n3, int n4, int n5, int n6, int n7, val_64_arr *pdest, double val) +static INLINE uint64_t mb_set_double_generic(int n0, int n1, int n2, int n3, int n4, int n5, int n6, int n7, val_64_arr *dest_ptr, double val) { - val_64_arr *pv = pdest; + val_64_arr *pv = dest_ptr; union { val_64_arr arr; double value; @@ -258,426 +258,330 @@ static INLINE uint64_t mb_set_double_generic(int n0, int n1, int n2, int n3, int return (*((uint64_t *)pv)); } -int8_t mb_get_int8_a(pi16) -val_16_arr *pi16; +int8_t mb_get_int8_a(val_16_arr *pi16) { return((int8_t)(*pi16)[MB_BO16_0]); } -uint16_t mb_set_int8_a(pi16, i8) -val_16_arr *pi16; -int8_t i8; +uint16_t mb_set_int8_a(val_16_arr *pi16, int8_t i8) { (*pi16)[MB_BO16_0] = (char)i8; (*pi16)[MB_BO16_1] = 0; return (*((uint16_t *)pi16)); } -int8_t mb_get_int8_b(pi16) -val_16_arr *pi16; +int8_t mb_get_int8_b(val_16_arr *pi16) { return((int8_t)(*pi16)[MB_BO16_1]); } -uint16_t mb_set_int8_b(pi16, i8) -val_16_arr *pi16; -int8_t i8; +uint16_t mb_set_int8_b(val_16_arr *pi16, int8_t i8) { (*pi16)[MB_BO16_0] = 0; (*pi16)[MB_BO16_1] = (char)i8; return (*((uint16_t *)pi16)); } -uint8_t mb_get_uint8_a(pu16) -val_16_arr *pu16; +uint8_t mb_get_uint8_a(val_16_arr *pu16) { - return((uint8_t)(*pu16)[MB_BO16_0]); + return((*pu16)[MB_BO16_0]); } -uint16_t mb_set_uint8_a(pu16, u8) -val_16_arr *pu16; -uint8_t u8; +uint16_t mb_set_uint8_a(val_16_arr *pu16, uint8_t u8) { (*pu16)[MB_BO16_0] = (char)u8; (*pu16)[MB_BO16_1] = 0; return (*((uint16_t *)pu16)); } -uint8_t mb_get_uint8_b(pu16) -val_16_arr *pu16; +uint8_t mb_get_uint8_b(val_16_arr *pu16) { - return((uint8_t)(*pu16)[MB_BO16_1]); + return((*pu16)[MB_BO16_1]); } -uint16_t mb_set_uint8_b(pu16, u8) -val_16_arr *pu16; -uint8_t u8; +uint16_t mb_set_uint8_b(val_16_arr *pu16, uint8_t u8) { (*pu16)[MB_BO16_0] = 0; (*pu16)[MB_BO16_1] = (char)u8; return (*((uint16_t *)pu16)); } -int16_t mb_get_int16_ab(pi16) -val_16_arr *pi16; +int16_t mb_get_int16_ab(val_16_arr *pi16) { return mb_get_int16_generic(0, 1, pi16); } -uint16_t mb_set_int16_ab(pi16, i16) -val_16_arr *pi16; -int16_t i16; +uint16_t mb_set_int16_ab(val_16_arr *pi16, int16_t i16) { return mb_set_int16_generic(0, 1, pi16, i16); } -uint16_t mb_get_uint16_ab(pu16) -val_16_arr *pu16; +uint16_t mb_get_uint16_ab(val_16_arr *pu16) { return mb_get_uint16_generic(0, 1, pu16); } -uint16_t mb_set_uint16_ab(pu16, u16) -val_16_arr *pu16; -uint16_t u16; +uint16_t mb_set_uint16_ab(val_16_arr *pu16, uint16_t u16) { return mb_set_uint16_generic(0, 1, pu16, u16); } -int16_t mb_get_int16_ba(pi16) -val_16_arr *pi16; +int16_t mb_get_int16_ba(val_16_arr *pi16) { return mb_get_int16_generic(1, 0, pi16); } -uint16_t mb_set_int16_ba(pi16, i16) -val_16_arr *pi16; -int16_t i16; +uint16_t mb_set_int16_ba(val_16_arr *pi16, int16_t i16) { return mb_set_int16_generic(1, 0, pi16, i16); } -uint16_t mb_get_uint16_ba(pu16) -val_16_arr *pu16; +uint16_t mb_get_uint16_ba(val_16_arr *pu16) { return mb_get_int16_generic(1, 0, pu16); } -uint16_t mb_set_uint16_ba(pu16, u16) -val_16_arr *pu16; -uint16_t u16; +uint16_t mb_set_uint16_ba(val_16_arr *pu16, uint16_t u16) { return mb_set_int16_generic(1, 0, pu16, u16); } -int32_t mb_get_int32_abcd(pi32) -val_32_arr *pi32; +int32_t mb_get_int32_abcd(val_32_arr *pi32) { return mb_get_int32_generic(0, 1, 2, 3, pi32); } -uint32_t mb_set_int32_abcd(pi32, i32) -val_32_arr *pi32; -int32_t i32; +uint32_t mb_set_int32_abcd(val_32_arr *pi32, int32_t i32) { return mb_set_int32_generic(0, 1, 2, 3, pi32, i32); } -uint32_t mb_get_uint32_abcd(pu32) -val_32_arr *pu32; +uint32_t mb_get_uint32_abcd(val_32_arr *pu32) { return mb_get_uint32_generic(0, 1, 2, 3, pu32); } -uint32_t mb_set_uint32_abcd(pu32, u32) -val_32_arr *pu32; -uint32_t u32; +uint32_t mb_set_uint32_abcd(val_32_arr *pu32, uint32_t u32) { return mb_set_uint32_generic(0, 1, 2, 3, pu32, u32); } -int32_t mb_get_int32_badc(pi32) -val_32_arr *pi32; +int32_t mb_get_int32_badc(val_32_arr *pi32) { return mb_get_int32_generic(1, 0, 3, 2, pi32); } -uint32_t mb_set_int32_badc(pi32, i32) -val_32_arr *pi32; -int32_t i32; +uint32_t mb_set_int32_badc(val_32_arr *pi32, int32_t i32) { return mb_set_int32_generic(1, 0, 3, 2, pi32, i32); } -uint32_t mb_get_uint32_badc(pu32) -val_32_arr *pu32; +uint32_t mb_get_uint32_badc(val_32_arr *pu32) { return mb_get_uint32_generic(1, 0, 3, 2, pu32); } -uint32_t mb_set_uint32_badc(pu32, u32) -val_32_arr *pu32; -uint32_t u32; +uint32_t mb_set_uint32_badc(val_32_arr *pu32, uint32_t u32) { return mb_set_uint32_generic(1, 0, 3, 2, pu32, u32); } -int32_t mb_get_int32_cdab(pi32) -val_32_arr *pi32; +int32_t mb_get_int32_cdab(val_32_arr *pi32) { return mb_get_int32_generic(2, 3, 0, 1, pi32); } -uint32_t mb_set_int32_cdab(pi32, i32) -val_32_arr *pi32; -int32_t i32; +uint32_t mb_set_int32_cdab(val_32_arr *pi32, int32_t i32) { return mb_set_int32_generic(2, 3, 0, 1, pi32, i32); } -uint32_t mb_get_uint32_cdab(pu32) -val_32_arr *pu32; +uint32_t mb_get_uint32_cdab(val_32_arr *pu32) { return mb_get_uint32_generic(2, 3, 0, 1, pu32); } -uint32_t mb_set_uint32_cdab(pu32, u32) -val_32_arr *pu32; -uint32_t u32; +uint32_t mb_set_uint32_cdab(val_32_arr *pu32, uint32_t u32) { return mb_set_uint32_generic(2, 3, 0, 1, pu32, u32); } -int32_t mb_get_int32_dcba(pi32) -val_32_arr *pi32; +int32_t mb_get_int32_dcba(val_32_arr *pi32) { return mb_get_int32_generic(3, 2, 1, 0, pi32); } -uint32_t mb_set_int32_dcba(pi32, i32) -val_32_arr *pi32; -int32_t i32; +uint32_t mb_set_int32_dcba(val_32_arr *pi32, int32_t i32) { return mb_set_int32_generic(3, 2, 1, 0, pi32, i32); } -uint32_t mb_get_uint32_dcba(pu32) -val_32_arr *pu32; +uint32_t mb_get_uint32_dcba(val_32_arr *pu32) { return mb_get_uint32_generic(3, 2, 1, 0, pu32); } -uint32_t mb_set_uint32_dcba(pu32, u32) -val_32_arr *pu32; -uint32_t u32; +uint32_t mb_set_uint32_dcba(val_32_arr *pu32, uint32_t u32) { return mb_set_uint32_generic(3, 2, 1, 0, pu32, u32); } -float mb_get_float_abcd(pf) -val_32_arr *pf; +float mb_get_float_abcd(val_32_arr *pf) { return mb_get_float_generic(0, 1, 2, 3, pf); } -uint32_t mb_set_float_abcd(pf, f) -val_32_arr *pf; -float f; +uint32_t mb_set_float_abcd(val_32_arr *pf, float f) { return mb_set_float_generic(0, 1, 2, 3, pf, f); } -float mb_get_float_badc(pf) -val_32_arr *pf; +float mb_get_float_badc(val_32_arr *pf) { return mb_get_float_generic(1, 0, 3, 2, pf); } -uint32_t mb_set_float_badc(pf, f) -val_32_arr *pf; -float f; +uint32_t mb_set_float_badc(val_32_arr *pf, float f) { return mb_set_float_generic(1, 0, 3, 2, pf, f); } -float mb_get_float_cdab(pf) -val_32_arr *pf; +float mb_get_float_cdab(val_32_arr *pf) { return mb_get_float_generic(2, 3, 0, 1, pf); } -uint32_t mb_set_float_cdab(pf, f) -val_32_arr *pf; -float f; +uint32_t mb_set_float_cdab(val_32_arr *pf, float f) { return mb_set_float_generic(2, 3, 0, 1, pf, f); } -float mb_get_float_dcba(pf) -val_32_arr *pf; +float mb_get_float_dcba(val_32_arr *pf) { return mb_get_float_generic(3, 2, 1, 0, pf); } -uint32_t mb_set_float_dcba(pf, f) -val_32_arr *pf; -float f; +uint32_t mb_set_float_dcba(val_32_arr *pf, float f) { return mb_set_float_generic(3, 2, 1, 0, pf, f); } -double mb_get_double_abcdefgh(pd) -val_64_arr *pd; +double mb_get_double_abcdefgh(val_64_arr *pd) { return mb_get_double_generic(0, 1, 2, 3, 4, 5, 6, 7, pd); } -uint64_t mb_set_double_abcdefgh(pd, d) -val_64_arr *pd; -double d; +uint64_t mb_set_double_abcdefgh(val_64_arr *pd, double d) { return mb_set_double_generic(0, 1, 2, 3, 4, 5, 6, 7, pd, d); } -double mb_get_double_hgfedcba(pd) -val_64_arr *pd; +double mb_get_double_hgfedcba(val_64_arr *pd) { return mb_get_double_generic(7, 6, 5, 4, 3, 2, 1, 0, pd); } -uint64_t mb_set_double_hgfedcba(pd, d) -val_64_arr *pd; -double d; +uint64_t mb_set_double_hgfedcba(val_64_arr *pd, double d) { return mb_set_double_generic(7, 6, 5, 4, 3, 2, 1, 0, pd, d); } -double mb_get_double_ghefcdab(pd) -val_64_arr *pd; +double mb_get_double_ghefcdab(val_64_arr *pd) { return mb_get_double_generic(6, 7, 4, 5, 2, 3, 0, 1, pd); } -uint64_t mb_set_double_ghefcdab(pd, d) -val_64_arr *pd; -double d; +uint64_t mb_set_double_ghefcdab(val_64_arr *pd, double d) { return mb_set_double_generic(6, 7, 4, 5, 2, 3, 0, 1, pd, d); } -double mb_get_double_badcfehg(pd) -val_64_arr *pd; +double mb_get_double_badcfehg(val_64_arr *pd) { return mb_get_double_generic(1, 0, 3, 2, 5, 4, 7, 6, pd); } -uint64_t mb_set_double_badcfehg(pd, d) -val_64_arr *pd; -double d; +uint64_t mb_set_double_badcfehg(val_64_arr *pd, double d) { return mb_set_double_generic(1, 0, 3, 2, 5, 4, 7, 6, pd, d); } -int64_t mb_get_int64_abcdefgh(pi64) -val_64_arr *pi64; +int64_t mb_get_int64_abcdefgh(val_64_arr *pi64) { return mb_get_int64_generic(0, 1, 2, 3, 4, 5, 6, 7, pi64); } -uint64_t mb_set_int64_abcdefgh(pi, i) -val_64_arr *pi; -int64_t i; +uint64_t mb_set_int64_abcdefgh(val_64_arr *pi, int64_t i) { return mb_set_int64_generic(0, 1, 2, 3, 4, 5, 6, 7, pi, i); } -int64_t mb_get_int64_hgfedcba(pi64) -val_64_arr *pi64; +int64_t mb_get_int64_hgfedcba(val_64_arr *pi64) { return mb_get_int64_generic(7, 6, 5, 4, 3, 2, 1, 0, pi64); } -uint64_t mb_set_int64_hgfedcba(pi, i) -val_64_arr *pi; -int64_t i; +uint64_t mb_set_int64_hgfedcba(val_64_arr *pi, int64_t i) { return mb_set_int64_generic(7, 6, 5, 4, 3, 2, 1, 0, pi, i); } -int64_t mb_get_int64_ghefcdab(pi64) -val_64_arr *pi64; +int64_t mb_get_int64_ghefcdab(val_64_arr *pi64) { return mb_get_int64_generic(6, 7, 4, 5, 2, 3, 0, 1, pi64); } -uint64_t mb_set_int64_ghefcdab(pi, i) -val_64_arr *pi; -int64_t i; +uint64_t mb_set_int64_ghefcdab(val_64_arr *pi, int64_t i) { return mb_set_int64_generic(6, 7, 4, 5, 2, 3, 0, 1, pi, i); } -int64_t mb_get_int64_badcfehg(pi64) -val_64_arr *pi64; +int64_t mb_get_int64_badcfehg(val_64_arr *pi64) { return mb_get_int64_generic(1, 0, 3, 2, 5, 4, 7, 6, pi64); } -uint64_t mb_set_int64_badcfehg(pi, i) -val_64_arr *pi; -int64_t i; +uint64_t mb_set_int64_badcfehg(val_64_arr *pi, int64_t i) { return mb_set_int64_generic(1, 0, 3, 2, 5, 4, 7, 6, pi, i); } -uint64_t mb_get_uint64_abcdefgh(pui) -val_64_arr *pui; +uint64_t mb_get_uint64_abcdefgh(val_64_arr *pui) { return mb_get_uint64_generic(0, 1, 2, 3, 4, 5, 6, 7, pui); } -uint64_t mb_set_uint64_abcdefgh(pui, ui) -val_64_arr *pui; -uint64_t ui; +uint64_t mb_set_uint64_abcdefgh(val_64_arr *pui, uint64_t ui) { return mb_set_uint64_generic(0, 1, 2, 3, 4, 5, 6, 7, pui, ui); } -uint64_t mb_get_uint64_hgfedcba(pui) -val_64_arr *pui; +uint64_t mb_get_uint64_hgfedcba(val_64_arr *pui) { return mb_get_uint64_generic(7, 6, 5, 4, 3, 2, 1, 0, pui); } -uint64_t mb_set_uint64_hgfedcba(pui, ui) -val_64_arr *pui; -uint64_t ui; +uint64_t mb_set_uint64_hgfedcba(val_64_arr *pui, uint64_t ui) { return mb_set_uint64_generic(7, 6, 5, 4, 3, 2, 1, 0, pui, ui); } -uint64_t mb_get_uint64_ghefcdab(pui) -val_64_arr *pui; +uint64_t mb_get_uint64_ghefcdab(val_64_arr *pui) { return mb_get_uint64_generic(6, 7, 4, 5, 2, 3, 0, 1, pui); } -uint64_t mb_set_uint64_ghefcdab(pui, ui) -val_64_arr *pui; -uint64_t ui; +uint64_t mb_set_uint64_ghefcdab(val_64_arr *pui, uint64_t ui) { return mb_set_uint64_generic(6, 7, 4, 5, 2, 3, 0, 1, pui, ui); } -uint64_t mb_get_uint64_badcfehg(pui) -val_64_arr *pui; +uint64_t mb_get_uint64_badcfehg(val_64_arr *pui) { return mb_get_int64_generic(1, 0, 3, 2, 5, 4, 7, 6, pui); } -uint64_t mb_set_uint64_badcfehg(pui, ui) -val_64_arr *pui; -uint64_t ui; +uint64_t mb_set_uint64_badcfehg(val_64_arr *pui, uint64_t ui) { return mb_set_uint64_generic(1, 0, 3, 2, 5, 4, 7, 6, pui, ui); } diff --git a/modbus/mb_controller/serial/mbc_serial_master.c b/modbus/mb_controller/serial/mbc_serial_master.c index fa42e99..f317a2b 100644 --- a/modbus/mb_controller/serial/mbc_serial_master.c +++ b/modbus/mb_controller/serial/mbc_serial_master.c @@ -184,81 +184,71 @@ static esp_err_t mbc_serial_master_send_request(void *ctx, mb_param_request_t *r #if MB_FUNC_READ_COILS_ENABLED case MB_FUNC_READ_COILS: - mb_error = mbm_rq_read_coils(mbm_controller_iface->mb_base, (uint8_t)mb_slave_addr, (uint16_t)mb_offset, - (uint16_t)mb_size, - pdMS_TO_TICKS(MB_MAX_RESP_DELAY_MS)); + mb_error = mbm_rq_read_coils(mbm_controller_iface->mb_base, mb_slave_addr, mb_offset, + mb_size, pdMS_TO_TICKS(MB_MAX_RESP_DELAY_MS)); break; #endif #if MB_FUNC_WRITE_COIL_ENABLED case MB_FUNC_WRITE_SINGLE_COIL: - mb_error = mbm_rq_write_coil(mbm_controller_iface->mb_base, (uint8_t)mb_slave_addr, (uint16_t)mb_offset, - *(uint16_t *)data_ptr, - pdMS_TO_TICKS(MB_MAX_RESP_DELAY_MS)); + mb_error = mbm_rq_write_coil(mbm_controller_iface->mb_base, mb_slave_addr, mb_offset, + *(uint16_t *)data_ptr, pdMS_TO_TICKS(MB_MAX_RESP_DELAY_MS)); break; #endif #if MB_FUNC_WRITE_MULTIPLE_COILS_ENABLED case MB_FUNC_WRITE_MULTIPLE_COILS: - mb_error = mbm_rq_write_multi_coils(mbm_controller_iface->mb_base, (uint8_t)mb_slave_addr, (uint16_t)mb_offset, - (uint16_t)mb_size, (uint8_t *)data_ptr, - pdMS_TO_TICKS(MB_MAX_RESP_DELAY_MS)); + mb_error = mbm_rq_write_multi_coils(mbm_controller_iface->mb_base, mb_slave_addr, mb_offset, + mb_size, (uint8_t *)data_ptr, pdMS_TO_TICKS(MB_MAX_RESP_DELAY_MS)); break; #endif #if MB_FUNC_READ_DISCRETE_INPUTS_ENABLED case MB_FUNC_READ_DISCRETE_INPUTS: - mb_error = mbm_rq_read_discrete_inputs(mbm_controller_iface->mb_base, (uint8_t)mb_slave_addr, (uint16_t)mb_offset, - (uint16_t)mb_size, - pdMS_TO_TICKS(MB_MAX_RESP_DELAY_MS)); + mb_error = mbm_rq_read_discrete_inputs(mbm_controller_iface->mb_base, mb_slave_addr, mb_offset, + mb_size, pdMS_TO_TICKS(MB_MAX_RESP_DELAY_MS)); break; #endif #if MB_FUNC_READ_HOLDING_ENABLED case MB_FUNC_READ_HOLDING_REGISTER: - mb_error = mbm_rq_read_holding_reg(mbm_controller_iface->mb_base, (uint8_t)mb_slave_addr, (uint16_t)mb_offset, - (uint16_t)mb_size, - pdMS_TO_TICKS(MB_MAX_RESP_DELAY_MS)); + mb_error = mbm_rq_read_holding_reg(mbm_controller_iface->mb_base, mb_slave_addr, mb_offset, + mb_size, pdMS_TO_TICKS(MB_MAX_RESP_DELAY_MS)); break; #endif #if MB_FUNC_WRITE_HOLDING_ENABLED case MB_FUNC_WRITE_REGISTER: - mb_error = mbm_rq_write_holding_reg(mbm_controller_iface->mb_base, (uint8_t)mb_slave_addr, (uint16_t)mb_offset, - *(uint16_t *)data_ptr, - pdMS_TO_TICKS(MB_MAX_RESP_DELAY_MS)); + mb_error = mbm_rq_write_holding_reg(mbm_controller_iface->mb_base, mb_slave_addr, mb_offset, + *(uint16_t *)data_ptr, pdMS_TO_TICKS(MB_MAX_RESP_DELAY_MS)); break; #endif #if MB_FUNC_WRITE_MULTIPLE_HOLDING_ENABLED case MB_FUNC_WRITE_MULTIPLE_REGISTERS: - mb_error = mbm_rq_write_multi_holding_reg(mbm_controller_iface->mb_base, (uint8_t)mb_slave_addr, - (uint16_t)mb_offset, (uint16_t)mb_size, - (uint16_t *)data_ptr, - pdMS_TO_TICKS(MB_MAX_RESP_DELAY_MS)); + mb_error = mbm_rq_write_multi_holding_reg(mbm_controller_iface->mb_base, mb_slave_addr, + mb_offset, mb_size, (uint16_t *)data_ptr, pdMS_TO_TICKS(MB_MAX_RESP_DELAY_MS)); break; #endif #if MB_FUNC_READWRITE_HOLDING_ENABLED case MB_FUNC_READWRITE_MULTIPLE_REGISTERS: - mb_error = mbm_rq_rw_multi_holding_reg(mbm_controller_iface->mb_base, (uint8_t)mb_slave_addr, (uint16_t)mb_offset, - (uint16_t)mb_size, (uint16_t *)data_ptr, - (uint16_t)mb_offset, (uint16_t)mb_size, - pdMS_TO_TICKS(MB_MAX_RESP_DELAY_MS)); + mb_error = mbm_rq_rw_multi_holding_reg(mbm_controller_iface->mb_base, mb_slave_addr, mb_offset, + mb_size, (uint16_t *)data_ptr, + mb_offset, mb_size, pdMS_TO_TICKS(MB_MAX_RESP_DELAY_MS)); break; #endif #if MB_FUNC_READ_INPUT_ENABLED case MB_FUNC_READ_INPUT_REGISTER: - mb_error = mbm_rq_read_inp_reg(mbm_controller_iface->mb_base, (uint8_t)mb_slave_addr, (uint16_t)mb_offset, - (uint16_t)mb_size, - pdMS_TO_TICKS(MB_MAX_RESP_DELAY_MS)); + mb_error = mbm_rq_read_inp_reg(mbm_controller_iface->mb_base, mb_slave_addr, mb_offset, + mb_size, pdMS_TO_TICKS(MB_MAX_RESP_DELAY_MS)); break; #endif default: - mb_fn_handler_fp phandler = NULL; + mb_fn_handler_fp handler = NULL; // check registered function handler - mb_error = mbm_get_handler(mbm_controller_iface->mb_base, mb_command, &phandler); + mb_error = mbm_get_handler(mbm_controller_iface->mb_base, mb_command, &handler); if (mb_error == MB_ENOERR) { // send the request for custom command mb_error = mbm_rq_custom(mbm_controller_iface->mb_base, mb_slave_addr, mb_command, @@ -339,21 +329,21 @@ static esp_err_t mbc_serial_master_get_parameter(void *ctx, uint16_t cid, uint8_ esp_err_t error = ESP_ERR_INVALID_RESPONSE; mb_param_request_t request ; mb_parameter_descriptor_t reg_info = { 0 }; - uint8_t *pdata = NULL; + uint8_t *data_ptr = NULL; error = mbc_serial_master_set_request(ctx, cid, MB_PARAM_READ, &request, ®_info); if ((error == ESP_OK) && (cid == reg_info.cid) && (request.slave_addr != MB_SLAVE_ADDR_PLACEHOLDER)) { MB_MASTER_ASSERT(xPortGetFreeHeapSize() > (reg_info.mb_size << 1)); // alloc buffer to store parameter data - pdata = calloc(1, (reg_info.mb_size << 1)); - if (!pdata) { + data_ptr = calloc(1, (reg_info.mb_size << 1)); + if (!data_ptr) { return ESP_ERR_INVALID_STATE; } - error = mbc_serial_master_send_request(ctx, &request, pdata); + error = mbc_serial_master_send_request(ctx, &request, data_ptr); if (error == ESP_OK) { // If data pointer is NULL then we don't need to set value (it is still in the cache of cid) if (value) { - error = mbc_master_set_param_data((void *)value, (void *)pdata, + error = mbc_master_set_param_data((void *)value, (void *)data_ptr, reg_info.param_type, reg_info.param_size); if (error != ESP_OK) { ESP_LOGE(TAG, "fail to set parameter data."); @@ -367,7 +357,7 @@ static esp_err_t mbc_serial_master_get_parameter(void *ctx, uint16_t cid, uint8_ ESP_LOGD(TAG, "%s: Bad response to get cid(%u) = %s", __FUNCTION__, (unsigned)reg_info.cid, (char *)esp_err_to_name(error)); } - free(pdata); + free(data_ptr); // Set the type of parameter found in the table *type = reg_info.param_type; } else { @@ -386,7 +376,7 @@ static esp_err_t mbc_serial_master_get_parameter_with(void *ctx, uint16_t cid, u esp_err_t error = ESP_ERR_INVALID_RESPONSE; mb_param_request_t request; mb_parameter_descriptor_t reg_info = {0}; - uint8_t *pdata = NULL; + uint8_t *data_ptr = NULL; error = mbc_serial_master_set_request(ctx, cid, MB_PARAM_READ, &request, ®_info); if ((error == ESP_OK) && (cid == reg_info.cid)) @@ -399,17 +389,17 @@ static esp_err_t mbc_serial_master_get_parameter_with(void *ctx, uint16_t cid, u request.slave_addr = uid; // override the UID MB_MASTER_ASSERT(xPortGetFreeHeapSize() > (reg_info.mb_size << 1)); // alloc buffer to store parameter data - pdata = calloc(1, (reg_info.mb_size << 1)); - if (!pdata) { + data_ptr = calloc(1, (reg_info.mb_size << 1)); + if (!data_ptr) { return ESP_ERR_INVALID_STATE; } // Send request to read characteristic data - error = mbc_serial_master_send_request(ctx, &request, pdata); + error = mbc_serial_master_send_request(ctx, &request, data_ptr); if (error == ESP_OK) { // If data pointer is NULL then we don't need to set value (it is still in the cache of cid) if (value_ptr) { - error = mbc_master_set_param_data((void *)value_ptr, (void *)pdata, + error = mbc_master_set_param_data((void *)value_ptr, (void *)data_ptr, reg_info.param_type, reg_info.param_size); if (error != ESP_OK) { ESP_LOGE(TAG, "fail to set parameter data."); @@ -425,7 +415,7 @@ static esp_err_t mbc_serial_master_get_parameter_with(void *ctx, uint16_t cid, u ESP_LOGD(TAG, "%s: Bad response to get cid(%u) = %s", __FUNCTION__, (unsigned)reg_info.cid, (char *)esp_err_to_name(error)); } - free(pdata); + free(data_ptr); // Set the type of parameter found in the table *type = reg_info.param_type; } @@ -446,25 +436,25 @@ static esp_err_t mbc_serial_master_set_parameter(void *ctx, uint16_t cid, uint8_ esp_err_t error = ESP_ERR_INVALID_RESPONSE; mb_param_request_t request ; mb_parameter_descriptor_t reg_info = { 0 }; - uint8_t *pdata = NULL; + uint8_t *data_ptr = NULL; error = mbc_serial_master_set_request(ctx, cid, MB_PARAM_WRITE, &request, ®_info); if ((error == ESP_OK) && (cid == reg_info.cid) && (request.slave_addr != MB_SLAVE_ADDR_PLACEHOLDER)) { MB_MASTER_ASSERT(xPortGetFreeHeapSize() > (reg_info.mb_size << 1)); - pdata = calloc(1, (reg_info.mb_size << 1)); // alloc parameter buffer - if (!pdata) { + data_ptr = calloc(1, (reg_info.mb_size << 1)); // alloc parameter buffer + if (!data_ptr) { return ESP_ERR_INVALID_STATE; } // Transfer value of characteristic into parameter buffer - error = mbc_master_set_param_data((void *)pdata, (void *)value, + error = mbc_master_set_param_data((void *)data_ptr, (void *)value, reg_info.param_type, reg_info.param_size); if (error != ESP_OK) { ESP_LOGE(TAG, "fail to set parameter data."); - free(pdata); + free(data_ptr); return ESP_ERR_INVALID_STATE; } // Send request to write characteristic data - error = mbc_serial_master_send_request(ctx, &request, pdata); + error = mbc_serial_master_send_request(ctx, &request, data_ptr); if (error == ESP_OK) { ESP_LOGD(TAG, "%s: Good response for set cid(%u) = %s", __FUNCTION__, (unsigned)reg_info.cid, (char *)esp_err_to_name(error)); @@ -472,7 +462,7 @@ static esp_err_t mbc_serial_master_set_parameter(void *ctx, uint16_t cid, uint8_ ESP_LOGD(TAG, "%s: Bad response to set cid(%u) = %s", __FUNCTION__, (unsigned)reg_info.cid, (char *)esp_err_to_name(error)); } - free(pdata); + free(data_ptr); // Set the type of parameter found in the table *type = reg_info.param_type; } else { @@ -492,7 +482,7 @@ static esp_err_t mbc_serial_master_set_parameter_with(void *ctx, uint16_t cid, u esp_err_t error = ESP_ERR_INVALID_RESPONSE; mb_param_request_t request; mb_parameter_descriptor_t reg_info = {0}; - uint8_t *pdata = NULL; + uint8_t *data_ptr = NULL; error = mbc_serial_master_set_request(ctx, cid, MB_PARAM_WRITE, &request, ®_info); if ((error == ESP_OK) && (cid == reg_info.cid)) { @@ -503,16 +493,16 @@ static esp_err_t mbc_serial_master_set_parameter_with(void *ctx, uint16_t cid, u } request.slave_addr = uid; // override the UID MB_MASTER_ASSERT(xPortGetFreeHeapSize() > (reg_info.mb_size << 1)); - pdata = calloc(1, (reg_info.mb_size << 1)); // alloc parameter buffer - if (!pdata) { + data_ptr = calloc(1, (reg_info.mb_size << 1)); // alloc parameter buffer + if (!data_ptr) { return ESP_ERR_INVALID_STATE; } // Transfer value of characteristic into parameter buffer - error = mbc_master_set_param_data((void *)pdata, (void *)value_ptr, + error = mbc_master_set_param_data((void *)data_ptr, (void *)value_ptr, reg_info.param_type, reg_info.param_size); if (error != ESP_OK) { ESP_LOGE(TAG, "fail to set parameter data."); - free(pdata); + free(data_ptr); return ESP_ERR_INVALID_STATE; } // Send request to write characteristic data @@ -527,7 +517,7 @@ static esp_err_t mbc_serial_master_set_parameter_with(void *ctx, uint16_t cid, u ESP_LOGD(TAG, "%s: Bad response to set cid(%u) = %s", __FUNCTION__, (unsigned)reg_info.cid, (char *)esp_err_to_name(error)); } - free(pdata); + free(data_ptr); // Set the type of parameter found in the table *type = reg_info.param_type; } @@ -574,6 +564,7 @@ static esp_err_t mbc_serial_master_controller_create(void **ctx) // Initialize interface properties mb_master_options_t *mbm_opts = &mbm_controller_iface->opts; + mbm_opts->task_handle = NULL; // Initialization of active context of the modbus controller mbm_opts->event_group_handle = xEventGroupCreate(); @@ -648,12 +639,12 @@ esp_err_t mbc_serial_master_create(mb_communication_info_t *config, void **ctx) // Initialize Modbus stack using mbcontroller parameters mb_err_enum_t err = MB_EILLSTATE; - void *pinst = (void *)mbm_controller_iface; + void *inst = (void *)mbm_controller_iface; if (pcomm_info->mode == MB_RTU) { #if ( CONFIG_FMB_COMM_MODE_RTU_EN ) - err = mbm_rtu_create(pcomm_info, &pinst); + err = mbm_rtu_create(pcomm_info, &inst); #else ESP_LOGE(TAG, "RTU mode is not enabled in the configuration."); ret = ESP_ERR_NOT_SUPPORTED; @@ -663,7 +654,7 @@ esp_err_t mbc_serial_master_create(mb_communication_info_t *config, void **ctx) else if (pcomm_info->mode == MB_ASCII) { #if ( CONFIG_FMB_COMM_MODE_ASCII_EN ) - err = mbm_ascii_create(pcomm_info, &pinst); + err = mbm_ascii_create(pcomm_info, &inst); #else ESP_LOGE(TAG, "ASCII mode is not enabled in the configuration."); ret = ESP_ERR_NOT_SUPPORTED; @@ -672,7 +663,7 @@ esp_err_t mbc_serial_master_create(mb_communication_info_t *config, void **ctx) } MB_GOTO_ON_FALSE((err == MB_ENOERR), ESP_ERR_INVALID_STATE, error, TAG, "mb object create returns (0x%x).", (int)err); - mbm_controller_iface->mb_base = (mb_base_t *)pinst; + mbm_controller_iface->mb_base = (mb_base_t *)inst; const mb_rw_callbacks_t rw_cbs = { .reg_input_cb = mbc_reg_input_master_cb, diff --git a/modbus/mb_controller/serial/mbc_serial_slave.c b/modbus/mb_controller/serial/mbc_serial_slave.c index 81d40a2..5f43dad 100644 --- a/modbus/mb_controller/serial/mbc_serial_slave.c +++ b/modbus/mb_controller/serial/mbc_serial_slave.c @@ -181,6 +181,7 @@ static esp_err_t mbc_serial_slave_controller_create(void **ctx) mb_slave_options_t *mbs_opts = &mbs_controller_iface->opts; mbs_opts->port_type = MB_PORT_SERIAL_SLAVE; // set interface port type + mbs_opts->task_handle = NULL; // Initialization of active context of the Modbus controller BaseType_t status = 0; @@ -250,13 +251,13 @@ esp_err_t mbc_serial_slave_create(mb_communication_info_t *config, void **ctx) mbs_opts->port_type = MB_PORT_SERIAL_SLAVE; mbs_opts->comm_opts = *config; mb_err_enum_t err = MB_ENOERR; - void *pinst = (void *)mbs_controller_iface; + void *inst = (void *)mbs_controller_iface; // Initialize Modbus stack using mbcontroller parameters if (pcomm_info->mode == MB_RTU) { #if (CONFIG_FMB_COMM_MODE_RTU_EN) - err = mbs_rtu_create(pcomm_info, &pinst); + err = mbs_rtu_create(pcomm_info, &inst); #else ESP_LOGE(TAG, "RTU mode is not enabled in the configuration."); ret = ESP_ERR_NOT_SUPPORTED; @@ -266,7 +267,7 @@ esp_err_t mbc_serial_slave_create(mb_communication_info_t *config, void **ctx) else if (pcomm_info->mode == MB_ASCII) { #if (CONFIG_FMB_COMM_MODE_ASCII_EN) - err = mbs_ascii_create(pcomm_info, &pinst); + err = mbs_ascii_create(pcomm_info, &inst); #else ESP_LOGE(TAG, "ASCII mode is not enabled in the configuration."); ret = ESP_ERR_NOT_SUPPORTED; @@ -275,7 +276,7 @@ esp_err_t mbc_serial_slave_create(mb_communication_info_t *config, void **ctx) } MB_GOTO_ON_FALSE((err == MB_ENOERR), ESP_ERR_INVALID_STATE, error, TAG, "mbs create returns (0x%x).", (int)err); - mbs_controller_iface->mb_base = (mb_base_t *)pinst; + mbs_controller_iface->mb_base = (mb_base_t *)inst; // Configure Modbus read/write callbacks for the base modbus object const mb_rw_callbacks_t rw_cbs = { diff --git a/modbus/mb_controller/tcp/mbc_tcp_master.c b/modbus/mb_controller/tcp/mbc_tcp_master.c index 5f759e6..b8e6798 100644 --- a/modbus/mb_controller/tcp/mbc_tcp_master.c +++ b/modbus/mb_controller/tcp/mbc_tcp_master.c @@ -36,8 +36,6 @@ static const char *TAG = "mbc_tcp.master"; #define MB_TCP_CONNECTION_TOUT pdMS_TO_TICKS(CONFIG_FMB_TCP_CONNECTION_TOUT_SEC * 1000) -//typedef enum _mb_sock_state mb_sock_state_t; - // Modbus event processing task static void modbus_tcp_master_task(void *param) { @@ -135,7 +133,7 @@ static esp_err_t mbc_tcp_master_set_descriptor(void *ctx, const mb_parameter_des MB_RETURN_ON_FALSE((comm_ip_table), ESP_ERR_INVALID_ARG, TAG, "mb ip table address is incorrect."); const mb_parameter_descriptor_t *reg_ptr = descriptor; - mb_uid_info_t *paddr_info = NULL; + mb_uid_info_t *addr_info = NULL; // Go through all items in the table to check all Modbus registers for (int idx = 0; idx < (num_elements); idx++, reg_ptr++) { @@ -149,8 +147,8 @@ static esp_err_t mbc_tcp_master_set_descriptor(void *ctx, const mb_parameter_des } // Is the slave with the UID already in the list? - paddr_info = mbm_port_tcp_get_slave_info(mbm_controller_iface->mb_base->port_obj, reg_ptr->mb_slave_addr, MB_SOCK_STATE_OPENED); - MB_RETURN_ON_FALSE((paddr_info), ESP_ERR_INVALID_ARG, TAG, + addr_info = mbm_port_tcp_get_slave_info(mbm_controller_iface->mb_base->port_obj, reg_ptr->mb_slave_addr, MB_SOCK_STATE_OPENED); + MB_RETURN_ON_FALSE((addr_info), ESP_ERR_INVALID_ARG, TAG, "mb missing IP address configuration for cid #%u, uid=%d.", (unsigned)reg_ptr->cid, (int)reg_ptr->mb_slave_addr); ESP_LOGI(TAG, "mb found config for cid #%d, uid=%d.", (int)reg_ptr->cid, (int)reg_ptr->mb_slave_addr); } @@ -183,15 +181,14 @@ static esp_err_t mbc_tcp_master_send_request(void *ctx, mb_param_request_t *requ switch(mb_command) { #if MB_FUNC_READ_COILS_ENABLED case MB_FUNC_READ_COILS: - mb_error = mbm_rq_read_coils(mbm_controller_iface->mb_base, (uint8_t)mb_slave_addr, (uint16_t)mb_offset, - (uint16_t)mb_size , - pdMS_TO_TICKS(MB_MAX_RESP_DELAY_MS)); + mb_error = mbm_rq_read_coils(mbm_controller_iface->mb_base, mb_slave_addr, + mb_offset, mb_size , pdMS_TO_TICKS(MB_MAX_RESP_DELAY_MS)); break; #endif #if MB_FUNC_WRITE_COIL_ENABLED case MB_FUNC_WRITE_SINGLE_COIL: - mb_error = mbm_rq_write_coil(mbm_controller_iface->mb_base, (uint8_t)mb_slave_addr, (uint16_t)mb_offset, + mb_error = mbm_rq_write_coil(mbm_controller_iface->mb_base, mb_slave_addr, mb_offset, *(uint16_t *)data_ptr, pdMS_TO_TICKS(MB_MAX_RESP_DELAY_MS)); break; @@ -199,31 +196,29 @@ static esp_err_t mbc_tcp_master_send_request(void *ctx, mb_param_request_t *requ #if MB_FUNC_WRITE_MULTIPLE_COILS_ENABLED case MB_FUNC_WRITE_MULTIPLE_COILS: - mb_error = mbm_rq_write_multi_coils(mbm_controller_iface->mb_base, (uint8_t)mb_slave_addr, (uint16_t)mb_offset, - (uint16_t)mb_size, (uint8_t *)data_ptr, + mb_error = mbm_rq_write_multi_coils(mbm_controller_iface->mb_base, mb_slave_addr, mb_offset, + mb_size, (uint8_t *)data_ptr, pdMS_TO_TICKS(MB_MAX_RESP_DELAY_MS)); break; #endif #if MB_FUNC_READ_DISCRETE_INPUTS_ENABLED case MB_FUNC_READ_DISCRETE_INPUTS: - mb_error = mbm_rq_read_discrete_inputs(mbm_controller_iface->mb_base, (uint8_t)mb_slave_addr, (uint16_t)mb_offset, - (uint16_t)mb_size, - pdMS_TO_TICKS(MB_MAX_RESP_DELAY_MS)); + mb_error = mbm_rq_read_discrete_inputs(mbm_controller_iface->mb_base, mb_slave_addr, mb_offset, + mb_size, pdMS_TO_TICKS(MB_MAX_RESP_DELAY_MS)); break; #endif #if MB_FUNC_READ_HOLDING_ENABLED case MB_FUNC_READ_HOLDING_REGISTER: - mb_error = mbm_rq_read_holding_reg(mbm_controller_iface->mb_base, (uint8_t)mb_slave_addr, (uint16_t)mb_offset, - (uint16_t)mb_size, - pdMS_TO_TICKS(MB_MAX_RESP_DELAY_MS)); + mb_error = mbm_rq_read_holding_reg(mbm_controller_iface->mb_base, mb_slave_addr, mb_offset, + mb_size, pdMS_TO_TICKS(MB_MAX_RESP_DELAY_MS)); break; #endif #if MB_FUNC_WRITE_HOLDING_ENABLED case MB_FUNC_WRITE_REGISTER: - mb_error = mbm_rq_write_holding_reg(mbm_controller_iface->mb_base, (uint8_t)mb_slave_addr, (uint16_t)mb_offset, + mb_error = mbm_rq_write_holding_reg(mbm_controller_iface->mb_base, mb_slave_addr, mb_offset, *(uint16_t *)data_ptr, pdMS_TO_TICKS(MB_MAX_RESP_DELAY_MS)); break; @@ -231,33 +226,28 @@ static esp_err_t mbc_tcp_master_send_request(void *ctx, mb_param_request_t *requ #if MB_FUNC_WRITE_MULTIPLE_HOLDING_ENABLED case MB_FUNC_WRITE_MULTIPLE_REGISTERS: - mb_error = mbm_rq_write_multi_holding_reg(mbm_controller_iface->mb_base, (uint8_t)mb_slave_addr, - (uint16_t)mb_offset, (uint16_t)mb_size, - (uint16_t *)data_ptr, - pdMS_TO_TICKS(MB_MAX_RESP_DELAY_MS)); + mb_error = mbm_rq_write_multi_holding_reg(mbm_controller_iface->mb_base, mb_slave_addr, + mb_offset, mb_size, (uint16_t *)data_ptr, pdMS_TO_TICKS(MB_MAX_RESP_DELAY_MS)); break; #endif #if MB_FUNC_READWRITE_HOLDING_ENABLED case MB_FUNC_READWRITE_MULTIPLE_REGISTERS: - mb_error = mbm_rq_rw_multi_holding_reg(mbm_controller_iface->mb_base, (uint8_t)mb_slave_addr, (uint16_t)mb_offset, - (uint16_t)mb_size, (uint16_t *)data_ptr, - (uint16_t)mb_offset, (uint16_t)mb_size, - pdMS_TO_TICKS(MB_MAX_RESP_DELAY_MS)); + mb_error = mbm_rq_rw_multi_holding_reg(mbm_controller_iface->mb_base, mb_slave_addr, mb_offset, + mb_size, (uint16_t *)data_ptr, mb_offset, mb_size, pdMS_TO_TICKS(MB_MAX_RESP_DELAY_MS)); break; #endif #if MB_FUNC_READ_INPUT_ENABLED case MB_FUNC_READ_INPUT_REGISTER: - mb_error = mbm_rq_read_inp_reg(mbm_controller_iface->mb_base, (uint8_t)mb_slave_addr, (uint16_t)mb_offset, - (uint16_t)mb_size, - pdMS_TO_TICKS(MB_MAX_RESP_DELAY_MS)); + mb_error = mbm_rq_read_inp_reg(mbm_controller_iface->mb_base, mb_slave_addr, mb_offset, + mb_size, pdMS_TO_TICKS(MB_MAX_RESP_DELAY_MS)); break; #endif default: - mb_fn_handler_fp phandler = NULL; + mb_fn_handler_fp handler = NULL; // check registered function handler - mb_error = mbm_get_handler(mbm_controller_iface->mb_base, mb_command, &phandler); + mb_error = mbm_get_handler(mbm_controller_iface->mb_base, mb_command, &handler); if (mb_error == MB_ENOERR) { // send the request for custom command mb_error = mbm_rq_custom(mbm_controller_iface->mb_base, mb_slave_addr, mb_command, @@ -334,27 +324,27 @@ static esp_err_t mbc_tcp_master_get_parameter(void *ctx, uint16_t cid, uint8_t * esp_err_t error = ESP_ERR_INVALID_RESPONSE; mb_param_request_t request ; mb_parameter_descriptor_t reg_info = { 0 }; - uint8_t *pdata = NULL; + uint8_t *data_ptr = NULL; error = mbc_tcp_master_set_request(ctx, cid, MB_PARAM_READ, &request, ®_info); if ((error == ESP_OK) && (cid == reg_info.cid) && (request.slave_addr != MB_SLAVE_ADDR_PLACEHOLDER)) { - mb_uid_info_t *paddr_info = mbm_port_tcp_get_slave_info(mbm_controller_iface->mb_base->port_obj, + mb_uid_info_t *addr_info = mbm_port_tcp_get_slave_info(mbm_controller_iface->mb_base->port_obj, request.slave_addr, MB_SOCK_STATE_CONNECTED); - if (!paddr_info) { + if (!addr_info) { ESP_LOGW(TAG, "Try to send request for cid #%u with uid = %d, node is disconnected.", (unsigned)reg_info.cid, (int)request.slave_addr); } MB_MASTER_ASSERT(xPortGetFreeHeapSize() > (reg_info.mb_size << 1)); // alloc buffer to store parameter data - pdata = calloc(1, (reg_info.mb_size << 1)); - if (!pdata) { + data_ptr = calloc(1, (reg_info.mb_size << 1)); + if (!data_ptr) { return ESP_ERR_INVALID_STATE; } - error = mbc_tcp_master_send_request(ctx, &request, pdata); + error = mbc_tcp_master_send_request(ctx, &request, data_ptr); if (error == ESP_OK) { // If data pointer is NULL then we don't need to set value (it is still in the cache of cid) if (value) { - error = mbc_master_set_param_data((void *)value, (void *)pdata, + error = mbc_master_set_param_data((void *)value, (void *)data_ptr, reg_info.param_type, reg_info.param_size); if (error != ESP_OK) { ESP_LOGE(TAG, "fail to set parameter data."); @@ -368,7 +358,7 @@ static esp_err_t mbc_tcp_master_get_parameter(void *ctx, uint16_t cid, uint8_t * ESP_LOGD(TAG, "%s: Bad response to get cid(%u) = %s", __FUNCTION__, (unsigned)reg_info.cid, (char *)esp_err_to_name(error)); } - free(pdata); + free(data_ptr); // Set the type of parameter found in the table *type = reg_info.param_type; } else { @@ -388,14 +378,14 @@ static esp_err_t mbc_tcp_master_get_parameter_with(void *ctx, uint16_t cid, uint esp_err_t error = ESP_ERR_INVALID_RESPONSE; mb_param_request_t request; mb_parameter_descriptor_t reg_info = { 0 }; - uint8_t *pdata = NULL; + uint8_t *data_ptr = NULL; error = mbc_tcp_master_set_request(ctx, cid, MB_PARAM_READ, &request, ®_info); if ((error == ESP_OK) && (cid == reg_info.cid)) { // check that the requested uid is connected (call to port iface) - mb_uid_info_t *paddr_info = mbm_port_tcp_get_slave_info(mbm_controller_iface->mb_base->port_obj, + mb_uid_info_t *addr_info = mbm_port_tcp_get_slave_info(mbm_controller_iface->mb_base->port_obj, uid, MB_SOCK_STATE_CONNECTED); - if (!paddr_info) { + if (!addr_info) { ESP_LOGW(TAG, "Try to send request for cid #%u with uid = %d, node is disconnected.", (unsigned)reg_info.cid, (int)request.slave_addr); } @@ -406,15 +396,15 @@ static esp_err_t mbc_tcp_master_get_parameter_with(void *ctx, uint16_t cid, uint request.slave_addr = uid; // override the UID MB_MASTER_ASSERT(xPortGetFreeHeapSize() > (reg_info.mb_size << 1)); // alloc buffer to store parameter data - pdata = calloc(1, (reg_info.mb_size << 1)); - if (!pdata) { + data_ptr = calloc(1, (reg_info.mb_size << 1)); + if (!data_ptr) { return ESP_ERR_INVALID_STATE; } - error = mbc_tcp_master_send_request(ctx, &request, pdata); + error = mbc_tcp_master_send_request(ctx, &request, data_ptr); if (error == ESP_OK) { // If data pointer is NULL then we don't need to set value (it is still in the cache of cid) if (value) { - error = mbc_master_set_param_data((void *)value, (void *)pdata, + error = mbc_master_set_param_data((void *)value, (void *)data_ptr, reg_info.param_type, reg_info.param_size); if (error != ESP_OK) { ESP_LOGE(TAG, "fail to set parameter data."); @@ -428,7 +418,7 @@ static esp_err_t mbc_tcp_master_get_parameter_with(void *ctx, uint16_t cid, uint ESP_LOGD(TAG, "%s: Bad response to get cid(%u) = %s", __FUNCTION__, (unsigned)reg_info.cid, (char *)esp_err_to_name(error)); } - free(pdata); + free(data_ptr); // Set the type of parameter found in the table *type = reg_info.param_type; } else { @@ -448,31 +438,31 @@ static esp_err_t mbc_tcp_master_set_parameter(void *ctx, uint16_t cid, uint8_t * esp_err_t error = ESP_ERR_INVALID_RESPONSE; mb_param_request_t request ; mb_parameter_descriptor_t reg_info = { 0 }; - uint8_t *pdata = NULL; + uint8_t *data_ptr = NULL; error = mbc_tcp_master_set_request(ctx, cid, MB_PARAM_WRITE, &request, ®_info); if ((error == ESP_OK) && (cid == reg_info.cid) && (request.slave_addr != MB_SLAVE_ADDR_PLACEHOLDER)) { - mb_uid_info_t *paddr_info = mbm_port_tcp_get_slave_info(mbm_controller_iface->mb_base->port_obj, + mb_uid_info_t *addr_info = mbm_port_tcp_get_slave_info(mbm_controller_iface->mb_base->port_obj, request.slave_addr, MB_SOCK_STATE_CONNECTED); - if (!paddr_info) { + if (!addr_info) { ESP_LOGW(TAG, "Try to send request for cid #%u with uid = %d, node is disconnected.", (unsigned)reg_info.cid, (int)request.slave_addr); } MB_MASTER_ASSERT(xPortGetFreeHeapSize() > (reg_info.mb_size << 1)); - pdata = calloc(1, (reg_info.mb_size << 1)); // alloc parameter buffer - if (!pdata) { + data_ptr = calloc(1, (reg_info.mb_size << 1)); // alloc parameter buffer + if (!data_ptr) { return ESP_ERR_INVALID_STATE; } // Transfer value of characteristic into parameter buffer - error = mbc_master_set_param_data((void *)pdata, (void *)value, + error = mbc_master_set_param_data((void *)data_ptr, (void *)value, reg_info.param_type, reg_info.param_size); if (error != ESP_OK) { ESP_LOGE(TAG, "fail to set parameter data."); - free(pdata); + free(data_ptr); return ESP_ERR_INVALID_STATE; } // Send request to write characteristic data - error = mbc_tcp_master_send_request(ctx, &request, pdata); + error = mbc_tcp_master_send_request(ctx, &request, data_ptr); if (error == ESP_OK) { ESP_LOGD(TAG, "%s: Good response for set cid(%u) = %s", __FUNCTION__, (unsigned)reg_info.cid, (char *)esp_err_to_name(error)); @@ -480,7 +470,7 @@ static esp_err_t mbc_tcp_master_set_parameter(void *ctx, uint16_t cid, uint8_t * ESP_LOGD(TAG, "%s: Bad response to set cid(%u) = %s", __FUNCTION__, (unsigned)reg_info.cid, (char *)esp_err_to_name(error)); } - free(pdata); + free(data_ptr); // Set the type of parameter found in the table *type = reg_info.param_type; } else { @@ -500,14 +490,14 @@ static esp_err_t mbc_tcp_master_set_parameter_with(void *ctx, uint16_t cid, uint esp_err_t error = ESP_ERR_INVALID_RESPONSE; mb_param_request_t request ; mb_parameter_descriptor_t reg_info = { 0 }; - uint8_t *pdata = NULL; + uint8_t *data_ptr = NULL; error = mbc_tcp_master_set_request(ctx, cid, MB_PARAM_WRITE, &request, ®_info); if ((error == ESP_OK) && (cid == reg_info.cid)) { // check that the requested uid is connected (call to port iface) - mb_uid_info_t *paddr_info = mbm_port_tcp_get_slave_info(mbm_controller_iface->mb_base->port_obj, + mb_uid_info_t *addr_info = mbm_port_tcp_get_slave_info(mbm_controller_iface->mb_base->port_obj, uid, MB_SOCK_STATE_CONNECTED); - if (!paddr_info) { + if (!addr_info) { ESP_LOGW(TAG, "Try to send request for cid #%u with uid = %d, node is disconnected.", (unsigned)reg_info.cid, (int)request.slave_addr); } @@ -518,20 +508,20 @@ static esp_err_t mbc_tcp_master_set_parameter_with(void *ctx, uint16_t cid, uint request.slave_addr = uid; // override the UID MB_MASTER_ASSERT(xPortGetFreeHeapSize() > (reg_info.mb_size << 1)); - pdata = calloc(1, (reg_info.mb_size << 1)); // alloc parameter buffer - if (!pdata) { + data_ptr = calloc(1, (reg_info.mb_size << 1)); // alloc parameter buffer + if (!data_ptr) { return ESP_ERR_INVALID_STATE; } // Transfer value of characteristic into parameter buffer - error = mbc_master_set_param_data((void *)pdata, (void *)value, + error = mbc_master_set_param_data((void *)data_ptr, (void *)value, reg_info.param_type, reg_info.param_size); if (error != ESP_OK) { ESP_LOGE(TAG, "fail to set parameter data."); - free(pdata); + free(data_ptr); return ESP_ERR_INVALID_STATE; } // Send request to write characteristic data - error = mbc_tcp_master_send_request(ctx, &request, pdata); + error = mbc_tcp_master_send_request(ctx, &request, data_ptr); if (error == ESP_OK) { ESP_LOGD(TAG, "%s: Good response for set cid(%u) = %s", __FUNCTION__, (unsigned)reg_info.cid, (char *)esp_err_to_name(error)); @@ -539,7 +529,7 @@ static esp_err_t mbc_tcp_master_set_parameter_with(void *ctx, uint16_t cid, uint ESP_LOGD(TAG, "%s: Bad response to set cid(%u) = %s", __FUNCTION__, (unsigned)reg_info.cid, (char *)esp_err_to_name(error)); } - free(pdata); + free(data_ptr); // Set the type of parameter found in the table *type = reg_info.param_type; } else { @@ -596,6 +586,7 @@ esp_err_t mbc_tcp_master_controller_create(void ** ctx) // Initialize interface properties mb_master_options_t *mbm_opts = MB_MASTER_GET_OPTS(mbm_controller_iface); + mbm_opts->task_handle = NULL; // Initialization of active context of the modbus controller BaseType_t status = 0; @@ -685,16 +676,16 @@ esp_err_t mbc_tcp_master_create(mb_communication_info_t *config, void **ctx) } mb_err_enum_t err = MB_EILLSTATE; - void *pinst = (void *)mbm_controller_iface; // set as descr.parent object + void *inst = (void *)mbm_controller_iface; // set as descr.parent object // Initialize Modbus stack using mbcontroller parameters if (tcp_opts.mode == MB_TCP) { - err = mbm_tcp_create(&tcp_opts, &pinst); + err = mbm_tcp_create(&tcp_opts, &inst); } MB_GOTO_ON_FALSE((err == MB_ENOERR), ESP_ERR_INVALID_STATE, error, TAG, "mbm create returns (0x%x).", (int)ret); - mbm_controller_iface->mb_base = (mb_base_t *)pinst; + mbm_controller_iface->mb_base = (mb_base_t *)inst; const mb_rw_callbacks_t rw_cbs = { .reg_input_cb = mbc_reg_input_master_cb, @@ -714,7 +705,7 @@ esp_err_t mbc_tcp_master_create(mb_communication_info_t *config, void **ctx) return ESP_OK; error: - if (mbm_controller_iface->mb_base) { + if (mbm_controller_iface && mbm_controller_iface->mb_base) { mbm_controller_iface->mb_base->delete(mbm_controller_iface->mb_base); mbm_controller_iface->mb_base = NULL; } diff --git a/modbus/mb_controller/tcp/mbc_tcp_slave.c b/modbus/mb_controller/tcp/mbc_tcp_slave.c index 01fc611..6b982d0 100644 --- a/modbus/mb_controller/tcp/mbc_tcp_slave.c +++ b/modbus/mb_controller/tcp/mbc_tcp_slave.c @@ -153,6 +153,7 @@ esp_err_t mbc_tcp_slave_controller_create(void ** ctx) mb_slave_options_t *mbs_opts = &mbs_controller_iface->opts; mbs_opts->port_type = MB_PORT_TCP_SLAVE; // set interface port type + mbs_opts->task_handle = NULL; // Initialization of active context of the Modbus controller BaseType_t status = 0; @@ -243,13 +244,13 @@ esp_err_t mbc_tcp_slave_create(mb_communication_info_t *config, void **ctx) mbs_opts->comm_opts.tcp_opts = tcp_opts; mb_err_enum_t err = MB_ENOERR; - void *pinst = (void *)mbs_controller_iface; + void *inst = (void *)mbs_controller_iface; // Initialize Modbus stack using mbcontroller parameters - err = mbs_tcp_create(&tcp_opts, &pinst); + err = mbs_tcp_create(&tcp_opts, &inst); MB_GOTO_ON_FALSE((err == MB_ENOERR), ESP_ERR_INVALID_STATE, error, TAG, "mbscreate returns (0x%x).", (uint16_t)err); - mbs_controller_iface->mb_base = (mb_base_t *)pinst; + mbs_controller_iface->mb_base = (mb_base_t *)inst; mbs_controller_iface->mb_base->descr.is_master = false; // Configure Modbus read/write callbacks for the base modbus object @@ -265,7 +266,7 @@ esp_err_t mbc_tcp_slave_create(mb_communication_info_t *config, void **ctx) return ESP_OK; error: - if (mbs_controller_iface->mb_base) { + if (mbs_controller_iface && mbs_controller_iface->mb_base) { mbs_controller_iface->mb_base->delete(mbs_controller_iface->mb_base); mbs_controller_iface->mb_base = NULL; } diff --git a/modbus/mb_objects/common/mb_port_types.h b/modbus/mb_objects/common/mb_port_types.h index 584da29..6ead915 100644 --- a/modbus/mb_objects/common/mb_port_types.h +++ b/modbus/mb_objects/common/mb_port_types.h @@ -33,7 +33,7 @@ static_assert( #define MB_ATTR_WEAK __attribute__ ((weak)) -typedef enum _mb_comm_mode mb_mode_type_t; +typedef enum mb_comm_mode_enum mb_mode_type_t; #if (CONFIG_FMB_COMM_MODE_ASCII_EN || CONFIG_FMB_COMM_MODE_RTU_EN) @@ -55,7 +55,7 @@ typedef struct port_serial_opts_s mb_serial_opts_t; #endif -typedef enum _addr_type_enum { +typedef enum addr_type_enum { MB_NOIP = 0, MB_IPV4 = 1, /*!< TCP IPV4 addressing */ MB_IPV6 = 2 /*!< TCP IPV6 addressing */ @@ -85,7 +85,7 @@ struct port_tcp_opts_s { typedef struct port_tcp_opts_s mb_tcp_opts_t; // The common object descriptor struture (common for mb, transport, port objects) -struct _obj_descr { +struct obj_descr_s { char *parent_name; /*!< Name of the parent (base) object */ char *obj_name; /*!< Name of the object */ void *parent; /*!< Pointer to the parent (base) object */ @@ -93,9 +93,9 @@ struct _obj_descr { bool is_master; /*!< The current object is master or slave (false) */ }; -typedef struct _obj_descr obj_descr_t; +typedef struct obj_descr_s obj_descr_t; -typedef enum _mb_sock_state { +typedef enum mb_sock_state_enum { MB_SOCK_STATE_UNDEF = 0x0000, /*!< Default init state */ MB_SOCK_STATE_CLOSED, /*!< Node is closed */ MB_SOCK_STATE_READY, /*!< Node is ready for communication */ @@ -106,7 +106,7 @@ typedef enum _mb_sock_state { MB_SOCK_STATE_ACCEPTED /*!< Slave node accepted the connection */ } mb_sock_state_t; -typedef struct _uid_info { +typedef struct uid_info_s { uint16_t index; /*!< index of the address info */ int fd; /*!< node global FD for VFS (reserved) */ char *node_name_str; /*!< node name string (host name of node to resolve) */ diff --git a/modbus/mb_objects/common/mb_types.h b/modbus/mb_objects/common/mb_types.h index 256dd37..a765301 100644 --- a/modbus/mb_objects/common/mb_types.h +++ b/modbus/mb_objects/common/mb_types.h @@ -43,7 +43,7 @@ extern "C" { * a low jitter. ASCII is slower and more reliable on slower links (E.g. modems) * The TCP or UDP mode is used for communication over ethernet. */ -typedef enum _mb_comm_mode +typedef enum mb_comm_mode_enum { MB_RTU, /*!< RTU transmission mode. */ MB_ASCII, /*!< ASCII transmission mode. */ @@ -71,7 +71,7 @@ typedef enum /*! \ingroup modbus * \brief Event types used by all function in the protocol stack. */ -typedef enum _mb_event_enum { +typedef enum mb_event_enum { EV_TRANS_START = 0x0001, /*!< Start of transaction. */ EV_READY = 0x0002, /*!< Startup finished. */ EV_FRAME_RECEIVED = 0x0004, /*!< Frame received. */ @@ -88,7 +88,7 @@ typedef enum _mb_event_enum { /*! \ingroup modbus * \brief Modbus exception types used in the stack. */ -typedef enum _mb_exception_enum +typedef enum mb_exception_enum { MB_EX_NONE = 0x00, MB_EX_ILLEGAL_FUNCTION = 0x01, @@ -108,7 +108,7 @@ typedef mb_exception_t (*mb_fn_handler_fp)(void *, uint8_t *frame_ptr, uint16_t /*! \ingroup modbus * \brief Error event type */ -typedef enum _mb_err_event_enum { +typedef enum mb_err_event_enum { EV_ERROR_INIT, /*!< No error, initial state. */ EV_ERROR_RESPOND_TIMEOUT, /*!< Slave respond timeout. */ EV_ERROR_RECEIVE_DATA, /*!< Receive frame data error. */ @@ -116,11 +116,11 @@ typedef enum _mb_err_event_enum { EV_ERROR_OK /*!< No error, processing completed. */ } mb_err_event_t; -typedef struct _mb_event_t { +typedef struct mb_event_s { mb_event_enum_t event; /*!< event itself. */ uint64_t trans_id; /*!< unique transaction id */ uint16_t length; /*!< length of data accociated with the event */ - void *pdata; /*!< data accociated with the event */ + void *data_ptr; /*!< data accociated with the event */ mb_err_event_t type; /*!< error type accociated with the event */ uint64_t post_ts; /*!< timestamp of event posted */ uint64_t get_ts; /*!< timestamp of event receved */ diff --git a/modbus/mb_objects/functions/mbfunc_handling.c b/modbus/mb_objects/functions/mbfunc_handling.c index 1578331..0df38ad 100644 --- a/modbus/mb_objects/functions/mbfunc_handling.c +++ b/modbus/mb_objects/functions/mbfunc_handling.c @@ -10,50 +10,49 @@ #define MB_IS_VALID_FUNC_CODE(fc) ((fc) >= MB_FUNC_CODE_MIN && (fc) <= MB_FUNC_CODE_MAX) static const char TAG[] __attribute__((unused)) = "MB_FUNC_HANDLING"; -mb_err_enum_t mb_set_handler(handler_descriptor_t *pdescriptor, uint8_t func_code, mb_fn_handler_fp phandler) +mb_err_enum_t mb_set_handler(handler_descriptor_t *descriptor, uint8_t func_code, mb_fn_handler_fp handler) { - MB_RETURN_ON_FALSE((pdescriptor && phandler && pdescriptor->instance), MB_EINVAL, TAG, "invalid arguments."); + MB_RETURN_ON_FALSE((descriptor && handler && descriptor->instance), MB_EINVAL, TAG, "invalid arguments."); MB_RETURN_ON_FALSE(MB_IS_VALID_FUNC_CODE(func_code), MB_EINVAL, TAG, "invalid function code (0x%x)", (int)func_code); - mb_command_entry_t *pitem = NULL; - LIST_FOREACH(pitem, &pdescriptor->head, entries) { - if (pitem && pitem->func_code == func_code) { + mb_command_entry_t *item_ptr = NULL; + LIST_FOREACH(item_ptr, &descriptor->head, entries) { + if (item_ptr && item_ptr->func_code == func_code) { // The handler for the function already exists, rewrite it. - pitem->handler = phandler; - ESP_LOGD(TAG, "Inst: %p, set handler: 0x%x, %p", pdescriptor->instance, pitem->func_code, pitem->handler); + item_ptr->handler = handler; + ESP_LOGD(TAG, "Inst: %p, set handler: 0x%x, %p", descriptor->instance, item_ptr->func_code, item_ptr->handler); return MB_ENOERR; } } // Insert new handler entry into list - if (pdescriptor->count >= MB_FUNC_HANDLERS_MAX) { + if (descriptor->count >= MB_FUNC_HANDLERS_MAX) { return MB_ENORES; - } else { - pdescriptor->count += 1; } - pitem = (mb_command_entry_t *) heap_caps_malloc(sizeof(mb_command_entry_t), MALLOC_CAP_INTERNAL|MALLOC_CAP_8BIT); + descriptor->count += 1; + item_ptr = (mb_command_entry_t *) heap_caps_malloc(sizeof(mb_command_entry_t), MALLOC_CAP_INTERNAL|MALLOC_CAP_8BIT); - MB_RETURN_ON_FALSE(pitem, MB_ENORES, TAG, "mb can not allocate memory for command handler 0x%x.", func_code); - pitem->func_code = func_code; - pitem->handler = phandler; - LIST_INSERT_HEAD(&pdescriptor->head, pitem, entries); - ESP_LOGD(TAG, "Inst: %p, add handler: 0x%x, %p", pdescriptor->instance, pitem->func_code, pitem->handler); + MB_RETURN_ON_FALSE(item_ptr, MB_ENORES, TAG, "mb can not allocate memory for command handler 0x%x.", func_code); + item_ptr->func_code = func_code; + item_ptr->handler = handler; + LIST_INSERT_HEAD(&descriptor->head, item_ptr, entries); + ESP_LOGD(TAG, "Inst: %p, add handler: 0x%x, %p", descriptor->instance, item_ptr->func_code, item_ptr->handler); return MB_ENOERR; } -mb_err_enum_t mb_get_handler(handler_descriptor_t *pdescriptor, uint8_t func_code, mb_fn_handler_fp *phandler) +mb_err_enum_t mb_get_handler(handler_descriptor_t *descriptor, uint8_t func_code, mb_fn_handler_fp *handler) { - MB_RETURN_ON_FALSE((pdescriptor && phandler && pdescriptor->instance), MB_EINVAL, TAG, "invalid arguments."); + MB_RETURN_ON_FALSE((descriptor && handler && descriptor->instance), MB_EINVAL, TAG, "invalid arguments."); MB_RETURN_ON_FALSE(MB_IS_VALID_FUNC_CODE(func_code), MB_EINVAL, TAG, "invalid function code (0x%x)", (int)func_code); - mb_command_entry_t *pitem = NULL; - LIST_FOREACH(pitem, &pdescriptor->head, entries) { - if (pitem && pitem->func_code == func_code) { - *phandler = pitem->handler; - ESP_LOGD(TAG, "Inst: %p, get handler: 0x%x, %p", pdescriptor->instance, pitem->func_code, pitem->handler); + mb_command_entry_t *item_ptr = NULL; + LIST_FOREACH(item_ptr, &descriptor->head, entries) { + if (item_ptr && item_ptr->func_code == func_code) { + *handler = item_ptr->handler; + ESP_LOGD(TAG, "Inst: %p, get handler: 0x%x, %p", descriptor->instance, item_ptr->func_code, item_ptr->handler); return MB_ENOERR; } } @@ -61,25 +60,25 @@ mb_err_enum_t mb_get_handler(handler_descriptor_t *pdescriptor, uint8_t func_cod } // Helper function to get handler -mb_err_enum_t mb_delete_handler(handler_descriptor_t *pdescriptor, uint8_t func_code) +mb_err_enum_t mb_delete_handler(handler_descriptor_t *descriptor, uint8_t func_code) { - MB_RETURN_ON_FALSE((pdescriptor && pdescriptor->instance), MB_EINVAL, TAG, "invalid arguments."); + MB_RETURN_ON_FALSE((descriptor && descriptor->instance), MB_EINVAL, TAG, "invalid arguments."); MB_RETURN_ON_FALSE(MB_IS_VALID_FUNC_CODE(func_code), MB_EINVAL, TAG, "invalid function code (0x%x)", (int)func_code); - if (LIST_EMPTY(&pdescriptor->head)) { + if (LIST_EMPTY(&descriptor->head)) { return MB_EINVAL; } - mb_command_entry_t *pitem = NULL; + mb_command_entry_t *item_ptr = NULL; mb_command_entry_t *ptemp = NULL; - LIST_FOREACH_SAFE(pitem, &pdescriptor->head, entries, ptemp) { - if (pitem && pitem->func_code == func_code) { - ESP_LOGD(TAG, "Inst: %p, remove handler: 0x%x, %p", pdescriptor->instance, pitem->func_code, pitem->handler); - LIST_REMOVE(pitem, entries); - free(pitem); - if (pdescriptor->count) { - pdescriptor->count--; + LIST_FOREACH_SAFE(item_ptr, &descriptor->head, entries, ptemp) { + if (item_ptr && item_ptr->func_code == func_code) { + ESP_LOGD(TAG, "Inst: %p, remove handler: 0x%x, %p", descriptor->instance, item_ptr->func_code, item_ptr->handler); + LIST_REMOVE(item_ptr, entries); + free(item_ptr); + if (descriptor->count) { + descriptor->count--; } return MB_ENOERR; } @@ -89,21 +88,21 @@ mb_err_enum_t mb_delete_handler(handler_descriptor_t *pdescriptor, uint8_t func_ } // Helper function to close all registered handlers in the list -mb_err_enum_t mb_delete_command_handlers(handler_descriptor_t *pdescriptor) +mb_err_enum_t mb_delete_command_handlers(handler_descriptor_t *descriptor) { - MB_RETURN_ON_FALSE((pdescriptor), MB_EINVAL, TAG, "invalid arguments."); + MB_RETURN_ON_FALSE((descriptor), MB_EINVAL, TAG, "invalid arguments."); - if (LIST_EMPTY(&pdescriptor->head)) { + if (LIST_EMPTY(&descriptor->head)) { return MB_EINVAL; } - mb_command_entry_t *pitem = NULL; - while ((pitem = LIST_FIRST(&pdescriptor->head))) { - ESP_LOGD(TAG, "Inst: %p, close handler: 0x%x, %p", pdescriptor->instance, pitem->func_code, pitem->handler); - LIST_REMOVE(pitem, entries); - free(pitem); - if (pdescriptor->count) { - pdescriptor->count--; + mb_command_entry_t *item_ptr = NULL; + while ((item_ptr = LIST_FIRST(&descriptor->head))) { + ESP_LOGD(TAG, "Inst: %p, close handler: 0x%x, %p", descriptor->instance, item_ptr->func_code, item_ptr->handler); + LIST_REMOVE(item_ptr, entries); + free(item_ptr); + if (descriptor->count) { + descriptor->count--; } } return MB_ENOERR; diff --git a/modbus/mb_objects/functions/mbfuncother.c b/modbus/mb_objects/functions/mbfuncother.c index 0c4b500..9f21c19 100644 --- a/modbus/mb_objects/functions/mbfuncother.c +++ b/modbus/mb_objects/functions/mbfuncother.c @@ -96,18 +96,18 @@ mb_err_enum_t mbm_rq_report_slave_id(mb_base_t *inst, uint8_t slave_addr, uint32 return err; } -mb_exception_t mbm_fn_report_slave_id(mb_base_t *inst, uint8_t *pframe, uint16_t *plen) +mb_exception_t mbm_fn_report_slave_id(mb_base_t *inst, uint8_t *frame, uint16_t *len) { uint8_t byte_count = 0; mb_exception_t status = MB_EX_NONE; mb_err_enum_t err; - if (!inst || !plen || !pframe) { + if (!inst || !len || !frame) { status = MB_EX_SLAVE_DEVICE_FAILURE; - } else if (*plen <= MB_BUFFER_SIZE - 2) { - byte_count = pframe[MB_PDU_BYTECNT_OFF]; + } else if (*len <= MB_BUFFER_SIZE - 2) { + byte_count = frame[MB_PDU_BYTECNT_OFF]; // Transfer data from command buffer. - err = mbc_reg_common_cb(inst, &pframe[MB_PDU_FUNC_DATA_OFF], 0, byte_count); + err = mbc_reg_common_cb(inst, &frame[MB_PDU_FUNC_DATA_OFF], 0, byte_count); // If an err occured convert it into a Modbus exception. if (err != MB_ENOERR) { status = mb_error_to_exception(err); @@ -119,19 +119,19 @@ mb_exception_t mbm_fn_report_slave_id(mb_base_t *inst, uint8_t *pframe, uint16_t return status; } -mb_exception_t mbs_fn_report_slave_id(mb_base_t *inst, uint8_t *pframe, uint16_t *plen_buf) +mb_exception_t mbs_fn_report_slave_id(mb_base_t *inst, uint8_t *frame, uint16_t *len_buf) { mb_exception_t status = MB_EX_NONE; - if (!inst || !pframe || !plen_buf || !inst->pobj_id || !inst->obj_id_len) { + if (!inst || !frame || !len_buf || !inst->obj_id || !inst->obj_id_len) { status = MB_EX_SLAVE_DEVICE_FAILURE; } else if ((inst->obj_id_len <= MB_BUFFER_SIZE - 2) - && (*plen_buf == MB_CMD_SL_ID_LEN)) { + && (*len_buf == MB_CMD_SL_ID_LEN)) { CRITICAL_SECTION(inst->lock) { - pframe[MB_PDU_FUNC_OFF] = MB_FUNC_OTHER_REPORT_SLAVEID; // rewrite the FC - *plen_buf = (uint16_t)(inst->obj_id_len); - pframe[MB_PDU_BYTECNT_OFF] = *plen_buf; - memcpy(&pframe[MB_PDU_FUNC_DATA_OFF], inst->pobj_id, (size_t)inst->obj_id_len); - *plen_buf += 2; // count function code + length in frame length + frame[MB_PDU_FUNC_OFF] = MB_FUNC_OTHER_REPORT_SLAVEID; // rewrite the FC + *len_buf = inst->obj_id_len; + frame[MB_PDU_BYTECNT_OFF] = *len_buf; + memcpy(&frame[MB_PDU_FUNC_DATA_OFF], inst->obj_id, (size_t)inst->obj_id_len); + *len_buf += 2; // count function code + length in frame length } } else { status = MB_EX_ILLEGAL_DATA_VALUE; @@ -139,7 +139,7 @@ mb_exception_t mbs_fn_report_slave_id(mb_base_t *inst, uint8_t *pframe, uint16_t return status; } -mb_err_enum_t mbs_set_slave_id(mb_base_t *inst, uint8_t slave_id, bool is_running, uint8_t const *pdata, uint8_t data_len) +mb_err_enum_t mbs_set_slave_id(mb_base_t *inst, uint8_t slave_id, bool is_running, uint8_t const *data_ptr, uint8_t data_len) { mb_err_enum_t status = MB_ENOERR; // the first byte and second byte in the buffer is reserved for @@ -147,20 +147,20 @@ mb_err_enum_t mbs_set_slave_id(mb_base_t *inst, uint8_t slave_id, bool is_runnin // the buffer is available for additional data. if (inst && inst->lock && (data_len + 2 <= MB_FUNC_OTHER_REP_SLAVEID_BUF)) { uint8_t chunk_num = ((data_len + 2) / MB_SLAVE_ID_CHUNK_SIZE) + 1; - if (!inst->pobj_id || inst->obj_id_chunks != chunk_num) { + if (!inst->obj_id || inst->obj_id_chunks != chunk_num) { CRITICAL_SECTION(inst->lock) { - inst->pobj_id = realloc(inst->pobj_id, (chunk_num * MB_SLAVE_ID_CHUNK_SIZE)); + inst->obj_id = realloc(inst->obj_id, (chunk_num * MB_SLAVE_ID_CHUNK_SIZE)); } } - if (!inst->pobj_id) { + if (!inst->obj_id) { return MB_ENORES; } CRITICAL_SECTION(inst->lock) { inst->obj_id_len = 0; - inst->pobj_id[inst->obj_id_len++] = slave_id; - inst->pobj_id[inst->obj_id_len++] = (uint8_t)(is_running ? 0xFF : 0x00); + inst->obj_id[inst->obj_id_len++] = slave_id; + inst->obj_id[inst->obj_id_len++] = (uint8_t)(is_running ? 0xFF : 0x00); if (data_len > 0) { - memcpy(&inst->pobj_id[inst->obj_id_len], pdata, (size_t)data_len); + memcpy(&inst->obj_id[inst->obj_id_len], data_ptr, (size_t)data_len); inst->obj_id_len += data_len; inst->obj_id_chunks = chunk_num; } @@ -171,21 +171,21 @@ mb_err_enum_t mbs_set_slave_id(mb_base_t *inst, uint8_t slave_id, bool is_runnin return status; } -mb_err_enum_t mbs_get_slave_id(mb_base_t *inst, uint8_t *pdata, uint8_t *pdata_len) +mb_err_enum_t mbs_get_slave_id(mb_base_t *inst, uint8_t *data_ptr, uint8_t *data_len) { mb_err_enum_t status = MB_ENOERR; - if (inst && inst->lock && pdata_len) { - if (!inst->pobj_id) { + if (inst && inst->lock && data_len) { + if (!inst->obj_id) { return MB_ENOREG; } - if (pdata && (*pdata_len >= inst->obj_id_len)) { + if (data_ptr && (*data_len >= inst->obj_id_len)) { CRITICAL_SECTION(inst->lock) { - memcpy(pdata, &inst->pobj_id[0],(size_t)inst->obj_id_len); + memcpy(data_ptr, &inst->obj_id[0],(size_t)inst->obj_id_len); } } else { status = MB_ENORES; } - *pdata_len = inst->obj_id_len; + *data_len = inst->obj_id_len; } else { status = MB_EINVAL; } diff --git a/modbus/mb_objects/include/mb_callbacks.h b/modbus/mb_objects/include/mb_callbacks.h index f76debf..04baee0 100644 --- a/modbus/mb_objects/include/mb_callbacks.h +++ b/modbus/mb_objects/include/mb_callbacks.h @@ -18,7 +18,7 @@ typedef mb_err_enum_t (*reg_holding_cb_fp)(mb_base_t *inst, uint8_t *reg_buff, u typedef mb_err_enum_t (*reg_coils_cb_fp)(mb_base_t *inst, uint8_t *reg_buff, uint16_t reg_addr, uint16_t coil_num, mb_reg_mode_enum_t mode); typedef mb_err_enum_t (*reg_discrete_cb_fp)(mb_base_t *inst, uint8_t *reg_buff, uint16_t reg_addr, uint16_t disc_num); -typedef struct _mb_rw_callbacks { +typedef struct mb_rw_callbacks_s { reg_input_cb_fp reg_input_cb; reg_holding_cb_fp reg_holding_cb; reg_coils_cb_fp reg_coils_cb; diff --git a/modbus/mb_objects/include/mb_common.h b/modbus/mb_objects/include/mb_common.h index e8f1c42..fe3fa47 100644 --- a/modbus/mb_objects/include/mb_common.h +++ b/modbus/mb_objects/include/mb_common.h @@ -68,43 +68,41 @@ extern "C" { #define SEMA_SECTION(sema, tout) for (int st = (int)xSemaphoreTake(sema, tout); (st > 0); xSemaphoreGive(sema), st = -1) -#define MB_STR_CAT(pref, message) (__extension__( \ -{ \ - char buf##__FUNCTION__##__LINE__[MB_CAT_BUF_SIZE]; \ - strncpy(&(buf##__FUNCTION__##__LINE__)[0], pref, (MB_CAT_BUF_SIZE - 1)); \ - strncat((buf##__FUNCTION__##__LINE__), message, (MB_CAT_BUF_SIZE - 1)); \ - (&((buf##__FUNCTION__##__LINE__)[0])); \ -} \ +#define MB_PRT_BUF(pref, message, buffer, length, level) (__extension__( \ +{ \ + assert(buffer); \ + char str_buf##__FUNCTION__##__LINE__[MB_CAT_BUF_SIZE]; \ + strncpy(&(str_buf##__FUNCTION__##__LINE__)[0], pref, (MB_CAT_BUF_SIZE - 1)); \ + strncat((str_buf##__FUNCTION__##__LINE__), message, (MB_CAT_BUF_SIZE - 1)); \ + ESP_LOG_BUFFER_HEX_LEVEL(&((str_buf##__FUNCTION__##__LINE__)[0]), \ + (void *)buffer, (uint16_t)length, level); \ + (&((str_buf##__FUNCTION__##__LINE__)[0])); \ +} \ )) #define MB_OBJ_FMT "%p" -#define MB_GET_OBJ_CTX(pinst, type, base) (__extension__( \ +#define MB_GET_OBJ_CTX(inst, type, base) (__extension__( \ { \ - assert(pinst); \ - ((type *)__containerof(pinst, type, base)); \ + assert(inst); \ + ((type *)__containerof(inst, type, base)); \ } \ )) -#define MB_OBJ(pinst) (__extension__( \ +#define MB_OBJ(inst) (__extension__( \ { \ - assert(pinst); \ - ((typeof(pinst))(pinst)); \ + assert(inst); \ + ((typeof(inst))(inst)); \ } \ )) -#define MB_OBJ_PARENT(pinst) (__extension__( \ -{ \ - assert(pinst); \ - (((obj_descr_t*)(pinst))->parent); \ -} \ -)) +#define MB_OBJ_PARENT(inst) (((obj_descr_t*)(inst))->parent) -#define MB_BASE2PORT(pinst) (__extension__( \ +#define MB_BASE2PORT(inst) (__extension__( \ { \ - assert(pinst); \ - assert(((mb_base_t *)pinst)->port_obj); \ - (((mb_base_t *)pinst)->port_obj); \ + assert(inst); \ + assert(((mb_base_t *)inst)->port_obj); \ + (((mb_base_t *)inst)->port_obj); \ } \ )) @@ -129,7 +127,7 @@ typedef struct mb_handler_descriptor_s { typedef struct mb_base_t mb_base_t; typedef struct mb_trans_base_t mb_trans_base_t; typedef struct mb_port_base_t mb_port_base_t; -typedef struct _obj_descr obj_descr_t; +typedef struct obj_descr_s obj_descr_t; typedef mb_err_enum_t (*mb_delete_fp)(mb_base_t *inst); typedef mb_err_enum_t (*mb_enable_fp)(mb_base_t *inst); @@ -139,7 +137,7 @@ typedef void (*mb_set_addr_fp)(mb_base_t *inst, uint8_t dest_addr); typedef uint8_t (*mb_get_addr_fp)(mb_base_t *inst); typedef void (*mb_set_send_len_fp)(mb_base_t *inst, uint16_t len); typedef uint16_t (*mb_get_send_len_fp)(mb_base_t *inst); -typedef void (*mb_get_send_buf_fp)(mb_base_t *inst, uint8_t **pbuf); +typedef void (*mb_get_send_buf_fp)(mb_base_t *inst, uint8_t **buf); typedef enum { @@ -156,7 +154,7 @@ struct mb_base_t mb_port_base_t *port_obj; #if MB_FUNC_OTHER_REP_SLAVEID_ENABLED - uint8_t *pobj_id; + uint8_t *obj_id; uint16_t obj_id_len; uint8_t obj_id_chunks; #endif @@ -175,10 +173,10 @@ struct mb_base_t }; // Helper functions for command handlers registration -mb_err_enum_t mb_set_handler(handler_descriptor_t *pdescriptor, uint8_t func_code, mb_fn_handler_fp phandler); -mb_err_enum_t mb_get_handler(handler_descriptor_t *pdescriptor, uint8_t func_code, mb_fn_handler_fp *phandler); -mb_err_enum_t mb_delete_handler(handler_descriptor_t *pdescriptor, uint8_t func_code); -mb_err_enum_t mb_delete_command_handlers(handler_descriptor_t *pdescriptor); +mb_err_enum_t mb_set_handler(handler_descriptor_t *descriptor, uint8_t func_code, mb_fn_handler_fp handler); +mb_err_enum_t mb_get_handler(handler_descriptor_t *descriptor, uint8_t func_code, mb_fn_handler_fp *handler); +mb_err_enum_t mb_delete_handler(handler_descriptor_t *descriptor, uint8_t func_code); +mb_err_enum_t mb_delete_command_handlers(handler_descriptor_t *descriptor); #if (CONFIG_FMB_COMM_MODE_ASCII_EN || CONFIG_FMB_COMM_MODE_RTU_EN) diff --git a/modbus/mb_objects/include/mb_func.h b/modbus/mb_objects/include/mb_func.h index 7f48f30..8784a4a 100644 --- a/modbus/mb_objects/include/mb_func.h +++ b/modbus/mb_objects/include/mb_func.h @@ -18,8 +18,8 @@ extern "C" { typedef struct mb_base_t mb_base_t; #if MB_FUNC_OTHER_REP_SLAVEID_ENABLED -mb_exception_t mbs_fn_report_slave_id(mb_base_t *inst, uint8_t *frame_ptr,uint16_t *len_buf); -mb_exception_t mbm_fn_report_slave_id(mb_base_t *inst, uint8_t *frame_ptr,uint16_t *len_buf); +mb_exception_t mbs_fn_report_slave_id(mb_base_t *inst, uint8_t *frame, uint16_t *len_buf); +mb_exception_t mbm_fn_report_slave_id(mb_base_t *inst, uint8_t *frame, uint16_t *len); #endif #if MB_FUNC_READ_INPUT_ENABLED diff --git a/modbus/mb_objects/include/mb_master.h b/modbus/mb_objects/include/mb_master.h index 51d5ca4..c52b196 100644 --- a/modbus/mb_objects/include/mb_master.h +++ b/modbus/mb_objects/include/mb_master.h @@ -14,7 +14,7 @@ typedef struct mb_base_t mb_base_t; /*!< Type of modbus object */ mb_err_enum_t mbm_rq_read_inp_reg(mb_base_t *inst, uint8_t snd_addr, uint16_t reg_addr, uint16_t reg_num, uint32_t tout); mb_err_enum_t mbm_rq_write_holding_reg(mb_base_t *inst, uint8_t snd_addr, uint16_t reg_addr, uint16_t reg_data, uint32_t tout); -mb_err_enum_t mbm_rq_write_multi_holding_reg(mb_base_t *inst, uint8_t snd_addr, uint16_t reg_addr, uint16_t reg_wr_addr, uint16_t *data_ptr, uint32_t tout); +mb_err_enum_t mbm_rq_write_multi_holding_reg(mb_base_t *inst, uint8_t snd_addr, uint16_t reg_addr, uint16_t reg_num, uint16_t *data_ptr, uint32_t tout); mb_err_enum_t mbm_rq_read_holding_reg(mb_base_t *inst, uint8_t snd_addr, uint16_t reg_addr, uint16_t reg_num, uint32_t tout); mb_err_enum_t mbm_rq_rw_multi_holding_reg(mb_base_t *inst, uint8_t snd_addr, uint16_t rd_reg_addr, uint16_t rd_reg_num, uint16_t *data_ptr, uint16_t wr_reg_addr, uint16_t wr_reg_num, uint32_t tout); @@ -26,12 +26,12 @@ mb_err_enum_t mbm_rq_custom(mb_base_t *inst, uint8_t uid, uint8_t fc, uint8_t *b #if MB_FUNC_OTHER_REP_SLAVEID_ENABLED mb_err_enum_t mbm_rq_report_slave_id(mb_base_t *inst, uint8_t slave_addr, uint32_t timeout); -mb_exception_t mbm_fn_report_slave_id(mb_base_t *inst, uint8_t * pframe, uint16_t *usLen); +mb_exception_t mbm_fn_report_slave_id(mb_base_t *inst, uint8_t * frame, uint16_t *len); /*! \ingroup modbus_registers * \brief The common callback function used to transfer common data as bytes from command buffer in little endian format. * - * \param pdata A pointer to data in command buffer to be transferred. + * \param data_ptr A pointer to data in command buffer to be transferred. * \param address Unused for this function == 0. * \param bytes Number of bytes the callback function must supply. * @@ -42,20 +42,20 @@ mb_exception_t mbm_fn_report_slave_id(mb_base_t *inst, uint8_t * pframe, uint16_ * - mb_err_enum_t::MB_EILLSTATE if can not procceed with data transfer due to critical error * - mb_err_enum_t::MB_EINVAL if value data can not be transferred */ -mb_err_enum_t mbc_reg_common_cb(mb_base_t *inst, uint8_t *pdata, uint16_t address, uint16_t bytes); +mb_err_enum_t mbc_reg_common_cb(mb_base_t *inst, uint8_t *data_ptr, uint16_t address, uint16_t bytes); #endif // The function to register custom function handler for master -mb_err_enum_t mbm_set_handler(mb_base_t *inst, uint8_t func_code, mb_fn_handler_fp phandler); +mb_err_enum_t mbm_set_handler(mb_base_t *inst, uint8_t func_code, mb_fn_handler_fp handler); // The helper function to get custom function handler for master -mb_err_enum_t mbm_get_handler(mb_base_t *inst, uint8_t func_code, mb_fn_handler_fp *phandler); +mb_err_enum_t mbm_get_handler(mb_base_t *inst, uint8_t func_code, mb_fn_handler_fp *handler); // The helper function to delete custom function handler for master mb_err_enum_t mbm_delete_handler(mb_base_t *inst, uint8_t func_code); // The helper function to get count of handlers for master -mb_err_enum_t mbm_get_handler_count(mb_base_t *inst, uint16_t *pcount); +mb_err_enum_t mbm_get_handler_count(mb_base_t *inst, uint16_t *count); #ifdef __cplusplus } diff --git a/modbus/mb_objects/include/mb_proto.h b/modbus/mb_objects/include/mb_proto.h index 43c6cd6..680130e 100644 --- a/modbus/mb_objects/include/mb_proto.h +++ b/modbus/mb_objects/include/mb_proto.h @@ -17,7 +17,7 @@ extern "C" { #define MB_ADDRESS_MIN ( 1 ) /*! Smallest possible slave address. */ #define MB_ADDRESS_MAX ( 247 ) /*! Biggest possible slave address. */ -typedef enum _mb_commands_enum +typedef enum mb_commands_enum { MB_FUNC_NONE = ( 0 ), MB_FUNC_READ_COILS = ( 1 ), diff --git a/modbus/mb_objects/include/mb_slave.h b/modbus/mb_objects/include/mb_slave.h index b01154a..45a0e3a 100644 --- a/modbus/mb_objects/include/mb_slave.h +++ b/modbus/mb_objects/include/mb_slave.h @@ -12,20 +12,20 @@ extern "C" { #endif #if MB_FUNC_OTHER_REP_SLAVEID_ENABLED -mb_exception_t mbs_fn_report_slave_id(mb_base_t *inst, uint8_t *frame_ptr, uint16_t *plen_buf); +mb_exception_t mbs_fn_report_slave_id(mb_base_t *inst, uint8_t *frame, uint16_t *len_buf); #endif // The helper function to register custom function handler for slave -mb_err_enum_t mbs_set_handler(mb_base_t *inst, uint8_t func_code, mb_fn_handler_fp phandler); +mb_err_enum_t mbs_set_handler(mb_base_t *inst, uint8_t func_code, mb_fn_handler_fp handler); // The helper function to get custom function handler for slave -mb_err_enum_t mbs_get_handler(mb_base_t *inst, uint8_t func_code, mb_fn_handler_fp *phandler); +mb_err_enum_t mbs_get_handler(mb_base_t *inst, uint8_t func_code, mb_fn_handler_fp *handler); // The helper function to delete custom function handler for slave mb_err_enum_t mbs_delete_handler(mb_base_t *inst, uint8_t func_code); // The helper function to get count of handlers for slave -mb_err_enum_t mbs_get_handler_count(mb_base_t *inst, uint16_t *pcount); +mb_err_enum_t mbs_get_handler_count(mb_base_t *inst, uint16_t *count); #ifdef __cplusplus } diff --git a/modbus/mb_objects/include/mb_utils.h b/modbus/mb_objects/include/mb_utils.h index 497309d..6b52395 100644 --- a/modbus/mb_objects/include/mb_utils.h +++ b/modbus/mb_objects/include/mb_utils.h @@ -109,13 +109,13 @@ uint8_t mb_util_get_bits(uint8_t *byte_buf, uint16_t bit_offset, uint8_t but_num * \param inst - instance pointer to base modbus object * \param slave_id - slave short address. * \param is_running - true, if the slave is running, false otherwise - * \param pdata - the pointer to slave ID array to set in the modbus object + * \param data_ptr - the pointer to slave ID array to set in the modbus object * \param len - slave ID array length * * returns the modbus error code = MB_ENOERR, if set correctly, MB_ENOREG, otherwise * \endcode */ -mb_err_enum_t mbs_set_slave_id(mb_base_t *inst, uint8_t sl_id, bool is_running, uint8_t const *pdata, uint16_t len); +mb_err_enum_t mbs_set_slave_id(mb_base_t *inst, uint8_t sl_id, bool is_running, uint8_t const *data_ptr, uint16_t len); /*! \brief Standard function to get slave ID from the modbus object. * @@ -123,15 +123,15 @@ mb_err_enum_t mbs_set_slave_id(mb_base_t *inst, uint8_t sl_id, bool is_running, * This ID can then be read over Modbus. * * \param inst - instance pointer to base modbus object - * \param pdata - the pointer to store object ID array from the modbus object - * \param[in/out] pdata_len - input length of the allocated pdata array, + * \param data_ptr - the pointer to store object ID array from the modbus object + * \param[in/out] data_len - input length of the allocated data_ptr array, * returns the actual length of object id. * returns the modbus error code = MB_ENOERR, if set correctly, * MB_ENOREG - if the object ID is not set, - * MB_ENORES - no space to store object ID in the pdata buffer, + * MB_ENORES - no space to store object ID in the data_ptr buffer, * MB_EINVAL - the arguments are not correct */ -mb_err_enum_t mbs_get_slave_id(mb_base_t *inst, uint8_t *pdata, uint8_t *pdata_len); +mb_err_enum_t mbs_get_slave_id(mb_base_t *inst, uint8_t *data_ptr, uint8_t *data_len); #endif #ifdef __cplusplus diff --git a/modbus/mb_objects/mb_master.c b/modbus/mb_objects/mb_master.c index 04d3690..c399ee6 100644 --- a/modbus/mb_objects/mb_master.c +++ b/modbus/mb_objects/mb_master.c @@ -53,26 +53,26 @@ static void mbm_set_pdu_send_length(mb_base_t *inst, uint16_t length); static uint16_t mbm_get_pdu_send_length(mb_base_t *inst); static void mbm_set_dest_addr(mb_base_t *inst, uint8_t dest_addr); static uint8_t mbm_get_dest_addr(mb_base_t *inst); -static void mbm_get_pdu_send_buf(mb_base_t *inst, uint8_t **pbuf); +static void mbm_get_pdu_send_buf(mb_base_t *inst, uint8_t **buf); -mb_err_enum_t mbm_set_handler(mb_base_t *inst, uint8_t func_code, mb_fn_handler_fp phandler) +mb_err_enum_t mbm_set_handler(mb_base_t *inst, uint8_t func_code, mb_fn_handler_fp handler) { mbm_object_t *mbm_obj = MB_GET_OBJ_CTX(inst, mbm_object_t, base); mb_err_enum_t status = MB_EILLSTATE; SEMA_SECTION(mbm_obj->handler_descriptor.sema, MB_HANDLER_UNLOCK_TICKS) { - status = mb_set_handler(&mbm_obj->handler_descriptor, func_code, phandler); + status = mb_set_handler(&mbm_obj->handler_descriptor, func_code, handler); } return status; } // The helper function to register custom function handler for master -mb_err_enum_t mbm_get_handler(mb_base_t *inst, uint8_t func_code, mb_fn_handler_fp *phandler) +mb_err_enum_t mbm_get_handler(mb_base_t *inst, uint8_t func_code, mb_fn_handler_fp *handler) { mbm_object_t *mbm_obj = MB_GET_OBJ_CTX(inst, mbm_object_t, base); mb_err_enum_t status = MB_EILLSTATE; - if (phandler) { + if (handler) { SEMA_SECTION(mbm_obj->handler_descriptor.sema, MB_HANDLER_UNLOCK_TICKS) { - status = mb_get_handler(&mbm_obj->handler_descriptor, func_code, phandler); + status = mb_get_handler(&mbm_obj->handler_descriptor, func_code, handler); } } return status; @@ -88,32 +88,32 @@ mb_err_enum_t mbm_delete_handler(mb_base_t *inst, uint8_t func_code) return status; } -mb_err_enum_t mbm_get_handler_count(mb_base_t *inst, uint16_t *pcount) +mb_err_enum_t mbm_get_handler_count(mb_base_t *inst, uint16_t *count) { - MB_RETURN_ON_FALSE((pcount && inst), MB_EINVAL, TAG, "get handler count wrong arguments."); + MB_RETURN_ON_FALSE((count && inst), MB_EINVAL, TAG, "get handler count wrong arguments."); mbm_object_t *mbm_obj = MB_GET_OBJ_CTX(inst, mbm_object_t, base); SEMA_SECTION(mbm_obj->handler_descriptor.sema, MB_HANDLER_UNLOCK_TICKS) { - *pcount = mbm_obj->handler_descriptor.count; + *count = mbm_obj->handler_descriptor.count; } return MB_ENOERR; } -static mb_err_enum_t mbm_check_invoke_handler(mb_base_t *inst, uint8_t func_code, uint8_t *pbuf, uint16_t *plen) +static mb_err_enum_t mbm_check_invoke_handler(mb_base_t *inst, uint8_t func_code, uint8_t *buf, uint16_t *len) { mbm_object_t *mbm_obj = MB_GET_OBJ_CTX(inst, mbm_object_t, base); mb_exception_t exception = MB_EX_ILLEGAL_FUNCTION; - if (!func_code || !pbuf) { + if (!func_code || !buf) { return MB_EX_ILLEGAL_FUNCTION; } if (func_code & MB_FUNC_ERROR) { - exception = (mb_exception_t)pbuf[MB_PDU_DATA_OFF]; + exception = (mb_exception_t)buf[MB_PDU_DATA_OFF]; return exception; } SEMA_SECTION(mbm_obj->handler_descriptor.sema, MB_HANDLER_UNLOCK_TICKS) { - mb_fn_handler_fp phandler = NULL; - mb_err_enum_t status = mb_get_handler(&mbm_obj->handler_descriptor, func_code, &phandler); - if ((status == MB_ENOERR) && phandler) { - exception = phandler(inst, pbuf, plen); + mb_fn_handler_fp handler = NULL; + mb_err_enum_t status = mb_get_handler(&mbm_obj->handler_descriptor, func_code, &handler); + if ((status == MB_ENOERR) && handler) { + exception = handler(inst, buf, len); } } return exception; @@ -126,7 +126,7 @@ static mb_err_enum_t mbm_register_default_handlers(mb_base_t *inst) LIST_INIT(&mbm_obj->handler_descriptor.head); mbm_obj->handler_descriptor.sema = xSemaphoreCreateBinary(); (void)xSemaphoreGive(mbm_obj->handler_descriptor.sema); - mbm_obj->handler_descriptor.instance = (void *)inst->descr.parent; + mbm_obj->handler_descriptor.instance = inst->descr.parent; #if MB_FUNC_OTHER_REP_SLAVEID_ENABLED err = mbm_set_handler(inst, MB_FUNC_OTHER_REPORT_SLAVEID, (void *)mbm_fn_report_slave_id); MB_RETURN_ON_FALSE((err == MB_ENOERR), err, TAG, "handler registration error = (0x%x).", (int)err); @@ -190,6 +190,7 @@ mb_err_enum_t mbm_rtu_create(mb_serial_opts_t *ser_opts, void **in_out_obj) MB_RETURN_ON_FALSE((ser_opts->mode == MB_RTU), MB_EILLSTATE, TAG, "incorrect mode != RTU."); mb_err_enum_t ret = MB_ENOERR; mbm_object_t *mbm_obj = NULL; + mb_trans_base_t *transp_obj = NULL; mbm_obj = (mbm_object_t *)calloc(1, sizeof(mbm_object_t)); MB_GOTO_ON_FALSE((mbm_obj), MB_EILLSTATE, error, TAG, "no mem for mb master instance."); CRITICAL_SECTION_INIT(mbm_obj->base.lock); @@ -208,21 +209,21 @@ mb_err_enum_t mbm_rtu_create(mb_serial_opts_t *ser_opts, void **in_out_obj) mbm_obj->base.descr.obj_name = (char *)TAG; mbm_obj->base.descr.inst_index = mb_port_get_inst_counter_inc(); #if MB_FUNC_OTHER_REP_SLAVEID_ENABLED - mbm_obj->base.pobj_id = NULL; + mbm_obj->base.obj_id = NULL; mbm_obj->base.obj_id_len = 0; mbm_obj->base.obj_id_chunks = 0; #endif int res = asprintf(&mbm_obj->base.descr.parent_name, "mbm_rtu@%p", mbm_obj->base.descr.parent); MB_GOTO_ON_FALSE((res), MB_EILLSTATE, error, TAG, "name alloc fail, err: %d", (int)res); - mb_trans_base_t *transp_obj = (mb_trans_base_t *)mbm_obj; + transp_obj = (mb_trans_base_t *)mbm_obj; ret = mbm_rtu_transp_create(ser_opts, (void **)&transp_obj); MB_GOTO_ON_FALSE((transp_obj && (ret == MB_ENOERR)), MB_EILLSTATE, error, TAG, "transport creation, err: %d", (int)ret); mbm_obj->cur_mode = ser_opts->mode; mbm_obj->cur_state = STATE_DISABLED; - transp_obj->get_tx_frm(transp_obj, (uint8_t **)&mbm_obj->snd_frame); - transp_obj->get_rx_frm(transp_obj, (uint8_t **)&mbm_obj->rcv_frame); + transp_obj->get_tx_frm(transp_obj, &mbm_obj->snd_frame); + transp_obj->get_rx_frm(transp_obj, &mbm_obj->rcv_frame); mbm_obj->curr_trans_id = 0; mbm_obj->base.port_obj = transp_obj->port_obj; mbm_obj->base.transp_obj = transp_obj; @@ -255,6 +256,7 @@ mb_err_enum_t mbm_ascii_create(mb_serial_opts_t *ser_opts, void **in_out_obj) MB_RETURN_ON_FALSE((ser_opts->mode == MB_ASCII), MB_EILLSTATE, TAG, "incorrect option mode != ASCII."); mb_err_enum_t ret = MB_ENOERR; mbm_object_t *mbm_obj = NULL; + mb_trans_base_t *transp_obj = NULL; mbm_obj = (mbm_object_t *)calloc(1, sizeof(mbm_object_t)); MB_GOTO_ON_FALSE((mbm_obj), MB_EILLSTATE, error, TAG, "no mem for mb master instance."); CRITICAL_SECTION_INIT(mbm_obj->base.lock); @@ -273,14 +275,14 @@ mb_err_enum_t mbm_ascii_create(mb_serial_opts_t *ser_opts, void **in_out_obj) mbm_obj->base.descr.obj_name = (char *)TAG; mbm_obj->base.descr.inst_index = mb_port_get_inst_counter_inc(); #if MB_FUNC_OTHER_REP_SLAVEID_ENABLED - mbm_obj->base.pobj_id = NULL; + mbm_obj->base.obj_id = NULL; mbm_obj->base.obj_id_len = 0; mbm_obj->base.obj_id_chunks = 0; #endif int res = asprintf(&mbm_obj->base.descr.parent_name, "mbm_ascii@%p", mbm_obj->base.descr.parent); MB_GOTO_ON_FALSE((res), MB_EILLSTATE, error, TAG, "name alloc fail, err: %d", (int)res); - mb_trans_base_t *transp_obj = (mb_trans_base_t *)mbm_obj; + transp_obj = (mb_trans_base_t *)mbm_obj; ret = mbm_ascii_transp_create(ser_opts, (void **)&transp_obj); MB_GOTO_ON_FALSE((transp_obj && (ret == MB_ENOERR)), MB_EILLSTATE, error, TAG, "transport creation, err: %d", (int)ret); @@ -289,8 +291,8 @@ mb_err_enum_t mbm_ascii_create(mb_serial_opts_t *ser_opts, void **in_out_obj) TAG, "default handlers registration fail, err: %d", (int)ret); mbm_obj->cur_mode = ser_opts->mode; mbm_obj->cur_state = STATE_DISABLED; - transp_obj->get_tx_frm(transp_obj, (uint8_t **)&mbm_obj->snd_frame); - transp_obj->get_rx_frm(transp_obj, (uint8_t **)&mbm_obj->rcv_frame); + transp_obj->get_tx_frm(transp_obj, &mbm_obj->snd_frame); + transp_obj->get_rx_frm(transp_obj, &mbm_obj->rcv_frame); mbm_obj->base.port_obj = transp_obj->port_obj; // binding of the modbus object with port object mbm_obj->base.transp_obj = transp_obj; *in_out_obj = (void *)&(mbm_obj->base); @@ -320,6 +322,7 @@ mb_err_enum_t mbm_tcp_create(mb_tcp_opts_t *tcp_opts, void **in_out_obj) MB_RETURN_ON_FALSE((tcp_opts->mode == MB_TCP), MB_EILLSTATE, TAG, "incorrect option mode != TCP."); mb_err_enum_t ret = MB_ENOERR; mbm_object_t *mbm_obj = NULL; + mb_trans_base_t *transp_obj = NULL; mbm_obj = (mbm_object_t *)calloc(1, sizeof(mbm_object_t)); MB_RETURN_ON_FALSE(mbm_obj, MB_EILLSTATE, TAG, "no mem for mb master instance."); CRITICAL_SECTION_INIT(mbm_obj->base.lock); @@ -338,14 +341,14 @@ mb_err_enum_t mbm_tcp_create(mb_tcp_opts_t *tcp_opts, void **in_out_obj) mbm_obj->base.descr.obj_name = (char *)TAG; mbm_obj->base.descr.inst_index = mb_port_get_inst_counter_inc(); #if MB_FUNC_OTHER_REP_SLAVEID_ENABLED - mbm_obj->base.pobj_id = NULL; + mbm_obj->base.obj_id = NULL; mbm_obj->base.obj_id_len = 0; mbm_obj->base.obj_id_chunks = 0; #endif int res = asprintf(&mbm_obj->base.descr.parent_name, "mbm_tcp#%p", mbm_obj->base.descr.parent); MB_GOTO_ON_FALSE((res), MB_EILLSTATE, error, TAG, "name alloc fail, err: %d", (int)res); - mb_trans_base_t *transp_obj = (mb_trans_base_t *)mbm_obj; + transp_obj = (mb_trans_base_t *)mbm_obj; ret = mbm_tcp_transp_create(tcp_opts, (void **)&transp_obj); MB_GOTO_ON_FALSE((transp_obj && (ret == MB_ENOERR)), MB_EILLSTATE, error, TAG, "transport creation, err: %d", (int)ret); @@ -354,8 +357,8 @@ mb_err_enum_t mbm_tcp_create(mb_tcp_opts_t *tcp_opts, void **in_out_obj) TAG, "default handlers registration fail, err: %d", (int)ret); mbm_obj->cur_mode = tcp_opts->mode; mbm_obj->cur_state = STATE_DISABLED; - transp_obj->get_tx_frm(transp_obj, (uint8_t **)&mbm_obj->snd_frame); - transp_obj->get_rx_frm(transp_obj, (uint8_t **)&mbm_obj->rcv_frame); + transp_obj->get_tx_frm(transp_obj, &mbm_obj->snd_frame); + transp_obj->get_rx_frm(transp_obj, &mbm_obj->rcv_frame); mbm_obj->base.port_obj = transp_obj->port_obj; // binding of the modbus object with port object mbm_obj->base.transp_obj = transp_obj; *in_out_obj = (void *)&(mbm_obj->base); @@ -387,9 +390,9 @@ mb_err_enum_t mbm_delete(mb_base_t *inst) } #if MB_FUNC_OTHER_REP_SLAVEID_ENABLED // check object ID - if (mbm_obj->base.pobj_id) { - free(mbm_obj->base.pobj_id); - mbm_obj->base.pobj_id = NULL; + if (mbm_obj->base.obj_id) { + free(mbm_obj->base.obj_id); + mbm_obj->base.obj_id = NULL; mbm_obj->base.obj_id_len = 0; mbm_obj->base.obj_id_chunks = 0; ESP_LOGW(TAG, "%p, Master object ID is not supported!", mbm_obj); @@ -449,17 +452,17 @@ mb_err_enum_t mbm_disable(mb_base_t *inst) return status; } -static void mbm_get_pdu_send_buf(mb_base_t *inst, uint8_t **pbuf) +static void mbm_get_pdu_send_buf(mb_base_t *inst, uint8_t **buf) { mbm_object_t *mbm_obj = MB_GET_OBJ_CTX(inst, mbm_object_t, base); - MB_OBJ(mbm_obj->base.transp_obj)->get_tx_frm(mbm_obj->base.transp_obj, pbuf); + MB_OBJ(mbm_obj->base.transp_obj)->get_tx_frm(mbm_obj->base.transp_obj, buf); } __attribute__((unused)) -static void mbm_get_pdu_recv_buf(mb_base_t *inst, uint8_t **pbuf) +static void mbm_get_pdu_recv_buf(mb_base_t *inst, uint8_t **buf) { mbm_object_t *mbm_obj = MB_GET_OBJ_CTX(inst, mbm_object_t, base);; - MB_OBJ(mbm_obj->base.transp_obj)->get_rx_frm(mbm_obj->base.transp_obj, pbuf); + MB_OBJ(mbm_obj->base.transp_obj)->get_rx_frm(mbm_obj->base.transp_obj, buf); } static void mbm_set_pdu_send_length(mb_base_t *inst, uint16_t length) @@ -542,8 +545,8 @@ mb_err_enum_t mbm_poll(mb_base_t *inst) case EV_FRAME_TRANSMIT: mbm_get_pdu_send_buf(inst, &mbm_obj->snd_frame); - ESP_LOG_BUFFER_HEX_LEVEL(MB_STR_CAT(inst->descr.parent_name, ":MB_TRANSMIT"), - (void *)mbm_obj->snd_frame, mbm_obj->pdu_snd_len, ESP_LOG_DEBUG); + MB_PRT_BUF(inst->descr.parent_name, ":MB_TRANSMIT", + mbm_obj->snd_frame, mbm_obj->pdu_snd_len, ESP_LOG_DEBUG); status = MB_OBJ(inst->transp_obj)->frm_send(inst->transp_obj, mbm_obj->master_dst_addr, mbm_obj->snd_frame, mbm_obj->pdu_snd_len); if (status != MB_ENOERR) { @@ -571,8 +574,8 @@ mb_err_enum_t mbm_poll(mb_base_t *inst) || (mbm_obj->rcv_addr == MB_TCP_PSEUDO_ADDRESS))) { if ((mbm_obj->rcv_frame[MB_PDU_FUNC_OFF] & ~MB_FUNC_ERROR) == (mbm_obj->snd_frame[MB_PDU_FUNC_OFF])) { ESP_LOGD(TAG, MB_OBJ_FMT", frame data received successfully, (%d).", MB_OBJ_PARENT(inst), (int)status); - ESP_LOG_BUFFER_HEX_LEVEL(MB_STR_CAT(inst->descr.parent_name, ":MB_RECV"), (void *)mbm_obj->rcv_frame, - (uint16_t)mbm_obj->pdu_rcv_len, ESP_LOG_DEBUG); + MB_PRT_BUF(inst->descr.parent_name, ":MB_RECV", + mbm_obj->rcv_frame, mbm_obj->pdu_rcv_len, ESP_LOG_DEBUG); (void)mb_port_event_post(MB_OBJ(inst->port_obj), EVENT(EV_EXECUTE)); } else { ESP_LOGE(TAG, MB_OBJ_FMT", drop incorrect frame, receive_func(%u) != send_func(%u)", @@ -686,4 +689,4 @@ mb_err_enum_t mbm_poll(mb_base_t *inst) return status; } -#endif +#endif \ No newline at end of file diff --git a/modbus/mb_objects/mb_slave.c b/modbus/mb_objects/mb_slave.c index 676d689..0a3a546 100644 --- a/modbus/mb_objects/mb_slave.c +++ b/modbus/mb_objects/mb_slave.c @@ -46,24 +46,24 @@ mb_err_enum_t mbs_disable(mb_base_t *inst); mb_err_enum_t mbs_poll(mb_base_t *inst); // The helper function to register custom function handler for slave -mb_err_enum_t mbs_set_handler(mb_base_t *inst, uint8_t func_code, mb_fn_handler_fp phandler) +mb_err_enum_t mbs_set_handler(mb_base_t *inst, uint8_t func_code, mb_fn_handler_fp handler) { mbs_object_t *mbs_obj = MB_GET_OBJ_CTX(inst, mbs_object_t, base); mb_err_enum_t status = MB_EINVAL; SEMA_SECTION(mbs_obj->handler_descriptor.sema, MB_HANDLER_UNLOCK_TICKS) { - status = mb_set_handler(&mbs_obj->handler_descriptor, func_code, phandler); + status = mb_set_handler(&mbs_obj->handler_descriptor, func_code, handler); } return status; } // The helper function to register custom function handler for slave -mb_err_enum_t mbs_get_handler(mb_base_t *inst, uint8_t func_code, mb_fn_handler_fp *phandler) +mb_err_enum_t mbs_get_handler(mb_base_t *inst, uint8_t func_code, mb_fn_handler_fp *handler) { mbs_object_t *mbs_obj = MB_GET_OBJ_CTX(inst, mbs_object_t, base); mb_err_enum_t status = MB_EINVAL; - if (phandler) { + if (handler) { SEMA_SECTION(mbs_obj->handler_descriptor.sema, MB_HANDLER_UNLOCK_TICKS) { - status = mb_get_handler(&mbs_obj->handler_descriptor, func_code, phandler); + status = mb_get_handler(&mbs_obj->handler_descriptor, func_code, handler); } } return status; @@ -79,17 +79,17 @@ mb_err_enum_t mbs_delete_handler(mb_base_t *inst, uint8_t func_code) return status; } -mb_err_enum_t mbs_get_handler_count(mb_base_t *inst, uint16_t *pcount) +mb_err_enum_t mbs_get_handler_count(mb_base_t *inst, uint16_t *count) { - MB_RETURN_ON_FALSE((pcount && inst), MB_EINVAL, TAG, "get handler count wrong arguments"); + MB_RETURN_ON_FALSE((count && inst), MB_EINVAL, TAG, "get handler count wrong arguments"); mbs_object_t *mbs_obj = MB_GET_OBJ_CTX(inst, mbs_object_t, base); SEMA_SECTION(mbs_obj->handler_descriptor.sema, MB_HANDLER_UNLOCK_TICKS) { - *pcount = mbs_obj->handler_descriptor.count; + *count = mbs_obj->handler_descriptor.count; } return MB_ENOERR; } -static mb_exception_t mbs_check_invoke_handler(mb_base_t *inst, uint8_t func_code, uint8_t *pbuf, uint16_t *plen) +static mb_exception_t mbs_check_invoke_handler(mb_base_t *inst, uint8_t func_code, uint8_t *buf, uint16_t *len) { mbs_object_t *mbs_obj = MB_GET_OBJ_CTX(inst, mbs_object_t, base); mb_exception_t exception = MB_EX_ILLEGAL_FUNCTION; @@ -97,11 +97,11 @@ static mb_exception_t mbs_check_invoke_handler(mb_base_t *inst, uint8_t func_cod return MB_EX_ILLEGAL_FUNCTION; } SEMA_SECTION(mbs_obj->handler_descriptor.sema, MB_HANDLER_UNLOCK_TICKS) { - mb_fn_handler_fp phandler = NULL; - mb_err_enum_t status = mb_get_handler(&mbs_obj->handler_descriptor, func_code, &phandler); - if ((status == MB_ENOERR) && phandler) { - exception = phandler(inst, pbuf, plen); - ESP_LOGD(TAG, MB_OBJ_FMT": function (0x%x), invoke handler %p.", MB_OBJ_PARENT(inst), (int)func_code, phandler); + mb_fn_handler_fp handler = NULL; + mb_err_enum_t status = mb_get_handler(&mbs_obj->handler_descriptor, func_code, &handler); + if ((status == MB_ENOERR) && handler) { + exception = handler(inst, buf, len); + ESP_LOGD(TAG, MB_OBJ_FMT": function (0x%x), invoke handler %p.", MB_OBJ_PARENT(inst), (int)func_code, handler); } } return exception; @@ -114,7 +114,7 @@ static mb_err_enum_t mbs_register_default_handlers(mb_base_t *inst) LIST_INIT(&mbs_obj->handler_descriptor.head); mbs_obj->handler_descriptor.sema = xSemaphoreCreateBinary(); (void)xSemaphoreGive(mbs_obj->handler_descriptor.sema); - mbs_obj->handler_descriptor.instance = (void *)inst->descr.parent; + mbs_obj->handler_descriptor.instance = inst->descr.parent; #if MB_FUNC_OTHER_REP_SLAVEID_ENABLED err = mbs_set_handler(inst, MB_FUNC_OTHER_REPORT_SLAVEID, (void *)mbs_fn_report_slave_id); MB_RETURN_ON_FALSE((err == MB_ENOERR), err, TAG, "handler registration error = (0x%x).", (int)err); @@ -178,6 +178,7 @@ mb_err_enum_t mbs_rtu_create(mb_serial_opts_t *ser_opts, void **in_out_obj) MB_RETURN_ON_FALSE(ser_opts, MB_EINVAL, TAG, "invalid options for the instance."); MB_RETURN_ON_FALSE((ser_opts->mode == MB_RTU), MB_EILLSTATE, TAG, "incorrect mode != RTU."); mbs_object_t *mbs_obj = NULL; + mb_trans_base_t *transp_obj = NULL; mbs_obj = (mbs_object_t*)calloc(1, sizeof(mbs_object_t)); MB_GOTO_ON_FALSE((mbs_obj), MB_EILLSTATE, error, TAG, "no mem for mb slave instance."); CRITICAL_SECTION_INIT(mbs_obj->base.lock); @@ -191,14 +192,14 @@ mb_err_enum_t mbs_rtu_create(mb_serial_opts_t *ser_opts, void **in_out_obj) mbs_obj->base.descr.obj_name = (char *)TAG; mbs_obj->base.descr.inst_index = mb_port_get_inst_counter_inc(); #if MB_FUNC_OTHER_REP_SLAVEID_ENABLED - mbs_obj->base.pobj_id = NULL; + mbs_obj->base.obj_id = NULL; mbs_obj->base.obj_id_len = 0; mbs_obj->base.obj_id_chunks = 0; #endif int res = asprintf(&mbs_obj->base.descr.parent_name, "mbs_rtu@%p", *in_out_obj); MB_GOTO_ON_FALSE((res), MB_EILLSTATE, error, TAG, "name alloc fail, err: %d", (int)res); - mb_trans_base_t *transp_obj = (mb_trans_base_t *)mbs_obj; + transp_obj = (mb_trans_base_t *)mbs_obj; ret = mbs_rtu_transp_create(ser_opts, (void **)&transp_obj); MB_GOTO_ON_FALSE((transp_obj && (ret == MB_ENOERR)), MB_EILLSTATE, error, TAG, "transport creation, err: %d", (int)ret); @@ -208,7 +209,7 @@ mb_err_enum_t mbs_rtu_create(mb_serial_opts_t *ser_opts, void **in_out_obj) mbs_obj->cur_mode = ser_opts->mode; mbs_obj->mb_address = ser_opts->uid; mbs_obj->cur_state = STATE_DISABLED; - transp_obj->get_tx_frm(transp_obj, (uint8_t **)&mbs_obj->frame); + transp_obj->get_tx_frm(transp_obj, &mbs_obj->frame); mbs_obj->base.port_obj = transp_obj->port_obj; mbs_obj->base.transp_obj = transp_obj; *in_out_obj = (void *)&(mbs_obj->base); @@ -237,6 +238,7 @@ mb_err_enum_t mbs_ascii_create(mb_serial_opts_t *ser_opts, void **in_out_obj) MB_RETURN_ON_FALSE(ser_opts, MB_EINVAL, TAG, "invalid options for %s instance.", TAG); MB_RETURN_ON_FALSE((ser_opts->mode == MB_ASCII), MB_EILLSTATE, TAG, "incorrect mode != ASCII."); mbs_object_t *mbs_obj = NULL; + mb_trans_base_t *transp_obj = NULL; mbs_obj = (mbs_object_t*)calloc(1, sizeof(mbs_object_t)); MB_GOTO_ON_FALSE((mbs_obj), MB_EILLSTATE, error, TAG, "no mem for mb slave instance."); CRITICAL_SECTION_INIT(mbs_obj->base.lock); @@ -249,14 +251,14 @@ mb_err_enum_t mbs_ascii_create(mb_serial_opts_t *ser_opts, void **in_out_obj) mbs_obj->base.descr.obj_name = (char *)TAG; mbs_obj->base.descr.inst_index = mb_port_get_inst_counter_inc(); #if MB_FUNC_OTHER_REP_SLAVEID_ENABLED - mbs_obj->base.pobj_id = NULL; + mbs_obj->base.obj_id = NULL; mbs_obj->base.obj_id_len = 0; mbs_obj->base.obj_id_chunks = 0; #endif int res = asprintf(&mbs_obj->base.descr.parent_name, "mbs_ascii@%p", *in_out_obj); MB_GOTO_ON_FALSE((res), MB_EILLSTATE, error, TAG, "name alloc fail, err: %d", (int)res); - mb_trans_base_t *transp_obj = (mb_trans_base_t *)mbs_obj; + transp_obj = (mb_trans_base_t *)mbs_obj; ret = mbs_ascii_transp_create(ser_opts, (void **)&transp_obj); MB_GOTO_ON_FALSE((transp_obj && (ret == MB_ENOERR)), MB_EILLSTATE, error, TAG, "transport creation, err: %d", (int)ret); @@ -266,7 +268,7 @@ mb_err_enum_t mbs_ascii_create(mb_serial_opts_t *ser_opts, void **in_out_obj) mbs_obj->cur_mode = ser_opts->mode; mbs_obj->mb_address = ser_opts->uid; mbs_obj->cur_state = STATE_DISABLED; - transp_obj->get_tx_frm(transp_obj, (uint8_t **)&mbs_obj->frame); + transp_obj->get_tx_frm(transp_obj, &mbs_obj->frame); mbs_obj->base.port_obj = transp_obj->port_obj; mbs_obj->base.transp_obj = transp_obj; *in_out_obj = (void *)&(mbs_obj->base); @@ -295,6 +297,7 @@ mb_err_enum_t mbs_tcp_create(mb_tcp_opts_t *tcp_opts, void **in_out_obj) MB_RETURN_ON_FALSE(tcp_opts, MB_EINVAL, TAG, "invalid options for the instance."); MB_RETURN_ON_FALSE((tcp_opts->mode == MB_TCP), MB_EILLSTATE, TAG, "incorrect mode != TCP."); mbs_object_t *mbs_obj = NULL; + mb_trans_base_t *transp_obj = NULL; mbs_obj = (mbs_object_t*)calloc(1, sizeof(mbs_object_t)); MB_GOTO_ON_FALSE((mbs_obj), MB_EILLSTATE, error, TAG, "no mem for mb slave instance."); CRITICAL_SECTION_INIT(mbs_obj->base.lock); @@ -308,14 +311,14 @@ mb_err_enum_t mbs_tcp_create(mb_tcp_opts_t *tcp_opts, void **in_out_obj) mbs_obj->base.descr.obj_name = (char *)TAG; mbs_obj->base.descr.inst_index = mb_port_get_inst_counter_inc(); #if MB_FUNC_OTHER_REP_SLAVEID_ENABLED - mbs_obj->base.pobj_id = NULL; + mbs_obj->base.obj_id = NULL; mbs_obj->base.obj_id_len = 0; mbs_obj->base.obj_id_chunks = 0; #endif int res = asprintf(&mbs_obj->base.descr.parent_name, "mbs_tcp@%p", *in_out_obj); MB_GOTO_ON_FALSE((res), MB_EILLSTATE, error, TAG, "name alloc fail, err: %d", (int)res); - mb_trans_base_t *transp_obj = (mb_trans_base_t *)mbs_obj; + transp_obj = (mb_trans_base_t *)mbs_obj; ret = mbs_tcp_transp_create(tcp_opts, (void **)&transp_obj); MB_GOTO_ON_FALSE((transp_obj && (ret == MB_ENOERR)), MB_EILLSTATE, error, TAG, "transport creation, err: %d", (int)ret); @@ -325,7 +328,7 @@ mb_err_enum_t mbs_tcp_create(mb_tcp_opts_t *tcp_opts, void **in_out_obj) mbs_obj->cur_mode = tcp_opts->mode; mbs_obj->mb_address = tcp_opts->uid; mbs_obj->cur_state = STATE_DISABLED; - transp_obj->get_tx_frm(transp_obj, (uint8_t **)&mbs_obj->frame); + transp_obj->get_tx_frm(transp_obj, &mbs_obj->frame); mbs_obj->base.port_obj = transp_obj->port_obj; mbs_obj->base.transp_obj = transp_obj; *in_out_obj = (void *)&(mbs_obj->base); @@ -357,9 +360,9 @@ mb_err_enum_t mbs_delete(mb_base_t *inst) } #if MB_FUNC_OTHER_REP_SLAVEID_ENABLED // delete allocated slave ID - if (mbs_obj->base.pobj_id) { - free(mbs_obj->base.pobj_id); - mbs_obj->base.pobj_id = NULL; + if (mbs_obj->base.obj_id) { + free(mbs_obj->base.obj_id); + mbs_obj->base.obj_id = NULL; mbs_obj->base.obj_id_len = 0; mbs_obj->base.obj_id_chunks = 0; } @@ -452,8 +455,8 @@ mb_err_enum_t mbs_poll(mb_base_t *inst) || (mbs_obj->rcv_addr == MB_TCP_PSEUDO_ADDRESS)) { mbs_obj->curr_trans_id = event.get_ts; (void)mb_port_event_post(MB_OBJ(inst->port_obj), EVENT(EV_EXECUTE | EV_TRANS_START)); - ESP_LOG_BUFFER_HEX_LEVEL(MB_STR_CAT(inst->descr.parent_name, ":MB_RECV"), &mbs_obj->frame[MB_PDU_FUNC_OFF], - (uint16_t)mbs_obj->length, ESP_LOG_DEBUG); + MB_PRT_BUF(inst->descr.parent_name, ":MB_RECV", + &mbs_obj->frame[MB_PDU_FUNC_OFF], mbs_obj->length, ESP_LOG_DEBUG); } } break; @@ -474,7 +477,8 @@ mb_err_enum_t mbs_poll(mb_base_t *inst) if ((mbs_obj->cur_mode == MB_ASCII) && MB_ASCII_TIMEOUT_WAIT_BEFORE_SEND_MS) { mb_port_timer_delay(MB_OBJ(inst->port_obj), MB_ASCII_TIMEOUT_WAIT_BEFORE_SEND_MS); } - ESP_LOG_BUFFER_HEX_LEVEL(MB_STR_CAT(inst->descr.parent_name, ":MB_SEND"), (void *)mbs_obj->frame, mbs_obj->length, ESP_LOG_DEBUG); + MB_PRT_BUF(inst->descr.parent_name, ":MB_SEND", (void *)mbs_obj->frame, + (uint16_t)mbs_obj->length, ESP_LOG_DEBUG); status = MB_OBJ(inst->transp_obj)->frm_send(inst->transp_obj, mbs_obj->rcv_addr, mbs_obj->frame, mbs_obj->length); if (status != MB_ENOERR) { ESP_LOGE(TAG, MB_OBJ_FMT":frame send error. %d", MB_OBJ_PARENT(inst), (int)status); @@ -505,4 +509,4 @@ mb_err_enum_t mbs_poll(mb_base_t *inst) return status; } -#endif /* (MB_SLAVE_ASCII_ENABLED || MB_SLAVE_RTU_ENABLED || MB_TCP_ENABLED) */ \ No newline at end of file +#endif /* (MB_SLAVE_ASCII_ENABLED || MB_SLAVE_RTU_ENABLED || MB_TCP_ENABLED) */ diff --git a/modbus/mb_ports/common/mb_transaction.c b/modbus/mb_ports/common/mb_transaction.c index 78a4d2f..3b13ddc 100644 --- a/modbus/mb_ports/common/mb_transaction.c +++ b/modbus/mb_ports/common/mb_transaction.c @@ -150,7 +150,7 @@ uint8_t *transaction_item_get_data(transaction_item_handle_t item, size_t *len, if (node_id) { *node_id = item->node_id; } - return (uint8_t *)item->buffer; + return item->buffer; } return NULL; } diff --git a/modbus/mb_ports/common/mb_transaction.h b/modbus/mb_ports/common/mb_transaction.h index d189ac3..0dc68c5 100644 --- a/modbus/mb_ports/common/mb_transaction.h +++ b/modbus/mb_ports/common/mb_transaction.h @@ -48,7 +48,7 @@ typedef enum pending_state { transaction_handle_t transaction_init(void); transaction_item_handle_t transaction_enqueue(transaction_handle_t transaction, transaction_message_handle_t message, transaction_tick_t tick); -transaction_item_handle_t transaction_dequeue(transaction_handle_t transaction, pending_state_t pending, transaction_tick_t *tick); +transaction_item_handle_t transaction_dequeue(transaction_handle_t transaction, pending_state_t state, transaction_tick_t *tick); transaction_item_handle_t transaction_get(transaction_handle_t transaction, int msg_id); transaction_item_handle_t transaction_get_first(transaction_handle_t transaction); uint8_t *transaction_item_get_data(transaction_item_handle_t item, size_t *len, uint16_t *msg_id, int *node_id); @@ -62,7 +62,7 @@ int transaction_delete_expired(transaction_handle_t transaction, transaction_tic * @return msg id of the deleted message, -1 if no expired message in the transaction */ int transaction_delete_single_expired(transaction_handle_t transaction, transaction_tick_t current_tick, transaction_tick_t timeout); -esp_err_t transaction_set_state(transaction_handle_t transaction, int msg_id, pending_state_t pending); +esp_err_t transaction_set_state(transaction_handle_t transaction, int msg_id, pending_state_t state); pending_state_t transaction_item_get_state(transaction_item_handle_t item); esp_err_t transaction_item_set_state(transaction_item_handle_t item, pending_state_t state); esp_err_t transaction_set_tick(transaction_handle_t transaction, int msg_id, transaction_tick_t tick); diff --git a/modbus/mb_ports/common/port_common.h b/modbus/mb_ports/common/port_common.h index 65a252a..99000a4 100644 --- a/modbus/mb_ports/common/port_common.h +++ b/modbus/mb_ports/common/port_common.h @@ -30,8 +30,8 @@ extern "C" { #define MB_EVENT_QUEUE_TIMEOUT_MAX (pdMS_TO_TICKS(MB_EVENT_QUEUE_TIMEOUT_MAX_MS)) #define MB_MS_TO_TICKS(time_ms) (pdMS_TO_TICKS(time_ms)) -int lock_obj(_lock_t *plock); -void unlock_obj(_lock_t *plock); +int lock_obj(_lock_t *lock_ptr); +void unlock_obj(_lock_t *lock_ptr); #define CRITICAL_SECTION_INIT(lock) \ do \ @@ -104,9 +104,9 @@ void unlock_obj(_lock_t *plock); #define EVENT_2(_1, _2) \ (mb_event_t) { .event = _1, .length = _2 } #define EVENT_3(_1, _2, _3) \ - (mb_event_t) { .event = _1, .length = _2, .pdata = _3 } + (mb_event_t) { .event = _1, .length = _2, .data_ptr = _3 } #define EVENT_4(_1, _2, _3, _4) \ - (mb_event_t) { .event = _1, .length = _2, .pdata = _3, .type = _4 } + (mb_event_t) { .event = _1, .length = _2, .data_ptr = _3, .type = _4 } typedef struct mb_port_base_t mb_port_base_t; @@ -117,7 +117,7 @@ typedef struct //((mb_port_base_t *)(((mb_common_iface_t *)pctx)->mb_base)->lock); -#define MB_OBJ_GET_LOCK(pctx) (__extension__( \ +#define MB_OBJ_GET_LOCK(pctx) (__extension__( \ { \ assert((pctx)); \ mb_common_iface_t *iface = (mb_common_iface_t *)pctx; \ @@ -136,14 +136,14 @@ typedef struct typedef struct mb_port_event_t mb_port_event_t; typedef struct mb_port_timer_t mb_port_timer_t; -typedef struct _obj_descr obj_descr_t; +typedef struct obj_descr_s obj_descr_t; -typedef struct _frame_queue_entry +typedef struct frame_queue_entry_s { uint16_t tid; /*!< Transaction identifier (TID) for slave */ uint16_t pid; /*!< Protocol ID field of MBAP frame */ uint16_t uid; /*!< Slave unit ID (UID) field for MBAP frame */ - uint8_t *pbuf; /*!< Points to the buffer for the frame */ + uint8_t *buf; /*!< Points to the buffer for the frame */ uint16_t len; /*!< Length of the frame in the buffer */ bool check; /*!< Checked flag */ } frame_entry_t; @@ -160,7 +160,7 @@ struct mb_port_base_t }; // Port event functions -mb_err_enum_t mb_port_event_create(mb_port_base_t *port_obj); +mb_err_enum_t mb_port_event_create(mb_port_base_t *inst); bool mb_port_event_post(mb_port_base_t *inst, mb_event_t event); bool mb_port_event_get(mb_port_base_t *inst, mb_event_t *event); bool mb_port_event_res_take(mb_port_base_t *inst, uint32_t timeout); @@ -196,8 +196,8 @@ QueueHandle_t queue_create(int queue_size); void queue_delete(QueueHandle_t queue); void queue_flush(QueueHandle_t queue); bool queue_is_empty(QueueHandle_t queue); -esp_err_t queue_push(QueueHandle_t queue, void *pbuf, size_t len, frame_entry_t *pframe); -ssize_t queue_pop(QueueHandle_t queue, void *pbuf, size_t len, frame_entry_t *pframe); +esp_err_t queue_push(QueueHandle_t queue, void *buf, size_t len, frame_entry_t *frame); +ssize_t queue_pop(QueueHandle_t queue, void *buf, size_t len, frame_entry_t *frame); #ifdef __cplusplus diff --git a/modbus/mb_ports/common/port_event.c b/modbus/mb_ports/common/port_event.c index 3c0f11a..e442c5e 100644 --- a/modbus/mb_ports/common/port_event.c +++ b/modbus/mb_ports/common/port_event.c @@ -27,40 +27,40 @@ struct mb_port_event_t mb_err_enum_t mb_port_event_create(mb_port_base_t *inst) { - mb_port_event_t *pevent = NULL; + mb_port_event_t *event_obj = NULL; mb_err_enum_t ret = MB_EILLSTATE; MB_RETURN_ON_FALSE((inst), MB_EILLSTATE, TAG, "mb event creation error."); - pevent = (mb_port_event_t *)calloc(1, sizeof(mb_port_event_t)); - MB_RETURN_ON_FALSE((pevent), MB_EILLSTATE, TAG, "mb event creation error."); + event_obj = (mb_port_event_t *)calloc(1, sizeof(mb_port_event_t)); + MB_RETURN_ON_FALSE((event_obj), MB_EILLSTATE, TAG, "mb event creation error."); // Create modbus semaphore (mb resource). - pevent->resource_hdl = xSemaphoreCreateBinary(); - MB_GOTO_ON_FALSE((pevent->resource_hdl), MB_EILLSTATE, error, TAG, + event_obj->resource_hdl = xSemaphoreCreateBinary(); + MB_GOTO_ON_FALSE((event_obj->resource_hdl), MB_EILLSTATE, error, TAG, "%s, mb resource create failure.", inst->descr.parent_name); - pevent->event_group_hdl = xEventGroupCreate(); - MB_GOTO_ON_FALSE((pevent->event_group_hdl), MB_EILLSTATE, error, TAG, + event_obj->event_group_hdl = xEventGroupCreate(); + MB_GOTO_ON_FALSE((event_obj->event_group_hdl), MB_EILLSTATE, error, TAG, "%s, event group create error.", inst->descr.parent_name); - pevent->event_hdl = xQueueCreate(MB_EVENT_QUEUE_SIZE, sizeof(mb_event_t)); - MB_GOTO_ON_FALSE((pevent->event_hdl), MB_EILLSTATE, error, TAG, "%s, event queue create error.", inst->descr.parent_name); - vQueueAddToRegistry(pevent->event_hdl, TAG); - inst->event_obj = pevent; - atomic_init(&pevent->curr_err_type, EV_ERROR_INIT); - ESP_LOGD(TAG, "initialized object @%p", pevent); + event_obj->event_hdl = xQueueCreate(MB_EVENT_QUEUE_SIZE, sizeof(mb_event_t)); + MB_GOTO_ON_FALSE((event_obj->event_hdl), MB_EILLSTATE, error, TAG, "%s, event queue create error.", inst->descr.parent_name); + vQueueAddToRegistry(event_obj->event_hdl, TAG); + inst->event_obj = event_obj; + atomic_init(&event_obj->curr_err_type, EV_ERROR_INIT); + ESP_LOGD(TAG, "initialized object @%p", event_obj); return MB_ENOERR; error: - if(pevent->event_hdl) { - vQueueDelete(pevent->event_hdl); - pevent->event_hdl = NULL; + if(event_obj->event_hdl) { + vQueueDelete(event_obj->event_hdl); + event_obj->event_hdl = NULL; } - if (pevent->event_group_hdl) { - vEventGroupDelete(pevent->event_group_hdl); - pevent->event_group_hdl = NULL; + if (event_obj->event_group_hdl) { + vEventGroupDelete(event_obj->event_group_hdl); + event_obj->event_group_hdl = NULL; } - if (pevent->resource_hdl) { - vSemaphoreDelete(pevent->resource_hdl); - pevent->resource_hdl = NULL; + if (event_obj->resource_hdl) { + vSemaphoreDelete(event_obj->resource_hdl); + event_obj->resource_hdl = NULL; } - free(inst->event_obj); + free(event_obj); inst->event_obj = NULL; return ret; } @@ -104,40 +104,35 @@ bool mb_port_event_post(mb_port_base_t *inst, mb_event_t event) result = xQueueSendFromISR(inst->event_obj->event_hdl, (const void*)&temp_event, &high_prio_task_woken); // Was the message posted successfully? - if (result == pdPASS) { - // If high_prio_task_woken is now set to pdTRUE - // then a context switch should be requested. - if (high_prio_task_woken) { - portYIELD_FROM_ISR(); - } - return true; - } else { + if (result != pdPASS) { ESP_EARLY_LOGV(TAG, "%s, post message %x failure .", inst->descr.parent_name, temp_event.event); return false; } + // If high_prio_task_woken is now set to pdTRUE + // then a context switch should be requested. if (high_prio_task_woken) { portYIELD_FROM_ISR(); } - } else { - result = xQueueSend(inst->event_obj->event_hdl, (const void*)&temp_event, MB_EVENT_QUEUE_TIMEOUT_MAX); - if (result != pdTRUE) { - xQueueReset(inst->event_obj->event_hdl); - ESP_LOGE(TAG, "%s, post message failure.", inst->descr.parent_name); - return false; - } + return true; + } + result = xQueueSend(inst->event_obj->event_hdl, (const void*)&temp_event, MB_EVENT_QUEUE_TIMEOUT_MAX); + if (result != pdTRUE) { + xQueueReset(inst->event_obj->event_hdl); + ESP_LOGE(TAG, "%s, post message failure.", inst->descr.parent_name); + return false; } return true; } -bool mb_port_event_get(mb_port_base_t *inst, mb_event_t *pevent) +bool mb_port_event_get(mb_port_base_t *inst, mb_event_t *event) { - MB_RETURN_ON_FALSE((inst && pevent && inst->event_obj && inst->event_obj->event_hdl), false, TAG, + MB_RETURN_ON_FALSE((inst && event && inst->event_obj && inst->event_obj->event_hdl), false, TAG, "incorrect object handle."); bool event_happened = false; - if (xQueueReceive(inst->event_obj->event_hdl, pevent, MB_EVENT_QUEUE_TIMEOUT_MAX) == pdTRUE) { - pevent->trans_id = atomic_load(&inst->event_obj->curr_trans_id); - pevent->get_ts = esp_timer_get_time(); + if (xQueueReceive(inst->event_obj->event_hdl, event, MB_EVENT_QUEUE_TIMEOUT_MAX) == pdTRUE) { + event->trans_id = atomic_load(&inst->event_obj->curr_trans_id); + event->get_ts = esp_timer_get_time(); event_happened = true; } else { ESP_LOGD(TAG, "%s, get event timeout.", inst->descr.parent_name); @@ -152,7 +147,7 @@ bool mb_port_event_res_take(mb_port_base_t *inst, uint32_t timeout) BaseType_t status = pdTRUE; status = xSemaphoreTake(inst->event_obj->resource_hdl, timeout); ESP_LOGD(TAG, "%s, mb take resource, (%" PRIu32 " ticks).", inst->descr.parent_name, timeout); - return status; + return (bool)status; } void mb_port_event_res_release(mb_port_base_t *inst) @@ -178,11 +173,11 @@ mb_err_enum_t mb_port_event_wait_req_finish(mb_port_base_t *inst) "incorrect object handle."); mb_err_enum_t err_status = MB_ENOERR; mb_event_enum_t rcv_event; - EventBits_t bits = xEventGroupWaitBits(inst->event_obj->event_group_hdl, // The event group being tested. - MB_EVENT_REQ_MASK, // The bits within the event group to wait for. - pdTRUE, // Masked bits should be cleared before returning. - pdFALSE, // Don't wait for both bits, either bit will do. - MB_EVENT_QUEUE_TIMEOUT_MAX); // Wait forever for either bit to be set. + EventBits_t bits = xEventGroupWaitBits(inst->event_obj->event_group_hdl,// The event group being tested. + MB_EVENT_REQ_MASK, // The bits within the event group to wait for. + pdTRUE, // Masked bits should be cleared before returning. + pdFALSE, // Don't wait for both bits, either bit will do. + MB_EVENT_QUEUE_TIMEOUT_MAX);// Wait forever for either bit to be set. rcv_event = (mb_event_enum_t)(bits); if (rcv_event) { ESP_LOGD(TAG, "%s, %s: returned event = 0x%x", inst->descr.parent_name, __func__, (int)rcv_event); diff --git a/modbus/mb_ports/common/port_other.c b/modbus/mb_ports/common/port_other.c index 51d3925..b005b2f 100644 --- a/modbus/mb_ports/common/port_other.c +++ b/modbus/mb_ports/common/port_other.c @@ -14,15 +14,15 @@ static _Atomic(uint32_t) inst_counter = 0; /* ----------------------- Start implementation -----------------------------*/ -int lock_obj(_lock_t *plock) +int lock_obj(_lock_t *lock_ptr) { - _lock_acquire(plock); + _lock_acquire(lock_ptr); return 1; } -void unlock_obj(_lock_t *plock) +void unlock_obj(_lock_t *lock_ptr) { - _lock_release(plock); + _lock_release(lock_ptr); } __attribute__((unused)) @@ -58,27 +58,27 @@ void queue_delete(QueueHandle_t queue) vQueueDelete(queue); } -esp_err_t queue_push(QueueHandle_t queue, void *pbuf, size_t len, frame_entry_t *pframe) +esp_err_t queue_push(QueueHandle_t queue, void *buf, size_t len, frame_entry_t *frame) { frame_entry_t frame_info = {0}; - if (!queue) { // || !pbuf || (len <= 0) + if (!queue) { // || !buf || (len <= 0) return -1; } - if (pframe) { - frame_info = *pframe; + if (frame) { + frame_info = *frame; } - if (pbuf && (len > 0)) { - if (!frame_info.pbuf) { - frame_info.pbuf = calloc(1, len); + if (buf && (len > 0)) { + if (!frame_info.buf) { + frame_info.buf = calloc(1, len); } - if (!frame_info.pbuf) { + if (!frame_info.buf) { return ESP_ERR_NO_MEM; } frame_info.len = len; - memcpy(frame_info.pbuf, pbuf, len); + memcpy(frame_info.buf, buf, len); } // try send to queue and check if the queue is full @@ -88,25 +88,25 @@ esp_err_t queue_push(QueueHandle_t queue, void *pbuf, size_t len, frame_entry_t return ESP_OK; } -ssize_t queue_pop(QueueHandle_t queue, void *pbuf, size_t len, frame_entry_t *pframe) +ssize_t queue_pop(QueueHandle_t queue, void *buf, size_t len, frame_entry_t *frame) { TickType_t timeout = portMAX_DELAY; frame_entry_t frame_info = {0}; if (xQueueReceive(queue, &frame_info, timeout) == pdTRUE) { - if (pframe) { - *pframe = frame_info; + if (frame) { + *frame = frame_info; } if (len > frame_info.len) { len = frame_info.len; } // if the input buffer pointer is defined copy the data and free queued buffer, // otherwise just return the frame entry - if (frame_info.pbuf && pbuf) { - memcpy(pbuf, frame_info.pbuf, len); - if (!pframe) { - free(frame_info.pbuf); // must free the buffer manually! + if (frame_info.buf && buf) { + memcpy(buf, frame_info.buf, len); + if (!frame) { + free(frame_info.buf); // must free the buffer manually! } } } else { @@ -126,8 +126,8 @@ void queue_flush(QueueHandle_t queue) { frame_entry_t frame_info; while (xQueueReceive(queue, &frame_info, 0) == pdTRUE) { - if ((frame_info.len > 0) && frame_info.pbuf) { - free(frame_info.pbuf); + if ((frame_info.len > 0) && frame_info.buf) { + free(frame_info.buf); } } } diff --git a/modbus/mb_ports/serial/port_serial.c b/modbus/mb_ports/serial/port_serial.c index 1f9459c..a95068b 100644 --- a/modbus/mb_ports/serial/port_serial.c +++ b/modbus/mb_ports/serial/port_serial.c @@ -17,7 +17,7 @@ #define MB_QUEUE_LENGTH (20) #define MB_SERIAL_TOUT (3) #define MB_SERIAL_TX_TOUT_TICKS (pdMS_TO_TICKS(400)) -#define MB_SERIAL_TASK_STACK_SIZE (CONFIG_FMB_PORT_TASK_STACK_SIZE) +#define MB_SERIAL_TASK_STACK_SIZE (CONFIG_FMB_PORT_TASK_STACK_SIZE) #define MB_SERIAL_RX_TOUT_TICKS (pdMS_TO_TICKS(100)) #define MB_SERIAL_MIN_PATTERN_INTERVAL (9) @@ -206,18 +206,19 @@ static void mb_port_ser_task(void *p_args) mb_err_enum_t mb_port_ser_create(mb_serial_opts_t *ser_opts, mb_port_base_t **in_out_obj) { - mb_ser_port_t *pserial = NULL; + mb_ser_port_t *ser_port = NULL; esp_err_t err = ESP_OK; __attribute__((unused)) mb_err_enum_t ret = MB_EILLSTATE; - pserial = (mb_ser_port_t*)calloc(1, sizeof(mb_ser_port_t)); - MB_RETURN_ON_FALSE((pserial && in_out_obj), MB_EILLSTATE, TAG, "mb serial port creation error."); - CRITICAL_SECTION_INIT(pserial->base.lock); - pserial->base.descr = ((mb_port_base_t*)*in_out_obj)->descr; + ser_port = (mb_ser_port_t*)calloc(1, sizeof(mb_ser_port_t)); + MB_GOTO_ON_FALSE((ser_port && in_out_obj), MB_EILLSTATE, error, TAG, "mb serial port creation error."); + + CRITICAL_SECTION_INIT(ser_port->base.lock); + ser_port->base.descr = (*in_out_obj)->descr; ser_opts->data_bits = ((ser_opts->data_bits > UART_DATA_5_BITS) && (ser_opts->data_bits < UART_DATA_BITS_MAX)) ? ser_opts->data_bits : UART_DATA_8_BITS; // Keep the UART communication options - pserial->ser_opts = *ser_opts; + ser_port->ser_opts = *ser_opts; // Configure serial communication parameters uart_config_t uart_cfg = { .baud_rate = ser_opts->baudrate, @@ -233,46 +234,46 @@ mb_err_enum_t mb_port_ser_create(mb_serial_opts_t *ser_opts, mb_port_base_t **in #endif }; // Set UART config - err = uart_param_config(pserial->ser_opts.port, &uart_cfg); + err = uart_param_config(ser_port->ser_opts.port, &uart_cfg); MB_GOTO_ON_FALSE((err == ESP_OK), MB_EILLSTATE, error, TAG, - "%s, mb config failure, uart_param_config() returned (0x%x).", pserial->base.descr.parent_name, (int)err); + "%s, mb config failure, uart_param_config() returned (0x%x).", ser_port->base.descr.parent_name, (int)err); // Install UART driver, and get the queue. - err = uart_driver_install(pserial->ser_opts.port, MB_BUFFER_SIZE, MB_BUFFER_SIZE, - MB_QUEUE_LENGTH, &pserial->uart_queue, MB_PORT_SERIAL_ISR_FLAG); + err = uart_driver_install(ser_port->ser_opts.port, MB_BUFFER_SIZE, MB_BUFFER_SIZE, + MB_QUEUE_LENGTH, &ser_port->uart_queue, MB_PORT_SERIAL_ISR_FLAG); MB_GOTO_ON_FALSE((err == ESP_OK), MB_EILLSTATE, error, TAG, - "%s, mb serial driver failure, retuned (0x%x).", pserial->base.descr.parent_name, (int)err); - err = uart_set_rx_timeout(pserial->ser_opts.port, MB_SERIAL_TOUT); + "%s, mb serial driver failure, retuned (0x%x).", ser_port->base.descr.parent_name, (int)err); + err = uart_set_rx_timeout(ser_port->ser_opts.port, MB_SERIAL_TOUT); MB_GOTO_ON_FALSE((err == ESP_OK), MB_EILLSTATE, error, TAG, - "%s, mb serial set rx timeout failure, returned (0x%x).", pserial->base.descr.parent_name, (int)err); + "%s, mb serial set rx timeout failure, returned (0x%x).", ser_port->base.descr.parent_name, (int)err); // Set always timeout flag to trigger timeout interrupt even after rx fifo full - uart_set_always_rx_timeout(pserial->ser_opts.port, true); - MB_GOTO_ON_FALSE((mb_port_ser_bus_sema_init(&pserial->base)), MB_EILLSTATE, error, TAG, - "%s, mb serial bus semaphore create fail.", pserial->base.descr.parent_name); + uart_set_always_rx_timeout(ser_port->ser_opts.port, true); + MB_GOTO_ON_FALSE((mb_port_ser_bus_sema_init(&ser_port->base)), MB_EILLSTATE, error, TAG, + "%s, mb serial bus semaphore create fail.", ser_port->base.descr.parent_name); // Suspend task on start and then resume when initialization is completed - atomic_store(&(pserial->enabled), false); + atomic_store(&(ser_port->enabled), false); // Create a task to handle UART events BaseType_t status = xTaskCreatePinnedToCore(mb_port_ser_task, "port_serial_task", MB_SERIAL_TASK_STACK_SIZE, - &pserial->base, CONFIG_FMB_PORT_TASK_PRIO, - &pserial->task_handle, CONFIG_FMB_PORT_TASK_AFFINITY); + &ser_port->base, CONFIG_FMB_PORT_TASK_PRIO, + &ser_port->task_handle, CONFIG_FMB_PORT_TASK_AFFINITY); // Force exit from function with failure MB_GOTO_ON_FALSE((status == pdPASS), MB_EILLSTATE, error, TAG, "%s, mb stack serial task creation error, returned (0x%x).", - pserial->base.descr.parent_name, (int)status); - *in_out_obj = &(pserial->base); - ESP_LOGD(TAG, "created object @%p", pserial); + ser_port->base.descr.parent_name, (int)status); + *in_out_obj = &(ser_port->base); + ESP_LOGD(TAG, "created object @%p", ser_port); return MB_ENOERR; error: - if (pserial) { - if (pserial->task_handle) { - vTaskDelete(pserial->task_handle); + if (ser_port) { + if (ser_port->task_handle) { + vTaskDelete(ser_port->task_handle); } - uart_driver_delete(pserial->ser_opts.port); - CRITICAL_SECTION_CLOSE(pserial->base.lock); - mb_port_ser_bus_sema_close(&pserial->base); + uart_driver_delete(ser_port->ser_opts.port); + CRITICAL_SECTION_CLOSE(ser_port->base.lock); + mb_port_ser_bus_sema_close(&ser_port->base); } - free(pserial); + free(ser_port); return MB_EILLSTATE; } @@ -286,24 +287,23 @@ void mb_port_ser_delete(mb_port_base_t *inst) free(port_obj); } -bool mb_port_ser_recv_data(mb_port_base_t *inst, uint8_t **pp_ser_frame, uint16_t *p_ser_length) +bool mb_port_ser_recv_data(mb_port_base_t *inst, uint8_t **ser_frame, uint16_t *p_ser_length) { - MB_RETURN_ON_FALSE((pp_ser_frame && p_ser_length), false, TAG, "mb serial get buffer failure."); + MB_RETURN_ON_FALSE((ser_frame && p_ser_length), false, TAG, "mb serial get buffer failure."); mb_ser_port_t *port_obj = __containerof(inst, mb_ser_port_t, base); uint16_t counter = *p_ser_length ? *p_ser_length : port_obj->recv_length; bool status = false; status = mb_port_ser_bus_sema_take(inst, pdMS_TO_TICKS(mb_port_timer_get_response_time_ms(inst))); - if (status && counter && *pp_ser_frame && atomic_load(&(port_obj->enabled))) { + if (status && counter && *ser_frame && atomic_load(&(port_obj->enabled))) { // Read frame data from the ringbuffer of receiver - counter = uart_read_bytes(port_obj->ser_opts.port, (uint8_t *)*pp_ser_frame, - counter, MB_SERIAL_RX_TOUT_TICKS); + counter = uart_read_bytes(port_obj->ser_opts.port, *ser_frame, counter, MB_SERIAL_RX_TOUT_TICKS); // Stop timer because the new data is received mb_port_timer_disable(inst); // Store the timestamp of received frame port_obj->recv_time_stamp = esp_timer_get_time(); ESP_LOGD(TAG, "%s, received data: %d bytes.", inst->descr.parent_name, (int)counter); - ESP_LOG_BUFFER_HEX_LEVEL(MB_STR_CAT(inst->descr.parent_name, ":PORT_RECV"), (void *)*pp_ser_frame, counter, ESP_LOG_DEBUG); + MB_PRT_BUF(inst->descr.parent_name, ":PORT_RECV", ser_frame, counter, ESP_LOG_DEBUG); int64_t time_delta = (port_obj->recv_time_stamp > port_obj->send_time_stamp) ? (port_obj->recv_time_stamp - port_obj->send_time_stamp) : (port_obj->send_time_stamp - port_obj->recv_time_stamp); @@ -335,8 +335,7 @@ bool mb_port_ser_send_data(mb_port_base_t *inst, uint8_t *p_ser_frame, uint16_t ESP_LOGD(TAG, "%s, tx buffer sent: (%d) bytes.", inst->descr.parent_name, (int)count); MB_RETURN_ON_FALSE((status == ESP_OK), false, TAG, "%s, mb serial sent buffer failure.", inst->descr.parent_name); - ESP_LOG_BUFFER_HEX_LEVEL(MB_STR_CAT(inst->descr.parent_name, ":PORT_SEND"), - (void *)p_ser_frame, ser_length, ESP_LOG_DEBUG); + MB_PRT_BUF(inst->descr.parent_name, ":PORT_SEND", p_ser_frame, ser_length, ESP_LOG_DEBUG); port_obj->send_time_stamp = esp_timer_get_time(); } else { ESP_LOGE(TAG, "%s, send fail state:%d, %p, %u. ", inst->descr.parent_name, (int)port_obj->tx_state_en, p_ser_frame, (unsigned)ser_length); @@ -346,4 +345,3 @@ bool mb_port_ser_send_data(mb_port_base_t *inst, uint8_t *p_ser_frame, uint16_t } #endif - diff --git a/modbus/mb_ports/serial/port_serial_common.h b/modbus/mb_ports/serial/port_serial_common.h index db02a0f..f867f5d 100644 --- a/modbus/mb_ports/serial/port_serial_common.h +++ b/modbus/mb_ports/serial/port_serial_common.h @@ -18,13 +18,13 @@ extern "C" { #endif -typedef enum _mb_comm_mode mb_mode_type_t; +typedef enum mb_comm_mode_enum mb_mode_type_t; typedef struct mb_port_base_t mb_port_base_t; #if (CONFIG_FMB_COMM_MODE_ASCII_EN || CONFIG_FMB_COMM_MODE_RTU_EN) -mb_err_enum_t mb_port_ser_create(mb_serial_opts_t *ser_opts, mb_port_base_t **port_obj); -bool mb_port_ser_recv_data(mb_port_base_t *inst, uint8_t **pp_ser_frame, uint16_t *p_ser_length); +mb_err_enum_t mb_port_ser_create(mb_serial_opts_t *ser_opts, mb_port_base_t **in_out_obj); +bool mb_port_ser_recv_data(mb_port_base_t *inst, uint8_t **ser_frame, uint16_t *p_ser_length); bool mb_port_ser_send_data(mb_port_base_t *inst, uint8_t *p_ser_frame, uint16_t ser_length); void mb_port_ser_enable(mb_port_base_t *inst); void mb_port_ser_disable(mb_port_base_t *inst); diff --git a/modbus/mb_ports/tcp/port_tcp_common.h b/modbus/mb_ports/tcp/port_tcp_common.h index 30d4358..e5e4679 100644 --- a/modbus/mb_ports/tcp/port_tcp_common.h +++ b/modbus/mb_ports/tcp/port_tcp_common.h @@ -36,16 +36,16 @@ mb_err_enum_t mbm_port_tcp_create(mb_tcp_opts_t *tcp_opts, mb_port_base_t **port void mbm_port_tcp_delete(mb_port_base_t *inst); void mbm_port_tcp_enable(mb_port_base_t *inst); void mbm_port_tcp_disable(mb_port_base_t *inst); -bool mbm_port_tcp_send_data(mb_port_base_t *inst, uint8_t address, uint8_t *pframe, uint16_t length); -bool mbm_port_tcp_recv_data(mb_port_base_t *inst, uint8_t **ppframe, uint16_t *plength); +bool mbm_port_tcp_send_data(mb_port_base_t *inst, uint8_t address, uint8_t *frame, uint16_t length); +bool mbm_port_tcp_recv_data(mb_port_base_t *inst, uint8_t **frame, uint16_t *length); bool mbm_port_tcp_add_slave_info(mb_port_base_t *inst, const uint16_t index, const char *ip_str, uint8_t uid); mb_err_enum_t mbs_port_tcp_create(mb_tcp_opts_t *tcp_opts, mb_port_base_t **port_obj); void mbs_port_tcp_delete(mb_port_base_t *inst); void mbs_port_tcp_enable(mb_port_base_t *inst); void mbs_port_tcp_disable(mb_port_base_t *inst); -bool mbs_port_tcp_send_data(mb_port_base_t *inst, uint8_t *pframe, uint16_t length); -bool mbs_port_tcp_recv_data(mb_port_base_t *inst, uint8_t **ppframe, uint16_t *plength); +bool mbs_port_tcp_send_data(mb_port_base_t *inst, uint8_t *frame, uint16_t length); +bool mbs_port_tcp_recv_data(mb_port_base_t *inst, uint8_t **frame, uint16_t *length); #endif diff --git a/modbus/mb_ports/tcp/port_tcp_driver.c b/modbus/mb_ports/tcp/port_tcp_driver.c index 5b73a77..90c1a4f 100644 --- a/modbus/mb_ports/tcp/port_tcp_driver.c +++ b/modbus/mb_ports/tcp/port_tcp_driver.c @@ -60,7 +60,7 @@ const char *driver_event_to_name_r(mb_driver_event_t event) static esp_err_t init_event_fd(void *ctx) { - port_driver_t *pdrv_ctx = MB_GET_DRV_PTR(ctx); + port_driver_t *drv_obj = MB_GET_DRV_PTR(ctx); if (!mb_drv_loop_inst_counter) { esp_vfs_eventfd_config_t config = MB_EVENTFD_CONFIG(); esp_err_t err = esp_vfs_eventfd_register(&config); @@ -68,50 +68,50 @@ static esp_err_t init_event_fd(void *ctx) ESP_LOGE(TAG, "eventfd registration fail."); } } - pdrv_ctx->event_fd = eventfd(0, 0); - MB_RETURN_ON_FALSE((pdrv_ctx->event_fd > 0), ESP_ERR_INVALID_STATE, TAG, "eventfd init error."); - return (pdrv_ctx->event_fd > 0) ? ESP_OK : ESP_ERR_INVALID_STATE; + drv_obj->event_fd = eventfd(0, 0); + MB_RETURN_ON_FALSE((drv_obj->event_fd > 0), ESP_ERR_INVALID_STATE, TAG, "eventfd init error."); + return (drv_obj->event_fd > 0) ? ESP_OK : ESP_ERR_INVALID_STATE; } static esp_err_t close_event_fd(void *ctx) { - port_driver_t *pdrv_ctx = MB_GET_DRV_PTR(ctx); + port_driver_t *drv_obj = MB_GET_DRV_PTR(ctx); if (mb_drv_loop_inst_counter) { - close(pdrv_ctx->event_fd); + close(drv_obj->event_fd); } else { - ESP_LOGD(TAG, "close eventfd (%d).", (int)pdrv_ctx->event_fd); + ESP_LOGD(TAG, "close eventfd (%d).", (int)drv_obj->event_fd); return esp_vfs_eventfd_unregister(); } return ESP_OK; } -int32_t write_event(void *ctx, mb_event_info_t *pevent) +int32_t write_event(void *ctx, mb_event_info_t *event) { - MB_RETURN_ON_FALSE((pevent && ctx), -1, TAG, "wrong arguments."); - port_driver_t *pdrv_ctx = MB_GET_DRV_PTR(ctx); + MB_RETURN_ON_FALSE((event && ctx), -1, TAG, "wrong arguments."); + port_driver_t *drv_obj = MB_GET_DRV_PTR(ctx); esp_err_t err = esp_event_post_to(mb_drv_loop_handle, - MB_EVENT_BASE(ctx), (int32_t)pevent->event_id, pevent, + MB_EVENT_BASE(ctx), event->event_id, event, sizeof(mb_event_info_t), MB_EVENT_TOUT); if ((err != ESP_OK)) { ESP_LOGE(TAG, "%p, event loop send fail, err = %d.", ctx, (int)err); return -1; } // send eventfd to just trigger select - int32_t ret = write(pdrv_ctx->event_fd, (char *)&pevent->val, sizeof(mb_event_info_t)); - return (ret == sizeof(mb_event_info_t)) ? pevent->event_id : -1; + int32_t ret = write(drv_obj->event_fd, (char *)&event->val, sizeof(mb_event_info_t)); + return (ret == sizeof(mb_event_info_t)) ? event->event_id : -1; } -static int32_t read_event(void *ctx, mb_event_info_t *pevent) +static int32_t read_event(void *ctx, mb_event_info_t *event) { - port_driver_t *pdrv_ctx = MB_GET_DRV_PTR(ctx); - MB_RETURN_ON_FALSE(pevent, ESP_ERR_INVALID_STATE, TAG, "cannot get event."); - int ret = read(pdrv_ctx->event_fd, (char *)&pevent->val, sizeof(mb_event_info_t)); - return (ret == sizeof(mb_event_info_t)) ? pevent->event_id : -1; + port_driver_t *drv_obj = MB_GET_DRV_PTR(ctx); + MB_RETURN_ON_FALSE(event, ESP_ERR_INVALID_STATE, TAG, "cannot get event."); + int ret = read(drv_obj->event_fd, (char *)&event->val, sizeof(mb_event_info_t)); + return (ret == sizeof(mb_event_info_t)) ? event->event_id : -1; } static esp_err_t mb_drv_event_loop_init(void *ctx) { - port_driver_t *pdrv_ctx = MB_GET_DRV_PTR(ctx); + port_driver_t *drv_obj = MB_GET_DRV_PTR(ctx); esp_err_t err = ESP_OK; /* Create Event loop without task (will be created separately)*/ esp_event_loop_args_t loop_args = { @@ -123,8 +123,8 @@ static esp_err_t mb_drv_event_loop_init(void *ctx) MB_RETURN_ON_FALSE(((err == ESP_OK) && mb_drv_loop_handle), ESP_ERR_INVALID_STATE, TAG, "create event loop failed, err=%d.", (int)err); } - pdrv_ctx->event_loop_hdl = mb_drv_loop_handle; - if (asprintf(&pdrv_ctx->loop_name, "loop:%p", ctx) == -1) { + drv_obj->event_loop_hdl = mb_drv_loop_handle; + if (asprintf(&drv_obj->loop_name, "loop:%p", ctx) == -1) { abort(); } return err; @@ -132,15 +132,15 @@ static esp_err_t mb_drv_event_loop_init(void *ctx) static esp_err_t mb_drv_event_loop_deinit(void *ctx) { - port_driver_t *pdrv_ctx = MB_GET_DRV_PTR(ctx); + port_driver_t *drv_obj = MB_GET_DRV_PTR(ctx); esp_err_t err = ESP_OK; // delete event loop MB_RETURN_ON_FALSE((mb_drv_loop_handle), ESP_ERR_INVALID_STATE, TAG, "delete event loop failed."); if (mb_drv_loop_inst_counter) { - ESP_LOGD(TAG, "delete loop inst: %s.", pdrv_ctx->loop_name); - free(pdrv_ctx->loop_name); - pdrv_ctx->loop_name = NULL; + ESP_LOGD(TAG, "delete loop inst: %s.", drv_obj->loop_name); + free(drv_obj->loop_name); + drv_obj->loop_name = NULL; mb_drv_loop_inst_counter--; } if (!mb_drv_loop_inst_counter) { @@ -155,38 +155,38 @@ static esp_err_t mb_drv_event_loop_deinit(void *ctx) 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); + port_driver_t *drv_obj = 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 #%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); + ESP_LOGD(TAG, "%p, event #%d, 0x%x, register.", drv_obj, (int)event_num, (int)event); + MB_RETURN_ON_FALSE((drv_obj->event_handler[event_num] == NULL), ESP_ERR_INVALID_ARG, + TAG, "%p, event handler %p, for event %x, is not empty.", drv_obj, drv_obj->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[event_num]); - ESP_LOGD(TAG, "%p, registered event handler %p, event 0x%x", pdrv_ctx, pdrv_ctx->event_handler[event_num], (int)event); + fp, ctx, &drv_obj->event_handler[event_num]); + ESP_LOGD(TAG, "%p, registered event handler %p, event 0x%x", drv_obj, drv_obj->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]); + TAG, "%p, event handler %p, registration error.", drv_obj, drv_obj->event_handler[event_num]); return ESP_OK; } 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); + port_driver_t *drv_obj = 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 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); + ESP_LOGD(TAG, "%p, event handler %p, event 0x%x, unregister.", drv_obj, drv_obj->event_handler[event_num], (int)event); + MB_RETURN_ON_FALSE((drv_obj->event_handler[event_num]), ESP_ERR_INVALID_ARG, + TAG, "%p, event handler %p, for event %x, is incorrect.", drv_obj, drv_obj->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[event_num]); - pdrv_ctx->event_handler[event_num] = NULL; + MB_EVENT_BASE(ctx), (int32_t)event, drv_obj->event_handler[event_num]); + drv_obj->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); + TAG, "%p, event handler %p, instance unregister with, error = %d", drv_obj, drv_obj->event_handler[event_num], (int)ret); return ESP_OK; } @@ -222,37 +222,37 @@ static void delete_queues(mb_node_info_t *pmb_node) inline void mb_drv_lock(void *ctx) { - port_driver_t *pdrv_ctx = MB_GET_DRV_PTR(ctx); - CRITICAL_SECTION_LOCK(pdrv_ctx->lock); + port_driver_t *drv_obj = MB_GET_DRV_PTR(ctx); + CRITICAL_SECTION_LOCK(drv_obj->lock); } inline void mb_drv_unlock(void *ctx) { - port_driver_t *pdrv_ctx = MB_GET_DRV_PTR(ctx); - CRITICAL_SECTION_UNLOCK(pdrv_ctx->lock); + port_driver_t *drv_obj = MB_GET_DRV_PTR(ctx); + CRITICAL_SECTION_UNLOCK(drv_obj->lock); } __attribute__((unused)) mb_sock_state_t mb_drv_get_node_state(void *ctx, int fd) { - port_driver_t *pdrv_ctx = MB_GET_DRV_PTR(ctx); - mb_node_info_t *pnode = pdrv_ctx->mb_nodes[fd]; + port_driver_t *drv_obj = MB_GET_DRV_PTR(ctx); + mb_node_info_t *pnode = drv_obj->mb_nodes[fd]; return (pnode) ? atomic_load(&pnode->addr_info.state) : MB_SOCK_STATE_UNDEF; } void mb_drv_check_suspend_shutdown(void *ctx) { - port_driver_t *pdrv_ctx = MB_GET_DRV_PTR(ctx); + port_driver_t *drv_obj = MB_GET_DRV_PTR(ctx); - if (pdrv_ctx->close_done_sema) { + if (drv_obj->close_done_sema) { mb_status_flags_t status = mb_drv_wait_status_flag(ctx, (MB_FLAG_SHUTDOWN | MB_FLAG_SUSPEND), 0); ESP_LOGD(TAG, "%p, driver check shutdown (%d)...", ctx, (int)status); if (status & MB_FLAG_SHUTDOWN) { - xSemaphoreGive(pdrv_ctx->close_done_sema); + xSemaphoreGive(drv_obj->close_done_sema); ESP_LOGD(TAG, "%p, driver task shutdown...", ctx); vTaskDelete(NULL); } else if (status & MB_FLAG_SUSPEND) { - xSemaphoreGive(pdrv_ctx->close_done_sema); + xSemaphoreGive(drv_obj->close_done_sema); ESP_LOGD(TAG, "%p, driver task is suspended...", ctx); vTaskSuspend(NULL); } @@ -261,20 +261,20 @@ void mb_drv_check_suspend_shutdown(void *ctx) mb_status_flags_t mb_drv_set_status_flag(void *ctx, mb_status_flags_t mask) { - port_driver_t *pdrv_ctx = MB_GET_DRV_PTR(ctx); - return (mb_status_flags_t)xEventGroupSetBits(pdrv_ctx->status_flags_hdl, (EventBits_t)mask); + port_driver_t *drv_obj = MB_GET_DRV_PTR(ctx); + return (mb_status_flags_t)xEventGroupSetBits(drv_obj->status_flags_hdl, (EventBits_t)mask); } mb_status_flags_t mb_drv_clear_status_flag(void *ctx, mb_status_flags_t mask) { - port_driver_t *pdrv_ctx = MB_GET_DRV_PTR(ctx); - return (mb_status_flags_t)xEventGroupClearBits(pdrv_ctx->status_flags_hdl, (EventBits_t)mask); + port_driver_t *drv_obj = MB_GET_DRV_PTR(ctx); + return (mb_status_flags_t)xEventGroupClearBits(drv_obj->status_flags_hdl, (EventBits_t)mask); } mb_status_flags_t mb_drv_wait_status_flag(void *ctx, mb_status_flags_t mask, TickType_t ticks) { - port_driver_t *pdrv_ctx = MB_GET_DRV_PTR(ctx); - return (mb_status_flags_t)xEventGroupWaitBits(pdrv_ctx->status_flags_hdl, + port_driver_t *drv_obj = MB_GET_DRV_PTR(ctx); + return (mb_status_flags_t)xEventGroupWaitBits(drv_obj->status_flags_hdl, (BaseType_t)(mask), pdFALSE, pdFALSE, @@ -284,87 +284,87 @@ mb_status_flags_t mb_drv_wait_status_flag(void *ctx, mb_status_flags_t mask, Tic int mb_drv_open(void *ctx, mb_uid_info_t addr_info, int flags) { int fd = UNDEF_FD; - port_driver_t *pdrv_ctx = MB_GET_DRV_PTR(ctx); - mb_node_info_t *pnode_info = NULL; + port_driver_t *drv_obj = MB_GET_DRV_PTR(ctx); + mb_node_info_t *node_ptr = NULL; // Find free fd and initialize for (fd = 0; fd < MB_MAX_FDS; fd++) { - pnode_info = pdrv_ctx->mb_nodes[fd]; - if (!pnode_info) { - pnode_info = calloc(1, sizeof(mb_node_info_t)); + node_ptr = drv_obj->mb_nodes[fd]; + if (!node_ptr) { + node_ptr = calloc(1, sizeof(mb_node_info_t)); mb_drv_lock(ctx); - if (!pnode_info) { + if (!node_ptr) { goto err; } ESP_LOGD(TAG, "%p, open vfd: %d, sl_addr: %02x, node: %s:%u", ctx, fd, (int8_t)addr_info.uid, addr_info.ip_addr_str, (unsigned)addr_info.port); - if (init_queues(pnode_info) != ESP_OK) { + if (init_queues(node_ptr) != ESP_OK) { goto err; } - if (pdrv_ctx->mb_node_open_count > MB_MAX_FDS) { - ESP_LOGD(TAG, "Exceeded maximum node count: %d", pdrv_ctx->mb_node_open_count); + if (drv_obj->mb_node_open_count > MB_MAX_FDS) { + ESP_LOGD(TAG, "Exceeded maximum node count: %d", drv_obj->mb_node_open_count); goto err; } - pdrv_ctx->mb_node_open_count++; - pnode_info->index = fd; - pnode_info->fd = fd; - pnode_info->sock_id = addr_info.fd; - pnode_info->error = -1; - pnode_info->recv_err = -1; - pnode_info->addr_info = addr_info; - //pnode_info->addr_info.ip_addr_str = NULL; - pnode_info->addr_info.index = fd; - pnode_info->send_time = esp_timer_get_time(); - pnode_info->recv_time = esp_timer_get_time(); - pnode_info->tid_counter = 0; - pnode_info->send_counter = 0; - pnode_info->recv_counter = 0; - pnode_info->is_blocking = ((flags & O_NONBLOCK) == 0); - pdrv_ctx->mb_nodes[fd] = pnode_info; + drv_obj->mb_node_open_count++; + node_ptr->index = fd; + node_ptr->fd = fd; + node_ptr->sock_id = addr_info.fd; + node_ptr->error = -1; + node_ptr->recv_err = -1; + node_ptr->addr_info = addr_info; + //node_ptr->addr_info.ip_addr_str = NULL; + node_ptr->addr_info.index = fd; + node_ptr->send_time = esp_timer_get_time(); + node_ptr->recv_time = esp_timer_get_time(); + node_ptr->tid_counter = 0; + node_ptr->send_counter = 0; + node_ptr->recv_counter = 0; + node_ptr->is_blocking = ((flags & O_NONBLOCK) == 0); + drv_obj->mb_nodes[fd] = node_ptr; // mark opened node in the open set - FD_SET(fd, &pdrv_ctx->open_set); + FD_SET(fd, &drv_obj->open_set); mb_drv_unlock(ctx); - MB_SET_NODE_STATE(pnode_info, MB_SOCK_STATE_OPENED); + MB_SET_NODE_STATE(node_ptr, MB_SOCK_STATE_OPENED); DRIVER_SEND_EVENT(ctx, MB_EVENT_OPEN, fd); return fd; } } err: - delete_queues(pnode_info); - free(pnode_info); - pdrv_ctx->mb_nodes[fd] = NULL; + delete_queues(node_ptr); + free(node_ptr); + drv_obj->mb_nodes[fd] = NULL; mb_drv_unlock(ctx); return UNDEF_FD; } mb_node_info_t *mb_drv_get_node(void *ctx, int fd) { - port_driver_t *pdrv_ctx = MB_GET_DRV_PTR(ctx); - return pdrv_ctx->mb_nodes[fd]; + port_driver_t *drv_obj = MB_GET_DRV_PTR(ctx); + return drv_obj->mb_nodes[fd]; } // writes data into tx queue ssize_t mb_drv_write(void *ctx, int fd, const void *data, size_t size) { - port_driver_t *pdrv_ctx = MB_GET_DRV_PTR(ctx); + port_driver_t *drv_obj = MB_GET_DRV_PTR(ctx); ssize_t ret = -1; if (size == 0) { return 0; } - mb_node_info_t *pnode_info = pdrv_ctx->mb_nodes[fd]; - if (!pnode_info) { + mb_node_info_t *node_ptr = drv_obj->mb_nodes[fd]; + if (!node_ptr) { errno = EBADF; return 0; } - if (MB_GET_NODE_STATE(pnode_info) >= MB_SOCK_STATE_CONNECTED) { - if (queue_push(pnode_info->tx_queue, (void *)data, size, NULL) == ESP_OK) { + if (MB_GET_NODE_STATE(node_ptr) >= MB_SOCK_STATE_CONNECTED) { + if (queue_push(node_ptr->tx_queue, (void *)data, size, NULL) == ESP_OK) { ret = size; // Inform FSM that is new frame data is ready to be send - DRIVER_SEND_EVENT(ctx, MB_EVENT_SEND_DATA, pnode_info->index); + DRIVER_SEND_EVENT(ctx, MB_EVENT_SEND_DATA, node_ptr->index); } else { // I/O error errno = EIO; @@ -379,15 +379,15 @@ ssize_t mb_drv_write(void *ctx, int fd, const void *data, size_t size) // reads data from rx queue ssize_t mb_drv_read(void *ctx, int fd, void *data, size_t size) { - port_driver_t *pdrv_ctx = MB_GET_DRV_PTR(ctx); - mb_node_info_t *pnode_info = pdrv_ctx->mb_nodes[fd]; - if (!pnode_info) { + port_driver_t *drv_obj = MB_GET_DRV_PTR(ctx); + mb_node_info_t *node_ptr = drv_obj->mb_nodes[fd]; + if (!node_ptr) { errno = EBADF; return 0; } // fd might be in process of closing (close was already called but preempted) - if (MB_GET_NODE_STATE(pnode_info) < MB_SOCK_STATE_CONNECTED) { + if (MB_GET_NODE_STATE(node_ptr) < MB_SOCK_STATE_CONNECTED) { // bad file desc errno = EBADF; return -1; @@ -398,7 +398,7 @@ ssize_t mb_drv_read(void *ctx, int fd, void *data, size_t size) } ssize_t actual_size = -1; - if ((actual_size = queue_pop(pnode_info->rx_queue, data, size, NULL)) < 0) { + if ((actual_size = queue_pop(node_ptr->rx_queue, data, size, NULL)) < 0) { errno = EAGAIN; } @@ -407,109 +407,109 @@ ssize_t mb_drv_read(void *ctx, int fd, void *data, size_t size) int mb_drv_close(void *ctx, int fd) { - port_driver_t *pdrv_ctx = MB_GET_DRV_PTR(ctx); - mb_node_info_t *pnode_info = pdrv_ctx->mb_nodes[fd]; // get address of configuration + port_driver_t *drv_obj = MB_GET_DRV_PTR(ctx); + mb_node_info_t *node_ptr = drv_obj->mb_nodes[fd]; // get address of configuration - if (!pnode_info) { + if (!node_ptr) { // not valid opened fd errno = EBADF; return -1; } mb_drv_lock(ctx); // stop socket - if (MB_GET_NODE_STATE(pnode_info) != MB_SOCK_STATE_CLOSED) { + if (MB_GET_NODE_STATE(node_ptr) != MB_SOCK_STATE_CLOSED) { // Do we need to close connection, if the close event is not run - if ((pnode_info->sock_id > 0) && (FD_ISSET(pnode_info->sock_id, &pdrv_ctx->conn_set))) + if ((node_ptr->sock_id > 0) && (FD_ISSET(node_ptr->sock_id, &drv_obj->conn_set))) { - FD_CLR(pnode_info->sock_id, &pdrv_ctx->conn_set); - if (pdrv_ctx->node_conn_count) + FD_CLR(node_ptr->sock_id, &drv_obj->conn_set); + if (drv_obj->node_conn_count) { - pdrv_ctx->node_conn_count--; + drv_obj->node_conn_count--; } } - port_close_connection((mb_node_info_t *)pnode_info); + port_close_connection(node_ptr); } - MB_SET_NODE_STATE(pnode_info, MB_SOCK_STATE_CLOSED); - FD_CLR(fd, &pdrv_ctx->open_set); - delete_queues(pnode_info); - if (pdrv_ctx->mb_node_open_count) { - pdrv_ctx->mb_node_open_count--; + MB_SET_NODE_STATE(node_ptr, MB_SOCK_STATE_CLOSED); + FD_CLR(fd, &drv_obj->open_set); + delete_queues(node_ptr); + if (drv_obj->mb_node_open_count) { + drv_obj->mb_node_open_count--; } - if (pnode_info->addr_info.node_name_str != pnode_info->addr_info.ip_addr_str) { - free((void *)pnode_info->addr_info.ip_addr_str); // node ip addr string shall be freed + if (node_ptr->addr_info.node_name_str != node_ptr->addr_info.ip_addr_str) { + free((void *)node_ptr->addr_info.ip_addr_str); // node ip addr string shall be freed } - free((void *)pnode_info->addr_info.node_name_str); - pnode_info->addr_info.node_name_str = NULL; - pnode_info->addr_info.ip_addr_str = NULL; - free(pnode_info); - pdrv_ctx->mb_nodes[fd] = NULL; + free((void *)node_ptr->addr_info.node_name_str); + node_ptr->addr_info.node_name_str = NULL; + node_ptr->addr_info.ip_addr_str = NULL; + free(node_ptr); + drv_obj->mb_nodes[fd] = NULL; mb_drv_unlock(ctx); return 0; } -mb_node_info_t *mb_drv_get_next_node_from_set(void *ctx, int *pfd, fd_set *pfdset) +mb_node_info_t *mb_drv_get_next_node_from_set(void *ctx, int *fd_ptr, fd_set *fdset) { - port_driver_t *pdrv_ctx = MB_GET_DRV_PTR(ctx); - if (!pfdset || !pfd) { + port_driver_t *drv_obj = MB_GET_DRV_PTR(ctx); + if (!fdset || !fd_ptr) { return NULL; } - mb_node_info_t *pnode_info = NULL; - for (int fd = *pfd; fd < MB_MAX_FDS; fd++) { - pnode_info = pdrv_ctx->mb_nodes[fd]; - if (pnode_info && (pnode_info->sock_id > 0) - && (MB_GET_NODE_STATE(pnode_info) >= MB_SOCK_STATE_CONNECTED) - && (FD_ISSET(pnode_info->index, pfdset) || (FD_ISSET(pnode_info->sock_id, pfdset)))) { - *pfd = fd; - //FD_CLR(pnode_info->sock_id, pfdset); - return pnode_info; + mb_node_info_t *node_ptr = NULL; + for (int fd = *fd_ptr; fd < MB_MAX_FDS; fd++) { + node_ptr = drv_obj->mb_nodes[fd]; + if (node_ptr && (node_ptr->sock_id > 0) + && (MB_GET_NODE_STATE(node_ptr) >= MB_SOCK_STATE_CONNECTED) + && (FD_ISSET(node_ptr->index, fdset) || (FD_ISSET(node_ptr->sock_id, fdset)))) { + *fd_ptr = fd; + //FD_CLR(node_ptr->sock_id, fdset); + return node_ptr; } } return NULL; } -mb_node_info_t *mb_drv_get_node_info_from_addr(void *ctx, uint8_t node_addr) +mb_node_info_t *mb_drv_get_node_info_from_addr(void *ctx, uint8_t uid) { - port_driver_t *pdrv_ctx = MB_GET_DRV_PTR(ctx); - mb_node_info_t *pnode_info = NULL; + port_driver_t *drv_obj = MB_GET_DRV_PTR(ctx); + mb_node_info_t *node_ptr = NULL; for (int fd = 0; fd < MB_MAX_FDS; fd++) { - pnode_info = pdrv_ctx->mb_nodes[fd]; - if (pnode_info && pnode_info->addr_info.uid == node_addr) { - return pnode_info; + node_ptr = drv_obj->mb_nodes[fd]; + if (node_ptr && node_ptr->addr_info.uid == uid) { + return node_ptr; } } return NULL; } -static int mb_drv_register_fds(void *ctx, fd_set *pfdset) +static int mb_drv_register_fds(void *ctx, fd_set *fdset) { - mb_node_info_t *pnode_info = NULL; - port_driver_t *pdrv_ctx = MB_GET_DRV_PTR(ctx); + mb_node_info_t *node_ptr = NULL; + port_driver_t *drv_obj = MB_GET_DRV_PTR(ctx); // Setup select waiting for eventfd && socket events - FD_ZERO(pfdset); + FD_ZERO(fdset); int max_fd = UNDEF_FD; // Add to the set all connected slaves for (int i = 0; i < MB_MAX_FDS; i++) { - pnode_info = pdrv_ctx->mb_nodes[i]; - if (pnode_info && pnode_info->sock_id && (MB_GET_NODE_STATE(pnode_info) >= MB_SOCK_STATE_CONNECTED)) { - MB_ADD_FD(pnode_info->sock_id, max_fd, pfdset); + node_ptr = drv_obj->mb_nodes[i]; + if (node_ptr && node_ptr->sock_id && (MB_GET_NODE_STATE(node_ptr) >= MB_SOCK_STATE_CONNECTED)) { + MB_ADD_FD(node_ptr->sock_id, max_fd, fdset); } } // Add event fd events to the set to handle them in one select - MB_ADD_FD(pdrv_ctx->event_fd, max_fd, pfdset); + MB_ADD_FD(drv_obj->event_fd, max_fd, fdset); // Add listen socket to handle incoming connections (for slave only) - MB_ADD_FD(pdrv_ctx->listen_sock_fd, max_fd, pfdset); + MB_ADD_FD(drv_obj->listen_sock_fd, max_fd, fdset); return max_fd; } // Wait socket ready event during timeout -static int mb_drv_wait_fd_events(void *ctx, fd_set *pfdset, fd_set *perrset, int time_ms) +static int mb_drv_wait_fd_events(void *ctx, fd_set *fdset, fd_set *perrset, int time_ms) { - fd_set readset = *pfdset; + fd_set readset = *fdset; int ret = 0; struct timeval tv; - if (!ctx || !pfdset) { + if (!ctx || !fdset) { return -1; } @@ -529,52 +529,52 @@ static int mb_drv_wait_fd_events(void *ctx, fd_set *pfdset, fd_set *perrset, int } else if (ret < 0) { ret = -1; } - *pfdset = readset; + *fdset = readset; return ret; } esp_err_t mb_drv_start_task(void *ctx) { - port_driver_t *pdrv_ctx = MB_GET_DRV_PTR(ctx); + port_driver_t *drv_obj = MB_GET_DRV_PTR(ctx); (void)mb_drv_clear_status_flag(ctx, MB_FLAG_SUSPEND); ESP_LOGD(TAG, "%p, resume tcp driver task.", ctx); - vTaskResume(pdrv_ctx->mb_tcp_task_handle); + vTaskResume(drv_obj->mb_tcp_task_handle); return ESP_OK; } esp_err_t mb_drv_stop_task(void *ctx) { - port_driver_t *pdrv_ctx = MB_GET_DRV_PTR(ctx); + port_driver_t *drv_obj = MB_GET_DRV_PTR(ctx); esp_err_t err = ESP_ERR_TIMEOUT; - if (!pdrv_ctx->close_done_sema) { - pdrv_ctx->close_done_sema = xSemaphoreCreateBinary(); + if (!drv_obj->close_done_sema) { + drv_obj->close_done_sema = xSemaphoreCreateBinary(); } (void)mb_drv_set_status_flag(ctx, MB_FLAG_SUSPEND); // Check if we can safely suspend the port task (workaround for issue with deadlock in suspend) - if (!pdrv_ctx->close_done_sema + if (!drv_obj->close_done_sema || !(mb_drv_wait_status_flag(ctx, MB_FLAG_SUSPEND, 1) & MB_FLAG_SUSPEND) - || (xSemaphoreTake(pdrv_ctx->close_done_sema, pdMS_TO_TICKS(MB_WAIT_DONE_MS)) != pdTRUE) + || (xSemaphoreTake(drv_obj->close_done_sema, pdMS_TO_TICKS(MB_WAIT_DONE_MS)) != pdTRUE) ) { ESP_LOGD(TAG, "%p, could not stop driver task during timeout.", ctx); - vTaskSuspend(pdrv_ctx->mb_tcp_task_handle); + vTaskSuspend(drv_obj->mb_tcp_task_handle); err = ESP_OK; } ESP_LOGD(TAG, "%p, stop tcp driver task.", ctx); - if (pdrv_ctx->close_done_sema) { - vSemaphoreDelete(pdrv_ctx->close_done_sema); - pdrv_ctx->close_done_sema = NULL; + if (drv_obj->close_done_sema) { + vSemaphoreDelete(drv_obj->close_done_sema); + drv_obj->close_done_sema = NULL; } return err; } -err_t mb_drv_check_node_state(void *ctx, int *pfd, uint32_t timeout_ms) +err_t mb_drv_check_node_state(void *ctx, int *fd_ptr, uint32_t timeout_ms) { - port_driver_t *pdrv_ctx = MB_GET_DRV_PTR(ctx); + port_driver_t *drv_obj = MB_GET_DRV_PTR(ctx); mb_node_info_t *pnode = NULL; err_t err = ERR_TIMEOUT; - pnode = mb_drv_get_next_node_from_set(ctx, pfd, &pdrv_ctx->conn_set); - if (pnode && FD_ISSET(pnode->sock_id, &pdrv_ctx->conn_set)) { + pnode = mb_drv_get_next_node_from_set(ctx, fd_ptr, &drv_obj->conn_set); + if (pnode && FD_ISSET(pnode->sock_id, &drv_obj->conn_set)) { uint64_t last_read_div_us = (esp_timer_get_time() - pnode->recv_time); ESP_LOGD(TAG, "%p, node: %d, sock: %d, IP:%s, check connection timeout = %" PRId64 ", rcv_time: %" PRId64 " %" PRId32, ctx, (int)pnode->index, (int)pnode->sock_id, pnode->addr_info.ip_addr_str, @@ -597,10 +597,12 @@ err_t mb_drv_check_node_state(void *ctx, int *pfd, uint32_t timeout_ms) void mb_drv_tcp_task(void *ctx) { - port_driver_t *pdrv_ctx = MB_GET_DRV_PTR(ctx); + port_driver_t *drv_obj = MB_GET_DRV_PTR(ctx); ESP_LOGD(TAG, "Start of driver task."); while (1) { fd_set readset, errorset; + FD_ZERO(&readset); + FD_ZERO(&errorset); // check all active socket and fd events int ret = mb_drv_wait_fd_events(ctx, &readset, &errorset, MB_SELECT_WAIT_MS); if (ret == ERR_TIMEOUT) { @@ -614,7 +616,7 @@ void mb_drv_tcp_task(void *ctx) ESP_LOGD(TAG, "%p, socket error, fdset: %" PRIx64, ctx, *(uint64_t *)&errorset); } else { // Is the fd event triggered, process the event - if (pdrv_ctx->event_fd && FD_ISSET(pdrv_ctx->event_fd, &readset)) { + if (drv_obj->event_fd && FD_ISSET(drv_obj->event_fd, &readset)) { mb_event_info_t mb_event = {0}; int32_t event_id = read_event(ctx, &mb_event); ESP_LOGD(TAG, "%p, fd event get: 0x%02x:%d, %s", @@ -625,15 +627,15 @@ void mb_drv_tcp_task(void *ctx) if (err != ESP_OK) { ESP_LOGE(TAG, "%p, event loop run, returns fail: %x", ctx, (int)err); } - } else if (pdrv_ctx->listen_sock_fd && FD_ISSET(pdrv_ctx->listen_sock_fd, &readset)) { + } else if (drv_obj->listen_sock_fd && FD_ISSET(drv_obj->listen_sock_fd, &readset)) { // If something happened on the listen socket, then it is an incoming connection. ESP_LOGD(TAG, "%p, listen_sock is active.", ctx); mb_uid_info_t node_info; - int sock_id = port_accept_connection(pdrv_ctx->listen_sock_fd, &node_info); + int sock_id = port_accept_connection(drv_obj->listen_sock_fd, &node_info); if (sock_id) { - int fd = mb_drv_open(pdrv_ctx, node_info, 0); + int fd = mb_drv_open(drv_obj, node_info, 0); if (fd < 0) { - ESP_LOGE(TAG, "%p, unable to open node: %s", pdrv_ctx, node_info.ip_addr_str); + ESP_LOGE(TAG, "%p, unable to open node: %s", drv_obj, node_info.ip_addr_str); } else { DRIVER_SEND_EVENT(ctx, MB_EVENT_CONNECT, fd); } @@ -642,38 +644,38 @@ void mb_drv_tcp_task(void *ctx) // socket event is ready, process each socket event mb_drv_check_suspend_shutdown(ctx); int curr_fd = 0; - mb_node_info_t *pnode_info = NULL; + mb_node_info_t *node_ptr = NULL; ESP_LOGD(TAG, "%p, socket event active: %" PRIx64, ctx, *(uint64_t *)&readset); - while(((pnode_info = mb_drv_get_next_node_from_set(ctx, &curr_fd, &readset)) + while(((node_ptr = mb_drv_get_next_node_from_set(ctx, &curr_fd, &readset)) && (curr_fd < MB_MAX_FDS))) { - if (FD_ISSET(pnode_info->sock_id, &pdrv_ctx->conn_set)) { + if (FD_ISSET(node_ptr->sock_id, &drv_obj->conn_set)) { // The data is ready in the socket, read frame and queue - FD_CLR(pnode_info->sock_id, &readset); - int ret = port_read_packet(pnode_info); + FD_CLR(node_ptr->sock_id, &readset); + int ret = port_read_packet(node_ptr); if (ret > 0) { - ESP_LOGD(TAG, "%p, "MB_NODE_FMT(", frame received."), ctx, (int)pnode_info->fd, - (int)pnode_info->sock_id, pnode_info->addr_info.ip_addr_str); + ESP_LOGD(TAG, "%p, "MB_NODE_FMT(", frame received."), ctx, (int)node_ptr->fd, + (int)node_ptr->sock_id, node_ptr->addr_info.ip_addr_str); mb_drv_lock(ctx); - pnode_info->recv_time = esp_timer_get_time(); + node_ptr->recv_time = esp_timer_get_time(); mb_drv_unlock(ctx); - DRIVER_SEND_EVENT(ctx, MB_EVENT_RECV_DATA, pnode_info->index); + DRIVER_SEND_EVENT(ctx, MB_EVENT_RECV_DATA, node_ptr->index); } else if (ret == ERR_TIMEOUT) { - ESP_LOGD(TAG, "%p, "MB_NODE_FMT(", frame read timeout or closed connection."), ctx, (int)pnode_info->fd, - (int)pnode_info->sock_id, pnode_info->addr_info.ip_addr_str); + ESP_LOGD(TAG, "%p, "MB_NODE_FMT(", frame read timeout or closed connection."), ctx, (int)node_ptr->fd, + (int)node_ptr->sock_id, node_ptr->addr_info.ip_addr_str); } else if (ret == ERR_BUF) { // After retries a response with incorrect TID received, process failure. - pdrv_ctx->event_cbs.mb_sync_event_cb(pdrv_ctx->event_cbs.port_arg, MB_SYNC_EVENT_RECV_FAIL); - ESP_LOGD(TAG, "%p, "MB_NODE_FMT(", frame error."), ctx, (int)pnode_info->fd, - (int)pnode_info->sock_id, pnode_info->addr_info.ip_addr_str); + drv_obj->event_cbs.mb_sync_event_cb(drv_obj->event_cbs.port_arg, MB_SYNC_EVENT_RECV_FAIL); + ESP_LOGD(TAG, "%p, "MB_NODE_FMT(", frame error."), ctx, (int)node_ptr->fd, + (int)node_ptr->sock_id, node_ptr->addr_info.ip_addr_str); } else { if (ret == ERR_CONN) { - ESP_LOGD(TAG, "%p, "MB_NODE_FMT(", connection lost."), ctx, (int)pnode_info->fd, - (int)pnode_info->sock_id, pnode_info->addr_info.ip_addr_str); - DRIVER_SEND_EVENT(ctx, MB_EVENT_ERROR, pnode_info->index); + ESP_LOGD(TAG, "%p, "MB_NODE_FMT(", connection lost."), ctx, (int)node_ptr->fd, + (int)node_ptr->sock_id, node_ptr->addr_info.ip_addr_str); + DRIVER_SEND_EVENT(ctx, MB_EVENT_ERROR, node_ptr->index); } else { - ESP_LOGD(TAG, "%p, "MB_NODE_FMT(", critical read error=%d, errno=%u."), ctx, (int)pnode_info->fd, - (int)pnode_info->sock_id, pnode_info->addr_info.ip_addr_str, (int)ret, (unsigned)errno); - DRIVER_SEND_EVENT(ctx, MB_EVENT_ERROR, pnode_info->index); + ESP_LOGD(TAG, "%p, "MB_NODE_FMT(", critical read error=%d, errno=%u."), ctx, (int)node_ptr->fd, + (int)node_ptr->sock_id, node_ptr->addr_info.ip_addr_str, (int)ret, (unsigned)errno); + DRIVER_SEND_EVENT(ctx, MB_EVENT_ERROR, node_ptr->index); } } } @@ -768,24 +770,24 @@ error: esp_err_t mb_drv_unregister(void *ctx) { - port_driver_t *pdrv_ctx = MB_GET_DRV_PTR(ctx); - ESP_LOGD(TAG, "%p, driver unregister.", pdrv_ctx); + port_driver_t *drv_obj = MB_GET_DRV_PTR(ctx); + ESP_LOGD(TAG, "%p, driver unregister.", drv_obj); (void)mb_drv_set_status_flag(ctx, MB_FLAG_SHUTDOWN); - pdrv_ctx->close_done_sema = xSemaphoreCreateBinary(); + drv_obj->close_done_sema = xSemaphoreCreateBinary(); // if no semaphore (alloc issues) or couldn't acquire it, just delete the task - if (!pdrv_ctx->close_done_sema + if (!drv_obj->close_done_sema || !(mb_drv_wait_status_flag(ctx, MB_FLAG_SHUTDOWN, 0) & MB_FLAG_SHUTDOWN) - || (xSemaphoreTake(pdrv_ctx->close_done_sema, pdMS_TO_TICKS(MB_WAIT_DONE_MS)) != pdTRUE) + || (xSemaphoreTake(drv_obj->close_done_sema, pdMS_TO_TICKS(MB_WAIT_DONE_MS)) != pdTRUE) ) { - ESP_LOGD(TAG, "%p, driver tasks couldn't exit within timeout -> abruptly deleting the task.", pdrv_ctx); - vTaskDelete(pdrv_ctx->mb_tcp_task_handle); + ESP_LOGD(TAG, "%p, driver tasks couldn't exit within timeout -> abruptly deleting the task.", drv_obj); + vTaskDelete(drv_obj->mb_tcp_task_handle); } mb_drv_event_loop_deinit(ctx); - if (pdrv_ctx->close_done_sema) { - vSemaphoreDelete(pdrv_ctx->close_done_sema); - pdrv_ctx->close_done_sema = NULL; + if (drv_obj->close_done_sema) { + vSemaphoreDelete(drv_obj->close_done_sema); + drv_obj->close_done_sema = NULL; } esp_err_t err = close_event_fd(ctx); @@ -793,38 +795,38 @@ esp_err_t mb_drv_unregister(void *ctx) ESP_LOGE(TAG, "could not close the eventfd handle, err = %d. Already closed?", err); } - if (pdrv_ctx->listen_sock_fd) { - shutdown(pdrv_ctx->listen_sock_fd, SHUT_RDWR); - close(pdrv_ctx->listen_sock_fd); - pdrv_ctx->listen_sock_fd = UNDEF_FD; + if (drv_obj->listen_sock_fd) { + shutdown(drv_obj->listen_sock_fd, SHUT_RDWR); + close(drv_obj->listen_sock_fd); + drv_obj->listen_sock_fd = UNDEF_FD; } for (int i = 0; i < MB_MAX_FDS; i++) { - mb_node_info_t *pnode_info = pdrv_ctx->mb_nodes[i]; - if (pnode_info) { - ESP_LOGD(TAG, "%p, close node instance #%d(%s).", ctx, i, pnode_info->addr_info.node_name_str); + mb_node_info_t *node_ptr = drv_obj->mb_nodes[i]; + if (node_ptr) { + ESP_LOGD(TAG, "%p, close node instance #%d(%s).", ctx, i, node_ptr->addr_info.node_name_str); mb_drv_close(ctx, i); } } - free(pdrv_ctx->mb_nodes); // free the node info address array - pdrv_ctx->mb_nodes = NULL; + free(drv_obj->mb_nodes); // free the node info address array + drv_obj->mb_nodes = NULL; - vEventGroupDelete(pdrv_ctx->status_flags_hdl); + vEventGroupDelete(drv_obj->status_flags_hdl); - pdrv_ctx->is_registered = false; - CRITICAL_SECTION_CLOSE(pdrv_ctx->lock); - free(pdrv_ctx); + drv_obj->is_registered = false; + CRITICAL_SECTION_CLOSE(drv_obj->lock); + free(drv_obj); return ESP_OK; } void mb_drv_set_cb(void *ctx, void *conn_cb, void *arg) { - port_driver_t *pdrv_ctx = MB_GET_DRV_PTR(ctx); + port_driver_t *drv_obj = MB_GET_DRV_PTR(ctx); mb_drv_lock(ctx); - pdrv_ctx->event_cbs.on_conn_done_cb = conn_cb; - pdrv_ctx->event_cbs.arg = arg; + drv_obj->event_cbs.on_conn_done_cb = conn_cb; + drv_obj->event_cbs.arg = arg; mb_drv_unlock(ctx); } diff --git a/modbus/mb_ports/tcp/port_tcp_driver.h b/modbus/mb_ports/tcp/port_tcp_driver.h index b28c6a1..31db918 100644 --- a/modbus/mb_ports/tcp/port_tcp_driver.h +++ b/modbus/mb_ports/tcp/port_tcp_driver.h @@ -90,15 +90,15 @@ typedef struct _port_driver port_driver_t; #define MB_EVENT_BASE(context) (__extension__( \ { \ - port_driver_t *pdrv_ctx = MB_GET_DRV_PTR(context); \ - (pdrv_ctx->loop_name) ? (esp_event_base_t)(pdrv_ctx->loop_name) : "UNK_BASE"; \ + port_driver_t *drv_obj = MB_GET_DRV_PTR(context); \ + (drv_obj->loop_name) ? (esp_event_base_t)(drv_obj->loop_name) : "UNK_BASE"; \ } \ )) -#define MB_ADD_FD(fd, max_fd, pfdset) do { \ +#define MB_ADD_FD(fd, max_fd, fdset) do { \ if (fd) { \ (max_fd = (fd > max_fd) ? fd : max_fd); \ - FD_SET(fd, pfdset); \ + FD_SET(fd, fdset); \ } \ } while(0) @@ -106,15 +106,15 @@ typedef struct _port_driver port_driver_t; // Macro for atomic operations #define MB_ATOMIC_LOAD(ctx, addr) (__extension__( \ { \ - port_driver_t *pdrv_ctx = MB_GET_DRV_PTR(ctx); \ - (CRITICAL_LOAD(pdrv_ctx->lock, addr)); \ + port_driver_t *drv_obj = MB_GET_DRV_PTR(ctx); \ + (CRITICAL_LOAD(drv_obj->lock, addr)); \ } \ )) #define MB_ATOMIC_STORE(ctx, addr, val) (__extension__( \ { \ - port_driver_t *pdrv_ctx = MB_GET_DRV_PTR(ctx); \ - CRITICAL_STORE(pdrv_ctx->lock, addr, val); \ + port_driver_t *drv_obj = MB_GET_DRV_PTR(ctx); \ + CRITICAL_STORE(drv_obj->lock, addr, val); \ } \ )) @@ -122,11 +122,11 @@ typedef struct _port_driver port_driver_t; // So, the eventfd value keeps last event and its fd. #define DRIVER_SEND_EVENT(ctx, event, fd) (__extension__( \ { \ - port_driver_t *pdrv_ctx = MB_GET_DRV_PTR(ctx); \ + port_driver_t *drv_obj = MB_GET_DRV_PTR(ctx); \ mb_event_info_t (event_info##__FUNCTION__##__LINE__); \ (event_info##__FUNCTION__##__LINE__).event_id = (int32_t)event; \ (event_info##__FUNCTION__##__LINE__).opt_fd = fd; \ - ((write_event((void *)pdrv_ctx, &(event_info##__FUNCTION__##__LINE__)) > 0) \ + ((write_event((void *)drv_obj, &(event_info##__FUNCTION__##__LINE__)) > 0) \ ? ((event_info##__FUNCTION__##__LINE__)).event_id : UNDEF_FD); \ } \ )) @@ -177,7 +177,7 @@ typedef union { uint64_t val; } mb_event_info_t; -typedef struct _mb_node_info { +typedef struct mb_node_info_s { int index; /*!< slave information index */ int fd; /*!< slave global file descriptor */ int sock_id; /*!< socket ID of slave */ @@ -263,7 +263,7 @@ typedef struct _port_driver { * @return esp_err_t * - ESP_OK on success */ -esp_err_t mb_drv_register(port_driver_t **config); +esp_err_t mb_drv_register(port_driver_t **ctx); /** * @brief Unregister modbus driver @@ -317,7 +317,7 @@ ssize_t mb_drv_read(void *ctx, int fd, void *data, size_t size); int mb_drv_close(void *ctx, int fd); -int32_t write_event(void *ctx, mb_event_info_t *pevent); +int32_t write_event(void *ctx, mb_event_info_t *event); const char *driver_event_to_name_r(mb_driver_event_t event); @@ -335,7 +335,7 @@ void mb_drv_lock(void *ctx); void mb_drv_unlock(void *ctx); -mb_node_info_t *mb_drv_get_next_node_from_set(void *ctx, int *pfd, fd_set *pfdset); +mb_node_info_t *mb_drv_get_next_node_from_set(void *ctx, int *fd_ptr, fd_set *fdset); mb_status_flags_t mb_drv_set_status_flag(void *ctx, mb_status_flags_t mask); diff --git a/modbus/mb_ports/tcp/port_tcp_master.c b/modbus/mb_ports/tcp/port_tcp_master.c index 9e221d7..706579d 100644 --- a/modbus/mb_ports/tcp/port_tcp_master.c +++ b/modbus/mb_ports/tcp/port_tcp_master.c @@ -19,45 +19,45 @@ typedef struct // TCP communication properties mb_tcp_opts_t tcp_opts; uint8_t ptemp_buf[MB_TCP_BUFF_MAX_SIZE]; - port_driver_t *pdriver; + port_driver_t *drv_obj; } mbm_tcp_port_t; /* ----------------------- Static variables & functions ----------------------*/ static const char *TAG = "mb_port.tcp.master"; static uint64_t mbm_port_tcp_sync_event(void *inst, mb_sync_event_t sync_event); bool mbm_port_timer_expired(void *inst); -extern int port_scan_addr_string(char *buffer, mb_uid_info_t *pslave_info); +extern int port_scan_addr_string(char *buffer, mb_uid_info_t *info_ptr); static esp_err_t mbm_port_tcp_register_handlers(void *ctx) { - port_driver_t *pdrv_ctx = MB_GET_DRV_PTR(ctx); + port_driver_t *drv_obj = MB_GET_DRV_PTR(ctx); esp_err_t ret = ESP_ERR_INVALID_STATE; - ret = mb_drv_register_handler(pdrv_ctx, MB_EVENT_READY_NUM, mbm_on_ready); + ret = mb_drv_register_handler(drv_obj, 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_NUM, mbm_on_open); + ret = mb_drv_register_handler(drv_obj, 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_NUM, mbm_on_resolve); + ret = mb_drv_register_handler(drv_obj, 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_NUM, mbm_on_connect); + ret = mb_drv_register_handler(drv_obj, 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_NUM, mbm_on_error); + ret = mb_drv_register_handler(drv_obj, 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_NUM, mbm_on_send_data); + ret = mb_drv_register_handler(drv_obj, 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_NUM, mbm_on_recv_data); + ret = mb_drv_register_handler(drv_obj, 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_NUM, mbm_on_close); + ret = mb_drv_register_handler(drv_obj, 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_NUM, mbm_on_timeout); + ret = mb_drv_register_handler(drv_obj, 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; @@ -65,35 +65,35 @@ static esp_err_t mbm_port_tcp_register_handlers(void *ctx) static esp_err_t mbm_port_tcp_unregister_handlers(void *ctx) { - port_driver_t *pdrv_ctx = MB_GET_DRV_PTR(ctx); + port_driver_t *drv_obj = MB_GET_DRV_PTR(ctx); esp_err_t ret = ESP_ERR_INVALID_STATE; - ESP_LOGD(TAG, "%p, event handler %p, unregister.", pdrv_ctx, pdrv_ctx->event_handler); + ESP_LOGD(TAG, "%p, event handler %p, unregister.", drv_obj, drv_obj->event_handler); - ret = mb_drv_unregister_handler(pdrv_ctx, MB_EVENT_READY_NUM); + ret = mb_drv_unregister_handler(drv_obj, 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_NUM); + ret = mb_drv_unregister_handler(drv_obj, 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_NUM); + ret = mb_drv_unregister_handler(drv_obj, 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_NUM); + ret = mb_drv_unregister_handler(drv_obj, 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_NUM); + ret = mb_drv_unregister_handler(drv_obj, 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_NUM); + ret = mb_drv_unregister_handler(drv_obj, 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_NUM); + ret = mb_drv_unregister_handler(drv_obj, 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_NUM); + ret = mb_drv_unregister_handler(drv_obj, 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_NUM); + ret = mb_drv_unregister_handler(drv_obj, 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; @@ -108,27 +108,27 @@ mb_err_enum_t mbm_port_tcp_create(mb_tcp_opts_t *tcp_opts, mb_port_base_t **port ptcp = (mbm_tcp_port_t*)calloc(1, sizeof(mbm_tcp_port_t)); MB_GOTO_ON_FALSE(ptcp, MB_EILLSTATE, error, TAG, "mb tcp port creation error."); - ptcp->pdriver = NULL; + ptcp->drv_obj = NULL; CRITICAL_SECTION_INIT(ptcp->base.lock); - ptcp->base.descr = ((mb_port_base_t *)*port_obj)->descr; + ptcp->base.descr = (*port_obj)->descr; - err = mb_drv_register(&ptcp->pdriver); - MB_GOTO_ON_FALSE(((err == ESP_OK) && ptcp->pdriver), MB_EILLSTATE, error, + err = mb_drv_register(&ptcp->drv_obj); + MB_GOTO_ON_FALSE(((err == ESP_OK) && ptcp->drv_obj), MB_EILLSTATE, error, TAG, "mb tcp port driver registration failed, err = (%x).", (int)err); - ptcp->pdriver->parent = ptcp; + ptcp->drv_obj->parent = ptcp; - err = mbm_port_tcp_register_handlers(ptcp->pdriver); - MB_GOTO_ON_FALSE(((err == ESP_OK) && ptcp->pdriver), MB_EILLSTATE, error, + err = mbm_port_tcp_register_handlers(ptcp->drv_obj); + MB_GOTO_ON_FALSE(((err == ESP_OK) && ptcp->drv_obj), MB_EILLSTATE, error, TAG, "mb tcp port driver event handlers registration failed, err = (%x).", (int)err); - ptcp->pdriver->network_iface_ptr = tcp_opts->ip_netif_ptr; - ptcp->pdriver->mb_proto = tcp_opts->mode; - ptcp->pdriver->port = tcp_opts->port; - ptcp->pdriver->uid = tcp_opts->uid; - ptcp->pdriver->is_master = true; - ptcp->pdriver->dns_name = tcp_opts->dns_name; - ptcp->pdriver->event_cbs.mb_sync_event_cb = mbm_port_tcp_sync_event; - ptcp->pdriver->event_cbs.port_arg = (void *)ptcp; + ptcp->drv_obj->network_iface_ptr = tcp_opts->ip_netif_ptr; + ptcp->drv_obj->mb_proto = tcp_opts->mode; + ptcp->drv_obj->port = tcp_opts->port; + ptcp->drv_obj->uid = tcp_opts->uid; + ptcp->drv_obj->is_master = true; + ptcp->drv_obj->dns_name = tcp_opts->dns_name; + ptcp->drv_obj->event_cbs.mb_sync_event_cb = mbm_port_tcp_sync_event; + ptcp->drv_obj->event_cbs.port_arg = (void *)ptcp; ptcp->base.cb.tmr_expired = mbm_port_timer_expired; ptcp->base.cb.tx_empty = NULL; @@ -142,26 +142,26 @@ mb_err_enum_t mbm_port_tcp_create(mb_tcp_opts_t *tcp_opts, mb_port_base_t **port int fd = 0; while(*paddr_table) { - int res = port_scan_addr_string((char *)*paddr_table, &slave_address_info); + int res = port_scan_addr_string(*paddr_table, &slave_address_info); if (res > 0) { ESP_LOGD(TAG, "Config: %s, IP: %s, port: %d, slave_addr: %d, ip_ver: %s", (char *)*paddr_table, slave_address_info.ip_addr_str, slave_address_info.port, slave_address_info.uid, (slave_address_info.addr_type == MB_IPV4 ? "IPV4" : "IPV6")); - fd = mb_drv_open(ptcp->pdriver, slave_address_info, 0); + fd = mb_drv_open(ptcp->drv_obj, slave_address_info, 0); if (fd < 0) { - ESP_LOGE(TAG, "%p, unable to open slave: %s", ptcp->pdriver, slave_address_info.ip_addr_str); + ESP_LOGE(TAG, "%p, unable to open slave: %s", ptcp->drv_obj, slave_address_info.ip_addr_str); } else { ESP_LOGD(TAG, "%p, open slave: %d, %s:%d", - ptcp->pdriver, fd, slave_address_info.ip_addr_str, slave_address_info.port); + ptcp->drv_obj, fd, slave_address_info.ip_addr_str, slave_address_info.port); } } else { - ESP_LOGE(TAG, "%p, unable to open slave: %s, check configuration.", ptcp->pdriver, (char *)*paddr_table); + ESP_LOGE(TAG, "%p, unable to open slave: %s, check configuration.", ptcp->drv_obj, (char *)*paddr_table); } paddr_table++; } #ifdef MB_MDNS_IS_INCLUDED - err = port_start_mdns_service(&ptcp->pdriver->dns_name, true, tcp_opts->uid, ptcp->pdriver->network_iface_ptr); + err = port_start_mdns_service(&ptcp->drv_obj->dns_name, true, tcp_opts->uid, ptcp->drv_obj->network_iface_ptr); MB_GOTO_ON_FALSE((err == ESP_OK), MB_EILLSTATE, error, TAG, "mb tcp port mdns service init failure."); #endif @@ -171,12 +171,12 @@ mb_err_enum_t mbm_port_tcp_create(mb_tcp_opts_t *tcp_opts, mb_port_base_t **port return MB_ENOERR; error: + if (ptcp && ptcp->drv_obj) { #ifdef MB_MDNS_IS_INCLUDED - port_stop_mdns_service(&ptcp->pdriver->dns_name); + port_stop_mdns_service(&ptcp->drv_obj->dns_name); #endif - if (ptcp && ptcp->pdriver) { - (void)mbm_port_tcp_unregister_handlers(ptcp->pdriver); - (void)mb_drv_unregister(ptcp->pdriver); + (void)mbm_port_tcp_unregister_handlers(ptcp->drv_obj); + (void)mb_drv_unregister(ptcp->drv_obj); CRITICAL_SECTION_CLOSE(ptcp->base.lock); // if the MDNS resolving is enabled, then free it } @@ -188,12 +188,12 @@ 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); + err = mbm_port_tcp_unregister_handlers(port_obj->drv_obj); 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); + port_stop_mdns_service(&port_obj->drv_obj->dns_name); #endif - err = mb_drv_unregister(port_obj->pdriver); + err = mb_drv_unregister(port_obj->drv_obj); if (err != ESP_OK) { ESP_LOGE(TAG, "driver unregister fail, returns (0x%d).", (uint16_t)err); } @@ -204,75 +204,75 @@ void mbm_port_tcp_delete(mb_port_base_t *inst) void mbm_port_tcp_enable(mb_port_base_t *inst) { mbm_tcp_port_t *port_obj = __containerof(inst, mbm_tcp_port_t, base); - (void)mb_drv_start_task(port_obj->pdriver); - (void)mb_drv_clear_status_flag(port_obj->pdriver, MB_FLAG_DISCONNECTED); - DRIVER_SEND_EVENT(port_obj->pdriver, MB_EVENT_RESOLVE, UNDEF_FD); + (void)mb_drv_start_task(port_obj->drv_obj); + (void)mb_drv_clear_status_flag(port_obj->drv_obj, MB_FLAG_DISCONNECTED); + DRIVER_SEND_EVENT(port_obj->drv_obj, MB_EVENT_RESOLVE, UNDEF_FD); } void mbm_port_tcp_disable(mb_port_base_t *inst) { mbm_tcp_port_t *port_obj = __containerof(inst, mbm_tcp_port_t, base); // Change the state of all slaves to close - DRIVER_SEND_EVENT(port_obj->pdriver, MB_EVENT_CLOSE, UNDEF_FD); - (void)mb_drv_wait_status_flag(port_obj->pdriver, MB_FLAG_DISCONNECTED, pdMS_TO_TICKS(MB_RECONNECT_TIME_MS)); + DRIVER_SEND_EVENT(port_obj->drv_obj, MB_EVENT_CLOSE, UNDEF_FD); + (void)mb_drv_wait_status_flag(port_obj->drv_obj, MB_FLAG_DISCONNECTED, pdMS_TO_TICKS(MB_RECONNECT_TIME_MS)); } -bool mbm_port_tcp_recv_data(mb_port_base_t *inst, uint8_t **ppframe, uint16_t *plength) +bool mbm_port_tcp_recv_data(mb_port_base_t *inst, uint8_t **frame, uint16_t *length) { mbm_tcp_port_t *port_obj = __containerof(inst, mbm_tcp_port_t, base); - mb_node_info_t *pinfo = port_obj->pdriver->mb_node_curr; - MB_RETURN_ON_FALSE((pinfo), false, TAG, "incorrect current slave pointer."); + mb_node_info_t *info_ptr = port_obj->drv_obj->mb_node_curr; + MB_RETURN_ON_FALSE((info_ptr), false, TAG, "incorrect current slave pointer."); bool status = false; - size_t sz = mb_drv_read(port_obj->pdriver, pinfo->fd, port_obj->ptemp_buf, MB_BUFFER_SIZE); + size_t sz = mb_drv_read(port_obj->drv_obj, info_ptr->fd, port_obj->ptemp_buf, MB_BUFFER_SIZE); if (sz > MB_TCP_FUNC) { uint16_t tid_counter = MB_TCP_MBAP_GET_FIELD(port_obj->ptemp_buf, MB_TCP_TID); - if (tid_counter == (pinfo->tid_counter - 1)) { - *ppframe = port_obj->ptemp_buf; - *plength = sz; + if (tid_counter == (info_ptr->tid_counter - 1)) { + *frame = port_obj->ptemp_buf; + *length = sz; ESP_LOGD(TAG, "%p, "MB_NODE_FMT(", get packet TID: 0x%04" PRIx16 ":0x%04" PRIx16 ", %p."), - port_obj->pdriver, pinfo->index, pinfo->sock_id, pinfo->addr_info.ip_addr_str, - (unsigned)tid_counter, (unsigned)pinfo->tid_counter, *ppframe); + port_obj->drv_obj, info_ptr->index, info_ptr->sock_id, info_ptr->addr_info.ip_addr_str, + (unsigned)tid_counter, (unsigned)info_ptr->tid_counter, *frame); uint64_t time = 0; - time = port_get_timestamp() - pinfo->send_time; - ESP_LOGD(TAG, "%p, "MB_NODE_FMT(", processing time[us] = %ju."), port_obj->pdriver, pinfo->index, - pinfo->sock_id, pinfo->addr_info.ip_addr_str, time); + time = port_get_timestamp() - info_ptr->send_time; + ESP_LOGD(TAG, "%p, "MB_NODE_FMT(", processing time[us] = %ju."), port_obj->drv_obj, info_ptr->index, + info_ptr->sock_id, info_ptr->addr_info.ip_addr_str, time); status = true; } else { ESP_LOGE(TAG, "%p, "MB_NODE_FMT(", drop packet TID: 0x%04" PRIx16 ":0x%04" PRIx16 ", %p."), - port_obj->pdriver, pinfo->index, pinfo->sock_id, - pinfo->addr_info.ip_addr_str, (unsigned)tid_counter, (unsigned)pinfo->tid_counter, *ppframe); + port_obj->drv_obj, info_ptr->index, info_ptr->sock_id, + info_ptr->addr_info.ip_addr_str, (unsigned)tid_counter, (unsigned)info_ptr->tid_counter, *frame); } } return status; } -bool mbm_port_tcp_send_data(mb_port_base_t *inst, uint8_t address, uint8_t *pframe, uint16_t length) +bool mbm_port_tcp_send_data(mb_port_base_t *inst, uint8_t address, uint8_t *frame, uint16_t length) { mbm_tcp_port_t *port_obj = __containerof(inst, mbm_tcp_port_t, base); bool frame_sent = false; // get slave descriptor from its address - mb_node_info_t *pinfo = (mb_node_info_t *)mb_drv_get_node_info_from_addr(port_obj->pdriver, address); + mb_node_info_t *info_ptr = mb_drv_get_node_info_from_addr(port_obj->drv_obj, address); - bool all_nodes_connected = mb_drv_wait_status_flag(port_obj->pdriver, MB_FLAG_CONNECTED, pdMS_TO_TICKS(MB_RECONNECT_TIME_MS)); + bool all_nodes_connected = mb_drv_wait_status_flag(port_obj->drv_obj, MB_FLAG_CONNECTED, pdMS_TO_TICKS(MB_RECONNECT_TIME_MS)); - MB_RETURN_ON_FALSE((all_nodes_connected && pinfo && (MB_GET_NODE_STATE(pinfo) >= MB_SOCK_STATE_CONNECTED)), + MB_RETURN_ON_FALSE((all_nodes_connected && info_ptr && (MB_GET_NODE_STATE(info_ptr) >= MB_SOCK_STATE_CONNECTED)), false, TAG, "The node UID #%d, is not connected.", address); - if (pinfo && pframe) { + if (info_ptr && frame) { // Apply TID field to the frame before send - MB_TCP_MBAP_SET_FIELD(pframe, MB_TCP_TID, pinfo->tid_counter); - pframe[MB_TCP_UID] = (uint8_t)(pinfo->addr_info.uid); + MB_TCP_MBAP_SET_FIELD(frame, MB_TCP_TID, info_ptr->tid_counter); + frame[MB_TCP_UID] = (uint8_t)(info_ptr->addr_info.uid); } ESP_LOGD(TAG, "%p, send fd: %d, sock_id: %d[%s], %p, len: %d", - port_obj->pdriver, pinfo->fd, pinfo->sock_id, pinfo->addr_info.ip_addr_str, pframe, length); + port_obj->drv_obj, info_ptr->fd, info_ptr->sock_id, info_ptr->addr_info.ip_addr_str, frame, length); // Write data to the modbus driver send queue of the slave - int write_length = mb_drv_write(port_obj->pdriver, pinfo->fd, pframe, length); + int write_length = mb_drv_write(port_obj->drv_obj, info_ptr->fd, frame, length); if (write_length) { frame_sent = true; } else { @@ -286,7 +286,7 @@ bool mbm_port_tcp_send_data(mb_port_base_t *inst, uint8_t address, uint8_t *pfra void mbm_port_tcp_set_conn_cb(mb_port_base_t *inst, void *conn_fp, void *arg) { mbm_tcp_port_t *port_obj = __containerof(inst, mbm_tcp_port_t, base); - mb_drv_set_cb(port_obj->pdriver, conn_fp, arg); + mb_drv_set_cb(port_obj->drv_obj, conn_fp, arg); } // Timer handler to check timeout of socket response @@ -303,8 +303,8 @@ bool mbm_port_timer_expired(void *inst) if (mb_port_get_cur_timer_mode(inst) == MB_TMODE_RESPOND_TIMEOUT) { // It is now to check solution. mb_event.event_id = MB_EVENT_TIMEOUT; - mb_event.opt_fd = port_obj->pdriver->curr_node_index; - err = esp_event_isr_post_to(port_obj->pdriver->event_loop_hdl, MB_EVENT_BASE(port_obj->pdriver), + mb_event.opt_fd = port_obj->drv_obj->curr_node_index; + err = esp_event_isr_post_to(port_obj->drv_obj->event_loop_hdl, MB_EVENT_BASE(port_obj->drv_obj), (int32_t)MB_EVENT_TIMEOUT, (void *)&mb_event, sizeof(mb_event_info_t*), &task_unblocked); if (err != ESP_OK) { ESP_EARLY_LOGE(TAG, "Timeout event send error: %d", err); @@ -316,15 +316,15 @@ bool mbm_port_timer_expired(void *inst) return need_poll; } -mb_uid_info_t *mbm_port_tcp_get_slave_info(mb_port_base_t *inst, uint8_t slave_addr, mb_sock_state_t exp_state) +mb_uid_info_t *mbm_port_tcp_get_slave_info(mb_port_base_t *inst, uint8_t uid, mb_sock_state_t exp_state) { mbm_tcp_port_t *port_obj = __containerof(inst, mbm_tcp_port_t, base); - mb_uid_info_t *paddr_info = NULL; - mb_node_info_t *pinfo = mb_drv_get_node_info_from_addr(port_obj->pdriver, slave_addr); - if (pinfo && (MB_GET_NODE_STATE(pinfo) >= exp_state)) { - paddr_info = &pinfo->addr_info; + mb_uid_info_t *addr_info = NULL; + mb_node_info_t *info_ptr = mb_drv_get_node_info_from_addr(port_obj->drv_obj, uid); + if (info_ptr && (MB_GET_NODE_STATE(info_ptr) >= exp_state)) { + addr_info = &info_ptr->addr_info; } - return paddr_info; + return addr_info; } static uint64_t mbm_port_tcp_sync_event(void *inst, mb_sync_event_t sync_event) @@ -354,30 +354,30 @@ static uint64_t mbm_port_tcp_sync_event(void *inst, mb_sync_event_t sync_event) MB_EVENT_HANDLER(mbm_on_ready) { // The driver is registered - mb_event_info_t *pevent_info = (mb_event_info_t *)data; - ESP_LOGD(TAG, "%s %s: fd: %d", (char *)base, __func__, (int)pevent_info->opt_fd); + mb_event_info_t *event_info = (mb_event_info_t *)data; + ESP_LOGD(TAG, "%s %s: fd: %d", (char *)base, __func__, (int)event_info->opt_fd); } MB_EVENT_HANDLER(mbm_on_open) { - mb_event_info_t *pevent_info = (mb_event_info_t *)data; - ESP_LOGD(TAG, "%s %s: fd: %d", (char *)base, __func__, (int)pevent_info->opt_fd); + mb_event_info_t *event_info = (mb_event_info_t *)data; + ESP_LOGD(TAG, "%s %s: fd: %d", (char *)base, __func__, (int)event_info->opt_fd); } MB_EVENT_HANDLER(mbm_on_resolve) { - port_driver_t *pdrv_ctx = MB_GET_DRV_PTR(ctx); - mb_event_info_t *pevent_info = (mb_event_info_t *)data; - ESP_LOGD(TAG, "%s %s: fd: %d", (char *)base, __func__, (int)pevent_info->opt_fd); + port_driver_t *drv_obj = MB_GET_DRV_PTR(ctx); + mb_event_info_t *event_info = (mb_event_info_t *)data; + ESP_LOGD(TAG, "%s %s: fd: %d", (char *)base, __func__, (int)event_info->opt_fd); - if (MB_CHECK_FD_RANGE(pevent_info->opt_fd)) { - ESP_LOGD(TAG, "%p, Node: %d, resolve.", ctx, (int)pevent_info->opt_fd); + if (MB_CHECK_FD_RANGE(event_info->opt_fd)) { + ESP_LOGD(TAG, "%p, Node: %d, resolve.", ctx, (int)event_info->opt_fd); // The mdns is not used in the main app, then can use manually defined IPs - int fd = pevent_info->opt_fd; - mb_node_info_t *pslave = mb_drv_get_node(pdrv_ctx, fd); + int fd = event_info->opt_fd; + mb_node_info_t *pslave = mb_drv_get_node(drv_obj, fd); if (pslave && (MB_GET_NODE_STATE(pslave) == MB_SOCK_STATE_OPENED) - && FD_ISSET(pslave->index, &pdrv_ctx->open_set)) { - mb_status_flags_t status = mb_drv_wait_status_flag(pdrv_ctx, MB_FLAG_DISCONNECTED, 0); + && FD_ISSET(pslave->index, &drv_obj->open_set)) { + mb_status_flags_t status = mb_drv_wait_status_flag(drv_obj, MB_FLAG_DISCONNECTED, 0); if ((status & MB_FLAG_DISCONNECTED)) { ESP_LOGV(TAG, "%p, slave: %d, sock: %d, IP:%s, disconnected.", ctx, (int)pslave->index, (int)pslave->sock_id, pslave->addr_info.ip_addr_str); @@ -391,7 +391,7 @@ MB_EVENT_HANDLER(mbm_on_resolve) DRIVER_SEND_EVENT(ctx, MB_EVENT_CONNECT, pslave->index); } else { #ifdef MB_MDNS_IS_INCLUDED - int ret = port_resolve_mdns_host(pslave->addr_info.node_name_str, (char **)&pslave->addr_info.ip_addr_str); + int ret = port_resolve_mdns_host(pslave->addr_info.node_name_str, &pslave->addr_info.ip_addr_str); if (ret > 0) { ESP_LOGI(TAG, "%p, slave: %d, resolved with IP:%s.", ctx, (int)fd, pslave->addr_info.ip_addr_str); MB_SET_NODE_STATE(pslave, MB_SOCK_STATE_RESOLVED); @@ -406,17 +406,17 @@ MB_EVENT_HANDLER(mbm_on_resolve) #endif } } - } else if (pevent_info->opt_fd < 0) { + } else if (event_info->opt_fd < 0) { // Todo: query for services is removed from this version // #ifdef MB_MDNS_IS_INCLUDED // // If the mDNS feature support is enabled, use it to resolve the slave IP - // res = mb_drv_resolve_mdns_service(ctx, "_modbus", "_tcp", pdrv_ctx->addr_type); - // ESP_LOGD(TAG, "%p, use mdns to resolve slave: %d, resolved: %d devices.", ctx, (int)pevent_info->opt_fd, res); + // res = mb_drv_resolve_mdns_service(ctx, "_modbus", "_tcp", drv_obj->addr_type); + // ESP_LOGD(TAG, "%p, use mdns to resolve slave: %d, resolved: %d devices.", ctx, (int)event_info->opt_fd, res); // #else - for (int fd = 0; fd < pdrv_ctx->mb_node_open_count; fd++) { - mb_node_info_t *pslave = mb_drv_get_node(pdrv_ctx, fd); + for (int fd = 0; fd < drv_obj->mb_node_open_count; fd++) { + mb_node_info_t *pslave = mb_drv_get_node(drv_obj, fd); if (pslave && (MB_GET_NODE_STATE(pslave) == MB_SOCK_STATE_OPENED) - && FD_ISSET(pslave->index, &pdrv_ctx->open_set)) { + && FD_ISSET(pslave->index, &drv_obj->open_set)) { DRIVER_SEND_EVENT(ctx, MB_EVENT_RESOLVE, pslave->index); } mb_drv_check_suspend_shutdown(ctx); @@ -427,74 +427,74 @@ MB_EVENT_HANDLER(mbm_on_resolve) MB_EVENT_HANDLER(mbm_on_connect) { - port_driver_t *pdrv_ctx = MB_GET_DRV_PTR(ctx); - mb_node_info_t *pnode_info = NULL; - mb_event_info_t *pevent_info = (mb_event_info_t *)data; - ESP_LOGD(TAG, "%s %s: fd: %d", (char *)base, __func__, (int)pevent_info->opt_fd); + port_driver_t *drv_obj = MB_GET_DRV_PTR(ctx); + mb_node_info_t *node_ptr = NULL; + mb_event_info_t *event_info = (mb_event_info_t *)data; + ESP_LOGD(TAG, "%s %s: fd: %d", (char *)base, __func__, (int)event_info->opt_fd); err_t err = ERR_CONN; - if (MB_CHECK_FD_RANGE(pevent_info->opt_fd)) { - pnode_info = mb_drv_get_node(pdrv_ctx, pevent_info->opt_fd); - if (pnode_info && - (MB_GET_NODE_STATE(pnode_info) < MB_SOCK_STATE_CONNECTED) && - (MB_GET_NODE_STATE(pnode_info) >= MB_SOCK_STATE_RESOLVED)) { + if (MB_CHECK_FD_RANGE(event_info->opt_fd)) { + node_ptr = mb_drv_get_node(drv_obj, event_info->opt_fd); + if (node_ptr && + (MB_GET_NODE_STATE(node_ptr) < MB_SOCK_STATE_CONNECTED) && + (MB_GET_NODE_STATE(node_ptr) >= MB_SOCK_STATE_RESOLVED)) { ESP_LOGD(TAG, "%p, connection phase, slave: #%d(%d) [%s].", - ctx, (int)pevent_info->opt_fd, (int)pnode_info->sock_id, pnode_info->addr_info.ip_addr_str); - err = port_connect(ctx, pnode_info); + ctx, (int)event_info->opt_fd, (int)node_ptr->sock_id, node_ptr->addr_info.ip_addr_str); + err = port_connect(ctx, node_ptr); switch (err) { case ERR_OK: - FD_SET(pnode_info->sock_id, &pdrv_ctx->conn_set); + FD_SET(node_ptr->sock_id, &drv_obj->conn_set); mb_drv_lock(ctx); - pdrv_ctx->node_conn_count++; + drv_obj->node_conn_count++; // Update time stamp for connected slaves - pnode_info->send_time = esp_timer_get_time(); - pnode_info->recv_time = esp_timer_get_time(); + node_ptr->send_time = esp_timer_get_time(); + node_ptr->recv_time = esp_timer_get_time(); mb_drv_unlock(ctx); ESP_LOGI(TAG, "%p, slave: #%d, sock:%d, IP: %s, is connected.", - ctx, (int)pevent_info->opt_fd, (int)pnode_info->sock_id, - pnode_info->addr_info.ip_addr_str); - MB_SET_NODE_STATE(pnode_info, MB_SOCK_STATE_CONNECTED); - (void)port_keep_alive(pnode_info->sock_id); + ctx, (int)event_info->opt_fd, (int)node_ptr->sock_id, + node_ptr->addr_info.ip_addr_str); + MB_SET_NODE_STATE(node_ptr, MB_SOCK_STATE_CONNECTED); + (void)port_keep_alive(node_ptr->sock_id); ESP_LOGD(TAG, "Opened/connected: %u, %u.", - (unsigned)pdrv_ctx->mb_node_open_count, (unsigned)pdrv_ctx->node_conn_count); - if (pdrv_ctx->mb_node_open_count == pdrv_ctx->node_conn_count) { - if (pdrv_ctx->event_cbs.on_conn_done_cb) { - pdrv_ctx->event_cbs.on_conn_done_cb(pdrv_ctx->event_cbs.arg); + (unsigned)drv_obj->mb_node_open_count, (unsigned)drv_obj->node_conn_count); + if (drv_obj->mb_node_open_count == drv_obj->node_conn_count) { + if (drv_obj->event_cbs.on_conn_done_cb) { + drv_obj->event_cbs.on_conn_done_cb(drv_obj->event_cbs.arg); } ESP_LOGI(TAG, "%p, Connected: %u, %u, start polling.", - ctx, (unsigned)pdrv_ctx->mb_node_open_count, (unsigned)pdrv_ctx->node_conn_count); + ctx, (unsigned)drv_obj->mb_node_open_count, (unsigned)drv_obj->node_conn_count); mb_drv_set_status_flag(ctx, MB_FLAG_CONNECTED); } break; case ERR_INPROGRESS: - if (FD_ISSET(pnode_info->sock_id, &pdrv_ctx->conn_set)) { - FD_CLR(pnode_info->sock_id, &pdrv_ctx->conn_set); + if (FD_ISSET(node_ptr->sock_id, &drv_obj->conn_set)) { + FD_CLR(node_ptr->sock_id, &drv_obj->conn_set); ESP_LOGD(TAG, "%p, slave: #%d, sock:%d, IP:%s, connect fail error = %d.", - ctx, (int)pevent_info->opt_fd, (int)pnode_info->sock_id, - pnode_info->addr_info.ip_addr_str, (int)err); + ctx, (int)event_info->opt_fd, (int)node_ptr->sock_id, + node_ptr->addr_info.ip_addr_str, (int)err); mb_drv_lock(ctx); - if (pdrv_ctx->node_conn_count) { - pdrv_ctx->node_conn_count--; + if (drv_obj->node_conn_count) { + drv_obj->node_conn_count--; } mb_drv_unlock(ctx); - DRIVER_SEND_EVENT(ctx, MB_EVENT_CLOSE, pevent_info->opt_fd); - port_close_connection(pnode_info); + DRIVER_SEND_EVENT(ctx, MB_EVENT_CLOSE, event_info->opt_fd); + port_close_connection(node_ptr); } else { ESP_LOGD(TAG, "%p, slave: #%d, sock:%d, IP:%s, connection is in progress.", - ctx, (int)pevent_info->opt_fd, (int)pnode_info->sock_id, - pnode_info->addr_info.ip_addr_str); - MB_SET_NODE_STATE(pnode_info, MB_SOCK_STATE_CONNECTING); + ctx, (int)event_info->opt_fd, (int)node_ptr->sock_id, + node_ptr->addr_info.ip_addr_str); + MB_SET_NODE_STATE(node_ptr, MB_SOCK_STATE_CONNECTING); vTaskDelay(MB_CONN_TICK_TIMEOUT); // try to connect to slave and check connection again if it is not connected - DRIVER_SEND_EVENT(ctx, MB_EVENT_CONNECT, pevent_info->opt_fd); + DRIVER_SEND_EVENT(ctx, MB_EVENT_CONNECT, event_info->opt_fd); } break; case ERR_CONN: ESP_LOGE(TAG, "Modbus connection phase, slave: %d (%s), connection error (%d).", - (int)pevent_info->opt_fd, pnode_info->addr_info.ip_addr_str, (int)err); + (int)event_info->opt_fd, node_ptr->addr_info.ip_addr_str, (int)err); break; default: ESP_LOGE(TAG, "Invalid error state, slave: %d (%s), error = %d.", - (int)pevent_info->opt_fd, pnode_info->addr_info.ip_addr_str, (int)err); + (int)event_info->opt_fd, node_ptr->addr_info.ip_addr_str, (int)err); break; } } @@ -502,13 +502,13 @@ MB_EVENT_HANDLER(mbm_on_connect) // if the event fd is UNDEF_FD (an event for all slaves), // then perform connection phase for all resolved slaves sending the connection event for (int node = 0; (node < MB_TCP_PORT_MAX_CONN); node++) { - pnode_info = mb_drv_get_node(pdrv_ctx, node); - if (pnode_info && - (MB_GET_NODE_STATE(pnode_info) < MB_SOCK_STATE_CONNECTED) && - (MB_GET_NODE_STATE(pnode_info) >= MB_SOCK_STATE_RESOLVED)) { - if (((pnode_info->sock_id < 0) || !FD_ISSET(pnode_info->sock_id, &pdrv_ctx->conn_set)) - && FD_ISSET(node, &pdrv_ctx->open_set)) { - DRIVER_SEND_EVENT(ctx, MB_EVENT_CONNECT, pnode_info->index); + node_ptr = mb_drv_get_node(drv_obj, node); + if (node_ptr && + (MB_GET_NODE_STATE(node_ptr) < MB_SOCK_STATE_CONNECTED) && + (MB_GET_NODE_STATE(node_ptr) >= MB_SOCK_STATE_RESOLVED)) { + if (((node_ptr->sock_id < 0) || !FD_ISSET(node_ptr->sock_id, &drv_obj->conn_set)) + && FD_ISSET(node, &drv_obj->open_set)) { + DRIVER_SEND_EVENT(ctx, MB_EVENT_CONNECT, node_ptr->index); } } mb_drv_check_suspend_shutdown(ctx); @@ -518,39 +518,39 @@ MB_EVENT_HANDLER(mbm_on_connect) MB_EVENT_HANDLER(mbm_on_error) { - port_driver_t *pdrv_ctx = MB_GET_DRV_PTR(ctx); - mb_event_info_t *pevent_info = (mb_event_info_t *)data; - mb_node_info_t *pnode_info = NULL; - if (MB_CHECK_FD_RANGE(pevent_info->opt_fd)) { + port_driver_t *drv_obj = MB_GET_DRV_PTR(ctx); + mb_event_info_t *event_info = (mb_event_info_t *)data; + mb_node_info_t *node_ptr = NULL; + if (MB_CHECK_FD_RANGE(event_info->opt_fd)) { mb_drv_check_suspend_shutdown(ctx); - mb_status_flags_t status = mb_drv_wait_status_flag(pdrv_ctx, MB_FLAG_DISCONNECTED, 1); + mb_status_flags_t status = mb_drv_wait_status_flag(drv_obj, MB_FLAG_DISCONNECTED, 1); if ((status & MB_FLAG_DISCONNECTED)) { - ESP_LOGE(TAG, "%p, node: %d, is in disconnected state.", ctx, (int)pevent_info->opt_fd); + ESP_LOGE(TAG, "%p, node: %d, is in disconnected state.", ctx, (int)event_info->opt_fd); mb_drv_clear_status_flag(ctx, MB_FLAG_CONNECTED); return; } - int ret = mb_drv_check_node_state(pdrv_ctx, (int *)&pevent_info->opt_fd, MB_RECONNECT_TIME_MS); + int ret = mb_drv_check_node_state(drv_obj, (int *)&event_info->opt_fd, MB_RECONNECT_TIME_MS); if ((ret != ERR_OK) && (ret != ERR_TIMEOUT)) { - pnode_info = mb_drv_get_node(pdrv_ctx, pevent_info->opt_fd); - ESP_LOGW(TAG, "%p, "MB_NODE_FMT(", error handling."), ctx, (int)pnode_info->fd, - (int)pnode_info->sock_id, pnode_info->addr_info.ip_addr_str); - ESP_LOGE(TAG, "Node: %d, try to repair lost connection, err= %d", (int)pevent_info->opt_fd, ret); - FD_CLR(pnode_info->sock_id, &pdrv_ctx->conn_set); + node_ptr = mb_drv_get_node(drv_obj, event_info->opt_fd); + ESP_LOGW(TAG, "%p, "MB_NODE_FMT(", error handling."), ctx, (int)node_ptr->fd, + (int)node_ptr->sock_id, node_ptr->addr_info.ip_addr_str); + ESP_LOGE(TAG, "Node: %d, try to repair lost connection, err= %d", (int)event_info->opt_fd, ret); + FD_CLR(node_ptr->sock_id, &drv_obj->conn_set); mb_drv_lock(ctx); - if (pdrv_ctx->node_conn_count) { - pdrv_ctx->node_conn_count--; + if (drv_obj->node_conn_count) { + drv_obj->node_conn_count--; } mb_drv_unlock(ctx); - port_close_connection(pnode_info); - DRIVER_SEND_EVENT(ctx, MB_EVENT_RESOLVE, pnode_info->index); + port_close_connection(node_ptr); + DRIVER_SEND_EVENT(ctx, MB_EVENT_RESOLVE, node_ptr->index); } - } else if (pevent_info->opt_fd < 0) { + } else if (event_info->opt_fd < 0) { // send resolve event to all slaves - for (int fd = 0; fd < pdrv_ctx->mb_node_open_count; fd++) { + for (int fd = 0; fd < drv_obj->mb_node_open_count; fd++) { mb_drv_check_suspend_shutdown(ctx); - mb_node_info_t *pslave = mb_drv_get_node(pdrv_ctx, fd); + mb_node_info_t *pslave = mb_drv_get_node(drv_obj, fd); if (pslave && (MB_GET_NODE_STATE(pslave) == MB_SOCK_STATE_OPENED) - && FD_ISSET(pslave->index, &pdrv_ctx->open_set)) { + && FD_ISSET(pslave->index, &drv_obj->open_set)) { DRIVER_SEND_EVENT(ctx, MB_EVENT_RESOLVE, pslave->index); } } @@ -559,48 +559,48 @@ MB_EVENT_HANDLER(mbm_on_error) MB_EVENT_HANDLER(mbm_on_send_data) { - port_driver_t *pdrv_ctx = MB_GET_DRV_PTR(ctx); - mb_event_info_t *pevent_info = (mb_event_info_t *)data; - ESP_LOGD(TAG, "%s %s: fd: %d", (char *)base, __func__, (int)pevent_info->opt_fd); + port_driver_t *drv_obj = MB_GET_DRV_PTR(ctx); + mb_event_info_t *event_info = (mb_event_info_t *)data; + ESP_LOGD(TAG, "%s %s: fd: %d", (char *)base, __func__, (int)event_info->opt_fd); mb_drv_check_suspend_shutdown(ctx); - mb_node_info_t *pinfo = mb_drv_get_node(pdrv_ctx, pevent_info->opt_fd); - if (pinfo && !queue_is_empty(pinfo->tx_queue)) { + mb_node_info_t *info_ptr = mb_drv_get_node(drv_obj, event_info->opt_fd); + if (info_ptr && !queue_is_empty(info_ptr->tx_queue)) { uint8_t tx_buffer[MB_TCP_BUFF_MAX_SIZE] = {0}; ESP_LOGD(TAG, "%p, get info: %d, sock_id: %d, queue_state: %d, state: %d.", - ctx, (int)pevent_info->opt_fd, (int)pinfo->sock_id, - (int)queue_is_empty(pinfo->tx_queue), (int)MB_GET_NODE_STATE(pinfo)); - size_t sz = queue_pop(pinfo->tx_queue, tx_buffer, sizeof(tx_buffer), NULL); - if (MB_GET_NODE_STATE(pinfo) < MB_SOCK_STATE_CONNECTED) { + ctx, (int)event_info->opt_fd, (int)info_ptr->sock_id, + (int)queue_is_empty(info_ptr->tx_queue), (int)MB_GET_NODE_STATE(info_ptr)); + size_t sz = queue_pop(info_ptr->tx_queue, tx_buffer, sizeof(tx_buffer), NULL); + if (MB_GET_NODE_STATE(info_ptr) < MB_SOCK_STATE_CONNECTED) { // if slave is not connected, drop data. ESP_LOGE(TAG, "%p, "MB_NODE_FMT(", is invalid, drop send data."), - ctx, (int)pinfo->index, (int)pinfo->sock_id, pinfo->addr_info.ip_addr_str); + ctx, (int)info_ptr->index, (int)info_ptr->sock_id, info_ptr->addr_info.ip_addr_str); return; } - int ret = port_write_poll(pinfo, tx_buffer, sz, MB_TCP_SEND_TIMEOUT_MS); + int ret = port_write_poll(info_ptr, tx_buffer, sz, MB_TCP_SEND_TIMEOUT_MS); if (ret < 0) { ESP_LOGE(TAG, "%p, "MB_NODE_FMT(", send data failure, err(errno) = %d(%u)."), - ctx, (int)pinfo->index, (int)pinfo->sock_id, - pinfo->addr_info.ip_addr_str, (int)ret, (unsigned)errno); - DRIVER_SEND_EVENT(ctx, MB_EVENT_ERROR, pinfo->index); - pinfo->error = ret; + ctx, (int)info_ptr->index, (int)info_ptr->sock_id, + info_ptr->addr_info.ip_addr_str, (int)ret, (unsigned)errno); + DRIVER_SEND_EVENT(ctx, MB_EVENT_ERROR, info_ptr->index); + info_ptr->error = ret; } else { ESP_LOGD(TAG, "%p, "MB_NODE_FMT(", send data successful: TID:0x%04x, %d (bytes), errno %d"), - ctx, (int)pinfo->index, (int)pinfo->sock_id, - pinfo->addr_info.ip_addr_str, (unsigned)pinfo->tid_counter, (int)ret, (unsigned)errno); - pinfo->error = 0; + ctx, (int)info_ptr->index, (int)info_ptr->sock_id, + info_ptr->addr_info.ip_addr_str, (unsigned)info_ptr->tid_counter, (int)ret, (unsigned)errno); + info_ptr->error = 0; // Every successful write increase TID counter - if (pinfo->tid_counter < (USHRT_MAX - 1)) { - pinfo->tid_counter++; + if (info_ptr->tid_counter < (USHRT_MAX - 1)) { + info_ptr->tid_counter++; } else { - pinfo->tid_counter = (uint16_t)(pinfo->index << 8U); + info_ptr->tid_counter = (uint16_t)(info_ptr->index << 8U); } } - pdrv_ctx->event_cbs.mb_sync_event_cb(pdrv_ctx->event_cbs.port_arg, MB_SYNC_EVENT_SEND_OK); + drv_obj->event_cbs.mb_sync_event_cb(drv_obj->event_cbs.port_arg, MB_SYNC_EVENT_SEND_OK); mb_drv_lock(ctx); - pdrv_ctx->mb_node_curr = pinfo; - pdrv_ctx->curr_node_index = pinfo->index; - pinfo->send_time = esp_timer_get_time(); - pinfo->send_counter = (pinfo->send_counter < (USHRT_MAX - 1)) ? (pinfo->send_counter + 1) : 0; + drv_obj->mb_node_curr = info_ptr; + drv_obj->curr_node_index = info_ptr->index; + info_ptr->send_time = esp_timer_get_time(); + info_ptr->send_counter = (info_ptr->send_counter < (USHRT_MAX - 1)) ? (info_ptr->send_counter + 1) : 0; mb_drv_unlock(ctx); // Get send buffer from stack ESP_LOG_BUFFER_HEX_LEVEL("SENT", tx_buffer, sz, ESP_LOG_DEBUG); @@ -609,30 +609,30 @@ MB_EVENT_HANDLER(mbm_on_send_data) MB_EVENT_HANDLER(mbm_on_recv_data) { - port_driver_t *pdrv_ctx = MB_GET_DRV_PTR(ctx); - mb_event_info_t *pevent_info = (mb_event_info_t *)data; - ESP_LOGD(TAG, "%s %s: fd: %d", (char *)base, __func__, (int)pevent_info->opt_fd); + port_driver_t *drv_obj = MB_GET_DRV_PTR(ctx); + mb_event_info_t *event_info = (mb_event_info_t *)data; + ESP_LOGD(TAG, "%s %s: fd: %d", (char *)base, __func__, (int)event_info->opt_fd); size_t sz = 0; - uint8_t pbuf[MB_TCP_BUFF_MAX_SIZE] = {0}; + uint8_t buf[MB_TCP_BUFF_MAX_SIZE] = {0}; mb_drv_check_suspend_shutdown(ctx); // Get frame from queue, check for correctness, push back correct frame and generate receive condition. // Removes incorrect or expired frames from the queue, leave just correct one then sent sync event - mb_node_info_t *pnode_info = mb_drv_get_node(pdrv_ctx, pevent_info->opt_fd); - if (pnode_info) { - ESP_LOGD(TAG, "%p, slave #%d(%d) [%s], receive data ready.", ctx, (int)pevent_info->opt_fd, - (int)pnode_info->sock_id, pnode_info->addr_info.ip_addr_str); - while ((sz <= 0) && !queue_is_empty(pnode_info->rx_queue)) { - size_t sz = queue_pop(pnode_info->rx_queue, pbuf, MB_TCP_BUFF_MAX_SIZE, NULL); - if ((sz > MB_TCP_FUNC) && (sz < sizeof(pbuf))) { - uint16_t tid = MB_TCP_MBAP_GET_FIELD(pbuf, MB_TCP_TID); + mb_node_info_t *node_ptr = mb_drv_get_node(drv_obj, event_info->opt_fd); + if (node_ptr) { + ESP_LOGD(TAG, "%p, slave #%d(%d) [%s], receive data ready.", ctx, (int)event_info->opt_fd, + (int)node_ptr->sock_id, node_ptr->addr_info.ip_addr_str); + while ((sz <= 0) && !queue_is_empty(node_ptr->rx_queue)) { + size_t sz = queue_pop(node_ptr->rx_queue, buf, MB_TCP_BUFF_MAX_SIZE, NULL); + if ((sz > MB_TCP_FUNC) && (sz < sizeof(buf))) { + uint16_t tid = MB_TCP_MBAP_GET_FIELD(buf, MB_TCP_TID); ESP_LOGD(TAG, "%p, packet TID: 0x%04" PRIx16 " received.", ctx, tid); - if (tid == (pnode_info->tid_counter - 1)) { - queue_push(pnode_info->rx_queue, pbuf, sz, NULL); + if (tid == (node_ptr->tid_counter - 1)) { + queue_push(node_ptr->rx_queue, buf, sz, NULL); mb_drv_lock(ctx); - pnode_info->recv_time = esp_timer_get_time(); + node_ptr->recv_time = esp_timer_get_time(); mb_drv_unlock(ctx); // send receive event to modbus object - pdrv_ctx->event_cbs.mb_sync_event_cb(pdrv_ctx->event_cbs.port_arg, MB_SYNC_EVENT_RECV_OK); + drv_obj->event_cbs.mb_sync_event_cb(drv_obj->event_cbs.port_arg, MB_SYNC_EVENT_RECV_OK); break; } } @@ -643,32 +643,32 @@ MB_EVENT_HANDLER(mbm_on_recv_data) MB_EVENT_HANDLER(mbm_on_close) { - mb_event_info_t *pevent_info = (mb_event_info_t *)data; - ESP_LOGD(TAG, "%s %s, fd: %d", (char *)base, __func__, (int)pevent_info->opt_fd); - port_driver_t *pdrv_ctx = MB_GET_DRV_PTR(ctx); + mb_event_info_t *event_info = (mb_event_info_t *)data; + ESP_LOGD(TAG, "%s %s, fd: %d", (char *)base, __func__, (int)event_info->opt_fd); + port_driver_t *drv_obj = MB_GET_DRV_PTR(ctx); mb_node_info_t *pnode = NULL; // if close all sockets event is received - if (pevent_info->opt_fd < 0) { + if (event_info->opt_fd < 0) { ESP_LOGD(TAG, "%p, Close all nodes...", ctx); - (void)mb_drv_clear_status_flag(pdrv_ctx, MB_FLAG_DISCONNECTED); + (void)mb_drv_clear_status_flag(drv_obj, MB_FLAG_DISCONNECTED); for (int fd = 0; fd < MB_MAX_FDS; fd++) { - mb_node_info_t *pnode = mb_drv_get_node(pdrv_ctx, fd); + mb_node_info_t *pnode = mb_drv_get_node(drv_obj, fd); if (pnode && (MB_GET_NODE_STATE(pnode) >= MB_SOCK_STATE_OPENED) - && FD_ISSET(pnode->index, &pdrv_ctx->open_set)) { + && FD_ISSET(pnode->index, &drv_obj->open_set)) { // Close node immediately - mb_drv_close(pdrv_ctx, fd); + mb_drv_close(drv_obj, fd); MB_SET_NODE_STATE(pnode, MB_SOCK_STATE_READY); ESP_LOGD(TAG, "%p, Close node %d, sock #%d.", ctx, fd, pnode->sock_id); } } - (void)mb_drv_set_status_flag(pdrv_ctx, MB_FLAG_DISCONNECTED); + (void)mb_drv_set_status_flag(drv_obj, MB_FLAG_DISCONNECTED); mb_drv_check_suspend_shutdown(ctx); - } else if (MB_CHECK_FD_RANGE(pevent_info->opt_fd)) { - pnode = mb_drv_get_node(pdrv_ctx, pevent_info->opt_fd); + } else if (MB_CHECK_FD_RANGE(event_info->opt_fd)) { + pnode = mb_drv_get_node(drv_obj, event_info->opt_fd); if (pnode && (MB_GET_NODE_STATE(pnode) >= MB_SOCK_STATE_OPENED)) { - ESP_LOGD(TAG, "%p, Close node %d, sock #%d, intentionally.", ctx, (int)pevent_info->opt_fd, pnode->sock_id); - if ((pnode->sock_id < 0) && FD_ISSET(pnode->sock_id, &pdrv_ctx->open_set)) { - mb_drv_close(pdrv_ctx, pevent_info->opt_fd); + ESP_LOGD(TAG, "%p, Close node %d, sock #%d, intentionally.", ctx, (int)event_info->opt_fd, pnode->sock_id); + if ((pnode->sock_id < 0) && FD_ISSET(pnode->sock_id, &drv_obj->open_set)) { + mb_drv_close(drv_obj, event_info->opt_fd); } } mb_drv_check_suspend_shutdown(ctx); @@ -678,8 +678,8 @@ MB_EVENT_HANDLER(mbm_on_close) MB_EVENT_HANDLER(mbm_on_timeout) { // Socket read/write timeout is triggered - mb_event_info_t *pevent_info = (mb_event_info_t *)data; - ESP_LOGD(TAG, "%s %s: fd: %d", (char *)base, __func__, (int)pevent_info->opt_fd); + mb_event_info_t *event_info = (mb_event_info_t *)data; + ESP_LOGD(TAG, "%s %s: fd: %d", (char *)base, __func__, (int)event_info->opt_fd); // Todo: this event can be used to check network state (kkep empty for now) mb_drv_check_suspend_shutdown(ctx); } diff --git a/modbus/mb_ports/tcp/port_tcp_master.h b/modbus/mb_ports/tcp/port_tcp_master.h index c6779c3..1791a9d 100644 --- a/modbus/mb_ports/tcp/port_tcp_master.h +++ b/modbus/mb_ports/tcp/port_tcp_master.h @@ -23,8 +23,8 @@ extern "C" { #if (CONFIG_FMB_COMM_MODE_TCP_EN) -typedef enum _mb_sock_state mb_sock_state_t; -typedef struct _uid_info mb_uid_info_t; +typedef enum mb_sock_state_enum mb_sock_state_t; +typedef struct uid_info_s mb_uid_info_t; void mbm_port_tcp_set_conn_cb(mb_port_base_t *inst, void *conn_fp, void *arg); mb_uid_info_t *mbm_port_tcp_get_slave_info(mb_port_base_t *inst, uint8_t uid, mb_sock_state_t exp_state); diff --git a/modbus/mb_ports/tcp/port_tcp_slave.c b/modbus/mb_ports/tcp/port_tcp_slave.c index 5f7e67f..ab3570d 100644 --- a/modbus/mb_ports/tcp/port_tcp_slave.c +++ b/modbus/mb_ports/tcp/port_tcp_slave.c @@ -26,7 +26,7 @@ typedef struct mb_uid_info_t addr_info; uint8_t ptemp_buf[MB_TCP_BUFF_MAX_SIZE]; // The driver object for the slave - port_driver_t *pdriver; + port_driver_t *drv_obj; transaction_handle_t transaction; uint16_t trans_count; } mbs_tcp_port_t; @@ -38,31 +38,31 @@ static uint64_t mbs_port_tcp_sync_event(void *inst, mb_sync_event_t sync_event); static esp_err_t mbs_port_tcp_register_handlers(void *ctx) { - port_driver_t *pdrv_ctx = MB_GET_DRV_PTR(ctx); + port_driver_t *drv_obj = MB_GET_DRV_PTR(ctx); esp_err_t ret = ESP_ERR_INVALID_STATE; - ret = mb_drv_register_handler(pdrv_ctx, MB_EVENT_READY_NUM, mbs_on_ready); + ret = mb_drv_register_handler(drv_obj, 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_NUM, mbs_on_open); + ret = mb_drv_register_handler(drv_obj, 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_NUM, mbs_on_connect); + ret = mb_drv_register_handler(drv_obj, 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_NUM, mbs_on_error); + ret = mb_drv_register_handler(drv_obj, 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_NUM, mbs_on_send_data); + ret = mb_drv_register_handler(drv_obj, 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_NUM, mbs_on_recv_data); + ret = mb_drv_register_handler(drv_obj, 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_NUM, mbs_on_close); + ret = mb_drv_register_handler(drv_obj, 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_NUM, mbs_on_timeout); + ret = mb_drv_register_handler(drv_obj, 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; @@ -70,29 +70,29 @@ static esp_err_t mbs_port_tcp_register_handlers(void *ctx) static esp_err_t mbs_port_tcp_unregister_handlers(void *ctx) { - port_driver_t *pdrv_ctx = MB_GET_DRV_PTR(ctx); + port_driver_t *drv_obj = MB_GET_DRV_PTR(ctx); esp_err_t ret = ESP_ERR_INVALID_STATE; - ESP_LOGD(TAG, "%p, event handler %p, unregister.", pdrv_ctx, pdrv_ctx->event_handler); + ESP_LOGD(TAG, "%p, event handler %p, unregister.", drv_obj, drv_obj->event_handler); - ret = mb_drv_unregister_handler(pdrv_ctx, MB_EVENT_READY_NUM); + ret = mb_drv_unregister_handler(drv_obj, 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_NUM); + ret = mb_drv_unregister_handler(drv_obj, 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_NUM); + ret = mb_drv_unregister_handler(drv_obj, 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_NUM); + ret = mb_drv_unregister_handler(drv_obj, 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_NUM); + ret = mb_drv_unregister_handler(drv_obj, 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_NUM); + ret = mb_drv_unregister_handler(drv_obj, 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_NUM); + ret = mb_drv_unregister_handler(drv_obj, 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; @@ -103,39 +103,40 @@ mb_err_enum_t mbs_port_tcp_create(mb_tcp_opts_t *tcp_opts, mb_port_base_t **port MB_RETURN_ON_FALSE((port_obj && tcp_opts), MB_EINVAL, TAG, "mb tcp port invalid arguments."); mbs_tcp_port_t *ptcp = NULL; esp_err_t err = ESP_ERR_INVALID_STATE; - ptcp = (mbs_tcp_port_t *)calloc(1, sizeof(mbs_tcp_port_t)); - MB_RETURN_ON_FALSE((ptcp && port_obj), MB_EILLSTATE, TAG, "mb tcp port creation error."); - CRITICAL_SECTION_INIT(ptcp->base.lock); mb_err_enum_t ret = MB_EILLSTATE; + ptcp = (mbs_tcp_port_t *)calloc(1, sizeof(mbs_tcp_port_t)); + MB_GOTO_ON_FALSE((ptcp && port_obj), MB_EILLSTATE, error, TAG, "mb tcp port creation error."); + + CRITICAL_SECTION_INIT(ptcp->base.lock); // Copy object descriptor from parent object (is used for logging) - ptcp->base.descr = ((mb_port_base_t *)*port_obj)->descr; - ptcp->pdriver = NULL; + ptcp->base.descr = (*port_obj)->descr; + ptcp->drv_obj = NULL; ptcp->transaction = transaction_init(); MB_GOTO_ON_FALSE((ptcp->transaction), MB_EILLSTATE, error, TAG, "mb transaction init failed."); ESP_MEM_CHECK(TAG, ptcp->transaction, goto error); - err = mb_drv_register(&ptcp->pdriver); - MB_GOTO_ON_FALSE(((err == ESP_OK) && ptcp->pdriver), MB_EILLSTATE, error, + err = mb_drv_register(&ptcp->drv_obj); + MB_GOTO_ON_FALSE(((err == ESP_OK) && ptcp->drv_obj), MB_EILLSTATE, error, TAG, "mb tcp port driver registration failed, err = (%x).", (int)err); - err = mbs_port_tcp_register_handlers(ptcp->pdriver); - MB_GOTO_ON_FALSE(((err == ESP_OK) && ptcp->pdriver), MB_EILLSTATE, error, + err = mbs_port_tcp_register_handlers(ptcp->drv_obj); + MB_GOTO_ON_FALSE(((err == ESP_OK) && ptcp->drv_obj), MB_EILLSTATE, error, TAG, "mb tcp port driver registration failed, err = (%x).", (int)err); - ptcp->pdriver->parent = ptcp; // just for logging purposes + ptcp->drv_obj->parent = ptcp; // just for logging purposes ptcp->tcp_opts = *tcp_opts; - ptcp->pdriver->network_iface_ptr = tcp_opts->ip_netif_ptr; - ptcp->pdriver->mb_proto = tcp_opts->mode; - ptcp->pdriver->uid = tcp_opts->uid; - ptcp->pdriver->is_master = false; - ptcp->pdriver->event_cbs.mb_sync_event_cb = mbs_port_tcp_sync_event; - ptcp->pdriver->event_cbs.port_arg = (void *)ptcp; + ptcp->drv_obj->network_iface_ptr = tcp_opts->ip_netif_ptr; + ptcp->drv_obj->mb_proto = tcp_opts->mode; + ptcp->drv_obj->uid = tcp_opts->uid; + ptcp->drv_obj->is_master = false; + ptcp->drv_obj->event_cbs.mb_sync_event_cb = mbs_port_tcp_sync_event; + ptcp->drv_obj->event_cbs.port_arg = (void *)ptcp; #ifdef MB_MDNS_IS_INCLUDED -err = port_start_mdns_service(&ptcp->pdriver->dns_name, false, tcp_opts->uid, ptcp->pdriver->network_iface_ptr); +err = port_start_mdns_service(&ptcp->drv_obj->dns_name, false, tcp_opts->uid, ptcp->drv_obj->network_iface_ptr); MB_GOTO_ON_FALSE((err == ESP_OK), MB_EILLSTATE, error, TAG, "mb tcp port mdns service init failure."); ESP_LOGD(TAG, "Start mdns for @%p", ptcp); @@ -153,15 +154,14 @@ error: { transaction_destroy(ptcp->transaction); } + if (ptcp && ptcp->drv_obj) { #ifdef MB_MDNS_IS_INCLUDED - port_stop_mdns_service(&ptcp->pdriver->dns_name); + port_stop_mdns_service(&ptcp->drv_obj->dns_name); #endif - if (ptcp && ptcp->pdriver) - { - if (ptcp->pdriver->event_handler[0]) { - mbs_port_tcp_unregister_handlers(ptcp->pdriver); + if (ptcp->drv_obj->event_handler[0]) { + mbs_port_tcp_unregister_handlers(ptcp->drv_obj); } - (void)mb_drv_unregister(ptcp->pdriver); + (void)mb_drv_unregister(ptcp->drv_obj); CRITICAL_SECTION_CLOSE(ptcp->base.lock); } free(ptcp); @@ -171,20 +171,17 @@ error: void mbs_port_tcp_delete(mb_port_base_t *inst) { mbs_tcp_port_t *port_obj = __containerof(inst, mbs_tcp_port_t, base); - if (port_obj && port_obj->transaction) - { + if (port_obj && port_obj->transaction) { transaction_destroy(port_obj->transaction); } + if (port_obj && port_obj->drv_obj) { #ifdef MB_MDNS_IS_INCLUDED - port_stop_mdns_service(&port_obj->pdriver->dns_name); + port_stop_mdns_service(&port_obj->drv_obj->dns_name); #endif - if (port_obj && port_obj->pdriver) - { - if (port_obj->pdriver->event_handler[0]) - { - mbs_port_tcp_unregister_handlers(port_obj->pdriver); + if (port_obj->drv_obj->event_handler[0]) { + mbs_port_tcp_unregister_handlers(port_obj->drv_obj); } - (void)mb_drv_unregister(port_obj->pdriver); + (void)mb_drv_unregister(port_obj->drv_obj); } CRITICAL_SECTION_CLOSE(inst->lock); free(port_obj); @@ -193,46 +190,42 @@ void mbs_port_tcp_delete(mb_port_base_t *inst) void mbs_port_tcp_enable(mb_port_base_t *inst) { mbs_tcp_port_t *port_obj = __containerof(inst, mbs_tcp_port_t, base); - (void)mb_drv_start_task(port_obj->pdriver); - DRIVER_SEND_EVENT(port_obj->pdriver, MB_EVENT_READY, UNDEF_FD); + (void)mb_drv_start_task(port_obj->drv_obj); + DRIVER_SEND_EVENT(port_obj->drv_obj, MB_EVENT_READY, UNDEF_FD); } void mbs_port_tcp_disable(mb_port_base_t *inst) { mbs_tcp_port_t *port_obj = __containerof(inst, mbs_tcp_port_t, base); // Change the state of all slaves to close - DRIVER_SEND_EVENT(port_obj->pdriver, MB_EVENT_CLOSE, UNDEF_FD); - (void)mb_drv_wait_status_flag(port_obj->pdriver, MB_FLAG_DISCONNECTED, pdMS_TO_TICKS(MB_RECONNECT_TIME_MS)); + DRIVER_SEND_EVENT(port_obj->drv_obj, MB_EVENT_CLOSE, UNDEF_FD); + (void)mb_drv_wait_status_flag(port_obj->drv_obj, MB_FLAG_DISCONNECTED, pdMS_TO_TICKS(MB_RECONNECT_TIME_MS)); } -bool mbs_port_tcp_recv_data(mb_port_base_t *inst, uint8_t **ppframe, uint16_t *plength) +bool mbs_port_tcp_recv_data(mb_port_base_t *inst, uint8_t **frame, uint16_t *length) { mbs_tcp_port_t *port_obj = __containerof(inst, mbs_tcp_port_t, base); - port_driver_t *pdrv_ctx = port_obj->pdriver; + port_driver_t *drv_obj = port_obj->drv_obj; mb_node_info_t *pnode = NULL; bool status = false; transaction_item_handle_t item; - if (plength && ppframe && *ppframe) - { - mb_drv_lock(pdrv_ctx); + if (length && frame && *frame) { + mb_drv_lock(drv_obj); item = transaction_get_first(port_obj->transaction); - if (item && (transaction_item_get_state(item) == ACKNOWLEDGED)) - { + if (item && (transaction_item_get_state(item) == ACKNOWLEDGED)) { uint16_t tid = 0; int node_id = 0; size_t len = 0; - uint8_t *pbuf = transaction_item_get_data(item, &len, &tid, &node_id); - pnode = mb_drv_get_node(pdrv_ctx, node_id); - if (pbuf && pnode && (MB_GET_NODE_STATE(pnode) >= MB_SOCK_STATE_CONNECTED)) - { - memcpy(*ppframe, pbuf, len); - //*ppframe = pbuf; - *plength = (uint16_t)len; + uint8_t *buf = transaction_item_get_data(item, &len, &tid, &node_id); + pnode = mb_drv_get_node(drv_obj, node_id); + if (buf && pnode && (MB_GET_NODE_STATE(pnode) >= MB_SOCK_STATE_CONNECTED)) { + memcpy(*frame, buf, len); + *length = (uint16_t)len; status = true; ESP_LOGD(TAG, "%p, " MB_NODE_FMT(", get packet TID: 0x%04" PRIx16 ", %p."), port_obj, pnode->index, pnode->sock_id, - pnode->addr_info.ip_addr_str, (unsigned)pnode->tid_counter, *ppframe); + pnode->addr_info.ip_addr_str, (unsigned)pnode->tid_counter, *frame); if (ESP_OK != transaction_item_set_state(item, CONFIRMED)) { ESP_LOGE(TAG, "transaction queue set state fail."); } @@ -246,40 +239,40 @@ bool mbs_port_tcp_recv_data(mb_port_base_t *inst, uint8_t **ppframe, uint16_t *p ESP_LOGE(TAG, "Deleted %d expired frames.", frame_cnt); } } - mb_drv_unlock(pdrv_ctx); + mb_drv_unlock(drv_obj); } return status; } -bool mbs_port_tcp_send_data(mb_port_base_t *inst, uint8_t *pframe, uint16_t length) +bool mbs_port_tcp_send_data(mb_port_base_t *inst, uint8_t *frame, uint16_t length) { mbs_tcp_port_t *port_obj = __containerof(inst, mbs_tcp_port_t, base); - MB_RETURN_ON_FALSE((pframe && (length > 0)), false, TAG, "incorrect arguments."); + MB_RETURN_ON_FALSE((frame && (length > 0)), false, TAG, "incorrect arguments."); bool frame_sent = false; - uint16_t tid = MB_TCP_MBAP_GET_FIELD(pframe, MB_TCP_TID); - port_driver_t *pdrv_ctx = port_obj->pdriver; + uint16_t tid = MB_TCP_MBAP_GET_FIELD(frame, MB_TCP_TID); + port_driver_t *drv_obj = port_obj->drv_obj; transaction_item_handle_t item; - mb_drv_lock(pdrv_ctx); + mb_drv_lock(drv_obj); item = transaction_dequeue(port_obj->transaction, CONFIRMED, NULL); if (item) { uint16_t msg_id = 0; int node_id = 0; - uint8_t *pbuf = transaction_item_get_data(item, NULL, &msg_id, &node_id); - if (pbuf && (tid == msg_id)) { - mb_node_info_t *pnode = mb_drv_get_node(pdrv_ctx, node_id); - int write_length = mb_drv_write(pdrv_ctx, node_id, pframe, length); + uint8_t *buf = transaction_item_get_data(item, NULL, &msg_id, &node_id); + if (buf && (tid == msg_id)) { + mb_node_info_t *pnode = mb_drv_get_node(drv_obj, node_id); + int write_length = mb_drv_write(drv_obj, node_id, frame, length); if (pnode && write_length) { frame_sent = true; ESP_LOGD(TAG, "%p, node: #%d, socket(#%d)[%s], send packet TID: 0x%04" PRIx16 ":0x%04" PRIx16 ", %p, len: %d, ", - pdrv_ctx, pnode->index, pnode->sock_id, - pnode->addr_info.node_name_str, (unsigned)tid, (unsigned)msg_id, pframe, length); + drv_obj, pnode->index, pnode->sock_id, + pnode->addr_info.node_name_str, (unsigned)tid, (unsigned)msg_id, frame, length); } else { ESP_LOGE(TAG, "%p, node: #%d, socket(#%d)[%s], mbs_write fail, TID: 0x%04" PRIx16 ":0x%04" PRIx16 ", %p, len: %d, ", - pdrv_ctx, pnode->index, pnode->sock_id, - pnode->addr_info.node_name_str, (unsigned)tid, (unsigned)msg_id, pframe, length); + drv_obj, pnode->index, pnode->sock_id, + pnode->addr_info.node_name_str, (unsigned)tid, (unsigned)msg_id, frame, length); } if (ESP_OK != transaction_item_set_state(item, REPLIED)) { ESP_LOGE(TAG, "transaction queue set state fail."); @@ -288,10 +281,9 @@ bool mbs_port_tcp_send_data(mb_port_base_t *inst, uint8_t *pframe, uint16_t leng } else { ESP_LOGE(TAG, "queue can not find the item to send."); } - mb_drv_unlock(pdrv_ctx); + mb_drv_unlock(drv_obj); - if (!frame_sent) - { + if (!frame_sent) { ESP_LOGE(TAG, "incorrect frame to send."); } return frame_sent; @@ -325,10 +317,10 @@ static uint64_t mbs_port_tcp_sync_event(void *inst, mb_sync_event_t sync_event) MB_EVENT_HANDLER(mbs_on_ready) { // The driver is registered - mb_event_info_t *pevent_info = (mb_event_info_t *)data; - port_driver_t *pdrv_ctx = MB_GET_DRV_PTR(ctx); - mbs_tcp_port_t *port_obj = __containerof(pdrv_ctx->parent, mbs_tcp_port_t, base); - ESP_LOGD(TAG, "%s %s: fd: %d", (char *)base, __func__, (int)pevent_info->opt_fd); + mb_event_info_t *event_info = (mb_event_info_t *)data; + port_driver_t *drv_obj = MB_GET_DRV_PTR(ctx); + mbs_tcp_port_t *port_obj = __containerof(drv_obj->parent, mbs_tcp_port_t, base); + ESP_LOGD(TAG, "%s %s: fd: %d", (char *)base, __func__, (int)event_info->opt_fd); ESP_LOGD(TAG, "addr_table:%p, addr_type:%d, mode:%d, port:%d", port_obj->tcp_opts.ip_addr_table, (int)port_obj->tcp_opts.addr_type, (int)port_obj->tcp_opts.mode, @@ -338,14 +330,13 @@ MB_EVENT_HANDLER(mbs_on_ready) port_obj->tcp_opts.addr_type, port_obj->tcp_opts.mode, port_obj->tcp_opts.port); - if (listen_sock < 0) - { + if (listen_sock < 0) { mb_drv_check_suspend_shutdown(ctx); ESP_LOGE(TAG, "%s, sock: %d, bind error", (char *)base, listen_sock); - mb_drv_lock(pdrv_ctx); - if (pdrv_ctx->retry_cnt) pdrv_ctx->retry_cnt--; - mb_drv_unlock(pdrv_ctx); - if (pdrv_ctx->retry_cnt) { + mb_drv_lock(drv_obj); + if (drv_obj->retry_cnt) drv_obj->retry_cnt--; + mb_drv_unlock(drv_obj); + if (drv_obj->retry_cnt) { vTaskDelay(TRANSACTION_TICKS); DRIVER_SEND_EVENT(ctx, MB_EVENT_READY, UNDEF_FD); } else { @@ -353,107 +344,98 @@ MB_EVENT_HANDLER(mbs_on_ready) ESP_LOGE(TAG, "%s, stop binding.", (char *)base); // mbs_port_tcp_disable(&port_obj->base); } - } - else - { + } else { mb_drv_lock(ctx); - pdrv_ctx->listen_sock_fd = listen_sock; + drv_obj->listen_sock_fd = listen_sock; // so, all accepted sockets will inherit the keep-alive feature - (void)port_keep_alive(pdrv_ctx->listen_sock_fd); + (void)port_keep_alive(drv_obj->listen_sock_fd); mb_drv_unlock(ctx); - ESP_LOGI(TAG, "%s %s: fd: %d, bind is done", (char *)base, __func__, (int)pevent_info->opt_fd); + ESP_LOGI(TAG, "%s %s: fd: %d, bind is done", (char *)base, __func__, (int)event_info->opt_fd); } } MB_EVENT_HANDLER(mbs_on_open) { - mb_event_info_t *pevent_info = (mb_event_info_t *)data; - ESP_LOGD(TAG, "%s %s: fd: %d", (char *)base, __func__, (int)pevent_info->opt_fd); + mb_event_info_t *event_info = (mb_event_info_t *)data; + ESP_LOGD(TAG, "%s %s: fd: %d", (char *)base, __func__, (int)event_info->opt_fd); } MB_EVENT_HANDLER(mbs_on_connect) { - mb_event_info_t *pevent_info = (mb_event_info_t *)data; - port_driver_t *pdrv_ctx = MB_GET_DRV_PTR(ctx); - ESP_LOGD(TAG, "%s %s: fd: %d", (char *)base, __func__, (int)pevent_info->opt_fd); - mb_node_info_t *pnode = mb_drv_get_node(pdrv_ctx, pevent_info->opt_fd); + mb_event_info_t *event_info = (mb_event_info_t *)data; + port_driver_t *drv_obj = MB_GET_DRV_PTR(ctx); + ESP_LOGD(TAG, "%s %s: fd: %d", (char *)base, __func__, (int)event_info->opt_fd); + mb_node_info_t *pnode = mb_drv_get_node(drv_obj, event_info->opt_fd); if (!pnode) { - ESP_LOGD(TAG, "%s %s: fd: %d, is closed.", (char *)base, __func__, (int)pevent_info->opt_fd); + ESP_LOGD(TAG, "%s %s: fd: %d, is closed.", (char *)base, __func__, (int)event_info->opt_fd); return; } (void)port_keep_alive(pnode->sock_id); mb_drv_lock(ctx); MB_SET_NODE_STATE(pnode, MB_SOCK_STATE_CONNECTED); - FD_SET(pnode->sock_id, &pdrv_ctx->conn_set); - if (pdrv_ctx->node_conn_count < MB_MAX_FDS) { - pdrv_ctx->node_conn_count++; + FD_SET(pnode->sock_id, &drv_obj->conn_set); + if (drv_obj->node_conn_count < MB_MAX_FDS) { + drv_obj->node_conn_count++; } mb_drv_unlock(ctx); } MB_EVENT_HANDLER(mbs_on_recv_data) { - port_driver_t *pdrv_ctx = MB_GET_DRV_PTR(ctx); - mb_event_info_t *pevent_info = (mb_event_info_t *)data; - mbs_tcp_port_t *port_obj = (mbs_tcp_port_t *)pdrv_ctx->parent; - ESP_LOGD(TAG, "%s %s: fd: %d", (char *)base, __func__, (int)pevent_info->opt_fd); - mb_node_info_t *pnode = mb_drv_get_node(pdrv_ctx, pevent_info->opt_fd); + port_driver_t *drv_obj = MB_GET_DRV_PTR(ctx); + mb_event_info_t *event_info = (mb_event_info_t *)data; + mbs_tcp_port_t *port_obj = (mbs_tcp_port_t *)drv_obj->parent; + ESP_LOGD(TAG, "%s %s: fd: %d", (char *)base, __func__, (int)event_info->opt_fd); + mb_node_info_t *pnode = mb_drv_get_node(drv_obj, event_info->opt_fd); transaction_item_handle_t item = NULL; - if (pnode) - { - if (!queue_is_empty(pnode->rx_queue)) - { - ESP_LOGD(TAG, "%p, node #%d(%d) [%s], receive data ready.", ctx, (int)pevent_info->opt_fd, + if (pnode) { + if (!queue_is_empty(pnode->rx_queue)) { + ESP_LOGD(TAG, "%p, node #%d(%d) [%s], receive data ready.", ctx, (int)event_info->opt_fd, (int)pnode->sock_id, pnode->addr_info.ip_addr_str); frame_entry_t frame_entry; size_t sz = queue_pop(pnode->rx_queue, NULL, MB_BUFFER_SIZE, &frame_entry); - if (sz > MB_TCP_FUNC) - { - uint16_t tid_counter = MB_TCP_MBAP_GET_FIELD(frame_entry.pbuf, MB_TCP_TID); + if (sz > MB_TCP_FUNC) { + uint16_t tid_counter = MB_TCP_MBAP_GET_FIELD(frame_entry.buf, MB_TCP_TID); ESP_LOGD(TAG, "%p, " MB_NODE_FMT(", received packet TID: 0x%04" PRIx16 ", %p."), - pdrv_ctx, pnode->index, pnode->sock_id, - pnode->addr_info.ip_addr_str, (unsigned)tid_counter, frame_entry.pbuf); - mb_drv_lock(pdrv_ctx); + drv_obj, pnode->index, pnode->sock_id, + pnode->addr_info.ip_addr_str, (unsigned)tid_counter, frame_entry.buf); + mb_drv_lock(drv_obj); transaction_message_t msg; - msg.buffer = frame_entry.pbuf; + msg.buffer = frame_entry.buf; msg.len = frame_entry.len; msg.msg_id = frame_entry.tid; msg.node_id = pnode->index; msg.pnode = pnode; item = transaction_enqueue(port_obj->transaction, &msg, port_get_timestamp()); pnode->tid_counter = tid_counter; // assign the TID from frame to use it on send - mb_drv_unlock(pdrv_ctx); + mb_drv_unlock(drv_obj); } } - mb_drv_lock(pdrv_ctx); + mb_drv_lock(drv_obj); item = transaction_get_first(port_obj->transaction); - if (item) - { - if (transaction_item_get_state(item) == QUEUED) - { + if (item) { + if (transaction_item_get_state(item) == QUEUED) { // send receive event to modbus object to get the new data uint16_t msg_id = 0; uint64_t tick = 0; (void)transaction_item_get_data(item, NULL, &msg_id, NULL); tick = port_get_timestamp(); - pdrv_ctx->event_cbs.mb_sync_event_cb(pdrv_ctx->event_cbs.port_arg, MB_SYNC_EVENT_RECV_OK); + drv_obj->event_cbs.mb_sync_event_cb(drv_obj->event_cbs.port_arg, MB_SYNC_EVENT_RECV_OK); transaction_set_tick(port_obj->transaction, msg_id, (transaction_tick_t)tick); if (ESP_OK == transaction_item_set_state(item, ACKNOWLEDGED)) { ESP_LOGD(TAG, "%p, " MB_NODE_FMT(", acknoledged packet TID: 0x%04" PRIx16 "."), - pdrv_ctx, pnode->index, pnode->sock_id, + drv_obj, pnode->index, pnode->sock_id, pnode->addr_info.ip_addr_str, (unsigned)msg_id); } - } - else - { + } else { if (transaction_item_get_state(item) != TRANSMITTED) { // Todo: for test removing expired item transaction_delete_expired(port_obj->transaction, port_get_timestamp(), 1000 * 1000); } - if (MB_FLAG_TRANSACTION_DONE == mb_drv_wait_status_flag(port_obj->pdriver, + if (MB_FLAG_TRANSACTION_DONE == mb_drv_wait_status_flag(port_obj->drv_obj, MB_FLAG_TRANSACTION_DONE, TRANSACTION_TICKS)) { - (void)mb_drv_clear_status_flag(pdrv_ctx, MB_FLAG_TRANSACTION_DONE); + (void)mb_drv_clear_status_flag(drv_obj, MB_FLAG_TRANSACTION_DONE); } // postpone the packet processing DRIVER_SEND_EVENT(ctx, MB_EVENT_RECV_DATA, pnode->index); @@ -461,20 +443,19 @@ MB_EVENT_HANDLER(mbs_on_recv_data) } else { ESP_LOGE(TAG, "%p, no queued items found", ctx); } - mb_drv_unlock(pdrv_ctx); + mb_drv_unlock(drv_obj); } mb_drv_check_suspend_shutdown(ctx); } MB_EVENT_HANDLER(mbs_on_send_data) { - port_driver_t *pdrv_ctx = MB_GET_DRV_PTR(ctx); - mb_event_info_t *pevent_info = (mb_event_info_t *)data; - mbs_tcp_port_t *port_obj = (mbs_tcp_port_t *)pdrv_ctx->parent; - ESP_LOGD(TAG, "%s %s: fd: %d", (char *)base, __func__, (int)pevent_info->opt_fd); - mb_node_info_t *pnode = mb_drv_get_node(pdrv_ctx, pevent_info->opt_fd); - if (pnode && !queue_is_empty(pnode->tx_queue)) - { + port_driver_t *drv_obj = MB_GET_DRV_PTR(ctx); + mb_event_info_t *event_info = (mb_event_info_t *)data; + mbs_tcp_port_t *port_obj = (mbs_tcp_port_t *)drv_obj->parent; + ESP_LOGD(TAG, "%s %s: fd: %d", (char *)base, __func__, (int)event_info->opt_fd); + mb_node_info_t *pnode = mb_drv_get_node(drv_obj, event_info->opt_fd); + if (pnode && !queue_is_empty(pnode->tx_queue)) { frame_entry_t frame_entry; // pop the frame entry, keep the buffer size_t sz = queue_pop(pnode->tx_queue, NULL, MB_BUFFER_SIZE, &frame_entry); @@ -483,94 +464,88 @@ MB_EVENT_HANDLER(mbs_on_send_data) ctx, (int)pnode->index, (int)pnode->sock_id, pnode->addr_info.ip_addr_str); return; } - uint16_t tid = MB_TCP_MBAP_GET_FIELD(frame_entry.pbuf, MB_TCP_TID); + uint16_t tid = MB_TCP_MBAP_GET_FIELD(frame_entry.buf, MB_TCP_TID); pnode->error = 0; - int ret = port_write_poll(pnode, frame_entry.pbuf, sz, MB_TCP_SEND_TIMEOUT_MS); - if (ret < 0) - { + int ret = port_write_poll(pnode, frame_entry.buf, sz, MB_TCP_SEND_TIMEOUT_MS); + if (ret < 0) { ESP_LOGE(TAG, "%p, " MB_NODE_FMT(", send data failure, err(errno) = %d(%u)."), ctx, (int)pnode->index, (int)pnode->sock_id, pnode->addr_info.ip_addr_str, (int)ret, (unsigned)errno); DRIVER_SEND_EVENT(ctx, MB_EVENT_ERROR, pnode->index); pnode->error = ret; - } - else - { + } else { pnode->error = 0; - if (tid != pnode->tid_counter) - { + if (tid != pnode->tid_counter) { ESP_LOGE(TAG, "%p, " MB_NODE_FMT(", send incorrect frame TID:0x%04" PRIx16 "!= 0x%04" PRIx16 ", %d (bytes), errno %d"), ctx, (int)pnode->index, (int)pnode->sock_id, pnode->addr_info.ip_addr_str, pnode->tid_counter, tid, (int)ret, (unsigned)errno); - } - else - { + } else { ESP_LOGD(TAG, "%p, " MB_NODE_FMT(", send data successful: TID:0x%04" PRIx16 ":0x%04" PRIx16 ", %d (bytes), errno %d"), ctx, (int)pnode->index, (int)pnode->sock_id, pnode->addr_info.ip_addr_str, pnode->tid_counter, tid, (int)ret, (unsigned)errno); } - ESP_LOG_BUFFER_HEX_LEVEL("SENT", frame_entry.pbuf, ret, ESP_LOG_DEBUG); + ESP_LOG_BUFFER_HEX_LEVEL("SENT", frame_entry.buf, ret, ESP_LOG_DEBUG); } - (void)mb_drv_set_status_flag(pdrv_ctx, MB_FLAG_TRANSACTION_DONE); - pdrv_ctx->event_cbs.mb_sync_event_cb(pdrv_ctx->event_cbs.port_arg, MB_SYNC_EVENT_SEND_OK); - mb_drv_lock(pdrv_ctx); + (void)mb_drv_set_status_flag(drv_obj, MB_FLAG_TRANSACTION_DONE); + drv_obj->event_cbs.mb_sync_event_cb(drv_obj->event_cbs.port_arg, MB_SYNC_EVENT_SEND_OK); + mb_drv_lock(drv_obj); transaction_set_state(port_obj->transaction, tid, TRANSMITTED); if (transaction_delete(port_obj->transaction, tid) != ESP_OK) { ESP_LOGE(TAG, "Failed to remove queued TID:0x%04" PRIx16, tid); } else { ESP_LOGD(TAG, "Remove the message TID:0x%04" PRIx16, tid); } - free(frame_entry.pbuf); + free(frame_entry.buf); pnode->send_time = esp_timer_get_time(); pnode->send_counter = (pnode->send_counter < (USHRT_MAX - 1)) ? (pnode->send_counter + 1) : 0; - mb_drv_unlock(pdrv_ctx); + mb_drv_unlock(drv_obj); } } MB_EVENT_HANDLER(mbs_on_error) { - port_driver_t *pdrv_ctx = MB_GET_DRV_PTR(ctx); - mb_event_info_t *pevent_info = (mb_event_info_t *)data; - ESP_LOGD(TAG, "%s %s: fd: %d", (char *)base, __func__, (int)pevent_info->opt_fd); - mb_node_info_t *pnode = mb_drv_get_node(pdrv_ctx, pevent_info->opt_fd); + port_driver_t *drv_obj = MB_GET_DRV_PTR(ctx); + mb_event_info_t *event_info = (mb_event_info_t *)data; + ESP_LOGD(TAG, "%s %s: fd: %d", (char *)base, __func__, (int)event_info->opt_fd); + mb_node_info_t *pnode = mb_drv_get_node(drv_obj, event_info->opt_fd); if (!pnode) { - ESP_LOGD(TAG, "%s %s: fd: %d, is closed.", (char *)base, __func__, (int)pevent_info->opt_fd); + ESP_LOGD(TAG, "%s %s: fd: %d, is closed.", (char *)base, __func__, (int)event_info->opt_fd); return; } // Check if the node is not alive for timeout - int ret = mb_drv_check_node_state(pdrv_ctx, (int *)&pevent_info->opt_fd, MB_TCP_EVENT_LOOP_TICK_MS); + int ret = mb_drv_check_node_state(drv_obj, (int *)&event_info->opt_fd, MB_TCP_EVENT_LOOP_TICK_MS); if ((ret != ERR_OK) && (ret != ERR_TIMEOUT)) { - ESP_LOGE(TAG, "Node: #%d is not alive, err= %d", (int)pevent_info->opt_fd, ret); - mb_drv_close(pdrv_ctx, pevent_info->opt_fd); + ESP_LOGE(TAG, "Node: #%d is not alive, err= %d", (int)event_info->opt_fd, ret); + mb_drv_close(drv_obj, event_info->opt_fd); } } MB_EVENT_HANDLER(mbs_on_close) { - mb_event_info_t *pevent_info = (mb_event_info_t *)data; - ESP_LOGD(TAG, "%s %s, fd: %d", (char *)base, __func__, (int)pevent_info->opt_fd); - port_driver_t *pdrv_ctx = MB_GET_DRV_PTR(ctx); + mb_event_info_t *event_info = (mb_event_info_t *)data; + ESP_LOGD(TAG, "%s %s, fd: %d", (char *)base, __func__, (int)event_info->opt_fd); + port_driver_t *drv_obj = MB_GET_DRV_PTR(ctx); mb_node_info_t *pnode =NULL; // if close all sockets event is received - if (pevent_info->opt_fd < 0) + if (event_info->opt_fd < 0) { - (void)mb_drv_clear_status_flag(pdrv_ctx, MB_FLAG_DISCONNECTED); + (void)mb_drv_clear_status_flag(drv_obj, MB_FLAG_DISCONNECTED); for (int fd = 0; fd < MB_MAX_FDS; fd++) { - mb_node_info_t *pnode = mb_drv_get_node(pdrv_ctx, fd); + mb_node_info_t *pnode = mb_drv_get_node(drv_obj, fd); if (pnode && (MB_GET_NODE_STATE(pnode) >= MB_SOCK_STATE_OPENED) - && FD_ISSET(pnode->index, &pdrv_ctx->open_set)) + && FD_ISSET(pnode->index, &drv_obj->open_set)) { - mb_drv_close(pdrv_ctx, fd); + mb_drv_close(drv_obj, fd); } } - (void)mb_drv_set_status_flag(pdrv_ctx, MB_FLAG_DISCONNECTED); + (void)mb_drv_set_status_flag(drv_obj, MB_FLAG_DISCONNECTED); mb_drv_check_suspend_shutdown(ctx); - } else if (MB_CHECK_FD_RANGE(pevent_info->opt_fd)) { - pnode = mb_drv_get_node(pdrv_ctx, pevent_info->opt_fd); + } else if (MB_CHECK_FD_RANGE(event_info->opt_fd)) { + pnode = mb_drv_get_node(drv_obj, event_info->opt_fd); if (pnode && (MB_GET_NODE_STATE(pnode) >= MB_SOCK_STATE_OPENED)) { - if ((pnode->sock_id < 0) && FD_ISSET(pnode->sock_id, &pdrv_ctx->open_set)) { - mb_drv_close(ctx, pevent_info->opt_fd); + if ((pnode->sock_id < 0) && FD_ISSET(pnode->sock_id, &drv_obj->open_set)) { + mb_drv_close(ctx, event_info->opt_fd); } } mb_drv_check_suspend_shutdown(ctx); @@ -580,17 +555,17 @@ MB_EVENT_HANDLER(mbs_on_close) MB_EVENT_HANDLER(mbs_on_timeout) { // Slave timeout triggered - //mb_event_info_t *pevent_info = (mb_event_info_t *)data; - port_driver_t *pdrv_ctx = MB_GET_DRV_PTR(ctx); + + port_driver_t *drv_obj = MB_GET_DRV_PTR(ctx); static int curr_fd = 0; - ESP_LOGD(TAG, "%s %s: fd: %d, %d", (char *)base, __func__, (int)curr_fd, pdrv_ctx->node_conn_count); + ESP_LOGD(TAG, "%s %s: fd: %d, %d", (char *)base, __func__, (int)curr_fd, drv_obj->node_conn_count); mb_drv_check_suspend_shutdown(ctx); - int ret = mb_drv_check_node_state(pdrv_ctx, &curr_fd, MB_RECONNECT_TIME_MS); + int ret = mb_drv_check_node_state(drv_obj, &curr_fd, MB_RECONNECT_TIME_MS); if ((ret != ERR_OK) && (ret != ERR_TIMEOUT)) { ESP_LOGE(TAG, "Node: %d, connection lost, err= %d", curr_fd, ret); - mb_drv_close(pdrv_ctx, curr_fd); + mb_drv_close(drv_obj, curr_fd); } - if ((curr_fd + 1) >= (pdrv_ctx->node_conn_count)) { + if ((curr_fd + 1) >= (drv_obj->node_conn_count)) { curr_fd = 0; } else { curr_fd++; diff --git a/modbus/mb_ports/tcp/port_tcp_utils.c b/modbus/mb_ports/tcp/port_tcp_utils.c index 0909397..b387907 100644 --- a/modbus/mb_ports/tcp/port_tcp_utils.c +++ b/modbus/mb_ports/tcp/port_tcp_utils.c @@ -25,10 +25,10 @@ bool port_check_host_addr(const char *host_str, ip_addr_t *host_addr) { MB_RETURN_ON_FALSE((host_str), false, TAG, "wrong host name or IP."); char cstr[HOST_STR_MAX_LEN]; - char *pstr = &cstr[0]; + char *string_ptr = &cstr[0]; ip_addr_t target_addr; struct addrinfo hint; - struct addrinfo *paddr_list; + struct addrinfo *addr_list; memset(&hint, 0, sizeof(hint)); // Do name resolution for both protocols hint.ai_family = AF_UNSPEC; @@ -38,53 +38,53 @@ bool port_check_host_addr(const char *host_str, ip_addr_t *host_addr) // convert domain name to IP address // Todo: check EAI_FAIL error when resolve host name - int ret = getaddrinfo(host_str, NULL, &hint, &paddr_list); + int ret = getaddrinfo(host_str, NULL, &hint, &addr_list); if (ret != 0) { ESP_LOGD(TAG, "Incorrect host IP: %s", host_str); return false; } - if (paddr_list->ai_family == AF_INET) { - struct in_addr addr4 = ((struct sockaddr_in *)(paddr_list->ai_addr))->sin_addr; + if (addr_list->ai_family == AF_INET) { + struct in_addr addr4 = ((struct sockaddr_in *)(addr_list->ai_addr))->sin_addr; inet_addr_to_ip4addr(ip_2_ip4(&target_addr), &addr4); - pstr = ip4addr_ntoa_r(ip_2_ip4(&target_addr), cstr, sizeof(cstr)); + string_ptr = ip4addr_ntoa_r(ip_2_ip4(&target_addr), cstr, sizeof(cstr)); } #if CONFIG_LWIP_IPV6 else { - struct in6_addr addr6 = ((struct sockaddr_in6 *)(paddr_list->ai_addr))->sin6_addr; + struct in6_addr addr6 = ((struct sockaddr_in6 *)(addr_list->ai_addr))->sin6_addr; inet6_addr_to_ip6addr(ip_2_ip6(&target_addr), &addr6); - pstr = ip6addr_ntoa_r(ip_2_ip6(&target_addr), cstr, sizeof(cstr)); + string_ptr = ip6addr_ntoa_r(ip_2_ip6(&target_addr), cstr, sizeof(cstr)); } #endif if (host_addr) { *host_addr = target_addr; } - ESP_LOGD(TAG, "Check name[IP]: \"%s\"[%s]", paddr_list->ai_canonname ? paddr_list->ai_canonname : "UNK", pstr); - freeaddrinfo(paddr_list); + ESP_LOGD(TAG, "Check name[IP]: \"%s\"[%s]", addr_list->ai_canonname ? addr_list->ai_canonname : "UNK", string_ptr); + freeaddrinfo(addr_list); return true; } -bool port_close_connection(mb_node_info_t *pinfo) +bool port_close_connection(mb_node_info_t *info_ptr) { - if (!pinfo) { + if (!info_ptr) { return false; } - if (pinfo->sock_id <= 0) { - ESP_LOGD(TAG, "wrong socket info or disconnected socket: %d, skip.", pinfo->index); + if (info_ptr->sock_id <= 0) { + ESP_LOGD(TAG, "wrong socket info or disconnected socket: %d, skip.", info_ptr->index); return false; } uint8_t tmp_buff[MB_PDU_SIZE_MAX]; // Empty tcp buffer before shutdown - (void)recv(pinfo->sock_id, &tmp_buff[0], MB_PDU_SIZE_MAX, MSG_DONTWAIT); - queue_flush(pinfo->rx_queue); - queue_flush(pinfo->tx_queue); + (void)recv(info_ptr->sock_id, &tmp_buff[0], MB_PDU_SIZE_MAX, MSG_DONTWAIT); + queue_flush(info_ptr->rx_queue); + queue_flush(info_ptr->tx_queue); - if (shutdown(pinfo->sock_id, SHUT_RDWR) == -1) { - ESP_LOGV(TAG, "Shutdown failed sock %d, errno=%d", pinfo->sock_id, (int)errno); + if (shutdown(info_ptr->sock_id, SHUT_RDWR) == -1) { + ESP_LOGV(TAG, "Shutdown failed sock %d, errno=%d", info_ptr->sock_id, (int)errno); } - close(pinfo->sock_id); - MB_SET_NODE_STATE(pinfo, MB_SOCK_STATE_OPENED); - pinfo->sock_id = UNDEF_FD; + close(info_ptr->sock_id); + MB_SET_NODE_STATE(info_ptr, MB_SOCK_STATE_OPENED); + info_ptr->sock_id = UNDEF_FD; return true; } @@ -101,47 +101,45 @@ static void port_ms_to_tv(uint16_t timeout_ms, struct timeval *tv) tv->tv_usec = (timeout_ms - (tv->tv_sec * 1000)) * 1000; } -int port_enqueue_packet(QueueHandle_t queue, uint8_t *pbuf, uint16_t len) +int port_enqueue_packet(QueueHandle_t queue, uint8_t *buf, uint16_t len) { frame_entry_t frame_info = {0}; esp_err_t ret = ESP_ERR_INVALID_STATE; - if (queue && pbuf) { - frame_info.tid = MB_TCP_MBAP_GET_FIELD(pbuf, MB_TCP_TID); - frame_info.uid = pbuf[MB_TCP_UID]; - frame_info.pid = MB_TCP_MBAP_GET_FIELD(pbuf, MB_TCP_PID); - frame_info.len = MB_TCP_MBAP_GET_FIELD(pbuf, MB_TCP_LEN) + MB_TCP_UID; + if (queue && buf) { + frame_info.tid = MB_TCP_MBAP_GET_FIELD(buf, MB_TCP_TID); + frame_info.uid = buf[MB_TCP_UID]; + frame_info.pid = MB_TCP_MBAP_GET_FIELD(buf, MB_TCP_PID); + frame_info.len = MB_TCP_MBAP_GET_FIELD(buf, MB_TCP_LEN) + MB_TCP_UID; if (len != frame_info.len) { ESP_LOGE(TAG, "Packet TID (%x), length in frame %u != %u expected.", frame_info.tid, frame_info.len, len); } assert(xPortGetFreeHeapSize() > frame_info.len); - ret = queue_push(queue, pbuf, frame_info.len, &frame_info); + ret = queue_push(queue, buf, frame_info.len, &frame_info); if (ret != ESP_OK) { ESP_LOGE(TAG, "Packet TID (%x), data enqueue failed.", frame_info.tid); // The packet send fail or the task which is waiting for event is already unblocked return ERR_BUF; - } else { - ESP_LOGD(TAG, "Enqueue data, length=%d, TID=0x%" PRIx16, frame_info.len, frame_info.tid); - return (int)frame_info.len; } - } else { - ESP_LOGE(TAG, "Enqueue data fail, %p, length=%d.", pbuf, len); + ESP_LOGD(TAG, "Enqueue data, length=%d, TID=0x%" PRIx16, frame_info.len, frame_info.tid); + return (int)frame_info.len; } + ESP_LOGE(TAG, "Enqueue data fail, %p, length=%d.", buf, len); return ERR_BUF; } -int port_dequeue_packet(QueueHandle_t queue, frame_entry_t *pframe_info) +int port_dequeue_packet(QueueHandle_t queue, frame_entry_t *frame_info_ptr) { frame_entry_t frame_info = {0}; esp_err_t ret = ESP_ERR_INVALID_STATE; - if (queue && pframe_info) { + if (queue && frame_info_ptr) { ret = queue_pop(queue, NULL, MB_TCP_BUFF_MAX_SIZE, &frame_info); if (ret == ESP_OK) { if ((frame_info.pid == 0) && (frame_info.uid < MB_ADDRESS_MAX)) { - *pframe_info = frame_info; - ESP_LOGD(TAG, "Dequeue data, length=%d, TID=0x%" PRIx16, (int)pframe_info->len, (int)pframe_info->tid); + *frame_info_ptr = frame_info; + ESP_LOGD(TAG, "Dequeue data, length=%d, TID=0x%" PRIx16, (int)frame_info_ptr->len, (int)frame_info_ptr->tid); return ERR_OK; } } else { @@ -151,65 +149,67 @@ int port_dequeue_packet(QueueHandle_t queue, frame_entry_t *pframe_info) return ERR_BUF; } -static int port_get_buf(mb_node_info_t *pinfo, uint8_t *pdst_buf, uint16_t len, uint16_t read_tick_ms) +static int port_get_buf(mb_node_info_t *info_ptr, uint8_t *pdst_buf, uint16_t len, uint16_t read_tick_ms) { int ret = 0; - uint8_t *pbuf = pdst_buf; + uint8_t *buf = pdst_buf; uint16_t bytes_left = len; struct timeval time_val; - MB_RETURN_ON_FALSE((pinfo && (pinfo->sock_id > UNDEF_FD)), -1, TAG, "Try to read incorrect socket = #%d.", pinfo->sock_id); + MB_RETURN_ON_FALSE((info_ptr && (info_ptr->sock_id > UNDEF_FD)), -1, TAG, "Try to read incorrect socket = #%d.", info_ptr->sock_id); // Set receive timeout for socket <= slave respond time time_val.tv_sec = read_tick_ms / 1000; time_val.tv_usec = (read_tick_ms % 1000) * 1000; - setsockopt(pinfo->sock_id, SOL_SOCKET, SO_RCVTIMEO, &time_val, sizeof(time_val)); + setsockopt(info_ptr->sock_id, SOL_SOCKET, SO_RCVTIMEO, &time_val, sizeof(time_val)); // blocking read of data from socket - ret = recv(pinfo->sock_id, pbuf, bytes_left, 0); + ret = recv(info_ptr->sock_id, buf, bytes_left, 0); if (ret < 0) { if (errno == EINPROGRESS || errno == EAGAIN || errno == EWOULDBLOCK) { // Read timeout occurred, check the timeout and return return 0; - } else if ((errno == ENOTCONN) || (errno == ECONNRESET)) { + } + if ((errno == ENOTCONN) || (errno == ECONNRESET)) { ESP_LOGD(TAG, "socket(#%d)(%s) connection closed, ret=%d, errno=%d.", - pinfo->sock_id, pinfo->addr_info.ip_addr_str, ret, (int)errno); + info_ptr->sock_id, info_ptr->addr_info.ip_addr_str, ret, (int)errno); // Socket connection closed return ERR_CONN; - } else { - // Other error occurred during receiving - ESP_LOGD(TAG, "Socket(#%d)(%s) receive error, ret = %d, errno = %d(%s)", - pinfo->sock_id, pinfo->addr_info.ip_addr_str, ret, (int)errno, strerror(errno)); - return -1; } - } + // Other error occurred during receiving + ESP_LOGD(TAG, "Socket(#%d)(%s) receive error, ret = %d, errno = %d(%s)", + info_ptr->sock_id, info_ptr->addr_info.ip_addr_str, ret, (int)errno, strerror(errno)); + ret = -1; + } return ret; } -int port_read_packet(mb_node_info_t *pinfo) +int port_read_packet(mb_node_info_t *info_ptr) { uint16_t temp = 0; int ret = 0; uint8_t ptemp_buf[MB_TCP_BUFF_MAX_SIZE] = {0}; // Receive data from connected client - if (pinfo) { - MB_RETURN_ON_FALSE((pinfo->sock_id > 0), -1, TAG, "try to read incorrect socket = #%d.", pinfo->sock_id); + if (info_ptr) { + MB_RETURN_ON_FALSE((info_ptr->sock_id > 0), -1, TAG, "try to read incorrect socket = #%d", info_ptr->sock_id); // Read packet header - ret = port_get_buf(pinfo, ptemp_buf, MB_TCP_UID, MB_READ_TICK); + ret = port_get_buf(info_ptr, ptemp_buf, MB_TCP_UID, MB_READ_TICK); if (ret < 0) { - pinfo->recv_err = ret; + info_ptr->recv_err = ret; return ret; - } else if (ret != MB_TCP_UID) { + } + + if (ret != MB_TCP_UID) { ESP_LOGD(TAG, "Socket (#%d)(%s), fail to read modbus header. ret=%d", - pinfo->sock_id, pinfo->addr_info.ip_addr_str, ret); - pinfo->recv_err = ERR_VAL; + info_ptr->sock_id, info_ptr->addr_info.ip_addr_str, ret); + info_ptr->recv_err = ERR_VAL; return ERR_VAL; } temp = MB_TCP_MBAP_GET_FIELD(ptemp_buf, MB_TCP_PID); if (temp != 0) { - pinfo->recv_err = ERR_BUF; + info_ptr->recv_err = ERR_BUF; return ERR_BUF; } @@ -219,53 +219,54 @@ int port_read_packet(mb_node_info_t *pinfo) if (temp > MB_TCP_BUFF_MAX_SIZE) { ESP_LOGD(TAG, "Incorrect packet length: %d", temp); ESP_LOG_BUFFER_HEX_LEVEL(TAG, ptemp_buf, MB_TCP_FUNC, ESP_LOG_DEBUG); - pinfo->recv_err = ERR_BUF; + info_ptr->recv_err = ERR_BUF; temp = MB_TCP_BUFF_MAX_SIZE; // read all remaining data from buffer } - ret = port_get_buf(pinfo, &ptemp_buf[MB_TCP_UID], temp, MB_READ_TICK); + ret = port_get_buf(info_ptr, &ptemp_buf[MB_TCP_UID], temp, MB_READ_TICK); if (ret < 0) { - pinfo->recv_err = ret; + info_ptr->recv_err = ret; return ret; - } else if (ret != temp) { - pinfo->recv_err = ERR_VAL; + } + + if (ret != temp) { + info_ptr->recv_err = ERR_VAL; return ERR_VAL; } if (ptemp_buf[MB_TCP_UID] > MB_ADDRESS_MAX) { - pinfo->recv_err = ERR_BUF; + info_ptr->recv_err = ERR_BUF; return ERR_BUF; } - ret = port_enqueue_packet(pinfo->rx_queue, ptemp_buf, temp + MB_TCP_UID); + ret = port_enqueue_packet(info_ptr->rx_queue, ptemp_buf, temp + MB_TCP_UID); if (ret < 0) { - pinfo->recv_err = ret; + info_ptr->recv_err = ret; return ret; } - pinfo->recv_counter++; + info_ptr->recv_counter++; - pinfo->recv_err = ERR_OK; + info_ptr->recv_err = ERR_OK; return ret + MB_TCP_FUNC; } return -1; } -err_t port_set_blocking(mb_node_info_t *pinfo, bool is_blocking) +err_t port_set_blocking(mb_node_info_t *info_ptr, bool is_blocking) { - if (!pinfo) { + if (!info_ptr) { return ERR_CONN; } // Set non blocking attribute for socket - uint32_t flags = fcntl(pinfo->sock_id, F_GETFL); + uint32_t flags = fcntl(info_ptr->sock_id, F_GETFL); flags = is_blocking ? flags & ~O_NONBLOCK : flags | O_NONBLOCK; - if (fcntl(pinfo->sock_id, F_SETFL, flags) == -1) { + if (fcntl(info_ptr->sock_id, F_SETFL, flags) == -1) { ESP_LOGE(TAG, "Socket(#%d)(%s), fcntl() call error=%d", - pinfo->sock_id, pinfo->addr_info.ip_addr_str, (int)errno); + info_ptr->sock_id, info_ptr->addr_info.ip_addr_str, (int)errno); return ERR_WOULDBLOCK; - } else { - pinfo->is_blocking = ((flags & O_NONBLOCK) != O_NONBLOCK); } + info_ptr->is_blocking = ((flags & O_NONBLOCK) != O_NONBLOCK); return ERR_OK; } @@ -303,45 +304,45 @@ int port_keep_alive(int sock) } // Check connection for timeout helper -err_t port_check_alive(mb_node_info_t *pinfo, uint32_t timeout_ms) +err_t port_check_alive(mb_node_info_t *info_ptr, uint32_t timeout_ms) { fd_set write_set; fd_set err_set; err_t err = -1; struct timeval time_val; - if (pinfo && pinfo->sock_id != -1) { + if (info_ptr && info_ptr->sock_id != -1) { FD_ZERO(&write_set); FD_ZERO(&err_set); - FD_SET(pinfo->sock_id, &write_set); - FD_SET(pinfo->sock_id, &err_set); + FD_SET(info_ptr->sock_id, &write_set); + FD_SET(info_ptr->sock_id, &err_set); port_ms_to_tv(timeout_ms, &time_val); // Check if the socket is writable - err = select(pinfo->sock_id + 1, NULL, &write_set, &err_set, &time_val); - if ((err < 0) || FD_ISSET(pinfo->sock_id, &err_set)) { + err = select(info_ptr->sock_id + 1, NULL, &write_set, &err_set, &time_val); + if ((err < 0) || FD_ISSET(info_ptr->sock_id, &err_set)) { if (errno == EINPROGRESS) { err = ERR_INPROGRESS; } else { ESP_LOGV(TAG, MB_NODE_FMT(" connection, select write err(errno) = %d(%d)."), - pinfo->index, pinfo->sock_id, pinfo->addr_info.ip_addr_str, err, (int)errno); + info_ptr->index, info_ptr->sock_id, info_ptr->addr_info.ip_addr_str, err, (int)errno); err = ERR_CONN; } } else if (err == 0) { ESP_LOGV(TAG, "Socket(#%d)(%s), connection timeout occurred, err(errno) = %d(%d).", - pinfo->sock_id, pinfo->addr_info.ip_addr_str, err, (int)errno); + info_ptr->sock_id, info_ptr->addr_info.ip_addr_str, err, (int)errno); return ERR_INPROGRESS; } else { int opt_err = 0; uint32_t opt_len = sizeof(opt_err); // Check socket error - err = getsockopt(pinfo->sock_id, SOL_SOCKET, SO_ERROR, (void *)&opt_err, (socklen_t *)&opt_len); + err = getsockopt(info_ptr->sock_id, SOL_SOCKET, SO_ERROR, (void *)&opt_err, (socklen_t *)&opt_len); if (opt_err != 0) { ESP_LOGD(TAG, "Socket(#%d)(%s), sock error occurred (%d).", - pinfo->sock_id, pinfo->addr_info.ip_addr_str, opt_err); + info_ptr->sock_id, info_ptr->addr_info.ip_addr_str, opt_err); return ERR_CONN; } ESP_LOGV(TAG, "Socket(#%d)(%s), is alive.", - pinfo->sock_id, pinfo->addr_info.ip_addr_str); + info_ptr->sock_id, info_ptr->addr_info.ip_addr_str); return ERR_OK; } } else { @@ -351,130 +352,132 @@ err_t port_check_alive(mb_node_info_t *pinfo, uint32_t timeout_ms) } // Unblocking connect function -err_t port_connect(void *ctx, mb_node_info_t *pinfo) +err_t port_connect(void *ctx, mb_node_info_t *info_ptr) { - if (!pinfo) { + if (!info_ptr) { return ERR_CONN; } - port_driver_t *pdrv_ctx = MB_GET_DRV_PTR(ctx); + port_driver_t *drv_obj = MB_GET_DRV_PTR(ctx); err_t err = ERR_OK; char str[HOST_STR_MAX_LEN]; - char *pstr = NULL; + char *string_ptr = NULL; ip_addr_t target_addr; struct addrinfo hint; struct addrinfo *addr_list; - struct addrinfo *pcur_addr; + struct addrinfo *cur_addr; memset(&hint, 0, sizeof(hint)); // Do name resolution for both protocols hint.ai_flags = AI_ADDRCONFIG | AI_CANONNAME; // get IPV6 address if supported, otherwise IPV4 - hint.ai_family = (pinfo->addr_info.addr_type == MB_IPV4) ? AF_INET : AF_INET6; - hint.ai_socktype = (pinfo->addr_info.proto == MB_UDP) ? SOCK_DGRAM : SOCK_STREAM; - hint.ai_protocol = (pinfo->addr_info.proto == MB_UDP) ? IPPROTO_UDP : IPPROTO_TCP; + hint.ai_family = (info_ptr->addr_info.addr_type == MB_IPV4) ? AF_INET : AF_INET6; + hint.ai_socktype = (info_ptr->addr_info.proto == MB_UDP) ? SOCK_DGRAM : SOCK_STREAM; + hint.ai_protocol = (info_ptr->addr_info.proto == MB_UDP) ? IPPROTO_UDP : IPPROTO_TCP; memset(&target_addr, 0, sizeof(target_addr)); - if (asprintf(&pstr, "%u", pinfo->addr_info.port) == -1) { + if (asprintf(&string_ptr, "%u", info_ptr->addr_info.port) == -1) { abort(); } // convert domain name to IP address - int ret = getaddrinfo(pinfo->addr_info.ip_addr_str, pstr, &hint, &addr_list); - free(pstr); + int ret = getaddrinfo(info_ptr->addr_info.ip_addr_str, string_ptr, &hint, &addr_list); + free(string_ptr); if (ret != 0) { - ESP_LOGE(TAG, "Cannot resolve host: %s", pinfo->addr_info.ip_addr_str); + ESP_LOGE(TAG, "Cannot resolve host: %s", info_ptr->addr_info.ip_addr_str); return ERR_CONN; } - for (pcur_addr = addr_list; pcur_addr != NULL; pcur_addr = pcur_addr->ai_next) { - if (pcur_addr->ai_family == AF_INET) { - struct in_addr addr4 = ((struct sockaddr_in *)(pcur_addr->ai_addr))->sin_addr; + for (cur_addr = addr_list; cur_addr != NULL; cur_addr = cur_addr->ai_next) { + if (cur_addr->ai_family == AF_INET) { + struct in_addr addr4 = ((struct sockaddr_in *)(cur_addr->ai_addr))->sin_addr; inet_addr_to_ip4addr(ip_2_ip4(&target_addr), &addr4); - pstr = ip4addr_ntoa_r(ip_2_ip4(&target_addr), str, sizeof(str)); + string_ptr = ip4addr_ntoa_r(ip_2_ip4(&target_addr), str, sizeof(str)); } #if CONFIG_LWIP_IPV6 - else if (pcur_addr->ai_family == AF_INET6) { - struct in6_addr addr6 = ((struct sockaddr_in6 *)(pcur_addr->ai_addr))->sin6_addr; + else if (cur_addr->ai_family == AF_INET6) { + struct in6_addr addr6 = ((struct sockaddr_in6 *)(cur_addr->ai_addr))->sin6_addr; inet6_addr_to_ip6addr(ip_2_ip6(&target_addr), &addr6); - pstr = ip6addr_ntoa_r(ip_2_ip6(&target_addr), str, sizeof(str)); + string_ptr = ip6addr_ntoa_r(ip_2_ip6(&target_addr), str, sizeof(str)); // Set scope id to fix routing issues with local address - ((struct sockaddr_in6 *)(pcur_addr->ai_addr))->sin6_scope_id = - esp_netif_get_netif_impl_index(pdrv_ctx->network_iface_ptr); + ((struct sockaddr_in6 *)(cur_addr->ai_addr))->sin6_scope_id = + esp_netif_get_netif_impl_index(drv_obj->network_iface_ptr); } #endif - if (pinfo->sock_id <= 0) { - pinfo->sock_id = socket(pcur_addr->ai_family, pcur_addr->ai_socktype, pcur_addr->ai_protocol); - if (pinfo->sock_id < 0) { - ESP_LOGE(TAG, "Unable to create socket: #%d, errno %d", pinfo->sock_id, (int)errno); + if (info_ptr->sock_id <= 0) { + info_ptr->sock_id = socket(cur_addr->ai_family, cur_addr->ai_socktype, cur_addr->ai_protocol); + if (info_ptr->sock_id < 0) { + ESP_LOGE(TAG, "Unable to create socket: #%d, errno %d", info_ptr->sock_id, (int)errno); err = ERR_IF; continue; } } else { - ESP_LOGV(TAG, "Socket (#%d)(%s) created.", pinfo->sock_id, str); + ESP_LOGV(TAG, "Socket (#%d)(%s) created.", info_ptr->sock_id, str); } // Set non blocking attribute for socket - port_set_blocking(pinfo, false); + port_set_blocking(info_ptr, false); // Can return EINPROGRESS as an error which means // that connection is in progress and should be checked later - err = connect(pinfo->sock_id, (struct sockaddr *)pcur_addr->ai_addr, pcur_addr->ai_addrlen); + err = connect(info_ptr->sock_id, cur_addr->ai_addr, cur_addr->ai_addrlen); if ((err < 0) && (errno == EINPROGRESS || errno == EALREADY)) { // The unblocking connect is pending (check status later) or already connected ESP_LOGD(TAG, "Socket(#%d)(%s) connection is pending, errno %d (%s).", - pinfo->sock_id, str, (int)errno, strerror(errno)); + info_ptr->sock_id, str, (int)errno, strerror(errno)); - // Set keepalive option - (void)port_keep_alive(pinfo->sock_id); - err = port_check_alive(pinfo, MB_TCP_CHECK_ALIVE_TOUT_MS); + // Set keep alive flag in socket options + (void)port_keep_alive(info_ptr->sock_id); + err = port_check_alive(info_ptr, MB_TCP_CHECK_ALIVE_TOUT_MS); continue; - } else if ((err < 0) && (errno == EISCONN)) { + } + if ((err < 0) && (errno == EISCONN)) { // Socket already connected err = ERR_OK; continue; - } else if (err != ERR_OK) { + } + if (err != ERR_OK) { // Other error occurred during connection ESP_LOGV(TAG, "%p, "MB_NODE_FMT(" unable to connect, error=%d, errno %d (%s)"), - ctx, pinfo->index, pinfo->sock_id, str, err, (int)errno, strerror(errno)); - port_close_connection(pinfo); + ctx, info_ptr->index, info_ptr->sock_id, str, err, (int)errno, strerror(errno)); + port_close_connection(info_ptr); err = ERR_CONN; } else { ESP_LOGI(TAG, "%p, "MB_NODE_FMT(", successfully connected."), - ctx, pinfo->index, pinfo->sock_id, str); + ctx, info_ptr->index, info_ptr->sock_id, str); continue; } } freeaddrinfo(addr_list); - port_set_blocking(pinfo, true); + port_set_blocking(info_ptr, true); return err; } -int port_write_poll(mb_node_info_t *pinfo, const uint8_t *pframe, uint16_t frame_len, uint32_t timeout) +int port_write_poll(mb_node_info_t *info_ptr, const uint8_t *frame, uint16_t frame_len, uint32_t timeout) { // Check if the socket is alive (writable and SO_ERROR == 0) - int res = (int)port_check_alive(pinfo, timeout); + int res = (int)port_check_alive(info_ptr, timeout); if ((res < 0) && (res != ERR_INPROGRESS)) { ESP_LOGE(TAG, MB_NODE_FMT(", is not writable, error: %d, errno %d"), - pinfo->index, pinfo->sock_id, pinfo->addr_info.ip_addr_str, res, (int)errno); + info_ptr->index, info_ptr->sock_id, info_ptr->addr_info.ip_addr_str, res, (int)errno); return res; } - res = send(pinfo->sock_id, pframe, frame_len, TCP_NODELAY); + res = send(info_ptr->sock_id, frame, frame_len, TCP_NODELAY); if (res < 0) { ESP_LOGE(TAG, MB_NODE_FMT(", send data error: %d, errno %d"), - pinfo->index, pinfo->sock_id, pinfo->addr_info.ip_addr_str, res, (int)errno); + info_ptr->index, info_ptr->sock_id, info_ptr->addr_info.ip_addr_str, res, (int)errno); } return res; } // Scan IP address according to IPV settings -int port_scan_addr_string(char *buffer, mb_uid_info_t *pinfo) +int port_scan_addr_string(char *buffer, mb_uid_info_t *info_ptr) { - char *phost_str = NULL; + char *host_str = NULL; unsigned int a[8] = {0}; int ret = 0; uint16_t index = 0; uint16_t port = 0; - MB_RETURN_ON_FALSE((buffer && (strlen(buffer) < (HOST_STR_MAX_LEN - 8)) && pinfo), + MB_RETURN_ON_FALSE((buffer && (strlen(buffer) < (HOST_STR_MAX_LEN - 8)) && info_ptr), -1, TAG, "check input parameters fail."); #if CONFIG_LWIP_IPV6 @@ -483,16 +486,16 @@ int port_scan_addr_string(char *buffer, mb_uid_info_t *pinfo) // "12:2001:0db8:85a3:0000:0000:8a2e:0370:7334" ret = sscanf(buffer, "%" PRIu16 ";" IPV6STR ";%" PRIu16, &index, &a[0], &a[1], &a[2], &a[3], &a[4], &a[5], &a[6], &a[7], &port); if ((ret == MB_STR_LEN_IDX_IP6) || (ret == MB_STR_LEN_IDX_IP6_PORT)) { - if (-1 == asprintf(&phost_str, IPV6STR, a[0], a[1], a[2], a[3], a[4], a[5], a[6], a[7])) { + if (-1 == asprintf(&host_str, IPV6STR, a[0], a[1], a[2], a[3], a[4], a[5], a[6], a[7])) { abort(); } - pinfo->node_name_str = phost_str; - pinfo->ip_addr_str = phost_str; - pinfo->uid = index; - pinfo->fd = UNDEF_FD; - pinfo->port = (ret == MB_STR_LEN_IDX_IP6_PORT) ? port : CONFIG_FMB_TCP_PORT_DEFAULT; - pinfo->addr_type = MB_IPV6; - pinfo->proto = MB_TCP; + info_ptr->node_name_str = host_str; + info_ptr->ip_addr_str = host_str; + info_ptr->uid = index; + info_ptr->fd = UNDEF_FD; + info_ptr->port = (ret == MB_STR_LEN_IDX_IP6_PORT) ? port : CONFIG_FMB_TCP_PORT_DEFAULT; + info_ptr->addr_type = MB_IPV6; + info_ptr->proto = MB_TCP; return ret; } @@ -500,16 +503,16 @@ int port_scan_addr_string(char *buffer, mb_uid_info_t *pinfo) // "2001:0db8:85a3:0000:0000:8a2e:0370:7334" ret = sscanf(buffer, IPV6STR, &a[0], &a[1], &a[2], &a[3], &a[4], &a[5], &a[6], &a[7]); if (ret == MB_STR_LEN_IP6_ONLY) { - if (-1 == asprintf(&phost_str, IPV6STR, a[0], a[1], a[2], a[3], a[4], a[5], a[6], a[7])) { + if (-1 == asprintf(&host_str, IPV6STR, a[0], a[1], a[2], a[3], a[4], a[5], a[6], a[7])) { abort(); } - pinfo->node_name_str = phost_str; - pinfo->ip_addr_str = phost_str; - pinfo->uid = 0; - pinfo->fd = UNDEF_FD; - pinfo->port = CONFIG_FMB_TCP_PORT_DEFAULT; - pinfo->addr_type = MB_IPV6; - pinfo->proto = MB_TCP; + info_ptr->node_name_str = host_str; + info_ptr->ip_addr_str = host_str; + info_ptr->uid = 0; + info_ptr->fd = UNDEF_FD; + info_ptr->port = CONFIG_FMB_TCP_PORT_DEFAULT; + info_ptr->addr_type = MB_IPV6; + info_ptr->proto = MB_TCP; return ret; } #endif @@ -517,16 +520,16 @@ int port_scan_addr_string(char *buffer, mb_uid_info_t *pinfo) // "192.168.1.1" ret = sscanf(buffer, IPSTR, &a[0], &a[1], &a[2], &a[3]); if (ret == MB_STR_LEN_IP4_ONLY) { - if (-1 == asprintf(&phost_str, IPSTR, a[0], a[1], a[2], a[3])) { + if (-1 == asprintf(&host_str, IPSTR, a[0], a[1], a[2], a[3])) { abort(); } - pinfo->node_name_str = phost_str; - pinfo->ip_addr_str = phost_str; - pinfo->uid = 0; - pinfo->fd = UNDEF_FD; - pinfo->port = CONFIG_FMB_TCP_PORT_DEFAULT; - pinfo->addr_type = MB_IPV4; - pinfo->proto = MB_TCP; + info_ptr->node_name_str = host_str; + info_ptr->ip_addr_str = host_str; + info_ptr->uid = 0; + info_ptr->fd = UNDEF_FD; + info_ptr->port = CONFIG_FMB_TCP_PORT_DEFAULT; + info_ptr->addr_type = MB_IPV4; + info_ptr->proto = MB_TCP; return ret; } @@ -534,45 +537,45 @@ int port_scan_addr_string(char *buffer, mb_uid_info_t *pinfo) // "1:192.168.1.1:502" ret = sscanf(buffer, "%" PRIu16 ";"IPSTR";%" PRIu16, &index, &a[0], &a[1], &a[2], &a[3], &port); if ((ret == MB_STR_LEN_IDX_IP4_PORT) || (ret == MB_STR_LEN_IDX_IP4)) { - if (-1 == asprintf(&phost_str, IPSTR, a[0], a[1], a[2], a[3])) { + if (-1 == asprintf(&host_str, IPSTR, a[0], a[1], a[2], a[3])) { abort(); } - pinfo->node_name_str = phost_str; - pinfo->ip_addr_str = phost_str; - pinfo->uid = index; - pinfo->fd = UNDEF_FD; - pinfo->port = (ret == MB_STR_LEN_IDX_IP4_PORT) ? port : CONFIG_FMB_TCP_PORT_DEFAULT; - pinfo->addr_type = MB_IPV4; - pinfo->proto = MB_TCP; + info_ptr->node_name_str = host_str; + info_ptr->ip_addr_str = host_str; + info_ptr->uid = index; + info_ptr->fd = UNDEF_FD; + info_ptr->port = (ret == MB_STR_LEN_IDX_IP4_PORT) ? port : CONFIG_FMB_TCP_PORT_DEFAULT; + info_ptr->addr_type = MB_IPV4; + info_ptr->proto = MB_TCP; return ret; } // Configuration format: // "01:mb_node_tcp_01:502" - ret = sscanf(buffer, "%" PRIu16 ";%m[a-z0-9_];%" PRIu16, (uint16_t*)&index, &phost_str, &port); + ret = sscanf(buffer, "%" PRIu16 ";%m[a-z0-9_];%" PRIu16, &index, &host_str, &port); if ((ret == MB_STR_LEN_HOST) || (ret == MB_STR_LEN_IDX_HOST_PORT)) { - pinfo->node_name_str = (phost_str && strlen(phost_str)) ? phost_str : pinfo->node_name_str; - pinfo->ip_addr_str = (pinfo->node_name_str) ? pinfo->node_name_str : pinfo->ip_addr_str; - pinfo->uid = index; - pinfo->fd = UNDEF_FD; - pinfo->port = (ret == MB_STR_LEN_IDX_HOST_PORT) ? port : CONFIG_FMB_TCP_PORT_DEFAULT; - pinfo->addr_type = MB_IPV4; - pinfo->proto = MB_TCP; + info_ptr->node_name_str = (host_str && strlen(host_str)) ? host_str : info_ptr->node_name_str; + info_ptr->ip_addr_str = (info_ptr->node_name_str) ? info_ptr->node_name_str : info_ptr->ip_addr_str; + info_ptr->uid = index; + info_ptr->fd = UNDEF_FD; + info_ptr->port = (ret == MB_STR_LEN_IDX_HOST_PORT) ? port : CONFIG_FMB_TCP_PORT_DEFAULT; + info_ptr->addr_type = MB_IPV4; + info_ptr->proto = MB_TCP; return ret; } // Configuration format: // "mb_node_tcp_01" - ret = sscanf(buffer, "%m[a-z0-9_]", &phost_str); + ret = sscanf(buffer, "%m[a-z0-9_]", &host_str); if (ret == MB_STR_LEN_HOST) { - pinfo->node_name_str = (phost_str && strlen(phost_str)) ? phost_str : pinfo->node_name_str; - pinfo->ip_addr_str = (pinfo->node_name_str) ? pinfo->node_name_str : pinfo->ip_addr_str; - pinfo->uid = index; - pinfo->fd = UNDEF_FD; - pinfo->port = CONFIG_FMB_TCP_PORT_DEFAULT; - pinfo->addr_type = MB_IPV4; - pinfo->proto = MB_TCP; + info_ptr->node_name_str = (host_str && strlen(host_str)) ? host_str : info_ptr->node_name_str; + info_ptr->ip_addr_str = (info_ptr->node_name_str) ? info_ptr->node_name_str : info_ptr->ip_addr_str; + info_ptr->uid = index; + info_ptr->fd = UNDEF_FD; + info_ptr->port = CONFIG_FMB_TCP_PORT_DEFAULT; + info_ptr->addr_type = MB_IPV4; + info_ptr->proto = MB_TCP; return ret; } @@ -584,20 +587,20 @@ int port_scan_addr_string(char *buffer, mb_uid_info_t *pinfo) static int mdns_instance_count = 0; // This function has limitation of working with IP6 address only -esp_err_t port_start_mdns_service(char **ppdns_name, bool is_master, int uid, void *pnode_netif) +esp_err_t port_start_mdns_service(char **dns_name, bool is_master, int uid, void *node_netif) { char temp_str[HOST_STR_MAX_LEN] = {0}; esp_ip6_addr_t ip6[LWIP_IPV6_NUM_ADDRESSES]; int ip6_addrs_count = 0; esp_err_t err = ESP_ERR_INVALID_STATE; - MB_RETURN_ON_FALSE((pnode_netif), + MB_RETURN_ON_FALSE((node_netif), err, TAG, "Invalid parameters for dns."); // initialize mDNS err = mdns_init(); // if the mdns is already initialized on higher layer, just returns - MB_RETURN_ON_FALSE(((err == ESP_OK) && pnode_netif), err, TAG, "mdns init fail, err = %d.", (int)err); + MB_RETURN_ON_FALSE(((err == ESP_OK) && node_netif), err, TAG, "mdns init fail, err = %d.", (int)err); - esp_netif_t *pnetif = (esp_netif_t*)pnode_netif; + esp_netif_t *pnetif = (esp_netif_t*)node_netif; // set mDNS hostname (required if need to advertise services) err = mdns_hostname_get(temp_str); if (err != ESP_OK) { @@ -614,9 +617,9 @@ esp_err_t port_start_mdns_service(char **ppdns_name, bool is_master, int uid, vo err, TAG, "mdns instance name set fail, err = %d.", (int)err); } // Check if the default mdns name is defined in the configuration - if (ppdns_name && *ppdns_name && (strlen(*ppdns_name) >= MB_MDNS_STR_MIN_LENGTH)) { - strncpy(temp_str, *ppdns_name, strlen(*ppdns_name)); - *ppdns_name[strlen(*ppdns_name)] = '\0'; + if (dns_name && *dns_name && (strlen(*dns_name) >= MB_MDNS_STR_MIN_LENGTH)) { + strncpy(temp_str, *dns_name, strlen(*dns_name)); + *dns_name[strlen(*dns_name)] = '\0'; } else { if (snprintf(temp_str, sizeof(temp_str), "%s_%02x", MB_MDNS_INST_NAME(is_master), uid) <= 0) { return ESP_ERR_INVALID_STATE; @@ -624,8 +627,8 @@ esp_err_t port_start_mdns_service(char **ppdns_name, bool is_master, int uid, vo } // Setup the real assigned dns_name instead of constant string - if (ppdns_name) { - *ppdns_name = strdup(temp_str); + if (dns_name) { + *dns_name = strdup(temp_str); } esp_netif_ip_info_t ip_info; @@ -669,12 +672,12 @@ esp_err_t port_start_mdns_service(char **ppdns_name, bool is_master, int uid, vo return ESP_OK; } -void port_stop_mdns_service(char **ppdns_name) +void port_stop_mdns_service(char **dns_name) { - if (ppdns_name && *ppdns_name) { - mdns_delegate_hostname_remove(*ppdns_name); - free(*ppdns_name); - *ppdns_name = NULL; + if (dns_name && *dns_name) { + mdns_delegate_hostname_remove(*dns_name); + free(*dns_name); + *dns_name = NULL; if (mdns_instance_count) { mdns_instance_count--; } @@ -755,12 +758,12 @@ void port_stop_mdns_service(char **ppdns_name) // return ESP_ERR_NOT_FOUND; // } -int port_resolve_mdns_host(const char *host_name, char **paddr_str) +int port_resolve_mdns_host(const char *host_name, char **addr_str) { ESP_LOGD(TAG, "Query A: %s.local", host_name); esp_ip_addr_t addr; - char *pstr = NULL; + char *string_ptr = NULL; bzero(&addr, sizeof(esp_ip_addr_t)); // Try to send query to obtain the IPv4 address @@ -774,7 +777,7 @@ int port_resolve_mdns_host(const char *host_name, char **paddr_str) return -1; } addr.type = ESP_IPADDR_TYPE_V6; - if (asprintf(&pstr, IPV6STR, IPV62STR(addr.u_addr.ip6) == -1)) { + if (asprintf(&string_ptr, IPV6STR, IPV62STR(addr.u_addr.ip6)) == -1) { abort(); } } else { @@ -782,15 +785,15 @@ int port_resolve_mdns_host(const char *host_name, char **paddr_str) } } else { addr.type = ESP_IPADDR_TYPE_V4; - if (asprintf(&pstr, IPSTR, IP2STR(&addr.u_addr.ip4)) == -1) { + if (asprintf(&string_ptr, IPSTR, IP2STR(&addr.u_addr.ip4)) == -1) { abort(); } } - if (paddr_str) { - ESP_LOGD(TAG, "Node: %s, was resolved with IP: %s", host_name, pstr); - *paddr_str = pstr; + if (addr_str) { + ESP_LOGD(TAG, "Node: %s, was resolved with IP: %s", host_name, string_ptr); + *addr_str = string_ptr; } - return strlen(pstr); + return strlen(string_ptr); } #endif // #ifdef MB_MDNS_IS_INCLUDED @@ -801,9 +804,9 @@ int port_bind_addr(const char *pbind_ip, mb_addr_type_t addr_type, mb_comm_mode_ int temp_par, ret; int listen_sock_fd = -1; struct addrinfo hint; - struct addrinfo *paddr_list; - struct addrinfo *pcur_addr; - char* pstr = NULL; + struct addrinfo *addr_list; + struct addrinfo *cur_addr; + char* string_ptr = NULL; memset(&hint, 0, sizeof(hint)); @@ -816,22 +819,22 @@ int port_bind_addr(const char *pbind_ip, mb_addr_type_t addr_type, mb_comm_mode_ hint.ai_protocol = (proto == MB_UDP) ? IPPROTO_UDP : IPPROTO_TCP; hint.ai_flags = AI_NUMERICSERV | AI_PASSIVE | AI_CANONNAME; - if (asprintf(&pstr, "%u", port) == -1) { + if (asprintf(&string_ptr, "%u", port) == -1) { abort(); } - ret = getaddrinfo(pbind_ip, pstr, &hint, &paddr_list); - free(pstr); + ret = getaddrinfo(pbind_ip, string_ptr, &hint, &addr_list); + free(string_ptr); if ((ret != 0) ) { return -1; } // Try the sockaddr until a binding succeeds - for (pcur_addr = paddr_list; pcur_addr != NULL; pcur_addr = pcur_addr->ai_next) + for (cur_addr = addr_list; cur_addr!= NULL; cur_addr = cur_addr->ai_next) { - listen_sock_fd = (int)socket(pcur_addr->ai_family, pcur_addr->ai_socktype, - pcur_addr->ai_protocol); + listen_sock_fd = socket(cur_addr->ai_family, cur_addr->ai_socktype, + cur_addr->ai_protocol); if (listen_sock_fd < 0) { continue; @@ -847,8 +850,8 @@ int port_bind_addr(const char *pbind_ip, mb_addr_type_t addr_type, mb_comm_mode_ continue; } - if (bind(listen_sock_fd, (struct sockaddr *)pcur_addr->ai_addr, - (socklen_t)pcur_addr->ai_addrlen) != 0 ) + if (bind(listen_sock_fd, cur_addr->ai_addr, + (socklen_t)cur_addr->ai_addrlen) != 0 ) { close(listen_sock_fd); listen_sock_fd = UNDEF_FD; @@ -868,19 +871,19 @@ int port_bind_addr(const char *pbind_ip, mb_addr_type_t addr_type, mb_comm_mode_ } } // Bind was successful - pstr = (pcur_addr->ai_canonname == NULL) ? (char *)"\0" : pcur_addr->ai_canonname; + string_ptr = (cur_addr->ai_canonname == NULL) ? (char *)"\0" : cur_addr->ai_canonname; ESP_LOGI(TAG, "Socket (#%d), listener %s on port: %u, errno=%u", - (int)listen_sock_fd, pstr, (unsigned)port, (unsigned)errno); + (int)listen_sock_fd, string_ptr, (unsigned)port, (unsigned)errno); break; } - freeaddrinfo(paddr_list); + freeaddrinfo(addr_list); return(listen_sock_fd); } -int port_accept_connection(int listen_sock_id, mb_uid_info_t *pinfo) +int port_accept_connection(int listen_sock_id, mb_uid_info_t *info_ptr) { - MB_RETURN_ON_FALSE((pinfo), -1, TAG, "Wrong parameter pointer."); + MB_RETURN_ON_FALSE((info_ptr), -1, TAG, "Wrong parameter pointer."); MB_RETURN_ON_FALSE((listen_sock_id > 0), -1, TAG, "Incorrect listen socket ID."); // Address structure large enough for both IPv4 or IPv6 address @@ -900,28 +903,28 @@ int port_accept_connection(int listen_sock_id, mb_uid_info_t *pinfo) // Get the sender's ip address as string if (src_addr.ss_family == PF_INET) { inet_ntoa_r(((struct sockaddr_in *)&src_addr)->sin_addr.s_addr, addr_str, sizeof(addr_str) - 1); - pinfo->port = ntohs(((struct sockaddr_in *)&src_addr)->sin_port); - pinfo->addr_type = MB_IPV4; + info_ptr->port = ntohs(((struct sockaddr_in *)&src_addr)->sin_port); + info_ptr->addr_type = MB_IPV4; } #if CONFIG_LWIP_IPV6 else if (src_addr.ss_family == PF_INET6) { inet6_ntoa_r(((struct sockaddr_in6 *)&src_addr)->sin6_addr, addr_str, sizeof(addr_str) - 1); - pinfo->port = ntohs(((struct sockaddr_in6 *)&src_addr)->sin6_port); - pinfo->addr_type = MB_IPV6; + info_ptr->port = ntohs(((struct sockaddr_in6 *)&src_addr)->sin6_port); + info_ptr->addr_type = MB_IPV6; } #endif else { // Make sure ss_family is valid abort(); } - ESP_LOGI(TAG, "Socket (#%d), accept client connection from address[port]: %s[%d]", (int)sock_id, addr_str, pinfo->port); + ESP_LOGI(TAG, "Socket (#%d), accept client connection from address[port]: %s[%d]", (int)sock_id, addr_str, info_ptr->port); paddr = strdup(addr_str); if (paddr) { - pinfo->fd = sock_id; - pinfo->ip_addr_str = paddr; - pinfo->node_name_str = paddr; - pinfo->proto = MB_TCP; - pinfo->uid = 0; + info_ptr->fd = sock_id; + info_ptr->ip_addr_str = paddr; + info_ptr->node_name_str = paddr; + info_ptr->proto = MB_TCP; + info_ptr->uid = 0; } } return sock_id; diff --git a/modbus/mb_ports/tcp/port_tcp_utils.h b/modbus/mb_ports/tcp/port_tcp_utils.h index 16c9ebb..73e2b5c 100644 --- a/modbus/mb_ports/tcp/port_tcp_utils.h +++ b/modbus/mb_ports/tcp/port_tcp_utils.h @@ -80,48 +80,48 @@ extern "C" { } \ )) -typedef struct _frame_queue_entry frame_entry_t; -typedef struct _mb_node_info mb_node_info_t; -typedef enum _addr_type_enum mb_tcp_addr_type_t; +typedef struct frame_queue_entry_s frame_entry_t; +typedef struct mb_node_info_s mb_node_info_t; +typedef enum addr_type_enum mb_tcp_addr_type_t; bool port_check_host_addr(const char *host_str, ip_addr_t* host_addr); mb_node_info_t* port_get_current_info(void *ctx); void port_check_shutdown(void *ctx); -int64_t port_get_resp_time_left(mb_node_info_t* pinfo); -int port_enqueue_packet(QueueHandle_t queue, uint8_t *pbuf, uint16_t len); -int port_dequeue_packet(QueueHandle_t queue, frame_entry_t* pframe_info); -int port_read_packet(mb_node_info_t* pinfo); -err_t port_set_blocking(mb_node_info_t* pinfo, bool is_blocking); +int64_t port_get_resp_time_left(mb_node_info_t* info_ptr); +int port_enqueue_packet(QueueHandle_t queue, uint8_t *buf, uint16_t len); +int port_dequeue_packet(QueueHandle_t queue, frame_entry_t* frame_info); +int port_read_packet(mb_node_info_t* info_ptr); +err_t port_set_blocking(mb_node_info_t* info_ptr, bool is_blocking); int port_keep_alive(int sock); -err_t port_check_alive(mb_node_info_t* pinfo, uint32_t timeout_ms); -err_t port_connect(void *ctx, mb_node_info_t* pinfo); -bool port_close_connection(mb_node_info_t* pinfo); -int port_write_poll(mb_node_info_t* pinfo, const uint8_t *pframe, uint16_t frame_len, uint32_t timeout); +err_t port_check_alive(mb_node_info_t* info_ptr, uint32_t timeout_ms); +err_t port_connect(void *ctx, mb_node_info_t* info_ptr); +bool port_close_connection(mb_node_info_t* info_ptr); +int port_write_poll(mb_node_info_t* info_ptr, const uint8_t *frame, uint16_t frame_len, uint32_t timeout); int64_t port_get_timestamp(void); -typedef struct _uid_info mb_uid_info_t; +typedef struct uid_info_s mb_uid_info_t; -int port_scan_addr_string(char *buffer, mb_uid_info_t *pnode_info); +int port_scan_addr_string(char *buffer, mb_uid_info_t *info_ptr); #if MB_MDNS_IS_INCLUDED // Init mdns service -esp_err_t port_start_mdns_service(char **ppdns_name, bool is_master, int uid, void *pnode_netif); -void port_stop_mdns_service(char **ppdns_name); +esp_err_t port_start_mdns_service(char **dns_name, bool is_master, int uid, void *node_netif); +void port_stop_mdns_service(char **dns_name); typedef struct mdns_ip_addr_s mdns_ip_addr_t; typedef struct mdns_result_s mdns_result_t; char *port_get_node_ip_str(mdns_ip_addr_t *address, mb_addr_type_t addr_type); esp_err_t port_resolve_slave(uint8_t short_addr, mdns_result_t *result, char **resolved_ip, mb_addr_type_t addr_type); -int port_resolve_mdns_host(const char *host_name, char **paddr_str); +int port_resolve_mdns_host(const char *host_name, char **addr_str); #endif // Modbus slave utility functions int port_bind_addr(const char *pbind_ip, mb_addr_type_t addr_type, mb_comm_mode_t proto, uint16_t port); -int port_accept_connection(int listen_sock_id, mb_uid_info_t *pnode_info); +int port_accept_connection(int listen_sock_id, mb_uid_info_t *info_ptr); #ifdef __cplusplus } diff --git a/modbus/mb_transports/ascii/ascii_lrc.c b/modbus/mb_transports/ascii/ascii_lrc.c index 078ef4c..3f6457e 100644 --- a/modbus/mb_transports/ascii/ascii_lrc.c +++ b/modbus/mb_transports/ascii/ascii_lrc.c @@ -11,34 +11,35 @@ /* ----------------------- functions ---------------------------------*/ uint8_t mb_char2bin(uint8_t char_val) { + uint8_t symb = 0xFF; if ((char_val >= '0') && (char_val <= '9')) { - return (uint8_t)(char_val - '0'); + symb = (uint8_t)(char_val - '0'); } else if ((char_val >= 'A') && (char_val <= 'F')) { - return (uint8_t)(char_val - 'A' + 0x0A); - } else { - return 0xFF; + symb = (uint8_t)(char_val - 'A' + 0x0A); } + return symb; } uint8_t mb_bin2char(uint8_t byte_val) { + uint8_t symb = '0'; if (byte_val <= 0x09) { - return (uint8_t)('0' + byte_val); + symb = (uint8_t)('0' + byte_val); } else if ((byte_val >= 0x0A) && (byte_val <= 0x0F)) { - return (uint8_t)(byte_val - 0x0A + 'A'); + symb = (uint8_t)(byte_val - 0x0A + 'A'); } else { /* Programming error. */ assert(0); } - return '0'; + return symb; } -uint8_t __attribute__ ((unused)) mb_lrc(uint8_t *pframe, uint16_t length) +uint8_t __attribute__ ((unused)) mb_lrc(uint8_t *frame, uint16_t length) { uint8_t lrc = 0; /* LRC char initialized */ while (length--) { - lrc += *pframe++; /* Add buffer byte without carry */ + lrc += *frame++; /* Add buffer byte without carry */ } /* Return twos complement */ @@ -47,41 +48,41 @@ uint8_t __attribute__ ((unused)) mb_lrc(uint8_t *pframe, uint16_t length) } // The helper function to fill ASCII frame buffer -int mb_ascii_set_buf(const uint8_t *pdata, uint8_t *pbuf, int bin_length) +int mb_ascii_set_buf(const uint8_t *data_ptr, uint8_t *buf, int bin_length) { int bin_idx = 0; int frm_idx = 0; uint8_t lrc = 0; - assert(pdata && pbuf); + assert(data_ptr && buf); - pbuf[0] = MB_ASCII_START; + buf[0] = MB_ASCII_START; for (frm_idx = 1; (bin_idx < bin_length); bin_idx++) { - pbuf[frm_idx++] = mb_bin2char((uint8_t)(pdata[bin_idx] >> 4)); // High nibble - pbuf[frm_idx++] = mb_bin2char((uint8_t)(pdata[bin_idx] & 0X0F)); // Low nibble - lrc += pdata[bin_idx]; + buf[frm_idx++] = mb_bin2char((uint8_t)(data_ptr[bin_idx] >> 4)); // High nibble + buf[frm_idx++] = mb_bin2char((uint8_t)(data_ptr[bin_idx] & 0X0F)); // Low nibble + lrc += data_ptr[bin_idx]; } lrc = (uint8_t)(-((char)lrc)); - pbuf[frm_idx++] = mb_bin2char((uint8_t)(lrc >> 4)); - pbuf[frm_idx++] = mb_bin2char((uint8_t)(lrc & 0X0F)); - pbuf[frm_idx++] = MB_ASCII_CR; - pbuf[frm_idx++] = MB_ASCII_LF; + buf[frm_idx++] = mb_bin2char((uint8_t)(lrc >> 4)); + buf[frm_idx++] = mb_bin2char((uint8_t)(lrc & 0X0F)); + buf[frm_idx++] = MB_ASCII_CR; + buf[frm_idx++] = MB_ASCII_LF; return frm_idx; } -int mb_ascii_get_binary_buf(uint8_t *pdata, int length) +int mb_ascii_get_binary_buf(uint8_t *data_ptr, int length) { int bin_idx = 0; uint8_t lrc = 0; - assert(pdata); + assert(data_ptr); - if ((pdata[0] == ':') && (pdata[length - 1] == '\n') && (pdata[length - 2] == '\r')) { - for (int str_idx = 1; (str_idx < length) && (pdata[str_idx] > ' '); str_idx += 2) { - pdata[bin_idx] = (mb_char2bin(pdata[str_idx]) << 4); // High nibble - pdata[bin_idx] |= mb_char2bin(pdata[str_idx + 1]); // Low nibble - lrc += pdata[bin_idx++]; + if ((data_ptr[0] == ':') && (data_ptr[length - 1] == '\n') && (data_ptr[length - 2] == '\r')) { + for (int str_idx = 1; (str_idx < length) && (data_ptr[str_idx] > ' '); str_idx += 2) { + data_ptr[bin_idx] = (mb_char2bin(data_ptr[str_idx]) << 4); // High nibble + data_ptr[bin_idx] |= mb_char2bin(data_ptr[str_idx + 1]); // Low nibble + lrc += data_ptr[bin_idx++]; } } diff --git a/modbus/mb_transports/ascii/ascii_lrc.h b/modbus/mb_transports/ascii/ascii_lrc.h index b0e1563..3101ca1 100644 --- a/modbus/mb_transports/ascii/ascii_lrc.h +++ b/modbus/mb_transports/ascii/ascii_lrc.h @@ -15,6 +15,6 @@ /* ----------------------- Static functions ---------------------------------*/ uint8_t mb_char2bin(uint8_t char_val); uint8_t mb_bin2char(uint8_t byte_val); -uint8_t mb_lrc(uint8_t *frame_ptr, uint16_t len_buf); -int mb_ascii_get_binary_buf(uint8_t *pdata, int length); -int mb_ascii_set_buf(const uint8_t *pdata, uint8_t *pbuf, int bin_length); \ No newline at end of file +uint8_t mb_lrc(uint8_t *frame, uint16_t length); +int mb_ascii_get_binary_buf(uint8_t *data_ptr, int length); +int mb_ascii_set_buf(const uint8_t *data_ptr, uint8_t *buf, int bin_length); \ No newline at end of file diff --git a/modbus/mb_transports/ascii/ascii_master.c b/modbus/mb_transports/ascii/ascii_master.c index 3e83a19..09766cd 100644 --- a/modbus/mb_transports/ascii/ascii_master.c +++ b/modbus/mb_transports/ascii/ascii_master.c @@ -28,12 +28,12 @@ typedef struct volatile mb_timer_mode_enum_t cur_timer_mode; } mbm_ascii_trasp_t; -static mb_err_enum_t mbm_ascii_transp_receive(mb_trans_base_t *inst, uint8_t *rcv_addr_buf, uint8_t **frame_ptr_buf, uint16_t *len_buf); +static mb_err_enum_t mbm_ascii_transp_receive(mb_trans_base_t *inst, uint8_t *recv_addr, uint8_t **frame_buf, uint16_t *buf_len); static mb_err_enum_t mbm_ascii_transp_send(mb_trans_base_t *inst, uint8_t slv_addr, const uint8_t *frame_ptr, uint16_t len); static void mbm_ascii_transp_start(mb_trans_base_t *inst); static void mbm_ascii_transp_stop(mb_trans_base_t *inst); -static void mbm_ascii_transp_get_rcv_buf(mb_trans_base_t *inst, uint8_t **frame_ptr_buf); -static void mbm_ascii_transp_get_snd_buf(mb_trans_base_t *inst, uint8_t **frame_ptr_buf); +static void mbm_ascii_transp_get_rcv_buf(mb_trans_base_t *inst, uint8_t **frame_buf); +static void mbm_ascii_transp_get_snd_buf(mb_trans_base_t *inst, uint8_t **frame_buf); static bool mbm_ascii_transp_timer_expired(void *inst); static bool mbm_ascii_transp_rq_is_bcast(mb_trans_base_t *inst); @@ -42,9 +42,11 @@ mb_err_enum_t mbm_ascii_transp_create(mb_serial_opts_t *ser_opts, void **in_out_ MB_RETURN_ON_FALSE((ser_opts && in_out_inst), MB_EINVAL, TAG, "invalid options for the instance."); mb_err_enum_t ret = MB_ENOERR; mbm_ascii_trasp_t *transp = NULL; + mb_port_base_t *port_obj = NULL; transp = (mbm_ascii_trasp_t *)calloc(1, sizeof(mbm_ascii_trasp_t)); + MB_GOTO_ON_FALSE((transp), MB_EILLSTATE, error, TAG, "no mem for transport instance."); transp->pascii_puf = calloc(1, MB_ASCII_SER_PDU_SIZE_MAX); - MB_RETURN_ON_FALSE((transp && transp->pascii_puf), MB_EILLSTATE, TAG, "no mem for ascii master transport instance."); + MB_GOTO_ON_FALSE((transp->pascii_puf), MB_EILLSTATE, error, TAG, "no mem for ascii master transport instance."); CRITICAL_SECTION_INIT(transp->base.lock); CRITICAL_SECTION_LOCK(transp->base.lock); transp->base.frm_rcv = mbm_ascii_transp_receive; @@ -57,7 +59,7 @@ mb_err_enum_t mbm_ascii_transp_create(mb_serial_opts_t *ser_opts, void **in_out_ transp->base.frm_is_bcast = mbm_ascii_transp_rq_is_bcast; transp->base.descr = ((mb_port_base_t *)*in_out_inst)->descr; transp->base.descr.obj_name = (char *)TAG; - mb_port_base_t *port_obj = (mb_port_base_t *)*in_out_inst; + port_obj = (mb_port_base_t *)*in_out_inst; ret = mb_port_ser_create(ser_opts, &port_obj); MB_GOTO_ON_FALSE((ret == MB_ENOERR), MB_EPORTERR, error, TAG, "serial port creation, err: %d", ret); ret = mb_port_timer_create(port_obj, (MB_ASCII_TIMEOUT_MS * MB_TIMER_TICS_PER_MS)); @@ -81,15 +83,17 @@ mb_err_enum_t mbm_ascii_transp_create(mb_serial_opts_t *ser_opts, void **in_out_ return MB_ENOERR; error: - free((void *)transp->pascii_puf); - transp->pascii_puf = NULL; + if (transp) { + free((void *)transp->pascii_puf); + transp->pascii_puf = NULL; + CRITICAL_SECTION_UNLOCK(transp->base.lock); + CRITICAL_SECTION_CLOSE(transp->base.lock); + } if (port_obj) { free(port_obj->event_obj); free(port_obj->timer_obj); } free(port_obj); - CRITICAL_SECTION_UNLOCK(transp->base.lock); - CRITICAL_SECTION_CLOSE(transp->base.lock); free(transp); return ret; } @@ -129,19 +133,19 @@ static void mbm_ascii_transp_stop(mb_trans_base_t *inst) }; } -static mb_err_enum_t mbm_ascii_transp_receive(mb_trans_base_t *inst, uint8_t *prcv_addr, uint8_t **ppframe_buf, uint16_t *pbuf_len) +static mb_err_enum_t mbm_ascii_transp_receive(mb_trans_base_t *inst, uint8_t *recv_addr, uint8_t **frame_buf, uint16_t *buf_len) { mbm_ascii_trasp_t *transp = __containerof(inst, mbm_ascii_trasp_t, base); mb_err_enum_t status = MB_ENOERR; - if (!pbuf_len) { + if (!buf_len) { return MB_EIO; } - uint8_t *pbuf = (uint8_t *)transp->rcv_buf; - uint16_t length = *pbuf_len; + uint8_t *buf = (uint8_t *)transp->rcv_buf; + uint16_t length = *buf_len; - if (mb_port_ser_recv_data(inst->port_obj, &pbuf, &length) == false) + if (mb_port_ser_recv_data(inst->port_obj, &buf, &length) == false) { return MB_EPORTERR; } @@ -149,23 +153,23 @@ static mb_err_enum_t mbm_ascii_transp_receive(mb_trans_base_t *inst, uint8_t *pr assert(length < MB_ASCII_SER_PDU_SIZE_MAX); // Convert the received ascii frame buffer to the binary representation - int ret = mb_ascii_get_binary_buf(pbuf, length); + int ret = mb_ascii_get_binary_buf(buf, length); /* Check length and LRC checksum */ if (ret >= MB_ASCII_SER_PDU_SIZE_MIN) { /* Save the address field. All frames are passed to the upper layed * and the decision if a frame is used is done there. */ - *prcv_addr = pbuf[MB_SER_PDU_ADDR_OFF]; + *recv_addr = buf[MB_SER_PDU_ADDR_OFF]; /* Total length of Modbus-PDU is Modbus-Serial-Line-PDU minus * size of address field and LRC checksum. */ - *pbuf_len = (uint16_t)(ret - MB_SER_PDU_PDU_OFF - MB_SER_PDU_SIZE_LRC); + *buf_len = (uint16_t)(ret - MB_SER_PDU_PDU_OFF - MB_SER_PDU_SIZE_LRC); transp->rcv_buf_pos = ret; /* Return the start of the Modbus PDU to the caller. */ - *ppframe_buf = (uint8_t *)&pbuf[MB_SER_PDU_PDU_OFF]; + *frame_buf = &buf[MB_SER_PDU_PDU_OFF]; } else { status = MB_EIO; } @@ -191,9 +195,9 @@ static mb_err_enum_t mbm_ascii_transp_send(mb_trans_base_t *inst, uint8_t slv_ad transp->snd_buf_cnt += frame_len; /* Prepare the ASCII buffer and send it to port */ - int ascii_len = mb_ascii_set_buf(transp->snd_buf_cur, (uint8_t *)transp->pascii_puf, transp->snd_buf_cnt); + int ascii_len = mb_ascii_set_buf(transp->snd_buf_cur, transp->pascii_puf, transp->snd_buf_cnt); if (ascii_len > MB_ASCII_SER_PDU_SIZE_MIN) { - bool ret = mb_port_ser_send_data(inst->port_obj, (uint8_t *)transp->pascii_puf, ascii_len); + bool ret = mb_port_ser_send_data(inst->port_obj, transp->pascii_puf, ascii_len); if (!ret) { return MB_EPORTERR; } @@ -264,19 +268,19 @@ static bool mbm_ascii_transp_timer_expired(void *inst) return need_poll; } -static void mbm_ascii_transp_get_rcv_buf(mb_trans_base_t *inst, uint8_t **frame_ptr_buf) +static void mbm_ascii_transp_get_rcv_buf(mb_trans_base_t *inst, uint8_t **frame_buf) { mbm_ascii_trasp_t *transp = __containerof(inst, mbm_ascii_trasp_t, base); CRITICAL_SECTION(inst->lock) { - *frame_ptr_buf = (uint8_t *)&transp->rcv_buf[MB_PDU_FUNC_OFF]; + *frame_buf = &transp->rcv_buf[MB_PDU_FUNC_OFF]; } } -static void mbm_ascii_transp_get_snd_buf(mb_trans_base_t *inst, uint8_t **frame_ptr_buf) +static void mbm_ascii_transp_get_snd_buf(mb_trans_base_t *inst, uint8_t **frame_buf) { mbm_ascii_trasp_t *transp = __containerof(inst, mbm_ascii_trasp_t, base); CRITICAL_SECTION(inst->lock) { - *frame_ptr_buf = (uint8_t *)&transp->snd_buf[MB_ASCII_SER_PDU_PDU_OFF]; + *frame_buf = &transp->snd_buf[MB_ASCII_SER_PDU_PDU_OFF]; } } diff --git a/modbus/mb_transports/ascii/ascii_slave.c b/modbus/mb_transports/ascii/ascii_slave.c index eb3c3a5..d2def36 100644 --- a/modbus/mb_transports/ascii/ascii_slave.c +++ b/modbus/mb_transports/ascii/ascii_slave.c @@ -31,23 +31,24 @@ typedef struct mb_err_enum_t mbs_ascii_transp_create(mb_serial_opts_t *ser_opts, void **in_out_inst); static void mbs_ascii_transp_start(mb_trans_base_t *inst); static void mbs_ascii_transp_stop(mb_trans_base_t *inst); -static mb_err_enum_t mbs_ascii_transp_receive(mb_trans_base_t *inst, uint8_t *rcv_addr_buf, uint8_t **frame_ptr_buf, uint16_t *len_buf); +static mb_err_enum_t mbs_ascii_transp_receive(mb_trans_base_t *inst, uint8_t *recv_addr, uint8_t **frame_buf, uint16_t *buf_len); static mb_err_enum_t mbs_ascii_transp_send(mb_trans_base_t *inst, uint8_t slv_addr, const uint8_t *frame_ptr, uint16_t len); static bool mbs_ascii_transp_rcv_fsm(mb_trans_base_t *inst); static bool mbs_ascii_transp_snd_fsm(mb_trans_base_t *inst); static bool mbs_ascii_transp_timer_expired(void *inst); -void mbs_ascii_transp_get_rcv_buf(mb_trans_base_t *inst, uint8_t **frame_ptr_buf); -static void mbs_ascii_transp_get_snd_buf(mb_trans_base_t *inst, uint8_t **frame_ptr_buf); +void mbs_ascii_transp_get_rcv_buf(mb_trans_base_t *inst, uint8_t **frame_buf); +static void mbs_ascii_transp_get_snd_buf(mb_trans_base_t *inst, uint8_t **frame_buf); mb_err_enum_t mbs_ascii_transp_create(mb_serial_opts_t *ser_opts, void **in_out_inst) { MB_RETURN_ON_FALSE((ser_opts && in_out_inst), MB_EINVAL, TAG, "invalid options for the instance."); mb_err_enum_t ret = MB_ENOERR; mbs_ascii_trasp_t *transp = NULL; + mb_port_base_t *port_obj = NULL; transp = (mbs_ascii_trasp_t *)calloc(1, sizeof(mbs_ascii_trasp_t)); - MB_RETURN_ON_FALSE(transp, MB_EILLSTATE, TAG, "no mem for the %s instance.", TAG); + MB_GOTO_ON_FALSE(transp, MB_EILLSTATE, error, TAG, "no mem for the %s instance.", TAG); transp->pascii_puf = calloc(1, MB_ASCII_SER_PDU_SIZE_MAX); - MB_RETURN_ON_FALSE((transp && transp->pascii_puf), MB_EILLSTATE, TAG, "no mem for the %s instance.", TAG); + MB_GOTO_ON_FALSE((transp->pascii_puf), MB_EILLSTATE, error, TAG, "no mem for the %s instance.", TAG); CRITICAL_SECTION_INIT(transp->base.lock); transp->base.frm_rcv = mbs_ascii_transp_receive; transp->base.frm_send = mbs_ascii_transp_send; @@ -59,7 +60,7 @@ mb_err_enum_t mbs_ascii_transp_create(mb_serial_opts_t *ser_opts, void **in_out_ transp->base.frm_is_bcast = NULL; transp->base.descr = ((mb_port_base_t *)*in_out_inst)->descr; transp->base.descr.obj_name = (char *)TAG; - mb_port_base_t *port_obj = (mb_port_base_t *)*in_out_inst; + port_obj = (mb_port_base_t *)*in_out_inst; ret = mb_port_ser_create(ser_opts, &port_obj); MB_GOTO_ON_FALSE((ret == MB_ENOERR), MB_EPORTERR, error, TAG, "serial port creation, err: %d", ret); ret = mb_port_timer_create(port_obj, (MB_ASCII_TIMEOUT_MS * MB_TIMER_TICS_PER_MS)); @@ -79,14 +80,17 @@ mb_err_enum_t mbs_ascii_transp_create(mb_serial_opts_t *ser_opts, void **in_out_ return MB_ENOERR; error: - free(transp->pascii_puf); - transp->pascii_puf = NULL; + if (transp) { + free(transp->pascii_puf); + transp->pascii_puf = NULL; + CRITICAL_SECTION_UNLOCK(transp->base.lock); + CRITICAL_SECTION_CLOSE(transp->base.lock); + } if (port_obj) { free(port_obj->event_obj); free(port_obj->timer_obj); } free(port_obj); - CRITICAL_SECTION_CLOSE(transp->base.lock); free(transp); return ret; } @@ -125,39 +129,39 @@ static void mbs_ascii_transp_stop(mb_trans_base_t *inst) }; } -static mb_err_enum_t mbs_ascii_transp_receive(mb_trans_base_t *inst, uint8_t *prcv_addr, uint8_t **ppframe_buf, uint16_t *pbuf_len) +static mb_err_enum_t mbs_ascii_transp_receive(mb_trans_base_t *inst, uint8_t *recv_addr, uint8_t **frame_buf, uint16_t *buf_len) { mbs_ascii_trasp_t *transp = __containerof(inst, mbs_ascii_trasp_t, base); mb_err_enum_t status = MB_ENOERR; assert(transp->rcv_buf); - uint8_t *pbuf = (uint8_t *)transp->rcv_buf; - uint16_t length = *pbuf_len; + uint8_t *buf = transp->rcv_buf; + uint16_t length = *buf_len; - if (mb_port_ser_recv_data(inst->port_obj, &pbuf, &length) == false) { + if (mb_port_ser_recv_data(inst->port_obj, &buf, &length) == false) { return MB_EPORTERR; } assert(length < MB_ASCII_SER_PDU_SIZE_MAX); // Convert the received ascii frame buffer to the binary representation - int ret = mb_ascii_get_binary_buf(pbuf, length); + int ret = mb_ascii_get_binary_buf(buf, length); /* Check length and CRC checksum */ if (ret >= MB_ASCII_SER_PDU_SIZE_MIN) { /* Save the address field. All frames are passed to the upper layed * and the decision if a frame is used is done there. */ - *prcv_addr = pbuf[MB_SER_PDU_ADDR_OFF]; + *recv_addr = buf[MB_SER_PDU_ADDR_OFF]; /* Total length of Modbus-PDU is Modbus-Serial-Line-PDU minus * size of address field and LRC checksum. */ - *pbuf_len = (uint16_t)(ret - MB_SER_PDU_PDU_OFF - MB_SER_PDU_SIZE_LRC); + *buf_len = (uint16_t)(ret - MB_SER_PDU_PDU_OFF - MB_SER_PDU_SIZE_LRC); transp->rcv_buf_pos = ret; /* Return the start of the Modbus PDU to the caller. */ - *ppframe_buf = (uint8_t *)&pbuf[MB_SER_PDU_PDU_OFF]; + *frame_buf = &buf[MB_SER_PDU_PDU_OFF]; } else { status = MB_EIO; } @@ -183,9 +187,9 @@ static mb_err_enum_t mbs_ascii_transp_send(mb_trans_base_t *inst, uint8_t slv_ad transp->snd_buf_cnt += frame_len; /* Prepare the ASCII buffer and send it to port */ - int ascii_len = mb_ascii_set_buf(transp->snd_buf_cur, (uint8_t *)transp->pascii_puf, transp->snd_buf_cnt); + int ascii_len = mb_ascii_set_buf(transp->snd_buf_cur, transp->pascii_puf, transp->snd_buf_cnt); if (ascii_len > MB_ASCII_SER_PDU_SIZE_MIN) { - bool ret = mb_port_ser_send_data(inst->port_obj, (uint8_t *)transp->pascii_puf, ascii_len); + bool ret = mb_port_ser_send_data(inst->port_obj, transp->pascii_puf, ascii_len); if (!ret) { return MB_EPORTERR; } @@ -218,22 +222,22 @@ static bool mbs_ascii_transp_timer_expired(void *inst) return false; } -void mbs_ascii_transp_get_rcv_buf(mb_trans_base_t *inst, uint8_t **frame_ptr_buf) +void mbs_ascii_transp_get_rcv_buf(mb_trans_base_t *inst, uint8_t **frame_buf) { mbs_ascii_trasp_t *transp = __containerof(inst, mbs_ascii_trasp_t, base); assert(transp->rcv_buf); CRITICAL_SECTION(inst->lock) { - *frame_ptr_buf = (uint8_t *)&transp->rcv_buf[MB_PDU_FUNC_OFF]; + *frame_buf = &transp->rcv_buf[MB_PDU_FUNC_OFF]; } } -static void mbs_ascii_transp_get_snd_buf(mb_trans_base_t *inst, uint8_t **frame_ptr_buf) +static void mbs_ascii_transp_get_snd_buf(mb_trans_base_t *inst, uint8_t **frame_buf) { mbs_ascii_trasp_t *transp = __containerof(inst, mbs_ascii_trasp_t, base); CRITICAL_SECTION(inst->lock) { - *frame_ptr_buf = (uint8_t *)&transp->pdu_buf[MB_PDU_FUNC_OFF]; + *frame_buf = (uint8_t *)&transp->pdu_buf[MB_PDU_FUNC_OFF]; } } diff --git a/modbus/mb_transports/rtu/rtu_master.c b/modbus/mb_transports/rtu/rtu_master.c index 7a0ca31..6558fe0 100644 --- a/modbus/mb_transports/rtu/rtu_master.c +++ b/modbus/mb_transports/rtu/rtu_master.c @@ -31,13 +31,13 @@ typedef struct mb_err_enum_t mbm_rtu_transp_create(mb_serial_opts_t *ser_opts, void **in_out_inst); static void mbm_rtu_transp_start(mb_trans_base_t *inst); static void mbm_rtu_transp_stop(mb_trans_base_t *inst); -static mb_err_enum_t mbm_rtu_transp_receive(mb_trans_base_t *inst, uint8_t *rcv_addr_buf, uint8_t **frame_ptr_buf, uint16_t *len_buf); +static mb_err_enum_t mbm_rtu_transp_receive(mb_trans_base_t *inst, uint8_t *rcv_addr_buf, uint8_t **frame_buf, uint16_t *buf_len); static mb_err_enum_t mbm_rtu_transp_send(mb_trans_base_t *inst, uint8_t slv_addr, const uint8_t *frame_ptr, uint16_t len); static bool mbm_rtu_transp_rcv_fsm(mb_trans_base_t *inst); static bool mbm_rtu_transp_snd_fsm(mb_trans_base_t *inst); static bool mbm_rtu_transp_timer_expired(void *inst); -static void mbm_rtu_transp_get_snd_buf(mb_trans_base_t *inst, uint8_t **frame_ptr_buf); -static void mbm_rtu_transp_get_rcv_buf(mb_trans_base_t *inst, uint8_t **frame_ptr_buf); +static void mbm_rtu_transp_get_snd_buf(mb_trans_base_t *inst, uint8_t **frame_buf); +static void mbm_rtu_transp_get_rcv_buf(mb_trans_base_t *inst, uint8_t **frame_buf); // static uint16_t mbm_rtu_transp_get_snd_len(mb_trans_base_t *inst); static void mbm_rtu_transp_set_snd_len(mb_trans_base_t *inst, uint16_t snd_pdu_len); static bool mbm_rtu_transp_rq_is_bcast(mb_trans_base_t *inst); @@ -48,8 +48,9 @@ mb_err_enum_t mbm_rtu_transp_create(mb_serial_opts_t *ser_opts, void **in_out_in MB_RETURN_ON_FALSE((ser_opts && in_out_inst), MB_EINVAL, TAG, "invalid options for the instance."); mb_err_enum_t ret = MB_ENOERR; mbm_rtu_transp_t *transp = NULL; + mb_port_base_t *port_obj = NULL; transp = (mbm_rtu_transp_t *)calloc(1, sizeof(mbm_rtu_transp_t)); - MB_RETURN_ON_FALSE(transp, MB_EILLSTATE, TAG, "no mem for %s instance.", TAG); + MB_GOTO_ON_FALSE(transp, MB_EILLSTATE, error, TAG, "no mem for %s instance.", TAG); CRITICAL_SECTION_INIT(transp->base.lock); CRITICAL_SECTION_LOCK(transp->base.lock); transp->base.frm_rcv = mbm_rtu_transp_receive; @@ -63,7 +64,7 @@ mb_err_enum_t mbm_rtu_transp_create(mb_serial_opts_t *ser_opts, void **in_out_in // Copy parent object descriptor transp->base.descr = ((mb_port_base_t *)*in_out_inst)->descr; transp->base.descr.obj_name = (char *)TAG; - mb_port_base_t *port_obj = (mb_port_base_t *)*in_out_inst; + port_obj = (mb_port_base_t *)*in_out_inst; ret = mb_port_ser_create(ser_opts, &port_obj); MB_GOTO_ON_FALSE((ret == MB_ENOERR), MB_EILLSTATE, error, TAG, "serial port creation, err: %d", ret); ret = mb_port_timer_create(port_obj, MB_RTU_GET_T35_VAL(ser_opts->baudrate)); @@ -87,16 +88,19 @@ mb_err_enum_t mbm_rtu_transp_create(mb_serial_opts_t *ser_opts, void **in_out_in return MB_ENOERR; error: - if (port_obj->timer_obj) { - mb_port_timer_delete(port_obj); - } - if (port_obj->event_obj) { - mb_port_event_delete(port_obj); - } if (port_obj) { + if (port_obj->timer_obj) { + mb_port_timer_delete(port_obj); + } + if (port_obj->event_obj) { + mb_port_event_delete(port_obj); + } mb_port_ser_delete(port_obj); } - CRITICAL_SECTION_CLOSE(transp->base.lock); + if (transp) { + CRITICAL_SECTION_UNLOCK(transp->base.lock); + CRITICAL_SECTION_CLOSE(transp->base.lock); + } free(transp); return ret; } @@ -134,43 +138,43 @@ static void mbm_rtu_transp_stop(mb_trans_base_t *inst) }; } -static mb_err_enum_t mbm_rtu_transp_receive(mb_trans_base_t *inst, uint8_t *prcv_addr, uint8_t **ppframe_buf, uint16_t *pbuf_len) +static mb_err_enum_t mbm_rtu_transp_receive(mb_trans_base_t *inst, uint8_t *rcv_addr_buf, uint8_t **frame_buf, uint16_t *buf_len) { mbm_rtu_transp_t *transp = __containerof(inst, mbm_rtu_transp_t, base); - if (!pbuf_len || !prcv_addr || !ppframe_buf || !pbuf_len) { + if (!buf_len || !rcv_addr_buf || !frame_buf || !buf_len) { return MB_EIO; } mb_err_enum_t status = MB_ENOERR; - uint8_t *pbuf = (uint8_t *)transp->rcv_buf; - uint16_t length = *pbuf_len; + uint8_t *buf = (uint8_t *)transp->rcv_buf; + uint16_t length = *buf_len; - if (mb_port_ser_recv_data(inst->port_obj, &pbuf, &length) == false) { - *pbuf_len = 0; + if (mb_port_ser_recv_data(inst->port_obj, &buf, &length) == false) { + *buf_len = 0; return MB_EPORTERR; } assert(length < MB_RTU_SER_PDU_SIZE_MAX); - assert(pbuf); + assert(buf); /* Check length and CRC checksum */ if ((length >= MB_RTU_SER_PDU_SIZE_MIN) - && (mb_crc16((uint8_t *)pbuf, length) == 0)) { + && (mb_crc16(buf, length) == 0)) { /* Save the address field. All frames are passed to the upper layed * and the decision if a frame is used is done there. */ - *prcv_addr = pbuf[MB_SER_PDU_ADDR_OFF]; + *rcv_addr_buf = buf[MB_SER_PDU_ADDR_OFF]; /* Total length of Modbus-PDU is Modbus-Serial-Line-PDU minus * size of address field and CRC checksum. */ - *pbuf_len = (uint16_t)(length - MB_SER_PDU_PDU_OFF - MB_SER_PDU_SIZE_CRC); + *buf_len = (uint16_t)(length - MB_SER_PDU_PDU_OFF - MB_SER_PDU_SIZE_CRC); transp->rcv_buf_pos = length; /* Return the start of the Modbus PDU to the caller. */ - *ppframe_buf = (uint8_t *)&pbuf[MB_SER_PDU_PDU_OFF]; + *frame_buf = &buf[MB_SER_PDU_PDU_OFF]; } else { status = MB_EIO; } @@ -196,11 +200,11 @@ static mb_err_enum_t mbm_rtu_transp_send(mb_trans_base_t *inst, uint8_t slv_addr transp->snd_buf_cur[MB_SER_PDU_ADDR_OFF] = slv_addr; transp->snd_buf_cnt += frame_len; /* Calculate CRC16 checksum for Modbus-Serial-Line-PDU. */ - crc16 = mb_crc16((uint8_t *) transp->snd_buf_cur, transp->snd_buf_cnt); + crc16 = mb_crc16(transp->snd_buf_cur, transp->snd_buf_cnt); transp->snd_buf_cur[transp->snd_buf_cnt++] = (uint8_t)(crc16 & 0xFF); transp->snd_buf_cur[transp->snd_buf_cnt++] = (uint8_t)(crc16 >> 8); - bool ret = mb_port_ser_send_data(inst->port_obj, (uint8_t *)transp->snd_buf_cur, transp->snd_buf_cnt); + bool ret = mb_port_ser_send_data(inst->port_obj, transp->snd_buf_cur, transp->snd_buf_cnt); if (!ret) { return MB_EPORTERR; } @@ -267,19 +271,19 @@ static bool mbm_rtu_transp_timer_expired(void *inst) return need_poll; } -static void mbm_rtu_transp_get_rcv_buf(mb_trans_base_t *inst, uint8_t **frame_ptr_buf) +static void mbm_rtu_transp_get_rcv_buf(mb_trans_base_t *inst, uint8_t **frame_buf) { mbm_rtu_transp_t *transp = __containerof(inst, mbm_rtu_transp_t, base); CRITICAL_SECTION(inst->lock) { - *frame_ptr_buf = (uint8_t *)&transp->rcv_buf[MB_PDU_FUNC_OFF]; + *frame_buf = &transp->rcv_buf[MB_PDU_FUNC_OFF]; } } -static void mbm_rtu_transp_get_snd_buf(mb_trans_base_t *inst, uint8_t **frame_ptr_buf) +static void mbm_rtu_transp_get_snd_buf(mb_trans_base_t *inst, uint8_t **frame_buf) { mbm_rtu_transp_t *transp = __containerof(inst, mbm_rtu_transp_t, base); CRITICAL_SECTION(inst->lock) { - *frame_ptr_buf = (uint8_t *)&transp->snd_buf[MB_RTU_SER_PDU_PDU_OFF]; + *frame_buf = &transp->snd_buf[MB_RTU_SER_PDU_PDU_OFF]; } } diff --git a/modbus/mb_transports/rtu/rtu_slave.c b/modbus/mb_transports/rtu/rtu_slave.c index deb0162..ab46e29 100644 --- a/modbus/mb_transports/rtu/rtu_slave.c +++ b/modbus/mb_transports/rtu/rtu_slave.c @@ -28,13 +28,13 @@ typedef struct mb_err_enum_t mbs_rtu_transp_create(mb_serial_opts_t *ser_opts, void **in_out_inst); static void mbs_rtu_transp_start(mb_trans_base_t *inst); static void mbs_rtu_transp_stop(mb_trans_base_t *inst); -static mb_err_enum_t mbs_rtu_transp_receive(mb_trans_base_t *inst, uint8_t *rcv_addr_buf, uint8_t **frame_ptr_buf, uint16_t *len_buf); +static mb_err_enum_t mbs_rtu_transp_receive(mb_trans_base_t *inst, uint8_t *recv_addr, uint8_t **frame_buf, uint16_t *buf_len); static mb_err_enum_t mbs_rtu_transp_send(mb_trans_base_t *inst, uint8_t slv_addr, const uint8_t *frame_ptr, uint16_t len); static bool mbs_rtu_transp_rcv_fsm(mb_trans_base_t *inst); static bool mbs_rtu_transp_snd_fsm(mb_trans_base_t *inst); static bool mbs_rtu_transp_timer_expired(void *inst); -static void mbs_rtu_transp_get_snd_buf(mb_trans_base_t *inst, uint8_t **frame_ptr_buf); -void mbs_rtu_transp_get_rcv_buf(mb_trans_base_t *inst, uint8_t **frame_ptr_buf); +static void mbs_rtu_transp_get_snd_buf(mb_trans_base_t *inst, uint8_t **frame_buf); +void mbs_rtu_transp_get_rcv_buf(mb_trans_base_t *inst, uint8_t **frame_buf); static uint16_t mbs_rtu_transp_get_snd_len(mb_trans_base_t *inst); static void mbs_rtu_transp_set_snd_len(mb_trans_base_t *inst, uint16_t snd_pdu_len); bool mbs_rtu_transp_delete(mb_trans_base_t *inst); @@ -82,8 +82,11 @@ error: free(port_obj->event_obj); free(port_obj->timer_obj); } + if (transp) { + CRITICAL_SECTION_UNLOCK(transp->base.lock); + CRITICAL_SECTION_CLOSE(transp->base.lock); + } free(port_obj); - CRITICAL_SECTION_CLOSE(transp->base.lock); free(transp); return ret; } @@ -121,42 +124,42 @@ static void mbs_rtu_transp_stop(mb_trans_base_t *inst) }; } -static mb_err_enum_t mbs_rtu_transp_receive(mb_trans_base_t *inst, uint8_t *prcv_addr, uint8_t **ppframe_buf, uint16_t *pbuf_len) +static mb_err_enum_t mbs_rtu_transp_receive(mb_trans_base_t *inst, uint8_t *recv_addr, uint8_t **frame_buf, uint16_t *buf_len) { - if (!pbuf_len || !prcv_addr || !ppframe_buf || !pbuf_len) { + if (!buf_len || !recv_addr || !frame_buf || !buf_len) { return MB_EIO; } mbs_rtu_transp_t *transp = __containerof(inst, mbs_rtu_transp_t, base); mb_err_enum_t status = MB_ENOERR; - uint8_t *pbuf = (uint8_t *)transp->rcv_buf; - uint16_t length = *pbuf_len; + uint8_t *buf = (uint8_t *)transp->rcv_buf; + uint16_t length = *buf_len; - if (mb_port_ser_recv_data(inst->port_obj, &pbuf, &length) == false){ - *pbuf_len = 0; + if (mb_port_ser_recv_data(inst->port_obj, &buf, &length) == false){ + *buf_len = 0; return MB_EPORTERR; } assert(length < MB_RTU_SER_PDU_SIZE_MAX); - assert(pbuf); + assert(buf); /* Check length and CRC checksum */ if ((length >= MB_RTU_SER_PDU_SIZE_MIN) - && (mb_crc16((uint8_t *)pbuf, length) == 0)) { + && (mb_crc16(buf, length) == 0)) { /* Save the address field. All frames are passed to the upper layed * and the decision if a frame is used is done there. */ - *prcv_addr = pbuf[MB_SER_PDU_ADDR_OFF]; + *recv_addr = buf[MB_SER_PDU_ADDR_OFF]; /* Total length of Modbus-PDU is Modbus-Serial-Line-PDU minus * size of address field and CRC checksum. */ - *pbuf_len = (uint16_t)(length - MB_SER_PDU_PDU_OFF - MB_SER_PDU_SIZE_CRC); + *buf_len = (uint16_t)(length - MB_SER_PDU_PDU_OFF - MB_SER_PDU_SIZE_CRC); transp->rcv_buf_pos = length; /* Return the start of the Modbus PDU to the caller. */ - *ppframe_buf = (uint8_t *)&pbuf[MB_SER_PDU_PDU_OFF]; + *frame_buf = &buf[MB_SER_PDU_PDU_OFF]; } else { status = MB_EIO; } @@ -182,11 +185,11 @@ static mb_err_enum_t mbs_rtu_transp_send(mb_trans_base_t *inst, uint8_t slv_addr transp->snd_buf_cur[MB_SER_PDU_ADDR_OFF] = slv_addr; transp->snd_buf_cnt += frame_len; /* Calculate CRC16 checksum for Modbus-Serial-Line-PDU. */ - crc16 = mb_crc16((uint8_t *) transp->snd_buf_cur, transp->snd_buf_cnt); + crc16 = mb_crc16(transp->snd_buf_cur, transp->snd_buf_cnt); transp->snd_buf_cur[transp->snd_buf_cnt++] = (uint8_t)(crc16 & 0xFF); transp->snd_buf_cur[transp->snd_buf_cnt++] = (uint8_t)(crc16 >> 8); - bool ret = mb_port_ser_send_data(inst->port_obj, (uint8_t *)transp->snd_buf_cur, transp->snd_buf_cnt); + bool ret = mb_port_ser_send_data(inst->port_obj, transp->snd_buf_cur, transp->snd_buf_cnt); if (!ret) { return MB_EPORTERR; } @@ -219,19 +222,19 @@ static bool mbs_rtu_transp_timer_expired(void *inst) return need_poll; } -static void mbs_rtu_transp_get_snd_buf(mb_trans_base_t *inst, uint8_t **frame_ptr_buf) +static void mbs_rtu_transp_get_snd_buf(mb_trans_base_t *inst, uint8_t **frame_buf) { mbs_rtu_transp_t *transp = __containerof(inst, mbs_rtu_transp_t, base); CRITICAL_SECTION(inst->lock) { - *frame_ptr_buf = (uint8_t *)&transp->snd_buf[MB_RTU_SER_PDU_PDU_OFF]; + *frame_buf = &transp->snd_buf[MB_RTU_SER_PDU_PDU_OFF]; } } -void mbs_rtu_transp_get_rcv_buf(mb_trans_base_t *inst, uint8_t **frame_ptr_buf) +void mbs_rtu_transp_get_rcv_buf(mb_trans_base_t *inst, uint8_t **frame_buf) { mbs_rtu_transp_t *transp = __containerof(inst, mbs_rtu_transp_t, base); CRITICAL_SECTION(inst->lock) { - *frame_ptr_buf = (uint8_t *)&transp->rcv_buf[MB_PDU_FUNC_OFF]; + *frame_buf = &transp->rcv_buf[MB_PDU_FUNC_OFF]; } } diff --git a/modbus/mb_transports/tcp/tcp_master.c b/modbus/mb_transports/tcp/tcp_master.c index 95a6d02..ed56315 100644 --- a/modbus/mb_transports/tcp/tcp_master.c +++ b/modbus/mb_transports/tcp/tcp_master.c @@ -28,10 +28,10 @@ typedef struct mb_err_enum_t mbm_tcp_transp_create(mb_tcp_opts_t *tcp_opts, void **in_out_inst); static void mbm_tcp_transp_start(mb_trans_base_t *inst); static void mbm_tcp_transp_stop(mb_trans_base_t *inst); -static mb_err_enum_t mbm_tcp_transp_receive(mb_trans_base_t *inst, uint8_t *rcv_addr_buf, uint8_t **frame_ptr_buf, uint16_t *pbuf_len); -static mb_err_enum_t mbm_tcp_transp_send(mb_trans_base_t *inst, uint8_t _unused, const uint8_t *pframe, uint16_t len); -static void mbm_tcp_transp_get_rcv_buf(mb_trans_base_t *inst, uint8_t **frame_ptr_buf); -static void mbm_tcp_transp_get_snd_buf(mb_trans_base_t *inst, uint8_t **frame_ptr_buf); +static mb_err_enum_t mbm_tcp_transp_receive(mb_trans_base_t *inst, uint8_t *rcv_addr_buf, uint8_t **frame_buf, uint16_t *buf_len); +static mb_err_enum_t mbm_tcp_transp_send(mb_trans_base_t *inst, uint8_t address, const uint8_t *frame, uint16_t len); +static void mbm_tcp_transp_get_rcv_buf(mb_trans_base_t *inst, uint8_t **frame_buf); +static void mbm_tcp_transp_get_snd_buf(mb_trans_base_t *inst, uint8_t **frame_buf); bool mbm_tcp_transp_delete(mb_trans_base_t *inst); static bool mbm_tcp_transp_rq_is_bcast(mb_trans_base_t *inst); @@ -123,11 +123,11 @@ static void mbm_tcp_transp_stop(mb_trans_base_t *inst) }; } -static mb_err_enum_t mbm_tcp_transp_receive(mb_trans_base_t *inst, uint8_t *rcv_addr, uint8_t **frame_ptr_buf, uint16_t *pbuf_len) +static mb_err_enum_t mbm_tcp_transp_receive(mb_trans_base_t *inst, uint8_t *rcv_addr, uint8_t **frame_buf, uint16_t *buf_len) { mb_err_enum_t status = MB_EIO; uint8_t *frame_ptr; - uint16_t len = *pbuf_len; + uint16_t len = *buf_len; uint16_t pid; if (mbm_port_tcp_recv_data(inst->port_obj, &frame_ptr, &len) != false) { @@ -135,8 +135,8 @@ static mb_err_enum_t mbm_tcp_transp_receive(mb_trans_base_t *inst, uint8_t *rcv_ pid |= frame_ptr[MB_TCP_PID + 1]; if (pid == MB_TCP_PROTOCOL_ID) { - *frame_ptr_buf = &frame_ptr[MB_TCP_FUNC]; - *pbuf_len = len - MB_TCP_FUNC; + *frame_buf = &frame_ptr[MB_TCP_FUNC]; + *buf_len = len - MB_TCP_FUNC; status = MB_ENOERR; /* Get MBAP UID field if its support is enabled. @@ -154,10 +154,10 @@ static mb_err_enum_t mbm_tcp_transp_receive(mb_trans_base_t *inst, uint8_t *rcv_ return status; } -static mb_err_enum_t mbm_tcp_transp_send(mb_trans_base_t *inst, uint8_t address, const uint8_t *pframe, uint16_t len) +static mb_err_enum_t mbm_tcp_transp_send(mb_trans_base_t *inst, uint8_t address, const uint8_t *frame, uint16_t len) { mb_err_enum_t status = MB_ENOERR; - uint8_t *frame_ptr = (uint8_t *)pframe - MB_TCP_FUNC; + uint8_t *frame_ptr = (uint8_t *)frame - MB_TCP_FUNC; uint16_t tcp_len = len + MB_TCP_FUNC; /* The MBAP header is already initialized because the caller calls this @@ -185,19 +185,19 @@ static mb_err_enum_t mbm_tcp_transp_send(mb_trans_base_t *inst, uint8_t address, return status; } -static void mbm_tcp_transp_get_rcv_buf(mb_trans_base_t *inst, uint8_t **frame_ptr_buf) +static void mbm_tcp_transp_get_rcv_buf(mb_trans_base_t *inst, uint8_t **frame_buf) { mbm_tcp_transp_t *transp = __containerof(inst, mbm_tcp_transp_t, base); CRITICAL_SECTION(inst->lock) { - *frame_ptr_buf = transp->recv_buf + MB_TCP_FUNC; + *frame_buf = transp->recv_buf + MB_TCP_FUNC; } } -static void mbm_tcp_transp_get_snd_buf(mb_trans_base_t *inst, uint8_t **frame_ptr_buf) +static void mbm_tcp_transp_get_snd_buf(mb_trans_base_t *inst, uint8_t **frame_buf) { mbm_tcp_transp_t *transp = __containerof(inst, mbm_tcp_transp_t, base); CRITICAL_SECTION(inst->lock) { - *frame_ptr_buf = transp->send_buf + MB_TCP_FUNC; + *frame_buf = transp->send_buf + MB_TCP_FUNC; } } diff --git a/modbus/mb_transports/tcp/tcp_slave.c b/modbus/mb_transports/tcp/tcp_slave.c index ec4bee7..739b8e3 100644 --- a/modbus/mb_transports/tcp/tcp_slave.c +++ b/modbus/mb_transports/tcp/tcp_slave.c @@ -26,10 +26,10 @@ typedef struct /* ----------------------- Function prototypes ------------------------------*/ static void mbs_tcp_transp_start(mb_trans_base_t *inst); static void mbs_tcp_transp_stop(mb_trans_base_t *inst); -static mb_err_enum_t mbs_tcp_transp_receive(mb_trans_base_t *inst, uint8_t *rcv_addr, uint8_t **frame_ptr_buf, uint16_t *pbuf_len); -static mb_err_enum_t mbs_tcp_transp_send(mb_trans_base_t *inst, uint8_t _unused, const uint8_t *frame_ptr, uint16_t len); -static void mbs_tcp_transp_get_rcv_buf(mb_trans_base_t *inst, uint8_t **frame_ptr_buf); -static void mbs_tcp_transp_get_snd_buf(mb_trans_base_t *inst, uint8_t **frame_ptr_buf); +static mb_err_enum_t mbs_tcp_transp_receive(mb_trans_base_t *inst, uint8_t *rcv_addr, uint8_t **frame_buf, uint16_t *buf_len); +static mb_err_enum_t mbs_tcp_transp_send(mb_trans_base_t *inst, uint8_t _unused, const uint8_t *frame, uint16_t len); +static void mbs_tcp_transp_get_rcv_buf(mb_trans_base_t *inst, uint8_t **frame_buf); +static void mbs_tcp_transp_get_snd_buf(mb_trans_base_t *inst, uint8_t **frame_buf); bool mbs_tcp_transp_delete(mb_trans_base_t *inst); static bool mbs_tcp_transp_timer_expired(void *inst); @@ -119,16 +119,16 @@ static void mbs_tcp_transp_stop(mb_trans_base_t *inst) }; } -static mb_err_enum_t mbs_tcp_transp_receive(mb_trans_base_t *inst, uint8_t *rcv_addr, uint8_t **frame_ptr_buf, uint16_t *pbuf_len) +static mb_err_enum_t mbs_tcp_transp_receive(mb_trans_base_t *inst, uint8_t *rcv_addr, uint8_t **frame_buf, uint16_t *buf_len) { - if (!pbuf_len || !frame_ptr_buf || !pbuf_len) { + if (!buf_len || !frame_buf || !buf_len) { return MB_EIO; } mbs_tcp_transp_t *transp = __containerof(inst, mbs_tcp_transp_t, base); uint8_t *frame_ptr = (uint8_t *)transp->recv_buf; - uint16_t length = *pbuf_len; + uint16_t length = *buf_len; mb_err_enum_t status = MB_EIO; uint16_t pid; @@ -137,8 +137,8 @@ static mb_err_enum_t mbs_tcp_transp_receive(mb_trans_base_t *inst, uint8_t *rcv_ pid |= frame_ptr[MB_TCP_PID + 1]; if (pid == MB_TCP_PROTOCOL_ID) { - *frame_ptr_buf = &frame_ptr[MB_TCP_FUNC]; - *pbuf_len = length - MB_TCP_FUNC; + *frame_buf = &frame_ptr[MB_TCP_FUNC]; + *buf_len = length - MB_TCP_FUNC; status = MB_ENOERR; /* Get MBAP UID field if its support is enabled. @@ -156,10 +156,10 @@ static mb_err_enum_t mbs_tcp_transp_receive(mb_trans_base_t *inst, uint8_t *rcv_ return status; } -static mb_err_enum_t mbs_tcp_transp_send(mb_trans_base_t *inst, uint8_t _unused, const uint8_t *pframe, uint16_t len) +static mb_err_enum_t mbs_tcp_transp_send(mb_trans_base_t *inst, uint8_t _unused, const uint8_t *frame, uint16_t len) { mb_err_enum_t status = MB_ENOERR; - uint8_t *frame_ptr = (uint8_t *)pframe - MB_TCP_FUNC; + uint8_t *frame_ptr = (uint8_t *)frame - MB_TCP_FUNC; uint16_t tcp_len = len + MB_TCP_FUNC; /* The MBAP header is already initialized because the caller calls this @@ -212,19 +212,19 @@ static bool mbs_tcp_transp_timer_expired(void *inst) return need_poll; } -static void mbs_tcp_transp_get_rcv_buf(mb_trans_base_t *inst, uint8_t **frame_ptr_buf) +static void mbs_tcp_transp_get_rcv_buf(mb_trans_base_t *inst, uint8_t **frame_buf) { mbs_tcp_transp_t *transp = __containerof(inst, mbs_tcp_transp_t, base); CRITICAL_SECTION(inst->lock) { - *frame_ptr_buf = transp->recv_buf + MB_TCP_FUNC; + *frame_buf = transp->recv_buf + MB_TCP_FUNC; } } -static void mbs_tcp_transp_get_snd_buf(mb_trans_base_t *inst, uint8_t **frame_ptr_buf) +static void mbs_tcp_transp_get_snd_buf(mb_trans_base_t *inst, uint8_t **frame_buf) { mbs_tcp_transp_t *transp = __containerof(inst, mbs_tcp_transp_t, base); CRITICAL_SECTION(inst->lock) { - *frame_ptr_buf = transp->send_buf + MB_TCP_FUNC; + *frame_buf = transp->send_buf + MB_TCP_FUNC; } } diff --git a/modbus/mb_transports/transport_common.h b/modbus/mb_transports/transport_common.h index 02d7f61..4d62e27 100644 --- a/modbus/mb_transports/transport_common.h +++ b/modbus/mb_transports/transport_common.h @@ -14,14 +14,14 @@ extern "C" { #endif typedef struct mb_trans_base_t mb_trans_base_t; /*!< Type of moddus transport object */ -typedef struct _obj_descr obj_descr_t; +typedef struct obj_descr_s obj_descr_t; typedef void (*mb_frm_start_fp)(mb_trans_base_t *transport); typedef void (*mb_frm_stop_fp)(mb_trans_base_t *transport); -typedef mb_err_enum_t (*mb_frm_rcv_fp)(mb_trans_base_t *transport, uint8_t *rcv_addr_buf, uint8_t **frame_ptr_buf, uint16_t *len_buf); +typedef mb_err_enum_t (*mb_frm_rcv_fp)(mb_trans_base_t *transport, uint8_t *rcv_addr_buf, uint8_t **frame_buf, uint16_t *len_buf); typedef mb_err_enum_t (*mb_frm_snd_fp)(mb_trans_base_t *transport, uint8_t slv_addr, const uint8_t *frame_ptr, uint16_t len); -typedef void (*mb_get_rx_frm_fp) (mb_trans_base_t *transport, uint8_t **frame_ptr_buf); -typedef void (*mb_get_tx_frm_fp) (mb_trans_base_t *transport, uint8_t **frame_ptr_buf); +typedef void (*mb_get_rx_frm_fp) (mb_trans_base_t *transport, uint8_t **frame_buf); +typedef void (*mb_get_tx_frm_fp) (mb_trans_base_t *transport, uint8_t **frame_buf); typedef bool (*mb_get_fp)(mb_trans_base_t *inst); struct mb_trans_base_t diff --git a/test_apps/adapter_tests/main/CMakeLists.txt b/test_apps/adapter_tests/main/CMakeLists.txt index 04de324..d933967 100644 --- a/test_apps/adapter_tests/main/CMakeLists.txt +++ b/test_apps/adapter_tests/main/CMakeLists.txt @@ -1,3 +1,5 @@ +set(PROJECT_NAME "test_comm_adapter") + set(srcs "test_app_main.c" "test_modbus_adapter_serial.c" "test_modbus_adapter_tcp.c" @@ -10,3 +12,9 @@ idf_component_register(SRCS ${srcs} set_property(TARGET ${COMPONENT_LIB} APPEND PROPERTY INTERFACE_LINK_LIBRARIES "-u mb_test_include_adapter_impl_serial") set_property(TARGET ${COMPONENT_LIB} APPEND PROPERTY INTERFACE_LINK_LIBRARIES "-u mb_test_include_adapter_impl_tcp") + +# Workaround to avoid static analysis false positives for some components. +if(CONFIG_FMB_COMPILER_STATIC_ANALYZER_ENABLE AND CMAKE_C_COMPILER_ID STREQUAL "GNU") + target_compile_options(${COMPONENT_LIB} PRIVATE "-fanalyzer") + message(STATUS "Static analyzer build for ${PROJECT_NAME}.") +endif() \ No newline at end of file diff --git a/test_apps/cpp/modbus_serial_cpp_test/CMakeLists.txt b/test_apps/cpp/modbus_serial_cpp_test/CMakeLists.txt index 00fabb8..9e52921 100644 --- a/test_apps/cpp/modbus_serial_cpp_test/CMakeLists.txt +++ b/test_apps/cpp/modbus_serial_cpp_test/CMakeLists.txt @@ -2,5 +2,11 @@ # CMakeLists in this exact order for cmake to work correctly cmake_minimum_required(VERSION 3.5) +# The workaround to expliciply remove the component from dependency list. +# This should allow to avoid GNU static analizer warnings for the esp_http_server component. +set(EXCLUDE_COMPONENTS esp_http_server) + include($ENV{IDF_PATH}/tools/cmake/project.cmake) project(mb_serial_cpp) + + diff --git a/test_apps/cpp/modbus_serial_cpp_test/main/CMakeLists.txt b/test_apps/cpp/modbus_serial_cpp_test/main/CMakeLists.txt index fe56aae..30aa168 100644 --- a/test_apps/cpp/modbus_serial_cpp_test/main/CMakeLists.txt +++ b/test_apps/cpp/modbus_serial_cpp_test/main/CMakeLists.txt @@ -1,2 +1,12 @@ +set(PROJECT_NAME "mb_serial_cpp") + idf_component_register(SRCS "serial_test.cpp" - INCLUDE_DIRS ".") \ No newline at end of file + REQUIRES esp-modbus nvs_flash esp_event esp_timer lwip + INCLUDE_DIRS ".") + +# Workaround to avoid static analysis false positives for some components. +if(CONFIG_FMB_COMPILER_STATIC_ANALYZER_ENABLE AND CMAKE_C_COMPILER_ID STREQUAL "GNU") + target_compile_options(${COMPONENT_LIB} PRIVATE "-fanalyzer") + message(STATUS "Static analyzer build for ${PROJECT_NAME}.") +endif() + diff --git a/test_apps/cpp/modbus_serial_cpp_test/main/serial_test.cpp b/test_apps/cpp/modbus_serial_cpp_test/main/serial_test.cpp index df37ca0..7ec46dc 100644 --- a/test_apps/cpp/modbus_serial_cpp_test/main/serial_test.cpp +++ b/test_apps/cpp/modbus_serial_cpp_test/main/serial_test.cpp @@ -21,8 +21,8 @@ enum { #define STR(fieldname) ((const char*)( fieldname )) #define OPTS(min_val, max_val, step_val) { .opt1 = min_val, .opt2 = max_val, .opt3 = step_val } -static void *pmaster_handle = NULL; -static void *pslave_handle = NULL; +static void *pmaster_handle = nullptr; +static void *pslave_handle = nullptr; // Example Data (Object) Dictionary for Modbus parameters const mb_parameter_descriptor_t dummy_dict[] = { @@ -36,7 +36,7 @@ const mb_parameter_descriptor_t dummy_dict[] = { const uint16_t num_device_parameters = (sizeof(dummy_dict)/sizeof(dummy_dict[0])); // Modbus serial master initialization -static esp_err_t master_serial_init(void **pinst) +static esp_err_t master_serial_init(void **inst) { mb_communication_info_t comm; comm.ser_opts.port = (uart_port_t)TEST_PORT_NUM; @@ -48,24 +48,24 @@ static esp_err_t master_serial_init(void **pinst) comm.ser_opts.data_bits = UART_DATA_8_BITS; comm.ser_opts.stop_bits = UART_STOP_BITS_1; // Initialize Modbus controller - esp_err_t err = mbc_master_create_serial(&comm, pinst); - MB_RETURN_ON_FALSE((pinst != NULL), ESP_ERR_INVALID_STATE, TAG, + esp_err_t err = mbc_master_create_serial(&comm, inst); + MB_RETURN_ON_FALSE((inst), ESP_ERR_INVALID_STATE, TAG, "mbc master initialization fail."); MB_RETURN_ON_FALSE((err == ESP_OK), ESP_ERR_INVALID_STATE, TAG, "mbc master initialization fail, returns(0x%x).", (int)err); - err = mbc_master_set_descriptor(*pinst, &dummy_dict[0], num_device_parameters); + err = mbc_master_set_descriptor(*inst, &dummy_dict[0], num_device_parameters); MB_RETURN_ON_FALSE((err == ESP_OK), ESP_ERR_INVALID_STATE, TAG, "mbc master set descriptor fail, returns(0x%x).", (int)err); - err = mbc_master_start(*pinst); + err = mbc_master_start(*inst); MB_RETURN_ON_FALSE((err == ESP_OK), ESP_ERR_INVALID_STATE, TAG, "mbc master start fail, returned (0x%x).", (int)err); - const mb_parameter_descriptor_t *pdescriptor = NULL; - err = mbc_master_get_cid_info(*pinst, CID_DEV_REG0, &pdescriptor); - MB_RETURN_ON_FALSE(((err != ESP_ERR_NOT_FOUND) && (pdescriptor != NULL)), ESP_ERR_INVALID_STATE, TAG, + const mb_parameter_descriptor_t *descriptor = nullptr; + err = mbc_master_get_cid_info(*inst, CID_DEV_REG0, &descriptor); + MB_RETURN_ON_FALSE(((err != ESP_ERR_NOT_FOUND) && descriptor), ESP_ERR_INVALID_STATE, TAG, "mbc master get descriptor fail, returned (0x%x).", (int)err); uint16_t regs[] = {0x1111, 0x2222}; uint8_t type = 0; - err = mbc_master_get_parameter(*pinst, pdescriptor->cid, (uint8_t *)®s[0], &type); + err = mbc_master_get_parameter(*inst, descriptor->cid, (uint8_t *)®s[0], &type); MB_RETURN_ON_FALSE((err != ESP_ERR_INVALID_STATE), ESP_ERR_INVALID_STATE, TAG, "mbc master get parameter fail, returned (0x%x).", (int)err); ESP_LOGI(TAG, "Modbus master stack initialized..."); @@ -73,7 +73,7 @@ static esp_err_t master_serial_init(void **pinst) } // Modbus serial slave initialization -static esp_err_t slave_serial_init(void **pinst) +static esp_err_t slave_serial_init(void **inst) { mb_register_area_descriptor_t reg_area; mb_communication_info_t comm; @@ -86,8 +86,8 @@ static esp_err_t slave_serial_init(void **pinst) comm.ser_opts.data_bits = UART_DATA_8_BITS; comm.ser_opts.stop_bits = UART_STOP_BITS_1; // Initialize Modbus controller - esp_err_t err = mbc_slave_create_serial(&comm, pinst); - MB_RETURN_ON_FALSE((pinst != NULL), ESP_ERR_INVALID_STATE, TAG, + esp_err_t err = mbc_slave_create_serial(&comm, inst); + MB_RETURN_ON_FALSE(inst, ESP_ERR_INVALID_STATE, TAG, "mbc slave initialization fail."); MB_RETURN_ON_FALSE((err == ESP_OK), ESP_ERR_INVALID_STATE, TAG, "mbc slave initialization fail, returns(0x%x).", (int)err); @@ -97,45 +97,44 @@ static esp_err_t slave_serial_init(void **pinst) reg_area.address = (void*)&holding_regs[0]; reg_area.size = sizeof(holding_regs); reg_area.access = MB_ACCESS_RW; - ESP_ERROR_CHECK(mbc_slave_set_descriptor(*pinst, reg_area)); - err = mbc_slave_start(*pinst); + ESP_ERROR_CHECK(mbc_slave_set_descriptor(*inst, reg_area)); + err = mbc_slave_start(*inst); MB_RETURN_ON_FALSE((err == ESP_OK), ESP_ERR_INVALID_STATE, TAG, "mbc slave start fail, returned (0x%x).", (int)err); ESP_LOGI(TAG, "Modbus slave stack initialized..."); return err; } -mb_exception_t test_handler(void *pinst, uint8_t *frame_ptr, uint16_t *plen) +mb_exception_t test_handler(void *inst, uint8_t *frame_ptr, uint16_t *len) { return MB_EX_CRITICAL; // Set the exception code for slave appropriately } -static int check_custom_handlers(void *pinst) +static int check_custom_handlers(void *inst) { - mb_fn_handler_fp phandler = NULL; + mb_fn_handler_fp handler = nullptr; int entry; uint16_t count = 0; esp_err_t err = ESP_FAIL; - err = mbc_get_handler_count(pinst, &count); + err = mbc_get_handler_count(inst, &count); MB_RETURN_ON_FALSE((err == ESP_OK), 0, TAG, "mbc slave get handler count, returns(0x%x).", (int)err); - ESP_LOGI(TAG,"Object %p, custom handler test, (registered:max) handlers: %d:%d.", pinst, count, CONFIG_FMB_FUNC_HANDLERS_MAX); + ESP_LOGI(TAG,"Object %p, custom handler test, (registered:max) handlers: %d:%d.", inst, count, CONFIG_FMB_FUNC_HANDLERS_MAX); for (entry = 0x01; entry < CONFIG_FMB_FUNC_HANDLERS_MAX; entry++) { // Try to remove the handler - err = mbc_delete_handler(pinst, (uint8_t)entry); + err = mbc_delete_handler(inst, (uint8_t)entry); if (err != ESP_OK) { ESP_LOGE(TAG, "Could not remove handler for command: (0x%x), returned (0x%x), already empty?", entry, (int)err); } - err = mbc_set_handler(pinst, (uint8_t)entry, test_handler); + err = mbc_set_handler(inst, (uint8_t)entry, test_handler); if (err != ESP_OK) { ESP_LOGE(TAG,"Could not set handler for command 0x%x, returned (0x%x).", entry, (int)err); break; - } else { - ESP_LOGI(TAG,"Set handler for command 0x%x, returned (0x%x).", entry, (int)err); } - err = mbc_get_handler(pinst, (uint8_t)entry, &phandler); - if (err != ESP_OK || phandler != test_handler) { - ESP_LOGE(TAG, "Could not get handler for command (0x%x) = (%p), returned (0x%x).", entry, phandler, (int)err); + ESP_LOGI(TAG,"Set handler for command 0x%x, returned (0x%x).", entry, (int)err); + err = mbc_get_handler(inst, (uint8_t)entry, &handler); + if (err != ESP_OK || handler != test_handler) { + ESP_LOGE(TAG, "Could not get handler for command (0x%x) = (%p), returned (0x%x).", entry, handler, (int)err); break; } } diff --git a/test_apps/cpp/modbus_serial_cpp_test/sdkconfig.defaults b/test_apps/cpp/modbus_serial_cpp_test/sdkconfig.defaults index eee55f2..166ec8b 100644 --- a/test_apps/cpp/modbus_serial_cpp_test/sdkconfig.defaults +++ b/test_apps/cpp/modbus_serial_cpp_test/sdkconfig.defaults @@ -1,3 +1,4 @@ # General options for test CONFIG_HEAP_POISONING_COMPREHENSIVE=y CONFIG_HEAP_TRACING_OFF=y + diff --git a/test_apps/physical_tests/main/CMakeLists.txt b/test_apps/physical_tests/main/CMakeLists.txt index fa9a219..e1b62d3 100644 --- a/test_apps/physical_tests/main/CMakeLists.txt +++ b/test_apps/physical_tests/main/CMakeLists.txt @@ -1,3 +1,5 @@ +set(PROJECT_NAME "test_modbus_comm_multi_dev") + set(srcs "test_app_main.c" "test_modbus_rs485_comm_master_slave.c" "test_modbus_tcp_comm_master_slave.c" @@ -12,3 +14,8 @@ idf_component_register(SRCS ${srcs} set_property(TARGET ${COMPONENT_LIB} APPEND PROPERTY INTERFACE_LINK_LIBRARIES "-u mb_test_include_phys_impl_tcp") set_property(TARGET ${COMPONENT_LIB} APPEND PROPERTY INTERFACE_LINK_LIBRARIES "-u mb_test_include_phys_impl_serial") +# Workaround to avoid static analysis false positives for some components. +if(CONFIG_FMB_COMPILER_STATIC_ANALYZER_ENABLE AND CMAKE_C_COMPILER_ID STREQUAL "GNU") + target_compile_options(${COMPONENT_LIB} PRIVATE "-fanalyzer") + message(STATUS "Static analyzer build for ${PROJECT_NAME}.") +endif() \ No newline at end of file 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 61f1cf6..40994b6 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 @@ -64,7 +64,7 @@ const char *slave_tcp_addr_table[] = { NULL // End of table condition (must be included) }; -static esp_err_t test_tcp_services_init(void **pnetif) +static esp_err_t test_tcp_services_init(void **netif) { esp_err_t result = nvs_flash_init(); if ((result == ESP_ERR_NVS_NO_FREE_PAGES) || (result == ESP_ERR_NVS_NEW_VERSION_FOUND)) { @@ -106,8 +106,8 @@ static esp_err_t test_tcp_services_init(void **pnetif) // "esp_wifi_set_ps fail, returns(0x%x).", // (int)result); #endif - if (pnetif) { - *pnetif = get_example_netif(); + if (netif) { + *netif = get_example_netif(); } return ESP_OK; } @@ -146,9 +146,9 @@ static esp_err_t test_tcp_services_destroy(void) static void test_modbus_tcp_slave(void) { - void *pnetif = NULL; - TEST_ASSERT_TRUE(test_tcp_services_init(&pnetif) == ESP_OK); - TEST_ASSERT_NOT_NULL(pnetif); + void *netif = NULL; + TEST_ASSERT_TRUE(test_tcp_services_init(&netif) == ESP_OK); + TEST_ASSERT_NOT_NULL(netif); test_common_start(); mb_communication_info_t tcp_slave_cfg_1 = { @@ -160,7 +160,7 @@ static void test_modbus_tcp_slave(void) .tcp_opts.start_disconnected = true, .tcp_opts.response_tout_ms = 1, .tcp_opts.test_tout_us = TEST_TCP_SLAVE_SEND_TOUT_US, - .tcp_opts.ip_netif_ptr = pnetif + .tcp_opts.ip_netif_ptr = netif }; TEST_ASSERT_NOT_NULL(test_common_slave_tcp_create(&tcp_slave_cfg_1, 0)); @@ -176,7 +176,7 @@ static void test_modbus_tcp_slave(void) .tcp_opts.start_disconnected = true, .tcp_opts.response_tout_ms = 1, .tcp_opts.test_tout_us = TEST_TCP_SLAVE_SEND_TOUT_US, - .tcp_opts.ip_netif_ptr = pnetif + .tcp_opts.ip_netif_ptr = netif }; TEST_ASSERT_NOT_NULL(test_common_slave_tcp_create(&tcp_slave_cfg_2, 0)); @@ -198,9 +198,9 @@ static void test_modbus_tcp_slave(void) 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); + void *netif = NULL; + TEST_ASSERT_TRUE(test_tcp_services_init(&netif) == ESP_OK); + TEST_ASSERT_NOT_NULL(netif); test_common_start(); @@ -218,7 +218,7 @@ static void test_modbus_tcp_master(void) .tcp_opts.start_disconnected = false, .tcp_opts.response_tout_ms = TEST_MASTER_RESPOND_TOUT_MS, .tcp_opts.test_tout_us = TEST_TCP_MASTER_SEND_TOUT_US, - .tcp_opts.ip_netif_ptr = pnetif + .tcp_opts.ip_netif_ptr = netif }; TEST_ASSERT_NOT_NULL(test_common_master_tcp_create(&tcp_master_cfg_1, 0, &descriptors[0], num_descriptors)); diff --git a/test_apps/test_common/include/test_common.h b/test_apps/test_common/include/test_common.h index c0d99f6..2d3d6ab 100644 --- a/test_apps/test_common/include/test_common.h +++ b/test_apps/test_common/include/test_common.h @@ -66,9 +66,9 @@ void test_common_stop(); // TaskHandle_t test_common_slave_serial_create(mb_communication_info_t *pconfig); TaskHandle_t test_common_slave_serial_create(mb_communication_info_t *pconfig, uint32_t priority); -TaskHandle_t test_common_master_serial_create(mb_communication_info_t *pconfig,uint32_t priority, const mb_parameter_descriptor_t *pdescr, uint16_t descr_size); +TaskHandle_t test_common_master_serial_create(mb_communication_info_t *pconfig,uint32_t priority, const mb_parameter_descriptor_t *descr, uint16_t descr_size); TaskHandle_t test_common_slave_tcp_create(mb_communication_info_t *pconfig, uint32_t priority); -TaskHandle_t test_common_master_tcp_create(mb_communication_info_t *pconfig, uint32_t priority, const mb_parameter_descriptor_t *pdescr, uint16_t descr_size); +TaskHandle_t test_common_master_tcp_create(mb_communication_info_t *pconfig, uint32_t priority, const mb_parameter_descriptor_t *descr, uint16_t descr_size); TaskHandle_t test_common_start_busy_task(uint32_t priority); /** diff --git a/test_apps/test_common/mb_utest_lib/port_adapter.c b/test_apps/test_common/mb_utest_lib/port_adapter.c index 7c78d36..e80441f 100644 --- a/test_apps/test_common/mb_utest_lib/port_adapter.c +++ b/test_apps/test_common/mb_utest_lib/port_adapter.c @@ -112,42 +112,42 @@ void mb_port_adapter_set_response_time(mb_port_base_t *inst, uint64_t resp_time) atomic_store(&(port_obj->test_timeout_us), resp_time); } -int mb_port_adapter_get_rx_buffer(mb_port_base_t *inst, uint8_t **ppfame, int *plen) +int mb_port_adapter_get_rx_buffer(mb_port_base_t *inst, uint8_t **frame_ptr, int *len) { - MB_RETURN_ON_FALSE((ppfame && plen), -1, TAG, "mb serial get buffer failure."); + MB_RETURN_ON_FALSE((frame_ptr && len), -1, TAG, "mb serial get buffer failure."); mb_port_adapter_t *port_obj = __containerof(inst, mb_port_adapter_t, base); int sz = port_obj->recv_length; - if (*ppfame && *plen >= port_obj->recv_length) + if (*frame_ptr && *len >= port_obj->recv_length) { CRITICAL_SECTION(inst->lock) { - memcpy(*ppfame, port_obj->rx_buffer, sz); + memcpy(*frame_ptr, port_obj->rx_buffer, sz); } } else { - *ppfame = port_obj->rx_buffer; - *plen = sz; + *frame_ptr = port_obj->rx_buffer; + *len = sz; } return sz; } -int mb_port_adapter_get_tx_buffer(mb_port_base_t *inst, uint8_t **ppfame, int *plen) +int mb_port_adapter_get_tx_buffer(mb_port_base_t *inst, uint8_t **frame_ptr, int *len) { - MB_RETURN_ON_FALSE((ppfame && plen), -1, TAG, "mb serial get buffer failure."); + MB_RETURN_ON_FALSE((frame_ptr && len), -1, TAG, "mb serial get buffer failure."); mb_port_adapter_t *port_obj = __containerof(inst, mb_port_adapter_t, base); int sz = port_obj->recv_length; - if (*ppfame && *plen >= port_obj->recv_length) + if (*frame_ptr && *len >= port_obj->recv_length) { CRITICAL_SECTION(inst->lock) { - memcpy(*ppfame, port_obj->rx_buffer, sz); + memcpy(*frame_ptr, port_obj->rx_buffer, sz); } } else { - *ppfame = port_obj->rx_buffer; - *plen = sz; + *frame_ptr = port_obj->rx_buffer; + *len = sz; } return sz; } @@ -216,7 +216,7 @@ bool mb_port_adapter_is_connected(void *inst) return false; } -static void mb_port_adapter_conn_logic(void *inst, mb_uid_info_t *paddr_info) +static void mb_port_adapter_conn_logic(void *inst, mb_uid_info_t *addr_info) { bool slave_found = false; mb_port_adapter_t *slave = NULL; @@ -224,15 +224,15 @@ static void mb_port_adapter_conn_logic(void *inst, mb_uid_info_t *paddr_info) if (port_obj->base.descr.is_master) { // master object LIST_FOREACH(slave, &s_port_list, entries) { - if ((paddr_info->uid == slave->addr_info.uid) + if ((addr_info->uid == slave->addr_info.uid) && !slave->base.descr.is_master - && (paddr_info->port == slave->addr_info.port)) { + && (addr_info->port == slave->addr_info.port)) { // Register each slave object ESP_LOGD(TAG, "Check connection state of object #%d(%s), uid: %d, port: %d, %s", - paddr_info->index, paddr_info->node_name_str, - paddr_info->uid, paddr_info->port, - (paddr_info->state == MB_SOCK_STATE_CONNECTED) ? "CONNECTED" : "DISCONNECTED"); - if ((paddr_info->state != MB_SOCK_STATE_CONNECTED) || (paddr_info->inst != inst)) { + addr_info->index, addr_info->node_name_str, + addr_info->uid, addr_info->port, + (addr_info->state == MB_SOCK_STATE_CONNECTED) ? "CONNECTED" : "DISCONNECTED"); + if ((addr_info->state != MB_SOCK_STATE_CONNECTED) || (addr_info->inst != inst)) { (void)xQueueSend(slave->conn_queue, &port_obj->addr_info, MB_ADAPTER_QUEUE_TIMEOUT); } else { mb_port_adapter_set_flag(inst, MB_QUEUE_FLAG_CONNECTED); @@ -244,19 +244,19 @@ static void mb_port_adapter_conn_logic(void *inst, mb_uid_info_t *paddr_info) if (!slave_found) { // reactivate the connection set ESP_LOGE(TAG, "Slave #%d(%s), uid: %d, port: %d is not found, reconnect.", - paddr_info->index, paddr_info->node_name_str, paddr_info->uid, paddr_info->port); - (void)xQueueSend(port_obj->conn_queue, paddr_info, MB_ADAPTER_QUEUE_TIMEOUT); + addr_info->index, addr_info->node_name_str, addr_info->uid, addr_info->port); + (void)xQueueSend(port_obj->conn_queue, addr_info, MB_ADAPTER_QUEUE_TIMEOUT); vTaskDelay(MB_ADAPTER_CONN_TIMEOUT); } } else { // slave connection logic ESP_LOGD(TAG, "Register connection in adapter object #%d(%s), uid: %d, port: %d, to master %s", port_obj->addr_info.index, port_obj->addr_info.node_name_str, - port_obj->addr_info.uid, port_obj->addr_info.port, paddr_info->node_name_str); + port_obj->addr_info.uid, port_obj->addr_info.port, addr_info->node_name_str); // Mimic connection logic for each slave here //mb_port_adapter_slave_connect(it); port_obj->addr_info.state = MB_SOCK_STATE_CONNECTED; - mb_port_adapter_t *master = (mb_port_adapter_t *)(paddr_info->inst); - port_obj->addr_info.inst = paddr_info->inst; // link slave with master + mb_port_adapter_t *master = (mb_port_adapter_t *)(addr_info->inst); + port_obj->addr_info.inst = addr_info->inst; // link slave with master (void)xQueueSend(master->conn_queue, &port_obj->addr_info, MB_ADAPTER_QUEUE_TIMEOUT); } } @@ -297,11 +297,11 @@ static void mb_port_adapter_task(void *p_args) vTaskDelete(NULL); } -static mb_err_enum_t mb_port_adapter_connect(mb_tcp_opts_t *tcp_opts, void *pobject) +static mb_err_enum_t mb_port_adapter_connect(mb_tcp_opts_t *tcp_opts, void *object) { char **paddr_table = tcp_opts->ip_addr_table; mb_uid_info_t uid_info; - mb_port_adapter_t *port_obj = __containerof(pobject, mb_port_adapter_t, base); + mb_port_adapter_t *port_obj = __containerof(object, mb_port_adapter_t, base); MB_RETURN_ON_FALSE((paddr_table && *paddr_table && (tcp_opts->mode == MB_TCP)), MB_EINVAL, TAG, @@ -325,7 +325,7 @@ static mb_err_enum_t mb_port_adapter_connect(mb_tcp_opts_t *tcp_opts, void *pobj }; // Mimic connection event if (!tcp_opts->start_disconnected) { - uint16_t event = mb_port_adapter_wait_flag(pobject, MB_QUEUE_FLAG_CONNECTED, MB_ADAPTER_CONN_TIMEOUT); + uint16_t event = mb_port_adapter_wait_flag(object, MB_QUEUE_FLAG_CONNECTED, MB_ADAPTER_CONN_TIMEOUT); if (!event) { ESP_LOGE(TAG, "Could not connect to slave %s during timeout.", (char *)*paddr_table); } @@ -341,34 +341,34 @@ static mb_err_enum_t mb_port_adapter_connect(mb_tcp_opts_t *tcp_opts, void *pobj return count ? MB_ENOERR : MB_EINVAL; } -mb_err_enum_t mb_port_adapter_create(mb_uid_info_t *paddr_info, mb_port_base_t **in_out_obj) +mb_err_enum_t mb_port_adapter_create(mb_uid_info_t *addr_info, mb_port_base_t **in_out_obj) { - mb_port_adapter_t *padapter = NULL; + mb_port_adapter_t *adapter_obj = NULL; mb_err_enum_t ret = MB_EILLSTATE; - padapter = (mb_port_adapter_t *)calloc(1, sizeof(mb_port_adapter_t)); + adapter_obj = (mb_port_adapter_t *)calloc(1, sizeof(mb_port_adapter_t)); - MB_GOTO_ON_FALSE((padapter && paddr_info && in_out_obj), MB_EILLSTATE, error, TAG, "mb serial port creation error."); + MB_GOTO_ON_FALSE((adapter_obj && addr_info && in_out_obj), MB_EILLSTATE, error, TAG, "mb serial port creation error."); - CRITICAL_SECTION_INIT(padapter->base.lock); - padapter->base.descr = ((mb_port_base_t *)*in_out_obj)->descr; - padapter->addr_info = *paddr_info; + CRITICAL_SECTION_INIT(adapter_obj->base.lock); + adapter_obj->base.descr = ((mb_port_base_t *)*in_out_obj)->descr; + adapter_obj->addr_info = *addr_info; esp_timer_create_args_t timer_conf = { .callback = mb_port_adapter_timer_cb, - .arg = padapter, + .arg = adapter_obj, .dispatch_method = ESP_TIMER_TASK, - .name = padapter->base.descr.parent_name + .name = adapter_obj->base.descr.parent_name }; // Create Modbus timer handlers for streams - MB_GOTO_ON_ERROR(esp_timer_create(&timer_conf, &padapter->timer_handle), + MB_GOTO_ON_ERROR(esp_timer_create(&timer_conf, &adapter_obj->timer_handle), error, TAG, "create input stream timer failed."); - padapter->rx_queue = queue_create(MB_ADAPTER_RX_QUEUE_MAX_SIZE); - MB_GOTO_ON_FALSE(padapter->rx_queue, MB_EILLSTATE, error, TAG, "create rx queue failed"); - padapter->tx_queue = queue_create(MB_ADAPTER_TX_QUEUE_MAX_SIZE); - MB_GOTO_ON_FALSE(padapter->tx_queue, MB_EILLSTATE, error, TAG, "create tx queue failed"); - padapter->event_group_handle = xEventGroupCreate(); - MB_GOTO_ON_FALSE((padapter->event_group_handle), MB_EILLSTATE, error, TAG, + adapter_obj->rx_queue = queue_create(MB_ADAPTER_RX_QUEUE_MAX_SIZE); + MB_GOTO_ON_FALSE(adapter_obj->rx_queue, MB_EILLSTATE, error, TAG, "create rx queue failed"); + adapter_obj->tx_queue = queue_create(MB_ADAPTER_TX_QUEUE_MAX_SIZE); + MB_GOTO_ON_FALSE(adapter_obj->tx_queue, MB_EILLSTATE, error, TAG, "create tx queue failed"); + adapter_obj->event_group_handle = xEventGroupCreate(); + MB_GOTO_ON_FALSE((adapter_obj->event_group_handle), MB_EILLSTATE, error, TAG, "%p, event group create error.", *in_out_obj); if (!s_port_list_counter) @@ -376,7 +376,7 @@ mb_err_enum_t mb_port_adapter_create(mb_uid_info_t *paddr_info, mb_port_base_t * // Create a task to handle UART events BaseType_t status = xTaskCreatePinnedToCore(mb_port_adapter_task, "adapt_rx_task", MB_ADAPTER_TASK_STACK_SIZE, - &padapter->base, CONFIG_FMB_PORT_TASK_PRIO, + &adapter_obj->base, CONFIG_FMB_PORT_TASK_PRIO, &adapter_task_handle, CONFIG_FMB_PORT_TASK_AFFINITY); // Force exit from function with failure MB_GOTO_ON_FALSE((status == pdPASS), MB_EILLSTATE, error, TAG, @@ -386,41 +386,41 @@ mb_err_enum_t mb_port_adapter_create(mb_uid_info_t *paddr_info, mb_port_base_t * MB_GOTO_ON_FALSE((queue_set), MB_EILLSTATE, error, TAG, "can not create queue set."); } // Add connection set for master object only - padapter->conn_queue = xQueueCreate(MB_ADAPTER_MAX_PORTS, sizeof(mb_uid_info_t)); - MB_GOTO_ON_FALSE(padapter->conn_queue, MB_EILLSTATE, error, TAG, "create conn queue failed"); - MB_GOTO_ON_FALSE((queue_set && xQueueAddToSet(padapter->conn_queue, queue_set)), + adapter_obj->conn_queue = xQueueCreate(MB_ADAPTER_MAX_PORTS, sizeof(mb_uid_info_t)); + MB_GOTO_ON_FALSE(adapter_obj->conn_queue, MB_EILLSTATE, error, TAG, "create conn queue failed"); + MB_GOTO_ON_FALSE((queue_set && xQueueAddToSet(adapter_obj->conn_queue, queue_set)), MB_EILLSTATE, error, TAG, "can not add conn queue to queue set."); // Add rx queue to set - MB_GOTO_ON_FALSE((queue_set && xQueueAddToSet(padapter->rx_queue, queue_set)), + MB_GOTO_ON_FALSE((queue_set && xQueueAddToSet(adapter_obj->rx_queue, queue_set)), MB_EILLSTATE, error, TAG, "can not add rx queue to queue set."); MB_GOTO_ON_FALSE((s_port_list_counter <= MB_ADAPTER_MAX_PORTS), MB_EILLSTATE, error, TAG, "adapter exceeded maximum number of ports = %d", MB_ADAPTER_MAX_PORTS); // register new port instance in the list - LIST_INSERT_HEAD(&s_port_list, padapter, entries); + LIST_INSERT_HEAD(&s_port_list, adapter_obj, entries); s_port_list_counter++; - char *pstr; - int res = asprintf(&pstr, "%d;%s;%u", (unsigned)paddr_info->uid, - padapter->base.descr.parent_name, (unsigned)paddr_info->port); + char *string_ptr; + int res = asprintf(&string_ptr, "%d;%s;%u", (unsigned)addr_info->uid, + adapter_obj->base.descr.parent_name, (unsigned)addr_info->port); MB_GOTO_ON_FALSE((res), MB_EILLSTATE, error, TAG, "object adress info alloc fail, err: %d", (int)res); - padapter->base.cb.tmr_expired = mb_port_adapter_timer_expired; - padapter->base.cb.tx_empty = NULL; - padapter->base.cb.byte_rcvd = NULL; - padapter->base.arg = (void *)padapter; + adapter_obj->base.cb.tmr_expired = mb_port_adapter_timer_expired; + adapter_obj->base.cb.tx_empty = NULL; + adapter_obj->base.cb.byte_rcvd = NULL; + adapter_obj->base.arg = (void *)adapter_obj; - padapter->addr_info.state = MB_SOCK_STATE_CONNECTING; - padapter->addr_info.inst = padapter; - padapter->addr_info.node_name_str = pstr; - padapter->addr_info.ip_addr_str = pstr; - *in_out_obj = &(padapter->base); - ESP_LOGD(TAG, "created object @%p, from parent %p", padapter, padapter->base.descr.parent); + adapter_obj->addr_info.state = MB_SOCK_STATE_CONNECTING; + adapter_obj->addr_info.inst = adapter_obj; + adapter_obj->addr_info.node_name_str = string_ptr; + adapter_obj->addr_info.ip_addr_str = string_ptr; + *in_out_obj = &(adapter_obj->base); + ESP_LOGD(TAG, "created object @%p, from parent %p", adapter_obj, adapter_obj->base.descr.parent); return MB_ENOERR; error: - if (padapter) { - mb_port_adapter_delete(&padapter->base); + if (adapter_obj) { + mb_port_adapter_delete(&adapter_obj->base); } return ret; } @@ -437,26 +437,26 @@ mb_err_enum_t mb_port_adapter_tcp_create(mb_tcp_opts_t *tcp_opts, mb_port_base_t .state = MB_SOCK_STATE_UNDEF }; - mb_port_base_t *pobj = *in_out_obj; - mb_err_enum_t ret = mb_port_adapter_create(&addr_info, &pobj); + mb_port_base_t *obj = *in_out_obj; + mb_err_enum_t ret = mb_port_adapter_create(&addr_info, &obj); - if ((ret == MB_ENOERR) && pobj) { + if ((ret == MB_ENOERR) && obj) { // Parse master config and register dependent objects - if (pobj->descr.is_master) { - ESP_LOGI(TAG, "Parsing of config for %s", pobj->descr.parent_name); - ret |= mb_port_adapter_connect(tcp_opts, pobj); + if (obj->descr.is_master) { + ESP_LOGI(TAG, "Parsing of config for %s", obj->descr.parent_name); + ret |= mb_port_adapter_connect(tcp_opts, obj); MB_GOTO_ON_FALSE((ret == MB_ENOERR), MB_EILLSTATE, error, TAG, - "%s, could not parse config, err=%x.", pobj->descr.parent_name, (int)ret); + "%s, could not parse config, err=%x.", obj->descr.parent_name, (int)ret); } - ESP_LOGD(TAG, "%s, set test time to %" PRIu64, pobj->descr.parent_name, tcp_opts->test_tout_us); - mb_port_adapter_set_response_time(pobj, (tcp_opts->test_tout_us)); + ESP_LOGD(TAG, "%s, set test time to %" PRIu64, obj->descr.parent_name, tcp_opts->test_tout_us); + mb_port_adapter_set_response_time(obj, (tcp_opts->test_tout_us)); } - *in_out_obj = pobj; + *in_out_obj = obj; return ret; error: - if (pobj) { - mb_port_adapter_delete(pobj); + if (obj) { + mb_port_adapter_delete(obj); } return ret; } @@ -476,12 +476,12 @@ mb_err_enum_t mb_port_adapter_ser_create(mb_serial_opts_t *ser_opts, mb_port_bas .state = MB_SOCK_STATE_UNDEF }; - mb_port_base_t *pobj = *in_out_obj; - mb_err_enum_t ret = mb_port_adapter_create(&addr_info, &pobj); - if ((ret == MB_ENOERR) && pobj) { - ESP_LOGD(TAG, "%s, set test time to %d", pobj->descr.parent_name, (int)(ser_opts->test_tout_us)); - mb_port_adapter_set_response_time(pobj, (ser_opts->test_tout_us)); - *in_out_obj = pobj; + mb_port_base_t *obj = *in_out_obj; + mb_err_enum_t ret = mb_port_adapter_create(&addr_info, &obj); + if ((ret == MB_ENOERR) && obj) { + ESP_LOGD(TAG, "%s, set test time to %d", obj->descr.parent_name, (int)(ser_opts->test_tout_us)); + mb_port_adapter_set_response_time(obj, (ser_opts->test_tout_us)); + *in_out_obj = obj; } return ret; } @@ -565,47 +565,44 @@ static esp_err_t mb_port_adapter_set_timer(mb_port_base_t *inst, uint64_t time_d return ESP_OK; } -bool mb_port_adapter_recv_data(mb_port_base_t *inst, uint8_t **ppframe, uint16_t *plength) +bool mb_port_adapter_recv_data(mb_port_base_t *inst, uint8_t **frame_ptr, uint16_t *len_ptr) { - MB_RETURN_ON_FALSE((ppframe && plength), false, TAG, "mb serial get buffer failure."); + MB_RETURN_ON_FALSE((frame_ptr && len_ptr), false, TAG, "mb serial get buffer failure."); mb_port_adapter_t *port_obj = __containerof(inst, mb_port_adapter_t, base); - int length = *plength ? *plength : port_obj->recv_length; + int rx_len = *len_ptr ? *len_ptr : port_obj->recv_length; + bool ret = false; - if (length) - { + if (rx_len) { CRITICAL_SECTION_LOCK(inst->lock); - int length = queue_pop(port_obj->rx_queue, &port_obj->rx_buffer[0], CONFIG_FMB_BUFFER_SIZE, NULL); - if (length) - { + rx_len = queue_pop(port_obj->rx_queue, &port_obj->rx_buffer[0], CONFIG_FMB_BUFFER_SIZE, NULL); + if (rx_len) { mb_port_timer_disable(inst); - ESP_LOGD(TAG, "%s, received data: %d bytes.", inst->descr.parent_name, length); + ESP_LOGD(TAG, "%s, received data: %d bytes.", inst->descr.parent_name, rx_len); // Stop timer because the new data is received // Store the timestamp of received frame port_obj->recv_time_stamp = esp_timer_get_time(); - *ppframe = &port_obj->rx_buffer[0]; - ESP_LOG_BUFFER_HEX_LEVEL(MB_STR_CAT(inst->descr.parent_name, ":PORT_RECV"), - (void *)&port_obj->rx_buffer[0], (uint16_t)length, ESP_LOG_DEBUG); + *frame_ptr = &port_obj->rx_buffer[0]; + MB_PRT_BUF(inst->descr.parent_name, ":PORT_RECV", + &port_obj->rx_buffer[0], rx_len, ESP_LOG_DEBUG); } CRITICAL_SECTION_UNLOCK(inst->lock); + *len_ptr = rx_len; + ret = true; + } else { + ESP_LOGE(TAG, "%s: junk data (%d bytes) received. ", inst->descr.parent_name, rx_len); } - else - { - ESP_LOGE(TAG, "%s: junk data (%d bytes) received. ", inst->descr.parent_name, length); - } - *plength = length; - return true; + return ret; } -bool mb_port_adapter_send_data(mb_port_base_t *inst, uint8_t address, uint8_t *pframe, uint16_t length) +bool mb_port_adapter_send_data(mb_port_base_t *inst, uint8_t addrets, uint8_t *frame_ptr, uint16_t length) { - bool res = false; + bool ret = false; mb_port_adapter_t *port_obj = __containerof(inst, mb_port_adapter_t, base); uint64_t time_diff = atomic_load(&port_obj->test_timeout_us); - if (pframe && length) - { + if (frame_ptr && length) { CRITICAL_SECTION_LOCK(inst->lock); - esp_err_t err = queue_push(port_obj->tx_queue, (void *)pframe, length, NULL); + esp_err_t err = queue_push(port_obj->tx_queue, (void *)frame_ptr, length, NULL); CRITICAL_SECTION_UNLOCK(inst->lock); MB_RETURN_ON_FALSE((err == ESP_OK), false, TAG, "%s, could not send the data into queue.", inst->descr.parent_name); @@ -615,18 +612,17 @@ bool mb_port_adapter_send_data(mb_port_base_t *inst, uint8_t address, uint8_t *p uint16_t flags = mb_port_adapter_wait_flag(inst, MB_QUEUE_FLAG_SENT, MB_EVENT_QUEUE_TIMEOUT_MAX); port_obj->send_time_stamp = esp_timer_get_time(); // Print sent packet, the tag used is more clear to see - ESP_LOG_BUFFER_HEX_LEVEL(MB_STR_CAT(inst->descr.parent_name, ":PORT_SEND"), - (void *)pframe, length, ESP_LOG_DEBUG); + MB_PRT_BUF(inst->descr.parent_name, ":PORT_SEND", frame_ptr, length, ESP_LOG_DEBUG); (void)mb_port_event_post(inst, EVENT(EV_FRAME_SENT)); ESP_LOGD(TAG, "%s, tx completed, flags = 0x%04x.", inst->descr.parent_name, (int)flags); - res = true; + ret = true; } else { - ESP_LOGE(TAG, "send callback %p, %u. ", pframe, (unsigned)length); + ESP_LOGE(TAG, "send callback %p, %u. ", frame_ptr, (unsigned)length); } - return res; + return ret; } void mb_port_adapter_enable(mb_port_base_t *inst) diff --git a/test_apps/test_common/mb_utest_lib/port_adapter.h b/test_apps/test_common/mb_utest_lib/port_adapter.h index e1a7c33..8181863 100644 --- a/test_apps/test_common/mb_utest_lib/port_adapter.h +++ b/test_apps/test_common/mb_utest_lib/port_adapter.h @@ -24,7 +24,7 @@ typedef enum #define MB_QUEUE_FLAGS (MB_QUEUE_FLAG_SENT | MB_QUEUE_FLAG_RECV | MB_QUEUE_FLAG_CONNECTED) -typedef struct _uid_info mb_uid_info_t; +typedef struct uid_info_s mb_uid_info_t; #if (CONFIG_FMB_COMM_MODE_ASCII_EN || CONFIG_FMB_COMM_MODE_RTU_EN) mb_err_enum_t mb_port_adapter_ser_create(mb_serial_opts_t *ser_opts, mb_port_base_t **in_out_obj); @@ -36,10 +36,10 @@ mb_err_enum_t mb_port_adapter_tcp_create(mb_tcp_opts_t *tcp_opts, mb_port_base_t void mb_port_adapter_delete(mb_port_base_t *inst); void mb_port_adapter_set_response_time(mb_port_base_t *inst, uint64_t resp_time); -int mb_port_adapter_get_rx_buffer(mb_port_base_t *inst, uint8_t **ppfame, int *plength); +int mb_port_adapter_get_rx_buffer(mb_port_base_t *inst, uint8_t **ppfame, int *length); -bool mb_port_adapter_send_data(mb_port_base_t *inst, uint8_t address, uint8_t *pframe, uint16_t length); -bool mb_port_adapter_recv_data(mb_port_base_t *inst, uint8_t **ppframe, uint16_t *plength); +bool mb_port_adapter_send_data(mb_port_base_t *inst, uint8_t address, uint8_t *frame, uint16_t length); +bool mb_port_adapter_recv_data(mb_port_base_t *inst, uint8_t **frame, uint16_t *length); void mb_port_adapter_enable(mb_port_base_t *inst); void mb_port_adapter_disable(mb_port_base_t *inst); void mb_port_adapter_tcp_set_conn_cb(mb_port_base_t *inst, void *conn_fp, void *arg); diff --git a/test_apps/test_common/mb_utest_lib/port_stubs.c b/test_apps/test_common/mb_utest_lib/port_stubs.c index 9e11570..2ff333a 100644 --- a/test_apps/test_common/mb_utest_lib/port_stubs.c +++ b/test_apps/test_common/mb_utest_lib/port_stubs.c @@ -49,14 +49,14 @@ void __wrap_mb_port_ser_delete(mb_port_base_t *inst) mb_port_adapter_delete(inst); } -bool __wrap_mb_port_ser_recv_data(mb_port_base_t *inst, uint8_t **ppframe, uint16_t *plength) +bool __wrap_mb_port_ser_recv_data(mb_port_base_t *inst, uint8_t **frame, uint16_t *length) { - return mb_port_adapter_recv_data(inst, ppframe, plength); + return mb_port_adapter_recv_data(inst, frame, length); } -bool __wrap_mb_port_ser_send_data(mb_port_base_t *inst, uint8_t *pframe, uint16_t length) +bool __wrap_mb_port_ser_send_data(mb_port_base_t *inst, uint8_t *frame, uint16_t length) { - return mb_port_adapter_send_data(inst, 0, pframe, length); + return mb_port_adapter_send_data(inst, 0, frame, length); } void __wrap_mb_port_ser_enable(mb_port_base_t *inst) @@ -72,10 +72,10 @@ void __wrap_mb_port_ser_disable(mb_port_base_t *inst) #endif IRAM_ATTR -bool __wrap_mb_port_event_get(mb_port_base_t *inst, mb_event_t *pevent) +bool __wrap_mb_port_event_get(mb_port_base_t *inst, mb_event_t *event) { - bool result = __real_mb_port_event_get(inst, pevent); - ESP_LOGD(TAG, "%s, get event:%x.", inst->descr.parent_name, pevent->event); + bool result = __real_mb_port_event_get(inst, event); + ESP_LOGD(TAG, "%s, get event:%x.", inst->descr.parent_name, event->event); return result; } @@ -95,14 +95,14 @@ mb_err_enum_t __wrap_mbm_port_tcp_create(mb_tcp_opts_t *tcp_opts, mb_port_base_t return mb_port_adapter_tcp_create(tcp_opts, in_out_obj); } -bool __wrap_mbm_port_tcp_recv_data(mb_port_base_t *inst, uint8_t **ppframe, uint16_t *plength) +bool __wrap_mbm_port_tcp_recv_data(mb_port_base_t *inst, uint8_t **frame, uint16_t *length) { - return mb_port_adapter_recv_data(inst, ppframe, plength); + return mb_port_adapter_recv_data(inst, frame, length); } -bool __wrap_mbm_port_tcp_send_data(mb_port_base_t *inst, uint8_t address, uint8_t *pframe, uint16_t length) +bool __wrap_mbm_port_tcp_send_data(mb_port_base_t *inst, uint8_t address, uint8_t *frame, uint16_t length) { - return mb_port_adapter_send_data(inst, address, pframe, length); + return mb_port_adapter_send_data(inst, address, frame, length); } void __wrap_mbm_port_tcp_delete(mb_port_base_t *inst) @@ -140,14 +140,14 @@ mb_err_enum_t __wrap_mbs_port_tcp_create(mb_tcp_opts_t *tcp_opts, mb_port_base_t return mb_port_adapter_tcp_create(tcp_opts, in_out_obj); } -bool __wrap_mbs_port_tcp_recv_data(mb_port_base_t *inst, uint8_t **ppframe, uint16_t *plength) +bool __wrap_mbs_port_tcp_recv_data(mb_port_base_t *inst, uint8_t **frame, uint16_t *length) { - return mb_port_adapter_recv_data(inst, ppframe, plength); + return mb_port_adapter_recv_data(inst, frame, length); } -bool __wrap_mbs_port_tcp_send_data(mb_port_base_t *inst, uint8_t *pframe, uint16_t length) +bool __wrap_mbs_port_tcp_send_data(mb_port_base_t *inst, uint8_t *frame, uint16_t length) { - return mb_port_adapter_send_data(inst, 0, pframe, length); + return mb_port_adapter_send_data(inst, 0, frame, length); } void __wrap_mbs_port_tcp_delete(mb_port_base_t *inst) diff --git a/test_apps/test_common/mb_utest_lib/port_stubs.h b/test_apps/test_common/mb_utest_lib/port_stubs.h index d0638df..c6c9519 100644 --- a/test_apps/test_common/mb_utest_lib/port_stubs.h +++ b/test_apps/test_common/mb_utest_lib/port_stubs.h @@ -13,9 +13,9 @@ // Serial port function wrappers -bool __wrap_mb_port_event_get(mb_port_base_t *inst, mb_event_t *pevent); +bool __wrap_mb_port_event_get(mb_port_base_t *inst, mb_event_t *event); bool __wrap_mb_port_event_post(mb_port_base_t *inst, mb_event_t event); -extern bool __real_mb_port_event_get(mb_port_base_t *inst, mb_event_t *pevent); +extern bool __real_mb_port_event_get(mb_port_base_t *inst, mb_event_t *event); extern bool __real_mb_port_event_post(mb_port_base_t *inst, mb_event_t event); #if (CONFIG_FMB_COMM_MODE_ASCII_EN || CONFIG_FMB_COMM_MODE_RTU_EN) @@ -23,14 +23,14 @@ extern bool __real_mb_port_event_post(mb_port_base_t *inst, mb_event_t event); extern void __real_mb_port_ser_enable(mb_port_base_t *inst); extern void __real_mb_port_ser_disable(mb_port_base_t *inst); extern bool __real_mb_port_ser_send_data(mb_port_base_t *inst, uint8_t *p_ser_frame, uint16_t ser_length); -extern bool __real_mb_port_ser_recv_data(mb_port_base_t *inst, uint8_t **pp_ser_frame, uint16_t *p_ser_length); +extern bool __real_mb_port_ser_recv_data(mb_port_base_t *inst, uint8_t **ser_frame, uint16_t *p_ser_length); extern void __real_mb_port_ser_delete(mb_port_base_t *inst); mb_err_enum_t __wrap_mb_port_ser_create(mb_serial_opts_t *ser_opts, mb_port_base_t **in_out_obj); void __wrap_mb_port_ser_enable(mb_port_base_t *inst); void __wrap_mb_port_ser_disable(mb_port_base_t *inst); bool __wrap_mb_port_ser_send_data(mb_port_base_t *inst, uint8_t *p_ser_frame, uint16_t ser_length); -bool __wrap_mb_port_ser_recv_data(mb_port_base_t *inst, uint8_t **pp_ser_frame, uint16_t *p_ser_length); +bool __wrap_mb_port_ser_recv_data(mb_port_base_t *inst, uint8_t **ser_frame, uint16_t *p_ser_length); void __wrap_mb_port_ser_delete(mb_port_base_t *inst); #endif @@ -40,8 +40,8 @@ void __wrap_mb_port_ser_delete(mb_port_base_t *inst); mb_err_enum_t __wrap_mbm_port_tcp_create(mb_tcp_opts_t *tcp_opts, mb_port_base_t **in_out_obj); void __wrap_mbm_port_tcp_delete(mb_port_base_t *inst); -bool __wrap_mbm_port_tcp_send_data(mb_port_base_t *inst, uint8_t address, uint8_t *pframe, uint16_t length); -bool __wrap_mbm_port_tcp_recv_data(mb_port_base_t *inst, uint8_t **ppframe, uint16_t *plength); +bool __wrap_mbm_port_tcp_send_data(mb_port_base_t *inst, uint8_t address, uint8_t *frame, uint16_t length); +bool __wrap_mbm_port_tcp_recv_data(mb_port_base_t *inst, uint8_t **frame, uint16_t *length); void __wrap_mbm_port_tcp_enable(mb_port_base_t *inst); void __wrap_mbm_port_tcp_disable(mb_port_base_t *inst); void __wrap_mbm_port_tcp_set_conn_cb(mb_port_base_t *inst, void *conn_fp, void *arg); @@ -52,19 +52,19 @@ extern void __real_mbm_port_tcp_enable(mb_port_base_t *inst); extern void __real_mbm_port_tcp_disable(mb_port_base_t *inst); extern void __real_mbm_port_tcp_set_conn_cb(mb_port_base_t *inst, void *conn_fp, void *arg); extern mb_uid_info_t *__real_mbm_port_tcp_get_slave_info(mb_port_base_t *inst, uint8_t uid, mb_sock_state_t exp_state); -extern bool __real_mbm_port_tcp_send_data(mb_port_base_t *inst, uint8_t address, uint8_t *pframe, uint16_t length); -extern bool __real_mbm_port_tcp_recv_data(mb_port_base_t *inst, uint8_t **ppframe, uint16_t *plength); +extern bool __real_mbm_port_tcp_send_data(mb_port_base_t *inst, uint8_t address, uint8_t *frame, uint16_t length); +extern bool __real_mbm_port_tcp_recv_data(mb_port_base_t *inst, uint8_t **frame, uint16_t *length); mb_err_enum_t __wrap_mbs_port_tcp_create(mb_tcp_opts_t *tcp_opts, mb_port_base_t **in_out_obj); void __wrap_mbs_port_tcp_delete(mb_port_base_t *inst); -bool __wrap_mbs_port_tcp_send_data(mb_port_base_t *inst, uint8_t *pframe, uint16_t length); -bool __wrap_mbs_port_tcp_recv_data(mb_port_base_t *inst, uint8_t **ppframe, uint16_t *plength); +bool __wrap_mbs_port_tcp_send_data(mb_port_base_t *inst, uint8_t *frame, uint16_t length); +bool __wrap_mbs_port_tcp_recv_data(mb_port_base_t *inst, uint8_t **frame, uint16_t *length); void __wrap_mbs_port_tcp_enable(mb_port_base_t *inst); void __wrap_mbs_port_tcp_disable(mb_port_base_t *inst); mb_err_enum_t __real_mbs_port_tcp_create(mb_tcp_opts_t *tcp_opts, mb_port_base_t **in_out_obj); extern void __real_mbs_port_tcp_delete(mb_port_base_t *inst); -extern bool __real_mbs_port_tcp_send_data(mb_port_base_t *inst, uint8_t *pframe, uint16_t length); -extern bool __real_mbs_port_tcp_recv_data(mb_port_base_t *inst, uint8_t **ppframe, uint16_t *plength); +extern bool __real_mbs_port_tcp_send_data(mb_port_base_t *inst, uint8_t *frame, uint16_t length); +extern bool __real_mbs_port_tcp_recv_data(mb_port_base_t *inst, uint8_t **frame, uint16_t *length); extern void __real_mbs_port_tcp_enable(mb_port_base_t *inst); extern void __real_mbs_port_tcp_disable(mb_port_base_t *inst); \ No newline at end of file diff --git a/test_apps/test_common/test_common.c b/test_apps/test_common/test_common.c index 23646ff..2ab39d1 100644 --- a/test_apps/test_common/test_common.c +++ b/test_apps/test_common/test_common.c @@ -120,7 +120,7 @@ static bool task_wait_done_and_remove(task_entry_t *task_entry, TickType_t tout_ return (is_done); } -static void test_task_add_entry(TaskHandle_t task_handle, void *pinst) +static void test_task_add_entry(TaskHandle_t task_handle, void *inst) { TEST_ASSERT_TRUE(task_handle); task_entry_t *new_entry = (task_entry_t*) calloc(1, sizeof(task_entry_t)); @@ -128,7 +128,7 @@ static void test_task_add_entry(TaskHandle_t task_handle, void *pinst) portENTER_CRITICAL(&s_list_spinlock); new_entry->task_handle = task_handle; new_entry->task_sema_handle = xSemaphoreCreateBinary(); - new_entry->inst_handle = pinst; + new_entry->inst_handle = inst; LIST_INSERT_HEAD(&s_task_list, new_entry, entries); portEXIT_CRITICAL(&s_list_spinlock); xSemaphoreTake(new_entry->task_sema_handle, 1); @@ -561,10 +561,10 @@ void test_common_slave_setup_start(void *mbs_handle) TaskHandle_t test_common_master_serial_create(mb_communication_info_t *pconfig, uint32_t priority, - const mb_parameter_descriptor_t *pdescr, + const mb_parameter_descriptor_t *descr, uint16_t descr_size) { - if (!pconfig || !pdescr) { + if (!pconfig || !descr) { ESP_LOGI(TAG, "invalid master configuration."); } @@ -574,7 +574,7 @@ TaskHandle_t test_common_master_serial_create(mb_communication_info_t *pconfig, TEST_ESP_OK(mbc_master_create_serial(pconfig, &mbm_handle)); mbm_controller_iface_t *pbase = mbm_handle; - TEST_ESP_OK(mbc_master_set_descriptor(mbm_handle, pdescr, descr_size)); + TEST_ESP_OK(mbc_master_set_descriptor(mbm_handle, descr, descr_size)); ESP_LOGI(TAG, "%p, modbus master stack is initialized", mbm_handle); TEST_ESP_OK(mbc_master_start(mbm_handle)); @@ -624,9 +624,9 @@ TaskHandle_t test_common_slave_serial_create(mb_communication_info_t *pconfig, u #if (CONFIG_FMB_COMM_MODE_TCP_EN) -TaskHandle_t test_common_master_tcp_create(mb_communication_info_t *pconfig, uint32_t priority, const mb_parameter_descriptor_t *pdescr, uint16_t descr_size) +TaskHandle_t test_common_master_tcp_create(mb_communication_info_t *pconfig, uint32_t priority, const mb_parameter_descriptor_t *descr, uint16_t descr_size) { - if (!pconfig || !pdescr) { + if (!pconfig || !descr) { ESP_LOGI(TAG, "invalid master configuration."); } @@ -636,7 +636,7 @@ TaskHandle_t test_common_master_tcp_create(mb_communication_info_t *pconfig, uin TEST_ESP_OK(mbc_master_create_tcp(pconfig, &mbm_handle)); mbm_controller_iface_t *pbase = mbm_handle; - TEST_ESP_OK(mbc_master_set_descriptor(mbm_handle, pdescr, descr_size)); + TEST_ESP_OK(mbc_master_set_descriptor(mbm_handle, descr, descr_size)); ESP_LOGI(TAG, "%p, modbus master stack is initialized", mbm_handle); TEST_ESP_OK(mbc_master_start(mbm_handle)); diff --git a/test_apps/unit_tests/mb_controller_common/components/mocked_esp_modbus/test_mbm_object.h b/test_apps/unit_tests/mb_controller_common/components/mocked_esp_modbus/test_mbm_object.h index 785f260..aab7bb3 100644 --- a/test_apps/unit_tests/mb_controller_common/components/mocked_esp_modbus/test_mbm_object.h +++ b/test_apps/unit_tests/mb_controller_common/components/mocked_esp_modbus/test_mbm_object.h @@ -22,7 +22,7 @@ extern "C" { typedef struct mb_base_t mb_base_t; /*!< Type of modbus object */ typedef struct mb_port_base_t mb_port_base_t; -bool mb_port_event_get(mb_port_base_t *inst, mb_event_t *pevent); +bool mb_port_event_get(mb_port_base_t *inst, mb_event_t *event); bool mb_port_event_post(mb_port_base_t *inst, mb_event_t event); bool mb_port_event_res_take(mb_port_base_t *inst, uint32_t timeout); void mb_port_event_res_release(mb_port_base_t *inst); diff --git a/test_apps/unit_tests/mb_controller_common/main/test_mb_controller_common.c b/test_apps/unit_tests/mb_controller_common/main/test_mb_controller_common.c index 1da8aaa..aebb7fc 100644 --- a/test_apps/unit_tests/mb_controller_common/main/test_mb_controller_common.c +++ b/test_apps/unit_tests/mb_controller_common/main/test_mb_controller_common.c @@ -88,11 +88,11 @@ TEST(unit_test_controller, test_setup_destroy_master_tcp) ESP_LOGI(TAG, "TEST: Verify master create-destroy sequence TCP."); void *mbm_handle = NULL; - mb_base_t *pmb_base = NULL; - TEST_ESP_ERR(MB_ENOERR, mb_stub_tcp_create(&master_config.tcp_opts, (void *)&pmb_base)); + mb_base_t *mb_base = NULL; + TEST_ESP_ERR(MB_ENOERR, mb_stub_tcp_create(&master_config.tcp_opts, (void *)&mb_base)); mbm_tcp_create_ExpectAnyArgsAndReturn(MB_ENOERR); - mbm_tcp_create_ReturnThruPtr_in_out_obj((void **)&pmb_base); + mbm_tcp_create_ReturnThruPtr_in_out_obj((void **)&mb_base); mbm_port_tcp_get_slave_info_IgnoreAndReturn((void *)(0x11223344)); TEST_ESP_OK(mbc_master_create_tcp(&master_config, &mbm_handle)); TEST_ESP_OK(mbc_master_set_descriptor(mbm_handle, &descriptors[0], num_descriptors)); @@ -121,18 +121,18 @@ TEST(unit_test_controller, test_setup_destroy_master_serial) ESP_LOGI(TAG, "TEST: Verify master create-destroy sequence."); void *mbm_handle = NULL; - mb_base_t *pmb_base = NULL; - TEST_ESP_ERR(MB_ENOERR, mb_stub_serial_create(&master_config.ser_opts, (void *)&pmb_base)); + mb_base_t *mb_base = NULL; + TEST_ESP_ERR(MB_ENOERR, mb_stub_serial_create(&master_config.ser_opts, (void *)&mb_base)); mbm_rtu_create_ExpectAnyArgsAndReturn(MB_ENOERR); - mbm_rtu_create_ReturnThruPtr_in_out_obj((void **)&pmb_base); + mbm_rtu_create_ReturnThruPtr_in_out_obj((void **)&mb_base); TEST_ESP_OK(mbc_master_create_serial(&master_config, &mbm_handle)); TEST_ESP_OK(mbc_master_set_descriptor(mbm_handle, &descriptors[0], num_descriptors)); TEST_ESP_OK(mbc_master_delete(mbm_handle)); master_config.ser_opts.mode = MB_ASCII; mbm_handle = NULL; - pmb_base = NULL; + mb_base = NULL; mbm_ascii_create_ExpectAnyArgsAndReturn(MB_EINVAL); TEST_ESP_ERR(ESP_ERR_INVALID_STATE, mbc_master_create_serial(&master_config, &mbm_handle)); @@ -157,11 +157,11 @@ TEST(unit_test_controller, test_setup_destroy_slave_serial) ESP_LOGI(TAG, "TEST: Verify slave create-destroy sequence."); void *mbs_handle = NULL; - mb_base_t *pmb_base = mbs_handle; - TEST_ESP_ERR(MB_ENOERR, mb_stub_serial_create(&slave_config.ser_opts, (void *)&pmb_base)); - mbs_rtu_create_ExpectAndReturn(&slave_config.ser_opts, (void *)pmb_base, MB_ENOERR); + mb_base_t *mb_base = mbs_handle; + TEST_ESP_ERR(MB_ENOERR, mb_stub_serial_create(&slave_config.ser_opts, (void *)&mb_base)); + mbs_rtu_create_ExpectAndReturn(&slave_config.ser_opts, (void *)mb_base, MB_ENOERR); mbs_rtu_create_IgnoreArg_in_out_obj(); - mbs_rtu_create_ReturnThruPtr_in_out_obj((void **)&pmb_base); + mbs_rtu_create_ReturnThruPtr_in_out_obj((void **)&mb_base); TEST_ESP_OK(mbc_slave_create_serial(&slave_config, &mbs_handle)); TEST_ESP_OK(mbc_slave_delete(mbs_handle)); @@ -186,13 +186,13 @@ esp_err_t test_master_registers(int par_index, mb_err_enum_t mb_err) .ser_opts.response_tout_ms = 1, .ser_opts.test_tout_us = TEST_SLAVE_SEND_TOUT_US }; - mb_base_t *pmb_base = NULL; // fake mb_base handle + mb_base_t *mb_base = NULL; // fake mb_base handle void *mbm_handle = NULL; - TEST_ESP_ERR(MB_ENOERR, mb_stub_serial_create(&master_config.ser_opts, (void *)&pmb_base)); - pmb_base->port_obj = (mb_port_base_t *)0x44556677; + TEST_ESP_ERR(MB_ENOERR, mb_stub_serial_create(&master_config.ser_opts, (void *)&mb_base)); + mb_base->port_obj = (mb_port_base_t *)0x44556677; mbm_rtu_create_ExpectAnyArgsAndReturn(MB_ENOERR); - mbm_rtu_create_ReturnThruPtr_in_out_obj((void **)&pmb_base); + mbm_rtu_create_ReturnThruPtr_in_out_obj((void **)&mb_base); TEST_ESP_OK(mbc_master_create_serial(&master_config, &mbm_handle)); TEST_ESP_OK(mbc_master_set_descriptor(mbm_handle, &descriptors[0], num_descriptors)); mb_port_event_res_take_ExpectAnyArgsAndReturn(true); @@ -205,12 +205,12 @@ esp_err_t test_master_registers(int par_index, mb_err_enum_t mb_err) { TEST_ASSERT_EQUAL_HEX32(&descriptors[par_index], param_descriptor); uint8_t type = 0; // type of parameter from dictionary - uint8_t *pdata = (uint8_t *)calloc(1, param_descriptor->mb_size + 1); + uint8_t *data_ptr = (uint8_t *)calloc(1, param_descriptor->mb_size + 1); ESP_LOGI(TAG, "Test CID #%d, %s, %s", param_descriptor->cid, param_descriptor->param_key, param_descriptor->param_units); // This is to check the request function is called with appropriate params. switch(param_descriptor->mb_param_type) { \ case MB_PARAM_INPUT: \ - mbm_rq_read_inp_reg_ExpectAndReturn(pmb_base, \ + mbm_rq_read_inp_reg_ExpectAndReturn(mb_base, \ param_descriptor->mb_slave_addr, \ param_descriptor->mb_reg_start, \ param_descriptor->mb_size, \ @@ -219,7 +219,7 @@ esp_err_t test_master_registers(int par_index, mb_err_enum_t mb_err) mbm_rq_read_inp_reg_IgnoreArg_tout(); \ break; \ case MB_PARAM_HOLDING: - mbm_rq_read_holding_reg_ExpectAndReturn(pmb_base, \ + mbm_rq_read_holding_reg_ExpectAndReturn(mb_base, \ param_descriptor->mb_slave_addr, \ param_descriptor->mb_reg_start, \ param_descriptor->mb_size, \ @@ -228,7 +228,7 @@ esp_err_t test_master_registers(int par_index, mb_err_enum_t mb_err) mbm_rq_read_holding_reg_IgnoreArg_tout(); \ break; \ case MB_PARAM_COIL: \ - mbm_rq_read_coils_ExpectAndReturn(pmb_base, \ + mbm_rq_read_coils_ExpectAndReturn(mb_base, \ param_descriptor->mb_slave_addr, \ param_descriptor->mb_reg_start, \ param_descriptor->mb_size, \ @@ -237,7 +237,7 @@ esp_err_t test_master_registers(int par_index, mb_err_enum_t mb_err) mbm_rq_read_coils_IgnoreArg_tout(); \ break; \ case MB_PARAM_DISCRETE: \ - mbm_rq_read_discrete_inputs_ExpectAndReturn(pmb_base, \ + mbm_rq_read_discrete_inputs_ExpectAndReturn(mb_base, \ param_descriptor->mb_slave_addr, \ param_descriptor->mb_reg_start, \ param_descriptor->mb_size, \ @@ -249,8 +249,8 @@ esp_err_t test_master_registers(int par_index, mb_err_enum_t mb_err) TEST_FAIL(); \ break; \ } - err = mbc_master_get_parameter(mbm_handle, par_index, pdata, &type); \ - free(pdata); + err = mbc_master_get_parameter(mbm_handle, par_index, data_ptr, &type); \ + free(data_ptr); } TEST_ESP_OK(mbc_master_stop(mbm_handle)); TEST_ESP_OK(mbc_master_delete(mbm_handle)); diff --git a/test_apps/unit_tests/mb_controller_mapping/components/mocked_esp_modbus/test_mbm_object.h b/test_apps/unit_tests/mb_controller_mapping/components/mocked_esp_modbus/test_mbm_object.h index 15d0f33..89910d9 100644 --- a/test_apps/unit_tests/mb_controller_mapping/components/mocked_esp_modbus/test_mbm_object.h +++ b/test_apps/unit_tests/mb_controller_mapping/components/mocked_esp_modbus/test_mbm_object.h @@ -73,7 +73,7 @@ extern "C" { typedef struct mb_base_t mb_base_t; /*!< Type of modbus object */ typedef struct mb_port_base_t mb_port_base_t; -bool mb_port_event_get(mb_port_base_t *inst, mb_event_t *pevent); +bool mb_port_event_get(mb_port_base_t *inst, mb_event_t *event); bool mb_port_event_post(mb_port_base_t *inst, mb_event_t event); bool mb_port_event_res_take(mb_port_base_t *inst, uint32_t timeout); void mb_port_event_res_release(mb_port_base_t *inst); diff --git a/test_apps/unit_tests/mb_controller_mapping/main/test_mb_controller_unit.c b/test_apps/unit_tests/mb_controller_mapping/main/test_mb_controller_unit.c index 8ef4808..a050b24 100644 --- a/test_apps/unit_tests/mb_controller_mapping/main/test_mb_controller_unit.c +++ b/test_apps/unit_tests/mb_controller_mapping/main/test_mb_controller_unit.c @@ -104,51 +104,51 @@ static void test_slave_check_descriptor(int par_index) }; void *mbs_handle = NULL; - mb_base_t *pmb_base = NULL; // fake mb_base handle + mb_base_t *mb_base = NULL; // fake mb_base handle - TEST_ESP_ERR(MB_ENOERR, mb_stub_serial_create(&slave_config.ser_opts, (void *)&pmb_base)); - pmb_base->port_obj = (mb_port_base_t *)0x44556677; + TEST_ESP_ERR(MB_ENOERR, mb_stub_serial_create(&slave_config.ser_opts, (void *)&mb_base)); + mb_base->port_obj = (mb_port_base_t *)0x44556677; mbs_rtu_create_ExpectAnyArgsAndReturn(MB_ENOERR); - mbs_rtu_create_ReturnThruPtr_in_out_obj((void **)&pmb_base); + mbs_rtu_create_ReturnThruPtr_in_out_obj((void **)&mb_base); TEST_ESP_OK(mbc_slave_create_serial(&slave_config, &mbs_handle)); TEST_ASSERT(mbs_handle); mbs_controller_iface_t *mbs_iface = (mbs_controller_iface_t *)mbs_handle; //mb_slave_options_t *mbs_opts = MB_SLAVE_GET_OPTS(mbs_iface); - TEST_ASSERT_EQUAL_HEX32(mbs_iface->mb_base, pmb_base); + TEST_ASSERT_EQUAL_HEX32(mbs_iface->mb_base, mb_base); - TEST_ASSERT_EQUAL_HEX32(pmb_base->rw_cbs.reg_input_cb, mbc_reg_input_slave_cb); - TEST_ASSERT_EQUAL_HEX32(pmb_base->rw_cbs.reg_holding_cb, mbc_reg_holding_slave_cb); - TEST_ASSERT_EQUAL_HEX32(pmb_base->rw_cbs.reg_coils_cb, mbc_reg_coils_slave_cb); - TEST_ASSERT_EQUAL_HEX32(pmb_base->rw_cbs.reg_discrete_cb, mbc_reg_discrete_slave_cb); + TEST_ASSERT_EQUAL_HEX32(mb_base->rw_cbs.reg_input_cb, mbc_reg_input_slave_cb); + TEST_ASSERT_EQUAL_HEX32(mb_base->rw_cbs.reg_holding_cb, mbc_reg_holding_slave_cb); + TEST_ASSERT_EQUAL_HEX32(mb_base->rw_cbs.reg_coils_cb, mbc_reg_coils_slave_cb); + TEST_ASSERT_EQUAL_HEX32(mb_base->rw_cbs.reg_discrete_cb, mbc_reg_discrete_slave_cb); - mb_parameter_descriptor_t *pdescr = (mb_parameter_descriptor_t *)&descriptors[par_index]; + mb_parameter_descriptor_t *descr = (mb_parameter_descriptor_t *)&descriptors[par_index]; mb_register_area_descriptor_t reg_area; - ESP_LOGI(TAG, "Test CID #%d, %s, %s", pdescr->cid, pdescr->param_key, pdescr->param_units); + ESP_LOGI(TAG, "Test CID #%d, %s, %s", descr->cid, descr->param_key, descr->param_units); - uint16_t n_bytes = ((pdescr->mb_param_type == MB_PARAM_INPUT) || (pdescr->mb_param_type == MB_PARAM_HOLDING)) - ? (pdescr->mb_size << 1) : ((pdescr->mb_size >> 3) + 1); + uint16_t n_bytes = ((descr->mb_param_type == MB_PARAM_INPUT) || (descr->mb_param_type == MB_PARAM_HOLDING)) + ? (descr->mb_size << 1) : ((descr->mb_size >> 3) + 1); // First define the correct area - reg_area.type = pdescr->mb_param_type; - reg_area.start_offset = pdescr->mb_reg_start; - reg_area.address = (void *)pdescr->param_offset; + reg_area.type = descr->mb_param_type; + reg_area.start_offset = descr->mb_reg_start; + reg_area.address = (void *)descr->param_offset; reg_area.size = n_bytes; ESP_LOGI(TAG, "Area (type, reg_start, address, size): %d, %u, 0x%" PRIx32 ", %d, is defined.", (int)reg_area.type, (unsigned)reg_area.start_offset, (uint32_t)reg_area.address, (int)reg_area.size); TEST_ESP_OK(mbc_slave_set_descriptor(mbs_handle, reg_area)); // Check additional area overlapped - reg_area.start_offset = (pdescr->mb_reg_start + pdescr->mb_size - 2); + reg_area.start_offset = (descr->mb_reg_start + descr->mb_size - 2); reg_area.size = 2; ESP_LOGI(TAG, "Area overlapped (type, reg_start, address, size): %d, %u, 0x%" PRIx32 ", %d.", (int)reg_area.type, (unsigned)reg_area.start_offset, (uint32_t)reg_area.address, (int)reg_area.size); TEST_ESP_ERR(ESP_ERR_INVALID_ARG, mbc_slave_set_descriptor(mbs_handle, reg_area)); - reg_area.start_offset = pdescr->mb_reg_start; + reg_area.start_offset = descr->mb_reg_start; reg_area.size = n_bytes; - reg_area.address = (void *)pdescr->param_offset - 2; + reg_area.address = (void *)descr->param_offset - 2; ESP_LOGI(TAG, "Area redefine (type, reg_start, address, size): %d, %u, 0x%" PRIx32 ", %d.", (int)reg_area.type, (unsigned)reg_area.start_offset, (uint32_t)reg_area.address, (int)reg_area.size); TEST_ESP_ERR(ESP_ERR_INVALID_ARG, mbc_slave_set_descriptor(mbs_handle, reg_area)); @@ -170,24 +170,24 @@ static esp_err_t test_master_read_req(int par_index, mb_err_enum_t mb_err) .ser_opts.parity = UART_PARITY_DISABLE, .ser_opts.response_tout_ms = 1, .ser_opts.test_tout_us = TEST_SLAVE_SEND_TOUT_US}; - mb_base_t *pmb_base = NULL; // fake mb_base handle + mb_base_t *mb_base = NULL; // fake mb_base handle void *mbm_handle = NULL; - TEST_ESP_ERR(MB_ENOERR, mb_stub_serial_create(&master_config.ser_opts, (void *)&pmb_base)); - pmb_base->port_obj = (mb_port_base_t *)0x44556677; + TEST_ESP_ERR(MB_ENOERR, mb_stub_serial_create(&master_config.ser_opts, (void *)&mb_base)); + mb_base->port_obj = (mb_port_base_t *)0x44556677; mbm_rtu_create_ExpectAnyArgsAndReturn(MB_ENOERR); - mbm_rtu_create_ReturnThruPtr_in_out_obj((void **)&pmb_base); + mbm_rtu_create_ReturnThruPtr_in_out_obj((void **)&mb_base); TEST_ESP_OK(mbc_master_create_serial(&master_config, &mbm_handle)); TEST_ESP_OK(mbc_master_set_descriptor(mbm_handle, &descriptors[0], num_descriptors)); - mb_port_event_post_ExpectAndReturn(pmb_base->port_obj, EVENT(EV_FRAME_TRANSMIT | EV_TRANS_START), true); + mb_port_event_post_ExpectAndReturn(mb_base->port_obj, EVENT(EV_FRAME_TRANSMIT | EV_TRANS_START), true); TEST_ESP_OK(mbc_master_start(mbm_handle)); - mb_port_event_wait_req_finish_ExpectAndReturn(pmb_base->port_obj, mb_err); + mb_port_event_wait_req_finish_ExpectAndReturn(mb_base->port_obj, mb_err); const mb_parameter_descriptor_t *param_descriptor = NULL; TEST_ESP_OK(mbc_master_get_cid_info(mbm_handle, par_index, ¶m_descriptor)); TEST_ASSERT_EQUAL_HEX32(&descriptors[par_index], param_descriptor); uint8_t type = 0; // type of parameter from dictionary - uint8_t pdata[100] = {0}; + uint8_t data_ptr[100] = {0}; ESP_LOGI(TAG, "Test CID #%d, %s, %s", param_descriptor->cid, param_descriptor->param_key, param_descriptor->param_units); mb_port_event_res_take_ExpectAnyArgsAndReturn(true); mb_port_event_res_release_ExpectAnyArgs(); @@ -195,12 +195,12 @@ static esp_err_t test_master_read_req(int par_index, mb_err_enum_t mb_err) mb_port_event_res_release_ExpectAnyArgs(); // Call the read method of modbus controller - esp_err_t err = mbc_master_get_parameter(mbm_handle, par_index, pdata, &type); + esp_err_t err = mbc_master_get_parameter(mbm_handle, par_index, data_ptr, &type); uint8_t *mb_frame_ptr = NULL; // get send buffer back using the fake mb_object - pmb_base->get_send_buf(pmb_base, &mb_frame_ptr); - TEST_ASSERT_EQUAL_HEX8(pmb_base->get_dest_addr(pmb_base), param_descriptor->mb_slave_addr); - uint8_t send_len = pmb_base->get_send_len(pmb_base); + mb_base->get_send_buf(mb_base, &mb_frame_ptr); + TEST_ASSERT_EQUAL_HEX8(mb_base->get_dest_addr(mb_base), param_descriptor->mb_slave_addr); + uint8_t send_len = mb_base->get_send_len(mb_base); TEST_ASSERT_EQUAL_HEX8(send_len, (MB_PDU_SIZE_MIN + MB_PDU_REQ_READ_SIZE)); // Check that request function forms correct buffer switch (param_descriptor->mb_param_type) @@ -261,17 +261,17 @@ static esp_err_t test_master_write_req(int par_index, mb_err_enum_t mb_err) .ser_opts.parity = UART_PARITY_DISABLE, .ser_opts.response_tout_ms = 1, .ser_opts.test_tout_us = TEST_SLAVE_SEND_TOUT_US}; - mb_base_t *pmb_base = NULL; // fake mb_base handle + mb_base_t *mb_base = NULL; // fake mb_base handle void *mbm_handle = NULL; - TEST_ESP_ERR(MB_ENOERR, mb_stub_serial_create(&master_config.ser_opts, (void *)&pmb_base)); - pmb_base->port_obj = (mb_port_base_t *)0x44556677; + TEST_ESP_ERR(MB_ENOERR, mb_stub_serial_create(&master_config.ser_opts, (void *)&mb_base)); + mb_base->port_obj = (mb_port_base_t *)0x44556677; mbm_rtu_create_ExpectAnyArgsAndReturn(MB_ENOERR); - mbm_rtu_create_ReturnThruPtr_in_out_obj((void **)&pmb_base); + mbm_rtu_create_ReturnThruPtr_in_out_obj((void **)&mb_base); TEST_ESP_OK(mbc_master_create_serial(&master_config, &mbm_handle)); TEST_ESP_OK(mbc_master_set_descriptor(mbm_handle, &descriptors[0], num_descriptors)); - mb_port_event_post_ExpectAndReturn(pmb_base->port_obj, EVENT(EV_FRAME_TRANSMIT | EV_TRANS_START), true); - mb_port_event_wait_req_finish_ExpectAndReturn(pmb_base->port_obj, mb_err); + mb_port_event_post_ExpectAndReturn(mb_base->port_obj, EVENT(EV_FRAME_TRANSMIT | EV_TRANS_START), true); + mb_port_event_wait_req_finish_ExpectAndReturn(mb_base->port_obj, mb_err); TEST_ESP_OK(mbc_master_start(mbm_handle)); const mb_parameter_descriptor_t *param_descriptor = NULL; @@ -289,9 +289,9 @@ static esp_err_t test_master_write_req(int par_index, mb_err_enum_t mb_err) esp_err_t err = mbc_master_set_parameter(mbm_handle, par_index, reg_data, &type); uint8_t *mb_frame_ptr = NULL; // get send buffer back using the fake mb_object - pmb_base->get_send_buf(pmb_base, &mb_frame_ptr); - TEST_ASSERT_EQUAL_HEX8(pmb_base->get_dest_addr(pmb_base), param_descriptor->mb_slave_addr); - uint8_t send_len = pmb_base->get_send_len(pmb_base); + mb_base->get_send_buf(mb_base, &mb_frame_ptr); + TEST_ASSERT_EQUAL_HEX8(mb_base->get_dest_addr(mb_base), param_descriptor->mb_slave_addr); + uint8_t send_len = mb_base->get_send_len(mb_base); // Check that request function forms correct buffer switch (param_descriptor->mb_param_type) { @@ -310,7 +310,7 @@ static esp_err_t test_master_write_req(int par_index, mb_err_enum_t mb_err) TEST_ASSERT_EQUAL_HEX8(reg_data[1], mb_frame_ptr[MB_PDU_REQ_WRITE_MUL_VALUES_OFF]); } ESP_LOG_BUFFER_HEX_LEVEL(TAG, (void *)mb_frame_ptr, send_len, ESP_LOG_INFO); - // TEST_ESP_ERR(MB_ENOERR, mbs_fn_write_holding_reg(pmb_base, mb_frame_ptr, &send_len)); + // TEST_ESP_ERR(MB_ENOERR, mbs_fn_write_holding_reg(mb_base, mb_frame_ptr, &send_len)); break; case MB_PARAM_COIL: TEST_ASSERT_EQUAL_HEX8(mb_frame_ptr[MB_PDU_FUNC_OFF], MB_FUNC_WRITE_MULTIPLE_COILS); @@ -347,23 +347,23 @@ static esp_err_t test_master_check_callback(int par_index, mb_err_enum_t mb_err) .ser_opts.parity = UART_PARITY_DISABLE, .ser_opts.response_tout_ms = 1, .ser_opts.test_tout_us = TEST_SLAVE_SEND_TOUT_US}; - mb_base_t *pmb_base = NULL; // fake mb_base handle + mb_base_t *mb_base = NULL; // fake mb_base handle void *mbm_handle = NULL; - TEST_ESP_ERR(MB_ENOERR, mb_stub_serial_create(&master_config.ser_opts, (void *)&pmb_base)); - pmb_base->port_obj = (mb_port_base_t *)0x44556677; + TEST_ESP_ERR(MB_ENOERR, mb_stub_serial_create(&master_config.ser_opts, (void *)&mb_base)); + mb_base->port_obj = (mb_port_base_t *)0x44556677; mbm_rtu_create_ExpectAnyArgsAndReturn(MB_ENOERR); - mbm_rtu_create_ReturnThruPtr_in_out_obj((void **)&pmb_base); + mbm_rtu_create_ReturnThruPtr_in_out_obj((void **)&mb_base); TEST_ESP_OK(mbc_master_create_serial(&master_config, &mbm_handle)); TEST_ESP_OK(mbc_master_set_descriptor(mbm_handle, &descriptors[0], num_descriptors)); mbm_controller_iface_t *mbm_controller_iface = (mbm_controller_iface_t *)mbm_handle; mb_master_options_t *mbm_opts = MB_MASTER_GET_OPTS(mbm_controller_iface); - TEST_ASSERT_EQUAL_HEX32(mbm_controller_iface->mb_base, pmb_base); + TEST_ASSERT_EQUAL_HEX32(mbm_controller_iface->mb_base, mb_base); - TEST_ASSERT_EQUAL_HEX32(pmb_base->rw_cbs.reg_input_cb, mbc_reg_input_master_cb); - TEST_ASSERT_EQUAL_HEX32(pmb_base->rw_cbs.reg_holding_cb, mbc_reg_holding_master_cb); - TEST_ASSERT_EQUAL_HEX32(pmb_base->rw_cbs.reg_coils_cb, mbc_reg_coils_master_cb); - TEST_ASSERT_EQUAL_HEX32(pmb_base->rw_cbs.reg_discrete_cb, mbc_reg_discrete_master_cb); + TEST_ASSERT_EQUAL_HEX32(mb_base->rw_cbs.reg_input_cb, mbc_reg_input_master_cb); + TEST_ASSERT_EQUAL_HEX32(mb_base->rw_cbs.reg_holding_cb, mbc_reg_holding_master_cb); + TEST_ASSERT_EQUAL_HEX32(mb_base->rw_cbs.reg_coils_cb, mbc_reg_coils_master_cb); + TEST_ASSERT_EQUAL_HEX32(mb_base->rw_cbs.reg_discrete_cb, mbc_reg_discrete_master_cb); TEST_ESP_OK(mbc_master_start(mbm_handle)); @@ -380,7 +380,7 @@ static esp_err_t test_master_check_callback(int par_index, mb_err_enum_t mb_err) switch (param_descriptor->mb_param_type) { case MB_PARAM_HOLDING: - err = mbc_reg_holding_master_cb(pmb_base, reg_data_in, param_descriptor->mb_reg_start, + err = mbc_reg_holding_master_cb(mb_base, reg_data_in, param_descriptor->mb_reg_start, param_descriptor->mb_size, MB_REG_READ); for (int i = 0; (i < param_descriptor->mb_size); i++) { @@ -392,7 +392,7 @@ static esp_err_t test_master_check_callback(int par_index, mb_err_enum_t mb_err) break; case MB_PARAM_INPUT: - err = mbc_reg_input_master_cb(pmb_base, reg_data_in, param_descriptor->mb_reg_start, + err = mbc_reg_input_master_cb(mb_base, reg_data_in, param_descriptor->mb_reg_start, param_descriptor->mb_size); ESP_LOG_BUFFER_HEX_LEVEL(TAG ", INPUT_BUFF", (void *)reg_data_in, (param_descriptor->mb_size << 1), ESP_LOG_INFO); for (int i = 0; (i < param_descriptor->mb_size); i++) @@ -406,7 +406,7 @@ static esp_err_t test_master_check_callback(int par_index, mb_err_enum_t mb_err) case MB_PARAM_COIL: reg_data_in[0] = 0xFF; reg_data_in[1] = 0xFF; - err = mbc_reg_coils_master_cb(pmb_base, reg_data_in, param_descriptor->mb_reg_start, param_descriptor->mb_size, MB_REG_READ); + err = mbc_reg_coils_master_cb(mb_base, reg_data_in, param_descriptor->mb_reg_start, param_descriptor->mb_size, MB_REG_READ); byte_cnt = (param_descriptor->mb_size & 0x0007) ? ((param_descriptor->mb_size >> 3) + 1) : (param_descriptor->mb_size >> 3); ESP_LOG_BUFFER_HEX_LEVEL(TAG ", INPUT_BUFF", (void *)reg_data_in, byte_cnt, ESP_LOG_INFO); TEST_ASSERT_EQUAL_HEX8((reg_data_out[0] & param_descriptor->param_opts.opt1), param_descriptor->param_opts.opt1); @@ -417,7 +417,7 @@ static esp_err_t test_master_check_callback(int par_index, mb_err_enum_t mb_err) case MB_PARAM_DISCRETE: reg_data_in[0] = 0xFF; reg_data_in[1] = 0xFF; - err = mbc_reg_discrete_master_cb(pmb_base, reg_data_in, param_descriptor->mb_reg_start, param_descriptor->mb_size); + err = mbc_reg_discrete_master_cb(mb_base, reg_data_in, param_descriptor->mb_reg_start, param_descriptor->mb_size); byte_cnt = (param_descriptor->mb_size & 0x0007) ? ((param_descriptor->mb_size >> 3) + 1) : (param_descriptor->mb_size >> 3); ESP_LOG_BUFFER_HEX_LEVEL(TAG ", INPUT_BUFF", (void *)reg_data_in, byte_cnt, ESP_LOG_INFO); TEST_ASSERT_EQUAL_HEX8((reg_data_out[0] & param_descriptor->param_opts.opt1), param_descriptor->param_opts.opt1); diff --git a/test_apps/unit_tests/test_stubs/include/transport_common.h b/test_apps/unit_tests/test_stubs/include/transport_common.h index 02d7f61..4d62e27 100644 --- a/test_apps/unit_tests/test_stubs/include/transport_common.h +++ b/test_apps/unit_tests/test_stubs/include/transport_common.h @@ -14,14 +14,14 @@ extern "C" { #endif typedef struct mb_trans_base_t mb_trans_base_t; /*!< Type of moddus transport object */ -typedef struct _obj_descr obj_descr_t; +typedef struct obj_descr_s obj_descr_t; typedef void (*mb_frm_start_fp)(mb_trans_base_t *transport); typedef void (*mb_frm_stop_fp)(mb_trans_base_t *transport); -typedef mb_err_enum_t (*mb_frm_rcv_fp)(mb_trans_base_t *transport, uint8_t *rcv_addr_buf, uint8_t **frame_ptr_buf, uint16_t *len_buf); +typedef mb_err_enum_t (*mb_frm_rcv_fp)(mb_trans_base_t *transport, uint8_t *rcv_addr_buf, uint8_t **frame_buf, uint16_t *len_buf); typedef mb_err_enum_t (*mb_frm_snd_fp)(mb_trans_base_t *transport, uint8_t slv_addr, const uint8_t *frame_ptr, uint16_t len); -typedef void (*mb_get_rx_frm_fp) (mb_trans_base_t *transport, uint8_t **frame_ptr_buf); -typedef void (*mb_get_tx_frm_fp) (mb_trans_base_t *transport, uint8_t **frame_ptr_buf); +typedef void (*mb_get_rx_frm_fp) (mb_trans_base_t *transport, uint8_t **frame_buf); +typedef void (*mb_get_tx_frm_fp) (mb_trans_base_t *transport, uint8_t **frame_buf); typedef bool (*mb_get_fp)(mb_trans_base_t *inst); struct mb_trans_base_t diff --git a/test_apps/unit_tests/test_stubs/src/mb_object_stub.c b/test_apps/unit_tests/test_stubs/src/mb_object_stub.c index 9e2f4fb..45e58e0 100644 --- a/test_apps/unit_tests/test_stubs/src/mb_object_stub.c +++ b/test_apps/unit_tests/test_stubs/src/mb_object_stub.c @@ -37,7 +37,7 @@ static void mb_set_pdu_send_length(mb_base_t *inst, uint16_t length); static uint16_t mb_get_pdu_send_length(mb_base_t *inst); static void mb_set_dest_addr(mb_base_t *inst, uint8_t dest_addr); static uint8_t mb_get_dest_addr(mb_base_t *inst); -static void mb_get_pdu_send_buf(mb_base_t *inst, uint8_t **pbuf); +static void mb_get_pdu_send_buf(mb_base_t *inst, uint8_t **buf); //mb_err_enum_t mb_tcp_create(mb_tcp_opts_t *tcp_opts, void **in_out_obj); @@ -140,16 +140,16 @@ mb_err_enum_t mb_disable(mb_base_t *inst) return status; } -static void mb_get_pdu_send_buf(mb_base_t *inst, uint8_t **pbuf) +static void mb_get_pdu_send_buf(mb_base_t *inst, uint8_t **buf) { mb_object_t *mb_obj = __containerof(inst, mb_object_t, base); - if (pbuf) { - *pbuf = mb_obj->snd_buf; + if (buf) { + *buf = mb_obj->snd_buf; } } // __attribute__((unused)) -// static void mb_get_pdu_recv_buf(mb_base_t *inst, uint8_t **pbuf) +// static void mb_get_pdu_recv_buf(mb_base_t *inst, uint8_t **buf) // { // //mb_object_t *mb_obj = __containerof(inst, mb_object_t, base); // } diff --git a/test_apps/unit_tests/test_stubs/src/mb_transport_stub.c b/test_apps/unit_tests/test_stubs/src/mb_transport_stub.c index e96f573..34d1475 100644 --- a/test_apps/unit_tests/test_stubs/src/mb_transport_stub.c +++ b/test_apps/unit_tests/test_stubs/src/mb_transport_stub.c @@ -32,13 +32,13 @@ typedef struct mb_err_enum_t mbm_rtu_transp_create(mb_serial_opts_t *ser_opts, void **in_out_inst); static void mbm_rtu_transp_start(mb_trans_base_t *inst); static void mbm_rtu_transp_stop(mb_trans_base_t *inst); -static mb_err_enum_t mbm_rtu_transp_receive(mb_trans_base_t *inst, uint8_t *rcv_addr_buf, uint8_t **frame_ptr_buf, uint16_t *len_buf); +static mb_err_enum_t mbm_rtu_transp_receive(mb_trans_base_t *inst, uint8_t *rcv_addr_buf, uint8_t **frame_buf, uint16_t *len_buf); static mb_err_enum_t mbm_rtu_transp_send(mb_trans_base_t *inst, uint8_t slv_addr, const uint8_t *frame_ptr, uint16_t len); static bool mbm_rtu_transp_rcv_fsm(mb_trans_base_t *inst); static bool mbm_rtu_transp_snd_fsm(mb_trans_base_t *inst); static bool mbm_rtu_transp_timer_expired(void *inst); -static void mbm_rtu_transp_get_snd_buf(mb_trans_base_t *inst, uint8_t **frame_ptr_buf); -static void mbm_rtu_transp_get_rcv_buf(mb_trans_base_t *inst, uint8_t **frame_ptr_buf); +static void mbm_rtu_transp_get_snd_buf(mb_trans_base_t *inst, uint8_t **frame_buf); +static void mbm_rtu_transp_get_rcv_buf(mb_trans_base_t *inst, uint8_t **frame_buf); // static uint16_t mbm_rtu_transp_get_snd_len(mb_trans_base_t *inst); static void mbm_rtu_transp_set_snd_len(mb_trans_base_t *inst, uint16_t snd_pdu_len); static bool mbm_rtu_transp_rq_is_bcast(mb_trans_base_t *inst); @@ -133,43 +133,43 @@ static void mbm_rtu_transp_stop(mb_trans_base_t *inst) }; } -static mb_err_enum_t mbm_rtu_transp_receive(mb_trans_base_t *inst, uint8_t *prcv_addr, uint8_t **ppframe_buf, uint16_t *pbuf_len) +static mb_err_enum_t mbm_rtu_transp_receive(mb_trans_base_t *inst, uint8_t *recv_addr, uint8_t **frame_buf, uint16_t *buf_len) { mbm_rtu_transp_t *transp = __containerof(inst, mbm_rtu_transp_t, base); - if (!pbuf_len || !prcv_addr || !ppframe_buf || !pbuf_len) { + if (!buf_len || !recv_addr || !frame_buf || !buf_len) { return MB_EIO; } mb_err_enum_t status = MB_ENOERR; - uint8_t *pbuf = (uint8_t *)transp->rcv_buf; - uint16_t length = *pbuf_len; + uint8_t *buf = (uint8_t *)transp->rcv_buf; + uint16_t length = *buf_len; - if (mb_port_ser_recv_data(inst->port_obj, &pbuf, &length) == false) { - *pbuf_len = 0; + if (mb_port_ser_recv_data(inst->port_obj, &buf, &length) == false) { + *buf_len = 0; return MB_EPORTERR; } assert(length < MB_RTU_SER_PDU_SIZE_MAX); - assert(pbuf); + assert(buf); /* Check length and CRC checksum */ if ((length >= MB_RTU_SER_PDU_SIZE_MIN) - && (mb_crc16((uint8_t *)pbuf, length) == 0)) { + && (mb_crc16((uint8_t *)buf, length) == 0)) { /* Save the address field. All frames are passed to the upper layed * and the decision if a frame is used is done there. */ - *prcv_addr = pbuf[MB_SER_PDU_ADDR_OFF]; + *recv_addr = buf[MB_SER_PDU_ADDR_OFF]; /* Total length of Modbus-PDU is Modbus-Serial-Line-PDU minus * size of address field and CRC checksum. */ - *pbuf_len = (uint16_t)(length - MB_SER_PDU_PDU_OFF - MB_SER_PDU_SIZE_CRC); + *buf_len = (uint16_t)(length - MB_SER_PDU_PDU_OFF - MB_SER_PDU_SIZE_CRC); transp->rcv_buf_pos = length; /* Return the start of the Modbus PDU to the caller. */ - *ppframe_buf = (uint8_t *)&pbuf[MB_SER_PDU_PDU_OFF]; + *frame_buf = (uint8_t *)&buf[MB_SER_PDU_PDU_OFF]; } else { status = MB_EIO; } @@ -266,19 +266,19 @@ static bool mbm_rtu_transp_timer_expired(void *inst) return need_poll; } -static void mbm_rtu_transp_get_rcv_buf(mb_trans_base_t *inst, uint8_t **frame_ptr_buf) +static void mbm_rtu_transp_get_rcv_buf(mb_trans_base_t *inst, uint8_t **frame_buf) { mbm_rtu_transp_t *transp = __containerof(inst, mbm_rtu_transp_t, base); CRITICAL_SECTION(inst->lock) { - *frame_ptr_buf = (uint8_t *)&transp->rcv_buf[MB_PDU_FUNC_OFF]; + *frame_buf = (uint8_t *)&transp->rcv_buf[MB_PDU_FUNC_OFF]; } } -static void mbm_rtu_transp_get_snd_buf(mb_trans_base_t *inst, uint8_t **frame_ptr_buf) +static void mbm_rtu_transp_get_snd_buf(mb_trans_base_t *inst, uint8_t **frame_buf) { mbm_rtu_transp_t *transp = __containerof(inst, mbm_rtu_transp_t, base); CRITICAL_SECTION(inst->lock) { - *frame_ptr_buf = (uint8_t *)&transp->snd_buf[MB_RTU_SER_PDU_PDU_OFF]; + *frame_buf = (uint8_t *)&transp->snd_buf[MB_RTU_SER_PDU_PDU_OFF]; } } diff --git a/tools/.clang-tidy b/tools/.clang-tidy new file mode 100644 index 0000000..723d12f --- /dev/null +++ b/tools/.clang-tidy @@ -0,0 +1,24 @@ +--- +Checks: > + -*, + bugprone-argument-comment, + bugprone-too-small-loop-variable, + google-explicit-constructor, + misc-unused-using-decls, + modernize-loop-convert, + modernize-use-bool-literals, + modernize-use-equals-default, + modernize-use-equals-delete, + modernize-use-nullptr, + readability-avoid-const-params-in-decls, + readability-make-member-function-const, + readability-redundant-control-flow, + readability-redundant-member-init, + readability-simplify-boolean-expr, + readability-static-accessed-through-instance, + readability-else-after-return, + readability-inconsistent-declaration-parameter-name, +WarningsAsErrors: '*' +HeaderFilterRegex: '(examples|include|src).*(?> ${PWD}/sdkconfig.defaults + idf.py set-target "esp32" + idf.py build || die "CMake build in ${PWD} has failed" + ;; + *) + echo "Incorrect parameter provided: $1, should be 'gcc' or 'clang'." + exit 1 + ;; + esac + popd +done