RTL-SDR - what else we can do?

In the previous post, I showed how you can listen to traditional FM radio using an RTL-SDR dongle with SDR# software.

In general, it all comes down to the antenna you have. The RTL-SDR works great as a frequency scanner when paired with wideband antennas. But even with the stock kit antennas you can still pick up a few interesting signals.

Listening to PMR (walkie-talkie).

This is the simplest example to show how you can hear transmissions from another radio device using an RTL-SDR kit and the included antennas.

Step 1. Prepare walkie-talkie device.

Motorola T82 Extreme will be used as a transmitter. Let's set it to channel 1 with no subtones (CTCSS).

Step 2. Set up antenna. 

Channel 1in PMR has 446,00625 Mhz frequency. The wavelength is 0,672 m. So for our kit antenna (which is a half-wave dipole), we need to set each arm to one quarter of the wavelength - about 16,8 cm. 

To be precise, remember that the dipole base adds about 2 cm of metal length to each arm, so you should subtract those 2 cm from the calculated arm length - set each arm to about 14.8 cm:

Step 3. Set SDR# and start transmitting on PMR.

In order to receive PMR transmission do the following:

1. Manually set the 446,00625 MHz (channel 1 in PMR)
2. Set NFM for modulation and bandwidth filter 12,5 kHz.
3. Set squelch to 50 (because PMR is very close to antenna)
4. Set RF Gain to minimum (same reason - PMR very close to antenna)
5. Start transmitting on PMR.
6. Press play and You should hear the PMR:

Listening to weather station

Another interesting idea is capturing transmissions from wireless temperature/humidity sensors used in home weather stations. They operate at 433 MHz, but they’re far from the only devices using that band. You’ll also find it in things like car tire pressure sensors (TPMS) and garage/gate remote controls.

In SDR#, you can of course detect the RF transmission itself, but in this case you can do more than that: you can decode the transmission and display the information it contains.

Step 1: Prepare wireless sensor.

Step 2: Set up antenna.

The wavelength is 0,692 m. So for our kit antenna (which is a half-wave dipole), we need to set each arm to one quarter of the wavelength - about 17,3 cm. 

To be precise, remember that the dipole base adds about 2 cm of metal length to each arm, so you should subtract those 2 cm from the calculated arm length - set each arm to about 15,3 cm.

Step 3. Set SDR# - plugin

First we need a plugin for SDR# which "understands" the transmission on 433 MHz and knows how to decode it. You can download it from there: https://github.com/marco402/plugin-Rtl433-for-SdrSharp/tree/master/install. Just download a zip file which is correct for Your SDR# version. In my case, my SDR# i 32 bit, so I download file named last_x86.zip.

Then locate plugin directory under Your SDR# installation path. It should be folder named Plugins. Cteate a folder inside named RTL_433 and unpack content of last_x86.zip there. It will be 3 .dll files. Once done, It should look like this:

Step 4. SDR# - set up plugin

Open installed plugin by clicking on "hamburger" button, then Plugins, then RTL_433:

Then configure it:

Step 4: SDR# - listen and decode.

The order is important here. 

1. Press main play button in SDR#, 
2. Enable plugin by selecting checkbox in it. 
3. Press Start button in the plugin window (make sure frequency in plugin is set to 433 MHz). 
4. Main frequency in SDR# will be set to frequency selected in plugin:

When SDR# receives a transmission from the sensor, a pop-up window appears showing the received, decoded message. In this case, two windows popped up because I have two sensors: one outdoor sensor and one indoor sensor. We can see temperature and humidity, and some other technical information about the certain message in transmission.

RTL-SDR - radio waves on Your computer

One day I thought to myself that I’d like to listen to “classic” radio - the kind one where you dial in the frequency and adjust the antenna, not something streamed over the internet. And instead of using a traditional receiver (which I don’t own), I chose an RTL-SDR from that site: https://www.rtl-sdr.com/about-rtl-sdr/

I chose the kit that comes with antennas (https://www.rtl-sdr.com/buy-rtl-sdr-dvb-t-dongles/) and followed the software installation instructions (https://www.rtl-sdr.com/rtl-sdr-quick-start-guide/).

Below there is a step-by-step list of what you need to do to listen to traditional radio using your computer.

Installing software

Step 1. Go to https://airspy.com/download/ and download Software Defined Radio Package.

This is an application that will decode radio waves into sound. It's name is SDR# (SDRSharp). Please note that if You use top download button for downloading Software Defined Radio Package You will download 32-bit version of the software. This may be important if You plan to install additional plugins.

Step 2. Unpack downloaded .zip file to the desired location:

Step 3. As an administrator run the install-rtlsdr.bat. That script will download a driver for Your RTL-SDR dongle with a small application named Zadig which will be used to install that diver in Windows.

Step 4. First plug in Your RTL-SDR dongle in the USB then as an administrator run zadig.exe. Then make sure that below options are changed in Zadig:

• List all devices - make it checked
• Ignore Hubs or Composite Parents - make it unchecked

Step 5. Select proper device/interface in Zadig:

Make sure that proper device/interface is selected and WinUSB driver will be installed. Then press Install Driver:

Listening FM radio

Step 1. We will try to listen traditional FM radio (frequency range 88 - 108 MHz). Make sure Your RTL-SDR dongle is plugged into USB. Set the antenna included with the kit as a dipole with 70 cm per arm, and mount the whole thing vertically. Make sure that antenna is attached to RTL-SDR:

Step 2. Start SDR# using SDRSharp.dotnet8.exe. After start You have to select the RTL-SDR dongle to be used:

Step 3. Finally listening. 

You have to press play button, but when You press it without some changes in the software You will hear nothing. Here is what needs to be changed (marked red square):

1. Manually set the desired frequency.
2. Set NFM for bandwidth.
3. Make sure that Your RTL-SDR dongle is used as source
4. Most important: set RF Gain somewhere near the middle
5. Press Play button and enjoy:

Gather all hammers inside toolbox - version 3

Whenever I decide to get back into programming after a longer break, I often find myself wondering how to set up the tools again. What has changed since last time? Does everything still install the same way as it used to?

This is the third post on this topic — the first one was written back in 2009 and can be found here, while the second one came out in 2019 and is available here. Let’s see what has changed since then.

Our goal remains the same — to build applications in Java. And we want to quickly set up all the essential tools we’ll need for that:

1. Java JDK
2. IDE
3. Git
4. Maven

As before, all things will be installed in C:\Development. 

After installing the tools, we’ll go classic and create a simple "Hello World" project using the installed JDK - with the code safely managed under Git version control.

Installing Java

This is where things have changed the most. We used to have a free JDK from Sun, then from Oracle — all nice and simple — until version 1.8, when commercial licensing entered the picture. Fortunately, free alternatives are still around, such as OpenJDK from Oracle or Amazon Corretto from… Amazon, of course :) And let's use JDK from Amazon.

Step 1: Download zip for Windows 64 from here.

Step 2: Create directory C:\Development\Java\AmazonJDK\Java25_64bit and extract downloaded zip there:

Step 3: After extract create/edit system variable named JAVA_HOME with value C:\Development\Java\AmazonJDK\Java25_64bit then modify Path system variable by adding %JAVA_HOME%\bin at the end.

Step 4: Verify Java installation by opening command line and type java -version and javac -version. You should see informationa about Java installed:

Installing IDE

Step 1: Create directory C:\Development\Jetbrains\Idea

Step 2: Download and install application named JetBrains Toolbox from here. If you have a JetBrains account, sign in to it from within the installed application — this way, if you already own a license for any of the tools, everything will activate automatically without any extra steps.

Step 3: In the Toolbox application, point to the default installation path you created in step 1 for all your development tools.

Step 4: Choose IntelliJ IDEA (Community for free or Ultimate if You have licene) and install it. It will be installed in the path from step 1.

Installing GIT

Step 1: Download Git for Windows from here. 

Step 2: Run the downloaded git installer and choose directory C:\Development\Git as the installation target. Then You can leave all options default, but I changed some of them, i.e I want to use my Notepad++ editor as default (not VIM), I do not want to use credential manager (I want to type password every time)

Step 3: Verify installation and basic configuration.

Open command prompt and execute command git --version to see if git responds. After that configure user and email by typing commands (replace XYZ with Your value):

git config --global user.name "XYZ"
git config --global user.email "XYZ"

Below is an example of running all these commands in action:

Installing Maven

Maven will be used for dependency managment, building and running future apps. Idea comes with bundled Maven, so we do not have install our version. But similar to installing Java, we will install our own version of Maven.

Step 1: Create directory C:\Development\Maven. Then download Maven (binary zip archive) from here and unpack it to the created directory.

Step 2: Create directory C:\Development\Maven\repository for artifacts downloaded by Maven:

Step 3: Tell Maven to use created above directory as a repository. Locate Maven settings file named settings.xml and add a line inside:

Step 4: Add Maven's bin folder to the system PATH variable in order to use maven commands from console.

Step 5: Verify if Maven is installed correctly. Open command line and execute command: mvn --version. You should see similar information:

Hello World in Java using above tools

We’ve got JDK, IDE, Maven, and Git all set up. Now let’s create a sample application that puts all these tools to good use.

Step 1: Open Intellij and create a new Java project. Give it a name HellWorld, make it controlled by Maven, and select our installed JDK:

Step 2: Open generated project and run its main class by clicking green play button as seen on below screen:

In the console, you can see that the project is being compiled and executed using our JDK.

Step 3: Let’s put this project under Git version control. 

First we have to tell where is our Git installed - just open settings, type in Git and chose already installed Git. InteliJ will automatically autodetect the path, just click Test button to display installed version:

Next, we need to add our project to a local Git repository. We do this by running the git init command in the project’s source directory. There are two ways to do it:

• Open the project folder in Windows Explorer, right-click inside it, and choose "Open Git Bash here" or
• Run the same command directly from the IntelliJ terminal.

Let’s go with the second option — but first, let’s make sure IntelliJ uses Git Bash as its default terminal instead of the standard Windows one (cmd.exe). Open settings again and find settings for Terminal:

After apply just open the terminal and run git init command there:

That all. Project is fully set up and saved in local Git repository.

Git for Windows - tips

Some time ago I described how to install Git For Windows and how to use it in IntelliJ Idea. See here for details. I realised that from time to time I go back to those things:

• modifying git config files and trying to find them
• working with passwords
• using different editor for commit message

Let's take a closer look.

Modifying git config files and trying to find them.

Git uses three different config files (usually named .gitconfig) at three different levels: 

System

Location: [your_git_for_windows_instalation_path]/etc/.gitconfig or  [your_git_for_windows_instalation_path]/mingw64/etc/.gitconfig.  

Purpose: contains values applied to every user on the system and all their repositories. If we want to read/write from/to this file we have to pass --system option. Because this is a system configuration file, you may need superuser privilege to make changes to it.

Global

Location: [windows_user_directory]/.gitconfig

Purpose: contains values applied to certain (usually logged in) user on the system and all repositories this user works with. If we want to read/write from/to this file we have to pass --global option.

Project

Location: [project_directory]/.gitconfig

Purpose: contains values applied to certain project. If we want to read/write from/to this file we have to pass --local option, or use no option. When changing values in certain project/git repository we have to execute this command being located in that project.

Working with passwords.

During installation process Git For Windows offers to install Git Credential Manager (GCM) - a tool for storing passwords in a secured way. 

But what if want to enter password every time when we push/pull code from remote repository? We can select "None" when Git installer asks for manager. But what if we already installed it and we want to remove it? We have to entirely remove below entry from system config file:  

[credential] 

    helper = manager

Git will start to ask for passord every time, but it will do it using OpenSSH popup window. If we want to disable it in order to enter password directly from command line (or in terminal window in IntellJ), we have to add empty entry for system config file by executing this command: 

git config --system core.askpass ""

If You really want to not to enter password every time during pull/push  with remote repository it is better to use SSH keys.

Using different editor for commit message.

By default Git For Windows offers to install vim as a default editor for commit messages. It is XXI century, we have many great editors under Windows, so do not do this mistake and do not install this archaic editor for linux geeks ;) Why? Let's demonstrate it with example.

1. We have a "Hello World" java application maintained by Git:

2. When we commit changes and in the commit command we pass commit message, we will not find any issues with the vim:

3. But let's use a commit command where no commit message is passed and we expect an editor to open and let us put message there. W use git commit command without "-m" option:

As we see vim is opened in the terminal and after start insertion mode (press Insert) we can type in commit message. Now we have to save the commit message. As You know we have to press Esc in vim to exit insert mode and type something like :wq!. 

Good luck :) When You press Esc focus is switched to the Main.java file instead of terminal where vim is opened. It is a known issue in IntelliJ when using Git in its terminal: https://stackoverflow.com/questions/67848200/how-do-i-commit-a-git-message-in-intellijs-terminal

In short: You have to change Esc key binding to switch focus under IntelliJ (assign different key not only remove Esc). Or if You have luck and do left-click (on some area different than file edit window) with Esc, You may sooner or later exit from insert mode:

After typing :wq! we see that commit is complete with our message:

You can now say: "What a problem, just change this binding if You still want to use git from terminal.  Or just use excellent graphic integration with git from IntelliJ". I would say: "Maybe it is high time use excellent external editor which I use every day instead of archaic one which I have to configure in unusual way".

4. Solution: use external editor instead of vim (here I will use Sublime).

First we define default editor in git system config file using this command:

git config --system core.editor "'C:/Dodatkowe/Sublime/subl.exe' -w"

Now we check if there are any entries about core.editor in global config file and specific project config file (which may override system setting). If  we find any, remove them. Now let's try to use Sublime as editor:

After typing in git commit Sublime editor is opened in new window, where we can type in our commit message. Please notice what IntelliJ displays in terminal: 

hint: Waiting for your editor to close the file...

Yes, it is wating until You save the file and close Sublime (when using vim it is also display this message, but exiting there is harder ;)). So lets save the file by Ctrl+S and close the Sublime:

It works without changing anything in IntelliJ.

Java Maven project error: Source option 5 is no longer supported. Use 6 or later.

Problem:

Suppose we are building an application from scratch based on Maven and JDK 11 and our pom.xml file contains nothing but groupId/artifactId/version information. An attempt to compile will end with an error as in the title.

The same thing will happen if we have an application in Java 1.5 (yes, it happens...) and we try to upgrade JDK version to e.g. 1.8 or 11. Changing Java version in the project and trying to compile will also end with this error.

Requirements:

• installed IntelliJ, JDK and Maven as described here. We need Java 11 to be installed.

Solution:

Let's try to repeat this mistake by creating simple "Hello World" application wchich is based on Maven and uses JDK 11 from Amazon:

Now let's try compiling it with Maven using the "mvn clean package" command in terminal (You can also do it by clicking in Idea's Maven window):

Tip: if you're wondering why I have such nice colors in the terminal, let me remind you that I set up the Idea terminal to use Git Bash underneath (described here). However when You use standard Windows Terminal (cmd.exe) or Windows PowerShell as a Terminal underneath colors also work.

We can observer compilation error with message marked in red rectangle. Why does this happen? 

• Maven uses "maven-compiler-plugin" to do the job, even if we don't have this plugin explicitly written into pom.xml
• this plugin (3.1.0) by default tries to set source and target bytecode version to 1.5 even if we set our project to use JDK 11:

Solution: 

• change the plugin version to a newer one - just add the plugin into the pom.xml explicitly
• set the source and target to 11 in the pom.xml. 

Why explicitly set version to 11? Because without explicitly setting them, newer plugin (from 3.6.0) will use 1.6 as default. Compilation is OK now but language level is set to 1.6 even we can use 11 as our JDK:

So, to set up everything together (plugin and language) just put those in pom.xml: 

    <properties>
        <maven.compiler.source>11</maven.compiler.source>
        <maven.compiler.target>11</maven.compiler.target>
    </properties>

    <build>
        <pluginManagement>
            <plugins>
                <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-compiler-plugin</artifactId>
                    <version>3.8.1</version>
                </plugin>
            </plugins>
        </pluginManagement>
    </build>

You can also put information about source and target language directly into the plugin instead of  defining properties:

    <build>
        <pluginManagement>
            <plugins>
                <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-compiler-plugin</artifactId>
                    <version>3.8.1</version>
                    <configuration>
                        <source>11</source>
                        <target>11</target>
                    </configuration>
                </plugin>
            </plugins>
        </pluginManagement>
    </build>

From JDK 1.9 and above plugin can also be configured using <release> option:

    <build>
        <pluginManagement>
            <plugins>
                <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-compiler-plugin</artifactId>
                    <version>3.8.1</version>
                    <configuration>
                        <release>11</release>
                    </configuration>
                </plugin>
            </plugins>
        </pluginManagement>
    </build>

Fortunately, when you create a new maven-based project from scratch in Idea, it (based on the selected JDK) automatically places the appropriate source and target for the language level in pom.xml (using <properties>).