Setting up LoRa-GPS Tracker

Installing bootloader

Bootloader is pre-installed on board. This information is given if you want to make changes to it. You will need Segger J-Link programmer to follow these instructions and custom adapter to connect with Tag-Connect cable to board.

Clone UF2 repository and make a copy of /boards/feather_mo directory.

clone https://github.com/adafruit/uf2-samdx1
cd uf2-samdx1
cd boards
cp -r feather_m0 tracker_m0

Go to that directory and edit board_config.h file as following:

#ifndef BOARD_CONFIG_H
#define BOARD_CONFIG_H

#define VENDOR_NAME "Juha-Pekka Varjonen"
#define PRODUCT_NAME "LoRa-GPS-Tracker"
#define VOLUME_LABEL "TRACKERBOOT"
#define INDEX_URL "https://locateworld.net/"
#define BOARD_ID "SAMD21G18A-Tracker-v1"

#define USB_VID 0x1209
#define USB_PID 0x0005

#define LED_PIN PIN_PA17

#endif

You can fill it with your own data if you want. Note that volume label must be 11 character long uppercase string.

Build bootloader with command:

make BOARD=tracker_m0

Go to newly created directory ‘build’ and it’s subdirectory ‘tracker_m0’. If not yet installed, download and install J-Link software from here. Install with this command:

sudo dpkg -i ~/Downloads/jlink_package.deb

To enable/disable bootloader protection you must create two files accordingly to same directory with bootloader.

set.mot:

S214804000FAC7E0D85DFCFFFFFFFFFFFFFFFFFFFF63
S9030000FC

clear.mot:

S214804000FFC7E0D85DFCFFFFFFFFFFFFFFFFFFFF5E
S9030000FC

Start J-Link Commander.

JLinkExe

Type ‘connect’ to make connection to microcontroller. It follows with three question. To first question press enter and then ‘S’+enter and then enter again. Default settings are ok.

J-Link>connect
Please specify device / core. : ATSAMD21G18
Type '?' for selection dialog
Device>
Please specify target interface:
  J) JTAG (Default)
  S) SWD
TIF>S
Specify target interface speed [kHz]. : 4000 kHz
Speed>
Device "ATSAMD21G18" selected.

Clear bootloader protection fuse:

loadfile clear.mot

Reset the target:

r

Upload the bootloader:

loadbin bootloader.bin,0

Set the bootloader fuse:

loadfile set.mot

Now it should be visible as USB mass storage device and serial port.

Installing CircuitPython

CircuitPython is pre-installed on board. These instructions is given if you want to make changes to it. Clone Adafruit CircuitPython repository:

git clone https://github.com/adafruit/circuitpython

An ARM compiler is required for the build. It can be installed as follows:

sudo add-apt-repository ppa:team-gcc-arm-embedded/ppa
sudo apt-get install gcc-arm-embedded

Install necessary submodules before continue:

git submodule update --init --recursive

Next commands must be executed in subdirectory ports/atmel-samd/. Create copy of directory boards/feather_m0_basic and edit file mpconfigboard.h as follows:

#define MICROPY_HW_BOARD_NAME "LoRa-GPS-Tracker"

Then edit file mpconfigboard.mk as follows:

USB_VID = 0x1209
USB_PID = 0x0005
USB_PRODUCT = "LoRa-GPS-Tracker"
USB_MANUFACTURER = "Juha-Pekka Varjonen"

Compile MicroPython cross-compiler:

make -C mpy-cross

To build give this command:

make BOARD=tracker_m0

It creates a lot of files and directories in to directory ‘build-tracker_m0’. We only need one with name firmware.uf2. Easiest method to install it is to drag and drop it in to previously created USB device TRACKERBOOT.

After dropping it takes about 15 seconds and device name changes to CIRCUITPY and it’s ready to use.

Setting up development environment

This step is necessary when programming and testing with Mu-editor. Clone Mu-editor repository and edit mu/modes/circuitpython.py file.

git clone https://github.com/mu-editor/mu
nano mu/mu/modes/circuitpython.py

Under ‘valid boards’ add VID and PID to the list. PID 0x0005 is only for testing. Do not use it in production.

valid_boards = [
...
(0x1209), (0x0005), # LoRa-GPS Tracker development
]

Run Mu-editor from it’s root directory with command:

python run.py

Now it should detect LoRa-GPS Tracker automatically. You will need also Adafruit library bundle. Download it from here.

Testing GPS receiver

At first you need to copy adafruit_gps folder from Adafruit library bundle to lib folder on CIRCUITPY device.

Open Mu editor and create new CircuitPython project with code.py filename. File content should be this:

import board
import busio
import adafruit_gps
import time

RX = board.RX
TX = board.TX

uart = busio.UART(TX, RX, baudrate=9600, timeout=30)
gps = adafruit_gps.GPS(uart, debug=False)
# Turn on the basic GGA and RMC info (what you typically want)
gps.send_command(b'PMTK314,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0')
# Set update rate to once a second (1hz) which is what you typically want
gps.send_command(b'PMTK220,1000')

while True:
    gps.update()
    if not gps.has_fix:
        # Try again if we don't have a fix yet.
        continue
    # We have a fix! (gps.has_fix is true)
    # Print out details about the fix like location, date, etc.
    print('=' * 40)  # Print a separator line.
    print('Fix timestamp: {:02}:{:02}:{:02}'.format(
        gps.timestamp_utc.tm_hour,  
        gps.timestamp_utc.tm_min,   
        gps.timestamp_utc.tm_sec))
    print('Latitude: {0:.6f} degrees'.format(gps.latitude))
    print('Longitude: {0:.6f} degrees'.format(gps.longitude))

That code prints out to serial port current coordinates. You can watch serial port communication by pressing Mu editor button ‘serial’.

Testing LoRa radio

At first you need to copy adafruit_tinylora and adafruit_bus_device folder from Adafruit library bundle to lib folder on CIRCUITPY device.

Open Mu editor and create new CircuitPython project with code.py filename. File content should be this:

import busio
import digitalio
import board
from adafruit_tinylora.adafruit_tinylora import TTN, TinyLoRa
import time
import microcontroller

# Create library object using our bus SPI port for radio
spi = busio.SPI(board.SCK, MOSI=board.MOSI, MISO=board.MISO)
 
# RFM9x Breakout Pinouts
cs = digitalio.DigitalInOut(microcontroller.pin.PA06)
irq = digitalio.DigitalInOut(microcontroller.pin.PA09)
rst = digitalio.DigitalInOut(microcontroller.pin.PA08)

# TTN Device Address, 4 Bytes, MSB
devaddr = bytearray([0x00, 0x00, 0x00, 0x00])
 
# TTN Network Key, 16 Bytes, MSB
nwkey = bytearray([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00])
 
# TTN Application Key, 16 Bytess, MSB
app = bytearray([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00])
 
ttn_config = TTN(devaddr, nwkey, app, country='EU')
 
lora = TinyLoRa(spi, cs, irq, rst, ttn_config)
 
# Data Packet to send to TTN
data = bytearray(4)
 
while True:
    # Encode payload as bytes
    data[0] = 0xff
    data[1] = 0x01
    data[2] = 0xff
    data[3] = 0x01
 
    # Send data packet
    print('Sending packet...')
    lora.send_data(data, len(data), lora.frame_counter)
    print('Packet Sent!')
    lora.frame_counter += 1
    time.sleep(15)

Important thing is that TTN device address, network key and application key should be your own unique numbers from TTN Console. More detailed instructions can be found from Adafruit site.

After code is copied to CIRCUITPY drive it runs automatically and starts sending data to internet. You can follow it with TTN Console. If there is no gateway in your area you need one own. Next is described how to setup one.

Setting up LoRaWAN gateway

I have Raspberry Pi with GW-01-RPI LoRa Shield. Start with downloading Rasbian img file from Raspberry Pi’s web site. Extract it with unzip command and transfer to SD card with dd command.

unzip your_image_file_name.zip
sudo umount /dev/sdx*
sudo dd bs=1M if=your_image_file_name.img of=/dev/sdx

Make sure to replace /dev/sdx with correct device name. You can check it with command sudo fdisk -l

Finally put a empty file named ‘ssh’ to the root directory of SD card. This way you enable ssh connection. Insert card to Raspberry Pi and connect power and LAN. Login with default username and password (user: pi, password: raspberry). With remote computer:

ssh pi@192.168.0.6

Change IP address accordingly. It is recommended to change password at this point. Use command passwd.

First enable onboard SPI connection. Go to raspi-config.

sudo raspi-config

Select interfacing options and there is SPI. Enable it by pressing enter and choosing enable.

Create directory and clone and make two necessary repositories on to it.

cd ~
mkdir lora
cd lora
git clone https://github.com/Lora-net/lora_gateway.git
cd lora_gateway
make

cd ~/lora
git clone https://github.com/Lora-net/packet_forwarder.git
cd packet_forwarder
./compile.sh

Then edit config files:

cd ~/lora/packet_forwarder/lora_pkt_fwd
nano global_conf.json
nano local_conf.json

Local config contains only one line for gateway ID. Change it’s value to same than in global_conf.json. You can make up that ID to be anything you like. It must be 8-bit hexadecimal number. Example settings:

gateway_ID: "0102030405060708"
server_address: "router.eu.thethings.network"
serv_port_up: "1700"
serv_port_down: "1700"

One last thing is to make startup file.

cd ~/lora
nano reset.sh

That file should contain following lines:

#!/bin/sh
echo "25" > /sys/class/gpio/export
echo "out" > /sys/class/gpio/gpio25/direction
echo "1" > /sys/class/gpio/gpio25/value
sleep 3
echo "0" > /sys/class/gpio/gpio25/value
sleep 1
echo "0" > /sys/class/gpio/gpio25/value
cd /home/pi/lora/packet_forwarder/lora_pkt_fwd/
./lora_pkt_fwd &

Set that file to be executable and run it:

sudo chmod +x reset.sh
sudo ./reset.sh

If you see line with following text then setup is succesfull.

INFO: [main] concentrator started, packet can now be received

Break that by pressing Ctrl-C. Next thing is to modify rc.local file.

sudo nano /etc/rc.local

Just before ending “exit 0” line, add following:

/home/pi/lora/reset.sh || /bin/true &

And on the beginning of the file change “#!/bin/sh -e” to “#!/bin/sh”. Save and close file. Then set executable bit and enable it:

sudo chmod +x /etc/rc.local
sudo systemctl daemon-reload
sudo systemctl enable rc-local.service

Now it should start every time when Raspberry starts. Restart to confirm that by typing ‘sudo reboot’ and pressing enter. When restarted look with top command if lora_pkt_fwd is running.

Setting up TTN

Start by logging in to TTN console and choose Gateway -> register gateway. Select “I’m using the legacy packet forwarder”. Important thing is that gateway EUI must be same than previously selected Gateway_ID. Also router needs to be same than in gateway settings. Other settings are self-explanatory.