433 & 868 MHz – RAK5146L & iC880a – LoRa Basics Station – LoRa@VSB – LoRaWAN Network of Technical University of Ostrava Campus

TTN version:	TTNv3
Frequency:	Europe 433 MHz (ITU region 1) Europe 863-870 MHz (SF9 for RX2 – recommended)
Classes:	Ready for LoRaWAN Classes A, B and C
Using Docker:	Yes
Last updated:	July 5, 2024

This article provides instructions for making LoRa Basics Station for two frequency plans – Europe 433 MHz (ITU region 1) and Europe 863-870 MHz (SF9 for RX2 – recommended). Dual GW

Note: RAK5146L with GPS is required to support Class B end devices and GPS module with PPS (Pulse Per Second) for iC880a is required to support Class B end devices.

Prepare

Raspberry Pi 3 or 4
Raspberry Pi Power Supply
microSD card
mPCIe to USB Board
RAK5146L Gateway Concentrator Module for LoRaWAN, SX1303 LoRa Core (EU433, USB)
iC880A-SPI LoRa Concentrator
GPS NEO-6M GYNEO6MV2
GPS antenna
12x jumper wire
2x SMA to uFL/u.FL/IPX/IPEX RF Adapter Cable
3D printed holder to mount boards with screws (optional)
PC

Assembly

First, from the 868 MHz iC880a – LoRa Basics Station tutorial, do only the Assembly part and return to this tutorial.
Then, from the 433MHz RAK5146L USB – LoRa Basics Station tutorial, do only the Assembly part and return to this tutorial.

Raspberry Pi OS setup

From https://www.raspberrypi.com/software/ download Raspberry Pi Imager and install it.
Insert the microSD card into the computer.
Run Raspberry Pi Imager.
Click on CHOOSE OS.
Click on Raspberry Pi OS (other).
Click on Raspberry Pi OS Lite (32-bit).
Click on CHOOSE STORAGE.
Select the inserted microSD card on which you want to install Raspberry Pi OS.
Click on Next.
Would you like to apply OS customisation settings? – EDIT SETTINGS.
Set hostname.
Set username and password. (we recommend a 17-digit password containing lower and upper case letters, numbers and symbols)
If you will use WiFi – Configure wireless LAN. (optional)
Set locale settings.
Click on tab SERVICES.
If you will be connecting remotely via SSH – Enable SSH – Use password authentication. (optional)
Click on SAVE.
Click on YES.
Click on YES.
Click on CONTINUE.
Insert the microSD card into the Raspberry Pi.
Turn on the Raspberry Pi.

Remote connection via SSH (optional)

Connect to your router and find the IP address of your Raspberry Pi.
From a Windows PC, you can connect using Command Prompt (CMD) or PuTTY.
On Windows PC open Command Prompt (CMD).
Type ssh -p port username@IP_Address (for example: ssh -p 22 loravsb@192.168.1.120).
Type your password.

Post-installation steps

Update, upgrade and reboot Raspberry Pi. This will ensure that any security vulnerabilities are patched:
```
$ sudo apt update
$ sudo apt full-upgrade
$ sudo reboot
```
Connect again via SSH.
Use a different port for SSH and disable root login. First, open the SSH configuration file with a text editor:
```
$ sudo nano /etc/ssh/sshd_config
```
Locate the line with Port 22 and change it to the desired port number (for example, change the port to 2222). Locate the line with PermitRootLogin and change its value to no (this will disable root login via SSH):
```
Port 2222
PermitRootLogin no
```
Save the changes and exit the text editor.
Restart the SSH service to apply the changes:
```
$ sudo systemctl restart ssh
```
Log out and connect again via SSH on the new port.
Install and configure the built-in firewall, ufw, to limit incoming network connections. In the sudo ufw limit 2222/tcp rule, change port 2222 to port you have chose for SSH above.
```
$ sudo apt install ufw
$ sudo ufw default deny incoming
$ sudo ufw limit 2222/tcp
$ sudo ufw enable
```
Note: Firewall rules will have no effect on ports opened by Docker.
Reboot Raspberry Pi:
```
$ sudo reboot
```

Docker

Connect again via SSH.

Install the latest Docker version using the convenience script provided by docker:

$ curl -fsSL https://get.docker.com -o get-docker.sh
$ sudo sh get-docker.sh
$ sudo groupadd docker
$ sudo usermod -aG docker $USER
$ newgrp docker
$ sudo systemctl enable docker.service
$ sudo systemctl enable containerd.service

For more information on Docker installation, see https://docs.docker.com/engine/install/.

LoRa Basics Station setup

First, get the Gateway EUI for the 433 MHz LoRa Basics Station by running the following command:

$ docker run -it --network host --rm -e GATEWAY_EUI_SOURCE=wlan0 xoseperez/basicstation:latest gateway_eui

Then get the Gateway EUI for 868 MHz LoRa Basics Station by running the following command:

$ docker run -it --network host --rm -e GATEWAY_EUI_SOURCE=eth0 xoseperez/basicstation:latest gateway_eui

If you receive two identical EUIs, change the last digit of one to make them different.

The Things Stack

Create an account on The Things Network if you don’t have one.
Login on The Things Network.
Click on your username and choose Console.
Select a network cluster.

433 MHz LoRa Basics Station

Go to gateways.
Click on button + Register gateway.
Write the previously detected Gateway EUI for 433 MHz LoRa Basics Station in the Gateway EUI field.
Click on button Confirm.
Write something into Gateway ID.
Write something into Gateway name.
Frequency plan – Europe 433 MHz (ITU region 1).
Click on button Register gateway.
In API keys click on button +Add API key.
Write something into Name.
Click on Grant individual rights.
Select Link as Gateway to a Gateway Server for traffic exchange, i.e. write uplink and read downlink.
Click on button Create API key.
Click the Copy to clipboard button and paste the key into some text document for future use.
Click on button I have copied the key.

868 MHz LoRa Basics Station

Go to gateways.
Click on button + Register gateway.
Write the previously detected Gateway EUI for 868 MHz LoRa Basics Station in the Gateway EUI field.
Click on button Confirm.
Write something into Gateway ID.
Write something into Gateway name.
Frequency plan – Europe 863-870 MHz (SF9 for RX2 – recommended)
Click on button Register gateway.
In API keys click on button +Add API key.
Write something into Name.
Click on Grant individual rights.
Select Link as Gateway to a Gateway Server for traffic exchange, i.e. write uplink and read downlink.
Click on button Create API key.
Click the Copy to clipboard button and paste the key into some text document for future use.
Click on button I have copied the key.

Raspberry Pi’s Interfaces

Run the following command to configure the Raspberry Pi’s Interfaces:
```
$ sudo raspi-config
```
In 3 Interface Options -> I4 SPI.
Would you like the SPI interface to be enabled? -> Yes.
Ok.
In 3 Interface Options -> I5 I2C.
Would you like the ARM I2C interface to be enabled? -> Yes.
Ok.
In 3 Interface Options -> I6 Serial Port.
Would you like a login shell to be accessible over serial? -> No.
Would you like the serial port hardware to be enabled? -> Yes.
Ok.
Finish.
Would you like to reboot now? -> Yes.

LoRa Basics Station

Connect again via SSH.
Clone the repository with LoRa Basics Station and go to the created directory:
```
$ git clone https://github.com/RAKWireless/basicstation.git
$ cd basicstation
```

Run this command to overwrite the station.v2.conf file with a new file containing the PPS settings:

$ curl -L https://raw.githubusercontent.com/OndrejKnebl/gateway-patch/main/station.v2.conf > runner/station.v2.conf

Build the image by using the buildx extension of docker. If you are not using a 64-bit ARMv8 computer (like Raspberry Pi 4), you can change aarch64 to armv7hf(ARMv7) or amd64 (AMD64):
```
$ REGISTRY=868_basicstation VARIANT=std docker buildx bake --load aarch64
```
Return to the parent folder:
```
$ cd ..
```
Run this command to create and edit the docker-compose.yml file:
```
$ sudo nano docker-compose.yml
```

Copy and paste the configuration below into your docker-compose.yml file. Copy and paste the API keys you got previously saved to the TC_KEY variables. Copy and paste the EUIs you got previously generated to the GATEWAY_EUI variables. If you are not using a 64-bit ARMv8 computer (like Raspberry Pi 4), you can change aarch64 to armv7hf (ARMv7) or amd64 (AMD64).

version: '2.0'
services:
  basicstation:
      image: xoseperez/basicstation:latest
      container_name: basicstation-433
      restart: unless-stopped
      privileged: true
      network_mode: host
      environment:
        INTERFACE: "USB"
        MODEL: "SX1303"
        GATEWAY_EUI: "0000000000000000"             # Copy here your EUI for 433 MHz LoRa Basics Station
        TC_KEY: "NNSXS...."                         # Copy here your API key from the TTS for 433 MHz LoRa Basics Station

  basicstation-868:
      image: 868_basicstation:aarch64-latest        # If not using a 64-bit ARMv8 computer, change aarch64
      container_name: basicstation-868
      restart: unless-stopped
      privileged: true
      network_mode: host
      environment:
        INTERFACE: "SPI"
        MODEL: "IC880A"
        GATEWAY_EUI: "0000000000000000"             # Copy here your EUI for 868 MHz LoRa Basics Station
        SPI_SPEED: 2000000                          # If using backplane = 2000000, if wired and not working properly = 1000000
        GW_RESET_GPIO: 25                           # If using backplane = 25, otherwise define your GPIO reset
        TC_KEY: "NNSXS...."                         # Copy here your API key from the TTS

Next, create a script that automatically on system startup (or power on) will recreate the containers (because there were errors when starting the original container for 433 MHz).
Create the script reset-docker-compose.sh:
```
$ sudo nano reset-docker-compose.sh
```
Copy and paste the content below into your reset-docker-compose.sh file. In the path, replace yourUsername with your username:
```
#!/bin/bash
cd /home/yourUsername/
sleep 30
sudo docker compose down
sudo docker compose up -d --force-recreate
```
Make the script executable:
```
$ sudo chmod +x reset-docker-compose.sh
```

Create a systemd service:

$ sudo nano /etc/systemd/system/docker-reset.service

Copy and paste the content below into your docker-reset.service file. In the path, replace yourUsername with your username:

[Unit]
Description=Reset Docker Compose on Startup

[Service]
Type=oneshot
ExecStart=/home/yourUsername/reset-docker-compose.sh

[Install]
WantedBy=multi-user.target

Enable and start the service. The second command will take 30 seconds to execute:
```
$ sudo systemctl enable docker-reset
$ sudo systemctl start docker-reset
```
Finaly, check that the gateway status is Connected in the TTS console.

For more information on LoRa Basics™ Station for Docker, see: