3D-Gyro Simulation to control orientation of virtual object

Published July 14, 2023 © MIT

3D-Gyro Simulation to control orientation of virtual object

Arduino Nano & 3-axis MEMS sensor (MPU-6050) takes real-time motion data and controls an orientation of virtual 3D cube in Processing IDE.

IntermediateFull instructions provided2 hours1,917

3D-Gyro Simulation to control orientation of virtual object

Things used in this project

Hardware components

Arduino Nano R3

Inertial Measurement Unit (IMU) (6 deg of freedom)

Software apps and online services

Arduino IDE

The Processing Foundation Processing

Hand tools and fabrication machines

Breadboard, 400 Pin

10 Pc. Jumper Wire Kit, 5 cm Long

Story

3D-Gyro Simulation to control orientation of virtual object.

Overview:

It is an integration of Arduino Nano and MPU6050, a 3-axis MEMS accelerometer and gyroscope sensor which aims to provide an interactive and immersive experience of a gyroscope's behavior in a virtual 3D environment. It employs real-time motion data captured by the MPU6050 sensor, which measures angular motion along three axes: roll, pitch, and yaw. By unleashing the Arduino Nano's capabilities, the seamless connection between the physical sensor and the Processing IDE has been established. The Arduino Nano serves as a mediator, transmitting the motion data to the computer through a serial connection.

In the Processing IDE, the received motion data is processed and applied to manipulate the orientation of a virtual cube in a 3D space. The cube's movements correspond to the angular changes detected by the MPU6050 sensor. The simulation replicates the intricate behavior of a gyroscope, allowing users to interact with the virtual cube. As users manipulate the physical gyroscope, the virtual cube responds accordingly, accurately reflecting its motion in real-time.

This integration of hardware and software showcases the potential for creating dynamic and immersive simulations. By bridging the physical and virtual realms, the project provides a hands-on experience of interacting with a gyroscope-like object. The Processing IDE serves as the virtual canvas, where the received motion data is utilized to manipulate the virtual cube's orientation. Its powerful graphics capabilities enable the creation of a visually immersive experience.

The real-world applications of this method extend beyond simulation and gaming. The integration of Arduino Nano and MPU6050 can be leveraged in fields such as robotics, aerospace, and virtual reality, where precise motion tracking and control are crucial. The project encourages experimentation and innovation, allowing users to develop their own applications and expand upon the existing simulation. It provides a solid foundation for further exploration into gyroscope-based systems and their potential applications.

Interfacing Arduino nano & MPU6050

Make the connections as instructed below.

MPU-6050 Arduino Nano

Vcc ------------> 5v

GND ------------> GND

SCL -----------> A5

SDA -----------> A4

other pins of MPU6050 are left as it is.

Setup IDEs:

1.) Arduino IDE

Install following libraries before compiling code.

https://codeload.github.com/ElectronicCats/mpu6050/zip/refs/heads/master

https://codeload.github.com/jrowberg/i2cdevlib/zip/refs/heads/master

2.) Processing IDE

Install libraries as shown in image below.

Click on Sketch -> Import library -> Manage Libraries.

Now, download Arduino Library by "Firmata" and now it's good to go.

Note: Install both Arduino and Processing IDE. Look for the code below, there are two tabs in code section.

Code

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

#if I2CDEV_IMPLEMENTATION == I2CDEV_ARDUINO_WIRE
#include "Wire.h"
#endif

MPU6050 mpu;
#define OUTPUT_READABLE_YAWPITCHROLL
#define LED_PIN 13 
bool blinkState = false;
bool dmpReady = false;  
uint8_t mpuIntStatus;   
uint8_t devStatus;      
uint16_t packetSize;    
uint16_t fifoCount;     
uint8_t fifoBuffer[64]; 

Quaternion q;           
VectorInt16 aa;         
VectorInt16 aaReal;     
VectorInt16 aaWorld;    
VectorFloat gravity;    
float euler[3];         
float ypr[3];           
uint8_t teapotPacket[14] = { '$', 0x02, 0,0, 0,0, 0,0, 0,0, 0x00, 0x00, '\r', '\n' };

volatile bool mpuInterrupt = false;     
void dmpDataReady() {
    mpuInterrupt = true;
}

void setup() {
    
    #if I2CDEV_IMPLEMENTATION == I2CDEV_ARDUINO_WIRE
        Wire.begin();
        TWBR = 24; 
    #elif I2CDEV_IMPLEMENTATION == I2CDEV_BUILTIN_FASTWIRE
        Fastwire::setup(400, true);
    #endif

    Serial.begin(115200);
    while (!Serial); 
    mpu.initialize();
    devStatus = mpu.dmpInitialize();

    
    mpu.setXGyroOffset(220);
    mpu.setYGyroOffset(76);
    mpu.setZGyroOffset(-85);
    mpu.setZAccelOffset(1788); 

    if (devStatus == 0) {
        mpu.setDMPEnabled(true);
        attachInterrupt(0, dmpDataReady, RISING);
        mpuIntStatus = mpu.getIntStatus();       
        dmpReady = true;
        packetSize = mpu.dmpGetFIFOPacketSize();
    } else {
        
        Serial.print(devStatus);
        Serial.println(F(")"));
    }
    pinMode(LED_PIN, OUTPUT);
}


void loop() {
    if (!dmpReady) return;
    while (!mpuInterrupt && fifoCount < packetSize) {
    }

    mpuInterrupt = false;
    mpuIntStatus = mpu.getIntStatus();
    fifoCount = mpu.getFIFOCount();

    if ((mpuIntStatus & 0x10) || fifoCount == 1024) {
        mpu.resetFIFO();

    } else if (mpuIntStatus & 0x02) {
        while (fifoCount < packetSize) fifoCount = mpu.getFIFOCount();
        mpu.getFIFOBytes(fifoBuffer, packetSize);
        fifoCount -= packetSize;

        #ifdef OUTPUT_READABLE_QUATERNION
            mpu.dmpGetQuaternion(&q, fifoBuffer);
            Serial.print("quat\t");
            Serial.print(q.w);
            Serial.print("\t");
            Serial.print(q.x);
            Serial.print("\t");
            Serial.print(q.y);
            Serial.print("\t");
            Serial.println(q.z);
        #endif

        #ifdef OUTPUT_READABLE_EULER
            mpu.dmpGetQuaternion(&q, fifoBuffer);
            mpu.dmpGetEuler(euler, &q);
            Serial.print("euler\t");
            Serial.print(euler[0] * 180/M_PI);
            Serial.print("\t");
            Serial.print(euler[1] * 180/M_PI);
            Serial.print("\t");
            Serial.println(euler[2] * 180/M_PI);
        #endif

        #ifdef OUTPUT_READABLE_YAWPITCHROLL
            mpu.dmpGetQuaternion(&q, fifoBuffer);
            mpu.dmpGetGravity(&gravity, &q);
            mpu.dmpGetYawPitchRoll(ypr, &q, &gravity);
            Serial.print(ypr[2] * 18/M_PI);
            Serial.print(" ");
            Serial.print(ypr[1] * 180/M_PI);
            Serial.print(" ");
            Serial.println(ypr[0] * 180/M_PI);
        #endif

        #ifdef OUTPUT_READABLE_REALACCEL
            mpu.dmpGetQuaternion(&q, fifoBuffer);
            mpu.dmpGetAccel(&aa, fifoBuffer);
            mpu.dmpGetGravity(&gravity, &q);
            mpu.dmpGetLinearAccel(&aaReal, &aa, &gravity);
            Serial.print("areal\t");
            Serial.print(aaReal.x);
            Serial.print("\t");
            Serial.print(aaReal.y);
            Serial.print("\t");
            Serial.println(aaReal.z);
        #endif

        #ifdef OUTPUT_READABLE_WORLDACCEL
            mpu.dmpGetQuaternion(&q, fifoBuffer);
            mpu.dmpGetAccel(&aa, fifoBuffer);
            mpu.dmpGetGravity(&gravity, &q);
            mpu.dmpGetLinearAccel(&aaReal, &aa, &gravity);
            mpu.dmpGetLinearAccelInWorld(&aaWorld, &aaReal, &q);
            Serial.print("aworld\t");
            Serial.print(aaWorld.x);
            Serial.print("\t");
            Serial.print(aaWorld.y);
            Serial.print("\t");
            Serial.println(aaWorld.z);
        #endif
    
        #ifdef OUTPUT_TEAPOT
            teapotPacket[2] = fifoBuffer[0];
            teapotPacket[3] = fifoBuffer[1];
            teapotPacket[4] = fifoBuffer[4];
            teapotPacket[5] = fifoBuffer[5];
            teapotPacket[6] = fifoBuffer[8];
            teapotPacket[7] = fifoBuffer[9];
            teapotPacket[8] = fifoBuffer[12];
            teapotPacket[9] = fifoBuffer[13];
            Serial.write(teapotPacket, 14);
            teapotPacket[11]++; 
        #endif

        blinkState = !blinkState;
        digitalWrite(LED_PIN, blinkState);
    }
}

import processing.serial.*;
import cc.arduino.*;

int W = 800;
int H = 800; 

Serial port;
float Phi;
float Theta;
float Psi;

int cubeSize = 70; 
int numCubes = 3;
int spacing = 2; 

int[][][] cubeColors;

void setup() {
  size(800, 800, P3D);
  rectMode(CENTER);
  smooth();
  strokeCap(SQUARE); 

  background(255); 

  println(Serial.list());
  port = new Serial(this, Serial.list()[0], 115200);
  port.bufferUntil('\n');

  cubeColors = new int[numCubes][numCubes][numCubes];

  // Initialize the cube colors
  for (int x = 0; x < numCubes; x++) {
    for (int y = 0; y < numCubes; y++) {
      for (int z = 0; z < numCubes; z++) {
        cubeColors[x][y][z] = color(random(255), random(255), random(255));
      }
    }
  }
}

void draw() {
  background(255);
  translate(W / 2, H / 2);

  // Rotate the entire grid
  rotateX(radians(Theta));
  rotateY(radians(Phi));
  rotateZ(radians(Psi));

  // Draw the grid of cubes
  for (int x = 0; x < numCubes; x++) {
    for (int y = 0; y < numCubes; y++) {
      for (int z = 0; z < numCubes; z++) {
        pushMatrix();
        translate((x - numCubes / 2) * (cubeSize + spacing),
          (y - numCubes / 2) * (cubeSize + spacing),
          (z - numCubes / 2) * (cubeSize + spacing));
        fill(cubeColors[x][y][z]);
        box(cubeSize);
        popMatrix();
      }
    }
  }
}

void serialEvent(Serial port) 
{
  String input = port.readStringUntil('\n');
  if (input != null) {
    input = trim(input);
    String[] values = split(input, " ");
    if (values.length == 3) {
      float phi = float(values[0]);
      float theta = float(values[1]);
      float psi = float(values[2]);
      Phi = phi;
      Theta = theta;
      Psi = psi;
    }
  }
}

Credits

Anip Shah

9 projects • 4 followers

Tech enthusiast and programmer who also happens to be a Biomedical Engineer.

3D-Gyro Simulation to control orientation of virtual object

Things used in this project

Hardware components

Software apps and online services

Hand tools and fabrication machines

Story

3D-Gyro Simulation to control orientation of virtual object.

Schematics

Interfacing MPU-6050 with Arduino Nano

Code

3D-Gyro (Arduino IDE)

3D-Gyro (Processing IDE)

Credits

Anip Shah

Comments

Embed the widget on your own site

3D-Gyro Simulation to control orientation of virtual object

3D-Gyro Simulation to control orientation of virtual object

Things used in this project

Hardware components

Software apps and online services

Hand tools and fabrication machines

Story

3D-Gyro Simulation to control orientation of virtual object.

Schematics

Interfacing MPU-6050 with Arduino Nano

Code

3D-Gyro (Arduino IDE)

3D-Gyro (Processing IDE)

Credits

Anip Shah

Comments

Related channels and tags