--- /dev/null
+from __future__ import print_function
+from Interface import Interface
+from time import sleep
+import sys
+import serial
+import threading
+import time
+import math
+import RNS
+
+class KISS():
+ FEND = chr(0xC0)
+ FESC = chr(0xDB)
+ TFEND = chr(0xDC)
+ TFESC = chr(0xDD)
+
+ CMD_UNKNOWN = chr(0xFE)
+ CMD_DATA = chr(0x00)
+ CMD_FREQUENCY = chr(0x01)
+ CMD_BANDWIDTH = chr(0x02)
+ CMD_TXPOWER = chr(0x03)
+ CMD_SF = chr(0x04)
+ CMD_CR = chr(0x05)
+ CMD_RADIO_STATE = chr(0x06)
+ CMD_RADIO_LOCK = chr(0x07)
+ CMD_DETECT = chr(0x08)
+ CMD_PROMISC = chr(0x0E)
+ CMD_READY = chr(0x0F)
+ CMD_STAT_RX = chr(0x21)
+ CMD_STAT_TX = chr(0x22)
+ CMD_STAT_RSSI = chr(0x23)
+ CMD_BLINK = chr(0x30)
+ CMD_RANDOM = chr(0x40)
+ CMD_FW_VERSION = chr(0x50)
+ CMD_ROM_READ = chr(0x51)
+
+ DETECT_REQ = chr(0x73)
+ DETECT_RESP = chr(0x46)
+
+ RADIO_STATE_OFF = chr(0x00)
+ RADIO_STATE_ON = chr(0x01)
+ RADIO_STATE_ASK = chr(0xFF)
+
+ CMD_ERROR = chr(0x90)
+ ERROR_INITRADIO = chr(0x01)
+ ERROR_TXFAILED = chr(0x02)
+ ERROR_EEPROM_LOCKED = chr(0x03)
+
+ @staticmethod
+ def escape(data):
+ data = data.replace(chr(0xdb), chr(0xdb)+chr(0xdd))
+ data = data.replace(chr(0xc0), chr(0xdb)+chr(0xdc))
+ return data
+
+
+class RNodeInterface():
+ MAX_CHUNK = 32768
+ FREQ_MIN = 137000000
+ FREQ_MAX = 1020000000
+
+ LOG_CRITICAL = 0
+ LOG_ERROR = 1
+ LOG_WARNING = 2
+ LOG_NOTICE = 3
+ LOG_INFO = 4
+ LOG_VERBOSE = 5
+ LOG_DEBUG = 6
+ LOG_EXTREME = 7
+
+ def __init__(self, callback, name, port, frequency = None, bandwidth = None, txpower = None, sf = None, cr = None, loglevel = -1, flow_control = True):
+ self.serial = None
+ self.loglevel = loglevel
+ self.callback = callback
+ self.name = name
+ self.port = port
+ self.speed = 115200
+ self.databits = 8
+ self.parity = serial.PARITY_NONE
+ self.stopbits = 1
+ self.timeout = 100
+ self.online = False
+
+ self.frequency = frequency
+ self.bandwidth = bandwidth
+ self.txpower = txpower
+ self.sf = sf
+ self.cr = cr
+ self.state = KISS.RADIO_STATE_OFF
+ self.bitrate = 0
+
+ self.r_frequency = None
+ self.r_bandwidth = None
+ self.r_txpower = None
+ self.r_sf = None
+ self.r_cr = None
+ self.r_state = None
+ self.r_lock = None
+ self.r_stat_rx = None
+ self.r_stat_tx = None
+ self.r_stat_rssi = None
+ self.r_random = None
+
+ self.packet_queue = []
+ self.flow_control = flow_control
+ self.interface_ready = False
+
+ self.validcfg = True
+ if (self.frequency < RNodeInterface.FREQ_MIN or self.frequency > RNodeInterface.FREQ_MAX):
+ self.log("Invalid frequency configured for "+str(self), RNodeInterface.LOG_ERROR)
+ self.validcfg = False
+
+ if (self.txpower < 0 or self.txpower > 17):
+ self.log("Invalid TX power configured for "+str(self), RNodeInterface.LOG_ERROR)
+ self.validcfg = False
+
+ if (self.bandwidth < 7800 or self.bandwidth > 500000):
+ self.log("Invalid bandwidth configured for "+str(self), RNodeInterface.LOG_ERROR)
+ self.validcfg = False
+
+ if (self.sf < 7 or self.sf > 12):
+ self.log("Invalid spreading factor configured for "+str(self), RNodeInterface.LOG_ERROR)
+ self.validcfg = False
+
+ if (not self.validcfg):
+ raise ValueError("The configuration for "+str(self)+" contains errors, interface is offline")
+
+ try:
+ self.log("Opening serial port "+self.port+"...")
+ self.serial = serial.Serial(
+ port = self.port,
+ baudrate = self.speed,
+ bytesize = self.databits,
+ parity = self.parity,
+ stopbits = self.stopbits,
+ xonxoff = False,
+ rtscts = False,
+ timeout = 0,
+ inter_byte_timeout = None,
+ write_timeout = None,
+ dsrdtr = False,
+ )
+ except Exception as e:
+ self.log("Could not open serial port for interface "+str(self), RNodeInterface.LOG_ERROR)
+ raise e
+
+ if self.serial.is_open:
+ sleep(2.0)
+ thread = threading.Thread(target=self.readLoop)
+ thread.setDaemon(True)
+ thread.start()
+ self.online = True
+ self.log("Serial port "+self.port+" is now open")
+ self.log("Configuring RNode interface...", RNodeInterface.LOG_VERBOSE)
+ self.initRadio()
+ if (self.validateRadioState()):
+ self.interface_ready = True
+ self.log(str(self)+" is configured and powered up")
+ sleep(1.0)
+ else:
+ self.log("After configuring "+str(self)+", the actual radio parameters did not match your configuration.", RNodeInterface.LOG_ERROR)
+ self.log("Make sure that your hardware actually supports the parameters specified in the configuration", RNodeInterface.LOG_ERROR)
+ self.log("Aborting RNode startup", RNodeInterface.LOG_ERROR)
+ self.serial.close()
+ raise IOError("RNode interface did not pass validation")
+ else:
+ raise IOError("Could not open serial port")
+
+ def log(self, message, level):
+ pass
+
+ def initRadio(self):
+ self.setFrequency()
+ self.setBandwidth()
+ self.setTXPower()
+ self.setSpreadingFactor()
+ self.setRadioState(KISS.RADIO_STATE_ON)
+
+ def setFrequency(self):
+ c1 = self.frequency >> 24
+ c2 = self.frequency >> 16 & 0xFF
+ c3 = self.frequency >> 8 & 0xFF
+ c4 = self.frequency & 0xFF
+ data = KISS.escape(chr(c1)+chr(c2)+chr(c3)+chr(c4))
+
+ kiss_command = KISS.FEND+KISS.CMD_FREQUENCY+data+KISS.FEND
+ written = self.serial.write(kiss_command)
+ if written != len(kiss_command):
+ raise IOError("An IO error occurred while configuring frequency for "+self(str))
+
+ def setBandwidth(self):
+ c1 = self.bandwidth >> 24
+ c2 = self.bandwidth >> 16 & 0xFF
+ c3 = self.bandwidth >> 8 & 0xFF
+ c4 = self.bandwidth & 0xFF
+ data = KISS.escape(chr(c1)+chr(c2)+chr(c3)+chr(c4))
+
+ kiss_command = KISS.FEND+KISS.CMD_BANDWIDTH+data+KISS.FEND
+ written = self.serial.write(kiss_command)
+ if written != len(kiss_command):
+ raise IOError("An IO error occurred while configuring bandwidth for "+self(str))
+
+ def setTXPower(self):
+ txp = chr(self.txpower)
+ kiss_command = KISS.FEND+KISS.CMD_TXPOWER+txp+KISS.FEND
+ written = self.serial.write(kiss_command)
+ if written != len(kiss_command):
+ raise IOError("An IO error occurred while configuring TX power for "+self(str))
+
+ def setSpreadingFactor(self):
+ sf = chr(self.sf)
+ kiss_command = KISS.FEND+KISS.CMD_SF+sf+KISS.FEND
+ written = self.serial.write(kiss_command)
+ if written != len(kiss_command):
+ raise IOError("An IO error occurred while configuring spreading factor for "+self(str))
+
+ def setCodingRate(self):
+ cr = chr(self.cr)
+ kiss_command = KISS.FEND+KISS.CMD_CR+cr+KISS.FEND
+ written = self.serial.write(kiss_command)
+ if written != len(kiss_command):
+ raise IOError("An IO error occurred while configuring coding rate for "+self(str))
+
+ def setRadioState(self, state):
+ kiss_command = KISS.FEND+KISS.CMD_RADIO_STATE+state+KISS.FEND
+ written = self.serial.write(kiss_command)
+ if written != len(kiss_command):
+ raise IOError("An IO error occurred while configuring radio state for "+self(str))
+
+ def validateRadioState(self):
+ self.log("Validating radio configuration for "+str(self)+"...", RNodeInterface.LOG_VERBOSE)
+ sleep(0.25);
+ if (self.frequency != self.r_frequency):
+ self.log("Frequency mismatch", RNodeInterface.LOG_ERROR)
+ self.validcfg = False
+ if (self.bandwidth != self.r_bandwidth):
+ self.log("Bandwidth mismatch", RNodeInterface.LOG_ERROR)
+ self.validcfg = False
+ if (self.txpower != self.r_txpower):
+ self.log("TX power mismatch", RNodeInterface.LOG_ERROR)
+ self.validcfg = False
+ if (self.sf != self.r_sf):
+ self.log("Spreading factor mismatch", RNodeInterface.LOG_ERROR)
+ self.validcfg = False
+
+ if (self.validcfg):
+ return True
+ else:
+ return False
+
+ def setPromiscuousMode(self, state):
+ if state == True
+ kiss_command = KISS.FEND+KISS.CMD_PROMISC+chr(0x01)+KISS.FEND
+ else:
+ kiss_command = KISS.FEND+KISS.CMD_PROMISC+chr(0x00)+KISS.FEND
+
+ written = self.serial.write(kiss_command)
+ if written != len(kiss_command):
+ raise IOError("An IO error occurred while configuring promiscuous mode for "+self(str))
+
+
+ def updateBitrate(self):
+ try:
+ self.bitrate = self.r_sf * ( (4.0/self.cr) / (math.pow(2,self.r_sf)/(self.r_bandwidth/1000)) ) * 1000
+ self.bitrate_kbps = round(self.bitrate/1000.0, 2)
+ self.log(str(self)+" On-air bitrate is now "+str(self.bitrate_kbps)+ " kbps", RNodeInterface.LOG_DEBUG)
+ except:
+ self.bitrate = 0
+
+ def processIncoming(self, data):
+ self.callback(data, self)
+
+ def send(self, data):
+ processOutgoing(data)
+
+ def processOutgoing(self,data):
+ if self.online:
+ if self.interface_ready:
+ if self.flow_control:
+ self.interface_ready = False
+
+ data = KISS.escape(data)
+ frame = chr(0xc0)+chr(0x00)+data+chr(0xc0)
+ written = self.serial.write(frame)
+ if written != len(frame):
+ raise IOError("Serial interface only wrote "+str(written)+" bytes of "+str(len(data)))
+ else:
+ self.queue(data)
+
+ def queue(self, data):
+ self.packet_queue.append(data)
+
+ def process_queue(self):
+ if len(self.packet_queue) > 0:
+ data = self.packet_queue.pop(0)
+ self.interface_ready = True
+ self.processOutgoing(data)
+ elif len(self.packet_queue) == 0:
+ self.interface_ready = True
+
+ def readLoop(self):
+ try:
+ in_frame = False
+ escape = False
+ command = KISS.CMD_UNKNOWN
+ data_buffer = ""
+ command_buffer = ""
+ last_read_ms = int(time.time()*1000)
+
+ while self.serial.is_open:
+ if self.serial.in_waiting:
+ byte = self.serial.read(1)
+ last_read_ms = int(time.time()*1000)
+
+ if (in_frame and byte == KISS.FEND and command == KISS.CMD_DATA):
+ in_frame = False
+ self.processIncoming(data_buffer)
+ data_buffer = ""
+ command_buffer = ""
+ elif (byte == KISS.FEND):
+ in_frame = True
+ command = KISS.CMD_UNKNOWN
+ data_buffer = ""
+ command_buffer = ""
+ elif (in_frame and len(data_buffer) < RNS.Reticulum.MTU):
+ if (len(data_buffer) == 0 and command == KISS.CMD_UNKNOWN):
+ command = byte
+ elif (command == KISS.CMD_DATA):
+ if (byte == KISS.FESC):
+ escape = True
+ else:
+ if (escape):
+ if (byte == KISS.TFEND):
+ byte = KISS.FEND
+ if (byte == KISS.TFESC):
+ byte = KISS.FESC
+ escape = False
+ data_buffer = data_buffer+byte
+ elif (command == KISS.CMD_FREQUENCY):
+ if (byte == KISS.FESC):
+ escape = True
+ else:
+ if (escape):
+ if (byte == KISS.TFEND):
+ byte = KISS.FEND
+ if (byte == KISS.TFESC):
+ byte = KISS.FESC
+ escape = False
+ command_buffer = command_buffer+byte
+ if (len(command_buffer) == 4):
+ self.r_frequency = ord(command_buffer[0]) << 24 | ord(command_buffer[1]) << 16 | ord(command_buffer[2]) << 8 | ord(command_buffer[3])
+ self.log(str(self)+" Radio reporting frequency is "+str(self.r_frequency/1000000.0)+" MHz", RNodeInterface.LOG_DEBUG)
+ self.updateBitrate()
+
+ elif (command == KISS.CMD_BANDWIDTH):
+ if (byte == KISS.FESC):
+ escape = True
+ else:
+ if (escape):
+ if (byte == KISS.TFEND):
+ byte = KISS.FEND
+ if (byte == KISS.TFESC):
+ byte = KISS.FESC
+ escape = False
+ command_buffer = command_buffer+byte
+ if (len(command_buffer) == 4):
+ self.r_bandwidth = ord(command_buffer[0]) << 24 | ord(command_buffer[1]) << 16 | ord(command_buffer[2]) << 8 | ord(command_buffer[3])
+ self.log(str(self)+" Radio reporting bandwidth is "+str(self.r_bandwidth/1000.0)+" KHz", RNodeInterface.LOG_DEBUG)
+ self.updateBitrate()
+
+ elif (command == KISS.CMD_TXPOWER):
+ self.r_txpower = ord(byte)
+ self.log(str(self)+" Radio reporting TX power is "+str(self.r_txpower)+" dBm", RNodeInterface.LOG_DEBUG)
+ elif (command == KISS.CMD_SF):
+ self.r_sf = ord(byte)
+ self.log(str(self)+" Radio reporting spreading factor is "+str(self.r_sf), RNodeInterface.LOG_DEBUG)
+ self.updateBitrate()
+ elif (command == KISS.CMD_CR):
+ self.r_cr = ord(byte)
+ self.log(str(self)+" Radio reporting coding rate is "+str(self.r_cr), RNodeInterface.LOG_DEBUG)
+ self.updateBitrate()
+ elif (command == KISS.CMD_RADIO_STATE):
+ self.r_state = ord(byte)
+ elif (command == KISS.CMD_RADIO_LOCK):
+ self.r_lock = ord(byte)
+ elif (command == KISS.CMD_STAT_RX):
+ if (byte == KISS.FESC):
+ escape = True
+ else:
+ if (escape):
+ if (byte == KISS.TFEND):
+ byte = KISS.FEND
+ if (byte == KISS.TFESC):
+ byte = KISS.FESC
+ escape = False
+ command_buffer = command_buffer+byte
+ if (len(command_buffer) == 4):
+ self.r_stat_rx = ord(command_buffer[0]) << 24 | ord(command_buffer[1]) << 16 | ord(command_buffer[2]) << 8 | ord(command_buffer[3])
+
+ elif (command == KISS.CMD_STAT_TX):
+ if (byte == KISS.FESC):
+ escape = True
+ else:
+ if (escape):
+ if (byte == KISS.TFEND):
+ byte = KISS.FEND
+ if (byte == KISS.TFESC):
+ byte = KISS.FESC
+ escape = False
+ command_buffer = command_buffer+byte
+ if (len(command_buffer) == 4):
+ self.r_stat_tx = ord(command_buffer[0]) << 24 | ord(command_buffer[1]) << 16 | ord(command_buffer[2]) << 8 | ord(command_buffer[3])
+
+ elif (command == KISS.CMD_STAT_RSSI):
+ self.r_stat_rssi = ord(byte)
+ elif (command == KISS.CMD_RANDOM):
+ self.r_random = ord(byte)
+ elif (command == KISS.CMD_ERROR):
+ if (byte == KISS.ERROR_INITRADIO):
+ self.log(str(self)+" hardware initialisation error (code "+RNS.hexrep(byte)+")", RNodeInterface.LOG_ERROR)
+ elif (byte == KISS.ERROR_INITRADIO):
+ self.log(str(self)+" hardware TX error (code "+RNS.hexrep(byte)+")", RNodeInterface.LOG_ERROR)
+ else:
+ self.log(str(self)+" hardware error (code "+RNS.hexrep(byte)+")", RNodeInterface.LOG_ERROR)
+ elif (command == KISS.CMD_READY):
+ # TODO: add timeout and reset if ready
+ # command never arrives
+ self.process_queue()
+
+ else:
+ time_since_last = int(time.time()*1000) - last_read_ms
+ if len(data_buffer) > 0 and time_since_last > self.timeout:
+ self.log(str(self)+" serial read timeout", RNodeInterface.LOG_DEBUG)
+ data_buffer = ""
+ in_frame = False
+ command = KISS.CMD_UNKNOWN
+ escape = False
+ sleep(0.08)
+
+ except Exception as e:
+ self.online = False
+ self.log("A serial port error occurred, the contained exception was: "+str(e), RNodeInterface.LOG_ERROR)
+ self.log("The interface "+str(self.name)+" is now offline.", RNodeInterface.LOG_ERROR)
+
+ def log(msg, level=3):
+ if self.loglevel >= level:
+ timestamp = time.time()
+ logstring = "["+time.strftime(logtimefmt)+"] ["+self.loglevelname(level)+"] "+msg
+
+ if (logdest == LOG_STDOUT):
+ print(logstring)
+
+ def loglevelname(level):
+ if (level == RNodeInterface.LOG_CRITICAL):
+ return "Critical"
+ if (level == RNodeInterface.LOG_ERROR):
+ return "Error"
+ if (level == RNodeInterface.LOG_WARNING):
+ return "Warning"
+ if (level == RNodeInterface.LOG_NOTICE):
+ return "Notice"
+ if (level == RNodeInterface.LOG_INFO):
+ return "Info"
+ if (level == RNodeInterface.LOG_VERBOSE):
+ return "Verbose"
+ if (level == RNodeInterface.LOG_DEBUG):
+ return "Debug"
+ if (level == RNodeInterface.LOG_EXTREME):
+ return "Extra"
+
+ def __str__(self):
+ return "RNodeInterface["+self.name+"]"
+
projects / lora-radio.git / commitdiff