In diesem Tutorial lernst du, wie du mit einem ESP32 einen einfachen Frequenzspektrumanalysator baust. Wir verwenden das MAX4466 Mikrofon und die arduinoFFT-Bibliothek, um die Frequenzen im Audiosignal zu messen und das Frequenzspektrum auf einem OLED anzuzeigen.
Fangen wir mit den Bauteilen an, die du für dieses Projekt benötigst.
Benötigte Bauteile
Du benötigst einen ESP32, ein OLED-Display und das MAX4466 Mikrofonmodul. Ich verwende den ESP32 lite als Mikroprozessor, da er eine Batterieschnittstelle zum Laden hat und du den Spektrumanalysator so einfach mit einer Batterie betreiben und portabel machen kannst. Aber jeder andere ESP32 funktioniert ebenfalls.
ESP32 lite
USB-Datenkabel
MAX4466 Mikrofon
OLED-Display
Dupont-Kabelset
Breadboard
Makerguides is a participant in affiliate advertising programs designed to provide a means for sites to earn advertising fees by linking to Amazon, AliExpress, Elecrow, and other sites. As an Affiliate we may earn from qualifying purchases.
Frequenzspektrumanalysator
Ein Frequenzspektrumanalysator ist ein Gerät, das den spektralen Inhalt von Signalen visualisiert und analysiert und die Amplitude oder Leistung eines Signals über seinen Frequenzbereich anzeigt. Er zeigt im Wesentlichen, wie viel Leistung des Signals auf bestimmte Frequenzen oder Frequenzbänder verteilt ist.
Das folgende Bild zeigt ein solches Frequenzspektrum. Die Frequenz ist auf der x-Achse und die Magnitude des Signals wird in Decibel wie auf der y-Achse dargestellt gemessen:
Je nach Genauigkeit und Frequenzbereich können Spektrumanalysatoren sehr teuer sein. Unten ein Bild des Siglent Technologies SSA3021X Spektrumanalysators, der Radiofrequenzen von 9 kHz bis 2,1 GHz analysieren kann.
Audio-Frequenzspektrum
Eine häufige Anwendung von Spektrumanalysatoren ist die Visualisierung der Frequenzverteilung innerhalb eines Audiosignals. Der Frequenz- oder Hörbereich eines Audiosignals, den Menschen hören können, reicht von 20 bis 20.000 Hz (=20 kHz). Das sind jedoch die Extremwerte, und der Hörbereich nimmt mit dem Alter ab. Für Erwachsene liegt die obere Grenze typischerweise bei etwa 15.000 Hz. Wenn du deine obere Hörgrenze wissen möchtest, kannst du diesen kleinen Hörtest test machen.
Das folgende Bild zeigt die Anzeige eines typischen Audio-Spektrumanalysators. Du kannst die verschiedenen Frequenzbänder (grüne Balken) von 20 Hz bis 20 kHz sehen.
In diesem Tutorial bauen wir einen solchen Audio-Spektrumanalysator selbst. Erwarte jedoch nicht zu viel. Da wir einen günstigen ESP32, ein kleines OLED und ein einfaches MAX4466 Mikrofon verwenden, wird unser Spektrumanalysator nicht sehr genau sein.
Sein Frequenzbereich wird nur von 125 Hz bis 8000 Hz reichen und wir werden nur 7 Frequenzbänder haben, aber es wird ausreichen, um die Frequenzinhalte von Musik zu visualisieren und zu animieren.
Funktionsweise eines Spektrumanalysators
Wie funktioniert unser kleiner Audio-Spektrumanalysator? Das Mikrofon wandelt Schallwellen in elektrische Impulse um. Diese schwachen Impulse werden vom MAX4466 verstärkt und an den Analog-Digital-Wandler (ADC) des ESP32 weitergeleitet. Wenn du den Ausgang des ADC ausliest und darstellst, könnte das erkannte Audiosignal so aussehen:
Auf der x-Achse ist die Zeit und auf der y-Achse die Amplitude des Signals. Dieses Signal wird als Zeitsignal bezeichnet, da es über die Zeit dargestellt wird, aber die Frequenzen im Signal nicht zeigt.
Das obige Signal besteht tatsächlich aus Kosinussignalen mit den Frequenzen 10, 20, 30, 40 und 50 Hz mit zunehmenden Amplituden. Wenn wir eine mathematische Methode namens Fast Fourier Transformation (FFT) anwenden, können wir diese Frequenzen aus dem Signal extrahieren. Die folgende Grafik zeigt dasselbe Signal nach Anwendung der FFT:
Das Signal befindet sich jetzt im Frequenzbereich mit der Frequenz auf der x-Achse (statt der Zeit). Du kannst deutlich die Spitzen bei 10, 20, 30, 40 und 50 Hz sehen, die die Frequenzen des Eingangssignals offenbaren. Um die FFT durchzuführen, lässt der ESP32 das Audiosignal vom ADC abtasten und ruft dann die arduinoFFT library auf, um die Frequenzen zu extrahieren. Das resultierende Frequenzspektrum wird dann auf dem OLED angezeigt.
Wir zeigen jedoch nicht die einzelnen Frequenzen im Spektrum an, sondern gruppieren sie in Frequenzbänder, die leichter zu lesen sind und häufig in Audio-Spektrumanalysatoren verwendet werden. Die Frequenzbänder liegen ungefähr bei 125, 250, 500, 1000, 2000, 4000 und 8000 Hz, wie unten gezeigt:
MAX4466 Mikrofonmodul
Das MAX4466 Mikrofonmodul ist ein Breakout-Board mit einem 20-20 kHz Elektretmikrofon und dem MAX4466 Vorverstärker-IC. Auf der Rückseite des Boards befindet sich ein kleiner Trimmer, mit dem du die Verstärkung von 25x bis 125x einstellen kannst. Das Bild unten zeigt Vorder- und Rückseite des Boards:
Das Modul läuft mit 2,4…5,5 V für VCC bei einem sehr niedrigen Ruhestrom von <24μA. Der Ausgang hat eine Vorspannung von VCC/2. Wenn es also vollkommen still ist, liegt die Ausgangsspannung bei VCC/2 V.
Wenn du mehr über das MAX4466 Mikrofonmodul erfahren möchtest, schau dir das Detect sound with MAX4466 and Arduino Tutorial an.
Anschluss von MAX4466 und OLED an ESP32
In diesem Abschnitt verbinden wir zuerst das MAX4466 Mikrofonmodul mit dem ESP32 und testen seine Funktion. Danach fügen wir das OLED zum Schaltkreis hinzu und schreiben den Code für den Spektrumanalysator:
Anschluss von MAX4466 an ESP32
Um das MAX4466 an einen ESP32 anzuschließen, verbinde zuerst die Masse (GND) des ESP32 mit der Masse des MAX4466-Moduls (blaues Kabel). Dann verbinde VCC des MAX4466 mit dem 3,3V-Ausgang des ESP32 (rotes Kabel). Schließlich verbinde GPIO 4 des ESP32 mit dem OUT-Pin des MAX4466 (oranges Kabel):
Beachte, dass du statt GPIO 4 jeden anderen Pin verwenden kannst, solange er ein analoges Signal lesen kann.
Testcode für MAX4466
Nachdem du das MAX4466 Mikrofon an den ESP32 angeschlossen hast, führen wir einen kleinen Test durch, um zu sehen, ob alles wie erwartet funktioniert. Der folgende Code liest das Mikrofonsignal an Pin 4 aus und gibt es im Serial Monitor aus:
const byte micPin = 4;
void setup() {
Serial.begin(115200);
pinMode(micPin, INPUT);
}
void loop() {
int value = analogRead(micPin);
Serial.println(value);
delay(100);
}
Wenn du diesen Code hochlädst, den Serial Plotter öffnest und etwas Lärm machst, solltest du Schwankungen im Audiosignal sehen, die mit der Lautstärke des Geräusches zusammenhängen:
Wenn du keine Änderung im Audiosignal siehst, ist entweder die Verkabelung falsch oder der GPIO-Pin für das Mikrofon im Code ist nicht korrekt.
OLED zum ESP32 hinzufügen
Im nächsten Schritt fügen wir das OLED zum ESP32 hinzu. Verbinde zuerst GND und VCC des OLED mit den vorhandenen Stromversorgungsleitungen (blaue und rote Kabel). Dann verbinde SCL mit Pin 23 und SDA mit Pin 18 des ESP32, wie unten gezeigt:
GPIO 23 und 18 sind die Hardware-I2C-Pins für den ESP32 lite. Wenn du ein anderes ESP32-Board verwendest, können die Pins für Hardware-I2C abweichen. Wenn du dir unsicher bist, welche Pins du verwenden sollst, schau dir das Find I2C and SPI default pins Tutorial an. Das Bild unten zeigt den fertigen Schaltkreis auf einem Breadboard:
Code zur Anzeige des Frequenzspektrums
Bevor wir den Code schreiben können, um das Frequenzspektrum zu berechnen und anzuzeigen, müssen wir die arduinoFFT library installieren. Öffne den LIBRARY MANAGER, tippe „arduinoFFT“ in die Suchleiste und drücke die INSTALL Taste. Nach erfolgreicher Installation solltest du Folgendes sehen:
Außerdem müssen wir die Adafruit_SSD1306 Library installieren, um das OLED zu steuern. Tippe „Adafruit_SSD1306“ in die Suchleiste und drücke wie zuvor INSTALL, um die Bibliothek zu installieren:
Damit ist alles bereit, um mit dem Schreiben des Codes zu beginnen. Der folgende Code für einen Audio-Spektrum-Visualizer liest Audiodaten von einem Mikrofon, führt eine Fast Fourier Transformation (FFT) durch, um das Frequenzspektrum zu analysieren, und zeigt die Ergebnisse auf einem OLED an. Das folgende Bild zeigt die Ausgabe und die Bedeutung der visuellen Elemente:
In den nächsten Abschnitten betrachten wir diesen Code Funktion für Funktion. Der Code basiert auf dem ESP32_FFT_VU Beispiel, wurde aber in kleinere Funktionen aufgeteilt und zur besseren Lesbarkeit leicht angepasst.
#include "arduinoFFT.h"
#include "Adafruit_SSD1306.h"
const int micPin = 4;
const int volume = 300; // Adjust depending on audio volume
const int noise = 2000; // Noise filter, smaller signal is ignored
const int nSamples = 256; // Must be a power of 2
const int sampleFreq = 40000; // Hz, 40000 or less
double vReal[nSamples];
double vImag[nSamples];
byte peaks[] = { 0, 0, 0, 0, 0, 0, 0 };
ArduinoFFT<double> FFT = ArduinoFFT<double>(vReal, vImag, nSamples, sampleFreq);
Adafruit_SSD1306 oled(128, 64, &Wire, -1);
void displayScale() {
oled.clearDisplay();
oled.setCursor(0, 0);
oled.print(".1 .2 .5 1K 2K 4K 8K");
}
void displayBands() {
for (int i = 2; i < (nSamples / 2); i++) {
if (vReal[i] > noise) {
if (i <= 2) displayBand(0, vReal[i]); // 125Hz
if (i > 3 && i <= 5) displayBand(1, vReal[i]); // 250Hz
if (i > 5 && i <= 7) displayBand(2, vReal[i]); // 500Hz
if (i > 7 && i <= 15) displayBand(3, vReal[i]); // 1000Hz
if (i > 15 && i <= 30) displayBand(4, vReal[i]); // 2000Hz
if (i > 30 && i <= 53) displayBand(5, vReal[i]); // 4000Hz
if (i > 53 && i <= 200) displayBand(6, vReal[i]); // 8000Hz
if (i > 200) displayBand(7, vReal[i]); // 16000Hz
}
}
}
void calcFFT() {
FFT.windowing(vReal, nSamples, FFT_WIN_TYP_HAMMING, FFT_FORWARD);
FFT.compute(vReal, vImag, nSamples, FFT_FORWARD);
FFT.complexToMagnitude(vReal, vImag, nSamples);
}
void sampleAudio() {
static unsigned long newTime, oldTime;
long period_us = round(1000000.0 / sampleFreq);
for (int i = 0; i < nSamples; i++) {
newTime = micros() - oldTime;
oldTime = newTime;
vReal[i] = analogRead(micPin);
vImag[i] = 0;
while (micros() < (newTime + period_us))
;
}
}
void displayPeaks() {
for (byte band = 0; band <= 6; band++) {
oled.drawFastHLine(18 * band, 64 - peaks[band], 14, WHITE);
}
}
void decayPeaks() {
if (millis() % 4 == 0) {
for (byte band = 0; band <= 6; band++) {
peaks[band] = max(0, peaks[band] - 1);
}
}
}
void displayBand(int band, double magnitude) {
int dmax = 50;
int dsize = min((int)(magnitude / volume), dmax);
if (band == 7) {
oled.drawFastHLine(18 * 6, 0, 14, WHITE);
}
for (int s = 0; s <= dsize; s += 2) {
oled.drawFastHLine(18 * band, 64 - s, 14, WHITE);
}
if (dsize > peaks[band]) {
peaks[band] = dsize;
}
}
void setup() {
oled.begin(SSD1306_SWITCHCAPVCC, 0x3C);
oled.setTextSize(1);
oled.setTextColor(WHITE);
pinMode(micPin, INPUT);
}
void loop() {
displayScale();
sampleAudio();
calcFFT();
displayBands();
displayPeaks();
decayPeaks();
oled.display();
delay(1);
}
Bibliotheken
Der Code beginnt mit dem Einbinden der benötigten Bibliotheken. Es gibt die arduinoFFT Bibliothek zur Berechnung der Fast Fourier Transformation (FFT) und die Adafruit_SSD1306 Bibliothek, die zur Steuerung des OLED benötigt wird:
#include "arduinoFFT.h" #include "Adafruit_SSD1306.h"
Konstanten
Dann definieren wir einige Konstanten. micPin legt den GPIO-Pin fest, an den der Ausgang des MAX4466 angeschlossen ist. Die volume Konstante ermöglicht es dir, die Größe des angezeigten Frequenzspektrums entsprechend der Lautstärke anzupassen. Wenn du keine Balken siehst, verringere diesen Wert, und wenn die Balken auch bei schwachem Ton sehr groß sind, erhöhe ihn.
Ähnlich filtert die Noise-Konstante niedriges Rauschen heraus. Wenn du zu viel Rauschen im Frequenzspektrum siehst (zufällige Schwankungen, auch wenn kein Ton vorhanden ist), erhöhe diesen Wert.
nSamples definiert, wie viele Audiosamples genommen werden, und sampleFreq ist die Abtastfrequenz. Für Mikrocontroller, die langsamer als der ESP32 sind, musst du diese Werte möglicherweise verringern.
const int micPin = 4; const int volume = 300; // Adjust depending on audio volume const int noise = 2000; // Noise filter, smaller signal is ignored const int nSamples = 256; // Must be a power of 2 const int sampleFreq = 40000; // Hz, 40000 or less
Variablen
Es gibt drei Variablen. vReal und vImag sind Arrays, die den Real- und Imaginärteil des Signals speichern, und das peaks Array hält die maximalen Magnituden für jeden Frequenzbalken fest.
double vReal[nSamples];
double vImag[nSamples];
byte peaks[] = { 0, 0, 0, 0, 0, 0, 0 };
Objekte
Schließlich gibt es die Objekte. Das FFT Objekt enthält die Funktionen zur Berechnung der Fast Fourier Transformation, und das oled Objekt enthält die Funktionen zur Steuerung des OLED-Displays.
ArduinoFFT<double> FFT = ArduinoFFT<double>(vReal, vImag, nSamples, sampleFreq); Adafruit_SSD1306 oled(128, 64, &Wire, -1);
displayScale
Die displayScale() Funktion bereitet das OLED-Display vor, indem sie vorherigen Inhalt löscht und Beschriftungen für die Frequenzbänder ausgibt. Das hilft dem Betrachter zu verstehen, welches Band welcher Frequenz entspricht. Die Funktion verwendet diesen Code:
void displayScale() {
oled.clearDisplay();
oled.setCursor(0, 0);
oled.print(".1 .2 .5 1K 2K 4K 8K");
}
Die displayBands() Funktion verarbeitet das FFT-Ergebnis, das im vReal Array gespeichert ist, und entscheidet, in welches Frequenzband jeder FFT-Bin fällt. Sie filtert Signale unterhalb eines Rauschschwellenwerts heraus und ruft dann displayBand() mit dem Index des Bandes und der Magnitude des Signals auf:
void displayBands() {
for (int i = 2; i < (nSamples / 2); i++) {
if (vReal[i] > noise) {
if (i <= 2) displayBand(0, vReal[i]);
if (i > 3 && i <= 5) displayBand(1, vReal[i]);
if (i > 5 && i <= 7) displayBand(2, vReal[i]);
if (i > 7 && i <= 15) displayBand(3, vReal[i]);
if (i > 15 && i <= 30) displayBand(4, vReal[i]);
if (i > 30 && i <= 53) displayBand(5, vReal[i]);
if (i > 53 && i <= 200) displayBand(6, vReal[i]);
if (i > 200) displayBand(7, vReal[i]);
}
}
}
Die calcFFT() Funktion führt die eigentliche FFT-Analyse durch. Sie wendet ein Hamming-Fenster an, um das Signal zu glätten, und berechnet dann die FFT, wobei die Real- und Imaginärteile in Magnituden umgewandelt und zurück in vReal gespeichert werden:
void calcFFT() {
FFT.windowing(vReal, nSamples, FFT_WIN_TYP_HAMMING, FFT_FORWARD);
FFT.compute(vReal, vImag, nSamples, FFT_FORWARD);
FFT.complexToMagnitude(vReal, vImag, nSamples);
}
Die sampleAudio() Funktion sammelt nSamples analoge Daten vom Mikrofon. Sie liest das Signal in regelmäßigen Abständen aus, die mit sampleFreq berechnet werden, und speichert es im vReal Array. vImag wird auf Null gesetzt, da der Eingang rein real ist:
void sampleAudio() {
static unsigned long newTime, oldTime;
long period_us = round(1000000.0 / sampleFreq);
for (int i = 0; i < nSamples; i++) {
newTime = micros() - oldTime;
oldTime = newTime;
vReal[i] = analogRead(micPin);
vImag[i] = 0;
while (micros() < (newTime + period_us))
;
}
}
Die displayPeaks() Funktion zeigt persistente Spitzenwerte jedes Frequenzbandes, indem sie kurze horizontale Linien an der Stelle zeichnet, an der die Spitze zuletzt auftrat. Diese Linien helfen, die maximalen aktuellen Lautstärkepegel in jedem Band zu visualisieren:
void displayPeaks() {
for (byte band = 0; band <= 6; band++) {
oled.drawFastHLine(18 * band, 64 - peaks[band], 14, WHITE);
}
}
Die decayPeaks() Funktion reduziert langsam den Spitzenwert über die Zeit, um einen Abklingeffekt zu simulieren. Sie läuft ungefähr alle 4 Millisekunden und senkt die Spitze jedes Bandes um 1, bis mindestens 0 erreicht ist:
void decayPeaks() {
if (millis() % 4 == 0) {
for (byte band = 0; band <= 6; band++) {
peaks[band] = max(0, peaks[band] - 1);
}
}
}
Die displayBand() Funktion zeichnet vertikale Balken für jedes Band auf dem OLED. Sie skaliert die Balkengröße basierend auf der Magnitude des Signals geteilt durch den volume Parameter. Wenn der Bandindex 7 ist, wird ein spezieller Balken oben auf dem Bildschirm gezeichnet. Die Funktion aktualisiert auch das peaks Array, wenn der aktuelle Balken den vorherigen Spitzenwert übertrifft:
void displayBand(int band, double magnitude) {
int dmax = 50;
int dsize = min((int)(magnitude / volume), dmax);
if (band == 7) {
oled.drawFastHLine(18 * 6, 0, 14, WHITE);
}
for (int s = 0; s <= dsize; s += 2) {
oled.drawFastHLine(18 * band, 64 - s, 14, WHITE);
}
if (dsize > peaks[band]) {
peaks[band] = dsize;
}
}
Die setup() Funktion initialisiert den OLED-Bildschirm und setzt den Mikrofon-Pin als Eingang. Damit ist das System bereit, Audiodaten zu erfassen und anzuzeigen:
void setup() {
oled.begin(SSD1306_SWITCHCAPVCC, 0x3C);
oled.setTextSize(1);
oled.setTextColor(WHITE);
pinMode(micPin, INPUT);
}
Schließlich ist die loop() Funktion der Hauptausführungszyklus. Sie führt wiederholt alle notwendigen Schritte aus, um Audio aufzunehmen, es per FFT zu verarbeiten, die Daten zu visualisieren und das OLED-Display zu aktualisieren:
void loop() {
displayScale();
sampleAudio();
calcFFT();
displayBands();
displayPeaks();
decayPeaks();
oled.display();
delay(1);
}
Zusammen bilden diese Funktionen eine vollständige Schleife, die kontinuierlich Audiodaten analysiert und ein visuelles Spektrum auf dem OLED-Display anzeigt.
Testtöne
Du kannst den Spektrumanalysator testen, indem du einige Testtöne abspielst. Hier sind Links zu YouTube-Videos, die Töne mit bestimmten Frequenzen abspielen:
Der Spektrumanalysator sollte für das Frequenzband, in das der Testton fällt, einen größeren/wachsenden Balken anzeigen. Zum Beispiel solltest du bei einem 2000-Hz-Ton einen größeren Balken im 2-kHz-Frequenzband sehen:
Die Höhe des Balkens hängt von der Lautstärke ab. Wahrscheinlich musst du die volume Konstante oder den gain control für das MAX4466 anpassen, um ein gutes Signal zu erhalten. Den Potentiometer zur Verstärkungsanpassung findest du auf der Rückseite des MAX4466-Moduls:
Fazit
In diesem Tutorial hast du gelernt, wie man einen Frequenzspektrumanalysator mit dem MAX4466 Mikrofonmodul, einem OLED und einem ESP32 baut.
Wenn du die Genauigkeit und den Frequenzbereich des Spektrumanalysators verbessern möchtest, könntest du einen externen Analog-Digital-Wandler für höhere Auflösung und ein I2C-Mikrofon für einen besseren Bereich verwenden.
Ebenso könntest du für ein größeres Display und Farben das OLED durch einen TFT-Bildschirm ersetzen. Schau dir die Interface TFT ILI9341 Touch Display with ESP32 und vielleicht die How to configure TFT_eSPI Library for TFT display Tutorials an.
Das ESP32 lite Board hat eine LiPo-Batterieschnittstelle, was es einfach macht, den Spektrumanalysator mit einer 4,2V LiPo-Batterie zu betreiben. Das Board ist jedoch etwas groß, besonders im Vergleich zum winzigen OLED, das wir verwendet haben. Statt des ESP32 lite könntest du einen ESP32-C SuperMini verwenden, um einen sehr kleinen, niedlichen und portablen Spektrumanalysator zu bauen.
Viel Spaß beim Tüfteln ; )
Links
Im Folgenden einige Links, die ich beim Schreiben dieses Tutorials nützlich fand:
- arduinoFFT Examples
- esp32-mic-fft
- ESP32_FFT_VU
- ESP32-8266-Audio-Spectrum-Display
- ESP32_Music_Spectrum_Analyzer
- ESP32 spectrum analyser VU meter using arduinoFFT and a FastLED matrix
