In this video lesson we show you how you can transfer data from your Raspberry Pi Pico W GPS Project to your PC for display on Google Earth. This program transfers the Pi Pico GPS Log file to your PC, and as the transfer is done, the program converts the log.txt file into a .kml file for display on Google Earth.

import serial
import time
serialPort = 'COM7'
baudRate = 115200
ser = serial.Serial(serialPort, baudRate, timeout = .1)
time.sleep(1)
ser.write(b"f=open('log.txt','r')\r\n")
line = ser.readline().decode('utf-8').strip()
print("Initial Line: "+line)
time.sleep(.1)
kmlHeader = """<?xml version="1.0" encoding="UTF-8"?>
<kml xmlns="http://www.opengis.net/kml/2.2">
  <Document>
    <name>Path from Pico</name>
    <Style id="pointStyle">
      <IconStyle>
        <Icon><href>http://maps.google.com/mapfiles/kml/shapes/placemark_circle.png</href></Icon>
        <scale>1.0</scale>
      </IconStyle>
    </Style>
    <Style id="lineStyle">
      <LineStyle><color>ff0000ff</color><width>3</width></LineStyle>
    </Style>
    <Placemark>
      <styleUrl>#pointStyle</styleUrl>
      <MultiGeometry> """
pointStart = "<Point><coordinates>"
pointEnd = "</coordinates></Point>"
lineStringStart = """ </MultiGeometry>
    </Placemark>
    <Placemark>
      <name>Path</name>
      <styleUrl> #lineStyle</styleUrl>
      <LineString>
        <tessellate>1</tessellate>
        <altitudeMode>clampToGround</altitudeMode>
        <coordinates> """
lineStringEnd = """ </coordinates>
      </LineString>
    </Placemark>
  </Document>
</kml> """
with open('path.kml','w') as kml:
    kml.write(kmlHeader)
with open('lon-lat.txt', 'w') as lonLat:
    pass
with open('path.kml','a') as kml:
    with open('lon-lat.txt','a') as lonLat:
        while line != "''":
            ser.write(b"f.readline()\r\n")
            line = ser.readline().decode('utf-8').strip()
            line = ser.readline().decode('utf-8').strip()
            print("LINE: "+line)
            if line.startswith("'") and line !="''":
                line = line[1:-3]
                myData = line.split(',')
                line = myData[1]+','+myData[0]
                print("New Line: ",line)
                kml.write(pointStart+'\n'+line+ '\n'+pointEnd+'\n')              
                lonLat.write(line+ " "+'\n')
with open('lon-lat.txt','r') as lonLat:
    coordinates = lonLat.read()
print(coordinates)
with open('path.kml','a') as kml:
    kml.write(lineStringStart+'\n'+ coordinates+lineStringEnd)
ser.write(b"f.close()\r\n")
ser.close()
print("KML File Saved as "+ 'path.kml')

import serial

import time

serialPort = 'COM7'

baudRate = 115200

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

time.sleep(1)

ser.write(b"f=open('log.txt','r')\r\n")

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

print("Initial Line: "+line)

time.sleep(.1)

kmlHeader = """<?xml version="1.0" encoding="UTF-8"?>

<Icon><href>http://maps.google.com/mapfiles/kml/shapes/placemark_circle.png</href></Icon>

</IconStyle>

</Style>

</Style>

<styleUrl>#pointStyle</styleUrl>

<MultiGeometry> """

pointStart = "<Point><coordinates>"

pointEnd = "</coordinates></Point>"

lineStringStart = """ </MultiGeometry>

</Placemark>

<styleUrl> #lineStyle</styleUrl>

<altitudeMode>clampToGround</altitudeMode>

<coordinates> """

lineStringEnd = """ </coordinates>

</LineString>

</Placemark>

</Document>

</kml> """

with open('path.kml','w') as kml:

kml.write(kmlHeader)

with open('lon-lat.txt', 'w') as lonLat:

pass

with open('path.kml','a') as kml:

with open('lon-lat.txt','a') as lonLat:

while line != "''":

ser.write(b"f.readline()\r\n")

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

print("LINE: "+line)

if line.startswith("'") and line !="''":

line = line[1:-3]

myData = line.split(',')

line = myData[1]+','+myData[0]

print("New Line: ",line)

kml.write(pointStart+'\n'+line+ '\n'+pointEnd+'\n')

lonLat.write(line+ " "+'\n')

with open('lon-lat.txt','r') as lonLat:

coordinates = lonLat.read()

print(coordinates)

with open('path.kml','a') as kml:

kml.write(lineStringStart+'\n'+ coordinates+lineStringEnd)

ser.write(b"f.close()\r\n")

ser.close()

print("KML File Saved as "+ 'path.kml')

Arduino, Python

Improving Digital Compass Accuracy With a Low Pass Filter

October 22, 2025 admin

In this video lesson we add a low pass filter to our calibration and digital compass program. This allows more precise calibration, and removes the jitter from the digital compass display. We continue to use the QMC5883L 3-Axis Magnetometer, which is on our GY-87 IMU module. We are using the following schematic for our project:

MPU6050 — Schematic for connecting the GY-87 module to the Arduino

We collect the data using the GY-87 connected to an Arduino. Below is the simple program which takes the magnetometer data and sends it to the serial port.

#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);

}

The code for the Python side to do the calibration and display a Digital Compass is:

import serial
import numpy as np
from PyQt5 import QtWidgets, QtCore, QtGui
import pyqtgraph as pg
import math
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)
x=0
y=0
z=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)

headingPlot = pg.PlotWidget(title="Compass Heading")
headingPlot.setAspectLocked(True)
headingPlot.showGrid(x=True, y=True)
headingPlot.setMinimumSize(300,300)
headingPlot.hideAxis('left')
headingPlot.hideAxis('bottom')
plotLayout.addWidget(headingPlot,1,1)

compassCircle=pg.EllipseROI([-1.5,-1.5],[3.,3.],pen=pg.mkPen('b',width=4),movable=False, resizable=False)
headingPlot.addItem(compassCircle)
compassCircle.removeHandle(0)
compassCircle.removeHandle(0)
compassCircle.setZValue(0)

arrowShaft=pg.PlotCurveItem( x=[0,0],y=[0,1.5],pen=pg.mkPen('r',width=4))
headingPlot.addItem(arrowShaft)
dot=pg.ScatterPlotItem(pos=[(0,1.5)],width=4,size=10,pen=pg.mkPen('y'),brush=pg.mkBrush('y'))
dot.setZValue(1)
headingPlot.addItem(dot)

for angle, label in zip([0,90,180,270],['E','N','W','S']):
    rad = angle/360*2*math.pi
    xPos = np.cos(rad)*1.8
    yPos = np.sin(rad)*1.8
    text=pg.TextItem(label, anchor = (.5,.5), color='g')
    font=QtGui.QFont()
    font.setBold(True)
    font.setPointSize(12)
    text.setFont(font)
    text.setPos(xPos,yPos)
    headingPlot.addItem(text)
    
liveHeading = pg.TextItem("Heading: 0.0\u00B0",anchor= (.5,.5),color='w')
liveHeading.setFont(font)
liveHeading.setPos(0,-2.2)
liveHeading.setZValue(1)
headingPlot.addItem(liveHeading)


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, x, y ,z
    if ser.in_waiting > 0:
        try:
            line= ser.readline().decode('utf-8').strip()
            values = line.split(',')
            if len(values)==3:
                x = x*.75 + float(values[0])*.25
                y = y*.75 + float(values[1])*.25
                z = z*.75 + float(values[2])*.25
                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))
                    
                    headRad= math.atan2(yC,xC)
                    headDeg=(headRad*360/2/math.pi)%360
                    compassRad= -headRad+ math.pi/2
                    compassDeg = (-headDeg + 90)%360
                    xDot=1.5*math.cos(compassRad)
                    yDot=1.5*math.sin(compassRad)
                    dot.setData(pos=([(xDot,yDot)]))
                    arrowShaft.setData(x=[0,xDot],y=[0,yDot])
                    liveHeading.setText("Heading: "+str(int(headDeg))+"\u00B0")      
        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

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

import serial

import numpy as np

from PyQt5 import QtWidgets, QtCore, QtGui

import pyqtgraph as pg

import math

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)

x=0

y=0

z=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)

headingPlot = pg.PlotWidget(title="Compass Heading")

headingPlot.setAspectLocked(True)

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

headingPlot.setMinimumSize(300,300)

headingPlot.hideAxis('left')

headingPlot.hideAxis('bottom')

plotLayout.addWidget(headingPlot,1,1)

compassCircle=pg.EllipseROI([-1.5,-1.5],[3.,3.],pen=pg.mkPen('b',width=4),movable=False, resizable=False)

headingPlot.addItem(compassCircle)

compassCircle.removeHandle(0)

compassCircle.setZValue(0)

arrowShaft=pg.PlotCurveItem( x=[0,0],y=[0,1.5],pen=pg.mkPen('r',width=4))

headingPlot.addItem(arrowShaft)

dot=pg.ScatterPlotItem(pos=[(0,1.5)],width=4,size=10,pen=pg.mkPen('y'),brush=pg.mkBrush('y'))

dot.setZValue(1)

headingPlot.addItem(dot)

for angle, label in zip([0,90,180,270],['E','N','W','S']):

rad = angle/360*2*math.pi

xPos = np.cos(rad)*1.8

yPos = np.sin(rad)*1.8

text=pg.TextItem(label, anchor = (.5,.5), color='g')

font=QtGui.QFont()

font.setBold(True)

font.setPointSize(12)

text.setFont(font)

text.setPos(xPos,yPos)

headingPlot.addItem(text)

liveHeading = pg.TextItem("Heading: 0.0\u00B0",anchor= (.5,.5),color='w')

liveHeading.setFont(font)

liveHeading.setPos(0,-2.2)

liveHeading.setZValue(1)

headingPlot.addItem(liveHeading)

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, x, y ,z

if ser.in_waiting > 0:

try:

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

values = line.split(',')

if len(values)==3:

x = x*.75 + float(values[0])*.25

y = y*.75 + float(values[1])*.25

z = z*.75 + float(values[2])*.25

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))

headRad= math.atan2(yC,xC)

headDeg=(headRad*360/2/math.pi)%360

compassRad= -headRad+ math.pi/2

compassDeg = (-headDeg + 90)%360

xDot=1.5*math.cos(compassRad)

yDot=1.5*math.sin(compassRad)

dot.setData(pos=([(xDot,yDot)]))

arrowShaft.setData(x=[0,xDot],y=[0,yDot])

liveHeading.setText("Heading: "+str(int(headDeg))+"\u00B0")

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()

Arduino, Python

Calibrated Compass Display in Python and PyQt5

October 15, 2025 admin

In this video lesson we develop a Graphical Digital Compass using python and PyQt5. The data comes from a QMC5883L magnetometer connected to an arduino. The magnetometer is on the GY-87 IMU module. The arduino sends the raw data to python. With the raw data in Python, we then calibrate the sensor, and create a graphical representation of a digital compass. The circuit schematic we are using is:

The simple program for collecting the raw data on Arduino is:

#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);

}

On the python side, this is the code we developed which both calibrates the magnetometers, and displays a Digital Compass.

import serial
import numpy as np
from PyQt5 import QtWidgets, QtCore, QtGui
import pyqtgraph as pg
import math
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)
x=0
y=0
z=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)

headingPlot = pg.PlotWidget(title="Compass Heading")
headingPlot.setAspectLocked(True)
headingPlot.showGrid(x=True, y=True)
headingPlot.setMinimumSize(300,300)
headingPlot.hideAxis('left')
headingPlot.hideAxis('bottom')
plotLayout.addWidget(headingPlot,1,1)

compassCircle=pg.EllipseROI([-1.5,-1.5],[3.,3.],pen=pg.mkPen('b',width=4),movable=False, resizable=False)
headingPlot.addItem(compassCircle)
compassCircle.removeHandle(0)
compassCircle.removeHandle(0)
compassCircle.setZValue(0)

arrowShaft=pg.PlotCurveItem( x=[0,0],y=[0,1.5],pen=pg.mkPen('r',width=4))
headingPlot.addItem(arrowShaft)
dot=pg.ScatterPlotItem(pos=[(0,1.5)],width=4,size=10,pen=pg.mkPen('y'),brush=pg.mkBrush('y'))
dot.setZValue(1)
headingPlot.addItem(dot)

for angle, label in zip([0,90,180,270],['E','N','W','S']):
    rad = angle/360*2*math.pi
    xPos = np.cos(rad)*1.8
    yPos = np.sin(rad)*1.8
    text=pg.TextItem(label, anchor = (.5,.5), color='g')
    font=QtGui.QFont()
    font.setBold(True)
    font.setPointSize(12)
    text.setFont(font)
    text.setPos(xPos,yPos)
    headingPlot.addItem(text)
    
liveHeading = pg.TextItem("Heading: 0.0\u00B0",anchor= (.5,.5),color='w')
liveHeading.setFont(font)
liveHeading.setPos(0,-2.2)
liveHeading.setZValue(1)
headingPlot.addItem(liveHeading)


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))
                    
                    headRad=math.atan2(yC,xC)
                    headDeg=(headRad*360/2/math.pi)%360
                    compassRad= -headRad+ math.pi/2
                    compassDeg = (-headDeg + 90)%360
                    xDot=1.5*math.cos(compassRad)
                    yDot=1.5*math.sin(compassRad)
                    dot.setData(pos=([(xDot,yDot)]))
                    arrowShaft.setData(x=[0,xDot],y=[0,yDot])
                    liveHeading.setText("Heading: "+str(int(headDeg))+"\u00B0")
                    
                    
        
        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

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

import serial

import numpy as np

from PyQt5 import QtWidgets, QtCore, QtGui

import pyqtgraph as pg

import math

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)

x=0

y=0

z=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)

headingPlot = pg.PlotWidget(title="Compass Heading")

headingPlot.setAspectLocked(True)

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

headingPlot.setMinimumSize(300,300)

headingPlot.hideAxis('left')

headingPlot.hideAxis('bottom')

plotLayout.addWidget(headingPlot,1,1)

compassCircle=pg.EllipseROI([-1.5,-1.5],[3.,3.],pen=pg.mkPen('b',width=4),movable=False, resizable=False)

headingPlot.addItem(compassCircle)

compassCircle.removeHandle(0)

compassCircle.setZValue(0)

arrowShaft=pg.PlotCurveItem( x=[0,0],y=[0,1.5],pen=pg.mkPen('r',width=4))

headingPlot.addItem(arrowShaft)

dot=pg.ScatterPlotItem(pos=[(0,1.5)],width=4,size=10,pen=pg.mkPen('y'),brush=pg.mkBrush('y'))

dot.setZValue(1)

headingPlot.addItem(dot)

for angle, label in zip([0,90,180,270],['E','N','W','S']):

rad = angle/360*2*math.pi

xPos = np.cos(rad)*1.8

yPos = np.sin(rad)*1.8

text=pg.TextItem(label, anchor = (.5,.5), color='g')

font=QtGui.QFont()

font.setBold(True)

font.setPointSize(12)

text.setFont(font)

text.setPos(xPos,yPos)

headingPlot.addItem(text)

liveHeading = pg.TextItem("Heading: 0.0\u00B0",anchor= (.5,.5),color='w')

liveHeading.setFont(font)

liveHeading.setPos(0,-2.2)

liveHeading.setZValue(1)

headingPlot.addItem(liveHeading)

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))

headRad=math.atan2(yC,xC)

headDeg=(headRad*360/2/math.pi)%360

compassRad= -headRad+ math.pi/2

compassDeg = (-headDeg + 90)%360

xDot=1.5*math.cos(compassRad)

yDot=1.5*math.sin(compassRad)

dot.setData(pos=([(xDot,yDot)]))

arrowShaft.setData(x=[0,xDot],y=[0,yDot])

liveHeading.setText("Heading: "+str(int(headDeg))+"\u00B0")

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()

Python, Raspberry Pi Pico

Portable GPS Data Tracker Using the Raspberry Pi Pico W

October 6, 2025 admin

In today’s video we show how to run your GPS tracker remotely by saving the program as main.py, and powering from the Sunfounder Breadvolt power supply. We also show how to prevent the problem of main.py locking up the serial port. We do this by adding a ‘kill switch’, that terminates the main.py program, so the log file can be transferred to your PC.

This is the schematic used for today’s lesson.

For your convenience, this is the code we developed in today’s video.

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

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

butOnePin = 12
butOne = Pin(butOnePin, Pin.IN, Pin.PULL_UP)
butOneUp = 0
butOneDown = 0
butOneOld = 1
tStart=time.time()
try:
    while time.time()-tStart<5:
        dsp.fill(0)
        dsp.text("Ultimate GPS",0,0)
        dsp.text("Press Button",0,26)
        dsp.text("To Cleanly",0,36)
        dsp.text("Quit",0,46)
        dsp.show()
        butOneValue = butOne.value()
        if butOneValue==0:
            dsp.fill(0)
            dsp.text("Ending",0,0)
            dsp.show()
            time.sleep(1)
            x=1/0

with open('log.txt', 'w') as file:  # Open log.txt in write mode ('w')
    pass
utcCorrect = 3
earthRadius = 6371000

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)
            dsp.text("Press Btn LOG",0,56)

        if sysState%5==1:
            lat=str(GPSdata['latDD'])
            lon=str(GPSdata['lonDD'])
            latLon=lat+','+lon+'\n'
            try:
                with open('log.txt', 'a+') as file:
                    file.write(latLon)
                    file.flush()  # Force write to disk
                time.sleep(0.05)  # Give filesystem time to settle
            except Exception as e:
                print("File write error:", e)
            dsp.fill(0)
            dsp.text("Logging Data",0,0)
            dsp.text(GPSdata['date'][0:5] + ' '+GPSdata['time'],0,16)
            dsp.text("P1 lat "+str(lat),0,26)
            dsp.text("P1 lon "+str(lon),0,36)
            dsp.text("To Stop Logging",0,56)

        if sysState%5==2:
            dsp.fill(0)
            dsp.text("Logging Stopped",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.show()
            sysState=0
    dsp.show()

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

299

300

301

302

303

304

305

306

307

308

309

310

311

312

313

314

315

316

317

318

319

320

321

322

from machine import Pin,I2C,UART

import time

import _thread

from ssd1306 import SSD1306_I2C

import math

import sys

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

dsp = SSD1306_I2C(128,64,i2c2)

butOnePin = 12

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

butOneUp = 0

butOneDown = 0

butOneOld = 1

tStart=time.time()

try:

while time.time()-tStart<5:

dsp.fill(0)

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

dsp.text("Press Button",0,26)

dsp.text("To Cleanly",0,36)

dsp.text("Quit",0,46)

dsp.show()

butOneValue = butOne.value()

if butOneValue==0:

dsp.fill(0)

dsp.text("Ending",0,0)

dsp.show()

time.sleep(1)

x=1/0

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

pass

utcCorrect = 3

earthRadius = 6371000

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)

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

if sysState%5==1:

lat=str(GPSdata['latDD'])

lon=str(GPSdata['lonDD'])

latLon=lat+','+lon+'\n'

try:

with open('log.txt', 'a+') as file:

file.write(latLon)

file.flush() # Force write to disk

time.sleep(0.05) # Give filesystem time to settle

except Exception as e:

print("File write error:", e)

dsp.fill(0)

dsp.text("Logging Data",0,0)

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

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

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

dsp.text("To Stop Logging",0,56)

if sysState%5==2:

dsp.fill(0)

dsp.text("Logging Stopped",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.show()

sysState=0

dsp.show()

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")

Python

Create a KML File to Display your GPS Data on Google Earth

October 1, 2025 admin

Below we show you an example KML file that allows you too display your logged GPS data on Google Earth. For simplicity, we have included two GPS points. First, notice that the ordered pairs are Longitude,Latitude. Notice this is reversed of what we would normally expect, but it is important to note the order . . . Longitude must be put as the first term in the ordered pair. Also notice that the ordered pair of data show up two times in the file. The first is to create the dot, or placemark on the map, and the second list creates the line over your logged path. Now, the challenge for you is to write a python program that takes your log.txt file, which contains simple comma delimited data, lat,lon, and use that to generate a .kml file as shown below.

<?xml version="1.0" encoding="UTF-8"?>
<kml xmlns="http://www.opengis.net/kml/2.2">
  <Document>
    <name>Path from Pico</name>
    <Style id="pointStyle">
      <IconStyle>
        <Icon><href>http://maps.google.com/mapfiles/kml/shapes/placemark_circle.png</href></Icon>
        <scale>1.0</scale>
      </IconStyle>
    </Style>
    <Style id="lineStyle">
      <LineStyle><color>ff0000ff</color><width>3</width></LineStyle>
    </Style>
    <Placemark>
      <styleUrl>#pointStyle</styleUrl>
      <MultiGeometry>
<Point><coordinates>
33.16453,0.47860332
</coordinates></Point>
<Point><coordinates>
33.164512,0.478673336
</coordinates></Point>
</MultiGeometry>
    </Placemark>
    <Placemark>
      <name>Path</name>
      <styleUrl>#lineStyle</styleUrl>
      <LineString>
        <tessellate>1</tessellate>
        <altitudeMode>clampToGround</altitudeMode>
        <coordinates>
33.16453,0.47860332 
33.164512,0.478673336 
</coordinates>
      </LineString>
    </Placemark>
  </Document>
</kml>

<?xml version="1.0" encoding="UTF-8"?>

<Icon><href>http://maps.google.com/mapfiles/kml/shapes/placemark_circle.png</href></Icon>

</IconStyle>

</Style>

</Style>

<styleUrl>#pointStyle</styleUrl>

33.16453,0.47860332

</coordinates></Point>

33.164512,0.478673336

</coordinates></Point>

</MultiGeometry>

</Placemark>

<styleUrl>#lineStyle</styleUrl>

<altitudeMode>clampToGround</altitudeMode>

33.16453,0.47860332

33.164512,0.478673336

</coordinates>

</LineString>

</Placemark>

</Document>

</kml>

Technology Tutorials

Python Program to Convert GPS Log file into a KML File for Display on Google Earth

Improving Digital Compass Accuracy With a Low Pass Filter

Calibrated Compass Display in Python and PyQt5

Portable GPS Data Tracker Using the Raspberry Pi Pico W

Create a KML File to Display your GPS Data on Google Earth

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