├── .github
    └── workflows
    │   └── hardware-test.yml
├── .gitignore
├── .gitmodules
├── .travis.yml
├── CMakeLists.txt
├── README.md
├── cmake
    └── CheckPython.cmake
├── src
    ├── CMakeLists.txt
    ├── device
    │   ├── CMakeLists.txt
    │   ├── ping-device.cpp
    │   └── ping-device.h
    ├── generate
    │   ├── generate-device.py
    │   ├── generate-message.py
    │   └── templates
    │   │   ├── ping-device-ping1d.cpp.in
    │   │   ├── ping-device-ping1d.h.in
    │   │   ├── ping-device-ping360.cpp.in
    │   │   ├── ping-device-ping360.h.in
    │   │   ├── ping-message-.h.in
    │   │   └── ping-message-all.h.in
    ├── hal
    │   ├── CMakeLists.txt
    │   ├── link
    │   │   ├── desktop
    │   │   │   ├── abstract-link.cpp
    │   │   │   ├── abstract-link.h
    │   │   │   ├── serial-link.cpp
    │   │   │   ├── serial-link.h
    │   │   │   ├── udp-link.cpp
    │   │   │   └── udp-link.h
    │   │   └── ping-port.h
    │   └── time
    │   │   ├── desktop
    │   │       └── ping-time.cpp
    │   │   └── ping-time.h
    └── message
    │   ├── CMakeLists.txt
    │   ├── ping-message.h
    │   └── ping-parser.h
├── test
    ├── command-line
    │   └── command-line.h
    ├── helper.h
    ├── test-device-ping1d.cpp
    ├── test-device-ping360.cpp
    ├── test-device.cpp
    └── test-message.cpp
└── tools
    └── travis-ci-script.sh


/.github/workflows/hardware-test.yml:
--------------------------------------------------------------------------------
 1 | name: Linux hardware test
 2 | 
 3 | on: [push, pull_request]
 4 | 
 5 | jobs:
 6 |   build:
 7 | 
 8 |     runs-on: self-hosted
 9 | 
10 |     steps:
11 |     - uses: actions/checkout@master
12 |     - name: Install necessary tools
13 |       run: |
14 |         sudo apt -y update
15 |         sudo apt -y install cmake libboost-all-dev
16 |         sudo apt -y install python3-pip python3-setuptools
17 | 
18 |     - name: Build it
19 |       run: |
20 |         git submodule update --init --recursive
21 |         mkdir build
22 |         cmake -B build -DCMAKE_BUILD_TYPE=Debug && cmake --build build --parallel --config Debug
23 | 
24 |     - name: Run tests
25 |       run: |
26 |         cd build
27 |         ./test-message
28 |         ls -ls /dev/ttyUSB*
29 |         for device in /dev/ttyUSB*; do $PWD/test-device --conn serial:$device:115200; done
30 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
1 | **/__pycache__
2 | **/ping-message-*.h
3 | build
4 | src/device/ping-device-ping1d.*
5 | src/device/ping-device-ping360.*
6 | 


--------------------------------------------------------------------------------
/.gitmodules:
--------------------------------------------------------------------------------
1 | [submodule "lib/ping-protocol"]
2 | 	path = lib/ping-protocol
3 | 	url = https://github.com/bluerobotics/ping-protocol
4 | [submodule "lib/fmt"]
5 | 	path = lib/fmt
6 | 	url = https://github.com/fmtlib/fmt
7 | 


--------------------------------------------------------------------------------
/.travis.yml:
--------------------------------------------------------------------------------
 1 | dist: bionic
 2 | 
 3 | language: minimal
 4 | 
 5 | addons:
 6 |   apt:
 7 |     packages:
 8 |       - python3
 9 |       - python3-pip
10 | 
11 | install:
12 | # thank you https://stackoverflow.com/a/47441734
13 | # this is requried to be able to checkout branches after fetching
14 | - git config remote.origin.fetch +refs/heads/*:refs/remotes/origin/*
15 | - git fetch origin deployment
16 | - sudo add-apt-repository -y ppa:mhier/libboost-latest
17 | - sudo apt install -y libboost1.70-dev
18 | 
19 | script:
20 | - tools/travis-ci-script.sh || travis_terminate 1
21 | 


--------------------------------------------------------------------------------
/CMakeLists.txt:
--------------------------------------------------------------------------------
 1 | cmake_minimum_required(VERSION 3.12)
 2 | project(ping-cpp LANGUAGES CXX)
 3 | 
 4 | # Use standard C++ version and remove extensions to allow better compatibility
 5 | set(CMAKE_CXX_STANDARD 14)
 6 | set(CMAKE_CXX_EXTENSIONS OFF)
 7 | 
 8 | # Enable compile checks for msvc, clang and gcc
 9 | if(MSVC)
10 |   add_compile_options(/W4 /WX)
11 | else()
12 |   add_compile_options(-Wall -Wextra -pedantic -Werror)
13 |   # Can be removed moving to C++17, or we could move this library out from header only
14 |   add_compile_options(-Wno-unused-function)
15 | endif()
16 | 
17 | # Used for the command line interface
18 | find_package(Boost 1.67 COMPONENTS filesystem program_options REQUIRED)
19 | include_directories(${Boost_INCLUDE_DIR})
20 | 
21 | # Include modules
22 | add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/src)
23 | 
24 | option(PING_CPP_BUILD_TESTS "Build the test cases when PING_CPP_BUILD_TESTS is enabled." ON)
25 | 
26 | if (PING_CPP_BUILD_TESTS)
27 |     # Add fmt subdirectory
28 |     add_subdirectory(lib/fmt/)
29 | 
30 |     # test-device
31 |     add_executable(test-device)
32 |     target_include_directories(test-device PRIVATE lib/fmt/include/)
33 |     target_sources(
34 |         test-device
35 |     PRIVATE
36 |         test/test-device.cpp
37 |     )
38 |     target_link_libraries(
39 |         test-device
40 |     PRIVATE
41 |         DEVICE
42 |         HAL
43 |         PING_MESSAGES
44 |         ${Boost_LIBRARIES}
45 |         fmt::fmt
46 |     )
47 | 
48 |     # test-device-ping1d
49 |     add_executable(test-device-ping1d)
50 |     target_include_directories(test-device-ping1d PRIVATE lib/fmt/include/)
51 |     target_sources(
52 |         test-device-ping1d
53 |     PRIVATE
54 |         test/test-device-ping1d.cpp
55 |     )
56 |     target_link_libraries(
57 |         test-device-ping1d
58 |     PRIVATE
59 |         DEVICE
60 |         HAL
61 |         PING_MESSAGES
62 |         ${Boost_LIBRARIES}
63 |         fmt::fmt
64 |     )
65 | 
66 |     # test-device-ping360
67 |     add_executable(test-device-ping360)
68 |     target_include_directories(test-device-ping360 PRIVATE lib/fmt/include/)
69 |     target_sources(
70 |         test-device-ping360
71 |     PRIVATE
72 |         test/test-device-ping360.cpp
73 |     )
74 |     target_link_libraries(
75 |         test-device-ping360
76 |     PRIVATE
77 |         DEVICE
78 |         HAL
79 |         PING_MESSAGES
80 |         ${Boost_LIBRARIES}
81 |         fmt::fmt
82 |     )
83 | 
84 |     # test-message
85 |     add_executable(test-message)
86 |     target_include_directories(test-message PRIVATE lib/fmt/include/)
87 |     target_sources(
88 |         test-message
89 |     PRIVATE
90 |         test/test-message.cpp
91 |     )
92 |     target_link_libraries(
93 |         test-message
94 |     PRIVATE
95 |         PING_MESSAGES
96 |     )
97 | endif()
98 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # ping-cpp
 2 | 
 3 | [![Travis Test](https://travis-ci.com/bluerobotics/ping-cpp.svg?branch=master)](https://travis-ci.com/github/bluerobotics/ping-cpp)
 4 | [![Linux hardware test](https://github.com/bluerobotics/ping-cpp/actions/workflows/hardware-test.yml/badge.svg)](https://github.com/bluerobotics/ping-cpp/actions/workflows/hardware-test.yml)
 5 | 
 6 | C++ API implementation of [ping-protocol](https://docs.bluerobotics.com/ping-protocol/).
 7 | 
 8 | This repository has the ping_message base class, and templates + scripts to automatically generate device-specific message subclasses.
 9 | 
10 | ## Usage
11 | 
12 | #### Generated files
13 | 
14 | If you would like to use the C++ API in your project, checkout the [deployment branch](https://github.com/bluerobotics/ping-cpp/tree/deployment).
15 | 
16 | #### CMake project
17 | 
18 | The **master branch** can be used directly in CMake based projects for desktop or SBC applications.
19 | ##### Example
20 | 
21 | ```sh
22 | # Clone the repository
23 | git clone https://github.com/bluerobotics/ping-cpp
24 | cd ping-cpp
25 | # Update the submodules
26 | git submodule update --init --recursive
27 | # Configure and build the project in debug mode
28 | cmake -B build -DCMAKE_BUILD_TYPE=Debug && cmake --build build --parallel --config Debug
29 | # Connect a Ping device and use the correct USB as argument
30 | ./build/test-device --conn serial:/dev/ttyUSB0:115200
31 | # If you have a Ping1D connected, you can run the test program for the device
32 | ./build/test-device-ping1d --conn serial:/dev/ttyUSB0:115200
33 | ```
34 | 


--------------------------------------------------------------------------------
/cmake/CheckPython.cmake:
--------------------------------------------------------------------------------
 1 | # Check if python is installed with the necessary components
 2 | find_package(Python3 QUIET REQUIRED COMPONENTS Interpreter)
 3 | 
 4 | execute_process(
 5 |     COMMAND ${Python3_EXECUTABLE} -m pip show jinja2
 6 |     OUTPUT_QUIET
 7 |     RESULT_VARIABLE EXIT_CODE
 8 | )
 9 | 
10 | if(NOT ${EXIT_CODE} EQUAL 0)
11 |     message(
12 |         WARNING
13 |         "The Python3 package \"jinja2\" is not installed. We are going to install it."
14 |     )
15 | 
16 |     execute_process(
17 |         COMMAND ${Python3_EXECUTABLE} -m pip install jinja2 --user
18 |         RESULT_VARIABLE EXIT_CODE
19 |     )
20 | 
21 |     if(NOT ${EXIT_CODE} EQUAL 0)
22 |         message(
23 |             FATAL_ERROR
24 |             "Failed to install the Python3 package \"jinja2\". Make sure that pip3 is installed and working."
25 |         )
26 |     endif()
27 | 
28 | endif()
29 | 


--------------------------------------------------------------------------------
/src/CMakeLists.txt:
--------------------------------------------------------------------------------
 1 | # Include each sub folder
 2 | set(INCLUDE_DIRS
 3 |     device
 4 |     hal
 5 |     message
 6 | )
 7 | 
 8 | include(${PROJECT_SOURCE_DIR}/cmake/CheckPython.cmake)
 9 | 
10 | include_directories(${CMAKE_CURRENT_SOURCE_DIR} ${INCLUDE_DIRS})
11 | 
12 | foreach(directory ${INCLUDE_DIRS})
13 |     add_subdirectory(${directory})
14 | endforeach()
15 | 


--------------------------------------------------------------------------------
/src/device/CMakeLists.txt:
--------------------------------------------------------------------------------
 1 | cmake_minimum_required(VERSION 3.12)
 2 | project(DEVICE)
 3 | 
 4 | # Generate ping-cpp devices
 5 | add_custom_target(generate-devices
 6 |     COMMAND ${CMAKE_CURRENT_SOURCE_DIR}/../generate/generate-device.py --output-dir ${CMAKE_CURRENT_SOURCE_DIR}
 7 |     COMMENT "Generates ping device class."
 8 | BYPRODUCTS
 9 |     ${CMAKE_CURRENT_SOURCE_DIR}/ping-device-ping360.cpp
10 |     ${CMAKE_CURRENT_SOURCE_DIR}/ping-device-ping1d.cpp
11 | )
12 | 
13 | add_library(
14 |     DEVICE
15 | STATIC
16 |     ping-device-ping1d.cpp
17 |     ping-device-ping360.cpp
18 |     ping-device.cpp
19 | )
20 | 
21 | include_directories(${HAL_SOURCE_DIR})
22 | 
23 | target_link_libraries(
24 |     DEVICE
25 | PRIVATE
26 |     HAL
27 |     PING_MESSAGES
28 | )
29 | 
30 | target_include_directories(
31 |     DEVICE
32 | PUBLIC
33 |     ${CMAKE_CURRENT_SOURCE_DIR}
34 | )
35 | 
36 | add_dependencies(DEVICE generate-devices)
37 | 


--------------------------------------------------------------------------------
/src/device/ping-device.cpp:
--------------------------------------------------------------------------------
 1 | #include "ping-device.h"
 2 | 
 3 | #include <link/ping-port.h>
 4 | #include <time/ping-time.h>
 5 | 
 6 | #include <cstdio>
 7 | 
 8 | bool PingDevice::initialize() { return request(CommonId::PROTOCOL_VERSION) && request(CommonId::DEVICE_INFORMATION); }
 9 | 
10 | ping_message* PingDevice::read()
11 | {
12 |     uint8_t data;
13 |     int result = _port.read(&data, 1);
14 |     if (result != 0 && _parser.parseByte(data) == PingParser::State::NEW_MESSAGE) {
15 |         return &_parser.rxMessage;
16 |     }
17 |     return nullptr;
18 | }
19 | 
20 | ping_message PingDevice::message() { return _parser.rxMessage; }
21 | 
22 | ping_message* PingDevice::request(uint16_t id, int timeoutMs)
23 | {
24 |     _general_request.set_requested_id(id);
25 |     writeMessage(_general_request);
26 | 
27 |     ping_message* reply = waitMessage(id, timeoutMs);
28 |     if (reply && reply->message_id() == CommonId::NACK) {
29 |         common_nack* m = static_cast<common_nack*>(reply);
30 |         if (m->nacked_id() != CommonId::GENERAL_REQUEST) {
31 |             return nullptr;
32 |         }
33 |     }
34 | 
35 |     return reply;
36 | }
37 | 
38 | ping_message* PingDevice::waitMessage(uint16_t id, int timeoutMs)
39 | {
40 |     int timeStart = PingTime::timeMs();
41 |     while (PingTime::timeMs() < timeStart + timeoutMs) {
42 |         // TODO: make this totally nonblocking
43 |         // this will block up to 0.1s for data to be available
44 |         ping_message* message = read();
45 | 
46 |         if (!message) {
47 |             continue;
48 |         }
49 | 
50 |         _handleMessage(message);
51 | 
52 |         if (message->message_id() == id || message->message_id() == CommonId::NACK) {
53 |             return message;
54 |         }
55 |         // Prevent cpu spinlock
56 |         PingTime::yield();
57 |     }
58 | 
59 |     return nullptr;
60 | }
61 | 
62 | int PingDevice::write(const uint8_t* data, int nBytes) { return _port.write(data, nBytes); }
63 | 
64 | void PingDevice::writeMessage(ping_message& message)
65 | {
66 |     message.updateChecksum();
67 |     write(reinterpret_cast<uint8_t*>(message.msgData), message.msgDataLength());
68 | }
69 | 
70 | void PingDevice::_handleMessage(const ping_message* message)
71 | {
72 |     device_id = message->source_device_id();
73 | 
74 |     switch (message->message_id()) {
75 |     case CommonId::NACK:
76 |         break;
77 |     case CommonId::PROTOCOL_VERSION: {
78 |         const common_protocol_version* message_protocol_version = static_cast<const common_protocol_version*>(message);
79 |         protocol_version.version_major = message_protocol_version->version_major();
80 |         protocol_version.version_minor = message_protocol_version->version_minor();
81 |         protocol_version.version_patch = message_protocol_version->version_patch();
82 |         break;
83 |     }
84 |     case CommonId::DEVICE_INFORMATION: {
85 |         const common_device_information* message_device_information = static_cast<const common_device_information*>(message);
86 |         device_information.device_type = message_device_information->device_type();
87 |         device_information.device_revision = message_device_information->device_revision();
88 |         device_information.firmware_version_major = message_device_information->firmware_version_major();
89 |         device_information.firmware_version_minor = message_device_information->firmware_version_minor();
90 |         device_information.firmware_version_patch = message_device_information->firmware_version_patch();
91 |         break;
92 |     }
93 |     default:
94 |         break;
95 |     }
96 | }
97 | 


--------------------------------------------------------------------------------
/src/device/ping-device.h:
--------------------------------------------------------------------------------
  1 | #pragma once
  2 | 
  3 | #include <ping-message-common.h>
  4 | #include <ping-message.h>
  5 | #include <ping-parser.h>
  6 | 
  7 | class PingPort;
  8 | 
  9 | /**
 10 |  * A PingDevice class can be used to communicate with a
 11 |  * device implementing Blue Robotics ping-protocol*
 12 |  *
 13 |  * *only messages from the common message set are handled by the PingDevice
 14 |  * base class
 15 |  *
 16 |  * to use another message set, you should subclass PingDevice
 17 |  * and re-implement handleMessage
 18 |  */
 19 | class PingDevice {
 20 | public:
 21 |     /**
 22 |      *  @brief Constructor
 23 |      *
 24 |      *  @param port: The device io handle
 25 |      */
 26 |     PingDevice(PingPort& port)
 27 |         : _parser(4096)
 28 |         , _port(port)
 29 |     {
 30 |     }
 31 | 
 32 |     /**
 33 |      *  @brief Initialize the device by establishing communications and reading in some basic data
 34 |      *
 35 |      *  @return true if the device was successfully initialized
 36 |      */
 37 |     bool initialize();
 38 | 
 39 |     /**
 40 |      *  @brief Read in data from device, return a PingMessage if available.
 41 |      *  Data will be read in from device until there is no data left in the RX
 42 |      * buffer, or a valid PingMessage is successfully decoded. Note that there may
 43 |      * still be data available in the RX buffer for decoding when this function
 44 |      * returns a PingMessage.
 45 |      *
 46 |      *  @return: The next PingMessage from the device
 47 |      *  @return: null if the RX buffer is empty and no PingMessage has been
 48 |      * decoded
 49 |      */
 50 |     ping_message* read();
 51 | 
 52 |     /**
 53 |      * @brief Return the last available message by copy
 54 |      *
 55 |      * @return ping_message
 56 |      */
 57 |     ping_message message();
 58 | 
 59 |     /**
 60 |      *  @brief Request a ping_message from the device
 61 |      *
 62 |      *  @param id: The message ID to request
 63 |      *  @param timeoutMs: The timeout period to wait for the requested
 64 |      * ping_message to be received
 65 |      *
 66 |      *  @return The ping_message that was requested, or a nack message if the device nacked the request
 67 |      *  @return null if the device did not reply with the requested message or nack before
 68 |      * the timeout period expired
 69 |      *
 70 |      *  @par ex.
 71 |      *  @code
 72 |      *  ping_msg_ping1D_voltage_5 msg(*pd.request(Ping1dId::Voltage_5));
 73 |      *  @endcode
 74 |      */
 75 |     ping_message* request(uint16_t id, int timeoutMs = 500);
 76 | 
 77 |     /**
 78 |      *  @brief Wait for receipt of a message with a particular message id from
 79 |      * device
 80 |      *
 81 |      *  @param id: The message id to wait for
 82 |      *  @param timeoutMs: The timeout period to wait for a matching ping_message
 83 |      * to be received
 84 |      *
 85 |      *  @return The ping_message received with matching id, or a nack message if the device nacked the request
 86 |      *  @return null if the timeout expires and no matching ping_message or nack was received
 87 |      */
 88 |     ping_message* waitMessage(uint16_t id, int timeoutMs = 500);
 89 | 
 90 |     /**
 91 |      *  @brief Write data to device
 92 |      *
 93 |      *  @param data: pointer to buffer to write
 94 |      *  @param length: buffer length to write
 95 |      *
 96 |      *  @return: size of data buffer written to the device
 97 |      */
 98 |     int write(const uint8_t* data, int length);
 99 | 
100 |     /**
101 |      *  @brief Write a ping_message to the device. Before writing, the ping_messaage is \n
102 |      *  prepared by updating the checksum
103 |      *
104 |      *  @param message: a pointer to the ping_message
105 |      */
106 |     void writeMessage(ping_message& message);
107 | 
108 |     uint8_t device_id;
109 | 
110 |     struct {
111 |         uint8_t device_type;
112 |         uint8_t device_revision;
113 |         uint8_t firmware_version_major;
114 |         uint8_t firmware_version_minor;
115 |         uint8_t firmware_version_patch;
116 |     } device_information;
117 | 
118 |     struct {
119 |         uint8_t version_major;
120 |         uint8_t version_minor;
121 |         uint8_t version_patch;
122 |     } protocol_version;
123 | 
124 | protected:
125 |     /**
126 |      *  @brief Handle an incoming message from the device. This object's values \n
127 |      *  are updated according to the device data.
128 |      *
129 |      *  @param message: A pointer to the message received from the device
130 |      */
131 |     virtual void _handleMessage(const ping_message* message);
132 | 
133 | private:
134 |     PingParser _parser;
135 |     PingPort& _port;
136 | 
137 |     common_general_request _general_request;
138 | };
139 | 


--------------------------------------------------------------------------------
/src/generate/generate-device.py:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env python3
 2 | 
 3 | import argparse
 4 | import json
 5 | import os
 6 | from pathlib import Path
 7 | 
 8 | scriptPath = Path(__file__).parent.absolute()
 9 | generatorPath = "%s/../../lib/ping-protocol/src/" % scriptPath
10 | 
11 | import sys
12 | sys.path.append(generatorPath)
13 | 
14 | from generator import Generator
15 | 
16 | parser = argparse.ArgumentParser(description="generate markdown documentation files for message definitions")
17 | parser.add_argument('--output-directory', action="store", default="./", type=str, help="directory to save output files")
18 | args = parser.parse_args()
19 | 
20 | if not os.path.exists(args.output_directory):
21 |     os.makedirs(args.output_directory)
22 | 
23 | definitionPath = "%s/../../lib/ping-protocol/src/definitions" % scriptPath
24 | templatePath = "%s/templates" % scriptPath
25 | 
26 | g = Generator()
27 | 
28 | f = open("%s/ping-device-ping1d.h" % args.output_directory, "w")
29 | f.write(g.generate("%s/ping1d.json" % definitionPath, "%s/ping-device-ping1d.h.in" % templatePath))
30 | f.close()
31 | 
32 | f = open("%s/ping-device-ping1d.cpp" % args.output_directory, "w")
33 | f.write(g.generate("%s/ping1d.json" % definitionPath, "%s/ping-device-ping1d.cpp.in" % templatePath))
34 | f.close()
35 | 
36 | f = open("%s/ping-device-ping360.h" % args.output_directory, "w")
37 | f.write(g.generate("%s/ping360.json" % definitionPath, "%s/ping-device-ping360.h.in" % templatePath))
38 | f.close()
39 | 
40 | f = open("%s/ping-device-ping360.cpp" % args.output_directory, "w")
41 | f.write(g.generate("%s/ping360.json" % definitionPath, "%s/ping-device-ping360.cpp.in" % templatePath))
42 | f.close()


--------------------------------------------------------------------------------
/src/generate/generate-message.py:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env python3
 2 | 
 3 | import argparse
 4 | import json
 5 | import os
 6 | from pathlib import Path
 7 | 
 8 | scriptPath = Path(__file__).parent.absolute()
 9 | generatorPath = "%s/../../lib/ping-protocol/src/" % scriptPath
10 | 
11 | import sys
12 | sys.path.append(generatorPath)
13 | 
14 | from generator import Generator
15 | 
16 | parser = argparse.ArgumentParser(description="generate markdown documentation files for message definitions")
17 | parser.add_argument('--output-directory', action="store", default="./", type=str, help="directory to save output files")
18 | args = parser.parse_args()
19 | 
20 | if not os.path.exists(args.output_directory):
21 |     os.makedirs(args.output_directory)
22 | 
23 | definitionPath = "%s/../../lib/ping-protocol/src/definitions" % scriptPath
24 | templatePath = "%s/templates" % scriptPath
25 | templateFile = "%s/ping-message-.h.in" % templatePath
26 | 
27 | g = Generator()
28 | 
29 | definitions = [ "bluebps",
30 |                 "common",
31 |                 "ping1d",
32 |                 "ping360"]
33 | 
34 | # Create global json
35 | mergedJson = {"global": {}}
36 | for definition in definitions:
37 |     definitionFile = "%s/%s.json" % (definitionPath, definition)
38 |     mergedJson["global"][definition] = json.loads(open(definitionFile, 'r').read())
39 | 
40 | # Create message definitions for each sensor
41 | for definition in definitions:
42 |     f = open("%s/ping-message-%s.h" % (args.output_directory, definition), "w")
43 |     f.write(g.generate(mergedJson["global"][definition], templateFile, {"definition": definition}))
44 |     f.close()
45 | 
46 | # Create header with global information
47 | templateFileAll = "%s/ping-message-all.h.in" % templatePath
48 | f = open("%s/ping-message-all.h" % (args.output_directory), "w")
49 | f.write(g.generate(mergedJson, templateFileAll))
50 | f.close()
51 | 


--------------------------------------------------------------------------------
/src/generate/templates/ping-device-ping1d.cpp.in:
--------------------------------------------------------------------------------
 1 | #include "ping-device-ping1d.h"
 2 | #include <ping-message-common.h>
 3 | #include <ping-message-ping1d.h>
 4 | 
 5 | Ping1d::~Ping1d()
 6 | {
 7 | {% for msg in messages["get"]|sort %}
 8 | {% for field in messages["get"][msg].payload %}
 9 | {% if generator.is_vector(field.type) %}
10 |     if ({{msg}}_data.{{field.name}}) {
11 |         delete[] {{msg}}_data.{{field.name}};
12 |     }
13 | {% endif %}
14 | {% endfor %}
15 | {% endfor %}
16 | }
17 | 
18 | bool Ping1d::initialize(uint16_t pingIntervalMs)
19 | {
20 |     if (!PingDevice::initialize()) {
21 |         return false;
22 |     }
23 | 
24 |     // Configure ping interval
25 |     if (!set_ping_interval(pingIntervalMs)) {
26 |         return false;
27 |     }
28 | 
29 |     return true;
30 | }
31 | 
32 | void Ping1d::_handleMessage(const ping_message* message)
33 | {
34 |     switch (message->message_id()) {
35 | {% for msg in messages["get"]|sort %}
36 | {% if not messages["get"][msg].deprecated %}
37 |         case Ping1dId::{{msg|upper}}:
38 |         {
39 |             const ping1d_{{msg}}* message_{{msg}} = static_cast<const ping1d_{{msg}}*>(message);
40 | {% for field in messages["get"][msg].payload %}
41 | {% if generator.is_vector(field.type) %}
42 |             if (message_{{msg}}->{{field.name}}_length() > {{msg}}_data.{{field.name}}_length) {
43 |                 if ({{msg}}_data.{{field.name}}) {
44 |                     delete[] {{msg}}_data.{{field.name}};
45 |                 }
46 |                 {{msg}}_data.{{field.name}} = new {{generator.get_type_string(field.vector.datatype)}}[message_{{msg}}->{{field.name}}_length()];
47 |             }
48 | 
49 |             // If pointer is invalid, make sure to abort, there is no more memory!
50 |             if (profile_data.profile_data == nullptr) {
51 |                 {{msg}}_data.{{field.name}}_length = -1;
52 |                 return;
53 |             }
54 | 
55 |             {{msg}}_data.{{field.name}}_length = message_{{msg}}->{{field.name}}_length();
56 |             memcpy({{msg}}_data.{{field.name}}, message_{{msg}}->{{field.name}}(), message_{{msg}}->{{field.name}}_length());
57 | {% else %}
58 |             {{msg}}_data.{{field.name}} = message_{{msg}}->{{field.name}}();
59 | {% endif %}
60 | {% endfor %}
61 |         }
62 |         break;
63 | {% endif %}
64 | {% endfor %}
65 | 
66 |         default:
67 |             break;
68 |     }
69 | 
70 |     PingDevice::_handleMessage(message);
71 | }
72 | 
73 | {% for msg in messages["set"]|sort %}
74 | bool Ping1d::{{msg}}({% for field in messages["set"][msg].payload %}{{generator.get_type_string(field.type)}} _{{field.name}}, {% endfor %}bool verify)
75 | {
76 |     ping1d_{{msg}} message;
77 | {% for field in messages["set"][msg].payload %}
78 |     message.set_{{field.name}}(_{{field.name}});
79 | {% endfor %}
80 |     writeMessage(message);
81 |     // Check if we have a reply from the device
82 |     if (!request(Ping1dId::{{msg|replace("set_", "")|upper}})) {
83 |         return false;
84 |     }
85 |     // Read back the data and check that changes have been applied
86 |     if (verify
87 | {% if messages["set"][msg].payload %}
88 | {% if msg != "set_device_id" %}
89 |         && ({% for field in messages["set"][msg].payload %}{{msg|replace("set_", "")}}_data.{{field.name}} != _{{field.name}}{{ "\n        || " if not loop.last }}{% endfor %})) {
90 | {% else %}
91 |         && ({% for field in messages["set"][msg].payload %}{{field.name}} != _{{field.name}}{{ "\n        || " if not loop.last }}{% endfor %})) {
92 | {% endif %}
93 | {% endif %}
94 |         return false;
95 |     }
96 |     return true;
97 | }
98 | {% endfor %}
99 | 


--------------------------------------------------------------------------------
/src/generate/templates/ping-device-ping1d.h.in:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * A device API for the Blue Robotics Ping Echosounder
 3 |  *
 4 |  *~!~!~!~!~!~!~!~!~!~!~!~!~!~!~!~!~!~!~!~!~!~!~!~!~!~!~!~!~!
 5 |  * THIS IS AN AUTOGENERATED FILE
 6 |  * DO NOT EDIT
 7 |  *~!~!~!~!~!~!~!~!~!~!~!~!~!~!~!~!~!~!~!~!~!~!~!~!~!~!~!~!~!
 8 |  *
 9 |  */
10 | 
11 | #pragma once
12 | 
13 | #include "ping-device.h"
14 | 
15 | class Ping1d : public PingDevice
16 | {
17 | public:
18 |     /**
19 |      *  @brief Constructor
20 |      *
21 |      *  @param ser: The device I/O
22 |      */
23 |     Ping1d(PingPort& port) : PingDevice(port) {}
24 | 
25 |     /**
26 |      * @brief Destructor
27 |      */
28 |     ~Ping1d();
29 | 
30 |     /**
31 |      *  @brief Establish communications with the device, and initialize the update interval
32 |      *
33 |      *  @param pingIntervalMs: The interval (in milliseconds) between acoustic measurements
34 |      *
35 |      *  @return true if the device was initialized successfully
36 |      */
37 |     bool initialize(uint16_t pingIntervalMs = 50);
38 | 
39 | {% for msg in messages["set"] %}
40 |     /**
41 |      * @brief {{messages["set"][msg].description}}
42 |      *
43 | {% for field in messages["set"][msg].payload %}
44 |      * @param {{field.name}} - {% if field.units %}Units: {{field.units}}; {% endif %}{{field.description}}
45 | {% endfor %}
46 |      *
47 |      * @return when verify = false: true if a valid reply is received from the device.
48 |      * @return when verify = true: true if a valid reply is received from the
49 |      * device, and the values in the reply match the values that we applied
50 |      */
51 |     bool {{msg}}({% for field in messages["set"][msg].payload %}{{generator.get_type_string(field.type)}} {{field.name}}, {% endfor %}bool verify = true);
52 | 
53 | {% endfor %}
54 | 
55 | {% for msg in messages["get"]|sort %}
56 | {% if not messages["get"][msg].deprecated %}
57 |     //! {{messages["get"][msg].description}}
58 |     struct {
59 | {% for field in messages["get"][msg].payload %}
60 |         // {{field.description}}
61 | {% if not generator.is_vector(field.type) %}
62 |         {{generator.get_type_string(field.type)}} {{field.name}};
63 | {% else %}
64 |         {{generator.get_type_string(field.vector.datatype)}}* {{field.name}} = nullptr;
65 |         {{generator.get_type_string(field.vector.sizetype)}} {{field.name}}_length = 0;
66 | {% endif %}
67 | {% endfor %}
68 |     } {{msg}}_data;
69 | 
70 | {% endif %}
71 | {% endfor %}
72 | 
73 | private:
74 |     /**
75 |      *  @brief Handle an incoming message from the device. Internal values are updated according to the device data.
76 |      *
77 |      *  @param message: A pointer to the message received from the device
78 |      */
79 |     void _handleMessage(const ping_message* message) override;
80 | };
81 | 


--------------------------------------------------------------------------------
/src/generate/templates/ping-device-ping360.cpp.in:
--------------------------------------------------------------------------------
 1 | #include <ping-message-common.h>
 2 | #include "ping-message-ping360.h"
 3 | #include "ping-device-ping360.h"
 4 | 
 5 | Ping360::~Ping360()
 6 | {
 7 | {% for msg in messages["get"]|sort %}
 8 | {% for field in messages["get"][msg].payload %}
 9 | {% if generator.is_vector(field.type) %}
10 |     if ({{msg}}_data.{{field.name}}) {
11 |         delete[] {{msg}}_data.{{field.name}};
12 |     }
13 | {% endif %}
14 | {% endfor %}
15 | {% endfor %}
16 | }
17 | 
18 | bool Ping360::initialize()
19 | {
20 |     if (!PingDevice::initialize()) {
21 |         return false;
22 |     }
23 | 
24 |     return true;
25 | }
26 | 
27 | void Ping360::_handleMessage(const ping_message* message)
28 | {
29 |     switch (message->message_id()) {
30 | {% for msg in messages["get"]|sort %}
31 | {% if not messages["get"][msg].deprecated %}
32 |         case Ping360Id::{{msg|upper}}:
33 |         {
34 |             const ping360_{{msg}}* message_{{msg}} = static_cast<const ping360_{{msg}}*>(message);
35 | {% for field in messages["get"][msg].payload %}
36 | {% if generator.is_vector(field.type) %}
37 |             if (message_{{msg}}->{{field.name}}_length() > {{msg}}_data.{{field.name}}_length) {
38 |                 if ({{msg}}_data.{{field.name}}) {
39 |                     delete[] {{msg}}_data.{{field.name}};
40 |                 }
41 |                 {{msg}}_data.{{field.name}} = new {{generator.get_type_string(field.vector.datatype)}}[message_{{msg}}->{{field.name}}_length()];
42 |             }
43 | 
44 |             {{msg}}_data.{{field.name}}_length = message_{{msg}}->{{field.name}}_length();
45 |             memcpy({{msg}}_data.{{field.name}}, message_{{msg}}->{{field.name}}(), message_{{msg}}->{{field.name}}_length());
46 | {% else %}
47 |             {{msg}}_data.{{field.name}} = message_{{msg}}->{{field.name}}();
48 | {% endif %}
49 | {% endfor %}
50 |         }
51 |         break;
52 | {% endif %}
53 | {% endfor %}
54 | 
55 |         default:
56 |             break;
57 |     }
58 | 
59 |     PingDevice::_handleMessage(message);
60 | }
61 | 
62 | 
63 | {% for msg in messages["control"]|sort %}
64 | void Ping360::set_{{msg}}({% for field in messages["control"][msg].payload %}{{generator.get_type_string(field.type)}} _{{field.name}}{{ ", " if not loop.last else "" }}{% endfor %})
65 | {
66 |     ping360_{{msg}} message;
67 | {% for field in messages["control"][msg].payload %}
68 |     message.set_{{field.name}}(_{{field.name}});
69 | {% endfor %}
70 |     writeMessage(message);
71 | }
72 | 
73 | {% endfor %}
74 | 


--------------------------------------------------------------------------------
/src/generate/templates/ping-device-ping360.h.in:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * A device API for the Blue Robotics Ping Echosounder
 3 |  *
 4 |  *~!~!~!~!~!~!~!~!~!~!~!~!~!~!~!~!~!~!~!~!~!~!~!~!~!~!~!~!~!
 5 |  * THIS IS AN AUTOGENERATED FILE
 6 |  * DO NOT EDIT
 7 |  *~!~!~!~!~!~!~!~!~!~!~!~!~!~!~!~!~!~!~!~!~!~!~!~!~!~!~!~!~!
 8 |  *
 9 |  */
10 | 
11 | #pragma once
12 | 
13 | #include "ping-device.h"
14 | 
15 | class Ping360 : public PingDevice
16 | {
17 | public:
18 |     /**
19 |      *  @brief Constructor
20 |      *
21 |      *  @param ser: The device I/O
22 |      */
23 |     Ping360(PingPort& port) : PingDevice(port) {}
24 | 
25 |     /**
26 |      * @brief Destructor
27 |      */
28 |     ~Ping360();
29 | 
30 |     /**
31 |      *  @brief Establish communications with the device, and initialize the update interval
32 |      *
33 |      *  @param pingIntervalMs: The interval (in milliseconds) between acoustic measurements
34 |      *
35 |      *  @return true if the device was initialized successfully
36 |      */
37 |     bool initialize();
38 | 
39 | {% for msg in messages["control"] %}
40 |     /**
41 |      * @brief {{messages["control"][msg].description}}
42 |      *
43 | {% for field in messages["control"][msg].payload %}
44 |      * @param {{field.name}} - {% if field.units %}Units: {{field.units}}; {% endif %}{{field.description}}
45 | {% endfor %}
46 |      */
47 |     void set_{{msg}}({% for field in messages["control"][msg].payload %}{{generator.get_type_string(field.type)}} {{field.name}}{{ ", " if not loop.last else "" }}{% endfor %});
48 | 
49 | {% endfor %}
50 | 
51 | {% for msg in messages["get"]|sort %}
52 | {% if not messages["get"][msg].deprecated %}
53 |     //! {{messages["get"][msg].description}}
54 |     struct {
55 | {% for field in messages["get"][msg].payload %}
56 |         // {{field.description}}
57 | {% if not generator.is_vector(field.type) %}
58 |         {{generator.get_type_string(field.type)}} {{field.name}};
59 | {% else %}
60 |         {{generator.get_type_string(field.vector.datatype)}}* {{field.name}} = nullptr;
61 |         {{generator.get_type_string(field.vector.sizetype)}} {{field.name}}_length = 0;
62 | {% endif %}
63 | {% endfor %}
64 |     } {{msg}}_data;
65 | 
66 | {% endif %}
67 | {% endfor %}
68 | 
69 | private:
70 |     /**
71 |      *  @brief Handle an incoming message from the device. Internal values are updated according to the device data.
72 |      *
73 |      *  @param message: A pointer to the message received from the device
74 |      */
75 |     void _handleMessage(const ping_message* message) override;
76 | };
77 | 


--------------------------------------------------------------------------------
/src/generate/templates/ping-message-.h.in:
--------------------------------------------------------------------------------
  1 | // C++ implementation of the Blue Robotics 'Ping' binary message protocol
  2 | 
  3 | //~!~!~!~!~!~!~!~!~!~!~!~!~!~!~!~!~!~!~!~!~!~!~!~!~!~!~!~!~!
  4 | // THIS IS AN AUTOGENERATED FILE
  5 | // DO NOT EDIT
  6 | //~!~!~!~!~!~!~!~!~!~!~!~!~!~!~!~!~!~!~!~!~!~!~!~!~!~!~!~!~!
  7 | 
  8 | #pragma once
  9 | 
 10 | #include "ping-message.h"
 11 | 
 12 | // TODO: should maybe be an enum
 13 | namespace {{definition|capitalize}}Id
 14 | {
 15 | {% for message_type in messages %}
 16 | {% for message in messages[message_type] %}
 17 | {% set m = messages[message_type][message] %}
 18 | {% set class_name = "%s_%s" % (definition, message) %}
 19 |     static const uint16_t {{message|upper}} = {{m.id}};
 20 | {% endfor %}
 21 | {% endfor %}
 22 | }
 23 | 
 24 | {% for message_type in messages %}
 25 | {% for message in messages[message_type] %}
 26 | {% set m = messages[message_type][message] %}
 27 | {% set total_payload = generator.calc_payload(m.payload) %}
 28 | {% set class_name = "%s_%s" % (definition, message) %}
 29 | class {{class_name}} : public ping_message
 30 | {
 31 | public:
 32 |     {{class_name}}(const ping_message& msg) : ping_message { msg } {}
 33 |     {{class_name}}(uint8_t* buf
 34 | {%- for payload in m.payload %}
 35 | {% if generator.is_vector(payload.type) %},
 36 | {% if payload.vector.sizetype -%}
 37 |             {{generator.get_type_string(payload.vector.sizetype)}} {{payload.name}}_length
 38 | {% else -%}
 39 |             uint16_t {{payload.name}}_length
 40 | {%- endif %}
 41 | {% endif %}
 42 | {% endfor %}{# each payload field #}
 43 | ) : ping_message { buf, static_cast<uint16_t>({{8 + total_payload + 2}}
 44 | {%- for payload in m.payload %}
 45 | {% if generator.is_vector(payload.type) %}
 46 |  + {{payload.name}}_length
 47 | {%- endif %}
 48 | {% endfor %}) }{# each payload field #}
 49 | 
 50 |     {
 51 |         msgData[0] = 'B';
 52 |         msgData[1] = 'R';
 53 |         reinterpret_cast<uint16_t&>(msgData[2]) = static_cast<uint16_t>({{total_payload}}
 54 | {%- for payload in m.payload %}
 55 | {% if generator.is_vector(payload.type) %}
 56 |  + {{payload.name}}_length
 57 | {%- endif %}
 58 | {% endfor %}); // payload size
 59 |         reinterpret_cast<uint16_t&>(msgData[4]) = {{m.id}}; // ID
 60 |         msgData[6] = 0;
 61 |         msgData[7] = 0;
 62 |     }
 63 |     {{class_name}}(const uint8_t* buf, const uint16_t length) : ping_message { buf, length } {}
 64 |     {{class_name}}(
 65 | {%- for payload in m.payload %}
 66 | {% if generator.is_vector(payload.type) %}
 67 | {% if payload.vector.sizetype -%}
 68 |             {{generator.get_type_string(payload.vector.sizetype)}} {{payload.name}}_length
 69 | {% else -%}
 70 |             uint16_t {{payload.name}}_length
 71 | {%- endif %}
 72 | {% endif %}
 73 | {% endfor %}{# each payload field #}
 74 | ) : ping_message { static_cast<uint16_t>({{8 + total_payload + 2}}
 75 | {%- for payload in m.payload %}
 76 | {% if generator.is_vector(payload.type) %}
 77 |  + {{payload.name}}_length
 78 | {%- endif %}
 79 | {% endfor %}) }{# each payload field #}
 80 | 
 81 |     {
 82 |         msgData[0] = 'B';
 83 |         msgData[1] = 'R';
 84 |         reinterpret_cast<uint16_t&>(msgData[2]) = static_cast<uint16_t>({{total_payload}}
 85 | {%- for payload in m.payload %}
 86 | {% if generator.is_vector(payload.type) %}
 87 |  + {{payload.name}}_length
 88 | {%- endif %}
 89 | {% endfor %}); // payload size
 90 |         reinterpret_cast<uint16_t&>(msgData[4]) = {{m.id}}; // ID
 91 |         msgData[6] = 0;
 92 |         msgData[7] = 0;
 93 |     }
 94 | 
 95 | {% set byte = namespace(offset=0, func='') %}
 96 | {% if m.payload %}
 97 | {% for payload in m.payload %}
 98 | {% if generator.is_vector(payload.type) %}
 99 | {% if payload.vector.sizetype %}
100 |     {{generator.get_type_string(payload.vector.sizetype)}} {{payload.name}}_length() const { return reinterpret_cast<{{generator.get_type_string(payload.vector.sizetype)}}&>(msgData[headerLength + {{byte.offset}}]); }
101 |     //TODO do this in constructor (const)
102 |     void set_{{payload.name}}_length(const {{generator.get_type_string(payload.vector.sizetype)}} {{payload.name}}_length) { reinterpret_cast<{{generator.get_type_string(payload.vector.sizetype)}}&>(msgData[headerLength + {{byte.offset}}]) = {{payload.name}}_length;}
103 | {% set byte.offset = byte.offset + generator.get_c_size(payload.vector.sizetype) %}
104 | {% endif %}
105 |     {{generator.get_type_string(payload.vector.datatype)}}* {{payload.name}}() const { return reinterpret_cast<{{generator.get_type_string(payload.vector.datatype)}}*>(msgData+headerLength+{{byte.offset}}); }
106 |     void set_{{payload.name}}_at(const uint16_t i, const {{generator.get_type_string(payload.vector.datatype)}} data) { reinterpret_cast<{{generator.get_type_string(payload.vector.datatype)}}&>(msgData[headerLength + {{byte.offset}} + i]) = data; }
107 | {% else %}
108 |     {{generator.get_type_string(payload.type)}} {{payload.name}}() const { return reinterpret_cast<{{generator.get_type_string(payload.type)}}&>(msgData[headerLength + {{byte.offset}}]); }
109 |     void set_{{payload.name}}(const {{generator.get_type_string(payload.type)}} {{payload.name}}) { reinterpret_cast<{{generator.get_type_string(payload.type)}}&>(msgData[headerLength + {{byte.offset}}]) = {{payload.name}}; }
110 | {% set byte.offset = byte.offset + generator.get_c_size(payload.type) %}
111 | {% endif %}
112 | {% endfor %}
113 | {% endif %}
114 | {% if m.payload %}
115 | 
116 |     int getMessageAsString(char* string, size_t size) const {
117 |         int written = ping_message::getMessageAsString(string, size);
118 |         if (written > 0 && written < static_cast<int>(size)) {
119 |             return snprintf(string + written, size - static_cast<size_t>(written),
120 | {% for payload in m.payload %}
121 | {% if generator.is_vector(payload.type) %}
122 | {% if payload.vector.sizetype %}
123 | {% else %}
124 |                 "  {{payload.name}}: %s\n"
125 | {% endif %}
126 | {% else %}
127 |                 "  {{payload.name}}: %" {{generator.get_printf_format(payload.type)}} "\n"
128 | {% endif %}
129 | {% endfor %}
130 | {% for payload in m.payload %}
131 | {% if generator.is_vector(payload.type) %}
132 | {% if payload.vector.sizetype %}
133 | {% else %}
134 |                 , {{payload.name}}()
135 | {% endif %}
136 | {% else %}
137 |                 , {{payload.name}}()
138 | {% endif %}
139 | {% endfor %}
140 |             );
141 |         }
142 |         return written;
143 |     }
144 | {% endif %}
145 | };
146 | 
147 | {% endfor %}
148 | {% endfor %}
149 | 


--------------------------------------------------------------------------------
/src/generate/templates/ping-message-all.h.in:
--------------------------------------------------------------------------------
  1 | // C++ implementation of the Blue Robotics 'Ping' binary message protocol
  2 | 
  3 | //~!~!~!~!~!~!~!~!~!~!~!~!~!~!~!~!~!~!~!~!~!~!~!~!~!~!~!~!~!
  4 | // THIS IS AN AUTOGENERATED FILE
  5 | // DO NOT EDIT
  6 | //~!~!~!~!~!~!~!~!~!~!~!~!~!~!~!~!~!~!~!~!~!~!~!~!~!~!~!~!~!
  7 | 
  8 | #pragma once
  9 | 
 10 | {% for definition in global %}
 11 | #include "ping-message-{{definition}}.h"
 12 | {% endfor %}
 13 | 
 14 | // Declare an empty Q_NAMESPACE and Q_ENUM_NS if it's not a Qt project, otherwise include QObject
 15 | #ifndef QT_CORE_LIB
 16 | #define Q_NAMESPACE
 17 | #define Q_ENUM_NS(x)
 18 | #else
 19 | #include <QObject>
 20 | #endif
 21 | 
 22 | namespace PingEnumNamespace {
 23 | Q_NAMESPACE
 24 | enum class PingDeviceType {
 25 |     UNKNOWN = 0,
 26 |     PING1D = 1,
 27 |     PING360 = 2,
 28 |     PINGHF = 3,
 29 | };
 30 | Q_ENUM_NS(PingDeviceType)
 31 | 
 32 | enum class PingMessageId {
 33 | {% for definition in global %}
 34 | {% for messages in global[definition] %}
 35 | {% for message_type in global[definition][messages] %}
 36 | {% for message in global[definition][messages][message_type] %}
 37 |     {{definition|upper}}_{{message|upper}} = {{global[definition][messages][message_type][message].id}},
 38 | {% endfor %}
 39 | {% endfor %}
 40 | {% endfor %}
 41 | {% endfor %}
 42 | };
 43 | Q_ENUM_NS(PingMessageId)
 44 | }
 45 | 
 46 | using namespace PingEnumNamespace;
 47 | 
 48 | /**
 49 |  * @brief Ping Helper class
 50 |  *  All functions should be validated in compile time or static
 51 |  *
 52 |  */
 53 | class PingHelper {
 54 | public:
 55 |     /**
 56 |      * @brief Return a human friendly device name
 57 |      *
 58 |      * @param deviceType
 59 |      * @return constexpr const char*
 60 |      */
 61 |     static constexpr const char* nameFromDeviceType(const PingDeviceType deviceType) {
 62 |         switch(deviceType) {
 63 |             case(PingDeviceType::UNKNOWN):
 64 |                 return "UNKNOWN";
 65 |             case(PingDeviceType::PING1D):
 66 |                 return "Ping1D";
 67 |             case(PingDeviceType::PING360):
 68 |                 return "Ping360";
 69 |             case(PingDeviceType::PINGHF):
 70 |                 return "PingHF";
 71 |             default:
 72 |                 return "Unregistered";
 73 |         }
 74 |     }
 75 | 
 76 |     /**
 77 |      * @brief Helper function that provides the name of a message from the message ID number
 78 |      *
 79 |      * @param messageId
 80 |      * @return constexpr const char*
 81 |      */
 82 |     static constexpr const char* nameFromMessageId(const PingEnumNamespace::PingMessageId messageId) {
 83 |         switch(messageId) {
 84 | {% for definition in global %}
 85 | {% for messages in global[definition] %}
 86 | {% for message_type in global[definition][messages] %}
 87 | {% for message in global[definition][messages][message_type] %}
 88 |             case(PingEnumNamespace::PingMessageId::{{definition|upper}}_{{message|upper}}):
 89 |                 return "{{message|upper}}";
 90 | {% endfor %}
 91 | {% endfor %}
 92 | {% endfor %}
 93 | {% endfor %}
 94 |             default:
 95 |                 return "UNKNOWN";
 96 |         }
 97 |     }
 98 | 
 99 | private:
100 |     PingHelper() = default;
101 |     ~PingHelper() = default;
102 | };
103 | 


--------------------------------------------------------------------------------
/src/hal/CMakeLists.txt:
--------------------------------------------------------------------------------
 1 | cmake_minimum_required(VERSION 3.12)
 2 | project(HAL)
 3 | 
 4 | find_package(Boost 1.67 COMPONENTS atomic program_options system thread REQUIRED)
 5 | find_package(Threads)
 6 | include_directories(${Boost_INCLUDE_DIR})
 7 | 
 8 | add_library(
 9 |     HAL
10 |     link/desktop/abstract-link.cpp
11 |     link/desktop/serial-link.cpp
12 |     link/desktop/udp-link.cpp
13 |     time/desktop/ping-time.cpp
14 | )
15 | 
16 | target_include_directories(
17 |     HAL
18 | PUBLIC
19 |     ${CMAKE_CURRENT_SOURCE_DIR}
20 | )
21 | 
22 | target_link_libraries(
23 |     HAL
24 | LINK_PUBLIC
25 |     ${Boost_LIBRARIES}
26 |     ${CMAKE_THREAD_LIBS_INIT}
27 | )
28 | 


--------------------------------------------------------------------------------
/src/hal/link/desktop/abstract-link.cpp:
--------------------------------------------------------------------------------
 1 | #include "abstract-link.h"
 2 | #include "serial-link.h"
 3 | #include "udp-link.h"
 4 | 
 5 | // TODO: Remove this
 6 | #include <iostream>
 7 | 
 8 | #include <boost/format.hpp>
 9 | #include <boost/xpressive/xpressive.hpp>
10 | 
11 | /**
12 |  * @brief Accepts inputs with format described in `openUrl`
13 |  *
14 |  */
15 | const char* AbstractLink::_urlStringRegex = R"((?P<type>udp|serial):(?P<host>.*):(?P<config>\d+))";
16 | 
17 | std::shared_ptr<AbstractLink> AbstractLink::openUrl(const std::string& url)
18 | {
19 |     if (url.empty()) {
20 |         std::cerr << "Empty URL was provided when trying to open a link" << std::endl;
21 |         return {};
22 |     }
23 | 
24 |     const auto regex = boost::xpressive::sregex::compile(_urlStringRegex);
25 |     boost::xpressive::smatch match;
26 | 
27 |     struct {
28 |         std::string type;
29 |         std::string host;
30 |         std::string config;
31 |     } urlStruct;
32 | 
33 |     if (!regex_search(url, match, regex)) {
34 |         std::cerr << "Invalid URL provided, should be in format `type:host:config`" << std::endl;
35 |         return {};
36 |     }
37 | 
38 | #if __cplusplus >= 201703L
39 | #warning "Move match strings to string_view and concatenate it with regex string inside the named regex match"
40 | #endif
41 |     urlStruct.type = match["type"].str();
42 |     urlStruct.host = match["host"].str();
43 |     urlStruct.config = match["config"].str();
44 | 
45 |     if (urlStruct.type == "serial") {
46 |         return std::make_shared<SerialLink>(urlStruct.host, std::stoi(urlStruct.config));
47 |     } else if (urlStruct.type == "udp") {
48 |         return std::make_shared<UdpLink>(urlStruct.host, urlStruct.config);
49 |     }
50 | 
51 |     std::cerr << "Unknown link type provided" << std::endl;
52 |     return {};
53 | }
54 | 


--------------------------------------------------------------------------------
/src/hal/link/desktop/abstract-link.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <memory>
 4 | #include <vector>
 5 | 
 6 | #include <boost/signals2.hpp>
 7 | 
 8 | #include "../ping-port.h"
 9 | 
10 | /**
11 |  * @brief AbstractLink for desktop like links
12 |  *
13 |  */
14 | class AbstractLink : public PingPort {
15 | public:
16 |     AbstractLink() = default;
17 |     virtual ~AbstractLink() = default;
18 | 
19 |     /**
20 |      * @brief Construct and return an owner smart pointer for the link class
21 |      *
22 |      * @param url Should follow TYPE:HOST:CONFIGURATION format.
23 |      *  Eg: udp:0.0.0.0:12345 or serial:/dev/ttyUSB0:115200
24 |      *  Possible types right now are only udp and serial.
25 |      *
26 |      * @return std::shared_ptr<AbstractLink>
27 |      */
28 |     static std::shared_ptr<AbstractLink> openUrl(const std::string& url);
29 | 
30 |     /**
31 |      * @brief Close link connection
32 |      *
33 |      */
34 |     virtual void close() = 0;
35 | 
36 |     /**
37 |      * @brief Check if link is open
38 |      *
39 |      * @return true
40 |      * @return false
41 |      */
42 |     virtual bool isOpen() = 0;
43 | 
44 |     /**
45 |      * @brief Allow connections via functions or binds when data is received from link
46 |      *
47 |      * @param slot
48 |      * @return boost::signals2::connection
49 |      */
50 |     boost::signals2::connection doOnReceived(std::function<void(std::vector<uint8_t>)> slot)
51 |     {
52 |         return _onReceived.connect(slot);
53 |     }
54 | 
55 | protected:
56 |     boost::signals2::signal<void(std::vector<uint8_t>)> _onReceived;
57 | 
58 | private:
59 |     // Shame on you, this is and should not be shared!
60 |     // This class should only be an abstract class that provides the construction for any registered link
61 |     AbstractLink(const AbstractLink&) = delete;
62 |     AbstractLink& operator=(const AbstractLink&) = delete;
63 | 
64 |     static const char* _urlStringRegex;
65 | };
66 | 


--------------------------------------------------------------------------------
/src/hal/link/desktop/serial-link.cpp:
--------------------------------------------------------------------------------
  1 | #include <algorithm>
  2 | #include <iostream>
  3 | #include <memory>
  4 | #include <string>
  5 | #include <thread>
  6 | 
  7 | #include "serial-link.h"
  8 | 
  9 | using boost::asio::serial_port_base;
 10 | 
 11 | SerialLink::SerialLink(const std::string& port, uint32_t baudrate)
 12 |     : AbstractLink()
 13 |     , _context()
 14 |     , _serialPort(_context.eventLoop)
 15 |     , _rxBuffer(4096)
 16 | {
 17 |     using namespace boost;
 18 | 
 19 |     // Open and do the necessary configuration for the serial port
 20 |     try {
 21 |         _serialPort.open(port);
 22 |         _serialPort.set_option(serial_port_base::baud_rate(baudrate));
 23 |         _serialPort.set_option(serial_port_base::character_size(8));
 24 |         _serialPort.set_option(serial_port_base::parity(serial_port_base::parity::none));
 25 |         _serialPort.set_option(serial_port_base::stop_bits(serial_port_base::stop_bits::one));
 26 |         _serialPort.set_option(asio::serial_port_base::character_size(8));
 27 | 
 28 |         // We should remove flow control to make sure that will work in any case
 29 |         _serialPort.set_option(asio::serial_port::flow_control(asio::serial_port::flow_control::none));
 30 |     } catch (const std::exception& exception) {
 31 |         std::cerr << "Error while configuring serial port: " << exception.what() << std::endl;
 32 |         close();
 33 |         return;
 34 |     }
 35 | 
 36 |     // Bind event loop start with the async read schedulement
 37 |     boost::asio::post(_context.eventLoop, boost::bind(&SerialLink::bindRead, this));
 38 | 
 39 |     runEventLoop();
 40 | 
 41 |     // Start Automatic Baud Rate procedure
 42 |     _serialPort.send_break();
 43 |     std::this_thread::sleep_for(std::chrono::milliseconds(10));
 44 |     _serialPort.write_some(asio::buffer("UUUUUUUUUU"));
 45 | }
 46 | 
 47 | SerialLink::~SerialLink()
 48 | {
 49 |     close();
 50 | 
 51 |     // Ask context to finish and wait for it
 52 |     _context.run = false;
 53 |     _context.future.wait();
 54 | }
 55 | 
 56 | void SerialLink::runEventLoop()
 57 | {
 58 |     // Allow event loop to run, for now
 59 |     _context.run = true;
 60 |     _context.future = std::async(std::launch::async, [this] {
 61 |         // Run event loop
 62 |         while (_context.run) {
 63 |             using namespace std::chrono_literals;
 64 |             try {
 65 |                 _context.eventLoop.run_for(100ms);
 66 |             } catch (const std::exception& exception) {
 67 |                 std::cerr << "Event loop failed to run: " << exception.what() << std::endl;
 68 |             }
 69 |         }
 70 |         _context.eventLoop.stop();
 71 |     });
 72 | }
 73 | 
 74 | void SerialLink::bindRead()
 75 | {
 76 |     using namespace boost;
 77 | 
 78 |     _serialPort.async_read_some(asio::buffer(_rxBuffer),
 79 |         boost::bind(
 80 |             &SerialLink::doRead, this, asio::placeholders::error, asio::placeholders::bytes_transferred));
 81 | }
 82 | 
 83 | void SerialLink::doRead(boost::system::error_code error, size_t bytesReceived)
 84 | {
 85 |     if (error) {
 86 |         // The read can canceled by someone else or when class is deleted
 87 |         if (error.value() == boost::system::errc::operation_canceled) {
 88 |             return;
 89 |         }
 90 |         // That's sad, something is really wrong!
 91 |         std::cerr << "Error while reading from serial port: " << error.message() << std::endl;
 92 |         // Close the serial port and abort
 93 |         if (_serialPort.is_open()) {
 94 |             _serialPort.close();
 95 |         }
 96 |         return;
 97 |     }
 98 | 
 99 |     // We got something
100 |     if (bytesReceived) {
101 |         // Notify signal that we got something
102 |         const std::vector<uint8_t> output(std::cbegin(_rxBuffer), std::next(std::cbegin(_rxBuffer), bytesReceived));
103 |         // Emit signal
104 |         _onReceived(output);
105 | 
106 |         // Update our shared buffer
107 |         _linkBuffer.mutex.lock();
108 |         _linkBuffer.data.insert(
109 |             std::end(_linkBuffer.data), std::begin(_rxBuffer), std::next(std::begin(_rxBuffer), bytesReceived));
110 |         _linkBuffer.mutex.unlock();
111 |     }
112 | 
113 |     // Schedule a new async read
114 |     bindRead();
115 | }
116 | 
117 | int SerialLink::read(uint8_t* buffer, int nBytes)
118 | {
119 |     _linkBuffer.mutex.lock();
120 |     // Check for the valid amount of data that we can give
121 |     const int amount = std::min(nBytes, static_cast<int>(_linkBuffer.data.size()));
122 |     std::copy_n(std::begin(_linkBuffer.data), amount, buffer);
123 |     // Erase bytes that was copied and update out shared buffer
124 |     _linkBuffer.data.erase(_linkBuffer.data.begin(), std::next(_linkBuffer.data.begin(), amount));
125 |     _linkBuffer.mutex.unlock();
126 | 
127 |     return amount;
128 | }
129 | 
130 | int SerialLink::write(const uint8_t* data, int nBytes)
131 | {
132 |     _serialPort.async_write_some(boost::asio::buffer(data, nBytes),
133 |         [](const boost::system::error_code& error, std::size_t /*bytes_transferred*/) {
134 |             if (error) {
135 |                 std::cout << "Error while writing in serial port: " << error.message() << std::endl;
136 |             }
137 |         });
138 | 
139 |     return nBytes;
140 | }
141 | 


--------------------------------------------------------------------------------
/src/hal/link/desktop/serial-link.h:
--------------------------------------------------------------------------------
  1 | #pragma once
  2 | 
  3 | #include <array>
  4 | #include <atomic>
  5 | #include <future>
  6 | #include <memory>
  7 | #include <mutex>
  8 | #include <string>
  9 | 
 10 | #include <boost/asio.hpp>
 11 | #include <boost/bind.hpp>
 12 | 
 13 | #include "abstract-link.h"
 14 | 
 15 | #include <iostream>
 16 | 
 17 | /**
 18 |  * @brief Serial class
 19 |  *  Works with linux, windows and mac
 20 |  *
 21 |  */
 22 | class SerialLink : public AbstractLink {
 23 | public:
 24 |     /**
 25 |      * @brief Construct a new Serial Link object
 26 |      *
 27 |      * @param port
 28 |      * @param baudrate
 29 |      */
 30 |     SerialLink(const std::string& port, uint32_t baudrate);
 31 | 
 32 |     /**
 33 |      * @brief Destroy the Serial Link object
 34 |      * This will also close and kill the event loop
 35 |      *
 36 |      */
 37 |     ~SerialLink();
 38 | 
 39 |     /**
 40 |      * @brief Close link
 41 |      *
 42 |      */
 43 |     virtual void close() override final { _serialPort.close(); };
 44 | 
 45 |     /**
 46 |      * @brief Check if link is open
 47 |      *
 48 |      * @return true
 49 |      * @return false
 50 |      */
 51 |     virtual bool isOpen() override final { return _serialPort.is_open(); };
 52 | 
 53 |     /**
 54 |      * @brief Copy bytes from our internal buffer to `buffer` argument
 55 |      *
 56 |      * @param buffer Array that the data will be provided
 57 |      * @param nBytes Number of bytes that `buffer` can handle
 58 |      * @return int The real number of bytes that was transferred to `buffer`
 59 |      */
 60 |     virtual int read(uint8_t* buffer, int nBytes) override final;
 61 | 
 62 |     /**
 63 |      * @brief Send bytes to link
 64 |      *
 65 |      * @param data Array that contain data that will be transferred to link
 66 |      * @param nBytes Number of bytes that `data` contains
 67 |      * @return int The real number of bytes that was transferred,
 68 |      *  since this class uses async read and async write to be faster than light,
 69 |      *  it's not possible to confirm the number of bytes that was successfully transferred.
 70 |      */
 71 |     virtual int write(const uint8_t* data, int nBytes) override final;
 72 | 
 73 | private:
 74 |     SerialLink(const SerialLink&) = delete;
 75 |     const SerialLink& operator=(const SerialLink&) = delete;
 76 | 
 77 |     /**
 78 |      * @brief Start event loop process
 79 |      *
 80 |      */
 81 |     void runEventLoop();
 82 | 
 83 |     /**
 84 |      * @brief Schedule an async read event
 85 |      *
 86 |      */
 87 |     void bindRead();
 88 | 
 89 |     /**
 90 |      * @brief Async event callback
 91 |      *
 92 |      * @param error Error code
 93 |      * @param bytesReceived Number of bytes received
 94 |      */
 95 |     void doRead(boost::system::error_code error, size_t bytesReceived);
 96 | 
 97 |     /**
 98 |      * @brief Deal with the async event loop
 99 |      *  run: Will control if the event loop will run or not
100 |      *  future: Will check if the event loop was able to finish
101 |      */
102 |     struct {
103 |         std::atomic<bool> run;
104 |         boost::asio::io_context eventLoop;
105 |         std::future<void> future;
106 |     } _context;
107 | 
108 |     boost::asio::serial_port _serialPort;
109 | 
110 |     // Buffer used to async read
111 |     std::vector<uint8_t> _rxBuffer;
112 | 
113 |     /**
114 |      * @brief Buffer used to transfer data between async read and our public `read` function.
115 |      *  This is necessary to avoid any problem of simultaneous `read` call while async read is received.
116 |      */
117 |     struct {
118 |         std::vector<uint8_t> data;
119 |         std::mutex mutex;
120 |     } _linkBuffer;
121 | };
122 | 


--------------------------------------------------------------------------------
/src/hal/link/desktop/udp-link.cpp:
--------------------------------------------------------------------------------
  1 | #include <memory>
  2 | #include <string>
  3 | 
  4 | #include <iostream>
  5 | 
  6 | #include "udp-link.h"
  7 | 
  8 | UdpLink::UdpLink(const std::string& host, const std::string& port)
  9 |     : AbstractLink()
 10 |     , _context()
 11 |     , _socket(_context.eventLoop)
 12 |     , _rxBuffer(4096)
 13 | {
 14 |     using namespace boost;
 15 | 
 16 |     // Identify endpoint from host and port
 17 |     _endpoint = asio::ip::udp::endpoint(asio::ip::make_address(host), std::stoi(port));
 18 | 
 19 |     // Do async connection request, schedule an async read operation if connection was successful
 20 |     _socket.async_connect(_endpoint, boost::bind(&UdpLink::connectionHandle, this, asio::placeholders::error));
 21 | 
 22 |     runEventLoop();
 23 | }
 24 | 
 25 | UdpLink::~UdpLink()
 26 | {
 27 |     close();
 28 | 
 29 |     // Ask context to finish and wait for it
 30 |     _context.run = false;
 31 |     _context.future.get();
 32 | }
 33 | 
 34 | void UdpLink::runEventLoop()
 35 | {
 36 |     // Allow event loop to run, for now
 37 |     _context.run = true;
 38 |     _context.future = std::async(std::launch::async, [this] {
 39 |         // Run event loop
 40 |         while (_context.run) {
 41 |             using namespace std::chrono_literals;
 42 |             try {
 43 |                 _context.eventLoop.run_for(100ms);
 44 |             } catch (const std::exception& exception) {
 45 |                 std::cerr << "Event loop failed to run:" << exception.what() << std::endl;
 46 |             }
 47 |         }
 48 |     });
 49 | }
 50 | 
 51 | void UdpLink::connectionHandle(boost::system::error_code const& error)
 52 | {
 53 |     if (error) {
 54 |         std::cerr << "Error while connecting with socket:" << error.message() << std::endl;
 55 |         return;
 56 |     }
 57 | 
 58 |     bindRead();
 59 | 
 60 |     // Send something to allow UDP server to know that we exist
 61 |     write({0, 255}); // Send a full low byte and a full high byte to trigger any hardware event
 62 | }
 63 | 
 64 | void UdpLink::bindRead()
 65 | {
 66 |     using namespace boost;
 67 | 
 68 |     _socket.async_receive(asio::buffer(_rxBuffer),
 69 |         boost::bind(
 70 |             &UdpLink::doRead, this, asio::placeholders::error, asio::placeholders::bytes_transferred));
 71 | }
 72 | 
 73 | void UdpLink::doRead(boost::system::error_code error, size_t bytesReceived)
 74 | {
 75 |     if (error) {
 76 |         // The read can canceled by someone else or when class is deleted
 77 |         if (error.value() == boost::system::errc::operation_canceled) {
 78 |             return;
 79 |         }
 80 |         // That's sad, something is really wrong!
 81 |         std::cerr << "Error while reading socket: " << error.message() << std::endl;
 82 |         // Close the socket and abort
 83 |         if (_socket.is_open()) {
 84 |             _socket.close();
 85 |         }
 86 | 
 87 |         return;
 88 |     }
 89 | 
 90 |     // We got something
 91 |     if (bytesReceived) {
 92 |         // Notify signal that we got something
 93 |         const std::vector<uint8_t> output(std::cbegin(_rxBuffer), std::next(std::cbegin(_rxBuffer), bytesReceived));
 94 |         // Emit signal
 95 |         _onReceived(output);
 96 | 
 97 |         // Update our shared buffer
 98 |         _linkBuffer.mutex.lock();
 99 |         _linkBuffer.data.insert(
100 |             std::end(_linkBuffer.data), std::begin(_rxBuffer), std::next(std::begin(_rxBuffer), bytesReceived));
101 |         _linkBuffer.mutex.unlock();
102 |     }
103 | 
104 |     // Schedule a new async read
105 |     bindRead();
106 | }
107 | 
108 | int UdpLink::read(uint8_t* buffer, int nBytes)
109 | {
110 |     _linkBuffer.mutex.lock();
111 |     // Check for the valid amount of data that we can give
112 |     const int amount = std::min(nBytes, static_cast<int>(_linkBuffer.data.size()));
113 |     std::copy_n(std::begin(_linkBuffer.data), amount, buffer);
114 |     // Erase bytes that was copied and update out shared buffer
115 |     _linkBuffer.data.erase(_linkBuffer.data.begin(), std::next(_linkBuffer.data.begin(), amount));
116 |     _linkBuffer.mutex.unlock();
117 |     return amount;
118 | }
119 | 
120 | int UdpLink::write(const uint8_t* data, int nBytes)
121 | {
122 |     _socket.async_send(
123 |         boost::asio::buffer(data, nBytes), [this](boost::system::error_code error, size_t /*bytes_transferred*/) {
124 |             if (error) {
125 |                 std::cerr << "Error while sending data to socket: " << _endpoint.address().to_string() << ":"
126 |                           << _endpoint.port() << std::endl;
127 |                 std::cerr << "Error: " << error.category().name() << " " << error.message() << std::endl;
128 |             }
129 |         });
130 | 
131 |     return nBytes;
132 | }
133 | 
134 | void UdpLink::write(const std::vector<uint8_t>& vector) { write(vector.data(), vector.size()); }
135 | 


--------------------------------------------------------------------------------
/src/hal/link/desktop/udp-link.h:
--------------------------------------------------------------------------------
  1 | #pragma once
  2 | 
  3 | #include <memory>
  4 | #include <string>
  5 | 
  6 | #include <boost/asio.hpp>
  7 | #include <boost/bind.hpp>
  8 | 
  9 | #include "abstract-link.h"
 10 | 
 11 | #include <iostream>
 12 | 
 13 | class UdpLink : public AbstractLink {
 14 | public:
 15 |     UdpLink(const std::string& host, const std::string& port);
 16 |     ~UdpLink();
 17 | 
 18 |     /**
 19 |      * @brief Close link
 20 |      *
 21 |      */
 22 |     virtual void close() override final { _socket.close(); };
 23 | 
 24 |     /**
 25 |      * @brief Check if link is open
 26 |      *
 27 |      * @return true
 28 |      * @return false
 29 |      */
 30 |     virtual bool isOpen() override final { return _socket.is_open(); };
 31 | 
 32 |     /**
 33 |      * @brief Copy bytes from our internal buffer to `buffer` argument
 34 |      *
 35 |      * @param buffer Array that the data will be provided
 36 |      * @param nBytes Number of bytes that `buffer` can handle
 37 |      * @return int The real number of bytes that was transferred to `buffer`
 38 |      */
 39 |     virtual int read(uint8_t* buffer, int nBytes) override final;
 40 | 
 41 |     /**
 42 |      * @brief Send bytes to link
 43 |      *
 44 |      * @param data Array that contain data that will be transferred to link
 45 |      * @param nBytes Number of bytes that `data` contains
 46 |      * @return int The real number of bytes that was transferred,
 47 |      *  since this class uses async read and async write to be faster than light,
 48 |      *  it's not possible to confirm the number of bytes that was successfully transferred.
 49 |      */
 50 |     virtual int write(const uint8_t* data, int nBytes) override final;
 51 | 
 52 |     /**
 53 |      * @brief Write data from vector to link
 54 |      *
 55 |      * @param vector
 56 |      */
 57 |     void write(const std::vector<uint8_t>& vector);
 58 | 
 59 | private:
 60 |     UdpLink(const UdpLink&) = delete;
 61 |     const UdpLink& operator=(const UdpLink&) = delete;
 62 | 
 63 |     /**
 64 |      * @brief Start event loop process
 65 |      *
 66 |      */
 67 |     void runEventLoop();
 68 | 
 69 |     /**
 70 |      * @brief Connection handle callback
 71 |      *
 72 |      * @param error
 73 |      */
 74 |     void connectionHandle(boost::system::error_code const& error);
 75 | 
 76 |     /**
 77 |      * @brief Schedule an async read event
 78 |      *
 79 |      */
 80 |     void bindRead();
 81 | 
 82 |     /**
 83 |      * @brief Async event callback
 84 |      *
 85 |      * @param error Error code
 86 |      * @param bytesReceived Number of bytes received
 87 |      */
 88 |     void doRead(boost::system::error_code error, size_t bytesReceived);
 89 | 
 90 |     /**
 91 |      * @brief Deal with the async event loop
 92 |      *  run: Will control if the event loop will run or not
 93 |      *  future: Will check if the event loop was able to finish
 94 |      */
 95 |     struct {
 96 |         std::atomic<bool> run;
 97 |         boost::asio::io_context eventLoop;
 98 |         std::future<void> future;
 99 |     } _context;
100 | 
101 |     boost::asio::ip::udp::socket _socket;
102 |     boost::asio::ip::udp::endpoint _endpoint;
103 | 
104 |     // Buffer used to async read
105 |     std::vector<uint8_t> _rxBuffer;
106 | 
107 |     /**
108 |      * @brief Buffer used to transfer data between async read and our public `read` function.
109 |      *  This is necessary to avoid any problem of simultaneous `read` call while async read is received.
110 |      */
111 |     struct {
112 |         std::vector<uint8_t> data;
113 |         std::mutex mutex;
114 |     } _linkBuffer;
115 | };
116 | 


--------------------------------------------------------------------------------
/src/hal/link/ping-port.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <stdint.h>
 4 | 
 5 | // port interface used by PingDevice class
 6 | class PingPort {
 7 | public:
 8 |     virtual int read(uint8_t* buffer, int nBytes) = 0;
 9 |     virtual int write(const uint8_t* data, int nBytes) = 0;
10 | };
11 | 


--------------------------------------------------------------------------------
/src/hal/time/desktop/ping-time.cpp:
--------------------------------------------------------------------------------
 1 | #include "../ping-time.h"
 2 | 
 3 | #include <chrono>
 4 | #include <thread>
 5 | 
 6 | int PingTime::timeMs()
 7 | {
 8 |     auto now = std::chrono::steady_clock::now();
 9 | 
10 |     auto duration = now.time_since_epoch();
11 |     auto durationMs = std::chrono::duration_cast<std::chrono::milliseconds>(duration);
12 | 
13 |     return durationMs.count();
14 | }
15 | 
16 | void PingTime::microsecondDelay(unsigned int microseconds)
17 | {
18 |     std::this_thread::sleep_for(std::chrono::microseconds(microseconds));
19 | }
20 | 
21 | void PingTime::yield() { std::this_thread::yield(); }
22 | 


--------------------------------------------------------------------------------
/src/hal/time/ping-time.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | /**
 4 |  * @brief Abstract namespace to allow usage between different implementations
 5 |  *
 6 |  */
 7 | namespace PingTime {
 8 | void microsecondDelay(unsigned int microseconds);
 9 | int timeMs();
10 | void yield();
11 | }
12 | 


--------------------------------------------------------------------------------
/src/message/CMakeLists.txt:
--------------------------------------------------------------------------------
 1 | cmake_minimum_required(VERSION 3.12)
 2 | project(PING_MESSAGES)
 3 | 
 4 | # Check if python is installed with the necessary components
 5 | find_package(Python3 QUIET REQUIRED COMPONENTS Interpreter)
 6 | 
 7 | add_custom_target(generate-messages
 8 |   # generate ping messages
 9 |   COMMAND ${CMAKE_CURRENT_SOURCE_DIR}/../generate/generate-message.py --output-dir ${CMAKE_CURRENT_SOURCE_DIR}/../message
10 |   COMMENT "Generates ping messages"
11 | )
12 | 
13 | add_library(PING_MESSAGES INTERFACE)
14 | 
15 | set(PING_CPP_INCLUDE_DIR ${CMAKE_CURRENT_SOURCE_DIR})
16 | 
17 | include_directories(${PING_CPP_INCLUDE_DIR})
18 | target_include_directories(PING_MESSAGES INTERFACE ${PING_CPP_INCLUDE_DIR})
19 | target_link_libraries(PING_MESSAGES)
20 | 
21 | add_dependencies(PING_MESSAGES generate-messages)
22 | 


--------------------------------------------------------------------------------
/src/message/ping-message.h:
--------------------------------------------------------------------------------
  1 | // C++ implementation of the Blue Robotics 'Ping' binary message protocol
  2 | 
  3 | #pragma once
  4 | #include <inttypes.h>
  5 | #include <string.h>
  6 | #include <stdlib.h>
  7 | #include <stdio.h>
  8 | 
  9 | class ping_message
 10 | {
 11 | public:
 12 |     ping_message() : msgData { nullptr } {}
 13 | 
 14 |     ping_message(const ping_message &msg)
 15 |         : _bufferLength { msg.msgDataLength() }
 16 |         , _allocated { true }
 17 |         , msgData { static_cast<uint8_t*>(malloc(sizeof(uint8_t) * _bufferLength)) }
 18 |     {
 19 |         memcpy(msgData, msg.msgData, _bufferLength);
 20 |     }
 21 | 
 22 |     ping_message(const uint16_t bufferLength)
 23 |         : _bufferLength { bufferLength }
 24 |         , _allocated { true }
 25 |         , msgData { static_cast<uint8_t*>(malloc(sizeof(uint8_t) * _bufferLength)) }
 26 |     {
 27 |         if (bufferLength >= 2) {
 28 |             msgData[0] = 'B';
 29 |             msgData[1] = 'R';
 30 |         }
 31 |     }
 32 | 
 33 |     ping_message(uint8_t* buf, const uint16_t length)
 34 |         : _bufferLength { length }
 35 |         , _allocated { false }
 36 |         , msgData { buf }
 37 |     {
 38 |     }
 39 | 
 40 |     ping_message(const uint8_t* buf, const uint16_t length)
 41 |         : _bufferLength { length }
 42 |         , _allocated { true }
 43 |         , msgData { static_cast<uint8_t*>(malloc(sizeof(uint8_t) * _bufferLength)) }
 44 |     {
 45 |         memcpy(msgData, buf, _bufferLength);
 46 |     }
 47 | 
 48 |     ping_message& operator = (const ping_message &msg) {
 49 |         _bufferLength = msg.msgDataLength();
 50 |         _allocated = msg.allocated();
 51 | 
 52 |         if(msgData) free(msgData);
 53 |         msgData = static_cast<uint8_t*>(malloc(sizeof(uint8_t) * _bufferLength));
 54 |         memcpy(msgData, msg.msgData, _bufferLength);
 55 |         return *this;
 56 |     }
 57 | 
 58 |     ~ping_message() { if(msgData && _allocated) free(msgData); }
 59 | 
 60 | protected:
 61 |     uint16_t _bufferLength;
 62 |     bool _allocated;
 63 | 
 64 | public:
 65 |     static const uint8_t headerLength = 8;
 66 |     static const uint8_t checksumLength = 2;
 67 | 
 68 |     uint8_t* msgData;
 69 |     bool allocated() const { return _allocated; }
 70 |     uint16_t bufferLength() const { return _bufferLength; } // size of internal buffer allocation
 71 |     uint16_t msgDataLength() const { return static_cast<uint16_t>(headerLength + payload_length() + checksumLength); } // size of entire message buffer (header, payload, and checksum)
 72 |     uint8_t* message_data(uint32_t offset=0) const { return msgData + offset; }
 73 |     uint8_t* payload_data(uint16_t offset=0) const { return msgData + headerLength + offset; }
 74 | 
 75 |     uint16_t payload_length()                const { return reinterpret_cast<uint16_t&>(msgData[2]); }
 76 |     void set_payload_length(const uint16_t payload_length) { reinterpret_cast<uint16_t&>(msgData[2]) = payload_length; }
 77 |     uint16_t message_id()                    const { return reinterpret_cast<uint16_t&>(msgData[4]); }
 78 |     void set_message_id(const uint16_t message_id) { reinterpret_cast<uint16_t&>(msgData[4]) = message_id; }
 79 |     uint8_t  source_device_id()              const { return msgData[6]; }
 80 |     void set_source_device_id(const uint8_t device_id) { msgData[6] = device_id; }
 81 |     uint8_t  destination_device_id()         const { return msgData[7]; }
 82 |     void set_destination_device_id(const uint8_t device_id) { msgData[7] = device_id; }
 83 |     // to migrate legacy ping1d devices, a new message id should be used with the same fields + padding
 84 |     uint16_t checksum()                      const { return static_cast<uint16_t>(msgData[msgDataLength() - checksumLength] + (msgData[msgDataLength() - checksumLength + 1] << 8)); }
 85 |     void set_checksum(uint16_t checksum)           { msgData[msgDataLength() - checksumLength] = (uint8_t)checksum; msgData[msgDataLength() - checksumLength + 1] = static_cast<uint8_t>(checksum >> 8); }
 86 | 
 87 |     bool verifyChecksum() const {
 88 |         if(msgDataLength() > bufferLength()) {
 89 |             return false;
 90 |         }
 91 |         return checksum() == calculateChecksum();
 92 |     }
 93 | 
 94 |     void updateChecksum() {
 95 |         if(msgDataLength() <= bufferLength()) {
 96 |             set_checksum(calculateChecksum());
 97 |         }
 98 |     }
 99 | 
100 |     uint16_t calculateChecksum() const {
101 |         uint16_t calculatedChecksum = 0;
102 |         for(uint32_t i = 0, data_size = msgDataLength() - checksumLength; i < data_size; i++) {
103 |             calculatedChecksum = static_cast<uint16_t>(msgData[i] + calculatedChecksum);
104 |         }
105 |         return calculatedChecksum;
106 |     }
107 | 
108 |     int getMessageAsString(char* string, size_t size) const {
109 |         return snprintf(string, size,
110 |             "ping_message:\n"
111 |             " payload_length: %d\n"
112 |             " message_id: %d\n"
113 |             " src_device_id: %d\n"
114 |             " dst_device_id: %d\n"
115 |             , payload_length()
116 |             , message_id()
117 |             , source_device_id()
118 |             , destination_device_id()
119 |         );
120 |     }
121 | };
122 | 


--------------------------------------------------------------------------------
/src/message/ping-parser.h:
--------------------------------------------------------------------------------
  1 | #pragma once
  2 | 
  3 | #include <inttypes.h>
  4 | #include "ping-message.h"
  5 | 
  6 | /**
  7 |  * @brief Parser that digests data and notifies owner when something interesting happens
  8 |  *
  9 |  */
 10 | class PingParser
 11 | {
 12 | public:
 13 |     PingParser(uint16_t bufferLength = 512)
 14 |         :rxMessage(bufferLength)
 15 |         ,rxBuffer_(rxMessage.msgData)
 16 |         ,rxBufferLength_(bufferLength)
 17 |     {}
 18 |     ~PingParser() = default;
 19 | 
 20 |     ping_message rxMessage; // This message is used as the rx buffer
 21 | 
 22 |      /**
 23 |      * @brief Number of messages/packets successfully parsed
 24 |      *
 25 |      */
 26 |     uint32_t parsed = 0; // number of messages/packets successfully parsed
 27 | 
 28 |      /**
 29 |      * @brief Number of parse errors
 30 |      *
 31 |      */
 32 |     uint32_t errors = 0; // number of parse errors
 33 | 
 34 |     // This enum MUST be contiguous
 35 |     enum class State : uint8_t {
 36 |         NEW_MESSAGE,   // Just got a complete checksum-verified message
 37 |         WAIT_START,    // Waiting for the first character of a message 'B'
 38 |         WAIT_HEADER,   // Waiting for the second character in the two-character sequence 'BR'
 39 |         WAIT_LENGTH_L, // Waiting for the low byte of the payload length field
 40 |         WAIT_LENGTH_H, // Waiting for the high byte of the payload length field
 41 |         WAIT_MSG_ID_L, // Waiting for the low byte of the payload id field
 42 |         WAIT_MSG_ID_H, // Waiting for the high byte of the payload id field
 43 |         WAIT_SRC_ID,   // Waiting for the source device id
 44 |         WAIT_DST_ID,   // Waiting for the destination device id
 45 |         WAIT_PAYLOAD,  // Waiting for the last byte of the payload to come in
 46 |         WAIT_CHECKSUM_L, // Waiting for the checksum low byte
 47 |         WAIT_CHECKSUM_H, // Waiting for the checksum high byte
 48 |         ERROR, // Checksum didn't check out
 49 |     };
 50 | 
 51 |     /**
 52 |      * @brief Reset parser state
 53 |      *
 54 |      */
 55 |     void reset()
 56 |     {
 57 |         state_ = State::WAIT_START;
 58 |     }
 59 | 
 60 |     /**
 61 |      * @brief Parse a single byte
 62 |      *
 63 |      * @param data
 64 |      * @return State
 65 |      */
 66 |     PingParser::State parseByte(const uint8_t data);
 67 | 
 68 | // variables used for parsing
 69 | private:
 70 |     uint8_t* rxBuffer_;
 71 |     uint32_t rxBufferLength_;
 72 |     uint32_t rxCount_ = 0;
 73 |     uint16_t payloadLength_ = 0;
 74 |     State state_ = PingParser::State::WAIT_START;
 75 | };
 76 | 
 77 | [[maybe_unused]] static const char* PINGPARSER_STATE_TO_STRING(PingParser::State state) {
 78 |     switch(state) {
 79 |         case PingParser::State::NEW_MESSAGE:
 80 |             return "NEW_MESSAGE";
 81 |         case PingParser::State::WAIT_START:
 82 |             return "WAIT_START";
 83 |         case PingParser::State::WAIT_HEADER:
 84 |             return "WAIT_HEADER";
 85 |         case PingParser::State::WAIT_LENGTH_L:
 86 |             return "WAIT_LENGTH_L";
 87 |         case PingParser::State::WAIT_LENGTH_H:
 88 |             return "WAIT_LENGTH_H";
 89 |         case PingParser::State::WAIT_MSG_ID_L:
 90 |             return "WAIT_MSG_ID_L";
 91 |         case PingParser::State::WAIT_MSG_ID_H:
 92 |             return "WAIT_MSG_ID_H";
 93 |         case PingParser::State::WAIT_SRC_ID:
 94 |             return "WAIT_SRC_ID";
 95 |         case PingParser::State::WAIT_DST_ID:
 96 |             return "WAIT_DST_ID";
 97 |         case PingParser::State::WAIT_PAYLOAD:
 98 |             return "WAIT_PAYLOAD";
 99 |         case PingParser::State::WAIT_CHECKSUM_L:
100 |             return "WAIT_CHECKSUM_L";
101 |         case PingParser::State::WAIT_CHECKSUM_H:
102 |             return "WAIT_CHECKSUM_H";
103 |         case PingParser::State::ERROR:
104 |             return "ERROR";
105 |         default:
106 |             return "UNKNOWN";
107 |     };
108 | }
109 | 
110 | /**
111 |  * @brief Increate state
112 |  *
113 |  * @param state
114 |  */
115 | inline void operator++(PingParser::State& state, int) {
116 |     state = static_cast<PingParser::State>((static_cast<int>(state)) + 1);
117 | }
118 | 
119 | inline PingParser::State PingParser::parseByte(const uint8_t data)
120 | {
121 |     switch(state_) {
122 |     case PingParser::State::WAIT_START:
123 |         rxCount_ = 0;
124 |         if (data == 'B') {
125 |             rxBuffer_[rxCount_++] = data;
126 |             state_++;
127 |         }
128 |         break;
129 |     case PingParser::State::WAIT_HEADER:
130 |         if (data == 'R') {
131 |             rxBuffer_[rxCount_++] = data;
132 |             state_++;
133 |         } else {
134 |             reset();
135 |         }
136 |         break;
137 |     case PingParser::State::WAIT_LENGTH_L:
138 |         rxBuffer_[rxCount_++] = data;
139 |         payloadLength_ = data;
140 |         state_++;
141 |         break;
142 |     case PingParser::State::WAIT_LENGTH_H:
143 |         rxBuffer_[rxCount_++] = data;
144 |         payloadLength_ = static_cast<uint16_t>((data << 8) | payloadLength_);
145 |         if (payloadLength_ <= rxBufferLength_ - 8 - 2) {
146 |             state_++;
147 |         } else {
148 |             reset();
149 |         }
150 |         break;
151 |     case PingParser::State::WAIT_MSG_ID_L: // fall-through
152 |     case PingParser::State::WAIT_MSG_ID_H:
153 |     case PingParser::State::WAIT_SRC_ID:
154 |         rxBuffer_[rxCount_++] = data;
155 |         state_++;
156 |         break;
157 |     case PingParser::State::WAIT_DST_ID:
158 |         rxBuffer_[rxCount_++] = data;
159 |         state_++;
160 |         if (payloadLength_ == 0) {
161 |             // no payload bytes, so we skip WAIT_PAYLOAD state
162 |             state_++;
163 |         }
164 |         break;
165 |     case PingParser::State::WAIT_PAYLOAD:
166 |         rxBuffer_[rxCount_++] = data;
167 |         if (--payloadLength_ == 0) {
168 |             state_++;
169 |         }
170 |         break;
171 |     case PingParser::State::WAIT_CHECKSUM_L:
172 |         rxBuffer_[rxCount_++] = data;
173 |         state_++;
174 |         break;
175 |     case PingParser::State::WAIT_CHECKSUM_H:
176 |         rxBuffer_[rxCount_++] = data;
177 |         state_ = PingParser::State::WAIT_START;
178 |         if (rxMessage.verifyChecksum()) {
179 |             parsed++;
180 |             return PingParser::State::NEW_MESSAGE;
181 |         } else {
182 |             errors++;
183 |             return PingParser::State::ERROR;
184 |         }
185 |     default:
186 |         return state_;
187 |     }
188 |     return state_;
189 | }
190 | 


--------------------------------------------------------------------------------
/test/command-line/command-line.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <iostream>
 4 | #include <string>
 5 | 
 6 | #include <boost/filesystem.hpp>
 7 | #include <boost/program_options.hpp>
 8 | 
 9 | /**
10 |  * @brief Command line helper
11 |  *
12 |  */
13 | class CommandLine {
14 | public:
15 |     /**
16 |      * @brief Run command line from argc and arg
17 |      *
18 |      * @param argc
19 |      * @param argv
20 |      * @return true Able to parse
21 |      * @return false Unable to parse input input
22 |      */
23 |     bool run(int argc, char* argv[])
24 |     {
25 |         const boost::filesystem::path applicationName{argv[0]};
26 |         printf(" ~* %s  *~\n", applicationName.filename().string().c_str());
27 | 
28 |         boost::program_options::variables_map variablesMap;
29 | 
30 |         try {
31 |             store(boost::program_options::parse_command_line(argc, argv, _description), variablesMap);
32 |             notify(variablesMap);
33 |         } catch (const std::exception& exception) {
34 |             std::cerr << "Error: " << exception.what() << std::endl;
35 |             std::cerr << _description;
36 |             return false;
37 |         }
38 | 
39 |         if (variablesMap.count("help")) {
40 |             std::cout << _description << std::endl;
41 |             return false;
42 |         }
43 | 
44 |         return true;
45 |     }
46 | 
47 |     /**
48 |      * @brief Return singleton
49 |      *
50 |      * @return CommandLine*
51 |      */
52 |     static CommandLine* self()
53 |     {
54 |         static CommandLine commandLine;
55 |         return &commandLine;
56 |     }
57 | 
58 |     // Connection string argument
59 |     std::string connectionString;
60 | 
61 | private:
62 |     CommandLine()
63 |         : _description("Options")
64 |     {
65 |         _description.add_options()("help,h", "This help screen.")(
66 |             "conn", boost::program_options::value<std::string>(&connectionString)->required(),
67 |             "Link configuration with format "
68 |             "(serial|udp):(device|IP):(baudrate|port).\nE.g: "
69 |             "serial:/dev/ttyUSB0:115200 "
70 |             "udp:192.168.2.2:12345");
71 |     };
72 | 
73 |     boost::program_options::options_description _description;
74 | };
75 | 


--------------------------------------------------------------------------------
/test/helper.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <functional>
 4 | #include <string>
 5 | 
 6 | #include <fmt/color.h>
 7 | #include <fmt/core.h>
 8 | 
 9 | class PingDeviceTest {
10 | public:
11 |     enum class Status {
12 |         // Something is wrong (invalid test)
13 |         ERROR = -1,
14 |         // It's a valid value but we can't make sure (generic test pass)
15 |         OK = 0,
16 |         // We are sure that the value is correct (value must be exact)
17 |         SUCCESS,
18 |     };
19 | 
20 |     static void test(std::string testName, bool isOk, Status goodStatus = Status::SUCCESS) {
21 |         Status status = isOk ? goodStatus : Status::ERROR;
22 |         fmt::text_style style;
23 |         std::string result;
24 |         switch(status) { 
25 |             case Status::OK:
26 |                 style = fg(fmt::color::white);
27 |                 result = "OK";
28 |                 break;
29 |             case Status::SUCCESS:
30 |                 style = fg(fmt::terminal_color::bright_green);
31 |                 result = "SUCCESS";
32 |                 break;
33 |             default:
34 |                 style = fmt::emphasis::bold | fg(fmt::color::red);
35 |                 result = "ERROR";
36 |         }
37 |         fmt::print(style, "Test {}: {}\n", testName, result);
38 | 
39 |         if (status == Status::ERROR) {
40 |             throw std::runtime_error(std::string("Test failed: ") + testName);
41 |         }
42 |     };
43 | 
44 |     static void test(std::string testName, std::function<bool(void)> function, Status goodStatus = Status::SUCCESS) {
45 |         test(testName, function(), goodStatus);
46 |     };
47 | };
48 | 


--------------------------------------------------------------------------------
/test/test-device-ping1d.cpp:
--------------------------------------------------------------------------------
 1 | #include <link/desktop/abstract-link.h>
 2 | #include <ping-device-ping1d.h>
 3 | #include <ping-message-all.h>
 4 | 
 5 | #include "command-line/command-line.h"
 6 | 
 7 | #include "helper.h"
 8 | 
 9 | #include <cstdio>
10 | 
11 | /**
12 |  * @brief Test ping 1D devices
13 |  */
14 | int main(int argc, char* argv[])
15 | {
16 |     if (!CommandLine::self()->run(argc, argv)) {
17 |         return -1;
18 |     }
19 | 
20 |     auto port = AbstractLink::openUrl(CommandLine::self()->connectionString);
21 |     if (!port) {
22 |         std::cerr << "Failed to open communication link with device" << std::endl;
23 |         return -1;
24 |     }
25 |     Ping1d device = Ping1d(*port.get());
26 | 
27 |     // Basic information
28 |     PingDeviceTest::test("Device initialization", device.initialize(100));
29 |     PingDeviceTest::test("Device type", static_cast<PingDeviceType>(device.device_information.device_type) == PingDeviceType::PING1D);
30 |     PingDeviceTest::test("Device ID", device.device_id == 1);
31 | 
32 |     PingDeviceTest::test("Ping protocol version",
33 |         device.protocol_version.version_major == 1);
34 |     PingDeviceTest::test("Device Firmware",
35 |         device.device_information.firmware_version_major >= 3 && device.device_information.firmware_version_minor >= 27);
36 | 
37 |     // Test commands
38 |     PingDeviceTest::test("Set mode", device.set_mode_auto(true));
39 |     PingDeviceTest::test("Set range", !device.set_range(100, 2000)); // We can't set range in auto mode
40 |     PingDeviceTest::test("Set mode", device.set_mode_auto(false));
41 |     PingDeviceTest::test("Set range", device.set_range(100, 2000)); // We are not in auto mode anymore
42 | 
43 |     PingDeviceTest::test("Set speed of sound", device.set_speed_of_sound(1550000));
44 |     PingDeviceTest::test("Set mode", device.set_mode_auto(false));
45 |     PingDeviceTest::test("Set interval", device.set_ping_interval(200));
46 |     PingDeviceTest::test("Set gain", device.set_gain_setting(1));
47 |     PingDeviceTest::test("Set ping enable", device.set_ping_enable(1));
48 | 
49 |     // Test request
50 |     auto requestIDs = {
51 |         Ping1dId::FIRMWARE_VERSION,
52 |         Ping1dId::DEVICE_ID,
53 |         Ping1dId::VOLTAGE_5,
54 |         Ping1dId::SPEED_OF_SOUND,
55 |         Ping1dId::RANGE,
56 |         Ping1dId::MODE_AUTO,
57 |         Ping1dId::PING_INTERVAL,
58 |         Ping1dId::GAIN_SETTING,
59 |         Ping1dId::TRANSMIT_DURATION,
60 |         Ping1dId::GENERAL_INFO,
61 |         Ping1dId::DISTANCE_SIMPLE,
62 |         Ping1dId::DISTANCE,
63 |         Ping1dId::PROCESSOR_TEMPERATURE,
64 |         Ping1dId::PCB_TEMPERATURE,
65 |         Ping1dId::PING_ENABLE,
66 |         Ping1dId::PROFILE,
67 |     };
68 | 
69 |     for (auto id : requestIDs) {
70 |         std::string title = "Requesting message [";
71 |         title.append(PingHelper::nameFromMessageId(static_cast<PingEnumNamespace::PingMessageId>(id)));
72 |         title.append("]");
73 | 
74 |         PingDeviceTest::test(title, device.request(id, 1000));
75 |     }
76 | 
77 |     return 0;
78 | }
79 | 


--------------------------------------------------------------------------------
/test/test-device-ping360.cpp:
--------------------------------------------------------------------------------
 1 | #include <link/desktop/abstract-link.h>
 2 | #include <ping-device-ping360.h>
 3 | #include <ping-message-all.h>
 4 | 
 5 | #include "command-line/command-line.h"
 6 | 
 7 | #include "helper.h"
 8 | 
 9 | #include <cstdio>
10 | 
11 | /**
12 |  * @brief Test ping 1D devices
13 |  */
14 | int main(int argc, char* argv[])
15 | {
16 |     if (!CommandLine::self()->run(argc, argv)) {
17 |         return -1;
18 |     }
19 | 
20 |     auto port = AbstractLink::openUrl(CommandLine::self()->connectionString);
21 |     if (!port) {
22 |         std::cerr << "Failed to open communication link with device" << std::endl;
23 |         return -1;
24 |     }
25 |     Ping360 device = Ping360(*port.get());
26 | 
27 |     // Basic information
28 |     PingDeviceTest::test("Device initialization", device.initialize());
29 |     PingDeviceTest::test("Device type", static_cast<PingDeviceType>(device.device_information.device_type) == PingDeviceType::PING360);
30 |     PingDeviceTest::test("Device ID", device.device_id == 2);
31 | 
32 |     PingDeviceTest::test("Ping protocol version",
33 |         device.protocol_version.version_major == 1);
34 | 
35 |     printf("Firmware version: %d.%d.%d\n", device.device_information.firmware_version_major, device.device_information.firmware_version_minor, device.device_information.firmware_version_patch);
36 | 
37 |     for(int number = 0; number < 200; number += 1) {
38 |         device.set_transducer(
39 |             1           //mode
40 |             ,1          //gain_setting
41 |             ,number     //angle
42 |             ,100        //transmit_duration
43 |             ,100        //sample_period
44 |             ,750        //transmit_frequency
45 |             ,200        //number_of_samples
46 |             ,1          //transmit
47 |             ,0          //reserved
48 |         );
49 | 
50 |         [[maybe_unused]] const auto message_device_data = static_cast<const ping360_device_data*>(device.waitMessage(Ping360Id::DEVICE_DATA, 8000));
51 |         assert(message_device_data);
52 |         assert(message_device_data->angle() == number);
53 |     }
54 |     PingDeviceTest::test("Check 400 transducer messages", true);
55 | 
56 |     device.set_auto_transmit(
57 |         1           //mode
58 |         ,1          //gain_setting
59 |         ,100        //transmit_duration
60 |         ,100        //sample_period
61 |         ,750        //transmit_frequency
62 |         ,200        //number_of_samples
63 |         ,0          //start_angle
64 |         ,399        //stop_angle
65 |         ,1          //number_of_steps
66 |         ,0          //delay
67 |     );
68 |     for(int number = 0; number < 200; number += 1) {
69 |         [[maybe_unused]] const auto message_device_data = static_cast<const ping360_auto_device_data*>(device.waitMessage(Ping360Id::AUTO_DEVICE_DATA, 8000));
70 |         assert(message_device_data);
71 |         assert(message_device_data->angle() == number);
72 |     }
73 |     PingDeviceTest::test("Check 400 auto transducer messages", true);
74 | 
75 |     device.set_motor_off();
76 |     PingDeviceTest::test("Turn off motor", device.waitMessage(CommonId::ACK, 1000));
77 | 
78 |     return 0;
79 | }
80 | 


--------------------------------------------------------------------------------
/test/test-device.cpp:
--------------------------------------------------------------------------------
 1 | #include <link/desktop/abstract-link.h>
 2 | #include <ping-device.h>
 3 | #include <ping-message-all.h>
 4 | 
 5 | #include "command-line/command-line.h"
 6 | #include "helper.h"
 7 | 
 8 | #include <cstdio>
 9 | 
10 | typedef PingDeviceTest::Status Status;
11 | 
12 | /**
13 |  * @brief Test generic ping devices
14 |  */
15 | int main(int argc, char* argv[])
16 | {
17 |     if (!CommandLine::self()->run(argc, argv)) {
18 |         return -1;
19 |     }
20 | 
21 |     auto port = AbstractLink::openUrl(CommandLine::self()->connectionString);
22 |     if (!port) {
23 |         std::cerr << "Failed to open communication link with device" << std::endl;
24 |         return -1;
25 |     }
26 |     PingDevice device = PingDevice(*port.get());
27 | 
28 |     // Basic information
29 |     PingDeviceTest::test("Device initialization", device.initialize());
30 |     PingDeviceTest::test("Device type", static_cast<int>(PingDeviceType::UNKNOWN) < device.device_information.device_type, Status::OK);
31 |     const auto device_type = static_cast<PingDeviceType>(device.device_information.device_type);
32 |     std::cout << "Device detected as: " << PingHelper::nameFromDeviceType(device_type) << std::endl;
33 |     PingDeviceTest::test("Device ID", device.device_id != 0, Status::OK);
34 | 
35 |     // Common messages validation
36 |     PingDeviceTest::test("Device Hardware revision", device.device_information.device_revision, Status::OK);
37 | 
38 |     printf("Protocol version: %d.%d.%d\n", device.protocol_version.version_major, device.protocol_version.version_minor, device.protocol_version.version_patch);
39 |     switch (device_type) {
40 |         case (PingDeviceType::PING1D):
41 |             PingDeviceTest::test(
42 |                 "Protocol version",
43 |                 device.protocol_version.version_major == 1 && device.protocol_version.version_minor == 0 && device.protocol_version.version_patch == 0,
44 |                 Status::OK
45 |             );
46 |         break;
47 |         case (PingDeviceType::PING360):
48 |             PingDeviceTest::test(
49 |                 "Protocol version",
50 |                 device.protocol_version.version_major == 1 && device.protocol_version.version_minor == 0 && device.protocol_version.version_patch == 0,
51 |                 Status::OK
52 |             );
53 |         break;
54 |         default:
55 |             break;
56 | 
57 |     }
58 |     PingDeviceTest::test(
59 |         "Firmware version",
60 |         device.device_information.firmware_version_major != 0 || device.device_information.firmware_version_minor != 0 || device.device_information.firmware_version_patch != 0,
61 |         Status::OK
62 |     );
63 | 
64 |     return 0;
65 | }
66 | 


--------------------------------------------------------------------------------
/test/test-message.cpp:
--------------------------------------------------------------------------------
  1 | // Test ping-message c++ api
  2 | // Test creating ping_message object from byte array (receive)
  3 | // Test creating byte array from ping_message object (transmit)
  4 | 
  5 | #include <ping-message-all.h>
  6 | #include <ping-parser.h>
  7 | 
  8 | #include <cstdio>
  9 | 
 10 | template <class T> bool compare(const char* s, T value, T expected);
 11 | 
 12 | static const uint8_t header_length = 8;
 13 | static const uint8_t checksum_length = 2;
 14 | 
 15 | ///////////////
 16 | ///// common
 17 | ///////////////
 18 | static const uint16_t protocol_version_payload_length = 4;
 19 | static const uint32_t protocol_version_msg_length = header_length + protocol_version_payload_length + checksum_length;
 20 | struct test_protocol_version_s;
 21 | bool verifyProtocolMessage(common_protocol_version m, test_protocol_version_s t);
 22 | bool testProtocolVersion();
 23 | 
 24 | ///////////////
 25 | ///// ping1d
 26 | ///////////////
 27 | static const uint16_t profile_static_payload_length = 4 + 2 + 2 + 4 + 4 + 4 + 4 + 2;
 28 | static const uint16_t profile_points = 10;
 29 | static const uint16_t profile_payload_length = profile_static_payload_length + profile_points;
 30 | static const uint32_t profile_msg_length = header_length + profile_payload_length + checksum_length;
 31 | struct test_profile_s;
 32 | bool verifyProfileMessage(ping1d_profile m, test_profile_s t);
 33 | bool testProfile();
 34 | bool testProfileZeroPayload();
 35 | 
 36 | // TODO maybe rework to read in test cases from file.
 37 | int main(void)
 38 | {
 39 |     bool ret = false;
 40 |     ret |= testProtocolVersion();
 41 |     ret |= testProfile();
 42 |     ret |= testProfileZeroPayload();
 43 |     return ret;
 44 | }
 45 | 
 46 | template <class T> bool compare(const char* s, T value, T expected)
 47 | {
 48 |     printf("%s: %d expected: %d\n", s, value, expected);
 49 |     if (value != expected) {
 50 |         printf("fail\n");
 51 |         return true;
 52 |     }
 53 |     return false;
 54 | }
 55 | 
 56 | struct test_protocol_version_s {
 57 |     uint8_t start1;
 58 |     uint8_t start2;
 59 |     uint16_t payload_length;
 60 |     uint16_t message_id;
 61 | 
 62 |     uint8_t source_device_id;
 63 |     uint8_t destination_device_id;
 64 | 
 65 |     uint8_t version_major;
 66 |     uint8_t version_minor;
 67 |     uint8_t version_patch;
 68 |     uint8_t reserved;
 69 | 
 70 |     uint16_t checksum;
 71 | } __attribute__((packed));
 72 | 
 73 | bool verifyProtocolMessage(common_protocol_version m, test_protocol_version_s t)
 74 | {
 75 |     bool result = false;
 76 |     result |= compare("payload_length", m.payload_length(), t.payload_length);
 77 |     result |= compare("message_id", m.message_id(), t.message_id);
 78 |     result |= compare("source_id", m.source_device_id(), t.source_device_id);
 79 |     result |= compare("destination_id", m.destination_device_id(), t.destination_device_id);
 80 |     result |= compare("version_major", m.version_major(), t.version_major);
 81 |     result |= compare("version_minor", m.version_minor(), t.version_minor);
 82 |     result |= compare("version_patch", m.version_patch(), t.version_patch);
 83 |     result |= compare("reserved", m.reserved(), t.reserved);
 84 |     return result;
 85 | }
 86 | 
 87 | bool testProtocolVersion()
 88 | {
 89 |     bool result = false;
 90 | 
 91 |     // Hand-made test case
 92 |     union {
 93 |         test_protocol_version_s fields {
 94 |             'B',
 95 |             'R',
 96 |             4,
 97 |             5,
 98 |             77,
 99 |             211,
100 |             1,
101 |             2,
102 |             3,
103 |             99,
104 |             550
105 |         };
106 |         uint8_t data[protocol_version_msg_length];
107 |     } test;
108 | 
109 |     printf("Testing byte array to object conversion...\n\n");
110 | 
111 |     // TODO test all constructors
112 |     // TODO test dynamic arrays, implicit and explicit length
113 |     common_protocol_version test_in(test.data, protocol_version_msg_length);
114 | 
115 |     result |= verifyProtocolMessage(test_in, test.fields);
116 | 
117 |     printf("\nTesting object to byte array conversion...\n\n");
118 | 
119 |     common_protocol_version test_out;
120 |     test_out.set_source_device_id(test.fields.source_device_id);
121 |     test_out.set_destination_device_id(test.fields.destination_device_id);
122 |     test_out.set_version_major(test.fields.version_major);
123 |     test_out.set_version_minor(test.fields.version_minor);
124 |     test_out.set_version_patch(test.fields.version_patch);
125 |     test_out.set_reserved(test.fields.reserved);
126 |     test_out.updateChecksum();
127 | 
128 |     for (uint8_t i = 0; i < protocol_version_msg_length; i++) {
129 |         result |= compare("checking output byte", test_out.msgData[i], test.data[i]);
130 |     }
131 | 
132 |     printf("\ntesting parser...\n\n");
133 | 
134 |     PingParser p;
135 |     for (uint8_t i = 0; i < protocol_version_msg_length; i++) {
136 |         printf("parse state: %s\n", PINGPARSER_STATE_TO_STRING(p.parseByte(test.data[i])));
137 |     }
138 | 
139 |     result |= verifyProtocolMessage(p.rxMessage, test.fields);
140 | 
141 |     return result;
142 | }
143 | 
144 | struct test_profile_s {
145 |     uint8_t start1;
146 |     uint8_t start2;
147 |     uint16_t payload_length;
148 |     uint16_t message_id;
149 | 
150 |     uint8_t source_device_id;
151 |     uint8_t destination_device_id;
152 | 
153 |     uint32_t distance;
154 |     uint16_t confidence;
155 |     uint16_t transmit_duration;
156 |     uint32_t ping_number;
157 |     uint32_t scan_start;
158 |     uint32_t scan_length;
159 |     uint32_t gain_setting;
160 |     uint16_t profile_data_length;
161 |     uint8_t profile_data[profile_points];
162 |     uint16_t checksum;
163 | } __attribute__((packed));
164 | 
165 | bool verifyProfileMessage(ping1d_profile m, test_profile_s t)
166 | {
167 |     bool result = false;
168 |     result |= compare("payload_length", m.payload_length(), t.payload_length);
169 |     result |= compare("message_id", m.message_id(), t.message_id);
170 |     result |= compare("source_id", m.source_device_id(), t.source_device_id);
171 |     result |= compare("destination_id", m.destination_device_id(), t.destination_device_id);
172 |     result |= compare("distance", m.distance(), t.distance);
173 |     result |= compare("confidence", m.confidence(), t.confidence);
174 |     result |= compare("transmit_duration", m.transmit_duration(), t.transmit_duration);
175 |     result |= compare("ping_number", m.ping_number(), t.ping_number);
176 |     result |= compare("scan_start", m.scan_start(), t.scan_start);
177 |     result |= compare("scan_length", m.scan_length(), t.scan_length);
178 |     result |= compare("gain_setting", m.gain_setting(), t.gain_setting);
179 |     result |= compare("profile_data_length", m.profile_data_length(), t.profile_data_length);
180 |     for (uint16_t i = 0; i < m.profile_data_length(); i++) {
181 |         compare("compare data", m.profile_data()[i], t.profile_data[i]);
182 |     }
183 |     return result;
184 | }
185 | 
186 | bool testProfile()
187 | {
188 |     printf("testing ping1d profile message...\n");
189 | 
190 |     bool result = false;
191 | 
192 |     // Hand-made test case
193 |     union {
194 |         test_profile_s fields {
195 |             'B',
196 |             'R',
197 |             profile_payload_length,
198 |             Ping1dId::PROFILE,
199 |             56,
200 |             45,
201 |             1000,
202 |             93,
203 |             2111,
204 |             44444444,
205 |             4000,
206 |             35000,
207 |             4,
208 |             profile_points,
209 |             { 0,1,2,3,4,5,6,7,8,9 }, // profile data
210 |             1502 // checksum
211 |         };
212 |         uint8_t data[profile_msg_length];
213 |     } test;
214 | 
215 |     printf("Testing byte array to object conversion...\n\n");
216 | 
217 |     // TODO test all constructors
218 |     // TODO test dynamic arrays, implicit and explicit length
219 |     ping1d_profile test_in(test.data, profile_msg_length);
220 | 
221 |     result |= verifyProfileMessage(test_in, test.fields);
222 | 
223 |     printf("\nTesting object to byte array conversion...\n\n");
224 | 
225 |     ping1d_profile test_out(profile_points);
226 |     test_out.set_source_device_id(test.fields.source_device_id);
227 |     test_out.set_destination_device_id(test.fields.destination_device_id);
228 |     test_out.set_distance(test.fields.distance);
229 |     test_out.set_confidence(test.fields.confidence);
230 |     test_out.set_transmit_duration(test.fields.transmit_duration);
231 |     test_out.set_ping_number(test.fields.ping_number);
232 |     test_out.set_scan_start(test.fields.scan_start);
233 |     test_out.set_scan_length(test.fields.scan_length);
234 |     test_out.set_gain_setting(test.fields.gain_setting);
235 |     test_out.set_profile_data_length(test.fields.profile_data_length);
236 |     for (uint16_t i = 0; i < profile_points; i++) {
237 |         test_out.set_profile_data_at(i, test.fields.profile_data[i]);
238 |     }
239 | 
240 |     test_out.updateChecksum();
241 | 
242 |     for (uint32_t i = 0; i < profile_msg_length; i++) {
243 |         result |= compare("checking output byte", test_out.msgData[i], test.data[i]);
244 |     }
245 | 
246 |     printf("\ntesting parser...\n\n");
247 | 
248 |     PingParser p(512); // parser buffer length must be large enough
249 |     for (uint32_t i = 0; i < profile_msg_length; i++) {
250 |         printf("parse state: %s\n", PINGPARSER_STATE_TO_STRING(p.parseByte(test.data[i])));
251 |     }
252 | 
253 |     result |= verifyProfileMessage(p.rxMessage, test.fields);
254 | 
255 |     return result;
256 | }
257 | 
258 | bool testProfileZeroPayload()
259 | {
260 |     printf("testing ping1d profile message with zero payload...\n");
261 | 
262 |     bool result = false;
263 | 
264 |     static const uint32_t profile_msg_length2 = header_length + profile_static_payload_length + checksum_length;
265 | 
266 |     // Hand-made test case
267 |     union {
268 |         test_profile_s fields {
269 |             'B',
270 |             'R',
271 |             profile_payload_length,
272 |             Ping1dId::PROFILE,
273 |             56,
274 |             45,
275 |             1000,
276 |             93,
277 |             2111,
278 |             44444444,
279 |             4000,
280 |             35000,
281 |             4,
282 |             0,
283 |             {}, // profile data
284 |             1502 // checksum
285 |         };
286 |         uint8_t data[profile_msg_length2];
287 |     } test;
288 | 
289 |     printf("Testing byte array to object conversion...\n\n");
290 | 
291 |     // TODO test all constructors
292 |     // TODO test dynamic arrays, implicit and explicit length
293 |     ping1d_profile test_in(test.data, profile_msg_length2);
294 | 
295 |     result |= verifyProfileMessage(test_in, test.fields);
296 | 
297 |     printf("\nTesting object to byte array conversion...\n\n");
298 | 
299 |     ping1d_profile test_out(profile_points);
300 |     test_out.set_source_device_id(test.fields.source_device_id);
301 |     test_out.set_destination_device_id(test.fields.destination_device_id);
302 |     test_out.set_distance(test.fields.distance);
303 |     test_out.set_confidence(test.fields.confidence);
304 |     test_out.set_transmit_duration(test.fields.transmit_duration);
305 |     test_out.set_ping_number(test.fields.ping_number);
306 |     test_out.set_scan_start(test.fields.scan_start);
307 |     test_out.set_scan_length(test.fields.scan_length);
308 |     test_out.set_gain_setting(test.fields.gain_setting);
309 |     test_out.set_profile_data_length(test.fields.profile_data_length);
310 |     for (uint16_t i = 0; i < profile_points; i++) {
311 |         test_out.set_profile_data_at(i, test.fields.profile_data[i]);
312 |     }
313 | 
314 |     test_out.updateChecksum();
315 | 
316 |     for (uint32_t i = 0; i < profile_msg_length2; i++) {
317 |         result |= compare("checking output byte", test_out.msgData[i], test.data[i]);
318 |     }
319 | 
320 |     printf("\ntesting parser...\n\n");
321 | 
322 |     PingParser p(512); // parser buffer length must be large enough
323 |     for (uint32_t i = 0; i < profile_msg_length2; i++) {
324 |         printf("parse state: %s\n", PINGPARSER_STATE_TO_STRING(p.parseByte(test.data[i])));
325 |     }
326 | 
327 |     result |= verifyProfileMessage(p.rxMessage, test.fields);
328 | 
329 |     return result;
330 | }
331 | 


--------------------------------------------------------------------------------
/tools/travis-ci-script.sh:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env bash
 2 | 
 3 | echo "Build tests.."
 4 | mkdir -p build && cd build
 5 | if !(cmake .. && make all); then
 6 |     echo " Failed to compile tests!"
 7 |     exit 1
 8 | fi
 9 | echo "run test.."
10 | ls
11 | if ! ./test-message; then
12 |     echo " Failed to run test-message!"
13 |     exit 1
14 | fi
15 | cd ..
16 | 
17 | # because these files are gitignored, we have to force-add and commit them
18 | # in order to move them to the deployment branch. every other approach I tried
19 | # clobbered the files
20 | git add src/message -f
21 | git add src/device -f
22 | git commit -m temporary-commit
23 | git checkout deployment
24 | git checkout HEAD@{1} src/message
25 | git checkout HEAD@{1} src/device
26 | git diff --staged
27 | git commit -m "update autogenerated files"
28 | 
29 | if [ ! -z ${TRAVIS_PULL_REQUEST} ] && [ ${TRAVIS_PULL_REQUEST} == "false" ] && [ "$TRAVIS_BRANCH" == "master" ] ; then
30 |     echo "Updating deployment branch.."
31 |     git remote set-url origin https://${GITHUB_TOKEN}@github.com/bluerobotics/ping-cpp
32 |     git push origin
33 | else
34 |     echo "PR detected, no deployment will be done."
35 | fi
36 | 


--------------------------------------------------------------------------------