Guías · 11 min de lectura

Detector de metales con Arduino: bobina, oscilador LC y código

Detector de metales con Arduino: cómo enrollar la bobina, oscilador LC, medir la frecuencia, buzzer, tabla de vueltas, efecto del suelo y código Uno y ESP32.

Un detector de metales con Arduino es un proyecto que puedes armar en una tarde con una bobina de búsqueda, un integrado barato y unos pocos componentes pasivos, y que además enseña muchísimo. La bobina forma parte de un oscilador LC; cuando se le acerca un metal, su inductancia cambia, la frecuencia del oscilador se corre y el Arduino mide ese cambio y lo convierte en sonido con un buzzer. Un detector así nota una moneda a unos pocos centímetros, una lata de refresco a 10–15 cm y una tapa metálica grande a 20–30 cm. No compite con un detector comercial, pero alcanza para encontrar un clavo en la pared, unas llaves en la arena o una herramienta perdida en el jardín.

En esta guía primero veremos cómo funciona un detector de metales y compararemos los tres métodos básicos: corrimiento de frecuencia, VLF e inducción de pulsos. Después enrollaremos la bobina de búsqueda, veremos en una tabla cómo influye el número de vueltas en la sensibilidad, armaremos el oscilador LC y escribiremos el código para Arduino Uno y ESP32. En las últimas secciones hablamos de la calibración, del efecto del suelo, de cómo distinguir el hierro de otros metales y de los problemas más comunes.

¿Cómo funciona un detector de metales?

Una bobina por la que circula corriente alterna crea a su alrededor un campo magnético que cambia de sentido todo el tiempo. Si un objeto metálico entra en ese campo pueden pasar dos cosas. En los metales que no contienen hierro, como aluminio, cobre, latón, oro y plata, el campo induce corrientes de Foucault (corrientes parásitas) dentro del objeto; esas corrientes generan un campo que se opone al de la bobina, la inductancia efectiva baja y la frecuencia del oscilador sube. Los metales magnéticos como el hierro y el acero, en cambio, concentran las líneas de campo; a frecuencias bajas ese efecto domina, la inductancia aumenta y la frecuencia baja. Es decir, el sentido en que se corre la frecuencia también te dice si el metal es hierro o no.

Este efecto se debilita muy rápido con la distancia. Para un objeto pequeño lejos de la bobina, el corrimiento de frecuencia cae más o menos con la sexta potencia de la distancia: si alejas el objeto al doble, la señal baja a cerca de 1/64. Por eso, en un detector casero la profundidad no la decide el código sino el tamaño de la bobina y la estabilidad del oscilador. Estos son los tres métodos básicos que usan los detectores:

Método¿Cómo funciona?ProfundidadDistingue el hierroEfecto del sueloDificultad
Corrimiento de frecuencia (tipo BFO)Mide el cambio de frecuencia de un oscilador con una sola bobinaPocaSí (según el sentido del cambio)Notable en suelos mineralizadosFácil, el método de esta guía
VLF (equilibrio de inducción)Dos bobinas, emisora y receptora; mide la diferencia de faseMedia a buenaMuy bienPermite equilibrar el sueloMedia a difícil
Inducción de pulsos (PI)Da pulsos cortos a la bobina y mide cuánto tarda en apagarse la señalLa mejorPocoBuena incluso en suelo mineralizado y arena de playaDifícil

En los detectores de inducción de pulsos, la bobina genera después de cada pulso un voltaje de retroceso de cientos de voltios; hay que amortiguarlo con seguridad, muestrearlo en microsegundos y procesarlo con un comparador o un amplificador operacional rápido. Para un primer proyecto es peligroso y difícil de depurar. Por eso aquí usamos el método de corrimiento de frecuencia: una bobina, un integrado, bajo voltaje y una tarea que el Arduino ya hace muy bien, contar pulsos.

Materiales necesarios

  • Arduino Uno (o una placa de desarrollo ESP32).
  • Un integrado inversor séxtuple 74HCU04 o CD4069UB. Las versiones sin búfer (con la U) son más estables en un oscilador; el 74HC04 también suele funcionar.
  • 2 capacitores de película de 10 nF (poliéster o polipropileno). Los capacitores cerámicos X7R cambian mucho con la temperatura y hacen que la frecuencia se corra.
  • Resistencias de 1 MΩ, 470 Ω y 220 Ω y un capacitor de desacople de 100 nF.
  • Alambre de cobre esmaltado (alambre magneto) de 0,4 mm, unos 30 m (para una bobina de 15 cm y 60 vueltas).
  • Buzzer pasivo, un LED y un pulsador.
  • Un marco de plástico o madera para la bobina, cable de dos hilos y, si quieres, papel aluminio y cinta aislante.
Buzzer
La voz del detector: el buzzer pasivo suena con tone() a distintas frecuencias, así oyes un tono grave para el hierro y uno agudo para los demás metales.

Cómo enrollar la bobina de búsqueda

  1. Busca un molde de unos 15 cm de diámetro: sirve la tapa de un balde de plástico, un tubo de cartón o unos clavos puestos en círculo sobre una tabla.
  2. Enrolla el alambre esmaltado alrededor del molde con 60 vueltas apretadas y parejas, y deja 15–20 cm de alambre en cada extremo.
  3. Antes de sacar el bobinado del molde, sujétalo bien con cinta aislante cada 3–4 cm; si los alambres se mueven entre sí, la inductancia cambia y el detector suena solo.
  4. Quita el esmalte de las puntas con lija o con un encendedor y mide la resistencia con el multímetro: en una bobina de 15 cm y 60 vueltas deberías ver unos 3–5 Ω.
  5. Si quieres, cubre el bobinado con cinta y envuélvelo en papel aluminio, pero deja un hueco de 1 cm entre los dos extremos del aluminio; toca el aluminio con un alambre pelado y llévalo al GND del circuito.
  6. Fija la bobina a un mango sin partes metálicas, trenza el cable de dos hilos y pégalo al mango con cinta.
Cerca de la bobina no debe haber nada de metal: tornillos, remaches, abrazaderas metálicas o un tubo de aluminio harán que el detector diga "hay metal" todo el tiempo. Usa tornillos de plástico, silicón caliente y madera. Nunca cierres los extremos del blindaje de aluminio; un anillo cerrado se comporta como un objeto metálico enorme y se "come" el campo de la bobina.

Tabla de vueltas de la bobina y sensibilidad

La frecuencia del oscilador se calcula con f = 1 / (2π√(L·C)). En nuestro circuito los dos capacitores de 10 nF actúan como si estuvieran en serie, así que C = 10 × 10 / (10 + 10) = 5 nF. La inductancia de una bobina de aire circular crece más o menos con el cuadrado del número de vueltas y con el diámetro. La tabla da los valores calculados para bobinas de alambre de 0,4 mm y las distancias de detección aproximadas que puedes esperar en suelo seco:

DiámetroVueltasInductancia (aprox.)Frecuencia (C = 5 nF)MonedaLata de refrescoNota
10 cm40350 µH120 kHz3–5 cm8–12 cmSensible a objetos chicos; frecuencia alta para el ESP32
10 cm60750 µH82 kHz3–5 cm8–12 cmDetector de mano compacto
15 cm40600 µH93 kHz4–7 cm12–18 cmPoco alambre, buen comienzo
15 cm601,25 mH63 kHz4–7 cm12–18 cmLa bobina de esta guía; sirve para Uno y ESP32
20 cm30500 µH100 kHz4–7 cm15–22 cmMás profundidad con objetos grandes
20 cm501,3 mH63 kHz4–7 cm15–22 cmPesada, pero barre un área amplia

De la tabla salen dos lecciones. La primera: el número de vueltas casi no cambia la profundidad; su función principal es fijar la frecuencia. Menos vueltas significa más frecuencia, y una frecuencia más alta es algo más sensible a objetos pequeños no ferrosos. La segunda: una bobina grande ve los objetos grandes desde más lejos, pero con objetos chicos como una moneda gana poco, porque el objeto pequeño altera solo una parte mínima de su campo. 15 cm y 60 vueltas es una opción equilibrada para un primer detector. Explicamos a fondo las bobinas y el cálculo de inductancia en la guía qué es una bobina, y para leer los códigos de bobinas comerciales te sirve la herramienta de código de bobinas.

El circuito: oscilador LC y conexiones

Como oscilador usamos la primera compuerta inversora del integrado. La resistencia de realimentación de 1 MΩ mantiene la compuerta en su zona lineal, y la bobina con los dos capacitores forma una red π. A la frecuencia de resonancia esa red gira la señal 180 grados; sumados a los 180 grados del propio inversor, el circuito oscila justo a esa frecuencia. La segunda compuerta convierte esa señal casi senoidal en una onda cuadrada limpia de 0–5 V y se la envía al Arduino.

Conexión¿A dónde?Nota
74HCU04 pin 14 (VCC)5VCapacitor de 100 nF a GND pegado al pin
74HCU04 pin 7 (GND)GNDTierra común con el Arduino
Pin 1 (entrada del 1.er inversor)Extremo A de la bobina, C1 (10 nF) a GND, 1 MΩ al pin 2Entrada del oscilador
Pin 2 (salida del 1.er inversor)Al punto B a través de 470 Ω y directo al pin 3Salida del oscilador
Punto BExtremo B de la bobina, C2 (10 nF) a GNDSegunda pata de la red π
Pin 4 (salida del 2.º inversor)En el Uno a D5; en el ESP32 a GPIO 34 por 10 kΩ, y de GPIO 34 a GND por 20 kΩOnda cuadrada de 0–5 V
Pines 5, 9, 11, 13GNDLas entradas sin usar nunca se dejan al aire
Buzzer pasivoEn el Uno a D8, en el ESP32 a GPIO 25; el otro extremo a GNDSonido con tone()
LEDEn el Uno a D13, en el ESP32 a GPIO 2; con 220 ΩIndicador de detección
Pulsador de ceroEn el Uno entre D2 y GND; en el ESP32 el botón BOOT de la placa (GPIO 0)Vuelve a medir la base
Antes de subir el código, prueba el oscilador: si tu multímetro mide frecuencia, mira el pin 4; con la bobina de 15 cm y 60 vueltas deberías ver entre 55 y 70 kHz. Si marca 0, revisa primero que las entradas sin usar estén a GND, que hayas quitado el esmalte de las puntas de la bobina y que la resistencia de 1 MΩ esté en su lugar.

Código para Arduino Uno: contar la frecuencia y hacer sonar el buzzer

El Timer1 de 16 bits del Uno puede contar por hardware los pulsos que llegan al pin D5, sin que el procesador tenga que atender cada uno. El código cuenta pulsos durante 200 ms, multiplica el resultado por 5 para pasarlo a hercios y lo compara con la frecuencia base medida sin metal. Si la frecuencia bajó, suena un tono grave; si subió, uno agudo, y cuanto mayor es la diferencia, más agudo se vuelve.

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 códigoQué haceSi quieres ajustarlo
countPulses()Convierte el Timer1 en un contador que toma su reloj de D5 y cuenta durante 200 msUna ventana más larga es más precisa pero más lenta
GATE_MS = 200A 63 kHz da unos 12 600 pulsos por ventana; 1 pulso equivale a 5 HzCon 500 ms la resolución es de 2 Hz
calibrate()Toma como base el promedio de 8 lecturas sin metalAl encender, mantén la bobina lejos del metal
smoothDiffSuaviza el ruido dando peso a las lecturas recientesSi subes el 0,6, la respuesta es más tranquila y más lenta
THRESHOLD_HZ = 15Considera ruido todo lo que esté por debajo de este corrimientoAjústalo a 2–3 veces el ruido que ves en el Serial Plotter
baseline += diff * 0.02Sin metal, acerca lentamente la base al valor realSi lo subes mucho, también "olvida" un metal que se acerca despacio

Después de subir el código, abre el Serial Plotter desde el menú Herramientas a 115200 baudios. Sin metal, la línea se mueve unos pocos hercios alrededor de cero; al acercar unas llaves a la bobina verás que salta hacia arriba o hacia abajo. Como el Timer1 ahora trabaja de contador, analogWrite deja de funcionar en D9 y D10; tone() usa el Timer2, así que no hay conflicto. Por qué el buzzer pasivo necesita tone() lo explicamos en la guía qué es un buzzer.

Calibración y efecto del suelo

El mayor enemigo de este tipo de detector no es el metal, sino la deriva. En los primeros 5–10 minutos después de encenderlo, el integrado, los capacitores y la bobina se calientan, y la frecuencia puede correrse decenas de hercios por minuto. Usar capacitores de película, sujetar bien la bobina con cinta y el seguimiento lento de la base que hace el código eliminan casi toda esa deriva. El resto lo resuelve la calibración:

  1. Enciende el detector a por lo menos 1 m de mesas metálicas, del celular y de la hebilla del cinturón, y deja que se caliente 2–3 minutos.
  2. Presiona el pulsador de cero; el LED se enciende un momento y la frecuencia base aparece en el monitor serie.
  3. En el Serial Plotter mira cuánto varía el ruido de pico a pico y ajusta THRESHOLD_HZ a 2–3 veces ese valor.
  4. Acerca una moneda al centro de la bobina a 2, 4, 6 y 8 cm y anota el corrimiento en cada distancia; ese es el alcance real de tu detector.
  5. En el terreno, sostén la bobina a 3–5 cm del suelo, vuelve a poner en cero y barre siempre a la misma altura y despacio.
Suelo o entornoEfectoQué hacer
Tierra roja con óxido de hierroBaja la frecuencia, se comporta como hierroPon en cero con la bobina a la altura de búsqueda y no cambies esa altura
Arena húmeda y salada (playa)Es conductora y sube la frecuenciaBusca en arena seca; en este suelo los detectores de inducción de pulsos son mucho mejores
Muro de concreto armadoLa varilla de acero da señal en todas partesPara buscar clavos en la pared, mueve la bobina paralela al muro y a distancia fija
Cambios de temperatura (sol, contacto con la mano)La base se corre lentamenteMantén la bobina a la sombra y la mano del mango lejos de la bobina
Cargadores, lámparas LED, motoresRuido eléctrico, pitidos al azarAliméntalo con baterías y aléjate de la fuente de ruido
Bobina que vibraLos alambres se mueven y dan señales falsasSujeta el bobinado con cinta y fija el cable al mango

Código para ESP32

El ESP32 no tiene un Timer1 con reloj externo como el Uno, así que elegimos el camino más simple y compatible con cualquier versión del núcleo: en cada flanco de subida se llama a una función de interrupción corta que suma uno a un contador. A 63 kHz eso son 63 000 interrupciones por segundo; el ESP32 de 240 MHz lo aguanta sin problema, pero conviene mantener la frecuencia por debajo de 100 kHz. Como las entradas del ESP32 no toleran 5 V, bajamos la salida del oscilador a 3,3 V con un divisor de voltaje de 10 kΩ y 20 kΩ. Para poner en cero no hace falta otro pulsador: el botón BOOT de la placa está conectado 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 lógica es la misma que en la versión para Uno; solo cambia la forma de contar los pulsos. IRAM_ATTR coloca la función de interrupción en la memoria interna rápida, y volatile le avisa al compilador que la variable pulseCount puede cambiar en cualquier momento. Para frecuencias más altas se puede usar el contador de pulsos por hardware del ESP32 (PCNT), pero su driver cambió entre las versiones 2.x y 3.x del núcleo, así que para empezar el método por interrupción da menos problemas. La gran ventaja del ESP32 es el Wi-Fi: puedes enviar el corrimiento como una gráfica en vivo a una página web en tu celular usando la estructura de la guía servidor web y WebSocket con ESP32.

Discriminación: ¿hierro u otro metal?

El sentido del corrimiento de frecuencia te da una pista sobre el tipo de objeto. Pero ojo: un objeto no ferroso grande y cercano y uno de hierro pequeño y lejano pueden dar señales de tamaño parecido; el sentido sirve, el tamaño por sí solo engaña. La tabla muestra cómo se comportan objetos comunes con el método de corrimiento de frecuencia:

ObjetoFrecuenciaSonidoNota
Clavo, tornillo o tapa de hierroBajaGraveHasta el óxido puede reforzar la señal
Monedas de 1, 2 y 5 céntimos de euro y muchas monedas de acero recubiertoBajaGraveSon de acero con baño de cobre u otro metal y se pegan al imán
Lata o papel de aluminioSubeAgudoSeñal fuerte por su gran superficie
Cable de cobre, llave de latónSubeAgudoAlta conductividad, se detectan bien
Anillo de oroSubeAgudoSeñal débil por ser pequeño; búscalo justo debajo de la bobina
Tenedor de acero inoxidableSube un pocoAgudo y débilLa mayoría de los inoxidables no son magnéticos y conducen poco

Problemas comunes y soluciones

SíntomaCausa probableSolución
En el monitor serie la frecuencia es 0El oscilador no arrancaConecta a GND las entradas sin usar, quita el esmalte de las puntas, revisa la de 1 MΩ
Hay frecuencia pero suena todo el tiempoLa base se midió cerca de metal o el umbral es muy bajoPon en cero lejos del metal y sube THRESHOLD_HZ
No detecta ningún metalUmbral demasiado alto, o bobina muy grande para un objeto muy chicoMira el corrimiento en el Serial Plotter, baja el umbral, prueba una bobina más chica
Suena solo, poco a pocoDeriva por calentamiento, capacitor cerámico X7RUsa capacitores de película y pon en cero tras 5 minutos de calentamiento
Al tocar la bobina aparece señalEfecto capacitivo de la manoAgrega el blindaje de aluminio a GND y sostén la bobina por el mango
En el ESP32 los valores no tienen sentidoSeñal de 5 V directo a la entrada o frecuencia muy altaRevisa el divisor de 10k/20k y baja la frecuencia a menos de 100 kHz
Antes de salir a buscar con un detector de metales, infórmate de las normas del lugar. En muchos países y regiones está prohibido buscar sin permiso en yacimientos arqueológicos, ruinas y zonas protegidas, y los hallazgos históricos deben comunicarse a las autoridades. En terrenos privados pide siempre permiso al dueño y tapa los hoyos que caves.

Ideas para mejorar el detector

  • Indicador con pantalla: muestra el corrimiento como una barra en una pantalla OLED y la frecuencia base en una esquina.
  • Versión portátil con batería: arma un detector de mano sin cables con una pila 18650 y un módulo de carga TP4056.
  • Aviso por vibración: en lugares ruidosos, usa un motor de vibración en lugar del buzzer.
  • Escáner de paredes: con una bobina chica de 5 cm busca clavos y tubos en la pared y observa cómo cambia la señal al girarla.
  • Separador de monedas: mide el corrimiento de las monedas que bajan por una rampa y separa las de acero de las de cobre.
  • Comparación con un sensor magnético: un sensor de efecto Hall solo ve imanes y campos magnéticos; prueba los dos sensores lado a lado y compara.
La forma más efectiva de aumentar el alcance no es tocar el código, sino mejorar la estabilidad. Si el ruido baja a la mitad, puedes bajar el umbral a la mitad y el detector oirá el mismo objeto desde más lejos. Capacitores de película, una bobina bien sujeta con cinta, un cable fijo y alimentación con baterías son las cuatro cosas que más diferencia hacen.

El detector de metales es uno de esos pocos proyectos que muestran de forma palpable cómo funcionan las bobinas, la resonancia y las corrientes de Foucault. Si antes quieres practicar a hacer sonar un buzzer o dar avisos según la distancia en un circuito más sencillo, en la app BlueGrays encontrarás paso a paso, con diagrama y código, los proyectos de uso del buzzer, ajuste de frecuencia con buzzer, sensor de estacionamiento con HC-SR04 y sensor de puerta con reed switch.

Preguntas frecuentes

¿Qué profundidad alcanza un detector de metales con Arduino?

Con el método de corrimiento de frecuencia de esta guía, una bobina de 15 cm detecta una moneda a unos 4–7 cm, una lata de refresco a 12–18 cm y una tapa metálica grande a 20–30 cm. Como la señal se debilita muy rápido con la distancia, la profundidad depende sobre todo del tamaño de la bobina y de la estabilidad del oscilador.

¿Cuántas vueltas debe tener la bobina de un detector de metales?

Para una bobina de 15 cm de diámetro con alambre de 0,4 mm, de 40 a 60 vueltas es un buen punto de partida, y con 5 nF da una frecuencia de entre 60 y 95 kHz. El número de vueltas casi no cambia la profundidad, sobre todo fija la frecuencia; si usas el ESP32 con interrupciones, enrolla suficientes vueltas para quedar por debajo de 100 kHz.

¿Un detector de metales casero distingue el oro del hierro?

En parte. El hierro y el acero aumentan la inductancia y bajan la frecuencia, mientras que el oro, la plata, el cobre y el aluminio la suben; el código lo distingue con un tono grave y otro agudo. Pero con este método sencillo no se puede diferenciar un anillo de oro chico de un trozo de papel aluminio; para eso hace falta la medición de fase de los detectores VLF.

¿Se puede hacer un detector de metales de inducción de pulsos (PI) con Arduino?

Sí, pero es un proyecto más difícil. Tienes que manejar la bobina con pulsos mediante un MOSFET, amortiguar con seguridad los cientos de voltios que aparecen al cortar la corriente y medir el tiempo de caída con precisión de microsegundos. A cambio obtienes un detector mucho más profundo y estable en suelos mineralizados y en arena húmeda.

¿Por qué mi detector de metales pita solo?

La causa más común es la deriva por temperatura: en los primeros minutos el integrado, los capacitores y la bobina se calientan y la frecuencia se corre. Usa capacitores de película, sujeta bien la bobina con cinta, espera unos minutos y vuelve a poner en cero. Un cable o un bobinado que se mueve y el ruido de cargadores cercanos también generan señales falsas.

¿Qué capacitor conviene usar en un detector de metales?

Lo mejor son los capacitores de película, de poliéster o polipropileno, porque su valor casi no cambia con la temperatura. Los cerámicos X7R o Y5V varían varios por ciento al calentarse, y eso corre la frecuencia como si se acercara un metal. Si vas a usar un cerámico, elige uno del tipo C0G (NP0).

Ver todos los proyectos
Uso del zumbador
AR-13Principiante

Uso del zumbador

¿Alguna vez te has preguntado cómo suena un timbre o una alarma? El Arduino hace pitar un pequeño zumbador a intervalos cortos: pip, silencio, pip, silencio.

4.7(92)
171
Ajuste de frecuencia con zumbador
AR-14Intermedio

Ajuste de frecuencia con zumbador

Controlas el sonido de un zumbador con cuatro botones: uno lo enciende, otro lo calla y los otros dos lo hacen más agudo o más grave.

4.6(69)
120
Sensor de aparcamiento con HC-SR04
AR-28Intermedio
Premium

Sensor de aparcamiento con HC-SR04

Una versión en miniatura del sensor de aparcamiento de los coches: cuanto más se acerca algo, más rápidos son los pitidos.

4.8(64)
86
Lectura de un interruptor reed
AR-37Principiante

Lectura de un interruptor reed

¿Alguna vez te has preguntado cómo funciona el interruptor magnético de las alarmas de puertas y ventanas?

4.5(22)
29
Sensor de puerta con interruptor reed
AR-38Principiante
Premium

Sensor de puerta con interruptor reed

Sabe si tu puerta está abierta o cerrada con solo mirar una luz. Pones un pequeño imán en la puerta y en el marco un interruptor que nota los imanes; con la puerta cerrada quedan juntos y se enciende…

4.7(34)
44
Sensor de aparcamiento ESP32 (HC-SR04 + barra de 5 LED + zumbador + OLED)
ES-38Avanzado
Premium

Sensor de aparcamiento ESP32 (HC-SR04 + barra de 5 LED + zumbador + OLED)

¡La versión ESP32 de un sensor de aparcamiento! El sensor ultrasónico HC-SR04 mide la distancia al objeto que tiene delante. Cuanto más cerca está, más se llena una barra de 5 LED (verde → amarillo → rojo) y más rápido pita el zumbador. Muy cerca (por debajo de 10 cm) suena una alarma continua y se encienden todos los LED. La OLED SSD1306 muestra los cm en tiempo real con letra grande y un texto de estado.

14
LED Parpadeante con ESP32
ES-1Principiante

LED Parpadeante con ESP32

Enseña el uso básico de la salida GPIO con ESP32. Conseguimos un efecto de parpadeo encendiendo y apagando un LED desde el pin digital. Versión para ESP32 del clásico proyecto blink en Arduino UNO; los comandos básicos de blink en el entorno Arduino son los mismos, pero la distribución de pines y los niveles GPIO de 3,3 V del ESP32 difieren de los del Arduino UNO.

4.7(37)
108