How to Program GPS in Your Car: A DIY Guide

For car enthusiasts and tech-savvy individuals, integrating a GPS system into your vehicle can open up a world of possibilities, from tracking your car’s location to creating custom navigation solutions. While modern cars often come equipped with built-in GPS, understanding how to program and customize your own GPS system can be a rewarding project. This guide will walk you through the basics of setting up a simple car GPS using readily available components and Arduino programming.

Understanding the Basics of Car GPS Programming

At its core, programming a GPS in your car involves using a GPS receiver to capture location data and then processing or transmitting this data for various applications. For a DIY approach, microcontrollers like Arduino are excellent platforms to interface with GPS modules and create custom GPS functionalities. Often, these projects also incorporate GSM modules to send location data remotely via SMS.

Required Components

To embark on this project, you will need the following components:

• Arduino Board: An Arduino Uno or similar microcontroller board to process data and control the system.
• GPS Module: A GPS receiver module (like the TinyGPS module mentioned in the original code) to capture latitude and longitude coordinates from GPS satellites.
• GSM Module: A GSM module (such as the SIM800L) to enable communication over cellular networks, allowing you to send SMS messages with location data.
• SoftwareSerial Library: This Arduino library allows serial communication on other digital pins, necessary for connecting both GPS and GSM modules.
• Power Supply: To power the Arduino and modules.
• Wiring and Connectors: To connect all the components together.

Setting up the Hardware

Connecting the hardware components is crucial for the system to function correctly. Here’s a basic wiring setup based on the original code:

1. GPS Module Connection: Connect the GPS module’s TX pin to a digital pin on the Arduino (e.g., pin 4) and the GPS module’s RX pin to another digital pin on the Arduino (e.g., pin 5). Use the SoftwareSerial library to establish serial communication with the GPS module on these pins.
2. GSM Module Connection: Similarly, connect the GSM module’s TX pin to a digital pin on the Arduino (e.g., pin 7) and the GSM module’s RX pin to another digital pin (e.g., pin 8) for SoftwareSerial communication.
3. Powering the Modules: Ensure both the GPS and GSM modules are powered correctly, typically with 3.3V or 5V, depending on the module specifications. Power can be supplied from the Arduino or an external power source.
4. Relay Module (Optional): The original code includes a relay for engine control. If you want to incorporate remote engine control via SMS, connect a relay module to a digital pin (e.g., pin 12) and wire it to your car’s engine control circuit (exercise extreme caution and professional guidance for automotive electrical work).

Arduino Code Explanation

The provided Arduino code snippet demonstrates a basic GPS tracking and SMS notification system. Let’s break down the code to understand how it works:

#include <SoftwareSerial.h>
#include <TinyGPS.h>

SoftwareSerial Sim800L(7, 8); // SoftwareSerial for GSM module
int state = 0;
const int pin = 9; // Pin for triggering GPS data sending (e.g., ignition detection)
float gpslat, gpslon; // Variables to store latitude and longitude
TinyGPS gps; // TinyGPS object
SoftwareSerial sgps(4, 5); // SoftwareSerial for GPS module

String textMessage; // Variable to store received SMS
String Engine = "HIGH"; // Variable to store engine state
const int relay = 12; // Relay control pin

void setup() {
  // Powering the GSM module (simulating power button press)
  digitalWrite(9, HIGH);
  delay(1000);
  digitalWrite(9, LOW);
  delay(5000);

  pinMode(relay, OUTPUT); // Relay pin as output
  digitalWrite(relay, HIGH); // Initially turn relay off

  Serial.begin(9600); // Serial monitor for debugging
  Sim800L.begin(9600); // Serial communication with GSM module
  sgps.begin(9600);    // Serial communication with GPS module
}

void loop() {
  // Read GPS data
  while (sgps.available()) {
    int c = sgps.read();
    if (gps.encode(c)) { // Encode GPS data
      gps.f_get_position(&gpslat, &gpslon); // Get latitude and longitude
    }
  }

  // Trigger SMS sending based on digital input (pin 9)
  if (digitalRead(pin) == HIGH && state == 0) {
    Sim800L.print("r");
    delay(1000);
    Sim800L.print("AT+CMGF=1r"); // Set SMS mode
    delay(1000);
    Sim800L.print("AT+CMGS=""xxxxxxxxxxxxxx""r"); // Replace with recipient phone number
    delay(1000);
    Sim800L.print("Latitude :");
    Sim800L.println(gpslat, 6);
    Sim800L.print("Longitude:");
    Sim800L.println(gpslon, 6);
    delay(1000);
    Sim800L.write(0x1A); // End SMS message (Ctrl+Z)
    delay(1000);
    state = 1;
  }
  if (digitalRead(pin) == LOW) {
    state = 0;
  }

  delay(20000); // Wait for GSM network registration
  Serial.print("SIM900 ready...");

  Sim800L.print("AT+CMGF=1r"); // Set SMS mode
  delay(100);
  Sim800L.print("AT+CNMI=2,2,0,0,0r"); // Configure SMS reception to serial

  // SMS command processing
  if (Sim800L.available() > 0) {
    textMessage = Sim800L.readString();
    Serial.print(textMessage);
    delay(10);

    if (textMessage.indexOf("ON") >= 0) {
      digitalWrite(relay, LOW); // Turn relay ON
      Engine = "on";
      Serial.println("Relay set to ON");
      textMessage = "";
    }
    if (textMessage.indexOf("OFF") >= 0) {
      digitalWrite(relay, HIGH); // Turn relay OFF
      Engine = "off";
      Serial.println("Relay set to OFF");
      textMessage = "";
    }
    if (textMessage.indexOf("STATE") >= 0) {
      String message = "Engine is " + Engine;
      sendSMS(message); // Send engine state via SMS
      Serial.println("Engine state request");
      textMessage = "";
    }
  }
}

// Function to send SMS
void sendSMS(String message) {
  Sim800L.print("AT+CMGF=1r");
  delay(100);
  Sim800L.println("AT + CMGS = ""xxxxxxxxxxxxxxxxxx"""); // Replace with recipient phone number
  delay(100);
  Sim800L.println(message);
  delay(100);
  Sim800L.println((char)26); // End SMS message (Ctrl+Z)
  delay(100);
  Sim800L.println();
  delay(5000);
}

Code Functionality:

• GPS Data Acquisition: The code continuously reads data from the GPS module using TinyGPS library to parse NMEA sentences and extract latitude and longitude.
• SMS Location Sending: When the digital pin 9 is HIGH (you could connect this to your car’s ignition signal), the system sends an SMS with the current GPS coordinates to a predefined phone number.
• SMS Command Reception: The GSM module is configured to receive SMS commands. The code checks for “ON”, “OFF”, and “STATE” commands in received SMS messages to control a relay (potentially for engine control) and to query the engine state.
• Relay Control: Based on SMS commands, the code can turn a relay ON or OFF, and report the current relay state via SMS.

Uploading the Code

1. Arduino IDE: Ensure you have the Arduino IDE installed on your computer.
2. Libraries: Install the SoftwareSerial and TinyGPS libraries through the Arduino Library Manager (Sketch > Include Library > Manage Libraries).
3. Code Modification: Replace the placeholder phone numbers (xxxxxxxxxxxxxx) in the code with your actual phone number for SMS alerts and command reception.
4. Upload: Connect your Arduino board to your computer, select the correct board and port in the Arduino IDE, and upload the code to your Arduino.

Testing and Troubleshooting

After setting up the hardware and uploading the code, testing is crucial:

1. GPS Signal: Ensure the GPS module has a clear view of the sky to acquire a GPS signal. This may take a few minutes initially.
2. GSM Signal: Insert a SIM card into the GSM module and ensure it has network connectivity.
3. Triggering SMS: Simulate the trigger condition (e.g., by manually setting pin 9 HIGH) and check if an SMS with GPS coordinates is sent to your phone.
4. SMS Commands: Send SMS commands like “ON”, “OFF”, and “STATE” to the SIM card number in the GSM module and verify if the relay responds correctly and if you receive state updates.
5. Serial Monitor: Use the Arduino Serial Monitor to debug and monitor the data flow from the GPS and GSM modules, and to check for any error messages.

Conclusion

Programming a GPS system in your car, as demonstrated by this Arduino project, offers a hands-on approach to understanding car electronics and GPS technology. While this is a basic example, it provides a foundation for more advanced DIY car GPS applications, such as custom tracking systems, geofencing, and smart vehicle automation. Remember to always prioritize safety and consult with professionals when working with automotive electrical systems.