Sistema de Domótica

En este proyecto vamos a explicar cómo hacer un sistema de domótica sencillo y perfectamente aplicable al hogar, en el cual, vamos a poder establecer control sobre la luz y la temperatura del mismo desde cualquier dispositivo Android.

En primer lugar, vamos a empezar por lo más básico, como es la lista de componentes que vamos a necesitar para hacer nuestras placas, en donde colocaremos los microcontroladores que se encargarán, junto con los programas que haremos, de controlar todo el sistema.

Lista de componentes.

- PIC16F877A

- ATMEGA328P

- Osciladores de 16MHz

- Condensadores (más adelante se aclararán cantidad y valores)

- Leds

- Resistencias (más adelante se aclararán cantidad y valores)

- LDR

- LM35

- Relés

- ULN2803A

- Módulo bluetooth

- Resistencia calefactora 230V

- Ventilador 12V

- Bombilla 230V

- Tablas de madera para maqueta.

Planificación.

Diseño de placas del PIC16F877A y ATMEGA328P.

Vamos con el diseño de las placas.

Empezaremos con la placa para el PIC16F877A, con sus respectivos condensadores de filtro, un oscilador, (cristal de cuarzo), de 16MHz con sus respectivos condensadores de 22pF, un pulsador para poder resetearlo en caso de fallo, un diodo led para que nos haga un blink mientras el programa que le metamos posteriormente veamos que arranca correctamente, sus puertos de salida y entrada y toma de alimentación y masa.

Aquí vemos el sistema eléctrico diseñado en Isis ya terminado en el que vemos que entre VCC y GND hay 2 condensadores para filtrar posibles picos de tensión. Para posibles picos altos hemos puesto uno de 100uF y para los pequeños el de 520pF, una resistencia pullup de 20k para evitar cortocircuitos en caso de que queramos resetear el PIC actuando sobre el pulsador, con un condensador de 100uF en paralelo para evitar los picos que puedan producirse por el llamado "efecto rebote" al ser pulsado, un diodo led con su respectiva resistencia de 250 ohm que usaremos para hacer el blink y los puertos de entrada y salida.

Este es el diseño que hemos hecho en Ares a partir del diseño eléctrico de Isis, el cual más tarde pondremos en placa de circuito impreso para hacer nuestra centralita con el PIC16F877A.

Resultado final de nuestra placa.

Lo mismo hacemos con la siguiente centralita, pero con el ATMEGA328P:

Circuito eléctrico.

Diseño para placa.

Resultado final.

Diseño de placa para el control de la temperatura.

A continuación haremos lo mismo que hasta ahora con las centralitas del PIC y el ATMEGA, pero con la placa que va a hacer que podamos controlar la temperatura con una de las dos centralitas, en este caso yo lo he hecho con el ATMEGA pero funcionaría con cualquiera de los dos.

Aquí nos encontramos con un circuito eléctrico que trabaja con distintas tensiones, (5, 12 y 230V).

Los 5V sirven para alimentar la bobina del relé mediante, en este caso, el "Pin 3 del arduino" (ATMEGA) que actúa en un transistor que deja pasar o no la corriente. Este relé se encarga de alimentar, con 230V, la resistencia calefactora que se encargará de la calefacción de la casa.

Los 12V sirven para alimentar el ventilador siempre y cuando el Pin 4 del arduino deje pasar la corriente y el motor del ventilador pueda funcionar para introducir el aire caliente que genera la resistencia en el interior de la casa.

Este sería el diseño para la placa de circuito impreso.

Y este el resultado final.

NOTA: como podéis comprobar le he puesto 2 condensadores en serie con la resistencia calefactora. Esto es porque antes de hacer el circuito eléctrico, mediante las muchas comprobaciones de cada uno de los componentes, noté que la resistencia alcanzaba demasiada temperatura, y podría haber riesgo de incendio o quemaduras en la maqueta. Para ello medí la impedancia de la resistencia calefactora y me dio aproximadamente 150 ohm, entonces para poder reducir la intensidad que pasaba por ella a casi la mitad recurrí a condensadores, (ya que las resistencias de potencia se calientan mucho), y poniéndolos en serie y mediante la fórmula, R=(1/(2*Pi*F*C)) en donde F es la frecuencia usada en Europa (50Hz) y la C es la capacidad del condensador, me dio una impedancia de unos 50 ohm. Con ello pude reducir, de una forma cómoda y sin alteraciones de la temperatura en el circuito, la potencia de calefacción de la resistencia y prevenir que se pudiera quemar algo.

Diseño de placa para bombilla de 230V.

Este circuito es prácticamente idéntico al anterior en donde accionábamos un relé para alimentar la resistencia calefactora, pero con una bombilla de 230V.

Diseño para placa.

Resultado final.

Montaje del sistema.

Después de haber montado ya nuestra pequeña maqueta, nos disponemos a montar ya el circuito completo con todos los componentes.

Conexión de las 2 centralitas ya terminadas y perfectamente funcionales con la placa de control de temperatura y de luz y el módulo bluetooth.

Conexión de la resistencia calefactora y ventilador a la placa de control de la temperatura.

Y conexión del porta bombillas a la placa de control de la luz.

Después para finalizar le he añadido personalmente unos leds en smd que se encienden y apagan mediante las mediciones de una LDR que simulan unas luces de jardín automatizadas. He usado en total 8 leds, pero como sabemos cada uno de los leds consumen 20mA cuando un arduino solo puede sacar un máximo de unos 40mA en total, para ello he usado un ULN2803A que alimentado a parte con 5V es capaz de sacar por patilla unos 300mA.

Creación de programa Android y programación del PIC16F877A y del ATMEGA328P.

Programa Android con App Inventor:

A continuación mostraré el diseño y programación que hice con App Inventor en donde pude realizar el programa Android que uso para controlar todo el sistema de domótica mediante cualquier aparato que tenga el sistema operativo Android, en este caso un móvil.

Este es el interfaz gráfico que realicé para el programa de control remoto del sistema de domótica en el cual se puede ver un botón de conexión con el módulo bluetooth que hemos conectado al PIC, el apartado de control de la "Luz del salón", como es el ejemplo de la bombilla de 230V que ya hemos instalado, el control de la temperatura de la resistencia calefactora que oscila desde los 22ºC a los 30ºC y un botón de desconexión de emergencia que apaga todo al instante en caso de problemas.

A continuación la programación por bloques de este programa...

Como podemos ver al principio se crean los bloques para que el programa sepa que al pulsar el botón "Conectar BT" tenga que mostrarnos un listado de posibles aparatos a los que conectarse. Luego hacemos el código en el cual cuando pulsamos el botón de "Encender" mande por puerto bluetooth una 'A' y si pulsamos en botón "Apagar" mande una 'B'. Y por último hacemos el código para que al seleccionar la graduación entre 22ºC a 30ºC y dale al "OK" mande un carácter diferente.

Con todos estos caracteres enviados por bluetooth al PIC junto con la programación del mismo PIC y el ATMEGA podemos controlar completamente todo el sistema.

NOTA: para el control de la temperatura que oscila entre los 22 y los 30ºC como he dicho anteriormente he usado el LM35. Es un sensión que mide la temperatura el cual puede funcionar con una tensión que oscila entre los 3V y los 40V. Su señal de salida analógica funciona por mV, cada grado de temperatura representa 10mV, así que contado con que la entrada analógica de un arduino son 1024 y trabajando con 5V, mediante la fórmula: temperatura=(((señal analógica de LM35*5000)/1024)/10) tenemos la temperatura exacta de medición.

A continuación los programas de las centralitas...

Pic:

#include

#byte tris_b=0x06
#byte tris_d=0x06

void main()
{

setup_adc_ports(NO_ANALOGS);
setup_adc(ADC_CLOCK_DIV_2);
setup_psp(PSP_DISABLED);
setup_spi(SPI_SS_DISABLED);
setup_timer_0(RTCC_INTERNAL|RTCC_DIV_1);
setup_timer_1(T1_DISABLED);
setup_timer_2(T2_DISABLED,0,1);
setup_comparator(NC_NC_NC_NC);
setup_vref(FALSE);

char dato;
set_tris_b(00000000);
set_tris_d(01111110);
delay_ms(1000);

while(1)
{
output_high(pin_d7);
delay_ms(100);

//TRANSFERENCIA DE CARÁCTERES.

if(kbhit())
{
dato=getch();
putc(dato);
}

output_low(pin_d7);
delay_ms(100);

//CONTROL DE LDR.
if(input(pin_d6))
{
output_high(pin_b0);
output_high(pin_b1);
output_high(pin_b2);
output_high(pin_b3);
output_high(pin_b4);
output_high(pin_b5);
output_high(pin_b6);
output_high(pin_b7);
}
else
{
output_low(pin_b0);
output_low(pin_b1);
output_low(pin_b2);
output_low(pin_b3);
output_low(pin_b4);
output_low(pin_b5);
output_low(pin_b6);
output_low(pin_b7);
}
}

}

ATMEGA:

int LDR;
char dato, dato1, dato2;
long temperatura, sensor;
long contador = millis();
boolean flagBlink = LOW;
void setup()
{
Serial.begin(9600);
pinMode(13, OUTPUT); // Led programa.
pinMode(2, OUTPUT); // Lámpara a 230V.
pinMode(3, OUTPUT); // Resistencia calefactora a 230V.
pinMode(4, OUTPUT); // Motor a 12V para la resistencia.
pinMode(5, OUTPUT); // LDR.
}

void loop()

{
if((millis()-contador)>100)
{
flagBlink=!flagBlink;
digitalWrite(13, flagBlink);
contador=millis();
}

// LECTURA DE DATOS.

if(Serial.available()>0) dato=Serial.read();
if((dato=='A')||(dato=='B')) dato1=dato;
if((dato=='C')||(dato=='D')||(dato=='E')||(dato=='F')||(dato=='G')||(dato=='H')||(dato=='I')||(dato=='J')||(dato=='K')) dato2=dato;
if(dato=='Z')
{
dato1='Z';
dato2='Z';
}

//LUZ JARDÍN.

LDR=analogRead(A1);
delay(10);
if(LDR>500) digitalWrite(5, HIGH);
else digitalWrite(5, LOW);

//LUZ SALÓN.

if(dato1==('A')) digitalWrite(2, HIGH);
if(dato1==('B')) digitalWrite(2, LOW);
if(dato1==('Z')) digitalWrite(2, LOW);

//TEMPERATURA.

sensor=analogRead(A0);
temperatura=(((sensor*5000)/1024)/10);
if(dato2==('C'))
{
digitalWrite(4, HIGH);
if(temperatura<22) digitalWrite(3, HIGH);
else digitalWrite(3, LOW);
delay(2000);
}
if(dato2==('D'))
{
digitalWrite(4, HIGH);
if(temperatura<23) digitalWrite(3, HIGH);
else digitalWrite(3, LOW);
delay(2000);
}
if(dato2==('E'))
{
digitalWrite(4, HIGH);
if(temperatura<24) digitalWrite(3, HIGH);
else digitalWrite(3, LOW);
delay(2000);
}
if(dato2==('F'))
{
digitalWrite(4, HIGH);
if(temperatura<25) digitalWrite(3, HIGH);
else digitalWrite(3, LOW);
delay(2000);
}
if(dato2==('G'))
{
digitalWrite(4, HIGH);
if(temperatura<26) digitalWrite(3, HIGH);
else digitalWrite(3, LOW);
delay(2000);
}
if(dato2==('H'))
{
digitalWrite(4, HIGH);
if(temperatura<27) digitalWrite(3, HIGH);
else digitalWrite(3, LOW);
delay(2000);
}
if(dato2==('I'))
{
digitalWrite(4, HIGH);
if(temperatura<28) digitalWrite(3, HIGH);
else digitalWrite(3, LOW);
delay(2000);
}
if(dato2==('J'))
{
digitalWrite(4, HIGH);
if(temperatura<29) digitalWrite(3, HIGH);
else digitalWrite(3, LOW);
delay(2000);
}
if(dato2==('K'))
{
digitalWrite(4, HIGH);
if(temperatura<30) digitalWrite(3, HIGH);
else digitalWrite(3, LOW);
delay(2000);
}
if(dato2==('Z'))
{
digitalWrite(3, LOW);
digitalWrite(4, LOW);
}

}

Comprobación del sistema.

Y finalmente habiendo montado y programado todo correctamente comprobamos que nuestro proyecto funciona perfectamente. Aquí unas mediciones con cámara térmica para ver el funcionamiento de la luz y la temperatura dentro de la maqueta.