UNIVERSIDAD PRIVADA DEL VALLE

FACULTAD DE INFORMATICA Y ELECTRONICA

INGENIERIA ELECTRONICA
Evaluación
SEDE LA PAZ

DOMOTICA (A)

Informe de Laboratorio N.º 1

“APLICACIÓN DE
MICROCONTROLADORES EN SISTEMAS
DOMÓTICOS”

Estudiantes:
Chura Flores Ronaldo Gabriel
Omonte Gutiérrez Daynor Manuel

Docente: Ing. Rómulo Roberto

Verástegui Mamani
La Paz, 1 de Abril de 2024
Gestión 1 – 2024
1. OBJETIVO

1.1. OBJETIVOS GENERALES

 Programar el microcontrolador stm32f103c8t6 para que actúe como llave digital e

implementar el circuito electrónico en un protoboard.

1.2. OBJETIVOS ESPECÍFICOS

 Definir las entradas y salidas necesarias para que el microcontrolador actúe como una
llave digital.

 Utilizar un teclado matricial 4x4 y una pantalla lcd para visualizar los resultados.

2. MARCO TEÓRICO

2.1. STM32F103T8C6

(ProfetoLocka, 2021) indica que la familia de microcontroladores STM32 se basa en núcleos

ARM Cortex-M de 32 bits. Estos microcontroladores se encuentran disponibles en una variedad
de modelos, desde aquellos con un núcleo M0 hasta los que tienen un núcleo M7. Los diferentes
modelos también varían en la cantidad de memoria RAM y Flash, los periféricos que incluyen y
su precio. ProfetoLocka. (2021, 29 de marzo). La familia de microcontroladores STM32.
Recuperado el 1 de abril de 2024, de https://www.profetolocka.com.ar/2021/03/29/la-familia-de-
microcontroladores-stm32/

CARACTERISTICAS:

 Microcontrolador: STM32F103C8T6.
 Arquitectura: 32Bits ARM Córtex M3.
 Compatibilidad con IDE de Arduino.
 Programador/depurador: ST-LINK/V2-1.
 Frecuencia de trabajo: 72Mhz.
 Memoria Flash de 64Kbyts.
 SRAM de 20Kbyts.
 2x ADC de 12 bits.
 37 GPIOs de I/O.
 Comunicación:
 2x SPI
 2x I2C
 3x USART
 1x USB
 1X CAN
 2.3. TECLADO MATRICIAL

(ElectronicaMade, 2023) describe un teclado matricial 4x4 como un dispositivo que agrupa varios
pulsadores y permite controlarlos con menos conductores de los que se necesitarían si se usaran
de forma individual. Estos teclados se pueden usar como controladores para autómatas o
procesadores como Arduino. ElectronicaMade. (2023, 14 de febrero). Teclado Matricial 4x4.
Recuperado el 1 de abril de 2024, de https://electronicamade.com/teclado-matricial-4x4/

2.3.1. ¿Cómo funciona?

(ElectronicaMade, 2023) describe la organización de un teclado

matricial 4x4 como una matriz de pulsadores dispuestos en filas
(L1, L2, L3 y L4) y columnas (C1, C2, C3 y C4). Esta
disposición reduce el número de pines necesarios para su
conexión y programación, requiriendo solo 8 pines del
microcontrolador en lugar de 16 independientes. Para leer el
botón pulsado, se utiliza una técnica de barrido que va más allá
de la simple lectura del pin del microcontrolador.
ElectronicaMade. (2023, 14 de febrero). Teclado Matricial 4x4.
Recuperado el 1 de abril de 2024, de
https://electronicamade.com/teclado-matricial-4x4/

2.4. PANTALLA LCD

2.4.1. ¿Qué son los LCD?

(ElectronicaMade, 2023) describe una pantalla LCD o Liquid

Cristal Display como una pantalla delgada con pixeles a color
que reflejan la luz. Posee un bajo consumo de electricidad y
es liviana. Las imágenes se visualizan en la pantalla
manipulando la orientación de los cristales mediante cargas
eléctricas y voltajes específicos.También indica que los
paneles LCD tienen un rango variado de resolución desde
1920x1080 a 128x64, lo que permite la visualización en
tamaños pequeños. Además, se necesitan solo 6 pines de
cualquier microcontrolador para utilizar una pantalla LCD,
aunque si se incorpora un módulo i2c, solo se requieren dos
pines.
ElectronicaMade. (2023, 14 de febrero). LCD - Liquid Cristal
Display. Recuperado el 1 de abril de 2024, de
https://electronicamade.com/lcd-liquid-crystal-display/

2.5. DOMOTICA Y SEGURIDAD

 (DomoticayHogar, 2023) define la domótica aplicada a la seguridad como la tecnología que
permite a los propietarios de una vivienda interactuar menos con los dispositivos de seguridad,
automatizando tareas y permitiendo que la casa inteligente las gestione por sí misma.

(DomoticayHogar, 2023) también menciona que la domótica ofrece seguridad inteligente

en cuatro niveles:

 Protección domótica exterior: detecta la presencia de movimiento u objetos extraños en

los alrededores de la vivienda.

 Protección domótica interior: protege contra peligros dentro de la vivienda, actuando en

caso de que el sistema externo sea vulnerado o si el peligro solo ocurre dentro de la casa.

 Protección personal en las casas domóticas reales: evita que las personas sufran daños o
accidentes en caso de intrusión o peligro.

 Sistema inteligente de alarmas técnicas o de detección: activa automáticamente sistemas

de seguridad en caso de incendio, como la apertura de ventanas o puertas.
DomoticayHogar. (2023, 27 de abril). Domótica y Seguridad. Recuperado el 1 de abril de
2024, de https://domoticayhogar.com/domotica-seguridad/

3. LISTA DE MATERIALES, INSUMOS Y EQUIPOS

Breadboard

STM32F103C8T6
 ST-LINK/V2

LCD 16x2-I2C

LED Verde y Rojo

Teclado Matricial 4x4

Resistencias de 220 Ω

4. CIRCUITO APLICADO
4.1. LAY OUT DEL CIRCUITO

4.2. CIRCUITO ARMADO

5. DESARROLLO DEL LABORATORIO

5.1. DISEÑO DEL CIRCUITO

Proceso de conexión:

 Conectar el microcontrolador STM32 a la protoboard.

 Conectar las líneas de datos (SDA y SCL) de la pantalla LCD a los pines PA-9 Y PA-10
respectivamente.

 Conectar el teclado matricial 4x4 al protoboard de los pines A0 – A7 de microcontrolador

stm32.

 Conecta los LEDs (rojo y verde) a la protoboard y a los pines GPIO B7 Y B8, con sus
respectivas resistencias limitadoras de corriente.

 Alimentar respectivamente a cada terminal del circuito.

Proceso de grabado:

Para este paso se hace uso del grabador st-link que se encarga de quemar o grabar el código
realizado en ide cube en el microcontrolador stm32f103t8c6, para poder grabar el programa
debemos activar el modo de funcionamiento 1 con los jumpers:
Explicación de funcionamiento

El proceso de funcionamiento se explica en la siguiente parte del código

char tecla;
char entrada_usuario [6] = "";
char clave_correcta [] = "#DCBA";
int intentos_restantes = 3;
int estado_parpadeo = 0;

 tecla: Se utiliza para almacenar la tecla presionada por el usuario.

 entrada usuario: Es un arreglo de caracteres que almacena la entrada actual del usuario.
Se inicializa con una cadena vacía de longitud 6.

 clave_correcta: Es un arreglo de caracteres que almacena la clave correcta.

 intentos_restantes: Es un entero que almacena el número de intentos restantes para

ingresar la clave correcta.

 estado_parpadeo: Es un entero que indica el estado de parpadeo, donde 0 significa

apagado y 1 significa encendido.

Gracias a idecude contamos con las librerías suficientes para controlar la pantalla lcd con i2c y
también para el teclado matricial 4x4. Las librerías que se usaron son:

#include "liquidcrystal_i2c.h"
#include "keypad_4x4.h"
#include <string.h>
#include <stdio.h

Al inicio la pantalla lcd de muestra al usuario el nombre del usuario y solicitando el ingreso de la
contraseña, mediante el teclado matricial se procede a introducir la contraseña de 5 espacios si se
ingresa la contraseña correcta, el mensaje de acceso aparece en la pantalla y a continuación se
enciente el led verde, en cambio sí se introduce la contraseña incorrecta se enciende el led rojo.
 Ilustración 1 armado del circuito

Ilustración 2 segundo intento de contraseña

5.2. DIAGRAMA DE FLUJO

5.3. PROGRAMA

#include "liquidcrystal_i2c.h"
#include "keypad_4x4.h"
#include <string.h>
#include <stdio.h>
/* Private variables ---------------------------------------------------------*/
/* USER CODE BEGIN PV */
char tecla;
char entrada_usuario [6] = "";
char clave_correcta [] = "#DCBA";
int intentos_restantes = 3;
int estado_parpadeo = 0;
/* USER CODE END PV */
/**
* @brief The application entry point.
* @retval int
*/
int main(void)
{
/* USER CODE BEGIN 1 */

/* USER CODE END 1 */

/* MCU Configuration--------------------------------------------------------*/

/* Reset of all peripherals, Initializes the Flash interface and the Systick. */
HAL_Init();

/* USER CODE BEGIN Init */

/* USER CODE END Init */

/* Configure the system clock */

SystemClock_Config();

/* USER CODE BEGIN SysInit */

/* USER CODE END SysInit */

/* Initialize all configured peripherals */

MX_GPIO_Init();
MX_I2C1_Init();
/* USER CODE BEGIN 2 */

HD44780_Init(2);
HD44780_Clear();
HD44780_SetCursor(0,0);
 HD44780_PrintStr("DOMOTICA OMONTE ");
HD44780_SetCursor(0,1);
HD44780_PrintStr("PASSWORD: ");
/* USER CODE END 2 */

/* Infinite loop */
/* USER CODE BEGIN WHILE */
while (1)
{
/* USER CODE END WHILE */

/* USER CODE BEGIN 3 */

// Aquí comienza el bucle principal del programa

if (estado_parpadeo)
{
// Si estado_parpadeo es verdadero, se activa el parpadeo de un LED rojo
HAL_GPIO_TogglePin(ROJO_GPIO_Port, ROJO_Pin);
HAL_Delay(500); // Se realiza un retardo de 500 ms
}

// Se obtiene la tecla presionada por el usuario

tecla = Keypad_Get_Char();

if(tecla != 0) // Si se ha presionado una tecla válida

{
if (estado_parpadeo && strlen(entrada_usuario) == 5)
{
// Si el parpadeo está activo y la longitud de la entrada del usuario es 5, se continúa
esperando más entrada
continue;
}
strcat(entrada_usuario, &tecla); // Se agrega la tecla presionada a la entrada del
usuario
HD44780_Clear(); // Se borra la pantalla LCD
HD44780_SetCursor(0,0); // Se posiciona el cursor en la primera línea
HD44780_PrintStr("PASWORD: "); // Se imprime el mensaje "PASSWORD: "
en la primera línea
HD44780_SetCursor(0,1); // Se posiciona el cursor en la segunda línea
HD44780_PrintStr(entrada_usuario); // Se imprime la entrada del usuario en la
segunda línea de la pantalla LCD
}

if(strlen(entrada_usuario) == 5) // Si la longitud de la entrada del usuario es igual a 5

{
if(strcmp(entrada_usuario, clave_correcta) == 0) // Si la entrada del usuario es
igual a la clave correcta
{
// Se enciende un LED verde durante 2 segundos para indicar un acceso correcto
HAL_GPIO_WritePin(VERDE_GPIO_Port, VERDE_Pin, GPIO_PIN_SET);
HAL_Delay(2000);
 HAL_GPIO_WritePin(VERDE_GPIO_Port, VERDE_Pin,
GPIO_PIN_RESET);

HD44780_Clear(); // Se borra la pantalla LCD

HD44780_SetCursor(0,0); // Se posiciona el cursor en la primera línea
HD44780_PrintStr("CORRECT ACCESS: "); // Se imprime el mensaje
"CORRECT ACCESS: " en la primera línea
HAL_Delay(2000); // Se realiza un retardo de 2 segundos

estado_parpadeo = 0; // Se desactiva el parpadeo

HAL_GPIO_WritePin(ROJO_GPIO_Port, ROJO_Pin, GPIO_PIN_RESET); //
Se apaga el LED rojo

break; // Se sale del bucle while

}
else // Si la entrada del usuario no es igual a la clave correcta
{
intentos_restantes--; // Se reduce el número de intentos restantes
if(intentos_restantes > 0) // Si aún quedan intentos restantes
{
// Se enciende un LED rojo durante 2 segundos para indicar un acceso incorrecto
HAL_GPIO_WritePin(ROJO_GPIO_Port, ROJO_Pin,
GPIO_PIN_SET);
HAL_Delay(2000);
HAL_GPIO_WritePin(ROJO_GPIO_Port, ROJO_Pin,
GPIO_PIN_RESET);
}
else // Si no quedan intentos restantes
{
estado_parpadeo = 1; // Se activa el parpadeo
HD44780_Clear(); // Se borra la pantalla LCD
HD44780_SetCursor(0,0); // Se posiciona el cursor en la primera línea
HD44780_PrintStr("LOCKED KEY : "); // Se imprime el mensaje
"LOCKED KEY : " en la primera línea
}
strcpy(entrada_usuario, ""); // Se borra la entrada del usuario
HD44780_Clear(); // Se borra la pantalla LCD
HD44780_SetCursor(0,0); // Se posiciona el cursor en la primera línea
HD44780_PrintStr("INCORRECT ACCESS "); // Se imprime el mensaje
"INCORRECT ACCESS " en la primera línea
HD44780_SetCursor(0,1); // Se posiciona el cursor en la segunda línea
HD44780_PrintStr("TRIED Nro: "); // Se imprime el mensaje "TRIED Nro: "
en la segunda línea
char str_intentos_restantes[2]; // Se declara un buffer para almacenar la cadena
de intentos restantes
sprintf(str_intentos_restantes, "%d", intentos_restantes); // Se convierte el
número de intentos restantes a cadena
HD44780_PrintStr(str_intentos_restantes); // Se imprime la cadena de intentos
restantes en la segunda línea de la pantalla LCD

HAL_Delay(2000); // Se realiza un retardo de 2 segundos

 HD44780_Clear(); // Se borra la pantalla LCD
HD44780_SetCursor(0,0); // Se posiciona el cursor en la primera línea
HD44780_PrintStr("ENTER PASSWORD: "); // Se imprime el mensaje
"ENTER PASSWORD: " en la primera línea
}
}
return 0; // Se devuelve 0 para indicar una salida exitosa del programa
/* USER CODE END 3 */
}
6. FIRMAS DE LABORATORIO

7. CUESTIONARIO.
 7.1. Explique de forma breve el concepto de domótica e inmódica.

Domótica: La domótica es un conjunto de tecnologías aplicadas a la automatización y

control inteligente de una vivienda o edificio, con el objetivo de mejorar la calidad de
vida, la seguridad, la eficiencia energética y la comodidad de sus ocupantes. Esto se logra
mediante la integración de dispositivos electrónicos, sistemas de comunicación, sensores,
actuadores y software, que permiten la gestión remota y automatizada de diversas
funciones como la iluminación, la climatización, los sistemas de seguridad, los
electrodomésticos, entre otros.

Inmótica: La inmótica se refiere a la aplicación de tecnologías similares a la domótica,

pero a escala de edificios comerciales, industriales o institucionales. A diferencia de la
domótica, que se centra en viviendas individuales, la inmótica abarca la automatización y
control inteligente de sistemas complejos y de gran escala, como la gestión de la
iluminación, el control de accesos, la climatización, la supervisión energética y la
seguridad en edificios de oficinas, hoteles, hospitales, centros comerciales, entre otros.

7.2 Explique el proceso de verificación de clave que usted utiliza en su código.

El proceso de verificación de clave en el código consiste en validar la entrada del usuario

comparándola con una clave predefinida.
La entrada del usuario se almacena en una variable entrada_usuario.
Cuando la longitud de la entrada del usuario alcanza 5 caracteres, se compara con una
clave predefinida (clave_correcta).

Si la entrada del usuario coincide con la clave correcta, se activa un LED verde y se
muestra un mensaje de acceso correcto en el LCD.
Si la entrada del usuario no coincide con la clave correcta, se decrementa el contador de
intentos restantes y se muestra un mensaje de acceso incorrecto en el LCD.
Si se agotan los intentos restantes, se activa un estado de parpadeo y se muestra un
mensaje de bloqueo en el LCD, impidiendo el acceso hasta que se reinicie el sistema.

8. CONCLUSIONES

El código implementado para este laboratorio cumplió con los objetivos planteados ya
que se pudo crear una llave digital haciendo uso del microcontrolador stm32f103t8c6
como cerebro del circuito, usando un teclado matricial para introducir la llave digital de 5
dígitos o caracteres visualizando todos estos resultados en la pantalla lcd, se realizó el uso
del módulo i2c para la pantalla lcd que nos ayuda a usar menos pines del stm32.
En el ámbito de seguridad en domótica se demostró que este proyecto puede ser
implementado como una chapa inteligente, pues podemos controlar el acceso a un cuarto
o vivienda introduciendo la contraseña correcta.

9. REFERENCIAS BIBLIOGRÁFICAS

DomoticayHogar. (2023, 27 de abril). Domótica y Seguridad. Recuperado el 1 de abril de 2024,

de https://domoticayhogar.com/domotica-seguridad/
EstradaGardea, V. ., & GallegosReyes, A. (2001). Sistema de Seguridad Domótico para uso
Doméstico y/o Industrial. Conciencia Tecnológica, (16), 33-37.
https://www.redalyc.org/articulo.oa?id=94401608

Ortiz López, E., Ibarra-Manzano, M. A., Andrade-Lucio, J. A., & Almanza Ojeda, D. L. (2012).
Control de acceso usando FPGA y RFID. Acta Universitaria, 22(6), 31-37.
https://www.redalyc.org/articulo.oa?id=41624636005

Teclado Matricial 4x4. Recuperado el 1 de abril de 2024, de https://electronicamade.com/teclado-

matricial-4x4/