Hi,
A experimental 1600 bps CODEC2 (used in FreeDV) mode is built using standard GNUradio block's. It's bandwidth is about 2 kHz, it uses BPSK,NRZI, scrambling and HDLC. I write it using GNUradio 3.10 using Pluto as SDR. As HDLC has CRC, no noise is heard. So it is a squelched mode.
Hi,
A experimental 1600 bps CODEC2 (used in FreeDV) mode is built using standard GNUradio block's. It's bandwidth is about 1 kHz, it uses QPSK and HDLC. I write it using GNUradio 3.10 using Pluto as SDR. As HDLC has CRC, no noise is heard. So it is a squelched mode.
Phase ambiguity problem is been solved for QPSK.
Hi,
A GNURadio flowchart was created that do frequency hopping using standard blocks. Initially a saw-tooth frequency hopping is used with progressive increment of sweep rate in order to find the correct delay using a carrier. After it was found, random key generator can be selected and also FreeDV for modulation. It must be noted that delay differs at each running. Also QO100 Doppler frequency must be known. In order for random generator to work, exact delay must be found. Random keys is produced at 1M/sec, so frequency change at this rate. They have 32768 different values leading to 32768 different frequencies. Frequency is spreading to 1 MHz. The hole system is GPSDO based.
Hi,
Direct sequence was added and tested.
Hi,
A direct sequence test Lab flowchart.
Hi,
Later spread spectrum experiments leads to a new possible way of spectrum management in QO100. This it would allocate 1 MHz in our example. Each spread spectrum station would sweep linear (saw-tooth) in this frequency range using for example 10.000 steps. This steps could sweep at 1 M rate. This is made them practically invisible to ordinary users. Each spread spectrum user can view other similar users as constant frequency ones but on different frequency. The difference is due to the propagation delay and different starting of 10.000 numbers seed. So multiple QSO can coexists between spread spectrum users viewing all each other and being together invisible to others normal users. Each spread spectrum user can change his 'frequency' by changing his seed initialization time.
Hi,
A two stations setup was operated successfully using a common RF path. Sample rate has to be adjusted in order to eliminate frequency drift between stations. It is possible for two stations to talk full duplex. Sweep rate is 10 per sec (100.000 numbers seed). In the photo it exists the two signals, one a voice and the other a pilot tone.
Hi,
Flowchart (for receiving) PDF and GRC attached.
Hi,
Independent Rx and Tx with frequency hopping at 1.000.000 hops per second with 10240 different keys is archived. USB is used expanded to 1 MHz. Keys is from Python random generator with seed(0).
Hi,
Monopulse direction finding GNURadio simulation.
It is used also for LEO satellites precise antenna positioning.
Hi,
Monopulse quad antenna array for finding both horizontal and vertical error angles, using GNURadio simulation flowchart.
Hi,
Monopulse RDF operation was verified using GNURadio and a B210 USRP. Using two rubbers at UHF at 17 cm distance (l/4) between them and rotating them, the angle was found. A custom block was used:
def general_work(self, input_items, output_items):
r = 0
if abs(input_items[1][0]) > 0.001:
output_items[0][0] = 2*math.atan(input_items[0][0]/input_items[1][0])
r = 1
self.consume(0,1)
self.consume(1,1)
return r
Hi,
Spectrum analyzer using B210 USRP SDR scanning 32*50 MHz using custom python code.
Hi,
These are the flowchart and GRC file of receiving frequency hopping.
Asked chatgpt: GNUradio python code for usb communication using Pluto for qo100
Here's an example GNU Radio Python code for USB communication with a Pluto SDR for QO-100 satellite operation:
#!/usr/bin/env python
from gnuradio import blocks
from gnuradio import gr
from gnuradio import uhd
import numpy as np
class usrp_source(gr.top_block):
def __init__(self, freq, samp_rate, gain):
gr.top_block.__init__(self, "Pluto Source")
self.u = uhd.usrp_sink(device_addr="", stream_args=uhd.stream_args(cpu_format="fc32", otw_format="sc16", channels=1))
self.u.set_samp_rate(samp_rate)
self.u.set_center_freq(freq, 0)
self.u.set_gain(gain, 0)
self.u.set_antenna("TX/RX", 0)
self.source = blocks.null_source(gr.sizeof_gr_complex * 1)
self.connect(self.source, self.u)
if __name__ == '__main__':
center_freq = 2400e6 # Center frequency of QO-100
samp_rate = 2.4e6 # Sample rate in Hz
gain = 40 # Transmit gain in dB
tb = usrp_source(center_freq, samp_rate, gain)
tb.start()
# Generate a continuous tone at 1 kHz
sample_period = 1 / samp_rate
tone_freq = 1000
samples_per_cycle = int(samp_rate / tone_freq)
sine_wave = np.sin(2 * np.pi * tone_freq * sample_period * np.arange(samples_per_cycle))
while True:
# Send the tone to the Pluto SDR
tb.source.set_data(sine_wave.astype(np.complex64))
In this code, we define a usrp_source class that creates a Pluto SDR source using the UHD library. We set the center frequency to 2400 MHz (the center frequency of QO-100), the sample rate to 2.4 MHz, and the gain to 40 dB. We then create a null source block and connect it to the Pluto SDR source.
Finally, we generate a continuous tone at 1 kHz using NumPy and send it to the Pluto SDR using the set_data method of the null source block. This creates a continuous wave signal that can be transmitted on the QO-100 satellite.
Note that this code is just an example, and you may need to modify it to suit your specific needs.
GNUradio python code for spread spectrum communication using USRP
Here is a sample GNUradio Python code for spread spectrum communication using USRP:
#!/usr/bin/env python
from gnuradio import gr, uhd
from gnuradio import analog
from gnuradio.filter import firdes
class my_top_block(gr.top_block):
def __init__(self):
gr.top_block.__init__(self)
# Set up the USRP source and sink
self.u = uhd.usrp_sink(device_addr="", stream_args=uhd.stream_args(cpu_format="fc32", channels=range(1),),)
self.u.set_samp_rate(1e6)
self.u.set_center_freq(915e6)
self.u.set_gain(10)
self.u.set_antenna("TX/RX")
self.u2 = uhd.usrp_source(device_addr="", stream_args=uhd.stream_args(cpu_format="fc32", channels=range(1),),)
self.u2.set_samp_rate(1e6)
self.u2.set_center_freq(915e6)
self.u2.set_gain(10)
self.u2.set_antenna("TX/RX")
# Generate a random bit stream to be transmitted
self.src = analog.random_source(gr.sizeof_char, 100)
# Convert the bit stream to a complex baseband signal using BPSK modulation
self.mod = analog.modulate_waveform(bpsk_data, 2*np.pi*np.linspace(0, 1, 100))
# Apply direct sequence spread spectrum to the signal
self.spread = np.tile(np.random.randint(0, 2, 100), 10)
self.spread[self.spread == 0] = -1
self.signal = np.multiply(self.mod, self.spread)
# Create a low-pass filter to smooth out the edges of the signal
self.lpfilter = firdes.low_pass(1, 1e6, 100e3, 10e3, firdes.WIN_HAMMING)
# Connect the signal to the USRP sink and source
self.sink = self.u
self.connect(self.src, self.signal, self.lpfilter, self.sink)
self.source = self.u2
self.connect(self.source, self.lpfilter)
if __name__ == '__main__':
try:
my_top_block().run()
except KeyboardInterrupt:
pass
This code generates a random bit stream, applies BPSK modulation to it, and then applies direct sequence spread spectrum using a random spreading code. The resulting spread spectrum signal is then low-pass filtered and transmitted using a USRP sink. The same signal is also received by a USRP source, low-pass filtered, and then processed. Note that this code is just an example and may need to be modified to suit your specific use case.
Hi,
I have involved with artificial intelligence and trying writing software. One idea I have is to use AI to automatically center an SSB receiver. A python code using tensorflow is written that trying to do machine learning in order to archive the result. For learning a set of MP3 files is found from Mozilla and an initial learning is done proving that it can learn. It's own sounds it can predict with an error of about 10-15 Hz. Unknown sounds currently it predicts with an error of about 100 Hz. It seems that errors are mainly from man and woman difference of pitch. As results are depend mainly from samples used for education next steps will be to download more training data and trying to improve it.
Hi,
The current results from artificial intelligence machine learning SSB auto tune, is that with 0.1 sec speach sample, a mean error of 40 Hz is archived. Possible applications except auto tune SSB receiving is SSB automatic voice recording for example on the satellite QO100.
Hi,
does the artificial intelligence understand the speech?
Detlev
