Introduction

In this lab, we will be adding an Inertial Measurement Unit (IMU) to our wearable prototype to implement a step counter. The IMU uses a combination of an accelerometer and a gyroscope to allow us to obtain useful calculations to detect steps, user movement, etc. Essentially, the IMU is a integral part of the final prototype that we have been building towards in Labs 1 to 3. Furthermore, we will be using the various types of signal manipulation, such as filtering, in order to shape our signals to optimize the functionality of our wearable prototype.

In the last portion of the lab, we will implement a step detection algorithm using scipy's peak finding methods. Using this algorithm, we transfer from Serial communication to BLE between the Arduino and Python. The final product will be a system that is capable of detecting steps, and displays the current step count on the Arduino's OLED display. A pause/play button will also be implemented to control the Arduino's data output to the Python script.

Objectives

1. IMU Basics
2. Step Counting
3. Step Counting Finalized

Objective 1

Using the IMU and Arduino, develop a Python script to read accelerometer and gyroscope values from the Arduino via Serial and live plot all values.

1.) We need to install the TimerOne and i2cDev libraries. This is done by copying the ZIP files of each library to the Arduino's libraries directory:

../Arduino/libraries

Then you can add the libraries in the Arduino IDE by going to:

Arduino >> Sketch >> Include Library >> Add .ZIP Library

2.) Install the Arduino code available below. Note that the code specifically requires the Arduino to read a "1" from Serial to start printing the values and a "0" from Serial to stop. Set up the circuit by connecting the prototype shield to the Arduino board and use Serial Monitor to write "1" to the Arduino to read the IMU values.

3.) We need a Python script to read the values from Arduino via Serial and live plot them in one figure with 6 subplots. This is done in the following code pasted below:

Remember to change the serial_port variable to the one corresponding to your Arduino. Once you run the Python code, you should obtain a plot similar to the one below:

Objective 2

Develop a Python script to obtain IMU values from the Arduino, and use an algorithm to detect when a step occurs. This will require the use of filters used previously in Lab 1 to 3.

1. We will use the Python script below to implement a rough draft of the step counter:

The code applies a LPF to the accelerometer's x-axis and y-axis values and then detects increases in the y-axis values within a 30 index window that exceed a pre-determined threshold value (thresh = 800). Whenever this is detected, the global step variable is incremented.

Using this Python script, we obtain a figure similar to the one below:

Note that only AX and AY values have been filtered. The other plots are left for comparison to demonstrate the effect that filtering has on our values from the Arduino. (Ideally, we want our signals to be noise-free for step detection purposes.)

In our first attempt to implement a step counter, we are successful in obtaining data from the Arduino to Python via Serial communication, and we are able to filter the data using the LPF. Using the filtered signal, we then increment the step variable every time the maximum value of a new set of sampled data exceeds the minimum value of the same set by a defined threshold value.

The issue with this strategy is that it only takes into account the maximum and minimum values of a set, regardless of their context. In other words, a "step" should consist of a peak in the signal, rather than a general spike. This means we will need a method of finding the peaks in our input signal, and using the detected peaks, we will increment the step count every time we detect a peak. In the next objective, I will be discussing how we will implement this functionality.

Objective 3

Refine the step counting algorithm from the previous objective to make it more robust. Replace the Serial communication between the Arduino and Python to BLE. Lastly, include a button that will command the Arduino to stop sending data once pressed.

1.) We will improve our step counter algorithm in a few ways. First, we will need to center our data signal to the 0-axis, so a high-pass filter is needed in addition to the existing low-pass filter. Next, we will detect the peaks in our signal using scipy's find_peak() method. This method returns the indices of the input signal where a peak exists. The peak is detected within a set of given parameters, such as minimum height/width, in order to prevent random noise from being labeled as a peak. The following Python code is pasted below:

lab4_final_step_count.py

As usual, make sure to replace the serial_port to be the port that your BLE module is connected to. The Python script obtains the IMU values from Arduino via Serial, filters the signals, detects the peaks that are considered "steps", and then prints out a '#' character back to the Arduino whenever a step is detected.

2.) From the Arduino side of things, we implement the following code so that the Arduino takes in a command character from Python via BLE, and based on the command, it will either print data or increment the stepCount (if a '#' character is sent) to display on the OLED screen.

Lab4FinalStepCount.ino

3.) Upload the Arduino sketch and run the Python script. You should see a live plot of the raw signal, filtered signal, and the peak detection. An example can be seen below:

The top graph plots the raw signal received from Arduino via BLE. The middle graph is the signal after being put through a low-pass and high-pass filter. Lastly, the bottom plot is a visualization of detected peaks from our step counting algorithm. Whenever a peak is detected, the bottom plot displays a spike based on the amplitude of the signal at the instance of the detected peak.

Congratulations! You have finished Lab 4. To ensure your system works properly, refer below to a video displaying the final system at work: