GPS speedometer with a trip odometer on an Arduino Uno

// GPS speedometer with a trip odometer: a NEO-6M read with NeoGPS shows the
// speed, the heading and the satellites on a 128x64 OLED, and adds up the
// distance covered into a trip and a total that survive a power cut.
//
//   NEO-6M   TX -> pin 4   RX -> pin 3   VCC -> 5V   GND -> GND
//   OLED     SDA -> A4     SCL -> A5     VCC -> 5V   GND -> GND
//   button   pin 2 to GND (hold it for a second to zero the trip)
//
// SPEED AND HEADING come from the GPS itself: the module works them out
// from the Doppler shift of the satellites' signals and sends them once a
// second in its RMC sentence, so no maths is needed here. Below 2 km/h a
// parked receiver's heading wanders, so it is shown as --- then.
//
// THE DISTANCE is the sum of the steps between one second's position and
// the next. Steps taken under 2 km/h are not counted: standing still, a
// real GPS position jitters by a few meters, and adding that up would make
// the trip grow in a parked car.
//
// THE ODOMETER lives in the EEPROM, written with EEPROMWearLevel. EEPROM
// cells last about 100,000 writes, so a value saved at the same address
// every 100 m would wear one out in 10,000 km; the library writes each new
// value to the next free bytes of a stretch instead, so the wear is spread
// over many cells. Saving every 100 m means a power cut loses at most 100 m.
//
// THE QUIET TIME. The NEO-6M sends RMC first and five more sentences after
// it, about half a second of text a second, and SoftwareSerial holds only
// 64 characters. So each fix waits until the module has gone quiet before
// the OLED is drawn and the line printed: doing that while the rest of the
// burst arrived would overflow the buffer and lose sentences. The OLED is
// drawn once with its labels, and after that only the numbers are written,
// padded to a fixed width, so an update is quick.
//
// Things to try. Change the GPS module's speed and course in its settings,
// then watch the trip count up. Press reset: the trip and the total are
// still there. Hold the button: the trip goes back to zero, the total does
// not. Click the GPS to lose the fix.

#include <Wire.h>
#include <SoftwareSerial.h>  // GPSport.h then puts the GPS on pins 4 (RX) and 3 (TX)
#include <NMEAGPS.h>
#include <GPSport.h>
#include <EEPROMWearLevel.h>
#include "SSD1306Ascii.h"
#include "SSD1306AsciiWire.h"

const byte BUTTON_PIN = 2;
const float MIN_SPEED_KMH = 2.0;    // slower than this counts as standing still
const float SAVE_EVERY_KM = 0.1;    // write the odometer to EEPROM every 100 m
const unsigned long QUIET_MS = 20;  // the GPS has finished its second's sentences

// EEPROMWearLevel's layout: two values, each in its own stretch of EEPROM.
const byte EEPROM_LAYOUT_VERSION = 1;
const int INDEX_TRIP = 0;
const int INDEX_TOTAL = 1;

NMEAGPS gps;
gps_fix fix;
SSD1306AsciiWire oled;

NeoGPS::Location_t lastPlace;
bool havePlace = false;
float tripKm = 0;
float totalKm = 0;
float savedTotalKm = 0;
unsigned long pressedAt = 0;
unsigned long lastCharAt = 0;
bool fixWaiting = false;

void saveOdometer() {
  EEPROMwl.put(INDEX_TRIP, tripKm);
  EEPROMwl.put(INDEX_TOTAL, totalKm);
  savedTotalKm = totalKm;
}

const char *compassPoint(int degrees) {
  static const char *const POINTS[] = {"N ", "NE", "E ", "SE", "S ", "SW", "W ", "NW"};
  return POINTS[((degrees * 2 + 45) / 90) % 8];
}

// Text at a column (in pixels) and a row (in 8-pixel pages).
void at(uint8_t col, uint8_t row, const char *text) {
  oled.setCursor(col, row);
  oled.print(text);
}

void drawLabels() {
  oled.clear();
  at(0, 0, "SAT");
  at(48, 0, "HDG");
  at(92, 3, "km/h");
  at(0, 6, "TRIP");
  at(0, 7, "ODO");
  at(96, 6, "km");
  at(96, 7, "km");
}

void drawDistances() {
  char text[9];
  at(36, 6, dtostrf(tripKm, 8, 2, text));
  at(36, 7, dtostrf(totalKm, 8, 1, text));
}

void draw(bool hasFix, float kmh, int heading) {
  char text[9];
  oled.setCursor(24, 0);
  oled.print(fix.valid.satellites ? fix.satellites : 0);
  oled.print(' ');
  oled.setCursor(72, 0);
  if (heading >= 0) {
    if (heading < 100) oled.print('0');
    if (heading < 10) oled.print('0');
    oled.print(heading);
    oled.print(' ');
    oled.print(compassPoint(heading));
  } else {
    oled.print(F("---   "));
  }

  // The speed twice the size, in rows 2 and 3.
  oled.set2X();
  if (hasFix) {
    at(0, 2, dtostrf(kmh, 7, 1, text));
  } else {
    at(0, 2, "   --.-");
  }
  oled.set1X();
  at(0, 4, hasFix ? "                 " : "waiting for a fix");
  drawDistances();
}

void setup() {
  Serial.begin(9600);
  pinMode(BUTTON_PIN, INPUT_PULLUP);
  gpsPort.begin(9600);

  Wire.begin();
  Wire.setClock(400000L);  // as SSD1306Ascii's examples run the OLED
  oled.begin(&Adafruit128x64, 0x3C);
  oled.setFont(Adafruit5x7);

  EEPROMwl.begin(EEPROM_LAYOUT_VERSION, 2);
  EEPROMwl.get(INDEX_TRIP, tripKm);  // left at 0 on a new board
  EEPROMwl.get(INDEX_TOTAL, totalKm);
  savedTotalKm = totalKm;

  drawLabels();
  draw(false, 0, -1);
  Serial.print(F("GPS speedometer: trip "));
  Serial.print(tripKm, 3);
  Serial.print(F(" km, total "));
  Serial.print(totalKm, 3);
  Serial.println(F(" km"));
}

void loop() {
  // Hold the button a second to zero the trip.
  if (digitalRead(BUTTON_PIN) == LOW) {
    if (pressedAt == 0) pressedAt = millis();
    if (pressedAt != 1 && millis() - pressedAt >= 1000) {
      tripKm = 0;
      saveOdometer();
      drawDistances();
      Serial.println(F("trip reset"));
      pressedAt = 1;  // wait for the button to come back up
    }
  } else {
    pressedAt = 0;
  }

  // NeoGPS hands over one whole fix a second, once the RMC sentence is in;
  // it is used when the rest of the second's sentences have arrived.
  if (gpsPort.available()) lastCharAt = millis();
  if (gps.available(gpsPort)) {
    fix = gps.read();
    fixWaiting = true;
  }
  if (!fixWaiting || millis() - lastCharAt < QUIET_MS) return;
  fixWaiting = false;

  if (!fix.valid.location || !fix.valid.speed) {
    havePlace = false;
    draw(false, 0, -1);
    Serial.println(F("no fix"));
    return;
  }

  float kmh = fix.speed_kph();
  bool moving = kmh >= MIN_SPEED_KMH;
  if (havePlace && moving) {
    float stepKm = fix.location.DistanceKm(lastPlace);
    tripKm += stepKm;
    totalKm += stepKm;
    if (totalKm - savedTotalKm >= SAVE_EVERY_KM) saveOdometer();
  }
  lastPlace = fix.location;
  havePlace = true;

  int heading = (moving && fix.valid.heading) ? (int)(fix.heading() + 0.5) % 360 : -1;
  draw(true, kmh, heading);

  Serial.print(F("speed "));
  Serial.print(kmh, 1);
  Serial.print(F(" km/h  heading "));
  if (heading >= 0) {
    Serial.print(heading);
  } else {
    Serial.print(F("---"));
  }
  Serial.print(F("  sats "));
  Serial.print(fix.satellites);
  Serial.print(F("  trip "));
  Serial.print(tripKm, 3);
  Serial.print(F(" km  total "));
  Serial.print(totalKm, 3);
  Serial.println(F(" km"));
}