UNIDAD EDUCATIVA PARTICULAR PDTE.
“CARLOS JULIO AROSEMENA
TOLA”
Título del proyecto
Implementación de un Sistema de Seguridad Electrónico para Control de Acceso en
Puertas y Cajas de Seguridad en la Unidad Educativa Particular Pdte. “Carlos Julio
Arosemena Tola”
Nombres de los integrantes del grupo
Orrala Gustavo
Meza Roberto
Estrada Elian
Materias involucradas
Soporte Técnico
Matemática
Sistemas
Operativos
Programación
Curso
3ro Informática A
Fecha de entrega
Domingo 12 de enero del 2025
Tabla de contenido
1. Resumen Ejecutivo......................................................................................................3
2. Introducción.................................................................................................................4
3. Objetivos.......................................................................................................................5
4. Marco Teórico..............................................................................................................6
5. Metodología..................................................................................................................9
6. Desarrollo del Proyecto.............................................................................................10
6.1 Diseño del Proyecto..............................................................................................10
6.2 Desarrollo de Software........................................................................................10
6.3 Implementación Piloto.........................................................................................10
7. Resultados..................................................................................................................11
8. Conclusiones y Recomendaciones............................................................................12
Conclusiones...............................................................................................................12
Recomendaciones.......................................................................................................12
9. Memoria Técnica.......................................................................................................13
10. Bibliografia...............................................................................................................14
11. Anexos.......................................................................................................................15
Código del arduino.....................................................................................................19
Ilustración 1 Conexion de los jumpers...........................................................................15
Ilustración 2 Diodos leds...............................................................................................15
Ilustración 3 BUZZER...................................................................................................16
Ilustración 4 ARDUINO................................................................................................16
Ilustración 5 PROTOTIPO TERMINADO....................................................................17
1. Resumen Ejecutivo
Propósito y Objetivos Principales
El proyecto consiste en el desarrollo de un sistema de control de acceso electrónico utilizando
Arduino y componentes electrónicos básicos, como LEDs, un teclado matricial, un servo
motor, un buzzer y una pantalla LCD. El objetivo principal es permitir el ingreso mediante
una contraseña y bloquear el sistema tras varios intentos fallidos. (Arduino, 2024)
Metodología Utilizada
El desarrollo del proyecto se llevó a cabo en cinco etapas:
1. Investigación sobre componentes electrónicos y la plataforma Arduino.
2. Diseño y simulación del circuito en Tinkercad.
3. Ensamblaje físico del prototipo en una protoboard.
4. Programación en el entorno Arduino IDE.
5. Pruebas y ajustes del sistema para asegurar su funcionamiento.
Resultados Clave
El sistema valida contraseñas correctamente, controla LEDs para indicar acceso permitido o
denegado, acciona un servo motor para desbloquear la cerradura, y bloquea temporalmente el
acceso tras tres intentos fallidos, emitiendo una alerta sonora periódica con el buzzer.
Relevancia del Proyecto
Este proyecto proporciona una solución económica y educativa para el control de acceso en
espacios restringidos, aplicable en entornos domésticos, escolares y laborales. Además, sirve
como plataforma de aprendizaje en electrónica y programación.
2. Introducción
Contextualización del Proyecto
En la actualidad, el control de acceso es un aspecto clave en la seguridad de hogares, oficinas
y áreas restringidas. Las soluciones comerciales suelen ser costosas y complejas, lo que limita
su uso en entornos pequeños. Este proyecto aborda esa necesidad mediante un sistema
sencillo y económico que emplea componentes básicos y un microcontrolador Arduino.
Importancia del Circuito y su Aplicación en la Vida Real
Este sistema es fácil de implementar y económico, permitiendo aplicaciones prácticas como:
Control de accesos en puertas de casas u oficinas.
Protección de equipos en laboratorios escolares o talleres.
Sistemas de aprendizaje en instituciones educativas para enseñar electrónica y
programación básica.
3. Objetivos
Objetivo General
Desarrollar un sistema electrónico de control de acceso seguro y eficiente, basado en
Arduino, que permita gestionar el ingreso mediante una contraseña alfanumérica, notificando
al usuario mediante una interfaz visual y sonora.
Objetivos Específicos
1. Comprender el funcionamiento y características de los componentes
electrónicos utilizados.
2. Diseñar y simular el circuito en software especializado como Tinkercad.
3. Construir el circuito físico en una protoboard y programar el sistema en
Arduino IDE.
4. Marco Teórico
Circuitos Electrónicos
Un circuito eléctrico es un grupo de elementos interconectados entre si por los que puede
circular o fluir una corriente eléctrica. Está compuesto por varios componentes que trabajan
juntos para permitir que la corriente eléctrica se mueva de un lugar a otro de manera
controlada.
Serie: Es un circuito en el que los componentes eléctricos están conectados en
secuencia, y la corriente fluye a través de ellos en una sola ruta.
Paralelo: Es un circuito en el que los componentes eléctricos están conectados
de tal manera que la corriente puede fluir a través de ellos de forma simultánea y separada.
Mixto: Es un circuito que combina elementos de circuitos en serie y en
paralelo.
Ejemplo: Los LEDs y resistencias en este proyecto funcionan en serie, limitando la corriente.
(Electrónica, 2017)
Componentes Electrónicos
Resistencias: Limitan la corriente para proteger componentes. Ejemplo:
resistencias de 220Ω en serie con los LEDs.
LEDs: Emiten luz cuando circula corriente. LED verde (acceso permitido),
LED rojo (acceso denegado).
Buzzer: Genera sonidos de advertencia. Se usa para alertar sobre errores o
bloqueos.
Servo Motor: Mueve la cerradura al permitir el acceso.
Teclado Matricial 4x4: Permite al usuario ingresar la contraseña.
Pantalla LCD I2C: Muestra mensajes claros al usuario, como instrucciones o
estados del sistema. (TodoElectrónica, 2024)
Ley de Ohm
La Ley de Ohm es una de las leyes más importantes en la electricidad. Establece una relación
entre el voltaje, la corriente y la resistencia en un circuito. Esta relación se expresa mediante
la fórmula:
V=R·I
Donde:
V es el voltaje en voltios.
I es la corriente en amperios.
R es la resistencia en ohmios. (Electrónica, 2017)
Ejemplo:
Con una resistencia de 20Ω y un voltaje de 3A:
V= I * R = 3A * 20 Ω = 60V
Variaciones de Voltaje y Corriente
En los LEDs, si la resistencia aumenta, la corriente disminuye y el brillo se
reduce.
La corriente debe ser controlada para evitar daños en los componentes.
Funciones de los Prototipos
Los prototipos permiten validar diseños antes de una implementación final, facilitando:
1. Detección de errores.
2. Pruebas funcionales para verificar conexiones y código.
3. Optimización de rendimiento sin comprometer recursos.
5. Metodología
1. Investigación
Se recopiló información sobre componentes electrónicos y teoría básica en sitios como
Prometec, Luis Llamas y TodoElectrónica.
2. Diseño
o El esquema del circuito se diseñó y simuló en Tinkercad.
3. Construcción
o El circuito se ensambló en una protoboard, asegurando conexiones correctas
entre Arduino, LEDs, teclado, buzzer y servo motor.
4. Pruebas
o Se verificó el ingreso de contraseñas, el bloqueo tras intentos fallidos y las
respuestas del servo, LEDs y buzzer.
5. Documentación
o Registro detallado de cada etapa, diagramas y pruebas realizadas.
6. Desarrollo del Proyecto
6.1 Diseño del Proyecto
Herramienta: Tinkercad. (Tinkercad, s.f.)
Componentes seleccionados: Arduino UNO, teclado matricial, LEDs, buzzer,
servo motor SG90, resistencias de 220Ω y pantalla LCD I2C. (Arduino E. C., 2023)
6.2 Desarrollo de Software
El código en Arduino IDE realiza:
Verificación de la contraseña ingresada.
Control del servo motor para abrir la cerradura.
Bloqueo del sistema tras tres intentos fallidos con sonido del buzzer y mensaje
en LCD.
6.3 Implementación Piloto
1. Ensamblaje del circuito en la protoboard.
2. Pruebas funcionales: ingreso correcto e incorrecto de la contraseña.
3. Ajuste de tiempos y configuración del buzzer para bloqueo.
7. Resultados
Prueba Resultado Esperado Resultado Obtenido
Contraseña correcta Acceso permitido Acceso permitido
Visualización de clave Mostrar * en LCD Clave visualizada como *
Contraseña incorrecta Acceso denegado Acceso denegado
3 intentos fallidos Sistema bloqueado por 1 Sistema bloqueado
minuto correctamente
Buzzer durante bloqueo Sonido periódico Sonido cada 5 segundos
Contador de tiempo Mostrar tiempo en Tiempo mostrado
abierto segundos correctamente
Cierre de la puerta Servo regresa a posición Servo regresó tras tiempo
inicial límite
El sistema funcionó según lo esperado, validando correctamente contraseñas y
bloqueando el acceso tras varios intentos fallidos.
8. Conclusiones y Recomendaciones
Conclusiones
El prototipo cumplió con su objetivo de implementar un sistema de control de
acceso funcional y económico.
El uso de Arduino permitió integrar fácilmente los componentes electrónicos.
Recomendaciones
Alimentar el sistema con una fuente externa para mayor estabilidad.
Incorporar un sistema de almacenamiento para contraseñas dinámicas o un
lector RFID.
9. Memoria Técnica
Conexiones: LEDs (pines 12 y 13), buzzer (pin 11), servo (pin 10), teclado
matricial (pines 2-9), pantalla LCD (SDA/A4, SCL/A5).
Componentes: Resistencias de 220Ω, LEDs, buzzer, teclado 4x4, servo SG90
y pantalla LCD I2C.
10. Bibliografia
Arduino. (2024). Arduino . Obtenido de Plataforma de Desarrollo Electrónico:
https://www.arduino.cc/
Arduino, E. C. (2023). El Cajón de Arduino. Obtenido de Guías y Proyectos de Arduino:
https://www.elcajondearduino.com/
Electrónica, R. E. (29 de Septiembre de 2017). redeweb. Obtenido de redeweb:
https://www.redeweb.com/actualidad/los-circuitos-electricos/#:~:text=Tipos%20de
%20circuitos%20el%C3%A9ctricos&text=Circuito%20paralelo%3A%20es%20un
%20circuito,en%20serie%20y%20en%20paralelo.
Tinkercad. (s.f.). Obtenido de https://www.tinkercad.com.
TodoElectrónica. (2024). Componentes y Tutoriales de Arduino. Obtenido de
https://www.todoelectronica.com/
11. Anexos
ILUSTRACIÓN 1 CONEXION DE LOS JUMPERS
Se muestran las conexiones con cables tipo jumper utilizadas para interconectar los
componentes electrónicos en la protoboard y el Arduino.
ILUSTRACIÓN 2 DIODOS LEDS
La instalación de los LEDs verde y rojo, utilizados como indicadores visuales para
señalar el estado de acceso permitido o denegado.
ILUSTRACIÓN 3 BUZZER
Fotografía del buzzer piezoeléctrico conectado al circuito, responsable de emitir
señales audibles en diferentes eventos, como acceso correcto o bloqueo por intentos fallidos.
ILUSTRACIÓN 4 ARDUINO
La placa microcontroladora encargada de gestionar y controlar el funcionamiento del
sistema, procesando entradas y generando las salidas correspondientes.
ILUSTRACIÓN 5 PROTOTIPO TERMINADO
Se presenta el circuito completo montado en una protoboard, mostrando todas las
conexiones funcionales entre el teclado matricial, LEDs, buzzer, servo motor y pantalla LCD.
ILUSTRACIÓN 6 COMIENZO DE LA MAQUETA
Iniciales de la construcción de la maqueta, donde se preparan las bases y el diseño del
entorno físico que integra el sistema electrónico.
ILUSTRACIÓN 7 MAQUETA TERMINADA
Maqueta final ensamblada, con todos los componentes montados y funcionando como un
sistema de control de acceso visualmente estructurado.
ILUSTRACIÓN 8 MAQUETA POR DETRÁS
Vista posterior de la maqueta, mostrando la organización de las conexiones y cables, así
como la integración del circuito electrónico en la estructura física.
Código del arduino
#include <Key.h>
#include <Keypad.h>
#include <Wire.h>
#include <LiquidCrystal_I2C.h>
#include <Servo.h>
// Declaraciones de funciones
void manejarError(); // Maneja intentos fallidos y bloqueo del sistema
void abrirPuerta(); // Función para abrir la puerta y cerrar después del tiempo
void mostrarIngresarClave(); // Muestra mensaje para ingresar la clave en el LCD
// Definición del LCD I2C
LiquidCrystal_I2C lcd(0x27, 16, 2); // Configuración de la pantalla LCD de 16x2 usando
dirección 0x27
// Definición del teclado 4x4
const byte FILAS = 4;
const byte COLUMNAS = 4;
// Matriz de teclas del teclado matricial
char teclas[FILAS][COLUMNAS] = {
{'1', '2', '3', 'A'},
{'4', '5', '6', 'B'},
{'7', '8', '9', 'C'},
{'*', '0', '#', 'D'}
};
// Pines conectados al teclado
byte pinesFilas[FILAS] = {9, 8, 7, 6}; // Pines para las filas del teclado
byte pinesColumnas[COLUMNAS] = {5, 4, 3, 2}; // Pines para las columnas del teclado
Keypad teclado = Keypad(makeKeymap(teclas), pinesFilas, pinesColumnas, FILAS,
COLUMNAS); // Inicialización del teclado
// Definición del servo
Servo servoMotor; // Objeto para controlar el servo motor
int servoPin = 10; // Pin donde está conectado el servo
// Definición del buzzer
int buzzerPin = 11; // Pin donde está conectado el buzzer
// Pines de los LEDs
int ledVerdePin = 12; // LED verde (acceso permitido)
int ledRojoPin = 13; // LED rojo (acceso denegado)
// Contraseña y variables de control
char password[5] = "1234"; // Contraseña predefinida de 4 dígitos
char entradaUsuario[5]; // Almacena la contraseña ingresada por el usuario
int indice = 0; // Contador para la cantidad de teclas presionadas
bool accesoPermitido = false; // Bandera para verificar si el acceso fue exitoso
// Variables para intentos fallidos y bloqueo del sistema
int intentosFallidos = 0; // Contador de intentos fallidos
const int maxIntentos = 3; // Número máximo de intentos permitidos
unsigned long tiempoBloqueo = 0; // Tiempo en que comenzó el bloqueo
const unsigned long duracionBloqueo = 60000; // Duración del bloqueo en milisegundos (1
minuto)
bool bloqueado = false; // Bandera para verificar si el sistema está bloqueado
void setup() {
// Inicialización de la pantalla LCD
lcd.begin(16, 2);
lcd.backlight();
// Configuración del servo motor
servoMotor.attach(servoPin);
servoMotor.write(0); // Posición inicial del servo (cerrado)
// Configuración de pines del buzzer y LEDs
pinMode(buzzerPin, OUTPUT);
pinMode(ledVerdePin, OUTPUT);
pinMode(ledRojoPin, OUTPUT);
// Configuración de comunicación serial (para pruebas)
Serial.begin(9600);
// Mensaje inicial de bienvenida
lcd.setCursor(0, 0);
lcd.print("Bienvenido!");
delay(2000);
lcd.clear();
mostrarIngresarClave(); // Mostrar el mensaje para ingresar clave
void loop() {
// Si el sistema está bloqueado, muestra el tiempo restante
if (bloqueado) {
unsigned long tiempoRestante = (duracionBloqueo - (millis() - tiempoBloqueo)) / 1000; //
Cálculo del tiempo restante
lcd.setCursor(0, 0);
lcd.print("Bloqueado!");
lcd.setCursor(0, 1);
lcd.print("Intenta en ");
lcd.print(tiempoRestante);
lcd.print(" seg");
// Verificar si el tiempo de bloqueo ha finalizado
if (millis() - tiempoBloqueo >= duracionBloqueo) {
bloqueado = false;
intentosFallidos = 0; // Reiniciar contador de intentos fallidos
lcd.clear();
lcd.setCursor(0, 0);
lcd.print("Sistema desbloq.");
delay(2000);
lcd.clear();
mostrarIngresarClave(); // Mostrar nuevamente el mensaje de clave
return; // Salir del loop hasta que termine el bloqueo
// Leer tecla ingresada
char tecla = teclado.getKey();
if (tecla) {
tone(buzzerPin, 1000, 100); // Confirmación sonora al presionar una tecla
lcd.setCursor(0, 0);
lcd.print("Ingresar clave:");
lcd.setCursor(0, 1);
if (tecla == '#') { // Revisar la contraseña al presionar "#"
revisarPassword();
indice = 0;
limpiarEntrada();
} else if (tecla == '*') { // Reiniciar ingreso de clave al presionar "*"
indice = 0;
limpiarEntrada();
lcd.clear();
mostrarIngresarClave();
} else if (indice < 4) { // Almacenar la tecla ingresada hasta 4 dígitos
entradaUsuario[indice] = tecla;
lcd.setCursor(indice, 1);
lcd.print("*"); // Mostrar asterisco en lugar del número ingresado
indice++;
}
}
void revisarPassword() {
// Comparar contraseña ingresada con la correcta
if (strcmp(entradaUsuario, password) == 0) {
accesoPermitido = true;
abrirPuerta();
} else {
accesoPermitido = false;
manejarError();
void limpiarEntrada() {
// Limpiar el buffer donde se almacena la clave ingresada
for (int i = 0; i < 4; i++) {
entradaUsuario[i] = '\0';
lcd.clear();
}
void abrirPuerta() {
// Acción al ingresar la contraseña correcta
lcd.clear();
lcd.setCursor(0, 0);
lcd.print("Acceso Permitido");
// Activar LED verde y mover servo
digitalWrite(ledVerdePin, HIGH);
digitalWrite(ledRojoPin, LOW);
servoMotor.write(60); // Mover el servo a posición abierta
tone(buzzerPin, 1000, 200); // Sonido de confirmación
// Contador regresivo de tiempo para cerrar la puerta
for (int i = 15; i > 0; i--) {
lcd.setCursor(0, 1);
lcd.print("Cerrando en ");
lcd.print(i);
lcd.print(" s ");
delay(1000);
}
// Cerrar la puerta
servoMotor.write(0);
digitalWrite(ledVerdePin, LOW); // Apagar LED verde
// Mostrar mensaje de puerta cerrada
lcd.clear();
lcd.setCursor(0, 0);
lcd.print("Puerta cerrada");
lcd.setCursor(0, 1);
lcd.print("Ingresa de nuevo");
delay(2000);
lcd.clear();
mostrarIngresarClave();
void manejarError() {
// Acción al ingresar una contraseña incorrecta
lcd.clear();
lcd.setCursor(0, 0);
lcd.print("Acceso Denegado");
digitalWrite(ledRojoPin, HIGH); // Encender LED rojo
tone(buzzerPin, 500, 500); // Sonido de error
delay(1000);
digitalWrite(ledRojoPin, LOW);
intentosFallidos++; // Incrementar contador de intentos fallidos
// Bloquear sistema si se exceden los intentos
if (intentosFallidos >= maxIntentos) {
bloqueado = true;
tiempoBloqueo = millis();
lcd.clear();
lcd.setCursor(0, 0);
lcd.print("Demasiados Fallos");
lcd.setCursor(0, 1);
lcd.print("Sistema Bloqueado");
delay(2000);
lcd.clear();
} else {
mostrarIngresarClave();
}
}
void mostrarIngresarClave() {
// Mensaje inicial para solicitar la clave
lcd.setCursor(0, 0);
lcd.print("Ingresar clave:");
lcd.setCursor(0, 1);
lcd.print(" ");
