DIY Soundsucher: Scanner für Ultrasoundaufnahmen bis 100 kHz

[ruessel]

Bin im Zeitverzug..... ist halt so, manchmal muss man(n) was anderes machen. ;-)

Habe gerade meinen "Verdrahtungsstift" für Kupferlackdraht montiert, der Stift war ein Kugelschreiber, der obige Aufbau kommt aus dem 3D Drucker. Keine Ahnung ob das klappt.

[ruessel]

Puh..... nach 3 Jahren das Projekt immer noch nicht fertig! Das hatte etwas in meinen persönlichen Umfeld zu tun und dadurch Zeitmangel...... und auch keine Lust mehr.

Da ich wieder in die HiRes Tonaufnahmen tiefer einsteigen möchte, habe ich heute das Thema noch einmal aufgenommen und fange nochmal neu an. In der Zwischenzeit hat sich auch bei den Prozessoren etwas getan. Ich habe nun ein Modell ausgesucht, einem Cortex M4 getaktet mit 120 MHz und Gleitkommaunterstützung. Dieser eignet sich mit seinen DSP und 8 x 12-Bit Analogeingänge besonders für dieses 100 kHz Audioprojekt, würde sogar noch höhere Frequenzen verarbeiten. Er besitzt außerdem eine einfache Anbindung an einem 3,5 Zoll Display mit umfangreichen Bibliotheken, was die Sache für mich erst überhaupt machbar erscheint. So gibt es dann nur noch ein Rechenknecht für Audioanalyse und Darstellung auf dem Bildschirm. Gut für die mobile Anwendung in Betrachtung des Stromverbrauches. Ich habe einen normalen 20,- EUR Bildschirm ausgesucht, OLED wäre mir viel lieber, ist aber in der Größe nicht bezahlbar. Vielleicht später, falls ich das zum Laufen bringen kann. Die für den Code erforderlichen Berechnungen habe ich der KI überlassen, sie wies auch nochmal darauf hin, dass das Mikrofon bei 100 kHz beschnitten werden muss, sonst gibt es in der Darstellung der Balkendiagramme auf dem Display Frequenzen die gar nicht vorhanden sind. Um den 100 kHz Mikrofonverstärker kümmere ich mich zuletzt. Für erste Tests ob das Skript läuft, setze ich einen Funktionsgenerator ein, das dürfte reichen um die Grundfunktionen zu Testen.

Der Prozessor ist bestellt, liegt um die 30 Euro, ist aber zur Zeit nicht so leicht in DE zu bekommen. Eine Makerbude hatte noch 2 auf Lager, also wieder warten auf Teile.



Die KI meint zu diesem Projekt:

Relevante technische Eckdaten des Feather M4:
CPU: ATSAMD51, Cortex‑M4 @ 120 MHz mit FPU und DSP‑Instruktionen.
RAM / Flash: 192 KB SRAM, 512 KB Flash; zusätzlich 2 MB SPI‑Flash auf dem Board.
ADC: Dual 12‑bit ADC mit bis zu 1 MSPS (je ADC).

Was das für einen 100 kHz Spektrumanalysator bedeutet:
Abtastrate: Für ein Nutzsignal bis 100 kHz brauchst du mindestens die Nyquist‑Rate ≥ 200 kS/s. Praktisch sind oft 250 kS/s – 1 MS/s sinnvoll.
≥ 200 kS/s.

ADC‑Leistung:
Die on‑board ADCs des ATSAMD51 (1 MSPS) reichen für 100 kHz‑Anwendungen aus, sofern die analoge Frontend‑Qualität (Anti‑Alias‑Filter, Verstärkung) passt.

FFT‑Rechenaufwand:
Eine FFT mit 𝑁 Punkten benötigt 𝑂(𝑁log 𝑁) Operationen; mit FPU und CMSIS‑DSP‑Bibliothek sind moderate FFT‑Größen (z. B. 1024–8192) auf einem 120 MHz M4 realisierbar, aber bei sehr kurzen FFT‑Intervallen oder sehr hoher Überlappung kann die CPU zum Engpass werden.

Praktische Implementationshinweise für den Feather M4:
ADC‑Acquisition: Nutze ADC + DMA, um kontinuierlich Samples in einen Ringpuffer zu schreiben; so vermeidest du CPU‑Blocking.
Windowing und FFT: Verwende optimierte DSP‑Bibliotheken (CMSIS‑DSP) und FPU‑Unterstützung für komplexe FFTs und Window‑Funktionen.

Puffergrößen:
Für 100 kHz und z. B. 1024‑Punkt‑FFT bei 250 kS/s entspricht ein FFT‑Frame 1024 / 250000 = 4.096 ms. Kleinere Frames erhöhen CPU‑Last und Overlap‑Kosten.

I/O und Visualisierung:
Nutze die Feather‑CPU für Datenerfassung und Vorverarbeitung; GUI/Logging per USB/SD oder seriell an einen PC auslagern, falls nötig.



Ich werde den Prozessor einfach mal testen, ich möchte ja keine ganz exakten Werte der Frequenzen beurteilen, sondern VOR der Aufnahme sehen, ob überhaupt hier Frequenzen oberhalb von 20 kHz vorhanden sind und sich diese Aufnahme dadurch in HiRes überhaupt "lohnt".

[ruessel]

Hier irrte die KI, bekomme ab 70 kHz kein richtiges Signal mehr raus. Ich vermute der Chip ist überlastet. Habe das neu durchrechnen lassen und eine KI (habe gewechselt) schlägt mir nun etwas anderes vor:

Feather M4 Express — was realistisch ist

Der ADC im Adafruit Feather M4 Express kann zwar theoretisch relativ schnell sampeln, aber:

stabile 12-Bit-Werte bei sehr hohen Sampleraten sind schwierig
FFT + Display + DMA gleichzeitig kostet Leistung
RAM wird schnell knapp

Realistisch:

sehr gut bis 20 kHz
brauchbar bis ~40 kHz
experimentell bis ~80 kHz
100 kHz eher grenzwertig

Bessere Plattform für 100 kHz FFT

Wenn dein Ziel wirklich ist:
„Ich möchte Frequenzen bis 100 kHz sichtbar machen“ dann wäre deutlich besser:

Teensy 4.1
externer ADC
DMA
CMSIS DSP FFT

Der Teensy 4.1 schafft locker:
500 kHz Sampling
große FFTs
TFT-Ausgabe in Echtzeit

Das ist eine ganz andere Liga als der Feather M4.

Ja, kostet auch in der neusten Form aktuell 50,- EUR........(Preise haben seit kurzen stark angezogen)

Scheint aber wirklich im Audiobereich stark zu sein, hier ein 6-voice polyphonic virtual analog synthesizer gebaut mit dem Teensy 4.1 Chip:

[ruessel]

Es ist verflixt, Amazonlieferung mit dem Teensy 4.1 verzögert sich um Wochen, was ist da los? Ich habe ihn nochmal bestellt, angeblich 3 auf Lager, Lieferung innerhalb 3 Werktagen.
Dieser Prozessor scheint einer der schnellsten der heute zur Verfügung an Bastler gehen kann, selbst die NASA soll diesen Chip für schnelle Messungen benutzen. Warum keinen Raspi? weil darauf ein Betriebssystem läuft und alles lahm macht, alleine der Start ist wahnsinnig langsam, bis alles erst geladen ist.

Hier habe ich ein nettes Video gefunden von der Fertigung:

[ruessel]

Heute ist mein Teensy angekommen. Da man nur tolle Leistungen vom Teensy hört und ich keine Vorstellung davon habe, dachte ich mir ein Rennen aus, ESP32 gegen Teensy. Leider kann ich heute nicht den Teensy programmieren, für die USB Schnittstelle habe ich kein Kabel, leider kein USC-C Anschluss.
Aber den ESP32 habe ich schon zum testen programmiert.

P1000056.JPG

Es läuft einwandfrei und erzeugt eine Computeranimation. Die KI hat die verwendeten Programmzeilen gelesen und diesen kurzen Aufsatz darüber geschrieben:

ESP32 Mandelbrot Benchmark – Erklärung

Dieser Sketch verwandelt einen einfachen ESP32 Mikrocontroller in einen kleinen Echtzeit-Grafikcomputer.
Auf einem ST7789 IPS-Display wird kontinuierlich ein sogenanntes Mandelbrot-Fraktal berechnet und dargestellt.

Dabei berechnet der ESP32 für jeden einzelnen Bildpunkt mathematisch:

welche Farbe der Pixel bekommt
wie komplex die Struktur ist
und wie schnell das Ganze berechnet werden kann.

Der Sketch dient gleichzeitig als:

Grafikdemo
CPU-Benchmark
Mathematikvisualisierung
Vergleichstest zwischen Mikrocontrollern

Später kann derselbe Sketch auf anderen Prozessoren laufen, z.B. auf einem Teensy 4.1.
Dadurch lässt sich direkt vergleichen:

welcher Prozessor schneller rechnet
höhere FPS erreicht
mehr Pixel pro Sekunde berechnet
Was ist das Mandelbrot-Fraktal?

Das Mandelbrot-Fraktal ist eines der berühmtesten mathematischen Bilder überhaupt.

Es wurde vom Mathematiker:
Benoît Mandelbrot

bekannt gemacht.

Das Besondere:

Das Bild entsteht rein aus Mathematik
Keine Grafikdatei wird geladen
Jeder Pixel wird live berechnet
Warum ist das so faszinierend?

Wenn man immer tiefer hineinzoomt:

erscheinen neue Muster
Spiralen entstehen
kleine Kopien des Gesamtbildes tauchen auf
Details wiederholen sich unendlich

Das nennt man ein:

Fractal

Ein Fraktal besitzt Strukturen, die sich selbst ähnlich bleiben — egal wie tief man hineinzoomt.

Was macht der Sketch genau?
1. Startbildschirm

Beim Einschalten zeigt das Display:

ESP32
Mandelbrot Rennen
Zoom Benchmark

Danach wird der Bildschirm sanft ausgeblendet.

2. Live-Berechnung des Fraktals

Der ESP32 berechnet anschließend:

jeden Pixel
jede Farbe
jede Zoomstufe

in Echtzeit.

Dabei bewegt sich die Kamera immer tiefer in das Fraktal hinein.

3. Benchmark-Anzeige

Oben auf dem Bildschirm erscheinen Live-Daten:

Anzeige Bedeutung
FPS Bilder pro Sekunde
Fxx aktuelle Framenummer
Zoom aktuelle Zoomstufe
kPix/s berechnete Pixel pro Sekunde

Damit sieht man direkt:

wie stark der Prozessor ausgelastet ist
wie schnell die Berechnung erfolgt
wann der Prozessor an seine Grenzen kommt
Warum ist das ein guter Benchmark?

Das Mandelbrot-Fraktal belastet einen Mikrocontroller stark, weil:

sehr viele mathematische Berechnungen nötig sind
jeder Pixel einzeln berechnet wird
Fließkommaoperationen benötigt werden
das Display permanent aktualisiert wird

Dadurch eignet sich der Sketch hervorragend zum Vergleich von:

ESP32
Teensy
STM32
Raspberry Pi Pico
anderen Mikrocontrollern
Technische Besonderheiten des Sketches

Der Sketch verwendet:

Hardware-SPI für schnellen Displaytransfer
Zeilenbuffer für effizientes Zeichnen
PWM-Fading für weiche Übergänge
Live-HUD mit Benchmarkdaten
optimierte Fraktalberechnung

Dadurch läuft die Demo überraschend flüssig — selbst auf einem kleinen ESP32.

Warum sieht das so beeindruckend aus?

Das Display zeigt:

mathematische Kunst
technische Leistung
Echtzeitberechnung
Farbanimation

gleichzeitig.

Die kleinen IPS-Displays mit den runden Ecken verleihen dem Projekt zusätzlich einen fast professionellen Geräte-Look.

Fazit

Dieser Sketch ist:

Mathematik
Grafikdemo
Benchmark
Mikrocontroller-Projekt
Echtzeitvisualisierung

in einem einzigen kleinen System.

Und das alles läuft vollständig auf einem kleinen ESP32-Mikrocontroller

Sehr schön und hier nun der verwendete Code:

Code: Alles auswählen

/*
========================================================
ESP32 WROOM Mandelbrot Benchmark V1.1
Display: ST7789 280x240 IPS
Library: TFT_eSPI
Ruesseltechnik 13.05.2026
========================================================

VERDRAHTUNG
========================================================

DISPLAY -> ESP32

GND  -> GND
VCC  -> 3.3V
SCL  -> GPIO 18   // SPI Clock
SDA  -> GPIO 23   // SPI MOSI
RES  -> GPIO 4
DC   -> GPIO 2
CS   -> GPIO 5
BLK  -> GPIO 15   // Backlight PWM

========================================================
TFT_eSPI User_Setup.h
========================================================

#define ST7789_DRIVER

#define TFT_WIDTH  280
#define TFT_HEIGHT 240

#define TFT_MOSI 23
#define TFT_SCLK 18

#define TFT_CS    5
#define TFT_DC    2
#define TFT_RST   4

#define LOAD_GLCD
#define LOAD_FONT2

#define SPI_FREQUENCY  40000000

========================================================
*/

#include <Arduino.h>
#include <TFT_eSPI.h>

TFT_eSPI tft = TFT_eSPI();

// ========================================
// Backlight
// ========================================

#define TFT_BL 15

// ========================================
// Displaygroesse
// ========================================

const int WIDTH  = 280;
const int HEIGHT = 240;

// ========================================
// HUD
// ========================================

const int HUD_HEIGHT = 60;

// ========================================
// Mandelbrot
// ========================================

const int MAX_ITER = 64;

// Zoom
float zoom = 1.0;
float zoomSpeed = 1.05;

// ========================================
// Hotspots
// ========================================

const int NUM_SPOTS = 4;

float spotX[NUM_SPOTS] =
{
    -0.77568377,
    -0.74364388703,
    -0.1011,
    -0.7453
};

float spotY[NUM_SPOTS] =
{
     0.13646737,
     0.13182590421,
     0.9563,
     0.1127
};

int currentSpot = 0;

float centerX = spotX[0];
float centerY = spotY[0];

// ========================================
// Statistik
// ========================================

float fps = 0.0;
float pixelsPerSecond = 0.0;

unsigned long frameTime  = 0;
unsigned long frameCount = 0;

// ========================================
// Zeilenbuffer
// ========================================

uint16_t lineBuffer[WIDTH];

// ========================================
// SETUP
// ========================================

void setup()
{
    Serial.begin(115200);

    // PWM Backlight
    ledcAttach(TFT_BL, 5000, 8);

    // Volle Helligkeit
    ledcWrite(TFT_BL, 255);

    // Display starten
    tft.init();

    // Orientierung
    tft.setRotation(1);

    // Bildschirm schwarz
    tft.fillScreen(TFT_BLACK);

    // ====================================
    // Startscreen
    // ====================================

    drawCenteredText("ESP32", 45, TFT_GREEN);
    drawCenteredText("Mandelbrot", 75, TFT_GREEN);
    drawCenteredText("Rennen", 105, TFT_GREEN);

    drawCenteredText("Zoom Benchmark", 150, TFT_WHITE);

    delay(2000);

    // Sanft abdunkeln
    fadeOut();

    // Bildschirm loeschen
    tft.fillScreen(TFT_BLACK);

    // Sanft einblenden
    fadeIn();
}

// ========================================
// LOOP
// ========================================

void loop()
{
    unsigned long startMicros = micros();

    renderMandelbrot();

    frameTime = micros() - startMicros;

    fps = 1000000.0 / frameTime;

    pixelsPerSecond =
        (float)(WIDTH * HEIGHT) * fps;

    drawHUD();

    frameCount++;

    // Zoom vergroessern
    zoom *= zoomSpeed;

    // ====================================
    // Naechster Hotspot
    // ====================================

    if (zoom > 5000.0)
    {
        // Ausblenden
        fadeOut();

        // Naechsten Spot waehlen
        currentSpot++;

        if (currentSpot >= NUM_SPOTS)
        {
            currentSpot = 0;
        }

        centerX = spotX[currentSpot];
        centerY = spotY[currentSpot];

        // Zoom reset
        zoom = 1.0;

        // Bildschirm schwarz
        tft.fillScreen(TFT_BLACK);

        // Einblenden
        fadeIn();
    }
}

// ========================================
// Mandelbrot Rendern
// ========================================

void renderMandelbrot()
{
    float scale = 3.0 / zoom;

    for (int py = HUD_HEIGHT; py < HEIGHT; py++)
    {
        float renderHeight = HEIGHT - HUD_HEIGHT;

float y0 =
    centerY +
    ((float)(py - HUD_HEIGHT) -
     renderHeight / 2.0) *
    scale / renderHeight;

        for (int px = 0; px < WIDTH; px++)
        {
            float x0 =
                centerX +
                ((float)px - WIDTH / 2.0) *
                scale / WIDTH;

            float x = 0.0;
            float y = 0.0;

            int iter = 0;

            while ((x * x + y * y <= 4.0) &&
                   (iter < MAX_ITER))
            {
                float xtemp =
                    x * x - y * y + x0;

                y = 2.0 * x * y + y0;
                x = xtemp;

                iter++;
            }

            uint16_t color;

            if (iter >= MAX_ITER)
            {
                color = TFT_BLACK;
            }
            else
            {
                uint8_t r = (iter * 9) % 255;
                uint8_t g = (iter * 7) % 255;
                uint8_t b = (iter * 5) % 255;

                color = tft.color565(r, g, b);
            }

            lineBuffer[px] = color;
        }

        // Ganze Zeile senden
        tft.pushImage(
            0,
            py,
            WIDTH,
            1,
            lineBuffer
        );
    }
}

// ========================================
// HUD
// ========================================

void drawHUD()
{
    // HUD Hintergrund
    tft.fillRect(
        0,
        0,
        WIDTH,
        HUD_HEIGHT,
        TFT_BLACK
    );

    tft.setTextColor(TFT_WHITE, TFT_BLACK);
    tft.setTextSize(2);

    char line1[64];
    char line2[64];

    sprintf(line1,
            "ESP32 %.1fFPS F%lu",
            fps,
            frameCount);

    sprintf(line2,
            "Z%.1fx  %lukPix/s",
            zoom,
            (unsigned long)(pixelsPerSecond / 1000.0));

    int w1 = strlen(line1) * 12;
    int w2 = strlen(line2) * 12;

    // Zentriert
    tft.setCursor((WIDTH - w1) / 2, 10);
    tft.print(line1);

    tft.setCursor((WIDTH - w2) / 2, 32);
    tft.print(line2);
}

// ========================================
// Zentrierter Text
// ========================================

void drawCenteredText(
    const char* text,
    int y,
    uint16_t color)
{
    tft.setTextColor(color, TFT_BLACK);
    tft.setTextSize(2);

    int w = strlen(text) * 12;

    tft.setCursor((WIDTH - w) / 2, y);

    tft.print(text);
}

// ========================================
// Fade Out
// ========================================

void fadeOut()
{
    for (int i = 255; i >= 0; i--)
    {
        ledcWrite(TFT_BL, i);
        delay(15);
    }
}

// ========================================
// Fade In
// ========================================

void fadeIn()
{
    for (int i = 0; i <= 255; i++)
    {
        ledcWrite(TFT_BL, i);
        delay(9);
    }
}

Der Code ist auch geeignet einen ESP32 auf Dauerstress zu testen. Ich habe die Stromaufnahme getestet, bei Anzeige der ersten Texttafel verbraucht er 0,4 watt Leistung, beim Berechnen des Mandelbrotes steigt der Verbrauch auf etwas über 0.7 Watt.