Gnu radio companion для windows

Windows Installation[edit]

Too long, won’t read: Use the RadioConda installer, as linked from our InstallingGR landing page.

Binary Installers[edit]

There are a few different unofficial GNU Radio binary installers that are maintained by the community:

1) Radioconda installer. This binary installer tends to be the most up-to-date, but you should check the list of packages to see if it includes what you need. It utilizes the conda package/environment manager and provides easy access to thousands of Python and other packages that are not strictly related to GNU Radio. This also lets you stay up-to-date without having to re-install. Since this provides the same conda-forge packages available without the installer, the conda install guide might be useful for additional instructions, including how to build additional OOT modules from source.
After installing Radioconda you will get a «GNU Radio Companion» added to your start menu. Run this to start GNU Radio Companion, the graphical GNU Radio design tool.

2) (only outdated versions as of 2023-09) Geof Nieboer’s installer hosted at gcndevelopment.com (recently unreachable in 2022-07, but reachable currently 2022-10-23). This is a binary installer for 64-bit Windows 7/8/10 that includes all dependencies for Windows, a custom python distro, commonly used SDR drivers, and several OOT blocks.

3) (only outdated versions as of 2023-09) Pothos SDR development environment installer. This binary installer includes GNU Radio, Pothos, CubicSDK, and other tools. It has historically been updated about once or twice per year.

Current Windows Status[edit]

Installing core GNU Radio and USRP on Windows is becoming more routine. Many OoT modules may still require compiling locally. Please report any success or failures. Patches and enhancements are especially welcome!

Windows Porting Issues[edit]

Considerable effort has been put into making the GNU Radio code portable among various operating systems, but there are several reasons why it cannot be «simply» compiled and run under Windows:

• The build and install procedures are based on Linux scripts and tools
• Several third-party libraries are used, each with its own, often system-dependent, installation procedure
• Most GNU Radio applications must interface to hardware (e.g., a sound card or USRP) which require system-dependent drivers and installation procedures
• Because GNU Radio is written as an extension to Python, there are potential problems on Windows if different runtime libraries are used for GNU Radio and Python

The following sections show how these issues can be addressed.

Installation Options[edit]

GNU Radio is designed to be flexible. It has a number of modules, capabilities, and options that can be enabled or disabled to suit the needs of the user, and the user can add custom blocks or modules to the system.

To support this flexibility, it comes with a set of files and scripts to be used with GNU software build tools (sh, make, autoconf, automake, etc.). These tools use Linux-like commands and filenames that are not normally available on Windows systems.

Fortunately, we are not the first to face this problem, and several solutions exist. These are presented in order of increasing difficulty:

Building on Windows with Native Tools[edit]

Ettus Application note [1] describes how to build from source. Similar is a post at [2] for OOT modules.

Powershell scripts are now available at https://www.github.com/gnieboer/gnuradio_windows_build_scripts that fully automate the build process for GNURadio 3.7.9.2+. A few build dependencies are required (MSVC 2015, Git, Doxygen, CMake, Perl, Wix) but all are free. The script has two options:

1. Build all dependencies from source (including python itself)
2. Download a prebuilt custom dependency package and then build only GNURadio and a few OOT modules on top.

The binary installers described above are built with these scripts. They ensure that all dependencies are built with the same toolchain against the same runtime libraries, and handle the patches and configuration «tweaks» needed to build them on Windows.
If option 1 is desired, note that to build scipy, the non-free Intel Fortran compiler is required, gfortran cannot build objects that can link with MSVC C objects. If you do not have said compiler, the scripts will download pre-compiled wheels instead.

More information on the build process is available on the GitHub repo readme, and also at http://www.gcndevelopment.com/gnuradio.

GNURadio 3.6 has also been compiled on Windows using native tools as well (see http://voltronics.blogspot.com/2013/01/gnu-radio-windows-build-guide.html and https://lists.gnu.org/archive/html/discuss-gnuradio/2013-08/msg00284.html)

More helpful tips on dependency version information have been reported:
https://lists.gnu.org/archive/html/discuss-gnuradio/2013-12/msg00497.html

MinGW/MSYS[edit]

MinGW (http://www.mingw.org/) provides GNU compilers and Window-specific header files for compiling native Windows applications.
MSYS (http://www.mingw.org/msys.shtml) is a companion set of Linux-like commands, shell, and build tools.
MinGW does not include a Linux programming interface; programs should be smaller and faster than with Cygwin (in theory), but will require more Windows-specific code.
MSYS is intended primarily as a build environment, making it more compact than Cygwin.

Because there is no Linux API emulation, GNU Radio built with MinGW should be used with standard Windows versions of Python and the third-party libraries.
MinGW does not provide as much support as Cygwin for installing third-party libraries, but in many cases precompiled binaries are available.

For detailed installation instructions using MinGW and MSYS see Installing GNU Radio with MinGW.

Cygwin[edit]

Cygwin (http://www.cygwin.com/) is a Linux-like environment for Windows.
It provides the Linux-like shell, file naming, and build tools we need and also makes it easy to install many of the third-party libraries required by GNU Radio. It also provides a Linux programming interface (API); this is not required by GNU Radio, but it lets us use the better-tested Linux versions of some functions.

Because the Linux API uses its own C runtime library, it is best to use Cygwin versions of Python and the third-party libraries when building GNU Radio with Cygwin.

For detailed installation instructions using Cygwin see Installing GNU Radio with Cygwin.

Chocolatey[edit]

To quote from the [|https://chocolatey.org/ Chocolatey homepage]: Chocolatey NuGet is a Machine Package Manager, somewhat like apt-get, but built with Windows in mind..

There are packages for gnuradio (and its dependencies) available in a separate repository (currently the best known source is: https://github.com/ariovistus/chocolatey-packages)

To install, open an Administrative command line session and run:

iex ((new-object net.webclient).DownloadString('https://chocolatey.org/install.ps1'))

Now you need to install a source which has the recipes for gnuradio and dependents. The easiest method is to clone the chocolatey-packages from the github repository listed above (https://github.com/ariovistus/chocolatey-packages), then add the local source from within an Administrative command line session:

choco source add -name gnuradio -source C:\<path-to>\chocolatey-packages

Create the numpy package:

cd <path-to>\chocolatey-package\numpy
cpack

Create the gnuradio package:

cd <path-to>\chocolatey-package\gnuradio
cpack

Now install the gnuradio package:

choco install gnuradio

Follow the command prompts.

WSL | Ubuntu[edit]

Enable WSL from windows features.

Install Ubuntu 20.04 (or newer) from Microsoft Store.

Using the Ubuntu terminal, install gnuradio as you would on linux [3]. If you want to develop GNU Radio’s core you will need to build GNU Radio from source.

WSL 1/2 (before WSLg)[edit]

Install additional package «libgtk-3-dev»

 sudo apt install libgtk-3-dev
 

WSL 1 and 2 (before WSLg) do not have an X server for displaying graphical applications. Install an X server, either VcXsrv [4] or Xming [5] as WSL does not come with an X server. VcXsrv is recommended as it is open source and self-contained instead of being tied to Cygwin, whereas Xming «asks for donations» to the developer as a dubious «sale» for non-existent support.

Launch VcXsrv, making sure to select «Disable access control» option in the Extra settings so that any application can export to X11.

Edit bashrc to set up the display by adding the following lines at the bottom of the file.

WSL1:

 # X11 forwarding for Windows
 export DISPLAY=:0.0
 export LIBGL_ALWAYS_INDIRECT=1

WSL2:

 # X11 forwarding for Windows
 export DISPLAY=$(awk '/nameserver / {print $2; exit}' /etc/resolv.conf 2>/dev/null):0
 export LIBGL_ALWAYS_INDIRECT=1

Restart the Ubuntu terminal and run

 gnuradio-companion

WSLg[edit]

Currently in early testing stages, the WSLg update contains a Wayland graphics server and X interface layer allowing graphical applications to run without extra setup.

From the Ubuntu terminal run

 gnuradio-companion

Using an Azure VM[edit]

Another way to generate a GNU Radio environment if you’re using Windows, is to create an Azure Virtual Machine running Ubuntu Server 18.04 LTS.

If you already have an existing Azure account you can follow the instructions here[6] to create an Ubuntu VM using the Azure portal. Otherwise, you can sign up for an account here[7]. Azure provides free accounts for students[8] with a limited set of credits.

Once your VM is created you should be able to SSH into it, to install a desktop environment. Full instructions can be found here, but in summary:
Install xfce

 sudo apt-get update 
 sudo apt-get -y install xfce4

Install xrdp as a remote desktop server

 sudo apt-get -y install xrdp 
 sudo systemctl enable xrdp

Configure xrdp to use xfce

 echo xfce4-session >~/.xsession

Restart the xrdp service

 sudo service xrdp restart

You will need to create a local password for your Linux VM (on top of your existing SSH key), and open port 3389[9] on the VM.

Finally you can use a remote desktop client, such as Remote Desktop Connection to connect to your VM and follow the instructions for GNU Radio on Ubuntu found here[10].

Gnu Radio Companion or GRC is a graphical user interface (GUI) for the GNU Radio software. It is used to design and simulate GNU Radio flow graphs. GRC is written in Python and uses the Qt library.

GRC can be used to create digital signal processing (DSP) applications, test bed applications, and educational exercises. It supports many common GNU Radio block types, including receivers, transmitters, filters, sources, and sinks.

GRC is included in the GNU Radio software distribution. It can be downloaded and installed separately, or it can be installed automatically when GNU Radio is installed.

GRC is available for Windows, macOS, and Linux.

Does GNU Radio work on Windows?

This is a question that often comes up on the GNU Radio mailing list. The answer, unfortunately, is that GNU Radio does not work on Windows as well as it does on Linux.

There are a few reasons for this. First, the GNU Radio codebase is written in C++, and the Windows port of C++ is not as robust as the Linux port. Second, many of the GNU Radio dependencies (such as the Python interpreter and the SWIG tool) do not work as well on Windows. Finally, there is not as much documentation or support for GNU Radio on Windows as there is for GNU Radio on Linux.

Despite these limitations, there are a few ways to get GNU Radio working on Windows. One option is to use the Cygwin environment, which provides a Linux-like environment on Windows. Another option is to use the WinPython environment, which provides a Python interpreter and GNU Radio dependencies that work better on Windows. Finally, it is possible to build GNU Radio from source on Windows, but this is a more complicated process and requires more knowledge of Windows than the other options.

So, does GNU Radio work on Windows? The answer is yes, but it is not as easy to set up as it is on Linux.

How do I install GNU Radio on Windows?

GNU Radio is a free and open source software development platform for digital signal processing and software-defined radio. It provides a toolkit for software-defined radios and a range of applications for manipulating digital signals.

GNU Radio is available on many platforms, including Windows. In this article, we will show you how to install GNU Radio on Windows.

First, download the GNU Radio installer from the GNU Radio website.

Then, run the installer and follow the on-screen instructions.

When the installation is complete, you will be able to launch GNU Radio from the Start Menu.

Now, you can start using GNU Radio to create digital signals and applications.

How do I use GNU Radio Companion?

GNU Radio Companion (GRC) is a graphical programming environment used to design and develop software-defined radios (SDRs). In this article, we will show you how to use GRC to create SDRs.

To start GRC, open a terminal and type ‘gnuradio-companion’. This will launch the GRC graphical interface. The main window consists of four panes: the leftmost pane is the block diagram, the top-right pane is the output window, the bottom-right pane is the properties window, and the bottom-left pane is the control panel.

The block diagram is where you design your SDR. The blocks in the diagram represent various components of the SDR. To add a block to the diagram, click on the ‘Blocks’ menu and select the desired block. To connect two blocks, click on the output of one block and drag it to the input of the other block.

The output window displays the output of the SDR. The properties window allows you to modify the properties of a block. The control panel allows you to control the execution of the SDR.

To create an SDR, first add a source block to the block diagram. This block will generate the input for the SDR. Next, add a receiver block to the diagram. This block will receive the input from the source block and convert it to a digital signal. Finally, add an output block to the diagram. This block will output the digital signal.

To execute the SDR, click on the ‘Execute’ button in the control panel. This will start the SDR and display the output in the output window.

Is GNU Radio Free?

Is GNU Radio free?

GNU Radio is free and open source software. This means that you are free to use it for any purpose, including commercially. It also means that you can view, modify, and redistribute the software.

GNU Radio is a toolkit for building software-defined radios. It can be used to create software that can receive and decode digital signals, such as those from digital TV broadcasts. It can also be used to create radios that transmit digital signals.

GNU Radio is written in C++. It can be used on a wide range of platforms, including Windows, Mac OS, and Linux.

Where is GNU Radio installed?

GNU Radio is a free and open source software development platform for digital signal processing and communications. It is widely used in research and education for prototyping and developing digital communications systems.

GNU Radio is not a single piece of software, but rather a collection of software tools that can be used to build digital communications systems. These tools include a signal processing library, a set of graphical user interface (GUI) tools, and a set of command-line tools.

The GNU Radio software is installed in a number of different ways, depending on your operating system and the type of system you are using GNU Radio on.

On Linux systems, GNU Radio is typically installed as a package in the software repositories of your distribution. You can install GNU Radio using the package management tools of your distribution, such as apt-get or yum.

On Windows systems, GNU Radio is typically installed as a self-contained executable file. You can download the latest release of GNU Radio from the GNU Radio website and run the installer.

On MacOS systems, GNU Radio is typically installed as a package in the software repositories of your distribution. You can install GNU Radio using the package management tools of your distribution, such as apt-get or Homebrew.

GNU Radio is also available as a virtual machine image that can be run on a variety of different platforms. You can download the virtual machine image from the GNU Radio website.

In addition to the official GNU Radio releases, there are a number of third-party distributions of GNU Radio that include additional features or tools. These distributions are typically created by members of the GNU Radio community. You can find a list of third-party distributions on the GNU Radio website.

What is SigMF?

SigMF stands for Signature-based Message Format. It is a binary format for encapsulating messages that can be verified for authenticity and integrity.

SigMF is designed to be simple and efficient, while also providing a high level of security. It is based on digital signatures, which are used to verify the authenticity of messages.

SigMF is a open standard, which means that it can be used by anyone. It is also royalty-free, so it can be used without any fees or restrictions.

SigMF is currently being used by a number of companies, including Apple, Google, and Microsoft. It is also being used by the IETF (Internet Engineering Task Force) to provide security for the Internet of Things.

What is PyBOMBS?

PyBOMBS is a Python based software deployment tool. It is used to automate the installation and configuration of software on servers. PyBOMBS can be used to install software on local machines as well as remote servers. It can also be used to manage software updates and installations. PyBOMBS is an open source project that is released under the GNU General Public License.

Время на прочтение
10 мин

Количество просмотров 39K

Привет, Хабр.

В третьей части было рассказано, как получить доступ к SDR-приемнику посредством языка Python. Сейчас мы познакомимся с программой GNU Radio — системой, позволяющей создать достаточно сложную конфигурацию радиоустройства, не написав ни единой строчки кода.

Для примера рассмотрим задачу параллельного приема нескольких FM-станций на один приемник. В качестве приемника будем использовать все тот же RTL SDR V3.

Продолжение под катом.

Установка

Для начала работы GNU Radio необходимо установить, дистрибутив для Windows можно скачать здесь. Система эта кроссплатформенная, версии есть также под Linux и под OSX (вроде бы GNU Radio успешно запускали и на Raspberry Pi, но 100% гарантии дать не могу).

По сути, GNU Radio это целый фреймворк для цифровой обработки сигналов, в котором программа «собирается» из отдельных модулей. Есть большое количество уже готовых блоков, при желании также можно создавать свои собственные. Сами модули написаны на С++, а для взаимодействия блоков друг с другом используется Python. Желающие могут посмотреть на API более подробно, но на практике это, скорее всего, не пригодится — все действия можно делать визуально в программе GNU Radio Companion.

Система ориентирована на обработку потоков данных, так что каждый блок обычно имеет вход и выход. Далее, соединяя блоки в редакторе, мы получаем готовую систему. Сам интерфейс GNU Radio довольно простой, сложность состоит в понимании того, что делает тот или иной блок. Как говорилось ранее, низкоуровневая работа с SDR имеет высокий порог входа и требует некоторого знания в DSP и математике. Но мы рассмотрим простую задачу, для которой никаких специальных знаний не потребуется. Итак, приступим.

Начало работы

Запускаем GNU Radio Companion, создаем новый проект, тип проекта выбираем WX GUI, добавляем на экран и соединяем два блока, как показано на скриншоте.

Мы видим два типа блоков — Source (источник) и Sink (выход, «слив»). RTL-SDR — это наш приемник, FFT GUI — это виртуальный спектроанализатор.

Переменную Sample Rate устанавливаем в 2048000, это частота дискретизации нашего приемника. Частоту RTL-SDR оставляем по умолчанию равной 100МГц.

Запускаем проект — все работает, мы видим спектр FM-станций. Первая программа для GNU Radio готова!

Если мы посмотрим лог, то увидим такие строки.

Generating: ‘D:\\MyProjects\\GNURadio\\top_block.py’
Executing: C:\Python27\python.exe -u D:\MyProjects\GNURadio\top_block.py

Да, мы можем посмотреть файл top_block.py, который сгенерил нам GNU Radio Companion. Истинные джедаи могут писать непосредственно в Python, но требуемый код, как мы видим, довольно большой. Мы же создали его за 1 минуту.

#!/usr/bin/env python2
# -*- coding: utf-8 -*-
##################################################
# GNU Radio Python Flow Graph
# Title: Top Block
# Generated: Wed May 22 22:05:14 2019
##################################################

if __name__ == '__main__':
    import ctypes
    import sys
    if sys.platform.startswith('linux'):
        try:
            x11 = ctypes.cdll.LoadLibrary('libX11.so')
            x11.XInitThreads()
        except:
            print "Warning: failed to XInitThreads()"

from gnuradio import eng_notation
from gnuradio import gr
from gnuradio import wxgui
from gnuradio.eng_option import eng_option
from gnuradio.fft import window
from gnuradio.filter import firdes
from gnuradio.wxgui import fftsink2
from grc_gnuradio import wxgui as grc_wxgui
from optparse import OptionParser
import osmosdr
import time
import wx


class top_block(grc_wxgui.top_block_gui):

    def __init__(self):
        grc_wxgui.top_block_gui.__init__(self, title="Top Block")

        ##################################################
        # Variables
        ##################################################
        self.samp_rate = samp_rate = 2048000

        ##################################################
        # Blocks
        ##################################################
        self.wxgui_fftsink2_0 = fftsink2.fft_sink_c(
        	self.GetWin(),
        	baseband_freq=0,
        	y_per_div=10,
        	y_divs=10,
        	ref_level=0,
        	ref_scale=2.0,
        	sample_rate=samp_rate,
        	fft_size=1024,
        	fft_rate=15,
        	average=False,
        	avg_alpha=None,
        	title='FFT Plot',
        	peak_hold=False,
        )
        self.Add(self.wxgui_fftsink2_0.win)
        self.rtlsdr_source_0 = osmosdr.source( args="numchan=" + str(1) + " " + '' )
        self.rtlsdr_source_0.set_sample_rate(samp_rate)
        self.rtlsdr_source_0.set_center_freq(100e6, 0)
        self.rtlsdr_source_0.set_freq_corr(0, 0)
        self.rtlsdr_source_0.set_dc_offset_mode(0, 0)
        self.rtlsdr_source_0.set_iq_balance_mode(0, 0)
        self.rtlsdr_source_0.set_gain_mode(False, 0)
        self.rtlsdr_source_0.set_gain(10, 0)
        self.rtlsdr_source_0.set_if_gain(20, 0)
        self.rtlsdr_source_0.set_bb_gain(20, 0)
        self.rtlsdr_source_0.set_antenna('', 0)
        self.rtlsdr_source_0.set_bandwidth(0, 0)


        ##################################################
        # Connections
        ##################################################
        self.connect((self.rtlsdr_source_0, 0), (self.wxgui_fftsink2_0, 0))

    def get_samp_rate(self):
        return self.samp_rate

    def set_samp_rate(self, samp_rate):
        self.samp_rate = samp_rate
        self.wxgui_fftsink2_0.set_sample_rate(self.samp_rate)
        self.rtlsdr_source_0.set_sample_rate(self.samp_rate)


def main(top_block_cls=top_block, options=None):

    tb = top_block_cls()
    tb.Start(True)
    tb.Wait()


if __name__ == '__main__':
    main()

Впрочем, если убрать громоздкую инициализацию, то мы увидим, что ключевых строк кода не так уж много.

from gnuradio import gr
from gnuradio.wxgui import fftsink2
import osmosdr

class top_block(grc_wxgui.top_block_gui):

    def __init__(self):
        grc_wxgui.top_block_gui.__init__(self, title="Top Block")
        self.samp_rate = samp_rate = 2048000
        self.wxgui_fftsink2_0 = fftsink2.fft_sink_c(...)
        self.Add(self.wxgui_fftsink2_0.win)
        self.rtlsdr_source_0 = osmosdr.source(args="numchan=" + str(1) + " " + '' )
        self.connect((self.rtlsdr_source_0, 0), (self.wxgui_fftsink2_0, 0))

def main(top_block_cls=top_block, options=None):
    tb = top_block_cls()
    tb.Start(True)
    tb.Wait()

Так что в принципе, это можно написать вручную. Но мышью оно все-таки быстрее. Хотя возможность поменять код иногда может пригодиться, если захочется добавить какую-то нестандартную логику.

Принимаем FM-радио

Теперь попробуем принять одну из станций. Как было видно из скриншотов, центральная частота приемника 100МГц и ширина полосы пропускания около 2МГц. На спектре мы видим две станции, на 100.1МГц и 100.7МГц соответственно.

Первым шагом необходимо перенести спектр станции в центр, сейчас он отстоит вправо на 100КГц. Для этого вспоминаем школьную формулу умножения косинусов — в результате будет две частоты, сумма и разность — нужная станция сдвинется в центр, что нам и нужно (а лишнее мы потом отфильтруем).

Создаем две переменные для хранения частоты freq_center=100000000 и freq_1=100100000, также добавляем генератор сигналов с частотой freq_center — freq_1.

Т.к. система построена на базе Python, то в полях ввода параметров мы можем использовать выражения, что достаточно удобно.

Схема в итоге должна выглядеть так:

Теперь необходимо добавить сразу несколько блоков — уменьшить тактовую частоту входного сигнала (она равна 2048КГц), отфильтровать сигнал, подать его на FM-декодер, затем еще раз уменьшить тактовую частоту до 48КГц.

Результат показан на картинке:

Считаем внимательно. Мы делим тактовую частоту 2048КГц в 4 раза блоком Rational Resampler (получаем 512КГц), затем после Low Pass фильтра стоит WBFM-декодер с децимацией 10 (получаем 51.2КГц). В принципе, этот сигнал уже можно подать на звуковую карту, но высота тона будет чуть отличаться. Еще раз меняем тактовую частоту в 48/51, в результате будет тактовая частота 48.2КГц, разницей уже можно пренебречь.

Второй важный момент — тип входов. С приемника поступает комплексный IQ-сигнал (входы-выходы синего цвета), с FM-декодера выходит вещественный сигнал — входы и выходы желтого цвета. Если перепутать, ничего не заработает. Подробнее уже было на Хабре, нам достаточно понять общий принцип.

В общем, запускаем, убеждаемся что все работает. Можно запустить программу и слушать радио. Мы пойдем дальше — у нас же все-таки Software Defined радио — добавим одновременный прием второй станции.

Многоканальный прием

Второй приемник добавляется любимым программистским методом — Ctrl+C/Ctrl+V. Добавляем переменную freq_2, копируем блоки и соединяем их точно также.

Результат вполне сюрреалистичный — две FM-станции можно слушать одновременно. Тем же самым методом (Ctrl+V) можно добавить и третью станцию.

Запись

Слушать две станции оригинально, но на практике мало полезно. Сделаем что-то более нужное, например добавим запись звука в отдельные файлы. Это может быть достаточно удобно — с одного физического приемника можно параллельно записывать несколько каналов.

Добавим к каждому выходу компонент File Sink, как показано на скриншоте.

Windows-версия почему-то требует абсолютные пути файлов, иначе запись не работает. Запускаем, убеждаемся что все нормально. Размер сохраняемых файлов довольно большой, т.к. по умолчанию записывается формат float. Запись в формате int оставлю читателям в качестве домашнего задания.

Получившиеся файлы можно открыть в Cool Edit и убедиться, что звук записался нормально.

Разумеется, число записываемых каналов можно увеличить, оно ограничено только полосой пропускания приемника и мощностью компьютера. Кроме File Sink можно использовать и UDP Sink, так что программу можно использовать для трансляции по сети.

Запуск из командной строки

И последнее. Если использовать программу автономно, например для многоканальной записи, то UI в принципе и не нужен. В верхнем левом блоке Options меняем параметр Run Options на No UI. Запускаем программу еще раз, убеждаемся что все работает. Теперь сохраняем сгенерированный файл top_block.py — мы можем просто запускать его из командной строки, например из bat-файла или из консоли.

Если кому интересно, сгенерированный файл сохранен под спойлером.

#!/usr/bin/env python2
# -*- coding: utf-8 -*-
##################################################
# GNU Radio Python Flow Graph
# Title: Top Block
# Generated: Fri May 24 21:47:03 2019
##################################################

from gnuradio import analog
from gnuradio import audio
from gnuradio import blocks
from gnuradio import eng_notation
from gnuradio import filter
from gnuradio import gr
from gnuradio.eng_option import eng_option
from gnuradio.filter import firdes
from optparse import OptionParser
import osmosdr
import time


class top_block(gr.top_block):

    def __init__(self):
        gr.top_block.__init__(self, "Top Block")

        ##################################################
        # Variables
        ##################################################
        self.samp_rate = samp_rate = 2048000
        self.freq_center = freq_center = 100000000
        self.freq_2 = freq_2 = 100700000
        self.freq_1 = freq_1 = 100100000

        ##################################################
        # Blocks
        ##################################################
        self.rtlsdr_source_0 = osmosdr.source( args="numchan=" + str(1) + " " + '' )
        self.rtlsdr_source_0.set_sample_rate(samp_rate)
        self.rtlsdr_source_0.set_center_freq(freq_center, 0)
        self.rtlsdr_source_0.set_freq_corr(0, 0)
        self.rtlsdr_source_0.set_dc_offset_mode(0, 0)
        self.rtlsdr_source_0.set_iq_balance_mode(0, 0)
        self.rtlsdr_source_0.set_gain_mode(False, 0)
        self.rtlsdr_source_0.set_gain(10, 0)
        self.rtlsdr_source_0.set_if_gain(20, 0)
        self.rtlsdr_source_0.set_bb_gain(20, 0)
        self.rtlsdr_source_0.set_antenna('', 0)
        self.rtlsdr_source_0.set_bandwidth(0, 0)

        self.rational_resampler_xxx_1_0 = filter.rational_resampler_fff(
                interpolation=48,
                decimation=51,
                taps=None,
                fractional_bw=None,
        )
        self.rational_resampler_xxx_1 = filter.rational_resampler_fff(
                interpolation=48,
                decimation=51,
                taps=None,
                fractional_bw=None,
        )
        self.rational_resampler_xxx_0_0 = filter.rational_resampler_ccc(
                interpolation=1,
                decimation=4,
                taps=None,
                fractional_bw=None,
        )
        self.rational_resampler_xxx_0 = filter.rational_resampler_ccc(
                interpolation=1,
                decimation=4,
                taps=None,
                fractional_bw=None,
        )
        self.low_pass_filter_0_0 = filter.fir_filter_ccf(1, firdes.low_pass(
        	1, samp_rate/4, 100000, 500000, firdes.WIN_HAMMING, 6.76))
        self.low_pass_filter_0 = filter.fir_filter_ccf(1, firdes.low_pass(
        	1, samp_rate/4, 100000, 500000, firdes.WIN_HAMMING, 6.76))
        self.blocks_multiply_xx_0_0 = blocks.multiply_vcc(1)
        self.blocks_multiply_xx_0 = blocks.multiply_vcc(1)
        self.blocks_file_sink_0_0 = blocks.file_sink(gr.sizeof_float*1, 'D:\\Temp\\1\\audio2.snd', False)
        self.blocks_file_sink_0_0.set_unbuffered(False)
        self.blocks_file_sink_0 = blocks.file_sink(gr.sizeof_float*1, 'D:\\Temp\\1\\audio1.snd', False)
        self.blocks_file_sink_0.set_unbuffered(False)
        self.audio_sink_0 = audio.sink(48000, '', True)
        self.analog_wfm_rcv_0_0 = analog.wfm_rcv(
        	quad_rate=samp_rate/4,
        	audio_decimation=10,
        )
        self.analog_wfm_rcv_0 = analog.wfm_rcv(
        	quad_rate=samp_rate/4,
        	audio_decimation=10,
        )
        self.analog_sig_source_x_0_0 = analog.sig_source_c(samp_rate, analog.GR_COS_WAVE, freq_center - freq_2, 1, 0)
        self.analog_sig_source_x_0 = analog.sig_source_c(samp_rate, analog.GR_COS_WAVE, freq_center - freq_1, 1, 0)

        ##################################################
        # Connections
        ##################################################
        self.connect((self.analog_sig_source_x_0, 0), (self.blocks_multiply_xx_0, 1))
        self.connect((self.analog_sig_source_x_0_0, 0), (self.blocks_multiply_xx_0_0, 1))
        self.connect((self.analog_wfm_rcv_0, 0), (self.rational_resampler_xxx_1, 0))
        self.connect((self.analog_wfm_rcv_0_0, 0), (self.rational_resampler_xxx_1_0, 0))
        self.connect((self.blocks_multiply_xx_0, 0), (self.rational_resampler_xxx_0, 0))
        self.connect((self.blocks_multiply_xx_0_0, 0), (self.rational_resampler_xxx_0_0, 0))
        self.connect((self.low_pass_filter_0, 0), (self.analog_wfm_rcv_0, 0))
        self.connect((self.low_pass_filter_0_0, 0), (self.analog_wfm_rcv_0_0, 0))
        self.connect((self.rational_resampler_xxx_0, 0), (self.low_pass_filter_0, 0))
        self.connect((self.rational_resampler_xxx_0_0, 0), (self.low_pass_filter_0_0, 0))
        self.connect((self.rational_resampler_xxx_1, 0), (self.audio_sink_0, 0))
        self.connect((self.rational_resampler_xxx_1, 0), (self.blocks_file_sink_0, 0))
        self.connect((self.rational_resampler_xxx_1_0, 0), (self.audio_sink_0, 1))
        self.connect((self.rational_resampler_xxx_1_0, 0), (self.blocks_file_sink_0_0, 0))
        self.connect((self.rtlsdr_source_0, 0), (self.blocks_multiply_xx_0, 0))
        self.connect((self.rtlsdr_source_0, 0), (self.blocks_multiply_xx_0_0, 0))

    def get_samp_rate(self):
        return self.samp_rate

    def set_samp_rate(self, samp_rate):
        self.samp_rate = samp_rate
        self.rtlsdr_source_0.set_sample_rate(self.samp_rate)
        self.low_pass_filter_0_0.set_taps(firdes.low_pass(1, self.samp_rate/4, 100000, 500000, firdes.WIN_HAMMING, 6.76))
        self.low_pass_filter_0.set_taps(firdes.low_pass(1, self.samp_rate/4, 100000, 500000, firdes.WIN_HAMMING, 6.76))
        self.analog_sig_source_x_0_0.set_sampling_freq(self.samp_rate)
        self.analog_sig_source_x_0.set_sampling_freq(self.samp_rate)

    def get_freq_center(self):
        return self.freq_center

    def set_freq_center(self, freq_center):
        self.freq_center = freq_center
        self.rtlsdr_source_0.set_center_freq(self.freq_center, 0)
        self.analog_sig_source_x_0_0.set_frequency(self.freq_center - self.freq_2)
        self.analog_sig_source_x_0.set_frequency(self.freq_center - self.freq_1)

    def get_freq_2(self):
        return self.freq_2

    def set_freq_2(self, freq_2):
        self.freq_2 = freq_2
        self.analog_sig_source_x_0_0.set_frequency(self.freq_center - self.freq_2)

    def get_freq_1(self):
        return self.freq_1

    def set_freq_1(self, freq_1):
        self.freq_1 = freq_1
        self.analog_sig_source_x_0.set_frequency(self.freq_center - self.freq_1)


def main(top_block_cls=top_block, options=None):

    tb = top_block_cls()
    tb.start()
    try:
        raw_input('Press Enter to quit: ')
    except EOFError:
        pass
    tb.stop()
    tb.wait()


if __name__ == '__main__':
    main()

Удобно и то, что система является кросс-платформенной, и получившаяся программа может работать на Linux, Windows и OSX.

Заключение

Можно сказать, что GNU Radio достаточно сложная система, не в плане рисования блоков конечно, а в плане понимания того, как все это работает. Но какие-то несложные вещи сделать вполне посильно и интересно. GNU Radio также удобно использовать как «виртуальную лабораторию» для обучения — к любой части схемы можно подключить виртуальный осциллограф или спектроанализатор и посмотреть, как выглядит сигнал.

Если не будет каких-то отдельных пожеланий, тему SDR-приема наверно можно закрыть — все основные моменты уже рассмотрены, да и количество просмотров от первой к третьей части падает почти по экспоненте (хотя еще можно написать про передачу, но оно требует более дорогого «железа» для тестов чем RTL SDR). Надеюсь все же, что некоторое понимание того как это работает, у читателей осталось. Ну и всем удачных экспериментов.

RTL-SDR сегодня очень популярная тема в сети. Существует множество информации, как использовать это недорогое устройство под Windows и Linux. В этой статье (перевод [1]) описан еще один интересный для экспериментатора способ использования RTL-SDR (приемников на основе чипов RTL28xxU) — создание FM-приемника из функциональных блоков системы GNU Radio Companion [10] (далее сокращенно GRC). Возможно это руководство поможет Вам при создании собственных вариантов приемников для других диапазонов и других сигналов. Непонятные термины и сокращения см. в разделе «Словарик» статьи [11].

[Шаг 1. Что такое RTL-SDR?]

Если Вас интересует только создание проекта GRC, то переходите сразу к шагу 5.

RTL-SDR это самый дешевый способ попробовать в работе приемник SDR (Software Defined Radio). Это новая технология, предлагающая основную обработку принимаемого сигнала (фильтрация, демодуляция и другие функции, которые ранее реализовывались чисто аппаратно) выполнять процессором компьютера PC. Некоторые реализации SDR устройств даже могут синтезировать передаваемый сигнал (устройства RTL-SDR этой функцией не обладают). Приемник RTL-SDR обычно позволяет прослушивать сигналы радиоэфира в диапазоне частот от 1 до 2000 МГц (крайние пределы зависят от особенностей реализации устройства).

Вот краткий перечень сигналов, которые может обработать приемник RTL-SDR:

— Обычные вещательные станции FM.
— Радиосвязь полиции.
— Радиосвязь воздушных диспетчеров, передача информации о положении самолетов и морских судов.
— Сигналы портативных передатчиков наподобие ключей от машины или двери гаража.
— Сигналы спутников GPS.
— Передачи МКС и другой космической связи с частотами ниже 2 ГГц.
— Сигналы аппаратуры радиоуправления моделями.

[Шаг 2. Где взять RTL-SDR?]

Самый простой и экономный метод — купить на AliExpress или eBay. Устройство RTL-SDR может стоить от $10 и выше, в зависимости от разновидности и комплектации. Лучше всего купить устройство RTL-SDR V3 на чипе RTL2832U в алюминиевом корпусе [2] (цена около $16 и выше). Более дешевый вариант приемника на основе чипа R820T (цена около $8). Поиск на сайтах AliExpress и eBay рационально проводить по наименованию чипа:

При выборе устройства обращайте внимание на варианты реализации устройства, они могут быть изготовлены на различных чипах, и от этого зависит качество приема и диапазон рабочих частот. Общие различия приемников рассмотрены в статье [3].

Очень многое зависит от качества приемной антенны. Обычно в комплект приемника входит короткая штыревая антенна, которая обеспечивает удовлетворительный прием местных радиостанций в диапазоне частот от 70 до 500 МГц. Для приема радиолюбительского обмена в диапазонах длин волн от 2м до 160м понадобится внешняя антенна соответствующего размера (например, см. [5]).

[Шаг 3. Что понадобится?]

Приемник RTL-SDR, антенна, соединительный кабель для передачи сигнала от антенны к приемнику, операционная система Linux. Автор [1] использовал приемники RTL2838 и Rafael Micro на чипах R820T под операционной системой Arch Linux.

[Шаг 4. Подключение аппаратуры и установка ПО]

Первое, что нужно сделать — подключить Ваше SDR-устройство к компьютеру, и определить, как оно определилось в системе (какой в нем используется чип). Для этого выполните на Linux команду dmesg | tail или journalctl. Ответ на команду dmesg может быть примерно таким (показана часть вывода dmesg со строками, относящиеся к тюнеру):

[ 4009.326338] usb 7-5: new high-speed USB device number 4 using ehci-pci
[ 4009.466712] usb 7-5: dvb_usb_v2: found a 'Realtek RTL2832U reference design' in warm state
[ 4009.531594] usb 7-5: dvb_usb_v2: will pass the complete MPEG2 transport stream to the software demuxer
[ 4009.531613] DVB: registering new adapter (Realtek RTL2832U reference design)
[ 4009.534554] usb 7-5: DVB: registering adapter 0 frontend 0 (Realtek RTL2832 (DVB-T))...
[ 4009.534627] r820t 4-001a: creating new instance
[ 4009.546177] r820t 4-001a: Rafael Micro r820t successfully identified
[ 4009.552681] Registered IR keymap rc-empty
[ 4009.552783] input: Realtek RTL2832U reference design as /devices/pci0000:00/0000:00:1d.7/usb7/7-5/rc/rc1/input20
[ 4009.552854] rc1: Realtek RTL2832U reference design as /devices/pci0000:00/0000:00:1d.7/usb7/7-5/rc/rc1
[ 4009.553275] input: MCE IR Keyboard/Mouse (dvb_usb_rtl28xxu) as /devices/virtual/input/input21
[ 4009.554466] rc rc1: lirc_dev: driver ir-lirc-codec (dvb_usb_rtl28xxu) registered at minor = 0
[ 4009.554474] usb 7-5: dvb_usb_v2: schedule remote query interval to 400 msecs
[ 4009.565930] usb 7-5: dvb_usb_v2: 'Realtek RTL2832U reference design' successfully initialized and connected

blacklist dvb_usb_rtl28xxu

FILES="/etc/modprobe.d/blacklist.conf"

Если операционная система правильно определила Ваш тюнер, то Вы можете установить пакеты, необходимые для использования RTL-SDR. Это пакеты rtl-sdr, sdrsharp-svn, gnuradio и gr-osmosdr-git.

rtl-sdr. Это основной драйвер, и он может быть установлен на Arch из community-репозитория (обратите внимание, что это делается с правами root):

Альтернативно есть git-версия доступная на AUR как rtl-sdr-git.

sdrsharp-svn. Этот пакет (доступный на AUR) содержит GUI-программу SDR#, она дает основной доступ к радиоприемнику RTL-SDR, и может использоваться для проверки. SDR# может декодировать сигналы AM, FM и другие виды модуляции, и эта программа хорошо подходит для первоначального знакомства с технологией SDR.

gnuradio. Наиболее мощный инструмент для SDR это программный пакет GNU Radio, и его графическая утилита GNU Radio Companion (GRC). Пакет gnuradio доступен на AUR под именем gnuradio. Пакет gnuradio также требует установки пакета gr-osmosdr-git из AUR, который нужен в GRC для использования тюнера RTL-SDR в качестве источника цифровых данных.

На других операционных системах Linux процедуры установки необходимых пакетов могут отличаться. На Ubuntu пакет rtl-sdr должен быть доступен из apt-get, и на Fedora он также должен быть в репозиториях по умолчанию. Хорошая инструкция по инсталляции gnuradio есть по ссылке [4].

Теперь можно применить программу SDR#, чтобы найти частоту станции FM с достаточно сильным и качественным сигналом. Запишите эту частоту, она понадобится для проверки, насколько хорошо работает Ваш самодельный приемник GNU Radio. Он должен работать не хуже, чем в программе SDR#.

[Шаг 5. Теоретическое введение в FM Radio]

Самое простое FM-радио состоит из нескольких элементов:

— Источник сигнала. В нашем случае это тюнер RTL-SDR (RTL-SDR Source).
— Фильтр (Low Pass Filter).
— Демодулятор WBFM (WBFM Receive).
— Вывод звука — звуковая карта нашего PC (Audio Sink).

Могут быть и другие элементы, в зависимости от входной и выходной частоты дискретизации. На рисунке ниже показаны основные используемые GRC-блоки.

Редактор GRC красным цветом показывает, что что-то не так. Блоки требуют соединений друг с другом, и их параметры также необходимо настроить. Все это будет проделано на следующих шагах.

[Шаг 6. RTL-SDR Source]

Здесь вместо RTL-SDR Source также может использоваться источник данных osmocom Source. Оба источника можно найти в категории Sources, находящейся в правой панели GRC.

Для источника нужно настроить частоту дискретизации (sample rate) на 2M. Это делается путем редактирования переменной samp_rate, и установки её значения в 2e6. Для источника также настраивается частота принимаемой радиостанции с помощью переменной freq. Имена переменных samp_rate и freq подставляются в соответствующие поля ввода диалога свойств источника сигнала.

[Шаг 7. Low Pass Filter]

Следующий шаг состоит в фильтрации частот кроме той, которую мы установили на предыдущем шаге. Эта задача выполняется блоком low pass filter (дословно переводится как фильтр низких частот, ФНЧ). Его можно найти в категории filters.

Частоту среза фильтра установите с помощью переменной cutoff со значением 100e3 (это стандартная полоса частот приема станции FM).

Параметр Transition Width обозначает длину спада характеристики фильтра. Автор [1] подобрал этот параметр опытным путем с помощью значения переменной transition, которая была установлена в 1M.

Для того, чтобы звуковая карта могла принять поступающий поток цифровых данных 2M, необходимо предварительно снизить частоту выборок до допустимого значения. Эта операция называется прореживанием выборок (децимация), и коэффициент прореживания устанавливается в поле Decimation диалога свойств фильтра, в этом примере как int(samp_rate/500e3). В результате получился коэффициент прореживания 4. Значение 500e3 было выбрано исходя из параметра Quadrature Rate демодулятора FM (который устанавливается на шаге 8), равного 500k. Частота выборок сигнала на выходе Low Pass Filter после децимации все еще достаточно высока, она будет дополнительно понижена впоследствии после дополнительных преобразований.

Соедините выход RTL-SDR Source со входом Low Pass Filter. Обратите внимание, что заголовок компонента RTL-SDR Source изменил цвет с красного на черный. Это означает, что блок RTL-SDR Source подключен корректно. У блока Low Pass Filter цвет заголовка пока не поменялся, потому что необходимо подключить его выход к получателю цифровых данных, что будет сделано на следующем шаге.

[Шаг 8. WBFM Receive]

Теперь нужно подключить к выходу Low Pass Filter демодулятор сигнала FM. Этот блок можно найти в разделе modulators, он называется WBFM Receive. Параметр Quadrature Rate, соответствующий частоте поступления входных выборок, был оставлен в значении по умолчанию 500k. Соедините выход Low Pass Filter со входом WBFM Receive.

[Шаг 9. Формирование звукового потока данных и регулирование громкости]

Эти две задачи могут быть выполнены блоками Rational Resampler (передискретизация с рациональным коэффициентом, находится в разделе resamplers) и Multiply Const (умножитель на константу, находится в разделе math operators).

Rational Resampler. Выборки данных с частотой 500k необходимо преобразовать в частоту выборок 48k, этот поток данных способен обработать любой драйвер звуковой карты PC. Преобразование частоты выборок (передискретизация) делается компонентом Rational Resampler, и это настраивается параметрами Interpolation (интерполяция, предварительное умножение со сглаживанием) и Decimation (прореживание). В нашем примере сначала делается децимация с коэффициентом 500 (деление частоты выборок на 500), и затем интерполяция с коэффициентом 48 (умножение частоты выборок на 48), в результате получается частота выборок сигнала 48k.

Multiply Const. В этом блоке параметр Constant может использоваться для регулирования громкости звука. Для этого создается переменная volume, которая будет связана с графическим элементом — ползунком регулирования «WX GUI Slider». Это позволит нам регулировать громкость звучания приемника после запуска программы GRC.

[Шаг 10. Audio Sink]

Последний шаг состоит в добавлении блока получателя звуковых данных Audio Sink (находится в разделе Audio). В нем нужно только установить необходимую частоту выборок сигнала (параметра Sample Rate). Это делается выбором 48k из выпадающего списка. Если по какой-то причине звуковая карта PC не предоставляет такого значения, то установите другое, и подберите соответствующие параметры блока Rational Resampler.

Во время тестов созданной схемы приемника было обнаружено, что децимация до 500k должна быть не на выходе блока фильтра, а на его входе. После этого демодулированный звук воспроизводится лучше.

Конечная рабочая схема FM-приемника:

Обратите внимание, что некоторые коннекторы GRC-блоков синие, а некоторые оранжевые. Синие относятся с комплексным данным (complex data, которые имеют реальную и мнимую составляющие). Оранжевые коннекторы показывают тип данных Float. В большинстве случаев система GRC может сама преобразовывать типы данных, однако иногда требуется явное преобразование.

Готовый GRC-проект приемника FM можно скачать по ссылке 190508FM-receiver.grc.

[AM приемник]

Этот проект простого приемника был повторен мной и немного переделан на основе информации по ссылкам [8, 9]. На схеме зеленым цветом добавлены пояснения на русском языке и основные взаимосвязи между компонентами приемника (к сожалению, такие комментарии нельзя добавлять в редакторе GRC).

Опции проекта. Блок содержит общие свойства — заголовок (Simple receiver AM), тип генерируемого исполняемого кода Python (WX GUI), размер окна запущенного проекта (1280,1024) и другие опции.

Частота оцифровки. Этот блок задает значение переменной samp_rate, которое по умолчанию используют все добавляемые в проект новые блоки, связанные с обработкой, отображением и выводом сигнала.

Настройка частоты. Эта группа блоков задает частоту настройки для блока приемника RTL-SDR Source. Частота настройки SDR-тюнера вычисляется по следующей формуле:

freq+offset_coarse+offset_fine+HamItUp_freq

Здесь переменная freq это основная частота настройки, задаваемая полем ввода WX GUI Text Box. Переменные offset_coarse и offset_fine задают грубую и точную подстройку частоты соответственно (эти переменные меняется движками-слайдерами WX GUI Slider). Переменная HamItUp_freq учитывает смещение частоты вверх на 125 МГц, которую создает аппаратный конвертер Ham It Up (производство Nooelec), подключенный между антенной и входом RF приемника RTL-SDR RTL2832U.

Усиление RF. Этот слайдер задает значение параметра усиления по радиочастоте блока RTL-SDR Source (SDR-приемник RTL2832U).

Управление полосой приема. В этой группе два блока — Low Pass Filter (фильтр низкой частоты), и WX GUI Slider (движок, которым можно настраивать полосу фильтра). Фильтр выполняет две важные функции — ограничивает полосу пропускания выходного тракта приемника (полоса регулируется слайдером в диапазоне от 2 до 40 кГц), а также выполняет прореживание выборок сигнала (децимацию) с коэффициентом 32. Децимация необходима для повышения производительности приемника — остальные блоки приемника будут обрабатывать только необходимую полосу частот.

Отображение сигналов. Эти блоки представляют собой визуальные компоненты, которые показывают спектр принимаемого сигнала. Серый верхний блок WX GUI FFT Sink графического спектра отключен и заменен на блок водопада WX GUI Waterfall Sink (водопад мне показался более удобным).

Передискретизация. С помощью блока Rational Resampler реализована подгонка частоты дискретизации сигнала 64 кГц на выходе фильтра Low Pass Filter (samp_rate/32 = 64 кГц) к стандартной частоте дискретизации звуковой карты компьютера 48 кГц (используется блоком вывода звука Audio Sink). Подгонка осуществляется с помощью интерполяции на 12 и децимации на 16, в результате получается частота 64 * 12 / 16 = 48 кГц.

АРУ. Блок AGC3 осуществляет автоматическую регулировку усиления приемника.

Детектор АМ. Блок AM Demod осуществляет демодуляцию амплитудно-модулированного сигнала.

Громкость звука. Блок слайдера и блок умножения на константу осуществляют управление громкостью звучания принимаемого сигнала.

Готовый GRC-проект приемника AM можно скачать по ссылке 190516AM-receiver.grc.

[Ссылки]

1. RTL-SDR FM Radio Receiver With GNU Radio Companion site:instructables.com.
2. RTL-SDR Blog V3 RTL2832U 1PPM TCXO HF BiasT SMA Software Defined Radio site:aliexpress.com.
3. rtl-sdr site:osmocom.org.
4. Installing GNU Radio site:gnuradio.org.
5. АНТЕННА БЕВЕРИДЖА практическая реализация.
6. HackRF и GNU Radio, быстрый старт.
7. GNU Radio + RTLSDR под Windows для начинающих site:youtube.com.
8. GNU Radio Companion, Part 2 HACKADAY site:youtube.com.
9. YOUR FIRST GNU RADIO RECEIVER WITH SDRPLAY site:hackaday.com.
10. GNU Radio Companion.
11. GNU Radio, краткий справочник.