diff --git a/tnc/data_handler.py b/tnc/data_handler.py index 7ed80eb5..d25378cb 100644 --- a/tnc/data_handler.py +++ b/tnc/data_handler.py @@ -35,57 +35,18 @@ detect and use them. ''' +# MODULE GLOBALS - -# MODULE GLOBALS TX/RX - -DATA_CHANNEL_MAX_RETRIES = 3 # N attempts for connecting to another station 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 -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 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 RPT_REQUEST_BUFFER = [] # requested frames, saved in a list - -BURST_ACK_TIMEOUT_SECONDS = 7.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 = False # state for timeout reached -#DATA_FRAME_ACK_TIMEOUT = False # state for timeout reached -RPT_ACK_TIMEOUT = False # state for timeout reached static.ARQ_RX_RPT_TIMEOUT - -# MODULE GLOBALS RX RX_START_OF_TRANSMISSION = 0 # time of transmission start -RX_START_OF_BURST = 0 # time of start of current burst -RX_PAYLOAD_PER_MODEM_FRAME = 0 # payload per moden frame -RX_PAYLOAD_PER_ARQ_FRAME = 0 # payload per arq frame -RX_N_FRAME_OF_BURST = 0 # number of frame per burst -RX_N_FRAMES_PER_BURST = 0 # amount of n frames per burst -RX_N_FRAME_OF_DATA_FRAME = 0 # number of frame per total data frame -RX_N_FRAMES_PER_DATA_FRAME = 0 # amount of n frames per data frame # total number of frames -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" -#static.RX_FRAME_BUFFER = [] # list buffer for data frame -#static.RX_BURST_BUFFER = [] # list buffer for burst - - -# MODULE GLOBALS TX -TX_START_OF_TRANSMISSION = 0 # time of transmission start -TX_PAYLOAD_PER_MODEM_FRAME = 0 # payload per moden frame -TX_PAYLOAD_PER_ARQ_FRAME = 0 # payload per arq frame -#static.TX_BUFFER = [] # buffer for sending data -TX_BUFFER_SIZE = 0 # size of static.TX_BUFFER -TX_N_SENT_FRAMES = 0 # already sent frames per data frame -TX_N_FRAMES_PER_BURST = 0 # amount of n frames per burst -TX_N_RETRIES_PER_BURST = 0 # retries we already sent data -TX_N_MAX_RETRIES_PER_BURST = 3 # max amount of retries we sent before frame is lost - # ################################################ # ARQ DATA HANDLER @@ -94,71 +55,66 @@ TX_N_MAX_RETRIES_PER_BURST = 3 # max amount of retries we sent def arq_data_received(data_in, bytes_per_frame): # we neeed to declare our global variables, so the thread has access to them global RX_START_OF_TRANSMISSION - global RX_START_OF_BURST - global RX_PAYLOAD_PER_MODEM_FRAME - global RX_PAYLOAD_PER_ARQ_FRAME - global RX_N_FRAME_OF_BURST - global RX_N_FRAMES_PER_BURST - global RX_N_FRAME_OF_DATA_FRAME - global RX_N_FRAMES_PER_DATA_FRAME - global RX_FRAME_BOF_RECEIVED - global RX_FRAME_EOF_RECEIVED global DATA_CHANNEL_LAST_RECEIVED - #global static.RX_BURST_BUFFER - #global static.RX_FRAME_BUFFER + global DATA_CHANNEL_READY_FOR_DATA - RX_PAYLOAD_PER_MODEM_FRAME = bytes_per_frame - 2 - RX_PAYLOAD_PER_ARQ_FRAME = RX_PAYLOAD_PER_MODEM_FRAME - 8 + # 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' DATA_CHANNEL_LAST_RECEIVED = int(time.time()) - - + 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 - - - calculate_transfer_rate() + 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) + logging.log(24, "ARQ | RX | " + str(DATA_CHANNEL_MODE) + " | F:[" + str(RX_N_FRAME_OF_BURST) + "/" + str(RX_N_FRAMES_PER_BURST) + "] [" + str(arq_percent_burst).zfill(3) + "%] T:[" + str(RX_N_FRAME_OF_DATA_FRAME) + "/" + str(RX_N_FRAMES_PER_DATA_FRAME) + "] [" + str(arq_percent_frame).zfill(3) + "%] [SNR:" + str(static.SNR) + "]") - # 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 - if RX_N_FRAME_OF_DATA_FRAME == 1: - static.RX_FRAME_BUFFER = [] - - # we 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() - 7 - calculate_transfer_rate() + #if RX_N_FRAME_OF_DATA_FRAME == 1: + # static.RX_FRAME_BUFFER = [] + # + # # we 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() - 7 + # calculate_transfer_rate() #try appending data to frame buffer try: static.RX_FRAME_BUFFER[RX_N_FRAME_OF_DATA_FRAME] = bytes(data_in) 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() - 7 + 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) - RX_FRAME_BOF_RECEIVED = False - RX_FRAME_EOF_RECEIVED = False - - if RX_N_FRAME_OF_BURST == 1: - static.ARQ_START_OF_BURST = time.time() - 6 - calculate_transfer_rate() + #if RX_N_FRAME_OF_BURST == 1: + # static.ARQ_START_OF_BURST = time.time() - 6 + # try appending data to burst buffer try: @@ -267,7 +223,7 @@ def arq_data_received(data_in, bytes_per_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: logging.log(25, "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) # append received frame to RX_BUFFER static.RX_BUFFER.append([static.DXCALLSIGN,static.DXGRID,int(time.time()), complete_data_frame.decode("utf-8")]) @@ -286,39 +242,53 @@ def arq_data_received(data_in, bytes_per_frame): while static.CHANNEL_STATE == 'SENDING_SIGNALLING': time.sleep(0.01) - arq_reset_frame_machine() - + #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') + "] [SNR:" + str(static.SNR) + "]") else: print("ARQ_FRAME_BOF_RECEIVED " + str(RX_FRAME_BOF_RECEIVED)) print("ARQ_FRAME_EOF_RECEIVED " + str(RX_FRAME_EOF_RECEIVED)) print(static.RX_FRAME_BUFFER) + 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) logging.error("ARQ | RX | DATA FRAME NOT SUCESSFULLY RECEIVED!") - - arq_reset_frame_machine() + + + # STATE CLEANUP + #arq_reset_frame_machine() + static.TNC_STATE = 'IDLE' + static.ARQ_STATE = 'IDLE' + DATA_CHANNEL_READY_FOR_DATA = False logging.info("DATA [" + str(static.MYCALLSIGN, 'utf-8') + "]<>[" + str(static.DXCALLSIGN, 'utf-8') + "] [SNR:" + str(static.SNR) + "]") -def arq_transmit(data_out): +def arq_transmit(data_out, mode, n_frames_per_burst): - #global TX_PAYLOAD_PER_MODEM_FRAME - global TX_PAYLOAD_PER_ARQ_FRAME - #static.TX_BUFFER - global TX_BUFFER_SIZE - global TX_N_SENT_FRAMES - global TX_N_FRAMES_PER_BURST - global TX_N_RETRIES_PER_BURST - global TX_N_MAX_RETRIES_PER_BURST global RPT_REQUEST_BUFFER global DATA_FRAME_ACK_RECEIVED global RPT_REQUEST_RECEIVED global BURST_ACK_RECEIVED - global DATA_CHANNEL_MODE - global TX_START_OF_TRANSMISSION + #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 + + TX_N_SENT_FRAMES = 0 # already sent frames 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 + + BURST_ACK_TIMEOUT_SECONDS = 7.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 + + # 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 @@ -337,7 +307,7 @@ def arq_transmit(data_out): TX_PAYLOAD_PER_ARQ_FRAME = payload_per_frame - 8 frame_header_length = 6 - n_arq_frames_per_data_frame = (len(data_out) + frame_header_length) // TX_PAYLOAD_PER_ARQ_FRAME + ((len(data_out) + frame_header_length) % TX_PAYLOAD_PER_ARQ_FRAME > 0) + #n_arq_frames_per_data_frame = (len(data_out) + frame_header_length) // TX_PAYLOAD_PER_ARQ_FRAME + ((len(data_out) + frame_header_length) % TX_PAYLOAD_PER_ARQ_FRAME > 0) frame_payload_crc = helpers.get_crc_16(data_out) @@ -347,8 +317,8 @@ def arq_transmit(data_out): # 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 - static.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(static.TX_BUFFER) + 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) logging.info("ARQ | TX | M:" + str(DATA_CHANNEL_MODE) + " | DATA FRAME --- BYTES: " + str(len(data_out)) + " ARQ FRAMES: " + str(TX_BUFFER_SIZE)) @@ -359,8 +329,8 @@ def arq_transmit(data_out): # ----------- CREATE FRAME TOTAL PAYLOAD TO BE ABLE TO CREATE CRC FOR IT try: # DETECT IF LAST BURST TO PREVENT INDEX ERROR OF BUFFER - for i in range(TX_N_FRAMES_PER_BURST): # Loop through static.TX_BUFFER LIST - len(static.TX_BUFFER[TX_N_SENT_FRAMES + i]) # we calculate the length to trigger a list index error + 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! @@ -377,12 +347,13 @@ def arq_transmit(data_out): 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() + #calculate_transfer_rate() + calculate_transfer_rate_tx(TX_N_SENT_FRAMES, TX_PAYLOAD_PER_ARQ_FRAME, TX_START_OF_TRANSMISSION, TX_BUFFER_SIZE) logging.log(24, "ARQ | TX | M:" + str(DATA_CHANNEL_MODE) + " | F:[" + str(TX_N_SENT_FRAMES + 1) + "-" + str(TX_N_SENT_FRAMES + TX_N_FRAMES_PER_BURST) + "] | T:[" + str(TX_N_SENT_FRAMES) + "/" + str(TX_BUFFER_SIZE) + "] [" + str(int(TX_N_SENT_FRAMES / (TX_BUFFER_SIZE) * 100)).zfill(3) + "%] | A:[" + str(TX_N_RETRIES_PER_BURST + 1) + "/" + str(TX_N_MAX_RETRIES_PER_BURST) + "]") # lets refresh all timers and ack states before sending a new frame arq_reset_ack(False) - #arq_reset_timeout(False) + # ---------------------------BUILD ARQ BURST --------------------------------------------------------------------- tempbuffer = [] @@ -390,10 +361,10 @@ def arq_transmit(data_out): for n in range(0, TX_N_FRAMES_PER_BURST): frame_type = 10 + n + 1 frame_type = bytes([frame_type]) - payload_data = bytes(static.TX_BUFFER[TX_N_SENT_FRAMES + n]) + 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(static.TX_BUFFER) + n_total_arq_frame = len(TX_BUFFER) #static.ARQ_TX_N_TOTAL_ARQ_FRAMES = n_total_arq_frame arqframe = frame_type + \ @@ -405,13 +376,13 @@ def arq_transmit(data_out): payload_data tempbuffer.append(arqframe) - print(tempbuffer) - modem.transmit_arq_burst(DATA_CHANNEL_MODE, tempbuffer) - - - # lets wait during sending. After sending is finished we will continue - while static.CHANNEL_STATE == 'SENDING_DATA': + + while not modem.transmit_arq_burst(DATA_CHANNEL_MODE, tempbuffer): time.sleep(0.01) + + ## lets wait during sending. After sending is finished we will continue + #while static.CHANNEL_STATE == 'SENDING_DATA': + # time.sleep(0.01) # --------------------------- START TIMER FOR WAITING FOR ACK ---> IF TIMEOUT REACHED, ACK_TIMEOUT = 1 @@ -437,15 +408,15 @@ def arq_transmit(data_out): frame_type = bytes([frame_type]) try: - payload_data = bytes(static.TX_BUFFER[TX_N_SENT_FRAMES + missing_frame - 1]) + payload_data = bytes(TX_BUFFER[TX_N_SENT_FRAMES + missing_frame - 1]) except: print("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(static.TX_BUFFER) - #static.ARQ_TX_N_TOTAL_ARQ_FRAMES = n_total_arq_frame + n_total_arq_frame = len(TX_BUFFER) + arqframe = frame_type + \ bytes([TX_N_FRAMES_PER_BURST]) + \ @@ -456,22 +427,21 @@ def arq_transmit(data_out): payload_data tempbuffer.append(arqframe) - modem.transmit_arq_burst(DATA_CHANNEL_MODE, tempbuffer) + while not modem.transmit_arq_burst(DATA_CHANNEL_MODE, tempbuffer): + time.sleep(0.01) # lets wait during sending. After sending is finished we will continue - while static.ARQ_STATE == 'SENDING_DATA': - time.sleep(0.01) - static.CHANNEL_STATE = 'RECEIVING_SIGNALLING' + #while static.ARQ_STATE == 'SENDING_DATA': + # time.sleep(0.01) + #static.CHANNEL_STATE = 'RECEIVING_SIGNALLING' - arq_reset_timeout(False) arq_reset_ack(False) rpttimeout = time.time() + RPT_ACK_TIMEOUT_SECONDS while not BURST_ACK_RECEIVED and not DATA_FRAME_ACK_RECEIVED and time.time() < rpttimeout: time.sleep(0.01) # lets reduce CPU load a little bit - #logging.info(static.ARQ_STATE) if BURST_ACK_RECEIVED: logging.info("ARQ | RX | ACK AFTER RPT") @@ -486,7 +456,6 @@ def arq_transmit(data_out): # 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: logging.info("ARQ | RX | EARLY FRAME ACK RECEIVED #2") @@ -505,7 +474,7 @@ def arq_transmit(data_out): # -----------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 - transfer_rates = calculate_transfer_rate() + transfer_rates = 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(transfer_rates[2]) + " bit/s | " + str(transfer_rates[3]) + " B/min]") @@ -548,7 +517,14 @@ def arq_transmit(data_out): #logging.info("RATE (DATA/ACK) :[" + str(transfer_rates[0]) + " bit/s | " + str(transfer_rates[1]) + " B/min]") logging.info("ARQ | TX | BUFFER EMPTY") - arq_reset_frame_machine() + # 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 + 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... @@ -597,13 +573,8 @@ def burst_rpt_received(data_in): def open_dc_and_transmit(data_out, mode, n_frames_per_burst): global DATA_CHANNEL_READY_FOR_DATA - global TX_N_FRAMES_PER_BURST - - if not DATA_CHANNEL_READY_FOR_DATA: - # we open the datachannel with the mode, selected from GUI - TX_N_FRAMES_PER_BURST = n_frames_per_burst - - asyncio.run(arq_open_data_channel(mode)) + + asyncio.run(arq_open_data_channel(mode)) # wait until data channel is open while not DATA_CHANNEL_READY_FOR_DATA: time.sleep(0.01) @@ -614,19 +585,18 @@ def open_dc_and_transmit(data_out, mode, n_frames_per_burst): pass # transmit data - arq_transmit(data_out) + arq_transmit(data_out, mode, n_frames_per_burst) async def arq_open_data_channel(mode): - global DATA_CHANNEL_MODE + global DATA_CHANNEL_READY_FOR_DATA global DATA_CHANNEL_LAST_RECEIVED + DATA_CHANNEL_MAX_RETRIES = 3 # N attempts for connecting to another station + DATA_CHANNEL_MODE = int(mode) DATA_CHANNEL_LAST_RECEIVED = int(time.time()) - - while static.CHANNEL_STATE == 'SENDING_SIGNALLING': - time.sleep(0.01) connection_frame = bytearray(14) connection_frame[:1] = bytes([225]) @@ -636,29 +606,32 @@ async def arq_open_data_channel(mode): connection_frame[12:13] = bytes([DATA_CHANNEL_MODE]) while not DATA_CHANNEL_READY_FOR_DATA: - for attempt in range(0,DATA_CHANNEL_MAX_RETRIES): - logging.info("DATA [" + str(static.MYCALLSIGN, 'utf-8') + "]>> <<[" + str(static.DXCALLSIGN, 'utf-8') + "] A:[" + str(attempt + 1) + "/" + str(DATA_CHANNEL_MAX_RETRIES) + "]") - modem.transmit_signalling(connection_frame, 1) - while static.CHANNEL_STATE == 'SENDING_SIGNALLING': + time.sleep(0.01) + for attempt in range(1,DATA_CHANNEL_MAX_RETRIES+1): + logging.info("DATA [" + str(static.MYCALLSIGN, 'utf-8') + "]>> <<[" + str(static.DXCALLSIGN, 'utf-8') + "] A:[" + str(attempt) + "/" + str(DATA_CHANNEL_MAX_RETRIES) + "]") + while not modem.transmit_signalling(connection_frame, 1): time.sleep(0.01) - + timeout = time.time() + 5 while time.time() < timeout: + time.sleep(0.01) # break if data channel is openend if DATA_CHANNEL_READY_FOR_DATA: break if DATA_CHANNEL_READY_FOR_DATA: break + print("attempt:" + str(attempt) + "/" + str(DATA_CHANNEL_MAX_RETRIES)) - if not DATA_CHANNEL_READY_FOR_DATA and attempt + 1 == DATA_CHANNEL_MAX_RETRIES: + if not DATA_CHANNEL_READY_FOR_DATA and attempt == DATA_CHANNEL_MAX_RETRIES: logging.info("DATA [" + str(static.MYCALLSIGN, 'utf-8') + "]>>X<<[" + str(static.DXCALLSIGN, 'utf-8') + "]") - arq_reset_frame_machine() - sys.exit() + static.TNC_STATE = 'IDLE' + static.ARQ_STATE = 'IDLE' + sys.exit() # close thread and so connection attempts def arq_received_data_channel_opener(data_in): - global DATA_CHANNEL_MODE + #global DATA_CHANNEL_MODE global DATA_CHANNEL_LAST_RECEIVED static.DXCALLSIGN_CRC8 = bytes(data_in[2:3]).rstrip(b'\x00') @@ -670,7 +643,7 @@ def arq_received_data_channel_opener(data_in): static.ARQ_STATE = 'DATA' static.TNC_STATE = 'BUSY' - DATA_CHANNEL_MODE = int.from_bytes(bytes(data_in[12:13]), "big") + mode = int.from_bytes(bytes(data_in[12:13]), "big") DATA_CHANNEL_LAST_RECEIVED = int(time.time()) @@ -679,14 +652,14 @@ 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([DATA_CHANNEL_MODE]) + connection_frame[12:13] = bytes([mode]) modem.transmit_signalling(connection_frame, 2) - while static.CHANNEL_STATE == 'SENDING_SIGNALLING': + while not modem.transmit_signalling(connection_frame, 2): time.sleep(0.01) - logging.info("DATA [" + str(static.MYCALLSIGN, 'utf-8') + "]>>|<<[" + str(static.DXCALLSIGN, 'utf-8') + "] [SNR:" + str(static.SNR) + "]") + logging.info("DATA [" + str(static.MYCALLSIGN, 'utf-8') + "]>>|<<[" + str(static.DXCALLSIGN, 'utf-8') + "] [M:"+str(mode)+"] SNR:" + str(static.SNR) + "]") wait_until_receive_data = time.time() + 1 while time.time() < wait_until_receive_data: @@ -699,6 +672,7 @@ def arq_received_channel_is_open(data_in): global DATA_CHANNEL_LAST_RECEIVED global DATA_CHANNEL_READY_FOR_DATA + global DATA_CHANNEL_MODE static.DXCALLSIGN_CRC8 = bytes(data_in[2:3]).rstrip(b'\x00') static.DXCALLSIGN = bytes(data_in[3:9]).rstrip(b'\x00') @@ -716,7 +690,9 @@ def arq_received_channel_is_open(data_in): DATA_CHANNEL_LAST_RECEIVED = int(time.time()) else: print("wrong mode received...") - + static.ARQ_STATE = 'DATA' + DATA_CHANNEL_READY_FOR_DATA = True + DATA_CHANNEL_LAST_RECEIVED = int(time.time()) # ############################################################################################################ # PING HANDLER @@ -734,8 +710,7 @@ def transmit_ping(callsign): ping_frame[3:9] = static.MYCALLSIGN # wait while sending.... - modem.transmit_signalling(ping_frame, 1) - while static.CHANNEL_STATE == 'SENDING_SIGNALLING': + while not modem.transmit_signalling(ping_frame, 1): time.sleep(0.01) @@ -753,9 +728,7 @@ def received_ping(data_in): ping_frame[3:9] = static.MYGRID # wait while sending.... - modem.transmit_signalling(ping_frame, 1) - - while static.CHANNEL_STATE == 'SENDING_SIGNALLING': + while not modem.transmit_signalling(ping_frame, 1): time.sleep(0.01) @@ -796,18 +769,6 @@ def received_cq(data_in): helpers.add_to_heard_stations(dxcallsign,dxgrid, 'CQ CQ CQ', static.SNR) -def arq_reset_timeout(state): - """ - Author: DJ2LS - """ - #global BURST_ACK_TIMEOUT - #global DATA_FRAME_ACK_TIMEOUT - global RPT_ACK_TIMEOUT - - #BURST_ACK_TIMEOUT = state - #DATA_FRAME_ACK_TIMEOUT = state - RPT_ACK_TIMEOUT = state - def arq_reset_ack(state): """ Author: DJ2LS @@ -821,145 +782,92 @@ def arq_reset_ack(state): DATA_FRAME_ACK_RECEIVED = state -def arq_reset_frame_machine(): - """ - Author: DJ2LS - - Reset the frame machine parameters to default, - so we need to call just a function - - """ - global DATA_CHANNEL_READY_FOR_DATA - global DATA_CHANNEL_LAST_RECEIVED - global DATA_CHANNEL_MODE - - global BURST_ACK_RECEIVED - global DATA_FRAME_ACK_RECEIVED - global RPT_REQUEST_RECEIVED - global RPT_REQUEST_BUFFER - - - # global BURST_ACK_TIMEOUT - # global DATA_FRAME_ACK_TIMEOUT - global RPT_ACK_TIMEOUT - - global RX_START_OF_TRANSMISSION - global RX_START_OF_BURST - global RX_PAYLOAD_PER_MODEM_FRAME - global RX_PAYLOAD_PER_ARQ_FRAME - global RX_N_FRAME_OF_BURST - global RX_N_FRAMES_PER_BURST - global RX_N_FRAME_OF_DATA_FRAME - global RX_N_FRAMES_PER_DATA_FRAME - global RX_FRAME_BOF_RECEIVED - global RX_FRAME_EOF_RECEIVED - #global static.RX_FRAME_BUFFER - - global TX_PAYLOAD_PER_MODEM_FRAME - global TX_PAYLOAD_PER_ARQ_FRAME - global TX_BUFFER_SIZE - global TX_N_SENT_FRAMES - global TX_N_FRAMES_PER_BURST - global TX_N_RETRIES_PER_BURST - global TX_START_OF_TRANSMISSION - - DATA_CHANNEL_READY_FOR_DATA = False - DATA_CHANNEL_LAST_RECEIVED = 0.0 - DATA_CHANNEL_MODE = 0 - - BURST_ACK_RECEIVED = False - DATA_FRAME_ACK_RECEIVED = False - RPT_REQUEST_RECEIVED = False - RPT_REQUEST_BUFFER = [] - - #BURST_ACK_TIMEOUT = False - #DATA_FRAME_ACK_TIMEOUT = False - RPT_ACK_TIMEOUT = False - - RX_START_OF_TRANSMISSION = 0 - RX_START_OF_BURST = 0 - RX_PAYLOAD_PER_MODEM_FRAME = 0 - RX_PAYLOAD_PER_ARQ_FRAME = 0 - RX_N_FRAME_OF_BURST = 0 - RX_N_FRAMES_PER_BURST = 0 - RX_N_FRAME_OF_DATA_FRAME = 0 - RX_N_FRAMES_PER_DATA_FRAME = 0 - RX_FRAME_BOF_RECEIVED = False - RX_FRAME_EOF_RECEIVED = False - - # MODULE GLOBALS TX - TX_PAYLOAD_PER_MODEM_FRAME = 0 - TX_PAYLOAD_PER_ARQ_FRAME = 0 - #static.TX_BUFFER = [] # buffer for sending data - TX_BUFFER_SIZE = 0 - TX_N_SENT_FRAMES = 0 - TX_N_FRAMES_PER_BURST = 0 - TX_N_RETRIES_PER_BURST = 0 - TX_START_OF_TRANSMISSION = 0 - - arq_reset_timeout(False) - arq_reset_ack(False) - - static.RX_BURST_BUFFER = [] - static.RX_FRAME_BUFFER = [] - - static.TNC_STATE = 'IDLE' - static.ARQ_STATE = 'IDLE' - static.CHANNEL_STATE = 'RECEIVING_SIGNALLING' - - - -def calculate_transfer_rate(): - global TX_N_SENT_FRAMES - global RX_N_FRAMES_PER_DATA_FRAME - global RX_N_FRAME_OF_DATA_FRAME - global RX_N_FRAME_OF_DATA_FRAME - global RX_START_OF_TRANSMISSION - global TX_START_OF_TRANSMISSION - global DATA_CHANNEL_LAST_RECEIVED - global TX_PAYLOAD_PER_ARQ_FRAME - global RX_PAYLOAD_PER_ARQ_FRAME - - # CALCULATION FOR TRANSMITTING - if len(static.TX_BUFFER) > 0: - static.ARQ_TRANSMISSION_PERCENT = int((TX_N_SENT_FRAMES / len(static.TX_BUFFER)) * 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 = DATA_CHANNEL_LAST_RECEIVED - TX_START_OF_TRANSMISSION - if TX_N_SENT_FRAMES > 0: - sendbytes = TX_N_SENT_FRAMES * TX_PAYLOAD_PER_ARQ_FRAME - - static.ARQ_BITS_PER_SECOND = (sendbytes*8) / transmissiontime - static.ARQ_BYTES_PER_MINUTE = int((sendbytes) / (transmissiontime/60)) - - else: - - - static.ARQ_BITS_PER_SECOND = 0 - static.ARQ_BYTES_PER_MINUTE = 0 - - - - # CALCULATION FOR RECEIVING - elif RX_N_FRAMES_PER_DATA_FRAME > 0: - 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 + transmissiontime = time.time() - rx_start_of_transmission + receivedbytes = rx_n_frame_of_data_frame * rx_payload_per_arq_frame static.ARQ_BITS_PER_SECOND = int((receivedbytes*8) / transmissiontime) static.ARQ_BYTES_PER_MINUTE = int((receivedbytes) / (transmissiontime/60)) - else: + except: static.ARQ_TRANSMISSION_PERCENT = 0.0 static.ARQ_BITS_PER_SECOND = 0 static.ARQ_BYTES_PER_MINUTE = 0 static.ARQ_BITS_PER_SECOND_BURST = 0 static.ARQ_BYTES_PER_MINUTE_BURST = 0 - - - - - return [static.ARQ_BITS_PER_SECOND, static.ARQ_BYTES_PER_MINUTE, static.ARQ_BITS_PER_SECOND_BURST, static.ARQ_BYTES_PER_MINUTE_BURST, static.ARQ_TRANSMISSION_PERCENT] + + return [static.ARQ_BITS_PER_SECOND, \ + static.ARQ_BYTES_PER_MINUTE, \ + static.ARQ_BITS_PER_SECOND_BURST, \ + static.ARQ_BYTES_PER_MINUTE_BURST, \ + static.ARQ_TRANSMISSION_PERCENT] + + + + +def calculate_transfer_rate_tx(tx_n_sent_frames, tx_payload_per_arq_frame, tx_start_of_transmission, tx_buffer_length): + try: + static.ARQ_TRANSMISSION_PERCENT = int((tx_n_sent_frames / 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 + + static.ARQ_BITS_PER_SECOND = (sendbytes*8) / transmissiontime + static.ARQ_BYTES_PER_MINUTE = int((sendbytes) / (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 + static.ARQ_BYTES_PER_MINUTE = 0 + static.ARQ_BITS_PER_SECOND_BURST = 0 + static.ARQ_BYTES_PER_MINUTE_BURST = 0 + + return [static.ARQ_BITS_PER_SECOND, \ + static.ARQ_BYTES_PER_MINUTE, \ + static.ARQ_BITS_PER_SECOND_BURST, \ + static.ARQ_BYTES_PER_MINUTE_BURST, \ + static.ARQ_TRANSMISSION_PERCENT] + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + # WATCHDOG FUNCTIONS @@ -990,8 +898,9 @@ def data_channel_keep_alive_watchdog(): 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() - + #arq_reset_frame_machine() + static.TNC_STATE = 'IDLE' + static.ARQ_STATE = 'IDLE' # START THE THREAD FOR THE TIMEOUT WATCHDOG WATCHDOG_SERVER_THREAD = threading.Thread(target=watchdog, name="watchdog") @@ -1002,3 +911,4 @@ WATCHDOG_SERVER_THREAD.start() + diff --git a/tnc/modem.py b/tnc/modem.py index aa3c415c..2c67c443 100644 --- a/tnc/modem.py +++ b/tnc/modem.py @@ -224,9 +224,10 @@ class RF(): state_before_transmit = static.CHANNEL_STATE static.CHANNEL_STATE = 'SENDING_SIGNALLING' # print(static.CHANNEL_STATE) - + freedv_signalling_mode = 14 + self.c_lib.freedv_open.restype = ctypes.POINTER(ctypes.c_ubyte) - freedv = self.c_lib.freedv_open(static.FREEDV_SIGNALLING_MODE) + freedv = self.c_lib.freedv_open(freedv_signalling_mode) bytes_per_frame = int(self.c_lib.freedv_get_bits_per_modem_frame(freedv) / 8) payload_per_frame = bytes_per_frame - 2 n_nom_modem_samples = self.c_lib.freedv_get_n_nom_modem_samples(freedv) @@ -286,7 +287,8 @@ class RF(): static.CHANNEL_STATE = state_before_transmit self.c_lib.freedv_close(freedv) - + + return True # -------------------------------------------------------------------------------------------------------- # GET ARQ BURST FRAME VOM BUFFER AND MODULATE IT @@ -369,13 +371,19 @@ class RF(): # close codec2 instance self.c_lib.freedv_close(freedv) + + return True # -------------------------------------------------------------------------------------------------------- def receive(self): - + + freedv_mode_datac0 = 14 + freedv_mode_datac1 = 10 + freedv_mode_datac3 = 12 + # DATAC0 self.c_lib.freedv_open.restype = ctypes.POINTER(ctypes.c_ubyte) - datac0_freedv = self.c_lib.freedv_open(14) + datac0_freedv = self.c_lib.freedv_open(freedv_mode_datac0) self.c_lib.freedv_get_bits_per_modem_frame(datac0_freedv) datac0_bytes_per_frame = int(self.c_lib.freedv_get_bits_per_modem_frame(datac0_freedv)/8) datac0_n_max_modem_samples = self.c_lib.freedv_get_n_max_modem_samples(datac0_freedv) @@ -394,7 +402,7 @@ class RF(): # DATAC1 self.c_lib.freedv_open.restype = ctypes.POINTER(ctypes.c_ubyte) - datac1_freedv = self.c_lib.freedv_open(10) + datac1_freedv = self.c_lib.freedv_open(freedv_mode_datac1) datac1_bytes_per_frame = int(self.c_lib.freedv_get_bits_per_modem_frame(datac1_freedv)/8) datac1_n_max_modem_samples = self.c_lib.freedv_get_n_max_modem_samples(datac1_freedv) # bytes_per_frame @@ -407,7 +415,7 @@ class RF(): # DATAC3 self.c_lib.freedv_open.restype = ctypes.POINTER(ctypes.c_ubyte) - datac3_freedv = self.c_lib.freedv_open(12) + datac3_freedv = self.c_lib.freedv_open(freedv_mode_datac3) datac3_bytes_per_frame = int(self.c_lib.freedv_get_bits_per_modem_frame(datac3_freedv)/8) datac3_n_max_modem_samples = self.c_lib.freedv_get_n_max_modem_samples(datac3_freedv) # bytes_per_frame @@ -429,7 +437,7 @@ class RF(): self.c_lib.freedv_set_frames_per_burst(freedv, 0) ''' - while static.FREEDV_RECEIVE == True: + while True: ''' # refresh vars, so the correct parameters of the used mode are set @@ -687,3 +695,4 @@ class RF(): print("setting fft = 0") # else 0 static.FFT = [0] * 400 + diff --git a/tnc/sock.py b/tnc/sock.py index b4567ef4..8be71f1d 100644 --- a/tnc/sock.py +++ b/tnc/sock.py @@ -270,3 +270,4 @@ def start_cmd_socket(): exc_type, exc_obj, exc_tb = sys.exc_info() fname = os.path.split(exc_tb.tb_frame.f_code.co_filename)[1] print(exc_type, fname, exc_tb.tb_lineno) + diff --git a/tnc/static.py b/tnc/static.py index 09597203..fe50ad2a 100644 --- a/tnc/static.py +++ b/tnc/static.py @@ -4,6 +4,8 @@ Created on Wed Dec 23 11:13:57 2020 @author: DJ2LS +Here we are saving application wide variables and stats, which have to be accessed everywhere. +Not nice, tipps are appreciated :-) """ # DAEMON @@ -44,14 +46,6 @@ HAMLIB_MODE = '' HAMLIB_BANDWITH = 0 # ------------------------- # FreeDV Defaults -FREEDV_RECEIVE = True - -FREEDV_SIGNALLING_MODE = 14 - -#FREEDV_DATA_BYTES_PER_FRAME = 0 -#FREEDV_DATA_PAYLOAD_PER_FRAME = 0 -#FREEDV_SIGNALLING_BYTES_PER_FRAME = 0 -#FREEDV_SIGNALLING_PAYLOAD_PER_FRAME = 0 BER = 0 SNR = 0 @@ -80,10 +74,11 @@ ARQ_BITS_PER_SECOND = 0 ARQ_TRANSMISSION_PERCENT = 0 TOTAL_BYTES = 0 +CHANNEL_STATE = 'RECEIVING_SIGNALLING' +TNC_STATE = 'IDLE' +ARQ_STATE = 'IDLE' + -# ------- TX BUFFER -#TX_BUFFER_SIZE = 0 -TX_BUFFER = [] # ------- RX BUFFER RX_BUFFER = [] RX_BURST_BUFFER = []