Crash_Override/FreeDATA
1
0
Fork 0
mirror of https://github.com/DJ2LS/FreeDATA synced 2024-05-14 08:04:33 +00:00
Code Issues Packages Projects Releases Wiki Activity

Remove excess newlines.

Browse source
This commit is contained in:
Paul Kronenwetter 2022-05-08 21:27:24 -04:00
parent 9753735c40
commit 3a70b87e21
14 changed files with 14 additions and 289 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

5
tnc/audio.py
View file

@ -8,9 +8,6 @@ import atexit
atexit.register(sd._terminate) atexit.register(sd._terminate)
def get_audio_devices(): def get_audio_devices():
""" """
return list of input and output audio devices in own process to avoid crashes of portaudio on raspberry pi return list of input and output audio devices in own process to avoid crashes of portaudio on raspberry pi
@ -47,7 +44,6 @@ def fetch_audio_devices(input_devices, output_devices):
Returns: Returns:
""" """
devices = sd.query_devices(device=None, kind=None) devices = sd.query_devices(device=None, kind=None)
index = 0 index = 0
for device in devices: for device in devices:
@ -70,4 +66,3 @@ def fetch_audio_devices(input_devices, output_devices):
if maxOutputChannels > 0: if maxOutputChannels > 0:
output_devices.append({"id": index, "name": str(name)}) output_devices.append({"id": index, "name": str(name)})
index += 1 index += 1

12
tnc/codec2.py
View file

@ -63,13 +63,11 @@ if sys.platform == 'linux':
files.append('libcodec2.so') files.append('libcodec2.so')
elif sys.platform == 'darwin': elif sys.platform == 'darwin':
files = glob.glob('**/*libcodec2*.dylib',recursive=True) files = glob.glob('**/*libcodec2*.dylib',recursive=True)
elif sys.platform == 'win32' or sys.platform == 'win64': elif sys.platform == 'win32' or sys.platform == 'win64':
files = glob.glob('**\*libcodec2*.dll',recursive=True) files = glob.glob('**\*libcodec2*.dll',recursive=True)
else: else:
files = [] files = []
for file in files: for file in files:
try: try:
api = ctypes.CDLL(file) api = ctypes.CDLL(file)
@ -78,15 +76,11 @@ for file in files:
except Exception as e: except Exception as e:
structlog.get_logger("structlog").warning("[C2 ] Libcodec2 found but not loaded", path=file, e=e) structlog.get_logger("structlog").warning("[C2 ] Libcodec2 found but not loaded", path=file, e=e)
# quit module if codec2 cant be loaded # quit module if codec2 cant be loaded
if not 'api' in locals(): if not 'api' in locals():
structlog.get_logger("structlog").critical("[C2 ] Libcodec2 not loaded", path=file) structlog.get_logger("structlog").critical("[C2 ] Libcodec2 not loaded", path=file)
os._exit(1) os._exit(1)
# ctypes function init # ctypes function init
#api.freedv_set_tuning_range.restype = c_int #api.freedv_set_tuning_range.restype = c_int
@ -211,6 +205,7 @@ MODEM_STATS_EYE_IND_MAX = 160
MODEM_STATS_NSPEC = 512 MODEM_STATS_NSPEC = 512
MODEM_STATS_MAX_F_HZ = 4000 MODEM_STATS_MAX_F_HZ = 4000
MODEM_STATS_MAX_F_EST = 4 MODEM_STATS_MAX_F_EST = 4
# modem stats structure # modem stats structure
class MODEMSTATS(ctypes.Structure): class MODEMSTATS(ctypes.Structure):
""" """ """ """
@ -233,8 +228,6 @@ class MODEMSTATS(ctypes.Structure):
("fft_buf", (ctypes.c_float * MODEM_STATS_NSPEC * 2)), ("fft_buf", (ctypes.c_float * MODEM_STATS_NSPEC * 2)),
] ]
# Return code flags for freedv_get_rx_status() function # Return code flags for freedv_get_rx_status() function
api.FREEDV_RX_TRIAL_SYNC = 0x1 # demodulator has trial sync api.FREEDV_RX_TRIAL_SYNC = 0x1 # demodulator has trial sync
api.FREEDV_RX_SYNC = 0x2 # demodulator has sync api.FREEDV_RX_SYNC = 0x2 # demodulator has sync
@ -275,6 +268,7 @@ class audio_buffer:
self.buffer = np.zeros(size, dtype=np.int16) self.buffer = np.zeros(size, dtype=np.int16)
self.nbuffer = 0 self.nbuffer = 0
self.mutex = Lock() self.mutex = Lock()
def push(self,samples): def push(self,samples):
""" """
Push new data to buffer Push new data to buffer
@ -291,6 +285,7 @@ class audio_buffer:
self.buffer[self.nbuffer:self.nbuffer+len(samples)] = samples self.buffer[self.nbuffer:self.nbuffer+len(samples)] = samples
self.nbuffer += len(samples) self.nbuffer += len(samples)
self.mutex.release() self.mutex.release()
def pop(self,size): def pop(self,size):
""" """
get data from buffer in size of NIN get data from buffer in size of NIN
@ -328,7 +323,6 @@ class resampler:
self.filter_mem8 = np.zeros(self.MEM8, dtype=np.int16) self.filter_mem8 = np.zeros(self.MEM8, dtype=np.int16)
self.filter_mem48 = np.zeros(self.MEM48) self.filter_mem48 = np.zeros(self.MEM48)
def resample48_to_8(self,in48): def resample48_to_8(self,in48):
""" """
audio resampler integration from codec2 audio resampler integration from codec2

19
tnc/daemon.py
View file

@ -8,7 +8,6 @@ Author: DJ2LS, January 2022
daemon for providing basic information for the tnc like audio or serial devices daemon for providing basic information for the tnc like audio or serial devices
""" """
import argparse import argparse
import threading import threading
import socketserver import socketserver
@ -49,7 +48,6 @@ def signal_handler(sig, frame):
signal.signal(signal.SIGINT, signal_handler) signal.signal(signal.SIGINT, signal_handler)
class DAEMON(): class DAEMON():
""" """
daemon class daemon class
@ -70,8 +68,6 @@ class DAEMON():
worker = threading.Thread(target=self.worker, name="WORKER", daemon=True) worker = threading.Thread(target=self.worker, name="WORKER", daemon=True)
worker.start() worker.start()
def update_audio_devices(self): def update_audio_devices(self):
""" """
update audio devices and set to static update audio devices and set to static
@ -85,7 +81,6 @@ class DAEMON():
print(e) print(e)
time.sleep(1) time.sleep(1)
def update_serial_devices(self): def update_serial_devices(self):
""" """
update serial devices and set to static update serial devices and set to static
@ -115,7 +110,6 @@ class DAEMON():
""" """
while 1: while 1:
try: try:
data = self.daemon_queue.get() data = self.daemon_queue.get()
# data[1] mycall # data[1] mycall
@ -168,7 +162,6 @@ class DAEMON():
# disabled mode # disabled mode
if data[13] != 'disabled': if data[13] != 'disabled':
options.append('--devicename') options.append('--devicename')
options.append(data[5]) options.append(data[5])
@ -212,7 +205,6 @@ class DAEMON():
if data[18] == 'True': if data[18] == 'True':
options.append('--500hz') options.append('--500hz')
options.append('--tuning_range_fmin') options.append('--tuning_range_fmin')
options.append(data[19]) options.append(data[19])
@ -229,8 +221,6 @@ class DAEMON():
if data[23] == 'True': if data[23] == 'True':
options.append('--qrv') options.append('--qrv')
# try running tnc from binary, else run from source # try running tnc from binary, else run from source
# this helps running the tnc in a developer environment # this helps running the tnc in a developer environment
try: try:
@ -282,7 +272,6 @@ class DAEMON():
# data[10] rigctld_ip # data[10] rigctld_ip
# data[11] rigctld_port # data[11] rigctld_port
if data[0] == 'TEST_HAMLIB': if data[0] == 'TEST_HAMLIB':
devicename = data[1] devicename = data[1]
deviceport = data[2] deviceport = data[2]
serialspeed = data[3] serialspeed = data[3]
@ -295,8 +284,6 @@ class DAEMON():
rigctld_ip = data[10] rigctld_ip = data[10]
rigctld_port = data[11] rigctld_port = data[11]
# check how we want to control the radio # check how we want to control the radio
if radiocontrol == 'direct': if radiocontrol == 'direct':
import rig import rig
@ -334,13 +321,10 @@ class DAEMON():
except Exception as e: except Exception as e:
print(e) print(e)
if __name__ == '__main__': if __name__ == '__main__':
# we need to run this on windows for multiprocessing support # we need to run this on windows for multiprocessing support
multiprocessing.freeze_support() multiprocessing.freeze_support()
# --------------------------------------------GET PARAMETER INPUTS # --------------------------------------------GET PARAMETER INPUTS
PARSER = argparse.ArgumentParser(description='FreeDATA Daemon') PARSER = argparse.ArgumentParser(description='FreeDATA Daemon')
PARSER.add_argument('--port', dest="socket_port",default=3001, help="Socket port in the range of 1024-65536", type=int) PARSER.add_argument('--port', dest="socket_port",default=3001, help="Socket port in the range of 1024-65536", type=int)
@ -348,7 +332,6 @@ if __name__ == '__main__':
static.DAEMONPORT = ARGS.socket_port static.DAEMONPORT = ARGS.socket_port
try: try:
if sys.platform == 'linux': if sys.platform == 'linux':
logging_path = os.getenv("HOME") + '/.config/' + 'FreeDATA/' + 'daemon' logging_path = os.getenv("HOME") + '/.config/' + 'FreeDATA/' + 'daemon'
@ -377,8 +360,8 @@ if __name__ == '__main__':
except Exception as e: except Exception as e:
structlog.get_logger("structlog").error("[DMN] Starting TCP/IP socket failed", port=static.DAEMONPORT, e=e) structlog.get_logger("structlog").error("[DMN] Starting TCP/IP socket failed", port=static.DAEMONPORT, e=e)
os._exit(1) os._exit(1)
daemon = DAEMON()
daemon = DAEMON()
structlog.get_logger("structlog").info("[DMN] Starting FreeDATA Daemon", author="DJ2LS", year="2022", version=static.VERSION) structlog.get_logger("structlog").info("[DMN] Starting FreeDATA Daemon", author="DJ2LS", year="2022", version=static.VERSION)
while True: while True:

126
tnc/data_handler.py
View file

@ -28,11 +28,11 @@ TESTMODE = False
DATA_QUEUE_TRANSMIT = queue.Queue() DATA_QUEUE_TRANSMIT = queue.Queue()
DATA_QUEUE_RECEIVED = queue.Queue() DATA_QUEUE_RECEIVED = queue.Queue()
class DATA(): class DATA():
""" """ """ """
def __init__(self): def __init__(self):
self.mycallsign = static.MYCALLSIGN # initial callsign. Will be overwritten later self.mycallsign = static.MYCALLSIGN # initial callsign. Will be overwritten later
self.data_queue_transmit = DATA_QUEUE_TRANSMIT self.data_queue_transmit = DATA_QUEUE_TRANSMIT
@ -49,8 +49,6 @@ class DATA():
self.received_mycall_crc = b'' # received my callsign crc if we received a crc for another ssid self.received_mycall_crc = b'' # received my callsign crc if we received a crc for another ssid
self.data_channel_last_received = 0.0 # time of last "live sign" of a frame self.data_channel_last_received = 0.0 # time of last "live sign" of a frame
self.burst_ack_snr = 0 # SNR from received ack frames self.burst_ack_snr = 0 # SNR from received ack frames
self.burst_ack = False # if we received an acknowledge frame for a burst self.burst_ack = False # if we received an acknowledge frame for a burst
@ -113,11 +111,9 @@ class DATA():
self.beacon_thread = threading.Thread(target=self.run_beacon, name="watchdog",daemon=True) self.beacon_thread = threading.Thread(target=self.run_beacon, name="watchdog",daemon=True)
self.beacon_thread.start() self.beacon_thread.start()
def worker_transmit(self): def worker_transmit(self):
""" """ """ """
while True: while True:
data = self.data_queue_transmit.get() data = self.data_queue_transmit.get()
# [0] Command # [0] Command
@ -154,7 +150,6 @@ class DATA():
# [5] mycallsign with ssid # [5] mycallsign with ssid
self.open_dc_and_transmit(data[1], data[2], data[3], data[4], data[5]) self.open_dc_and_transmit(data[1], data[2], data[3], data[4], data[5])
elif data[0] == 'CONNECT': elif data[0] == 'CONNECT':
# [0] DX CALLSIGN # [0] DX CALLSIGN
self.arq_session_handler(data[1]) self.arq_session_handler(data[1])
@ -171,7 +166,6 @@ class DATA():
print(f"wrong command {data}") print(f"wrong command {data}")
pass pass
def worker_receive(self): def worker_receive(self):
""" """ """ """
while True: while True:
@ -181,7 +175,6 @@ class DATA():
# [2] bytes_per_frame # [2] bytes_per_frame
self.process_data(bytes_out=data[0],freedv=data[1],bytes_per_frame=data[2]) self.process_data(bytes_out=data[0],freedv=data[1],bytes_per_frame=data[2])
def process_data(self, bytes_out, freedv, bytes_per_frame): def process_data(self, bytes_out, freedv, bytes_per_frame):
""" """
@ -197,11 +190,8 @@ class DATA():
# bytes_out[1:4] == callsign check for signalling frames, # bytes_out[1:4] == callsign check for signalling frames,
# bytes_out[2:5] == transmission # bytes_out[2:5] == transmission
# we could also create an own function, which returns True. # we could also create an own function, which returns True.
frametype = int.from_bytes(bytes(bytes_out[:1]), "big") frametype = int.from_bytes(bytes(bytes_out[:1]), "big")
print(f"self.n_retries_per_burst = {self.n_retries_per_burst}") print(f"self.n_retries_per_burst = {self.n_retries_per_burst}")
_valid1, _ = helpers.check_callsign(self.mycallsign, bytes(bytes_out[1:4])) _valid1, _ = helpers.check_callsign(self.mycallsign, bytes(bytes_out[1:4]))
@ -251,7 +241,6 @@ class DATA():
structlog.get_logger("structlog").debug("BURST NACK RECEIVED....") structlog.get_logger("structlog").debug("BURST NACK RECEIVED....")
self.burst_nack_received(bytes_out[:-2]) self.burst_nack_received(bytes_out[:-2])
# CQ FRAME # CQ FRAME
elif frametype == 200: elif frametype == 200:
structlog.get_logger("structlog").debug("CQ RECEIVED....") structlog.get_logger("structlog").debug("CQ RECEIVED....")
@ -262,20 +251,16 @@ class DATA():
structlog.get_logger("structlog").debug("QRV RECEIVED!") structlog.get_logger("structlog").debug("QRV RECEIVED!")
self.received_qrv(bytes_out[:-2]) self.received_qrv(bytes_out[:-2])
# PING FRAME # PING FRAME
elif frametype == 210: elif frametype == 210:
structlog.get_logger("structlog").debug("PING RECEIVED....") structlog.get_logger("structlog").debug("PING RECEIVED....")
self.received_ping(bytes_out[:-2]) self.received_ping(bytes_out[:-2])
# PING ACK # PING ACK
elif frametype == 211: elif frametype == 211:
structlog.get_logger("structlog").debug("PING ACK RECEIVED....") structlog.get_logger("structlog").debug("PING ACK RECEIVED....")
self.received_ping_ack(bytes_out[:-2]) self.received_ping_ack(bytes_out[:-2])
# SESSION OPENER # SESSION OPENER
elif frametype == 221: elif frametype == 221:
structlog.get_logger("structlog").debug("OPEN SESSION RECEIVED....") structlog.get_logger("structlog").debug("OPEN SESSION RECEIVED....")
@ -301,14 +286,11 @@ class DATA():
structlog.get_logger("structlog").debug("ARQ arq_received_channel_is_open") structlog.get_logger("structlog").debug("ARQ arq_received_channel_is_open")
self.arq_received_channel_is_open(bytes_out[:-2]) self.arq_received_channel_is_open(bytes_out[:-2])
# ARQ MANUAL MODE TRANSMISSION # ARQ MANUAL MODE TRANSMISSION
elif 230 <= frametype <= 240 : elif 230 <= frametype <= 240 :
structlog.get_logger("structlog").debug("ARQ manual mode ") structlog.get_logger("structlog").debug("ARQ manual mode ")
self.arq_received_data_channel_opener(bytes_out[:-2]) self.arq_received_data_channel_opener(bytes_out[:-2])
# ARQ STOP TRANSMISSION # ARQ STOP TRANSMISSION
elif frametype == 249: elif frametype == 249:
structlog.get_logger("structlog").debug("ARQ received stop transmission") structlog.get_logger("structlog").debug("ARQ received stop transmission")
@ -330,8 +312,6 @@ class DATA():
# for debugging purposes to receive all data # for debugging purposes to receive all data
structlog.get_logger("structlog").debug("[TNC] Unknown frame received", frame=bytes_out[:-2]) structlog.get_logger("structlog").debug("[TNC] Unknown frame received", frame=bytes_out[:-2])
def arq_data_received(self, data_in:bytes, bytes_per_frame:int, snr:int, freedv): def arq_data_received(self, data_in:bytes, bytes_per_frame:int, snr:int, freedv):
""" """
@ -376,7 +356,6 @@ class DATA():
RX_N_FRAME_OF_BURST = int.from_bytes(bytes(data_in[:1]), "big") - 10 # get number of burst frame RX_N_FRAME_OF_BURST = int.from_bytes(bytes(data_in[:1]), "big") - 10 # get number of burst frame
RX_N_FRAMES_PER_BURST = int.from_bytes(bytes(data_in[1:2]), "big") # get number of bursts from received frame RX_N_FRAMES_PER_BURST = int.from_bytes(bytes(data_in[1:2]), "big") # get number of bursts from received frame
''' '''
The RX burst buffer needs to have a fixed length filled with "None". We need this later for counting the "Nones" The RX burst buffer needs to have a fixed length filled with "None". We need this later for counting the "Nones"
check if burst buffer has expected length else create it check if burst buffer has expected length else create it
@ -387,8 +366,6 @@ class DATA():
# append data to rx burst buffer # append data to rx burst buffer
static.RX_BURST_BUFFER[RX_N_FRAME_OF_BURST] = data_in[8:] # [frame_type][n_frames_per_burst][CRC24][CRC24] static.RX_BURST_BUFFER[RX_N_FRAME_OF_BURST] = data_in[8:] # [frame_type][n_frames_per_burst][CRC24][CRC24]
structlog.get_logger("structlog").debug("[TNC] static.RX_BURST_BUFFER", buffer=static.RX_BURST_BUFFER) structlog.get_logger("structlog").debug("[TNC] static.RX_BURST_BUFFER", buffer=static.RX_BURST_BUFFER)
helpers.add_to_heard_stations(static.DXCALLSIGN,static.DXGRID, 'DATA-CHANNEL', static.SNR, static.FREQ_OFFSET, static.HAMLIB_FREQUENCY) helpers.add_to_heard_stations(static.DXCALLSIGN,static.DXGRID, 'DATA-CHANNEL', static.SNR, static.FREQ_OFFSET, static.HAMLIB_FREQUENCY)
@ -414,14 +391,11 @@ class DATA():
# here we are going to search for our data in the last received bytes # here we are going to search for our data in the last received bytes
# this increases chance we are not loosing the entire frame in case of signalling frame loss # this increases chance we are not loosing the entire frame in case of signalling frame loss
else: else:
# static.RX_FRAME_BUFFER --> exisitng data # static.RX_FRAME_BUFFER --> exisitng data
# temp_burst_buffer --> new data # temp_burst_buffer --> new data
# search_area --> area where we want to search # search_area --> area where we want to search
search_area = 510 search_area = 510
search_position = len(static.RX_FRAME_BUFFER)-search_area search_position = len(static.RX_FRAME_BUFFER)-search_area
# find position of data. returns -1 if nothing found in area else >= 0 # find position of data. returns -1 if nothing found in area else >= 0
# we are beginning from the end, so if data exists twice or more, only the last one should be replaced # we are beginning from the end, so if data exists twice or more, only the last one should be replaced
@ -436,9 +410,6 @@ class DATA():
static.RX_FRAME_BUFFER += temp_burst_buffer static.RX_FRAME_BUFFER += temp_burst_buffer
structlog.get_logger("structlog").debug("[TNC] ARQ | RX | appending data to buffer") structlog.get_logger("structlog").debug("[TNC] ARQ | RX | appending data to buffer")
# lets check if we didnt receive a BOF and EOF yet to avoid sending ack frames if we already received all data # lets check if we didnt receive a BOF and EOF yet to avoid sending ack frames if we already received all data
if not self.rx_frame_bof_received and not self.rx_frame_eof_received and data_in.find(self.data_frame_eof) < 0: if not self.rx_frame_bof_received and not self.rx_frame_eof_received and data_in.find(self.data_frame_eof) < 0:
@ -474,7 +445,6 @@ class DATA():
# calculate statistics # calculate statistics
self.calculate_transfer_rate_rx(self.rx_start_of_transmission, len(static.RX_FRAME_BUFFER)) self.calculate_transfer_rate_rx(self.rx_start_of_transmission, len(static.RX_FRAME_BUFFER))
# check if we received last frame of burst and we have "Nones" in our rx buffer # check if we received last frame of burst and we have "Nones" in our rx buffer
# this is an indicator for missed frames. # this is an indicator for missed frames.
# with this way of doing this, we always MUST receive the last frame of a burst otherwise the entire # with this way of doing this, we always MUST receive the last frame of a burst otherwise the entire
@ -490,7 +460,6 @@ class DATA():
# we need to work on this # we need to work on this
codec2.api.freedv_set_frames_per_burst(freedv,len(missing_frames)) codec2.api.freedv_set_frames_per_burst(freedv,len(missing_frames))
# then create a repeat frame # then create a repeat frame
rpt_frame = bytearray(14) rpt_frame = bytearray(14)
rpt_frame[:1] = bytes([62]) rpt_frame[:1] = bytes([62])
@ -508,12 +477,10 @@ class DATA():
time.sleep(0.01) time.sleep(0.01)
self.calculate_transfer_rate_rx(self.rx_start_of_transmission, len(static.RX_FRAME_BUFFER)) self.calculate_transfer_rate_rx(self.rx_start_of_transmission, len(static.RX_FRAME_BUFFER))
# we should never reach this point # we should never reach this point
else: else:
structlog.get_logger("structlog").error("we shouldnt reach this point...", frame=RX_N_FRAME_OF_BURST, frames=RX_N_FRAMES_PER_BURST) structlog.get_logger("structlog").error("we shouldnt reach this point...", frame=RX_N_FRAME_OF_BURST, frames=RX_N_FRAMES_PER_BURST)
# We have a BOF and EOF flag in our data. If we received both we received our frame. # We have a BOF and EOF flag in our data. If we received both we received our frame.
# In case of loosing data but we received already a BOF and EOF we need to make sure, we # In case of loosing data but we received already a BOF and EOF we need to make sure, we
# received the complete last burst by checking it for Nones # received the complete last burst by checking it for Nones
@ -531,7 +498,6 @@ class DATA():
static.ARQ_COMPRESSION_FACTOR = compression_factor / 10 static.ARQ_COMPRESSION_FACTOR = compression_factor / 10
self.calculate_transfer_rate_rx(self.rx_start_of_transmission, len(static.RX_FRAME_BUFFER)) self.calculate_transfer_rate_rx(self.rx_start_of_transmission, len(static.RX_FRAME_BUFFER))
if bof_position >= 0 and eof_position > 0 and not None in static.RX_BURST_BUFFER: if bof_position >= 0 and eof_position > 0 and not None in static.RX_BURST_BUFFER:
print(f"bof_position {bof_position} / eof_position {eof_position}") print(f"bof_position {bof_position} / eof_position {eof_position}")
self.rx_frame_bof_received = True self.rx_frame_bof_received = True
@ -545,7 +511,6 @@ class DATA():
static.TOTAL_BYTES = frame_length static.TOTAL_BYTES = frame_length
# 8:9 = compression factor # 8:9 = compression factor
data_frame = payload[9:] data_frame = payload[9:]
data_frame_crc_received = helpers.get_crc_32(data_frame) data_frame_crc_received = helpers.get_crc_32(data_frame)
@ -554,17 +519,14 @@ class DATA():
if data_frame_crc == data_frame_crc_received: if data_frame_crc == data_frame_crc_received:
structlog.get_logger("structlog").info("[TNC] ARQ | RX | DATA FRAME SUCESSFULLY RECEIVED") structlog.get_logger("structlog").info("[TNC] ARQ | RX | DATA FRAME SUCESSFULLY RECEIVED")
# decompression # decompression
data_frame_decompressed = zlib.decompress(data_frame) data_frame_decompressed = zlib.decompress(data_frame)
static.ARQ_COMPRESSION_FACTOR = len(data_frame_decompressed) / len(data_frame) static.ARQ_COMPRESSION_FACTOR = len(data_frame_decompressed) / len(data_frame)
data_frame = data_frame_decompressed data_frame = data_frame_decompressed
uniqueid = str(uuid.uuid4()) uniqueid = str(uuid.uuid4())
timestamp = int(time.time()) timestamp = int(time.time())
# check if callsign ssid override # check if callsign ssid override
valid, mycallsign = helpers.check_callsign(self.mycallsign, self.received_mycall_crc) valid, mycallsign = helpers.check_callsign(self.mycallsign, self.received_mycall_crc)
if not valid: if not valid:
@ -622,7 +584,6 @@ class DATA():
while static.TRANSMITTING: while static.TRANSMITTING:
time.sleep(0.01) time.sleep(0.01)
# update session timeout # update session timeout
self.arq_session_last_received = int(time.time()) # we need to update our timeout timestamp self.arq_session_last_received = int(time.time()) # we need to update our timeout timestamp
@ -631,8 +592,6 @@ class DATA():
if not TESTMODE: if not TESTMODE:
self.arq_cleanup() self.arq_cleanup()
def arq_transmit(self, data_out:bytes, mode:int, n_frames_per_burst:int): def arq_transmit(self, data_out:bytes, mode:int, n_frames_per_burst:int):
""" """
@ -644,7 +603,6 @@ class DATA():
Returns: Returns:
""" """
global TESTMODE global TESTMODE
self.arq_file_transfer = True self.arq_file_transfer = True
@ -663,7 +621,6 @@ class DATA():
DATA_FRAME_ACK_TIMEOUT_SECONDS = 3.0 # timeout for data frame acknowledges DATA_FRAME_ACK_TIMEOUT_SECONDS = 3.0 # timeout for data frame acknowledges
RPT_ACK_TIMEOUT_SECONDS = 3.0 # timeout for rpt frame acknowledges RPT_ACK_TIMEOUT_SECONDS = 3.0 # timeout for rpt frame acknowledges
# save len of data_out to TOTAL_BYTES for our statistics --> kBytes # save len of data_out to TOTAL_BYTES for our statistics --> kBytes
#static.TOTAL_BYTES = round(len(data_out) / 1024, 2) #static.TOTAL_BYTES = round(len(data_out) / 1024, 2)
static.TOTAL_BYTES = len(data_out) static.TOTAL_BYTES = len(data_out)
@ -674,10 +631,8 @@ class DATA():
json_data_out = json.dumps(jsondata) json_data_out = json.dumps(jsondata)
sock.SOCKET_QUEUE.put(json_data_out) sock.SOCKET_QUEUE.put(json_data_out)
structlog.get_logger("structlog").info("[TNC] | TX | DATACHANNEL", mode=mode, Bytes=static.TOTAL_BYTES) structlog.get_logger("structlog").info("[TNC] | TX | DATACHANNEL", mode=mode, Bytes=static.TOTAL_BYTES)
# compression # compression
data_frame_compressed = zlib.compress(data_out) data_frame_compressed = zlib.compress(data_out)
compression_factor = len(data_out) / len(data_frame_compressed) compression_factor = len(data_out) / len(data_frame_compressed)
@ -694,7 +649,6 @@ class DATA():
frame_payload_crc = helpers.get_crc_32(data_out) frame_payload_crc = helpers.get_crc_32(data_out)
structlog.get_logger("structlog").debug("frame payload crc", crc=frame_payload_crc) structlog.get_logger("structlog").debug("frame payload crc", crc=frame_payload_crc)
# data_out = self.data_frame_bof + frame_payload_crc + data_out + self.data_frame_eof # data_out = self.data_frame_bof + frame_payload_crc + data_out + self.data_frame_eof
data_out = self.data_frame_bof + frame_payload_crc + frame_total_size + compression_factor + data_out + self.data_frame_eof data_out = self.data_frame_bof + frame_payload_crc + frame_total_size + compression_factor + data_out + self.data_frame_eof
@ -704,10 +658,8 @@ class DATA():
# iterate through data out buffer # iterate through data out buffer
while bufferposition < len(data_out) and not self.data_frame_ack_received and static.ARQ_STATE: while bufferposition < len(data_out) and not self.data_frame_ack_received and static.ARQ_STATE:
# we have TX_N_MAX_RETRIES_PER_BURST attempts for sending a burst # we have TX_N_MAX_RETRIES_PER_BURST attempts for sending a burst
for self.tx_n_retry_of_burst in range(0,TX_N_MAX_RETRIES_PER_BURST): for self.tx_n_retry_of_burst in range(0,TX_N_MAX_RETRIES_PER_BURST):
# AUTO MODE SELECTION # AUTO MODE SELECTION
# mode 255 == AUTO MODE # mode 255 == AUTO MODE
# force usage of selected mode # force usage of selected mode
@ -715,7 +667,6 @@ class DATA():
data_mode = mode data_mode = mode
structlog.get_logger("structlog").debug("FIXED MODE", mode=data_mode) structlog.get_logger("structlog").debug("FIXED MODE", mode=data_mode)
else: else:
# we are doing a modulo check of transmission retries of the actual burst # we are doing a modulo check of transmission retries of the actual burst
# every 2nd retry which failes, decreases speedlevel by 1. # every 2nd retry which failes, decreases speedlevel by 1.
@ -735,8 +686,6 @@ class DATA():
# self.speed_level = len(self.mode_list)-1 # self.speed_level = len(self.mode_list)-1
# if speed level is greater than our available modes, set speed level to maximum = lenght of mode list -1 # if speed level is greater than our available modes, set speed level to maximum = lenght of mode list -1
if self.speed_level >= len(self.mode_list): if self.speed_level >= len(self.mode_list):
self.speed_level = len(self.mode_list) - 1 self.speed_level = len(self.mode_list) - 1
static.ARQ_SPEED_LEVEL = self.speed_level static.ARQ_SPEED_LEVEL = self.speed_level
@ -744,8 +693,6 @@ class DATA():
structlog.get_logger("structlog").debug("Speed-level:", level=self.speed_level, retry=self.tx_n_retry_of_burst, mode=data_mode) structlog.get_logger("structlog").debug("Speed-level:", level=self.speed_level, retry=self.tx_n_retry_of_burst, mode=data_mode)
# payload information # payload information
payload_per_frame = modem.get_bytes_per_frame(data_mode) -2 payload_per_frame = modem.get_bytes_per_frame(data_mode) -2
@ -755,7 +702,6 @@ class DATA():
# append data frames with TX_N_FRAMES_PER_BURST to tempbuffer # append data frames with TX_N_FRAMES_PER_BURST to tempbuffer
# this part ineeds to a completly rewrite! # this part ineeds to a completly rewrite!
# TX_NF_RAMES_PER_BURST = 1 is working # TX_NF_RAMES_PER_BURST = 1 is working
arqheader = bytearray() arqheader = bytearray()
arqheader[:1] = bytes([10]) #bytes([10 + i]) arqheader[:1] = bytes([10]) #bytes([10 + i])
arqheader[1:2] = bytes([TX_N_FRAMES_PER_BURST]) arqheader[1:2] = bytes([TX_N_FRAMES_PER_BURST])
@ -766,7 +712,6 @@ class DATA():
# normal behavior # normal behavior
if bufferposition_end <= len(data_out): if bufferposition_end <= len(data_out):
frame = data_out[bufferposition:bufferposition_end] frame = data_out[bufferposition:bufferposition_end]
frame = arqheader + frame frame = arqheader + frame
@ -780,7 +725,6 @@ class DATA():
extended_data_out += bytes([0]) * (payload_per_frame-len(extended_data_out)-len(arqheader)) extended_data_out += bytes([0]) * (payload_per_frame-len(extended_data_out)-len(arqheader))
frame = arqheader + extended_data_out frame = arqheader + extended_data_out
# append frame to tempbuffer for transmission # append frame to tempbuffer for transmission
tempbuffer.append(frame) tempbuffer.append(frame)
@ -822,7 +766,6 @@ class DATA():
if self.data_frame_ack_received: if self.data_frame_ack_received:
break #break retry loop break #break retry loop
# we need this part for leaving the repeat loop # we need this part for leaving the repeat loop
# static.ARQ_STATE == 'DATA' --> when stopping transmission manually # static.ARQ_STATE == 'DATA' --> when stopping transmission manually
if not static.ARQ_STATE: if not static.ARQ_STATE:
@ -845,9 +788,7 @@ class DATA():
#GOING TO NEXT ITERATION #GOING TO NEXT ITERATION
if self.data_frame_ack_received: if self.data_frame_ack_received:
static.INFO.append("ARQ;TRANSMITTING;SUCCESS") static.INFO.append("ARQ;TRANSMITTING;SUCCESS")
jsondata = {"arq":"transmission", "status" :"success", "uuid" : self.transmission_uuid, "percent" : static.ARQ_TRANSMISSION_PERCENT, "bytesperminute" : static.ARQ_BYTES_PER_MINUTE} jsondata = {"arq":"transmission", "status" :"success", "uuid" : self.transmission_uuid, "percent" : static.ARQ_TRANSMISSION_PERCENT, "bytesperminute" : static.ARQ_BYTES_PER_MINUTE}
json_data_out = json.dumps(jsondata) json_data_out = json.dumps(jsondata)
@ -855,8 +796,6 @@ class DATA():
structlog.get_logger("structlog").info("ARQ | TX | DATA TRANSMITTED!", BytesPerMinute=static.ARQ_BYTES_PER_MINUTE, BitsPerSecond=static.ARQ_BITS_PER_SECOND, overflows=static.BUFFER_OVERFLOW_COUNTER) structlog.get_logger("structlog").info("ARQ | TX | DATA TRANSMITTED!", BytesPerMinute=static.ARQ_BYTES_PER_MINUTE, BitsPerSecond=static.ARQ_BITS_PER_SECOND, overflows=static.BUFFER_OVERFLOW_COUNTER)
else: else:
static.INFO.append("ARQ;TRANSMITTING;FAILED") static.INFO.append("ARQ;TRANSMITTING;FAILED")
jsondata = {"arq":"transmission", "status" :"failed", "uuid" : self.transmission_uuid, "percent" : static.ARQ_TRANSMISSION_PERCENT, "bytesperminute" : static.ARQ_BYTES_PER_MINUTE} jsondata = {"arq":"transmission", "status" :"failed", "uuid" : self.transmission_uuid, "percent" : static.ARQ_TRANSMISSION_PERCENT, "bytesperminute" : static.ARQ_BYTES_PER_MINUTE}
@ -876,8 +815,6 @@ class DATA():
import os import os
os._exit(0) os._exit(0)
# signalling frames received # signalling frames received
def burst_ack_received(self, data_in:bytes): def burst_ack_received(self, data_in:bytes):
""" """
@ -888,7 +825,6 @@ class DATA():
Returns: Returns:
""" """
# increase speed level if we received a burst ack # increase speed level if we received a burst ack
#self.speed_level += 1 #self.speed_level += 1
#if self.speed_level >= len(self.mode_list)-1: #if self.speed_level >= len(self.mode_list)-1:
@ -907,6 +843,7 @@ class DATA():
self.burst_nack_counter = 0 self.burst_nack_counter = 0
# reset n retries per burst counter # reset n retries per burst counter
self.n_retries_per_burst = 0 self.n_retries_per_burst = 0
# signalling frames received # signalling frames received
def burst_nack_received(self, data_in:bytes): def burst_nack_received(self, data_in:bytes):
""" """
@ -917,7 +854,6 @@ class DATA():
Returns: Returns:
""" """
# increase speed level if we received a burst ack # increase speed level if we received a burst ack
#self.speed_level += 1 #self.speed_level += 1
#if self.speed_level >= len(self.mode_list)-1: #if self.speed_level >= len(self.mode_list)-1:
@ -934,7 +870,6 @@ class DATA():
self.burst_nack_counter += 1 self.burst_nack_counter += 1
print(self.speed_level) print(self.speed_level)
def frame_ack_received(self): def frame_ack_received(self):
""" """ """ """
# only process data if we are in ARQ and BUSY state # only process data if we are in ARQ and BUSY state
@ -963,8 +898,6 @@ class DATA():
if not TESTMODE: if not TESTMODE:
self.arq_cleanup() self.arq_cleanup()
def burst_rpt_received(self, data_in:bytes): def burst_rpt_received(self, data_in:bytes):
""" """
@ -974,7 +907,6 @@ class DATA():
Returns: Returns:
""" """
# only process data if we are in ARQ and BUSY state # only process data if we are in ARQ and BUSY state
if static.ARQ_STATE and static.TNC_STATE == 'BUSY': if static.ARQ_STATE and static.TNC_STATE == 'BUSY':
helpers.add_to_heard_stations(static.DXCALLSIGN,static.DXGRID, 'DATA-CHANNEL', static.SNR, static.FREQ_OFFSET, static.HAMLIB_FREQUENCY) helpers.add_to_heard_stations(static.DXCALLSIGN,static.DXGRID, 'DATA-CHANNEL', static.SNR, static.FREQ_OFFSET, static.HAMLIB_FREQUENCY)
@ -990,8 +922,6 @@ class DATA():
missing = missing_area[i:i + 2] missing = missing_area[i:i + 2]
self.rpt_request_buffer.insert(0, missing) self.rpt_request_buffer.insert(0, missing)
# ############################################################################################################ # ############################################################################################################
# ARQ SESSION HANDLER # ARQ SESSION HANDLER
# ############################################################################################################ # ############################################################################################################
@ -1023,7 +953,6 @@ class DATA():
static.ARQ_SESSION_STATE = 'failed' static.ARQ_SESSION_STATE = 'failed'
return False return False
def open_session(self, callsign): def open_session(self, callsign):
""" """
@ -1044,7 +973,6 @@ class DATA():
connection_frame[4:7] = static.MYCALLSIGN_CRC connection_frame[4:7] = static.MYCALLSIGN_CRC
connection_frame[7:13] = helpers.callsign_to_bytes(self.mycallsign) connection_frame[7:13] = helpers.callsign_to_bytes(self.mycallsign)
while not static.ARQ_SESSION: while not static.ARQ_SESSION:
time.sleep(0.01) time.sleep(0.01)
for attempt in range(1,self.session_connect_max_retries+1): for attempt in range(1,self.session_connect_max_retries+1):
@ -1077,7 +1005,6 @@ class DATA():
self.close_session() self.close_session()
return False return False
def received_session_opener(self, data_in:bytes): def received_session_opener(self, data_in:bytes):
""" """
@ -1102,7 +1029,6 @@ class DATA():
self.transmit_session_heartbeat() self.transmit_session_heartbeat()
def close_session(self): def close_session(self):
""" """ """ """
static.ARQ_SESSION_STATE = 'disconnecting' static.ARQ_SESSION_STATE = 'disconnecting'
@ -1153,7 +1079,6 @@ class DATA():
def transmit_session_heartbeat(self): def transmit_session_heartbeat(self):
""" """ """ """
# static.ARQ_SESSION = True # static.ARQ_SESSION = True
# static.TNC_STATE = 'BUSY' # static.TNC_STATE = 'BUSY'
# static.ARQ_SESSION_STATE = 'connected' # static.ARQ_SESSION_STATE = 'connected'
@ -1165,7 +1090,6 @@ class DATA():
connection_frame[1:4] = static.DXCALLSIGN_CRC connection_frame[1:4] = static.DXCALLSIGN_CRC
connection_frame[4:7] = static.MYCALLSIGN_CRC connection_frame[4:7] = static.MYCALLSIGN_CRC
txbuffer = [connection_frame] txbuffer = [connection_frame]
static.TRANSMITTING = True static.TRANSMITTING = True
@ -1174,9 +1098,6 @@ class DATA():
while static.TRANSMITTING: while static.TRANSMITTING:
time.sleep(0.01) time.sleep(0.01)
def received_session_heartbeat(self, data_in:bytes): def received_session_heartbeat(self, data_in:bytes):
""" """
@ -1186,7 +1107,6 @@ class DATA():
Returns: Returns:
""" """
# Accept session data if the DXCALLSIGN_CRC matches the station in static. # Accept session data if the DXCALLSIGN_CRC matches the station in static.
_valid_crc, _ = helpers.check_callsign(static.DXCALLSIGN, bytes(data_in[4:7])) _valid_crc, _ = helpers.check_callsign(static.DXCALLSIGN, bytes(data_in[4:7]))
if _valid_crc: if _valid_crc:
@ -1229,7 +1149,6 @@ class DATA():
if static.ARQ_SESSION: if static.ARQ_SESSION:
time.sleep(0.5) time.sleep(0.5)
self.datachannel_timeout = False self.datachannel_timeout = False
# we need to compress data for gettin a compression factor. # we need to compress data for gettin a compression factor.
@ -1269,7 +1188,6 @@ class DATA():
frametype = bytes([225]) frametype = bytes([225])
structlog.get_logger("structlog").debug("requesting high bandwith mode") structlog.get_logger("structlog").debug("requesting high bandwith mode")
if 230 <= mode <= 240: if 230 <= mode <= 240:
structlog.get_logger("structlog").debug("requesting manual mode --> not yet implemented ") structlog.get_logger("structlog").debug("requesting manual mode --> not yet implemented ")
frametype = bytes([mode]) frametype = bytes([mode])
@ -1320,10 +1238,6 @@ class DATA():
return False return False
#sys.exit() # close thread and so connection attempts #sys.exit() # close thread and so connection attempts
def arq_received_data_channel_opener(self, data_in:bytes): def arq_received_data_channel_opener(self, data_in:bytes):
""" """
@ -1353,7 +1267,6 @@ class DATA():
self.time_list = self.time_list_low_bw self.time_list = self.time_list_low_bw
self.speed_level = len(self.mode_list) - 1 self.speed_level = len(self.mode_list) - 1
if 230 <= frametype <= 240: if 230 <= frametype <= 240:
print("manual mode request") print("manual mode request")
@ -1375,7 +1288,6 @@ class DATA():
static.ARQ_STATE = True static.ARQ_STATE = True
static.TNC_STATE = 'BUSY' static.TNC_STATE = 'BUSY'
self.reset_statistics() self.reset_statistics()
self.data_channel_last_received = int(time.time()) self.data_channel_last_received = int(time.time())
@ -1405,8 +1317,6 @@ class DATA():
# set start of transmission for our statistics # set start of transmission for our statistics
self.rx_start_of_transmission = time.time() self.rx_start_of_transmission = time.time()
def arq_received_channel_is_open(self, data_in:bytes): def arq_received_channel_is_open(self, data_in:bytes):
""" """
Called if we received a data channel opener Called if we received a data channel opener
@ -1448,7 +1358,6 @@ class DATA():
structlog.get_logger("structlog").warning("protocol version missmatch", received=protocol_version, own=static.ARQ_PROTOCOL_VERSION) structlog.get_logger("structlog").warning("protocol version missmatch", received=protocol_version, own=static.ARQ_PROTOCOL_VERSION)
self.arq_cleanup() self.arq_cleanup()
# ---------- PING # ---------- PING
def transmit_ping(self, dxcallsign:bytes): def transmit_ping(self, dxcallsign:bytes):
""" """
@ -1492,7 +1401,6 @@ class DATA():
Returns: Returns:
""" """
static.DXCALLSIGN_CRC = bytes(data_in[4:7]) static.DXCALLSIGN_CRC = bytes(data_in[4:7])
static.DXCALLSIGN = helpers.bytes_to_callsign(bytes(data_in[7:13])) static.DXCALLSIGN = helpers.bytes_to_callsign(bytes(data_in[7:13]))
helpers.add_to_heard_stations(static.DXCALLSIGN, static.DXGRID, 'PING', static.SNR, static.FREQ_OFFSET, static.HAMLIB_FREQUENCY) helpers.add_to_heard_stations(static.DXCALLSIGN, static.DXGRID, 'PING', static.SNR, static.FREQ_OFFSET, static.HAMLIB_FREQUENCY)
@ -1534,7 +1442,6 @@ class DATA():
Returns: Returns:
""" """
static.DXCALLSIGN_CRC = bytes(data_in[4:7]) static.DXCALLSIGN_CRC = bytes(data_in[4:7])
static.DXGRID = bytes(data_in[7:13]).rstrip(b'\x00') static.DXGRID = bytes(data_in[7:13]).rstrip(b'\x00')
@ -1549,7 +1456,6 @@ class DATA():
structlog.get_logger("structlog").info("[TNC] PING ACK [" + str(self.mycallsign, 'utf-8') + "] >|< [" + str(static.DXCALLSIGN, 'utf-8') + "]", snr=static.SNR ) structlog.get_logger("structlog").info("[TNC] PING ACK [" + str(self.mycallsign, 'utf-8') + "] >|< [" + str(static.DXCALLSIGN, 'utf-8') + "]", snr=static.SNR )
static.TNC_STATE = 'IDLE' static.TNC_STATE = 'IDLE'
def stop_transmission(self): def stop_transmission(self):
""" """
Force a stop of the running transmission Force a stop of the running transmission
@ -1594,7 +1500,6 @@ class DATA():
""" """
try: try:
while 1: while 1:
time.sleep(0.5) time.sleep(0.5)
while static.BEACON_STATE: while static.BEACON_STATE:
@ -1616,7 +1521,6 @@ class DATA():
else: else:
modem.MODEM_TRANSMIT_QUEUE.put([14,1,0,txbuffer]) modem.MODEM_TRANSMIT_QUEUE.put([14,1,0,txbuffer])
# wait while transmitting # wait while transmitting
while static.TRANSMITTING: while static.TRANSMITTING:
time.sleep(0.01) time.sleep(0.01)
@ -1649,7 +1553,6 @@ class DATA():
structlog.get_logger("structlog").info("[TNC] BEACON RCVD [" + str(dxcallsign, 'utf-8') + "]["+ str(dxgrid, 'utf-8') +"] ", snr=static.SNR) structlog.get_logger("structlog").info("[TNC] BEACON RCVD [" + str(dxcallsign, 'utf-8') + "]["+ str(dxgrid, 'utf-8') +"] ", snr=static.SNR)
helpers.add_to_heard_stations(dxcallsign,dxgrid, 'BEACON', static.SNR, static.FREQ_OFFSET, static.HAMLIB_FREQUENCY) helpers.add_to_heard_stations(dxcallsign,dxgrid, 'BEACON', static.SNR, static.FREQ_OFFSET, static.HAMLIB_FREQUENCY)
def transmit_cq(self): def transmit_cq(self):
""" """
Transmit a CQ Transmit a CQ
@ -1675,7 +1578,6 @@ class DATA():
time.sleep(0.01) time.sleep(0.01)
return return
def received_cq(self, data_in:bytes): def received_cq(self, data_in:bytes):
""" """
Called if we received a CQ Called if we received a CQ
@ -1696,7 +1598,6 @@ class DATA():
if static.RESPOND_TO_CQ: if static.RESPOND_TO_CQ:
self.transmit_qrv() self.transmit_qrv()
def transmit_qrv(self): def transmit_qrv(self):
""" """
Called if we send a QRV frame Called if we send a QRV frame
@ -1731,7 +1632,6 @@ class DATA():
while static.TRANSMITTING: while static.TRANSMITTING:
time.sleep(0.01) time.sleep(0.01)
def received_qrv(self, data_in:bytes): def received_qrv(self, data_in:bytes):
""" """
Called if we receive a QRV frame Called if we receive a QRV frame
@ -1753,7 +1653,6 @@ class DATA():
structlog.get_logger("structlog").info("[TNC] QRV RCVD [" + str(dxcallsign, 'utf-8') + "]["+ str(dxgrid, 'utf-8') +"] ", snr=static.SNR) structlog.get_logger("structlog").info("[TNC] QRV RCVD [" + str(dxcallsign, 'utf-8') + "]["+ str(dxgrid, 'utf-8') +"] ", snr=static.SNR)
helpers.add_to_heard_stations(dxcallsign,dxgrid, 'QRV', static.SNR, static.FREQ_OFFSET, static.HAMLIB_FREQUENCY) helpers.add_to_heard_stations(dxcallsign,dxgrid, 'QRV', static.SNR, static.FREQ_OFFSET, static.HAMLIB_FREQUENCY)
# ------------ CALUCLATE TRANSFER RATES # ------------ CALUCLATE TRANSFER RATES
def calculate_transfer_rate_rx(self, rx_start_of_transmission:float, receivedbytes:int) -> list: def calculate_transfer_rate_rx(self, rx_start_of_transmission:float, receivedbytes:int) -> list:
""" """
@ -1765,7 +1664,6 @@ class DATA():
Returns: Returns:
""" """
try: try:
if static.TOTAL_BYTES == 0: if static.TOTAL_BYTES == 0:
static.TOTAL_BYTES = 1 static.TOTAL_BYTES = 1
@ -1791,8 +1689,6 @@ class DATA():
static.ARQ_BYTES_PER_MINUTE, \ static.ARQ_BYTES_PER_MINUTE, \
static.ARQ_TRANSMISSION_PERCENT] static.ARQ_TRANSMISSION_PERCENT]
def reset_statistics(self): def reset_statistics(self):
""" """
Reset statistics Reset statistics
@ -1816,7 +1712,6 @@ class DATA():
Returns: Returns:
""" """
try: try:
static.ARQ_TRANSMISSION_PERCENT = int((sentbytes / tx_buffer_length) * 100) static.ARQ_TRANSMISSION_PERCENT = int((sentbytes / tx_buffer_length) * 100)
@ -1843,14 +1738,12 @@ class DATA():
static.ARQ_BYTES_PER_MINUTE, \ static.ARQ_BYTES_PER_MINUTE, \
static.ARQ_TRANSMISSION_PERCENT] static.ARQ_TRANSMISSION_PERCENT]
# ----------------------CLEANUP AND RESET FUNCTIONS # ----------------------CLEANUP AND RESET FUNCTIONS
def arq_cleanup(self): def arq_cleanup(self):
""" """
Cleanup funktion which clears all ARQ states Cleanup funktion which clears all ARQ states
""" """
structlog.get_logger("structlog").debug("cleanup") structlog.get_logger("structlog").debug("cleanup")
self.received_mycall_crc = b'' self.received_mycall_crc = b''
@ -1894,10 +1787,6 @@ class DATA():
static.BEACON_PAUSE = False static.BEACON_PAUSE = False
def arq_reset_ack(self,state:bool): def arq_reset_ack(self,state:bool):
""" """
Funktion for resetting acknowledge states Funktion for resetting acknowledge states
@ -1907,12 +1796,10 @@ class DATA():
Returns: Returns:
""" """
self.burst_ack = state self.burst_ack = state
self.rpt_request_received = state self.rpt_request_received = state
self.data_frame_ack_received = state self.data_frame_ack_received = state
def set_listening_modes(self, mode): def set_listening_modes(self, mode):
""" """
Function for setting the data modes we are listening to for saving cpu power Function for setting the data modes we are listening to for saving cpu power
@ -1941,7 +1828,6 @@ class DATA():
modem.RECEIVE_FSK_LDPC_1 = True modem.RECEIVE_FSK_LDPC_1 = True
structlog.get_logger("structlog").debug("changing listening data mode", mode="datac1/datac3/fsk_ldpc") structlog.get_logger("structlog").debug("changing listening data mode", mode="datac1/datac3/fsk_ldpc")
# ------------------------- WATCHDOG FUNCTIONS FOR TIMER # ------------------------- WATCHDOG FUNCTIONS FOR TIMER
def watchdog(self): def watchdog(self):
"""Author: DJ2LS """Author: DJ2LS
@ -1959,13 +1845,11 @@ class DATA():
self.burst_watchdog() self.burst_watchdog()
self.arq_session_keep_alive_watchdog() self.arq_session_keep_alive_watchdog()
def burst_watchdog(self): def burst_watchdog(self):
""" """
watchdog which checks if we are running into a connection timeout watchdog which checks if we are running into a connection timeout
DATA BURST DATA BURST
""" """
# IRS SIDE # IRS SIDE
if static.ARQ_STATE and static.ARQ_SESSION_STATE == 'connected' and static.TNC_STATE == 'BUSY' and self.is_IRS: if static.ARQ_STATE and static.ARQ_SESSION_STATE == 'connected' and static.TNC_STATE == 'BUSY' and self.is_IRS:
if self.data_channel_last_received + self.time_list[self.speed_level] > time.time(): if self.data_channel_last_received + self.time_list[self.speed_level] > time.time():
@ -2011,13 +1895,11 @@ class DATA():
self.stop_transmission() self.stop_transmission()
self.arq_cleanup() self.arq_cleanup()
def data_channel_keep_alive_watchdog(self): def data_channel_keep_alive_watchdog(self):
""" """
watchdog which checks if we are running into a connection timeout watchdog which checks if we are running into a connection timeout
DATA CHANNEL DATA CHANNEL
""" """
# and not static.ARQ_SEND_KEEP_ALIVE: # and not static.ARQ_SEND_KEEP_ALIVE:
if static.ARQ_STATE and static.TNC_STATE == 'BUSY': if static.ARQ_STATE and static.TNC_STATE == 'BUSY':
time.sleep(0.01) time.sleep(0.01)
@ -2045,8 +1927,6 @@ class DATA():
static.INFO.append("ARQ;SESSION;TIMEOUT") static.INFO.append("ARQ;SESSION;TIMEOUT")
self.close_session() self.close_session()
def heartbeat(self): def heartbeat(self):
""" """
heartbeat thread which auto resumes the heartbeat signal within a arq session heartbeat thread which auto resumes the heartbeat signal within a arq session
@ -2058,7 +1938,5 @@ class DATA():
self.transmit_session_heartbeat() self.transmit_session_heartbeat()
time.sleep(2) time.sleep(2)
def send_test_frame(self): def send_test_frame(self):
modem.MODEM_TRANSMIT_QUEUE.put([12,1,0,[bytearray(126)]]) modem.MODEM_TRANSMIT_QUEUE.put([12,1,0,[bytearray(126)]])

21
tnc/helpers.py
View file

@ -5,13 +5,10 @@ Created on Fri Dec 25 21:25:14 2020
@author: DJ2LS @author: DJ2LS
""" """
import time import time
import crcengine import crcengine
import static import static
def wait(seconds): def wait(seconds):
""" """
@ -27,8 +24,6 @@ def wait(seconds):
time.sleep(0.01) time.sleep(0.01)
return True return True
def get_crc_8(data): def get_crc_8(data):
"""Author: DJ2LS """Author: DJ2LS
@ -47,7 +42,6 @@ def get_crc_8(data):
crc_data = crc_data.to_bytes(1, byteorder='big') crc_data = crc_data.to_bytes(1, byteorder='big')
return crc_data return crc_data
def get_crc_16(data): def get_crc_16(data):
"""Author: DJ2LS """Author: DJ2LS
@ -87,7 +81,6 @@ def get_crc_24(data):
crc_data = crc_data.to_bytes(3, byteorder='big') crc_data = crc_data.to_bytes(3, byteorder='big')
return crc_data return crc_data
def get_crc_32(data): def get_crc_32(data):
"""Author: DJ2LS """Author: DJ2LS
@ -106,7 +99,6 @@ def get_crc_32(data):
crc_data = crc_data.to_bytes(4, byteorder='big') crc_data = crc_data.to_bytes(4, byteorder='big')
return crc_data return crc_data
def add_to_heard_stations(dxcallsign, dxgrid, datatype, snr, offset, frequency): def add_to_heard_stations(dxcallsign, dxgrid, datatype, snr, offset, frequency):
""" """
@ -137,14 +129,11 @@ def add_to_heard_stations(dxcallsign, dxgrid, datatype, snr, offset, frequency):
static.HEARD_STATIONS.append([dxcallsign, dxgrid, int(time.time()), datatype, snr, offset, frequency]) static.HEARD_STATIONS.append([dxcallsign, dxgrid, int(time.time()), datatype, snr, offset, frequency])
break break
# for idx, item in enumerate(static.HEARD_STATIONS): # for idx, item in enumerate(static.HEARD_STATIONS):
# if dxcallsign in item: # if dxcallsign in item:
# item = [dxcallsign, int(time.time())] # item = [dxcallsign, int(time.time())]
# static.HEARD_STATIONS[idx] = item # static.HEARD_STATIONS[idx] = item
def callsign_to_bytes(callsign): def callsign_to_bytes(callsign):
""" """
@ -195,7 +184,6 @@ def callsign_to_bytes(callsign):
ssid = bytes([ssid]).decode("utf-8") ssid = bytes([ssid]).decode("utf-8")
return encode_call(callsign + ssid) return encode_call(callsign + ssid)
#return bytes(bytestring) #return bytes(bytestring)
def bytes_to_callsign(bytestring): def bytes_to_callsign(bytestring):
@ -209,7 +197,6 @@ def bytes_to_callsign(bytestring):
bytes bytes
""" """
# http://www.aprs.org/aprs11/SSIDs.txt # http://www.aprs.org/aprs11/SSIDs.txt
#-0 Your primary station usually fixed and message capable #-0 Your primary station usually fixed and message capable
#-1 generic additional station, digi, mobile, wx, etc #-1 generic additional station, digi, mobile, wx, etc
@ -246,8 +233,6 @@ def bytes_to_callsign(bytestring):
ssid = ord(bytes(decoded[-1], "utf-8")) ssid = ord(bytes(decoded[-1], "utf-8"))
return bytes(callsign + "-" + str(ssid), "utf-8") return bytes(callsign + "-" + str(ssid), "utf-8")
def check_callsign(callsign:bytes, crc_to_check:bytes): def check_callsign(callsign:bytes, crc_to_check:bytes):
""" """
Funktion to check a crc against a callsign to calculate the ssid by generating crc until we got it Funktion to check a crc against a callsign to calculate the ssid by generating crc until we got it
@ -260,7 +245,6 @@ def check_callsign(callsign:bytes, crc_to_check:bytes):
[True, Callsign + SSID] [True, Callsign + SSID]
False False
""" """
print(callsign) print(callsign)
try: try:
callsign = callsign.split(b'-') callsign = callsign.split(b'-')
@ -282,8 +266,6 @@ def check_callsign(callsign:bytes, crc_to_check:bytes):
return [False, ""] return [False, ""]
def encode_grid(grid): def encode_grid(grid):
""" """
@auther: DB1UJ @auther: DB1UJ
@ -345,8 +327,6 @@ def decode_grid(b_code_word:bytes):
return grid return grid
def encode_call(call): def encode_call(call):
""" """
@auther: DB1UJ @auther: DB1UJ
@ -390,4 +370,3 @@ def decode_call(b_code_word:bytes):
call = call[0:-1] + ssid # remove the last char from call and replace with SSID call = call[0:-1] + ssid # remove the last char from call and replace with SSID
return call return call

1
tnc/log_handler.py
View file

@ -8,7 +8,6 @@ def setup_logging(filename):
Returns: Returns:
""" """
import logging.config import logging.config
import structlog import structlog

9
tnc/main.py
View file

@ -6,11 +6,7 @@ Created on Tue Dec 22 16:58:45 2020
@author: DJ2LS @author: DJ2LS
main module for running the tnc main module for running the tnc
""" """
import argparse import argparse
import threading import threading
import static import static
@ -26,7 +22,6 @@ import signal
import time import time
import multiprocessing import multiprocessing
# signal handler for closing aplication # signal handler for closing aplication
def signal_handler(sig, frame): def signal_handler(sig, frame):
""" """
@ -75,7 +70,6 @@ if __name__ == '__main__':
PARSER.add_argument('--tuning_range_fmax', dest="tuning_range_fmax", choices=[50.0, 100.0, 150.0, 200.0, 250.0], default=50.0, help="Tuning range fmax", type=float) PARSER.add_argument('--tuning_range_fmax', dest="tuning_range_fmax", choices=[50.0, 100.0, 150.0, 200.0, 250.0], default=50.0, help="Tuning range fmax", type=float)
PARSER.add_argument('--tx-audio-level', dest="tx_audio_level", default=50, help="Set the tx audio level at an early stage", type=int) PARSER.add_argument('--tx-audio-level', dest="tx_audio_level", default=50, help="Set the tx audio level at an early stage", type=int)
ARGS = PARSER.parse_args() ARGS = PARSER.parse_args()
# additional step for beeing sure our callsign is correctly # additional step for beeing sure our callsign is correctly
@ -132,8 +126,6 @@ if __name__ == '__main__':
except: except:
structlog.get_logger("structlog").error("[DMN] logger init error") structlog.get_logger("structlog").error("[DMN] logger init error")
structlog.get_logger("structlog").info("[TNC] Starting FreeDATA", author="DJ2LS", year="2022", version=static.VERSION) structlog.get_logger("structlog").info("[TNC] Starting FreeDATA", author="DJ2LS", year="2022", version=static.VERSION)
# start data handler # start data handler
@ -142,7 +134,6 @@ if __name__ == '__main__':
# start modem # start modem
modem = modem.RF() modem = modem.RF()
# --------------------------------------------START CMD SERVER # --------------------------------------------START CMD SERVER
try: try:

40
tnc/modem.py
View file

@ -40,7 +40,6 @@ RECEIVE_DATAC1 = False
RECEIVE_DATAC3 = False RECEIVE_DATAC3 = False
RECEIVE_FSK_LDPC_1 = False RECEIVE_FSK_LDPC_1 = False
class RF(): class RF():
""" """ """ """
@ -49,7 +48,6 @@ class RF():
self.sampler_avg = 0 self.sampler_avg = 0
self.buffer_avg = 0 self.buffer_avg = 0
self.AUDIO_SAMPLE_RATE_RX = 48000 self.AUDIO_SAMPLE_RATE_RX = 48000
self.AUDIO_SAMPLE_RATE_TX = 48000 self.AUDIO_SAMPLE_RATE_TX = 48000
self.MODEM_SAMPLE_RATE = codec2.api.FREEDV_FS_8000 self.MODEM_SAMPLE_RATE = codec2.api.FREEDV_FS_8000
@ -107,7 +105,6 @@ class RF():
codec2.api.freedv_set_frames_per_burst(self.datac3_freedv,1) codec2.api.freedv_set_frames_per_burst(self.datac3_freedv,1)
self.datac3_buffer = codec2.audio_buffer(2*self.AUDIO_FRAMES_PER_BUFFER_RX) self.datac3_buffer = codec2.audio_buffer(2*self.AUDIO_FRAMES_PER_BUFFER_RX)
self.fsk_ldpc_freedv_0 = cast(codec2.api.freedv_open_advanced(codec2.api.FREEDV_MODE_FSK_LDPC, ctypes.byref(codec2.api.FREEDV_MODE_FSK_LDPC_0_ADV)), c_void_p) self.fsk_ldpc_freedv_0 = cast(codec2.api.freedv_open_advanced(codec2.api.FREEDV_MODE_FSK_LDPC, ctypes.byref(codec2.api.FREEDV_MODE_FSK_LDPC_0_ADV)), c_void_p)
self.fsk_ldpc_bytes_per_frame_0 = int(codec2.api.freedv_get_bits_per_modem_frame(self.fsk_ldpc_freedv_0)/8) self.fsk_ldpc_bytes_per_frame_0 = int(codec2.api.freedv_get_bits_per_modem_frame(self.fsk_ldpc_freedv_0)/8)
self.fsk_ldpc_bytes_out_0 = create_string_buffer(self.fsk_ldpc_bytes_per_frame_0) self.fsk_ldpc_bytes_out_0 = create_string_buffer(self.fsk_ldpc_bytes_per_frame_0)
@ -147,7 +144,6 @@ class RF():
structlog.get_logger("structlog").error("[TNC] starting pyaudio callback failed", e=e) structlog.get_logger("structlog").error("[TNC] starting pyaudio callback failed", e=e)
else: else:
# create a stream object for simulating audio stream # create a stream object for simulating audio stream
class Object(object): class Object(object):
pass pass
@ -168,7 +164,6 @@ class RF():
mkfifo_read_callback_thread = threading.Thread(target=self.mkfifo_read_callback, name="MKFIFO READ CALLBACK THREAD",daemon=True) mkfifo_read_callback_thread = threading.Thread(target=self.mkfifo_read_callback, name="MKFIFO READ CALLBACK THREAD",daemon=True)
mkfifo_read_callback_thread.start() mkfifo_read_callback_thread.start()
# --------------------------------------------INIT AND OPEN HAMLIB # --------------------------------------------INIT AND OPEN HAMLIB
# check how we want to control the radio # check how we want to control the radio
if static.HAMLIB_RADIOCONTROL == 'direct': if static.HAMLIB_RADIOCONTROL == 'direct':
@ -182,7 +177,6 @@ class RF():
else: else:
import rigdummy as rig import rigdummy as rig
self.hamlib = rig.radio() self.hamlib = rig.radio()
self.hamlib.open_rig(devicename=static.HAMLIB_DEVICE_NAME, deviceport=static.HAMLIB_DEVICE_PORT, hamlib_ptt_type=static.HAMLIB_PTT_TYPE, serialspeed=static.HAMLIB_SERIAL_SPEED, pttport=static.HAMLIB_PTT_PORT, data_bits=static.HAMLIB_DATA_BITS, stop_bits=static.HAMLIB_STOP_BITS, handshake=static.HAMLIB_HANDSHAKE, rigctld_ip = static.HAMLIB_RGICTLD_IP, rigctld_port = static.HAMLIB_RGICTLD_PORT) self.hamlib.open_rig(devicename=static.HAMLIB_DEVICE_NAME, deviceport=static.HAMLIB_DEVICE_PORT, hamlib_ptt_type=static.HAMLIB_PTT_TYPE, serialspeed=static.HAMLIB_SERIAL_SPEED, pttport=static.HAMLIB_PTT_PORT, data_bits=static.HAMLIB_DATA_BITS, stop_bits=static.HAMLIB_STOP_BITS, handshake=static.HAMLIB_HANDSHAKE, rigctld_ip = static.HAMLIB_RGICTLD_IP, rigctld_port = static.HAMLIB_RGICTLD_PORT)
@ -219,7 +213,6 @@ class RF():
# -------------------------------------------------------------------------------------------------------- # --------------------------------------------------------------------------------------------------------
def mkfifo_read_callback(self): def mkfifo_read_callback(self):
while 1: while 1:
time.sleep(0.01) time.sleep(0.01)
# -----read # -----read
data_in48k = bytes() data_in48k = bytes()
@ -245,8 +238,6 @@ class RF():
if RECEIVE_DATAC3: if RECEIVE_DATAC3:
self.datac3_buffer.push(x) self.datac3_buffer.push(x)
def mkfifo_write_callback(self): def mkfifo_write_callback(self):
while 1: while 1:
time.sleep(0.01) time.sleep(0.01)
@ -264,7 +255,6 @@ class RF():
fifo_write.write(data_out48k) fifo_write.write(data_out48k)
fifo_write.flush() fifo_write.flush()
# -------------------------------------------------------------------------------------------------------- # --------------------------------------------------------------------------------------------------------
#def audio_callback(self, data_in48k, frame_count, time_info, status): #def audio_callback(self, data_in48k, frame_count, time_info, status):
def callback(self, data_in48k, outdata, frames, time, status): def callback(self, data_in48k, outdata, frames, time, status):
@ -279,7 +269,6 @@ class RF():
Returns: Returns:
""" """
x = np.frombuffer(data_in48k, dtype=np.int16) x = np.frombuffer(data_in48k, dtype=np.int16)
x = self.resampler.resample48_to_8(x) x = self.resampler.resample48_to_8(x)
@ -358,18 +347,15 @@ class RF():
data_out = json.dumps(jsondata) data_out = json.dumps(jsondata)
sock.SOCKET_QUEUE.put(data_out) sock.SOCKET_QUEUE.put(data_out)
# open codec2 instance # open codec2 instance
self.MODE = mode self.MODE = mode
if self.MODE == 'FSK_LDPC_0' or self.MODE == 200: if self.MODE == 'FSK_LDPC_0' or self.MODE == 200:
freedv = cast(codec2.api.freedv_open_advanced(codec2.api.FREEDV_MODE_FSK_LDPC, ctypes.byref(codec2.api.FREEDV_MODE_FSK_LDPC_0_ADV)), c_void_p) freedv = cast(codec2.api.freedv_open_advanced(codec2.api.FREEDV_MODE_FSK_LDPC, ctypes.byref(codec2.api.FREEDV_MODE_FSK_LDPC_0_ADV)), c_void_p)
elif self.MODE == 'FSK_LDPC_1' or self.MODE == 201: elif self.MODE == 'FSK_LDPC_1' or self.MODE == 201:
freedv = cast(codec2.api.freedv_open_advanced(codec2.api.FREEDV_MODE_FSK_LDPC, ctypes.byref(codec2.api.FREEDV_MODE_FSK_LDPC_1_ADV)), c_void_p) freedv = cast(codec2.api.freedv_open_advanced(codec2.api.FREEDV_MODE_FSK_LDPC, ctypes.byref(codec2.api.FREEDV_MODE_FSK_LDPC_1_ADV)), c_void_p)
else: else:
freedv = cast(codec2.api.freedv_open(self.MODE), c_void_p) freedv = cast(codec2.api.freedv_open(self.MODE), c_void_p)
# get number of bytes per frame for mode # get number of bytes per frame for mode
bytes_per_frame = int(codec2.api.freedv_get_bits_per_modem_frame(freedv)/8) bytes_per_frame = int(codec2.api.freedv_get_bits_per_modem_frame(freedv)/8)
payload_bytes_per_frame = bytes_per_frame -2 payload_bytes_per_frame = bytes_per_frame -2
@ -415,7 +401,6 @@ class RF():
codec2.api.freedv_rawdatatx(freedv,mod_out,data) # modulate DATA and save it into mod_out pointer codec2.api.freedv_rawdatatx(freedv,mod_out,data) # modulate DATA and save it into mod_out pointer
txbuffer += bytes(mod_out) txbuffer += bytes(mod_out)
# codec2 fsk preamble may be broken - at least it sounds like that so we are disabling it for testing # codec2 fsk preamble may be broken - at least it sounds like that so we are disabling it for testing
if not self.MODE == 'FSK_LDPC_0' or self.MODE == 200 or self.MODE == 'FSK_LDPC_1' or self.MODE == 201: if not self.MODE == 'FSK_LDPC_0' or self.MODE == 200 or self.MODE == 'FSK_LDPC_1' or self.MODE == 201:
# write preamble to txbuffer # write preamble to txbuffer
@ -437,12 +422,8 @@ class RF():
# deaktivated for testing purposes # deaktivated for testing purposes
self.mod_out_locked = False self.mod_out_locked = False
# ------------------------------- # -------------------------------
chunk_length = self.AUDIO_FRAMES_PER_BUFFER_TX #4800 chunk_length = self.AUDIO_FRAMES_PER_BUFFER_TX #4800
chunk = [txbuffer_48k[i:i+chunk_length] for i in range(0, len(txbuffer_48k), chunk_length)] chunk = [txbuffer_48k[i:i+chunk_length] for i in range(0, len(txbuffer_48k), chunk_length)]
for c in chunk: for c in chunk:
@ -455,8 +436,6 @@ class RF():
#structlog.get_logger("structlog").debug("[TNC] mod out shorter than audio buffer", delta=delta) #structlog.get_logger("structlog").debug("[TNC] mod out shorter than audio buffer", delta=delta)
self.modoutqueue.append(c) self.modoutqueue.append(c)
# Release our mod_out_lock so we can use the queue # Release our mod_out_lock so we can use the queue
self.mod_out_locked = False self.mod_out_locked = False
@ -553,8 +532,6 @@ class RF():
#self.get_scatter(self.fsk_ldpc_freedv_1) #self.get_scatter(self.fsk_ldpc_freedv_1)
self.calculate_snr(self.fsk_ldpc_freedv_1) self.calculate_snr(self.fsk_ldpc_freedv_1)
# worker for FIFO queue for processing received frames # worker for FIFO queue for processing received frames
def worker_transmit(self): def worker_transmit(self):
""" """ """ """
@ -564,8 +541,6 @@ class RF():
self.transmit(mode=data[0], repeats=data[1], repeat_delay=data[2], frames=data[3]) self.transmit(mode=data[0], repeats=data[1], repeat_delay=data[2], frames=data[3])
#self.modem_transmit_queue.task_done() #self.modem_transmit_queue.task_done()
# worker for FIFO queue for processing received frames # worker for FIFO queue for processing received frames
def worker_received(self): def worker_received(self):
""" """ """ """
@ -577,7 +552,6 @@ class RF():
data_handler.DATA_QUEUE_RECEIVED.put([data[0], data[1], data[2]]) data_handler.DATA_QUEUE_RECEIVED.put([data[0], data[1], data[2]])
self.modem_received_queue.task_done() self.modem_received_queue.task_done()
def get_frequency_offset(self, freedv): def get_frequency_offset(self, freedv):
""" """
@ -594,7 +568,6 @@ class RF():
static.FREQ_OFFSET = offset static.FREQ_OFFSET = offset
return offset return offset
def get_scatter(self, freedv): def get_scatter(self, freedv):
""" """
@ -629,7 +602,6 @@ class RF():
scatterdata_small = scatterdata[::10] scatterdata_small = scatterdata[::10]
static.SCATTER = scatterdata_small static.SCATTER = scatterdata_small
def calculate_snr(self, freedv): def calculate_snr(self, freedv):
""" """
@ -639,7 +611,6 @@ class RF():
Returns: Returns:
""" """
try: try:
modem_stats_snr = c_float() modem_stats_snr = c_float()
modem_stats_sync = c_int() modem_stats_sync = c_int()
@ -666,7 +637,6 @@ class RF():
static.HAMLIB_MODE = self.hamlib.get_mode() static.HAMLIB_MODE = self.hamlib.get_mode()
static.HAMLIB_BANDWITH = self.hamlib.get_bandwith() static.HAMLIB_BANDWITH = self.hamlib.get_bandwith()
def calculate_fft(self): def calculate_fft(self):
""" """ """ """
# channel_busy_delay counter # channel_busy_delay counter
@ -678,7 +648,6 @@ class RF():
# WE NEED TO OPTIMIZE THIS! # WE NEED TO OPTIMIZE THIS!
if len(self.fft_data) >= 128: if len(self.fft_data) >= 128:
# https://gist.github.com/ZWMiller/53232427efc5088007cab6feee7c6e4c # https://gist.github.com/ZWMiller/53232427efc5088007cab6feee7c6e4c
# Fast Fourier Transform, 10*log10(abs) is to scale it to dB # Fast Fourier Transform, 10*log10(abs) is to scale it to dB
# and make sure it's not imaginary # and make sure it's not imaginary
@ -693,7 +662,6 @@ class RF():
# get average of dfft # get average of dfft
avg = np.mean(dfft) avg = np.mean(dfft)
# detect signals which are higher than the average + 10 ( +10 smoothes the output ) # detect signals which are higher than the average + 10 ( +10 smoothes the output )
# data higher than the average must be a signal. Therefore we are setting it to 100 so it will be highlighted # data higher than the average must be a signal. Therefore we are setting it to 100 so it will be highlighted
# have to do this when we are not transmittig so our own sending data will not affect this too much # have to do this when we are not transmittig so our own sending data will not affect this too much
@ -703,7 +671,6 @@ class RF():
# calculate audio max value # calculate audio max value
# static.AUDIO_RMS = np.amax(self.fft_data) # static.AUDIO_RMS = np.amax(self.fft_data)
# check for signals higher than average by checking for "100" # check for signals higher than average by checking for "100"
# if we have a signal, increment our channel_busy delay counter so we have a smoother state toggle # if we have a signal, increment our channel_busy delay counter so we have a smoother state toggle
@ -728,9 +695,7 @@ class RF():
static.FFT = dfftlist[0:320] #320 --> bandwith 3000 static.FFT = dfftlist[0:320] #320 --> bandwith 3000
except: except:
structlog.get_logger("structlog").debug("[TNC] Setting fft=0") structlog.get_logger("structlog").debug("[TNC] Setting fft=0")
# else 0 # else 0
static.FFT = [0] static.FFT = [0]
@ -750,8 +715,6 @@ class RF():
codec2.api.freedv_set_frames_per_burst(self.datac3_freedv,n_frames_per_burst) codec2.api.freedv_set_frames_per_burst(self.datac3_freedv,n_frames_per_burst)
codec2.api.freedv_set_frames_per_burst(self.fsk_ldpc_freedv_0,n_frames_per_burst) codec2.api.freedv_set_frames_per_burst(self.fsk_ldpc_freedv_0,n_frames_per_burst)
def get_bytes_per_frame(mode): def get_bytes_per_frame(mode):
""" """
provide bytes per frame information for accessing from data handler provide bytes per frame information for accessing from data handler
@ -772,9 +735,6 @@ def get_bytes_per_frame(mode):
# get number of bytes per frame for mode # get number of bytes per frame for mode
return int(codec2.api.freedv_get_bits_per_modem_frame(freedv)/8) return int(codec2.api.freedv_get_bits_per_modem_frame(freedv)/8)
def set_audio_volume(datalist, volume): def set_audio_volume(datalist, volume):
data = np.fromstring(datalist, np.int16) * (volume / 100.) data = np.fromstring(datalist, np.int16) * (volume / 100.)
return data.astype(np.int16) return data.astype(np.int16)

12
tnc/rig.py
View file

@ -7,7 +7,6 @@ import atexit
import subprocess import subprocess
import os import os
# set global hamlib version # set global hamlib version
hamlib_version = 0 hamlib_version = 0
@ -19,7 +18,6 @@ except:
app_path = os.path.abspath(".") app_path = os.path.abspath(".")
sys.path.append(app_path) sys.path.append(app_path)
# try importing hamlib # try importing hamlib
try: try:
# get python version # get python version
@ -76,7 +74,6 @@ except Exception as e:
class radio: class radio:
""" """ """ """
def __init__(self): def __init__(self):
self.devicename = '' self.devicename = ''
self.devicenumber = '' self.devicenumber = ''
self.deviceport = '' self.deviceport = ''
@ -106,7 +103,6 @@ class radio:
Returns: Returns:
""" """
self.devicename = devicename self.devicename = devicename
self.deviceport = str(deviceport) self.deviceport = str(deviceport)
self.serialspeed = str(serialspeed) # we need to ensure this is a str, otherwise set_conf functions are crashing self.serialspeed = str(serialspeed) # we need to ensure this is a str, otherwise set_conf functions are crashing
@ -116,7 +112,6 @@ class radio:
self.stop_bits = str(stop_bits) self.stop_bits = str(stop_bits)
self.handshake = str(handshake) self.handshake = str(handshake)
# try to init hamlib # try to init hamlib
try: try:
Hamlib.rig_set_debug(Hamlib.RIG_DEBUG_NONE) Hamlib.rig_set_debug(Hamlib.RIG_DEBUG_NONE)
@ -128,7 +123,6 @@ class radio:
structlog.get_logger("structlog").error("[RIG] Hamlib: rig not supported...") structlog.get_logger("structlog").error("[RIG] Hamlib: rig not supported...")
self.devicenumber = 0 self.devicenumber = 0
self.my_rig = Hamlib.Rig(self.devicenumber) self.my_rig = Hamlib.Rig(self.devicenumber)
self.my_rig.set_conf("rig_pathname", self.deviceport) self.my_rig.set_conf("rig_pathname", self.deviceport)
self.my_rig.set_conf("retry", "5") self.my_rig.set_conf("retry", "5")
@ -138,9 +132,6 @@ class radio:
self.my_rig.set_conf("data_bits", self.data_bits) self.my_rig.set_conf("data_bits", self.data_bits)
self.my_rig.set_conf("ptt_pathname", self.pttport) self.my_rig.set_conf("ptt_pathname", self.pttport)
if self.hamlib_ptt_type == 'RIG': if self.hamlib_ptt_type == 'RIG':
self.hamlib_ptt_type = Hamlib.RIG_PTT_RIG self.hamlib_ptt_type = Hamlib.RIG_PTT_RIG
self.my_rig.set_conf("ptt_type", 'RIG') self.my_rig.set_conf("ptt_type", 'RIG')
@ -149,7 +140,6 @@ class radio:
self.hamlib_ptt_type = Hamlib.RIG_PORT_USB self.hamlib_ptt_type = Hamlib.RIG_PORT_USB
self.my_rig.set_conf("ptt_type", 'USB') self.my_rig.set_conf("ptt_type", 'USB')
elif self.hamlib_ptt_type == 'DTR-H': elif self.hamlib_ptt_type == 'DTR-H':
self.hamlib_ptt_type = Hamlib.RIG_PTT_SERIAL_DTR self.hamlib_ptt_type = Hamlib.RIG_PTT_SERIAL_DTR
self.my_rig.set_conf("dtr_state", "HIGH") self.my_rig.set_conf("dtr_state", "HIGH")
@ -182,7 +172,6 @@ class radio:
structlog.get_logger("structlog").info("[RIG] Opening...", device=self.devicenumber, path=self.my_rig.get_conf("rig_pathname"), serial_speed=self.my_rig.get_conf("serial_speed"), serial_handshake=self.my_rig.get_conf("serial_handshake"), stop_bits=self.my_rig.get_conf("stop_bits"), data_bits=self.my_rig.get_conf("data_bits"), ptt_pathname=self.my_rig.get_conf("ptt_pathname")) structlog.get_logger("structlog").info("[RIG] Opening...", device=self.devicenumber, path=self.my_rig.get_conf("rig_pathname"), serial_speed=self.my_rig.get_conf("serial_speed"), serial_handshake=self.my_rig.get_conf("serial_handshake"), stop_bits=self.my_rig.get_conf("stop_bits"), data_bits=self.my_rig.get_conf("data_bits"), ptt_pathname=self.my_rig.get_conf("ptt_pathname"))
self.my_rig.open() self.my_rig.open()
atexit.register(self.my_rig.close) atexit.register(self.my_rig.close)
@ -199,7 +188,6 @@ class radio:
except: except:
structlog.get_logger("structlog").info("[RIG] Hamlib device opened", status='SUCCESS') structlog.get_logger("structlog").info("[RIG] Hamlib device opened", status='SUCCESS')
# set ptt to false if ptt is stuck for some reason # set ptt to false if ptt is stuck for some reason
self.set_ptt(False) self.set_ptt(False)

9
tnc/rigctl.py
View file

@ -18,10 +18,10 @@ import os
# set global hamlib version # set global hamlib version
hamlib_version = 0 hamlib_version = 0
class radio: class radio:
""" """ """ """
def __init__(self): def __init__(self):
self.devicename = '' self.devicename = ''
self.devicenumber = '' self.devicenumber = ''
self.deviceport = '' self.deviceport = ''
@ -51,7 +51,6 @@ class radio:
Returns: Returns:
""" """
self.devicename = devicename self.devicename = devicename
self.deviceport = deviceport self.deviceport = deviceport
self.serialspeed = str(serialspeed) # we need to ensure this is a str, otherwise set_conf functions are crashing self.serialspeed = str(serialspeed) # we need to ensure this is a str, otherwise set_conf functions are crashing
@ -61,7 +60,6 @@ class radio:
self.stop_bits = stop_bits self.stop_bits = stop_bits
self.handshake = handshake self.handshake = handshake
# check if we are running in a pyinstaller environment # check if we are running in a pyinstaller environment
try: try:
app_path = sys._MEIPASS app_path = sys._MEIPASS
@ -86,9 +84,6 @@ class radio:
print(self.devicenumber, self.deviceport, self.serialspeed) print(self.devicenumber, self.deviceport, self.serialspeed)
# select precompiled executable for win32/win64 rigctl # select precompiled executable for win32/win64 rigctl
# this is really a hack...somewhen we need a native hamlib integration for windows # this is really a hack...somewhen we need a native hamlib integration for windows
if sys.platform == 'win32' or sys.platform == 'win64': if sys.platform == 'win32' or sys.platform == 'win64':
@ -116,7 +111,6 @@ class radio:
except: except:
return False return False
def get_mode(self): def get_mode(self):
""" """ """ """
#(hamlib_mode, bandwith) = self.my_rig.get_mode() #(hamlib_mode, bandwith) = self.my_rig.get_mode()
@ -126,7 +120,6 @@ class radio:
except: except:
return False return False
def get_bandwith(self): def get_bandwith(self):
""" """ """ """
#(hamlib_mode, bandwith) = self.my_rig.get_mode() #(hamlib_mode, bandwith) = self.my_rig.get_mode()

6
tnc/rigctld.py
View file

@ -5,6 +5,7 @@ import log_handler
import logging import logging
import time import time
import static import static
# class taken from darsidelemm # class taken from darsidelemm
# rigctl - https://github.com/darksidelemm/rotctld-web-gui/blob/master/rotatorgui.py#L35 # rigctl - https://github.com/darksidelemm/rotctld-web-gui/blob/master/rotatorgui.py#L35
# #
@ -13,6 +14,7 @@ import static
# set global hamlib version # set global hamlib version
hamlib_version = 0 hamlib_version = 0
class radio(): class radio():
"""rotctld (hamlib) communication class""" """rotctld (hamlib) communication class"""
# Note: This is a massive hack. # Note: This is a massive hack.
@ -48,7 +50,6 @@ class radio():
self.hostname = rigctld_ip self.hostname = rigctld_ip
self.port = int(rigctld_port) self.port = int(rigctld_port)
if self.connect(): if self.connect():
logging.debug(f"Rigctl intialized") logging.debug(f"Rigctl intialized")
return True return True
@ -75,7 +76,6 @@ class radio():
self.sock.close() self.sock.close()
self.connected = False self.connected = False
def send_command(self, command): def send_command(self, command):
"""Send a command to the connected rotctld instance, """Send a command to the connected rotctld instance,
and return the return value. and return the return value.
@ -104,7 +104,6 @@ class radio():
time.sleep(0.5) time.sleep(0.5)
self.connect() self.connect()
def get_mode(self): def get_mode(self):
""" """ """ """
try: try:
@ -114,6 +113,7 @@ class radio():
return mode.decode("utf-8") return mode.decode("utf-8")
except: except:
0 0
def get_bandwith(self): def get_bandwith(self):
""" """ """ """
try: try:

3
tnc/rigdummy.py
View file

@ -4,12 +4,12 @@ import structlog
hamlib_version = 0 hamlib_version = 0
class radio: class radio:
""" """ """ """
def __init__(self): def __init__(self):
pass pass
def open_rig(self, **kwargs): def open_rig(self, **kwargs):
""" """
@ -62,4 +62,3 @@ class radio:
def close_rig(self): def close_rig(self):
""" """ """ """
return return

35
tnc/sock.py
View file

@ -42,10 +42,6 @@ CONNECTED_CLIENTS = set()
CLOSE_SIGNAL = False CLOSE_SIGNAL = False
class ThreadedTCPServer(socketserver.ThreadingMixIn, socketserver.TCPServer): class ThreadedTCPServer(socketserver.ThreadingMixIn, socketserver.TCPServer):
""" """
the socket handler base class the socket handler base class
@ -53,11 +49,9 @@ class ThreadedTCPServer(socketserver.ThreadingMixIn, socketserver.TCPServer):
pass pass
class ThreadedTCPRequestHandler(socketserver.StreamRequestHandler): class ThreadedTCPRequestHandler(socketserver.StreamRequestHandler):
""" """ """ """
def send_to_client(self): def send_to_client(self):
""" """
function called by socket handler function called by socket handler
@ -66,10 +60,8 @@ class ThreadedTCPRequestHandler(socketserver.StreamRequestHandler):
""" """
tempdata = b'' tempdata = b''
while self.connection_alive and not CLOSE_SIGNAL: while self.connection_alive and not CLOSE_SIGNAL:
# send tnc state as network stream # send tnc state as network stream
# check server port against daemon port and send corresponding data # check server port against daemon port and send corresponding data
if self.server.server_address[1] == static.PORT and not static.TNCSTARTED: if self.server.server_address[1] == static.PORT and not static.TNCSTARTED:
data = send_tnc_state() data = send_tnc_state()
if data != tempdata: if data != tempdata:
@ -82,7 +74,6 @@ class ThreadedTCPRequestHandler(socketserver.StreamRequestHandler):
SOCKET_QUEUE.put(data) SOCKET_QUEUE.put(data)
time.sleep(0.5) time.sleep(0.5)
while not SOCKET_QUEUE.empty(): while not SOCKET_QUEUE.empty():
data = SOCKET_QUEUE.get() data = SOCKET_QUEUE.get()
sock_data = bytes(data, 'utf-8') sock_data = bytes(data, 'utf-8')
@ -120,7 +111,6 @@ class ThreadedTCPRequestHandler(socketserver.StreamRequestHandler):
#print("connection broken. Closing...") #print("connection broken. Closing...")
self.connection_alive = False self.connection_alive = False
if data.startswith(b'{') and data.endswith(b'}\n'): if data.startswith(b'{') and data.endswith(b'}\n'):
# split data by \n if we have multiple commands in socket buffer # split data by \n if we have multiple commands in socket buffer
data = data.split(b'\n') data = data.split(b'\n')
@ -141,19 +131,16 @@ class ThreadedTCPRequestHandler(socketserver.StreamRequestHandler):
# and which one can be processed during a running transmission # and which one can be processed during a running transmission
time.sleep(3) time.sleep(3)
# finally delete our rx buffer to be ready for new commands # finally delete our rx buffer to be ready for new commands
data = bytes() data = bytes()
except Exception as e: except Exception as e:
structlog.get_logger("structlog").info("[SCK] Connection closed", ip=self.client_address[0], port=self.client_address[1], e=e) structlog.get_logger("structlog").info("[SCK] Connection closed", ip=self.client_address[0], port=self.client_address[1], e=e)
self.connection_alive = False self.connection_alive = False
def handle(self): def handle(self):
""" """
socket handler socket handler
""" """
CONNECTED_CLIENTS.add(self.request) CONNECTED_CLIENTS.add(self.request)
structlog.get_logger("structlog").debug("[SCK] Client connected", ip=self.client_address[0], port=self.client_address[1]) structlog.get_logger("structlog").debug("[SCK] Client connected", ip=self.client_address[0], port=self.client_address[1])
@ -166,8 +153,6 @@ class ThreadedTCPRequestHandler(socketserver.StreamRequestHandler):
while self.connection_alive and not CLOSE_SIGNAL: while self.connection_alive and not CLOSE_SIGNAL:
time.sleep(1) time.sleep(1)
def finish(self): def finish(self):
""" """ """ """
structlog.get_logger("structlog").warning("[SCK] Closing client socket", ip=self.client_address[0], port=self.client_address[1]) structlog.get_logger("structlog").warning("[SCK] Closing client socket", ip=self.client_address[0], port=self.client_address[1])
@ -189,7 +174,6 @@ def process_tnc_commands(data):
""" """
# we need to do some error handling in case of socket timeout or decoding issue # we need to do some error handling in case of socket timeout or decoding issue
try: try:
# convert data to json object # convert data to json object
received_json = json.loads(data) received_json = json.loads(data)
structlog.get_logger("structlog").debug("[SCK] CMD", command=received_json) structlog.get_logger("structlog").debug("[SCK] CMD", command=received_json)
@ -203,7 +187,6 @@ def process_tnc_commands(data):
command_response("tx_audio_level", False) command_response("tx_audio_level", False)
structlog.get_logger("structlog").warning("[SCK] command execution error", e=e, command=received_json) structlog.get_logger("structlog").warning("[SCK] command execution error", e=e, command=received_json)
# TRANSMIT SINE WAVE ----------------------------------------------------- # TRANSMIT SINE WAVE -----------------------------------------------------
if received_json["type"] == "set" and received_json["command"] == "send_test_frame": if received_json["type"] == "set" and received_json["command"] == "send_test_frame":
try: try:
@ -222,6 +205,7 @@ def process_tnc_commands(data):
except Exception as e: except Exception as e:
command_response("cqcqcq", False) command_response("cqcqcq", False)
structlog.get_logger("structlog").warning("[SCK] command execution error", e=e, command=received_json) structlog.get_logger("structlog").warning("[SCK] command execution error", e=e, command=received_json)
# START_BEACON ----------------------------------------------------- # START_BEACON -----------------------------------------------------
if received_json["command"] == "start_beacon": if received_json["command"] == "start_beacon":
try: try:
@ -262,7 +246,6 @@ def process_tnc_commands(data):
command_response("ping", False) command_response("ping", False)
structlog.get_logger("structlog").warning("[SCK] command execution error", e=e, command=received_json) structlog.get_logger("structlog").warning("[SCK] command execution error", e=e, command=received_json)
# CONNECT ---------------------------------------------------------- # CONNECT ----------------------------------------------------------
if received_json["type"] == 'arq' and received_json["command"] == "connect": if received_json["type"] == 'arq' and received_json["command"] == "connect":
static.BEACON_PAUSE = True static.BEACON_PAUSE = True
@ -297,7 +280,6 @@ def process_tnc_commands(data):
# TRANSMIT RAW DATA ------------------------------------------- # TRANSMIT RAW DATA -------------------------------------------
if received_json["type"] == 'arq' and received_json["command"] == "send_raw": if received_json["type"] == 'arq' and received_json["command"] == "send_raw":
static.BEACON_PAUSE = True static.BEACON_PAUSE = True
try: try:
if not static.ARQ_SESSION: if not static.ARQ_SESSION:
@ -314,7 +296,6 @@ def process_tnc_commands(data):
dxcallsign = static.DXCALLSIGN dxcallsign = static.DXCALLSIGN
static.DXCALLSIGN_CRC = helpers.get_crc_24(static.DXCALLSIGN) static.DXCALLSIGN_CRC = helpers.get_crc_24(static.DXCALLSIGN)
mode = int(received_json["parameter"][0]["mode"]) mode = int(received_json["parameter"][0]["mode"])
n_frames = int(received_json["parameter"][0]["n_frames"]) n_frames = int(received_json["parameter"][0]["n_frames"])
base64data = received_json["parameter"][0]["data"] base64data = received_json["parameter"][0]["data"]
@ -335,15 +316,13 @@ def process_tnc_commands(data):
binarydata = base64.b64decode(base64data) binarydata = base64.b64decode(base64data)
data_handler.DATA_QUEUE_TRANSMIT.put(['ARQ_RAW', binarydata, mode, n_frames, arq_uuid, mycallsign]) data_handler.DATA_QUEUE_TRANSMIT.put(['ARQ_RAW', binarydata, mode, n_frames, arq_uuid, mycallsign])
else: else:
raise TypeError raise TypeError
except Exception as e: except Exception as e:
command_response("send_raw", False) command_response("send_raw", False)
structlog.get_logger("structlog").warning("[SCK] command execution error", e=e, command=received_json) structlog.get_logger("structlog").warning("[SCK] command execution error", e=e, command=received_json)
# STOP TRANSMISSION ---------------------------------------------------------- # STOP TRANSMISSION ----------------------------------------------------------
if received_json["type"] == 'arq' and received_json["command"] == "stop_transmission": if received_json["type"] == 'arq' and received_json["command"] == "stop_transmission":
try: try:
@ -357,7 +336,6 @@ def process_tnc_commands(data):
command_response("stop_transmission", False) command_response("stop_transmission", False)
structlog.get_logger("structlog").warning("[SCK] command execution error", e=e, command=received_json) structlog.get_logger("structlog").warning("[SCK] command execution error", e=e, command=received_json)
if received_json["type"] == 'get' and received_json["command"] == 'rx_buffer': if received_json["type"] == 'get' and received_json["command"] == 'rx_buffer':
try: try:
output = { output = {
@ -380,7 +358,6 @@ def process_tnc_commands(data):
command_response("rx_buffer", False) command_response("rx_buffer", False)
structlog.get_logger("structlog").warning("[SCK] command execution error", e=e, command=received_json) structlog.get_logger("structlog").warning("[SCK] command execution error", e=e, command=received_json)
if received_json["type"] == 'set' and received_json["command"] == 'del_rx_buffer': if received_json["type"] == 'set' and received_json["command"] == 'del_rx_buffer':
try: try:
static.RX_BUFFER = [] static.RX_BUFFER = []
@ -397,7 +374,6 @@ def send_tnc_state():
""" """
send the tnc state to network send the tnc state to network
""" """
encoding = 'utf-8' encoding = 'utf-8'
output = { output = {
@ -438,7 +414,6 @@ def send_tnc_state():
jsondata = json.dumps(output) jsondata = json.dumps(output)
return jsondata return jsondata
def process_daemon_commands(data): def process_daemon_commands(data):
""" """
process daemon commands process daemon commands
@ -469,7 +444,6 @@ def process_daemon_commands(data):
command_response("mycallsign", False) command_response("mycallsign", False)
structlog.get_logger("structlog").warning("[SCK] command execution error", e=e, command=received_json) structlog.get_logger("structlog").warning("[SCK] command execution error", e=e, command=received_json)
if received_json["type"] == 'set' and received_json["command"] == 'mygrid': if received_json["type"] == 'set' and received_json["command"] == 'mygrid':
try: try:
mygrid = received_json["parameter"] mygrid = received_json["parameter"]
@ -484,9 +458,7 @@ def process_daemon_commands(data):
command_response("mygrid", False) command_response("mygrid", False)
structlog.get_logger("structlog").warning("[SCK] command execution error", e=e, command=received_json) structlog.get_logger("structlog").warning("[SCK] command execution error", e=e, command=received_json)
if received_json["type"] == 'set' and received_json["command"] == 'start_tnc' and not static.TNCSTARTED: if received_json["type"] == 'set' and received_json["command"] == 'start_tnc' and not static.TNCSTARTED:
try: try:
mycall = str(received_json["parameter"][0]["mycall"]) mycall = str(received_json["parameter"][0]["mycall"])
mygrid = str(received_json["parameter"][0]["mygrid"]) mygrid = str(received_json["parameter"][0]["mygrid"])
@ -512,7 +484,6 @@ def process_daemon_commands(data):
tx_audio_level = str(received_json["parameter"][0]["tx_audio_level"]) tx_audio_level = str(received_json["parameter"][0]["tx_audio_level"])
respond_to_cq = str(received_json["parameter"][0]["respond_to_cq"]) respond_to_cq = str(received_json["parameter"][0]["respond_to_cq"])
# print some debugging parameters # print some debugging parameters
for item in received_json["parameter"][0]: for item in received_json["parameter"][0]:
structlog.get_logger("structlog").debug("[DMN] TNC Startup Config : " + item, value=received_json["parameter"][0][item]) structlog.get_logger("structlog").debug("[DMN] TNC Startup Config : " + item, value=received_json["parameter"][0][item])
@ -549,7 +520,6 @@ def process_daemon_commands(data):
structlog.get_logger("structlog").warning("[SCK] command execution error", e=e, command=received_json) structlog.get_logger("structlog").warning("[SCK] command execution error", e=e, command=received_json)
if received_json["type"] == 'get' and received_json["command"] == 'test_hamlib': if received_json["type"] == 'get' and received_json["command"] == 'test_hamlib':
try: try:
devicename = str(received_json["parameter"][0]["devicename"]) devicename = str(received_json["parameter"][0]["devicename"])
deviceport = str(received_json["parameter"][0]["deviceport"]) deviceport = str(received_json["parameter"][0]["deviceport"])
@ -619,7 +589,6 @@ def send_daemon_state():
else: else:
output["daemon_state"].append({"status": "stopped"}) output["daemon_state"].append({"status": "stopped"})
jsondata = json.dumps(output) jsondata = json.dumps(output)
return jsondata return jsondata

3
tnc/static.py
View file

@ -15,7 +15,6 @@ DAEMONPORT = 3001
TNCSTARTED = False TNCSTARTED = False
TNCPROCESS = 0 TNCPROCESS = 0
# Operator Defaults # Operator Defaults
MYCALLSIGN = b'AA0AA' MYCALLSIGN = b'AA0AA'
MYCALLSIGN_CRC = b'A' MYCALLSIGN_CRC = b'A'
@ -39,7 +38,6 @@ SOCKET_TIMEOUT = 1 # seconds
SERIAL_DEVICES = [] SERIAL_DEVICES = []
# --------------------------------- # ---------------------------------
PTT_STATE = False PTT_STATE = False
TRANSMITTING = False TRANSMITTING = False
@ -96,7 +94,6 @@ ARQ_TRANSMISSION_PERCENT = 0
ARQ_SPEED_LEVEL = 0 ARQ_SPEED_LEVEL = 0
TOTAL_BYTES = 0 TOTAL_BYTES = 0
#CHANNEL_STATE = 'RECEIVING_SIGNALLING' #CHANNEL_STATE = 'RECEIVING_SIGNALLING'
TNC_STATE = 'IDLE' TNC_STATE = 'IDLE'
ARQ_STATE = False ARQ_STATE = False