AlLoRa 1.2.0__tar.gz → 2.0.0__tar.gz

allora-2.0.0/AlLoRa/Connectors/Connector.py

@@ -0,0 +1,323 @@
+from AlLoRa.Packet import Packet
+import gc
+from math import ceil
+from AlLoRa.utils.time_utils import get_time, current_time_ms as time, sleep, sleep_ms
+from AlLoRa.utils.debug_utils import print
+from AlLoRa.utils.os_utils import os
+from os import urandom
+
+class Connector:
+    MAX_LENGTH_MESSAGE = 255
+
+    def __init__(self):
+        self.MAC = "00000000"
+        self.observed_min_timeout = float('inf')
+        self.debug = False
+
+    def config(self, config_json):
+        # JSON Example:
+        # {
+        #     "name": "N",
+        #     "frequency": 868,
+        #     "sf": 7,
+        #     "mesh_mode": false,
+        #     "debug": false,
+        #     "min_timeout": 0.5,
+        #     "max_timeout": 6
+        # }
+        self.config_parameters = config_json
+        if self.config_parameters:
+            self.name = self.config_parameters.get('name', "N")
+            self.debug = self.config_parameters.get('debug', False)
+
+            self.frequency = self.config_parameters.get('freq', 868)    # 868 MHz
+            self.sf = self.config_parameters.get('sf', 7)               # SF7
+            self.bw = self.config_parameters.get("bandwidth", 125)            # 125 kHz
+            self.cr = self.config_parameters.get("coding_rate", 1)            # 4/5
+            self.tx_power = self.config_parameters.get("tx_power", 14)         # 14 dBm
+
+            self.mesh_mode = self.config_parameters.get('mesh_mode', False)
+            self.short_mac = self.config_parameters.get('short_mac', False)
+
+            self.min_timeout = self.config_parameters.get('min_timeout', 0.5)
+            self.max_timeout = self.config_parameters.get('max_timeout', 6)
+            self.timeout_delta = self.config_parameters.get('timeout_delta', 1)  # Delta for processing times
+        
+            # Calculate initial adaptive timeouts
+            self.update_timeouts()
+
+            self.adaptive_timeout = self.max_timeout
+            self.backup_timeout = self.adaptive_timeout
+            self.backup_rf_config()
+        else:
+            if self.debug:
+                print("Error: No config parameters")
+
+    def get_max_payload_size(self):
+        if self.sf < 11:
+            return 255
+        elif self.sf == 11:
+            return 111
+        elif self.sf == 12:
+            return 30   #51
+
+    def update_timeouts(self):
+        # Calculate the min and max timeouts based on the ToA for the current RF settings
+        self.max_payload_size = self.get_max_payload_size()
+        min_toa = self.calculate_toa(self.sf, self.bw, self.cr, self.max_payload_size)   # Max payload
+        max_toa = min_toa * 2
+        self.min_timeout = min_toa + self.timeout_delta # Convert ms to seconds
+        self.max_timeout = max_toa + self.timeout_delta  # Convert ms to seconds and add delta for processing times
+        if self.debug:
+            print("Updated timeouts: Min: {} s, Max: {} s".format(self.min_timeout, self.max_timeout))
+
+    def calculate_toa(self, sf, bw, cr, payload_size):
+        if self.debug:
+            print("TOA with SF:", sf, "BW:", bw, "CR:", cr, "Payload:", payload_size)
+        crc = 1  # CRC enabled
+        bw_hz = bw * 1000   # Convert bandwidth to Hz
+        t_symbol = (2 ** sf) / bw_hz    # Symbol duration
+        t_preamble = t_symbol * (8 + 4.25)  # Preamble duration
+        h = 0   # Implicit header disabled
+        de = 1 if (sf >= 11 and bw == 125) else 0   # Low data rate optimization enabled for SF11 and SF12 with 125kHz BW
+        cr_rate = cr / 4.0  # Coding rate
+        # Payload Symbol Calculation
+        payload_bits = 8 * payload_size - 4 * sf + 28 + 16 * (1 if crc else 0) - 20 * h
+        bits_per_symbol = 4 * (sf - 2 * de)
+        n_payload = 8 + max(0, int(ceil(payload_bits / bits_per_symbol) * (cr_rate + 4)))
+        
+        # Payload Duration
+        t_payload = t_symbol * n_payload
+        
+        # Total Time on Air
+        t_air = t_preamble + t_payload
+        if self.debug:
+            print("TOA:", t_air)
+        
+        return t_air
+
+    def backup_config(self):
+        return self.config_parameters
+
+    def get_mac(self):
+        return self.MAC
+
+    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 increase_adaptive_timeout(self):
+        random_factor = int.from_bytes(urandom(2), "little") / 2**16
+        self.adaptive_timeout = min(self.adaptive_timeout * (1 + random_factor), self.max_timeout)
+
+    def decrease_adaptive_timeout(self, td):
+        smoothing_factor = 0.2
+        new_timeout = self.adaptive_timeout * (1 - smoothing_factor) + td * smoothing_factor
+        self.observed_min_timeout = min(self.observed_min_timeout, td)
+        self.adaptive_timeout = max(new_timeout, max(self.min_timeout, self.observed_min_timeout))
+    
+    def send_and_wait_response(self, packet):
+        focus_time = self.adaptive_timeout
+        packet_size_sent = len(packet.get_content())
+        try:
+            send_success = self.send(packet)
+            if not send_success:
+                error_info = {
+                    "type": "SEND_ERROR",
+                    "message": "Error sending packet",
+                    "focus_time": focus_time,
+                    "adaptive_timeout": self.adaptive_timeout,
+                }
+                if self.debug:
+                    print(error_info["message"])
+                return error_info, packet_size_sent, 0, 0
+        except Exception as e:
+            error_info = {
+                "type": "EXCEPTION",
+                "message": "Exception during send: {}".format(e),
+                "focus_time": focus_time,
+                "adaptive_timeout": self.adaptive_timeout,
+            }
+            if self.debug:
+                print(error_info["message"])
+            self.increase_adaptive_timeout()
+            return error_info, packet_size_sent, 0, 0
+
+        while focus_time > 0:
+            t0 = time()
+            try:
+                received_data = self.recv(focus_time)
+            except Exception as e:
+                error_info = {
+                    "type": "EXCEPTION",
+                    "message": "Exception during recv: {}".format(e),
+                    "focus_time": focus_time,
+                    "adaptive_timeout": self.adaptive_timeout,
+                }
+                if self.debug:
+                    print(error_info["message"])
+                return error_info, packet_size_sent, 0, 0
+
+            td = (time() - t0) / 1000  # Calculate the time difference in seconds
+            packet_size_received = len(received_data) if received_data else 0
+
+            if not received_data:
+                error_info = {
+                    "type": "TIMEOUT",
+                    "message": "No response received",
+                    "focus_time": focus_time,
+                    "time_difference": td,
+                    "adaptive_timeout": self.adaptive_timeout,
+                }
+                if self.debug:
+                    print(error_info["message"])
+                self.increase_adaptive_timeout()
+                return error_info, packet_size_sent, packet_size_received, td
+
+            response_packet = Packet(self.mesh_mode, self.short_mac)
+            if self.debug:
+                print("WAIT_RESPONSE({}) at: {}|| source_reply: {}".format(td, self.adaptive_timeout, received_data))
+            try:
+                if 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.decrease_adaptive_timeout(td)
+                        if response_packet.get_debug_hops():
+                            response_packet.add_hop(self.name, self.get_rssi(), 0)
+                        return response_packet, packet_size_sent, packet_size_received, td
+                else:
+                    if len(received_data) > 0:
+                        error_info = {
+                            "type": "CORRUPTED_PACKET",
+                            "message": "{}".format(received_data),
+                        }
+                    else:
+                        error_info = {
+                            "type": "NO_PACKET",
+                            "message": "No packet received",
+                        }
+                    if self.debug:
+                        print(error_info["message"])
+                    return error_info, packet_size_sent, packet_size_received, td
+
+            except Exception as e:
+                error_info = {
+                    "type": "EXCEPTION",
+                    "message": "Exception during packet load: {}, data: {}".format(e, received_data),
+                }
+                if self.debug:
+                    print(error_info["message"])
+                return error_info, packet_size_sent, packet_size_received, td
+
+            focus_time = self.adaptive_timeout - td
+            if focus_time < self.min_timeout:
+                focus_time = self.min_timeout
+                error_info = {
+                    "type": "MIN_TIMEOUT_REACHED",
+                    "message": "Minimum timeout reached, can't wait more",
+                    "focus_time": focus_time,
+                }
+                if self.debug:
+                    print(error_info["message"])
+                return error_info, packet_size_sent, packet_size_received, td
+
+    # This function returns the RSSI of the last received packet
+    def get_rssi(self):
+        return 0
+
+    # This function returns the SNR of the last received packet
+    def get_snr(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
+        if self.debug:
+            print('SIGNAL STRENGTH', percentage, '%')
+        return percentage
+
+    def get_rf_config(self):
+        return [self.frequency, self.sf, self.bw, self.cr, self.tx_power]
+
+    def change_rf_config(self, frequency=None, sf=None, bw=None, cr=None, tx_power=None, backup=True):
+        if backup:
+            self.backup_rf_config()
+        try:
+            if frequency is not None:
+                self.set_frequency(frequency)
+            if sf is not None:
+                self.set_sf(sf)
+            if bw is not None:
+                self.set_bw(bw)
+            if cr is not None:
+                self.set_cr(cr)
+            if tx_power is not None:
+                self.set_transmission_power(tx_power)
+            self.update_timeouts()
+            self.adaptive_timeout = self.max_timeout
+            return True
+        except Exception as e:
+            if self.debug:
+                print("Error changing RF config: ", e)
+            self.restore_rf_config()
+            return False
+
+    def backup_rf_config(self):
+        self.last_rf_config = [self.frequency, 
+                                    self.sf, 
+                                    self.bw, 
+                                    self.cr, 
+                                    self.tx_power]
+
+    def update_rf_params(self, params):
+        """
+        Updates the connector's RF parameters.
+        Override in derived classes if needed.
+        """
+        self.frequency = params.get("frequency", self.frequency)
+        self.sf = params.get("sf", self.sf)
+        self.bw = params.get("bw", self.bw)
+        self.cr = params.get("cr", self.cr)
+        self.tx_power = params.get("tx_power", self.tx_power)
+        if self.debug:
+            print("Updated RF parameters:", self.get_rf_config())
+
+    def restore_rf_config(self):
+        frequency =  self.last_rf_config[0]
+        sf = self.last_rf_config[1]
+        bw = self.last_rf_config[2] 
+        cr = self.last_rf_config[3]
+        tx_power = self.last_rf_config[4]
+        self.change_rf_config(frequency=frequency, 
+                                sf=sf, 
+                                bw=bw, 
+                                cr=cr, 
+                                tx_power=tx_power,
+                                backup=False)
+
+
+    def set_frequency(self, frequency):
+        pass
+
+    def set_sf(self, sf):
+        pass
+
+    def set_bw(self, bw):
+        pass
+
+    def set_cr(self, cr):
+        pass
+
+    def set_transmission_power(self, tx_power):
+        pass

allora-2.0.0/AlLoRa/Connectors/E5_connector.py

@@ -0,0 +1,339 @@
+import utime
+from machine import UART
+import ubinascii
+# import network
+import re
+from math import ceil
+
+from AlLoRa.Packet import Packet
+from AlLoRa.Connectors.Connector import Connector
+from AlLoRa.utils.debug_utils import print
+
+class E5_connector(Connector):
+    def __init__(self):
+        super().__init__()
+
+    def config(self, config_json):
+        super().config(config_json)
+        if self.config_parameters:
+            connector_config = self.config_parameters
+
+            self.debug = connector_config.get("debug", True)
+
+            self.uart_id = connector_config.get("uart_id", 1)
+            self.baudrate = connector_config.get("baudrate", 115200)  
+            self.tx_pin = connector_config.get("tx", 43)
+            self.rx_pin = connector_config.get("rx", 44)
+            self.bits = connector_config.get("bits", 8)
+            self.parity = connector_config.get("parity", None)
+            self.stop = connector_config.get("stop", 1)
+            self.timeout = connector_config.get("timeout", 300)  # Set the UART timeout to 300 ms
+            self.txbuf = connector_config.get("txbuf", 150)  # TX buffer size
+            self.rxbuf = connector_config.get("rxbuf", 150)  # RX buffer size
+            
+            self.tx_preamble = connector_config.get("tx_preamble", 8)
+            self.rx_preamble = connector_config.get("rx_preamble", 8)
+            
+            self.crc = connector_config.get("crc", "ON")
+            self.iq = connector_config.get("iq", "OFF")
+            self.net = connector_config.get("net", "ON")
+
+            
+            # Initialize UART with the default baud rate
+            self.uart = UART(self.uart_id, 9600)
+            self.uart.init(baudrate=9600, tx=self.tx_pin, rx=self.rx_pin, bits=self.bits, 
+                            parity=self.parity, stop=self.stop, timeout=self.timeout,
+                            txbuf=self.txbuf, rxbuf=self.rxbuf)
+            
+            # Set the baud rate to the desired value and restart the module
+            self.set_uart_baudrate(self.baudrate)
+            self.restart_module()
+            # Reinitialize UART with the new baud rate
+            self.uart.init(baudrate=self.baudrate, tx=self.tx_pin, rx=self.rx_pin, bits=self.bits, parity=self.parity, stop=self.stop, timeout=self.timeout)
+            
+            # Set the UART timeout
+            self.set_uart_timeout(0)
+
+            # Enter test mode and configure RF settings
+            self.enter_test_mode()
+            self.set_rf_config(self.frequency, self.sf, self.bw, self.tx_preamble, self.rx_preamble, self.tx_power, self.crc, self.iq, self.net)
+            if self.debug:
+                print("Configuration: uart_id={}, baudrate={}, tx={}, rx={}, bits={}, parity={}, stop={}, timeout={}".format(
+                    self.uart_id, self.baudrate, self.tx_pin, self.rx_pin, self.bits, self.parity, self.stop, self.timeout))
+                print("RF Configuration: frequency={}, sf={}, bandwidth={}, tx_preamble={}, rx_preamble={}, tx_power={}, crc={}, iq={}, net={}".format(
+                    self.frequency, self.sf, self.bw, self.tx_preamble, self.rx_preamble, self.tx_power, self.crc, self.iq, self.net))
+            self.get_mac_from_module()
+
+    def get_mac_from_module(self):
+        cmd = "AT+ID\r\n"
+        expected_response = "+ID: DevEui,"
+        default_APP_EUI = "80:00:00:00:00:00:00:06"
+        success, response = self.send_command(cmd, expected_response, 500)
+        if success:
+            if self.debug:
+                print("Response:", response.decode())
+            mac = response.decode()#.split('+ID: ')[-1].strip()
+            obtained_APP_EUI = mac.split('DevEui, ')[1][:23]
+            self.MAC = obtained_APP_EUI.replace(':', '').strip()
+            if self.debug:
+                print("Obtained APP_EUI:", obtained_APP_EUI)
+                print("MAC:", self.MAC)
+
+    def set_dynamic_uart_timeout(self, timeout):
+        self.uart.init(baudrate=self.baudrate, tx=self.tx_pin, rx=self.rx_pin, bits=self.bits, parity=self.parity, stop=self.stop, timeout=timeout)
+        if self.debug:
+            print("UART timeout set to:", timeout)
+
+    # AT Commands
+    def send_command(self, cmd, expected_response, timeout_ms):
+        start_time_total = utime.ticks_ms()
+
+        self.uart.write(cmd)
+        utime.sleep_ms(10)  # Short sleep to ensure command is processed
+        
+        start_time = utime.ticks_ms()
+        response = b''
+        while utime.ticks_diff(utime.ticks_ms(), start_time) < timeout_ms:
+            if self.uart.any():
+                response += self.uart.read()
+                if expected_response in response:
+                    end_time_total = utime.ticks_ms()
+                    if self.debug:
+                        print("send_command Total Time:", utime.ticks_diff(end_time_total, start_time_total), "ms")
+                    return True, response
+        end_time_total = utime.ticks_ms()
+        if self.debug:
+            print("send_command Total Time:", utime.ticks_diff(end_time_total, start_time_total), "ms")
+        return False, response
+    
+    def set_uart_baudrate(self, baudrate):
+        cmd = "AT+UART=BR,{}\r\n".format(baudrate)
+        print("Set Baud Rate Command:", cmd)
+        expected_response = "+UART=BR"
+        success, response = self.send_command(cmd, expected_response, 500)
+        if self.debug:
+            print("Set Baud Rate Response:", response.decode())
+        return success
+
+    def set_uart_timeout(self, timeout):
+        cmd = "AT+UART=TIMEOUT,{}\r\n".format(timeout)
+        if self.debug:
+            print("Set Timeout Command:", cmd)
+        expected_response = "+UART: TIMEOUT, {}".format(timeout)
+        success, response = self.send_command(cmd, expected_response, 500)
+        if self.debug:
+            print("Set Timeout Response:", response.decode(), "Success:", success)
+        return success
+
+    def restart_module(self):
+        # Send a command to reset the module (if available) or reinitialize the UART
+        cmd = "AT+RESET\r\n"
+        if self.debug:
+            print("Restart Module Command:", cmd)
+        expected_response = "+RESET"
+        success, response = self.send_command(cmd, expected_response, 1000)
+        if self.debug:
+            print("Restart Module Response:", response.decode())
+        utime.sleep(1)  # Wait for the module to reset
+        return success
+
+    def enter_test_mode(self):
+        cmd = "AT+MODE=TEST\r\n"
+        expected_response = "+MODE: TEST"
+        success, response = self.send_command(cmd, expected_response, 2000)
+        if self.debug:
+            print("Enter Test Mode Response:", response.decode())
+        return success
+
+    def receive_packet(self, timeout=10000, chunk_size=124):
+        cmd = "AT+TEST=RXLRPKT\r\n"
+        success = self.uart.write(cmd)
+        
+        t0_ack = utime.ticks_ms()
+        ack = self.uart.read(32)
+        start_time_total = utime.ticks_ms()
+        response = b''
+        
+        while utime.ticks_diff(utime.ticks_ms(), start_time_total) < timeout:
+            if self.uart.any():
+                response += self.uart.read(min(chunk_size, self.uart.any()))
+                if response.endswith(b'"\r\n'):
+                    break
+            else:
+                utime.sleep_ms(1)
+        
+        end_time_total = utime.ticks_ms()
+        if self.debug:
+            print("receive_packet Total Time:", utime.ticks_diff(end_time_total, start_time_total), "ms")
+        
+        return response if response else None
+
+    def send_packet(self, data):
+        cmd = 'AT+TEST=TXLRPKT,"{}"\r\n'.format(data)
+        start_time_total = utime.ticks_ms()
+        expected_response = "+TEST: TXLRPKT"    #expected_response = "+TEST: TX DONE\r\n"    #
+        sfs = {8: 2, 9: 4, 10: 8, 11: 16, 12: 32}
+        sf_changed = False
+        if self.sf > 7:
+            self.set_dynamic_uart_timeout(ceil((self.timeout * sfs[self.sf])*1.1))
+            sf_changed = True
+
+        wt0 = utime.ticks_ms()
+        success = self.uart.write(cmd)
+        wt1 = utime.ticks_ms()
+        print("Time to write:", utime.ticks_diff(wt1, wt0), "ms")
+        start_time = utime.ticks_ms()
+        #response = b''
+        response = self.uart.read()
+        if sf_changed:
+            self.set_dynamic_uart_timeout(self.timeout) # Set the UART timeout back to the default value
+        #expected_response = "+TEST: TXLRPKT"
+        
+        end_time_total = utime.ticks_ms()
+        if self.debug:
+            print("send_packet Total Time:", utime.ticks_diff(end_time_total, start_time_total), "ms")
+        try: 
+            if expected_response in response:
+                return True
+            else:
+                return False
+        except:
+            return False
+
+    # Packet Handling
+    def hex_to_bytes(self, hex_str):
+        hex_str = hex_str.replace('"', '').replace('\n', '').replace(' ', '').strip()
+        if len(hex_str) % 2 != 0:
+            raise ValueError("odd-length string")
+        return bytes.fromhex(hex_str)
+
+    def bytes_to_hex(self, byte_str):
+        return byte_str.hex()
+
+    def extract_packet_info(self, response):
+        # time_0 = utime.ticks_ms()
+        rssi_match = re.search(r'RSSI:(-?\d+)', response)
+        snr_match = re.search(r'SNR:(-?\d+)', response)
+
+        if rssi_match:
+            try:
+                self.rssi = int(rssi_match.group(1))
+            except ValueError:
+                self.rssi = None
+        else:
+            self.rssi = None
+
+        if snr_match:
+            try:
+                self.snr = int(snr_match.group(1))
+            except ValueError:
+                self.snr = None
+               
+        else:
+            self.snr = None
+    
+    # Connector Methods
+    def send(self, packet):
+        data = packet.get_content()
+        hex_data = self.bytes_to_hex(data)
+        hex_data = hex_data.strip().strip('"')
+        
+        success = self.send_packet(hex_data)
+        
+        return success
+
+    def recv(self, focus_time=12):
+        rt_0 = utime.ticks_ms()
+        packet_data = self.receive_packet(focus_time * 1000)
+        if packet_data:
+            try:
+                self.extract_packet_info(packet_data)
+                hex_data = packet_data.decode().split('RX ')[-1].strip().strip('"')
+                bytes_data = self.hex_to_bytes(hex_data)
+                return bytes_data
+            except (ValueError, IndexError) as e:
+                if self.debug:
+                    print("Error decoding packet:", e)
+        return None
+
+    def get_rssi(self):
+        return self.rssi
+
+    def get_snr(self):
+        return self.snr
+
+    def change_rf_config(self, frequency=None, sf=None, bw=None, cr=None, tx_power=None, backup=True):
+        if self.debug:
+            print("Changing RF Config to: ", frequency, sf, bw, cr, tx_power)
+        if backup:
+            self.backup_rf_config()
+        freq = frequency if frequency is not None else self.frequency
+        sf = sf if sf is not None else self.sf
+        bandwidth = bw if bw is not None else self.bw
+        cr = cr if cr is not None else self.cr
+        tx_power = tx_power if tx_power is not None else self.tx_power
+        success = self.set_rf_config(freq, sf, bandwidth, self.tx_preamble, self.rx_preamble, tx_power, self.crc, self.iq, self.net)
+        if success:
+            if self.debug:
+                print("RF Config Changed to: ", freq, sf, bandwidth, cr, tx_power)
+            self.update_timeouts()
+            self.adaptive_timeout = self.max_timeout
+            return True
+        else:
+            self.restore_rf_config()
+            return False
+
+    def set_rf_config(self, frequency, sf, bandwidth, tx_preamble, rx_preamble, tx_power, crc, iq, net):
+        cmd = "AT+TEST=RFCFG,{},SF{},{},{},{},{},{},{},{}\r\n".format(frequency, sf, bandwidth, tx_preamble, rx_preamble, tx_power, crc, iq, net)
+        print(cmd)
+        expected_response = "+TEST: RFCFG"
+        success, response = self.send_command(cmd, expected_response, 2000)
+        if self.debug:
+            print("Set RF Config Response:", response.decode())
+        if success:
+            if self.debug:
+                print("RF Config Set to:", frequency, sf, bandwidth, tx_preamble, rx_preamble, tx_power, crc, iq, net)
+            self.frequency = frequency
+            self.sf = sf
+            self.bw = bandwidth
+            self.tx_preamble = tx_preamble
+            self.rx_preamble = rx_preamble
+            self.tx_power = tx_power
+            self.crc = crc
+            self.iq = iq
+            self.net = net
+        return success
+
+    def set_frequency(self, frequency):
+        success = self.set_rf_config(frequency, "SF" + str(self.sf), self.bw, self.tx_preamble, self.rx_preamble, self.tx_power, self.crc, self.iq, self.net)
+        if success:
+            if self.debug:
+                print("Frequency Set to:", frequency)
+        return success
+
+    def set_sf(self, sf):
+        success = self.set_rf_config(self.frequency, "SF" + str(self.sf), self.bw, self.tx_preamble, self.rx_preamble, self.tx_power, self.crc, self.iq, self.net)
+        if success:
+            if self.debug:
+                print("SF Changed to:", sf)
+        return success
+
+    def set_bw(self, bw):
+        success = self.set_rf_config(self.frequency, "SF" + str(self.sf), bw, self.tx_preamble, self.rx_preamble, self.tx_power, self.crc, self.iq, self.net)
+        if success:
+            if self.debug:
+                print("Bandwidth Set to:", bw)
+        return success
+
+    def set_cr(self, cr):
+        # CR is not configurable in E5 module
+        if self.debug:
+            print("CR is not configurable in E5 module")
+        return False
+
+    def set_transmission_power(self, desired_power):
+        success = self.set_rf_config(self.frequency, "SF" + str(self.sf), self.bw, self.tx_preamble, self.rx_preamble, desired_power, self.crc, self.iq, self.net)
+        if success:
+            if self.debug:
+                print("Transmission Power Set to:", desired_power)
+        return success

{AlLoRa-1.2.0 → allora-2.0.0}/AlLoRa/Connectors/LoPy4_connector.py

@@ -2,6 +2,7 @@ from time import sleep
 
 from AlLoRa.Packet import Packet
 from AlLoRa.Connectors.Connector import Connector
+from AlLoRa.utils.debug_utils import print
 from network import LoRa
 import socket
 import binascii