No version for distro humble showing lunar. Known supported distros are highlighted in the buttons above.
Package symbol

async_comm package from async_comm repo

async_comm

ROS Distro
lunar

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

A C++ library for asynchronous serial communication

Additional Links

Maintainers

  • Daniel Koch

Authors

No additional authors.

Async Comm Library

CI Status ROS Buildfarm Status Documentation Status

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:

  1. If you’ll be using the library in a ROS package, install from the ROS repositories
  2. Build and install the library on your system, then use CMake’s find_package() functionality
  3. 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

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

This package does not provide any links to tutorials in it's rosindex metadata. You can check on the ROS Wiki Tutorials page for the package.

Package Dependencies

No dependencies on ROS packages.

System Dependencies

Dependant Packages

No known dependants.

Launch files

No launch files found

Messages

No message files found.

Services

No service files found

Plugins

No plugins found.

Recent questions tagged async_comm at Robotics Stack Exchange

No version for distro jazzy showing lunar. Known supported distros are highlighted in the buttons above.
Package symbol

async_comm package from async_comm repo

async_comm

ROS Distro
lunar

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

A C++ library for asynchronous serial communication

Additional Links

Maintainers

  • Daniel Koch

Authors

No additional authors.

Async Comm Library

CI Status ROS Buildfarm Status Documentation Status

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:

  1. If you’ll be using the library in a ROS package, install from the ROS repositories
  2. Build and install the library on your system, then use CMake’s find_package() functionality
  3. 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

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

This package does not provide any links to tutorials in it's rosindex metadata. You can check on the ROS Wiki Tutorials page for the package.

Package Dependencies

No dependencies on ROS packages.

System Dependencies

Dependant Packages

No known dependants.

Launch files

No launch files found

Messages

No message files found.

Services

No service files found

Plugins

No plugins found.

Recent questions tagged async_comm at Robotics Stack Exchange

No version for distro kilted showing lunar. Known supported distros are highlighted in the buttons above.
Package symbol

async_comm package from async_comm repo

async_comm

ROS Distro
lunar

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

A C++ library for asynchronous serial communication

Additional Links

Maintainers

  • Daniel Koch

Authors

No additional authors.

Async Comm Library

CI Status ROS Buildfarm Status Documentation Status

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:

  1. If you’ll be using the library in a ROS package, install from the ROS repositories
  2. Build and install the library on your system, then use CMake’s find_package() functionality
  3. 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

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

This package does not provide any links to tutorials in it's rosindex metadata. You can check on the ROS Wiki Tutorials page for the package.

Package Dependencies

No dependencies on ROS packages.

System Dependencies

Dependant Packages

No known dependants.

Launch files

No launch files found

Messages

No message files found.

Services

No service files found

Plugins

No plugins found.

Recent questions tagged async_comm at Robotics Stack Exchange

No version for distro rolling showing lunar. Known supported distros are highlighted in the buttons above.
Package symbol

async_comm package from async_comm repo

async_comm

ROS Distro
lunar

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

A C++ library for asynchronous serial communication

Additional Links

Maintainers

  • Daniel Koch

Authors

No additional authors.

Async Comm Library

CI Status ROS Buildfarm Status Documentation Status

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:

  1. If you’ll be using the library in a ROS package, install from the ROS repositories
  2. Build and install the library on your system, then use CMake’s find_package() functionality
  3. 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

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

This package does not provide any links to tutorials in it's rosindex metadata. You can check on the ROS Wiki Tutorials page for the package.

Package Dependencies

No dependencies on ROS packages.

System Dependencies

Dependant Packages

No known dependants.

Launch files

No launch files found

Messages

No message files found.

Services

No service files found

Plugins

No plugins found.

Recent questions tagged async_comm at Robotics Stack Exchange

No version for distro ardent showing lunar. Known supported distros are highlighted in the buttons above.
Package symbol

async_comm package from async_comm repo

async_comm

ROS Distro
lunar

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

A C++ library for asynchronous serial communication

Additional Links

Maintainers

  • Daniel Koch

Authors

No additional authors.

Async Comm Library

CI Status ROS Buildfarm Status Documentation Status

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:

  1. If you’ll be using the library in a ROS package, install from the ROS repositories
  2. Build and install the library on your system, then use CMake’s find_package() functionality
  3. 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

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

This package does not provide any links to tutorials in it's rosindex metadata. You can check on the ROS Wiki Tutorials page for the package.

Package Dependencies

No dependencies on ROS packages.

System Dependencies

Dependant Packages

No known dependants.

Launch files

No launch files found

Messages

No message files found.

Services

No service files found

Plugins

No plugins found.

Recent questions tagged async_comm at Robotics Stack Exchange

No version for distro bouncy showing lunar. Known supported distros are highlighted in the buttons above.
Package symbol

async_comm package from async_comm repo

async_comm

ROS Distro
lunar

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

A C++ library for asynchronous serial communication

Additional Links

Maintainers

  • Daniel Koch

Authors

No additional authors.

Async Comm Library

CI Status ROS Buildfarm Status Documentation Status

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:

  1. If you’ll be using the library in a ROS package, install from the ROS repositories
  2. Build and install the library on your system, then use CMake’s find_package() functionality
  3. 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

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

This package does not provide any links to tutorials in it's rosindex metadata. You can check on the ROS Wiki Tutorials page for the package.

Package Dependencies

No dependencies on ROS packages.

System Dependencies

Dependant Packages

No known dependants.

Launch files

No launch files found

Messages

No message files found.

Services

No service files found

Plugins

No plugins found.

Recent questions tagged async_comm at Robotics Stack Exchange

No version for distro crystal showing lunar. Known supported distros are highlighted in the buttons above.
Package symbol

async_comm package from async_comm repo

async_comm

ROS Distro
lunar

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

A C++ library for asynchronous serial communication

Additional Links

Maintainers

  • Daniel Koch

Authors

No additional authors.

Async Comm Library

CI Status ROS Buildfarm Status Documentation Status

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:

  1. If you’ll be using the library in a ROS package, install from the ROS repositories
  2. Build and install the library on your system, then use CMake’s find_package() functionality
  3. 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

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

This package does not provide any links to tutorials in it's rosindex metadata. You can check on the ROS Wiki Tutorials page for the package.

Package Dependencies

No dependencies on ROS packages.

System Dependencies

Dependant Packages

No known dependants.

Launch files

No launch files found

Messages

No message files found.

Services

No service files found

Plugins

No plugins found.

Recent questions tagged async_comm at Robotics Stack Exchange

No version for distro eloquent showing lunar. Known supported distros are highlighted in the buttons above.
Package symbol

async_comm package from async_comm repo

async_comm

ROS Distro
lunar

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

A C++ library for asynchronous serial communication

Additional Links

Maintainers

  • Daniel Koch

Authors

No additional authors.

Async Comm Library

CI Status ROS Buildfarm Status Documentation Status

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:

  1. If you’ll be using the library in a ROS package, install from the ROS repositories
  2. Build and install the library on your system, then use CMake’s find_package() functionality
  3. 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

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

This package does not provide any links to tutorials in it's rosindex metadata. You can check on the ROS Wiki Tutorials page for the package.

Package Dependencies

No dependencies on ROS packages.

System Dependencies

Dependant Packages

No known dependants.

Launch files

No launch files found

Messages

No message files found.

Services

No service files found

Plugins

No plugins found.

Recent questions tagged async_comm at Robotics Stack Exchange

No version for distro dashing showing lunar. Known supported distros are highlighted in the buttons above.
Package symbol

async_comm package from async_comm repo

async_comm

ROS Distro
lunar

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

A C++ library for asynchronous serial communication

Additional Links

Maintainers

  • Daniel Koch

Authors

No additional authors.

Async Comm Library

CI Status ROS Buildfarm Status Documentation Status

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:

  1. If you’ll be using the library in a ROS package, install from the ROS repositories
  2. Build and install the library on your system, then use CMake’s find_package() functionality
  3. 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

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

This package does not provide any links to tutorials in it's rosindex metadata. You can check on the ROS Wiki Tutorials page for the package.

Package Dependencies

No dependencies on ROS packages.

System Dependencies

Dependant Packages

No known dependants.

Launch files

No launch files found

Messages

No message files found.

Services

No service files found

Plugins

No plugins found.

Recent questions tagged async_comm at Robotics Stack Exchange

No version for distro galactic showing lunar. Known supported distros are highlighted in the buttons above.
Package symbol

async_comm package from async_comm repo

async_comm

ROS Distro
lunar

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

A C++ library for asynchronous serial communication

Additional Links

Maintainers

  • Daniel Koch

Authors

No additional authors.

Async Comm Library

CI Status ROS Buildfarm Status Documentation Status

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:

  1. If you’ll be using the library in a ROS package, install from the ROS repositories
  2. Build and install the library on your system, then use CMake’s find_package() functionality
  3. 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

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

This package does not provide any links to tutorials in it's rosindex metadata. You can check on the ROS Wiki Tutorials page for the package.

Package Dependencies

No dependencies on ROS packages.

System Dependencies

Dependant Packages

No known dependants.

Launch files

No launch files found

Messages

No message files found.

Services

No service files found

Plugins

No plugins found.

Recent questions tagged async_comm at Robotics Stack Exchange

No version for distro foxy showing lunar. Known supported distros are highlighted in the buttons above.
Package symbol

async_comm package from async_comm repo

async_comm

ROS Distro
lunar

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

A C++ library for asynchronous serial communication

Additional Links

Maintainers

  • Daniel Koch

Authors

No additional authors.

Async Comm Library

CI Status ROS Buildfarm Status Documentation Status

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:

  1. If you’ll be using the library in a ROS package, install from the ROS repositories
  2. Build and install the library on your system, then use CMake’s find_package() functionality
  3. 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

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

This package does not provide any links to tutorials in it's rosindex metadata. You can check on the ROS Wiki Tutorials page for the package.

Package Dependencies

No dependencies on ROS packages.

System Dependencies

Dependant Packages

No known dependants.

Launch files

No launch files found

Messages

No message files found.

Services

No service files found

Plugins

No plugins found.

Recent questions tagged async_comm at Robotics Stack Exchange

No version for distro iron showing lunar. Known supported distros are highlighted in the buttons above.
Package symbol

async_comm package from async_comm repo

async_comm

ROS Distro
lunar

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

A C++ library for asynchronous serial communication

Additional Links

Maintainers

  • Daniel Koch

Authors

No additional authors.

Async Comm Library

CI Status ROS Buildfarm Status Documentation Status

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:

  1. If you’ll be using the library in a ROS package, install from the ROS repositories
  2. Build and install the library on your system, then use CMake’s find_package() functionality
  3. 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

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

This package does not provide any links to tutorials in it's rosindex metadata. You can check on the ROS Wiki Tutorials page for the package.

Package Dependencies

No dependencies on ROS packages.

System Dependencies

Dependant Packages

No known dependants.

Launch files

No launch files found

Messages

No message files found.

Services

No service files found

Plugins

No plugins found.

Recent questions tagged async_comm at Robotics Stack Exchange

Package symbol

async_comm package from async_comm repo

async_comm

ROS Distro
lunar

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

A C++ library for asynchronous serial communication

Additional Links

Maintainers

  • Daniel Koch

Authors

No additional authors.

Async Comm Library

CI Status ROS Buildfarm Status Documentation Status

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:

  1. If you’ll be using the library in a ROS package, install from the ROS repositories
  2. Build and install the library on your system, then use CMake’s find_package() functionality
  3. 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

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

This package does not provide any links to tutorials in it's rosindex metadata. You can check on the ROS Wiki Tutorials page for the package.

Package Dependencies

No dependencies on ROS packages.

System Dependencies

Dependant Packages

No known dependants.

Launch files

No launch files found

Messages

No message files found.

Services

No service files found

Plugins

No plugins found.

Recent questions tagged async_comm at Robotics Stack Exchange

No version for distro jade showing lunar. Known supported distros are highlighted in the buttons above.
Package symbol

async_comm package from async_comm repo

async_comm

ROS Distro
lunar

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

A C++ library for asynchronous serial communication

Additional Links

Maintainers

  • Daniel Koch

Authors

No additional authors.

Async Comm Library

CI Status ROS Buildfarm Status Documentation Status

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:

  1. If you’ll be using the library in a ROS package, install from the ROS repositories
  2. Build and install the library on your system, then use CMake’s find_package() functionality
  3. 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

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

This package does not provide any links to tutorials in it's rosindex metadata. You can check on the ROS Wiki Tutorials page for the package.

Package Dependencies

No dependencies on ROS packages.

System Dependencies

Dependant Packages

No known dependants.

Launch files

No launch files found

Messages

No message files found.

Services

No service files found

Plugins

No plugins found.

Recent questions tagged async_comm at Robotics Stack Exchange

No version for distro indigo showing lunar. Known supported distros are highlighted in the buttons above.
Package symbol

async_comm package from async_comm repo

async_comm

ROS Distro
lunar

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

A C++ library for asynchronous serial communication

Additional Links

Maintainers

  • Daniel Koch

Authors

No additional authors.

Async Comm Library

CI Status ROS Buildfarm Status Documentation Status

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:

  1. If you’ll be using the library in a ROS package, install from the ROS repositories
  2. Build and install the library on your system, then use CMake’s find_package() functionality
  3. 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

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

This package does not provide any links to tutorials in it's rosindex metadata. You can check on the ROS Wiki Tutorials page for the package.

Package Dependencies

No dependencies on ROS packages.

System Dependencies

Dependant Packages

No known dependants.

Launch files

No launch files found

Messages

No message files found.

Services

No service files found

Plugins

No plugins found.

Recent questions tagged async_comm at Robotics Stack Exchange

No version for distro hydro showing lunar. Known supported distros are highlighted in the buttons above.
Package symbol

async_comm package from async_comm repo

async_comm

ROS Distro
lunar

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

A C++ library for asynchronous serial communication

Additional Links

Maintainers

  • Daniel Koch

Authors

No additional authors.

Async Comm Library

CI Status ROS Buildfarm Status Documentation Status

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:

  1. If you’ll be using the library in a ROS package, install from the ROS repositories
  2. Build and install the library on your system, then use CMake’s find_package() functionality
  3. 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

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

This package does not provide any links to tutorials in it's rosindex metadata. You can check on the ROS Wiki Tutorials page for the package.

Package Dependencies

No dependencies on ROS packages.

System Dependencies

Dependant Packages

No known dependants.

Launch files

No launch files found

Messages

No message files found.

Services

No service files found

Plugins

No plugins found.

Recent questions tagged async_comm at Robotics Stack Exchange

Package symbol

async_comm package from async_comm repo

async_comm

ROS Distro
kinetic

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

A C++ library for asynchronous serial communication

Additional Links

Maintainers

  • Daniel Koch

Authors

No additional authors.

Async Comm Library

CI Status ROS Buildfarm Status Documentation Status

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:

  1. If you’ll be using the library in a ROS package, install from the ROS repositories
  2. Build and install the library on your system, then use CMake’s find_package() functionality
  3. 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

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

This package does not provide any links to tutorials in it's rosindex metadata. You can check on the ROS Wiki Tutorials page for the package.

Package Dependencies

No dependencies on ROS packages.

System Dependencies

Dependant Packages

No known dependants.

Launch files

No launch files found

Messages

No message files found.

Services

No service files found

Plugins

No plugins found.

Recent questions tagged async_comm at Robotics Stack Exchange

Package symbol

async_comm package from async_comm repo

async_comm

ROS Distro
melodic

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

A C++ library for asynchronous serial communication

Additional Links

Maintainers

  • Daniel Koch

Authors

No additional authors.

Async Comm Library

CI Status ROS Buildfarm Status Documentation Status

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:

  1. If you’ll be using the library in a ROS package, install from the ROS repositories
  2. Build and install the library on your system, then use CMake’s find_package() functionality
  3. 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

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

This package does not provide any links to tutorials in it's rosindex metadata. You can check on the ROS Wiki Tutorials page for the package.

Package Dependencies

No dependencies on ROS packages.

System Dependencies

Dependant Packages

No known dependants.

Launch files

No launch files found

Messages

No message files found.

Services

No service files found

Plugins

No plugins found.

Recent questions tagged async_comm at Robotics Stack Exchange

Package symbol

async_comm package from async_comm repo

async_comm

ROS Distro
noetic

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

A C++ library for asynchronous serial communication

Additional Links

Maintainers

  • Daniel Koch

Authors

No additional authors.

Async Comm Library

CI Status ROS Buildfarm Status Documentation Status

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:

  1. If you’ll be using the library in a ROS package, install from the ROS repositories
  2. Build and install the library on your system, then use CMake’s find_package() functionality
  3. 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

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

This package does not provide any links to tutorials in it's rosindex metadata. You can check on the ROS Wiki Tutorials page for the package.

Package Dependencies

No dependencies on ROS packages.

System Dependencies

Dependant Packages

No known dependants.

Launch files

No launch files found

Messages

No message files found.

Services

No service files found

Plugins

No plugins found.

Recent questions tagged async_comm at Robotics Stack Exchange