Ananya's Portfolio - IMU

Lab 6: Orientation Control

2026-03-16T00:00:00+00:00

Lab 6: Orientation Control</h1>
The goal of this lab was to get the robot, Meep, to be able to turn to a specified orientation, and maintain that position when encountering disturbances. I implement and tune a PI controller that shows success in varying terain conditions. A PID or Proportional, Inetegral, and Derivative controller is a controller that adjusts the PWM signal based on the bots current error from a set point. In this lab, the setpoint is a given orientation angle and the error is the difference between estimated angle (via IMU readings) and the setpoint. The proportion term is important for obvious reasons. I also implemented the integral term to help with steady error and make the controller more effective on varying floor conditions (as discussed below).</p>

Prelab: Data transfer</h2>

One of the major decisions of this lab way how to tranfer data. Transferring each piece of data in the control loop would slow the loop down, resulting in slower updates and slower reaction time. Trying to store all the data is limited by the maximum storage of the Artemis. I decide to store all my values and transmit after PID has stopped. This results in a long waiting time when PID is stopped, but allows the code to loop fast while in the PID loop. I allow the buffer to override the inital values if the controller tries to save more values than the set max buffer length but set the buffer length to the largest number possible to prevent this case from occurring. I parse this data into python lists like I have in previous labs and save them to a CSV for the future.</p>

case PID_STOP: </span>{</span></span>
  // Stop PID and motors</span></span>
  pid_running </span>=</span> false</span>;</span></span>
  analogWrite</span>(</span>AB1_left</span>,</span>0</span>);</span> </span></span>
  analogWrite</span>(</span>AB2_left</span>,</span>0</span>);</span></span>
  analogWrite</span>(</span>AB1_right</span>,</span>0</span>);</span> </span></span>
  analogWrite</span>(</span>AB2_right</span>,</span>0</span>);</span></span>
</span>
  // Transfer Data</span></span>
  for</span> (</span>int</span> j </span>=</span> 0</span>;</span> j </span><</span> i</span>;</span> j</span>++</span>){</span></span>
    tx_estring_value</span>.</span>clear</span>();</span></span>
    tx_estring_value</span>.</span>append</span>(</span>time_stamps</span>[</span>j</span>]);</span></span>
    tx_estring_value</span>.</span>append</span>(</span>":"</span>);</span></span>
    tx_estring_value</span>.</span>append</span>(</span>roll_readings</span>[</span>j</span>]);</span></span>
    tx_estring_value</span>.</span>append</span>(</span>":"</span>);</span></span>
    tx_estring_value</span>.</span>append</span>(</span>pitch_readings</span>[</span>j</span>]);</span></span>
    tx_estring_value</span>.</span>append</span>(</span>":"</span>);</span></span>
    tx_estring_value</span>.</span>append</span>(</span>yaw_readings</span>[</span>j</span>]);</span></span>
    tx_estring_value</span>.</span>append</span>(</span>":"</span>);</span></span>
    tx_estring_value</span>.</span>append</span>(</span>p_data</span>[</span>j</span>]);</span></span>
    tx_estring_value</span>.</span>append</span>(</span>":"</span>);</span></span>
    tx_estring_value</span>.</span>append</span>(</span>i_data</span>[</span>j</span>]);</span></span>
    tx_estring_value</span>.</span>append</span>(</span>":"</span>);</span></span>
    tx_estring_value</span>.</span>append</span>(</span>d_data</span>[</span>j</span>]);</span></span>
    tx_estring_value</span>.</span>append</span>(</span>":"</span>);</span></span>
    tx_estring_value</span>.</span>append</span>(</span>motor_data</span>[</span>j</span>]);</span></span>
    tx_estring_value</span>.</span>append</span>(</span>":"</span>);</span></span>
    tx_estring_value</span>.</span>append</span>(</span>setpoint_angle</span>[</span>j</span>]);</span></span>
    tx_characteristic_string</span>.</span>writeValue</span>(</span>tx_estring_value</span>.</span>c_str</span>());</span></span>
</span>
    // drain the DMP FIFO so the chip doesn't crash</span></span>
    if</span> (</span>myICM</span>.</span>status</span> =</span> ICM_20948_Stat_FIFOMoreDataAvail</span>) {</span></span>
      myICM</span>.</span>readDMPdataFromFIFO</span>(</span>&</span>imu_data</span>);</span></span>
    }</span></span>
  }</span></span>
</span>
  // Signal that the data is done sending</span></span>
  tx_estring_value</span>.</span>clear</span>();</span></span>
  tx_estring_value</span>.</span>append</span>(</span>"Done"</span>);</span></span>
  tx_characteristic_string</span>.</span>writeValue</span>(</span>tx_estring_value</span>.</span>c_str</span>());</span>          </span></span>
  break</span>;</span></span>
</span>
  Serial</span>.</span>println</span>(</span>"Done"</span>);</span></span>
}</span></span></code></pre>
I also added the SET_ANGLE</code> command, which allows the user to change the setpoint while PID is running.</p>
case SET_ANGLE: </span>{</span></span>
    success </span>=</span> robot_cmd</span>.</span>get_next_value</span>(</span>curr_setpoint</span>);</span></span>
    if</span> (</span>!</span>success</span>)</span></span>
        return</span>;</span></span>
    break</span>;</span></span>
}</span></span></code></pre>Range/Sampling time and DMP</h2>
I enabled the DMP (Digital Motion Processing) to get calibrated accurate IMU angles. The DMP fills a Queue (First In, First Out) with values from the desired report. To prevent the DMP FIFO from filling, I had to make sure to pop vaules while waiting for comamnds and while transfering data. I chose to get the Game Rotation Vector which return the quaterion of the angle facing, calcultated by combinding the accelerometer and gyroscope values. I chose to not use the magnetometer since Meep only needs to know its relative orientation and I wasn’t sure how the megnetometer would perform in different environments. I was able to run its max frequency of about 55 Hz which resulted in an average of 17.6 ms</strong> between motor updates.</p>
void</span> pid_angle</span>(</span>float</span> angle</span>){</span></span>
  myICM</span>.</span>readDMPdataFromFIFO</span>(</span>&</span>imu_data</span>);</span></span>
  // Skip everything if valid data wasn't available</span></span>
  if</span> ((</span>myICM</span>.</span>status</span> ==</span> ICM_20948_Stat_Ok</span>)</span> ||</span> (</span>myICM</span>.</span>status</span> ==</span> ICM_20948_Stat_FIFOMoreDataAvail</span>))</span> </span></span>
  {</span></span>
      time_stamps</span>[</span>i</span>]</span> =</span> millis</span>();</span></span>
      get_roll_pitch_yaw</span>(</span>i</span>);</span></span>
</span>
</span>
      // Calcualate error, total error, and error change</span></span>
      float</span> e </span>=</span> yaw_readings</span>[</span>i</span>]</span> -</span> angle</span>;</span></span>
      if</span> (</span>e </span>></span> 180</span>){</span></span>
        e </span>-=</span> 360</span>;</span></span>
      }</span></span>
      else if</span> (</span>e </span>< -</span>180</span>) {</span></span>
        e </span>+=</span> 360</span>;</span></span>
      }</span></span>
      error_total </span>+=</span> e</span>;</span></span>
</span>
      // Integrator Windup code</span></span>
      if</span> (</span>error_total </span>></span> 1000</span>){</span></span>
        error_total </span>=</span> 1000</span>;</span></span>
      }</span></span>
      else if</span> (</span>error_total </span>< -</span>1000</span>){</span></span>
        error_total </span>= -</span>1000</span>;</span></span>
      }</span></span>
</span>
      error_change </span>=</span> e</span>-</span>last_error</span>;</span></span>
</span>
</span>
      // Motor Update</span></span>
      int</span> motor_out </span>=</span> (</span>int</span>)(</span>Kp</span>*</span>e </span>+</span> Ki</span>*</span>error_total </span>+</span> Kd</span>*</span>error_change</span>);</span></span>
</span>
      // Record Data</span></span>
      p_data</span>[</span>i</span>]</span> =</span> Kp</span>*</span>e</span>;</span></span>
      i_data</span>[</span>i</span>]</span> =</span> Ki</span>*</span>error_total</span>;</span></span>
      d_data</span>[</span>i</span>]</span> =</span> Kd</span>*</span>error_change</span>;</span></span>
      motor_data</span>[</span>i</span>]</span> =</span> motor_out</span>;</span></span>
      setpoint_angle</span>[</span>i</span>]</span> =</span> angle</span>;</span></span>
</span>
      // Set motor values while adjusting for the deadband region</span></span>
      if</span> (</span>motor_out </span><</span> 5</span> &&</span> motor_out </span>> -</span>5</span>){</span></span>
        right</span>(</span>0</span>,</span> 0</span>);</span></span>
      }</span></span>
      else if</span> (</span>motor_out </span>></span> 0</span>){</span></span>
        if</span> (</span>motor_out </span><</span> 140</span>){</span></span>
          motor_out </span>=</span> 140</span>;</span></span>
        }</span></span>
        right</span>(</span>motor_out</span>,</span> motor_out</span>);</span>   </span></span>
      }</span></span>
      else</span> {</span></span>
        if</span> (</span>motor_out </span>> -</span>140</span>){</span></span>
          motor_out </span>= -</span>140</span>;</span></span>
        }</span></span>
        left</span>(</span>-</span>motor_out</span>,</span> -</span>motor_out</span>);</span></span>
      }</span></span>
      last_error </span>=</span> e</span>;</span></span>
      </span></span>
      // Increment data index</span></span>
      i</span>++</span>;</span></span>
      if</span> (</span>i </span>>=</span> TIME_ARR_SIZE</span>){</span></span>
        i </span>=</span> 0</span>;</span></span>
      }</span></span>
      </span></span>
  </span></span>
  }</span></span>
}</span></span></code></pre>Tuning process and results</h2>
I started with just a proportional controller on a smooth but grippy floor. With proportion drive, Meep was able to quickly turn to the desire angle with minimal overshoot and negliable steady state error.</p>
</iframe>
I adjusted the P term to be 1.9</strong> and tested it on a set sequence. I had the robot reach 0, 90, -90, 45, and 0 degrees with 5 seconds between setpoint changes. I did this to test accuracy, speed, and ability to adjust to a changing setpoint. I saw very accurate and quick positioning.</p>
</iframe>


Next, I tried running the robot on carpet and immediately ran into problems. The robot struggled to turn with the currently set deadband region.</p>
</iframe>

Since I didn’t want to adjust the deadband region but wanted Meep to be able to turn accurately on all floor types, I decided to add the integral term. An integral term of 0.1</strong> allowed Meep to turn accurately on carpet.</p>
</iframe>

We can see the addition of the I</code> term allowed Meep to get enough power to turn successfully!</p>

Finally, I tested Meep with its newly tuned PI controller on a tile floor.</p>


I gave Meep some light kicks to demonstrate its ability to readjust.</p>
</iframe>


Grad Task: Integrator Term</h2>
The i</code> term is proportional to the cummalative error. Without being capped, the error term can greatly accumulate causing a high amount of overshoot once the robot is unstuck. In this lab, this causes the robot to be stuck spinning since the error in unable to decrease so the PWM is always maxed out.</p>
</iframe>

We can fix this by capping the max value. Earlier in the lab, I capped the cummlative error to 2000. I decided to decrement the cap to 1000 so that Meep would not be stuck overshooting (osciallating) for as long.</p>
</iframe>

Collaboration and Sources</h2>
I did the lab with very light discussion with Dyllan Hofflich.</p>



Lab 2: IMU
2026-02-10T00:00:00+00:00
Lab Tasks</h1>
This lab explores an Inertial Measurement Unit (IMU), specifically the Sparkfun breakout board</a>. This board has an accelerometer, gyrocrope, and magnetometer on the boards X, Y, and Z axis. This lab explores use of the accelerometer and gyroscope, noise analysis for low pass filtering, and using a complementary filter for optimal angle estimation.</p>
IMU Set Up</h2>
The IMU is connected to the Artemis with a Qwiic connect able with 4 wires: Power (3.3 V), Ground, Clock (SCL), and Data (SDA).</p>


AD0_VAL and I2C</h2>
I2C commincation is used fairly often with sensors and other devices that need to write data to an area where it can be read by a microcontroller. I2C uses a clock to synchronize data reads from a specified memory location on the IMU. The IMU will transmit data on the SDA line synchronized with SCL.</p>
The IMU example code itself describes the AD0_VAL</code> as "the value of the last bit of the I2C address"</code>. This value defaults as 1 but can be changed to 0 to allow multiple IMUs (or I2C devices in general) to attach to different I2C commincation addresses.</p>
IMU Example Code</h2>
We run the IMU example code. I could see the acceleration raw readings range from about -1000 to 1000 as the board was spun 360 degrees on all its axis.</p>
</iframe>
Accelerometer</h1>
Calculating and Calibrating Roll and Pitch</h2>
The acceleraometer reads acceleration, or force per mass, being applied to the IMU. When the IMU is stationary, the only force applied to it is gravity. We can use 2 of the raw acceleromter readings to determine the angle of the board for both pitch and roll. In the case of roll, as shown below, we can use the obervation that $a_z = g*\cos(\theta)$ and that $a_x = g*\sin(\theta)$ to determine that the angle $\theta = tan^{-1}(a_x/a_z)$. Since we want $\theta$ to be the correct sign, we use the function $atan2$ to get an angle in radians between $-\pi/2$ and $\pi/2$. The same logic applies to finding the pitch, where $\phi = atan2(a_y, a_z)$. We use these equations with the accelerometer readings to determine roll and pitch.</p>


#ifdef</span> USE_SPI</span></span>
float</span> roll_calc_accel</span>(</span>ICM_20948_SPI </span>*</span>sensor</span>) {</span></span>
#else</span></span>
float</span> roll_calc_accel</span>(</span>ICM_20948_I2C </span>*</span>sensor</span>) {</span></span>
#endif</span></span>
  return</span> atan2</span>(</span>sensor</span>-></span>accX</span>(),</span> sensor</span>-></span>accZ</span>())</span> /</span> M_PI </span>*</span> 180.0</span>;</span> </span></span>
}</span></span>
</span>
</span>
#ifdef</span> USE_SPI</span></span>
float</span> pitch_calc_accel</span>(</span>ICM_20948_SPI </span>*</span>sensor</span>) {</span></span>
#else</span></span>
float</span> pitch_calc_accel</span>(</span>ICM_20948_I2C </span>*</span>sensor</span>) {</span></span>
#endif</span></span>
  return</span> atan2</span>(</span>sensor</span>-></span>accY</span>(),</span> sensor</span>-></span>accZ</span>())</span> /</span> M_PI </span>*</span> 180.0</span>;</span></span>
}</span></span></code></pre>
To callibrate, I started by observing the IMU roll and pitch readings for -90°, 0°, and 90°. I used the edge of the lab table as reference for ground truth degree measurements. I observed that the accelerometer readings were about one degree off of expected. I chose to calibrate the IMU by shifting based on the 0° output, then scaling the values based on the -90° and 90° readings. For example, for the pitch, I added 1° to shift 0 into the right location, then scaled by $\frac{180}{91.1-(-89.1)} \approx .999$. My calibration equations are as follows:</p>
Roll: $\phi_{actual} = 1.01294(\phi_{measured}+0.21)$</p>
Pitch: $\theta_{actual} = 0.998890(\theta_{measured}+1.0)$</p>
















Data Speed and Accuracy</h2>
Overall, the IMU is able to output accelermoter values very quickly and decently accurately. Raw acceleromter values are constantly changing and very noise. Even slight bumps in the table are detected with extreme changed in the accelerometer readings. An easy way to fix this is to low pass the accelerometer to filter out the noise. We start by observing stationary accelerometer readings in the frequency domain. We apply a fast fourier transformation to transform the data into the frequency domain. I attempted to sample 2048 accelerometer readings at a semi constant rate which ended up being about 1329 microseconds between data reads.</p>




f</span> =</span> np</span>.</span>linspace</span>(</span>0</span>,</span> fs</span>/</span>2</span>,</span> int</span>(</span>N</span>/</span>2</span>),</span> endpoint</span>=</span>False</span>)</span> </span></span>
roll_fft</span> =</span> fft</span>(</span>rolls</span>)</span></span>
pitch_fft</span> =</span> fft</span>(</span>pitches</span>)</span></span>
roll_y</span> =</span> 2.0</span> /</span> N</span> *</span> np</span>.</span>abs</span>(</span>roll_fft</span>[:</span>N</span>//</span>2</span>])</span></span>
pitch_y</span> =</span> 2.0</span> /</span> N</span> *</span> np</span>.</span>abs</span>(</span>pitch_fft</span>[:</span>N</span>//</span>2</span>])</span></span></code></pre>
I noticed that all data seemed to be contained within 10 Hz so I chose to make this my cutoff. Sticking with the SciPy library, I used the built in butter</code> and filtfilt</code> functions to low pass the accelerometer values. This showed accelerometer readings that were far more resistant to noise as shown in the graph below.</p>




Gyroscope</h1>
Raw Gyroscope Readings</h2>
A gyroscope measures angular velocity. By updating out angle estimate based on time, the gyroscope readings, and the previous angle, we can accurately estimate the angle with far less noise. To estimate angle $\theta$ with the gyroscope, we can use the following equation $\theta_t = \theta_{t-1} + $ gyro_reading $ * dt$. This updates the angle based on the change between the last angle and the current. We can observe that when the imu is stable, we see little to no fluctuation in the gyroscope angle estimates. However, a major issue with relying only on the gyroscope is the value drifting from reality. Since we are estimating the position through the deriviative, we can easily stray from reality as the same estimates in our error compound.</p>





Here’s an example of gyroscope readings as I spin the IMU 360 degrees on the yaw axis.</p>
</iframe>

Sample Time</h2>
One factor in gyroscope angle estimation is the time between samples. If we have a long time between samples, we can easily drift from reality since we are estimating the angle based on the change in angle. If we have a short time between samples, we can get more accurate readings since we are updating our angle estimate more frequently. I attempted to observe the difference between a short and long sample time. I noticed that quick movements could not be picked up if the gyroscope is already stationary when sampled again, leading to larger drift.</p>


Complementary Filter Readings</h2>
The solution to account for both the noise in the accelerometer and the drift in the gyroscope is to use a complementary filter. A complementary filter is simply a way of combinding the output for both the accelerometer and the gyrpscope to get non-noisy and accurate angle readings. We do this by taking the weighted average of the accelerometer and gyroscope angle estimates. I chose to take 99% of the gyroscopes reading since it would update quickly and not be noisy. I used 1% of the angle to be the acceleromter’s reading to correct any drift introduced by the gyroscope. We can see in the graphs below that the complementary filter greatly improved both angle drift and resistanct to noise for the IMU readings. Light vibrations of the table no longer cause the angle to fluctuate and the gyroscope’s drift is adjusted for (as demonstrated clearly in the pitch graph below).</p>




fs</span> =</span> 1</span>/</span>2827e-6</span></span>
cutoff_freq</span> =</span> 10</span> </span></span>
Wn</span> =</span> cutoff_freq</span> /</span> (</span>fs</span> /</span> 2</span>)</span></span>
b</span>,</span> a</span> =</span> butter</span>(</span>N</span>=</span>4</span>,</span> Wn</span>=</span>Wn</span>,</span> btype</span>=</span>'low'</span>)</span></span>
comp_accel_roll_filtered</span> =</span> filtfilt</span>(</span>b</span>,</span> a</span>,</span> comp_acc_rolls</span>)</span> # filter the acceleration roll</span></span>
comp_accel_pitch_filtered</span> =</span> filtfilt</span>(</span>b</span>,</span> a</span>,</span> comp_acc_pitches</span>)</span> # filter the acceleration pitch</span></span>
comp_roll</span> =</span> np</span>.</span>zeros</span>(</span>2048</span>)</span></span>
comp_pitch</span> =</span> np</span>.</span>zeros</span>(</span>2048</span>)</span></span>
comp_roll</span>[</span>0</span>]</span> =</span> comp_accel_roll_filtered</span>[</span>0</span>]</span></span>
comp_pitch</span>[</span>0</span>]</span> =</span> comp_accel_pitch_filtered</span>[</span>0</span>]</span></span>
</span>
# calculate the complementary filter angles</span></span>
for</span> i</span> in</span> range</span>(</span>1</span>,</span> 2048</span>):</span></span>
    dt</span> =</span> (</span>comp_times</span>[</span>i</span>]</span> -</span> comp_times</span>[</span>i</span>-</span>1</span>])</span> *</span> 0.000001</span></span>
    comp_roll</span>[</span>i</span>]</span> =</span> (</span>comp_roll</span>[</span>i</span>-</span>1</span>]</span>+</span> comp_gyr_rolls</span>[</span>i</span>]</span>*</span>dt</span>)</span>*</span>(</span>0.99</span>)</span> +</span> comp_acc_rolls</span>[</span>i</span>]</span>*</span>0.01</span></span>
    comp_pitch</span>[</span>i</span>]</span> =</span> (</span>comp_pitch</span>[</span>i</span>-</span>1</span>]</span>+</span> comp_gyr_pitches</span>[</span>i</span>]</span>*</span>dt</span>)</span>*</span>(</span>0.99</span>)</span> +</span> comp_acc_pitches</span>[</span>i</span>]</span>*</span>0.01</span></span></code></pre>
One design choice I made was to do the complementary filter math in python rather than on the Artemis. I chose to do this because I wanted to transmit IMU data as quickly as possible and I wanted to be able to low pass and calibrate the accelerometer readings before passing them into the complementary filter.</p>
Sample Data</h1>
To continously sample data, I created the commands IMU_START</code> and IMU_STOP</code>. The IMU will record and send out data in batches until it receives the stop command. I chose a batch size of 10 to minimize latency while transmitting mostly up to data readings. This resulted in a sampling rate of about 48.6 milliseconds between data points.</p>
</iframe>


// START STORING VALUES. TRANSMIT WHEN THE BUFFER IS FULL</span></span>
void</span> transmit_imu_data</span>(){</span></span>
    int</span> dropped_data </span>=</span> 0</span>;</span></span>
    int</span> j </span>=</span> 0</span>;</span></span>
    time_stamps</span>[</span>0</span>]</span> =</span> (</span>int</span>)</span> millis</span>();</span></span>
</span>
    for</span> (</span>i </span>=</span> 0</span>;</span> i </span><</span> TIME_ARR_SIZE</span>;</span> i</span>++</span>) {</span></span>
        if</span> (</span>myICM</span>.</span>dataReady</span>()) {</span></span>
          myICM</span>.</span>getAGMT</span>();</span></span>
          time_stamps</span>[</span>i</span>]</span> =</span> (</span>int</span>)</span> millis</span>();</span></span>
          roll_readings</span>[</span>i</span>]</span> =</span> roll_calc_accel</span>(</span>&</span>myICM</span>);</span></span>
          pitch_readings</span>[</span>i</span>]</span> =</span> pitch_calc_accel</span>(</span>&</span>myICM</span>);</span></span>
          gyro_roll_readings</span>[</span>i</span>]</span> =</span> myICM</span>.</span>gyrX</span>();</span></span>
          gyro_pitch_readings</span>[</span>i</span>]</span> =</span> myICM</span>.</span>gyrY</span>();</span></span>
          gyro_pitch_readings</span>[</span>i</span>]</span> =</span> myICM</span>.</span>gyrY</span>();</span></span>
          gyro_yaw_readings</span>[</span>i</span>]</span> =</span> myICM</span>.</span>gyrZ</span>();</span></span>
        }</span></span>
        else</span>{</span></span>
          dropped_data</span>++</span>;</span></span>
        }</span></span>
        read_data</span>();</span></span>
        if</span> (</span>!</span>imu_trans</span>){</span></span>
          break</span>;</span></span>
        }</span></span>
    }</span>         </span></span>
      </span></span>
    // Serial.println("SENDING IMU DATA");</span></span>
</span>
    for</span> (</span>j </span>=</span> 0</span>;</span> j </span><</span> i</span>;</span> j</span>++</span>) {</span></span>
        tx_estring_value</span>.</span>clear</span>();</span></span>
        tx_estring_value</span>.</span>append</span>(</span>time_stamps</span>[</span>j</span>]);</span></span>
        tx_estring_value</span>.</span>append</span>(</span>":"</span>);</span></span>
        tx_estring_value</span>.</span>append</span>(</span>roll_readings</span>[</span>j</span>]);</span></span>
        tx_estring_value</span>.</span>append</span>(</span>":"</span>);</span></span>
        tx_estring_value</span>.</span>append</span>(</span>pitch_readings</span>[</span>j</span>]);</span></span>
        tx_estring_value</span>.</span>append</span>(</span>":"</span>);</span></span>
        tx_estring_value</span>.</span>append</span>(</span>gyro_roll_readings</span>[</span>j</span>]);</span></span>
        tx_estring_value</span>.</span>append</span>(</span>":"</span>);</span></span>
        tx_estring_value</span>.</span>append</span>(</span>gyro_pitch_readings</span>[</span>j</span>]);</span></span>
        tx_estring_value</span>.</span>append</span>(</span>":"</span>);</span></span>
        tx_estring_value</span>.</span>append</span>(</span>gyro_yaw_readings</span>[</span>j</span>]);</span></span>
        tx_estring_value</span>.</span>append</span>(</span>":"</span>);</span></span>
        tx_estring_value</span>.</span>append</span>(</span>dropped_data</span>);</span></span>
        tx_characteristic_string</span>.</span>writeValue</span>(</span>tx_estring_value</span>.</span>c_str</span>());</span></span>
    }</span>       </span></span>
</span>
    // Serial.println("COMP DATA TRANFER Complete");</span></span>
}</span></span></code></pre>Stunt</h1>
After playing around with my RC car, I observed the car’s natural drifting, turning speed/accuracy, and how easy it was to flip the bot over (either by driving into a wall or rapidally switching directions). I noted that telling the bot to drive ‘straight’ resulted in the car taking a pretty heavy curve. It was pretty easy to get the car to only have 1 or 2 wheel touching the ground causing a straight command to result in the car spinning in a circle (as shown in the video).</p>
</iframe>
Shao and I also (accidently) observed that the RC car can drive on its side. I’m not sure what to do with this information at this time, but it could be used for a stunt in the future. Driving on the side seemed much more controlled and better for slower motion. (Please ignore my cackling as I found this driving method to be quite funny).</p>
</iframe>
Collaboration</h1>
This lab was worked on with consultation from Shao Stassen. We worked together more closely for the Stunt section. Aidan McNay’s student page was also consulted.</p>
Resources</h2>
Qwiic Connect Guide</a></p>
ArduinoDocs I2C Guide</a></p>
Alphabold FFT Tutorial</a></p>
SciPy Butter</a></p>
SciPy Filtfilt</a></p>

Ananya's Portfolio - IMU

Lab 6: Orientation Control

Collaboration and Sources</h2> I did the lab with very light discussion with Dyllan Hofflich.</p>

Lab 2: IMU

Accelerometer</h1>

Collaboration</h1> This lab was worked on with consultation from Shao Stassen. We worked together more closely for the Stunt section. Aidan McNay’s student page was also consulted.</p>

Resources</h2> Qwiic Connect Guide</a></p> ArduinoDocs I2C Guide</a></p> Alphabold FFT Tutorial</a></p> SciPy Butter</a></p> SciPy Filtfilt</a></p>

`Collaboration and Sources</h2> I did the lab with very light discussion with Dyllan Hofflich.</p>`

Collaboration</h1>
This lab was worked on with consultation from Shao Stassen. We worked together more closely for the Stunt section. Aidan McNay’s student page was also consulted.</p>

Resources</h2>
Qwiic Connect Guide</a></p>
ArduinoDocs I2C Guide</a></p>
Alphabold FFT Tutorial</a></p>
SciPy Butter</a></p>
SciPy Filtfilt</a></p>