![]() |
async_comm package from async_comm repoasync_comm |
ROS Distro
|
Package Summary
Tags | No category tags. |
Version | 0.2.1 |
License | BSD |
Build type | CMAKE |
Use | RECOMMENDED |
Repository Summary
Checkout URI | https://github.com/dpkoch/async_comm.git |
VCS Type | git |
VCS Version | master |
Last Updated | 2021-05-14 |
Dev Status | DEVELOPED |
CI status | Continuous Integration |
Released | RELEASED |
Tags | No category tags. |
Contributing |
Help Wanted (0)
Good First Issues (0) Pull Requests to Review (0) |
Package Description
Additional Links
Maintainers
- Daniel Koch
Authors
Async Comm Library
This project provides a C++ library that gives a simple interface for asynchronous serial communications over a serial port or UDP. It uses the Boost.Asio library under the hood, but hides from the user the details of interfacing with the ports or sockets and managing send/receive buffers.
Including in your project
There are three ways to use the async_comm
library in your project:
- If you’ll be using the library in a ROS package, install from the ROS repositories
- Build and install the library on your system, then use CMake’s
find_package()
functionality - Include the async_comm as a submodule in your project
With the second and third options, you will need to ensure that the Boost library is installed before proceeding:
sudo apt -y install libboost-dev libboost-system-dev
ROS install
The async_comm
library is released as a third-party, non-catkin package for ROS following the guidelines in REP 136. To use the library in your ROS package, first install the library from the ROS repositories:
sudo apt install ros-<DISTRO>-async-comm
Replace <DISTRO>
with your ROS distribution. The library is currently released for kinetic, lunar, and melodic.
Then, add something like the following lines to your package’s CMakeLists.txt:
# ...
find_package(async_comm REQUIRED)
catkin_package(
# ...
DEPENDS async_comm
)
# ...
add_executable(my_node src/my_node.cpp)
target_link_libraries(my_node ${async_comm_LIBRARIES})
Also be sure to list async_comm
as a dependency in your package.xml:
<?xml version="1.0"?>
<package format="2">
...
<depend>async_comm</depend>
...
</package>
System install
First, download and install the library:
git clone https://github.com/dpkoch/async_comm.git
cd async_comm
mkdir build && cd build/
cmake .. && make
sudo make install
Then, do something like this in your project’s CMakeLists.txt:
cmake_minimum_required(VERSION 3.0.2)
project(my_project)
find_package(async_comm REQUIRED)
add_executable(my_project src/my_project.cpp)
target_link_libraries(my_project ${async_comm_LIBRARIES})
Including as a submodule
If you don’t want to go with the ROS or system install options, the next easiest way to embed the async_comm
library in your project is as a Git submodule. The following instructions are for a project using Git for version control and CMake for a build system, but should serve as a starting point for other setups.
For example, to put async_comm
in the lib/async_comm directory
, run the following from the root of your project:
git submodule add https://github.com/dpkoch/async_comm.git lib/async_comm
Your CMakeLists.txt file would then look something like this:
```CMake cmake_minimum_required(VERSION 3.0.2)
File truncated at 100 lines see the full file
Changelog for package async_comm
0.2.1 (2021-01-21)
- Add noetic to ROS prerelease test distribution list
- Fixes for compatibility with ROS2 workspaces:
- cmake: Change install paths to basic lib/ and include/
- package.xml: Remove unneeded catkin dependency
- Updated CMake examples in README
- Contributors: Daniel Koch, Maciej Bogusz
0.2.0 (2020-03-16)
- Fix for UDP/TCP when loopback is only device with an address
- Added listener interface
- Added custom message handler functionality
- TCPClient class implementing an async tcp client
- Contributors: Daniel Koch, James Jackson, Rein Appeldoorn
0.1.1 (2019-02-21)
- Some cleanup
- Process callbacks on a separate thread
- Made buffer sizes constant, removed faulty mechanism for overriding
- Removed requirement that bulk write length be no greater than write buffer size
- Contributors: Daniel Koch
0.1.0 (2018-08-31)
- Initial release
- Contributors: Daniel Koch, James Jackson
Wiki Tutorials
Launch files
Messages
Services
Plugins
Recent questions tagged async_comm at Robotics Stack Exchange
![]() |
async_comm package from async_comm repoasync_comm |
ROS Distro
|
Package Summary
Tags | No category tags. |
Version | 0.2.1 |
License | BSD |
Build type | CMAKE |
Use | RECOMMENDED |
Repository Summary
Checkout URI | https://github.com/dpkoch/async_comm.git |
VCS Type | git |
VCS Version | master |
Last Updated | 2021-05-14 |
Dev Status | DEVELOPED |
CI status | Continuous Integration |
Released | RELEASED |
Tags | No category tags. |
Contributing |
Help Wanted (0)
Good First Issues (0) Pull Requests to Review (0) |
Package Description
Additional Links
Maintainers
- Daniel Koch
Authors
Async Comm Library
This project provides a C++ library that gives a simple interface for asynchronous serial communications over a serial port or UDP. It uses the Boost.Asio library under the hood, but hides from the user the details of interfacing with the ports or sockets and managing send/receive buffers.
Including in your project
There are three ways to use the async_comm
library in your project:
- If you’ll be using the library in a ROS package, install from the ROS repositories
- Build and install the library on your system, then use CMake’s
find_package()
functionality - Include the async_comm as a submodule in your project
With the second and third options, you will need to ensure that the Boost library is installed before proceeding:
sudo apt -y install libboost-dev libboost-system-dev
ROS install
The async_comm
library is released as a third-party, non-catkin package for ROS following the guidelines in REP 136. To use the library in your ROS package, first install the library from the ROS repositories:
sudo apt install ros-<DISTRO>-async-comm
Replace <DISTRO>
with your ROS distribution. The library is currently released for kinetic, lunar, and melodic.
Then, add something like the following lines to your package’s CMakeLists.txt:
# ...
find_package(async_comm REQUIRED)
catkin_package(
# ...
DEPENDS async_comm
)
# ...
add_executable(my_node src/my_node.cpp)
target_link_libraries(my_node ${async_comm_LIBRARIES})
Also be sure to list async_comm
as a dependency in your package.xml:
<?xml version="1.0"?>
<package format="2">
...
<depend>async_comm</depend>
...
</package>
System install
First, download and install the library:
git clone https://github.com/dpkoch/async_comm.git
cd async_comm
mkdir build && cd build/
cmake .. && make
sudo make install
Then, do something like this in your project’s CMakeLists.txt:
cmake_minimum_required(VERSION 3.0.2)
project(my_project)
find_package(async_comm REQUIRED)
add_executable(my_project src/my_project.cpp)
target_link_libraries(my_project ${async_comm_LIBRARIES})
Including as a submodule
If you don’t want to go with the ROS or system install options, the next easiest way to embed the async_comm
library in your project is as a Git submodule. The following instructions are for a project using Git for version control and CMake for a build system, but should serve as a starting point for other setups.
For example, to put async_comm
in the lib/async_comm directory
, run the following from the root of your project:
git submodule add https://github.com/dpkoch/async_comm.git lib/async_comm
Your CMakeLists.txt file would then look something like this:
```CMake cmake_minimum_required(VERSION 3.0.2)
File truncated at 100 lines see the full file
Changelog for package async_comm
0.2.1 (2021-01-21)
- Add noetic to ROS prerelease test distribution list
- Fixes for compatibility with ROS2 workspaces:
- cmake: Change install paths to basic lib/ and include/
- package.xml: Remove unneeded catkin dependency
- Updated CMake examples in README
- Contributors: Daniel Koch, Maciej Bogusz
0.2.0 (2020-03-16)
- Fix for UDP/TCP when loopback is only device with an address
- Added listener interface
- Added custom message handler functionality
- TCPClient class implementing an async tcp client
- Contributors: Daniel Koch, James Jackson, Rein Appeldoorn
0.1.1 (2019-02-21)
- Some cleanup
- Process callbacks on a separate thread
- Made buffer sizes constant, removed faulty mechanism for overriding
- Removed requirement that bulk write length be no greater than write buffer size
- Contributors: Daniel Koch
0.1.0 (2018-08-31)
- Initial release
- Contributors: Daniel Koch, James Jackson
Wiki Tutorials
Launch files
Messages
Services
Plugins
Recent questions tagged async_comm at Robotics Stack Exchange
![]() |
async_comm package from async_comm repoasync_comm |
ROS Distro
|
Package Summary
Tags | No category tags. |
Version | 0.2.1 |
License | BSD |
Build type | CMAKE |
Use | RECOMMENDED |
Repository Summary
Checkout URI | https://github.com/dpkoch/async_comm.git |
VCS Type | git |
VCS Version | master |
Last Updated | 2021-05-14 |
Dev Status | DEVELOPED |
CI status | Continuous Integration |
Released | RELEASED |
Tags | No category tags. |
Contributing |
Help Wanted (0)
Good First Issues (0) Pull Requests to Review (0) |
Package Description
Additional Links
Maintainers
- Daniel Koch
Authors
Async Comm Library
This project provides a C++ library that gives a simple interface for asynchronous serial communications over a serial port or UDP. It uses the Boost.Asio library under the hood, but hides from the user the details of interfacing with the ports or sockets and managing send/receive buffers.
Including in your project
There are three ways to use the async_comm
library in your project:
- If you’ll be using the library in a ROS package, install from the ROS repositories
- Build and install the library on your system, then use CMake’s
find_package()
functionality - Include the async_comm as a submodule in your project
With the second and third options, you will need to ensure that the Boost library is installed before proceeding:
sudo apt -y install libboost-dev libboost-system-dev
ROS install
The async_comm
library is released as a third-party, non-catkin package for ROS following the guidelines in REP 136. To use the library in your ROS package, first install the library from the ROS repositories:
sudo apt install ros-<DISTRO>-async-comm
Replace <DISTRO>
with your ROS distribution. The library is currently released for kinetic, lunar, and melodic.
Then, add something like the following lines to your package’s CMakeLists.txt:
# ...
find_package(async_comm REQUIRED)
catkin_package(
# ...
DEPENDS async_comm
)
# ...
add_executable(my_node src/my_node.cpp)
target_link_libraries(my_node ${async_comm_LIBRARIES})
Also be sure to list async_comm
as a dependency in your package.xml:
<?xml version="1.0"?>
<package format="2">
...
<depend>async_comm</depend>
...
</package>
System install
First, download and install the library:
git clone https://github.com/dpkoch/async_comm.git
cd async_comm
mkdir build && cd build/
cmake .. && make
sudo make install
Then, do something like this in your project’s CMakeLists.txt:
cmake_minimum_required(VERSION 3.0.2)
project(my_project)
find_package(async_comm REQUIRED)
add_executable(my_project src/my_project.cpp)
target_link_libraries(my_project ${async_comm_LIBRARIES})
Including as a submodule
If you don’t want to go with the ROS or system install options, the next easiest way to embed the async_comm
library in your project is as a Git submodule. The following instructions are for a project using Git for version control and CMake for a build system, but should serve as a starting point for other setups.
For example, to put async_comm
in the lib/async_comm directory
, run the following from the root of your project:
git submodule add https://github.com/dpkoch/async_comm.git lib/async_comm
Your CMakeLists.txt file would then look something like this:
```CMake cmake_minimum_required(VERSION 3.0.2)
File truncated at 100 lines see the full file
Changelog for package async_comm
0.2.1 (2021-01-21)
- Add noetic to ROS prerelease test distribution list
- Fixes for compatibility with ROS2 workspaces:
- cmake: Change install paths to basic lib/ and include/
- package.xml: Remove unneeded catkin dependency
- Updated CMake examples in README
- Contributors: Daniel Koch, Maciej Bogusz
0.2.0 (2020-03-16)
- Fix for UDP/TCP when loopback is only device with an address
- Added listener interface
- Added custom message handler functionality
- TCPClient class implementing an async tcp client
- Contributors: Daniel Koch, James Jackson, Rein Appeldoorn
0.1.1 (2019-02-21)
- Some cleanup
- Process callbacks on a separate thread
- Made buffer sizes constant, removed faulty mechanism for overriding
- Removed requirement that bulk write length be no greater than write buffer size
- Contributors: Daniel Koch
0.1.0 (2018-08-31)
- Initial release
- Contributors: Daniel Koch, James Jackson
Wiki Tutorials
Launch files
Messages
Services
Plugins
Recent questions tagged async_comm at Robotics Stack Exchange
![]() |
async_comm package from async_comm repoasync_comm |
ROS Distro
|
Package Summary
Tags | No category tags. |
Version | 0.2.1 |
License | BSD |
Build type | CMAKE |
Use | RECOMMENDED |
Repository Summary
Checkout URI | https://github.com/dpkoch/async_comm.git |
VCS Type | git |
VCS Version | master |
Last Updated | 2021-05-14 |
Dev Status | DEVELOPED |
CI status | Continuous Integration |
Released | RELEASED |
Tags | No category tags. |
Contributing |
Help Wanted (0)
Good First Issues (0) Pull Requests to Review (0) |
Package Description
Additional Links
Maintainers
- Daniel Koch
Authors
Async Comm Library
This project provides a C++ library that gives a simple interface for asynchronous serial communications over a serial port or UDP. It uses the Boost.Asio library under the hood, but hides from the user the details of interfacing with the ports or sockets and managing send/receive buffers.
Including in your project
There are three ways to use the async_comm
library in your project:
- If you’ll be using the library in a ROS package, install from the ROS repositories
- Build and install the library on your system, then use CMake’s
find_package()
functionality - Include the async_comm as a submodule in your project
With the second and third options, you will need to ensure that the Boost library is installed before proceeding:
sudo apt -y install libboost-dev libboost-system-dev
ROS install
The async_comm
library is released as a third-party, non-catkin package for ROS following the guidelines in REP 136. To use the library in your ROS package, first install the library from the ROS repositories:
sudo apt install ros-<DISTRO>-async-comm
Replace <DISTRO>
with your ROS distribution. The library is currently released for kinetic, lunar, and melodic.
Then, add something like the following lines to your package’s CMakeLists.txt:
# ...
find_package(async_comm REQUIRED)
catkin_package(
# ...
DEPENDS async_comm
)
# ...
add_executable(my_node src/my_node.cpp)
target_link_libraries(my_node ${async_comm_LIBRARIES})
Also be sure to list async_comm
as a dependency in your package.xml:
<?xml version="1.0"?>
<package format="2">
...
<depend>async_comm</depend>
...
</package>
System install
First, download and install the library:
git clone https://github.com/dpkoch/async_comm.git
cd async_comm
mkdir build && cd build/
cmake .. && make
sudo make install
Then, do something like this in your project’s CMakeLists.txt:
cmake_minimum_required(VERSION 3.0.2)
project(my_project)
find_package(async_comm REQUIRED)
add_executable(my_project src/my_project.cpp)
target_link_libraries(my_project ${async_comm_LIBRARIES})
Including as a submodule
If you don’t want to go with the ROS or system install options, the next easiest way to embed the async_comm
library in your project is as a Git submodule. The following instructions are for a project using Git for version control and CMake for a build system, but should serve as a starting point for other setups.
For example, to put async_comm
in the lib/async_comm directory
, run the following from the root of your project:
git submodule add https://github.com/dpkoch/async_comm.git lib/async_comm
Your CMakeLists.txt file would then look something like this:
```CMake cmake_minimum_required(VERSION 3.0.2)
File truncated at 100 lines see the full file
Changelog for package async_comm
0.2.1 (2021-01-21)
- Add noetic to ROS prerelease test distribution list
- Fixes for compatibility with ROS2 workspaces:
- cmake: Change install paths to basic lib/ and include/
- package.xml: Remove unneeded catkin dependency
- Updated CMake examples in README
- Contributors: Daniel Koch, Maciej Bogusz
0.2.0 (2020-03-16)
- Fix for UDP/TCP when loopback is only device with an address
- Added listener interface
- Added custom message handler functionality
- TCPClient class implementing an async tcp client
- Contributors: Daniel Koch, James Jackson, Rein Appeldoorn
0.1.1 (2019-02-21)
- Some cleanup
- Process callbacks on a separate thread
- Made buffer sizes constant, removed faulty mechanism for overriding
- Removed requirement that bulk write length be no greater than write buffer size
- Contributors: Daniel Koch
0.1.0 (2018-08-31)
- Initial release
- Contributors: Daniel Koch, James Jackson
Wiki Tutorials
Launch files
Messages
Services
Plugins
Recent questions tagged async_comm at Robotics Stack Exchange
![]() |
async_comm package from async_comm repoasync_comm |
ROS Distro
|
Package Summary
Tags | No category tags. |
Version | 0.2.1 |
License | BSD |
Build type | CMAKE |
Use | RECOMMENDED |
Repository Summary
Checkout URI | https://github.com/dpkoch/async_comm.git |
VCS Type | git |
VCS Version | master |
Last Updated | 2021-05-14 |
Dev Status | DEVELOPED |
CI status | Continuous Integration |
Released | RELEASED |
Tags | No category tags. |
Contributing |
Help Wanted (0)
Good First Issues (0) Pull Requests to Review (0) |
Package Description
Additional Links
Maintainers
- Daniel Koch
Authors
Async Comm Library
This project provides a C++ library that gives a simple interface for asynchronous serial communications over a serial port or UDP. It uses the Boost.Asio library under the hood, but hides from the user the details of interfacing with the ports or sockets and managing send/receive buffers.
Including in your project
There are three ways to use the async_comm
library in your project:
- If you’ll be using the library in a ROS package, install from the ROS repositories
- Build and install the library on your system, then use CMake’s
find_package()
functionality - Include the async_comm as a submodule in your project
With the second and third options, you will need to ensure that the Boost library is installed before proceeding:
sudo apt -y install libboost-dev libboost-system-dev
ROS install
The async_comm
library is released as a third-party, non-catkin package for ROS following the guidelines in REP 136. To use the library in your ROS package, first install the library from the ROS repositories:
sudo apt install ros-<DISTRO>-async-comm
Replace <DISTRO>
with your ROS distribution. The library is currently released for kinetic, lunar, and melodic.
Then, add something like the following lines to your package’s CMakeLists.txt:
# ...
find_package(async_comm REQUIRED)
catkin_package(
# ...
DEPENDS async_comm
)
# ...
add_executable(my_node src/my_node.cpp)
target_link_libraries(my_node ${async_comm_LIBRARIES})
Also be sure to list async_comm
as a dependency in your package.xml:
<?xml version="1.0"?>
<package format="2">
...
<depend>async_comm</depend>
...
</package>
System install
First, download and install the library:
git clone https://github.com/dpkoch/async_comm.git
cd async_comm
mkdir build && cd build/
cmake .. && make
sudo make install
Then, do something like this in your project’s CMakeLists.txt:
cmake_minimum_required(VERSION 3.0.2)
project(my_project)
find_package(async_comm REQUIRED)
add_executable(my_project src/my_project.cpp)
target_link_libraries(my_project ${async_comm_LIBRARIES})
Including as a submodule
If you don’t want to go with the ROS or system install options, the next easiest way to embed the async_comm
library in your project is as a Git submodule. The following instructions are for a project using Git for version control and CMake for a build system, but should serve as a starting point for other setups.
For example, to put async_comm
in the lib/async_comm directory
, run the following from the root of your project:
git submodule add https://github.com/dpkoch/async_comm.git lib/async_comm
Your CMakeLists.txt file would then look something like this:
```CMake cmake_minimum_required(VERSION 3.0.2)
File truncated at 100 lines see the full file
Changelog for package async_comm
0.2.1 (2021-01-21)
- Add noetic to ROS prerelease test distribution list
- Fixes for compatibility with ROS2 workspaces:
- cmake: Change install paths to basic lib/ and include/
- package.xml: Remove unneeded catkin dependency
- Updated CMake examples in README
- Contributors: Daniel Koch, Maciej Bogusz
0.2.0 (2020-03-16)
- Fix for UDP/TCP when loopback is only device with an address
- Added listener interface
- Added custom message handler functionality
- TCPClient class implementing an async tcp client
- Contributors: Daniel Koch, James Jackson, Rein Appeldoorn
0.1.1 (2019-02-21)
- Some cleanup
- Process callbacks on a separate thread
- Made buffer sizes constant, removed faulty mechanism for overriding
- Removed requirement that bulk write length be no greater than write buffer size
- Contributors: Daniel Koch
0.1.0 (2018-08-31)
- Initial release
- Contributors: Daniel Koch, James Jackson
Wiki Tutorials
Launch files
Messages
Services
Plugins
Recent questions tagged async_comm at Robotics Stack Exchange
![]() |
async_comm package from async_comm repoasync_comm |
ROS Distro
|
Package Summary
Tags | No category tags. |
Version | 0.2.1 |
License | BSD |
Build type | CMAKE |
Use | RECOMMENDED |
Repository Summary
Checkout URI | https://github.com/dpkoch/async_comm.git |
VCS Type | git |
VCS Version | master |
Last Updated | 2021-05-14 |
Dev Status | DEVELOPED |
CI status | Continuous Integration |
Released | RELEASED |
Tags | No category tags. |
Contributing |
Help Wanted (0)
Good First Issues (0) Pull Requests to Review (0) |
Package Description
Additional Links
Maintainers
- Daniel Koch
Authors
Async Comm Library
This project provides a C++ library that gives a simple interface for asynchronous serial communications over a serial port or UDP. It uses the Boost.Asio library under the hood, but hides from the user the details of interfacing with the ports or sockets and managing send/receive buffers.
Including in your project
There are three ways to use the async_comm
library in your project:
- If you’ll be using the library in a ROS package, install from the ROS repositories
- Build and install the library on your system, then use CMake’s
find_package()
functionality - Include the async_comm as a submodule in your project
With the second and third options, you will need to ensure that the Boost library is installed before proceeding:
sudo apt -y install libboost-dev libboost-system-dev
ROS install
The async_comm
library is released as a third-party, non-catkin package for ROS following the guidelines in REP 136. To use the library in your ROS package, first install the library from the ROS repositories:
sudo apt install ros-<DISTRO>-async-comm
Replace <DISTRO>
with your ROS distribution. The library is currently released for kinetic, lunar, and melodic.
Then, add something like the following lines to your package’s CMakeLists.txt:
# ...
find_package(async_comm REQUIRED)
catkin_package(
# ...
DEPENDS async_comm
)
# ...
add_executable(my_node src/my_node.cpp)
target_link_libraries(my_node ${async_comm_LIBRARIES})
Also be sure to list async_comm
as a dependency in your package.xml:
<?xml version="1.0"?>
<package format="2">
...
<depend>async_comm</depend>
...
</package>
System install
First, download and install the library:
git clone https://github.com/dpkoch/async_comm.git
cd async_comm
mkdir build && cd build/
cmake .. && make
sudo make install
Then, do something like this in your project’s CMakeLists.txt:
cmake_minimum_required(VERSION 3.0.2)
project(my_project)
find_package(async_comm REQUIRED)
add_executable(my_project src/my_project.cpp)
target_link_libraries(my_project ${async_comm_LIBRARIES})
Including as a submodule
If you don’t want to go with the ROS or system install options, the next easiest way to embed the async_comm
library in your project is as a Git submodule. The following instructions are for a project using Git for version control and CMake for a build system, but should serve as a starting point for other setups.
For example, to put async_comm
in the lib/async_comm directory
, run the following from the root of your project:
git submodule add https://github.com/dpkoch/async_comm.git lib/async_comm
Your CMakeLists.txt file would then look something like this:
```CMake cmake_minimum_required(VERSION 3.0.2)
File truncated at 100 lines see the full file
Changelog for package async_comm
0.2.1 (2021-01-21)
- Add noetic to ROS prerelease test distribution list
- Fixes for compatibility with ROS2 workspaces:
- cmake: Change install paths to basic lib/ and include/
- package.xml: Remove unneeded catkin dependency
- Updated CMake examples in README
- Contributors: Daniel Koch, Maciej Bogusz
0.2.0 (2020-03-16)
- Fix for UDP/TCP when loopback is only device with an address
- Added listener interface
- Added custom message handler functionality
- TCPClient class implementing an async tcp client
- Contributors: Daniel Koch, James Jackson, Rein Appeldoorn
0.1.1 (2019-02-21)
- Some cleanup
- Process callbacks on a separate thread
- Made buffer sizes constant, removed faulty mechanism for overriding
- Removed requirement that bulk write length be no greater than write buffer size
- Contributors: Daniel Koch
0.1.0 (2018-08-31)
- Initial release
- Contributors: Daniel Koch, James Jackson
Wiki Tutorials
Launch files
Messages
Services
Plugins
Recent questions tagged async_comm at Robotics Stack Exchange
![]() |
async_comm package from async_comm repoasync_comm |
ROS Distro
|
Package Summary
Tags | No category tags. |
Version | 0.2.1 |
License | BSD |
Build type | CMAKE |
Use | RECOMMENDED |
Repository Summary
Checkout URI | https://github.com/dpkoch/async_comm.git |
VCS Type | git |
VCS Version | master |
Last Updated | 2021-05-14 |
Dev Status | DEVELOPED |
CI status | Continuous Integration |
Released | RELEASED |
Tags | No category tags. |
Contributing |
Help Wanted (0)
Good First Issues (0) Pull Requests to Review (0) |
Package Description
Additional Links
Maintainers
- Daniel Koch
Authors
Async Comm Library
This project provides a C++ library that gives a simple interface for asynchronous serial communications over a serial port or UDP. It uses the Boost.Asio library under the hood, but hides from the user the details of interfacing with the ports or sockets and managing send/receive buffers.
Including in your project
There are three ways to use the async_comm
library in your project:
- If you’ll be using the library in a ROS package, install from the ROS repositories
- Build and install the library on your system, then use CMake’s
find_package()
functionality - Include the async_comm as a submodule in your project
With the second and third options, you will need to ensure that the Boost library is installed before proceeding:
sudo apt -y install libboost-dev libboost-system-dev
ROS install
The async_comm
library is released as a third-party, non-catkin package for ROS following the guidelines in REP 136. To use the library in your ROS package, first install the library from the ROS repositories:
sudo apt install ros-<DISTRO>-async-comm
Replace <DISTRO>
with your ROS distribution. The library is currently released for kinetic, lunar, and melodic.
Then, add something like the following lines to your package’s CMakeLists.txt:
# ...
find_package(async_comm REQUIRED)
catkin_package(
# ...
DEPENDS async_comm
)
# ...
add_executable(my_node src/my_node.cpp)
target_link_libraries(my_node ${async_comm_LIBRARIES})
Also be sure to list async_comm
as a dependency in your package.xml:
<?xml version="1.0"?>
<package format="2">
...
<depend>async_comm</depend>
...
</package>
System install
First, download and install the library:
git clone https://github.com/dpkoch/async_comm.git
cd async_comm
mkdir build && cd build/
cmake .. && make
sudo make install
Then, do something like this in your project’s CMakeLists.txt:
cmake_minimum_required(VERSION 3.0.2)
project(my_project)
find_package(async_comm REQUIRED)
add_executable(my_project src/my_project.cpp)
target_link_libraries(my_project ${async_comm_LIBRARIES})
Including as a submodule
If you don’t want to go with the ROS or system install options, the next easiest way to embed the async_comm
library in your project is as a Git submodule. The following instructions are for a project using Git for version control and CMake for a build system, but should serve as a starting point for other setups.
For example, to put async_comm
in the lib/async_comm directory
, run the following from the root of your project:
git submodule add https://github.com/dpkoch/async_comm.git lib/async_comm
Your CMakeLists.txt file would then look something like this:
```CMake cmake_minimum_required(VERSION 3.0.2)
File truncated at 100 lines see the full file
Changelog for package async_comm
0.2.1 (2021-01-21)
- Add noetic to ROS prerelease test distribution list
- Fixes for compatibility with ROS2 workspaces:
- cmake: Change install paths to basic lib/ and include/
- package.xml: Remove unneeded catkin dependency
- Updated CMake examples in README
- Contributors: Daniel Koch, Maciej Bogusz
0.2.0 (2020-03-16)
- Fix for UDP/TCP when loopback is only device with an address
- Added listener interface
- Added custom message handler functionality
- TCPClient class implementing an async tcp client
- Contributors: Daniel Koch, James Jackson, Rein Appeldoorn
0.1.1 (2019-02-21)
- Some cleanup
- Process callbacks on a separate thread
- Made buffer sizes constant, removed faulty mechanism for overriding
- Removed requirement that bulk write length be no greater than write buffer size
- Contributors: Daniel Koch
0.1.0 (2018-08-31)
- Initial release
- Contributors: Daniel Koch, James Jackson
Wiki Tutorials
Launch files
Messages
Services
Plugins
Recent questions tagged async_comm at Robotics Stack Exchange
![]() |
async_comm package from async_comm repoasync_comm |
ROS Distro
|
Package Summary
Tags | No category tags. |
Version | 0.2.1 |
License | BSD |
Build type | CMAKE |
Use | RECOMMENDED |
Repository Summary
Checkout URI | https://github.com/dpkoch/async_comm.git |
VCS Type | git |
VCS Version | master |
Last Updated | 2021-05-14 |
Dev Status | DEVELOPED |
CI status | Continuous Integration |
Released | RELEASED |
Tags | No category tags. |
Contributing |
Help Wanted (0)
Good First Issues (0) Pull Requests to Review (0) |
Package Description
Additional Links
Maintainers
- Daniel Koch
Authors
Async Comm Library
This project provides a C++ library that gives a simple interface for asynchronous serial communications over a serial port or UDP. It uses the Boost.Asio library under the hood, but hides from the user the details of interfacing with the ports or sockets and managing send/receive buffers.
Including in your project
There are three ways to use the async_comm
library in your project:
- If you’ll be using the library in a ROS package, install from the ROS repositories
- Build and install the library on your system, then use CMake’s
find_package()
functionality - Include the async_comm as a submodule in your project
With the second and third options, you will need to ensure that the Boost library is installed before proceeding:
sudo apt -y install libboost-dev libboost-system-dev
ROS install
The async_comm
library is released as a third-party, non-catkin package for ROS following the guidelines in REP 136. To use the library in your ROS package, first install the library from the ROS repositories:
sudo apt install ros-<DISTRO>-async-comm
Replace <DISTRO>
with your ROS distribution. The library is currently released for kinetic, lunar, and melodic.
Then, add something like the following lines to your package’s CMakeLists.txt:
# ...
find_package(async_comm REQUIRED)
catkin_package(
# ...
DEPENDS async_comm
)
# ...
add_executable(my_node src/my_node.cpp)
target_link_libraries(my_node ${async_comm_LIBRARIES})
Also be sure to list async_comm
as a dependency in your package.xml:
<?xml version="1.0"?>
<package format="2">
...
<depend>async_comm</depend>
...
</package>
System install
First, download and install the library:
git clone https://github.com/dpkoch/async_comm.git
cd async_comm
mkdir build && cd build/
cmake .. && make
sudo make install
Then, do something like this in your project’s CMakeLists.txt:
cmake_minimum_required(VERSION 3.0.2)
project(my_project)
find_package(async_comm REQUIRED)
add_executable(my_project src/my_project.cpp)
target_link_libraries(my_project ${async_comm_LIBRARIES})
Including as a submodule
If you don’t want to go with the ROS or system install options, the next easiest way to embed the async_comm
library in your project is as a Git submodule. The following instructions are for a project using Git for version control and CMake for a build system, but should serve as a starting point for other setups.
For example, to put async_comm
in the lib/async_comm directory
, run the following from the root of your project:
git submodule add https://github.com/dpkoch/async_comm.git lib/async_comm
Your CMakeLists.txt file would then look something like this:
```CMake cmake_minimum_required(VERSION 3.0.2)
File truncated at 100 lines see the full file
Changelog for package async_comm
0.2.1 (2021-01-21)
- Add noetic to ROS prerelease test distribution list
- Fixes for compatibility with ROS2 workspaces:
- cmake: Change install paths to basic lib/ and include/
- package.xml: Remove unneeded catkin dependency
- Updated CMake examples in README
- Contributors: Daniel Koch, Maciej Bogusz
0.2.0 (2020-03-16)
- Fix for UDP/TCP when loopback is only device with an address
- Added listener interface
- Added custom message handler functionality
- TCPClient class implementing an async tcp client
- Contributors: Daniel Koch, James Jackson, Rein Appeldoorn
0.1.1 (2019-02-21)
- Some cleanup
- Process callbacks on a separate thread
- Made buffer sizes constant, removed faulty mechanism for overriding
- Removed requirement that bulk write length be no greater than write buffer size
- Contributors: Daniel Koch
0.1.0 (2018-08-31)
- Initial release
- Contributors: Daniel Koch, James Jackson
Wiki Tutorials
Launch files
Messages
Services
Plugins
Recent questions tagged async_comm at Robotics Stack Exchange
![]() |
async_comm package from async_comm repoasync_comm |
ROS Distro
|
Package Summary
Tags | No category tags. |
Version | 0.2.1 |
License | BSD |
Build type | CMAKE |
Use | RECOMMENDED |
Repository Summary
Checkout URI | https://github.com/dpkoch/async_comm.git |
VCS Type | git |
VCS Version | master |
Last Updated | 2021-05-14 |
Dev Status | DEVELOPED |
CI status | Continuous Integration |
Released | RELEASED |
Tags | No category tags. |
Contributing |
Help Wanted (0)
Good First Issues (0) Pull Requests to Review (0) |
Package Description
Additional Links
Maintainers
- Daniel Koch
Authors
Async Comm Library
This project provides a C++ library that gives a simple interface for asynchronous serial communications over a serial port or UDP. It uses the Boost.Asio library under the hood, but hides from the user the details of interfacing with the ports or sockets and managing send/receive buffers.
Including in your project
There are three ways to use the async_comm
library in your project:
- If you’ll be using the library in a ROS package, install from the ROS repositories
- Build and install the library on your system, then use CMake’s
find_package()
functionality - Include the async_comm as a submodule in your project
With the second and third options, you will need to ensure that the Boost library is installed before proceeding:
sudo apt -y install libboost-dev libboost-system-dev
ROS install
The async_comm
library is released as a third-party, non-catkin package for ROS following the guidelines in REP 136. To use the library in your ROS package, first install the library from the ROS repositories:
sudo apt install ros-<DISTRO>-async-comm
Replace <DISTRO>
with your ROS distribution. The library is currently released for kinetic, lunar, and melodic.
Then, add something like the following lines to your package’s CMakeLists.txt:
# ...
find_package(async_comm REQUIRED)
catkin_package(
# ...
DEPENDS async_comm
)
# ...
add_executable(my_node src/my_node.cpp)
target_link_libraries(my_node ${async_comm_LIBRARIES})
Also be sure to list async_comm
as a dependency in your package.xml:
<?xml version="1.0"?>
<package format="2">
...
<depend>async_comm</depend>
...
</package>
System install
First, download and install the library:
git clone https://github.com/dpkoch/async_comm.git
cd async_comm
mkdir build && cd build/
cmake .. && make
sudo make install
Then, do something like this in your project’s CMakeLists.txt:
cmake_minimum_required(VERSION 3.0.2)
project(my_project)
find_package(async_comm REQUIRED)
add_executable(my_project src/my_project.cpp)
target_link_libraries(my_project ${async_comm_LIBRARIES})
Including as a submodule
If you don’t want to go with the ROS or system install options, the next easiest way to embed the async_comm
library in your project is as a Git submodule. The following instructions are for a project using Git for version control and CMake for a build system, but should serve as a starting point for other setups.
For example, to put async_comm
in the lib/async_comm directory
, run the following from the root of your project:
git submodule add https://github.com/dpkoch/async_comm.git lib/async_comm
Your CMakeLists.txt file would then look something like this:
```CMake cmake_minimum_required(VERSION 3.0.2)
File truncated at 100 lines see the full file
Changelog for package async_comm
0.2.1 (2021-01-21)
- Add noetic to ROS prerelease test distribution list
- Fixes for compatibility with ROS2 workspaces:
- cmake: Change install paths to basic lib/ and include/
- package.xml: Remove unneeded catkin dependency
- Updated CMake examples in README
- Contributors: Daniel Koch, Maciej Bogusz
0.2.0 (2020-03-16)
- Fix for UDP/TCP when loopback is only device with an address
- Added listener interface
- Added custom message handler functionality
- TCPClient class implementing an async tcp client
- Contributors: Daniel Koch, James Jackson, Rein Appeldoorn
0.1.1 (2019-02-21)
- Some cleanup
- Process callbacks on a separate thread
- Made buffer sizes constant, removed faulty mechanism for overriding
- Removed requirement that bulk write length be no greater than write buffer size
- Contributors: Daniel Koch
0.1.0 (2018-08-31)
- Initial release
- Contributors: Daniel Koch, James Jackson
Wiki Tutorials
Launch files
Messages
Services
Plugins
Recent questions tagged async_comm at Robotics Stack Exchange
![]() |
async_comm package from async_comm repoasync_comm |
ROS Distro
|
Package Summary
Tags | No category tags. |
Version | 0.2.1 |
License | BSD |
Build type | CMAKE |
Use | RECOMMENDED |
Repository Summary
Checkout URI | https://github.com/dpkoch/async_comm.git |
VCS Type | git |
VCS Version | master |
Last Updated | 2021-05-14 |
Dev Status | DEVELOPED |
CI status | Continuous Integration |
Released | RELEASED |
Tags | No category tags. |
Contributing |
Help Wanted (0)
Good First Issues (0) Pull Requests to Review (0) |
Package Description
Additional Links
Maintainers
- Daniel Koch
Authors
Async Comm Library
This project provides a C++ library that gives a simple interface for asynchronous serial communications over a serial port or UDP. It uses the Boost.Asio library under the hood, but hides from the user the details of interfacing with the ports or sockets and managing send/receive buffers.
Including in your project
There are three ways to use the async_comm
library in your project:
- If you’ll be using the library in a ROS package, install from the ROS repositories
- Build and install the library on your system, then use CMake’s
find_package()
functionality - Include the async_comm as a submodule in your project
With the second and third options, you will need to ensure that the Boost library is installed before proceeding:
sudo apt -y install libboost-dev libboost-system-dev
ROS install
The async_comm
library is released as a third-party, non-catkin package for ROS following the guidelines in REP 136. To use the library in your ROS package, first install the library from the ROS repositories:
sudo apt install ros-<DISTRO>-async-comm
Replace <DISTRO>
with your ROS distribution. The library is currently released for kinetic, lunar, and melodic.
Then, add something like the following lines to your package’s CMakeLists.txt:
# ...
find_package(async_comm REQUIRED)
catkin_package(
# ...
DEPENDS async_comm
)
# ...
add_executable(my_node src/my_node.cpp)
target_link_libraries(my_node ${async_comm_LIBRARIES})
Also be sure to list async_comm
as a dependency in your package.xml:
<?xml version="1.0"?>
<package format="2">
...
<depend>async_comm</depend>
...
</package>
System install
First, download and install the library:
git clone https://github.com/dpkoch/async_comm.git
cd async_comm
mkdir build && cd build/
cmake .. && make
sudo make install
Then, do something like this in your project’s CMakeLists.txt:
cmake_minimum_required(VERSION 3.0.2)
project(my_project)
find_package(async_comm REQUIRED)
add_executable(my_project src/my_project.cpp)
target_link_libraries(my_project ${async_comm_LIBRARIES})
Including as a submodule
If you don’t want to go with the ROS or system install options, the next easiest way to embed the async_comm
library in your project is as a Git submodule. The following instructions are for a project using Git for version control and CMake for a build system, but should serve as a starting point for other setups.
For example, to put async_comm
in the lib/async_comm directory
, run the following from the root of your project:
git submodule add https://github.com/dpkoch/async_comm.git lib/async_comm
Your CMakeLists.txt file would then look something like this:
```CMake cmake_minimum_required(VERSION 3.0.2)
File truncated at 100 lines see the full file
Changelog for package async_comm
0.2.1 (2021-01-21)
- Add noetic to ROS prerelease test distribution list
- Fixes for compatibility with ROS2 workspaces:
- cmake: Change install paths to basic lib/ and include/
- package.xml: Remove unneeded catkin dependency
- Updated CMake examples in README
- Contributors: Daniel Koch, Maciej Bogusz
0.2.0 (2020-03-16)
- Fix for UDP/TCP when loopback is only device with an address
- Added listener interface
- Added custom message handler functionality
- TCPClient class implementing an async tcp client
- Contributors: Daniel Koch, James Jackson, Rein Appeldoorn
0.1.1 (2019-02-21)
- Some cleanup
- Process callbacks on a separate thread
- Made buffer sizes constant, removed faulty mechanism for overriding
- Removed requirement that bulk write length be no greater than write buffer size
- Contributors: Daniel Koch
0.1.0 (2018-08-31)
- Initial release
- Contributors: Daniel Koch, James Jackson
Wiki Tutorials
Launch files
Messages
Services
Plugins
Recent questions tagged async_comm at Robotics Stack Exchange
![]() |
async_comm package from async_comm repoasync_comm |
ROS Distro
|
Package Summary
Tags | No category tags. |
Version | 0.2.1 |
License | BSD |
Build type | CMAKE |
Use | RECOMMENDED |
Repository Summary
Checkout URI | https://github.com/dpkoch/async_comm.git |
VCS Type | git |
VCS Version | master |
Last Updated | 2021-05-14 |
Dev Status | DEVELOPED |
CI status | Continuous Integration |
Released | RELEASED |
Tags | No category tags. |
Contributing |
Help Wanted (0)
Good First Issues (0) Pull Requests to Review (0) |
Package Description
Additional Links
Maintainers
- Daniel Koch
Authors
Async Comm Library
This project provides a C++ library that gives a simple interface for asynchronous serial communications over a serial port or UDP. It uses the Boost.Asio library under the hood, but hides from the user the details of interfacing with the ports or sockets and managing send/receive buffers.
Including in your project
There are three ways to use the async_comm
library in your project:
- If you’ll be using the library in a ROS package, install from the ROS repositories
- Build and install the library on your system, then use CMake’s
find_package()
functionality - Include the async_comm as a submodule in your project
With the second and third options, you will need to ensure that the Boost library is installed before proceeding:
sudo apt -y install libboost-dev libboost-system-dev
ROS install
The async_comm
library is released as a third-party, non-catkin package for ROS following the guidelines in REP 136. To use the library in your ROS package, first install the library from the ROS repositories:
sudo apt install ros-<DISTRO>-async-comm
Replace <DISTRO>
with your ROS distribution. The library is currently released for kinetic, lunar, and melodic.
Then, add something like the following lines to your package’s CMakeLists.txt:
# ...
find_package(async_comm REQUIRED)
catkin_package(
# ...
DEPENDS async_comm
)
# ...
add_executable(my_node src/my_node.cpp)
target_link_libraries(my_node ${async_comm_LIBRARIES})
Also be sure to list async_comm
as a dependency in your package.xml:
<?xml version="1.0"?>
<package format="2">
...
<depend>async_comm</depend>
...
</package>
System install
First, download and install the library:
git clone https://github.com/dpkoch/async_comm.git
cd async_comm
mkdir build && cd build/
cmake .. && make
sudo make install
Then, do something like this in your project’s CMakeLists.txt:
cmake_minimum_required(VERSION 3.0.2)
project(my_project)
find_package(async_comm REQUIRED)
add_executable(my_project src/my_project.cpp)
target_link_libraries(my_project ${async_comm_LIBRARIES})
Including as a submodule
If you don’t want to go with the ROS or system install options, the next easiest way to embed the async_comm
library in your project is as a Git submodule. The following instructions are for a project using Git for version control and CMake for a build system, but should serve as a starting point for other setups.
For example, to put async_comm
in the lib/async_comm directory
, run the following from the root of your project:
git submodule add https://github.com/dpkoch/async_comm.git lib/async_comm
Your CMakeLists.txt file would then look something like this:
```CMake cmake_minimum_required(VERSION 3.0.2)
File truncated at 100 lines see the full file
Changelog for package async_comm
0.2.1 (2021-01-21)
- Add noetic to ROS prerelease test distribution list
- Fixes for compatibility with ROS2 workspaces:
- cmake: Change install paths to basic lib/ and include/
- package.xml: Remove unneeded catkin dependency
- Updated CMake examples in README
- Contributors: Daniel Koch, Maciej Bogusz
0.2.0 (2020-03-16)
- Fix for UDP/TCP when loopback is only device with an address
- Added listener interface
- Added custom message handler functionality
- TCPClient class implementing an async tcp client
- Contributors: Daniel Koch, James Jackson, Rein Appeldoorn
0.1.1 (2019-02-21)
- Some cleanup
- Process callbacks on a separate thread
- Made buffer sizes constant, removed faulty mechanism for overriding
- Removed requirement that bulk write length be no greater than write buffer size
- Contributors: Daniel Koch
0.1.0 (2018-08-31)
- Initial release
- Contributors: Daniel Koch, James Jackson
Wiki Tutorials
Launch files
Messages
Services
Plugins
Recent questions tagged async_comm at Robotics Stack Exchange
![]() |
async_comm package from async_comm repoasync_comm |
ROS Distro
|
Package Summary
Tags | No category tags. |
Version | 0.2.1 |
License | BSD |
Build type | CMAKE |
Use | RECOMMENDED |
Repository Summary
Checkout URI | https://github.com/dpkoch/async_comm.git |
VCS Type | git |
VCS Version | master |
Last Updated | 2021-05-14 |
Dev Status | DEVELOPED |
CI status | Continuous Integration |
Released | RELEASED |
Tags | No category tags. |
Contributing |
Help Wanted (0)
Good First Issues (0) Pull Requests to Review (0) |
Package Description
Additional Links
Maintainers
- Daniel Koch
Authors
Async Comm Library
This project provides a C++ library that gives a simple interface for asynchronous serial communications over a serial port or UDP. It uses the Boost.Asio library under the hood, but hides from the user the details of interfacing with the ports or sockets and managing send/receive buffers.
Including in your project
There are three ways to use the async_comm
library in your project:
- If you’ll be using the library in a ROS package, install from the ROS repositories
- Build and install the library on your system, then use CMake’s
find_package()
functionality - Include the async_comm as a submodule in your project
With the second and third options, you will need to ensure that the Boost library is installed before proceeding:
sudo apt -y install libboost-dev libboost-system-dev
ROS install
The async_comm
library is released as a third-party, non-catkin package for ROS following the guidelines in REP 136. To use the library in your ROS package, first install the library from the ROS repositories:
sudo apt install ros-<DISTRO>-async-comm
Replace <DISTRO>
with your ROS distribution. The library is currently released for kinetic, lunar, and melodic.
Then, add something like the following lines to your package’s CMakeLists.txt:
# ...
find_package(async_comm REQUIRED)
catkin_package(
# ...
DEPENDS async_comm
)
# ...
add_executable(my_node src/my_node.cpp)
target_link_libraries(my_node ${async_comm_LIBRARIES})
Also be sure to list async_comm
as a dependency in your package.xml:
<?xml version="1.0"?>
<package format="2">
...
<depend>async_comm</depend>
...
</package>
System install
First, download and install the library:
git clone https://github.com/dpkoch/async_comm.git
cd async_comm
mkdir build && cd build/
cmake .. && make
sudo make install
Then, do something like this in your project’s CMakeLists.txt:
cmake_minimum_required(VERSION 3.0.2)
project(my_project)
find_package(async_comm REQUIRED)
add_executable(my_project src/my_project.cpp)
target_link_libraries(my_project ${async_comm_LIBRARIES})
Including as a submodule
If you don’t want to go with the ROS or system install options, the next easiest way to embed the async_comm
library in your project is as a Git submodule. The following instructions are for a project using Git for version control and CMake for a build system, but should serve as a starting point for other setups.
For example, to put async_comm
in the lib/async_comm directory
, run the following from the root of your project:
git submodule add https://github.com/dpkoch/async_comm.git lib/async_comm
Your CMakeLists.txt file would then look something like this:
```CMake cmake_minimum_required(VERSION 3.0.2)
File truncated at 100 lines see the full file
Changelog for package async_comm
0.2.1 (2021-01-21)
- Add noetic to ROS prerelease test distribution list
- Fixes for compatibility with ROS2 workspaces:
- cmake: Change install paths to basic lib/ and include/
- package.xml: Remove unneeded catkin dependency
- Updated CMake examples in README
- Contributors: Daniel Koch, Maciej Bogusz
0.2.0 (2020-03-16)
- Fix for UDP/TCP when loopback is only device with an address
- Added listener interface
- Added custom message handler functionality
- TCPClient class implementing an async tcp client
- Contributors: Daniel Koch, James Jackson, Rein Appeldoorn
0.1.1 (2019-02-21)
- Some cleanup
- Process callbacks on a separate thread
- Made buffer sizes constant, removed faulty mechanism for overriding
- Removed requirement that bulk write length be no greater than write buffer size
- Contributors: Daniel Koch
0.1.0 (2018-08-31)
- Initial release
- Contributors: Daniel Koch, James Jackson
Wiki Tutorials
Launch files
Messages
Services
Plugins
Recent questions tagged async_comm at Robotics Stack Exchange
![]() |
async_comm package from async_comm repoasync_comm |
ROS Distro
|
Package Summary
Tags | No category tags. |
Version | 0.2.1 |
License | BSD |
Build type | CMAKE |
Use | RECOMMENDED |
Repository Summary
Checkout URI | https://github.com/dpkoch/async_comm.git |
VCS Type | git |
VCS Version | master |
Last Updated | 2021-05-14 |
Dev Status | DEVELOPED |
CI status | Continuous Integration |
Released | RELEASED |
Tags | No category tags. |
Contributing |
Help Wanted (0)
Good First Issues (0) Pull Requests to Review (0) |
Package Description
Additional Links
Maintainers
- Daniel Koch
Authors
Async Comm Library
This project provides a C++ library that gives a simple interface for asynchronous serial communications over a serial port or UDP. It uses the Boost.Asio library under the hood, but hides from the user the details of interfacing with the ports or sockets and managing send/receive buffers.
Including in your project
There are three ways to use the async_comm
library in your project:
- If you’ll be using the library in a ROS package, install from the ROS repositories
- Build and install the library on your system, then use CMake’s
find_package()
functionality - Include the async_comm as a submodule in your project
With the second and third options, you will need to ensure that the Boost library is installed before proceeding:
sudo apt -y install libboost-dev libboost-system-dev
ROS install
The async_comm
library is released as a third-party, non-catkin package for ROS following the guidelines in REP 136. To use the library in your ROS package, first install the library from the ROS repositories:
sudo apt install ros-<DISTRO>-async-comm
Replace <DISTRO>
with your ROS distribution. The library is currently released for kinetic, lunar, and melodic.
Then, add something like the following lines to your package’s CMakeLists.txt:
# ...
find_package(async_comm REQUIRED)
catkin_package(
# ...
DEPENDS async_comm
)
# ...
add_executable(my_node src/my_node.cpp)
target_link_libraries(my_node ${async_comm_LIBRARIES})
Also be sure to list async_comm
as a dependency in your package.xml:
<?xml version="1.0"?>
<package format="2">
...
<depend>async_comm</depend>
...
</package>
System install
First, download and install the library:
git clone https://github.com/dpkoch/async_comm.git
cd async_comm
mkdir build && cd build/
cmake .. && make
sudo make install
Then, do something like this in your project’s CMakeLists.txt:
cmake_minimum_required(VERSION 3.0.2)
project(my_project)
find_package(async_comm REQUIRED)
add_executable(my_project src/my_project.cpp)
target_link_libraries(my_project ${async_comm_LIBRARIES})
Including as a submodule
If you don’t want to go with the ROS or system install options, the next easiest way to embed the async_comm
library in your project is as a Git submodule. The following instructions are for a project using Git for version control and CMake for a build system, but should serve as a starting point for other setups.
For example, to put async_comm
in the lib/async_comm directory
, run the following from the root of your project:
git submodule add https://github.com/dpkoch/async_comm.git lib/async_comm
Your CMakeLists.txt file would then look something like this:
```CMake cmake_minimum_required(VERSION 3.0.2)
File truncated at 100 lines see the full file
Changelog for package async_comm
0.2.1 (2021-01-21)
- Add noetic to ROS prerelease test distribution list
- Fixes for compatibility with ROS2 workspaces:
- cmake: Change install paths to basic lib/ and include/
- package.xml: Remove unneeded catkin dependency
- Updated CMake examples in README
- Contributors: Daniel Koch, Maciej Bogusz
0.2.0 (2020-03-16)
- Fix for UDP/TCP when loopback is only device with an address
- Added listener interface
- Added custom message handler functionality
- TCPClient class implementing an async tcp client
- Contributors: Daniel Koch, James Jackson, Rein Appeldoorn
0.1.1 (2019-02-21)
- Some cleanup
- Process callbacks on a separate thread
- Made buffer sizes constant, removed faulty mechanism for overriding
- Removed requirement that bulk write length be no greater than write buffer size
- Contributors: Daniel Koch
0.1.0 (2018-08-31)
- Initial release
- Contributors: Daniel Koch, James Jackson
Wiki Tutorials
Launch files
Messages
Services
Plugins
Recent questions tagged async_comm at Robotics Stack Exchange
![]() |
async_comm package from async_comm repoasync_comm |
ROS Distro
|
Package Summary
Tags | No category tags. |
Version | 0.2.1 |
License | BSD |
Build type | CMAKE |
Use | RECOMMENDED |
Repository Summary
Checkout URI | https://github.com/dpkoch/async_comm.git |
VCS Type | git |
VCS Version | master |
Last Updated | 2021-05-14 |
Dev Status | DEVELOPED |
CI status | Continuous Integration |
Released | RELEASED |
Tags | No category tags. |
Contributing |
Help Wanted (0)
Good First Issues (0) Pull Requests to Review (0) |
Package Description
Additional Links
Maintainers
- Daniel Koch
Authors
Async Comm Library
This project provides a C++ library that gives a simple interface for asynchronous serial communications over a serial port or UDP. It uses the Boost.Asio library under the hood, but hides from the user the details of interfacing with the ports or sockets and managing send/receive buffers.
Including in your project
There are three ways to use the async_comm
library in your project:
- If you’ll be using the library in a ROS package, install from the ROS repositories
- Build and install the library on your system, then use CMake’s
find_package()
functionality - Include the async_comm as a submodule in your project
With the second and third options, you will need to ensure that the Boost library is installed before proceeding:
sudo apt -y install libboost-dev libboost-system-dev
ROS install
The async_comm
library is released as a third-party, non-catkin package for ROS following the guidelines in REP 136. To use the library in your ROS package, first install the library from the ROS repositories:
sudo apt install ros-<DISTRO>-async-comm
Replace <DISTRO>
with your ROS distribution. The library is currently released for kinetic, lunar, and melodic.
Then, add something like the following lines to your package’s CMakeLists.txt:
# ...
find_package(async_comm REQUIRED)
catkin_package(
# ...
DEPENDS async_comm
)
# ...
add_executable(my_node src/my_node.cpp)
target_link_libraries(my_node ${async_comm_LIBRARIES})
Also be sure to list async_comm
as a dependency in your package.xml:
<?xml version="1.0"?>
<package format="2">
...
<depend>async_comm</depend>
...
</package>
System install
First, download and install the library:
git clone https://github.com/dpkoch/async_comm.git
cd async_comm
mkdir build && cd build/
cmake .. && make
sudo make install
Then, do something like this in your project’s CMakeLists.txt:
cmake_minimum_required(VERSION 3.0.2)
project(my_project)
find_package(async_comm REQUIRED)
add_executable(my_project src/my_project.cpp)
target_link_libraries(my_project ${async_comm_LIBRARIES})
Including as a submodule
If you don’t want to go with the ROS or system install options, the next easiest way to embed the async_comm
library in your project is as a Git submodule. The following instructions are for a project using Git for version control and CMake for a build system, but should serve as a starting point for other setups.
For example, to put async_comm
in the lib/async_comm directory
, run the following from the root of your project:
git submodule add https://github.com/dpkoch/async_comm.git lib/async_comm
Your CMakeLists.txt file would then look something like this:
```CMake cmake_minimum_required(VERSION 3.0.2)
File truncated at 100 lines see the full file
Changelog for package async_comm
0.2.1 (2021-01-21)
- Add noetic to ROS prerelease test distribution list
- Fixes for compatibility with ROS2 workspaces:
- cmake: Change install paths to basic lib/ and include/
- package.xml: Remove unneeded catkin dependency
- Updated CMake examples in README
- Contributors: Daniel Koch, Maciej Bogusz
0.2.0 (2020-03-16)
- Fix for UDP/TCP when loopback is only device with an address
- Added listener interface
- Added custom message handler functionality
- TCPClient class implementing an async tcp client
- Contributors: Daniel Koch, James Jackson, Rein Appeldoorn
0.1.1 (2019-02-21)
- Some cleanup
- Process callbacks on a separate thread
- Made buffer sizes constant, removed faulty mechanism for overriding
- Removed requirement that bulk write length be no greater than write buffer size
- Contributors: Daniel Koch
0.1.0 (2018-08-31)
- Initial release
- Contributors: Daniel Koch, James Jackson
Wiki Tutorials
Launch files
Messages
Services
Plugins
Recent questions tagged async_comm at Robotics Stack Exchange
![]() |
async_comm package from async_comm repoasync_comm |
ROS Distro
|
Package Summary
Tags | No category tags. |
Version | 0.2.1 |
License | BSD |
Build type | CMAKE |
Use | RECOMMENDED |
Repository Summary
Checkout URI | https://github.com/dpkoch/async_comm.git |
VCS Type | git |
VCS Version | master |
Last Updated | 2021-05-14 |
Dev Status | DEVELOPED |
CI status | Continuous Integration |
Released | RELEASED |
Tags | No category tags. |
Contributing |
Help Wanted (0)
Good First Issues (0) Pull Requests to Review (0) |
Package Description
Additional Links
Maintainers
- Daniel Koch
Authors
Async Comm Library
This project provides a C++ library that gives a simple interface for asynchronous serial communications over a serial port or UDP. It uses the Boost.Asio library under the hood, but hides from the user the details of interfacing with the ports or sockets and managing send/receive buffers.
Including in your project
There are three ways to use the async_comm
library in your project:
- If you’ll be using the library in a ROS package, install from the ROS repositories
- Build and install the library on your system, then use CMake’s
find_package()
functionality - Include the async_comm as a submodule in your project
With the second and third options, you will need to ensure that the Boost library is installed before proceeding:
sudo apt -y install libboost-dev libboost-system-dev
ROS install
The async_comm
library is released as a third-party, non-catkin package for ROS following the guidelines in REP 136. To use the library in your ROS package, first install the library from the ROS repositories:
sudo apt install ros-<DISTRO>-async-comm
Replace <DISTRO>
with your ROS distribution. The library is currently released for kinetic, lunar, and melodic.
Then, add something like the following lines to your package’s CMakeLists.txt:
# ...
find_package(async_comm REQUIRED)
catkin_package(
# ...
DEPENDS async_comm
)
# ...
add_executable(my_node src/my_node.cpp)
target_link_libraries(my_node ${async_comm_LIBRARIES})
Also be sure to list async_comm
as a dependency in your package.xml:
<?xml version="1.0"?>
<package format="2">
...
<depend>async_comm</depend>
...
</package>
System install
First, download and install the library:
git clone https://github.com/dpkoch/async_comm.git
cd async_comm
mkdir build && cd build/
cmake .. && make
sudo make install
Then, do something like this in your project’s CMakeLists.txt:
cmake_minimum_required(VERSION 3.0.2)
project(my_project)
find_package(async_comm REQUIRED)
add_executable(my_project src/my_project.cpp)
target_link_libraries(my_project ${async_comm_LIBRARIES})
Including as a submodule
If you don’t want to go with the ROS or system install options, the next easiest way to embed the async_comm
library in your project is as a Git submodule. The following instructions are for a project using Git for version control and CMake for a build system, but should serve as a starting point for other setups.
For example, to put async_comm
in the lib/async_comm directory
, run the following from the root of your project:
git submodule add https://github.com/dpkoch/async_comm.git lib/async_comm
Your CMakeLists.txt file would then look something like this:
```CMake cmake_minimum_required(VERSION 3.0.2)
File truncated at 100 lines see the full file
Changelog for package async_comm
0.2.1 (2021-01-21)
- Add noetic to ROS prerelease test distribution list
- Fixes for compatibility with ROS2 workspaces:
- cmake: Change install paths to basic lib/ and include/
- package.xml: Remove unneeded catkin dependency
- Updated CMake examples in README
- Contributors: Daniel Koch, Maciej Bogusz
0.2.0 (2020-03-16)
- Fix for UDP/TCP when loopback is only device with an address
- Added listener interface
- Added custom message handler functionality
- TCPClient class implementing an async tcp client
- Contributors: Daniel Koch, James Jackson, Rein Appeldoorn
0.1.1 (2019-02-21)
- Some cleanup
- Process callbacks on a separate thread
- Made buffer sizes constant, removed faulty mechanism for overriding
- Removed requirement that bulk write length be no greater than write buffer size
- Contributors: Daniel Koch
0.1.0 (2018-08-31)
- Initial release
- Contributors: Daniel Koch, James Jackson
Wiki Tutorials
Launch files
Messages
Services
Plugins
Recent questions tagged async_comm at Robotics Stack Exchange
![]() |
async_comm package from async_comm repoasync_comm |
ROS Distro
|
Package Summary
Tags | No category tags. |
Version | 0.2.1 |
License | BSD |
Build type | CMAKE |
Use | RECOMMENDED |
Repository Summary
Checkout URI | https://github.com/dpkoch/async_comm.git |
VCS Type | git |
VCS Version | master |
Last Updated | 2021-05-14 |
Dev Status | DEVELOPED |
CI status | Continuous Integration |
Released | RELEASED |
Tags | No category tags. |
Contributing |
Help Wanted (0)
Good First Issues (0) Pull Requests to Review (0) |
Package Description
Additional Links
Maintainers
- Daniel Koch
Authors
Async Comm Library
This project provides a C++ library that gives a simple interface for asynchronous serial communications over a serial port or UDP. It uses the Boost.Asio library under the hood, but hides from the user the details of interfacing with the ports or sockets and managing send/receive buffers.
Including in your project
There are three ways to use the async_comm
library in your project:
- If you’ll be using the library in a ROS package, install from the ROS repositories
- Build and install the library on your system, then use CMake’s
find_package()
functionality - Include the async_comm as a submodule in your project
With the second and third options, you will need to ensure that the Boost library is installed before proceeding:
sudo apt -y install libboost-dev libboost-system-dev
ROS install
The async_comm
library is released as a third-party, non-catkin package for ROS following the guidelines in REP 136. To use the library in your ROS package, first install the library from the ROS repositories:
sudo apt install ros-<DISTRO>-async-comm
Replace <DISTRO>
with your ROS distribution. The library is currently released for kinetic, lunar, and melodic.
Then, add something like the following lines to your package’s CMakeLists.txt:
# ...
find_package(async_comm REQUIRED)
catkin_package(
# ...
DEPENDS async_comm
)
# ...
add_executable(my_node src/my_node.cpp)
target_link_libraries(my_node ${async_comm_LIBRARIES})
Also be sure to list async_comm
as a dependency in your package.xml:
<?xml version="1.0"?>
<package format="2">
...
<depend>async_comm</depend>
...
</package>
System install
First, download and install the library:
git clone https://github.com/dpkoch/async_comm.git
cd async_comm
mkdir build && cd build/
cmake .. && make
sudo make install
Then, do something like this in your project’s CMakeLists.txt:
cmake_minimum_required(VERSION 3.0.2)
project(my_project)
find_package(async_comm REQUIRED)
add_executable(my_project src/my_project.cpp)
target_link_libraries(my_project ${async_comm_LIBRARIES})
Including as a submodule
If you don’t want to go with the ROS or system install options, the next easiest way to embed the async_comm
library in your project is as a Git submodule. The following instructions are for a project using Git for version control and CMake for a build system, but should serve as a starting point for other setups.
For example, to put async_comm
in the lib/async_comm directory
, run the following from the root of your project:
git submodule add https://github.com/dpkoch/async_comm.git lib/async_comm
Your CMakeLists.txt file would then look something like this:
```CMake cmake_minimum_required(VERSION 3.0.2)
File truncated at 100 lines see the full file
Changelog for package async_comm
0.2.1 (2021-01-21)
- Add noetic to ROS prerelease test distribution list
- Fixes for compatibility with ROS2 workspaces:
- cmake: Change install paths to basic lib/ and include/
- package.xml: Remove unneeded catkin dependency
- Updated CMake examples in README
- Contributors: Daniel Koch, Maciej Bogusz
0.2.0 (2020-03-16)
- Fix for UDP/TCP when loopback is only device with an address
- Added listener interface
- Added custom message handler functionality
- TCPClient class implementing an async tcp client
- Contributors: Daniel Koch, James Jackson, Rein Appeldoorn
0.1.1 (2019-02-21)
- Some cleanup
- Process callbacks on a separate thread
- Made buffer sizes constant, removed faulty mechanism for overriding
- Removed requirement that bulk write length be no greater than write buffer size
- Contributors: Daniel Koch
0.1.0 (2018-08-31)
- Initial release
- Contributors: Daniel Koch, James Jackson
Wiki Tutorials
Launch files
Messages
Services
Plugins
Recent questions tagged async_comm at Robotics Stack Exchange
![]() |
async_comm package from async_comm repoasync_comm |
ROS Distro
|
Package Summary
Tags | No category tags. |
Version | 0.2.1 |
License | BSD |
Build type | CMAKE |
Use | RECOMMENDED |
Repository Summary
Checkout URI | https://github.com/dpkoch/async_comm.git |
VCS Type | git |
VCS Version | master |
Last Updated | 2021-05-14 |
Dev Status | DEVELOPED |
CI status | Continuous Integration |
Released | RELEASED |
Tags | No category tags. |
Contributing |
Help Wanted (0)
Good First Issues (0) Pull Requests to Review (0) |
Package Description
Additional Links
Maintainers
- Daniel Koch
Authors
Async Comm Library
This project provides a C++ library that gives a simple interface for asynchronous serial communications over a serial port or UDP. It uses the Boost.Asio library under the hood, but hides from the user the details of interfacing with the ports or sockets and managing send/receive buffers.
Including in your project
There are three ways to use the async_comm
library in your project:
- If you’ll be using the library in a ROS package, install from the ROS repositories
- Build and install the library on your system, then use CMake’s
find_package()
functionality - Include the async_comm as a submodule in your project
With the second and third options, you will need to ensure that the Boost library is installed before proceeding:
sudo apt -y install libboost-dev libboost-system-dev
ROS install
The async_comm
library is released as a third-party, non-catkin package for ROS following the guidelines in REP 136. To use the library in your ROS package, first install the library from the ROS repositories:
sudo apt install ros-<DISTRO>-async-comm
Replace <DISTRO>
with your ROS distribution. The library is currently released for kinetic, lunar, and melodic.
Then, add something like the following lines to your package’s CMakeLists.txt:
# ...
find_package(async_comm REQUIRED)
catkin_package(
# ...
DEPENDS async_comm
)
# ...
add_executable(my_node src/my_node.cpp)
target_link_libraries(my_node ${async_comm_LIBRARIES})
Also be sure to list async_comm
as a dependency in your package.xml:
<?xml version="1.0"?>
<package format="2">
...
<depend>async_comm</depend>
...
</package>
System install
First, download and install the library:
git clone https://github.com/dpkoch/async_comm.git
cd async_comm
mkdir build && cd build/
cmake .. && make
sudo make install
Then, do something like this in your project’s CMakeLists.txt:
cmake_minimum_required(VERSION 3.0.2)
project(my_project)
find_package(async_comm REQUIRED)
add_executable(my_project src/my_project.cpp)
target_link_libraries(my_project ${async_comm_LIBRARIES})
Including as a submodule
If you don’t want to go with the ROS or system install options, the next easiest way to embed the async_comm
library in your project is as a Git submodule. The following instructions are for a project using Git for version control and CMake for a build system, but should serve as a starting point for other setups.
For example, to put async_comm
in the lib/async_comm directory
, run the following from the root of your project:
git submodule add https://github.com/dpkoch/async_comm.git lib/async_comm
Your CMakeLists.txt file would then look something like this:
```CMake cmake_minimum_required(VERSION 3.0.2)
File truncated at 100 lines see the full file
Changelog for package async_comm
0.2.1 (2021-01-21)
- Add noetic to ROS prerelease test distribution list
- Fixes for compatibility with ROS2 workspaces:
- cmake: Change install paths to basic lib/ and include/
- package.xml: Remove unneeded catkin dependency
- Updated CMake examples in README
- Contributors: Daniel Koch, Maciej Bogusz
0.2.0 (2020-03-16)
- Fix for UDP/TCP when loopback is only device with an address
- Added listener interface
- Added custom message handler functionality
- TCPClient class implementing an async tcp client
- Contributors: Daniel Koch, James Jackson, Rein Appeldoorn
0.1.1 (2019-02-21)
- Some cleanup
- Process callbacks on a separate thread
- Made buffer sizes constant, removed faulty mechanism for overriding
- Removed requirement that bulk write length be no greater than write buffer size
- Contributors: Daniel Koch
0.1.0 (2018-08-31)
- Initial release
- Contributors: Daniel Koch, James Jackson
Wiki Tutorials
Launch files
Messages
Services
Plugins
Recent questions tagged async_comm at Robotics Stack Exchange
![]() |
async_comm package from async_comm repoasync_comm |
ROS Distro
|
Package Summary
Tags | No category tags. |
Version | 0.2.1 |
License | BSD |
Build type | CMAKE |
Use | RECOMMENDED |
Repository Summary
Checkout URI | https://github.com/dpkoch/async_comm.git |
VCS Type | git |
VCS Version | master |
Last Updated | 2021-05-14 |
Dev Status | DEVELOPED |
CI status | Continuous Integration : 0 / 0 |
Released | RELEASED |
Tags | No category tags. |
Contributing |
Help Wanted (0)
Good First Issues (0) Pull Requests to Review (0) |
Package Description
Additional Links
Maintainers
- Daniel Koch
Authors
Async Comm Library
This project provides a C++ library that gives a simple interface for asynchronous serial communications over a serial port or UDP. It uses the Boost.Asio library under the hood, but hides from the user the details of interfacing with the ports or sockets and managing send/receive buffers.
Including in your project
There are three ways to use the async_comm
library in your project:
- If you’ll be using the library in a ROS package, install from the ROS repositories
- Build and install the library on your system, then use CMake’s
find_package()
functionality - Include the async_comm as a submodule in your project
With the second and third options, you will need to ensure that the Boost library is installed before proceeding:
sudo apt -y install libboost-dev libboost-system-dev
ROS install
The async_comm
library is released as a third-party, non-catkin package for ROS following the guidelines in REP 136. To use the library in your ROS package, first install the library from the ROS repositories:
sudo apt install ros-<DISTRO>-async-comm
Replace <DISTRO>
with your ROS distribution. The library is currently released for kinetic, lunar, and melodic.
Then, add something like the following lines to your package’s CMakeLists.txt:
# ...
find_package(async_comm REQUIRED)
catkin_package(
# ...
DEPENDS async_comm
)
# ...
add_executable(my_node src/my_node.cpp)
target_link_libraries(my_node ${async_comm_LIBRARIES})
Also be sure to list async_comm
as a dependency in your package.xml:
<?xml version="1.0"?>
<package format="2">
...
<depend>async_comm</depend>
...
</package>
System install
First, download and install the library:
git clone https://github.com/dpkoch/async_comm.git
cd async_comm
mkdir build && cd build/
cmake .. && make
sudo make install
Then, do something like this in your project’s CMakeLists.txt:
cmake_minimum_required(VERSION 3.0.2)
project(my_project)
find_package(async_comm REQUIRED)
add_executable(my_project src/my_project.cpp)
target_link_libraries(my_project ${async_comm_LIBRARIES})
Including as a submodule
If you don’t want to go with the ROS or system install options, the next easiest way to embed the async_comm
library in your project is as a Git submodule. The following instructions are for a project using Git for version control and CMake for a build system, but should serve as a starting point for other setups.
For example, to put async_comm
in the lib/async_comm directory
, run the following from the root of your project:
git submodule add https://github.com/dpkoch/async_comm.git lib/async_comm
Your CMakeLists.txt file would then look something like this:
```CMake cmake_minimum_required(VERSION 3.0.2)
File truncated at 100 lines see the full file
Changelog for package async_comm
0.2.1 (2021-01-21)
- Add noetic to ROS prerelease test distribution list
- Fixes for compatibility with ROS2 workspaces:
- cmake: Change install paths to basic lib/ and include/
- package.xml: Remove unneeded catkin dependency
- Updated CMake examples in README
- Contributors: Daniel Koch, Maciej Bogusz
0.2.0 (2020-03-16)
- Fix for UDP/TCP when loopback is only device with an address
- Added listener interface
- Added custom message handler functionality
- TCPClient class implementing an async tcp client
- Contributors: Daniel Koch, James Jackson, Rein Appeldoorn
0.1.1 (2019-02-21)
- Some cleanup
- Process callbacks on a separate thread
- Made buffer sizes constant, removed faulty mechanism for overriding
- Removed requirement that bulk write length be no greater than write buffer size
- Contributors: Daniel Koch
0.1.0 (2018-08-31)
- Initial release
- Contributors: Daniel Koch, James Jackson
Wiki Tutorials
Launch files
Messages
Services
Plugins
Recent questions tagged async_comm at Robotics Stack Exchange
![]() |
async_comm package from async_comm repoasync_comm |
ROS Distro
|
Package Summary
Tags | No category tags. |
Version | 0.2.1 |
License | BSD |
Build type | CMAKE |
Use | RECOMMENDED |
Repository Summary
Checkout URI | https://github.com/dpkoch/async_comm.git |
VCS Type | git |
VCS Version | master |
Last Updated | 2021-05-14 |
Dev Status | DEVELOPED |
CI status | Continuous Integration |
Released | RELEASED |
Tags | No category tags. |
Contributing |
Help Wanted (0)
Good First Issues (0) Pull Requests to Review (0) |
Package Description
Additional Links
Maintainers
- Daniel Koch
Authors
Async Comm Library
This project provides a C++ library that gives a simple interface for asynchronous serial communications over a serial port or UDP. It uses the Boost.Asio library under the hood, but hides from the user the details of interfacing with the ports or sockets and managing send/receive buffers.
Including in your project
There are three ways to use the async_comm
library in your project:
- If you’ll be using the library in a ROS package, install from the ROS repositories
- Build and install the library on your system, then use CMake’s
find_package()
functionality - Include the async_comm as a submodule in your project
With the second and third options, you will need to ensure that the Boost library is installed before proceeding:
sudo apt -y install libboost-dev libboost-system-dev
ROS install
The async_comm
library is released as a third-party, non-catkin package for ROS following the guidelines in REP 136. To use the library in your ROS package, first install the library from the ROS repositories:
sudo apt install ros-<DISTRO>-async-comm
Replace <DISTRO>
with your ROS distribution. The library is currently released for kinetic, lunar, and melodic.
Then, add something like the following lines to your package’s CMakeLists.txt:
# ...
find_package(async_comm REQUIRED)
catkin_package(
# ...
DEPENDS async_comm
)
# ...
add_executable(my_node src/my_node.cpp)
target_link_libraries(my_node ${async_comm_LIBRARIES})
Also be sure to list async_comm
as a dependency in your package.xml:
<?xml version="1.0"?>
<package format="2">
...
<depend>async_comm</depend>
...
</package>
System install
First, download and install the library:
git clone https://github.com/dpkoch/async_comm.git
cd async_comm
mkdir build && cd build/
cmake .. && make
sudo make install
Then, do something like this in your project’s CMakeLists.txt:
cmake_minimum_required(VERSION 3.0.2)
project(my_project)
find_package(async_comm REQUIRED)
add_executable(my_project src/my_project.cpp)
target_link_libraries(my_project ${async_comm_LIBRARIES})
Including as a submodule
If you don’t want to go with the ROS or system install options, the next easiest way to embed the async_comm
library in your project is as a Git submodule. The following instructions are for a project using Git for version control and CMake for a build system, but should serve as a starting point for other setups.
For example, to put async_comm
in the lib/async_comm directory
, run the following from the root of your project:
git submodule add https://github.com/dpkoch/async_comm.git lib/async_comm
Your CMakeLists.txt file would then look something like this:
```CMake cmake_minimum_required(VERSION 3.0.2)
File truncated at 100 lines see the full file
Changelog for package async_comm
0.2.1 (2021-01-21)
- Add noetic to ROS prerelease test distribution list
- Fixes for compatibility with ROS2 workspaces:
- cmake: Change install paths to basic lib/ and include/
- package.xml: Remove unneeded catkin dependency
- Updated CMake examples in README
- Contributors: Daniel Koch, Maciej Bogusz
0.2.0 (2020-03-16)
- Fix for UDP/TCP when loopback is only device with an address
- Added listener interface
- Added custom message handler functionality
- TCPClient class implementing an async tcp client
- Contributors: Daniel Koch, James Jackson, Rein Appeldoorn
0.1.1 (2019-02-21)
- Some cleanup
- Process callbacks on a separate thread
- Made buffer sizes constant, removed faulty mechanism for overriding
- Removed requirement that bulk write length be no greater than write buffer size
- Contributors: Daniel Koch
0.1.0 (2018-08-31)
- Initial release
- Contributors: Daniel Koch, James Jackson