PID Control Made Simple

In this tutorial, I’ll explain how PID (Proportional-Integral-Derivative) Control works using an analogy.

Imagine we are the captain of a ship. We want the boat to maintain a heading of due north automatically, without any human intervention.

compass_direction_magnetic_compass

We go out and hire a smart robotics software engineer to write a control algorithm for the ship. 

The variable that we want to control is the ship’s heading, and we want to make sure the heading maintains a “set point” of due north (e.g. 0 degrees).

Proportional Control

  • If the ship is heading slightly off course to the left, we want the ship to steer slightly to the right.
  • If the ship is heading slightly off course to the right, we want the ship to steer slightly to the left.
  • If the ship is heading strongly off course to the left, we want the ship to steer strongly to the right.
  • If the ship is heading strongly off course to the right, we want the ship to steer strongly to the left.

In short, the steering magnitude is directly proportional to the difference between the desired heading and the current heading. The further you are off course, the harder the ship steers.

Mathematically, proportional control is: 

Control Output  = Kp * (Desired – Actual)

Where:

  • Control Output is what you want to control (e.g. steering intensity, speed, etc.)
  • Kp is some non-negative constant
  • Desired = Set Point (e.g. the heading you want to achieve…i.e. 0 degrees north)
  • Actual = Process Variable (e.g. the heading you measured)
  • Error = Desired – Actual

The Proportional term is all about adjusting the output based on the present error.

Integral Control

Now let’s suppose that there is a crosswind. Even though the ship is adjusting the steering in proportion to the heading error, there are still differences between the actual and desired heading that are accumulating over time as a result of this ongoing crosswind. 

The ship continues to drift off course even though proportional control is being applied.

The integral term looks for the residual error that is generated even after proportional control is applied. In this example, the residual error is caused by the wind, and it keeps adding up over time. The integral term seeks to get rid of this residual error by incorporating the historical cumulative value of the error. As the error decreases, the integral term will decrease.

Integral control looks for factors that keep pushing the ship off course and adjusts accordingly.

Mathematically, we now have to add the Integral term.

Control Output  = Kp * Error + Ki * Sum of Errors Over Time

The Integral term is all about adjusting the output based on the past error.

Derivative Control

Let’s suppose that the ship is steering hard to the left in order to correct the heading. You don’t want the ship to steer so hard that momentum causes the ship to overshoot your desired heading. 

What you want to do is have the ship slow down the steering as it approaches the heading. 

The derivative term of PID control does this. It is used to slow down the heading correction as the measured heading approaches the desired heading. This derivative term helps the ship avoid overshooting.

Mathematically, we now have to add the Derivative term to get the final PID Control equation:

Control Output  = Kp * Error + Ki * Sum of Errors Over Time + Kd * Rate of Change of the Error with Respect to Time

1-pid-control
How all of the PID control constants combine to generate the desired control response

The Derivative term is all about adjusting the output based on the future (predicted) error. If the error is decreasing too quickly with respect to time, this term will reduce the control output.

How To Set up a ROS2 Project for Python – Foxy Fitzroy

In this tutorial, we will learn how to set up a ROS2 project from scratch.

Prerequisites

Source Your ROS2 Installation

We first need to create a new workspace. A workspace is a folder that will contain all your ROS packages.

Here is the official tutorial, but I’ll walk through all the steps below.

Open a new terminal window.

To find out which version of ROS2 you have installed, type the following command:

printenv ROS_DISTRO

I’m using the foxy distribution of ROS2.

Now, let’s source the ROS2 environment. Type the following command:

source /opt/ros/foxy/setup.bash

Create a Workspace

Let’s create a workspace directory. “-p” is short for “–parents”. This flag makes sure the mkdir (“make directory”) command makes the parent /dev_ws/ folder as well as the /src/ folder within it (Feel free to check out my Linux commands tutorial).

mkdir -p ~/dev_ws/src
cd ~/dev_ws/src

The syntax is:

mkdir -p ~/<yourworkspace>_ws/src

cd ~/<yourworkspace>_ws/src

Create a Package

Now let’s create a ROS package.

We will use the following syntax.

ros2 pkg create –build-type ament_python <package_name>

Type this command:

ros2 pkg create --build-type ament_python my_package

Your package named my_package has now been created.

Build Your Package

Return to the root of your workspace:

cd ~/dev_ws

Build all packages in the workspace.

colcon build

If you only want to build my_package, you can type

colcon build --packages-select my_package

Source the Setup File

Open a new terminal window.

Source your ROS2 installation.

source /opt/ros/foxy/setup.bash

Move to your workspace folder.

cd ~/dev_ws

Add the files you just created to the path.

source install/setup.bash

If you don’t have gedit installed, install it using this command:

sudo apt-get install gedit

Open your .bashrc file.

gedit ~/.bashrc

Add this line of code to the very bottom of the file.

source /opt/ros/foxy/setup.bash

You now don’t have to source your ROS2 installation every time you open a new terminal window.

While you’re at it add this line of code to the very bottom of the .bashrc file.

source ~/dev_ws/install/setup.bash

The syntax is

source ~/<your_workspace>/install/setup.bash

Save the file, and close it.

Your system now knows where to find your ROS2 packages.

Write Node(s)

Move to the dev_ws/src/my_package/my_package folder.

cd dev_ws/src/my_package/my_package

Write a Python program (i.e. node), and add it to this folder you’re currently in. This post has some sample code you can use. Copy the Publisher Node code, and paste it into a file named my_python_script.py.

gedit my_python_script.py

Save the file and close it.

Now change the permissions on the file.

chmod +x my_python_script.py

Make sure that the names of your python nodes are not the same as the name of the package. Otherwise, you will have ImportErrors.

You can add as many Python programs as you like. For example, you might have one node that defines a class, and then you have another node that imports that class and uses it to make calculations, which are then published to a ROS2 topic as some data type (e.g. Float64, geometry_msgs/Twist, etc.).

Add Dependencies

Navigate one level back.

cd ..

You are now in the dev_ws/src/my_package/ directory. 

Type 

ls

You should see the setup.py, setup.cfg, and package.xml files.

Open package.xml with your text editor.

gedit package.xml

Fill in the <description>, <maintainer>, and <license> tags.

Add a new line after the ament_python build_type dependency and add the following dependencies which will correspond to other packages the packages in this workspace needs (this will be in your node’s import statements):

<exec_depend>rclpy</exec_depend>
<exec_depend>geometry_msgs</exec_depend>

This let’s the system know that this package needs the rclpy and geometry_msgs packages when its code is executed. 

The code doesn’t need the geometry_msgs package, but I’m having you add it anyway just to show you that you can add all sorts of message types in this package.xml file.

Save the file.

Add an Entry Point

Now we need to add the entry points for the node(s) by opening the setup.py file.

gedit setup.py

Make sure this code is in there:

entry_points={
        'console_scripts': [
                'my_python_script = my_package.my_python_script:main',
        ],
},

The syntax is:

‘my_python_script = my_package.my_python_script:main’

my_python_script will be the name of the executable.

‘my_package.my_python_script:main’ tells the system to execute the main() function inside my_python_script.py. Therefore, this will be the entry point when you run your node.

The executable script will go to:

~/dev_ws/install/my_package/lib/my_package/

Save setup.py and close it.

Check for Missing Dependencies

Check for any missing dependencies before you build the package.

Move to your workspace folder.

cd ~/dev_ws

Run the following command:

rosdep install -i --from-path src --rosdistro <distro> -y

For example:

rosdep install -i --from-path src --rosdistro foxy -y

I get a message that says:

“#All required rosdeps installed successfully”

Build and Run

Now, build your package by first moving to the src folder.

cd src

Then build the package.

colcon build --packages-select my_package

You should get a message that says:

“Summary: 1 package finished [<time it took in seconds>]”

Open a new terminal tab.

cd ~/dev_ws

Run the node:

ros2 run my_package my_python_script

The syntax is:

ros2 run <package_name> <node name without the .py>

Open a new terminal tab, and move to the root directory of the workspace.

cd ~/dev_ws

List the active topics.

ros2 topic list -t

To listen to any topic, type:

ros2 topic echo /topic_name

Where you replace “/topic_name” with the name of the topic. 

When you’ve had enough, type Ctrl+C in each terminal tab to stop the nodes from spinning.

Zip the Workspace for Distribution

If you ever want to zip the whole workspace and send it to someone, open a new terminal window.

Move to the directory containing your workspace.

cd ~/dev_ws
cd ..
zip -r myros2workspace.zip /dev_ws

The syntax is:

zip -r <filename.zip> <foldername>

How to Send Roll, Pitch, & Yaw Data Over I2C From Arduino to Raspberry Pi

In this post, I’ll show you how to send roll, pitch, and yaw data over I2C using Raspberry Pi and Arduino. We’ll also capture GPS data on the Raspberry Pi to make things interesting for when I mount everything on a quadcopter.

Requirements

Here are the requirements:

  • Using the IMU connected to the Arduino, capture roll, pitch, and yaw data.
  • Using the GPS connected to the Raspberry Pi, capture latitude, longitude, and altitude data.
  • Send the IMU data via I2C to the Raspberry Pi.
  • Send the IMU and GPS data via Bluetooth from Raspberry Pi to my host computer (e.g. my personal laptop).
  • Display the data on my host computer.
  • To make things interesting, I mounted all the equipment on a quadcopter.

Design

Hardware

The following components are used in this project. You will need:

Software

Here are the steps for the GPS Poller, responsible for capturing Latitude+Longitude+Altitude data on the Raspberry Pi:

  • Open a new file to log the GPS data
  • Create a GPS Poller class
  • Log the latitude data
  • Log the longitude data
  • Log the altitude in feet
  • Delay 5 seconds
  • Close file

Here are the steps for the IMU I2C program on the Arduino, responsible for capturing Roll+Pitch+Yaw data and sending to the Raspberry Pi:

  • Set the delay between fresh samples
  • Define a flag to stop the program
  • Make the Arduino a slave to the Raspberry Pi by defining a slave address
  • Declare a byte array of size 12, which will be the roll+pitch+yaw data (with the sign) to send back to Raspberry Pi
  • Declare variables used for digit extraction
  • Declare function to end the program
  • Display some basic information on the IMU sensor
  • Display some basic info about the sensor status
  • Display sensor calibration status
  • Create method that sends a byte array (of size 12) when reading request is received from the Raspberry Pi
  • Create method that retrieves the digit of any position in an integer. The rightmost digit has position 0. The second rightmost digit has position 1, etc. e.g. Position 3 of integer 245984 is 5.
  • Create Arduino setup function (automatically called at startup) — 9600 Baud Rate
  • Initialize the sensor
  • Set up the Wire library and make Arduino the slave
  • Define the callbacks for i2c communication
  • Need callback that specifies a function when data is received from the RPi Master
  • Need callback that specifies a function when the Master requests data from the Arduino
  • Arduino loop function, called once ‘setup’ is complete
  • While not done:
    • Get a new sensor event
    • Display the floating point data and capture the roll, pitch, and yaw data. Cast the floats to signed integers.
    • Store each digit of the roll, pitch, and yaw data into a byte array (which will be sent to the RPi)
    • End program
  • While true infinite loop

Here are the steps for the I2C Python program on the Raspberry Pi, responsible for sending messages and requesting IMU data via I2C from the Arduino slave:

  • Open a new text file to log the IMU data
  • Set up slave address in the Arduino Program
  • Read a block of 12 bytes starting at SLAVE_ADDRESS, offset 0
  • Extract the IMU reading data
  • Print the IMU data to the console
  • Write the IMU data to the text file
  • Close text file when done
  • Request IMU data every 5 seconds from the Arduino

Implementation

The most straightforward way to connect the Arduino board to the Raspberry Pi is using the USB cable, as I have done in previous projects. However, we can also use I2C. I2C uses two lines: SDA (data) and SCL (clock). It also uses GND (ground).

Here are the connections that I made between the Raspberry Pi and the Arduino:

  • Raspberry Pi SDA (I2C1 SDA) –> Arduino SDA
  • Raspberry Pi SCL (I2C1 SCL) –> Arduino SCL
  • Raspberry Pi GND –> Arduino GND
imu_i2c_1

Raspberry Pi 3 Pin Mappings. Image Source: Microsoft.com

imu_i2c_2

Arduino Uno Pin Mappings. Image Source: Electronics Schematics

Here is the schematic I followed.

imu_i2c_3

Image Source: Monk (2016)

The BNO055 (IMU) was wired to the Arduino Uno using the solderless breadboard as follows:

  • Connected Vin to the power supply of 5V
  • Connected GND to common power/data ground
  • Connected the SDA pin to the I2C data SDA pin on the Arduino (A4).
  • Connected the SCL pin to the I2C clock SCL pin on the Arduino (A5).

To get started with the implementation, I tested the GPS device to see if I can successfully capture GPS latitude + longitude + altitude data on the Raspberry Pi and save it to a text file. This data will later get sent via Bluetooth from Raspberry Pi to my Host computer (HP Omen laptop with Windows 10).

GPS was connected to the Raspberry Pi via the USB cord. The commands for this are as follows:

To start the GPS stream, I typed:

sudo gpsd /dev/ttyAMA0 -F /var/run/gpsd.sock

To display the GPS data, I typed the following command:

cgps -s

Here is what the display looked like:

imu_i2c_4

Other commands I could have run are gpsmon and xgps.

gpsmon looks like this:

imu_i2c_5

xgps looks like this:

imu_i2c_6

Sometimes the GPS data did not show up immediately. When that occurred, I rebooted the Raspberry Pi by typing the following command:

sudo reboot

I typed the following command to shutdown the GPS stream:

sudo killall gpsd

Now, I want to do the same thing, but this time I want to save the GPS data to a text file. I will use this syntax in the command terminal in order to save the standard output stream to a text file.

command | tee output.txt

More specifically, I will type:

cgps -s | tee /home/pi/Documents/GPS/output.txt

The output.txt was created, and the data was logged in the file. However, it is more useful to output the GPS data in a more user-friendly format. To do this, I will run a Python script that is a GPS polling program. The code for this program is located in the Software section later in this report.

To create the program, I opened the Python IDE (Raspberry Pi -> Programming -> Python 3 (IDLE)).

I clicked File -> New File. I then added the code and saved the file as GPSPoller.py.

imu_i2c_7

To run the script, I typed

python GPSPoller.py

To stop the script, I pressed Ctrl-C. I could have also pressed Ctrl-Pause/Break.

imu_i2c_8

Here is the output of the locations.csv file. For the actual code when I flew the quadcopter, this file was named gps_data.txt.

imu_i2c_9

Here is how gps_data.txt looks:

gps_data

Next I connected Arduino to Raspberry Pi via I2C as pictured earlier in this section. I also connected them via USB in order to provide the Arduino with power and to easily upload sketches to the Arduino. BNO055 connects to Arduino.

Next, I followed the instructions inMonk (2016) to make the Arduino the Slave, and the Raspberry Pi the Master. I needed to write code for both the Arduino and the Raspberry Pi in order for them to communicate with each other via I2C (The code for Arduino and Raspberry Pi are in the Software section later in this report).

After writing the Arduino code for I2C communication and IMU data capture, I uploaded the code to the board. I then needed to enable I2C on the Raspberry Pi. I configured Raspberry Pi accordingly by going to Preferences under the main menu, and then clicking Raspberry Pi Configuration -> Interfaces -> Enable I2C.

I now installed the Python I2C library by using the command:

sudo apt-get install python-smbus

It was already installed. I then clicked:

sudo reboot

I had my Arduino Uno attached to the Raspberry Pi via I2C. I wanted to check that it’s attached and find its I2C address.

From a Terminal window on my Raspberry Pi, I typed the following commands to fetch and install the i2c-tools:

sudo apt-get install i2c-tools

It was already installed.

Next, I ran the following command:

$ sudo i2cdetect -y 1
imu_i2c_10

Next, I needed to write the code in Python that the Raspberry Pi can use to make requests for IMU data from the Arduino. That code, as I mentioned above, is in the Software section of this post. I will run this Python script in the terminal window and redirect the IMU data response from the Arduino slave to a text file.

The command to run the Python program is as follows:

sudo python ardu_pi_i2c_imu.py

A file named imu_data.txt will capture the Roll+Pitch+Yaw data. Here is how the data looks:

imu_data

Hardware

imu_i2c_hw 2
imu_i2c_hw 3

Software

Here is the Python script that logs the GPS latitude + longitude + altitude data into a text file on the Raspberry Pi. Don’t be scared at how long the code is. Just copy and paste it into your file:

from gps import *
import time
import threading

# Source: Donat, Wolfram. "Make a Raspberry Pi-controlled Robot :
# Building a Rover with Python, Linux, Motors, and Sensors.
# Sebastopol, CA: Maker Media, 2014. Print.
# Modified by Addison Sears-Collins
# Date April 17, 2019

# Open a new file to log the GPS data
f = open("gps_data.txt", "w")

gpsd = None

# Create a GPS Poller class. 
class GpsPoller(threading.Thread):
  def __init__(self):
    threading.Thread.__init__(self)
    global gpsd
    gpsd = gps(mode=WATCH_ENABLE)
    self.current_value = None
    self.running = True

  def run(self):
    global gpsd
    while gpsp.running:
      gpsd.next()

if __name__ == '__main__':
  gpsp = GpsPoller()
  try:
    gpsp.start()
    while True:
      f.write("Lat: " + str(gpsd.fix.latitude) # Log the latitude data
      + "\tLon: " + str(gpsd.fix.longitude) # Log the longitude data
      + "\tAlt: " + str(gpsd.fix.altitude / .3048) # Log the altitude in feet
      + "\n")
      time.sleep(5)
  except(KeyboardInterrupt, SystemExit):
    f.close()
    gpsp.running = False
    gpsp.join()

Here is the code for the IMU I2C program on the Arduino, responsible for capturing Roll+Pitch+Yaw data and sending to the Raspberry Pi:

#include <Wire.h>
#include <Adafruit_Sensor.h>
#include <Adafruit_BNO055.h>
#include <utility/imumaths.h>

/* This driver uses the Adafruit unified sensor library (Adafruit_Sensor),
   which provides a common 'type' for sensor data and some helper functions.

   To use this driver you will also need to download the Adafruit_Sensor
   library and include it in your libraries folder.

   You should also assign a unique ID to this sensor for use with
   the Adafruit Sensor API so that you can identify this particular
   sensor in any data logs, etc.  To assign a unique ID, simply
   provide an appropriate value in the constructor below (12345
   is used by default in this example).

   Connections
   ===========
   Connect SCL to analog 5
   Connect SDA to analog 4
   Connect VDD to 3-5V DC
   Connect GROUND to common ground

   History
   =======
   2015/MAR/03  - First release (KTOWN)
   2015/AUG/27  - Added calibration and system status helpers

   @Author Modified by Addison Sears-Collins
   @Date   April 17, 2019
*/

/* Set the delay between fresh samples */
#define BNO055_SAMPLERATE_DELAY_MS (100)

Adafruit_BNO055 bno = Adafruit_BNO055(55);

// Flag used to stop the program
bool done = false;

// Make the Arduino a slave to the Raspberry Pi
int SLAVE_ADDRESS = 0X04;

// Toggle in-built LED for verifying program is working
int ledPin = 13;

// Data to send back to Raspberry Pi
byte imu_data[] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};

// Variables used for digit extraction
int roll = 0;
int pitch = 0;
int yaw = 0;

// Initialize the LED. This is used for testing.
boolean ledOn = false;

/**************************************************************************/
/*
    This function ends the program
*/
/**************************************************************************/

void end_program() {
    
    // Used for reading data from the serial monitor
    char ch;

    // Check to see if ! is available to be read
    if (Serial.available()) {

    // Read the character
    ch = Serial.read();

    // End the program if exclamation point is entered in the serial monitor
    if (ch == '!') {
      done = true;
      Serial.println("Finished recording Roll+Pitch+Yaw data. Goodbye.");
    }
  } 
}

/**************************************************************************/
/*
    Displays some basic information on this sensor from the unified
    sensor API sensor_t type (see Adafruit_Sensor for more information)
*/
/**************************************************************************/
void displaySensorDetails(void)
{
  sensor_t sensor;
  bno.getSensor(&sensor);
  Serial.println("------------------------------------");
  Serial.print  ("Sensor:       "); Serial.println(sensor.name);
  Serial.print  ("Driver Ver:   "); Serial.println(sensor.version);
  Serial.print  ("Unique ID:    "); Serial.println(sensor.sensor_id);
  Serial.print  ("Max Value:    "); Serial.print(sensor.max_value); Serial.println(" xxx");
  Serial.print  ("Min Value:    "); Serial.print(sensor.min_value); Serial.println(" xxx");
  Serial.print  ("Resolution:   "); Serial.print(sensor.resolution); Serial.println(" xxx");
  Serial.println("------------------------------------");
  Serial.println("");
  delay(500);
}

/**************************************************************************/
/*
    Display some basic info about the sensor status
*/
/**************************************************************************/
void displaySensorStatus(void)
{
  /* Get the system status values (mostly for debugging purposes) */
  uint8_t system_status, self_test_results, system_error;
  system_status = self_test_results = system_error = 0;
  bno.getSystemStatus(&system_status, &self_test_results, &system_error);

  /* Display the results in the Serial Monitor */
  Serial.println("");
  Serial.print("System Status: 0x");
  Serial.println(system_status, HEX);
  Serial.print("Self Test:     0x");
  Serial.println(self_test_results, HEX);
  Serial.print("System Error:  0x");
  Serial.println(system_error, HEX);
  Serial.println("");
  delay(500);
}

/**************************************************************************/
/*
    Display sensor calibration status
*/
/**************************************************************************/
void displayCalStatus(void)
{
  /* Get the four calibration values (0..3) */
  /* Any sensor data reporting 0 should be ignored, */
  /* 3 means 'fully calibrated" */
  uint8_t system, gyro, accel, mag;
  system = gyro = accel = mag = 0;
  bno.getCalibration(&system, &gyro, &accel, &mag);

  /* The data should be ignored until the system calibration is > 0 */
  Serial.print("\t");
  if (!system)
  {
    Serial.print("! ");
  }

  /* Display the individual values */
  Serial.print("Sys:");
  Serial.print(system, DEC);
  Serial.print(" G:");
  Serial.print(gyro, DEC);
  Serial.print(" A:");
  Serial.print(accel, DEC);
  Serial.print(" M:");
  Serial.print(mag, DEC);
}

/**************************************************************************/
/*
    Callback for received data
*/
/**************************************************************************/

void processMessage(int n) {

  char ch = Wire.read();
  if (ch == 'l') {
    toggleLED();
  }
}

/**************************************************************************/
/*
    Method to toggle the LED. This is used for testing.
*/
/**************************************************************************/

void toggleLED() {
  ledOn = ! ledOn;
  digitalWrite(ledPin, ledOn);
  
}

/**************************************************************************/
/*
    Code that executes when request is received from Raspberry Pi
*/
/**************************************************************************/

void sendIMUReading() {
  Wire.write(imu_data, 12); 
}

/**************************************************************************/
/*
    Retrieves the digit of any position in an integer. The rightmost digit
    has position 0. The second rightmost digit has position 1, etc.
    e.g. Position 3 of integer 245984 is 5.
*/
/**************************************************************************/

byte getDigit(int num, int n) {
  int int_digit, temp1, temp2;
  byte byte_digit;

  temp1 = pow(10, n+1);
  int_digit = num % temp1;

  if (n > 0) {
    temp2 = pow(10, n);
    int_digit = int_digit / temp2;
  }

  byte_digit = (byte) int_digit;

  return byte_digit;
}

    
/**************************************************************************/
/*
    Arduino setup function (automatically called at startup)
*/
/**************************************************************************/
void setup(void)
{
  Serial.begin(9600);
  Serial.println("Orientation Sensor Test"); Serial.println("");

  /* Initialise the sensor */
  if(!bno.begin())
  {
    /* There was a problem detecting the BNO055 ... check your connections */
    Serial.print("Ooops, no BNO055 detected ... Check your wiring or I2C ADDR!");
    while(1);
  }

  delay(1000);

  /* Display some basic information on this sensor */
  displaySensorDetails();

  /* Optional: Display current status */
  displaySensorStatus();

  bno.setExtCrystalUse(true);

  pinMode(ledPin, OUTPUT); // This is used for testing.

  Wire.begin(SLAVE_ADDRESS); // Set up the Wire library and make Arduino the slave
  
  /* Define the callbacks for i2c communication */
  Wire.onReceive(processMessage); // Used to specify a function when data received from Master
  Wire.onRequest(sendIMUReading); // Used to specify a function when the Master requests data
  
}

/**************************************************************************/
/*
    Arduino loop function, called once 'setup' is complete
*/
/**************************************************************************/
void loop(void)
{

  while (!done) {
    /* Get a new sensor event */
    sensors_event_t event;
    bno.getEvent(&event);

    /* Display the floating point data */
    Serial.print("Yaw: ");
    yaw = (int) event.orientation.x;
    Serial.print(yaw);
    if (yaw < 0) {
      imu_data[8] = 1;  // Capture the sign information
      yaw = abs(yaw);
    }
    else {
      imu_data[8] = 0;
    }
    if (yaw > 360) {
      yaw = yaw - 360; // Calculate equivalent angle
    } 
    
    Serial.print("\tPitch: ");
    pitch = (int) event.orientation.y;
    Serial.print(pitch);
    if (pitch < 0) {
      imu_data[4] = 1;   // Capture the sign information
      pitch = abs(pitch);
    }
    else {
      imu_data[4] = 0;
    }
    
    Serial.print("\tRoll: ");
    roll = (int) event.orientation.z; 
    Serial.print(roll);
    if (roll < 0) {
      imu_data[0] = 1;    // Capture the sign information
      roll = abs(roll);
    }    
    else {
      imu_data[0] = 0;
    }

    /* Optional: Display calibration status */
    displayCalStatus();

    /* Optional: Display sensor status (debug only) */
    //displaySensorStatus();

    /* New line for the next sample */
    Serial.println("");

    /* Update the IMU data by extracting each digit from the raw data */
    imu_data[1] = getDigit(roll, 2);
    imu_data[2] = getDigit(roll, 1);
    imu_data[3] = getDigit(roll, 0);
    imu_data[5] = getDigit(pitch, 2);
    imu_data[6] = getDigit(pitch, 1);
    imu_data[7] = getDigit(pitch, 0);
    imu_data[9] = getDigit(yaw, 2);
    imu_data[10] = getDigit(yaw, 1);
    imu_data[11] = getDigit(yaw, 0);

    /* Wait the specified delay before requesting nex data */
    delay(BNO055_SAMPLERATE_DELAY_MS);

    end_program();

  }
         
  // Do nothing
  while (true){};

}

Here is the code for the I2C Python program on the Raspberry Pi, responsible for sending messages and requesting IMU data via I2C from the Arduino slave:

import smbus
import time
# Created by Addison Sears-Collins
# April 17, 2019
# Open a new file to log the IMU data
f = open("imu_data.txt", "w")

# for RPI version 1, use bus = smbus.SMBus(0)
bus = smbus.SMBus(1)

# This is the address we setup in the Arduino Program
SLAVE_ADDRESS = 0x04

def request_reading():
  # Read a block of 12 bytes starting at SLAVE_ADDRESS, offset 0
  reading = bus.read_i2c_block_data(SLAVE_ADDRESS, 0, 12)

  # Extract the IMU reading data
  if reading[0] < 1:
    roll_sign = "+"
  else:
    roll_sign = "-"
  roll_1 = reading[1]
  roll_2 = reading[2]
  roll_3 = reading[3]

  if reading[4] < 1:
    pitch_sign = "+"
  else:
    pitch_sign = "-"    
  pitch_1 = reading[5]
  pitch_2 = reading[6]
  pitch_3 = reading[7]

  if reading[8] < 1:
    yaw_sign = "+"
  else:
    yaw_sign = "-" 
  yaw_1 = reading[9]
  yaw_2 = reading[10]
  yaw_3 = reading[11]

  # Print the IMU data to the console
  print("Roll: " + roll_sign + str(roll_1) + str(roll_2) + str(roll_3) +
        "   Pitch: " + pitch_sign + str(pitch_1) + str(pitch_2) + str(pitch_3) +
        "   Yaw: " + yaw_sign + str(yaw_1) + str(yaw_2) + str(yaw_3))

  try:
    f.write("Roll: " + roll_sign + str(roll_1) + str(roll_2) + str(roll_3) +
        "   Pitch: " + pitch_sign + str(pitch_1) + str(pitch_2) + str(pitch_3) +
        "   Yaw: " + yaw_sign + str(yaw_1) + str(yaw_2) + str(yaw_3) + "\n")
  except(KeyboardInterrupt, SystemExit):
    f.close()

# Request IMU data every 5 seconds from the Arduino
while True:
  # Used for testing: command = raw_input("Enter command: l - toggle LED, r - read IMU ")
    # if command == 'l' :
    #   bus.write_byte(SLAVE_ADDRESS, ord('l'))
    # elif command == 'r' :
  request_reading()
  time.sleep(5)

Video