ROS Index
|
indoor_positioning package from indoor_positioning repoindoor_positioning |
ROS Distro
|
Package Summary
| Tags | No category tags. |
| Version | 1.1.0 |
| License | BSD 2-Clause License |
| Build type | CATKIN |
| Use | RECOMMENDED |
Repository Summary
| Checkout URI | https://github.com/metratec/indoor_positioning.git |
| VCS Type | git |
| VCS Version | master |
| Last Updated | 2018-10-26 |
| Dev Status | MAINTAINED |
| CI status | Continuous Integration |
| Released | RELEASED |
| Tags | No category tags. |
| Contributing |
Help Wanted (0)
Good First Issues (0) Pull Requests to Review (0) |
Package Description
Additional Links
Maintainers
- Christian Arndt
Authors
- Christian Arndt
indoor_positioning
I. About
This is a ROS package for the metraTec Indoor Positioning System. You can use the regular IPS for zone location of your robot or the IPS+ products for 3D-position-estimation using UWB ranging.
The image shows an example of the indoor positioning functionality. Four RF beacons are placed in the environment that localize a corresponding receiver in the vicinity. The IPS displays the current (user-defined) zone that the receiver is in (green rectangle). Additionally, using the IPS+ position estimation, the actual 3D-position of the receiver is displayed (pink sphere).
II. Installation
From ROS binaries (preferred method):
Simply run the following command where you change
``` to whatever distribution you are using.
$ sudo apt-get install ros-ROSDISTRO-indoor-positioning
### From source:
If you can't use the binary release, for example when you are using an older version of ROS, you can still manually
build the package yourself.
First, clone the repository into the source folder of your catkin workspace:
$ git clone https://github.com/metratec/indoor_positioning.git YOUR_CATKIN_WS/src/indoor_positioning
Install python dependencies via:
$ pip install -r requirements.txt
Now you should be able to use the package like any other (catkin) package in your workspace.
## III. Usage
The
```receiver.py
``` node handles communication with the receiver and publishes incoming messages. Therefore you have to run this node
in order to use the IPS or IPS+ node. Then you can run either the
```positioning.py
``` node for IPS or the
```positioning_plus.py
``` node for IPS+ (or both, theoretically).
### Setup
To be able to use the nodes for zone location (IPS) or UWB positioning (IPS+) you have to setup your environment in a YAML configuration file.
Take a look at the
```config/zones_template.yml
``` example for information about the structure and content of this config file.
### Launch files
There are two launch files you can use right away to test this package with default parameters.
The
```ips.launch
``` file starts the receiver and the IPS node for zone location.
The
```ips_plus.launch
``` file starts the receiver and the IPS+ node for UWB position estimation.
For both you have to specify whether you use a TCP or USB receiver and how they are connected.
launching the IPS node using a metraTec USB receiver
$ roslaunch indoor_positioning ips.launch rec_name:=port rec_value:=/dev/ttyUSB0
launching the IPS+ node using a TCP receiver
$ roslaunch indoor_positioning ips_plus.launch rec_name:=host rec_value:=192.168.2.223
If you want to use non-default parameters for any of the nodes you have to set them in the ROS parameter server or
write your own launch files that set the respective parameters however you want.
Take a look at the two launch files mentioned above as an example.
_Note:_ by setting the
```do_vis
``` parameter of the launch files to
```True
``` you can simultaneously start rviz with
predefined settings to display the defined beacon positions, current zone and/or estimated receiver position.
### Nodes
#### receiver.py
Use this node to establish a connection with the metraTec IPS receiver or USB stick. You have to pass the USB port the
stick is connected to or the IP address of the regular receiver as a command line argument or as a private parameter
when you are using a launch file.
Running from command line:
$ rosrun indoor_positioning receiver.py TYPE REQUIRED OPTIONAL
For example:
$ rosrun indoor_positioning receiver.py usb /dev/ttyUSB0 $ rosrun indoor_positioning receiver.py tcp 192.168.2.223
```
Subscribed topics:
- ips/receiver/send (std_msgs/String):
Message to be sent over the TCP or serial connection to the IPS receiver or USB stick
Published topics:
- ips/receiver/raw (indoor_positioning/StringStamped):
Raw messages received from the receiver or USB stick
Parameters:
-
~type (string, default=’tcp’):
‘tcp’ for TCP receiver or ‘usb’ for metraTec USB stick -
~host (string, default=’192.168.2.223):
IP address of the connected receiver -
~port (with type=’tcp’: int, default=10001; with type=’usb’: string, default=’/dev/ttyUSB0):
Port for the TCP connection if ‘~type’ parameter is set to ‘tcp’, otherwise specifies the USB port of the stick -
~baudrate (int, default=115200):
Baudrate to use for serial communication with USB receiver
positioning.py (IPS)
Use this node to perform indoor zone location using the metraTec IPS tracking system. Prerequisites for using this node
File truncated at 100 lines see the full file
Changelog for package ros_ips
1.1.0 (2018-06-20) -----------* Trilatered positions are only published now if they are inside a polygon spanned by the beacons * Revamped launch files
1.0.3 (2018-06-20)
- Added some parametrization options to allow more efficient and robust position estimation
1.0.2 (2018-05-22)
- Renamed package from ros_ips to indoor_positioning
1.0.1 (2018-05-11)
- First public release for kinetic
Wiki Tutorials
Package Dependencies
| Deps | Name |
|---|---|
| roscpp | |
| rospy | |
| std_msgs | |
| message_generation | |
| catkin | |
| message_runtime |
System Dependencies
Dependant Packages
Launch files
- launch/ips.launch
-
- type [default: usb]
- host [default: 192.168.2.223]
- port [default: /dev/ttyUSB0]
- baudrate [default: 115200]
- config_file [default: config/zones.yml]
- rate [default: 1]
- bcn_len [default: -1]
- do_vis [default: False]
- launch/ips_plus.launch
-
- type [default: tcp]
- host [default: 192.168.2.223]
- port [default: 10001]
- baudrate [default: 115200]
- config_file [default: config/zones.yml]
- frame_id [default: map]
- rate [default: 0.1]
- bcn_len [default: -1]
- srg_len [default: -1]
- min_beacons [default: 3]
- max_beacons [default: 6]
- rssi_thresh [default: -127]
- max_z [default: 1]
- dilation [default: 0]
- do_vis [default: False]
Messages
Services
Plugins
Recent questions tagged indoor_positioning at Robotics Stack Exchange
|
|
indoor_positioning package from indoor_positioning repoindoor_positioning |
ROS Distro
|
Package Summary
| Tags | No category tags. |
| Version | 1.1.0 |
| License | BSD 2-Clause License |
| Build type | CATKIN |
| Use | RECOMMENDED |
Repository Summary
| Checkout URI | https://github.com/metratec/indoor_positioning.git |
| VCS Type | git |
| VCS Version | master |
| Last Updated | 2018-10-26 |
| Dev Status | MAINTAINED |
| CI status | Continuous Integration |
| Released | RELEASED |
| Tags | No category tags. |
| Contributing |
Help Wanted (0)
Good First Issues (0) Pull Requests to Review (0) |
Package Description
Additional Links
Maintainers
- Christian Arndt
Authors
- Christian Arndt
indoor_positioning
I. About
This is a ROS package for the metraTec Indoor Positioning System. You can use the regular IPS for zone location of your robot or the IPS+ products for 3D-position-estimation using UWB ranging.
The image shows an example of the indoor positioning functionality. Four RF beacons are placed in the environment that localize a corresponding receiver in the vicinity. The IPS displays the current (user-defined) zone that the receiver is in (green rectangle). Additionally, using the IPS+ position estimation, the actual 3D-position of the receiver is displayed (pink sphere).
II. Installation
From ROS binaries (preferred method):
Simply run the following command where you change
``` to whatever distribution you are using.
$ sudo apt-get install ros-ROSDISTRO-indoor-positioning
### From source:
If you can't use the binary release, for example when you are using an older version of ROS, you can still manually
build the package yourself.
First, clone the repository into the source folder of your catkin workspace:
$ git clone https://github.com/metratec/indoor_positioning.git YOUR_CATKIN_WS/src/indoor_positioning
Install python dependencies via:
$ pip install -r requirements.txt
Now you should be able to use the package like any other (catkin) package in your workspace.
## III. Usage
The
```receiver.py
``` node handles communication with the receiver and publishes incoming messages. Therefore you have to run this node
in order to use the IPS or IPS+ node. Then you can run either the
```positioning.py
``` node for IPS or the
```positioning_plus.py
``` node for IPS+ (or both, theoretically).
### Setup
To be able to use the nodes for zone location (IPS) or UWB positioning (IPS+) you have to setup your environment in a YAML configuration file.
Take a look at the
```config/zones_template.yml
``` example for information about the structure and content of this config file.
### Launch files
There are two launch files you can use right away to test this package with default parameters.
The
```ips.launch
``` file starts the receiver and the IPS node for zone location.
The
```ips_plus.launch
``` file starts the receiver and the IPS+ node for UWB position estimation.
For both you have to specify whether you use a TCP or USB receiver and how they are connected.
launching the IPS node using a metraTec USB receiver
$ roslaunch indoor_positioning ips.launch rec_name:=port rec_value:=/dev/ttyUSB0
launching the IPS+ node using a TCP receiver
$ roslaunch indoor_positioning ips_plus.launch rec_name:=host rec_value:=192.168.2.223
If you want to use non-default parameters for any of the nodes you have to set them in the ROS parameter server or
write your own launch files that set the respective parameters however you want.
Take a look at the two launch files mentioned above as an example.
_Note:_ by setting the
```do_vis
``` parameter of the launch files to
```True
``` you can simultaneously start rviz with
predefined settings to display the defined beacon positions, current zone and/or estimated receiver position.
### Nodes
#### receiver.py
Use this node to establish a connection with the metraTec IPS receiver or USB stick. You have to pass the USB port the
stick is connected to or the IP address of the regular receiver as a command line argument or as a private parameter
when you are using a launch file.
Running from command line:
$ rosrun indoor_positioning receiver.py TYPE REQUIRED OPTIONAL
For example:
$ rosrun indoor_positioning receiver.py usb /dev/ttyUSB0 $ rosrun indoor_positioning receiver.py tcp 192.168.2.223
```
Subscribed topics:
- ips/receiver/send (std_msgs/String):
Message to be sent over the TCP or serial connection to the IPS receiver or USB stick
Published topics:
- ips/receiver/raw (indoor_positioning/StringStamped):
Raw messages received from the receiver or USB stick
Parameters:
-
~type (string, default=’tcp’):
‘tcp’ for TCP receiver or ‘usb’ for metraTec USB stick -
~host (string, default=’192.168.2.223):
IP address of the connected receiver -
~port (with type=’tcp’: int, default=10001; with type=’usb’: string, default=’/dev/ttyUSB0):
Port for the TCP connection if ‘~type’ parameter is set to ‘tcp’, otherwise specifies the USB port of the stick -
~baudrate (int, default=115200):
Baudrate to use for serial communication with USB receiver
positioning.py (IPS)
Use this node to perform indoor zone location using the metraTec IPS tracking system. Prerequisites for using this node
File truncated at 100 lines see the full file
Changelog for package ros_ips
1.1.0 (2018-06-20) -----------* Trilatered positions are only published now if they are inside a polygon spanned by the beacons * Revamped launch files
1.0.3 (2018-06-20)
- Added some parametrization options to allow more efficient and robust position estimation
1.0.2 (2018-05-22)
- Renamed package from ros_ips to indoor_positioning
1.0.1 (2018-05-11)
- First public release for kinetic
Wiki Tutorials
Package Dependencies
| Deps | Name |
|---|---|
| roscpp | |
| rospy | |
| std_msgs | |
| message_generation | |
| catkin | |
| message_runtime |
System Dependencies
Dependant Packages
Launch files
- launch/ips.launch
-
- type [default: usb]
- host [default: 192.168.2.223]
- port [default: /dev/ttyUSB0]
- baudrate [default: 115200]
- config_file [default: config/zones.yml]
- rate [default: 1]
- bcn_len [default: -1]
- do_vis [default: False]
- launch/ips_plus.launch
-
- type [default: tcp]
- host [default: 192.168.2.223]
- port [default: 10001]
- baudrate [default: 115200]
- config_file [default: config/zones.yml]
- frame_id [default: map]
- rate [default: 0.1]
- bcn_len [default: -1]
- srg_len [default: -1]
- min_beacons [default: 3]
- max_beacons [default: 6]
- rssi_thresh [default: -127]
- max_z [default: 1]
- dilation [default: 0]
- do_vis [default: False]
Messages
Services
Plugins
Recent questions tagged indoor_positioning at Robotics Stack Exchange
|
|
indoor_positioning package from indoor_positioning repoindoor_positioning |
ROS Distro
|
Package Summary
| Tags | No category tags. |
| Version | 1.1.0 |
| License | BSD 2-Clause License |
| Build type | CATKIN |
| Use | RECOMMENDED |
Repository Summary
| Checkout URI | https://github.com/metratec/indoor_positioning.git |
| VCS Type | git |
| VCS Version | master |
| Last Updated | 2018-10-26 |
| Dev Status | MAINTAINED |
| CI status | Continuous Integration |
| Released | RELEASED |
| Tags | No category tags. |
| Contributing |
Help Wanted (0)
Good First Issues (0) Pull Requests to Review (0) |
Package Description
Additional Links
Maintainers
- Christian Arndt
Authors
- Christian Arndt
indoor_positioning
I. About
This is a ROS package for the metraTec Indoor Positioning System. You can use the regular IPS for zone location of your robot or the IPS+ products for 3D-position-estimation using UWB ranging.
The image shows an example of the indoor positioning functionality. Four RF beacons are placed in the environment that localize a corresponding receiver in the vicinity. The IPS displays the current (user-defined) zone that the receiver is in (green rectangle). Additionally, using the IPS+ position estimation, the actual 3D-position of the receiver is displayed (pink sphere).
II. Installation
From ROS binaries (preferred method):
Simply run the following command where you change
``` to whatever distribution you are using.
$ sudo apt-get install ros-ROSDISTRO-indoor-positioning
### From source:
If you can't use the binary release, for example when you are using an older version of ROS, you can still manually
build the package yourself.
First, clone the repository into the source folder of your catkin workspace:
$ git clone https://github.com/metratec/indoor_positioning.git YOUR_CATKIN_WS/src/indoor_positioning
Install python dependencies via:
$ pip install -r requirements.txt
Now you should be able to use the package like any other (catkin) package in your workspace.
## III. Usage
The
```receiver.py
``` node handles communication with the receiver and publishes incoming messages. Therefore you have to run this node
in order to use the IPS or IPS+ node. Then you can run either the
```positioning.py
``` node for IPS or the
```positioning_plus.py
``` node for IPS+ (or both, theoretically).
### Setup
To be able to use the nodes for zone location (IPS) or UWB positioning (IPS+) you have to setup your environment in a YAML configuration file.
Take a look at the
```config/zones_template.yml
``` example for information about the structure and content of this config file.
### Launch files
There are two launch files you can use right away to test this package with default parameters.
The
```ips.launch
``` file starts the receiver and the IPS node for zone location.
The
```ips_plus.launch
``` file starts the receiver and the IPS+ node for UWB position estimation.
For both you have to specify whether you use a TCP or USB receiver and how they are connected.
launching the IPS node using a metraTec USB receiver
$ roslaunch indoor_positioning ips.launch rec_name:=port rec_value:=/dev/ttyUSB0
launching the IPS+ node using a TCP receiver
$ roslaunch indoor_positioning ips_plus.launch rec_name:=host rec_value:=192.168.2.223
If you want to use non-default parameters for any of the nodes you have to set them in the ROS parameter server or
write your own launch files that set the respective parameters however you want.
Take a look at the two launch files mentioned above as an example.
_Note:_ by setting the
```do_vis
``` parameter of the launch files to
```True
``` you can simultaneously start rviz with
predefined settings to display the defined beacon positions, current zone and/or estimated receiver position.
### Nodes
#### receiver.py
Use this node to establish a connection with the metraTec IPS receiver or USB stick. You have to pass the USB port the
stick is connected to or the IP address of the regular receiver as a command line argument or as a private parameter
when you are using a launch file.
Running from command line:
$ rosrun indoor_positioning receiver.py TYPE REQUIRED OPTIONAL
For example:
$ rosrun indoor_positioning receiver.py usb /dev/ttyUSB0 $ rosrun indoor_positioning receiver.py tcp 192.168.2.223
```
Subscribed topics:
- ips/receiver/send (std_msgs/String):
Message to be sent over the TCP or serial connection to the IPS receiver or USB stick
Published topics:
- ips/receiver/raw (indoor_positioning/StringStamped):
Raw messages received from the receiver or USB stick
Parameters:
-
~type (string, default=’tcp’):
‘tcp’ for TCP receiver or ‘usb’ for metraTec USB stick -
~host (string, default=’192.168.2.223):
IP address of the connected receiver -
~port (with type=’tcp’: int, default=10001; with type=’usb’: string, default=’/dev/ttyUSB0):
Port for the TCP connection if ‘~type’ parameter is set to ‘tcp’, otherwise specifies the USB port of the stick -
~baudrate (int, default=115200):
Baudrate to use for serial communication with USB receiver
positioning.py (IPS)
Use this node to perform indoor zone location using the metraTec IPS tracking system. Prerequisites for using this node
File truncated at 100 lines see the full file
Changelog for package ros_ips
1.1.0 (2018-06-20) -----------* Trilatered positions are only published now if they are inside a polygon spanned by the beacons * Revamped launch files
1.0.3 (2018-06-20)
- Added some parametrization options to allow more efficient and robust position estimation
1.0.2 (2018-05-22)
- Renamed package from ros_ips to indoor_positioning
1.0.1 (2018-05-11)
- First public release for kinetic
Wiki Tutorials
Package Dependencies
| Deps | Name |
|---|---|
| roscpp | |
| rospy | |
| std_msgs | |
| message_generation | |
| catkin | |
| message_runtime |
System Dependencies
Dependant Packages
Launch files
- launch/ips.launch
-
- type [default: usb]
- host [default: 192.168.2.223]
- port [default: /dev/ttyUSB0]
- baudrate [default: 115200]
- config_file [default: config/zones.yml]
- rate [default: 1]
- bcn_len [default: -1]
- do_vis [default: False]
- launch/ips_plus.launch
-
- type [default: tcp]
- host [default: 192.168.2.223]
- port [default: 10001]
- baudrate [default: 115200]
- config_file [default: config/zones.yml]
- frame_id [default: map]
- rate [default: 0.1]
- bcn_len [default: -1]
- srg_len [default: -1]
- min_beacons [default: 3]
- max_beacons [default: 6]
- rssi_thresh [default: -127]
- max_z [default: 1]
- dilation [default: 0]
- do_vis [default: False]
Messages
Services
Plugins
Recent questions tagged indoor_positioning at Robotics Stack Exchange
|
|
indoor_positioning package from indoor_positioning repoindoor_positioning |
ROS Distro
|
Package Summary
| Tags | No category tags. |
| Version | 1.1.0 |
| License | BSD 2-Clause License |
| Build type | CATKIN |
| Use | RECOMMENDED |
Repository Summary
| Checkout URI | https://github.com/metratec/indoor_positioning.git |
| VCS Type | git |
| VCS Version | master |
| Last Updated | 2018-10-26 |
| Dev Status | MAINTAINED |
| CI status | Continuous Integration |
| Released | RELEASED |
| Tags | No category tags. |
| Contributing |
Help Wanted (0)
Good First Issues (0) Pull Requests to Review (0) |
Package Description
Additional Links
Maintainers
- Christian Arndt
Authors
- Christian Arndt
indoor_positioning
I. About
This is a ROS package for the metraTec Indoor Positioning System. You can use the regular IPS for zone location of your robot or the IPS+ products for 3D-position-estimation using UWB ranging.
The image shows an example of the indoor positioning functionality. Four RF beacons are placed in the environment that localize a corresponding receiver in the vicinity. The IPS displays the current (user-defined) zone that the receiver is in (green rectangle). Additionally, using the IPS+ position estimation, the actual 3D-position of the receiver is displayed (pink sphere).
II. Installation
From ROS binaries (preferred method):
Simply run the following command where you change
``` to whatever distribution you are using.
$ sudo apt-get install ros-ROSDISTRO-indoor-positioning
### From source:
If you can't use the binary release, for example when you are using an older version of ROS, you can still manually
build the package yourself.
First, clone the repository into the source folder of your catkin workspace:
$ git clone https://github.com/metratec/indoor_positioning.git YOUR_CATKIN_WS/src/indoor_positioning
Install python dependencies via:
$ pip install -r requirements.txt
Now you should be able to use the package like any other (catkin) package in your workspace.
## III. Usage
The
```receiver.py
``` node handles communication with the receiver and publishes incoming messages. Therefore you have to run this node
in order to use the IPS or IPS+ node. Then you can run either the
```positioning.py
``` node for IPS or the
```positioning_plus.py
``` node for IPS+ (or both, theoretically).
### Setup
To be able to use the nodes for zone location (IPS) or UWB positioning (IPS+) you have to setup your environment in a YAML configuration file.
Take a look at the
```config/zones_template.yml
``` example for information about the structure and content of this config file.
### Launch files
There are two launch files you can use right away to test this package with default parameters.
The
```ips.launch
``` file starts the receiver and the IPS node for zone location.
The
```ips_plus.launch
``` file starts the receiver and the IPS+ node for UWB position estimation.
For both you have to specify whether you use a TCP or USB receiver and how they are connected.
launching the IPS node using a metraTec USB receiver
$ roslaunch indoor_positioning ips.launch rec_name:=port rec_value:=/dev/ttyUSB0
launching the IPS+ node using a TCP receiver
$ roslaunch indoor_positioning ips_plus.launch rec_name:=host rec_value:=192.168.2.223
If you want to use non-default parameters for any of the nodes you have to set them in the ROS parameter server or
write your own launch files that set the respective parameters however you want.
Take a look at the two launch files mentioned above as an example.
_Note:_ by setting the
```do_vis
``` parameter of the launch files to
```True
``` you can simultaneously start rviz with
predefined settings to display the defined beacon positions, current zone and/or estimated receiver position.
### Nodes
#### receiver.py
Use this node to establish a connection with the metraTec IPS receiver or USB stick. You have to pass the USB port the
stick is connected to or the IP address of the regular receiver as a command line argument or as a private parameter
when you are using a launch file.
Running from command line:
$ rosrun indoor_positioning receiver.py TYPE REQUIRED OPTIONAL
For example:
$ rosrun indoor_positioning receiver.py usb /dev/ttyUSB0 $ rosrun indoor_positioning receiver.py tcp 192.168.2.223
```
Subscribed topics:
- ips/receiver/send (std_msgs/String):
Message to be sent over the TCP or serial connection to the IPS receiver or USB stick
Published topics:
- ips/receiver/raw (indoor_positioning/StringStamped):
Raw messages received from the receiver or USB stick
Parameters:
-
~type (string, default=’tcp’):
‘tcp’ for TCP receiver or ‘usb’ for metraTec USB stick -
~host (string, default=’192.168.2.223):
IP address of the connected receiver -
~port (with type=’tcp’: int, default=10001; with type=’usb’: string, default=’/dev/ttyUSB0):
Port for the TCP connection if ‘~type’ parameter is set to ‘tcp’, otherwise specifies the USB port of the stick -
~baudrate (int, default=115200):
Baudrate to use for serial communication with USB receiver
positioning.py (IPS)
Use this node to perform indoor zone location using the metraTec IPS tracking system. Prerequisites for using this node
File truncated at 100 lines see the full file
Changelog for package ros_ips
1.1.0 (2018-06-20) -----------* Trilatered positions are only published now if they are inside a polygon spanned by the beacons * Revamped launch files
1.0.3 (2018-06-20)
- Added some parametrization options to allow more efficient and robust position estimation
1.0.2 (2018-05-22)
- Renamed package from ros_ips to indoor_positioning
1.0.1 (2018-05-11)
- First public release for kinetic
Wiki Tutorials
Package Dependencies
| Deps | Name |
|---|---|
| roscpp | |
| rospy | |
| std_msgs | |
| message_generation | |
| catkin | |
| message_runtime |
System Dependencies
Dependant Packages
Launch files
- launch/ips.launch
-
- type [default: usb]
- host [default: 192.168.2.223]
- port [default: /dev/ttyUSB0]
- baudrate [default: 115200]
- config_file [default: config/zones.yml]
- rate [default: 1]
- bcn_len [default: -1]
- do_vis [default: False]
- launch/ips_plus.launch
-
- type [default: tcp]
- host [default: 192.168.2.223]
- port [default: 10001]
- baudrate [default: 115200]
- config_file [default: config/zones.yml]
- frame_id [default: map]
- rate [default: 0.1]
- bcn_len [default: -1]
- srg_len [default: -1]
- min_beacons [default: 3]
- max_beacons [default: 6]
- rssi_thresh [default: -127]
- max_z [default: 1]
- dilation [default: 0]
- do_vis [default: False]
Messages
Services
Plugins
Recent questions tagged indoor_positioning at Robotics Stack Exchange
|
|
indoor_positioning package from indoor_positioning repoindoor_positioning |
ROS Distro
|
Package Summary
| Tags | No category tags. |
| Version | 1.1.0 |
| License | BSD 2-Clause License |
| Build type | CATKIN |
| Use | RECOMMENDED |
Repository Summary
| Checkout URI | https://github.com/metratec/indoor_positioning.git |
| VCS Type | git |
| VCS Version | master |
| Last Updated | 2018-10-26 |
| Dev Status | MAINTAINED |
| CI status | Continuous Integration |
| Released | RELEASED |
| Tags | No category tags. |
| Contributing |
Help Wanted (0)
Good First Issues (0) Pull Requests to Review (0) |
Package Description
Additional Links
Maintainers
- Christian Arndt
Authors
- Christian Arndt
indoor_positioning
I. About
This is a ROS package for the metraTec Indoor Positioning System. You can use the regular IPS for zone location of your robot or the IPS+ products for 3D-position-estimation using UWB ranging.
The image shows an example of the indoor positioning functionality. Four RF beacons are placed in the environment that localize a corresponding receiver in the vicinity. The IPS displays the current (user-defined) zone that the receiver is in (green rectangle). Additionally, using the IPS+ position estimation, the actual 3D-position of the receiver is displayed (pink sphere).
II. Installation
From ROS binaries (preferred method):
Simply run the following command where you change
``` to whatever distribution you are using.
$ sudo apt-get install ros-ROSDISTRO-indoor-positioning
### From source:
If you can't use the binary release, for example when you are using an older version of ROS, you can still manually
build the package yourself.
First, clone the repository into the source folder of your catkin workspace:
$ git clone https://github.com/metratec/indoor_positioning.git YOUR_CATKIN_WS/src/indoor_positioning
Install python dependencies via:
$ pip install -r requirements.txt
Now you should be able to use the package like any other (catkin) package in your workspace.
## III. Usage
The
```receiver.py
``` node handles communication with the receiver and publishes incoming messages. Therefore you have to run this node
in order to use the IPS or IPS+ node. Then you can run either the
```positioning.py
``` node for IPS or the
```positioning_plus.py
``` node for IPS+ (or both, theoretically).
### Setup
To be able to use the nodes for zone location (IPS) or UWB positioning (IPS+) you have to setup your environment in a YAML configuration file.
Take a look at the
```config/zones_template.yml
``` example for information about the structure and content of this config file.
### Launch files
There are two launch files you can use right away to test this package with default parameters.
The
```ips.launch
``` file starts the receiver and the IPS node for zone location.
The
```ips_plus.launch
``` file starts the receiver and the IPS+ node for UWB position estimation.
For both you have to specify whether you use a TCP or USB receiver and how they are connected.
launching the IPS node using a metraTec USB receiver
$ roslaunch indoor_positioning ips.launch rec_name:=port rec_value:=/dev/ttyUSB0
launching the IPS+ node using a TCP receiver
$ roslaunch indoor_positioning ips_plus.launch rec_name:=host rec_value:=192.168.2.223
If you want to use non-default parameters for any of the nodes you have to set them in the ROS parameter server or
write your own launch files that set the respective parameters however you want.
Take a look at the two launch files mentioned above as an example.
_Note:_ by setting the
```do_vis
``` parameter of the launch files to
```True
``` you can simultaneously start rviz with
predefined settings to display the defined beacon positions, current zone and/or estimated receiver position.
### Nodes
#### receiver.py
Use this node to establish a connection with the metraTec IPS receiver or USB stick. You have to pass the USB port the
stick is connected to or the IP address of the regular receiver as a command line argument or as a private parameter
when you are using a launch file.
Running from command line:
$ rosrun indoor_positioning receiver.py TYPE REQUIRED OPTIONAL
For example:
$ rosrun indoor_positioning receiver.py usb /dev/ttyUSB0 $ rosrun indoor_positioning receiver.py tcp 192.168.2.223
```
Subscribed topics:
- ips/receiver/send (std_msgs/String):
Message to be sent over the TCP or serial connection to the IPS receiver or USB stick
Published topics:
- ips/receiver/raw (indoor_positioning/StringStamped):
Raw messages received from the receiver or USB stick
Parameters:
-
~type (string, default=’tcp’):
‘tcp’ for TCP receiver or ‘usb’ for metraTec USB stick -
~host (string, default=’192.168.2.223):
IP address of the connected receiver -
~port (with type=’tcp’: int, default=10001; with type=’usb’: string, default=’/dev/ttyUSB0):
Port for the TCP connection if ‘~type’ parameter is set to ‘tcp’, otherwise specifies the USB port of the stick -
~baudrate (int, default=115200):
Baudrate to use for serial communication with USB receiver
positioning.py (IPS)
Use this node to perform indoor zone location using the metraTec IPS tracking system. Prerequisites for using this node
File truncated at 100 lines see the full file
Changelog for package ros_ips
1.1.0 (2018-06-20) -----------* Trilatered positions are only published now if they are inside a polygon spanned by the beacons * Revamped launch files
1.0.3 (2018-06-20)
- Added some parametrization options to allow more efficient and robust position estimation
1.0.2 (2018-05-22)
- Renamed package from ros_ips to indoor_positioning
1.0.1 (2018-05-11)
- First public release for kinetic
Wiki Tutorials
Package Dependencies
| Deps | Name |
|---|---|
| roscpp | |
| rospy | |
| std_msgs | |
| message_generation | |
| catkin | |
| message_runtime |
System Dependencies
Dependant Packages
Launch files
- launch/ips.launch
-
- type [default: usb]
- host [default: 192.168.2.223]
- port [default: /dev/ttyUSB0]
- baudrate [default: 115200]
- config_file [default: config/zones.yml]
- rate [default: 1]
- bcn_len [default: -1]
- do_vis [default: False]
- launch/ips_plus.launch
-
- type [default: tcp]
- host [default: 192.168.2.223]
- port [default: 10001]
- baudrate [default: 115200]
- config_file [default: config/zones.yml]
- frame_id [default: map]
- rate [default: 0.1]
- bcn_len [default: -1]
- srg_len [default: -1]
- min_beacons [default: 3]
- max_beacons [default: 6]
- rssi_thresh [default: -127]
- max_z [default: 1]
- dilation [default: 0]
- do_vis [default: False]
Messages
Services
Plugins
Recent questions tagged indoor_positioning at Robotics Stack Exchange
|
|
indoor_positioning package from indoor_positioning repoindoor_positioning |
ROS Distro
|
Package Summary
| Tags | No category tags. |
| Version | 1.1.0 |
| License | BSD 2-Clause License |
| Build type | CATKIN |
| Use | RECOMMENDED |
Repository Summary
| Checkout URI | https://github.com/metratec/indoor_positioning.git |
| VCS Type | git |
| VCS Version | master |
| Last Updated | 2018-10-26 |
| Dev Status | MAINTAINED |
| CI status | Continuous Integration |
| Released | RELEASED |
| Tags | No category tags. |
| Contributing |
Help Wanted (0)
Good First Issues (0) Pull Requests to Review (0) |
Package Description
Additional Links
Maintainers
- Christian Arndt
Authors
- Christian Arndt
indoor_positioning
I. About
This is a ROS package for the metraTec Indoor Positioning System. You can use the regular IPS for zone location of your robot or the IPS+ products for 3D-position-estimation using UWB ranging.
The image shows an example of the indoor positioning functionality. Four RF beacons are placed in the environment that localize a corresponding receiver in the vicinity. The IPS displays the current (user-defined) zone that the receiver is in (green rectangle). Additionally, using the IPS+ position estimation, the actual 3D-position of the receiver is displayed (pink sphere).
II. Installation
From ROS binaries (preferred method):
Simply run the following command where you change
``` to whatever distribution you are using.
$ sudo apt-get install ros-ROSDISTRO-indoor-positioning
### From source:
If you can't use the binary release, for example when you are using an older version of ROS, you can still manually
build the package yourself.
First, clone the repository into the source folder of your catkin workspace:
$ git clone https://github.com/metratec/indoor_positioning.git YOUR_CATKIN_WS/src/indoor_positioning
Install python dependencies via:
$ pip install -r requirements.txt
Now you should be able to use the package like any other (catkin) package in your workspace.
## III. Usage
The
```receiver.py
``` node handles communication with the receiver and publishes incoming messages. Therefore you have to run this node
in order to use the IPS or IPS+ node. Then you can run either the
```positioning.py
``` node for IPS or the
```positioning_plus.py
``` node for IPS+ (or both, theoretically).
### Setup
To be able to use the nodes for zone location (IPS) or UWB positioning (IPS+) you have to setup your environment in a YAML configuration file.
Take a look at the
```config/zones_template.yml
``` example for information about the structure and content of this config file.
### Launch files
There are two launch files you can use right away to test this package with default parameters.
The
```ips.launch
``` file starts the receiver and the IPS node for zone location.
The
```ips_plus.launch
``` file starts the receiver and the IPS+ node for UWB position estimation.
For both you have to specify whether you use a TCP or USB receiver and how they are connected.
launching the IPS node using a metraTec USB receiver
$ roslaunch indoor_positioning ips.launch rec_name:=port rec_value:=/dev/ttyUSB0
launching the IPS+ node using a TCP receiver
$ roslaunch indoor_positioning ips_plus.launch rec_name:=host rec_value:=192.168.2.223
If you want to use non-default parameters for any of the nodes you have to set them in the ROS parameter server or
write your own launch files that set the respective parameters however you want.
Take a look at the two launch files mentioned above as an example.
_Note:_ by setting the
```do_vis
``` parameter of the launch files to
```True
``` you can simultaneously start rviz with
predefined settings to display the defined beacon positions, current zone and/or estimated receiver position.
### Nodes
#### receiver.py
Use this node to establish a connection with the metraTec IPS receiver or USB stick. You have to pass the USB port the
stick is connected to or the IP address of the regular receiver as a command line argument or as a private parameter
when you are using a launch file.
Running from command line:
$ rosrun indoor_positioning receiver.py TYPE REQUIRED OPTIONAL
For example:
$ rosrun indoor_positioning receiver.py usb /dev/ttyUSB0 $ rosrun indoor_positioning receiver.py tcp 192.168.2.223
```
Subscribed topics:
- ips/receiver/send (std_msgs/String):
Message to be sent over the TCP or serial connection to the IPS receiver or USB stick
Published topics:
- ips/receiver/raw (indoor_positioning/StringStamped):
Raw messages received from the receiver or USB stick
Parameters:
-
~type (string, default=’tcp’):
‘tcp’ for TCP receiver or ‘usb’ for metraTec USB stick -
~host (string, default=’192.168.2.223):
IP address of the connected receiver -
~port (with type=’tcp’: int, default=10001; with type=’usb’: string, default=’/dev/ttyUSB0):
Port for the TCP connection if ‘~type’ parameter is set to ‘tcp’, otherwise specifies the USB port of the stick -
~baudrate (int, default=115200):
Baudrate to use for serial communication with USB receiver
positioning.py (IPS)
Use this node to perform indoor zone location using the metraTec IPS tracking system. Prerequisites for using this node
File truncated at 100 lines see the full file
Changelog for package ros_ips
1.1.0 (2018-06-20) -----------* Trilatered positions are only published now if they are inside a polygon spanned by the beacons * Revamped launch files
1.0.3 (2018-06-20)
- Added some parametrization options to allow more efficient and robust position estimation
1.0.2 (2018-05-22)
- Renamed package from ros_ips to indoor_positioning
1.0.1 (2018-05-11)
- First public release for kinetic
Wiki Tutorials
Package Dependencies
| Deps | Name |
|---|---|
| roscpp | |
| rospy | |
| std_msgs | |
| message_generation | |
| catkin | |
| message_runtime |
System Dependencies
Dependant Packages
Launch files
- launch/ips.launch
-
- type [default: usb]
- host [default: 192.168.2.223]
- port [default: /dev/ttyUSB0]
- baudrate [default: 115200]
- config_file [default: config/zones.yml]
- rate [default: 1]
- bcn_len [default: -1]
- do_vis [default: False]
- launch/ips_plus.launch
-
- type [default: tcp]
- host [default: 192.168.2.223]
- port [default: 10001]
- baudrate [default: 115200]
- config_file [default: config/zones.yml]
- frame_id [default: map]
- rate [default: 0.1]
- bcn_len [default: -1]
- srg_len [default: -1]
- min_beacons [default: 3]
- max_beacons [default: 6]
- rssi_thresh [default: -127]
- max_z [default: 1]
- dilation [default: 0]
- do_vis [default: False]
Messages
Services
Plugins
Recent questions tagged indoor_positioning at Robotics Stack Exchange
|
|
indoor_positioning package from indoor_positioning repoindoor_positioning |
ROS Distro
|
Package Summary
| Tags | No category tags. |
| Version | 1.1.0 |
| License | BSD 2-Clause License |
| Build type | CATKIN |
| Use | RECOMMENDED |
Repository Summary
| Checkout URI | https://github.com/metratec/indoor_positioning.git |
| VCS Type | git |
| VCS Version | master |
| Last Updated | 2018-10-26 |
| Dev Status | MAINTAINED |
| CI status | Continuous Integration |
| Released | RELEASED |
| Tags | No category tags. |
| Contributing |
Help Wanted (0)
Good First Issues (0) Pull Requests to Review (0) |
Package Description
Additional Links
Maintainers
- Christian Arndt
Authors
- Christian Arndt
indoor_positioning
I. About
This is a ROS package for the metraTec Indoor Positioning System. You can use the regular IPS for zone location of your robot or the IPS+ products for 3D-position-estimation using UWB ranging.
The image shows an example of the indoor positioning functionality. Four RF beacons are placed in the environment that localize a corresponding receiver in the vicinity. The IPS displays the current (user-defined) zone that the receiver is in (green rectangle). Additionally, using the IPS+ position estimation, the actual 3D-position of the receiver is displayed (pink sphere).
II. Installation
From ROS binaries (preferred method):
Simply run the following command where you change
``` to whatever distribution you are using.
$ sudo apt-get install ros-ROSDISTRO-indoor-positioning
### From source:
If you can't use the binary release, for example when you are using an older version of ROS, you can still manually
build the package yourself.
First, clone the repository into the source folder of your catkin workspace:
$ git clone https://github.com/metratec/indoor_positioning.git YOUR_CATKIN_WS/src/indoor_positioning
Install python dependencies via:
$ pip install -r requirements.txt
Now you should be able to use the package like any other (catkin) package in your workspace.
## III. Usage
The
```receiver.py
``` node handles communication with the receiver and publishes incoming messages. Therefore you have to run this node
in order to use the IPS or IPS+ node. Then you can run either the
```positioning.py
``` node for IPS or the
```positioning_plus.py
``` node for IPS+ (or both, theoretically).
### Setup
To be able to use the nodes for zone location (IPS) or UWB positioning (IPS+) you have to setup your environment in a YAML configuration file.
Take a look at the
```config/zones_template.yml
``` example for information about the structure and content of this config file.
### Launch files
There are two launch files you can use right away to test this package with default parameters.
The
```ips.launch
``` file starts the receiver and the IPS node for zone location.
The
```ips_plus.launch
``` file starts the receiver and the IPS+ node for UWB position estimation.
For both you have to specify whether you use a TCP or USB receiver and how they are connected.
launching the IPS node using a metraTec USB receiver
$ roslaunch indoor_positioning ips.launch rec_name:=port rec_value:=/dev/ttyUSB0
launching the IPS+ node using a TCP receiver
$ roslaunch indoor_positioning ips_plus.launch rec_name:=host rec_value:=192.168.2.223
If you want to use non-default parameters for any of the nodes you have to set them in the ROS parameter server or
write your own launch files that set the respective parameters however you want.
Take a look at the two launch files mentioned above as an example.
_Note:_ by setting the
```do_vis
``` parameter of the launch files to
```True
``` you can simultaneously start rviz with
predefined settings to display the defined beacon positions, current zone and/or estimated receiver position.
### Nodes
#### receiver.py
Use this node to establish a connection with the metraTec IPS receiver or USB stick. You have to pass the USB port the
stick is connected to or the IP address of the regular receiver as a command line argument or as a private parameter
when you are using a launch file.
Running from command line:
$ rosrun indoor_positioning receiver.py TYPE REQUIRED OPTIONAL
For example:
$ rosrun indoor_positioning receiver.py usb /dev/ttyUSB0 $ rosrun indoor_positioning receiver.py tcp 192.168.2.223
```
Subscribed topics:
- ips/receiver/send (std_msgs/String):
Message to be sent over the TCP or serial connection to the IPS receiver or USB stick
Published topics:
- ips/receiver/raw (indoor_positioning/StringStamped):
Raw messages received from the receiver or USB stick
Parameters:
-
~type (string, default=’tcp’):
‘tcp’ for TCP receiver or ‘usb’ for metraTec USB stick -
~host (string, default=’192.168.2.223):
IP address of the connected receiver -
~port (with type=’tcp’: int, default=10001; with type=’usb’: string, default=’/dev/ttyUSB0):
Port for the TCP connection if ‘~type’ parameter is set to ‘tcp’, otherwise specifies the USB port of the stick -
~baudrate (int, default=115200):
Baudrate to use for serial communication with USB receiver
positioning.py (IPS)
Use this node to perform indoor zone location using the metraTec IPS tracking system. Prerequisites for using this node
File truncated at 100 lines see the full file
Changelog for package ros_ips
1.1.0 (2018-06-20) -----------* Trilatered positions are only published now if they are inside a polygon spanned by the beacons * Revamped launch files
1.0.3 (2018-06-20)
- Added some parametrization options to allow more efficient and robust position estimation
1.0.2 (2018-05-22)
- Renamed package from ros_ips to indoor_positioning
1.0.1 (2018-05-11)
- First public release for kinetic
Wiki Tutorials
Package Dependencies
| Deps | Name |
|---|---|
| roscpp | |
| rospy | |
| std_msgs | |
| message_generation | |
| catkin | |
| message_runtime |
System Dependencies
Dependant Packages
Launch files
- launch/ips.launch
-
- type [default: usb]
- host [default: 192.168.2.223]
- port [default: /dev/ttyUSB0]
- baudrate [default: 115200]
- config_file [default: config/zones.yml]
- rate [default: 1]
- bcn_len [default: -1]
- do_vis [default: False]
- launch/ips_plus.launch
-
- type [default: tcp]
- host [default: 192.168.2.223]
- port [default: 10001]
- baudrate [default: 115200]
- config_file [default: config/zones.yml]
- frame_id [default: map]
- rate [default: 0.1]
- bcn_len [default: -1]
- srg_len [default: -1]
- min_beacons [default: 3]
- max_beacons [default: 6]
- rssi_thresh [default: -127]
- max_z [default: 1]
- dilation [default: 0]
- do_vis [default: False]
Messages
Services
Plugins
Recent questions tagged indoor_positioning at Robotics Stack Exchange
|
|
indoor_positioning package from indoor_positioning repoindoor_positioning |
ROS Distro
|
Package Summary
| Tags | No category tags. |
| Version | 1.1.0 |
| License | BSD 2-Clause License |
| Build type | CATKIN |
| Use | RECOMMENDED |
Repository Summary
| Checkout URI | https://github.com/metratec/indoor_positioning.git |
| VCS Type | git |
| VCS Version | master |
| Last Updated | 2018-10-26 |
| Dev Status | MAINTAINED |
| CI status | Continuous Integration |
| Released | RELEASED |
| Tags | No category tags. |
| Contributing |
Help Wanted (0)
Good First Issues (0) Pull Requests to Review (0) |
Package Description
Additional Links
Maintainers
- Christian Arndt
Authors
- Christian Arndt
indoor_positioning
I. About
This is a ROS package for the metraTec Indoor Positioning System. You can use the regular IPS for zone location of your robot or the IPS+ products for 3D-position-estimation using UWB ranging.
The image shows an example of the indoor positioning functionality. Four RF beacons are placed in the environment that localize a corresponding receiver in the vicinity. The IPS displays the current (user-defined) zone that the receiver is in (green rectangle). Additionally, using the IPS+ position estimation, the actual 3D-position of the receiver is displayed (pink sphere).
II. Installation
From ROS binaries (preferred method):
Simply run the following command where you change
``` to whatever distribution you are using.
$ sudo apt-get install ros-ROSDISTRO-indoor-positioning
### From source:
If you can't use the binary release, for example when you are using an older version of ROS, you can still manually
build the package yourself.
First, clone the repository into the source folder of your catkin workspace:
$ git clone https://github.com/metratec/indoor_positioning.git YOUR_CATKIN_WS/src/indoor_positioning
Install python dependencies via:
$ pip install -r requirements.txt
Now you should be able to use the package like any other (catkin) package in your workspace.
## III. Usage
The
```receiver.py
``` node handles communication with the receiver and publishes incoming messages. Therefore you have to run this node
in order to use the IPS or IPS+ node. Then you can run either the
```positioning.py
``` node for IPS or the
```positioning_plus.py
``` node for IPS+ (or both, theoretically).
### Setup
To be able to use the nodes for zone location (IPS) or UWB positioning (IPS+) you have to setup your environment in a YAML configuration file.
Take a look at the
```config/zones_template.yml
``` example for information about the structure and content of this config file.
### Launch files
There are two launch files you can use right away to test this package with default parameters.
The
```ips.launch
``` file starts the receiver and the IPS node for zone location.
The
```ips_plus.launch
``` file starts the receiver and the IPS+ node for UWB position estimation.
For both you have to specify whether you use a TCP or USB receiver and how they are connected.
launching the IPS node using a metraTec USB receiver
$ roslaunch indoor_positioning ips.launch rec_name:=port rec_value:=/dev/ttyUSB0
launching the IPS+ node using a TCP receiver
$ roslaunch indoor_positioning ips_plus.launch rec_name:=host rec_value:=192.168.2.223
If you want to use non-default parameters for any of the nodes you have to set them in the ROS parameter server or
write your own launch files that set the respective parameters however you want.
Take a look at the two launch files mentioned above as an example.
_Note:_ by setting the
```do_vis
``` parameter of the launch files to
```True
``` you can simultaneously start rviz with
predefined settings to display the defined beacon positions, current zone and/or estimated receiver position.
### Nodes
#### receiver.py
Use this node to establish a connection with the metraTec IPS receiver or USB stick. You have to pass the USB port the
stick is connected to or the IP address of the regular receiver as a command line argument or as a private parameter
when you are using a launch file.
Running from command line:
$ rosrun indoor_positioning receiver.py TYPE REQUIRED OPTIONAL
For example:
$ rosrun indoor_positioning receiver.py usb /dev/ttyUSB0 $ rosrun indoor_positioning receiver.py tcp 192.168.2.223
```
Subscribed topics:
- ips/receiver/send (std_msgs/String):
Message to be sent over the TCP or serial connection to the IPS receiver or USB stick
Published topics:
- ips/receiver/raw (indoor_positioning/StringStamped):
Raw messages received from the receiver or USB stick
Parameters:
-
~type (string, default=’tcp’):
‘tcp’ for TCP receiver or ‘usb’ for metraTec USB stick -
~host (string, default=’192.168.2.223):
IP address of the connected receiver -
~port (with type=’tcp’: int, default=10001; with type=’usb’: string, default=’/dev/ttyUSB0):
Port for the TCP connection if ‘~type’ parameter is set to ‘tcp’, otherwise specifies the USB port of the stick -
~baudrate (int, default=115200):
Baudrate to use for serial communication with USB receiver
positioning.py (IPS)
Use this node to perform indoor zone location using the metraTec IPS tracking system. Prerequisites for using this node
File truncated at 100 lines see the full file
Changelog for package ros_ips
1.1.0 (2018-06-20) -----------* Trilatered positions are only published now if they are inside a polygon spanned by the beacons * Revamped launch files
1.0.3 (2018-06-20)
- Added some parametrization options to allow more efficient and robust position estimation
1.0.2 (2018-05-22)
- Renamed package from ros_ips to indoor_positioning
1.0.1 (2018-05-11)
- First public release for kinetic
Wiki Tutorials
Package Dependencies
| Deps | Name |
|---|---|
| roscpp | |
| rospy | |
| std_msgs | |
| message_generation | |
| catkin | |
| message_runtime |
System Dependencies
Dependant Packages
Launch files
- launch/ips.launch
-
- type [default: usb]
- host [default: 192.168.2.223]
- port [default: /dev/ttyUSB0]
- baudrate [default: 115200]
- config_file [default: config/zones.yml]
- rate [default: 1]
- bcn_len [default: -1]
- do_vis [default: False]
- launch/ips_plus.launch
-
- type [default: tcp]
- host [default: 192.168.2.223]
- port [default: 10001]
- baudrate [default: 115200]
- config_file [default: config/zones.yml]
- frame_id [default: map]
- rate [default: 0.1]
- bcn_len [default: -1]
- srg_len [default: -1]
- min_beacons [default: 3]
- max_beacons [default: 6]
- rssi_thresh [default: -127]
- max_z [default: 1]
- dilation [default: 0]
- do_vis [default: False]
Messages
Services
Plugins
Recent questions tagged indoor_positioning at Robotics Stack Exchange
|
|
indoor_positioning package from indoor_positioning repoindoor_positioning |
ROS Distro
|
Package Summary
| Tags | No category tags. |
| Version | 1.1.0 |
| License | BSD 2-Clause License |
| Build type | CATKIN |
| Use | RECOMMENDED |
Repository Summary
| Checkout URI | https://github.com/metratec/indoor_positioning.git |
| VCS Type | git |
| VCS Version | master |
| Last Updated | 2018-10-26 |
| Dev Status | MAINTAINED |
| CI status | Continuous Integration |
| Released | RELEASED |
| Tags | No category tags. |
| Contributing |
Help Wanted (0)
Good First Issues (0) Pull Requests to Review (0) |
Package Description
Additional Links
Maintainers
- Christian Arndt
Authors
- Christian Arndt
indoor_positioning
I. About
This is a ROS package for the metraTec Indoor Positioning System. You can use the regular IPS for zone location of your robot or the IPS+ products for 3D-position-estimation using UWB ranging.
The image shows an example of the indoor positioning functionality. Four RF beacons are placed in the environment that localize a corresponding receiver in the vicinity. The IPS displays the current (user-defined) zone that the receiver is in (green rectangle). Additionally, using the IPS+ position estimation, the actual 3D-position of the receiver is displayed (pink sphere).
II. Installation
From ROS binaries (preferred method):
Simply run the following command where you change
``` to whatever distribution you are using.
$ sudo apt-get install ros-ROSDISTRO-indoor-positioning
### From source:
If you can't use the binary release, for example when you are using an older version of ROS, you can still manually
build the package yourself.
First, clone the repository into the source folder of your catkin workspace:
$ git clone https://github.com/metratec/indoor_positioning.git YOUR_CATKIN_WS/src/indoor_positioning
Install python dependencies via:
$ pip install -r requirements.txt
Now you should be able to use the package like any other (catkin) package in your workspace.
## III. Usage
The
```receiver.py
``` node handles communication with the receiver and publishes incoming messages. Therefore you have to run this node
in order to use the IPS or IPS+ node. Then you can run either the
```positioning.py
``` node for IPS or the
```positioning_plus.py
``` node for IPS+ (or both, theoretically).
### Setup
To be able to use the nodes for zone location (IPS) or UWB positioning (IPS+) you have to setup your environment in a YAML configuration file.
Take a look at the
```config/zones_template.yml
``` example for information about the structure and content of this config file.
### Launch files
There are two launch files you can use right away to test this package with default parameters.
The
```ips.launch
``` file starts the receiver and the IPS node for zone location.
The
```ips_plus.launch
``` file starts the receiver and the IPS+ node for UWB position estimation.
For both you have to specify whether you use a TCP or USB receiver and how they are connected.
launching the IPS node using a metraTec USB receiver
$ roslaunch indoor_positioning ips.launch rec_name:=port rec_value:=/dev/ttyUSB0
launching the IPS+ node using a TCP receiver
$ roslaunch indoor_positioning ips_plus.launch rec_name:=host rec_value:=192.168.2.223
If you want to use non-default parameters for any of the nodes you have to set them in the ROS parameter server or
write your own launch files that set the respective parameters however you want.
Take a look at the two launch files mentioned above as an example.
_Note:_ by setting the
```do_vis
``` parameter of the launch files to
```True
``` you can simultaneously start rviz with
predefined settings to display the defined beacon positions, current zone and/or estimated receiver position.
### Nodes
#### receiver.py
Use this node to establish a connection with the metraTec IPS receiver or USB stick. You have to pass the USB port the
stick is connected to or the IP address of the regular receiver as a command line argument or as a private parameter
when you are using a launch file.
Running from command line:
$ rosrun indoor_positioning receiver.py TYPE REQUIRED OPTIONAL
For example:
$ rosrun indoor_positioning receiver.py usb /dev/ttyUSB0 $ rosrun indoor_positioning receiver.py tcp 192.168.2.223
```
Subscribed topics:
- ips/receiver/send (std_msgs/String):
Message to be sent over the TCP or serial connection to the IPS receiver or USB stick
Published topics:
- ips/receiver/raw (indoor_positioning/StringStamped):
Raw messages received from the receiver or USB stick
Parameters:
-
~type (string, default=’tcp’):
‘tcp’ for TCP receiver or ‘usb’ for metraTec USB stick -
~host (string, default=’192.168.2.223):
IP address of the connected receiver -
~port (with type=’tcp’: int, default=10001; with type=’usb’: string, default=’/dev/ttyUSB0):
Port for the TCP connection if ‘~type’ parameter is set to ‘tcp’, otherwise specifies the USB port of the stick -
~baudrate (int, default=115200):
Baudrate to use for serial communication with USB receiver
positioning.py (IPS)
Use this node to perform indoor zone location using the metraTec IPS tracking system. Prerequisites for using this node
File truncated at 100 lines see the full file
Changelog for package ros_ips
1.1.0 (2018-06-20) -----------* Trilatered positions are only published now if they are inside a polygon spanned by the beacons * Revamped launch files
1.0.3 (2018-06-20)
- Added some parametrization options to allow more efficient and robust position estimation
1.0.2 (2018-05-22)
- Renamed package from ros_ips to indoor_positioning
1.0.1 (2018-05-11)
- First public release for kinetic
Wiki Tutorials
Package Dependencies
| Deps | Name |
|---|---|
| roscpp | |
| rospy | |
| std_msgs | |
| message_generation | |
| catkin | |
| message_runtime |
System Dependencies
Dependant Packages
Launch files
- launch/ips.launch
-
- type [default: usb]
- host [default: 192.168.2.223]
- port [default: /dev/ttyUSB0]
- baudrate [default: 115200]
- config_file [default: config/zones.yml]
- rate [default: 1]
- bcn_len [default: -1]
- do_vis [default: False]
- launch/ips_plus.launch
-
- type [default: tcp]
- host [default: 192.168.2.223]
- port [default: 10001]
- baudrate [default: 115200]
- config_file [default: config/zones.yml]
- frame_id [default: map]
- rate [default: 0.1]
- bcn_len [default: -1]
- srg_len [default: -1]
- min_beacons [default: 3]
- max_beacons [default: 6]
- rssi_thresh [default: -127]
- max_z [default: 1]
- dilation [default: 0]
- do_vis [default: False]
Messages
Services
Plugins
Recent questions tagged indoor_positioning at Robotics Stack Exchange
|
|
indoor_positioning package from indoor_positioning repoindoor_positioning |
ROS Distro
|
Package Summary
| Tags | No category tags. |
| Version | 1.1.0 |
| License | BSD 2-Clause License |
| Build type | CATKIN |
| Use | RECOMMENDED |
Repository Summary
| Checkout URI | https://github.com/metratec/indoor_positioning.git |
| VCS Type | git |
| VCS Version | master |
| Last Updated | 2018-10-26 |
| Dev Status | MAINTAINED |
| CI status | Continuous Integration |
| Released | RELEASED |
| Tags | No category tags. |
| Contributing |
Help Wanted (0)
Good First Issues (0) Pull Requests to Review (0) |
Package Description
Additional Links
Maintainers
- Christian Arndt
Authors
- Christian Arndt
indoor_positioning
I. About
This is a ROS package for the metraTec Indoor Positioning System. You can use the regular IPS for zone location of your robot or the IPS+ products for 3D-position-estimation using UWB ranging.
The image shows an example of the indoor positioning functionality. Four RF beacons are placed in the environment that localize a corresponding receiver in the vicinity. The IPS displays the current (user-defined) zone that the receiver is in (green rectangle). Additionally, using the IPS+ position estimation, the actual 3D-position of the receiver is displayed (pink sphere).
II. Installation
From ROS binaries (preferred method):
Simply run the following command where you change
``` to whatever distribution you are using.
$ sudo apt-get install ros-ROSDISTRO-indoor-positioning
### From source:
If you can't use the binary release, for example when you are using an older version of ROS, you can still manually
build the package yourself.
First, clone the repository into the source folder of your catkin workspace:
$ git clone https://github.com/metratec/indoor_positioning.git YOUR_CATKIN_WS/src/indoor_positioning
Install python dependencies via:
$ pip install -r requirements.txt
Now you should be able to use the package like any other (catkin) package in your workspace.
## III. Usage
The
```receiver.py
``` node handles communication with the receiver and publishes incoming messages. Therefore you have to run this node
in order to use the IPS or IPS+ node. Then you can run either the
```positioning.py
``` node for IPS or the
```positioning_plus.py
``` node for IPS+ (or both, theoretically).
### Setup
To be able to use the nodes for zone location (IPS) or UWB positioning (IPS+) you have to setup your environment in a YAML configuration file.
Take a look at the
```config/zones_template.yml
``` example for information about the structure and content of this config file.
### Launch files
There are two launch files you can use right away to test this package with default parameters.
The
```ips.launch
``` file starts the receiver and the IPS node for zone location.
The
```ips_plus.launch
``` file starts the receiver and the IPS+ node for UWB position estimation.
For both you have to specify whether you use a TCP or USB receiver and how they are connected.
launching the IPS node using a metraTec USB receiver
$ roslaunch indoor_positioning ips.launch rec_name:=port rec_value:=/dev/ttyUSB0
launching the IPS+ node using a TCP receiver
$ roslaunch indoor_positioning ips_plus.launch rec_name:=host rec_value:=192.168.2.223
If you want to use non-default parameters for any of the nodes you have to set them in the ROS parameter server or
write your own launch files that set the respective parameters however you want.
Take a look at the two launch files mentioned above as an example.
_Note:_ by setting the
```do_vis
``` parameter of the launch files to
```True
``` you can simultaneously start rviz with
predefined settings to display the defined beacon positions, current zone and/or estimated receiver position.
### Nodes
#### receiver.py
Use this node to establish a connection with the metraTec IPS receiver or USB stick. You have to pass the USB port the
stick is connected to or the IP address of the regular receiver as a command line argument or as a private parameter
when you are using a launch file.
Running from command line:
$ rosrun indoor_positioning receiver.py TYPE REQUIRED OPTIONAL
For example:
$ rosrun indoor_positioning receiver.py usb /dev/ttyUSB0 $ rosrun indoor_positioning receiver.py tcp 192.168.2.223
```
Subscribed topics:
- ips/receiver/send (std_msgs/String):
Message to be sent over the TCP or serial connection to the IPS receiver or USB stick
Published topics:
- ips/receiver/raw (indoor_positioning/StringStamped):
Raw messages received from the receiver or USB stick
Parameters:
-
~type (string, default=’tcp’):
‘tcp’ for TCP receiver or ‘usb’ for metraTec USB stick -
~host (string, default=’192.168.2.223):
IP address of the connected receiver -
~port (with type=’tcp’: int, default=10001; with type=’usb’: string, default=’/dev/ttyUSB0):
Port for the TCP connection if ‘~type’ parameter is set to ‘tcp’, otherwise specifies the USB port of the stick -
~baudrate (int, default=115200):
Baudrate to use for serial communication with USB receiver
positioning.py (IPS)
Use this node to perform indoor zone location using the metraTec IPS tracking system. Prerequisites for using this node
File truncated at 100 lines see the full file
Changelog for package ros_ips
1.1.0 (2018-06-20) -----------* Trilatered positions are only published now if they are inside a polygon spanned by the beacons * Revamped launch files
1.0.3 (2018-06-20)
- Added some parametrization options to allow more efficient and robust position estimation
1.0.2 (2018-05-22)
- Renamed package from ros_ips to indoor_positioning
1.0.1 (2018-05-11)
- First public release for kinetic
Wiki Tutorials
Package Dependencies
| Deps | Name |
|---|---|
| roscpp | |
| rospy | |
| std_msgs | |
| message_generation | |
| catkin | |
| message_runtime |
System Dependencies
Dependant Packages
Launch files
- launch/ips.launch
-
- type [default: usb]
- host [default: 192.168.2.223]
- port [default: /dev/ttyUSB0]
- baudrate [default: 115200]
- config_file [default: config/zones.yml]
- rate [default: 1]
- bcn_len [default: -1]
- do_vis [default: False]
- launch/ips_plus.launch
-
- type [default: tcp]
- host [default: 192.168.2.223]
- port [default: 10001]
- baudrate [default: 115200]
- config_file [default: config/zones.yml]
- frame_id [default: map]
- rate [default: 0.1]
- bcn_len [default: -1]
- srg_len [default: -1]
- min_beacons [default: 3]
- max_beacons [default: 6]
- rssi_thresh [default: -127]
- max_z [default: 1]
- dilation [default: 0]
- do_vis [default: False]
Messages
Services
Plugins
Recent questions tagged indoor_positioning at Robotics Stack Exchange
|
|
indoor_positioning package from indoor_positioning repoindoor_positioning |
ROS Distro
|
Package Summary
| Tags | No category tags. |
| Version | 1.1.0 |
| License | BSD 2-Clause License |
| Build type | CATKIN |
| Use | RECOMMENDED |
Repository Summary
| Checkout URI | https://github.com/metratec/indoor_positioning.git |
| VCS Type | git |
| VCS Version | master |
| Last Updated | 2018-10-26 |
| Dev Status | MAINTAINED |
| CI status | Continuous Integration |
| Released | RELEASED |
| Tags | No category tags. |
| Contributing |
Help Wanted (0)
Good First Issues (0) Pull Requests to Review (0) |
Package Description
Additional Links
Maintainers
- Christian Arndt
Authors
- Christian Arndt
indoor_positioning
I. About
This is a ROS package for the metraTec Indoor Positioning System. You can use the regular IPS for zone location of your robot or the IPS+ products for 3D-position-estimation using UWB ranging.
The image shows an example of the indoor positioning functionality. Four RF beacons are placed in the environment that localize a corresponding receiver in the vicinity. The IPS displays the current (user-defined) zone that the receiver is in (green rectangle). Additionally, using the IPS+ position estimation, the actual 3D-position of the receiver is displayed (pink sphere).
II. Installation
From ROS binaries (preferred method):
Simply run the following command where you change
``` to whatever distribution you are using.
$ sudo apt-get install ros-ROSDISTRO-indoor-positioning
### From source:
If you can't use the binary release, for example when you are using an older version of ROS, you can still manually
build the package yourself.
First, clone the repository into the source folder of your catkin workspace:
$ git clone https://github.com/metratec/indoor_positioning.git YOUR_CATKIN_WS/src/indoor_positioning
Install python dependencies via:
$ pip install -r requirements.txt
Now you should be able to use the package like any other (catkin) package in your workspace.
## III. Usage
The
```receiver.py
``` node handles communication with the receiver and publishes incoming messages. Therefore you have to run this node
in order to use the IPS or IPS+ node. Then you can run either the
```positioning.py
``` node for IPS or the
```positioning_plus.py
``` node for IPS+ (or both, theoretically).
### Setup
To be able to use the nodes for zone location (IPS) or UWB positioning (IPS+) you have to setup your environment in a YAML configuration file.
Take a look at the
```config/zones_template.yml
``` example for information about the structure and content of this config file.
### Launch files
There are two launch files you can use right away to test this package with default parameters.
The
```ips.launch
``` file starts the receiver and the IPS node for zone location.
The
```ips_plus.launch
``` file starts the receiver and the IPS+ node for UWB position estimation.
For both you have to specify whether you use a TCP or USB receiver and how they are connected.
launching the IPS node using a metraTec USB receiver
$ roslaunch indoor_positioning ips.launch rec_name:=port rec_value:=/dev/ttyUSB0
launching the IPS+ node using a TCP receiver
$ roslaunch indoor_positioning ips_plus.launch rec_name:=host rec_value:=192.168.2.223
If you want to use non-default parameters for any of the nodes you have to set them in the ROS parameter server or
write your own launch files that set the respective parameters however you want.
Take a look at the two launch files mentioned above as an example.
_Note:_ by setting the
```do_vis
``` parameter of the launch files to
```True
``` you can simultaneously start rviz with
predefined settings to display the defined beacon positions, current zone and/or estimated receiver position.
### Nodes
#### receiver.py
Use this node to establish a connection with the metraTec IPS receiver or USB stick. You have to pass the USB port the
stick is connected to or the IP address of the regular receiver as a command line argument or as a private parameter
when you are using a launch file.
Running from command line:
$ rosrun indoor_positioning receiver.py TYPE REQUIRED OPTIONAL
For example:
$ rosrun indoor_positioning receiver.py usb /dev/ttyUSB0 $ rosrun indoor_positioning receiver.py tcp 192.168.2.223
```
Subscribed topics:
- ips/receiver/send (std_msgs/String):
Message to be sent over the TCP or serial connection to the IPS receiver or USB stick
Published topics:
- ips/receiver/raw (indoor_positioning/StringStamped):
Raw messages received from the receiver or USB stick
Parameters:
-
~type (string, default=’tcp’):
‘tcp’ for TCP receiver or ‘usb’ for metraTec USB stick -
~host (string, default=’192.168.2.223):
IP address of the connected receiver -
~port (with type=’tcp’: int, default=10001; with type=’usb’: string, default=’/dev/ttyUSB0):
Port for the TCP connection if ‘~type’ parameter is set to ‘tcp’, otherwise specifies the USB port of the stick -
~baudrate (int, default=115200):
Baudrate to use for serial communication with USB receiver
positioning.py (IPS)
Use this node to perform indoor zone location using the metraTec IPS tracking system. Prerequisites for using this node
File truncated at 100 lines see the full file
Changelog for package ros_ips
1.1.0 (2018-06-20) -----------* Trilatered positions are only published now if they are inside a polygon spanned by the beacons * Revamped launch files
1.0.3 (2018-06-20)
- Added some parametrization options to allow more efficient and robust position estimation
1.0.2 (2018-05-22)
- Renamed package from ros_ips to indoor_positioning
1.0.1 (2018-05-11)
- First public release for kinetic
Wiki Tutorials
Package Dependencies
| Deps | Name |
|---|---|
| roscpp | |
| rospy | |
| std_msgs | |
| message_generation | |
| catkin | |
| message_runtime |
System Dependencies
Dependant Packages
Launch files
- launch/ips.launch
-
- type [default: usb]
- host [default: 192.168.2.223]
- port [default: /dev/ttyUSB0]
- baudrate [default: 115200]
- config_file [default: config/zones.yml]
- rate [default: 1]
- bcn_len [default: -1]
- do_vis [default: False]
- launch/ips_plus.launch
-
- type [default: tcp]
- host [default: 192.168.2.223]
- port [default: 10001]
- baudrate [default: 115200]
- config_file [default: config/zones.yml]
- frame_id [default: map]
- rate [default: 0.1]
- bcn_len [default: -1]
- srg_len [default: -1]
- min_beacons [default: 3]
- max_beacons [default: 6]
- rssi_thresh [default: -127]
- max_z [default: 1]
- dilation [default: 0]
- do_vis [default: False]
Messages
Services
Plugins
Recent questions tagged indoor_positioning at Robotics Stack Exchange
|
|
indoor_positioning package from indoor_positioning repoindoor_positioning |
ROS Distro
|
Package Summary
| Tags | No category tags. |
| Version | 1.1.0 |
| License | BSD 2-Clause License |
| Build type | CATKIN |
| Use | RECOMMENDED |
Repository Summary
| Checkout URI | https://github.com/metratec/indoor_positioning.git |
| VCS Type | git |
| VCS Version | master |
| Last Updated | 2018-10-26 |
| Dev Status | MAINTAINED |
| CI status | Continuous Integration |
| Released | RELEASED |
| Tags | No category tags. |
| Contributing |
Help Wanted (0)
Good First Issues (0) Pull Requests to Review (0) |
Package Description
Additional Links
Maintainers
- Christian Arndt
Authors
- Christian Arndt
indoor_positioning
I. About
This is a ROS package for the metraTec Indoor Positioning System. You can use the regular IPS for zone location of your robot or the IPS+ products for 3D-position-estimation using UWB ranging.
The image shows an example of the indoor positioning functionality. Four RF beacons are placed in the environment that localize a corresponding receiver in the vicinity. The IPS displays the current (user-defined) zone that the receiver is in (green rectangle). Additionally, using the IPS+ position estimation, the actual 3D-position of the receiver is displayed (pink sphere).
II. Installation
From ROS binaries (preferred method):
Simply run the following command where you change
``` to whatever distribution you are using.
$ sudo apt-get install ros-ROSDISTRO-indoor-positioning
### From source:
If you can't use the binary release, for example when you are using an older version of ROS, you can still manually
build the package yourself.
First, clone the repository into the source folder of your catkin workspace:
$ git clone https://github.com/metratec/indoor_positioning.git YOUR_CATKIN_WS/src/indoor_positioning
Install python dependencies via:
$ pip install -r requirements.txt
Now you should be able to use the package like any other (catkin) package in your workspace.
## III. Usage
The
```receiver.py
``` node handles communication with the receiver and publishes incoming messages. Therefore you have to run this node
in order to use the IPS or IPS+ node. Then you can run either the
```positioning.py
``` node for IPS or the
```positioning_plus.py
``` node for IPS+ (or both, theoretically).
### Setup
To be able to use the nodes for zone location (IPS) or UWB positioning (IPS+) you have to setup your environment in a YAML configuration file.
Take a look at the
```config/zones_template.yml
``` example for information about the structure and content of this config file.
### Launch files
There are two launch files you can use right away to test this package with default parameters.
The
```ips.launch
``` file starts the receiver and the IPS node for zone location.
The
```ips_plus.launch
``` file starts the receiver and the IPS+ node for UWB position estimation.
For both you have to specify whether you use a TCP or USB receiver and how they are connected.
launching the IPS node using a metraTec USB receiver
$ roslaunch indoor_positioning ips.launch rec_name:=port rec_value:=/dev/ttyUSB0
launching the IPS+ node using a TCP receiver
$ roslaunch indoor_positioning ips_plus.launch rec_name:=host rec_value:=192.168.2.223
If you want to use non-default parameters for any of the nodes you have to set them in the ROS parameter server or
write your own launch files that set the respective parameters however you want.
Take a look at the two launch files mentioned above as an example.
_Note:_ by setting the
```do_vis
``` parameter of the launch files to
```True
``` you can simultaneously start rviz with
predefined settings to display the defined beacon positions, current zone and/or estimated receiver position.
### Nodes
#### receiver.py
Use this node to establish a connection with the metraTec IPS receiver or USB stick. You have to pass the USB port the
stick is connected to or the IP address of the regular receiver as a command line argument or as a private parameter
when you are using a launch file.
Running from command line:
$ rosrun indoor_positioning receiver.py TYPE REQUIRED OPTIONAL
For example:
$ rosrun indoor_positioning receiver.py usb /dev/ttyUSB0 $ rosrun indoor_positioning receiver.py tcp 192.168.2.223
```
Subscribed topics:
- ips/receiver/send (std_msgs/String):
Message to be sent over the TCP or serial connection to the IPS receiver or USB stick
Published topics:
- ips/receiver/raw (indoor_positioning/StringStamped):
Raw messages received from the receiver or USB stick
Parameters:
-
~type (string, default=’tcp’):
‘tcp’ for TCP receiver or ‘usb’ for metraTec USB stick -
~host (string, default=’192.168.2.223):
IP address of the connected receiver -
~port (with type=’tcp’: int, default=10001; with type=’usb’: string, default=’/dev/ttyUSB0):
Port for the TCP connection if ‘~type’ parameter is set to ‘tcp’, otherwise specifies the USB port of the stick -
~baudrate (int, default=115200):
Baudrate to use for serial communication with USB receiver
positioning.py (IPS)
Use this node to perform indoor zone location using the metraTec IPS tracking system. Prerequisites for using this node
File truncated at 100 lines see the full file
Changelog for package ros_ips
1.1.0 (2018-06-20) -----------* Trilatered positions are only published now if they are inside a polygon spanned by the beacons * Revamped launch files
1.0.3 (2018-06-20)
- Added some parametrization options to allow more efficient and robust position estimation
1.0.2 (2018-05-22)
- Renamed package from ros_ips to indoor_positioning
1.0.1 (2018-05-11)
- First public release for kinetic
Wiki Tutorials
Package Dependencies
| Deps | Name |
|---|---|
| roscpp | |
| rospy | |
| std_msgs | |
| message_generation | |
| catkin | |
| message_runtime |
System Dependencies
Dependant Packages
Launch files
- launch/ips.launch
-
- type [default: usb]
- host [default: 192.168.2.223]
- port [default: /dev/ttyUSB0]
- baudrate [default: 115200]
- config_file [default: config/zones.yml]
- rate [default: 1]
- bcn_len [default: -1]
- do_vis [default: False]
- launch/ips_plus.launch
-
- type [default: tcp]
- host [default: 192.168.2.223]
- port [default: 10001]
- baudrate [default: 115200]
- config_file [default: config/zones.yml]
- frame_id [default: map]
- rate [default: 0.1]
- bcn_len [default: -1]
- srg_len [default: -1]
- min_beacons [default: 3]
- max_beacons [default: 6]
- rssi_thresh [default: -127]
- max_z [default: 1]
- dilation [default: 0]
- do_vis [default: False]
Messages
Services
Plugins
Recent questions tagged indoor_positioning at Robotics Stack Exchange
|
|
indoor_positioning package from indoor_positioning repoindoor_positioning |
ROS Distro
|
Package Summary
| Tags | No category tags. |
| Version | 1.1.0 |
| License | BSD 2-Clause License |
| Build type | CATKIN |
| Use | RECOMMENDED |
Repository Summary
| Checkout URI | https://github.com/metratec/indoor_positioning.git |
| VCS Type | git |
| VCS Version | master |
| Last Updated | 2018-10-26 |
| Dev Status | MAINTAINED |
| CI status | Continuous Integration |
| Released | RELEASED |
| Tags | No category tags. |
| Contributing |
Help Wanted (0)
Good First Issues (0) Pull Requests to Review (0) |
Package Description
Additional Links
Maintainers
- Christian Arndt
Authors
- Christian Arndt
indoor_positioning
I. About
This is a ROS package for the metraTec Indoor Positioning System. You can use the regular IPS for zone location of your robot or the IPS+ products for 3D-position-estimation using UWB ranging.
The image shows an example of the indoor positioning functionality. Four RF beacons are placed in the environment that localize a corresponding receiver in the vicinity. The IPS displays the current (user-defined) zone that the receiver is in (green rectangle). Additionally, using the IPS+ position estimation, the actual 3D-position of the receiver is displayed (pink sphere).
II. Installation
From ROS binaries (preferred method):
Simply run the following command where you change
``` to whatever distribution you are using.
$ sudo apt-get install ros-ROSDISTRO-indoor-positioning
### From source:
If you can't use the binary release, for example when you are using an older version of ROS, you can still manually
build the package yourself.
First, clone the repository into the source folder of your catkin workspace:
$ git clone https://github.com/metratec/indoor_positioning.git YOUR_CATKIN_WS/src/indoor_positioning
Install python dependencies via:
$ pip install -r requirements.txt
Now you should be able to use the package like any other (catkin) package in your workspace.
## III. Usage
The
```receiver.py
``` node handles communication with the receiver and publishes incoming messages. Therefore you have to run this node
in order to use the IPS or IPS+ node. Then you can run either the
```positioning.py
``` node for IPS or the
```positioning_plus.py
``` node for IPS+ (or both, theoretically).
### Setup
To be able to use the nodes for zone location (IPS) or UWB positioning (IPS+) you have to setup your environment in a YAML configuration file.
Take a look at the
```config/zones_template.yml
``` example for information about the structure and content of this config file.
### Launch files
There are two launch files you can use right away to test this package with default parameters.
The
```ips.launch
``` file starts the receiver and the IPS node for zone location.
The
```ips_plus.launch
``` file starts the receiver and the IPS+ node for UWB position estimation.
For both you have to specify whether you use a TCP or USB receiver and how they are connected.
launching the IPS node using a metraTec USB receiver
$ roslaunch indoor_positioning ips.launch rec_name:=port rec_value:=/dev/ttyUSB0
launching the IPS+ node using a TCP receiver
$ roslaunch indoor_positioning ips_plus.launch rec_name:=host rec_value:=192.168.2.223
If you want to use non-default parameters for any of the nodes you have to set them in the ROS parameter server or
write your own launch files that set the respective parameters however you want.
Take a look at the two launch files mentioned above as an example.
_Note:_ by setting the
```do_vis
``` parameter of the launch files to
```True
``` you can simultaneously start rviz with
predefined settings to display the defined beacon positions, current zone and/or estimated receiver position.
### Nodes
#### receiver.py
Use this node to establish a connection with the metraTec IPS receiver or USB stick. You have to pass the USB port the
stick is connected to or the IP address of the regular receiver as a command line argument or as a private parameter
when you are using a launch file.
Running from command line:
$ rosrun indoor_positioning receiver.py TYPE REQUIRED OPTIONAL
For example:
$ rosrun indoor_positioning receiver.py usb /dev/ttyUSB0 $ rosrun indoor_positioning receiver.py tcp 192.168.2.223
```
Subscribed topics:
- ips/receiver/send (std_msgs/String):
Message to be sent over the TCP or serial connection to the IPS receiver or USB stick
Published topics:
- ips/receiver/raw (indoor_positioning/StringStamped):
Raw messages received from the receiver or USB stick
Parameters:
-
~type (string, default=’tcp’):
‘tcp’ for TCP receiver or ‘usb’ for metraTec USB stick -
~host (string, default=’192.168.2.223):
IP address of the connected receiver -
~port (with type=’tcp’: int, default=10001; with type=’usb’: string, default=’/dev/ttyUSB0):
Port for the TCP connection if ‘~type’ parameter is set to ‘tcp’, otherwise specifies the USB port of the stick -
~baudrate (int, default=115200):
Baudrate to use for serial communication with USB receiver
positioning.py (IPS)
Use this node to perform indoor zone location using the metraTec IPS tracking system. Prerequisites for using this node
File truncated at 100 lines see the full file
Changelog for package ros_ips
1.1.0 (2018-06-20) -----------* Trilatered positions are only published now if they are inside a polygon spanned by the beacons * Revamped launch files
1.0.3 (2018-06-20)
- Added some parametrization options to allow more efficient and robust position estimation
1.0.2 (2018-05-22)
- Renamed package from ros_ips to indoor_positioning
1.0.1 (2018-05-11)
- First public release for kinetic
Wiki Tutorials
Package Dependencies
| Deps | Name |
|---|---|
| roscpp | |
| rospy | |
| std_msgs | |
| message_generation | |
| catkin | |
| message_runtime |
System Dependencies
Dependant Packages
Launch files
- launch/ips.launch
-
- type [default: usb]
- host [default: 192.168.2.223]
- port [default: /dev/ttyUSB0]
- baudrate [default: 115200]
- config_file [default: config/zones.yml]
- rate [default: 1]
- bcn_len [default: -1]
- do_vis [default: False]
- launch/ips_plus.launch
-
- type [default: tcp]
- host [default: 192.168.2.223]
- port [default: 10001]
- baudrate [default: 115200]
- config_file [default: config/zones.yml]
- frame_id [default: map]
- rate [default: 0.1]
- bcn_len [default: -1]
- srg_len [default: -1]
- min_beacons [default: 3]
- max_beacons [default: 6]
- rssi_thresh [default: -127]
- max_z [default: 1]
- dilation [default: 0]
- do_vis [default: False]
Messages
Services
Plugins
Recent questions tagged indoor_positioning at Robotics Stack Exchange
|
|
indoor_positioning package from indoor_positioning repoindoor_positioning |
ROS Distro
|
Package Summary
| Tags | No category tags. |
| Version | 1.1.0 |
| License | BSD 2-Clause License |
| Build type | CATKIN |
| Use | RECOMMENDED |
Repository Summary
| Checkout URI | https://github.com/metratec/indoor_positioning.git |
| VCS Type | git |
| VCS Version | master |
| Last Updated | 2018-10-26 |
| Dev Status | MAINTAINED |
| CI status | Continuous Integration |
| Released | RELEASED |
| Tags | No category tags. |
| Contributing |
Help Wanted (0)
Good First Issues (0) Pull Requests to Review (0) |
Package Description
Additional Links
Maintainers
- Christian Arndt
Authors
- Christian Arndt
indoor_positioning
I. About
This is a ROS package for the metraTec Indoor Positioning System. You can use the regular IPS for zone location of your robot or the IPS+ products for 3D-position-estimation using UWB ranging.
The image shows an example of the indoor positioning functionality. Four RF beacons are placed in the environment that localize a corresponding receiver in the vicinity. The IPS displays the current (user-defined) zone that the receiver is in (green rectangle). Additionally, using the IPS+ position estimation, the actual 3D-position of the receiver is displayed (pink sphere).
II. Installation
From ROS binaries (preferred method):
Simply run the following command where you change
``` to whatever distribution you are using.
$ sudo apt-get install ros-ROSDISTRO-indoor-positioning
### From source:
If you can't use the binary release, for example when you are using an older version of ROS, you can still manually
build the package yourself.
First, clone the repository into the source folder of your catkin workspace:
$ git clone https://github.com/metratec/indoor_positioning.git YOUR_CATKIN_WS/src/indoor_positioning
Install python dependencies via:
$ pip install -r requirements.txt
Now you should be able to use the package like any other (catkin) package in your workspace.
## III. Usage
The
```receiver.py
``` node handles communication with the receiver and publishes incoming messages. Therefore you have to run this node
in order to use the IPS or IPS+ node. Then you can run either the
```positioning.py
``` node for IPS or the
```positioning_plus.py
``` node for IPS+ (or both, theoretically).
### Setup
To be able to use the nodes for zone location (IPS) or UWB positioning (IPS+) you have to setup your environment in a YAML configuration file.
Take a look at the
```config/zones_template.yml
``` example for information about the structure and content of this config file.
### Launch files
There are two launch files you can use right away to test this package with default parameters.
The
```ips.launch
``` file starts the receiver and the IPS node for zone location.
The
```ips_plus.launch
``` file starts the receiver and the IPS+ node for UWB position estimation.
For both you have to specify whether you use a TCP or USB receiver and how they are connected.
launching the IPS node using a metraTec USB receiver
$ roslaunch indoor_positioning ips.launch rec_name:=port rec_value:=/dev/ttyUSB0
launching the IPS+ node using a TCP receiver
$ roslaunch indoor_positioning ips_plus.launch rec_name:=host rec_value:=192.168.2.223
If you want to use non-default parameters for any of the nodes you have to set them in the ROS parameter server or
write your own launch files that set the respective parameters however you want.
Take a look at the two launch files mentioned above as an example.
_Note:_ by setting the
```do_vis
``` parameter of the launch files to
```True
``` you can simultaneously start rviz with
predefined settings to display the defined beacon positions, current zone and/or estimated receiver position.
### Nodes
#### receiver.py
Use this node to establish a connection with the metraTec IPS receiver or USB stick. You have to pass the USB port the
stick is connected to or the IP address of the regular receiver as a command line argument or as a private parameter
when you are using a launch file.
Running from command line:
$ rosrun indoor_positioning receiver.py TYPE REQUIRED OPTIONAL
For example:
$ rosrun indoor_positioning receiver.py usb /dev/ttyUSB0 $ rosrun indoor_positioning receiver.py tcp 192.168.2.223
```
Subscribed topics:
- ips/receiver/send (std_msgs/String):
Message to be sent over the TCP or serial connection to the IPS receiver or USB stick
Published topics:
- ips/receiver/raw (indoor_positioning/StringStamped):
Raw messages received from the receiver or USB stick
Parameters:
-
~type (string, default=’tcp’):
‘tcp’ for TCP receiver or ‘usb’ for metraTec USB stick -
~host (string, default=’192.168.2.223):
IP address of the connected receiver -
~port (with type=’tcp’: int, default=10001; with type=’usb’: string, default=’/dev/ttyUSB0):
Port for the TCP connection if ‘~type’ parameter is set to ‘tcp’, otherwise specifies the USB port of the stick -
~baudrate (int, default=115200):
Baudrate to use for serial communication with USB receiver
positioning.py (IPS)
Use this node to perform indoor zone location using the metraTec IPS tracking system. Prerequisites for using this node
File truncated at 100 lines see the full file
Changelog for package ros_ips
1.1.0 (2018-06-20) -----------* Trilatered positions are only published now if they are inside a polygon spanned by the beacons * Revamped launch files
1.0.3 (2018-06-20)
- Added some parametrization options to allow more efficient and robust position estimation
1.0.2 (2018-05-22)
- Renamed package from ros_ips to indoor_positioning
1.0.1 (2018-05-11)
- First public release for kinetic
Wiki Tutorials
Package Dependencies
| Deps | Name |
|---|---|
| roscpp | |
| rospy | |
| std_msgs | |
| message_generation | |
| catkin | |
| message_runtime |
System Dependencies
Dependant Packages
Launch files
- launch/ips.launch
-
- type [default: usb]
- host [default: 192.168.2.223]
- port [default: /dev/ttyUSB0]
- baudrate [default: 115200]
- config_file [default: config/zones.yml]
- rate [default: 1]
- bcn_len [default: -1]
- do_vis [default: False]
- launch/ips_plus.launch
-
- type [default: tcp]
- host [default: 192.168.2.223]
- port [default: 10001]
- baudrate [default: 115200]
- config_file [default: config/zones.yml]
- frame_id [default: map]
- rate [default: 0.1]
- bcn_len [default: -1]
- srg_len [default: -1]
- min_beacons [default: 3]
- max_beacons [default: 6]
- rssi_thresh [default: -127]
- max_z [default: 1]
- dilation [default: 0]
- do_vis [default: False]
Messages
Services
Plugins
Recent questions tagged indoor_positioning at Robotics Stack Exchange
|
|
indoor_positioning package from indoor_positioning repoindoor_positioning |
ROS Distro
|
Package Summary
| Tags | No category tags. |
| Version | 1.1.0 |
| License | BSD 2-Clause License |
| Build type | CATKIN |
| Use | RECOMMENDED |
Repository Summary
| Checkout URI | https://github.com/metratec/indoor_positioning.git |
| VCS Type | git |
| VCS Version | master |
| Last Updated | 2018-10-26 |
| Dev Status | MAINTAINED |
| CI status | Continuous Integration |
| Released | RELEASED |
| Tags | No category tags. |
| Contributing |
Help Wanted (0)
Good First Issues (0) Pull Requests to Review (0) |
Package Description
Additional Links
Maintainers
- Christian Arndt
Authors
- Christian Arndt
indoor_positioning
I. About
This is a ROS package for the metraTec Indoor Positioning System. You can use the regular IPS for zone location of your robot or the IPS+ products for 3D-position-estimation using UWB ranging.
The image shows an example of the indoor positioning functionality. Four RF beacons are placed in the environment that localize a corresponding receiver in the vicinity. The IPS displays the current (user-defined) zone that the receiver is in (green rectangle). Additionally, using the IPS+ position estimation, the actual 3D-position of the receiver is displayed (pink sphere).
II. Installation
From ROS binaries (preferred method):
Simply run the following command where you change
``` to whatever distribution you are using.
$ sudo apt-get install ros-ROSDISTRO-indoor-positioning
### From source:
If you can't use the binary release, for example when you are using an older version of ROS, you can still manually
build the package yourself.
First, clone the repository into the source folder of your catkin workspace:
$ git clone https://github.com/metratec/indoor_positioning.git YOUR_CATKIN_WS/src/indoor_positioning
Install python dependencies via:
$ pip install -r requirements.txt
Now you should be able to use the package like any other (catkin) package in your workspace.
## III. Usage
The
```receiver.py
``` node handles communication with the receiver and publishes incoming messages. Therefore you have to run this node
in order to use the IPS or IPS+ node. Then you can run either the
```positioning.py
``` node for IPS or the
```positioning_plus.py
``` node for IPS+ (or both, theoretically).
### Setup
To be able to use the nodes for zone location (IPS) or UWB positioning (IPS+) you have to setup your environment in a YAML configuration file.
Take a look at the
```config/zones_template.yml
``` example for information about the structure and content of this config file.
### Launch files
There are two launch files you can use right away to test this package with default parameters.
The
```ips.launch
``` file starts the receiver and the IPS node for zone location.
The
```ips_plus.launch
``` file starts the receiver and the IPS+ node for UWB position estimation.
For both you have to specify whether you use a TCP or USB receiver and how they are connected.
launching the IPS node using a metraTec USB receiver
$ roslaunch indoor_positioning ips.launch rec_name:=port rec_value:=/dev/ttyUSB0
launching the IPS+ node using a TCP receiver
$ roslaunch indoor_positioning ips_plus.launch rec_name:=host rec_value:=192.168.2.223
If you want to use non-default parameters for any of the nodes you have to set them in the ROS parameter server or
write your own launch files that set the respective parameters however you want.
Take a look at the two launch files mentioned above as an example.
_Note:_ by setting the
```do_vis
``` parameter of the launch files to
```True
``` you can simultaneously start rviz with
predefined settings to display the defined beacon positions, current zone and/or estimated receiver position.
### Nodes
#### receiver.py
Use this node to establish a connection with the metraTec IPS receiver or USB stick. You have to pass the USB port the
stick is connected to or the IP address of the regular receiver as a command line argument or as a private parameter
when you are using a launch file.
Running from command line:
$ rosrun indoor_positioning receiver.py TYPE REQUIRED OPTIONAL
For example:
$ rosrun indoor_positioning receiver.py usb /dev/ttyUSB0 $ rosrun indoor_positioning receiver.py tcp 192.168.2.223
```
Subscribed topics:
- ips/receiver/send (std_msgs/String):
Message to be sent over the TCP or serial connection to the IPS receiver or USB stick
Published topics:
- ips/receiver/raw (indoor_positioning/StringStamped):
Raw messages received from the receiver or USB stick
Parameters:
-
~type (string, default=’tcp’):
‘tcp’ for TCP receiver or ‘usb’ for metraTec USB stick -
~host (string, default=’192.168.2.223):
IP address of the connected receiver -
~port (with type=’tcp’: int, default=10001; with type=’usb’: string, default=’/dev/ttyUSB0):
Port for the TCP connection if ‘~type’ parameter is set to ‘tcp’, otherwise specifies the USB port of the stick -
~baudrate (int, default=115200):
Baudrate to use for serial communication with USB receiver
positioning.py (IPS)
Use this node to perform indoor zone location using the metraTec IPS tracking system. Prerequisites for using this node
File truncated at 100 lines see the full file
Changelog for package ros_ips
1.1.0 (2018-06-20) -----------* Trilatered positions are only published now if they are inside a polygon spanned by the beacons * Revamped launch files
1.0.3 (2018-06-20)
- Added some parametrization options to allow more efficient and robust position estimation
1.0.2 (2018-05-22)
- Renamed package from ros_ips to indoor_positioning
1.0.1 (2018-05-11)
- First public release for kinetic
Wiki Tutorials
Package Dependencies
| Deps | Name |
|---|---|
| roscpp | |
| rospy | |
| std_msgs | |
| message_generation | |
| catkin | |
| message_runtime |
System Dependencies
Dependant Packages
Launch files
- launch/ips.launch
-
- type [default: usb]
- host [default: 192.168.2.223]
- port [default: /dev/ttyUSB0]
- baudrate [default: 115200]
- config_file [default: config/zones.yml]
- rate [default: 1]
- bcn_len [default: -1]
- do_vis [default: False]
- launch/ips_plus.launch
-
- type [default: tcp]
- host [default: 192.168.2.223]
- port [default: 10001]
- baudrate [default: 115200]
- config_file [default: config/zones.yml]
- frame_id [default: map]
- rate [default: 0.1]
- bcn_len [default: -1]
- srg_len [default: -1]
- min_beacons [default: 3]
- max_beacons [default: 6]
- rssi_thresh [default: -127]
- max_z [default: 1]
- dilation [default: 0]
- do_vis [default: False]
Messages
Services
Plugins
Recent questions tagged indoor_positioning at Robotics Stack Exchange
|
|
indoor_positioning package from indoor_positioning repoindoor_positioning |
ROS Distro
|
Package Summary
| Tags | No category tags. |
| Version | 1.1.0 |
| License | BSD 2-Clause License |
| Build type | CATKIN |
| Use | RECOMMENDED |
Repository Summary
| Checkout URI | https://github.com/metratec/indoor_positioning.git |
| VCS Type | git |
| VCS Version | master |
| Last Updated | 2018-10-26 |
| Dev Status | MAINTAINED |
| CI status | Continuous Integration |
| Released | RELEASED |
| Tags | No category tags. |
| Contributing |
Help Wanted (0)
Good First Issues (0) Pull Requests to Review (0) |
Package Description
Additional Links
Maintainers
- Christian Arndt
Authors
- Christian Arndt
indoor_positioning
I. About
This is a ROS package for the metraTec Indoor Positioning System. You can use the regular IPS for zone location of your robot or the IPS+ products for 3D-position-estimation using UWB ranging.
The image shows an example of the indoor positioning functionality. Four RF beacons are placed in the environment that localize a corresponding receiver in the vicinity. The IPS displays the current (user-defined) zone that the receiver is in (green rectangle). Additionally, using the IPS+ position estimation, the actual 3D-position of the receiver is displayed (pink sphere).
II. Installation
From ROS binaries (preferred method):
Simply run the following command where you change
``` to whatever distribution you are using.
$ sudo apt-get install ros-ROSDISTRO-indoor-positioning
### From source:
If you can't use the binary release, for example when you are using an older version of ROS, you can still manually
build the package yourself.
First, clone the repository into the source folder of your catkin workspace:
$ git clone https://github.com/metratec/indoor_positioning.git YOUR_CATKIN_WS/src/indoor_positioning
Install python dependencies via:
$ pip install -r requirements.txt
Now you should be able to use the package like any other (catkin) package in your workspace.
## III. Usage
The
```receiver.py
``` node handles communication with the receiver and publishes incoming messages. Therefore you have to run this node
in order to use the IPS or IPS+ node. Then you can run either the
```positioning.py
``` node for IPS or the
```positioning_plus.py
``` node for IPS+ (or both, theoretically).
### Setup
To be able to use the nodes for zone location (IPS) or UWB positioning (IPS+) you have to setup your environment in a YAML configuration file.
Take a look at the
```config/zones_template.yml
``` example for information about the structure and content of this config file.
### Launch files
There are two launch files you can use right away to test this package with default parameters.
The
```ips.launch
``` file starts the receiver and the IPS node for zone location.
The
```ips_plus.launch
``` file starts the receiver and the IPS+ node for UWB position estimation.
For both you have to specify whether you use a TCP or USB receiver and how they are connected.
launching the IPS node using a metraTec USB receiver
$ roslaunch indoor_positioning ips.launch rec_name:=port rec_value:=/dev/ttyUSB0
launching the IPS+ node using a TCP receiver
$ roslaunch indoor_positioning ips_plus.launch rec_name:=host rec_value:=192.168.2.223
If you want to use non-default parameters for any of the nodes you have to set them in the ROS parameter server or
write your own launch files that set the respective parameters however you want.
Take a look at the two launch files mentioned above as an example.
_Note:_ by setting the
```do_vis
``` parameter of the launch files to
```True
``` you can simultaneously start rviz with
predefined settings to display the defined beacon positions, current zone and/or estimated receiver position.
### Nodes
#### receiver.py
Use this node to establish a connection with the metraTec IPS receiver or USB stick. You have to pass the USB port the
stick is connected to or the IP address of the regular receiver as a command line argument or as a private parameter
when you are using a launch file.
Running from command line:
$ rosrun indoor_positioning receiver.py TYPE REQUIRED OPTIONAL
For example:
$ rosrun indoor_positioning receiver.py usb /dev/ttyUSB0 $ rosrun indoor_positioning receiver.py tcp 192.168.2.223
```
Subscribed topics:
- ips/receiver/send (std_msgs/String):
Message to be sent over the TCP or serial connection to the IPS receiver or USB stick
Published topics:
- ips/receiver/raw (indoor_positioning/StringStamped):
Raw messages received from the receiver or USB stick
Parameters:
-
~type (string, default=’tcp’):
‘tcp’ for TCP receiver or ‘usb’ for metraTec USB stick -
~host (string, default=’192.168.2.223):
IP address of the connected receiver -
~port (with type=’tcp’: int, default=10001; with type=’usb’: string, default=’/dev/ttyUSB0):
Port for the TCP connection if ‘~type’ parameter is set to ‘tcp’, otherwise specifies the USB port of the stick -
~baudrate (int, default=115200):
Baudrate to use for serial communication with USB receiver
positioning.py (IPS)
Use this node to perform indoor zone location using the metraTec IPS tracking system. Prerequisites for using this node
File truncated at 100 lines see the full file
Changelog for package ros_ips
1.1.0 (2018-06-20) -----------* Trilatered positions are only published now if they are inside a polygon spanned by the beacons * Revamped launch files
1.0.3 (2018-06-20)
- Added some parametrization options to allow more efficient and robust position estimation
1.0.2 (2018-05-22)
- Renamed package from ros_ips to indoor_positioning
1.0.1 (2018-05-11)
- First public release for kinetic
Wiki Tutorials
Package Dependencies
| Deps | Name |
|---|---|
| roscpp | |
| rospy | |
| std_msgs | |
| message_generation | |
| catkin | |
| message_runtime |
System Dependencies
Dependant Packages
Launch files
- launch/ips.launch
-
- type [default: usb]
- host [default: 192.168.2.223]
- port [default: /dev/ttyUSB0]
- baudrate [default: 115200]
- config_file [default: config/zones.yml]
- rate [default: 1]
- bcn_len [default: -1]
- do_vis [default: False]
- launch/ips_plus.launch
-
- type [default: tcp]
- host [default: 192.168.2.223]
- port [default: 10001]
- baudrate [default: 115200]
- config_file [default: config/zones.yml]
- frame_id [default: map]
- rate [default: 0.1]
- bcn_len [default: -1]
- srg_len [default: -1]
- min_beacons [default: 3]
- max_beacons [default: 6]
- rssi_thresh [default: -127]
- max_z [default: 1]
- dilation [default: 0]
- do_vis [default: False]
Messages
Services
Plugins
Recent questions tagged indoor_positioning at Robotics Stack Exchange
|
|
indoor_positioning package from indoor_positioning repoindoor_positioning |
ROS Distro
|
Package Summary
| Tags | No category tags. |
| Version | 1.1.0 |
| License | BSD 2-Clause License |
| Build type | CATKIN |
| Use | RECOMMENDED |
Repository Summary
| Checkout URI | https://github.com/metratec/indoor_positioning.git |
| VCS Type | git |
| VCS Version | master |
| Last Updated | 2018-10-26 |
| Dev Status | MAINTAINED |
| CI status | Continuous Integration |
| Released | RELEASED |
| Tags | No category tags. |
| Contributing |
Help Wanted (0)
Good First Issues (0) Pull Requests to Review (0) |
Package Description
Additional Links
Maintainers
- Christian Arndt
Authors
- Christian Arndt
indoor_positioning
I. About
This is a ROS package for the metraTec Indoor Positioning System. You can use the regular IPS for zone location of your robot or the IPS+ products for 3D-position-estimation using UWB ranging.
The image shows an example of the indoor positioning functionality. Four RF beacons are placed in the environment that localize a corresponding receiver in the vicinity. The IPS displays the current (user-defined) zone that the receiver is in (green rectangle). Additionally, using the IPS+ position estimation, the actual 3D-position of the receiver is displayed (pink sphere).
II. Installation
From ROS binaries (preferred method):
Simply run the following command where you change
``` to whatever distribution you are using.
$ sudo apt-get install ros-ROSDISTRO-indoor-positioning
### From source:
If you can't use the binary release, for example when you are using an older version of ROS, you can still manually
build the package yourself.
First, clone the repository into the source folder of your catkin workspace:
$ git clone https://github.com/metratec/indoor_positioning.git YOUR_CATKIN_WS/src/indoor_positioning
Install python dependencies via:
$ pip install -r requirements.txt
Now you should be able to use the package like any other (catkin) package in your workspace.
## III. Usage
The
```receiver.py
``` node handles communication with the receiver and publishes incoming messages. Therefore you have to run this node
in order to use the IPS or IPS+ node. Then you can run either the
```positioning.py
``` node for IPS or the
```positioning_plus.py
``` node for IPS+ (or both, theoretically).
### Setup
To be able to use the nodes for zone location (IPS) or UWB positioning (IPS+) you have to setup your environment in a YAML configuration file.
Take a look at the
```config/zones_template.yml
``` example for information about the structure and content of this config file.
### Launch files
There are two launch files you can use right away to test this package with default parameters.
The
```ips.launch
``` file starts the receiver and the IPS node for zone location.
The
```ips_plus.launch
``` file starts the receiver and the IPS+ node for UWB position estimation.
For both you have to specify whether you use a TCP or USB receiver and how they are connected.
launching the IPS node using a metraTec USB receiver
$ roslaunch indoor_positioning ips.launch rec_name:=port rec_value:=/dev/ttyUSB0
launching the IPS+ node using a TCP receiver
$ roslaunch indoor_positioning ips_plus.launch rec_name:=host rec_value:=192.168.2.223
If you want to use non-default parameters for any of the nodes you have to set them in the ROS parameter server or
write your own launch files that set the respective parameters however you want.
Take a look at the two launch files mentioned above as an example.
_Note:_ by setting the
```do_vis
``` parameter of the launch files to
```True
``` you can simultaneously start rviz with
predefined settings to display the defined beacon positions, current zone and/or estimated receiver position.
### Nodes
#### receiver.py
Use this node to establish a connection with the metraTec IPS receiver or USB stick. You have to pass the USB port the
stick is connected to or the IP address of the regular receiver as a command line argument or as a private parameter
when you are using a launch file.
Running from command line:
$ rosrun indoor_positioning receiver.py TYPE REQUIRED OPTIONAL
For example:
$ rosrun indoor_positioning receiver.py usb /dev/ttyUSB0 $ rosrun indoor_positioning receiver.py tcp 192.168.2.223
```
Subscribed topics:
- ips/receiver/send (std_msgs/String):
Message to be sent over the TCP or serial connection to the IPS receiver or USB stick
Published topics:
- ips/receiver/raw (indoor_positioning/StringStamped):
Raw messages received from the receiver or USB stick
Parameters:
-
~type (string, default=’tcp’):
‘tcp’ for TCP receiver or ‘usb’ for metraTec USB stick -
~host (string, default=’192.168.2.223):
IP address of the connected receiver -
~port (with type=’tcp’: int, default=10001; with type=’usb’: string, default=’/dev/ttyUSB0):
Port for the TCP connection if ‘~type’ parameter is set to ‘tcp’, otherwise specifies the USB port of the stick -
~baudrate (int, default=115200):
Baudrate to use for serial communication with USB receiver
positioning.py (IPS)
Use this node to perform indoor zone location using the metraTec IPS tracking system. Prerequisites for using this node
File truncated at 100 lines see the full file
Changelog for package ros_ips
1.1.0 (2018-06-20) -----------* Trilatered positions are only published now if they are inside a polygon spanned by the beacons * Revamped launch files
1.0.3 (2018-06-20)
- Added some parametrization options to allow more efficient and robust position estimation
1.0.2 (2018-05-22)
- Renamed package from ros_ips to indoor_positioning
1.0.1 (2018-05-11)
- First public release for kinetic
Wiki Tutorials
Package Dependencies
| Deps | Name |
|---|---|
| roscpp | |
| rospy | |
| std_msgs | |
| message_generation | |
| catkin | |
| message_runtime |
System Dependencies
Dependant Packages
Launch files
- launch/ips.launch
-
- type [default: usb]
- host [default: 192.168.2.223]
- port [default: /dev/ttyUSB0]
- baudrate [default: 115200]
- config_file [default: config/zones.yml]
- rate [default: 1]
- bcn_len [default: -1]
- do_vis [default: False]
- launch/ips_plus.launch
-
- type [default: tcp]
- host [default: 192.168.2.223]
- port [default: 10001]
- baudrate [default: 115200]
- config_file [default: config/zones.yml]
- frame_id [default: map]
- rate [default: 0.1]
- bcn_len [default: -1]
- srg_len [default: -1]
- min_beacons [default: 3]
- max_beacons [default: 6]
- rssi_thresh [default: -127]
- max_z [default: 1]
- dilation [default: 0]
- do_vis [default: False]
Messages
Services
Plugins
Recent questions tagged indoor_positioning at Robotics Stack Exchange
|
|
indoor_positioning package from indoor_positioning repoindoor_positioning |
ROS Distro
|
Package Summary
| Tags | No category tags. |
| Version | 1.1.0 |
| License | BSD 2-Clause License |
| Build type | CATKIN |
| Use | RECOMMENDED |
Repository Summary
| Checkout URI | https://github.com/metratec/indoor_positioning.git |
| VCS Type | git |
| VCS Version | master |
| Last Updated | 2018-10-26 |
| Dev Status | MAINTAINED |
| CI status | Continuous Integration |
| Released | RELEASED |
| Tags | No category tags. |
| Contributing |
Help Wanted (0)
Good First Issues (0) Pull Requests to Review (0) |
Package Description
Additional Links
Maintainers
- Christian Arndt
Authors
- Christian Arndt
indoor_positioning
I. About
This is a ROS package for the metraTec Indoor Positioning System. You can use the regular IPS for zone location of your robot or the IPS+ products for 3D-position-estimation using UWB ranging.
The image shows an example of the indoor positioning functionality. Four RF beacons are placed in the environment that localize a corresponding receiver in the vicinity. The IPS displays the current (user-defined) zone that the receiver is in (green rectangle). Additionally, using the IPS+ position estimation, the actual 3D-position of the receiver is displayed (pink sphere).
II. Installation
From ROS binaries (preferred method):
Simply run the following command where you change
``` to whatever distribution you are using.
$ sudo apt-get install ros-ROSDISTRO-indoor-positioning
### From source:
If you can't use the binary release, for example when you are using an older version of ROS, you can still manually
build the package yourself.
First, clone the repository into the source folder of your catkin workspace:
$ git clone https://github.com/metratec/indoor_positioning.git YOUR_CATKIN_WS/src/indoor_positioning
Install python dependencies via:
$ pip install -r requirements.txt
Now you should be able to use the package like any other (catkin) package in your workspace.
## III. Usage
The
```receiver.py
``` node handles communication with the receiver and publishes incoming messages. Therefore you have to run this node
in order to use the IPS or IPS+ node. Then you can run either the
```positioning.py
``` node for IPS or the
```positioning_plus.py
``` node for IPS+ (or both, theoretically).
### Setup
To be able to use the nodes for zone location (IPS) or UWB positioning (IPS+) you have to setup your environment in a YAML configuration file.
Take a look at the
```config/zones_template.yml
``` example for information about the structure and content of this config file.
### Launch files
There are two launch files you can use right away to test this package with default parameters.
The
```ips.launch
``` file starts the receiver and the IPS node for zone location.
The
```ips_plus.launch
``` file starts the receiver and the IPS+ node for UWB position estimation.
For both you have to specify whether you use a TCP or USB receiver and how they are connected.
launching the IPS node using a metraTec USB receiver
$ roslaunch indoor_positioning ips.launch rec_name:=port rec_value:=/dev/ttyUSB0
launching the IPS+ node using a TCP receiver
$ roslaunch indoor_positioning ips_plus.launch rec_name:=host rec_value:=192.168.2.223
If you want to use non-default parameters for any of the nodes you have to set them in the ROS parameter server or
write your own launch files that set the respective parameters however you want.
Take a look at the two launch files mentioned above as an example.
_Note:_ by setting the
```do_vis
``` parameter of the launch files to
```True
``` you can simultaneously start rviz with
predefined settings to display the defined beacon positions, current zone and/or estimated receiver position.
### Nodes
#### receiver.py
Use this node to establish a connection with the metraTec IPS receiver or USB stick. You have to pass the USB port the
stick is connected to or the IP address of the regular receiver as a command line argument or as a private parameter
when you are using a launch file.
Running from command line:
$ rosrun indoor_positioning receiver.py TYPE REQUIRED OPTIONAL
For example:
$ rosrun indoor_positioning receiver.py usb /dev/ttyUSB0 $ rosrun indoor_positioning receiver.py tcp 192.168.2.223
```
Subscribed topics:
- ips/receiver/send (std_msgs/String):
Message to be sent over the TCP or serial connection to the IPS receiver or USB stick
Published topics:
- ips/receiver/raw (indoor_positioning/StringStamped):
Raw messages received from the receiver or USB stick
Parameters:
-
~type (string, default=’tcp’):
‘tcp’ for TCP receiver or ‘usb’ for metraTec USB stick -
~host (string, default=’192.168.2.223):
IP address of the connected receiver -
~port (with type=’tcp’: int, default=10001; with type=’usb’: string, default=’/dev/ttyUSB0):
Port for the TCP connection if ‘~type’ parameter is set to ‘tcp’, otherwise specifies the USB port of the stick -
~baudrate (int, default=115200):
Baudrate to use for serial communication with USB receiver
positioning.py (IPS)
Use this node to perform indoor zone location using the metraTec IPS tracking system. Prerequisites for using this node
File truncated at 100 lines see the full file
Changelog for package ros_ips
1.1.0 (2018-06-20) -----------* Trilatered positions are only published now if they are inside a polygon spanned by the beacons * Revamped launch files
1.0.3 (2018-06-20)
- Added some parametrization options to allow more efficient and robust position estimation
1.0.2 (2018-05-22)
- Renamed package from ros_ips to indoor_positioning
1.0.1 (2018-05-11)
- First public release for kinetic
Wiki Tutorials
Package Dependencies
| Deps | Name |
|---|---|
| roscpp | |
| rospy | |
| std_msgs | |
| message_generation | |
| catkin | |
| message_runtime |
System Dependencies
Dependant Packages
Launch files
- launch/ips.launch
-
- type [default: usb]
- host [default: 192.168.2.223]
- port [default: /dev/ttyUSB0]
- baudrate [default: 115200]
- config_file [default: config/zones.yml]
- rate [default: 1]
- bcn_len [default: -1]
- do_vis [default: False]
- launch/ips_plus.launch
-
- type [default: tcp]
- host [default: 192.168.2.223]
- port [default: 10001]
- baudrate [default: 115200]
- config_file [default: config/zones.yml]
- frame_id [default: map]
- rate [default: 0.1]
- bcn_len [default: -1]
- srg_len [default: -1]
- min_beacons [default: 3]
- max_beacons [default: 6]
- rssi_thresh [default: -127]
- max_z [default: 1]
- dilation [default: 0]
- do_vis [default: False]
Messages
Services
Plugins
Recent questions tagged indoor_positioning at Robotics Stack Exchange
|
|
indoor_positioning package from indoor_positioning repoindoor_positioning |
ROS Distro
|
Package Summary
| Tags | No category tags. |
| Version | 1.1.0 |
| License | BSD 2-Clause License |
| Build type | CATKIN |
| Use | RECOMMENDED |
Repository Summary
| Checkout URI | https://github.com/metratec/indoor_positioning.git |
| VCS Type | git |
| VCS Version | master |
| Last Updated | 2018-10-26 |
| Dev Status | MAINTAINED |
| CI status | Continuous Integration |
| Released | RELEASED |
| Tags | No category tags. |
| Contributing |
Help Wanted (0)
Good First Issues (0) Pull Requests to Review (0) |
Package Description
Additional Links
Maintainers
- Christian Arndt
Authors
- Christian Arndt
indoor_positioning
I. About
This is a ROS package for the metraTec Indoor Positioning System. You can use the regular IPS for zone location of your robot or the IPS+ products for 3D-position-estimation using UWB ranging.
The image shows an example of the indoor positioning functionality. Four RF beacons are placed in the environment that localize a corresponding receiver in the vicinity. The IPS displays the current (user-defined) zone that the receiver is in (green rectangle). Additionally, using the IPS+ position estimation, the actual 3D-position of the receiver is displayed (pink sphere).
II. Installation
From ROS binaries (preferred method):
Simply run the following command where you change
``` to whatever distribution you are using.
$ sudo apt-get install ros-ROSDISTRO-indoor-positioning
### From source:
If you can't use the binary release, for example when you are using an older version of ROS, you can still manually
build the package yourself.
First, clone the repository into the source folder of your catkin workspace:
$ git clone https://github.com/metratec/indoor_positioning.git YOUR_CATKIN_WS/src/indoor_positioning
Install python dependencies via:
$ pip install -r requirements.txt
Now you should be able to use the package like any other (catkin) package in your workspace.
## III. Usage
The
```receiver.py
``` node handles communication with the receiver and publishes incoming messages. Therefore you have to run this node
in order to use the IPS or IPS+ node. Then you can run either the
```positioning.py
``` node for IPS or the
```positioning_plus.py
``` node for IPS+ (or both, theoretically).
### Setup
To be able to use the nodes for zone location (IPS) or UWB positioning (IPS+) you have to setup your environment in a YAML configuration file.
Take a look at the
```config/zones_template.yml
``` example for information about the structure and content of this config file.
### Launch files
There are two launch files you can use right away to test this package with default parameters.
The
```ips.launch
``` file starts the receiver and the IPS node for zone location.
The
```ips_plus.launch
``` file starts the receiver and the IPS+ node for UWB position estimation.
For both you have to specify whether you use a TCP or USB receiver and how they are connected.
launching the IPS node using a metraTec USB receiver
$ roslaunch indoor_positioning ips.launch rec_name:=port rec_value:=/dev/ttyUSB0
launching the IPS+ node using a TCP receiver
$ roslaunch indoor_positioning ips_plus.launch rec_name:=host rec_value:=192.168.2.223
If you want to use non-default parameters for any of the nodes you have to set them in the ROS parameter server or
write your own launch files that set the respective parameters however you want.
Take a look at the two launch files mentioned above as an example.
_Note:_ by setting the
```do_vis
``` parameter of the launch files to
```True
``` you can simultaneously start rviz with
predefined settings to display the defined beacon positions, current zone and/or estimated receiver position.
### Nodes
#### receiver.py
Use this node to establish a connection with the metraTec IPS receiver or USB stick. You have to pass the USB port the
stick is connected to or the IP address of the regular receiver as a command line argument or as a private parameter
when you are using a launch file.
Running from command line:
$ rosrun indoor_positioning receiver.py TYPE REQUIRED OPTIONAL
For example:
$ rosrun indoor_positioning receiver.py usb /dev/ttyUSB0 $ rosrun indoor_positioning receiver.py tcp 192.168.2.223
```
Subscribed topics:
- ips/receiver/send (std_msgs/String):
Message to be sent over the TCP or serial connection to the IPS receiver or USB stick
Published topics:
- ips/receiver/raw (indoor_positioning/StringStamped):
Raw messages received from the receiver or USB stick
Parameters:
-
~type (string, default=’tcp’):
‘tcp’ for TCP receiver or ‘usb’ for metraTec USB stick -
~host (string, default=’192.168.2.223):
IP address of the connected receiver -
~port (with type=’tcp’: int, default=10001; with type=’usb’: string, default=’/dev/ttyUSB0):
Port for the TCP connection if ‘~type’ parameter is set to ‘tcp’, otherwise specifies the USB port of the stick -
~baudrate (int, default=115200):
Baudrate to use for serial communication with USB receiver
positioning.py (IPS)
Use this node to perform indoor zone location using the metraTec IPS tracking system. Prerequisites for using this node
File truncated at 100 lines see the full file
Changelog for package ros_ips
1.1.0 (2018-06-20) -----------* Trilatered positions are only published now if they are inside a polygon spanned by the beacons * Revamped launch files
1.0.3 (2018-06-20)
- Added some parametrization options to allow more efficient and robust position estimation
1.0.2 (2018-05-22)
- Renamed package from ros_ips to indoor_positioning
1.0.1 (2018-05-11)
- First public release for kinetic
Wiki Tutorials
Package Dependencies
| Deps | Name |
|---|---|
| roscpp | |
| rospy | |
| std_msgs | |
| message_generation | |
| catkin | |
| message_runtime |
System Dependencies
Dependant Packages
Launch files
- launch/ips.launch
-
- type [default: usb]
- host [default: 192.168.2.223]
- port [default: /dev/ttyUSB0]
- baudrate [default: 115200]
- config_file [default: config/zones.yml]
- rate [default: 1]
- bcn_len [default: -1]
- do_vis [default: False]
- launch/ips_plus.launch
-
- type [default: tcp]
- host [default: 192.168.2.223]
- port [default: 10001]
- baudrate [default: 115200]
- config_file [default: config/zones.yml]
- frame_id [default: map]
- rate [default: 0.1]
- bcn_len [default: -1]
- srg_len [default: -1]
- min_beacons [default: 3]
- max_beacons [default: 6]
- rssi_thresh [default: -127]
- max_z [default: 1]
- dilation [default: 0]
- do_vis [default: False]