In this video lesson, We show you how to log sensor data on your Raspberry Pi Pico W. We will start with simple read and write functions, and then show you how to write and read files line by line, and keep a log of your sensor data.

Our first program is very simple, and just shows how to write a line of data, and read a line of data the the Pico’s flash memory. Here is the code we used in the video for the first simple example.

# This code writes three sensor readings as a comma-separated string to log.txt
# on the Pico W, then reads the file back and splits the string into a list.
# Purpose: Demonstrate basic file writing and reading in MicroPython using log.txt.

# Writing comma-delimited data to a file
sensorData = "25.5,26.0,24.8"  # Example temperature readings from three sensors
with open('log.txt', 'w') as file:  # Open log.txt in write mode ('w')
    file.write(sensorData)  # Write the comma-separated string to the file
print("Data written to log.txt")  # Confirm data was written

# Reading comma-delimited data
with open('log.txt', 'r') as file:  # Open log.txt in read mode ('r')
    content = file.read()  # Read the entire file as a string
    print("Raw data:", content)  # Print the raw string
    # Parse into a list
    values = content.split(',')  # Split the string at commas to create a list
    print("Parsed values:", values)  # Print the resulting list

# This code writes three sensor readings as a comma-separated string to log.txt

# on the Pico W, then reads the file back and splits the string into a list.

# Purpose: Demonstrate basic file writing and reading in MicroPython using log.txt.

# Writing comma-delimited data to a file

sensorData = "25.5,26.0,24.8" # Example temperature readings from three sensors

with open('log.txt', 'w') as file: # Open log.txt in write mode ('w')

file.write(sensorData) # Write the comma-separated string to the file

print("Data written to log.txt") # Confirm data was written

# Reading comma-delimited data

with open('log.txt', 'r') as file: # Open log.txt in read mode ('r')

content = file.read() # Read the entire file as a string

print("Raw data:", content) # Print the raw string

# Parse into a list

values = content.split(',') # Split the string at commas to create a list

print("Parsed values:", values) # Print the resulting list

In the second example, we show greater complexity by writing and reading a file, line by line. Each line contains comma delimited sensor data.

# This code writes three sets of sensor readings to log.txt on the Pico W,
# each set as a comma-separated line, overwriting previous content, then reads
# the file back line by line, splitting each line into a list.
# Purpose: Show how to log multiple data sets to log.txt and read them one line at a time.

# Writing one line at a time
readingsOne = ["25.5", "26.0", "24.8"]  # First set of sensor readings
readingsTwo = ["12.6", "62.5", "33.4"]  # Second set of sensor readings
readingsThree = ["19.8", "20.1", "21.3"]  # Third set of sensor readings
allReadings = [readingsOne, readingsTwo, readingsThree]  # Combine into a list of lists

with open('log.txt', 'w') as file:  # Open log.txt in write mode ('w')
    for readingSet in allReadings:  # Loop through each set of readings
        # ','.join(readingSet) converts the list (e.g., ["25.5", "26.0", "24.8"])
        # into a single string "25.5,26.0,24.8" with commas between values.
        # We need this because file.write() requires a string, not a list.
        line = ','.join(readingSet)
        file.write(line + '\n')  # Write the line to the file with a newline
print("Data written to log.txt")  # Confirm data was written

# Reading one line at a time
with open('log.txt', 'r') as file:  # Open log.txt in read mode ('r')
    print("Reading line by line:")
    for line in file:  # Loop through each line in the file
        # line.strip() removes leading/trailing whitespace, including '\n'
        # .split(',') splits the line at commas to create a list of values
        values = line.strip().split(',')
        print("Sensor readings:", values)  # Print the list of readings

# This code writes three sets of sensor readings to log.txt on the Pico W,

# each set as a comma-separated line, overwriting previous content, then reads

# the file back line by line, splitting each line into a list.

# Purpose: Show how to log multiple data sets to log.txt and read them one line at a time.

# Writing one line at a time

readingsOne = ["25.5", "26.0", "24.8"] # First set of sensor readings

readingsTwo = ["12.6", "62.5", "33.4"] # Second set of sensor readings

readingsThree = ["19.8", "20.1", "21.3"] # Third set of sensor readings

allReadings = [readingsOne, readingsTwo, readingsThree] # Combine into a list of lists

with open('log.txt', 'w') as file: # Open log.txt in write mode ('w')

for readingSet in allReadings: # Loop through each set of readings

# ','.join(readingSet) converts the list (e.g., ["25.5", "26.0", "24.8"])

# into a single string "25.5,26.0,24.8" with commas between values.

# We need this because file.write() requires a string, not a list.

line = ','.join(readingSet)

file.write(line + '\n') # Write the line to the file with a newline

print("Data written to log.txt") # Confirm data was written

# Reading one line at a time

with open('log.txt', 'r') as file: # Open log.txt in read mode ('r')

print("Reading line by line:")

for line in file: # Loop through each line in the file

# line.strip() removes leading/trailing whitespace, including '\n'

# .split(',') splits the line at commas to create a list of values

values = line.strip().split(',')

print("Sensor readings:", values) # Print the list of readings

In these first two examples, when we open the file as ‘w’, the existing data is erased and a new file is created. In the example below, we open an existing file, and show how to append new data to the existing file without erasing the old data.

# This code appends a new set of sensor readings to log.txt on the Pico W
# as a comma-separated line, checks if the file exists, and reads the file
# line by line to verify the append.
# Purpose: Demonstrate appending to log.txt, verifying file existence, and checking contents.

import os  # Import os module for file system operations

# Appending a new set of readings to the file
newReadings = ["30.1", "29.8", "31.0"]  # New set of sensor readings
try:
    with open('log.txt', 'a') as file:  # Open log.txt in append mode ('a')
        # ','.join(newReadings) converts the list (e.g., ["30.1", "29.8", "31.0"])
        # into a single string "30.1,29.8,31.0" with commas between values.
        # We need this because file.write() requires a string, not a list.
        line = ','.join(newReadings)
        file.write(line + '\n')  # Append the line with a newline
    print("Appended new readings to log.txt")  # Confirm data was appended
except OSError as e:
    print("Error appending to file:", e)  # Handle errors like full flash

# Read and print file to verify append
try:
    with open('log.txt', 'r') as file:  # Open log.txt in read mode ('r')
        print("Verifying log.txt contents line by line:")
        for line in file:  # Loop through each line in the file
            # line.strip() removes leading/trailing whitespace, including '\n'
            # .split(',') splits the line at commas to create a list of values
            values = line.strip().split(',')
            print("Sensor readings:", values)  # Print the list of readings
except OSError as e:
    print("Error reading file:", e)  # Handle errors like file not found

# This code appends a new set of sensor readings to log.txt on the Pico W

# as a comma-separated line, checks if the file exists, and reads the file

# line by line to verify the append.

# Purpose: Demonstrate appending to log.txt, verifying file existence, and checking contents.

import os # Import os module for file system operations

# Appending a new set of readings to the file

newReadings = ["30.1", "29.8", "31.0"] # New set of sensor readings

try:

with open('log.txt', 'a') as file: # Open log.txt in append mode ('a')

# ','.join(newReadings) converts the list (e.g., ["30.1", "29.8", "31.0"])

# into a single string "30.1,29.8,31.0" with commas between values.

# We need this because file.write() requires a string, not a list.

line = ','.join(newReadings)

file.write(line + '\n') # Append the line with a newline

print("Appended new readings to log.txt") # Confirm data was appended

except OSError as e:

print("Error appending to file:", e) # Handle errors like full flash

# Read and print file to verify append

try:

with open('log.txt', 'r') as file: # Open log.txt in read mode ('r')

print("Verifying log.txt contents line by line:")

for line in file: # Loop through each line in the file

# line.strip() removes leading/trailing whitespace, including '\n'

# .split(',') splits the line at commas to create a list of values

values = line.strip().split(',')

print("Sensor readings:", values) # Print the list of readings

except OSError as e:

print("Error reading file:", e) # Handle errors like file not found

Arduino

Improving MPU6050 IMU Arduino Project Performance with a Complimentary Filter

September 11, 2025 admin

In this video lesson I show you how you can improve the performance of your Arduino MPU6050 IMU Project by incorporating a complimentary filter. We will combine the roll and pitch calculations from the accelerometer and gyro into a fused result which allows us to enjoy the best of both worlds.

For your convenience, the code developed is presented below:

#include <Adafruit_MPU6050.h>
#include <Adafruit_Sensor.h>
#include <Wire.h>
float Ax;
float Ay;
float Az;

float Gx;
float Gy;
float Gz;

float rollG=0;
float pitchG=0;
float yawG=0;

float gyroXOffset=0;
float gyroYOffset=0;
float gyroZOffset=0;

int tStart = millis();

// If You want Calibrated results, you must rotate
// your board to all possible orientations, and
// record your velues of xMax, xMin, yMax, yMin
// zMax, zMin. I show you how to do that in LESSON
// 79 on my youtube channel. Put in your values and then
// uncomment the code below. Don't use my values, you have
// to measure your own for it to work.

// float xMax= 1.03;
// float xMin= -.97;
// float yMax= .98;
// float yMin= -1.01;
// float zMax=.96 ;
// float zMin= -1.08;

// float xOffset = (xMax+xMin)/2;
// float yOffset = (yMax+yMin)/2;
// float zOffset = (zMax+zMin)/2;

// float xScale = 2/(xMax -xMin);
// float yScale = 2/(yMax - yMin);
// float zScale = 2/(zMax -zMin);

float rollLP = 0;
float pitchLP = 0;

float rollRAW;
float pitchRAW;

float rollComp=0;
float pitchComp=0;

float deltaRoll=0;
float deltaPitch=0;

Adafruit_MPU6050 mpu;

void calibrateGyro(){
Serial.println("Calibrating the Gyro: Keep Completely Stationary");
delay(1000);
int i;
float sumX = 0;
float sumY = 0;
float sumZ = 0;
int numPoints=100;
for (i=0;i<numPoints;i=i+1){
  sensors_event_t a, g, temp;
  mpu.getEvent(&a, &g, &temp);
  sumX = sumX + g.gyro.x;
  sumY = sumY + g.gyro.y;
  sumZ = sumZ + g.gyro.z;
  delay(10);
}
gyroXOffset = sumX/numPoints;
gyroYOffset = sumY/numPoints;
gyroZOffset = sumZ/numPoints;

}

void setup() {
  // put your setup code here, to run once:
  Serial.begin(115200);
  mpu.begin();
  Serial.println("MPU6050 Started!");
  mpu.setAccelerometerRange(MPU6050_RANGE_2_G);
  mpu.setGyroRange(MPU6050_RANGE_2000_DEG);
  mpu.setFilterBandwidth(MPU6050_BAND_21_HZ);
calibrateGyro();
tStart = millis();
}

void loop() {
  // put your main code here, to run repeatedly:
  sensors_event_t a, g, temp;
  mpu.getEvent(&a, &g, &temp);
  Ax = a.acceleration.x / 9.81;
  Ay = a.acceleration.y / 9.81;
  Az = a.acceleration.z / 9.81;

  Gx = g.gyro.x-gyroXOffset;
  Gy = -(g.gyro.y-gyroYOffset);
  Gz = g.gyro.z-gyroZOffset;

rollG = rollG + (millis() - tStart)/1000. * Gy *360./2./3.14;
pitchG = pitchG + (millis() - tStart)/1000. * Gx *360./2./3.14;
yawG = yawG + (millis() - tStart)/1000. * Gz *360./2./3.14;
deltaRoll=(millis() - tStart)/1000. * Gy *360./2./3.14;
deltaPitch=(millis() - tStart)/1000. * Gx *360./2./3.14;
tStart = millis();

  //Uncomment these lines of code to do the callibration
  //This will only work if you have measured your max
  //and min values, and put them in at the top of the code
  // Ax = xScale*(Ax-xOffset);
  // Ay = yScale*(Ay-yOffset);
  // Az = zScale*(Az-zOffset);

  pitchRAW = atan2(Ay, sqrt(Az * Az + Ax * Ax)) * 360 / (2 * 3.14);
  rollRAW = atan2(Ax, sqrt(Az * Az + Ay * Ay)) * 360 / (2 * 3.14);

  pitchLP = .75 * pitchLP + .25 * pitchRAW;
  rollLP = .75 * rollLP + .25 * rollRAW;

  rollComp= .1*rollRAW + .9*(rollComp + deltaRoll);
  pitchComp= .1*pitchRAW +.9*(pitchComp +deltaPitch);

  Serial.print("rollComp:");
  Serial.print(rollComp);
  Serial.print(',');
  Serial.print("pitchComp:");
  Serial.print(pitchComp);
  Serial.print(',');
  Serial.print("yawG:");
  Serial.print(yawG);
  Serial.print(',');
  // Serial.print("rollComp:");
  // Serial.print(rollComp);
  // Serial.print(',');
  // Serial.print("pitchG:");
  // Serial.print(pitchG);
  // Serial.print(',');
  // Serial.print("yawG:");
  // Serial.print(yawG);
  // Serial.print(',');
  Serial.print("UL:");
  Serial.print(90);
  Serial.print(',');
  Serial.print("LL:");
  Serial.println(-90);

  //   Serial.print("Ax:");
  //   Serial.print(Ax);
  //   Serial.print(',');
  //   Serial.print("Ay:");
  //   Serial.print(Ay);
  //   Serial.print(',');
  //     Serial.print("Az:");
  //   Serial.print(Az);
  //   Serial.print(',');
  //  Serial.print("UL:");
  //  Serial.print(1);
  //  Serial.print(',');
  //  Serial.print("LL:");
  //  Serial.println(-1);
  delay(1);
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

#include <Adafruit_MPU6050.h>

#include <Adafruit_Sensor.h>

#include <Wire.h>

float Ax;

float Ay;

float Az;

float Gx;

float Gy;

float Gz;

float rollG=0;

float pitchG=0;

float yawG=0;

float gyroXOffset=0;

float gyroYOffset=0;

float gyroZOffset=0;

int tStart = millis();

// If You want Calibrated results, you must rotate

// your board to all possible orientations, and

// record your velues of xMax, xMin, yMax, yMin

// zMax, zMin. I show you how to do that in LESSON

// 79 on my youtube channel. Put in your values and then

// uncomment the code below. Don't use my values, you have

// to measure your own for it to work.

// float xMax= 1.03;

// float xMin= -.97;

// float yMax= .98;

// float yMin= -1.01;

// float zMax=.96 ;

// float zMin= -1.08;

// float xOffset = (xMax+xMin)/2;

// float yOffset = (yMax+yMin)/2;

// float zOffset = (zMax+zMin)/2;

// float xScale = 2/(xMax -xMin);

// float yScale = 2/(yMax - yMin);

// float zScale = 2/(zMax -zMin);

float rollLP = 0;

float pitchLP = 0;

float rollRAW;

float pitchRAW;

float rollComp=0;

float pitchComp=0;

float deltaRoll=0;

float deltaPitch=0;

Adafruit_MPU6050 mpu;

void calibrateGyro(){

Serial.println("Calibrating the Gyro: Keep Completely Stationary");

delay(1000);

int i;

float sumX = 0;

float sumY = 0;

float sumZ = 0;

int numPoints=100;

for (i=0;i<numPoints;i=i+1){

sensors_event_t a, g, temp;

mpu.getEvent(&a, &g, &temp);

sumX = sumX + g.gyro.x;

sumY = sumY + g.gyro.y;

sumZ = sumZ + g.gyro.z;

delay(10);

}

gyroXOffset = sumX/numPoints;

gyroYOffset = sumY/numPoints;

gyroZOffset = sumZ/numPoints;

}

void setup() {

// put your setup code here, to run once:

Serial.begin(115200);

mpu.begin();

Serial.println("MPU6050 Started!");

mpu.setAccelerometerRange(MPU6050_RANGE_2_G);

mpu.setGyroRange(MPU6050_RANGE_2000_DEG);

mpu.setFilterBandwidth(MPU6050_BAND_21_HZ);

calibrateGyro();

tStart = millis();

}

void loop() {

// put your main code here, to run repeatedly:

sensors_event_t a, g, temp;

mpu.getEvent(&a, &g, &temp);

Ax = a.acceleration.x / 9.81;

Ay = a.acceleration.y / 9.81;

Az = a.acceleration.z / 9.81;

Gx = g.gyro.x-gyroXOffset;

Gy = -(g.gyro.y-gyroYOffset);

Gz = g.gyro.z-gyroZOffset;

rollG = rollG + (millis() - tStart)/1000. * Gy *360./2./3.14;

pitchG = pitchG + (millis() - tStart)/1000. * Gx *360./2./3.14;

yawG = yawG + (millis() - tStart)/1000. * Gz *360./2./3.14;

deltaRoll=(millis() - tStart)/1000. * Gy *360./2./3.14;

deltaPitch=(millis() - tStart)/1000. * Gx *360./2./3.14;

tStart = millis();

//Uncomment these lines of code to do the callibration

//This will only work if you have measured your max

//and min values, and put them in at the top of the code

// Ax = xScale*(Ax-xOffset);

// Ay = yScale*(Ay-yOffset);

// Az = zScale*(Az-zOffset);

pitchRAW = atan2(Ay, sqrt(Az * Az + Ax * Ax)) * 360 / (2 * 3.14);

rollRAW = atan2(Ax, sqrt(Az * Az + Ay * Ay)) * 360 / (2 * 3.14);

pitchLP = .75 * pitchLP + .25 * pitchRAW;

rollLP = .75 * rollLP + .25 * rollRAW;

rollComp= .1*rollRAW + .9*(rollComp + deltaRoll);

pitchComp= .1*pitchRAW +.9*(pitchComp +deltaPitch);

Serial.print("rollComp:");

Serial.print(rollComp);

Serial.print(',');

Serial.print("pitchComp:");

Serial.print(pitchComp);

Serial.print(',');

Serial.print("yawG:");

Serial.print(yawG);

Serial.print(',');

// Serial.print("rollComp:");

// Serial.print(rollComp);

// Serial.print(',');

// Serial.print("pitchG:");

// Serial.print(pitchG);

// Serial.print(',');

// Serial.print("yawG:");

// Serial.print(yawG);

// Serial.print(',');

Serial.print("UL:");

Serial.print(90);

Serial.print(',');

Serial.print("LL:");

Serial.println(-90);

// Serial.print("Ax:");

// Serial.print(Ax);

// Serial.print(',');

// Serial.print("Ay:");

// Serial.print(Ay);

// Serial.print(',');

// Serial.print("Az:");

// Serial.print(Az);

// Serial.print(',');

// Serial.print("UL:");

// Serial.print(1);

// Serial.print(',');

// Serial.print("LL:");

// Serial.println(-1);

delay(1);

}

Arduino

Reducing Gyro Drift in MPU6050 IMU Arduino Project

September 11, 2025 admin

In this video lesson we learn how to reduce drift in our roll, pitch, and yaw from the MPU6050 IMU Arduino Project. We will be using the following schematic in today’s work.

This is the code we developed in this lesson:

#include <Adafruit_MPU6050.h>
#include <Adafruit_Sensor.h>
#include <Wire.h>
float Ax;
float Ay;
float Az;

float Gx;
float Gy;
float Gz;

float rollG=0;
float pitchG=0;
float yawG=0;

float gyroXOffset=0;
float gyroYOffset=0;
float gyroZOffset=0;

int tStart = millis();

// If You want Calibrated results, you must rotate
// your board to all possible orientations, and
// record your velues of xMax, xMin, yMax, yMin
// zMax, zMin. I show you how to do that in LESSON
// 79 on my youtube channel. Put in your values and then
// uncomment the code below. Don't use my values, you have
// to measure your own for it to work.

// float xMax= 1.03;
// float xMin= -.97;
// float yMax= .98;
// float yMin= -1.01;
// float zMax=.96 ;
// float zMin= -1.08;

// float xOffset = (xMax+xMin)/2;
// float yOffset = (yMax+yMin)/2;
// float zOffset = (zMax+zMin)/2;

// float xScale = 2/(xMax -xMin);
// float yScale = 2/(yMax - yMin);
// float zScale = 2/(zMax -zMin);

float roll = 0;

float pitch = 0;
float rollRAW;
float pitchRAW;

Adafruit_MPU6050 mpu;

void calibrateGyro(){
Serial.println("Calibrating the Gyro: Keep Completely Stationary");
delay(1000);
int i;
float sumX = 0;
float sumY = 0;
float sumZ = 0;
int numPoints=1000;
for (i=0;i<numPoints;i=i+1){
  sensors_event_t a, g, temp;
  mpu.getEvent(&a, &g, &temp);
  sumX = sumX + g.gyro.x;
  sumY = sumY + g.gyro.y;
  sumZ = sumZ + g.gyro.z;
  delay(10);
}
gyroXOffset = sumX/numPoints;
gyroYOffset = sumY/numPoints;
gyroZOffset = sumZ/numPoints;

}

void setup() {
  // put your setup code here, to run once:
  Serial.begin(115200);
  mpu.begin();
  Serial.println("MPU6050 Started!");
  mpu.setAccelerometerRange(MPU6050_RANGE_2_G);
  mpu.setGyroRange(MPU6050_RANGE_2000_DEG);
  mpu.setFilterBandwidth(MPU6050_BAND_21_HZ);
calibrateGyro();
tStart = millis();
}

void loop() {
  // put your main code here, to run repeatedly:
  sensors_event_t a, g, temp;
  mpu.getEvent(&a, &g, &temp);
  Ax = a.acceleration.x / 9.81;
  Ay = a.acceleration.y / 9.81;
  Az = a.acceleration.z / 9.81;

  Gx = g.gyro.x-gyroXOffset;
  Gy = g.gyro.y-gyroYOffset;
  Gz = g.gyro.z-gyroZOffset;

rollG = rollG + (millis() - tStart)/1000. * Gy *360./2./3.14;
pitchG = pitchG + (millis() - tStart)/1000. * Gx *360./2./3.14;
yawG = yawG + (millis() - tStart)/1000. * Gz *360./2./3.14;
tStart = millis();

  //Uncomment these lines of code to do the callibration
  //This will only work if you have measured your max
  //and min values, and put them in at the top of the code
  // Ax = xScale*(Ax-xOffset);
  // Ay = yScale*(Ay-yOffset);
  // Az = zScale*(Az-zOffset);

  pitchRAW = atan2(Ay, sqrt(Az * Az + Ax * Ax)) * 360 / (2 * 3.14);
  rollRAW = atan2(Ax, sqrt(Az * Az + Ay * Ay)) * 360 / (2 * 3.14);

  pitch = .75 * pitch + .25 * pitchRAW;
  roll = .75 * roll + .25 * rollRAW;

  Serial.print("Gx:");
  Serial.print(Gx);
  Serial.print(',');
  Serial.print("Gy:");
  Serial.print(Gy);
  Serial.print(',');
  Serial.print("Gz:");
  Serial.print(Gz);
  Serial.print(',');
  Serial.print("rollG:");
  Serial.print(rollG);
  Serial.print(',');
  Serial.print("pitchG:");
  Serial.print(pitchG);
  Serial.print(',');
  Serial.print("yawG:");
  Serial.print(yawG);
  Serial.print(',');
  Serial.print("UL:");
  Serial.print(90);
  Serial.print(',');
  Serial.print("LL:");
  Serial.println(-90);

  //   Serial.print("Ax:");
  //   Serial.print(Ax);
  //   Serial.print(',');
  //   Serial.print("Ay:");
  //   Serial.print(Ay);
  //   Serial.print(',');
  //     Serial.print("Az:");
  //   Serial.print(Az);
  //   Serial.print(',');
  //  Serial.print("UL:");
  //  Serial.print(1);
  //  Serial.print(',');
  //  Serial.print("LL:");
  //  Serial.println(-1);
  delay(1);
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

#include <Adafruit_MPU6050.h>

#include <Adafruit_Sensor.h>

#include <Wire.h>

float Ax;

float Ay;

float Az;

float Gx;

float Gy;

float Gz;

float rollG=0;

float pitchG=0;

float yawG=0;

float gyroXOffset=0;

float gyroYOffset=0;

float gyroZOffset=0;

int tStart = millis();

// If You want Calibrated results, you must rotate

// your board to all possible orientations, and

// record your velues of xMax, xMin, yMax, yMin

// zMax, zMin. I show you how to do that in LESSON

// 79 on my youtube channel. Put in your values and then

// uncomment the code below. Don't use my values, you have

// to measure your own for it to work.

// float xMax= 1.03;

// float xMin= -.97;

// float yMax= .98;

// float yMin= -1.01;

// float zMax=.96 ;

// float zMin= -1.08;

// float xOffset = (xMax+xMin)/2;

// float yOffset = (yMax+yMin)/2;

// float zOffset = (zMax+zMin)/2;

// float xScale = 2/(xMax -xMin);

// float yScale = 2/(yMax - yMin);

// float zScale = 2/(zMax -zMin);

float roll = 0;

float pitch = 0;

float rollRAW;

float pitchRAW;

Adafruit_MPU6050 mpu;

void calibrateGyro(){

Serial.println("Calibrating the Gyro: Keep Completely Stationary");

delay(1000);

int i;

float sumX = 0;

float sumY = 0;

float sumZ = 0;

int numPoints=1000;

for (i=0;i<numPoints;i=i+1){

sensors_event_t a, g, temp;

mpu.getEvent(&a, &g, &temp);

sumX = sumX + g.gyro.x;

sumY = sumY + g.gyro.y;

sumZ = sumZ + g.gyro.z;

delay(10);

}

gyroXOffset = sumX/numPoints;

gyroYOffset = sumY/numPoints;

gyroZOffset = sumZ/numPoints;

}

void setup() {

// put your setup code here, to run once:

Serial.begin(115200);

mpu.begin();

Serial.println("MPU6050 Started!");

mpu.setAccelerometerRange(MPU6050_RANGE_2_G);

mpu.setGyroRange(MPU6050_RANGE_2000_DEG);

mpu.setFilterBandwidth(MPU6050_BAND_21_HZ);

calibrateGyro();

tStart = millis();

}

void loop() {

// put your main code here, to run repeatedly:

sensors_event_t a, g, temp;

mpu.getEvent(&a, &g, &temp);

Ax = a.acceleration.x / 9.81;

Ay = a.acceleration.y / 9.81;

Az = a.acceleration.z / 9.81;

Gx = g.gyro.x-gyroXOffset;

Gy = g.gyro.y-gyroYOffset;

Gz = g.gyro.z-gyroZOffset;

rollG = rollG + (millis() - tStart)/1000. * Gy *360./2./3.14;

pitchG = pitchG + (millis() - tStart)/1000. * Gx *360./2./3.14;

yawG = yawG + (millis() - tStart)/1000. * Gz *360./2./3.14;

tStart = millis();

//Uncomment these lines of code to do the callibration

//This will only work if you have measured your max

//and min values, and put them in at the top of the code

// Ax = xScale*(Ax-xOffset);

// Ay = yScale*(Ay-yOffset);

// Az = zScale*(Az-zOffset);

pitchRAW = atan2(Ay, sqrt(Az * Az + Ax * Ax)) * 360 / (2 * 3.14);

rollRAW = atan2(Ax, sqrt(Az * Az + Ay * Ay)) * 360 / (2 * 3.14);

pitch = .75 * pitch + .25 * pitchRAW;

roll = .75 * roll + .25 * rollRAW;

Serial.print("Gx:");

Serial.print(Gx);

Serial.print(',');

Serial.print("Gy:");

Serial.print(Gy);

Serial.print(',');

Serial.print("Gz:");

Serial.print(Gz);

Serial.print(',');

Serial.print("rollG:");

Serial.print(rollG);

Serial.print(',');

Serial.print("pitchG:");

Serial.print(pitchG);

Serial.print(',');

Serial.print("yawG:");

Serial.print(yawG);

Serial.print(',');

Serial.print("UL:");

Serial.print(90);

Serial.print(',');

Serial.print("LL:");

Serial.println(-90);

// Serial.print("Ax:");

// Serial.print(Ax);

// Serial.print(',');

// Serial.print("Ay:");

// Serial.print(Ay);

// Serial.print(',');

// Serial.print("Az:");

// Serial.print(Az);

// Serial.print(',');

// Serial.print("UL:");

// Serial.print(1);

// Serial.print(',');

// Serial.print("LL:");

// Serial.println(-1);

delay(1);

}

Python, Raspberry Pi Pico

Measure Distance Between Two GPS Points with the Haversine Equations

September 9, 2025 admin

In this video lesson we show how we can modify our GPS tracker project to calculate the distance between any two GPS points. User presses the onboard button to log the first data point. Then the user travels to the next point, and then presses the button again. The system calculates the distance between those two points, and the heading angle between the first and second point.

This is a schematic of the circuit we are using:

For your convenience, this is the code developed in the video lesson:

from machine import Pin,I2C,UART
import time
import _thread
from ssd1306 import SSD1306_I2C
import math

utcCorrect = 3
earthRadius = 6371000
i2c2 = I2C(1, sda=Pin(2), scl=Pin(3), freq=400000)
dsp = SSD1306_I2C(128,64,i2c2)

sysState = 0

dataLock = _thread.allocate_lock()
keepRunning = True
GPS = UART(1, baudrate=9600, tx=machine.Pin(8), rx=machine.Pin(9))
# Reset GPS
GPS.write(b'$PMTK314,-1*04\r\n')
#The following line ensures that the GPS reports the GPVTG NMEA Sentence
GPS.write(b"$PMTK314,0,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0*28\r\n")
NMEAdata = {
    'GPGGA' : "",
    'GPGSA' : "",
    'GPRMC' : "",
    'GPVTG' : ""
    }
GPSdata = {
    'latDD' 	: 0,
    'lonDD'		: 0,
    'heading'	: 0,
    'fix'		: False,
    'sats'		: 0,
    'knots'		: 0,
    'time'		: '00:00:00',
    'date'		: '00/00/0000',
    'alt'		: 0.0
    }
def calculateDistance(lat1,lon1,lat2,lon2):
    lat1=lat1*2*math.pi/360
    lon1=lon1*2*math.pi/360
    lat2=lat2*2*math.pi/360
    lon2=lon2*2*math.pi/360
    theta = 2*math.asin(math.sqrt(
        math.sin((lat2-lat1)/2)**2 +
        math.cos(lat1)*math.cos(lat2)*math.sin((lon2-lon1)/2)**2
        ))
    distance = earthRadius * theta
    return distance
def calculateHeading(lat1,lon1,lat2,lon2):
    lat1=lat1*2*math.pi/360
    lon1=lon1*2*math.pi/360
    lat2=lat2*2*math.pi/360
    lon2=lon2*2*math.pi/360
    deltaLon=lon2-lon1
    xC=math.sin(deltaLon)*math.cos(lat2)
    yC=math.cos(lat1)*math.sin(lat2)-math.sin(lat1)*math.cos(lat2)*math.cos(deltaLon)
    beta = math.atan2(xC,yC)
    betaDeg = beta*360/2/math.pi
    return betaDeg
def gpsThread():
    print("Thread Running")
    global keepRunning,NMEAdata
    GPGGA = ""
    GPGSA = ""
    GPRMC = ""
    GPVTG = ""
    while not GPS.any():
        pass
    while GPS.any():
        junk = GPS.read()
        print(junk)
    myNMEA = ""
    while keepRunning:
        if GPS.any():
            myChar=GPS.read(1).decode('utf-8')
            myNMEA = myNMEA + myChar
            if myChar == '\n':
                myNMEA = myNMEA.strip()
                if myNMEA[1:6] == "GPGGA":
                    GPGGA = myNMEA
                if myNMEA[1:6] == "GPGSA":
                    GPGSA = myNMEA
                if myNMEA[1:6] == "GPRMC":
                    GPRMC = myNMEA
                if myNMEA[1:6] == "GPVTG":
                    GPVTG = myNMEA
                if GPGGA != "" and GPGSA!="" and GPRMC!="" and GPVTG!="":
                    dataLock.acquire()
                    NMEAdata = {
                        'GPGGA' : GPGGA,
                        'GPGSA' : GPGSA,
                        'GPRMC' : GPRMC,
                        'GPVTG' : GPVTG
                        }
                    dataLock.release()
                myNMEA = ""
    print("Thread Terminated Cleanly")
def parseGPS():
    readFix=int(NMEAmain['GPGGA'].split(',')[6])
    if readFix !=0:
        GPSdata['fix'] = True
        latRAW = NMEAmain['GPGGA'].split(',')[2]
        latDD = int(latRAW[0:2]) + float(latRAW[2:])/60
        if NMEAmain['GPGGA'].split(',')[3] == 'S':
            latDD = -latDD
        GPSdata['latDD']= latDD
        lonRAW=NMEAmain['GPGGA'].split(',')[4]
        lonDD=int(lonRAW[0:3]) + float(lonRAW[3:])/60
        if NMEAmain['GPGGA'].split(',')[5] == 'W':
            lonDD = -lonDD
        GPSdata['lonDD'] = lonDD
        heading = float(NMEAmain['GPRMC'].split(',')[8])
        GPSdata['heading'] = heading
        knots = float(NMEAmain['GPRMC'].split(',')[7])
        GPSdata['knots'] = knots
        sats = int(NMEAmain['GPGGA'].split(',')[7])
        GPSdata['sats'] = sats
        utcTime = NMEAmain['GPGGA'].split(',')[1]
        utcDate = NMEAmain['GPRMC'].split(',')[9]
        # utcTime = "013445.000"
        # utcDate = "010125"

        # Extract year from UTC date (format: DDMMYY), prepend '20' for full year (e.g., '25' → '2025')
        myYear = '20' + utcDate[4:]
        # Extract month from UTC date (e.g., '01' for January)
        myMonth = utcDate[2:4]
        # Extract day from UTC date (e.g., '01' for 1st)
        myDay = utcDate[0:2]
        # Calculate hours by adding UTC offset to UTC hours, convert to string
        myHours = str(int(utcTime[0:2]) + utcCorrect)
        # Extract minutes from UTC time (e.g., '34' from '013445.000')
        myMin = utcTime[2:4]
        # Extract seconds from UTC time (e.g., '45' from '013445.000')
        mySec = utcTime[4:6]

        # Define array of maximum days per month (index 0-11 for months 1-12: Jan to Dec)
        maxDays = ['31', '28', '31', '30', '31', '30', '31', '31', '30', '31', '30', '31']

        # Check if year is a leap year (simplified: divisible by 4); if so, set February to 29 days
        if int(myYear) % 4 == 0:
            maxDays[1] = '29'

        # Check if hours exceed 24 (for positive UTC offsets, e.g., UTC 22:00 + 5 = 27:00)
        if int(myHours) >= 24:
            # Subtract 24 from hours to wrap around to next day (e.g., 27 → 3)
            myHours = str(int(myHours) - 24)
            # Pad hours with leading zero if single digit (e.g., '3' → '03')
            if len(myHours) < 2:
                myHours = '0' + myHours
            # Increment day to account for crossing midnight (e.g., 30 → 31)
            myDay = str(int(myDay) + 1)
            # Check if day exceeds maximum days for the current month (e.g., June 31 > 30)
            if int(myDay) > int(maxDays[int(myMonth) - 1]):
                # Reset day to 1 for the next month
                myDay = '01'
                # Increment month (e.g., June → July)
                myMonth = str(int(myMonth) + 1)
                # Check if month exceeds 12 (e.g., December → January)
                if int(myMonth) > 12:
                    # Reset month to January
                    myMonth = '01'
                    # Increment year (e.g., 2025 → 2026)
                    myYear = str(int(myYear) + 1)
            # Pad day with leading zero if single digit (e.g., '1' → '01')
            if len(myDay) < 2:
                myDay = '0' + myDay
            # Pad month with leading zero if single digit (e.g., '7' → '07')
            if len(myMonth) < 2:
                myMonth = '0' + myMonth

        # Check if hours are negative (for negative UTC offsets, e.g., UTC 01:00 - 5 = -4)
        if int(myHours) < 0:
            # Add 24 to hours to wrap around to previous day (e.g., -4 → 20)
            myHours = str(int(myHours) + 24)
            # Pad hours with leading zero if single digit (e.g., '3' → '03')
            if len(myHours) < 2:
                myHours = '0' + myHours
            # Decrement day to account for crossing midnight backward (e.g., 01 → 00)
            myDay = str(int(myDay) - 1)
            # Check if day is less than 1 (e.g., January 1 → December 31)
            if int(myDay) < 1:
                # Decrement month (e.g., January → December)
                myMonth = str(int(myMonth) - 1)
                # Check if month is less than 1 (e.g., January → December of previous year)
                if int(myMonth) < 1:
                    # Set month to December
                    myMonth = '12'
                    # Decrement year (e.g., 2025 → 2024)
                    myYear = str(int(myYear) - 1)
                # Set day to maximum days of the new month (e.g., December → 31)
                myDay = maxDays[int(myMonth) - 1]
            # Pad day with leading zero if single digit (e.g., '1' → '01')
            if len(myDay) < 2:
                myDay = '0' + myDay
            # Pad month with leading zero if single digit (e.g., '7' → '07')
            if len(myMonth) < 2:
                myMonth = '0' + myMonth

        # Combine hours, minutes, seconds into time string (e.g., '20:34:45')
        myTime = myHours + ':' + myMin + ':' + mySec
        # Combine month, day, year into date string (e.g., '12/31/2024')
        myDate = myMonth + '/' + myDay + '/' + myYear
        # Store local time in GPSdata dictionary
        GPSdata['time'] = myTime
        # Store local date in GPSdata dictionary
        GPSdata['date'] = myDate
        GPSdata['alt'] = float(NMEAmain['GPGGA'].split(',')[9])
def dispOLED():
    global sysState,latitude1,longitude1,latitude2,longitude2
    dsp.fill(0)
    if GPSdata['fix'] == False:
        dsp.text("Waiting for Fix . . .",0,0)
    if GPSdata['fix'] == True:
        if sysState%5== 0:
            dsp.fill(0)
            dsp.text("Ultimate GPS",0,0)
            dsp.text(GPSdata['date'][0:5] + ' '+GPSdata['time'],0,16)
            dsp.text("LAT: "+str(GPSdata['latDD']),0,26)
            dsp.text("LON: "+str(GPSdata['lonDD']),0,36)
            dsp.text("SATS: "+str(GPSdata['sats']),0,46)

        if sysState%5==1:
            latitude1=GPSdata['latDD']
            longitude1=GPSdata['lonDD']
            sysState = 2
        if sysState%5==2:
            dsp.fill(0)
            dsp.text("Ultimate GPS",0,0)
            dsp.text(GPSdata['date'][0:5] + ' '+GPSdata['time'],0,16)
            dsp.text("P1 lat "+str(latitude1),0,26)
            dsp.text("P1 lon "+str(longitude1),0,36)
            dsp.text("Proceed to P2",0,46)
            dsp.text("Then Press Btn",0,56)
        if sysState%5==3:
            latitude2=GPSdata['latDD']
            longitude2=GPSdata['lonDD']
            sysState=4
        if sysState%5==4:
            dsp.fill(0)
            dsp.text("Ultimate GPS",0,0)
            dsp.text(GPSdata['date'][0:5] + ' '+GPSdata['time'],0,16)
            dist=calculateDistance(latitude1,longitude1,latitude2,longitude2)
            head=calculateHeading(latitude1,longitude1,latitude2,longitude2)
            dsp.text("Dist: "+str(dist),0,26)
            dsp.text("Head: "+str(head),0,36)
    dsp.show()
butOnePin = 12
butOne = Pin(butOnePin, Pin.IN, Pin.PULL_UP)
butOneUp = 0
butOneDown = 0
butOneOld = 1

def butOneIRQ(pin):
    global butOneUp,butOneDown,butOneOld,sysState
    butOneValue = butOne.value()
    if butOneValue==0:
        butOneDown=time.ticks_ms()
    if butOneValue==1:
        butOneUp = time.ticks_ms()
    if butOneOld==1 and butOneValue==0 and butOneDown-butOneUp>50:
        sysState = sysState + 1
        print('Button One Triggered')
    butOneOld=butOneValue
    
butOne.irq(trigger=Pin.IRQ_FALLING | Pin.IRQ_RISING , handler = butOneIRQ)
 
_thread.start_new_thread(gpsThread,())
time.sleep(3)
try:
    while True:
        dataLock.acquire()
        NMEAmain = NMEAdata.copy()
        dataLock.release()
        parseGPS()
        if GPSdata['fix'] == False:
            print("Waiting for Fix . . .")
        if GPSdata['fix'] == True:
            print("Ultimate GPS Tracker Report: ")
            print(GPSdata['time'],GPSdata['date'])
            print("Lat and Lon: ",GPSdata['latDD'],GPSdata['lonDD'])
            print("Knots: ",GPSdata['knots'])
            print("Heading: ",GPSdata['heading'])
            print("Elevation: ",GPSdata['alt'])
            print("Sats: ",GPSdata['sats'])
            print()
        dispOLED()
        time.sleep(1)


except KeyboardInterrupt:
    print("\nStopping Program . . . Cleaning Up UART")
    keepRunning = False
    time.sleep(1)
    GPS.deinit()
    time.sleep(1)
    dsp.fill(0)
    dsp.show()
    print("Exited Cleanly")

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

255

256

257

258

259

260

261

262

263

264

265

266

267

268

269

270

271

272

273

274

275

276

277

278

279

280

281

282

283

284

285

286

287

288

289

290

291

292

293

294

295

296

297

298

from machine import Pin,I2C,UART

import time

import _thread

from ssd1306 import SSD1306_I2C

import math

utcCorrect = 3

earthRadius = 6371000

i2c2 = I2C(1, sda=Pin(2), scl=Pin(3), freq=400000)

dsp = SSD1306_I2C(128,64,i2c2)

sysState = 0

dataLock = _thread.allocate_lock()

keepRunning = True

GPS = UART(1, baudrate=9600, tx=machine.Pin(8), rx=machine.Pin(9))

# Reset GPS

GPS.write(b'$PMTK314,-1*04\r\n')

#The following line ensures that the GPS reports the GPVTG NMEA Sentence

GPS.write(b"$PMTK314,0,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0*28\r\n")

NMEAdata = {

'GPGGA' : "",

'GPGSA' : "",

'GPRMC' : "",

'GPVTG' : ""

}

GPSdata = {

'latDD' : 0,

'lonDD' : 0,

'heading' : 0,

'fix' : False,

'sats' : 0,

'knots' : 0,

'time' : '00:00:00',

'date' : '00/00/0000',

'alt' : 0.0

}

def calculateDistance(lat1,lon1,lat2,lon2):

lat1=lat1*2*math.pi/360

lon1=lon1*2*math.pi/360

lat2=lat2*2*math.pi/360

lon2=lon2*2*math.pi/360

theta = 2*math.asin(math.sqrt(

math.sin((lat2-lat1)/2)**2 +

math.cos(lat1)*math.cos(lat2)*math.sin((lon2-lon1)/2)**2

))

distance = earthRadius * theta

return distance

def calculateHeading(lat1,lon1,lat2,lon2):

lat1=lat1*2*math.pi/360

lon1=lon1*2*math.pi/360

lat2=lat2*2*math.pi/360

lon2=lon2*2*math.pi/360

deltaLon=lon2-lon1

xC=math.sin(deltaLon)*math.cos(lat2)

yC=math.cos(lat1)*math.sin(lat2)-math.sin(lat1)*math.cos(lat2)*math.cos(deltaLon)

beta = math.atan2(xC,yC)

betaDeg = beta*360/2/math.pi

return betaDeg

def gpsThread():

print("Thread Running")

global keepRunning,NMEAdata

GPGGA = ""

GPGSA = ""

GPRMC = ""

GPVTG = ""

while not GPS.any():

pass

while GPS.any():

junk = GPS.read()

print(junk)

myNMEA = ""

while keepRunning:

if GPS.any():

myChar=GPS.read(1).decode('utf-8')

myNMEA = myNMEA + myChar

if myChar == '\n':

myNMEA = myNMEA.strip()

if myNMEA[1:6] == "GPGGA":

GPGGA = myNMEA

if myNMEA[1:6] == "GPGSA":

GPGSA = myNMEA

if myNMEA[1:6] == "GPRMC":

GPRMC = myNMEA

if myNMEA[1:6] == "GPVTG":

GPVTG = myNMEA

if GPGGA != "" and GPGSA!="" and GPRMC!="" and GPVTG!="":

dataLock.acquire()

NMEAdata = {

'GPGGA' : GPGGA,

'GPGSA' : GPGSA,

'GPRMC' : GPRMC,

'GPVTG' : GPVTG

}

dataLock.release()

myNMEA = ""

print("Thread Terminated Cleanly")

def parseGPS():

readFix=int(NMEAmain['GPGGA'].split(',')[6])

if readFix !=0:

GPSdata['fix'] = True

latRAW = NMEAmain['GPGGA'].split(',')[2]

latDD = int(latRAW[0:2]) + float(latRAW[2:])/60

if NMEAmain['GPGGA'].split(',')[3] == 'S':

latDD = -latDD

GPSdata['latDD']= latDD

lonRAW=NMEAmain['GPGGA'].split(',')[4]

lonDD=int(lonRAW[0:3]) + float(lonRAW[3:])/60

if NMEAmain['GPGGA'].split(',')[5] == 'W':

lonDD = -lonDD

GPSdata['lonDD'] = lonDD

heading = float(NMEAmain['GPRMC'].split(',')[8])

GPSdata['heading'] = heading

knots = float(NMEAmain['GPRMC'].split(',')[7])

GPSdata['knots'] = knots

sats = int(NMEAmain['GPGGA'].split(',')[7])

GPSdata['sats'] = sats

utcTime = NMEAmain['GPGGA'].split(',')[1]

utcDate = NMEAmain['GPRMC'].split(',')[9]

# utcTime = "013445.000"

# utcDate = "010125"

# Extract year from UTC date (format: DDMMYY), prepend '20' for full year (e.g., '25' → '2025')

myYear = '20' + utcDate[4:]

# Extract month from UTC date (e.g., '01' for January)

myMonth = utcDate[2:4]

# Extract day from UTC date (e.g., '01' for 1st)

myDay = utcDate[0:2]

# Calculate hours by adding UTC offset to UTC hours, convert to string

myHours = str(int(utcTime[0:2]) + utcCorrect)

# Extract minutes from UTC time (e.g., '34' from '013445.000')

myMin = utcTime[2:4]

# Extract seconds from UTC time (e.g., '45' from '013445.000')

mySec = utcTime[4:6]

# Define array of maximum days per month (index 0-11 for months 1-12: Jan to Dec)

maxDays = ['31', '28', '31', '30', '31', '30', '31', '31', '30', '31', '30', '31']

# Check if year is a leap year (simplified: divisible by 4); if so, set February to 29 days

if int(myYear) % 4 == 0:

maxDays[1] = '29'

# Check if hours exceed 24 (for positive UTC offsets, e.g., UTC 22:00 + 5 = 27:00)

if int(myHours) >= 24:

# Subtract 24 from hours to wrap around to next day (e.g., 27 → 3)

myHours = str(int(myHours) - 24)

# Pad hours with leading zero if single digit (e.g., '3' → '03')

if len(myHours) < 2:

myHours = '0' + myHours

# Increment day to account for crossing midnight (e.g., 30 → 31)

myDay = str(int(myDay) + 1)

# Check if day exceeds maximum days for the current month (e.g., June 31 > 30)

if int(myDay) > int(maxDays[int(myMonth) - 1]):

# Reset day to 1 for the next month

myDay = '01'

# Increment month (e.g., June → July)

myMonth = str(int(myMonth) + 1)

# Check if month exceeds 12 (e.g., December → January)

if int(myMonth) > 12:

# Reset month to January

myMonth = '01'

# Increment year (e.g., 2025 → 2026)

myYear = str(int(myYear) + 1)

# Pad day with leading zero if single digit (e.g., '1' → '01')

if len(myDay) < 2:

myDay = '0' + myDay

# Pad month with leading zero if single digit (e.g., '7' → '07')

if len(myMonth) < 2:

myMonth = '0' + myMonth

# Check if hours are negative (for negative UTC offsets, e.g., UTC 01:00 - 5 = -4)

if int(myHours) < 0:

# Add 24 to hours to wrap around to previous day (e.g., -4 → 20)

myHours = str(int(myHours) + 24)

# Pad hours with leading zero if single digit (e.g., '3' → '03')

if len(myHours) < 2:

myHours = '0' + myHours

# Decrement day to account for crossing midnight backward (e.g., 01 → 00)

myDay = str(int(myDay) - 1)

# Check if day is less than 1 (e.g., January 1 → December 31)

if int(myDay) < 1:

# Decrement month (e.g., January → December)

myMonth = str(int(myMonth) - 1)

# Check if month is less than 1 (e.g., January → December of previous year)

if int(myMonth) < 1:

# Set month to December

myMonth = '12'

# Decrement year (e.g., 2025 → 2024)

myYear = str(int(myYear) - 1)

# Set day to maximum days of the new month (e.g., December → 31)

myDay = maxDays[int(myMonth) - 1]

# Pad day with leading zero if single digit (e.g., '1' → '01')

if len(myDay) < 2:

myDay = '0' + myDay

# Pad month with leading zero if single digit (e.g., '7' → '07')

if len(myMonth) < 2:

myMonth = '0' + myMonth

# Combine hours, minutes, seconds into time string (e.g., '20:34:45')

myTime = myHours + ':' + myMin + ':' + mySec

# Combine month, day, year into date string (e.g., '12/31/2024')

myDate = myMonth + '/' + myDay + '/' + myYear

# Store local time in GPSdata dictionary

GPSdata['time'] = myTime

# Store local date in GPSdata dictionary

GPSdata['date'] = myDate

GPSdata['alt'] = float(NMEAmain['GPGGA'].split(',')[9])

def dispOLED():

global sysState,latitude1,longitude1,latitude2,longitude2

dsp.fill(0)

if GPSdata['fix'] == False:

dsp.text("Waiting for Fix . . .",0,0)

if GPSdata['fix'] == True:

if sysState%5== 0:

dsp.fill(0)

dsp.text("Ultimate GPS",0,0)

dsp.text(GPSdata['date'][0:5] + ' '+GPSdata['time'],0,16)

dsp.text("LAT: "+str(GPSdata['latDD']),0,26)

dsp.text("LON: "+str(GPSdata['lonDD']),0,36)

dsp.text("SATS: "+str(GPSdata['sats']),0,46)

if sysState%5==1:

latitude1=GPSdata['latDD']

longitude1=GPSdata['lonDD']

sysState = 2

if sysState%5==2:

dsp.fill(0)

dsp.text("Ultimate GPS",0,0)

dsp.text(GPSdata['date'][0:5] + ' '+GPSdata['time'],0,16)

dsp.text("P1 lat "+str(latitude1),0,26)

dsp.text("P1 lon "+str(longitude1),0,36)

dsp.text("Proceed to P2",0,46)

dsp.text("Then Press Btn",0,56)

if sysState%5==3:

latitude2=GPSdata['latDD']

longitude2=GPSdata['lonDD']

sysState=4

if sysState%5==4:

dsp.fill(0)

dsp.text("Ultimate GPS",0,0)

dsp.text(GPSdata['date'][0:5] + ' '+GPSdata['time'],0,16)

dist=calculateDistance(latitude1,longitude1,latitude2,longitude2)

head=calculateHeading(latitude1,longitude1,latitude2,longitude2)

dsp.text("Dist: "+str(dist),0,26)

dsp.text("Head: "+str(head),0,36)

dsp.show()

butOnePin = 12

butOne = Pin(butOnePin, Pin.IN, Pin.PULL_UP)

butOneUp = 0

butOneDown = 0

butOneOld = 1

def butOneIRQ(pin):

global butOneUp,butOneDown,butOneOld,sysState

butOneValue = butOne.value()

if butOneValue==0:

butOneDown=time.ticks_ms()

if butOneValue==1:

butOneUp = time.ticks_ms()

if butOneOld==1 and butOneValue==0 and butOneDown-butOneUp>50:

sysState = sysState + 1

print('Button One Triggered')

butOneOld=butOneValue

butOne.irq(trigger=Pin.IRQ_FALLING | Pin.IRQ_RISING , handler = butOneIRQ)

_thread.start_new_thread(gpsThread,())

time.sleep(3)

try:

while True:

dataLock.acquire()

NMEAmain = NMEAdata.copy()

dataLock.release()

parseGPS()

if GPSdata['fix'] == False:

print("Waiting for Fix . . .")

if GPSdata['fix'] == True:

print("Ultimate GPS Tracker Report: ")

print(GPSdata['time'],GPSdata['date'])

print("Lat and Lon: ",GPSdata['latDD'],GPSdata['lonDD'])

print("Knots: ",GPSdata['knots'])

print("Heading: ",GPSdata['heading'])

print("Elevation: ",GPSdata['alt'])

print("Sats: ",GPSdata['sats'])

print()

dispOLED()

time.sleep(1)

except KeyboardInterrupt:

print("\nStopping Program . . . Cleaning Up UART")

keepRunning = False

time.sleep(1)

GPS.deinit()

time.sleep(1)

dsp.fill(0)

dsp.show()

print("Exited Cleanly")

Arduino, Python

Python PyQt5 Magnetometer Calibration Program

September 4, 2025 admin

In this video lesson we show how to calibrate a QMC5883L 3-Axis magnetometer using python and PyQt5. The program presents the user with a visual representation of the magnetic vector, allowing more precise calibration of the sensors. We are using the GY-87 module, and it is connected like this:

This is the simple code on the Arduino side, sending the raw magnetometer data:

#include <Adafruit_MPU6050.h>
#include <Adafruit_Sensor.h>
#include <Wire.h>
#include <QMC5883LCompass.h>
int x,y,z;
Adafruit_MPU6050 mpu;
QMC5883LCompass compass;
void setup() {
Serial.begin(115200);
mpu.begin();
mpu.setI2CBypass(true);
compass.init();
}
void loop() {
 compass.read();
 x = compass.getX();
 y = compass.getY();
 z = compass.getZ();
Serial.print(x);
Serial.print(',');
Serial.print(y);
Serial.print(',');
Serial.println(z);
 delay(100);
}

#include <Adafruit_MPU6050.h>

#include <Adafruit_Sensor.h>

#include <Wire.h>

#include <QMC5883LCompass.h>

int x,y,z;

Adafruit_MPU6050 mpu;

QMC5883LCompass compass;

void setup() {

Serial.begin(115200);

mpu.begin();

mpu.setI2CBypass(true);

compass.init();

}

void loop() {

compass.read();

x = compass.getX();

y = compass.getY();

z = compass.getZ();

Serial.print(x);

Serial.print(',');

Serial.print(y);

Serial.print(',');

Serial.println(z);

delay(100);

}

This is the calibration code, running on the Python side;

import serial
import numpy as np
from PyQt5 import QtWidgets, QtCore
import pyqtgraph as pg
serialPort = 'COM8'
baudRate =115200
to =.1
ser =serial.Serial(serialPort, baudRate, timeout=to)
maxPoints = 2000
xRaw = np.empty(0)
yRaw = np.empty(0)
zRaw = np.empty(0)

xCal = np.empty(0)
yCal = np.empty(0)
zCal = np.empty(0)

calibrated = False
offsets = np.zeros(3)
scales = np.ones(3)

app = QtWidgets.QApplication([])
mainWindow = QtWidgets.QWidget()
mainWindow.setWindowTitle("Magnetometer Calibratioin")
mainLayout =QtWidgets.QVBoxLayout()
mainWindow.setLayout(mainLayout)

statusLabel = QtWidgets.QLabel("Program Running: Not Calibrated")
statusLabel.setAlignment(QtCore.Qt.AlignCenter)
statusLabel.setStyleSheet("color: green; font-weight: bold; font-size: 20px;")
mainLayout.addWidget(statusLabel)

minMaxLabel=QtWidgets.QLabel("Min/Max: N/A")
minMaxLabel.setAlignment(QtCore.Qt.AlignCenter)
minMaxLabel.setStyleSheet("color: green; font-weight: bold; font-size: 16px;")
mainLayout.addWidget(minMaxLabel)

calibrateButton = QtWidgets.QPushButton("Start Calibration")
calibrateButton.setCheckable(True)
mainLayout.addWidget(calibrateButton)


plotLayout =QtWidgets.QGridLayout()
mainLayout.addLayout(plotLayout)
xyPlot = pg.PlotWidget(title="XY Plane")
yzPlot = pg.PlotWidget(title="YZ Plane")
xzPlot = pg.PlotWidget(title="XZ Plane")
for plot in [xyPlot, yzPlot, xzPlot]:
    plot.setAspectLocked(True)
    plot.showGrid(x=True, y=True)
    plot.setMinimumSize(300,300)
plotLayout.addWidget(xyPlot, 0,0)
plotLayout.addWidget(yzPlot, 0,1)
plotLayout.addWidget(xzPlot, 1,0)

xyScatter = pg.ScatterPlotItem(size=5)
yzScatter = pg.ScatterPlotItem(size=5)
xzScatter = pg.ScatterPlotItem(size=5)

xyPlot.addItem(xyScatter)
yzPlot.addItem(yzScatter)
xzPlot.addItem(xzScatter)

def toggleCalibration():
    global calibrated, xRaw, yRaw, zRaw, xCal, yCal, zCal, offsets, scales
    
    if calibrateButton.isChecked():
        calibrateButton.setText("Stop Calibration")
        statusLabel.setText("Mode: Calibration")
        statusLabel.setStyleSheet("color: red; font-weight: bold; font-size: 20px;")
        minMaxLabel.setText("Min/Max: collecting . . .")
        minMaxLabel.setStyleSheet("color: red; font-weight: bold; font-size: 16px;")
        calibrated = False
        xRaw = np.empty(0)
        yRaw = np.empty(0)
        zRaw = np.empty(0)
    if not calibrateButton.isChecked():
        calibrateButton.setText("Start Calibration")
        statusLabel.setText("Mode: Calibrated")
        statusLabel.setStyleSheet("color: green; font-weight: bold; font-size: 20px;")
        
        rawData = np.column_stack((xRaw,yRaw,zRaw))
        minVals = np.min(rawData, axis=0)
        maxVals = np.max(rawData, axis=0)
        offsets = (maxVals + minVals)/2
        scales = 2.0/(maxVals-minVals)
        minMaxLabel.setStyleSheet("color: green; font-weight: bold; font-size: 16px;")
        minMaxLabel.setText("Min(x,y,z: "+str(minVals.round(2))+" Max(x,y,z): "
                            +str(maxVals.round(2))+" Offsets(x,y,z): "+str(offsets.round(2))
                            +"Scales(x,y,z): "+str(scales.round(5)))
        print("Calibration Completed.")
        print("Offsets: ", offsets)
        print("Scales: ", scales)
        
        xCal = np.empty(0)
        yCal = np.empty(0)
        zCal = np.empty(0)
        calibrated = True

calibrateButton.clicked.connect(toggleCalibration)
        
def updatePlot():
    global xRaw, yRaw, zRaw, xCal, yCal, zCal
    if ser.in_waiting > 0:
        try:
            line= ser.readline().decode('utf-8').strip()
            values = line.split(',')
            if len(values)==3:
                x = float(values[0])
                y = float(values[1])
                z = float(values[2])
                if not calibrated:
                    xRaw =np.append(xRaw, x)[-maxPoints:]
                    yRaw =np.append(yRaw, y)[-maxPoints:]
                    zRaw =np.append(zRaw, z)[-maxPoints:]
                    xyScatter.setData(x=xRaw, y=yRaw, brush=pg.mkBrush(0,0,255,255))
                    yzScatter.setData(x=yRaw, y=zRaw, brush=pg.mkBrush(0,255,0,255))
                    xzScatter.setData(x=xRaw, y=zRaw, brush=pg.mkBrush(255,0,0,255))
                    
                    if len(xRaw)>10:
                        minVals = np.min(np.column_stack((xRaw,yRaw,zRaw)),axis=0)
                        maxVals = np.max(np.column_stack((xRaw,yRaw,zRaw)),axis=0)
                        
                        minMaxLabel.setStyleSheet("color: red; font-weight: bold; font-size: 16px;")
                        minMaxLabel.setText("Min(x,y,z: "+str(minVals.round(2))+" Max(x,y,z): "
                            +str(maxVals.round(2)))
                
                if calibrated:
                    xC= (x - offsets[0])*scales[0]
                    yC= (y - offsets[1])*scales[1]
                    zC= (z - offsets[2])*scales[2]
                    
                    xCal = np.append(xCal, xC)[-maxPoints:]
                    yCal = np.append(yCal, yC)[-maxPoints:]
                    zCal = np.append(zCal, zC)[-maxPoints:]
                    
                    xyScatter.setData(x=xCal, y=yCal, brush=pg.mkBrush(0,0,255,120))
                    yzScatter.setData(x=yCal, y=zCal, brush=pg.mkBrush(0,255,0,120))
                    xzScatter.setData(x=xCal, y=zCal, brush=pg.mkBrush(255,0,0,120))             
        
        except Exception as e:
            print("Parse Error: ", e)

plotTimer =QtCore.QTimer()
plotTimer.timeout.connect(updatePlot)
plotTimer.start(50)
mainWindow.show()
try:
    app.exec_()
finally:
    ser.close()

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

import serial

import numpy as np

from PyQt5 import QtWidgets, QtCore

import pyqtgraph as pg

serialPort = 'COM8'

baudRate =115200

to =.1

ser =serial.Serial(serialPort, baudRate, timeout=to)

maxPoints = 2000

xRaw = np.empty(0)

yRaw = np.empty(0)

zRaw = np.empty(0)

xCal = np.empty(0)

yCal = np.empty(0)

zCal = np.empty(0)

calibrated = False

offsets = np.zeros(3)

scales = np.ones(3)

app = QtWidgets.QApplication([])

mainWindow = QtWidgets.QWidget()

mainWindow.setWindowTitle("Magnetometer Calibratioin")

mainLayout =QtWidgets.QVBoxLayout()

mainWindow.setLayout(mainLayout)

statusLabel = QtWidgets.QLabel("Program Running: Not Calibrated")

statusLabel.setAlignment(QtCore.Qt.AlignCenter)

statusLabel.setStyleSheet("color: green; font-weight: bold; font-size: 20px;")

mainLayout.addWidget(statusLabel)

minMaxLabel=QtWidgets.QLabel("Min/Max: N/A")

minMaxLabel.setAlignment(QtCore.Qt.AlignCenter)

minMaxLabel.setStyleSheet("color: green; font-weight: bold; font-size: 16px;")

mainLayout.addWidget(minMaxLabel)

calibrateButton = QtWidgets.QPushButton("Start Calibration")

calibrateButton.setCheckable(True)

mainLayout.addWidget(calibrateButton)

plotLayout =QtWidgets.QGridLayout()

mainLayout.addLayout(plotLayout)

xyPlot = pg.PlotWidget(title="XY Plane")

yzPlot = pg.PlotWidget(title="YZ Plane")

xzPlot = pg.PlotWidget(title="XZ Plane")

for plot in [xyPlot, yzPlot, xzPlot]:

plot.setAspectLocked(True)

plot.showGrid(x=True, y=True)

plot.setMinimumSize(300,300)

plotLayout.addWidget(xyPlot, 0,0)

plotLayout.addWidget(yzPlot, 0,1)

plotLayout.addWidget(xzPlot, 1,0)

xyScatter = pg.ScatterPlotItem(size=5)

yzScatter = pg.ScatterPlotItem(size=5)

xzScatter = pg.ScatterPlotItem(size=5)

xyPlot.addItem(xyScatter)

yzPlot.addItem(yzScatter)

xzPlot.addItem(xzScatter)

def toggleCalibration():

global calibrated, xRaw, yRaw, zRaw, xCal, yCal, zCal, offsets, scales

if calibrateButton.isChecked():

calibrateButton.setText("Stop Calibration")

statusLabel.setText("Mode: Calibration")

statusLabel.setStyleSheet("color: red; font-weight: bold; font-size: 20px;")

minMaxLabel.setText("Min/Max: collecting . . .")

minMaxLabel.setStyleSheet("color: red; font-weight: bold; font-size: 16px;")

calibrated = False

xRaw = np.empty(0)

yRaw = np.empty(0)

zRaw = np.empty(0)

if not calibrateButton.isChecked():

calibrateButton.setText("Start Calibration")

statusLabel.setText("Mode: Calibrated")

statusLabel.setStyleSheet("color: green; font-weight: bold; font-size: 20px;")

rawData = np.column_stack((xRaw,yRaw,zRaw))

minVals = np.min(rawData, axis=0)

maxVals = np.max(rawData, axis=0)

offsets = (maxVals + minVals)/2

scales = 2.0/(maxVals-minVals)

minMaxLabel.setStyleSheet("color: green; font-weight: bold; font-size: 16px;")

minMaxLabel.setText("Min(x,y,z: "+str(minVals.round(2))+" Max(x,y,z): "

+str(maxVals.round(2))+" Offsets(x,y,z): "+str(offsets.round(2))

+"Scales(x,y,z): "+str(scales.round(5)))

print("Calibration Completed.")

print("Offsets: ", offsets)

print("Scales: ", scales)

xCal = np.empty(0)

yCal = np.empty(0)

zCal = np.empty(0)

calibrated = True

calibrateButton.clicked.connect(toggleCalibration)

def updatePlot():

global xRaw, yRaw, zRaw, xCal, yCal, zCal

if ser.in_waiting > 0:

try:

line= ser.readline().decode('utf-8').strip()

values = line.split(',')

if len(values)==3:

x = float(values[0])

y = float(values[1])

z = float(values[2])

if not calibrated:

xRaw =np.append(xRaw, x)[-maxPoints:]

yRaw =np.append(yRaw, y)[-maxPoints:]

zRaw =np.append(zRaw, z)[-maxPoints:]

xyScatter.setData(x=xRaw, y=yRaw, brush=pg.mkBrush(0,0,255,255))

yzScatter.setData(x=yRaw, y=zRaw, brush=pg.mkBrush(0,255,0,255))

xzScatter.setData(x=xRaw, y=zRaw, brush=pg.mkBrush(255,0,0,255))

if len(xRaw)>10:

minVals = np.min(np.column_stack((xRaw,yRaw,zRaw)),axis=0)

maxVals = np.max(np.column_stack((xRaw,yRaw,zRaw)),axis=0)

minMaxLabel.setStyleSheet("color: red; font-weight: bold; font-size: 16px;")

minMaxLabel.setText("Min(x,y,z: "+str(minVals.round(2))+" Max(x,y,z): "

+str(maxVals.round(2)))

if calibrated:

xC= (x - offsets[0])*scales[0]

yC= (y - offsets[1])*scales[1]

zC= (z - offsets[2])*scales[2]

xCal = np.append(xCal, xC)[-maxPoints:]

yCal = np.append(yCal, yC)[-maxPoints:]

zCal = np.append(zCal, zC)[-maxPoints:]

xyScatter.setData(x=xCal, y=yCal, brush=pg.mkBrush(0,0,255,120))

yzScatter.setData(x=yCal, y=zCal, brush=pg.mkBrush(0,255,0,120))

xzScatter.setData(x=xCal, y=zCal, brush=pg.mkBrush(255,0,0,120))

except Exception as e:

print("Parse Error: ", e)

plotTimer =QtCore.QTimer()

plotTimer.timeout.connect(updatePlot)

plotTimer.start(50)

mainWindow.show()

try:

app.exec_()

finally:

ser.close()

Technology Tutorials

Logging Data On Your Raspberry Pi Pico Using Flash Memory

Improving MPU6050 IMU Arduino Project Performance with a Complimentary Filter

Reducing Gyro Drift in MPU6050 IMU Arduino Project

Measure Distance Between Two GPS Points with the Haversine Equations

Python PyQt5 Magnetometer Calibration Program

Making The World a Better Place One High Tech Project at a Time. Enjoy!