zx/quisk
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Add TX0 samples

Browse Source
This commit is contained in:
James C. Ahlstrom
2026-09-15 15:32:53 -04:00
parent ceab3bed26
commit 2a530e5d11
6 changed files with 302 additions and 123 deletions
Download Patch File Download Diff File Expand all files Collapse all files
microntrxpkg/quisk_hardware.py
+175 -112
View File
@@ -1,24 +1,38 @@
# This provides support for the SDR Micron TRX by David Fainitski, N7DDC
# On Windows this uses Python module ftd2xx. Install with pip.
# On Linux it uses ftdi1. Install python3-ftdi1 with your package manager.
import sys, wx, traceback, time
from quisk_hardware_model import Hardware as BaseHardware
DEBUG = 0 # print debug messages during operation
DEBUG = 1 # print debug messages during operation
WRITE_LOG = 1 # write the data received from the MicronTRX during self.log_time to the file self.log_name
#WRITE_LOG = 2 # receive data from the file self.log_name instead of from USB
# https://github.com/Dfinitski/SDR-Micron
# Control from PC to Micron TRX, 64 bytes, MSB first (big-endian)
# Short Control Packet type "SCP" from PC to Micron TRX, 16 bytes, MSB first (big endian)
#
# (0 - 7) Preamble, seven 0x55 and 0xD5
# (8, 9, 10) "SCP"
#(11) RX0 enable, 0 - 1
#(12) RX1 enable, 0 - 1
#(13) BS0 enable, 0 - 1
#(14) TX0 enable, 0 - 1
#(15) CDC enable, 0 - 1
# Universal control packet type "UCP" from PC to TRX or from TRX to PC, 64 bytes, MSB first (big-endian)
#
# (0 - 7) Preamble, seven 0x55 and 0xD5
# (8, 9, 10) "UCP"
# (11) SN - Sequence Number 0 - 255
# (12) RX0 enable, mode, 0 - off, 1 - 48kHz, 2 - 96kHz, 3 - 192kHz
# (13) RX1 enable, mode, 0 - off, 1 - 48kHz, 2 - 96kHz, 3- 192kHz
# (14) BS0 enable
# (15) BS1 enable
# (16) TX0 enable
# (17) CDC enable
# (11) read only FW prefix MSB
# (12) read only FW prefix
# (13) read only FW prefix LSB
# (14) read only char '-'
# (15) Not used
# (16) Not used
# (17) Not used
# (18, 19, 20, 21) - 4 bytes RX0 frequency
# (22, 23, 24, 25) - 4 bytes RX1 frequency
# (26, 27, 28, 29) - 4 bytes BS0 frequency
@@ -31,38 +45,34 @@ WRITE_LOG = 1 # write the data received from the MicronTRX during self.log_time
# 3 - 384 kHz,
# 4 - 768 kHz,
# 5 - 1536 kHz
# 6 - 1920 kHz
# (36) LNA enable
# (37) TX level 0 - 255
# (38) Not used
# (38) RX BPF bypass 0 - 1
# (39) BS0 mode
# 0 - 4096 buffered samples
# 1 - 8192 buffered samples
# 2 - 16384 buffered samples
# (40) BS1 mode
# 0 - 4096 buffered samples
# 1 - 8192 buffered samples
# 2 - 16384 buffered samples
# (41) BS0 period 50 - 255 ms (100ms is recommended)
# (42) BS1 period 50 - 255 ms (100ms is recommended)
# (40) Not used
# (41) Not used
# (42) read-only PTT state from device 0-1
# (43) Mic Boost, 0 - 1
# (44) Not used
# (45) PTT from PC
# (46) CW mode 0 - 1
# (47) CWX from PC - key manipulation
# (44) TX LPF Bypass 0 - 1
# (45) PTT to device 1 - 0
# (46) CW mode on 0 - 1
# (47) CW key manipulation from PC to device 1 - 0
# (48) Read only PWR, Output power in Watts
# (49) Read only SWR x.x, from 1.0 to 9.9 as a natural number without decimal dot.
# (49) Read only SWR x.x, from 1.0 to 9.9 as a natural number without decimal point
# (50) Key Speed 10 - 63 ppm (20 by default)
# (51) Paddle swap 0, 1
# (52) Key mode, 0 = straight, 01 = Mode A, 10 = Mode B
# (53) Key weight, 33 to 66, (50 by default)
# (54) Key spacing, 0, 1
# (54) Key auto spacing, 0, 1
# (55) ST Level, 0 - 255 sight tone level
# (56) ST Freq MSB- 4 MSB bits
# (57) ST Freq LSB - 8 LSB bits sight tone frequency in Hertz
# (56) ST Freq in tens Hertz, 40 - 100 (400 - 1000Hz), 70 by default
# (57) Not used
# (58) Delay ON, 8 - 255 ms (25 by default) - time for TX carrier delay is needed for transmitter preparing to TX
# (59) Hang out time in tens ms 0 - 255 (0 to 2550 msec) (250 ms by default) needed to keep transmitter ready after PTT
# (60) Not used
# (60) Read only CW key manipulation from device to PC
# (61) Read only FW2 - firmware version MSB
# (62) Read only FW1
# (63) Read only FW0 - firmware version LSB
@@ -76,14 +86,16 @@ WRITE_LOG = 1 # write the data received from the MicronTRX during self.log_time
class Hardware(BaseHardware):
sample_rates = [48] #[48, 96, 192, 384, 768, 1536]
BS1_samples = {0:4096, 1:8192, 2:16384}
BS1_bytes = {0:4096 * 2, 1:8192 * 2, 2:16384 * 2} # Two bytes per sample
BS0_samples = {0:4096, 1:8192, 2:16384}
BS0_bytes = {0:4096 * 2, 1:8192 * 2, 2:16384 * 2} # Two bytes per sample
def __init__(self, app, conf):
BaseHardware.__init__(self, app, conf)
self.usb = None
self.usb_windows = None
self.usb_linux = None
self.prefix = b'\x55\x55\x55\x55\x55\x55\x55\xD5'
self.read_data = bytearray()
self.rf_gain_labels = ('RF 0', 'RF -10', 'RF -20', 'RF -31')
self.tx_samples = b''
self.rf_gain_labels = ('RF 0', 'RF -10', 'RF -20', 'RF -30')
self.index = 1
self.old_vfo = 0
self.sdrmicron_clock = 76800000
@@ -91,37 +103,41 @@ class Hardware(BaseHardware):
self.bscope_data = bytearray()
self.have_version = False
self.frame_msg = ''
self.remaining_BS1 = -1
self.log_name = "microntrx_log.dat"
self.remaining_BS0 = -1
self.log_name = "microntrxpkg/microntrx_log.dat"
self.log_time = 5.0 # seconds of log data
self.log_time0 = None # starting time.time() to start log file
self.log_fp = None
self.pc_control = bytearray(64)
self.pc_control[0:8] = self.prefix
self.pc_control[8:11] = b'UCP'
self.pc_control[34] = 10 # Attenuator, 0 - 31 (dB value)
self.pc_control[35] = 0 # BS0 rate: 0:48ksps, 1:96, 2:192, 3:384, 4:768, 5:1536
self.pc_control[36] = 0 # LNA enable
self.pc_control[39] = 0 # Buffered BS0 samples, 0:4096, 1:8192, 2:16384
self.pc_control[40] = 0 # Buffered BS1 samples, 0:4096, 1:8192, 2:16384
self.pc_control[41] = 100 # BS0 period msec
self.pc_control[42] = 100 # BS1 period msec
self.pc_control[58] = 25 # time for TX carrier delay needed for transmitter preparing to TX, msec
self.pc_control[59] = 25 # tens of msec needed to keep transmitter ready
self.got_defaults = 0
self.pc_enables = bytearray(16)
self.pc_enables[0:8] = self.prefix
self.pc_enables[8:11] = b'SCP'
self.fw_version = bytearray
if conf.fft_size_multiplier == 0:
conf.fft_size_multiplier = 3 # Set size needed by VarDecim
def open(self): # This method must return a string showing whether the open succeeded or failed.
if WRITE_LOG == 1:
self.log_fp = open(self.log_name, "wb")
elif WRITE_LOG == 2:
self.log_fp = open(self.log_name, "rb")
rx_bytes = 3 # rx_bytes is the number of bytes in each I or Q sample: 1, 2, 3, or 4
rx_endian = 1 # rx_endian is the order of bytes in the sample array: 0 == little endian; 1 == big endian
self.InitSamples(rx_bytes, rx_endian) # Initialize: read samples from this hardware file and send them to Quisk
self.InitTxSamples(2, 1, 48000) # Initialize Tx samples to send to the hardware
bs_bytes = 2
bs_endian = 1
self.InitBscope(bs_bytes, bs_endian, self.sdrmicron_clock, self.BS1_samples[self.pc_control[40]]) # Initialize bandscope
if sys.platform == 'win32':
#self.InitBscope(bs_bytes, bs_endian, self.sdrmicron_clock, self.BS1_samples[self.pc_control[40]]) # Initialize bandscope
if WRITE_LOG == 2:
return "Read data from %s" % self.log_name
elif sys.platform == 'win32':
return self.open_win()
return "This code is Windows only"
else:
return self.open_linux()
def open_win(self):
try:
@@ -137,48 +153,84 @@ class Hardware(BaseHardware):
print ("%d: description %s, serial %s" % (i, a['description'], a['serial']))
if a['description']==b'SDR-Micron':
try:
self.usb = d2xx.openEx(a['serial'])
usb = d2xx.openEx(a['serial'])
except:
return 'Device SDR-Micron could not be opened'
self.usb.setBitMode(255, 0) # reset
usb.setBitMode(255, 0) # reset
time.sleep(0.1)
self.usb.setBitMode(255, 64) # Configure FT2232H into Sync FIFO mode
self.usb.setTimeouts(100, 100) # read, write
self.usb.setLatencyTimer(2)
self.usb.setUSBParameters(32, 32) # in_tx_size, out_tx_size
usb.setBitMode(255, 64) # Configure FT2232H into Sync FIFO mode
usb.setTimeouts(100, 100) # read, write
usb.setLatencyTimer(2)
usb.setUSBParameters(32, 32) # in_tx_size, out_tx_size
time.sleep(1.5) # waiting for device initialisation
self.usb.read(self.usb.getQueueStatus()) # clean the usb data buffer
usb.read(usb.getQueueStatus()) # clean the usb data buffer
self.frame_msg = a['description'].decode('utf-8') + ' S/N - ' + a['serial'].decode('utf-8')
self.usb_windows = usb
return self.frame_msg
return 'Device SDR-Micron was not found'
def open_linux(self): # Not finished
try:
import ftdi1 as d2xx
import ftdi1
except:
return 'The ftdi1 module is missing'
self.usb = d2xx.new()
usb = ftdi1.new()
# Open Channel A (interface 1 in libftdi)
d2xx.set_interface(self.usb, d2xx.INTERFACE_A)
rc = d2xx.usb_open(self.usb, 0x0403, 0x6014) # 0x6014 is the standard FT232H PID
ftdi1.set_interface(usb, ftdi1.INTERFACE_A)
rc = ftdi1.usb_open(usb, 0x0403, 0x6014) # 0x6014 is the standard FT232H PID
if rc == 0:
d2xx.usb_reset(self.usb)
d2xx.set_latency_timer(self.usb, 2)
ftdi1.usb_reset(usb)
ftdi1.set_usb_read_timout(usb, 1)
ftdi1.set_usb_write_timout(usb, 5)
ftdi1.set_latency_timer(usb, 2)
# Enable Sync FIFO mode
# 0xFF = pin mask, 0x40 = BITMODE_SYNCFF
d2xx.set_bitmode(self.usb, 0xFF, d2xx.BITMODE_SYNCFF)
ftdi1.set_bitmode(usb, 0xFF, ftdi1.BITMODE_SYNCFF)
if DEBUG:
print("Sync FIFO active via ftdi1.")
# To read at maximum speed, use d2xx.read_data()
d2xx.usb_close(self.usb)
d2xx.free(self.usb)
self.usb_linux = usb
return "Device SDR-Micron opened"
return 'Device SDR-Micron was not found'
def usb_read(self):
if WRITE_LOG == 2:
data = self.log_fp.read(120)
return data
elif self.usb_windows:
count = self.usb_windows.getQueueStatus() # Read all available bytes
if count > 0:
return self.usb_windows.read(count) # return Python bytes
elif self.usb_linux:
count, data = ftdi1.read_data(self.usb_linux, 1024)
if count > 0:
return data # data is Python bytes
elif count < 0 and DEBUG:
print("Error %d in usb_read", count)
return None
def usb_write(self, data):
data = bytes(data) # Convert bytearray to bytes
if self.usb_windows:
try:
self.usb_windows.write(data)
except:
if DEBUG:
print('Error while usb_write')
elif self.usb_linux:
count = ftdi1.write_data(self.usb_linux, data)
if count != len(data) and DEBUG:
print("Failure in usb_write_data %d %d", count, len(data))
def close(self):
if self.usb:
self.usb.setBitMode(255, 0) # reset
if self.usb_windows:
self.usb_windows.setBitMode(255, 0) # reset
time.sleep(0.5)
self.usb.close()
self.usb = None
self.usb_windows.close()
self.usb_windows = None
elif self.usb_linux:
ftdi1.usb_close(self.usb_linux)
ftdi1.free(self.usb_linux)
self.usb_linux = None
def OnButtonRfGain(self, event):
btn = event.GetEventObject()
@@ -190,7 +242,7 @@ class Hardware(BaseHardware):
elif n == 2:
self.pc_control[34] = 20
elif n == 3:
self.pc_control[34] = 31
self.pc_control[34] = 30
if DEBUG:
print ('pc_control[34]', self.pc_control[34])
self.rx_control_upd()
@@ -209,12 +261,15 @@ class Hardware(BaseHardware):
vfo = int(vfo - self.transverter_offset)
if vfo != self.old_vfo:
self.old_vfo = vfo
self.pc_control[26] = (vfo >> 24) & 0xFF # MSB
self.pc_control[27] = (vfo >> 16) & 0xFF
self.pc_control[28] = (vfo >> 8) & 0xFF
self.pc_control[29] = (vfo ) & 0xFF #LSB
self.pc_control[18] = (vfo >> 24) & 0xFF # MSB
self.pc_control[19] = (vfo >> 16) & 0xFF
self.pc_control[20] = (vfo >> 8) & 0xFF
self.pc_control[21] = (vfo ) & 0xFF #LSB
self.rx_control_upd()
return tx_freq, vfo
def OnSpot(self, level):
pass
def VarDecimGetChoices(self): # Return a list/tuple of strings for the decimation control.
return list(map(str, self.sample_rates)) # convert integer to string
@@ -246,37 +301,40 @@ class Hardware(BaseHardware):
return (48000, 48000)
def StartSamples(self): # called by the sound thread
self.pc_control[12] = 1 # RX0 enable
self.pc_control[15] = 1 # BS1 enable
self.rx_control_upd()
if WRITE_LOG:
if self.log_fp is None:
self.log_fp = open(self.log_name, "wb")
self.pc_enables[11] = 1 # RX0 enable
#self.pc_enables[13] = 1 # BS0 enable
self.usb_write(self.pc_enables)
if DEBUG:
print ("Start samples")
def StopSamples(self): # called by the sound thread
self.pc_control[12] = 0
self.pc_control[15] = 0
self.rx_control_upd()
self.pc_enables[11] = 0
self.pc_enables[13] = 0
self.usb_write(self.pc_enables)
if DEBUG:
print ("Stop Samples")
def rx_control_upd(self):
if self.usb:
try:
self.usb.write(self.pc_control)
except:
print('Error while rx_control_upd')
if self.pc_control[11] < 255: # sequence number
self.pc_control[11] += 1
else:
self.pc_control[11] = 0
if self.got_defaults:
self.usb_write(self.pc_control)
def GetRxSamples(self): # Read from the MicronTRX. Called frequently from the sound thread.
if not self.usb:
return
count = self.usb.getQueueStatus() # Read all available bytes
if count > 0:
data = bytearray(self.usb.read(count))
# Send Tx samples to the hardware
self.tx_samples += self.GetTxSamples()
while len(self.tx_samples) >= 492:
data = self.prefix + b'TX0\x00\x00\x00\x00\x00' + self.tx_samples[0:492]
self.usb_write(data)
#print(data[0:24], len(data))
#i = data[16] << 8 | data[17]
#print ("%8d" % i)
self.tx_samples = self.tx_samples[492:]
# Read messages from USB
data = self.usb_read()
if data:
self.read_data += data
if WRITE_LOG:
if DEBUG > 1:
print("Read %s bytes, buffer length %d" % (len(data), len(self.read_data)))
if WRITE_LOG == 1:
if self.log_fp:
if self.log_time0 is None:
self.log_time0 = time.time()
@@ -299,28 +357,28 @@ class Hardware(BaseHardware):
if block_type == b'BS0':
if len(self.read_data) < 508:
return
del self.read_data[0:508]
elif block_type == b'BS1':
if len(self.read_data) < 508:
return
packet_number = self.read_data[12]
packet_number = self.read_data[11]
if packet_number == 0: # start of a block of data
self.remaining_BS1 = self.BS1_bytes[self.pc_control[40]]
self.remaining_BS0 = self.BS0_bytes[self.pc_control[39]]
self.bscope_data = self.read_data[16:508] # 492 bytes
self.remaining_BS1 -= 492
elif self.remaining_BS1 >= 492:
self.remaining_BS0 -= 492
elif self.remaining_BS0 >= 492:
self.bscope_data += self.read_data[16:508] # 492 bytes
self.remaining_BS1 -= 492
elif self.remaining_BS1 <= 0:
self.remaining_BS0 -= 492
elif self.remaining_BS0 <= 0:
pass
else:
self.bscope_data += self.read_data[16:self.remaining_BS1 + 16]
self.remaining_BS1 = -1
self.bscope_data += self.read_data[16:self.remaining_BS0 + 16]
self.remaining_BS0 = -1
# self.AddBscopeSamples(self.bscope_data)
if DEBUG > 1:
print("BS0 buffer length %d" % len(self.bscope_data))
del self.read_data[0:508]
elif block_type == b'CDM':
if len(self.read_data) < 180:
return
if DEBUG > 1:
print("CDM")
del self.read_data[0:180]
elif block_type == b'RX0':
if len(self.read_data) < 508:
@@ -328,24 +386,29 @@ class Hardware(BaseHardware):
if self.read_data[12]:
self.GotClip()
self.AddRxSamples(self.read_data[16:508])
if DEBUG > 1:
print("RX0")
del self.read_data[0:508]
elif block_type == b'RX1':
if len(self.read_data) < 508:
return
if DEBUG > 1:
print("RX1")
del self.read_data[0:508]
elif block_type == b'SBL':
if len(self.read_data) < 32:
return
del self.read_data[0:32]
elif block_type == b'UCP':
if len(self.read_data) < 64:
return
if self.have_version is False:
self.have_version = True
self.frame_msg += ' F/W version - %d.%d' % (self.read_data[61], self.read_data[63])
self.fw_version = self.read_data[11:15] + self.read_data[61:64]
self.frame_msg += ' F/W version - ' + self.fw_version.decode('utf-8')
self.application.main_frame.SetConfigText(self.frame_msg)
self.pc_control[11:64] = self.read_data[11:64] # save UCP content with defaults
self.got_defaults = 1;
if DEBUG > 1:
print("UCP")
del self.read_data[0:64]
else:
del self.read_data[0:8]
del self.read_data[0:11]
if DEBUG:
print("Unknown USB block type")