Published March 26, 2017 © CC BY-SA

Smart Parking Node

Monitor your parking lot with the LoPy using LoRa!

BeginnerFull instructions provided3 hours7,145

Things used in this project

Hardware components

Pycom LoPy4

Sparkfun Lithium Ion Battery - 2000mAh

SparkFun Compass Module - HMC6352

TheStripe™ 868 Mhz PCB A ntenna

Story

Smart Parking Node

With this project we create a (concept of a) basic smart parking system with the Pycom Lopy using the LoRa onboard functionality. The thought behind this idea is that we want to monitor whether a parking space is occupied or not. Using an application like this users can be notified beforehand if there is still a vacant spot for them to park their car. This can be helpful in crowded places or to improve efficiency by guiding the user to a free spot. This data may also be interesting in the long run for facility management and enhance operational intelligence.

How it Works

The sensor node can be placed on the pavement of the parking spot you want to monitor. The node is equipped with a magnetometer (sensor) which is able to detect ferrous materials, such as car parts. The same sensor can also often be found in electronic compasses to find the magnetic north. With the readings of this sensor we will be able to decide whether the parking spot is occupied or free. We do this by comparing the initial calibrated heading value (in tenths of degrees) with a measured value. A vehicle that parks on top of the sensor will cause the heading value to deviate by a few degrees. We can use a threshold to determine if this variation in heading could be caused by a vehicle. To minimize interference from passing vehicles or vehicles that are parked in the spot next to the sensor we can use a few techiniques.

To prevent the sensor from picking up passing vehicles the sensor needs to be placed centered on the parking place, away from the road. Next, the readings could also be averaged to ensure the car is parked and not moving anymore. The sensor is read every minute and then a small message is send with LoRa based on the sensor data (0 or 1). The total sensor packages will be an enclosed, autonomously functioning device.

LoRa

For the sensor to communicate its measured events (a car arrives or leaves), the sensor will be connected to the LoRa network. In this example we use the network provided by Dutch provider KPN together with a free developer account. This network roughly covers the whole country with indoor and outdoor usability so this is perfect for our application. Only limitation is the amount of uplink messages we can send each hour (maximum of 6), but I found that using a small payload you can send more messages. You could also use your own gateway or see if there is already a nearby (free) Things Network gateway that you can use.

If you're in the Netherlands, go to https://loradeveloper.mendixcloud.com/login.html and register for an account.

Create an account on https://loradeveloper.mendixcloud.com to use the Dutch KPN LoRa service

The reliability of the LoRa broadcast depends, among other factors, on the spreading factor. A good reliability generally can be achieved with a spreading factor of 10, or in very densily built environments SF12, but the LoRa stack will determine this for you. At this moment it is not possible to manually set this option in LoRaWAN mode with the Lopy. If you were to set this value manually, consider that a higher SF-number will increase the on-air-time of the signal and therefore decrease the frequency of the event updates we can send (so keep this number as low as possible). Usually this value is set by communicating with the gateway by a test message, automatically calculating the best SF to use (Adaptive Data Rate (ADR)).

To receive the sensor data on an application server connected with the internet, and possibly create a nice interface around the sensor data, the data has to be send from the gateway to a POST address.

Step 1: create a post server address to receive the LoRa messages on. For illustrative purposes we will use a temporary Hookbin server. You can also setup/code this part yourself or use software like Node-Red to make a more permanent solution.

Go to www.hookbin.com and create a new endpoint, you can make it private if you want (note that you can only access it from the computer it was created on in that case).

Create a new endpoint

Step 2: copy the URL of the endpoint (in blue):

When data comes in you have to press F5 or refresh the page to see it

Next go to the KPN developer portal and add a device. Paste in the URL of step 2 in the destination (this is where the data from you device will be forwarded to after it's been received by KPN's LoRa gateway, has to be HTTPS). Go with the ABP option for now.

Add a device and take note of the two keys and the address of the node

Take note of the device address for the specific LoRa network and the two keys. In this example the application key is also shared with the provider so the payload is not encrypted anymore once it reaches the provider, hence why HTTPS is required.

The status should show a blue balloon and once the device is active you should see a green checkmark under status (you need to send something for this first).

Setting up the sensor

The keys and device address copied earlier need to be placed in the main.py script on the Lopy. You can use FileZilla or any other FTP client. Remember to limit the amount of connections to 1 and set it on passive. For the device address to be correctly read by the onboard LoRa radio we manually convert it to decimal. Like so:

http://www.binaryhexconverter.com/hex-to-decimal-converter

For the keys (network and application shared keys) the binascii.unhexlify('<hex code>') option will work fine.

Building the Sensor Node

The enclosure has to be waterproof and durable (to withstand a vehicle driving over it). And all this while still providing enough space to house the main components: the Lopy, sensor, LoRa antenna and a battery. The battery pack is often the biggest component to ensure long running times. Note that at this moment the sleep functionality of the LoPy might not work 100% correctly so the power draw on the LoPy can be a bit too high. This will hopefully be fixed by Espressif soon with a firmware update - edit: this has been fixed with the deep sleep shield.

Case consists of two separate parts: the case and a separate base plate

Print with strong durable material and select a high infill.

Bevelled edges help gradually absorb the weight of the vehicle

Schematics

Code

"""The main script that will loop continuously with the use of deepsleep.
Sensorvalue is read once every minute. If a change is detected, send it with
LoRa.

Parameters:
start_val: has to be chosen in the field depeding on the environment
"""
import time
from machine import I2C
from network import LoRa
import socket
import binascii
import struct
import pycom


print('Main start')

# global parameters:
start_val = 2590  # e.g. 259.0 degrees

# LoRa details keys obtained from KPN
dev_addr = 7656999  # converted hex to decimal for better readability
nwks_key = binascii.unhexlify('d9ab51e44341853fbf0abe2671dddccd')
apps_key = binascii.unhexlify('99150d3a4dfddd08e6be1b63e58dd91f')

i2c = I2C(0, I2C.MASTER, baudrate=100000, pins=('P9', 'P10'))
addr = i2c.scan()
if addr:
    print('Peripheral found on address: ', addr, '\n')
    addr = addr[0]
else:
    print('No peripherals found!\n')
    addr = 0x21  # use default address
    pycom.rgbled(0xFF0000)  # light the led to indicate an error with peripheral


class Sensor():
    """Address is 0x42>>1, which is 0x21"""

    def __init__(self, i2c, addr):
        self.i2c = i2c
        self.addr = addr
        self.val = 0

    def read(self):
        self.i2c.writeto(addr, bytes([0x41]))  # query for heading
        time.sleep_ms(10)
        # read 2 bytes
        raw_val = self.i2c.readfrom(self.addr, 2)
        # bitshift first byte 8 places to the left
        self.val = raw_val[0] * 2**8 + raw_val[1]
        return self.val


sensor = Sensor(i2c, addr)

# Setup LoRa
lora = LoRa(mode=LoRa.LORAWAN)

# join a network using ABP
lora.join(activation=LoRa.ABP, auth=(dev_addr, nwks_key, apps_key), timeout=0)
print("LoRa active: ",  lora.has_joined())

# create a LoRa socket
lora_sock = socket.socket(socket.AF_LORA, socket.SOCK_RAW)

# set the LoRaWAN data rate
lora_sock.setsockopt(socket.SOL_LORA, socket.SO_DR, 5)


def ack():
    for i in range(3):
        pycom.rgbled(0x00ff00)
        time.sleep_ms(100)
        pycom.rgbled(0)
        time.sleep_ms(100)


def lora_tx(payload):
    print('Sending uplink message')
    pycom.rgbled(0xff0000)
    lora_sock.send(payload)
    print('LoRa uplink complete')
    ack()


time.sleep_ms(10)  # give the sensor some time to get a good reading
other_val = sensor.read()  # e.g. 261.0 degrees

# set to more than 2 degrees (find a good threshold here)
if abs(start_val - other_val) > 20:
    lora_tx(bytes([0x01]))  # there is a parked vehicle
else:
    lora_tx(bytes([0x00]))  # no vehicle detected`

machine.deepsleep(1000 * 60)  # 60 sec interval, resumes again from top

Credits

Rob Braggaar

3 projects • 13 followers

Professional tinkerer, Node specialist and tech geek

Contact

Comments

Please log in or sign up to comment.

Smart Parking Node

Things used in this project

Hardware components

Story

Smart Parking Node

How it Works

LoRa

Setting up the sensor

Building the Sensor Node

Custom parts and enclosures

case

lid

Schematics

Diagram

Sensor

Lopy

Internal antenna

Code

boot.py

main.py

Credits

Rob Braggaar

Comments

Embed the widget on your own site

Smart Parking Node

Smart Parking Node

Things used in this project

Hardware components

Story

Smart Parking Node

How it Works

LoRa

Setting up the sensor

Building the Sensor Node

Custom parts and enclosures

case

lid

Schematics

Diagram

Sensor

Lopy

Internal antenna

Code

boot.py

main.py

Credits

Rob Braggaar

Comments

Related channels and tags