Getting instruments from
different brands to talk.

Who are NMEA, anyway?

The initials nobody explains

National Marine Electronics Association.

They're a US trade body, founded in 1957 — a group of marine electronics dealers who met at the New York Boat Show and decided they'd get further working together than separately. Not a government agency, not a regulator. A members' organisation of manufacturers, dealers and installers.

Their useful contribution is standards. Before them, every manufacturer's gear spoke only to its own. NMEA got the industry to agree on a common language so a depth sounder from one company could feed a display from another. They published NMEA 0183 in 1983, NMEA 2000 around the turn of the century, and OneNet for ethernet since.

And the catch

The standards documents are sold, not published. You can buy them, and they are not cheap. For a hobbyist wanting to read their own boat's data, that's a wall — which is exactly the wall Kees Verruijt went around by reverse engineering NMEA 2000 from scratch and giving the result away.

So when you read a PGN on this page, you're reading it through one man's work rather than through the official document.

Three languages, three kinds of cable

Everything on a boat is one of these

Every argument about marine electronics compatibility comes down to which of those three a thing uses, and whether anyone has written down the format.

NMEA 0183 — the one you can read

1983, and still going

0183 is plain text. No decoding, no tooling. If you can see the wire, you can read the data.

$GPVTG,164.0,T,175.2,M,0.0,N,0.0,K,A
$WIMWV,274.1,R,11.7,N,A
$SDDBT,,f,,M,,F

Each line is a sentence. The first two letters after the $ say who is talking — GP is GPS, WI is wind, SD is a sounder. The next three say what kind of message it is. Then comma-separated fields, and a checksum on the end so the listener can tell if it arrived intact.

How it works: one device talks, and anything wired to it listens. That's the whole model. It's a one-way conversation down a pair of wires at 4,800 bits a second — about 40 sentences a second if you push it.

The catch: one talker per wire. Want your GPS heard by three things? You wire it to three things, or buy a multiplexer. It's slow, it's clumsy, and it is still on almost every boat afloat because it is dead simple and it never stops working.

Reading 0183, character by character

Every field in one sentence

Here's a real one off this boat. It scrolls past about forty times a second, which is why nobody ever stops to look at it:

$GPVTG,164.0,T,175.2,M,0.0,N,0.0,K,A*23

That's the whole design. A label saying who's talking, a label saying what kind of message, then comma-separated values where each number is followed by a letter telling you its units.

Another one, same rules

$WIMWV,274.1,R,11.7,N,A

WI = Weather Instruments. MWV = Wind Speed and Angle. Wind at 274.1°, R for Relative (apparent, not true), 11.7 knots, A for valid.

The checksum, which is cleverer than it looks

That *23 on the end is a two-digit hex number. To make it, the talker takes every character between the $ and the * and XORs them all together. The listener does the same sum and compares.

It costs almost nothing to compute and it catches the single-character corruption you get from a noisy wire on a boat. Forty-year-old engineering, still doing its job.

Talker IDs you'll actually see

And sentences worth recognising

Learn those and you can read most of what crosses an 0183 wire without looking anything up.

NMEA 2000 — the shared bus

A network instead of a wire per device

N2K fixed the one-talker problem. Everything hangs off one backbone and everything hears everything.

Underneath, it is CAN bus — the same technology your car uses to let the engine talk to the dashboard. 250 kilobits a second, shared by every instrument aboard. Messages are tiny: eight bytes at a time.

Here is the depth sounder on this boat, as it actually appears:

0DF50B05#FF19020000000099
|        |  |        |  |
|        |  |        |  +-- max range
|        |  |        +----- transducer offset
|        |  +-------------- 537 x 0.01 m = 17.6 ft
|        +----------------- sequence tag (unused)
+-------------------------- priority 3, PGN 128267, from device 5

That PGN — Parameter Group Number — is the key. 128267 means "water depth" on every N2K boat in the world, regardless of who built the sensor. 127250 is heading. 130306 is wind. It is a shared dictionary, and that is why a Garmin display can read a Airmar sensor.

And they really are all just cables

This part costs people money. Raymarine sell SeaTalkNG. Simrad and B&G sell SimNet. Furuno have CAN bus. They come in different colours with different plugs and they are sold as if they were different systems.

They are all NMEA 2000. Same two signal wires, same power pair, same 250 kbit CAN bus, same PGNs. What differs is the connector moulded on the end. An adapter cable — which every one of those manufacturers will happily sell you — makes them the same network, because they always were.

Reading NMEA 2000, bit by bit

The same depth message, taken apart

N2K isn't text, so you can't just look at it. But it's not complicated either — it's an address followed by eight bytes. Here's the depth sounder on this boat:

0DF50B05#FF19020000000099
\_______/ \______________/
  address      eight data bytes

The address, which is three things in one

That 0DF50B05 is a 29-bit CAN identifier, and it's packed with three separate pieces of information:

Work it the other way and it reassembles exactly: priority 3 shifted up 26 bits, plus PGN 128267 shifted up 8, plus source 5, gives 0x0DF50B05. That's the whole addressing scheme.

And the eight bytes

PGNs worth recognising

When eight bytes isn't enough

A CAN frame carries eight bytes and no more. Plenty of messages need more than that — a GNSS position fix with satellites and accuracy runs to dozens.

The answer is fast-packet: the sender chops the message into eight-byte pieces, numbers them, and the receiver glues them back together. It works, and it's a large part of why reading N2K properly is harder than it looks — and why a complete PGN database took one person years to build.

Ethernet — where the pictures go

Ordinary network cable, extraordinary secrecy

Radar and sonar imagery will not fit on NMEA 2000. Not even close. So manufacturers run a second network: plain ethernet, the same Cat5 cable as a home router.

On this boat the radar streams to one multicast address and the fishfinder to another. Any machine on that network can ask for a copy — which is exactly how our Raspberry Pi gets them.

The cable is standard. The connectors are standard. Only the format is secret, and only because nobody published it. That is the one real wall left, and it is made of paperwork rather than technology.

Which is why we sat down and read the bytes.

Eight bytes, or a hundred and fifty thousand

Why one is open and the other isn't

The depth number is eight bytes once a second, and it is open to everyone. The sonar picture is 150,000 bytes a second, and it is locked. That is not a conspiracy, it is arithmetic: one sonar channel is about five times the entire capacity of an NMEA 2000 network. It was never going to fit, so it never got standardised, so it never got opened.

One is eight bytes. The other is a hundred and fifty thousand. The small one fits on an open standard somebody reverse-engineered in an attic. The big one never did.

The decoding work in detail →

So what does open source actually buy you?

The reason any of this matters

A translator in the middle, that speaks all three and belongs to nobody.

On this boat that translator is Signal K, running on a Raspberry Pi. It reads 0183. It reads NMEA 2000. It listens on the ethernet. And it turns all of it into one common set of names that any program can ask for.

What that means in practice:

• A wind sensor from one brand feeding a display from another
• Old 0183 gear and modern N2K gear on the same screen
• Your radar drawn by three different programs, none of them written by the company that sold you the radar
• Your own instruments logged, alarmed and watched by software you can read and change
• And when the expensive box dies, something else still knows what is going on

None of this requires throwing away your marine electronics. We run Raymarine gear and we are glad of it. The open-source layer sits alongside, reads the same wires, and removes the part where one company decides what your own data is allowed to do.

Signal K OpenPlotter Who built all this →