Update JoinAcceptPayload.py to make OTAA helium work

.gitignore

@@ -1,2 +1,3 @@
 *.pyc
-keys.py
+.env
+frame.txt

LoRaWAN/DataPayload.py

@@ -56,7 +56,7 @@ def decrypt_payload(self, key, direction, mic):
             a += [0x00]
             a += [i+1]
 
-        cipher = AES.new(bytes(key))
+        cipher = AES.new(bytes(key), AES.MODE_ECB)
         s = cipher.encrypt(bytes(a))
 
         padded_payload = []
@@ -84,7 +84,7 @@ def encrypt_payload(self, key, direction, data):
             a += [0x00]
             a += [i+1]
 
-        cipher = AES.new(bytes(key))
+        cipher = AES.new(bytes(key), AES.MODE_ECB)
         s = cipher.encrypt(bytes(a))
 
         padded_payload = []

LoRaWAN/JoinAcceptPayload.py

@@ -56,7 +56,7 @@ def decrypt_payload(self, key, direction, mic):
         a += self.encrypted_payload
         a += mic
 
-        cipher = AES.new(bytes(key))
+        cipher = AES.new(bytes(key), AES.MODE_ECB)
         self.payload = cipher.encrypt(bytes(a))[:-4]
 
         self.appnonce = self.payload[:3]
@@ -75,7 +75,7 @@ def encrypt_payload(self, key, direction, mhdr):
         a += self.to_clear_raw()
         a += self.compute_mic(key, direction, mhdr)
 
-        cipher = AES.new(bytes(key))
+        cipher = AES.new(bytes(key), AES.MODE_ECB)
         return list(map(int, cipher.decrypt(bytes(a))))
 
     def derive_nwskey(self, key, devnonce):
@@ -85,7 +85,7 @@ def derive_nwskey(self, key, devnonce):
         a += devnonce
         a += [0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]
 
-        cipher = AES.new(bytes(key))
+        cipher = AES.new(bytes(key), AES.MODE_ECB)
         return list(map(int, cipher.encrypt(bytes(a))))
 
     def derive_appskey(self, key, devnonce):
@@ -95,5 +95,5 @@ def derive_appskey(self, key, devnonce):
         a += devnonce
         a += [0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]
 
-        cipher = AES.new(bytes(key))
+        cipher = AES.new(bytes(key), AES.MODE_ECB)
         return list(map(int, cipher.encrypt(bytes(a))))

README.md

@@ -1,3 +1,17 @@
+#RPI install routine
+```
+sudo apt-get install -y tmux htop 
+sudo pip3 install adafruit-circuitpython-ssd1306
+sudo pip3 install adafruit-circuitpython-framebuf
+sudo pip3 install adafruit-circuitpython-rfm9x
+sudo pip3 install adafruit-circuitpython-gps
+sudo pip3 install pycryptodome
+sudo pip3 install shortuuid
+sudo pip3 install python-dotenv
+sudo apt-get install gpsd gpsd-clients
+git clone git@github.com:DGaffney/LoRaWAN.git
+```
+
 # LoRaWAN
 This is a LoRaWAN v1.0 implementation in python.
 
@@ -9,13 +23,39 @@ This fork adds support for the Adafruit LoRA Radio Bonnet with OLED - RFM95W @ 9
 
 It also allows you to connect as a client to the Helium Network.
 
-You must create a device on the Helium Console at https://console.helium.com/
-
-You need to rename "keys_example.py" to "keys.py" and enter you device information from the Helium Console.
 
 
 ## Installation
-To register a device and get a device ID you need to run otaa_helium.py and stores the results in keys.py.
+
+After forking the repo, install the python libs:
+
+    pip3 install -r requirements.txt
+
+## Credentials
+
+The keys can be added to a `./.env` file:
+
+```
+deveui = 1234ASD432
+appeui = 234ASD4321
+appkey = 34ASD43210
+
+devaddr = [00,11,22]
+nwskey = [11,22,33]
+appskey = [22,33,44]
+```
+
+They can also be passed as environment variables:
+
+```
+deveui=1234ASD432 python3 rssi_helium.py
+```
+
+## Registration
+
+You must create a device on the Helium Console at https://console.helium.com/
+
+After copying the device credentials (the first three in the `.env` file, above), run otaa_helium.py, which will get the final three credentials for the `.env` file.
 
 Then you can run tx_helium.py to send messages by specifying the msg and the frame like this:
 

gps.py

@@ -0,0 +1,50 @@
+from math import sin, cos, sqrt, atan2, radians
+import datetime
+from gpsdclient import GPSDClient
+
+client = GPSDClient(host="127.0.0.1")
+def get_gps_data(transact_timeout=10):
+    start = datetime.datetime.now()
+    for result in client.dict_stream(convert_datetime=True):
+        (datetime.datetime.now() - start).seconds < transact_timeout
+        if result["class"] == "TPV":
+            return {"lat": result.get("lat"), "lon": result.get("lon"), "speed": result.get("speed"), "alt": result.get("alt")}
+
+
+def get_dist(lat1,lon1,lat2,lon2):
+    # approximate radius of earth in km
+    R = 6373.0
+    lat1 = radians(lat1)
+    lon1 = radians(lon1)
+    lat2 = radians(lat2)
+    lon2 = radians(lon2)
+    dlon = lon2 - lon1
+    dlat = lat2 - lat1
+    a = sin(dlat / 2)**2 + cos(lat1) * cos(lat2) * sin(dlon / 2)**2
+    print(a)
+    if not a:
+        return 0
+    c = 2 * atan2(sqrt(a), sqrt(1 - a))
+    distance = R * c
+    return distance
+
+def should_send_gps(new, old, last_sent_at):
+    if last_sent_at is None:
+        return True
+    if not new:
+        return False
+    if new and not old:
+        return True
+    if new.get("lat") is not None and  new.get("lon") is not None and None in [old.get("lat"), old.get("lon")]:
+        return True
+    if None not in [new["lat"], new["lon"], old["lat"], old["lon"]]:
+        distance = get_dist(new["lat"], new["lon"], old["lat"], old["lon"])
+        if distance < 0.05:
+            if (datetime.datetime.now() - last_sent_at).seconds > 60*5:
+                return True
+            else:
+                return False
+        else:
+            return True
+    else:
+        return False

gps_simpletest.py

@@ -0,0 +1,109 @@
+# SPDX-FileCopyrightText: 2021 ladyada for Adafruit Industries
+# SPDX-License-Identifier: MIT
+
+# Simple GPS module demonstration.
+# Will wait for a fix and print a message every second with the current location
+# and other details.
+import time
+import board
+import busio
+
+import adafruit_gps
+
+# Create a serial connection for the GPS connection using default speed and
+# a slightly higher timeout (GPS modules typically update once a second).
+# These are the defaults you should use for the GPS FeatherWing.
+# For other boards set RX = GPS module TX, and TX = GPS module RX pins.
+# uart = busio.UART(board.TX, board.RX, baudrate=9600, timeout=10)
+
+# for a computer, use the pyserial library for uart access
+import serial
+uart = serial.Serial("/dev/ttyUSB1", baudrate=9600, timeout=10)
+
+# If using I2C, we'll create an I2C interface to talk to using default pins
+# i2c = board.I2C()
+
+# Create a GPS module instance.
+gps = adafruit_gps.GPS(uart, debug=False)  # Use UART/pyserial
+# gps = adafruit_gps.GPS_GtopI2C(i2c, debug=False)  # Use I2C interface
+
+# Initialize the GPS module by changing what data it sends and at what rate.
+# These are NMEA extensions for PMTK_314_SET_NMEA_OUTPUT and
+# PMTK_220_SET_NMEA_UPDATERATE but you can send anything from here to adjust
+# the GPS module behavior:
+#   https://cdn-shop.adafruit.com/datasheets/PMTK_A11.pdf
+
+# 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")
+# Turn on just minimum info (RMC only, location):
+# gps.send_command(b'PMTK314,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0')
+# Turn off everything:
+# gps.send_command(b'PMTK314,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0')
+# Turn on everything (not all of it is parsed!)
+# gps.send_command(b'PMTK314,1,1,1,1,1,1,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")
+# Or decrease to once every two seconds by doubling the millisecond value.
+# Be sure to also increase your UART timeout above!
+# gps.send_command(b'PMTK220,2000')
+# You can also speed up the rate, but don't go too fast or else you can lose
+# data during parsing.  This would be twice a second (2hz, 500ms delay):
+# gps.send_command(b'PMTK220,500')
+
+# Main loop runs forever printing the location, etc. every second.
+last_print = time.monotonic()
+while True:
+    # Make sure to call gps.update() every loop iteration and at least twice
+    # as fast as data comes from the GPS unit (usually every second).
+    # This returns a bool that's true if it parsed new data (you can ignore it
+    # though if you don't care and instead look at the has_fix property).
+    gps.update()
+    # Every second print out current location details if there's a fix.
+    current = time.monotonic()
+    if current - last_print >= 1.0:
+        last_print = current
+        if not gps.has_fix:
+            # Try again if we don't have a fix yet.
+            print("Waiting for fix...")
+            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_mon,  # Grab parts of the time from the
+                gps.timestamp_utc.tm_mday,  # struct_time object that holds
+                gps.timestamp_utc.tm_year,  # the fix time.  Note you might
+                gps.timestamp_utc.tm_hour,  # not get all data like year, day,
+                gps.timestamp_utc.tm_min,  # month!
+                gps.timestamp_utc.tm_sec,
+            )
+        )
+        print("Latitude: {0:.6f} degrees".format(gps.latitude))
+        print("Longitude: {0:.6f} degrees".format(gps.longitude))
+        print(
+            "Precise Latitude: {:2.}{:2.4f} degrees".format(
+                gps.latitude_degrees, gps.latitude_minutes
+            )
+        )
+        print(
+            "Precise Longitude: {:2.}{:2.4f} degrees".format(
+                gps.longitude_degrees, gps.longitude_minutes
+            )
+        )
+        print("Fix quality: {}".format(gps.fix_quality))
+        # Some attributes beyond latitude, longitude and timestamp are optional
+        # and might not be present.  Check if they're None before trying to use!
+        if gps.satellites is not None:
+            print("# satellites: {}".format(gps.satellites))
+        if gps.altitude_m is not None:
+            print("Altitude: {} meters".format(gps.altitude_m))
+        if gps.speed_knots is not None:
+            print("Speed: {} knots".format(gps.speed_knots))
+        if gps.track_angle_deg is not None:
+            print("Track angle: {} degrees".format(gps.track_angle_deg))
+        if gps.horizontal_dilution is not None:
+            print("Horizontal dilution: {}".format(gps.horizontal_dilution))
+        if gps.height_geoid is not None:
+            print("Height geoid: {} meters".format(gps.height_geoid))

helium.py

@@ -1,2 +1,42 @@
-UPFREQ = 903.9
-DOWNFREQ = 923.3
+import time
+import requests
+from helium_authenticator import HeliumAuthenticator
+from helium_transactor import keys, HeliumTransactor
+
+class Helium:
+    def authenticate(self):
+        try_count = 0
+        while try_count < 5:
+            try:
+                authentication = HeliumAuthenticator.authenticate()
+                cur_keys = self.keys
+                for k,v in authentication.items():
+                    cur_keys[k] = v
+                keys.write(cur_keys)
+            except:
+                print("Failed Auth")
+                try_count += 1
+                time.sleep(3)
+            return authentication
+
+    def register_device(self):
+        # if we have never seen the device, build some ... machinery and APIs etc to register this device.
+        # response = requests.get("http://somewebsite.com/register_device.json"+some_authentication_information)
+        return None
+
+    def get_last_message(self):
+        return self.ht.last_message
+
+    def transact(self, msg):
+        return self.ht.transact(msg)
+
+    def __init__(self, passed_keys=None, verbose=False):
+        self.keys = keys.get_keys()
+        if not self.keys.get("deveui"):
+            self.register_device()
+        if not self.keys.get("nwskey"):
+            self.authenticate()
+        helium_keys = passed_keys or keys.get_keys()
+        self.ht = HeliumTransactor.init(verbose, helium_keys)
+
+