mirror of
https://github.com/DJ2LS/FreeDATA
synced 2024-05-14 08:04:33 +00:00
commit
53b7188187
14 changed files with 775 additions and 773 deletions
|
@ -2,6 +2,7 @@
|
||||||
## FreeDV- Just Another TNC Experiment
|
## FreeDV- Just Another TNC Experiment
|
||||||
My first attempt to learn more about FreeDV and how to create a TNC which gets data from a TCP/IP socket
|
My first attempt to learn more about FreeDV and how to create a TNC which gets data from a TCP/IP socket
|
||||||
|
|
||||||
|
|
||||||
## Credits
|
## Credits
|
||||||
|
|
||||||
David Rowe and the FreeDV team for developing the modem and libraries
|
David Rowe and the FreeDV team for developing the modem and libraries
|
||||||
|
|
497
arq.py
497
arq.py
|
@ -5,309 +5,356 @@ Created on Sun Dec 27 20:43:40 2020
|
||||||
|
|
||||||
@author: DJ2LS
|
@author: DJ2LS
|
||||||
"""
|
"""
|
||||||
# CRC aller payloads via XOR scrambeln und dann eine CRC8 mitsenden
|
|
||||||
|
|
||||||
|
|
||||||
import logging
|
import logging
|
||||||
import crcengine
|
|
||||||
import threading
|
import threading
|
||||||
import time
|
import time
|
||||||
|
from random import randrange
|
||||||
|
|
||||||
import static
|
import static
|
||||||
import modem
|
import modem
|
||||||
import other
|
import helpers
|
||||||
|
import main
|
||||||
|
|
||||||
modem = modem.RF()
|
modem = modem.RF()
|
||||||
|
|
||||||
crc_algorithm = crcengine.new('crc16-ccitt-false') #load crc16 library
|
static.ARQ_PAYLOAD_PER_FRAME = static.FREEDV_DATA_PAYLOAD_PER_FRAME - 3 #6?!
|
||||||
|
static.ARQ_ACK_PAYLOAD_PER_FRAME = 14 - 2#
|
||||||
static.ARQ_PAYLOAD_PER_FRAME = static.FREEDV_PAYLOAD_PER_FRAME - 6
|
|
||||||
|
|
||||||
|
|
||||||
|
def arq_ack_timeout():
|
||||||
|
static.ARQ_ACK_TIMEOUT = 1
|
||||||
|
|
||||||
|
|
||||||
def data_received(data_in):
|
def data_received(data_in):
|
||||||
|
|
||||||
ARQ_N_RX_BURSTS = int.from_bytes(bytes(data_in[:1]), "big") - 10
|
|
||||||
static.ARQ_RX_BURST_BUFFER.append(data_in) #append data to RX BUFFER
|
|
||||||
|
|
||||||
print(ARQ_N_RX_BURSTS)
|
# arqframe = frame_type + \ # 1 [:1] # frame type and current number of arq frame of (current) burst
|
||||||
|
# bytes([static.ARQ_TX_N_FRAMES_PER_BURST]) + \ # 1 [1:2] # total number of arq frames per (current) burst
|
||||||
|
# static.ARQ_N_CURRENT_ARQ_FRAME + \ # 2 [2:4] # current arq frame number
|
||||||
|
# static.ARQ_N_TOTAL_ARQ_FRAMES + \ # 2 [4:6] # total number arq frames
|
||||||
|
# static.ARQ_BURST_PAYLOAD_CRC + \ # 2 [6:8] # arq crc
|
||||||
|
# payload_data # N [8:N] # payload data
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
#while static.ACK_RX_TIMEOUT == 0: #define timeout where data has to be received untl error occurs
|
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
|
||||||
|
static.ARQ_BURST_PAYLOAD_CRC = data_in[6:8]
|
||||||
|
|
||||||
if len(static.ARQ_RX_BURST_BUFFER) == ARQ_N_RX_BURSTS: #if received bursts are equal to burst number in frame
|
|
||||||
|
|
||||||
|
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_BURST_PAYLOAD_CRC: " + str(static.ARQ_BURST_PAYLOAD_CRC))
|
||||||
|
logging.debug("----------------------------------------------------------------")
|
||||||
|
|
||||||
|
|
||||||
|
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.info("ARQ | RX | ARQ FRAME [" + str(static.ARQ_N_FRAME) + "/" + str(static.ARQ_N_RX_FRAMES_PER_BURSTS) + "] [" + str(arq_percent_burst).zfill(3) + "%] --- TOTAL [" + str(static.ARQ_RX_N_CURRENT_ARQ_FRAME) + "/" + str(static.ARQ_N_ARQ_FRAMES_PER_DATA_FRAME) + "] [" + str(arq_percent_frame).zfill(3) + "%]" )
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
#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
|
||||||
|
if static.ARQ_N_ARQ_FRAMES_PER_DATA_FRAME != len(static.ARQ_RX_FRAME_BUFFER) and static.ARQ_RX_N_CURRENT_ARQ_FRAME == 1:
|
||||||
|
for i in range(0,static.ARQ_N_ARQ_FRAMES_PER_DATA_FRAME+1):
|
||||||
|
static.ARQ_RX_FRAME_BUFFER.insert(i,None)
|
||||||
|
|
||||||
|
|
||||||
|
#allocate ARQ_RX_BURST_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 burst to N list position so we can explicit search for it
|
||||||
|
if static.ARQ_N_RX_FRAMES_PER_BURSTS != len(static.ARQ_RX_BURST_BUFFER) and static.ARQ_N_FRAME == 1:
|
||||||
|
for i in range(0,static.ARQ_N_RX_FRAMES_PER_BURSTS+1):
|
||||||
|
static.ARQ_RX_BURST_BUFFER.insert(i,None)
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
# now we add the incoming data to the specified position in our lists
|
||||||
|
static.ARQ_RX_BURST_BUFFER[static.ARQ_N_FRAME] = bytes(data_in)
|
||||||
|
static.ARQ_RX_FRAME_BUFFER[static.ARQ_RX_N_CURRENT_ARQ_FRAME] = bytes(data_in)
|
||||||
|
|
||||||
|
|
||||||
|
# -------------------------- ARQ BURST CHECKER
|
||||||
|
|
||||||
|
# run only if we recieved all ARQ FRAMES per ARQ BURST
|
||||||
burst_total_payload = bytearray()
|
burst_total_payload = bytearray()
|
||||||
for n_raw_frame in range(0,len(static.ARQ_RX_BURST_BUFFER)):
|
if static.ARQ_N_FRAME == static.ARQ_N_RX_FRAMES_PER_BURSTS: #if received bursts are equal to burst number in frame
|
||||||
|
|
||||||
|
#here we get the total payload for the frame to calculate the crc
|
||||||
|
for n_raw_frame in range(1,len(static.ARQ_RX_BURST_BUFFER)):
|
||||||
|
# we need to check if we have a None or received data in list
|
||||||
|
if static.ARQ_RX_BURST_BUFFER[n_raw_frame] != None:
|
||||||
burst_frame = static.ARQ_RX_BURST_BUFFER[n_raw_frame] #get burst frame
|
burst_frame = static.ARQ_RX_BURST_BUFFER[n_raw_frame] #get burst frame
|
||||||
burst_payload = burst_frame[3:] #remove frame type and burst CRC
|
burst_payload = burst_frame[8:] #remove frame type and burst CRC #4
|
||||||
burst_total_payload = burst_total_payload + burst_payload #stick bursts together
|
burst_total_payload = burst_total_payload + burst_payload #stick bursts together
|
||||||
|
|
||||||
print(burst_total_payload)
|
# ------------------ calculate CRC of BURST
|
||||||
burst_payload_crc = crc_algorithm(burst_total_payload)
|
burst_payload_crc = helpers.get_crc_16(burst_total_payload)
|
||||||
burst_payload_crc = burst_payload_crc.to_bytes(2, byteorder='big')
|
# IF BURST CRC IS CORRECT, APPEND BURST TO BUFFER AND SEND ACK FRAME
|
||||||
print(burst_payload_crc)
|
if burst_payload_crc == data_in[6:8]:
|
||||||
|
|
||||||
|
#BUILDING ACK FRAME FOR BURST -----------------------------------------------
|
||||||
if burst_payload_crc == data_in[1:3]: #IF burst payload crc and input crc are equal
|
#ack_payload = bytes(burst_payload_crc)
|
||||||
|
ack_frame = b'<'+ bytes(burst_payload_crc) # < = 60
|
||||||
print(data_in[1:3])
|
ack_buffer = bytearray(static.ARQ_ACK_PAYLOAD_PER_FRAME)
|
||||||
print("CRC EQUAL")
|
|
||||||
logging.info("TX | SENDING ACK [" + str(data_in[1:3]) +"]")
|
|
||||||
static.ARQ_RX_FRAME_BUFFER.append(burst_total_payload) # IF CRC TRUE APPEND burst_total_payload TO ARQ_RX_FRAME_BUFFER
|
|
||||||
print(data_in[7:9])
|
|
||||||
|
|
||||||
|
|
||||||
# -------- DETECT IF WE HAVE A FRAME HEADER
|
|
||||||
|
|
||||||
if data_in[7:9].startswith(b'\xAA\xAA'):
|
|
||||||
print("DAS IST DER ERSTE BURST MIT BOF!!!")
|
|
||||||
print("FRAME CRC = " + str(data_in[5:7]))
|
|
||||||
print("FRAME BURSTS = " + str(data_in[3:5]))
|
|
||||||
static.FRAME_CRC = data_in[5:7]
|
|
||||||
|
|
||||||
|
|
||||||
if data_in.rstrip(b'\x00').endswith(b'\xFF\xFF'):
|
|
||||||
print("DAS IST DER LETZTE BURST MIT EOF!!!")
|
|
||||||
|
|
||||||
# WENN DAS HIER ERFÜLLT IST, DANN KÖNNEN WIR MAL SCHAUEN WAS WIR AUSGEBEN KÖNNEN
|
|
||||||
print(len(static.ARQ_RX_FRAME_BUFFER))
|
|
||||||
|
|
||||||
total_frame = bytearray()
|
|
||||||
for b in range(len(static.ARQ_RX_FRAME_BUFFER)):
|
|
||||||
|
|
||||||
total_frame = total_frame + static.ARQ_RX_FRAME_BUFFER[b]
|
|
||||||
#print(total_frame)
|
|
||||||
|
|
||||||
payload = total_frame.split(b'\xAA\xAA')
|
|
||||||
payload = payload[1]
|
|
||||||
payload = payload.split(b'\xFF\xFF')
|
|
||||||
payload = payload[0]
|
|
||||||
|
|
||||||
frame_payload_crc = crc_algorithm(payload)
|
|
||||||
frame_payload_crc = frame_payload_crc.to_bytes(2, byteorder='big')
|
|
||||||
|
|
||||||
|
|
||||||
if static.FRAME_CRC == frame_payload_crc:
|
|
||||||
print("FRAME CRC PASST")
|
|
||||||
print(payload)
|
|
||||||
else:
|
|
||||||
print("FRAME CRC PASST NICHT")
|
|
||||||
print(static.FRAME_CRC)
|
|
||||||
print(frame_payload_crc)
|
|
||||||
print(payload)
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
#BUILDING ACK FRAME -----------------------------------------------
|
|
||||||
|
|
||||||
ack_frame = b'\7' + bytes(burst_payload_crc)
|
|
||||||
ack_buffer = bytearray(static.ARQ_PAYLOAD_PER_FRAME)
|
|
||||||
ack_buffer[:len(ack_frame)] = ack_frame # set buffersize to length of data which will be send
|
ack_buffer[:len(ack_frame)] = ack_frame # set buffersize to length of data which will be send
|
||||||
|
|
||||||
#TRANSMIT ACK FRAME -----------------------------------------------
|
#TRANSMIT ACK FRAME FOR BURST-----------------------------------------------
|
||||||
time.sleep(2)
|
logging.info("ARQ | TX | ARQ BURST ACK [" + str(data_in[6:8].hex()) +"]")
|
||||||
modem.Transmit(ack_buffer)
|
modem.transmit_arq_ack(ack_buffer)
|
||||||
static.ARQ_RX_BURST_BUFFER = []
|
|
||||||
|
|
||||||
|
# ----------------------------------------------------------------
|
||||||
|
static.ARQ_RX_BURST_BUFFER = [] # CLEAR RX BURST BUFFER AFTER SENDING DATA
|
||||||
|
|
||||||
else: #IF burst payload crc and input crc are NOT equal
|
else: #IF burst payload crc and input crc are NOT equal
|
||||||
print("CRC NOT EQUAL!!!!!")
|
logging.info("ARQ BURST CRC NOT EQUAL! [" + str(data_in[6:8]) + "]")
|
||||||
print(data_in[1:3])
|
static.ARQ_RX_BURST_BUFFER = [] #erase ARQ RX Burst buffer
|
||||||
|
|
||||||
|
#if nframes are unequal to expected frames per burst
|
||||||
|
else:
|
||||||
|
#just a placeholder at this time
|
||||||
|
pass
|
||||||
|
|
||||||
|
# ---------------------------- FRAME MACHINE
|
||||||
|
|
||||||
|
# --------------- CHECK IF WE ARE MISSING FRAMES -------------------------------------------
|
||||||
|
#for frame in range(1,len(static.ARQ_RX_FRAME_BUFFER)):
|
||||||
|
# if static.ARQ_RX_FRAME_BUFFER[frame] == None:
|
||||||
|
# print("Missing frames:" + str(frame))
|
||||||
|
|
||||||
|
# --------------- IF LIST NOT CONTAINS "None" stick everything together
|
||||||
|
complete_data_frame = bytearray()
|
||||||
|
if static.ARQ_RX_FRAME_BUFFER.count(None) == 1: ## 1 because position 0 of list will alaways be None in our case
|
||||||
|
|
||||||
|
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]
|
||||||
|
|
||||||
|
# -------- DETECT IF WE RECEIVED A FRAME FOOTER THEN SAVE DATA TO GLOBALS
|
||||||
|
if arq_frame_payload.rstrip(b'\x00').endswith(static.FRAME_EOF):
|
||||||
|
static.ARQ_FRAME_EOF_RECEIVED = True
|
||||||
|
|
||||||
|
arq_frame_payload = arq_frame_payload.split(static.FRAME_EOF)
|
||||||
|
arq_frame_payload = arq_frame_payload[0]
|
||||||
|
|
||||||
|
|
||||||
|
# --------- AFTER WE SEPARATED BOF AND EOF, STICK EVERYTHING TOGETHER
|
||||||
|
|
||||||
|
complete_data_frame = complete_data_frame + arq_frame_payload
|
||||||
|
|
||||||
|
|
||||||
|
#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.info("ARQ | RX | DATA FRAME SUCESSFULLY RECEIVED! - TIME TO PARTY")
|
||||||
|
|
||||||
|
static.RX_BUFFER.append(complete_data_frame)
|
||||||
|
|
||||||
|
|
||||||
|
#BUILDING ACK FRAME FOR DATA FRAME -----------------------------------------------
|
||||||
|
|
||||||
|
ack_frame = b'='+ bytes(static.FRAME_CRC) # < = 61
|
||||||
|
ack_buffer = bytearray(static.ARQ_ACK_PAYLOAD_PER_FRAME)
|
||||||
|
ack_buffer[:len(ack_frame)] = ack_frame # set buffersize to length of data which will be send
|
||||||
|
|
||||||
|
#TRANSMIT ACK FRAME FOR BURST-----------------------------------------------
|
||||||
|
logging.info("ARQ | TX | ARQ DATA FRAME ACK [" + str(static.FRAME_CRC.hex()) +"]")
|
||||||
|
modem.transmit_arq_ack(ack_buffer)
|
||||||
|
|
||||||
|
# clearing buffers and resetting counters
|
||||||
static.ARQ_RX_BURST_BUFFER = []
|
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
|
||||||
|
|
||||||
|
#print("----------------------------------------------------------------")
|
||||||
|
#print(static.RX_BUFFER[-1])
|
||||||
|
#print("----------------------------------------------------------------")
|
||||||
|
|
||||||
|
else:
|
||||||
|
logging.info("ARQ | RX | DATA FRAME NOT SUCESSFULLY RECEIVED!")
|
||||||
|
|
||||||
|
|
||||||
|
def burst_ack_received():
|
||||||
|
|
||||||
|
logging.debug("ARQ | RX | BURST ACK RCVD!")
|
||||||
|
static.ARQ_ACK_TIMEOUT = 1 #Force timer to stop waiting
|
||||||
|
static.ARQ_ACK_RECEIVED = 1 #Force data loops of TNC to stop and continue with next frame
|
||||||
|
|
||||||
|
def frame_ack_received():
|
||||||
|
|
||||||
|
logging.debug("ARQ | RX | FRAME ACK RCVD!")
|
||||||
|
static.ARQ_ACK_TIMEOUT = 1 #Force timer to stop waiting
|
||||||
|
static.ARQ_FRAME_ACK_RECEIVED = 1 #Force data loops of TNC to stop and continue with next frame
|
||||||
def ack_received():
|
|
||||||
|
|
||||||
logging.info("RX | ACK RCVD!")
|
|
||||||
static.ACK_TIMEOUT = 1 #Force timer to stop waiting
|
|
||||||
static.ACK_RECEIVED = 1 #Force data loops of TNC to stop and continue with next frame
|
|
||||||
# static.ARQ_ACK_WAITING_FOR_ID
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
def transmit(data_out):
|
def transmit(data_out):
|
||||||
|
|
||||||
static.ARQ_PAYLOAD_PER_FRAME = static.FREEDV_PAYLOAD_PER_FRAME - 3
|
static.ARQ_PAYLOAD_PER_FRAME = static.FREEDV_DATA_PAYLOAD_PER_FRAME - 8 #3 ohne ARQ_TX_N_FRAMES_PER_BURST
|
||||||
|
frame_header_length = 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) # aufrunden 3.2 = 4
|
||||||
|
|
||||||
|
#print(static.FREEDV_DATA_PAYLOAD_PER_FRAME)
|
||||||
|
#print(static.ARQ_PAYLOAD_PER_FRAME)
|
||||||
|
#print(n_bursts_prediction)
|
||||||
|
####static.ARQ_N_ARQ_FRAMES_PER_DATA_FRAME = n_arq_frames_per_data_frame.to_bytes(2, byteorder='big') #65535
|
||||||
|
|
||||||
|
frame_payload_crc = helpers.get_crc_16(data_out)
|
||||||
|
#print(frame_payload_crc)
|
||||||
|
|
||||||
|
# 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
|
||||||
#----------------------- BUILD A FRAME WITH CRC AND N BURSTS
|
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)]
|
||||||
|
|
||||||
frame_BOF = b'\xAA\xAA'
|
|
||||||
frame_EOF = b'\xFF\xFF'
|
|
||||||
|
|
||||||
|
|
||||||
frame_header_length = 8
|
|
||||||
|
|
||||||
n_bursts_prediction = (len(data_out)+frame_header_length) // static.ARQ_PAYLOAD_PER_FRAME + ((len(data_out)+frame_header_length) % static.ARQ_PAYLOAD_PER_FRAME > 0) # aufrunden 3.2 = 4
|
|
||||||
n_bursts_prediction = n_bursts_prediction.to_bytes(2, byteorder='big') #65535
|
|
||||||
|
|
||||||
frame_payload_crc = crc_algorithm(data_out)
|
|
||||||
frame_payload_crc = frame_payload_crc.to_bytes(2, byteorder='big')
|
|
||||||
|
|
||||||
data_out = n_bursts_prediction + frame_payload_crc + frame_BOF + data_out + frame_EOF
|
|
||||||
# 2 2 2 N 2
|
|
||||||
print(data_out)
|
|
||||||
# --------------------------------------------- START OF MAIN DATA LOOP
|
|
||||||
|
|
||||||
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)] # split incomming bytes to size of 30bytes - arq payload
|
|
||||||
static.TX_BUFFER_SIZE = len(static.TX_BUFFER)
|
static.TX_BUFFER_SIZE = len(static.TX_BUFFER)
|
||||||
|
#print(static.TX_BUFFER)
|
||||||
|
|
||||||
static.ARQ_TX_N_FRAMES = n_frames_per_burst(len(data_out)) # DEFINE NUMBER OF FRAMES PER BURSTS
|
logging.info("ARQ | TX | DATA FRAME --- BYTES: " + str(len(data_out)) + " ARQ FRAMES: " + str(static.TX_BUFFER_SIZE))
|
||||||
|
|
||||||
logging.info("TX | TOTAL PAYLOAD BYTES/FRAMES TO SEND: " + str(len(data_out)) + " / " + str(static.TX_BUFFER_SIZE))
|
# --------------------------------------------- THIS IS THE MAIN LOOP-----------------------------------------------------------------
|
||||||
|
|
||||||
#print(static.TX_BUFFER[2])
|
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:
|
||||||
|
|
||||||
for n_raw_frame in range(0, static.TX_BUFFER_SIZE, static.ARQ_TX_N_FRAMES): # LOOP THROUGH DATA LIST with steps = ARQ_TX_N_FRAMES
|
#print("static.ARQ_N_SENT_FRAMES: " + str(static.ARQ_N_SENT_FRAMES))
|
||||||
|
static.ARQ_TX_N_FRAMES_PER_BURST = get_n_frames_per_burst()
|
||||||
|
|
||||||
# ----------- GENERATE PAYLOAD CRC FOR ARQ_TX_N_FRAMES
|
# ----------- CREATE FRAME TOTAL PAYLOAD TO BE ABLE TO CREATE CRC FOR IT
|
||||||
burst_total_payload = bytearray()
|
burst_total_payload = bytearray()
|
||||||
|
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
|
||||||
|
|
||||||
#----------------------------------------------------------------------------------------------------------
|
# make sure we have always a filled buffer with the length of payload per frame
|
||||||
try: # DETECT IF LAST BURST
|
burst_raw_payload = static.TX_BUFFER[static.ARQ_N_SENT_FRAMES + i]
|
||||||
for i in range(static.ARQ_TX_N_FRAMES): #bytearray(b'111111111111111111111111222222222222222222222222')
|
|
||||||
|
|
||||||
# we need to make sure, payload data is always as long as static.ARQ_PAYLOAD_PER_FRAME beacuse of CRC!
|
|
||||||
|
|
||||||
burst_raw_payload = static.TX_BUFFER[n_raw_frame + i]
|
|
||||||
burst_payload = bytearray(static.ARQ_PAYLOAD_PER_FRAME)
|
burst_payload = bytearray(static.ARQ_PAYLOAD_PER_FRAME)
|
||||||
burst_payload[:len(burst_raw_payload)] = burst_raw_payload # set buffersize to length of data which will be send
|
burst_payload[:len(burst_raw_payload)] = burst_raw_payload # get frame from TX_BUFFER
|
||||||
burst_total_payload = burst_total_payload + burst_payload
|
burst_total_payload = burst_total_payload + burst_payload # append single frame to total payload buffer
|
||||||
|
|
||||||
|
except IndexError: # IF LAST BURST DETECTED BUILD CRC WITH LESS FRAMES AND SET static.ARQ_TX_N_FRAMES_PER_BURST TO VALUE OF REST!
|
||||||
|
|
||||||
except IndexError: # IF LAST BURST DETECTED BUILD CRC WITH LESS FRAMES AND SET static.ARQ_TX_N_FRAMES TO VALUE OF REST!
|
|
||||||
print("LAST BURST!!!")
|
|
||||||
burst_total_payload = bytearray() # reset burst_total_payload because of possible input remaining of detecting loop one step above
|
burst_total_payload = bytearray() # reset burst_total_payload because of possible input remaining of detecting loop one step above
|
||||||
n_last_burst = (static.TX_BUFFER_SIZE % n_raw_frame)
|
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
|
||||||
print(n_last_burst)
|
static.ARQ_TX_N_FRAMES_PER_BURST = static.TX_BUFFER_SIZE
|
||||||
static.ARQ_TX_N_FRAMES = n_last_burst
|
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)
|
||||||
|
|
||||||
for i in range(n_last_burst): #bytearray(b'111111111111111111111111222222222222222222222222')
|
#print("ARQ_TX_N_FRAMES_PER_BURST OF LAST BURST: " + str(static.ARQ_TX_N_FRAMES_PER_BURST))
|
||||||
|
|
||||||
burst_raw_payload = static.TX_BUFFER[n_raw_frame + i]
|
for i in range(static.ARQ_TX_N_FRAMES_PER_BURST): #bytearray(b'111111111111111111111111222222222222222222222222')
|
||||||
|
|
||||||
|
# make sure we have always a filled buffer with the length of payload per frame
|
||||||
|
burst_raw_payload = static.TX_BUFFER[static.ARQ_N_SENT_FRAMES + i]
|
||||||
burst_payload = bytearray(static.ARQ_PAYLOAD_PER_FRAME)
|
burst_payload = bytearray(static.ARQ_PAYLOAD_PER_FRAME)
|
||||||
burst_payload[:len(burst_raw_payload)] = burst_raw_payload # set buffersize to length of data which will be send
|
burst_payload[:len(burst_raw_payload)] = burst_raw_payload # get frame from TX_BUFFER
|
||||||
burst_total_payload = burst_total_payload + burst_payload
|
burst_total_payload = burst_total_payload + burst_payload # append single frame to total payload buffer
|
||||||
|
|
||||||
#----------------------------------------------------------------------------------------------------------
|
# ----------- GENERATE PAYLOAD CRC FOR ARQ_TX_N_FRAMES_PER_BURST
|
||||||
|
static.ARQ_BURST_PAYLOAD_CRC = helpers.get_crc_16(burst_total_payload)
|
||||||
|
|
||||||
print(burst_total_payload)
|
#--------------------------------------------- N ATTEMPTS TO SEND BURSTS IF ACK RECEPTION FAILS
|
||||||
|
|
||||||
burst_payload_crc = crc_algorithm(burst_total_payload)
|
|
||||||
burst_payload_crc = burst_payload_crc.to_bytes(2, byteorder='big')
|
|
||||||
|
|
||||||
print(burst_payload_crc)
|
|
||||||
static.ARQ_ACK_WAITING_FOR_ID = burst_payload_crc #set the global variable so we know for which ACK we are waiting for
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
#----------------------------------------------------------------------------------------------------------
|
|
||||||
#-------------------- BUILD ARQBURSTS
|
|
||||||
|
|
||||||
arqburst = []
|
|
||||||
for i in range(static.ARQ_TX_N_FRAMES):
|
|
||||||
|
|
||||||
|
|
||||||
frame_type = 10 + static.ARQ_TX_N_FRAMES
|
|
||||||
frame_type = bytes([frame_type])
|
|
||||||
|
|
||||||
payload_data = bytes(static.TX_BUFFER[n_raw_frame + i])
|
|
||||||
|
|
||||||
arqframe = frame_type + burst_payload_crc + payload_data
|
|
||||||
|
|
||||||
buffer = bytearray(static.FREEDV_PAYLOAD_PER_FRAME) # create TX buffer
|
|
||||||
buffer[:len(arqframe)] = arqframe # set buffersize to length of data which will be send
|
|
||||||
|
|
||||||
arqburst.append(buffer)
|
|
||||||
|
|
||||||
#----------------------------------------------------------------------------------------------------------
|
|
||||||
|
|
||||||
|
|
||||||
#--------------------------------------------- N ATTEMPTS TO SEND BURSTS IF ACK FAILS
|
|
||||||
for static.TX_N_RETRIES in range(static.TX_N_MAX_RETRIES):
|
for static.TX_N_RETRIES in range(static.TX_N_MAX_RETRIES):
|
||||||
|
|
||||||
static.ACK_RECEIVED = 0
|
if static.ARQ_N_SENT_FRAMES+1 <= static.TX_BUFFER_SIZE:
|
||||||
|
logging.info("ARQ | TX | B:[" + str(static.ARQ_BURST_PAYLOAD_CRC.hex()) + "] 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) + "]")
|
||||||
|
|
||||||
# ----------------------- Loop through ARQ FRAMES BUFFER with N = Numbers of frames which will be send at once
|
|
||||||
|
|
||||||
for n in range(static.ARQ_TX_N_FRAMES):
|
|
||||||
logging.info("TX | SENDING BURST " + str(n+1) + " / " + str(static.ARQ_TX_N_FRAMES))
|
|
||||||
modem.Transmit(arqburst[n])
|
|
||||||
time.sleep(2)
|
|
||||||
#modem.RF.Transmit(arqburst[n])
|
|
||||||
print(arqburst[n])
|
|
||||||
|
|
||||||
# --------------------------- START TIMER ---> IF TIMEOUT REACHED, ACK_TIMEOUT = 1
|
# lets start a thread to transmit nonblocking
|
||||||
static.ACK_TIMEOUT = 0
|
TRANSMIT_ARQ_BURST_THREAD = threading.Thread(target=modem.transmit_arq_burst, name="TRANSMIT_ARQ_BURST")
|
||||||
timer = threading.Timer(static.ACK_TIMEOUT_SECONDS * static.ARQ_TX_N_FRAMES, other.timeout)
|
TRANSMIT_ARQ_BURST_THREAD.start()
|
||||||
|
|
||||||
|
# lets wait during sending. After sending is finished we will continue
|
||||||
|
while static.ARQ_STATE == 'SENDING_DATA':
|
||||||
|
time.sleep(0.05)
|
||||||
|
|
||||||
|
|
||||||
|
# --------------------------- START TIMER FOR WAITING FOR ACK ---> IF TIMEOUT REACHED, ACK_TIMEOUT = 1
|
||||||
|
#reset timer and ack state
|
||||||
|
static.ARQ_FRAME_ACK_RECEIVED = 0
|
||||||
|
static.ARQ_ACK_RECEIVED = 0
|
||||||
|
static.ARQ_ACK_TIMEOUT = 0
|
||||||
|
|
||||||
|
logging.debug("ARQ | RX | WAITING FOR BURST ACK")
|
||||||
|
static.ARQ_STATE = 'RECEIVING_ACK'
|
||||||
|
|
||||||
|
timer = threading.Timer(static.ARQ_ACK_TIMEOUT_SECONDS, arq_ack_timeout)
|
||||||
timer.start()
|
timer.start()
|
||||||
|
|
||||||
|
|
||||||
# --------------------------- WHILE TIMEOUT NOT REACHED AND NO ACK RECEIVED --> LISTEN
|
# --------------------------- WHILE TIMEOUT NOT REACHED AND NO ACK RECEIVED --> LISTEN
|
||||||
logging.info("TX | WAITING FOR ACK")
|
while static.ARQ_ACK_TIMEOUT == 0 and static.ARQ_ACK_RECEIVED == 0:
|
||||||
|
time.sleep(0.01) # lets reduce CPU load a little bit
|
||||||
|
#print(static.ARQ_STATE)
|
||||||
|
|
||||||
while static.ACK_TIMEOUT == 0 and static.ACK_RECEIVED == 0:
|
|
||||||
static.MODEM_RECEIVE = True
|
|
||||||
else:
|
|
||||||
logging.info("TX | ACK TIMEOUT - SENDING AGAIN")
|
|
||||||
|
|
||||||
#--------------- BREAK LOOP IF ACK HAS BEEN RECEIVED
|
if static.ARQ_ACK_RECEIVED == 0 and static.ARQ_ACK_TIMEOUT == 1:
|
||||||
if static.ACK_RECEIVED == 1:
|
#logging.info("ARQ | RX | ACK TIMEOUT | SENDING ARQ BURST AGAIN")
|
||||||
#static.TX_N_RETRIES = 3
|
pass
|
||||||
|
|
||||||
|
#--------------- BREAK LOOP IF ACK HAS BEEN RECEIVED OR FRAME ACK HAS BEEN RECEIVED
|
||||||
|
if static.ARQ_ACK_RECEIVED == 1:
|
||||||
|
#-----------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
|
||||||
|
if static.ARQ_FRAME_ACK_RECEIVED == 1:
|
||||||
|
logging.info("ARQ | RX | EARLY FRAME ACK RECEIVED - STOPPING TX")
|
||||||
|
#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
|
break
|
||||||
|
|
||||||
# ----------- if no ACK received and out of retries.....stop frame sending
|
# ----------- if no ACK received and out of retries.....stop frame sending
|
||||||
if static.ACK_RECEIVED == 0:
|
if static.ARQ_ACK_RECEIVED == 0 and static.ARQ_FRAME_ACK_RECEIVED == 0 and static.ARQ_ACK_TIMEOUT == 1:
|
||||||
logging.info("TX | NO ACK RECEIVED | FRAME NEEDS TO BE RESEND!")
|
logging.info("ARQ | TX | NO BURST OR FRAME ACK RECEIVED | DATA SHOULD BE RESEND!")
|
||||||
|
print(bytes(static.TX_BUFFER[static.ARQ_N_SENT_FRAMES]))
|
||||||
|
break
|
||||||
|
|
||||||
|
#-------------------------BREAK TX BUFFER LOOP IF ALL PACKETS HAVE BEEN SENT AND WE GOT A FRAME ACK
|
||||||
|
if static.ARQ_N_SENT_FRAMES == static.TX_BUFFER_SIZE and static.ARQ_FRAME_ACK_RECEIVED == 1:
|
||||||
|
logging.info("ARQ | RX | REGULAR FRAME ACK RECEIVED - DATA TRANSMITTED!")
|
||||||
break
|
break
|
||||||
|
|
||||||
|
|
||||||
#-------------------------BREAK TX BUFFER LOOP IF ALL PACKETS HAVE BEEN SENT
|
# IF TX BUFFER IS EMPTY / ALL FRAMES HAVE BEEN SENT --> HERE WE COULD ADD AN static.VAR for IDLE STATE
|
||||||
if n_raw_frame == static.TX_BUFFER_SIZE:
|
|
||||||
break
|
|
||||||
|
|
||||||
# ------------ TIMER TO WAIT UNTIL NEXT PACKAGE WILL BE SEND TO PREVENT TIME ISSEUS
|
logging.info("ARQ | TX | BUFFER EMPTY")
|
||||||
time.sleep(5)
|
# - RESET COUNTERS
|
||||||
|
static.ARQ_N_SENT_FRAMES = 0
|
||||||
logging.info("TX | BUFFER EMPTY")
|
static.ARQ_TX_N_FRAMES_PER_BURST = 0
|
||||||
|
static.ARQ_ACK_RECEIVED = 0
|
||||||
|
static.ARQ_FRAME_ACK_RECEIVED = 0
|
||||||
|
|
||||||
|
|
||||||
# BURST MACHINE TO DEFINE N BURSTS PER FRAME
|
|
||||||
def n_frames_per_burst(len_data):
|
|
||||||
|
|
||||||
if len_data <= static.ARQ_PAYLOAD_PER_FRAME:
|
|
||||||
n_frames_per_burst = 1
|
|
||||||
else:
|
|
||||||
n_frames_per_burst = 1
|
|
||||||
|
|
||||||
|
# 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
|
||||||
return n_frames_per_burst
|
return n_frames_per_burst
|
29
helpers.py
Normal file
29
helpers.py
Normal file
|
@ -0,0 +1,29 @@
|
||||||
|
#!/usr/bin/env python3
|
||||||
|
# -*- coding: utf-8 -*-
|
||||||
|
"""
|
||||||
|
Created on Fri Dec 25 21:25:14 2020
|
||||||
|
|
||||||
|
@author: DJ2LS
|
||||||
|
"""
|
||||||
|
|
||||||
|
import time
|
||||||
|
import threading
|
||||||
|
import logging
|
||||||
|
import crcengine
|
||||||
|
|
||||||
|
|
||||||
|
import static
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
def get_crc_8(data):
|
||||||
|
crc_algorithm = crcengine.new('crc8-ccitt') #load crc8 library
|
||||||
|
crc_data = crc_algorithm(data)
|
||||||
|
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_data = crc_algorithm(data)
|
||||||
|
crc_data = crc_data.to_bytes(2, byteorder='big')
|
||||||
|
return crc_data
|
|
@ -21,6 +21,6 @@ cmake -DCODEC2_BUILD_DIR=~/FreeDV-JATE/codec2/build_linux ../
|
||||||
make
|
make
|
||||||
|
|
||||||
|
|
||||||
cd ~/FreeDV-Socket-TNC/codec2/build_linux && rm -Rf *
|
cd ~/FreeDV-JATE/codec2/build_linux && rm -Rf *
|
||||||
cmake -DLPCNET_BUILD_DIR=~/FreeDV-JATE/LPCNet/build_linux ..
|
cmake -DLPCNET_BUILD_DIR=~/FreeDV-JATE/LPCNet/build_linux ..
|
||||||
make
|
make
|
||||||
|
|
18
main.py
18
main.py
|
@ -8,17 +8,19 @@ Created on Tue Dec 22 16:58:45 2020
|
||||||
"""
|
"""
|
||||||
|
|
||||||
import socketserver
|
import socketserver
|
||||||
import threading
|
|
||||||
import argparse
|
import argparse
|
||||||
import logging
|
import logging
|
||||||
|
|
||||||
import tnc
|
#import tnc
|
||||||
import static
|
import static
|
||||||
import modem
|
|
||||||
|
|
||||||
modem = modem.RF()
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
if __name__ == '__main__':
|
||||||
|
|
||||||
#--------------------------------------------GET PARAMETER INPUTS
|
#--------------------------------------------GET PARAMETER INPUTS
|
||||||
parser = argparse.ArgumentParser(description='Simons TEST TNC')
|
parser = argparse.ArgumentParser(description='Simons TEST TNC')
|
||||||
parser.add_argument('--rx', dest="audio_input_device", default=0, help="sound card for listening.", type=int)
|
parser.add_argument('--rx', dest="audio_input_device", default=0, help="sound card for listening.", type=int)
|
||||||
|
@ -27,11 +29,11 @@ parser.add_argument('--port', dest="socket_port", default=3000, help="Set the po
|
||||||
|
|
||||||
args = parser.parse_args()
|
args = parser.parse_args()
|
||||||
|
|
||||||
|
|
||||||
static.AUDIO_INPUT_DEVICE = args.audio_input_device
|
static.AUDIO_INPUT_DEVICE = args.audio_input_device
|
||||||
static.AUDIO_OUTPUT_DEVICE = args.audio_output_device
|
static.AUDIO_OUTPUT_DEVICE = args.audio_output_device
|
||||||
static.PORT = args.socket_port
|
static.PORT = args.socket_port
|
||||||
|
|
||||||
|
import tnc # we need to wait until we got all parameters from argparse
|
||||||
|
|
||||||
#-------------------------------------------- DEFINE LOGGER
|
#-------------------------------------------- DEFINE LOGGER
|
||||||
logger = logging.getLogger()
|
logger = logging.getLogger()
|
||||||
|
@ -39,12 +41,6 @@ logger.setLevel("INFO") #DEBUG>INFO>WARNING>ERROR>CRITICAL
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
#--------------------------------------------START AUDIO THREAD
|
|
||||||
logging.info("STARTING AUDIO THREAD")
|
|
||||||
static.MODEM_RECEIVE = True
|
|
||||||
audio_receiver_thread = threading.Thread(target=modem.Receive, name="Audio Listener")
|
|
||||||
audio_receiver_thread.start()
|
|
||||||
|
|
||||||
|
|
||||||
#--------------------------------------------START SERVER
|
#--------------------------------------------START SERVER
|
||||||
logging.info("STARTING TCP/IP SOCKET ON PORT " + str(static.PORT))
|
logging.info("STARTING TCP/IP SOCKET ON PORT " + str(static.PORT))
|
||||||
|
|
407
modem.py
407
modem.py
|
@ -10,174 +10,327 @@ import ctypes
|
||||||
from ctypes import *
|
from ctypes import *
|
||||||
import pathlib
|
import pathlib
|
||||||
import pyaudio
|
import pyaudio
|
||||||
import audioop
|
|
||||||
import sys
|
import sys
|
||||||
import logging
|
import logging
|
||||||
|
import time
|
||||||
|
import threading
|
||||||
|
|
||||||
|
import helpers
|
||||||
import static
|
import static
|
||||||
import arq
|
import arq
|
||||||
|
|
||||||
#arq = arq.ARQ()
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
class RF():
|
class RF():
|
||||||
|
|
||||||
def __init__(self):
|
def __init__(self):
|
||||||
|
#-------------------------------------------- LOAD FREEDV
|
||||||
self.p = pyaudio.PyAudio()
|
|
||||||
self.defaultFrames = static.DEFAULT_FRAMES
|
|
||||||
self.audio_input_device = static.AUDIO_INPUT_DEVICE
|
|
||||||
self.audio_output_device = static.AUDIO_OUTPUT_DEVICE
|
|
||||||
self.tx_sample_state = static.TX_SAMPLE_STATE
|
|
||||||
self.rx_sample_state = static.RX_SAMPLE_STATE
|
|
||||||
self.audio_sample_rate = static.AUDIO_SAMPLE_RATE
|
|
||||||
self.modem_sample_rate = static.MODEM_SAMPLE_RATE
|
|
||||||
self.audio_frames_per_buffer = static.AUDIO_FRAMES_PER_BUFFER
|
|
||||||
self.audio_channels = static.AUDIO_CHANNELS
|
|
||||||
self.format = pyaudio.paInt16
|
|
||||||
self.stream = None
|
|
||||||
|
|
||||||
#self.data_input = "stdin"
|
|
||||||
self.data_input = "audio"
|
|
||||||
#self.data_output = "stdout"
|
|
||||||
self.data_output = "audio"
|
|
||||||
|
|
||||||
libname = pathlib.Path().absolute() / "codec2/build_linux/src/libcodec2.so"
|
libname = pathlib.Path().absolute() / "codec2/build_linux/src/libcodec2.so"
|
||||||
self.c_lib = ctypes.CDLL(libname)
|
self.c_lib = ctypes.CDLL(libname)
|
||||||
|
#--------------------------------------------CREATE PYAUDIO INSTANCE
|
||||||
self.mode = static.FREEDV_MODE # define mode
|
self.p = pyaudio.PyAudio()
|
||||||
|
#--------------------------------------------GET SUPPORTED SAMPLE RATES FROM SOUND DEVICE
|
||||||
self.freedv = self.c_lib.freedv_open(self.mode)
|
#static.AUDIO_SAMPLE_RATE_RX = int(self.p.get_device_info_by_index(static.AUDIO_INPUT_DEVICE)['defaultSampleRate'])
|
||||||
self.bytes_per_frame = int(self.c_lib.freedv_get_bits_per_modem_frame(self.freedv)/8)
|
#static.AUDIO_SAMPLE_RATE_TX = int(self.p.get_device_info_by_index(static.AUDIO_OUTPUT_DEVICE)['defaultSampleRate'])
|
||||||
self.payload_per_frame = self.bytes_per_frame -2
|
static.AUDIO_SAMPLE_RATE_TX = 8000
|
||||||
self.n_tx_modem_samples = self.c_lib.freedv_get_n_tx_modem_samples(self.freedv)*2 #get n_tx_modem_samples which defines the size of the modulation object
|
static.AUDIO_SAMPLE_RATE_RX = 8000
|
||||||
self.n_max_modem_samples = self.c_lib.freedv_get_n_max_modem_samples(self.freedv)
|
#--------------------------------------------OPEN AUDIO CHANNEL RX
|
||||||
self.n_nom_modem_samples = self.c_lib.freedv_get_n_nom_modem_samples(self.freedv)
|
self.stream_rx = self.p.open(format=pyaudio.paInt16,
|
||||||
self.nin = self.c_lib.freedv_nin(self.freedv)
|
channels=static.AUDIO_CHANNELS,
|
||||||
|
rate=static.AUDIO_SAMPLE_RATE_RX,
|
||||||
static.FREEDV_BYTES_PER_FRAME = self.bytes_per_frame
|
frames_per_buffer=static.AUDIO_FRAMES_PER_BUFFER,
|
||||||
static.FREEDV_PAYLOAD_PER_FRAME = self.payload_per_frame
|
input=True,
|
||||||
|
input_device_index=static.AUDIO_INPUT_DEVICE,
|
||||||
|
)
|
||||||
# MODULATION-OUT OBJECT
|
#--------------------------------------------OPEN AUDIO CHANNEL TX
|
||||||
def ModulationOut(self):
|
self.stream_tx = self.p.open(format=pyaudio.paInt16,
|
||||||
return (c_short * self.n_tx_modem_samples)
|
channels=1,
|
||||||
|
rate=static.AUDIO_SAMPLE_RATE_TX,
|
||||||
# MODULATION-IN OBJECT
|
frames_per_buffer=static.AUDIO_FRAMES_PER_BUFFER, #n_nom_modem_samples
|
||||||
def ModulationIn(self):
|
output=True,
|
||||||
return (c_short * (self.n_max_modem_samples))
|
output_device_index=static.AUDIO_OUTPUT_DEVICE, #static.AUDIO_OUTPUT_DEVICE
|
||||||
|
)
|
||||||
# FRAME BYTES
|
#--------------------------------------------START DECODER THREAD
|
||||||
# Pointer for changing buffer data type
|
FREEDV_DECODER_THREAD = threading.Thread(target=self.receive, args=[static.FREEDV_DATA_MODE,static.FREEDV_SIGNALLING_MODE], name="FREEDV_DECODER_THREAD")
|
||||||
def FrameBytes(self):
|
FREEDV_DECODER_THREAD.start()
|
||||||
return (c_ubyte * self.bytes_per_frame)
|
#--------------------------------------------------------------------------------------------------------
|
||||||
|
|
||||||
# GET DATA AND MODULATE IT
|
# GET DATA AND MODULATE IT
|
||||||
|
|
||||||
def Transmit(self,data_out):
|
def transmit(self,mode,data_out):
|
||||||
|
|
||||||
mod_out = self.ModulationOut()() # new modulation object and get pointer to it
|
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)
|
||||||
|
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)*2 #get n_tx_modem_samples which defines the size of the modulation object
|
||||||
|
|
||||||
|
mod_out = ctypes.c_short * n_tx_modem_samples
|
||||||
|
mod_out = mod_out()
|
||||||
|
mod_out_preamble = ctypes.c_short * n_tx_modem_samples #1760 for mode 10,11,12 #4000 for mode 9
|
||||||
|
mod_out_preamble = mod_out_preamble()
|
||||||
|
|
||||||
data_list = [data_out[i:i+self.payload_per_frame] for i in range(0, len(data_out), self.payload_per_frame)] # split incomming bytes to size of 30bytes, create a list and loop through it
|
data_list = [data_out[i:i+payload_per_frame] for i in range(0, len(data_out), payload_per_frame)] # split incomming bytes to size of 30bytes, create a list and loop through it
|
||||||
data_list_length = len(data_list)
|
data_list_length = len(data_list)
|
||||||
for i in range(data_list_length): # LOOP THROUGH DATA LIST
|
for i in range(data_list_length): # LOOP THROUGH DATA LIST
|
||||||
|
|
||||||
if self.mode < 10: # don't generate CRC16 for modes 0 - 9
|
buffer = bytearray(payload_per_frame) # use this if CRC16 checksum is required ( DATA1-3)
|
||||||
|
|
||||||
buffer = bytearray(self.bytes_per_frame) # use this if no CRC16 checksum is required
|
|
||||||
buffer[:len(data_list[i])] = data_list[i] # set buffersize to length of data which will be send
|
buffer[:len(data_list[i])] = data_list[i] # set buffersize to length of data which will be send
|
||||||
|
|
||||||
if self.mode >= 10: #generate CRC16 for modes 10-12..
|
crc = ctypes.c_ushort(self.c_lib.freedv_gen_crc16(bytes(buffer), payload_per_frame)) # generate CRC16
|
||||||
|
|
||||||
buffer = bytearray(self.payload_per_frame) # use this if CRC16 checksum is required ( DATA1-3)
|
|
||||||
buffer[:len(data_list[i])] = data_list[i] # set buffersize to length of data which will be send
|
|
||||||
|
|
||||||
crc = c_ushort(self.c_lib.freedv_gen_crc16(bytes(buffer), self.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
|
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
|
||||||
|
|
||||||
data = self.FrameBytes().from_buffer_copy(buffer) #change data format from bytearray to ctypes.u_byte and copy from buffer to data
|
# -------------- preamble area
|
||||||
|
# WE NEED TO ADJUST IT FOR SINGLE TRANSMISSION
|
||||||
|
|
||||||
self.c_lib.freedv_rawdatatx(self.freedv,mod_out,data) # modulate DATA and safe it into mod_out pointer
|
txbuffer = bytearray()
|
||||||
|
txbuffer += bytes(mod_out_preamble)
|
||||||
if self.data_output == "stdout":
|
txbuffer += bytes(mod_out)
|
||||||
sys.stdout.buffer.write(mod_out) # print data to terminal for piping the output to other programs
|
txbuffer = txbuffer.rstrip(b'\x00')
|
||||||
sys.stdout.flush() # flushing stdout
|
|
||||||
|
|
||||||
if self.data_output == "audio":
|
|
||||||
#print(self.audio_channels)
|
|
||||||
stream_tx = self.p.open(format=self.format,
|
|
||||||
channels=self.audio_channels,
|
|
||||||
rate=self.audio_sample_rate,
|
|
||||||
frames_per_buffer=self.n_nom_modem_samples,
|
|
||||||
output=True,
|
|
||||||
output_device_index=self.audio_output_device,
|
|
||||||
)
|
|
||||||
|
|
||||||
audio = audioop.ratecv(mod_out,2,1,self.modem_sample_rate, self.audio_sample_rate, self.tx_sample_state)
|
|
||||||
stream_tx.write(audio[0])
|
|
||||||
stream_tx.close()
|
|
||||||
|
|
||||||
return mod_out
|
|
||||||
|
|
||||||
|
|
||||||
# DEMODULATE DATA AND RETURN IT
|
# -------------- transmit audio
|
||||||
def Receive(self):
|
self.stream_tx.write(bytes(txbuffer))
|
||||||
|
|
||||||
# Open Audio Channel once
|
#--------------------------------------------------------------------------------------------------------
|
||||||
stream_rx = self.p.open(format=self.format,
|
def transmit_arq_ack(self,ack_buffer):
|
||||||
channels=self.audio_channels,
|
|
||||||
rate=self.audio_sample_rate,
|
static.ARQ_STATE = 'SENDING_ACK'
|
||||||
frames_per_buffer=self.n_max_modem_samples,
|
|
||||||
input=True,
|
self.c_lib.freedv_open.restype = ctypes.POINTER(ctypes.c_ubyte)
|
||||||
input_device_index=self.audio_input_device,
|
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
|
||||||
|
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
|
||||||
|
|
||||||
|
mod_out = ctypes.c_short * n_tx_modem_samples
|
||||||
|
mod_out = mod_out()
|
||||||
|
mod_out_preamble = ctypes.c_short * (1760*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(ack_buffer)] = ack_buffer # 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
|
||||||
|
buffer += crc # append crc16 to buffer
|
||||||
|
#print(bytes(buffer))
|
||||||
|
data = (ctypes.c_ubyte * bytes_per_frame).from_buffer_copy(buffer)
|
||||||
|
|
||||||
|
preamble_bytes = 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 = txbuffer.rstrip(b'\x00') #lets remove unallocated memory because of wrong buffer :-/
|
||||||
|
txbuffer += bytes(mod_out)
|
||||||
|
txbuffer = txbuffer.rstrip(b'\x00') #lets remove unallocated memory because of wrong buffer :-/
|
||||||
|
# -------------- transmit audio
|
||||||
|
self.stream_tx.write(bytes(txbuffer))
|
||||||
|
self.stream_tx.write(bytes(txbuffer))
|
||||||
|
|
||||||
|
static.ARQ_STATE = 'RECEIVING_DATA'
|
||||||
|
#--------------------------------------------------------------------------------------------------------
|
||||||
|
# GET ARQ BURST FRAME VOM BUFFER AND MODULATE IT
|
||||||
|
def transmit_arq_burst(self):
|
||||||
|
static.ARQ_STATE = 'SENDING_DATA'
|
||||||
|
|
||||||
|
self.c_lib.freedv_open.restype = ctypes.POINTER(ctypes.c_ubyte)
|
||||||
|
freedv = self.c_lib.freedv_open(static.FREEDV_DATA_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
|
||||||
|
|
||||||
|
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
|
||||||
|
|
||||||
|
mod_out = ctypes.c_short * n_tx_modem_samples
|
||||||
|
mod_out = mod_out()
|
||||||
|
mod_out_preamble = ctypes.c_short * (n_tx_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);
|
||||||
|
txbuffer = bytearray()
|
||||||
|
txbuffer += bytes(mod_out_preamble)
|
||||||
|
txbuffer = txbuffer.rstrip(b'\x00') #lets remove unallocated memory because of wrong buffer :-/
|
||||||
|
|
||||||
|
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
|
||||||
|
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')
|
||||||
|
|
||||||
|
|
||||||
while static.MODEM_RECEIVE == True: # Listne to audio until data arrives
|
|
||||||
|
# 1 # frame type and current number of arq frame of burst
|
||||||
|
# 1 # total number of arq frames per (current) burst
|
||||||
|
# 2 # current arq frame number
|
||||||
|
# 2 # total number arq frames
|
||||||
|
# 2 # arq crc
|
||||||
|
# N # payload data
|
||||||
|
|
||||||
|
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.ARQ_BURST_PAYLOAD_CRC + \
|
||||||
|
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
|
||||||
|
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
|
||||||
|
txbuffer += bytes(mod_out)
|
||||||
|
txbuffer = txbuffer.rstrip(b'\x00') #lets remove unallocated memory because of wrong buffer :-/
|
||||||
|
|
||||||
|
# -------------- transmit audio
|
||||||
|
self.stream_tx.write(bytes(txbuffer))
|
||||||
|
|
||||||
|
static.ARQ_STATE = 'RECEIVING_ACK'
|
||||||
|
|
||||||
|
#--------------------------------------------------------------------------------------------------------
|
||||||
|
def receive(self,data_mode,signalling_mode):
|
||||||
|
|
||||||
|
self.c_lib.freedv_open.restype = ctypes.POINTER(ctypes.c_ubyte)
|
||||||
|
|
||||||
|
freedv_data = self.c_lib.freedv_open(data_mode)
|
||||||
|
freedv_signalling = self.c_lib.freedv_open(signalling_mode)
|
||||||
|
|
||||||
|
static.FREEDV_DATA_BYTES_PER_FRAME = int(self.c_lib.freedv_get_bits_per_modem_frame(freedv_data)/8)
|
||||||
|
static.FREEDV_DATA_PAYLOAD_PER_FRAME = static.FREEDV_DATA_BYTES_PER_FRAME -2
|
||||||
|
static.FREEDV_SIGNALLING_BYTES_PER_FRAME = int(self.c_lib.freedv_get_bits_per_modem_frame(freedv_signalling)/8)
|
||||||
|
static.FREEDV_SIGNALLING_PAYLOAD_PER_FRAME = static.FREEDV_SIGNALLING_BYTES_PER_FRAME -2
|
||||||
|
|
||||||
|
data_bytes_out = (ctypes.c_ubyte * static.FREEDV_DATA_BYTES_PER_FRAME)
|
||||||
|
data_bytes_out = data_bytes_out() #get pointer from bytes_out
|
||||||
|
|
||||||
|
signalling_bytes_out = (ctypes.c_ubyte * static.FREEDV_SIGNALLING_BYTES_PER_FRAME)
|
||||||
|
signalling_bytes_out = signalling_bytes_out() #get pointer from bytes_out
|
||||||
|
|
||||||
|
# with this we can interrupt receiving
|
||||||
|
while static.FREEDV_RECEIVE == True:
|
||||||
|
time.sleep(0.01)
|
||||||
|
|
||||||
|
# stuck in sync counter
|
||||||
|
stuck_in_sync_counter = 0
|
||||||
|
stuck_in_sync_10_counter = 0
|
||||||
|
#
|
||||||
|
|
||||||
|
|
||||||
#if self.data_input == "stdin":
|
|
||||||
# samples = self.c_lib.freedv_nin(self.freedv)*2 ### MIT DER *2 funktioniert das irgendwie recht zuverlässig bei mode 5! Bei Mode 12 auch
|
|
||||||
# data_in = sys.stdin.buffer.read(samples)
|
|
||||||
if self.data_input == "audio":
|
|
||||||
|
|
||||||
data_in = stream_rx.read(self.c_lib.freedv_nin(self.freedv), exception_on_overflow = False)
|
while static.ARQ_STATE == 'RECEIVING_DATA':
|
||||||
#print(bytes(data_in))
|
time.sleep(0.01)
|
||||||
buffer = bytearray(self.n_max_modem_samples*2) # N MAX SAMPLES * 2
|
|
||||||
buffer[:len(data_in)] = data_in # copy across what we have
|
nin = self.c_lib.freedv_nin(freedv_data)
|
||||||
|
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 = data_in.rstrip(b'\x00')
|
||||||
|
|
||||||
|
#print(data_in)
|
||||||
|
|
||||||
|
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_data, data_bytes_out, data_in) # demodulate audio
|
||||||
|
#print(self.c_lib.freedv_get_rx_status(freedv_data))
|
||||||
|
|
||||||
|
|
||||||
self.ModulationIn()() #Create new ModulationIn Object
|
#-------------STUCK IN SYNC DETECTOR
|
||||||
modulation = self.ModulationIn()# get an empty modulation array
|
stuck_in_sync_counter += 1
|
||||||
modulation = modulation.from_buffer_copy(buffer) # copy buffer across and get a pointer to it.
|
if self.c_lib.freedv_get_rx_status(freedv_data) == 10:
|
||||||
|
stuck_in_sync_10_counter += 1
|
||||||
bytes_out = self.FrameBytes()() # initilize a pointer to where bytes will be outputed
|
|
||||||
|
|
||||||
nbytes = self.c_lib.freedv_rawdatarx(self.freedv, bytes_out, data_in) # Demodulated data and get number of demodulated bytes
|
|
||||||
|
|
||||||
if nbytes == self.bytes_per_frame: # make sure, we receive a full frame
|
|
||||||
|
|
||||||
print(bytes(bytes_out[:-2]))
|
|
||||||
self.c_lib.freedv_set_sync(self.freedv, 0) #FORCE UNSYNC
|
|
||||||
|
|
||||||
|
|
||||||
# CHECK IF FRAMETYPE CONTAINS ACK------------------------
|
#print(stuck_in_sync_counter)
|
||||||
frametype = int.from_bytes(bytes(bytes_out[:1]), "big")
|
if stuck_in_sync_counter == 33 and self.c_lib.freedv_get_rx_status(freedv_data) == 10:
|
||||||
if 50 >= frametype >= 10 :
|
print("stuck in sync #1 --> DOING UNSYNC")
|
||||||
arq.data_received(bytes(bytes_out[:-2])) #send payload data to arq checker without CRC16
|
self.c_lib.freedv_set_sync(freedv_data, 0) #FORCE UNSYNC
|
||||||
|
stuck_in_sync_counter = 0
|
||||||
|
stuck_in_sync_10_counter = 0
|
||||||
|
data_in = None
|
||||||
|
|
||||||
|
|
||||||
|
if stuck_in_sync_counter >= 66 and stuck_in_sync_10_counter >= 2:
|
||||||
|
print("stuck in sync #2 --> DOING UNSYNC")
|
||||||
|
self.c_lib.freedv_set_sync(freedv_data, 0) #FORCE UNSYNC
|
||||||
|
stuck_in_sync_counter = 0
|
||||||
|
stuck_in_sync_10_counter = 0
|
||||||
|
data_in = None
|
||||||
|
#-----------------------------------
|
||||||
|
|
||||||
|
|
||||||
|
#modem_stats_snr = c_float()
|
||||||
|
#modem_stats_sync = c_int()
|
||||||
|
|
||||||
|
#self.c_lib.freedv_get_modem_stats(freedv_data,byref(modem_stats_sync), byref(modem_stats_snr))
|
||||||
|
#modem_stats_snr = modem_stats_snr.value
|
||||||
|
#print(modem_stats_snr)
|
||||||
|
|
||||||
|
if nbytes == static.FREEDV_DATA_BYTES_PER_FRAME:
|
||||||
|
# counter reset for stuck in sync counter
|
||||||
|
stuck_in_sync_counter = 0
|
||||||
|
stuck_in_sync_10_counter = 0
|
||||||
|
#
|
||||||
|
|
||||||
|
# CHECK IF FRAMETYPE IS BETWEEN 10 and 50 ------------------------
|
||||||
|
frametype = int.from_bytes(bytes(data_bytes_out[:1]), "big")
|
||||||
|
frame = frametype - 10
|
||||||
|
n_frames_per_burst = int.from_bytes(bytes(data_bytes_out[1:2]), "big")
|
||||||
|
if 50 >= frametype >= 10 and len(data_bytes_out) > 30: # --> The length check filters out random strings without CRC
|
||||||
|
arq.data_received(bytes(data_bytes_out[:-2])) #send payload data to arq checker without CRC16
|
||||||
|
else:
|
||||||
|
print("MODE: " + str(data_mode) + " DATA: " + str(bytes(data_bytes_out)))
|
||||||
|
|
||||||
|
# NEEDS TO BE OPTIMIZED
|
||||||
|
# DO UNSYNC AFTER LAST BURST by checking the frame numbers agains the total frames per burst
|
||||||
|
if frame == n_frames_per_burst:
|
||||||
|
self.c_lib.freedv_set_sync(freedv_data, 0) #FORCE UNSYNC
|
||||||
|
|
||||||
|
# DETECT STUCK IN SYNC
|
||||||
|
# count rx status 10
|
||||||
|
# if 10 greater 2 after 6 then unsync
|
||||||
|
|
||||||
|
while static.ARQ_STATE == 'IDLE' or static.ARQ_STATE == 'RECEIVING_ACK':
|
||||||
|
time.sleep(0.01)
|
||||||
|
|
||||||
|
nin = self.c_lib.freedv_nin(freedv_signalling)
|
||||||
|
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 = data_in.rstrip(b'\x00')
|
||||||
|
|
||||||
|
self.c_lib.freedv_rawdatarx.argtype = [ctypes.POINTER(ctypes.c_ubyte), signalling_bytes_out, data_in] # check if really neccessary
|
||||||
|
nbytes = self.c_lib.freedv_rawdatarx(freedv_signalling, signalling_bytes_out, data_in) # demodulate audio
|
||||||
|
|
||||||
# CHECK IF FRAME CONTAINS ACK------------------------
|
# CHECK IF FRAME CONTAINS ACK------------------------
|
||||||
if bytes(bytes_out[:1]) == b'\7':
|
frametype = int.from_bytes(bytes(signalling_bytes_out[:1]), "big")
|
||||||
arq.ack_received()
|
|
||||||
|
# BURST ACK
|
||||||
|
if frametype == 60 and nbytes == static.FREEDV_SIGNALLING_BYTES_PER_FRAME:
|
||||||
#return bytes(bytes_out[:-2])
|
arq.burst_ack_received()
|
||||||
|
# FRAME ACK
|
||||||
|
if frametype == 61 and nbytes == static.FREEDV_SIGNALLING_BYTES_PER_FRAME:
|
||||||
|
arq.frame_ack_received()
|
||||||
|
|
||||||
|
|
||||||
|
rxstatus = self.c_lib.freedv_get_rx_status(freedv_signalling)
|
||||||
|
#print(rxstatus)
|
||||||
|
if nbytes == static.FREEDV_SIGNALLING_BYTES_PER_FRAME or rxstatus == 10:
|
||||||
|
self.c_lib.freedv_set_sync(freedv_signalling, 0) #FORCE UNSYNC
|
||||||
|
|
||||||
|
|
18
other.py
18
other.py
|
@ -1,18 +0,0 @@
|
||||||
#!/usr/bin/env python3
|
|
||||||
# -*- coding: utf-8 -*-
|
|
||||||
"""
|
|
||||||
Created on Fri Dec 25 21:25:14 2020
|
|
||||||
|
|
||||||
@author: DJ2LS
|
|
||||||
"""
|
|
||||||
|
|
||||||
import time
|
|
||||||
import threading
|
|
||||||
import logging
|
|
||||||
|
|
||||||
import static
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
def timeout():
|
|
||||||
static.ACK_TIMEOUT = 1
|
|
94
static.py
94
static.py
|
@ -3,17 +3,25 @@
|
||||||
"""
|
"""
|
||||||
Created on Wed Dec 23 11:13:57 2020
|
Created on Wed Dec 23 11:13:57 2020
|
||||||
|
|
||||||
@author: parallels
|
@author: DJ2LS
|
||||||
"""
|
"""
|
||||||
|
# ADDITION MESSUREMENT:
|
||||||
|
#AUDIO TIME: 7.451462268829346 #12 # 1 FRAME + PREAMBLE
|
||||||
|
#MODULATION TIME: 0.002051115036010742 #12 # 1 FRAME + PREAMBLE
|
||||||
|
|
||||||
# Modem States
|
#MODULATION TIME: 0.004580974578857422 #12 # 2 FRAME + PREAMBLE
|
||||||
MODEM_RECEIVE = True
|
#AUDIO TIME: 14.750595331192017 #12 # 2 FRAME + PREAMBLE
|
||||||
|
|
||||||
|
|
||||||
# FreeDV Defaults
|
# FreeDV Defaults
|
||||||
FREEDV_MODE = 12
|
FREEDV_RECEIVE = True
|
||||||
FREEDV_BYTES_PER_FRAME = 0
|
|
||||||
FREEDV_PAYLOAD_PER_FRAME = 0
|
FREEDV_DATA_MODE = 12
|
||||||
|
FREEDV_SIGNALLING_MODE = 14
|
||||||
|
|
||||||
|
FREEDV_DATA_BYTES_PER_FRAME = 0
|
||||||
|
FREEDV_DATA_PAYLOAD_PER_FRAME = 0
|
||||||
|
FREEDV_SIGNALLING_BYTES_PER_FRAME = 0
|
||||||
|
FREEDV_SIGNALLING_PAYLOAD_PER_FRAME = 0
|
||||||
|
|
||||||
# Server Defaults
|
# Server Defaults
|
||||||
HOST = "localhost"
|
HOST = "localhost"
|
||||||
|
@ -21,38 +29,78 @@ PORT = 3000
|
||||||
|
|
||||||
|
|
||||||
#AUdio Defaults
|
#AUdio Defaults
|
||||||
DEFAULT_FRAMES = 1024
|
|
||||||
AUDIO_INPUT_DEVICE = 1
|
AUDIO_INPUT_DEVICE = 1
|
||||||
AUDIO_OUTPUT_DEVICE = 1
|
AUDIO_OUTPUT_DEVICE = 1
|
||||||
TX_SAMPLE_STATE = None
|
#TX_SAMPLE_STATE = None
|
||||||
RX_SAMPLE_STATE = None
|
#RX_SAMPLE_STATE = None
|
||||||
AUDIO_SAMPLE_RATE = 8000
|
|
||||||
MODEM_SAMPLE_RATE = 8000
|
#AUDIO_SAMPLE_RATE_RX = 44100
|
||||||
AUDIO_FRAMES_PER_BUFFER = 1024
|
#AUDIO_SAMPLE_RATE_TX = 44100
|
||||||
|
MODEM_SAMPLE_RATE = 8000 #8000
|
||||||
|
AUDIO_FRAMES_PER_BUFFER = 2048
|
||||||
AUDIO_CHANNELS = 1
|
AUDIO_CHANNELS = 1
|
||||||
|
|
||||||
|
|
||||||
#TNC DEFAULTS
|
#TNC DEFAULTS
|
||||||
# ----ARQ STOP AND WAIT
|
# ARQ
|
||||||
TX_N_MAX_RETRIES = 3
|
TX_N_MAX_RETRIES = 3
|
||||||
TX_N_RETRIES = 3
|
TX_N_RETRIES = 0
|
||||||
ACK_RECEIVED = 0
|
|
||||||
ACK_TIMEOUT = 0
|
|
||||||
ACK_TIMEOUT_SECONDS = 15.0
|
|
||||||
ACK_RX_TIMEOUT = 0
|
ARQ_TX_N_FRAMES_PER_BURST = 0
|
||||||
ACK_RX_TIMEOUT_SECONDS = 15.0
|
ARQ_TX_N_BURSTS = 0
|
||||||
|
|
||||||
ARQ_TX_N_FRAMES = 2
|
|
||||||
ARQ_PAYLOAD_PER_FRAME = 0
|
ARQ_PAYLOAD_PER_FRAME = 0
|
||||||
ARQ_ACK_WAITING_FOR_ID = 0
|
ARQ_ACK_WAITING_FOR_ID = 0
|
||||||
|
|
||||||
ARQ_RX_BURST_BUFFER = []
|
ARQ_RX_BURST_BUFFER = []
|
||||||
ARQ_RX_FRAME_BUFFER = []
|
ARQ_RX_FRAME_BUFFER = []
|
||||||
|
ARQ_RX_FRAME_N_BURSTS = 0
|
||||||
|
|
||||||
|
## 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
|
||||||
|
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_ACK_RECEIVED = 0 # set to 1 if ACK received
|
||||||
|
ARQ_FRAME_ACK_RECEIVED = 0 # set to 1 if FRAME ACK received
|
||||||
|
ARQ_ACK_TIMEOUT = 0 # set to 1 if timeut reached
|
||||||
|
ARQ_ACK_TIMEOUT_SECONDS = 4.0 #timeout for waiting for ACK frames
|
||||||
|
|
||||||
FRAME_CRC = b''
|
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
|
||||||
|
|
||||||
|
ARQ_N_SENT_FRAMES = 0 #counter for already sent frames
|
||||||
|
|
||||||
|
|
||||||
|
# ARQ STATES:
|
||||||
|
# IDLE
|
||||||
|
# RECEIVING_DATA
|
||||||
|
# SENDING_DATA
|
||||||
|
# RECEIVING_ACK
|
||||||
|
# SENDING_ACK
|
||||||
|
# ACK_RECEIVED
|
||||||
|
#
|
||||||
|
#
|
||||||
|
#
|
||||||
|
ARQ_STATE = 'RECEIVING_DATA'
|
||||||
|
|
||||||
# ------- TX BUFFER
|
# ------- TX BUFFER
|
||||||
TX_BUFFER_SIZE = 0
|
TX_BUFFER_SIZE = 0
|
||||||
|
TX_BUFFER = []
|
||||||
|
# ------- RX BUFFER
|
||||||
|
RX_BUFFER = []
|
||||||
|
RX_BUFFER_SIZE = 0
|
||||||
|
|
||||||
|
|
|
@ -1,64 +0,0 @@
|
||||||
# TESTS
|
|
||||||
|
|
||||||
### TEST_RX.py
|
|
||||||
|
|
||||||
Receive string "HALLO" with a lot of debugging output
|
|
||||||
```
|
|
||||||
./TEST_TX.py | ./TEST_RX.py
|
|
||||||
```
|
|
||||||
Output should be:
|
|
||||||
```
|
|
||||||
SYNC
|
|
||||||
INPUT PARSER: 1760
|
|
||||||
INPUT LENGTH: 1760
|
|
||||||
BUFFER LENGTH: 1848
|
|
||||||
MODULATION LENGTH: 924
|
|
||||||
SYNC
|
|
||||||
b'HALLO\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x15S'
|
|
||||||
INPUT PARSER: 1760
|
|
||||||
INPUT LENGTH: 1760
|
|
||||||
BUFFER LENGTH: 1848
|
|
||||||
MODULATION LENGTH: 924
|
|
||||||
SYNC
|
|
||||||
INPUT PARSER: 1760
|
|
||||||
```
|
|
||||||
|
|
||||||
### TEST_TX.py
|
|
||||||
|
|
||||||
Send string "HALLO"
|
|
||||||
```
|
|
||||||
./TEST_TX.py | ./freedv_data_raw_rx DATAC3 - - | hexdump -C
|
|
||||||
```
|
|
||||||
Output should be:
|
|
||||||
```
|
|
||||||
payload bytes_per_modem_frame: 30
|
|
||||||
00000000 54 45 53 54 00 00 00 00 00 00 00 00 00 00 00 00 |TEST............|
|
|
||||||
modem bufs processed: 22 output bytes: 30 output_frames: 1
|
|
||||||
00000010 00 00 00 00 00 00 00 00 00 00 00 00 00 00 |..............|
|
|
||||||
0000001e
|
|
||||||
```
|
|
||||||
|
|
||||||
|
|
||||||
### Checksum comparison FREEDV vs CRCENGINE
|
|
||||||
```
|
|
||||||
|
|
||||||
###################### CHECKSUM COMPARISON FREEDV VS CRCENGINE ########
|
|
||||||
#https://crccalc.com
|
|
||||||
|
|
||||||
teststring = b'TEST'
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
# freedv crc16 checksum
|
|
||||||
crctest2 = c_ushort(self.c_lib.freedv_gen_crc16(teststring, len(teststring)))
|
|
||||||
print("FREEDV2: " + str(crctest2.value) + " = " + hex(crctest2.value))
|
|
||||||
|
|
||||||
|
|
||||||
#Python crc16 checksum
|
|
||||||
crc_algorithm = crcengine.new('crc16-ccitt-false') #load crc16 library
|
|
||||||
crctest3 = crc_algorithm(teststring)
|
|
||||||
print("CRCENGINE: " + str(crctest3) + " = " + hex(crctest3))
|
|
||||||
|
|
||||||
|
|
||||||
#######################################################################
|
|
||||||
```
|
|
111
test/TEST_RX.py
111
test/TEST_RX.py
|
@ -1,111 +0,0 @@
|
||||||
#!/usr/bin/env python3
|
|
||||||
# -*- coding: utf-8 -*-
|
|
||||||
"""
|
|
||||||
Created on Tue Dec 15 18:29:22 2020
|
|
||||||
|
|
||||||
@author: DJ2LS
|
|
||||||
"""
|
|
||||||
|
|
||||||
|
|
||||||
import ctypes
|
|
||||||
from ctypes import *
|
|
||||||
import pathlib
|
|
||||||
|
|
||||||
import binascii #required for string.to_bytes() function
|
|
||||||
import sys
|
|
||||||
|
|
||||||
|
|
||||||
def main():
|
|
||||||
|
|
||||||
modem = FreeDV() #Load FreeDV Class as "modem"
|
|
||||||
|
|
||||||
modem.Demodulate()
|
|
||||||
|
|
||||||
class FreeDV():
|
|
||||||
|
|
||||||
def __init__(self):
|
|
||||||
|
|
||||||
self.mode = 12 # define mode
|
|
||||||
|
|
||||||
libname = pathlib.Path().absolute() / "libcodec2.so"
|
|
||||||
self.c_lib = ctypes.CDLL(libname) # Load FreeDV shared libary
|
|
||||||
|
|
||||||
self.freedv = self.c_lib.freedv_open(self.mode) #Set FreeDV waveform ( 10,11,12 --> DATA1-3 )
|
|
||||||
|
|
||||||
self.bytes_per_frame = int(self.c_lib.freedv_get_bits_per_modem_frame(self.freedv)/8) #get bytes per frame from selected waveform
|
|
||||||
self.payload_per_frame = self.bytes_per_frame -2 #get frame payload because of 2byte CRC16 checksum
|
|
||||||
self.n_max_modem_samples = self.c_lib.freedv_get_n_max_modem_samples(self.freedv)
|
|
||||||
self.nin = self.c_lib.freedv_nin(self.freedv)
|
|
||||||
|
|
||||||
print("N MAX MODEM SAMPLES: " + str(self.n_max_modem_samples))
|
|
||||||
print("NIN: " + str(self.nin))
|
|
||||||
print("BYTES PER FRAME: " + str(self.bytes_per_frame))
|
|
||||||
print("---------------------------------")
|
|
||||||
|
|
||||||
# MODULATION-IN OBJECT
|
|
||||||
def ModulationIn(self):
|
|
||||||
return (c_short * (self.n_max_modem_samples)) ##
|
|
||||||
|
|
||||||
|
|
||||||
# Pointer for changing buffer data type
|
|
||||||
def FrameBytes(self):
|
|
||||||
return (c_ubyte * self.bytes_per_frame)
|
|
||||||
|
|
||||||
|
|
||||||
# Modulate function which returns modulated data
|
|
||||||
def Demodulate(self):
|
|
||||||
|
|
||||||
|
|
||||||
nin = self.c_lib.freedv_nin(self.freedv)
|
|
||||||
#while (self.c_lib.freedv_nin(self.freedv) == nin):
|
|
||||||
#while sys.stdin.buffer != 0:
|
|
||||||
while True:
|
|
||||||
|
|
||||||
samples = self.c_lib.freedv_nin(self.freedv)*2 ### MIT DER *2 funktioniert das irgendwie recht zuverlässig bei mode 5! Bei Mode 12 auch
|
|
||||||
data_in = sys.stdin.buffer.read(samples)
|
|
||||||
|
|
||||||
|
|
||||||
#buffer = bytearray(len(self.ModulationIn()())*sizeof(c_short)) # create empty byte array
|
|
||||||
#buffer = bytearray(len(self.ModulationIn()())*self.n_max_modem_samples) # create empty byte array
|
|
||||||
buffer = bytearray(self.n_max_modem_samples*2) # N MAX SAMPLES * 2
|
|
||||||
buffer[:len(data_in)] = data_in # copy across what we have
|
|
||||||
|
|
||||||
self.ModulationIn()() #Create new ModulationIn Object
|
|
||||||
modulation = self.ModulationIn()# get an empty modulation array
|
|
||||||
modulation = modulation.from_buffer_copy(buffer) # copy buffer across and get a pointer to it.
|
|
||||||
bytes_out = self.FrameBytes()() # initilize a pointer to where bytes will be outputed
|
|
||||||
|
|
||||||
nbytes = self.c_lib.freedv_rawdatarx(self.freedv, bytes_out, data_in) # Demodulated data and get number of demodulated bytes
|
|
||||||
#self.nin = self.c_lib.freedv_nin(self.freedv)
|
|
||||||
|
|
||||||
|
|
||||||
# ------------- SOME DEBUGGING OUTPUT
|
|
||||||
#print("INPUT PARSER: " + str(samples))
|
|
||||||
#print("INPUT LENGTH: " + str(len(data_in)))
|
|
||||||
#print("BUFFER LENGTH: " + str(len(buffer)))
|
|
||||||
#print("MODULATION LENGTH: " + str(len(modulation)))
|
|
||||||
|
|
||||||
#sync_state = self.c_lib.freedv_get_sync(self.freedv)
|
|
||||||
#if sync_state > 0:
|
|
||||||
# print("SYNC")
|
|
||||||
#else:
|
|
||||||
# print("NO SYNC")
|
|
||||||
# -------------
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
# print data to terminal if nbytes == bytes_per_frame for selected mode
|
|
||||||
if nbytes == self.bytes_per_frame:
|
|
||||||
print(bytes(bytes_out))
|
|
||||||
self.c_lib.freedv_set_sync(self.freedv, 0)
|
|
||||||
|
|
||||||
|
|
||||||
#Stop loop until data input is empty
|
|
||||||
#if len(data_in) == 0:
|
|
||||||
# False
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
main()
|
|
|
@ -1,81 +0,0 @@
|
||||||
#!/usr/bin/env python3
|
|
||||||
# -*- coding: utf-8 -*-
|
|
||||||
"""
|
|
||||||
Created on Sun Dec 13 13:45:58 2020
|
|
||||||
@author: DJ2LS
|
|
||||||
"""
|
|
||||||
|
|
||||||
import ctypes
|
|
||||||
from ctypes import *
|
|
||||||
import pathlib
|
|
||||||
|
|
||||||
import binascii #required for string.to_bytes() function
|
|
||||||
import sys
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
def main():
|
|
||||||
|
|
||||||
modem = FreeDV() #Load FreeDV Class as "modem"
|
|
||||||
|
|
||||||
data = b'HALLO' #byte string which will be send
|
|
||||||
|
|
||||||
modem.Modulate(data) #Call Modulate function, which modulates data and prints it to the terminal
|
|
||||||
|
|
||||||
|
|
||||||
class FreeDV():
|
|
||||||
|
|
||||||
def __init__(self):
|
|
||||||
|
|
||||||
self.mode = 12 # define mode
|
|
||||||
|
|
||||||
libname = pathlib.Path().absolute() / "libcodec2.so"
|
|
||||||
self.c_lib = ctypes.CDLL(libname) # Load FreeDV shared libary
|
|
||||||
|
|
||||||
self.freedv = self.c_lib.freedv_open(self.mode) #Set FreeDV waveform ( 10,11,12 --> DATAC1-3 )
|
|
||||||
|
|
||||||
self.bytes_per_frame = int(self.c_lib.freedv_get_bits_per_modem_frame(self.freedv)/8) #get bytes per frame from selected waveform
|
|
||||||
self.payload_per_frame = self.bytes_per_frame -2 #get frame payload because of 2byte CRC16 checksum
|
|
||||||
self.n_tx_modem_samples = self.c_lib.freedv_get_n_tx_modem_samples(self.freedv)*2 #get n_tx_modem_samples which defines the size of the modulation object
|
|
||||||
|
|
||||||
# MODULATION-OUT OBJECT
|
|
||||||
def ModulationOut(self):
|
|
||||||
return (c_short * self.n_tx_modem_samples) ##
|
|
||||||
|
|
||||||
# Pointer for changing buffer data type
|
|
||||||
def FrameBytes(self):
|
|
||||||
return (c_ubyte * self.bytes_per_frame)
|
|
||||||
|
|
||||||
# Modulate function which returns modulated data
|
|
||||||
def Modulate(self,data_out):
|
|
||||||
|
|
||||||
mod_out = self.ModulationOut()() # new modulation object and get pointer to it
|
|
||||||
|
|
||||||
data_list = [data_out[i:i+self.payload_per_frame] for i in range(0, len(data_out), self.payload_per_frame)] # split incomming bytes to size of 30bytes, create a list and loop through it
|
|
||||||
data_list_length = len(data_list)
|
|
||||||
for i in range(data_list_length): # LOOP THROUGH DATA LIST
|
|
||||||
|
|
||||||
if self.mode < 10: # don't generate CRC16 for modes 0 - 9
|
|
||||||
|
|
||||||
buffer = bytearray(self.bytes_per_frame) # use this if no CRC16 checksum is required
|
|
||||||
buffer[:len(data_list[i])] = data_list[i] # set buffersize to length of data which will be send
|
|
||||||
|
|
||||||
if self.mode >= 10: #generate CRC16 for modes 10-12..
|
|
||||||
|
|
||||||
buffer = bytearray(self.payload_per_frame) # use this if CRC16 checksum is required ( DATA1-3)
|
|
||||||
buffer[:len(data_list[i])] = data_list[i] # set buffersize to length of data which will be send
|
|
||||||
|
|
||||||
crc = c_ushort(self.c_lib.freedv_gen_crc16(bytes(buffer), self.payload_per_frame)) # generate CRC16
|
|
||||||
crc = crc.value.to_bytes(2, byteorder='big') # convert crc to 2 byte hex string
|
|
||||||
buffer += crc # append crc16 to buffer
|
|
||||||
|
|
||||||
|
|
||||||
data = self.FrameBytes().from_buffer_copy(buffer) #change data format from bytearray to ctypes.u_byte and copy from buffer to data
|
|
||||||
|
|
||||||
self.c_lib.freedv_rawdatatx(self.freedv,mod_out,data) # modulate DATA and safe it into mod_out pointer
|
|
||||||
|
|
||||||
sys.stdout.buffer.write(mod_out) # print data to terminal for piping the output to other programs
|
|
||||||
sys.stdout.flush() # flushing stdout
|
|
||||||
|
|
||||||
|
|
||||||
main()
|
|
Binary file not shown.
Binary file not shown.
46
tnc.py
46
tnc.py
|
@ -1,37 +1,37 @@
|
||||||
#!/usr/bin/env python3
|
#!/usr/bin/env python3
|
||||||
# -*- coding: utf-8 -*-
|
# -*- coding: utf-8 -*-
|
||||||
|
"""
|
||||||
|
Created on Fri Dec 25 21:25:14 2020
|
||||||
|
|
||||||
|
@author: DJ2LS
|
||||||
|
"""
|
||||||
|
|
||||||
import socketserver
|
import socketserver
|
||||||
import threading
|
import threading
|
||||||
import logging
|
import logging
|
||||||
import crcengine
|
|
||||||
import ctypes
|
|
||||||
from ctypes import *
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
import static
|
import static
|
||||||
#from other import *
|
|
||||||
import other
|
|
||||||
import arq
|
import arq
|
||||||
|
|
||||||
#arq = arq.ARQ()
|
|
||||||
|
|
||||||
|
|
||||||
crc_algorithm = crcengine.new('crc16-ccitt-false') #load crc16 library
|
|
||||||
|
|
||||||
|
|
||||||
class TCPRequestHandler(socketserver.BaseRequestHandler):
|
class TCPRequestHandler(socketserver.BaseRequestHandler):
|
||||||
|
|
||||||
def handle(self):
|
def handle(self):
|
||||||
|
|
||||||
# self.request is the TCP socket connected to the client
|
self.data = bytes()
|
||||||
self.data = self.request.recv(1024).strip()
|
while True:
|
||||||
|
chunk = self.request.recv(8192)#.strip()
|
||||||
|
if chunk.endswith(b'\n'):
|
||||||
|
break
|
||||||
|
|
||||||
|
self.data += chunk
|
||||||
|
|
||||||
|
|
||||||
|
# self.request is the TCP socket connected to the client
|
||||||
|
#self.data = self.request.recv(1024).strip()
|
||||||
|
### self.data = self.request.recv(1000000).strip()
|
||||||
|
|
||||||
# interrupt listening loop "while true" by setting MODEM_RECEIVE to False
|
# interrupt listening loop "while true" by setting MODEM_RECEIVE to False
|
||||||
#if len(self.data) > 0:
|
#if len(self.data) > 0:
|
||||||
|
@ -46,6 +46,9 @@ class TCPRequestHandler(socketserver.BaseRequestHandler):
|
||||||
|
|
||||||
#if self.data == b'TEST':
|
#if self.data == b'TEST':
|
||||||
#logging.info("DER TEST KLAPPT! HIER KOMMT DER COMMAND PARSER HIN!")
|
#logging.info("DER TEST KLAPPT! HIER KOMMT DER COMMAND PARSER HIN!")
|
||||||
|
if self.data.startswith(b'SHOWBUFFERSIZE'):
|
||||||
|
self.request.sendall(bytes(static.RX_BUFFER[-1]))
|
||||||
|
print(static.RX_BUFFER_SIZE)
|
||||||
|
|
||||||
# BROADCAST PARSER -----------------------------------------------------------
|
# BROADCAST PARSER -----------------------------------------------------------
|
||||||
|
|
||||||
|
@ -53,22 +56,21 @@ class TCPRequestHandler(socketserver.BaseRequestHandler):
|
||||||
#import modem
|
#import modem
|
||||||
#modem = modem.RF()
|
#modem = modem.RF()
|
||||||
|
|
||||||
static.MODEM_RECEIVE = True ####### FALSE....
|
|
||||||
|
|
||||||
data = self.data.split(b'BC:')
|
data = self.data.split(b'BC:')
|
||||||
#modem.Transmit(data[1])
|
#modem.Transmit(data[1])
|
||||||
|
|
||||||
static.MODEM_RECEIVE = True
|
|
||||||
|
|
||||||
|
|
||||||
# SEND AN ARQ FRAME -----------------------------------------------------------
|
# SEND AN ARQ FRAME -----------------------------------------------------------
|
||||||
|
|
||||||
if self.data.startswith(b'ACK:'):
|
if self.data.startswith(b'ARQ:'):
|
||||||
static.MODEM_RECEIVE = True ############## FALSE
|
|
||||||
|
|
||||||
data = self.data.split(b'ACK:')
|
data = self.data.split(b'ARQ:')
|
||||||
data_out = data[1]
|
data_out = data[1]
|
||||||
|
|
||||||
arq.transmit(data_out)
|
#arq.transmit(data_out)
|
||||||
|
|
||||||
|
TRANSMIT_ARQ = threading.Thread(target=arq.transmit, args=[data_out], name="TRANSMIT_ARQ")
|
||||||
|
TRANSMIT_ARQ.start()
|
||||||
|
|
||||||
|
|
Loading…
Reference in a new issue