Average Speed Head-up Display Unit - Giantboard

GPS/GNSS Average Speed HUD - Giant Board project

There are better choices available e.g. the smaller PCB-mounted devices with integrated antenna are ideal providing they offer serial data with TTL levels, and can be powered from 3.3 or 5V. The 4,800Bd data from my Garmin is similar to RS232 but without the +/- 12V voltages therefore it requires inverting to get the correct resting logic high state, hence the two transistor interface. My transistor interface circuit also reduces the 5V signalling levels from the GPS receiver down to 3.3V with a potential divider.

I have experimented with a GNSS 5 Click Board (shown above) and an external active GPS antenna; it works very nicely. With only a micro-USB lead between the Click board and my PC, to provide both power and data, I could immediately get serial data at a default 9,600Bd on COM6: using Putty. It streams default sentences, but not the GPRMC one that I use on the Garmin. Because the Click board is a GNSS receiver it uses slightly different sentences, so GPRMC is renamed GNRMC. Its GNRMC sentence has an extra comma towards the end, so I have modified my software GPS_AV1.py accordingly and it will decode both. Oddly its speed reporting is not zero but dithers around 0.02kts when the antenna is stationary. Another comparison between receivers is that the Click board reports speed with ten times the resolution. The Click board may need setting up to decode the other satellites. I have yet to try that, and I have not trained the Click unit to send just one sentence.

c. SSD1306 OLED. The 128x64 blue monochrome display seems to work nicely and consumes very little power. It has an internal 3 to 5V inverter and the adafruit_ssd1306 library code is happy, using default settings, to initialise the board's internal registers including the inverter controller.

To make a reflected display appear at infinity requires a small lens but I have not investigated this. It would need some careful thought to prevent sunlight from setting fire to the OLED...

e. Press button input. This multi-function button is used to clear the average speed accumulators, select average or current speed, and exit the program. Once the program has stopped, power can be removed or a PC connected perhaps to copy log files to its SD card's /boot/uboot, or software changes made and the program re-run. Again, an external pull-up resistor has been fitted. The push button may be duct-taped to the gear stick.

If held for 10 seconds or more, it stops the program. But it was found on a test drive that displaying one's current speed to 0.1mph resolution could be another useful feature to add, because the car's (mechanical) speedometer accuracy is ultimately dependent on tyre/tire diameter, air pressure, temperature, a spring and a magnet.

My Button Logic is now: press and release for approximately half a second to clear average speed. A press and release over about 2 seconds toggles average to current speed display, and a hold down for >10 seconds hold exits the program.

Eagle-eyed people will notice the lack of a driver transistor on the Veroboard implementation. My original interface was built in bird’s-nest style, in the ‘D’ connector’s shell. But that didn’t look neat. As I had set-up the GPS receiver already, I did not put the extra components on the Veroboard to save space.

Viewed from the top:

It took the Giant Board about 2 minutes 30 seconds to boot up its Linux OS. To reduce this try:

sudo systemctl disable connman-wait-online.service.

sudo python3 GPS_AV1.py

After setting up the UART and I/O pins, the main program then waits until the GPS unit replies with valid data. GPS serial data is fed from the Garmin via a transistor interface into the Aux serial port /dev/ttyS1 on pin AD3. Even though the Giant Board has pins marked TX and RX, this port /dev/ttyS0 is only useable to display Linux boot output, at 115kBd, and cannot be used to receive data due to permissions errors. Unfortunately the kernel would require forking to sort that issue out.

The main reason to use the Giant Board, as opposed to perhaps a PIC, is the ability to use Python3. A few lines of that can do loads of useful work, and one does not have to worry about cross-compilers, (in)correct libraries etc. 

line_in = tty1.readline() # get the sentence

str_in = str (line_in) # convert to a string

data = str_in.split(',') # split at each comma
speed = data[7] # for example, this is speed.  

Debug_mode = False # could be True to print debug messages

My program was typed in with Nano, as it is not that long, under 300 lines. Home-made font files were copied over from a PC using the boot directory. The Giant Board plus OLED take only about 80-120mA from the USB power supply during boot-up, and the current drops dramatically once my app starts. It then takes only 60mA with no GPS device attached, and 130mA for the Giant Board, OLED  and GPS. My loop ends with

time.sleep(0.1)

#! /usr/bin/python3
# above line is 'shebang line'
# GPS Test Program
# GPSX1.py APRW 29-04-2020
 
# set Garmin to output only GPRMC NMEA sentence.
# read data
# generate average speed
# display average speed
 
# Gadget Port commands:
# c = clear av speed
# m = monitor GPS input
# wr/w1 = write to GPS unit : r reset output/ 1 = allow RMC only
# n = no monitor output
# gga = send GPGGA sentences
# gsv = send GPGSV
# rmc = send GPRMC
# f = flush input
import serial
# no module called: import getch
 
sv_speed_kts=0.0
av_speed_samples=0
av_speed_acc=0.0
 
def clear_av_speed():
    av_speed_kts=0.0
    av_speed_samples=0
    av_speed_acc=0.0
    print ('Averages cleared.')
 
def reset_GPS():
# send $PGRMO,,2<cr>,<lf> to ttyS1
    tty1.write(b'$PGRMO,,2*75rn')
    print ('Sent $PGRMO,,2*75 cmd')
 
def send_RMC():
# send $PGRMO,GPRMC,1<cr><lf> to ttyS1 ( tty1)
 
    tty1.write(b'$PGRMO,GPRMC,1*3Drn')
    print ('Sent PGRMO,GPRMC,1*3D cmd')
 
def send_GSV():
    tty1.write(b'$PGRMO,GPGSV,1*23rn')
 
def send_GGA():
    tty1.write(b'$PGRMO,GPGGA,1*20rn')
 
#main
tty1=serial.Serial('/dev/ttyS1',4800,timeout=1)
print ('GPSX1 GPS Average Speed Program. rnOpening ttyS1...%s' %tty1.name)
run_mode=True
tty1.flushInput()
 
while run_mode == True:
    print('Enter cmd: c/wr/w1/m/n/x/X:')
    cmd=input() # renamed input from raw_input
    if (cmd=='x' or cmd=='X'):
        run_mode=False
    elif (cmd=='c'):
        clear_av_speed()
    elif (cmd=='wr'):
        reset_GPS()
    elif (cmd=='gga'):
        send_GGA()
    elif (cmd=='gsv'):
        send_GSV()
    elif (cmd=='rmc'):
        send_RMC()
    elif (cmd=='f'):
        tty1.flushInput()
    line_in= tty1.readline()
    print ('Input: %s' %line_in)
tty1.close()
   
 

And GPS_AV1.py (latest version with fonts etc is here: https://app.box.com/s/8e6okfii3m20sz3rgg7s5ogb9pfs8nye

#! /usr/bin/python3
 
# GPS_AV1.py
# Font ses QBI 24-point bitmap to display average speed.
# Hardware: GPS on serial UART and SSD1306 on I2C bus, button on IO port
# Feed GPS serial data into AD3.
# Wed 13th May 2020 APRW
# Mon 18th May 2020 APRW Add digital in on AD4.
# Tue 19th May 2020 APRW Add button on AD1, log data into logs directory.
# $GPRMC,time,A/V,Lat,Long,spd, dir, date, offsets, csum
#    0    1    2   3   5    7    8    9      10     12  # split
# display is 128 x 64 dots.
# DIP Switch inverts display for HUD mode.
# Press button clears average speed if pressed for a second or so
# Press button exits program if held for 10 secs or so.
# Tue 2nd June 2020 APRW New feature: toggle average/current speed display.
# Tue 2nd June 2020 APRW Press button mods to change mode.
# Wed 3rd June 2020 APRW try time.monotonic to check loop time.
# Thu 4th June 2020 APRW Manifest constant Debug Mode to 
# stop/allow debug print
# Thu 11th June 2020 APRW Add state machine.
# Thu 11th June 2020 APRW Try digital outputs.
# Sun 14th June 2020 APRW getline() mods for split data. L.
# Mon 15th June 2020 APRW Check input is GPRMC and has >=11 commas
# Tue 16th June 2020 APRW Store valid data in one file, junk in another.
 
Debug_mode=False
 
import board
import adafruit_ssd1306
import serial
import busio
import time
import binascii
import digitalio
from enum import Enum
 
 
class ModeEnum(Enum):
   START = 0
   RUN = 1
   END = 2
 
 
# convert offset to 32-bit mask as my font is not in bit order.
# Each 32-bit font row is in byte order e.g.
# ....**** **...... .**...** *.......   (left to right pixels) 
#   0x0F      0xC0     0x63    0x80        
lut_dict={0:0x80,1:0x40,2:0x20,3:0x10,4:0x8,5:0x4,6:0x2,7:1,
          8:0x8000,9:0x4000,10:0x2000,11:0x1000,12:0x800,13:0x400,14:0x200,15:0x100,
          16:0x800000,17:0x400000,18:0x200000,19:0x100000,20:0x80000,21:0x40000,22:0x20000,23:0x10000}
 
 
# These constants relate to my 36-pt font and 24-pt font in a 32 bit x 32 bit matrix
FontBytesPerRow = 4
FontCharPitch = 128
FontRowsPerChar = 4
FontBitsPerCharRow = 24
FontTopMargin = 24
FontCharScanLines = 16
row_offset = 1
 
# display one large character at a time, xpos 0 for top left.
# siz = 2 is 2 dots in row and 2 in column expansion
# siz = 3 is 2 dots wide and 3 high expansion
 
# inv_bool is true/false to invert characters
def disp_txt(ch, xpos, siz, inv_bool):
 
   fhfont= open("/home/debian/24REGA.RES","rb")  # full path required
   res_offset = ord(ch)                          # find offset into font file
   res_offset -= ord(' ')                        # remove space as font starts at ch = 20h
   res_offset *= FontCharPitch
   res_offset += FontTopMargin                  # now we know exactly where to seek
# read out 4 bytes at this file offset, as there are 4 bytes per dot row.
   fhfont.seek ( res_offset, 0 )                # 0 is SEEK from start of file
   dat = fhfont.read(FontBytesPerRow)
   ldat = int.from_bytes(dat,"little", signed = False) # convert to a long
#   print (hex(ldat)) ...uncomment to see what top row looks like
   for row in range (0, FontCharScanLines,1):
      if (inv_bool == True ): row = FontCharScanLines - row
      row += row_offset                         # to fit smaller characters centrally
      for col in range (0, FontBitsPerCharRow,1):
         if (ldat & lut_dict[col]):
            if  siz==1:
               oled.pixel((col+xpos), row, 1)
            if (siz==2):
               oled.pixel(xpos+col*2 + 1, row*2, 1)
               oled.pixel(xpos+col*2 + 1, row*2,1)
               oled.pixel(xpos+col*2, row*2 + 1,1)
               oled.pixel(xpos+col*2 + 1, row*2 + 1,1)
            if (siz==3):
               oled.pixel(xpos+col*2, row*3, 1)   # these could be a pythonic
               oled.pixel(xpos+col*2, row*3 + 1, 1) # rewrite
               oled.pixel(xpos+col*2, row*3 + 2, 1)
               oled.pixel(xpos+col*2 + 1, row*3, 1)
               oled.pixel(xpos+col*2 + 1, row*3 + 1, 1)
               oled.pixel(xpos+col*2 + 1, row*3 + 2, 1) 
 
 
      dat = fhfont.read(FontBytesPerRow) # read another 4 bytes
      ldat = int.from_bytes(dat,"little", signed = False)
 
   fhfont.close()
 
 
def disp_curspd(cspd, invert):               # display current speed
# toggle horizontal or vertical border on and off
   global edge
#   global size
   oled.fill(0)               # clear display buffer
   fcspd = float(cspd)        # to a float from 000.0
   spd = fcspd*1.15078        # convert kts to mph
   if (spd>0.0):
      spd_str = str(spd)
   else:
      spd_str = '0.00'        # convert to string
   digits = len (spd_str)     # how many to display
#   print (spd_str+' '+str(digits)) # debug only
   if digits>4:
      digits=4
   for i in range (digits):
      if spd_str[i]=='.':
         disp_txt(spd_str[i],30*i+21,size, invert)
      else:
         disp_txt(spd_str[i],30*i+6, size, invert)
   if edge>1:
      edge=0
      oled.line(0,0,127,0,1)     # top line
      oled.line(0,63, 127,63,1)  # bottom line
   else:
      oled.line(0,0,0,63,1)      # left line
      oled.line(127,0,127,63,1)  # right line
# do later in state_machine 11-6-2020   oled.show() as it takes 100ms
   edge+=1
 
 
def disp_av(acc, ctr, invert): # display average speed
   global edge
   x1=(0,64,127,63,0,0)       # 4 tuples for edge border
   x2=(64,127,127,127,63,0)   # so oled.line can be used to 
   y1=(0,0,0,63,63,0)         # draw the moving border
   y2=(0,0,63,63,63,63)
   oled.fill(0)               # clear the display
 
   if (ctr==0):
      ctr=1                   # prevent divide by zero
   av_spd_kts = acc/ctr       # divide accumulator by number of samples
   av_spd_mph = av_spd_kts * 1.15078 # convert from knots to mph
   av_spd_str = str(av_spd_mph) # Convert float to string
   digits = len(av_spd_str)   # how many digits to display?
 
   if digits>4:
      digits=4
   for i in range (digits):
      if (av_spd_str[i]=='.'):
         disp_txt(av_spd_str[i],30*i+21,size, invert)
      else:
         disp_txt(av_spd_str[i],30*i+6,size,invert)
   if (edge >5):
      edge = 0
   oled.line(x1[edge],y1[edge],x2[edge],y2[edge],1)
 
   edge += 1  # move the 64 pixel border line along for next time 
# in state_machine 11-6-20   oled.show()  # display digits plus border line
 
def log_data(date, strdata):
   logf = open('/home/debian/logs/'+date, "a+") # generate absolute path
   logf.write(strdata)        # must be str not bytes...
   logf.write("n")           # whack a newline at the end of each row
   logf.close()
 
#
# void main(void) # start here!...
#
i2c = busio.I2C(board.SCL, board.SDA)
oled = adafruit_ssd1306.SSD1306_I2C(128, 64, i2c)
oled.fill(0)                  # clear the display buffer 
                              # GPS serial data input on this port...
tty1 = serial.Serial('/dev/ttyS1',4800,timeout=0.1) # timeout 100ms
# operator push button...
button = digitalio.DigitalInOut(board.AD1)
button.direction = digitalio.Direction.INPUT
# button.pull = digitalio.Pull.UP ! error not implemented !
# button.switch_to_input(pull=digitalio.Pull.UP) ! ditto !
 
# invert display switch on AD4...
inv_sw = digitalio.DigitalInOut(board.AD4)
inv_sw.direction = digitalio.Direction.INPUT
 
PWM1_Out = digitalio.DigitalInOut(board.PWM1)   # to time functions
PWM1_Out.direction = digitalio.Direction.OUTPUT
 
PWML1_Out = digitalio.DigitalInOut(board.PWML1)
PWML1_Out.direction = digitalio.Direction.OUTPUT
 
PWM2_Out = digitalio.DigitalInOut(board.PWM2)
PWM2_Out.direction = digitalio.Direction.OUTPUT
 
PWM3_Out = digitalio.DigitalInOut(board.PWM3)
PWM3_Out.direction = digitalio.Direction.OUTPUT
 
 
oled.rect(0,0,127,63,1)             # a border...
# Show s/w version on oled...
invert = inv_sw.value
size = 3
 
edge = 0                   # display rotating border when running using edge
disp_txt("A",6, size, invert)
oled.show()
time.sleep(1)
disp_txt("V",36, size, invert)
oled.show()
time.sleep(1)
disp_txt("1",64, size, invert)
oled.show()
time.sleep(1)
disp_txt("N",90, size, invert)
oled.show()
time.sleep(1)
 
 
# flush GPS serial buffer as lots of stuff could be in queue...
tty1.flushInput()
	
time.sleep(1)
spd_acc=0.0 # accumulate speed, kts
spd_ctr=0 # count samples
 
run_mode = ModeEnum.RUN
oled.fill(0)         # clear oled
disp_txt("*",6,size,invert)
oled.show()
disp_mode=0          # for av speed (0) or current speed (1)
button_down_ctr = 0  # see how long button is pressed.
state_machine = 0    # split read data / print / update OLED
str_in=''		# clear line in so it can be concatenated 
while run_mode == ModeEnum.RUN:
   if button.value == 0:         # first of all check the push button
      button_down_ctr += 1
#      print (str(button_down_ctr))
      if button_down_ctr>=30 : # 10 seconds - ish! 3 loops per second
         run_mode = ModeEnum.END # end program if button held for > 10 secs
         oled.fill(0) # clear the display
         oled.show()
   else:
      if button_down_ctr>0: # had been pressed so check time
         if button_down_ctr<3: # under 1 second so clear average speed
            spd_acc=0
            spd_ctr=0
            if Debug_mode: print ("Clr...")
         elif button_down_ctr>=6: # 2 seconds at 250ms per loop - ish!
            disp_mode^=1 # XOR current speed bit
            if Debug_mode: print ("Disp"+str(disp_mode))
      button_down_ctr = 0
# end of read button section. 
# Now see if serial data sentence in from GPS unit...     
   if state_machine == 0:
      PWML1_Out.value = True # time the function
      line_in = str(tty1.readline())
      PWML1_Out.value = False
      if len(line_in)>1:
         PWM1_Out.value = True # time when data rxd
         if Debug_mode:
            disptime = time.monotonic()
            print('d')
            print (disptime) # see how long sections take to run
            print (line_in)
         str_in=line_in  # no need to concatenate
         if len(str_in)>60:
            if str_in.find('$GPRMC')>0: # or str_in.find('$GNRMC')>0: # or GNRMC of course!
               state_machine = 1
            else:
               str_in=''   # clear and start again
         PWM1_Out.value = False
         
   elif state_machine ==1:    # we have got a sentence so split on commas
      PWM2_Out.value = True # time this function with MSO
      invert = inv_sw.value
      line_in=''
#      print ( str_in)  # uncomment to print all GPS info to GadgetPort
#      print ('commas='+str(str_in.count(','))) # should be 11 commas
      if str_in.count(',') < 11:
         oled.fill(0)
         disp_txt("C", 6, size, invert)  # 'C' means comma count error
         state_machine = 2 # display it
 
      else:
         data = str_in.split(',')
         if data[2]=='A':              # A=valid data
            spd_acc+= float(data[7])   # speed in knots from GPS
            spd_ctr+=1                 # (1 second per) sample
            if disp_mode & 1:
               disp_curspd(data[7], invert)
            else:
               disp_av(spd_acc, spd_ctr, invert)
            state_machine = 2 # display on next loop
            log_data(data[9], str_in) # log good blocks here
            duff_data = False
#      log_data(data[9],str_in) # log valid data, log filename = date
         elif (data[2]=='V'): # debug only!!! ZZZ
            oled.fill(0)		# clear display
            disp_txt("V", 6, size, invert)   # invalid data
            state_machine = 2
            duff_data = True
         else:
            oled.fill(0)
            disp_txt("?", 6, size, invert)   # something wrong!
            state_machine = 2          # get more data as sentence not valid.
            duff_data = True
#      log_data(data[9],str_in)      # log all rxd data. Filename = date (data[9])
      PWM2_Out.value = False        # end timing, MSO says 50ms
      if duff_data is True:
         log_data(data[9]+'x',str_in) # attempt to log in date+x file
   elif state_machine ==2: 
      PWM3_Out.value = True         # see how long oled.show takes
      oled.show()                   # MSO says this takes exactly 100ms at 100kHz I2C speed
      PWM3_Out.value = False
      str_in = ''
      state_machine = 0
      
   time.sleep(0.1)   # delay of 100ms for a loop time of 200ms
   if Debug_mode:    # remember wait for serial data is blocked for up to 100ms.
      looptime=time.monotonic()
      print (looptime)
                 
tty1.close()
# the end...