PyFT8 2.4.3__tar.gz → 2.6.0__tar.gz

{pyft8-2.4.3 → pyft8-2.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PyFT8
-Version: 2.4.3
+Version: 2.6.0
 Summary: FT8 Decoding and Encoding in Python with test/loopback code
 Author-email: G1OJS <g1ojs@yahoo.com>
 License-Expression: GPL-3.0-or-later

{pyft8-2.4.3 → pyft8-2.6.0}/PyFT8/gui.py

@@ -19,7 +19,7 @@ class Scrollbox:
         self.lineartists = []
         for i in range(self.nlines):
             self.lineartists.append(self.ax.text(0.03,1 - self.line_height * (i+1),
-                            '', color = 'white', fontsize = self.fontsize))
+                            '', color = 'white', fontsize = self.fontsize, family="monospace"))
         self.ax.set_xticks([])
         self.ax.set_yticks([])
         self.ax.set_facecolor('black')
@@ -31,6 +31,10 @@ class Scrollbox:
             self.lineartists[i].set_text(line['text'])
             self.lineartists[i].set_color(line['color'])
 
+    def clear(self):
+        for i in range(self.nlines):
+            self.print("")
+
 class Msg_box:
     def __init__(self, fig, ax, tbin, fbin, w, h, onclick):
         from matplotlib.patches import Rectangle
@@ -69,11 +73,12 @@ class Msg_box:
             self.onclick(self.message)
 
 class Gui:
-    def __init__(self, dBgrid, hps, bpt, config, on_msg_click, on_control_click):
+    def __init__(self, dBgrid, hps, bpt, config, update_usermessages, on_msg_click, on_control_click):
         if config is not None:
             self.mStation = {'c':config['station']['call'], 'g':config['station']['grid']}
         self.on_msg_click = on_msg_click
         self.on_control_click = on_control_click
+        self.update_usermessages = update_usermessages
         self.dBgrid = dBgrid
         self.hps, self.bpt = hps, bpt
         self.msg_boxes = {}
@@ -82,7 +87,7 @@ class Gui:
         self.make_layout(config)
         self.ani = FuncAnimation(self.fig, self._animate, interval = 40, frames=(100000), blit=True)
 
-    def make_layout(self, config, wf_left = 0.15, wf_top = 0.87):
+    def make_layout(self, config, wf_left = 0.15, wf_top = 0.87, left_width = 0.13):
         self.plt = plt
         self.fig = plt.figure(figsize = (10,10), facecolor=(.18, .71, .71, 0.4)) 
         self.fig.canvas.manager.set_window_title('PyFT8 by G1OJS')
@@ -90,6 +95,9 @@ class Gui:
         self.image = self.ax_wf.imshow(self.dBgrid.T,vmax=120,vmin=90,origin='lower',interpolation='none', aspect = 'auto')
         self.ax_wf.set_xticks([])
         self.ax_wf.set_yticks([])
+        self.sep_h = 0.002
+        self.ax_band_stats = self.fig.add_axes([self.pmarg, wf_top + self.sep_h, left_width, 1-self.pmarg - (wf_top + self.sep_h)])
+        self.band_stats = Scrollbox(self.fig, self.ax_band_stats, nlines = 4)
         self.ax_console = self.fig.add_axes([self.pmarg + wf_left, wf_top, 1-2*self.pmarg - wf_left, 1-self.pmarg-wf_top])
         self.console = Scrollbox(self.fig, self.ax_console)
 
@@ -100,7 +108,7 @@ class Gui:
                                #{'label':'Averaging','style':'ctrl','data':None}]
             for band, freq in config['bands'].items():
                 button_defs.append({'label':band,'style':'band','action':'SET_FREQ','data':freq})
-            self._make_buttons(button_defs, styles, wf_top, 0.02, 0.1, 0.002)
+            self._make_buttons(button_defs, styles, wf_top, 0.02, left_width, 0.002)
 
     def _make_buttons(self, btn_defs, styles, btns_top, btn_h, btn_w, sep_h):
         self.buttons = []
@@ -132,6 +140,8 @@ class Gui:
             self._display_message_box(self.decode_queue.get())
         if (frame % 10 == 0):
             self._tidy_msg_boxes()
-        return [self.image, *self.ax_wf.patches, *self.ax_wf.texts, *self.console.lineartists]
+        if (frame % 50 == 0):
+            self.update_usermessages()
+        return [self.image, *self.ax_wf.patches, *self.ax_wf.texts, *self.band_stats.lineartists, *self.console.lineartists, *[btn.label for btn in self.buttons]]
 
                                     

pyft8-2.6.0/PyFT8/hamlib.py

@@ -0,0 +1,36 @@
+import socket
+import subprocess
+import threading
+import time
+
+class Rig_hamlib:
+    def __init__(self, config):
+        com = config['hamlib_rig']['port']
+        s = config['hamlib_rig']['baud_rate']
+        rigctld = config['hamlib_rig']['rigctld']
+        rig = config['hamlib_rig']['model']
+        host, port ="localhost", 4532
+        cmd = f"{rigctld} -m {rig} -r /{com} -s {s}"
+        threading.Thread(target = subprocess.run, args = (cmd,)).start()
+        self.sock = socket.create_connection((host, port))
+
+    def cmd(self, command):
+        self.sock.sendall((command + "\n").encode())
+        return self.sock.recv(1024).decode()
+
+    def set_freq_Hz(self, hz):
+        self.cmd(f"F {hz}")
+
+    def ptt_on(self):
+        self.cmd(f"T 1")
+
+    def ptt_off(self):
+        self.cmd(f"T 0")
+
+
+if __name__ == '__main__':
+    rig = Rig_hamlib()
+    rig.set_freq_Hz(14074000)
+    rig.ptt_on()
+    time.sleep(0.1)
+    rig.ptt_off()

pyft8-2.6.0/PyFT8/mqtt.py

@@ -0,0 +1,84 @@
+import paho.mqtt.client as mqtt
+import threading
+import time
+from ast import literal_eval
+
+class PSKR_MQTT_listener:
+
+    def __init__(self, home_square):
+        self.home_square = home_square
+        self.cache = {}
+        self.band_TxRx_homecall_report_times = {}
+        self.band_TxRx_homecall_countremotes = {}
+        self.home_activity = {}
+        self.home_most_remotes = {}
+        self.lock = threading.Lock()
+        mqttc = mqtt.Client(mqtt.CallbackAPIVersion.VERSION2)
+        mqttc.on_connect = self.on_connect
+        mqttc.on_message = self.on_message
+        try:
+            mqttc.connect("mqtt.pskreporter.info", 1883, 60)
+        except:
+            print("[MQTT] connection error")
+        threading.Thread(target = mqttc.loop_forever, daemon = True).start()
+        threading.Thread(target = self.count_activity, daemon = True).start()
+
+    def on_connect(self, client, userdata, flags, reason_code, properties):
+        #pskr/filter/v2/{band}/{mode}/{sendercall}/{receivercall}/{senderlocator}/{receiverlocator}/{sendercountry}/{receivercountry}
+        print(f"[MQTT] Requesting mqtt feed for {self.home_square}")
+        client.subscribe(f"pskr/filter/v2/+/FT8/+/+/{self.home_square}/#")
+        client.subscribe(f"pskr/filter/v2/+/FT8/+/+/+/{self.home_square}/#")
+
+
+    def on_message(self, client, userdata, msg):
+        try:
+            d = literal_eval(msg.payload.decode())
+        except:
+            return
+        sc, rc = (d['sc'], d['sl']), (d['rc'], d['rl'])
+        for i, c in enumerate([sc, rc]):
+            call, loc = c
+            if call not in self.cache:
+                self.cache[call] = loc
+            if self.home_square in loc:
+                key = f"{d['b']}_{['Tx','Rx'][i]}_{call}"
+                if not key in self.band_TxRx_homecall_report_times:
+                    with self.lock:
+                        self.band_TxRx_homecall_report_times[key] = []
+                self.band_TxRx_homecall_report_times[key].append(time.time())
+
+    def count_activity(self):
+        while True:
+            time.sleep(5)
+            self.band_TxRx_homecall_countremotes = {}
+            with self.lock:
+                for band_TxRx_homecall in self.band_TxRx_homecall_report_times:
+                    b = band_TxRx_homecall.split("_")[0]
+                    self.home_activity[b] = [0,0]
+                for band_TxRx_homecall in self.band_TxRx_homecall_report_times:
+                    b, tr, c = band_TxRx_homecall.split("_")
+                    report_times = self.band_TxRx_homecall_report_times[band_TxRx_homecall]
+                    report_times = [t for t in report_times if (time.time() - t) < 15*60]
+                    self.band_TxRx_homecall_report_times[band_TxRx_homecall] = report_times
+                    nremotes = len(report_times)
+                    self.home_activity[b][['Tx','Rx'].index(tr)] +=1
+                    if not b in self.home_most_remotes:
+                        self.home_most_remotes[b] = [('',0), ('',0)]
+                    if nremotes>self.home_most_remotes[b][['Tx','Rx'].index(tr)][1]:
+                        self.home_most_remotes[b][['Tx','Rx'].index(tr)] = (c, nremotes)
+
+    def get_spot_counts(self, band, call):
+        n_spotting = len(self.band_TxRx_homecall_report_times.get(f"{band}_Tx_{call}", []))
+        n_spotted = len(self.band_TxRx_homecall_report_times.get(f"{band}_Rx_{call}", []))
+        return n_spotted, n_spotting
+                
+if __name__ == '__main__':
+    pskr = PSKR_MQTT_listener("IO90")
+        
+
+        
+
+    
+
+
+    

{pyft8-2.4.3 → pyft8-2.6.0}/PyFT8/pskr_upload.py

@@ -26,6 +26,7 @@ class PSKR_upload:
         self.rx_block =  self._block(b"\x99\x92", rx)
         self.console_print = console_print
         self.lock = threading.Lock()
+        print(f"[PSKR_upload] Spots will upload to pskreporter")
         threading.Thread(target = self._check_for_send, daemon = True).start()
 
     def _enc_str(self, s):
@@ -71,10 +72,15 @@ class PSKR_upload:
         packet = bytearray(header + self.rx_block + self._block(b"\x99\x93", senders))
         struct.pack_into("!H", packet, 2, len(packet))
         self.seq += len(self.reports)
-        self.sock.sendto(packet, self.addr)
-        txt = f"[pskr_upload] Sent packet with {len(self.reports)} reports"
+        try:
+            self.sock.sendto(packet, self.addr)
+            txt = f"[pskr_upload] Sent packet with {len(self.reports)} reports"
+            col = 'green'
+        except:
+            txt = "[PSKR_UPLOAD] Connection error"
+            col = 'red'
         print(txt)
-        self.console_print(txt)
+        self.console_print(txt, color = col)
         self.reports = {}
         self.last_report_time = time.time()
 

{pyft8-2.4.3 → pyft8-2.6.0}/PyFT8/pyft8.py

@@ -10,11 +10,13 @@ from PyFT8.gui import Gui
 from PyFT8.transmitter import AudioOut
 from PyFT8.time_utils import global_time_utils
 from PyFT8.rigctrl import Rig
+from PyFT8.hamlib import Rig_hamlib
+from PyFT8.mqtt import PSKR_MQTT_listener
 
-VER = '2.4.3'
+VER = '2.6.0'
 
 MAX_TX_START_SECONDS = 2.5
-rig, gui, qso, worked_before, pskr_upload = None, None, None, None, None
+rig, gui, qso, adif_logging, pskr_info, pskr_upload = None, None, None, None, None, None
 
 def get_config():
     import configparser
@@ -24,6 +26,7 @@ def get_config():
     if not os.path.exists(ini_file):
         config['station'] = {'call':'station_callsign', 'grid':'station_grid'}
         config['bands'] = {'20m':14.074}
+        config['hamlib_rig'] = {'rigctld':'C:/WSJT/wsjtx/bin/rigctld-wsjtx', 'port': 'COM4', 'baud_rate':9600, 'model':3070}
         config['rig'] = {'port': 'COM4', 'baud_rate':9600,
                          'set_freq_command':'FEFE88E0.05.0000000000.FD', 'set_freq_value':'5|5|vfBcdLU|1|0',
                          'ptt_on_command':'FEFE88E0.1C00.01.FD', 'ptt_off_command':'FEFE88E0.1C00.00.FD'}
@@ -34,56 +37,21 @@ def get_config():
     console_print(f"Reading config from {ini_file}")
     config.read(ini_file)
 
-def parse_from_adif_rec(rec, field):
-    p = rec.find(field)
-    if p > 0:
-        p1, p2 = rec.find(':',p), rec.find('>',p)
-        n = int(rec[p1+1:p2])
-        return rec[p2+1: p2+1+n]
-        
-class Logging:
-    def __init__(self):
-        self.adif_log_file = f"{config_folder}/PyFT8.adi"
-        self.worked_before_file = f"{config_folder}/PyFT8_wb.pkl"
-        if(not os.path.exists(self.adif_log_file)):
-            with open(self.adif_log_file, 'w') as f:
-                f.write("header <eoh>")
-        if(not os.path.exists(self.worked_before_file)):
-            with open(f"{self.worked_before_file}","wb") as f:
-                pickle.dump({'dummy':0}, f)
-        self.load_wb()
-        console_print(f"Logging to {self.adif_log_file}")
-
-    def load_wb(self):
-        global worked_before
-        with open(f"{self.worked_before_file}","rb") as f:
-            worked_before = pickle.load(f)
-
-    def merge_adif_to_wb_not_used(self, file = 'c:/users/drala/recent_log.adi'):
-        import datetime
-        with open(file, 'r') as f:
-            for l in f.readlines():
-                mode = parse_from_adif_rec(l, 'mode')
-                if mode == "FT8":
-                    callsign = parse_from_adif_rec(l, 'call')
-                    t = parse_from_adif_rec(l, 'time_on')
-                    d = parse_from_adif_rec(l, 'qso_date')
-                    tm = time.mktime(datetime.datetime.strptime(d+t, "%Y%m%d%H%M%S").timetuple())
-                    if callsign in worked_before:
-                        if tm < worked_before[callsign]:
-                            continue
-                    self.update_worked_before(callsign, tm)
-
-    def update_worked_before(self, callsign, band, mode, tm):
-        global worked_before
-        self.load_wb()
-        worked_before[callsign] = tm
-        cbm = callsign + "_"+band+"_"+mode
-        worked_before[callsign] = tm
-        worked_before[cbm] = tm
-        with open(f"{self.worked_before_file}","wb") as f:
-            pickle.dump(worked_before, f)
-                
+def ensure_file_exists(path, header = None):
+    try:
+        with open(path, "x") as f:
+            if header is not None:
+                f.write(header)
+    except FileExistsError:
+        pass
+      
+class ADIF:
+    def __init__(self, logfile):
+        self.adif_log_file = logfile
+        ensure_file_exists(self.adif_log_file, header = "header <eoh>\n")
+        console_print(f"ADIF to {self.adif_log_file}")
+        self.cache = self._build_cache()
+              
     def log(self, times, band_info, mStation, oStation, rpts):
         log_dict = {'call':oStation['c'], 'gridsquare':oStation['g'], 'mode':'FT8',
         'operator':mStation['c'], 'station_callsign':mStation['c'], 'my_gridsquare':mStation['g'], 
@@ -92,14 +60,33 @@ class Logging:
         'time_on':time.strftime("%H%M%S", times['time_on']), 'time_off':time.strftime("%H%M%S", times['time_on']),
         'band':band_info['b'], 'freq':band_info['fMHz']}
         with open(self.adif_log_file,'a') as f:
-            f.write(f"\n")
             for k, v in log_dict.items():
                 v = str(v)
                 f.write(f"<{k}:{len(v)}>{v} ")
             f.write(f"<eor>\n")
-        self.update_worked_before(oStation['c'], band_info['b'], 'FT8', time.time())
+        cbm = log_dict['call'] + "_" + log_dict['band'] + "_FT8"
+        tm = time.time()
+        self.cache[log_dict['call']] = tm
+        self.cache[cbm] = tm
         console_print(f"Logged QSO with {oStation['c']}")
 
+    def _build_cache(self):
+        import datetime
+        def parse(rec, field):
+            p = rec.find(field)
+            if p > 0:
+                p1, p2 = rec.find(':',p), rec.find('>',p)
+                n = int(rec[p1+1:p2])
+                return rec[p2+1: p2+1+n]
+        cache = {}
+        with open(self.adif_log_file, 'r') as f:
+            for l in f.readlines():
+                if parse(l, 'mode') == "FT8":
+                    c, b, d, t = parse(l, 'call'), parse(l, 'band'), parse(l, 'qso_date'), parse(l, 'time_on')
+                    tm = time.mktime(datetime.datetime.strptime(d+t, "%Y%m%d%H%M%S").timetuple())
+                    cache[c] = tm
+                    cache[c + "_"+b+"_FT8"] = tm
+        return cache
 
 class Message:
     def __init__(self, candidate):
@@ -113,12 +100,13 @@ class Message:
         self.is_from_me = c.msg_tuple[1] == mycall
         self.is_to_me = c.msg_tuple[0] == mycall
         self.is_cq = c.msg_tuple[0].startswith('CQ')
-        gui_wb_text = ''
-        if self.is_cq and worked_before is not None:
-            if c.msg_tuple[1] in worked_before:
-                gui_wb_text = f"wb: {global_time_utils.format_duration(time.time() - worked_before[c.msg_tuple[1]])}"
-        self.gui_text = f"{c.msg} {gui_wb_text}"
-
+        call = c.msg_tuple[1]
+        loc = pskr_info.cache.get(call,'')
+        qui_loc_text = f"loc: {loc}" if loc else ''
+        wb = adif_logging.cache.get(call,'')
+        gui_wb_text = f"wb: {global_time_utils.format_duration(time.time() - float(wb))}" if wb else ''
+        self.gui_text = f"{c.msg} {gui_wb_text} {qui_loc_text}"
+    
     def wsjtx_screen_format(self):
         return f"{self.cyclestart['string']} {self.snr:+03d} {self.dt:4.1f} {self.fHz:4.0f} ~ {self.msg}"
 
@@ -126,10 +114,8 @@ class Message:
         fMHz = float(qso.band_info['fMHz']) if qso.band_info['fMHz'] is not None else 0
         return f"{self.cyclestart['string']} {fMHz:8.3f} Rx FT8    {self.snr:+03d} {self.dt:4.1f} {self.fHz:4.0f} ~ {self.msg}"
 
-
 class FT8_QSO:
-    def __init__(self, logging):
-        self.logging = logging
+    def __init__(self):
         if config is not None:
             self.mStation = {'c':config['station']['call'], 'g':config['station']['grid']}
         self.band_info = {'b':None, 'fMHz':0}
@@ -181,9 +167,9 @@ class FT8_QSO:
             self.message_to_transmit = None
 
     def log(self):
-        if self.logging is not None:
+        if adif_logging is not None:
             self.times['time_off'] = time.gmtime()
-            self.logging.log(self.times, self.band_info, self.mStation, self.oStation, self.rpts)
+            adif_logging.log(self.times, self.band_info, self.mStation, self.oStation, self.rpts)
 
 def isReport(grid_rpt):     return "+" in grid_rpt or "-" in grid_rpt
 def isRReport(grid_rpt):    return isReport(grid_rpt) and 'R' in grid_rpt
@@ -210,7 +196,7 @@ def progress_qso(clicked_message):
         qso.times['time_on'] = time.gmtime()
         qso.oStation = {'c': call_b, 'g': grid_rpt}
         qso.rpts['sent'] = f"{clicked_message.snr:+03d}"
-        qso.set_tx_message(f"{qso.oStation['c']} {my_station['c']} {my_station['g']}")
+        qso.set_tx_message(f"{qso.oStation['c']} {my_station['c']} {my_station['g'][:4]}")
         return
 
     if call_a == my_station['c']:
@@ -254,19 +240,19 @@ def write_all_txt_row(message):
     with open(all_file, mode) as f:
         f.write(f"{row}\n")
 
-#============= Callbacks for GUI ==========================================================
-def on_decode(c):
+#============= Callbacks for Receiver ==========================================================
+def on_rx_decode(c):
     message = Message(c)
     if gui:
         gui.add_message_box(message)
     if qso.band_info['b'] is not None and pskr_upload is not None:
         dx_call = c.msg_tuple[1]
-        if dx_call != 'not':
+        if dx_call != 'not' and dx_call != config['station']['call']:
             pskr_upload.add_report(dx_call, int(1000000*float(qso.band_info['fMHz'])) + c.fHz, c.snr, 'FT8', 1, int(time.time()))
     print(message.wsjtx_screen_format())
     write_all_txt_row(message)
 
-def on_busy_profile(busy_profile, cycle):
+def on_rx_busy_profile(busy_profile, cycle):
     if output_device_idx is None:
         return
     fmax = 950 if qso.band_info['b']=='60m' else 2000
@@ -274,14 +260,37 @@ def on_busy_profile(busy_profile, cycle):
     idx = np.argmin(busy_profile[f0_idx:fn_idx])
     clear_frequencies[cycle] = (f0_idx + idx) * audio_in.df
     console_print(f"[on_busy] Set Tx freq to {clear_frequencies[cycle]:6.1f} for cycle {cycle}")
+
+#============= Callbacks for GUI ==========================================================
+def gui_update_usermessages():
     if qso.band_info['b'] is None:
         console_print(f"[PyFT8] Band not set; please select a band.", color = 'red')
-
-def on_control_click(btn_widg):
+    if pskr_info is not None and gui is not None: 
+        grd = config['station']['grid'][:4]
+        #s = [f"{b} {cnts[0]}/{cnts[1]} " for b, cnts in pskr_info.home_activity.items()]
+        #console_print(f"Tx/Rx calls in {grd}: {' '.join(s)}", color = 'yellow')
+        for bw in gui.buttons:
+            band_text = bw.user_data['label']
+            if band_text in pskr_info.home_activity:
+                cnts = pskr_info.home_activity[band_text]
+                activity_text = f"{cnts[0]}t/{cnts[1]}r"
+                bw.label.set_text(f"{band_text} {activity_text}")
+            
+        b = qso.band_info['b']
+        if b is not None and b in pskr_info.home_most_remotes:
+            tx_lead,  rx_lead = pskr_info.home_most_remotes[b]
+            call = config['station']['call']
+            n_spotted, n_spotting = pskr_info.get_spot_counts(b, call)
+            gui.band_stats.print(f"{call:<7} {tx_lead[0]:<7}", color = 'red')
+            gui.band_stats.print(f"{n_spotting:<7} {tx_lead[1]:<7}", color = 'red')
+            gui.band_stats.print(f"{call:<7} {rx_lead[0]:<7}", color = 'green')
+            gui.band_stats.print(f"{n_spotted:<7} {rx_lead[1]:<7}", color = 'green')
+
+def on_gui_control_click(btn_widg):
     btn_def = btn_widg.user_data
     btn_action = btn_def['action']
     if btn_action == "CQ":
-        mc, mg = config['station']['call'], config['station']['grid']
+        mc, mg = config['station']['call'], config['station']['grid'][:4]
         qso.set_tx_message(f"CQ {mc} {mg}")
     if btn_action == "RPT_LAST":
         qso.set_tx_message(qso.last_tx)
@@ -290,12 +299,13 @@ def on_control_click(btn_widg):
         rig.ptt_off()
         qso.tx_cycle = None
     if(btn_action == 'SET_FREQ'):
-        btn_text, freqMHz = btn_widg.label.get_text(), btn_def['data']
+        btn_text, freqMHz = btn_def['label'], btn_def['data']
         qso.band_info = {'b':btn_text, 'fMHz':freqMHz}
         rig.set_freq_Hz(int(1000000*float(qso.band_info['fMHz'])))
         console_print(f"[PyFT8] Set band: {qso.band_info['b']} {qso.band_info['fMHz']}")
+        gui.band_stats.clear()
 
-def on_msg_click(message):
+def on_gui_msg_click(message):
     progress_qso(message)
 
 #=============== CLI ========================================================================
@@ -306,7 +316,7 @@ def console_print(text, color = 'white'):
         print(text)
         
 def cli():
-    global audio_in, audio_out, output_device_idx, rig, gui, qso, config, config_folder, clear_frequencies, pskr_upload
+    global audio_in, audio_out, output_device_idx, rig, gui, qso, config, config_folder, clear_frequencies, adif_logging, pskr_upload, pskr_info
     import time
     parser = argparse.ArgumentParser(prog='PyFT8rx', description = 'Command Line FT8 decoder')
     parser.add_argument('-c', '--config_folder', help = 'Location of config folder e.g. C:/Users/drala/Documents/Projects/GitHub/G1OJS/PyFT8_cfg', default = './') 
@@ -321,14 +331,19 @@ def cli():
     output_device_idx = None
     config_folder = f"{args.config_folder}".strip()
     get_config()
-    logging = Logging()
+    adif_logging = ADIF(f"{config_folder}/PyFT8.adi")
     mc, mg = config['station']['call'], config['station']['grid']
     if mc is not None and 'pskreporter' in config.keys():
         if config['pskreporter']['upload'] == 'Y':
             pskr_upload = PSKR_upload(mc, mg, software = f"PyFT8 v{VER}", console_print = console_print) if not mc is None else None
-            console_print(f"[PyFT8] Spots will upload to pskreporter") 
-    qso = FT8_QSO(logging)
-    rig = Rig(config)
+            pskr_info = PSKR_MQTT_listener(mg[:4])
+    qso = FT8_QSO()
+    if config.has_section('hamlib_rig'):
+        console_print("Connecting to rig via Hamlib")
+        rig = Rig_hamlib(config)
+    else:
+        console_print("Connecting to rig via CAT")
+        rig = Rig(config)
 
     if args.transmit_message or args.outputcard_keywords:
         audio_out = AudioOut()
@@ -349,8 +364,8 @@ def cli():
         if not input_device_idx:
             console_print("No input device")
         else:
-            gui = None if args.no_gui else Gui(audio_in.dBgrid_main, 4, 2, config, on_msg_click, on_control_click)
-            rx = Receiver(audio_in, [200, 3100], on_decode, on_busy_profile)
+            gui = None if args.no_gui else Gui(audio_in.dBgrid_main, 4, 2, config, gui_update_usermessages, on_gui_msg_click, on_gui_control_click)
+            rx = Receiver(audio_in, [200, 3100], on_rx_decode, on_rx_busy_profile)
             audio_in.start_streamed_audio(input_device_idx)
             if gui is not None:
                 gui.plt.show()
@@ -366,4 +381,5 @@ if __name__ == "__main__":
     #with mock.patch('sys.argv', ['pyft8', '-i Mic, CODEC', '-n']):
     #with mock.patch('sys.argv', ['pyft8', '-m',  "CQ G1OJS IO90", '-cC:/Users/drala/Documents/Projects/GitHub/G1OJS/PyFT8_cfg']):
     #with mock.patch('sys.argv', ['pyft8', '-m',  "CQ G1OJS IO90", '-o', "Speak, CODEC"]):
+    #with mock.patch('sys.argv', ['pyft8', '-m',  "CQ G1OJS IO90"]):
         cli()

{pyft8-2.4.3 → pyft8-2.6.0}/PyFT8/transmitter.py

@@ -2,7 +2,7 @@ import numpy as np
 import wave
 import pyaudio
 import time
-from PyFT8.callhashes import call_hashes, add_call_hashes
+from PyFT8.callhashes import add_call_hashes
 
 #==================== AUDIO OUT ================================================================
 

{pyft8-2.4.3 → pyft8-2.6.0}/PyFT8.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PyFT8
-Version: 2.4.3
+Version: 2.6.0
 Summary: FT8 Decoding and Encoding in Python with test/loopback code
 Author-email: G1OJS <g1ojs@yahoo.com>
 License-Expression: GPL-3.0-or-later

{pyft8-2.4.3 → pyft8-2.6.0}/PyFT8.egg-info/SOURCES.txt

@@ -5,6 +5,8 @@ pyproject.toml
 PyFT8/__init__.py
 PyFT8/callhashes.py
 PyFT8/gui.py
+PyFT8/hamlib.py
+PyFT8/mqtt.py
 PyFT8/pskr_upload.py
 PyFT8/pyft8.py
 PyFT8/receiver.py

{pyft8-2.4.3 → pyft8-2.6.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "PyFT8"
-version = "2.4.3"
+version = "2.6.0"
 license = "GPL-3.0-or-later"
 
 authors = [