How to Connect any NMEA-0183 Device to an Arduino

NMEA-0183 uses 12V signals to communicate with each other. The oldest instruments use RS-232, or a single wire that sends a high voltage followed by a low voltage, to indicate on or off. Newer NMEA-0183 devices us the RS-422 protocol, which uses two wires (a positive and a negative) that alternate between high and low to achieve the same effect, with greater accuracy and less chance for error. But the point is, both use 12 volts along their wires, and that will fry your Arduino if you plug it directly in.

EDIT 24 May, 2016: Apparently this is incorrect. 5V is the industry standard for RS-422, and 10V is the max voltage allowed for open circuits. See Max44's comments below the entry for more.

Recommended Gear

• Any NMEA-0183 device (such as the Airmar DST-800 Thru-Hull Triducer Smart Sensor)
• Arduino Mega (or any other Arduino)
• An RS-232 to TTL converter or...
• An RS-422/485 to TTL converter (not sure which one you need? See the next section)
• USB-A Cable (for the Arduino)
• Jumper Cables
• Header Pins
• Soldering Iron (don't forget the actual solder)
• Nylon Screws to mount everything
• Something to mount it all to

NMEA-0183: RS-232 or RS-422 or RS-485?

This part is really easy. If you have a single transmit wire from your device (most likely labeled TX or NMEA OUT or something like that), then it uses the RS-232 protocol, and you need the respective converter. If your device has two wires coming out (typically labeled NMEA OUT+ and NMEA OUT- or TX+ or TX-), then you have RS-422. What about RS-485? For our purposes, it's the same thing as RS-422. The difference is that with 485, you can connect a bunch of different devices that can all talk to each other, which is cool and all, but not applicable for our NMEA device. For our purposes, treat RS-485 the same as RS-422, since the protocal is identical (just RS-485 can support a lot more devices than RS-422, like on the order of 80 or so more).

Wiring Diagrams for NMEA-0183 and Arduino devices

There are way too many converters out there to cover them all, but I'll cover a few here. You are basically looking at a simple system: the NMEA-0183 device sends a signal to the converter (either a single wire or two), and that tones the signal down to 3-5V for the Arduino, and pipes that signal out to the input on the Arduino itself. For the most part, you don't need power since most NMEA-1083 devices require 12V, something the Arduino can't put out. So here are a few examples:

SparkFun MAX3232 Wiring Diagram (for RS-232)

NMEA-0183	MAX3232	ARDUINO
TX	T1 OUT
	R1 OUT	Receive Pin

SparkFun RS232 Shifter (No DB9) (for RS-232)

NMEA-0183	RS-232 Shifter	ARDUINO
TX	Pin 2 (right next to the square hole)
	TX-O	Receive Pin

RS-422/485 Shifter

NMEA-0183	RS-422/485 Shifter	ARDUINO
NMEA+	B
NMEA-	A
	VCC	5V
	GND	Ground
	RE	Ground
	RO	Receive Pin

It also goes without saying that you need to ensure your device is powered through the boat's electrical system. Now that we have our device physically connected, let's work through the code.

My super hi-tech test bed

The NMEA-0183 Arduino Library

Marten Laamer's has done a fantastic job building this useful and lightweight library. You'll need to download his library and check out his website over here first. There are hundreds of tutorials out there to get a GPS working (including some that come with the library), which is useful but pretty easy to figure out, so I'm going to show how to use his library to parse any NMEA sentence.

First, you must open up nmea.h and change this line

 #include "WConstants.h"  

to this

 #include "arduino.h"  

Then open up nmea.cpp and change this line

 #include "WProgram.h"  

to this

 #include "arduino.h"  

The most basic application is to receive an NMEA sentence, and then send it without doing anything. Here's a quick sketch for doing just that (remember, you must have the NMEA library included).

 #include <nmea.h>   
     
  NMEA nmeaDecoder(ALL);   
     
  void setup() {   
  Serial.begin(4800);   
  Serial2.begin(4800);   
  }   
     
  void loop() {   
  if (Serial2.available()) {                 // if something is incoming through the Serial Port
   if (nmeaDecoder.decode(Serial2.read())) { // if it's a valid NMEA sentence   
    Serial.println(nmeaDecoder.sentence());  // print it   
    }   
   }   
  }  

Pretty boring and basic. Here's what the Serial Monitor output looks like. So if you connect this to your chart plotter, this is what it will see. If you connect more than one instrument, then just include each "If Serial is Available" loop for each appropriate Serial Port.

If you have no clue what's going on, this basically scans the Serial port that we plugged our converter into (the Receiver Pin in the wiring diagrams above). We're using Serial Port 2 as our input for my DST-800, which is using the RS-422 converter. If you are using an RS-232 device (with only one NMEA Transmit wire), then you actually have to get a little more fancy because the converter inverts your signal. So if you are using an RS-422 device, and you're not getting good output, then maybe just swap the A and B wires and try again.

But you can't just do that with an RS-232 signal, since there's only one wire. So what you have to do is use the Software Serial Library. Here's a sample sketch that uses an RS-232 NMEA-0183 device.

 #include <SoftwareSerial.h>  
 #include <nmea.h>  
   
 SoftwareSerial nmeaSerial(10,11,true); // RX pin, TX pin (not used), and true means we invert the signal  
 NMEA nmeaDecoder(ALL);   
   
 void setup()  
 {  
  Serial.begin(4800);  
  nmeaSerial.begin(4800);  
 }  
   
 void loop()  
 {  
   if (nmeaSerial.available() > 0 ) {  
     if (nmeaDecoder.decode(nmeaSerial.read())) {  
     Serial.println(nmeaDecoder.sentence());  
    }  
   }
 }  

Note that this includes the SoftwareSerial Library. This is basically taking a Serial signal, and instead of plugging it into a Serial Port, we're plugging it into a digital pin and simulating a Serial Port. We have to do it this way because this is the only way to invert the Serial Signal on an Arduino. I suppose you could get another converter, and wire two of them together to invert the signal twice (ending with the original signal), but that's wholly unnecessary.

Something else to note with this is that I tried hooking up my wireless wind vane to it, but the signal kept getting garbled. Unfortunately, I don't know if it was the converter not doing it's job, or if it was the unit itself. It occasionally spat out a wind sentence, but it wasn't usable because it was one constant stream of meaningless characters interspersed with a valid sentence. I ended up returning the wind vane, and hopefully the next one works fine. But it DID put out valid sentences for the first week; so I know it works with the Max3232 converter.

But now let's get a little more complicated. Here's a sample sketch that parses the sentence, and allows you do manipulate it how you want. Then we reconstruct it as a valid sentence, including a checksum function. A huge thanks goes to Tom over at https://mechinations.wordpress.com/ for guiding me in the right direction for the sentence creation on an Arduino. I highly recommend you go over there to check out his cool stuff (especially this post).

 #include <nmea.h>  
   
 NMEA nmeaDecoder(ALL);  
   
 void setup() {  
  Serial.begin(4800);  
  Serial2.begin(4800);  
 }  
   
 void loop() {  
 if (Serial2.available()) {  
   if (nmeaDecoder.decode(Serial2.read())) {  // if we get a valid NMEA sentence  
     Serial.println(nmeaDecoder.sentence());  
     char* t0 = nmeaDecoder.term(0);  
     char* t1 = nmeaDecoder.term(1);  
     char* t2 = nmeaDecoder.term(2);  
     char* t3 = nmeaDecoder.term(3);  
     char* t4 = nmeaDecoder.term(4);  
     char* t5 = nmeaDecoder.term(5);  
     char* t6 = nmeaDecoder.term(6);  
     char* t7 = nmeaDecoder.term(7);  
     char* t8 = nmeaDecoder.term(8);  
     char* t9 = nmeaDecoder.term(9);  
     Serial.print("Term 0: ");  
     Serial.println(t0);  
     Serial.print("Term 1: ");  
     Serial.println(t1);  
     Serial.print("Term 2: ");  
     Serial.println(t2);  
     Serial.print("Term 3: ");  
     Serial.println(t3);  
     Serial.print("Term 4: ");  
     Serial.println(t4);  
     Serial.print("Term 5: ");  
     Serial.println(t5);  
     Serial.print("Term 6: ");  
     Serial.println(t6);  
     Serial.print("Term 7: ");  
     Serial.println(t7);  
     Serial.print("Term 8: ");  
     Serial.println(t8);  
     Serial.print("Term 9: ");  
     Serial.println(t9);  
     Serial.println("--------");  
     }  
   }  
 }  

And here's the output:

As you can see, we can extract different terms from the sentence quite easily, and manipulate them if need be (but be careful--if you don't redeclare each term, then it will reflect the previous sentence if the new sentence doesn't have one). For example, my DST-800 has a temperature sensor on it which gives out the YXMTW NMEA sentence, which is the Mean Temperature of the Water (the first two characters, "YX," are largely meaningless for NMEA-0183--they just designate the name of the device transmitting. You could put anything there and it would still work fine). A good place to start for NMEA sentences is this page here, and we see that the MTW sentence format is as follows:

          1  2  3   
          |  |  |   
  $--MTW,x.x,C*hh  
 1. Temperature  
 2. Units  
 3. Checksum  

In order to print our own NMEA sentence, we will also need the PString Library available over here. Let's go ahead and change that Fahrenheit, with the following sketch:

 #include <PString.h>  
 #include <nmea.h>  
   
 NMEA nmeaDecoder(ALL);  
   
 void setup() {  
  Serial.begin(4800);  
  Serial2.begin(4800);  
 }  
   
 // calculate checksum function (thanks to https://mechinations.wordpress.com)  
 byte checksum(char* str)   
 {  
   byte cs = 0;   
   for (unsigned int n = 1; n < strlen(str) - 1; n++)   
   {  
     cs ^= str[n];  
   }  
   return cs;  
 }  
   
 void loop() {  
 if (Serial2.available()) {  
   if (nmeaDecoder.decode(Serial2.read())) {  
     char* title = nmeaDecoder.term(0);  
     if (strcmp(title,"YXMTW") == 0) {            // only run the following code if the incoming sentence is MTW  
      Serial.println(nmeaDecoder.sentence());     // prints the original in Celsius  
      float degc = atof(nmeaDecoder.term(1));     // declares a float from a string  
      float degf = degc*1.8+32;                   // and converts it to F  
       
      // Time to assemble the sentence  
      char mtwSentence [18];                      // the MTW sentence can be up to 18 characters long  
      byte cst;  
      PString strt(mtwSentence, sizeof(mtwSentence));  
      strt.print("$YXMTW,");  
      strt.print(degf);  
      strt.print(",F*");  
      cst = checksum(mtwSentence);  
      if (cst < 0x10) strt.print('0');            // Arduino prints 0x007 as 7, 0x02B as 2B, so we add it now  
      strt.print(cst, HEX);  
      Serial.println(mtwSentence);  
     }  
    }  
   }  
 }  

And this is the output:

And there it is! We have parsed the sentence, converted it to Fahrenheit, and then printed out a new NMEA sentence. Pretty simple, right?

Final Thoughts on NMEA-0183 Devices and Arduino

This means we can do a lot of cool things, such as: convert our speed to miles per hour, or extract our latitude/longitude for any sort of application. Or even filter our wind speed using the MPU-9150. Or anything, really, and then make our own sentence with whatever data we want. This unlocks a huge amount of possibilities for chart plotting, sailing, and taking charge of your own sailboat.