Exploring Infrasound

Tornado Early Warning Detection Project Using Raspberry Pi Pico and a Python Supervisory Program

Inspired by the possibility of building an early warning system for tornadoes, Dev developed an infrasound detector. Tornadoes are rare in his area, but his detector found other infrasound activity using sensor circuitry based on a Raspberry Pi Pico, combined with a Python supervisory program that stores data on a computer for analysis.

A few electronic device designs have been published for making ultrasound audible. Most of these use heterodyning to shift the ultrasonic frequencies down to the audible range. The principal purpose of these circuits is to listen to the echolocation calls of bats, which occur at frequencies up to about 200kHz, but more typically between 20kHz and 60kHz. Electronics for such devices are a simple design problem for Circuit Cellar readers, but microphones with sensitivity at ultrasonic frequencies can be quite expensive. The inexpensive ultrasound receivers used in remote controls are not suitable for broadband ultrasonic detection, since they respond to a single frequency, 40kHz, with just a kilohertz bandwidth. If you don’t live near a bat cave or highly wooded area, there will be little ultrasound activity.

Winds blowing over uneven terrain, ocean waves crashing onto shorelines, and erupting volcanoes generate infrasound waves that can travel long distances. Heavy vehicles and machinery are other sources of infrasound. Sound is a pressure wave that expands and compresses air over each cycle, and energy is lost during this expansion-compression cycle. Low-frequency waves have fewer cycles per distance than higher-frequency waves, so infrasound travels farther. Nuclear weapons are no longer being tested, but the infrasound from nuclear explosions were detected worldwide. Before supersonic flights of Concorde jets were discontinued, it was discovered that their infrasound emission interfered with the navigation of homing pigeons.

It’s been known for decades that tornadoes produce intense infrasound that travels for many miles. Detection of this infrasound, which exists in a frequency range of about 10-15Hz, could give more than a hour’s advance warning of a tornado’s approach. Infrasound is produced even while a tornado is just forming, and arrays of infrasound microphones have detected infrasound produced by tornadoes 60 miles distant.

Although you might not be interested in building an infrasound detector, this project is a good introduction to using MicroPython to program the serial port, ADC and I²C bus of the Raspberry Pi Pico, and powering the Raspberry Pi Pico from an external 5V supply. There’s also information about using a common base differential amplifier to impedance match a low-impedance transducer to an amplifier, to minimize electronic noise, and the use of Qucs, a free SPICE hardware simulation program.

INFRASOUND DETECTOR

The heart of the detector is a sensitive acoustic transducer (microphone) optimized for infrasound frequencies. Just as in a low-frequency loudspeaker (woofer), there’s an inductance coil attached to a large-area diaphragm moving in a magnetic field. For the loudspeaker, it’s a current through the coil that causes movement of the diaphragm to create sound. For the infrasound detector, movement of the diaphragm creates a voltage in the coil.

As shown in Figure 1, I cut a 12” circle from a large-format piece of paper 0.004” inch thick. The paper was the type used in large-format printers and plotters, but a variety of other thin flexible materials, such as Mylar or Tyvek, could be used. I waterproofed the paper by coating each side with a clear polyurethane varnish commonly used for furniture finishing. The inductance coil, 1,000 turns of AWG-36 enameled copper wire, was wound on a 1.5” diameter by 0.5” high coil form harvested from a thin-walled plastic bottle. The coil resistance was 150Ω, it had 17.5g total weight, and it was glued to the center of the paper using silicone adhesive, as shown in Figure 2. The paper diaphragm was glued to a thin 14” square plywood sheet with an 11” diameter circular cutout (Figure 1).

The magnet was a stack of two NdFeB disk magnets, each 1.25” in diameter by 0.125” thick. The magnet face was adjusted by a spacer from the base of the acoustic detector, to be fairly close to the face of the coil. Maximum sensitivity was achieved with close proximity of the magnet to the coil, as shown by the response curve in Figure 2.

Since the infrasound detector was placed outside in the open air, I made provisions for appropriate waterproofing. Wide plastic tape was wrapped around the open edge of the detector’s frame, and the frame was placed into a somewhat larger wooden box protected by exterior-quality house paint. An input horn was created from an inexpensive plastic wastepaper basket, and this was bonded to the wooden box using three small L brackets and a liberal quantity of silicone adhesive to prevent any water entry.

The assembly, shown in Figure 3, was mounted at a slight downward angle to prevent any rainwater from running into the detector. I found that the roof overhang of my house shielded the detector from direct downward rainfall. A plastic mesh of the type used for yarn art was used as a screen to prevent insects or wind-blown debris from reaching the internal detector. A shielded length of dual conductor cable was needed for connection of the coil to the infrasound processing circuitry. As I discovered, the best source of this was a 50’ length of microphone extension cable. These mass-produced cables are quite inexpensive, and they also have mating XLR connectors at each end. I cut the female connector, along with a short length of the cable, to attach to the detector leads for easy connection.

CIRCUITRY

The circuitry for the infrasound detector is built around a Raspberry Pi Pico. Unlike a Raspberry Pi, which is a functional Linux computer, the Raspberry Pi Pico is a microcontroller board much like an Arduino. The Arduino from its inception has been programmed using C++, but it now supports a version of Python for microcontrollers, called MicroPython, as does the Raspberry Pi Pico. Like the Arduino, the Raspberry Pi Pico has many onboard peripherals, including a real-time clock (RTC), a 12-bit analog-to-digital converter (ADC), a serial port, and an I²C bus for easy interface to other peripherals. The infrasound detector circuit uses the I²C bus to interface with a digital-to-analog converter (DAC) to produce an audible representation of the infrasound signal, and the serial interface allows setting of the RTC and transmission of the infrasound intensity data.

As I learned early in my career, impedance matching of low-impedance sensors to amplifier inputs is important for noise reduction. This is especially true for infrasound, because of flicker noise—an electronic noise that increases as the reciprocal of frequency (1/f). Since we’re amplifying very low frequencies, we need to ensure that we’re getting the most from our signal by impedance matching before amplification. For this reason, I decided to use a common base amplifier, the lesser-used cousin of the common emitter amplifier, for the input stage. The common base amplifier has a low-input impedance suitable for interface to the coil.

I generally design my circuits by instinct, finally tweaking component values on a breadboard, or in the final hardware build. I needed more help in the design of a good common base differential amplifier interfaced to an operational amplifier, so I decided to use some simulation software. I used the free “Quite universal circuit simulator” (Qucs) for SPICE simulation of the amplifier. I used the Linux version of this free software, but a Windows version is available. There wasn’t a version compatible with my current Linux Mint system, so I needed to use an older version of Linux in a VirtualBox. A schematic of the Qucs simulation is shown in Figure 4. The Qucs datafile for this simulation is in the source code for this project, available on the Circuit Cellar Article Code and Files webpage.

As can be seen in the circuit in Figure 5, the signal from the common base amplifier is further amplified by an operational amplifier. To avoid a drifting baseline caused by temperature effects on the 2N3904 transistors, there’s capacitance coupling at the final amplification stage. To have a reasonably sized capacitor from the DC amplifier to the second amplifier, we need a high-impedance input. This works against having a large amplification, since the gain of the operational amplifier is set by a ratio of resistors.

To solve this problem, I used a resistor-capacitor network at the feedback loop of the operational amplifier, to produce higher AC gain using lower-value resistors. There’s a trimpot used to set the voltage value of the ADC at mid-range, and additional capacitors for low-pass filtering. While you can use the serial voltage signal as an aid to zeroing, it’s easier to monitor the audio output and adjust for minimum sound.

The circuit, shown in Figure 6, is powered by a wall transformer connected via a USB cable. This voltage is also supplied to the Raspberry Pi Pico through a 1N5819 diode, a Schottky diode, as recommended in the Pico documentation. This allows simultaneous connection of the Pico to a host computer, which also provides a 5V power source, but has the Pico powered by the circuit’s supply. Although I haven’t tried it, substitution of a conventional diode, such as a 1N4004, should also work, but with the effect that the Pico and I2C module would be powered by the host computer, not the circuit power, when its USB cable is connected.

The circuit operates simultaneously in two modes. There’s an “entertainment” mode, in which the DAC module attached to the I2C bus outputs a 440Hz audio signal that’s modulated by the infrasound intensity. A set of personal computer speakers can be used to monitor the audio signal. I paralleled a second audio output jack in my device to allow simultaneous recording of the audio signal. There’s also a “scientific” mode, in which the serial port sends time and intensity data every 5 seconds.

SOFTWARE

All code and example programs for this project are available on the Circuit Cellar Article Code and Files webpage.

Python has become a popular programming language, principally because of its ability to import code libraries for specific functions. Two versions of Python are used for the infrasound detector. There’s MicroPython, which is Python for microcontrollers, (used by the Raspberry Pi Pico), and there’s Python3 on the desktop computer.

The first step is to install an integrated development environment (IDE) for Python on your host computer. The best choice for this is Thonny, which has versions for Linux, Windows, and MacOS. The graphical user interface of the version of Thonny on my Raspberry Pi 3 was not as intuitive as the one on my Linux desktop, so I used my desktop for program development.

After installation of Thonny, the next step is to establish a link to your host computer via a USB cable. This is done by pressing the button on the Raspberry Pi Pico as you make the USB connection.

Subsequent steps, which include firmware updating and downloading of MicroPython, are too tedious to summarize here, but there are quite a few Internet resources, including tutorial videos, that step through the process.

Once connection between Thonny and MicroPython on the Raspberry Pi Pico is established, you can run Python commands in the included terminal and edit program code for execution. You can enter and run the example programs to test the I²C and serial interfaces. Any program named main.py will be executed automatically at each power-up.

The infrasound program for the Raspberry Pi Pico, named main.py, is available on the Circuit Cellar Article Code and Files webpage. When this is installed on the Pico, the following happens at each power cycling or reboot.

• Required libraries are imported.
• The serial UART is initialized.
• There’s a 30-second wait to allow setting the Pico RTC to the current time.
• The I2C port is scanned to verify that the DAC module appears at its selected address.
• An infinite loop is entered that averages the ADC data in approximate 5-second intervals, outputs a modulated triangle 440Hz waveform to the DAC, checks for user input to set the RTC, and outputs time data and amplitude to the serial port. For ease in plotting the data, the time is given as hours since midnight.

PYTHON STORES DATA

While the RTC can be set and the infrasound data captured in a serial terminal application on the host computer, I wrote a supervisory program in Python for automatic setting of the RTC and capturing the data to a new file each day. The filenames are created from the timestamp of their creation. This supervisory program named acquire_data.py, along with a utility program, datafile_plot.py, for creating plots, are available on the Circuit Cellar Article Code and Files webpage.

The plotting program creates a simple plot and saves it as an image named plot.png. The plots in this article were created with the free spreadsheet application, Gnumeric. It’s necessary to first apply power to the Pico, then execute the supervisory program, acquire_data.py, within 30 seconds, in a command terminal in the directory in which it is placed. On my Linux systems, the command is python3 acquire_data.py. You might need to add your user name to the “dialout” group for the serial interface to work on your desktop computer.

OBSERVATIONS

First, and most importantly, don’t rely on this device as a tornado warning system. Much more experience and statistics would be required to certify a device for that.

In my many days of observations, it appeared that most infrasound arises from human activity, probably from heavy vehicle traffic and construction. This can be seen in Figure 7, which shows noise starting at the morning rush hour at about 7:30 AM, and ending at about 7:00 PM.

Although passenger jet traffic was not detected, a helicopter flying over my house produced a huge infrasound peak. Lawn mowers and leaf blowers are loud noise sources at audible frequencies, but they had no infrasound signal. Light rainfall was not detected, but heavy rainfall accompanied by wind was detected. I suspect that this was caused by large volumes of water being flung from tree foliage by the wind. One interesting nighttime signal appeared to coincide with night construction at a bridge across an interstate highway, as shown in Figure 8.

RESOURCES
Raspberry Pi | www.raspberrypi.com

Code and Supporting Files

ACCESSING HARDWARE IN MICROPYTHON

Many inexpensive I2C bus modules can be purchased to extend the capability of microcontrollers such as the Raspberry Pi Pico. However, specific documentation for any module is sparse, though some clues to programming can be found in the datasheet for the module’s principal chip. One other problem is finding which of the 127 possible I2C bus device addresses is used by a particular module. The following is a simple MicroPython script that scans the I2C bus and locates the address of every connected device.

import machine# Note - These are GPIO pin numbers, not the physical pinsi2c = machine.I2C(0, scl=machine.Pin(5), sda=machine.Pin(4))print(‘Scanning the I2C bus’)i2c_devices = i2c.scan()if len(i2c_devices) == 0: print(“No I2C devices present”)else: print(str(len(i2c_devices))+ ‘ I2C devices found’) for device in i2c_devices:   print(“Decimal address = “,device,” | Hexadecimal address = “,hex(device))

Serial ports have been a convenient method of data transfer from the time that acoustically coupled modems were first attached to personal computers. Along with the versatility of multiple baud rates comes the problem of selecting the proper baud rate and other serial port parameters for data transmission. The following MicroPython script tests the serial interface (UART) by transmitting a stream of data from the real-time clock.

from machine import Pin,UART,RTCimport timertc = machine.RTC()# Note - These are GPIO pin numbers, not the physical pinsuart = UART(0, baudrate=19200, tx=Pin(0), rx=Pin(1))uart.init(bits=8, parity=None, stop=2, timeout=50000)while(1):  time_data = rtc.datetime()  hours_from_midnight = float(time_data[4]) + (float(time_data[5])/60) + (float(time_data[6])/3600)  uart.write(“{:.4f}\n”.format(hours_from_midnight))  time.sleep(5)

PUBLISHED IN CIRCUIT CELLAR MAGAZINE • SEPTEMBER 2024 #410 – Get a PDF of the issue

Sponsor this Article