Quisk version 4.2.28
This commit is contained in:
James C. Ahlstrom
@@ -0,0 +1,408 @@
|
||||
# THIS IS THE ENTIRE "RADIO" FOR QUISK RUNNING AS A CONTROL HEAD
|
||||
# No real radio hardware is attached to the control_head computer.
|
||||
#
|
||||
# This software is Copyright (C) 2021-2022 by Ben Cahill and 2006-2022 by James C. Ahlstrom.,
|
||||
# and is licensed for use under the GNU General Public License (GPL).
|
||||
# See http://www.opensource.org.
|
||||
# Note that there is NO WARRANTY AT ALL. USE AT YOUR OWN RISK!!
|
||||
#
|
||||
# This file, control_common.py, along with a radio-specific file, e.g.
|
||||
# control_softrock.py, control_hermes.py, or similar, allows a radio-less (control_head) Quisk,
|
||||
# running on this computer, to connect to a remote (remote_radio) instance of Quisk
|
||||
# that runs on a separate computer.
|
||||
#
|
||||
# The remote_radio Quisk controls an attached real radio, and uses the hardware file
|
||||
# remote_common.py, along with a radio-specific file, e.g. remote_softrock.py,
|
||||
# remote_hermes.py, or similar, to communicate with this control_head Quisk
|
||||
# computer via a network connection.
|
||||
#
|
||||
# The remote_radio computer should be set up with a static IP address, so that you know
|
||||
# where to point the control_head. The control head computer may, however, use dynamic
|
||||
# addressing; the remote radio computer will read the control head address when the
|
||||
# remote control connection is made.
|
||||
#
|
||||
# The main control interface between control_head and remote_radio is via a TCP port;
|
||||
# this uses very low bandwidth. All functional control, including CW keying, is done via this port.
|
||||
#
|
||||
# There are 2 additional ports, both UDP, using low to moderate bandwidth:
|
||||
# -- Receive graph/waterfall data from the remote_radio
|
||||
# -- Receive radio sound from the remote_radio and send mic samples
|
||||
# These use sequential port numbers based on the TCP port number self.remote_ctl_base_port.
|
||||
# If you need to change the default base port number, you can edit the line in this file
|
||||
# that looks like (without the #):
|
||||
#
|
||||
# self.remote_ctl_base_port = 4585 # Remote Control base TCP port
|
||||
# self.graph_data_port = self.remote_ctl_base_port + 1 # UDP port for graph data
|
||||
# self.remote_radio_sound_port = self.remote_ctl_base_port + 2 # UDP port for radio sound and mic
|
||||
#
|
||||
# Make sure to edit the corresponding line in remote_common.py to match ports!!
|
||||
#
|
||||
# You should be able to use the Quisk control_head along with any/all means of control that
|
||||
# you normally use to control Quisk, including serial ports, MIDI, and hamlib/rigctl interfaces.
|
||||
#
|
||||
# The remote_radio Quisk/computer is assumed to track the local control_head Quisk/computer;
|
||||
# no attempt is made to verify the remote_radio Quisk's tuning frequency, mode, etc.
|
||||
# Snap-to Rx tuning for CW works on the control_head Quisk by virtue of graph/waterfall data
|
||||
# received from the remote_radio Quisk.
|
||||
#
|
||||
# To test CW key timing, set DEBUG_CW_SEND_DITS = 1. This issues "perfect" bursts of dits,
|
||||
# configurable in terms of dit length, dit space, number of dits per burst, and pause between
|
||||
# bursts (phrases). Search in this file for "DEBUG_CW_SEND_DITS" to find configurable variables.
|
||||
# To get log output from remote_radio end, in quisk_hardware_remote_radio.py, set DEBUG_CW_JITTER = 1.
|
||||
|
||||
from __future__ import print_function
|
||||
from __future__ import absolute_import
|
||||
|
||||
DEBUG_CW_JITTER = 0
|
||||
DEBUG_CW_SEND_DITS = 0
|
||||
DEBUG = 0
|
||||
|
||||
import socket, time, traceback, hmac, threading, select
|
||||
import _quisk as QS # Access Quisk C functions via PyMethodDef QuiskMethods[] in quisk.c
|
||||
import wx
|
||||
|
||||
from quisk_hardware_model import Hardware as BaseHardware
|
||||
|
||||
class ControlCommon(BaseHardware): # This is the Hardware class for the control head
|
||||
def __init__(self, app, conf):
|
||||
BaseHardware.__init__(self, app, conf)
|
||||
self.app = app # Access Quisk class App (Python) functions
|
||||
app.remote_control_head = True
|
||||
self.remote_ctl_base_port = 4585 # Base of ports for remote connection (maybe edit this)
|
||||
self.remote_ctl_socket = None
|
||||
self.remote_ctl_connected = False
|
||||
self.remote_ctl_timestamp = None
|
||||
self.graph_data_port = self.remote_ctl_base_port + 1
|
||||
self.remote_radio_sound_port = self.remote_ctl_base_port + 2
|
||||
self.thread_lock = threading.Lock()
|
||||
self.remote_radio_ip = socket.gethostbyname(self.conf.remote_radio_ip) # Allow either host name or IP address
|
||||
self.first_heartbeat = True
|
||||
|
||||
self.cw_keydown = 0
|
||||
self.cw_phrase_begin_ts = None # timestamp of beginning of cw phrase
|
||||
self.cw_phrase_end_ts = None
|
||||
self.cw_phrase_break_duration_secs = 1.0 # cw timestamps will reset to 0
|
||||
self.cw_poll_started_ts = None
|
||||
self.cw_poll_started = False
|
||||
|
||||
if DEBUG_CW_SEND_DITS:
|
||||
self.dit_width = 100 # msec (configurable)
|
||||
self.space_width = 100 # msec (configurable)
|
||||
self.phrase_gap = 1000 # msec (configurable)
|
||||
self.num_dits_in_phrase = 5 # number (configurable)
|
||||
self.num_dits_cur_count = 0
|
||||
self.key_was_down = False
|
||||
self.send_cw_dits = False
|
||||
self.cw_test_next_ts = None
|
||||
self.cw_test_next_msec = None
|
||||
self.cw_phrase_start_ts = None
|
||||
|
||||
self.smeter_text = ''
|
||||
self.received = ''
|
||||
self.closing = False
|
||||
QS.set_sparams(remote_control_head=1, remote_control_slave=0)
|
||||
|
||||
def open(self):
|
||||
ret = BaseHardware.open(self)
|
||||
self.remote_ctl_timestamp = time.time()
|
||||
passw = self.app.local_conf.globals.get("remote_radio_password", "")
|
||||
passw = passw.strip()
|
||||
if passw:
|
||||
del passw
|
||||
return "Not yet connected to " + self.conf.remote_radio_ip
|
||||
else:
|
||||
return "Not yet connected to %s -- Missing Password Here" % self.conf.remote_radio_ip
|
||||
|
||||
def close(self):
|
||||
print('Closing Remote Control connection')
|
||||
self.closing = True
|
||||
t = f'QUIT\n' # Tell Remote Radio we are quitting
|
||||
self.RemoteCtlSend(t)
|
||||
self.RemoteCtlClose()
|
||||
return BaseHardware.close(self)
|
||||
|
||||
def RemoteCtlClose(self):
|
||||
if self.remote_ctl_socket:
|
||||
self.remote_ctl_socket.close()
|
||||
else:
|
||||
print(' Remote Control TCP socket already closed')
|
||||
self.remote_ctl_socket = None
|
||||
self.remote_ctl_connected = False
|
||||
QS.stop_control_head_remote_sound()
|
||||
self.app.main_frame.SetConfigText("Disconnected from remote radio " + self.conf.remote_radio_ip)
|
||||
self.first_heartbeat = True
|
||||
|
||||
def RemoteCtlConnect(self):
|
||||
if self.remote_ctl_connected:
|
||||
return True
|
||||
if not self.remote_ctl_socket:
|
||||
self.remote_ctl_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
|
||||
self.remote_ctl_socket.setsockopt(socket.IPPROTO_IP, socket.IP_TOS, 184) # DSCP "Expedite" (46)
|
||||
if DEBUG: print("Default timeout for remote_ctl_socket = ", self.remote_ctl_socket.gettimeout())
|
||||
self.remote_ctl_socket.settimeout(0.1) # Allow some time for connection response
|
||||
if DEBUG: print("Our set timeout for remote_ctl_socket = ", self.remote_ctl_socket.gettimeout())
|
||||
try:
|
||||
self.remote_ctl_socket.connect((self.remote_radio_ip, self.remote_ctl_base_port))
|
||||
except OSError as err:
|
||||
if str(err).startswith('[WinError 10056]'):
|
||||
# Connected, in spite of "error" --
|
||||
# This can occur in Windows; Windows networking infrastructure continues attempting to connect,
|
||||
# even after the connect() call times out (as set in settimeout(), above).
|
||||
# If Windows connects after the timeout, then, the next time we call connect(),
|
||||
# it returns WinError 10056, "A connect request was made on an already connected socket".
|
||||
# Let's accept this "error" as success!
|
||||
if DEBUG: print('connect() returned WinError 10056; Windows already connected! Good!')
|
||||
pass
|
||||
else:
|
||||
# Not yet connected; errors may be expected/normal, or unexpected.
|
||||
if str(err).startswith('time'):
|
||||
# Timeout "error" is normal when we are waiting for Remote Radio server to become available.
|
||||
if DEBUG: print('connect() returned timeout; still waiting for remote radio server')
|
||||
elif str(err).startswith('[WinError 10022]'):
|
||||
# This can occur in Windows; Windows networking infrastructure continues attempting to connect,
|
||||
# even after the connect() call times out (as set in settimeout(), above).
|
||||
# If, by the next time we call connect(), it has not yet connected, but is still trying to do so
|
||||
# as a continuation of the prior call to connect(), it returns WinError 10022,
|
||||
# "An invalid argument was supplied", which is a little misleading, but okay for us.
|
||||
# We have not yet connected, but this is an "expected behavior".
|
||||
if DEBUG: print('connect() returned WinError 10022; invalid argument; still waiting for remote radio server')
|
||||
elif str(err).startswith('[Errno 103]'):
|
||||
# This can occur in Linux; still attempting to connect
|
||||
if DEBUG: print('connect() returned Errno 103; software connection abort; still waiting for remote radio server')
|
||||
elif str(err).startswith('[Errno 111]'):
|
||||
# This can occur in Linux; still attempting to connect
|
||||
if DEBUG: print('connect() returned Errno 111; connection refused; still waiting for remote radio server')
|
||||
else:
|
||||
# Unexpected error. Print error info, regardless of DEBUG status.
|
||||
print("Remote Control socket.connect() error: {0}".format(err))
|
||||
return False # Failure to connect
|
||||
self.remote_ctl_connected = True
|
||||
self.remote_ctl_socket.settimeout(0.0) # Now that we're connected, don't wait if nothing there
|
||||
if DEBUG: print("Remote Control connected")
|
||||
self.app.main_frame.SetConfigText("Connecting to remote radio " + self.conf.remote_radio_ip)
|
||||
# We have a TCP connection, and the remote will send a challenge token. If we give a valid response
|
||||
# we will receive "TOKEN_OK" and we can start communication.
|
||||
return True # Success
|
||||
|
||||
def ChangeFrequency(self, tune, vfo, source='', band='', event=None):
|
||||
# TODO: Try to get any modifications of freq or vfo from remote Quisk (?)
|
||||
t = f'FREQ;{tune};{vfo};{source};{band};{self.app.rxFreq};{self.VarDecimGetIndex()}\n'
|
||||
#print (t)
|
||||
self.RemoteCtlSend(t)
|
||||
#BMC if DEBUG: print('Change', source, tune, vfo, band)
|
||||
return tune, vfo
|
||||
|
||||
def OnSpot(self, level):
|
||||
pass
|
||||
|
||||
def SendCwDits(self):
|
||||
ts = time.time()
|
||||
# Use CW key to start/stop stream of dit phrases
|
||||
key_down = QS.is_cwkey_down()
|
||||
if not key_down:
|
||||
self.key_was_down = False
|
||||
else:
|
||||
if not self.key_was_down: # Leading edge detector for key down
|
||||
self.key_was_down = True
|
||||
if not self.send_cw_dits:
|
||||
self.send_cw_dits = True # Start sending dits
|
||||
self.cw_phrase_start_ts = ts # Beginning of phrase
|
||||
self.cw_test_next_ts = ts
|
||||
self.cw_test_next_msec = 0 # Start phrase at 0 msec
|
||||
self.num_dits_cur_count = 0
|
||||
else:
|
||||
self.send_cw_dits = False # Stop sending dits
|
||||
if self.send_cw_dits and ts >= self.cw_test_next_ts:
|
||||
# Send one on/off pair of CW commands (with msec timestamps since start of CW phrase)
|
||||
t = f'CW;1;{self.cw_test_next_msec}\n'
|
||||
self.RemoteCtlSend(t)
|
||||
self.cw_test_next_msec += self.dit_width
|
||||
t = f'CW;0;{self.cw_test_next_msec}\n'
|
||||
self.RemoteCtlSend(t)
|
||||
self.cw_test_next_msec += self.space_width
|
||||
self.cw_test_next_ts = self.cw_phrase_start_ts + (float(self.cw_test_next_msec) / 1000)
|
||||
self.num_dits_cur_count += 1
|
||||
if self.num_dits_cur_count >= self.num_dits_in_phrase:
|
||||
# Set up for next phrase
|
||||
self.cw_test_next_ts = ts + (float(self.phrase_gap) / 1000)
|
||||
self.cw_phrase_start_ts = self.cw_test_next_ts # Re-start beginning of phrase
|
||||
self.cw_test_next_msec = 0 # Start phrase at 0 msec
|
||||
self.num_dits_cur_count = 0
|
||||
|
||||
def ThreadPrinter(self, *args, **kw):
|
||||
# Call this to print from (possibly) the sound thread, which must not be slowed down by a print.
|
||||
# example: print (x, y, end=' ') ----> self.ThreadPrinter(x, y, end=' ')
|
||||
with self.thread_lock: # Call thread_lock only once; twice will deadlock.
|
||||
# If print request is from within sound thread, pass the print request to the GUI thread.
|
||||
if threading.current_thread().name == "QuiskSound":
|
||||
wx.CallAfter(print, *args, **kw)
|
||||
else:
|
||||
print(*args, **kw)
|
||||
|
||||
def PollCwKey(self): # Called by the sound thread
|
||||
if DEBUG_CW_SEND_DITS:
|
||||
self.SendCwDits()
|
||||
return
|
||||
# Check Quisk key state, send to Remote Radio if change.
|
||||
# NOTE: Timestamps enable Remote Radio to overcome WiFi/network jitter
|
||||
ts = time.time()
|
||||
if not self.cw_phrase_end_ts:
|
||||
self.cw_phrase_end_ts = ts
|
||||
self.cw_poll_started_ts = ts
|
||||
|
||||
key_down = QS.is_cwkey_down()
|
||||
if not self.cw_poll_started:
|
||||
# Detect Quisk startup with CW key down
|
||||
if ts - self.cw_poll_started_ts > 0.1:
|
||||
# Check for key down only within first 1/10 second of running
|
||||
self.cw_poll_started = True
|
||||
elif key_down == 1:
|
||||
# Quisk startup with key down
|
||||
t = f'Quisk is starting with CW key down! Tx is on, and Rx is blocked until you release CW key.'
|
||||
self.ThreadPrinter(t)
|
||||
#dlg = wx.MessageDialog(self.app.main_frame, t, "Quisk start, CW key down", style=wx.OK)
|
||||
#wx.CallAfter(dlg.ShowModal)
|
||||
self.cw_phrase_begin_ts = ts
|
||||
self.cw_poll_started = True
|
||||
if key_down != self.cw_keydown:
|
||||
if key_down == 1 and (ts - self.cw_phrase_end_ts) > self.cw_phrase_break_duration_secs:
|
||||
# First CW key-down since a while ago, re-start timestamp sequence for new CW phrase
|
||||
self.cw_phrase_begin_ts = ts
|
||||
cw_event_ts_msecs = int((ts - self.cw_phrase_begin_ts) * 1000) # float secs to int msecs
|
||||
self.cw_keydown = key_down
|
||||
t = f'CW;{key_down};{cw_event_ts_msecs}\n'
|
||||
self.RemoteCtlSend(t)
|
||||
self.cw_phrase_end_ts = ts # End-of-cw-phrase-detection
|
||||
if DEBUG_CW_JITTER: self.ThreadPrinter(f'{ts:10.4f} {key_down}, {cw_event_ts_msecs}')
|
||||
|
||||
def HeartBeat(self): # Called at about 10 Hz by the main
|
||||
if self.closing: # Don't try to connect if we are closing
|
||||
return
|
||||
ts = time.time()
|
||||
if (ts - self.remote_ctl_timestamp) > 1.0 or self.first_heartbeat:
|
||||
self.remote_ctl_timestamp = ts
|
||||
if self.remote_ctl_connected:
|
||||
# Send keep-alive heartbeat command
|
||||
t = f'HEARTBEAT\n'
|
||||
self.RemoteCtlSend(t)
|
||||
else:
|
||||
# Else continually try to connect
|
||||
if DEBUG: print('Heartbeat Connect Attempt')
|
||||
self.RemoteCtlConnect()
|
||||
self.first_heartbeat = False
|
||||
self.RemoteCtlRead()
|
||||
|
||||
def RemoteCtlSend(self, text):
|
||||
# RemoteCtlSend() may be called from sound thread or GUI thread!
|
||||
# self.thread lock (also used in self.ThreadPrinter) protects against thread collisions.
|
||||
if not self.remote_ctl_connected:
|
||||
if DEBUG: self.ThreadPrinter('Cannot send if not TCP connected:', text)
|
||||
return
|
||||
if DEBUG: self.ThreadPrinter('Send: ', text, end=' ')
|
||||
with self.thread_lock: # Do not call ThreadPrinter() from another thread lock!
|
||||
try:
|
||||
self.remote_ctl_socket.sendall(text.encode('utf-8', errors='ignore'))
|
||||
except OSError as err:
|
||||
errtxt = err
|
||||
pass
|
||||
else:
|
||||
return
|
||||
self.ThreadPrinter("Closing remote control socket; error in RemoteCtlSend(): {0}".format(errtxt))
|
||||
self.RemoteCtlClose()
|
||||
|
||||
def GetSmeter(self):
|
||||
return self.smeter_text
|
||||
|
||||
def RemoteCtlRead(self):
|
||||
if not self.remote_ctl_connected:
|
||||
return
|
||||
try: # Read any data from the socket
|
||||
text = self.remote_ctl_socket.recv(1024).decode('utf-8', errors='replace')
|
||||
except socket.timeout: # This does not work
|
||||
pass
|
||||
except socket.error: # Nothing to read
|
||||
pass
|
||||
else: # We got some characters
|
||||
self.received += text
|
||||
while '\n' in self.received: # A complete response ending with newline is available
|
||||
reply, self.received = self.received.split('\n', 1) # Split off the reply, save any further characters
|
||||
reply = reply.strip() # Here is our reply
|
||||
if DEBUG: print('Rcvd: ', reply)
|
||||
if reply[0] in 'Qq':
|
||||
print('Closing Remote Control socket: Q (Quit) from remote radio')
|
||||
self.RemoteCtlClose()
|
||||
return
|
||||
elif reply[0] in 'Mm':
|
||||
# S-meter text from remote_radio
|
||||
self.smeter_text = reply[2:]
|
||||
#print ("Receive smeter", reply[2:])
|
||||
elif reply[0:6] == "TOKEN;":
|
||||
passw = self.app.local_conf.globals.get("remote_radio_password", "")
|
||||
passw = passw.strip()
|
||||
if passw:
|
||||
passw = passw.encode('utf-8')
|
||||
H = hmac.new(passw, reply[6:].encode('utf-8'), 'sha3_256')
|
||||
del passw
|
||||
self.RemoteCtlSend("TOKEN;%s;%d\n" % (H.hexdigest(), self.app.data_width))
|
||||
else:
|
||||
print ("Error: Missing password on control head")
|
||||
elif reply[0:8] == "TOKEN_OK":
|
||||
self.app.main_frame.SetConfigText("Connected to remote radio " + self.conf.remote_radio_ip)
|
||||
QS.start_control_head_remote_sound(self.remote_radio_ip, self.remote_radio_sound_port, self.graph_data_port)
|
||||
self.CommonInit() # Send initial parameters common to all radios
|
||||
self.RadioInit() # Send initial parameters peculiar to a given radio
|
||||
elif reply[0:9] == "TOKEN_BAD":
|
||||
self.app.main_frame.SetConfigText("Error: Remote radio %s: Security challenge failed" % self.conf.remote_radio_ip)
|
||||
elif reply[0:13] == "TOKEN_MISSING":
|
||||
self.app.main_frame.SetConfigText("Error: Remote radio %s has no password" % self.conf.remote_radio_ip)
|
||||
elif reply[0:9] == "HL2_TEMP;":
|
||||
setattr(self, "HL2_TEMP", reply[9:])
|
||||
elif reply[:3] == 'ERR':
|
||||
print('Remote Radio returned ' + reply)
|
||||
else:
|
||||
print ("Control head received unrecognized command", reply)
|
||||
|
||||
def CommonInit(self): # Send initial frequencies, band, sample rate, etc. to remote
|
||||
app = self.app
|
||||
# Frequency and decimation
|
||||
self.ChangeFrequency(app.txFreq + app.VFO, app.VFO, "NewDecim")
|
||||
# Band
|
||||
self.RemoteCtlSend("%s;1\n" % app.lastBand)
|
||||
# Mode
|
||||
btn = app.modeButns.GetSelectedButton()
|
||||
if btn:
|
||||
self.RemoteCtlSend("%s;%d\n" % (btn.idName, btn.GetIndex()))
|
||||
# Filter and adjustable bandwidth
|
||||
name = "Filter 6Slider"
|
||||
value = app.midiControls[name][0].button.slider_value
|
||||
self.RemoteCtlSend("%s;%d\n" % (name, value))
|
||||
btn = app.filterButns.GetSelectedButton()
|
||||
if btn:
|
||||
self.RemoteCtlSend("%s;%d\n" % (btn.idName, btn.GetIndex()))
|
||||
# AGC and Squelch levels, split offset
|
||||
self.RemoteCtlSend("Split;0\n")
|
||||
btn = app.BtnAGC
|
||||
self.RemoteCtlSend("AGCSQLCH;%d;%d;%d;%d;%d\n" % (btn.slider_value_off, btn.slider_value_on,
|
||||
app.levelSquelch, app.levelSquelchSSB, app.split_offset))
|
||||
idName = "SqlchSlider"
|
||||
value = app.midiControls[idName][0].button.slider_value
|
||||
self.RemoteCtlSend("%s;%d\n" % (idName, value))
|
||||
# Spot slider
|
||||
idName = "SpotSlider"
|
||||
value = app.midiControls[idName][0].button.slider_value
|
||||
self.RemoteCtlSend("%s;%d\n" % (idName, value))
|
||||
# Various buttons
|
||||
for idName in ("Mute", "NR2", "AGC", "Sqlch", "NB 1", "Notch", "Test 1", "Spot", "FDX", "PTT", "VOX"):
|
||||
self.RemoteCtlSend("%s;%d\n" % (idName, app.idName2Button[idName].GetIndex()))
|
||||
# Menus
|
||||
for menu in (app.NB_menu, app.split_menu, app.freedv_menu, app.smeter_menu):
|
||||
if menu:
|
||||
for nid in menu.id2data:
|
||||
menu_item = menu.FindItemById(nid)
|
||||
kind = menu_item.GetKind()
|
||||
if kind == wx.ITEM_RADIO:
|
||||
if menu_item.IsChecked():
|
||||
self.RemoteCtlSend('MENU;%s;%s;1\n' % (menu.menu_name, menu_item.GetItemLabelText()))
|
||||
elif kind == wx.ITEM_CHECK:
|
||||
checked = menu_item.IsChecked()
|
||||
self.RemoteCtlSend('MENU;%s;%s;%d\n' % (menu.menu_name, menu_item.GetItemLabelText(), int(checked)))
|
||||
Reference in New Issue
Block a user