FreeDATA/tnc/sock.py

327 lines
15 KiB
Python
Raw Normal View History

2021-02-16 13:23:57 +00:00
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Fri Dec 25 21:25:14 2020
@author: DJ2LS
"""
import socketserver
import threading
import logging
2021-03-08 09:49:50 +00:00
import json
import asyncio
2021-03-17 10:22:06 +00:00
import time
2021-02-16 13:23:57 +00:00
import static
2021-02-24 13:22:28 +00:00
import data_handler
2021-02-16 19:49:02 +00:00
import helpers
2021-07-25 14:34:28 +00:00
import sys, os
2021-03-12 13:14:36 +00:00
class CMDTCPRequestHandler(socketserver.BaseRequestHandler):
2021-02-16 13:36:01 +00:00
2021-02-16 18:39:08 +00:00
def handle(self):
2021-05-29 14:57:31 +00:00
print("Client connected...")
# loop through socket buffer until timeout is reached. then close buffer
socketTimeout = time.time() + 10
while socketTimeout > time.time():
2021-05-29 14:57:31 +00:00
2021-05-28 18:54:23 +00:00
time.sleep(0.01)
encoding = 'utf-8'
#data = str(self.request.recv(1024), 'utf-8')
data = bytes()
# we need to loop through buffer until end of chunk is reached or timeout occured
while True and socketTimeout > time.time():
chunk = self.request.recv(1024) # .strip()
2021-05-28 18:54:23 +00:00
data += chunk
if chunk.endswith(b'\n'):
break
data = data[:-1] # remove b'\n'
data = str(data, 'utf-8')
2021-07-25 16:00:18 +00:00
print(data)
2021-03-12 16:03:04 +00:00
if len(data) > 0:
socketTimeout = time.time() + static.SOCKET_TIMEOUT
2021-05-28 18:54:23 +00:00
# convert data to json object
# we need to do some error handling in case of socket timeout
2021-07-25 16:00:18 +00:00
try:
received_json = json.loads(data)
2021-07-25 14:34:28 +00:00
#print(received_json)
2021-07-25 16:00:18 +00:00
#except:
# received_json = ''
# print(data)
#except Exception as e:
# #print("Wrong command: " + data)
# #print(e)
# exc_type, exc_obj, exc_tb = sys.exc_info()
# fname = os.path.split(exc_tb.tb_frame.f_code.co_filename)[1]
# print(exc_type, fname, exc_tb.tb_lineno)
except json.decoder.JSONDecodeError as e:
print(e)
print("#################################")
print(data)
2021-05-28 18:54:23 +00:00
# GET COMMANDS
# "command" : "..."
2021-03-17 10:22:06 +00:00
2021-05-28 18:54:23 +00:00
# SET COMMANDS
# "command" : "..."
# "parameter" : " ..."
2021-05-28 18:54:23 +00:00
# DATA COMMANDS
# "command" : "..."
# "type" : "..."
# "dxcallsign" : "..."
# "data" : "..."
2021-05-29 14:57:31 +00:00
try:
# SOCKETTEST ---------------------------------------------------
#if data == 'SOCKETTEST':
2021-07-25 14:34:28 +00:00
#if received_json["command"] == "SOCKETTEST":
# #cur_thread = threading.current_thread()
# response = bytes("WELL DONE! YOU ARE ABLE TO COMMUNICATE WITH THE TNC", encoding)
# self.request.sendall(response)
2021-05-29 14:57:31 +00:00
# CQ CQ CQ -----------------------------------------------------
#if data == 'CQCQCQ':
if received_json["command"] == "CQCQCQ":
socketTimeout = 0
#asyncio.run(data_handler.transmit_cq())
CQ_THREAD = threading.Thread(target=data_handler.transmit_cq, args=[], name="CQ")
CQ_THREAD.start()
2021-05-29 14:57:31 +00:00
# PING ----------------------------------------------------------
#if data.startswith('PING:'):
if received_json["type"] == 'PING' and received_json["command"] == "PING":
2021-05-29 14:57:31 +00:00
# send ping frame and wait for ACK
print(received_json)
2021-05-29 14:57:31 +00:00
dxcallsign = received_json["dxcallsign"]
#asyncio.run(data_handler.transmit_ping(dxcallsign))
PING_THREAD = threading.Thread(target=data_handler.transmit_ping, args=[dxcallsign], name="CQ")
PING_THREAD.start()
2021-05-29 14:57:31 +00:00
# ARQ CONNECT TO CALLSIGN ----------------------------------------
#if data.startswith('ARQ:CONNECT:'):
#if received_json["command"] == "ARQ:CONNECT":
#
# dxcallsign = received_json["dxcallsign"]
# static.DXCALLSIGN = bytes(dxcallsign, 'utf-8')
# static.DXCALLSIGN_CRC8 = helpers.get_crc_8(static.DXCALLSIGN)
# if static.ARQ_STATE == 'CONNECTED':
# # here we could disconnect
# pass
# if static.TNC_STATE == 'IDLE':
# asyncio.run(data_handler.arq_connect())
# ARQ DISCONNECT FROM CALLSIGN ----------------------------------------
#if received_json["command"] == "ARQ:DISCONNECT":
# asyncio.run(data_handler.arq_disconnect())
if received_json["type"] == 'ARQ' and received_json["command"] == "OPEN_DATA_CHANNEL": # and static.ARQ_STATE == 'CONNECTED':
static.ARQ_READY_FOR_DATA = False
static.TNC_STATE = 'BUSY'
dxcallsign = received_json["dxcallsign"]
static.DXCALLSIGN = bytes(dxcallsign, 'utf-8')
static.DXCALLSIGN_CRC8 = helpers.get_crc_8(static.DXCALLSIGN)
asyncio.run(data_handler.arq_open_data_channel())
2021-07-28 16:43:41 +00:00
if received_json["type"] == 'ARQ' and received_json["command"] == "sendFile":# and static.ARQ_READY_FOR_DATA == True: # and static.ARQ_STATE == 'CONNECTED' :
2021-05-29 14:57:31 +00:00
static.TNC_STATE = 'BUSY'
#on a new transmission we reset the timer
static.ARQ_START_OF_TRANSMISSION = int(time.time())
2021-07-28 16:43:41 +00:00
2021-05-29 14:57:31 +00:00
dxcallsign = received_json["dxcallsign"]
2021-07-28 16:43:41 +00:00
mode = int(received_json["mode"])
n_frames = int(received_json["n_frames"])
filename = received_json["filename"]
filetype = received_json["filetype"]
data = received_json["data"]
checksum = received_json["checksum"]
print(mode)
print(n_frames)
2021-05-29 14:57:31 +00:00
static.DXCALLSIGN = bytes(dxcallsign, 'utf-8')
static.DXCALLSIGN_CRC8 = helpers.get_crc_8(static.DXCALLSIGN)
2021-07-28 16:43:41 +00:00
dataframe = '{"filename": "'+ filename + '", "filetype" : "' + filetype + '", "data" : "' + data + '", "checksum" : "' + checksum + '"}'
#data_out = bytes(received_json["data"], 'utf-8')
data_out = bytes(dataframe, 'utf-8')
2021-03-12 13:14:36 +00:00
2021-07-28 16:43:41 +00:00
2021-05-28 18:54:23 +00:00
2021-05-29 14:57:31 +00:00
#ARQ_DATA_THREAD = threading.Thread(target=data_handler.arq_transmit, args=[data_out], name="ARQ_DATA")
#ARQ_DATA_THREAD.start()
ARQ_DATA_THREAD = threading.Thread(target=data_handler.open_dc_and_transmit, args=[data_out, mode, n_frames], name="ARQ_DATA")
ARQ_DATA_THREAD.start()
# asyncio.run(data_handler.arq_transmit(data_out))
# SETTINGS AND STATUS ---------------------------------------------
if received_json["type"] == 'SET' and received_json["command"] == 'MYCALLSIGN':
callsign = received_json["parameter"]
if bytes(callsign, encoding) == b'':
self.request.sendall(b'INVALID CALLSIGN')
else:
static.MYCALLSIGN = bytes(callsign, encoding)
static.MYCALLSIGN_CRC8 = helpers.get_crc_8(static.MYCALLSIGN)
logging.info("CMD | MYCALLSIGN: " + str(static.MYCALLSIGN))
if received_json["type"] == 'SET' and received_json["command"] == 'MYGRID':
mygrid = received_json["parameter"]
if bytes(mygrid, encoding) == b'':
self.request.sendall(b'INVALID GRID')
else:
static.MYGRID = bytes(mygrid, encoding)
logging.info("CMD | MYGRID: " + str(static.MYGRID))
if received_json["type"] == 'GET' and received_json["command"] == 'STATION_INFO':
output = {
"COMMAND": "STATION_INFO",
"MY_CALLSIGN": str(static.MYCALLSIGN, encoding),
"DX_CALLSIGN": str(static.DXCALLSIGN, encoding),
2021-08-06 20:09:16 +00:00
"DX_GRID": str(static.DXGRID, encoding),
"EOF" : "EOF",
2021-05-29 14:57:31 +00:00
}
jsondata = json.dumps(output)
self.request.sendall(bytes(jsondata, encoding))
if received_json["type"] == 'GET' and received_json["command"] == 'TNC_STATE':
2021-08-06 20:09:16 +00:00
print(static.SCATTER)
2021-05-29 14:57:31 +00:00
output = {
"COMMAND": "TNC_STATE",
"PTT_STATE": str(static.PTT_STATE),
"CHANNEL_STATE": str(static.CHANNEL_STATE),
"TNC_STATE": str(static.TNC_STATE),
"ARQ_STATE": str(static.ARQ_STATE),
"AUDIO_RMS": str(static.AUDIO_RMS),
"BER": str(static.BER),
2021-05-29 20:18:11 +00:00
"SNR": str(static.SNR),
2021-05-29 21:19:50 +00:00
"FREQUENCY" : str(static.HAMLIB_FREQUENCY),
"MODE" : str(static.HAMLIB_MODE),
2021-07-09 17:26:02 +00:00
"BANDWITH" : str(static.HAMLIB_BANDWITH),
2021-07-25 14:34:28 +00:00
"FFT" : str(static.FFT),
2021-08-06 20:09:16 +00:00
"SCATTER" : static.SCATTER,
2021-07-25 14:34:28 +00:00
#"RX_BUFFER_LENGTH": str(len(static.RX_BUFFER)),
#"TX_N_MAX_RETRIES": str(static.TX_N_MAX_RETRIES),
#"ARQ_TX_N_FRAMES_PER_BURST": str(static.ARQ_TX_N_FRAMES_PER_BURST),
#"ARQ_TX_N_BURSTS": str(static.ARQ_TX_N_BURSTS),
#"ARQ_TX_N_CURRENT_ARQ_FRAME": str(int.from_bytes(bytes(static.ARQ_TX_N_CURRENT_ARQ_FRAME), "big")),
#"ARQ_TX_N_TOTAL_ARQ_FRAMES": str(int.from_bytes(bytes(static.ARQ_TX_N_TOTAL_ARQ_FRAMES), "big")),
#"ARQ_RX_FRAME_N_BURSTS": str(static.ARQ_RX_FRAME_N_BURSTS),
#"ARQ_RX_N_CURRENT_ARQ_FRAME": str(static.ARQ_RX_N_CURRENT_ARQ_FRAME),
#"ARQ_N_ARQ_FRAMES_PER_DATA_FRAME": str(static.ARQ_N_ARQ_FRAMES_PER_DATA_FRAME)
2021-08-06 20:09:16 +00:00
"EOF" : "EOF",
}
2021-05-29 14:57:31 +00:00
jsondata = json.dumps(output)
2021-07-25 14:34:28 +00:00
#print(len(jsondata))
2021-05-29 14:57:31 +00:00
self.request.sendall(bytes(jsondata, encoding))
2021-07-09 17:26:02 +00:00
if received_json["type"] == 'GET' and received_json["command"] == 'FFT':
output = {
"FFT" : str(static.FFT)
}
jsondata = json.dumps(output)
self.request.sendall(bytes(jsondata, encoding))
2021-08-06 20:09:16 +00:00
#if received_json["type"] == 'GET' and received_json["command"] == 'SCATTER':
#
# print(static.SCATTER)
# output = {
# "COMMAND" : "SCATTER",
# "DATA" : static.SCATTER
# }
# print(output)
# jsondata = json.dumps(output)
# self.request.sendall(bytes(jsondata, encoding))
2021-05-29 14:57:31 +00:00
if received_json["type"] == 'GET' and received_json["command"] == 'DATA_STATE':
output = {
"COMMAND": "DATA_STATE",
"RX_BUFFER_LENGTH": str(len(static.RX_BUFFER)),
"TX_N_MAX_RETRIES": str(static.TX_N_MAX_RETRIES),
"ARQ_TX_N_FRAMES_PER_BURST": str(static.ARQ_TX_N_FRAMES_PER_BURST),
"ARQ_TX_N_BURSTS": str(static.ARQ_TX_N_BURSTS),
"ARQ_TX_N_CURRENT_ARQ_FRAME": str(int.from_bytes(bytes(static.ARQ_TX_N_CURRENT_ARQ_FRAME), "big")),
"ARQ_TX_N_TOTAL_ARQ_FRAMES": str(int.from_bytes(bytes(static.ARQ_TX_N_TOTAL_ARQ_FRAMES), "big")),
"ARQ_RX_FRAME_N_BURSTS": str(static.ARQ_RX_FRAME_N_BURSTS),
"ARQ_RX_N_CURRENT_ARQ_FRAME": str(static.ARQ_RX_N_CURRENT_ARQ_FRAME),
2021-08-06 20:09:16 +00:00
"ARQ_N_ARQ_FRAMES_PER_DATA_FRAME": str(static.ARQ_N_ARQ_FRAMES_PER_DATA_FRAME),
"EOF" : "EOF",
2021-05-29 14:57:31 +00:00
}
jsondata = json.dumps(output)
self.request.sendall(bytes(jsondata, encoding))
2021-07-25 16:00:18 +00:00
2021-05-29 14:57:31 +00:00
if received_json["type"] == 'GET' and received_json["command"] == 'HEARD_STATIONS':
2021-07-28 16:43:41 +00:00
# print("HEARD STATIONS COMMAND!")
2021-07-25 16:00:18 +00:00
data = {"COMMAND": "HEARD_STATIONS", "STATIONS" : []}
2021-05-29 14:57:31 +00:00
for i in range(0, len(static.HEARD_STATIONS)):
2021-07-28 16:43:41 +00:00
data["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]})
# print(static.HEARD_STATIONS[i][1])
2021-08-06 20:09:16 +00:00
#data.append({"EOF" : "EOF"})
2021-07-25 16:00:18 +00:00
jsondata = json.dumps(data)
2021-05-29 14:57:31 +00:00
self.request.sendall(bytes(jsondata, encoding))
2021-07-25 16:00:18 +00:00
2021-05-29 14:57:31 +00:00
if received_json["type"] == 'GET' and received_json["command"] == 'RX_BUFFER':
data = data.split('GET:RX_BUFFER:')
bufferposition = int(data[1]) - 1
if bufferposition == -1:
if len(static.RX_BUFFER) > 0:
self.request.sendall(static.RX_BUFFER[-1])
if bufferposition <= len(static.RX_BUFFER) > 0:
self.request.sendall(bytes(static.RX_BUFFER[bufferposition]))
if received_json["type"] == 'SET' and received_json["command"] == 'DEL_RX_BUFFER':
static.RX_BUFFER = []
#exception, if JSON cant be decoded
2021-07-25 14:34:28 +00:00
except Exception as e:
#print("Wrong command: " + data)
#print(e)
exc_type, exc_obj, exc_tb = sys.exc_info()
fname = os.path.split(exc_tb.tb_frame.f_code.co_filename)[1]
print(exc_type, fname, exc_tb.tb_lineno)
2021-05-29 14:57:31 +00:00
print("Client disconnected...")
2021-02-16 13:36:01 +00:00
def start_cmd_socket():
try:
logging.info("SRV | STARTING TCP/IP SOCKET FOR CMD ON PORT: " + str(static.PORT))
2021-03-12 13:14:36 +00:00
socketserver.TCPServer.allow_reuse_address = True # https://stackoverflow.com/a/16641793
cmdserver = socketserver.TCPServer((static.HOST, static.PORT), CMDTCPRequestHandler)
cmdserver.serve_forever()
2021-03-12 13:14:36 +00:00
finally:
cmdserver.server_close()