Índice de documentos

Índice de documentos
DOCUMENTO I. MEMORIA
Parte I. Memoria
Parte II. Estudio económico
Parte III. Código Fuente
Parte III. Datasheets
pág. 11 a 87
pág. 89 a 90
pág. 91 a 100
pág. 101 a 107
77 páginas
2 páginas
10 páginas
7 páginas
DOCUMENTO II. PLIEGO DE CONDICIONES
1. Generales y económicas
2. Técnicas y particulares
pág. 3 a 8
pág. 11 a 15
6 páginas
5 páginas
pág. 5 a 9
pág. 11 a 13
5 páginas
3 páginas
DOCUMENTO III. PRESUPUESTO
1. Presupuestos parciales
2. Presupuesto general
Documento I
Memoria
DESARROLLO DE UN SISTEMA DOMÓTICO BASADO EN 6LOWPAN
II
DESARROLLO DE UN SISTEMA DOMÓTICO BASADO EN 6LOWPAN
III
ÍNDICE
Parte I
Capítulo 1
1
Memoria ........................................................................................... 11
Introducción................................................................................. 13
Estudio de los trabajos existentes / tecnologías existentes ....................... 14
1.1 ZigBee ............................................................................................................................ 14
1.2 KNX ................................................................................................................................ 16
1.3 Z-wave ........................................................................................................................... 18
1.4 Contiki............................................................................................................................ 18
2
Motivación del proyecto ................................................................................. 19
3
Objetivos y aplicaciones ................................................................................. 21
4
Metodología ...................................................................................................... 21
5
Recursos / herramientas empleadas.............................................................. 22
Capítulo 2
1
Principios Teóricos ..................................................................... 25
6LoWPAN .......................................................................................................... 25
1.1 La arquitectura de 6LoWPAN .................................................................................... 25
1.2 Introducción a 6LoWPAN ........................................................................................... 27
2
Contiki................................................................................................................ 31
2.1 Resumen del sistema .................................................................................................... 31
2.2 La arquitectura del Kernel ........................................................................................... 32
2.3 Servicios (services) en Contiki .................................................................................... 33
2.4 Librerias ......................................................................................................................... 34
Capítulo 3
El procesador MC13226V ........................................................... 35
1
Borrado de la memoria FLASH ..................................................................... 35
2
Carga de programas en MC13226V ............................................................... 37
2.1 Instalación de la librería libmc1322x .......................................................................... 37
2.2 Cargar imágenes en la RAM con mc1322x-load.pl .................................................. 37
3
Entradas/salidas en MC13226V ..................................................................... 38
3.1 Salidas en MC13226V ................................................................................................... 38
DESARROLLO DE UN SISTEMA DOMÓTICO BASADO EN 6LOWPAN
IV
3.2 Registros GPIO ............................................................................................................. 40
3.3 Entradas en MC13226V ............................................................................................... 44
4
Primeras comunicaciones entre dos tarjetas ............................................... 46
4.1 Inicialización del módulo de comunicación ............................................................. 46
4.2 Programa emisor .......................................................................................................... 47
4.3 Programa receptor ........................................................................................................ 49
4.4 Fallo en la inicialización del módulo de comunicación. ......................................... 50
Capítulo 4
El procesador MC13224V ........................................................... 55
1
Adecuación previa de la tarjeta ..................................................................... 55
2
Diseño e implantación de un circuito sencillo (LED+Pulsador) ............. 58
3
Entradas/Salidas en MC13224V ..................................................................... 59
3.1 Cambio en los pines y bits del registro GPIO ........................................................... 59
3.2 Modificación del archivo Makefile............................................................................. 60
4
Primeras comunicaciones entre dos tarjetas. .............................................. 61
4.1 Fallo en la inicialización. ............................................................................................. 62
4.2 Impresión de paquetes. ................................................................................................ 64
Capítulo 5
Programación de una red con Contiki y 6LoWPAN ............. 67
1
Compilar programas con Contiki.................................................................. 67
2
Esquema básico de una programa en Contiki ............................................ 68
3
Programación de una red sencilla border router-cliente udp .................. 69
3.1 Esquema de la red ........................................................................................................ 69
3.2 Ejecución de la red........................................................................................................ 69
4
Entradas/salidas en Contiki ........................................................................... 73
4.1 Salidas ............................................................................................................................ 73
4.2 Entradas ......................................................................................................................... 76
4.3 Ejemplo Entradas/Salidas ........................................................................................... 76
5
Ejecución de una pequeña red domótica ..................................................... 78
5.1 Funciones necesarias .................................................................................................... 78
5.2 Desarrollo del programa ............................................................................................. 80
5.3 Salida del programa en cada tarjeta ........................................................................... 82
Capítulo 6
Conclusiones ................................................................................ 85
Capítulo 7
Futuros Desarrollos .................................................................... 87
DESARROLLO DE UN SISTEMA DOMÓTICO BASADO EN 6LOWPAN
V
1
Conexión de la red 6LoWPAN a Internet. ................................................... 87
2
Smart cities ........................................................................................................ 88
Bibliografía .......................................................................................................... 91
Parte II
Capítulo 1
1
Estudio económico ...................................................................... 95
Viabilidad del proyecto. ................................................................................. 95
Parte III
Capítulo 1
1
Estudio económico .......................................................................... 93
Código Fuente .................................................................................. 97
Código Fuente .............................................................................. 99
Entradas/salidas en MC13226V ..................................................................... 99
1.1 gpio.c .............................................................................................................................. 99
1.2 conpulsadores.c .......................................................................................................... 100
2
Comunicación básica en MC13226V........................................................... 101
2.1 enviapaquetes.c........................................................................................................... 101
2.2 recibepaquetes.c .......................................................................................................... 103
3
Entradas/Salidas con Contiki y MC13224V............................................... 104
3.1 entradasalida1.c .......................................................................................................... 104
4
Red domótica .................................................................................................. 105
4.1 redom.c ........................................................................................................................ 105
Parte IV
Datasheets ..................................................................................... 109
Capítulo 1
Esquemas de Freescale Sensor Reference Board ................... 111
Capítulo 2
Esquemas de Redbee Econotag ............................................... 113
DESARROLLO DE UN SISTEMA DOMÓTICO BASADO EN 6LOWPAN
VI
DESARROLLO DE UN SISTEMA DOMÓTICO BASADO EN 6LOWPAN
VII
ÍNDICE DE FIGURAS
Parte I
Memoria ........................................................................................... 11
Figura 1.2. Logotipos de las distintas partes del Proyecto OSIRIS ................. 16
Figura 1.3. Modos de configuración KNX. ........................................................... 17
Figura 1.4. KNX Flat Panel PC ................................................................................ 17
Figura 1.5. Termostato para radiadores Danfoss ................................................. 18
Figura 1.6.Monitorización del agua a distancia ................................................... 19
Figura 1.7.Freescale Sensor Reference Board....................................................... 22
Figura 1.8. Redwire Econotag (Top) ...................................................................... 23
Figura 1.9. Redwire Econotag(Bottom) ................................................................. 23
Figura 1.10. Placa protoboard.................................................................................. 24
Figura 2.1. La arquitectura de 6LoWPAN ............................................................. 26
Figura 2.2. Pilas de los protocolos IP y 6LoWPAN ............................................. 27
Figura 2.3. IPv6 edge router con soporte para 6LoWPAN ................................. 28
Figura 2.4. Ejemplo de compresión en 6LoWPAN .............................................. 30
Figura 2.5.Partición entre el nucleo y los programas cargados......................... 32
Figura 3.1. Jumpers J19 y J20 ................................................................................... 36
Figura 3.2. Situación de J19 y J20 en la tarjeta. .................................................... 36
Figura 3.3.Circuito de recuperación ....................................................................... 37
Figura 3.4. Conexión de los Leds/pulsadores....................................................... 40
Figura 3.5. Esquema comunicación entre dos tarjetas. ....................................... 46
Figura 3.6. Pantallazo del Terminal con ROM desensamblada. ...................... 53
Figura 4.1.Zoom de la tarjeta Redwire Econotag................................................. 56
Figura 4.2. Parte del esquema de Redwire Econotag. ......................................... 56
DESARROLLO DE UN SISTEMA DOMÓTICO BASADO EN 6LOWPAN
VIII
Figura 4.3. Zoom del esquema 2 de Redwire Econotag. .................................... 57
Figura 4.4. Zoom 2 de la tarjeta Redwire Econotag............................................. 57
Figura 4.5. Soldadura de las hembras en los pines. ............................................ 57
Figura 4.7. Circuito LED + Pulsador ...................................................................... 58
Figura 4.8. Implantación y conexión del circuito a la tarjeta. ........................... 59
Figura 4.9. Esquema primera comunicación entre dos tarjetas. ....................... 61
Figura 4.10. Vista Terminal con dispositivos conectados. ................................. 62
Figura 4.11. Vista Terminal corriendo enviapaquetes.c..................................... 63
Figura 4.12. Funcionamiento de enviapaquetes.c ............................................... 65
Figura 4.13. Funcionamiento de recibepaquetes.c .............................................. 65
Figura 5.1. Esquema de la red. ................................................................................ 69
Figura 5.2. Primeras líneas de ejecución border-router.c .................................. 70
Figura 5.3. Primeras líneas de ejecución udp-client.c ........................................ 72
Figura 5.4. Página web generada por border-router.c ........................................ 73
Figura 5.5. Zoom del esquema 1 de Redwire Econotag. .................................... 75
Figura 5.6. Salida del programa entradasalida1.c ............................................... 77
Figura 5.7. Salida del programa redom.c en la tarjeta 1 ..................................... 83
Figura 7.1. Ejemplo de control via iPhone............................................................ 88
Parte II
Estudio económico .......................................................................... 93
Parte III
Código Fuente .................................................................................. 97
Parte IV
Datasheets ..................................................................................... 109
Figura 1.1. Componentes del PCB (vista superior) ........................................... 111
Figura 1.2. Esquema de Freescale Sensor Reference Board ............................ 112
Figura 2.1. Esquema 1 Redwire Econotag ........................................................... 114
Figura 2.2.Esquema 2 Redwire Econotag. ........................................................... 115
DESARROLLO DE UN SISTEMA DOMÓTICO BASADO EN 6LOWPAN
IX
ÍNDICE DE TABLAS
Parte I
Memoria ........................................................................................... 11
Tabla 3.1. Correspondencia Pin-Registro GPIO ................................................. 40
Tabla 3.2. Selección de Funciones en GPIO......................................................... 43
Tabla 4.1. Correspondencia pin-bit ....................................................................... 64
Parte II
Estudio económico .......................................................................... 93
Parte III
Código Fuente .................................................................................. 97
Parte IV
Datasheets ..................................................................................... 109
DESARROLLO DE UN SISTEMA DOMÓTICO BASADO EN 6LOWPAN
DESARROLLO DE UN SISTEMA DOMÓTICO BASADO EN 6LOWPAN
Parte I MEMORIA
DESARROLLO DE UN SISTEMA DOMÓTICO BASADO EN 6LOWPAN
Introducción.
13
Capítulo 1 INTRODUCCIÓN
A lo largo de la historia el hombre ha ido utilizando su inteligencia
para evolucionar y hacerse a sí mismo la vida más cómoda y a la vez
utilizar los recursos que la Tierra le proporciona de forma más eficiente.
La evolución marca el ritmo de la vida y las casas tampoco pueden
escapar de ella. Por ello se ha ido evolucionando desde la cueva con fuego
para calentar e iluminar a las antorchas, las velas, el candil y por último la
electricidad. Esta ha dado paso en la casa a los electrodomésticos que
necesitan de la electrónica para regular sus procesos. Por último, se
presenta en esta evolución la domótica que se encarga de que la casa sea
capaz de “sentir” y reaccionar por sí sola e interactuar con nosotros. La
domótica hace referencia al conjunto de sistemas capaces de automatizar
una vivienda, aportando servicios de gestión energética, seguridad,
bienestar y comunicación, y que pueden estar integrados por medio de
redes interiores y exteriores de comunicación, cableadas o inalámbricas, y
cuyo control goza de cierta ubicuidad, desde dentro y fuera del hogar[1].
Este proyecto se desarrollará en el campo anteriormente mencionado
de la domótica. Se diseñará un sistema de control tanto de iluminación
como de electrodomésticos usando comunicaciones inalámbricas basadas
en 6LowPan. Para ello el software se implantará bajo el sistema operativo
Contiki.
A lo largo de las diferentes secciones se irá analizando cómo se ha
ido desarrollando el trabajo y que resultados se han ido obteniendo. En la
presente sección se hará una pequeña introducción al entorno en el que se
mueve el proyecto y los sistemas que en él se han desarrollado ya, al igual
que se explicará cual será la metodología a seguir para lograr llevar a cabo
el fin que se propone.
DESARROLLO DE UN SISTEMA DOMÓTICO BASADO EN 6LOWPAN
14
Memoria
1 Estudio de los trabajos existentes / tecnologías existentes
Los últimos avances en el campo de la domótica se refieren
básicamente a cuatro campos:
1) Ahorro energético, mediante el control del consumo. Como
ejemplo tenemos el encendido y apagado automático de la
iluminación de una casa.
2) Confort, mediante la regulación de los sistemas de
climatización e iluminación y también a la hora de generar
controles inalámbricos de los dispositivos de una casa de forma que
el sujeto no tenga que moverse.
3) Seguridad, mediante el control con sensores, cámara, etc.
4) Comunicaciones, con el avance de las tecnologías de
comunicación ya sea con cable o sin él.
Es interesante hacer un pequeño resumen de lo que se hace hasta el
momento relacionado con este proyecto. Veremos los sistemas alternativos
que existen a 6LowPan y sus usos dentro del campo de la domótica, así
como el uso que se ha hecho hasta la fecha del sistema operativo Contiki.
1.1 ZigBee
Es el nombre de la especificación de un conjunto de protocolos de
alto nivel de comunicación inalámbrica para su utilización con
radiodifusión digital de bajo consumo, basada en el estándar IEEE 802.15.4
de redes inalámbricas de área personal (Wireless Personal Area Network,
WPAN). Su objetivo son las aplicaciones que requieren comunicaciones
seguras con baja tasa de envío de datos y maximización de la vida útil de
sus baterías [2]. Tiene unas velocidades comprendidas entre los 20 kB/s y
250 kB/s y rangos de 10 a 75 m de alcance. Puede usar las bandas libres
ISM de 2.4GHz, 868MHz para Europa y 915 para EEUU.
DESARROLLO DE UN SISTEMA DOMÓTICO BASADO EN 6LOWPAN
Introducción.
1.1.1 Arquitectura
Zigbee es una pila de protocolos constituido por diferentes capas, las
cuales son independientes una de la otra. En la Figura 1.1 se muestran las
diferentes capas que componen la pila.
Figura 1.1.Diferentes capas que conforman la pila de protocolos para Zigbee.
1.1.2 Empaquetamiento
El empaquetamiento se realiza en cuatro tipos diferentes de paquetes
básicos, que son:
-
Datos: con un tamaño de hasta 104 bytes.
-
Paquete ACK: es donde se realiza una realimentación desde el
receptor al emisor para confirmar que el paquete se ha recibido sin
errores.
-
Paquete MAC:se utiliza para el control remoto y la configuración de
dispositivos.
-
Paquete baliza: se encarga de “despertar” los dispositivos que
“escuchan” y luego vuelven a “dormirse” si no reciben nada más.
1.1.3 Ejemplo de aplicación
Como uso de ejemplo de ZigBee, la empresa Domodesk ha
desarrollado una solución domótica completa para el hogar que ha
nombrado como Proyecto OSIRIS. Ésta cuenta con múltiples funciones
que van desde el control del agua y del gas hasta la seguridad de la casa e
incluso el control de un sistema de home cinema (Figura 1.2). El producto
se ofrece como una solución óptima para instalar sistemas domóticos sin
DESARROLLO DE UN SISTEMA DOMÓTICO BASADO EN 6LOWPAN
15
16
Memoria
necesidad de realizar obras en la vivienda. El kit ofrece un conjunto de
sensores y actuadores con los cuales se puede controlar la vivienda de
forma automática.
Figura 1.2. Logotipos de las distintas
partes del Proyecto OSIRIS
1.2 KNX
Desarrollado por la asociación de un conjunto de empresas
(KONNEX) con el objetivo de conseguir un sistema de control de la
instalación eléctrica en viviendas y edificios. Este sistema pretende ser el
“único estándar abierto para todas las aplicaciones de control de la
vivienda” [4] para todos los miembros que formen parte de la asociación
anteriormente citada.
Una característica que lo hace interesante es la posibilidad de
configurarlo conforme a dos modos de funcionamiento según el segmento
de mercado al que se desee orientar. En la Figura 1.3 se pueden ver estos
dos modos de funcionamiento.
DESARROLLO DE UN SISTEMA DOMÓTICO BASADO EN 6LOWPAN
Introducción.
17
Figura 1.3. Modos de configuración KNX.
Un primer modo, Easy Mode, está dirigido a instaladores con
conocimientos básicos sobre KNX. Ofrece limitadas funciones con respecto
al otro sistema, System Mode, dirigido a instaladores KNX formado que
llevan a cabo funciones de control sofisticadas.
Un ejemplo que podemos nombrar de este sistema puede ser el KNX
Flat Panel PC (Figura 1.4). Sistema diseñado para el control de la casa que
ofrece la empresa JUNG (una de las componentes de KONNEX). Se trata
de un panel táctil con el que se controlan las distintas variables de la casa y
con el que se manda las órdenes oportunas.
Figura 1.4. KNX Flat Panel PC
DESARROLLO DE UN SISTEMA DOMÓTICO BASADO EN 6LOWPAN
18
Memoria
1.3 Z-wave
Z-wave es un tipo de tecnología inalámbrica diseñada para la
automatización del hogar. Es un estándar que permite a todos los
dispositivos fabricados bajo el mismo comunicarse perfectamente entre
ellos, formando una red doméstica. Usa la frecuencia de 868.42MHz.
Actualmente existen 160 fabricantes que utilizan este tipo de tecnología
para sus productos.
Un ejemplo de fabricantes que utilizan esta tecnología puede ser la
compañía Danfoss, que ofrece una automatización inalámbrica completa
de todas las variables de una casa por medio de esta tecnología. Un
ejemplo puede ser el termostato inalámbricamente controlado para
radiadores (Figura 1.5).
Figura 1.5. Termostato para radiadores Danfoss
1.4 Contiki
No son muchos los usos comerciales que se han dado hasta el
momento a Contiki, pero sin duda el más importante de ellos puede ser la
Monitorización del Agua a distancia (Figura 1.6), desarrollado por el SICS
en el Mar Báltico. Se trata de un conjunto de sensores anclados a diferentes
profundidades que recogen información y son capaces de transmitirla de
forma inalámbrica.
DESARROLLO DE UN SISTEMA DOMÓTICO BASADO EN 6LOWPAN
Introducción.
19
Figura 1.6.Monitorización del agua a distancia
2 Motivación del proyecto
Este proyecto surge de ese afán de comodidad y de eficiencia que se
ha comentado antes. En primer lugar comodidad evidente a la hora de
facilitar el control de una casa desde cualquier lugar. En segundo lugar la
eficiencia a la hora de poder usar esta tecnología para reducir el consumo
de electricidad de una casa común. Se busca que el sujeto sea capaz de
controlar todo lo relativo a su casa de forma cómoda y sencilla.
A la vista de los trabajos ya realizados en este campo y las
investigaciones que se han llevado a cabo en el mismo, encontramos la
motivación de este proyecto. Es clara la necesidad de un sistema domótico
dentro de la vivienda donde los protocolos y software sean gratuitos, con
lo que eso supone en la reducción del coste de los dispositivos. El uso de
otros protocolos de comunicación, como es el caso de ZigBee, supone un
importe extra a la hora de implantar las redes que puede ser fácilmente
obviado con el uso de protocolos Open Source1.
La propuesta del uso de Contiki y de 6LoWPAN es una alternativa
muy atractiva para solucionar lo que ya se ha nombrado antes. Ambos
software cumplen a la perfección con la premisa de gratuidad y fácil
acceso a los mismos.
1
Llamamos así al conjunto de Software que es desarrollado y distribuido libremente.
DESARROLLO DE UN SISTEMA DOMÓTICO BASADO EN 6LOWPAN
20
Memoria
Además del coste, otro atractivo que tiene el sistema 6LoWPAN es su
funcionamiento directamente sobre protocolos IP lo que facilitará en gran
medida la conexión con la red inalámbrica Wi-Fi, ya existente en la
vivienda.
DESARROLLO DE UN SISTEMA DOMÓTICO BASADO EN 6LOWPAN
Introducción.
3 Objetivos y aplicaciones
Los principales objetivos que seguiremos a la hora de alcanzar
nuestra meta son los siguientes:
1)
Documentación.
Se procederá a la búsqueda de información referida a lo que este
proyecto abarca, con el fin de crear una base para el posterior desarrollo
del mismo. La búsqueda de información se enfocará a los recursos
(software, hardware…) que se van a emplear.
2)
Toma de contacto con Contiki y con el procesador MC13226V.
A fin de saber utilizar el citado sistema operativo para el futuro del
proyecto. El aprendizaje se realizara mediante tutoriales y uso del mismo.
La toma de contacto con el procesador se llevará a cabo mediante la
realización de aplicaciones sencillas usando dicho dispositivo.
3)
Diseño de una placa básica.
El fin de este objetivo es poder acoplar dicha placa al sistema de
desarrollo y poder simular el sistema domótico.
4)
Programación de MC13226V para uso en la comunicación entre
dos tarjetas.
Se desarrollara una aplicación capaz de realizar una comunicación
correcta entre los dos dispositivos de tal forma que cuando se pulse un
pulsador de una de las tarjetas se encienda un indicador (LED) en la otra.
5)
Programación de MC13226V para montar una pequeña red
domótica.
Se creará una pasarela con Internet para poder conectar la red
domótica a red local de casa.
4 Metodología
Una vez instalados Contiki y sus diferentes aplicaciones se procederá
al uso del mismo de forma sencilla a fin de conocer de forma precisa el
DESARROLLO DE UN SISTEMA DOMÓTICO BASADO EN 6LOWPAN
21
22
Memoria
entorno. La metodología que se usará será el ir de menos complejidad a
más en la creación de redes y comunicación entre dispositivos con el fin de
llegar a nuestro objetivo de forma sencilla y eficiente.
5 Recursos / herramientas empleadas
Para la realización del proyecto se van a utilizar diversas
herramientas que a continuación se detallan:

Contiki 2.5
Es un sistema operativo Open Source usado para el internet
de las cosas. Es un sistema portátil, multitarea para sistemas de
red que necesiten eficiencia en la memoria.

Freescale Sensor Reference Board
Es un sistema de desarrollo que cuenta con un procesador
MC13226 además de múltiples entradas y salidas, así como
sensores de temperatura, presión e incluso acelerómetros (Figura
1.7).
Figura 1.7.Freescale Sensor Reference Board
DESARROLLO DE UN SISTEMA DOMÓTICO BASADO EN 6LOWPAN
Introducción.
23

Redwire Econotag
Es un sistema de desarrollo que cuenta con un procesador
MC13226 además de múltiples conectores para su uso como
entradas y salidas (Figuras 1.8 y 1.9).
Figura 1.8. Redwire Econotag (Top)
Figura 1.9. Redwire Econotag(Bottom)

Placa Protoboard
Para la construcción de un circuito sencillo (Figura 1.10).
DESARROLLO DE UN SISTEMA DOMÓTICO BASADO EN 6LOWPAN
24
Memoria
Figura 1.10. Placa protoboard.

PC
Para ejecutar el sistema de desarrollo. Será necesario que el
sistema operativo de dicho PC sea Linux o en su caso una
máquina virtual sobre la que se pueda ejecutar la programación
de los distintos dispositivos. Para el caso particular del
desarrollo de este proyecto se ha elegido un sistema operativo
Windows con una instalación de una máquina virtual gracias a
la aplicación Instant Contiki que instala automáticamente en el
ordenador el programa VMware Player, dentro del cual hay una
versión completa de Linux con todas las librerías y todo lo
necesario para el uso de Contiki.
DESARROLLO DE UN SISTEMA DOMÓTICO BASADO EN 6LOWPAN
Principios Teóricos.
Capítulo 2 PRINCIPIOS TEÓRICOS
1 6LoWPAN
En este apartado se procederá a introducir el estándar que permite el
uso de IPv6 sobre redes inalámbricas de baja potencia2 (6LoWPAN). Gracias a
este protocolo se puede romper la barrera para el uso de IPv6 en
dispositivos de baja potencia.
6LoWPAN es un conjunto de estándares definidos y creados por el
Internet Engineering Task Force (IETF), que crean y mantienen todos los
estándares y arquitecturas basados en Internet.
El estándar 6LoWPAN permite el uso eficiente de IPv6 en redes de
baja potencia y baja tasa de datos en simples dispositivos empotrados
mediante una capa de adaptación y la optimización de los protocolos
referidos.
1.1 La arquitectura de 6LoWPAN
El internet inalámbrico integrado se crea a partir de la conexión de
pequeñas islas de dispositivos integrados, cada isla perteneciente a un
“stub network”3 en internet. La estructura de 6LoWPAN está hecha a partir
de redes inalámbricas de baja potencia (LoWPANs), que son IPv6 “stub
networks”. El conjunto de arquitectura 6LoWPAN se muestra en la Figura
2.1. Como se observa en dicha figura hay definidos tres niveles diferentes
de LoWPANs:

Simple LoWPAN.

Extended LoWPAN.

Ad hoc LoWPAN.
En inglés: IPv6 over Low-power Wireless Personal Area Networks = 6LoWPAN
Un “stub network” es una red cuyos paquetes IP son enviados “desde” o “destinados
a”, pero nunca funcionan como tránsito para otras redes.
2
3
DESARROLLO DE UN SISTEMA DOMÓTICO BASADO EN 6LOWPAN
25
26
Memoria
Figura 2.1. La arquitectura de 6LoWPAN
Una red LoWPAN es un conjunto de nodos que comparten el prefijo
de la dirección IPv6 (los primeros 64 bits de la dirección IPv6). Una red Ad
hoc LoWPAN no está conectada a internet, pero en lugar de eso puede
operar sin ninguna infraestructura. Por el contrario una red Simple
LoWPAN está conectada mediante un Edge Router a otra red IP4.
Finalmente, una red Extended LoWPAN abarca un conjunto de LoWPANs
de múltiples edge routers a lo largo de un link principal que las conecta
entre ellas.
En este tipo de redes los edge routers juegan un papel muy
importante ya que se encarga de conectar las redes y a la vez realizar la
compresión o descompresión necesaria ya sea el flujo entrante o saliente a
la red LoWPAN.
4
Internet Protocol
DESARROLLO DE UN SISTEMA DOMÓTICO BASADO EN 6LOWPAN
Principios Teóricos.
1.2 Introducción a 6LoWPAN
En este apartado se hará una pequeña introducción a los aspectos
más importantes de 6LoWPAN.
1.2.1 Pila del protocolo
En la Figura 2.2 se puede ver la pila de un protocolo 6loWPAN en
comparación con la de un protocolo IP normal y las cinco capas del
Modelo de Internet. Como se puede observar son prácticamente iguales
exceptuando las siguientes diferencias:

Lo primero de todo es que 6LoWPAN solo es compatible con IPv6,
de tal forma que ha sido definida una pequeña capa de adaptación
(llamada LoWPAN adaptation layer) para optimizar IPv6 sobre IEEE
802.15.4.

El protocolo de transmisión comúnmente utilizado suele ser el user
datagram protocol (UDP), que suele comprimirse usando el formato
LoWPAN. Por el contrario el transmission control protocol (TCP) no
suele usarse debido a razones de complejidad, eficiencia y
rendimiento.
Figura 2.2. Pilas de los protocolos IP y 6LoWPAN
DESARROLLO DE UN SISTEMA DOMÓTICO BASADO EN 6LOWPAN
27
28
Memoria

La adaptación entre IPv6 completo y el formato LoWPAN suele
realizarse en los routers que se encuentran entre las diferentes islas
de dispositivos 6LoWPAN, los edge routers que ya se comentaron en
el apartado anterior. En la Figura 2.3 se representa esto mismo con
más detalle.
Figura 2.3. IPv6 edge router con soporte para 6LoWPAN
1.2.2 Capas de enlace en 6LoWPAN
Una de las ventajas del protocolo de comunicación IP es la capacidad
que tiene de conectar enlaces heterogéneos formando una sola red en la
que existe la interoperabilidad. Lo mismo ocurre con 6LoWPAN y las
redes integradas, donde existen muchos tipos de enlaces inalámbricos (y
en ocasiones por cable). Al existir tantos tipos de comunicaciones tiene
que existir una aplicación con un rango más grande de integración que el
existente para PC, por ejemplo, que suelen usar solo Ethernet o WiFi.
Afortunadamente IEEE 802.15.4 es el estándar más utilizado en estos
casos, y que casualmente es la base sobre la que se desarrolla 6LoWPAN.
Como ya se describe en [RFC3819]5 para poder trabajar con IP es
necesario cumplir una serie de requisitos tales como direccionamiento,
control de errores, fiabilidad, etc. Por el contrario, 6LoWPAN está
diseñado para usar un tipo especial de enlace y por ello tiene diferentes
tipos de requerimientos.
Los requisitos más importantes en el uso de 6LoWPAN tienen que
ver con direccionamiento, las tramas (framing) y la transmisión punto a
punto (unicast transmission). El direccionamiento es necesario para
5
http://www.ietf.org/rfc/rfc3819.txt
DESARROLLO DE UN SISTEMA DOMÓTICO BASADO EN 6LOWPAN
Principios Teóricos.
diferenciar entre nodos de un enlace, y para formar direcciones IPv6 que
son luego comprimidas por 6LoWPAN.
Los accesos de enlace múltiple suelen ser capaces de administrar un
servicio broadcast, por eso no es necesario en 6LoWPAN multicast-service.
IPv6 requiere una unidad de transmisión máxima (MTU6) de 1280
bytes desde un enlace. 6LoWPAN cumple con esto mediante la
fragmentación de la capa de adaptación LoWPAN. El enlace debe
proporcionar un tamaño de al menos 30bytes para que sea útil
(preferiblemente de más de 60 bytes). Aunque UDP y ICMP proporcionan
una suma de comprobación de 16-bit es recomendable que la capa de
enlace proporcione una fuerte comprobación de errores.
1.2.3 Direccionamiento
El direccionamiento IP en 6LoWPAN es prácticamente igual que en
cualquier red IPv6, y muy similar, incluso, al direccionamiento sobre redes
Ethernet como se define en [RFC2464]7.
1.2.4 Formato del encabezamiento
La funcionalidad más importante de 6LoWPAN viene de la mano de
la capa de adaptación LoWPAN, que permite comprimir IPv6. Esta
compresión se basa en compartir información conocida a lo largo de todos
los nodos que participan en esta LoWPAN.
La cabecera de LoWPAN consiste en un valor que indica el tipo de
cabecera que es, seguido por un byte de compresión de la cabecera IPv6
que indica qué campos están comprimidos.
Un ejemplo de esta compresión en 6LoWPAN viene en la Figura 2.4.
Se puede observar como en el paquete superior existe un único byte (L )
para indicar que es IPv6 completa sobre IEEE 802.15.4. Por el contrario, en
6
7
Maximum transmission unit
http://www.ietf.org/rfc/rfc2464.txt
DESARROLLO DE UN SISTEMA DOMÓTICO BASADO EN 6LOWPAN
29
30
Memoria
el paquete inferior, existen 2 bytes para indicar una compresión de la
cabecera de IPv6.
Figura 2.4. Ejemplo de compresión en 6LoWPAN
1.2.5 Arranque (Bootstrapping)
Las aplicaciones más comunes a las que suele estar destinado
6LoWPAN requieren de una completa autonomía tanto en dispositivos
como en redes, que deben autoconfigurarse solos. El arranque primero
necesita ser ejecutado por la capa de enlace, de forma que habilite la
comunicación con todos los nodos dentro del radio de acción.
Para esto en 6LoWPAN se utiliza la herramienta de reconocimiento
de nodos vecinos (Neighbor Discovery). Esta herramienta está basada en la
ya existente para IPv6 pero optimizada para el uso en baja potencia,
siendo capaz de autoconfigurar la actuación de los hosts, routers y edge
routers en la red LoWPAN. El registro de todos los nodos se encuentra en
el edge router, que simplifica así la actuación de IPv6 sobre la red y reduce
la
cantidad
de
flujo
multipunto.
Además
6LoWPAN
Neighbor
Discovery(6LoWPAN-ND) permite que las redes de baja potencia puedan
tener más de un edge router bajo una misma raíz (e.g. Ethernet), y una
única generación de la dirección de la capa de enlace.
DESARROLLO DE UN SISTEMA DOMÓTICO BASADO EN 6LOWPAN
Principios Teóricos.
2 Contiki
Contiki es un sistema operativo “ligero” o de bajo consumo diseñado
específicamente para la creación de redes de comunicación con gran
cantidad de nodos. Es por eso que el sistema es capaz de soportar cargas
de programas y sustitución de programas y “servicios” de forma
dinámica, para no tener que parar el funcionamiento de toda la red para
cambiar o reparar la programación de uno de los nodos. Está construido
sobre un Kernel que actúa por eventos pero a su vez proporciona
multitarea preferente que puede ser asignada a un proceso individual.
2.1 Resumen del sistema
El sistema operativo Contiki necesita de un kernel, librerías, un
programa de carga y una serie de procesos para poder funcionar. Los
programas y aplicaciones pueden ser sustituidos mientras el dispositivo
está en funcionamiento. La comunicación entre procesos siempre se
realiza a través del kernel. Finalmente, el kernel no proporciona una capa
de adaptación con el hardware, deja a las aplicaciones comunicarse
directamente con el hardware.
Un proceso es definido mediante una función de control de eventos.
El estado del proceso está definido en la parte de la memoria destinada a
este fin, de esta forma el kernel solo coge un puntero hacia el estado del
proceso. Todos los procesos comparten el mismo espacio de direcciónes y
no funcionan en diferentes dominios protegidos. La comunicación entre
procesos se hace mediante un posting de eventos.
Como se ve en la Figura 2.5 el sistema Contiki esta partido en dos
mitades: el núcleo (core) y los programas ya cargados (loaded programs).
La partición se realiza durante la compilación y es específica de donde
Contiki vaya a ser usado. Normalmente, el núcleo está formado por el
kernel, el cargador de programas (program loader), las partes más usadas
del lenguaje del tiempo de ejecución y una pila de comunicación con
drivers para el hardware de comunicación.
DESARROLLO DE UN SISTEMA DOMÓTICO BASADO EN 6LOWPAN
31
32
Memoria
Figura 2.5.Partición entre el nucleo y los programas cargados.
2.2 La arquitectura del Kernel
El kernel de Contiki consiste en un sistema de planificación de
eventos de bajo consumo que reparte eventos entre los procesos en
ejecución y que periódicamente llama a una serie de procesos que
controlan dichos eventos.
El kernel soporta dos tipos de eventos: asíncronos y síncronos. Los
asíncronos son colocados en una cola y luego son distribuidos a los
procesos un tiempo después. Los eventos síncronos son similares a los
asíncronos pero hacen que el proceso objetivo sea inmediatamente
programado.
Además de lo ya mencionado el kernel proporciona un sistema
polling o de control de eventos. Este puede verse como un sistema de
prioridad de eventos que hace que sean programados entre los eventos
asíncronos. Suele ser usado por procesos que se encuentran “cerca” del
hardware para controlar de forma periódica el estado de los dispositivos
de dicho hardware. Por ejemplo, si se usa un puerto serie se tendrá que
utilizar dicho mecanismo para ver el flag de recepción del UART, para
comprobar si ha llegado un carácter y en caso afirmativo procesarlo.
2.2.1 Dos niveles de arquitectura de programación
La programación de eventos en Contiki se hace en un solo nivel, de
esta forma los eventos no se pueden adelantar unos a otros. La única
DESARROLLO DE UN SISTEMA DOMÓTICO BASADO EN 6LOWPAN
Principios Teóricos.
33
forma de adelantarse es mediante las interrupciones. Normalmente estas
interrupciones vienen implementadas por el uso del hardware, pero en
ocasiones pueden estar implementadas usando un sistema en tiempo real
subyacente (que utiliza la misma técnica previamente utilizada en el
kernel de Linux).
2.2.2 Modo de ahorro de energía
Un aspecto muy importante dentro de una red de sensores es ser
capaz de apagar uno de los nodos cuando esté inactivo. El ahorro de
energía en Contiki viene dado por dos fuentes, las aplicaciones y los
protocolos usados por la red. El kernel de Contiki tiene el propósito
directo de ahorrar energía. Para permitir a las aplicaciones saber cuándo
apagar el sistema el programador de eventos proporciona la longitud de la
cola de eventos. Gracias a esto se puede saber cuándo va a dejar de haber
eventos y así apagar el sistema. El sistema arrancará de nuevo cuando
surja una interrupción.
2.3 Servicios (services) en Contiki
En
Contiki,
un
servicio
es
un
proceso
que
implementa
funcionalidades que pueden ser usadas por otros procesos. Se puede ver
como una forma de librería compartida por los procesos. Los servicios, al
igual que los programas pueden ser reemplazados de forma dinámica en
tiempo de ejecución, pero a su vez tienen que ser vinculados también de
forma dinámica.
Los servicios están organizados en una capa de servicios que está
conceptualmente situada al lado del kernel. Dicha capa proporciona un
rastreo de los servicios que están siendo ejecutados así como un camino
para encontrar los ya instalados. Un servicio se identifica por una cadena
de caracteres que lo describe.
Un servicio se compone de una interfaz y un proceso que la
implementa. La interfaz está compuesta por una tabla que apunta hacia las
funciones que implementan dicha interfaz.
DESARROLLO DE UN SISTEMA DOMÓTICO BASADO EN 6LOWPAN
34
Memoria
2.4 Librerias
El kernel de Contiki solo proporciona las funcionalidades más
básicas de la CPU. Para todo lo demás están las librerías. Un programa
puede ser enlazado con una librería de tres formas diferentes. Primero,
puede ser enlazado de forma estática con librerías que forman parte del
núcleo. Segundo, puede ser enlazado de forma estática con librerías que
forman parte del propio programa cargado. Tercero, los programas
pueden llamar a servicios implementando una librería en particular. Para
este último caso es necesario lo que ya se ha comentado antes sobre la
sustitución dinámica de servicios en Contiki.
DESARROLLO DE UN SISTEMA DOMÓTICO BASADO EN 6LOWPAN
El procesador MC13226V.
Capítulo 3 EL PROCESADOR MC13226V
En este capítulo se expondrá el desarrollo de la primera toma de
contacto con el microprocesador MC13226V que va a ser usado en la
mayor parte del desarrollo del proyecto.
Para hacer un uso eficiente del procesador y eliminar los posibles
problemas derivados de un fallo en el diseño del hardware o incluso en el
montaje del mismo, el procesador será utilizado a través de una placa de
desarrollo. En este caso dicha placa será la denominada como Freescale
Sensor Reference Board, ya introducida en el capítulo primero de este
documento.
1 Borrado de la memoria FLASH
Antes de comenzar con la programación del microprocesador es
necesaria la preparación del mismo para dicho fin.
El dispositivo que se va a usar viene protegido contra escritura por
defecto. Para cambiar dicho estado es necesario seguir las instrucciones
que se detallan en el manual de referencia [8] y que a continuación se
explican.
El primer paso es identificar los jumpers J19 y J20. En la Parte cuatro
del presente documento se adjuntan una serie de esquemas necesarios
para dicho fin. Fijándose en el primero de estos esquemas podemos ver
que los jumpers buscados se encuentran en la parte superior central de la
tarjeta. En la Figura 3.1 se observa con más detalle estos dos jumpers.
Finalmente, en la Figura 3.2 se muestra la ubicación en el dispositivo real.
DESARROLLO DE UN SISTEMA DOMÓTICO BASADO EN 6LOWPAN
35
36
Memoria
Figura 3.1. Jumpers J19 y J20
Figura 3.2. Situación de J19 y J20 en la tarjeta.
El segundo paso que se debe realizar es el de cortocircuitar dichos
jumpers a la vez. Lo tercero que debemos realizar es encender el
dispositivo y pulsar el botón de reset durante unos segundos. Finalmente,
se debe apagar la tarjeta y así concluir el proceso de borrado de la
memoria Flash, ahora el dispositivo se encuentra en disposición de ser
programado.
En la Figura 3.3 se muestra el circuito que va detrás de este
procedimiento y cómo para obtener el estado de recuperación es necesario
poner la entrada ADC2_VREFH a 0 y la entrada ADC2_VREFL a 1.
DESARROLLO DE UN SISTEMA DOMÓTICO BASADO EN 6LOWPAN
El procesador MC13226V.
Figura 3.3.Circuito de recuperación
2 Carga de programas en MC13226V
Antes de empezar a conocer el microprocesador es necesario conocer
cómo se puede introducir un programa dentro del mismo, debido a que la
comprensión del funcionamiento del dispositivo se va a realizar por
medio de carga de distintos programas de prueba disponibles en la
librería libmc1322x. Esta librería ha sido creada y distribuida libremente
con el fin de facilitar el aprendizaje del sistema mediante el uso de
tutoriales. La librería es un conjunto de programas tutoriales que abarcan
la mayor parte de las funcionalidades del sistema.
2.1 Instalación de la librería libmc1322x
El primer paso es instalar dicha librería en el ordenador. Para ello es
necesario abrir el terminal del sistema operativo Linux e introducir el
siguiente comando.
git clone git://git.devl.org/git/malvira/libmc1322x.git
Una vez realizado este paso con éxito se dispone ya de la librería
completa dentro de la carpeta raíz del sistema.
2.2 Cargar imágenes en la RAM con mc1322x-load.pl
Una vez instalada ya la librería es el momento de aprender a usar
todas sus funcionalidades.
DESARROLLO DE UN SISTEMA DOMÓTICO BASADO EN 6LOWPAN
37
38
Memoria
Para poder cargar programas dentro del microprocesador se utilizará
la herramienta mc1322x-load.pl. Con ella se conseguirá una carga de
forma rápida y sencilla en un único paso. Es importante tener en cuenta
que con esto se consigue introducir el programa en la memoria RAM, por
lo que al apagar el dispositivo el programa se borrará automáticamente.
Para introducir el programa primero se ha de conectar la tarjeta de
desarrollo al ordenador por medio del puerto USB disponible. La carga
del programa se hará vía UART.
El siguiente paso es ir al terminal del ordenador y meter el comando
con el que se conseguirá la carga del programa buscada. Dicho comando
es el que se muestra a continuación.
~/libmc1322x/tools/mc1322x-load.pl –f nombredelprograma_freescalencb.bin –t /dev/ttyUSB0
Es importante tener en cuenta y ver en que entrada se encuentra
conectado la tarjeta de desarrollo, ya que en muchas ocasiones no estará
en la entrada USB0.
Una vez introducido el comando es necesario pulsar una vez el botón
de reset de la tarjeta para que funcione correctamente.
3 Entradas/salidas en MC13226V
Una vez que se ha recuperado la memoria FLASH y se conoce la
forma de cargar programas es el momento de empezar a tomar contacto
con las distintas entradas/salidas del microprocesador y ver cómo actuar
sobre ellas a la hora de realizar la programación.
3.1 Salidas en MC13226V
Se empezará primero con las salidas, debido a que requieren una
menor complejidad que las entradas y es un mecanismo más directo. Para
esta toma de contacto y las sucesivas que se harán se utilizaran los
ejemplos de la librería ya instalada que servirán de ayuda en la
comprensión del funcionamiento perseguido.
DESARROLLO DE UN SISTEMA DOMÓTICO BASADO EN 6LOWPAN
El procesador MC13226V.
Los programas que se utilizarán se encuentran todos en la carpeta
tests dentro de la carpeta libmc1322x en el directorio raíz.
Antes de proceder a introducir ningún programa es necesario hacer
la compilación de todos ellos para poder generar los archivos .bin que
posteriormente serán introducidos en el micro.
Para ello se procederá a ejecutar los siguientes comandos dentro del
terminal, prestando atención de estar en la carpeta correcta donde se
encuentran todos los archivos .c de los programas.
cd ~/libmc1322x/tests
make BOARD=freescale-ncb
Como se puede observar hemos elegido la tarjeta para la que se
quiere que se compilen todos los programas, así no generará archivos .bin
de más. En caso de querer que el ordenador compile para todos las tarjetas
disponibles en el Makefile únicamente se tendría que poner el comando
make, sin especificar tarjeta.
Se analizará en primer lugar todos los programas que únicamente
trabajen con los LED disponibles en la tarjeta. Estos programas son todos
los que comienzan su nombre con la palabra “blink”. Haciendo una
pequeña revisión de los códigos se descubre que en todos ellos se utilizan
un conjunto de funciones que previamente han sido definidas archivo
gpio.c,
archivo cuyo código se adjunta en la parte 3 del presente
documento.
Se puede observar como cada una de estas funciones simplemente da
un valor a un conjunto de punteros que sirven tanto para definir el valor
del puerto entrada/salida, como para inicializarlo.
Para conseguir comprender en mayor medida el funcionamiento de
estos punteros es necesario acudir al manual de referencia [9] y más
concretamente al capítulo 11 donde se explica cómo utilizar estos
registros, además de en que bit se encuentra cada entrada/salida de
propósito general del microprocesador. Para no extender demasiado este
DESARROLLO DE UN SISTEMA DOMÓTICO BASADO EN 6LOWPAN
39
40
Memoria
documento se ha preferido no introducir dicho manual de referencia
debido a su longitud. A continuación se hace una pequeña explicación en
el uso de dichos registros.
3.2 Registros GPIO
Lo primero que hay que hacer antes de nada es ver en que parte de
los registros se encuentran los LEDs y los pulsadores de la tarjeta de
desarrollo. Para ello hay que examinar el esquema del circuito de la tarjeta
que se adjunta en la parte cuatro de este documento. En la Figura 3.4 se
observa que los LEDs y pulsadores se encuentran en los pines del micro
denominados por KBI (de 0 a 7).
Figura 3.4. Conexión de los Leds/pulsadores
En el manual de referencia [9] que se ha mencionado antes viene la
tabla de correspondencia entre los pines del micro y el bit del registro
GPIO. En la Tabla 3.1 se muestra un extracto de la misma donde se ven los
pines KBI.
Register X
Bit
Function
Pin
23
GPIO23/KBI1
41
24
GPIO24/KBI2
40
25
GPIO25/KBI3
39
26
GPIO26/KBI4
38
27
GPIO27/KBI5
37
28
GPIO28/KBI6
36
29
GPIO29/KBI7
35
Tabla 3.1. Correspondencia Pin-Registro GPIO
DESARROLLO DE UN SISTEMA DOMÓTICO BASADO EN 6LOWPAN
El procesador MC13226V.
41
Para acceder a los bits correspondientes del registro el sistema
presenta una serie de punteros que facilitan la tarea de dar valor a dichos
registros
tanto
para
inicializarlos
como
para
actuar
sobre
las
entradas/salidas. Dichos punteros normalmente suelen estar divididos en
dos, uno se encarga de los primeros 32bits del registro y el segundo se
encarga de los otros 32bits. Generalmente, como
los bits de los
LEDs/pulsadores se encuentran dentro de los primeros 32 se hará
únicamente referencia al puntero que los tiene en cuenta
A continuación se hace un pequeño resumen de los registros más
importantes y que se utilizarán en esta primera parte del proyecto.
3.2.1 GPIO_PAD_DIR0
Este registro es el encargado de definir la dirección
de un
determinado pin del micro, teniendo dos posibles valores, entrada o
salida. Cuando se encuentra a 0 significa que el pin es una entrada, en
cambio, cuando se encuentra a 1 el pin es una salida.
A su vez tiene dos punteros complementarios:

GPIO_PAD_DIR_RESET0.
Cuando
se
pone
un
1
en
un
correspondiente bit de este registro se pone automáticamente un 0
en el correspondiente bit de registro GPIO_PAD_DIR0.

GPIO_PAD_DIR_SET0.
Cuando
se
pone
un
1
en
un
correspondiente bit de este registro se pone automáticamente un
en el correspondiente bit de registro GPIO_PAD_DIR0.
3.2.2 GPIO_PAD_PU_SEL0
Este registro es el encargado de decir si en un determinado pin del
micro la conexión se ha hecho mediante una resistencia pull-up ó pulldown. Poniéndolo a 0 se activa la opción pull-down y poniéndolo a 1 se
activa la opción pull-up.
DESARROLLO DE UN SISTEMA DOMÓTICO BASADO EN 6LOWPAN
42
Memoria
3.2.3 GPIO_DATA_SEL0
Este registro es el encargado de determinar si los datos de un
determinado pin van a ser leídos desde el Data Register o directamente
desde el pad. Cuando se pone un determinado bit a 0 quiere decir que la
lectura se va a realizar desde el pad. Por el contrario, si al bit se le da el
valor 1 quiere decir que la lectura se va a realizar desde el Data Register.
3.2.4 GPIO_DATA0
Es el puntero a través del cual se interactúa con la entrada/salida, de
tal forma que si está en modo salida se le puede poner el valor que se elija.
Mientras que si está en modo entrada desde él se puede leer el valor de
dicha entrada.
3.2.5 GPIO_FUN_SEL1
Es el registro que se encarga de seleccionar la función que tendrá
cada pin. Tiene dos bit por cada pin del microprocesador. A continuación
se muestra la tabla de correspondencia entre el valor y la función a la que
corresponde que ha sido extraída de [9].
Category
Alternative
Function
Function 0
[00]
(Default)
Function 1
Function 2
Function 2
[01]
[10]
[11]
1
SSI
GPIO
SSI
GPIO
GPIO
2
SPI
GPIO
SPI
GPIO
GPIO
3
TIMER
GPIO
TIMER
GPIO
GPIO
4
I2C
GPIO
I2C
GPIO
GPIO
5
UART
GPIO
UART
GPIO
GPIO
6
KBI
GPIO/KBI
GPIO/KBI
GPIO/KBI
GPIO/KBI
7
ADC
-
-
GPIO
GPIO
GPIO
TX Control
RX Control
GPIO
8
EXT RF
CTL
DESARROLLO DE UN SISTEMA DOMÓTICO BASADO EN 6LOWPAN
El procesador MC13226V.
Category
9
Alternative
Function
43
Function 0
[00]
(Default)
JTAG &
JTAG &
Nexus
Nexus
Function 1
Function 2
Function 2
[01]
[10]
[11]
GPIO
GPIO
GPIO
Tabla 3.2. Selección de Funciones en GPIO
3.2.6 Aplicación final a las salidas
Así pues, si lo que se quiere es encender un determinado LED (o
simplemente actuar sobre una salida) en un determinado pin se ha de
proceder como se expone en el siguiente ejemplo.
El primer paso que hay que dar es el de poner los “includes”
necesarios. Para este caso en particular los serán los siguientes.
#include <mc1322x.h>
#include <board.h>
A continuación se procede con el programa principal, donde (si no se
necesita ninguna variable) lo primero es inicializar los puertos con los
registros que ya se han explicado anteriormente. El LED elegido en este
ejemplo es el que se encuentra en el pin KBI1, el bit 23 del registro.
*GPIO_FUNC_SEL1 = 0; /*Eliges el LED con función GPIO*/
*GPIO_PAD_DIR0 |= (1 << 23); /*Pones el LED como salida*/
Finalmente, ya solo queda actuar sobre el LED como se estime
oportuno para las diferentes aplicaciones a las que vaya dirigido el
programa. En este caso ponemos un ejemplo de un parpadeo del
determinado LED.
while(1) {
*GPIO_DATA0 |=(1 << 23); /*Enciendes el LED*/
for(i=0; i<DELAY; i++) { continue; }
*GPIO_DATA0&=~(1 << 23);/*Apagas el LED*/
for(i=0; i<DELAY; i++) { continue; }
}
Una vez realizado el programa sólo queda compilarlo para la tarjeta
a la que va destinada como ya se ha visto en anteriores apartados y
cargarlo en la misma.
DESARROLLO DE UN SISTEMA DOMÓTICO BASADO EN 6LOWPAN
44
Memoria
3.3 Entradas en MC13226V
Una vez expuesto el funcionamiento de las salidas resulta más fácil
entender las entradas, que prácticamente funcionan igual. Como todos los
punteros necesarios ya han sido explicados, se analizarán las entradas a la
luz de un ejemplo. En este caso el ejemplo será el que se adjunta en la
parte III del documento, conpulsadores.c.
Al igual que antes, una vez hechos todos los “includes”, hay que
realizar las inicializaciones dentro del programa principal. Esta vez es
muy importante seleccionar que tipo de resistencia va a haber a la entrada
cuando actives el pulsador, es decir, como está implementado el circuito
del pulsador (de esto dependerá que tengas un 0 o un 1 a la entrada
cuando pulses) y seleccionar desde donde se va a leer el valor del registro
para las posteriores operaciones que se vayan a realizar.
*GPIO_FUNC_SEL1 = 0; /*Eliges los pulsadores con función GPIO*/
*GPIO_PAD_DIR0 |= (7 << 23); /*Pones el LED como salida*/
*GPIO_PAD_DIR_RESET0 = (1 << 26);/*Pones el pulsador como
entrada*/
*GPIO_PAD_PU_SEL0 |= (1 << 26);/*Activas la resistencia de pullup, es decir que cuando pulses te va a poner un 0*/
*GPIO_DATA_SEL0 &= ~(1 << 26); /*Seleccionas que vas a leer desde
el Data register un no desde el pad*/
A continuación viene realizar las operaciones, en este caso serán:

Leer el registro.

Seleccionar el bit del pulsador elegido.

Dependiendo del valor del mismo actuar.
t = *GPIO_DATA0; /*Lees las entradas */
a = ((t >> 26) & 1);/*Seleccionas el bit*/
if(a == 1){
*GPIO_DATA0|=(1 << 24);/*Enciendes el LED2*/
}else{
*GPIO_DATA0&=~(1 << 24);/*Apagas el LED2*/
}
Para completar el programa se ha incluido la opción de sacar por
pantalla, vía el UART, el valor del registro completo, por si en algún
momento y por algún caso el programa no llega a funcionar del todo ver si
el registro funciona correctamente. Este ha sido una de los pasos clave a la
DESARROLLO DE UN SISTEMA DOMÓTICO BASADO EN 6LOWPAN
El procesador MC13226V.
45
hora de conseguir entender y hacer funcionar las salidas dentro de este
proyecto. Generalmente todo funciona correctamente y es en la elección de
las inicializaciones donde se encuentra el fallo, por ello hay que tener
especial cuidado en este paso.
Para mostrar por pantalla el registro completo se utiliza una función,
que viene previamente definida dentro del sistema que muestra un solo
caracter, para definir una segunda función que sea capaz de mostrar una
cadena de caracteres completa. Esta segunda función es la que se muestra
a continuación.
void uart1_puts(char *ps){
while (*ps != '\0'){
uart1_putc(*ps);
ps++;
}
}
Finalmente, lo único que se debe hacer es
llenar la cadena de
caracteres con el registro completo y sacarlo por pantalla.
for(i=0;i<=31;i++){
/*El registro tiene 32bits de 0 a 31*/
j=((*GPIO_DATA0>>i)&1);
if(j == 1){
buffer[i] = '1';
}
else{
buffer[i] = '0';
}
}
uart1_puts(buffer);
uart1_puts("\n");
Es muy importante tener en cuenta que para que esto funcione
correctamente es necesario haber inicializado el módulo UART de la
tarjeta. Para ello el sistema trae definida una función que hay que poner en
las inicializaciones del programa.
uart1_init(INC,MOD,SAMP);
DESARROLLO DE UN SISTEMA DOMÓTICO BASADO EN 6LOWPAN
46
Memoria
4 Primeras comunicaciones entre dos tarjetas
Una vez que se han conseguido los pasos anteriores y ya se controlan
tanto las entradas como las salidas el siguiente paso es el de ser capaz de
hacer una comunicación básica entre dos tarjetas. Se intentará hacer que
mientras se pulsa un pulsador en una de las tarjetas en la otra se encienda
un LED. Para ello primero se hará de forma básica para probar que
funcionan bien, usando una comunicación básica de 802.15.4.
En la Figura 3.5 se muestra un simple esquema de lo que se pretende
hacer en este apartado.
Figura 3.5. Esquema comunicación entre dos tarjetas.
La forma en la que se va a proceder para alcanzar el fin que se
propone es introducir un programa en la tarjeta emisora que cuando
detecte que se ha pulsado un determinado pulsador envíe un paquete
cuyo contenido sea un ‘1’. A partir de esto habrá que introducir un
segundo programa en la tarjeta receptora que detecte los paquetes
entrantes y cuando alguno sea ‘1’ encienda un determinado LED. A
continuación se explica más detalladamente estos programas.
4.1 Inicialización del módulo de comunicación
Antes de comenzar las aplicaciones que hemos descrito antes, el
programa tiene que tener una parte que se encargue de la inicialización de
las comunicaciones. En este caso coincidirán tanto para el programa de
transferencia como para el de recepción.
Las inicializaciones que se deben hacer son las que se incluyen en los
correspondientes códigos adjuntos en la parte de este documento
destinada a los códigos fuentes.
DESARROLLO DE UN SISTEMA DOMÓTICO BASADO EN 6LOWPAN
El procesador MC13226V.
printf("trim_xtal");
trim_xtal();
printf("->done\n");
printf("vreg_init");
vreg_init();
printf("->done\n");
printf("maca_init");
maca_init();
printf("->done\n");
set_channel(0); /* 802.15.4 canal 11 */
set_power(0x12); /* 0x12 es la más alta, 4.5dBm */
Las tres primeras funciones vienen definidas en el propio sistema y
son autónomas, no hay que configurarlas de ninguna manera. Con ellas se
consigue que iniciar el regulador de voltaje del NVM (vreg_init()), que se
inicie el hardware de comunicación y el bucle de interrupciones para la
recepción y transmisión (maca_init()), y finalmente que el on-board crystal
se ponga en exactamente 24MHz.
Después de estas se encuentran otras dos funciones a las cuales si
que hay que pasarles un valor. Con la primera de ellas se elige el canal en
el cual se va a realizar la comunicación, generalmente el canal más usado
es el 11. Y con la segunda se configura la potencia de emisión, en este caso
se elige la más alta para no tener problemas en este sentido.
4.2 Programa emisor
El primer programa que se va a realizar será el que vaya en el
emisor. Antes de comenzar con la programación es importante saber qué
forma tienen los paquetes que se van a enviar o recibir, para saber donde
habrá que escribir o leer el valor de dicho paquete.
4.2.1 La estructura de los paquetes
La estructura interna de dichos paquetes es la que se muestra a
continuación.
struct packet {
uint8_t length;
/* offset into data for first byte of the packet payload */
DESARROLLO DE UN SISTEMA DOMÓTICO BASADO EN 6LOWPAN
47
48
Memoria
/* On TX this should be 0 */
/* On RX this should be 1 since the maca puts the length as the
first byte*/
uint8_t offset;
uint8_t data[MAX_PAYLOAD_SIZE+2+1]; /* +2 for FCS; + 1 since maca
returns the length as the first byte */
};
typedef struct packet packet_t;
Se observa que los paquetes cuentan con tres partes claramente
diferenciadas. La primera que define la longitud que van a tener los
paquetes. Una segunda parte que define el offset que tendrán. Y
finalmente una tercera parte donde se encuentra el verdadero valor del
paquete y que será la parte útil del mismo que se deberá usar.
4.2.2 Función para rellenar paquetes
Es necesario crearse una función cuyo cometido sea el de rellenar un
paquete que después será enviado. Dicha función se muestra a
continuación.
void fill_packet(volatile packet_t *p){
(p->data)[0] = '1';
(*p).length = 1;
(*p).offset = 0;
}
En este caso como solo se quiere mandar un único ‘1’ los valores del
paquete se definen directamente.
Si el paquete interesa que sea una cadena de caracteres, donde
valores como la longitud del paquete vienen condicionados por dicha
cadena la función encargada de rellenar un paquete tiene que ser como se
muestra a continuación.
void fill_packet(volatile packet_t *p){
sprintf(p->data, "Hola:\n");
p->length = strlen(p->data);
(*p).offset = 0;
}
DESARROLLO DE UN SISTEMA DOMÓTICO BASADO EN 6LOWPAN
El procesador MC13226V.
4.2.3 Bucle infinito
Finalmente lo único que queda es definir el bucle infinito que se
ejecutará durante el funcionamiento del dispositivo.
Lo primero de todo se pone un LED de comprobación para ver que
realmente el sistema pasa dentro del bucle. Luego se lee el registro GPIO y
se extrae el bit que interese, como ya se hiciera en apartados anteriores.
Finalmente lo que queda es actuar en función del valor de dicho bit.
Si el bit tiene un valor de ‘0’ quiere decir que el pulsador está siendo
pulsado y es el momento de enviar un paquete con valor ‘1’. Para ello
primero es necesario obtener un nuevo paquete con la función ya definida
en el sistema get_free_paqket(), si este paso ha sido correcto la función nos
devuelve un TRUE. Si este paso ha sido correcto lo que hay que hacer es
enviar el paquete. Para ello, primero le tenemos que llenar y luego enviar
con la función ya definida tx_packet().
while(1) {
*GPIO_DATA0 |=(1 << 23); /*Enciendes el LED1*/
t = *GPIO_DATA0; /*Lees las entradas */
a = ((t >> 26) & 1);
if(a == 0){
p_mi_paquete = get_free_packet();
if(p_mi_paquete) {
fill_packet(p_mi_paquete);
tx_packet(p_mi_paquete);
printf("Enviando\n");
} else {
printf("can't get free packet\n");
}
}
}
4.3 Programa receptor
Para el programa que hay que cargar en la tarjeta receptora lo único
que hay que cambiar respecto al programa anterior es el bucle infinito.
DESARROLLO DE UN SISTEMA DOMÓTICO BASADO EN 6LOWPAN
49
50
Memoria
Además de la comprobación de que el sistema se ha introducido de
forma correcta dentro del bucle esta vez hay que actuar solo cuando se
detecte que se ha recibido un paquete. Para ello se utiliza la función
rx_packet()
que devuelve el paquete que se ha recibido cuando esto
ocurre.
Posteriormente hay que comprobar el valor que tiene dicho paquete
y cuando este coincida con el requisito del programa (en este caso se
quiere que el paquete tenga valor ‘1’) actuar. Esta vez la forma elegida de
actuación es encender un LED en la tarjeta de recepción.
Finalmente lo que se debe hacer es liberar la cola de paquetes para
poder seguir recibiendo más.
while(1) {
*GPIO_DATA0 |=(1 << 23); /*Enciendes el LED1*/
if((p_mi_paquete = rx_packet())) {
/* print and free the
packet */
if( (p_mi_paquete->data)[p_mi_paquete->offset]=='1'){
*GPIO_DATA0 |=(1 << 24); /*Enciendes el LED1*/
}
free_packet(p_mi_paquete);
}
}
4.4 Fallo en la inicialización del módulo de comunicación.
Una vez se han realizado los pasos anteriores es el momento de
probar su correcto funcionamiento.
En este punto se comprueba que los programas tienen un fallo en
común y el sistema no funciona debido a ello. El problema surge cuando
el programa comienza su inicialización e intenta inicializar el módulo de
comunicación. El fallo que se da es que el programa se queda bloqueado.
Después
de
una
minuciosa
búsqueda
poniendo
textos
de
comprobación de paso para ver en qué función se quedaba parado el
programa y dentro de esta en qué punto era, se descubrió que el problema
venia de la inicialización del módulo NVM. Los dos programas, tanto
enviapaquetes.c
como recibepaquetes.c se quedaban parados en la función
DESARROLLO DE UN SISTEMA DOMÓTICO BASADO EN 6LOWPAN
El procesador MC13226V.
maca_init()
51
y dentro de esta en la inicialización de la Non Volatile
Memory. Una vez llegados a este punto hay dos posibles fuentes de fallo:

Que haya que poner en esta parte del programa el sistema en
modo THUMB para que entienda el código de forma correcta.

Están mal las direcciones de memoria dentro de la
inicialización del NVM.
Lo lógico hubiese sido abordar en primera instancia el primer posible
fallo y una vez resuelto o desechado pasar al siguiente. Pero un nuevo
problema surgió en este punto, la falta de información al respecto. Se hizo
una búsqueda intensiva de cómo proceder para funcionar en modo
THUMB pero no se consiguió una guía apropiada, y lo poco que se
consiguió hacía suponer que sería una tarea costosa. Por eso se determinó
el abordar primero la segunda fuente de fallo y desecharla.
A continuación se muestra el programa de inicialización del NVM.
#include "nvm.h"
nvmErr_t (*nvm_detect)
(nvmInterface_t nvmInterface,nvmType_t* pNvmType)
= (void *) 0x00006cb9;// 2a38;
nvmErr_t (*nvm_read)
(nvmInterface_t nvmInterface , nvmType_t
uint32_t address, uint32_t numBytes)
= (void *) 0x00006d69;// 2ae8;
nvmType
,
void
*pDest,
nvmErr_t (*nvm_write)
(nvmInterface_t nvmInterface, nvmType_t nvmType ,void *pSrc, uint32_t
address, uint32_t numBytes)
= (void *) 0x00006ec5;// 2c40;
nvmErr_t (*nvm_erase)
(nvmInterface_t
nvmInterface,
sectorBitfield)
= (void*) 0x00006e05;// 2b80;
nvmType_t
nvmType
,uint32_t
void(*nvm_setsvar)
(uint32_t zero_for_awesome)
= (void *)0x00007085;// 2df8;
Se ha resaltado en rojo donde se encontraba el problema. Todos los
punteros de las funciones definidas dentro de la ROM del Chip apuntaban
a unas direcciones de memoria erróneas. Esto es debido a que todos los
DESARROLLO DE UN SISTEMA DOMÓTICO BASADO EN 6LOWPAN
52
Memoria
programas y tutoriales que se han estado usando para el aprendizaje en el
uso del microprocesador, y que se encontraban dentro de la librería
libmc1322x
estaban definidos para un microprocesador muy parecido pero
a la vez diferente al se ha estado usando hasta el momento, el MC13224V.
Esto hace que las direcciones de memoria a las que apuntan esos punteros
estén destinadas a otros usos en el MC13226V.
La forma en la que se intentó solucionar este problema fue en primer
lugar contactar con el creador de los tutoriales y pedirle ayuda respecto a
las direcciones de memoria de nuestro micro.
Su respuesta fue inmediata y el resultado fue unas nuevas
direcciones de memoria, que en el código anterior se han resaltado en
azul.
Una vez introducidas las nuevas direcciones de memoria en el
programa se realizó una nueva prueba y se comprobó que el mismo
problema persistía.
La segunda forma de intentar solucionar el problema fue con el uso
de la herramienta JTAG. Se procedió desensamblando la ROM y viendo si
realmente en las direcciones de memoria que se nos habían proporcionado
parecía iniciar una función. En la Figura 3.6 se puede apreciar que
realmente en esa una de las direcciones de memoria dadas aparecía lo que
parecía ser un inicio de función.
DESARROLLO DE UN SISTEMA DOMÓTICO BASADO EN 6LOWPAN
El procesador MC13226V.
Figura 3.6. Pantallazo del Terminal con ROM desensamblada.
Viendo que esta dirección no era la correcta se recorrió todo el código
de la ROM buscando funciones parecidas y probando las correspondientes
direcciones de memoria, obteniendo un resultado negativo.
Finalmente, por el fallo rotundo en el intento de cambiar las
direcciones de memoria y viendo prácticamente imposible el aprender a
manejar modo THUMB en poco tiempo se optó por cambiar de tarjetas y
utilizar unas que tuviesen un microprocesador MC13224V, donde se sabía
que realmente funcionaba todo correctamente.
Buscando el consejo del creador de los tutoriales se determinó optar
por comprar dos tarjetas Redwire Econotag, que parecían ser la opción
mejor y menos costosa.
DESARROLLO DE UN SISTEMA DOMÓTICO BASADO EN 6LOWPAN
53
El procesador MC13224V.
Capítulo 4 EL PROCESADOR MC13224V
En este capítulo se expondrá el desarrollo y la manera de proceder
para la primera toma de contacto con el microprocesador MC13224V. Esta
vez, a diferencia de en el anterior capítulo, no será necesario “flashear” la
memoria para empezar con la programación del dispositivo, al igual que
no será necesario el tener que hacer un repaso de todos los punteros que
controlan el registro que se encarga de las entradas y salidas, ya que es el
mismo y se usa de la misma manera en la programación.
El microprocesador viene instalado en la tarjeta de desarrollo
Redwire Econotag, cuyos esquemas más relevantes para este proyecto
vienen adjuntos en la última de las partes del presente documento.
1 Adecuación previa de la tarjeta
Antes de comenzar nuevamente con la revisión del funcionamiento
de las entradas y las salidas en esta nueva tarjeta es necesario instalarle un
LED y un pulsador a la misma ya que no trae dichos elementos. Si que es
cierto que la tarjeta trae instalados dos pulsadores y dos LEDs pero están
destinados a otros fines ya establecidos (los LEDs, por ejemplo, son para
encenderse cuando se emite, el LED rojo, y cuando se recibe, el LED verde,
un paquete).
El primer paso para esto es buscar los pines en los cuales se van a
conectar el LED y el pulsador. Como se puede ver en la Figura 1.6 la tarjeta
cuenta con unos accesos directos a los pines que no están siendo usados
con otro fin. Para la elección de pines hay que tener en cuenta que tanto
las entradas como las salidas tienen que estar dentro de los pines
nombrados por KBI, como ocurría en la tarjeta de desarrollo anterior.
Leyendo todos los pines disponibles se observa que los únicos que
son del tipo KBI son los que se muestran en la Figura 4.1, que es un zoom
DESARROLLO DE UN SISTEMA DOMÓTICO BASADO EN 6LOWPAN
55
56
Memoria
que se le ha hecho a la tarjeta. Por lo tanto se debe conectar el LED y el
pulsador a uno de estos cuatro pines KBI2, KBI3, KBI6 y KBI7.
Figura 4.1.Zoom de la tarjeta Redwire Econotag.
En la Figura 4.2 se observa una parte del esquema adjunto en la
última parte del documento. En ella se puede ver como los pines KBI2,
KBI3, KBI6, KBI7 están conectados a los pines de la tarjeta 40, 39, 36 y 35,
que a su vez corresponden con los bits 24, 25, 28 y 29 del registro GPIO,
como se vio en capítulos anteriores.
Figura 4.2. Parte del esquema de Redwire Econotag.
Una vez elegidos los pines sobre los que vamos a conectar las
entradas/salidas, es el momento de elegir un punto del que se sacará la
tierra de referencia. Es necesario sacar la tierra directamente de la tarjeta
para que las tensiones en las entradas/salidas tengan el mismo nivel y
todo funcione correctamente.
Para buscar el pin que servirá de tierra es necesario mirar el
esquema que aparece en la Figura 2.2 de la parte 4 de este documento.
DESARROLLO DE UN SISTEMA DOMÓTICO BASADO EN 6LOWPAN
El procesador MC13224V.
En la Figura 4.3 se muestra un zoom de dicho esquema donde
aparece un pin, que es accesible, conectado a tierra. Por lo tanto el pin
elegido para servir de tierra de referencia será el segundo conector del JP3
Figura 4.3. Zoom del esquema 2 de Redwire Econotag.
En la Figura 4.4 se muestra en que parte de la tarjeta se puede acceder
al pin elegido.
Figura 4.4. Zoom 2 de la tarjeta Redwire Econotag
Finalmente, ya solo queda soldar en los puntos elegidos unas
hembras para poder conectar unos cables que saldrán hacia el circuito. En
la Figura 4.5 se muestra como se ha realizado la soldadura y que tipo de
hembras se ha utilizado.
Figura 4.5. Soldadura de las hembras en los pines.
DESARROLLO DE UN SISTEMA DOMÓTICO BASADO EN 6LOWPAN
57
58
Memoria
2 Diseño
e
implantación
de
un
circuito
sencillo
(LED+Pulsador)
Una vez soldadas las hembras en la tarjeta es la hora de diseñar e
implantar el circuito. Para esta segunda parte, la implantación, se utilizará
una placa protoboard, para que sea más rápido y sencillo de utilizar.
El diseño del circuito es sencillo, solo hace falta un LED, una
resistencia para limitar la corriente que pasa por el LED y finalmente un
pulsador. Para el diseño de la resistencia no será necesario hacer ningún
cálculo ya que en la propia tarjeta hay instalados dos LED con una
resistencia en serie, por lo tanto se cogerá el mismo valor (Figura 4.6).
Figura 4.6. LED+Resistencia instalado en la tarjeta de desarrollo.
El pulsador se conectará directamente entre el pin y tierra por lo que
a la hora de leer la entrada en el pin se tiene que tener en cuenta que
cuando se pulsa se pone un ‘0’ y hay que habilitar en el correspondiente
registro el pull-up.
En la Figura 4.7 se muestra el esquema del diseño del circuito y en la
Figura 4.8 se muestra su posterior implantación y conexión a una de las
tarjetas de desarrollo.
Figura 4.7. Circuito LED + Pulsador
DESARROLLO DE UN SISTEMA DOMÓTICO BASADO EN 6LOWPAN
El procesador MC13224V.
Figura 4.8. Implantación y conexión del circuito a la tarjeta.
3 Entradas/Salidas en MC13224V
Para comprobar el funcionamiento de las entradas y las salidas
dentro de esta nueva tarjeta se procederá de igual forma que con la
anterior tarjeta, teniendo en cuenta una serie de especificaciones.
Al haber sido ya explicado el procedimiento esta vez se pasará más
rápido sobre él, resaltando únicamente las variantes con respecto a lo
anterior. Se utilizará directamente el programa conpulsadores.c, adjunto
en la parte tres del documento y ya utilizado anteriormente.
3.1 Cambio en los pines y bits del registro GPIO
Algo muy importante a tener en cuenta y sin lo que el programa no
funcionará correctamente es que esta vez los LEDS y los pulsadores se
encuentran en bits diferentes a la tarjeta anterior, por ello hay que cambiar
la inicialización de los mismos y tenerlo en cuenta a la hora de manejarlos.
Como se ve en la Figura 4.6, esta vez el LED se encuentra en la I/O KBI2,
que corresponde con el bit GPIO24. El pulsador, por su parte, se encuentra
en la I/O KBI6, que corresponde con el bit GPIO28.
Con esto, hay que ir a la parte del programa que se encarga de la
inicialización de los registros y cambiar el número de los bits, como se
muestra a continuación.
DESARROLLO DE UN SISTEMA DOMÓTICO BASADO EN 6LOWPAN
59
60
Memoria
*GPIO_FUNC_SEL1 = 0; /*Eliges el pulsador con función GPIO*/
*GPIO_PAD_DIR0 |= (1 << 24); /*Pones el LED como salida*/
*GPIO_PAD_DIR_RESET0 = (1 << 28);/*Pones el pulsador como
entrada*/
*GPIO_PAD_PU_SEL0 |= (1 << 28);/*Activas la resistencia de pullup, es decir que cuando pulses te va a poner un 0*/
*GPIO_DATA_SEL0 &= ~(1 << 28); /*Seleccionas que vas a leer desde
el Data register un no desde el pad*/
*GPIO_DATA0 &= ~(1 << 24); /*Apagas el LED*/
3.2 Modificación del archivo Makefile
Es importante tener en cuenta que cada vez que se requiere que un
nuevo programa, que no estaba previamente en la librería, se compile
cuando se introduce el comando correcto, es necesario modificar el
archivo Makefile para indicarle al sistema que también tiene que compilar
dicho programa. Para conseguir esto es necesario introducir el nombre del
programa dentro del apartado TARGETS, dentro del archivo. A
continuación se muestra un ejemplo con el programa conpulsadores.c.
# all of the target programs to build
TARGETS := conpulsadores \
blink-red blink-green blink-blue blink-white blink-allio\
uart1-loopback \
u1u2-loopback \
tmr tmr-ints \
sleep \
printf \
asm \
adc \
pwm \
wdt \
xtal-trim
Hay que tener en cuenta que si el programa va a hacer uso de la
memoria ROM del micro es necesario meter el nombre del programa en la
parte de TARGETS_WITH_ROM_VARS, como es el caso de los programas
enviapaquete.c
y recibepaquetes.c.
# these targets are built with space reserved for variables needed by ROM
services
# this space is initialized with a rom call to rom_data_init
TARGETS_WITH_ROM_VARS := enviapaquetes recibepaquetes \
#nvm-read nvm-write romimg flasher \
rftest-rx rftest-tx \
autoack-rx autoack-tx \
DESARROLLO DE UN SISTEMA DOMÓTICO BASADO EN 6LOWPAN
El procesador MC13224V.
4 Primeras comunicaciones entre dos tarjetas.
Una vez ya probadas las entradas/salidas del sistema es el momento
de pasar al siguiente paso, como se hiciera con la anterior tarjeta sin un
resultado satisfactorio.
Se procederá de la misma forma y se utilizarán los mismos
programas que en la anterior vez, enviapaquete.c y recibepaquetes.c.
Como ya se ha comentado en el apartado 3 de este Capítulo, la única cosa
que hay que variar es el número de bit en el que se encuentran los pines
utilizados.
En la Figura 4.9 se muestra un esquema de lo que se pretende
conseguir en este apartado.
Figura 4.9. Esquema primera comunicación entre dos tarjetas.
Una vez que se ha entendido bien el esquema y que es lo que se va a
hacer a continuación, es el momento de empezar. Para ello tenemos que
introducir los archivos .bin correspondientes a los programas antes
nombrados en sus correspondientes tarjetas. En este punto hay que tener
una pequeña precaución, y es que cuando conectas los Redbee Econotag
por el puerto USB generalmente aparecen dos dispositivos. Normalmente
hay que introducir el programa en el segundo que aparece, pero no viene
mal hacer una comprobación antes. Como se ve en la Figura 4.10 una vez
que se conectan las dos tarjetas aparecen 4 dispositivos conectados por el
DESARROLLO DE UN SISTEMA DOMÓTICO BASADO EN 6LOWPAN
61
62
Memoria
puerto USB. Es recomendable primero conectar una de las tarjetas y ver
que puertos aparecen y luego conectar la otra, para ver cual corresponde a
cada una.
Figura 4.10. Vista Terminal con dispositivos conectados.
4.1 Fallo en la inicialización.
Una vez que se han introducido los dos programas en las tarjetas
correspondientes es el momento de ver si existe algún fallo en alguna
parte. Cuando se realiza la carga de los programas dentro de las tarjetas el
sistema muestra por pantalla todos los textos de paso que se habían
puesto para ver el correcto funcionamiento del programa. Como se puede
observar en la Figura 4.11 la salida por pantalla es totalmente correcta y
efectivamente aparece en la misma todo lo que debe aparecer.
Sin embargo aun apreciándose un correcto funcionamiento una vez
que se intenta ejecutar, pulsando en una de las tarjetas para que en la otra
se encienda un LED, no funciona. El posible fallo puede venir motivado
por dos fuentes:

No se han realizado correctamente la inicializaciones, no solo
del modulo de comunicación sino del registro GPIO.

Algo falla en las funciones de enviar (tx_packet()) y recibir
(rx_packet()) definidas en el sistema.
DESARROLLO DE UN SISTEMA DOMÓTICO BASADO EN 6LOWPAN
El procesador MC13224V.
Figura 4.11. Vista Terminal corriendo enviapaquetes.c
Antes de intentar meterse a fondo dentro de una de las posibles
fuentes de fallo para solucionarla, es necesario ver cuál de las dos tarjetas
es la que está fallando. Para determinar cuál es la que falla se empezará
viendo si realmente el emisor está emitiendo algo, ya que si viene de aquí
el fallo se descartará automáticamente el receptor como fuente de fallo.
Para ver si el emisor emite se utilizará el sniffer Peryton S/SG que
opera dentro de 802.15.4. Una vez montada nuevamente la red entre las
dos tarjetas se comprueba gracias a esta aplicación que el emisor es el que
está dando problemas y no está haciendo ninguna emisión.
Para intentar solucionar el problema primero se hará una revisión de
todas las inicializaciones que son necesarias y se verá si falta alguna o se
ha hecho incorrectamente.
Gracias a esta revisión se descubre la falta de una de las
inicializaciones dentro del registro GPIO. Es necesario inicializar de forma
correcta los pines de Tx. Es necesario ponerlos en la función de
transferencia (Función 1). También será necesario poner los pines de SPI
en función SPI (Función 1) Para ver en qué pin se encuentra se utilizará
nuevamente el manual de referencia [9]. En la Tabla 4.1 se muestra un
extracto de este manual donde se pueden ver los bits necesarios.
DESARROLLO DE UN SISTEMA DOMÓTICO BASADO EN 6LOWPAN
63
64
Memoria
GPIO
Chip Pin
PORT
Name
Functional Functional Functional Functional
0
1
2
3
GPIO_4
SPI_SS
GPIO_4
SPI_SS
GPIO_4
GPIO_4
GPIO_5
SPI_MISO
GPIO_5
SPI_MISO
GPIO_5
GPIO_5
GPIO_6
SPI_MOSI
GPIO_6
SPI_MOSI
GPIO_6
GPIO_6
GPIO_7
SPI_SCK
GPIO_7
SPI_SCK
GPIO_7
GPIO_7
…
GPIO_44
TX_ON
GPIO_44
TX Seq Mgr
RX Seq Mgr
GPO1
GPO1
GPIO_44
Tabla 4.1. Correspondencia pin-bit
Por lo tanto el nuevo código de inicialización del registro quedará de
la siguiente manera.
*GPIO_FUNC_SEL0 |= (0x55<<8); /*Pones los pines de SPI en funcion 1*/
*GPIO_FUNC_SEL2 = (0x01 << ((44-16*2)*2)); /*Pones Tx ON*/
Gracias a esto se consigue que el programa y a su vez la red
funcionen correctamente.
4.2 Impresión de paquetes.
Como última comprobación antes de dar por concluida esta fase se
añadirá al código una línea que saque por pantalla el paquete que se ha
recibido, en caso del receptor, o que se ha emitido, en caso del emisor. Con
esto se comprobará que realmente se está recibiendo bien lo que se está
enviando. Para ello se utilizará una función previamente definida en el
sistema, print_packet(). Esta función además de mostrar el paquete
muestra más información como el tiempo que ha tardado desde que se
envía hasta que se recibe.
printf("rftest-tx --- ");
print_packet(p);
En las Figura 4.12 y Figura 4.13 se muestran los dos terminales donde
se puede comprobar la correspondencia entre paquetes. Se observa como
DESARROLLO DE UN SISTEMA DOMÓTICO BASADO EN 6LOWPAN
El procesador MC13224V.
cuando se pulsa en enviapaquetes se pone un ‘1’ y a la vez se recibe en
recibepaquetes.
Figura 4.12. Funcionamiento de enviapaquetes.c
Figura 4.13. Funcionamiento de recibepaquetes.c
Después de esta última comprobación se puede dar por concluida
esta fase de primeros pasos en la tarjeta de desarrollo y el
microprocesador. El siguiente paso será ya el inicio en el desarrollo de una
pequeña red domótica con Contiki y 6LoWPAN.
DESARROLLO DE UN SISTEMA DOMÓTICO BASADO EN 6LOWPAN
65
Programación de una red con Contiki y 6LoWPAN.
Capítulo 5 PROGRAMACIÓN DE UNA RED CON
CONTIKI Y 6LOWPAN
Antes de empezar la programación de la red domótica con Contiki y
6LoWPAN y con el fin de no volver a caer en errores de inicialización, esta
vez se va a comenzar la programación desde una buena base, una base
que funcione correctamente y desde la cual se pueda construir una red
propia.
Para ello se probará primero una pequeña red con las dos tarjetas
disponibles una de ellas haciendo de border router y la otra de un cliente
udp. Para conseguir hacer esto se utilizarán los programas de prueba que
vienen dentro del archivo de contiki una vez que se ha instalado la
aplicación InstantContiki.
1 Compilar programas con Contiki
Antes de dar ningún otro paso es necesario realizar una compilación
de los programas para generar los archivos .bin que serán necesarios
cargar dentro de la memoria de las tarjetas.
Para realizar la compilación primero es necesario situarse en el
directorio adecuado. Por ejemplo, para acceder al directorio del programa
que va a ir dentro de la tarjeta que hará de border router la secuencia es la
siguiente.
cd contiki/examples/ipv6/rpl-border-router
Dentro de este directorio hay que realizar la compilación con el
siguiente comando.
make
TARGET=redbee-econotag
Es importante tener en cuenta que ahora el comando ha cambiado
ligeramente a como se hacía en anteriores capítulos, esta vez es necesario
poner TARGET en lugar de BOARD.
DESARROLLO DE UN SISTEMA DOMÓTICO BASADO EN 6LOWPAN
67
68
Memoria
Se repite el proceso para el caso del cliente udp, cuyo directorio se
encuentra donde se muestra a continuación.
cd contiki/examples/ipv6/rpl-udp
2 Esquema básico de una programa en Contiki
Todos los programas del sistema operativo Contiki tienen que tener
obligatoriamente un esquema básico a partir del cual se desarrolla el
programa completo y sin el cual no funciona correctamente.
Este esquema es el que se muestra a continuación.
#includes
PROCESS(ejemplo_process, “proceso ejemplo”);
AUTOSTART_PROCESSES(&ejemplo_process);
PROCESS_THREAD(ejemplo_process,ev,data);
{
PROCESS_EXITHANDLER(goto exit);
PROCESS_BEGIN();
while(1){
/*Espacio para el programa*/
exit:
PROCESS_END();
}
}
El primer paso que hay que dar es el de definir el proceso con un
nombre y con una cadena de caracteres que lo definan.
Posteriormente, es necesario indicarle al sistema que se quiere que el
programa empiece a ejecutarse automáticamente cuando se introduzca en
la tarjeta.
A partir de PROCESS_THREAD es donde realmente empieza a
definirse el proceso.
El programa que se va a ejecutar tiene que estar definido entre un
PROCESS_BEGIN y un PROCESS_END pudiendo estar este último dentro
o fuera del bucle infinito dependiendo de si se ha definido o no un punto
de salida con la función PROCESS_EXITHANDLER().
DESARROLLO DE UN SISTEMA DOMÓTICO BASADO EN 6LOWPAN
Programación de una red con Contiki y 6LoWPAN.
3 Programación de una red sencilla border router-cliente udp
Lo que se pretende en este apartado es que una de las tarjetas actúe
como border router para poder así mandar información al ordenador a
través de un SLIP tunnel, que será generado con la herramienta tunslip6.
Una vez que la información es enviada se podrá ver a través de un
navegador estándar, como es Mozilla, metiendo en la barra de direcciones
la dirección IP del border router.
3.1 Esquema de la red
El esquema de lo que se pretende conseguir en esta primera
aproximación a nuestra red definitiva se muestra en la Figura 5.1.
Figura 5.1. Esquema de la red.
3.2 Ejecución de la red
Como en esta primera aproximación únicamente se van a utilizar los
programas que vienen dentro de la librería, lo único que hay que hacer es
cargarlos y comprobar su correcto funcionamiento, y una vez hecho esto
empezar a ver cómo escribir un programa que cumpla con el fin
perseguido en este proyecto.
Una vez ya compilados ambos programas en sus respectivas carpetas
se procede a la carga de los mismos en tarjetas diferentes.
DESARROLLO DE UN SISTEMA DOMÓTICO BASADO EN 6LOWPAN
69
70
Memoria
3.2.1 Border Router
Primero se hará la carga del programa border-router.c. Para ello se
utilizará el comando ya utilizado anteriormente y que se muestra a
continuación.
mc1322x-load.pl -f border-router_redbee-econotag.bin -t /dev/ttyUSB1
Con este comando la dirección de la MAC es al azar, pero siempre se
mantendrá la misma. Las direcciones IP de ambas tarjetas se muestran
siempre en el comienzo de la ejecución del programa que se haya cargado
en la respectiva tarjeta. Esto se puede observar en la Figura 5.2, en esta se
ve como las primeras líneas de ejecución dan dicha información que
después será necesaria para introducirla en la barra de direcciones de
Mozilla.
Figura 5.2. Primeras líneas de ejecución border-router.c
En este caso, la tarjeta que va a hacer de border router tiene una
dirección IP aaaa:0000:0000:0000:0250:c2ab:c000:0001.
En este caso la dirección IP de la tarjeta a sido previamente
programada. Para ello se ha utilizado la aplicación “flasher” que viene con
la librería.
DESARROLLO DE UN SISTEMA DOMÓTICO BASADO EN 6LOWPAN
Programación de una red con Contiki y 6LoWPAN.
Lo primero que hay que hacer es compilar las herramientas
necesarias, en este caso BBMC (Bit-Bang the MC13224v).
cd contitiki/cpu/mc1322x/tool/ftditools
make
Luego se procede a cargar el programa que se va a encargar del
“flasheado”.
~/contiki/cpu/mc1322x/tool/mc1322x-load.pl –e –f
~/libmc1322x/test/flasher_redbee-econotag.bin –z –t /dev/ttyUSB1 –c
‘bbmc –l redbee-econotag reset’ 0x1e000, 0xABC25000, 0x010000C0
De esta forma la próxima vez que se use la tarjeta tendrá la dirección
que se ha mostrado anteriormente.
3.2.1.1 SLIP tunnel
Para generar el SLIP tunnel se utilizará la herramienta tunslip6 que
viene con el sistema operativo Contiki.
Para ello lo primero que hay que hacer es compilar el programa.
cd contiki/tools
make tunslip6
Finalmente, se ejecuta la aplicación introduciéndole sobre que puerto
se va a realizar el túnel. El comando “-v3” se introduce para ejecutar la
aplicación en modo debug para que aparezca sobre el terminal la
actividad que hay sobre la conexión. La última parte del comando se
introduce para indicarle que actúe sobre la dirección IP global.
sudo ~/contiki/tools/tunslip6 -s /dev/ttyUSB1 -v3 aaaa::1/64
3.2.2 Udp-client
Para cargar el programa del cliente udp en la otra tarjeta es necesario
abrir un nuevo terminal para poder dejar corriendo la herramienta
tunslip6.
En este nuevo terminal lo que hay que hacer ahora es introducir el
comando necesario para la carga del programa en la tarjeta.
DESARROLLO DE UN SISTEMA DOMÓTICO BASADO EN 6LOWPAN
71
72
Memoria
~/contiki/cpu/mc1322x/tool/mc1322x-load.pl -f udp-client_redbeeeconotag.bin -t /dev/ttyUSB2 'bbmc -l redbee-econotag -i 0'
En la Figura 5.3 se muestra las primeras líneas en la ejecución del
programa, donde se puede ver la dirección que tiene esta tarjeta.
Figura 5.3. Primeras líneas de ejecución udp-client.c
3.2.3 Comprobar la red en el servidor web
Una vez realizados estos pasos ya solo queda el comprobar que la
red se está ejecutando correctamente. Para ello se introduce simplemente
la dirección de la tarjeta que hace las veces de border-router en la barra de
direcciones del navegador. El resultado en una página web generada por
esta tarjeta en la que aparecen los nodos vecinos en la red. En la Figura 5.4
se muestra el ejemplo de esta página web con la red que se ha realizado
con los dos Econotags.
DESARROLLO DE UN SISTEMA DOMÓTICO BASADO EN 6LOWPAN
Programación de una red con Contiki y 6LoWPAN.
Figura 5.4. Página web generada por border-router.c
Se puede comprobar cómo efectivamente coinciden las direcciones
mostradas en la página con las de las tarjetas que se han mostrado en
anteriores figuras.
4 Entradas/salidas en Contiki
Una vez que se ha conseguido montar una pequeña red entre dos
tarjetas mediante el sistema operativo Contiki y con la base de
comunicaciones de 6LoWPAN, es la hora de empezar a incluirle
aplicaciones orientadas a la domótica. Con este fin el primer paso es ver el
tratamiento que se le da a las I/O en Contiki.
Al ser éste un sistema operativo orientado a la comunicación, el
manejo de las entradas y salidas se realiza a base de una serie de funciones
previamente definidas en el propio sistema y que se expondrán a
continuación.
4.1 Salidas
Todas las funciones que tienen que ver con el manejo de las salidas y
más concretamente con el manejo de los LEDs vienen definidas en un
archivo .c dentro del propio sistema. El archivo se encuentra en el
siguiente directorio.
~/contiki/core/dev/leds.c
DESARROLLO DE UN SISTEMA DOMÓTICO BASADO EN 6LOWPAN
73
74
Memoria
En este archivo se encuentran todas las funciones necesarias para el
manejo de los LEDs. Entre ellas las más importantes serán las de
encendido y apagado de los mismos así como la de invertir el estado de
uno de los LED, que están definidas de la forma que se muestra a
continuación.
void leds_on(unsigned char ledv)
{
unsigned char changed;
changed = (~leds) & ledv;
leds |= ledv;
show_leds(changed);
}
/*---------------------------------------------------------------------*/
void leds_off(unsigned char ledv)
{
unsigned char changed;
changed = leds & ledv;
leds &= ~ledv;
show_leds(changed);
}
/*---------------------------------------------------------------------*/
void leds_toggle(unsigned char ledv)
{
leds_invert(ledv);
}
Fijándose en la definición de todas ellas se percibe como a todas hay
que pasarles un argumento, que tiene la misma forma en todas. Este
argumento tiene que ver con los pines en los que se quiere que funcione
esa determinada función. Como ocurre casi con todo, estos argumentos
vienen ya definidos en un archivo adjunto en el sistema. Dicho archivo se
encuentra en el .h del archivo anteriormente citado. La definición a la que
se está haciendo referencia es la siguiente.
#ifndef LEDS_GREEN
#define LEDS_GREEN 1
#endif /* LEDS_GREEN */
#ifndef LEDS_YELLOW
#define LEDS_YELLOW 2
#endif /* LEDS_YELLOW */
#ifndef LEDS_RED
#define LEDS_RED 4
#endif /* LEDS_RED */
#ifndef LEDS_BLUE
#define LEDS_BLUE LEDS_YELLOW
#endif /* LEDS_BLUE */
DESARROLLO DE UN SISTEMA DOMÓTICO BASADO EN 6LOWPAN
Programación de una red con Contiki y 6LoWPAN.
#ifdef LEDS_CONF_ALL
#define LEDS_ALL
LEDS_CONF_ALL
#else /* LEDS_CONF_ALL */
#define LEDS_ALL
7
#endif /* LEDS_CONF_ALL */
A su vez todos estos argumentos están definidos sobre otros que son
específicos de cada tarjeta y que determinan en cada caso en que pin de la
tarjeta se encuentran los LEDs que vienen instalados por defecto. En el
caso concreto de este proyecto, se ha instalado un LED más a la tarjeta, con
lo que el archivo debe ser modificado para poder actuar sobre el mismo.
Dicho archivo se encuentra en la siguiente dirección.
~/contiki/cpu/mc1322x/board/redbee-econotag.h
En este caso como la tarjeta tiene únicamente dos LEDs podemos
definir el LED de más en cualquiera de los argumentos que se han visto
anteriormente y que no se estén utilizando. En este caso se ha elegido
LED_BLUE y la definición se ha realizado como sigue y teniendo en
cuenta que el LED se instaló en el bit 25 del registro GPIO.
#define LED_RED
44
#define LED_GREEN 45
#define LED_BLUE 25
Fijándose en los esquemas adjuntos en la parte cuarta del presente
documento se puede comprobar que los LEDs que están definidos por
defecto en la tarjeta (LED_RED y LED_GREEN) coinciden con lo esperado,
ya que se encuentran en los bits del registro GPIO 44 y 45. En la Figura 5.5
se muestra un zoom de dicho esquema con lo que se ha comentado
resaltado.
Figura 5.5. Zoom del esquema 1 de Redwire Econotag.
DESARROLLO DE UN SISTEMA DOMÓTICO BASADO EN 6LOWPAN
75
76
Memoria
4.2 Entradas
El manejo de las entradas en Contiki es un proceso un tanto
complicado pero que a la hora de usarlo resulta extremadamente sencillo.
El uso es tan sencillo debido a que el propio sistema actúa de forma casi
automática sin necesidad de hacer nada complicado. Cada vez que se
pulsa un botón el sistema lo detecta y activa un flag para que tu programa
actúe de una determinada forma.
Para que esto ocurra lo primero de todo es inicializar el sensor que se
va a encargar de detectar cada vez que se pulse, que en Contiki se
denomina “button_sensor”. Para la inicialización es necesario introducir
en el inicio del programa la siguiente línea de código.
SENSORS_ACTIVATE(button_sensor);
Finalmente, para que el sistema actúe cuando se pulse es necesario
escribir dentro del bucle infinito la siguiente línea de código que se
encargará de pausar el programa hasta que se produzca el evento
deseado, en este caso que se pulse.
PROCESS_WAIT_EVENT_UNTIL((ev==sensors_event)
&button_sensor));
&&
(data
==
Todo lo que se escriba después de esta línea de código únicamente
se ejecutará cuando se produzca el evento deseado.
4.3 Ejemplo Entradas/Salidas
Para probar y ejemplificar todo lo que se ha explicado anteriormente
se ha realizado un programa que abarque todo y en el que se pueda ver
claramente el funcionamiento de todo. El programa se va a encargar de
encender y apagar el LED de la tarjeta periódicamente cada vez que se
pulse el pulsador. El código completo del programa se ha adjuntado en la
tercera parte del presente documento con el nombre de entradasalida1.c.
Lo primero que hay que hacer para que todo funcione correctamente
es hacer los includes necesarios para poder usar las funciones. En este caso
son los siguientes.
DESARROLLO DE UN SISTEMA DOMÓTICO BASADO EN 6LOWPAN
Programación de una red con Contiki y 6LoWPAN.
77
#include "dev/leds.h"
#include "dev/button-sensor.h"
Una vez hecho esto y ya dentro del programa hay que inicializar el
sensor del pulsador y a la vez se enciende el LED.
SENSORS_ACTIVATE(button_sensor);
leds_on(LEDS_ALL);
Lo único que queda ya es introducir la condición dentro del bucle
infinito para que el programa funcione solo cuando pulsas, y la
correspondiente actuación sobre el LED cuando esto ocurre.
PROCESS_WAIT_EVENT_UNTIL((ev==sensors_event)
&button_sensor));
&&
(data
==
if (push % 2 == 0) {
leds_toggle(LED_BLUE);
printf("[%d] APAGANDO EL LED ... [DONE]\n", push);
push++;
} else {
leds_toggle(LED_BLUE);
printf("[%d] ENCENDIENDO EL LED ...
[DONE]\n", push);
push++;
}
if (push == 255){ push = 0;} // previene el overflowing
}
En la Figura 5.6 se muestra la salida del programa donde se ve el
correcto funcionamiento del mismo.
Figura 5.6. Salida del programa entradasalida1.c
DESARROLLO DE UN SISTEMA DOMÓTICO BASADO EN 6LOWPAN
78
Memoria
5 Ejecución de una pequeña red domótica
Después de haber conseguido con éxito comunicar dos tarjetas
llegando a crear una pequeña red y después de manejar con éxito tanto
entradas como salidas, es el momento de crear una pequeña red domótica
donde en una tarjeta se elija el estado de la iluminación de la casa y en la
otra se ejecute este estado.
En un primer momento la idea más razonable era a partir de los
programas de border router y de udp client generar un código que se
amoldase a las necesidades de este proyecto. Tras un análisis de ambos
códigos y con una escasa documentación al respecto se ha desechado esta
idea. El fin ahora será el de generar un código propio que tenga unas
funciones muy básica pero que sea a la vez capaz de llegar a la finalidad
del proyecto.
Se procurará desarrollar un programa donde en el momento en el
que se pulse el botón en una de las tarjetas se envíe un paquete a la otra y
esta lo indique con el LED. El flujo podrá ser bidireccional de forma que se
pueda simular un sensor y un actuador en una vivienda. Para este caso se
necesita un flujo bidireccional de forma que el sensor envíe lo que percibe
y desde el actuador se envíe la manera de proceder.
5.1 Funciones necesarias
A la hora de desarrollar el programa se necesitarán una serie de
funciones previamente definidas en el sistema y que serán de mucha
utilidad en el envío y recepción de paquetes. Todo este conjunto de
funciones se encuentran en el archivo simple-udp.h, disponible en la
siguiente dirección.
~/contiki/core/net/simple-udp.h
5.1.1 Función de envío
La función que se utilizará para dicho fin será simple_udp_sendto(),
cuya definición se muestra a continuación y cuyo fin es el de enviar un
DESARROLLO DE UN SISTEMA DOMÓTICO BASADO EN 6LOWPAN
Programación de una red con Contiki y 6LoWPAN.
paquete UDP a una determinada dirección IP. El envío se realizará entre
los puertos que serán previamente definidos con la función de registro
simple_udp_register().
int
simple_udp_sendto(struct simple_udp_connection *c,
const void *data, uint16_t datalen,
const uip_ipaddr_t *to)
{
if(c->udp_conn != NULL) {
uip_udp_packet_sendto(c->udp_conn, data, datalen,
to, UIP_HTONS(c->remote_port));
}
return 0;
}
Los argumentos que hay que pasarle a la función son los siguientes:

c: es un puntero a una estructura simple_udp_connection.

data: es un puntero a los datos que van a ser enviados.

datalen: la longitud de los datos.

to: la dirección IP del receptor.
5.1.2 Función de registro
Esta va a ser una función imprescindible para el funcionamiento de
la función de envío. Se encargará de registrar una conexión UDP viendo
los nodos vecinos y probando la conexión por medio del éxito en el envío
y posterior recepción de un paquete. La función que se utilizará será
simple_udp_register(), cuya
definición se muestra a continuación.
int
simple_udp_register(struct simple_udp_connection *c,
uint16_t local_port,
uip_ipaddr_t *remote_addr,
uint16_t remote_port,
simple_udp_callback receive_callback)
{
init_simple_udp();
c->local_port = local_port;
c->remote_port = remote_port;
if(remote_addr != NULL) {
uip_ipaddr_copy(&c->remote_addr, remote_addr);
}
c->receive_callback = receive_callback;
DESARROLLO DE UN SISTEMA DOMÓTICO BASADO EN 6LOWPAN
79
80
Memoria
PROCESS_CONTEXT_BEGIN(&simple_udp_process);
c->udp_conn = udp_new(remote_addr, UIP_HTONS(remote_port), c);
if(c->udp_conn != NULL) {
udp_bind(c->udp_conn, UIP_HTONS(local_port));
}
PROCESS_CONTEXT_END();
if(c->udp_conn == NULL) {
return 0;
}
return 1;
}
Los argumentos necesarios en esta función son los siguientes:

c: es un puntero a una estructura simple_udp_connection.

local_port: el puerto UDP local con los bytes ordenados según
host.

remote_addr: la dirección IP remota.

remote_port: el puerto UDP remoto con los bytes ordenados
según host.

receive_callback: un puntero a la función que tiene que ser
llamada para paquetes entrantes.
5.1.3 Función de recepción
Esta será la función que se ejecutará cada vez que exista un paquete
entrante. La función que se utilizará será receiver() y la definición se
tendrá que crear en el propio programa.
5.2 Desarrollo del programa
A continuación se muestra el programa que se ha desarrollado
explicado por pasos. El código del programa completo se encuentra en la
tercera parte de este documento. El programa será el mismo para las dos
tarjetas y tendrá que tener tanto la función de envío como la de recepción.
DESARROLLO DE UN SISTEMA DOMÓTICO BASADO EN 6LOWPAN
Programación de una red con Contiki y 6LoWPAN.
5.2.1 Include
El primer paso importante que hay que dar es el de definir los
includes necesarios. Los más importantes que hay que poner son los que
se enumeran a continuación.
#include "simple-udp.h"
#include "dev/leds.h"
#include "dev/button-sensor.h"
El primero es el encargado de las funciones de comunicación entre
las dos tarjetas, las que se han descrito anteriormente. Las dos siguientes
son las necesarias para el manejo de los LED y del pulsador.
5.2.2 Definición de la función de recepción
El siguiente paso a destacar es el de la definición de la función que se
ha de ejecutar cada vez que se reciba un paquete. La definición es la que se
muestra a continuación.
static void
receiver(struct simple_udp_connection *c,
const uip_ipaddr_t *sender_addr,
uint16_t sender_port,
const uip_ipaddr_t *receiver_addr,
uint16_t receiver_port,
const uint8_t *data,
uint16_t datalen)
{
static uint8_t push = 0;
printf("Datos recibidos en el puerto %d de 2 desde el puerto %d de 1 con
una longitud %d\n",
receiver_port, sender_port, datalen);
leds_toggle(LED_BLUE);
}
Lo único que hace la función es sacar un mensaje por pantalla y a la
vez cambiar el estado del LED según este encendido o apagado.
5.2.3 Definición del proceso
Lo único que queda ya es la definición del proceso y del bucle
infinito.
DESARROLLO DE UN SISTEMA DOMÓTICO BASADO EN 6LOWPAN
81
82
Memoria
Dentro del proceso lo que hay que hacer es activar el sensor que se
encarga del funcionamiento de los botones. Para ello se incluye la línea de
código que se vió en capítulos anteriores.
SENSORS_ACTIVATE(button_sensor);
Después de esto lo que hay que hacer es registrar la conexión con la
función que se ha visto antes y decir que cada vez que haya un paquete
entrante se ejecute la función receiver().
simple_udp_register(&c, UDP_PORT,NULL, UDP_PORT,receiver);
Finalmente ya solo queda definir el bucle infinito en el cual se debe
ejecutar la función de envío cada vez que se pulse el botón de la tarjeta.
while(1) {
PROCESS_WAIT_EVENT_UNTIL(
(ev==sensors_event)
&button_sensor));
printf("Enviando paquete ...\n");
uip_create_linklocal_allnodes_mcast(&addr);
simple_udp_sendto(&c, "Test", 4, &addr);
}
&&
(data
==
5.3 Salida del programa en cada tarjeta
En este apartado se muestran las salidas correspondientes a cada
tarjeta.
En la Figura 5.7 se muestra la salida del programa para la tarjeta 1. En
esta imagen se puede observar como la dirección IP de la tarjeta
permanece desde que se hiciera el flasheado de la MAC.
DESARROLLO DE UN SISTEMA DOMÓTICO BASADO EN 6LOWPAN
Programación de una red con Contiki y 6LoWPAN.
Figura 5.7. Salida del programa redom.c en la tarjeta 1
En la Figura 5.8 se muestra la salida del programa para la tarjeta 2.
Figura 5.8. Salida del programa redom.c en la tarjeta 2
Se puede comprobar viendo las dos imágenes como cada vez que se
envía un paquete con una de las tarjetas en la otra se recibe correctamente
y se imprime el mensaje en el correspondiente terminal.
DESARROLLO DE UN SISTEMA DOMÓTICO BASADO EN 6LOWPAN
83
Conclusiones.
85
Capítulo 6 CONCLUSIONES
El objetivo de este proyecto era el de implantar una pequeña red
domótica con la que se pudiese comprobar la validez del sistema
6LoWPAN en estos casos. El primer pasó que se ha dado a sido el de
tomar un primer contacto con las tarjetas de desarrollo que se iban a usar
con el fin de hacer una programación más fluida posteriormente.
En un principio se tomó como primera tarjeta de desarrollo Freescale
Sensor Reference Board con la cual se obtuvo un resultado poco
satisfactorio en uno de los primeros pasos del desarrollo del proyecto,
debido a un problema en las direcciones de los punteros que apuntaban a
las funciones almacenadas en la ROM.
En un segundo caso se optó por la tarjeta de desarrollo Redbee
Econotag, que monta un microprocesador diferente a la anterior tarjeta.
Con esta tarjeta se consiguió satisfactoriamente completar todos los pasos.
En primer lugar se consiguió dominar tanto los puertos de entradas
como los de salida, donde se tuvo que instalar tanto un LED como un
pulsador respectivamente debido a la falta de los mismos en la propia
tarjeta y con los cuales la comprobación del funcionamiento de dichos
puerto no sería sencilla.
El siguiente paso sería la comprobación del funcionamiento del
sistema de comunicación inalámbrica de la tarjeta, lo cual se consiguió de
un modo satisfactorio por medio de pequeños programas de envio y
recepción de paquetes.
Finalmente ya solo quedaba crear la red inalámbrica deseada. Para
ello se aunó una comunicación inalámbrica basada en direcciones IP,
gracias a 6LoWPAN, y el manejo de las entradas y las salidas que
previamente se había conseguido dominar. Todo esto fue incluido en un
programa que fue introducido en las tarjetas y con el cual se consiguió
DESARROLLO DE UN SISTEMA DOMÓTICO BASADO EN 6LOWPAN
86
Memoria
satisfactoriamente el resultado deseado en el proyecto, quedando
demostrada y comprobada la validez del sistema 6LoWPAN para redes
domóticas.
DESARROLLO DE UN SISTEMA DOMÓTICO BASADO EN 6LOWPAN
Futuros Desarrollos.
Capítulo 7 FUTUROS DESARROLLOS
A lo largo de este capítulo se analizarán los posibles futuros
desarrollos que tienen como base el presente proyecto. Se trata de futuros
proyectos que puede ser interesante abordar para utilizar lo que en este
proyecto se ha utilizado y se ha conseguido.
1 Conexión de la red 6LoWPAN a Internet.
Uno de los siguientes pasos más claros y directos que puede tener
este proyecto es el de su uso para la realización de un control completo de
una vivienda desde múltiples dispositivos.
Una vez conseguido el objetivo de este proyecto y habiendo
conseguido realizar una pequeña red domótica, sería lógico pensar en
llevar a la práctica esto e implantarlo en una pequeña vivienda, o una
simulación de ella. De esta forma y habiendo conseguido montar una red
sobre IP, que es uno de los atractivos del sistema 6LoWPAN, el siguiente
paso sería el de conseguir conectar la red de la vivienda con la red de
internet de la misma, con el objetivo de poder actuar sobre ella con el
único requisito de tener una conexión a internet desde cualquier punto del
planeta.
Esta conexión se realizaría siguiendo profundizando un poco más en
uno de los pasos que se ha visto con anterioridad. Se trata de conectar la
red de la vivienda a través de un border-router, que a su vez esté
conectado con un PC desde el cual se puedan enviar y recibir paquetes.
Como se ha visto la conexión a internet a partir de aquí es muy sencilla,
dando pie al posible control de la vivienda multiplataforma.
Como se puede ver en la Figura 7.1 un posible ejemplo de esto que se
ha comentado es el control de la vivienda desde un dispositivo iPhone.
Teniendo una simple conexión a internet puedes elegir entre distintos
DESARROLLO DE UN SISTEMA DOMÓTICO BASADO EN 6LOWPAN
87
88
Memoria
estados de las luces de la vivienda e incluso controlar el estado de las
mismas.
Figura 7.1. Ejemplo de control via iPhone
2 Smart cities
Un aspecto muy importante dentro de una smart city es el del control
de la energía. Una fuente de consumo, y de derroche en ocasiones, muy
importante de energía es el conjunto de todas las viviendas de una ciudad,
en las cuales la legislación no puede entrar, como es el caso del sector
industrial donde una serie de normas rigen los consumos y las
instalaciones que es debido poner.
Gracias a este proyecto es muy fácil el poder realizar un control, o
consumo, más eficiente y moderado dentro de una vivienda. Así, por
ejemplo, se puede dejar programado el funcionamiento de una lavadora o
un lavavajillas para que la compañía eléctrica la accione en un momento
en el que el consumo de energía presente un valle. Esto sería posible si
dentro de la vivienda se ha creado una red domótica conectada a los
electrodomésticos y a la vez conectada a internet, y es a través de este por
donde la compañía es capaz de actuar. Esto es doblemente beneficioso,
primero para el consumidor, que consume energía en un momento en el
que esta está más barata, y segundo para la compañía que gracias a esto
DESARROLLO DE UN SISTEMA DOMÓTICO BASADO EN 6LOWPAN
Futuros Desarrollos.
puede conseguir tener una demanda de energía más plana que siempre es
muy beneficioso para ella.
DESARROLLO DE UN SISTEMA DOMÓTICO BASADO EN 6LOWPAN
89
Bibliografía
BIBLIOGRAFÍA
[1]
Domótica – Wikipedia, la enciclopedia libre.
http://es.wikipedia.org/wiki/Domótica. [Online; último acceso 18 de Julio de
2012].
[2]
ZigBee – Wikipedia, la enciclopedia libre. http://es.wikipedia.org/wiki/ZigBee.
[Online; último acceso 18 de Julio de 2012].
[3]
Osiris RF Domótica Sistema RF domótico, alta sensoriazación domótica sin
cables. http://www.domodesk.com/content.aspx?co=44&t=146&c=43. [Online;
último acceso 18 de Julio de 2012].
[4]
KNX Association [Official Website]. http://www.knx.org/es/. [Online; último
acceso 18 de Julio de 2012].
[5]
http://www.redwirellc.com/store/node/1
[6]
http://www.danfoss.com
[7]
Shelby, Zach; Bormann, Carsten. 6LoWPAN, The wireless embedded internet.
[8]
Dunkels, A; Grönvall, Björn; Voigt, Thiemo. Contiki- a Lightweight and
Flexible operating System for Tiny Networked Sensors. Swedish Institute of
Computer Science.
[9]
Freescale. 1322x Sensor Node, Reference Manual. Document number:
1322xSNRM; Rev.1.5; 11/2010
[10]
Freescale.MC1322xRM. Document number: 1322xRM; Rev.1.6; 01/2012.
DESARROLLO DE UN SISTEMA DOMÓTICO BASADO EN 6LOWPAN
91
Parte II ESTUDIO ECONÓMICO
DESARROLLO DE UN SISTEMA DOMÓTICO BASADO EN 6LOWPAN
Estudio económico
Capítulo 1 ESTUDIO ECONÓMICO
Este capítulo tiene como propósito estudiar la viabilidad del
proyecto “Desarrollo de un sistema domótico basado en 6LoWPAN” y hacer de
este modo un análisis de la realización de este proyecto.
1 Viabilidad del proyecto.
Dentro del mundo de la vivienda en los últimos años está cobrando
cada vez más importancia el campo de la domótica. Cada vez se hace más
indispensable el uso de este tipo de tecnología de control de la vivienda
para tener una vida más fácil y cómoda. De aquí que se haya visto la
necesidad de sistemas de domóticos inalámbricos que tengan un bajo
coste de licencias.
La importancia de este proyecto radica en este punto, el poder
proporcionar un estudio satisfactorio sobre técnicas para la domótica que
sean capaces de generar una red inalámbrica en la vivienda con un bajo
coste.
Debido a que este proyecto se ha realizado con un fin de estudio y
no meramente comercial, hacer un estudio económico resultaría poco
apropiado.
Debido a esto hay que tener en cuenta que el coste calculado en el
Documento 3 tiene que ver únicamente con el desarrollo del propio estudio
y no con la fabricación propia de sistemas domóticos que utilicen esta
tecnología y que sin duda debido a economías de escala y al uso de
caminos directos hacia el éxito tendrán un coste unitario mucho más
reducido del expuesto en el documento citado.
DESARROLLO DE UN SISTEMA DOMÓTICO BASADO EN 6LOWPAN
95
Parte III CÓDIGO FUENTE
DESARROLLO DE UN SISTEMA DOMÓTICO BASADO EN 6LOWPAN
Código Fuente
Capítulo 1 CÓDIGO FUENTE
En este capítulo se exponen los códigos fuentes más significativos
utilizados dentro del proyecto y a los que se hace referencia en la
consecución de la memoria.
1 Entradas/salidas en MC13226V
1.1 gpio.c
#include <mc1322x.h>
#include <stdint.h>
inline void gpio_pad_dir(volatile uint64_t data)
{
*GPIO_PAD_DIR0 = (data & 0xffffffff);
*GPIO_PAD_DIR1 = (data >> 32);
}
inline void gpio_data(volatile uint64_t data)
{
*GPIO_DATA0 = (data & 0xffffffff);
*GPIO_DATA1 = (data >> 32);
}
inline uint64_t gpio_data_get(volatile uint64_t bits) {
uint64_t rdata = 0;
rdata = *GPIO_DATA0 & (bits & 0xffffffff);
rdata |= (*GPIO_DATA1 & (bits >> 32)) << 32;
return rdata;
}
inline void gpio_pad_pu_en(volatile uint64_t data)
{
*GPIO_PAD_PU_EN0 = (data & 0xffffffff);
*GPIO_PAD_PU_EN1 = (data >> 32);
}
inline void gpio_data_sel(volatile uint64_t data)
{
*GPIO_DATA_SEL0 = (data & 0xffffffff);
*GPIO_DATA_SEL1 = (data >> 32);
}
inline void gpio_pad_pu_sel(volatile uint64_t data)
{
*GPIO_PAD_PU_SEL0 = (data & 0xffffffff);
*GPIO_PAD_PU_SEL1 = (data >> 32);
}
inline void gpio_data_set(volatile uint64_t data)
DESARROLLO DE UN SISTEMA DOMÓTICO BASADO EN 6LOWPAN
99
100
Código Fuente
{
*GPIO_DATA_SET0 = (data & 0xffffffff);
*GPIO_DATA_SET1 = (data >> 32);
}
inline void gpio_data_reset(volatile uint64_t data)
{
*GPIO_DATA_RESET0 = (data & 0xffffffff);
*GPIO_DATA_RESET1 = (data >> 32);
}
inline void gpio_pad_dir_set(volatile uint64_t data)
{
*GPIO_PAD_DIR_SET0 = (data & 0xffffffff);
*GPIO_PAD_DIR_SET1 = (data >> 32);
}
inline void gpio_pad_dir_reset(volatile uint64_t data)
{
*GPIO_PAD_DIR_RESET0 = (data & 0xffffffff);
*GPIO_PAD_DIR_RESET1 = (data >> 32);
}
1.2 conpulsadores.c
#include
#include
#include
#include
#include
<mc1322x.h>
<board.h>
"stdio.h"
"tests.h"
"config.h"
void uart1_puts(char *ps);
void main(void) {
int a = 0;
//int i=0;
//int j;
volatile uint32_t t;
//char buffer[32];
print_welcome("ejecutando conpulsadores.c\n");
uart1_init(INC,MOD,SAMP);
*GPIO_FUNC_SEL1 = 0; /*Eliges el pulsador con función GPIO*/
*GPIO_PAD_DIR0 |= (7 << 23); /*Pones el LED como salida*/
*GPIO_PAD_DIR_RESET0 = (1 << 26);/*Pones el pulsador como
entrada*/
*GPIO_PAD_PU_SEL0 |= (1 << 26);/*Activas la resistencia de pullup, es decir que cuando pulses te va a poner un 0*/
*GPIO_DATA_SEL0 &= ~(1 << 26); /*Seleccionas que vas a leer desde
el Data register un no desde el pad*/
while(1) {
*GPIO_DATA0 |=(1 << 23); /*Enciendes el LED1*/
DESARROLLO DE UN SISTEMA DOMÓTICO BASADO EN 6LOWPAN
Código Fuente
/*for(i=0;i<=31;i++){
j=((*GPIO_DATA0>>i)&1);
if(j == 1){
buffer[i] = '1';
}
else{
buffer[i] = '0';
}
}
uart1_puts(buffer);
uart1_puts("\n");*/
t = *GPIO_DATA0; /*Lees las entradas */
a = ((t >> 26) & 1);
if(a == 1){
*GPIO_DATA0|=(1 << 24);/*Enciendes el LED2*/
}else{
*GPIO_DATA0&=~(1 << 24);/*Apagas el LED2*/
}
};
}
void uart1_puts(char *ps){
while (*ps != '\0'){
uart1_putc(*ps);
ps++;
}
}
2 Comunicación básica en MC13226V
2.1 enviapaquetes.c
#include
#include
#include
#include
#include
#include
<mc1322x.h>
<board.h>
"stdio.h"
"tests.h"
"config.h"
"crm.h"
void uart1_puts(char *ps);
void fill_packet(volatile packet_t *p);
DESARROLLO DE UN SISTEMA DOMÓTICO BASADO EN 6LOWPAN
101
102
Código Fuente
int main(void){
volatile packet_t *p_mi_paquete;
int a = 0;
int i=0;
volatile uint32_t t;
char buffer[32];
uart1_init(INC,MOD,SAMP);
*GPIO_FUNC_SEL1 = 0; /*Eliges el pulsador con función GPIO*/
*GPIO_PAD_DIR0 |= (7 << 23); /*Pones el LED como salida*/
*GPIO_PAD_DIR_RESET0 = (1 << 26);/*Pones el pulsador como
entrada*/
*GPIO_PAD_PU_SEL0 |= (1 << 26);/*Activas la resistencia de pullup, es decir que cuando pulses te va a poner un 0*/
*GPIO_DATA_SEL0 &= ~(1 << 26); /*Seleccionas que vas a leer desde
el Data register un no desde el pad*/
*GPIO_DATA0 &= ~(7 << 23);
*GPIO_FUNC_SEL0 |= (0x55<<8);/*pones los pines de SPI en funcion
1*/
printf("input/output initialized\n");
printf("trim_xtal");
trim_xtal();
printf("->done\n");
printf("vreg_init");
vreg_init();
printf("->done\n");
printf("maca_init");
maca_init();
printf("->done\n");
for(i=0;i<=31;i++){
buffer[i]='1';
}
uart1_puts(buffer);
uart1_puts("\n");
set_channel(0); /* 802.15.4 channel 11 */
set_power(0x12); /* 0x12 es la más alta, 4.5dBm */
while(1) {
*GPIO_DATA0 |=(1 << 23); /*Enciendes el LED1*/
t = *GPIO_DATA0; /*Lees las entradas */
DESARROLLO DE UN SISTEMA DOMÓTICO BASADO EN 6LOWPAN
Código Fuente
103
a = ((t >> 26) & 1);
if(a == 0){
p_mi_paquete = get_free_packet();
if(p_mi_paquete) {
fill_packet(p_mi_paquete);
tx_packet(p_mi_paquete);
printf("Enviando\n");
} else {
printf("can't get free packet\n");
}
}
}
}
void fill_packet(volatile packet_t *p){
(p->data)[0] = '1';
//sprintf(p->data, "Hola:\n");
// p->length = strlen(p->data);
(*p).length = 1;
(*p).offset = 0;
}
void uart1_puts(char *ps){
while (*ps != '\0'){
uart1_putc(*ps);
ps++;
}
}
2.2 recibepaquetes.c
#include
#include
#include
#include
#include
<mc1322x.h>
<board.h>
"stdio.h"
"tests.h"
"config.h"
int main(void){
volatile packet_t *p_mi_paquete;
//(*mi_paquete).data = 1;
//mi_paquete->data;
uart1_init(INC,MOD,SAMP);
DESARROLLO DE UN SISTEMA DOMÓTICO BASADO EN 6LOWPAN
104
Código Fuente
*GPIO_FUNC_SEL1 = 0; /*Eliges el pulsador con función GPIO*/
*GPIO_PAD_DIR0 |= (7 << 23); /*Pones el LED como salida*/
*GPIO_PAD_DIR_RESET0 = (1 << 26);/*Pones el pulsador como
entrada*/
*GPIO_PAD_PU_SEL0 |= (1 << 26);/*Activas la resistencia de pullup, es decir que cuando pulses te va a poner un 0*/
*GPIO_DATA_SEL0 &= ~(1 << 26); /*Seleccionas que vas a leer desde
el Data register un no desde el pad*/
*GPIO_DATA0 &= ~(7 << 23);
printf("input/output initialized\n");
printf("trim_xtal");
trim_xtal();
printf("->done\n");
printf("vreg_init");
vreg_init();
printf("->done\n");
printf("maca_init");
maca_init();
printf("->done\n");
set_channel(0); /* 802.15.4 channel 11 */
set_power(0x12); /* 0x12 es la más alta, 4.5dBm */
while(1) {
*GPIO_DATA0 |=(1 << 23); /*Enciendes el LED1*/
if((p_mi_paquete = rx_packet())) {
/* print and free the
packet */
if( (p_mi_paquete->data)[p_mi_paquete->offset]=='1'){
*GPIO_DATA0 |=(1 << 24); /*Enciendes el LED1*/
}
free_packet(p_mi_paquete);
}
}
}
3 Entradas/Salidas con Contiki y MC13224V
3.1 entradasalida1.c
#include
#include
#include
#include
"contiki.h"
"dev/leds.h"
"dev/button-sensor.h"
<stdio.h> /* para el printf() */
DESARROLLO DE UN SISTEMA DOMÓTICO BASADO EN 6LOWPAN
Código Fuente
105
//----------------------------------------------------------------PROCESS(blink_process, "ejemplo blink");
AUTOSTART_PROCESSES(&blink_process);
//----------------------------------------------------------------PROCESS_THREAD(blink_process, ev, data)
{
PROCESS_EXITHANDLER(goto exit);
PROCESS_BEGIN();
SENSORS_ACTIVATE(button_sensor);
leds_on(LED_BLUE);
printf("+ El LED está encendido +\n\n");
printf(" Pulsa el botón para empezar \n\n");
while(1) {
static uint8_t push = 0;
se ha pulsado
// Para ir contabilizando las veces que
PROCESS_WAIT_EVENT_UNTIL((ev==sensors_event)
&button_sensor));
&&
(data
if (push % 2 == 0) {
leds_toggle(LED_BLUE);
printf("[%d] APAGANDO EL LED ... [DONE]\n", push);
push++;
} else {
leds_toggle(LED_BLUE);
printf("[%d] ENCENDIENDO EL LED ...
[DONE]\n", push);
push++;
}
if (push == 255){ push = 0;} // previene el overflowing
}
exit:
leds_off(LEDS_ALL);
PROCESS_END();
}
4 Red domótica
4.1 redom.c
#include
#include
#include
#include
"contiki.h"
"lib/random.h"
"net/uip.h"
"net/uip-ds6.h"
#include "simple-udp.h"
DESARROLLO DE UN SISTEMA DOMÓTICO BASADO EN 6LOWPAN
==
106
Código Fuente
#include "dev/leds.h"
#include "dev/button-sensor.h"
#include <stdio.h>
#include <string.h>
#define UDP_PORT 1234
static struct simple_udp_connection broadcast_connection;
/*---------------------------------------------------------------------*/
PROCESS(red_domotica_process, "Red domotica process");
AUTOSTART_PROCESSES(&red_domotica_process);
/*---------------------------------------------------------------------*/
static void
receiver(struct simple_udp_connection *c,
const uip_ipaddr_t *sender_addr,
uint16_t sender_port,
const uip_ipaddr_t *receiver_addr,
uint16_t receiver_port,
const uint8_t *data,
uint16_t datalen)
{
static uint8_t push = 0;
printf("Datos recividos en el puerto %d de 2 desde el puerto %d de 1 con
una longitud %d\n",
receiver_port, sender_port, datalen);
leds_toggle(LED_BLUE);
}
/*---------------------------------------------------------------------*/
PROCESS_THREAD(red_domotica_process, ev, data)
{
uip_ipaddr_t addr;
PROCESS_BEGIN();
SENSORS_ACTIVATE(button_sensor);
simple_udp_register(&broadcast_connection, UDP_PORT,
NULL, UDP_PORT,
receiver);
while(1) {
PROCESS_WAIT_EVENT_UNTIL(
(ev==sensors_event)
&&
(data
&button_sensor));
printf("Enviando paquete ...\n");
uip_create_linklocal_allnodes_mcast(&addr);
simple_udp_sendto(&broadcast_connection, "Test", 4, &addr);
DESARROLLO DE UN SISTEMA DOMÓTICO BASADO EN 6LOWPAN
==
Código Fuente
}
PROCESS_END();
}
/*---------------------------------------------------------------------*/
DESARROLLO DE UN SISTEMA DOMÓTICO BASADO EN 6LOWPAN
107
Parte IV DATASHEETS
DESARROLLO DE UN SISTEMA DOMÓTICO BASADO EN 6LOWPAN
Esquemas de Freescale Sensor Reference Board
Capítulo 1 ESQUEMAS DE FREESCALE SENSOR
REFERENCE BOARD
En este apartado se expondrán los principales esquemas necesarios
para la correcta comprensión del desarrollo de la memoria del proyecto en
lo que se refiere a la tarjeta de desarrollo Freescale Sensor Reference
Board.
Figura 1.1. Componentes del PCB (vista superior)
DESARROLLO DE UN SISTEMA DOMÓTICO BASADO EN 6LOWPAN
111
112
Datasheets
Figura 1.2. Esquema de Freescale Sensor Reference Board
DESARROLLO DE UN SISTEMA DOMÓTICO BASADO EN 6LOWPAN
Esquemas de Redbee Econotag
Capítulo 2 ESQUEMAS DE REDBEE ECONOTAG
En este apartado se expondrán los principales esquemas necesarios
para la correcta comprensión del desarrollo de la memoria del proyecto en
lo que se refiere a la tarjeta de desarrollo Redbee Econotag.
DESARROLLO DE UN SISTEMA DOMÓTICO BASADO EN 6LOWPAN
113
114
Datasheets
Figura 2.1. Esquema 1 Redwire Econotag
DESARROLLO DE UN SISTEMA DOMÓTICO BASADO EN 6LOWPAN
Esquemas de Redbee Econotag
Figura 2.2.Esquema 2 Redwire Econotag.
DESARROLLO DE UN SISTEMA DOMÓTICO BASADO EN 6LOWPAN
115
116
DESARROLLO DE UN SISTEMA DOMÓTICO BASADO EN 6LOWPAN
Datasheets
117
Madrid, 3 de Septiembre de 2012
Firmado:
DESARROLLO DE UN SISTEMA DOMÓTICO BASADO EN 6LOWPAN
Documento II
Pliego de condiciones
DESARROLLO DE UN SISTEMA DOMÓTICO BASADO EN 6LOWPAN
2
DESARROLLO DE UN SISTEMA DOMÓTICO BASADO EN 6LOWPAN
III
ÍNDICE
Parte I
Capítulo 1
Condiciones generales y económicas ............................................. 5
Condiciones generales .................................................................. 7
1
Compromiso administrador y cliente............................................................. 7
2
Reclamaciones..................................................................................................... 7
3
Compromiso del suministrador ...................................................................... 7
4
Características diferenciadoras ........................................................................ 7
5
Plazo de entrega.................................................................................................. 8
6
Garantía................................................................................................................ 8
Capítulo 2
Condiciones económicas .............................................................. 9
1
Precios .................................................................................................................. 9
2
Pago ....................................................................................................................... 9
3
Gastos de embalaje y transporte ..................................................................... 9
4
Garantía................................................................................................................ 9
5
Costes de suministros ...................................................................................... 10
Parte II
Capítulo 1
Condiciones técnicas y particulares ............................................ 11
Condiciones técnicas .................................................................. 13
1
Equipo informático. ......................................................................................... 13
2
Placas de circuito impreso. ............................................................................. 13
3
Sistema de radiofrecuencia. ........................................................................... 14
4
Normas de calidad. .......................................................................................... 15
5
Normas de seguridad e higiene. .................................................................... 15
6
Vida útil del producto. .................................................................................... 15
7
Otros criterios del diseño................................................................................ 15
DESARROLLO DE UN SISTEMA DOMÓTICO BASADO EN 6LOWPAN
Parte I CONDICIONES GENERALES Y
ECONÓMICAS
DESARROLLO DE UN SISTEMA DOMÓTICO BASADO EN 6LOWPAN
Condiciones generales
7
Capítulo 1 CONDICIONES GENERALES
Las condiciones y cláusulas que se establecen en este documento son
de obligado cumplimiento por las partes contratantes.
1 Compromiso administrador y cliente
Tanto el administrador como el cliente se comprometen desde la
fecha de la firma del contrato a llevar a cabo lo que se estipule.
2 Reclamaciones
Ante cualquier reclamación o discrepancia en lo concerniente al
cumplimiento de lo pactado por cualquiera de las partes, una vez agotada
toda vía de entendimiento, se tramitará el asunto por la vía de lo legal. El
dictamen o sentencia que se dicte será de obligado cumplimiento para las
dos partes.
3 Compromiso del suministrador
Al firmarse el contrato, el suministrador se compromete a facilitar
toda la información necesaria para la instalación y buen funcionamiento
del sistema, siempre que sea requerido para ello.
4 Características diferenciadoras
Asimismo,
el
cliente
entregará
al
suministrador
todas
las
características distintivas del equipo comprado y aquellas que considere
oportunas para el necesario conocimiento de la misma a efectos del diseño
del presente equipo.
DESARROLLO DE UN SISTEMA DOMÓTICO BASADO EN 6LOWPAN
8
Condiciones generales y económicas
5 Plazo de entrega
El plazo de entrega será de tres meses, a partir de la fecha de la firma
del contrato, pudiendo ampliarse en un mes. Cualquier modificación de
los plazos deberá contar con el acuerdo de las dos partes.
En caso de retrasos imputables al suministrador, se considerará una
indemnización del 1 % del valor estipulado por semana de retraso.
6 Garantía
Existirá un plazo de garantía de un año a partir de la entrega del
sistema. Dicha garantía quedará sin efecto si se demostrase que el sistema
ha estado sometido a manipulación o uso indebido.
Cumplido dicho plazo de garantía, el suministrador queda obligado
a la reparación del sistema durante un plazo de cinco años, fuera del cual
quedará a su propio criterio atender la petición del cliente.
En ningún momento tendrá el suministrador obligación alguna
frente a desperfectos o averías por uso indebido por personas no
autorizadas por el suministrador.
DESARROLLO DE UN SISTEMA DOMÓTICO BASADO EN 6LOWPAN
Condiciones económicas
Capítulo 2 CONDICIONES ECONÓMICAS
1 Precios
Los precios indicados en este proyecto son firmes y sin revisión por
ningún concepto, siempre y cuando se acepten dentro del periodo de
validez del presupuesto que se fija hasta Diciembre de 2012.
2 Pago
El pago se realizará como sigue:
75% a la firma del contrato.
25% en el momento de entrega.
La forma de pago será al contado mediante cheque nominativo o
mediante transferencia bancaria. En ningún caso se aceptarán letras de
cambio.
3 Gastos de embalaje y transporte
El suministrador se hará cargo de los gastos de embalaje y del
transporte, dentro de la ciudad donde se encuentre la instalación. En caso
de ser necesario transporte interurbano, el gasto correrá por cuenta del
cliente. En todo caso, el responsable de los posibles desperfectos
ocasionados por el transporte será el suministrador.
4 Garantía
Durante el plazo de garantía, la totalidad de los gastos originados
por las reparaciones correrán por cuenta del suministrador.
DESARROLLO DE UN SISTEMA DOMÓTICO BASADO EN 6LOWPAN
9
10
Condiciones generales y económicas
5 Costes de suministros
Fuera de dicho plazo y durante los siguientes cinco años, los costes
serán fijados mediante acuerdo por ambas partes. Pasados 5 años, éstos los
fijará exclusivamente el suministrador.
DESARROLLO DE UN SISTEMA DOMÓTICO BASADO EN 6LOWPAN
Parte II CONDICIONES TÉCNICAS Y
PARTICULARES
DESARROLLO DE UN SISTEMA DOMÓTICO BASADO EN 6LOWPAN
Condiciones técnicas
13
Capítulo 1 CONDICIONES TÉCNICAS
1 Equipo informático.

El dispositivo debe estar homologado conforme a la normativa
Europea y Española a fecha de Septiembre de 2012.

El dispositivo debe instalarse conforme a las indicaciones del
fabricante,
manteniendo
las
condiciones
de
humedad
y
temperatura entre los límites marcados.

Los programas informáticos empleados han de contar con la
licencia preceptiva y cumplir con las condiciones de la misma. En
caso de usar programas de licencia GNU, se deberán respetar las
condiciones de la misma.
2 Placas de circuito impreso.
2.1 Soporte
El tipo de soporte aislante utilizado en las placas de circuito impreso
será de fibra de vidrio, con las características siguientes (recomendadas):

Resistencia superficial en M
105

Resistencia volumétrica en M
107

Constante dieléctrica (a f=1 MHz)
0,25

Temperatura máxima de trabajo
125ºC

Temperatura máxima de soldadura (máx. 20 seg.)
260ºC
DESARROLLO DE UN SISTEMA DOMÓTICO BASADO EN 6LOWPAN
14
Condiciones técnicas y particulares
El espesor de las placas será de 1,6 mm (valor normalizado). Las
placas serán de una o dos caras, fabricadas por el método sustractivo
basado en máscaras. Deberán acompañarse de un esquema que contenga
los taladros a realizar, así como la colocación exacta de los componentes.
2.2 Diseño de las pistas
El diseño se realizará teniendo en cuenta las recomendaciones para
equipos de alta frecuencia y de telecomunicaciones que dicta la normativa
Europea en cuanto a:

Compatibilidad electromagnética (89/36/EEC).

Niveles de tensión (73/23/EEC).
Asimismo, se realizarán las pistas con el siguiente grosor
recomendado (suponiendo un espesor típico):
Grosor(pulgadas)
Corriente Máxima
0.010"
0.3 A
0.015"
0.4 A
0.020"
0.7 A
0.025"
1A
0.05"
2A
0.1"
4A
0.15"
6A
3 Sistema de radiofrecuencia.
El sistema de radio frecuencia cumplirá con los requisitos
establecidos en la normativa Europea (R&TTE Directive 1999-5-EC).
El sistema de radiofrecuencia se atendrá a la normativa vigente de
protección del espacio radioeléctrico y protección de la salud: LEY
GENERAL DE TELECOMUNICACIONES 11/1998, DE 24 DE ABRIL DE
1998.
DESARROLLO DE UN SISTEMA DOMÓTICO BASADO EN 6LOWPAN
Condiciones técnicas
4 Normas de calidad.
Los sistemas se diseñarán de forma que cumplan las normas UNE,
CEI y EN aplicables a este tipo de productos, así como las normas ETSI
(European Telecommunications Standards Institute) para sistemas de
radiofrecuencia.
5 Normas de seguridad e higiene.
El proyecto cumplirá con la Ley 31/95 de Prevención de Riesgos
Laborales.
6 Vida útil del producto.
El proyecto cumplirá con la Ley 31/95 de Prevención de Riesgos
Laborales.
7 Otros criterios del diseño.
Se
emplearán componentes normalizados para los circuitos
electrónicos.
DESARROLLO DE UN SISTEMA DOMÓTICO BASADO EN 6LOWPAN
15
Documento III
Presupuesto
DESARROLLO DE UN SISTEMA DOMÓTICO BASADO EN 6LOWPAN
II
DESARROLLO DE UN SISTEMA DOMÓTICO BASADO EN 6LOWPAN
III
ÍNDICE
Parte I
Capítulo 1
1
Presupuestos parciales ..................................................................... 7
Sumas Parciales ............................................................................ 9
Hardware ............................................................................................................. 9
1.1 Placas de desarrollo ........................................................................................................ 9
1.2 Equipo .............................................................................................................................. 9
1.3 Total Hardware............................................................................................................. 10
2
Software ............................................................................................................. 10
3
Mano de obra .................................................................................................... 10
4
Costes indirectos .............................................................................................. 11
Parte II
Capítulo 1
1
Presupuesto total ............................................................................ 13
Total de gastos de desarrollo .................................................... 15
Coste total del proyecto ................................................................................... 15
DESARROLLO DE UN SISTEMA DOMÓTICO BASADO EN 6LOWPAN
IV
DESARROLLO DE UN SISTEMA DOMÓTICO BASADO EN 6LOWPAN
V
ÍNDICE DE TABLAS
Parte I
Capítulo 1
Presupuestos parciales ..................................................................... 7
Sumas Parciales ............................................................................ 9
Tabla 1.1: Coste de las placas de desarrollo. .......................................................... 9
Tabla 1.2: Coste de equipo ........................................................................................ 9
Tabla 1.3: Coste total del Hardware....................................................................... 10
Tabla 1.4: Coste del Software.................................................................................. 10
Tabla 1.5: Coste de la mano de obra ...................................................................... 10
Tabla 1.6: Costes indirectos ..................................................................................... 11
Parte II
Capítulo 1
Presupuesto total ............................................................................ 13
Total de gastos de desarrollo .................................................... 15
Tabla 1.1: Coste total del proyecto ......................................................................... 15
DESARROLLO DE UN SISTEMA DOMÓTICO BASADO EN 6LOWPAN
Parte I PRESUPUESTOS PARCIALES
DESARROLLO DE UN SISTEMA DOMÓTICO BASADO EN 6LOWPAN
Sumas Parciales
9
Capítulo 1 SUMAS PARCIALES
En este apartado se tendrán en cuenta todos los costes que implican el
desarrollo del proyecto. Se incluyen en dichos costes los de hardware, que
en el caso concreto de este proyecto simplemente incluyen el precio de
compra del dispositivo, los de software, como son las licencias de los
programas utilizados en el diseño, los de mano de obra, es decir las
personas que trabajan tanto en el diseño como en el desarrollo del
proyecto, y los costes indirectos.
1 Hardware
1.1 Placas de desarrollo
Concepto
Unidades
Precio Unitario
(€/und)
Coste Total
(€)
1322x-SRB(Sensor Reference
Board)
2
432,87
865,74
Redwire Econotag
2
44,08
88,16
Placa protoboard prof. mediana
1
15,75
15,75
Total
969,65
Tabla 1.1: Coste de las placas de desarrollo.
1.2 Equipo
Concepto
Ordenador
Unidades
1
Precio Unitario
Amortización
(€/und)
Coste Total
en el
proyecto (€)
5 años
170
850
Total
170
Tabla 1.2: Coste de equipo
DESARROLLO DE UN SISTEMA DOMÓTICO BASADO EN 6LOWPAN
10
Presupuestos parciales
1.3 Total Hardware
Concepto
Placas de desarrollo
Equipo
Unidades
Precio Unitario
(€/und)
1
1
969,65
170
Total
Coste
Total
(€)
969,65
170
1139,65
Tabla 1.3: Coste total del Hardware
2 Software
Concepto
Unidades
Precio
Unitario
(€/und)
Amortización
Coste Total
en el
proyecto (€)
VMWare Player
Instant Contiki
Mozilla
1
1
1
0
0
0
-
0
0
0
Microsoft Office®
1
199
5años
39,8
Total
39,8
Tabla 1.4: Coste del Software
3 Mano de obra
Concepto
Precio Unitario
(€/h)
Horas
Coste Total
(€)
Desarrollo de software
Pruebas
140
220
35
25
4900
5500
Documentación
100
30
3000
20
30
600
Trabajo de revisión y corrección
Total
14000
Tabla 1.5: Coste de la mano de obra
DESARROLLO DE UN SISTEMA DOMÓTICO BASADO EN 6LOWPAN
Sumas Parciales
11
4 Costes indirectos
Coste Total
(€)
Concepto
Gastos de luz y equipos
Gastos de comunicación
Gastos de transporte
Total
37
30
55
122
Tabla 1.6: Costes indirectos
DESARROLLO DE UN SISTEMA DOMÓTICO BASADO EN 6LOWPAN
Parte II PRESUPUESTO TOTAL
DESARROLLO DE UN SISTEMA DOMÓTICO BASADO EN 6LOWPAN
Total de gastos de desarrollo
15
Capítulo 1 TOTAL DE GASTOS DE DESARROLLO
1 Coste total del proyecto
A continuación se muestra el total de los costes del proyecto:
Concepto
Hardware
Software
Mano de obra
Costes Indirectos
Total
Coste Total (€)
1139,65
39,8
14000
122
15301,45
Tabla 1.1: Coste total del proyecto
Por tanto el presupuesto total para este proyecto asciende a QUINCEMIL
TRESCIENTOS UNO euros con CUARENTA Y CINCO céntimos.
DESARROLLO DE UN SISTEMA DOMÓTICO BASADO EN 6LOWPAN
16
DESARROLLO DE UN SISTEMA DOMÓTICO BASADO EN 6LOWPAN
Presupuesto total
17
Madrid, 3 de Septiembre de 2012
Firmado
DESARROLLO DE UN SISTEMA DOMÓTICO BASADO EN 6LOWPAN