Skip to content


Switch branches/tags

Name already in use

A tag already exists with the provided branch name. Many Git commands accept both tag and branch names, so creating this branch may cause unexpected behavior. Are you sure you want to create this branch?
This branch is 309 commits ahead of ros-drivers:master.

Latest commit


Git stats


Failed to load latest commit information.


Interface (driver) software, including ROS node, for the MicroStrain line of inertial sensors from Parker, developed in Williston, VT.

Implemented using the MicroStrain Inertial Protocol SDK (mip_sdk)

Table of Contents

ROS Wiki

For more information on the data published and services available see our ROS wiki page

ROS vs ROS2 Versions

Note that this branch contains the ROS implementation for the packages. If you are looking for the ROS2 version, you should go to the ros2 branch


This repo contains the following packages:

Install Instructions


As of v2.0.5 this package is being built and distributed by the ROS build farm. If you do not need to modify the source, it is recommended to install directly from the buildfarm by running the following commands where ROS_DISTRO is the version of ROS you are using such as melodic or noetic:


sudo apt-get update && sudo apt-get install ros-ROS_DISTRO-microstrain-inertial-driver


sudo apt-get update && sudo apt-get install ros-ROS_DISTRO-microstrain-inertial-rqt

For more information on the ROS distros and platforms we support, please see


As of v2.2.2 the microstrain_inertial_driver is distributed as a docker image. More information on how to use the image can be found on DockerHub.

If you are interested in working on the node in a docker container, see the Docker Development section.


If you need to modify the source of this repository, or are running on a platform that we do not support, you can build from source by following the Building From Source guide below.


This repo 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 update --init --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

Building from source

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

  2. Clone the repository into your workspace:

    git clone --recursive --branch ros ~/your_workspace/src/microstrain_inertial
  3. Install rosdeps for this package: rosdep install --from-paths ~/your_workspace/src -i -r -y

  4. Build your workspace:

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

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

Run Instructions

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

The node has some optional launch parameters that can be specified from the command line in the format param:=value

  • namespace : namespace that the driver will run in. All services and publishers will be prepended with this, default: /
  • node_name : name of the driver, default: microstrain_inertial_driver
  • debug : output debug logs, default: false
  • params_file : path to a parameter file to override the default parameters stored in params.yml, default: empty

Publish data from two devices simultaneously

  1. Create the following files somewhere on your system (we will assume they are stored in the ~ directory):
    1. ~/sensor_a_params.yml with the contents:
      port: /dev/ttyACM0
    2. ~/sensor_b_params.yml with the contents:
      port: /dev/ttyACM1
  2. In two different terminals:
    roslaunch microstrain_inertial_driver microstrain.launch node_name:=sensor_a_node namespace:=sensor_a params_file:="~/sensor_a_params.yml"
    roslaunch microstrain_inertial_driver microstrain.launch node_name:=sensor_b_node namespace:=sensor_b params_file:="~/sensor_b_params.yml"

This will launch two nodes that publish data to different namespaces:

  • /sensor_a, connected over port: /dev/ttyACM0
  • /sensor_b, connected over port: /dev/ttyACM1

An example subscriber node can be found in the MicroStrain Examples package.

Docker Development


The easiest way to develop in docker while still using an IDE is to use VSCode. 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 Remote Containers plugin
  3. Open this directory in a container:
    1. Open the microstrain_inertial directory in VSCode
    2. Click the green >< icon in the bottom left corner of the window
    3. Choose Reopen In Container
  4. Once the project is open in the container, it will take some time to automatically install the rosdeps inside the container, you can then build and run the container by following step 4 of Building from source


If you are comfortable working from the command line, or want to produce your own 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 (only 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 development 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 runtime image that contains only the required dependencies and the ROS node.
  • make clean - Cleans up after the above two tasks

Shared codebases

Both the ros and ros2 branches share most of their code by using git submodules. The following submodules contain most of the actual implementations:

Previous Versions

Previous versions of the driver were released as tags on Github. They can also be found in specific branches:

  • ros-2.x.x contains the most recent code before the MIP SDK refactor
  • master contains the most recent code before the common codebase refactor (prior to 2.0.0)


Different packages in this repo are released under different licenses. For more information, see the LICENSE files in each of the package directories.

Here is a quick overview of the licenses used in each package:

Package License
microstrain_inertial_driver MIT
microstrain_inertial_msgs MIT
microstrain_inertial_rqt BSD
microstrain_inertial_examples MIT