Hardware

Monitor

Like I mentioned, I have a Raspberry Pi 4B connected to a small 7" HDMI touch screen. I won't cover connecting the monitor - it's pretty straight forward and you likely have different hardware anyway, but here's a link to buy one that I thought was decent. https://www.amazon.com/dp/B07VNX4ZWY/?th=1 

The monitor above isn't sunlight readable, so you may want to consider buying one from MakerPlane. Theirs is smaller, but brighter:
https://store.makerplane.org/5-sunlight-readable-touchscreen-hdmi-display-for-raspberry-pi/ 

SD Card

I used a SanDisk 16GB Ultra microSDHC UHS-I Memory Card. 16GB should be plenty for this, but feel free to buy something larger. After installing everything, I only used about half of the microSD card's capacity:
https://www.amazon.com/dp/B073K14CVB?th=1

SD Card Reader

You'll also need a USB Flash Memory Card Adapter. This is the one I bought about five years ago. It plugs into a USB port on your computer and can accommodate either a full-size or microSD card. It works really well and is cheap:
https://www.amazon.com/dp/B0779V61XB 

Raspbian Operating System

The first thing to do is to install the Raspbian Operating System on your microSD card. Raspberry Pi has a handy tool called the Raspberry Pi Imager:
https://www.raspberrypi.com/software/

The RPi Imager software makes it super easy to get everything installed and ready. It will automatically download your favorite OS image and it even allows you to do some configuration before-hand (e.g. turn on SSH or VNC) so you don't have to do anything but put the microSD card into your RPi and turn it on to get started.

To start: 

• open Raspberry Pi Imager

• Select your Raspberry Pi Device (a Raspberry Pi 4 in my case, but maybe you have another board)

• Select the Operating System you want to install. Typically you'll just want to select the one at the top of the list (that's the latest release)

• Plug in your SD card reader and click on the Storage button to select it. In my case, it was called Generic MassStorageClass USB Device - 15.9 GB

• Then click Next

You'll be asked Would you like to apply OS customization settings?

Select EDIT SETTINGS

This is how I configured mine (I only changed stuff on the GENERAL tab and the SERVICES tab). Obviously, you should remember your username/password combination and configure things for your own network and locale. Click SAVE when you're done with your custom configuration. 

I like to have a backdoor into the pi, so I enable SSH. SSH stands for Secure SHell and it allows you to use a terminal:

• click the YES button to apply the settings to your microSD Card.

• click YES again to acknowledge that you plan to delete everything on the microSD Card 

As soon as you click the second YES, the process will start start the process of erasing/imaging your microSD Card. On my Windows 10 computer, I was prompted by Windows to select a drive. Ignore this - RPi Imager has just erased the microSD card, unmounted and remounted it. Windows is just recognized it as a new device, but RPi Imager is already applying the new image in the background.

When prompted, remove the microSD card, insert it into your RPi and power the RPi on. It should automatically connect to your WiFi network and it will prompt you to let you know what your IP address is. 

Remote Control of Your Raspberry Pi

Remember how we set up SSH? Well, you can use it to connect to your RPi over your network. Open a command prompt on your Windows computer and type (or whatever you set as a username and host name in the OS Customization tab above) and press Enter:

ssh pi@makerplane.local

You'll be prompted to  enter a password. You won't see text as you type ... just trust that you're entering it and press enter. If it works, you'll get a command prompt that says:
pi@makerplane:~$ 

(or whatever your username/hostname was set to)

Now we'll use a special configuration tool that comes installed on Rasbian called raspi-config. 

pi@makerplane:~$ sudo raspi-config

Note that the sudo portion of that command gives you admin permissions when you run the command. If you don't add it, the Pi will complain that you don't have admin permissions.

raspi-config is a text-based graphical configuration tool that allows you to easily turn on or off configurations. You will use the arrow keys on your keyboard to move between menus. And you can press Esc to cancel the current screen (e.g. go back to the previous screen).

VNC Remote Control

One of the things I like to do is enable a VNC Server on the Raspberry Pi. With some software installed on your computer, you can remote control the Pi over your network. You can enable VNC using raspi-config. Using your arrow keys, select the following options in raspi-config: 

• 3. Interface Options 

• I3 VNC

• <YES>

• <OK>

• Esc (or you can use the arrows to select <Finish> if you prefer)

If you do everything correctly, you'll be notified that the VNC Server is Enabled. 

Now that you have the VNC server running on your Pi, you'll want to install the VNC Viewer software on the computer you want to remote control the Pi from. 

There are a few VNC client software options out there. This one from RealVNC is free and it works pretty well:
https://www.realvnc.com/en/connect/download/viewer/

Just download the one that matches your system (e.g. Windows or Linux or Mac or whatever) and install it. Then open it.

In the address bar at the top enter makerplane.local (or whatever you set your hostname to be above) and press Enter.

The VNC Viewer software will fire up a remote control session with the Pi and prompt you for your credentials (which you also set above). I like to save my password so I don't have to type it every time I open a VNC session. Press OK and a remote control window will open.

At this point, you have two options for entering the commands below to complete the set up of your MakerPlane FiXGateway and pyEFIS installation:

1. You can continue to use the SSH tool that you have open on your Windows computer. That is perfectly acceptable (and I actually prefer to do it that way). 

2. However, if you like to control the RPi directly, you can use VNC to remote control the Pi where you can click the terminal icon in the menu at the top (notice the red square around the shortcut in the image above). 

I personally prefer option 1 because once you install and configure the pyEFIS software, it will start automatically and cover the entire screen (including the shortcuts in the menu bar) and it's a little hard to get to a terminal window. Using SSH from your computer instead, you can run terminal commands that way without fighting pyEFIS. 

Before installing the MakerPlane software, you will want to get the latest updates for your Raspberry Pi. Do this from the terminal window on the Pi or using SSH from your Windows computer (this is the last time I'll mention this - you can run the commands below from either location):

$ sudo apt update
$ sudo apt dist-upgrade -y
$ sudo reboot

That last command will, obviously, reboot the RPi, which will disconnect your VNC and/or SSH sessions. You can just reconnect when it's done rebooting.

Installing MakerPlane Software

Now that you have your RPi updated, it's time to start installing the software and configuring it for use. I followed this tutorial on the MakerPlane github repository. It was a little hard to find, so this should make it easier to follow along:
https://github.com/makerplane/pyEfis/blob/master/INSTALLING.md 

Run the following commands (note that they may take a few minutes each to complete - be patient):

$ sudo apt install -y snapd
$ sudo snap set system experimental.hotplug=true
$ sudo snap set system experimental.user-daemons=true

That's as far as we can go without a reboot:
$ sudo reboot

When it comes back up, continue:
$ sudo snap install core
$ sudo snap install fixgateway
$ sudo snap install pyefis

At this point, pyEFIS will start up and will take over your entire screen. This is not a problem if you're using SSH from your Windows computer. You can still run commands from there.

CAN Bus Configuration

If you want to use CAN, you ... uh ... can. This won't go into detail about pushing CAN data out to the CAN Bus network. But assuming you already have that happening, this is how you set up your RPi to consume it:

You will need a USB CAN Bus module - I have tested a couple of them that work out of the box:

• https://www.amazon.com/dp/B0956NV6CM - ~$33

• https://www.amazon.com/dp/B0CRB8KXWL - ~$18

This second one is a little cheaper and seems to work just fine. If you plan to make your own CAN bus board using DB-9 connectors, the first one is probably a better option for that.

When you plug it your USB CAN module, nothing really happens. That's because you need to enable CAN Bus functionality on your Pi. 

Install can-utils (which includes all the drivers for the USB CAN module and the candump command that we'll get to below): 

$ sudo apt install can-utils

Connect your CAN module to the CAN network. E.g. the GND, CAN-H, and CAN-L cables need to be wired to at least one other CAN module with the same wires and the other device needs to be outputting properly formatted data over those wires. 

At this point, you probably won't see anything, but try the candump command to see if your CAN module is set up correctly. (hint: it probably isn't - we'll use this command more below)

$ candump can0

When that doesn't work, you will likely need to tell the Linux Kernel to load the CAN module:

$ sudo modprobe can
$ ip link show

The first command tells the Linux Kernel to load the CAN module and the second command will output all of the various networking devices on the computer. One of those devices should be "can0."

Now you'll likely need to actually set up and start up the device. Note: I added some instructions to make this happen automatically on reboot farther down in this document - just test it for now by running these two commands. The first one sets the parameter for the USB CAN module (e.g. configure "can0" to act as a "can" device and run at "250000" bits per second). The second command tells "can0" to start running based on how you configured it in the first command. Note that whatever is spitting out CAN data on your little network has to be running at the same bitrate for them to communicate properly:

$ sudo ip link set can0 type can bitrate 250000
$ ip link set up can0

Provided you have another device pushing data over the CAN network, you should see lights start flashing on your CAN module now as the data starts flowing over it. Try to see the data again with candump:

$ candump can0

This time a bunch of data should start appearing in the terminal. Each of the lines in the image below represents a single CAN message coming across the CAN bus. In this case, I had a little project I made that pulls Attitude data from a SpeedyBee F405 Wing RC Flight Controller and converts it to MakerPlane CAN messages (based on the MakerPlane CAN-FiX standard):

https://github.com/danderflieger/AHRS_SB_F405-Adafruit_Feather_M4_CAN  

Below you can see three messages repeated over and over: 180, 181, and 185. Those message types are expressed in Hexadecimal. When converted to decimals, those values are 384, 385, and 390. 

The three message types are defined as Pitch Angle, Roll Angle, and Heading (respectively) in the CAN-FiX standard. 

So each message will tell pyEFIS to move the Attitude Indicator in the pitch and roll axes, and the Heading Indicator to move according to the heading values.

Automatically Starting the CAN Module

If you want to make sure that the CAN module starts automatically on reboot, you can set up a Linux service. A Linux service runs in the background and is ready for use whenever it's running.

First, create a new file called can0.service in the /etc/systemd/system folder, using the terminal-based text editor called nano. You'll notice that we have to edit this file using elevated privileges (sudo) because the location where you need to save the file is a protected area (it's meant to prevent just anyone from enabling a background service on a Linux computer). 

Type this command to create and open this new file in nano:

$ sudo nano /etc/systemd/system/can0.service

Unless you've already done this (e.g. created a file called can0.service), nano will open with a blank file. Copy and paste (or type) this text verbatim into the new file:

[Unit]

Description=Setup SocketCAN interface can0 with a baudrate of 250000

[Service]

Type=oneshot

RemainAfterExit=yes

ExecStartPre=/sbin/ip link set can0 type can bitrate 250000

ExecStart=/sbin/ip link set can0 up

ExecStop=/sbin/ip link set can0 down

[Install]

WantedBy=default.target

Press Ctrl+x and then y to save the file and exit nano.

BAM!! You have created a Linux service. But it won't be enabled until you tell the operating system to do so, which you'll want to have happen whenever the Pi starts.

This command tells Linux to look in where the system service files are located and read all of them (including your new file) so it knows your new service exists - run this first:

$ sudo systemctl daemon-reload

Next, run this command to will enable the new service to run when the RPi starts up:

$ sudo systemctl enable can0.service

And finally, start the service so it starts running immediately rather than waiting for a restart:
$ sudo systemctl start can0.service

To stop it (in case you need to for some reason):

$ sudo systemctl stop can0.service

That should be it. When you restart your Pi, the CAN bus module should start up automatically and then pyefis should start up automatically as well. And if you have a CAN enabled sensor spewing out MakerPlane formatted CAN messages, fixgw will receive it and pyefis should start displaying the data.

Well ... almost ... see the next section.

Configuring pyEFIS/FIX-GW

By default, pyEFIS (and the underlying messaging bridge called FiX-Gateway) will spew out a bunch of mock data that changes things on the pyEFIS screen. 

This is called demo mode and FiX-GW is where the demo data (or whatever other type of data) comes from. To turn off demo mode, you need to edit a config file. 

Make sure you're editing the preferences.yaml.custom file. There is also a preferences.yaml (notice it's missing the .custom extension at the end of the file name) that you DO NOT want to edit.

$ nano makerplane/fixgw/config/preferences.yaml.custom

Copy/Paste this text into the file (note that it must look EXACTLY like this - spaces matter in YAML files, so there are two spaces in front of each of the third through sixth lines and NO spaces before the first two lines):

# This section is used to turn things on or off
enabled:
  AUTO_START: true
  CANFIX: true
  QUORUM: false
  DEMO: false

The AUTO_START: true line tells fixgw to start automatically when the RPi restarts. The CANFIX: true line tells fixgw to listen to CANFIX messages. I'm not 100% sure what the QUORUM: false line does. DEMO: false is turning off the default demo mode.

Next, you'll need to edit the CAN connection configuration for fixgw.

$ cd
$ nano ~/makerplane/fixgw/config/connections/canfix.yaml 

About line #7 it says:

  channel: vcan0

Change that setting to use can0 instead of vcan0. 

  channel: can0  

Remember: spaces matter in yaml files, so make sure the same number of spaces (2) precede that line!

Press Ctrl+x, y, Enter to save your changes. Then reboot and you should be good to go.

$ sudo reboot