Pulverizador automático por tiempo
Recorrido del nivel
Esa barra de arriba te dice en qué paso estás. Tocala para ver el índice completo y saltar a cualquier paso.
Conectar el servomotor
Empezamos conectando el servomotorServomotorMotor que se ubica en un ángulo específico (los comunes, de 0° a 180°) y se mantiene ahí. Se programa indicando el ángulo deseado; tiene tres cables: alimentación (VCC, GND) y señal., 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.
En el ArduinoArduinoPlaca electrónica con un microcontrolador programable y comunicación USB/serial. Desde la computadora, un IDE permite escribir el código, compilarlo y cargarlo en la placa. Tiene entradas y salidas digitales (0 a 13) y entradas analógicas (A0 a A5). 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 ESP32ESP32Placa con un microcontrolador de Espressif que trae WiFi (y Bluetooth) integrados. Se programa desde el Arduino IDE igual que un Arduino, con pines llamados GPIO. En este proyecto reemplaza al conjunto Arduino UNO + módulo OBLOQ para el nivel IoT., 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:
- Conectar la placa a la computadora con el cable USB.
- Chequear que en el selector de placa del Arduino IDE esté seleccionada la placa correcta.
- Seleccionar el puertoPuerto COMPuerto de comunicaciones por el cual el sistema operativo se comunica con un dispositivo externo, como la placa. Se asigna automáticamente al conectarla por USB y puede cambiar de número; en el IDE hay que indicar cuál usar. al que está conectada la placa.
- 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 0° 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: 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: 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);
} 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 .stlFormato .stlFormato de archivo que contiene la forma de un objeto sólido 3D, sin color, texturas ni propiedades físicas. Es el más usado para intercambiar e imprimir modelos 3D; funciona como la 'exportación final' de un diseño, como un PDF de un documento de texto.. Ese es el formato que abre el software de la impresora para, desde ahí, generar el código GCódigo GConjunto de acciones que la impresora 3D (o cualquier máquina CNC) debe realizar para completar un trabajo. Se genera analizando un archivo STL, y es específico de cada modelo de impresora.: 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.
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.
Verificá
Con el programa por tiempo corriendo y el mecanismo montado, cada ciclo del servo aprieta y suelta el gatillo, y sale una pulverización. Si el gatillo no se aprieta del todo, revisá la sujeción del soporte y probá ajustar el ángulo de disparo.
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.