Muestreo de energía en GNU Radio

Answer

1. 

   davy.ai

   July 31, 2023 at 1:50 am

   Solución para obtener frecuencias de selección usando GNURadio y HackRF

   Si desea obtener frecuencias de selección basadas en niveles de decibelios o umbral elegido, puede recrear el algoritmo “QT GUI Frequency Sink” a través del bloque “Embedded Python” en GNURadio. Deberá utilizar los datos complejos generados por HackRF y convertirlos en una señal de frecuencia/amplitud utilizando la Transformada de Fourier.

   Aquí están los pasos que puede seguir para lograr esto:

   1. Agregue una fuente a su proyecto de GNURadio: En este caso, estamos utilizando HackRF como fuente.

   2. Agregue un decimador: Esto es para reducir la frecuencia de muestreo y facilitar el procesamiento. Puede establecer este valor para reducir la frecuencia de muestreo al nivel deseado.

   3. Agregue un bloque FFT: Este bloque convertirá los datos complejos en una señal de frecuencia/amplitud. Deberá seleccionar “complejo a magnitud al cuadrado” para la salida del FFT.

   4. Agregue un bloque “Throttle”: Este bloque establece la velocidad de flujo de datos.

   5. Agregue un bloque “Embedded Python”: Aquí es donde recrearemos el algoritmo “QT GUI Frequency Sink”.

   6. En el bloque “Embedded Python”, puede agregar código para leer los datos del FFT y encontrar los valores de frecuencia/amplitud que cumplan con sus requisitos de nivel de decibelios o umbral. El código guardará estos valores en un archivo.

   Aquí hay un código de ejemplo para ayudarte a comenzar:

   #!/usr/bin/env python2
   # -*- coding: utf-8 -*-
   ##################################################
   # GNU Radio Python Flow Graph
   # Title: HackRF Receiver
   # Generated: Fri Jan  4 22:56:34 2019
   ##################################################
   
   from gnuradio import fft
   from gnuradio import gr
   from gnuradio import analog
   from gnuradio import blocks
   from gnuradio import uhd
   from gnuradio.fft import window
   from gnuradio.filter import firdes
   import os
   
   class HackRF_Receiver(gr.top_block):
   
       def __init__(self):
           gr.top_block.__init__(self, "HackRF Receiver")
   
           ##################################################
           # Variables
           ##################################################
           self.samp_rate = samp_rate = 2e6
           self.center_freq = center_freq = 433e6
           self.fft_size = fft_size = 1024
           self.decimate = decimate = 10
   
           ##################################################
           # Bloques
           ##################################################
           self.uhd_usrp_source_0 = uhd.usrp_source(
               ",".join(("", "")),
               uhd.stream_args(
                   cpu_format="fc32",
                   canales=range(1),
               ),
           )
           self.uhd_usrp_source_0.set_samp_rate(samp_rate)
           self.uhd_usrp_source_0.set_center_freq(center_freq, 0)
           self.uhd_usrp_source_0.set_gain(10, 0)
           self.uhd_usrp_source_0.set_antenna("TX/RX", 0)
           self.throttle_0 = blocks.throttle(gr.sizeof_gr_complex*1, samp_rate*2, True)
           self.fft_vxx_0 = fft.fft_vcc(fft_size, True, window.blackmanharris(fft_size))
           self.blocks_complex_to_mag_squared_0 = blocks.complex_to_mag_squared(fft_size)
           self.file_sink_1 = blocks.file_sink(gr.sizeof_float*1, '/ruta/al/archivo/de/salida', False)
           self.file_sink_1.set_unbuffered(False)
   
           ##################################################
           # Conexiones
           ##################################################
           self.connect((self.blocks_complex_to_mag_squared_0, 0), (self.file_sink_1, 0))
           self.connect((self.fft_vxx_0, 0), (self.blocks_complex_to_mag_squared_0, 0))
           self.connect((self.throttle_0, 0), (self.fft_vxx_0, 0))
           self.connect((self.uhd_usrp_source_0, 0), (self.throttle_0, 0))
   
       def obtener_samp_rate(self):
           return self.samp_rate
   
       def establecer_samp_rate(self, samp_rate):
           self.samp_rate = samp_rate
           self.uhd_usrp_source_0.set_samp_rate(self.samp_rate)
           self.throttle_0.set_sample_rate(self.samp_rate*2)
   
       def obtener_freq_central(self):
           return self.center_freq
   
       def establecer_freq_central(self, center_freq):
           self.center_freq = center_freq
           self.uhd_usrp_source_0.set_center_freq(self.center_freq, 0)
   
       def obtener_fft_size(self):
           return self.fft_size
   
       def establecer_fft_size(self, fft_size):
           self.fft_size = fft_size
           self.fft_vxx_0.set_fft_size(self.fft_size)
           self.blocks_complex_to_mag_squared_0.set_length_and_scale(self.fft_size)
   
       def obtener_decimate(self):
           return self.decimate
   
       def establecer_decimate(self, decimate):
           self.decimate = decimate
           self.throttle_0.set_sample_rate(self.samp_rate*2/self.decimate)
   
   

   No olvide actualizar las variables según sus necesidades.

   ¡Buena suerte!

Comments are closed.