Bienvenido al proyecto tecnológico

Vamos a construir una máquina que abre una compuerta y deja caer la comida de tu mascota o animal. Lo hace de dos maneras: cuando llega la hora del almuerzo, y cuando alguien acerca la mano.

¿Cómo funciona? En 4 pasos

1. El reloj cuenta el tiempo. Un módulo llamado DS1302 sabe qué hora es, igual que el reloj de tu casa.
2. El sensor vigila. El sensor ultrasónico mide si hay algo cerca, como los murciélagos.
3. El Arduino decide. Es la pequeña computadora que pregunta: «¿ya es la hora?» o «¿hay una mano cerca?».
4. El motor abre la tapa. El servomotor gira, la compuerta se abre 2 segundos y se cierra.

¿Cómo usar esta guía?

Reglas de seguridad

¿Qué es un Arduino?

El Arduino Uno es una computadora del tamaño de una tarjeta. No tiene pantalla ni teclado: lo que hace es leer sensores y mover cosas.

Las partes de la placa

¿Cómo se le da una orden?

Escribimos un programa en la computadora, apretamos «Subir» y el programa se guarda dentro del chip. Desde ese momento el Arduino lo repite solo, aunque desconectes la computadora.

Todo programa de Arduino tiene 2 partes

void setup() {
  // Esto se hace UNA SOLA VEZ, al encender.
}

void loop() {
  // Esto se repite PARA SIEMPRE, miles de veces por segundo.
}

Palabras que verás en todos los códigos

Las piezas del proyecto tecnológico

Usaremos 4 piezas principales. Aquí conocerás cada una antes de conectarla.

1. Arduino Uno — el cerebro

2. Microservo SG90 — el músculo

Un servomotor es un motor especial: no gira sin parar como el de un ventilador. En lugar de eso, se coloca en el ángulo que le pidamos y se queda ahí.

3. Sensor HC-SR04 — el oído

Es el sensor ultrasónico. Tiene dos cilindros que parecen ojitos, pero en realidad son un altavoz y un micrófono.

1. El cilindro TRIG lanza un sonido tan agudo que las personas no lo escuchamos.
2. El sonido viaja, choca contra tu mano y rebota.
3. El cilindro ECHO escucha el rebote y avisa cuánto tardó.
4. El Arduino hace una cuenta y sabe a cuántos centímetros está tu mano.

4. Módulo DS1302 — el reloj

Es un reloj de tiempo real (RTC). Guarda la hora, el minuto, el segundo y hasta la fecha.

Piezas de apoyo

Cómo conectar todo

Cada cable tiene un lugar exacto. Si uno se equivoca de agujero, la pieza no funciona (pero casi nunca se rompe).

La regla de los 3 tipos de cable

Tabla oficial de conexiones

Avisos importantes

Lista para revisar antes de encender

1. ¿El cable rojo del servo está en 5V y no en un pin numerado?
2. ¿TRIG está en D6 y ECHO en D7? (Si los cambias de lugar, el sensor no mide.)
3. ¿El reloj tiene su pila puesta?
4. ¿Ningún cable pelado toca a otro?
5. Recién ahora: conecta el USB.

Probamos el servo solo

Antes de juntar todo, probamos cada pieza por separado. Así, si algo falla, sabemos exactamente quién tiene la culpa.

Prueba A: ponerlo en 0 grados

Este programa coloca el servo en su posición inicial. Cuando ya esté en 0°, desconecta el USB y recién ahí atornilla el brazo con la compuerta cerrada.

#include <Servo.h>

Servo servo;

void setup() {
  servo.attach(9);   // La señal del servo está en el pin D9
  servo.write(0);    // Colocar el servo en 0 grados
}

void loop() {
  // No hacemos nada más.
}

Prueba B: recorrer todos los ángulos

Ahora el servo hará este recorrido, cambiando cada 2 segundos:

0° → 45° → 90° → 135° → 180° → 135° → 90° → 45° → 0°

#include <Servo.h>

Servo servo;

int angulo = 0;      // Empezamos en 0 grados
int paso = 45;       // Avanzamos de 45 en 45

void setup() {
  servo.attach(9);   // Señal del servo en D9
  servo.write(0);    // Posición inicial
  delay(2000);       // Esperar 2 segundos
}

void loop() {
  angulo = angulo + paso;
  servo.write(angulo);
  delay(2000);

  if (angulo == 180) {
    paso = -45;      // Empezar a regresar
  }

  if (angulo == 0) {
    paso = 45;       // Empezar a avanzar
  }
}

Probamos el sensor de distancia

Este programa no mueve nada: solo escribe en la pantalla de la computadora a cuántos centímetros está el objeto más cercano.

const int trigPin = 6;
const int echoPin = 7;

void setup() {
  Serial.begin(9600);
  pinMode(trigPin, OUTPUT);
  pinMode(echoPin, INPUT);
}

void loop() {
  digitalWrite(trigPin, LOW);
  delayMicroseconds(5);

  digitalWrite(trigPin, HIGH);
  delayMicroseconds(10);
  digitalWrite(trigPin, LOW);

  unsigned long duracion = pulseIn(echoPin, HIGH, 30000);

  if (duracion == 0) {
    Serial.println("Sin eco");
  } else {
    float distancia = duracion * 0.0343 / 2;

    Serial.print("Distancia: ");
    Serial.print(distancia);
    Serial.println(" cm");
  }

  delay(500);
}

¿De dónde sale la cuenta mágica?

1. El sonido viaja a 343 metros por segundo, que es lo mismo que 0.0343 centímetros por microsegundo.
2. Si multiplicamos el tiempo por esa velocidad, sabemos cuántos centímetros recorrió.
3. Pero el sonido fue y volvió: hizo el camino dos veces. Por eso dividimos entre 2.

Probamos el reloj DS1302

Paso 1: ponerle la hora (una sola vez)

El reloj sale de fábrica sin saber qué hora es. Este programa le copia la hora de tu computadora.

#include <ThreeWire.h>
#include <RtcDS1302.h>

// DAT = D3, CLK = D4, RST = D2
ThreeWire conexionRtc(3, 4, 2);
RtcDS1302<ThreeWire> rtc(conexionRtc);

void setup() {
  rtc.Begin();
  rtc.SetIsWriteProtected(false);
  rtc.SetIsRunning(true);

  // Copia al DS1302 la fecha y hora de la computadora.
  rtc.SetDateTime(RtcDateTime(__DATE__, __TIME__));
}

void loop() {
  // Este programa solo sirve para ajustar la hora.
}

Paso 2: leer la hora

#include <ThreeWire.h>
#include <RtcDS1302.h>

// DAT = D3, CLK = D4, RST = D2
ThreeWire conexionRtc(3, 4, 2);
RtcDS1302<ThreeWire> rtc(conexionRtc);

void setup() {
  Serial.begin(9600);
  rtc.Begin();
  rtc.SetIsWriteProtected(false);
  rtc.SetIsRunning(true);
}

void loop() {
  RtcDateTime ahora = rtc.GetDateTime();

  Serial.print(ahora.Hour());
  Serial.print(":");
  Serial.print(ahora.Minute());
  Serial.print(":");
  Serial.println(ahora.Second());

  delay(1000);
}

Servo + reloj trabajando juntos

Ya sabemos que cada pieza funciona sola. Ahora las unimos: el reloj decide cuándo, y el servo se mueve.

El servo recorrerá 0°, 45°, 90°, 135°, 180° y regresará, pero esta vez el que da la orden no es delay(), sino los segundos del reloj: se mueve en los segundos 0, 2, 4, 6, 8…

#include <Servo.h>
#include <ThreeWire.h>
#include <RtcDS1302.h>

// DAT = D3, CLK = D4, RST = D2
ThreeWire conexionRtc(3, 4, 2);
RtcDS1302<ThreeWire> rtc(conexionRtc);

Servo servo;

int angulo = 0;          // Comenzamos en 0 grados
int paso = 45;           // Cambiamos 45 grados cada vez
int ultimoSegundo = -1;  // Evita repetir una orden

void setup() {
  Serial.begin(9600);
  rtc.Begin();

  servo.attach(9);
  servo.write(0);
}

void loop() {
  RtcDateTime ahora = rtc.GetDateTime();
  int segundoActual = ahora.Second();

  // Entramos una sola vez cuando cambia el segundo.
  if (segundoActual != ultimoSegundo) {
    ultimoSegundo = segundoActual;

    Serial.print(ahora.Hour());
    Serial.print(":");
    Serial.print(ahora.Minute());
    Serial.print(":");
    Serial.println(segundoActual);

    // Se mueve en 0, 2, 4, 6, 8...
    if (segundoActual % 2 == 0) {
      angulo = angulo + paso;
      servo.write(angulo);

      if (angulo == 180) {
        paso = -45;
      }

      if (angulo == 0) {
        paso = 45;
      }
    }
  }
}

¿Por qué necesitamos ultimoSegundo?

Es como cuando suena el timbre del recreo: quieres salir una vez cuando suena, no quedarte saliendo mil veces mientras suena.

Servo + sensor trabajando juntos

Ahora la orden la da tu mano: si te acercas a 10 cm o menos, la tapa se abre 2 segundos y se cierra sola.

#include <Servo.h>

Servo servo;

const int trigPin = 6;
const int echoPin = 7;
const int DISTANCIA_MANO = 10;

void setup() {
  Serial.begin(9600);

  servo.attach(9);
  servo.write(0);

  pinMode(trigPin, OUTPUT);
  pinMode(echoPin, INPUT);
}

void loop() {
  digitalWrite(trigPin, LOW);
  delayMicroseconds(5);
  digitalWrite(trigPin, HIGH);
  delayMicroseconds(10);
  digitalWrite(trigPin, LOW);

  unsigned long duracion = pulseIn(echoPin, HIGH, 30000);

  if (duracion != 0) {
    float distancia = duracion * 0.0343 / 2;

    Serial.print("Distancia: ");
    Serial.print(distancia);
    Serial.println(" cm");

    if (distancia <= DISTANCIA_MANO) {
      servo.write(90);  // Abrir
      delay(2000);      // Esperar 2 segundos
      servo.write(0);   // Cerrar
      delay(1000);
    }
  }

  delay(100);
}

Las tres piezas juntas

Este es el dispensador terminado. Sabe hacer tres cosas:

#include <Servo.h>
#include <ThreeWire.h>
#include <RtcDS1302.h>

// CONEXIONES
// Servo: D9
// HC-SR04: TRIG D6 y ECHO D7
// DS1302: DAT D3, CLK D4 y RST D2

Servo servoTapa;

const int ANGULO_CERRADO = 0;
const int ANGULO_ABIERTO = 90;

const int trigPin = 6;
const int echoPin = 7;
const int DISTANCIA_MANO = 10;
const int DISTANCIA_REACTIVAR = 15;

ThreeWire conexionRtc(3, 4, 2);
RtcDS1302<ThreeWire> rtc(conexionRtc);

// Cambia estos números para elegir la hora.
const int HORA_COMIDA = 8;
const int MINUTO_COMIDA = 0;

bool tapaAbierta = false;
bool manoYaDetectada = false;

long segundoEnQueAbrio = 0;
int ultimoSegundoLeido = -1;
int ultimoDiaAlimentado = -1;

// Convierte la hora en segundos del día.
long segundosDelDia(RtcDateTime tiempo) {
  return tiempo.Hour() * 3600L
       + tiempo.Minute() * 60L
       + tiempo.Second();
}

// Mide la distancia con el ultrasónico.
float medirDistancia() {
  digitalWrite(trigPin, LOW);
  delayMicroseconds(5);

  digitalWrite(trigPin, HIGH);
  delayMicroseconds(10);
  digitalWrite(trigPin, LOW);

  unsigned long duracion = pulseIn(echoPin, HIGH, 30000);

  if (duracion == 0) {
    return -1;
  }

  return duracion * 0.0343 / 2;
}

void abrirTapa(long segundoActual) {
  servoTapa.write(ANGULO_ABIERTO);
  tapaAbierta = true;
  segundoEnQueAbrio = segundoActual;
  Serial.println("Tapa abierta");
}

void cerrarTapa() {
  servoTapa.write(ANGULO_CERRADO);
  tapaAbierta = false;
  Serial.println("Tapa cerrada");
}

void setup() {
  Serial.begin(9600);

  rtc.Begin();

  servoTapa.attach(9);
  servoTapa.write(ANGULO_CERRADO);

  pinMode(trigPin, OUTPUT);
  pinMode(echoPin, INPUT);
}

void loop() {
  RtcDateTime ahora = rtc.GetDateTime();

  // La parte principal se ejecuta una vez por segundo.
  if (ahora.Second() != ultimoSegundoLeido) {
    ultimoSegundoLeido = ahora.Second();

    long segundoActual = segundosDelDia(ahora);

    Serial.print(ahora.Hour());
    Serial.print(":");
    Serial.print(ahora.Minute());
    Serial.print(":");
    Serial.println(ahora.Second());

    // Si está abierta, el DS1302 cuenta 2 segundos.
    if (tapaAbierta) {
      long tiempoAbierta = segundoActual - segundoEnQueAbrio;

      // Corrección por si pasa la medianoche.
      if (tiempoAbierta < 0) {
        tiempoAbierta = tiempoAbierta + 86400;
      }

      if (tiempoAbierta >= 2) {
        cerrarTapa();
      }
    }

    // Solo buscamos otra orden cuando está cerrada.
    if (!tapaAbierta) {
      float distancia = medirDistancia();

      Serial.print("Distancia: ");
      Serial.print(distancia);
      Serial.println(" cm");

      bool esHoraDeComer =
          ahora.Hour() == HORA_COMIDA &&
          ahora.Minute() == MINUTO_COMIDA &&
          ahora.Second() == 0 &&
          ahora.Day() != ultimoDiaAlimentado;

      // Apertura por hora programada.
      if (esHoraDeComer) {
        abrirTapa(segundoActual);
        ultimoDiaAlimentado = ahora.Day();
      }

      // Apertura al acercar la mano.
      else if (
        distancia > 0 &&
        distancia <= DISTANCIA_MANO &&
        !manoYaDetectada
      ) {
        abrirTapa(segundoActual);
        manoYaDetectada = true;
      }

      // Hay que alejar la mano para volver a activar.
      if (
        distancia == -1 ||
        distancia >= DISTANCIA_REACTIVAR
      ) {
        manoYaDetectada = false;
      }
    }
  }
}

Las ideas nuevas de este programa

¿Por qué convertir la hora a segundos?

Restar horas es complicado: ¿cuánto va de 8:59:58 a 9:00:03? Pero si convertimos todo a segundos desde la medianoche, se vuelve una resta normal.

1. Cada hora tiene 3600 segundos, así que multiplicamos las horas por 3600.
2. Cada minuto tiene 60 segundos, así que multiplicamos los minutos por 60.
3. Sumamos los segundos que ya teníamos.
4. El día completo tiene 86400 segundos. Por eso, si la resta da negativa, sumamos 86400: es que pasó la medianoche.

¿Por qué existe DISTANCIA_REACTIVAR?

Cómo demostrarlo en clase

1. Abre el Monitor Serie y muestra la hora corriendo: eso prueba que el reloj funciona.
2. Acerca la mano: la tapa se abre. Mira cómo cambia el número de distancia.
3. Aleja la mano y cuenta en voz alta: uno… dos… la tapa se cierra.
4. Programa HORA_COMIDA para dentro de un minuto y espera. La tapa se abrirá sola.

Si algo no funciona

Que algo falle es parte del aprendizaje al construir el proyecto. Aquí están los problemas más comunes y cómo resolverlos. Toca cada pregunta para ver la respuesta.

Recordatorio de pines

Glosario: todas las palabras nuevas

Aquí están todas las palabras difíciles del proyecto, explicadas en una frase y ordenadas de la A a la Z.