MemoriaPimoteHito1

Memoria del proyecto desarrollado en Sistemas

Digitales II (SDII)

Curso 2012/2013

Pimote

Autores: Sara Álvarez Vinagre

Alfredo Tendero Casanova

Código de la pareja: MT-10

Sistemas Digitales IIUniversidad Politécnica de Madrid

Departamento de Ingeniería ElectrónicaE.T.S.I. de Telecomunicación

ÍNDICE GENERAL1 INTRODUCCIÓN...................................................................................................................2

2 DIAGRAMA DE SUBSISTEMAS......................................................................................... 3

3 DESCRIPCIÓN DEL SUBSISTEMA HARDWARE............................................................ 4

4 DESCRIPCIÓN DEL SUBSISTEMA SOFTWARE............................................................10

5 PRINCIPALES PROBLEMAS ENCONTRADOS............................................................. 15

6 MANUAL DE USUARIO..................................................................................................... 16

7 BIBLIOGRAFÍA...................................................................................................................17

1

Memoria del proyecto desarrollado en Sistemas Digitales II (SDII) curso 2012/2013

1 Introducción

1.1 Objetivos del proyecto

El objetivo del proyecto es implementar un mando a distancia universal de aire acondicionado usando una Raspberry Pi, un circuito externo de emisión y recepción de infrarrojos y una aplicación desde un smartphone.

La Raspberry se encargará de 'aprender' el funcionamiento de cada mando, almacenándolos y administrándolos de forma que, con la ayuda de la aplicación, desde nuestro smartphone podamos seleccionar entre los distintos modelos disponibles ofreciéndonos una interfaz desde la que controlar el aparato de aire acondicionado.

El sistema es fácilmente extrapolable no sólo a equipos de aire aconcionado, sino cualquier otro cuyo control remoto esté basado en infrarrojos. En general podemos distinguir dos familias dentro de los mandos a distancia: con y sin memoria. Los primeros son a los que nos dedicaremos.

En este tipo de mandos el emisor de la trama no se limita a enviar un código asignado a cada botón, sino que reenvía la configuración completa al dispositivo, independientemente del botón pulsado. Esto entraña un grado de complejidad mayor respecto al mando sin memoria, como puede ser el de una televisión estándar. Sin embargo, aunque en este momento nos centramos en un equipo de aire acondicionado, el sistema pretende poder ser capaz en un futuro de 'aprender' y gestionar controles remotos de ambos tipos.

2


2 Diagrama de subsistemas

3


3 Descripción del subsistema Hardware

El hardware está formado por tres módulos diferenciados que cooperan entre sí: emisor, receptor y Raspberry Pi. La Raspberry Pi hace de nexo entre el resto de subsistemas, gestionando el comportamiento del emisor y recogiendo la información del receptor.

4


3.1 Emisor de infrarrojos

• Esquema eléctrico. El emisor de infrarrojos consta de:

1. Un led emisor de infrarrojos, encargado de enviar la trama modulada al equipo receptor (aire acondicionado, televisión...).

2. Un oscilador a 33kHz, que proporciona una onda cuadrada a dicha frecuencia para generar pulsos modulados en el led infrarrojo.

3. Un amplificador para que la corriente en el led sea suficiente.

• Justificación de la solución adoptada. Las tramas enviadas por un mando a distancia estándar constan de pulsos modulados (usualmente a 38kHz). Por tanto, nuestro emisor debe ser capaz de modular los bits de la trama antes de ser enviados.

Para este primer hito se ha optado por generar la modulación de manera externa a la Raspberry Pi, mediante la utilización de un circuito de oscilación básico basado en NE555. Esta solución nos permite hacer una primera aproximación al proyecto, pudiendo generar tramas moduladas fácilmente. Sin embargo, en las futuras versiones llevaremos a cabo la modulación haciendo uso de los temporizadores que ofrece la Raspberry Pi. Para ello implementaremos un driver (ver detalles en descripción del subsistema software) que nos permitirá prescindir del oscilador externo y del programa en Python actualmente utilizado.

En cuanto a la frecuencia del oscilador (33kHz), debemos recalcar que aunque la frecuencia de portadora más común en mandos a distancia es de 38 kHz, el aire acondicionado bajo estudio utiliza una portadora de 32,7 kHz. Por este motivo nuestro oscilador generará una onda cuadrada de frecuencia 33kHz, con un duty cycle de entre el 60 y el 70%.

5

Memoria del proyecto desarrollado en Sistemas Digitales II (SDII) curso 2012/2013• Justificaciones teóricas de los valores adoptados para cada uno de los componentes.

◦ Para el oscilador hemos utilizado un esquema básico basado en el integrado NE555 (ver figura).

Para obtener los valores de las resistencias hemos utilizado las siguientes relaciones

DC=R1R2

R12 · R2 f = 1.44

R12· R2·C

De este modo, fijando f =33kHz , DC=65 y C=4.7nF, obtenemos:

R1R2=4787.23

Tomamos R1=1 k y R2=3.3 k

◦ Para el circuito amplificador hemos utilizado un transistor NPN y una resistencia de 47 tal y como se indica a continuación:

◦ La alimentación y la masa del circuito la proporciona la propia Raspberry Pi a partir de sus puertos de +5V y GND.

◦ El pin desde el que se controla el oscilador es el número 7. La elección de este pin es arbitraria, pues en principio cualquiera de los pines configurables en entrada/salida del GPIO sería válido.

• Problemas encontrados durante la implementación. En principio el montaje del oscilador no presentó grandes dificultades al tratarse de un montaje básico. Se barajó utilizar otro esquema eléctrico, como un oscilador en Puente Wien, pero dada la aplicación que buscábamos concluimos que la opción del NE555 era la más adecuada.

6


3.2 Receptor de infrarrojos

• Esquema eléctrico. El esquema eléctrico del receptor es esencialmente un integrado encargado de la recepción y demodulación de señales infrarrojas.

• Justificación de la solución adoptada. El receptor de infrarrojos consta de un integrado encargado de la recepción y demodulación de la señal infrarroja. Hemos utilizado el TSOP1133, hecho específicamente para extraer la trama de una señal modulada a 33 kHz. La resistencia y el condensador asociados los recomienda el fabricante para evitar que el ruido pueda interferir en la señal obtenida.

• Justificaciones teóricas de los valores adoptados para cada uno de los componentes.Para fijar la resistencia y el condensador atendimos a las recomendaciones del fabricante. Éstas establecen una resistencia entre 33 y 1 k y un condensador mayor a 0.1 μF .

• Plan de pruebas realizado y resultados medidos. Previamente al montaje del sistema se procedió a estudiar la trama generada por el mando a distancia real. De este modo, utilizando un receptor de infrarrojos (TSOP1138) capturamos la siguiente señal:

7

Memoria del proyecto desarrollado en Sistemas Digitales II (SDII) curso 2012/2013En la figura puede apreciarse cómo está dividida en dos partes. Para saber el significado de la trama enviada por el mando acudimos a diversos foros de electrónica relacionados con los mandos a distancia (ver bibliografía) y tras indagar encontramos algo de información útil. Sin embargo, a la hora de replicar las tramas para encendido y apagado optamos por capturarlas directamente con un osciloscopio, y extraer de ahí la información enviada bit a bit. En el futuro el procesado de las señales se hará de manera automática, componiendo la trama a enviar a partir de la configuración de aire acondicionado que se desee conseguir.

Una vez desarrollado el código para emular las señales de ON y OFF (ver descripción de subsistema software) procedemos a comprobar el funcionamiento del montaje. Las figuras a continuación muestran comparativamente la trama real y la generada para el caso de la señal de OFF.

8

Memoria del proyecto desarrollado en Sistemas Digitales II (SDII) curso 2012/2013Por tanto puede concluirse que la aproximación es suficientemente buena, pues la información se envía correctamente, aunque el tiempo de bit varía respecto al original puesto que no podemos controlar el resto de procesos ejecutados simultáneamente en la Raspberry.

Nota: la escala de tiempo en las capturas es diferente y de ahí la diferente anchura.

• Problemas encontrados durante la implementación. Se encontraron ciertas dificultades a la hora de encontrar un receptor adecuado para el mando a distancia utilizado. Dado que la mayoría de los mandos funcionan a una frecuencia de 38 kHz, se optó primero por utilizar un receptor centrado a esta frecuencia. Al no conseguir capturar la trama de manera eficiente, encargamos receptores de todas las frecuencias disponibles (33, 36, 38 y 40 kHz y universal) para quedarnos con el que diera mejores resultados. Finalmente y como era de esperar, el de 33kHz dio los mejores resultados. El universal, aunque funcional, también captura mucho más ruido del ambiente, por lo que se desestimó su uso.

9


4 Descripción del subsistema Software

4.1 Proceso del programa principal

• Pseudocódigo del proceso

◦ Código en python para la réplica de una trama.Para este primer hito hemos replicado las tramas de “ON” y “OFF” del mando a distancia. Dado que un mando de aire acondicionado envía no solo el código del botón pulsado sino un mensaje con la información completa del estado del dispositivo, hemos fijado el resto de parámetros de manera arbitraria.

▪ Trama de 'ON' (sendON.py)

#sendON#Envía la trama de encendido (18ºC, calor, swing, ventilador automático)

import RPi.GPIO as GPIOimport time

GPIO.setup(7, GPIO.OUT) #Pone el pin 7 del GPIO como salida

buffer = [1,1,1,1,1,1,1,1,0,0,0,0,1,0,0,0,1,0,1,0,1,0,1,0,0,0,1,0,1,0,1,0,1,0,1,0,0,0,1,0,1,0,0,0,1,0,0,0,1,0,1,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,1,0,1,0,1,0,0,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,0,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,0,0,0,0,1,0,0,0,1,0,1,0,1,0,1,0,0,0,1,0,1,0,1,0,1,0,1,0,0,0,1,0,1,0,0,0,1,0,0,0,1,0,1,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,1,0,1,0,1,0,0,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,0,0,1,0,1,0,1,0,1,0,1,0,1,0,0,0,1,0,1,0,1,0,1,0,0,0,1,0,1,0,1,0,0,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,1,0,1,0,0,0,1,0,1,0,0,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,0,0,1,0,0,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,0,0,1,0,0,0,1,0,1,0,1,0,0,0,1,0,0,0,1,0,0,0,1] #Trama a enviar

cont=0

for elem in buffer : #Se recorre la trama y se envía bit a bit if elem==1: GPIO.output(7, True) #Activa el oscilador else: GPIO.output(7, False) #Desactiva el oscilador time.sleep(525/1000000) #El tiempo de bit es 525 useg cont += 1 print 'Esta es la vuelta: ', cont

10

Memoria del proyecto desarrollado en Sistemas Digitales II (SDII) curso 2012/2013▪ Trama de 'OFF' (sendOFF.py)

#sendOFF#Envía la trama de apagado (18ºC, calor, swing, ventilador automático)

import RPi.GPIO as GPIOimport time

GPIO.setup(7, GPIO.OUT) #Pone el pin 7 del GPIO como salida

buffer = [1,1,1,1,1,1,1,1,0,0,0,0,1,0,0,0,1,0,1,0,1,0,1,0,0,0,1,0,1,0,1,0,1,0,1,0,0,0,1,0,1,0,0,0,1,0,0,0,1,0,1,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,1,0,1,0,1,0,0,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,0,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,0,0,0,0,1,0,0,0,1,0,1,0,1,0,1,0,0,0,1,0,1,0,1,0,1,0,1,0,0,0,1,0,1,0,0,0,1,0,0,0,1,0,1,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,0,0,1,0,1,0,1,0,1,0,0,0,1,0,1,0,1,0,0,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,1,0,1,0,0,0,1,0,1,0,0,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,0,0,1,0,0,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,0,0,1,0,1,0,0,0,1,0,1,0,1,0,0,0,1,0,0,0,1,0,0,0,1] #Trama a enviar

cont=0

for elem in buffer : #Se recorre la trama y se envía bit a bit if elem==1: GPIO.output(7, True) #Activa el oscilador else: GPIO.output(7, False) #Desactiva el oscilador time.sleep(525/1000000) #El tiempo de bit es 525 useg cont += 1 print 'Esta es la vuelta: ', cont

Como se puede ver en el código, hemos hecho uso del pin 7 de la Raspberry como salida. Esta nos proporciona una tensión de 3.3V si el bit vale '1' y alta impedancia si el bit es '0'.Mediante el uso del método 'sleep()' de la librería time de Python reproducimos el tiempo de bit de la trama original haciendo que el pin espere dicho tiempo de bit entre lectura y lectura de cada uno de los bits del array 'buffer'.

◦ Módulo en C para Raspberry Pi

/** Pimote driver* pimote_dev.c*/

#include <linux/module.h>#include <linux/kernel.h>#include <linux/fs.h>#include <linux/init.h>

static struct file_operations lirc_dev_fops = {.owner = THIS_MODULE,.read = pimote_read,.write = pimote_write,.open = pimote_open,

11


.release = pimote_close,};int pimote_open(){

printk(<1>"Estoy abriéndome");return 1;

}

ssize_t pimote_read(){printk(<1>"Estoy leyendo");return 1;

}ssize_t pimote_write(){

printk(<1>"Estoy escribiendo");return 1;

}

int pimote_close(){printk(<1>"Estoy cerrado");return 1;

}

static int __init pimote_init(void){return 1;

}

static void __exit pimote_exit(void){}

module_init(lirc_dev_init);module_exit(lirc_dev_exit);

MODULE_DESCRIPTION("Pimote GPIO driver");MODULE_AUTHOR("Alfredo & Sara");MODULE_LICENSE("GPL");

El código anterior muestra un ejemplo de un driver en C para ser compilado en el kernel de la Raspberry Pi.

Este módulo será usado para controlar la tensión en los pines de entrada/salida de la Raspberry usando un temporizador del sistema, ya que usando el código en Python no se puede reproducir con exactitud el tiempo de bit de la trama enviada por el mando. Para este primer hito se ha realizado a modo de ejemplo un driver que informa de cuándo está siendo realizada cada una de las operaciones requeridas para en su futura utilización; esto es, montarse, leer, escribir y desmontarse.

• Relaciones con otros procesos

En este primer hito no hay comunicación con ninguna variable del sistema ya que el driver aún no se comunica con el registro para controlar los pines de entrada y salida de la Raspberry.

• Justificación de la solución adoptada

Hemos optado por un programa en Python para esta primera parte como aproximación a lo que después haría el driver ya que es un lenguaje sencillo y es el más usado para el manejo del GPIO de Raspberry Pi. Por limitaciones del sistema no podemos reproducir exactamente el tiempo de bit de la trama que debemos enviar ya que no podemos controlar cómo afectan el resto de procesos a la ejecución de nuestro programa, por ello más adelante usaremos el driver para reproducir la señal a enviar.

12

Memoria del proyecto desarrollado en Sistemas Digitales II (SDII) curso 2012/2013• Plan de pruebas

Para probar el código en Python hemos desarrollado un ejemplo con el código mostrado anteriormente (sendON.py, sendOFF.py) en el que al buffer le introducimos los bits “11001100111000111”. Como resultado obtenemos la trama siguiente en el receptor:

Efectivamente la trama enviada es correcta (nótese que la captura muestra la trama invertida), sin embargo al tomar las medidas de tiempo de bit observamos que no somos capaces de reproducir los 525 μSeg con este sistema, ya que, como hemos mencionado anteriormente, no podemos controlar cómo afectan el resto de procesos de la máquina.

Por otro lado, para comprobar el correcto funcionamiento del driver hemos implementado un pequeño script que ejecute las funciones básicas de un driver a modo demostrativo.

<!/bin/bash>

cd /Escritorio

echo("Módulos instalados:")lsmod

echo("Iniciamos el módulo...")insmod pimote_dev.c

echo("Escribimos")echo "" > pimote_dev.c

echo("Leemos")cat pimote_dev.c

echo("Desinstalamos el módulo")rmmod pimote_dev.c

echo("Módulos instalados:")lsmodecho("FIN")

13

Memoria del proyecto desarrollado en Sistemas Digitales II (SDII) curso 2012/2013• Justificaciones teóricas de los valores adoptados para cada uno de los componentes.

Para obtener el tiempo de bit de la trama y así poder reproducirla correctamente buscamos información sobre la documentación del fabricante y comprobamos que efectivamente el tiempo de bit de la trama enviada por el mando es de 525 μSeg.

• Problemas encontrados durante la implementación.

Los principales problemas encontrados en el apartado de software fueron entender el funcionamiento del puerto GPIO de Raspberry para controlarlo y configurarlo mediante Python, así como el aprendizaje necesario para la creación de un módulo del kernel de la Raspberry Pi que nos permitiese controlar en el futuro los registros del dispositivo.

Así mismo, a la hora de instalar las cabeceras necesarias del kernel vimos que era algo más complicado de lo previsto, teniendo que recurrir a ayuda externa para instalarlas.

Otro problema ha sido la escasa documentación sobre el protocolo usado por el mando usado en esta práctica, lo que ha dificultado la obtención de información enviada por la trama. Sin embargo, tras una extensa búsqueda fuimos capaces de recabar la información necesaria.

14


5 Principales problemas encontrados

Tal y como se ha venido recalcando a lo largo de la memoria, los principales problemas han sido a raíz de la falta de documentación acerca del aire acondicionado estudiado. Esto nos ha llevado a destinar mayor tiempo del que se esperaba a buscar información al respecto y probar a 'descifrar' el funcionamiento del mando. Sin embargo, una vez pasado este escollo nos hemos desenvuelto con normalidad, y esperamos que en el futuro la información recabada hasta ahora nos permita continuar con el proyecto con mayor facilidad.

A continuación se detalla una autoevaluación que considera los aspectos abordados en esta memoria:

Módulos Puntuación máxima (sobre 100)

Puntuación esperada (sobre 100)

Requisitos mínimos 35/40 35(sobre 40)Memoria 15 13,5Software 25 21,25

Hardware 5 4,5Mejoras - -TOTAL 85 74,25

15


6 Manual de usuarioPara controlar el sistema implementado hasta ahora deberemos seguir los siguientes pasos:

• En primer lugar encendemos la Raspberry Pi conectándola a la corriente a través del puerto micro-USB. Al enchufarla ya tendremos alimentados los circuitos externos de emisión y recepción.

• Una vez alimentados debemos establecer comunicación con la Raspberry por ssh desde un ordenador conectado a la misma red que el dispositivo escribiendo en un terminal el comando:

$ ssh pi@host

donde “host” es la dirección ip asignada al dispositivo.

• Ya en la Raspberry Pi, para ejecutar el fichero "sendON.py" o "sendOFF.py" que nos permita enviar la trama, nos movemos al directorio raiz del usuario pi encribiendo el comando:

$ cd /home/pi

(Este directorio es en el que nos sitúa por defecto al hacer ssh por lo que si antes del prompt ($) vemos escrito pi@raspberrypi~ no es necesario realizar el paso anterior).

• Tras esto, ejecutaremos el fichero con el comando:

$ python sendON.py

O bien

$ python sendOFF.py

Al pulsar Enter ya habremos enviado una trama (si existen problemas para ejecutar el comando anterior puede deberse a que hay que tener permisos de administrador, por lo que una posible solución es escribir “sudo” delante del comando anterior de la siguiente forma '$ sudo python sendXX.py').

• Para probar el driver, en lugar de ejecutar uno de los ficheros mostrados anteriormente, vamos a ejecutar un script que monte el modulo en el kernel, lo ejecute y lo desmonte de la sigueinte forma:

$ ./modtest.sh

• Una vez ejecutado podemos ver los mensajes del kernel con el comando

$ dmesg

16


7 Bibliografía

• Información sobre drivers en Linux:Third Edition of Linux Device Drivers, by Jonathan Corbet, Alessandro Rubini, and Greg Kroah-Hartma.

• LIRC GPIO driver:http://aron.ws/projects/lirc_rpi/

• Librería Python para GPIO de Raspberry:https://pypi.python.org/pypi/RPi.GPIO

• Vídeo con ejemplos de cómo usar el GPIO con Python:https://www.youtube.com/watch?v=q_NvDTZIaS4

• Información sobre los pines del GPIO:http://elinux.org/RPi_Low-level_peripherals

• Agradecimientos a Guy Palmer.

17

http://aron.ws/projects/lirc_rpi/

http://elinux.org/RPi_Low-level_peripherals

https://www.youtube.com/watch?v=q_NvDTZIaS4

https://pypi.python.org/pypi/RPi.GPIO

MemoriaPimoteHito1

Documents

Transcript of MemoriaPimoteHito1