PyFT8 2.12.2__tar.gz → 3.0.0__tar.gz

{pyft8-2.12.2 → pyft8-3.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PyFT8
-Version: 2.12.2
+Version: 3.0.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
@@ -35,26 +35,20 @@ If you're interested in how this works, maybe have a look at [MiniPyFT8](https:/
  - Finds sound cards by keywords so follows them if windows moves them ...
  - Logs QSOs to ADIF file and all spots to WSJTX-style ALL.txt file
  - Uploads spots to pskreporter
- - Direct CAT control for some rigs, designed to drop connection when not used, allowing sharing of rig's serial port
- - Or control rigs via Hamlib
+ - Control rigs via Hamlib
 
  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 / distance and bearing in the message boxes
- - List of stations hearing your transmissions on the selected band
+ - List of stations hearing your transmissions on the selected band, alternating with list of stations you're hearing. On these lists, 'new' callsigns (first heard since program launch) are in white font.
  - Marker on message if 2nd call is hearing you
  - Band activity in your level 4 square live updated next to 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
  - Data used for the above is cached to disk so is not lost when restarting the program
 
-To enable uploading of spots to pskreporter, make sure that your .ini file includes
-```
-[pskreporter]
-upload = Y
-```
+<img width="997" height="1025" alt="screenshot" src="https://github.com/user-attachments/assets/88228f65-c39e-45ee-9f73-1d85138563f3" />
 
-![screenshot](screenshot.png)
 
 ## Motivation
 This started out as me thinking "How hard can it be, really?" after some frustration with Windows moving sound devices around and wanting to get a minimal decoder running that I can fully control. 
@@ -68,7 +62,7 @@ If you want to install this software without getting into the code, you can inst
 pip install PyFT8
 ```
 
-Once installed, you can use the following commands to run it. Otherwise, please download or browse the code, or fork the repo and play with it! If you do fork it, please check back here as I'm constantly (as of Jan 2026) rewriting and improving.
+Once installed, you can use the following commands to run it. Otherwise, please download or browse the code, or fork the repo and play with it! If you do fork it, please check back here as I'm constantly (as of April 2026) rewriting and improving.
 
 The use cases below are the ones held in the test cases at the bottom of the main pyft8.py file. Where a config folder and .ini file is required, if you leave off the '-c {folder}' option, you'll be asked if you want to create a .ini file in the current directory.
 
@@ -82,30 +76,19 @@ The use cases below are the ones held in the test cases at the bottom of the mai
 | Command line create a wav file | pyft8 -w "Mywav.wav" -m "CQ G1OJS IO90"| No config folder / .ini file required |
 
 ### Rig control 
-I've included the Python code that I use with my Icom IC-7100 in the file 'rigctrl.py', and believe I've moved sufficient 'specification' for the rig protocol into the .ini file so that you can paste in your own rig specification (see for e.g. the Omnirig .ini file for your rig) and get it working with PyFT8 controlling PTT and frequency. I designed this code to drop the serial connection when it's not required, so that the rig's serial port can be accessed by other software at the same time (assuming that the other software returns the favour and doesn't permanently hog the serial port).
-
-I've also included a basic Hamlib interface which launches rigctld and uses that to control the rig. To use this, make sure that the hamlib section of the ini file is populated; this will then take precedence over the direct CAT control section.
-
-Alternatively, you can run PyFT8 without rig control; if there is no rig found, PyFT8 defaults to running without a rig connected. In this case, you need to provide your own PTT method and note that the band buttons will only set the information used for logging QSOs to the PyFT8.adi file. Or you can use PyFT8 as Rx-only.
+I designed PyFT8 to be minimal as far as possible, and it needs very limited control of the rig in order to transmit. However, whilst previous versions used direct CAT control and Hamlib as a fallback, Version 3.0.0 moves to Hamlib as the only interface.
 
 ## Customising
-Even if you don't want to edit the code, there's quite a bit that you can change in the .ini file. I haven't written a user guide yet, so here's my own .ini file for reference. I use CAT control so my hamlib block is disabled by adding a _ to the name of the block (I keep it there for testing only). I need to add some more switches really to catch up with recent additions.
+Even if you don't want to edit the code, there's quite a bit that you can change in the .ini file. I haven't written a user guide yet, so here's my own .ini file for reference. You'll note that my instance of rigctld is in C:/WSJT/wsjtx/bin/rigctld-wsjtx, but any rigctld should also work. PyFT8 launches this if it's not already running (to be precise, it launches it if it can't open a socket on localhost:4532).
 
 ```
 [station]
 call = G1OJS
-grid = IO90******
+grid = IO******
 [gui]
 loc = km_deg
 wb = Y
-[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
-[_hamlib_rig]
+[hamlib_rig]
 rigctld = C:/WSJT/wsjtx/bin/rigctld-wsjtx
 port = COM4
 baud_rate = 9600
@@ -128,7 +111,8 @@ upload = Y
 
 The image below shows the number of decodes from PyFT8, WSJT-x V2.7.0 running in NORM mode, and FT8_lib, using the same 10 minutes of busy 20m audio that is used to test ft8_lib. 
 
-![performance snapshot](performance%20snapshot.png)
+<img width="640" height="480" alt="performance snapshot" src="https://github.com/user-attachments/assets/b62221ec-2d74-4fbc-9c61-34b2bbc0e963" />
+
 
 ## Limitations
 PyFT8 doesn't decode / encode *all* message types. The table below shows which are handled.

{pyft8-2.12.2 → pyft8-3.0.0}/PyFT8/databases.py

@@ -2,6 +2,7 @@ from PyFT8.pskreporter import PSKR_MQTT_listener
 import threading, time, os, pickle, json
 
 call_hashes = {}
+
 def add_call_hashes(call):
     global call_hashes
     chars = " 0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ/"
@@ -64,37 +65,39 @@ class DiskDict:
         with self.lock:        
             if(os.path.exists(self.file)):
                 with open(f"{self.file}","rb") as f:
-                    self.data = json.load(f)
+                    try:
+                        self.data = json.load(f)
+                    except:
+                        pass
 
     def save(self):
         with self.lock:
-            tmp_file = f"{self.file}.tmp"
-            with open(tmp_file, "w") as f:
-                json.dump(self.data, f)
-                f.flush()
-                os.fsync(f.fileno())
-            os.replace(tmp_file, self.file)
+            with open(self.file, "w") as f:
+                try:
+                    json.dump(self.data, f)
+                except:
+                    pass
 
 class History:
     def __init__(self, config_folder, my_call, home_square, pskr_refresh_mins, parse_all_file):
-        self.t0 = 1775324204
         self.pskr_refresh_mins = pskr_refresh_mins
         self.config_folder = config_folder
         self.my_call = my_call
         self.home_square = home_square
         self.home_square_lev4 = home_square[:4]
+        self.freqs_to_bands = {}
         self.dist_brg_cache = {}
         self.hearing_me = DiskDict(f"{self.config_folder}/hearing_me.json", 3)   # all-time record of hearing me
         self.heard_by_me = DiskDict(f"{self.config_folder}/heard_by_me.json", 5) # all-time record of heard by me
         self.hearing_me_new = {}
         self.heard_by_me_new = {}
         self.call_to_grid = DiskDict(f"{self.config_folder}/call_to_grid.json", 7) # all time cache call -> fine locator
-        self.band_TxRx_homecall_report_times = DiskDict(f"{self.config_folder}/report_times.json", 9) # last 20 mins data -> per band tx/rx & current band detail
+        self.band_TxRx_homecall_recent_l4grid = DiskDict(f"{self.config_folder}/recent_l4grid.json", 9) # last 20 mins data -> per band tx/rx & current band detail
         self.home_activity = {}
         self.home_most_remotes = {}
         self.lock = threading.Lock()
         if parse_all_file:
-            self.load_all_file(f"{self.config_folder}/ALL.txt")
+            self.load_hearing_heard_from_all_file(f"{self.config_folder}/ALL.txt")
             self.hearing_me.save()
             self.heard_by_me.save()
             print("All file parsed and saved to hearing_me / heard_by_me files")
@@ -102,29 +105,29 @@ class History:
             mqtt = PSKR_MQTT_listener(self.home_square_lev4, self.add_mqtt_spot)
             threading.Thread(target = self.count_activity, daemon = True).start()
 
-    def band_from_MHz(self, fMHz): # rewrite this to use the band button defs from ini file
-        f = int(fMHz)
-        if f > 0:
-            freqs = [1,3,5,7,10,14,18,21,24,28,50,144,433]
-            idx = freqs.index(f) if f in freqs else -1
-            if idx > -1:
-                return ['160m','80m','60m','40m','30m','20m','17m','15m','12m','10m','6m','2m','70cm'][idx]
-
-    def load_from_wb(self, log_cache):
+    def set_bands(self, bands):
+        for b in bands:
+            f = float(bands[b])
+            self.freqs_to_bands[round(f,1)] = b
+            
+    def load_hearing_heard_from_adif(self, log_cache):
         for key in log_cache:
             key_parts = key.split('_')
             if len(key_parts) > 1:
                 c, b, m = key_parts
                 if m == 'FT8':
+                    #print(f"Parsing adif log: Add hearing & heard by {c} on {b}")
                     self.add_myspots_record(self.hearing_me.data, None, b, c, 0, 0)
                     self.add_myspots_record(self.heard_by_me.data, None, b, c, 0, 0)
+                else:
+                    print(m)
 
-    def load_all_file(self, all_file):
+    def load_hearing_heard_from_all_file(self, all_file):
         recs = self.parse_all_txt(all_file)
         if not any(recs): return
         for r in recs:
             if r['md'] == 'FT8':
-                band = self.band_from_MHz(r['fMHz'])
+                band = self.freqs_to_bands.get(round(r['fMHz'], 1), None)
                 if band is not None:
                     TxRx = 'Tx' if (r['TxRx'] == 'Tx' or r['call_b'] == self.my_call) else 'Rx'
                     call = r['call_b'] if TxRx == 'Rx' else r['call_a']
@@ -175,8 +178,8 @@ class History:
             self.call_to_grid.data[call] = grid
         
     def add_homespots_record(self, key, t):
-        self.band_TxRx_homecall_report_times.data.setdefault(key, [])
-        self.band_TxRx_homecall_report_times.data[key].append(int(t-self.t0))
+        self.band_TxRx_homecall_recent_l4grid.data.setdefault(key, [])
+        self.band_TxRx_homecall_recent_l4grid.data[key].append(int(t))
 
     def add_myspots_record(self, historic_data, new_alert_data, band, call, t, rp):
         self._update_new_alert(band, call, historic_data, new_alert_data)
@@ -223,29 +226,29 @@ class History:
                     self.home_most_remotes[b] = [('Nobody',0), ('Nobody',0)]
 
                 # keep only the remote spots that happened in the self.pskr_refresh_mins window
-                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() - self.t0 - t) < 60*self.pskr_refresh_mins]
-                    self.band_TxRx_homecall_report_times.data[band_TxRx_homecall] = band_TxRx_homecall_report_times
+                for band_TxRx_homecall in self.band_TxRx_homecall_recent_l4grid.data:
+                    band_TxRx_homecall_recent_l4grid = self.band_TxRx_homecall_recent_l4grid.data[band_TxRx_homecall]
+                    band_TxRx_homecall_recent_l4grid = [t for t in band_TxRx_homecall_recent_l4grid if (time.time() - t) < 60*self.pskr_refresh_mins]
+                    self.band_TxRx_homecall_recent_l4grid.data[band_TxRx_homecall] = band_TxRx_homecall_recent_l4grid
 
                 # count number of local Tx and Rx, and identify the local Tx and Rx with most remote spots
-                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):
+                for band_TxRx_homecall in self.band_TxRx_homecall_recent_l4grid.data:
+                    band_TxRx_homecall_recent_l4grid = self.band_TxRx_homecall_recent_l4grid.data[band_TxRx_homecall]
+                    if len(band_TxRx_homecall_recent_l4grid):
                         b, iTxRx, c = band_TxRx_homecall.split('_')
                         iTxRx = int(iTxRx)
                         self.home_activity.setdefault(b, [0, 0])
                         self.home_activity[b][iTxRx] +=1
                         self.home_most_remotes.setdefault(b, [('Nobody',0), ('Nobody',0)])
-                        nremotes = len(band_TxRx_homecall_report_times)
+                        nremotes = len(band_TxRx_homecall_recent_l4grid)
                         current_winner = self.home_most_remotes[b][iTxRx]
                         if nremotes > current_winner[1]:
                             if c != self.my_call:
                                 self.home_most_remotes[b][iTxRx] = (c, nremotes)
 
     def get_spot_counts(self, band, call):
-        tx_reports = self.band_TxRx_homecall_report_times.data.get(f"{band}_0_{call}", [])
-        rx_reports = self.band_TxRx_homecall_report_times.data.get(f"{band}_1_{call}", [])
+        tx_reports = self.band_TxRx_homecall_recent_l4grid.data.get(f"{band}_0_{call}", [])
+        rx_reports = self.band_TxRx_homecall_recent_l4grid.data.get(f"{band}_1_{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
@@ -298,6 +301,10 @@ class ADIF:
         import calendar
         def parse(rec, field):
             p = rec.find(field)
+            if p<0:
+                p = rec.find(field.upper())
+            if p<0:
+                p = rec.find(field.lower())
             if p > 0:
                 p1, p2 = rec.find(':',p), rec.find('>',p)
                 n = int(rec[p1+1:p2])
@@ -307,8 +314,9 @@ class ADIF:
             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')
-                    time_tuple = time.strptime(d+t, "%Y%m%d%H%M%S")
-                    tm = calendar.timegm(time_tuple)
-                    cache[c] = tm
-                    cache[c + "_"+b+"_FT8"] = tm
+                    if c and b and d and t:
+                        time_tuple = time.strptime(d+t, "%Y%m%d%H%M%S")
+                        tm = calendar.timegm(time_tuple)
+                        cache[c] = tm
+                        cache[c + "_"+b+"_FT8"] = tm
         return cache

{pyft8-2.12.2 → pyft8-3.0.0}/PyFT8/pyft8.py

@@ -9,13 +9,13 @@ from PyFT8.pskreporter import PSKR_upload
 from PyFT8.gui import Gui
 from PyFT8.transmitter import AudioOut
 from PyFT8.time_utils import global_time_utils
-from PyFT8.rigctrl import Rig_CAT, Rig_hamlib
+from PyFT8.rigctrl import Rig_hamlib
 from PyFT8.databases import History, ADIF
 
-VER = '2.12.2'
+VER = '3.0.0'
 
 MAX_TX_START_SECONDS = 2.5
-HEARING_PANEL_LIFE_MINS = 5
+HEARING_PANEL_LIFE_MINS = 20
 PSKR_REFRESH_MINS = 20
 config_folder, rig, gui, qso, adif_logging, history, pskr_upload, output_device_idx = None, None, None, None, None, None, None, None
 busy_profile, hearing_me = None, None
@@ -38,9 +38,6 @@ def get_config():
         config['bands'] = {'20m':14.074}
         config['gui'] = {'loc':'km_deg', 'wb':'Y'}
         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'}
         config['pskreporter'] = {'upload':'Y'}
         with open(ini_file, 'w') as f:
             config.write(f)
@@ -57,7 +54,7 @@ class Message:
             mycall = qso.mStation['c']
         self.h0_idx, self.f0_idx, self.msg_tuple, self.msg, self.snr, self.dt, self.fHz = c.h0_idx, c.f0_idx, c.msg_tuple, c.msg, c.snr, c.dt, c.fHz
         self.cyclestart = c.cyclestart
-        self.expire = time.time() + 29.8
+        self.expire = time.time() + 29.25
         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')
@@ -351,9 +348,6 @@ def cli():
     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_CAT(config)
 
     if args.outputcard_keywords:
         outputcard_keywords = args.outputcard_keywords.replace(' ','').split(',')
@@ -378,8 +372,9 @@ def cli():
     if not args.no_gui:
         gui = Gui(audio_in.dBgrid_main, 4, 2, config, on_gui_sidebars_refresh, on_gui_msg_click, on_gui_control_click)
         history = History(config_folder, mc, mg, PSKR_REFRESH_MINS, args.parse_all_file)
+        history.set_bands(config['bands'])
         adif_logging = ADIF(f"{config_folder}/PyFT8.adi")
-        history.load_from_wb(adif_logging.cache)
+        history.load_hearing_heard_from_adif(adif_logging.cache)
 
     if mc is not None and 'pskreporter' in config.keys():
         if config['pskreporter']['upload'] == 'Y':

pyft8-3.0.0/PyFT8/rigctrl.py

@@ -0,0 +1,43 @@
+import time, socket, subprocess, threading
+
+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}"
+        self.sock = None
+        if not self.create_socket(host, port):
+            threading.Thread(target = subprocess.run, args = (cmd,)).start()
+            time.sleep(0.5)
+            if not self.create_socket(host, port):
+                print(f"Couldn't create socket for hamlib on {host}:{port}")
+        self.set_mode("PKTUSB")
+
+    def create_socket(self, host, port):
+        try:
+            self.sock = socket.create_connection((host, port))
+        except:
+            return False
+        return True
+
+    def cmd(self, command):
+        if self.sock:
+            self.sock.sendall((command + "\n").encode())
+            return self.sock.recv(1024).decode()
+
+    def set_mode(self, mode):
+        self.cmd(f"M {mode} 0")
+
+    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")
+
+

{pyft8-2.12.2 → pyft8-3.0.0}/PyFT8.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PyFT8
-Version: 2.12.2
+Version: 3.0.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
@@ -35,26 +35,20 @@ If you're interested in how this works, maybe have a look at [MiniPyFT8](https:/
  - Finds sound cards by keywords so follows them if windows moves them ...
  - Logs QSOs to ADIF file and all spots to WSJTX-style ALL.txt file
  - Uploads spots to pskreporter
- - Direct CAT control for some rigs, designed to drop connection when not used, allowing sharing of rig's serial port
- - Or control rigs via Hamlib
+ - Control rigs via Hamlib
 
  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 / distance and bearing in the message boxes
- - List of stations hearing your transmissions on the selected band
+ - List of stations hearing your transmissions on the selected band, alternating with list of stations you're hearing. On these lists, 'new' callsigns (first heard since program launch) are in white font.
  - Marker on message if 2nd call is hearing you
  - Band activity in your level 4 square live updated next to 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
  - Data used for the above is cached to disk so is not lost when restarting the program
 
-To enable uploading of spots to pskreporter, make sure that your .ini file includes
-```
-[pskreporter]
-upload = Y
-```
+<img width="997" height="1025" alt="screenshot" src="https://github.com/user-attachments/assets/88228f65-c39e-45ee-9f73-1d85138563f3" />
 
-![screenshot](screenshot.png)
 
 ## Motivation
 This started out as me thinking "How hard can it be, really?" after some frustration with Windows moving sound devices around and wanting to get a minimal decoder running that I can fully control. 
@@ -68,7 +62,7 @@ If you want to install this software without getting into the code, you can inst
 pip install PyFT8
 ```
 
-Once installed, you can use the following commands to run it. Otherwise, please download or browse the code, or fork the repo and play with it! If you do fork it, please check back here as I'm constantly (as of Jan 2026) rewriting and improving.
+Once installed, you can use the following commands to run it. Otherwise, please download or browse the code, or fork the repo and play with it! If you do fork it, please check back here as I'm constantly (as of April 2026) rewriting and improving.
 
 The use cases below are the ones held in the test cases at the bottom of the main pyft8.py file. Where a config folder and .ini file is required, if you leave off the '-c {folder}' option, you'll be asked if you want to create a .ini file in the current directory.
 
@@ -82,30 +76,19 @@ The use cases below are the ones held in the test cases at the bottom of the mai
 | Command line create a wav file | pyft8 -w "Mywav.wav" -m "CQ G1OJS IO90"| No config folder / .ini file required |
 
 ### Rig control 
-I've included the Python code that I use with my Icom IC-7100 in the file 'rigctrl.py', and believe I've moved sufficient 'specification' for the rig protocol into the .ini file so that you can paste in your own rig specification (see for e.g. the Omnirig .ini file for your rig) and get it working with PyFT8 controlling PTT and frequency. I designed this code to drop the serial connection when it's not required, so that the rig's serial port can be accessed by other software at the same time (assuming that the other software returns the favour and doesn't permanently hog the serial port).
-
-I've also included a basic Hamlib interface which launches rigctld and uses that to control the rig. To use this, make sure that the hamlib section of the ini file is populated; this will then take precedence over the direct CAT control section.
-
-Alternatively, you can run PyFT8 without rig control; if there is no rig found, PyFT8 defaults to running without a rig connected. In this case, you need to provide your own PTT method and note that the band buttons will only set the information used for logging QSOs to the PyFT8.adi file. Or you can use PyFT8 as Rx-only.
+I designed PyFT8 to be minimal as far as possible, and it needs very limited control of the rig in order to transmit. However, whilst previous versions used direct CAT control and Hamlib as a fallback, Version 3.0.0 moves to Hamlib as the only interface.
 
 ## Customising
-Even if you don't want to edit the code, there's quite a bit that you can change in the .ini file. I haven't written a user guide yet, so here's my own .ini file for reference. I use CAT control so my hamlib block is disabled by adding a _ to the name of the block (I keep it there for testing only). I need to add some more switches really to catch up with recent additions.
+Even if you don't want to edit the code, there's quite a bit that you can change in the .ini file. I haven't written a user guide yet, so here's my own .ini file for reference. You'll note that my instance of rigctld is in C:/WSJT/wsjtx/bin/rigctld-wsjtx, but any rigctld should also work. PyFT8 launches this if it's not already running (to be precise, it launches it if it can't open a socket on localhost:4532).
 
 ```
 [station]
 call = G1OJS
-grid = IO90******
+grid = IO******
 [gui]
 loc = km_deg
 wb = Y
-[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
-[_hamlib_rig]
+[hamlib_rig]
 rigctld = C:/WSJT/wsjtx/bin/rigctld-wsjtx
 port = COM4
 baud_rate = 9600
@@ -128,7 +111,8 @@ upload = Y
 
 The image below shows the number of decodes from PyFT8, WSJT-x V2.7.0 running in NORM mode, and FT8_lib, using the same 10 minutes of busy 20m audio that is used to test ft8_lib. 
 
-![performance snapshot](performance%20snapshot.png)
+<img width="640" height="480" alt="performance snapshot" src="https://github.com/user-attachments/assets/b62221ec-2d74-4fbc-9c61-34b2bbc0e963" />
+
 
 ## Limitations
 PyFT8 doesn't decode / encode *all* message types. The table below shows which are handled.

{pyft8-2.12.2 → pyft8-3.0.0}/README.md

@@ -16,26 +16,20 @@ If you're interested in how this works, maybe have a look at [MiniPyFT8](https:/
  - Finds sound cards by keywords so follows them if windows moves them ...
  - Logs QSOs to ADIF file and all spots to WSJTX-style ALL.txt file
  - Uploads spots to pskreporter
- - Direct CAT control for some rigs, designed to drop connection when not used, allowing sharing of rig's serial port
- - Or control rigs via Hamlib
+ - Control rigs via Hamlib
 
  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 / distance and bearing in the message boxes
- - List of stations hearing your transmissions on the selected band
+ - List of stations hearing your transmissions on the selected band, alternating with list of stations you're hearing. On these lists, 'new' callsigns (first heard since program launch) are in white font.
  - Marker on message if 2nd call is hearing you
  - Band activity in your level 4 square live updated next to 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
  - Data used for the above is cached to disk so is not lost when restarting the program
 
-To enable uploading of spots to pskreporter, make sure that your .ini file includes
-```
-[pskreporter]
-upload = Y
-```
+<img width="997" height="1025" alt="screenshot" src="https://github.com/user-attachments/assets/88228f65-c39e-45ee-9f73-1d85138563f3" />
 
-![screenshot](screenshot.png)
 
 ## Motivation
 This started out as me thinking "How hard can it be, really?" after some frustration with Windows moving sound devices around and wanting to get a minimal decoder running that I can fully control. 
@@ -49,7 +43,7 @@ If you want to install this software without getting into the code, you can inst
 pip install PyFT8
 ```
 
-Once installed, you can use the following commands to run it. Otherwise, please download or browse the code, or fork the repo and play with it! If you do fork it, please check back here as I'm constantly (as of Jan 2026) rewriting and improving.
+Once installed, you can use the following commands to run it. Otherwise, please download or browse the code, or fork the repo and play with it! If you do fork it, please check back here as I'm constantly (as of April 2026) rewriting and improving.
 
 The use cases below are the ones held in the test cases at the bottom of the main pyft8.py file. Where a config folder and .ini file is required, if you leave off the '-c {folder}' option, you'll be asked if you want to create a .ini file in the current directory.
 
@@ -63,30 +57,19 @@ The use cases below are the ones held in the test cases at the bottom of the mai
 | Command line create a wav file | pyft8 -w "Mywav.wav" -m "CQ G1OJS IO90"| No config folder / .ini file required |
 
 ### Rig control 
-I've included the Python code that I use with my Icom IC-7100 in the file 'rigctrl.py', and believe I've moved sufficient 'specification' for the rig protocol into the .ini file so that you can paste in your own rig specification (see for e.g. the Omnirig .ini file for your rig) and get it working with PyFT8 controlling PTT and frequency. I designed this code to drop the serial connection when it's not required, so that the rig's serial port can be accessed by other software at the same time (assuming that the other software returns the favour and doesn't permanently hog the serial port).
-
-I've also included a basic Hamlib interface which launches rigctld and uses that to control the rig. To use this, make sure that the hamlib section of the ini file is populated; this will then take precedence over the direct CAT control section.
-
-Alternatively, you can run PyFT8 without rig control; if there is no rig found, PyFT8 defaults to running without a rig connected. In this case, you need to provide your own PTT method and note that the band buttons will only set the information used for logging QSOs to the PyFT8.adi file. Or you can use PyFT8 as Rx-only.
+I designed PyFT8 to be minimal as far as possible, and it needs very limited control of the rig in order to transmit. However, whilst previous versions used direct CAT control and Hamlib as a fallback, Version 3.0.0 moves to Hamlib as the only interface.
 
 ## Customising
-Even if you don't want to edit the code, there's quite a bit that you can change in the .ini file. I haven't written a user guide yet, so here's my own .ini file for reference. I use CAT control so my hamlib block is disabled by adding a _ to the name of the block (I keep it there for testing only). I need to add some more switches really to catch up with recent additions.
+Even if you don't want to edit the code, there's quite a bit that you can change in the .ini file. I haven't written a user guide yet, so here's my own .ini file for reference. You'll note that my instance of rigctld is in C:/WSJT/wsjtx/bin/rigctld-wsjtx, but any rigctld should also work. PyFT8 launches this if it's not already running (to be precise, it launches it if it can't open a socket on localhost:4532).
 
 ```
 [station]
 call = G1OJS
-grid = IO90******
+grid = IO******
 [gui]
 loc = km_deg
 wb = Y
-[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
-[_hamlib_rig]
+[hamlib_rig]
 rigctld = C:/WSJT/wsjtx/bin/rigctld-wsjtx
 port = COM4
 baud_rate = 9600
@@ -109,7 +92,8 @@ upload = Y
 
 The image below shows the number of decodes from PyFT8, WSJT-x V2.7.0 running in NORM mode, and FT8_lib, using the same 10 minutes of busy 20m audio that is used to test ft8_lib. 
 
-![performance snapshot](performance%20snapshot.png)
+<img width="640" height="480" alt="performance snapshot" src="https://github.com/user-attachments/assets/b62221ec-2d74-4fbc-9c61-34b2bbc0e963" />
+
 
 ## Limitations
 PyFT8 doesn't decode / encode *all* message types. The table below shows which are handled.

{pyft8-2.12.2 → pyft8-3.0.0}/pyproject.toml

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

pyft8-2.12.2/PyFT8/rigctrl.py

@@ -1,102 +0,0 @@
-import serial, time, socket, subprocess, threading
-
-class Rig_CAT:
-    def __init__(self, config, verbose = False):
-        self.serial_port = False
-        self.port = config['rig']['port']
-        self.baud_rate = config['rig']['baud_rate']
-        self.ptt_on_cmd = self.parse_configstr(config['rig']['ptt_on_command']) if config['rig']['ptt_on_command']else None
-        self.ptt_off_cmd = self.parse_configstr(config['rig']['ptt_off_command']) if config['rig']['ptt_off_command'] else None
-        self.set_freq_cmd = self.parse_configstr(config['rig']['set_freq_command']) if config['rig']['set_freq_command'] else None
-        self.set_freq_value = config['rig']['set_freq_value'] if config['rig']['set_freq_value'] else None
-        self.verbose = verbose
-
-    def parse_configstr(self, configstr):
-        if "." in configstr:
-            hexstr = configstr.replace(".", "")
-            return bytearray.fromhex(hexstr)
-        else:
-            return bytearray(configstr.encode())
-        
-    def vprint(self, text):
-        if self.verbose:
-            print(text)
-
-    def _sendCAT(self, msg):
-        try:
-            self.serial_port = serial.Serial(port = self.port, baudrate = self.baud_rate, timeout = 0.1)
-        except Exception as e:
-            print(f"[CAT] couldn't open {self.port}: {e}")
-        if (self.serial_port):
-            self.serial_port.reset_input_buffer()
-            self.vprint(f"[CAT] send {msg.hex(' ')}")
-            try:
-                self.serial_port.write(msg)
-                time.sleep(0.05)
-                self.serial_port.close()
-            except Exception as e:
-                print(f"[CAT] couldn't send CAT command {msg} on {self.port}: {e}")
-
-    def set_freq_Hz(self, freqHz):
-        if self.set_freq_cmd and self.set_freq_value:
-            self.vprint(f"[CAT] SET frequency to {freqHz} Hz")
-            start, length, fmt, mult, offset = self.set_freq_value.split("|")
-            start, length, mult, offset = int(start), int(length), int(mult), int(offset)
-            fVal = freqHz * mult + offset
-            nDigits = length if fmt == "text" else 2*length
-            s = f"{fVal:0{nDigits}d}"
-            if fmt=='text':
-                fBytes = s.encode()
-            else:
-                pairs = [(int(s[i]) << 4) | int(s[i+1]) for i in range(0, len(s), 2)]
-                if fmt == "vfBcdLU":
-                    fBytes = bytes(pairs[::-1])
-                else:
-                    fBytes = bytes(pairs)
-            cmd = bytearray(self.set_freq_cmd)
-            cmd[start:start+length] = fBytes
-            if fmt.startswith("vfBcd"):  # CI-V
-                cmd = b'\x00' + cmd
-            self._sendCAT(cmd)
-
-    def ptt_on(self):
-        if self.ptt_on_cmd:
-            self.vprint(f"[CAT] PTT On")
-            self._sendCAT(self.ptt_on_cmd)
-
-    def ptt_off(self):
-        if self.ptt_off_cmd:
-            self.vprint(f"[CAT] PTT Off")
-            self._sendCAT(self.ptt_off_cmd)
-
-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()