Envío en 1 a 2 días hábiles en productos disponibles

Troxino
Categorías

El proyecto de fin de semana · 4 de noviembre 2026

La planta que avisa cuando tiene sed

Un sensor clavado en la maceta mide qué tan húmeda está la tierra. Tres LEDs te dicen cómo va (verde: bien, amarillo: pronto, rojo: tiene sed) y, cuando la tierra se seca, un buzzer hace un pitido para que no se te olvide regarla.

  • Nivel principiante
  • 2 a 3 horas
  • 12 materiales

Sin soldar (Nano con pines soldados en protoboard y cables DuPont).

Ver la lista de materiales
La planta que avisa cuando tiene sed

Para qué sirve en la escuela

  • Feria de ciencias: junta biología y electrónica, y da datos medibles. Riega, anota la lectura cada hora en el Monitor Serie y grafica cómo se seca la tierra (o compara macetas con tierra, arena y composta).
  • Prepa y secundaria: práctica de entradas analógicas (analogRead), salidas digitales y condicionales if / else.
  • Ingeniería: introducción a sensores resistivos, calibración y por qué conviene alimentar un sensor solo cuando se lee (corrosión).

Cómo funciona

Qué vamos a hacer

Un medidor de humedad para tu maceta. El Arduino lee el sensor cada 2 segundos, decide si la tierra está bien, a punto de secarse o seca, y lo muestra con un LED de color. Si está seca, además pita una vez por minuto hasta que la riegues.

Cómo funciona

  • El sensor: la horquilla tiene dos patas de metal que no se tocan. Entre ellas solo hay tierra, y la tierra deja pasar más o menos corriente según cuánta agua tenga.
  • El módulo: convierte esa corriente en un voltaje entre 0 y 5 V en su pin AO. Con tierra seca el voltaje es alto; con tierra mojada, bajo.
  • El Arduino: analogRead(A0) convierte ese voltaje en un número de 0 a 1023. El código saca el promedio de varias lecturas y lo compara con dos umbrales: arriba de UMBRAL_PRONTO prende el amarillo, arriba de UMBRAL_SED prende el rojo y pita. Abajo de los dos, verde.
  • El buzzer: es pasivo, así que no suena solo. tone() lo prende y apaga miles de veces por segundo, y esa vibración es el sonido.

Por qué funciona

El agua pura casi no conduce la electricidad, pero el agua de la tierra trae sales disueltas que sí la conducen. Más agua es más camino para la corriente, o sea menos resistencia entre las dos patas. El módulo pone esa resistencia en serie con otra fija (un divisor de voltaje): cuando la del sensor baja, el voltaje de salida baja también. Por eso el número sube cuando la tierra se seca.

Cada tierra conduce distinto, y por eso hay que calibrar: los umbrales son tus propios números de "seca" y "recién regada".

El sensor no se alimenta de los 5 V fijos, sino del pin D7, y solo durante la lectura. Una corriente que pasa todo el tiempo por metal húmedo lo va comiendo: es electrólisis, y una de las patas se oxida y se deshace poco a poco. Prenderlo unos milisegundos cada 2 segundos hace que dure mucho más.

Los LEDs llevan resistencia porque un LED solo no limita su corriente: con 5 V directos se quemaría. Con 220 Ω, la ley de Ohm deja la corriente entre 9 y 13 mA (depende del color), suficiente para que brille y segura para el LED y para el pin.

Conexiones

El Nano va a lo largo de la protoboard, montado sobre el canal central (una fila de pines de cada lado). Usa el riel azul (−) de abajo como tierra común. Las resistencias brincan el canal central y los LEDs y el buzzer quedan del otro lado, con su pata − en el riel.

Vista completa en la protoboard

Pieza Pin de la pieza A dónde va
Nano GND Riel − de la protoboard
Módulo YL-69 VCC Nano D7 (lo prendemos solo al medir)
Módulo YL-69 GND Riel −
Módulo YL-69 AO Nano A0
Módulo YL-69 DO Sin conectar
Horquilla YL-69 2 pines Los 2 pines del módulo, con el cablecito que trae el sensor
LED verde Pata larga (+) Resistencia de 220 Ω → Nano D3
LED amarillo Pata larga (+) Resistencia de 220 Ω → Nano D4
LED rojo Pata larga (+) Resistencia de 220 Ω → Nano D5
Los 3 LEDs Pata corta (−) Riel −
Buzzer pasivo + (pata marcada o más larga) Resistencia de 100 Ω → Nano D9
Buzzer pasivo − Riel −

Corrientes: los LEDs rojo y amarillo quedan en unos 13 mA y el verde en unos 9 mA; el buzzer, con su resistencia de 100 Ω, por debajo de 20 mA. Todo dentro de lo que aguanta un pin del Nano.

Paso a paso

  1. 01

    Monta el Nano sobre el canal central de la protoboard, con el conector USB hacia afuera. Presiona parejo hasta que entren todos los pines.

  2. 02

    Tierra común: con un cable macho-macho, une el pin GND del Nano al riel − de la protoboard.

  3. 03

    Los tres LEDs: colócalos del lado libre de la protoboard. Pata corta al riel −, pata larga a una fila con su resistencia de 220 Ω, y de la resistencia un cable a D3 (verde), D4 (amarillo) y D5 (rojo).

  4. 04

    El buzzer: pata − al riel −; pata + a una resistencia de 100 Ω y de ahí un cable a D9.

  5. 05

    El sensor: conecta la horquilla al módulo con su cablecito. Del módulo a la protoboard usa cables macho-hembra de 20 cm: VCC a D7, GND al riel − y AO a A0. DO se queda libre.

  6. 06

    Sube el código: conecta el Nano por USB, en el IDE elige Arduino Nano y el puerto. Si no sube, cambia el procesador a ATmega328P (Old Bootloader).

  7. 07

    Calibra: abre el Monitor Serie a 9600. Anota la lectura con la horquilla al aire (seca, cerca de 1000) y metida en un vaso con agua (cerca de 300 a 400). Ajusta UMBRAL_PRONTO y UMBRAL_SED con tu tierra: seca vs. recién regada. Vuelve a subir el código para que tome los números nuevos.

  8. 08

    A la maceta: clava la horquilla en la tierra hasta la mitad, sin mojar el módulo ni los cables. Deja el Nano conectado por USB, a la laptop o a un cargador de celular, porque de ahí toma la corriente. Listo: la planta ya te avisa.

El paso a paso en imágenes

La planta que avisa cuando tiene sed, imagen 1 La planta que avisa cuando tiene sed, imagen 2 La planta que avisa cuando tiene sed, imagen 3 La planta que avisa cuando tiene sed, imagen 4 La planta que avisa cuando tiene sed, imagen 5 La planta que avisa cuando tiene sed, imagen 6

Código planta-con-sed.ino

Ver en GitHub

Ábrelo en el Arduino IDE, elige tu placa y puerto, y súbelo con la flecha.

// La planta que avisa cuando tiene sed
// El proyecto de fin de semana · Troxino.com
//
// Lectura del sensor: más alta = tierra más seca.
// Verde: bien · Amarillo: pronto toca regar · Rojo + pitido: tiene sed.

const int PIN_SENSOR_VCC = 7;   // alimenta el módulo solo al medir
const int PIN_SENSOR     = A0;  // salida analógica del módulo (AO)
const int LED_VERDE      = 3;
const int LED_AMARILLO   = 4;
const int LED_ROJO       = 5;
const int PIN_BUZZER     = 9;

// Ajusta estos dos números con lo que veas en el Monitor Serie.
const int UMBRAL_PRONTO = 550;  // de aquí para arriba: amarillo
const int UMBRAL_SED    = 750;  // de aquí para arriba: rojo y pitido

const unsigned long CADA_LECTURA = 2000;   // ms entre lecturas
const unsigned long CADA_AVISO   = 60000;  // ms entre pitidos mientras siga seca

unsigned long ultimoAviso = 0;
bool teniaSed = false;

// Prende el módulo, promedia 5 lecturas y lo vuelve a apagar.
// Así pasa corriente por la horquilla solo un instante y se corroe mucho menos.
int leerHumedad() {
  digitalWrite(PIN_SENSOR_VCC, HIGH);
  delay(10);  // deja que se estabilice

  long suma = 0;
  for (int i = 0; i < 5; i++) {
    suma += analogRead(PIN_SENSOR);
    delay(5);
  }

  digitalWrite(PIN_SENSOR_VCC, LOW);
  return suma / 5;
}

// Deja prendido solo el LED que le pases.
void mostrar(int led) {
  digitalWrite(LED_VERDE, led == LED_VERDE ? HIGH : LOW);
  digitalWrite(LED_AMARILLO, led == LED_AMARILLO ? HIGH : LOW);
  digitalWrite(LED_ROJO, led == LED_ROJO ? HIGH : LOW);
}

// Tres pitidos cortos y agudos, como un grillo.
void pitido() {
  for (int i = 0; i < 3; i++) {
    tone(PIN_BUZZER, 2800, 60);
    delay(130);
  }
}

void setup() {
  pinMode(PIN_SENSOR_VCC, OUTPUT);
  digitalWrite(PIN_SENSOR_VCC, LOW);
  pinMode(LED_VERDE, OUTPUT);
  pinMode(LED_AMARILLO, OUTPUT);
  pinMode(LED_ROJO, OUTPUT);
  pinMode(PIN_BUZZER, OUTPUT);

  Serial.begin(9600);
  Serial.println("Planta lista. Lectura: alta = seca, baja = humeda.");

  // Prueba rápida al arrancar: los tres LEDs y un pitido.
  mostrar(LED_VERDE);    delay(250);
  mostrar(LED_AMARILLO); delay(250);
  mostrar(LED_ROJO);     delay(250);
  tone(PIN_BUZZER, 2000, 100);
}

void loop() {
  int lectura = leerHumedad();
  Serial.print("Lectura: ");
  Serial.println(lectura);

  if (lectura >= UMBRAL_SED) {
    mostrar(LED_ROJO);
    unsigned long ahora = millis();
    // Pita en cuanto se seca y luego cada minuto, no sin parar.
    if (!teniaSed || ahora - ultimoAviso >= CADA_AVISO) {
      pitido();
      ultimoAviso = ahora;
    }
    teniaSed = true;
  } else if (lectura >= UMBRAL_PRONTO) {
    mostrar(LED_AMARILLO);
    teniaSed = false;
  } else {
    mostrar(LED_VERDE);
    teniaSed = false;
  }

  delay(CADA_LECTURA);
}

Cómo probarlo

  1. Al conectar el Nano, los tres LEDs se prenden uno tras otro y suena un pitido: el cableado de LEDs y buzzer está bien.
  2. Con la horquilla al aire debe quedar en rojo y pitar.
  3. Métela en un vaso con agua: pasa a verde en un par de segundos.
  4. Sácala y sécala con un trapo: vuelve a rojo. Con la mano húmeda tocando las dos patas debería quedar en amarillo o verde.

Problemas comunes

  • Siempre en rojo, aun en agua: revisa que VCC del módulo vaya a D7 (no a 5V suelto ni a nada) y AO a A0, no DO.
  • Siempre en verde: quizá conectaste DO en lugar de AO, o los umbrales no van con tu tierra. Mira los números en el Monitor Serie y ajusta.
  • No sube el código: elige ATmega328P (Old Bootloader) y, si la computadora no ve el puerto, instala el driver CH340.
  • Un LED no prende: está al revés (la pata larga va hacia la resistencia) o su resistencia no comparte fila con él.
  • El buzzer no suena o suena muy bajito: que sea el pasivo (el código usa tone), con su pata + hacia D9.
  • La horquilla se pone verde o negra con las semanas: es corrosión normal de este tipo de sensor; por eso solo la prendemos al leer. Para algo que dure meses, usa el sensor resistente a la corrosión.

Para mejorarlo

  • Riego automático: agrega un relevador y una mini bomba de agua para que riegue sola cuando llegue a rojo.
  • Gráfica para la feria: usa el Serial Plotter del IDE para ver cómo se seca la tierra a lo largo del día.
  • Modo noche: agrega una fotorresistencia para que el pitido no suene cuando está oscuro.

¿Te atoraste?

Escríbenos por WhatsApp con una foto de tus conexiones y te ayudamos.

Escríbenos por WhatsApp Ver más proyectos

Cookies

Usamos cookies para tu sesión y tu carrito, y Google Analytics y Microsoft Clarity para ver qué funciona en la tienda. Nada de publicidad. Aviso de privacidad