From 346d7c978a2b910930168aeca8653c237d049f69 Mon Sep 17 00:00:00 2001 From: Nikita Date: Thu, 27 Jul 2023 16:48:36 +0300 Subject: [PATCH] Added receiving data via UDP --- wrappers/Cpp/rf60Xsdk/rf60Xsdk.cpp | 166 ++++++++++++++++++------ wrappers/Cpp/rf60Xsdk/rf60Xsdk.h | 15 ++- wrappers/Cpp/rf60Xsdk/rf60Xtypes.h | 96 +++++++++++--- wrappers/Cpp/rf60Xsdk/serialmanager.cpp | 93 ++++++++++++- wrappers/Cpp/rf60Xsdk/serialmanager.h | 10 +- 5 files changed, 322 insertions(+), 58 deletions(-) diff --git a/wrappers/Cpp/rf60Xsdk/rf60Xsdk.cpp b/wrappers/Cpp/rf60Xsdk/rf60Xsdk.cpp index dd71ebc..33a5459 100644 --- a/wrappers/Cpp/rf60Xsdk/rf60Xsdk.cpp +++ b/wrappers/Cpp/rf60Xsdk/rf60Xsdk.cpp @@ -1525,6 +1525,8 @@ bool rf60x::test_read_custom_command(uint8_t command, uint8_t size, vec_ref.emplace_back(tempByteBuffer); } } catch (std::exception &e) { + + std::cout << e.what() << std::endl; return false; } } @@ -1533,8 +1535,8 @@ bool rf60x::test_read_custom_command(uint8_t command, uint8_t size, } bool rf60x::test_request_custom_command( - uint8_t command, uint8_t size, - char *data) { // TODO command возможно не нужен + char *data, uint8_t size + ) { // TODO command возможно не нужен return serial_manager->write_command(data, size); } @@ -1545,7 +1547,8 @@ bool rf60x::test_get_measure_uart(void *measure, PROTOCOL_MEASURE_UART type) { size_t sequenceLength = 0; char tempButeBufferArray[12]; - + serial_manager->set_timeout( + std::chrono::milliseconds(500)); while (sequenceLength != sizeType) { try { if (!serial_manager->read_command(&tempByteBuffer, 1)) { @@ -1692,78 +1695,78 @@ bool rf60x::test_get_measure_uart(void *measure, PROTOCOL_MEASURE_UART type) { } std::pair rf60x::test_get_sensor() { - return test_get_param(CODE::PARAM_NAME_KEY::USER_POWER); + return test_get_param_2(CODE::PARAM_NAME_KEY_BYTE::USER_POWER); } std::pair rf60x::test_get_analog_out() { - return test_get_param(CODE::PARAM_NAME_KEY::POWER_ANALOG_OUTPUT); + return test_get_param_2(CODE::PARAM_NAME_KEY_BYTE::POWER_ANALOG_OUTPUT); } std::pair rf60x::test_get_network_address() { - return test_get_param(CODE::PARAM_NAME_KEY::POWER_ANALOG_OUTPUT); + return test_get_param_2(CODE::PARAM_NAME_KEY_BYTE::POWER_ANALOG_OUTPUT); } std::pair rf60x::test_get_baute_rate() { - return test_get_param(CODE::PARAM_NAME_KEY::POWER_ANALOG_OUTPUT); + return test_get_param_2(CODE::PARAM_NAME_KEY_BYTE::POWER_ANALOG_OUTPUT); } std::pair rf60x::test_get_number_of_averaged_values() { - return test_get_param( - CODE::PARAM_NAME_KEY::NUMBER_OF_AVERAGED_VALUES); + return test_get_param_2( + CODE::PARAM_NAME_KEY_BYTE::NUMBER_OF_AVERAGED_VALUES); } std::pair rf60x::test_get_sampling_period() { - return test_get_param( - CODE::PARAM_NAME_KEY::LOW_BYTE_OF_THE_SAMPLING_PERIOD); + return test_get_param_2( + CODE::PARAM_NAME_KEY_USHORT::LOW_BYTE_OF_THE_SAMPLING_PERIOD); } std::pair rf60x::test_get_maximum_integration_time() { - return test_get_param( - CODE::PARAM_NAME_KEY::LOW_BYTE_OF_MAX_INTEGRATION_TIME); + return test_get_param_2( + CODE::PARAM_NAME_KEY_USHORT::LOW_BYTE_OF_MAX_INTEGRATION_TIME); } std::pair rf60x::test_get_begin_analog_range() { - return test_get_param( - CODE::PARAM_NAME_KEY::LOW_BYTE_FOR_THE_BEGINNING_OF_ANALOG_OUT_RANGE); + return test_get_param_2( + CODE::PARAM_NAME_KEY_USHORT::LOW_BYTE_FOR_THE_BEGINNING_OF_ANALOG_OUT_RANGE); } std::pair rf60x::test_get_end_analog_range() { - return test_get_param( - CODE::PARAM_NAME_KEY::LOW_BYTE_FOR_THE_END_OF_ANALOG_OUT_RANGE); + return test_get_param_2( + CODE::PARAM_NAME_KEY_USHORT::LOW_BYTE_FOR_THE_END_OF_ANALOG_OUT_RANGE); } std::pair rf60x::test_get_time_lock_of_result() { - return test_get_param(CODE::PARAM_NAME_KEY::TIME_LOCK_OF_RESULT); + return test_get_param_2(CODE::PARAM_NAME_KEY_BYTE::TIME_LOCK_OF_RESULT); } std::pair rf60x::test_get_zero_point() { - return test_get_param( - CODE::PARAM_NAME_KEY::LOW_BYTE_OF_A_ZERO_POINT); + return test_get_param_2( + CODE::PARAM_NAME_KEY_USHORT::LOW_BYTE_OF_A_ZERO_POINT); } std::pair rf60x::test_get_CAN_interface_speed() { - return test_get_param( - CODE::PARAM_NAME_KEY::DATA_TRANSFER_RATE_VIA_CAN_INTERFACE); + return test_get_param_2( + CODE::PARAM_NAME_KEY_BYTE::DATA_TRANSFER_RATE_VIA_CAN_INTERFACE); } std::pair rf60x::test_get_standard_identifier() { - return test_get_param( - CODE::PARAM_NAME_KEY::LOW_BYTE_OF_STANDARD_IDENTIFIER); + return test_get_param_2( + CODE::PARAM_NAME_KEY_USHORT::LOW_BYTE_OF_STANDARD_IDENTIFIER); } std::pair rf60x::test_get_extend_identifier() { - return test_get_param( - CODE::PARAM_NAME_KEY::ZERO_BYTE_OF_EXTENDED_IDENTIFIER); + return test_get_param_2( + CODE::PARAM_NAME_KEY_UINT::ZERO_BYTE_OF_EXTENDED_IDENTIFIER); } std::pair rf60x::test_get_CAN_interface_identifier() { - return test_get_param( - CODE::PARAM_NAME_KEY::CAN_INTERFACE_IDENTIFIER); + return test_get_param_2( + CODE::PARAM_NAME_KEY_BYTE::CAN_INTERFACE_IDENTIFIER); } std::pair rf60x::test_get_CAN_interface() { - return test_get_param( - CODE::PARAM_NAME_KEY::CAN_INTERFACE_POWER_SWITCH); + return test_get_param_2( + CODE::PARAM_NAME_KEY_BYTE::CAN_INTERFACE_POWER_SWITCH); } std::pair rf60x::test_get_source_ip_address() { @@ -1785,23 +1788,46 @@ std::pair rf60x::test_subnet_mask() { std::pair rf60x::test_get_number_of_measurements_in_the_packet() { - return test_get_param( - CODE::PARAM_NAME_KEY:: + return test_get_param_2( + CODE::PARAM_NAME_KEY_USHORT:: LOW_BYTE_OF_THE_NUMBER_OF_MEASUREMENTS_IN_THE_PACKET); } std::pair rf60x::test_get_ethernet_inteface() { - return test_get_param(CODE::PARAM_NAME_KEY::ETH_INTERFACE_ON_OFF); + return test_get_param_2(CODE::PARAM_NAME_KEY_BYTE::ETH_INTERFACE_ON_OFF); } std::pair rf60x::test_get_autostart_of_measurement_stream() { - return test_get_param(CODE::PARAM_NAME_KEY::AUTO_OF_THE_STREAM); + return test_get_param_2(CODE::PARAM_NAME_KEY_BYTE::AUTO_OF_THE_STREAM); } std::pair rf60x::test_get_protol_type() { - return test_get_param(CODE::PARAM_NAME_KEY::PROTOCOLS_INTERFACE); + + return test_get_param_2(CODE::PARAM_NAME_KEY_BYTE::USER_POWER); + //return test_get_param(CODE::PARAM_NAME_KEY::PROTOCOLS_INTERFACE); +} + +bool rf60x::test_connect_udp(const std::string &hostAddress, uint32_t port) +{ + return serial_manager->connect_udp(hostAddress,port); +} + +void rf60x::test_disconnect_udp() +{ + return serial_manager->disconnect_udp(); +} + +template +bool rf60x::test_get_measure_udp(T &protocolUDP) +{ + serial_manager->set_timeout( + std::chrono::milliseconds(5000)); + return serial_manager->get_measure_udp(reinterpret_cast(&protocolUDP),sizeof(protocolUDP)); } +template bool rf60x::test_get_measure_udp(udp_measure_t&); +template bool rf60x::test_get_measure_udp(binocular_udp_measure_t&); + std::pair rf60x::get_ip_address(CODE::PARAM_NAME_KEY key) { std::vector ip_values; bool result = 0; @@ -1820,7 +1846,7 @@ std::pair rf60x::get_ip_address(CODE::PARAM_NAME_KEY key) { ucBuffer[2] = 0x80 | (param_key & 0x0F); ucBuffer[3] = 0x80 | ((param_key >> 4) & 0x0F); - if (!test_request_custom_command(0x78, 4, ucBuffer)) { + if (!test_request_custom_command(ucBuffer,2)) { return {false, "An error occurred while sending the request."}; } @@ -1853,6 +1879,28 @@ uint32_t rf60x::converIPString(const std::string &str) (ipValues[2] << 8) | (ipValues[3]); } +//enum class someenum +//{ +// e1, +// e2 +//}; + +//template +//struct someMap; + +//template <> struct someMap {using return_t = uint32_t;}; + +//template +//typename someMap::return_t foo() +//{ +// return 0; +//} + +//void goo() +//{ +// foo(); +//} + template std::pair rf60x::test_get_param(CODE::PARAM_NAME_KEY key) { std::vector ip_values; @@ -1871,7 +1919,7 @@ std::pair rf60x::test_get_param(CODE::PARAM_NAME_KEY key) { ucBuffer[2] = 0x80 | (param_key & 0x0F); ucBuffer[3] = 0x80 | ((param_key >> 4) & 0x0F); - if (!test_request_custom_command(0x78, 4, ucBuffer)) { + if (!test_request_custom_command(ucBuffer,4)) { return {false, 0}; } @@ -2032,7 +2080,7 @@ bool rf60x::test_set_param(const T &value, CODE::PARAM_NAME_KEY key) { ucBuffer[4] = 0x80 | ((bytes[i] & 0x000F)); ucBuffer[5] = 0x80 | (((bytes[i] & 0x00F0) >> 4)); - if (!test_request_custom_command(0x78, 6, ucBuffer)) { + if (!test_request_custom_command(ucBuffer,6)) { return false; } } @@ -2042,6 +2090,48 @@ bool rf60x::test_set_param(const T &value, CODE::PARAM_NAME_KEY key) { } } +template +std::pair rf60x::test_get_param_2(T key) +{ + + std::vector ip_values; + U result = 0; + size_t num_bytes = sizeof(T); + + char ucBuffer[4]; + ucBuffer[0] = (current_config.network_address & 0xFF); + ucBuffer[1] = + 0x80 | (static_cast(RF60X_COMMAND::READPARAM) & 0x0F); // + + try { + for (int i = 0; i < num_bytes; i++) { + uint8_t param_key = static_cast(key) + i; + + ucBuffer[2] = 0x80 | (param_key & 0x0F); + ucBuffer[3] = 0x80 | ((param_key >> 4) & 0x0F); + + if (!test_request_custom_command(ucBuffer,4)) { + return {false, 0}; + } + + if (!test_read_custom_command(param_key, 2, ip_values)) { + return {false, 0}; + } + + result |= static_cast((ip_values.at(0) & 0x0F) | + ((ip_values.at(1) & 0x0F) << 4)) + << (8 * i); + + ip_values.clear(); + } + + return {true, result}; + } catch (std::exception &e) { + std::cout << e.what() << std::endl; + return {false, 0}; + } +} + } // namespace RF60X } // namespace SCANNERS } // namespace SDK diff --git a/wrappers/Cpp/rf60Xsdk/rf60Xsdk.h b/wrappers/Cpp/rf60Xsdk/rf60Xsdk.h index 525b67d..f1d797a 100644 --- a/wrappers/Cpp/rf60Xsdk/rf60Xsdk.h +++ b/wrappers/Cpp/rf60Xsdk/rf60Xsdk.h @@ -246,7 +246,7 @@ public: bool test_read_custom_command(uint8_t command, uint8_t size, std::vector &vec_ref); - bool test_request_custom_command(uint8_t command, uint8_t size, char *data); + bool test_request_custom_command(char *data, uint8_t size); bool test_get_measure_uart(void *measure, PROTOCOL_MEASURE_UART type); @@ -303,6 +303,14 @@ public: std::pair test_get_protol_type(); + + bool test_connect_udp(const std::string &hostAddress, uint32_t port); + + void test_disconnect_udp(); + + template + bool test_get_measure_udp(T &protocolUDP); + param_t *get_param(std::string param_name); param_t *get_param(PARAM_NAME_KEY param_name); @@ -322,6 +330,11 @@ private: std::pair get_ip_address(CODE::PARAM_NAME_KEY key); template std::pair test_get_param(CODE::PARAM_NAME_KEY key); + + + template ::value, typename std::underlying_type::type>::type> + std::pair test_get_param_2(T key); + template bool test_set_param(const T& value,CODE::PARAM_NAME_KEY key); diff --git a/wrappers/Cpp/rf60Xsdk/rf60Xtypes.h b/wrappers/Cpp/rf60Xsdk/rf60Xtypes.h index 7d6c4c0..c0d3948 100644 --- a/wrappers/Cpp/rf60Xsdk/rf60Xtypes.h +++ b/wrappers/Cpp/rf60Xsdk/rf60Xtypes.h @@ -10,6 +10,7 @@ typedef struct { uint16_t encoderValue; } uart_result_with_encoder_t; +#pragma pack(push, 1) typedef struct { uint16_t value; uint8_t status; @@ -24,6 +25,27 @@ typedef struct { uint8_t packetControlSumm; } udp_measure_t; + +typedef struct { + uint16_t measure; + uint16_t exposition; + uint8_t status; +} binocular_udp_value_t; + +typedef struct { + binocular_udp_value_t rf60xBValArray[100]; + uint16_t reserved; + uint16_t reserved2; + uint16_t deviceSerial; + uint16_t deviceBaseDistance; + uint16_t deviceMeasureRange; + uint8_t packCount; + uint8_t packetControlSumm; +} binocular_udp_measure_t; + + +#pragma pack(pop) + typedef struct { uint16_t value; uint8_t count; @@ -47,23 +69,6 @@ typedef struct { uint16_t cnt_stream; } uart_stream_modified_measure_t; -typedef struct { - uint16_t measure; - uint16_t exposition; - uint8_t status; -} binocular_udp_value_t; - -typedef struct { - binocular_udp_value_t rf60xBValArray[100]; - uint16_t reserved; - uint16_t reserved2; - uint16_t deviceSerial; - uint16_t deviceBaseDistance; - uint16_t deviceMeasureRange; - uint8_t packCount; - uint8_t packetControlSumm; -} binocular_udp_measure_t; - typedef struct { uint8_t deviceType; uint8_t deviceModificaton; @@ -260,6 +265,63 @@ enum class PARAM_NAME_KEY { namespace CODE { +enum class PARAM_NAME_KEY_BYTE:uint8_t{ + USER_POWER = 0x00, + POWER_ANALOG_OUTPUT= 0x01, + CONTROL_OF_AVERAGING= 0x02, + NETWORK_ADDRESS_UART=0x03, + BAUD_RATE_UART= 0x04, + NUMBER_OF_AVERAGED_VALUES= 0x06, + TIME_LOCK_OF_RESULT = 0x10, + DATA_TRANSFER_RATE_VIA_CAN_INTERFACE = 0x20, + CAN_INTERFACE_IDENTIFIER = 0x28, + CAN_INTERFACE_POWER_SWITCH = 0x29, + ETH_INTERFACE_ON_OFF= 0x88, + AUTO_OF_THE_STREAM= 0x89, + PROTOCOLS_INTERFACE= 0x8A +}; + +enum class PARAM_NAME_KEY_USHORT:uint16_t{ + LOW_BYTE_OF_THE_SAMPLING_PERIOD= 0x08, + HIGH_BYTE_OF_THE_SAMPLING_PERIOD= 0x09, + LOW_BYTE_OF_MAX_INTEGRATION_TIME=0x0A, + HIGH_BYTE_OF_MAX_INTEGRATION_TIME=0x0B, + LOW_BYTE_FOR_THE_BEGINNING_OF_ANALOG_OUT_RANGE= 0x0C, + HIGH_BYTE_FOR_THE_BEGINNING_OF_ANALOG_OUT_RANGE= 0x0D, + LOW_BYTE_FOR_THE_END_OF_ANALOG_OUT_RANGE= 0x0E, + HIGH_BYTE_FOR_THE_END_OF_ANALOG_OUT_RANGE= 0x0F, + LOW_BYTE_OF_A_ZERO_POINT = 0x17, + HIGH_BYTE_OF_A_ZERO_POINT = 0x18, + LOW_BYTE_OF_STANDARD_IDENTIFIER = 0x22, + HIGH_BYTE_OF_STANDARD_IDENTIFIER = 0x23, + LOW_BYTE_OF_THE_NUMBER_OF_MEASUREMENTS_IN_THE_PACKET= 0x7C, + HIGH_BYTE_OF_THE_NUMBER_OF_MEASUREMENTS_IN_THE_PACKET= 0x7D +}; + + +enum class PARAM_NAME_KEY_UINT:uint32_t{ + ZERO_BYTE_OF_EXTENDED_IDENTIFIER = 0x24, + FIRST_BYTE_OF_EXTENDED_IDENTIFIER = 0x25, + SECOND_BYTE_OF_EXTENDED_IDENTIFIER = 0x26, + THIRD_BYTE_OF_EXTENDED_IDENTIFIER = 0x27, + ZERO_BYTE_OF_DESTINATION_IP_ADDRESS=0x6C, + FIRST_BYTE_OF_DESTINATION_IP_ADDRESS = 0x6D, + SECOND_BYTE_OF_DESTINATION_IP_ADDRESS= 0x6E, + THIRD_BYTE_OF_DESTINATION_IP_ADDRESS= 0x6F, + ZERO_BYTE_OF_GATEWAY_IP_ADDRESS= 0x70, + FIRST_BYTE_OF_GATEWAY_IP_ADDRESS= 0x71, + SECOND_BYTE_OF_GATEWAY_IP_ADDRESS= 0x72, + THIRD_BYTE_OF_GATEWAY_IP_ADDRESS= 0x73, + ZERO_BYTE_OF_SUBNET_MASK= 0x74, + FIRST_BYTE_OF_SUBNET_MASK= 0x75, + SECOND_BYTE_OF_SUBNET_MASK= 0x76, + THIRD_BYTE_OF_SUBNET_MASK= 0x77, + ZERO_BYTE_OF_SOURCE_IP_ADDRESS= 0x78, + FIRST_BYTE_OF_SOURCE_IP_ADDRESS= 0x79, + SECOND_BYTE_OF_SOURCE_IP_ADDRESS= 0x7A, + THIRD_BYTE_OF_SOURCE_IP_ADDRESS= 0x7B, +}; + enum PARAM_NAME_KEY { USER_POWER = 0x00, POWER_ANALOG_OUTPUT= 0x01, diff --git a/wrappers/Cpp/rf60Xsdk/serialmanager.cpp b/wrappers/Cpp/rf60Xsdk/serialmanager.cpp index 2dbf5d4..cae21ec 100644 --- a/wrappers/Cpp/rf60Xsdk/serialmanager.cpp +++ b/wrappers/Cpp/rf60Xsdk/serialmanager.cpp @@ -79,7 +79,7 @@ bool SerialManager::read_command(char *data, size_t size) { timer.cancel(); return true; case resultTimeoutExpired: - port.cancel(); + // port.cancel(); throw(timeout_exception("Timeout expired")); case resultError: timer.cancel(); @@ -97,6 +97,97 @@ void SerialManager::timeout_expired(const std::error_code &error) { } } +bool SerialManager::connect_udp(const std::string &hostAddress, uint32_t port) { + asio::error_code ec; + + using asio::ip::udp; + + udp::resolver resolver(io); + udp::endpoint endpoint = *resolver.resolve(udp::endpoint(asio::ip::address::from_string(hostAddress), port)); + + try{ + socket.bind(endpoint,ec); + } catch(std::exception &e){ + + std::cout< 0) { + // Действия с полученными данными + /* std::cout << "Получены данные: " + << std::string(recvBuffer.data(), bytesReceived) << std::endl;*/ + std::cout< timeout; ///< Read/write timeout asio::streambuf readData; ///< Holds eventual read but not consumed + asio::ip::udp::socket socket; + asio::ip::udp::endpoint endpoint; enum ReadResult result; ///< Used by read with timeout size_t bytesTransferred; ///< Used by async read callback std::error_code error_code; -- GitLab