Guias · 11 min de leitura

Detector de metais com Arduino: bobina de busca, oscilador LC e código

Monte um detector de metais com Arduino: como enrolar a bobina de busca, oscilador LC, desvio de frequência, tons no buzzer, tabela de espiras, efeito do solo e código para Uno e ESP32.

Um detector de metais com Arduino é um projeto que você monta em uma tarde com uma bobina de busca, um chip barato e um punhado de componentes passivos, e que ensina muito pelo caminho. A bobina faz parte de um oscilador LC; quando um metal chega perto, a indutância da bobina muda, a frequência do oscilador se desloca, e o Arduino mede esse desvio e o transforma em som por um buzzer. Um detector assim percebe uma moeda a poucos centímetros, uma lata de refrigerante a 10–15 cm e uma tampa grande de metal a 20–30 cm. Ele não concorre com um detector comercial, mas dá conta de achar um prego na parede, chaves na areia ou uma ferramenta perdida no jardim.

Neste guia vamos ver primeiro como os detectores de metais funcionam e comparar os três métodos básicos: desvio de frequência, VLF e indução de pulso. Depois vamos enrolar a bobina de busca, ver em uma tabela como o número de espiras afeta a sensibilidade, montar o oscilador LC e escrever o código para um Arduino Uno e para um ESP32. As últimas seções tratam da calibração, dos efeitos do solo, de como diferenciar o ferro dos outros metais e dos problemas mais comuns.

Como funciona um detector de metais?

Uma bobina percorrida por corrente alternada cria ao seu redor um campo magnético que muda de sentido o tempo todo. Quando um objeto metálico entra nesse campo, acontece uma de duas coisas. Nos metais que não contêm ferro, como alumínio, cobre, latão, ouro e prata, o campo faz circular correntes parasitas dentro do objeto; essas correntes criam um campo que se opõe ao da bobina, a indutância efetiva da bobina cai e a frequência do oscilador sobe. Já os metais magnéticos, como o ferro e o aço, concentram as linhas de campo em si mesmos; em baixas frequências esse efeito predomina, a indutância aumenta e a frequência cai. Ou seja, o sentido do desvio também diz se o metal é ferro ou não.

O efeito some muito depressa com a distância. Para um objeto pequeno, um pouco afastado da bobina, o desvio de frequência cai mais ou menos com a sexta potência da distância: afaste o objeto para o dobro da distância e o sinal cai para cerca de 1/64. É por isso que, em um detector caseiro, quem define a profundidade não é o código, e sim o tamanho da bobina e a estabilidade do oscilador. Estes são os três métodos básicos que os detectores usam:

MétodoComo funcionaProfundidadeDiferencia o ferroEfeito do soloDificuldade
Desvio de frequência (tipo BFO)Mede a variação de frequência de um oscilador com uma só bobinaPequenaSim (pelo sentido do desvio)Perceptível em solo mineralizadoFácil; é o método deste guia
VLF (balanço de indução)Bobinas separadas de transmissão e recepção; mede a diferença de faseMédia a boaMuito bemPermite balanço de soloMédia a difícil
Indução de pulso (PI)Aplica pulsos na bobina e mede quanto tempo dura o decaimento depois do desligamentoA melhorMalBom até em solo mineralizado e areia de praiaDifícil

Nos detectores de indução de pulso, a bobina produz uma tensão de retorno (flyback) de centenas de volts depois de cada pulso; ela precisa ser amortecida com segurança, amostrada em microssegundos e processada com um comparador ou amplificador operacional rápido. Para um primeiro projeto, isso é arriscado e difícil de depurar. Por isso usamos o método do desvio de frequência: uma bobina, um chip, baixa tensão e uma tarefa que o Arduino já faz bem, que é contar pulsos.

O que você vai precisar

  • Um Arduino Uno (ou uma placa de desenvolvimento ESP32).
  • Um chip com seis inversores 74HCU04 ou CD4069UB. As versões sem buffer (com o U) são mais estáveis em um oscilador; um 74HC04 normalmente também funciona.
  • Dois capacitores de filme de 10 nF (poliéster ou polipropileno). Os capacitores cerâmicos X7R variam muito com a temperatura e fazem a frequência derivar.
  • Resistores de 1 MΩ, 470 Ω e 220 Ω e um capacitor de desacoplamento de 100 nF.
  • Fio de cobre esmaltado de 0,4 mm (magnet wire), cerca de 30 m para uma bobina de 15 cm e 60 espiras.
  • Um buzzer passivo, um LED e um botão.
  • Uma armação de plástico ou de madeira para a bobina, um cabo de duas vias e, se quiser, papel-alumínio e fita isolante.
Buzzer
A voz do detector: um buzzer passivo toca frequências diferentes com tone(), então você ouve um tom grave para o ferro e um tom agudo para os outros metais.

Como enrolar a bobina de busca

  1. Arranje um molde com cerca de 15 cm de diâmetro: uma tampa de balde de plástico, um tubo de papelão ou pregos batidos em círculo em uma tábua, tudo isso serve.
  2. Enrole 60 espiras de fio esmaltado em volta do molde, bem juntas e regulares, e deixe 15–20 cm de fio em cada ponta.
  3. Antes de tirar o enrolamento do molde, amarre-o firme com fita isolante a cada 3–4 cm; se os fios se mexerem uns contra os outros, a indutância muda e o detector apita sozinho.
  4. Remova o esmalte das pontas do fio com lixa ou com um isqueiro e meça a resistência com um multímetro: uma bobina de 15 cm e 60 espiras deve dar em torno de 3–5 Ω.
  5. Se quiser, cubra o enrolamento com fita e envolva-o em papel-alumínio, mas deixe um vão de 1 cm entre as duas pontas do alumínio; encoste um fio desencapado no alumínio e leve-o ao GND do circuito.
  6. Prenda a bobina em um cabo sem partes metálicas, trance o cabo de duas vias e prenda-o com fita ao longo da haste.
Não pode haver metal perto da bobina: parafusos, rebites, abraçadeiras metálicas ou uma haste de alumínio vão fazer o detector dizer “metal” o tempo todo. Use parafusos de plástico, cola quente e madeira. Nunca una as pontas da blindagem de alumínio; um anel fechado se comporta como um objeto metálico enorme e engole o campo da bobina.

Tabela de espiras da bobina e sensibilidade

A frequência do oscilador é dada por f = 1 / (2π√(L·C)). No nosso circuito, os dois capacitores de 10 nF se comportam como se estivessem em série, então C = 10 × 10 / (10 + 10) = 5 nF. A indutância de uma bobina redonda com núcleo de ar cresce mais ou menos com o quadrado do número de espiras e com o diâmetro da bobina. A tabela traz valores calculados para bobinas enroladas com fio de 0,4 mm e as distâncias aproximadas de detecção que se pode esperar em solo seco:

Diâmetro da bobinaEspirasIndutância (aprox.)Frequência (C = 5 nF)MoedaLata de refrigeranteObservação
10 cm40350 µH120 kHz3–5 cm8–12 cmSensível a objetos pequenos; frequência alta para o ESP32
10 cm60750 µH82 kHz3–5 cm8–12 cmDetector de mão compacto
15 cm40600 µH93 kHz4–7 cm12–18 cmMenos fio, um bom começo
15 cm601,25 mH63 kHz4–7 cm12–18 cmA bobina deste guia; serve para o Uno e para o ESP32
20 cm30500 µH100 kHz4–7 cm15–22 cmMais profundidade em objetos grandes
20 cm501,3 mH63 kHz4–7 cm15–22 cmPesada, mas varre uma área ampla

A tabela deixa duas lições. A primeira: o número de espiras quase não muda a profundidade; a função principal dele é definir a frequência. Menos espiras significam frequência mais alta, e uma frequência mais alta é um pouco mais sensível a objetos pequenos não ferrosos. A segunda: uma bobina grande enxerga objetos grandes de mais longe, mas ganha pouco nos pequenos, como uma moeda, porque um objeto pequeno perturba só uma parte minúscula do campo dela. 15 cm e 60 espiras é uma escolha equilibrada para um primeiro detector. Tratamos a fundo de bobinas e cálculos de indutância no nosso guia o que é um indutor, e a ferramenta de código de indutores ajuda a decifrar indutores prontos.

O circuito: oscilador LC e ligações

Usamos a primeira porta inversora do chip como oscilador. O resistor de realimentação de 1 MΩ mantém a porta na região linear, e a bobina, com os dois capacitores, forma uma rede π. Na frequência de ressonância, essa rede defasa o sinal em 180 graus; somados aos 180 graus do próprio inversor, o circuito oscila exatamente nessa frequência. A segunda porta inversora transforma o sinal quase senoidal em uma onda quadrada limpa de 0–5 V e a envia ao Arduino.

LigaçãoVai paraObservação
Pino 14 do 74HCU04 (VCC)5VCapacitor de 100 nF para o GND, bem junto do pino
Pino 7 do 74HCU04 (GND)GNDTerra comum com o Arduino
Pino 1 (entrada do 1º inversor)Ponta A da bobina, C1 (10 nF) para o GND, 1 MΩ para o pino 2Entrada do oscilador
Pino 2 (saída do 1º inversor)Por 470 Ω até o ponto B e direto para o pino 3Saída do oscilador
Ponto BPonta B da bobina, C2 (10 nF) para o GNDSegunda perna da rede π
Pino 4 (saída do 2º inversor)Uno: D5; ESP32: GPIO 34 por 10 kΩ, mais 20 kΩ do GPIO 34 para o GNDOnda quadrada de 0–5 V
Pinos 5, 9, 11, 13GNDEntradas sem uso nunca ficam flutuando
Buzzer passivoUno: D8; ESP32: GPIO 25; a outra ponta no GNDSom com tone()
LEDUno: D13; ESP32: GPIO 2; por 220 ΩIndicador de detecção
Botão de zerarUno: entre D2 e GND; ESP32: o botão BOOT da placa (GPIO 0)Mede de novo a referência
Teste o oscilador antes de carregar qualquer código: se o seu multímetro tem escala de frequência, meça no pino 4; com a bobina de 15 cm e 60 espiras, você deve ver mais ou menos 55–70 kHz. Se der 0, confira primeiro se as entradas sem uso vão para o GND, se o esmalte foi removido das pontas da bobina e se o resistor de 1 MΩ está no lugar.

Código para Arduino Uno: contando a frequência e gerando som

O Timer1 de 16 bits do Uno consegue contar direto no hardware os pulsos que chegam ao pino D5, então o processador não precisa cuidar de cada um deles. O código conta pulsos por 200 ms, multiplica o resultado por 5 para obter hertz e compara com a frequência de referência, medida sem metal por perto. Se a frequência caiu, ele toca um tom grave; se subiu, um agudo, e quanto maior o desvio, mais agudo fica o som.

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}
Trecho do códigoO que fazSe você quiser ajustar
countPulses()Transforma o Timer1 em um contador com clock vindo de D5 e conta por 200 msUma janela mais longa é mais precisa, porém mais lenta
GATE_MS = 200Cerca de 12.600 pulsos por janela em 63 kHz; um pulso equivale a 5 HzCom 500 ms, a resolução passa a ser de 2 Hz
calibrate()Usa como referência a média de 8 leituras sem metalMantenha a bobina longe de metal ao ligar
smoothDiffSuaviza o ruído dando mais peso às leituras recentesAumente o 0.6 para uma resposta mais calma, porém mais lenta
THRESHOLD_HZ = 15Trata como ruído qualquer desvio abaixo desse valorDefina em 2–3 vezes o ruído que você vê no Plotter Serial
baseline += diff * 0.02Sem metal, puxa devagar a referência para o valor realSe ficar grande demais, ele também “esquece” um metal que se aproxima devagar

Depois de carregar, abra o Plotter Serial pelo menu Ferramentas, em 115200 baud. Sem metal por perto, a linha oscila alguns hertz em torno de zero; aproxime um molho de chaves da bobina e você vai vê-la saltar para cima ou para baixo. Como o Timer1 agora trabalha como contador, o analogWrite deixa de funcionar em D9 e D10; o tone() usa o Timer2, então não há conflito. Explicamos por que um buzzer passivo precisa de tone() no nosso guia o que é um buzzer.

Calibração e efeitos do solo

O maior inimigo desse tipo de detector não é o metal, e sim a deriva. Nos primeiros 5–10 minutos depois de ligar, o chip, os capacitores e a bobina esquentam, e a frequência pode derivar dezenas de hertz por minuto. Capacitores de filme, uma bobina bem presa com fita e o acompanhamento lento da referência feito pelo código eliminam a maior parte dessa deriva. A calibração cuida do resto:

  1. Ligue o detector a pelo menos 1 m de mesas metálicas, do celular e da fivela do cinto, e deixe-o esquentar por 2–3 minutos.
  2. Aperte o botão de zerar; o LED acende por um instante e a frequência de referência aparece no Monitor Serial.
  3. No Plotter Serial, veja quanto o ruído varia de pico a pico e defina THRESHOLD_HZ em 2–3 vezes esse valor.
  4. Leve uma moeda ao centro da bobina a 2, 4, 6 e 8 cm e anote o desvio em cada distância; esse é o alcance real do seu detector.
  5. Em campo, segure a bobina 3–5 cm acima do chão, zere de novo e depois varra sempre devagar, na mesma altura.
Solo ou ambienteEfeitoO que fazer
Terra vermelha, com óxido de ferroBaixa a frequência, comporta-se como ferroZere com a bobina na altura de busca e não mude essa altura
Areia molhada e salgada (praia)Condutora, eleva a frequênciaProcure na areia seca; nesse terreno, os detectores de indução de pulso são muito melhores
Parede de concreto armadoOs vergalhões de aço dão sinal em todo lugarAo procurar pregos, mova a bobina paralela à parede, a uma distância fixa
Variações de temperatura (sol, contato da mão)A referência deriva devagarMantenha a bobina na sombra e a mão que segura o cabo longe dela
Carregadores, lâmpadas de LED, motoresRuído elétrico, apitos aleatóriosAlimente com pilhas ou bateria e afaste-se da fonte de ruído
Bobina balançandoFios em movimento geram sinais falsosPrenda o enrolamento com fita e fixe o cabo na haste

Código para ESP32

O ESP32 não tem um Timer1 com clock externo como o do Uno, então seguimos o caminho mais simples, que funciona com todas as versões do core: a cada borda de subida, uma rotina curta de interrupção é chamada e soma um a um contador. Em 63 kHz, são 63.000 interrupções por segundo; um ESP32 de 240 MHz dá conta com folga, mas é prudente manter a frequência abaixo de 100 kHz. Como as entradas do ESP32 não toleram 5 V, baixamos a saída do oscilador para 3,3 V com um divisor de tensão de 10 kΩ e 20 kΩ. Você não precisa de um botão de zerar a mais: o botão BOOT da placa está ligado ao 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}

A lógica é a mesma da versão para o Uno; só muda a forma de contar os pulsos. IRAM_ATTR coloca a rotina de interrupção na memória interna rápida, e volatile avisa o compilador de que pulseCount pode mudar a qualquer momento. Para frequências mais altas, você pode usar o contador de pulsos por hardware do ESP32 (PCNT), mas o driver dele mudou entre as versões 2.x e 3.x do core, então o método da interrupção dá menos dor de cabeça para começar. O verdadeiro bônus do ESP32 é o Wi-Fi: dá para enviar o desvio como um gráfico ao vivo para uma página web no celular, usando a estrutura do nosso guia servidor web e WebSocket com ESP32.

Discriminação: ferro ou outro metal?

O sentido do desvio de frequência dá uma pista sobre o tipo de objeto. Mas atenção: um objeto não ferroso grande e próximo e um de ferro pequeno e distante podem dar sinais de tamanho parecido; o sentido ajuda, o tamanho sozinho engana. A tabela mostra como objetos comuns se comportam no método do desvio de frequência:

ObjetoFrequênciaSomObservação
Prego, parafuso ou tampa de ferroCaiGraveAté a ferrugem pode reforçar o sinal
Moedas de 1, 2 e 5 centavos de euro e outras moedas de aço revestidoCaiGraveAço com revestimento de cobre ou de outro metal; grudam em um ímã
Lata ou folha de alumínioSobeAgudoSinal forte graças à superfície grande
Fio de cobre, chave de latãoSobeAgudoAlta condutividade, fácil de detectar
Anel de ouroSobeAgudoFraco porque é pequeno; procure bem embaixo da bobina
Garfo de aço inoxidávelSobe um poucoAgudo, fracoA maior parte dos aços inoxidáveis não é magnética e conduz mal

Problemas comuns e soluções

SintomaCausa provávelSolução
O Monitor Serial mostra 0 HzO oscilador não está funcionandoLigue as entradas sem uso ao GND, remova o esmalte das pontas da bobina, confira o resistor de 1 MΩ
Há frequência, mas ele apita sem pararReferência medida perto de metal ou limiar baixo demaisZere longe de metal e aumente THRESHOLD_HZ
Não detecta metal nenhumLimiar alto demais, ou bobina grande demais para um objeto minúsculoObserve o desvio no Plotter Serial, baixe o limiar, experimente uma bobina menor
Aos poucos, começa a apitar sozinhoDeriva de aquecimento, capacitor cerâmico X7RUse capacitores de filme e zere depois de 5 minutos de aquecimento
Encostar na bobina gera sinalEfeito capacitivo da sua mãoAcrescente a blindagem de alumínio ligada ao GND e segure a bobina pelo cabo
Os valores não fazem sentido no ESP32Sinal de 5 V direto na entrada ou frequência alta demaisConfira o divisor de 10k/20k e traga a frequência para menos de 100 kHz
Antes de sair para procurar com um detector de metais, informe-se sobre as regras do lugar. Em muitos países e regiões, é ilegal fazer buscas sem autorização em sítios arqueológicos, ruínas e áreas protegidas, e os achados históricos precisam ser comunicados às autoridades. Em terreno particular, peça sempre permissão ao dono antes e tape os buracos que você cavar.

Ideias para melhorar o detector

  • Leitura em display: mostre o desvio como um gráfico de barra em um display OLED, com a frequência de referência em um canto.
  • Versão a bateria: monte um detector de mão sem fio com uma célula 18650 e um módulo de carga TP4056.
  • Alerta por vibração: em lugares barulhentos, use um motor de vibração no lugar do buzzer.
  • Scanner de parede: use uma bobina pequena, de 5 cm, para achar pregos e canos em uma parede e veja como o sinal muda conforme você a gira.
  • Separador de moedas: meça o desvio de moedas que descem por uma rampa e separe as de aço das de cobre.
  • Compare com um sensor magnético: um sensor de efeito Hall só enxerga ímãs e campos magnéticos; teste os dois sensores lado a lado e compare.
A maneira mais eficaz de aumentar o alcance não é mexer no código, e sim melhorar a estabilidade. Se o ruído cai pela metade, você pode reduzir o limiar pela metade e o detector percebe o mesmo objeto de mais longe. Capacitores de filme, uma bobina bem presa com fita, um cabo fixo e alimentação por bateria são as quatro coisas que mais fazem diferença.

Um detector de metais é um daqueles raros projetos que mostram na prática como funcionam as bobinas, a ressonância e as correntes parasitas. Se você quiser treinar antes, em um circuito mais simples, como fazer um buzzer tocar ou dar avisos conforme a distância, o app BlueGrays tem projetos passo a passo, com esquema do circuito e código, de uso do buzzer, de mudança da frequência do buzzer, de um sensor de estacionamento com HC-SR04 e de um sensor de porta com reed switch.

Perguntas frequentes

A que profundidade um detector de metais com Arduino consegue detectar?

Com o método do desvio de frequência deste guia, uma bobina de 15 cm detecta uma moeda a cerca de 4–7 cm, uma lata de refrigerante a 12–18 cm e uma tampa grande de metal a 20–30 cm. Como o sinal some muito depressa com a distância, a profundidade depende principalmente do tamanho da bobina e da estabilidade do oscilador.

Quantas espiras deve ter a bobina de um detector de metais?

Para uma bobina de 15 cm enrolada com fio de 0,4 mm, de 40 a 60 espiras é um bom ponto de partida, o que dá 60–95 kHz com uma capacitância de 5 nF. O número de espiras quase não muda a profundidade; ele define principalmente a frequência. Se você estiver usando o método da interrupção no ESP32, enrole espiras suficientes para ficar abaixo de 100 kHz.

Um detector de metais caseiro consegue diferenciar ouro de ferro?

Em parte. O ferro e o aço aumentam a indutância e baixam a frequência, enquanto ouro, prata, cobre e alumínio fazem a frequência subir; o código separa os dois grupos com um tom grave e um agudo. Mas esse método simples não distingue um anelzinho de ouro de um pedaço de papel-alumínio; para isso é preciso a medição de fase usada nos detectores VLF.

Dá para montar um detector de metais de indução de pulso (PI) com Arduino?

Sim, mas é um projeto mais difícil. Você precisa aplicar pulsos na bobina por meio de um MOSFET, amortecer com segurança as centenas de volts que aparecem no desligamento e medir o tempo de decaimento com precisão de microssegundos. Em troca, você ganha um detector muito mais profundo e estável em solo mineralizado e areia molhada.

Por que meu detector de metais apita sozinho?

A causa mais comum é a deriva térmica: nos primeiros minutos, o chip, os capacitores e a bobina esquentam e a frequência se desloca. Use capacitores de filme, prenda bem a bobina com fita, espere alguns minutos e zere de novo. Um cabo ou enrolamento que se mexe e o ruído de carregadores próximos também geram sinais falsos.

Que capacitor devo usar em um detector de metais?

Os capacitores de filme, como os de poliéster ou de polipropileno, são os melhores, porque o valor deles quase não muda com a temperatura. Os cerâmicos X7R ou Y5V variam vários por cento ao esquentar, o que desloca a frequência como se um metal estivesse se aproximando. Se você precisar mesmo usar um cerâmico, escolha o tipo C0G (NP0).

Ver todos os projetos
Uso do buzzer
AR-13Iniciante

Uso do buzzer

Já se perguntou como uma campainha ou um alarme produz som? O Arduino faz um pequeno buzzer emitir bipes em intervalos curtos: bipe, pausa, bipe, pausa.

4.7(92)
171
Ajuste de frequência com buzzer
AR-14Intermediário

Ajuste de frequência com buzzer

Você controla o som de um buzzer com quatro botões: um inicia o som, outro o interrompe e os outros dois o deixam mais agudo ou mais grave.

4.6(69)
120
Sensor de estacionamento com HC-SR04
AR-28Intermediário
Premium

Sensor de estacionamento com HC-SR04

Uma versão em miniatura do sensor de estacionamento de um carro: quanto mais perto um objeto chega, mais rápidos ficam os bipes.

4.8(64)
86
Leitura de uma chave reed
AR-37Iniciante

Leitura de uma chave reed

Você já teve curiosidade sobre a chave magnética dos alarmes de portas e janelas?

4.5(22)
29
Sensor de porta com chave reed
AR-38Iniciante
Premium

Sensor de porta com chave reed

Saiba se a porta está aberta ou fechada só de olhar uma luz. Você fixa um pequeno ímã na porta e uma chave sensível ao ímã no batente; quando a porta está fechada, os dois ficam lado a lado e o LED…

4.7(34)
44
Sensor de estacionamento com ESP32 (HC-SR04 + barra de 5 LEDs + buzzer + OLED)
ES-38Avançado
Premium

Sensor de estacionamento com ESP32 (HC-SR04 + barra de 5 LEDs + buzzer + OLED)

A versão com ESP32 do sensor de estacionamento de carro! Usamos o sensor ultrassônico HC-SR04 para medir a distância até o objeto à sua frente. Conforme a distância diminui, a barra de 5 LEDs vai se preenchendo (verde → amarelo → vermelho) e o intervalo entre os bipes do buzzer diminui. Quando o objeto chega muito perto (menos de 10 cm), o alarme soa continuamente e todos os LEDs acendem.

14
LED piscando com ESP32
ES-1Iniciante

LED piscando com ESP32

Ensina o uso básico de uma saída GPIO no ESP32. Fazemos um LED piscar ligando e desligando um pino digital. É a versão para ESP32 do clássico projeto blink do Arduino UNO: os comandos básicos de blink no ambiente Arduino são os mesmos, mas a disposição dos pinos e os níveis de 3,3 V dos GPIOs do ESP32 diferem dos do Arduino UNO.

4.7(37)
108