Caso práctico: ventilación de invernadero con Arduino UNO

Objetivo y caso de uso

Qué construirás: Construirás un controlador de ventilación de invernadero automatizado e independiente que ajusta dinámicamente una compuerta de ventilación física mediante un servomotor en función de la temperatura ambiente. El sistema incorpora una anulación de hardware manual y lógica de histéresis para evitar la oscilación mecánica.

Por qué es importante / Casos de uso

Automatización agrícola: Regula invernaderos a pequeña escala de forma autónoma, eliminando la necesidad de monitoreo humano constante para prevenir el estrés de las plantas.
Implementación de histéresis: Utiliza umbrales de temperatura superior e inferior distintos (por ejemplo, abrir la compuerta a 26°C, cerrar a 22°C) para estabilizar el sistema y evitar el desgaste del servo por cambios rápidos.
Anulaciones de seguridad: Proporciona una derivación manual basada en hardware (mediante un interruptor de fin de carrera) para control inmediato durante emergencias o mantenimiento de rutina.

Resultado esperado

Un sistema de bucle cerrado que acciona un servo de 0° (cerrado) a 90° (abierto) con una latencia de respuesta de <50ms cuando se cruzan los umbrales de temperatura.
Funcionamiento mecánico suave y sin vibraciones en los límites de temperatura gracias a la histéresis programada.
Respuesta mecánica inmediata al interruptor de fin de carrera, reemplazando toda la lógica automatizada del sensor con latencia casi nula.

Audiencia: Makers, estudiantes de tecnología agrícola y desarrolladores de sistemas embebidos; Nivel: Principiante a Intermedio

Arquitectura/flujo: Sensor de temperatura (Entrada analógica) ➔ Microcontrolador (Lógica de histéresis e interrupciones de hardware) ➔ Salida PWM ➔ Actuador de servomotor

Nota educativa de validación

Antes de publicar este caso, el contenido pasó la puerta automática de validación de Prometeo con estado PASS. El validador comprobó los bloques de código, la estructura del artículo, los comandos copiables y la coherencia con el catálogo de dispositivos soportados.

Evidencia de validación publicada

Resultado automático: PASS.
Estructura parseada: 3 apartados, 3 tablas y 2 bloques de código detectados antes de publicar.
Código comprobado: 1 Arduino/arduino-cli compile, 1 Bash/copy-paste checks.
Catálogo soportado: el texto se contrastó contra los perfiles de dispositivo validables de Prometeo y los stacks no soportados bloquean la publicación.
Hallazgos del informe: sin hallazgos bloqueantes.

Esta validación confirma compatibilidad sintáctica y de herramientas para el material publicado, pero no sustituye la prueba física sobre tu hardware, cableado y entorno exactos.

Nota educativa de seguridad

Este proyecto es un prototipo educativo de bajo voltaje, no un producto certificado. Antes de encender la configuración, verifique el cableado de su Arduino UNO R3, evite cortocircuitar los 5V, GND o pines digitales, desconecte la alimentación antes de cambiar las conexiones y use módulos de interfaz adecuados para relés, motores o cargas externas.

Requisitos previos

Para completar con éxito este tutorial, debe tener:
* Una comprensión básica de cómo usar la línea de comandos/terminal en su sistema operativo.
* La CLI (Interfaz de línea de comandos) de Arduino instalada en su computadora.
* Familiaridad básica con placas de pruebas (protoboards) y conexiones de cables puente (jumpers).
* Un cable USB Tipo-B estándar para conectar el Arduino UNO a su computadora.

Materiales

Para este proyecto, debe usar EXACTAMENTE este modelo de dispositivo y lista de componentes:
* Microcontrolador: Arduino UNO R3 (ATmega328P)
* Actuador: Micro servomotor SG90
* Sensor: Sensor de temperatura analógico LM35 (encapsulado TO-92)
* Dispositivo de entrada: Interruptor de fin de carrera (microinterruptor estándar con palanca de rodillo o botón pulsador básico)
* Accesorios: 1x Placa de pruebas (protoboard) sin soldadura, varios cables puente macho a macho.

Nota: No se requieren resistencias externas para el interruptor de fin de carrera porque utilizaremos las resistencias pull-up internas del ATmega328P mediante software.

Configuración/Conexión

Un cableado adecuado es fundamental para la estabilidad de las lecturas analógicas y los movimientos del servo. El LM35 proporciona una salida de voltaje analógico lineal proporcional a la temperatura (10mV por grado Celsius). El servo SG90 se controla mediante Modulación por Ancho de Pulso (PWM), y el interruptor de fin de carrera utiliza una entrada digital simple.

Tabla de cableado

Componente	Pin / Color del cable	Pin del Arduino UNO R3	Función / Notas
LM35	Pin 1 (Izquierdo, cara plana hacia arriba)	5V	Fuente de alimentación para el sensor de temperatura.
LM35	Pin 2 (Medio)	A0	Señal de salida analógica (10mV/°C).
LM35	Pin 3 (Derecho)	GND	Referencia de tierra.
Servo SG90	Cable rojo	5V	Fuente de alimentación para el servomotor.
Servo SG90	Cable marrón / negro	GND	Referencia de tierra.
Servo SG90	Cable naranja / amarillo	D9	Señal PWM para controlar el ángulo del servo.
Interruptor de fin de carrera	COM (Común)	GND	Referencia de tierra para el interruptor.
Interruptor de fin de carrera	NO (Normalmente Abierto)	D2	Entrada digital. En estado ALTO (HIGH) internamente; cambia a BAJO (LOW) al presionarse.

Instrucciones de conexión

Distribución de energía: Conecte el pin de 5V del Arduino al riel positivo de su placa de pruebas. Conecte el pin GND del Arduino al riel negativo.
Sensor LM35: Inserte el LM35 en la placa de pruebas. Con el lado plano mirándolo a usted, conecte el pin izquierdo al riel de 5V, el pin derecho al riel GND y el pin central directamente al pin analógico A0 del Arduino.
Servo SG90: Conecte los cables de alimentación del servo (rojo a 5V, marrón/negro a GND) a los rieles de la placa de pruebas. Conecte el cable de señal (naranja/amarillo) al pin digital D9 del Arduino.
Interruptor de fin de carrera: Conecte el terminal Común (COM) del interruptor de fin de carrera al riel GND. Conecte el terminal Normalmente Abierto (NO) al pin digital D2 del Arduino.

Código validado

La siguiente sección contiene el sketch de Arduino completo y compilable y un script de shell de Bash utilizado para automatizar el proceso de compilación y carga mediante la CLI de Arduino.

Sketch de Arduino: greenhouse_vent.ino

Cree un directorio llamado greenhouse_vent y guarde este código dentro como greenhouse_vent.ino.

Vista pública parcial del archivo validado. El código completo se muestra a miembros y en PDF/Print.

/*
 * Greenhouse Vent Servo Controller
 * Device: Arduino UNO R3 (ATmega328P) + SG90 servo + LM35 temperature sensor + limit switch
 * 
 * Description: Reads temperature from LM35. Opens vent (servo 90 deg) if temp >= 28C.
 * Closes vent (servo 0 deg) if temp <= 25C. 
 * A limit switch on D2 acts as a manual override to force the vent open.
 */

#include <Servo.h>

// Pin Definitions
const int lm35Pin = A0;
const int limitSwitchPin = 2;
const int servoPin = 9;

// Servo Object
Servo ventServo;

// Configuration Constants
const float TEMP_OPEN_THRESHOLD = 28.0;
const float TEMP_CLOSE_THRESHOLD = 25.0;
const int ANGLE_CLOSED = 0;
const int ANGLE_OPEN = 90;

// Timing Variables for non-blocking execution
unsigned long lastUpdateMillis = 0;
const unsigned long UPDATE_INTERVAL_MS = 1000;

// State Tracking
bool ventIsOpen = false;

void setup() {
  // Initialize Serial Monitor
  Serial.begin(9600);
  while (!Serial) {
    ; // Wait for serial port to connect
  }

  // Configure Pins
  // Internal pull-up ensures the pin reads HIGH when the switch is unpressed.
  // When pressed, the switch connects the pin to GND, reading LOW.
  pinMode(limitSwitchPin, INPUT_PULLUP);

  // Attach and initialize servo to closed position
  ventServo.attach(servoPin);
  ventServo.write(ANGLE_CLOSED);

  Serial.println("========================================");
  Serial.println("Greenhouse Vent Controller Initialized");
  Serial.println("========================================");
}
// ...


void loop() {
  unsigned long currentMillis = millis();

  // Execute control logic at defined intervals
  if (currentMillis - lastUpdateMillis >= UPDATE_INTERVAL_MS) {
    lastUpdateMillis = currentMillis;

    // 1. Read Manual Override Limit Switch
    // LOW means the switch is pressed (override active)
    bool overrideActive = (digitalRead(limitSwitchPin) == LOW);

    // 2. Read and Calculate Temperature from LM35
    int rawADC = analogRead(lm35Pin);

    // The Arduino UNO has a 10-bit ADC (0-1023) and operates at 5.0V.
    // Voltage = (ADC Value / 1024.0) * 5.0
    float voltage = rawADC * (5.0 / 1024.0);

    // LM35 outputs 10mV per degree Celsius (0.01V/C)
    // Temperature (C) = Voltage / 0.01 = Voltage * 100.0
    float temperatureC = voltage * 100.0;

    // 3. Determine Target Vent State
    if (overrideActive) {
      // Manual override forces the vent open
      ventIsOpen = true;
    } else {

🔒 Este contenido es premium. Con la suscripción mensual (7 días gratis) podrás desbloquear el material didáctico completo y el pack PDF listo para imprimir.🔓 Desbloquéalo — 7 días gratis

/*
 * Greenhouse Vent Servo Controller
 * Device: Arduino UNO R3 (ATmega328P) + SG90 servo + LM35 temperature sensor + limit switch
 * 
 * Description: Reads temperature from LM35. Opens vent (servo 90 deg) if temp >= 28C.
 * Closes vent (servo 0 deg) if temp <= 25C. 
 * A limit switch on D2 acts as a manual override to force the vent open.
 */

#include <Servo.h>

// Pin Definitions
const int lm35Pin = A0;
const int limitSwitchPin = 2;
const int servoPin = 9;

// Servo Object
Servo ventServo;

// Configuration Constants
const float TEMP_OPEN_THRESHOLD = 28.0;
const float TEMP_CLOSE_THRESHOLD = 25.0;
const int ANGLE_CLOSED = 0;
const int ANGLE_OPEN = 90;

// Timing Variables for non-blocking execution
unsigned long lastUpdateMillis = 0;
const unsigned long UPDATE_INTERVAL_MS = 1000;

// State Tracking
bool ventIsOpen = false;

void setup() {
  // Initialize Serial Monitor
  Serial.begin(9600);
  while (!Serial) {
    ; // Wait for serial port to connect
  }

  // Configure Pins
  // Internal pull-up ensures the pin reads HIGH when the switch is unpressed.
  // When pressed, the switch connects the pin to GND, reading LOW.
  pinMode(limitSwitchPin, INPUT_PULLUP);

  // Attach and initialize servo to closed position
  ventServo.attach(servoPin);
  ventServo.write(ANGLE_CLOSED);

  Serial.println("========================================");
  Serial.println("Greenhouse Vent Controller Initialized");
  Serial.println("========================================");
}

void loop() {
  unsigned long currentMillis = millis();

  // Execute control logic at defined intervals
  if (currentMillis - lastUpdateMillis >= UPDATE_INTERVAL_MS) {
    lastUpdateMillis = currentMillis;

    // 1. Read Manual Override Limit Switch
    // LOW means the switch is pressed (override active)
    bool overrideActive = (digitalRead(limitSwitchPin) == LOW);

    // 2. Read and Calculate Temperature from LM35
    int rawADC = analogRead(lm35Pin);

    // The Arduino UNO has a 10-bit ADC (0-1023) and operates at 5.0V.
    // Voltage = (ADC Value / 1024.0) * 5.0
    float voltage = rawADC * (5.0 / 1024.0);

    // LM35 outputs 10mV per degree Celsius (0.01V/C)
    // Temperature (C) = Voltage / 0.01 = Voltage * 100.0
    float temperatureC = voltage * 100.0;

    // 3. Determine Target Vent State
    if (overrideActive) {
      // Manual override forces the vent open
      ventIsOpen = true;
    } else {
      // Temperature-based hysteresis control
      if (temperatureC >= TEMP_OPEN_THRESHOLD) {
        ventIsOpen = true;
      } else if (temperatureC <= TEMP_CLOSE_THRESHOLD) {
        ventIsOpen = false;
      }
      // If temperature is between 25.0 and 28.0, ventIsOpen remains unchanged.
    }

    // 4. Actuate Servo
    if (ventIsOpen) {
      ventServo.write(ANGLE_OPEN);
    } else {
      ventServo.write(ANGLE_CLOSED);
    }

    // 5. Log System State
    Serial.print("Temp: ");
    Serial.print(temperatureC, 1);
    Serial.print(" C | Override: ");
    Serial.print(overrideActive ? "ACTIVE " : "STANDBY");
    Serial.print(" | Vent State: ");
    Serial.println(ventIsOpen ? "OPEN  (90 deg)" : "CLOSED (0 deg)");
  }
}

Script de automatización: build_and_upload.sh

Guarde este archivo en el directorio principal de greenhouse_vent (o ajuste las rutas en consecuencia). Este script asegura que el núcleo Arduino AVR esté instalado, compila el código y lo carga en la placa.

#!/bin/bash

# Define the FQBN for Arduino UNO R3
FQBN="arduino:avr:uno"

# Define the serial port (Change this to match your system, e.g., /dev/ttyACM0 or COM3)
PORT="/dev/ttyACM0"

# Define the sketch directory
SKETCH_DIR="greenhouse_vent"

echo "Updating Arduino CLI core index..."
arduino-cli core update-index

echo "Installing Arduino AVR core..."
arduino-cli core install arduino:avr

echo "Compiling sketch..."
arduino-cli compile --fqbn $FQBN $SKETCH_DIR

if [ $? -eq 0 ]; then
    echo "Compilation successful. Uploading to $PORT..."
    arduino-cli upload --fqbn $FQBN --port $PORT $SKETCH_DIR

    if [ $? -eq 0 ]; then
        echo "Upload complete! Open serial monitor at 9600 baud."
    else
        echo "Upload failed. Please check the PORT and connection."
    fi
else
    echo "Compilation failed. Please check the source code."
fi

Comandos de compilación/flasheo/ejecución

Para desplegar el código en su Arduino UNO R3, utilizará la CLI de Arduino. A continuación se muestran los comandos exactos utilizados por el script de automatización, que también puede ejecutar manualmente.

Tabla de referencia de comandos

Acción	Comando
Actualizar índice del núcleo	`arduino-cli core update-index`
Instalar núcleo AVR	`arduino-cli core install arduino:avr`
Compilar sketch	`arduino-cli compile --fqbn arduino:avr:uno greenhouse_vent`
Cargar en la placa	`arduino-cli upload --fqbn arduino:avr:uno --port <PORT> greenhouse_vent`
Monitorizar salida	`arduino-cli monitor --port <PORT> --config baudrate=9600`

Flujo de trabajo numerado

Conecte su Arduino UNO R3 a su computadora a través del cable USB.
Identifique su puerto serie. En Linux, este es típicamente /dev/ttyACM0 o /dev/ttyUSB0. En Windows, será un puerto COM como COM3. Puede encontrarlo ejecutando arduino-cli board list.
Abra su terminal y navegue hasta el directorio que contiene su carpeta greenhouse_vent.
Ejecute el comando de compilación: arduino-cli compile --fqbn arduino:avr:uno greenhouse_vent.
Ejecute el comando de carga, reemplazando <PORT> con su puerto real: arduino-cli upload --fqbn arduino:avr:uno --port /dev/ttyACM0 greenhouse_vent.
Inicie el monitor serie para ver los registros: arduino-cli monitor --port /dev/ttyACM0 --config baudrate=9600.

Validación paso a paso

Una vez que el código esté cargado y el monitor serie esté en ejecución, realice los siguientes puntos de control de validación para asegurarse de que la lógica y el hardware funcionen correctamente.

Punto de control 1: Inicialización y estado de reposo
- Acción: Observe el monitor serie inmediatamente después de la carga, con la temperatura ambiente por debajo de 25°C.
- Observación esperada: El monitor serie imprime el banner de inicialización. El servo se mueve a la posición de 0 grados. Los registros indican una temperatura por debajo de 25.0°C, Override: STANDBY y Vent State: CLOSED.
- Condición de aprobación: El servo está físicamente en la posición cero y los registros reflejan el estado cerrado con precisión.
Punto de control 2: Calentamiento (Cruzando el umbral superior)
- Acción: Pellizque suavemente el sensor LM35 entre sus dedos para elevar su temperatura. Observe el monitor serie.
- Observación esperada: La temperatura registrada aumentará de manera constante. Una vez que alcance 28.0°C o más, el estado de ventilación (Vent State) cambiará a OPEN.
- Condición de aprobación: El servo SG90 gira físicamente 90 grados inmediatamente cuando el registro muestra una temperatura $\ge$ 28.0°C.
Punto de control 3: Verificación de histéresis (Enfriamiento)
- Acción: Suelte el LM35 y permita que se enfríe. Observe los registros a medida que la temperatura desciende entre 27.9°C y 25.1°C.
- Observación esperada: La temperatura desciende, pero el estado de ventilación (Vent State) permanece en OPEN. El servo no se mueve.
- Condición de aprobación: El sistema mantiene su estado actual mientras se encuentra en la banda muerta de histéresis, evitando una oscilación mecánica rápida.
Punto de control 4: Cruzando el umbral inferior
- Acción: Continúe dejando que el sensor se enfríe (o sople suavemente sobre él) hasta que la temperatura descienda a 25.0°C o menos.
- Observación esperada: El registro actualiza el estado de ventilación (Vent State) a CLOSED.
- Condición de aprobación: El servo gira físicamente de vuelta a la posición de 0 grados.
Punto de control 5: Activación de anulación manual
- Acción: Mientras la temperatura esté por debajo de 25°C (ventilación normalmente cerrada), mantenga presionado el interruptor de fin de carrera.
- Observación esperada: El siguiente registro serie (dentro de 1 segundo) muestra Override: ACTIVE y Vent State: OPEN.
- Condición de aprobación: El servo se mueve inmediatamente a 90 grados a pesar de la temperatura fría. Al soltar el interruptor, el servo debería volver a 0 grados en el siguiente ciclo.

Solución de problemas

Si su prototipo no se comporta como se esperaba, consulte la tabla a continuación para ver problemas comunes y sus soluciones.

Síntoma	Causa probable	Solución
El LM35 lee ~0°C o ~500°C constantemente	Sensor cableado al revés o tierra flotante.	Desconecte la alimentación inmediatamente. Compruebe la cara plana del LM35. Izquierda es 5V, Derecha es GND, Centro es A0. Vuelva a asentar los cables puente.
Las lecturas de temperatura fluctúan bruscamente (±5°C)

Encuentra este producto y/o libros sobre este tema en Amazon

Ir a Amazon

Como afiliado de Amazon, gano con las compras que cumplan los requisitos. Si compras a través de este enlace, ayudas a mantener este proyecto.

Carlos Núñez Zorrilla

Electronics & Computer Engineer

Ingeniero Superior en Electrónica de Telecomunicaciones e Ingeniero en Informática (titulaciones oficiales en España).

Sígueme:

¿Quiénes somos?