AlLoRa 1.1.0__tar.gz

AlLoRa-1.1.0/AlLoRa/Connectors/Connector.py

@@ -0,0 +1,111 @@
+from AlLoRa.Packet import Packet
+try:
+    from utime import sleep, ticks_ms as time
+    from uos import urandom
+    import gc
+except:
+    from time import sleep, time
+    from os import urandom
+
+class Connector:
+    MAX_LENGTH_MESSAGE = 255
+
+    def __init__(self):
+        self.MAC = "00000000"
+
+    def config(self, name="N", frequency = 868, sf=7, mesh_mode=False, debug=False, min_timeout = 0.5, max_timeout = 6):
+        self.name = name
+        self.frequency = frequency
+        self.sf = sf
+        self.mesh_mode = mesh_mode
+
+        self.debug = debug
+
+        self.min_timeout = min_timeout
+        self.max_timeout = max_timeout
+        self.adaptive_timeout = self.min_timeout
+        self.backup_timeout = self.adaptive_timeout
+
+        self.sf_backup = self.sf
+
+    def backup_config(self):
+        return {"freq": self.frequency,
+                "sf": self.sf,
+                "min_timeout":  self.min_timeout,
+                "max_timeout":  self.max_timeout
+                }
+
+    def get_mac(self):
+        return self.MAC
+
+    def set_sf(self, sf):
+        pass
+
+    def backup_sf(self):
+        self.sf_backup = self.sf
+
+    def restore_sf(self):
+        self.set_sf(self.sf_backup)
+
+    def set_mesh_mode(self, mesh_mode=False):
+        self.mesh_mode = mesh_mode
+
+    def send(self, packet: Packet):
+        return None
+
+    def recv(self, focus_time=12):
+        return None
+
+    def send_and_wait_response(self, packet):
+        packet.set_source(self.get_mac())  # Adding mac address to packet
+        focus_time = self.adaptive_timeout
+        send_success = self.send(packet)
+        #if not send_success:
+            #return None
+
+        while focus_time > 0:
+            t0 = time()
+            received_data = self.recv(focus_time)
+            td = (time() - t0)/1000
+            if not received_data:
+                random_factor = int.from_bytes(urandom(2), "little") / 2**16
+                self.adaptive_timeout = min(self.adaptive_timeout * (1 + random_factor),
+                                        self.max_timeout) #random exponential backoff.
+                gc.collect()
+                return None
+            response_packet = Packet(self.mesh_mode)
+            if self.debug:
+                self.signal_estimation()
+                print("WAIT_RESPONSE({}) || sender_reply: {}".format(self.adaptive_timeout, received_data))
+            try:
+                response_packet.load(received_data)
+                if response_packet.get_source() == packet.get_destination() and response_packet.get_destination() == self.get_mac():
+                    if len(received_data) > response_packet.HEADER_SIZE + 60:	# Hardcoded for only chunks
+                        self.adaptive_timeout = max(self.adaptive_timeout * 0.8 + td * 0.21, self.min_timeout)
+                    if response_packet.get_debug_hops():
+                        response_packet.add_hop(self.name, self.get_rssi(), 0)
+                    if response_packet.get_change_sf():
+                        print("OK and changing sf")
+                        new_sf = int(response_packet.get_payload().decode().split('"')[1])
+                        print(new_sf)
+                        self.set_sf(new_sf)
+                    gc.collect()
+                    return response_packet
+            except Exception as e:
+                print("Corrupted packet received", e, received_data)
+            focus_time = self.adaptive_timeout - td
+
+    """ This function returns the RSSI of the last received packet"""
+    def get_rssi(self):
+        return 0
+
+    def signal_estimation(self):
+        percentage = 0
+        rssi = self.get_rssi()
+        if (rssi >= -50):
+            percentage = 100
+        elif (rssi <= -50) and (rssi >= -100):
+            percentage = 2 * (rssi + 100)
+        elif (rssi < 100):
+            percentage = 0
+        print('SIGNAL STRENGTH', percentage, '%')

AlLoRa-1.1.0/AlLoRa/Connectors/LoPy4_connector.py

@@ -0,0 +1,76 @@
+from time import sleep
+
+from AlLoRa.Packet import Packet
+from AlLoRa.Connectors.Connector import Connector
+from network import LoRa
+import socket
+import binascii
+
+import pycom
+
+class LoPy4_connector(Connector):
+
+    def __init__(self):
+        super().__init__()
+        self.MAC = binascii.hexlify(LoRa().mac()).decode('utf-8')[-8:]
+
+    def config(self, name = "L", frequency = 868, sf=7,
+                mesh_mode=False, debug=False,  min_timeout = 0.5, max_timeout = 6): #max_timeout = 100
+        super().config(name, frequency, sf, mesh_mode, debug, min_timeout, max_timeout)
+        self.lora = LoRa(mode=LoRa.LORA, frequency=self.frequency*1000000,
+                            region=LoRa.EU868, sf = self.sf)
+        self.lora_socket = socket.socket(socket.AF_LORA, socket.SOCK_RAW)
+
+    def set_sf(self, sf):
+        if self.sf != sf:
+            self.lora.sf(sf)
+            self.sf = sf
+            if self.debug:
+                print("SF Changed to: ", self.sf)
+
+    def get_stats(self):
+        stats = self.lora.stats()
+        if self.debug:
+            print("rx_timestamp {0}, rssi {1}, snr {2}, sftx {3}, sfrx {4}, tx_trials {5}, tx_power {6}, tx_time_on_air {7}, tx_counter {8}, tx_frequency {9}".format(stats[0],
+                    stats[1], stats[2], stats[3], stats[4], stats[5], stats[6], stats[7], stats[8], stats[9]))
+        return stats
+
+    def get_rssi(self):
+        return self.lora.stats()[1]
+
+    def send(self, packet):
+        if packet.get_length() <= Connector.MAX_LENGTH_MESSAGE:
+            if self.debug:
+                print("SEND_PACKET(SF: {}) || packet: {}".format(self.sf, packet.get_content()))
+                if packet.get_mesh():
+                    pycom.rgbled(0xb19cd8) # purple
+                else:
+                    pycom.rgbled(0x007f00) # green
+            try:
+                self.lora_socket.send(packet.get_content())	#.encode()
+                if self.debug:
+                    pycom.rgbled(0)        # off
+                return True
+            except:
+                if self.debug:
+                    pycom.rgbled(0)        # off
+                return False
+        else:
+            if self.debug:
+                print("Error: Packet too big")
+            return False
+
+    def recv(self, focus_time=12):
+        try:
+            self.lora_socket.settimeout(focus_time)
+            data = self.lora_socket.recv(Connector.MAX_LENGTH_MESSAGE)
+            self.lora_socket.setblocking(False)
+            if self.debug:
+                self.get_stats()
+            return data
+        except Exception as e:
+            if self.debug:
+                print("Error receiving: ", e)
+
+    def send_and_wait_response(self, packet):
+        return super().send_and_wait_response(packet)

AlLoRa-1.1.0/AlLoRa/Connectors/SX127x_connector.py

@@ -0,0 +1,63 @@
+import time
+import ubinascii
+import network
+
+from AlLoRa.Packet import Packet
+from AlLoRa.Connectors.Connector import Connector
+
+# Requires PyLora_SX127x_extensions to be installed
+# https://github.com/GRCDEV/PyLora_SX127x_extensions
+from PyLora_SX127x_extensions.pyLora import pyLora
+
+class SX127x_connector(Connector):
+
+    def __init__(self): #max_timeout = 10
+        super().__init__()
+
+        wlan_sta = network.WLAN(network.STA_IF)
+        wlan_sta.active(True)
+        wlan_mac = wlan_sta.config('mac')
+        self.MAC = ubinascii.hexlify(wlan_mac).decode()[-8:]
+        wlan_sta.active(False)
+
+    def config(self, name = "S", frequency = 868, sf=7, mesh_mode=False, debug=False,  min_timeout = 0.5, max_timeout = 6):  #max_timeout = 10
+        super().config(name, frequency, sf, mesh_mode, debug, min_timeout, max_timeout)
+        self.lora = pyLora(freq = self.frequency,
+                            sf=self.sf, verbose= self.debug)
+        self.lora.setblocking(False) 
+
+    def set_sf(self, sf):
+        if self.sf != sf:
+            self.lora.sf(sf)
+            self.sf = sf
+            if self.debug:
+                print("SF Changed to: ", self.sf)
+
+    def get_rssi(self):
+        return self.lora.get_rssi()
+
+    def send(self, packet):
+        if self.debug:
+            print("SEND_PACKET() || packet: {}".format(packet.get_content()))
+        if packet.get_length() <= Connector.MAX_LENGTH_MESSAGE:
+            try:
+                self.lora.setblocking(True)
+                self.lora.send(packet.get_content())  # .encode()
+                self.lora.setblocking(False)
+                return True
+            except:
+                self.lora.setblocking(False)
+                return False
+        else:
+            if self.debug:
+                print("Error: Packet too big")
+            return False
+
+    def recv(self, focus_time=12):
+        try:
+            self.lora.settimeout(focus_time)
+            data = self.lora.recv(Connector.MAX_LENGTH_MESSAGE)
+            return data
+        except:
+            if self.debug:
+                print("nothing received or error")

AlLoRa-1.1.0/AlLoRa/Connectors/Serial_connector.py

@@ -0,0 +1,49 @@
+import serial, struct
+from time import sleep, time
+
+
+from AlLoRa.Packet import Packet
+from AlLoRa.Connectors.Connector import Connector
+
+class Serial_connector(Connector):
+
+    def __init__(self, serial_port = "/dev/ttyAMA3", baud = 9600, timeout = 1):
+        super().__init__()
+        self.SERIAL_PORT = serial_port
+        self.BAUD_RATE = baud
+        self.timeout = timeout
+        self.serial = serial.Serial(self.SERIAL_PORT, self.BAUD_RATE, timeout=self.timeout)
+        
+
+    def send_and_wait_response(self, packet: Packet) -> Packet:
+        if self.debug:
+            print("send and wait")
+        retry = True
+        max_retries = 1
+        response_packet = Packet(self.mesh_mode)
+        while max_retries > 0 and retry:
+            try:
+                content = packet.get_content()
+                if self.debug:
+                    print("Sending: ", content) 
+                
+                self.serial.write(content)
+                sleep(1)
+                received_data = self.serial.read(255)
+                
+                if received_data:
+                    response_packet = Packet(self.mesh_mode)
+                    check = response_packet.load(received_data)   
+                    if check:
+                        if self.debug:
+                            print("Receiving: ", response_packet.get_content())
+                        retry = False
+                
+            except Exception as e:
+                retry = True
+                if self.debug:
+                    print("Error S&W: ", e)
+            finally:
+                max_retries -= 1
+
+        return response_packet

AlLoRa-1.1.0/AlLoRa/Connectors/Wifi_connector.py

@@ -0,0 +1,67 @@
+import socket
+import json
+import select
+from time import sleep, time
+
+from AlLoRa.Packet import Packet
+from AlLoRa.Connectors.Connector import Connector
+
+class WiFi_connector(Connector):
+
+    def __init__(self, RECEIVER_API_HOST, RECEIVER_API_PORT, SOCKET_TIMEOUT=10, 
+                    SOCKET_RECV_SIZE=10000,  PACKET_RETRY_SLEEP=0.5, logger_error=None):
+        super().__init__()
+        self.SOCKET_TIMEOUT = SOCKET_TIMEOUT
+        self.RECEIVER_API_HOST = RECEIVER_API_HOST
+        self.RECEIVER_API_PORT = RECEIVER_API_PORT
+        self.SOCKET_RECV_SIZE = SOCKET_RECV_SIZE
+        self.logger_error = logger_error
+        self.PACKET_RETRY_SLEEP = PACKET_RETRY_SLEEP
+
+    def send_and_wait_response(self, packet: Packet) -> Packet:
+        json_response = None
+        retry = True
+        max_retries = 1
+        response_packet = Packet(self.mesh_mode)
+        while max_retries > 0 and retry:
+            try:
+                s = socket.socket()
+                s.setblocking(True)
+                addr = socket.getaddrinfo(self.RECEIVER_API_HOST, self.RECEIVER_API_PORT)[0][-1]
+                s.settimeout(self.SOCKET_TIMEOUT)
+                s.connect(addr)
+
+                content_str = packet.get_dict()
+                content = json.dumps({"packet": content_str})
+
+                httpreq = 'POST {} HTTP/1.1\r\nHost: {}\r\nConnection: close\r\nAccept: */*\r\nContent-Type: application/json\r\nContent-Length: {}\r\n\r\n{}'.format(
+                    "/send-packet", self.RECEIVER_API_HOST, len(content), content).encode('utf-8')
+
+                ready_to_read, ready_to_write, in_error = select.select([],
+                                                                        [s],
+                                                                        [],
+                                                                        15)
+                s.send(httpreq)
+                ready_to_read, ready_to_write, in_error = select.select([s],
+                                                                        [],
+                                                                        [s],
+                                                                        15)
+                response = s.recv(self.SOCKET_RECV_SIZE)
+
+                retry = False
+                try:
+                    extracted_response = response.decode('utf-8').split('\r\n\r\n')[1]
+                    json_response = json.loads(extracted_response)
+                    response_packet.load_dict(json_response['response_packet'])
+                except Exception as e:
+                    #print("Error in load: ", e)
+                    pass    # It fails when response is empty
+
+            except Exception as e:
+                #self.logger_error.error("Allowed Exception (Network connection was interrupted by some reason, but will keep trying to reconnect): {}".format(e))
+                sleep(self.PACKET_RETRY_SLEEP)
+                retry = True
+            finally:
+                max_retries -= 1
+
+        return response_packet

AlLoRa-1.1.0/AlLoRa/DataSource.py

@@ -0,0 +1,115 @@
+import _thread
+import utime
+import os
+
+from AlLoRa.File import CTP_File
+
+# Do not instanciate this class as pretends to be an abstract one
+class DataSource:
+
+
+    def __init__(self, file_chunk_size: int, file_queue_size=25, sleep_between_readings=60):
+
+        self.STOP_THREAD = True
+        self.IS_STARTED = False
+
+        self.file_queue = []
+        self.file_queue_size = file_queue_size
+        self.file_chunk_size = file_chunk_size
+
+        self.SECONDS_BETWEEN_READINGS = sleep_between_readings
+
+        self.backup_file = None
+
+
+    def get_file_chunk_size(self):
+        return self.file_chunk_size
+
+
+    def add_to_queue(self, file: CTP_File):
+        if len(self.file_queue) >= self.file_queue_size:
+            self.file_queue.pop(0)
+        repeated = False
+        for f in self.file_queue:
+            if f.get_name() == file.get_name():
+                repeated = True
+                break
+        if repeated is False:
+            self.file_queue.append(file)
+
+
+    def read(self):
+        while self.STOP_THREAD is False:
+            try:
+                file = self.read_datasource()
+                if file is not None:
+                    self.add_to_queue(file=file)
+                else:
+                    print("skipped file, it is None")
+                utime.sleep(self.SECONDS_BETWEEN_READINGS)
+            except KeyboardInterrupt as e:
+                self.stop()
+        self.IS_STARTED = False
+        print(self.STOP_THREAD)
+
+
+    def read_datasource(self) -> CTP_File:
+        pass
+
+
+    def prepare(self):
+        pass
+
+    def start(self):
+        self.prepare()
+        self.STOP_THREAD = False
+        self.IS_STARTED = True
+        _thread.start_new_thread(self.read, ())
+
+
+    def stop(self):
+        self.STOP_THREAD = True
+        print(self.STOP_THREAD)
+
+    def is_started(self):
+        return self.IS_STARTED
+
+    '''
+    Everytime this function is called, it assumes the file is already consumed, so a deleting is performed.
+    '''
+    def get_next_file(self):
+        try:
+            backup_file = self.file_queue.pop(0)
+            self.backup(file=backup_file)
+            return backup_file
+        except IndexError as e:
+            return None
+
+
+    def get_backup(self):
+        try:
+            filename = ""
+            with open("./filename-backup.txt", "r") as f:
+                filename = f.read()
+ 
+            content = None
+            with open("./content-backup", "r") as f:
+                content = f.read()
+            rescued_file = CTP_File(name='{}'.format(filename), content=bytearray(content), chunk_size=self.file_chunk_size)
+            return rescued_file
+        except OSError as e:
+            print("The backup could not be restored", e)
+
+
+    def backup(self, file: CTP_File):
+        try:
+            os.remove("./filename-backup.txt")
+            os.remove("./content-backup")
+        except OSError:
+            pass
+ 
+        with open("./filename-backup.txt", "w") as f:
+            f.write(file.get_name())
+ 
+        with open("./content-backup", "w") as f:
+            f.write(file.get_content())

AlLoRa-1.1.0/AlLoRa/Digital_Endpoint.py

@@ -0,0 +1,105 @@
+from AlLoRa.File import CTP_File
+
+class Digital_Endpoint:
+
+    REQUEST_DATA_STATE = "REQUEST_DATA_STATE"
+    PROCESS_CHUNK_STATE = "PROCESS_CHUNK_STATE"
+    OK = "OK"
+
+    def __init__(self, name: str, mac_address: str, active: bool = True, sleep_mesh: bool = True,
+                        MAX_RETRANSMISSIONS_BEFORE_MESH: int = 10):
+        self.name = name
+        self.mac_address = mac_address[-8:]
+        self.active = active
+        self.current_file = None
+
+        self.state = Digital_Endpoint.OK
+
+        self.mesh = False
+        self.sleep_mesh = sleep_mesh
+        self.retransmission_counter = 0
+        self.MAX_RETRANSMISSIONS_BEFORE_MESH = MAX_RETRANSMISSIONS_BEFORE_MESH
+
+    def get_name(self):
+        return self.name
+
+    def get_mac_address(self):
+        return self.mac_address
+
+    def get_mesh(self):
+        return self.mesh
+
+    def is_active(self):
+        return self.active
+
+    def enable_mesh(self):
+        self.mesh = True
+        print("Node {}: ENABLING MESH".format(self.name))
+
+    def disable_mesh(self):
+        self.mesh = False
+        self.retransmission_counter = 0
+        print("Node {}: DISABLING MESH".format(self.name))
+
+    def get_sleep(self):
+        return self.sleep_mesh
+
+    def count_retransmission(self):
+        if not self.get_mesh():
+            self.retransmission_counter += 1
+            if self.retransmission_counter >= self.MAX_RETRANSMISSIONS_BEFORE_MESH:
+                self.enable_mesh()
+
+    def reset_retransmission_counter(self, hop): #packet
+        if not self.get_mesh():                        # If mesh mode is deactivated and I receive a message from this node
+            self.retransmission_counter = 0           # Reset counter, going well...
+        else:
+            if not hop:
+                self.disable_mesh()
+
+    def set_current_file(self, file: CTP_File):
+        self.current_file = file
+
+    def get_current_file(self):
+        return self.current_file
+
+    def connected(self, ok, hop, mesh_mode):
+        if ok:
+            if mesh_mode:
+                self.reset_retransmission_counter(hop)
+            self.state = Digital_Endpoint.REQUEST_DATA_STATE
+        else:
+            if mesh_mode:
+                self.count_retransmission()
+        
+    def set_metadata(self, metadata, hop, mesh_mode):
+        if metadata:
+            new_file = CTP_File(name = metadata[1], length = metadata[0])
+            self.set_current_file(new_file)
+            if mesh_mode:
+                self.reset_retransmission_counter(hop)
+            
+            self.state = Digital_Endpoint.PROCESS_CHUNK_STATE
+        else:
+            if mesh_mode:
+                self.count_retransmission()
+
+    def get_next_chunk(self):
+        try:
+            self.current_chunk = self.current_file.get_missing_chunks()[0]
+            return self.current_chunk
+        except:
+            return None
+
+    def set_data(self, data, hop, mesh_mode):  
+        if data:
+            self.current_file.add_chunk(self.current_chunk, data)
+            if mesh_mode:
+                self.reset_retransmission_counter(hop)
+        else:
+            if mesh_mode:
+                self.count_retransmission()
+        
+        if len(self.current_file.get_missing_chunks()) <= 0:
+            self.state = Digital_Endpoint.OK
+            return self.current_file