From 36b7ac91f8088af8f79c2f127657676f12c614ca Mon Sep 17 00:00:00 2001 From: DJ2LS <75909252+DJ2LS@users.noreply.github.com> Date: Fri, 12 Mar 2021 14:14:36 +0100 Subject: [PATCH] smaller PEP8 cleanup --- data_handler.py | 1106 ++++++++++++++++++++++++----------------------- helpers.py | 103 +++-- main.py | 20 +- modem.py | 447 ++++++++++--------- sock.py | 134 +++--- static.py | 88 ++-- 6 files changed, 939 insertions(+), 959 deletions(-) diff --git a/data_handler.py b/data_handler.py index 8a4d8f69..8e7b78ec 100644 --- a/data_handler.py +++ b/data_handler.py @@ -6,6 +6,7 @@ Created on Sun Dec 27 20:43:40 2020 @author: DJ2LS """ + import logging import threading import time @@ -15,502 +16,492 @@ import sys import static import modem -modem = modem.RF() import helpers +modem = modem.RF() - - -############################################################################################################# +# ############################################################################################################ # ARQ DATA HANDLER -############################################################################################################# +# ############################################################################################################ + - def arq_data_received(data_in): - static.TNC_STATE = 'BUSY' + static.TNC_STATE = 'BUSY' - static.ARQ_N_FRAME = int.from_bytes(bytes(data_in[:1]), "big") - 10 #get number of burst frame - static.ARQ_N_RX_FRAMES_PER_BURSTS = int.from_bytes(bytes(data_in[1:2]), "big") #get number of bursts from received frame - static.ARQ_RX_N_CURRENT_ARQ_FRAME = int.from_bytes(bytes(data_in[2:4]), "big") #get current number of total frames - static.ARQ_N_ARQ_FRAMES_PER_DATA_FRAME = int.from_bytes(bytes(data_in[4:6]), "big") # get get total number of frames - - logging.debug("----------------------------------------------------------------") - logging.debug("ARQ_N_FRAME: " + str(static.ARQ_N_FRAME)) - logging.debug("ARQ_N_RX_FRAMES_PER_BURSTS: " + str(static.ARQ_N_RX_FRAMES_PER_BURSTS)) - logging.debug("ARQ_RX_N_CURRENT_ARQ_FRAME: " + str(static.ARQ_RX_N_CURRENT_ARQ_FRAME)) - logging.debug("ARQ_N_ARQ_FRAMES_PER_DATA_FRAME: " + str(static.ARQ_N_ARQ_FRAMES_PER_DATA_FRAME)) - logging.debug("----------------------------------------------------------------") + static.ARQ_N_FRAME = int.from_bytes(bytes(data_in[:1]), "big") - 10 # get number of burst frame + static.ARQ_N_RX_FRAMES_PER_BURSTS = int.from_bytes(bytes(data_in[1:2]), "big") # get number of bursts from received frame + static.ARQ_RX_N_CURRENT_ARQ_FRAME = int.from_bytes(bytes(data_in[2:4]), "big") # get current number of total frames + static.ARQ_N_ARQ_FRAMES_PER_DATA_FRAME = int.from_bytes(bytes(data_in[4:6]), "big") # get get total number of frames - arq_percent_burst = int((static.ARQ_N_FRAME / static.ARQ_N_RX_FRAMES_PER_BURSTS)*100) - arq_percent_frame = int(((static.ARQ_RX_N_CURRENT_ARQ_FRAME)/static.ARQ_N_ARQ_FRAMES_PER_DATA_FRAME)*100) - - logging.log(24, "ARQ | RX | " + str(static.ARQ_DATA_CHANNEL_MODE) + " | F:[" + str(static.ARQ_N_FRAME) + "/" + str(static.ARQ_N_RX_FRAMES_PER_BURSTS) + "] [" + str(arq_percent_burst).zfill(3) + "%] T:[" + str(static.ARQ_RX_N_CURRENT_ARQ_FRAME) + "/" + str(static.ARQ_N_ARQ_FRAMES_PER_DATA_FRAME) + "] [" + str(arq_percent_frame).zfill(3) + "%] [BER."+str(static.BER)+"]" ) - - #allocate ARQ_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 static.ARQ_RX_N_CURRENT_ARQ_FRAME == 1: - static.ARQ_RX_FRAME_BUFFER = [] + logging.debug("----------------------------------------------------------------") + logging.debug("ARQ_N_FRAME: " + str(static.ARQ_N_FRAME)) + logging.debug("ARQ_N_RX_FRAMES_PER_BURSTS: " + str(static.ARQ_N_RX_FRAMES_PER_BURSTS)) + logging.debug("ARQ_RX_N_CURRENT_ARQ_FRAME: " + str(static.ARQ_RX_N_CURRENT_ARQ_FRAME)) + logging.debug("ARQ_N_ARQ_FRAMES_PER_DATA_FRAME: " + str(static.ARQ_N_ARQ_FRAMES_PER_DATA_FRAME)) + logging.debug("----------------------------------------------------------------") - try: - static.ARQ_RX_FRAME_BUFFER[static.ARQ_RX_N_CURRENT_ARQ_FRAME] = bytes(data_in) + arq_percent_burst = int((static.ARQ_N_FRAME / static.ARQ_N_RX_FRAMES_PER_BURSTS) * 100) + arq_percent_frame = int(((static.ARQ_RX_N_CURRENT_ARQ_FRAME) / static.ARQ_N_ARQ_FRAMES_PER_DATA_FRAME) * 100) - except IndexError: + logging.log(24, "ARQ | RX | " + str(static.ARQ_DATA_CHANNEL_MODE) + " | F:[" + str(static.ARQ_N_FRAME) + "/" + str(static.ARQ_N_RX_FRAMES_PER_BURSTS) + "] [" + str(arq_percent_burst).zfill(3) + "%] T:[" + str(static.ARQ_RX_N_CURRENT_ARQ_FRAME) + "/" + str(static.ARQ_N_ARQ_FRAMES_PER_DATA_FRAME) + "] [" + str(arq_percent_frame).zfill(3) + "%] [BER." + str(static.BER) + "]") - static.ARQ_RX_FRAME_BUFFER = [] - for i in range(0,static.ARQ_N_ARQ_FRAMES_PER_DATA_FRAME+1): - static.ARQ_RX_FRAME_BUFFER.insert(i,None) - - static.ARQ_RX_FRAME_BUFFER[static.ARQ_RX_N_CURRENT_ARQ_FRAME] = bytes(data_in) - static.ARQ_FRAME_BOF_RECEIVED = False - static.ARQ_FRAME_EOF_RECEIVED = False + # allocate ARQ_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 static.ARQ_RX_N_CURRENT_ARQ_FRAME == 1: + static.ARQ_RX_FRAME_BUFFER = [] + + try: + static.ARQ_RX_FRAME_BUFFER[static.ARQ_RX_N_CURRENT_ARQ_FRAME] = bytes(data_in) + + except IndexError: + + static.ARQ_RX_FRAME_BUFFER = [] + for i in range(0, static.ARQ_N_ARQ_FRAMES_PER_DATA_FRAME + 1): + static.ARQ_RX_FRAME_BUFFER.insert(i, None) + + static.ARQ_RX_FRAME_BUFFER[static.ARQ_RX_N_CURRENT_ARQ_FRAME] = bytes(data_in) + static.ARQ_FRAME_BOF_RECEIVED = False + static.ARQ_FRAME_EOF_RECEIVED = False + + try: + static.ARQ_RX_BURST_BUFFER[static.ARQ_N_FRAME] = bytes(data_in) + + except IndexError: + + static.ARQ_RX_BURST_BUFFER = [] + for i in range(0, static.ARQ_N_RX_FRAMES_PER_BURSTS + 1): + static.ARQ_RX_BURST_BUFFER.insert(i, None) + + static.ARQ_RX_BURST_BUFFER[static.ARQ_N_FRAME] = bytes(data_in) + +# - ------------------------- ARQ BURST CHECKER + # run only if we recieved all ARQ FRAMES per ARQ BURST + if static.ARQ_RX_BURST_BUFFER.count(None) == 1: # count nones + logging.info("ARQ | TX | BURST ACK") + + # BUILDING ACK FRAME FOR BURST ----------------------------------------------- + # ack_payload = b'ACK' + # ack_frame = b'<' + ack_payload # < = 60 + + ack_frame = bytearray(14) + ack_frame[:1] = bytes([60]) + ack_frame[1:2] = static.DXCALLSIGN_CRC8 + ack_frame[2:3] = static.MYCALLSIGN_CRC8 + # print(ack_frame) + # TRANSMIT ACK FRAME FOR BURST----------------------------------------------- + modem.transmit_signalling(ack_frame) + while static.CHANNEL_STATE == 'SENDING_SIGNALLING': + time.sleep(0.01) + static.CHANNEL_STATE = 'RECEIVING_DATA' + # TRANSMIT_ARQ_ACK_THREAD = threading.Thread(target=modem.transmit_arq_ack, args=[ack_frame], name="TRANSMIT_ARQ_BURST") + # TRANSMIT_ARQ_ACK_THREAD.start() + # while static.ARQ_STATE == 'SENDING_ACK': + # pass + # clear burst buffer + static.ARQ_RX_BURST_BUFFER = [] + + # if decoded N frames are unequal to expected frames per burst + elif static.ARQ_N_FRAME == static.ARQ_N_RX_FRAMES_PER_BURSTS and static.ARQ_RX_BURST_BUFFER.count(None) != 1: + + # --------------- CHECK WHICH BURST FRAMES WE ARE MISSING ------------------------------------------- + missing_frames = b'' + for burstnumber in range(1, len(static.ARQ_RX_BURST_BUFFER)): + + if static.ARQ_RX_BURST_BUFFER[burstnumber] == None: + # frame_number = static.ARQ_RX_N_CURRENT_ARQ_FRAME - static.ARQ_N_RX_FRAMES_PER_BURSTS + burstnumber + # logging.debug("frame_number" + str(frame_number)) + logging.debug("static.ARQ_RX_N_CURRENT_ARQ_FRAME" + str(static.ARQ_RX_N_CURRENT_ARQ_FRAME)) + logging.debug("ARQ_N_RX_FRAMES_PER_BURSTS" + str(static.ARQ_N_RX_FRAMES_PER_BURSTS)) + + frame_number = burstnumber + frame_number = frame_number.to_bytes(2, byteorder='big') + missing_frames += frame_number + + logging.warning("ARQ | TX | RPT ARQ FRAMES [" + str(missing_frames) + "] [BER." + str(static.BER) + "]") + + # BUILDING RPT FRAME FOR BURST ----------------------------------------------- + # rpt_payload = missing_frames + # rpt_frame = b'>' + rpt_payload #> = 63 --> 62?!?!?!?! + rpt_frame = bytearray(14) + rpt_frame[:1] = bytes([63]) + 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----------------------------------------------- + modem.transmit_signalling(rpt_frame) + while static.CHANNEL_STATE == 'SENDING_SIGNALLING': + time.sleep(0.01) + static.CHANNEL_STATE = 'RECEIVING_DATA' + +# ---------------------------- FRAME MACHINE + # --------------- IF LIST NOT CONTAINS "None" stick everything together + complete_data_frame = bytearray() + # print("static.ARQ_RX_FRAME_BUFFER.count(None)" + str(static.ARQ_RX_FRAME_BUFFER.count(None))) + if static.ARQ_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.ARQ_RX_FRAME_BUFFER)): + raw_arq_frame = static.ARQ_RX_FRAME_BUFFER[frame] + arq_frame_payload = raw_arq_frame[8:] + + # -------- DETECT IF WE RECEIVED A FRAME HEADER THEN SAVE DATA TO GLOBALS + if arq_frame_payload[2:4].startswith(static.FRAME_BOF): + static.FRAME_CRC = arq_frame_payload[:2] + static.ARQ_FRAME_BOF_RECEIVED = True + + arq_frame_payload = arq_frame_payload.split(static.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(static.FRAME_EOF) or arq_frame_payload.rstrip(b'\x00').endswith(static.FRAME_EOF[:-1]): + static.ARQ_FRAME_EOF_RECEIVED = True + if arq_frame_payload.rstrip(b'\x00').endswith(static.FRAME_EOF[:-1]): + arq_frame_payload = arq_frame_payload.split(static.FRAME_EOF[:-1]) + arq_frame_payload = arq_frame_payload[0] + else: + arq_frame_payload = arq_frame_payload.split(static.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 static.ARQ_FRAME_BOF_RECEIVED == True and static.ARQ_FRAME_EOF_RECEIVED == True: + + 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 == static.FRAME_CRC: + logging.log(25, "ARQ | RX | DATA FRAME SUCESSFULLY RECEIVED! :-) ") + + # append received frame to RX_BUFFER + static.RX_BUFFER.append(complete_data_frame) + + # BUILDING ACK FRAME FOR DATA FRAME ----------------------------------------------- + # ack_payload = b'FRAME_ACK' + # ack_frame = b'='+ ack_payload + bytes(static.FRAME_CRC) # < = 61 - - try: - static.ARQ_RX_BURST_BUFFER[static.ARQ_N_FRAME] = bytes(data_in) - - except IndexError: - - static.ARQ_RX_BURST_BUFFER = [] - for i in range(0,static.ARQ_N_RX_FRAMES_PER_BURSTS+1): - static.ARQ_RX_BURST_BUFFER.insert(i,None) - - static.ARQ_RX_BURST_BUFFER[static.ARQ_N_FRAME] = bytes(data_in) - -# - ------------------------- ARQ BURST CHECKER - # run only if we recieved all ARQ FRAMES per ARQ BURST - if static.ARQ_RX_BURST_BUFFER.count(None) == 1: #count nones - logging.info("ARQ | TX | BURST ACK") - - #BUILDING ACK FRAME FOR BURST ----------------------------------------------- - #ack_payload = b'ACK' - #ack_frame = b'<' + ack_payload # < = 60 - ack_frame = bytearray(14) - ack_frame[:1] = bytes([60]) + ack_frame[:1] = bytes([61]) ack_frame[1:2] = static.DXCALLSIGN_CRC8 ack_frame[2:3] = static.MYCALLSIGN_CRC8 - #print(ack_frame) - #TRANSMIT ACK FRAME FOR BURST----------------------------------------------- + + # TRANSMIT ACK FRAME FOR BURST----------------------------------------------- + time.sleep(1) # 0.5 + logging.info("ARQ | TX | ARQ DATA FRAME ACK [" + str(static.FRAME_CRC.hex()) + "] [BER." + str(static.BER) + "]") + modem.transmit_signalling(ack_frame) while static.CHANNEL_STATE == 'SENDING_SIGNALLING': time.sleep(0.01) - static.CHANNEL_STATE = 'RECEIVING_DATA' - #TRANSMIT_ARQ_ACK_THREAD = threading.Thread(target=modem.transmit_arq_ack, args=[ack_frame], name="TRANSMIT_ARQ_BURST") - #TRANSMIT_ARQ_ACK_THREAD.start() - #while static.ARQ_STATE == 'SENDING_ACK': - # pass - - #clear burst buffer + + static.CHANNEL_STATE = 'RECEIVING_SIGNALLING' + # clearing buffers and resetting counters static.ARQ_RX_BURST_BUFFER = [] - - #if decoded N frames are unequal to expected frames per burst - elif static.ARQ_N_FRAME == static.ARQ_N_RX_FRAMES_PER_BURSTS and static.ARQ_RX_BURST_BUFFER.count(None) != 1: - - # --------------- CHECK WHICH BURST FRAMES WE ARE MISSING ------------------------------------------- - missing_frames = b'' - for burstnumber in range(1,len(static.ARQ_RX_BURST_BUFFER)): - - if static.ARQ_RX_BURST_BUFFER[burstnumber] == None: - #frame_number = static.ARQ_RX_N_CURRENT_ARQ_FRAME - static.ARQ_N_RX_FRAMES_PER_BURSTS + burstnumber - #logging.debug("frame_number" + str(frame_number)) - logging.debug("static.ARQ_RX_N_CURRENT_ARQ_FRAME" + str(static.ARQ_RX_N_CURRENT_ARQ_FRAME)) - logging.debug("ARQ_N_RX_FRAMES_PER_BURSTS" + str(static.ARQ_N_RX_FRAMES_PER_BURSTS)) - - frame_number = burstnumber - frame_number = frame_number.to_bytes(2, byteorder='big') - missing_frames += frame_number - - logging.warning("ARQ | TX | RPT ARQ FRAMES [" + str(missing_frames) + "] [BER."+str(static.BER)+"]") - - #BUILDING RPT FRAME FOR BURST ----------------------------------------------- - #rpt_payload = missing_frames - #rpt_frame = b'>' + rpt_payload #> = 63 --> 62?!?!?!?! - rpt_frame = bytearray(14) - rpt_frame[:1] = bytes([63]) - 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----------------------------------------------- - modem.transmit_signalling(rpt_frame) - while static.CHANNEL_STATE == 'SENDING_SIGNALLING': - time.sleep(0.01) - static.CHANNEL_STATE = 'RECEIVING_DATA' - -# ---------------------------- FRAME MACHINE - # --------------- IF LIST NOT CONTAINS "None" stick everything together - complete_data_frame = bytearray() - #print("static.ARQ_RX_FRAME_BUFFER.count(None)" + str(static.ARQ_RX_FRAME_BUFFER.count(None))) - if static.ARQ_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.ARQ_RX_FRAME_BUFFER)): - raw_arq_frame = static.ARQ_RX_FRAME_BUFFER[frame] - arq_frame_payload = raw_arq_frame[8:] - - # -------- DETECT IF WE RECEIVED A FRAME HEADER THEN SAVE DATA TO GLOBALS - if arq_frame_payload[2:4].startswith(static.FRAME_BOF): - static.FRAME_CRC = arq_frame_payload[:2] - static.ARQ_FRAME_BOF_RECEIVED = True - - arq_frame_payload = arq_frame_payload.split(static.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(static.FRAME_EOF) or arq_frame_payload.rstrip(b'\x00').endswith(static.FRAME_EOF[:-1]): - static.ARQ_FRAME_EOF_RECEIVED = True - if arq_frame_payload.rstrip(b'\x00').endswith(static.FRAME_EOF[:-1]): - arq_frame_payload = arq_frame_payload.split(static.FRAME_EOF[:-1]) - arq_frame_payload = arq_frame_payload[0] - else: - arq_frame_payload = arq_frame_payload.split(static.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 static.ARQ_FRAME_BOF_RECEIVED == True and static.ARQ_FRAME_EOF_RECEIVED == True: - - 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 == static.FRAME_CRC: - logging.log(25,"ARQ | RX | DATA FRAME SUCESSFULLY RECEIVED! :-) ") - - #append received frame to RX_BUFFER - static.RX_BUFFER.append(complete_data_frame) - - #BUILDING ACK FRAME FOR DATA FRAME ----------------------------------------------- - #ack_payload = b'FRAME_ACK' - #ack_frame = b'='+ ack_payload + bytes(static.FRAME_CRC) # < = 61 - - 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----------------------------------------------- - time.sleep(1) #0.5 - logging.info("ARQ | TX | ARQ DATA FRAME ACK [" + str(static.FRAME_CRC.hex()) +"] [BER."+str(static.BER)+"]") - - modem.transmit_signalling(ack_frame) - while static.CHANNEL_STATE == 'SENDING_SIGNALLING': - time.sleep(0.01) - - static.CHANNEL_STATE = 'RECEIVING_SIGNALLING' - # clearing buffers and resetting counters - static.ARQ_RX_BURST_BUFFER = [] - static.ARQ_RX_FRAME_BUFFER = [] - static.ARQ_FRAME_BOF_RECEIVED = False - static.ARQ_FRAME_EOF_RECEIVED = False - static.ARQ_N_ARQ_FRAMES_PER_DATA_FRAME = 0 - static.ARQ_RX_N_CURRENT_ARQ_FRAME = 0 - static.TNC_STATE = 'IDLE' - static.ARQ_SEND_KEEP_ALIVE = True - static.ARQ_READY_FOR_DATA = False - - logging.info("DATA ["+ str(static.MYCALLSIGN, 'utf-8') + "]<< >>["+ str(static.DXCALLSIGN, 'utf-8') + "] [BER."+str(static.BER)+"]") - - else: - print("ARQ_FRAME_BOF_RECEIVED " + str(static.ARQ_FRAME_BOF_RECEIVED)) - print("ARQ_FRAME_EOF_RECEIVED " + str(static.ARQ_FRAME_EOF_RECEIVED)) - logging.error("ARQ | RX | DATA FRAME NOT SUCESSFULLY RECEIVED!") - static.ARQ_STATE = 'IDLE' - static.ARQ_SEND_KEEP_ALIVE = True - static.ARQ_READY_FOR_DATA = False - logging.info("DATA ["+ str(static.MYCALLSIGN, 'utf-8') + "]<< >>["+ str(static.DXCALLSIGN, 'utf-8') + "] [BER."+str(static.BER)+"]") - + static.ARQ_RX_FRAME_BUFFER = [] + static.ARQ_FRAME_BOF_RECEIVED = False + static.ARQ_FRAME_EOF_RECEIVED = False + static.ARQ_N_ARQ_FRAMES_PER_DATA_FRAME = 0 + static.ARQ_RX_N_CURRENT_ARQ_FRAME = 0 + static.TNC_STATE = 'IDLE' + static.ARQ_SEND_KEEP_ALIVE = True + static.ARQ_READY_FOR_DATA = False + + logging.info("DATA [" + str(static.MYCALLSIGN, 'utf-8') + "]<< >>[" + str(static.DXCALLSIGN, 'utf-8') + "] [BER." + str(static.BER) + "]") + + else: + print("ARQ_FRAME_BOF_RECEIVED " + str(static.ARQ_FRAME_BOF_RECEIVED)) + print("ARQ_FRAME_EOF_RECEIVED " + str(static.ARQ_FRAME_EOF_RECEIVED)) + logging.error("ARQ | RX | DATA FRAME NOT SUCESSFULLY RECEIVED!") + static.ARQ_STATE = 'IDLE' + static.ARQ_SEND_KEEP_ALIVE = True + static.ARQ_READY_FOR_DATA = False + logging.info("DATA [" + str(static.MYCALLSIGN, 'utf-8') + "]<< >>[" + str(static.DXCALLSIGN, 'utf-8') + "] [BER." + str(static.BER) + "]") + def arq_transmit(data_out): - # we need to set payload per frame manually at this point. maybe we can do this more dynmic. - if static.ARQ_DATA_CHANNEL_MODE == 10: - payload_per_frame = 512-2 - elif static.ARQ_DATA_CHANNEL_MODE == 11: - payload_per_frame = 256-2 - elif static.ARQ_DATA_CHANNEL_MODE == 12: - payload_per_frame = 128-2 - elif static.ARQ_DATA_CHANNEL_MODE == 14: - payload_per_frame = 16-2 + # we need to set payload per frame manually at this point. maybe we can do this more dynmic. + if static.ARQ_DATA_CHANNEL_MODE == 10: + payload_per_frame = 512 - 2 + elif static.ARQ_DATA_CHANNEL_MODE == 11: + payload_per_frame = 256 - 2 + elif static.ARQ_DATA_CHANNEL_MODE == 12: + payload_per_frame = 128 - 2 + elif static.ARQ_DATA_CHANNEL_MODE == 14: + payload_per_frame = 16 - 2 + else: + payload_per_frame = 16 - 2 + + static.ARQ_PAYLOAD_PER_FRAME = payload_per_frame - 8 + + # print("static.ARQ_DATA_PAYLOAD_PER_FRAME " + str(static.FREEDV_DATA_PAYLOAD_PER_FRAME)) + # print("static.ARQ_PAYLOAD_PER_FRAME " + str(static.ARQ_PAYLOAD_PER_FRAME)) + + frame_header_length = 6 # 4 + + n_arq_frames_per_data_frame = (len(data_out) + frame_header_length) // static.ARQ_PAYLOAD_PER_FRAME + ((len(data_out) + frame_header_length) % static.ARQ_PAYLOAD_PER_FRAME > 0) + + 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 + static.FRAME_BOF + data_out + static.FRAME_EOF + # 2 2 N 2 + + # --------------------------------------------- LETS CREATE A BUFFER BY SPLITTING THE FILES INTO PEACES + static.TX_BUFFER = [data_out[i:i + static.ARQ_PAYLOAD_PER_FRAME] for i in range(0, len(data_out), static.ARQ_PAYLOAD_PER_FRAME)] + static.TX_BUFFER_SIZE = len(static.TX_BUFFER) + + logging.info("ARQ | TX | M:" + str(static.ARQ_DATA_CHANNEL_MODE) + " | DATA FRAME --- BYTES: " + str(len(data_out)) + " ARQ FRAMES: " + str(static.TX_BUFFER_SIZE)) + + # --------------------------------------------- THIS IS THE MAIN LOOP----------------------------------------------------------------- + static.ARQ_N_SENT_FRAMES = 0 # SET N SENT FRAMES TO 0 FOR A NEW SENDING CYCLE + while static.ARQ_N_SENT_FRAMES <= static.TX_BUFFER_SIZE: + + static.ARQ_TX_N_FRAMES_PER_BURST = get_n_frames_per_burst() + + # ----------- 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(static.ARQ_TX_N_FRAMES_PER_BURST): # Loop through TX_BUFFER LIST + len(static.TX_BUFFER[static.ARQ_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 static.ARQ_TX_N_FRAMES_PER_BURST TO VALUE OF REST! + + if static.ARQ_N_SENT_FRAMES == 0 and (static.ARQ_TX_N_FRAMES_PER_BURST > static.TX_BUFFER_SIZE): # WE CANT DO MODULO 0 --> CHECK IF FIRST FRAME == LAST FRAME + static.ARQ_TX_N_FRAMES_PER_BURST = static.TX_BUFFER_SIZE + + elif static.ARQ_N_SENT_FRAMES == 1 and (static.ARQ_TX_N_FRAMES_PER_BURST > static.TX_BUFFER_SIZE): # MODULO 1 WILL ALWAYS BE 0 --> THIS FIXES IT + static.ARQ_TX_N_FRAMES_PER_BURST = static.TX_BUFFER_SIZE - static.ARQ_N_SENT_FRAMES + else: - payload_per_frame = 16-2 - - static.ARQ_PAYLOAD_PER_FRAME = payload_per_frame - 8 + static.ARQ_TX_N_FRAMES_PER_BURST = (static.TX_BUFFER_SIZE % static.ARQ_N_SENT_FRAMES) - #print("static.ARQ_DATA_PAYLOAD_PER_FRAME " + str(static.FREEDV_DATA_PAYLOAD_PER_FRAME)) - #print("static.ARQ_PAYLOAD_PER_FRAME " + str(static.ARQ_PAYLOAD_PER_FRAME)) + # --------------------------------------------- N ATTEMPTS TO SEND BURSTS IF ACK RECEPTION FAILS + for static.TX_N_RETRIES in range(static.TX_N_MAX_RETRIES): - frame_header_length = 6 #4 - - n_arq_frames_per_data_frame = (len(data_out)+frame_header_length) // static.ARQ_PAYLOAD_PER_FRAME + ((len(data_out)+frame_header_length) % static.ARQ_PAYLOAD_PER_FRAME > 0) - - frame_payload_crc = helpers.get_crc_16(data_out) + if static.ARQ_N_SENT_FRAMES + 1 <= static.TX_BUFFER_SIZE: + logging.log(24, "ARQ | TX | M:" + str(static.ARQ_DATA_CHANNEL_MODE) + " | F:[" + str(static.ARQ_N_SENT_FRAMES + 1) + "-" + str(static.ARQ_N_SENT_FRAMES + static.ARQ_TX_N_FRAMES_PER_BURST) + "] | T:[" + str(static.ARQ_N_SENT_FRAMES) + "/" + str(static.TX_BUFFER_SIZE) + "] [" + str(int(static.ARQ_N_SENT_FRAMES / (static.TX_BUFFER_SIZE) * 100)).zfill(3) + "%] | A:[" + str(static.TX_N_RETRIES + 1) + "/" + str(static.TX_N_MAX_RETRIES) + "] [BER." + str(static.BER) + "]") - # This is the total frame with frame header, which will be send - data_out = frame_payload_crc + static.FRAME_BOF + data_out + static.FRAME_EOF - # 2 2 N 2 - - # --------------------------------------------- LETS CREATE A BUFFER BY SPLITTING THE FILES INTO PEACES - static.TX_BUFFER = [data_out[i:i+static.ARQ_PAYLOAD_PER_FRAME] for i in range(0, len(data_out), static.ARQ_PAYLOAD_PER_FRAME)] - static.TX_BUFFER_SIZE = len(static.TX_BUFFER) - - logging.info("ARQ | TX | M:" + str(static.ARQ_DATA_CHANNEL_MODE) + " | DATA FRAME --- BYTES: " + str(len(data_out)) + " ARQ FRAMES: " + str(static.TX_BUFFER_SIZE)) - - # --------------------------------------------- THIS IS THE MAIN LOOP----------------------------------------------------------------- - static.ARQ_N_SENT_FRAMES = 0 # SET N SENT FRAMES TO 0 FOR A NEW SENDING CYCLE - while static.ARQ_N_SENT_FRAMES <= static.TX_BUFFER_SIZE: + # lets start a thread to transmit nonblocking + # TRANSMIT_ARQ_BURST_THREAD = threading.Thread(target=modem.transmit_arq_burst, name="TRANSMIT_ARQ_BURST") + # TRANSMIT_ARQ_BURST_THREAD.start() + # asyncio.run(modem.transmit_arq_burst()) + # await modem.transmit_arq_burst() + modem.transmit_arq_burst() + # lets wait during sending. After sending is finished we will continue + while static.CHANNEL_STATE == 'SENDING_DATA': + time.sleep(0.01) - static.ARQ_TX_N_FRAMES_PER_BURST = get_n_frames_per_burst() - - # ----------- 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(static.ARQ_TX_N_FRAMES_PER_BURST): # Loop through TX_BUFFER LIST - len(static.TX_BUFFER[static.ARQ_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 static.ARQ_TX_N_FRAMES_PER_BURST TO VALUE OF REST! - - if static.ARQ_N_SENT_FRAMES == 0 and (static.ARQ_TX_N_FRAMES_PER_BURST > static.TX_BUFFER_SIZE): #WE CANT DO MODULO 0 --> CHECK IF FIRST FRAME == LAST FRAME - static.ARQ_TX_N_FRAMES_PER_BURST = static.TX_BUFFER_SIZE - - elif static.ARQ_N_SENT_FRAMES == 1 and (static.ARQ_TX_N_FRAMES_PER_BURST > static.TX_BUFFER_SIZE): # MODULO 1 WILL ALWAYS BE 0 --> THIS FIXES IT - static.ARQ_TX_N_FRAMES_PER_BURST = static.TX_BUFFER_SIZE - static.ARQ_N_SENT_FRAMES - - else: - static.ARQ_TX_N_FRAMES_PER_BURST = (static.TX_BUFFER_SIZE % static.ARQ_N_SENT_FRAMES) - - #--------------------------------------------- N ATTEMPTS TO SEND BURSTS IF ACK RECEPTION FAILS - for static.TX_N_RETRIES in range(static.TX_N_MAX_RETRIES): - - if static.ARQ_N_SENT_FRAMES + 1 <= static.TX_BUFFER_SIZE: - logging.log(24, "ARQ | TX | M:" + str(static.ARQ_DATA_CHANNEL_MODE) + " | F:[" + str(static.ARQ_N_SENT_FRAMES+1) + "-" + str(static.ARQ_N_SENT_FRAMES + static.ARQ_TX_N_FRAMES_PER_BURST) + "] | T:[" + str(static.ARQ_N_SENT_FRAMES) + "/" + str(static.TX_BUFFER_SIZE) + "] [" + str(int(static.ARQ_N_SENT_FRAMES/(static.TX_BUFFER_SIZE)*100)).zfill(3) + "%] | A:[" + str(static.TX_N_RETRIES+1) + "/" + str(static.TX_N_MAX_RETRIES) + "] [BER."+str(static.BER)+"]") - - - # lets start a thread to transmit nonblocking - #TRANSMIT_ARQ_BURST_THREAD = threading.Thread(target=modem.transmit_arq_burst, name="TRANSMIT_ARQ_BURST") - #TRANSMIT_ARQ_BURST_THREAD.start() - #asyncio.run(modem.transmit_arq_burst()) - #await modem.transmit_arq_burst() - modem.transmit_arq_burst() - # 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 - - logging.info("ARQ | RX | WAITING FOR BURST ACK") - static.CHANNEL_STATE = 'RECEIVING_SIGNALLING' - #print(static.CHANNEL_STATE) - - helpers.arq_reset_timeout(False) - helpers.arq_reset_ack(False) - #print(static.ARQ_RX_ACK_TIMEOUT) - #print("timeout......?!?") - #asyncio.ensure_future(helpers.set_variable_after_timeout()) - ##################task = asyncio.create_task(helpers.set_after_timeout()) - #async with trio.open_nursery() as nursery: - # nursery.start_soon(helpers.set_after_timeout()) - - - #print("TIMEOUT glaube gestartet...") - #print(task) - #print(static.ARQ_RX_ACK_TIMEOUT) - - acktimer = threading.Timer(static.ARQ_RX_ACK_TIMEOUT_SECONDS, helpers.arq_ack_timeout) - acktimer.start() - - logging.debug(".............................") - logging.debug("static.ARQ_STATE " + str(static.ARQ_STATE)) - logging.debug("static.ARQ_FRAME_ACK_RECEIVED " + str(static.ARQ_FRAME_ACK_RECEIVED)) - logging.debug("static.ARQ_ACK_RECEIVED " + str(static.ARQ_ACK_RECEIVED)) - logging.debug("static.ARQ_RX_ACK_TIMEOUT " + str(static.ARQ_RX_ACK_TIMEOUT)) - logging.debug("static.ARQ_RPT_RECEIVED " + str(static.ARQ_RPT_RECEIVED)) - logging.debug(".............................") + # --------------------------- START TIMER FOR WAITING FOR ACK ---> IF TIMEOUT REACHED, ACK_TIMEOUT = 1 - # --------------------------- WHILE TIMEOUT NOT REACHED AND NO ACK RECEIVED --> LISTEN - while static.ARQ_ACK_RECEIVED != True and static.ARQ_RPT_RECEIVED != True and static.ARQ_FRAME_ACK_RECEIVED != True and static.ARQ_RX_FRAME_TIMEOUT != True and static.ARQ_RX_ACK_TIMEOUT != True: - time.sleep(0.01) # lets reduce CPU load a little bit - logging.debug(static.CHANNEL_STATE) - - if static.ARQ_RPT_RECEIVED == True: - - logging.warning("ARQ | RX | REQUEST FOR REPEATING FRAMES: " + str(static.ARQ_RPT_FRAMES)) - logging.warning("ARQ | TX | SENDING REQUESTED FRAMES: " + str(static.ARQ_RPT_FRAMES)) - - #TRANSMIT_ARQ_BURST_THREAD = threading.Thread(target=modem.transmit_arq_burst, name="TRANSMIT_ARQ_BURST") - #TRANSMIT_ARQ_BURST_THREAD.start() - #asyncio.run(modem.transmit_arq_burst()) - #await modem.transmit_arq_burst() - modem.transmit_arq_burst() - # 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' - - helpers.arq_reset_timeout(False) - helpers.arq_reset_ack(False) - - rpttimer = threading.Timer(static.ARQ_RX_RPT_TIMEOUT_SECONDS, helpers.arq_rpt_timeout) - rpttimer.start() - - while static.ARQ_ACK_RECEIVED == False and static.ARQ_FRAME_ACK_RECEIVED == False and static.ARQ_RX_RPT_TIMEOUT == False: - time.sleep(0.01) # lets reduce CPU load a little bit - logging.debug(static.ARQ_STATE) - - if static.ARQ_ACK_RECEIVED == True: - - logging.info("ARQ | RX | ACK AFTER RPT") - rpttimer.cancel() - helpers.arq_reset_ack(True) - static.ARQ_RPT_FRAMES = [] + logging.info("ARQ | RX | WAITING FOR BURST ACK") + static.CHANNEL_STATE = 'RECEIVING_SIGNALLING' + # print(static.CHANNEL_STATE) - if static.ARQ_RX_RPT_TIMEOUT == True and static.ARQ_ACK_RECEIVED == False: - - logging.error("ARQ | Burst lost....") - - helpers.arq_reset_ack(False) - static.ARQ_RPT_FRAMES = [] - - #-------------------------------------------------------------------------------------------------------------- - - elif static.ARQ_ACK_RECEIVED == 0 and static.ARQ_RX_ACK_TIMEOUT == 1: - 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 static.ARQ_ACK_RECEIVED == True: - logging.info("ARQ | RX | ACK") - acktimer.cancel() - #-----------IF ACK RECEIVED, INCREMENT ITERATOR FOR MAIN LOOP TO PROCEED WITH NEXT FRAMES/BURST - static.ARQ_N_SENT_FRAMES = static.ARQ_N_SENT_FRAMES + static.ARQ_TX_N_FRAMES_PER_BURST - break - - #--------------- BREAK LOOP IF FRAME ACK HAS BEEN RECEIVED EARLIER AS EXPECTED - elif static.ARQ_FRAME_ACK_RECEIVED == True: - - logging.info("ARQ | RX | EARLY FRAME ACK RECEIVED") - - #static.ARQ_N_SENT_FRAMES = #static.TX_BUFFER_SIZE - static.ARQ_N_SENT_FRAMES = static.ARQ_N_SENT_FRAMES + static.ARQ_TX_N_FRAMES_PER_BURST - break - - else: - logging.debug("------------------------------->NO RULE MATCHED!") - break - - - #--------------------------------WAITING AREA FOR FRAME ACKs - - logging.debug("static.ARQ_N_SENT_FRAMES " + str(static.ARQ_N_SENT_FRAMES)) - logging.debug("static.TX_BUFFER_SIZE " + str(static.TX_BUFFER_SIZE)) - logging.debug("static.TX_N_RETRIES " + str(static.TX_N_RETRIES)) - logging.debug("static.TX_N_MAX_RETRIES " + str(static.TX_N_MAX_RETRIES)) - logging.debug("static.ARQ_STATE " + str(static.ARQ_STATE)) - logging.debug("static.ARQ_FRAME_ACK_RECEIVED " + str(static.ARQ_FRAME_ACK_RECEIVED)) - logging.debug("static.ARQ_RX_FRAME_TIMEOUT " + str(static.ARQ_RX_FRAME_TIMEOUT)) - logging.debug("static.ARQ_ACK_RECEIVED " + str(static.ARQ_ACK_RECEIVED)) - logging.debug("static.ARQ_RX_ACK_TIMEOUT " + str(static.ARQ_RX_ACK_TIMEOUT)) - logging.debug("static.ARQ_RPT_RECEIVED " + str(static.ARQ_RPT_RECEIVED)) - logging.debug("static.ARQ_TX_N_FRAMES_PER_BURST " + str(static.ARQ_TX_N_FRAMES_PER_BURST)) - - frametimer = threading.Timer(static.ARQ_RX_FRAME_TIMEOUT_SECONDS, helpers.arq_frame_timeout) - frametimer.start() + helpers.arq_reset_timeout(False) + helpers.arq_reset_ack(False) + # print(static.ARQ_RX_ACK_TIMEOUT) + # print("timeout......?!?") + # asyncio.ensure_future(helpers.set_variable_after_timeout()) + # #################task = asyncio.create_task(helpers.set_after_timeout()) + # async with trio.open_nursery() as nursery: + # nursery.start_soon(helpers.set_after_timeout()) + + # print("TIMEOUT glaube gestartet...") + # print(task) + # print(static.ARQ_RX_ACK_TIMEOUT) + + acktimer = threading.Timer(static.ARQ_RX_ACK_TIMEOUT_SECONDS, helpers.arq_ack_timeout) + acktimer.start() + + logging.debug(".............................") + logging.debug("static.ARQ_STATE " + str(static.ARQ_STATE)) + logging.debug("static.ARQ_FRAME_ACK_RECEIVED " + str(static.ARQ_FRAME_ACK_RECEIVED)) + logging.debug("static.ARQ_ACK_RECEIVED " + str(static.ARQ_ACK_RECEIVED)) + logging.debug("static.ARQ_RX_ACK_TIMEOUT " + str(static.ARQ_RX_ACK_TIMEOUT)) + logging.debug("static.ARQ_RPT_RECEIVED " + str(static.ARQ_RPT_RECEIVED)) + logging.debug(".............................") + + # --------------------------- WHILE TIMEOUT NOT REACHED AND NO ACK RECEIVED --> LISTEN + while static.ARQ_ACK_RECEIVED != True and static.ARQ_RPT_RECEIVED != True and static.ARQ_FRAME_ACK_RECEIVED != True and static.ARQ_RX_FRAME_TIMEOUT != True and static.ARQ_RX_ACK_TIMEOUT != True: + time.sleep(0.01) # lets reduce CPU load a little bit + logging.debug(static.CHANNEL_STATE) + + if static.ARQ_RPT_RECEIVED == True: + + logging.warning("ARQ | RX | REQUEST FOR REPEATING FRAMES: " + str(static.ARQ_RPT_FRAMES)) + logging.warning("ARQ | TX | SENDING REQUESTED FRAMES: " + str(static.ARQ_RPT_FRAMES)) + + # TRANSMIT_ARQ_BURST_THREAD = threading.Thread(target=modem.transmit_arq_burst, name="TRANSMIT_ARQ_BURST") + # TRANSMIT_ARQ_BURST_THREAD.start() + # asyncio.run(modem.transmit_arq_burst()) + # await modem.transmit_arq_burst() + modem.transmit_arq_burst() + # 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' - - # wait for frame ACK if we processed the last frame/burst - while static.ARQ_FRAME_ACK_RECEIVED == False and static.ARQ_RX_FRAME_TIMEOUT == False and static.ARQ_N_SENT_FRAMES == static.TX_BUFFER_SIZE: - time.sleep(0.01) # lets reduce CPU load a little bit - #print(static.ARQ_STATE) - logging.debug("WAITING FOR FRAME ACK") - - - # ----------- if no ACK received and out of retries.....stop frame sending - if static.ARQ_ACK_RECEIVED == False and static.ARQ_FRAME_ACK_RECEIVED == False and static.ARQ_RX_ACK_TIMEOUT == True: - logging.error("ARQ | TX | NO ACK RECEIVED | DATA SHOULD BE RESEND!") - static.CHANNEL_STATE = 'RECEIVING_SIGNALLING' - logging.error("------------------------------------------------------") - break - #-------------------------BREAK TX BUFFER LOOP IF ALL PACKETS HAVE BEEN SENT AND WE GOT A FRAME ACK - elif static.ARQ_N_SENT_FRAMES == static.TX_BUFFER_SIZE and static.ARQ_FRAME_ACK_RECEIVED == True: - logging.log(25,"ARQ | RX | FRAME ACK RECEIVED - DATA TRANSMITTED! :-)") - static.CHANNEL_STATE = 'RECEIVING_SIGNALLING' - break - - elif static.ARQ_FRAME_ACK_RECEIVED == False and static.ARQ_RX_FRAME_TIMEOUT == True: - logging.error("ARQ | TX | NO FRAME ACK RECEIVED") - static.CHANNEL_STATE = 'RECEIVING_DATA' - break - - else: - logging.debug("NO MATCHING RULE AT THE END") - - # stop all timers - try: - frametimer.cancel() - except Exception: - pass - - try: - acktimer.cancel() - except Exception: - pass + helpers.arq_reset_timeout(False) + helpers.arq_reset_ack(False) - # IF TX BUFFER IS EMPTY / ALL FRAMES HAVE BEEN SENT --> HERE WE COULD ADD AN static.VAR for IDLE STATE - - logging.info("ARQ | TX | BUFFER EMPTY") - helpers.arq_reset_frame_machine() - #await asyncio.sleep(2) - time.sleep(2) - logging.info("DATA ["+ str(static.MYCALLSIGN, 'utf-8') + "]<< >>["+ str(static.DXCALLSIGN, 'utf-8') + "] [BER."+str(static.BER)+"]") - arq_transmit_keep_alive() - - # 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() + rpttimer = threading.Timer(static.ARQ_RX_RPT_TIMEOUT_SECONDS, helpers.arq_rpt_timeout) + rpttimer.start() + + while static.ARQ_ACK_RECEIVED == False and static.ARQ_FRAME_ACK_RECEIVED == False and static.ARQ_RX_RPT_TIMEOUT == False: + time.sleep(0.01) # lets reduce CPU load a little bit + logging.debug(static.ARQ_STATE) + + if static.ARQ_ACK_RECEIVED == True: + + logging.info("ARQ | RX | ACK AFTER RPT") + rpttimer.cancel() + helpers.arq_reset_ack(True) + static.ARQ_RPT_FRAMES = [] + + if static.ARQ_RX_RPT_TIMEOUT == True and static.ARQ_ACK_RECEIVED == False: + + logging.error("ARQ | Burst lost....") + + helpers.arq_reset_ack(False) + static.ARQ_RPT_FRAMES = [] + + # -------------------------------------------------------------------------------------------------------------- + + elif static.ARQ_ACK_RECEIVED == 0 and static.ARQ_RX_ACK_TIMEOUT == 1: + 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 static.ARQ_ACK_RECEIVED == True: + logging.info("ARQ | RX | ACK") + acktimer.cancel() + # -----------IF ACK RECEIVED, INCREMENT ITERATOR FOR MAIN LOOP TO PROCEED WITH NEXT FRAMES/BURST + static.ARQ_N_SENT_FRAMES = static.ARQ_N_SENT_FRAMES + static.ARQ_TX_N_FRAMES_PER_BURST + break + + # --------------- BREAK LOOP IF FRAME ACK HAS BEEN RECEIVED EARLIER AS EXPECTED + elif static.ARQ_FRAME_ACK_RECEIVED == True: + + logging.info("ARQ | RX | EARLY FRAME ACK RECEIVED") + + # static.ARQ_N_SENT_FRAMES = #static.TX_BUFFER_SIZE + static.ARQ_N_SENT_FRAMES = static.ARQ_N_SENT_FRAMES + static.ARQ_TX_N_FRAMES_PER_BURST + break + + else: + logging.debug("------------------------------->NO RULE MATCHED!") + break + + # --------------------------------WAITING AREA FOR FRAME ACKs + + logging.debug("static.ARQ_N_SENT_FRAMES " + str(static.ARQ_N_SENT_FRAMES)) + logging.debug("static.TX_BUFFER_SIZE " + str(static.TX_BUFFER_SIZE)) + logging.debug("static.TX_N_RETRIES " + str(static.TX_N_RETRIES)) + logging.debug("static.TX_N_MAX_RETRIES " + str(static.TX_N_MAX_RETRIES)) + logging.debug("static.ARQ_STATE " + str(static.ARQ_STATE)) + logging.debug("static.ARQ_FRAME_ACK_RECEIVED " + str(static.ARQ_FRAME_ACK_RECEIVED)) + logging.debug("static.ARQ_RX_FRAME_TIMEOUT " + str(static.ARQ_RX_FRAME_TIMEOUT)) + logging.debug("static.ARQ_ACK_RECEIVED " + str(static.ARQ_ACK_RECEIVED)) + logging.debug("static.ARQ_RX_ACK_TIMEOUT " + str(static.ARQ_RX_ACK_TIMEOUT)) + logging.debug("static.ARQ_RPT_RECEIVED " + str(static.ARQ_RPT_RECEIVED)) + logging.debug("static.ARQ_TX_N_FRAMES_PER_BURST " + str(static.ARQ_TX_N_FRAMES_PER_BURST)) + + frametimer = threading.Timer(static.ARQ_RX_FRAME_TIMEOUT_SECONDS, helpers.arq_frame_timeout) + frametimer.start() + static.CHANNEL_STATE = 'RECEIVING_SIGNALLING' + + # wait for frame ACK if we processed the last frame/burst + while static.ARQ_FRAME_ACK_RECEIVED == False and static.ARQ_RX_FRAME_TIMEOUT == False and static.ARQ_N_SENT_FRAMES == static.TX_BUFFER_SIZE: + time.sleep(0.01) # lets reduce CPU load a little bit + # print(static.ARQ_STATE) + logging.debug("WAITING FOR FRAME ACK") + + # ----------- if no ACK received and out of retries.....stop frame sending + if static.ARQ_ACK_RECEIVED == False and static.ARQ_FRAME_ACK_RECEIVED == False and static.ARQ_RX_ACK_TIMEOUT == True: + logging.error("ARQ | TX | NO ACK RECEIVED | DATA SHOULD BE RESEND!") + static.CHANNEL_STATE = 'RECEIVING_SIGNALLING' + logging.error("------------------------------------------------------") + break + + # -------------------------BREAK TX BUFFER LOOP IF ALL PACKETS HAVE BEEN SENT AND WE GOT A FRAME ACK + elif static.ARQ_N_SENT_FRAMES == static.TX_BUFFER_SIZE and static.ARQ_FRAME_ACK_RECEIVED == True: + logging.log(25, "ARQ | RX | FRAME ACK RECEIVED - DATA TRANSMITTED! :-)") + static.CHANNEL_STATE = 'RECEIVING_SIGNALLING' + break + + elif static.ARQ_FRAME_ACK_RECEIVED == False and static.ARQ_RX_FRAME_TIMEOUT == True: + logging.error("ARQ | TX | NO FRAME ACK RECEIVED") + static.CHANNEL_STATE = 'RECEIVING_DATA' + break + + else: + logging.debug("NO MATCHING RULE AT THE END") + + # stop all timers + try: + frametimer.cancel() + except Exception: + pass + + try: + acktimer.cancel() + except Exception: + pass + + # IF TX BUFFER IS EMPTY / ALL FRAMES HAVE BEEN SENT --> HERE WE COULD ADD AN static.VAR for IDLE STATE + + logging.info("ARQ | TX | BUFFER EMPTY") + helpers.arq_reset_frame_machine() + # await asyncio.sleep(2) + time.sleep(2) + logging.info("DATA [" + str(static.MYCALLSIGN, 'utf-8') + "]<< >>[" + str(static.DXCALLSIGN, 'utf-8') + "] [BER." + str(static.BER) + "]") + arq_transmit_keep_alive() + + # 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() -# BURST MACHINE TO DEFINE N BURSTS PER FRAME ---> LATER WE CAN USE CHANNEL MESSUREMENT TO SET FRAMES PER BURST +# BURST MACHINE TO DEFINE N BURSTS PER FRAME ---> LATER WE CAN USE CHANNEL MESSUREMENT TO SET FRAMES PER BURST def get_n_frames_per_burst(): #n_frames_per_burst = randrange(1,10) - n_frames_per_burst = 1 + n_frames_per_burst = 1 return n_frames_per_burst - - - -def burst_ack_received(): - static.ARQ_ACK_RECEIVED = True #Force data loops of TNC to stop and continue with next frame - + +def burst_ack_received(): + static.ARQ_ACK_RECEIVED = True # Force data loops of TNC to stop and continue with next frame + def frame_ack_received(): - static.ARQ_FRAME_ACK_RECEIVED = True #Force data loops of TNC to stop and continue with next frame - - + static.ARQ_FRAME_ACK_RECEIVED = True # Force data loops of TNC to stop and continue with next frame + def burst_rpt_received(data_in): static.ARQ_RPT_RECEIVED = True static.ARQ_RPT_FRAMES = [] - + missing_area = bytes(data_in[1:9]) - - for i in range(0,6,2): - if not missing_area[i:i+2].endswith(b'\x00\x00'): - missing = missing_area[i:i+2] - static.ARQ_RPT_FRAMES.insert(0,missing) - -############################################################################################################# + + for i in range(0, 6, 2): + if not missing_area[i:i + 2].endswith(b'\x00\x00'): + missing = missing_area[i:i + 2] + static.ARQ_RPT_FRAMES.insert(0, missing) + +# ############################################################################################################ # ARQ CONNECT HANDLER -############################################################################################################# - +# ############################################################################################################ + + async def arq_connect(): - static.ARQ_STATE = 'CONNECTING' - logging.info("CONN ["+ str(static.MYCALLSIGN, 'utf-8') + "]-> <-["+ str(static.DXCALLSIGN, 'utf-8') + "] [BER."+str(static.BER)+"]") + static.ARQ_STATE = 'CONNECTING' + logging.info("CONN [" + str(static.MYCALLSIGN, 'utf-8') + "]-> <-[" + str(static.DXCALLSIGN, 'utf-8') + "] [BER." + str(static.BER) + "]") frame_type = bytes([220]) connection_frame = bytearray(14) @@ -518,257 +509,263 @@ async def arq_connect(): connection_frame[1:2] = static.DXCALLSIGN_CRC8 connection_frame[2:3] = static.MYCALLSIGN_CRC8 connection_frame[3:9] = static.MYCALLSIGN # we need the full CALLSIGN, if we are doing a connect without ping and cq - #connection_frame[12:13] = bytes([static.ARQ_DATA_CHANNEL_MODE]) - #connection_frame[13:14] = bytes([static.ARQ_READY_FOR_DATA]) - #print(connection_frame) + # connection_frame[12:13] = bytes([static.ARQ_DATA_CHANNEL_MODE]) + # connection_frame[13:14] = bytes([static.ARQ_READY_FOR_DATA]) + # print(connection_frame) modem.transmit_signalling(connection_frame) while static.CHANNEL_STATE == 'SENDING_SIGNALLING': - time.sleep(0.01) - -def arq_received_connect(data_in): - static.ARQ_STATE = 'CONNECTING' - - static.DXCALLSIGN = bytes(data_in[3:9]).rstrip(b'\x00') - static.DXCALLSIGN_CRC8 = helpers.get_crc_8(static.DXCALLSIGN) - #static.FREEDV_DATA_MODE = int.from_bytes(bytes(data_in[12:13]), "big") + time.sleep(0.01) - logging.info("CONN ["+ str(static.MYCALLSIGN, 'utf-8') + "]-> <-["+ str(static.DXCALLSIGN, 'utf-8') + "] [BER."+str(static.BER)+"]") + +def arq_received_connect(data_in): + static.ARQ_STATE = 'CONNECTING' + + static.DXCALLSIGN = bytes(data_in[3:9]).rstrip(b'\x00') + static.DXCALLSIGN_CRC8 = helpers.get_crc_8(static.DXCALLSIGN) + # static.FREEDV_DATA_MODE = int.from_bytes(bytes(data_in[12:13]), "big") + + logging.info("CONN [" + str(static.MYCALLSIGN, 'utf-8') + "]-> <-[" + str(static.DXCALLSIGN, 'utf-8') + "] [BER." + str(static.BER) + "]") frame_type = bytes([221]) connection_frame = bytearray(14) connection_frame[:1] = frame_type connection_frame[1:2] = static.DXCALLSIGN_CRC8 connection_frame[2:3] = static.MYCALLSIGN_CRC8 - #connection_frame[12:13] = bytes([static.FREEDV_DATA_MODE]) + # connection_frame[12:13] = bytes([static.FREEDV_DATA_MODE]) - #send ACK for connect + # send ACK for connect modem.transmit_signalling(connection_frame) while static.CHANNEL_STATE == 'SENDING_SIGNALLING': time.sleep(0.01) - - + + def arq_transmit_keep_alive(): frame_type = bytes([221]) connection_frame = bytearray(14) connection_frame[:1] = frame_type connection_frame[1:2] = static.DXCALLSIGN_CRC8 connection_frame[2:3] = static.MYCALLSIGN_CRC8 - + modem.transmit_signalling(connection_frame) while static.CHANNEL_STATE == 'SENDING_SIGNALLING': - time.sleep(0.01) - + time.sleep(0.01) + + def arq_received_connect_keep_alive(data_in): if static.ARQ_SEND_KEEP_ALIVE == True and (static.ARQ_STATE == 'CONNECTING' or static.ARQ_STATE == 'CONNECTED'): - logging.info("CONN ["+ str(static.MYCALLSIGN, 'utf-8') + "] >|< ["+ str(static.DXCALLSIGN, 'utf-8') + "] [BER."+str(static.BER)+"]") + logging.info("CONN [" + str(static.MYCALLSIGN, 'utf-8') + "] >|< [" + str(static.DXCALLSIGN, 'utf-8') + "] [BER." + str(static.BER) + "]") static.ARQ_STATE = 'CONNECTED' - - frame_type = bytes([221]) + + frame_type = bytes([221]) connection_frame = bytearray(14) connection_frame[:1] = frame_type connection_frame[1:2] = static.DXCALLSIGN_CRC8 connection_frame[2:3] = static.MYCALLSIGN_CRC8 connection_frame[12:13] = bytes([static.ARQ_DATA_CHANNEL_MODE]) - connection_frame[13:14] = bytes([0]) - - #lets wait a second before sending + connection_frame[13:14] = bytes([0]) + + # lets wait a second before sending acktimer = threading.Timer(1.0, modem.transmit_signalling, args=[connection_frame]) acktimer.start() while static.CHANNEL_STATE == 'SENDING_SIGNALLING': - time.sleep(0.01) + time.sleep(0.01) else: pass - #print("keep alive = False") -############################################################################################################# + # print("keep alive = False") +# ############################################################################################################ # ARQ DATA CHANNEL HANDLER -############################################################################################################# +# ############################################################################################################ + - async def arq_open_data_channel(): # we need to wait until the last keep alive has been sent. - logging.info("DATA ["+ str(static.MYCALLSIGN, 'utf-8') + "]>> <<["+ str(static.DXCALLSIGN, 'utf-8') + "] [BER."+str(static.BER)+"]") + logging.info("DATA [" + str(static.MYCALLSIGN, 'utf-8') + "]>> <<[" + str(static.DXCALLSIGN, 'utf-8') + "] [BER." + str(static.BER) + "]") static.ARQ_SEND_KEEP_ALIVE = False static.ARQ_DATA_CHANNEL_MODE = 12 while static.CHANNEL_STATE == 'SENDING_SIGNALLING': time.sleep(0.01) - #print("wir warten 2 sekunden...") + # print("wir warten 2 sekunden...") await asyncio.sleep(4) - + 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[12:13] = bytes([static.ARQ_DATA_CHANNEL_MODE]) - #connection_frame[13:14] = bytes([225]) - + # connection_frame[13:14] = bytes([225]) modem.transmit_signalling(connection_frame) while static.CHANNEL_STATE == 'SENDING_SIGNALLING': - time.sleep(0.01) - - + time.sleep(0.01) + + def arq_received_data_channel_opener(data_in): - logging.info("DATA ["+ str(static.MYCALLSIGN, 'utf-8') + "]>> <<["+ str(static.DXCALLSIGN, 'utf-8') + "] [BER."+str(static.BER)+"]") + logging.info("DATA [" + str(static.MYCALLSIGN, 'utf-8') + "]>> <<[" + str(static.DXCALLSIGN, 'utf-8') + "] [BER." + str(static.BER) + "]") static.ARQ_SEND_KEEP_ALIVE = False static.ARQ_DATA_CHANNEL_MODE = int.from_bytes(bytes(data_in[12:13]), "big") - #static.ARQ_READY_FOR_DATA = int.from_bytes(bytes(data_in[13:14]), "big") - + # static.ARQ_READY_FOR_DATA = int.from_bytes(bytes(data_in[13:14]), "big") + connection_frame = bytearray(14) connection_frame[:1] = bytes([226]) connection_frame[1:2] = static.DXCALLSIGN_CRC8 connection_frame[2:3] = static.MYCALLSIGN_CRC8 connection_frame[12:13] = bytes([static.ARQ_DATA_CHANNEL_MODE]) - #connection_frame[13:14] = bytes([226]) + #connection_frame[13:14] = bytes([226]) modem.transmit_signalling(connection_frame) while static.CHANNEL_STATE == 'SENDING_SIGNALLING': time.sleep(0.01) - - #print("waiting for data....") + + # print("waiting for data....") static.CHANNEL_STATE = 'RECEIVING_DATA' - # einen timeout benötigen wir auch noch.... + # einen timeout benötigen wir auch noch.... # und ab hier geht es dann in den "RECEIVING_DATA" mode.... - + + def arq_received_channel_is_open(data_in): static.ARQ_SEND_KEEP_ALIVE == False - + if static.ARQ_DATA_CHANNEL_MODE == int.from_bytes(bytes(data_in[12:13]), "big"): - logging.info("DATA ["+ str(static.MYCALLSIGN, 'utf-8') + "]>>|<<["+ str(static.DXCALLSIGN, 'utf-8') + "] [BER."+str(static.BER)+"]") + logging.info("DATA [" + str(static.MYCALLSIGN, 'utf-8') + "]>>|<<[" + str(static.DXCALLSIGN, 'utf-8') + "] [BER." + str(static.BER) + "]") time.sleep(1) static.ARQ_READY_FOR_DATA = True -############################################################################################################# +# ############################################################################################################ # DISCONNECT HANDLER -############################################################################################################# +# ############################################################################################################ async def arq_disconnect(): - + # we need to create a "force ignore all" so we don't receive frames any more... Then we don't need a timer static.ARQ_SEND_KEEP_ALIVE == False - static.ARQ_STATE = 'DISCONNECTING' - logging.info("DISC ["+ str(static.MYCALLSIGN, 'utf-8') + "] <-> ["+ str(static.DXCALLSIGN, 'utf-8') + "] [BER."+str(static.BER)+"]") - #frame_type = bytes([222]) - #disconnection_frame = frame_type + static.MYCALLSIGN - + static.ARQ_STATE = 'DISCONNECTING' + logging.info("DISC [" + str(static.MYCALLSIGN, 'utf-8') + "] <-> [" + str(static.DXCALLSIGN, 'utf-8') + "] [BER." + str(static.BER) + "]") + # frame_type = bytes([222]) + # disconnection_frame = frame_type + static.MYCALLSIGN + disc_frame = bytearray(14) disc_frame[:1] = bytes([222]) disc_frame[1:2] = static.DXCALLSIGN_CRC8 disc_frame[2:3] = static.MYCALLSIGN_CRC8 - - #while static.CHANNEL_STATE == 'SENDING_SIGNALLING': + + # while static.CHANNEL_STATE == 'SENDING_SIGNALLING': # time.sleep(0.01) - + await asyncio.sleep(4) modem.transmit_signalling(disc_frame) while static.CHANNEL_STATE == 'SENDING_SIGNALLING': - time.sleep(0.01) - - logging.info("DISC ["+ str(static.MYCALLSIGN, 'utf-8') + "]< X >["+ str(static.DXCALLSIGN, 'utf-8') + "] [BER."+str(static.BER)+"]") + time.sleep(0.01) + + logging.info("DISC [" + str(static.MYCALLSIGN, 'utf-8') + "]< X >[" + str(static.DXCALLSIGN, 'utf-8') + "] [BER." + str(static.BER) + "]") static.ARQ_STATE = 'IDLE' static.DXCALLSIGN = b'' static.DXCALLSIGN_CRC8 = b'' - + + def arq_disconnect_received(data_in): - static.ARQ_STATE = 'DISCONNECTED' - logging.info("DISC ["+ str(static.MYCALLSIGN, 'utf-8') + "]< X >["+ str(static.DXCALLSIGN, 'utf-8') + "] [BER."+str(static.BER)+"]") static.ARQ_STATE = 'DISCONNECTED' - static.TNC_STATE = 'IDLE' + logging.info("DISC [" + str(static.MYCALLSIGN, 'utf-8') + "]< X >[" + str(static.DXCALLSIGN, 'utf-8') + "] [BER." + str(static.BER) + "]") + static.ARQ_STATE = 'DISCONNECTED' + static.TNC_STATE = 'IDLE' static.DXCALLSIGN = b'' static.DXCALLSIGN_CRC8 = b'' - -############################################################################################################# +# ############################################################################################################ # PING HANDLER -############################################################################################################# - +# ############################################################################################################ + async def transmit_ping(callsign): static.DXCALLSIGN = bytes(callsign, 'utf-8').rstrip(b'\x00') static.DXCALLSIGN_CRC8 = helpers.get_crc_8(static.DXCALLSIGN) - logging.info("PING ["+ str(static.MYCALLSIGN, 'utf-8') + "] >>> [" + str(static.DXCALLSIGN, 'utf-8') + "] [BER."+str(static.BER)+"]") - + logging.info("PING [" + str(static.MYCALLSIGN, 'utf-8') + "] >>> [" + str(static.DXCALLSIGN, 'utf-8') + "] [BER." + str(static.BER) + "]") + ping_frame = bytearray(14) ping_frame[:1] = bytes([210]) ping_frame[1:2] = static.DXCALLSIGN_CRC8 ping_frame[2:3] = static.MYCALLSIGN_CRC8 ping_frame[3:9] = static.MYCALLSIGN - # wait while sending.... modem.transmit_signalling(ping_frame) while static.CHANNEL_STATE == 'SENDING_SIGNALLING': - time.sleep(0.01) - + time.sleep(0.01) + + def received_ping(data_in): static.DXCALLSIGN_CRC8 = bytes(data_in[2:3]).rstrip(b'\x00') static.DXCALLSIGN = bytes(data_in[3:9]).rstrip(b'\x00') - logging.info("PING ["+ str(static.MYCALLSIGN, 'utf-8') + "] <<< ["+ str(static.DXCALLSIGN, 'utf-8') + "] [BER."+str(static.BER)+"]") + logging.info("PING [" + str(static.MYCALLSIGN, 'utf-8') + "] <<< [" + str(static.DXCALLSIGN, 'utf-8') + "] [BER." + str(static.BER) + "]") ping_frame = bytearray(14) ping_frame[:1] = bytes([211]) ping_frame[1:2] = static.DXCALLSIGN_CRC8 ping_frame[2:3] = static.MYCALLSIGN_CRC8 ping_frame[3:9] = static.MYCALLSIGN - + # wait while sending.... modem.transmit_signalling(ping_frame) while static.CHANNEL_STATE == 'SENDING_SIGNALLING': - time.sleep(0.01) + time.sleep(0.01) + + def received_ping_ack(data_in): static.DXCALLSIGN_CRC8 = bytes(data_in[2:3]).rstrip(b'\x00') static.DXCALLSIGN = bytes(data_in[3:9]).rstrip(b'\x00') - logging.info("PING [" + str(static.DXCALLSIGN, 'utf-8') + "] >|< [" + str(static.MYCALLSIGN, 'utf-8') + "] [BER."+str(static.BER)+"]") + logging.info("PING [" + str(static.DXCALLSIGN, 'utf-8') + "] >|< [" + str(static.MYCALLSIGN, 'utf-8') + "] [BER." + str(static.BER) + "]") static.TNC_STATE = 'IDLE' -############################################################################################################# +# ############################################################################################################ # BROADCAST HANDLER -############################################################################################################# - +# ############################################################################################################ + + async def transmit_cq(): logging.info("CQ CQ CQ") - + cq_frame = bytearray(14) cq_frame[:1] = bytes([200]) cq_frame[1:2] = b'\x01' cq_frame[2:3] = static.MYCALLSIGN_CRC8 cq_frame[3:9] = static.MYCALLSIGN - - for i in range(0,3): - + + for i in range(0, 3): + modem.transmit_signalling(cq_frame) while static.CHANNEL_STATE == 'SENDING_SIGNALLING': time.sleep(0.01) - + + def received_cq(data_in): static.DXCALLSIGN = b'' static.DXCALLSIGN_CRC8 = b'' - logging.info("CQ [" + str(bytes(data_in[3:9]), 'utf-8') + "] [BER."+str(static.BER)+"]") - - ## here we add the received station to the heard stations buffer + logging.info("CQ RCVD [" + str(bytes(data_in[3:9]), 'utf-8') + "] [BER." + str(static.BER) + "]") + + # here we add the received station to the heard stations buffer dxcallsign = bytes(data_in[3:9]).rstrip(b'\x00') # check if buffer empty if len(static.HEARD_STATIONS) == 0: static.HEARD_STATIONS.append([dxcallsign, int(time.time())]) - # if not, we search and update + # if not, we search and update else: - for i in range(0,len(static.HEARD_STATIONS)): + for i in range(0, len(static.HEARD_STATIONS)): # update callsign with new timestamp if static.HEARD_STATIONS[i].count(dxcallsign) > 0: static.HEARD_STATIONS[i] = [dxcallsign, int(time.time())] break # insert if nothing found - if i == len(static.HEARD_STATIONS)-1: + if i == len(static.HEARD_STATIONS) - 1: static.HEARD_STATIONS.append([dxcallsign, int(time.time())]) break - + async def transmit_beacon(): logging.info("BEACON") @@ -780,3 +777,26 @@ async def transmit_beacon(): modem.transmit_signalling(beacon_frame) while static.CHANNEL_STATE == 'SENDING_SIGNALLING': time.sleep(0.01) + + +def received_beacon(): + static.DXCALLSIGN = b'' + static.DXCALLSIGN_CRC8 = b'' + logging.info("BEACON RCVD [" + str(bytes(data_in[3:9]), 'utf-8') + "] [BER." + str(static.BER) + "]") + + # here we add the received station to the heard stations buffer + dxcallsign = bytes(data_in[3:9]).rstrip(b'\x00') + # check if buffer empty + if len(static.HEARD_STATIONS) == 0: + static.HEARD_STATIONS.append([dxcallsign, int(time.time())]) + # if not, we search and update + else: + for i in range(0, len(static.HEARD_STATIONS)): + # update callsign with new timestamp + if static.HEARD_STATIONS[i].count(dxcallsign) > 0: + static.HEARD_STATIONS[i] = [dxcallsign, int(time.time())] + break + # insert if nothing found + if i == len(static.HEARD_STATIONS) - 1: + static.HEARD_STATIONS.append([dxcallsign, int(time.time())]) + break diff --git a/helpers.py b/helpers.py index 96e034b2..e41e023a 100644 --- a/helpers.py +++ b/helpers.py @@ -7,31 +7,27 @@ Created on Fri Dec 25 21:25:14 2020 """ import time -import threading import logging -import crcengine -import pyaudio import asyncio +import crcengine -import data_handler import static - - - def get_crc_8(data): - crc_algorithm = crcengine.new('crc8-ccitt') #load crc8 library + crc_algorithm = crcengine.new('crc8-ccitt') # load crc8 library crc_data = crc_algorithm(data) - crc_data = crc_data.to_bytes(1, byteorder='big') + crc_data = crc_data.to_bytes(1, byteorder='big') return crc_data + def get_crc_16(data): - crc_algorithm = crcengine.new('crc16-ccitt-false') #load crc16 library + crc_algorithm = crcengine.new('crc16-ccitt-false') # load crc16 library crc_data = crc_algorithm(data) - crc_data = crc_data.to_bytes(2, byteorder='big') - return crc_data + crc_data = crc_data.to_bytes(2, byteorder='big') + return crc_data + async def set_after_timeout(): while True: @@ -40,41 +36,45 @@ async def set_after_timeout(): print("HALLOIOIOIOIOIOI") static.ARQ_RX_ACK_TIMEOUT = True await asyncio.sleep(1.1) - #await asyncio.sleep(timeout) + # await asyncio.sleep(timeout) #vars()[variable] = value - - + def arq_disconnect_timeout(): static.ARQ_WAIT_FOR_DISCONNECT = True - logging.debug("ARQ_WAIT_FOR_DISCONNECT") - - + logging.debug("ARQ_WAIT_FOR_DISCONNECT") + + def arq_ack_timeout(): if static.CHANNEL_STATE == 'RECEIVING_SIGNALLING': static.ARQ_RX_ACK_TIMEOUT = True logging.debug("ARQ_RX_ACK_TIMEOUT") - + + def arq_rpt_timeout(): if static.CHANNEL_STATE == 'RECEIVING_SIGNALLING': - static.ARQ_RX_RPT_TIMEOUT = True - logging.debug("ARQ_RX_RPT_TIMEOUT") + static.ARQ_RX_RPT_TIMEOUT = True + logging.debug("ARQ_RX_RPT_TIMEOUT") + def arq_frame_timeout(): if static.CHANNEL_STATE == 'RECEIVING_SIGNALLING': - static.ARQ_RX_FRAME_TIMEOUT = True - logging.debug("ARQ_RX_FRAME_TIMEOUT") - + static.ARQ_RX_FRAME_TIMEOUT = True + logging.debug("ARQ_RX_FRAME_TIMEOUT") + + def arq_reset_timeout(state): static.ARQ_RX_ACK_TIMEOUT = state static.ARQ_RX_FRAME_TIMEOUT = state static.ARQ_RX_RPT_TIMEOUT = state - -def arq_reset_ack(state): + + +def arq_reset_ack(state): static.ARQ_ACK_RECEIVED = state static.ARQ_RPT_RECEIVED = state static.ARQ_FRAME_ACK_RECEIVED = state - + + def arq_reset_frame_machine(): arq_reset_timeout(False) arq_reset_ack(False) @@ -84,42 +84,41 @@ def arq_reset_frame_machine(): static.ARQ_TX_N_CURRENT_ARQ_FRAME = 0 static.ARQ_TX_N_TOTAL_ARQ_FRAMES = 0 static.ARQ_TX_N_CURRENT_ARQ_FRAME = 0 - + static.ARQ_RX_N_CURRENT_ARQ_FRAME = 0 static.ARQ_N_ARQ_FRAMES_PER_DATA_FRAME = 0 static.ARQ_FRAME_BOF_RECEIVED = False - static.ARQ_FRAME_EOF_RECEIVED = False - + static.ARQ_FRAME_EOF_RECEIVED = False - static.TNC_STATE = 'IDLE' + static.TNC_STATE = 'IDLE' static.ARQ_SEND_KEEP_ALIVE = True static.CHANNEL_STATE = 'RECEIVING_SIGNALLING' static.ARQ_READY_FOR_DATA = False - - #start sending keep alive after some seconds + + # start sending keep alive after some seconds #acktimer = threading.Timer(3.0, data_handler.arq_connect) - #acktimer.start() - #await asyncio.sleep(2) - #modem.transmit_arq_connect() + # acktimer.start() + # await asyncio.sleep(2) + # modem.transmit_arq_connect() + + def setup_logging(): - + logging.basicConfig(format='%(asctime)s.%(msecs)03d %(levelname)s:\t%(message)s', datefmt='%H:%M:%S', level=logging.INFO) - logging.addLevelName( logging.DEBUG, "\033[1;36m%s\033[1;0m" % logging.getLevelName(logging.DEBUG)) - logging.addLevelName( logging.INFO, "\033[1;37m%s\033[1;0m" % logging.getLevelName(logging.INFO)) - logging.addLevelName( logging.WARNING, "\033[1;33m%s\033[1;0m" % logging.getLevelName(logging.WARNING)) - logging.addLevelName( logging.ERROR, "\033[1;31m%s\033[1;0m" % "FAILED") + logging.addLevelName(logging.DEBUG, "\033[1;36m%s\033[1;0m" % logging.getLevelName(logging.DEBUG)) + logging.addLevelName(logging.INFO, "\033[1;37m%s\033[1;0m" % logging.getLevelName(logging.INFO)) + logging.addLevelName(logging.WARNING, "\033[1;33m%s\033[1;0m" % logging.getLevelName(logging.WARNING)) + logging.addLevelName(logging.ERROR, "\033[1;31m%s\033[1;0m" % "FAILED") #logging.addLevelName( logging.ERROR, "\033[1;31m%s\033[1;0m" % logging.getLevelName(logging.ERROR)) - logging.addLevelName( logging.CRITICAL, "\033[1;41m%s\033[1;0m" % logging.getLevelName(logging.CRITICAL)) - - logging.addLevelName( 25, "\033[1;32m%s\033[1;0m" % "SUCCESS") - logging.addLevelName( 24, "\033[1;34m%s\033[1;0m" % "DATA") + logging.addLevelName(logging.CRITICAL, "\033[1;41m%s\033[1;0m" % logging.getLevelName(logging.CRITICAL)) + + logging.addLevelName(25, "\033[1;32m%s\033[1;0m" % "SUCCESS") + logging.addLevelName(24, "\033[1;34m%s\033[1;0m" % "DATA") - # https://stackoverflow.com/questions/384076/how-can-i-color-python-logging-output - #'DEBUG' : 37, # white - #'INFO' : 36, # cyan - #'WARNING' : 33, # yellow - #'ERROR' : 31, # red - #'CRITICAL': 41, # white on red bg - + # 'DEBUG' : 37, # white + # 'INFO' : 36, # cyan + # 'WARNING' : 33, # yellow + # 'ERROR' : 31, # red + # 'CRITICAL': 41, # white on red bg diff --git a/main.py b/main.py index bbd18746..a269b08f 100644 --- a/main.py +++ b/main.py @@ -17,23 +17,23 @@ if __name__ == '__main__': # config logging helpers.setup_logging() - - #--------------------------------------------GET PARAMETER INPUTS + + # --------------------------------------------GET PARAMETER INPUTS PARSER = argparse.ArgumentParser(description='Simons TEST TNC') PARSER.add_argument('--rx', dest="audio_input_device", default=0, help="listening sound card", type=int) PARSER.add_argument('--tx', dest="audio_output_device", default=0, help="transmitting sound card", type=int) - PARSER.add_argument('--port', dest="socket_port", default=3000, help="Socket port", type=int) - #parser.add_argument('--mode', dest="freedv_data_mode", default=12, help="Set the mode.", type=int) - + PARSER.add_argument('--port', dest="socket_port", default=3000, help="Socket port", type=int) + # parser.add_argument('--mode', dest="freedv_data_mode", default=12, help="Set the mode.", type=int) + ARGS = PARSER.parse_args() - - #static.FREEDV_DATA_MODE = args.freedv_data_mode + + # static.FREEDV_DATA_MODE = args.freedv_data_mode static.AUDIO_INPUT_DEVICE = ARGS.audio_input_device static.AUDIO_OUTPUT_DEVICE = ARGS.audio_output_device static.PORT = ARGS.socket_port - - #--------------------------------------------START CMD SERVER - import sock # we need to wait until we got all parameters from argparse first + + # --------------------------------------------START CMD SERVER + import sock # we need to wait until we got all parameters from argparse first CMD_SERVER_THREAD = threading.Thread(target=sock.start_cmd_socket, name="cmd server") CMD_SERVER_THREAD.start() diff --git a/modem.py b/modem.py index a86ca0cc..9da40387 100644 --- a/modem.py +++ b/modem.py @@ -24,68 +24,63 @@ import data_handler import Hamlib - class RF(): - - def __init__(self): - #-------------------------------------------- LOAD FREEDV + + def __init__(self): + # -------------------------------------------- LOAD FREEDV libname = pathlib.Path().absolute() / "codec2/build_linux/src/libcodec2.so" self.c_lib = ctypes.CDLL(libname) - #--------------------------------------------CREATE PYAUDIO INSTANCE + # --------------------------------------------CREATE PYAUDIO INSTANCE self.p = pyaudio.PyAudio() - #--------------------------------------------GET SUPPORTED SAMPLE RATES FROM SOUND DEVICE + # --------------------------------------------GET SUPPORTED SAMPLE RATES FROM SOUND DEVICE #static.AUDIO_SAMPLE_RATE_RX = int(self.p.get_device_info_by_index(static.AUDIO_INPUT_DEVICE)['defaultSampleRate']) #static.AUDIO_SAMPLE_RATE_TX = int(self.p.get_device_info_by_index(static.AUDIO_OUTPUT_DEVICE)['defaultSampleRate']) static.AUDIO_SAMPLE_RATE_TX = 8000 static.AUDIO_SAMPLE_RATE_RX = 8000 - #--------------------------------------------OPEN AUDIO CHANNEL RX - self.stream_rx = self.p.open(format=pyaudio.paInt16, - channels=static.AUDIO_CHANNELS, - rate=static.AUDIO_SAMPLE_RATE_RX, - frames_per_buffer=static.AUDIO_FRAMES_PER_BUFFER, - input=True, - input_device_index=static.AUDIO_INPUT_DEVICE, - ) - #--------------------------------------------OPEN AUDIO CHANNEL TX + # --------------------------------------------OPEN AUDIO CHANNEL RX + self.stream_rx = self.p.open(format=pyaudio.paInt16, + channels=static.AUDIO_CHANNELS, + rate=static.AUDIO_SAMPLE_RATE_RX, + frames_per_buffer=static.AUDIO_FRAMES_PER_BUFFER, + input=True, + input_device_index=static.AUDIO_INPUT_DEVICE, + ) + # --------------------------------------------OPEN AUDIO CHANNEL TX self.stream_tx = self.p.open(format=pyaudio.paInt16, - channels=1, - rate=static.AUDIO_SAMPLE_RATE_TX, - frames_per_buffer=static.AUDIO_FRAMES_PER_BUFFER, #n_nom_modem_samples - output=True, - output_device_index=static.AUDIO_OUTPUT_DEVICE, #static.AUDIO_OUTPUT_DEVICE - ) - - + channels=1, + rate=static.AUDIO_SAMPLE_RATE_TX, + frames_per_buffer=static.AUDIO_FRAMES_PER_BUFFER, # n_nom_modem_samples + output=True, + output_device_index=static.AUDIO_OUTPUT_DEVICE, # static.AUDIO_OUTPUT_DEVICE + ) + self.streambuffer = bytes(0) - self.audio_writing_to_stream = False - #--------------------------------------------START DECODER THREAD + self.audio_writing_to_stream = False + # --------------------------------------------START DECODER THREAD FREEDV_DECODER_THREAD_10 = threading.Thread(target=self.receive, args=[10], name="FREEDV_DECODER_THREAD_10") FREEDV_DECODER_THREAD_10.start() - + FREEDV_DECODER_THREAD_11 = threading.Thread(target=self.receive, args=[11], name="FREEDV_DECODER_THREAD_11") FREEDV_DECODER_THREAD_11.start() - + FREEDV_DECODER_THREAD_12 = threading.Thread(target=self.receive, args=[12], name="FREEDV_DECODER_THREAD_12") FREEDV_DECODER_THREAD_12.start() - + FREEDV_DECODER_THREAD_14 = threading.Thread(target=self.receive, args=[static.FREEDV_SIGNALLING_MODE], name="FREEDV_DECODER_THREAD_14") FREEDV_DECODER_THREAD_14.start() - + FREEDV_PLAYBACK_THREAD = threading.Thread(target=self.play_audio, name="FREEDV_DECODER_THREAD_14") FREEDV_PLAYBACK_THREAD.start() - - - #--------------------------------------------CONFIGURE HAMLIB + + # --------------------------------------------CONFIGURE HAMLIB Hamlib.rig_set_debug(Hamlib.RIG_DEBUG_NONE) # Init RIG_MODEL_DUMMY self.my_rig = Hamlib.Rig(Hamlib.RIG_MODEL_DUMMY) self.my_rig.set_conf("rig_pathname", "/dev/Rig") self.my_rig.set_conf("retry", "5") - self.my_rig.open () - - - + self.my_rig.open() + if static.HAMLIB_PTT_TYPE == 'RIG_PTT_RIG': self.hamlib_ptt_type = Hamlib.RIG_PTT_RIG elif static.HAMLIB_PTT_TYPE == 'RIG_PTT_SERIAL_DTR': @@ -98,284 +93,282 @@ class RF(): self.hamlib_ptt_type = Hamlib.RIG_PTT_RIG_MICDATA elif static.HAMLIB_PTT_TYPE == 'RIG_PTT_CM108': self.hamlib_ptt_type = Hamlib.RIG_PTT_CM108 - else:# static.HAMLIB_PTT_TYPE == 'RIG_PTT_NONE': + else: # static.HAMLIB_PTT_TYPE == 'RIG_PTT_NONE': self.hamlib_ptt_type = Hamlib.RIG_PTT_NONE - - self.my_rig.set_ptt(self.hamlib_ptt_type,0) - -#-------------------------------------------------------------------------------------------------------- + + self.my_rig.set_ptt(self.hamlib_ptt_type, 0) + +# -------------------------------------------------------------------------------------------------------- def play_audio(self): - - while True: + + while True: time.sleep(0.01) #state_before_transmit = static.CHANNEL_STATE while len(self.streambuffer) > 0: - time.sleep(0.01) + time.sleep(0.01) if len(self.streambuffer) > 0: - #print(self.streambuffer) + # print(self.streambuffer) self.audio_writing_to_stream = True self.stream_tx.write(self.streambuffer) self.streambuffer = bytes() #static.CHANNEL_STATE = state_before_transmit self.audio_writing_to_stream = False -#-------------------------------------------------------------------------------------------------------- - def transmit_signalling(self,data_out): +# -------------------------------------------------------------------------------------------------------- + + def transmit_signalling(self, data_out): state_before_transmit = static.CHANNEL_STATE - static.CHANNEL_STATE = 'SENDING_SIGNALLING' + static.CHANNEL_STATE = 'SENDING_SIGNALLING' static.PTT_STATE = True - self.my_rig.set_ptt(self.hamlib_ptt_type,1) - + self.my_rig.set_ptt(self.hamlib_ptt_type, 1) + self.c_lib.freedv_open.restype = ctypes.POINTER(ctypes.c_ubyte) freedv = self.c_lib.freedv_open(static.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 + 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) - n_tx_modem_samples = self.c_lib.freedv_get_n_tx_modem_samples(freedv) #get n_tx_modem_samples which defines the size of the modulation object - n_tx_preamble_modem_samples = self.c_lib.freedv_get_n_tx_preamble_modem_samples(freedv) - + n_tx_modem_samples = self.c_lib.freedv_get_n_tx_modem_samples(freedv) # get n_tx_modem_samples which defines the size of the modulation object + n_tx_preamble_modem_samples = self.c_lib.freedv_get_n_tx_preamble_modem_samples(freedv) + mod_out = ctypes.c_short * n_tx_modem_samples mod_out = mod_out() - mod_out_preamble = ctypes.c_short * n_tx_preamble_modem_samples #*2 #1760 for mode 10,11,12 #4000 for mode 9 + mod_out_preamble = ctypes.c_short * n_tx_preamble_modem_samples # *2 #1760 for mode 10,11,12 #4000 for mode 9 mod_out_preamble = mod_out_preamble() - buffer = bytearray(payload_per_frame) # use this if CRC16 checksum is required ( DATA1-3) - buffer[:len(data_out)] = data_out # set buffersize to length of data which will be send + buffer = bytearray(payload_per_frame) # use this if CRC16 checksum is required ( DATA1-3) + buffer[:len(data_out)] = data_out # set buffersize to length of data which will be send crc = ctypes.c_ushort(self.c_lib.freedv_gen_crc16(bytes(buffer), payload_per_frame)) # generate CRC16 - crc = crc.value.to_bytes(2, byteorder='big') # convert crc to 2 byte hex string + crc = crc.value.to_bytes(2, byteorder='big') # convert crc to 2 byte hex string buffer += crc # append crc16 to buffer data = (ctypes.c_ubyte * bytes_per_frame).from_buffer_copy(buffer) - - self.c_lib.freedv_rawdatapreambletx(freedv, mod_out_preamble) - self.c_lib.freedv_rawdatatx(freedv,mod_out,data) # modulate DATA and safe it into mod_out pointer - - txbuffer = bytearray() + + self.c_lib.freedv_rawdatapreambletx(freedv, mod_out_preamble) + self.c_lib.freedv_rawdatatx(freedv, mod_out, data) # modulate DATA and safe it into mod_out pointer + + txbuffer = bytearray() txbuffer += bytes(mod_out_preamble) txbuffer += bytes(mod_out) - + # -------------- transmit audio logging.debug("SENDING SIGNALLING FRAME " + str(data_out)) - - self.streambuffer = bytes() + + self.streambuffer = bytes() self.streambuffer = bytes(txbuffer) self.audio_writing_to_stream = True - #wait until audio has been processed + # wait until audio has been processed while self.audio_writing_to_stream == True: time.sleep(0.01) static.CHANNEL_STATE = 'SENDING_SIGNALLING' #print("sending signalling...") - - self.my_rig.set_ptt(self.hamlib_ptt_type,0) - static.PTT_STATE = False + + self.my_rig.set_ptt(self.hamlib_ptt_type, 0) + static.PTT_STATE = False static.CHANNEL_STATE = state_before_transmit - - self.c_lib.freedv_close(freedv) - #time.sleep(0.5) -#-------------------------------------------------------------------------------------------------------- - # GET ARQ BURST FRAME VOM BUFFER AND MODULATE IT + + self.c_lib.freedv_close(freedv) + # time.sleep(0.5) +# -------------------------------------------------------------------------------------------------------- + # GET ARQ BURST FRAME VOM BUFFER AND MODULATE IT + def transmit_arq_burst(self): - - self.my_rig.set_ptt(self.hamlib_ptt_type,1) + + self.my_rig.set_ptt(self.hamlib_ptt_type, 1) static.PTT_STATE = True state_before_transmit = static.CHANNEL_STATE static.CHANNEL_STATE = 'SENDING_DATA' self.c_lib.freedv_open.restype = ctypes.POINTER(ctypes.c_ubyte) freedv = self.c_lib.freedv_open(static.ARQ_DATA_CHANNEL_MODE) - - static.FREEDV_DATA_BYTES_PER_FRAME = int(self.c_lib.freedv_get_bits_per_modem_frame(freedv)/8) - static.FREEDV_DATA_PAYLOAD_PER_FRAME = static.FREEDV_DATA_BYTES_PER_FRAME -2 - + + static.FREEDV_DATA_BYTES_PER_FRAME = int(self.c_lib.freedv_get_bits_per_modem_frame(freedv) / 8) + static.FREEDV_DATA_PAYLOAD_PER_FRAME = static.FREEDV_DATA_BYTES_PER_FRAME - 2 + n_nom_modem_samples = self.c_lib.freedv_get_n_nom_modem_samples(freedv) - n_tx_modem_samples = self.c_lib.freedv_get_n_tx_modem_samples(freedv)#*2 #get n_tx_modem_samples which defines the size of the modulation object + n_tx_modem_samples = self.c_lib.freedv_get_n_tx_modem_samples(freedv) # *2 #get n_tx_modem_samples which defines the size of the modulation object n_tx_preamble_modem_samples = self.c_lib.freedv_get_n_tx_preamble_modem_samples(freedv) - + mod_out = ctypes.c_short * n_tx_modem_samples mod_out = mod_out() - mod_out_preamble = ctypes.c_short * n_tx_preamble_modem_samples #*2 #1760 for mode 10,11,12 #4000 for mode 9 + mod_out_preamble = ctypes.c_short * n_tx_preamble_modem_samples # *2 #1760 for mode 10,11,12 #4000 for mode 9 mod_out_preamble = mod_out_preamble() - self.c_lib.freedv_rawdatapreambletx(freedv, mod_out_preamble); + self.c_lib.freedv_rawdatapreambletx(freedv, mod_out_preamble) txbuffer = bytearray() txbuffer += bytes(mod_out_preamble) if static.ARQ_RPT_RECEIVED == False: - for n in range(0,static.ARQ_TX_N_FRAMES_PER_BURST): + for n in range(0, static.ARQ_TX_N_FRAMES_PER_BURST): - #---------------------------BUILD ARQ BURST --------------------------------------------------------------------- - frame_type = 10 + n + 1 #static.ARQ_TX_N_FRAMES_PER_BURST + # ---------------------------BUILD ARQ BURST --------------------------------------------------------------------- + frame_type = 10 + n + 1 # static.ARQ_TX_N_FRAMES_PER_BURST frame_type = bytes([frame_type]) payload_data = bytes(static.TX_BUFFER[static.ARQ_N_SENT_FRAMES + n]) - + n_current_arq_frame = static.ARQ_N_SENT_FRAMES + n + 1 static.ARQ_TX_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.to_bytes(2, byteorder='big') - + arqframe = frame_type + \ - bytes([static.ARQ_TX_N_FRAMES_PER_BURST]) + \ - static.ARQ_TX_N_CURRENT_ARQ_FRAME + \ - static.ARQ_TX_N_TOTAL_ARQ_FRAMES + \ - static.DXCALLSIGN_CRC8 + \ - static.MYCALLSIGN_CRC8 + \ - payload_data - - #print(arqframe) - - buffer = bytearray(static.FREEDV_DATA_PAYLOAD_PER_FRAME) # create TX buffer - buffer[:len(arqframe)] = arqframe # set buffersize to length of data which will be send - + bytes([static.ARQ_TX_N_FRAMES_PER_BURST]) + \ + static.ARQ_TX_N_CURRENT_ARQ_FRAME + \ + static.ARQ_TX_N_TOTAL_ARQ_FRAMES + \ + static.DXCALLSIGN_CRC8 + \ + static.MYCALLSIGN_CRC8 + \ + payload_data + + # print(arqframe) + + buffer = bytearray(static.FREEDV_DATA_PAYLOAD_PER_FRAME) # create TX buffer + buffer[:len(arqframe)] = arqframe # set buffersize to length of data which will be send + crc = ctypes.c_ushort(self.c_lib.freedv_gen_crc16(bytes(buffer), static.FREEDV_DATA_PAYLOAD_PER_FRAME)) # generate CRC16 - crc = crc.value.to_bytes(2, byteorder='big') # convert crc to 2 byte hex string + crc = crc.value.to_bytes(2, byteorder='big') # convert crc to 2 byte hex string buffer += crc # append crc16 to buffer data = (ctypes.c_ubyte * static.FREEDV_DATA_BYTES_PER_FRAME).from_buffer_copy(buffer) - self.c_lib.freedv_rawdatatx(freedv,mod_out,data) # modulate DATA and safe it into mod_out pointer + self.c_lib.freedv_rawdatatx(freedv, mod_out, data) # modulate DATA and safe it into mod_out pointer txbuffer += bytes(mod_out) - + elif static.ARQ_RPT_RECEIVED == True: - - for n in range(0,len(static.ARQ_RPT_FRAMES)): + + for n in range(0, len(static.ARQ_RPT_FRAMES)): missing_frame = int.from_bytes(static.ARQ_RPT_FRAMES[n], "big") - - #---------------------------BUILD ARQ BURST --------------------------------------------------------------------- - frame_type = 10 + missing_frame #static.ARQ_TX_N_FRAMES_PER_BURST + + # ---------------------------BUILD ARQ BURST --------------------------------------------------------------------- + frame_type = 10 + missing_frame # static.ARQ_TX_N_FRAMES_PER_BURST frame_type = bytes([frame_type]) payload_data = bytes(static.TX_BUFFER[static.ARQ_N_SENT_FRAMES + missing_frame - 1]) - + n_current_arq_frame = static.ARQ_N_SENT_FRAMES + missing_frame static.ARQ_TX_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.to_bytes(2, byteorder='big') - - arqframe = frame_type + \ - bytes([static.ARQ_TX_N_FRAMES_PER_BURST]) + \ - static.ARQ_TX_N_CURRENT_ARQ_FRAME + \ - static.ARQ_TX_N_TOTAL_ARQ_FRAMES + \ - static.DXCALLSIGN_CRC8 + \ - static.MYCALLSIGN_CRC8 + \ - payload_data - buffer = bytearray(static.FREEDV_DATA_PAYLOAD_PER_FRAME) # create TX buffer - buffer[:len(arqframe)] = arqframe # set buffersize to length of data which will be send - + arqframe = frame_type + \ + bytes([static.ARQ_TX_N_FRAMES_PER_BURST]) + \ + static.ARQ_TX_N_CURRENT_ARQ_FRAME + \ + static.ARQ_TX_N_TOTAL_ARQ_FRAMES + \ + static.DXCALLSIGN_CRC8 + \ + static.MYCALLSIGN_CRC8 + \ + payload_data + + buffer = bytearray(static.FREEDV_DATA_PAYLOAD_PER_FRAME) # create TX buffer + buffer[:len(arqframe)] = arqframe # set buffersize to length of data which will be send + crc = ctypes.c_ushort(self.c_lib.freedv_gen_crc16(bytes(buffer), static.FREEDV_DATA_PAYLOAD_PER_FRAME)) # generate CRC16 - crc = crc.value.to_bytes(2, byteorder='big') # convert crc to 2 byte hex string + crc = crc.value.to_bytes(2, byteorder='big') # convert crc to 2 byte hex string buffer += crc # append crc16 to buffer - + data = (ctypes.c_ubyte * static.FREEDV_DATA_BYTES_PER_FRAME).from_buffer_copy(buffer) - self.c_lib.freedv_rawdatatx(freedv,mod_out,data) # modulate DATA and safe it into mod_out pointer + self.c_lib.freedv_rawdatatx(freedv, mod_out, data) # modulate DATA and safe it into mod_out pointer txbuffer += bytes(mod_out) - - + # -------------- transmit audio - - - #self.stream_tx.write(bytes(txbuffer)) - self.streambuffer = bytes() + + # self.stream_tx.write(bytes(txbuffer)) + self.streambuffer = bytes() self.streambuffer = bytes(txbuffer) self.audio_writing_to_stream = True - #wait until audio has been processed + # wait until audio has been processed while self.audio_writing_to_stream == True: time.sleep(0.01) static.CHANNEL_STATE = 'SENDING_DATA' #print("sending data...") - + static.CHANNEL_STATE = 'RECEIVING_SIGNALLING' static.PTT_STATE = False - self.my_rig.set_ptt(self.hamlib_ptt_type,0) - - self.c_lib.freedv_close(freedv) -#-------------------------------------------------------------------------------------------------------- + self.my_rig.set_ptt(self.hamlib_ptt_type, 0) - def receive(self,mode): + self.c_lib.freedv_close(freedv) +# -------------------------------------------------------------------------------------------------------- + + def receive(self, mode): force = True - - self.c_lib.freedv_open.restype = ctypes.POINTER(ctypes.c_ubyte) + + self.c_lib.freedv_open.restype = ctypes.POINTER(ctypes.c_ubyte) freedv = self.c_lib.freedv_open(mode) - bytes_per_frame = int(self.c_lib.freedv_get_bits_per_modem_frame(freedv)/8) - + bytes_per_frame = int(self.c_lib.freedv_get_bits_per_modem_frame(freedv) / 8) + if mode == static.FREEDV_SIGNALLING_MODE: static.FREEDV_SIGNALLING_BYTES_PER_FRAME = bytes_per_frame static.FREEDV_SIGNALLING_PAYLOAD_PER_FRAME = bytes_per_frame - 2 - - self.c_lib.freedv_set_frames_per_burst(freedv, 1); - + + self.c_lib.freedv_set_frames_per_burst(freedv, 1) + elif mode == static.ARQ_DATA_CHANNEL_MODE: static.FREEDV_DATA_BYTES_PER_FRAME = bytes_per_frame static.FREEDV_DATA_PAYLOAD_PER_FRAME = bytes_per_frame - 2 - - self.c_lib.freedv_set_frames_per_burst(freedv, 0); + + self.c_lib.freedv_set_frames_per_burst(freedv, 0) else: pass - - - + bytes_out = (ctypes.c_ubyte * bytes_per_frame) - bytes_out = bytes_out() #get pointer to bytes_out + bytes_out = bytes_out() # get pointer to bytes_out while static.FREEDV_RECEIVE == True: time.sleep(0.05) - + # stuck in sync counter stuck_in_sync_counter = 0 stuck_in_sync_10_counter = 0 # - + # here we do an unsync to be sure, the modem is in idle state and ready for new data self.c_lib.freedv_set_sync(freedv, 0) - + # here we do a buffer cleanup before returning to demod loop dummy_mod = bytes(self.c_lib.freedv_nin(freedv)) self.c_lib.freedv_rawdatarx(freedv, bytes_out, dummy_mod) - - #demod loop + + # demod loop while (static.CHANNEL_STATE == 'RECEIVING_DATA' and static.ARQ_DATA_CHANNEL_MODE == mode) or (static.CHANNEL_STATE == 'RECEIVING_SIGNALLING' and static.FREEDV_SIGNALLING_MODE == mode): time.sleep(0.01) # refresh vars, so the correct parameters of the used mode are set static.FREEDV_DATA_BYTES_PER_FRAME = bytes_per_frame static.FREEDV_DATA_PAYLOAD_PER_FRAME = bytes_per_frame - 2 - + nin = self.c_lib.freedv_nin(freedv) #nin = int(nin*(static.AUDIO_SAMPLE_RATE_RX/static.MODEM_SAMPLE_RATE)) - data_in = self.stream_rx.read(nin, exception_on_overflow = False) + data_in = self.stream_rx.read(nin, exception_on_overflow=False) static.AUDIO_RMS = audioop.rms(data_in, 2) - #self.c_lib.freedv_rawdatarx.argtype = [ctypes.POINTER(ctypes.c_ubyte), data_bytes_out, data_in] # check if really neccessary - nbytes = self.c_lib.freedv_rawdatarx(freedv, bytes_out, data_in) # demodulate audio - #logging.debug(self.c_lib.freedv_get_rx_status(freedv)) + # self.c_lib.freedv_rawdatarx.argtype = [ctypes.POINTER(ctypes.c_ubyte), data_bytes_out, data_in] # check if really neccessary + nbytes = self.c_lib.freedv_rawdatarx(freedv, bytes_out, data_in) # demodulate audio + # logging.debug(self.c_lib.freedv_get_rx_status(freedv)) #print("listening-" + str(mode) + "-" + str(self.c_lib.freedv_get_rx_status(freedv))) - - #-------------STUCK IN SYNC DETECTOR + + # -------------STUCK IN SYNC DETECTOR stuck_in_sync_counter += 1 if self.c_lib.freedv_get_rx_status(freedv) == 10: stuck_in_sync_10_counter += 1 #self.c_lib.freedv_set_sync(freedv, 0) logging.warning("MODEM | SYNC 10 TRIGGER | M:" + str(mode) + " | " + str(static.CHANNEL_STATE)) - + if stuck_in_sync_counter == 33 and self.c_lib.freedv_get_rx_status(freedv) == 10: logging.critical("MODEM | stuck in sync #1") - self.c_lib.freedv_set_sync(freedv, 0) #FORCE UNSYNC + self.c_lib.freedv_set_sync(freedv, 0) # FORCE UNSYNC stuck_in_sync_counter = 0 stuck_in_sync_10_counter = 0 - + if stuck_in_sync_counter >= 66 and stuck_in_sync_10_counter >= 2: logging.critical("MODEM | stuck in sync #2") - self.c_lib.freedv_set_sync(freedv, 0) #FORCE UNSYNC - stuck_in_sync_counter = 0 + self.c_lib.freedv_set_sync(freedv, 0) # FORCE UNSYNC + stuck_in_sync_counter = 0 stuck_in_sync_10_counter = 0 - #----------------------------------- - + # ----------------------------------- + # forward data only if broadcast or we are the receiver if nbytes == bytes_per_frame and bytes(bytes_out[1:2]) == static.MYCALLSIGN_CRC8 or bytes(bytes_out[1:2]) == b'\x01': self.calculate_ber(freedv) @@ -384,120 +377,118 @@ class RF(): stuck_in_sync_counter = 0 stuck_in_sync_10_counter = 0 # - + # CHECK IF FRAMETYPE IS BETWEEN 10 and 50 ------------------------ frametype = int.from_bytes(bytes(bytes_out[:1]), "big") frame = frametype - 10 n_frames_per_burst = int.from_bytes(bytes(bytes_out[1:2]), "big") - + #self.c_lib.freedv_set_frames_per_burst(freedv_data, n_frames_per_burst); - - if 50 >= frametype >= 10: + + if 50 >= frametype >= 10: if frame != 3 or force == True: - data_handler.arq_data_received(bytes(bytes_out[:-2])) #send payload data to arq checker without CRC16 - + data_handler.arq_data_received(bytes(bytes_out[:-2])) # send payload data to arq checker without CRC16 + #print("static.ARQ_RX_BURST_BUFFER.count(None) " + str(static.ARQ_RX_BURST_BUFFER.count(None))) if static.ARQ_RX_BURST_BUFFER.count(None) <= 1: logging.debug("FULL BURST BUFFER ---> UNSYNC") self.c_lib.freedv_set_sync(freedv, 0) - + else: logging.critical("---------------------------SIMULATED MISSING FRAME") force = True # BURST ACK elif frametype == 60: - logging.debug("ACK RECEIVED....") - data_handler.burst_ack_received() - + logging.debug("ACK RECEIVED....") + data_handler.burst_ack_received() + # FRAME ACK elif frametype == 61: - logging.debug("FRAME ACK RECEIVED....") - data_handler.frame_ack_received() - + logging.debug("FRAME ACK RECEIVED....") + data_handler.frame_ack_received() + # FRAME RPT elif frametype == 62: - logging.debug("REPEAT REQUEST RECEIVED....") - data_handler.burst_rpt_received(bytes_out[:-2]) + logging.debug("REPEAT REQUEST RECEIVED....") + data_handler.burst_rpt_received(bytes_out[:-2]) # CQ FRAME elif frametype == 200: - logging.debug("CQ RECEIVED....") - data_handler.received_cq(bytes_out[:-2]) - + logging.debug("CQ RECEIVED....") + data_handler.received_cq(bytes_out[:-2]) + # PING FRAME elif frametype == 210: - logging.debug("PING RECEIVED....") - data_handler.received_ping(bytes_out[:-2]) + logging.debug("PING RECEIVED....") + data_handler.received_ping(bytes_out[:-2]) # PING ACK elif frametype == 211: - logging.debug("PING ACK RECEIVED....") - data_handler.received_ping_ack(bytes_out[:-2]) + logging.debug("PING ACK RECEIVED....") + data_handler.received_ping_ack(bytes_out[:-2]) # ARQ CONNECT elif frametype == 220: - logging.debug("ARQ CONNECT RECEIVED....") - data_handler.arq_received_connect(bytes_out[:-2]) + logging.debug("ARQ CONNECT RECEIVED....") + data_handler.arq_received_connect(bytes_out[:-2]) # ARQ CONNECT ACK / KEEP ALIVE elif frametype == 221: - logging.debug("ARQ CONNECT ACK RECEIVED / KEEP ALIVE....") - data_handler.arq_received_connect_keep_alive(bytes_out[:-2]) + logging.debug("ARQ CONNECT ACK RECEIVED / KEEP ALIVE....") + data_handler.arq_received_connect_keep_alive(bytes_out[:-2]) # ARQ CONNECT ACK / KEEP ALIVE elif frametype == 222: - logging.debug("ARQ DISCONNECT RECEIVED") - data_handler.arq_disconnect_received(bytes_out[:-2]) + logging.debug("ARQ DISCONNECT RECEIVED") + data_handler.arq_disconnect_received(bytes_out[:-2]) - # ARQ FILE TRANSFER RECEIVED! + # ARQ FILE TRANSFER RECEIVED! elif frametype == 225: - logging.debug("ARQ arq_received_data_channel_opener RECEIVED") - data_handler.arq_received_data_channel_opener(bytes_out[:-2]) - + logging.debug("ARQ arq_received_data_channel_opener RECEIVED") + 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 RECEIVED") - data_handler.arq_received_channel_is_open(bytes_out[:-2]) - + logging.debug("ARQ arq_received_channel_is_open RECEIVED") + data_handler.arq_received_channel_is_open(bytes_out[:-2]) + # ARQ CONNECT ACK / KEEP ALIVE elif frametype == 230: - logging.debug("BEACON RECEIVED") - + logging.debug("BEACON RECEIVED") + data_handler.received_beacon(bytes_out[:-2]) + else: logging.info("OTHER FRAME: " + str(bytes_out[:-2])) print(frametype) - + # DO UNSYNC AFTER LAST BURST by checking the frame nums agains the total frames per burst - if frame == n_frames_per_burst: + if frame == n_frames_per_burst: logging.debug("LAST FRAME ---> UNSYNC") - self.c_lib.freedv_set_sync(freedv, 0) #FORCE UNSYNC - - + self.c_lib.freedv_set_sync(freedv, 0) # FORCE UNSYNC + # clear bytes_out buffer to be ready for next frames after successfull decoding - + bytes_out = (ctypes.c_ubyte * bytes_per_frame) - bytes_out = bytes_out() #get pointer to bytes_out - + bytes_out = bytes_out() # get pointer to bytes_out + if mode == 14: self.c_lib.freedv_set_sync(freedv, 0) - for i in range(0,10): + for i in range(0, 10): dummy_mod = bytes(self.c_lib.freedv_nin(freedv)) self.c_lib.freedv_rawdatarx(freedv, bytes_out, dummy_mod) else: # for debugging purposes to receive all data pass - #print(bytes_out[:-2]) - - - def calculate_ber(self,freedv): + # print(bytes_out[:-2]) + + def calculate_ber(self, freedv): Tbits = self.c_lib.freedv_get_total_bits(freedv) Terrs = self.c_lib.freedv_get_total_bit_errors(freedv) if Tbits != 0: - ber = (Terrs/Tbits)*100 + ber = (Terrs / Tbits) * 100 static.BER = int(ber) - - self.c_lib.freedv_set_total_bit_errors(freedv,0) - self.c_lib.freedv_set_total_bits(freedv,0) - + + self.c_lib.freedv_set_total_bit_errors(freedv, 0) + self.c_lib.freedv_set_total_bits(freedv, 0) diff --git a/sock.py b/sock.py index 1a6ed436..5e5bf293 100644 --- a/sock.py +++ b/sock.py @@ -9,7 +9,6 @@ Created on Fri Dec 25 21:25:14 2020 import socketserver import threading import logging -import time import json import asyncio @@ -20,124 +19,113 @@ import helpers -import asyncbg - - - -class CMDTCPRequestHandler(socketserver.BaseRequestHandler): +class CMDTCPRequestHandler(socketserver.BaseRequestHandler): def handle(self): - - encoding = 'utf-8' + + encoding = 'utf-8' #data = str(self.request.recv(1024), 'utf-8') - + data = bytes() - while True: - chunk = self.request.recv(8192)#.strip() + while True: + chunk = self.request.recv(8192) # .strip() data += chunk if chunk.endswith(b'\n'): break - data = data[:-1] # remove b'\n' - data = str(data, 'utf-8') + data = data[:-1] # remove b'\n' + data = str(data, 'utf-8') # SOCKETTEST --------------------------------------------------- if data == 'SOCKETTEST': #cur_thread = threading.current_thread() response = bytes("WELL DONE! YOU ARE ABLE TO COMMUNICATE WITH THE TNC", encoding) self.request.sendall(response) - + # CQ CQ CQ ----------------------------------------------------- if data == 'CQCQCQ': asyncio.run(data_handler.transmit_cq()) - #asyncio.run(asyncbg.call(data_handler.transmit_cq)) + # asyncio.run(asyncbg.call(data_handler.transmit_cq)) #######self.request.sendall(b'CALLING CQ') - # PING ---------------------------------------------------------- if data.startswith('PING:'): - #send ping frame and wait for ACK + # send ping frame and wait for ACK pingcommand = data.split('PING:') dxcallsign = pingcommand[1] - #data_handler.transmit_ping(dxcallsign) + # data_handler.transmit_ping(dxcallsign) ##loop = asyncio.get_event_loop() - ##loop.create_task(data_handler.transmit_ping(dxcallsign)) - ##loop.run() - - #asyncio.new_event_loop() - #asyncio.ensure_future(data_handler.transmit_ping(dxcallsign)) - + # loop.create_task(data_handler.transmit_ping(dxcallsign)) + # loop.run() + + # asyncio.new_event_loop() + # asyncio.ensure_future(data_handler.transmit_ping(dxcallsign)) + asyncio.run(data_handler.transmit_ping(dxcallsign)) - - #asyncio.create_task(data_handler.transmit_ping(dxcallsign)) - #asyncio.run(data_handler.transmit_ping(dxcallsign)) - + + # asyncio.create_task(data_handler.transmit_ping(dxcallsign)) + # asyncio.run(data_handler.transmit_ping(dxcallsign)) + # ARQ CONNECT TO CALLSIGN ---------------------------------------- if data.startswith('ARQ:CONNECT:'): arqconnectcommand = data.split('ARQ:CONNECT:') dxcallsign = arqconnectcommand[1] static.DXCALLSIGN = bytes(dxcallsign, 'utf-8') static.DXCALLSIGN_CRC8 = helpers.get_crc_8(static.DXCALLSIGN) - + if static.ARQ_STATE == 'CONNECTED': # here we could disconnect pass - + if static.TNC_STATE == 'IDLE': # here we send an "CONNECT FRAME - + #ARQ_CONNECT_THREAD = threading.Thread(target=data_handler.arq_connect, name="ARQ_CONNECT") - #ARQ_CONNECT_THREAD.start() + # ARQ_CONNECT_THREAD.start() asyncio.run(data_handler.arq_connect()) ########self.request.sendall(bytes("CONNECTING", encoding)) - #data_handler.arq_connect() + # data_handler.arq_connect() # ARQ DISCONNECT FROM CALLSIGN ---------------------------------------- if data == 'ARQ:DISCONNECT': #ARQ_DISCONNECT_THREAD = threading.Thread(target=data_handler.arq_disconnect, name="ARQ_DISCONNECT") - #ARQ_DISCONNECT_THREAD.start() + # ARQ_DISCONNECT_THREAD.start() asyncio.run(data_handler.arq_disconnect()) - + ########self.request.sendall(bytes("DISCONNECTING", encoding)) - #data_handler.arq_disconnect() - - - - - - + # data_handler.arq_disconnect() + if data.startswith('ARQ:OPEN_DATA_CHANNEL') and static.ARQ_STATE == 'CONNECTED': static.ARQ_READY_FOR_DATA = False static.TNC_STATE = 'BUSY' asyncio.run(data_handler.arq_open_data_channel()) - - if data.startswith('ARQ:DATA:') and static.ARQ_STATE == 'CONNECTED' and static.ARQ_READY_FOR_DATA == True: + + if data.startswith('ARQ:DATA:') and static.ARQ_STATE == 'CONNECTED' and static.ARQ_READY_FOR_DATA == True: static.TNC_STATE = 'BUSY' arqdata = data.split('ARQ:') data_out = bytes(arqdata[1], 'utf-8') - + ARQ_DATA_THREAD = threading.Thread(target=data_handler.arq_transmit, args=[data_out], name="ARQ_DATA") - ARQ_DATA_THREAD.start() - #asyncio.run(data_handler.arq_transmit(data_out)) - - # SETTINGS AND STATUS --------------------------------------------- + ARQ_DATA_THREAD.start() + # asyncio.run(data_handler.arq_transmit(data_out)) + + # SETTINGS AND STATUS --------------------------------------------- if data.startswith('SET:MYCALLSIGN:'): callsign = data.split('SET:MYCALLSIGN:') if bytes(callsign[1], encoding) == b'': self.request.sendall(b'INVALID CALLSIGN') - else: + else: static.MYCALLSIGN = bytes(callsign[1], encoding) static.MYCALLSIGN_CRC8 = helpers.get_crc_8(static.MYCALLSIGN) - ########self.request.sendall(static.MYCALLSIGN) + # self.request.sendall(static.MYCALLSIGN) logging.info("CMD | MYCALLSIGN: " + str(static.MYCALLSIGN)) - + if data == 'GET:MYCALLSIGN': self.request.sendall(bytes(static.MYCALLSIGN, encoding)) - - + if data == 'GET:DXCALLSIGN': - self.request.sendall(bytes(static.DXCALLSIGN, encoding)) - + self.request.sendall(bytes(static.DXCALLSIGN, encoding)) + if data == 'GET:TNC_STATE': output = { "PTT_STATE": str(static.PTT_STATE), @@ -149,7 +137,7 @@ class CMDTCPRequestHandler(socketserver.BaseRequestHandler): } jsondata = json.dumps(output) self.request.sendall(bytes(jsondata, encoding)) - + if data == 'GET:DATA_STATE': output = { "RX_BUFFER_LENGTH": str(len(static.RX_BUFFER)), @@ -159,51 +147,43 @@ class CMDTCPRequestHandler(socketserver.BaseRequestHandler): "ARQ_TX_N_CURRENT_ARQ_FRAME": str(int.from_bytes(bytes(static.ARQ_TX_N_CURRENT_ARQ_FRAME), "big")), "ARQ_TX_N_TOTAL_ARQ_FRAMES": str(int.from_bytes(bytes(static.ARQ_TX_N_TOTAL_ARQ_FRAMES), "big")), "ARQ_RX_FRAME_N_BURSTS": str(static.ARQ_RX_FRAME_N_BURSTS), - "ARQ_RX_N_CURRENT_ARQ_FRAME": str(static.ARQ_RX_N_CURRENT_ARQ_FRAME), - "ARQ_N_ARQ_FRAMES_PER_DATA_FRAME": str(static.ARQ_N_ARQ_FRAMES_PER_DATA_FRAME ) + "ARQ_RX_N_CURRENT_ARQ_FRAME": str(static.ARQ_RX_N_CURRENT_ARQ_FRAME), + "ARQ_N_ARQ_FRAMES_PER_DATA_FRAME": str(static.ARQ_N_ARQ_FRAMES_PER_DATA_FRAME) } jsondata = json.dumps(output) - self.request.sendall(bytes(jsondata, encoding)) + self.request.sendall(bytes(jsondata, encoding)) if data == 'GET:HEARD_STATIONS': output = [] - for i in range(0,len(static.HEARD_STATIONS)): - output.append({"CALLSIGN" : str(static.HEARD_STATIONS[i][0], 'utf-8'), "TIMESTAMP" : static.HEARD_STATIONS[i][1]}) - + for i in range(0, len(static.HEARD_STATIONS)): + output.append({"CALLSIGN": str(static.HEARD_STATIONS[i][0], 'utf-8'), "TIMESTAMP": static.HEARD_STATIONS[i][1]}) + jsondata = json.dumps(output) self.request.sendall(bytes(jsondata, encoding)) - - - - - if data.startswith('GET:RX_BUFFER:'): data = data.split('GET:RX_BUFFER:') - bufferposition = int(data[1])-1 + bufferposition = int(data[1]) - 1 if bufferposition == -1: if len(static.RX_BUFFER) > 0: self.request.sendall(static.RX_BUFFER[-1]) - + if bufferposition <= len(static.RX_BUFFER) > 0: - self.request.sendall(bytes(static.RX_BUFFER[bufferposition])) - + self.request.sendall(bytes(static.RX_BUFFER[bufferposition])) if data == 'DEL:RX_BUFFER': static.RX_BUFFER = [] - #self.request.close() - - + # self.request.close() def start_cmd_socket(): try: logging.info("SRV | STARTING TCP/IP SOCKET FOR CMD ON PORT: " + str(static.PORT)) - socketserver.TCPServer.allow_reuse_address = True #https://stackoverflow.com/a/16641793 + socketserver.TCPServer.allow_reuse_address = True # https://stackoverflow.com/a/16641793 cmdserver = socketserver.TCPServer((static.HOST, static.PORT), CMDTCPRequestHandler) cmdserver.serve_forever() - + finally: cmdserver.server_close() diff --git a/static.py b/static.py index e4feea7b..7356ce47 100644 --- a/static.py +++ b/static.py @@ -15,50 +15,41 @@ DXCALLSIGN_CRC8 = b'A' MYGRID = b'' - - - - - -#--------------------------------- +# --------------------------------- # Server Defaults HOST = "localhost" PORT = 3000 -#--------------------------------- +# --------------------------------- # HAMLIB DEFAULTS -#RIG_PTT_NONE -#No PTT available +# RIG_PTT_NONE +# No PTT available -#RIG_PTT_RIG -#Legacy PTT +# RIG_PTT_RIG +# Legacy PTT -#RIG_PTT_SERIAL_DTR -#PTT control through serial DTR signal +# RIG_PTT_SERIAL_DTR +# PTT control through serial DTR signal -#RIG_PTT_SERIAL_RTS -#PTT control through serial RTS signal +# RIG_PTT_SERIAL_RTS +# PTT control through serial RTS signal -#RIG_PTT_PARALLEL -#PTT control through parallel port +# RIG_PTT_PARALLEL +# PTT control through parallel port -#RIG_PTT_RIG_MICDATA -#Legacy PTT, supports RIG_PTT_ON_MIC/RIG_PTT_ON_DATA +# RIG_PTT_RIG_MICDATA +# Legacy PTT, supports RIG_PTT_ON_MIC/RIG_PTT_ON_DATA -#RIG_PTT_CM108 -#PTT control through CM108 GPIO pin +# RIG_PTT_CM108 +# PTT control through CM108 GPIO pin HAMLIB_PTT_TYPE = 'RIG_PTT_NONE' PTT_STATE = False - - - - -#------------------------- +# ------------------------- # FreeDV Defaults FREEDV_RECEIVE = True @@ -70,9 +61,9 @@ FREEDV_SIGNALLING_BYTES_PER_FRAME = 0 FREEDV_SIGNALLING_PAYLOAD_PER_FRAME = 0 BER = 0 -#--------------------------------- +# --------------------------------- -#Audio Defaults +# Audio Defaults AUDIO_INPUT_DEVICE = 1 AUDIO_OUTPUT_DEVICE = 1 #TX_SAMPLE_STATE = None @@ -80,13 +71,13 @@ AUDIO_OUTPUT_DEVICE = 1 #AUDIO_SAMPLE_RATE_RX = 44100 #AUDIO_SAMPLE_RATE_TX = 44100 -MODEM_SAMPLE_RATE = 8000 #8000 +MODEM_SAMPLE_RATE = 8000 # 8000 AUDIO_FRAMES_PER_BUFFER = 2048 AUDIO_CHANNELS = 1 AUDIO_RMS = 0 -#--------------------------------- +# --------------------------------- -#ARQ DEFAULTS +# ARQ DEFAULTS TX_N_MAX_RETRIES = 5 TX_N_RETRIES = 0 @@ -99,41 +90,41 @@ ARQ_RX_BURST_BUFFER = [] ARQ_RX_FRAME_BUFFER = [] ARQ_RX_FRAME_N_BURSTS = 0 -## TX +# TX ARQ_TX_N_CURRENT_ARQ_FRAME = 0 ARQ_TX_N_TOTAL_ARQ_FRAMES = 0 ## -## RX -ARQ_N_ARQ_FRAMES_PER_DATA_FRAME = 0 #total number of arq frames per data frame +# RX +ARQ_N_ARQ_FRAMES_PER_DATA_FRAME = 0 # total number of arq frames per data frame ARQ_RX_N_CURRENT_ARQ_FRAME = 0 ## -ARQ_N_RX_ARQ_FRAMES = 0 # total number of received frames -ARQ_N_RX_FRAMES_PER_BURSTS = 0 # NUMBER OF FRAMES WE ARE WAITING FOR --> GOT DATA FROM RECEIVED FRAME -ARQ_ACK_PAYLOAD_PER_FRAME = 0 # PAYLOAD per ACK frame +ARQ_N_RX_ARQ_FRAMES = 0 # total number of received frames +ARQ_N_RX_FRAMES_PER_BURSTS = 0 # NUMBER OF FRAMES WE ARE WAITING FOR --> GOT DATA FROM RECEIVED FRAME +ARQ_ACK_PAYLOAD_PER_FRAME = 0 # PAYLOAD per ACK frame -ARQ_ACK_RECEIVED = False # set to 1 if ACK received -ARQ_RX_ACK_TIMEOUT = False # set to 1 if timeut reached -ARQ_RX_ACK_TIMEOUT_SECONDS = 10.0 #timeout for waiting for ACK frames +ARQ_ACK_RECEIVED = False # set to 1 if ACK received +ARQ_RX_ACK_TIMEOUT = False # set to 1 if timeut reached +ARQ_RX_ACK_TIMEOUT_SECONDS = 10.0 # timeout for waiting for ACK frames -ARQ_FRAME_ACK_RECEIVED = False # set to 1 if FRAME ACK received +ARQ_FRAME_ACK_RECEIVED = False # set to 1 if FRAME ACK received ARQ_RX_FRAME_TIMEOUT = False ARQ_RX_FRAME_TIMEOUT_SECONDS = 10.0 ARQ_RX_RPT_TIMEOUT = False ARQ_RX_RPT_TIMEOUT_SECONDS = 10.0 -ARQ_RPT_RECEIVED = False #indicate if RPT frame has been received -ARQ_RPT_FRAMES = [] #buffer for frames which are requested to repeat +ARQ_RPT_RECEIVED = False # indicate if RPT frame has been received +ARQ_RPT_FRAMES = [] # buffer for frames which are requested to repeat FRAME_CRC = b'' -FRAME_BOF = b'\xAA\xAA' #here we define 2 bytes for the BOF -FRAME_EOF = b'\xFF\xFF' #here we define 2 bytes for the EOF -ARQ_FRAME_BOF_RECEIVED = False # status, if we received a BOF of a data frame -ARQ_FRAME_EOF_RECEIVED = False # status, if we received a EOF of a data frame +FRAME_BOF = b'\xAA\xAA' # here we define 2 bytes for the BOF +FRAME_EOF = b'\xFF\xFF' # here we define 2 bytes for the EOF +ARQ_FRAME_BOF_RECEIVED = False # status, if we received a BOF of a data frame +ARQ_FRAME_EOF_RECEIVED = False # status, if we received a EOF of a data frame -ARQ_N_SENT_FRAMES = 0 #counter for already sent frames +ARQ_N_SENT_FRAMES = 0 # counter for already sent frames # ARQ STATES: @@ -177,4 +168,3 @@ RX_BUFFER_SIZE = 0 # ------- HEARD STATIOS BUFFER HEARD_STATIONS = [] -