- Also look at this summary.
We will be setting up a Raspberry Pi Zero W with an e-ink 2.13" bonnet.
As you would see below, this is just an example of configuration, used to explain the way it goes. Several other configurations are available, using the same process and guidelines.
The e-ink technology is quite interesting here, in the sense that it consumes energy only when updating the screen. Once something
is displayed on the screen, you can pull the plug, whatever's displayed remains displayed.
As you would see below, there is a web interface that can be used to see - among others - the data displayed on the screen.
But having the screen allows you not to use any other device to get to the data.
In the use-case presented here, the NMEA-multiplexer will:
- Read a GPS
- Log the data into a file
- Display the data on the e-ink screen
- The two buttons on the screen's bonnet can be used to scroll through the available data
- Broadcast the data on TCP:7001
- Host Web Pages to display the data, manage the system, manage the log files.
The server (aka Mux) will be automatically started when the Raspberry Pi boots. In this example,
the multiplexer is driven by the configuration file nmea.mux.gps.nmea-fwd.yaml.
Reminder : The
serveris a component that can
- Create its own hotspot network
- For details, see the scripts like
rc.local.ssd1306.gps.sh,connect-network.sh,disable-hotspot.sh- Read the NMEA flow and manage the data (transform, forward, log, etc)
- Serve static HTML requests (HTML, JS, CSS, images, etc)
- Serve REST requests
Some already existing components can already fulfill this kind of needs, the reason why it's been re-written (from scratch) is to make it as small as possible (in disk space, and memory footprint). As it is, it is not 100% J2EE compliant but it is good enough for the current purpose. In addition, it can read all the static resources mentioned above from a zip file. This considerably reduces - again - the required disk space.
Many user interfaces (if not all) are written in HTML and related technologies. They use absolutely NO external libraries. All you need to display the UI is a (recent) browser, compatible with HTML5, ES6, and CSS3. There is absolutely nothing else to install.
The server creates its own network, but again, Internet is not required.
We do the build on one machine, where the git repo has been cloned, and we deploy on the Raspberry Pi
only the parts required at runtime.
The build is a demanding operation, the Raspberry Pi Zero could do it, but it would indeed take quite some time.
A more powerful machine is more suitable for this kind of process.
The process goes in two main big steps (also summarized here).
- Step One: you clone this repo, do the build, and package for deployment.
- This step requires a bit more resources than the next one.
- You will need an Internet connection, a keyboard and a screen.
- Step Two: you setup the Raspberry Pi, and make it ready for duty.
- You start from a freshly flashed SD card, setup the system to emit its own network, install the required softwares and configure them.
- Configuration steps will require an Internet connection.
- Once the configuration is completed, the Internet connection is not required anymore,
sshandscpwill do the job.- Note:
VNCcould also be an option to access the Graphical Desktop running on the Raspberry Pi. But this could be too demanding for a Raspberry Pi Zero (but it works)... To enable it, useraspi-configon the Raspberry Pi, to boot to Desktop, and start the VNC Server.
- Note:
-
Use Raspberry Pi imager to flash a new SD Card.
- Warning: Use
bookworm, nottrixie, for JDK compatibility reasons - Make sure
SSHis enabled (it's a setting parameter in the Raspberry Pi imager). - Create a user named
pi(this is the name we use below, choose your own if you want to) - Choose the version matching the Raspberry Pi you want to run on (A, A+, Zero, 2, 3, 4, 5, etc)
-
and do make sure you boot the first time on the right machine!!
Starting an A+ SDCard on an RPi-5 could put you in trouble (when moving back to A+)...
- Warning: Use
-
Use the script
./to.prod.shto package the current software. This step happens on the machine you've cloned the repo on.- The script can take a CLI parameter with 2 options:
--basic, basic config--big, more REST request managers, more options
- Warning: For the build, do make sure you use a JDK (Java Development Kit) compatible with your target!
If you've installed a JDK8 (see below) on the Raspberry Pi, do the build with a JDK of the same version!
Using a JDK11 for the build will not work at runtime on a JDK8. - Make sure you package the Python part as well, when prompted.
- This will prepare a
tar.gzarchive, called - for example -nmea-dist.tar.gz(you choose the namenmea-distduring the build process). - Send the archive to the newly flashed Raspberry Pi (change its IP address at will)
scp nmea-dist.tar.gz pi@192.168.1.15:~
wherenmea-distis a name chosen by you during the execution of theto.prod.shscript,piis the username you chose too, and192.168.1.15is the IP Address of the Raspberry Pi, obtained with anifconfigon the Raspberry Pi, or afingon any machine on the same network as the Raspberry Pi.
- The script can take a CLI parameter with 2 options:
-
Log on to the new Raspberry Pi, to prepare the new system. This will require an Internet connection.
- Using
sudo raspi-config(or its desktop equivalent,Preferences>Raspberry Pi Configuration):- Boot to Command Line Interface (CLI), Desktop is not required.
- Make sure
SSHis enabled. - Enable interfaces
SPI,I2C,Serial Port
- Install Java and other required parts
sudo apt-get update # sudo apt-get install openjdk-8-jdk-headlessJDK8 will work on any Raspberry Pi I know.
Some Raspberry Pi Zero W would not support JDK11, but as long as you know what you're doing, you can install it using:sudo apt-get install openjdk-11-jdksudo apt install default-jre-headless sudo apt install default-jdkBut be careful, some jdk version might not be compatible with the build (Gradle 7).
If JDK 11 cannot be installed, you might want to downgrade the version of the OS (like fromtrixietobookworm).- LibRxTx (optional, skip it if you don't know it)
sudo apt-get install librxtx-java- Install required Python modules (if any), like here, for example (for the e-ink bonnet)
sudo pip3 install adafruit-circuitpython-epd - Using
Alternatively, in the tar.gz, there is a python/scripts/install.all.sh that does it (and more) for you.
Depending on the Python servers you need, do look into the specific code to see what to install with pip3...
The above is here for the e-ink bonnet. That would be another one for a SSD1306 (for example).
- Setup Hotspot (if needed), as explained here.
- Expand the archive, using a command like
tar -xzvf nmea-dist.tar.gz - Modify the
/etc/rc.localto start the server when the server boots, and issue the required command (links, maps, stty, etc). There is an example inrc.local.use_case.3.sh. - Plug in the GPS and the e-ink screen, and give it a try (see for example the script
start.all.sh, used as below) - Try the web interface
- From a browser on another machine (laptop, cell-phone, tablet, ...), connected on the Raspberry Pi's network, reach
http://192.168.50.10:9999/zip/index.html, and see for yourself! - Again, the code of the Web UI is not carved in stone, they're all examples (including the admin pages), suggesting what can be done. Do feel free to come up with your own pages!
- From a browser on another machine (laptop, cell-phone, tablet, ...), connected on the Raspberry Pi's network, reach
Now, you're good to go, the Raspberry Pi should not need an Internet connection anymore.
A first test can be done, using start.all.sh.
$ ./start.all.sh
For EINK2-13 (default)
$ ./start.all.sh EINK2-13
For BME280-SSD
$ ./start.all.sh BME280-SSD
etc...
Look at the start.all.sh script for details, you can also do a ./start.all.sh --help.
About the modification of the /etc/rc.local script, to start the
required components when the machine boots,
here are the lines to add to the file, before the exit statement at the end:
#!/bin/bash
. . .
#
# "Link" the Serial Port
stty -F /dev/ttyACM0 raw 4800 cs8 clocal
#
# Start MUX and Co on startup
#
# Start the REST Server for EINK2-13
/home/pi/nmea-dist/python/scripts/start.EINK2-13.REST.server.sh --interactive:false --machine-name:localhost --port:8080 --verbose:false --data:NAV,POS,SOG,COG --screen-saver:on > /home/pi/nmea-dist/eink2-13.python.log 2>&1
sleep 10
# Start the MUX
cd /home/pi/nmea-dist
nohup ./mux.sh nmea.mux.gps.nmea-fwd.yaml &
#
. . .
exit 0
As you can tell: it starts the Python server that takes care of the e-ink display, and
starts the mux with the config file nmea.mux.gps.nmea-fwd.yaml, provided here.
Make sure the /etc/rc.local is executable.
Again, the system is now operational, and can be re-booted.
Note: There are other ways to do the same. You invoke the starting script from
/etc/rc.local.... . . pushd /home/pi/nmea-dist ./start.all.sh SSD1306 popd . . . exit 0
Warning: The data read from the GPS are logged into some log-files. Make sure you download and delete them from time to time...,
before they get too big (triggering the message "No space left on device"...). There is a Web page for that (in the embarked Web UI), called "Log Management".
Note: For the log-files not to grow too big, we've excluded some strings from the log, see in the yaml config file:
sentence.filters: ~GGA,~GSV,~GSAThis excludes the sentences concerning the GPS satellites from the log files. They're still available in the cache tough, and can be displayed in some Web UI packaged in the archive we've generated.
You can use the find.port.sh script, to find the serial port name of your GPS, and then (assuming that the port name is /dev/ttyACM0):
$ stty -F /dev/ttyACM0 raw 4800 cs8 clocal
$ cat /dev/ttyACM0
or, if you want to see only some sentences, and log them into a file:
$ stty -F /dev/ttyACM0 raw 4800 cs8 clocal
$ cat /dev/ttyACM0 | grep -e "RMC" -e "GLL" -e "VTG" >> data.log
STL files available from another repo, here, and
here, along with the OpenSCAD code to generate them.
![]() |
![]() |
| In its box | Connected (Power, GPS) |
![]() |
![]() |
| Up and Running | Closed |
![]() |
![]() |
| Hanging (with brackets) | Hanging (with brackets) |
![]() |
![]() |
| Phone UI (the pelican is the screen saver...) | Phone UI |
![]() |
|
| Solar powered |
- Other STL files, including a power bank, instead of an external power supply, can be found here.
For the phone UI: the phone is connected to the RPi's network, URL in the browser is http://192.168.50.10:9999/zip/index.html
Note: The phone does not need to have a SIM card.
Connected from OpenCPN through TCP, from a laptop:

When a graphical user interface is needed, we use web pages. All you need
to see them is a (recent) browser. No need to worry about the operating system of the client you use (Android, iPhone, etc), nor about the type of device (laptop, tablet, cell-phone, etc).
The Web pages presented (and packaged) here require absolutely NO external framework.
ALL the graphical user-interfaces are provided as web pages (HTML5, ES6, CSS3). That means that if you have a browser
on the devices you want to use (laptops, tablets, cell-phones), there is absolutely NOTHING else you need. Once you're connected on
the network emitted by the Raspberry Pi, you're good to go.
There is an index.html, accessible for example from http://192.168.50.10:9999/zip/index.html, that gathers
several examples you can use. This includes admin pages, and log files management as well.
Again, those are only examples, intending to demonstrate what can be done.
It also uses several WebComponents (a W3C standard), their source code is here too.
Nothing carved in stone. And this is Open Source. Everything is here, but nothing more. Feel free to contribute!
Among many others, we've introduced this concept of Chartless Maps.
The idea is to prepare your own - light - cartography before leaving, with some dedicated UI. You can define
markers, borders, way-points, etc..., stored in some data files you can then refer to in the Mux's config.
All this support proximity detection, waypoint calculation, and all this kind of things.
The idea is to know where you are on this chartless map, and when a proximity is detected, then you go
back to your paper charts!
From a laptop, tablet, or cell-phone, Web UI (100% hosted on the Raspberry Pi):

Exiting Étel
You can define all kind of borders, markers, way-points...
Chartless maps (borders, markers, waypoints, ...) can be dynamically managed from the Admin UI

Once data have been logged, they can be merged and cleaned with scripts like log.merge.deep.sh and its neighbors, and log.to.json.sh...
Data can be re-played from several web UIs. See in ROB/raspberry-sailor/MUX-implementations/MISCSamples/LeafLetAnalysis for examples.
The web UI is customizable at will. Above is examples of the ChartlessMap WebComponent.
In case this is good enough for you, the e-ink screen can become optional.
And as soon as you have a configuration that fits your needs, do make a backup of your SD card... When you need it,
this is the kind of things you might regret not to have done. For the backup of your SD Card, use
a tool depending on the system you do the backup from, like this one if you're on Mac.
Also see here.
It comes with many web components and examples.

The two ones below have been added recently. Sailing at night, I was wondering
"What is this star ahead of us?". Those components answer the question 😉.



Small boards that can be wifi-aware can connect to the network emitted by the Raspberry Pi (Huzzah, M5Stick, Arduino, etc, the list is long), using REST or other standard protocols.
| Server | M5Stick Client |
|---|---|
![]() |
![]() |
Details on those small boards can be found at https://github.com/OlivierLD/small-boards/.
For the M5Stick featured above, see https://github.com/OlivierLD/small-boards/tree/master/M5StickC, and the code
itself is here. That would give you an idea.
The M5Stick is quite affordable (less than $10.00 in 2025), see here.
Measured consumption for the config above (with an e-ink bonnet):
Between
0.18 Aand0.24 A
When building the SD Card, you enabled ssh, this allows you to use ssh and scp from another machine connected on the same network (the one emitted by the Raspberry Pi).
$ ssh pi@192.168.50.10
Similarly, as already mentioned above, you can also use VNC.
You need - using sudo raspi-config from the command line - to enable VNC, and make sure you boot to a graphical desktop (not to the command line).
Once done, you can use a VNC-viewer from another machine, and see the Raspberry Pi's desktop !

So, you now have a system that starts at boot.
The Raspberry Pi emits its own network, so you can connect to it from other machines or devices,
using ssh, scp, or just http and tcp.
Note: There is a network, but no Internet.
This is not Cloud Computing..., maybe more like "Flake" ❄️ Computing. Very low carbon footprint! The consumption of the setting described above is below ridiculous. I power mine with a solar panel, it's happy as a clam!
A power bank, or a USB Adapter in a 12v cigarette lighter do the job as well.
Current data are displayed on the e-ink screen (basic UI).
It comes with a Web UI, to help you to manage the system, and/or visualize the data (using plain http, as mentioned above).
It also broadcasts the data on tcp, port 7001, so other software can use them, like OpenCPN, SeaWi, etc.
Data are logged into some files, so you can analyze, transform (to GPX, KML, etc) or replay them.
And as no one is going to sell your personal data behind your back, the Web UI does not require any cookie.
With this configuration, we have a multiplexer - written in Java - interacting with one or more sensors (like BME280, push buttons)
and actuators (like eInk or OLED screens). Technically, we have several servers - potentially written in different languages (Java, Python, C, etc).
As long as those languages can deal with standard protocols (like TCP, HTTP, etc), there is no problem.
The screens in this case act like the displays you'd have on board, at the chart table or in the cockpit.
It's like those buses we are used to. The multiplexer makes the data circulate around the bus,
and the display is choosing what to show. It receives all the data, and knows what to display, and how.
Note: An
nmea-cache-publisher(used from the MUX to send data to the server(s) managing the actuators) can be seen as an NMEA bus. The full NMEA-cache would be sent to it, and it would decide what to do (to display) with it, based on a user's decision/action (taken here with button-clicks).
As far as I know, there is no standard for such a content. We use an arbitraryjsonstructure here, examples are available all around.
Raspberry Pi Zero WH, with an OLED screen, 2 buttons, and a Lipo battery:
![]() |
![]() |
![]() |
| Ready to start | Power on! | With the foam |
Raspberry Pi A+, with an OLED Screen, a BME280 (ATM pressure, Humidity, Air Temp), 2 buttons:
![]() |
![]() |
| Ready... | En route ! |
Notice on the configs above, that 2 push-buttons have been added. This was not necessary before, as the EInk screen we mentioned did indeed
have those 2 buttons. Some screens come with even more buttons, or joysticks.
This actually triggers a very interesting question:
Beside the screen, what is the minimal config for a user to be able to interact with a given software?
One button? Two buttons?
Buttons can support click, double-click, long-click...
That would deserve some brainstorming, right? 🤪
But that would not be wasted!
Again, once you have a configuration that fits you, do make a backup of your SD Card !
This way, you can restore it in no time in case something goes wrong...
- e-ink bonnet, $19.95 (Aug-2023)
- Raspberry Pi Zero W, $16.00 (Aug-2023). This one has WiFi capabilities, it does not require an extra WiFi dongle.
- GPS Dongle, $11.99 (Aug-2023)
The price of the config described here comes to $47.94.
Note: It could be even simpler - and cheaper. The e-ink bonnet is an option. In any case, the system is logging data (in a file), forwarding them (on tcp), and there is a Web interface available through http.
The Python part is not necessary if the e-ink screen is not in the picture.
Without the e-ink screen, the price comes down to $27.99.
Price of the wires and SD card is not included here. I know.
But still 😜.


















