microstrain_inertial repository

Repository Summary

Checkout URI https://github.com/LORD-MicroStrain/microstrain_inertial.git
VCS Type git
VCS Version ros
Last Updated 2021-09-08
CI status No Continuous Integration
Tags No category tags.
Contributing Help Wanted (0)
Good First Issues (0)
Pull Requests to Review (0)



Interface (driver) software, including ROS node, for inertial sensors compatible with the Microstrain Communication Library (MSCL).

MSCL is developed by LORD Sensing - Microstrain in Williston, VT.

Different Codebases

This repo is now structured differently as of 2.0.0.

Important Branches

There are three important branches that you may want to checkout:

  • master -- Contains the most recent ROS1 changes before the transition to 2.0.0. Kept for backwards compatibility, but no longer updated or supported
  • ros -- Contains ROS1 implementation for this node as of 2.0.0. This version is being actively updated and supported
  • ros2 -- Contains ROS2 implementation for this node as of 2.0.0. This version is being actively updated and supported

Both the ros and ros2 branches share most of their code by using the ROS-MSCL-Common submodule which is submoduled in this repo at microstrain_common

Different Package Names

Prior to version 2.0.0, this repo contained the following ROS packages: * ros_mscl -- ROS node that will communicate with the devices * mscl_msgs -- Collection of messages produced by the ros_mscl node * ros_mscl_cpp_example -- Simple subscriber written in C++ that will consume a message produced by ros_mscl * ros_mscl_py_example -- Simple subscriber written in Python that will consume a message produced by ros_mscl

Due to requirements laid out by the ROS maintainers here, as of version 2.0.0, this repo contains the following ROS packages: * microstrain_inertial_driver -- ROS node that will communicate with the devices * microstrain_inertial_msgs -- Collection of messages produces by the microstrain_inertial_driver node * microstrain_inretial_examples -- Collection of examples that show how to interact with the microstrain_inertial_driver node. Currently contains one simple C++ and python subscriber node

Build Instructions


This repo now takes advantage of git submodules in order to share code between ROS versions. When cloning the repo, you should clone with the --recursive flag to get all of the submodules.

If you have already cloned the repo, you can checkout the submodules by running git submodule init && git submodule update --recursive from the project directory

The CMakeLists.txt will automatically checkout the submodule if it does not exist, but it will not keep it up to date. In order to keep up to date, every time you pull changes you should pull with the --recurse-submodules flag, or alternatively run git submodule update --recursive after you have pulled changes


MSCL is now installed in the CMakeLists.txt. The version installed can be changed by passing the flag -DMSCL_VERSION="62.0.0"

If you already have MSCL installed and want to use your installed version instead of the one automatically downloaded, you can specify the location by passing the flag -DMSCL_DIR=/usr/share/c++-mscl

We do our best to keep ROS-MSCL up-to-date with the latest MSCL changes, but sometimes there is a delay. The currently supported version of MSCL is v62.0.0

Building from source

  1. Install ROS and create a workspace: Installing and Configuring Your ROS Environment

  2. Move the entire microstrain_inertial folder (microstrain_inertial_driver, microstrain_inertial_msgs , and microstrain_common for just source) to the your_workspace/src directory.

  3. Locate and register the ros_mscl package: rospack find microstrain_inertial_driver

  4. Build your workspace:

    cd ~/your_workspace
    source ~/your_workspace/devel/setup.bash

    The source command may need to be run in each terminal prior to launching a ROS node.

    Launch the node and publish data

    The following command will launch the driver. Keep in mind each instance needs to be run in a separate terminal.

    roslaunch microstrain_inertial_driver microstrain.launch

    Optional launch parameters:

  5. name: namespace the node will publish messages to, default: gx5

  6. port: serial port name to connect to the device over, default: /dev/ttyACM0

  7. baudrate: baud rate to open the connection with, default: 115200

  8. imu_rate: sample rate for IMU data (hz), default: 100

  9. debug: output debug info? default: false

  10. diagnostics: output diagnostic info? default: true

To check published topics:

rostopic list

Example: Connect to and publish data from two devices simultaneously
In two different terminals:

roslaunch microstrain_inertial_driver microstrain.launch name:=sensor1234

roslaunch microstrain_inertial_driver microstrain.launch name:=bestSensor port:=/dev/ttyACM1

This will launch two nodes that publish data to different namespaces: - sensor1234, connected over port: /dev/ttyACM0 - bestSensor, connected over port: /dev/ttyACM1

An example subscriber node can be found here: Microstrain Examples

Docker Integration


The easiest way to use docker while still using an IDE is to use VSCode as an IDE. Follow the steps below to develop on this repo in a docker container

  1. Install the following dependencies:
    1. VSCode
    2. Docker
  2. Open VSCode and install the following plugins:
    1. VSCode Docker plugin
    2. VSCode Remote Containers plugin
  3. Open this directory in a container by following this guide
    1. Due to a bug in the remote container plugin, you will need to refresh the window once it comes up. To do this, type Ctrl+Shift+p and type Reload Window and hit enter. Note that this will have to be repeated every time the container is rebuilt
  4. Once the folder is open in VSCode, you can build the project by running Ctrl+Shift+B to trigger a build, or Ctrl+p to open quick open, then type task build and hit enter
  5. You can run the project by following this guide


If you are comfortable working from the command line, or want to produce runtime images, the Makefile in the .devcontainer directory can be used to build docker images, run a shell inside the docker images and produce a runtime image. Follow the steps below to setup your environment to use the Makefile

  1. Install the following dependencies:
    1. Make
    2. Docker
    3. qemu-user-static (for multiarch builds)
      1. Run the following command to register the qemu binaries with docker: docker run --rm --privileged multiarch/qemu-user-static:register

The Makefile exposes the following tasks. They can all be run from the .devcontainer directory: * make build-shell - Builds the docker image and starts a shell session in the image allowing the user to develop and build the ROS project using common commands such as catkin_make * make image - Builds the runtim image that contains only the required dependencies and the ROS node. The resulting image is names ros-mscl * make clean - Cleans up after the above two tasks


microstrain_inertial is released under the MIT License - see the LICENSE file in the source distribution.

Copyright (c) 2021, Parker Hannifin Corp.