Metal detector con Arduino: bobina, oscillatore LC e codice
Metal detector con Arduino: avvolgere la bobina, oscillatore LC, misura della frequenza, cicalino, tabella delle spire, effetto del suolo, codice Uno ed ESP32.
Un metal detector con Arduino si costruisce in un pomeriggio con una bobina di ricerca, un integrato economico e pochi componenti passivi, e insegna moltissimo. La bobina fa parte di un oscillatore LC; quando un metallo si avvicina, la sua induttanza cambia, la frequenza dell'oscillatore si sposta e Arduino misura questo spostamento e lo trasforma in suono con un cicalino. Un rilevatore così sente una moneta a pochi centimetri, una lattina a 10–15 cm e un grande coperchio metallico a 20–30 cm. Non compete con un apparecchio commerciale, ma basta per trovare un chiodo nel muro, le chiavi nella sabbia o un attrezzo perso in giardino.
In questa guida vediamo prima come funziona un metal detector e confrontiamo i tre metodi di base: spostamento di frequenza, VLF e induzione a impulsi. Poi avvolgeremo la bobina di ricerca, vedremo in una tabella come il numero di spire influisce sulla sensibilità, monteremo l'oscillatore LC e scriveremo il codice per Arduino Uno ed ESP32. Le ultime sezioni parlano di taratura, effetto del suolo, distinzione tra ferro e altri metalli e problemi più comuni.
Come funziona un metal detector?
Una bobina percorsa da corrente alternata crea intorno a sé un campo magnetico che cambia continuamente verso. Quando un oggetto metallico entra in questo campo possono succedere due cose. Nei metalli senza ferro, come alluminio, rame, ottone, oro e argento, il campo induce correnti parassite (di Foucault); queste correnti generano un campo opposto, l'induttanza effettiva della bobina diminuisce e la frequenza dell'oscillatore sale. I metalli magnetici come ferro e acciaio invece concentrano le linee di campo; alle basse frequenze questo effetto prevale, l'induttanza aumenta e la frequenza scende. Quindi il verso dello spostamento ti dice anche se il metallo è ferro oppure no.
L'effetto si indebolisce molto in fretta con la distanza. Per un oggetto piccolo a una certa distanza dalla bobina, lo spostamento di frequenza cala all'incirca con la sesta potenza della distanza: allontana l'oggetto del doppio e il segnale scende a circa 1/64. Ecco perché in un rilevatore fatto in casa la profondità non dipende dal codice, ma dalle dimensioni della bobina e dalla stabilità dell'oscillatore. Questi sono i tre metodi di base usati dai metal detector:
| Metodo | Come funziona | Profondità | Riconosce il ferro | Effetto del suolo | Difficoltà |
|---|---|---|---|---|---|
| Spostamento di frequenza (tipo BFO) | Misura la variazione di frequenza di un oscillatore a bobina singola | Bassa | Sì (dal verso dello spostamento) | Evidente su terreno mineralizzato | Facile, il metodo di questa guida |
| VLF (bilanciamento a induzione) | Bobine di trasmissione e ricezione separate, misura lo sfasamento | Media o buona | Molto bene | Bilanciamento del suolo possibile | Media o difficile |
| Induzione a impulsi (PI) | Invia brevi impulsi alla bobina e misura quanto dura lo smorzamento dopo lo spegnimento | La migliore | Poco | Buono anche su terreno mineralizzato e sabbia di mare | Difficile |
Nei rilevatori a induzione a impulsi la bobina produce, dopo ogni impulso, una sovratensione di centinaia di volt; va smorzata in sicurezza, campionata in pochi microsecondi ed elaborata con un comparatore o un amplificatore operazionale veloce. Per un primo progetto è rischioso e difficile da mettere a punto. Per questo qui usiamo lo spostamento di frequenza: una bobina, un integrato, bassa tensione e un lavoro che Arduino sa già fare bene, contare impulsi.
Cosa ti serve
- Un Arduino Uno (o una scheda di sviluppo ESP32).
- Un integrato a sei invertitori 74HCU04 o CD4069UB. Le versioni senza buffer (con la U) sono più stabili in un oscillatore; anche un 74HC04 di solito funziona.
- 2 condensatori a film da 10 nF (poliestere o polipropilene). I condensatori ceramici X7R cambiano molto con la temperatura e fanno slittare la frequenza.
- Resistenze da 1 MΩ, 470 Ω e 220 Ω e un condensatore di disaccoppiamento da 100 nF.
- Filo di rame smaltato da 0,4 mm, circa 30 m (per una bobina da 15 cm e 60 spire).
- Un cicalino passivo (buzzer), un LED e un pulsante.
- Un telaio in plastica o legno per la bobina, un cavo a due fili e, se vuoi, carta stagnola e nastro isolante.

Avvolgere la bobina di ricerca
- Trova una forma di circa 15 cm di diametro: va bene il coperchio di un secchio di plastica, un tubo di cartone o dei chiodi piantati in cerchio su una tavola.
- Avvolgi intorno alla forma 60 spire strette e regolari di filo smaltato e lascia 15–20 cm di filo a ogni estremità.
- Prima di togliere l'avvolgimento dalla forma, fascialo bene con nastro isolante ogni 3–4 cm; se i fili si muovono tra loro, l'induttanza cambia e il rilevatore suona da solo.
- Togli lo smalto dalle estremità con carta vetrata o un accendino e misura la resistenza con il multimetro: una bobina da 15 cm e 60 spire deve dare circa 3–5 Ω.
- Se vuoi, copri l'avvolgimento con nastro e poi con carta stagnola, lasciando 1 cm di spazio tra le due estremità della stagnola; appoggia un filo spellato sulla stagnola e collegalo al GND del circuito.
- Fissa la bobina a un manico senza parti metalliche, attorciglia il cavo a due fili e fissalo al manico con il nastro.
Tabella delle spire e della sensibilità
La frequenza dell'oscillatore si calcola con f = 1 / (2π√(L·C)). Nel nostro circuito i due condensatori da 10 nF si comportano come se fossero in serie, quindi C = 10 × 10 / (10 + 10) = 5 nF. L'induttanza di una bobina in aria circolare cresce più o meno con il quadrato del numero di spire e con il diametro. La tabella riporta i valori calcolati per bobine in filo da 0,4 mm e le distanze di rilevamento approssimative su terreno asciutto:
| Diametro | Spire | Induttanza (circa) | Frequenza (C = 5 nF) | Moneta | Lattina | Nota |
|---|---|---|---|---|---|---|
| 10 cm | 40 | 350 µH | 120 kHz | 3–5 cm | 8–12 cm | Sensibile agli oggetti piccoli; frequenza alta per l'ESP32 |
| 10 cm | 60 | 750 µH | 82 kHz | 3–5 cm | 8–12 cm | Rilevatore a mano compatto |
| 15 cm | 40 | 600 µH | 93 kHz | 4–7 cm | 12–18 cm | Poco filo, buon inizio |
| 15 cm | 60 | 1,25 mH | 63 kHz | 4–7 cm | 12–18 cm | La bobina di questa guida; adatta a Uno ed ESP32 |
| 20 cm | 30 | 500 µH | 100 kHz | 4–7 cm | 15–22 cm | Più profonda con gli oggetti grandi |
| 20 cm | 50 | 1,3 mH | 63 kHz | 4–7 cm | 15–22 cm | Pesante, ma copre un'area ampia |
Dalla tabella escono due lezioni. Primo: il numero di spire cambia poco la profondità; serve soprattutto a fissare la frequenza. Meno spire vuol dire frequenza più alta, un po' più sensibile ai piccoli oggetti non ferrosi. Secondo: una bobina grande vede gli oggetti grandi da più lontano, ma guadagna poco con quelli piccoli come una moneta, perché un oggetto piccolo disturba solo una minima parte del suo campo. 15 cm e 60 spire sono una scelta equilibrata per il primo rilevatore. Spieghiamo a fondo bobine e calcolo dell'induttanza nella guida cos'è un induttore, e lo strumento per i codici degli induttori ti aiuta a decifrare quelli già pronti.
Il circuito: oscillatore LC e collegamenti
Come oscillatore usiamo la prima porta invertente dell'integrato. La resistenza di retroazione da 1 MΩ tiene la porta nella sua zona lineare, e la bobina con i due condensatori forma una rete a π. Alla frequenza di risonanza questa rete sfasa il segnale di 180 gradi; sommati ai 180 gradi dell'invertitore stesso, il circuito oscilla proprio a quella frequenza. La seconda porta trasforma il segnale quasi sinusoidale in un'onda quadra pulita da 0 a 5 V e la manda ad Arduino.
| Collegamento | Dove va | Nota |
|---|---|---|
| 74HCU04 pin 14 (VCC) | 5V | Condensatore da 100 nF verso GND vicinissimo al pin |
| 74HCU04 pin 7 (GND) | GND | Massa in comune con Arduino |
| Pin 1 (ingresso 1° invertitore) | Estremità A della bobina, C1 (10 nF) a GND, 1 MΩ al pin 2 | Ingresso dell'oscillatore |
| Pin 2 (uscita 1° invertitore) | Al punto B tramite 470 Ω e direttamente al pin 3 | Uscita dell'oscillatore |
| Punto B | Estremità B della bobina, C2 (10 nF) a GND | Secondo ramo della rete a π |
| Pin 4 (uscita 2° invertitore) | Uno: D5; ESP32: GPIO 34 tramite 10 kΩ, più 20 kΩ da GPIO 34 a GND | Onda quadra 0–5 V |
| Pin 5, 9, 11, 13 | GND | Gli ingressi inutilizzati non si lasciano mai scollegati |
| Cicalino passivo | Uno: D8, ESP32: GPIO 25; l'altro capo a GND | Suono con tone() |
| LED | Uno: D13, ESP32: GPIO 2; tramite 220 Ω | Indicatore di rilevamento |
| Pulsante di azzeramento | Uno: tra D2 e GND; ESP32: pulsante BOOT della scheda (GPIO 0) | Rimisura la base |
Codice per Arduino Uno: contare la frequenza e far suonare il cicalino
Il Timer1 a 16 bit di Uno può contare in hardware gli impulsi che arrivano sul pin D5, senza che il processore debba occuparsi di ciascuno. Il codice conta per 200 ms, moltiplica il risultato per 5 per ottenere hertz e lo confronta con la frequenza di base misurata senza metallo. Se la frequenza è scesa suona un tono grave, se è salita uno acuto, e più grande è lo scarto, più il tono sale.
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}| Parte del codice | Cosa fa | Se vuoi regolarla |
|---|---|---|
| countPulses() | Trasforma Timer1 in un contatore con clock da D5 e conta per 200 ms | Una finestra più lunga è più precisa ma più lenta |
| GATE_MS = 200 | Circa 12.600 impulsi per finestra a 63 kHz; un impulso vale 5 Hz | Con 500 ms la risoluzione diventa 2 Hz |
| calibrate() | Prende come base la media di 8 letture senza metallo | All'accensione tieni la bobina lontana dal metallo |
| smoothDiff | Smorza il rumore pesando le letture più recenti | Con un coefficiente maggiore di 0,6 la risposta è più calma ma più lenta |
| THRESHOLD_HZ = 15 | Considera rumore ogni scarto inferiore | Impostala a 2–3 volte il rumore che vedi nel plotter seriale |
| baseline += diff * 0.02 | Senza metallo riporta lentamente la base al valore reale | Se è troppo grande "dimentica" anche un metallo che si avvicina piano |
Dopo il caricamento apri il plotter seriale dal menu Strumenti a 115200 baud. Senza metallo la linea oscilla di qualche hertz intorno allo zero; avvicina un mazzo di chiavi alla bobina e la vedrai saltare in alto o in basso. Dato che ora Timer1 lavora come contatore, analogWrite non funziona più su D9 e D10; tone() usa il Timer2, quindi nessun conflitto. Perché un cicalino passivo ha bisogno di tone() lo spieghiamo nella guida cos'è un buzzer.
Taratura ed effetto del suolo
Il peggior nemico di questo tipo di rilevatore non è il metallo ma la deriva. Nei primi 5–10 minuti dall'accensione l'integrato, i condensatori e la bobina si scaldano, e la frequenza può slittare di decine di hertz al minuto. Condensatori a film, una bobina ben fasciata e l'inseguimento lento della base nel codice eliminano gran parte della deriva. Al resto pensa la taratura:
- Accendi il rilevatore ad almeno 1 m da tavoli metallici, telefono e fibbia della cintura e lascialo scaldare per 2–3 minuti.
- Premi il pulsante di azzeramento; il LED si accende per un attimo e la frequenza di base compare nel monitor seriale.
- Nel plotter seriale guarda quanto oscilla il rumore da picco a picco e imposta THRESHOLD_HZ a 2–3 volte quel valore.
- Avvicina una moneta al centro della bobina a 2, 4, 6 e 8 cm e annota lo scarto a ogni distanza; questa è la portata reale del tuo rilevatore.
- Sul campo tieni la bobina a 3–5 cm da terra, azzera di nuovo e poi spazza lentamente e sempre alla stessa altezza.
| Terreno o ambiente | Effetto | Cosa fare |
|---|---|---|
| Terra rossa ricca di ossido di ferro | Abbassa la frequenza, si comporta come il ferro | Azzera con la bobina all'altezza di ricerca e non cambiare più quell'altezza |
| Sabbia bagnata e salata (spiaggia) | È conduttiva e alza la frequenza | Cerca nella sabbia asciutta; su questo terreno i rilevatori a impulsi sono molto migliori |
| Muro in cemento armato | I ferri d'armatura danno segnale ovunque | Per cercare chiodi muovi la bobina parallela al muro e a distanza fissa |
| Sbalzi di temperatura (sole, contatto con la mano) | La base slitta lentamente | Tieni la bobina all'ombra e la mano del manico lontana dalla bobina |
| Alimentatori, lampade LED, motori | Rumore elettrico, bip casuali | Alimenta a batteria e allontanati dalla fonte di disturbo |
| Bobina che vibra | I fili che si muovono danno falsi segnali | Fascia l'avvolgimento e fissa il cavo al manico |
Codice per ESP32
L'ESP32 non ha un Timer1 con clock esterno come Uno, quindi scegliamo la strada più semplice e compatibile con ogni versione del core: a ogni fronte di salita viene chiamata una breve routine di interrupt che aggiunge uno a un contatore. A 63 kHz sono 63.000 interrupt al secondo; un ESP32 a 240 MHz li regge senza fatica, ma conviene restare sotto i 100 kHz. Dato che gli ingressi dell'ESP32 non tollerano i 5 V, abbassiamo l'uscita dell'oscillatore a 3,3 V con un partitore di tensione da 10 kΩ e 20 kΩ. Non serve un altro pulsante per l'azzeramento: il pulsante BOOT della scheda è collegato a GPIO 0.
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}La logica è la stessa della versione per Uno; cambia solo il modo di contare gli impulsi. IRAM_ATTR mette la routine di interrupt nella memoria interna veloce, e volatile avvisa il compilatore che pulseCount può cambiare in qualsiasi momento. Per frequenze più alte si può usare il contatore di impulsi hardware (PCNT) dell'ESP32, ma il suo driver è cambiato tra le versioni 2.x e 3.x del core; per iniziare, il metodo a interrupt dà meno grattacapi. Il vero asso dell'ESP32 è il Wi-Fi: puoi mandare lo scarto come grafico in tempo reale a una pagina web sul telefono, usando la struttura della guida web server e WebSocket con ESP32.
Discriminazione: ferro o altro metallo?
Il verso dello spostamento di frequenza ti dà un indizio sul tipo di oggetto. Ma attenzione: un oggetto non ferroso grande e vicino e uno di ferro piccolo e lontano possono dare segnali di intensità simile; il verso aiuta, l'intensità da sola inganna. La tabella mostra come si comportano oggetti comuni con il metodo dello spostamento di frequenza:
| Oggetto | Frequenza | Suono | Nota |
|---|---|---|---|
| Chiodo, vite o tappo di ferro | Scende | Grave | Anche la ruggine può rafforzare il segnale |
| Monete da 1, 2 e 5 centesimi di euro e altre monete in acciaio placcato | Scende | Grave | Acciaio ramato, si attaccano alla calamita |
| Lattina o stagnola di alluminio | Sale | Acuto | Segnale forte grazie alla grande superficie |
| Filo di rame, chiave di ottone | Sale | Acuto | Alta conducibilità, si rilevano bene |
| Anello d'oro | Sale | Acuto | Segnale debole perché piccolo; cercalo proprio sotto la bobina |
| Forchetta in acciaio inox | Sale poco | Acuto, debole | Quasi tutti gli acciai inox non sono magnetici e conducono poco |
Problemi comuni e soluzioni
| Sintomo | Causa probabile | Soluzione |
|---|---|---|
| Il monitor seriale mostra 0 Hz | L'oscillatore non parte | Collega a GND gli ingressi inutilizzati, togli lo smalto ai capi, controlla la 1 MΩ |
| C'è frequenza ma suona di continuo | Base misurata vicino a un metallo o soglia troppo bassa | Azzera lontano dal metallo e alza THRESHOLD_HZ |
| Non rileva nessun metallo | Soglia troppo alta, o bobina troppo grande per un oggetto minuscolo | Guarda lo scarto nel plotter seriale, abbassa la soglia, prova una bobina più piccola |
| Comincia a suonare da solo, piano piano | Deriva da riscaldamento, condensatore ceramico X7R | Usa condensatori a film e azzera dopo 5 minuti di riscaldamento |
| Toccando la bobina compare un segnale | Effetto capacitivo della mano | Aggiungi la schermatura in stagnola collegata a GND e tieni la bobina dal manico |
| Valori senza senso sull'ESP32 | Segnale a 5 V diretto sull'ingresso o frequenza troppo alta | Controlla il partitore 10k/20k e porta la frequenza sotto i 100 kHz |
Idee per migliorare il rilevatore
- Indicatore con display: mostra lo scarto come barra su un display OLED e la frequenza di base in un angolo.
- Versione portatile a batteria: costruisci un rilevatore a mano senza fili con una cella 18650 e un modulo di ricarica TP4056.
- Avviso a vibrazione: nei luoghi rumorosi usa un motorino a vibrazione al posto del cicalino.
- Scanner per muri: con una piccola bobina da 5 cm cerca chiodi e tubi nel muro e osserva come cambia il segnale quando la giri.
- Selezionatore di monete: misura lo scarto delle monete che scivolano su uno scivolo e separa quelle d'acciaio da quelle di rame.
- Confronto con un sensore magnetico: un sensore a effetto Hall vede solo calamite e campi magnetici; prova i due sensori fianco a fianco e confrontali.
Il metal detector è uno dei rari progetti che mostrano in modo concreto come funzionano bobine, risonanza e correnti parassite. Se prima vuoi esercitarti a far suonare un cicalino o a dare avvisi in base alla distanza su un circuito più semplice, nell'app BlueGrays trovi passo dopo passo, con schema e codice, i progetti uso del buzzer, regolazione della frequenza con buzzer, sensore di parcheggio con HC-SR04 e sensore porta con contatto reed.
Domande frequenti
Quanto in profondità rileva un metal detector con Arduino?
Con il metodo dello spostamento di frequenza di questa guida, una bobina da 15 cm rileva una moneta a circa 4–7 cm, una lattina a 12–18 cm e un grande coperchio metallico a 20–30 cm. Poiché il segnale si indebolisce molto in fretta con la distanza, la profondità dipende soprattutto dalle dimensioni della bobina e dalla stabilità dell'oscillatore.
Quante spire deve avere la bobina di un metal detector?
Per una bobina da 15 cm in filo da 0,4 mm, da 40 a 60 spire sono un buon punto di partenza e con 5 nF danno 60–95 kHz. Il numero di spire cambia poco la profondità, fissa soprattutto la frequenza; se usi l'ESP32 con il metodo a interrupt, avvolgi abbastanza spire da restare sotto i 100 kHz.
Un metal detector fatto in casa distingue l'oro dal ferro?
In parte. Ferro e acciaio aumentano l'induttanza e abbassano la frequenza, mentre oro, argento, rame e alluminio la alzano; il codice li distingue con un tono grave e uno acuto. Questo metodo semplice però non separa un piccolo anello d'oro da un pezzetto di stagnola; per farlo serve la misura di fase dei rilevatori VLF.
Si può costruire un metal detector a induzione a impulsi (PI) con Arduino?
Sì, ma è un progetto più impegnativo. Bisogna pilotare la bobina a impulsi con un MOSFET, smorzare in sicurezza le centinaia di volt che compaiono allo spegnimento e misurare il tempo di smorzamento con precisione al microsecondo. In cambio si ottiene un rilevatore molto più profondo e stabile su terreni mineralizzati e sabbia bagnata.
Perché il mio metal detector suona da solo?
La causa più comune è la deriva termica: nei primi minuti integrato, condensatori e bobina si scaldano e la frequenza si sposta. Usa condensatori a film, fascia bene la bobina, aspetta qualche minuto e azzera di nuovo. Anche un cavo o un avvolgimento che si muovono e il rumore di alimentatori vicini creano falsi segnali.
Quale condensatore usare in un metal detector?
I migliori sono i condensatori a film in poliestere o polipropilene, perché il loro valore cambia pochissimo con la temperatura. I ceramici X7R o Y5V variano di qualche punto percentuale scaldandosi, e questo sposta la frequenza come se si avvicinasse un metallo. Se devi usare un ceramico, scegli il tipo C0G (NP0).
Progetti da realizzare dopo questo articolo
Vedi tutti i progetti
Uso del cicalino
Ti sei mai chiesto come fa un campanello o un allarme a suonare? L'Arduino fa suonare un piccolo cicalino a intervalli brevi: bip, pausa, bip, pausa.

Impostazione della frequenza con cicalino
Comandi il suono di un buzzer con quattro pulsanti: uno avvia il suono, uno lo zittisce e gli altri due lo rendono più acuto o più grave.

Sensore di parcheggio con HC-SR04
Una versione in miniatura del sensore di parcheggio delle auto: più qualcosa si avvicina, più i bip accelerano.

Lettura di un sensore reed
Ti sei mai chiesto come funziona l'interruttore magnetico degli allarmi per porte e finestre?

Sensore porta con contatto reed
Capisci se la tua porta è aperta o chiusa guardando una luce. Metti un piccolo magnete sulla porta e sul telaio un interruttore che sente i magneti; a porta chiusa stanno vicini e si accende il LED…

Sensore di parcheggio ESP32 (HC-SR04 + barra a 5 LED + cicalino + OLED)
La versione ESP32 di un sensore di parcheggio! Il sensore a ultrasuoni HC-SR04 misura la distanza dall'oggetto davanti. Più si avvicina, più si riempie una barra di 5 LED (verde → giallo → rosso) e più il buzzer suona rapido. Molto vicino (sotto i 10 cm) parte un allarme continuo e si accendono tutti i LED. Il display OLED SSD1306 mostra i cm in tempo reale a caratteri grandi, insieme a un messaggio di stato.

LED Lampeggiante con ESP32
Insegna l'uso di base delle uscite GPIO con l'ESP32. Otteniamo un effetto lampeggiante accendendo e spegnendo un LED dal pin digitale. Versione ESP32 del classico progetto blink su Arduino UNO; i comandi di base di blink nell'ambiente Arduino sono gli stessi, ma la disposizione dei pin e i livelli GPIO a 3,3 V dell'ESP32 sono diversi da quelli di Arduino UNO.
Altri articoli
App BlueGrays
Costruisci questo circuito passo passo sul telefono
Schema, codice ed elenco componenti in un’unica schermata. Oltre 500 progetti Arduino, ESP32 e Pico da realizzare.
Inquadra con il telefono
Punta la fotocamera sul codice: si apre lo store del tuo telefono.
oppure apri lo store

