Guide · 11 min di lettura

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:

MetodoCome funzionaProfonditàRiconosce il ferroEffetto del suoloDifficoltà
Spostamento di frequenza (tipo BFO)Misura la variazione di frequenza di un oscillatore a bobina singolaBassaSì (dal verso dello spostamento)Evidente su terreno mineralizzatoFacile, il metodo di questa guida
VLF (bilanciamento a induzione)Bobine di trasmissione e ricezione separate, misura lo sfasamentoMedia o buonaMolto beneBilanciamento del suolo possibileMedia o difficile
Induzione a impulsi (PI)Invia brevi impulsi alla bobina e misura quanto dura lo smorzamento dopo lo spegnimentoLa migliorePocoBuono anche su terreno mineralizzato e sabbia di mareDifficile

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.
Buzzer
La voce del rilevatore: il cicalino passivo suona frequenze diverse con tone(), così senti un tono grave per il ferro e uno acuto per gli altri metalli.

Avvolgere la bobina di ricerca

  1. 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.
  2. Avvolgi intorno alla forma 60 spire strette e regolari di filo smaltato e lascia 15–20 cm di filo a ogni estremità.
  3. 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.
  4. 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 Ω.
  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.
  6. Fissa la bobina a un manico senza parti metalliche, attorciglia il cavo a due fili e fissalo al manico con il nastro.
Vicino alla bobina non deve esserci metallo: viti, rivetti, fascette metalliche o un tubo di alluminio fanno segnalare al rilevatore "metallo" in continuazione. Usa viti di plastica, colla a caldo e legno. Non unire mai le estremità della schermatura di stagnola; un anello chiuso si comporta come un enorme oggetto metallico e assorbe il campo della bobina.

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:

DiametroSpireInduttanza (circa)Frequenza (C = 5 nF)MonetaLattinaNota
10 cm40350 µH120 kHz3–5 cm8–12 cmSensibile agli oggetti piccoli; frequenza alta per l'ESP32
10 cm60750 µH82 kHz3–5 cm8–12 cmRilevatore a mano compatto
15 cm40600 µH93 kHz4–7 cm12–18 cmPoco filo, buon inizio
15 cm601,25 mH63 kHz4–7 cm12–18 cmLa bobina di questa guida; adatta a Uno ed ESP32
20 cm30500 µH100 kHz4–7 cm15–22 cmPiù profonda con gli oggetti grandi
20 cm501,3 mH63 kHz4–7 cm15–22 cmPesante, 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.

CollegamentoDove vaNota
74HCU04 pin 14 (VCC)5VCondensatore da 100 nF verso GND vicinissimo al pin
74HCU04 pin 7 (GND)GNDMassa in comune con Arduino
Pin 1 (ingresso 1° invertitore)Estremità A della bobina, C1 (10 nF) a GND, 1 MΩ al pin 2Ingresso dell'oscillatore
Pin 2 (uscita 1° invertitore)Al punto B tramite 470 Ω e direttamente al pin 3Uscita dell'oscillatore
Punto BEstremità B della bobina, C2 (10 nF) a GNDSecondo ramo della rete a π
Pin 4 (uscita 2° invertitore)Uno: D5; ESP32: GPIO 34 tramite 10 kΩ, più 20 kΩ da GPIO 34 a GNDOnda quadra 0–5 V
Pin 5, 9, 11, 13GNDGli ingressi inutilizzati non si lasciano mai scollegati
Cicalino passivoUno: D8, ESP32: GPIO 25; l'altro capo a GNDSuono con tone()
LEDUno: D13, ESP32: GPIO 2; tramite 220 ΩIndicatore di rilevamento
Pulsante di azzeramentoUno: tra D2 e GND; ESP32: pulsante BOOT della scheda (GPIO 0)Rimisura la base
Prova l'oscillatore prima di caricare il codice: se il multimetro misura la frequenza, controlla il pin 4; con la bobina da 15 cm e 60 spire dovresti leggere circa 55–70 kHz. Se segna 0, verifica prima che gli ingressi inutilizzati siano a GND, che lo smalto sia stato tolto dalle estremità della bobina e che la resistenza da 1 MΩ sia al suo posto.

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.

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}
Parte del codiceCosa faSe vuoi regolarla
countPulses()Trasforma Timer1 in un contatore con clock da D5 e conta per 200 msUna finestra più lunga è più precisa ma più lenta
GATE_MS = 200Circa 12.600 impulsi per finestra a 63 kHz; un impulso vale 5 HzCon 500 ms la risoluzione diventa 2 Hz
calibrate()Prende come base la media di 8 letture senza metalloAll'accensione tieni la bobina lontana dal metallo
smoothDiffSmorza il rumore pesando le letture più recentiCon un coefficiente maggiore di 0,6 la risposta è più calma ma più lenta
THRESHOLD_HZ = 15Considera rumore ogni scarto inferioreImpostala a 2–3 volte il rumore che vedi nel plotter seriale
baseline += diff * 0.02Senza metallo riporta lentamente la base al valore realeSe è 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:

  1. Accendi il rilevatore ad almeno 1 m da tavoli metallici, telefono e fibbia della cintura e lascialo scaldare per 2–3 minuti.
  2. Premi il pulsante di azzeramento; il LED si accende per un attimo e la frequenza di base compare nel monitor seriale.
  3. Nel plotter seriale guarda quanto oscilla il rumore da picco a picco e imposta THRESHOLD_HZ a 2–3 volte quel valore.
  4. 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.
  5. 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 ambienteEffettoCosa fare
Terra rossa ricca di ossido di ferroAbbassa la frequenza, si comporta come il ferroAzzera con la bobina all'altezza di ricerca e non cambiare più quell'altezza
Sabbia bagnata e salata (spiaggia)È conduttiva e alza la frequenzaCerca nella sabbia asciutta; su questo terreno i rilevatori a impulsi sono molto migliori
Muro in cemento armatoI ferri d'armatura danno segnale ovunquePer cercare chiodi muovi la bobina parallela al muro e a distanza fissa
Sbalzi di temperatura (sole, contatto con la mano)La base slitta lentamenteTieni la bobina all'ombra e la mano del manico lontana dalla bobina
Alimentatori, lampade LED, motoriRumore elettrico, bip casualiAlimenta a batteria e allontanati dalla fonte di disturbo
Bobina che vibraI fili che si muovono danno falsi segnaliFascia 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.

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}

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:

OggettoFrequenzaSuonoNota
Chiodo, vite o tappo di ferroScendeGraveAnche la ruggine può rafforzare il segnale
Monete da 1, 2 e 5 centesimi di euro e altre monete in acciaio placcatoScendeGraveAcciaio ramato, si attaccano alla calamita
Lattina o stagnola di alluminioSaleAcutoSegnale forte grazie alla grande superficie
Filo di rame, chiave di ottoneSaleAcutoAlta conducibilità, si rilevano bene
Anello d'oroSaleAcutoSegnale debole perché piccolo; cercalo proprio sotto la bobina
Forchetta in acciaio inoxSale pocoAcuto, deboleQuasi tutti gli acciai inox non sono magnetici e conducono poco

Problemi comuni e soluzioni

SintomoCausa probabileSoluzione
Il monitor seriale mostra 0 HzL'oscillatore non parteCollega a GND gli ingressi inutilizzati, togli lo smalto ai capi, controlla la 1 MΩ
C'è frequenza ma suona di continuoBase misurata vicino a un metallo o soglia troppo bassaAzzera lontano dal metallo e alza THRESHOLD_HZ
Non rileva nessun metalloSoglia troppo alta, o bobina troppo grande per un oggetto minuscoloGuarda lo scarto nel plotter seriale, abbassa la soglia, prova una bobina più piccola
Comincia a suonare da solo, piano pianoDeriva da riscaldamento, condensatore ceramico X7RUsa condensatori a film e azzera dopo 5 minuti di riscaldamento
Toccando la bobina compare un segnaleEffetto capacitivo della manoAggiungi la schermatura in stagnola collegata a GND e tieni la bobina dal manico
Valori senza senso sull'ESP32Segnale a 5 V diretto sull'ingresso o frequenza troppo altaControlla il partitore 10k/20k e porta la frequenza sotto i 100 kHz
Prima di andare a cercare con un metal detector, informati sulle regole del luogo. In molti paesi, Italia compresa, la ricerca non autorizzata in aree archeologiche, ruderi e zone protette è vietata, e i ritrovamenti di interesse storico vanno denunciati alle autorità. Sui terreni privati chiedi sempre il permesso al proprietario e richiudi le buche che scavi.

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 modo più efficace per aumentare la portata non è cambiare il codice, ma migliorare la stabilità. Se il rumore si dimezza, puoi dimezzare la soglia e il rilevatore sentirà lo stesso oggetto da più lontano. Condensatori a film, bobina ben fasciata, cavo fissato e alimentazione a batteria sono le quattro cose che fanno più differenza.

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).

Vedi tutti i progetti
Uso del cicalino
AR-13Principiante

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.

4.7(92)
171
Impostazione della frequenza con cicalino
AR-14Intermedio

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.

4.6(69)
120
Sensore di parcheggio con HC-SR04
AR-28Intermedio
Premium

Sensore di parcheggio con HC-SR04

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

4.8(64)
86
Lettura di un sensore reed
AR-37Principiante

Lettura di un sensore reed

Ti sei mai chiesto come funziona l'interruttore magnetico degli allarmi per porte e finestre?

4.5(22)
29
Sensore porta con contatto reed
AR-38Principiante
Premium

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…

4.7(34)
44
Sensore di parcheggio ESP32 (HC-SR04 + barra a 5 LED + cicalino + OLED)
ES-38Avanzato
Premium

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.

14
LED Lampeggiante con ESP32
ES-1Principiante

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.

4.7(37)
108