Repository Summary
| Checkout URI | https://github.com/brow1633/network_bridge.git |
| VCS Type | git |
| VCS Version | main |
| Last Updated | 2026-10-12 |
| Dev Status | MAINTAINED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| network_bridge | 3.1.0 |
README
Network Bridge
Network Bridge is a lightweight ROS2 node designed for robust communication between robotic systems over arbitrary network protocols. Supporting UDP, TCP, and ZMQ protocols out of the box, this packages seamlessly bridges ROS2 topics across networks, facilitating effective remote communications between a base station and robotic systems, or between multiple robotic systems.
Installation
Installation via apt
Install with:
sudo apt install ros-<distro>-network-bridge
Building from Source
Simply clone the repository into your ROS2 workspace and build with colcon build.
Usage
Demo
TCP
ros2 launch network_bridge tcp.launch.py
ros2 topic pub /tcp1/MyDefaultTopic std_msgs/msg/String "data: 'Hello World'"
ros2 topic echo /tcp2/MyDefaultTopic
UDP
ros2 launch network_bridge udp.launch.py
ros2 topic pub /udp1/MyDefaultTopic std_msgs/msg/String "data: 'Hello World'"
ros2 topic echo /udp2/MyDefaultTopic
ZMQ
ros2 launch network_bridge zmq.launch.py
ros2 topic pub /zmq1/test_topic std_msgs/msg/String "data: 'Hello World'"
ros2 topic echo /zmq2/test_topic
Talker/listener demos
The installed files in demo/ bridge sample chatter and static transforms.
The server starts both TCP and UDP bridges. Run the server in one terminal:
ros2 launch network_bridge demo_server.launch.py
In another terminal, run either client:
ros2 launch network_bridge tcp_demo_client.launch.py
# Or:
ros2 launch network_bridge udp_demo_client.launch.py
The talkers publish automatically. The listeners print the messages received
through the bridge. The demo_nodes_cpp runtime dependency is installed with
this package, or resolved by rosdep when building from source.
For separate hosts, use the server’s address on the TCP client:
ros2 launch network_bridge tcp_demo_client.launch.py server_host:=SERVER_IP
For UDP, configure both hosts. On the server:
ros2 launch network_bridge demo_server.launch.py udp_server_address:=0.0.0.0 udp_receiver_host:=CLIENT_IP
On the client:
ros2 launch network_bridge udp_demo_client.launch.py receiver_address:=0.0.0.0 server_host:=SERVER_IP
Replace SERVER_IP and CLIENT_IP with the hosts’ reachable addresses. The
port arguments are available through each launch file’s --show-args option.
Configuration
Simply setup the network interface parameters and list your desired topics to get started. If you are using UDP over cellular data, it is recommended to setup a VPN to facilitate connection. Also, please note that no encryption occurs within this package. Currently, if you would like encryption, you must use a VPN.
See config/Udp1.yaml for a description of all parameters, as well as the TCP example configuration files.
Minimal Example
The following configuration examples demonstrate a robot sending a message on /gps/fix over UDP to a basestation that will then re-publish the message. This works seamlessly on all message types, so long as they are built and sourced on both ends of the transmission.
Robot
``` /udp_sender: ros__parameters: UdpInterface: local_address: “192.168.1.2” receive_port: 5001
File truncated at 100 lines see the full file
CONTRIBUTING
Repository Summary
| Checkout URI | https://github.com/brow1633/network_bridge.git |
| VCS Type | git |
| VCS Version | main |
| Last Updated | 2026-10-12 |
| Dev Status | MAINTAINED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| network_bridge | 3.1.0 |
README
Network Bridge
Network Bridge is a lightweight ROS2 node designed for robust communication between robotic systems over arbitrary network protocols. Supporting UDP, TCP, and ZMQ protocols out of the box, this packages seamlessly bridges ROS2 topics across networks, facilitating effective remote communications between a base station and robotic systems, or between multiple robotic systems.
Installation
Installation via apt
Install with:
sudo apt install ros-<distro>-network-bridge
Building from Source
Simply clone the repository into your ROS2 workspace and build with colcon build.
Usage
Demo
TCP
ros2 launch network_bridge tcp.launch.py
ros2 topic pub /tcp1/MyDefaultTopic std_msgs/msg/String "data: 'Hello World'"
ros2 topic echo /tcp2/MyDefaultTopic
UDP
ros2 launch network_bridge udp.launch.py
ros2 topic pub /udp1/MyDefaultTopic std_msgs/msg/String "data: 'Hello World'"
ros2 topic echo /udp2/MyDefaultTopic
ZMQ
ros2 launch network_bridge zmq.launch.py
ros2 topic pub /zmq1/test_topic std_msgs/msg/String "data: 'Hello World'"
ros2 topic echo /zmq2/test_topic
Talker/listener demos
The installed files in demo/ bridge sample chatter and static transforms.
The server starts both TCP and UDP bridges. Run the server in one terminal:
ros2 launch network_bridge demo_server.launch.py
In another terminal, run either client:
ros2 launch network_bridge tcp_demo_client.launch.py
# Or:
ros2 launch network_bridge udp_demo_client.launch.py
The talkers publish automatically. The listeners print the messages received
through the bridge. The demo_nodes_cpp runtime dependency is installed with
this package, or resolved by rosdep when building from source.
For separate hosts, use the server’s address on the TCP client:
ros2 launch network_bridge tcp_demo_client.launch.py server_host:=SERVER_IP
For UDP, configure both hosts. On the server:
ros2 launch network_bridge demo_server.launch.py udp_server_address:=0.0.0.0 udp_receiver_host:=CLIENT_IP
On the client:
ros2 launch network_bridge udp_demo_client.launch.py receiver_address:=0.0.0.0 server_host:=SERVER_IP
Replace SERVER_IP and CLIENT_IP with the hosts’ reachable addresses. The
port arguments are available through each launch file’s --show-args option.
Configuration
Simply setup the network interface parameters and list your desired topics to get started. If you are using UDP over cellular data, it is recommended to setup a VPN to facilitate connection. Also, please note that no encryption occurs within this package. Currently, if you would like encryption, you must use a VPN.
See config/Udp1.yaml for a description of all parameters, as well as the TCP example configuration files.
Minimal Example
The following configuration examples demonstrate a robot sending a message on /gps/fix over UDP to a basestation that will then re-publish the message. This works seamlessly on all message types, so long as they are built and sourced on both ends of the transmission.
Robot
``` /udp_sender: ros__parameters: UdpInterface: local_address: “192.168.1.2” receive_port: 5001
File truncated at 100 lines see the full file
CONTRIBUTING
Repository Summary
| Checkout URI | https://github.com/brow1633/network_bridge.git |
| VCS Type | git |
| VCS Version | main |
| Last Updated | 2026-10-12 |
| Dev Status | MAINTAINED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| network_bridge | 3.1.0 |
README
Network Bridge
Network Bridge is a lightweight ROS2 node designed for robust communication between robotic systems over arbitrary network protocols. Supporting UDP, TCP, and ZMQ protocols out of the box, this packages seamlessly bridges ROS2 topics across networks, facilitating effective remote communications between a base station and robotic systems, or between multiple robotic systems.
Installation
Installation via apt
Install with:
sudo apt install ros-<distro>-network-bridge
Building from Source
Simply clone the repository into your ROS2 workspace and build with colcon build.
Usage
Demo
TCP
ros2 launch network_bridge tcp.launch.py
ros2 topic pub /tcp1/MyDefaultTopic std_msgs/msg/String "data: 'Hello World'"
ros2 topic echo /tcp2/MyDefaultTopic
UDP
ros2 launch network_bridge udp.launch.py
ros2 topic pub /udp1/MyDefaultTopic std_msgs/msg/String "data: 'Hello World'"
ros2 topic echo /udp2/MyDefaultTopic
ZMQ
ros2 launch network_bridge zmq.launch.py
ros2 topic pub /zmq1/test_topic std_msgs/msg/String "data: 'Hello World'"
ros2 topic echo /zmq2/test_topic
Talker/listener demos
The installed files in demo/ bridge sample chatter and static transforms.
The server starts both TCP and UDP bridges. Run the server in one terminal:
ros2 launch network_bridge demo_server.launch.py
In another terminal, run either client:
ros2 launch network_bridge tcp_demo_client.launch.py
# Or:
ros2 launch network_bridge udp_demo_client.launch.py
The talkers publish automatically. The listeners print the messages received
through the bridge. The demo_nodes_cpp runtime dependency is installed with
this package, or resolved by rosdep when building from source.
For separate hosts, use the server’s address on the TCP client:
ros2 launch network_bridge tcp_demo_client.launch.py server_host:=SERVER_IP
For UDP, configure both hosts. On the server:
ros2 launch network_bridge demo_server.launch.py udp_server_address:=0.0.0.0 udp_receiver_host:=CLIENT_IP
On the client:
ros2 launch network_bridge udp_demo_client.launch.py receiver_address:=0.0.0.0 server_host:=SERVER_IP
Replace SERVER_IP and CLIENT_IP with the hosts’ reachable addresses. The
port arguments are available through each launch file’s --show-args option.
Configuration
Simply setup the network interface parameters and list your desired topics to get started. If you are using UDP over cellular data, it is recommended to setup a VPN to facilitate connection. Also, please note that no encryption occurs within this package. Currently, if you would like encryption, you must use a VPN.
See config/Udp1.yaml for a description of all parameters, as well as the TCP example configuration files.
Minimal Example
The following configuration examples demonstrate a robot sending a message on /gps/fix over UDP to a basestation that will then re-publish the message. This works seamlessly on all message types, so long as they are built and sourced on both ends of the transmission.
Robot
``` /udp_sender: ros__parameters: UdpInterface: local_address: “192.168.1.2” receive_port: 5001
File truncated at 100 lines see the full file
CONTRIBUTING
Repository Summary
| Checkout URI | https://github.com/brow1633/network_bridge.git |
| VCS Type | git |
| VCS Version | main |
| Last Updated | 2026-10-12 |
| Dev Status | MAINTAINED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| network_bridge | 3.1.0 |
README
Network Bridge
Network Bridge is a lightweight ROS2 node designed for robust communication between robotic systems over arbitrary network protocols. Supporting UDP, TCP, and ZMQ protocols out of the box, this packages seamlessly bridges ROS2 topics across networks, facilitating effective remote communications between a base station and robotic systems, or between multiple robotic systems.
Installation
Installation via apt
Install with:
sudo apt install ros-<distro>-network-bridge
Building from Source
Simply clone the repository into your ROS2 workspace and build with colcon build.
Usage
Demo
TCP
ros2 launch network_bridge tcp.launch.py
ros2 topic pub /tcp1/MyDefaultTopic std_msgs/msg/String "data: 'Hello World'"
ros2 topic echo /tcp2/MyDefaultTopic
UDP
ros2 launch network_bridge udp.launch.py
ros2 topic pub /udp1/MyDefaultTopic std_msgs/msg/String "data: 'Hello World'"
ros2 topic echo /udp2/MyDefaultTopic
ZMQ
ros2 launch network_bridge zmq.launch.py
ros2 topic pub /zmq1/test_topic std_msgs/msg/String "data: 'Hello World'"
ros2 topic echo /zmq2/test_topic
Talker/listener demos
The installed files in demo/ bridge sample chatter and static transforms.
The server starts both TCP and UDP bridges. Run the server in one terminal:
ros2 launch network_bridge demo_server.launch.py
In another terminal, run either client:
ros2 launch network_bridge tcp_demo_client.launch.py
# Or:
ros2 launch network_bridge udp_demo_client.launch.py
The talkers publish automatically. The listeners print the messages received
through the bridge. The demo_nodes_cpp runtime dependency is installed with
this package, or resolved by rosdep when building from source.
For separate hosts, use the server’s address on the TCP client:
ros2 launch network_bridge tcp_demo_client.launch.py server_host:=SERVER_IP
For UDP, configure both hosts. On the server:
ros2 launch network_bridge demo_server.launch.py udp_server_address:=0.0.0.0 udp_receiver_host:=CLIENT_IP
On the client:
ros2 launch network_bridge udp_demo_client.launch.py receiver_address:=0.0.0.0 server_host:=SERVER_IP
Replace SERVER_IP and CLIENT_IP with the hosts’ reachable addresses. The
port arguments are available through each launch file’s --show-args option.
Configuration
Simply setup the network interface parameters and list your desired topics to get started. If you are using UDP over cellular data, it is recommended to setup a VPN to facilitate connection. Also, please note that no encryption occurs within this package. Currently, if you would like encryption, you must use a VPN.
See config/Udp1.yaml for a description of all parameters, as well as the TCP example configuration files.
Minimal Example
The following configuration examples demonstrate a robot sending a message on /gps/fix over UDP to a basestation that will then re-publish the message. This works seamlessly on all message types, so long as they are built and sourced on both ends of the transmission.
Robot
``` /udp_sender: ros__parameters: UdpInterface: local_address: “192.168.1.2” receive_port: 5001
File truncated at 100 lines see the full file
CONTRIBUTING
Repository Summary
| Checkout URI | https://github.com/brow1633/network_bridge.git |
| VCS Type | git |
| VCS Version | main |
| Last Updated | 2026-10-12 |
| Dev Status | MAINTAINED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| network_bridge | 3.1.0 |
README
Network Bridge
Network Bridge is a lightweight ROS2 node designed for robust communication between robotic systems over arbitrary network protocols. Supporting UDP, TCP, and ZMQ protocols out of the box, this packages seamlessly bridges ROS2 topics across networks, facilitating effective remote communications between a base station and robotic systems, or between multiple robotic systems.
Installation
Installation via apt
Install with:
sudo apt install ros-<distro>-network-bridge
Building from Source
Simply clone the repository into your ROS2 workspace and build with colcon build.
Usage
Demo
TCP
ros2 launch network_bridge tcp.launch.py
ros2 topic pub /tcp1/MyDefaultTopic std_msgs/msg/String "data: 'Hello World'"
ros2 topic echo /tcp2/MyDefaultTopic
UDP
ros2 launch network_bridge udp.launch.py
ros2 topic pub /udp1/MyDefaultTopic std_msgs/msg/String "data: 'Hello World'"
ros2 topic echo /udp2/MyDefaultTopic
ZMQ
ros2 launch network_bridge zmq.launch.py
ros2 topic pub /zmq1/test_topic std_msgs/msg/String "data: 'Hello World'"
ros2 topic echo /zmq2/test_topic
Talker/listener demos
The installed files in demo/ bridge sample chatter and static transforms.
The server starts both TCP and UDP bridges. Run the server in one terminal:
ros2 launch network_bridge demo_server.launch.py
In another terminal, run either client:
ros2 launch network_bridge tcp_demo_client.launch.py
# Or:
ros2 launch network_bridge udp_demo_client.launch.py
The talkers publish automatically. The listeners print the messages received
through the bridge. The demo_nodes_cpp runtime dependency is installed with
this package, or resolved by rosdep when building from source.
For separate hosts, use the server’s address on the TCP client:
ros2 launch network_bridge tcp_demo_client.launch.py server_host:=SERVER_IP
For UDP, configure both hosts. On the server:
ros2 launch network_bridge demo_server.launch.py udp_server_address:=0.0.0.0 udp_receiver_host:=CLIENT_IP
On the client:
ros2 launch network_bridge udp_demo_client.launch.py receiver_address:=0.0.0.0 server_host:=SERVER_IP
Replace SERVER_IP and CLIENT_IP with the hosts’ reachable addresses. The
port arguments are available through each launch file’s --show-args option.
Configuration
Simply setup the network interface parameters and list your desired topics to get started. If you are using UDP over cellular data, it is recommended to setup a VPN to facilitate connection. Also, please note that no encryption occurs within this package. Currently, if you would like encryption, you must use a VPN.
See config/Udp1.yaml for a description of all parameters, as well as the TCP example configuration files.
Minimal Example
The following configuration examples demonstrate a robot sending a message on /gps/fix over UDP to a basestation that will then re-publish the message. This works seamlessly on all message types, so long as they are built and sourced on both ends of the transmission.
Robot
``` /udp_sender: ros__parameters: UdpInterface: local_address: “192.168.1.2” receive_port: 5001
File truncated at 100 lines see the full file
CONTRIBUTING
Repository Summary
| Checkout URI | https://github.com/brow1633/network_bridge.git |
| VCS Type | git |
| VCS Version | main |
| Last Updated | 2026-10-12 |
| Dev Status | MAINTAINED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| network_bridge | 3.1.0 |
README
Network Bridge
Network Bridge is a lightweight ROS2 node designed for robust communication between robotic systems over arbitrary network protocols. Supporting UDP, TCP, and ZMQ protocols out of the box, this packages seamlessly bridges ROS2 topics across networks, facilitating effective remote communications between a base station and robotic systems, or between multiple robotic systems.
Installation
Installation via apt
Install with:
sudo apt install ros-<distro>-network-bridge
Building from Source
Simply clone the repository into your ROS2 workspace and build with colcon build.
Usage
Demo
TCP
ros2 launch network_bridge tcp.launch.py
ros2 topic pub /tcp1/MyDefaultTopic std_msgs/msg/String "data: 'Hello World'"
ros2 topic echo /tcp2/MyDefaultTopic
UDP
ros2 launch network_bridge udp.launch.py
ros2 topic pub /udp1/MyDefaultTopic std_msgs/msg/String "data: 'Hello World'"
ros2 topic echo /udp2/MyDefaultTopic
ZMQ
ros2 launch network_bridge zmq.launch.py
ros2 topic pub /zmq1/test_topic std_msgs/msg/String "data: 'Hello World'"
ros2 topic echo /zmq2/test_topic
Talker/listener demos
The installed files in demo/ bridge sample chatter and static transforms.
The server starts both TCP and UDP bridges. Run the server in one terminal:
ros2 launch network_bridge demo_server.launch.py
In another terminal, run either client:
ros2 launch network_bridge tcp_demo_client.launch.py
# Or:
ros2 launch network_bridge udp_demo_client.launch.py
The talkers publish automatically. The listeners print the messages received
through the bridge. The demo_nodes_cpp runtime dependency is installed with
this package, or resolved by rosdep when building from source.
For separate hosts, use the server’s address on the TCP client:
ros2 launch network_bridge tcp_demo_client.launch.py server_host:=SERVER_IP
For UDP, configure both hosts. On the server:
ros2 launch network_bridge demo_server.launch.py udp_server_address:=0.0.0.0 udp_receiver_host:=CLIENT_IP
On the client:
ros2 launch network_bridge udp_demo_client.launch.py receiver_address:=0.0.0.0 server_host:=SERVER_IP
Replace SERVER_IP and CLIENT_IP with the hosts’ reachable addresses. The
port arguments are available through each launch file’s --show-args option.
Configuration
Simply setup the network interface parameters and list your desired topics to get started. If you are using UDP over cellular data, it is recommended to setup a VPN to facilitate connection. Also, please note that no encryption occurs within this package. Currently, if you would like encryption, you must use a VPN.
See config/Udp1.yaml for a description of all parameters, as well as the TCP example configuration files.
Minimal Example
The following configuration examples demonstrate a robot sending a message on /gps/fix over UDP to a basestation that will then re-publish the message. This works seamlessly on all message types, so long as they are built and sourced on both ends of the transmission.
Robot
``` /udp_sender: ros__parameters: UdpInterface: local_address: “192.168.1.2” receive_port: 5001
File truncated at 100 lines see the full file
CONTRIBUTING
Repository Summary
| Checkout URI | https://github.com/brow1633/network_bridge.git |
| VCS Type | git |
| VCS Version | main |
| Last Updated | 2026-10-12 |
| Dev Status | MAINTAINED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| network_bridge | 3.1.0 |
README
Network Bridge
Network Bridge is a lightweight ROS2 node designed for robust communication between robotic systems over arbitrary network protocols. Supporting UDP, TCP, and ZMQ protocols out of the box, this packages seamlessly bridges ROS2 topics across networks, facilitating effective remote communications between a base station and robotic systems, or between multiple robotic systems.
Installation
Installation via apt
Install with:
sudo apt install ros-<distro>-network-bridge
Building from Source
Simply clone the repository into your ROS2 workspace and build with colcon build.
Usage
Demo
TCP
ros2 launch network_bridge tcp.launch.py
ros2 topic pub /tcp1/MyDefaultTopic std_msgs/msg/String "data: 'Hello World'"
ros2 topic echo /tcp2/MyDefaultTopic
UDP
ros2 launch network_bridge udp.launch.py
ros2 topic pub /udp1/MyDefaultTopic std_msgs/msg/String "data: 'Hello World'"
ros2 topic echo /udp2/MyDefaultTopic
ZMQ
ros2 launch network_bridge zmq.launch.py
ros2 topic pub /zmq1/test_topic std_msgs/msg/String "data: 'Hello World'"
ros2 topic echo /zmq2/test_topic
Talker/listener demos
The installed files in demo/ bridge sample chatter and static transforms.
The server starts both TCP and UDP bridges. Run the server in one terminal:
ros2 launch network_bridge demo_server.launch.py
In another terminal, run either client:
ros2 launch network_bridge tcp_demo_client.launch.py
# Or:
ros2 launch network_bridge udp_demo_client.launch.py
The talkers publish automatically. The listeners print the messages received
through the bridge. The demo_nodes_cpp runtime dependency is installed with
this package, or resolved by rosdep when building from source.
For separate hosts, use the server’s address on the TCP client:
ros2 launch network_bridge tcp_demo_client.launch.py server_host:=SERVER_IP
For UDP, configure both hosts. On the server:
ros2 launch network_bridge demo_server.launch.py udp_server_address:=0.0.0.0 udp_receiver_host:=CLIENT_IP
On the client:
ros2 launch network_bridge udp_demo_client.launch.py receiver_address:=0.0.0.0 server_host:=SERVER_IP
Replace SERVER_IP and CLIENT_IP with the hosts’ reachable addresses. The
port arguments are available through each launch file’s --show-args option.
Configuration
Simply setup the network interface parameters and list your desired topics to get started. If you are using UDP over cellular data, it is recommended to setup a VPN to facilitate connection. Also, please note that no encryption occurs within this package. Currently, if you would like encryption, you must use a VPN.
See config/Udp1.yaml for a description of all parameters, as well as the TCP example configuration files.
Minimal Example
The following configuration examples demonstrate a robot sending a message on /gps/fix over UDP to a basestation that will then re-publish the message. This works seamlessly on all message types, so long as they are built and sourced on both ends of the transmission.
Robot
``` /udp_sender: ros__parameters: UdpInterface: local_address: “192.168.1.2” receive_port: 5001
File truncated at 100 lines see the full file
CONTRIBUTING
Repository Summary
| Checkout URI | https://github.com/brow1633/network_bridge.git |
| VCS Type | git |
| VCS Version | main |
| Last Updated | 2026-10-12 |
| Dev Status | MAINTAINED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| network_bridge | 3.1.0 |
README
Network Bridge
Network Bridge is a lightweight ROS2 node designed for robust communication between robotic systems over arbitrary network protocols. Supporting UDP, TCP, and ZMQ protocols out of the box, this packages seamlessly bridges ROS2 topics across networks, facilitating effective remote communications between a base station and robotic systems, or between multiple robotic systems.
Installation
Installation via apt
Install with:
sudo apt install ros-<distro>-network-bridge
Building from Source
Simply clone the repository into your ROS2 workspace and build with colcon build.
Usage
Demo
TCP
ros2 launch network_bridge tcp.launch.py
ros2 topic pub /tcp1/MyDefaultTopic std_msgs/msg/String "data: 'Hello World'"
ros2 topic echo /tcp2/MyDefaultTopic
UDP
ros2 launch network_bridge udp.launch.py
ros2 topic pub /udp1/MyDefaultTopic std_msgs/msg/String "data: 'Hello World'"
ros2 topic echo /udp2/MyDefaultTopic
ZMQ
ros2 launch network_bridge zmq.launch.py
ros2 topic pub /zmq1/test_topic std_msgs/msg/String "data: 'Hello World'"
ros2 topic echo /zmq2/test_topic
Talker/listener demos
The installed files in demo/ bridge sample chatter and static transforms.
The server starts both TCP and UDP bridges. Run the server in one terminal:
ros2 launch network_bridge demo_server.launch.py
In another terminal, run either client:
ros2 launch network_bridge tcp_demo_client.launch.py
# Or:
ros2 launch network_bridge udp_demo_client.launch.py
The talkers publish automatically. The listeners print the messages received
through the bridge. The demo_nodes_cpp runtime dependency is installed with
this package, or resolved by rosdep when building from source.
For separate hosts, use the server’s address on the TCP client:
ros2 launch network_bridge tcp_demo_client.launch.py server_host:=SERVER_IP
For UDP, configure both hosts. On the server:
ros2 launch network_bridge demo_server.launch.py udp_server_address:=0.0.0.0 udp_receiver_host:=CLIENT_IP
On the client:
ros2 launch network_bridge udp_demo_client.launch.py receiver_address:=0.0.0.0 server_host:=SERVER_IP
Replace SERVER_IP and CLIENT_IP with the hosts’ reachable addresses. The
port arguments are available through each launch file’s --show-args option.
Configuration
Simply setup the network interface parameters and list your desired topics to get started. If you are using UDP over cellular data, it is recommended to setup a VPN to facilitate connection. Also, please note that no encryption occurs within this package. Currently, if you would like encryption, you must use a VPN.
See config/Udp1.yaml for a description of all parameters, as well as the TCP example configuration files.
Minimal Example
The following configuration examples demonstrate a robot sending a message on /gps/fix over UDP to a basestation that will then re-publish the message. This works seamlessly on all message types, so long as they are built and sourced on both ends of the transmission.
Robot
``` /udp_sender: ros__parameters: UdpInterface: local_address: “192.168.1.2” receive_port: 5001
File truncated at 100 lines see the full file
CONTRIBUTING
Repository Summary
| Checkout URI | https://github.com/brow1633/network_bridge.git |
| VCS Type | git |
| VCS Version | main |
| Last Updated | 2026-10-12 |
| Dev Status | MAINTAINED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| network_bridge | 3.1.0 |
README
Network Bridge
Network Bridge is a lightweight ROS2 node designed for robust communication between robotic systems over arbitrary network protocols. Supporting UDP, TCP, and ZMQ protocols out of the box, this packages seamlessly bridges ROS2 topics across networks, facilitating effective remote communications between a base station and robotic systems, or between multiple robotic systems.
Installation
Installation via apt
Install with:
sudo apt install ros-<distro>-network-bridge
Building from Source
Simply clone the repository into your ROS2 workspace and build with colcon build.
Usage
Demo
TCP
ros2 launch network_bridge tcp.launch.py
ros2 topic pub /tcp1/MyDefaultTopic std_msgs/msg/String "data: 'Hello World'"
ros2 topic echo /tcp2/MyDefaultTopic
UDP
ros2 launch network_bridge udp.launch.py
ros2 topic pub /udp1/MyDefaultTopic std_msgs/msg/String "data: 'Hello World'"
ros2 topic echo /udp2/MyDefaultTopic
ZMQ
ros2 launch network_bridge zmq.launch.py
ros2 topic pub /zmq1/test_topic std_msgs/msg/String "data: 'Hello World'"
ros2 topic echo /zmq2/test_topic
Talker/listener demos
The installed files in demo/ bridge sample chatter and static transforms.
The server starts both TCP and UDP bridges. Run the server in one terminal:
ros2 launch network_bridge demo_server.launch.py
In another terminal, run either client:
ros2 launch network_bridge tcp_demo_client.launch.py
# Or:
ros2 launch network_bridge udp_demo_client.launch.py
The talkers publish automatically. The listeners print the messages received
through the bridge. The demo_nodes_cpp runtime dependency is installed with
this package, or resolved by rosdep when building from source.
For separate hosts, use the server’s address on the TCP client:
ros2 launch network_bridge tcp_demo_client.launch.py server_host:=SERVER_IP
For UDP, configure both hosts. On the server:
ros2 launch network_bridge demo_server.launch.py udp_server_address:=0.0.0.0 udp_receiver_host:=CLIENT_IP
On the client:
ros2 launch network_bridge udp_demo_client.launch.py receiver_address:=0.0.0.0 server_host:=SERVER_IP
Replace SERVER_IP and CLIENT_IP with the hosts’ reachable addresses. The
port arguments are available through each launch file’s --show-args option.
Configuration
Simply setup the network interface parameters and list your desired topics to get started. If you are using UDP over cellular data, it is recommended to setup a VPN to facilitate connection. Also, please note that no encryption occurs within this package. Currently, if you would like encryption, you must use a VPN.
See config/Udp1.yaml for a description of all parameters, as well as the TCP example configuration files.
Minimal Example
The following configuration examples demonstrate a robot sending a message on /gps/fix over UDP to a basestation that will then re-publish the message. This works seamlessly on all message types, so long as they are built and sourced on both ends of the transmission.
Robot
``` /udp_sender: ros__parameters: UdpInterface: local_address: “192.168.1.2” receive_port: 5001
File truncated at 100 lines see the full file
CONTRIBUTING
Repository Summary
| Checkout URI | https://github.com/brow1633/network_bridge.git |
| VCS Type | git |
| VCS Version | main |
| Last Updated | 2026-10-12 |
| Dev Status | MAINTAINED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| network_bridge | 3.1.0 |
README
Network Bridge
Network Bridge is a lightweight ROS2 node designed for robust communication between robotic systems over arbitrary network protocols. Supporting UDP, TCP, and ZMQ protocols out of the box, this packages seamlessly bridges ROS2 topics across networks, facilitating effective remote communications between a base station and robotic systems, or between multiple robotic systems.
Installation
Installation via apt
Install with:
sudo apt install ros-<distro>-network-bridge
Building from Source
Simply clone the repository into your ROS2 workspace and build with colcon build.
Usage
Demo
TCP
ros2 launch network_bridge tcp.launch.py
ros2 topic pub /tcp1/MyDefaultTopic std_msgs/msg/String "data: 'Hello World'"
ros2 topic echo /tcp2/MyDefaultTopic
UDP
ros2 launch network_bridge udp.launch.py
ros2 topic pub /udp1/MyDefaultTopic std_msgs/msg/String "data: 'Hello World'"
ros2 topic echo /udp2/MyDefaultTopic
ZMQ
ros2 launch network_bridge zmq.launch.py
ros2 topic pub /zmq1/test_topic std_msgs/msg/String "data: 'Hello World'"
ros2 topic echo /zmq2/test_topic
Talker/listener demos
The installed files in demo/ bridge sample chatter and static transforms.
The server starts both TCP and UDP bridges. Run the server in one terminal:
ros2 launch network_bridge demo_server.launch.py
In another terminal, run either client:
ros2 launch network_bridge tcp_demo_client.launch.py
# Or:
ros2 launch network_bridge udp_demo_client.launch.py
The talkers publish automatically. The listeners print the messages received
through the bridge. The demo_nodes_cpp runtime dependency is installed with
this package, or resolved by rosdep when building from source.
For separate hosts, use the server’s address on the TCP client:
ros2 launch network_bridge tcp_demo_client.launch.py server_host:=SERVER_IP
For UDP, configure both hosts. On the server:
ros2 launch network_bridge demo_server.launch.py udp_server_address:=0.0.0.0 udp_receiver_host:=CLIENT_IP
On the client:
ros2 launch network_bridge udp_demo_client.launch.py receiver_address:=0.0.0.0 server_host:=SERVER_IP
Replace SERVER_IP and CLIENT_IP with the hosts’ reachable addresses. The
port arguments are available through each launch file’s --show-args option.
Configuration
Simply setup the network interface parameters and list your desired topics to get started. If you are using UDP over cellular data, it is recommended to setup a VPN to facilitate connection. Also, please note that no encryption occurs within this package. Currently, if you would like encryption, you must use a VPN.
See config/Udp1.yaml for a description of all parameters, as well as the TCP example configuration files.
Minimal Example
The following configuration examples demonstrate a robot sending a message on /gps/fix over UDP to a basestation that will then re-publish the message. This works seamlessly on all message types, so long as they are built and sourced on both ends of the transmission.
Robot
``` /udp_sender: ros__parameters: UdpInterface: local_address: “192.168.1.2” receive_port: 5001
File truncated at 100 lines see the full file
CONTRIBUTING
Repository Summary
| Checkout URI | https://github.com/brow1633/network_bridge.git |
| VCS Type | git |
| VCS Version | main |
| Last Updated | 2026-10-12 |
| Dev Status | MAINTAINED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| network_bridge | 3.1.0 |
README
Network Bridge
Network Bridge is a lightweight ROS2 node designed for robust communication between robotic systems over arbitrary network protocols. Supporting UDP, TCP, and ZMQ protocols out of the box, this packages seamlessly bridges ROS2 topics across networks, facilitating effective remote communications between a base station and robotic systems, or between multiple robotic systems.
Installation
Installation via apt
Install with:
sudo apt install ros-<distro>-network-bridge
Building from Source
Simply clone the repository into your ROS2 workspace and build with colcon build.
Usage
Demo
TCP
ros2 launch network_bridge tcp.launch.py
ros2 topic pub /tcp1/MyDefaultTopic std_msgs/msg/String "data: 'Hello World'"
ros2 topic echo /tcp2/MyDefaultTopic
UDP
ros2 launch network_bridge udp.launch.py
ros2 topic pub /udp1/MyDefaultTopic std_msgs/msg/String "data: 'Hello World'"
ros2 topic echo /udp2/MyDefaultTopic
ZMQ
ros2 launch network_bridge zmq.launch.py
ros2 topic pub /zmq1/test_topic std_msgs/msg/String "data: 'Hello World'"
ros2 topic echo /zmq2/test_topic
Talker/listener demos
The installed files in demo/ bridge sample chatter and static transforms.
The server starts both TCP and UDP bridges. Run the server in one terminal:
ros2 launch network_bridge demo_server.launch.py
In another terminal, run either client:
ros2 launch network_bridge tcp_demo_client.launch.py
# Or:
ros2 launch network_bridge udp_demo_client.launch.py
The talkers publish automatically. The listeners print the messages received
through the bridge. The demo_nodes_cpp runtime dependency is installed with
this package, or resolved by rosdep when building from source.
For separate hosts, use the server’s address on the TCP client:
ros2 launch network_bridge tcp_demo_client.launch.py server_host:=SERVER_IP
For UDP, configure both hosts. On the server:
ros2 launch network_bridge demo_server.launch.py udp_server_address:=0.0.0.0 udp_receiver_host:=CLIENT_IP
On the client:
ros2 launch network_bridge udp_demo_client.launch.py receiver_address:=0.0.0.0 server_host:=SERVER_IP
Replace SERVER_IP and CLIENT_IP with the hosts’ reachable addresses. The
port arguments are available through each launch file’s --show-args option.
Configuration
Simply setup the network interface parameters and list your desired topics to get started. If you are using UDP over cellular data, it is recommended to setup a VPN to facilitate connection. Also, please note that no encryption occurs within this package. Currently, if you would like encryption, you must use a VPN.
See config/Udp1.yaml for a description of all parameters, as well as the TCP example configuration files.
Minimal Example
The following configuration examples demonstrate a robot sending a message on /gps/fix over UDP to a basestation that will then re-publish the message. This works seamlessly on all message types, so long as they are built and sourced on both ends of the transmission.
Robot
``` /udp_sender: ros__parameters: UdpInterface: local_address: “192.168.1.2” receive_port: 5001
File truncated at 100 lines see the full file
CONTRIBUTING
Repository Summary
| Checkout URI | https://github.com/brow1633/network_bridge.git |
| VCS Type | git |
| VCS Version | main |
| Last Updated | 2026-10-12 |
| Dev Status | MAINTAINED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| network_bridge | 3.1.0 |
README
Network Bridge
Network Bridge is a lightweight ROS2 node designed for robust communication between robotic systems over arbitrary network protocols. Supporting UDP, TCP, and ZMQ protocols out of the box, this packages seamlessly bridges ROS2 topics across networks, facilitating effective remote communications between a base station and robotic systems, or between multiple robotic systems.
Installation
Installation via apt
Install with:
sudo apt install ros-<distro>-network-bridge
Building from Source
Simply clone the repository into your ROS2 workspace and build with colcon build.
Usage
Demo
TCP
ros2 launch network_bridge tcp.launch.py
ros2 topic pub /tcp1/MyDefaultTopic std_msgs/msg/String "data: 'Hello World'"
ros2 topic echo /tcp2/MyDefaultTopic
UDP
ros2 launch network_bridge udp.launch.py
ros2 topic pub /udp1/MyDefaultTopic std_msgs/msg/String "data: 'Hello World'"
ros2 topic echo /udp2/MyDefaultTopic
ZMQ
ros2 launch network_bridge zmq.launch.py
ros2 topic pub /zmq1/test_topic std_msgs/msg/String "data: 'Hello World'"
ros2 topic echo /zmq2/test_topic
Talker/listener demos
The installed files in demo/ bridge sample chatter and static transforms.
The server starts both TCP and UDP bridges. Run the server in one terminal:
ros2 launch network_bridge demo_server.launch.py
In another terminal, run either client:
ros2 launch network_bridge tcp_demo_client.launch.py
# Or:
ros2 launch network_bridge udp_demo_client.launch.py
The talkers publish automatically. The listeners print the messages received
through the bridge. The demo_nodes_cpp runtime dependency is installed with
this package, or resolved by rosdep when building from source.
For separate hosts, use the server’s address on the TCP client:
ros2 launch network_bridge tcp_demo_client.launch.py server_host:=SERVER_IP
For UDP, configure both hosts. On the server:
ros2 launch network_bridge demo_server.launch.py udp_server_address:=0.0.0.0 udp_receiver_host:=CLIENT_IP
On the client:
ros2 launch network_bridge udp_demo_client.launch.py receiver_address:=0.0.0.0 server_host:=SERVER_IP
Replace SERVER_IP and CLIENT_IP with the hosts’ reachable addresses. The
port arguments are available through each launch file’s --show-args option.
Configuration
Simply setup the network interface parameters and list your desired topics to get started. If you are using UDP over cellular data, it is recommended to setup a VPN to facilitate connection. Also, please note that no encryption occurs within this package. Currently, if you would like encryption, you must use a VPN.
See config/Udp1.yaml for a description of all parameters, as well as the TCP example configuration files.
Minimal Example
The following configuration examples demonstrate a robot sending a message on /gps/fix over UDP to a basestation that will then re-publish the message. This works seamlessly on all message types, so long as they are built and sourced on both ends of the transmission.
Robot
``` /udp_sender: ros__parameters: UdpInterface: local_address: “192.168.1.2” receive_port: 5001
File truncated at 100 lines see the full file
CONTRIBUTING
Repository Summary
| Checkout URI | https://github.com/brow1633/network_bridge.git |
| VCS Type | git |
| VCS Version | main |
| Last Updated | 2026-10-12 |
| Dev Status | MAINTAINED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| network_bridge | 3.1.0 |
README
Network Bridge
Network Bridge is a lightweight ROS2 node designed for robust communication between robotic systems over arbitrary network protocols. Supporting UDP, TCP, and ZMQ protocols out of the box, this packages seamlessly bridges ROS2 topics across networks, facilitating effective remote communications between a base station and robotic systems, or between multiple robotic systems.
Installation
Installation via apt
Install with:
sudo apt install ros-<distro>-network-bridge
Building from Source
Simply clone the repository into your ROS2 workspace and build with colcon build.
Usage
Demo
TCP
ros2 launch network_bridge tcp.launch.py
ros2 topic pub /tcp1/MyDefaultTopic std_msgs/msg/String "data: 'Hello World'"
ros2 topic echo /tcp2/MyDefaultTopic
UDP
ros2 launch network_bridge udp.launch.py
ros2 topic pub /udp1/MyDefaultTopic std_msgs/msg/String "data: 'Hello World'"
ros2 topic echo /udp2/MyDefaultTopic
ZMQ
ros2 launch network_bridge zmq.launch.py
ros2 topic pub /zmq1/test_topic std_msgs/msg/String "data: 'Hello World'"
ros2 topic echo /zmq2/test_topic
Talker/listener demos
The installed files in demo/ bridge sample chatter and static transforms.
The server starts both TCP and UDP bridges. Run the server in one terminal:
ros2 launch network_bridge demo_server.launch.py
In another terminal, run either client:
ros2 launch network_bridge tcp_demo_client.launch.py
# Or:
ros2 launch network_bridge udp_demo_client.launch.py
The talkers publish automatically. The listeners print the messages received
through the bridge. The demo_nodes_cpp runtime dependency is installed with
this package, or resolved by rosdep when building from source.
For separate hosts, use the server’s address on the TCP client:
ros2 launch network_bridge tcp_demo_client.launch.py server_host:=SERVER_IP
For UDP, configure both hosts. On the server:
ros2 launch network_bridge demo_server.launch.py udp_server_address:=0.0.0.0 udp_receiver_host:=CLIENT_IP
On the client:
ros2 launch network_bridge udp_demo_client.launch.py receiver_address:=0.0.0.0 server_host:=SERVER_IP
Replace SERVER_IP and CLIENT_IP with the hosts’ reachable addresses. The
port arguments are available through each launch file’s --show-args option.
Configuration
Simply setup the network interface parameters and list your desired topics to get started. If you are using UDP over cellular data, it is recommended to setup a VPN to facilitate connection. Also, please note that no encryption occurs within this package. Currently, if you would like encryption, you must use a VPN.
See config/Udp1.yaml for a description of all parameters, as well as the TCP example configuration files.
Minimal Example
The following configuration examples demonstrate a robot sending a message on /gps/fix over UDP to a basestation that will then re-publish the message. This works seamlessly on all message types, so long as they are built and sourced on both ends of the transmission.
Robot
``` /udp_sender: ros__parameters: UdpInterface: local_address: “192.168.1.2” receive_port: 5001
File truncated at 100 lines see the full file
CONTRIBUTING
Repository Summary
| Checkout URI | https://github.com/brow1633/network_bridge.git |
| VCS Type | git |
| VCS Version | main |
| Last Updated | 2026-10-12 |
| Dev Status | MAINTAINED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| network_bridge | 3.1.0 |
README
Network Bridge
Network Bridge is a lightweight ROS2 node designed for robust communication between robotic systems over arbitrary network protocols. Supporting UDP, TCP, and ZMQ protocols out of the box, this packages seamlessly bridges ROS2 topics across networks, facilitating effective remote communications between a base station and robotic systems, or between multiple robotic systems.
Installation
Installation via apt
Install with:
sudo apt install ros-<distro>-network-bridge
Building from Source
Simply clone the repository into your ROS2 workspace and build with colcon build.
Usage
Demo
TCP
ros2 launch network_bridge tcp.launch.py
ros2 topic pub /tcp1/MyDefaultTopic std_msgs/msg/String "data: 'Hello World'"
ros2 topic echo /tcp2/MyDefaultTopic
UDP
ros2 launch network_bridge udp.launch.py
ros2 topic pub /udp1/MyDefaultTopic std_msgs/msg/String "data: 'Hello World'"
ros2 topic echo /udp2/MyDefaultTopic
ZMQ
ros2 launch network_bridge zmq.launch.py
ros2 topic pub /zmq1/test_topic std_msgs/msg/String "data: 'Hello World'"
ros2 topic echo /zmq2/test_topic
Talker/listener demos
The installed files in demo/ bridge sample chatter and static transforms.
The server starts both TCP and UDP bridges. Run the server in one terminal:
ros2 launch network_bridge demo_server.launch.py
In another terminal, run either client:
ros2 launch network_bridge tcp_demo_client.launch.py
# Or:
ros2 launch network_bridge udp_demo_client.launch.py
The talkers publish automatically. The listeners print the messages received
through the bridge. The demo_nodes_cpp runtime dependency is installed with
this package, or resolved by rosdep when building from source.
For separate hosts, use the server’s address on the TCP client:
ros2 launch network_bridge tcp_demo_client.launch.py server_host:=SERVER_IP
For UDP, configure both hosts. On the server:
ros2 launch network_bridge demo_server.launch.py udp_server_address:=0.0.0.0 udp_receiver_host:=CLIENT_IP
On the client:
ros2 launch network_bridge udp_demo_client.launch.py receiver_address:=0.0.0.0 server_host:=SERVER_IP
Replace SERVER_IP and CLIENT_IP with the hosts’ reachable addresses. The
port arguments are available through each launch file’s --show-args option.
Configuration
Simply setup the network interface parameters and list your desired topics to get started. If you are using UDP over cellular data, it is recommended to setup a VPN to facilitate connection. Also, please note that no encryption occurs within this package. Currently, if you would like encryption, you must use a VPN.
See config/Udp1.yaml for a description of all parameters, as well as the TCP example configuration files.
Minimal Example
The following configuration examples demonstrate a robot sending a message on /gps/fix over UDP to a basestation that will then re-publish the message. This works seamlessly on all message types, so long as they are built and sourced on both ends of the transmission.
Robot
``` /udp_sender: ros__parameters: UdpInterface: local_address: “192.168.1.2” receive_port: 5001
File truncated at 100 lines see the full file
CONTRIBUTING
Repository Summary
| Checkout URI | https://github.com/brow1633/network_bridge.git |
| VCS Type | git |
| VCS Version | main |
| Last Updated | 2026-10-12 |
| Dev Status | MAINTAINED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| network_bridge | 3.1.0 |
README
Network Bridge
Network Bridge is a lightweight ROS2 node designed for robust communication between robotic systems over arbitrary network protocols. Supporting UDP, TCP, and ZMQ protocols out of the box, this packages seamlessly bridges ROS2 topics across networks, facilitating effective remote communications between a base station and robotic systems, or between multiple robotic systems.
Installation
Installation via apt
Install with:
sudo apt install ros-<distro>-network-bridge
Building from Source
Simply clone the repository into your ROS2 workspace and build with colcon build.
Usage
Demo
TCP
ros2 launch network_bridge tcp.launch.py
ros2 topic pub /tcp1/MyDefaultTopic std_msgs/msg/String "data: 'Hello World'"
ros2 topic echo /tcp2/MyDefaultTopic
UDP
ros2 launch network_bridge udp.launch.py
ros2 topic pub /udp1/MyDefaultTopic std_msgs/msg/String "data: 'Hello World'"
ros2 topic echo /udp2/MyDefaultTopic
ZMQ
ros2 launch network_bridge zmq.launch.py
ros2 topic pub /zmq1/test_topic std_msgs/msg/String "data: 'Hello World'"
ros2 topic echo /zmq2/test_topic
Talker/listener demos
The installed files in demo/ bridge sample chatter and static transforms.
The server starts both TCP and UDP bridges. Run the server in one terminal:
ros2 launch network_bridge demo_server.launch.py
In another terminal, run either client:
ros2 launch network_bridge tcp_demo_client.launch.py
# Or:
ros2 launch network_bridge udp_demo_client.launch.py
The talkers publish automatically. The listeners print the messages received
through the bridge. The demo_nodes_cpp runtime dependency is installed with
this package, or resolved by rosdep when building from source.
For separate hosts, use the server’s address on the TCP client:
ros2 launch network_bridge tcp_demo_client.launch.py server_host:=SERVER_IP
For UDP, configure both hosts. On the server:
ros2 launch network_bridge demo_server.launch.py udp_server_address:=0.0.0.0 udp_receiver_host:=CLIENT_IP
On the client:
ros2 launch network_bridge udp_demo_client.launch.py receiver_address:=0.0.0.0 server_host:=SERVER_IP
Replace SERVER_IP and CLIENT_IP with the hosts’ reachable addresses. The
port arguments are available through each launch file’s --show-args option.
Configuration
Simply setup the network interface parameters and list your desired topics to get started. If you are using UDP over cellular data, it is recommended to setup a VPN to facilitate connection. Also, please note that no encryption occurs within this package. Currently, if you would like encryption, you must use a VPN.
See config/Udp1.yaml for a description of all parameters, as well as the TCP example configuration files.
Minimal Example
The following configuration examples demonstrate a robot sending a message on /gps/fix over UDP to a basestation that will then re-publish the message. This works seamlessly on all message types, so long as they are built and sourced on both ends of the transmission.
Robot
``` /udp_sender: ros__parameters: UdpInterface: local_address: “192.168.1.2” receive_port: 5001
File truncated at 100 lines see the full file
CONTRIBUTING
Repository Summary
| Checkout URI | https://github.com/brow1633/network_bridge.git |
| VCS Type | git |
| VCS Version | main |
| Last Updated | 2026-10-12 |
| Dev Status | MAINTAINED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| network_bridge | 3.1.0 |
README
Network Bridge
Network Bridge is a lightweight ROS2 node designed for robust communication between robotic systems over arbitrary network protocols. Supporting UDP, TCP, and ZMQ protocols out of the box, this packages seamlessly bridges ROS2 topics across networks, facilitating effective remote communications between a base station and robotic systems, or between multiple robotic systems.
Installation
Installation via apt
Install with:
sudo apt install ros-<distro>-network-bridge
Building from Source
Simply clone the repository into your ROS2 workspace and build with colcon build.
Usage
Demo
TCP
ros2 launch network_bridge tcp.launch.py
ros2 topic pub /tcp1/MyDefaultTopic std_msgs/msg/String "data: 'Hello World'"
ros2 topic echo /tcp2/MyDefaultTopic
UDP
ros2 launch network_bridge udp.launch.py
ros2 topic pub /udp1/MyDefaultTopic std_msgs/msg/String "data: 'Hello World'"
ros2 topic echo /udp2/MyDefaultTopic
ZMQ
ros2 launch network_bridge zmq.launch.py
ros2 topic pub /zmq1/test_topic std_msgs/msg/String "data: 'Hello World'"
ros2 topic echo /zmq2/test_topic
Talker/listener demos
The installed files in demo/ bridge sample chatter and static transforms.
The server starts both TCP and UDP bridges. Run the server in one terminal:
ros2 launch network_bridge demo_server.launch.py
In another terminal, run either client:
ros2 launch network_bridge tcp_demo_client.launch.py
# Or:
ros2 launch network_bridge udp_demo_client.launch.py
The talkers publish automatically. The listeners print the messages received
through the bridge. The demo_nodes_cpp runtime dependency is installed with
this package, or resolved by rosdep when building from source.
For separate hosts, use the server’s address on the TCP client:
ros2 launch network_bridge tcp_demo_client.launch.py server_host:=SERVER_IP
For UDP, configure both hosts. On the server:
ros2 launch network_bridge demo_server.launch.py udp_server_address:=0.0.0.0 udp_receiver_host:=CLIENT_IP
On the client:
ros2 launch network_bridge udp_demo_client.launch.py receiver_address:=0.0.0.0 server_host:=SERVER_IP
Replace SERVER_IP and CLIENT_IP with the hosts’ reachable addresses. The
port arguments are available through each launch file’s --show-args option.
Configuration
Simply setup the network interface parameters and list your desired topics to get started. If you are using UDP over cellular data, it is recommended to setup a VPN to facilitate connection. Also, please note that no encryption occurs within this package. Currently, if you would like encryption, you must use a VPN.
See config/Udp1.yaml for a description of all parameters, as well as the TCP example configuration files.
Minimal Example
The following configuration examples demonstrate a robot sending a message on /gps/fix over UDP to a basestation that will then re-publish the message. This works seamlessly on all message types, so long as they are built and sourced on both ends of the transmission.
Robot
``` /udp_sender: ros__parameters: UdpInterface: local_address: “192.168.1.2” receive_port: 5001
File truncated at 100 lines see the full file
CONTRIBUTING
Repository Summary
| Checkout URI | https://github.com/brow1633/network_bridge.git |
| VCS Type | git |
| VCS Version | main |
| Last Updated | 2026-10-12 |
| Dev Status | MAINTAINED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| network_bridge | 3.1.0 |
README
Network Bridge
Network Bridge is a lightweight ROS2 node designed for robust communication between robotic systems over arbitrary network protocols. Supporting UDP, TCP, and ZMQ protocols out of the box, this packages seamlessly bridges ROS2 topics across networks, facilitating effective remote communications between a base station and robotic systems, or between multiple robotic systems.
Installation
Installation via apt
Install with:
sudo apt install ros-<distro>-network-bridge
Building from Source
Simply clone the repository into your ROS2 workspace and build with colcon build.
Usage
Demo
TCP
ros2 launch network_bridge tcp.launch.py
ros2 topic pub /tcp1/MyDefaultTopic std_msgs/msg/String "data: 'Hello World'"
ros2 topic echo /tcp2/MyDefaultTopic
UDP
ros2 launch network_bridge udp.launch.py
ros2 topic pub /udp1/MyDefaultTopic std_msgs/msg/String "data: 'Hello World'"
ros2 topic echo /udp2/MyDefaultTopic
ZMQ
ros2 launch network_bridge zmq.launch.py
ros2 topic pub /zmq1/test_topic std_msgs/msg/String "data: 'Hello World'"
ros2 topic echo /zmq2/test_topic
Talker/listener demos
The installed files in demo/ bridge sample chatter and static transforms.
The server starts both TCP and UDP bridges. Run the server in one terminal:
ros2 launch network_bridge demo_server.launch.py
In another terminal, run either client:
ros2 launch network_bridge tcp_demo_client.launch.py
# Or:
ros2 launch network_bridge udp_demo_client.launch.py
The talkers publish automatically. The listeners print the messages received
through the bridge. The demo_nodes_cpp runtime dependency is installed with
this package, or resolved by rosdep when building from source.
For separate hosts, use the server’s address on the TCP client:
ros2 launch network_bridge tcp_demo_client.launch.py server_host:=SERVER_IP
For UDP, configure both hosts. On the server:
ros2 launch network_bridge demo_server.launch.py udp_server_address:=0.0.0.0 udp_receiver_host:=CLIENT_IP
On the client:
ros2 launch network_bridge udp_demo_client.launch.py receiver_address:=0.0.0.0 server_host:=SERVER_IP
Replace SERVER_IP and CLIENT_IP with the hosts’ reachable addresses. The
port arguments are available through each launch file’s --show-args option.
Configuration
Simply setup the network interface parameters and list your desired topics to get started. If you are using UDP over cellular data, it is recommended to setup a VPN to facilitate connection. Also, please note that no encryption occurs within this package. Currently, if you would like encryption, you must use a VPN.
See config/Udp1.yaml for a description of all parameters, as well as the TCP example configuration files.
Minimal Example
The following configuration examples demonstrate a robot sending a message on /gps/fix over UDP to a basestation that will then re-publish the message. This works seamlessly on all message types, so long as they are built and sourced on both ends of the transmission.
Robot
``` /udp_sender: ros__parameters: UdpInterface: local_address: “192.168.1.2” receive_port: 5001
File truncated at 100 lines see the full file
CONTRIBUTING
Repository Summary
| Checkout URI | https://github.com/brow1633/network_bridge.git |
| VCS Type | git |
| VCS Version | main |
| Last Updated | 2026-10-12 |
| Dev Status | MAINTAINED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| network_bridge | 3.1.0 |
README
Network Bridge
Network Bridge is a lightweight ROS2 node designed for robust communication between robotic systems over arbitrary network protocols. Supporting UDP, TCP, and ZMQ protocols out of the box, this packages seamlessly bridges ROS2 topics across networks, facilitating effective remote communications between a base station and robotic systems, or between multiple robotic systems.
Installation
Installation via apt
Install with:
sudo apt install ros-<distro>-network-bridge
Building from Source
Simply clone the repository into your ROS2 workspace and build with colcon build.
Usage
Demo
TCP
ros2 launch network_bridge tcp.launch.py
ros2 topic pub /tcp1/MyDefaultTopic std_msgs/msg/String "data: 'Hello World'"
ros2 topic echo /tcp2/MyDefaultTopic
UDP
ros2 launch network_bridge udp.launch.py
ros2 topic pub /udp1/MyDefaultTopic std_msgs/msg/String "data: 'Hello World'"
ros2 topic echo /udp2/MyDefaultTopic
ZMQ
ros2 launch network_bridge zmq.launch.py
ros2 topic pub /zmq1/test_topic std_msgs/msg/String "data: 'Hello World'"
ros2 topic echo /zmq2/test_topic
Talker/listener demos
The installed files in demo/ bridge sample chatter and static transforms.
The server starts both TCP and UDP bridges. Run the server in one terminal:
ros2 launch network_bridge demo_server.launch.py
In another terminal, run either client:
ros2 launch network_bridge tcp_demo_client.launch.py
# Or:
ros2 launch network_bridge udp_demo_client.launch.py
The talkers publish automatically. The listeners print the messages received
through the bridge. The demo_nodes_cpp runtime dependency is installed with
this package, or resolved by rosdep when building from source.
For separate hosts, use the server’s address on the TCP client:
ros2 launch network_bridge tcp_demo_client.launch.py server_host:=SERVER_IP
For UDP, configure both hosts. On the server:
ros2 launch network_bridge demo_server.launch.py udp_server_address:=0.0.0.0 udp_receiver_host:=CLIENT_IP
On the client:
ros2 launch network_bridge udp_demo_client.launch.py receiver_address:=0.0.0.0 server_host:=SERVER_IP
Replace SERVER_IP and CLIENT_IP with the hosts’ reachable addresses. The
port arguments are available through each launch file’s --show-args option.
Configuration
Simply setup the network interface parameters and list your desired topics to get started. If you are using UDP over cellular data, it is recommended to setup a VPN to facilitate connection. Also, please note that no encryption occurs within this package. Currently, if you would like encryption, you must use a VPN.
See config/Udp1.yaml for a description of all parameters, as well as the TCP example configuration files.
Minimal Example
The following configuration examples demonstrate a robot sending a message on /gps/fix over UDP to a basestation that will then re-publish the message. This works seamlessly on all message types, so long as they are built and sourced on both ends of the transmission.
Robot
``` /udp_sender: ros__parameters: UdpInterface: local_address: “192.168.1.2” receive_port: 5001
File truncated at 100 lines see the full file
CONTRIBUTING
Repository Summary
| Checkout URI | https://github.com/brow1633/network_bridge.git |
| VCS Type | git |
| VCS Version | main |
| Last Updated | 2026-10-12 |
| Dev Status | MAINTAINED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| network_bridge | 3.1.0 |
README
Network Bridge
Network Bridge is a lightweight ROS2 node designed for robust communication between robotic systems over arbitrary network protocols. Supporting UDP, TCP, and ZMQ protocols out of the box, this packages seamlessly bridges ROS2 topics across networks, facilitating effective remote communications between a base station and robotic systems, or between multiple robotic systems.
Installation
Installation via apt
Install with:
sudo apt install ros-<distro>-network-bridge
Building from Source
Simply clone the repository into your ROS2 workspace and build with colcon build.
Usage
Demo
TCP
ros2 launch network_bridge tcp.launch.py
ros2 topic pub /tcp1/MyDefaultTopic std_msgs/msg/String "data: 'Hello World'"
ros2 topic echo /tcp2/MyDefaultTopic
UDP
ros2 launch network_bridge udp.launch.py
ros2 topic pub /udp1/MyDefaultTopic std_msgs/msg/String "data: 'Hello World'"
ros2 topic echo /udp2/MyDefaultTopic
ZMQ
ros2 launch network_bridge zmq.launch.py
ros2 topic pub /zmq1/test_topic std_msgs/msg/String "data: 'Hello World'"
ros2 topic echo /zmq2/test_topic
Talker/listener demos
The installed files in demo/ bridge sample chatter and static transforms.
The server starts both TCP and UDP bridges. Run the server in one terminal:
ros2 launch network_bridge demo_server.launch.py
In another terminal, run either client:
ros2 launch network_bridge tcp_demo_client.launch.py
# Or:
ros2 launch network_bridge udp_demo_client.launch.py
The talkers publish automatically. The listeners print the messages received
through the bridge. The demo_nodes_cpp runtime dependency is installed with
this package, or resolved by rosdep when building from source.
For separate hosts, use the server’s address on the TCP client:
ros2 launch network_bridge tcp_demo_client.launch.py server_host:=SERVER_IP
For UDP, configure both hosts. On the server:
ros2 launch network_bridge demo_server.launch.py udp_server_address:=0.0.0.0 udp_receiver_host:=CLIENT_IP
On the client:
ros2 launch network_bridge udp_demo_client.launch.py receiver_address:=0.0.0.0 server_host:=SERVER_IP
Replace SERVER_IP and CLIENT_IP with the hosts’ reachable addresses. The
port arguments are available through each launch file’s --show-args option.
Configuration
Simply setup the network interface parameters and list your desired topics to get started. If you are using UDP over cellular data, it is recommended to setup a VPN to facilitate connection. Also, please note that no encryption occurs within this package. Currently, if you would like encryption, you must use a VPN.
See config/Udp1.yaml for a description of all parameters, as well as the TCP example configuration files.
Minimal Example
The following configuration examples demonstrate a robot sending a message on /gps/fix over UDP to a basestation that will then re-publish the message. This works seamlessly on all message types, so long as they are built and sourced on both ends of the transmission.
Robot
``` /udp_sender: ros__parameters: UdpInterface: local_address: “192.168.1.2” receive_port: 5001
File truncated at 100 lines see the full file
CONTRIBUTING
Repository Summary
| Checkout URI | https://github.com/brow1633/network_bridge.git |
| VCS Type | git |
| VCS Version | main |
| Last Updated | 2026-10-12 |
| Dev Status | MAINTAINED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| network_bridge | 3.1.0 |
README
Network Bridge
Network Bridge is a lightweight ROS2 node designed for robust communication between robotic systems over arbitrary network protocols. Supporting UDP, TCP, and ZMQ protocols out of the box, this packages seamlessly bridges ROS2 topics across networks, facilitating effective remote communications between a base station and robotic systems, or between multiple robotic systems.
Installation
Installation via apt
Install with:
sudo apt install ros-<distro>-network-bridge
Building from Source
Simply clone the repository into your ROS2 workspace and build with colcon build.
Usage
Demo
TCP
ros2 launch network_bridge tcp.launch.py
ros2 topic pub /tcp1/MyDefaultTopic std_msgs/msg/String "data: 'Hello World'"
ros2 topic echo /tcp2/MyDefaultTopic
UDP
ros2 launch network_bridge udp.launch.py
ros2 topic pub /udp1/MyDefaultTopic std_msgs/msg/String "data: 'Hello World'"
ros2 topic echo /udp2/MyDefaultTopic
ZMQ
ros2 launch network_bridge zmq.launch.py
ros2 topic pub /zmq1/test_topic std_msgs/msg/String "data: 'Hello World'"
ros2 topic echo /zmq2/test_topic
Talker/listener demos
The installed files in demo/ bridge sample chatter and static transforms.
The server starts both TCP and UDP bridges. Run the server in one terminal:
ros2 launch network_bridge demo_server.launch.py
In another terminal, run either client:
ros2 launch network_bridge tcp_demo_client.launch.py
# Or:
ros2 launch network_bridge udp_demo_client.launch.py
The talkers publish automatically. The listeners print the messages received
through the bridge. The demo_nodes_cpp runtime dependency is installed with
this package, or resolved by rosdep when building from source.
For separate hosts, use the server’s address on the TCP client:
ros2 launch network_bridge tcp_demo_client.launch.py server_host:=SERVER_IP
For UDP, configure both hosts. On the server:
ros2 launch network_bridge demo_server.launch.py udp_server_address:=0.0.0.0 udp_receiver_host:=CLIENT_IP
On the client:
ros2 launch network_bridge udp_demo_client.launch.py receiver_address:=0.0.0.0 server_host:=SERVER_IP
Replace SERVER_IP and CLIENT_IP with the hosts’ reachable addresses. The
port arguments are available through each launch file’s --show-args option.
Configuration
Simply setup the network interface parameters and list your desired topics to get started. If you are using UDP over cellular data, it is recommended to setup a VPN to facilitate connection. Also, please note that no encryption occurs within this package. Currently, if you would like encryption, you must use a VPN.
See config/Udp1.yaml for a description of all parameters, as well as the TCP example configuration files.
Minimal Example
The following configuration examples demonstrate a robot sending a message on /gps/fix over UDP to a basestation that will then re-publish the message. This works seamlessly on all message types, so long as they are built and sourced on both ends of the transmission.
Robot
``` /udp_sender: ros__parameters: UdpInterface: local_address: “192.168.1.2” receive_port: 5001
File truncated at 100 lines see the full file