Saltar al contenido
Nivel inicial

Pulverizador automático por tiempo

Conectar el servomotor

Empezamos conectando el servomotor, que será el encargado de apretar el gatillo del pulverizador. El servo es un motor con un sistema de control que le permite ubicarse en un ángulo específico y mantenerse ahí; tiene tres cables: dos de alimentación (negro/marrón para GND y rojo para VCC) y uno de señal (naranja o amarillo) que lleva la orden de ángulo desde la placa.

Esquema de conexión: placa Arduino UNO con el cable de señal del servo (amarillo) al pin 3, y la alimentación del servo (rojo y negro) a los pines 5V y GND a través de la protoboard.
Conexión del servomotor a la placa: la señal al pin indicado por PIN_SERVO y la alimentación a 5V y GND (figura original del proyecto).

En el Arduino UNO, el cable de señal (amarillo) del servo va al pin 3 —el que indica la constante PIN_SERVO al comienzo del código— y la alimentación se toma directamente de la placa: el cable rojo al pin de 5 V y el negro a GND.

En el ESP32, el cable de señal del servo va al GPIO 13 (el que indica PIN_SERVO), un pin seguro para esta salida. Una diferencia importante de alimentación: el GPIO entrega 3,3 V de señal, que alcanza para controlar el servo, pero el motor del servo consume más de lo que la placa puede dar. Por eso el servo se alimenta a 5 V desde una fuente aparte, compartiendo el GND con el ESP32. Nunca inyectes 5 V en un GPIO.

Programar el servomotor (posición 90°)

Para mover el servo hay que programarlo. Lo haremos directamente en el lenguaje de Arduino (C++), usando el Arduino IDE en su versión 2.x, que se descarga gratis desde arduino.cc/en/software. Un programa de Arduino se llama sketch y tiene dos bloques: la función setup(), que se ejecuta una sola vez al inicializarse el dispositivo, y la función loop(), que se repite después. Después de // se escriben comentarios para el lector, que no tienen efecto en el programa.

Controlar el servo es sencillo: se usa una librería que lo maneja, se le dice en el setup() a qué pin está conectado (attach) y después se le ordena un ángulo con write. Para empezar, vamos a llevarlo a 90° —la posición de disparo, con la que el mecanismo apretará el gatillo— y a comprobar que responde.

En el Arduino UNO, la librería que maneja el servo es Servo.h (viene incluida con el IDE). Con servoGatillo.attach(PIN_SERVO) le indicamos el pin y con servoGatillo.write(90) lo mandamos a 90°.

En el ESP32, la Servo.h estándar no sirve (es solo para placas AVR como el UNO): se usa la librería ESP32Servo, que se instala una vez desde el gestor de bibliotecas del IDE (buscá “ESP32Servo”). El código es idéntico —attach y write—, solo cambia la librería que se incluye al principio.

Subir el código a la placa

Para subir el código a la placa, necesitamos:

  1. Conectar la placa a la computadora con el cable USB.
  2. Chequear que en el selector de placa del Arduino IDE esté seleccionada la placa correcta.
  3. Seleccionar el puerto al que está conectada la placa.
  4. Cliquear el botón Subir (la flecha →) en la parte superior de la interfaz.

En el Arduino IDE 2.x, la placa y el puerto se eligen juntos en el menú desplegable de la barra superior: al conectar la placa suele aparecer directamente como opción. Si no aparece, entrá a “Select other board and port” y buscala por nombre.

Para el Arduino UNO: usá el cable USB tipo B, elegí la placa Arduino UNO y el puerto que se agregó al conectarla (en Windows es un puerto COM numerado; en Linux suele llamarse /dev/ttyACM0 o similar).

Para el ESP32 hay dos pasos previos que se hacen una sola vez: instalar el soporte de placas ESP32 desde el gestor de placas del IDE (buscá “esp32” e instalá el paquete de Espressif) y, si el puerto no aparece, instalar el driver del conversor USB-serie de tu placa (generalmente CP210x o CH340). Después, elegí la placa ESP32 Dev Module (o “DOIT ESP32 DEVKIT V1”) y el puerto correspondiente. Si al subir el IDE queda esperando en “Connecting…”, mantené apretado el botón BOOT de la placa hasta que empiece la carga.

Al terminar de subir, veremos el mensaje de carga completada en la barra inferior del IDE y el servo se moverá a la posición de 90°.

Movimiento del servomotor (90° ↔ 0° cada 5 segundos)

Para que se accione el gatillo, necesitamos que el servo vaya y vuelva: gire a 90° para apretar (pulverizar) y regrese a para soltar, respetando intervalos de tiempo. Programaremos que lo haga cada 5 segundos para poder probarlo cómodamente; más adelante podés modificar ese intervalo según la necesidad de las góndolas. Como queremos que la acción se repita sin parar, va toda dentro de loop().

Ver el código completo · pulverizador-temporizado.ino
pulverizador-temporizado.ino Arduino UNO
// Pulverizador temporizado: el servomotor acciona el gatillo del pulverizador
// a intervalos fijos, sin ningún sensor. Es el mecanismo automático más
// simple: cada cierto tiempo el servo va a la posición de disparo (90°) para
// pulverizar y vuelve al reposo (0°). Así se mantiene la humedad de las
// góndolas de frutas y verduras sin intervención humana.
//
// SEGURIDAD: es una práctica de baja tensión. El servo y su electrónica
// trabajan a 5 V; el agua pulverizada sale a baja presión y NO debe tocar la
// placa, el servo ni las conexiones. Ubicar el circuito lejos del chorro.
//
// Plataforma: Arduino UNO.
// Conexión: cable de señal del servo (amarillo) → pin 3; alimentación del
// servo a 5V y GND de la placa.
//
// Basado en: código del Paso 4, Nivel Inicial — Pulverizador Automatizado,
// Saberes Digitales (INET/EDUCAR 2019).
// Modernización: se elimina el C generado por mBlock3 (angle_rad/angle_deg,
// _delay, _loop) y se usan constantes nombradas para los ángulos y tiempos.
// En este nivel el delay() bloqueante es la herramienta que ya conocemos y
// alcanza para un temporizador simple (fiel a la progresión original).

// En el UNO la librería es Servo.h; el #if mantiene el mismo archivo válido
// si se compilara para ESP32 (donde la librería correcta es ESP32Servo.h).
#if defined(ESP32)
  #include <ESP32Servo.h>
#else
  #include <Servo.h>
#endif

const int PIN_SERVO = 3;

// Ángulos del gatillo: 0° es el reposo (gatillo suelto) y 90° es el disparo
// (gatillo apretado = pulveriza). Son los ángulos del original.
const int ANGULO_REPOSO  = 0;
const int ANGULO_DISPARO = 90;

// Tiempos del ciclo. El original mantiene el gatillo apretado ~1 s y luego
// espera ~5 s hasta la próxima pulverización.
// NOTA DE AULA: son valores cortos a propósito para poder probar el mecanismo
// sin esperar. En un uso real se alargarían (por ejemplo, pulverizar cada
// varios minutos según la necesidad de las góndolas).
const unsigned long TIEMPO_DISPARO_MS       = 1000;  // gatillo apretado
const unsigned long TIEMPO_ENTRE_DISPAROS_MS = 5000;  // reposo entre riegos

Servo servoGatillo;

void setup() {
  servoGatillo.attach(PIN_SERVO);
  // Arranca en reposo para no pulverizar apenas se enciende.
  servoGatillo.write(ANGULO_REPOSO);
}

void loop() {
  // Aprieta el gatillo: pulveriza.
  servoGatillo.write(ANGULO_DISPARO);
  delay(TIEMPO_DISPARO_MS);

  // Suelta el gatillo y espera hasta el próximo ciclo.
  servoGatillo.write(ANGULO_REPOSO);
  delay(TIEMPO_ENTRE_DISPAROS_MS);
}
pulverizador-temporizado.ino ESP32
// Pulverizador temporizado: el servomotor acciona el gatillo del pulverizador
// a intervalos fijos, sin ningún sensor. Es el mecanismo automático más
// simple: cada cierto tiempo el servo va a la posición de disparo (90°) para
// pulverizar y vuelve al reposo (0°). Así se mantiene la humedad de las
// góndolas de frutas y verduras sin intervención humana.
//
// SEGURIDAD: es una práctica de baja tensión. El servo y su electrónica
// trabajan a baja tensión; el agua pulverizada sale a baja presión y NO debe
// tocar la placa, el servo ni las conexiones. Ubicar el circuito lejos del
// chorro.
//
// Plataforma: ESP32 (DevKit v1).
// Conexión: cable de señal del servo (amarillo) → GPIO 13; alimentación del
// servo (ver nota eléctrica). El ESP32 trabaja a 3,3 V en sus GPIO: la señal
// de control sale a 3,3 V. El servo se alimenta a 5 V desde una fuente aparte
// con GND común; nunca inyectar 5 V en un GPIO.
//
// Basado en: código del Paso 4, Nivel Inicial — Pulverizador Automatizado,
// Saberes Digitales (INET/EDUCAR 2019).
// Modernización: se elimina el C generado por mBlock3 (angle_rad/angle_deg,
// _delay, _loop) y se usan constantes nombradas. Portado a ESP32 con la
// librería ESP32Servo (la Servo.h estándar es solo para AVR) y un GPIO seguro
// (13) en lugar del pin 3 del UNO. En este nivel el delay() bloqueante es la
// herramienta que ya conocemos y alcanza para un temporizador simple.

// En el ESP32 la librería correcta es ESP32Servo.h; el #if selecciona la
// librería según la placa para mantener un único archivo válido en ambas.
#if defined(ESP32)
  #include <ESP32Servo.h>
#else
  #include <Servo.h>
#endif

const int PIN_SERVO = 13;

// Ángulos del gatillo: 0° es el reposo (gatillo suelto) y 90° es el disparo
// (gatillo apretado = pulveriza). Son los ángulos del original.
const int ANGULO_REPOSO  = 0;
const int ANGULO_DISPARO = 90;

// Tiempos del ciclo. El original mantiene el gatillo apretado ~1 s y luego
// espera ~5 s hasta la próxima pulverización.
// NOTA DE AULA: son valores cortos a propósito para poder probar el mecanismo
// sin esperar. En un uso real se alargarían (por ejemplo, pulverizar cada
// varios minutos según la necesidad de las góndolas).
const unsigned long TIEMPO_DISPARO_MS       = 1000;  // gatillo apretado
const unsigned long TIEMPO_ENTRE_DISPAROS_MS = 5000;  // reposo entre riegos

Servo servoGatillo;

void setup() {
  servoGatillo.attach(PIN_SERVO);
  // Arranca en reposo para no pulverizar apenas se enciende.
  servoGatillo.write(ANGULO_REPOSO);
}

void loop() {
  // Aprieta el gatillo: pulveriza.
  servoGatillo.write(ANGULO_DISPARO);
  delay(TIEMPO_DISPARO_MS);

  // Suelta el gatillo y espera hasta el próximo ciclo.
  servoGatillo.write(ANGULO_REPOSO);
  delay(TIEMPO_ENTRE_DISPAROS_MS);
}
Pulverizador por tiempo: el servo aprieta el gatillo (90°), lo mantiene un segundo, lo suelta (0°) y espera 5 segundos antes del próximo disparo.

Leelo como una receta: “apretá el gatillo, mantené un segundo, soltá, esperá cinco segundos… y volvé a empezar”. Podés explorar ese mismo comportamiento en el simulador antes de armarlo sobre la mesa:

Simulación del comportamiento

La misma máquina de estados del firmware, portada a TypeScript, maneja el comportamiento del dispositivo. No se ejecuta el binario real: la ejecución del .hex con avr8js está en el roadmap.

Simulación lista. Presioná «Iniciar» para arrancar la secuencia.

Impresión de las piezas del mecanismo

Con la electrónica funcionando, toca la parte mecánica: las piezas que acoplan el servo al gatillo del pulverizador se imprimen en 3D. El modelo original se descargaba de forma libre y gratuita; el paquete de fabricación de esta reedición está a diseñar (lo vas a encontrar en la ficha del proyecto cuando esté disponible).

Si querés modificar el modelo, sea cual sea el programa de diseño que uses, exportá las piezas en formato .stl. Ese es el formato que abre el software de la impresora para, desde ahí, generar el código G: las instrucciones concretas de movimiento con las que la impresora convierte el modelo en la pieza física.

Ensamblaje del sistema mecánico con la parte electrónica

Último paso del nivel: montar las piezas impresas sobre el gatillo del pulverizador de modo que el brazo del servo, al girar a 90°, apriete el gatillo, y al volver a 0° lo suelte. El servo queda sujeto al soporte y conectado a la placa como en el paso 1.

Vista del mecanismo impreso en 3D montado sobre la botella del pulverizador: el servo, sujeto al soporte, acciona el gatillo mediante un brazo articulado; los cables de señal y alimentación bajan hacia la placa Arduino.
El sistema ensamblado: el servo apoyado en el soporte impreso acciona el gatillo del pulverizador, con la electrónica del lado seco (figura original del proyecto).

Cuidado con el agua. Este es un proyecto de baja tensión, pero mezcla electrónica y líquido. El agua sale a baja presión y no debe tocar la placa, el servo, el sensor ni las conexiones: montá la electrónica del lado seco del mecanismo y orientá la boquilla hacia afuera, lejos de los cables.

Cierre del nivel

Al terminar este nivel, el pulverizador de las góndolas funciona solo: el servomotor —controlado con la librería de tu placa— aprieta y suelta el gatillo a intervalos de tiempo fijos, y las piezas impresas en 3D sostienen todo el mecanismo con la electrónica a salvo del agua. En el nivel avanzado el sistema va a dejar de pulverizar “a ciegas”: un sensor de movimiento va a detectar cuándo un cliente retira productos de la góndola, y recién entonces —y esperando un rato para no mojarlo— el pulverizador entrará en acción.

Evidencia de cierre

Al terminar este nivel, esto tiene que estar funcionando:

  • El servomotor está conectado a la placa (señal, alimentación y tierra) y responde al código: al subir el programa, se mueve a la posición indicada.
  • El programa mueve el servo de 0° (reposo) a 90° (disparo) y de vuelta, a intervalos de tiempo fijos, accionando el gatillo del pulverizador de forma automática.
  • Las piezas del mecanismo están impresas y ensambladas sobre el gatillo del pulverizador, con la electrónica montada del lado seco, lejos del chorro de agua.