Tag Archives: Arduino

Arduino Ethernet — This circuit contains an Arduino Nano and Pressure Sensor Communicating over Ethernet

In LESSON 16 we showed a simple Client Server model that allows us to send strings between Python running on a PC and the arduino over Ethernet. That lesson simply passed strings back and forth to show a very basic Server on Arduino, and Python acting as the Client. In this lesson we show a more practical example, with the Arduino connected to an Adafruit BMP180 Pressure Sensor. In order to complete this lesson, you will need an Arduino, an Ethernet Shield, and the Pressure Sensor. If you do not have this particular pressure sensor, you can probably follow along in the lesson using whatever sensor you have that is of interest. The video will take you through the tutorial step-by-step, and then the code we developed is shown below.

The key issue in getting this project to work is to get your mac address and IP address from your router or network. If you are at school, simply speak to your network administrator, and he will help you get an IP address for your arduino. If you are at home, you will need to connect to your router from a browser, and configure it to assign an IP address and agree on a mac address for your arduino. Some arduino Ethernet shields have a sticker with a mac address. If your Ethernet shield has a sticker with mac address, use that one. If it does not, you will need to come up with a unique mac address. There are thousands of possible routers and networks out there, so I can not help you with that part. But if you look in the router documentation, you should be able to get the IP address and mac address worked out. The arduino itself does not have a hard wired mac address, but you set the mac address in the arduino software, and the IP address as well. The key thing is that the mac address is unique on your network, and the router and arduino agree on the IP address and mac address. If you have a clearer way to explain this, please leave a comment below.

This is the server side software to run on the arduino. Again, you should use a suitable IP address and mac address for your network. Do not think you can just copy the ones I use in the code below.

#include <Ethernet.h> //Load Ethernet Library
#include <EthernetUdp.h> //Load the Udp Library
#include <SPI.h> //Load SPI Library

#include "Wire.h" //imports the wire library
#include "Adafruit_BMP085.h" // import the Pressure/Temperature sensor library
Adafruit_BMP085 mySensor; //Create a sensor object

float tempC; //Declare variable for Temp in C
float tempF; //Declare variable for Temp in F
float Pressure; //Declare a variable for Pressure

byte mac[] ={ 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xEE}; //Assign mac address
IPAddress ip(10, 1, 15, 243); //Assign the IP Adress
unsigned int localPort = 5000; // Assign a port to talk over
char packetBuffer[UDP_TX_PACKET_MAX_SIZE]; //dimensian a char array to hold our data packet
String datReq; //String for our data
int packetSize; //Size of the packet
EthernetUDP Udp; // Create a UDP Object

void setup() {
  
  Serial.begin(9600); //Initialize Serial Port 
  Ethernet.begin( mac, ip); //Inialize the Ethernet
  Udp.begin(localPort); //Initialize Udp
  delay(1500); //delay
  mySensor.begin(); //initialize pressure-temp sensor
  

}

void loop() {
  
  packetSize =Udp.parsePacket(); //Reads the packet size
  
  if(packetSize>0) { //if packetSize is >0, that means someone has sent a request
    
    Udp.read(packetBuffer, UDP_TX_PACKET_MAX_SIZE); //Read the data request
    String datReq(packetBuffer); //Convert char array packetBuffer into a string called datReq
    
    if (datReq =="Temperature") { //Do the following if Temperature is requested
    
      tempC = mySensor.readTemperature(); //Read the temperature
      tempF = tempC*1.8 + 32; //Convert temp to F
      
      Udp.beginPacket(Udp.remoteIP(), Udp.remotePort()); //Initialize packet send
      Udp.print(tempF); //Send the temperature data
      Udp.endPacket(); //End the packet
      
    }
    
    if (datReq== "Pressure") { //Do the following if Pressure is requested
    
      Pressure=mySensor.readPressure(); //read the pressure
      
        Udp.beginPacket(Udp.remoteIP(), Udp.remotePort()); //Initialize packet send
        Udp.print(Pressure); //Send the Pressure data
        Udp.endPacket(); //End the packet
        
    }
      
  }
  memset(packetBuffer, 0, UDP_TX_PACKET_MAX_SIZE); //clear out the packetBuffer array
}

#include <Ethernet.h> //Load Ethernet Library

#include <EthernetUdp.h> //Load the Udp Library

#include <SPI.h> //Load SPI Library

#include "Wire.h" //imports the wire library

#include "Adafruit_BMP085.h" // import the Pressure/Temperature sensor library

Adafruit_BMP085 mySensor; //Create a sensor object

float tempC; //Declare variable for Temp in C

float tempF; //Declare variable for Temp in F

float Pressure; //Declare a variable for Pressure

byte mac[] ={ 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xEE}; //Assign mac address

IPAddress ip(10, 1, 15, 243); //Assign the IP Adress

unsigned int localPort = 5000; // Assign a port to talk over

char packetBuffer[UDP_TX_PACKET_MAX_SIZE]; //dimensian a char array to hold our data packet

String datReq; //String for our data

int packetSize; //Size of the packet

EthernetUDP Udp; // Create a UDP Object

void setup() {

Serial.begin(9600); //Initialize Serial Port

Ethernet.begin( mac, ip); //Inialize the Ethernet

Udp.begin(localPort); //Initialize Udp

delay(1500); //delay

mySensor.begin(); //initialize pressure-temp sensor

}

void loop() {

packetSize =Udp.parsePacket(); //Reads the packet size

if(packetSize>0) { //if packetSize is >0, that means someone has sent a request

Udp.read(packetBuffer, UDP_TX_PACKET_MAX_SIZE); //Read the data request

String datReq(packetBuffer); //Convert char array packetBuffer into a string called datReq

if (datReq =="Temperature") { //Do the following if Temperature is requested

tempC = mySensor.readTemperature(); //Read the temperature

tempF = tempC*1.8 + 32; //Convert temp to F

Udp.beginPacket(Udp.remoteIP(), Udp.remotePort()); //Initialize packet send

Udp.print(tempF); //Send the temperature data

Udp.endPacket(); //End the packet

}

if (datReq== "Pressure") { //Do the following if Pressure is requested

Pressure=mySensor.readPressure(); //read the pressure

Udp.beginPacket(Udp.remoteIP(), Udp.remotePort()); //Initialize packet send

Udp.print(Pressure); //Send the Pressure data

Udp.endPacket(); //End the packet

}

memset(packetBuffer, 0, UDP_TX_PACKET_MAX_SIZE); //clear out the packetBuffer array

}

Once you have this on your arduino, and the arduino connected to the internet via an Ethernet cable, you can test by opening a command line in Windows. Then ping the address you have assigned to the Arduino. If it pings correctly and you get a reply, you are ready to develop the Python code. The Python will be the client. It will send the requests to the Arduino, and the Arduino will respond with data. Since our circuit can measure pressure or temperature, you can request either of those. When the arduino receives a request for temperature, it will go out, make the temperature measurement and then return the data to Python. Similarly, if you request Pressure the arduino will read the request, will make the Pressure measurement, and then return pressure reading to the client (Python).

from socket import *
import time

address= ( '10.1.15.243', 5000) #define server IP and port
client_socket =socket(AF_INET, SOCK_DGRAM) #Set up the Socket
client_socket.settimeout(1) #Only wait 1 second for a response

while(1):

    data = "Temperature" #Set data request to Temperature

    client_socket.sendto( data, address) #Send the data request

    try:

        rec_data, addr = client_socket.recvfrom(2048) #Read response from arduino
        temp = float(rec_data) #Convert string rec_data to float temp
        print "The Measured Temperature is ", temp, " degrees F." # Print the result

    except:
        pass

    time.sleep(2) #delay before sending next command

    data = "Pressure" #Set data request to Pressure

    client_socket.sendto( data, address) #Send the data request

    try:

        rec_data, addr = client_socket.recvfrom(2048) #Read response from arduino
        Pressure = float(rec_data) #Convert string rec_data to float temp
        print "The Measured Pressure is ", Pressure, " Pa." # Print the result

    except:
        pass

    time.sleep(2) #delay before sending next command

    print ""

from socket import *

import time

address= ( '10.1.15.243', 5000) #define server IP and port

client_socket =socket(AF_INET, SOCK_DGRAM) #Set up the Socket

client_socket.settimeout(1) #Only wait 1 second for a response

while(1):

data = "Temperature" #Set data request to Temperature

client_socket.sendto( data, address) #Send the data request

try:

rec_data, addr = client_socket.recvfrom(2048) #Read response from arduino

temp = float(rec_data) #Convert string rec_data to float temp

print "The Measured Temperature is ", temp, " degrees F." # Print the result

except:

pass

time.sleep(2) #delay before sending next command

data = "Pressure" #Set data request to Pressure

client_socket.sendto( data, address) #Send the data request

try:

rec_data, addr = client_socket.recvfrom(2048) #Read response from arduino

Pressure = float(rec_data) #Convert string rec_data to float temp

print "The Measured Pressure is ", Pressure, " Pa." # Print the result

except:

pass

time.sleep(2) #delay before sending next command

print ""

This python code will request Temperature, will then read the response, and then will print the data. It then requests Pressure, reads the response, and then prints it. If you look at our earlier lessons you can see graphical techniques to visually present the data. The hard part is getting the data passed back and forth, which we show how to do in this lesson.

Arduino with Python, Tutorial

Python with Arduino LESSON 15: Configuring and Using the Xbee Radios

March 18, 2015 admin

This lesson describes how to program the Xbee Series 1 radios. It will work with either the standard Series 1 (S1) or the Series 1 Pro models. The Pro radios are higher power and will give greater range, but they cost more. The radios are configured using X-CTU software, which can be downloaded here. The video gives step by step instructions on how to configure and use the radios to communicate wirelessly over the serial port. Lesson 14 gives information on the hardware needed. Lessons 1-13 sill show you how to communicate between Python and Arduino if you need to get caught up on basic serial communication and interfacing arduino and python. The techniques provided in the video above, however, should work for just about any arduino project where you want to communicate between two arduinos, an arduino and PC, or between two PCs.

Arduino, Tutorial

LESSON 27: Instrument Package

August 9, 2014 admin

In this lesson we bring together a lot of the material from the first 26 lessons to create an instrument package that could be deployed in a demonstration project. We will wire wrap up an Arduino Nano, a Virtuabotix SD card reader, and the Adafruit Ultimate GPS to create a system that will track and log position and altitude, and save the data in a format that can be displayed on Google Earth.

Wire Wrapping tools and Perforated Board

You will want to place the Adafruit GPS, the SD Card Reader, and the Arduino Nano into a perf board. Then, you will want to carefully wire wrap the components as follows:

Connecting the Adafruit Ultimate GPS Unit to Arduino
GPS Pin	Arduino Pin
Vin	5V
GND	GND
RX	Pin 2
TX	Pin 3

Connecting the SD Card Reader
Sd Card Reader Pin	Arduino Pin	Details
GND	GND	Common Ground
3.3 V – (NOT USED)
+5	5V	Power
CS	4	Chip Select
MOSI	11	SPI Data
SCK	13	Clock
MISO	12	SPI Data
GND	GND	Common Ground

Now the code you developed in LESSON 26 should run on this prototype. The code creates a Google Earth friendly set of coordinates. Just put a KML wrapper on the coordinates as described in LESSON 26. Putting it all together, I took the system outside and walked around, and this is the data track I got.

GPS Track — GPS track generated by my wire wrapped prototype

Arduino

LESSON 23: Arduino GPS with Data Logger

July 31, 2014 admin

In this lesson we will extend what we did in lesson 22 to include a data logger with our GPS. You should be sure and do lesson 22 first, as that shows you how to hook up and program the GPS. In this project we will connect an SD Card Reader/Writer, and will power the whole thing with a 9 Volt battery. With this, you can walk around, and the device will constantly monitor and log your position. You can then bring it back inside, and look at where you have been using Google Earth.

GPS Data Logger — Arduino connected to Adafruit ultimate GPS and a n SD card Data Logger

To start with, lets talk about what you will need to do this project. As described earlier, you need to start by doing lesson 22 which will get you going on the GPS hookup and initial software. Now, to move forward, you will need an Arduino, Adafruit Ultimate GPS, Virtuabotix SD card reader, and a Battery Clip to power the arduino during your mobile jaunts. You will need a 9V battery. If you are going to be doing a lot of mobile work, it is probably worth it to invest in a good 9v Rechargable battery system.

When you get your gear gathered up, you will be ready to get this project going. First, hook the GPS up to the arduino as we did in lesson 22:

Connecting the Adafruit Ultimate GPS Unit to Arduino
GPS Pin	Arduino Pin
Vin	5V
GND	GND
RX	Pin 2
TX	Pin 3

You also need to hook up the SC Card Reader/Writer. You should be familiar with this from lesson 21.

Connecting the SD Card Reader
Sd Card Reader Pin	Arduino Pin	Details
GND	GND	Common Ground
3.3 V – (NOT USED)
+5	5V	Power
CS	4	Chip Select
MOSI	11	SPI Data
SCK	13	Clock
MISO	12	SPI Data
GND	GND	Common Ground

Remember that this SD card reader has two rows of pins. Don’t let that confuse you, both rows are equivalent. You can connect to either row.

Most of the code has already been written in Lesson 22. In this lesson, the main thing we will be doing is to write the GPS data to the SD card. This way, as we walk around outside, it will log our positions to the SD card. We will create two files. One will hold the raw NMEA sentences, and the other our location data, as parsed by the adafruit GPS library. You should be able to figure most of this out from what you already know from lesson 22 and lesson 21. In the video above, we take you through this code step-by-step, so watch the video to understand what we are doing. If you get stuck, you can look at the code below.

#include <SD.h> //Load SD card library
#include<SPI.h> //Load SPI Library

#include <Adafruit_GPS.h>    //Install the adafruit GPS library
#include <SoftwareSerial.h> //Load the Software Serial library
SoftwareSerial mySerial(3,2); //Initialize the Software Serial port
Adafruit_GPS GPS(&mySerial); //Create the GPS Object

String NMEA1; //Variable for first NMEA sentence
String NMEA2; //Variable for second NMEA sentence
char c; //to read characters coming from the GPS

int chipSelect = 4; //chipSelect pin for the SD card Reader
File mySensorData; //Data object you will write your sesnor data to


void setup() {
  
  Serial.begin(115200); //Turn on serial monitor
  GPS.begin(9600); //Turn on GPS at 9600 baud
  GPS.sendCommand("$PGCMD,33,0*6D");  //Turn off antenna update nuisance data
  GPS.sendCommand(PMTK_SET_NMEA_OUTPUT_RMCGGA); //Request RMC and GGA Sentences only
  GPS.sendCommand(PMTK_SET_NMEA_UPDATE_1HZ); //Set update rate to 1 hz
  delay(1000); 
  
  pinMode(10, OUTPUT); //Must declare 10 an output and reserve it to keep SD card happy
  SD.begin(chipSelect); //Initialize the SD card reader
  
  if (SD.exists("NMEA.txt")) { //Delete old data files to start fresh
    SD.remove("NMEA.txt");
  }
  if (SD.exists("GPSData.txt")) { //Delete old data files to start fresh
    SD.remove("GPSData.txt");
  }

}

void loop() {
  
  readGPS();

  if(GPS.fix==1) { //Only save data if we have a fix
  mySensorData = SD.open("NMEA.txt", FILE_WRITE); //Open file on SD card for writing
  mySensorData.println(NMEA1); //Write first NMEA to SD card
  mySensorData.println(NMEA2); //Write Second NMEA to SD card
  mySensorData.close();  //Close the file
  mySensorData = SD.open("GPSData.txt", FILE_WRITE);
  mySensorData.print(GPS.latitude,4); //Write measured latitude to file
  mySensorData.print(GPS.lat); //Which hemisphere N or S
  mySensorData.print(",");
  mySensorData.print(GPS.longitude,4); //Write measured longitude to file
  mySensorData.print(GPS.lon); //Which Hemisphere E or W
  mySensorData.print(",");
  mySensorData.println(GPS.altitude);
  mySensorData.close();
  }
  
}

void readGPS() {
  
  clearGPS();
  while(!GPS.newNMEAreceived()) { //Loop until you have a good NMEA sentence
    c=GPS.read();
  }
  GPS.parse(GPS.lastNMEA()); //Parse that last good NMEA sentence
  NMEA1=GPS.lastNMEA();
  
   while(!GPS.newNMEAreceived()) { //Loop until you have a good NMEA sentence
    c=GPS.read();
  }
  GPS.parse(GPS.lastNMEA()); //Parse that last good NMEA sentence
  NMEA2=GPS.lastNMEA();
  
  Serial.println(NMEA1);
  Serial.println(NMEA2);
  Serial.println("");
  
}

void clearGPS() {  //Clear old and corrupt data from serial port 
  while(!GPS.newNMEAreceived()) { //Loop until you have a good NMEA sentence
    c=GPS.read();
  }
  GPS.parse(GPS.lastNMEA()); //Parse that last good NMEA sentence
  
  while(!GPS.newNMEAreceived()) { //Loop until you have a good NMEA sentence
    c=GPS.read();
  }
  GPS.parse(GPS.lastNMEA()); //Parse that last good NMEA sentence
   while(!GPS.newNMEAreceived()) { //Loop until you have a good NMEA sentence
    c=GPS.read();
  }
  GPS.parse(GPS.lastNMEA()); //Parse that last good NMEA sentence
  
}

#include <SD.h> //Load SD card library

#include<SPI.h> //Load SPI Library

#include <Adafruit_GPS.h> //Install the adafruit GPS library

#include <SoftwareSerial.h> //Load the Software Serial library

SoftwareSerial mySerial(3,2); //Initialize the Software Serial port

Adafruit_GPS GPS(&mySerial); //Create the GPS Object

String NMEA1; //Variable for first NMEA sentence

String NMEA2; //Variable for second NMEA sentence

char c; //to read characters coming from the GPS

int chipSelect = 4; //chipSelect pin for the SD card Reader

File mySensorData; //Data object you will write your sesnor data to

void setup() {

Serial.begin(115200); //Turn on serial monitor

GPS.begin(9600); //Turn on GPS at 9600 baud

GPS.sendCommand("$PGCMD,33,0*6D"); //Turn off antenna update nuisance data

GPS.sendCommand(PMTK_SET_NMEA_OUTPUT_RMCGGA); //Request RMC and GGA Sentences only

GPS.sendCommand(PMTK_SET_NMEA_UPDATE_1HZ); //Set update rate to 1 hz

delay(1000);

pinMode(10, OUTPUT); //Must declare 10 an output and reserve it to keep SD card happy

SD.begin(chipSelect); //Initialize the SD card reader

if (SD.exists("NMEA.txt")) { //Delete old data files to start fresh

SD.remove("NMEA.txt");

}

if (SD.exists("GPSData.txt")) { //Delete old data files to start fresh

SD.remove("GPSData.txt");

}

void loop() {

readGPS();

if(GPS.fix==1) { //Only save data if we have a fix

mySensorData = SD.open("NMEA.txt", FILE_WRITE); //Open file on SD card for writing

mySensorData.println(NMEA1); //Write first NMEA to SD card

mySensorData.println(NMEA2); //Write Second NMEA to SD card

mySensorData.close(); //Close the file

mySensorData = SD.open("GPSData.txt", FILE_WRITE);

mySensorData.print(GPS.latitude,4); //Write measured latitude to file

mySensorData.print(GPS.lat); //Which hemisphere N or S

mySensorData.print(",");

mySensorData.print(GPS.longitude,4); //Write measured longitude to file

mySensorData.print(GPS.lon); //Which Hemisphere E or W

mySensorData.print(",");

mySensorData.println(GPS.altitude);

mySensorData.close();

}

void readGPS() {

clearGPS();

while(!GPS.newNMEAreceived()) { //Loop until you have a good NMEA sentence

c=GPS.read();

}

GPS.parse(GPS.lastNMEA()); //Parse that last good NMEA sentence

NMEA1=GPS.lastNMEA();

while(!GPS.newNMEAreceived()) { //Loop until you have a good NMEA sentence

c=GPS.read();

}

GPS.parse(GPS.lastNMEA()); //Parse that last good NMEA sentence

NMEA2=GPS.lastNMEA();

Serial.println(NMEA1);

Serial.println(NMEA2);

Serial.println("");

}

void clearGPS() { //Clear old and corrupt data from serial port

while(!GPS.newNMEAreceived()) { //Loop until you have a good NMEA sentence

c=GPS.read();

}

GPS.parse(GPS.lastNMEA()); //Parse that last good NMEA sentence

while(!GPS.newNMEAreceived()) { //Loop until you have a good NMEA sentence

c=GPS.read();

}

GPS.parse(GPS.lastNMEA()); //Parse that last good NMEA sentence

while(!GPS.newNMEAreceived()) { //Loop until you have a good NMEA sentence

c=GPS.read();

}

GPS.parse(GPS.lastNMEA()); //Parse that last good NMEA sentence

}

Arduino, Tutorial

LESSON 22: Build an Arduino GPS Tracker

July 30, 2014 admin

OK, it is time for us to take our projects up to that next level. We are going to build a GPS tracker from scratch. This is going to take several lessons to complete, but it will build on what you already know, and is really not going to be that difficult of a project. We will be using the most excellent Adafruit Ultimate GPS module. This is an excellent GPS. I like it because it is affordable, easy to use, and is one of the few that will work at extreme elevations, making it ideal for our Edge of Space/High Altitude Balloon work.

Arduino GPS — We are using the Adafruit Ultimate GPS

This unit is pretty easy to hook up, as you can see in the Table below:

Connecting the Adafruit Ultimate GPS Unit to Arduino
GPS Pin	Arduino Pin
Vin	5V
GND	GND
RX	Pin 2
TX	Pin 3

Our goal in this lesson is to get the GPS connected, and get it reading NMEA sentences. NMEA is a data format used by GPS and mapping devices and software to keep track of position coordinates. There are lots of different NMEA sentences, but the two that contain the most useful information are the $GPRMC and $GPGGA sentences.

Our interest is in creating a location tracker for our High Altitude Balloon work, and the $GPRMC and $GPGGA sentences contain all the information and data we would need for that work. These sentences contain the lattitude, longitude, time, altitude, and velocity.

The GPS modules are pretty easy to work with. When you apply power to the GPS, it immediately starts spitting out NMEA sentences to its serial port. Our job on the arduino side is to simply read these data strings, and then parse them into useful data. The thing that is a challenge is that they constantly spit out data, whether you want it, or whether you are ready for it or not. In developing the software, we have to be mindful the the data is always spewing out of the GPS. Typically, we will have other components on our package, like temperature, pressure and inertial sensors. While our arduino is out making measurements on these other sensors, data continues to stream in from the GPS, likely overflowing our serial buffer. When we return to make a GPS measurement, it is very likely that the serial buffer will have old or corrupt GPS data in it. Hence, we must be mindful to deal with this issue in developing our software.

The video above takes you step-by-step through connecting and reading the NMEA sentences step-by-step. Then in the next lesson we will parse and log the data to create a portable GPS tracker. The code below is explained in the video. You need to watch the video to understand this code, and so you will be able to begin to work with this code to create a portable GPS tracker.

In order for this software to work, you need to download and install the Adafruit GPS Library.

//Make sure to install the adafruit GPS library from https://github.com/adafruit/Adafruit-GPS-Library
#include <Adafruit_GPS.h> //Load the GPS Library. Make sure you have installed the library form the adafruit site above
#include <SoftwareSerial.h> //Load the Software Serial Library. This library in effect gives the arduino additional serial ports
SoftwareSerial mySerial(3, 2); //Initialize SoftwareSerial, and tell it you will be connecting through pins 2 and 3
Adafruit_GPS GPS(&mySerial); //Create GPS object

String NMEA1;  //We will use this variable to hold our first NMEA sentence
String NMEA2;  //We will use this variable to hold our second NMEA sentence
char c;       //Used to read the characters spewing from the GPS module

void setup()  
{
  Serial.begin(115200);  //Turn on the Serial Monitor
  GPS.begin(9600);       //Turn GPS on at baud rate of 9600
  GPS.sendCommand("$PGCMD,33,0*6D"); // Turn Off GPS Antenna Update
  GPS.sendCommand(PMTK_SET_NMEA_OUTPUT_RMCGGA); //Tell GPS we want only $GPRMC and $GPGGA NMEA sentences
  GPS.sendCommand(PMTK_SET_NMEA_UPDATE_1HZ);   // 1 Hz update rate
  delay(1000);  //Pause
}


void loop()                     // run over and over again
{
readGPS();  //This is a function we define below which reads two NMEA sentences from GPS

}
void readGPS(){  //This function will read and remember two NMEA sentences from GPS
  clearGPS();    //Serial port probably has old or corrupt data, so begin by clearing it all out
  while(!GPS.newNMEAreceived()) { //Keep reading characters in this loop until a good NMEA sentence is received
  c=GPS.read(); //read a character from the GPS
  }
GPS.parse(GPS.lastNMEA());  //Once you get a good NMEA, parse it
NMEA1=GPS.lastNMEA();      //Once parsed, save NMEA sentence into NMEA1
while(!GPS.newNMEAreceived()) {  //Go out and get the second NMEA sentence, should be different type than the first one read above.
  c=GPS.read();
  }
GPS.parse(GPS.lastNMEA());
NMEA2=GPS.lastNMEA();
  Serial.println(NMEA1);
  Serial.println(NMEA2);
  Serial.println("");
}
void clearGPS() {  //Since between GPS reads, we still have data streaming in, we need to clear the old data by reading a few sentences, and discarding these
while(!GPS.newNMEAreceived()) {
  c=GPS.read();
  }
GPS.parse(GPS.lastNMEA());
while(!GPS.newNMEAreceived()) {
  c=GPS.read();
  }
GPS.parse(GPS.lastNMEA());

}

//Make sure to install the adafruit GPS library from https://github.com/adafruit/Adafruit-GPS-Library

#include <Adafruit_GPS.h> //Load the GPS Library. Make sure you have installed the library form the adafruit site above

#include <SoftwareSerial.h> //Load the Software Serial Library. This library in effect gives the arduino additional serial ports

SoftwareSerial mySerial(3, 2); //Initialize SoftwareSerial, and tell it you will be connecting through pins 2 and 3

Adafruit_GPS GPS(&mySerial); //Create GPS object

String NMEA1; //We will use this variable to hold our first NMEA sentence

String NMEA2; //We will use this variable to hold our second NMEA sentence

char c; //Used to read the characters spewing from the GPS module

void setup()

{

Serial.begin(115200); //Turn on the Serial Monitor

GPS.begin(9600); //Turn GPS on at baud rate of 9600

GPS.sendCommand("$PGCMD,33,0*6D"); // Turn Off GPS Antenna Update

GPS.sendCommand(PMTK_SET_NMEA_OUTPUT_RMCGGA); //Tell GPS we want only $GPRMC and $GPGGA NMEA sentences

GPS.sendCommand(PMTK_SET_NMEA_UPDATE_1HZ); // 1 Hz update rate

delay(1000); //Pause

}

void loop() // run over and over again

{

readGPS(); //This is a function we define below which reads two NMEA sentences from GPS

}

void readGPS(){ //This function will read and remember two NMEA sentences from GPS

clearGPS(); //Serial port probably has old or corrupt data, so begin by clearing it all out

while(!GPS.newNMEAreceived()) { //Keep reading characters in this loop until a good NMEA sentence is received

c=GPS.read(); //read a character from the GPS

}

GPS.parse(GPS.lastNMEA()); //Once you get a good NMEA, parse it

NMEA1=GPS.lastNMEA(); //Once parsed, save NMEA sentence into NMEA1

while(!GPS.newNMEAreceived()) { //Go out and get the second NMEA sentence, should be different type than the first one read above.

c=GPS.read();

}

GPS.parse(GPS.lastNMEA());

NMEA2=GPS.lastNMEA();

Serial.println(NMEA1);

Serial.println(NMEA2);

Serial.println("");

}

void clearGPS() { //Since between GPS reads, we still have data streaming in, we need to clear the old data by reading a few sentences, and discarding these

while(!GPS.newNMEAreceived()) {

c=GPS.read();

}

GPS.parse(GPS.lastNMEA());

while(!GPS.newNMEAreceived()) {

c=GPS.read();

}

GPS.parse(GPS.lastNMEA());

}

Technology Tutorials

Tag Archives: Arduino

Python with Arduino LESSON 17: Sending and Receiving Data Over Ethernet

Python with Arduino LESSON 15: Configuring and Using the Xbee Radios

LESSON 27: Instrument Package

Connecting the Adafruit Ultimate GPS Unit to Arduino

Connecting the SD Card Reader

LESSON 23: Arduino GPS with Data Logger

Connecting the Adafruit Ultimate GPS Unit to Arduino

Connecting the SD Card Reader

LESSON 22: Build an Arduino GPS Tracker

Connecting the Adafruit Ultimate GPS Unit to Arduino

Making The World a Better Place One High Tech Project at a Time. Enjoy!