Improve Debug. Always Accept RxHello

test/Pi_Receiver.py

+#!/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()