mirror of
https://github.com/DJ2LS/FreeDATA
synced 2024-05-14 08:04:33 +00:00
Remove excess trailing spaces.
This commit is contained in:
Paul Kronenwetter
parent
f2ef3f7ea2
commit
9753735c40
18
tnc/audio.py
18
tnc/audio.py
|
|
@ -9,11 +9,11 @@ atexit.register(sd._terminate)
|
|||
|
||||
def get_audio_devices():
|
||||
|
||||
|
||||
|
||||
|
||||
"""
|
||||
return list of input and output audio devices in own process to avoid crashes of portaudio on raspberry pi
|
||||
|
||||
|
||||
also uses a process data manager
|
||||
"""
|
||||
# we need to run this on windows for multiprocessing support
|
||||
|
|
@ -24,22 +24,22 @@ def get_audio_devices():
|
|||
# If we are not doing this at this early point, not all devices will be displayed
|
||||
sd._terminate()
|
||||
sd._initialize()
|
||||
|
||||
|
||||
with multiprocessing.Manager() as manager:
|
||||
|
||||
|
||||
proxy_input_devices = manager.list()
|
||||
proxy_output_devices = manager.list()
|
||||
#print(multiprocessing.get_start_method())
|
||||
p = multiprocessing.Process(target=fetch_audio_devices, args=(proxy_input_devices, proxy_output_devices))
|
||||
p.start()
|
||||
p.join()
|
||||
|
||||
return list(proxy_input_devices), list(proxy_output_devices)
|
||||
|
||||
return list(proxy_input_devices), list(proxy_output_devices)
|
||||
|
||||
def fetch_audio_devices(input_devices, output_devices):
|
||||
"""
|
||||
get audio devices from portaudio
|
||||
|
||||
|
||||
Args:
|
||||
input_devices: proxy variable for input devices
|
||||
output_devices: proxy variable for outout devices
|
||||
|
|
@ -47,7 +47,7 @@ def fetch_audio_devices(input_devices, output_devices):
|
|||
Returns:
|
||||
|
||||
"""
|
||||
|
||||
|
||||
devices = sd.query_devices(device=None, kind=None)
|
||||
index = 0
|
||||
for device in devices:
|
||||
|
|
@ -55,7 +55,7 @@ def fetch_audio_devices(input_devices, output_devices):
|
|||
# we need to do a try exception, beacuse for windows theres no audio device range
|
||||
try:
|
||||
name = device["name"]
|
||||
|
||||
|
||||
maxOutputChannels = device["max_output_channels"]
|
||||
maxInputChannels = device["max_input_channels"]
|
||||
|
||||
|
|
|
|||
|
|
@ -30,7 +30,7 @@ def freedv_get_mode_value_by_name(mode):
|
|||
"""
|
||||
get the codec2 mode by entering its string
|
||||
Args:
|
||||
mode:
|
||||
mode:
|
||||
|
||||
Returns: int
|
||||
|
||||
|
|
@ -42,14 +42,14 @@ def freedv_get_mode_name_by_value(mode):
|
|||
"""
|
||||
get the codec2 mode name as string
|
||||
Args:
|
||||
mode:
|
||||
mode:
|
||||
|
||||
Returns: string
|
||||
|
||||
"""
|
||||
return FREEDV_MODE(mode).name
|
||||
|
||||
|
||||
|
||||
|
||||
# check if we are running in a pyinstaller environment
|
||||
try:
|
||||
app_path = sys._MEIPASS
|
||||
|
|
@ -63,12 +63,12 @@ if sys.platform == 'linux':
|
|||
files.append('libcodec2.so')
|
||||
elif sys.platform == 'darwin':
|
||||
files = glob.glob('**/*libcodec2*.dylib',recursive=True)
|
||||
|
||||
|
||||
elif sys.platform == 'win32' or sys.platform == 'win64':
|
||||
files = glob.glob('**\*libcodec2*.dll',recursive=True)
|
||||
else:
|
||||
files = []
|
||||
|
||||
|
||||
|
||||
for file in files:
|
||||
try:
|
||||
|
|
@ -79,15 +79,15 @@ for file in files:
|
|||
structlog.get_logger("structlog").warning("[C2 ] Libcodec2 found but not loaded", path=file, e=e)
|
||||
|
||||
|
||||
# quit module if codec2 cant be loaded
|
||||
# quit module if codec2 cant be loaded
|
||||
if not 'api' in locals():
|
||||
structlog.get_logger("structlog").critical("[C2 ] Libcodec2 not loaded", path=file)
|
||||
os._exit(1)
|
||||
|
||||
|
||||
|
||||
|
||||
# ctypes function init
|
||||
|
||||
# ctypes function init
|
||||
|
||||
#api.freedv_set_tuning_range.restype = c_int
|
||||
#api.freedv_set_tuning_range.argype = [c_void_p, c_float, c_float]
|
||||
|
|
@ -121,24 +121,24 @@ api.freedv_get_n_max_modem_samples.restype = c_int
|
|||
|
||||
api.freedv_set_frames_per_burst.argtype = [c_void_p, c_int]
|
||||
api.freedv_set_frames_per_burst.restype = c_void_p
|
||||
|
||||
|
||||
api.freedv_get_rx_status.argtype = [c_void_p]
|
||||
api.freedv_get_rx_status.restype = c_int
|
||||
api.freedv_get_rx_status.restype = c_int
|
||||
|
||||
api.freedv_get_modem_stats.argtype = [c_void_p, c_void_p, c_void_p]
|
||||
api.freedv_get_modem_stats.restype = c_int
|
||||
|
||||
api.freedv_get_n_tx_postamble_modem_samples.argtype = [c_void_p]
|
||||
api.freedv_get_n_tx_postamble_modem_samples.restype = c_int
|
||||
api.freedv_get_n_tx_postamble_modem_samples.restype = c_int
|
||||
|
||||
api.freedv_get_n_tx_preamble_modem_samples.argtype = [c_void_p]
|
||||
api.freedv_get_n_tx_preamble_modem_samples.restype = c_int
|
||||
api.freedv_get_n_tx_preamble_modem_samples.restype = c_int
|
||||
|
||||
api.freedv_get_n_tx_modem_samples.argtype = [c_void_p]
|
||||
api.freedv_get_n_tx_modem_samples.restype = c_int
|
||||
api.freedv_get_n_tx_modem_samples.restype = c_int
|
||||
|
||||
api.freedv_get_n_max_modem_samples.argtype = [c_void_p]
|
||||
api.freedv_get_n_max_modem_samples.restype = c_int
|
||||
api.freedv_get_n_max_modem_samples.restype = c_int
|
||||
|
||||
api.FREEDV_FS_8000 = 8000
|
||||
api.FREEDV_MODE_DATAC1 = 10
|
||||
|
|
@ -152,13 +152,13 @@ api.FREEDV_MODE_FSK_LDPC = 9
|
|||
class ADVANCED(ctypes.Structure):
|
||||
""" """
|
||||
_fields_ = [
|
||||
("interleave_frames", ctypes.c_int),
|
||||
("interleave_frames", ctypes.c_int),
|
||||
("M", ctypes.c_int),
|
||||
("Rs", ctypes.c_int),
|
||||
("Fs", ctypes.c_int),
|
||||
("first_tone", ctypes.c_int),
|
||||
("tone_spacing", ctypes.c_int),
|
||||
("codename", ctypes.c_char_p),
|
||||
("first_tone", ctypes.c_int),
|
||||
("tone_spacing", ctypes.c_int),
|
||||
("codename", ctypes.c_char_p),
|
||||
]
|
||||
|
||||
'''
|
||||
|
|
@ -232,9 +232,9 @@ class MODEMSTATS(ctypes.Structure):
|
|||
("f_est", (ctypes.c_float * MODEM_STATS_MAX_F_EST)), # How many samples in the eye diagram
|
||||
("fft_buf", (ctypes.c_float * MODEM_STATS_NSPEC * 2)),
|
||||
]
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
# Return code flags for freedv_get_rx_status() function
|
||||
api.FREEDV_RX_TRIAL_SYNC = 0x1 # demodulator has trial sync
|
||||
api.FREEDV_RX_SYNC = 0x2 # demodulator has sync
|
||||
|
|
@ -264,7 +264,7 @@ api.rx_sync_flags_to_text = [
|
|||
class audio_buffer:
|
||||
"""
|
||||
thread safe audio buffer, which fits to needs of codec2
|
||||
|
||||
|
||||
made by David Rowe, VK5DGR
|
||||
"""
|
||||
# a buffer of int16 samples, using a fixed length numpy array self.buffer for storage
|
||||
|
|
@ -280,7 +280,7 @@ class audio_buffer:
|
|||
Push new data to buffer
|
||||
|
||||
Args:
|
||||
samples:
|
||||
samples:
|
||||
|
||||
Returns:
|
||||
|
||||
|
|
@ -295,7 +295,7 @@ class audio_buffer:
|
|||
"""
|
||||
get data from buffer in size of NIN
|
||||
Args:
|
||||
size:
|
||||
size:
|
||||
|
||||
Returns:
|
||||
|
||||
|
|
@ -306,7 +306,7 @@ class audio_buffer:
|
|||
self.buffer[:self.nbuffer] = self.buffer[size:size+self.nbuffer]
|
||||
assert self.nbuffer >= 0
|
||||
self.mutex.release()
|
||||
|
||||
|
||||
# resampler ---------------------------------------------------------
|
||||
|
||||
api.FDMDV_OS_48 = int(6) # oversampling rate
|
||||
|
|
@ -327,8 +327,8 @@ class resampler:
|
|||
structlog.get_logger("structlog").debug("[C2 ] create 48<->8 kHz resampler")
|
||||
self.filter_mem8 = np.zeros(self.MEM8, dtype=np.int16)
|
||||
self.filter_mem48 = np.zeros(self.MEM48)
|
||||
|
||||
|
||||
|
||||
|
||||
def resample48_to_8(self,in48):
|
||||
"""
|
||||
audio resampler integration from codec2
|
||||
|
|
|
|||
134
tnc/daemon.py
134
tnc/daemon.py
|
|
@ -37,8 +37,8 @@ def signal_handler(sig, frame):
|
|||
"""
|
||||
signal handler for closing the network socket on app exit
|
||||
Args:
|
||||
sig:
|
||||
frame:
|
||||
sig:
|
||||
frame:
|
||||
|
||||
Returns: system exit
|
||||
|
||||
|
|
@ -51,15 +51,15 @@ signal.signal(signal.SIGINT, signal_handler)
|
|||
|
||||
|
||||
class DAEMON():
|
||||
"""
|
||||
"""
|
||||
daemon class
|
||||
|
||||
|
||||
"""
|
||||
def __init__(self):
|
||||
|
||||
# load crc engine
|
||||
|
||||
# load crc engine
|
||||
self.crc_algorithm = crcengine.new('crc16-ccitt-false') # load crc8 library
|
||||
|
||||
|
||||
self.daemon_queue = sock.DAEMON_QUEUE
|
||||
update_audio_devices = threading.Thread(target=self.update_audio_devices, name="UPDATE_AUDIO_DEVICES", daemon=True)
|
||||
update_audio_devices.start()
|
||||
|
|
@ -69,23 +69,23 @@ class DAEMON():
|
|||
|
||||
worker = threading.Thread(target=self.worker, name="WORKER", daemon=True)
|
||||
worker.start()
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
def update_audio_devices(self):
|
||||
"""
|
||||
"""
|
||||
update audio devices and set to static
|
||||
"""
|
||||
while 1:
|
||||
try:
|
||||
if not static.TNCSTARTED:
|
||||
|
||||
|
||||
static.AUDIO_INPUT_DEVICES, static.AUDIO_OUTPUT_DEVICES = audio.get_audio_devices()
|
||||
except Exception as e:
|
||||
print(e)
|
||||
time.sleep(1)
|
||||
|
||||
|
||||
|
||||
|
||||
def update_serial_devices(self):
|
||||
"""
|
||||
update serial devices and set to static
|
||||
|
|
@ -96,26 +96,26 @@ class DAEMON():
|
|||
serial_devices = []
|
||||
ports = serial.tools.list_ports.comports()
|
||||
for port, desc, hwid in ports:
|
||||
|
||||
|
||||
# calculate hex of hwid if we have unique names
|
||||
crc_hwid = self.crc_algorithm(bytes(hwid, encoding='utf-8'))
|
||||
crc_hwid = crc_hwid.to_bytes(2, byteorder='big')
|
||||
crc_hwid = crc_hwid.hex()
|
||||
description = desc + ' [' + crc_hwid + ']'
|
||||
serial_devices.append({"port": str(port), "description": str(description) })
|
||||
|
||||
|
||||
static.SERIAL_DEVICES = serial_devices
|
||||
time.sleep(1)
|
||||
except Exception as e:
|
||||
print(e)
|
||||
|
||||
|
||||
def worker(self):
|
||||
"""
|
||||
a worker for the received commands
|
||||
"""
|
||||
while 1:
|
||||
try:
|
||||
|
||||
|
||||
data = self.daemon_queue.get()
|
||||
|
||||
# data[1] mycall
|
||||
|
|
@ -141,81 +141,81 @@ class DAEMON():
|
|||
# data[21] enable FSK
|
||||
# data[22] tx-audio-level
|
||||
# data[23] respond_to_cq
|
||||
|
||||
|
||||
if data[0] == 'STARTTNC':
|
||||
structlog.get_logger("structlog").warning("[DMN] Starting TNC", rig=data[5], port=data[6])
|
||||
|
||||
# list of parameters, necessary for running subprocess command as a list
|
||||
options = []
|
||||
|
||||
|
||||
options.append('--port')
|
||||
options.append(str(static.DAEMONPORT - 1))
|
||||
|
||||
|
||||
options.append('--mycall')
|
||||
options.append(data[1])
|
||||
|
||||
|
||||
options.append('--mygrid')
|
||||
options.append(data[2])
|
||||
|
||||
|
||||
options.append('--rx')
|
||||
options.append(data[3])
|
||||
|
||||
|
||||
options.append('--tx')
|
||||
options.append(data[4])
|
||||
|
||||
|
||||
# if radiocontrol != disabled
|
||||
# this should hopefully avoid a ton of problems if we are just running in
|
||||
# this should hopefully avoid a ton of problems if we are just running in
|
||||
# disabled mode
|
||||
|
||||
if data[13] != 'disabled':
|
||||
|
||||
|
||||
options.append('--devicename')
|
||||
options.append(data[5])
|
||||
|
||||
|
||||
options.append('--deviceport')
|
||||
options.append(data[6])
|
||||
|
||||
|
||||
options.append('--serialspeed')
|
||||
options.append(data[7])
|
||||
|
||||
|
||||
options.append('--pttprotocol')
|
||||
options.append(data[8])
|
||||
|
||||
|
||||
options.append('--pttport')
|
||||
options.append(data[9])
|
||||
|
||||
|
||||
options.append('--data_bits')
|
||||
options.append(data[10])
|
||||
|
||||
|
||||
options.append('--stop_bits')
|
||||
options.append(data[11])
|
||||
|
||||
|
||||
options.append('--handshake')
|
||||
options.append(data[12])
|
||||
|
||||
|
||||
options.append('--radiocontrol')
|
||||
options.append(data[13])
|
||||
|
||||
|
||||
if data[13] != 'rigctld':
|
||||
options.append('--rigctld_ip')
|
||||
options.append(data[14])
|
||||
|
||||
|
||||
options.append('--rigctld_port')
|
||||
options.append(data[15])
|
||||
|
||||
|
||||
if data[16] == 'True':
|
||||
options.append('--scatter')
|
||||
|
||||
|
||||
if data[17] == 'True':
|
||||
options.append('--fft')
|
||||
|
||||
if data[18] == 'True':
|
||||
options.append('--500hz')
|
||||
|
||||
|
||||
|
||||
options.append('--tuning_range_fmin')
|
||||
options.append(data[19])
|
||||
|
||||
|
||||
options.append('--tuning_range_fmax')
|
||||
options.append(data[20])
|
||||
|
||||
|
|
@ -224,13 +224,13 @@ class DAEMON():
|
|||
# options.append('--fsk')
|
||||
|
||||
options.append('--tx-audio-level')
|
||||
options.append(data[22])
|
||||
|
||||
if data[23] == 'True':
|
||||
options.append(data[22])
|
||||
|
||||
if data[23] == 'True':
|
||||
options.append('--qrv')
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
# try running tnc from binary, else run from source
|
||||
# this helps running the tnc in a developer environment
|
||||
try:
|
||||
|
|
@ -239,10 +239,10 @@ class DAEMON():
|
|||
command.append('./freedata-tnc')
|
||||
elif sys.platform == 'win32' or sys.platform == 'win64':
|
||||
command.append('freedata-tnc.exe')
|
||||
|
||||
|
||||
command += options
|
||||
p = subprocess.Popen(command)
|
||||
|
||||
|
||||
atexit.register(p.kill)
|
||||
|
||||
structlog.get_logger("structlog").info("[DMN] TNC started", path="binary")
|
||||
|
|
@ -252,7 +252,7 @@ class DAEMON():
|
|||
command.append('python3')
|
||||
elif sys.platform == 'win32' or sys.platform == 'win64':
|
||||
command.append('python')
|
||||
|
||||
|
||||
command.append('main.py')
|
||||
command += options
|
||||
p = subprocess.Popen(command)
|
||||
|
|
@ -269,7 +269,7 @@ class DAEMON():
|
|||
structlog.get_logger("structlog").warning("[DMN] Stopping TNC")
|
||||
#os.kill(static.TNCPROCESS, signal.SIGKILL)
|
||||
static.TNCSTARTED = False
|
||||
'''
|
||||
'''
|
||||
# data[1] devicename
|
||||
# data[2] deviceport
|
||||
# data[3] serialspeed
|
||||
|
|
@ -306,15 +306,15 @@ class DAEMON():
|
|||
import rigctld as rig
|
||||
else:
|
||||
import rigdummy as rig
|
||||
|
||||
|
||||
hamlib = rig.radio()
|
||||
hamlib.open_rig(devicename=devicename, deviceport=deviceport, hamlib_ptt_type=pttprotocol, serialspeed=serialspeed, pttport=pttport, data_bits=data_bits, stop_bits=stop_bits, handshake=handshake, rigctld_ip=rigctld_ip, rigctld_port = rigctld_port)
|
||||
|
||||
hamlib_version = rig.hamlib_version
|
||||
|
||||
hamlib.set_ptt(True)
|
||||
hamlib.set_ptt(True)
|
||||
pttstate = hamlib.get_ptt()
|
||||
|
||||
|
||||
if pttstate:
|
||||
structlog.get_logger("structlog").info("[DMN] Hamlib PTT", status = 'SUCCESS')
|
||||
response = {'command': 'test_hamlib', 'result': 'SUCCESS'}
|
||||
|
|
@ -324,13 +324,13 @@ class DAEMON():
|
|||
else:
|
||||
structlog.get_logger("structlog").error("[DMN] Hamlib PTT", status = 'FAILED')
|
||||
response = {'command': 'test_hamlib', 'result': 'FAILED'}
|
||||
|
||||
hamlib.set_ptt(False)
|
||||
|
||||
hamlib.set_ptt(False)
|
||||
hamlib.close_rig()
|
||||
|
||||
|
||||
jsondata = json.dumps(response)
|
||||
sock.SOCKET_QUEUE.put(jsondata)
|
||||
|
||||
|
||||
except Exception as e:
|
||||
print(e)
|
||||
|
||||
|
|
@ -343,27 +343,27 @@ if __name__ == '__main__':
|
|||
|
||||
# --------------------------------------------GET PARAMETER INPUTS
|
||||
PARSER = argparse.ArgumentParser(description='FreeDATA Daemon')
|
||||
PARSER.add_argument('--port', dest="socket_port",default=3001, help="Socket port in the range of 1024-65536", type=int)
|
||||
PARSER.add_argument('--port', dest="socket_port",default=3001, help="Socket port in the range of 1024-65536", type=int)
|
||||
ARGS = PARSER.parse_args()
|
||||
|
||||
|
||||
static.DAEMONPORT = ARGS.socket_port
|
||||
|
||||
|
||||
|
||||
try:
|
||||
if sys.platform == 'linux':
|
||||
logging_path = os.getenv("HOME") + '/.config/' + 'FreeDATA/' + 'daemon'
|
||||
|
||||
|
||||
if sys.platform == 'darwin':
|
||||
logging_path = os.getenv("HOME") + '/Library/' + 'Application Support/' + 'FreeDATA/' + 'daemon'
|
||||
|
||||
logging_path = os.getenv("HOME") + '/Library/' + 'Application Support/' + 'FreeDATA/' + 'daemon'
|
||||
|
||||
if sys.platform == 'win32' or sys.platform == 'win64':
|
||||
logging_path = os.getenv('APPDATA') + '/' + 'FreeDATA/' + 'daemon'
|
||||
|
||||
logging_path = os.getenv('APPDATA') + '/' + 'FreeDATA/' + 'daemon'
|
||||
|
||||
if not os.path.exists(logging_path):
|
||||
os.makedirs(logging_path)
|
||||
log_handler.setup_logging(logging_path)
|
||||
except:
|
||||
structlog.get_logger("structlog").error("[DMN] logger init error")
|
||||
structlog.get_logger("structlog").error("[DMN] logger init error")
|
||||
|
||||
try:
|
||||
structlog.get_logger("structlog").info("[DMN] Starting TCP/IP socket", port=static.DAEMONPORT)
|
||||
|
|
@ -379,7 +379,7 @@ if __name__ == '__main__':
|
|||
os._exit(1)
|
||||
daemon = DAEMON()
|
||||
|
||||
|
||||
|
||||
structlog.get_logger("structlog").info("[DMN] Starting FreeDATA Daemon", author="DJ2LS", year="2022", version=static.VERSION)
|
||||
while True:
|
||||
time.sleep(1)
|
||||
|
|
|
|||
File diff suppressed because it is too large
Load diff
|
|
@ -16,7 +16,7 @@ def wait(seconds):
|
|||
"""
|
||||
|
||||
Args:
|
||||
seconds:
|
||||
seconds:
|
||||
|
||||
Returns:
|
||||
|
||||
|
|
@ -26,18 +26,18 @@ def wait(seconds):
|
|||
while time.time() < timeout:
|
||||
time.sleep(0.01)
|
||||
return True
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
def get_crc_8(data):
|
||||
"""Author: DJ2LS
|
||||
|
||||
|
||||
Get the CRC8 of a byte string
|
||||
|
||||
|
||||
param: data = bytes()
|
||||
|
||||
Args:
|
||||
data:
|
||||
data:
|
||||
|
||||
Returns:
|
||||
|
||||
|
|
@ -50,13 +50,13 @@ def get_crc_8(data):
|
|||
|
||||
def get_crc_16(data):
|
||||
"""Author: DJ2LS
|
||||
|
||||
|
||||
Get the CRC16 of a byte string
|
||||
|
||||
|
||||
param: data = bytes()
|
||||
|
||||
Args:
|
||||
data:
|
||||
data:
|
||||
|
||||
Returns:
|
||||
|
||||
|
|
@ -68,35 +68,35 @@ def get_crc_16(data):
|
|||
|
||||
def get_crc_24(data):
|
||||
"""Author: DJ2LS
|
||||
|
||||
|
||||
Get the CRC24-OPENPGP of a byte string
|
||||
https://github.com/GardenTools/CrcEngine#examples
|
||||
|
||||
|
||||
param: data = bytes()
|
||||
|
||||
Args:
|
||||
data:
|
||||
data:
|
||||
|
||||
Returns:
|
||||
|
||||
"""
|
||||
crc_algorithm = crcengine.create(0x864cfb, 24, 0xb704ce, ref_in=False,
|
||||
ref_out=False, xor_out=0,
|
||||
name='crc-24-openpgp')
|
||||
name='crc-24-openpgp')
|
||||
crc_data = crc_algorithm(data)
|
||||
crc_data = crc_data.to_bytes(3, byteorder='big')
|
||||
return crc_data
|
||||
|
||||
|
||||
|
||||
|
||||
def get_crc_32(data):
|
||||
"""Author: DJ2LS
|
||||
|
||||
|
||||
Get the CRC32 of a byte string
|
||||
|
||||
|
||||
param: data = bytes()
|
||||
|
||||
Args:
|
||||
data:
|
||||
data:
|
||||
|
||||
Returns:
|
||||
|
||||
|
|
@ -111,12 +111,12 @@ def add_to_heard_stations(dxcallsign, dxgrid, datatype, snr, offset, frequency):
|
|||
"""
|
||||
|
||||
Args:
|
||||
dxcallsign:
|
||||
dxgrid:
|
||||
datatype:
|
||||
snr:
|
||||
offset:
|
||||
frequency:
|
||||
dxcallsign:
|
||||
dxgrid:
|
||||
datatype:
|
||||
snr:
|
||||
offset:
|
||||
frequency:
|
||||
|
||||
Returns:
|
||||
|
||||
|
|
@ -149,7 +149,7 @@ def callsign_to_bytes(callsign):
|
|||
"""
|
||||
|
||||
Args:
|
||||
callsign:
|
||||
callsign:
|
||||
|
||||
Returns:
|
||||
|
||||
|
|
@ -171,21 +171,21 @@ def callsign_to_bytes(callsign):
|
|||
#-13 Weather stations
|
||||
#-14 Truckers or generally full time drivers
|
||||
#-15 generic additional station, digi, mobile, wx, etc
|
||||
|
||||
|
||||
# try converting to bytestring if possible type string
|
||||
try:
|
||||
callsign = bytes(callsign, 'utf-8')
|
||||
try:
|
||||
callsign = bytes(callsign, 'utf-8')
|
||||
except:
|
||||
pass
|
||||
|
||||
# we need to do this step to reduce the needed paypload by the callsign ( stripping "-" out of the callsign )
|
||||
# we need to do this step to reduce the needed paypload by the callsign ( stripping "-" out of the callsign )
|
||||
callsign = callsign.split(b'-')
|
||||
try:
|
||||
ssid = int(callsign[1])
|
||||
except:
|
||||
ssid = 0
|
||||
|
||||
#callsign = callsign[0]
|
||||
|
||||
#callsign = callsign[0]
|
||||
#bytestring = bytearray(8)
|
||||
#bytestring[:len(callsign)] = callsign
|
||||
#bytestring[7:8] = bytes([ssid])
|
||||
|
|
@ -196,14 +196,14 @@ def callsign_to_bytes(callsign):
|
|||
return encode_call(callsign + ssid)
|
||||
|
||||
|
||||
#return bytes(bytestring)
|
||||
|
||||
#return bytes(bytestring)
|
||||
|
||||
def bytes_to_callsign(bytestring):
|
||||
"""
|
||||
Convert our callsign, received by a frame to a callsign in a human readable format
|
||||
|
||||
Args:
|
||||
bytestring:
|
||||
bytestring:
|
||||
|
||||
Returns:
|
||||
bytes
|
||||
|
|
@ -227,8 +227,8 @@ def bytes_to_callsign(bytestring):
|
|||
#-13 Weather stations
|
||||
#-14 Truckers or generally full time drivers
|
||||
#-15 generic additional station, digi, mobile, wx, etc
|
||||
|
||||
# we need to do this step to reduce the needed paypload by the callsign ( stripping "-" out of the callsign )
|
||||
|
||||
# we need to do this step to reduce the needed paypload by the callsign ( stripping "-" out of the callsign )
|
||||
'''
|
||||
callsign = bytes(bytestring[:7])
|
||||
callsign = callsign.rstrip(b'\x00')
|
||||
|
|
@ -238,8 +238,8 @@ def bytes_to_callsign(bytestring):
|
|||
callsign = callsign.decode('utf-8')
|
||||
callsign = callsign + str(ssid)
|
||||
callsign = callsign.encode('utf-8')
|
||||
|
||||
return bytes(callsign)
|
||||
|
||||
return bytes(callsign)
|
||||
'''
|
||||
decoded = decode_call(bytestring)
|
||||
callsign = decoded[:-1]
|
||||
|
|
@ -254,23 +254,23 @@ def check_callsign(callsign:bytes, crc_to_check:bytes):
|
|||
|
||||
Args:
|
||||
callsign: Callsign which we want to check
|
||||
crc_to_check: The CRC which we want the callsign to check against
|
||||
crc_to_check: The CRC which we want the callsign to check against
|
||||
|
||||
Returns:
|
||||
[True, Callsign + SSID]
|
||||
False
|
||||
"""
|
||||
|
||||
|
||||
print(callsign)
|
||||
try:
|
||||
callsign = callsign.split(b'-')
|
||||
callsign = callsign[0] # we want the callsign without SSID
|
||||
|
||||
|
||||
except:
|
||||
callsign = callsign
|
||||
|
||||
|
||||
for ssid in static.SSID_LIST:
|
||||
call_with_ssid = bytearray(callsign)
|
||||
call_with_ssid = bytearray(callsign)
|
||||
call_with_ssid.extend('-'.encode('utf-8'))
|
||||
call_with_ssid.extend(str(ssid).encode('utf-8'))
|
||||
|
||||
|
|
@ -279,7 +279,7 @@ def check_callsign(callsign:bytes, crc_to_check:bytes):
|
|||
if callsign_crc == crc_to_check:
|
||||
print(call_with_ssid)
|
||||
return [True, bytes(call_with_ssid)]
|
||||
|
||||
|
||||
return [False, ""]
|
||||
|
||||
|
||||
|
|
@ -327,7 +327,7 @@ def decode_grid(b_code_word:bytes):
|
|||
"""
|
||||
code_word = int.from_bytes(b_code_word, byteorder='big', signed=False)
|
||||
|
||||
grid = chr((code_word & 0b11111) + 65)
|
||||
grid = chr((code_word & 0b11111) + 65)
|
||||
code_word = code_word >> 5
|
||||
|
||||
grid = chr((code_word & 0b11111) + 65) + grid
|
||||
|
|
@ -359,7 +359,7 @@ def encode_call(call):
|
|||
out_code_word = int(0)
|
||||
|
||||
call = call.upper() # upper case to be save
|
||||
|
||||
|
||||
for x in call:
|
||||
int_val = ord(x)-48 # -48 reduce bits, begin with first number utf8 table
|
||||
out_code_word = out_code_word << 6 # shift left 6 bit, making space for a new char
|
||||
|
|
|
|||
|
|
@ -3,7 +3,7 @@ def setup_logging(filename):
|
|||
"""
|
||||
|
||||
Args:
|
||||
filename:
|
||||
filename:
|
||||
|
||||
Returns:
|
||||
|
||||
|
|
|
|||
92
tnc/main.py
92
tnc/main.py
|
|
@ -33,7 +33,7 @@ def signal_handler(sig, frame):
|
|||
a signal handler, which closes the network/socket when closing the application
|
||||
Args:
|
||||
sig: signal
|
||||
frame:
|
||||
frame:
|
||||
|
||||
Returns: system exit
|
||||
|
||||
|
|
@ -41,7 +41,7 @@ def signal_handler(sig, frame):
|
|||
print('Closing TNC...')
|
||||
sock.CLOSE_SIGNAL = True
|
||||
sys.exit(0)
|
||||
|
||||
|
||||
signal.signal(signal.SIGINT, signal_handler)
|
||||
|
||||
if __name__ == '__main__':
|
||||
|
|
@ -51,31 +51,31 @@ if __name__ == '__main__':
|
|||
PARSER = argparse.ArgumentParser(description='FreeDATA TNC')
|
||||
PARSER.add_argument('--mycall', dest="mycall", default="AA0AA", help="My callsign", type=str)
|
||||
PARSER.add_argument('--ssid', dest="ssid_list", nargs='*', default=[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15], help="SSID list we are responding to", type=str)
|
||||
PARSER.add_argument('--mygrid', dest="mygrid", default="JN12AA", help="My gridsquare", type=str)
|
||||
PARSER.add_argument('--mygrid', dest="mygrid", default="JN12AA", help="My gridsquare", type=str)
|
||||
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 in the range of 1024-65536", type=int)
|
||||
PARSER.add_argument('--deviceport', dest="hamlib_device_port", default="/dev/ttyUSB0", help="Hamlib device port", type=str)
|
||||
PARSER.add_argument('--devicename', dest="hamlib_device_name", default="2028", help="Hamlib device name", type=str)
|
||||
PARSER.add_argument('--serialspeed', dest="hamlib_serialspeed", choices=[1200, 2400, 4800, 9600, 19200, 38400, 57600, 115200], default=9600, help="Serialspeed", type=int)
|
||||
PARSER.add_argument('--pttprotocol', dest="hamlib_ptt_type", choices=['USB', 'RIG', 'RTS', 'DTR', 'CM108', 'MICDATA', 'PARALLEL', 'DTR-H', 'DTR-L', 'NONE'], default='USB', help="PTT Type", type=str)
|
||||
PARSER.add_argument('--pttport', dest="hamlib_ptt_port", default="/dev/ttyUSB0", help="PTT Port", type=str)
|
||||
PARSER.add_argument('--data_bits', dest="hamlib_data_bits", choices=[7, 8], default=8, help="Hamlib data bits", type=int)
|
||||
PARSER.add_argument('--stop_bits', dest="hamlib_stop_bits", choices=[1, 2], default=1, help="Hamlib stop bits", type=int)
|
||||
PARSER.add_argument('--handshake', dest="hamlib_handshake", default="None", help="Hamlib handshake", type=str)
|
||||
PARSER.add_argument('--radiocontrol', dest="hamlib_radiocontrol", choices=['disabled', 'direct', 'rigctl', 'rigctld'], default="disabled", help="Set how you want to control your radio")
|
||||
PARSER.add_argument('--rigctld_port', dest="rigctld_port", default=4532, type=int, help="Set rigctld port")
|
||||
PARSER.add_argument('--rigctld_ip', dest="rigctld_ip", default="localhost", help="Set rigctld ip")
|
||||
PARSER.add_argument('--scatter', dest="send_scatter", action="store_true", help="Send scatter information via network")
|
||||
PARSER.add_argument('--fft', dest="send_fft", action="store_true", help="Send fft information via network")
|
||||
PARSER.add_argument('--500hz', dest="low_bandwith_mode", action="store_true", help="Enable low bandwith mode ( 500 Hz only )")
|
||||
PARSER.add_argument('--fsk', dest="enable_fsk", action="store_true", help="Enable FSK mode for ping, beacon and CQ")
|
||||
PARSER.add_argument('--qrv', dest="enable_respond_to_cq", action="store_true", help="Enable sending a QRV frame if CQ received")
|
||||
PARSER.add_argument('--tuning_range_fmin', dest="tuning_range_fmin", choices=[-50.0, -100.0, -150.0, -200.0, -250.0], default=-50.0, help="Tuning range fmin", type=float)
|
||||
PARSER.add_argument('--devicename', dest="hamlib_device_name", default="2028", help="Hamlib device name", type=str)
|
||||
PARSER.add_argument('--serialspeed', dest="hamlib_serialspeed", choices=[1200, 2400, 4800, 9600, 19200, 38400, 57600, 115200], default=9600, help="Serialspeed", type=int)
|
||||
PARSER.add_argument('--pttprotocol', dest="hamlib_ptt_type", choices=['USB', 'RIG', 'RTS', 'DTR', 'CM108', 'MICDATA', 'PARALLEL', 'DTR-H', 'DTR-L', 'NONE'], default='USB', help="PTT Type", type=str)
|
||||
PARSER.add_argument('--pttport', dest="hamlib_ptt_port", default="/dev/ttyUSB0", help="PTT Port", type=str)
|
||||
PARSER.add_argument('--data_bits', dest="hamlib_data_bits", choices=[7, 8], default=8, help="Hamlib data bits", type=int)
|
||||
PARSER.add_argument('--stop_bits', dest="hamlib_stop_bits", choices=[1, 2], default=1, help="Hamlib stop bits", type=int)
|
||||
PARSER.add_argument('--handshake', dest="hamlib_handshake", default="None", help="Hamlib handshake", type=str)
|
||||
PARSER.add_argument('--radiocontrol', dest="hamlib_radiocontrol", choices=['disabled', 'direct', 'rigctl', 'rigctld'], default="disabled", help="Set how you want to control your radio")
|
||||
PARSER.add_argument('--rigctld_port', dest="rigctld_port", default=4532, type=int, help="Set rigctld port")
|
||||
PARSER.add_argument('--rigctld_ip', dest="rigctld_ip", default="localhost", help="Set rigctld ip")
|
||||
PARSER.add_argument('--scatter', dest="send_scatter", action="store_true", help="Send scatter information via network")
|
||||
PARSER.add_argument('--fft', dest="send_fft", action="store_true", help="Send fft information via network")
|
||||
PARSER.add_argument('--500hz', dest="low_bandwith_mode", action="store_true", help="Enable low bandwith mode ( 500 Hz only )")
|
||||
PARSER.add_argument('--fsk', dest="enable_fsk", action="store_true", help="Enable FSK mode for ping, beacon and CQ")
|
||||
PARSER.add_argument('--qrv', dest="enable_respond_to_cq", action="store_true", help="Enable sending a QRV frame if CQ received")
|
||||
PARSER.add_argument('--tuning_range_fmin', dest="tuning_range_fmin", choices=[-50.0, -100.0, -150.0, -200.0, -250.0], default=-50.0, help="Tuning range fmin", type=float)
|
||||
PARSER.add_argument('--tuning_range_fmax', dest="tuning_range_fmax", choices=[50.0, 100.0, 150.0, 200.0, 250.0], default=50.0, help="Tuning range fmax", type=float)
|
||||
PARSER.add_argument('--tx-audio-level', dest="tx_audio_level", default=50, help="Set the tx audio level at an early stage", type=int)
|
||||
|
||||
|
||||
PARSER.add_argument('--tx-audio-level', dest="tx_audio_level", default=50, help="Set the tx audio level at an early stage", type=int)
|
||||
|
||||
|
||||
ARGS = PARSER.parse_args()
|
||||
|
||||
# additional step for beeing sure our callsign is correctly
|
||||
|
|
@ -84,10 +84,10 @@ if __name__ == '__main__':
|
|||
mycallsign = bytes(ARGS.mycall.upper(), 'utf-8')
|
||||
mycallsign = helpers.callsign_to_bytes(mycallsign)
|
||||
static.MYCALLSIGN = helpers.bytes_to_callsign(mycallsign)
|
||||
static.MYCALLSIGN_CRC = helpers.get_crc_24(static.MYCALLSIGN)
|
||||
|
||||
static.MYCALLSIGN_CRC = helpers.get_crc_24(static.MYCALLSIGN)
|
||||
|
||||
static.SSID_LIST = ARGS.ssid_list
|
||||
|
||||
|
||||
static.MYGRID = bytes(ARGS.mygrid, 'utf-8')
|
||||
static.AUDIO_INPUT_DEVICE = ARGS.audio_input_device
|
||||
static.AUDIO_OUTPUT_DEVICE = ARGS.audio_output_device
|
||||
|
|
@ -105,40 +105,40 @@ if __name__ == '__main__':
|
|||
static.HAMLIB_RGICTLD_PORT = str(ARGS.rigctld_port)
|
||||
static.ENABLE_SCATTER = ARGS.send_scatter
|
||||
static.ENABLE_FFT = ARGS.send_fft
|
||||
static.ENABLE_FSK = ARGS.enable_fsk
|
||||
static.LOW_BANDWITH_MODE = ARGS.low_bandwith_mode
|
||||
static.TUNING_RANGE_FMIN = ARGS.tuning_range_fmin
|
||||
static.TUNING_RANGE_FMAX = ARGS.tuning_range_fmax
|
||||
static.TX_AUDIO_LEVEL = ARGS.tx_audio_level
|
||||
static.RESPOND_TO_CQ = ARGS.enable_respond_to_cq
|
||||
|
||||
static.ENABLE_FSK = ARGS.enable_fsk
|
||||
static.LOW_BANDWITH_MODE = ARGS.low_bandwith_mode
|
||||
static.TUNING_RANGE_FMIN = ARGS.tuning_range_fmin
|
||||
static.TUNING_RANGE_FMAX = ARGS.tuning_range_fmax
|
||||
static.TX_AUDIO_LEVEL = ARGS.tx_audio_level
|
||||
static.RESPOND_TO_CQ = ARGS.enable_respond_to_cq
|
||||
|
||||
# we need to wait until we got all parameters from argparse first before we can load the other modules
|
||||
import sock
|
||||
|
||||
# config logging
|
||||
try:
|
||||
import sock
|
||||
|
||||
# config logging
|
||||
try:
|
||||
if sys.platform == 'linux':
|
||||
logging_path = os.getenv("HOME") + '/.config/' + 'FreeDATA/' + 'tnc'
|
||||
|
||||
|
||||
if sys.platform == 'darwin':
|
||||
logging_path = os.getenv("HOME") + '/Library/' + 'Application Support/' + 'FreeDATA/' + 'tnc'
|
||||
|
||||
logging_path = os.getenv("HOME") + '/Library/' + 'Application Support/' + 'FreeDATA/' + 'tnc'
|
||||
|
||||
if sys.platform == 'win32' or sys.platform == 'win64':
|
||||
logging_path = os.getenv('APPDATA') + '/' + 'FreeDATA/' + 'tnc'
|
||||
|
||||
logging_path = os.getenv('APPDATA') + '/' + 'FreeDATA/' + 'tnc'
|
||||
|
||||
if not os.path.exists(logging_path):
|
||||
os.makedirs(logging_path)
|
||||
log_handler.setup_logging(logging_path)
|
||||
except:
|
||||
structlog.get_logger("structlog").error("[DMN] logger init error")
|
||||
structlog.get_logger("structlog").error("[DMN] logger init error")
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
structlog.get_logger("structlog").info("[TNC] Starting FreeDATA", author="DJ2LS", year="2022", version=static.VERSION)
|
||||
|
||||
|
||||
# start data handler
|
||||
data_handler.DATA()
|
||||
|
||||
|
||||
# start modem
|
||||
modem = modem.RF()
|
||||
|
||||
|
|
|
|||
413
tnc/modem.py
413
tnc/modem.py
|
|
@ -45,10 +45,10 @@ class RF():
|
|||
""" """
|
||||
|
||||
def __init__(self):
|
||||
|
||||
|
||||
self.sampler_avg = 0
|
||||
self.buffer_avg = 0
|
||||
|
||||
|
||||
|
||||
self.AUDIO_SAMPLE_RATE_RX = 48000
|
||||
self.AUDIO_SAMPLE_RATE_TX = 48000
|
||||
|
|
@ -57,15 +57,15 @@ class RF():
|
|||
self.AUDIO_FRAMES_PER_BUFFER_TX = 2400*2 #8192 Lets to some tests with very small chunks for TX
|
||||
self.AUDIO_CHUNKS = 48 #8 * (self.AUDIO_SAMPLE_RATE_RX/self.MODEM_SAMPLE_RATE) #48
|
||||
self.AUDIO_CHANNELS = 1
|
||||
|
||||
|
||||
# locking state for mod out so buffer will be filled before we can use it
|
||||
# https://github.com/DJ2LS/FreeDATA/issues/127
|
||||
# https://github.com/DJ2LS/FreeDATA/issues/99
|
||||
self.mod_out_locked = True
|
||||
|
||||
|
||||
# make sure our resampler will work
|
||||
assert (self.AUDIO_SAMPLE_RATE_RX / self.MODEM_SAMPLE_RATE) == codec2.api.FDMDV_OS_48
|
||||
|
||||
|
||||
# small hack for initializing codec2 via codec2.py module
|
||||
# TODO: we need to change the entire modem module to integrate codec2 module
|
||||
self.c_lib = codec2.api
|
||||
|
|
@ -76,11 +76,11 @@ class RF():
|
|||
|
||||
# init FIFO queue to store modulation out in
|
||||
self.modoutqueue = deque()
|
||||
|
||||
|
||||
# define fft_data buffer
|
||||
self.fft_data = bytes()
|
||||
|
||||
# open codec2 instance
|
||||
|
||||
# open codec2 instance
|
||||
self.datac0_freedv = cast(codec2.api.freedv_open(codec2.api.FREEDV_MODE_DATAC0), c_void_p)
|
||||
self.c_lib.freedv_set_tuning_range(self.datac0_freedv, c_float(static.TUNING_RANGE_FMIN), c_float(static.TUNING_RANGE_FMAX))
|
||||
self.datac0_bytes_per_frame = int(codec2.api.freedv_get_bits_per_modem_frame(self.datac0_freedv)/8)
|
||||
|
|
@ -120,70 +120,54 @@ class RF():
|
|||
#codec2.api.freedv_set_frames_per_burst(self.fsk_ldpc_freedv_0,1)
|
||||
self.fsk_ldpc_buffer_1 = codec2.audio_buffer(self.AUDIO_FRAMES_PER_BUFFER_RX)
|
||||
|
||||
# initial nin values
|
||||
self.datac0_nin = codec2.api.freedv_nin(self.datac0_freedv)
|
||||
self.datac1_nin = codec2.api.freedv_nin(self.datac1_freedv)
|
||||
# initial nin values
|
||||
self.datac0_nin = codec2.api.freedv_nin(self.datac0_freedv)
|
||||
self.datac1_nin = codec2.api.freedv_nin(self.datac1_freedv)
|
||||
self.datac3_nin = codec2.api.freedv_nin(self.datac3_freedv)
|
||||
self.fsk_ldpc_nin_0 = codec2.api.freedv_nin(self.fsk_ldpc_freedv_0)
|
||||
self.fsk_ldpc_nin_1 = codec2.api.freedv_nin(self.fsk_ldpc_freedv_1)
|
||||
self.fsk_ldpc_nin_0 = codec2.api.freedv_nin(self.fsk_ldpc_freedv_0)
|
||||
self.fsk_ldpc_nin_1 = codec2.api.freedv_nin(self.fsk_ldpc_freedv_1)
|
||||
# --------------------------------------------CREATE PYAUDIO INSTANCE
|
||||
|
||||
'''
|
||||
try:
|
||||
# we need to "try" this, because sometimes libasound.so isn't in the default place
|
||||
# try to supress error messages
|
||||
with audio.noalsaerr(): # https://github.com/DJ2LS/FreeDATA/issues/22
|
||||
self.p = audio.pyaudio.PyAudio()
|
||||
# else do it the default way
|
||||
except:
|
||||
self.p = audio.pyaudio.PyAudio()
|
||||
atexit.register(self.p.terminate)
|
||||
|
||||
# --------------------------------------------OPEN RX AUDIO CHANNEL
|
||||
# optional auto selection of loopback device if using in testmode
|
||||
if static.AUDIO_INPUT_DEVICE == -2:
|
||||
loopback_list = []
|
||||
for dev in range(0,self.p.get_device_count()):
|
||||
if 'Loopback: PCM' in self.p.get_device_info_by_index(dev)["name"]:
|
||||
loopback_list.append(dev)
|
||||
if len(loopback_list) >= 2:
|
||||
static.AUDIO_INPUT_DEVICE = loopback_list[0] #0 = RX
|
||||
static.AUDIO_OUTPUT_DEVICE = loopback_list[1] #1 = TX
|
||||
print(f"loopback_list rx: {loopback_list}", file=sys.stderr)
|
||||
|
||||
'''
|
||||
try:
|
||||
'''
|
||||
self.audio_stream = self.p.open(format=audio.pyaudio.paInt16,
|
||||
channels=self.AUDIO_CHANNELS,
|
||||
rate=self.AUDIO_SAMPLE_RATE_RX,
|
||||
frames_per_buffer=self.AUDIO_FRAMES_PER_BUFFER_RX,
|
||||
input=True,
|
||||
output=True,
|
||||
input_device_index=static.AUDIO_INPUT_DEVICE,
|
||||
output_device_index=static.AUDIO_OUTPUT_DEVICE,
|
||||
stream_callback=self.audio_callback
|
||||
)
|
||||
'''
|
||||
|
||||
self.stream = sd.RawStream(channels=1, dtype='int16', callback=self.callback, device=(static.AUDIO_INPUT_DEVICE, static.AUDIO_OUTPUT_DEVICE), samplerate = self.AUDIO_SAMPLE_RATE_RX, blocksize=4800)
|
||||
|
||||
|
||||
atexit.register(self.stream.stop)
|
||||
|
||||
structlog.get_logger("structlog").info("opened audio devices")
|
||||
|
||||
except Exception as e:
|
||||
structlog.get_logger("structlog").error("can't open audio device. Exit", e=e)
|
||||
os._exit(1)
|
||||
|
||||
try:
|
||||
structlog.get_logger("structlog").debug("[TNC] starting pyaudio callback")
|
||||
#self.audio_stream.start_stream()
|
||||
self.stream.start()
|
||||
if not TESTMODE:
|
||||
try:
|
||||
|
||||
self.stream = sd.RawStream(channels=1, dtype='int16', callback=self.callback, device=(static.AUDIO_INPUT_DEVICE, static.AUDIO_OUTPUT_DEVICE), samplerate = self.AUDIO_SAMPLE_RATE_RX, blocksize=4800)
|
||||
atexit.register(self.stream.stop)
|
||||
structlog.get_logger("structlog").info("opened audio devices")
|
||||
|
||||
except Exception as e:
|
||||
structlog.get_logger("structlog").error("can't open audio device. Exit", e=e)
|
||||
os._exit(1)
|
||||
|
||||
try:
|
||||
structlog.get_logger("structlog").debug("[TNC] starting pyaudio callback")
|
||||
#self.audio_stream.start_stream()
|
||||
self.stream.start()
|
||||
|
||||
except Exception as e:
|
||||
structlog.get_logger("structlog").error("[TNC] starting pyaudio callback failed", e=e)
|
||||
|
||||
else:
|
||||
|
||||
# create a stream object for simulating audio stream
|
||||
class Object(object):
|
||||
pass
|
||||
self.stream = Object()
|
||||
self.stream.active = True
|
||||
|
||||
# create mkfifo buffer
|
||||
try:
|
||||
|
||||
os.mkfifo(RXCHANNEL)
|
||||
os.mkfifo(TXCHANNEL)
|
||||
except:
|
||||
pass
|
||||
|
||||
mkfifo_write_callback_thread = threading.Thread(target=self.mkfifo_write_callback, name="MKFIFO WRITE CALLBACK THREAD",daemon=True)
|
||||
mkfifo_write_callback_thread.start()
|
||||
|
||||
mkfifo_read_callback_thread = threading.Thread(target=self.mkfifo_read_callback, name="MKFIFO READ CALLBACK THREAD",daemon=True)
|
||||
mkfifo_read_callback_thread.start()
|
||||
|
||||
except Exception as e:
|
||||
structlog.get_logger("structlog").error("[TNC] starting pyaudio callback failed", e=e)
|
||||
|
||||
# --------------------------------------------INIT AND OPEN HAMLIB
|
||||
# check how we want to control the radio
|
||||
|
|
@ -196,9 +180,9 @@ class RF():
|
|||
elif static.HAMLIB_RADIOCONTROL == 'disabled':
|
||||
import rigdummy as rig
|
||||
else:
|
||||
import rigdummy as rig
|
||||
import rigdummy as rig
|
||||
|
||||
|
||||
|
||||
self.hamlib = rig.radio()
|
||||
self.hamlib.open_rig(devicename=static.HAMLIB_DEVICE_NAME, deviceport=static.HAMLIB_DEVICE_PORT, hamlib_ptt_type=static.HAMLIB_PTT_TYPE, serialspeed=static.HAMLIB_SERIAL_SPEED, pttport=static.HAMLIB_PTT_PORT, data_bits=static.HAMLIB_DATA_BITS, stop_bits=static.HAMLIB_STOP_BITS, handshake=static.HAMLIB_HANDSHAKE, rigctld_ip = static.HAMLIB_RGICTLD_IP, rigctld_port = static.HAMLIB_RGICTLD_PORT)
|
||||
|
||||
|
|
@ -206,52 +190,101 @@ class RF():
|
|||
if static.ENABLE_FFT:
|
||||
fft_thread = threading.Thread(target=self.calculate_fft, name="FFT_THREAD" ,daemon=True)
|
||||
fft_thread.start()
|
||||
|
||||
|
||||
audio_thread_datac0 = threading.Thread(target=self.audio_datac0, name="AUDIO_THREAD DATAC0",daemon=True)
|
||||
audio_thread_datac0.start()
|
||||
|
||||
audio_thread_datac1 = threading.Thread(target=self.audio_datac1, name="AUDIO_THREAD DATAC1",daemon=True)
|
||||
audio_thread_datac1.start()
|
||||
|
||||
|
||||
audio_thread_datac3 = threading.Thread(target=self.audio_datac3, name="AUDIO_THREAD DATAC3",daemon=True)
|
||||
audio_thread_datac3.start()
|
||||
|
||||
|
||||
if static.ENABLE_FSK:
|
||||
audio_thread_fsk_ldpc0 = threading.Thread(target=self.audio_fsk_ldpc_0, name="AUDIO_THREAD FSK LDPC0",daemon=True)
|
||||
audio_thread_fsk_ldpc0.start()
|
||||
|
||||
audio_thread_fsk_ldpc1 = threading.Thread(target=self.audio_fsk_ldpc_1, name="AUDIO_THREAD FSK LDPC1",daemon=True)
|
||||
audio_thread_fsk_ldpc1.start()
|
||||
|
||||
|
||||
hamlib_thread = threading.Thread(target=self.update_rig_data, name="HAMLIB_THREAD",daemon=True)
|
||||
hamlib_thread.start()
|
||||
|
||||
|
||||
worker_received = threading.Thread(target=self.worker_received, name="WORKER_THREAD",daemon=True)
|
||||
worker_received.start()
|
||||
|
||||
|
||||
worker_transmit = threading.Thread(target=self.worker_transmit, name="WORKER_THREAD",daemon=True)
|
||||
worker_transmit.start()
|
||||
|
||||
|
||||
# --------------------------------------------------------------------------------------------------------
|
||||
def mkfifo_read_callback(self):
|
||||
while 1:
|
||||
|
||||
time.sleep(0.01)
|
||||
# -----read
|
||||
data_in48k = bytes()
|
||||
with open(RXCHANNEL, 'rb') as fifo:
|
||||
for line in fifo:
|
||||
|
||||
data_in48k += line
|
||||
|
||||
while len(data_in48k) >= 48:
|
||||
x = np.frombuffer(data_in48k[:48], dtype=np.int16)
|
||||
x = self.resampler.resample48_to_8(x)
|
||||
data_in48k = data_in48k[48:]
|
||||
|
||||
length_x = len(x)
|
||||
if not self.datac0_buffer.nbuffer+length_x > self.datac0_buffer.size:
|
||||
self.datac0_buffer.push(x)
|
||||
|
||||
if not self.datac1_buffer.nbuffer+length_x > self.datac1_buffer.size:
|
||||
if RECEIVE_DATAC1:
|
||||
self.datac1_buffer.push(x)
|
||||
|
||||
if not self.datac3_buffer.nbuffer+length_x > self.datac3_buffer.size:
|
||||
if RECEIVE_DATAC3:
|
||||
self.datac3_buffer.push(x)
|
||||
|
||||
|
||||
|
||||
def mkfifo_write_callback(self):
|
||||
while 1:
|
||||
time.sleep(0.01)
|
||||
|
||||
# -----write
|
||||
if len(self.modoutqueue) <= 0 or self.mod_out_locked:
|
||||
#data_out48k = np.zeros(self.AUDIO_FRAMES_PER_BUFFER_RX, dtype=np.int16)
|
||||
pass
|
||||
|
||||
else:
|
||||
data_out48k = self.modoutqueue.popleft()
|
||||
#print(len(data_out48k))
|
||||
|
||||
fifo_write = open(TXCHANNEL, 'wb')
|
||||
fifo_write.write(data_out48k)
|
||||
fifo_write.flush()
|
||||
|
||||
|
||||
# --------------------------------------------------------------------------------------------------------
|
||||
#def audio_callback(self, data_in48k, frame_count, time_info, status):
|
||||
def callback(self, data_in48k, outdata, frames, time, status):
|
||||
"""
|
||||
|
||||
Args:
|
||||
data_in48k:
|
||||
frame_count:
|
||||
time_info:
|
||||
status:
|
||||
data_in48k:
|
||||
frame_count:
|
||||
time_info:
|
||||
status:
|
||||
|
||||
Returns:
|
||||
|
||||
"""
|
||||
|
||||
"""
|
||||
|
||||
x = np.frombuffer(data_in48k, dtype=np.int16)
|
||||
x = self.resampler.resample48_to_8(x)
|
||||
x = self.resampler.resample48_to_8(x)
|
||||
|
||||
length_x = len(x)
|
||||
|
||||
|
||||
# avoid decoding when transmitting to reduce CPU
|
||||
if not static.TRANSMITTING:
|
||||
# avoid buffer overflow by filling only if buffer not full
|
||||
|
|
@ -259,14 +292,14 @@ class RF():
|
|||
self.datac0_buffer.push(x)
|
||||
else:
|
||||
static.BUFFER_OVERFLOW_COUNTER[0] += 1
|
||||
|
||||
|
||||
# avoid buffer overflow by filling only if buffer not full and selected datachannel mode
|
||||
if not self.datac1_buffer.nbuffer+length_x > self.datac1_buffer.size:
|
||||
if RECEIVE_DATAC1:
|
||||
self.datac1_buffer.push(x)
|
||||
else:
|
||||
static.BUFFER_OVERFLOW_COUNTER[1] += 1
|
||||
|
||||
|
||||
# avoid buffer overflow by filling only if buffer not full and selected datachannel mode
|
||||
if not self.datac3_buffer.nbuffer+length_x > self.datac3_buffer.size:
|
||||
if RECEIVE_DATAC3:
|
||||
|
|
@ -276,29 +309,29 @@ class RF():
|
|||
|
||||
# avoid buffer overflow by filling only if buffer not full and selected datachannel mode
|
||||
if not self.fsk_ldpc_buffer_0.nbuffer+length_x > self.fsk_ldpc_buffer_0.size:
|
||||
if static.ENABLE_FSK:
|
||||
if static.ENABLE_FSK:
|
||||
self.fsk_ldpc_buffer_0.push(x)
|
||||
else:
|
||||
static.BUFFER_OVERFLOW_COUNTER[3] += 1
|
||||
|
||||
# avoid buffer overflow by filling only if buffer not full and selected datachannel mode
|
||||
if not self.fsk_ldpc_buffer_1.nbuffer+length_x > self.fsk_ldpc_buffer_1.size:
|
||||
if RECEIVE_FSK_LDPC_1 and static.ENABLE_FSK:
|
||||
if RECEIVE_FSK_LDPC_1 and static.ENABLE_FSK:
|
||||
self.fsk_ldpc_buffer_1.push(x)
|
||||
else:
|
||||
static.BUFFER_OVERFLOW_COUNTER[4] += 1
|
||||
|
||||
if len(self.modoutqueue) <= 0 or self.mod_out_locked:
|
||||
|
||||
if len(self.modoutqueue) <= 0 or self.mod_out_locked:
|
||||
#if not self.modoutqueue or self.mod_out_locked:
|
||||
data_out48k = np.zeros(frames, dtype=np.int16)
|
||||
self.fft_data = x
|
||||
|
||||
|
||||
else:
|
||||
data_out48k = self.modoutqueue.popleft()
|
||||
self.fft_data = data_out48k
|
||||
|
||||
|
||||
try:
|
||||
outdata[:] = data_out48k[:frames]
|
||||
outdata[:] = data_out48k[:frames]
|
||||
except Exception as e:
|
||||
print(e)
|
||||
|
||||
|
|
@ -306,14 +339,14 @@ class RF():
|
|||
|
||||
# --------------------------------------------------------------------------------------------------------
|
||||
|
||||
def transmit(self, mode, repeats, repeat_delay, frames):
|
||||
def transmit(self, mode, repeats, repeat_delay, frames):
|
||||
"""
|
||||
|
||||
Args:
|
||||
mode:
|
||||
repeats:
|
||||
repeat_delay:
|
||||
frames:
|
||||
mode:
|
||||
repeats:
|
||||
repeat_delay:
|
||||
frames:
|
||||
|
||||
Returns:
|
||||
|
||||
|
|
@ -324,19 +357,19 @@ class RF():
|
|||
jsondata = {"ptt":"True"}
|
||||
data_out = json.dumps(jsondata)
|
||||
sock.SOCKET_QUEUE.put(data_out)
|
||||
|
||||
|
||||
# open codec2 instance
|
||||
|
||||
|
||||
# open codec2 instance
|
||||
self.MODE = mode
|
||||
if self.MODE == 'FSK_LDPC_0' or self.MODE == 200:
|
||||
freedv = cast(codec2.api.freedv_open_advanced(codec2.api.FREEDV_MODE_FSK_LDPC, ctypes.byref(codec2.api.FREEDV_MODE_FSK_LDPC_0_ADV)), c_void_p)
|
||||
elif self.MODE == 'FSK_LDPC_1' or self.MODE == 201:
|
||||
freedv = cast(codec2.api.freedv_open_advanced(codec2.api.FREEDV_MODE_FSK_LDPC, ctypes.byref(codec2.api.FREEDV_MODE_FSK_LDPC_1_ADV)), c_void_p)
|
||||
|
||||
freedv = cast(codec2.api.freedv_open_advanced(codec2.api.FREEDV_MODE_FSK_LDPC, ctypes.byref(codec2.api.FREEDV_MODE_FSK_LDPC_1_ADV)), c_void_p)
|
||||
|
||||
else:
|
||||
freedv = cast(codec2.api.freedv_open(self.MODE), c_void_p)
|
||||
|
||||
|
||||
|
||||
# get number of bytes per frame for mode
|
||||
bytes_per_frame = int(codec2.api.freedv_get_bits_per_modem_frame(freedv)/8)
|
||||
payload_bytes_per_frame = bytes_per_frame -2
|
||||
|
|
@ -356,12 +389,12 @@ class RF():
|
|||
data_delay_mseconds = 0 #miliseconds
|
||||
data_delay = int(self.MODEM_SAMPLE_RATE*(data_delay_mseconds/1000))
|
||||
mod_out_silence = create_string_buffer(data_delay*2)
|
||||
txbuffer = bytes(mod_out_silence)
|
||||
|
||||
txbuffer = bytes(mod_out_silence)
|
||||
|
||||
structlog.get_logger("structlog").debug("TRANSMIT", mode=self.MODE, payload=payload_bytes_per_frame)
|
||||
|
||||
|
||||
for i in range(0,repeats):
|
||||
# codec2 fsk preamble may be broken - at least it sounds like that so we are disabling it for testing
|
||||
# codec2 fsk preamble may be broken - at least it sounds like that so we are disabling it for testing
|
||||
if not self.MODE == 'FSK_LDPC_0' or self.MODE == 200 or self.MODE == 'FSK_LDPC_1' or self.MODE == 201:
|
||||
# write preamble to txbuffer
|
||||
codec2.api.freedv_rawdatapreambletx(freedv, mod_out_preamble)
|
||||
|
|
@ -372,28 +405,28 @@ class RF():
|
|||
buffer = bytearray(payload_bytes_per_frame) # use this if CRC16 checksum is required ( DATA1-3)
|
||||
buffer[:len(frames[n])] = frames[n] # set buffersize to length of data which will be send
|
||||
|
||||
# create crc for data frame - we are using the crc function shipped with codec2 to avoid
|
||||
# create crc for data frame - we are using the crc function shipped with codec2 to avoid
|
||||
# crc algorithm incompatibilities
|
||||
crc = ctypes.c_ushort(codec2.api.freedv_gen_crc16(bytes(buffer), payload_bytes_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
|
||||
|
||||
buffer += crc # append crc16 to buffer
|
||||
|
||||
data = (ctypes.c_ubyte * bytes_per_frame).from_buffer_copy(buffer)
|
||||
codec2.api.freedv_rawdatatx(freedv,mod_out,data) # modulate DATA and save it into mod_out pointer
|
||||
codec2.api.freedv_rawdatatx(freedv,mod_out,data) # modulate DATA and save it into mod_out pointer
|
||||
txbuffer += bytes(mod_out)
|
||||
|
||||
|
||||
# codec2 fsk preamble may be broken - at least it sounds like that so we are disabling it for testing
|
||||
|
||||
|
||||
# codec2 fsk preamble may be broken - at least it sounds like that so we are disabling it for testing
|
||||
if not self.MODE == 'FSK_LDPC_0' or self.MODE == 200 or self.MODE == 'FSK_LDPC_1' or self.MODE == 201:
|
||||
# write preamble to txbuffer
|
||||
codec2.api.freedv_rawdatapostambletx(freedv, mod_out_postamble)
|
||||
txbuffer += bytes(mod_out_postamble)
|
||||
# append postamble to txbuffer
|
||||
# append postamble to txbuffer
|
||||
# add delay to end of frames
|
||||
samples_delay = int(self.MODEM_SAMPLE_RATE*(repeat_delay/1000))
|
||||
mod_out_silence = create_string_buffer(samples_delay*2)
|
||||
txbuffer += bytes(mod_out_silence)
|
||||
|
||||
|
||||
# resample up to 48k (resampler works on np.int16)
|
||||
x = np.frombuffer(txbuffer, dtype=np.int16)
|
||||
x = set_audio_volume(x, static.TX_AUDIO_LEVEL)
|
||||
|
|
@ -403,11 +436,11 @@ class RF():
|
|||
# explicitly lock our usage of mod_out_queue if needed
|
||||
# deaktivated for testing purposes
|
||||
self.mod_out_locked = False
|
||||
|
||||
|
||||
|
||||
|
||||
# -------------------------------
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
chunk_length = self.AUDIO_FRAMES_PER_BUFFER_TX #4800
|
||||
|
|
@ -422,35 +455,35 @@ class RF():
|
|||
#structlog.get_logger("structlog").debug("[TNC] mod out shorter than audio buffer", delta=delta)
|
||||
self.modoutqueue.append(c)
|
||||
|
||||
|
||||
|
||||
# Release our mod_out_lock so we can use the queue
|
||||
|
||||
# Release our mod_out_lock so we can use the queue
|
||||
self.mod_out_locked = False
|
||||
|
||||
while self.modoutqueue:
|
||||
time.sleep(0.01)
|
||||
|
||||
|
||||
static.PTT_STATE = self.hamlib.set_ptt(False)
|
||||
|
||||
|
||||
# push ptt state to socket stream
|
||||
jsondata = {"ptt":"False"}
|
||||
data_out = json.dumps(jsondata)
|
||||
sock.SOCKET_QUEUE.put(data_out)
|
||||
|
||||
|
||||
# after processing we want to set the locking state back to true to be prepared for next transmission
|
||||
self.mod_out_locked = True
|
||||
|
||||
|
||||
self.c_lib.freedv_close(freedv)
|
||||
self.modem_transmit_queue.task_done()
|
||||
static.TRANSMITTING = False
|
||||
threading.Event().set()
|
||||
|
||||
def audio_datac0(self):
|
||||
def audio_datac0(self):
|
||||
""" """
|
||||
nbytes_datac0 = 0
|
||||
nbytes_datac0 = 0
|
||||
while self.stream.active:
|
||||
threading.Event().wait(0.01)
|
||||
while self.datac0_buffer.nbuffer >= self.datac0_nin:
|
||||
while self.datac0_buffer.nbuffer >= self.datac0_nin:
|
||||
# demodulate audio
|
||||
nbytes_datac0 = codec2.api.freedv_rawdatarx(self.datac0_freedv, self.datac0_bytes_out, self.datac0_buffer.buffer.ctypes)
|
||||
self.datac0_buffer.pop(self.datac0_nin)
|
||||
|
|
@ -474,66 +507,66 @@ class RF():
|
|||
self.modem_received_queue.put([self.datac1_bytes_out, self.datac1_freedv ,self.datac1_bytes_per_frame])
|
||||
#self.get_scatter(self.datac1_freedv)
|
||||
self.calculate_snr(self.datac1_freedv)
|
||||
|
||||
def audio_datac3(self):
|
||||
|
||||
def audio_datac3(self):
|
||||
""" """
|
||||
nbytes_datac3 = 0
|
||||
while self.stream.active:
|
||||
threading.Event().wait(0.01)
|
||||
while self.datac3_buffer.nbuffer >= self.datac3_nin:
|
||||
# demodulate audio
|
||||
# demodulate audio
|
||||
nbytes_datac3 = codec2.api.freedv_rawdatarx(self.datac3_freedv, self.datac3_bytes_out, self.datac3_buffer.buffer.ctypes)
|
||||
self.datac3_buffer.pop(self.datac3_nin)
|
||||
self.datac3_nin = codec2.api.freedv_nin(self.datac3_freedv)
|
||||
if nbytes_datac3 == self.datac3_bytes_per_frame:
|
||||
self.modem_received_queue.put([self.datac3_bytes_out, self.datac3_freedv ,self.datac3_bytes_per_frame])
|
||||
#self.get_scatter(self.datac3_freedv)
|
||||
self.calculate_snr(self.datac3_freedv)
|
||||
|
||||
def audio_fsk_ldpc_0(self):
|
||||
self.calculate_snr(self.datac3_freedv)
|
||||
|
||||
def audio_fsk_ldpc_0(self):
|
||||
""" """
|
||||
nbytes_fsk_ldpc_0 = 0
|
||||
while self.stream.active and static.ENABLE_FSK:
|
||||
threading.Event().wait(0.01)
|
||||
while self.fsk_ldpc_buffer_0.nbuffer >= self.fsk_ldpc_nin_0:
|
||||
# demodulate audio
|
||||
# demodulate audio
|
||||
nbytes_fsk_ldpc_0 = codec2.api.freedv_rawdatarx(self.fsk_ldpc_freedv_0, self.fsk_ldpc_bytes_out_0, self.fsk_ldpc_buffer_0.buffer.ctypes)
|
||||
self.fsk_ldpc_buffer_0.pop(self.fsk_ldpc_nin_0)
|
||||
self.fsk_ldpc_nin_0 = codec2.api.freedv_nin(self.fsk_ldpc_freedv_0)
|
||||
if nbytes_fsk_ldpc_0 == self.fsk_ldpc_bytes_per_frame_0:
|
||||
self.modem_received_queue.put([self.fsk_ldpc_bytes_out_0, self.fsk_ldpc_freedv_0 ,self.fsk_ldpc_bytes_per_frame_0])
|
||||
#self.get_scatter(self.fsk_ldpc_freedv_0)
|
||||
self.calculate_snr(self.fsk_ldpc_freedv_0)
|
||||
self.calculate_snr(self.fsk_ldpc_freedv_0)
|
||||
|
||||
def audio_fsk_ldpc_1(self):
|
||||
def audio_fsk_ldpc_1(self):
|
||||
""" """
|
||||
nbytes_fsk_ldpc_1 = 0
|
||||
while self.stream.active and static.ENABLE_FSK:
|
||||
threading.Event().wait(0.01)
|
||||
while self.fsk_ldpc_buffer_1.nbuffer >= self.fsk_ldpc_nin_1:
|
||||
# demodulate audio
|
||||
# demodulate audio
|
||||
nbytes_fsk_ldpc_1 = codec2.api.freedv_rawdatarx(self.fsk_ldpc_freedv_1, self.fsk_ldpc_bytes_out_1, self.fsk_ldpc_buffer_1.buffer.ctypes)
|
||||
self.fsk_ldpc_buffer_1.pop(self.fsk_ldpc_nin_1)
|
||||
self.fsk_ldpc_nin_1 = codec2.api.freedv_nin(self.fsk_ldpc_freedv_1)
|
||||
if nbytes_fsk_ldpc_1 == self.fsk_ldpc_bytes_per_frame_1:
|
||||
self.modem_received_queue.put([self.fsk_ldpc_bytes_out_1, self.fsk_ldpc_freedv_1 ,self.fsk_ldpc_bytes_per_frame_1])
|
||||
#self.get_scatter(self.fsk_ldpc_freedv_1)
|
||||
self.calculate_snr(self.fsk_ldpc_freedv_1)
|
||||
|
||||
|
||||
|
||||
# worker for FIFO queue for processing received frames
|
||||
self.calculate_snr(self.fsk_ldpc_freedv_1)
|
||||
|
||||
|
||||
|
||||
# worker for FIFO queue for processing received frames
|
||||
def worker_transmit(self):
|
||||
""" """
|
||||
while True:
|
||||
data = self.modem_transmit_queue.get()
|
||||
|
||||
self.transmit(mode=data[0], repeats=data[1], repeat_delay=data[2], frames=data[3])
|
||||
#self.modem_transmit_queue.task_done()
|
||||
|
||||
|
||||
|
||||
# worker for FIFO queue for processing received frames
|
||||
self.transmit(mode=data[0], repeats=data[1], repeat_delay=data[2], frames=data[3])
|
||||
#self.modem_transmit_queue.task_done()
|
||||
|
||||
|
||||
|
||||
# worker for FIFO queue for processing received frames
|
||||
def worker_received(self):
|
||||
""" """
|
||||
while True:
|
||||
|
|
@ -543,13 +576,13 @@ class RF():
|
|||
# data[2] = bytes_per_frame
|
||||
data_handler.DATA_QUEUE_RECEIVED.put([data[0], data[1], data[2]])
|
||||
self.modem_received_queue.task_done()
|
||||
|
||||
|
||||
|
||||
def get_frequency_offset(self, freedv):
|
||||
"""
|
||||
|
||||
Args:
|
||||
freedv:
|
||||
freedv:
|
||||
|
||||
Returns:
|
||||
|
||||
|
|
@ -560,13 +593,13 @@ class RF():
|
|||
offset = round(modemStats.foff) * (-1)
|
||||
static.FREQ_OFFSET = offset
|
||||
return offset
|
||||
|
||||
|
||||
|
||||
|
||||
def get_scatter(self, freedv):
|
||||
"""
|
||||
|
||||
Args:
|
||||
freedv:
|
||||
freedv:
|
||||
|
||||
Returns:
|
||||
|
||||
|
|
@ -596,12 +629,12 @@ class RF():
|
|||
scatterdata_small = scatterdata[::10]
|
||||
static.SCATTER = scatterdata_small
|
||||
|
||||
|
||||
|
||||
def calculate_snr(self, freedv):
|
||||
"""
|
||||
|
||||
Args:
|
||||
freedv:
|
||||
freedv:
|
||||
|
||||
Returns:
|
||||
|
||||
|
|
@ -633,19 +666,19 @@ class RF():
|
|||
static.HAMLIB_MODE = self.hamlib.get_mode()
|
||||
static.HAMLIB_BANDWITH = self.hamlib.get_bandwith()
|
||||
|
||||
|
||||
|
||||
def calculate_fft(self):
|
||||
""" """
|
||||
# channel_busy_delay counter
|
||||
channel_busy_delay = 0
|
||||
|
||||
|
||||
while True:
|
||||
#time.sleep(0.01)
|
||||
threading.Event().wait(0.01)
|
||||
# WE NEED TO OPTIMIZE THIS!
|
||||
|
||||
# WE NEED TO OPTIMIZE THIS!
|
||||
|
||||
if len(self.fft_data) >= 128:
|
||||
|
||||
|
||||
# https://gist.github.com/ZWMiller/53232427efc5088007cab6feee7c6e4c
|
||||
# Fast Fourier Transform, 10*log10(abs) is to scale it to dB
|
||||
# and make sure it's not imaginary
|
||||
|
|
@ -656,7 +689,7 @@ class RF():
|
|||
# set value 0 to 1 to avoid division by zero
|
||||
fftarray[fftarray == 0] = 1
|
||||
dfft = 10.*np.log10(abs(fftarray))
|
||||
|
||||
|
||||
# get average of dfft
|
||||
avg = np.mean(dfft)
|
||||
|
||||
|
|
@ -665,15 +698,15 @@ class RF():
|
|||
# data higher than the average must be a signal. Therefore we are setting it to 100 so it will be highlighted
|
||||
# have to do this when we are not transmittig so our own sending data will not affect this too much
|
||||
if not static.TRANSMITTING:
|
||||
dfft[dfft>avg+10] = 100
|
||||
|
||||
dfft[dfft>avg+10] = 100
|
||||
|
||||
# calculate audio max value
|
||||
# static.AUDIO_RMS = np.amax(self.fft_data)
|
||||
|
||||
|
||||
# static.AUDIO_RMS = np.amax(self.fft_data)
|
||||
|
||||
|
||||
# check for signals higher than average by checking for "100"
|
||||
# if we have a signal, increment our channel_busy delay counter so we have a smoother state toggle
|
||||
|
||||
|
||||
if np.sum(dfft[dfft>avg+10]) >= 300 and not static.TRANSMITTING:
|
||||
static.CHANNEL_BUSY = True
|
||||
channel_busy_delay += 5
|
||||
|
|
@ -681,56 +714,56 @@ class RF():
|
|||
if channel_busy_delay > 50:
|
||||
channel_busy_delay = 50
|
||||
else:
|
||||
# decrement channel busy counter if no signal has been detected.
|
||||
# decrement channel busy counter if no signal has been detected.
|
||||
channel_busy_delay -= 1
|
||||
if channel_busy_delay < 0:
|
||||
channel_busy_delay = 0
|
||||
# if our channel busy counter reached 0, we toggle state to False
|
||||
if channel_busy_delay == 0:
|
||||
static.CHANNEL_BUSY = False
|
||||
|
||||
|
||||
# round data to decrease size
|
||||
dfft = np.around(dfft, 0)
|
||||
dfftlist = dfft.tolist()
|
||||
|
||||
|
||||
static.FFT = dfftlist[0:320] #320 --> bandwith 3000
|
||||
|
||||
|
||||
except:
|
||||
|
||||
|
||||
structlog.get_logger("structlog").debug("[TNC] Setting fft=0")
|
||||
# else 0
|
||||
static.FFT = [0]
|
||||
else:
|
||||
pass
|
||||
|
||||
|
||||
def set_frames_per_burst(self, n_frames_per_burst):
|
||||
"""
|
||||
|
||||
Args:
|
||||
n_frames_per_burst:
|
||||
n_frames_per_burst:
|
||||
|
||||
Returns:
|
||||
|
||||
"""
|
||||
codec2.api.freedv_set_frames_per_burst(self.datac1_freedv,n_frames_per_burst)
|
||||
codec2.api.freedv_set_frames_per_burst(self.datac3_freedv,n_frames_per_burst)
|
||||
codec2.api.freedv_set_frames_per_burst(self.fsk_ldpc_freedv_0,n_frames_per_burst)
|
||||
|
||||
|
||||
|
||||
codec2.api.freedv_set_frames_per_burst(self.datac3_freedv,n_frames_per_burst)
|
||||
codec2.api.freedv_set_frames_per_burst(self.fsk_ldpc_freedv_0,n_frames_per_burst)
|
||||
|
||||
|
||||
|
||||
def get_bytes_per_frame(mode):
|
||||
"""
|
||||
provide bytes per frame information for accessing from data handler
|
||||
|
||||
|
||||
Args:
|
||||
mode:
|
||||
mode:
|
||||
|
||||
Returns:
|
||||
|
||||
"""
|
||||
if mode == 200:
|
||||
freedv = cast(codec2.api.freedv_open_advanced(codec2.api.FREEDV_MODE_FSK_LDPC, ctypes.byref(codec2.api.FREEDV_MODE_FSK_LDPC_0_ADV)), c_void_p)
|
||||
freedv = cast(codec2.api.freedv_open_advanced(codec2.api.FREEDV_MODE_FSK_LDPC, ctypes.byref(codec2.api.FREEDV_MODE_FSK_LDPC_0_ADV)), c_void_p)
|
||||
elif mode == 201:
|
||||
freedv = cast(codec2.api.freedv_open_advanced(codec2.api.FREEDV_MODE_FSK_LDPC, ctypes.byref(codec2.api.FREEDV_MODE_FSK_LDPC_1_ADV)), c_void_p)
|
||||
else:
|
||||
|
|
@ -738,10 +771,10 @@ def get_bytes_per_frame(mode):
|
|||
|
||||
# get number of bytes per frame for mode
|
||||
return int(codec2.api.freedv_get_bits_per_modem_frame(freedv)/8)
|
||||
|
||||
|
||||
|
||||
|
||||
def set_audio_volume(datalist, volume):
|
||||
data = np.fromstring(datalist, np.int16) * (volume / 100.)
|
||||
return data.astype(np.int16)
|
||||
|
||||
|
||||
|
||||
|
||||
|
|
|
|||
82
tnc/rig.py
82
tnc/rig.py
|
|
@ -20,17 +20,17 @@ except:
|
|||
sys.path.append(app_path)
|
||||
|
||||
|
||||
# try importing hamlib
|
||||
# try importing hamlib
|
||||
try:
|
||||
# get python version
|
||||
python_version = str(sys.version_info[0]) + "." + str(sys.version_info[1])
|
||||
|
||||
# installation path for Ubuntu 20.04 LTS python modules
|
||||
#sys.path.append('/usr/local/lib/python'+ python_version +'/site-packages')
|
||||
|
||||
|
||||
# installation path for Ubuntu 20.10 +
|
||||
sys.path.append('/usr/local/lib/')
|
||||
|
||||
|
||||
# installation path for Suse
|
||||
sys.path.append('/usr/local/lib64/python'+ python_version +'/site-packages')
|
||||
|
||||
|
|
@ -41,14 +41,14 @@ try:
|
|||
sys.path.append('/usr/local/lib/python3.8/site-packages')
|
||||
sys.path.append('/usr/local/lib/python3.9/site-packages')
|
||||
sys.path.append('/usr/local/lib/python3.10/site-packages')
|
||||
|
||||
|
||||
sys.path.append('lib/hamlib/linux/python3.8/site-packages')
|
||||
import Hamlib
|
||||
|
||||
|
||||
# https://stackoverflow.com/a/4703409
|
||||
hamlib_version = re.findall(r"[-+]?\d*\.?\d+|\d+", Hamlib.cvar.hamlib_version)
|
||||
hamlib_version = re.findall(r"[-+]?\d*\.?\d+|\d+", Hamlib.cvar.hamlib_version)
|
||||
hamlib_version = float(hamlib_version[0])
|
||||
|
||||
|
||||
min_hamlib_version = 4.1
|
||||
if hamlib_version > min_hamlib_version:
|
||||
structlog.get_logger("structlog").info("[RIG] Hamlib found", version=hamlib_version)
|
||||
|
|
@ -68,15 +68,15 @@ except Exception as e:
|
|||
else:
|
||||
raise Exception
|
||||
except Exception as e:
|
||||
structlog.get_logger("structlog").critical("[RIG] HAMLIB NOT INSTALLED", error=e)
|
||||
structlog.get_logger("structlog").critical("[RIG] HAMLIB NOT INSTALLED", error=e)
|
||||
hamlib_version = 0
|
||||
sys.exit()
|
||||
|
||||
|
||||
|
||||
|
||||
class radio:
|
||||
""" """
|
||||
def __init__(self):
|
||||
|
||||
|
||||
self.devicename = ''
|
||||
self.devicenumber = ''
|
||||
self.deviceport = ''
|
||||
|
|
@ -87,26 +87,26 @@ class radio:
|
|||
self.data_bits = ''
|
||||
self.stop_bits = ''
|
||||
self.handshake = ''
|
||||
|
||||
def open_rig(self, devicename, deviceport, hamlib_ptt_type, serialspeed, pttport, data_bits, stop_bits, handshake, rigctld_port, rigctld_ip):
|
||||
|
||||
def open_rig(self, devicename, deviceport, hamlib_ptt_type, serialspeed, pttport, data_bits, stop_bits, handshake, rigctld_port, rigctld_ip):
|
||||
"""
|
||||
|
||||
Args:
|
||||
devicename:
|
||||
deviceport:
|
||||
hamlib_ptt_type:
|
||||
serialspeed:
|
||||
pttport:
|
||||
data_bits:
|
||||
stop_bits:
|
||||
handshake:
|
||||
rigctld_port:
|
||||
rigctld_ip:
|
||||
devicename:
|
||||
deviceport:
|
||||
hamlib_ptt_type:
|
||||
serialspeed:
|
||||
pttport:
|
||||
data_bits:
|
||||
stop_bits:
|
||||
handshake:
|
||||
rigctld_port:
|
||||
rigctld_ip:
|
||||
|
||||
Returns:
|
||||
|
||||
"""
|
||||
|
||||
|
||||
self.devicename = devicename
|
||||
self.deviceport = str(deviceport)
|
||||
self.serialspeed = str(serialspeed) # we need to ensure this is a str, otherwise set_conf functions are crashing
|
||||
|
|
@ -115,8 +115,8 @@ class radio:
|
|||
self.data_bits = str(data_bits)
|
||||
self.stop_bits = str(stop_bits)
|
||||
self.handshake = str(handshake)
|
||||
|
||||
|
||||
|
||||
|
||||
# try to init hamlib
|
||||
try:
|
||||
Hamlib.rig_set_debug(Hamlib.RIG_DEBUG_NONE)
|
||||
|
|
@ -127,8 +127,8 @@ class radio:
|
|||
except:
|
||||
structlog.get_logger("structlog").error("[RIG] Hamlib: rig not supported...")
|
||||
self.devicenumber = 0
|
||||
|
||||
|
||||
|
||||
|
||||
self.my_rig = Hamlib.Rig(self.devicenumber)
|
||||
self.my_rig.set_conf("rig_pathname", self.deviceport)
|
||||
self.my_rig.set_conf("retry", "5")
|
||||
|
|
@ -137,10 +137,10 @@ class radio:
|
|||
self.my_rig.set_conf("stop_bits", self.stop_bits)
|
||||
self.my_rig.set_conf("data_bits", self.data_bits)
|
||||
self.my_rig.set_conf("ptt_pathname", self.pttport)
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
if self.hamlib_ptt_type == 'RIG':
|
||||
self.hamlib_ptt_type = Hamlib.RIG_PTT_RIG
|
||||
self.my_rig.set_conf("ptt_type", 'RIG')
|
||||
|
|
@ -176,7 +176,7 @@ class radio:
|
|||
|
||||
elif self.hamlib_ptt_type == 'RIG_PTT_NONE':
|
||||
self.hamlib_ptt_type = Hamlib.RIG_PTT_NONE
|
||||
|
||||
|
||||
else: #self.hamlib_ptt_type == 'RIG_PTT_NONE':
|
||||
self.hamlib_ptt_type = Hamlib.RIG_PTT_NONE
|
||||
|
||||
|
|
@ -185,13 +185,13 @@ class radio:
|
|||
|
||||
self.my_rig.open()
|
||||
atexit.register(self.my_rig.close)
|
||||
|
||||
|
||||
try:
|
||||
# lets determine the error message when opening rig
|
||||
error = str(Hamlib.rigerror(my_rig.error_status)).splitlines()
|
||||
error = error[1].split('err=')
|
||||
error = error[1]
|
||||
|
||||
|
||||
if error == 'Permission denied':
|
||||
structlog.get_logger("structlog").error("[RIG] Hamlib has no permissions", e = error)
|
||||
help_url = 'https://github.com/DJ2LS/FreeDATA/wiki/UBUNTU-Manual-installation#1-permissions'
|
||||
|
|
@ -212,16 +212,16 @@ class radio:
|
|||
except Exception as e:
|
||||
structlog.get_logger("structlog").error("[RIG] Hamlib - can't open rig", error=e, e=sys.exc_info()[0])
|
||||
return False
|
||||
|
||||
|
||||
def get_frequency(self):
|
||||
""" """
|
||||
return int(self.my_rig.get_freq())
|
||||
|
||||
|
||||
def get_mode(self):
|
||||
""" """
|
||||
(hamlib_mode, bandwith) = self.my_rig.get_mode()
|
||||
return Hamlib.rig_strrmode(hamlib_mode)
|
||||
|
||||
|
||||
def get_bandwith(self):
|
||||
""" """
|
||||
(hamlib_mode, bandwith) = self.my_rig.get_mode()
|
||||
|
|
@ -230,16 +230,16 @@ class radio:
|
|||
# not needed yet beacuse of some possible problems
|
||||
#def set_mode(self, mode):
|
||||
# return 0
|
||||
|
||||
|
||||
def get_ptt(self):
|
||||
""" """
|
||||
return self.my_rig.get_ptt()
|
||||
|
||||
|
||||
def set_ptt(self, state):
|
||||
"""
|
||||
|
||||
Args:
|
||||
state:
|
||||
state:
|
||||
|
||||
Returns:
|
||||
|
||||
|
|
@ -249,7 +249,7 @@ class radio:
|
|||
else:
|
||||
self.my_rig.set_ptt(Hamlib.RIG_VFO_CURR, 0)
|
||||
return state
|
||||
|
||||
|
||||
def close_rig(self):
|
||||
""" """
|
||||
self.my_rig.close()
|
||||
|
|
|
|||
|
|
@ -17,11 +17,11 @@ import os
|
|||
|
||||
# set global hamlib version
|
||||
hamlib_version = 0
|
||||
|
||||
|
||||
class radio:
|
||||
""" """
|
||||
def __init__(self):
|
||||
|
||||
|
||||
self.devicename = ''
|
||||
self.devicenumber = ''
|
||||
self.deviceport = ''
|
||||
|
|
@ -32,26 +32,26 @@ class radio:
|
|||
self.data_bits = ''
|
||||
self.stop_bits = ''
|
||||
self.handshake = ''
|
||||
|
||||
def open_rig(self, devicename, deviceport, hamlib_ptt_type, serialspeed, pttport, data_bits, stop_bits, handshake, rigctld_ip, rigctld_port):
|
||||
|
||||
def open_rig(self, devicename, deviceport, hamlib_ptt_type, serialspeed, pttport, data_bits, stop_bits, handshake, rigctld_ip, rigctld_port):
|
||||
"""
|
||||
|
||||
Args:
|
||||
devicename:
|
||||
deviceport:
|
||||
hamlib_ptt_type:
|
||||
serialspeed:
|
||||
pttport:
|
||||
data_bits:
|
||||
stop_bits:
|
||||
handshake:
|
||||
rigctld_ip:
|
||||
rigctld_port:
|
||||
devicename:
|
||||
deviceport:
|
||||
hamlib_ptt_type:
|
||||
serialspeed:
|
||||
pttport:
|
||||
data_bits:
|
||||
stop_bits:
|
||||
handshake:
|
||||
rigctld_ip:
|
||||
rigctld_port:
|
||||
|
||||
Returns:
|
||||
|
||||
"""
|
||||
|
||||
|
||||
self.devicename = devicename
|
||||
self.deviceport = deviceport
|
||||
self.serialspeed = str(serialspeed) # we need to ensure this is a str, otherwise set_conf functions are crashing
|
||||
|
|
@ -60,15 +60,15 @@ class radio:
|
|||
self.data_bits = data_bits
|
||||
self.stop_bits = stop_bits
|
||||
self.handshake = handshake
|
||||
|
||||
|
||||
|
||||
|
||||
# check if we are running in a pyinstaller environment
|
||||
try:
|
||||
app_path = sys._MEIPASS
|
||||
except:
|
||||
app_path = os.path.abspath(".")
|
||||
sys.path.append(app_path)
|
||||
|
||||
sys.path.append(app_path)
|
||||
|
||||
# get devicenumber by looking for deviceobject in Hamlib module
|
||||
try:
|
||||
import Hamlib
|
||||
|
|
@ -78,12 +78,12 @@ class radio:
|
|||
self.devicenumber = int(self.devicename)
|
||||
else:
|
||||
self.devicenumber = 6 #dummy
|
||||
structlog.get_logger("structlog").warning("[RIGCTL] RADIO NOT FOUND USING DUMMY!", error=e)
|
||||
|
||||
structlog.get_logger("structlog").warning("[RIGCTL] RADIO NOT FOUND USING DUMMY!", error=e)
|
||||
|
||||
# set deviceport to dummy port, if we selected dummy model
|
||||
if self.devicenumber == 1 or self.devicenumber == 6:
|
||||
self.deviceport = '/dev/ttyUSB0'
|
||||
|
||||
|
||||
print(self.devicenumber, self.deviceport, self.serialspeed)
|
||||
|
||||
|
||||
|
|
@ -93,17 +93,17 @@ class radio:
|
|||
# this is really a hack...somewhen we need a native hamlib integration for windows
|
||||
if sys.platform == 'win32' or sys.platform == 'win64':
|
||||
self.cmd = app_path + 'lib\\hamlib\\'+sys.platform+'\\rigctl -m %d -r %s -s %d ' % (int(self.devicenumber), self.deviceport, int(self.serialspeed))
|
||||
|
||||
|
||||
else:
|
||||
self.cmd = 'rigctl -m %d -r %s -s %d ' % (int(self.devicenumber), self.deviceport, int(self.serialspeed))
|
||||
|
||||
# eseguo semplicemente rigctl con il solo comando T 1 o T 0 per
|
||||
# il set e t per il get
|
||||
# il set e t per il get
|
||||
|
||||
# set ptt to false if ptt is stuck for some reason
|
||||
self.set_ptt(False)
|
||||
return True
|
||||
|
||||
|
||||
def get_frequency(self):
|
||||
""" """
|
||||
cmd = self.cmd + ' f'
|
||||
|
|
@ -116,7 +116,7 @@ class radio:
|
|||
except:
|
||||
return False
|
||||
|
||||
|
||||
|
||||
def get_mode(self):
|
||||
""" """
|
||||
#(hamlib_mode, bandwith) = self.my_rig.get_mode()
|
||||
|
|
@ -126,7 +126,7 @@ class radio:
|
|||
except:
|
||||
return False
|
||||
|
||||
|
||||
|
||||
def get_bandwith(self):
|
||||
""" """
|
||||
#(hamlib_mode, bandwith) = self.my_rig.get_mode()
|
||||
|
|
@ -141,18 +141,18 @@ class radio:
|
|||
"""
|
||||
|
||||
Args:
|
||||
mode:
|
||||
mode:
|
||||
|
||||
Returns:
|
||||
|
||||
"""
|
||||
# non usata
|
||||
return 0
|
||||
|
||||
|
||||
def get_ptt(self):
|
||||
""" """
|
||||
cmd = self.cmd + ' t'
|
||||
sw_proc = subprocess.Popen(cmd, shell=True, stdin=subprocess.PIPE, stdout=subprocess.PIPE, text=True)
|
||||
sw_proc = subprocess.Popen(cmd, shell=True, stdin=subprocess.PIPE, stdout=subprocess.PIPE, text=True)
|
||||
time.sleep(0.5)
|
||||
status = sw_proc.communicate()[0]
|
||||
|
||||
|
|
@ -160,12 +160,12 @@ class radio:
|
|||
return status
|
||||
except:
|
||||
return False
|
||||
|
||||
|
||||
def set_ptt(self, state):
|
||||
"""
|
||||
|
||||
Args:
|
||||
state:
|
||||
state:
|
||||
|
||||
Returns:
|
||||
|
||||
|
|
@ -178,12 +178,12 @@ class radio:
|
|||
cmd = cmd + '0'
|
||||
print('set_ptt', cmd)
|
||||
|
||||
sw_proc = subprocess.Popen(cmd, shell=True, text=True)
|
||||
sw_proc = subprocess.Popen(cmd, shell=True, text=True)
|
||||
try:
|
||||
return state
|
||||
except:
|
||||
return False
|
||||
|
||||
|
||||
def close_rig(self):
|
||||
""" """
|
||||
#self.my_rig.close()
|
||||
|
|
|
|||
|
|
@ -15,7 +15,7 @@ hamlib_version = 0
|
|||
|
||||
class radio():
|
||||
"""rotctld (hamlib) communication class"""
|
||||
# Note: This is a massive hack.
|
||||
# Note: This is a massive hack.
|
||||
|
||||
def __init__(self, hostname="localhost", port=4532, poll_rate=5, timeout=5):
|
||||
""" Open a connection to rotctld, and test it for validity """
|
||||
|
|
@ -31,31 +31,31 @@ class radio():
|
|||
"""
|
||||
|
||||
Args:
|
||||
devicename:
|
||||
deviceport:
|
||||
hamlib_ptt_type:
|
||||
serialspeed:
|
||||
pttport:
|
||||
data_bits:
|
||||
stop_bits:
|
||||
handshake:
|
||||
rigctld_ip:
|
||||
rigctld_port:
|
||||
devicename:
|
||||
deviceport:
|
||||
hamlib_ptt_type:
|
||||
serialspeed:
|
||||
pttport:
|
||||
data_bits:
|
||||
stop_bits:
|
||||
handshake:
|
||||
rigctld_ip:
|
||||
rigctld_port:
|
||||
|
||||
Returns:
|
||||
|
||||
"""
|
||||
self.hostname = rigctld_ip
|
||||
self.port = int(rigctld_port)
|
||||
|
||||
|
||||
|
||||
|
||||
if self.connect():
|
||||
logging.debug(f"Rigctl intialized")
|
||||
return True
|
||||
else:
|
||||
structlog.get_logger("structlog").error("[RIGCTLD] Can't connect to rigctld!", ip=self.hostname, port=self.port)
|
||||
return False
|
||||
|
||||
|
||||
def connect(self):
|
||||
"""Connect to rigctld instance"""
|
||||
if not self.connected:
|
||||
|
|
@ -69,7 +69,7 @@ class radio():
|
|||
self.close_rig()
|
||||
structlog.get_logger("structlog").warning("[RIGCTLD] Connection to rigctld refused! Reconnect...", ip=self.hostname, port=self.port, e=e)
|
||||
return False
|
||||
|
||||
|
||||
def close_rig(self):
|
||||
""" """
|
||||
self.sock.close()
|
||||
|
|
@ -81,7 +81,7 @@ class radio():
|
|||
and return the return value.
|
||||
|
||||
Args:
|
||||
command:
|
||||
command:
|
||||
|
||||
Returns:
|
||||
|
||||
|
|
@ -99,7 +99,7 @@ class radio():
|
|||
structlog.get_logger("structlog").warning("[RIGCTLD] No command response!", command=command, ip=self.hostname, port=self.port)
|
||||
self.connected = False
|
||||
else:
|
||||
|
||||
|
||||
# reconnecting....
|
||||
time.sleep(0.5)
|
||||
self.connect()
|
||||
|
|
@ -111,7 +111,7 @@ class radio():
|
|||
data = self.send_command(b"m")
|
||||
data = data.split(b'\n')
|
||||
mode = data[0]
|
||||
return mode.decode("utf-8")
|
||||
return mode.decode("utf-8")
|
||||
except:
|
||||
0
|
||||
def get_bandwith(self):
|
||||
|
|
@ -123,7 +123,7 @@ class radio():
|
|||
return bandwith.decode("utf-8")
|
||||
except:
|
||||
return 0
|
||||
|
||||
|
||||
def get_frequency(self):
|
||||
""" """
|
||||
try:
|
||||
|
|
@ -131,19 +131,19 @@ class radio():
|
|||
return frequency.decode("utf-8")
|
||||
except:
|
||||
return 0
|
||||
|
||||
|
||||
def get_ptt(self):
|
||||
""" """
|
||||
try:
|
||||
return self.send_command(b"t")
|
||||
except:
|
||||
return False
|
||||
|
||||
|
||||
def set_ptt(self, state):
|
||||
"""
|
||||
|
||||
Args:
|
||||
state:
|
||||
state:
|
||||
|
||||
Returns:
|
||||
|
||||
|
|
@ -153,6 +153,6 @@ class radio():
|
|||
self.send_command(b"T 1")
|
||||
else:
|
||||
self.send_command(b"T 0")
|
||||
return state
|
||||
return state
|
||||
except:
|
||||
return False
|
||||
|
|
|
|||
|
|
@ -3,32 +3,32 @@
|
|||
import structlog
|
||||
|
||||
hamlib_version = 0
|
||||
|
||||
|
||||
class radio:
|
||||
""" """
|
||||
def __init__(self):
|
||||
pass
|
||||
|
||||
|
||||
def open_rig(self, **kwargs):
|
||||
|
||||
def open_rig(self, **kwargs):
|
||||
"""
|
||||
|
||||
Args:
|
||||
**kwargs:
|
||||
**kwargs:
|
||||
|
||||
Returns:
|
||||
|
||||
"""
|
||||
return True
|
||||
|
||||
|
||||
def get_frequency(self):
|
||||
""" """
|
||||
return None
|
||||
|
||||
|
||||
def get_mode(self):
|
||||
""" """
|
||||
return None
|
||||
|
||||
|
||||
def get_bandwith(self):
|
||||
""" """
|
||||
return None
|
||||
|
|
@ -37,28 +37,28 @@ class radio:
|
|||
"""
|
||||
|
||||
Args:
|
||||
mode:
|
||||
mode:
|
||||
|
||||
Returns:
|
||||
|
||||
"""
|
||||
return None
|
||||
|
||||
|
||||
def get_ptt(self):
|
||||
""" """
|
||||
return None
|
||||
|
||||
def set_ptt(self, state):
|
||||
|
||||
def set_ptt(self, state):
|
||||
"""
|
||||
|
||||
Args:
|
||||
state:
|
||||
state:
|
||||
|
||||
Returns:
|
||||
|
||||
"""
|
||||
return state
|
||||
|
||||
|
||||
def close_rig(self):
|
||||
""" """
|
||||
return
|
||||
|
|
|
|||
198
tnc/sock.py
198
tnc/sock.py
|
|
@ -7,11 +7,11 @@ Created on Fri Dec 25 21:25:14 2020
|
|||
|
||||
# GET COMMANDS
|
||||
# "command" : "..."
|
||||
|
||||
|
||||
# SET COMMANDS
|
||||
# "command" : "..."
|
||||
# "parameter" : " ..."
|
||||
|
||||
|
||||
# DATA COMMANDS
|
||||
# "command" : "..."
|
||||
# "type" : "..."
|
||||
|
|
@ -51,25 +51,25 @@ class ThreadedTCPServer(socketserver.ThreadingMixIn, socketserver.TCPServer):
|
|||
the socket handler base class
|
||||
"""
|
||||
pass
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
class ThreadedTCPRequestHandler(socketserver.StreamRequestHandler):
|
||||
""" """
|
||||
|
||||
|
||||
|
||||
def send_to_client(self):
|
||||
"""
|
||||
function called by socket handler
|
||||
send data to a network client if available
|
||||
|
||||
|
||||
"""
|
||||
tempdata = b''
|
||||
while self.connection_alive and not CLOSE_SIGNAL:
|
||||
|
||||
# send tnc state as network stream
|
||||
# check server port against daemon port and send corresponding data
|
||||
|
||||
|
||||
if self.server.server_address[1] == static.PORT and not static.TNCSTARTED:
|
||||
data = send_tnc_state()
|
||||
if data != tempdata:
|
||||
|
|
@ -81,13 +81,13 @@ class ThreadedTCPRequestHandler(socketserver.StreamRequestHandler):
|
|||
tempdata = data
|
||||
SOCKET_QUEUE.put(data)
|
||||
time.sleep(0.5)
|
||||
|
||||
|
||||
|
||||
while not SOCKET_QUEUE.empty():
|
||||
data = SOCKET_QUEUE.get()
|
||||
sock_data = bytes(data, 'utf-8')
|
||||
sock_data += b'\n' # append line limiter
|
||||
|
||||
|
||||
# send data to all clients
|
||||
#try:
|
||||
for client in CONNECTED_CLIENTS:
|
||||
|
|
@ -101,7 +101,7 @@ class ThreadedTCPRequestHandler(socketserver.StreamRequestHandler):
|
|||
# we want to transmit scatter data only once to reduce network traffic
|
||||
static.SCATTER = []
|
||||
# we want to display INFO messages only once
|
||||
static.INFO = []
|
||||
static.INFO = []
|
||||
#self.request.sendall(sock_data)
|
||||
time.sleep(0.15)
|
||||
|
||||
|
|
@ -115,18 +115,18 @@ class ThreadedTCPRequestHandler(socketserver.StreamRequestHandler):
|
|||
try:
|
||||
chunk = self.request.recv(1024)
|
||||
data += chunk
|
||||
|
||||
|
||||
if chunk == b'':
|
||||
#print("connection broken. Closing...")
|
||||
self.connection_alive = False
|
||||
|
||||
|
||||
if data.startswith(b'{') and data.endswith(b'}\n'):
|
||||
|
||||
if data.startswith(b'{') and data.endswith(b'}\n'):
|
||||
# split data by \n if we have multiple commands in socket buffer
|
||||
data = data.split(b'\n')
|
||||
# remove empty data
|
||||
data.remove(b'')
|
||||
|
||||
|
||||
# iterate thorugh data list
|
||||
for commands in data:
|
||||
if self.server.server_address[1] == static.PORT:
|
||||
|
|
@ -136,19 +136,19 @@ class ThreadedTCPRequestHandler(socketserver.StreamRequestHandler):
|
|||
|
||||
# wait some time between processing multiple commands
|
||||
# this is only a first test to avoid doubled transmission
|
||||
# we might improve this by only processing one command or
|
||||
# we might improve this by only processing one command or
|
||||
# doing some kind of selection to determin which commands need to be dropped
|
||||
# and which one can be processed during a running transmission
|
||||
time.sleep(3)
|
||||
|
||||
|
||||
|
||||
|
||||
# finally delete our rx buffer to be ready for new commands
|
||||
data = bytes()
|
||||
except Exception as e:
|
||||
structlog.get_logger("structlog").info("[SCK] Connection closed", ip=self.client_address[0], port=self.client_address[1], e=e)
|
||||
self.connection_alive = False
|
||||
|
||||
|
||||
|
||||
|
||||
def handle(self):
|
||||
"""
|
||||
socket handler
|
||||
|
|
@ -158,19 +158,19 @@ class ThreadedTCPRequestHandler(socketserver.StreamRequestHandler):
|
|||
|
||||
structlog.get_logger("structlog").debug("[SCK] Client connected", ip=self.client_address[0], port=self.client_address[1])
|
||||
self.connection_alive = True
|
||||
|
||||
|
||||
self.sendThread = threading.Thread(target=self.send_to_client, args=[],daemon=True).start()
|
||||
self.receiveThread = threading.Thread(target=self.receive_from_client, args=[],daemon=True).start()
|
||||
|
||||
|
||||
# keep connection alive until we close it
|
||||
while self.connection_alive and not CLOSE_SIGNAL:
|
||||
time.sleep(1)
|
||||
|
||||
|
||||
|
||||
|
||||
def finish(self):
|
||||
""" """
|
||||
structlog.get_logger("structlog").warning("[SCK] Closing client socket", ip=self.client_address[0], port=self.client_address[1])
|
||||
structlog.get_logger("structlog").warning("[SCK] Closing client socket", ip=self.client_address[0], port=self.client_address[1])
|
||||
try:
|
||||
CONNECTED_CLIENTS.remove(self.request)
|
||||
except:
|
||||
|
|
@ -182,7 +182,7 @@ def process_tnc_commands(data):
|
|||
process tnc commands
|
||||
|
||||
Args:
|
||||
data:
|
||||
data:
|
||||
|
||||
Returns:
|
||||
|
||||
|
|
@ -198,9 +198,9 @@ def process_tnc_commands(data):
|
|||
try:
|
||||
static.TX_AUDIO_LEVEL = int(received_json["value"])
|
||||
command_response("tx_audio_level", True)
|
||||
|
||||
except Exception as e:
|
||||
command_response("tx_audio_level", False)
|
||||
|
||||
except Exception as e:
|
||||
command_response("tx_audio_level", False)
|
||||
structlog.get_logger("structlog").warning("[SCK] command execution error", e=e, command=received_json)
|
||||
|
||||
|
||||
|
|
@ -209,8 +209,8 @@ def process_tnc_commands(data):
|
|||
try:
|
||||
data_handler.DATA_QUEUE_TRANSMIT.put(['SEND_TEST_FRAME'])
|
||||
command_response("send_test_frame", True)
|
||||
except Exception as e:
|
||||
command_response("send_test_frame", False)
|
||||
except Exception as e:
|
||||
command_response("send_test_frame", False)
|
||||
structlog.get_logger("structlog").warning("[SCK] command execution error", e=e, command=received_json)
|
||||
|
||||
# CQ CQ CQ -----------------------------------------------------
|
||||
|
|
@ -218,9 +218,9 @@ def process_tnc_commands(data):
|
|||
try:
|
||||
data_handler.DATA_QUEUE_TRANSMIT.put(['CQ'])
|
||||
command_response("cqcqcq", True)
|
||||
|
||||
except Exception as e:
|
||||
command_response("cqcqcq", False)
|
||||
|
||||
except Exception as e:
|
||||
command_response("cqcqcq", False)
|
||||
structlog.get_logger("structlog").warning("[SCK] command execution error", e=e, command=received_json)
|
||||
# START_BEACON -----------------------------------------------------
|
||||
if received_json["command"] == "start_beacon":
|
||||
|
|
@ -229,21 +229,21 @@ def process_tnc_commands(data):
|
|||
interval = int(received_json["parameter"])
|
||||
data_handler.DATA_QUEUE_TRANSMIT.put(['BEACON', interval, True])
|
||||
command_response("start_beacon", True)
|
||||
except Exception as e:
|
||||
command_response("start_beacon", False)
|
||||
except Exception as e:
|
||||
command_response("start_beacon", False)
|
||||
structlog.get_logger("structlog").warning("[SCK] command execution error", e=e, command=received_json)
|
||||
|
||||
|
||||
# STOP_BEACON -----------------------------------------------------
|
||||
if received_json["command"] == "stop_beacon":
|
||||
try:
|
||||
try:
|
||||
structlog.get_logger("structlog").warning("[TNC] Stopping beacon!")
|
||||
static.BEACON_STATE = False
|
||||
data_handler.DATA_QUEUE_TRANSMIT.put(['BEACON', None, False])
|
||||
command_response("stop_beacon", True)
|
||||
except Exception as e:
|
||||
command_response("stop_beacon", False)
|
||||
except Exception as e:
|
||||
command_response("stop_beacon", False)
|
||||
structlog.get_logger("structlog").warning("[SCK] command execution error", e=e, command=received_json)
|
||||
|
||||
|
||||
# PING ----------------------------------------------------------
|
||||
if received_json["type"] == 'ping' and received_json["command"] == "ping":
|
||||
# send ping frame and wait for ACK
|
||||
|
|
@ -255,14 +255,14 @@ def process_tnc_commands(data):
|
|||
# then we are forcing a station ssid = 0
|
||||
dxcallsign = helpers.callsign_to_bytes(dxcallsign)
|
||||
dxcallsign = helpers.bytes_to_callsign(dxcallsign)
|
||||
|
||||
|
||||
data_handler.DATA_QUEUE_TRANSMIT.put(['PING', dxcallsign])
|
||||
command_response("ping", True)
|
||||
except Exception as e:
|
||||
except Exception as e:
|
||||
command_response("ping", False)
|
||||
structlog.get_logger("structlog").warning("[SCK] command execution error", e=e, command=received_json)
|
||||
|
||||
|
||||
|
||||
|
||||
# CONNECT ----------------------------------------------------------
|
||||
if received_json["type"] == 'arq' and received_json["command"] == "connect":
|
||||
static.BEACON_PAUSE = True
|
||||
|
|
@ -275,14 +275,14 @@ def process_tnc_commands(data):
|
|||
# then we are forcing a station ssid = 0
|
||||
dxcallsign = helpers.callsign_to_bytes(dxcallsign)
|
||||
dxcallsign = helpers.bytes_to_callsign(dxcallsign)
|
||||
|
||||
|
||||
static.DXCALLSIGN = dxcallsign
|
||||
static.DXCALLSIGN_CRC = helpers.get_crc_24(static.DXCALLSIGN)
|
||||
|
||||
|
||||
data_handler.DATA_QUEUE_TRANSMIT.put(['CONNECT', dxcallsign])
|
||||
command_response("connect", True)
|
||||
except Exception as e:
|
||||
command_response("connect", False)
|
||||
except Exception as e:
|
||||
command_response("connect", False)
|
||||
structlog.get_logger("structlog").warning("[SCK] command execution error", e=e, command=received_json)
|
||||
|
||||
# DISCONNECT ----------------------------------------------------------
|
||||
|
|
@ -291,15 +291,15 @@ def process_tnc_commands(data):
|
|||
try:
|
||||
data_handler.DATA_QUEUE_TRANSMIT.put(['DISCONNECT'])
|
||||
command_response("disconnect", True)
|
||||
except Exception as e:
|
||||
except Exception as e:
|
||||
command_response("disconnect", False)
|
||||
structlog.get_logger("structlog").warning("[SCK] command execution error", e=e, command=received_json)
|
||||
|
||||
structlog.get_logger("structlog").warning("[SCK] command execution error", e=e, command=received_json)
|
||||
|
||||
# TRANSMIT RAW DATA -------------------------------------------
|
||||
if received_json["type"] == 'arq' and received_json["command"] == "send_raw":
|
||||
|
||||
static.BEACON_PAUSE = True
|
||||
try:
|
||||
try:
|
||||
if not static.ARQ_SESSION:
|
||||
dxcallsign = received_json["parameter"][0]["dxcallsign"]
|
||||
# additional step for beeing sure our callsign is correctly
|
||||
|
|
@ -314,37 +314,37 @@ def process_tnc_commands(data):
|
|||
dxcallsign = static.DXCALLSIGN
|
||||
static.DXCALLSIGN_CRC = helpers.get_crc_24(static.DXCALLSIGN)
|
||||
|
||||
|
||||
|
||||
mode = int(received_json["parameter"][0]["mode"])
|
||||
n_frames = int(received_json["parameter"][0]["n_frames"])
|
||||
base64data = received_json["parameter"][0]["data"]
|
||||
|
||||
|
||||
# check if specific callsign is set with different SSID than the TNC is initialized
|
||||
try:
|
||||
mycallsign = received_json["parameter"][0]["mycallsign"]
|
||||
except:
|
||||
mycallsign = static.MYCALLSIGN
|
||||
|
||||
|
||||
# check if transmission uuid provided else set no-uuid
|
||||
try:
|
||||
arq_uuid = received_json["uuid"]
|
||||
except:
|
||||
arq_uuid = 'no-uuid'
|
||||
|
||||
if not len(base64data) % 4:
|
||||
|
||||
if not len(base64data) % 4:
|
||||
binarydata = base64.b64decode(base64data)
|
||||
|
||||
data_handler.DATA_QUEUE_TRANSMIT.put(['ARQ_RAW', binarydata, mode, n_frames, arq_uuid, mycallsign])
|
||||
|
||||
else:
|
||||
raise TypeError
|
||||
except Exception as e:
|
||||
command_response("send_raw", False)
|
||||
except Exception as e:
|
||||
command_response("send_raw", False)
|
||||
structlog.get_logger("structlog").warning("[SCK] command execution error", e=e, command=received_json)
|
||||
|
||||
|
||||
|
||||
# STOP TRANSMISSION ----------------------------------------------------------
|
||||
|
||||
|
||||
# STOP TRANSMISSION ----------------------------------------------------------
|
||||
if received_json["type"] == 'arq' and received_json["command"] == "stop_transmission":
|
||||
try:
|
||||
if static.TNC_STATE == 'BUSY' or static.ARQ_STATE:
|
||||
|
|
@ -353,10 +353,10 @@ def process_tnc_commands(data):
|
|||
static.TNC_STATE = 'IDLE'
|
||||
static.ARQ_STATE = False
|
||||
command_response("stop_transmission", True)
|
||||
except Exception as e:
|
||||
command_response("stop_transmission", False)
|
||||
except Exception as e:
|
||||
command_response("stop_transmission", False)
|
||||
structlog.get_logger("structlog").warning("[SCK] command execution error", e=e, command=received_json)
|
||||
|
||||
|
||||
|
||||
if received_json["type"] == 'get' and received_json["command"] == 'rx_buffer':
|
||||
try:
|
||||
|
|
@ -364,7 +364,7 @@ def process_tnc_commands(data):
|
|||
"command": "rx_buffer",
|
||||
"data-array": [],
|
||||
}
|
||||
|
||||
|
||||
for i in range(0, len(static.RX_BUFFER)):
|
||||
#print(static.RX_BUFFER[i][4])
|
||||
#rawdata = json.loads(static.RX_BUFFER[i][4])
|
||||
|
|
@ -375,18 +375,18 @@ def process_tnc_commands(data):
|
|||
#self.request.sendall(bytes(jsondata, encoding))
|
||||
SOCKET_QUEUE.put(jsondata)
|
||||
command_response("rx_buffer", True)
|
||||
|
||||
except Exception as e:
|
||||
command_response("rx_buffer", False)
|
||||
|
||||
except Exception as e:
|
||||
command_response("rx_buffer", False)
|
||||
structlog.get_logger("structlog").warning("[SCK] command execution error", e=e, command=received_json)
|
||||
|
||||
|
||||
|
||||
|
||||
if received_json["type"] == 'set' and received_json["command"] == 'del_rx_buffer':
|
||||
try:
|
||||
static.RX_BUFFER = []
|
||||
command_response("del_rx_buffer", True)
|
||||
except Exception as e:
|
||||
command_response("del_rx_buffer", False)
|
||||
except Exception as e:
|
||||
command_response("del_rx_buffer", False)
|
||||
structlog.get_logger("structlog").warning("[SCK] command execution error", e=e, command=received_json)
|
||||
|
||||
# exception, if JSON cant be decoded
|
||||
|
|
@ -397,7 +397,7 @@ def send_tnc_state():
|
|||
"""
|
||||
send the tnc state to network
|
||||
"""
|
||||
|
||||
|
||||
encoding = 'utf-8'
|
||||
|
||||
output = {
|
||||
|
|
@ -410,7 +410,7 @@ def send_tnc_state():
|
|||
"audio_rms": str(static.AUDIO_RMS),
|
||||
"snr": str(static.SNR),
|
||||
"frequency": str(static.HAMLIB_FREQUENCY),
|
||||
"speed_level": str(static.ARQ_SPEED_LEVEL),
|
||||
"speed_level": str(static.ARQ_SPEED_LEVEL),
|
||||
"mode": str(static.HAMLIB_MODE),
|
||||
"bandwith": str(static.HAMLIB_BANDWITH),
|
||||
"fft": str(static.FFT),
|
||||
|
|
@ -434,7 +434,7 @@ def send_tnc_state():
|
|||
# add heard stations to heard stations object
|
||||
for i in range(0, len(static.HEARD_STATIONS)):
|
||||
output["stations"].append({"dxcallsign": str(static.HEARD_STATIONS[i][0], 'utf-8'), "dxgrid": str(static.HEARD_STATIONS[i][1], 'utf-8'),"timestamp": static.HEARD_STATIONS[i][2], "datatype": static.HEARD_STATIONS[i][3], "snr": static.HEARD_STATIONS[i][4], "offset": static.HEARD_STATIONS[i][5], "frequency": static.HEARD_STATIONS[i][6]})
|
||||
|
||||
|
||||
jsondata = json.dumps(output)
|
||||
return jsondata
|
||||
|
||||
|
|
@ -444,7 +444,7 @@ def process_daemon_commands(data):
|
|||
process daemon commands
|
||||
|
||||
Args:
|
||||
data:
|
||||
data:
|
||||
|
||||
Returns:
|
||||
|
||||
|
|
@ -465,11 +465,11 @@ def process_daemon_commands(data):
|
|||
|
||||
command_response("mycallsign", True)
|
||||
structlog.get_logger("structlog").info("[DMN] SET MYCALL", call=static.MYCALLSIGN, crc=static.MYCALLSIGN_CRC)
|
||||
except Exception as e:
|
||||
except Exception as e:
|
||||
command_response("mycallsign", False)
|
||||
structlog.get_logger("structlog").warning("[SCK] command execution error", e=e, command=received_json)
|
||||
|
||||
|
||||
|
||||
|
||||
if received_json["type"] == 'set' and received_json["command"] == 'mygrid':
|
||||
try:
|
||||
mygrid = received_json["parameter"]
|
||||
|
|
@ -480,13 +480,13 @@ def process_daemon_commands(data):
|
|||
static.MYGRID = bytes(mygrid, 'utf-8')
|
||||
structlog.get_logger("structlog").info("[SCK] SET MYGRID", grid=static.MYGRID)
|
||||
command_response("mygrid", True)
|
||||
except Exception as e:
|
||||
except Exception as e:
|
||||
command_response("mygrid", False)
|
||||
structlog.get_logger("structlog").warning("[SCK] command execution error", e=e, command=received_json)
|
||||
|
||||
|
||||
|
||||
|
||||
if received_json["type"] == 'set' and received_json["command"] == 'start_tnc' and not static.TNCSTARTED:
|
||||
|
||||
|
||||
try:
|
||||
mycall = str(received_json["parameter"][0]["mycall"])
|
||||
mygrid = str(received_json["parameter"][0]["mygrid"])
|
||||
|
|
@ -543,9 +543,9 @@ def process_daemon_commands(data):
|
|||
respond_to_cq \
|
||||
])
|
||||
command_response("start_tnc", True)
|
||||
|
||||
except Exception as e:
|
||||
command_response("start_tnc", False)
|
||||
|
||||
except Exception as e:
|
||||
command_response("start_tnc", False)
|
||||
structlog.get_logger("structlog").warning("[SCK] command execution error", e=e, command=received_json)
|
||||
|
||||
if received_json["type"] == 'get' and received_json["command"] == 'test_hamlib':
|
||||
|
|
@ -577,23 +577,23 @@ def process_daemon_commands(data):
|
|||
rigctld_port \
|
||||
])
|
||||
command_response("test_hamlib", True)
|
||||
except Exception as e:
|
||||
command_response("test_hamlib", False)
|
||||
except Exception as e:
|
||||
command_response("test_hamlib", False)
|
||||
structlog.get_logger("structlog").warning("[SCK] command execution error", e=e, command=received_json)
|
||||
|
||||
|
||||
if received_json["type"] == 'set' and received_json["command"] == 'stop_tnc':
|
||||
try:
|
||||
static.TNCPROCESS.kill()
|
||||
# unregister process from atexit to avoid process zombies
|
||||
atexit.unregister(static.TNCPROCESS.kill)
|
||||
|
||||
|
||||
structlog.get_logger("structlog").warning("[DMN] Stopping TNC")
|
||||
static.TNCSTARTED = False
|
||||
command_response("stop_tnc", True)
|
||||
except Exception as e:
|
||||
command_response("stop_tnc", False)
|
||||
except Exception as e:
|
||||
command_response("stop_tnc", False)
|
||||
structlog.get_logger("structlog").warning("[SCK] command execution error", e=e, command=received_json)
|
||||
|
||||
|
||||
def send_daemon_state():
|
||||
"""
|
||||
send the daemon state to network
|
||||
|
|
@ -613,26 +613,26 @@ def send_daemon_state():
|
|||
#'ram': str(psutil.virtual_memory().percent),
|
||||
'version': '0.1'
|
||||
}
|
||||
|
||||
|
||||
if static.TNCSTARTED:
|
||||
output["daemon_state"].append({"status": "running"})
|
||||
else:
|
||||
output["daemon_state"].append({"status": "stopped"})
|
||||
|
||||
|
||||
|
||||
|
||||
jsondata = json.dumps(output)
|
||||
|
||||
return jsondata
|
||||
except Exception as e:
|
||||
structlog.get_logger("structlog").warning("[SCK] error", e=e)
|
||||
return None
|
||||
|
||||
|
||||
def command_response(command, status):
|
||||
if status:
|
||||
status = "OK"
|
||||
else:
|
||||
status = "Failed"
|
||||
|
||||
|
||||
jsondata = {"command_response": command, "status" : status}
|
||||
data_out = json.dumps(jsondata)
|
||||
SOCKET_QUEUE.put(data_out)
|
||||
|
|
|
|||
|
|
@ -5,7 +5,7 @@ Created on Wed Dec 23 11:13:57 2020
|
|||
|
||||
@author: DJ2LS
|
||||
Here we are saving application wide variables and stats, which have to be accessed everywhere.
|
||||
Not nice, suggestions are appreciated :-)
|
||||
Not nice, suggestions are appreciated :-)
|
||||
"""
|
||||
|
||||
VERSION = '0.4.0-alpha'
|
||||
|
|
@ -55,7 +55,7 @@ HAMLIB_HANDSHAKE = 'None'
|
|||
HAMLIB_RADIOCONTROL = 'direct'
|
||||
HAMLIB_RIGCTLD_IP = '127.0.0.1'
|
||||
HAMLIB_RIGCTLD_PORT = '4532'
|
||||
|
||||
|
||||
HAMLIB_FREQUENCY = 0
|
||||
HAMLIB_MODE = ''
|
||||
HAMLIB_BANDWITH = 0
|
||||
|
|
@ -122,4 +122,4 @@ INFO = []
|
|||
|
||||
# ------- CODEC2 SETTINGS
|
||||
TUNING_RANGE_FMIN = -50.0
|
||||
TUNING_RANGE_FMAX = 50.0
|
||||
TUNING_RANGE_FMAX = 50.0
|
||||
|
|
|
|||
Loading…
Reference in a new issue