PyFT8 2.6.1__tar.gz → 2.7.0__tar.gz

{pyft8-2.6.1 → pyft8-2.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PyFT8
-Version: 2.6.1
+Version: 2.7.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
@@ -41,7 +41,7 @@ If you're interested in how this works, maybe have a look at [MiniPyFT8](https:/
  The Gui shows:
  - Simultaneous views of odd and even cycles
  - Messages overlaid on waterfall signals that produce them
- - Worked-before info and fine grid locators in the message boxes (distance and bearing coming soon)
+ - Worked-before info and fine grid locators / distance and bearing in the message boxes 
  - Band activity on band select buttons
  - Number of remote stations hearing your Tx, number of remote Txs that you're hearing, plus the same info for the 'best' station in your level 4 square
 
@@ -50,8 +50,8 @@ To enable uploading of spots to pskreporter, make sure that your .ini file inclu
 [pskreporter]
 upload = Y
 ```
-<img width="1078" height="436" alt="Capture" src="https://github.com/user-attachments/assets/5c4b64cb-e3e6-4a2f-aa77-93fd361a4e74" />
 
+<img width="980" height="807" alt="screenshot" src="https://github.com/user-attachments/assets/ac393a05-277a-4d98-bd74-78bcb0ae8b03" />
 
 
 ## Motivation

pyft8-2.7.0/PyFT8/gui.py

@@ -0,0 +1,222 @@
+import numpy as np
+import matplotlib.pyplot as plt
+import time, queue
+from matplotlib import rcParams
+from matplotlib.animation import FuncAnimation
+from matplotlib.widgets import Slider, Button
+
+rcParams['toolbar'] = 'None'
+MAIN_TEXT_COLOR = '#f0f9fa'
+TEXT_BACKGROUND_COLOR = '#2a2b2b'
+INFO_TEXT_COLOR = 'white'
+BUTTONCOLOR = 'grey'
+HOVERCOLOR = 'darkgreen'
+ACTIVE_BUTTON_COLOR = 'cyan'
+INACTIVE_BUTTON_COLOR = '#edeef0'
+MAX_FONT_SIZE_MAIN = 10
+L = {'pmargin':0.04, 'sidebar_width': 0.16, 'banner_height':0.1, 'vsep1':0.01, 'hsep1':0.02}
+
+# ================== WATERFALL ======================================================
+
+class Scrollbox:
+    def __init__(self, fig, box, nlines = 5, monospace = False, default_text = '', fontsize = None):
+        self.fig = fig
+        self.ax = fig.add_axes(box)
+        self.default_text = default_text
+        bbox = self.ax.get_window_extent().transformed(fig.dpi_scale_trans.inverted())
+        self.fontsize = np.min([0.5 * bbox.height * fig.dpi / nlines, MAX_FONT_SIZE_MAIN]) if fontsize is None else fontsize
+        self.nlines = nlines
+        self.line_height = 0.9 / nlines
+        self.lines = []
+        self.lineartists = []
+        for i in range(self.nlines):
+            self.lineartists.append(self.ax.text(0.03,1 - self.line_height * (i+1),
+                            '', color = MAIN_TEXT_COLOR, fontsize = self.fontsize))
+            if monospace:
+                self.lineartists[-1].set_fontfamily('monospace')
+        self.ax.set_xticks([])
+        self.ax.set_yticks([])
+        self.ax.set_facecolor(TEXT_BACKGROUND_COLOR)
+
+    def scroll_print(self, text, color = MAIN_TEXT_COLOR):
+        self.lines = self.lines[-(self.nlines-1):]
+        self.lines.append({'text':text, 'color':color})
+        for i, line in enumerate(self.lines):
+            self.lineartists[i].set_text(line['text'])
+            self.lineartists[i].set_color(line['color'])
+
+    def clear(self):
+        self.lines = []
+        for i in range(self.nlines):
+            self.lineartists[i].set_text(self.default_text)
+
+    def list_print(self, lst):
+        self.lines = [{'text':l, 'color':'white'} for l in lst[:self.nlines]]
+        for i, line in enumerate(self.lines):
+            if line['text'] != self.lineartists[i].get_text():
+                self.lineartists[i].set_text(line['text'])
+                self.lineartists[i].set_color(line['color'])
+        for i in range(len(lst), self.nlines):
+            if self.lineartists[i].get_text() != '':
+                self.lineartists[i].set_text('')          
+
+
+class Msg_box:
+    def __init__(self, fig, ax, tbin, fbin, w, h, onclick):
+        from matplotlib.patches import Rectangle
+        self.onclick = onclick 
+        rect = Rectangle((tbin, fbin), width=w, height=h, alpha=0.6, edgecolor='lime', lw=2)
+        self.patch = ax.add_patch(rect)
+        self.text_inst = ax.text(tbin, fbin+2, '', fontsize='small', fontweight='bold' )
+        self.cid = fig.canvas.mpl_connect('button_press_event', self._onclick)
+        self.expire = 0 
+
+    def set_properties(self, message):
+        self.message = message
+        self.patch.set_x(message.h0_idx)
+        self.text_inst.set_x(message.h0_idx)
+        self.patch.set_visible(True)
+        self.text_inst.set_visible(True)
+        self.expire = message.expire
+
+    def set_appearance(self, message):
+        self.text_inst.set_text(message.gui_text)
+        colors = ['blue', 'white']
+        if message.is_cq: colors = ['green', 'white']
+        if message.is_from_me: colors = ['yellow', 'white']
+        if message.is_to_me: colors = ['red', 'white']
+        self.text_inst.set_color(colors[1])
+        self.patch.set_facecolor(colors[0])
+        
+    def hide_if_expired(self):
+        if time.time() > self.expire > 0:
+            self.patch.set_visible(False)
+            self.text_inst.set_visible(False)
+
+    def _onclick(self, event):
+        b, _ = self.patch.contains(event)
+        if(b):
+            self.onclick(self.message)
+
+class ButtonBox:
+    def __init__(self, fig, box, btn_pc = 30, onclick = None, clickargs=None, btn_label = ''):
+        btnbox, infobox = box.copy(), box.copy()
+        btnbox[2] = box[2] * btn_pc /100
+        infobox[2] = box[2] * (100-btn_pc) /100
+        infobox[0] = box[0] + box[2] * (btn_pc /100)
+        self.btn_axs = fig.add_axes(btnbox)
+        self.info_axs = fig.add_axes(infobox)
+        self.info_axs.set_xticks([])
+        self.info_axs.set_yticks([])
+        self.info_axs.set_facecolor(TEXT_BACKGROUND_COLOR)
+        self.label2 = self.info_axs.text(0.03, 0.5, '', color = INFO_TEXT_COLOR, verticalalignment = 'center')
+        self.btn_widg = Button(self.btn_axs, btn_label, color = BUTTONCOLOR, hovercolor = HOVERCOLOR)
+        self.label = self.btn_widg.label
+        self.label.set_color(MAIN_TEXT_COLOR)
+        self.clickargs = clickargs
+        self.active = False
+        self.btn_widg.on_clicked(lambda x: onclick(clickargs))
+
+    def set_active(self, active: bool):
+        if self.active != active:
+            self.active = active
+            self._update_appearance()
+
+    def set_info_text(self, text):
+        self.label2.set_text(text)
+
+    def get_info_text(self):
+        return self.label2
+
+    def _update_appearance(self):
+        color = ACTIVE_BUTTON_COLOR if self.active else INACTIVE_BUTTON_COLOR
+        self.label.set_color(color)
+        self.label2.set_color(color)
+
+class Gui:
+    def __init__(self, dBgrid, hps, bpt, config, on_gui_sidebars_refresh, 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.on_gui_sidebars_refresh = on_gui_sidebars_refresh
+        self.dBgrid = dBgrid
+        self.hps, self.bpt = hps, bpt
+        self.msg_boxes = {}
+        self.decode_queue = queue.Queue()
+        self.make_layout(config)
+        self.ani = FuncAnimation(self.fig, self._animate, interval = 40, frames=(100000), blit=True)
+
+    def make_layout(self, config):
+        # figure
+        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')
+        wf_top = 1-L['pmargin']-L['banner_height']-L['vsep1']
+        wf_left = L['pmargin']+L['sidebar_width']+L['hsep1']
+
+        # waterfall
+        self.ax_wf = self.fig.add_axes([wf_left, L['pmargin'], 1-wf_left-L['pmargin'], wf_top-L['pmargin']])
+        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([])
+
+        # band stats
+        self.band_stats = Scrollbox(self.fig, [L['pmargin'], wf_top+L['vsep1'], L['sidebar_width'], L['banner_height']], nlines = 4, monospace = True)
+        self.band_stats.ax.text(-0.2,0.75,'Tx')
+        self.band_stats.ax.text(-0.2,0.25,'Rx')
+        self.band_stats.ax.set_title(f"Spots to/from {config['station']['grid'][:4]}", fontsize = 10)
+
+        # console
+        self.console = Scrollbox(self.fig, [wf_left, wf_top+L['vsep1'], 1-wf_left-L['pmargin'], L['banner_height']])
+
+        # control buttons
+        self.button_boxes = []
+        bh, bs = 0.02, 0.002
+        bb = ButtonBox(self.fig, [L['pmargin'], wf_top - (len(self.button_boxes)+1) * bh + bs, L['sidebar_width'], bh-bs], btn_pc = 100,
+                        btn_label = "CQ", onclick = self.on_control_click, clickargs = {'action':'CQ'})                            
+        self.button_boxes.append(bb)
+        bb = ButtonBox(self.fig, [L['pmargin'], wf_top - (len(self.button_boxes)+1) * bh + bs, L['sidebar_width'], bh-bs], btn_pc = 100,
+                        btn_label = "Repeat last", onclick = self.on_control_click, clickargs = {'action':'RPT_LAST'})                            
+        self.button_boxes.append(bb)
+        bb = ButtonBox(self.fig, [L['pmargin'], wf_top - (len(self.button_boxes)+1) * bh + bs, L['sidebar_width'], bh-bs], btn_pc = 100,
+                        btn_label = "Tx off", onclick = self.on_control_click, clickargs = {'action':'TX_OFF'})                            
+        self.button_boxes.append(bb)            
+        for band, freq in config['bands'].items():
+            bb = ButtonBox(self.fig, [L['pmargin'], wf_top - (len(self.button_boxes)+1) * bh + bs, L['sidebar_width'], bh-bs], btn_pc = 30,
+                            btn_label = band, onclick = self.on_control_click, clickargs = {'action':'SET_BAND','band':band,'freq':freq})
+            self.button_boxes.append(bb)
+
+        # hearing me list
+        self.hm = Scrollbox(self.fig, [L['pmargin'], L['pmargin'], L['sidebar_width'], wf_top - (len(self.button_boxes)+2) * bh + bs - L['vsep1']],
+                            nlines = 30, monospace = True, fontsize = 8)
+        
+
+    def refresh_sidebars(self):
+        self.on_gui_sidebars_refresh(self)
+        
+    def add_message_box(self, message):
+        self.decode_queue.put(message)
+
+    def _display_message_box(self, message):
+        h0_idx, f0_idx = message.h0_idx, message.f0_idx
+        if not f0_idx in self.msg_boxes:
+            self.msg_boxes[f0_idx] = Msg_box(self.fig, self.ax_wf, h0_idx, f0_idx, 79*self.hps, 8*self.bpt, onclick = self.on_msg_click)
+        self.msg_boxes[f0_idx].set_properties(message)
+        self.msg_boxes[f0_idx].set_appearance(message)
+        
+    def _tidy_msg_boxes(self):
+        for fb in self.msg_boxes:
+            self.msg_boxes[fb].hide_if_expired()
+ 
+    def _animate(self, frame):
+        self.image.set_data(self.dBgrid.T)
+        while not self.decode_queue.empty():
+            self._display_message_box(self.decode_queue.get())
+        if (frame % 10 == 0):
+            self._tidy_msg_boxes()
+            self.refresh_sidebars()
+        return [self.image, *self.ax_wf.patches, *self.ax_wf.texts, *self.band_stats.lineartists, *self.console.lineartists, *self.hm.lineartists,
+                *[bb.label for bb in self.button_boxes], *[bb.label2 for bb in self.button_boxes]]
+
+                                    

pyft8-2.7.0/PyFT8/maidenhead.py

@@ -0,0 +1,32 @@
+import numpy as np
+
+def grid_to_latlong(grid, centre = True):
+    lat, lon = -90, -180
+    grid = grid.upper()
+    if centre:
+        grid = grid + "LL44LL44LL44"[len(grid):]
+    mults = [20, 2, 2/24, 0.2/24, 0.2/(24*24), 0.02/(24*24)]
+    grid = grid[:2*len(mults)]
+    pairs = [grid[i:i+2] for i in range(0,len(grid),2)]
+    for i, p in enumerate(pairs):
+        zero = [ord('A'),ord('0')][i % 2]
+        lon += mults[i] * (ord(p[0]) - zero)
+        lat += mults[i] * (ord(p[1]) - zero) / 2
+    return (lat, lon)
+        
+
+def db(sq1, sq2):
+    ll1, ll2 = grid_to_latlong(sq1), grid_to_latlong(sq2)
+    lats = [np.radians(ll1[0]),np.radians(ll2[0])]
+    dlat, dlon = np.radians(ll2[0] - ll1[0]), np.radians(ll2[1] - ll1[1])
+    s_lats, c_lats = np.sin(lats), np.cos(lats)
+    a = np.sin(dlat/2)**2 + c_lats[0] * c_lats[1] * np.sin(dlon/2)**2
+    r = 6371 * 2 * np.asin(np.sqrt(a))
+    b = np.atan2(c_lats[1] * np.sin(dlon), c_lats[0] * s_lats[1] - s_lats[0] * c_lats[1] * np.cos(dlon))
+    return (r, np.degrees(b) % 360)
+
+#grids = ['LL44LL44LL44', 'IO90', 'IO90JU', 'IO90JU44', 'IO90JU95LX', 'IO90JU96MA','IN79jx55']
+#for g in grids:
+#    print(g, grid_to_latlong(g, centre = True))
+
+#print(db('IO90','IO91'))

pyft8-2.7.0/PyFT8/mqtt.py

@@ -0,0 +1,133 @@
+import paho.mqtt.client as mqtt
+import threading
+import time
+from ast import literal_eval
+
+SPOTLIFE = 15*60
+
+import os
+import pickle
+
+class DiskDict:
+    def __init__(self, file):
+        self.file = file
+        self.data = {}
+        self.load()
+        threading.Thread(target = self._autosave, daemon = True).start()
+
+    def _autosave(self, autosave_period = 15):
+        while True:
+            time.sleep(autosave_period)
+            self.save()
+
+    def load(self):
+        if(os.path.exists(self.file)):
+            with open(f"{self.file}","rb") as f:
+                self.data = pickle.load(f)
+
+    def save(self):
+        if self.data:
+            with open(f"{self.file}","wb") as f:
+                pickle.dump(self.data, f)
+
+class PSKR_MQTT_listener:
+    def __init__(self, config_folder, my_call, home_square):
+        self.my_call = my_call
+        self.hearing_me = DiskDict(f"{config_folder}/hearing_me.pkl")
+        self.home_square = home_square
+        self.callsign_cache = DiskDict(f"{config_folder}/callsign_cache.pkl")
+        self.band_TxRx_homecall_report_times = DiskDict(f"{config_folder}/report_times.pkl")
+        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.callsign_cache.data:
+                self.callsign_cache.data[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.data:
+                    with self.lock:
+                        self.band_TxRx_homecall_report_times.data[key] = []
+                self.band_TxRx_homecall_report_times.data[key].append(time.time())
+            if d['sc'] == self.my_call:
+                if d['b'] not in self.hearing_me.data:
+                    self.hearing_me.data[d['b']] = {}
+                if d['rc'] not in self.hearing_me.data[d['b']]:
+                    self.hearing_me.data[d['b']][d['rc']] = {'t':time.time(), 'rp':d['rp'], 'c':d['rc']}
+
+    def count_activity(self):
+        import numpy as np
+        while True:
+            time.sleep(5)
+            self.home_activity = {}
+            self.band_TxRx_homecall_countremotes = {}
+            self.home_most_remotes = {}
+            with self.lock:
+                for band_TxRx_homecall in self.band_TxRx_homecall_report_times.data:
+                    b = band_TxRx_homecall.split("_")[0]
+                    self.home_activity[b] = [0, 0]
+
+                for band_TxRx_homecall in self.band_TxRx_homecall_report_times.data:
+                    band_TxRx_homecall_report_times = self.band_TxRx_homecall_report_times.data[band_TxRx_homecall]
+                    band_TxRx_homecall_report_times = [t for t in band_TxRx_homecall_report_times if (time.time() - t) < SPOTLIFE]
+                    self.band_TxRx_homecall_report_times.data[band_TxRx_homecall] = band_TxRx_homecall_report_times
+
+                for band_TxRx_homecall in self.band_TxRx_homecall_report_times.data:
+                    band_TxRx_homecall_report_times = self.band_TxRx_homecall_report_times.data[band_TxRx_homecall]
+                    if len(band_TxRx_homecall_report_times):
+                        b, tr, c = band_TxRx_homecall.split("_")
+                        self.home_activity[b][['Tx','Rx'].index(tr)] +=1
+                        nremotes = len(band_TxRx_homecall_report_times)
+                        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)
+
+                for b in self.hearing_me.data:
+                    newdict = {}
+                    for c in self.hearing_me.data[b]:
+                        if (time.time() - self.hearing_me.data[b][c]['t']) < SPOTLIFE:
+                            newdict[c] = self.hearing_me.data[b][c]
+                    self.hearing_me.data[b] = newdict
+
+    def get_spot_counts(self, band, call):
+        tx_reports = self.band_TxRx_homecall_report_times.data.get(f"{band}_Tx_{call}", [])
+        rx_reports = self.band_TxRx_homecall_report_times.data.get(f"{band}_Rx_{call}", [])
+        n_spotting = len(tx_reports) if tx_reports else 0
+        n_spotted = len(rx_reports) if rx_reports else 0
+        return n_spotted, n_spotting
+                
+if __name__ == '__main__':
+    pskr = PSKR_MQTT_listener("IO90")
+        
+
+        
+
+    
+
+
+    

{pyft8-2.6.1 → pyft8-2.7.0}/PyFT8/pyft8.py

@@ -12,11 +12,13 @@ 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
+import PyFT8.maidenhead as maidenhead
 
-VER = '2.6.1'
+VER = '2.7.0'
 
 MAX_TX_START_SECONDS = 2.5
 rig, gui, qso, adif_logging, pskr_info, pskr_upload = None, None, None, None, None, None
+busy_profile, hearing_me = None, None
 
 def get_config():
     import configparser
@@ -88,6 +90,16 @@ class ADIF:
                     cache[c + "_"+b+"_FT8"] = tm
         return cache
 
+def get_geo_text(call):
+    geo_text = ''
+    loc = pskr_info.callsign_cache.data.get(call,'')
+    if loc and config['gui']['loc'] == 'km_deg':
+            loc = maidenhead.db(config['station']['grid'], loc)
+            geo_text = f"{int(loc[0]):5d}k {int(loc[1]):3d}°"
+    if loc and config['gui']['loc'] == 'loc':
+            geo_text = f"loc: {loc}"
+    return geo_text
+
 class Message:
     def __init__(self, candidate):
         c = candidate
@@ -100,12 +112,10 @@ 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')
-        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}"
+        geo_text = get_geo_text(c.msg_tuple[1])
+        wb_time = adif_logging.cache.get(c.msg_tuple[1],'')
+        wb_text = f"wb: {global_time_utils.format_duration(time.time() - float(wb_time))}" if wb_time else ''
+        self.gui_text = f"{c.msg} {wb_text} {geo_text}"
     
     def wsjtx_screen_format(self):
         return f"{self.cyclestart['string']} {self.snr:+03d} {self.dt:4.1f} {self.fHz:4.0f} ~ {self.msg}"
@@ -152,7 +162,7 @@ class FT8_QSO:
                 time.sleep(delay)
             if self.tx_cycle is None:
                 self.tx_cycle = global_time_utils.curr_cycle_from_time()
-                self.tx_freq = clear_frequencies[self.tx_cycle]
+                self.tx_freq = clearest_frequency
                 console_print(f"[PyFT8] Set tx cycle = {self.tx_cycle} f = {self.tx_freq:5.1f}")
             symbols = audio_out.create_ft8_symbols(self.message_to_transmit)
             if any(symbols):
@@ -252,42 +262,59 @@ def on_rx_decode(c):
     print(message.wsjtx_screen_format())
     write_all_txt_row(message)
 
-def on_rx_busy_profile(busy_profile, cycle):
+def on_rx_busy_profile(busy_profile_new, cycle):
+    global busy_profile
     if output_device_idx is None:
         return
-    fmax = 950 if qso.band_info['b']=='60m' else 2000
-    f0_idx, fn_idx = int(500/audio_in.df), int(fmax/audio_in.df)
-    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}")
+    if busy_profile is not None:
+        busy_profile += busy_profile_new
+        fmax = 950 if qso.band_info['b']=='60m' else 2000
+        f0_idx, fn_idx = int(500/audio_in.df), int(fmax/audio_in.df)
+        idx = np.argmin(busy_profile[f0_idx:fn_idx])
+        clearest_frequency = (f0_idx + idx) * audio_in.df
+    busy_profile = busy_profile_new
+    #console_print(f"[on_busy] Set Tx freq to {clearest_frequency:6.1f}")
 
 #============= Callbacks for GUI ==========================================================
-def gui_update_usermessages():
+def on_gui_sidebars_refresh(gui):
     if qso.band_info['b'] is None:
         console_print(f"[PyFT8] Band not set; please select a band.", color = 'red')
-    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 = '#ff756b')
-            gui.band_stats.print(f"{n_spotting:<7} {tx_lead[1]:<7}", color = '#ff756b')
-            gui.band_stats.print(f"{call:<7} {rx_lead[0]:<7}", color = '#b6f0c6')
-            gui.band_stats.print(f"{n_spotted:<7} {rx_lead[1]:<7}", color = '#b6f0c6')
+    if pskr_info is None:
+        return
+    
+    # refresh band stats
+    grd = config['station']['grid'][:4]
+    for bb in gui.button_boxes:
+        band = bb.clickargs.get('band','')
+        if band:
+            bb.set_active(band == qso.band_info.get('b',''))
+            if band in pskr_info.home_activity:
+                cnts = pskr_info.home_activity[band]
+                new_text = f"{cnts[0]}Tx, {cnts[1]}Rx"
+                if new_text != bb.get_info_text():
+                    bb.set_info_text(new_text)
 
-def on_gui_control_click(btn_widg):
-    btn_def = btn_widg.user_data
+    # refresh home square counts
+    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)
+        # add local count here for n_spotted prior to round trip to pskreporter?
+        gui.band_stats.scroll_print(f"{call:<7} {tx_lead[0]:<7}", color = '#ff756b')
+        gui.band_stats.scroll_print(f"{n_spotting:<7} {tx_lead[1]:<7}", color = '#ff756b')
+        gui.band_stats.scroll_print(f"{call:<7} {rx_lead[0]:<7}", color = '#b6f0c6')
+        gui.band_stats.scroll_print(f"{n_spotted:<7} {rx_lead[1]:<7}", color = '#b6f0c6')
+
+    #refresh hearing me
+    hearing_me_text = []
+    if b is not None and b in pskr_info.hearing_me.data:    
+        for h in pskr_info.hearing_me.data[b].values():
+            geo_text = geo_text = get_geo_text(h['c'])
+            hearing_me_text.append(f"{h['c']:<7} {int(h['rp']):+03d} {geo_text:<12}")
+    gui.hm.list_print(['Hearing me:'] + hearing_me_text)
+
+def on_gui_control_click(btn_def):
     btn_action = btn_def['action']
     if btn_action == "CQ":
         mc, mg = config['station']['call'], config['station']['grid'][:4]
@@ -298,25 +325,26 @@ def on_gui_control_click(btn_widg):
         console_print("[PyFT8] Set PTT Off")
         rig.ptt_off()
         qso.tx_cycle = None
-    if(btn_action == 'SET_FREQ'):
-        band, freqMHz = btn_def['label'], btn_def['data']
+    if(btn_action == 'SET_BAND'):
+        band, freqMHz = btn_def['band'], btn_def['freq']
         qso.band_info = {'b':band, '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()
-
+        gui.refresh_sidebars()
+        
 def on_gui_msg_click(message):
     progress_qso(message)
 
 #=============== CLI ========================================================================
 def console_print(text, color = 'white'):
     if gui is not None:
-        gui.console.print(text, color)
+        gui.console.scroll_print(text, color)
     else:
         print(text)
         
 def cli():
-    global audio_in, audio_out, output_device_idx, rig, gui, qso, config, config_folder, clear_frequencies, adif_logging, pskr_upload, pskr_info
+    global audio_in, audio_out, output_device_idx, rig, gui, qso, config, config_folder, clearest_frequency, 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 = './') 
@@ -336,7 +364,7 @@ def cli():
     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
-            pskr_info = PSKR_MQTT_listener(mg[:4])
+            pskr_info = PSKR_MQTT_listener(config_folder, mc, mg[:4])
     qso = FT8_QSO()
     if config.has_section('hamlib_rig'):
         console_print("Connecting to rig via Hamlib")
@@ -347,7 +375,7 @@ def cli():
 
     if args.transmit_message or args.outputcard_keywords:
         audio_out = AudioOut()
-        clear_frequencies = [760, 760]
+        clearest_frequency = 760
     
     if args.outputcard_keywords:
         outputcard_keywords = args.outputcard_keywords.replace(' ','').split(',')
@@ -364,7 +392,7 @@ 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, gui_update_usermessages, on_gui_msg_click, on_gui_control_click)
+            gui = None if args.no_gui else Gui(audio_in.dBgrid_main, 4, 2, config, on_gui_sidebars_refresh, 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:

{pyft8-2.6.1 → pyft8-2.7.0}/PyFT8.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PyFT8
-Version: 2.6.1
+Version: 2.7.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
@@ -41,7 +41,7 @@ If you're interested in how this works, maybe have a look at [MiniPyFT8](https:/
  The Gui shows:
  - Simultaneous views of odd and even cycles
  - Messages overlaid on waterfall signals that produce them
- - Worked-before info and fine grid locators in the message boxes (distance and bearing coming soon)
+ - Worked-before info and fine grid locators / distance and bearing in the message boxes 
  - Band activity on band select buttons
  - Number of remote stations hearing your Tx, number of remote Txs that you're hearing, plus the same info for the 'best' station in your level 4 square
 
@@ -50,8 +50,8 @@ To enable uploading of spots to pskreporter, make sure that your .ini file inclu
 [pskreporter]
 upload = Y
 ```
-<img width="1078" height="436" alt="Capture" src="https://github.com/user-attachments/assets/5c4b64cb-e3e6-4a2f-aa77-93fd361a4e74" />
 
+<img width="980" height="807" alt="screenshot" src="https://github.com/user-attachments/assets/ac393a05-277a-4d98-bd74-78bcb0ae8b03" />
 
 
 ## Motivation

{pyft8-2.6.1 → pyft8-2.7.0}/PyFT8.egg-info/SOURCES.txt

@@ -6,6 +6,7 @@ PyFT8/__init__.py
 PyFT8/callhashes.py
 PyFT8/gui.py
 PyFT8/hamlib.py
+PyFT8/maidenhead.py
 PyFT8/mqtt.py
 PyFT8/pskr_upload.py
 PyFT8/pyft8.py

{pyft8-2.6.1 → pyft8-2.7.0}/README.md

@@ -22,7 +22,7 @@ If you're interested in how this works, maybe have a look at [MiniPyFT8](https:/
  The Gui shows:
  - Simultaneous views of odd and even cycles
  - Messages overlaid on waterfall signals that produce them
- - Worked-before info and fine grid locators in the message boxes (distance and bearing coming soon)
+ - Worked-before info and fine grid locators / distance and bearing in the message boxes 
  - Band activity on band select buttons
  - Number of remote stations hearing your Tx, number of remote Txs that you're hearing, plus the same info for the 'best' station in your level 4 square
 
@@ -31,8 +31,8 @@ To enable uploading of spots to pskreporter, make sure that your .ini file inclu
 [pskreporter]
 upload = Y
 ```
-<img width="1078" height="436" alt="Capture" src="https://github.com/user-attachments/assets/5c4b64cb-e3e6-4a2f-aa77-93fd361a4e74" />
 
+<img width="980" height="807" alt="screenshot" src="https://github.com/user-attachments/assets/ac393a05-277a-4d98-bd74-78bcb0ae8b03" />
 
 
 ## Motivation

{pyft8-2.6.1 → pyft8-2.7.0}/pyproject.toml

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

pyft8-2.6.1/PyFT8/gui.py

@@ -1,153 +0,0 @@
-import numpy as np
-import matplotlib.pyplot as plt
-import time, queue
-from matplotlib import rcParams
-from matplotlib.animation import FuncAnimation
-from matplotlib.widgets import Slider, Button
-
-rcParams['toolbar'] = 'None'
-# ================== WATERFALL ======================================================
-
-class Scrollbox:
-    def __init__(self, fig, ax, nlines = 5):
-        self.fig, self.ax = fig, ax
-        bbox = ax.get_window_extent().transformed(fig.dpi_scale_trans.inverted())
-        self.fontsize = 0.5 * bbox.height * fig.dpi / nlines
-        self.nlines = nlines
-        self.line_height = 0.9 / nlines
-        self.lines = []
-        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, family="monospace"))
-        self.ax.set_xticks([])
-        self.ax.set_yticks([])
-        self.ax.set_facecolor('black')
-
-    def print(self, text, color = 'white'):
-        self.lines = self.lines[-(self.nlines-1):]
-        self.lines.append({'text':text, 'color':color})
-        for i, line in enumerate(self.lines):
-            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
-        self.onclick = onclick 
-        rect = Rectangle((tbin, fbin), width=w, height=h, alpha=0.6, edgecolor='lime', lw=2)
-        self.patch = ax.add_patch(rect)
-        self.text_inst = ax.text(tbin, fbin+2, '', fontsize='small', fontweight='bold' )
-        self.cid = fig.canvas.mpl_connect('button_press_event', self._onclick)
-        self.expire = 0 
-
-    def set_properties(self, message):
-        self.message = message
-        self.patch.set_x(message.h0_idx)
-        self.text_inst.set_x(message.h0_idx)
-        self.patch.set_visible(True)
-        self.text_inst.set_visible(True)
-        self.expire = message.expire
-
-    def set_appearance(self, message):
-        self.text_inst.set_text(message.gui_text)
-        colors = ['blue', 'white']
-        if message.is_cq: colors = ['green', 'white']
-        if message.is_from_me: colors = ['yellow', 'black']
-        if message.is_to_me: colors = ['red', 'white']
-        self.text_inst.set_color(colors[1])
-        self.patch.set_facecolor(colors[0])
-        
-    def hide_if_expired(self):
-        if time.time() > self.expire > 0:
-            self.patch.set_visible(False)
-            self.text_inst.set_visible(False)
-
-    def _onclick(self, event):
-        b, _ = self.patch.contains(event)
-        if(b):
-            self.onclick(self.message)
-
-class Gui:
-    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 = {}
-        self.decode_queue = queue.Queue()
-        self.pmarg = 0.04
-        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, 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')
-        self.ax_wf = self.fig.add_axes([self.pmarg + wf_left, self.pmarg, 1-2*self.pmarg-wf_left, wf_top-self.pmarg])
-        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_band_stats.text(-0.2,0.75,'Tx')
-        self.ax_band_stats.text(-0.2,0.25,'Rx')
-        if 'station' in config:
-            self.ax_band_stats.set_title(f"Spots to/from {config['station']['grid'][:4]}", fontsize = 10)
-        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)
-
-        if config is not None:
-            styles = {'ctrl':{'fc':'grey','c':'black'}, 'band':{'fc':'green','c':'white'}}
-            button_defs = [{'label':'CQ','style':'ctrl','action':'CQ', 'data':None}, {'label':'Repeat last','style':'ctrl','action':'RPT_LAST','data':None},
-                               {'label':'Tx off','style':'ctrl','action':'TX_OFF', 'data':None}]
-                               #{'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, left_width, 0.002)
-
-    def _make_buttons(self, btn_defs, styles, btns_top, btn_h, btn_w, sep_h):
-        self.buttons = []
-        for i, btn_def in enumerate(btn_defs):
-            btn_axs = plt.axes([self.pmarg, btns_top - (i+1) * btn_h, btn_w, btn_h-sep_h])
-            style = styles[btn_def['style']]
-            btn_widg = Button(btn_axs, '', color=style['fc'], hovercolor='skyblue')
-            btn_widg.user_data = btn_def
-            btn_widg.label = btn_axs.text(0.05, 0.5, btn_def['label'], verticalalignment='center',  horizontalalignment='left',
-                             color = 'white', fontweight = 'bold', transform=btn_axs.transAxes)
-            btn_widg.on_clicked(lambda event, btn_widg=btn_widg: self.on_control_click(btn_widg))
-            self.buttons.append(btn_widg)
-        
-    def add_message_box(self, message):
-        self.decode_queue.put(message)
-
-    def _display_message_box(self, message):
-        h0_idx, f0_idx = message.h0_idx, message.f0_idx
-        if not f0_idx in self.msg_boxes:
-            self.msg_boxes[f0_idx] = Msg_box(self.fig, self.ax_wf, h0_idx, f0_idx, 79*self.hps, 8*self.bpt, onclick = self.on_msg_click)
-        self.msg_boxes[f0_idx].set_properties(message)
-        self.msg_boxes[f0_idx].set_appearance(message)
-        
-    def _tidy_msg_boxes(self):
-        for fb in self.msg_boxes:
-            self.msg_boxes[fb].hide_if_expired()
-
-    def _animate(self, frame):
-        self.image.set_data(self.dBgrid.T)
-        while not self.decode_queue.empty():
-            self._display_message_box(self.decode_queue.get())
-        if (frame % 10 == 0):
-            self._tidy_msg_boxes()
-        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.1/PyFT8/mqtt.py

@@ -1,84 +0,0 @@
-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")
-        
-
-        
-
-    
-
-
-