Remove wheel tester.

Merge mouse wheel logic.

afedrinet/afedrinet_io.c

@@ -128,10 +128,10 @@ static PyObject * open_rx_udp(const char * ip, int port)
 			shutdown(rx_udp_socket, QUISK_SHUT_BOTH);
 			close(rx_udp_socket);
 			rx_udp_socket = INVALID_SOCKET;
-			sprintf(buf, "Failed to connect to UDP %s port %u", ip, port);
+			snprintf(buf, sizeof(buf), "Failed to connect to UDP %s port %u", ip, port);
 		}
 		else {
-			sprintf(buf, "Capture from UDP %s port %u", ip, port);
+			snprintf(buf, sizeof(buf), "Capture from UDP %s port %u", ip, port);
 #if DEBUG_IO
 			if (getsockopt(rx_udp_socket, SOL_SOCKET, SO_RCVBUF, (char *)&intbuf, &bufsize) == 0)
 			{

configure.py

@@ -727,17 +727,6 @@ class Configuration:
         count -= 1
     return count
 
-class xxConfigHelp(wx.html.HtmlWindow):	# The "Help with Radios" first-level page
-  """Create the help screen for the configuration tabs."""
-  def __init__(self, parent):
-    wx.html.HtmlWindow.__init__(self, parent, -1, size=(win_width, 100))
-    if "gtk2" in wx.PlatformInfo:
-      self.SetStandardFonts()
-    self.SetFonts("", "", [10, 12, 14, 16, 18, 20, 22])
-    self.SetBackgroundColour(parent.bg_color)
-    # read in text from file help_conf.html in the directory of this module
-    self.LoadFile('help_conf.html')
-
 class QPowerMeterCalibration(wx.Frame):
   """Create a window to enter the power output and corresponding ADC value AIN1/2"""
   def __init__(self, parent, local_names):

docs.html

@@ -307,6 +307,7 @@ These are part of your operating system. You only install them once unless it ch
 </p>
 <br>
 <pre>
+sudo apt-get install gcc
 sudo apt-get install libfftw3-dev
 sudo apt-get install libasound2-dev
 sudo apt-get install portaudio19-dev

makefile

@@ -56,7 +56,7 @@ $(OBJDIR):
 	@mkdir -p $(OBJDIR)
 
 # Link the shared library object
-$(TARGET): $(OBJS)
+$(TARGET): $(OBJS) ac2yd/remote.o
 	$(CC) -o $@ $(OBJS) ac2yd/remote.o $(LDFLAGS)
 
 # Define the location for dependency files

quisk.c

@@ -4830,7 +4830,7 @@ static PyObject * set_multirx_mode(PyObject * self, PyObject * args)
 
 	if (!PyArg_ParseTuple (args, "ii", &index, &mode))
 		return NULL;
-	if (index < QUISK_MAX_SUB_RECEIVERS)
+	if (index >= 0 && index < QUISK_MAX_SUB_RECEIVERS)
 		multirx_mode[index] = mode;
 	Py_INCREF (Py_None);
 	return Py_None;
@@ -4842,7 +4842,7 @@ static PyObject * set_multirx_freq(PyObject * self, PyObject * args)
 
 	if (!PyArg_ParseTuple (args, "ii", &index, &freq))
 		return NULL;
-	if (index < QUISK_MAX_SUB_RECEIVERS)
+	if (index >= 0 && index < QUISK_MAX_SUB_RECEIVERS)
 		multirx_freq[index] = freq;
 	Py_INCREF (Py_None);
 	return Py_None;
@@ -4860,7 +4860,7 @@ static PyObject * set_multirx_play_channel(PyObject * self, PyObject * args)
 {
 	if (!PyArg_ParseTuple (args, "i", &multirx_play_channel))
 		return NULL;
-	if (multirx_play_channel >= QUISK_MAX_SUB_RECEIVERS)
+	if (multirx_play_channel < 0 || multirx_play_channel >= QUISK_MAX_SUB_RECEIVERS)
 		multirx_play_channel = -1;
 	Py_INCREF (Py_None);
 	return Py_None;
@@ -5638,6 +5638,10 @@ static void measure_freq(complex double * cSamples, int nSamples, int srate)
 			ipeak = i;
 		}
 	}
+	if (ipeak < 1)
+		ipeak = 1;
+	else if (ipeak > fft_size - 2)
+		ipeak = fft_size - 2;
 	c3 = 1.36 * (fft_average[ipeak+1] - fft_average[ipeak - 1]) / (fft_average[ipeak-1] + fft_average[ipeak] + fft_average[ipeak+1]);
 	freq = srate * (2 * (ipeak + c3) - fft_size) / 2 / fft_size;
 	freq += rx_tune_freq;
@@ -6006,6 +6010,8 @@ static PyObject * record_app(PyObject * self, PyObject * args)
 	}
 	// Initialize plan for multirx FFT
 	multirx_fft_width = multirx_data_width * MULTIRX_FFT_MULT;		// Use larger FFT than graph size
+	if (multirx_fft_next_samples)
+		free(multirx_fft_next_samples);
 	multirx_fft_next_samples = (fftw_complex *)malloc(multirx_fft_width * sizeof(fftw_complex));
 	multirx_fft_next_plan = quisk_create_or_cache_fftw_plan_dft_1d(multirx_fft_width, multirx_fft_next_samples, multirx_fft_next_samples, FFTW_FORWARD, FFTW_MEASURE);
 	if (current_graph)

quisk.py

@@ -39,6 +39,7 @@ from filters import Filters
 import dxcluster
 import configure
 import quisk_conf_defaults as conf
+import quisk_utils
 import quisk_wdsp
 
 for name in configure.name2format:      # Add defaults. These may be overwritten by a user config file.
@@ -2584,7 +2585,7 @@ class GraphScreen(wx.Window):
     else:
       self.mouse_is_rx = False
     if self.mouse_is_rx:
-      freq = application.rxFreq + self.VFO + wm * event.GetWheelRotation() // event.GetWheelDelta()
+      freq = application.rxFreq + self.VFO + quisk_utils.wheel_step(event.GetWheelRotation(), event.GetWheelDelta(), wm)
       if conf.freq_spacing:
         freq = self.FreqRound(freq, 0)
       elif freq >= 0:
@@ -2594,7 +2595,7 @@ class GraphScreen(wx.Window):
       tune = freq - self.VFO
       self.ChangeHwFrequency(self.txFreq, self.VFO, 'MouseWheel', event=event, rx_freq=tune)
     else:
-      freq = self.txFreq + self.VFO + wm * event.GetWheelRotation() // event.GetWheelDelta()
+      freq = self.txFreq + self.VFO + quisk_utils.wheel_step(event.GetWheelRotation(), event.GetWheelDelta(), wm)
       if conf.freq_spacing:
         freq = self.FreqRound(freq, 0)
       elif freq >= 0:
@@ -3662,8 +3663,8 @@ class HelpScreen(wx.html.HtmlWindow):
     if "gtk2" in wx.PlatformInfo:
       self.SetStandardFonts()
     self.SetFonts("", "", [10, 12, 14, 16, 18, 20, 22])
-    # read in text from file help.html in the directory of this module
-    self.LoadFile('help.html')
+    if not self.LoadFile('help.html'):
+      self.LoadFile('/usr/share/doc/quisk/help.html')
   def OnGraphData(self, data):
     pass
   def ChangeYscale(self, y_scale):

quisk_conf_defaults.py

@@ -172,6 +172,22 @@ tx_level = {}
 # This is the maximum value of the slider.
 digital_tx_level = 100
 
+################ Receivers SuperPuper SDR, by UT3MK and US5NCJ 
+## hardware_file_name		Hardware file path, rfile
+# This is the file that contains the control logic for each radio.
+#hardware_file_name = 'ut3mkpkg/quisk_hardware.py'
+
+## widgets_file_name			Widget file path, rfile
+# This optional file adds additional controls for the radio.
+#widgets_file_name = ''
+
+## sdr1000_serial_port			Serial port, text
+# This is serial Port for the synthesizer, usually /dev/ttyUSBn on Linux or COMn on Win
+sdr1000_serial_port = "/dev/ttyUSB0"
+
+## sdr1000_serial_rate			Serial baud rate, integer
+# This is baud rate for the synthesizer.
+sdr1000_serial_rate = 57600
 
 
 ################ Receivers HiQSDR, The original N2ADR and HiQSDR radios.
@@ -425,7 +441,7 @@ hermes_PTT_hang_time = 4
 # This option only applies to the Hermes Lite 2. Set this to None if you don't have a tuner.
 # Set this to "Tune" to control the Icom AH-4 compatible ATU attached to the Hermes Lite 2 end plate.
 # Note that this option only applies to the HL2 end plate, not the IO board.
-# A tuner attached to the IO board is controlled from a button on the last line of the screen.
+# A tuner attached to the IO board is controlled from a button on the last line of the screen.
 # Then when the Spot button is pressed with a positive power, a tune request is sent to the ATU.
 # If the Spot button is pressed with a zero power level, the tuner is set to bypass mode.
 # Changes are immediate (no need to restart).

quisk_utils.py

@@ -1,6 +1,29 @@
 from __future__ import print_function
 from __future__ import division
 
+
+def wheel_step(rotation, delta, step):
+  """Convert signed wheel rotation into configured frequency steps.
+
+  A measured downward event reported rotation=-180 with delta=120. Scaling
+  that by a 50 Hz step gives -75 Hz; flooring the resulting absolute frequency
+  made downward tuning jump -100 Hz while upward tuning moved only +50 Hz.
+  Round the wheel units symmetrically first: +/-180 now gives +/-50 Hz, while
+  +/-240 still gives +/-100 Hz rather than being collapsed to one step.
+  """
+  if delta == 0:
+    return 0
+  rotation = int(rotation)
+  delta = int(delta)
+  step = int(step)
+  direction = -1 if rotation * delta < 0 else 1
+  whole_steps, remainder = divmod(abs(rotation), abs(delta))
+  if remainder * 2 > abs(delta):
+    whole_steps += 1
+
+  return direction * whole_steps * step
+
+
 class SplineInterpolator:	# From Numerical Recipes in C
   """Interpolate a table of [x, y] values."""
   def __init__(self, table, Xmin=None, Xmax=None):

quisk_vna.py

@@ -26,6 +26,7 @@ import threading, webbrowser
 import _quisk as QS
 from quisk_widgets import *
 import configure
+import quisk_utils
 
 DEBUG = 0
 
@@ -630,7 +631,7 @@ class GraphScreen(wx.Window):
       mouse_x, mouse_y = self.GetMousePosition(event)
       self.SetTxFreq(index=mouse_x - self.originX)
   def OnWheel(self, event):
-    tune = self.display.tune_tx + event.GetWheelRotation() // event.GetWheelDelta()
+    tune = self.display.tune_tx + quisk_utils.wheel_step(event.GetWheelRotation(), event.GetWheelDelta(), 1)
     self.SetTxFreq(index=tune)
 
 class HelpScreen(wx.html.HtmlWindow):
@@ -640,8 +641,8 @@ class HelpScreen(wx.html.HtmlWindow):
     if "gtk2" in wx.PlatformInfo:
       self.SetStandardFonts()
     self.SetFonts("", "", [10, 12, 14, 16, 18, 20, 22])
-    # read in text from file help.html in the directory of this module
-    self.LoadFile('help_vna.html')
+    if not self.LoadFile('help_vna.html'):
+      self.LoadFile('/usr/share/doc/quisk/help_vna.html')
   def OnLinkClicked(self, link):
     webbrowser.open(link.GetHref(), new=2)
 

ut3mkpkg/README.txt

@@ -0,0 +1,2 @@
+This directory has files for the SDR-1000 clone synthesizer by
+UT3MK and US5NCJ

ut3mkpkg/__init__.py

@@ -0,0 +1 @@
+#

ut3mkpkg/quisk_hardware.py

@@ -0,0 +1,523 @@
+# -*- coding: utf-8 -*-
+
+
+from __future__ import print_function
+import serial, time, logging
+import re
+import _quisk as QS
+import quisk_conf_defaults as conf
+import sys, wx, traceback
+
+
+# ── ПОСЛЕДОВАТЕЛЬНЫЙ ПОРТ ДЛЯ CAT ───────────────────────────────────
+sdr1000_serial_port = "/dev/ttyUSB0"  # Windows: "COM3"  /  Linux: "/dev/ttyUSB0"
+sdr1000_serial_rate = 57600          # PowerSDR CAT: до 115200
+
+# ── ЛОГ ────────────────────────────────────────────────────────────
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s  %(levelname)-5s  %(message)s",
+    datefmt="%H:%M:%S",
+)
+log = logging.getLogger("SDR1000")
+
+Mode2Index = {'CWL':0, 'CWU':1, 'LSB':2, 'USB':3, 'AM':4,
+      'FM':5, 'EXT':6, 'DGT-U':7, 'DGT-L':8, 'DGT-IQ':9,
+      'IMD':10, 'FDV-U':11, 'FDV-L':12, 'DGT-FM':13}
+
+# ── КЛАСС УПРАВЛЕНИЯ ЖЕЛЕЗОМ ────────────────────────────────────────
+from quisk_hardware_model import Hardware as BaseHardware
+
+class Hardware(BaseHardware):
+    """
+    Quisk Hardware-класс для FlexRadio SDR-1000.
+    Использует CAT-команды протокола PowerSDR (ZZ + Kenwood).
+    """
+    # Буфер для приема данных с com-порта
+    serialbuf = '';
+
+    # Буфер для отправки команд на com-порт
+    cmdbuf = '';
+
+    # Буфер отправки IF
+    statusbuf ='';
+    statussending = False;
+
+    # Сопоставление размера шагов
+    STEP_MAP =  {
+        '1':   '0000', '10':  '0001', '50':  '1000', '100':  '0010',
+        '250': '1001', '500': '1010', '1k':  '0011', '5k':   '1011',
+        '9k':  '1100', '10k': '0100', '100k':'0101', '1M':   '0110',
+        '10M': '0111',
+    }
+
+    STEP_VAL = {
+        '1':    1,
+        '10':   10,
+        '50':   50,
+        '100':  100,
+        '250':  250,
+        '500':  500,
+        '1k':   1000,
+        '5k':   5000,
+        '9k':   9000,
+        '10k':  10000,
+        '100k': 100000,
+        '1M':   1000000,
+        '10M':  10000000,
+    }
+
+    # STEP_ENA = ['1', '10', '50', '100', '250', '500', '1k', '5k', '10k', '100k' ]
+    STEP_ENA = [ '10', '50', '100', '250', '500', '1k', '5k', '10k', '100k' ]
+
+    BAND_ENA = ['80', '40', '30', '20', '17', '15', '12', '10']
+
+    watchdog = 0
+    watchdog_limit = 100
+
+    # Сопоставление режимов Quisk → код MD (PowerSDR/Kenwood)
+    # TODO
+    
+    MODE_MAP = {
+        'LSB':  '1',  'USB':  '2',  'CWU':   '3',  'FM':  '4',
+        'AM':   '5',  'DGT-L':  '6',  'CWL':  '7',  
+        # Quisk-специфичные → стандартные
+        'DGT-U':'2', 'FMN':  '4',  'AMN': '5',
+        'DGT-FM':  '4',  'FDV-U':'2',  'FDV-L':'1',
+        'FSK' : '9', 'FSKR' : '2', 
+    }
+
+    def __init__(self, app, conf):
+        BaseHardware.__init__(self, app, conf)
+        self.ser = None
+        self.current_freq = 0
+        self.current_vfo = 0
+        self.current_mode = 'USB'
+        self.current_band = '80'
+        self.current_step = '50'
+        self.rf_gain_labels = ('RF -20', 'RF -10', 'RF 0', 'RF +10' )
+        self.current_pre = 0
+        self.current_ritfreq = 0
+        self.rit_active = False
+        self.ptt_active = False
+
+    # ── Открытие/закрытие ────────────────────────────────────────────
+
+    def open(self):
+        """Вызывается один раз при старте Quisk."""
+
+        try:
+            self.ser = serial.Serial(
+                sdr1000_serial_port,
+                sdr1000_serial_rate,
+                timeout=0, xonxoff=True,
+            )
+            log.debug("SDR-1000: COM-порт открыт %s @ %d",
+                     sdr1000_serial_port, sdr1000_serial_rate)
+        except serial.SerialException as e:
+            log.error("SDR-1000: не удалось открыть порт: %s", e)
+            self.ser = None
+            return "SDR-1000: ошибка порта %s" % sdr1000_serial_port
+
+        msg = "SDR-1000 подключен (%s, %s)" % (
+            sdr1000_serial_port, "PowerSDR")
+        return msg
+
+    def close(self):
+        """Вызывается один раз при завершении Quisk."""
+        if self.ptt_active:
+            self.ser.cmdbuf += 'RX;'     # снять передачу
+
+        if self.ser and self.ser.is_open:
+            self.cmdbuf = ''
+            self.ser.flush
+            self.ser.close()
+            log.debug("SDR-1000: порт закрыт")
+
+    # ── Низкоуровневый CAT-обмен ────────────────────────────────────
+
+    def _cat(self):
+        """
+        Вызываться будет периодически для чтения порта
+        """
+        if not self.ser or not self.ser.is_open:
+            return ""
+
+        try:
+            #self.ser.write(frame)
+            if self.ser.in_waiting > 0:
+                sdata = self.ser.read(size=self.ser.in_waiting)
+                self.serialbuf += sdata.decode('ascii')
+            else:
+                self.watchdog += 1
+            if self.watchdog > self.watchdog_limit:
+                log.debug("Watchdog! Resetting arduino")
+                self.ser.dtr = 0
+                time.sleep(0.1)
+                self.ser.dtr = 1
+                self.ser.flush
+                self.ser.close()
+                time.sleep(0.1)
+                try:
+                    self.ser = serial.Serial(
+                    sdr1000_serial_port,
+                    sdr1000_serial_rate,
+                    timeout=0, xonxoff=True,
+                    )
+                    log.debug("SDR-1000: COM-порт открыт %s @ %d",
+                    sdr1000_serial_port, sdr1000_serial_rate)
+                except serial.SerialException as e:
+                    log.error("SDR-1000: не удалось открыть порт: %s", e)
+                    self.ser = None
+                    return "SDR-1000: ошибка порта %s" % sdr1000_serial_port
+                self.ser.flushInput()
+                self.ser.flushOutput()
+                self.watchdog = 0
+
+
+            ans = ''
+            while ';' in self.serialbuf:
+                cmds = self.serialbuf.partition(';')
+
+                cmd = cmds[0]
+                self.serialbuf = cmds[-1]
+                # log.info("Splitted to %s and %s", cmd, self.serialbuf)
+                if len(cmd) > 0:
+                    answer = ''
+                    cmddone = 0
+                    match cmd:
+                        case 'IF':
+                            # Запрос полного статуса
+                            # Возврат в statusbuf
+                            self.statusbuf = self.ReturnInfo()
+                            log.debug("Status refresh, buf: %s", self.serialbuf)
+                            cmddone = 1
+                        case 'ZZSM0':
+                            # Запрос показаний S-метра
+                            ans = self.ReturnSmeterA()
+                            log.debug("S-meter refresh, buf: %s", ans)
+                            cmddone = 1
+                        case 'PS1':
+                            # Включение
+                            ans = 'PS1;'
+                            log.debug("PowerON, buf: %s", ans)
+                            cmddone = 1
+                        case 'ZZPA':
+                            # Запрос показаний PRE ! TODO смена режима
+                            ans = self.ReturnPre()
+                            log.debug("PRE answer, buf: %s", ans)
+                            cmddone = 1
+                        case 'UP':
+                            # Запрос на увеличение частоты
+                            self.application.ChangeHwFrequency(9000,
+                                self.current_vfo+self.STEP_VAL[self.current_step])
+                            cmddone = 1
+                        case 'DN':
+                            # Запрос на уменьшение частоты
+                            self.application.ChangeHwFrequency(9000,
+                                self.current_vfo-self.STEP_VAL[self.current_step])
+                            cmddone = 1
+                        case 'ZZSU':
+                            # Запрос на увеличение шага
+                            self.StepInc()
+                            cmddone = 1
+                        case 'ZZSD':
+                            # Запрос на уменьшение шага
+                            self.StepDec()
+                            cmddone = 1
+                        case 'BU':
+                            # Запрос смены диапазона
+                            self.BandUp()
+                            cmddone = 1
+                        case 'BD':
+                            # Запрос смены диапазона
+                            self.BandDn()
+                            cmddone = 1
+                        case 'TX':
+                            # Transmit
+                            QS.set_PTT(1)
+                            self.ptt_active = True
+                            log.info("PTT ON")
+                            cmddone = 1
+                        case 'RX':
+                            # Recieve
+                            QS.set_PTT(0)
+                            self.ptt_active = False
+                            log.info("PTT OFF")
+                            cmddone = 1
+                            
+                        case 'ZZQR':
+                            # Запрос восстановление QuickSave
+                            cmddone = 1
+
+                    if len(cmd) > 4 and not cmddone:
+                        log.debug("Try to match cmd: %s, buf: %s", cmd[0:4], self.serialbuf)
+                        match cmd[0:4]:
+                            case 'ZZPA':
+                                # Запрос изменения PRE
+                                self.SetPre(cmd)
+                                ans = self.ReturnPre()
+                                log.debug("PRE set, buf: %s", ans)
+                                cmddone = 1
+                            case 'ZZMD':
+                                # Запрос изменения режима
+                                self.SetMode(cmd)
+                                log.debug("Mode set, buf: %s", cmd)
+                                cmddone = 1
+                            case 'FA00':
+                                # Запрос изменения частоты
+                                self.SetFreq(cmd)
+                                log.debug("Freq set, buf: %s", cmd)
+                                cmddone = 1
+                    if not cmddone:
+                        log.info("unknown cmd: %s, buf: %s", cmd, self.serialbuf)
+                        ans = '?;'
+                    if len(ans) > 0:
+                        log.debug("Sending answer, buf: %s", ans)
+                        self.ser.write(ans.encode('ascii'))
+
+            if len(self.serialbuf) == 0:
+                if len(self.cmdbuf) > 0:
+                    cmds = self.cmdbuf.partition(';')
+                    cmd = cmds[0]
+                    self.cmdbuf = cmds[-1]
+                    log.debug("Sending cmd %s, buf: %s", cmd, self.cmdbuf)
+                    self.ser.write(cmd.encode('ascii'))
+            if (len(self.statusbuf) > 0) and not self.statussending:
+                self.statussending = True
+                log.debug("Sending status, buf: %s", self.statusbuf)
+                self.ser.write(self.statusbuf.encode('ascii'))
+                self.statusbuf = ''
+                self.statussending = False
+
+        # End of CAT
+        except Exception as e:
+            log.error("SDR-1000 CAT error: %s", e)
+            return ""
+
+    @staticmethod
+    def _fmt_freq(hz):
+        """Частота → 11 цифр: 14200000 → '00014200000'."""
+        return "%011d" % int(hz)
+
+    # ── Quisk API: частота ──────────────────────────────────────────
+
+    def ChangeFrequency(self, tune, vfo, source='', band='', event=None):
+        """Quisk вызывает при смене частоты. Возвращает (tune, vfo)."""
+        if tune and tune != self.current_freq:
+            self.current_freq = tune
+            self.current_vfo = tune-9000
+            if re.search('FA\\d{11};', self.cmdbuf,0):
+                log.debug("--> RE MATCH")
+                re.sub('FA\\d{11};', "FA" + self._fmt_freq(tune)+";", self.cmdbuf, 1)
+            # self.cmdbuf += ("FA" + self._fmt_freq(tune)+";")
+            else:
+                self.cmdbuf += ("FA" + self._fmt_freq(tune)+";")
+            log.debug("VFO A → %d Hz (%.6f MHz)", self.current_vfo, self.current_freq / 1e6)
+        return self.current_freq, self.current_vfo
+
+    def ReturnInfo(self):
+        ritstr = self.application.ritFreq
+        if ritstr >= 0:
+            ritsign = "+"
+        else:
+            ritsign = ""
+        answer = "IF%011d%4s%s%05d%01d0000%01d%1s0000000;" % (
+            self.current_freq, self.STEP_MAP[self.current_step],
+            ritsign,ritstr,self.application.ritButton.GetValue(),
+            self.ptt_active,self.MODE_MAP[self.current_mode])
+        # log.info(answer)
+        return answer
+
+    def ReturnSmeterA(self):
+        i = round((self.application.smeter_db + 67) * 2)
+        if i < 0:
+            i = 0
+        elif i > 260:
+            i = 260
+        answer = "ZZSM0%03d;" % ( i )
+        # log.info(answer)
+        return answer
+
+    def ReturnPre(self):
+        answer = "ZZPA%01d;" % ( self.current_pre )
+        return answer
+
+    def SetPre(self, precmd):
+        if len(precmd) == 5:
+            match precmd:
+                case 'ZZPA0': i = 0
+                case 'ZZPA1': i = 1
+                case 'ZZPA2': i = 2
+                case 'ZZPA3': i = 3
+                case _: i = 0
+            self.current_pre = i
+
+    def SetFreq(self, freqcmd):
+        if len(freqcmd) == 13:
+            newfreq = int(freqcmd[2:])
+            log.info("Request to change freq: %d", newfreq)
+            self.current_vfo=newfreq-9000
+            self.application.ChangeHwFrequency(9000, self.current_vfo)
+    
+    def OnButtonRfGain(self, event):
+        btn = event.GetEventObject()
+        n = btn.index
+        self.current_pre = n
+        self.cmdbuf += ("ZZPA%1d;" % self.current_pre)
+        
+    def SetMode(self, modecmd):
+        if len(modecmd) == 6:
+            log.info("Request to change mode: %s", modecmd[4:])
+            match modecmd[4:]:
+                
+                # 00 = LSB  =>  LSB
+                # 01 = USB  =>  USB
+                # 02 = DSB  =>  USB
+                # 03 = CWL  =>  CW
+                # 04 = CWU  =>  CW
+                # 05 = FMN  =>  FMN
+                # 06 = AM   =>  AM
+                # 07 = DIGU =>  FSKR
+                # 08 = SPEC =>  AMN
+                # 09 = DIGL =>  FSK
+                # 10 = SAM  =>  USB
+                # 11 = DRM  =>  USB
+                
+                case '00': newmode = 'LSB'
+                case '01': newmode = 'USB'
+                case '02': newmode = 'USB'
+                case '03': newmode = 'CWL'
+                case '04': newmode = 'CWU'
+                case '05': newmode = 'FM'
+                case '06': newmode = 'AM'
+                case '07': newmode = 'DGT-U'
+                case '08': newmode = 'AM'
+                case '09': newmode = 'DGT-L'
+                case '10': newmode = 'USB'
+                case '11': newmode = 'USB'
+                case _: newmode = 'USB'
+            self.current_mode = newmode
+            self.application.mode = self.current_mode
+            self.application.MakeFilterButtons(self.application.Mode2Filters(self.current_mode))
+            QS.set_rx_mode(Mode2Index.get(self.current_mode, 3))
+            if self.current_mode == 'CWL':
+                self.application.SetRit(conf.cwTone)
+            elif self.current_mode == 'CWU':
+                self.application.SetRit(-conf.cwTone)
+            else:
+                self.application.SetRit(0)
+            if self.current_mode in ('CWL', 'CWU'):
+                self.application.SetFilterByMode('CW')
+            elif self.current_mode in ('LSB', 'USB'):
+                self.application.SetFilterByMode('SSB')
+            elif self.current_mode == 'AM':
+                self.application.SetFilterByMode('AM')
+            elif self.current_mode[0:2] == 'FM':
+                self.application.SetFilterByMode('FM')
+            elif self.current_mode[0:4] == 'DGT-':
+                self.application.SetFilterByMode('DGT')
+            self.application.sliderSquelch.DeleteSliderWindow()
+            
+            if self.current_mode == 'FM':
+                self.application.sliderSquelch.SetSlider(self.application.levelSquelch)
+            else:
+                self.application.sliderSquelch.SetSlider(self.application.levelSquelchSSB)
+            self.application.OnBtnSquelch()
+            if self.current_mode not in ('FDV-L', 'FDV-U'):
+                self.application.graph.SetDisplayMsg()
+                self.application.waterfall.SetDisplayMsg()
+            self.application.SetTxAudio()
+            
+    def StepInc(self):
+        i = self.STEP_ENA.index(self.current_step)
+        log.debug("Found index of %s, idx: %d", self.current_step, i)
+        if i < (len(self.STEP_ENA)-1):
+            self.current_step = self.STEP_ENA[i + 1]
+            log.debug("Step changed to %s, idx: %d", self.current_step, i+1)
+        else: 
+            log.debug("Step not changed, remain %s", self.current_step)
+
+
+    def StepDec(self):
+        i = self.STEP_ENA.index(self.current_step)
+        log.info("Found index of %s, idx: %d", self.current_step, i)
+        if i > 0:
+            self.current_step = self.STEP_ENA[i - 1]
+            log.debug("Step changed to %s, idx: %d", self.current_step, i-1)
+        else: 
+            log.debug("Step not changed, remain %s", self.current_step)
+
+    def BandUp(self):
+        i = self.BAND_ENA.index(self.current_band)
+        log.debug("Found index of %s, idx: %d", self.current_band, i)
+        if i < (len(self.BAND_ENA)-1):
+            self.current_band = self.BAND_ENA[i + 1]
+        else:
+            self.current_band = self.BAND_ENA[0]
+        log.info("Band changed to %s, idx: %d", self.current_band, i)
+        vfo, tune, mode = self.application.bandState[self.current_band]
+        self.application.ChangeHwFrequency(9000, vfo+tune)
+
+    def BandDn(self):
+        i = self.BAND_ENA.index(self.current_band)
+        log.debug("Found index of %s, idx: %d", self.current_band, i)
+        if i > 0:
+            self.current_band = self.BAND_ENA[i - 1]
+        else:
+            self.current_band = self.BAND_ENA[len(self.BAND_ENA)-1]
+        log.info("Band changed to %s, idx: %d", self.current_band, i)
+        vfo, tune, mode = self.application.bandState[self.current_band]
+        self.application.ChangeHwFrequency(9000, vfo+tune)
+
+    def ReturnFrequency(self):
+        """Опрос ~10 Гц. Возвращает (tune, vfo) или (None, None)."""
+        # SDR-1000 не сообщает частоту сам, поэтому возвращаем None
+        return None, None
+
+    # ── Quisk API: режим ─────────────────────────────────────────────
+
+    def ChangeMode(self, mode):
+        """Quisk вызывает при смене режима. mode: 'USB', 'CW', и т.д."""
+        # Нормализуем DGT-* → USB
+        # if mode.startswith('DGT'):
+        #     mode = 'USB'
+        code = self.MODE_MAP.get(mode)
+        if not code:
+            log.warning("Неизвестный режим Quisk: %s → по умолчанию USB", mode)
+            code = '2'
+        self.cmdbuf += ("MD" + code+';')
+        self.current_mode = mode
+        log.debug("Режим → %s (MD%s)", mode, code)
+
+    # ── Quisk API: диапазон ─────────────────────────────────────────
+
+    def ChangeBand(self, band):
+        """Quisk вызывает при смене диапазона. band: '160', '80', …"""
+        BaseHardware.ChangeBand(self, band)
+        log.info("Диапазон → %s м", band)
+
+    # ── Quisk API: PTT ──────────────────────────────────────────────
+
+    def OnButtonPTT(self, event=None):
+        """Quisk вызывает при нажатии/отпускании PTT."""
+        if event:
+            self.ptt_active = bool(event.GetEventObject().GetValue())
+        #self._cat("ZZTX%d" % (1 if self.ptt_active else 0))
+        log.debug("PTT %s", "ON" if self.ptt_active else "OFF")
+
+    # ── Quisk API: HeartBeat (~10 Гц) ───────────────────────────────
+
+    def HeartBeat(self):
+        """Периодический опрос — можно использовать для синхронизации."""
+        self._cat()
+
+    def FastHeartBeat(self):    # Called frequently by the GUI thread
+        pass
+
+    # ── Quisk API: TUNE ─────────────────────────────────────────────
+
+    def OnBtnFDX(self, is_fdx):
+        """Кнопка FDX (полный дуплекс)."""
+        log.debug("FDX → %s", is_fdx)
+