diff --git a/test/README.md b/test/README.md
index 8f6f0607..222bf424 100644
--- a/test/README.md
+++ b/test/README.md
@@ -1,3 +1,34 @@
+
+# Instructions
+
+1. Install:
+ ```
+ cd FreeDATA
+ mkdir build
+ cd build
+ cmake -DCODEC2_BUILD_DIR=$HOME/codec2/build_linux ..
+ ```
+2. List available tests:
+ ```
+ ctest -N
+ Test project /home/david/FreeDATA/build
+ Test #1: 000_audio_tests
+ Test #2: 001_highsnr_stdio_audio
+
+ Total Tests: 2
+ ```
+3. Run tests:
+ ```
+ ctest --output-on-failure
+ ```
+4. Run tests verbosely:
+ ```
+ ctest -V
+ ```
+
+
+
+
# 001_HIGHSNR_STDIO_AUDIO TEST SUITE
1. Install
diff --git a/test/test_arq_short.py b/test/test_arq_short.py
new file mode 100644
index 00000000..96b8c845
--- /dev/null
+++ b/test/test_arq_short.py
@@ -0,0 +1,28 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created on Wed Dec 23 07:04:24 2020
+
+@author: DJ2LS
+"""
+
+import sys
+sys.path.insert(0,'..')
+sys.path.insert(0,'../tnc')
+import data_handler
+import argparse
+import codec2
+
+parser = argparse.ArgumentParser(description='ARQ TEST')
+parser.add_argument('--mode', dest="FREEDV_MODE", type=str, choices=['datac0', 'datac1', 'datac3'])
+parser.add_argument('--framesperburst', dest="N_FRAMES_PER_BURST", default=1, type=int)
+args = parser.parse_args()
+
+
+bytes_out = b'{"dt":"f","fn":"zeit.txt","ft":"text\\/plain","d":"data:text\\/plain;base64,MyBtb2Rlcywgb2huZSBjbGFzcwowLjAwMDk2OTQ4MTE4MDk5MTg0MTcKCjIgbW9kZXMsIG9obmUgY2xhc3MKMC4wMDA5NjY1NDUxODkxMjI1Mzk0CgoxIG1vZGUsIG9obmUgY2xhc3MKMC4wMDA5NjY5NzY1NTU4Nzc4MjA5CgMyBtb2Rlcywgb2huZSBjbGFzcwowLjAwMDk2OTQ4MTE4MDk5MTg0MTcKCjIgbW9kZXMsIG9obmUgY2xhc3MKMC4wMDA5NjY1NDUxODkxMjI1Mzk0CgoxIG1vZGUsIG9obmUgY2xhc3MKMC4wMDA5NjY5NzY1NTU4Nzc4MjA5Cg=MyBtb2Rlcywgb2huZSBjbGFzcwowLjAwMDk2OTQ4MTE4MDk5MTg0MTcKCjIgbW9kZXMsIG9obmUgY2xhc3MKMC4wMDA5NjY1NDUxODkxMjI1Mzk0CgoxIG1vZGUsIG9obmUgY2xhc3MKMC4wMDA5NjY5NzY1NTU4Nzc4MjA5CgMyBtb2Rlcywgb2huZSBjbGFzcwowLjAwMDk2OTQ4MTE4MDk5MTg0MTcKCjIgbW9kZXMsIG9obmUgY2xhc3MKMC4wMDA5NjY1NDUxODkxMjI1Mzk0CgoxIG1vZGUsIG9obmUgY2xhc3MKMC4wMDA5NjY5NzY1NTU4Nzc4MjA5CgMyBtb2Rlcywgb2huZSBjbGFzcwowLjAwMDk2OTQ4MTE4MDk5MTg0MTcKCjIgbW9kZXMsIG9obmUgY2xhc3MKMC4wMDA5NjY1NDUxODkxMjI1Mzk0CgoxIG1vZGUsIG9obmUgY2xhc3MKMC4wMDA5NjY5NzY1NTU4Nzc4MjA5Cg=","crc":"123123123"}'
+
+mode = codec2.freedv_get_mode(args.FREEDV_MODE)
+n_frames_per_burst = args.N_FRAMES_PER_BURST
+
+data_handler.TESTMODE = True
+data_handler.open_dc_and_transmit(bytes_out, mode, n_frames_per_burst)
diff --git a/test/test_arq_tx.py b/test/test_arq_tx.py
deleted file mode 100644
index 4554282e..00000000
--- a/test/test_arq_tx.py
+++ /dev/null
@@ -1,22 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-"""
-Created on Wed Dec 23 07:04:24 2020
-
-@author: DJ2LS
-"""
-
-import sys
-sys.path.insert(0,'..')
-sys.path.insert(0,'../tnc')
-import data_handler
-
-
-teststring = b'HELLO WORLD'
-
-data_handler.arq_transmit(teststring, 10, 1)
-
-
-
-
-
diff --git a/tnc/data_handler.py b/tnc/data_handler.py
index 75acaf71..c0b1f8dc 100644
--- a/tnc/data_handler.py
+++ b/tnc/data_handler.py
@@ -11,18 +11,20 @@ import threading
import time
from random import randrange
import asyncio
-
+import zlib
import ujson as json
import static
import modem
import helpers
+import codec2
modem = modem.RF()
+
'''
Author: DJ2LS
Description:
data_handler is a module like file, which handles all the ARQ related parts.
-Because of the fact, that we need to use it from both directions,
+Because of the fact, that we need to use it from both directions - circular import,
socket.py and modem.py ( TX and RX ), I was not able, to move it to a class system, yet.
Global variables are needed, because we need to save our ack state for example, which needs to
be accessable by several functions.
@@ -35,12 +37,14 @@ and moving them to module wide globals
'''
+TESTMODE = False
+
+
# MODULE GLOBALS
-DATA_CHANNEL_READY_FOR_DATA = False # Indicator if we are ready for sending or receiving data
DATA_CHANNEL_LAST_RECEIVED = 0.0 # time of last "live sign" of a frame
-DATA_CHANNEL_MODE = 0 # mode for data channel
+BURST_ACK_SNR = 0 # SNR from received ack frames
BURST_ACK_RECEIVED = False # if we received an acknowledge frame for a burst
DATA_FRAME_ACK_RECEIVED = False # if we received an acknowledge frame for a data frame
RPT_REQUEST_RECEIVED = False # if we received an request for repeater frames
@@ -48,535 +52,394 @@ RPT_REQUEST_BUFFER = [] # requested frames, saved in a l
RX_START_OF_TRANSMISSION = 0 # time of transmission start
-# ################################################
-# ARQ DATA HANDLER
-# ################################################
+DATA_FRAME_BOF = b'BOF'#b'\xAA\xAA' # 2 bytes for the BOF End of File indicator in a data frame
+DATA_FRAME_EOF = b'EOF'#b'\xFF\xFF' # 2 bytes for the EOF End of File indicator in a data frame
-def arq_data_received(data_in, bytes_per_frame):
+def arq_data_received(data_in:bytes, bytes_per_frame:int, snr:int, freedv):
+ data_in = bytes(data_in)
+
# we neeed to declare our global variables, so the thread has access to them
global RX_START_OF_TRANSMISSION
global DATA_CHANNEL_LAST_RECEIVED
- global DATA_CHANNEL_READY_FOR_DATA
-
+ global DATA_FRAME_BOF
+ global DATA_FRAME_EOF
+ global TESTMODE
# only process data if we are in ARQ and BUSY state else return to quit
- if static.ARQ_STATE != 'DATA' and static.TNC_STATE != 'BUSY':
+ if not static.ARQ_STATE and static.TNC_STATE != 'BUSY':
return
# these vars will be overwritten during processing data
RX_FRAME_BOF_RECEIVED = False # here we save, if we received a "beginn of (data)frame"
RX_FRAME_EOF_RECEIVED = False # here we save, if we received a "end of (data)frame"
- DATA_FRAME_BOF = b'\xAA\xAA' # 2 bytes for the BOF End of File indicator in a data frame
- DATA_FRAME_EOF = b'\xFF\xFF' # 2 bytes for the EOF End of File indicator in a data frame
-
RX_PAYLOAD_PER_MODEM_FRAME = bytes_per_frame - 2 # payload per moden frame
- RX_PAYLOAD_PER_ARQ_FRAME = RX_PAYLOAD_PER_MODEM_FRAME - 8 # payload per arq frame
static.TNC_STATE = 'BUSY'
- static.ARQ_STATE = 'DATA'
+ static.ARQ_STATE = True
+ static.INFO.append("ARQ;RECEIVING")
DATA_CHANNEL_LAST_RECEIVED = int(time.time())
# get some important data from the 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_FRAME_OF_DATA_FRAME = int.from_bytes(bytes(data_in[2:4]), "big") # get current number of total frames
- RX_N_FRAMES_PER_DATA_FRAME = int.from_bytes(bytes(data_in[4:6]), "big") # get total number of frames
- static.TOTAL_BYTES = RX_N_FRAMES_PER_DATA_FRAME * RX_PAYLOAD_PER_ARQ_FRAME # calculate total bytes
-
- ##arq_percent_burst = int((RX_N_FRAME_OF_BURST / RX_N_FRAMES_PER_BURST) * 100)
- #arq_percent_frame = int(((RX_N_FRAME_OF_DATA_FRAME) / RX_N_FRAMES_PER_DATA_FRAME) * 100)
- calculate_transfer_rate_rx(RX_N_FRAMES_PER_DATA_FRAME, RX_N_FRAME_OF_DATA_FRAME, RX_START_OF_TRANSMISSION, RX_PAYLOAD_PER_ARQ_FRAME)
- static.INFO.append("ARQ;RECEIVING")
+
+ print(f"RX_N_FRAME_OF_BURST-{RX_N_FRAME_OF_BURST}")
+ print(f"RX_N_FRAMES_PER_BURST-{RX_N_FRAMES_PER_BURST}")
+
+ '''
+ 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
+ '''
+ if len(static.RX_BURST_BUFFER) != RX_N_FRAMES_PER_BURST:
+ static.RX_BURST_BUFFER = [None] * RX_N_FRAMES_PER_BURST
+
+ # append data to rx burst buffer
+ static.RX_BURST_BUFFER[RX_N_FRAME_OF_BURST] = data_in[4:]
- frame_progress = str(RX_N_FRAME_OF_BURST) + "/" + str(RX_N_FRAMES_PER_BURST)
- total_frame_progress = str(RX_N_FRAME_OF_DATA_FRAME) + "/" + str(RX_N_FRAMES_PER_DATA_FRAME)
- transmission_percent = str(static.ARQ_TRANSMISSION_PERCENT).zfill(3)
- structlog.get_logger("structlog").info("[TNC] ARQ | RX | DATA FRAME", mode=DATA_CHANNEL_MODE, frames=frame_progress, percent=transmission_percent, frames_total=total_frame_progress)
+ structlog.get_logger("structlog").debug("[TNC] static.RX_BURST_BUFFER", buffer=static.RX_BURST_BUFFER)
+ '''
+ check if we received all frames per burst by checking if burst buffer has no more "Nones"
+ this is the ideal case because we received all data
+ '''
+ if not None in static.RX_BURST_BUFFER:
+ # then iterate through burst buffer and append data to frame buffer
+ for i in range(0,len(static.RX_BURST_BUFFER)):
+ static.RX_FRAME_BUFFER += static.RX_BURST_BUFFER[i]
+ # then delete burst buffer
+ static.RX_BURST_BUFFER = []
+
+ # lets check if we didnt receive a BOF and EOF yet to avoid sending ack frames if we already received all data
+ if not RX_FRAME_BOF_RECEIVED and not RX_FRAME_EOF_RECEIVED and data_in.find(DATA_FRAME_EOF) < 0:
+
+ # create an ack frame
+ ack_frame = bytearray(14)
+ ack_frame[:1] = bytes([60])
+ ack_frame[1:2] = static.DXCALLSIGN_CRC8
+ ack_frame[2:3] = static.MYCALLSIGN_CRC8
+ ack_frame[3:4] = bytes([int(snr)])
+ # and transmit it
+ txbuffer = [ack_frame]
+ structlog.get_logger("structlog").info("[TNC] ARQ | RX | ACK")
+ modem.transmit(mode=14, repeats=1, repeat_delay=0, frames=txbuffer)
+
+ calculate_transfer_rate_rx(RX_START_OF_TRANSMISSION, len(static.RX_FRAME_BUFFER))
+
- # allocate ARQ_static.RX_FRAME_BUFFER as a list with "None" if not already done. This should be done only once per burst!
- # here we will save the N frame of a data frame to N list position so we can explicit search for it
-
- # delete frame buffer if first frame to make sure the buffer is cleared and no junks of a old frame is remaining
- # normally this shouldn't appear, since we are doing a buffer cleanup after every frame processing
- # but better doing this, to avoid problems caused by old chunks in data
- if RX_N_FRAME_OF_DATA_FRAME == 1:
- static.RX_FRAME_BUFFER = []
-
- #try appending data to frame buffer
- try:
- static.RX_FRAME_BUFFER[RX_N_FRAME_OF_DATA_FRAME] = bytes(data_in)
+ # check if we received last frame of burst and we have "Nones" in our rx buffer
+ # 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
+ # burst is lost
+ elif RX_N_FRAME_OF_BURST == RX_N_FRAMES_PER_BURST -1:
+ # check where a None is in our burst buffer and do frame+1, beacuse lists start at 0
+ missing_frames = [(frame+1) for frame, element in enumerate(static.RX_BURST_BUFFER) if element == None]
- except IndexError:
- # we are receiving new data, so we are doing a cleanup first
- static.RX_FRAME_BUFFER = []
-
- # set the start of transmission - 7 seconds,
- # which is more or less the transfer time for the first frame
- RX_START_OF_TRANSMISSION = time.time() - 6
-
- for i in range(0, RX_N_FRAMES_PER_DATA_FRAME + 1):
- static.RX_FRAME_BUFFER.insert(i, None)
-
- static.RX_FRAME_BUFFER[RX_N_FRAME_OF_DATA_FRAME] = bytes(data_in)
+ structlog.get_logger("structlog").debug("all frames per burst received", frame=RX_N_FRAME_OF_BURST, frames=RX_N_FRAMES_PER_BURST)
+
+ # set n frames per burst to modem
+ # this is an idea so its not getting lost....
+ # we need to work on this
+ codec2.api.freedv_set_frames_per_burst(freedv,len(missing_frames))
- # try appending data to burst buffer
- try:
- static.RX_BURST_BUFFER[RX_N_FRAME_OF_BURST] = bytes(data_in)
- except IndexError:
-
- static.RX_BURST_BUFFER = []
-
- for i in range(0, RX_N_FRAMES_PER_BURST + 1):
- static.RX_BURST_BUFFER.insert(i, None)
-
- static.RX_BURST_BUFFER[RX_N_FRAME_OF_BURST] = bytes(data_in)
-
-# - ------------------------- ARQ BURST CHECKER
- # run only if we recieved all ARQ FRAMES per ARQ BURST
- # and we didnt receive the last burst of a data frame
- # if we received the last burst of a data frame, we can directly send a frame ack to
- # improve transfer rate
- if static.RX_BURST_BUFFER.count(None) == 1 and RX_N_FRAMES_PER_DATA_FRAME != RX_N_FRAME_OF_DATA_FRAME : # count nones
- structlog.get_logger("structlog").info("[TNC] ARQ | RX | SENDING BURST ACK")
-
- # BUILDING ACK FRAME FOR BURST -----------------------------------------------
- ack_frame = bytearray(14)
- ack_frame[:1] = bytes([60])
- ack_frame[1:2] = static.DXCALLSIGN_CRC8
- ack_frame[2:3] = static.MYCALLSIGN_CRC8
-
- txbuffer = [ack_frame]
- modem.transmit(mode=14, repeats=1, repeat_delay=0, frames=txbuffer)
-
- # clear burst buffer
- static.RX_BURST_BUFFER = []
-
- # if decoded N frames are unequal to expected frames per burst
- elif RX_N_FRAME_OF_BURST == RX_N_FRAMES_PER_BURST and static.RX_BURST_BUFFER.count(None) != 1:
-
- # --------------- CHECK WHICH BURST FRAMES WE ARE MISSING -------------------------------------------
- missing_frames = b''
- for burstnumber in range(1, len(static.RX_BURST_BUFFER)):
-
- if static.RX_BURST_BUFFER[burstnumber] == None:
- logging.debug("RX_N_FRAME_OF_DATA_FRAME" + str(RX_N_FRAME_OF_DATA_FRAME))
- logging.debug("ARQ_N_RX_FRAMES_PER_BURSTS" + str(RX_N_FRAMES_PER_BURST))
-
- frame_number = burstnumber
- frame_number = frame_number.to_bytes(2, byteorder='big')
- missing_frames += frame_number
-
- structlog.get_logger("structlog").warning("[TNC] ARQ | RX | RPT FRAMES", snr=static.SNR, frames=missing_frames)
-
- # BUILDING RPT FRAME FOR BURST -----------------------------------------------
+ # then create a repeat frame
rpt_frame = bytearray(14)
rpt_frame[:1] = bytes([62])
rpt_frame[1:2] = static.DXCALLSIGN_CRC8
rpt_frame[2:3] = static.MYCALLSIGN_CRC8
rpt_frame[3:9] = missing_frames
- # TRANSMIT RPT FRAME FOR BURST-----------------------------------------------
+ # and transmit it
txbuffer = [rpt_frame]
+ structlog.get_logger("structlog").info("[TNC] ARQ | RX | Requesting", frames=missing_frames)
modem.transmit(mode=14, repeats=1, repeat_delay=0, frames=txbuffer)
+ calculate_transfer_rate_rx(RX_START_OF_TRANSMISSION, len(static.RX_FRAME_BUFFER))
+
+
+ # we should never reach this point
+ else:
+ 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.
+ # 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
+ bof_position = static.RX_FRAME_BUFFER.find(DATA_FRAME_BOF)
+ eof_position = static.RX_FRAME_BUFFER.find(DATA_FRAME_EOF)
+ 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}")
+ RX_FRAME_BOF_RECEIVED = True
+ RX_FRAME_EOF_RECEIVED = True
- # ---------------------------- FRAME MACHINE
- # --------------- IF LIST NOT CONTAINS "None" stick everything together
- complete_data_frame = bytearray()
- if static.RX_FRAME_BUFFER.count(None) == 1: # 1 because position 0 of list will alaways be None in our case
- #logging.debug("DECODING FRAME!")
- for frame in range(1, len(static.RX_FRAME_BUFFER)):
- raw_arq_frame = static.RX_FRAME_BUFFER[frame]
- arq_frame_payload = raw_arq_frame[8:]
+ #now extract raw data from buffer
+ payload = static.RX_FRAME_BUFFER[bof_position+len(DATA_FRAME_BOF):eof_position]
+ # get the data frame crc
- # -------- DETECT IF WE RECEIVED A FRAME HEADER THEN SAVE DATA TO GLOBALS
- if arq_frame_payload[2:4].startswith(DATA_FRAME_BOF):
- data_frame_crc = arq_frame_payload[:2]
- RX_FRAME_BOF_RECEIVED = True
+ data_frame_crc = payload[:2]
+ data_frame = payload[2:]
- arq_frame_payload = arq_frame_payload.split(DATA_FRAME_BOF)
- arq_frame_payload = arq_frame_payload[1]
- #logging.debug("BOF")
-
-
- # -------- DETECT IF WE RECEIVED A FRAME FOOTER THEN SAVE DATA TO GLOBALS
- # we need to check for at least one xFF. Sometimes we have only one xFF, because the second one is in the next frame
- if arq_frame_payload.rstrip(b'\x00').endswith(DATA_FRAME_EOF) or arq_frame_payload.rstrip(b'\x00').endswith(DATA_FRAME_EOF[:-1]):
- RX_FRAME_EOF_RECEIVED = True
- if arq_frame_payload.rstrip(b'\x00').endswith(DATA_FRAME_EOF[:-1]):
- arq_frame_payload = arq_frame_payload.split(DATA_FRAME_EOF[:-1])
- arq_frame_payload = arq_frame_payload[0]
- else:
- arq_frame_payload = arq_frame_payload.split(DATA_FRAME_EOF)
- arq_frame_payload = arq_frame_payload[0]
- #logging.debug("EOF")
-
- # --------- AFTER WE SEPARATED BOF AND EOF, STICK EVERYTHING TOGETHER
- complete_data_frame = complete_data_frame + arq_frame_payload
- logging.debug(complete_data_frame)
-
- # check if Begin of Frame BOF and End of Frame EOF are received, then start calculating CRC and sticking everything together
- if RX_FRAME_BOF_RECEIVED and RX_FRAME_EOF_RECEIVED:
-
- frame_payload_crc = helpers.get_crc_16(complete_data_frame)
-
- # IF THE FRAME PAYLOAD CRC IS EQUAL TO THE FRAME CRC WHICH IS KNOWN FROM THE HEADER --> SUCCESS
- if frame_payload_crc == data_frame_crc:
- static.INFO.append("ARQ;RECEIVING;SUCCESS")
+ data_frame_crc_received = helpers.get_crc_16(data_frame)
+ # check if data_frame_crc is equal with received crc
+ if data_frame_crc == data_frame_crc_received:
structlog.get_logger("structlog").info("[TNC] ARQ | RX | DATA FRAME SUCESSFULLY RECEIVED")
- calculate_transfer_rate_rx(RX_N_FRAMES_PER_DATA_FRAME, RX_N_FRAME_OF_DATA_FRAME, RX_START_OF_TRANSMISSION, RX_PAYLOAD_PER_ARQ_FRAME)
+ static.INFO.append("ARQ;RECEIVING;SUCCESS")
+ # decompression
+ data_frame_decompressed = zlib.decompress(data_frame)
+ static.ARQ_COMPRESSION_FACTOR = len(data_frame_decompressed) / len(data_frame)
+ data_frame = data_frame_decompressed
# decode to utf-8 string
- complete_data_frame = complete_data_frame.decode("utf-8")
+ data_frame = data_frame.decode("utf-8")
# decode json objects from data frame to inspect if we received a file or message
- rawdata = json.loads(complete_data_frame)
-
- # if datatype is a file, we append to RX_BUFFER, which contains files only
- # dt = datatype
- # --> f = file
- # --> m = message
- # fn = filename
- # ft = filetype
- # d = data
- # crc = checksum
+ rawdata = json.loads(data_frame)
+ '''
+ if datatype is a file, we append to RX_BUFFER, which contains files only
+ dt = datatype
+ --> f = file
+ --> m = message
+ fn = filename
+ ft = filetype
+ d = data
+ crc = checksum
+ '''
if rawdata["dt"] == "f":
- #logging.debug("RECEIVED FILE --> MOVING DATA TO RX BUFFER")
- static.RX_BUFFER.append([static.DXCALLSIGN,static.DXGRID,int(time.time()), complete_data_frame])
+ #structlog.get_logger("structlog").debug("RECEIVED FILE --> MOVING DATA TO RX BUFFER")
+ static.RX_BUFFER.append([static.DXCALLSIGN,static.DXGRID,int(time.time()), data_frame])
# if datatype is a file, we append to RX_MSG_BUFFER, which contains messages only
if rawdata["dt"] == "m":
static.RX_MSG_BUFFER.append([static.DXCALLSIGN,static.DXGRID,int(time.time()), complete_data_frame])
- #logging.debug("RECEIVED MESSAGE --> MOVING DATA TO MESSAGE BUFFER")
+ #structlog.get_logger("structlog").debug("RECEIVED MESSAGE --> MOVING DATA TO MESSAGE BUFFER")
- # BUILDING ACK FRAME FOR DATA FRAME -----------------------------------------------
+
+ # BUILDING ACK FRAME FOR DATA FRAME
ack_frame = bytearray(14)
ack_frame[:1] = bytes([61])
ack_frame[1:2] = static.DXCALLSIGN_CRC8
ack_frame[2:3] = static.MYCALLSIGN_CRC8
- # TRANSMIT ACK FRAME FOR BURST-----------------------------------------------
+ # TRANSMIT ACK FRAME FOR BURST
structlog.get_logger("structlog").info("[TNC] ARQ | RX | SENDING DATA FRAME ACK", snr=static.SNR, crc=data_frame_crc.hex())
-
-
txbuffer = [ack_frame]
- modem.transmit(mode=14, repeats=2, repeat_delay=250, frames=txbuffer)
+ modem.transmit(mode=14, repeats=1, repeat_delay=0, frames=txbuffer)
+
+ # update our statistics AFTER the frame ACK
+ calculate_transfer_rate_rx(RX_START_OF_TRANSMISSION, len(static.RX_FRAME_BUFFER))
+
+ structlog.get_logger("structlog").info("[TNC] | RX | DATACHANNEL [" + str(static.MYCALLSIGN, 'utf-8') + "]<< >>[" + str(static.DXCALLSIGN, 'utf-8') + "]", snr=static.SNR)
- calculate_transfer_rate_rx(RX_N_FRAMES_PER_DATA_FRAME, RX_N_FRAME_OF_DATA_FRAME, RX_START_OF_TRANSMISSION, RX_PAYLOAD_PER_ARQ_FRAME)
-
- #arq_reset_frame_machine()
- static.TNC_STATE = 'IDLE'
- static.ARQ_STATE = 'IDLE'
- DATA_CHANNEL_READY_FOR_DATA = False
- static.RX_BURST_BUFFER = []
- static.RX_FRAME_BUFFER = []
-
- structlog.get_logger("structlog").info("[TNC] DATACHANNEL [" + str(static.MYCALLSIGN, 'utf-8') + "]<< >>[" + str(static.DXCALLSIGN, 'utf-8') + "]", snr=static.SNR)
else:
-
- structlog.get_logger("structlog").debug("[TNC] ARQ: ", ARQ_FRAME_BOF_RECEIVED=RX_FRAME_BOF_RECEIVED, ARQ_FRAME_EOF_RECEIVED=RX_FRAME_EOF_RECEIVED )
-
- calculate_transfer_rate_rx(RX_N_FRAMES_PER_DATA_FRAME, RX_N_FRAME_OF_DATA_FRAME, RX_START_OF_TRANSMISSION, RX_PAYLOAD_PER_ARQ_FRAME)
static.INFO.append("ARQ;RECEIVING;FAILED")
- structlog.get_logger("structlog").warning("[TNC] ARQ | RX | DATA FRAME NOT SUCESSFULLY RECEIVED!")
-
- # STATE CLEANUP
- #arq_reset_frame_machine()
- static.TNC_STATE = 'IDLE'
- static.ARQ_STATE = 'IDLE'
- DATA_CHANNEL_READY_FOR_DATA = False
- static.RX_BURST_BUFFER = []
- static.RX_FRAME_BUFFER = []
-
- structlog.get_logger("structlog").info("[TNC] DATACHANNEL [" + str(static.MYCALLSIGN, 'utf-8') + "]<
>[" + str(static.DXCALLSIGN, 'utf-8') + "]", snr=static.SNR)
-
+ structlog.get_logger("structlog").warning("[TNC] ARQ | RX | DATA FRAME NOT SUCESSFULLY RECEIVED!", e="wrong crc", expected=data_frame_crc, received=data_frame_crc_received)
-def arq_transmit(data_out, mode, n_frames_per_burst):
+ # BUILDING NACK FRAME FOR DATA FRAME
+ nack_frame = bytearray(14)
+ nack_frame[:1] = bytes([63])
+ nack_frame[1:2] = static.DXCALLSIGN_CRC8
+ nack_frame[2:3] = static.MYCALLSIGN_CRC8
+
+ # TRANSMIT NACK FRAME FOR BURST
+ txbuffer = [nack_frame]
+ modem.transmit(mode=14, repeats=1, repeat_delay=0, frames=txbuffer)
+
+ # And finally we do a cleanup of our buffers and states
+ # do cleanup only when not in testmode
+ if not TESTMODE:
+ arq_cleanup()
+
+
+
+def arq_transmit(data_out:bytes, mode:int, n_frames_per_burst:int):
global RPT_REQUEST_BUFFER
global DATA_FRAME_ACK_RECEIVED
global RPT_REQUEST_RECEIVED
global BURST_ACK_RECEIVED
+ global BURST_ACK_SNR
#global TX_START_OF_TRANSMISSION
- global DATA_CHANNEL_READY_FOR_DATA
-
- DATA_CHANNEL_MODE = mode
-
- DATA_FRAME_BOF = b'\xAA\xAA' # 2 bytes for the BOF End of File indicator in a data frame
- DATA_FRAME_EOF = b'\xFF\xFF' # 2 bytes for the EOF End of File indicator in a data frame
+ global DATA_FRAME_BOF
+ global DATA_FRAME_EOF
+ global TESTMODE
- TX_N_SENT_FRAMES = 0 # already sent frames per data frame
+ TX_N_SENT_BYTES = 0 # already sent bytes per data frame
TX_N_RETRIES_PER_BURST = 0 # retries we already sent data
TX_N_MAX_RETRIES_PER_BURST = 5 # max amount of retries we sent before frame is lost
TX_N_FRAMES_PER_BURST = n_frames_per_burst # amount of n frames per burst
TX_BUFFER = [] # our buffer for appending new data
# TIMEOUTS
- BURST_ACK_TIMEOUT_SECONDS = 10.0 # timeout for burst acknowledges
- DATA_FRAME_ACK_TIMEOUT_SECONDS = 10.0 # timeout for data frame acknowledges
- RPT_ACK_TIMEOUT_SECONDS = 10.0 # timeout for rpt frame acknowledges
+ BURST_ACK_TIMEOUT_SECONDS = 3.0 # timeout for burst acknowledges
+ DATA_FRAME_ACK_TIMEOUT_SECONDS = 3.0 # timeout for data frame acknowledges
+ RPT_ACK_TIMEOUT_SECONDS = 3.0 # timeout for rpt frame acknowledges
- # we need to set payload per frame manually at this point. maybe we can do this more dynmic.
- if DATA_CHANNEL_MODE == 10:
- payload_per_frame = 512 - 2
- #elif DATA_CHANNEL_MODE == 11:
- # payload_per_frame = 258 - 2
- elif DATA_CHANNEL_MODE == 12:
- payload_per_frame = 128 - 2
- elif DATA_CHANNEL_MODE == 14:
- payload_per_frame = 16 - 2
- else:
- payload_per_frame = 16 - 2
-
+ # save len of data_out to TOTAL_BYTES for our statistics --> kBytes
+ static.TOTAL_BYTES = round(len(data_out) / 1024, 2)
+
- TX_START_OF_TRANSMISSION = time.time()
-
- TX_PAYLOAD_PER_ARQ_FRAME = payload_per_frame - 8
- frame_header_length = 6
-
- frame_payload_crc = helpers.get_crc_16(data_out)
-
- # This is the total frame with frame header, which will be send
- data_out = frame_payload_crc + DATA_FRAME_BOF + data_out + DATA_FRAME_EOF
- # 2 2 N 2
- # save len of data_out to TOTAL_BYTES for our statistics
- static.TOTAL_BYTES = len(data_out)
- # --------------------------------------------- LETS CREATE A BUFFER BY SPLITTING THE FILES INTO PEACES
- # https://newbedev.com/how-to-split-a-byte-string-into-separate-bytes-in-python
- TX_BUFFER = [data_out[i:i + TX_PAYLOAD_PER_ARQ_FRAME] for i in range(0, len(data_out), TX_PAYLOAD_PER_ARQ_FRAME)]
- TX_BUFFER_SIZE = len(TX_BUFFER)
static.INFO.append("ARQ;TRANSMITTING")
+ structlog.get_logger("structlog").info("[TNC] | TX | DATACHANNEL", mode=mode, kBytes=static.TOTAL_BYTES)
- structlog.get_logger("structlog").info("[TNC] DATACHANNEL", mode=DATA_CHANNEL_MODE, bytes=len(data_out), frames=TX_BUFFER_SIZE)
+ # compression
+ data_frame_compressed = zlib.compress(data_out)
+ static.ARQ_COMPRESSION_FACTOR = len(data_out) / len(data_frame_compressed)
+ data_out = data_frame_compressed
+
+ # reset statistics
+ tx_start_of_transmission = time.time()
+ calculate_transfer_rate_tx(tx_start_of_transmission, 0, len(data_out))
+
+ # append a crc and beginn and end of file indicators
+ frame_payload_crc = helpers.get_crc_16(data_out)
+ data_out = DATA_FRAME_BOF + frame_payload_crc + data_out + DATA_FRAME_EOF
- # ----------------------- THIS IS THE MAIN LOOP-----------------------------------------------------------------
- TX_N_SENT_FRAMES = 0 # SET N SENT FRAMES TO 0 FOR A NEW SENDING CYCLE
- while TX_N_SENT_FRAMES <= TX_BUFFER_SIZE and static.ARQ_STATE == 'DATA':
+ #initial bufferposition is 0
+ bufferposition = 0
- # ----------- CREATE FRAME TOTAL PAYLOAD TO BE ABLE TO CREATE CRC FOR IT
- try: # DETECT IF LAST BURST TO PREVENT INDEX ERROR OF BUFFER
+ # iterate through data out buffer
+ while bufferposition < len(data_out) and not DATA_FRAME_ACK_RECEIVED and static.ARQ_STATE:
- for i in range(TX_N_FRAMES_PER_BURST): # Loop through TX_BUFFER LIST
- len(TX_BUFFER[TX_N_SENT_FRAMES + i]) # we calculate the length to trigger a list index error
-
- except IndexError: # IF LAST BURST DETECTED BUILD CRC WITH LESS FRAMES AND SET TX_N_FRAMES_PER_BURST TO VALUE OF REST!
-
- if TX_N_SENT_FRAMES == 0 and (TX_N_FRAMES_PER_BURST > TX_BUFFER_SIZE): # WE CANT DO MODULO 0 > CHECK IF FIRST FRAME == LAST FRAME
- TX_N_FRAMES_PER_BURST = TX_BUFFER_SIZE
-
- elif TX_N_SENT_FRAMES == 1 and (TX_N_FRAMES_PER_BURST > TX_BUFFER_SIZE): # MODULO 1 WILL ALWAYS BE 0 --> THIS FIXES IT
- TX_N_FRAMES_PER_BURST = TX_BUFFER_SIZE - TX_N_SENT_FRAMES
-
- else:
- TX_N_FRAMES_PER_BURST = (TX_BUFFER_SIZE % TX_N_SENT_FRAMES)
-
- # --------------------------------------------- N ATTEMPTS TO SEND BURSTS IF ACK RECEPTION FAILS
- for TX_N_RETRIES_PER_BURST in range(TX_N_MAX_RETRIES_PER_BURST):
-
- if TX_N_SENT_FRAMES + 1 <= TX_BUFFER_SIZE:
- calculate_transfer_rate_tx(TX_N_SENT_FRAMES, TX_PAYLOAD_PER_ARQ_FRAME, TX_START_OF_TRANSMISSION, TX_BUFFER_SIZE)
-
- frame_progress = str(TX_N_SENT_FRAMES + 1) + "-" + str(TX_N_SENT_FRAMES + TX_N_FRAMES_PER_BURST)
- total_frame_progress = str(TX_N_SENT_FRAMES) + "/" + str(TX_BUFFER_SIZE)
- transmission_percent = str(static.ARQ_TRANSMISSION_PERCENT).zfill(3)
- transmission_attempts = str(TX_N_RETRIES_PER_BURST + 1) + "/" + str(TX_N_MAX_RETRIES_PER_BURST)
- structlog.get_logger("structlog").info("[TNC] ARQ | TX | DATA", mode=DATA_CHANNEL_MODE, frames=frame_progress, percent=transmission_percent, frames_total=total_frame_progress, attempt=transmission_attempts)
-
- # lets refresh all timers and ack states before sending a new frame
- arq_reset_ack(False)
-
-
- # ---------------------------BUILD ARQ BURST ---------------------------------------------------------------------
- tempbuffer = []
-
- # we need to optimize this and doing frame building like the other frames with explicit possition
- # instead of just appending byte data
- for n in range(0, TX_N_FRAMES_PER_BURST):
- frame_type = 10 + n + 1
- frame_type = bytes([frame_type])
- payload_data = bytes(TX_BUFFER[TX_N_SENT_FRAMES + n])
- n_current_arq_frame = TX_N_SENT_FRAMES + n + 1
- n_current_arq_frame = n_current_arq_frame.to_bytes(2, byteorder='big')
- n_total_arq_frame = len(TX_BUFFER)
-
- arqframe = frame_type + \
- bytes([TX_N_FRAMES_PER_BURST]) + \
- n_current_arq_frame + \
- n_total_arq_frame.to_bytes(2, byteorder='big') + \
- static.DXCALLSIGN_CRC8 + \
- static.MYCALLSIGN_CRC8 + \
- payload_data
-
- tempbuffer.append(arqframe)
- modem.transmit(mode=DATA_CHANNEL_MODE, repeats=1, repeat_delay=0, frames=tempbuffer)
-
-
- # --------------------------- START TIMER FOR WAITING FOR ACK ---> IF TIMEOUT REACHED, ACK_TIMEOUT = 1
+
+ # we have TX_N_MAX_RETRIES_PER_BURST attempts for sending a burst
+ for TX_N_RETRIES_PER_BURST in range(0,TX_N_MAX_RETRIES_PER_BURST):
- structlog.get_logger("structlog").debug("[TNC] ARQ | TX | WAITING FOR BURST ACK")
- #static.CHANNEL_STATE = 'RECEIVING_SIGNALLING'
-
- burstacktimeout = time.time() + BURST_ACK_TIMEOUT_SECONDS
- # --------------------------- WHILE TIMEOUT NOT REACHED AND NO ACK RECEIVED AND IN ARQ STATE--> LISTEN
- while not BURST_ACK_RECEIVED and not RPT_REQUEST_RECEIVED and not DATA_FRAME_ACK_RECEIVED and time.time() < burstacktimeout and static.ARQ_STATE == 'DATA':
- time.sleep(0.01) # lets reduce CPU load a little bit
- logging.debug("WAITING FOR BURST ACK..")
-
- # HERE WE PROCESS DATA IF WE RECEIVED ACK/RPT FRAMES OR NOT WHILE WE ARE IN ARQ STATE
- # IF WE ARE NOT IN ARQ STATE, WE STOPPED THE TRANSMISSION
- if RPT_REQUEST_RECEIVED and static.ARQ_STATE == 'DATA':
-
- structlog.get_logger("structlog").debug("[TNC] ARQ | TX | REQUEST FOR REPEATING FRAMES: ",buffer=RPT_REQUEST_BUFFER)
- structlog.get_logger("structlog").debug("[TNC] ARQ | TX | SENDING REQUESTED FRAMES: ",buffer=RPT_REQUEST_BUFFER)
- # --------- BUILD RPT FRAME --------------
- tempbuffer = []
- for n in range(0, len(RPT_REQUEST_BUFFER)):
- # we need to optimize this and doing frame building like the other frames with explicit possition
- # instead of just appending byte data
- missing_frame = int.from_bytes(RPT_REQUEST_BUFFER[n], "big")
-
- frame_type = 10 + missing_frame # static.ARQ_TX_N_FRAMES_PER_BURST
- frame_type = bytes([frame_type])
-
- try:
- payload_data = bytes(TX_BUFFER[TX_N_SENT_FRAMES + missing_frame - 1])
- except:
- structlog.get_logger("structlog").warning("[TNC] ARQ :modem buffer selection problem with ARQ RPT frames")
- n_current_arq_frame = TX_N_SENT_FRAMES + missing_frame
- n_current_arq_frame = n_current_arq_frame.to_bytes(2, byteorder='big')
-
- n_total_arq_frame = len(TX_BUFFER)
-
-
- arqframe = frame_type + \
- bytes([TX_N_FRAMES_PER_BURST]) + \
- n_current_arq_frame + \
- n_total_arq_frame.to_bytes(2, byteorder='big') + \
- static.DXCALLSIGN_CRC8 + \
- static.MYCALLSIGN_CRC8 + \
- payload_data
-
- tempbuffer.append(arqframe)
-
- modem.transmit(mode=DATA_CHANNEL_MODE, repeats=1, repeat_delay=0, frames=tempbuffer)
-
- arq_reset_ack(False)
-
- rpttimeout = time.time() + RPT_ACK_TIMEOUT_SECONDS
-
- while not BURST_ACK_RECEIVED and not DATA_FRAME_ACK_RECEIVED and static.ARQ_STATE == 'DATA' and time.time() < rpttimeout:
- time.sleep(0.01) # lets reduce CPU load a little bit
-
- if BURST_ACK_RECEIVED:
-
- structlog.get_logger("structlog").info("[TNC] ARQ : ACK after repeat")
- arq_reset_ack(True)
- RPT_REQUEST_BUFFER = []
- TX_N_SENT_FRAMES = TX_N_SENT_FRAMES + TX_N_FRAMES_PER_BURST
-
- if time.time() > rpttimeout and not BURST_ACK_RECEIVED:
- structlog.get_logger("structlog").warning("[TNC] ARQ : Burst lost...")
- arq_reset_ack(False)
- RPT_REQUEST_BUFFER = []
-
- # the order of ACK check is important! speciall the FRAME ACK after RPT needs to be checked really early!
-
- # --------------- BREAK LOOP IF FRAME ACK HAS BEEN RECEIVED EARLIER AS EXPECTED
- elif DATA_FRAME_ACK_RECEIVED and static.ARQ_STATE == 'DATA':
- logging.info("ARQ | RX | EARLY FRAME ACK RECEIVED #2")
-
- TX_N_SENT_FRAMES = TX_N_SENT_FRAMES + TX_N_FRAMES_PER_BURST
- break
-
- # --------------------------------------------------------------------------------------------------------------
- elif not BURST_ACK_RECEIVED and static.ARQ_STATE == 'DATA':
- logging.warning("ARQ | RX | ACK TIMEOUT!")
- pass # no break here so we can continue with the next try of repeating the burst
-
-
- # --------------- BREAK LOOP IF ACK HAS BEEN RECEIVED
- elif BURST_ACK_RECEIVED and static.ARQ_STATE == 'DATA':
- # -----------IF ACK RECEIVED, INCREMENT ITERATOR FOR MAIN LOOP TO PROCEED WITH NEXT FRAMES/BURST
- TX_N_SENT_FRAMES = TX_N_SENT_FRAMES + TX_N_FRAMES_PER_BURST
-
- # SET TX ATTEMPTS BACK TO 0
- TX_N_RETRIES_PER_BURST = 0
-
- calculate_transfer_rate_tx(TX_N_SENT_FRAMES, TX_PAYLOAD_PER_ARQ_FRAME, TX_START_OF_TRANSMISSION, TX_BUFFER_SIZE)
- logging.info("ARQ | RX | ACK [" + str(static.ARQ_BITS_PER_SECOND) + " bit/s | " + str(static.ARQ_BYTES_PER_MINUTE) + " B/min]")
- break
+ # AUTO MODE SELECTION
+ # mode 255 == AUTO MODE
+ # force usage of selected mode
+ if mode != 255:
+ data_mode = mode
+ structlog.get_logger("structlog").debug("FIXED MODE", mode=data_mode)
else:
- logging.debug("--->NO RULE MATCHED OR TRANSMISSION STOPPED!")
- logging.debug("ARQ_ACK_RECEIVED " + str(BURST_ACK_RECEIVED))
- logging.debug(f"TX_N_SENT_FRAMES: {TX_N_SENT_FRAMES}") # SENT FRAMES WILL INCREMENT AFTER ACK RECEIVED!
- logging.debug(f"TX_BUFFER_SIZE: {TX_BUFFER_SIZE}")
- logging.debug(f"DATA_FRAME_ACK_RECEIVED: {DATA_FRAME_ACK_RECEIVED}")
+ # at beginnign of transmission try fastest mode
+ if bufferposition == 0:
+ data_mode = 10
+ # if we have a reduced SNR OR its the second attempt of sending data, select slower mode
+ if BURST_ACK_SNR < 10 or TX_N_RETRIES_PER_BURST >= 2:
+ data_mode = 12
+ structlog.get_logger("structlog").debug("AUTO MODE", mode=data_mode)
+
+ # if we have (again) a high SNR and our attmepts are 0, then switch back to a faster mode
+ if BURST_ACK_SNR < 20 and TX_N_RETRIES_PER_BURST == 0:
+ data_mode = 10
+ structlog.get_logger("structlog").debug("FIXED MODE", mode=data_mode)
+
+
+ # payload information
+ payload_per_frame = modem.get_bytes_per_frame(data_mode) -2
+
+ # tempbuffer list for storing our data frames
+ tempbuffer = []
+
+ # append data frames with TX_N_FRAMES_PER_BURST to tempbuffer
+ # this part ineeds to a completly rewrite!
+ # TX_NF_RAMES_PER_BURST = 1 is working
+
+ arqheader = bytearray()
+ arqheader[:1] = bytes([10]) #bytes([10 + i])
+ arqheader[1:2] = bytes([TX_N_FRAMES_PER_BURST])
+ arqheader[3:4] = bytes(static.DXCALLSIGN_CRC8)
+ arqheader[4:5] = bytes(static.MYCALLSIGN_CRC8)
+
+ bufferposition_end = (bufferposition + payload_per_frame - len(arqheader))
+
+ # normal behavior
+ if bufferposition_end <= len(data_out):
+
+ frame = data_out[bufferposition:bufferposition_end]
+ frame = arqheader + frame
+
+ # this point shouldnt reached that often
+ elif bufferposition > len(data_out):
break
-
- # --------------------------------WAITING AREA FOR FRAME ACKs
-
- frameacktimeout = time.time() + DATA_FRAME_ACK_TIMEOUT_SECONDS
- # wait for frame ACK if we processed the last frame/burst
-
- while not DATA_FRAME_ACK_RECEIVED and time.time() < frameacktimeout and TX_N_SENT_FRAMES == TX_BUFFER_SIZE:
- time.sleep(0.01) # lets reduce CPU load a little bit
- logging.debug("WAITING FOR FRAME ACK")
-
- # ----------- if no ACK received and out of retries.....stop frame sending
- if not BURST_ACK_RECEIVED and not DATA_FRAME_ACK_RECEIVED:
- logging.error("ARQ | TX | NO ACK RECEIVED | DATA SHOULD BE RESEND!")
- static.INFO.append("ARQ;TRANSMITTING;FAILED")
- break
-
- # -------------------------BREAK TX BUFFER LOOP IF ALL PACKETS HAVE BEEN SENT AND WE GOT A FRAME ACK
- elif TX_N_SENT_FRAMES == TX_BUFFER_SIZE and DATA_FRAME_ACK_RECEIVED:
- calculate_transfer_rate_tx(TX_N_SENT_FRAMES, TX_PAYLOAD_PER_ARQ_FRAME, TX_START_OF_TRANSMISSION, TX_BUFFER_SIZE)
- static.INFO.append("ARQ;TRANSMITTING;SUCCESS")
- logging.info("ARQ | RX | FRAME ACK! - DATA TRANSMITTED! [" + str(static.ARQ_BITS_PER_SECOND) + " bit/s | " + str(static.ARQ_BYTES_PER_MINUTE) + " B/min]")
- break
+
+ # the last bytes of a frame
+ else:
+ extended_data_out = data_out[bufferposition:]
+ extended_data_out += bytes([0]) * (payload_per_frame-len(extended_data_out)-len(arqheader))
+ frame = arqheader + extended_data_out
+
+
+ # append frame to tempbuffer for transmission
+ tempbuffer.append(frame)
- elif not DATA_FRAME_ACK_RECEIVED and time.time() > frameacktimeout:
- logging.error("ARQ | TX | NO FRAME ACK RECEIVED")
- break
+ structlog.get_logger("structlog").debug("[TNC] tempbuffer", tempbuffer=tempbuffer)
+ structlog.get_logger("structlog").info("[TNC] ARQ | TX | FRAMES", mode=data_mode, fpb=TX_N_FRAMES_PER_BURST, retry=TX_N_RETRIES_PER_BURST)
+ modem.transmit(mode=data_mode, repeats=1, repeat_delay=0, frames=tempbuffer)
+
+ # lets wait for an ACK or RPT frame
+ burstacktimeout = time.time() + BURST_ACK_TIMEOUT_SECONDS
+ while not BURST_ACK_RECEIVED and not RPT_REQUEST_RECEIVED and not DATA_FRAME_ACK_RECEIVED and time.time() < burstacktimeout and static.ARQ_STATE:
+ time.sleep(0.001)
+
+ # once we received a burst ack, reset its state and break the RETRIES loop
+ if BURST_ACK_RECEIVED:
+ BURST_ACK_RECEIVED = False # reset ack state
+ TX_N_RETRIES_PER_BURST = 0 # reset retries
+ break #break retry loop
- else:
- logging.debug("NO MATCHING RULE AT THE END")
+ if RPT_REQUEST_RECEIVED:
+ pass
- # IF TX BUFFER IS EMPTY / ALL FRAMES HAVE BEEN SENT --> HERE WE COULD ADD AN static.VAR for IDLE STATE
- #transfer_rates = calculate_transfer_rate()
- #logging.info("RATE (DATA/ACK) :[" + str(transfer_rates[0]) + " bit/s | " + str(transfer_rates[1]) + " B/min]")
+ if DATA_FRAME_ACK_RECEIVED:
+ break #break retry loop
+
+
+ # we need this part for leaving the repeat loop
+ # static.ARQ_STATE == 'DATA' --> when stopping transmission manually
+ if not static.ARQ_STATE:
+ #print("not ready for data...leaving loop....")
+ break
+
+
+ # NEXT ATTEMPT
+ structlog.get_logger("structlog").debug("ATTEMPT", retry=TX_N_RETRIES_PER_BURST, maxretries=TX_N_MAX_RETRIES_PER_BURST)
+
+ # update buffer position
+ bufferposition = bufferposition_end
- logging.info("ARQ | TX | BUFFER EMPTY")
- # we are doing some cleanup here
- static.TNC_STATE = 'IDLE'
- static.ARQ_STATE = 'IDLE'
- DATA_CHANNEL_READY_FOR_DATA = False
- #DATA_CHANNEL_LAST_RECEIVED = 0
- #BURST_ACK_RECEIVED = False
- #DATA_FRAME_ACK_RECEIVED = False
+ # update stats
+ calculate_transfer_rate_tx(tx_start_of_transmission, bufferposition_end, len(data_out))
+ #GOING TO NEXT ITERATION
+
+
+ if DATA_FRAME_ACK_RECEIVED:
- logging.info("DATA [" + str(static.MYCALLSIGN, 'utf-8') + "]<< >>[" + str(static.DXCALLSIGN, 'utf-8') + "] [SNR:" + str(static.SNR) + "]")
-
- # this should close our thread so we are saving memory...
- # https://stackoverflow.com/questions/905189/why-does-sys-exit-not-exit-when-called-inside-a-thread-in-python
- sys.exit()
+ static.INFO.append("ARQ;TRANSMITTING;SUCCESS")
+
+ structlog.get_logger("structlog").info("ARQ | TX | DATA TRANSMITTED!", BytesPerMinute=static.ARQ_BYTES_PER_MINUTE, BitsPerSecond=static.ARQ_BITS_PER_SECOND)
+
+ else:
+ static.INFO.append("ARQ;TRANSMITTING;FAILED")
+ structlog.get_logger("structlog").info("ARQ | TX | TRANSMISSION FAILED OR TIME OUT!")
+
+ # and last but not least doing a state cleanup
+ # do cleanup only when not in testmode
+ if not TESTMODE:
+ arq_cleanup()
+
+ # quit after transmission
+ if TESTMODE:
+ import os
+ os._exit(0)
-def burst_ack_received():
+def burst_ack_received(data_in:bytes):
global BURST_ACK_RECEIVED
+ global BURST_ACK_SNR
global DATA_CHANNEL_LAST_RECEIVED
+
+
# only process data if we are in ARQ and BUSY state
- if static.ARQ_STATE == 'DATA' and static.TNC_STATE == 'BUSY':
+ if static.ARQ_STATE:
BURST_ACK_RECEIVED = True # Force data loops of TNC to stop and continue with next frame
DATA_CHANNEL_LAST_RECEIVED = int(time.time()) # we need to update our timeout timestamp
+ BURST_ACK_SNR = int.from_bytes(bytes(data_in[3:4]), "big")
def frame_ack_received():
@@ -584,20 +447,25 @@ def frame_ack_received():
global DATA_CHANNEL_LAST_RECEIVED
# only process data if we are in ARQ and BUSY state
- if static.ARQ_STATE == 'DATA' and static.TNC_STATE == 'BUSY':
-
+ if static.ARQ_STATE:
DATA_FRAME_ACK_RECEIVED = True # Force data loops of TNC to stop and continue with next frame
DATA_CHANNEL_LAST_RECEIVED = int(time.time()) # we need to update our timeout timestamp
-def burst_rpt_received(data_in):
+def frame_nack_received(data_in:bytes):
+ static.INFO.append("ARQ;TRANSMITTING;FAILED")
+ arq_cleanup()
+
+
+
+def burst_rpt_received(data_in:bytes):
global RPT_REQUEST_RECEIVED
global RPT_REQUEST_BUFFER
global DATA_CHANNEL_LAST_RECEIVED
# only process data if we are in ARQ and BUSY state
- if static.ARQ_STATE == 'DATA' and static.TNC_STATE == 'BUSY':
+ if static.ARQ_STATE and static.TNC_STATE == 'BUSY':
RPT_REQUEST_RECEIVED = True
DATA_CHANNEL_LAST_RECEIVED = int(time.time()) # we need to update our timeout timestamp
@@ -615,45 +483,57 @@ def burst_rpt_received(data_in):
# ############################################################################################################
-def open_dc_and_transmit(data_out, mode, n_frames_per_burst):
- global DATA_CHANNEL_READY_FOR_DATA
+def open_dc_and_transmit(data_out:bytes, mode:int, n_frames_per_burst:int):
static.TNC_STATE = 'BUSY'
-
- asyncio.run(arq_open_data_channel(mode))
+
+ # we need to compress data for gettin a compression factor.
+ # so we are compressing twice. This is not that nice and maybe theres another way
+ # for calculating transmission statistics
+ static.ARQ_COMPRESSION_FACTOR = len(data_out) / len(zlib.compress(data_out))
+
+
+
+ arq_open_data_channel(mode, len(data_out), n_frames_per_burst)
# wait until data channel is open
- while not DATA_CHANNEL_READY_FOR_DATA:
+ while not static.ARQ_STATE:
time.sleep(0.01)
arq_transmit(data_out, mode, n_frames_per_burst)
-
-async def arq_open_data_channel(mode):
-
- global DATA_CHANNEL_READY_FOR_DATA
+def arq_open_data_channel(mode:int, data_len:int, n_frames_per_burst:int):
global DATA_CHANNEL_LAST_RECEIVED
DATA_CHANNEL_MAX_RETRIES = 5 # N attempts for connecting to another station
-
- DATA_CHANNEL_MODE = int(mode)
DATA_CHANNEL_LAST_RECEIVED = int(time.time())
+ # devide by 1024 for getting Bytes -> kBytes
+ data_len = int(data_len / 1024)
+
+
+ # multiply compression factor for reducing it from float to int
+ compression_factor = int(static.ARQ_COMPRESSION_FACTOR * 10)
+
connection_frame = bytearray(14)
connection_frame[:1] = bytes([225])
connection_frame[1:2] = static.DXCALLSIGN_CRC8
connection_frame[2:3] = static.MYCALLSIGN_CRC8
connection_frame[3:9] = static.MYCALLSIGN
- connection_frame[12:13] = bytes([DATA_CHANNEL_MODE])
+ connection_frame[9:10] = bytes([0]) # ONE BYTE LEFT FOR OTHER THINGS
+ connection_frame[10:12] = data_len.to_bytes(2, byteorder='big')
+ connection_frame[12:13] = bytes([compression_factor])
+ connection_frame[13:14] = bytes([n_frames_per_burst])
+
- while not DATA_CHANNEL_READY_FOR_DATA:
+ while not static.ARQ_STATE:
time.sleep(0.01)
for attempt in range(1,DATA_CHANNEL_MAX_RETRIES+1):
static.INFO.append("DATACHANNEL;OPENING")
- structlog.get_logger("structlog").info("[TNC] DATA [" + str(static.MYCALLSIGN, 'utf-8') + "]>> <<[" + str(static.DXCALLSIGN, 'utf-8') + "]", attempt=str(attempt) + "/" + str(DATA_CHANNEL_MAX_RETRIES))
+ structlog.get_logger("structlog").info("[TNC] ARQ | DATA | TX | [" + str(static.MYCALLSIGN, 'utf-8') + "]>> <<[" + str(static.DXCALLSIGN, 'utf-8') + "]", attempt=str(attempt) + "/" + str(DATA_CHANNEL_MAX_RETRIES))
-
+
txbuffer = [connection_frame]
modem.transmit(mode=14, repeats=1, repeat_delay=0, frames=txbuffer)
@@ -661,37 +541,45 @@ async def arq_open_data_channel(mode):
while time.time() < timeout:
time.sleep(0.01)
# break if data channel is openend
- if DATA_CHANNEL_READY_FOR_DATA:
+ if static.ARQ_STATE:
break
- if DATA_CHANNEL_READY_FOR_DATA:
+ if static.ARQ_STATE:
break
- if not DATA_CHANNEL_READY_FOR_DATA and attempt == DATA_CHANNEL_MAX_RETRIES:
+ if not static.ARQ_STATE and attempt == DATA_CHANNEL_MAX_RETRIES:
static.INFO.append("DATACHANNEL;FAILED")
- structlog.get_logger("structlog").warning("[TNC] DATA [" + str(static.MYCALLSIGN, 'utf-8') + "]>>X<<[" + str(static.DXCALLSIGN, 'utf-8') + "]")
- static.TNC_STATE = 'IDLE'
- static.ARQ_STATE = 'IDLE'
+ structlog.get_logger("structlog").warning("[TNC] ARQ | TX | DATA [" + str(static.MYCALLSIGN, 'utf-8') + "]>>X<<[" + str(static.DXCALLSIGN, 'utf-8') + "]")
+ arq_cleanup()
sys.exit() # close thread and so connection attempts
-def arq_received_data_channel_opener(data_in):
+def arq_received_data_channel_opener(data_in:bytes):
- #global DATA_CHANNEL_MODE
global DATA_CHANNEL_LAST_RECEIVED
+ global RX_START_OF_TRANSMISSION
+
static.INFO.append("DATACHANNEL;RECEIVEDOPENER")
static.DXCALLSIGN_CRC8 = bytes(data_in[2:3]).rstrip(b'\x00')
static.DXCALLSIGN = bytes(data_in[3:9]).rstrip(b'\x00')
+
+ static.TOTAL_BYTES = int.from_bytes(bytes(data_in[10:12]), "big") # kBytes
+ static.ARQ_COMPRESSION_FACTOR = float(int.from_bytes(bytes(data_in[12:13]), "big") / 10)
+ n_frames_per_burst = int.from_bytes(bytes(data_in[13:14]), "big")
+
+ modem.set_frames_per_burst(n_frames_per_burst)
+
+
+
helpers.add_to_heard_stations(static.DXCALLSIGN,static.DXGRID, 'DATA-CHANNEL', static.SNR, static.FREQ_OFFSET, static.HAMLIB_FREQUENCY)
- structlog.get_logger("structlog").info("[TNC] DATA [" + str(static.MYCALLSIGN, 'utf-8') + "]>> <<[" + str(static.DXCALLSIGN, 'utf-8') + "]")
+ structlog.get_logger("structlog").info("[TNC] ARQ | DATA | RX | [" + str(static.MYCALLSIGN, 'utf-8') + "]>> <<[" + str(static.DXCALLSIGN, 'utf-8') + "]")
- static.ARQ_STATE = 'DATA'
+ static.ARQ_STATE = True
static.TNC_STATE = 'BUSY'
- mode = int.from_bytes(bytes(data_in[12:13]), "big")
DATA_CHANNEL_LAST_RECEIVED = int(time.time())
connection_frame = bytearray(14)
@@ -699,18 +587,22 @@ def arq_received_data_channel_opener(data_in):
connection_frame[1:2] = static.DXCALLSIGN_CRC8
connection_frame[2:3] = static.MYCALLSIGN_CRC8
connection_frame[3:9] = static.MYCALLSIGN
- connection_frame[12:13] = bytes([mode])
+
+ #connection_frame[12:13] = bytes([mode])
+
+
txbuffer = [connection_frame]
modem.transmit(mode=14, repeats=1, repeat_delay=0, frames=txbuffer)
- structlog.get_logger("structlog").info("[TNC] DATA [" + str(static.MYCALLSIGN, 'utf-8') + "]>>|<<[" + str(static.DXCALLSIGN, 'utf-8') + "]", snr=static.SNR, mode=mode)
+ structlog.get_logger("structlog").info("[TNC] ARQ | DATA | RX | [" + str(static.MYCALLSIGN, 'utf-8') + "]>>|<<[" + str(static.DXCALLSIGN, 'utf-8') + "]", snr=static.SNR)
-def arq_received_channel_is_open(data_in):
+ # set start of transmission for our statistics
+ RX_START_OF_TRANSMISSION = time.time()
+
+def arq_received_channel_is_open(data_in:bytes):
global DATA_CHANNEL_LAST_RECEIVED
- global DATA_CHANNEL_READY_FOR_DATA
- global DATA_CHANNEL_MODE
static.INFO.append("DATACHANNEL;OPEN")
static.DXCALLSIGN_CRC8 = bytes(data_in[2:3]).rstrip(b'\x00')
@@ -719,27 +611,17 @@ def arq_received_channel_is_open(data_in):
DATA_CHANNEL_LAST_RECEIVED = int(time.time())
- # we are doing a mode check here, but this doesn't seem to be necessary since we have simultaneous decoding
- # we are forcing doing a transmission at the moment --> see else statement
- if DATA_CHANNEL_MODE == int.from_bytes(bytes(data_in[12:13]), "big"):
- structlog.get_logger("structlog").info("[TNC] DATA [" + str(static.MYCALLSIGN, 'utf-8') + "]>>|<<[" + str(static.DXCALLSIGN, 'utf-8') + "]", snr=static.SNR)
-
- # as soon as we set ARQ_STATE to DATA, transmission starts
- static.ARQ_STATE = 'DATA'
- DATA_CHANNEL_READY_FOR_DATA = True
- DATA_CHANNEL_LAST_RECEIVED = int(time.time())
- else:
- structlog.get_logger("structlog").info("[TNC] DATA [" + str(static.MYCALLSIGN, 'utf-8') + "]>>|<<[" + str(static.DXCALLSIGN, 'utf-8') + "]", snr=static.SNR, info="wrong mode rcvd")
- # as soon as we set ARQ_STATE to DATA, transmission starts
- static.ARQ_STATE = 'DATA'
- DATA_CHANNEL_READY_FOR_DATA = True
- DATA_CHANNEL_LAST_RECEIVED = int(time.time())
+ structlog.get_logger("structlog").info("[TNC] ARQ | DATA | TX | [" + str(static.MYCALLSIGN, 'utf-8') + "]>>|<<[" + str(static.DXCALLSIGN, 'utf-8') + "]", snr=static.SNR)
+ # as soon as we set ARQ_STATE to DATA, transmission starts
+ static.ARQ_STATE = True
+ DATA_CHANNEL_LAST_RECEIVED = int(time.time())
+
# ############################################################################################################
# PING HANDLER
# ############################################################################################################
-def transmit_ping(callsign):
+def transmit_ping(callsign:str):
static.DXCALLSIGN = bytes(callsign, 'utf-8').rstrip(b'\x00')
static.DXCALLSIGN_CRC8 = helpers.get_crc_8(static.DXCALLSIGN)
@@ -755,7 +637,7 @@ def transmit_ping(callsign):
txbuffer = [ping_frame]
modem.transmit(mode=14, repeats=1, repeat_delay=0, frames=txbuffer)
-def received_ping(data_in, frequency_offset):
+def received_ping(data_in:bytes, frequency_offset:str):
static.DXCALLSIGN_CRC8 = bytes(data_in[2:3]).rstrip(b'\x00')
static.DXCALLSIGN = bytes(data_in[3:9]).rstrip(b'\x00')
@@ -775,7 +657,7 @@ def received_ping(data_in, frequency_offset):
txbuffer = [ping_frame]
modem.transmit(mode=14, repeats=1, repeat_delay=0, frames=txbuffer)
-def received_ping_ack(data_in):
+def received_ping_ack(data_in:bytes):
static.DXCALLSIGN_CRC8 = bytes(data_in[2:3]).rstrip(b'\x00')
static.DXGRID = bytes(data_in[3:9]).rstrip(b'\x00')
@@ -791,7 +673,7 @@ def received_ping_ack(data_in):
# BROADCAST HANDLER
# ############################################################################################################
-def run_beacon(interval):
+def run_beacon(interval:int):
try:
structlog.get_logger("structlog").warning("[TNC] Starting beacon!", interval=interval)
@@ -814,7 +696,7 @@ def run_beacon(interval):
except Exception as e:
print(e)
-def received_beacon(data_in):
+def received_beacon(data_in:bytes):
# here we add the received station to the heard stations buffer
dxcallsign = bytes(data_in[2:8]).rstrip(b'\x00')
dxgrid = bytes(data_in[8:14]).rstrip(b'\x00')
@@ -843,7 +725,7 @@ def transmit_cq():
# pass
-def received_cq(data_in):
+def received_cq(data_in:bytes):
# here we add the received station to the heard stations buffer
dxcallsign = bytes(data_in[2:8]).rstrip(b'\x00')
dxgrid = bytes(data_in[8:14]).rstrip(b'\x00')
@@ -854,29 +736,22 @@ def received_cq(data_in):
-def arq_reset_ack(state):
- """
- Author: DJ2LS
- """
- global BURST_ACK_RECEIVED
- global RPT_REQUEST_RECEIVED
- global DATA_FRAME_ACK_RECEIVED
+
+
+
+def calculate_transfer_rate_rx(rx_start_of_transmission:float, receivedbytes:int) -> list:
- BURST_ACK_RECEIVED = state
- RPT_REQUEST_RECEIVED = state
- DATA_FRAME_ACK_RECEIVED = state
+ try:
+ static.ARQ_TRANSMISSION_PERCENT = int((receivedbytes*static.ARQ_COMPRESSION_FACTOR / (static.TOTAL_BYTES * 1024)) * 100)
-
-def calculate_transfer_rate_rx(rx_n_frames_per_data_frame, rx_n_frame_of_data_frame, rx_start_of_transmission, rx_payload_per_arq_frame):
- try:
- static.ARQ_TRANSMISSION_PERCENT = int((rx_n_frame_of_data_frame / rx_n_frames_per_data_frame) * 100)
-
transmissiontime = time.time() - rx_start_of_transmission
- receivedbytes = rx_n_frame_of_data_frame * (rx_payload_per_arq_frame-6) # 6 = length of ARQ header
- static.ARQ_BITS_PER_SECOND = int((receivedbytes*8) / transmissiontime)
- static.ARQ_BYTES_PER_MINUTE = int((receivedbytes) / (transmissiontime/60))
-
+ if receivedbytes > 0:
+ static.ARQ_BITS_PER_SECOND = int((receivedbytes*8) / transmissiontime)
+ static.ARQ_BYTES_PER_MINUTE = int((receivedbytes) / (transmissiontime/60))
+ else:
+ static.ARQ_BITS_PER_SECOND = 0
+ static.ARQ_BYTES_PER_MINUTE = 0
except:
static.ARQ_TRANSMISSION_PERCENT = 0.0
static.ARQ_BITS_PER_SECOND = 0
@@ -889,16 +764,17 @@ def calculate_transfer_rate_rx(rx_n_frames_per_data_frame, rx_n_frame_of_data_fr
-def calculate_transfer_rate_tx(tx_n_sent_frames, tx_payload_per_arq_frame, tx_start_of_transmission, tx_buffer_length):
+def calculate_transfer_rate_tx(tx_start_of_transmission:float, sentbytes:int, tx_buffer_length:int) -> list:
+
try:
- static.ARQ_TRANSMISSION_PERCENT = int((tx_n_sent_frames / tx_buffer_length) * 100)
+ static.ARQ_TRANSMISSION_PERCENT = int((sentbytes / tx_buffer_length) * 100)
transmissiontime = time.time() - tx_start_of_transmission
- if tx_n_sent_frames > 0:
- sendbytes = tx_n_sent_frames * (tx_payload_per_arq_frame-6) #6 = length of ARQ header
+
+ if sentbytes > 0:
- static.ARQ_BITS_PER_SECOND = int((sendbytes*8) / transmissiontime)
- static.ARQ_BYTES_PER_MINUTE = int((sendbytes) / (transmissiontime/60))
+ static.ARQ_BITS_PER_SECOND = int((sentbytes*8) / transmissiontime) # Bits per Second
+ static.ARQ_BYTES_PER_MINUTE = int((sentbytes) / (transmissiontime/60)) #Bytes per Minute
else:
static.ARQ_BITS_PER_SECOND = 0
@@ -909,7 +785,6 @@ def calculate_transfer_rate_tx(tx_n_sent_frames, tx_payload_per_arq_frame, tx_st
static.ARQ_BITS_PER_SECOND = 0
static.ARQ_BYTES_PER_MINUTE = 0
-
return [static.ARQ_BITS_PER_SECOND, \
static.ARQ_BYTES_PER_MINUTE, \
static.ARQ_TRANSMISSION_PERCENT]
@@ -919,35 +794,6 @@ def calculate_transfer_rate_tx(tx_n_sent_frames, tx_payload_per_arq_frame, tx_st
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
# WATCHDOG FUNCTIONS
def watchdog():
"""
@@ -966,19 +812,52 @@ def data_channel_keep_alive_watchdog():
"""
global DATA_CHANNEL_LAST_RECEIVED
-
+
# and not static.ARQ_SEND_KEEP_ALIVE:
- if static.ARQ_STATE == 'DATA' and static.TNC_STATE == 'BUSY':
+ if static.ARQ_STATE and static.TNC_STATE == 'BUSY':
time.sleep(0.01)
if DATA_CHANNEL_LAST_RECEIVED + 30 > time.time():
time.sleep(0.01)
#pass
else:
DATA_CHANNEL_LAST_RECEIVED = 0
- logging.info("DATA [" + str(static.MYCALLSIGN, 'utf-8') + "]<>[" + str(static.DXCALLSIGN, 'utf-8') + "] [BER." + str(static.BER) + "]")
- #arq_reset_frame_machine()
- static.TNC_STATE = 'IDLE'
- static.ARQ_STATE = 'IDLE'
+ logging.info("DATA [" + str(static.MYCALLSIGN, 'utf-8') + "]<>[" + str(static.DXCALLSIGN, 'utf-8') + "]")
+ arq_cleanup()
+
+
+def arq_cleanup():
+ global DATA_CHANNEL_LAST_RECEIVED
+ global BURST_ACK_RECEIVED
+ global RPT_REQUEST_RECEIVED
+ global DATA_FRAME_ACK_RECEIVED
+ global RX_FRAME_BOF_RECEIVED
+ global RX_FRAME_EOF_RECEIVED
+ global BURST_ACK_SNR
+
+ structlog.get_logger("structlog").debug("cleanup")
+
+ RX_FRAME_BOF_RECEIVED = False
+ RX_FRAME_EOF_RECEIVED = False
+ static.TNC_STATE = 'IDLE'
+ static.ARQ_STATE = False
+ BURST_ACK_RECEIVED = False
+ RPT_REQUEST_RECEIVED = False
+ DATA_FRAME_ACK_RECEIVED = False
+ static.RX_BURST_BUFFER = []
+ static.RX_FRAME_BUFFER = b''
+ BURST_ACK_SNR = 255
+
+def arq_reset_ack(state:bool):
+ """
+ Author: DJ2LS
+ """
+ global BURST_ACK_RECEIVED
+ global RPT_REQUEST_RECEIVED
+ global DATA_FRAME_ACK_RECEIVED
+
+ BURST_ACK_RECEIVED = state
+ RPT_REQUEST_RECEIVED = state
+ DATA_FRAME_ACK_RECEIVED = state
# START THE THREAD FOR THE TIMEOUT WATCHDOG
WATCHDOG_SERVER_THREAD = threading.Thread(target=watchdog, name="watchdog")
diff --git a/tnc/modem.py b/tnc/modem.py
index 20a0ac73..fb7a26c5 100644
--- a/tnc/modem.py
+++ b/tnc/modem.py
@@ -18,6 +18,7 @@ import numpy as np
import helpers
import static
import data_handler
+
import re
import queue
import codec2
@@ -233,17 +234,17 @@ class RF():
mod_out_postamble = create_string_buffer(n_tx_postamble_modem_samples * 2)
# add empty data to handle ptt toggle time
- data_delay_seconds = 250
- data_delay = int(self.MODEM_SAMPLE_RATE*(data_delay_seconds/1000))
+ data_delay_mseconds = 0 #miliseconds
+ data_delay = int(self.MODEM_SAMPLE_RATE*(data_delay_mseconds/1000))
mod_out_silence = create_string_buffer(data_delay*2)
txbuffer = bytes(mod_out_silence)
for i in range(1,repeats+1):
-
# write preamble to txbuffer
codec2.api.freedv_rawdatapreambletx(freedv, mod_out_preamble)
- time.sleep(0.01)
+ time.sleep(0.05)
txbuffer += bytes(mod_out_preamble)
+
# create modulaton for n frames in list
for n in range(0,len(frames)):
@@ -260,19 +261,19 @@ class RF():
data = (ctypes.c_ubyte * bytes_per_frame).from_buffer_copy(buffer)
codec2.api.freedv_rawdatatx(freedv,mod_out,data) # modulate DATA and save it into mod_out pointer
- time.sleep(0.01)
+ time.sleep(0.05)
txbuffer += bytes(mod_out)
# append postamble to txbuffer
codec2.api.freedv_rawdatapostambletx(freedv, mod_out_postamble)
txbuffer += bytes(mod_out_postamble)
- time.sleep(0.01)
+ time.sleep(0.05)
# add delay to end of frames
samples_delay = int(self.MODEM_SAMPLE_RATE*(repeat_delay/1000))
mod_out_silence = create_string_buffer(samples_delay*2)
txbuffer += bytes(mod_out_silence)
- time.sleep(0.01)
+ #time.sleep(0.05)
# resample up to 48k (resampler works on np.int16)
x = np.frombuffer(txbuffer, dtype=np.int16)
@@ -287,7 +288,9 @@ class RF():
# if data is shorter than the expcected audio frames per buffer we need to append 0
# to prevent the callback from stucking/crashing
if len(c) < self.AUDIO_FRAMES_PER_BUFFER_RX*2:
- c += bytes(self.AUDIO_FRAMES_PER_BUFFER_RX*2 - len(c))
+ delta = bytes(self.AUDIO_FRAMES_PER_BUFFER_RX*2 - len(c))
+ c += delta
+ structlog.get_logger("structlog").debug("[TNC] mod out shorter than audio buffer", delta=len(delta))
self.modoutqueue.put(c)
# maybe we need to toggle PTT before craeting modulation because of queue processing
@@ -295,21 +298,21 @@ class RF():
while not self.modoutqueue.empty():
pass
static.PTT_STATE = self.hamlib.set_ptt(False)
-
self.c_lib.freedv_close(freedv)
return True
def audio(self):
try:
- print(f"starting pyaudio callback", file=sys.stderr)
+ structlog.get_logger("structlog").debug("[TNC] starting pyaudio callback")
self.audio_stream.start_stream()
except Exception as e:
- print(f"pyAudio error: {e}", file=sys.stderr)
+ structlog.get_logger("structlog").error("[TNC] starting pyaudio callback failed", e=e)
while self.audio_stream.is_active():
while self.datac0_buffer.nbuffer >= self.datac0_nin:
+
# demodulate audio
nbytes = codec2.api.freedv_rawdatarx(self.datac0_freedv, self.datac0_bytes_out, self.datac0_buffer.buffer.ctypes)
self.datac0_buffer.pop(self.datac0_nin)
@@ -320,6 +323,7 @@ class RF():
self.calculate_snr(self.datac0_freedv)
while self.datac1_buffer.nbuffer >= self.datac1_nin:
+
# demodulate audio
nbytes = codec2.api.freedv_rawdatarx(self.datac1_freedv, self.datac1_bytes_out, self.datac1_buffer.buffer.ctypes)
self.datac1_buffer.pop(self.datac1_nin)
@@ -330,6 +334,7 @@ class RF():
self.calculate_snr(self.datac1_freedv)
while self.datac3_buffer.nbuffer >= self.datac3_nin:
+
# demodulate audio
nbytes = codec2.api.freedv_rawdatarx(self.datac3_freedv, self.datac3_bytes_out, self.datac3_buffer.buffer.ctypes)
self.datac3_buffer.pop(self.datac3_nin)
@@ -337,8 +342,9 @@ class RF():
if nbytes == self.datac3_bytes_per_frame:
self.dataqueue.put([self.datac3_bytes_out, self.datac3_freedv ,self.datac3_bytes_per_frame])
self.get_scatter(self.datac3_freedv)
- self.calculate_snr(self.datac3_freedv)
-
+ self.calculate_snr(self.datac3_freedv)
+
+
@@ -346,8 +352,11 @@ class RF():
# worker for FIFO queue for processing received frames
def worker(self):
while True:
- time.sleep(0.1)
+ time.sleep(0.01)
data = self.dataqueue.get()
+ # data[0] = bytes_out
+ # data[1] = freedv session
+ # data[2] = bytes_per_frame
self.process_data(data[0], data[1], data[2])
self.dataqueue.task_done()
@@ -359,7 +368,7 @@ class RF():
# we could also create an own function, which returns True.
def process_data(self, bytes_out, freedv, bytes_per_frame):
- if bytes(bytes_out[1:2]) == static.MYCALLSIGN_CRC8 or bytes(bytes_out[6:7]) == static.MYCALLSIGN_CRC8 or bytes(bytes_out[1:2]) == b'\x01':
+ if bytes(bytes_out[1:2]) == static.MYCALLSIGN_CRC8 or bytes(bytes_out[3:4]) == static.MYCALLSIGN_CRC8 or bytes(bytes_out[1:2]) == b'\x01':
# CHECK IF FRAMETYPE IS BETWEEN 10 and 50 ------------------------
frametype = int.from_bytes(bytes(bytes_out[:1]), "big")
@@ -371,39 +380,47 @@ class RF():
#print("Freq-Offset: " + str(frequency_offset))
if 50 >= frametype >= 10:
-
+ # get snr of received data
+ snr = self.calculate_snr(freedv)
+ structlog.get_logger("structlog").debug("[TNC] RX SNR", snr=snr)
# send payload data to arq checker without CRC16
- data_handler.arq_data_received(bytes(bytes_out[:-2]), bytes_per_frame)
+ data_handler.arq_data_received(bytes(bytes_out[:-2]), bytes_per_frame, snr, freedv)
- #print("static.ARQ_RX_BURST_BUFFER.count(None) " + str(static.ARQ_RX_BURST_BUFFER.count(None)))
- if static.RX_BURST_BUFFER.count(None) <= 1:
- logging.debug("FULL BURST BUFFER ---> UNSYNC")
+ # if we received the last frame of a burst or the last remaining rpt frame, do a modem unsync
+ if static.RX_BURST_BUFFER.count(None) <= 1 or (frame+1) == n_frames_per_burst:
+ structlog.get_logger("structlog").debug(f"LAST FRAME OF BURST --> UNSYNC {frame+1}/{n_frames_per_burst}")
self.c_lib.freedv_set_sync(freedv, 0)
# BURST ACK
elif frametype == 60:
- logging.debug("ACK RECEIVED....")
- data_handler.burst_ack_received()
+ structlog.get_logger("structlog").debug("ACK RECEIVED....")
+
+ data_handler.burst_ack_received(bytes_out[:-2])
# FRAME ACK
elif frametype == 61:
- logging.debug("FRAME ACK RECEIVED....")
+ structlog.get_logger("structlog").debug("FRAME ACK RECEIVED....")
data_handler.frame_ack_received()
# FRAME RPT
elif frametype == 62:
- logging.debug("REPEAT REQUEST RECEIVED....")
+ structlog.get_logger("structlog").debug("REPEAT REQUEST RECEIVED....")
data_handler.burst_rpt_received(bytes_out[:-2])
+ # FRAME NACK
+ elif frametype == 63:
+ structlog.get_logger("structlog").debug("FRAME NOT ACK RECEIVED....")
+ data_handler.frame_nack_received(bytes_out[:-2])
+
# CQ FRAME
elif frametype == 200:
- logging.debug("CQ RECEIVED....")
+ structlog.get_logger("structlog").debug("CQ RECEIVED....")
data_handler.received_cq(bytes_out[:-2])
# PING FRAME
elif frametype == 210:
- logging.debug("PING RECEIVED....")
+ structlog.get_logger("structlog").debug("PING RECEIVED....")
frequency_offset = self.get_frequency_offset(freedv)
#print("Freq-Offset: " + str(frequency_offset))
data_handler.received_ping(bytes_out[:-2], frequency_offset)
@@ -411,7 +428,7 @@ class RF():
# PING ACK
elif frametype == 211:
- logging.debug("PING ACK RECEIVED....")
+ structlog.get_logger("structlog").debug("PING ACK RECEIVED....")
# early detection of frequency offset
#frequency_offset = int.from_bytes(bytes(bytes_out[9:11]), "big", signed=True)
#print("Freq-Offset: " + str(frequency_offset))
@@ -426,19 +443,21 @@ class RF():
# ARQ FILE TRANSFER RECEIVED!
elif frametype == 225:
- logging.debug("ARQ arq_received_data_channel_opener")
+ structlog.get_logger("structlog").debug("ARQ arq_received_data_channel_opener")
data_handler.arq_received_data_channel_opener(bytes_out[:-2])
-
+
# ARQ CHANNEL IS OPENED
elif frametype == 226:
- logging.debug("ARQ arq_received_channel_is_open")
+ structlog.get_logger("structlog").debug("ARQ arq_received_channel_is_open")
data_handler.arq_received_channel_is_open(bytes_out[:-2])
# ARQ CONNECT ACK / KEEP ALIVE
+ # this is outdated and we may remove it
elif frametype == 230:
- logging.debug("BEACON RECEIVED")
+ structlog.get_logger("structlog").debug("BEACON RECEIVED")
data_handler.received_beacon(bytes_out[:-2])
+ # TESTFRAMES
elif frametype == 255:
structlog.get_logger("structlog").debug("TESTFRAME RECEIVED", frame=bytes_out[:])
@@ -448,6 +467,7 @@ class RF():
# DO UNSYNC AFTER LAST BURST by checking the frame nums against the total frames per burst
+ # this should be changed to a timeout based unsync
if frame == n_frames_per_burst:
logging.info("LAST FRAME ---> UNSYNC")
self.c_lib.freedv_set_sync(freedv, 0) # FORCE UNSYNC
@@ -501,11 +521,13 @@ class RF():
self.c_lib.freedv_get_modem_stats(freedv, byref(
modem_stats_sync), byref(modem_stats_snr))
modem_stats_snr = modem_stats_snr.value
+
try:
static.SNR = round(modem_stats_snr, 1)
+ return static.SNR
except:
static.SNR = 0
-
+ return static.SNR
def update_rig_data(self):
while True:
@@ -546,3 +568,13 @@ class RF():
static.FFT = [0] * 320
else:
pass
+
+ def get_bytes_per_frame(self, mode):
+ freedv = cast(codec2.api.freedv_open(mode), c_void_p)
+
+ # get number of bytes per frame for mode
+ return int(codec2.api.freedv_get_bits_per_modem_frame(freedv)/8)
+
+ def set_frames_per_burst(self, n_frames_per_burst):
+ codec2.api.freedv_set_frames_per_burst(self.datac1_freedv,n_frames_per_burst)
+ codec2.api.freedv_set_frames_per_burst(self.datac3_freedv,n_frames_per_burst)
diff --git a/tnc/sock.py b/tnc/sock.py
index 37394fbd..6ce9cd38 100644
--- a/tnc/sock.py
+++ b/tnc/sock.py
@@ -31,6 +31,7 @@ import time
import static
import data_handler
+
import helpers
import sys
@@ -121,7 +122,7 @@ class ThreadedTCPRequestHandler(socketserver.BaseRequestHandler):
PING_THREAD = threading.Thread(target=data_handler.transmit_ping, args=[dxcallsign], name="PING")
PING_THREAD.start()
- # and static.ARQ_READY_FOR_DATA == True: # and static.ARQ_STATE == 'CONNECTED' :
+
if received_json["type"] == 'ARQ' and received_json["command"] == "sendFile":
static.TNC_STATE = 'BUSY'
@@ -191,7 +192,7 @@ class ThreadedTCPRequestHandler(socketserver.BaseRequestHandler):
print(" >>> STOPPING TRANSMISSION <<<")
structlog.get_logger("structlog").warning("[TNC] Stopping transmission!")
static.TNC_STATE = 'IDLE'
- static.ARQ_STATE = 'IDLE'
+ static.ARQ_STATE = False
# SETTINGS AND STATUS ---------------------------------------------
@@ -248,6 +249,7 @@ class ThreadedTCPRequestHandler(socketserver.BaseRequestHandler):
"RX_MSG_BUFFER_LENGTH": str(len(static.RX_MSG_BUFFER)),
"ARQ_BYTES_PER_MINUTE": str(static.ARQ_BYTES_PER_MINUTE),
"ARQ_BYTES_PER_MINUTE_BURST": str(static.ARQ_BYTES_PER_MINUTE_BURST),
+ "ARQ_COMPRESSION_FACTOR": str(static.ARQ_COMPRESSION_FACTOR),
"ARQ_TRANSMISSION_PERCENT": str(static.ARQ_TRANSMISSION_PERCENT),
"TOTAL_BYTES": str(static.TOTAL_BYTES),
"INFO" : static.INFO,
@@ -322,8 +324,7 @@ class ThreadedTCPRequestHandler(socketserver.BaseRequestHandler):
print(exc_type, fname, exc_tb.tb_lineno)
print("############ END OF ERROR #######################")
- print("reset of connection...")
- structlog.get_logger("structlog").warning("[TNC] Stopping transmission!")
+ structlog.get_logger("structlog").warning("[TNC] reset of tcp/ip connection...")
#socketTimeout = 0
structlog.get_logger("structlog").error("[TNC] Network error", e = sys.exc_info()[0])
diff --git a/tnc/static.py b/tnc/static.py
index 10edeb76..90a66d0e 100644
--- a/tnc/static.py
+++ b/tnc/static.py
@@ -43,7 +43,7 @@ HAMLIB_SERIAL_SPEED = '9600'
HAMLIB_PTT_PORT = '/dev/ttyUSB0'
HAMLIB_STOP_BITS = '1'
HAMLIB_DATA_BITS = '8'
-HANLIB_HANDSHAKE = 'None'
+HAMLIB_HANDSHAKE = 'None'
HAMLIB_FREQUENCY = 0
HAMLIB_MODE = ''
@@ -71,12 +71,14 @@ ARQ_BYTES_PER_MINUTE_BURST = 0
ARQ_BYTES_PER_MINUTE = 0
ARQ_BITS_PER_SECOND_BURST = 0
ARQ_BITS_PER_SECOND = 0
+ARQ_COMPRESSION_FACTOR = 0
ARQ_TRANSMISSION_PERCENT = 0
TOTAL_BYTES = 0
+
#CHANNEL_STATE = 'RECEIVING_SIGNALLING'
TNC_STATE = 'IDLE'
-ARQ_STATE = 'IDLE'
+ARQ_STATE = False
# BEACON STATE
BEACON_STATE = False
@@ -85,7 +87,7 @@ BEACON_STATE = False
RX_BUFFER = []
RX_MSG_BUFFER = []
RX_BURST_BUFFER = []
-RX_FRAME_BUFFER = []
+RX_FRAME_BUFFER = b''
#RX_BUFFER_SIZE = 0
# ------- HEARD STATIOS BUFFER