Pulverizador Automatizado

// 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);
}

// Pulverizador por movimiento (PIR): en lugar de pulverizar a ciegas cada
// tantos segundos, el sistema espera a detectar movimiento con un sensor PIR
// (un cliente que retira frutas o verduras) y recién entonces acciona el
// gatillo. Así no se desperdicia agua: se riega cuando hace falta.
//
// Detalle clave del original: al detectar movimiento NO se pulveriza de
// inmediato. Primero se deja pasar un tiempo de espera (para no rociar a la
// persona que todavía está frente a la góndola) y después se hace una tanda
// de 3 pulverizaciones seguidas sobre las frutas que quedaron.
//
// SEGURIDAD: es una práctica de baja tensión. El servo y el PIR trabajan a
// 5 V; el agua pulverizada sale a baja presión y NO debe tocar la placa, el
// servo, el sensor ni las conexiones. Ubicar el circuito lejos del chorro.
//
// Plataforma: Arduino UNO.
// Conexión: señal del servo (amarillo) → pin 3; salida de datos del PIR →
// pin 4; alimentaciones a 5V y GND.
//
// Basado en: código de los Pasos 4 a 6, Nivel Avanzado — 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. Se mantiene la estructura
// bloqueante del original (delay()): es fiel a lo que la guía enseña en este
// proyecto y hace el flujo de "esperar y luego repetir" fácil de leer.

// 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;
const int PIN_PIR   = 4;

// Ángulos del gatillo (iguales al nivel inicial y al original).
const int ANGULO_REPOSO  = 0;
const int ANGULO_DISPARO = 90;

// Cantidad de pulverizaciones por detección: el original repite el disparo
// 3 veces para asegurar el rociado.
const int CICLOS_POR_DETECCION = 3;

// Tiempos. El original: esperar antes de accionar y, dentro de la tanda,
// pulverizaciones cortas y seguidas (1 s entre una y otra).
// NOTA DE AULA: son valores cortos a propósito para probar sin esperar. La
// espera real del original es de 60 s (para que el cliente se aleje antes de
// rociar); si querés ver el ciclo completo rápido en el aula, bajá
// temporalmente TIEMPO_ESPERA_MS (por ejemplo a 5000 = 5 s).
const unsigned long TIEMPO_ESPERA_MS        = 60000;  // antes de pulverizar
const unsigned long TIEMPO_DISPARO_MS       = 1000;   // gatillo apretado
const unsigned long TIEMPO_ENTRE_CICLOS_MS  = 1000;   // reposo entre disparos

Servo servoGatillo;

void setup() {
  pinMode(PIN_PIR, INPUT);
  servoGatillo.attach(PIN_SERVO);
  servoGatillo.write(ANGULO_REPOSO);
}

void loop() {
  // El PIR devuelve HIGH (1) cuando detecta movimiento.
  if (digitalRead(PIN_PIR) == HIGH) {
    // Esperar antes de accionar: le damos tiempo a la persona para retirarse
    // de la góndola y así no la rociamos (Paso 6 del original).
    delay(TIEMPO_ESPERA_MS);

    // Tanda de pulverizaciones sobre las frutas que quedaron (Paso 5).
    for (int i = 0; i < CICLOS_POR_DETECCION; i++) {
      servoGatillo.write(ANGULO_DISPARO);
      delay(TIEMPO_DISPARO_MS);
      servoGatillo.write(ANGULO_REPOSO);
      delay(TIEMPO_ENTRE_CICLOS_MS);
    }
  }
  // Sin movimiento: loop() vuelve a empezar y consulta el sensor de nuevo.
}

// Pulverizador por movimiento (PIR): en lugar de pulverizar a ciegas cada
// tantos segundos, el sistema espera a detectar movimiento con un sensor PIR
// (un cliente que retira frutas o verduras) y recién entonces acciona el
// gatillo. Así no se desperdicia agua: se riega cuando hace falta.
//
// Detalle clave del original: al detectar movimiento NO se pulveriza de
// inmediato. Primero se deja pasar un tiempo de espera (para no rociar a la
// persona que todavía está frente a la góndola) y después se hace una tanda
// de 3 pulverizaciones seguidas sobre las frutas que quedaron.
//
// SEGURIDAD: es una práctica de baja tensión. El servo y el PIR trabajan a
// baja tensión; el agua pulverizada sale a baja presión y NO debe tocar la
// placa, el servo, el sensor ni las conexiones. Ubicar el circuito lejos del
// chorro.
//
// Plataforma: ESP32 (DevKit v1).
// Conexión: señal del servo (amarillo) → GPIO 13; salida de datos del PIR →
// GPIO 27. Nota eléctrica: el ESP32 trabaja a 3,3 V en sus GPIO; el servo se
// alimenta a 5 V desde una fuente aparte con GND común, y el PIR debe entregar
// su salida a 3,3 V (o adaptarla). Nunca inyectar 5 V en un GPIO.
//
// Basado en: código de los Pasos 4 a 6, Nivel Avanzado — 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 y GPIO seguros (servo 13, PIR 27) en lugar de los
// pines 3 y 4 del UNO. Se mantiene la estructura bloqueante del original
// (delay()): es fiel a lo que la guía enseña en este proyecto.

// 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;
const int PIN_PIR   = 27;

// Ángulos del gatillo (iguales al nivel inicial y al original).
const int ANGULO_REPOSO  = 0;
const int ANGULO_DISPARO = 90;

// Cantidad de pulverizaciones por detección: el original repite el disparo
// 3 veces para asegurar el rociado.
const int CICLOS_POR_DETECCION = 3;

// Tiempos. El original: esperar antes de accionar y, dentro de la tanda,
// pulverizaciones cortas y seguidas (1 s entre una y otra).
// NOTA DE AULA: son valores cortos a propósito para probar sin esperar. La
// espera real del original es de 60 s (para que el cliente se aleje antes de
// rociar); si querés ver el ciclo completo rápido en el aula, bajá
// temporalmente TIEMPO_ESPERA_MS (por ejemplo a 5000 = 5 s).
const unsigned long TIEMPO_ESPERA_MS        = 60000;  // antes de pulverizar
const unsigned long TIEMPO_DISPARO_MS       = 1000;   // gatillo apretado
const unsigned long TIEMPO_ENTRE_CICLOS_MS  = 1000;   // reposo entre disparos

Servo servoGatillo;

void setup() {
  pinMode(PIN_PIR, INPUT);
  servoGatillo.attach(PIN_SERVO);
  servoGatillo.write(ANGULO_REPOSO);
}

void loop() {
  // El PIR devuelve HIGH (1) cuando detecta movimiento.
  if (digitalRead(PIN_PIR) == HIGH) {
    // Esperar antes de accionar: le damos tiempo a la persona para retirarse
    // de la góndola y así no la rociamos (Paso 6 del original).
    delay(TIEMPO_ESPERA_MS);

    // Tanda de pulverizaciones sobre las frutas que quedaron (Paso 5).
    for (int i = 0; i < CICLOS_POR_DETECCION; i++) {
      servoGatillo.write(ANGULO_DISPARO);
      delay(TIEMPO_DISPARO_MS);
      servoGatillo.write(ANGULO_REPOSO);
      delay(TIEMPO_ENTRE_CICLOS_MS);
    }
  }
  // Sin movimiento: loop() vuelve a empezar y consulta el sensor de nuevo.
}