Unsignedio
/
LoRaMon
mirror of https://github.com/markqvist/LoRaMon.git
1
0
Fork 0
Code Issues Releases Wiki Activity

Added UI.

pull/6/head
Alligitor 2025-04-20 13:35:00 +00:00
parent 88318b17a1
commit a6df76b928
1 changed files with 641 additions and 663 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

384
loramon/loramon.py
View File

@ -10,111 +10,21 @@ import time
import math import math
import traceback import traceback
from importlib import util from importlib import util
import queue
import serial
from LoRaMonUIApp import LoRaMonUIApp
from LoRaMonHelperClasses import RNS
from LoRaMonHelperClasses import RNSSerial
from LoRaMonHelperClasses import KISS
from LoRaMonHelperClasses import ROM
class RNS():
log_enabled = True
@staticmethod
def log(msg):
if RNS.log_enabled:
logtimefmt = "%Y-%m-%d %H:%M:%S"
timestamp = time.time()
logstring = "["+time.strftime(logtimefmt)+"] "+msg
print(logstring)
@staticmethod
def hexrep(data, delimit=True):
delimiter = ":"
if not delimit:
delimiter = ""
hexrep = delimiter.join("{:02x}".format(c) for c in data)
return hexrep
@staticmethod
def prettyhexrep(data):
delimiter = ""
hexrep = "<"+delimiter.join("{:02x}".format(c) for c in data)+">"
return hexrep
class KISS():
FEND = 0xC0
FESC = 0xDB
TFEND = 0xDC
TFESC = 0xDD
CMD_UNKNOWN = 0xFE
CMD_DATA = 0x00
CMD_FREQUENCY = 0x01
CMD_BANDWIDTH = 0x02
CMD_TXPOWER = 0x03
CMD_SF = 0x04
CMD_CR = 0x05
CMD_RADIO_STATE = 0x06
CMD_RADIO_LOCK = 0x07
CMD_DETECT = 0x08
CMD_IMPLICIT = 0x09
CMD_PROMISC = 0x0E
CMD_READY = 0x0F
CMD_STAT_RX = 0x21
CMD_STAT_TX = 0x22
CMD_STAT_RSSI = 0x23
CMD_STAT_SNR = 0x24
CMD_STAT_CHTM = 0x25
CMD_STAT_PHYPRM = 0x26
CMD_STAT_BAT = 0x27
CMD_STAT_CSMA = 0x28
CMD_BLINK = 0x30
CMD_RANDOM = 0x40
CMD_FW_VERSION = 0x50
CMD_ROM_READ = 0x51
CMD_ROM_WRITE = 0x52
CMD_CONF_SAVE = 0x53
CMD_CONF_DELETE = 0x54
DETECT_REQ = 0x73
DETECT_RESP = 0x46
RADIO_STATE_OFF = 0x00
RADIO_STATE_ON = 0x01
RADIO_STATE_ASK = 0xFF
CMD_ERROR = 0x90
ERROR_INITRADIO = 0x01
ERROR_TXFAILED = 0x02
ERROR_EEPROM_LOCKED = 0x03
@staticmethod
def escape(data):
data = data.replace(bytes([0xdb]), bytes([0xdb, 0xdd]))
data = data.replace(bytes([0xc0]), bytes([0xdb, 0xdc]))
return data
class ROM():
PRODUCT_RNODE = chr(0x03)
MODEL_A4 = chr(0xA4)
MODEL_A9 = chr(0xA9)
ADDR_PRODUCT = chr(0x00)
ADDR_MODEL = chr(0x01)
ADDR_HW_REV = chr(0x02)
ADDR_SERIAL = chr(0x03)
ADDR_MADE = chr(0x07)
ADDR_CHKSUM = chr(0x0B)
ADDR_SIGNATURE = chr(0x1B)
ADDR_INFO_LOCK = chr(0x9B)
ADDR_CONF_SF = chr(0x9C)
ADDR_CONF_CR = chr(0x9D)
ADDR_CONF_TXP = chr(0x9E)
ADDR_CONF_BW = chr(0x9F)
ADDR_CONF_FREQ = chr(0xA3)
ADDR_CONF_OK = chr(0xA7)
INFO_LOCK_BYTE = chr(0x73)
CONF_OK_BYTE = chr(0x73)
class RNode(): class RNode():
def __init__(self, serial_instance): def __init__(self, serial_instance):
self.serial = serial_instance self.rns_serial = serial_instance
self.timeout = 100 self.timeout = 100
#These are parameters recevied from the radio
self.r_frequency = None self.r_frequency = None
self.r_bandwidth = None self.r_bandwidth = None
self.r_txpower = None self.r_txpower = None
@ -123,16 +33,20 @@ class RNode():
self.r_lock = None self.r_lock = None
self.r_stat_rssi = 0 self.r_stat_rssi = 0
self.r_stat_snr = 0 self.r_stat_snr = 0
self.r_battery = None
self.r_cr = None
self.r_implicit_length = 0 self.r_implicit_length = 0
self.rssi_offset = 157 self.rssi_offset = 157
# command line arguments
self.sf = None self.sf = None
self.cr = None self.cr = None
self.txpower = None self.txpower = None
self.frequency = None self.frequency = None
self.bandwidth = None self.bandwidth = None
self.implicit_length = 0 self.implicit_length = 0
self.promiscuous = False
self.detected = None self.detected = None
@ -191,12 +105,48 @@ class RNode():
#flag for printing raw bytes from RNode #flag for printing raw bytes from RNode
self.raw_data_enabled = False self.raw_data_enabled = False
#flag for stopping the thread
self.thread_continue = None
#link back to the ui app, used for updating
self.loramon_ui_app = None
def setCapturDuration(self, seconds): def setCapturDuration(self, seconds):
#set the start time, first #set the start time, first
self.capture_start_time = time.time() self.capture_start_time = time.time()
#set seconds after setting the time, to eliminate race issues with the thread #set seconds after setting the time, to eliminate race issues with the thread
self.duration_to_capture_for = seconds self.duration_to_capture_for = seconds
def device_probe(self):
deviced_detected = False
iterations_to_wait = 10
sleep(2.5)
self.detectRequest()
while True:
if self.detected == True:
RNS.log("RNode connected")
RNS.log("Firmware version: " + str(self.version))
device_detected = True
break
else:
sleep(0.1)
iterations_to_wait -= 1
if iterations_to_wait == 0:
device_detected = False
break
return device_detected
def updateIUApp(self):
if (self.loramon_ui_app != None):
self.loramon_ui_app.frequency = self.r_frequency
self.loramon_ui_app.bandwidth = self.r_bandwidth
self.loramon_ui_app.spread_factor = self.r_sf
self.loramon_ui_app.coding_rate = self.r_cr
self.loramon_ui_app.battery = self.r_battery
self.loramon_ui_app.packet_received = self.number_of_packets_received
def packetReadLoop(self): def packetReadLoop(self):
try: try:
in_frame = False in_frame = False
@ -205,26 +155,29 @@ class RNode():
data_buffer = b"" data_buffer = b""
command_buffer = b"" command_buffer = b""
last_read_ms = int(time.time()*1000) last_read_ms = int(time.time()*1000)
packet_string = ""
while self.serial.is_open: while self.rns_serial.IsOpen() and self.thread_continue == True:
if (self.duration_to_capture_for > 0): #handle case where a capture duration is specified if (self.duration_to_capture_for > 0): #handle case where a capture duration is specified
seconds_elapsed = int(time.time() - self.capture_start_time) seconds_elapsed = int(time.time() - self.capture_start_time)
if(seconds_elapsed > self.duration_to_capture_for): if(seconds_elapsed > self.duration_to_capture_for):
return (self.number_of_packets_received) return (self.number_of_packets_received)
if self.serial.in_waiting: if self.rns_serial.InWaiting():
byte = ord(self.serial.read(1)) byte = ord(self.rns_serial.Read(1))
last_read_ms = int(time.time()*1000) last_read_ms = int(time.time()*1000)
if (in_frame == True): if (in_frame == True):
if (self.raw_data_enabled == True): #logic to print raw frame data when in frame if (self.raw_data_enabled == True): #logic to print raw frame data when in frame
if (byte == KISS.FEND): if (byte == KISS.FEND):
# we have detected end of a frame # we have detected end of a frame
print(f"{byte:#0{4}x}", end="") packet_string += str(f"{byte:#0{4}x}")
print("<--") packet_string += "<--"
RNS.log(packet_string)
packet_string = ""
else: else:
# we are still capturing bytes while a frame was detected # we are still capturing bytes while a frame was detected
print(f"{byte:#0{4}x} ", end="") packet_string += f"{byte:#0{4}x} "
if (byte == KISS.FEND): #received FEND, which signals end of a frame if (byte == KISS.FEND): #received FEND, which signals end of a frame
#first make sure we actually received a command #first make sure we actually received a command
@ -247,6 +200,7 @@ class RNode():
if (len(data_buffer) == 4): if (len(data_buffer) == 4):
self.r_frequency = data_buffer[0] << 24 | data_buffer[1] << 16 | data_buffer[2] << 8 | data_buffer[3] self.r_frequency = data_buffer[0] << 24 | data_buffer[1] << 16 | data_buffer[2] << 8 | data_buffer[3]
RNS.log("Radio reporting frequency is "+str(self.r_frequency/1000000.0)+" MHz") RNS.log("Radio reporting frequency is "+str(self.r_frequency/1000000.0)+" MHz")
self.updateIUApp()
self.updateBitrate() self.updateBitrate()
else: else:
RNS.log(f"Wrong number of bytes {len(data_buffer)} for frequency") RNS.log(f"Wrong number of bytes {len(data_buffer)} for frequency")
@ -254,6 +208,7 @@ class RNode():
if (len(data_buffer) == 4): if (len(data_buffer) == 4):
self.r_bandwidth = data_buffer[0] << 24 | data_buffer[1] << 16 | data_buffer[2] << 8 | data_buffer[3] self.r_bandwidth = data_buffer[0] << 24 | data_buffer[1] << 16 | data_buffer[2] << 8 | data_buffer[3]
RNS.log("Radio reporting bandwidth is "+str(self.r_bandwidth/1000.0)+" KHz") RNS.log("Radio reporting bandwidth is "+str(self.r_bandwidth/1000.0)+" KHz")
self.updateIUApp()
self.updateBitrate() self.updateBitrate()
else: else:
RNS.log(f"Wrong number of bytes {len(data_buffer)} for bandwith") RNS.log(f"Wrong number of bytes {len(data_buffer)} for bandwith")
@ -274,6 +229,7 @@ class RNode():
if (len(data_buffer) == 1): if (len(data_buffer) == 1):
self.r_sf = data_buffer[0] self.r_sf = data_buffer[0]
RNS.log("Radio reporting spreading factor is "+str(self.r_sf)) RNS.log("Radio reporting spreading factor is "+str(self.r_sf))
self.updateIUApp()
self.updateBitrate() self.updateBitrate()
else: else:
RNS.log(f"Wrong number of bytes {len(data_buffer)} for spreading factor") RNS.log(f"Wrong number of bytes {len(data_buffer)} for spreading factor")
@ -281,6 +237,7 @@ class RNode():
if (len(data_buffer) == 1): if (len(data_buffer) == 1):
self.r_cr = data_buffer[0] self.r_cr = data_buffer[0]
RNS.log("Radio reporting coding rate is "+str(self.r_cr)) RNS.log("Radio reporting coding rate is "+str(self.r_cr))
self.updateIUApp()
self.updateBitrate() self.updateBitrate()
else: else:
RNS.log(f"Wrong number of bytes {len(data_buffer)} for coding rate") RNS.log(f"Wrong number of bytes {len(data_buffer)} for coding rate")
@ -336,6 +293,8 @@ class RNode():
case KISS.CMD_STAT_BAT: case KISS.CMD_STAT_BAT:
if (len(data_buffer) == 2): if (len(data_buffer) == 2):
RNS.log(f"Radio reporting battery state is {data_buffer[0]}, % {data_buffer[1]}") RNS.log(f"Radio reporting battery state is {data_buffer[0]}, % {data_buffer[1]}")
self.r_battery = f"S:{data_buffer[0]}, % {data_buffer[1]}"
self.updateIUApp()
else: else:
RNS.log(f"Wrong number of bytes {len(data_buffer)} for battery") RNS.log(f"Wrong number of bytes {len(data_buffer)} for battery")
case KISS.CMD_STAT_CHTM: case KISS.CMD_STAT_CHTM:
@ -450,9 +409,9 @@ class RNode():
minstr = "0"+minstr minstr = "0"+minstr
self.version = str(self.major_version)+"."+minstr self.version = str(self.major_version)+"."+minstr
def detect(self): def detectRequest(self):
kiss_command = bytes([KISS.FEND, KISS.CMD_DETECT, KISS.DETECT_REQ, KISS.FEND, KISS.CMD_FW_VERSION, 0x00, KISS.FEND]) kiss_command = bytes([KISS.FEND, KISS.CMD_DETECT, KISS.DETECT_REQ, KISS.FEND, KISS.CMD_FW_VERSION, 0x00, KISS.FEND])
written = self.serial.write(kiss_command) written = self.rns_serial.Write(kiss_command)
if written != len(kiss_command): if written != len(kiss_command):
raise IOError("An IO error occurred while configuring spreading factor for "+self(str)) raise IOError("An IO error occurred while configuring spreading factor for "+self(str))
@ -464,6 +423,8 @@ class RNode():
self.setCodingRate() self.setCodingRate()
self.setImplicitLength() self.setImplicitLength()
self.setRadioState(KISS.RADIO_STATE_ON) self.setRadioState(KISS.RADIO_STATE_ON)
self.setPromiscuousMode()
sleep(0.5)
def setFrequency(self): def setFrequency(self):
c1 = self.frequency >> 24 c1 = self.frequency >> 24
@ -473,7 +434,7 @@ class RNode():
data = KISS.escape(bytes([c1])+bytes([c2])+bytes([c3])+bytes([c4])) data = KISS.escape(bytes([c1])+bytes([c2])+bytes([c3])+bytes([c4]))
kiss_command = bytes([KISS.FEND])+bytes([KISS.CMD_FREQUENCY])+data+bytes([KISS.FEND]) kiss_command = bytes([KISS.FEND])+bytes([KISS.CMD_FREQUENCY])+data+bytes([KISS.FEND])
written = self.serial.write(kiss_command) written = self.rns_serial.Write(kiss_command)
if written != len(kiss_command): if written != len(kiss_command):
raise IOError("An IO error occurred while configuring frequency for "+self(str)) raise IOError("An IO error occurred while configuring frequency for "+self(str))
@ -485,7 +446,7 @@ class RNode():
data = KISS.escape(bytes([c1])+bytes([c2])+bytes([c3])+bytes([c4])) data = KISS.escape(bytes([c1])+bytes([c2])+bytes([c3])+bytes([c4]))
kiss_command = bytes([KISS.FEND])+bytes([KISS.CMD_BANDWIDTH])+data+bytes([KISS.FEND]) kiss_command = bytes([KISS.FEND])+bytes([KISS.CMD_BANDWIDTH])+data+bytes([KISS.FEND])
written = self.serial.write(kiss_command) written = self.rns_serial.Write(kiss_command)
if written != len(kiss_command): if written != len(kiss_command):
raise IOError("An IO error occurred while configuring bandwidth for "+self(str)) raise IOError("An IO error occurred while configuring bandwidth for "+self(str))
@ -493,7 +454,7 @@ class RNode():
txp = bytes([self.txpower]) txp = bytes([self.txpower])
kiss_command = bytes([KISS.FEND])+bytes([KISS.CMD_TXPOWER])+txp+bytes([KISS.FEND]) kiss_command = bytes([KISS.FEND])+bytes([KISS.CMD_TXPOWER])+txp+bytes([KISS.FEND])
written = self.serial.write(kiss_command) written = self.rns_serial.Write(kiss_command)
if written != len(kiss_command): if written != len(kiss_command):
raise IOError("An IO error occurred while configuring TX power for "+self(str)) raise IOError("An IO error occurred while configuring TX power for "+self(str))
@ -501,7 +462,7 @@ class RNode():
sf = bytes([self.sf]) sf = bytes([self.sf])
kiss_command = bytes([KISS.FEND])+bytes([KISS.CMD_SF])+sf+bytes([KISS.FEND]) kiss_command = bytes([KISS.FEND])+bytes([KISS.CMD_SF])+sf+bytes([KISS.FEND])
written = self.serial.write(kiss_command) written = self.rns_serial.Write(kiss_command)
if written != len(kiss_command): if written != len(kiss_command):
raise IOError("An IO error occurred while configuring spreading factor for "+self(str)) raise IOError("An IO error occurred while configuring spreading factor for "+self(str))
@ -509,7 +470,7 @@ class RNode():
cr = bytes([self.cr]) cr = bytes([self.cr])
kiss_command = bytes([KISS.FEND])+bytes([KISS.CMD_CR])+cr+bytes([KISS.FEND]) kiss_command = bytes([KISS.FEND])+bytes([KISS.CMD_CR])+cr+bytes([KISS.FEND])
written = self.serial.write(kiss_command) written = self.rns_serial.Write(kiss_command)
if written != len(kiss_command): if written != len(kiss_command):
raise IOError("An IO error occurred while configuring coding rate for "+self(str)) raise IOError("An IO error occurred while configuring coding rate for "+self(str))
@ -518,23 +479,23 @@ class RNode():
length = KISS.escape(bytes([self.implicit_length])) length = KISS.escape(bytes([self.implicit_length]))
kiss_command = bytes([KISS.FEND])+bytes([KISS.CMD_IMPLICIT])+length+bytes([KISS.FEND]) kiss_command = bytes([KISS.FEND])+bytes([KISS.CMD_IMPLICIT])+length+bytes([KISS.FEND])
written = self.serial.write(kiss_command) written = self.rns_serial.Write(kiss_command)
if written != len(kiss_command): if written != len(kiss_command):
raise IOError("An IO error occurred while configuring implicit header mode for "+self(str)) raise IOError("An IO error occurred while configuring implicit header mode for "+self(str))
def setRadioState(self, state): def setRadioState(self, state):
kiss_command = bytes([KISS.FEND])+bytes([KISS.CMD_RADIO_STATE])+bytes([state])+bytes([KISS.FEND]) kiss_command = bytes([KISS.FEND])+bytes([KISS.CMD_RADIO_STATE])+bytes([state])+bytes([KISS.FEND])
written = self.serial.write(kiss_command) written = self.rns_serial.Write(kiss_command)
if written != len(kiss_command): if written != len(kiss_command):
raise IOError("An IO error occurred while configuring radio state for "+self(str)) raise IOError("An IO error occurred while configuring radio state for "+self(str))
def setPromiscuousMode(self, state): def setPromiscuousMode(self):
if state == True: if self.promiscuous == True:
kiss_command = bytes([KISS.FEND, KISS.CMD_PROMISC, 0x01, KISS.FEND]) kiss_command = bytes([KISS.FEND, KISS.CMD_PROMISC, 0x01, KISS.FEND])
else: else:
kiss_command = bytes([KISS.FEND, KISS.CMD_PROMISC, 0x00, KISS.FEND]) kiss_command = bytes([KISS.FEND, KISS.CMD_PROMISC, 0x00, KISS.FEND])
written = self.serial.write(kiss_command) written = self.rns_serial.Write(kiss_command)
if written != len(kiss_command): if written != len(kiss_command):
raise IOError("An IO error occurred while configuring promiscuous mode for "+self(str)) raise IOError("An IO error occurred while configuring promiscuous mode for "+self(str))
@ -543,17 +504,6 @@ class RNode():
#make this a global for use, even if rnode isn't initialized #make this a global for use, even if rnode isn't initialized
number_of_packets_received_exit_code = 0 number_of_packets_received_exit_code = 0
def device_probe(rnode):
sleep(2.5)
rnode.detect()
sleep(0.1)
if rnode.detected == True:
RNS.log("RNode connected")
RNS.log("Firmware version: " + str(rnode.version))
return True
else:
raise IOError("Got invalid response while detecting device")
def packet_captured(data, rnode_instance): def packet_captured(data, rnode_instance):
if rnode_instance.console_output: if rnode_instance.console_output:
if rnode_instance.print_hex: if rnode_instance.print_hex:
@ -586,8 +536,6 @@ def main():
print("") print("")
exit(number_of_packets_received_exit_code) exit(number_of_packets_received_exit_code)
import serial
try: try:
parser = argparse.ArgumentParser(description="LoRa packet sniffer for RNode hardware.") parser = argparse.ArgumentParser(description="LoRa packet sniffer for RNode hardware.")
parser.add_argument("-C", "--console", action="store_true", help="Print captured packets to the console") parser.add_argument("-C", "--console", action="store_true", help="Print captured packets to the console")
@ -603,6 +551,7 @@ def main():
parser.add_argument("-Q", action="store_true", help="Quite mode, no logging") parser.add_argument("-Q", action="store_true", help="Quite mode, no logging")
parser.add_argument("-R", action="store_true", help="Raw frame mode") parser.add_argument("-R", action="store_true", help="Raw frame mode")
parser.add_argument("-P", action="store_true", help="Set promiscuous mode") parser.add_argument("-P", action="store_true", help="Set promiscuous mode")
parser.add_argument("-U", action="store_true", help="Use a URWID based UI")
parser.add_argument("port", nargs="?", default=None, help="Serial port where RNode is attached", type=str) parser.add_argument("port", nargs="?", default=None, help="Serial port where RNode is attached", type=str)
args = parser.parse_args() args = parser.parse_args()
@ -611,6 +560,47 @@ def main():
write_to_disk = False write_to_disk = False
write_dir = None write_dir = None
if args.duration and args.U:
print("UI mode and timed capture are not compatible")
exit(number_of_packets_received_exit_code)
if args.port:
RNS.log("Opening serial port "+args.port+"...")
rnode = None
serial_device = None
rnode_baudrate = 115200
try:
serial_device = serial.Serial(
port = args.port,
baudrate = rnode_baudrate,
bytesize = 8,
parity = serial.PARITY_NONE,
stopbits = 1,
xonxoff = False,
rtscts = False,
timeout = 0,
inter_byte_timeout = None,
write_timeout = None,
dsrdtr = False
)
except Exception as e:
RNS.log("Could not open the specified serial port. The contained exception was:")
RNS.log(str(e))
exit(number_of_packets_received_exit_code)
else:
print("")
parser.print_help()
print("")
exit(number_of_packets_received_exit_code)
# create an RNS Serial device that uses locking for read / write
rns_serial = RNSSerial(serial_device)
# create the RNode object and give it the lockable serial device
rnode = RNode(rns_serial)
if args.Q: if args.Q:
RNS.log_enabled = False RNS.log_enabled = False
@ -629,68 +619,17 @@ def main():
write_to_disk = True write_to_disk = True
write_dir = args.W write_dir = args.W
if args.port:
RNS.log("Opening serial port "+args.port+"...")
rnode = None
rnode_serial = None
rnode_baudrate = 115200
try:
rnode_serial = serial.Serial(
port = args.port,
baudrate = rnode_baudrate,
bytesize = 8,
parity = serial.PARITY_NONE,
stopbits = 1,
xonxoff = False,
rtscts = False,
timeout = 0,
inter_byte_timeout = None,
write_timeout = None,
dsrdtr = False
)
except Exception as e:
RNS.log("Could not open the specified serial port. The contained exception was:")
RNS.log(str(e))
exit(number_of_packets_received_exit_code)
rnode = RNode(rnode_serial)
if (args.R):
rnode.raw_data_enabled = True
rnode.callback = packet_captured
rnode.console_output = console_output
rnode.write_to_disk = write_to_disk
rnode.write_dir = write_dir
thread = threading.Thread(target=rnode.packetReadLoop)
thread.daemon = True
thread.start()
try:
device_probe(rnode)
except Exception as e:
RNS.log("Serial port opened, but RNode did not respond.")
print(e)
exit(number_of_packets_received_exit_code)
if not (args.freq and args.bw and args.sf and args.cr):
RNS.log("Please input startup configuration:")
print("")
if args.freq: if args.freq:
rnode.frequency = args.freq rnode.frequency = args.freq
else: else:
print("Frequency in Hz:\t", end=' ') RNS.log("Freq is a required parameter.")
rnode.frequency = int(input()) exit(number_of_packets_received_exit_code)
if args.bw: if args.bw:
rnode.bandwidth = args.bw rnode.bandwidth = args.bw
else: else:
print("Bandwidth in Hz:\t", end=' ') RNS.log("BW is a required parameter.")
rnode.bandwidth = int(input()) exit(number_of_packets_received_exit_code)
if args.txp and (args.txp >= 0 and args.txp <= 17): if args.txp and (args.txp >= 0 and args.txp <= 17):
rnode.txpower = args.txp rnode.txpower = args.txp
@ -700,14 +639,14 @@ def main():
if args.sf: if args.sf:
rnode.sf = args.sf rnode.sf = args.sf
else: else:
print("Spreading factor:\t", end=' ') RNS.log("SF is a required parameter.")
rnode.sf = int(input()) exit(number_of_packets_received_exit_code)
if args.cr: if args.cr:
rnode.cr = args.cr rnode.cr = args.cr
else: else:
print("Coding rate:\t\t", end=' ') RNS.log("CR is a required parameter.")
rnode.cr = int(input()) exit(number_of_packets_received_exit_code)
if args.implicit: if args.implicit:
rnode.implicit_length = args.implicit rnode.implicit_length = args.implicit
@ -719,29 +658,68 @@ def main():
else: else:
rnode.print_hex = False rnode.print_hex = False
rnode.initRadio()
if args.P: if args.P:
rnode.setPromiscuousMode(True) rnode.promiscuous = True
sleep(0.5) else:
rnode.promiscuous = False
# set the duration here, after radio has been initialized if (args.R):
rnode.setCapturDuration(args.duration) rnode.raw_data_enabled = True
RNS.log(f"Capture Duration {rnode.duration_to_capture_for}")
if not args.W and not args.console: if not args.W and not args.console:
RNS.log("Warning! No output destination specified! You won't see any captured packets.") RNS.log("Warning! No output destination specified! You won't see any captured packets.")
#turn off all logging until we probe the RNode device
RNS.log_enabled = False
#Get the background thread going that will read from radio and help detect it
rnode.callback = packet_captured
rnode.console_output = console_output
rnode.write_to_disk = write_to_disk
rnode.write_dir = write_dir
#set the flag that keeps the thread running
rnode.thread_continue = True
thread = threading.Thread(target=rnode.packetReadLoop)
thread.daemon = True
thread.start()
#kick off a probe
if rnode.device_probe() == False:
print("Serial port opened, but RNode did not respond.")
rnode.thread_continue = False
else:
#enable logging again, now that radio is detected
RNS.log_enabled = True
#decide whether we are running on console, or URWID based UI
if (args.U):
#UI Mode
RNS.ui_msg_queue = queue.Queue()
loramon_ui_app = LoRaMonUIApp(RNS.ui_msg_queue)
rnode.loramon_ui_app = loramon_ui_app
#initialize the radio
rnode.initRadio()
loramon_ui_app.run()
rnode.thread_continue = False
None
else:
#Console mode
#initialize the radio
rnode.initRadio()
# set the duration here, after radio has been initialized
rnode.setCapturDuration(args.duration)
RNS.log(f"Capture Duration {rnode.duration_to_capture_for}")
#program is ending, by the it gets here
#wait for the thread to finish #wait for the thread to finish
thread.join() thread.join()
exit(number_of_packets_received_exit_code) exit(number_of_packets_received_exit_code)
else:
print("")
parser.print_help()
print("")
exit(number_of_packets_received_exit_code)
except KeyboardInterrupt: except KeyboardInterrupt:
print("") print("")
exit(number_of_packets_received_exit_code) exit(number_of_packets_received_exit_code)