Download MPU6050 example

This project show you how we can connect a 6DOF sensor to Unity. For this project, I used the MPU-6050 sensor, which is one of the most popular. If your sensor is different, this example shows you the main steps to follow to connect any sensor.

This package also include example with multiple MPU!

Extending libraries

To have more in formations on how to augment existing libraries, you can watch the dedicated video tutorial.

Sending IMU from Arduino to Unity

Complex sensors are complex. Luckily, talented developers provide useful libraries. To connect the IMU to Arduino, we used the powerful i2cdev library. You need to add to your Arduino libraries folder the \Arduino\I2Cdev* folder and the \Arduino\MPU6050* folder. We wire the sensor to communicates in i2c with the Arduino.

This is a simple example included with the library.

To receive the Acceleration data, just uncomment the lines in the arduino code and adapt the c# code!

#include "Uduino.h"  // Include Uduino library at the top of the sketch
Uduino uduino("IMU");

#include "I2Cdev.h"
#include "MPU6050_6Axis_MotionApps20.h"
#include "Wire.h"

MPU6050 mpu;

// MPU control/status vars
bool dmpReady = false;  // set true if DMP init was successful
uint8_t devStatus;      // return status after each device operation (0 = success, !0 = error)
uint16_t packetSize;    // expected DMP packet size (default is 42 bytes)
uint16_t fifoCount;     // count of all bytes currently in FIFO
uint8_t fifoBuffer[64]; // FIFO storage buffer

// orientation/motion vars
Quaternion q;           // [w, x, y, z]         quaternion container
VectorInt16 aa;         // [x, y, z]            accel sensor measurements
VectorInt16 aaReal;     // [x, y, z]            gravity-free accel sensor measurements
VectorInt16 aaWorld;    // [x, y, z]            world-frame accel sensor measurements
VectorFloat gravity;    // [x, y, z]            gravity vector
float euler[3];         // [psi, theta, phi]    Euler angle container
float ypr[3];           // [yaw, pitch, roll]   yaw/pitch/roll container and gravity vector

void setup() {
  Wire.setClock(400000); // 400kHz I2C clock. Comment this line if having compilation difficulties


  while (!Serial); // wait for Leonardo enumeration, others continue immediately

  devStatus = mpu.dmpInitialize();
  mpu.setXGyroOffset(54); //++
  mpu.setYGyroOffset(-21); //--

  if (devStatus == 0) {
    // set our DMP Ready flag so the main loop() function knows it's okay to use it
    dmpReady = true;
    // get expected DMP packet size for later comparison
    packetSize = mpu.dmpGetFIFOPacketSize();
  } else {
    // Error

void loop() {

  if (uduino.isInit()) {
    if (!dmpReady) {
      Serial.println("IMU not connected.");

    int  mpuIntStatus = mpu.getIntStatus();
    fifoCount = mpu.getFIFOCount();

    if ((mpuIntStatus & 0x10) || fifoCount == 1024) { // check if overflow
    } else if (mpuIntStatus & 0x02) {
      while (fifoCount < packetSize) fifoCount = mpu.getFIFOCount();

      mpu.getFIFOBytes(fifoBuffer, packetSize);
      fifoCount -= packetSize;


void SendQuaternion() {
  mpu.dmpGetQuaternion(&q, fifoBuffer);
  Serial.print(q.w, 4); Serial.print("/");
  Serial.print(q.x, 4); Serial.print("/");
  Serial.print(q.y, 4); Serial.print("/");
  Serial.println(q.z, 4);

void SendEuler() {
  // display Euler angles in degrees
  mpu.dmpGetQuaternion(&q, fifoBuffer);
  mpu.dmpGetEuler(euler, &q);
  Serial.print(euler[0] * 180 / M_PI); Serial.print("/");
  Serial.print(euler[1] * 180 / M_PI); Serial.print("/");
  Serial.println(euler[2] * 180 / M_PI);

void SendYawPitchRoll() {
  // display Euler angles in degrees
  mpu.dmpGetQuaternion(&q, fifoBuffer);
  mpu.dmpGetGravity(&gravity, &q);
  mpu.dmpGetYawPitchRoll(ypr, &q, &gravity);
  Serial.print(ypr[0] * 180 / M_PI); Serial.print("/");
  Serial.print(ypr[1] * 180 / M_PI); Serial.print("/");
  Serial.println(ypr[2] * 180 / M_PI);

void SendRealAccel() {
  // display real acceleration, adjusted to remove gravity
  mpu.dmpGetQuaternion(&q, fifoBuffer);
  mpu.dmpGetAccel(&aa, fifoBuffer);
  mpu.dmpGetGravity(&gravity, &q);
  mpu.dmpGetLinearAccel(&aaReal, &aa, &gravity);
  Serial.print(aaReal.x); Serial.print("/");
  Serial.print(aaReal.y); Serial.print("/");

void SendWorldAccel() {
  // display initial world-frame acceleration, adjusted to remove gravity
  // and rotated based on known orientation from quaternion
  mpu.dmpGetQuaternion(&q, fifoBuffer);
  mpu.dmpGetAccel(&aa, fifoBuffer);
  mpu.dmpGetGravity(&gravity, &q);
  mpu.dmpGetLinearAccel(&aaReal, &aa, &gravity);
  mpu.dmpGetLinearAccelInWorld(&aaWorld, &aaReal, &q);
  Serial.print(aaWorld.x); Serial.print("/");
  Serial.print(aaWorld.y); Serial.print("/");

If you add some Serial.print commands in the setup function, it might break Uduino auto-detection process

Now we need to add Uduino library in this sketch to send the values to Unity. First, we create an Uduino object named "IMU". At this stage, you can test the code in the Arduino serial monitor. Everything should work as expected.

#include "Uduino.h"  // Include Uduino library at the top of the sketch
Uduino uduino("IMU");

Then, we keep the same Arduino code and add uduino.update() in the loop function.
To write the values only when the board is connected, we add the condition uduino.isConnected(). Some delay may be added to not overflow the serial.

void loop() {
  uduino.update(); // This part is needed to be detected by Unity. 

  if (uduino.isConnected()) {
   // All the code previously in the loop() function

The values have to be written in the same line. Serial.println should be called only once, ad the send of the loop.

If you are using Uduino Wifi, replace Serial.println by duino.println.

Get sensor values on Unity

In Arduino, the code is printing the values in the loop. We use the delegate OnDataReceived to continuously read the values coming from the serial.

void Start () {
      UduinoManager.Instance.OnDataReceived += ReadIMU;

The ReadIMU will parse the data to use them with unity. The string we receive has the format x/y/z/gx/gy/gz so it needs to be separated (by the character '/' ) and parse in a float.

    public void ReadIMU (string data, UduinoDevice device) {
        string[] values = data.Split('/');
        if (values.Length == 5 && values[0] == imuName) // Rotation of the first one 
            float w = float.Parse(values[1]);
            float x = float.Parse(values[2]);
            float y = float.Parse(values[3]);
            float z = float.Parse(values[4]);
            this.transform.localRotation = Quaternion.Lerp(this.transform.localRotation,  new Quaternion(w, y, x, z), Time.deltaTime * speedFactor);
        } else if (values.Length != 5)
        this.transform.parent.transform.eulerAngles = rotationOffset;
      //  Log.Debug("The new rotation is : " + transform.Find("IMU_Object").eulerAngles);

Set default orientation

The IMU usually have a default rotation. To fix that, we added a boolean that will set the rotation offset.

   public bool setOrigin = false;
   Quaternion rotOffset = Quaternion.identity;

   void Update()
            rotOffset = this.transform.rotation;
            setOrigin = false;

   void ReadIMU (string data, UduinoDevice device) {
    this.transform.rotation = new Quaternion(w, x, y, z) * Quaternion.Inverse(rotOffset);