PyFT8 2.12.3__tar.gz → 3.0.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PyFT8
-Version: 2.12.3
+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,14 +35,13 @@ 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
@@ -63,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.
 
@@ -77,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

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

@@ -80,7 +80,6 @@ class DiskDict:
 
 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
@@ -93,12 +92,12 @@ class History:
         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")
@@ -123,7 +122,7 @@ class History:
                 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:
@@ -179,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)
@@ -227,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

{pyft8-2.12.3 → 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.3'
+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)
@@ -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(',')

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.3 → pyft8-3.0.0}/PyFT8.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PyFT8
-Version: 2.12.3
+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,14 +35,13 @@ 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
@@ -63,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.
 
@@ -77,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

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

@@ -16,14 +16,13 @@ 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
@@ -44,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.
 
@@ -58,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

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

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

pyft8-2.12.3/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()