diff --git a/gw_RPi3/README b/gw_RPi3/README new file mode 100644 index 0000000..0a160e8 --- /dev/null +++ b/gw_RPi3/README @@ -0,0 +1 @@ +pi@192.168.1.180 : raspberry diff --git a/gw_RPi3/config.txt b/gw_RPi3/config.txt new file mode 100755 index 0000000..95d1c14 --- /dev/null +++ b/gw_RPi3/config.txt @@ -0,0 +1,59 @@ +# For more options and information see +# http://rpf.io/configtxt +# Some settings may impact device functionality. See link above for details + +# uncomment if you get no picture on HDMI for a default "safe" mode +#hdmi_safe=1 + +# uncomment this if your display has a black border of unused pixels visible +# and your display can output without overscan +#disable_overscan=1 + +# uncomment the following to adjust overscan. Use positive numbers if console +# goes off screen, and negative if there is too much border +#overscan_left=16 +#overscan_right=16 +#overscan_top=16 +#overscan_bottom=16 + +# uncomment to force a console size. By default it will be display's size minus +# overscan. +#framebuffer_width=1280 +#framebuffer_height=720 + +# uncomment if hdmi display is not detected and composite is being output +#hdmi_force_hotplug=1 + +# uncomment to force a specific HDMI mode (this will force VGA) +#hdmi_group=1 +#hdmi_mode=1 + +# uncomment to force a HDMI mode rather than DVI. This can make audio work in +# DMT (computer monitor) modes +#hdmi_drive=2 + +# uncomment to increase signal to HDMI, if you have interference, blanking, or +# no display +#config_hdmi_boost=4 + +# uncomment for composite PAL +#sdtv_mode=2 + +#uncomment to overclock the arm. 700 MHz is the default. +#arm_freq=800 + +# Uncomment some or all of these to enable the optional hardware interfaces +dtparam=i2c_arm=on +#dtparam=i2s=on +dtparam=spi=on +dtparam=i2c1=on, dtparam=i2c_arm_baudrate=100000 + +# Uncomment this to enable the lirc-rpi module +#dtoverlay=lirc-rpi + +# Additional overlays and parameters are documented /boot/overlays/README + +# Enable audio (loads snd_bcm2835) +dtparam=audio=on +dtoverlay=disable-bt +dtoverlay=i2c1 diff --git a/gw_RPi3/python/Endpoint.py b/gw_RPi3/python/Endpoint.py new file mode 100644 index 0000000..541d322 --- /dev/null +++ b/gw_RPi3/python/Endpoint.py @@ -0,0 +1,32 @@ +#!/usr/bin/env python3 +# -*- coding: utf-8 -*- +""" +Created on Wed Jun 9 11:15:10 2021 + +@author: Georges de Massol +""" +import base64 +#import binascii + +class Endpoint: + def __init__(self, EUI = None): + """ + + Parameters + ---------- + EUI : bytes + ex : bytes([0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01]) + + Returns + ------- + None. + + """ + # This must point to the API interface. + self.EUI = EUI + + #EUI = bytes([0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01]) + def EUIfromjson(self, json): + self.EUI = base64.b64decode(json["devEUI"]).hex() + return self.EUI + \ No newline at end of file diff --git a/gw_RPi3/python/gat.py b/gw_RPi3/python/gat.py new file mode 100644 index 0000000..6e7aefb --- /dev/null +++ b/gw_RPi3/python/gat.py @@ -0,0 +1,124 @@ +#!/usr/bin/env python3 +# -*- coding: utf-8 -*- +""" +Do not execute directly. +Please execute gateway_http_uplink.py + +Created on Mon Oct 19 2021 + +@author: ALKADRI Mohammad +""" + +from gateway_http_downlink import Downlink + +from Endpoint import Endpoint + +import time +from datetime import datetime +import os +import json +import base64 + + +APIKey = 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJhcGlfa2V5X2lkIjoiYzA2ZGY1MDMtNjE5Zi00ZjI2LTgxNzEtYTU0OTRmMWJmYmRmIiwiYXVkIjoiYXMiLCJpc3MiOiJhcyIsIm5iZiI6MTYyMjY1MzMzMSwic3ViIjoiYXBpX2tleSJ9.23eLyvgd5zheP9hDM0acCAl9ojhQjLTZAU77IKqhvQY' +server = 'localhost:8080' +#just defining an instance to be used +downlink = Downlink(server, APIKey) +directory = '/home/pi/python/' + + + +def WriteFile(body, event): + filename = directory + "log/" + \ + time.strftime("%Y_%m_%d_%H-%M-%S") + '_' + event + # in case of unexisting folder 'log' + if not os.path.exists(directory + 'log'): + os.mkdir(directory + 'log') + # in case of already existing file : + if os.path.exists(filename + ".json"): + i = 2 + while(os.path.exists(filename + '_' + str(i) + ".json")): + i += 1 + path = filename + '_' + str(i) + ".json" + else: + path = filename + ".json" + + f = open(path, "a") + f.write(body.decode("utf-8")) + f.close() + print("file written : %s" % path) + + +def step0(endpoint): + downlink.FlushQueue(endpoint.EUI) + downlink.Lorasend(endpoint.EUI, b'\x46') + print("State: The data sent by Gateway") + + +def step1(endpoint): + T3 = 222333 + T4 = 1112223 + print ("T3 : %s" % T3.to_bytes(4, 'big')) + print ("T4 : %s" % T4.to_bytes(4, 'big')) + T = T4 << 32| T3 + print ("T : %s" % T) + print ("T : %s" % T.to_bytes(8, 'big')) + downlink.FlushQueue(endpoint.EUI) + # send all data + downlink.Lorasend(endpoint.EUI, T.to_bytes(8, 'big')) + + +def reset(endpoint): + downlink.FlushQueue(endpoint.EUI) + downlink.Lorasend(endpoint.EUI, b'\x55') #initialisation packet + print("enpoint reset : %s" % endpoint.EUI) + + +def postcompute(event, body, Tn): + global data + print(datetime.utcnow().strftime('%Y-%m-%d %H:%M:%S.%f')[:-3]) + + json_ = json.loads(body) + endpoint = Endpoint() + endpoint.EUIfromjson(json_) + + print("request from :\nEUI : %s" % endpoint.EUI) + print("name : %s" % json_['deviceName']) + # write json in a file + WriteFile(body, event) + + print("event : %s " % event) + print(datetime.utcnow().strftime('%Y-%m-%d %H:%M:%S.%f')[:-3]) + #treat all cases + if event == 'up': + #b64 to bytes + data = base64.b64decode(json_["data"]) + #bytes to integer + #integer = int.from_bytes(data, 'big') + print("data received from Endpoint : ") + print("base 64 : %s" % json_["data"]) + print("bytes : %s" % data) + #print("int : %s" % integer) + print() + print(datetime.utcnow().strftime('%Y-%m-%d %H:%M:%S.%f')[:-3]) + data = int.from_bytes(data, 'big') + print("data : %s" % data) + print("fin") + elif event == 'txack': + print("data : %s" % data) + if data == 0x5374617274 : # 0x5374617274 : Start + step0(endpoint) + elif data == 0x54696D6573: # 0x54696D6573 : Times + step1(endpoint) + else: + print("error : uncovered State") + reset(endpoint) + elif event == 'error': + print('error : ' + json_["error"]) + else: + print("possible error : uncovered event") + print(body) + reset(endpoint) + print() + +print("Chirpstack server for downlink : %s" % downlink.server) diff --git a/gw_RPi3/python/gate.py b/gw_RPi3/python/gate.py new file mode 100644 index 0000000..bd03469 --- /dev/null +++ b/gw_RPi3/python/gate.py @@ -0,0 +1,165 @@ +#!/usr/bin/env python3 +# -*- coding: utf-8 -*- +""" +Do not execute directly. +Please execute gateway_http_downlink.py + +Created on Tue Jun 8 16:37:22 2021 + +@author: Georges de Massol +""" + +from gateway_http_downlink import Downlink + +from Endpoint import Endpoint + +import time +from datetime import datetime +import os +import json +import base64 + + + +APIKey = 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJhcGlfa2V5X2lkIjoiYzA2ZGY1MDMtNjE5Zi00ZjI2LTgxNzEtYTU0OTRmMWJmYmRmIiwiYXVkIjoiYXMiLCJpc3MiOiJhcyIsIm5iZiI6MTYyMjY1MzMzMSwic3ViIjoiYXBpX2tleSJ9.23eLyvgd5zheP9hDM0acCAl9ojhQjLTZAU77IKqhvQY' +server = 'localhost:8080' +#just defining an instance to be used +downlink = Downlink(server, APIKey) +directory = '/home/pi/python/' + + +State = 0 + +def WriteFile(body, event): + filename = directory + "log/" + \ + time.strftime("%Y_%m_%d_%H-%M-%S") + '_' + event + # in case of unexisting folder 'log' + if not os.path.exists(directory + 'log'): + os.mkdir(directory + 'log') + # in case of already existing file : + if os.path.exists(filename + ".json"): + i = 2 + while(os.path.exists(filename + '_' + str(i) + ".json")): + i += 1 + path = filename + '_' + str(i) + ".json" + else: + path = filename + ".json" + + f = open(path, "a") + f.write(body.decode("utf-8")) + f.close() + print("file written : %s" % path) + + +def step0(Tn, endpoint): + global T2, State + print("Last State sss : %s" % State) + if State != 0: + print("probable error : message unexpected :") + print("Last State sss : %s" % State) + print("Current State : 0") + #reset() + T2 = Tn + State = 0 + +def step1(data, endpoint): + global T3, State, dTg + T3 = data + State = 1 + + #time spent by gateway between uplink and downlink + dTg = T3+1 + print ("Tg : %s" % dTg.to_bytes(4, 'big')) + downlink.FlushQueue(endpoint.EUI) + # send all data for step 3 + downlink.Lorasend(endpoint.EUI, b'\x01' + dTg.to_bytes(4, 'big')) + +def step2(endpoint, data): + global State + + if State != 1: + print("probable error : message unexpected :") + print("Last State : %s" % State) + print("Current State : 2") + reset() + + State = 2 + + dTe = int.from_bytes(data, 'big') + dTv = (dTe - dTg)/2 + print("time of flight (samples number) : %s" % dTv) + print("time of flight (microseconds) : %s" % (dTv * 0.0005)) ## 1 sample = 500ns + +def step3(endpoint): + global State + State = 3 + + #reset the endpoint + reset(endpoint) + +def reset(endpoint): + global State + downlink.FlushQueue(endpoint.EUI) + downlink.Lorasend(endpoint.EUI, b'\x55')#initialisation packet + print("enpoint reset : %s" % endpoint.EUI) + State = 0 +def postcompute(event, body, Tn): + print("D") + global data + print(datetime.utcnow().strftime('%Y-%m-%d %H:%M:%S.%f')[:-3]) + + json_ = json.loads(body) + endpoint = Endpoint() + endpoint.EUIfromjson(json_) + + print("request from :\nEUI : %s" % endpoint.EUI) + print("name : %s" % json_['deviceName']) + # write json in a file + WriteFile(body, event) + + + print("event : %s " % event) + print(datetime.utcnow().strftime('%Y-%m-%d %H:%M:%S.%f')[:-3]) + #treat all cases + if event == 'up': + #b64 to bytes + data = base64.b64decode(json_["data"]) + #bytes to integer + integer = int.from_bytes(data, 'big') + print("data received from Endpoint : ") + print("base 64 : %s" % json_["data"]) + print("bytes : %s" % data) + print("int : %s" % integer) + print() + + step = data[0] + print("step : %s" % step) + print("data : %s" % data[1:]) + if step == 0: + step0(Tn, endpoint) + elif step == 2: + step2(endpoint, data[1:]) + else: + print("error : uncovered step : %s" % step) + reset(endpoint) + print(datetime.utcnow().strftime('%Y-%m-%d %H:%M:%S.%f')[:-3]) + data = int.from_bytes(data, 'big') + print("fin") + elif event == 'txack': + print("data sent to endpoint") + if State == 0: + step1(data, endpoint) + elif State == 2: + step3(endpoint) + else: + print('error : state %s not expected', State) + reset(endpoint) + + elif event == 'error': + print('error : ' + json_["error"]) + else: + print("possible error : uncovered event") + print(body) + reset(endpoint) + print() +print("Chirpstack server for downlink : %s" % downlink.server) diff --git a/gw_RPi3/python/gateway.py b/gw_RPi3/python/gateway.py new file mode 100644 index 0000000..6d85691 --- /dev/null +++ b/gw_RPi3/python/gateway.py @@ -0,0 +1,199 @@ +#!/usr/bin/env python3 +# -*- coding: utf-8 -*- +""" +Do not execute directly. +Please execute gateway_http_downlink.py + +Created on Tue Jun 8 16:37:22 2021 + +@author: Georges de Massol +""" + +from gateway_http_downlink import Downlink + +from Endpoint import Endpoint + +import time +from datetime import datetime +import os +import json +import base64 + + +APIKey = 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJhcGlfa2V5X2lkIjoiYzA2ZGY1MDMtNjE5Zi00ZjI2LTgxNzEtYTU0OTRmMWJmYmRmIiwiYXVkIjoiYXMiLCJpc3MiOiJhcyIsIm5iZiI6MTYyMjY1MzMzMSwic3ViIjoiYXBpX2tleSJ9.23eLyvgd5zheP9hDM0acCAl9ojhQjLTZAU77IKqhvQY' +server = 'localhost:8080' +#just defining an instance to be used +downlink = Downlink(server, APIKey) +directory = '/home/pi/python/' + + +State = 0 + +def WriteFile(body, event): + filename = directory + "log/" + \ + time.strftime("%Y_%m_%d_%H-%M-%S") + '_' + event + # in case of unexisting folder 'log' + if not os.path.exists(directory + 'log'): + os.mkdir(directory + 'log') + # in case of already existing file : + if os.path.exists(filename + ".json"): + i = 2 + while(os.path.exists(filename + '_' + str(i) + ".json")): + i += 1 + path = filename + '_' + str(i) + ".json" + else: + path = filename + ".json" + + f = open(path, "a") + f.write(body.decode("utf-8")) + f.close() + print("file written : %s" % path) + + +def step0(Tn, endpoint): + global T2, State + + print("Last State sss : %s" % State) + if State != 0: + print("probable error : message unexpected :") + print("Last State sss : %s" % State) + print("Current State : 0") + #reset() + T2 = Tn + State = 0 + +State=0 +dTg=0 +T3=0 + +def step1(data, endpoint): + global T3, State, dTg + T3 = data + State = 1 + + #time spent by gateway between uplink and downlink + dTg = T3+1 + print ("Tg : %s" % dTg.to_bytes(4, 'big')) + downlink.FlushQueue(endpoint.EUI) + # send all data for step 3 + downlink.Lorasend(endpoint.EUI, b'\x01' + dTg.to_bytes(7, 'big')) + + + +def step2(endpoint, data): + global State, dTg + + if State != 1: + print("probable error : message unexpected :") + print("Last State : %s" % State) + print("Current State : 2") + reset(endpoint) + + State = 2 + + dTe = int.from_bytes(data, 'big') + dTv = (dTe - dTg)/2 + print("time of flight (samples number) : %s" % dTv) + print("time of flight (microseconds) : %s" % (dTv * 0.0005)) ## 1 sample = 500ns + +def step3(endpoint): + global State + State = 3 + + #reset the endpoint + reset(endpoint) + +def reset(endpoint): + global State + downlink.FlushQueue(endpoint.EUI) + downlink.Lorasend(endpoint.EUI, b'\x55')#initialisation packet + print("enpoint reset : %s" % endpoint.EUI) + State = 0 +def postcompute(event, body, Tn): + print("D") + global data + print(datetime.utcnow().strftime('%Y-%m-%d %H:%M:%S.%f')[:-3]) + + json_ = json.loads(body) + endpoint = Endpoint() + endpoint.EUIfromjson(json_) + + print("request from :\nEUI : %s" % endpoint.EUI) + print("name : %s" % json_['deviceName']) + # write json in a file + WriteFile(body, event) + + print("event : %s " % event) + print(datetime.utcnow().strftime('%Y-%m-%d %H:%M:%S.%f')[:-3]) + #treat all cases + if event == 'up': + #b64 to bytes + data = base64.b64decode(json_["data"]) + #bytes to integer + integer = int.from_bytes(data, 'big') + print("data received from Endpoint : ") + print("base 64 : %s" % json_["data"]) + print("bytes : %s" % data) + print("int : %s" % integer) + print() + + step = data[0] + print("step : %s" % step) + print("data : %s" % data[1:]) + if step == 0: + step0(Tn, endpoint) + elif step == 2: + step2(endpoint, data[1:]) + else: + print("error : uncovered step : %s" % step) + reset(endpoint) + """ + print("preparation des donnees pour envoi a la prochaine connection du EndNode") + print(datetime.utcnow().strftime('%Y-%m-%d %H:%M:%S.%f')[:-3]) + print("message pour : %s" % endpoint.EUI) + print("message int : %s" % integer) + #send a LoRa packet + fCnt = downlink.Lorasend(endpoint.EUI, data) + # Print the downlink frame-counter value. + print("fCnt : %s" % fCnt) + """ + + print(datetime.utcnow().strftime('%Y-%m-%d %H:%M:%S.%f')[:-3]) + data = int.from_bytes(data, 'big') + print("fin") + elif event == 'txack': + print("data sent to endpoint") + if State == 0: + step1(data, endpoint) + elif State == 2: + step3(endpoint) + else: + print('error : state %s not expected', State) + reset(endpoint) + + elif event == 'error': + print('error : ' + json_["error"]) + else: + print("possible error : uncovered event") + print(body) + reset(endpoint) + print() + + + +# def start(): +# ok = False +# while not ok: +# try: +# Time = time.time() +# fCnt = downlink.Lorasend("70b3d549966002e1", Time) +# print(fCnt) +# time.sleep(5) +# ok = True +# except: +# pass +# +# start() + +#print ("Chirpstack API Key :\n%s" % downlink.api_token) +print("Chirpstack server for downlink : %s" % downlink.server) diff --git a/gw_RPi3/python/gateway_http_downlink.py b/gw_RPi3/python/gateway_http_downlink.py new file mode 100644 index 0000000..364687f --- /dev/null +++ b/gw_RPi3/python/gateway_http_downlink.py @@ -0,0 +1,95 @@ +#!/usr/bin/env python3 +# -*- coding: utf-8 -*- +""" +Created on Tue Jun 8 16:03:39 2021 + +@author: Georges de Massol +""" +import grpc +from chirpstack_api.as_pb.external import api + +class Downlink: + def __init__(self, server = "localhost:8080", api_token = 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJhcGlfa2V5X2lkIjoiYzA2ZGY1MDMtNjE5Zi00ZjI2LTgxNzEtYTU0OTRmMWJmYmRmIiwiYXVkIjoiYXMiLCJpc3MiOiJhcyIsIm5iZiI6MTYyMjY1MzMzMSwic3ViIjoiYXBpX2tleSJ9.23eLyvgd5zheP9hDM0acCAl9ojhQjLTZAU77IKqhvQY'): + """ + + Parameters + ---------- + server : string, optional + Chirpstack server adress, with port. The default is "localhost:8080". + api_token : TYPE, optional + Chirpstack API token. + + Returns + ------- + None. + + """ + # This must point to the API interface. + self.server = server + + # The DevEUI for which you want to enqueue the downlink. + #dev_eui = bytes([0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01]) + + # The API token (retrieved using the web-interface). + self.api_token = api_token + + def Lorasend(self, dev_eui, data): + """ + + Parameters + ---------- + dev_eui : hex + The DevEUI for which you want to enqueue the downlink. + data : bytes + Data to be sent to the endpoint. + + Returns + ------- + fCnt : int + Downlink frame-counter value. + + """ + # Connect without using TLS. + channel = grpc.insecure_channel(self.server) + + # Device-queue API client. + client = api.DeviceQueueServiceStub(channel) + + # Define the API key meta-data. + auth_token = [("authorization", "Bearer %s" % self.api_token)] + + # Construct request. + req = api.EnqueueDeviceQueueItemRequest() + req.device_queue_item.confirmed = False + req.device_queue_item.data = bytes(data) + req.device_queue_item.dev_eui = dev_eui + req.device_queue_item.f_port = 10 + + resp = client.Enqueue(req, metadata=auth_token) + + return resp.f_cnt + def FlushQueue(self, dev_eui): + """ + Flush the downlink queue of an endpoint. + + Parameters + ---------- + dev_eui : hex + Endpoint EUI. + + """ + # Connect without using TLS. + channel = grpc.insecure_channel(self.server) + + # Device-queue API client. + client = api.DeviceQueueServiceStub(channel) + + # Define the API key meta-data. + auth_token = [("authorization", "Bearer %s" % self.api_token)] + + + req = api.FlushDeviceQueueRequest() + req.dev_eui = dev_eui + + client.Flush(req, metadata=auth_token) + \ No newline at end of file diff --git a/gw_RPi3/python/gateway_http_uplink.py b/gw_RPi3/python/gateway_http_uplink.py new file mode 100644 index 0000000..962c4a1 --- /dev/null +++ b/gw_RPi3/python/gateway_http_uplink.py @@ -0,0 +1,75 @@ +#!/usr/bin/env python3 +# -*- coding: utf-8 -*- +""" +Script to be executed. +Open a http server with function serve_forever(port) + +Created on Wed Jun 9 10:56:11 2021 + +@author: Georges de Massol +""" + + + +from http.server import HTTPServer, BaseHTTPRequestHandler +import urllib.parse +import gateway +import test_gateway +import gat +ip = 'localhost' + +class SimpleHTTPRequestHandler(BaseHTTPRequestHandler): + def do_GET(self): + self.send_response(200) + self.end_headers() + self.wfile.write(b'Serveur uplink en marche!') + print("do_get") + + def do_POST(self): + print("do_post00") + + # ↓↓↓ Lecture de la dernière valeur de GNU Radio ↓↓↓ + # la lecture est faite le plus tôt possible pour éviter tout parasitage par un autre appareil. + + # Tn : échantillon n + Tn = 123456 + # ↑↑↑ Lecture de la dernière valeur de GNU Radio ↑↑↑ + content_length = int(self.headers['Content-Length']) + body = self.rfile.read(content_length) + self.send_response(200) + self.end_headers() + print(urllib.parse.urlparse(self.path)) + print("do_post0") + # print(urllib.parse.parse_qs(urllib.parse.urlparse(self.path).query)) + event = urllib.parse.parse_qs(urllib.parse.urlparse(self.path).query).get('event', None)[0] + print("do_post1") + gat.postcompute(event, body, Tn) + print("do_post2") + +def serve_forever(port = 6666): + """ + Function executed permanently. + Do not run code after this function. + + Parameters + ---------- + port : int, optional + Port for the server. The default is 6666. + + Returns + ------- + None. + + """ + print("d1") + + httpd = HTTPServer((ip, port), SimpleHTTPRequestHandler) + print("d2") + print("http server for uplink started on {}:{}\n".format(ip, port)) + print("d3") + httpd.serve_forever() + print("d4") + + +#do not add code then +serve_forever() diff --git a/gw_RPi3/python/test_gateway.py b/gw_RPi3/python/test_gateway.py new file mode 100644 index 0000000..34ca268 --- /dev/null +++ b/gw_RPi3/python/test_gateway.py @@ -0,0 +1,23 @@ +#!/usr/bin/env python3 +# -*- coding: utf-8 -*- +""" + +Code de test pour envoyer des requetes au gateway. + +Created on Fri Jun 11 09:12:11 2021 + +@author: Georges de Massol +""" + +import gateway as gw + +gw.server = '192.168.1.180:8080' +EUI = "70b3d549966002e1" +endpoint = gw.Endpoint(EUI) +downlink = gw.Downlink(gw.server, gw.APIKey) +#fCnt = downlink.Lorasend(endpoint.EUI, b'\x01' + int(10000).to_bytes(4, 'big')) +downlink.FlushQueue(endpoint.EUI) +print("queue flushed") +fCnt = downlink.Lorasend(endpoint.EUI, b'\x55') +print("premier paquet envoye, fCnT : %s" % fCnt) +#downlink.ResetCounter(endpoint.EUI)