Skip to content
Snippets Groups Projects
Commit 35bc8cec authored by Callum Inglis's avatar Callum Inglis
Browse files

Improve Debug. Always Accept RxHello

parent 0abd9eeb
No related branches found
No related tags found
1 merge request!1Reliable polling
#!/usr/bin/env python3
'''
=========================================================================================
CS408 Environmental Monitoring Independent of Existing Infrastructure
Copyright (C) 2021 Callum Inglis
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License along
with this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
Contact: Callum.Inglis.2018(at)uni.strath.ac.uk
=========================================================================================
Libraries Used
https://github.com/raspberrypi-tw/lora-sx1276
=========================================================================================
'''
# Usage: python Pi_Receiver.py -f 433 -b BW125 -s 7
from argparse import ArgumentError
import sys
sys.path.insert(0, '../')
from time import sleep, time
import json
import requests # pip3 install requests
import random
from SX127x.LoRa import *
from SX127x.LoRaArgumentParser import LoRaArgumentParser
from SX127x.board_config import BOARD
import SX127x.packer as packer
DEBUG = 1
API_URL = "http://environmental-monitoring.int.4oh4.co/api"
BOARD.setup()
parser = LoRaArgumentParser("Continous LoRa receiver.")
# Recived from Sensors when they have data to send
class RxHello(object):
def __init__(self, uid, reservationTime):
self.uid = uid
self.reservationTime = reservationTime
self.okToTransmit = False
self.txAuthID = None
def setOK(self, okToTransmit):
self.okToTransmit = okToTransmit
def setTxAuthID(self, txAuthID):
self.txAuthID = txAuthID
# Python Object to JSON Object
def ToJson(self):
return json.dumps(self, default=lambda o: o.__dict__, sort_keys=True, indent=4)
class SensorResponse(object):
def __init__(self, sensorMetadata, data):
self.sensorMetadata = SensorMetadata(**sensorMetadata)
self.sensorReading = SensorReading(**data)
# Python Object to JSON Object
def ToJson(self):
return json.dumps(self, default=lambda o: o.__dict__, sort_keys=True, indent=4)
def sendToApi(self):
headers = {'Content-Type': 'Application/json'}
response = requests.post(API_URL + '/sensor/reading', data=self.ToJson(), headers=headers, verify=False) # Using self signed cert for now, sort later!
if DEBUG > 0:
print(response)
return
class SensorMetadata(object):
def __init__(self, uid, messageID, samplePeriod):
self.uid = uid
self.messageID = messageID
self.samplePeriod = samplePeriod
self.sampleTime = round(time())
class SensorReading(object):
def __init__(self, ppm, sht, co2):
self.ppm = PPM(**ppm)
self.sht = SHT(**sht)
self.co2 = Co2(**co2)
class PPM(object):
def __init__(self, p10, p25, p100):
self.p10 = p10
self.p25 = p25
self.p100 = p100
class SHT(object):
def __init__(self, temperature, humidity):
self.temperature = temperature
self.humidity = humidity
class Co2(object):
def __init__(self, tmp):
self.tmp = "Coming Soon!"
class Reply():
ackStatus = False
def __init__(self, remoteSensorID, replyMsgID):
self.messageID = random.randrange(10000, 99999)
self.gatewayUid = getserial()
self.remoteSensorID = remoteSensorID
self.replyMsgID = replyMsgID
def setAckStatus(self, ackStatus):
self.ackStatus = ackStatus
def ToJson(self):
return json.dumps(self, default=lambda o: o.__dict__, sort_keys=True, indent=4)
class LoRaReceiver(LoRa):
def __init__(self, verbose=False):
super(LoRaReceiver, self).__init__(verbose)
self._id = "Base-01"
self.set_mode(MODE.SLEEP)
self.set_dio_mapping([0] * 6)
def on_rx_done(self):
if DEBUG > 1:
print("\n[+] Rx Done")
self.clear_irq_flags(RxDone=1)
payload = self.read_payload(nocheck=True)
# Parse our data here!
data = ''.join([chr(c) for c in payload])
handleData(data)
self.reset_ptr_rx()
self.set_mode(MODE.RXCONT)
def on_tx_done(self):
print("\nTxDone")
# set RX
self.set_dio_mapping([0,0,0,0,0,0]) # RX
sleep(1)
self.reset_ptr_rx()
self.set_mode(MODE.RXCONT)
self.clear_irq_flags(RxDone=1)
def on_cad_done(self):
print("\non_CadDone")
print(self.get_irq_flags())
def on_rx_timeout(self):
print("\non_RxTimeout")
print(self.get_irq_flags())
def on_valid_header(self):
print("\non_ValidHeader")
print(self.get_irq_flags())
def on_payload_crc_error(self):
print("\non_PayloadCrcError")
print(self.get_irq_flags())
def on_fhss_change_channel(self):
print("\non_FhssChangeChannel")
print(self.get_irq_flags())
def receive(self):
self.reset_ptr_rx()
self.set_mode(MODE.RXCONT)
while True:
if (self.get_mode() == MODE.TX):
rssi_value = self.get_rssi_value()
status = self.get_modem_status()
if DEBUG > 1:
sys.stdout.flush()
sys.stdout.write("\r%d %d %d" % (rssi_value, status['rx_ongoing'], status['modem_clear']))
def transmit(self, _payload):
global args
self.tx_counter = 0
self.write_payload(_payload)
self.set_mode(MODE.TX)
# Source: https://www.raspberrypi-spy.co.uk/2012/09/getting-your-raspberry-pi-serial-number-using-python/
def getserial():
# Extract serial from cpuinfo file
cpuserial = "0000000000000000"
try:
f = open('/proc/cpuinfo','r')
for line in f:
if line[0:6]=='Serial':
cpuserial = line[10:26]
f.close()
except:
cpuserial = "ERROR000000000"
return cpuserial
# Upon succesfully receiving a message, send back an ack
def ackMsg(sensorResponse):
data = Reply(sensorResponse.sensorMetadata.uid, sensorResponse.sensorMetadata.messageID)
data.setAckStatus(True)
print(data.ToJson())
_length, _payload = packer.Pack_Str( data.ToJson() )
payload = [int(hex(c), 0) for c in _payload]
loraReceiver.transmit(payload)
return
# When a sensor has data to transmit, it will send a TxHello.
# Pick up that message here and decide if we can accept the message at this time.
def handleRxHello(data):
timeBegin = time()
print("\n[?] Try RX Hello!")
if DEBUG > 1:
print("\nRaw data: %s" % data)
try:
rxHelloJson = json.loads(data)
rxHello = RxHello(**rxHelloJson)
except Exception as e:
print("[-] Not RX Hello\n")
return False
print("[+] RX Hello Confirmed!\n")
# TODO Check i'm not expecting any methods within rxHello.reservationTime seconds
# Send "OK" + UID + TX_AUTH_ID
rxHello.setOK(True) # We are happy for this sensor to send it's data
rxHello.setTxAuthID(123)
print(rxHello.ToJson())
_length, _payload = packer.Pack_Str( rxHello.ToJson() ) # Send OK Back Back
payload = [int(hex(c), 0) for c in _payload]
loraReceiver.transmit(payload)
print("\n[+] RX Hello \"OK\" Reply Sent\n")
# Sleep until out transmit block expires (2 Seconds)
#sleep(2 - (time() - timeBegin))
sleep(0.2)
return True
# handle SensorResponse data packet
def handleSensorResponsePacket(data):
timeBegin = time()
print("\n[?] Try Sensor Response Data!\nRaw data: %s" % data)
try:
parsed = json.loads(data)
p = SensorResponse(**parsed)
except Exception as e:
print("\n[-] Unable to Parse response, ignoring") # TODO Error handling, log increased error rates etc
if DEBUG > 1:
print("\tE: %e" % e)
return False
print("[+] Sensor Response Data Confirmed!\n")
print(p.ToJson())
# TODO Validate response is valid and non-corrupt
# TODO Ack / process here
# TODO Transmit ACK
print("\n[+] Sending Sensor Response Ack")
ackMsg(p)
print("[+] Sensor Response Ack Sent\n")
# Process response
print("Sensor ID: %s \tPPM 10: %s\n" % (p.sensorMetadata.uid, p.sensorReading.ppm.p10))
# TODO Send To API
print("\n[+] Sending Data to API")
p.sendToApi()
print("[+] Data Sent to API\n")
# Sleep until out transmit block expires (2 Seconds)
#sleep(2 - (time() - timeBegin))
sleep(0.2)
# Parse LoRa response, validate, save / transmit
def handleData(data):
# Handle TxHello Transmission
# Rx - "I've got data to send!" + UID (From Sensor)
# If not expecting any messages, continue
# Tx - "OK" + UID (Back to Sensor) + TX_Auth_ID
#
# <Do not Tx for 2s>
if (handleRxHello(data)): # Handled all OK
return
# Handle Payload Transmission
# Rx - Packet + UID + Tx_Auth_ID (From Sensor)
# Handle message, ack / nak appropriately
# Tx - Ack + UID + Next_Send_Interval
# Tx - Nak + UID
#
# <Do not Tx for 3s>
if (handleSensorResponsePacket(data)):
return
# T+3 Tx reserved window expires
# Setup Receiver
loraReceiver = LoRaReceiver(verbose=False)
args = parser.parse_args(loraReceiver)
loraReceiver.set_mode(MODE.STDBY)
loraReceiver.set_pa_config(pa_select=1)
#loraReceiver.set_rx_crc(True)
#loraReceiver.set_coding_rate(CODING_RATE.CR4_6)
#loraReceiver.set_pa_config(max_power=0, output_power=0)
#loraReceiver.set_lna_gain(GAIN.G1)
#loraReceiver.set_implicit_header_mode(False)
#loraReceiver.set_low_data_rate_optim(True)
#loraReceiver.set_pa_ramp(PA_RAMP.RAMP_50_us)
#loraReceiver.set_agc_auto_on(True)
# Go Go Go!
print("[+] Receiver & API Gateway")
assert(loraReceiver.get_agc_auto_on() == 1)
try:
loraReceiver.receive()
except KeyboardInterrupt:
sys.stdout.flush()
print("")
sys.stderr.write("KeyboardInterrupt\n")
finally:
sys.stdout.flush()
print("")
loraReceiver.set_mode(MODE.SLEEP)
BOARD.teardown()
0% Loading or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment