REPÚBLICA BOLIVARIANA DE VENEZUELA

UNIVERSIDAD PRIVADA DR. RAFAEL BELLOSO CHACÍN

FACULTAD DE INGENIERÍA
LABORATORIO DE AUTOMATIZACIÓN INDUSTRIAL
SECCIÓN: O1013
PROFESOR: GONZÁLEZ BRACAMONTE, JOSÉ JESÚS

PROYECTO FINAL
CONTROL DOMÓTICO DE UNA CASA

INTEGRANTES:

ABRAHAMSZ, SALVADOR. C.I. 30.167.002

BRICEÑO, LUIS. C.I: 30.093.152

CRESPO, SEBASTIÁN. C.I: 29.526.959

NAVARRO, CARLOS. C.I. 17.668.574

RINCÓN, ERNESTO. C.I: 30.310.548

SANCHEZ, BRAULIO. C.I. 24.820.629

MARACAIBO, OCTUBRE DE 2023

INTRODUCCIÓN

En este proyecto se tiene por objetivo desarrollar una aplicación para

automatizar y supervisar las variables comunes que pueden existir en una
vivienda “Domótica”, realizaremos simulación enviado datos entre proteus y
LabVIEW, utilizando dispositivos electrónicos para controlar las diferentes
variables físicas como el transistor BJT, las compuertas lógica y acopladores de
señal quienes se encargan de separar la señal de control de la señal de potencia,
relé electromecánico, optoacopladores ópticos. Para el desarrollo de este circuito
se utilizara las bondades del microcontrolador Arduino Mega 2560 y la
programación a través del software Arduino IDE, la visualización de las variables
será procesada por medio del software LabVIEW, a través de pulsadores se
podrá controlar sistema de alarma, bloqueo de puertas, sistema de riego,
encendido de luces de la vivienda, control de apertura y cierre de las persianas,
cada elemento posee una condición de feedback, por medio de una conexión
serial virtual entre Proteus y LabView se realizara la supervisión del proceso.

En el presente informe se incluye un manual técnico y un manual

operativo, en donde se explica detalladamente el uso y funcionamiento del
dispositivo desarrollado. Al mismo tiempo se muestra una ficha técnica de los
componentes utilizados, donde se puede visualizar tanto el modelo como el
precio de cada uno, así como el precio total de los componentes.

Esta práctica es realizada con el simulador de circuitos electrónicos

Proteus, el software de simulación de procesos LabVIEW, y el software de
programación Arduino IDE.

OBJETIVOS

• Desarrollar un sistema para control domótico de una vivienda a través de

LabView y Arduino IDE.
• Supervisar y controlar cada acción mediante una retroalimentación.
• Diseñar un sensor de movimiento para activación de una alarma.
• Diseñar sistema de accionamiento de un solenoide que permita la
apertura y cierre de las puertas.
• Programar salida para activación del motor de las persianas.
• Automatizar accionamiento de bomba de agua para el sistema de riego
mediante aspersor.
• Redactar un manual técnico y un manual operativo donde se explique el
funcionamiento y el uso del dispositivo respectivamente.
MANUAL DEL USUARIO

Este sistema permite automatizar cualquier condición que el usuario

requiera para su confort o seguridad, aprovechando las bondades del internet
mediante la fibra óptica que llega a cada hogar. Los pasos para la utilización del
sistema son:

• Alimentar el Arduino con un voltaje adecuado y encenderlo. El usuario

debe alimentar el Arduino con un voltaje de 5v DC a 15v DC.
• Establecer la conexión serial entre el Arduino y el panel de control y
visualización. Esta conexión se puede realizar mediante cableado UTP.
• Seleccionar en el Arduino el modo local o el modo remoto. En modo local,
el control se hace a través de interruptores en el Arduino. En modo
remoto, el control se realiza a través de los botones del panel de control.
• Si se ha elegido el modo remoto, acceder al panel de control.
• Seleccionar el proceso de la casa que se quiera activar. Cada proceso
tiene un botón de un color diferente, siendo rojo para las alarmas, azul
para el cierre de las puertas, verde para el riego del patio, amarillo para el
encendido de las luces, y naranja para el control de las persianas.
• Para visualizar el estado y funcionamiento de los dispositivos, acceder al
panel de visualización donde se muestran luces de diferentes colores que
indican y verifican la activación de cada proceso.
• De presentar cualquier inconveniente llamar a centro de servicio
Bracamonte C.A., sede en Trujillo.
MANUAL TÉCNICO
La operación del sistema es definida por el suich local/remoto, el cual
determinará si las ordenes serán dadas localmente por el operador o serán
enviadas a través de la comunicación serial remota. Para actuar en pos de ello,
el procedimiento inicial del código será revisar el estado del selector local/remoto.

Se quiere que el código reciba datos desde LabVIEW a Proteus si el

selector está en modo remoto, para ello el microcontrolador inicia una breve
configuración que abre un puerto serial (estándar COM) de lectura y escritura
que se puede conectar a cualquier computadora para ejercer una interface de
datos utilizando una velocidad de transferencia de 9600 baudios.

El control de los procesos se realiza mediante el uso de compuertas lógicas,

transistores, relés y demás elementos de acoplamiento de fases de potencia
para poder realizar el control desde el arduino.
 Por la parte del feedback, para simular este sistema se colocó una serie
de limitswitch que informan del estado de la posición de varios procesos al igual
que una serie de sensores que detectarán el resto de las variables a controlar.

Para mostrar el feedback en LabVIEW, se realizó una conexión serial

virtual entre este y Proteus, por medio la herramienta Virtual Serial Port Emulator.
Esta herramienta es capaz de simular puertos seriales de manera virtual, para
lograr la conexión entre dos programas que simulan una transmisión y recepción
de datos. Tanto en Proteus como en LabVIEW hay dos componentes que nos
permiten conectar de forma serial ambos programas, estos son el COMPIM y el
VISA Configure Serial Port, que hacen las funciones de puertos seriales en
Proteus y LabVIEW respectivamente. Para ambos componentes es necesario
elegir el puerto virtual que se va a utilizar (en este caso el puerto COM1), así
como seleccionar la velocidad en baudios (9600) y la cantidad de bits de datos
(8).

Adicionado al bloque se VISA Configure Serial Port, se encuentran

conectados en serie los bloques VISA Read y VISA Write, encargados de leer y
escribir respectivamente los datos trasmitidos a través el puerto serial, y de
enviarlos o recibirlos por medio de otros bloques dentro de LabVIEW. Los datos
enviados son de tipo string, por lo que se visualizan como caracteres.
Otros bloques que se utilizaron fueron:
• Timed Loop, para que el ciclo de lectura se realice infinitamente
• Bloque VISA Close para cerrar el circuito de conexión
• Control stop para detener el bucle si se desea.
• Less String y Get Plot, para separar la cadena de caracteres recibida
desde el serial.
• Decimal string to number, para convertir datos de carácter a numérico.
• Number to decimal string, para convertir datos de numérico a carácter.
FICHA DE COMPONENTES

Componente Cantidad Valor Potencia Tolerancia

2n3904 (NPN) 7 --- --- ---
Resistencia 24 1Kohms ¼w +- 5%
Resistencia 2 10ohms 1/8 w +- 5%
Resistencia 1 220ohms ¼w +- 5%
Switch Final de 10 --- --- ---
Carrera
LM4081 1 --- --- ---
(Puertas AND)
Buzzer 1 --- --- ---
LM74LS04 1 --- --- ---
(Puertas NOT)
PC817 1 --- --- ---
Motor DC 12v 2 12v --- ---
Relé 4 SPDT --- ---
Bombillo AC 1 Dependiente --- ---
del tipo de
bombillo
Microcontrolad 1 --- --- ---
or (Arduino
MEGA)
RESULTADOS

Procesos activados de forma remota

Procesos activados de forma local
Detectores de funcionamiento
CÓDIGO DEL MICROCONTROLADOR

#include <string.h>
//Defines
#define alarma 22
#define puertas 23
#define patio 24
#define luces 25
#define abrir_persianas 26
#define cerrar_persianas 27
#define alarma_encendida 33
#define puertas_cerradas 35
#define motor_patio 37
#define valvula_abierta 39
#define luces_encendidas 43
#define persianas_abiertas 45
#define persianas_cerradas 47

#define BTNREMOTOLOCAL 3
#define BTNALARMA 4
#define BTNPUERTA 5
#define BTNPATIO 6
#define BTNLUCES 7
#define BTNPERSIANAS 8

//Declarations
int var_alarma, var_puertas, var_motor_patio;
int var_valvula, var_luces, var_persianas_abiertas;
int var_persianas_cerradas, var, comando;

void setup() {
//Iniciar comunicación serial
Serial.begin(9600);

//Configurar puertos:
pinMode(alarma, OUTPUT);
pinMode(puertas, OUTPUT);
pinMode(patio, OUTPUT);
pinMode(luces, OUTPUT);
pinMode(abrir_persianas, OUTPUT);
pinMode(cerrar_persianas, OUTPUT);
pinMode(2, INPUT_PULLUP);
pinMode(3, INPUT_PULLUP);
pinMode(4, INPUT_PULLUP);
pinMode(5, INPUT_PULLUP);
pinMode(6, INPUT_PULLUP);
pinMode(7, INPUT_PULLUP);
pinMode(alarma_encendida, INPUT);
pinMode(puertas_cerradas, INPUT);
pinMode(motor_patio, INPUT);
pinMode(valvula_abierta, INPUT);
pinMode(luces_encendidas, INPUT);
 pinMode(persianas_abiertas, INPUT);
pinMode(persianas_cerradas, INPUT);
}

void loop() {

//Leer SW local/remoto
//Caso 0, modo remoto, sw presionado
if(digitalRead(BTNREMOTOLOCAL)==0){
if(Serial.available()){
var=Serial.read();
}
funcionMilagrosa();
}
//Caso 1, modo local, sw no presionado
else{
//Alarma
if (digitalRead(BTNALARMA)==0){
var='a';
}
else{
var='b';
}
funcionMilagrosa();
//Puertas
if (digitalRead(BTNPUERTA)==0){
var='c';
}
else{
var='d';
}
funcionMilagrosa();
//Regar patio
if (digitalRead(BTNPATIO)==0){
var='e';
}
else{
var='f';
}
funcionMilagrosa();
//Luces
if (digitalRead(BTNLUCES)==0){
var='g';
}
else{
var='h';
}
funcionMilagrosa();
//Persianas
if (digitalRead(BTNPERSIANAS)==0){
 var='i';
}
else{
var='j';
}
funcionMilagrosa();
}
}

void funcionMilagrosa(void){
activar_alarma();
detectar_alarma();
cerrar_puertas();
detectar_puertas();
regar_patio();
detectar_patio();
prender_luces();
detectar_luces();
abrir_cerrar_persianas();
detectar_persianas();
enviar_datos();
}
void activar_alarma(){
if(var=='a'){
digitalWrite(alarma, HIGH);
}
if(var=='b'){
digitalWrite(alarma, LOW);
}
}
void detectar_alarma(){
if(digitalRead(alarma_encendida)==HIGH){
var_alarma = 1;
}
if(digitalRead(alarma_encendida)==LOW){
var_alarma = 0;
}
}
void cerrar_puertas(){
if(var=='c'){
digitalWrite(puertas, HIGH);
}
if(var=='d'){
digitalWrite(puertas, LOW);
}
}
void detectar_puertas(){
if(digitalRead(puertas_cerradas)==HIGH){
var_puertas = 1;
}
if(digitalRead(puertas_cerradas)==LOW){
var_puertas = 0;
 }
}
void regar_patio(){
if(var=='e'){
digitalWrite(patio, HIGH);
}
if(var=='f'){
digitalWrite(patio, LOW);
}
}

void detectar_patio(){
if(digitalRead(motor_patio)==HIGH){
var_motor_patio = 1;
}
if(digitalRead(motor_patio)==LOW){
var_motor_patio = 0;
}
if(digitalRead(valvula_abierta)==HIGH){
var_valvula = 1;
}
if(digitalRead(valvula_abierta)==LOW){
var_valvula = 0;
}
}

void prender_luces(){
if(var=='g'){
digitalWrite(luces, HIGH);
}
if(var=='h'){
digitalWrite(luces, LOW);
}
}

void detectar_luces(){
if(digitalRead(luces_encendidas)==HIGH){
var_luces = 1;
}
if(digitalRead(luces_encendidas)==LOW){
var_luces = 0;
}
}

void abrir_cerrar_persianas(){
if(var=='i'){
digitalWrite(cerrar_persianas, LOW);
delay(10);
digitalWrite(abrir_persianas, HIGH);
}
if(var=='j'){
digitalWrite(abrir_persianas, LOW);
 delay(10);
digitalWrite(cerrar_persianas, HIGH);
}
}

void detectar_persianas(){
if(digitalRead(persianas_cerradas)==HIGH){
var_persianas_cerradas = 1;
}
if(digitalRead(persianas_cerradas)==LOW){
var_persianas_cerradas = 0;
}
if(digitalRead(persianas_abiertas)==HIGH){
var_persianas_abiertas = 1;
}
if(digitalRead(persianas_abiertas)==LOW){
var_persianas_abiertas = 0;
}
}

void enviar_datos(){
Serial.print("A");
Serial.print(var_alarma);
Serial.print("B");
Serial.print(var_puertas);
Serial.print("C");
Serial.print(var_motor_patio);
Serial.print("D");
Serial.print(var_valvula);
Serial.print("E");
Serial.print(var_luces);
Serial.print("F");
Serial.print(var_persianas_abiertas);
Serial.print("G");
Serial.print(var_persianas_cerradas);
Serial.println("H");
}
CONCLUSIONES PERSONALES

Abrahamsz, Salvador

Este sistema utiliza un microcontrolador Arduino para controlar varios

procesos de domótica y proporcionar retroalimentación a través de una conexión
con LabVIEW. La operación está definida por un interruptor local/remoto, que
determina si los comandos se dan localmente o remotamente a través de la
comunicación serie. En el modo remoto, el Arduino abre un puerto serie para
transmitir datos a LabVIEW a 9600 baudios. Las puertas lógicas, los transistores,
los relés y otros componentes se utilizan para controlar los procesos industriales
desde el Arduino en función de estos comandos. La retroalimentación, como los
sensores de posición y los interruptores de límite, informa de la información de
estado al Arduino.

Para demostrarlo virtualmente, se realizó una conexión entre Proteus y

LabVIEW utilizando un emulador de puerto serie virtual. Ambos programas
contienen componentes de puerto serie para establecer la conexión en COM1
9600 baudios. Los datos se transmiten como caracteres de cadena y se
convierten entre numéricos y de cadena según sea necesario. LabVIEW utiliza
bloques de lectura/escritura VISA para recibir cadenas de retroalimentación de
Proteus a través del puerto serie, y un bucle temporizado se ejecuta
continuamente para monitorear el estado. Esta configuración virtual simula el
control en tiempo real y la retroalimentación entre una interfaz Arduino y
LabVIEW para el monitoreo y operación remotos de procesos industriales.

Briceño, Luis

En conclusión, el uso de la comunicación serial entre un microcontrolador

Arduino y LabVIEW es una herramienta poderosa para controlar y monitorear
procesos de domótica. Esta conexión permite la transmisión de datos y señales
de control en tiempo real, lo que facilita la operación remota de dispositivos
industriales desde un tablero de control. La configuración virtual realizada en
Proteus y LabVIEW demuestra la viabilidad de esta comunicación, brindando
retroalimentación sobre el estado de los dispositivos y permitiendo el control
preciso de los mismos. Esta práctica nos brinda una idea clara de cómo se
implementa un sistema SCADA en el ámbito de la domótica, ofreciendo un
enfoque versátil y eficiente para automatizar y supervisar procesos en el hogar u
otras instalaciones.
Crespo, Sebastián

El presente proyecto consiste en un sistema de domótico para la

automatización del control de un sistema de alarma, riego, apertura y bloqueo de
puertas, control de persianas e iluminación a través de LabView, Arduino IDE y
Proteus. Para la realización de este proyecto se utilizaron diferentes
componentes electrónicos, tales como: Arduino MEGA, compuertas lógicas,
relés, transistores, resistencias, entre otros. Cada variable a controlar cuenta con
un sistema de retroalimentación. Así mismo, el sistema también cuenta con un
interruptor local / remoto para la comunicación en serie. En este sentido, el
presente proyecto nos permite entender cómo funciona un sistema domótico
sencllo, seguro y eficaz para el control de variables en el hogar de manera
automática.

Navarro, Carlos

En el presente diseño se diseña un sistema para automatizar y supervisar

mediate LabView, Proteus y Arduino IDE “Domótica” las actividades rutinarias
que se realizan en una vivienda, este desarrollo se logra mediante los elementos
de control básico visto en las clases de electrónica como el transistor BJT, relé,
sensores, actuadores. Estos dispositivos se pueden emplear para controlar
diferentes variables dependiendo de las condiciones de entrada que
configuremos. Un sistema...

Rincón, Ernesto

Gracias a esta práctica se pudo comprobar lo útil que resulta la

comunicación serial para enviar y recibir datos y señales de control entre dos
softwares diferentes. Esta práctica nos da una idea de cómo es en la vida real
un sistema SCADA, pero en este caso aplicado a la domótica, en el cual se
controla y se monitorea un proceso desde un tablero de control. En este caso,
nuestro proceso se encontraría en proteus, y nuestro tablero de control en
LabVIEW, pero se puede cambiar entre el control local y remoto en cualquier
momento. El uso de microcontroladores, el software labview y otras herramientas
trabajar con los dispositivos de este proceso, que son los sistemas de alarma,
puertas, riego, luces y persianas. Mediante programación, se visualiza en
LabVIEW el estado de los dispositivos y si estos estan en funcionamiento
mediante feedbacks, y a su vez, desde labview se envían distintos valores
numéricos para controlar dichos dispositivos. Todo esto se realizó gracias a la
comunicación serial.
Sánchez, Braulio

En conclusión, este proyecto ha logrado implementar un sistema domótico

eficiente para el control y supervisión de variables en una vivienda, mediante la
integración de LabVIEW y Arduino IDE. La utilización de diversos dispositivos
electrónicos y la simulación de datos entre Proteus y LabVIEW han permitido
automatizar funciones como el sistema de alarma, bloqueo de puertas, riego,
iluminación, y control de persianas, con un sistema retroalimentación para cada
elemento del sistema. Adicionalmente, entregamos manuales técnicos y
operativos, junto con una ficha técnica detallada que facilita la comprensión y el
uso del dispositivo, brindando a los usuarios una solución completa para la
gestión de su hogar de manera eficaz y segura. En el ámbito del usuario, el
sistema proporciona una experiencia sencilla con instrucciones claras y un panel
de control intuitivo, aprovechando la conectividad a través de fibra óptica.
Además, se destaca la disponibilidad de soporte técnico para resolver cualquier
inconveniente, asegurando la funcionalidad continua del sistema domótico.