Remote SDR v5 – Installation manuelle

GNU RADIO 3.9 – Osmocom – Soapy SDR

RTL-SDR – HackRF – Adalm-Pluto – RSP1 – RSP1A – SA818

Ci-dessous la procédure détaillée pour installer Remote SDR en version 5 sur un Raspberry Pi 4 B (2Go) ou un Orange Pi Zero 2. Elle est adaptable pour d’autres cartes ‘Single Board Computer’ si elles disposent de la puissance de calcul nécessaire comme le Raspberry Pi 4.

Attention, cette procédure est longue et complexe. Dans la mesure du possible, il est préférable d’utiliser une image pour carte SD disponible pour les Raspberry 4B et l’orange pi Zero 2.

Les sources et images seront disponibles sur Github https://github.com/F1ATB/Remote-SDR

La version 5 de Remote SDR est construite autour des OS Armbian (Bullseye) pour l’Orange Pi Zero 2 et Raspberry OS (Bullseye) pour le Raspberry 4B. GNU Radio dédié au traitement du signal est à présent en version 3.9. L’installation manuelle prend plusieurs heures. À ce jour, Mars 2022, il faut passer par une compilation de nombreux logiciels sources et surtout GNU-Radio 3.9. Les packages binaires ne sont pas encore disponibles.

Installation Système Linux

Avant d’installer les traitements du signal radio, il faut installer le système d’exploitation de base. La procédure est détaillée ici:

Téléchargez le système d’exploitation Linux pour processeurs ARM , Armbian Bullseye sur armbian.com pour l’Orange pi zero 2 et le charger sur une carte microSD.

Obtenir l’adresse IP et se connecter en SSH.

Le Raspberry Pi OS en version Bullseye est téléchargeable sur le site de Raspberry. Choisissez la version avec Desktop uniquement.

Faire dans un terminal un raspi-config ou aller dans les paramètres pour activer l’accès SSH et l’accès VNC.
Configurer Samba si l’on souhaite accéder aux fichiers depuis son PC sous Windows plutôt que par SSH.

Installation Node JS

Dans les versions précédentes de Remote SDR, un serveur Apache distribuait les pages web. Depuis la version 5, c’est un serveur web basé sur Node JS qui est utilisé.

Passer en root si besoin avec:

sudo su

Téléchargez la version 16 ou une plus récente de Node JS puis lancez l’installation.

curl -sL https://deb.nodesource.com/setup_16.x | bash -

apt-get install -y nodejs

Rebootez le système.
Pour une première installation permettant de créer un projet, il faut plusieurs modules complémentaires pour gérer des pages web dynamiques et les communications réseau. Pour Remote SDR, créez un dossier remsdr à la racine et donnez lui dans un premier temps, tous les droits. Allez dans le dossier du projet:

cd /remsdr

Si on copie un projet existant., on peut passer cette étape

npm install html
npm install https
npm install ejs
npm install express
npm install jquery
npm install socket.io
npm install net
npm install fs
npm install cors
npm install xmlrpc
npm install onoff
npm install dgram

Géneration d’un certificat de sécurité

Pour Remote SDR, afin d’accéder au microphone du PC client, il faut accéder au serveur web sur le Raspbery/Orange pi en https. Dans les versions précédentes de Remote SDR, on mettait en place une dérogation. Ici, on va mettre un certificat de sécurité auto-signé qui facilitera l’accès au microphone.

Open SSL doit être installé de base sur votre système. Il permet la génération d’un certificat de sécurité afin d’accéder à votre site en https. Lancez la commande suivante:

openssl req -x509 -nodes -days 365 -newkey rsa:4096 -keyout selfsigned.key -out selfsigned.crt

Ces fichiers seront appelés par le serveur web (Radio_Server.js) réalisé avec node js.

Ci-dessous un extrait du code:

const http = require('http');
const https = require('https');
var httpserver = http.createServer(app);
const fs = require('fs');
const options = {
      key: fs.readFileSync('selfsigned.key'),
      cert: fs.readFileSync('selfsigned.crt')};

--_ Your Project ---

httpserver.listen(80);
https.createServer(options, app).listen(443);

Installation GNU Radio Companion

GNU Radio est un outil très puissant pour modéliser des chaines de traitement du signal. GNU Radio Companion est un outil complémentaire permettant de construire des chaines de traitement radio graphiquement sans écrire une ligne de code. Nous allons installer la version 3.9 à partir des sources sachant que le package binaire disponible actuellement est à la version 3.8 seulement. Cette version 3.9 nous permettra de rajouter à Remote SDR, les SDR de la famille SDR play comme le RSP1 et RSP1A qui couvrent les bandes HF radioamateur avec une dynamique de 12 à 14bits.

Dans le cas d’un Orange Pi Zéro 2 ne disposant que de 1GB de mémoire, la compilation du Source de Gnuradio est impossible. Le système va accéder à la mémoire swap sur la carte SD qui ne fait que 482Mo et cela n’est pas suffisant. On peut contrôler avec la commande:
swapon --show

Avec la commande htop, vous pouvez visualiser en temps réel l’utilisation du swap.
Vous pouvez rajouter 4GB puis revenir à la valeur d’origine du système une fois la compilation terminée. J’ai utilisé le tuto suivant:
https://linuxize.com/post/how-to-add-swap-space-on-debian-9/

Dans le cas du Raspberry 4B, les 2GB de mémoire suffisent. Il n’y a pas d’accès au swap.

Installation de librairies

Il faut mettre à jour votre système:
apt-get update apt-get upgrade

puis rajouter les librairies suivantes:

apt install git cmake g++ libboost-all-dev libgmp-dev swig python3-numpy \ python3-mako python3-sphinx python3-lxml doxygen libfftw3-dev \ libsdl1.2-dev libgsl-dev libqwt-qt5-dev libqt5opengl5-dev python3-pyqt5 \ liblog4cpp5-dev libzmq3-dev python3-yaml python3-click python3-click-plugins \ python3-zmq python3-scipy python3-gi python3-gi-cairo gir1.2-gtk-3.0 \ libcodec2-dev libgsm1-dev

Certaines de ces librairies sont peut-être déjà disponibles sur votre système.

apt install pybind11-dev python3-matplotlib libsndfile1-dev \ python3-pip libsoapysdr-dev soapysdr-tools

pip install pygccxml

pip install pyqtgraph

Installation de VOLK

VOLK est une bibliothèque de noyaux optimisés pour le traitement vectoriel. Elle contient des noyaux de code SIMD (Single Instruction Multiple Data) écrit à la main pour optimiser différentes opérations mathématiques. Son installation doit être faite avant Gnu Radio.

Se placer dans le dossier ~/Downloads#

git clone --recursive https://github.com/gnuradio/volk.git
cd volk
mkdir build
cd build
cmake -DCMAKE_BUILD_TYPE=Release -DPYTHON_EXECUTABLE=/usr/bin/python3 ../
make
make test
make install
ldconfig

Installation de Gnu Radio 3.9

Se placer dans le dossier ~/Downloads#

cd
git clone https://github.com/gnuradio/gnuradio.git
cd gnuradio

Forcer l’installation de la version 3.9

git checkout maint-3.9
mkdir build
cd build
cmake -DCMAKE_BUILD_TYPE=Release -DPYTHON_EXECUTABLE=/usr/bin/python3 ../

La compilation va prendre des heures. On utilise 3 coeurs (-j3) sur les 4 disponibles pour garder un peu de puissance pour surveiller le processus.

– make -j3
Ensuite on lance des tests avec probablement quelques erreurs sans importance.
– make test
– make install
– ldconfig

A ce stade, il est possible d’optimiser le traitement en exécutant Volk ou le reporter à plus tard.
–volk_profile

Pour les Orange Pi, installez LXTerminal

apt install lxterminal

Rajoutez au fichier de configuration /etc/gnuradio/conf.d/grc.conf ou /usr/local/etc/gnuradio/conf.d/grc.conf dans la section [grc]

[grc]
xterm_executable = /usr/bin/lxterminal

A ce stade vous pouvez faire un essai avec GNU-Radio. Passez en mode graphique à l’aide de VNC (utilisez par exemple VNC Viewer pour windows) si vous êtes distant . Port 5901 pour les Oranges Pi.

Lancez ‘Gnu Radio Companion’ , c’est un outil graphique fantastique pour créer des chaines de traitement du signal. Des exemples se trouvent dans le dossier /usr/share/gnuradio/examples ou /usr/local/share/gnuradio/examples/

Installation des drivers de SDR

Suivant les modèles de SDR que l’on souhaite utiliser, il faut installer les drivers correspondants ou tous les installer pour être universel. De plus, pour faciliter les interfaçages avec GNU-Radio, il faut des blocs comme SoapySDR (neutral SDR support library) ou Osmocom (Open source mobile communications) .

Installation de la librairie Soapysdr

Installer les librairies suivantes :
apt-get install libpython3-dev python3-numpy swig

Il ne faut pas installer la version 0.8 de SopySDR, car l’installation de librairies complémentaires pour les SDR ne fonctionne qu’avec la version 0.7

Ne pas installer ~~git clone https://github.com/pothosware/SoapySDR.git~~
Allez dans le dossier Tags sur le github de SoapySDR ( https://github.com/pothosware/SoapySDR/tags ) et télécharger le zip de soapy-sdr-07.2
Allez dans le dossier SoapySDR..

mkdir build cd build cmake .. make -j4 sudo make install ldconfig

Arrivé à ce stade, vous pouvez voir quel sont les drivers de SDR qui sont détectés avec la commande:
SoapySDRUtil --info

Vous ne trouvez encore aucun modèle de SDR sur la ligne ‘Available factories’ mais vérifiez la recherche de drivers dans le sous-dossier modules0.7 et non modules0.8

Installation des drivers pour RTL-SDR

Le SDR le plus connu qui se trouve sous différentes marques est le RTL-SDR. La version V3 peut même travailler en dessous de 28MHz avec des performances dégradées.

Installation de la bibliothèque USB et de l’outil de compilation:

apt-get install build-essential libusb-1.0-0-dev
apt-get install pkg-config

On clone rtl-sdr d’ Osmocom dans le dossier ~/Downloads# :
git clone https://github.com/osmocom/rtl-sdr.git

Allez dans le dossier rtl-sdr et enchainez les commandes:

cd rtl-sdr
mkdir build
cd build
cmake ../ -DINSTALL_UDEV_RULES=ON -DDETACH_KERNEL_DRIVER=ON
make
make install
ldconfig

Installez la librairie de développement :
apt-get install rtl-sdr librtlsdr-dev
puis cloner dans le dossier Downloads:

git clone https://github.com/pothosware/SoapyRTLSDR.git cd SoapyRTLSDR mkdir build cd build cmake .. make make install ldconfig

La commande :
SoapySDRUtil --find
permet de lister les SDR branchés à votre carte Orange ou Raspberry Pi.

La commande
SoapySDRUtil --probe="driver=rtlsdr"
donne tous les détails sur le RTL-SDR branché en USB.

De même avec un RTL-SDR sur le port USB on a des informations en tapant : rtl_eeprom
ou
rtl_eeprom -h

Installation des drivers pour HackRF One

Un premier paquet permet le contrôle du HackRF One.

apt install hackrf

En branchant un HackRF One sur le port USB de l’Orange/Raspberry PI, on peut vérifier sa présence en installant le paquet hackrf et tapant dans un terminal:
hackrf_info

Pour s’interfacer avec SoapySDR, allez dans le dossier Downloads et tapez la suite de commandes :
apt-get install libhackrf-dev git clone https://github.com/pothosware/SoapyHackRF.git cd SoapyHackRF mkdir build cd build cmake .. make sudo make install ldconfig

Pour avoir des détails sur les caractéristiques du HackRF, tapez dans un terminal:

SoapySDRUtil --probe="driver=hackrf"

Installation DES DRIVERS POUR Adalm-Pluto

L’Adalm-Pluto est une solution intéressante capable de travailler en Full-Duplex (réception et émission simultanées) dans une bande de fréquence comprise entre 325 MHz à 3,8 GHz. Il est possible d’étendre la gamme de fréquence du Pluto de 70MHz à 6GHz. Cela est décrit dans l’article suivant : https://f1atb.fr/index.php/fr/2021/03/09/extension-en-frequence-du-pluto-sdr/

Le Pluto s’interface par le port USB qui se comporte comme un port ethernet. Il ne faut pas l’alimenter par le port USB de l’Orange/raspberry Pi, car il y a des coupures dans la liaison. En complément rajoutez une alimentation 5V2A extérieure. Le Pluto dispose d’une entrée micro USB pour l’alimenter.

Vérifiez que les modules suivants sont présents avec :
lsmod. Ils sont absents avec certaines versions d’Armbian / Debian.

cdc_acm,cdc_ether
rndis_host
rndis_wlan
usbnet

Si un module manque tapez:

modprobe « nom du module »

modprobe rajoute les modules avec leurs dépendances, ainsi en rajoutant par exemple cdc_ether, usbnet sera également rajouté. Après chaque installation faite un lsmod pour vérifier.

Avec l’orange pi zero 2, ces modules ne sont pas tous disponibles sur l’os Armbian , mais cela ne semble perturber le fonctionnement. Il manque cdc_ether et usbnet. De même avec le Rasopberry Pi 4, il manque usbnet.

Comme recommandé sur le site d’Analog Device, rajoutez dans le dossier
/etc/udev/rules.d/
le fichier de règles: 53-adi-plutosdr-usb.rules donnée ci-dessous. Faites :

nano /etc/udev/rules.d/53-adi-plutosdr-usb.rules

# allow "plugdev" group read/write access to ADI PlutoSDR devices
# DFU Device
SUBSYSTEM=="usb", ATTRS{idVendor}=="0456", ATTRS{idProduct}=="b674", MODE="0664", GROUP="plugdev"
SUBSYSTEM=="usb", ATTRS{idVendor}=="2fa2", ATTRS{idProduct}=="5a32", MODE="0664", GROUP="plugdev"
# SDR Device
SUBSYSTEM=="usb", ATTRS{idVendor}=="0456", ATTRS{idProduct}=="b673", MODE="0664", GROUP="plugdev"
SUBSYSTEM=="usb", ATTRS{idVendor}=="2fa2", ATTRS{idProduct}=="5a02", MODE="0664", GROUP="plugdev"
# tell the ModemManager (part of the NetworkManager suite) that the device is not a modem, 
# and don't send AT commands to it
SUBSYSTEM=="usb", ATTRS{idVendor}=="0456", ATTRS{idProduct}=="b673", ENV{ID_MM_DEVICE_IGNORE}="1"
SUBSYSTEM=="usb", ATTRS{idVendor}=="2fa2", ATTRS{idProduct}=="5a02", ENV{ID_MM_DEVICE_IGNORE}="1"

Pour faire fonctionner l’Adalm-Pluto avec GNU Radio, il faut installer les paquets suivants:

apt-get install gr-iio
apt-get install libiio-utils
apt-get install gqrx-sdr

Une fois l’installation faite vous pouvez vérifier l’accès au Pluto avec la commande:

ssh root@192.168.2.1

Le Pluto se connecte physiquement par USB, mais est accessible en ssh via une adresse IP 192.168.2.1. Le mot de passe est ‘analog’.

Pour accéder à distance au Pluto, il faut rajouter le paquet paramiko.
apt-get install python3-paramiko

Pour tester l’interface avec l’Adalm-Pluto, vérifiez qu’il est visible dans la liste des périphériques connectés en USB en tapant dans un terminal : lsusb

Pour s’interfacer avec SoapySDR, installez :
apt install libiio-dev libad9361-dev libspdlog-dev python3-packaging

Allez dans le dossier Downloads et tapez la suite de commandes :
git clone https://github.com/pothosware/SoapyPlutoSDR cd SoapyPlutoSDR mkdir build cd build cmake .. make sudo make install ldconfig

Pour connaitre tous les détails sur un Adalm-Pluto connecté en USB, tapez:
SoapySDRUtil --probe="driver=plutosdr"

Installation DES DRIVERS POUR SDRPLAY :RSP1 et RSP1A

La famille des SDR de marque SDRplay est intéressante pour couvrir les bandes basses HF des radioamateurs, pas couverte spar le Pluto ou partiellement par les clés RTL-SDR. De plus, ils offrent une dynamique de 12 ou 14 bits. Pour moins de 30€ en Chine, vous trouvez des équivalents au RSP1.

Il faut se rendre sur le site de sdrplay.com et allez dans les pages dédiées au téléchargement.

Pour l’Orange Pi Zero2, il faut télécharger l’API v3
SDRplay_RSP_API-ARM64-3.07.1.run

Avec une commande chmod 755 SDR… rendre le fichier executable puis:
sh SDRplay_RSP_API-ARM64-3.07.1.run

La version 64 bits de ‘Orange Pi Zero2 ne fonctionne pas pour le Raspberry Pi4. Ce sera la version 32 bits SDRplay_RSP_API-ARM32-3.07.2.run. Il propose un script d’installation dans un zip.

Dezipez l’ensemble et rendre le script executable, puis:

sh 1installAPI.sh

Répondre Y à la licence puis rebooter l’Orange/Raspberry Pi.

Pour s’interfacer avec SoapySDR, allez dans le dossier Downloads et tapez la suite de commandes :
git clone https://github.com/pothosware/SoapySDRPlay3 cd SoapySDRPlay3 mkdir build cd build cmake .. make make install ldconfig

Pour connaitre tous les détails sur un SdrPlay connecté en USB, tapez:
SoapySDRUtil --probe="driver=sdrplay"

Arrivez à ce stade, vous avez toute la liste des SDR adressables par SoapySDR avec la commande :
SoapySDRUtil --info

Modification pour RSP2

A ce jour (septembre 2022), je ne dispose pas d’un RSP2. En prenant la main à distance sur le Raspberry PI4 d’un OM avec un RSP2, j’ai pu faire fonctionner Remote SDR en modifiant une variable dans l’application GNU-RADIO fichier /remsdr/PY/RX_SdrPlay_sanw_v5.grc. Il s’agit du nom de l’antenne.

Je n’ai pu investiguer plus loin.

Installation Interface Série pour SA818

Le module SA818 permet d’émettre en VHF ou UHF en NBFM avec une puissance de 1w. Ce n’est pas un SDR mais il est pratique pour réaliser un petit émetteur pilotable à distance par Remote SDR. Il s’interface à l’Orange Pi Zero 2 par le port série UART5 et la sortie audio analogique ‘Line Out’. Il faut installer la bibliothèque python d’accès au port série :

pip3 install pyserial-asyncio

Installation bloc gr-osmocom pour Gnu Radio

Installation optionnelle si l’on souhaite utiliser Osmocom dans Gnu Radio

Pour interfacer un SDR dans Gnu Radio avec Osmocom, il faut installer gr-osmocom. Allez dans le dossier Downloads puis les commandes:
git clone git://git.osmocom.org/gr-osmosdr cd gr-osmosdr/ mkdir build cd build/ cmake ../

Bien lire le résultat de cmake afin d’identifier les drivers qui ont été trouvés et ceux qui ne le sont pas. Corriger si besoin.

######################################################
— # Gnuradio enabled components
— ######################################################
— * Python support
— * IQ File Source & Sink
— * Osmocom RTLSDR
— * RTLSDR TCP Client
— * HackRF & rad1o Badge
— * RFSPACE Receivers
— * SoapySDR support
— * Red Pitaya SDR

Pluto et SDRplay ne sont pas dans pas dans la liste. On passera par SoapySDR pour s’interfacer avec les RSP1 , RSP1A et Pluto.

Puis lancer la compilation:
make make install ldconfig

À présent le bloc Osmocom apparait dans GNU-Radio Companion.

Installation fichiers Remote SDR

Copiez dans le dossier remsdr les fichiers source de Remote SDR mais ne pas modifier les dossiers et fichiers existants suite à l’installation des packages ci-dessus. À savoir : node_modules,package-lock.json et package.json.
Il en est de même pour les 2 fichiers du certificat de sécurité.

Tous les fichiers nécessaires à l’exécution de Remote SDR sont à installer dans le dossier /remsdr . Dans un premier temps pour faciliter le transfert depuis la source téléchargée sur Github vers l’Orange/Raspberry Pi, il est préférable de donner toutes les autorisations au dossier .
chmod -R 777 /remsdr

Une fois tout opérationnel, on pourra limiter les droits d’accès au strict nécessaire.

Lancement de Remote SDR

Si vous utilisez un Adalm-Pluto, un seul Orange PI Zero 2 ou un seul Raspberry Pi4 est nécessaire.

Si vous utilisez un HackRF en émission et un hackRF en réception vous aurez besoin de 2 Orange Pi Zero 2 avec la même configuration ou d’un seul Raspberry Pi 4.

Pour lancer le ou les serveurs web, allez dans le dossier /remsdr et tapez:

node Radio_Server.js

Depuis un PC client vous vous connecter à l’Orange/Raspberry PI dédié à la réception à l’adresse :

https://192.168.xx.xx

Notez que les échanges se font en https sur le port 443 habituel . Tout est échangé via ce port. On utilise plus comme dans les versions précédentes les ports 8001 à 8005.

Néanmoins, depuis la version v3 de Remote SDR, il est possible de s’interfacer avec Gpredict via le port 8006 pour le récepteur et 8007 pour l’émetteur.

Depuis la version v4.3 de Remote SDR, il est possible de s’interfacer avec VSPE / Omnirig via le port 8008 ce qui permet de dialoguer avec d’autres logiciels comme WSJT-X.

Lancement au boot

Pour un lancement automatique au boot de l’Orange/Raspberry Pi, ouvrir le fichier crontab:

crontab -e

En bas de page rajouter la ligne suivante:

@reboot /usr/bin/node /remsdr/Radio_Server.js

A présent, suite à un reboot, le server « Radio_Server.js » doit se lancer automatiquement.