About:

In this project we will learn how to interface GPS module with esp8266 as main controller to show GPS data on OLED display. We will read and display various elements from GPS like Speed, Clock, Date, Location, Altitude, Trip distance, Number of connected satellites, Cardinals (moving direction), etc. We can use this project in cars or other moving vehicles.

In next update I am planning to build a web-server using esp8266 to receive data from GPS in smart phones and generate geographical location on online 2D maps using longitude and latitude.

Components:

• ESP8266 NodeMCU board
• Ublox neo-6m GPS module
• OLED i2c display 128x64px
• Momentary push buttons – 2Nos
• Software : Arduino IDE

Circuit Diagram:

Code:

/*
 * Project: Mini GPS Display using Ublox neo-6m and ESP8266
 * Author: Pranay SS, eTechPath
 * Website: www.etechpath.com
 * Tutorial Link: 
   
Mini GPS Display using Ublox neo-6m module and ESP8266 nodemcu

 * Video Link: https://youtu.be/ExPBmiz1cj0
 * 
 */
 
 
 
 #include <Arduino.h>
#include <U8g2lib.h>
#ifdef U8X8_HAVE_HW_SPI
#include <SPI.h>
#endif
#ifdef U8X8_HAVE_HW_I2C
#include <Wire.h>
#endif
#define menu D3
#define enter D4
int key = 0;
double Home_LAT = 0;
double Home_LNG = 0;


//sat20x20px logo
U8G2_SSD1306_128X64_NONAME_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);
static const unsigned char u8g_logo_sat[] U8X8_PROGMEM = {
  0x00, 0x01, 0x00, 0x80, 0x07, 0x00, 0xc0, 0x06, 0x00, 0x60, 0x30, 0x00,
  0x60, 0x78, 0x00, 0xc0, 0xfc, 0x00, 0x00, 0xfe, 0x01, 0x00, 0xff, 0x01,
  0x80, 0xff, 0x00, 0xc0, 0x7f, 0x06, 0xc0, 0x3f, 0x06, 0x80, 0x1f, 0x0c,
  0x80, 0x4f, 0x06, 0x19, 0xc6, 0x03, 0x1b, 0x80, 0x01, 0x73, 0x00, 0x00,
  0x66, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x3c, 0x00, 0x00, 0x70, 0x00, 0x00
};
//wave10px logo
static const unsigned char u8g2_logo_wave[] U8X8_PROGMEM ={
  0xE0, 0x03, 0x18, 0x00, 0xC4, 0x01, 0x32, 0x00, 0x8A, 0x01, 0x69, 0x00, 
  0x25, 0x00, 0x95, 0x01, 0x95, 0x01, 0x01, 0x00, };
//sat40x35px logo



// The serial connection to the GPS device
#include <SoftwareSerial.h>
static const int RXPin = D5, TXPin = D6;
static const uint32_t GPSBaud = 9600;
SoftwareSerial ss(RXPin, TXPin);

//GPS Library
#include <TinyGPS++.h>
TinyGPSPlus gps;

//Program variables
double Lat;
double Long;
double Alt;
int day, month, year;
//int hour, minute, second;

int num_sat, gps_speed;
String heading;


//SETUP
void setup() {
  pinMode(menu, INPUT_PULLUP);
  pinMode(enter, INPUT_PULLUP);

  ss.begin(GPSBaud);
   u8g2.begin();

//PrintingLoadingPage
    u8g2.firstPage();
  do {
    print_page1();
  } while ( u8g2.nextPage() );
  delay(5000);



  
}//END SETUP


//LOOP
void loop() {

  Get_GPS(); //Get GPS data

  if (digitalRead(menu) == LOW)
     key = (key+1);
             //else if (digitalRead(menu) == LOW)
             //key = (key-1);
  if (key<0 or key>3)
     key = 0;


   switch (key)

{ 
  case 0:
      u8g2.firstPage();
  do {
     print_Clock();
  } while ( u8g2.nextPage() );
  delay(10);
  break;
  case 1:
   u8g2.firstPage();
  do {
   print_speed();
  } while ( u8g2.nextPage() );
  delay(10);
  break;
  case 2:
  u8g2.firstPage();
  do {
    print_location();
  } while ( u8g2.nextPage() );
  delay(10);

  break;
 case 3:
     u8g2.firstPage();
  do {
    print_Trip();
    if (digitalRead(enter) == LOW)
    { Home_LAT = gps.location.lat();
    Home_LNG = gps.location.lng(); }
    else 
    { u8g2.setFont(u8g2_font_courR08_tr);
      u8g2.setCursor(0, 64);
      u8g2.print("Press Enter to reset");
    }   
   
  } while ( u8g2.nextPage() );
  delay(10);

  break;

 }

   
} //end of loop


void print_page1() {
  u8g2.drawXBMP(0, 0, 20, 20, u8g_logo_sat);
  u8g2.setFont( u8g2_font_crox1cb_tf);
  //u8g2.setFont(u8g2_font_helvB12_tf);
  //u8g2.setFont(u8g2_font_timB12_tf);
  u8g2.setCursor(45, 20);
  u8g2.print("MINI GPS");
  //u8g2.setFont(u8g2_font_7x13B_tf);
  u8g2.setFont(u8g2_font_nine_by_five_nbp_tf);
  u8g2.setCursor(55, 35);
  u8g2.print("by  eTechPath");
  u8g2.setFont(u8g2_font_nine_by_five_nbp_tf);
  u8g2.setCursor(0, 60);
  u8g2.print("Loading");
  u8g2.setFont(u8g2_font_glasstown_nbp_tf);
  u8g2.setCursor(40, 60);
  u8g2.print(" . . . . . ");  
   
}  


void print_Clock()
  {
    u8g2.setFont(u8g2_font_courB08_tn);
    u8g2.setCursor(105, 64);
    u8g2.print( num_sat, 5);
    u8g2.drawXBMP(118, 54, 10, 10, u8g2_logo_wave);
    
    
    u8g2.setFont(u8g2_font_crox1cb_tf);
    u8g2.setCursor(20, 10);
    u8g2.print("GPS CLOCK");
    u8g2.drawLine(0,12,128,12);
    u8g2.setFont(u8g2_font_t0_22b_tn);
    u8g2.setCursor(20, 42);
    printTime(gps.time);
    // u8g.print(gps.date);
    //Get_Date();
    u8g2.setFont(u8g2_font_nine_by_five_nbp_tf);
    u8g2.setCursor(0, 64);
    printDate(gps.date);
  
  }
  
void print_speed() {

  
 u8g2.setFont(u8g2_font_crox1cb_tf);
    u8g2.setCursor(16, 10);
    u8g2.print("Speedometer");
    u8g2.drawLine(0,15,128,15);
    
  u8g2.setFont(u8g2_font_t0_22b_tn);
  u8g2.setCursor(5, 42);
  u8g2.print(gps_speed , DEC);
  u8g2.setFont(u8g2_font_glasstown_nbp_tf);
  u8g2.setCursor(62, 42);
  u8g2.print("km/h");


  u8g2.setFont(u8g2_font_courB08_tn);
  u8g2.setCursor(105, 64);
  u8g2.print( num_sat, 5);
  u8g2.drawXBMP(118, 54, 10, 10, u8g2_logo_wave);

  u8g2.setFont(u8g2_font_glasstown_nbp_tf);
  u8g2.setCursor(0,64);
  u8g2.print("Direction:");
  u8g2.setCursor(45,64);
  u8g2.print( heading);
}

void print_location()
{
  u8g2.setFont(u8g2_font_crox1cb_tf);
  u8g2.setCursor(10, 10);
  u8g2.print("GPS Location");
  u8g2.drawLine(0,12,128,12);

  u8g2.setFont(u8g2_font_nine_by_five_nbp_tf);
  u8g2.setCursor(5, 28);
  u8g2.print("Long: ");
  u8g2.setCursor(40, 28);
  u8g2.print( Long, 6);

  u8g2.setCursor(5, 43);
  u8g2.print("Lat: ");
  u8g2.setCursor(40, 43);
  u8g2.print( Lat, 6);

  u8g2.setCursor(0, 64);
  u8g2.print("Alt: ");
  u8g2.setCursor(20, 64);
  u8g2.print( Alt, 3);

  u8g2.setFont(u8g2_font_courB08_tn);
  u8g2.setCursor(105, 64);
  u8g2.print( num_sat, 5);
  u8g2.drawXBMP(118, 54, 10, 10, u8g2_logo_wave);
  
  }

// This custom version of delay() ensures that the gps object
// is being "fed".
static void smartDelay(unsigned long ms)
{
  unsigned long start = millis();
  do
  {
    while (ss.available())
      gps.encode(ss.read());
  } while (millis() - start < ms);
}


void Get_GPS()
{


  num_sat = gps.satellites.value();

  if (gps.location.isValid() == 1) {

    Lat = gps.location.lat();
    Long = gps.location.lng();
    Alt = gps.altitude.meters();
    
    gps_speed = gps.speed.kmph();

    heading = gps.cardinal(gps.course.value());
  }



 /*   if (gps.date.isValid())
    {
      day = gps.date.day();
      month = gps.date.month();
      year = gps.date.year();
    }

  if (gps.time.isValid())
    {

      hour = gps.time.hour();
      minute = gps.time.minute();
      second = gps.time.second();
    }
*/

  smartDelay(1000);


  if (millis() > 5000 && gps.charsProcessed() < 10)
  {
    // Serial.println(F("No GPS detected: check wiring."));

  }



}

static void printDate(TinyGPSDate &d)
{
  if (!d.isValid())
  {
    u8g2.print(F("******** "));
  }
  else
  {
    char sz[32];
    sprintf(sz, "%02d/%02d/%02d ", d.month(), d.day(), d.year());
    u8g2.print(sz);
  }
}
static void printTime(TinyGPSTime &t)
{  
  if (!t.isValid())
  {
    u8g2.print(F("******** "));
  }
  else
  {
    char sz[32];
    sprintf(sz, "%02d:%02d:%02d ", t.hour(), t.minute(), t.second());
    u8g2.print(sz);
  }

 // printInt(d.age(), d.isValid(), 5);
  smartDelay(0);
}

void print_Trip()
{
unsigned long distanceKm =
  (unsigned long)TinyGPSPlus::distanceBetween(
    gps.location.lat(),
    gps.location.lng(),
    Home_LAT,
    Home_LNG ) / 1000.0;
      u8g2.setFont(u8g2_font_nine_by_five_nbp_tf);
      u8g2.setCursor(0, 20);
      u8g2.print("Trip: ");
      u8g2.setCursor(50, 20);
      u8g2.print(distanceKm);
      u8g2.setCursor(90, 20);
      u8g2.print("Km");
      
double courseTo =
  TinyGPSPlus::courseTo(
    gps.location.lat(),
    gps.location.lng(),
    Home_LAT,
    Home_LNG );
      
      u8g2.setCursor(0, 30);
      u8g2.print("Course: ");
      u8g2.setCursor(60, 30);
      u8g2.print(courseTo);
      u8g2.setCursor(90, 30);
      u8g2.print("Km");

String cardinalTo = TinyGPSPlus::cardinal(courseTo);
      u8g2.setCursor(0, 40);
      u8g2.print("Cardinal: ");
      u8g2.setCursor(60, 40);
      u8g2.print(cardinalTo);

}

Prototype:

GPS Display Screens:

Working Video:

Downloads:

• Arduino IDE
• TinyGPS++ Library (tinygps2)
• OLED library u8glib2
• SoftwareSerial Library

This project is about moving LED matrix display. In this project we will use MAX7219 8×8 LED module for display, Arduino UNO for brain and Bluetooth serial  module for communication. You will need an Android phone for controlling this display.




Things you will need: 

1. Arduino UNO.
2. MAX7219 LED modules – 3Nos.   (You can add many of these for increasing length of display)
3. HC-05 Serial Bluetooth Module.      (You can use any other similar serial Bluetooth module instead )
4. Android Phone.

Circuit Diagram:

Code :

    /*
          8x8 LED Matrix MAX7219 Scrolling Text
              Android Control via Bluetooth
    */
    #include <MaxMatrix.h>
    #include <SoftwareSerial.h>
    #include <avr/pgmspace.h>
    PROGMEM const unsigned char CH[] = {
      3, 8, B00000000, B00000000, B00000000, B00000000, B00000000, // space
      1, 8, B01011111, B00000000, B00000000, B00000000, B00000000, // !
      3, 8, B00000011, B00000000, B00000011, B00000000, B00000000, // "
      5, 8, B00010100, B00111110, B00010100, B00111110, B00010100, // #
      4, 8, B00100100, B01101010, B00101011, B00010010, B00000000, // $
      5, 8, B01100011, B00010011, B00001000, B01100100, B01100011, // %
      5, 8, B00110110, B01001001, B01010110, B00100000, B01010000, // &
      1, 8, B00000011, B00000000, B00000000, B00000000, B00000000, // '
      3, 8, B00011100, B00100010, B01000001, B00000000, B00000000, // (
      3, 8, B01000001, B00100010, B00011100, B00000000, B00000000, // )
      5, 8, B00101000, B00011000, B00001110, B00011000, B00101000, // *
      5, 8, B00001000, B00001000, B00111110, B00001000, B00001000, // +
      2, 8, B10110000, B01110000, B00000000, B00000000, B00000000, // ,
      4, 8, B00001000, B00001000, B00001000, B00001000, B00000000, // -
      2, 8, B01100000, B01100000, B00000000, B00000000, B00000000, // .
      4, 8, B01100000, B00011000, B00000110, B00000001, B00000000, // /
      4, 8, B00111110, B01000001, B01000001, B00111110, B00000000, // 0
      3, 8, B01000010, B01111111, B01000000, B00000000, B00000000, // 1
      4, 8, B01100010, B01010001, B01001001, B01000110, B00000000, // 2
      4, 8, B00100010, B01000001, B01001001, B00110110, B00000000, // 3
      4, 8, B00011000, B00010100, B00010010, B01111111, B00000000, // 4
      4, 8, B00100111, B01000101, B01000101, B00111001, B00000000, // 5
      4, 8, B00111110, B01001001, B01001001, B00110000, B00000000, // 6
      4, 8, B01100001, B00010001, B00001001, B00000111, B00000000, // 7
      4, 8, B00110110, B01001001, B01001001, B00110110, B00000000, // 8
      4, 8, B00000110, B01001001, B01001001, B00111110, B00000000, // 9
      2, 8, B01010000, B00000000, B00000000, B00000000, B00000000, // :
      2, 8, B10000000, B01010000, B00000000, B00000000, B00000000, // ;
      3, 8, B00010000, B00101000, B01000100, B00000000, B00000000, // <
      3, 8, B00010100, B00010100, B00010100, B00000000, B00000000, // =
      3, 8, B01000100, B00101000, B00010000, B00000000, B00000000, // >
      4, 8, B00000010, B01011001, B00001001, B00000110, B00000000, // ?
      5, 8, B00111110, B01001001, B01010101, B01011101, B00001110, // @
      4, 8, B01111110, B00010001, B00010001, B01111110, B00000000, // A
      4, 8, B01111111, B01001001, B01001001, B00110110, B00000000, // B
      4, 8, B00111110, B01000001, B01000001, B00100010, B00000000, // C
      4, 8, B01111111, B01000001, B01000001, B00111110, B00000000, // D
      4, 8, B01111111, B01001001, B01001001, B01000001, B00000000, // E
      4, 8, B01111111, B00001001, B00001001, B00000001, B00000000, // F
      4, 8, B00111110, B01000001, B01001001, B01111010, B00000000, // G
      4, 8, B01111111, B00001000, B00001000, B01111111, B00000000, // H
      3, 8, B01000001, B01111111, B01000001, B00000000, B00000000, // I
      4, 8, B00110000, B01000000, B01000001, B00111111, B00000000, // J
      4, 8, B01111111, B00001000, B00010100, B01100011, B00000000, // K
      4, 8, B01111111, B01000000, B01000000, B01000000, B00000000, // L
      5, 8, B01111111, B00000010, B00001100, B00000010, B01111111, // M
      5, 8, B01111111, B00000100, B00001000, B00010000, B01111111, // N
      4, 8, B00111110, B01000001, B01000001, B00111110, B00000000, // O
      4, 8, B01111111, B00001001, B00001001, B00000110, B00000000, // P
      4, 8, B00111110, B01000001, B01000001, B10111110, B00000000, // Q
      4, 8, B01111111, B00001001, B00001001, B01110110, B00000000, // R
      4, 8, B01000110, B01001001, B01001001, B00110010, B00000000, // S
      5, 8, B00000001, B00000001, B01111111, B00000001, B00000001, // T
      4, 8, B00111111, B01000000, B01000000, B00111111, B00000000, // U
      5, 8, B00001111, B00110000, B01000000, B00110000, B00001111, // V
      5, 8, B00111111, B01000000, B00111000, B01000000, B00111111, // W
      5, 8, B01100011, B00010100, B00001000, B00010100, B01100011, // X
      5, 8, B00000111, B00001000, B01110000, B00001000, B00000111, // Y
      4, 8, B01100001, B01010001, B01001001, B01000111, B00000000, // Z
      2, 8, B01111111, B01000001, B00000000, B00000000, B00000000, // [
      4, 8, B00000001, B00000110, B00011000, B01100000, B00000000, // \ backslash
      2, 8, B01000001, B01111111, B00000000, B00000000, B00000000, // ]
      3, 8, B00000010, B00000001, B00000010, B00000000, B00000000, // hat
      4, 8, B01000000, B01000000, B01000000, B01000000, B00000000, // _
      2, 8, B00000001, B00000010, B00000000, B00000000, B00000000, // `
      4, 8, B00100000, B01010100, B01010100, B01111000, B00000000, // a
      4, 8, B01111111, B01000100, B01000100, B00111000, B00000000, // b
      4, 8, B00111000, B01000100, B01000100, B00101000, B00000000, // c
      4, 8, B00111000, B01000100, B01000100, B01111111, B00000000, // d
      4, 8, B00111000, B01010100, B01010100, B00011000, B00000000, // e
      3, 8, B00000100, B01111110, B00000101, B00000000, B00000000, // f
      4, 8, B10011000, B10100100, B10100100, B01111000, B00000000, // g
      4, 8, B01111111, B00000100, B00000100, B01111000, B00000000, // h
      3, 8, B01000100, B01111101, B01000000, B00000000, B00000000, // i
      4, 8, B01000000, B10000000, B10000100, B01111101, B00000000, // j
      4, 8, B01111111, B00010000, B00101000, B01000100, B00000000, // k
      3, 8, B01000001, B01111111, B01000000, B00000000, B00000000, // l
      5, 8, B01111100, B00000100, B01111100, B00000100, B01111000, // m
      4, 8, B01111100, B00000100, B00000100, B01111000, B00000000, // n
      4, 8, B00111000, B01000100, B01000100, B00111000, B00000000, // o
      4, 8, B11111100, B00100100, B00100100, B00011000, B00000000, // p
      4, 8, B00011000, B00100100, B00100100, B11111100, B00000000, // q
      4, 8, B01111100, B00001000, B00000100, B00000100, B00000000, // r
      4, 8, B01001000, B01010100, B01010100, B00100100, B00000000, // s
      3, 8, B00000100, B00111111, B01000100, B00000000, B00000000, // t
      4, 8, B00111100, B01000000, B01000000, B01111100, B00000000, // u
      5, 8, B00011100, B00100000, B01000000, B00100000, B00011100, // v
      5, 8, B00111100, B01000000, B00111100, B01000000, B00111100, // w
      5, 8, B01000100, B00101000, B00010000, B00101000, B01000100, // x
      4, 8, B10011100, B10100000, B10100000, B01111100, B00000000, // y
      3, 8, B01100100, B01010100, B01001100, B00000000, B00000000, // z
      3, 8, B00001000, B00110110, B01000001, B00000000, B00000000, // {
      1, 8, B01111111, B00000000, B00000000, B00000000, B00000000, // |
      3, 8, B01000001, B00110110, B00001000, B00000000, B00000000, // }
      4, 8, B00001000, B00000100, B00001000, B00000100, B00000000, // ~
    };
    int dIn = 7;   // DIN pin of MAX7219 module
    int clk = 6;   // CLK pin of MAX7219 module
    int cs = 5;    // CS pin of MAX7219 module
    int maxInUse = 2;    // Number of MAX7219's connected
    MaxMatrix m(dIn, cs, clk, maxInUse);
    SoftwareSerial Bluetooth(8, 7); // Bluetooth
    byte buffer[10];
    char incomebyte;
    int scrollSpeed = 100;
    char text[100] = "www.etechpath.com  "; // Initial text message
    int brightness = 15;
    int count = 0;
    char indicator;
    void setup() {
      m.init(); // MAX7219 initialization
      m.setIntensity(brightness); // initial led matrix intensity, 0-15
      Bluetooth.begin(38400); // Default communication rate of the Bluetooth module
    }
    void loop() {
      // Printing the text
      printStringWithShift(text, scrollSpeed);
      
      if (Bluetooth.available()) {   // Checks whether data is comming from the serial port
        indicator = Bluetooth.read();   // Starts reading the serial port, the first byte from the incoming data
        // If we have pressed the "Send" button from the Android App, clear the previous text
        if (indicator == '1') {
          for (int i = 0; i < 100; i++) {
            text[i] = 0;
            m.clear();
          }
          // Read the whole data/string comming from the phone and put it into text[] array.
          while (Bluetooth.available()) {
            incomebyte = Bluetooth.read();
            text[count] = incomebyte;
            count++;
          }
          count = 0;
        }
        // Adjusting the Scrolling Speed
        else if (indicator == '2') {
          String sS = Bluetooth.readString();
          scrollSpeed = 150 - sS.toInt(); // Milliseconds, subtraction because lower value means higher scrolling speed
        }
        // Adjusting the brightness
        else if (indicator == '3') {
          String sB = Bluetooth.readString();
          brightness = sB.toInt();
          m.setIntensity(brightness);
        }
      }
    }
    void printCharWithShift(char c, int shift_speed) {
      if (c < 32) return;
      c -= 32;
      memcpy_P(buffer, CH + 7 * c, 7);
      m.writeSprite(32, 0, buffer);
      m.setColumn(32 + buffer[0], 0);
      for (int i = 0; i < buffer[0] + 1; i++)
      {
        delay(shift_speed);
        m.shiftLeft(false, false);
      }
    }
    void printStringWithShift(char* s, int shift_speed) {
      while (*s != 0) {
        printCharWithShift(*s, shift_speed);
        s++;
      }
    }
    void printString(char* s)
    {
      int col = 0;
      while (*s != 0)
      {
        if (*s < 32) continue;
        char c = *s - 32;
        memcpy_P(buffer, CH + 7 * c, 7);
        m.writeSprite(col, 0, buffer);
        m.setColumn(col + buffer[0], 0);
        col += buffer[0] + 1;
        s++;
      }
    }

Steps :

1. Connect MAX7219 LED modules with each other as shown in above wiring diagram.
2. Connect led modules data pins to arduino data pins and connect source power as shown in circuit diagram.
3. Now connect HC-05 serial module to RX TX pins of Arduino. Arduino RX to HC-05 TX and arduino TX to HC-05 RX.
4. Download code into arduino using Arduino IDE.
5. Download android application from download section and install it in your phone .
6. Now you can connect your phone with this display using provided application to control matrix display.

Downloads :

1. Android appliation
2. MAX7219 Datasheet
3. MaxMatrix.h

Check this WiFi controlled MAX7219 LED Matrix using ESP-12 NodeMCU module