Category: Software Development

In this part of the Meshtastic with Raspberry Pi (Serial) series, we will be writing some code to test the connection, then adding to our code to send sample data. When sending data, we will format the message to allow us to reject data if it is not formatted correctly and do some simple error detection.

A good resource, which will be used to write this code may be found on the “Raspberry Pi UART Communication using Python and C” page on the ElectronicWings site.

Preparation

You need to start off by editing the cmdline.txt file to remove the console=serial0,115400 argument and value. If you don’t do this, you will see errors similar to ‘device reports readiness to read but returned no data’. More information and background is available at https://raspberrypi.stackexchange.com/questions/111817/serial-serialutil-serialexception-device-reports-readiness-to-read-but-returned

On the Raspberry Pi, open a terminal window or use PuTTY to run the following command.
sudo nano /boot/cmdline.txt

Comment out or delete the “console=serial0,115400” in the line.

Once the cmdline.txt has been modified, restart the Raspberry Pi.

NOTES: If the console=serial0,115400 is missing, you skipped enabling the serial port from the raspi-config tool. Look back at the earlier posts in this series for instructions on how to enable the serial port. It is also possible that the baud rate in the command is something other than 115400 so you may see a different baud rate, which is fine, but you will need to remove that argument from the file.

Test Program

Now that the serial port is properly configured, we can write a simple program and test the T-Beam connection to the Raspberry Pi. On both Raspberry Pi boards, create a uart.py file with the following code.

'''
UART communication on Raspberry Pi using Python
http://www.electronicwings.com
'''
import serial
from time import sleep

ser = serial.Serial ("/dev/ttyS0", 38400)    #Open port with baud rate
while True:
    raw_data = ser.read()              #read serial port
    sleep(0.03)
    if raw_data:
        data_len = ser.inWaiting()
        raw_data += ser.read(data_len)              #read serial port
        received_data = str(raw_data, "utf-8")
        print (received_data)                   #print received data

The code will listen for data on the serial port and will print the received data in the terminal window. Run the code on both Raspberry Pi boards by typing the following command.
sudo python uart.py

On the Android device, open the Meshtastic application and type a message and press the send button.

The message will be displayed in the terminal window of the receiving Raspberry Pi device.

Sample code sending and receiving data

Before using the following example, it is suggested to change the serial configuration to “Simple” and creating an additional channel named “serial”. Screenshots were taken of the Meshtastic application and placed into a Google Album. Refer to the album if you have any questions regarding what configuration values were used for this example.

The sample code will send CPU Temperature data twice per minute. Below are a few notes/requirements.

• The data will be sent as JSON.
• The data will be contained in a Python Dictionary with string values for the keys.
  Sample keys:
  • t: Time in UTC ISO 8601 format without milliseconds
  • nam: The host name of the Raspberry Pi
  • cput: CPU Temperature in degrees Celsius
• Float values will be sent as formatted strings with the precession required for the application. As an example, temperature will be sent with two decimal values.
• The total length of the message shall not exceed 200 bytes. In practice, it should be kept well below 200 bytes. This requires that the keys for the key value pairs to be kept short.

Example Code:

The following example code was written to meet the above requirements.

'''
- References -
--------------
ISO 8601
    https://pynative.com/python-iso-8601-datetime/
UART communication on Raspberry Pi using Pyhton
    http://www.electronicwings.com
'''

import serial
import time
from datetime import datetime, timezone
import re
import socket
import json

def get_temp():
    with open('/sys/class/thermal/thermal_zone0/temp', 'r') as infile:
        return float(infile.read()) * 1e-3

# Open port with baud rate
ser = serial.Serial("/dev/ttyS0", 38400)
# Set the start time in the past so that the first data point will be sent at the startF
start = time.time() - 600
# Create a variable for the received data.
received_data = ""
# Flag for knowning if the error for T-Beam being disconnected has been displayed
no_serial = False

try:
    while True:
        data_len = 0
        data_len = ser.in_waiting
        utc_dt = datetime.now(timezone.utc).replace(microsecond=0)

        if data_len > 0:
            raw_data = ser.read(data_len)  # read serial port
            try:
                received_data += str(raw_data, "utf-8")
                x = re.search("\{.*\}", received_data)
                if x:
                    # PuTTY changes tab characters to spaces so we will use the pipe symbol
                    # print(F"{utc_dt.isoformat()}\tRECV\t{x[0]}")
                    print(F"{utc_dt.isoformat()}|RECV|{x[0]}")
                    received_data = ""
                if no_serial:
                    no_serial = False
            except UnicodeDecodeError:
                received_data = ""
                if not no_serial:
                    print("ERROR: The serial connection may be down")
                    no_serial = True

        if time.time() - start > 30:
            start = time.time()
            temp = get_temp()
            dat = {
                "t": utc_dt.isoformat(),
                "nam": socket.gethostname(),
                "cput": F"{temp:0.2f}",
            }
            if len(json.dumps(dat)) < 200:
                ser.write(bytes(json.dumps(dat), "utf-8"))
                # PuTTY changes tab characters to spaces so we will use the pipe symbol
                # print(F"{utc_dt.isoformat()}\tSENT\t{json.dumps(dat)}")
                print(F"{utc_dt.isoformat()}|SENT|{json.dumps(dat)}")
            else:
                print(
                    F"ERROR: Data length is greater than 200 bytes (length={len(json.dumps(dat))})")

except KeyboardInterrupt:
    print("\r\nExiting")
# finally:
#   GPIO.cleanup()

Below is the output from both Raspberry Pi boards running the code with the same T-Beam Meshtastic settings.

An Excel workbook was put together to check the delay from transmit and receive as well as identifying packets being received out of order. Previous runs with slightly different code did contain out of order packets so it should not be assumed that packets will be received in order. Below is the Check.xlsx file that you may download.

Below are some statistics from the Check.xlsx Excel Workbook with data produced from 27 minutes runtime of the sample code.

• pi-sensor01
  • Receive Delay (hh:mm:ss)
    • Min: 00:00:07
    • Max: 00:04:12
    • Average: 00:01:28
    • Median: 00:00:57
  • Data Received out of order: 0
  • Data Points
    • Total: 104
    • Sent: 56
    • Received: 48
  • Sent Packets Received by pi-sensor01:
    • Received: 55
    • Not Received: 1
    • Percent of Packets Received: 98.21%
• pi-sensor02
  • Receive Delay (hh:mm:ss)
    • Min: 00:00:07
    • Max: 00:01:35
    • Average: 00:00:23
    • Median: 00:00:15
  • Data Received out of order: 1
  • Data Points
    • Total: 111
    • Sent: 56
    • Received: 55
  • Sent Packets Received by pi-sensor01:
    • Received: 48
    • Not Received: 8
    • Percent of Packets Received: 85.71%

Going Further

This is the end of this series at least for now. It was put together to provide some information with one way to send data between two Raspberry Pi devices using serial communications. There are other ways to send data using the serial port. One of the more interesting ways may be using the PROTO mode for the Meshtastic serial port. It looks like using the PROTO mode may allow for the code to setup and configure the Meshtastic device. If that is the case, it may provide much more control and standardization across connections. (Meshtastic Serial Port Configuration)

Another area to look into is how to improve the successful delivery of messages in a timely manor. It may be sending messages every 30 seconds was too fast and flooded the available channels. It may also be possible that the store and forward setting was misunderstood and caused message flooding on the channel. The devices may have been too close together to provide reliable communications. All of these things and others could be looked into to see if it is possible to create more reliable communications.

In this part of the Meshtastic with Raspberry Pi (Serial) series, we will be installing Meshtastic to the LilyGo T-Beam devices. We will then create a Meshtastic Channel on one LilyGo T-Beam and replicate the channel to the other LilyGo T-Beam. We will then wire the Raspberry Pi and LilyGo T-Beam devices.

Install Meshtastic Firmware on the LilyGo T-Beam devices

Visit the Meshtastic Web Installer at https://flasher.meshtastic.org/. Select the following options:

• Device: Tbeam
• Firmware Version: Select the latest version.
  NOTE: May want to install latest beta version if you want the most stable version available.
• Update or reinstall: Either option is fine. A reinstall may wipe out any settings that you have configured on the device but may be the best option for the first installation.

Click the “CONNECT” button

Select the serial port that the T-Beam is connected to. If you are uncertain, you may open the Windows Device Manager and look at Ports (COM & LPT), then look for “USB-Enhanced-SERIAL CH9102” or similar device to find the serial port.

Click “INSTALL TBEAM”

Click “INSTALL”

You will see the progress as it installs the firmware.

When the installation is complete, click “NEXT”

You may then click the X in the device dashboard to close the dashboard.

Repeat the steps for the other T-Beam, then close the browser.

Configure T-Beam and Create Channel

Using a mobile phone, tablet, or PC, open the Meshtastic App or Web Client. The following examples will show the Web Client and Android App.

• Android – Google Play Store
• iOS & Mac PC – Apple App Store
• Linux – Instructions
• Web client for nearly any device – Options
  • Hosted Version

Web Browser on a PC

It is best to use the Android application to configure the T-Beam device. The instructions provided here for the Web Browser are incomplete as I could not determine how to set some of the options that I know are available in the Android Application. These instructions are provided to demonstrate how to access the configuration from the web browser.

With the LilyGo T-Beam connected to the PC, open a browser and navigate to https://client.meshtastic.org/. Click the “New Connection” button.

The “Connect New Device” dialog is shown. Click the “New device” button.

Select the T-Beam device from the list of devices and click the “Connect” button.

Click the device from the device list.

The selected device will turn gray to show that it is selected. Click the X in the top right corner of the “Connect New Device” dialog to close the dialog box.

Android App

If the Meshtastic application is not already installed, go to the Play Store and search for an install the Meshtastic App.

Open the Meshtastic Application and click the gear icon in the top toolbar on the right, then click the “+” in the lower right corner to add a new Meshtastic device.

On the T-Beam device, look for the device name on the LCD screen.

In the Meshtastic App, select the device name that matches the name on the T-Beam LCD Screen, in the list of available devices.

The T-Beam device will display a Bluetooth pin on the LCD Screen.

Enter the Pin in the Bluetooth pairing request screen and click “OK”.

Next, we need to set the region by clicking on the region dropdown.
NOTE: Make certain that the correct device is selected.

Select your region from the list. My region is “US”, so that is what I selected.

The selected region will be displayed in the application and the T-Beam device will reboot.

Once the device reboots, you may enter a name if you like. Do not move off this screen right away or the name may not stick. You may find that you need to reenter the name a few times before it is saved.

Click on the hamburger menu in the upper right corner and select “Radio configuration”.

Click on “Serial” from the “Radio configuration” menu.

Enter the settings for the Serial Port, then click the “Send” button.

• Serial enabled: Turn on
• RX: Pin 13
• TX: Pin 14
• Serial baud rate: Selected 38400 baud but may select different rate. Make certain this matches when writing code on the Raspberry Pi.
• Serial mode: TEXTMSG

If you want a private channel, setup the channel on one device, then scan the QR Code on the other devices in the Mesh. I will not go over setting up a channel. For more information on setting up a channel, go to Meshtastic’s Channel Configuration page.

Wire Everything Up

The connection between the Raspberry Pi and the T-Beam device only requires three wires. A wire for the ground and two for the serial connection. The serial connection will cross the transmit (TX) and receive (RX) wires so that the TX from the Raspberry Pi is connected to the T-Beam RX and the Raspberry Pi RX will connect to the T-Beam TX. Below is a diagram showing these connections.

In Part I, we installed the Raspberry Pi OS and connected to the Raspberry Pi using PuTTY and VNC from another PC. In Part II, we will install Visual Code on the Raspberry Pi to allow us to code directly on the Raspberry Pi using a modern IDE.

It is not required to install Visual Studio Code. There are several options for writing programs and running them on the Raspberry Pi. It is possible to simply use the Text Editor on the desktop, Nano or VI from the terminal, or use an editor on the PC and transfer files using WinSCP.

Installing Visual Studio Code

The first thing to note is that the Chromium web browser is not going to work well on older Raspberry Pi boards. I am using a Raspberry Pi 3, so it is necessary to open a terminal and run the following command to launch the Dillo web browser:
dillo

Once the browser is open, navigate to https://code.visualstudio.com/download.

Clicking on the .deb Arm32 link does nothing as the link is using JavaScript to download the correct file. We will need to get the installation package from our PC and move it to the Raspberry Pi.

On the PC, navigate to https://code.visualstudio.com/download and click the .deb Arm32 link to download the installation package. Save it to a known location and remember where you saved it.

Open WinSCP and connect to the Raspberry Pi.

If it is the first time connecting to the Raspberry Pi, you will see a Warning dialog. Click “Yes” to continue.

Once connected, in the right pane of the WinSCP application, navigate to the desktop folder on the Raspberry Pi and in the left pane, navigate to the location of Visual Studio Code installation package on your PC. Once the locations have been selected, you may click and drag the installation package from the PC to the Raspberry Pi.

Once the package has been transferred, switch to VNC Viewer and you will see the file on your desktop.

Right-click on the installation package and select “Package Install” from the context menu.

Once the installation completes, you may launch Visual Studio Code from the menu by navigating to Programming > Visual Studio Code.

NOTE: You may delete the Visual Studio Code installer from the desktop if you wish.

I like to use the Explorer, the top icon on the left toolbar, to open a folder. From there, I may create files and folders for the project. In the screenshot below, I have created a folder named “Test” in my home folder and added a file named “test.py”. Once I created the file, Visual Studio Code recognized that I created a Python file and prompted me to install the Python language extension.