SatDump Software

Receiving GOES HRIT with SATDUMP

Loading

GOES Receiving with SATDUMP

SatDump Icon

What is satdump?

SatDump is a popular multi-platform software program that lets you receive and decode images and other data directly from weather satellites and more. It works great with most brands of SDR dongles, and the nightly updates brings exciting new featuresbug fixes, enhancements, etc.

Be Aware: SatDump is Constantly Under Development

SatDump is like a Tesla Cybertruck: exciting and feature-rich, but still under development and requires software updates. The developers constantly update it, so this guide uses the latest nightly builds from GitHub (not the current stable version). You can find these under “Nightly Builds – Assets” on the SatDump releases page on GitHub.

Supported Platforms and This Guide’s Focus

SatDump works on various platforms, including Raspberry Pi. This guide details installing the latest nightly build on a Raspberry Pi in headless mode (no GUI) for receiving and decoding GOES-R Series satellite imagery. Also, further down in this documentation are some techniques for using the CLI version in Windows as well.

Here’s a breakdown of the benefits of using SatDump in CLI mode for long-term GOES-16/18 reception with an RTL-SDR, along with the example command:

Why CLI mode for GOES reception?

  • Stability and Efficiency: SatDump’s CLI mode is more lightweight and efficient than the interactive UI. This translates to smoother, more reliable decoding over extended periods. Fewer resources are consumed, making it ideal for long-term data collection.
  • Automation Potential: CLI commands can be easily scripted and automated. This allows you to schedule unattended recordings or integrate GOES reception into larger data processing workflows.
  • Background Operation: SatDump running in CLI mode can operate quietly in the background without interfering with other tasks on your PI or computer. You can continue using your machine for other purposes while GOES data is being captured.

Hardware Recommendations

I’ve successfully run SatDump on Raspberry Pi 4 (4GB RAM), Pi 5 (8GB RAM), and Pi 3B (1GB RAM). The Pi 5 with 8GB RAM offered the best performance, so that’s the focus here. For the receiver, I am using the Nooelec SmarTee XTR in combination with the Nooelec Sawbird + GOES

Nooelec Products

Shortcuts:

Installing the latest Rasberry Operating system on the PI -Headless Version!

  1. Download and install Raspberry Pi Imager to a computer with an SD card reader. https://www.raspberrypi.com/software/
  2. Put the SD card you’ll use with your Raspberry Pi into the reader and run Raspberry Pi Imager.
  3. In the Raspberry Pi Imager, click on CHOOSE DEVICE, and choose the device you will be installing the Raspberry OS onto.
    • Rasberry Pi 5 (Or Pi4 if that is what you are using)
  4. Now click on CHOOSE OS, and scroll down to Raspberry PI OS (Other).
    • Select Raspberry PI OS Lite (64 bit).
  5. Choose the storage location to write the PI img to by clicking CHOOSE STORAGE. Then Click NEXT.
  6. I recommend Editing the OS customization settings and adding the following information under the General Tab, add Hostname, Username and Password, the WIFI Settings you use, and Locale settings.
    • Under the Services tab, enable SSH and tick the Use Password Identification button.
  7. Then let the installer burn the image to your SD card. NOTE: I have had issues using the SanDisk Ultra Class 10 SD cards, the boot time on the PI was VERY slow, and it was nearly impossible to run the PI. I have seen others post about the same thing. I switched to a PNY and a Kingston SD card Class 10, and had no issues.
  8. After the OS is burned to the SD card, insert it into the PI (unpowered!) and let it boot up for the first time.

Updating the OS

Now we need to make sure the Pi OS is fully Updated:

Using an SSH program such as PUtty, log into the Pi using the IP address of the pi, once connected enter the username (default is “pi”), and then the password. Once connected do the following

Within the Terminal Window type:
sudo apt update to update the package list
sudo apt full-upgrade to upgrade all installed package

Let the process run, and answer yes (Y) if you are prompted to continue. When it is complete:

Within the Terminal Window type:

sudo reboot

To fully reboot the system.

Then, using SSH (like puTTY software), log back into the Pi.

Install dependencies:

Get the packages necessary to build and librtlsdr (for your SDR)

sudo apt-get install git build-essential cmake libusb-1.0 libopencv-dev libproj-dev

Let the process run, and answer yes (Y) if you are prompted to continue.

Download, compile, and install the latest librtlsdr files

git clone https://github.com/steve-m/librtlsdr
cd librtlsdr && mkdir build && cd build
cmake -DCMAKE_BUILD_TYPE=Release -DCMAKE_INSTALL_PREFIX=/usr ..
make -j4
sudo make install

#load udev rules and blacklist the DVB driver shipped with the OS
sudo cp ../rtl-sdr.rules /etc/udev/rules.d/
sudo ldconfig
echo 'blacklist dvb_usb_rtl28xxu' | sudo tee --append /etc/modprobe.d/blacklist-dvb_usb_rtl28xxu.conf

Reboot the device

sudo reboot

Install SatDump

Within the Terminal Window type:

mkdir satdump
cd satdump

Now we are going to install the nightly build of the satdump software for RPI onto the pi

wget https://github.com/SatDump/SatDump/releases/download/nightly/satdump_rpi64_latest_arm64.deb
sudo apt install ./satdump_rpi64_latest_arm64.deb

Allow the software and all dependencies to install, you may get asked to confirm installations of files or dependencies, answer yes (Y) to those questions.

After the installation is successfully done, within the Terminal Window type:

sudo reboot

Now that satdump is installed on your Pi, and now, because it is a headless install (that is, no GUI), we need to configure the Pi to start receiving and processing the GOES data and imagery.

On another page on my site are the instructions (using goestools) for setting up and aligning your dish, so I won’t go into this now as the process is very similar.

We are going to use CLI, (Command Line Instructions) to run satdump and tell it what to do. But, before we do that, let me explain the different configurations of this basic command line for satdump to process GOES-HRIT with this line as an example:

satdump live goes_hrit GOES_18 --source rtlsdr --samplerate 2.4e6 --frequency 1694.1e6 --gain 40 --fill_missing

So what is happening in that line? First satdump live tells the pi to run satdump in live processing mode, that is to receive and process as data is received. goes_hrit tells satdump to use the GOES HRIT satellite processing pipeline as well as the pre-configured parameters.

For GOES there are many different pipelines available, we are using the goes_hrit in this setup, I am showing the others below for reference.

  • goes_gvar: GOES GVAR (GOES VARIABLE)
  • goes_hrit: GOES-R HRIT (High Rate Information Transmission)
    • write_images: Saves FD, Meso, etc images (Default: True)
    • write_emwin: Save EMWIN Data (Default: True)
    • write_messages: Save Admin Messages (Default: True)
    • write_unknown: Save Unknown LRIT data(Default: True)
    • write_dcs: Save DCS LRIT files (Default: False)
    • write_lrit: Write all LRIT files (Default: False)
  • goes_hrit_tcp: GOES-R HRIT to goestools
  • goes_grb: GOES-R GRB (GRB contains the ABI, GLM, space environment, and solar data)
  • goesr_cda: GOES_R CDA (Telemetry signal sent from GOES 16, 17, 18, and 19)
  • goes_md1: GOES-N MDL (Multi-use Data Link) provides a medium-rate (400 kbit/s) downlink of Imager and Sounder)
  • goes_lrit: GOES-N LRIT (Low-Rate Information Transmission)
  • goesn_cda: GOES-N CDA (Telemetry signal sent from older GOES (EWS-G2))
  • goesn_sounder: GOES-N Sounder SD (Sensor data)
  • goesn_sd: GOES-N Sounder Data (Imager and Sounder sensor data)
  • goesr_raw: GOES-R Raw Data (Level 0 (L0) raw data from GOES-R series)

After goes_ hrit is the command GOES_18. In this case I am receiving from GOES 18, so I want to put all the received files into a folder on the PI called GOES_18. You can name this anything you want. GOES_16 for GOES 16, or call it GOES_West or GOES_East, or sat_imagery, or whatever.

--source rtlsdr Instructs satdump that an RTLSDR device is connected, such as a Nooelec SmarteeXTR, or RTL-SDR Dongle or equivalent. There are other choices as well and these can be found in more detail on the satdump.org documentation page.

--samplerate 2.4e6 sets the sample rate to 2.4 MSPS, --frequency 1694.1e6 sets the frequency to 1694.1 Mhz (1.6941 GHz) In some cases, in order to achieve a better SNR and lower vit count try using --samplerate 1.536e6 instead of --samplerate 2.4e6 could show better results

Lastly --gain 40 sets the gain on the SDR to a setting of 40, NOTE: if you have used goestools, please note that settings in goestools are configured differently and uses the gain setting to control an internal multiplier, this is NOT the case in satdump. --fill_missing automatically fills missing lines caused by errors.

So now, in the example below I am using a Nooelec SmarTee XTR and Nooelec LNA. So that the BIAS TEE is always on.

With your SDRand LNA connected to the dish and the PI, and within the Terminal Window copy and paste (with your folder names:

satdump live goes_hrit GOES_18 --source rtlsdr --samplerate 2.4e6 --frequency 1694.1e6 --gain 40 --fill_missing

Press enter. If everything was set up correctly, your terminal window should start filling up with received file names and data.

In the screenshot above, we can see that satdump is processing received EMWIN data and some LRIT data into imagery.

Let satdump run about 15 mins to an hour to allow time to receive the data and imagery, then, using a program such as Filezilla, log into your Pi using your pi’s IP address, and the username and password you setup for your PI and check the folder you specified for received data, txt, and imagery.

Autostart SatDump

Pause on automatic startup for now. It’s important to get familiar with how the Raspberry Pi, SatDump, and other processes work manually first. Understand how the imagery is saved and confirm everything functions as expected. Once you’re comfortable, you can explore the next step: Enabling automatic startup.

Any troubleshooting should be done ahead of time!

Automatic Startup on Reboot:

I added the ability to have my PI automatically start all of the satdump software on boot or after a power glitch.   Be sure and match the file structure to your own set up!

To ensure SatDump automatically starts whenever your computer or Raspberry Pi restarts (due to power outages or planned reboots), we need to configure a systemd service.

1. Create the service file:

Start by creating a new systemd service file specifically for SatDump. Use the following command to open and create the file for editing with nano:

sudo nano /etc/systemd/system/satdump-goes.service

2. Paste and customize the service definition (coming next):

We’ll provide the service definition content in the next step, allowing you to copy and paste it into the newly created file. You might need to adjust some details depending on your setup.

[Unit]
Description=SatDump automated GOES station
After=network.target
StartLimitIntervalSec=0

[Service]
Type=simple
StandardOutput=null
StandardError=null
Restart=always
RestartSec=1
# Edit to match your username
User=chrinomann
# Edit to match the name and location of your goes satdump file
ExecStart=/usr/bin/satdump live goes_hrit GOES_18 --fill_missing --source rtlsdr --samplerate 2.4e6 --frequency 1694.1e6 --gain 40
# Edit to match the home directory
WorkingDirectory=/home/pi
[Install]
WantedBy=multi-user.target

Save the file.

Now we need to let the Pi know that there is a new service to use:

1. Reload systemd configuration:

Start by telling systemd about the new service using

sudo systemctl daemon-reload.

This command instructs systemd to reread service files from disk, ensuring it recognizes your newly added “satdump-goes” service.

2. Start the service:

Once systemd is aware of the service, initiate it with

sudo systemctl start satdump-goes. This will launch the “satdump-goes” service.

3. Verify status:

Use sudo systemctl status satdump-goes to check the service’s status. Look for any error messages. If everything runs smoothly, you’ll see “active (running)” next to the service name.

4. Address errors (if any):

Encountering errors during the status check? Address them before proceeding. Common culprits include typos or incorrect paths in the service configuration file.

5. Enable for automatic startup:

If the service functions as expected and you want it to start automatically at boot, run

sudo systemctl enable satdump-goes.

This ensures the service launches whenever your system restarts.

Keeping Satdump updated-

SatDump is constantly evolving (WIP) with frequent updates, often daily or nightly. This rapid development means you’ll get new features and bug fixes quickly. It’s recommended to update regularly to take advantage of these improvements.

First, we need to temporarily disable satdump-goes.service that is running in the background:

sudo systemctl disable satdump-goes.service

We already have made the folder satdump earlier, so enter:

cd satdump
sudo rm satdump_rpi64_latest_arm64.deb This will delete the older version of the satdump file.

Now we are going to install the nightly build of the satdump software for RPI onto the previous section, we are going to use the same commands to download and install the latest build.

wget https://github.com/SatDump/SatDump/releases/download/nightly/satdump_rpi64_latest_arm64.deb
sudo apt install ./satdump_rpi64_latest_arm64.deb

After it installs, re-enable the satdump-goes.service

sudo systemctl enable satdump-goes

sudo reboot

If you want to check to see what services are running on your PI then:

sudo systemctl --type=service --state=running

or check the status of just the satdump-goes.service by entering sudo systemctl status satdump-goes

A note on using client mode for Satdump for Windows to receive and decode.

Under Windows, I recommend ditching the fancy UI for long-term GOES (or any satellite) reception! SatDump’s CLI mode is leaner, meaning smoother decoding and less computer strain. Plus, scripting lets you automate recordings. Here’s the command to get started with GOES-16/18 on your RTL-SDR:

satdump live goes_hrit C:\path\to\satdump --source rtlsdr --samplerate 2.4e6 --frequency 1694.1e6 --gain 49 --http_server 0.0.0.0:8080 --fill_missing

The http_server part is optional and is only needed to provide decoder/demodulator statistics. Once started, you will be able to access a http server providing the live state of the demodulator and decoder(s). That can useful for 24/7 setups where constant monitoring may be required. (or with Vitality GOES)

Adjust the gain (--gain 40) based on your setup to avoid overloading the signal. You might also need to tweak your antenna for best reception

Explanation of Options:

  • live: Instructs SatDump to capture a live data stream.
  • goes_hrit: Specifies the format of the GOES data being received (HRIT in this case).
  • --source rtlsdr: Defines the signal source as an RTL-SDR dongle.
  • --samplerate 2.4e6: Sets the sampling rate to 2.4 MHz (common for GOES reception).
  • --frequency 1694.1: Tunes the SDR to the GOES-16/18 downlink frequency (1694.1 MHz).
  • --gain 40: Sets the gain level on the RTL-SDR (adjust based on your setup).

Additional Considerations:

  • Remember to replace --gain 40 with a value appropriate for your SDR and reception conditions. Start with a low gain setting and increase it gradually to avoid signal saturation.
  • For optimal reception, you might need to adjust the antenna and its positioning based on your location and the satellite you’re targeting (GOES-16 or GOES-18).

By following these guidelines and using the CLI mode, you can configure SatDump for reliable, long-term reception of GOES-16/18 weather satellite data using your RTL-SDR.

A tutorial for using SatDump on Windows in a GUI environment can be found on my site here.

Integrating Vitality GOES into your system.

Vitality GOES feature overview video

Vitality GOES is a web application designed for visualizing and analyzing data collected by geostationary weather satellites, specifically GOES-16 and GOES-18, But easily handles other satellites as well. It works by pulling in information from external software like goestools, Satdump, or XRIT Decoder, which are programs that receive and decode the raw satellite data stream.

Here’s a breakdown of the details:

  • Geostationary Weather Satellites: These satellites orbit Earth at a fixed position, constantly monitoring the same area. GOES-16 and GOES-18 are operated by the National Oceanic and Atmospheric Administration (NOAA) and provide continuous observations of the Western Hemisphere.
  • Data Types: Vitality GOES can handle various types of data transmitted by the satellites, including:
    • Images: GOES satellites capture images of Earth in different wavelengths of light, which can reveal cloud formations, water vapor content, and even sea surface temperatures.
    • Text Data: The satellites might also transmit formatted text messages containing meteorological observations or other relevant data.
  • Web Interface: The beauty of Vitality GOES is that it presents this complex satellite data in a user-friendly way through a web browser. This means you can access and view the information from any device on your local network, without needing to install any special software.
  • Offline Access: An important advantage of Vitality GOES is its ability to work even if your internet connection goes down. As long as you’re on the same local network as the computer running the software, you can still access the latest weather data being received from the satellites.

In essence, Vitality GOES acts as a bridge between the raw satellite data and the user, transforming it into a visually appealing and readily interpretable format for weather enthusiasts and professionals alike.

How to Install into your system:

Jamie Vital, the author of Vitality GOES, has a very comprehensive guide to setting up the software tool on your respective system. Additionally, he has a comprehensive WIKI on the page as well to help you understand the many configurations and setup options available.

Example of one of USRadioguys -Vitality GOES system installations:

A note about the differences between how SatDump processes imagery, and how GOEStools Processes imagery:

Why you might see black bars or, skipped images in satellite images processed by SatDump or GOEStools:

Filling in the Gaps:

Both programs can encounter “bad packets” which contain corrupt data.
To compensate, they employ a technique that in essence “fills missing lines” to replace missing data with information from good packets.
This works well as long as the missing data is in the middle or towards the end of a data segment.

The Challenge of Missing First Packets:

The key difference arises when the very first packet of a data segment is missing. This packet holds crucial information like the total data size and compression type, which are essential for interpreting the entire segment.
Without this information, neither program can properly decode the remaining packets.

SatDump’s Approach (Saving with Black Bars):

SatDump tries to salvage the situation by saving the image with a placeholder for the missing data. This placeholder appears as black bars because it lacks the information to reconstruct the actual image data.
SatDump holds onto this incomplete image until it receives data from the next time slot. At this point, it realizes the missing data from the previous slot won’t be recovered and saves the image with the black bars to disk.
The resulting black bars will exactly match the size of a specific data unit (339 pixels for a non-relayed full image).

SatDump image with unrecoverable packet loss

GOEStools’s Approach (Silent Dropping):

GOEStools takes a more drastic approach. When it encounters a missing first packet, it completely discards the entire image without any warning. (Not that this is a bad thing, especially when creating animations)
You can find this behavior confirmed in the GOEStools source code.
The consequence of this approach is that you’ll simply see a “skipped” image for that particular channel and time slot in the final output.

To Summarize:
In essence, SatDump attempts to display the image with a clear indication of missing data (black bars), whereas GOEStools silently removes the image altogether. This difference could significantly impact how you interpret the final processed satellite images.

Customizing the configuration files for the different types of imagery processing.

This section is WIP as I continue with some experimentation on different levels of GOES enhancements:

The first thing you should do is set up your configuration in the settings.json file. This is better than editing the satdump_cfg.json as the satdump_cfg.json gets overwritten when you upgrade satdump, but settings.json does not.

Settings.json can be found on the pi under /home/pi/.config/satdump/

You can use a text editor to edit it such as nano by typing

nano /home/pi/.config/satdump/settings.json

This is my settings.json file contents.

{
    "satdump_general": {
        "image_format": {
            "value": "jpg"
        }
    },
    "viewer": {
        "instruments": {
            "abi": {
                "rgb_composites": {
                    "GEO False Color IR Merge": {
                        "autogen": true
                    },
                    "GEO False Color": {
                        "cpp": "goes_abi_false_color",
                        "vars": {
						"lut": "goes/abi/usradioguycustomlut.png" } 
                    },					
                    "Fog Brightness Temperature Difference": {
                        "autogen": true
                    },
                    "Split Window Difference": {
                        "autogen": true
                    },
                    "Day Cloud Convection": {
                        "autogen": true
                    },
                    "Nighttime Microphysics": {
                        "autogen": true
                    },
                    "Day Rocket Plume Detection": {
                        "autogen": true
                    },						
                    "789": {
                        "autogen": false
                    },
                    "7_13_15": {
                        "autogen": false
                    }
                }
            }
        }
    },
    "plugin_settings": null,
    "user": {
        "tles_last_updated": 1716559554
    }
}

In this section, you can see that I have changed from storing files as png to jpg (to save file size) and have enabled some enhancements with the autogen “true” statement and others as “false”. In addition, I have added my color LUT (lookup table) to the processed GEO False Color imagery.