venerdì 15 gennaio 2021

BladeRF-Wiphy is an open-source IEEE 802.11 compatible software defined radio VHDL modem

What is the bladeRF-wiphy project?

The bladeRF-wiphy project is an open-source IEEE 802.11 compatible software defined radio VHDL modem. The modem is able to modulate and demodulate 802.11 packets (the protocol WiFi is based on), and run directly on the bladeRF 2.0 micro xA9’s FPGA.

The bladeRF-wiphy coupled with Linux mac80211 allows the bladeRF 2.0 micro xA9 to become a software defined radio 802.11 access point! 802.11 packets (PDUs) are modulated and demodulated directly on the FPGA, so only 802.11 packets are transferred between the FPGA and libbladeRF.

Documentation

A technical deep dive of bladeRF-wiphy https://www.nuand.com/bladeRF-wiphy/

Instructions to compile, install, and run bladeRF-wiphy and tools https://www.nuand.com/bladeRF-wiphy-instructions/

Instructions to simulate bladeRF-wiphy: https://www.nuand.com/bladeRF-wiphy-simulation/

 

Features
  • IEEE 802.11 compatible FPGA based PHY receiver and transmitter
  • Compatible with bladeRF 2.0 micro xA9
  • Linux mac80211 MAC integration
  • RX and TX monitor mode support
  • Hardware Distributed Coordination Function (DCF) allows quick turn-around time ACKs
  • High-performance equalizer – implements Zero Forcing (ZF) and optionally Decision Feedback Equalizer (DFE)
Modulation schemes
  • DSSS - CCK
  • OFDM - 20MHz (6Mbps, 9Mbps, 12Mbps, 18Mbps, 24Mbps, 36Mbps, 48Mbps, 54Mbps)
Modulation constellations
  • DSSS-CCK DBPSK
  • OFDM-BPSK
  • OFDM-QPSK
  • OFDM-16-QAM
  • OFDM-64-QAM
Contact information

Email: bladeRF@nuand.com

Slack: See Slack section on this page

 

Tag: #GiammaIoT @GiammaIoT @GiammaIoT2 #SoftwareDefinedRadio #BladeRF #open-source #IEEE802.11 #VHDL #modem

OpenWebRX Web Page For Mobile Device

Shared Link: https://github.com/bclswl0827/webrx4mobile

OpenWebRX web page suitable for mobile devices.

Try it

Now, it's available on s.ibcl.us/webview/m.wrx, where you can have a try.

Preview

iPhone 8

Google Pixel

How to

You just need to replace the files in htdocs folder.

License

MIT


Tag: #GiammaIoT @GiammaIoT @GiammaIoT2 #SoftwareDefinedRadio #WebServer #OpenWebRX #OpenWebRXMobile

RetroGram~RTLSDR Spectrum analyzer on your terminal/ssh console with ASCII art ~ RTLSDR

Shared Link: https://github.com/r4d10n/retrogram-rtlsdr

          _                                      /\/|    _   _ _________________ 
         | |                                    |/\/    | | | /  ___|  _  \ ___ \
 _ __ ___| |_ _ __ ___   __ _ _ __ __ _ _ __ ___    _ __| |_| \ `--.| | | | |_/ /
| '__/ _ \ __| '__/ _ \ / _` | '__/ _` | '_ ` _ \  | '__| __| |`--. \ | | |    / 
| | |  __/ |_| | | (_) | (_| | | | (_| | | | | | | | |  | |_| /\__/ / |/ /| |\ \ 
|_|  \___|\__|_|  \___/ \__, |_|  \__,_|_| |_| |_| |_|   \__|_\____/|___/ \_| \_|
                         __/ |                                                   
                        |___/                                                    

Wideband Spectrum analyzer on your terminal/ssh console with ASCII art. Hacked from Ettus UHD RX ASCII Art DFT code for RTLSDR. Adapted from retrogram~plutosdr.

retrogram-rtlsdr-vhf [Tuning on VHF band while transmitting on 145.500 MHz with Handheld Radio]

retrogram-rtlsdr-gsm [Spotting FCCH (Freq. Correction) burst in the local GSM BCCH (Broadcast Control Channel) @ 938.2 MHz]

Pan & Zoom spectrum using keyboard controls [decrement-Increment]. [Full feature demo]

  • Center Frequency using keys [f-F]
  • Sampling rate using keys [r-R]
  • Gain using keys [g-G]
  • Reference level using keys [l-L]
  • Dynamic Range using keys [d-D]
  • Frame rate using keys [s-S]
  • Tuning step using keys [t-T]
  • Hide/Show Controls using keys [c-C]
  • Quit program using keys [q-Q]

Tuning step applies for decrementing / Incrementing Center Frequency and Sampling Rate.


retrogram~rtlsdr - ASCII Art Spectrum Analysis for RTLSDR

Allowed options:
  --help                   help message
  --dev arg (=0)           rtl-sdr device index
  --rate arg (=1000000)    rate of incoming samples (sps) [r-R]
  --freq arg (=100000000)  RF center frequency in Hz [f-F]
  --gain arg (=0)          gain for the RF chain [g-G]
  --frame-rate arg (=15)   frame rate of the display (fps) [s-S]
  --ref-lvl arg (=0)       reference level for the display (dB) [l-L]
  --dyn-rng arg (=80)      dynamic range for the display (dB) [d-D]
  --step arg (=100000)     tuning step for rate/bw/freq [t-T]
  --show-controls arg (=1) show the keyboard controls

 
Requires: librtlsdr, libcurses, libboost-program-options
sudo apt install librtlsdr-dev libncurses5-dev 
libboost-program-options-dev
Build:

For running on a Linux host with RTLSDR

make
Run:
./retrogram-rtlsdr --rate 1.8e6 --freq 100e6 --step 1e5
TODO:
  • Generic support for osmosdr / soapysdr devices
  • Direct Freq Entry / parameter change
  • Mouse tuning
  • Modularize / Optimize with std::vector transform
  • Waterfall (!) / Markers / Demodulators (!!) :)
  • HTML output / Web(sockets)-server

 

Tag: #GiammaIoT @GiammaIoT @GiammaIoT2 #SoftwareDefinedRadio #Spectrogram #Analyzer #Terminal #SSH #RTLSDR #RetroGram #ASCII

mercoledì 13 gennaio 2021

PiRadio Turn Raspberry Pi into a radio (Radiko, Rajiru Rajiru, SDR compatible) by takao-t

Shared Link: https://github.com/takao-t/piradio

Turn Raspberry Pi into a radio (Radiko, Rajiru Rajiru, SDR compatible)

sample pirate pirate_radio_s

What you need:

Use the following, which are also found in every home

  1. Raspberri Pi 3 or 4 or Zero W
  2. 5 switches to connect to GPIO (PUSH ON) 5 pull-up resistors (*) The basic number is 5, but you can operate with at least 2.
  3. LCD that can be used as a frame buffer (/ dev / fbX) (320x240 is assumed in this script) I'm using Adafruit's Pi TFT mini (2.8 "), but it doesn't support touch because it's not compatible with the touch panel. It's just a switch operation. Even the cheap SPI TFT sold in that area can be used if it can be operated as / dev / fbX.
  4. Suitable TTF font for Japanese display
  5. Please install ffmpeg separately. Use ffplay.

*: When connecting a switch to GPIO, pull it up and connect the switch between the pin and GND.

Normal (piradio.py) version

Since pygame is used for the screen, a frame buffer that can be used with pygame is required. For now for Python 2.7

Pirate Audio (piradio_pirate.py) (

The screen is written in PIL. Pirate Audio does not work as a framebuffer, but it requires the SPI LCD Python library. See Pirate_README.txt.

There are many Radiko playback scripts here and there, but since the source is not clear, I wrote a new one and implemented it in radiko.py. It also supports Radiko Premium. If you want to use area free, you can use it by registering for premium and setting your e-mail address and password. In order to avoid frequent logins when using Premium, cookie information is stored in the current directory, so start it in a directory where scripts can be written. Modify the script if you want to save the cookie elsewhere.

Even if there is no frame buffer, it will be a radio for API operation. If you start it with -nogui, it will work only with API. However, the volume at the initial startup is too low, so adjust vol_val and start it.

Please refer to the Wiki for detailed explanation and usage.

The chassis data is here https://www.thingiverse.com/thing:4417542

Update information and detailed usage etc. can be found on the Wiki https://github.com/takao-t/piradio/wiki

Let's make a radio

radio PirateAudio

A project to make a radio because radio is more interesting

However, since it is the 21st century, we will use Radiko instead of 6-stone supermarkets.

Currently, it supports Radiko, Rajiru Rajiru, FM reception by SDR, and stream playback.

There is also a Pimoroni Pirate Audio compatible version

I don't have anything

I bought a Raspberry Pi. A PC + audio interface will do the trick, though. Basically, it works if you can handle audio devices in an environment where Python works.

I only have a Raspberry Pi

If you start it with python piradio.py -nogui, it will start without GUI. Since there is an API, it is an ant if you want to make a radio controlled by a browser. In this case, you cannot control the volume (the API has no volume), so pay attention to the initial value of the volume. When controlling from a browser, you can see it by looking at index_sample.php under the attached webui, but if there is a directory called stations / under this PHP, and there is a station list and icon file called station_list, it will look like A crappy page is displayed. In short, it's easy to make a symbolic link from the stations / directory of piradio. Whether it's API or webui, it's super messy, so please use it only in a LAN environment.

I have a Raspberry Pi and an LCD

In this case, you can use the GUI, but you need 5 pushbutton switches for operation. Connect the switch between a free GPIO and GND. It's safe to do a pull-up, but depending on the pin, the Raspberry Pi pull-up alone is fine.

I'm not sure how to set up the LCD because I don't know what the LCD you have, but basically it should work if it's a framebuffer that can be used with Pygame. The expected resolution is 320x240 dots, and I used Adafruit's Pi TFT mini (2.8 ") at the time of development. It can also be used with SPI TFT LCDs, which are sold at a bargain price. However, you need something that is supported by fbtft and is recognized as a framebuffer. If you try it and you know how to use it even if it is sold at a bargain price such as amazon (2.4 "is cheap), it will work without much trouble. Since you know how to use it, you will not have any trouble. but.

Anyway, the display used by the regular version of piradio.py is the framebuffer used by Pygame. X does not need to work, but it should be recognized and work as / dev / fbX.

I want to be cool

If you are good at woodworking, it is cool to make a cabinet.

For those who have a 3D printer, we publish the 3D data of the cabinet.

https://www.thingiverse.com/thing:4417542

This cabinet has a 5cm speaker underneath, so it's easy to buy a USB-connected speaker that uses a 5cm unit, disassemble it, and push it in. You may have a little trouble fixing the speaker, but please screw it or stick it with double-sided tape.

When using Pi2 / Pi3, please use a case with holes. USB and LAN come out next to it, so it's a bit clunky, but you can also make it a wired type. When using a USB speaker, pull out the cable from the gap and insert it. It would be nice if the Pi had a USB header on the board, but unfortunately it doesn't.

I want to buy something

For those who don't have anything but want to buy something, the Raspberry Pi Zero WH and Pimoroni Pirate Audio are recommended. https://github.com/takao-t/piradio/wiki/Pimoroni-Pirate-Audio%E3%82%92%E3%83%A9%E3%82%B8%E3%82%AA%E3%81% AB% E3% 81% 97% E3% 82% 88% E3% 81% 86

There are three types of Pirate Audio, and I'm wondering which one to buy, but the only difference is the audio output method, so I choose what I want to connect to. With Pirate Audio with speakers, it's the smallest radio.

We also have a frame that can be printed in 3D.

https://www.thingiverse.com/thing:4420857

Application

In short, I'm just writing a front end for playing Radiko, so if you apply it, you can use it for other things as well.

As you can see from the inside, since I am writing a program to kick with the playback method and its method, it is easy to apply by touching the source.

If you look at start.php etc., you can see how to kick with API, so you can prepare it with cron and wake up.

It is easy to support if the station supports stream (simul) even in community FM. If you know the stream URL, you can play it, so you can use it because it can be incorporated into the station list.

Tag: #GiammaIoT @GiammaIoT @GiammaIoT2 #SoftwareDefinedRadio #SoftwareDefinedRadios #Standalone #Raspberry

martedì 12 gennaio 2021

ESA (European Space Agency) SSDR - High-end satellite software defined radio (SSDR) platform

Shared Link: https://artes.esa.int/projects/ssdr

Objectives

The objective of this project is to develop a new Software Defined Radio (SDR) platform specially designed for the implementation of high-end satellite communication applications. The new platform is modular, with a carrier board having the capability of plugging powerful FPGA SoC modules and radio front-end modules and high-speed DACs and ADCs into FMC+ connectors.

In the photo below, the carrier board is mounted in the 19” rack mechanical enclosure. 

The FPGA SoC module developed in this project can be seen in the photo below.

Challenges

Key challenges of the project are:

  • Complex PCB layout of the FPGA SoC processing module where the need for interconnecting large amount of DDR4 RAM to the SoC FPGA must be balanced against the need for a large number of high-speed transceiver lines in a small PCB area
  • High speed transceiver interconnects via 2 x FMC+ connectors between FPGA SoC ICs and between FPGA SoC ICs and high speed ADCs, DACs and Ethernet fibre interfaces
  • Implementation of a flexible software framework to automate the generation of the management interfaces of the applications running on the platform
Benefits

This project involves the development of a new software defined radio platform specially designed for implementation of high-end satellite communication applications. The name of the platform is the WideNorth Satellite Software Defined Radio (SSDR) platform. Main differentiators from COTS processing boards are:

  • Integrated large amount of high speed DDR4 memory with SoC FPGA
  • Support for 2 x SoC FPGA modules
  • Tailored for use with high-end DACs, ADCs and radio front-ends
  • Support for up to 4 x DAC / ADC / radio front-end modules
  • Available in 19” rack mountable mechanics with integrated power supply and touch screen
  • SW framework for automatic generation of management interfaces (Web, ssh, SNMP, Python scripts)
Features

The WideNorth SSDR platform is a powerful system on a chip (SoC) FPGA platform where SoC FPGA modules can be plugged in to a carrier board using FMC+ connectors, and where radio front-end modules can be connected as FMC/FMC+ plugin boards.

In the minimum configuration, the WideNorth SSDR is equipped with one FPGA module. The SSDR can be delivered as bare circuit boards only (without mechanics) or mounted inside a 19” rack mountable mechanical enclosure.

For the applications that are to be implemented on the SSDR platform, a software framework is available for automatic generation of management interfaces like web-interface, command line interface, and SNMP.

System Architecture

The block diagram below illustrates the top level architecture of the SSDR processing platform. The platform consists of a carrier board with one, or optionally two, SoC FPGA processing module(s) mounted. The yellow blocks in the block diagram are only available when the second SoC FPGA module is mounted. The platform is designed to be as generic as possible, to be compatible with new ADCs, DACs, and radio front-end modules that will enter the market in the coming years. The SoC FPGA module is built around the Xilinx Zynq UltraScale+ SoC EG family, and the PCB design supports the ZU11EG, ZU17EG, and the ZU19EG devices. The primary SoC processing module is connected to multiple FMC+ connectors that support ADCs, DACs and narrow band receiver mezzanine boards. The carrier board provides the main 10Gbps SFP+ interface, the dual LAN interface as well as the USB, display port and serial debug interface.

In the project, a SW tool referred to as the Interface Generator (IG) is developed in Python. The main focus is to generate a Web Interface for regular user interaction and a Python interface for automating the testing of the applications running on the SDR platform. In addition, to simplify documentation and ease generation of software code for management interface, an Interface Control Document is generated automatically in the process.

The figure below offers an overview of the management interfaces and SW stack developed in this project for the SDR platform.

Plan
  • Kick-off: November 2017
  • Design Review (DR): February 2018
  • Acceptance Test (AT): September 2019
  • Final Review (FR): October 2020
Current status

The development of the new SDR platform was completed in September 2019, and the first unit was delivered to a customer in the second quarter of 2020.

Example of applications that have been implemented and demonstrated on this new SDR platform are:

  • 5 Gbps, 1400 Msps DVB-S2X Satellite Modem
  • 1500 MHz satellite channel simulator for Low Earth Orbit

The final review of the project was carried out in October 2020. 

CentSDR - Tiny Standalone Software Defined Receiver

Shared Link: https://github.com/ttrftech/CentSDR

About

CentSDR is tiny handheld standalone software defined receiver with LCD display, that is simple, low budget, but has reasonable perfomance. This project is aimed at contributing to studies, experiments and educations around RF technology.

Block Diagram

Build Firmware

Prepare ARM Cross Tools

Install cross tools and firmware updating tool.

$ brew cask install gcc-arm-embedded
Fetch Source

Clone source code from github.

$ git clone https://github.com/ttrftech/CentSDR centsdr

Then fetch ChibiOS submodule into tree.

$ cd centsdr
$ git submodule update --init --recursive

Just make in the top directory.

$ make
Flash firmware

Using OpenOCD and gdb

Prepare openocd.

$ brew install openocd

Connect ST-Link2 to target board, then launch openocd as follows.

$ openocd -f board/stm32f3discovery.cfg

Flash firmware using gdb.

$ arm-none-eabi-gdb 
> target extended-remote :4242
> exec build/ch.elf 
> load
> quit

Or use gdb script to flash.

$ arm-none-eabi-gdb -x flash-openocd.gdb --silent

Using st-util and gdb

Prepare stlink utilities.

$ brew install stlink

Connect target board via SWD with ST-Link2, In other terminal, launch st-util

$ st-util

Then, flash the firmware.

$ arm-none-eabi-gdb -x flash-stutil.gdb --silent
Flash firmware using Nucleo st-link v2.1

Or you can flash the firmware using Nucleo. First, mount as usb mass storage device, then copy 'build/ch.bin' file into mounted volume.

Attention

This repository contains only source of CentSDR firmware, but NO hardware design resources.

Reference

[EOF]

  

Tag: #GiammaIoT @GiammaIoT @GiammaIoT2 #SoftwareDefinedRadio #SoftwareDefinedRadios #CentSDR #Tiny #Standalone #Receiver


SkyScan: Automatically photograph planes that fly by!

Shared Link: https://github.com/IQTLabs/SkyScan

Follow allowing as we build, here

Airbus A321 Airbus A321 at 32,000 feet

Overview

To enable better tracking, most planes broadcast a signal known as Automatic Dependent Surveillance–Broadcast or ADS-B. This signal is at 1090MHz and can be easily received using a low cost Software Defined Radio (SDR), like the RTL-SDR which repurposes a digital TV chip.

From the ADS-B transmissions, you can get a plane's location and altitude. If you know where a plane is and where you are, you can do some math and point a camera at the plane and take a picture. If you have a Pan/Tilt camera lying around, you can have it automatically track a plane as it flies by and snap photos.

Hardware

The project works with the following hardware. It should be easy to extended to work with other SDRs or cameras... but that is on you.

  • Raspberry Pi 4
  • Axis m5525 Axis has a great API for their network cameras, and it should work with any of there PTZ cameras. The m5525 is nice because it supports continuous 360 degree rotation. You can literally have it spin around in circles, giving you complete coverage. It also has 10x optical zoom.
  • Pan Tilt Hat & Raspberry Pi Camera - This is the budget option. It is a small kit that uses servo motors to move the Raspberry Pi Cam around. It only has about 170 degrees of panning and the positioning is not that accurate. Since the Pi Cam is used, it is not zoomed in much. If you are in a spot where planes are flying low overhead, this could be a perfect solution.
  • RTL-SDR This is nice and stable RTL-SDR. It is compact and doesn't block all the other ports on a Pi. Since you are just trying to capture local planes, you can get away with using any antenna you have lying around.
Software Architecture

The different components for this project have been made into Docker containers. This modularity makes it easier to add in new data sources or cameras down the road. We have found containers to work really well on the Pi and the help enforce that you have properly documented all of the software requirements.

+-------------+      +-------------+           +---------------+            +--------------+
|             |      |             |           |               |            |              |
|             |      |             |           |               |            |  Axis+PTZ    |
| Pi+Aware    +----->+  ADSB+MQTT  +---------->+ Tracker       +----------->+              |
|             | TCP  |             |  MQTT     |               |  MQTT      |              |
|             |      |             |  all      |               |  only      |              |
+-------------+      +-------------+  planes   +---------------+  tracking  +-------+------+
                                                                  plane             |
                                                                                    | HTTP API
                                                                                    | Pan/Tilt
                                                                                    v
                                +--------------------+                     +--------+---------+
                                |                    |                     |                  |
                                |                    |                     |                  |
                                |   MQTT Broker      |                     |    Axis m5525    |
                                |                    |                     |    Camera        |
                                |                    |                     |                  |
                                |                    |                     |                  |
                                +--------------------+                     +------------------+

Here is a brief overview of each component. There are additional details in the component's subdirectory

  • mikenye/piaware - This is a dockerized version of FlightAware's PiAware program. PiAware is actually just a wrapper around dump1090. Dump1090 is a small program that can use an RTL-SDR to receive an ADS-B transmission. The program uses these transmission to track where nearby planes are and display then on a webpage. It also output all of the messages it receives on a TCP port, for other programs to use. We use this connection to get the plane information. PiAware adds the ability to send the information to FlightAware. You could probably just switch this to only use Dump1090.

  • ADSB-MQTT Is a small python program that reads in information collected by Dump1090 over a TCP port and publishes all the messages it receives onto the MQTT bus.

  • tracker Receives all of the plane's location, determines how far away from the camera each one is and then finds the closest plane. The location and relative position of the closest plane is periodically published as an MQTT messages. Tracker needs to know the location and altitude of the camera in order to determine the planes relative position.

  • axis-ptz Receives updates on which plane to track over MQTT and then directs the PTZ camera towards the plane and takes a picture.

Configure

In order to start PiAware, you need to register with Flight Aware and request a Feed ID. There are directions on how to do that here.

Copy the env-example file to .env. Edit the .env file to include the correct values.

Operations

Launch the application using docker-compose:

docker-compose up

A web interface will be available on port 8080. As pictures of planes are captured they will be saved in folders in the ./capture directory.

Enable Raspi-camera

If you are using the Pan Tilt hat, you will need to make sure the Pi Camera has been configured correctly: In the base OS on the Pi make sure the Camera is enabled:

sudo raspi-config
  • Interfacing Options
  • Camera
  • Enable 

 

Tag: #GiammaIoT @GiammaIoT @GiammaIoT2 #SoftwareDefinedRadio #SoftwareDefinedRadios  #ADSB #Automatically #Photograph#Planes #Raspberry #MQTT #RTLSDR #Dump1090 #PiAware #PTZ #Camera