El día que hice un termostato

Hace unos años se me ocurrió la idea de hacerme mi propio termostato. Parecía un proyecto asequible pues sólo debería controlarse la temperatura de la calefacción. Sí… La cosa se complicó.

El termostato que tenía para encender la caldera era muy básico, y pensé que no podría ser muy difícil mejorar ese trozo de plástico com porquería incustado . Me puse manos a la obra y empecé a investigar cómo podría hacer el proyecto.

Justo tenía un nuevo asistente Alexa, lo que despertó en mí una obsesión muy loca por todo lo que se pudiera automatizar y controlar por bebe o internet. Me hice con todos los gadgets compatibles con Alexa que encontré: para que me cegaran las luces, la tv, el aire acondicionado, el robot aspirador, la lavadora… y claro, faltaba la calefacción.

Las motivaciones iniciales eran tener un termostato al estilo NEST que en ese momento me daba pereza comprar, y crear algo funcional con una Raspberry-pi 3, pues me habían regalado una y también tenía por casa una pantalla táctil compatible muy básica ..

Algunas preguntas básicas:

  • ¿Cuál es el SO idóneo para el proyecto?
  • ¿Cómo se configura la pantalla?
  • ¿Qué lenguaje utilizaré para crear la aplicación?
  • ¿Qué componentes electrónicos necesito?
  • Cómo hago que inicie mi aplicación

Al final encontré las respuestas a estas preguntas. Basé la solución en desarrollo Python y componentes básicos de compatibles con Raspberry y el resultado fue lo suficientemente bueno:

Componentes Básicos:

Los componentes de hardware y sofware los encontrará en el proyecto de git:

Os adjunto la captura de los componentes.

Importante el modelo de pantalla en el que dependen las siguientes configuraciones

3.5 inch 320*480 TFT

Sistema Operativo

El sistema operativo elegido fue el Raspbian sin sistema gráfico. Ya le instalaría yo Xinit más tarde. Algunos pasos a tener en cuenta:

Fijar IP en WiFi local:

$ sudo nano /etc/dhcpcd.conf

Añadir:

interface wlan0
static ip_address=192.168.1.205 //IP deseada
static routers=192.168.1.1
static domain_name_servers=192.168.1.1

Instalar XINIT 

Se trata del sistema de ventanas necesario para poder visualizar la aplicación

$ apt-get install xinit

Instalar Python y drivers Raspberry

$ sudo apt-get install git
$ git clone https://github.com/adafruit/Adafruit_Python_DHT.git
$ sudo apt-get install build-essential python-dev
$ cd Adafruit_Python_DHT
$ sudo python3 setup.py install

También instalaremos el RPI:

$ sudo apt-get install python-dev python-rpi.gpio
$ Sudo pip3 install RPi.GPIO

Configurar pantalla

Basado en https://circuitdigest.com/microcontroller-projects/interfacing-3.5-inch-touchscreen-tft-lcd-with-raspberry-pi

Conectamos la pantalla la Raspberry y configuramos el autologin desde raspi-config:

$ sudo raspi-config

Descargamos el driver

$ sudo rm -rf LCD-show 
$ git clone https://github.com/goodtft/LCD-show.git 
$ chmod -R 755 LCD-show 
$ cd LCD-show/
$ sudo ./LCD35-show

Para revertir el cambio:

$ chmod -R 755 LCD-show 
$ cd LCD-show/ 
$ sudo ./LCD-hdmi

Eliminar el archivo de conf:

sudo mv /usr/share/X11/xorg.conf.d/99-fbturbo.conf ~startx

Se debe crar de alta lo siguiente:

/etc/X11/xorg.conf.d/99-fbturbo.conf
Section "Device"
 Identifier "DeviceHDMI"
 Driver "fbdev"
 Option "fbdev" "/dev/fb0"
 Option "SwapbuffersWait" "True"
EndSection

Section "Device"
  Identifier "DeviceTFT"
  Driver "fbdev"
  Option "fbdev" "/dev/fb1"
EndSection

Section "ServerLayout"
 Identifier "HDMI"
 Screen 0 "ScreenHDMI"
EndSection

Section "ServerLayout"
 Identifier "TFT"
 Screen 0 "ScreenTFT"
EndSection

Section "Screen"
 Identifier "ScreenHDMI"
 Monitor "MonitorHDMI"
 Device "DeviceHDMI"
EndSection

Section "Screen"
 Identifier "ScreenTFT"
 Monitor "MonitorTFT"
 Device "DeviceTFT"
EndSection

Section "Monitor"
 Identifier "MonitorHDMI"
EndSection

Section "Monitor"
 Identifier "MonitorTFT"
EndSection

Evitar que se active el modo reposo de la pantalla

Prerionemos la orden de terminal:

$ xset q

Es posible que al acceder remotamente no encuentre la pantalla. Es por eso que previamente debe definirse la variable DISPLAY

export DISPLAY=:0 #o el que corresongui en el vostre cas

Aparecerá algo similar a:

keyboard Control:
  auto repeat:  on    key click percent:  0    LED mask:  00000000
  XKB indicators:
    00: Caps Lock:   off    01: Num Lock:    off    02: Scroll Lock: off
    03: Compose:     off    04: Kana:        off    05: Sleep:       off
    06: Suspend:     off    07: Mute:        off    08: Misc:        off
    09: Mail:        off    10: Charging:    off    11: Shift Lock:  off
    12: Group 2:     off    13: Mouse Keys:  off
  auto repeat delay:  660    repeat rate:  25
  auto repeating keys:  00ffffffdffffbbf
                        fadfffefffedffff
                        9fffffffffffffff
                        fff7ffffffffffff
  bell percent:  50    bell pitch:  400    bell duration:  100
Pointer Control:
  acceleration:  2/1    threshold: dddd 4
Screen Saver:
  prefer blanking:  yes    allow exposures:  yes
  timeout:  600    cycle:  600
Colors:
  default colormap:  0x20    BlackPixel:  0x0    WhitePixel:  0xffff
Font Path:
  /usr/share/fonts/X11/misc,/usr/share/fonts/X11/100dpi/:unscaled,/usr/share/fonts/X11/75dpi/:unscaled,/usr/share/fonts/X11/Type1,/usr/share/fonts/X11/100dpi,/usr/share/fonts/X11/75dpi,built-ins
DPMS (Energy Star):
  Standby: 600    Suspend: 600    Off: 600
  DPMS is Enabled
  Monitor is On

Tecleamos:

$ xset -dpms
$ xset s noblank
$ xset s off

Y ya tendremos la pantalla configurada para que no se ponga en modo reposo.

Permisos de ejecución remotos

La aplicación Python se ejecuta con el gestor gráfico startX. Para poder ejecutar remotamente (desde el terminal mediante ssh) la aplicación y por tanto iniciar startX es necesario modificar el archivo:

/etc/X11/Xwrapper.config

y añadir la linea:

allowed_users = anybody

De lo contrario aparecería el mensaje:

/usr/lib/xorg/Xorg.wrap: Only console users are allowed to run the X server

Instal·lar llibreries Python necessaries per al projecte

#Instalar TKINTER
$ sudo apt-get install python3-tk

#Instalar PIP3
$ sudo apt-get install python3-pip

#Instalar PIL
$ sudo pip3 install pillow

#Instalar libopenjp2 
$ sudo apt-get install libopenjp2-7
#Instalar libtiff (si no esta ya instalado)
$ sudo apt install libtiff5

#Instalar numpy
$ sudo pip3 install numpy

#Instlar libatlas
$ sudo apt-get install libatlas-base-dev

#Instalar Flask
Virtual env:
$ sudo apt install python3-venv
$ Sudo pip3 install flask

#Instalar matplotlib
$ sudo pip3 install matplotlib

#Instalar requests
$ sudo pip3 install requests

Copiar las fuentes del proyecto

El proyecto incluye fondos especiales necesarios para su correcta visualización. Simplemente deben instalarse en el repositorio de fuentes de raspbian. Una vez descargado el proyecto de github donde encontrará los fondos:

Instalar fontconfig:

$ sudo apt-get install fontconfig

Luego podremos ver las fuentes instaladas en un idioma (Ex:Tamil):

$ fc-list :lang=ta

Situarse en el directorio thermostat y teclear el siguiente comando:

Copiar las fuentes:

$ sudo cp -r thermoFonts/ /usr/share/fonts

Cargar las fuentes sin necesidad de reiniciar:

$ fc-cache -f -v

Preparación pinaje

Basándonos en el pinaje de la raspberry pi 3:

https://pinout.xyz/pinout/pin36_gpio16

En el proyecto se utilizan los pinos

  • 26: Para el sensor de la temperatura
  • 16 y 12: Para el potenciometro electrónico
  • 13: Para el relé que activa la caldera

ç

Disposición del potenciometro electrónico (KY-040)

http://www.ardiotech.com/en/connect-ky-040-rotary-encoder-raspberry-pi/

Disposición del sensor de temperatura

Disposición relé KY-019

Finalmente hice mi propio sketch electrónico del modelo final:

Configurar arranque automático

https://openhardware.pe/raspberry-pi-ejecucion-de-programas-en-el-arranque-del-s-o/

Crear un script en /etc/init.d

sudo nano /etc/init.d/thermoPi.sh

En el archivo rc.local añadimos el arranque del mismo:

sudo nano /etc/rc.local 
#/etc/rc.local
/etc/init.d/thermoPi.sh start &

Paralelamente al arranque de la aplicación termostato debemos arrancar el gestor de ventanas start. Encontrará los scripts de arranque en el propio proyecto:

Montaje y resultado final

Deja un comentario

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *

Scroll al inicio