Abrir y cerrar la cerradura con dos pulsadores

El proyecto arranca por el circuito que controla el movimiento de la cerradura. El corazón es un 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.: un motor con un sistema de control que le permite ubicarse en un ángulo preciso (entre 0° y 180°) y quedarse ahí. Ese giro es el que, más adelante, va a mover el mecanismo que traba y destraba la puerta.

Sumamos también los dos pulsadoresPulsadorInterruptor que normalmente está abierto y, mientras se lo mantiene presionado, cierra el circuito entre sus patas. Se usa como botón para que el usuario interactúe con el dispositivo, o como sensor de contacto (fin de carrera). —ABRIR y CERRAR— sobre la protoboardProtoboardPlaca experimental para el prototipado rápido de circuitos: sus orificios permiten insertar y conectar componentes sin soldadura. Las líneas superior e inferior recorren la placa de punta a punta y suelen usarse para la alimentación.. Un pulsador está normalmente abierto y, mientras se lo mantiene apretado, cierra el circuito entre sus patas: así la placa detecta que lo presionamos.

Ahora escribimos la lógica de apertura y cierre. La programación la hacemos directamente en el lenguaje de Arduino (C++), con el Arduino IDE en su versión 2.x, que se descarga gratis de arduino.cc/en/software. Un programa de Arduino se llama sketch y tiene dos bloques: setup(), que se ejecuta una sola vez al encender, y loop(), que se repite después. Todo lo que va después de // es un comentario: no afecta al programa, sirve para leerlo mejor.

La idea es simple: en cada vuelta de loop() el programa mira los pulsadores. Si está presionado ABRIR, lleva el servo a la posición abierta; si está presionado CERRAR, lo lleva a la cerrada. Al servo se le ordena un ángulo con cerradura.write(...). En esta reedición unificamos los ángulos para todos los niveles: abierta = 90° y cerrada = 0°.

Un detalle sobre cómo leemos los botones: los conectamos con la resistencia interna de pull-up de la placa (INPUT_PULLUP). Con eso, el pin lee ALTO en reposo y BAJO cuando el botón está presionado. Por eso en el código preguntamos if (digitalRead(...) == LOW). Es la forma moderna y con menos componentes que el “leer al aire” del material original.

Para subir el programa a la placa, conectala a la computadora con el cable USB, elegí en el Arduino IDE 2.x la placa y 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. (en el IDE 2.x se eligen juntos en el menú desplegable de la barra superior) y apretá el botón Subir (la flecha →). Al terminar, aparece el mensaje de carga completada en la barra inferior.

Sumamos ahora los dos LEDLEDComponente electrónico tipo diodo que emite luz. Tiene polaridad: la pata larga es la positiva y la corta (o el lado plano del encapsulado) la negativa. Conectado al revés no se daña, pero no enciende. que muestran el estado de la cerradura: el verde para abierta y el rojo para cerrada. El LED tiene polaridad: la pata larga es la positiva y va al pin de la placa; la pata corta (negativa) va a masa a través de una resistenciaResistenciaComponente que se opone al paso de la corriente eléctrica. Su valor se mide en ohm (Ω). Se usa para determinar la cantidad de corriente de una rama del circuito, por ejemplo para evitar que un LED se queme por exceso de corriente. de 220 Ω, que limita la corriente para que no se dañe.

Completamos el programa para que, además de mover el servo, encienda el LED que corresponde a cada estado. La regla es: cuando la cerradura queda abierta, se enciende el verde y se apaga el rojo; cuando queda cerrada, se enciende el rojo y se apaga el verde. El sistema arranca cerrado (LED rojo), su estado seguro por defecto.

Fijate en el código cómo las dos acciones —“abrir” y “cerrar”— quedan agrupadas en funciones (abrirPuerta() y cerrarPuerta()): cada una mueve el servo y actualiza los dos LED de una vez. Así el programa se lee como lo que hace.

// Cerradura automatizada — Nivel Inicial (Arduino UNO).
//
// Dos pulsadores controlan el servomotor que traba/destraba la cerradura:
//   - Pulsador ABRIR  -> el servo va a la posicion "abierta"  + LED verde.
//   - Pulsador CERRAR -> el servo va a la posicion "cerrada"  + LED rojo.
// Los LED indican de un vistazo el estado de la puerta (verde = abierta,
// rojo = cerrada), tal como pide la situacion-problema del abuelo de Josefina.
//
// Plataforma: Arduino UNO. Proyecto de BAJA TENSION (servo 5 V, LED,
// pulsadores): no hay 220 V ni agua, no lleva advertencias electricas.
//
// Nivel inicial: se permite delay() (fiel a la progresion original); el
// antirrebote se resuelve con una espera corta. El nivel avanzado pasa a
// millis() sin bloquear.
//
// Basado en: Fragmentos de codigo del Nivel Inicial (Pasos 2 y 5) — Cerradura
// Automatica, Saberes Digitales (INET/EDUCAR 2019).
// Desvios respecto del original (ver README):
//  (1) PINES UNIFICADOS: el original ataba el servo al pin 0 (rompe USB/serial)
//      y usaba pines de LED distintos por nivel. Aca el servo va al pin 10 y
//      los LED a 11/13 — el MISMO esquema en los tres niveles.
//  (2) Angulos del servo unificados (ABIERTA=90, CERRADA=0) para que el mismo
//      criterio valga en inicial, intermedio y avanzado.
//  (3) Pulsadores con INPUT_PULLUP (activo en LOW): el original leia entradas
//      "al aire"; el pull-up interno evita lecturas erraticas sin resistencias.

#if defined(ESP32)
  #include <ESP32Servo.h>
#else
  #include <Servo.h>
#endif

// --- Pines (esquema UNIFICADO del contrato) ---
const int PIN_SERVO      = 10;  // senal del servomotor de la cerradura
const int PIN_LED_VERDE  = 11;  // encendido = cerradura ABIERTA
const int PIN_LED_ROJO   = 13;  // encendido = cerradura CERRADA
// En el nivel inicial NO hay teclado, asi que los botones ocupan dos pines
// libres (2 y 3). En intermedio, el teclado matricial los reemplaza.
const int PIN_BOTON_ABRIR  = 2;
const int PIN_BOTON_CERRAR = 3;

// Angulos del servo (unificados en los tres niveles).
const int ANGULO_ABIERTA = 90;
const int ANGULO_CERRADA = 0;

// Antirrebote simple del pulsador (ms).
const unsigned long ANTIRREBOTE_MS = 200;

Servo cerradura;

void abrirPuerta() {
  cerradura.write(ANGULO_ABIERTA);
  digitalWrite(PIN_LED_VERDE, HIGH);
  digitalWrite(PIN_LED_ROJO, LOW);
}

void cerrarPuerta() {
  cerradura.write(ANGULO_CERRADA);
  digitalWrite(PIN_LED_VERDE, LOW);
  digitalWrite(PIN_LED_ROJO, HIGH);
}

void setup() {
  pinMode(PIN_LED_VERDE, OUTPUT);
  pinMode(PIN_LED_ROJO, OUTPUT);
  // Con INPUT_PULLUP el pulsador lee HIGH en reposo y LOW al presionarse.
  pinMode(PIN_BOTON_ABRIR, INPUT_PULLUP);
  pinMode(PIN_BOTON_CERRAR, INPUT_PULLUP);

  cerradura.attach(PIN_SERVO);
  // Estado inicial: CERRADA (LED rojo). Es el estado seguro por defecto de
  // una cerradura.
  cerrarPuerta();
}

void loop() {
  // Pulsador presionado = LOW (por el pull-up interno).
  if (digitalRead(PIN_BOTON_ABRIR) == LOW) {
    abrirPuerta();
    delay(ANTIRREBOTE_MS);
  }

  if (digitalRead(PIN_BOTON_CERRAR) == LOW) {
    cerrarPuerta();
    delay(ANTIRREBOTE_MS);
  }
}

// Cerradura automatizada — Nivel Inicial (ESP32 DevKit v1).
//
// Dos pulsadores controlan el servomotor que traba/destraba la cerradura:
//   - Pulsador ABRIR  -> el servo va a la posicion "abierta"  + LED verde.
//   - Pulsador CERRAR -> el servo va a la posicion "cerrada"  + LED rojo.
// Los LED indican de un vistazo el estado (verde = abierta, rojo = cerrada).
//
// Plataforma: ESP32 (DevKit v1). El servo se maneja con la libreria
// ESP32Servo (la Servo.h clasica no funciona en ESP32). Nota electrica: el
// ESP32 trabaja a 3,3 V (el UNO a 5 V); alimentar el servo desde 5 V con GND
// comun. Proyecto de BAJA TENSION: sin 220 V ni agua.
//
// Nivel inicial: se permite delay() (fiel a la progresion original).
//
// Basado en: Fragmentos de codigo del Nivel Inicial (Pasos 2 y 5) — Cerradura
// Automatica, Saberes Digitales (INET/EDUCAR 2019).
// Desvios (ver README): pines GPIO seguros del contrato; angulos del servo
// unificados (ABIERTA=90, CERRADA=0); pulsadores con INPUT_PULLUP.

#if defined(ESP32)
  #include <ESP32Servo.h>
#else
  #include <Servo.h>
#endif

// --- Pines (GPIO seguros del contrato) ---
const int PIN_SERVO      = 13;  // ESP32Servo
const int PIN_LED_VERDE  = 25;  // encendido = cerradura ABIERTA
const int PIN_LED_ROJO   = 26;  // encendido = cerradura CERRADA
// En el nivel inicial no hay teclado: los botones ocupan dos GPIO libres de
// entrada (32 y 33). En intermedio los reemplaza el teclado matricial.
const int PIN_BOTON_ABRIR  = 32;
const int PIN_BOTON_CERRAR = 33;

// Angulos del servo (unificados en los tres niveles).
const int ANGULO_ABIERTA = 90;
const int ANGULO_CERRADA = 0;

// Antirrebote simple del pulsador (ms).
const unsigned long ANTIRREBOTE_MS = 200;

Servo cerradura;

void abrirPuerta() {
  cerradura.write(ANGULO_ABIERTA);
  digitalWrite(PIN_LED_VERDE, HIGH);
  digitalWrite(PIN_LED_ROJO, LOW);
}

void cerrarPuerta() {
  cerradura.write(ANGULO_CERRADA);
  digitalWrite(PIN_LED_VERDE, LOW);
  digitalWrite(PIN_LED_ROJO, HIGH);
}

void setup() {
  pinMode(PIN_LED_VERDE, OUTPUT);
  pinMode(PIN_LED_ROJO, OUTPUT);
  // Con INPUT_PULLUP el pulsador lee HIGH en reposo y LOW al presionarse.
  pinMode(PIN_BOTON_ABRIR, INPUT_PULLUP);
  pinMode(PIN_BOTON_CERRAR, INPUT_PULLUP);

  cerradura.attach(PIN_SERVO);
  // Estado inicial: CERRADA (LED rojo), estado seguro por defecto.
  cerrarPuerta();
}

void loop() {
  // Pulsador presionado = LOW (por el pull-up interno).
  if (digitalRead(PIN_BOTON_ABRIR) == LOW) {
    abrirPuerta();
    delay(ANTIRREBOTE_MS);
  }

  if (digitalRead(PIN_BOTON_CERRAR) == LOW) {
    cerrarPuerta();
    delay(ANTIRREBOTE_MS);
  }
}

Podés ver el comportamiento —los botones moviendo el servo y los LED cambiando de estado— en el simulador, antes de armar el circuito real:

Con el circuito probado, decidimos si cerramos el proyecto en este nivel o si avanzamos al intermedio para sumarle el teclado. Si vamos a dejar la maqueta armada, conviene pasar de la protoboard a un montaje más firme: soldar los cables a los componentes para que las conexiones no se suelten cuando el mecanismo se mueva.

El mecanismo de la cerradura se fabrica con piezas impresas en 3D. La idea es un piñón-cremallera: el servo hace girar un piñón (un engranaje) que empuja una cremallera (una barra dentada), y esa barra es la que se corre para trabar o destrabar la puerta, como un pasador.

Estas piezas forman parte de los paquetes de fabricación del proyecto, que se descargan desde su ficha. Si querés modificar el modelo, sea cual sea el programa de diseño 3D que uses, tenés que exportar 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., el estándar para intercambiar e imprimir modelos sólidos.

Con las piezas impresas, ensamblamos el mecanismo sobre el servomotor: el piñón se calza en el eje del servo y engrana con la cremallera, de modo que al girar el servo (a 90° o a 0°) la barra se corra y trabe o destrabe la cerradura.

Una vez armado, el sistema se fija a la puerta (o a una apertura similar) y allí se ubican los LED y los pulsadores, al alcance de quien la va a usar.