Ratgeber · 9 Min. Lesezeit

Metalldetektor mit Arduino bauen: Suchspule, LC-Oszillator, Code

Metalldetektor mit Arduino: Suchspule wickeln, LC-Oszillator, Frequenzverschiebung messen, Summerton, Windungstabelle, Bodeneffekt sowie Code für Uno und ESP32.

Einen Metalldetektor mit Arduino baust du an einem Nachmittag aus einer Suchspule, einem günstigen IC und ein paar passiven Bauteilen, und du lernst dabei eine Menge. Die Spule ist Teil eines LC-Oszillators; kommt Metall in ihre Nähe, ändert sich ihre Induktivität, die Frequenz des Oszillators verschiebt sich, und der Arduino misst diese Verschiebung und macht sie über einen Summer hörbar. So ein Detektor spürt eine Münze auf wenige Zentimeter, eine Getränkedose auf 10–15 cm und einen großen Metalldeckel auf 20–30 cm. Mit einem gekauften Gerät kann er nicht mithalten, aber für den Nagel in der Wand, den Schlüssel im Sand oder das verlorene Werkzeug im Garten reicht er.

In dieser Anleitung schauen wir uns zuerst an, wie Metalldetektoren funktionieren, und vergleichen die drei Grundverfahren: Frequenzverschiebung, VLF und Pulsinduktion. Dann wickeln wir die Suchspule, sehen in einer Tabelle, wie die Windungszahl die Empfindlichkeit beeinflusst, bauen den LC-Oszillator auf und schreiben den Code für Arduino Uno und ESP32. Die letzten Abschnitte behandeln Kalibrierung, Bodeneffekte, die Unterscheidung von Eisen und anderen Metallen und die häufigsten Probleme.

Wie funktioniert ein Metalldetektor?

Eine Spule, durch die Wechselstrom fließt, erzeugt um sich herum ein Magnetfeld, das ständig die Richtung wechselt. Gerät ein Metallgegenstand in dieses Feld, kann zweierlei passieren. In Metallen ohne Eisen wie Aluminium, Kupfer, Messing, Gold und Silber induziert das Feld Wirbelströme; diese erzeugen ein Gegenfeld, die wirksame Induktivität der Spule sinkt und die Oszillatorfrequenz steigt. Magnetische Metalle wie Eisen und Stahl bündeln dagegen die Feldlinien; bei niedrigen Frequenzen überwiegt dieser Effekt, die Induktivität steigt und die Frequenz sinkt. Die Richtung der Verschiebung verrät also auch, ob das Metall Eisen ist oder nicht.

Der Effekt nimmt mit der Entfernung sehr schnell ab. Bei einem kleinen Gegenstand in einigem Abstand zur Spule fällt die Frequenzverschiebung ungefähr mit der sechsten Potenz der Entfernung: Doppelt so weit weg, und das Signal sinkt auf etwa 1/64. Deshalb bestimmt bei einem selbst gebauten Detektor nicht der Code die Suchtiefe, sondern die Spulengröße und die Stabilität des Oszillators. Diese drei Grundverfahren nutzen Detektoren:

VerfahrenFunktionsweiseTiefeErkennt EisenBodeneffektSchwierigkeit
Frequenzverschiebung (BFO-Typ)Misst die Frequenzänderung eines Oszillators mit einer SpuleGeringJa (an der Richtung der Verschiebung)Deutlich bei mineralisiertem BodenEinfach, das Verfahren dieser Anleitung
VLF (Induktionsbalance)Getrennte Sende- und Empfangsspule, misst die PhasenverschiebungMittel bis gutSehr gutBodenabgleich möglichMittel bis schwer
Pulsinduktion (PI)Schickt kurze Pulse in die Spule und misst, wie lange das Signal nach dem Abschalten abklingtAm bestenKaumGut selbst bei mineralisiertem Boden und StrandsandSchwer

Bei Pulsinduktionsdetektoren erzeugt die Spule nach jedem Puls eine Rückschlagspannung von mehreren hundert Volt; die muss sicher bedämpft, innerhalb von Mikrosekunden abgetastet und mit einem schnellen Komparator oder Operationsverstärker ausgewertet werden. Für ein erstes Projekt ist das riskant und schwer zu debuggen. Darum nutzen wir hier die Frequenzverschiebung: eine Spule, ein IC, niedrige Spannung und eine Aufgabe, die der Arduino ohnehin gut kann, nämlich Pulse zählen.

Das brauchst du

  • Einen Arduino Uno (oder ein ESP32-Entwicklungsboard).
  • Einen Sechsfach-Inverter 74HCU04 oder CD4069UB. Die ungepufferten Varianten (mit dem U) laufen im Oszillator stabiler; ein 74HC04 funktioniert meist auch.
  • 2 Folienkondensatoren mit 10 nF (Polyester oder Polypropylen). Keramische X7R-Kondensatoren ändern sich stark mit der Temperatur und lassen die Frequenz wandern.
  • Widerstände mit 1 MΩ, 470 Ω und 220 Ω und einen 100-nF-Abblockkondensator.
  • 0,4 mm Kupferlackdraht, etwa 30 m (für eine Spule mit 15 cm Durchmesser und 60 Windungen).
  • Einen passiven Summer, eine LED und einen Taster.
  • Einen Rahmen aus Kunststoff oder Holz für die Spule, ein zweiadriges Kabel und auf Wunsch Alufolie und Isolierband.
Summer
Die Stimme des Detektors: Der passive Summer spielt mit tone() verschiedene Frequenzen, so hörst du bei Eisen einen tiefen und bei anderen Metallen einen hohen Ton.

Die Suchspule wickeln

  1. Such dir eine Form mit etwa 15 cm Durchmesser: ein Eimerdeckel aus Kunststoff, eine Papprolle oder im Kreis in ein Brett geschlagene Nägel eignen sich.
  2. Wickle 60 straffe, gleichmäßige Windungen Kupferlackdraht um die Form und lass an beiden Enden 15–20 cm Draht überstehen.
  3. Bevor du die Wicklung abnimmst, umwickle sie alle 3–4 cm fest mit Isolierband; bewegen sich die Drähte gegeneinander, ändert sich die Induktivität und der Detektor piept von selbst.
  4. Entferne den Lack an den Drahtenden mit Schleifpapier oder einem Feuerzeug und miss den Widerstand mit dem Multimeter: Bei 15 cm und 60 Windungen solltest du etwa 3–5 Ω sehen.
  5. Wenn du willst, umwickle die Spule mit Band und dann mit Alufolie, lass aber zwischen den beiden Folienenden 1 cm Lücke; leg einen blanken Draht an die Folie und führ ihn zur Masse (GND) der Schaltung.
  6. Befestige die Spule an einem Stiel ohne Metallteile, verdrille das zweiadrige Kabel und klebe es am Stiel fest.
In der Nähe der Spule darf kein Metall sein: Schrauben, Nieten, Metallschellen oder ein Alurohr lassen den Detektor ständig „Metall“ melden. Nimm Kunststoffschrauben, Heißkleber und Holz. Verbinde niemals die Enden der Folienabschirmung; eine geschlossene Schleife wirkt wie ein riesiger Metallgegenstand und schluckt das Feld der Spule.

Windungszahl und Empfindlichkeit: die Tabelle

Die Oszillatorfrequenz ergibt sich aus f = 1 / (2π√(L·C)). In unserer Schaltung wirken die beiden 10-nF-Kondensatoren wie in Reihe geschaltet, also C = 10 × 10 / (10 + 10) = 5 nF. Die Induktivität einer runden Luftspule wächst ungefähr mit dem Quadrat der Windungszahl und mit dem Durchmesser. Die Tabelle zeigt berechnete Werte für Spulen aus 0,4-mm-Draht und grobe Erkennungsabstände auf trockenem Boden:

SpulendurchmesserWindungenInduktivität (ca.)Frequenz (C = 5 nF)MünzeGetränkedoseHinweis
10 cm40350 µH120 kHz3–5 cm8–12 cmEmpfindlich für Kleinteile; Frequenz für den ESP32 hoch
10 cm60750 µH82 kHz3–5 cm8–12 cmKompakter Handdetektor
15 cm40600 µH93 kHz4–7 cm12–18 cmWenig Draht, guter Einstieg
15 cm601,25 mH63 kHz4–7 cm12–18 cmDie Spule dieser Anleitung; passt für Uno und ESP32
20 cm30500 µH100 kHz4–7 cm15–22 cmTiefer bei großen Gegenständen
20 cm501,3 mH63 kHz4–7 cm15–22 cmSchwer, deckt aber eine breite Fläche ab

Aus der Tabelle folgen zwei Lehren. Erstens ändert die Windungszahl die Tiefe kaum; sie legt vor allem die Frequenz fest. Weniger Windungen bedeuten eine höhere Frequenz, und die ist für kleine Nichteisenmetalle etwas empfindlicher. Zweitens erkennt eine große Spule große Gegenstände aus größerer Entfernung, gewinnt bei kleinen wie einer Münze aber wenig, weil ein kleiner Gegenstand nur einen winzigen Teil ihres Feldes stört. 15 cm und 60 Windungen sind ein ausgewogener Start. Spulen und Induktivitätsberechnung erklären wir ausführlich im Artikel Was ist eine Spule?, und beim Entschlüsseln fertiger Induktivitäten hilft das Tool für Spulencodes.

Die Schaltung: LC-Oszillator und Anschlüsse

Als Oszillator dient das erste Invertergatter des ICs. Der 1-MΩ-Rückkopplungswiderstand hält das Gatter im linearen Bereich, und die Spule bildet mit den beiden Kondensatoren ein π-Glied. Bei der Resonanzfrequenz dreht dieses Netzwerk das Signal um 180 Grad; zusammen mit den 180 Grad des Inverters schwingt die Schaltung genau bei dieser Frequenz. Das zweite Gatter formt das fast sinusförmige Signal zu einem sauberen 0–5-V-Rechteck und gibt es an den Arduino weiter.

AnschlussWohin?Hinweis
74HCU04 Pin 14 (VCC)5V100-nF-Kondensator direkt am Pin nach GND
74HCU04 Pin 7 (GND)GNDGemeinsame Masse mit dem Arduino
Pin 1 (Eingang 1. Inverter)Spulenende A, C1 (10 nF) nach GND, 1 MΩ zu Pin 2Oszillatoreingang
Pin 2 (Ausgang 1. Inverter)Über 470 Ω zu Punkt B und direkt zu Pin 3Oszillatorausgang
Punkt BSpulenende B, C2 (10 nF) nach GNDZweiter Zweig des π-Glieds
Pin 4 (Ausgang 2. Inverter)Uno: D5; ESP32: über 10 kΩ an GPIO 34, von GPIO 34 mit 20 kΩ nach GND0–5-V-Rechtecksignal
Pins 5, 9, 11, 13GNDUnbenutzte Eingänge nie offen lassen
Passiver SummerUno: D8, ESP32: GPIO 25; anderes Ende an GNDTon mit tone()
LEDUno: D13, ESP32: GPIO 2; über 220 ΩAnzeige bei Fund
Nullstell-TasterUno: zwischen D2 und GND; ESP32: BOOT-Taste auf dem Board (GPIO 0)Misst die Basis neu
Teste den Oszillator, bevor du Code hochlädst: Hat dein Multimeter einen Frequenzbereich, miss an Pin 4; mit der 15-cm-Spule und 60 Windungen solltest du etwa 55–70 kHz sehen. Zeigt es 0 an, prüf zuerst, ob die unbenutzten Eingänge an GND liegen, der Lack an den Spulenenden entfernt ist und der 1-MΩ-Widerstand sitzt.

Code für den Arduino Uno: Frequenz zählen und Ton ausgeben

Der 16-Bit-Timer1 des Uno kann die Pulse an Pin D5 direkt in Hardware zählen, der Prozessor muss sich also nicht um jeden einzelnen kümmern. Der Code zählt 200 ms lang, multipliziert das Ergebnis mit 5, um auf Hertz zu kommen, und vergleicht es mit der Basisfrequenz, die ohne Metall gemessen wurde. Ist die Frequenz gesunken, ertönt ein tiefer Ton, ist sie gestiegen, ein hoher, und je größer die Abweichung, desto höher der Ton.

C++ (Arduino IDE)
1// Arduino Uno metal dedektörü (frekans kayması yöntemi)
2// Arduino Uno metal detector (frequency-shift method)
3// Osilatör çıkışı D5'e: Timer1 bu pindeki darbeleri sayar / oscillator output to D5: Timer1 counts its pulses
4
5const byte BUZZER_PIN = 8;          // pasif buzzer / passive buzzer
6const byte LED_PIN = 13;            // algılama LED'i / detection LED
7const byte ZERO_PIN = 2;            // sıfırlama butonu, GND'ye / re-zero button to GND
8const unsigned int GATE_MS = 200;   // ölçüm penceresi / gate time
9const float THRESHOLD_HZ = 15.0;    // bu kadar sapma metal demek / this much shift means metal
10
11float baseline = 0;                 // metal yokken frekans / frequency with no metal nearby
12float smoothDiff = 0;               // yumuşatılmış fark / smoothed difference
13
14// GATE_MS boyunca D5'teki yükselen kenarları sayar / counts rising edges on D5 during GATE_MS
15unsigned long countPulses() {
16  TCCR1A = 0;
17  TCCR1B = 0;
18  TCNT1 = 0;
19  TIFR1 = _BV(TOV1);                                // taşma bayrağını temizle / clear the overflow flag
20  TCCR1B = _BV(CS12) | _BV(CS11) | _BV(CS10);       // saat kaynağı T1, yükselen kenar / clock from T1, rising edge
21  delay(GATE_MS);
22  TCCR1B = 0;                                       // sayacı durdur / stop the counter
23  unsigned long n = TCNT1;
24  if (TIFR1 & _BV(TOV1)) n += 65536UL;              // bir taşma olduysa ekle / add one overflow
25  return n;
26}
27
28float readFrequency() {
29  return countPulses() * (1000.0 / GATE_MS);        // Hz
30}
31
32void calibrate() {
33  noTone(BUZZER_PIN);
34  digitalWrite(LED_PIN, HIGH);
35  float sum = 0;
36  for (int i = 0; i < 8; i++) sum += readFrequency();  // 8 ölçümün ortalaması / average of 8 readings
37  baseline = sum / 8;
38  smoothDiff = 0;
39  digitalWrite(LED_PIN, LOW);
40  Serial.print(F("Taban frekans / Baseline (Hz): "));
41  Serial.println(baseline);
42}
43
44void setup() {
45  Serial.begin(115200);
46  pinMode(5, INPUT);                                // T1 girişi / T1 input
47  pinMode(BUZZER_PIN, OUTPUT);
48  pinMode(LED_PIN, OUTPUT);
49  pinMode(ZERO_PIN, INPUT_PULLUP);
50  delay(500);                                       // osilatör otursun / let the oscillator settle
51  calibrate();
52}
53
54void loop() {
55  if (digitalRead(ZERO_PIN) == LOW) calibrate();    // butona basınca sıfırla / re-zero on button press
56
57  float f = readFrequency();
58  float diff = f - baseline;
59  smoothDiff = smoothDiff * 0.6 + diff * 0.4;       // gürültüyü azalt / reduce noise
60
61  Serial.print(F("diff:"));                         // Seri Çizici için / for the Serial Plotter
62  Serial.println(smoothDiff);
63
64  float strength = fabs(smoothDiff);
65  if (strength > THRESHOLD_HZ) {
66    digitalWrite(LED_PIN, HIGH);
67    if (smoothDiff < 0) {
68      tone(BUZZER_PIN, constrain(200 + strength * 4, 200, 800));       // frekans düştü: demir, kalın ses / frequency fell: iron, low tone
69    } else {
70      tone(BUZZER_PIN, constrain(1000 + strength * 10, 1000, 3000));   // frekans arttı: demir dışı, ince ses / frequency rose: non-ferrous, high tone
71    }
72  } else {
73    digitalWrite(LED_PIN, LOW);
74    noTone(BUZZER_PIN);
75    baseline += diff * 0.02;                        // yavaş sıcaklık kaymasını izle / follow slow temperature drift
76  }
77}
CodeteilAufgabeZum Anpassen
countPulses()Macht Timer1 zu einem Zähler mit Takt von D5 und zählt 200 ms langEin längeres Fenster ist genauer, aber träger
GATE_MS = 200Bei 63 kHz etwa 12.600 Pulse pro Fenster; ein Puls entspricht 5 HzMit 500 ms beträgt die Auflösung 2 Hz
calibrate()Nimmt den Mittelwert aus 8 Messungen ohne Metall als BasisBeim Einschalten die Spule von Metall fernhalten
smoothDiffGlättet das Rauschen durch Gewichtung der letzten MessungenGrößerer Faktor als 0,6: ruhiger, aber langsamer
THRESHOLD_HZ = 15Alles unter dieser Abweichung gilt als RauschenAuf das 2- bis 3-Fache des Rauschens im seriellen Plotter setzen
baseline += diff * 0.02Zieht die Basis ohne Metall langsam auf den echten WertZu groß gewählt, „vergisst“ sie auch langsam näherkommendes Metall

Öffne nach dem Hochladen über das Menü Werkzeuge den seriellen Plotter mit 115200 Baud. Ohne Metall pendelt die Linie ein paar Hertz um null; hältst du einen Schlüsselbund an die Spule, springt sie nach oben oder unten. Da Timer1 jetzt als Zähler arbeitet, funktioniert analogWrite an D9 und D10 nicht mehr; tone() nutzt Timer2, das passt also. Warum ein passiver Summer tone() braucht, steht im Artikel Was ist ein Summer?.

Kalibrierung und Bodeneffekt

Der größte Feind dieses Detektortyps ist nicht das Metall, sondern die Drift. In den ersten 5–10 Minuten nach dem Einschalten erwärmen sich IC, Kondensatoren und Spule, und die Frequenz kann um einige zehn Hertz pro Minute wandern. Folienkondensatoren, eine fest umwickelte Spule und die langsame Basisnachführung im Code beseitigen den Großteil davon. Den Rest erledigt die Kalibrierung:

  1. Schalte den Detektor mindestens 1 m entfernt von Metalltischen, Handy und Gürtelschnalle ein und lass ihn 2–3 Minuten warmlaufen.
  2. Drück den Nullstell-Taster; die LED leuchtet kurz und die Basisfrequenz erscheint im seriellen Monitor.
  3. Schau im seriellen Plotter, wie stark das Rauschen von Spitze zu Spitze schwankt, und setz THRESHOLD_HZ auf das 2- bis 3-Fache.
  4. Halte eine Münze in 2, 4, 6 und 8 cm Abstand mittig vor die Spule und notiere jeweils die Abweichung; das ist die echte Reichweite deines Detektors.
  5. Im Gelände hältst du die Spule 3–5 cm über dem Boden, stellst erneut auf null und suchst dann langsam und immer in derselben Höhe.
Boden oder UmgebungWirkungWas tun?
Roter, eisenoxidhaltiger BodenSenkt die Frequenz, wirkt wie EisenIn Suchhöhe auf null stellen und die Höhe nicht mehr ändern
Nasser, salziger Sand (Strand)Leitfähig, hebt die FrequenzIm trockenen Sand suchen; hier sind Pulsinduktionsdetektoren deutlich besser
StahlbetonwandDie Bewehrung gibt überall SignalBei der Nagelsuche die Spule parallel und im festen Abstand zur Wand führen
Temperaturänderungen (Sonne, Handkontakt)Die Basis wandert langsamSpule im Schatten halten, die Hand am Stiel weg von der Spule
Netzteile, LED-Lampen, MotorenElektrisches Rauschen, zufälliges PiepenMit Akkus betreiben und Abstand zur Störquelle halten
Wackelnde SpuleBewegte Drähte erzeugen FehlsignaleWicklung festkleben und Kabel am Stiel fixieren

Code für den ESP32

Der ESP32 hat keinen Timer1 mit externem Takt wie der Uno, daher wählen wir den einfachsten Weg, der mit jeder Core-Version läuft: Bei jeder steigenden Flanke wird eine kurze Interrupt-Routine aufgerufen, die einen Zähler um eins erhöht. Bei 63 kHz sind das 63.000 Interrupts pro Sekunde; ein ESP32 mit 240 MHz schafft das locker, die Frequenz sollte aber unter 100 kHz bleiben. Weil die Eingänge des ESP32 nicht 5-V-tolerant sind, teilen wir den Oszillatorausgang mit einem Spannungsteiler aus 10 kΩ und 20 kΩ auf 3,3 V herunter. Einen zusätzlichen Nullstell-Taster brauchst du nicht: Die BOOT-Taste auf dem Board liegt an GPIO 0.

C++ (Arduino IDE)
1// ESP32 metal dedektörü: kesmeyle darbe sayma / ESP32 metal detector: counting pulses with an interrupt
2const int SIGNAL_PIN = 34;          // 10k/20k bölücü üzerinden / through a 10k/20k divider
3const int BUZZER_PIN = 25;          // pasif buzzer / passive buzzer
4const int LED_PIN = 2;              // çoğu kartta dahili LED / onboard LED on most boards
5const int ZERO_PIN = 0;             // kart üzerindeki BOOT butonu / the BOOT button on the board
6const unsigned int GATE_MS = 200;
7const float THRESHOLD_HZ = 15.0;
8
9volatile uint32_t pulseCount = 0;
10float baseline = 0;
11float smoothDiff = 0;
12
13void IRAM_ATTR onPulse() {
14  pulseCount++;                     // her yükselen kenarda bir / one per rising edge
15}
16
17float readFrequency() {
18  uint32_t start = pulseCount;
19  delay(GATE_MS);
20  return (pulseCount - start) * (1000.0 / GATE_MS);   // Hz
21}
22
23void calibrate() {
24  noTone(BUZZER_PIN);
25  digitalWrite(LED_PIN, HIGH);
26  float sum = 0;
27  for (int i = 0; i < 8; i++) sum += readFrequency();
28  baseline = sum / 8;
29  smoothDiff = 0;
30  digitalWrite(LED_PIN, LOW);
31  Serial.printf("Taban frekans / Baseline: %.1f Hz\n", baseline);
32}
33
34void setup() {
35  Serial.begin(115200);
36  pinMode(SIGNAL_PIN, INPUT);
37  pinMode(LED_PIN, OUTPUT);
38  pinMode(ZERO_PIN, INPUT_PULLUP);
39  attachInterrupt(digitalPinToInterrupt(SIGNAL_PIN), onPulse, RISING);
40  delay(500);
41  calibrate();
42}
43
44void loop() {
45  if (digitalRead(ZERO_PIN) == LOW) calibrate();     // BOOT'a basınca sıfırla / re-zero with BOOT
46
47  float diff = readFrequency() - baseline;
48  smoothDiff = smoothDiff * 0.6 + diff * 0.4;
49  Serial.printf("diff:%.1f\n", smoothDiff);          // Seri Çizici için / for the Serial Plotter
50
51  float strength = fabs(smoothDiff);
52  if (strength > THRESHOLD_HZ) {
53    digitalWrite(LED_PIN, HIGH);
54    if (smoothDiff < 0) tone(BUZZER_PIN, constrain(200 + strength * 4, 200, 800));       // demir / iron
55    else tone(BUZZER_PIN, constrain(1000 + strength * 10, 1000, 3000));                   // demir dışı / non-ferrous
56  } else {
57    digitalWrite(LED_PIN, LOW);
58    noTone(BUZZER_PIN);
59    baseline += diff * 0.02;                         // yavaş kaymayı izle / follow slow drift
60  }
61}

Die Logik entspricht der Uno-Version; nur die Art, wie Pulse gezählt werden, ist anders. IRAM_ATTR legt die Interrupt-Routine in den schnellen internen Speicher, und volatile sagt dem Compiler, dass sich pulseCount jederzeit ändern kann. Für höhere Frequenzen gibt es den Hardware-Pulszähler (PCNT) des ESP32, dessen Treiber sich aber zwischen den Core-Versionen 2.x und 3.x geändert hat; für den Anfang macht die Interrupt-Methode weniger Ärger. Das eigentliche Plus des ESP32 ist das WLAN: Du kannst die Abweichung als Live-Grafik auf eine Webseite im Handy schicken, mit dem Aufbau aus dem Artikel ESP32-Webserver und WebSocket.

Unterscheidung: Eisen oder anderes Metall?

Die Richtung der Frequenzverschiebung gibt dir einen Hinweis auf die Art des Gegenstands. Aber Vorsicht: Ein großer, naher Nichteisen-Gegenstand und ein kleines, entferntes Eisenteil können ähnlich starke Signale liefern; die Richtung hilft, die Stärke allein täuscht. Die Tabelle zeigt, wie sich typische Gegenstände bei der Frequenzverschiebung verhalten:

GegenstandFrequenzTonHinweis
Eisennagel, Schraube, KronkorkenSinktTiefSogar Rost kann das Signal verstärken
1-, 2- und 5-Cent-Münzen und andere plattierte StahlmünzenSinktTiefStahl mit Kupferüberzug, haften am Magneten
Alu-Dose oder AlufolieSteigtHochStarkes Signal wegen der großen Fläche
Kupferkabel, MessingschlüsselSteigtHochHohe Leitfähigkeit, gut erkennbar
GoldringSteigtHochSchwach, weil klein; direkt unter der Spule suchen
Gabel aus EdelstahlSteigt leichtHoch, schwachDie meisten Edelstähle sind nicht magnetisch und leiten schlecht

Häufige Probleme und Lösungen

SymptomMögliche UrsacheLösung
Serieller Monitor zeigt 0 HzDer Oszillator schwingt nichtUnbenutzte Eingänge an GND, Spulenenden ablacken, 1 MΩ prüfen
Frequenz ist da, aber es piept ständigBasis in Metallnähe gemessen oder Schwelle zu niedrigFern von Metall nullen und THRESHOLD_HZ erhöhen
Erkennt überhaupt kein MetallSchwelle zu hoch oder Spule zu groß für ein winziges ObjektAbweichung im seriellen Plotter ansehen, Schwelle senken, kleinere Spule testen
Fängt langsam von selbst an zu piepenDrift durch Erwärmung, X7R-KeramikkondensatorFolienkondensatoren nehmen und nach 5 Minuten Aufwärmzeit nullen
Berührung der Spule erzeugt ein SignalKapazitiver Einfluss der HandFolienabschirmung an GND ergänzen, Spule am Stiel halten
Am ESP32 unsinnige Werte5-V-Signal direkt am Eingang oder Frequenz zu hoch10k/20k-Teiler prüfen und Frequenz unter 100 kHz bringen
Bevor du mit einem Metalldetektor auf Suche gehst, informiere dich über die Regeln vor Ort. In vielen Ländern und Bundesländern ist das Suchen ohne Genehmigung in Bodendenkmälern, Ruinen und Schutzgebieten verboten, und historische Funde müssen den Behörden gemeldet werden. Auf Privatgrund fragst du immer vorher den Eigentümer und schließt gegrabene Löcher wieder.

Ideen zum Ausbau des Detektors

  • Anzeige mit Display: Zeig die Abweichung als Balken auf einem OLED-Display und die Basisfrequenz in einer Ecke.
  • Akkubetriebene Version: Bau mit einer 18650-Zelle und einem TP4056-Lademodul einen kabellosen Handdetektor.
  • Vibrationsalarm: Nimm in lauter Umgebung statt des Summers einen Vibrationsmotor.
  • Wandscanner: Such mit einer kleinen 5-cm-Spule Nägel und Rohre in der Wand und beobachte, wie sich das Signal beim Drehen ändert.
  • Münzsortierer: Miss die Abweichung von Münzen, die eine Rampe hinunterrutschen, und trenne Stahl- von Kupfermünzen.
  • Vergleich mit einem Magnetsensor: Ein Hall-Sensor sieht nur Magnete und Magnetfelder; probier beide Sensoren nebeneinander aus und vergleiche.
Die wirksamste Methode, die Reichweite zu erhöhen, ist nicht der Code, sondern bessere Stabilität. Halbiert sich das Rauschen, kannst du die Schwelle halbieren, und der Detektor hört denselben Gegenstand aus größerer Entfernung. Folienkondensatoren, eine fest umwickelte Spule, ein fixiertes Kabel und Akkubetrieb machen dabei den größten Unterschied.

Ein Metalldetektor gehört zu den seltenen Projekten, die anschaulich zeigen, wie Spulen, Resonanz und Wirbelströme funktionieren. Willst du vorher an einer einfacheren Schaltung üben, einen Summer anzusteuern oder abhängig von der Entfernung zu warnen, findest du in der BlueGrays-App Schritt für Schritt, mit Schaltplan und Code, die Projekte Summer verwenden, Summerfrequenz einstellen, Einparkhilfe mit HC-SR04 und Türsensor mit Reedkontakt.

Häufige Fragen

Wie tief erkennt ein Metalldetektor mit Arduino?

Mit der Frequenzverschiebung aus dieser Anleitung erkennt eine 15-cm-Spule eine Münze auf etwa 4–7 cm, eine Getränkedose auf 12–18 cm und einen großen Metalldeckel auf 20–30 cm. Weil das Signal mit der Entfernung sehr schnell abnimmt, hängt die Tiefe vor allem von der Spulengröße und der Stabilität des Oszillators ab.

Wie viele Windungen braucht die Spule eines Metalldetektors?

Für eine Spule mit 15 cm Durchmesser aus 0,4-mm-Draht sind 40 bis 60 Windungen ein guter Startpunkt; mit 5 nF ergibt das 60–95 kHz. Die Windungszahl ändert die Tiefe kaum, sie legt vor allem die Frequenz fest. Nutzt du den ESP32 mit Interrupts, wickle so viele Windungen, dass du unter 100 kHz bleibst.

Kann ein selbst gebauter Metalldetektor Gold von Eisen unterscheiden?

Teilweise. Eisen und Stahl erhöhen die Induktivität und senken die Frequenz, Gold, Silber, Kupfer und Aluminium heben sie an; der Code trennt das mit einem tiefen und einem hohen Ton. Einen kleinen Goldring von einem Stück Alufolie kann diese einfache Methode aber nicht unterscheiden; dafür braucht es die Phasenmessung von VLF-Detektoren.

Kann man einen Pulsinduktions-Metalldetektor (PI) mit Arduino bauen?

Ja, aber das Projekt ist deutlich anspruchsvoller. Du musst die Spule über einen MOSFET pulsen, die beim Abschalten entstehenden Hunderte Volt sicher bedämpfen und die Abklingzeit auf Mikrosekunden genau messen. Dafür bekommst du auf mineralisiertem Boden und nassem Sand einen viel tieferen und stabileren Detektor.

Warum piept mein Metalldetektor von selbst?

Meist ist es Temperaturdrift: In den ersten Minuten erwärmen sich IC, Kondensatoren und Spule, und die Frequenz wandert. Nimm Folienkondensatoren, umwickle die Spule fest, warte ein paar Minuten und stell erneut auf null. Auch ein bewegliches Kabel, eine lose Wicklung und Störungen von Netzteilen in der Nähe erzeugen Fehlsignale.

Welcher Kondensator eignet sich für einen Metalldetektor?

Am besten sind Folienkondensatoren aus Polyester oder Polypropylen, weil sich ihr Wert mit der Temperatur kaum ändert. Keramische X7R- oder Y5V-Kondensatoren driften beim Erwärmen um einige Prozent und verschieben die Frequenz, als käme Metall näher. Wenn es Keramik sein muss, nimm den Typ C0G (NP0).

Alle Projekte ansehen
Verwendung des Summers
AR-13Anfänger

Verwendung des Summers

Hast du dich mal gefragt, wie eine Türklingel oder ein Alarm seinen Ton erzeugt? Der Arduino lässt einen kleinen Summer in kurzen Abständen piepen: piep, Pause, piep, Pause.

4.7(92)
171
Frequenzeinstellung mit Buzzer
AR-14Mittel

Frequenzeinstellung mit Buzzer

Mit vier Knöpfen steuerst du den Ton eines Summers: Einer startet den Ton, einer macht ihn stumm, die anderen beiden machen ihn höher oder tiefer.

4.6(69)
120
Parksensor mit HC-SR04
AR-28Mittel
Premium

Parksensor mit HC-SR04

Eine Mini-Ausgabe der Einparkhilfe im Auto: Je näher etwas kommt, desto schneller piept es.

4.8(64)
86
Reedschalter auslesen
AR-37Anfänger

Reedschalter auslesen

Hast du dich schon mal gefragt, wie der Magnetschalter in Tür- und Fensteralarmen funktioniert?

4.5(22)
29
Türsensor mit Reedschalter
AR-38Anfänger
Premium

Türsensor mit Reedschalter

Erkenne an einem Licht, ob deine Tür offen oder zu ist. An der Tür befestigst du einen kleinen Magneten, am Rahmen einen Schalter, der Magnete spürt; ist die Tür zu, liegen beide nebeneinander und…

4.7(34)
44
ESP32-Parksensor (HC-SR04 + 5-LED-Leiste + Summer + OLED)
ES-38Fortgeschritten
Premium

ESP32-Parksensor (HC-SR04 + 5-LED-Leiste + Summer + OLED)

Die ESP32-Version einer Einparkhilfe! Der Ultraschallsensor HC-SR04 misst den Abstand zum Objekt davor. Je näher es kommt, desto weiter füllt sich eine Leiste aus 5 LEDs (grün → gelb → rot) und desto schneller piept der Summer. Ganz nah (unter 10 cm) ertönt ein Daueralarm und alle LEDs leuchten. Das SSD1306-OLED zeigt den aktuellen Abstand in cm groß an, dazu einen Statustext.

14
LED Blinken mit ESP32
ES-1Anfänger

LED Blinken mit ESP32

Lehrt die grundlegende Verwendung von GPIO-Ausgängen mit ESP32. Wir erreichen einen Blinkeffekt, indem wir eine LED über einen digitalen Pin ein- und ausschalten. ESP32-Version des klassischen Blink-Projekts auf Arduino UNO; die grundlegenden Blink-Befehle in der Arduino-Umgebung bleiben gleich, aber die Pinbelegung und die GPIO-Pegel von 3,3 V des ESP32 unterscheiden sich von denen des Arduino UNO.

4.7(37)
108