GPS Distance altitude and Speed Logger

A simple project to make a GPS log station with data speed, max speed, distance trip and altitude. all data are write on SD card

Jun 7, 2020

•

12514 views

•

8 respects

Components and supplies

Graphic OLED, 128 x 64

GPS Module (Generic)

Memory Socket, SD Card

Graphic OLED, 128 x 64

Arduino Nano R3

Tools and machines

Soldering iron (generic)

Solder Wire, Lead Free

Apps and platforms

Arduino IDE

Project description

Code

more data on display sh1106 1.3 version 2021''

arduino

add "Di" aerial distance (km) from fix point base. add "S"satellites count. add "Am"max altitude. add "He"heading degrees (360° N 180° S) previous data: "Km" odometer travel distance, "Sp" live speed, "Sm" max speed, "Al" altitude slm. display now is full with 8 informations data most of it collect to SD card (just heading and satellite count are not)

1#include <SPI.h>
2#include <SD.h>
3#include <Wire.h>
4#include "SSD1306Ascii.h"
5#include   "SSD1306AsciiWire.h"
6#include <NMEAGPS.h>
7#include <NeoSWSerial.h>
8#define   I2C_ADDRESS 0x3C
9#define RST_PIN -1
10#define MAX_CHARS 24
11#define RX_pin   5
12#define TX_pin 4
13#define SHOW_INTERVAL 1
14#define GPS_baud 9600
15SSD1306AsciiWire   oled;
16NMEAGPS gps;
17gps_fix fix;
18float odo, Speed, alt, Dist, head, maxs   = 0, Am = 0;
19unsigned int Sat = 0;
20NeoGPS::Location_t    lastLoc, base;
21bool   stScan = true, lastLocOK = false;
22static NeoSWSerial gpsPort(RX_pin, TX_pin);
23static   constexpr int INITIAL_SHOW  = (2 * SHOW_INTERVAL) - 1;
24int show          = INITIAL_SHOW;
25const   int   LED_PIN  = 3;
26const float SPEED_LIMIT = 0.1; // speed limit value
27void   disp(int c, int r)
28{
29  oled.clear();
30  oled.setCursor(c, r);
31}
32void   setup() {
33
34  pinMode (LED_PIN, OUTPUT);
35  Serial.begin(9600);
36  gpsPort.begin(GPS_baud);
37   Wire.begin();
38  oled.begin(&SH1106_128x64, I2C_ADDRESS);
39  oled.setFont(ZevvPeep8x16);
40   oled.clear();
41  disp(30, 2);// as to center your name change 30
42  oled.println("YourName");//10   characters available here
43  delay(2000);
44  disp(55, 2);
45  oled.print("GPS");//5   characters available here
46  delay(2000);
47  oled.clear();
48  const int cs_sd   = 2;
49  if (!SD.begin (cs_sd)) {
50    oled.clear();
51    disp(60, 2);
52     oled.print("SD");//if you read this on display mean SD is not present
53     delay(10000);
54    oled.clear();
55    return;
56  }
57  disp(60, 2);
58   oled.print("OK");
59  delay(2000);
60  oled.clear();
61  File data = SD.open("L.csv",   FILE_WRITE);
62  data.println("");
63  data.println("Da  Hr  La  Lo  At  Am   Km  Di  Sp  He  Sa" );
64  data.close();
65}
66void loop() {
67  if (gps.available(   gpsPort )) {
68    gps_fix fix = gps.read();
69    show = (show + 1) % SHOW_INTERVAL;
70     if (fix.valid.speed && (fix.speed_kph() > SPEED_LIMIT)) {
71      digitalWrite(   LED_PIN, HIGH );
72    } else {
73      digitalWrite( LED_PIN, LOW );
74    }
75     if (fix.valid.location) {
76      if (lastLocOK) {
77        odo += fix.location.DistanceKm(   lastLoc );
78        Speed = fix.speed_kph();
79      }
80      lastLoc   = fix.location;
81       lastLocOK = true;
82      if (stScan) {
83        stScan = false;
84        base    = fix.location;
85      } else {
86        Dist = ( fix.location.DistanceKm(   base ) );
87      }
88    }
89    if ( Speed > maxs)          maxs = Speed;
90     if (fix.valid.heading )     head = fix.heading() ;
91    if (fix.valid.satellites   )  Sat = fix.satellites ;
92    if (fix.valid.altitude)     alt = fix.altitude();
93     if ( alt > Am)              Am = alt;
94         if (show == 0) {
95        char   displayBufffer[MAX_CHARS];
96        oled.setCursor(0, 0);
97        snprintf(displayBufffer,   MAX_CHARS, "Km:%2d.%1d",  (int)odo, (int)(odo * 100) % 100);
98        oled.println(displayBufffer);
99         oled.setCursor(65, 0);
100        snprintf(displayBufffer, MAX_CHARS, "Di:%2d.%1d",   (int)Dist, (int)(Dist * 100) % 100);
101        oled.println(displayBufffer);
102         snprintf(displayBufffer, MAX_CHARS, "Sp:%2d.%1d", (int)Speed, (int)(Speed   * 10) % 10);
103        oled.println(displayBufffer);
104        oled.setCursor(65,   2);
105        snprintf(displayBufffer, MAX_CHARS, "Sm:%2d.%1d", (int)maxs, (int)(maxs   * 10) % 10);
106        oled.println(displayBufffer);
107        snprintf(displayBufffer,   MAX_CHARS, "Al:%2d.%1d", (int)alt, (int)(alt * 100) % 100);
108        oled.println(displayBufffer);
109         oled.setCursor(65, 4);
110        snprintf(displayBufffer, MAX_CHARS, "Am:%2d.%1d",   (int)Am, (int)(Am * 100) % 100);
111        oled.println(displayBufffer);
112        snprintf(displayBufffer,   MAX_CHARS, "Sa: %d", (int)Sat);
113        oled.println(displayBufffer);
114        oled.setCursor(65,   6);
115        snprintf(displayBufffer, MAX_CHARS, "He:%2d.%1d", (int)head, (int)(head   * 100) % 100);
116        oled.println(displayBufffer);
117      }
118    File data   = SD.open("L.csv", FILE_WRITE);
119    data.print(fix.dateTime.hours + 2);
120     data.print(":");
121    data.print(fix.dateTime.minutes);
122    data.print("   ");
123    data.print(fix.dateTime.date);
124    data.print("/");
125    data.print(fix.dateTime.month);
126     data.print("  ");
127    data.print(fix.latitude(), 6);
128    data.print("   ");
129    data.print(fix.longitude(), 6);
130    data.print("  ");
131    data.print(alt);
132     data.print("  ");
133    data.print(Am);
134    data.print("  ");
135    data.print(odo);
136     data.print("  ");
137    data.print(Dist);
138    data.print("  ");
139     data.print(Speed);
140    data.print("  ");
141    data.print(head);
142    data.print("   ");
143    data.print(Sat);
144    data.println();
145    data.close();
146  }
147}

#include <SPI.h>
#include <SD.h>
#include <Wire.h>
#include "SSD1306Ascii.h"
#include   "SSD1306AsciiWire.h"
#include <NMEAGPS.h>
#include <NeoSWSerial.h>
#define   I2C_ADDRESS 0x3C
#define RST_PIN -1
#define MAX_CHARS 24
#define RX_pin   5
#define TX_pin 4
#define SHOW_INTERVAL 1
#define GPS_baud 9600
SSD1306AsciiWire   oled;
NMEAGPS gps;
gps_fix fix;
float odo, Speed, alt, Dist, head, maxs   = 0, Am = 0;
unsigned int Sat = 0;
NeoGPS::Location_t    lastLoc, base;
bool   stScan = true, lastLocOK = false;
static NeoSWSerial gpsPort(RX_pin, TX_pin);
static   constexpr int INITIAL_SHOW  = (2 * SHOW_INTERVAL) - 1;
int show          = INITIAL_SHOW;
const   int   LED_PIN  = 3;
const float SPEED_LIMIT = 0.1; // speed limit value
void   disp(int c, int r)
{
  oled.clear();
  oled.setCursor(c, r);
}
void   setup() {

  pinMode (LED_PIN, OUTPUT);
  Serial.begin(9600);
  gpsPort.begin(GPS_baud);
   Wire.begin();
  oled.begin(&SH1106_128x64, I2C_ADDRESS);
  oled.setFont(ZevvPeep8x16);
   oled.clear();
  disp(30, 2);// as to center your name change 30
  oled.println("YourName");//10   characters available here
  delay(2000);
  disp(55, 2);
  oled.print("GPS");//5   characters available here
  delay(2000);
  oled.clear();
  const int cs_sd   = 2;
  if (!SD.begin (cs_sd)) {
    oled.clear();
    disp(60, 2);
     oled.print("SD");//if you read this on display mean SD is not present
     delay(10000);
    oled.clear();
    return;
  }
  disp(60, 2);
   oled.print("OK");
  delay(2000);
  oled.clear();
  File data = SD.open("L.csv",   FILE_WRITE);
  data.println("");
  data.println("Da  Hr  La  Lo  At  Am   Km  Di  Sp  He  Sa" );
  data.close();
}
void loop() {
  if (gps.available(   gpsPort )) {
    gps_fix fix = gps.read();
    show = (show + 1) % SHOW_INTERVAL;
     if (fix.valid.speed && (fix.speed_kph() > SPEED_LIMIT)) {
      digitalWrite(   LED_PIN, HIGH );
    } else {
      digitalWrite( LED_PIN, LOW );
    }
     if (fix.valid.location) {
      if (lastLocOK) {
        odo += fix.location.DistanceKm(   lastLoc );
        Speed = fix.speed_kph();
      }
      lastLoc   = fix.location;
       lastLocOK = true;
      if (stScan) {
        stScan = false;
        base    = fix.location;
      } else {
        Dist = ( fix.location.DistanceKm(   base ) );
      }
    }
    if ( Speed > maxs)          maxs = Speed;
     if (fix.valid.heading )     head = fix.heading() ;
    if (fix.valid.satellites   )  Sat = fix.satellites ;
    if (fix.valid.altitude)     alt = fix.altitude();
     if ( alt > Am)              Am = alt;
         if (show == 0) {
        char   displayBufffer[MAX_CHARS];
        oled.setCursor(0, 0);
        snprintf(displayBufffer,   MAX_CHARS, "Km:%2d.%1d",  (int)odo, (int)(odo * 100) % 100);
        oled.println(displayBufffer);
         oled.setCursor(65, 0);
        snprintf(displayBufffer, MAX_CHARS, "Di:%2d.%1d",   (int)Dist, (int)(Dist * 100) % 100);
        oled.println(displayBufffer);
         snprintf(displayBufffer, MAX_CHARS, "Sp:%2d.%1d", (int)Speed, (int)(Speed   * 10) % 10);
        oled.println(displayBufffer);
        oled.setCursor(65,   2);
        snprintf(displayBufffer, MAX_CHARS, "Sm:%2d.%1d", (int)maxs, (int)(maxs   * 10) % 10);
        oled.println(displayBufffer);
        snprintf(displayBufffer,   MAX_CHARS, "Al:%2d.%1d", (int)alt, (int)(alt * 100) % 100);
        oled.println(displayBufffer);
         oled.setCursor(65, 4);
        snprintf(displayBufffer, MAX_CHARS, "Am:%2d.%1d",   (int)Am, (int)(Am * 100) % 100);
        oled.println(displayBufffer);
        snprintf(displayBufffer,   MAX_CHARS, "Sa: %d", (int)Sat);
        oled.println(displayBufffer);
        oled.setCursor(65,   6);
        snprintf(displayBufffer, MAX_CHARS, "He:%2d.%1d", (int)head, (int)(head   * 100) % 100);
        oled.println(displayBufffer);
      }
    File data   = SD.open("L.csv", FILE_WRITE);
    data.print(fix.dateTime.hours + 2);
     data.print(":");
    data.print(fix.dateTime.minutes);
    data.print("   ");
    data.print(fix.dateTime.date);
    data.print("/");
    data.print(fix.dateTime.month);
     data.print("  ");
    data.print(fix.latitude(), 6);
    data.print("   ");
    data.print(fix.longitude(), 6);
    data.print("  ");
    data.print(alt);
     data.print("  ");
    data.print(Am);
    data.print("  ");
    data.print(odo);
     data.print("  ");
    data.print(Dist);
    data.print("  ");
     data.print(Speed);
    data.print("  ");
    data.print(head);
    data.print("   ");
    data.print(Sat);
    data.println();
    data.close();
  }
}

display sh1106 1,3''

arduino

code for large 1,3'' 4 pin 128x64 display

1#include <SPI.h>
2#include <SD.h>
3#include <Wire.h>
4
5#include   "SSD1306Ascii.h"
6#include "SSD1306AsciiWire.h"
7#include <NMEAGPS.h>
8//#include   <SoftwareSerial.h> //check library or change neoSWSerial.h
9#include <NeoSWSerial.h>
10const   int cs_sd=2;
11#define I2C_ADDRESS 0x3C
12#define RST_PIN -1
13SSD1306AsciiWire   oled;
14NMEAGPS gps;
15gps_fix fix;
16File myFile;
17float odo;
18float Speed;   
19float alt;
20
21NeoGPS::Location_t    lastLoc;
22bool                  lastLocOK   = false;
23static const int RXPin = 5, TXPin = 4; //-- gps pin
24static const   uint32_t GPSBaud = 9600;
25NeoSWSerial gpsPort(RXPin, TXPin);
26const int SHOW_INTERVAL   = 1;
27const int INITIAL_SHOW  = (2 * SHOW_INTERVAL) - 1; 
28int show          =   INITIAL_SHOW;
29const int   LED_PIN  = 3;
30const float SPEED_LIMIT = 0.0; //   --setup speed limit value es: 55.0; kmh default 0.0
31int maxs = 0; 
32void setup(){
33   
34  pinMode (LED_PIN, OUTPUT);
35Serial.begin(9600);
36gpsPort.begin(GPSBaud);
37Wire.begin();
38oled.begin(&SH1106_128x64,   I2C_ADDRESS);
39oled.setFont(ZevvPeep8x16);
40oled.clear();
41oled.println("   ");
42oled.println("  GPS LOGGER"); 
43oled.println(" ");
44oled.println("    WELCOME"); 
45delay(3000);
46oled.clear();
47if(!SD.begin(cs_sd)){
48oled.clear();
49oled.println("   ");
50oled.print("NO SD");
51delay(3000);
52return;}
53oled.println(" ");
54oled.print("   SD Card OK");
55delay(2000);
56oled.clear();
57File data = SD.open("log.csv",FILE_WRITE);               
58data.println(""); 
59data.println("Dat  Hr+  Lat  Lon  Alt   Vel  Dis" ); 
60data.close();}
61void loop(){
62if (gps.available( gpsPort   )) {  
63gps_fix fix = gps.read();  
64show = (show + 1) % SHOW_INTERVAL;
65if   (fix.valid.speed && (fix.speed_kph() > SPEED_LIMIT)) {
66    digitalWrite( LED_PIN,   HIGH );   
67 } else {
68 digitalWrite( LED_PIN, LOW ); } 
69 if (fix.valid.location)   { 
70 if (lastLocOK) {
71 odo += fix.location.DistanceKm( lastLoc );
72 Speed   = (fix.speed_kph());}
73lastLoc   = fix.location;
74lastLocOK = true;}
75if (   Speed > maxs) 
76maxs = Speed;
77if (fix.valid.altitude)
78 alt = ( fix.altitude   () );
79 
80if (show == 0) {
81#define MAX_CHARS 24
82char displayBufffer[MAX_CHARS];
83oled.setCursor(0,0);    
84snprintf(displayBufffer, MAX_CHARS, " K m :% 3d.%02d", (int)odo, (int)(odo   * 100)%100);
85oled.println(displayBufffer);   
86snprintf(displayBufffer, MAX_CHARS,   " Kmh :% 3d.%02d", (int)Speed, (int)(Speed * 100)%100);
87oled.println(displayBufffer);
88snprintf(displayBufffer,   MAX_CHARS, " Mspd:% 3d.%02d", (int)maxs, (int)(maxs * 100)%100);
89oled.println(displayBufffer);
90snprintf(displayBufffer,   MAX_CHARS, " Alt :% 3d.%02d", (int)alt, (int)(alt * 100)%100);
91oled.println(displayBufffer);}   
92if (fix.dateTime);   
93String Temps=String(fix.dateTime.hours )+(":")+(fix.dateTime.minutes)+(":")+(fix.dateTime.seconds);
94String   Date=String(fix.dateTime.date )+("/")+(fix.dateTime.month)+("/")+(fix.dateTime.year);   
95File data=SD.open("log.csv",FILE_WRITE);
96data.println(Date +("  ")+   Temps +("  ")+ String(fix.latitude(), 6)+("  ")+String(fix.longitude(), 6)+("   ")+(alt)+("  ") +(Speed)+("  ")+(odo)); 
97data.close();}}

#include <SPI.h>
#include <SD.h>
#include <Wire.h>

#include   "SSD1306Ascii.h"
#include "SSD1306AsciiWire.h"
#include <NMEAGPS.h>
//#include   <SoftwareSerial.h> //check library or change neoSWSerial.h
#include <NeoSWSerial.h>
const   int cs_sd=2;
#define I2C_ADDRESS 0x3C
#define RST_PIN -1
SSD1306AsciiWire   oled;
NMEAGPS gps;
gps_fix fix;
File myFile;
float odo;
float Speed;   
float alt;

NeoGPS::Location_t    lastLoc;
bool                  lastLocOK   = false;
static const int RXPin = 5, TXPin = 4; //-- gps pin
static const   uint32_t GPSBaud = 9600;
NeoSWSerial gpsPort(RXPin, TXPin);
const int SHOW_INTERVAL   = 1;
const int INITIAL_SHOW  = (2 * SHOW_INTERVAL) - 1; 
int show          =   INITIAL_SHOW;
const int   LED_PIN  = 3;
const float SPEED_LIMIT = 0.0; //   --setup speed limit value es: 55.0; kmh default 0.0
int maxs = 0; 
void setup(){
   
  pinMode (LED_PIN, OUTPUT);
Serial.begin(9600);
gpsPort.begin(GPSBaud);
Wire.begin();
oled.begin(&SH1106_128x64,   I2C_ADDRESS);
oled.setFont(ZevvPeep8x16);
oled.clear();
oled.println("   ");
oled.println("  GPS LOGGER"); 
oled.println(" ");
oled.println("    WELCOME"); 
delay(3000);
oled.clear();
if(!SD.begin(cs_sd)){
oled.clear();
oled.println("   ");
oled.print("NO SD");
delay(3000);
return;}
oled.println(" ");
oled.print("   SD Card OK");
delay(2000);
oled.clear();
File data = SD.open("log.csv",FILE_WRITE);               
data.println(""); 
data.println("Dat  Hr+  Lat  Lon  Alt   Vel  Dis" ); 
data.close();}
void loop(){
if (gps.available( gpsPort   )) {  
gps_fix fix = gps.read();  
show = (show + 1) % SHOW_INTERVAL;
if   (fix.valid.speed && (fix.speed_kph() > SPEED_LIMIT)) {
    digitalWrite( LED_PIN,   HIGH );   
 } else {
 digitalWrite( LED_PIN, LOW ); } 
 if (fix.valid.location)   { 
 if (lastLocOK) {
 odo += fix.location.DistanceKm( lastLoc );
 Speed   = (fix.speed_kph());}
lastLoc   = fix.location;
lastLocOK = true;}
if (   Speed > maxs) 
maxs = Speed;
if (fix.valid.altitude)
 alt = ( fix.altitude   () );
 
if (show == 0) {
#define MAX_CHARS 24
char displayBufffer[MAX_CHARS];
oled.setCursor(0,0);    
snprintf(displayBufffer, MAX_CHARS, " K m :% 3d.%02d", (int)odo, (int)(odo   * 100)%100);
oled.println(displayBufffer);   
snprintf(displayBufffer, MAX_CHARS,   " Kmh :% 3d.%02d", (int)Speed, (int)(Speed * 100)%100);
oled.println(displayBufffer);
snprintf(displayBufffer,   MAX_CHARS, " Mspd:% 3d.%02d", (int)maxs, (int)(maxs * 100)%100);
oled.println(displayBufffer);
snprintf(displayBufffer,   MAX_CHARS, " Alt :% 3d.%02d", (int)alt, (int)(alt * 100)%100);
oled.println(displayBufffer);}   
if (fix.dateTime);   
String Temps=String(fix.dateTime.hours )+(":")+(fix.dateTime.minutes)+(":")+(fix.dateTime.seconds);
String   Date=String(fix.dateTime.date )+("/")+(fix.dateTime.month)+("/")+(fix.dateTime.year);   
File data=SD.open("log.csv",FILE_WRITE);
data.println(Date +("  ")+   Temps +("  ")+ String(fix.latitude(), 6)+("  ")+String(fix.longitude(), 6)+("   ")+(alt)+("  ") +(Speed)+("  ")+(odo)); 
data.close();}}

10/2021 update compass 16 sectors

arduino

a new code version for oled 1.3'' sh1106 with travel time and compass 16 sectors

1#include <SPI.h>
2#include <SD.h>
3#include <Wire.h>
4#include "SSD1306Ascii.h"
5#include  "SSD1306AsciiWire.h"
6#include <NMEAGPS.h>
7#include <NeoSWSerial.h>
8
9#define  I2C_ADDRESS 0x3C
10#define RST_PIN -1
11#define MAX_CHARS 24
12#define RX_pin  5
13#define TX_pin 4
14#define SHOW_INTERVAL 1
15#define GPS_baud 9600
16SSD1306AsciiWire  oled;
17NMEAGPS gps;
18gps_fix fix;
19float odo, Dist;
20unsigned int head,  Speed, alt, Sat = 0, maxs = 0;
21
22NeoGPS::Location_t    lastLoc, base;
23bool  stScan = true, lastLocOK = false;
24bool altOK = false;
25bool Satok = false;
26static  NeoSWSerial gpsPort(RX_pin, TX_pin);
27static constexpr int INITIAL_SHOW  = (2  * SHOW_INTERVAL) - 1;
28int show          = INITIAL_SHOW;
29const int   LED_PIN  = 3;
30const float SPEED_LIMIT = 0.1; // speed limit value
31
32void disp(int  c, int r) {
33  oled.clear();
34  oled.setCursor(c, r);
35}
36
37const char*  strBussola[16] = {"N  ", "NNe", "NE ", "EnE", "E  ", "EsE",
38                              "SE  ", "SSe", "S  ", "SSw", "SW ", "WsW", "W  ", "WnW", "NW ", "NNw"
39                             };
40int index;
41
42int trovaIndice(float angolo)  {
43  int _index;
44  for (_index = 0; _index < 16; _index++) {
45    float angoloDirezione  = _index * 22.25 + 11.25;
46    float angoloMin = angoloDirezione - 11.25;
47    float angoloMax = angoloDirezione + 11.25;
48    if (angolo >= angoloMin &&  angolo <= angoloMax)
49      return _index;
50  }
51  return _index;
52}
53
54void  setup() {
55  pinMode (LED_PIN, OUTPUT);
56  Serial.begin(9600);
57  gpsPort.begin(GPS_baud);
58  Wire.begin();
59  oled.begin(&SH1106_128x64, I2C_ADDRESS);
60  oled.setFont(ZevvPeep8x16);
61  //oled.displayRemap(true); // inversione dello schermo display
62  disp(0, 2);
63  oled.println(F(" YOUR  NAME "));// put your name here
64  delay(1500);
65  oled.setCursor(24, 5);
66  oled.println(F("GPS LOGGER"));
67  delay(2500);
68  oled.clear();
69  const int cs_sd = 2;
70  if (!SD.begin (cs_sd)) {
71    oled.clear();
72    disp(50, 2);
73    oled.print(F("SD"));
74    delay(10000);
75    oled.clear();
76  }
77  File data = SD.open("L.csv", FILE_WRITE);
78  data.println("");
79  data.println(F("D H T La Lo At Km Di Ve He Co Sa" ));
80  data.close();
81}
82
83void  loop() {
84  unsigned long tmp = millis() / 1000;
85  byte secondi = tmp % 60;
86  byte minuti = (tmp / 60) % 60;
87  byte ore = (tmp / 3600) % 24;
88
89  if  (gps.available( gpsPort )) {
90    gps_fix fix = gps.read();
91    show = (show  + 1) % SHOW_INTERVAL;
92    if (fix.valid.speed && (fix.speed_kph() > SPEED_LIMIT))  {
93      digitalWrite( LED_PIN, HIGH );
94    } else {
95      digitalWrite(  LED_PIN, LOW );
96    }
97    if (fix.valid.location) {
98      if (lastLocOK)  {
99        odo += fix.location.DistanceKm( lastLoc );
100        Speed = fix.speed_kph();
101      }
102      lastLoc   = fix.location;
103      lastLocOK = true;
104      if  (stScan) {
105        stScan = false;
106        base   = fix.location;
107      }  else {
108        Dist = ( fix.location.DistanceKm( base ) );
109      }
110    }
111    if ( Speed > maxs)          maxs = Speed;
112    if (fix.valid.satellites )  {
113      Sat = fix.satellites ;
114      Satok = true;
115    }
116
117
118    if  (fix.valid.heading ) {
119      head = fix.heading() ;
120      index = trovaIndice(head);
121    }
122
123    if (fix.valid.altitude){ 
124      alt = fix.altitude();
125     altOK  = true;
126    }
127
128    if (show == 0) {
129      char displayBufffer[MAX_CHARS];
130      oled.setCursor(0, 0);
131      snprintf(displayBufffer, MAX_CHARS, "Km: %d.%d",  (int)odo, (int)(odo * 100) % 100);
132      oled.println(displayBufffer);
133      oled.setCursor(65, 0);
134      snprintf(displayBufffer, MAX_CHARS, "Ve:  %d", (int)Speed, (int)(Speed * 100) % 100);
135      oled.println(displayBufffer);
136      snprintf(displayBufffer, MAX_CHARS, "Di: %d.%d",  (int)Dist, (int)(Dist  * 100) % 100);
137      
138      oled.println(displayBufffer);
139     oled.setCursor(65,  2);
140     snprintf(displayBufffer, MAX_CHARS, "Vm: %d", (int)maxs, (int)(maxs  * 100) % 100);
141      
142      oled.println(displayBufffer);
143
144      snprintf(displayBufffer,  MAX_CHARS, "Al: %d", (int)alt, (int)(alt * 100) % 100);
145      oled.println(displayBufffer);
146      oled.setCursor(65, 4);
147      snprintf(displayBufffer, MAX_CHARS, "He:  %d", (int)head, (int)(head * 100) % 100);
148      oled.println(displayBufffer);
149      snprintf(displayBufffer, MAX_CHARS, "%d:%d:%d ", (int)ore, (int)minuti,  (int)secondi);
150      oled.println(displayBufffer);
151      oled.setCursor(65,  6);
152      snprintf(displayBufffer, MAX_CHARS, "Co: %s\
153", (strBussola[index]));
154      
155      oled.println(displayBufffer);
156    }
157    File data = SD.open("L.csv",  FILE_WRITE);
158    data.print(fix.dateTime.hours + 2);
159    data.print(":");
160    data.print(fix.dateTime.minutes);
161    data.print(" ");
162    data.print(fix.dateTime.date);
163    data.print("/");
164    data.print(fix.dateTime.month);
165    data.print("  ");
166    data.print(ore);
167    data.print(":");
168    data.print(minuti);
169    data.print(":");
170    data.print(secondi);
171    data.print(" ");
172    data.print(fix.latitude(), 6);
173    data.print(" ");
174    data.print(fix.longitude(),  6);
175    data.print(" ");
176    data.print(alt);
177    data.print(" ");
178
179    data.print(odo);
180    data.print(" ");
181    data.print(Dist);
182    data.print("  ");
183    data.print(Speed);
184    data.print(" ");
185    data.print(head);
186    data.print(" ");
187    data.print(strBussola[index]);
188    data.print("  ");
189    data.print(Sat);
190    data.println();
191    data.close();
192  }
193}

#include <SPI.h>
#include <SD.h>
#include <Wire.h>
#include "SSD1306Ascii.h"
#include  "SSD1306AsciiWire.h"
#include <NMEAGPS.h>
#include <NeoSWSerial.h>

#define  I2C_ADDRESS 0x3C
#define RST_PIN -1
#define MAX_CHARS 24
#define RX_pin  5
#define TX_pin 4
#define SHOW_INTERVAL 1
#define GPS_baud 9600
SSD1306AsciiWire  oled;
NMEAGPS gps;
gps_fix fix;
float odo, Dist;
unsigned int head,  Speed, alt, Sat = 0, maxs = 0;

NeoGPS::Location_t    lastLoc, base;
bool  stScan = true, lastLocOK = false;
bool altOK = false;
bool Satok = false;
static  NeoSWSerial gpsPort(RX_pin, TX_pin);
static constexpr int INITIAL_SHOW  = (2  * SHOW_INTERVAL) - 1;
int show          = INITIAL_SHOW;
const int   LED_PIN  = 3;
const float SPEED_LIMIT = 0.1; // speed limit value

void disp(int  c, int r) {
  oled.clear();
  oled.setCursor(c, r);
}

const char*  strBussola[16] = {"N  ", "NNe", "NE ", "EnE", "E  ", "EsE",
                              "SE  ", "SSe", "S  ", "SSw", "SW ", "WsW", "W  ", "WnW", "NW ", "NNw"
                             };
int index;

int trovaIndice(float angolo)  {
  int _index;
  for (_index = 0; _index < 16; _index++) {
    float angoloDirezione  = _index * 22.25 + 11.25;
    float angoloMin = angoloDirezione - 11.25;
    float angoloMax = angoloDirezione + 11.25;
    if (angolo >= angoloMin &&  angolo <= angoloMax)
      return _index;
  }
  return _index;
}

void  setup() {
  pinMode (LED_PIN, OUTPUT);
  Serial.begin(9600);
  gpsPort.begin(GPS_baud);
  Wire.begin();
  oled.begin(&SH1106_128x64, I2C_ADDRESS);
  oled.setFont(ZevvPeep8x16);
  //oled.displayRemap(true); // inversione dello schermo display
  disp(0, 2);
  oled.println(F(" YOUR  NAME "));// put your name here
  delay(1500);
  oled.setCursor(24, 5);
  oled.println(F("GPS LOGGER"));
  delay(2500);
  oled.clear();
  const int cs_sd = 2;
  if (!SD.begin (cs_sd)) {
    oled.clear();
    disp(50, 2);
    oled.print(F("SD"));
    delay(10000);
    oled.clear();
  }
  File data = SD.open("L.csv", FILE_WRITE);
  data.println("");
  data.println(F("D H T La Lo At Km Di Ve He Co Sa" ));
  data.close();
}

void  loop() {
  unsigned long tmp = millis() / 1000;
  byte secondi = tmp % 60;
  byte minuti = (tmp / 60) % 60;
  byte ore = (tmp / 3600) % 24;

  if  (gps.available( gpsPort )) {
    gps_fix fix = gps.read();
    show = (show  + 1) % SHOW_INTERVAL;
    if (fix.valid.speed && (fix.speed_kph() > SPEED_LIMIT))  {
      digitalWrite( LED_PIN, HIGH );
    } else {
      digitalWrite(  LED_PIN, LOW );
    }
    if (fix.valid.location) {
      if (lastLocOK)  {
        odo += fix.location.DistanceKm( lastLoc );
        Speed = fix.speed_kph();
      }
      lastLoc   = fix.location;
      lastLocOK = true;
      if  (stScan) {
        stScan = false;
        base   = fix.location;
      }  else {
        Dist = ( fix.location.DistanceKm( base ) );
      }
    }
    if ( Speed > maxs)          maxs = Speed;
    if (fix.valid.satellites )  {
      Sat = fix.satellites ;
      Satok = true;
    }


    if  (fix.valid.heading ) {
      head = fix.heading() ;
      index = trovaIndice(head);
    }

    if (fix.valid.altitude){ 
      alt = fix.altitude();
     altOK  = true;
    }

    if (show == 0) {
      char displayBufffer[MAX_CHARS];
      oled.setCursor(0, 0);
      snprintf(displayBufffer, MAX_CHARS, "Km: %d.%d",  (int)odo, (int)(odo * 100) % 100);
      oled.println(displayBufffer);
      oled.setCursor(65, 0);
      snprintf(displayBufffer, MAX_CHARS, "Ve:  %d", (int)Speed, (int)(Speed * 100) % 100);
      oled.println(displayBufffer);
      snprintf(displayBufffer, MAX_CHARS, "Di: %d.%d",  (int)Dist, (int)(Dist  * 100) % 100);
      
      oled.println(displayBufffer);
     oled.setCursor(65,  2);
     snprintf(displayBufffer, MAX_CHARS, "Vm: %d", (int)maxs, (int)(maxs  * 100) % 100);
      
      oled.println(displayBufffer);

      snprintf(displayBufffer,  MAX_CHARS, "Al: %d", (int)alt, (int)(alt * 100) % 100);
      oled.println(displayBufffer);
      oled.setCursor(65, 4);
      snprintf(displayBufffer, MAX_CHARS, "He:  %d", (int)head, (int)(head * 100) % 100);
      oled.println(displayBufffer);
      snprintf(displayBufffer, MAX_CHARS, "%d:%d:%d ", (int)ore, (int)minuti,  (int)secondi);
      oled.println(displayBufffer);
      oled.setCursor(65,  6);
      snprintf(displayBufffer, MAX_CHARS, "Co: %s\
", (strBussola[index]));
      
      oled.println(displayBufffer);
    }
    File data = SD.open("L.csv",  FILE_WRITE);
    data.print(fix.dateTime.hours + 2);
    data.print(":");
    data.print(fix.dateTime.minutes);
    data.print(" ");
    data.print(fix.dateTime.date);
    data.print("/");
    data.print(fix.dateTime.month);
    data.print("  ");
    data.print(ore);
    data.print(":");
    data.print(minuti);
    data.print(":");
    data.print(secondi);
    data.print(" ");
    data.print(fix.latitude(), 6);
    data.print(" ");
    data.print(fix.longitude(),  6);
    data.print(" ");
    data.print(alt);
    data.print(" ");

    data.print(odo);
    data.print(" ");
    data.print(Dist);
    data.print("  ");
    data.print(Speed);
    data.print(" ");
    data.print(head);
    data.print(" ");
    data.print(strBussola[index]);
    data.print("  ");
    data.print(Sat);
    data.println();
    data.close();
  }
}

display 1306 0,96''

arduino

use this with 0,96'' 4 pin oled 128x64 display

1#include <SPI.h>
2#include <SD.h>
3#include <Wire.h>
4
5#include   "SSD1306Ascii.h"
6#include "SSD1306AsciiWire.h"
7#include <NMEAGPS.h>
8
9#include   <NeoSWSerial.h>
10const int cs_sd=2;
11#define I2C_ADDRESS 0x3C
12#define RST_PIN   -1
13SSD1306AsciiWire oled;
14NMEAGPS gps;
15gps_fix fix;
16File myFile;
17float   odo;
18float Speed; 
19float alt;
20
21NeoGPS::Location_t    lastLoc;
22bool                   lastLocOK = false;
23static const int RXPin = 5, TXPin = 4; //--   gps pin
24static const uint32_t GPSBaud = 9600;
25NeoSWSerial gpsPort(RXPin, TXPin);
26const   int SHOW_INTERVAL = 1;
27const int INITIAL_SHOW  = (2 * SHOW_INTERVAL) - 1; 
28int   show          = INITIAL_SHOW;
29const int   LED_PIN  = 3;  //-- led on at speed   limit
30const float SPEED_LIMIT = 0.0; // --setup speed limit value es: 55.0; kmh   default 0.0
31int maxs = 0; 
32void setup(){
33  
34  pinMode (LED_PIN, OUTPUT);
35Serial.begin(9600);
36gpsPort.begin(GPSBaud);
37Wire.begin();
38oled.begin(&   Adafruit128x64, I2C_ADDRESS);
39oled.setFont(TimesNewRoman16);
40oled.clear();
41oled.println("   ");
42oled.println("  GPS LOGGER"); //you can custom this text
43oled.println("   ");
44oled.println("   WELCOME"); //you can custom this text
45delay(3000);
46oled.clear();
47if(!SD.begin(cs_sd)){
48oled.clear();
49oled.println("   ");
50oled.print("NO SD");
51delay(3000);
52return;}
53oled.println(" ");
54oled.print("   SD Card OK");
55delay(2000);
56oled.clear();
57File data = SD.open("log.csv",FILE_WRITE);               
58data.println(""); 
59data.println("Dat  Hr+  Lat  Lon  Alt   Vel  Dis" ); 
60data.close();}
61void loop(){
62if (gps.available( gpsPort   )) {  
63gps_fix fix = gps.read();  
64show = (show + 1) % SHOW_INTERVAL;
65if   (fix.valid.speed && (fix.speed_kph() > SPEED_LIMIT)) {
66    digitalWrite( LED_PIN,   HIGH );   
67 } else {
68 digitalWrite( LED_PIN, LOW ); } 
69 if (fix.valid.location)   { 
70 if (lastLocOK) {
71 odo += fix.location.DistanceKm( lastLoc );
72 Speed   = (fix.speed_kph());}
73lastLoc   = fix.location;
74lastLocOK = true;}
75if (   Speed > maxs) 
76maxs = Speed;
77if (fix.valid.altitude)
78 alt = ( fix.altitude   () );
79 
80if (show == 0) {
81#define MAX_CHARS 24
82char displayBufffer[MAX_CHARS];
83oled.setCursor(0,0);    
84snprintf(displayBufffer, MAX_CHARS, " DIST :  %  3d.%02d", (int)odo, (int)(odo   * 100)%100);//distance
85oled.println(displayBufffer);   
86snprintf(displayBufffer,   MAX_CHARS, " KMH:  %  3d.%02d", (int)Speed, (int)(Speed * 100)%100);//speed
87oled.println(displayBufffer);
88snprintf(displayBufffer,   MAX_CHARS, " MxSP: %  3d.%02d", (int)maxs, (int)(maxs * 100)%100);//max top speed
89oled.println(displayBufffer);
90snprintf(displayBufffer,   MAX_CHARS, " ALT  :  %  3d.%02d", (int)alt, (int)(alt * 100)%100);//altitude
91oled.println(displayBufffer);}   
92if (fix.dateTime);   
93String Temps=String(fix.dateTime.hours )+(":")+(fix.dateTime.minutes)+(":")+(fix.dateTime.seconds);
94String   Date=String(fix.dateTime.date )+("/")+(fix.dateTime.month)+("/")+(fix.dateTime.year);   
95File data=SD.open("log.csv",FILE_WRITE);
96data.println(Date +("  ")+   Temps +("  ")+ String(fix.latitude(), 6)+("  ")+String(fix.longitude(), 6)+("   ")+(alt)+("  ") +(Speed)+("  ")+(odo)); 
97data.close();}}
98

#include <SPI.h>
#include <SD.h>
#include <Wire.h>

#include   "SSD1306Ascii.h"
#include "SSD1306AsciiWire.h"
#include <NMEAGPS.h>

#include   <NeoSWSerial.h>
const int cs_sd=2;
#define I2C_ADDRESS 0x3C
#define RST_PIN   -1
SSD1306AsciiWire oled;
NMEAGPS gps;
gps_fix fix;
File myFile;
float   odo;
float Speed; 
float alt;

NeoGPS::Location_t    lastLoc;
bool                   lastLocOK = false;
static const int RXPin = 5, TXPin = 4; //--   gps pin
static const uint32_t GPSBaud = 9600;
NeoSWSerial gpsPort(RXPin, TXPin);
const   int SHOW_INTERVAL = 1;
const int INITIAL_SHOW  = (2 * SHOW_INTERVAL) - 1; 
int   show          = INITIAL_SHOW;
const int   LED_PIN  = 3;  //-- led on at speed   limit
const float SPEED_LIMIT = 0.0; // --setup speed limit value es: 55.0; kmh   default 0.0
int maxs = 0; 
void setup(){
  
  pinMode (LED_PIN, OUTPUT);
Serial.begin(9600);
gpsPort.begin(GPSBaud);
Wire.begin();
oled.begin(&   Adafruit128x64, I2C_ADDRESS);
oled.setFont(TimesNewRoman16);
oled.clear();
oled.println("   ");
oled.println("  GPS LOGGER"); //you can custom this text
oled.println("   ");
oled.println("   WELCOME"); //you can custom this text
delay(3000);
oled.clear();
if(!SD.begin(cs_sd)){
oled.clear();
oled.println("   ");
oled.print("NO SD");
delay(3000);
return;}
oled.println(" ");
oled.print("   SD Card OK");
delay(2000);
oled.clear();
File data = SD.open("log.csv",FILE_WRITE);               
data.println(""); 
data.println("Dat  Hr+  Lat  Lon  Alt   Vel  Dis" ); 
data.close();}
void loop(){
if (gps.available( gpsPort   )) {  
gps_fix fix = gps.read();  
show = (show + 1) % SHOW_INTERVAL;
if   (fix.valid.speed && (fix.speed_kph() > SPEED_LIMIT)) {
    digitalWrite( LED_PIN,   HIGH );   
 } else {
 digitalWrite( LED_PIN, LOW ); } 
 if (fix.valid.location)   { 
 if (lastLocOK) {
 odo += fix.location.DistanceKm( lastLoc );
 Speed   = (fix.speed_kph());}
lastLoc   = fix.location;
lastLocOK = true;}
if (   Speed > maxs) 
maxs = Speed;
if (fix.valid.altitude)
 alt = ( fix.altitude   () );
 
if (show == 0) {
#define MAX_CHARS 24
char displayBufffer[MAX_CHARS];
oled.setCursor(0,0);    
snprintf(displayBufffer, MAX_CHARS, " DIST :  %  3d.%02d", (int)odo, (int)(odo   * 100)%100);//distance
oled.println(displayBufffer);   
snprintf(displayBufffer,   MAX_CHARS, " KMH:  %  3d.%02d", (int)Speed, (int)(Speed * 100)%100);//speed
oled.println(displayBufffer);
snprintf(displayBufffer,   MAX_CHARS, " MxSP: %  3d.%02d", (int)maxs, (int)(maxs * 100)%100);//max top speed
oled.println(displayBufffer);
snprintf(displayBufffer,   MAX_CHARS, " ALT  :  %  3d.%02d", (int)alt, (int)(alt * 100)%100);//altitude
oled.println(displayBufffer);}   
if (fix.dateTime);   
String Temps=String(fix.dateTime.hours )+(":")+(fix.dateTime.minutes)+(":")+(fix.dateTime.seconds);
String   Date=String(fix.dateTime.date )+("/")+(fix.dateTime.month)+("/")+(fix.dateTime.year);   
File data=SD.open("log.csv",FILE_WRITE);
data.println(Date +("  ")+   Temps +("  ")+ String(fix.latitude(), 6)+("  ")+String(fix.longitude(), 6)+("   ")+(alt)+("  ") +(Speed)+("  ")+(odo)); 
data.close();}}

more data on display sh1106 1.3 version 2021''

arduino

1#include <SPI.h>
2#include <SD.h>
3#include <Wire.h>
4#include "SSD1306Ascii.h"
5#include  "SSD1306AsciiWire.h"
6#include <NMEAGPS.h>
7#include <NeoSWSerial.h>
8#define  I2C_ADDRESS 0x3C
9#define RST_PIN -1
10#define MAX_CHARS 24
11#define RX_pin  5
12#define TX_pin 4
13#define SHOW_INTERVAL 1
14#define GPS_baud 9600
15SSD1306AsciiWire  oled;
16NMEAGPS gps;
17gps_fix fix;
18float odo, Speed, alt, Dist, head, maxs  = 0, Am = 0;
19unsigned int Sat = 0;
20NeoGPS::Location_t    lastLoc, base;
21bool  stScan = true, lastLocOK = false;
22static NeoSWSerial gpsPort(RX_pin, TX_pin);
23static  constexpr int INITIAL_SHOW  = (2 * SHOW_INTERVAL) - 1;
24int show          = INITIAL_SHOW;
25const  int   LED_PIN  = 3;
26const float SPEED_LIMIT = 0.1; // speed limit value
27void  disp(int c, int r)
28{
29  oled.clear();
30  oled.setCursor(c, r);
31}
32void  setup() {
33
34  pinMode (LED_PIN, OUTPUT);
35  Serial.begin(9600);
36  gpsPort.begin(GPS_baud);
37  Wire.begin();
38  oled.begin(&SH1106_128x64, I2C_ADDRESS);
39  oled.setFont(ZevvPeep8x16);
40  oled.clear();
41  disp(30, 2);// as to center your name change 30
42  oled.println("YourName");//10  characters available here
43  delay(2000);
44  disp(55, 2);
45  oled.print("GPS");//5  characters available here
46  delay(2000);
47  oled.clear();
48  const int cs_sd  = 2;
49  if (!SD.begin (cs_sd)) {
50    oled.clear();
51    disp(60, 2);
52    oled.print("SD");//if you read this on display mean SD is not present
53    delay(10000);
54    oled.clear();
55    return;
56  }
57  disp(60, 2);
58  oled.print("OK");
59  delay(2000);
60  oled.clear();
61  File data = SD.open("L.csv",  FILE_WRITE);
62  data.println("");
63  data.println("Da  Hr  La  Lo  At  Am  Km  Di  Sp  He  Sa" );
64  data.close();
65}
66void loop() {
67  if (gps.available(  gpsPort )) {
68    gps_fix fix = gps.read();
69    show = (show + 1) % SHOW_INTERVAL;
70    if (fix.valid.speed && (fix.speed_kph() > SPEED_LIMIT)) {
71      digitalWrite(  LED_PIN, HIGH );
72    } else {
73      digitalWrite( LED_PIN, LOW );
74    }
75    if (fix.valid.location) {
76      if (lastLocOK) {
77        odo += fix.location.DistanceKm(  lastLoc );
78        Speed = fix.speed_kph();
79      }
80      lastLoc   = fix.location;
81      lastLocOK = true;
82      if (stScan) {
83        stScan = false;
84        base   = fix.location;
85      } else {
86        Dist = ( fix.location.DistanceKm(  base ) );
87      }
88    }
89    if ( Speed > maxs)          maxs = Speed;
90    if (fix.valid.heading )     head = fix.heading() ;
91    if (fix.valid.satellites  )  Sat = fix.satellites ;
92    if (fix.valid.altitude)     alt = fix.altitude();
93    if ( alt > Am)              Am = alt;
94         if (show == 0) {
95        char  displayBufffer[MAX_CHARS];
96        oled.setCursor(0, 0);
97        snprintf(displayBufffer,  MAX_CHARS, "Km:%2d.%1d",  (int)odo, (int)(odo * 100) % 100);
98        oled.println(displayBufffer);
99        oled.setCursor(65, 0);
100        snprintf(displayBufffer, MAX_CHARS, "Di:%2d.%1d",  (int)Dist, (int)(Dist * 100) % 100);
101        oled.println(displayBufffer);
102        snprintf(displayBufffer, MAX_CHARS, "Sp:%2d.%1d", (int)Speed, (int)(Speed  * 10) % 10);
103        oled.println(displayBufffer);
104        oled.setCursor(65,  2);
105        snprintf(displayBufffer, MAX_CHARS, "Sm:%2d.%1d", (int)maxs, (int)(maxs  * 10) % 10);
106        oled.println(displayBufffer);
107        snprintf(displayBufffer,  MAX_CHARS, "Al:%2d.%1d", (int)alt, (int)(alt * 100) % 100);
108        oled.println(displayBufffer);
109        oled.setCursor(65, 4);
110        snprintf(displayBufffer, MAX_CHARS, "Am:%2d.%1d",  (int)Am, (int)(Am * 100) % 100);
111        oled.println(displayBufffer);
112        snprintf(displayBufffer,  MAX_CHARS, "Sa: %d", (int)Sat);
113        oled.println(displayBufffer);
114        oled.setCursor(65,  6);
115        snprintf(displayBufffer, MAX_CHARS, "He:%2d.%1d", (int)head, (int)(head  * 100) % 100);
116        oled.println(displayBufffer);
117      }
118    File data  = SD.open("L.csv", FILE_WRITE);
119    data.print(fix.dateTime.hours + 2);
120    data.print(":");
121    data.print(fix.dateTime.minutes);
122    data.print("  ");
123    data.print(fix.dateTime.date);
124    data.print("/");
125    data.print(fix.dateTime.month);
126    data.print("  ");
127    data.print(fix.latitude(), 6);
128    data.print("  ");
129    data.print(fix.longitude(), 6);
130    data.print("  ");
131    data.print(alt);
132    data.print("  ");
133    data.print(Am);
134    data.print("  ");
135    data.print(odo);
136    data.print("  ");
137    data.print(Dist);
138    data.print("  ");
139    data.print(Speed);
140    data.print("  ");
141    data.print(head);
142    data.print("  ");
143    data.print(Sat);
144    data.println();
145    data.close();
146  }
147}

#include <SPI.h>
#include <SD.h>
#include <Wire.h>
#include "SSD1306Ascii.h"
#include  "SSD1306AsciiWire.h"
#include <NMEAGPS.h>
#include <NeoSWSerial.h>
#define  I2C_ADDRESS 0x3C
#define RST_PIN -1
#define MAX_CHARS 24
#define RX_pin  5
#define TX_pin 4
#define SHOW_INTERVAL 1
#define GPS_baud 9600
SSD1306AsciiWire  oled;
NMEAGPS gps;
gps_fix fix;
float odo, Speed, alt, Dist, head, maxs  = 0, Am = 0;
unsigned int Sat = 0;
NeoGPS::Location_t    lastLoc, base;
bool  stScan = true, lastLocOK = false;
static NeoSWSerial gpsPort(RX_pin, TX_pin);
static  constexpr int INITIAL_SHOW  = (2 * SHOW_INTERVAL) - 1;
int show          = INITIAL_SHOW;
const  int   LED_PIN  = 3;
const float SPEED_LIMIT = 0.1; // speed limit value
void  disp(int c, int r)
{
  oled.clear();
  oled.setCursor(c, r);
}
void  setup() {

  pinMode (LED_PIN, OUTPUT);
  Serial.begin(9600);
  gpsPort.begin(GPS_baud);
  Wire.begin();
  oled.begin(&SH1106_128x64, I2C_ADDRESS);
  oled.setFont(ZevvPeep8x16);
  oled.clear();
  disp(30, 2);// as to center your name change 30
  oled.println("YourName");//10  characters available here
  delay(2000);
  disp(55, 2);
  oled.print("GPS");//5  characters available here
  delay(2000);
  oled.clear();
  const int cs_sd  = 2;
  if (!SD.begin (cs_sd)) {
    oled.clear();
    disp(60, 2);
    oled.print("SD");//if you read this on display mean SD is not present
    delay(10000);
    oled.clear();
    return;
  }
  disp(60, 2);
  oled.print("OK");
  delay(2000);
  oled.clear();
  File data = SD.open("L.csv",  FILE_WRITE);
  data.println("");
  data.println("Da  Hr  La  Lo  At  Am  Km  Di  Sp  He  Sa" );
  data.close();
}
void loop() {
  if (gps.available(  gpsPort )) {
    gps_fix fix = gps.read();
    show = (show + 1) % SHOW_INTERVAL;
    if (fix.valid.speed && (fix.speed_kph() > SPEED_LIMIT)) {
      digitalWrite(  LED_PIN, HIGH );
    } else {
      digitalWrite( LED_PIN, LOW );
    }
    if (fix.valid.location) {
      if (lastLocOK) {
        odo += fix.location.DistanceKm(  lastLoc );
        Speed = fix.speed_kph();
      }
      lastLoc   = fix.location;
      lastLocOK = true;
      if (stScan) {
        stScan = false;
        base   = fix.location;
      } else {
        Dist = ( fix.location.DistanceKm(  base ) );
      }
    }
    if ( Speed > maxs)          maxs = Speed;
    if (fix.valid.heading )     head = fix.heading() ;
    if (fix.valid.satellites  )  Sat = fix.satellites ;
    if (fix.valid.altitude)     alt = fix.altitude();
    if ( alt > Am)              Am = alt;
         if (show == 0) {
        char  displayBufffer[MAX_CHARS];
        oled.setCursor(0, 0);
        snprintf(displayBufffer,  MAX_CHARS, "Km:%2d.%1d",  (int)odo, (int)(odo * 100) % 100);
        oled.println(displayBufffer);
        oled.setCursor(65, 0);
        snprintf(displayBufffer, MAX_CHARS, "Di:%2d.%1d",  (int)Dist, (int)(Dist * 100) % 100);
        oled.println(displayBufffer);
        snprintf(displayBufffer, MAX_CHARS, "Sp:%2d.%1d", (int)Speed, (int)(Speed  * 10) % 10);
        oled.println(displayBufffer);
        oled.setCursor(65,  2);
        snprintf(displayBufffer, MAX_CHARS, "Sm:%2d.%1d", (int)maxs, (int)(maxs  * 10) % 10);
        oled.println(displayBufffer);
        snprintf(displayBufffer,  MAX_CHARS, "Al:%2d.%1d", (int)alt, (int)(alt * 100) % 100);
        oled.println(displayBufffer);
        oled.setCursor(65, 4);
        snprintf(displayBufffer, MAX_CHARS, "Am:%2d.%1d",  (int)Am, (int)(Am * 100) % 100);
        oled.println(displayBufffer);
        snprintf(displayBufffer,  MAX_CHARS, "Sa: %d", (int)Sat);
        oled.println(displayBufffer);
        oled.setCursor(65,  6);
        snprintf(displayBufffer, MAX_CHARS, "He:%2d.%1d", (int)head, (int)(head  * 100) % 100);
        oled.println(displayBufffer);
      }
    File data  = SD.open("L.csv", FILE_WRITE);
    data.print(fix.dateTime.hours + 2);
    data.print(":");
    data.print(fix.dateTime.minutes);
    data.print("  ");
    data.print(fix.dateTime.date);
    data.print("/");
    data.print(fix.dateTime.month);
    data.print("  ");
    data.print(fix.latitude(), 6);
    data.print("  ");
    data.print(fix.longitude(), 6);
    data.print("  ");
    data.print(alt);
    data.print("  ");
    data.print(Am);
    data.print("  ");
    data.print(odo);
    data.print("  ");
    data.print(Dist);
    data.print("  ");
    data.print(Speed);
    data.print("  ");
    data.print(head);
    data.print("  ");
    data.print(Sat);
    data.println();
    data.close();
  }
}

10/2021 update compass 16 sectors

arduino

a new code version for oled 1.3'' sh1106 with travel time and compass 16 sectors

1#include <SPI.h>
2#include <SD.h>
3#include <Wire.h>
4#include "SSD1306Ascii.h"
5#include
6  "SSD1306AsciiWire.h"
7#include <NMEAGPS.h>
8#include <NeoSWSerial.h>
9
10#define
11  I2C_ADDRESS 0x3C
12#define RST_PIN -1
13#define MAX_CHARS 24
14#define RX_pin
15  5
16#define TX_pin 4
17#define SHOW_INTERVAL 1
18#define GPS_baud 9600
19SSD1306AsciiWire
20  oled;
21NMEAGPS gps;
22gps_fix fix;
23float odo, Dist;
24unsigned int head,
25  Speed, alt, Sat = 0, maxs = 0;
26
27NeoGPS::Location_t    lastLoc, base;
28bool
29  stScan = true, lastLocOK = false;
30bool altOK = false;
31bool Satok = false;
32static
33  NeoSWSerial gpsPort(RX_pin, TX_pin);
34static constexpr int INITIAL_SHOW  = (2
35  * SHOW_INTERVAL) - 1;
36int show          = INITIAL_SHOW;
37const int   LED_PIN
38  = 3;
39const float SPEED_LIMIT = 0.1; // speed limit value
40
41void disp(int
42  c, int r) {
43  oled.clear();
44  oled.setCursor(c, r);
45}
46
47const char*
48  strBussola[16] = {"N  ", "NNe", "NE ", "EnE", "E  ", "EsE",
49                              "SE
50  ", "SSe", "S  ", "SSw", "SW ", "WsW", "W  ", "WnW", "NW ", "NNw"
51
52                             };
53int index;
54
55int trovaIndice(float angolo)
56  {
57  int _index;
58  for (_index = 0; _index < 16; _index++) {
59    float angoloDirezione
60  = _index * 22.25 + 11.25;
61    float angoloMin = angoloDirezione - 11.25;
62
63    float angoloMax = angoloDirezione + 11.25;
64    if (angolo >= angoloMin &&
65  angolo <= angoloMax)
66      return _index;
67  }
68  return _index;
69}
70
71void
72  setup() {
73  pinMode (LED_PIN, OUTPUT);
74  Serial.begin(9600);
75  gpsPort.begin(GPS_baud);
76
77  Wire.begin();
78  oled.begin(&SH1106_128x64, I2C_ADDRESS);
79  oled.setFont(ZevvPeep8x16);
80
81  //oled.displayRemap(true); // inversione dello schermo display
82  disp(0, 2);
83
84  oled.println(F(" YOUR  NAME "));// put your name here
85  delay(1500);
86
87  oled.setCursor(24, 5);
88  oled.println(F("GPS LOGGER"));
89  delay(2500);
90
91  oled.clear();
92  const int cs_sd = 2;
93  if (!SD.begin (cs_sd)) {
94    oled.clear();
95
96    disp(50, 2);
97    oled.print(F("SD"));
98    delay(10000);
99    oled.clear();
100
101  }
102  File data = SD.open("L.csv", FILE_WRITE);
103  data.println("");
104
105  data.println(F("D H T La Lo At Km Di Ve He Co Sa" ));
106  data.close();
107}
108
109void
110  loop() {
111  unsigned long tmp = millis() / 1000;
112  byte secondi = tmp % 60;
113
114  byte minuti = (tmp / 60) % 60;
115  byte ore = (tmp / 3600) % 24;
116
117  if
118  (gps.available( gpsPort )) {
119    gps_fix fix = gps.read();
120    show = (show
121  + 1) % SHOW_INTERVAL;
122    if (fix.valid.speed && (fix.speed_kph() > SPEED_LIMIT))
123  {
124      digitalWrite( LED_PIN, HIGH );
125    } else {
126      digitalWrite(
127  LED_PIN, LOW );
128    }
129    if (fix.valid.location) {
130      if (lastLocOK)
131  {
132        odo += fix.location.DistanceKm( lastLoc );
133        Speed = fix.speed_kph();
134
135      }
136      lastLoc   = fix.location;
137      lastLocOK = true;
138      if
139  (stScan) {
140        stScan = false;
141        base   = fix.location;
142      }
143  else {
144        Dist = ( fix.location.DistanceKm( base ) );
145      }
146    }
147
148    if ( Speed > maxs)          maxs = Speed;
149    if (fix.valid.satellites )
150  {
151      Sat = fix.satellites ;
152      Satok = true;
153    }
154
155
156    if
157  (fix.valid.heading ) {
158      head = fix.heading() ;
159      index = trovaIndice(head);
160
161    }
162
163    if (fix.valid.altitude){ 
164      alt = fix.altitude();
165     altOK
166  = true;
167    }
168
169    if (show == 0) {
170      char displayBufffer[MAX_CHARS];
171
172      oled.setCursor(0, 0);
173      snprintf(displayBufffer, MAX_CHARS, "Km: %d.%d",
174  (int)odo, (int)(odo * 100) % 100);
175      oled.println(displayBufffer);
176
177      oled.setCursor(65, 0);
178      snprintf(displayBufffer, MAX_CHARS, "Ve:
179  %d", (int)Speed, (int)(Speed * 100) % 100);
180      oled.println(displayBufffer);
181
182      snprintf(displayBufffer, MAX_CHARS, "Di: %d.%d",  (int)Dist, (int)(Dist
183  * 100) % 100);
184      
185      oled.println(displayBufffer);
186     oled.setCursor(65,
187  2);
188     snprintf(displayBufffer, MAX_CHARS, "Vm: %d", (int)maxs, (int)(maxs
189  * 100) % 100);
190      
191      oled.println(displayBufffer);
192
193      snprintf(displayBufffer,
194  MAX_CHARS, "Al: %d", (int)alt, (int)(alt * 100) % 100);
195      oled.println(displayBufffer);
196
197      oled.setCursor(65, 4);
198      snprintf(displayBufffer, MAX_CHARS, "He:
199  %d", (int)head, (int)(head * 100) % 100);
200      oled.println(displayBufffer);
201
202      snprintf(displayBufffer, MAX_CHARS, "%d:%d:%d ", (int)ore, (int)minuti,
203  (int)secondi);
204      oled.println(displayBufffer);
205      oled.setCursor(65,
206  6);
207      snprintf(displayBufffer, MAX_CHARS, "Co: %s\
208", (strBussola[index]));
209
210      
211      oled.println(displayBufffer);
212    }
213    File data = SD.open("L.csv",
214  FILE_WRITE);
215    data.print(fix.dateTime.hours + 2);
216    data.print(":");
217
218    data.print(fix.dateTime.minutes);
219    data.print(" ");
220    data.print(fix.dateTime.date);
221
222    data.print("/");
223    data.print(fix.dateTime.month);
224    data.print("
225  ");
226    data.print(ore);
227    data.print(":");
228    data.print(minuti);
229
230    data.print(":");
231    data.print(secondi);
232    data.print(" ");
233
234    data.print(fix.latitude(), 6);
235    data.print(" ");
236    data.print(fix.longitude(),
237  6);
238    data.print(" ");
239    data.print(alt);
240    data.print(" ");
241
242
243    data.print(odo);
244    data.print(" ");
245    data.print(Dist);
246    data.print("
247  ");
248    data.print(Speed);
249    data.print(" ");
250    data.print(head);
251
252    data.print(" ");
253    data.print(strBussola[index]);
254    data.print("
255  ");
256    data.print(Sat);
257    data.println();
258    data.close();
259  }
260}

#include <SPI.h>
#include <SD.h>
#include <Wire.h>
#include "SSD1306Ascii.h"
#include
  "SSD1306AsciiWire.h"
#include <NMEAGPS.h>
#include <NeoSWSerial.h>

#define
  I2C_ADDRESS 0x3C
#define RST_PIN -1
#define MAX_CHARS 24
#define RX_pin
  5
#define TX_pin 4
#define SHOW_INTERVAL 1
#define GPS_baud 9600
SSD1306AsciiWire
  oled;
NMEAGPS gps;
gps_fix fix;
float odo, Dist;
unsigned int head,
  Speed, alt, Sat = 0, maxs = 0;

NeoGPS::Location_t    lastLoc, base;
bool
  stScan = true, lastLocOK = false;
bool altOK = false;
bool Satok = false;
static
  NeoSWSerial gpsPort(RX_pin, TX_pin);
static constexpr int INITIAL_SHOW  = (2
  * SHOW_INTERVAL) - 1;
int show          = INITIAL_SHOW;
const int   LED_PIN
  = 3;
const float SPEED_LIMIT = 0.1; // speed limit value

void disp(int
  c, int r) {
  oled.clear();
  oled.setCursor(c, r);
}

const char*
  strBussola[16] = {"N  ", "NNe", "NE ", "EnE", "E  ", "EsE",
                              "SE
  ", "SSe", "S  ", "SSw", "SW ", "WsW", "W  ", "WnW", "NW ", "NNw"

                             };
int index;

int trovaIndice(float angolo)
  {
  int _index;
  for (_index = 0; _index < 16; _index++) {
    float angoloDirezione
  = _index * 22.25 + 11.25;
    float angoloMin = angoloDirezione - 11.25;

    float angoloMax = angoloDirezione + 11.25;
    if (angolo >= angoloMin &&
  angolo <= angoloMax)
      return _index;
  }
  return _index;
}

void
  setup() {
  pinMode (LED_PIN, OUTPUT);
  Serial.begin(9600);
  gpsPort.begin(GPS_baud);

  Wire.begin();
  oled.begin(&SH1106_128x64, I2C_ADDRESS);
  oled.setFont(ZevvPeep8x16);

  //oled.displayRemap(true); // inversione dello schermo display
  disp(0, 2);

  oled.println(F(" YOUR  NAME "));// put your name here
  delay(1500);

  oled.setCursor(24, 5);
  oled.println(F("GPS LOGGER"));
  delay(2500);

  oled.clear();
  const int cs_sd = 2;
  if (!SD.begin (cs_sd)) {
    oled.clear();

    disp(50, 2);
    oled.print(F("SD"));
    delay(10000);
    oled.clear();

  }
  File data = SD.open("L.csv", FILE_WRITE);
  data.println("");

  data.println(F("D H T La Lo At Km Di Ve He Co Sa" ));
  data.close();
}

void
  loop() {
  unsigned long tmp = millis() / 1000;
  byte secondi = tmp % 60;

  byte minuti = (tmp / 60) % 60;
  byte ore = (tmp / 3600) % 24;

  if
  (gps.available( gpsPort )) {
    gps_fix fix = gps.read();
    show = (show
  + 1) % SHOW_INTERVAL;
    if (fix.valid.speed && (fix.speed_kph() > SPEED_LIMIT))
  {
      digitalWrite( LED_PIN, HIGH );
    } else {
      digitalWrite(
  LED_PIN, LOW );
    }
    if (fix.valid.location) {
      if (lastLocOK)
  {
        odo += fix.location.DistanceKm( lastLoc );
        Speed = fix.speed_kph();

      }
      lastLoc   = fix.location;
      lastLocOK = true;
      if
  (stScan) {
        stScan = false;
        base   = fix.location;
      }
  else {
        Dist = ( fix.location.DistanceKm( base ) );
      }
    }

    if ( Speed > maxs)          maxs = Speed;
    if (fix.valid.satellites )
  {
      Sat = fix.satellites ;
      Satok = true;
    }


    if
  (fix.valid.heading ) {
      head = fix.heading() ;
      index = trovaIndice(head);

    }

    if (fix.valid.altitude){ 
      alt = fix.altitude();
     altOK
  = true;
    }

    if (show == 0) {
      char displayBufffer[MAX_CHARS];

      oled.setCursor(0, 0);
      snprintf(displayBufffer, MAX_CHARS, "Km: %d.%d",
  (int)odo, (int)(odo * 100) % 100);
      oled.println(displayBufffer);

      oled.setCursor(65, 0);
      snprintf(displayBufffer, MAX_CHARS, "Ve:
  %d", (int)Speed, (int)(Speed * 100) % 100);
      oled.println(displayBufffer);

      snprintf(displayBufffer, MAX_CHARS, "Di: %d.%d",  (int)Dist, (int)(Dist
  * 100) % 100);
      
      oled.println(displayBufffer);
     oled.setCursor(65,
  2);
     snprintf(displayBufffer, MAX_CHARS, "Vm: %d", (int)maxs, (int)(maxs
  * 100) % 100);
      
      oled.println(displayBufffer);

      snprintf(displayBufffer,
  MAX_CHARS, "Al: %d", (int)alt, (int)(alt * 100) % 100);
      oled.println(displayBufffer);

      oled.setCursor(65, 4);
      snprintf(displayBufffer, MAX_CHARS, "He:
  %d", (int)head, (int)(head * 100) % 100);
      oled.println(displayBufffer);

      snprintf(displayBufffer, MAX_CHARS, "%d:%d:%d ", (int)ore, (int)minuti,
  (int)secondi);
      oled.println(displayBufffer);
      oled.setCursor(65,
  6);
      snprintf(displayBufffer, MAX_CHARS, "Co: %s\
", (strBussola[index]));

      
      oled.println(displayBufffer);
    }
    File data = SD.open("L.csv",
  FILE_WRITE);
    data.print(fix.dateTime.hours + 2);
    data.print(":");

    data.print(fix.dateTime.minutes);
    data.print(" ");
    data.print(fix.dateTime.date);

    data.print("/");
    data.print(fix.dateTime.month);
    data.print("
  ");
    data.print(ore);
    data.print(":");
    data.print(minuti);

    data.print(":");
    data.print(secondi);
    data.print(" ");

    data.print(fix.latitude(), 6);
    data.print(" ");
    data.print(fix.longitude(),
  6);
    data.print(" ");
    data.print(alt);
    data.print(" ");


    data.print(odo);
    data.print(" ");
    data.print(Dist);
    data.print("
  ");
    data.print(Speed);
    data.print(" ");
    data.print(head);

    data.print(" ");
    data.print(strBussola[index]);
    data.print("
  ");
    data.print(Sat);
    data.println();
    data.close();
  }
}

display 1306 0,96''

arduino

use this with 0,96'' 4 pin oled 128x64 display

1#include <SPI.h>
2#include <SD.h>
3#include <Wire.h>
4
5#include  "SSD1306Ascii.h"
6#include "SSD1306AsciiWire.h"
7#include <NMEAGPS.h>
8
9#include  <NeoSWSerial.h>
10const int cs_sd=2;
11#define I2C_ADDRESS 0x3C
12#define RST_PIN  -1
13SSD1306AsciiWire oled;
14NMEAGPS gps;
15gps_fix fix;
16File myFile;
17float  odo;
18float Speed; 
19float alt;
20
21NeoGPS::Location_t    lastLoc;
22bool                  lastLocOK = false;
23static const int RXPin = 5, TXPin = 4; //--  gps pin
24static const uint32_t GPSBaud = 9600;
25NeoSWSerial gpsPort(RXPin, TXPin);
26const  int SHOW_INTERVAL = 1;
27const int INITIAL_SHOW  = (2 * SHOW_INTERVAL) - 1; 
28int  show          = INITIAL_SHOW;
29const int   LED_PIN  = 3;  //-- led on at speed  limit
30const float SPEED_LIMIT = 0.0; // --setup speed limit value es: 55.0; kmh  default 0.0
31int maxs = 0; 
32void setup(){
33  
34  pinMode (LED_PIN, OUTPUT);
35Serial.begin(9600);
36gpsPort.begin(GPSBaud);
37Wire.begin();
38oled.begin(&  Adafruit128x64, I2C_ADDRESS);
39oled.setFont(TimesNewRoman16);
40oled.clear();
41oled.println("  ");
42oled.println("  GPS LOGGER"); //you can custom this text
43oled.println("  ");
44oled.println("   WELCOME"); //you can custom this text
45delay(3000);
46oled.clear();
47if(!SD.begin(cs_sd)){
48oled.clear();
49oled.println("  ");
50oled.print("NO SD");
51delay(3000);
52return;}
53oled.println(" ");
54oled.print("  SD Card OK");
55delay(2000);
56oled.clear();
57File data = SD.open("log.csv",FILE_WRITE);              
58data.println(""); 
59data.println("Dat  Hr+  Lat  Lon  Alt  Vel  Dis" ); 
60data.close();}
61void loop(){
62if (gps.available( gpsPort  )) {  
63gps_fix fix = gps.read();  
64show = (show + 1) % SHOW_INTERVAL;
65if  (fix.valid.speed && (fix.speed_kph() > SPEED_LIMIT)) {
66    digitalWrite( LED_PIN,  HIGH );   
67 } else {
68 digitalWrite( LED_PIN, LOW ); } 
69 if (fix.valid.location)  { 
70 if (lastLocOK) {
71 odo += fix.location.DistanceKm( lastLoc );
72 Speed  = (fix.speed_kph());}
73lastLoc   = fix.location;
74lastLocOK = true;}
75if (  Speed > maxs) 
76maxs = Speed;
77if (fix.valid.altitude)
78 alt = ( fix.altitude  () );
79 
80if (show == 0) {
81#define MAX_CHARS 24
82char displayBufffer[MAX_CHARS];
83oled.setCursor(0,0);   
84snprintf(displayBufffer, MAX_CHARS, " DIST :  %  3d.%02d", (int)odo, (int)(odo  * 100)%100);//distance
85oled.println(displayBufffer);   
86snprintf(displayBufffer,  MAX_CHARS, " KMH:  %  3d.%02d", (int)Speed, (int)(Speed * 100)%100);//speed
87oled.println(displayBufffer);
88snprintf(displayBufffer,  MAX_CHARS, " MxSP: %  3d.%02d", (int)maxs, (int)(maxs * 100)%100);//max top speed
89oled.println(displayBufffer);
90snprintf(displayBufffer,  MAX_CHARS, " ALT  :  %  3d.%02d", (int)alt, (int)(alt * 100)%100);//altitude
91oled.println(displayBufffer);}  
92if (fix.dateTime);   
93String Temps=String(fix.dateTime.hours )+(":")+(fix.dateTime.minutes)+(":")+(fix.dateTime.seconds);
94String  Date=String(fix.dateTime.date )+("/")+(fix.dateTime.month)+("/")+(fix.dateTime.year);  
95File data=SD.open("log.csv",FILE_WRITE);
96data.println(Date +("  ")+  Temps +("  ")+ String(fix.latitude(), 6)+("  ")+String(fix.longitude(), 6)+("  ")+(alt)+("  ") +(Speed)+("  ")+(odo)); 
97data.close();}}
98

#include <SPI.h>
#include <SD.h>
#include <Wire.h>

#include  "SSD1306Ascii.h"
#include "SSD1306AsciiWire.h"
#include <NMEAGPS.h>

#include  <NeoSWSerial.h>
const int cs_sd=2;
#define I2C_ADDRESS 0x3C
#define RST_PIN  -1
SSD1306AsciiWire oled;
NMEAGPS gps;
gps_fix fix;
File myFile;
float  odo;
float Speed; 
float alt;

NeoGPS::Location_t    lastLoc;
bool                  lastLocOK = false;
static const int RXPin = 5, TXPin = 4; //--  gps pin
static const uint32_t GPSBaud = 9600;
NeoSWSerial gpsPort(RXPin, TXPin);
const  int SHOW_INTERVAL = 1;
const int INITIAL_SHOW  = (2 * SHOW_INTERVAL) - 1; 
int  show          = INITIAL_SHOW;
const int   LED_PIN  = 3;  //-- led on at speed  limit
const float SPEED_LIMIT = 0.0; // --setup speed limit value es: 55.0; kmh  default 0.0
int maxs = 0; 
void setup(){
  
  pinMode (LED_PIN, OUTPUT);
Serial.begin(9600);
gpsPort.begin(GPSBaud);
Wire.begin();
oled.begin(&  Adafruit128x64, I2C_ADDRESS);
oled.setFont(TimesNewRoman16);
oled.clear();
oled.println("  ");
oled.println("  GPS LOGGER"); //you can custom this text
oled.println("  ");
oled.println("   WELCOME"); //you can custom this text
delay(3000);
oled.clear();
if(!SD.begin(cs_sd)){
oled.clear();
oled.println("  ");
oled.print("NO SD");
delay(3000);
return;}
oled.println(" ");
oled.print("  SD Card OK");
delay(2000);
oled.clear();
File data = SD.open("log.csv",FILE_WRITE);              
data.println(""); 
data.println("Dat  Hr+  Lat  Lon  Alt  Vel  Dis" ); 
data.close();}
void loop(){
if (gps.available( gpsPort  )) {  
gps_fix fix = gps.read();  
show = (show + 1) % SHOW_INTERVAL;
if  (fix.valid.speed && (fix.speed_kph() > SPEED_LIMIT)) {
    digitalWrite( LED_PIN,  HIGH );   
 } else {
 digitalWrite( LED_PIN, LOW ); } 
 if (fix.valid.location)  { 
 if (lastLocOK) {
 odo += fix.location.DistanceKm( lastLoc );
 Speed  = (fix.speed_kph());}
lastLoc   = fix.location;
lastLocOK = true;}
if (  Speed > maxs) 
maxs = Speed;
if (fix.valid.altitude)
 alt = ( fix.altitude  () );
 
if (show == 0) {
#define MAX_CHARS 24
char displayBufffer[MAX_CHARS];
oled.setCursor(0,0);   
snprintf(displayBufffer, MAX_CHARS, " DIST :  %  3d.%02d", (int)odo, (int)(odo  * 100)%100);//distance
oled.println(displayBufffer);   
snprintf(displayBufffer,  MAX_CHARS, " KMH:  %  3d.%02d", (int)Speed, (int)(Speed * 100)%100);//speed
oled.println(displayBufffer);
snprintf(displayBufffer,  MAX_CHARS, " MxSP: %  3d.%02d", (int)maxs, (int)(maxs * 100)%100);//max top speed
oled.println(displayBufffer);
snprintf(displayBufffer,  MAX_CHARS, " ALT  :  %  3d.%02d", (int)alt, (int)(alt * 100)%100);//altitude
oled.println(displayBufffer);}  
if (fix.dateTime);   
String Temps=String(fix.dateTime.hours )+(":")+(fix.dateTime.minutes)+(":")+(fix.dateTime.seconds);
String  Date=String(fix.dateTime.date )+("/")+(fix.dateTime.month)+("/")+(fix.dateTime.year);  
File data=SD.open("log.csv",FILE_WRITE);
data.println(Date +("  ")+  Temps +("  ")+ String(fix.latitude(), 6)+("  ")+String(fix.longitude(), 6)+("  ")+(alt)+("  ") +(Speed)+("  ")+(odo)); 
data.close();}}

display sh1106 1,3''

arduino

code for large 1,3'' 4 pin 128x64 display

1#include <SPI.h>
2#include <SD.h>
3#include <Wire.h>
4
5#include  "SSD1306Ascii.h"
6#include "SSD1306AsciiWire.h"
7#include <NMEAGPS.h>
8//#include  <SoftwareSerial.h> //check library or change neoSWSerial.h
9#include <NeoSWSerial.h>
10const  int cs_sd=2;
11#define I2C_ADDRESS 0x3C
12#define RST_PIN -1
13SSD1306AsciiWire  oled;
14NMEAGPS gps;
15gps_fix fix;
16File myFile;
17float odo;
18float Speed;  
19float alt;
20
21NeoGPS::Location_t    lastLoc;
22bool                  lastLocOK  = false;
23static const int RXPin = 5, TXPin = 4; //-- gps pin
24static const  uint32_t GPSBaud = 9600;
25NeoSWSerial gpsPort(RXPin, TXPin);
26const int SHOW_INTERVAL  = 1;
27const int INITIAL_SHOW  = (2 * SHOW_INTERVAL) - 1; 
28int show          =  INITIAL_SHOW;
29const int   LED_PIN  = 3;
30const float SPEED_LIMIT = 0.0; //  --setup speed limit value es: 55.0; kmh default 0.0
31int maxs = 0; 
32void setup(){
33  
34  pinMode (LED_PIN, OUTPUT);
35Serial.begin(9600);
36gpsPort.begin(GPSBaud);
37Wire.begin();
38oled.begin(&SH1106_128x64,  I2C_ADDRESS);
39oled.setFont(ZevvPeep8x16);
40oled.clear();
41oled.println("  ");
42oled.println("  GPS LOGGER"); 
43oled.println(" ");
44oled.println("   WELCOME"); 
45delay(3000);
46oled.clear();
47if(!SD.begin(cs_sd)){
48oled.clear();
49oled.println("  ");
50oled.print("NO SD");
51delay(3000);
52return;}
53oled.println(" ");
54oled.print("  SD Card OK");
55delay(2000);
56oled.clear();
57File data = SD.open("log.csv",FILE_WRITE);              
58data.println(""); 
59data.println("Dat  Hr+  Lat  Lon  Alt  Vel  Dis" ); 
60data.close();}
61void loop(){
62if (gps.available( gpsPort  )) {  
63gps_fix fix = gps.read();  
64show = (show + 1) % SHOW_INTERVAL;
65if  (fix.valid.speed && (fix.speed_kph() > SPEED_LIMIT)) {
66    digitalWrite( LED_PIN,  HIGH );   
67 } else {
68 digitalWrite( LED_PIN, LOW ); } 
69 if (fix.valid.location)  { 
70 if (lastLocOK) {
71 odo += fix.location.DistanceKm( lastLoc );
72 Speed  = (fix.speed_kph());}
73lastLoc   = fix.location;
74lastLocOK = true;}
75if (  Speed > maxs) 
76maxs = Speed;
77if (fix.valid.altitude)
78 alt = ( fix.altitude  () );
79 
80if (show == 0) {
81#define MAX_CHARS 24
82char displayBufffer[MAX_CHARS];
83oled.setCursor(0,0);   
84snprintf(displayBufffer, MAX_CHARS, " K m :% 3d.%02d", (int)odo, (int)(odo  * 100)%100);
85oled.println(displayBufffer);   
86snprintf(displayBufffer, MAX_CHARS,  " Kmh :% 3d.%02d", (int)Speed, (int)(Speed * 100)%100);
87oled.println(displayBufffer);
88snprintf(displayBufffer,  MAX_CHARS, " Mspd:% 3d.%02d", (int)maxs, (int)(maxs * 100)%100);
89oled.println(displayBufffer);
90snprintf(displayBufffer,  MAX_CHARS, " Alt :% 3d.%02d", (int)alt, (int)(alt * 100)%100);
91oled.println(displayBufffer);}  
92if (fix.dateTime);   
93String Temps=String(fix.dateTime.hours )+(":")+(fix.dateTime.minutes)+(":")+(fix.dateTime.seconds);
94String  Date=String(fix.dateTime.date )+("/")+(fix.dateTime.month)+("/")+(fix.dateTime.year);  
95File data=SD.open("log.csv",FILE_WRITE);
96data.println(Date +("  ")+  Temps +("  ")+ String(fix.latitude(), 6)+("  ")+String(fix.longitude(), 6)+("  ")+(alt)+("  ") +(Speed)+("  ")+(odo)); 
97data.close();}}

#include <SPI.h>
#include <SD.h>
#include <Wire.h>

#include  "SSD1306Ascii.h"
#include "SSD1306AsciiWire.h"
#include <NMEAGPS.h>
//#include  <SoftwareSerial.h> //check library or change neoSWSerial.h
#include <NeoSWSerial.h>
const  int cs_sd=2;
#define I2C_ADDRESS 0x3C
#define RST_PIN -1
SSD1306AsciiWire  oled;
NMEAGPS gps;
gps_fix fix;
File myFile;
float odo;
float Speed;  
float alt;

NeoGPS::Location_t    lastLoc;
bool                  lastLocOK  = false;
static const int RXPin = 5, TXPin = 4; //-- gps pin
static const  uint32_t GPSBaud = 9600;
NeoSWSerial gpsPort(RXPin, TXPin);
const int SHOW_INTERVAL  = 1;
const int INITIAL_SHOW  = (2 * SHOW_INTERVAL) - 1; 
int show          =  INITIAL_SHOW;
const int   LED_PIN  = 3;
const float SPEED_LIMIT = 0.0; //  --setup speed limit value es: 55.0; kmh default 0.0
int maxs = 0; 
void setup(){
  
  pinMode (LED_PIN, OUTPUT);
Serial.begin(9600);
gpsPort.begin(GPSBaud);
Wire.begin();
oled.begin(&SH1106_128x64,  I2C_ADDRESS);
oled.setFont(ZevvPeep8x16);
oled.clear();
oled.println("  ");
oled.println("  GPS LOGGER"); 
oled.println(" ");
oled.println("   WELCOME"); 
delay(3000);
oled.clear();
if(!SD.begin(cs_sd)){
oled.clear();
oled.println("  ");
oled.print("NO SD");
delay(3000);
return;}
oled.println(" ");
oled.print("  SD Card OK");
delay(2000);
oled.clear();
File data = SD.open("log.csv",FILE_WRITE);              
data.println(""); 
data.println("Dat  Hr+  Lat  Lon  Alt  Vel  Dis" ); 
data.close();}
void loop(){
if (gps.available( gpsPort  )) {  
gps_fix fix = gps.read();  
show = (show + 1) % SHOW_INTERVAL;
if  (fix.valid.speed && (fix.speed_kph() > SPEED_LIMIT)) {
    digitalWrite( LED_PIN,  HIGH );   
 } else {
 digitalWrite( LED_PIN, LOW ); } 
 if (fix.valid.location)  { 
 if (lastLocOK) {
 odo += fix.location.DistanceKm( lastLoc );
 Speed  = (fix.speed_kph());}
lastLoc   = fix.location;
lastLocOK = true;}
if (  Speed > maxs) 
maxs = Speed;
if (fix.valid.altitude)
 alt = ( fix.altitude  () );
 
if (show == 0) {
#define MAX_CHARS 24
char displayBufffer[MAX_CHARS];
oled.setCursor(0,0);   
snprintf(displayBufffer, MAX_CHARS, " K m :% 3d.%02d", (int)odo, (int)(odo  * 100)%100);
oled.println(displayBufffer);   
snprintf(displayBufffer, MAX_CHARS,  " Kmh :% 3d.%02d", (int)Speed, (int)(Speed * 100)%100);
oled.println(displayBufffer);
snprintf(displayBufffer,  MAX_CHARS, " Mspd:% 3d.%02d", (int)maxs, (int)(maxs * 100)%100);
oled.println(displayBufffer);
snprintf(displayBufffer,  MAX_CHARS, " Alt :% 3d.%02d", (int)alt, (int)(alt * 100)%100);
oled.println(displayBufffer);}  
if (fix.dateTime);   
String Temps=String(fix.dateTime.hours )+(":")+(fix.dateTime.minutes)+(":")+(fix.dateTime.seconds);
String  Date=String(fix.dateTime.date )+("/")+(fix.dateTime.month)+("/")+(fix.dateTime.year);  
File data=SD.open("log.csv",FILE_WRITE);
data.println(Date +("  ")+  Temps +("  ")+ String(fix.latitude(), 6)+("  ")+String(fix.longitude(), 6)+("  ")+(alt)+("  ") +(Speed)+("  ")+(odo)); 
data.close();}}

Downloadable files

gps_mgebcsszu1_5rDBAfZKUE.fzz

schematics

basically the same circuit but maybe can help

schematics

connect wires by colors

schematics

connect wires by colors

schematics

gps_mgebcsszu1_5rDBAfZKUE.fzz

Comments

Only logged in users can leave comments

wrighi

0 Followers

•

0 Projects

Intro