Posts by SV1BDS


    I use Greek speech to check error and the same performance exists.

    By the way, the current mean error is dropped to about 32 Hz.

    Hi Detlev,

    In this case it is not understand the speech. It gives attention how to predict the frequency shift. The frequency prediction range is -300 to +300 Hz. Now I have train it with English voices and one of the tests it will be to test it with other languages. Also the time that give it to the model is now 0.1 sec which is too small to understand speech. Generally speaking it tries to predict what it is trained to do. In my case it is trained to predict the frequency shift.


    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.


    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.

    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):


    # 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.u2 = uhd.usrp_source(device_addr="", stream_args=uhd.stream_args(cpu_format="fc32", channels=range(1),),)





    # 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__':



    except KeyboardInterrupt:


    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.

    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_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)


    # 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


    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.


    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



    return r


    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).


    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.


    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.