Raspberry PiIoT Projects

T ECNOLOGÍA EN AC TI ON ™
Frambuesa
Pi Proyectos de la IO
Los experimentos de prototipos para Makers
-
John C. Shovic
Frambuesa Pi IO
proyectos
Los experimentos de prototipos para Makers
John C. Shovic, PhD

Frambuesa Pi Proyectos de la IO: creación de prototipos para las personas encargadas Experimentos
John C. Shovic
Liberty Lake, Washington, EE.UU. ISBN-13
(PBK): 978-1-4842-1378-0 ISBN-13 (electrónico): 978-1-4842-1377-3

DOI 10.1007 / 978-1-4842-1377-3
Biblioteca del Congreso de control el número: 2016949468 Copyright
© 2016 por John C. Shovic
Esta obra está sujeta a derechos de autor. Todos los derechos están reservados por el editor, si la totalidad o parte del material se refiere, en concreto los
derechos de traducción, reimpresión, la reutilización de las ilustraciones, la recitación, la radiodifusión, la reproducción en microfilm o en cualquier otra forma
física, y transmisión o almacenamiento de información y la recuperación, la adaptación electrónico, software informático, o por metodología similar o no conocido
actualmente o desarrollado en el futuro. Exentos de esta reserva legal son breves extractos en relación con los exámenes o análisis académico o materiales
suministrados específicamente con el fin de ser introducido y ejecutado en un sistema informático, para su uso exclusivo por parte del comprador de la obra. La
duplicación de esta publicación o partes de los mismos se permite solamente bajo las disposiciones de la Ley de Propiedad Intelectual sobre la ubicación del
Editor, en su versión actual, y el permiso para su uso siempre debe ser obtenido de Springer. Permisos de uso se pueden obtener a través de Rightslink en el
Centro de Copyright Clearance. Violaciónes deben ser procesados bajo la respectiva Ley de Propiedad Intelectual. nombres de marcas registradas, logotipos y
las imágenes pueden aparecer en este libro. En lugar de utilizar un símbolo de marca con cada ocurrencia de un nombre, logotipo o imagen de marca registrada
que utilizamos los nombres, logotipos e imágenes solamente de forma editorial y para el beneficio del propietario de la marca, sin intención de infracción de la
marca. y las imágenes pueden aparecer en este libro. En lugar de utilizar un símbolo de marca con cada ocurrencia de un nombre, logotipo o imagen de marca
registrada que utilizamos los nombres, logotipos e imágenes solamente de forma editorial y para el beneficio del propietario de la marca, sin intención de
infracción de la marca. y las imágenes pueden aparecer en este libro. En lugar de utilizar un símbolo de marca con cada ocurrencia de un nombre, logotipo o
imagen de marca registrada que utilizamos los nombres, logotipos e imágenes solamente de forma editorial y para el beneficio del propietario de la marca, sin
intención de infracción de la marca.
La utilización de esta publicación de nombres comerciales, marcas registradas, marcas de servicio y términos similares, aunque no se identifican
como tal, no debe ser tomado como una expresión de opinión en cuanto a si son o no están sujetos a derechos de propiedad.
Mientras que el asesoramiento y la información en este libro se cree que son verdadera y exacta a la fecha de publicación, ni los autores ni
los editores ni el editor puede aceptar ninguna responsabilidad legal por cualquier error u omisión que se pueden hacer. El editor no ofrece
ninguna garantía, expresa o implícita, con respecto al material contenido en el presente documento.
Gerente: Welmoed Spahr plomo Editor:

Jonathan Gennick Técnico Evaluador:
Gheorghe Editor Desarrollo Chesler: James
Markham
Consejo Editorial: Steve Anglin, Pramila Balen, Louise Corrigan, Jonathan Gennick,
Robert Hutchinson, Celestin Suresh John, James Markham, Susan McDermott, Matthew Moodie,
Gwenan Editor de Coordinación Spearing: Melissa Maldonado Copy Editor: Karen Jameson Compositor: SPI
Global paso a paso: SPI Global Artista: SPI Global
Distribuido a la industria del libro en todo el mundo por Springer Science + Business Media Nueva York, 233 Spring Street, 6th Floor, New
York, NY 10013. Teléfono 1-800-Springer, fax (201) 348 a 4.505, e-mail [email protected] , o visitar www.springer.com . Apress
Media, LLC es una LLC de California y el único miembro (propietario) es Springer Science + Business Media Finance Inc (SSBM Finance Inc).
SSBM Finance Inc es una Delaware sociedad. Para obtener información sobre traducciones, envíe un correo electrónico [email protected] , o
visitar www.apress.com .
Apress y amigos de los libros ED se pueden comprar en grandes cantidades para uso académico, corporativo o de promoción. versiones de libros
electrónicos y licencias también están disponibles para la mayoría de los títulos. Para obtener más información, hacer referencia a nuestra página web de
licencias a granel Ventas-libro electrónico en especial www.apress.com/bulk-sales .
Cualquier código fuente u otros materiales complementarios que se hace referencia por el autor en este texto están disponibles para los lectores en www.apress.com
. Para obtener información detallada acerca de cómo localizar el código fuente de su libro, vaya a www.apress.com/source-code/ .
Impreso en papel libre de ácido

Para mi mejor amiga Laurie y también a mi gato de pantera,
que es un dispositivo IOT por sí mismo.
Mapa de contenidos
Sobre el Autor ............................................... .............................. xv Sobre el revisor
técnico ............... ........................................ Agradecimientos xvii ........
.................................................. ................ xix Introducción ................................
.................................................. .. capítulos xxi de un vistazo
........................................... ......................... XXIII
■ Capítulo 1: Introducción a la IOT ............................................ ............ 1
■ Capítulo 2: Detectando Su IOT Medio Ambiente ...................................... 9
■ Capítulo 3: La construcción de una estación meteorológica accionada solar IOT ........... 63
■ Capítulo 4: El cambio de su entorno con IOT y iBeacons ... 113
■ Capítulo 5: Conexión de un dispositivo IOT a una nube

Servidor - IOTPulse ............................................... ......................... 147
■ Capítulo 6: El uso de IOT para la RFID y MQTT y el Raspberry Pi ...... 187
■ Capítulo 7: Seguridad de ordenador y la IOT ................................. 213
■ Apéndice: Sugerencias para otras actividades ................................... 229
Índice ................................................. ............................................. 231
v
Contenido
Sobre el Autor ............................................... .............................. xv Sobre el revisor
técnico ............... ........................................ Agradecimientos xvii ........
.................................................. ................ xix Introducción ................................
.................................................. .. capítulos xxi de un vistazo
........................................... ......................... XXIII
■ Capítulo 1: Introducción a la IOT ............................................ ............ 1
Elegir un modelo de Frambuesa Pi ............................................. ................. 2
La elección de un dispositivo IOT .............................................. ............................. 3
La caracterización de un proyecto IOT .............................................. .................... 3
Comunicaciones ................................................. .................................................. 4 ....
Procesador Power ................................................ .................................................. ..... 4
Almacenamiento local ................................................ .................................................. .......... 4
El consumo de energía ................................................ ................................................. 5
Funcionalidad ................................................. .................................................. .......... 5
Costo................................................. .................................................. ........................ 5
Las herramientas adecuadas para hacer frente a hardware ........................................... ........ 5
Escribir código en Python y el IDE Arduino .......................................... . 7
En este libro ............................................... .............................................. 8
vii
■ CONTENIDO
■ Capítulo 2: Detectando Su IOT Medio Ambiente ...................................... 9
Redes de sensores IOT ............................................... ...................................... 10
IOT caracterización de este Proyecto ............................................. ......... 10
¿Cómo funciona este dispositivo se conectan a la IOT? ........................................ ... 11
¿Qué es un ESP8266? .................................................. ............................................ 11
El diseño LightSwarm ............................................... .......................................... 12
La construcción de su primer IOT Swarm ............................................. .................. dieciséis
Instalación del soporte de Arduino en el PC o Mac .......................................... ................ dieciséis
Su Primer bosquejo para la ESP8266 ............................................ .............................. dieciséis
El hardware ................................................ .................................................. ....... 17
El software ................................................ .................................................. ........ 25
Auto-organización de Comportamiento .............................................. ........................ 43
Monitoreo y probar el sistema con la Frambuesa Pi (del tipo inteligente en el Bloque)

................................. ............................... 44
LightSwarm software de registro escrito en Python ............................................ ....... 44
El panel de control RasPiConnect en Tiempo real ....................................... 54
Resultados ................................................. ................................................. 58
¿Qué más se puede hacer con esta arquitectura? ...................................... 61
Conclusión ................................................. ............................................ 61
■ Capítulo 3: La construcción de una estación meteorológica accionada solar IOT ........... 63
IOT caracterización de este Proyecto ............................................. ......... sesenta y cinco
¿Cómo funciona este dispositivo se conectan a la IOT? ........................................ ... sesenta y cinco
Recolección de datos ................................................ ...................................... sesenta y cinco
El proyecto - IOTWeatherPi .............................................. ..................... 66
Cómo funciona todo esto .............................................. .................................................. . 68
Los subsistemas ................................................ .................................................. ... 68
El bus I2C ............................................... .................................................. ............ 71
viii
■ CONTENIDO
El tamaño de su sistema de energía solar ............................................. .............. 76
Encendido y Apagado ............................................. ...................... 78
El problema de baja de voltaje ............................................... ............................................ 80
Apagado del Pi .............................................. .................................................. 80 ..
A partir del Pi ............................................... ........................................ 81
La cuestión ................................................ .................................................. .............. 81
Su accionar Pi arriba y abajo con el USB Power Control ...................................... 82
El USB Consejo Regulador de la energía ............................................. ............................... 83
Uno Más Escenario ............................................... .................................................. 84
¿Qué necesita para construir este proyecto? .............................................. 86
Conectar y probar el hardware ............................................. ..... 88
La lista completa de cableado .............................................. .................................. 90
El software ................................................ ......................................... 95
Requisitos que no son normales para su Pi ........................................... ........................ 95
El software IOTWeatherPi Python .............................................. .......................... 95
El panel de control RasPiConnect .............................................. .............................. 97
Las mejoras ................................................. .................................................. ...... 98
El piar sus datos meteorológicos .............................................. ................... 98
Empezando ................................................ .................................................. ..... 98
Registro de una aplicación de Twitter .............................................. .......................................... 99
Los mensajes de texto de sus datos meteorológicos .............................................. ..................... 102
Al remitir sus datos a la World - CWOP .......................................... . 105
CWOP ................................................. .................................................. ................. 105
CWOP software de interfaz a IOTWeatherPi ............................................. .............. 105
CWOP Software ................................................ .................................................. ... 105
Ejemplo CWOP de paquetes ............................................... .......................................... 108
Resultados ................................................. .................................................. ............... 108
Conclusión ................................................. .......................................... 110
ix
■ CONTENIDO
■ Capítulo 4: El cambio de su entorno con IOT y iBeacons ...... 113
El IOTBeaconAir ................................................ ................................ 113
IOT caracterización de este Proyecto ............................................. ......................... 114
¿Cómo funciona este dispositivo se conectan a la IOT? .................................................. ........ 115
Lista de hardware ................................................ .................................................. ..... 115
iBeacons ................................................. ............................................. 116
Bluetooth IBeacon escáner ............................................... ................................... 118
Sistema de Iluminación Hue Phillips .............................................. .................................. 119
Phillips Hue Hub ............................................... .................................................. 120 ..
BeaconAir hardware, software, y con fi guración ............................. 121
BeaconAir de descripción de hardware ............................................... ........................... 121
BeaconAir Descripción del software ............................................... ............................ 121
BeaconAir Con fi guración del archivo .............................................. .................................. 133
IBeacon Software ................................................ ................................................. 134
Trilateralización ................................................. .................................................. 134 ..
El panel de control IOTBeaconAir .............................................. ............................. 135
Instalación y Bluez Phue en la Frambuesa Pi .................................... 138
BlueZ ................................................. .................................................. .................. 139
Phue ................................................. .................................................. ................... 141
RasPiConnectServer inicio ................................................ ............... 141
Procedimiento de inicio ................................................ ................................................ 141
Haciendo IOTBeaconAir de inicio en el arranque ............................................. .................... 142
¿Cómo funciona en la práctica ............................................. .......................................... 143
Cosas para hacer ............................................... ......................................... 143
El clásico de problemas del sistema distribuido ........................................... 144
Conclusión ................................................. .......................................... 145
X
■ CONTENIDO
■ Capítulo 5: Conexión de un dispositivo IOT a una nube

Servidor - IOTPulse ............................................... ......................... 147
IOT caracterización de este Proyecto ............................................. ....... 148
La Internet de las cosas en la Red Global .................................... 148
Computación en la nube ................................................ .................................................. 149
Creadores de aplicaciones ................................................ .............................................. 150
Visualización y generación de informes .............................................. ............................... 150
El IBM bluemix Internet de las cosas Solución ........................................... ............ 151
El diseño IOTPulse ............................................... ............................. 152
La construcción de la IOTPulse ............................................... ............................................. 155
Impresión de archivos 3D para el caso del IOT ........................................... .............................. 157
Software necesario ................................................ .................................................. 160
El Código IOTPulse ............................................... ................................................. 160
La revisión de los resultados del Monitor de serie Arduino IDE ........................................... .... 170
Bluemix unirse a IBM y la Fundación IO ...................................... 173
El envío de sus datos a bluemix ............................................. ................................. 175
Viendo datos en tiempo real en la plataforma IBM IOT bluemix ............................... 179
Temas avanzados ................................................ .................................. 184
Información histórica ................................................ .................................................. .... 184
Aplicaciones ganglios ROJO .............................................. ........................................... 185
Aplicaciones Watson ................................................ ............................................. 186
Conclusión ................................................. .......................................... 186
■ Capítulo 6: El uso de IOT para la RFID y MQTT y el Raspberry Pi ........ 187
IOT caracterización de este Proyecto ............................................. ....... 187
¿Qué es la tecnología RFID? .................................................. ................. 188
¿Qué es MQTT? .................................................. .................................. 189
Hardware utilizado para IOTRFID .............................................. ................... 190
La construcción de un servidor en un MQTT Frambuesa Pi ....................................... 191
xi
■ CONTENIDO
El software en el Raspberry Pi ............................................ ........... 192
Instalación del MQTT “mosquitto” ............................................ ............................... 192
Con fi gurar e inicio del servidor mosquitto ........................................... ......... 193
Inicio del servidor mosquitto .............................................. ................................ 194
Prueba de la mosquitto servidor .............................................. .................................. 194
La construcción de la IOTRFID ............................................... ............................. 195
Las piezas necesarias ............................................... .................................................. 195
Instalación del soporte de Arduino en el PC o Mac .......................................... .............. 196
El hardware ................................................ .................................................. ..... 196
¿Qué es este sensor estamos usando? .................................................. .................... 196
Impreso caso 3D ............................................... .................................................. ... 197
La lista completa de cableado .............................................. ................................................. 199
El software para el Proyecto IOTRFID ............................................ ...... 201
Las bibliotecas ................................................ .................................................. ....... 201
El software principal ............................................... ................................................ 202
Comprobación del sistema de IOTRFID .............................................. .................................... 205
Configuración de la ventana de depuración mosquitto ............................................ ................. 206
Configurar un suscriptor de la Frambuesa Pi .......................................... ................... 207
Comprobación del sistema de IOTRFID Todo el ............................................. .......................... 208
Lo que hay que hacer con los datos de RFID en el servidor ..................................... 210
Conclusión ................................................. .......................................... 210
■ Capítulo 7: Seguridad de ordenador y la IOT ................................. 213
IOT: Top Cinco cosas que debe saber sobre IOT Computer Security ................ 214
Número 1: Se trata de importante. Puede probar su aplicación es inseguro, pero no se puede probar su
aplicación es seguro. .................................................. ............... 214 Número 2: la seguridad por oscuridad no
es la seguridad ........................................ . 214
Número 3: Siempre conectado? Siempre vulnerable. .............................................. 214
xii
■ CONTENIDO
Número 4: Enfoque en lo que se Importante a la seguridad de su aplicación IOT ...... 215
Número 5: Seguridad informática se basa en tres aspectos principales: Con fi dencialidad, integridad y disponibilidad
................................ .................................................. ..... 215
Cuáles son los peligros? .................................................. ...................... 216
Asignación de valor a la información .............................................. .............. 216
La construcción de tres componentes de seguridad básica para IOT Computadoras .... 217
Confidencialidad - Criptografía .............................................. ................................ 217
Integridad - Autenticación ............................................... ....................................... 222
Disponibilidad - Manejo de DOS / Pérdida de servidor / Los perros guardianes .................................... 225
Gestión de claves ................................................ ................................ 226
La administración de actualizaciones ................................................ ........................... 227
Conclusión ................................................. .......................................... 227
■ Apéndice: Sugerencias para otras actividades ................................... 229

Las palabras de despedida ... ............................................. .................................................. ..... 230
Índice ................................................. ............................................. 231
xiii
Sobre el Autor
Dr. John C. Shovic Actualmente es director de tecnología de SwitchDoc

Labs, una empresa especializada en productos técnicos para el Movimiento
Maker y la IOT; y InstiComm, una empresa especializada en soluciones de
software médicas móviles para profesionales de la salud. También fue
director de estrategia de Tecnología en Stratus Global Partners con un
enfoque en el suministro de experiencia en áreas de seguridad informática
reglamentarias y técnicas a los proveedores de atención de salud. Ha
trabajado en la industria durante más de treinta años y ha fundado siete
empresas: arquitecturas de hardware avanzada, TriGeo de seguridad de red,
Azul Water Technologies, MiloCreek, InstiComm, SwitchDoc Labs, y
bankCDA. Como miembro fundador de la junta directiva bankCDA,
actualmente se desempeña como presidente del comité de tecnología. Él
tiene también
servido como un profesor de informática de la Universidad del Este de Washington, la Universidad Estatal de Washington y la
Universidad de Idaho. El Dr. Shovic ha dado más de ochenta conferencias invitadas y ha publicado más de setenta trabajos
sobre una variedad de temas Arduino / Frambuesa Pi de, HIPAA, GLB, la seguridad informática, informática forense, y
sistemas embebidos.
xv
Sobre el revisor
técnico
Gheorghe Chesler es un ingeniero de software senior con experiencia en Aseguramiento de la Calidad, Sistema de
automatización, ingeniería de rendimiento, y la publicación electrónica. Trabaja en ServiceNow como Ingeniero de las
Realizaciones, y es un asesor técnico principal de Plural Publishing, una editorial-campo de la medicina. Su lenguaje de
programación preferido es Perl (tanto es así que se identifica con la mascota de Perl, por lo tanto, la imagen del camello), pero
también ha trabajado en muchos proyectos de Java y Objective-C.
xvii
Expresiones de gratitud
El autor desea reconocer el duro trabajo del equipo editorial APulse en poner este libro juntos.
También quisiera reconocer el duro trabajo de la Fundación Raspberry Pi y el grupo de Arduino para la
elaboración de productos y comunidades que ayudan a hacer que el Internet de las cosas más
accesible para el público en general. Viva la democratización de la tecnología!
xix
Introducción
El Internet de las Cosas (IOT) es un concepto complejo, con muchas computadoras y muchas rutas de comunicación. Algunos
dispositivos IO estén conectados a Internet y algunos no lo son. Algunos dispositivos IOT forman enjambres que se comunican
entre sí. Algunos están diseñados para un solo propósito, mientras que algunos son ordenadores de propósito más general.
Este libro está diseñado para mostrar la IOT, de adentro hacia afuera. Con la construcción de dispositivos de IOT, el lector
podrá entender los conceptos básicos y será capaz de innovar utilizando los conceptos básicos para crear sus propias
aplicaciones IOT.
Estos proyectos incluidos mostrarán al lector cómo construir sus propios proyectos IOT y ampliar en los
ejemplos mostrados. La importancia de la seguridad informática en dispositivos IOT también se discute y diversas
técnicas para mantener la IOT salvo de usuarios no autorizados o hackers. La conclusión más importante de este libro
es en la construcción de los proyectos de usted mismo.
xxi
Capítulos de un vistazo
En este libro, hemos construido ejemplos de todas las partes principales de dispositivos simples y complejos IOT.
en el capítulo 1 , Los conceptos básicos de la IOT se explican en términos básicos, y usted

aprender qué partes y las herramientas necesarios para iniciar la creación de prototipos sus propios dispositivos IOT.
en el capítulo 2 , Aprenderá a percibir el medio ambiente con la electrónica y que

incluso el comportamiento de tipo simple LightSwarm de dispositivos puede ser muy impredecible.
Capítulo 3 introduce conceptos importantes sobre cómo construir sistemas reales que puedan responder a las cuestiones de
poder y errores de programación mediante el uso de un buen diseño y organismos de control del sistema.
Capítulo 4 Resulta una Raspberry Pi en un dispositivo alimentado por batería que detecta iBeacons y controla la
iluminación en una casa al informar de su ubicación a un servidor.
en el capítulo 5 , Que va a hacer IOT la forma en que los chicos grandes conectando hasta la IBM
Bluemix IOT servidor y enviar nuestras tasas de pulso biométricos para el almacenamiento y visualización.
en el capítulo 6 , Vamos a construir un pequeño sistema RFID de inventario y el uso de protocolos estándar
MQTT como para enviar información a un Raspberry Pi, un producto completo IOT.
Capítulo 7 muestra el lado oscuro de la IOT, Seguridad Informática. La manera de proteger el dispositivo de IOT de
piratas informáticos y problemas de la red es la parte más difícil del dispositivo IOT y el diseño del sistema.
¿Está totalmente seguro? Nunca se sabe. Planificarlo.

El apéndice de referencia proporciona recursos para el estudio adicional y sugerencias para otros proyectos.
xxiii
CAPÍTULO 1
Introducción a la IOT
Capítulo Objetivo: entender lo que el IOT es y cómo hacer un prototipo dispositivos IOT
Los temas tratados en este capítulo:
• Lo que es IOT
• Elegir un modelo de Frambuesa Pi
• La elección de su dispositivo IOT
• Caracterización de dispositivos IOT
• La compra de las herramientas adecuadas para hacer frente a hardware
• Escribir código en Python y en el IDE de Arduino
El IOT es un nombre para la vasta colección de “cosas” que se están conectados en red en el hogar y en el lugar de trabajo
(hasta 20 mil millones para el año 2020 de acuerdo con Gardner, una empresa de consultoría de tecnología). Esa es una muy
vasta colección. Y pueden ser subestimarla.
Todos tenemos un gran número de computadoras en una casa moderna. Acabo de hacer un tutorial de mi casa, haciendo caso omiso
de mi oficina (que se llena con otros ordenadores ~ 100). He encontrado 65 dispositivos diferentes que tienen ordenadores integrados. Estoy
seguro de que echaba de menos a algunos de ellos. Ahora de esos dispositivos basados en computadoras, conté 20 de ellos que tienen
direcciones IP, aunque sé que me falta unos pocos (como por ejemplo el termostato). Así que en un sentido real, esta casa cuenta con 20
dispositivos IOT. Y es sólo 2,016 partir de la redacción de este libro. Con más de 100 millones de hogares en los Estados Unidos solamente,
20 mil millones de dispositivos IOT de alguna forma no parecen tantos.
¿Cuáles son las tres características definitorias de la IOT?
• Networking - estos dispositivos IOT hablan entre sí (comunicación M2M) o a los

servidores ubicados en la red local o en Internet. Al estar en la red permite que el
dispositivo de la capacidad común para consumir y producir datos.
• Percibiendo - IOT dispositivos detectan algo acerca de su entorno.
material complementario electrónico La versión en línea de este capítulo (doi: 10.1007 / 978-1-4842-1377-3_ 1 ) Contiene
material suplementario, que está disponible para los usuarios autorizados.
© 2016 John C. Shovic 1

JC Shovic, Frambuesa Pi IO Proyectos, DOI 10.1007 / 978-1-4842-1377-3_1
CAPÍTULO 1 ■ INTRODUCCIÓN A IOT
• Actuadores - IOT dispositivos que hacen algo. Cierre las puertas, pitido, encienden las luces, o encender
el televisor.
Por supuesto, no todos los dispositivos IOT tiene los tres, pero estas son las características de lo que nos encontraremos
por ahí.
Es valiosa la IOT? ¿Hará la diferencia? Nadie está seguro de lo que será la aplicación estrella, pero la
gente está apostando grandes sumas de dinero que habrá una aplicación asesina. La lectura de este libro y
hacer los proyectos le enseñará mucho sobre la tecnología y le permiten crear sus propias aplicaciones IOT.
Elegir un modelo de Frambuesa Pi

La familia Frambuesa Pi de los ordenadores de placa única (ver figura 1-1 ) Es un producto de la Fundación Raspberry Pi ( RaspberryPi.org
). Han vendido más de 9 millones de estos pequeños ordenadores, de bajo costo. La Raspberry Pi se ejecuta una serie de
diferentes sistemas operativos, la más común de las cuales es la liberación de Raspian Unbuntu Linux.
La Figura 1-1. Frambuesa Pi 2
Al igual que Windows, Linux es un sistema operativo multitarea, pero a diferencia de Windows, que es un sistema de
código abierto. Usted puede obtener todo el código fuente y compilarlo si lo desea, pero yo no recomendaría que para un
principiante.
Una de las mejores partes de la Frambuesa Pi es que hay un gran número de controladores de dispositivos y sensores
disponibles, lo que hace que sea una buena opción para la construcción de proyectos de IOT,
2
especialmente usarlo como un servidor para su proyecto IOT. El Frambuesa Pi no es un dispositivo de baja potencia, lo que limita su
uso como un dispositivo de IOT. Sin embargo, todavía es un gran dispositivo de prototipos y un gran servidor.
Hay una variedad desconcertante en lugar de placas de Frambuesa Pi disponibles. Sugiero para este libro que se obtiene un
IP o frambuesa 2 Frambuesa Pi 3. Mientras que el $ 5.00 Frambuesa Pi cero es tentador, se necesita un poco de otro hardware
para conseguir que el punto en que se puede utilizar. Mientras que la Frambuesa Pi 3 es más caro ($ 35), que viene con una
interfaz de conexión Wi-Fi incorporado y puertos USB adicionales.
Tenga en cuenta que estamos usando la Frambuesa Pi A + para la construcción de la estación meteorológica IOTWeatherPi más
adelante en este libro. La razón de ello es el consumo de energía: la mitad o un tercio de la energía utilizada por los modelos más
potentes Frambuesa Pi.
Hay muchos tutoriales en la web para configurar el Pi de frambuesa y conseguir el software del
sistema operativo en ejecución.
La elección de un dispositivo IOT

Si piensa que la lista de las tarjetas Frambuesa Pi disponibles es desconcertante, a continuación, esperar a que nos fijamos en el número
de dispositivos IOT que están disponibles. Mientras que cada oferta es interesante y tiene características únicas, estoy sugiriendo los
siguientes dispositivos para sus primeros proyectos en la IOT. Tenga en cuenta que he seleccionado en base a éstos la posibilidad de
personalizar el software y añadir sus propios dispositivos sin ocultar toda la complejidad, por lo tanto, la reducción de aprendizaje en
cuestión. Es por eso que no estoy usando dispositivos de tipo de Lego en este libro.
Vamos a utilizar la siguiente:
• placas basadas en ESP8266 (específicamente el Adafruit Hurra ESP8266)
• placas Arduino Uno y Arduino Mega2560
La caracterización de un proyecto IOT

Cuando se mira en un nuevo proyecto, lo primero que hay que hacer para entender un proyecto IOT es mirar a los seis aspectos
diferentes para caracterizar un proyecto IOT.
• comunicaciones
• procesador Power
• Almacenamiento local
• El consumo de energía
• funcionalidad
• Costo
Cuando pienso en estas características, me gusta calificar cada uno en una escala del 1-10, siendo 1 el menos
adecuado para IOT y 10 es la más adecuada para aplicaciones de IO. Anotando cada uno me obliga a pensar
cuidadosamente acerca de cómo un proyecto dado cae en el espectro de idoneidad.
3
comunicaciones
Las comunicaciones son importantes para proyectos IOT. De hecho, las comunicaciones son fundamentales para todo el género.
Hay una compensación para los dispositivos IOT. Cuanto más complejo y los protocolos más altas las tasas de datos, el
procesador más potente que necesita y la potencia eléctrica más el dispositivo IOT consumirán.
comunicaciones de base TCP / IP (piensan servidores web; la conmutación basada en HTTP (como servidores de descanso);
flujos de datos; UDP - véase el capítulo 2 ) Proporcionar la mayor flexibilidad y funcionalidad a un costo de procesador y de energía
eléctrica.
BlueTooth de baja potencia y tipos de conexiones permiten Zigbee potencia mucho menor para las conexiones con la
correspondiente disminución en el ancho de banda y la funcionalidad.
IOT proyectos pueden ser por todo el mapa de los requisitos para las necesidades de comunicación de flexibilidad y de ancho de
banda de datos.
IOT dispositivos que tienen el apoyo total de TCP / IP son la mejor en esta categoría, pero probablemente serán
marcados en otras categorías (como el consumo de energía).
procesador Power
Hay un número de diferentes formas de medir la potencia del procesador. La velocidad del procesador, tamaño de instrucciones del
procesador y sistema operativo, juegan en este cálculo. Para la mayoría de aplicaciones de sensores y dispositivos IOT, no estará
limitado por la velocidad del procesador, ya que son todos bastante rápido. Sin embargo, hay una excepción a esto. Si está
utilizando técnicas de cifrado y descifrado (véase el capítulo 7 ), Entonces esas operaciones son computacionalmente caro y
requieren más potencia de procesador para funcionar. La compensación puede ser que usted tiene para transmitir o recibir datos de
forma mucho más lenta debido a los requisitos computacionales de cifrar / descifrar los datos. Sin embargo, para muchos proyectos
IOT, esto está muy bien.
potencia del procesador más alto se da a las calificaciones más altas en esta categoría.
Almacenamiento local
El almacenamiento local se refiere a los tres principales tipos de almacenamiento: memoria RAM, EEPROM y memoria flash.
RAM (Random Access Memory) es de alta velocidad de datos, memoria de lectura / escritura, generalmente utilizado para datos
y almacenamiento de pila durante la ejecución del programa de IOT. EEPROM (eléctricamente programable y borrable memoria de
sólo lectura) se utiliza para escribir pequeñas cantidades de información de configuración para el dispositivo IOT para su lectura en el
encendido. Memoria flash se utiliza generalmente para el código del programa en sí. Flash es legible al azar (como el código se
ejecuta, por ejemplo), pero sólo se puede escribir en bloques grandes y muy lentamente. Flash es lo que usted está poniendo su
código en el IDE de Arduino (véase el capítulo 2 ). La cantidad de almacenamiento local (especialmente RAM) se sumará al costo de
su dispositivo IOT. Para la creación de prototipos, cuantos más mejor. Para la implementación, menos es mejor, ya que reducirá su
costo.
4
El consumo de energía
El consumo de energía es la pesadilla de todos los dispositivos IOT. Si no está conectando su dispositivo IOT en la pared, a
continuación, se ejecuta fuera de las baterías o células solares y cada recuento milivatios en su diseño. Reducir el consumo de
energía es un tema complejo que es mucho más allá de los proyectos de introducción a este libro. Sin embargo, los conceptos
son bien comprendidas por la siguiente:
• Poner el procesador en modo de reposo tanto como sea posible.
• Minimizar la comunicación con el exterior de su dispositivo.
• Trate de ser impulsada interrumpir y no sondeo conducido.
• Buscar en su diseño buscando cada cantidad innecesaria de la corriente.
Cuanto mayor sea el número en esta categoría, menos potencia de la unidad IOT utiliza.
funcionalidad
Esta es una especie de cajón de sastre que es bastante subjetiva. Por ejemplo, tener GPIO adicionales (uso general de entrada
salidas) disponibles es muy bueno para la flexibilidad. Estoy funcionando continuamente en limitaciones GPIO con el Adafruit Hurra
ESP8266 ya que hay pocos pines disponibles. Que tienen interfaces seriales adicionales son muy útiles para la depuración. apoyo
especial de hardware para el cifrado y el descifrado puede hacer que la seguridad informática dispositivo mucho más simple. Una de
las cosas que echo de menos en la mayor parte del sistema de prototipado IOT es hardware y software de soporte de depuración.
También incluyo la disponibilidad de librerías de software para una plataforma en esta categoría. A diez significa muy alta
funcionalidad; números bajos significan una funcionalidad limitada.
Costo
¿Qué es un costo aceptable para su dispositivo IOT? Eso depende del valor del dispositivo y el mercado para su dispositivo.
Un precio de $ 2.50 puede ser grande para prototipos, pero será la muerte del producto de la producción. Es necesario
dimensionar el precio del producto y el mercado. Los números altos son unidades de bajo costo y bajo número son
dispositivos de mayor costo.
Las herramientas adecuadas para hacer frente a hardware

Cualquier cosa es más difícil sin las herramientas adecuadas. Cuando realiza el salto de sólo hacer software para hacer una mezcla
de software / hardware, aquí hay una lista de las herramientas que debe tener:
• 30W temperatura regulable soldador - calefacción y cables de

conexión
• soporte de soldadura - para mantener el soldador caliente
5
• Solder, colofonia-core, 0,031” de diámetro, 1/4 lb (100 g) de carrete - para soldar con
• Lechón de la soldadura -Útil en la limpieza de los errores
• Mecha de soldadura / trenza de 5 pies carrete - Se utiliza junto con el succionador de soldadura a
recoger el desorden de soldadura
• Panavise Jr - Uso general de 360 grados mini-tornillo de banco
• Multímetro digital - Buena todo-en torno básica multímetro
• Alicates de corte diagonal - Recorte de alambres y cables
• pelacables - herramienta para la toma de aislamiento de cables
• alicates de punta fina Micro - para doblar y componentes de formación de
• alambre de núcleo sólido, 22 AWG, 25 pies carretes - negro, rojo y amarillo para el pan-embarque
y cableado
Adafruit tiene un equipo de excelentes principiantes por $ 100 [ https://www.adafruit.com/ productos / 136] . Figura 1-2 muestra
las herramientas que están en él.
La Figura 1-2. Adafruit Electrónica Toolkit
6
Escribir código en Python y el IDE Arduino

Todo el código de este libro está en dos idiomas. Específicamente, Python se utiliza para la Frambuesa Pi y C / C ++
(No se asuste, hay muchos ejemplos y recursos) para el IDE Arduino.
Python es un alto nivel, lenguaje de programación de propósito general. Está diseñado para enfatizar la legibilidad del
código, y en especial le mantiene fuera de tener punteros sueltas (una maldición de todos los programadores de C / C ++) y hace
la gestión de memoria para usted. Este es el lenguaje de programación de elección para el Raspberry Pi. Python tiene el mayor
conjunto de bibliotecas para IOT y dispositivos de sistemas integrados de cualquier idioma para el Raspberry Pi. Todos los
ejemplos en este libro que utilizan el Raspberry Pi, usar Python. Estoy usando Python 2.7 en este libro, pero es relativamente fácil
de convertir a Python 3.5. Sin embargo, no es tan trivial para encontrar todas las bibliotecas de Python 3.5, así que sugiero que
se alojen con Python 2.7.
¿Por qué estamos usando C ++ para la mayoría de los dispositivos IOT? Hay cuatro razones para esto:
• Los programas en C se compilan en código nativo para estos pequeños dispositivos, que le da
mucho mejor control sobre el tamaño y el tiempo. Python requiere un intérprete, que es una gran
cantidad de código que no caben en pequeños dispositivos IOT, como el Arduino. En un
Frambuesa Pi, es posible que tenga un Gigabyte (GB) de RAM y 8 GB de almacenamiento tarjeta
SD. En un dispositivo IOT, es posible que sólo 2.000 bytes (2K) y 32 KB de almacenamiento de
códigos. Esa es una razón de 500.000 a 1. Esa es la razón por lo que necesita un código eficiente
en dispositivos IOT. Sí, hay MicroPython, pero es muy limitado y todavía utiliza más memoria que
la mayoría de las placas Arduino.
• Cuando se programa en C / C ++, que están más cerca del hardware y tener un mejor control de
la programación de las operaciones. Esto puede ser muy importante en algunas situaciones.
Uno de los temas de Python es la del recolector de basura de memoria. A veces, el programa se
ejecutará sin memoria y Python invocará el recolector de basura para limpiar la memoria y
configurarlo para su reutilización. Esto puede causar que su programa no se ejecutará en el
momento que esperaba. Una nota interesante es que el ESP8266 utilizado en varios capítulos
de este libro también tiene un recolector de basura de memoria, lo que puede causar algunos
problemas en secuencias de tiempo críticos. Ninguno de se sabe que existe en el código
utilizado en este libro. Mantener los dedos cruzados, sin embargo.
• Bibliotecas, librerías, bibliotecas. Puede encontrar bibliotecas Arduino C / C ++ para casi cualquier
dispositivo y la aplicación se puede imaginar para aplicaciones IOT. La biblioteca de Arduino en sí
está lleno de grandes cantidades de funcionalidad, por lo que es mucho más fácil conseguir su
aplicación IOT en funcionamiento.
7
• Por último, el IDE Arduino (entorno de desarrollo integrado) es un ambiente bueno (pero
no genial) para escribir código para dispositivos pequeños. Tiene sus peculiaridades y
algunas desventajas. El número uno desventaja del IDE Arduino es que no tiene un
depurador incorporado. Incluso con esta desventaja significativa, que se ejecuta en
Linux, Windows y Mac, y lo vamos a utilizar en este libro. El IDE de Arduino está
ampliamente disponible, y hay muchos recursos para el aprendizaje y bibliotecas
diseñadas para ello. Otras alternativas incluyen Visuales Micro (se ejecuta en Windows,
basado en Microsoft Visual Studio) y Eclipse (se ejecuta en Linux, Windows y Mac).
Eclipse puede ser una pesadilla para establecer y actualizar, pero se han realizado
mejoras en los últimos años.
En este libro
¿Qué vamos a hacer en los próximos capítulos? Vamos a construir proyectos IOT reales que en realidad tienen una gran cantidad
de funcionalidad. Sí, es divertido a parpadear un LED, pero es sólo el primer paso para hacer las cosas realmente interesantes y
útiles con toda esta nueva tecnología. Construir una estación meteorológica IOT. Construir un enjambre luz IOT. Construir su propio
dispositivo IOT con sus propios sensores. Todo es accesible y de bajo costo y dentro de su capacidad si usted es un ingeniero o no.
8
CAPITULO 2
Al percibir su entorno
IOT
Capítulo Objetivo: construir su primer dispositivo IOT
• La construcción de un dispositivo sensor de IOT de bajo costo basado en el IDE de Arduino y ESP8266
• La creación de una auto-organización sencilla IOT neto del sensor
• Lectura del sensor I2C (luz y color) en los dispositivos de Arduino
• La lectura de datos de los sensores IOT remotas en el Frambuesa Pi
• El uso de la Frambuesa Pi de Seguimiento y Depuración
• Viendo los datos en la pantalla y en un iPad
En este capítulo, construimos nuestro primer dispositivo IOT. Este diseño simple, un enjambre sensor de luz, es fácil de
construir e ilustra una serie de principios IOT entre ellos los siguientes:
• control distribuido
• La auto-organización
• Pasar información a Internet
• Comportamiento Swarm
La arquitectura LightSwarm es un esquema simple y flexible para la comprensión de la idea de un proyecto IOT usando
muchos pequeños ordenadores y sensores simples con responsabilidad compartida para el control y la presentación de informes.
Tenga en cuenta que en este enjambre, la comunicación con Internet es manejado por un Frambuesa Pi. Los dispositivos enjambre
hablan entre sí, pero no con Internet. La Raspberry Pi se encuentra en el mismo punto de acceso Wi-Fi como el enjambre, pero
podría estar situado muy lejos con un poco de reenvío inteligente de paquetes a través de su router Wi-Fi. En este caso, ya que no
tenemos la seguridad informática en absoluto en este diseño (véase el capítulo 7 para obtener información acerca de hacer su
enjambre IOT y el dispositivo más seguro) y así que son fieles a la red local. La excepción a esto es el panel de control RasPiConnect
LightSwarm que puede ser ubicado en cualquier lugar en Internet y está asegurado por el control de contraseña y fácilmente podría
ser enviado a través de https, el cifrado de los paquetes XML individuales.

CAPITULO 2 ■ SENSING su entorno IOT
Redes de sensores IOT

Uno de los principales usos de la IOT será la construcción de redes y grupos de sensores. detección de bajo costo es tan grande de un
controlador para la IOT como el desarrollo de las computadoras de bajo costo. La capacidad de un equipo para percibir su entorno es la
clave para la recopilación de información para el análisis, acción, o transmisión a Internet. redes de sensores han existido en el mundo
académico durante muchos años, pero ahora los precios de goteo y la disponibilidad de herramientas de desarrollo están moviéndose
rápidamente redes de sensores a la corriente principal. conferencias industriales y académicos enteros ahora se celebran en redes de
sensores [ www.sensornets.org ] . El mercado está explotando para estos dispositivos, y las oportunidades son enormes para la persona
creativa o grupo que pueda encontrar la manera de hacer que la red de sensores que realmente va a impulsar las ventas de consumo.
IOT Caracterización de este proyecto

Como ya os comentamos en el capítulo 1 , Lo primero que hay que hacer para entender un proyecto IOT es mirar a nuestros seis
diferentes aspectos de IOT. LightSwarm es un proyecto bastante simple y puede ser dividido en los seis componentes que figuran en la
tabla 2-1 .
Tabla 2-1. LightSwarm Caracterización (CPLPFC)
Aspecto Clasificación comentarios
comunicaciones 9 conexión WiFi a Internet - puede hacer ad hoc de comunicación

meshtype
procesador Power 7 80MHz Xtensa Harvard arquitectura de CPU, memoria RAM de datos ~ 80KB
/ ~ 35 KB de RAM Instrucción / 200K ROM
Almacenamiento local 6 Flash de 4MB (o sistema de archivos 3 MB!)
Consumo de energía 7 ~ 200 mA de transmisión, recepción ~ 60mA, no hay WiFi ~ 15 mA, 1 mA

en espera ~
funcionalidad 7 Soporte parcial Arduino (GPIO limitados Entradas / analógicos)
Costo 9 <$ 10 y cada vez más barato
Las calificaciones son del 1-10, siendo 1 el menos adecuado para IOT y 10 es la más adecuada para
aplicaciones de IO.
Esto nos da una calificación de 7,2 CPLPFC. Esta se calcula promediando los seis valores junto con igual
ponderación. De esta forma es ideal para el aprendizaje y la experimentación, y podría ser desplegado para algunas
aplicaciones.
El ESP8266 es un dispositivo impresionante que tiene un sistema incorporado en la conexión WiFi, una potente CPU, y un poco de
memoria RAM y el acceso a las bibliotecas de Arduino. Es barato y un precio más bajo con el paso del tiempo. Se trata de un potente
dispositivo para la creación de prototipos de aplicaciones que requieren IOT niveles medios de la funcionalidad.
10
¿Cómo funciona este dispositivo se conectan a la IOT?

El ESP8266 proporciona una conexión Wi-Fi transmisor / receptor, una pila TCP / IP, y el firmware para soportar conexiones de
dirección a un punto de acceso Wi-Fi local que luego pueden conectarse a Internet. En este proyecto, la ESP8266 sólo se refería a
los dispositivos de la red inalámbrica local. -Esta es una increíble cantidad de funcionalidades por menos de $ 10 al por menor. Estos
chips se pueden encontrar para tan poco como $ 1 en el mercado abierto, si quieres rodar su propia placa de circuito impreso.
¿Qué es un ESP8266?
El ESP8266 es hecha por una empresa en China llama Espressif [espressif.com]. Son una compañía de
semiconductores que acaba de salir de la nada con la primera generación de este chip y sacudió a toda la industria.
Ahora todos los principales actores están trabajando en versiones baratas de un chip de IOT con conectividad
Wi-Fi.
El chip ESP8266 fue diseñado originalmente para las bombillas conectadas pero pronto se acostumbró en una variedad de
aplicaciones y módulos ESP8266 son actualmente ahora las soluciones más populares para añadir WiFi a proyectos IOT. Mientras que el
ESP8266 tiene gran funcionalidad y un buen precio, la cantidad de corriente consumida por el chip hace que las soluciones que funcionan
con baterías problemática.
El ESP8266 está permitiendo un nuevo conjunto de aplicaciones y comunidades con su diseño innovador y
de bajo costo (Figura 2-1 ).
La Figura 2-1. Los ESP8266 mueren. (Cortesía de Hackaday.io)
11
Vamos a utilizar una versión de la ESP8266 en un tablero del desbloqueo diseñada por Adafruit (figura 2-2 ). La placa
tiene algunas conexiones, una antena incorporada, y una cierta regulación de potencia, todo por menos de $ 10.
La Figura 2-2. El Adafruit Hurra ESP8266. (Cortesía de adafruit.com )
El diseño LightSwarm
Hay dos aspectos importantes del diseño del proyecto LightSwarm. Primero de todo, cada elemento del enjambre se basa en un
ESP8266 con un sensor de luz adjunto. El software es lo que hace que este pequeño dispositivo IOT en un enjambre. En el
siguiente diagrama de bloques se puede ver los dos dispositivos principales. Estoy utilizando el tablero del desbloqueo Adafruit
Hurra para la ESP8266
[ www.adafruit.com/product/2471 ] . ¿Por qué utilizar un tablero del desbloqueo? Con un tablero del desbloqueo de dispositivos
que pueda rápidamente prototipos y luego pasar a un diseño menos costoso en el futuro. El otro componente electrónico (figura
2-3 ) Es un tablero del desbloqueo de luz-sensor TCS34725 RGB, también de Adafruit [ www.adafruit.com/products/1334 ] .
12
La Figura 2-3. Tablero del desbloqueo del TCS34725. (Cortesía de adafruit.com )
La adición de un sensor a un ordenador es lo que hace este proyecto un dispositivo IOT. Estoy sintiendo el medio
ambiente y luego hacer algo con la información (la determinación de qué del enjambre tiene la luz más brillante). Figura 2-4
muestra el diagrama de bloques de un único elemento Swarm.
13
La Figura 2-4. LightSwarm Diagrama de bloques de elementos
Cada uno de los dispositivos LightSwarm en el enjambre es idéntico. No hay diferencias de software y
no hay diferencias de hardware. Como se verá cuando discutimos el software, que votar entre sí y comparar
notas y luego elegir el dispositivo que tiene la luz más brillante como el “Maestro” y luego el “Maestro” se
convierte el LED rojo en el dispositivo para mostrarnos que ha sido elegido “Maestro”. el enjambre está
diseñado para dispositivos pueden caer fuera del enjambre, se añade a la enjambre de forma dinámica, y el
enjambre se ajusta a la nueva configuración. El comportamiento de enjambre (que es el maestro, el tiempo
que tarda la información sobre el cambio de luces para propagarse a través del enjambre, etc.) es bastante
complejo. Más complejo de lo esperado de la simple código de dispositivo enjambre. Hay una lección aquí:
El comportamiento de la LightSwarm me sorprendió varias veces y era a veces muy difícil de averiguar lo
que estaba ocurriendo, incluso con el registrador de Frambuesa Pi. Figura 2-5 muestra la LightSwarm completa
incluyendo la Frambuesa Pi.
14
La Figura 2-5. El enjambre Luz
El Frambuesa Pi en este diagrama no está controlando el enjambre. La Raspberry Pi recoge los datos de la nube
(la corriente del dispositivo “Maestro” envía información a la Frambuesa Pi), y luego el Raspberry Pi puede almacenar los
datos y comunicarse a través de Internet, en este caso a una aplicación basada en iPad llamada RasPiConnect [ www.milocreek.com
],
que muestra el estado actual e histórico de la LightSwarm.
El proyecto LightSwarm tiene una increíble cantidad de funcionalidad y comportamiento auto-organizados peculiar
para un diseño tan simple.
15
La construcción de su primer IOT Swarm

Mesa 2-2 enumera las piezas necesarias para construir un enjambre IOT.
Tabla 2-2. Lista de piezas nadaron
Número de pieza Contar Descripción Costo aproximado Fuente

por la Junta
ESP8266 5 CPU bordo / Wi-Fi $ 10 productos

Junta huzzah www.adafruit.com/ / 2471
TCS34725 5 Sensor de luz I2C $8 productos

Tablero del desbloqueo www.adafruit.com/ / 1334
FTDI cable 1 Cable para la programación de la $ 18 de productos

ESP8266 desde el PC / Mac www.adafruit.com/ / 70
Instalación del soporte de Arduino en el PC o Mac

La clave para hacer este trabajo del proyecto es el software. Si bien hay muchas maneras de programar el
ESP8266 (MicroPython) [ micropython.org], intérprete NodeMCU Lua
[Nodemcu.com/index_en.html], y el IDE Arduino (entorno de desarrollo integrado) [ www.arduino.cc/en/Main/Software
] ), Elegí el IDE Arduino por su flexibilidad y el gran número de bibliotecas de sensores y dispositivos
disponibles.
Para instalar el IDE Arduino que tiene que hacer lo siguiente:
a. Descargar el paquete de Arduino IDE para su computadora y

instalar el software [ www.arduino.cc/en/Guide/HomePage ] .
segundo. Descargar las bibliotecas ESP para que pueda usar el IDE Arduino
con el tablero del desbloqueo ESP. Adafruit tiene un excelente tutorial para instalar
el soporte ESP8266 para el IDE Arduino
[ learn.adafruit.com/adafruit-huzzah-esp8266-breakout/ usando-arduino-ide ] .
Su Primer bosquejo para la ESP8266

Una gran manera de poner a prueba su configuración es ejecutar un pequeño boceto que parpadeará el LED rojo en el tablero del
desbloqueo ESP8266. El LED rojo está conectado a GPIO 0 (General Purpose Input-Output pin 0) en la placa Adafruit.
Abrir un nuevo boceto usando el IDE Arduino y coloque el código siguiente en la ventana de código, en sustitución
de los stubs proporcionado al abrir un nuevo croquis. El código dado aquí hará que el LED rojo parpadea.
dieciséis
void setup () {
pinMode (0, OUTPUT); }
void loop () {
digitalWrite (0, HIGH); retardo
(500);
digitalWrite (0, LOW); retardo
(500); }
Si el LED está parpadeando felizmente lejos ahora, de haber seguido correctamente todos los tutoriales y tienen la
ESP8266 y el IDE de Arduino que se ejecuta en el ordenador.
A continuación voy a describir los principales sistemas de hardware y luego sumergirse en el software.
el hardware
Los principales elementos de hardware en el dispositivo enjambre son los siguientes:
• ESP8266 - Interfaz de CPU / Wi-Fi
• TCS34725 - Sensor de luz
• Batería de 9 V - Power
• FTDI Cable - Programación y poder
El ESP8266 comunica con otros dispositivos enjambre mediante la interfaz de WiFi. El ESP8266 utiliza la
interfaz I2C para comunicarse con el sensor de luz. El Wi-Fi es un estándar que es muy común (aunque utilizamos
protocolos de comunicación que no son comunes). Véase la descripción de (User Datagram Protocol) UDP más
adelante en este capítulo. La interfaz de bus I2C es mucho menos familiar y necesita alguna explicación.
Revisando el bus I2C

Un bus I2C se utiliza a menudo para comunicarse con las virutas o sensores que están en la misma placa o ubicados
físicamente cerca de la CPU. Es sinónimo de bus de dispositivo estándar Inter-IC. El I2C fue desarrollado por primera vez por
Phillips (ahora NXP Semiconductors). Para moverse por problemas de licencia, a menudo el autobús se llamará TWI (Two
Wire Interface). SMBus, desarrollado por Intel, es un subconjunto de I2C que define los protocolos de forma más estricta. I2C
sistemas modernos toman las políticas y normas de SMBus veces con apoyo tanto reconfiguración mínima necesaria. La
Frambuesa Pi y el Arduino son estos dos tipos de dispositivos. Incluso el ESP8266 utiliza en este proyecto puede soportar
tanto.
Un I2C proporciona un buen soporte para los dispositivos periféricos lentos y estrechos que sólo necesitan ser abordados de vez en
cuando. Por ejemplo, un dispositivo de medición de temperatura por lo general sólo cambian muy lentamente y por lo tanto es un buen
candidato para el uso de I2C, donde una cámara generará una gran cantidad de datos de forma rápida y potencialmente cambia a menudo.
17
Un bus I2C utiliza sólo dos líneas de drenaje abierto bidireccionales (-drenaje abierto significa que el dispositivo puede
tirar de un nivel hacia abajo a tierra, pero no puede tirar de la línea hasta Vdd. De ahí el nombre open-drenaje). Por lo tanto un
requisito de un bus I2C es que ambas líneas se levantan a Vdd. Esta es un área importante y no tirar correctamente las líneas
es la primera y más común error que hace cuando se utiliza por primera vez un bus I2C. Más de pull-up más adelante en la
sección siguiente. Las dos líneas son SDA (Serial Line Datos) y el SCL (Serial Line Reloj). Hay dos tipos de dispositivos que se
pueden conectar a un bus I2C. Se trata de dispositivos maestros y esclavos. Por lo general, usted tiene un dispositivo maestro
(la Frambuesa Pi en nuestro caso) y múltiples dispositivos esclavos, cada uno con su dirección de 7 bits individuales (como
0x68 en el caso de la DS1307). Hay maneras de tener direcciones de 10 bits y múltiples dispositivos maestros, pero que está
más allá del alcance de esta columna. Figura 2-6 muestra un bus I2C con dispositivos y el maestro conectado.
■ Nota SwitchDoc Vcc y Vdd significan lo mismo. GND y Vss, también es posible tanto significan suelo. Hay diferencias
históricas, pero hoy Vcc por lo general es una fuente de alimentación, y si hay una segunda, que se llaman Vdd.
Cuando se usa en la Raspberry Pi, el Raspberry Pi actúa como maestro y todos los demás dispositivos están conectados
como esclavos.
La Figura 2-6. Un bus I2C con un maestro (la ESP8266 en este caso) y tres dispositivos esclavos. RPS son los pull-up
■ Nota SwitchDoc Si se conecta un Arduino a un Frambuesa Pi, tiene que estar
cuidado acerca de los niveles de tensión debido a que la Frambuesa Pi es un dispositivo de 3.3V y la Arduino es un
dispositivo de 5.0V. El ESP8266 es un dispositivo de 3.3V por lo que también hay que tener cuidado de conectar un
Arduino a una ESP8266. Antes de hacer esto, lea este excelente tutorial [ blog.retep. org / 2014/02/15 /
conexión-an-arduino-a-a-frambuesa-pi-usando-I2C / ].
18
El protocolo I2C utiliza tres tipos de mensajes:
• Un solo mensaje donde un maestro escribe los datos a un esclavo;
• Un solo mensaje donde un maestro lee datos de un esclavo;
• mensajes combinados , donde unos problemas maestros al menos dos lecturas y / o escribe en uno o
más esclavos.
Por suerte para nosotros, la mayor parte de la complejidad de tratar con el bus I2C está oculto por los conductores y las bibliotecas.
Dominadas en el bus I2C

Una cosa importante a tener en cuenta en el bus I2C es una resistencia de actuación. La Raspberry Pi tiene 1.8K ohm (1K8)
resistencias ya unidos a la SDA y SCL líneas, por lo que realmente no debería necesitar ningún pull-up adicionales. Sin
embargo, usted tiene que mirar a sus tablas I2C para averiguar si tienen pull-up. Si usted tiene demasiados dispositivos en el
bus I2C con sus propios dominadas, su autobús dejará de funcionar. La regla de oro de Phillips es no dejar que las
resistencias pull-up en paralelo totales sean inferiores a 1K ohmios (1K0). Usted puede obtener una idea bastante buena de lo
que la resistencia total de pull-up es de desconectar la alimentación de todos los dispositivos y el uso de un ohmímetro para
medir la resistencia en la línea SCL desde la línea SCL a Vdd.
Sensor siendo usado

Estamos utilizando el TCS34725, que tiene RGB y elementos sensibles a la luz claros. Figura 2-7 muestra el TCS34725 morir
con el sensor óptico que muestra en el centro de la figura. Un filtro de bloqueo IR, integrada en el chip y localizada a los
fotodiodos de color de detección, minimiza la componente espectral IR de la luz entrante y permite mediciones de color para
hacerse con precisión. El filtro IR significa que obtendrá color mucho más cierto que la mayoría de los sensores, ya que los
humanos no ven IR. El sensor hace ver IR y por lo tanto se proporciona el filtro IR. El sensor también tiene un 3,800,000: rango
dinámico 1 con tiempo de integración ajustable y ganancia por lo que es adecuado para su uso detrás de un vidrio oscurecido o
directamente en la luz.
19
Figura 2-7. La suerte TCS34725 viruta
Este es un excelente sensor de bajo costo ($ 8 por menor de Adafruit en un tablero del desbloqueo) y constituye la base de
nuestra matriz de sensores IOT. Por supuesto, habría que agregar muchos más sensores, pero tener un sensor que es fácil de
manipular es perfecto para nuestro primer proyecto IOT. en el capítulo 3 , Añadimos muchos más sensores al ordenador
Raspberry Pi para un diseño completo IOT WeatherStation.
Impreso caso 3D
Uno de los grandes cambios en la forma de construir prototipos es la disponibilidad de las impresoras 3D de bajo costo. Lo
que solía ser difícil de construir prototipos de los casos y se encuentra a varios proyectos electrónicos. Ahora bien, es fácil
diseñar un caso en uno de los muchos tipos de software 3D y luego imprimirlo utilizando la impresora 3D. Para el enjambre,
que quería un caso parcial para mantener la batería de 9V, la ESP8266, y el sensor de luz. Solía OpenSCAD
[Www.openscad.org] para hacer el diseño. OpenSCAD es un sistema CAD 3D gratis que hace un llamamiento a
los programadores. En lugar de hacer todo el diseño en un entorno gráfico, se escribe código (que consta de
varios objetos, unido o se resta uno del otro) que, a continuación compila en el ambiente para formar un diseño
en el espacio 3D. OpenSCAD viene con un IDE (Integrated Development Environment) y coloque el código
20
muestra en el Listado 2-1 en el editor, compilar el código y, a continuación ver los resultados en la IDE conectado como se
muestra en la figura 2-8 .
La Figura 2-8. pantalla OpenSCAD
Como se muestra en el Listado 2-1 , El código de programación OpenSCAD para construir este soporte es
bastante sencillo. Se compone de cubos y cilindros de diferentes tamaños y tipos.
Listado 2-1. Base de montaje para el IOT LightSwarm
//
// IOT Luz Swarm Base de montaje //
// // SwitchDoc laboratorios de
agosto de 2015 //
Unión() {
cubo ([80,60,3]); translate ([-

1, -1,0]) del cubo ([82,62,2]);
// montaje para batería
translate ([40,2,0]) del cubo

([40,1.35,20]); traducir ([40,26.10 +
3.3,0]) del cubo ([40,1.5,20]);
21
// labios de la batería se
traducen ([79,2,0]) del cubo
([1,28,4]);
// torres para ESP8266
traducir ([70-1.0,35,0])
cilindro (h = 10, r1 = 2,2, r2 = 1.35 / 2, $ fn = 100); traducir
([70-1.0,56,0])
([70-34,35,0])
([70-34,56,0])
cilindro (h = 10, r1 = 2,2, r2 = 1.35 / 2, $ fn = 100);
// pilones para sensor de luz
traducir ([10,35,0])
([10,49.5,0])
cilindro (h = 10, r1 = 2,2, r2 = 1.35 / 2, $ fn = 100);
cilindro (h = 6, r1 = 2,2, r2 = 2,2, $ fn = 100); traducir
([22,47,0])
cilindro (h = 6, r1 = 2,2, r2 = 2,2, $ fn = 100); }
Se puede ver el soporte completado y el cable de FTDI en la próxima figura 2-9 .

Una vez diseñado, rápidamente construyeron cinco de ellos para el LightSwarm. Figura 2-10 muestra un elemento de Swarm
completado.
La lista completa de cableado
Mesa 2-3 proporciona la lista cableado completo de un dispositivo LightSwarm. A medida de que conecte, marque cada cable para mayor
exactitud.
22
Tabla 2-3. Lista de cableado LightSwarm
Desde A Descripción
ESP8266 / GND TCS34725 / GND Terreno para el sensor de luz I2C
ESP8266 / 3V TCS34725 / 3V3 3.3V de alimentación para el sensor de luz I2C
ESP8266 / # 4 TCS34725 / SDA SDA para el sensor de luz I2C
ESP8266 / # 5 TCS34725 / SCL SCL sensor de luz I2C
ESP8266 / GND 9VBat / terminal “-” (menos de terminal) Planta para ESP8266 batería / VBat 9VBat /
“+” terminal (además de 9V) 9V de la batería
TCS34725 / LED TCS34725 / INT La conexión de estos dos pines juntos

permiten un control de software de
LED brillante a bordo TCS34725
El cable de FTDI está conectado en el extremo de la Adafruit Hurra ESP8266. Asegúrese de alinear el cable negro con
el pin GND en el tablero del desbloqueo ESP8266 como en la figura 2-9 . Figura 2-11 muestra el dispositivo LightSwarm
totalmente completa.
Figura 2-9. FTDI aparato esté conectado a ESP8266
23
Figura 2-10. Completado el soporte LightSwarm
Figura 2-11. Un dispositivo completo LightSwarm
24
El software
Hay dos módulos principales escritos para la LightSwarm. El primero es el código de ESP8266 para el dispositivo en sí
LightSwarm (escrito en el IDE de Arduino - escrito en C simplificado y el lenguaje C ++), y el segundo es el software de
recogida de datos Frambuesa Pi (escrito en Python en la Frambuesa Pi).
Las principales especificaciones de diseño de software de los dispositivos LightSwarm son los siguientes:
• auto descubrimiento de dispositivos.
• Dispositivo se convierte en maestro cuando se tiene la luz más brillante; todos los otros se convierten
en esclavos.
• método de votación distribuido para determinar la condición de maestro.
• Enjambre de auto-organización. No hay ningún servidor.
• Enjambre debe sobrevivir y recuperarse de los dispositivos que entran y salen de la red.
• dispositivo maestro envía datos a Raspberry Pi para el análisis y la distribución de

Internet.
El código completo para los dispositivos LightSwarm se proporciona en los listados 2-2 aunque 2-11
(Con la excepción de que el conductor TCS74725 sensor de luz, disponible aquí [ github.com/ adafruit /
Adafruit_TCS34725 ]). El código también está disponible en el sitio web APulse [ www.apress.com ] y el sitio
laboratorios SwitchDoc github [ lightswarm github.com/switchdoclabs/ ].
El listado 2-2. Código LightSwarm
/*
Cooperativa IOT Self Organizing Ejemplo SwitchDoc
laboratorios, Agosto el año 2015
*/
# incluir <ESP8266WiFi.h>
# incluir <WiFiUdp.h>
# incluir <Wire.h>
# incluir "Adafruit_TCS34725.h"
# DEBUG undef
Char SSID [] = "yyyyy"; // el SSID de la red inalámbrica (nombre)

Char pasar [] = "xxxxxxx"; // la contraseña de red inalámbrica
# definir VersionNumber 28
25
# definir SWARMSIZE 5
// 30 segundos es demasiado viejo - debe estar muerto
# definir SWARMTOOOLD 30000
int mySwarmID = 0;
A continuación en el Listado 2-3 , Definimos las constantes necesarias. Las siguientes son las definiciones
de todos los comandos disponibles del enjambre:
• LIGHT_UPDATE_PACKET - paquete que contiene la luz corriente de un dispositivo de

LightSwarm. Se utiliza para determinar quién es maestro y quién es esclavo;
• RESET_SWARM_PACKET - Todos los dispositivos LightSwarm se les dice a restablecer su
software;
• CHANGE_TEST_PACKET - Diseñado para cambiar los criterios de maestro / esclavo (no

implementado);
• RESET_ME_PACKET - Sólo restablecer un ID de dispositivo LightSwarm en particular;
• DEFINE_SERVER_LOGGER_PACKET - Esta es la nueva dirección IP de la Raspberry Pi para

que el dispositivo LightSwarm puede enviar paquetes de datos;
• LOG_TO_SERVER_PACKET - Los paquetes enviados desde dispositivos LightSwarm a

Frambuesa Pi;
• MASTER_CHANGE_PACKET - paquete enviado desde el dispositivo LightSwarm cuando se

convierte en un maestro (no implementado);
• BLINK_BRIGHT_LED - Comando para un dispositivo LightSwarm a parpadear el LED brillante en el
TCS34725. Después de las constantes en venta 2-3 He creado las variables del sistema para los dispositivos.
yo
estoy usando UDP a través de la interfaz de conexión Wi-Fi. Lo que es UDP? UDP significa Protocolo de datagramas de usuario.
UDP utiliza un modelo sin conexión sencilla. Sin conexión significa que no hay diálogo entre el dispositivo transmisor y el
dispositivo receptor para permitir que el emisor sabe que el receptor está realmente allí. A diferencia de TCP (Transmission
Control Protocol), usted no tiene idea o garantía de los paquetes de datos que se entregan a cualquier dispositivo en particular. Se
puede pensar en él como una especie de transmisión de TV a su red local. Todo el mundo lo consigue, pero no tiene que leer los
paquetes. También hay otros efectos sutiles - como usted no tiene ninguna garantía de que los paquetes lleguen en el orden en
que se envían. Entonces ¿por qué estamos usando UDP en lugar de TCP? Estoy utilizando el modo de difusión de UDP por lo que
cuando un dispositivos LightSwarm envían un mensaje a la subred de Wi-Fi, todo el mundo lo consigue y si están escuchando en
el puerto 2910 (definida anteriormente), entonces puede reaccionar al mensaje. Se trata de cómo los dispositivos LightSwarm
obtienen descubierto. Todo el mundo comienza a enviar paquetes (con retrasos introducidos al azar) y todos los dispositivos
LightSwarm averiguar quién está presente y que tiene la luz más brillante. Nada en el sistema LightSwarm asigna números IP o
nombres. Todos ellos lo averigüen ellos mismos.
26
Listado 2-3. LightSwarm Constantes
// tipos de paquetes
# definir LIGHT_UPDATE_PACKET 0
# definir RESET_SWARM_PACKET 1
# definir CHANGE_TEST_PACKET 2
# definir RESET_ME_PACKET 3
# definir DEFINE_SERVER_LOGGER_PACKET 4
# definir LOG_TO_SERVER_PACKET 5
# definir MASTER_CHANGE_PACKET 6
# definir BLINK_BRIGHT_LED 7
unsigned int localPort = 2,910; // puerto local para escuchar a los paquetes UDP
// variables de maestros
boolean masterState = true; // True si amo, False si no int swarmClear [SWARMSIZE];
int swarmVersion [SWARMSIZE]; int swarmState [SWARMSIZE];
largo swarmTimeStamp [SWARMSIZE]; // para el envejecimiento
Dirección IP serverAddress = Dirección IP (0, 0, 0, 0); // Dirección IP por defecto sin
int swarmAddresses [SWARMSIZE]; // direcciones Swarm
// variables para sensor de luz
int clearColor; int

redcolor; int bluecolor;
int Greencolor;
const int PACKET_SIZE = 14; // Luz de actualización de paquetes const int

BUFFERSIZE = 1024;
byte packetBuffer [BUFFERSIZE]; // reguladoras para mantener los paquetes entrantes y salientes
// Un ejemplo UDP para no retrasar el envío y recepción de paquetes a través de UDP WiFiUDP UDP;
/ * Inicializar con valores específicos int tiempo y de ganancia * /

Adafruit_TCS34725 tcs = Adafruit_TCS34725 (TCS34725_INTEGRATIONTIME_700MS, TCS34725_GAIN_1X);
Dirección IP LocalIP;
27
La configuración () rutina mostrada en el Listado 2-4 sólo ejecuta una vez después del reinicio de la ESP8266 y se
utiliza para configurar toda la información y dispositivos de impresión de registro para el puerto serie de la ESP8266, donde, si
tiene el cable FTDI conectado, se puede ver la información de registro de la información y la depuración su PC o Mac.
Listado 2-4. La función de configuración () para LightSwarm
void setup () {
Serial.begin (115,200);
Serial.println (); Serial.println ();
Serial.println ( "");
Serial.println ( "--------------------------"); Serial.println (
"LightSwarm"); Serial.print ( "Version"); Serial.println
(VersionNumber);
Serial.println ( "--------------------------");
Serial.println (F (" 03.09.2015" )); Serial.print (F (

"compilado en:")); Serial.print (F (__ TIME__));
Serial.print (F (" ")); Serial.println (F (__
DATE__)); Serial.println (); pinMode (0,
OUTPUT);
digitalWrite (0, LOW); retardo

(500);
digitalWrite (0, HIGH);
Aquí se utiliza el valor flotante de la entrada analógica en la ESP8266 para establecer la semilla de números
pseudoaleatorios generación. Esto puede variar un poco de dispositivo a dispositivo, y así que no es una mala manera de
inicializar el generador de números pseudo-aleatorios. Si se pone un número fijo como el argumento, siempre va a generar el
mismo conjunto de números pseudo-aleatorios. Esto puede ser muy útil en las pruebas. Listado 2-5 muestra la configuración de la
semilla aleatoria y la detección de la TCS34725.
¿Qué es un generador de números pseudo-aleatorios? Es un algoritmo para generar una secuencia de números cuyas
propiedades aproximarse a una secuencia de número verdaderamente aleatorio. No es realmente una secuencia aleatoria de
números, pero está cerca. suficiente para nuestro uso bueno.
28
Listado 2-5. El resto de la función de configuración () para LightSwarm
randomSeed (analogRead (A0)); Serial.print (

"analogRead (A0) ="); Serial.println
(analogRead (A0));
si (tcs.begin ()) {
Serial.println ( "sensor Encontrado"); } Else {
Serial.println ( "No se encontró TCS34725 ... ver sus conexiones");
// apagar la luz
tcs.setInterrupt (true); // true significa apagado, significa falsa en
// todo el mundo empieza en 0 y los cambios desde allí mySwarmID =

0;
// Comenzamos mediante la conexión a una red Wi-Fi

Serial.print ( "LightSwarm Instancia:"); Serial.println
(mySwarmID);
Serial.print ( "Conexión a"); Serial.println

(SSID); WiFi.begin (SSID, pase);
// inicializar Swarm Dirección - partimos como swarmID de 0
while (! WiFi.status () = WL_CONNECTED) {retardo

(500); Serial.print ( ""); }
Serial.println ( "WiFi conectado"); Serial.println (

"dirección IP"); Serial.println (WiFi.localIP ());
Serial.println ( "A partir de UDP");
udp.begin (localPort); Serial.print ( "Puerto

local:"); Serial.println (udp.localPort ());
29
// inicializar sensor de luz y arrays int i;
for (i = 0; i <SWARMSIZE; i ++) {
swarmAddresses [i] = 0;
swarmClear [i] = 0;
swarmTimeStamp [i] = -1; }
swarmClear [mySwarmID] = 0;
swarmTimeStamp [mySwarmID] = 1; // Estoy siempre en el tiempo a mí mismo clearColor =
swarmClear [mySwarmID]; swarmVersion [mySwarmID] = VersionNumber; swarmState
[mySwarmID] = masterState; Serial.print ( "clearColor ="); Serial.println (clearColor);
Ahora hemos inicializado todas las estructuras de datos para la descripción de nuestro dispositivo LightSwarm y los
estados del sensor de luz. Listado 2-6 establece el SwarmID basándose en la dirección IP actual del dispositivo. Cuando se
enciende el dispositivo LightSwarm y se conecta a un punto de acceso Wi-Fi, el punto de acceso asigna una dirección IP única
para el dispositivo LightSwarm. Esto se hace a través de un proceso llamado DHCP (Dynamic Host Configuration Protocol) [ en.wikipedia.org/wiki/Dyna
]. Mientras que el número será diferente para cada dispositivo LightSwarm, no es al azar. Normalmente, si usted acciona un
dispositivo específico hacia abajo y ponerlo en marcha de nuevo, el punto de acceso asignará la misma dirección IP. Sin
embargo, no se puede contar con este. El punto de acceso sabe su dispositivo específico, porque todos y cada interfaz de
conexión Wi-Fi tiene un número específico y único MAC (Media Access Control), que es por lo general nunca ha cambiado.
■ Nota SwitchDoc Falsificando las direcciones MAC le permite suplantar a otros dispositivos con su dispositivo, en algunos
casos, y se puede utilizar para rastrear las direcciones MAC máquinas específicas mirando a la red. Esta es la razón por Apple,
Inc. ha comenzado a usar direcciones MAC aleatorias en sus dispositivos mientras está buscando redes. Si no se usan
direcciones MAC aleatorias, a continuación, los investigadores han confirmado que es posible vincular una verdadera identidad
específica a una dirección MAC inalámbrica particular [Cunche, Mathieu. "Sé que su dirección MAC: Targeted seguimiento del
individuo usando Wi-Fi" . 2013].
30
Listado 2-6. Ajuste de la dirección IP de SwarmID
// establecer SwarmID según la dirección IP
LocalIP = WiFi.localIP ();
swarmAddresses [0] = LocalIP [3];
mySwarmID = 0;
Serial.print ( "MySwarmID =");

Serial.println (mySwarmID);
La segunda sección principal del código del dispositivo LightSwarm es el bucle (). La función de bucle () hace
exactamente lo que su nombre sugiere y bucles infinitamente, lo que permite su programa para cambiar y responder.
Esta es la sección del código que realiza el trabajo principal del código LightSwarm.
void loop () {
int secondsCount; int

lastSecondsCount;
lastSecondsCount = 0;
# definir LOGHOWOFTEN
secondsCount = millis () / 100;
En este inmueble 2-7 , Leemos todos los datos del sensor TCS34725 para averiguar cómo
brillante la luz ambiental actualmente es. Esto constituye la esencia de los datos para determinar quién es el maestro en el
enjambre es.
Después de la línea de retardo (300) en el Listado 2-7 , Puedo comprobar para paquetes UDP que se está emitiendo
al puerto 2910. Recuerde que la forma en que el enjambre está utilizando UDP está en modo de emisión y todos los paquetes son
recibidos por todo el mundo todo el tiempo. Tenga en cuenta, esto establece un límite de la cantidad de dispositivos que puede tener
enjambre (limitado al tamaño de subred) y también por la congestión de tener demasiados mensajes pasan por al mismo tiempo. Esto
fue bastante fácil para simular mediante el aumento de la velocidad de envío de paquetes. El enjambre sigue funcionando pero el
comportamiento se vuelve más errático y a veces con grandes retrasos.
31
El listado 2-7. La lectura de la luz de color
uint16_t r, g, b, c, ColorTemp, lux;
tcs.getRawData (& r, & g, y b, y c);

ColorTemp = tcs.calculateColorTemperature (r, g, b); lux =
tcs.calculateLux (r, g, b);
Serial.print ( "Temperatura de color:"); Serial.print (ColorTemp, DEC); De serie. print ( "K -");
Serial.print ( "Lux:"); Serial.print (lux, DEC); Serial.print ( "-"); Serial.print ( "R:"); Serial.print (r,
DEC); Serial.print (" "); Serial.print ( "G:"); Serial.print (g, DEC); Serial.print (" "); Serial.print (
"B:"); Serial.print (b, DEC); Serial.print (" "); Serial.print ( "C:"); Serial.print (c, DEC); Serial.print ("
"); Serial.println (" ");
clearColor = c;
redcolor = r; bluecolor
= b; Greencolor = g;
swarmClear [mySwarmID] = clearColor;
// esperar a ver si la respuesta es retardo disponibles

(300);
int cb = udp.parsePacket ();
si (CB) {
// Serial.println ( "no paquete todavía"); Serial.print (
""); }
else {
en el Listado 2-8 , Interpretamos todos los paquetes en función del tipo de paquete.
El listado 2-8. Interpretar el tipo de paquete
// Hemos recibido un paquete, lea los datos de ella
udp.read (packetBuffer, PACKET_SIZE); // leer el paquete en la Serial.print tampón ( "packetbuffer [1]

="); Serial.println (packetBuffer [1]); si (packetBuffer [1] == LIGHT_UPDATE_PACKET)
32
{
Serial.print ( "LIGHT_UPDATE_PACKET recibió de LightSwarm #"); Serial.println
(packetBuffer [2]); setAndReturnMySwarmIndex (packetBuffer [2]);
Serial.print ( "LS paquetes recibimos del #"); Serial.print

(packetBuffer [2]); Serial.print ( "SwarmState:"); si
(packetBuffer [3] == 0) Serial.print ( "esclavo"); más
Serial.print ( "MASTER");
Serial.print ( "CC:");
Serial.print (packetBuffer [5] * 256 + packetBuffer [6]); Serial.print ( "RC:");
Serial.print (packetBuffer [7] * 256 + packetBuffer [8]); Serial.print ( "GC:");
Serial.print (packetBuffer [9] * 256 + packetBuffer [10]); Serial.print ( "AC:");
Serial.print (packetBuffer [11] * 256 + packetBuffer [12]); Serial.print ( "versión

="); Serial.println (packetBuffer [4]);
// registrar el color claro de entrada
swarmClear [setAndReturnMySwarmIndex (packetBuffer [2])] = packetBuffer [5]

* 256 + packetBuffer [6];
swarmVersion [setAndReturnMySwarmIndex (packetBuffer [2])] = packetBuffer
[4];
swarmState [setAndReturnMySwarmIndex (packetBuffer [2])] = packetBuffer
[3];
swarmTimeStamp [setAndReturnMySwarmIndex (packetBuffer [2])] = millis ();
// Comprobar para ver si yo soy el amo!

checkAndSetIfMaster ();
Los conjuntos de comandos RESET_SWARM_PACKET todos los dispositivos LightSwarm a dominar (encender el LED
rojo en cada uno) y luego permite el voto de software LightSwarm y determinar quién tiene la luz más brillante. A medida que
cada dispositivo recibe un paquete LIGHT_UPDATE_, compara la luz de ese dispositivo enjambre a su propio sensor y se
convierte en un esclavo si su luz es más brillante. Con el tiempo, el enjambre se da cuenta de que tiene la luz más brillante. He
estado enviando periódicamente este de la Frambuesa Pi y viendo los dispositivos funcionan a cabo. Se hace un interesante
vídeo. Listado 2-9 muestra cómo LightSwarm interpreta los paquetes entrantes. La última sección del inmueble 2-9 muestra
cómo el enjambre actualizaciones de todos los demás elementos en el enjambre de lo que está pasando con este dispositivo y
luego enviar un paquete de datos a la Frambuesa Pi si somos el maestro enjambre.
33
El listado 2-9. Código Interpretación LightSwarm de paquetes
si (packetBuffer [1] == RESET_SWARM_PACKET) {
Serial.println ( ">>>>>>>>> RESET_SWARM_PACKETPacket recibida"); masterState =

true;
Serial.println ( "Reset enjambre: Me acaba de convertirse en maestro (y todos los demás)!");
digitalWrite (0, LOW);
si (packetBuffer [1] == CHANGE_TEST_PACKET) {
Serial.println ( ">>>>>>>>> CHANGE_TEST_PACKET paquete recibido"); Serial.println (

"no implementado"); int i;
for (i = 0; i <PACKET_SIZE; i ++) {
si (i == 2) {
Serial.print ( "LPS [");

Serial.print (i); Serial.print ( "]
=");
Serial.println (packetBuffer [i]);
} Else {
Serial.print ( "LPS ["); Serial.print

(i); Serial.print ( "] = 0x");
Serial.println (packetBuffer [i], HEX); }
si (packetBuffer [1] == RESET_ME_PACKET) {
Serial.println ( ">>>>>>>>> RESET_ME_PACKET paquete recibido");
34
si (packetBuffer [2] == swarmAddresses [mySwarmID]) {
masterState = true;
Serial.println ( "Reset Me: Me acaba de convertirse en Maestro");
digitalWrite (0, LOW);
} Else {
Serial.print ( "Se busca #"); Serial.print

(packetBuffer [2]);
Serial.println ( "No yo - reinicio ignorado"); }
si (packetBuffer [1] == DEFINE_SERVER_LOGGER_PACKET) {
Serial.println ( ">>>>>>>>> DEFINE_SERVER_LOGGER_PACKET paquete recibido"); serverAddress

= Dirección IP (packetBuffer [4], packetBuffer [5], packetBuffer [6], packetBuffer [7]); Serial.print (
"Dirección del servidor recibido:"); Serial.println (serverAddress);
}
si (packetBuffer [1] == BLINK_BRIGHT_LED) {
Serial.println ( ">>>>>>>>> BLINK_BRIGHT_LED paquete recibido"); si (packetBuffer

[2] == swarmAddresses [mySwarmID]) {
tcs.setInterrupt (false); // true significa off, medios falsas en retardo (packetBuffer [4]
* 100);
tcs.setInterrupt (true); // true significa fuera, mediante falsas on} else {
Serial.print ( "Se busca #"); Serial.print

(packetBuffer [2]);
Serial.println ( "No yo - reinicio ignorado"); }
35
Serial.print ( "MasterStatus:"); si
(masterState == true) {
digitalWrite (0, LOW); Serial.print (

"MASTER"); }
else {
digitalWrite (0, HIGH);

Serial.print ( "esclavo"); }
Serial.print ( "/ cc ="); Serial.print

(clearColor); Serial.print ( "/ KS:");
Serial.println (serverAddress);
Serial.println ( "--------");
int i;
Serial.print ( "swarmAddress ["); Serial.print

(i); Serial.print ( "] =");
Serial.println (swarmAddresses [i]); }
Serial.println ( "--------");
broadcastARandomUpdatePacket ();
sendLogToServer ();
} // fin de bucle ()
Listado 2-10 se utiliza para enviar paquetes de luz a una dirección enjambre. A pesar de una dirección específica está
permitido por esta función, nos fijamos el último octeto de la dirección IP (201 en la dirección IP 192.168.1.201) en la función de
llamada al 255, que es la dirección de difusión UDP.
Listado 2-10. Transmitiendo al Swarm
// enviar un paquete de solicitud de LUZ a los enjambres en la dirección indicada

sendLightUpdatePacket largo sin signo (Dirección IP y dirección) {
// establecer todos los bytes en la memoria intermedia a 0 memset

(packetBuffer, 0, PACKET_SIZE); // valores necesarios para formar paquetes
Light // (ver dirección de arriba para más detalles sobre los paquetes)
Inicializar packetBuffer [0] = 0xF0; // StartByte
36
packetBuffer [1] = LIGHT_UPDATE_PACKET; // Tipo de Paquete

packetBuffer [2] = LocalIP [3]; // Número Envío Swarm
packetBuffer [3] = masterState; // 0 = esclavo, 1 = master packetBuffer [4] =
VersionNumber; // Software Version packetBuffer [5] = (clearColor y 0xFF00) >> 8; // Claro
alta Byte packetBuffer [6] = (clearColor y 0x00FF); // Despejado Low Byte packetBuffer [7] =
(redcolor y 0xFF00) >> 8; // Red de alta Byte packetBuffer [8] = (redcolor y 0x00FF); // Red
Byte bajo packetBuffer [9] = (Greencolor y 0xFF00) >> 8; // verde de alta Byte packetBuffer
[10] = (Greencolor y 0x00FF); // verde Byte bajo packetBuffer [11] = (bluecolor y 0xFF00) >>
8; // azul de alta Byte packetBuffer [12] = (bluecolor y 0x00FF); // azul Byte bajo
packetBuffer [13] = 0x0F; // Byte Fin
// valores han sido dados todos los campos del paquete de luz, ahora // puede
enviar un paquete que pide la coordinación
udp.beginPacketMulticast (dirección, localPort, WiFi.localIP ()); // udp.write (packetBuffer,
PACKET_SIZE); udp.endPacket (); }
// retardo segundo 0-MaxDelay

# definir MaxDelay 500
broadcastARandomUpdatePacket vacío () {
int sendToLightSwarm = 255; Serial.print ( "Broadcast

ToSwarm ="); Serial.print (sendToLightSwarm);
Serial.print (" ");
// retardo 0-MaxDelay segundo int

randomDelay;
randomDelay = aleatorio (0, MaxDelay);
Serial.print ( "Delay ="); Serial.print
(randomDelay); Serial.print ( "ms:");
retardo (randomDelay);
Dirección IP sendSwarmAddress (192, 168, 1, sendToLightSwarm); // Dirección mi Swarm
sendLightUpdatePacket (sendSwarmAddress);
37
En la función del Listado 2-11 , Puedo comprobar si sólo se convirtió en amo y también actualizar el
estado de todos los dispositivos LightSwarm. Aquí es donde se lleva a cabo la función de tiempo de espera que eliminará los
dispositivos obsoletos o muertas del enjambre.
Listado 2-11. Maestro Registro y Actualización
checkAndSetIfMaster vacío () {
int i;
# DEBUG ifdef
Serial.print ( "swarmClear ["); Serial.print (i);

Serial.print ( "] ="); Serial.print (swarmClear [i]);
Serial.print ( "swarmTimeStamp ["); Serial.print (i);
Serial.print ( "] =");
Serial.println (swarmTimeStamp [i]);

# terminara si
Serial.print ( "#");
Serial.print (i); Serial.print (
"/");
Serial.print (swarmState [i]); Serial.print (
"/");
Serial.print (swarmVersion [i]); Serial.print (
":"); // datos de edad
int howLongAgo = millis () - swarmTimeStamp [i];
si (swarmTimeStamp [i] == 0) {
Serial.print ( "A"); }
else if (swarmTimeStamp [i] == -1) {
Serial.print ( "NP"); }
else if (swarmTimeStamp [i] == 1) {
Serial.print ( "ME"); }
38
else if (howLongAgo> SWARMTOOOLD) {
Serial.print ( "A");
swarmTimeStamp [i] = 0;
swarmClear [i] = 0;
} Else {
Serial.print ( "PR");
}}
Serial.println (); setMaster boolean =

true;
si (swarmClear [mySwarmID]> = swarmClear [i]) {
// Yo podría ser el amo!
} Else {
// No, no dominar setMaster

= false; descanso; }
}
si (setMaster == true) {
si (masterState == false) {
Serial.println ( "Me acaba de convertirse en Maestro");

digitalWrite (0, LOW); }
masterState = true; }
39
else {
si (masterState == true) {
Serial.println ( "acabo de perder Maestro");

digitalWrite (0, HIGH); }
masterState = false; }
swarmState [mySwarmID] = masterState;
int setAndReturnMySwarmIndex (int incomingID) {
int i;
si (swarmAddresses [i] == incomingID) {
i volver; } else
si (swarmAddresses [i] == 0) // no en el sistema, por lo que lo puso en {
swarmAddresses [i] = incomingID; Serial.print

( "incomingID"); Serial.print (incomingID);
Serial.print ( "# asignado"); Serial.println (i); i
volver; }
// si hemos llegado hasta aquí, entonces tenemos un nuevo miembro de enjambre. //

Eliminar el miembro más antiguo enjambre y añadir la nueva en // (esto
probablemente será la que se retiró)
40
int oldSwarmID; largo

Oldtime; Oldtime = millis ();
si (Oldtime> swarmTimeStamp [i]) {
Oldtime = swarmTimeStamp [i];

oldSwarmID = i; }
// eliminar el viejo y poner éste en .... swarmAddresses [oldSwarmID] =

incomingID; // el resto se rellenará por paquetes Luz Recibir
// enviar el paquete de registro al servidor si amo y servidor de direcciones definido
sendLogToServer vacío () {
// crear la cadena
Char myBuildString [1000];

myBuildString [0] = '\ 0';
si (masterState == true) {
// Ahora comprobar la dirección del servidor definido

if ((serverAddress [0] == 0) && (serverAddress [1] == 0)) {
regreso; // hemos terminado. No definido} else {
// ahora enviar el paquete como una cadena con el siguiente formato: // swarmID, amo-,
Versión de software, clearColor, Estado | .... siguiente Swarm ID
// 0,1,15,3883, PR | 1,0,14,399, PR | ....
int i;
Char swarmString [20];
swarmString [0] = '\ 0';
41
Char stateString [5]; stateString [0] = '\

0'; si (swarmTimeStamp [i] == 0) {
strcat (stateString, "A"); }
else if (swarmTimeStamp [i] == -1) {
strcat (stateString, "NP"); }
else if (swarmTimeStamp [i] == 1) {
strcat (stateString, "PR"); } Else {
strcat (stateString, "PR"); }
sprintf (swarmString, "% i,% i,% i,% i,% s,% i", i, swarmState [i], swarmVersion [i],
swarmClear [i], stateString, swarmAddresses [i]);
strcat (myBuildString, swarmString); si (i

<SWARMSIZE - 1) {
strcat (myBuildString, "|");
}}
// establecer todos los bytes en la memoria intermedia a 0 memset

(packetBuffer, 0, BUFFERSIZE); // valores necesarios para formar paquetes
Light // (ver dirección de arriba para más detalles sobre los paquetes)
Inicializar packetBuffer [0] = 0xF0; // StartByte packetBuffer [1] =
LOG_TO_SERVER_PACKET;
// Tipo de Paquete
packetBuffer [2] = LocalIP [3]; // Número Envío Swarm
packetBuffer [3] = strlen (myBuildString); // longitud de cadena en bytes packetBuffer [4] =
VersionNumber; // Versión de software int i;
42
for (i = 0; i <STRLEN (myBuildString); i ++) {
packetBuffer [i + 5] = myBuildString [i]; // primero byte string}
packetBuffer [i + 5] = 0x0F; // Fin Byte Serial.print (

"Registro de envío de Sever:"); Serial.println
(myBuildString); int packetLength; packetLength = i + 5
+ 1;
udp.beginPacket (serverAddress, localPort); //
udp.write (packetBuffer, packetLength); udp.endPacket

();
Eso es todo el código del dispositivo LightSwarm. Al compilar el código en el IDE de Arduino dirigidas a la
Adafruit ESP8266, obtenemos lo siguiente:
Bosquejo utiliza 308,736 bytes (29%) de espacio de almacenamiento de programa. Máxima es 1,044,464 bytes.
Las variables globales usan 50,572 bytes (61%) de la memoria dinámica, dejando 31,348 bytes para variables locales.
Máxima es de 81,920 bytes.
Todavía un montón de espacio de la izquierda para obtener más código. La mayor parte del espacio de códigos se utilizan
compilado por encima de las bibliotecas del sistema de conexión Wi-Fi y ejecutar el ESP8266.
Comportamiento de auto-organización
¿Por qué decimos que el código LightSwarm es auto-organización? Se debe a que no existe un control central de quién
es el amo y quién es el esclavo. Esto hace que el sistema sea más fiable y capaz de funcionar incluso en un mal
ambiente. La auto-organización se define como un proceso en algún tipo de orden surge de las interacciones locales
entre los artículos más pequeños en un sistema inicialmente desordenada.
Por lo general este tipo de sistemas son robustos y capaces de sobrevivir en un entorno caótico. Los sistemas de
auto-organización se producen en una variedad de sistemas físicos, biológicos y sociales.
Una de las razones para construir este tipo de sistemas es que los dispositivos individuales pueden ser pequeñas y no muy
inteligente, y sin embargo, la tarea global o la imagen de que los datos sean recogidos y tratados pueden ser increíblemente interesante
e informativo.
43
Monitoreo y probar el sistema con la Frambuesa Pi (del

tipo inteligente en el bloque)
La Raspberry Pi se utiliza en LightSwarm principalmente como un dispositivo de almacenamiento de datos para examinar los
datos LightSwarm y contar lo que está pasando en el enjambre. Puede enviar algunos comandos para restablecer el enjambre,
encender las luces, etc., pero el enjambre se ejecuta en sí con o sin el funcionamiento Frambuesa Pi. Sin embargo, la depuración
de sistemas de auto-organización de este tipo son difíciles sin alguna forma de ver lo que está pasando con el enjambre,
preferentemente desde otro equipo. Y eso es lo que hemos hecho con el software LightSwarm Logger en la Raspberry Pi. Los
principales criterios de diseño para la siguiente manera: este software
• Leer e información sobre el comportamiento de enjambre de registro.
• Reproducir el comportamiento enjambre de archivo.
• Proporcionar métodos para las pruebas de comportamiento enjambre (como el restablecimiento del
enjambre).
• Proporcionar información en tiempo real a Internet en el comportamiento y el estado de enjambre.
Recuerde que el Raspberry Pi es un sistema completo, complejo y potente equipo que va mucho más allá de lo que
puede hacer con un ESP8266. En primer lugar vamos a ver el software de registro de LightSwarm y luego el software que
soporta el panel RasPiConnect LightSwarm. Nótese que no estamos almacenando la información procedente de los
dispositivos de enjambre en este software, pero fácilmente podríamos añadir software de registro que llenar una base de
datos MySQL que nos permita almacenar y analizar la información desde la nube.
LightSwarm software de registro escrito en Python

Toda la base de código del software LightSwarm registro está disponible fuera de la página APulse [sitio de código
APulse] y en los laboratorios de SwitchDoc sitio github [ github.com/switchdoclabs/ lightswarm_Pi]. Estoy recibiendo el
código más interesante en el software de registro para comentar y explicar.
En primer lugar, este programa está escrito en Python. Python es un lenguaje de programación ampliamente utilizado,
especialmente con codificadores Frambuesa Pi. Hay una serie de bibliotecas de dispositivos disponibles para la construcción de sus
propios dispositivos IOT y hay incluso una pequeña versión que se ejecuta en el ESP8266. filosofía de diseño de Python hace hincapié
en la legibilidad del código. Sangría es importante en Python, así que tenlo en cuenta cuando nos fijamos en el código de abajo.
■ Nota SwitchDoc Python es “tipos débiles”, es decir se define una variable y el tipo de la primera vez que lo utilice. Algunos
programadores de este tipo, pero no lo hago. Escribir incorrectamente el nombre de una variable hace que una variable
totalmente nueva y puede causar una gran confusión. Mi perjuicio es hacia lenguajes “inflexible”, ya que tiende a reducir el
número de errores de codificación, a costa de tener que pensar y declarar variables explícitamente.
44
La primera sección de este programa define todas las librerías necesarias (declaraciones de importación) y define
necesarias “constantes”. Python no tiene una forma de definir constantes, por lo que declarar las variables para los valores
constantes, que por mi convención están todos en mayúsculas. Hay otras formas de definir las constantes mediante el uso de
clases y funciones, pero son más complejo que la simple definición de otra variable. Listado 2-13 muestra cómo se inicializan
las variables y constantes.
El listado 2-13. La importación y la declaración de valor constante
'''
LightSwarm Frambuesa Pi Logger SwitchDoc
laboratorios de septiembre de 2015 '''
import sys importar

importar tiempo
aleatorio
netifaces de interfaces de importación, ifaddresses, AF_INET
de la toma de importación *
VersionNumber = 6
# definiciones de tipo de paquete
LIGHT_UPDATE_PACKET = 0
RESET_SWARM_PACKET = 1
CHANGE_TEST_PACKET = 2 # No implementado
RESET_ME_PACKET = 3
DEFINE_SERVER_LOGGER_PACKET = 4
LOG_TO_SERVER_PACKET = 5
MASTER_CHANGE_PACKET = 6
BLINK_BRIGHT_LED = 7
MYPORT = 2910
SWARMSIZE = 5
Listado 2-14 define la interfaz entre el software LightSwarm Logging y el software de panel de control
RasPiConnect [ www.milocreek.com ]. El autor ha escrito un tutorial sobre esto estructura de mando de
paso en MAGPI reimpreso en la revista Labs sitio web SwitchDoc [ www.switchdoc.com/2014/07/build-control-panels-tut
] . Estas son las tres funciones importantes:
• processCommand (s) - Cuando se recibe un comando del software de servidor

RasPiConnect se ejecuta en el mismo equipo, esta función define todas las
acciones que se completará cuando se recibe un comando específico de
RasPiConnect.
45
• completeCommandWithValue (valor) - llame a la función y devuelve un valor de

RasPiConnect cuando haya completado un comando.
• CompleteCommand () - función de llamada cuando haya completado un comando para contar

RasPiConnect que haya terminado con el comando. Básicamente, la idea es que cuando se pide una actualización
de datos o empujar un botón en el panel de control RasPiConnect, el software de servidor RasPiConnect envía una
orden al software de registro de LightSwarm que se ejecuta en un hilo diferente en el mismo sistema. Recuerde que
el sistema basado en Linux Frambuesa Pi es multitarea y puede ejecutar muchos programas diferentes a la vez.
Listado 2-14. Código RaspiConnect
logString = ""
# comando de ejecución de código RasPiConnect
def CompleteCommand ():
f = open ( "/ home / pi / LightSwarm / estado / LSCommand.txt", "w")

f.write ( "DONE")
f.close ()
def completeCommandWithValue (valor):
f = open ( "/ home / pi / LightSwarm / estado / LSResponse.txt", "w")

f.write (valor)
de impresión "en completeCommandWithValue =", el valor
f.close ()
CompleteCommand ()
def processCommand (s):

f = open ( "// Inicio / pi / LightSwarm / estado / LSCommand.txt", "r") de comando =
f.read ()
f.close ()
si (comando == "") o (comando == "DONE"):

# Nada que ver return
false
# Comprobar si nuestros comandos
print "Comando de procesamiento:", comando si (==

comando "ESTADO"):
completeCommandWithValue (logString)
devolver True
46
si (== comando "RESETSWARM"):
SendRESET_SWARM_PACKET (s)
CompleteCommand ()
devolver True
# comprobar si hay comandos,
imprimir "=% s" comando% myCommandList =

command.split ( '') print "myCommandList =",
myCommandList
si (myCommandList.count> 1):
# tenemos una lista de comandos
si (myCommandList [0] == "BLINKLIGHT"):

SendBLINK_BRIGHT_LED (s, int (myCommandList [1]), 1)
si (myCommandList [0] == "RESETSELECTED"):

SendRESET_ME_PACKET (s, int (myCommandList [1]))
si (myCommandList [0] == "SENDSERVER"):

SendDEFINE_SERVER_LOGGER_PACKET (s)
CompleteCommand ()
devolver True
CompleteCommand ()
falso retorno
en el Listado 2-15 , Tengo las implementaciones de mandatos LightSwarm reales para enviar
paquetes. Listado 2-15 simplemente muestra la primera de tipo de paquete para ilustrar los conceptos.
El listado 2-15. Swam luz de comandos de paquetes Definiciones
# UDP Comandos y paquetes
def SendDEFINE_SERVER_LOGGER_PACKET (s):

print "DEFINE_SERVER_LOGGER_PACKET Sent"
s.setsockopt (SOL_SOCKET, SO_BROADCAST, 1)
47
# obtener la dirección IP
para ifaceName en las interfaces ():
direcciones = [i [ 'addr'] para i en ifaddresses (ifaceName). setdefault
(AF_INET, [{ 'dir': 'No dir IP'}])] print '% s:% s' % (ifaceName, '' .join
(direcciones))
# Interfaz pasado (wlan0) agarró direcciones de

impresión
MyIP = direcciones [0] .split ( '') MyIP de
impresión
= Datos [ "" para i en el rango de (14)]
datos [0] = chr (0xF0)

datos [1] = chr (DEFINE_SERVER_LOGGER_PACKET)
datos [2] = chr (0xFF) # enjambre id (FF no significa parte de enjambre) de datos [3] = chr
(VersionNumber)
datos [4] = chr (int (MyIP [0])) # primer octeto de datos de IP [5] = chr
(int (MyIP [1])) # segundo octeto de datos de IP [6] = chr (int (MyIP
datos [2])) # tercer octeto de datos de IP [7] = chr (int (MyIP [3])) #
cuarto octeto de datos de IP [8] = chr (0x00) [9] = chr (0x00) datos [ 10]
de datos = chr (0x00) de datos [11] = chr (0x00) [12] = chr (0x00) de
datos [13] = chr (0x0F)
s.sendto ( ''. join (datos), ( '<broadcast>', MYPORT))
La siguiente sección del código para ser discutido es el mapa en línea, que es utilizado por el control de la tela
RasPiConnect para mostrar código HTML. El código del Listado 2-16 produce figura 2-12 .
Figura 2-12. Control web HTML en RasPiConnect Producido por Web del código del mapa en el software de registro
LightSwarm
48
El listado 2-16. página Web del Código de Construcción
# construir Mapa web
def buildWebMapToFile (logString, swarmSize):
f = open ( "/ home / pi / RasPiConnectServer / Plantillas / W-1a.txt", "w")
WebResponse = ""
swarmList = logString.split ( "|") para i en el

rango (0, swarmSize):
swarmElement = swarmList [i] .split ( "") print
"swarmElement =", swarmElement WebResponse + =
"<figure>" WebResponse + = "<figcaption"
WebResponse + = "style = 'position: absolute; top:" WebResponse + =

str (100-20) WebResponse + = "px; izquierda:"
+ str (20 + 120 * i) + "px; '/> \ n" si (int

(swarmElement [5]) == 0):
WebResponse + = "& nbsp; & nbsp; & nbsp & nbsp; & nb sp; ---" otra
cosa:
WebResponse + = "& nbsp; & nbsp; & nbsp; & nbsp; & nbs p; & nbsp;%
s" % swarmElement [5]
WebResponse + = "</ figcaption>"

WebResponse + = "<img src = '" + "192.168.1.40:9750"
si (swarmElement [4] == "PR"):

si (swarmElement [1] == "1"):
WebResponse + = " 'style =' /static/On-Master.png
posición: absolute; top:" else:
WebResponse + = " 'style =' /static/On-Slave.png

posición: absolute; top:"
más:
si (swarmElement [4] == "A"):
WebResponse + = "/ /-timeout Off estática png
posición '= estilo': absolute; top:"
49
más:
WebResponse + = " 'style ='
/static/OffNotPresent.png posición: absolute;
top:"
WebResponse + = str (100)

WebResponse + = "px; izquierda:"
+ str (20 + 120 * i) + "px; '/> \ n"
WebResponse + = "<figcaption"
WebResponse + = "style = 'position: absolute; top:" WebResponse + =
str (100 + 100) WebResponse + = "px; izquierda:"
+ str (20 + 120 * i) + "px; '/> \ n" si

(swarmElement [4] == "PR"):
si (swarmElement [1] == "1"):
WebResponse + = "& nbsp; & nbsp; & nbsp; & nbsp;
Maestro" otra cosa:
WebResponse + = "& nbsp; & nbsp; & nbsp; & n bsp; &
nbsp; Slave"
más:
si (swarmElement [4] == "A"):
WebResponse + = "Tiempo de espera"
más:
WebResponse + = "No Presente"
WebResponse + = "</ figcaption>"
WebResponse + = "</ figura>"
# WebResponse de impresión
f.write (WebResponse)
f.close ()
Listado 2-17 mira a los ID enjambre entrantes y construye una tabla actual de hacer coincidir los ID, la eliminación de los viejos
cuando se añaden otros nuevos. El número máximo de dispositivos enjambre que puede tener es de cinco, pero se puede aumentar
fácilmente.
50
Listado 2-17. Código Análisis enjambre entrante
def setAndReturnSwarmID (incomingID):
para i en el rango (0, SWARMSIZE):

si (swarmStatus [i] [5] == incomingID):
i volver
más:
si (swarmStatus [i] [5] == 0): # no en el sistema, por lo que lo puso en
swarmStatus [i] [5] = incomingID; print

"incomingID% d" % de impresión incomingID
"asignado #% d" % i Regrésame
# Si hemos llegado hasta aquí, entonces tenemos un nuevo miembro de enjambre.

# Eliminar el miembro más antiguo enjambre y añadir la nueva en
# (Esto probablemente va a ser el que se retiró)
Oldtime = time.time ();

oldSwarmID = 0
si (Oldtime> swarmStatus [i] [1]):
Oldtime = swarmStatus [i] [1]
oldSwarmID = i
# eliminar el viejo y poner éste en .... swarmStatus

[oldSwarmID] [5] = incomingID;
# el resto será rellenado por paquetes Luz Recibe impresión
"oldSwarmID% i" % oldSwarmID
volver oldSwarmID
Por último, el Listado 2-18 es el código principal para el programa Python. Es muy similar en función al código de
configuración () para el ESP8266 en el IDE de Arduino. Lo utilizamos para definir variables, enviar comandos de una sola
vez, y configurar la interfaz UDP.
El listado 2-18. LightSwarm Código de inicio Logger
# creados enchufes para UDP
s = socket (AF_INET, SOCK_DGRAM)

host = 'localhost';
s.bind (( '', MYPORT))
51
print "--------------" imprimir "LightSwarm

Logger" imprimir "Versión", VersionNumber
de impresión "--------------"
# primero enviar DEFINE_SERVER_LOGGER_PACKET enjambre de decir dónde enviar la información de

registro
time.sleep (3)
# swarmStatus
swarmStatus = [[0 para x en el rango de (6)] para x en el rango (SWARMSIZE)]
# 6 artículos por artículo enjambre
# 0 - NP no presente, P = presente, A = tiempo de espera

# 1 - fecha y hora de la última LIGHT_UPDATE_PACKET recibido
# 2 - maestro o esclavo de estado EM
# 3 - Corriente de prueba de artículos - 0 - 1 CC - Lux 2 - Red 3 - Verde 4 - Azul
# 4 - actual Dirección de prueba 0> = 1 <=
# 5 - Dirección IP del enjambre

swarmStatus [i] [0] = "NP"
swarmStatus [i] [5] = 0
# 300 segundos ronda

seconds_300_round = time.time () + 300,0
# 120 segundos ronda

seconds_120_round = time.time () + 120. 0
CompleteCommand () # Sistema es decir RasPiConnect - borrar los comandos de edad
Listado 2-19 proporciona el bucle principal del programa. Tenga en cuenta que esto es muy similar a la función loop () en el
ESP8266. En este código, comprobamos los paquetes UDP entrantes, proceso RasPiConnect comandos, información de estado de
actualización, y ejecutar comandos periódicos. Es en este bucle que estaríamos almacenando el estado del enjambre, los paquetes,
y la información si queríamos reproducir el comportamiento enjambre archivally.
52
Listado 2-19. Frambuesa Pi registrador principal Loop
mientras que (1):
# recibir datclient (datos, addr) d = s.recvfrom

(1024)
mensaje = d [0] addr

= d [1]
si (len (mensaje) == 14):
si (ord (mensaje de [1]) == LIGHT_UPDATE_PACKET):
incomingSwarmID = setAndReturnSwarmID (ord (mensaje [2])) swarmStatus
[incomingSwarmID] [0] = "P" swarmStatus [incomingSwarmID] [1] = time.time
()
si (ord (mensaje de [1]) == RESET_SWARM_PACKET):

imprimir "Swarm RESET_SWARM_PACKET Recibidas"
imprimir "recibido de dir:", dir
si (ord (mensaje de [1]) == CHANGE_TEST_PACKET):

imprimir "Swarm CHANGE_TEST_PACKET Recibidas"
si (ord (mensaje de [1]) == RESET_ME_PACKET):

imprimir "Swarm RESET_ME_PACKET Recibidas"
si (ord (mensaje de [1]) == DEFINE_SERVER_LOGGER_PACKET):

imprimir "Swarm DEFINE_SERVER_LOGGER_PACKET Recibidas"
si (ord (mensaje de [1]) == MASTER_CHANGE_PACKET):

imprimir "Swarm MASTER_CHANGE_PACKET Recibidas"
para i en el rango de (0,14):

impresión "ls [" + str (i) + "] =" + formato (ord (mensaje [i]), "#
04x")
más:
si (ord (mensaje de [1]) == LOG_TO_SERVER_PACKET):
imprimir "Swarm LOG_TO_SERVER_PACKET recibido"
# procesar el registro de paquetes logString =

parseLogPacket (mensaje) buildWebMapToFile (logString,
SWARMSIZE)
más:
impresión "longitud de mensaje de error =", Len (mensaje)
53
si (time.time ()> seconds_120_round):

# hacer nuestra impresión 2 minutos redonda ">>>> haciendo
120 segundos tarea" SENDTO = random.randint (0,
SWARMSIZE-1) SendBLINK_BRIGHT_LED (s, SENDTO, 1)
seconds_120_round = time.time () + 120,0
si (time.time ()> seconds_300_round):

# hacer nuestra impresión de la ronda 2 minuto ">>>> haciendo
300 segundos tarea" SendDEFINE_SERVER_LOGGER_PACKET
(s) = seconds_300_round time.time () + 300,0
processCommand (s)
# imprimir swarmStatus
A continuación, voy a mirar partes del código del servidor RasPiConnect.
El Panel de Control en Tiempo Real RasPiConnect

RasPiConnect (y la versión Arduino, ArduinoConnect) es un software diseñado para el IPAD y el iPhone para la construcción de
paneles de control habilitados para Internet que conectan a las computadoras pequeñas. Está diseñado para ser ligero en la
memoria y el uso del procesador. Tiene servidores creados previamente en Python para la Frambuesa Pi (en realidad cualquier tipo
de equipo que ejecuta Python) y en C / C ++ para uso en el IDE Arduino. Fácilmente podríamos implementar una versión que se
ejecuta en el EPS8266 y un plan para hacer que en un proyecto de futuro. Usted puede hacer diseños de interfaces complejas
utilizando RasPiConnect. Considere la pantalla en la figura 2-13 mostrando una de las seis pantallas utilizadas en ProjectCuracao,
un proyecto de energía solar de detección masiva del medio ambiente se ejecuta de forma remota en la isla caribeña de Curazao [ www.switchdoc.com/proje
].
54
Figura 2-13. Panel de control del proyecto Curacao RasPiConnect - página principal
Figura 2-14 muestra la LightSwarm RasPiConnect panel de control en funcionamiento. El panel de control muestra que hay
actualmente 3 dispositivos LightSwarm activos con 125 siendo el principal (con las luces brillantes), mientras que los otros son
esclavos. Puede enviar una variedad de comandos al enjambre, como el restablecimiento de un dispositivo específico enjambre, luces
parpadeantes en un dispositivo enjambre, o el reinicio de todo el enjambre.
55
Figura 2-14. Panel de control LightSwarm RasPiConnect
Todos los archivos de software y de configuración del servidor de aplicaciones de Apple RasPiConnect y están en el
sitio de descarga APulse [El sitio de Apress] y en el sitio de GitHub SwitchDoc laboratorios
[github.com/switchdoclabs/lightswarm_RasPiConnect]
El software de servidor RasPiConnect es bastante sencillo. Hay un excelente tutorial para
personalizar el software de servidor en el sitio web MiloCreek [ www.milocreek.com/wiki ] .
A modo de ejemplo, el listado 2-20 es el código (que se encuentra en Local.py) para el botón de reinicio Swarm (como se
ve en la figura 2-14 ) Y también el código para establecer el segundo desde la pantalla del medidor justo en el panel de control
LightSwarm.
El listado 2-20. Local.py Archivo de Código RasPiConnect para Reset Button Swarm
# Restablecer Swarm
si (objectServerID == "B-4"):
# comprobar si hay solicitud de validación

# Validar permite RasPiConnect para verificar este objeto es aquí
56
si (== validar "SÍ"):

outgoingXMLData + = Validate.buildValidateResponse ( "SÍ") outgoingXMLData
+ = BuildResponse.buildFooter () devuelven outgoingXMLData
# respuesta solicitada Answ normales =

"OK"
# Resp = ""
si (Config.debug ()):
impresión "En B-4 local" de impresión (
"Resp =% s" % Resp)
sendCommandToLightSwarmAndWait ( "RESETSWARM")
ResponseData = "OK"
outgoingXMLData + = BuildResponse.buildResponse (ResponseData) outgoingXMLData

si (objectServerID == "M-1"):
# comprobar si la solicitud de validación

(validar == "SÍ"):
+ = BuildResponse.buildFooter ()
volver outgoingXMLData
tratar:
f = open ( "/ home / pi / LightSwarm / estado / LSStatus.txt", "r") logString =
f.read ()
f.close ()
excepto:
logString = ""
ResponseData = "% 3.2f" % logString.count ( "PR") print "% s =% s"

% (objectServerID, ResponseData)

57
resultados
He construido un LightSwarm que consta de cinco dispositivos enjambre individuales. El enjambre se puede ver en la figura 2-15 .
Figura 2-15. El enjambre Luz
Por último, algunos resultados de los dispositivos se muestran en el Listado 2-21 . En primer lugar es el
salida de depuración de serie de un dispositivo de LightSwarm. En primer lugar se inicializa el dispositivo, recibe una dirección IP
del punto de acceso WiFi (llamado Gracie en este caso), y luego comienza la escucha y el envío de paquetes. El dispositivo es
enjambre dispositivo # 125 y recibe paquetes de
# 123 y # 122, pero se mantuvo el maestro como el CC (color claro) de # 125 es 2,610, mientras que los paquetes entrantes
desde # 123 y # 122 tenían valores de CC de 310 y 499, respectivamente, y dos eran esclavos.
58
Listado 2-21. Los resultados de LightSwarm IOT de dispositivos se ejecutan en ESP8266
--------------------------
LightSwarm
Versión 27
--------------------------
09/03/2015
Compilado en: 21: 30: 47 16 de septiembre 2015
analogRead (A0) = 98 44
sensor encontrado
LightSwarm Instancia: 0
Conexión a Gracie
..........................
Wi-Fi conectada
dirección IP:
A partir 192.168.1.125
UDP Puerto local: 2910
clearColor = 0 = 0
MySwarmID
Temperatura de color: 2390 K - Lux: 630 - R: 1188 G: 848 B: 440 C: 2,610 packetbuffer [1]
=0
LIGHT_UPDATE_PACKET recibió de LightSwarm # 123 # 123
incomingID asignado 1
LS paquetes Recibido desde el # 123 SwarmState: ESCLAVO CC: 310 RC: 119 GC: 116 aC: 69 Versión = 27
# 0/1/27: ME # 1/0/27: PR # 2/0/0: NP # 3/0/0: NP # 4/0/0: NP MasterStatus:

MAESTRO / cc = 2610 / KS: 0,0 .0.0
--------
swarmAddress [0] = 125
--------
Broadcast ToSwarm = 255 delay = 121ms: Temp del color: 2390 K - Lux: 630 - R: 1188 G: 848 B: 440 C:
2,610 packetbuffer [1] = 0
LIGHT_UPDATE_PACKET recibió de LightSwarm # 122 # 122

incomingID asignado 2
LS de paquetes Recieved desde el # 122 SwarmState: SLAVE CC: 499 RC: 231 GC: 182 BC: 98 Version = 27
# 0/1/27: ME # 1/0/27: PR # 2/0/27: PR # 3/0/0: NP # 4/0/0: NP MasterStatus:

MAESTRO / cc = 2610 / KS: 0,0 .0.0
--------
59

--------
Listado 2-22 es la salida del software de registro de Frambuesa Pi LightSwarm. Lo primero que el software de registro
hace es enviar un “DEFINE_SERVER_LOGGING_ PAQUETE” para decir a los dispositivos enjambre la dirección IP
(1.168.1.40) del servidor por lo que el maestro enjambre puede enviar paquetes de registro directamente a la Frambuesa Pi,
en lugar de utilizar los ya concurridos puertos de difusión UDP. Por último, vemos un paquete que viene de SwarmID # 111.
Número 111 recogió la dirección del servidor, y ya que era el maestro del enjambre, que comenzó a enviar en paquetes de
registro a la Frambuesa Pi. Nota de los resultados del registro, parece que
# 111 es un dispositivo enjambre solitario, sin amigos cercanos.
Listado 2-22. La salida de Frambuesa Pi LightSwarm Logger
--------------
LightSwarm Logger
Version 6
--------------
DEFINE_SERVER_LOGGER_PACKET Sent
lo: eth0 127.0.0.1: No wlan0 dir IP: 192.168
. 1.40
[ '192.168.1.40']
[ '192', '168', '1', '40']
DEFINE_SERVER_LOGGER_PACKET
Enviados lo: eth0 127.0.0.1: No addr IP wlan0:
192.168.1.40 [ '192.168.1.40']
[ '192', '168', '1', '40']

Swarm DEFINE_SERVER_LOGGER_PACKET recibidas
Recibidas por addr: 192.168.1.40 ( '', 2910) incomingID 111 #
asignado 0
Swarm LOG_TO_SERVER_PACKET Registro recibido

Desde SwarmID: 111 enjambre Software Version: 28
StringLength: 80
logString: 0,1,28,1672, PR, 111 | 1,0,0,0, NP, 0 | 2,0,0,0, NP, 0 | 3,0,0,0, NP, 0 | 4,0,0,0, NP, 0
swarmElement = [' 0' , '1', '28', '1672', 'PR' ' 111 '] swarmElement = [' 1', '0',
'0', '0', 'NP', '0 '] swarmElement = [' 2', '0', '0', '0', 'NP', '0']
60
swarmElement = [' 3' , '0', '0', '0', 'NP', '0 '] swarmElement = [' 4', '0',
'0', '0', 'NP', '0 '] swarmElement = [' 3', '0', '0', '0', 'NP', '0 ']
swarmElement = [' 4', '0', '0', '0', 'NP', '0']
¿Qué más se puede hacer con esta arquitectura?

La arquitectura LightSwarm es flexible. Puede cambiar el sensor, añadir más sensores, y poner en algoritmos más
sofisticados para el comportamiento enjambre. en el capítulo 5 , Extendemos esta arquitectura a un comportamiento
más complejo enjambre, de hecho cambiar algunos del entorno físico de los dispositivos de enjambre.
Conclusión
Una buena parte de la IOT será la reunión de pequeñas cantidades simples, de los datos; algunos análisis sobre los datos; y la
comunicación de que los datos a los servidores de acción y su posterior análisis en Internet. Los proyectos en los capítulos 3
y 4 son de dispositivos IOT más complejas reuniendo las porciones de datos, procesamiento de ella, que actúan sobre los
datos, y la comunicación de los resúmenes a Internet. El LightSwarm hace de manera diferente porque los elementos
enjambre son simples y cooperan sin un controlador central para determinar quién tiene la luz más brillante y luego actuar en
esa información (girando el LED rojo).
Enjambres de dispositivos IOT se pueden hacer a bajo costo, puede exhibir un comportamiento complejo inesperado, y ser
diabólicamente difíciles de depurar.
61
CAPÍTULO 3
La construcción de una estación

meteorológica accionada solar IOT
Capítulo Objetivo: recopilación de datos y transmisión de datos a través de Internet los temas tratados en
este capítulo:
• ¿Cómo construir un sistema de tiempo con energía solar IOT (figura 3-1 )
• Cómo diseñar y tamaño de los paneles y las baterías
• Cómo recopilar datos para analizar el rendimiento del sistema
• Cómo cablear un Frambuesa Pi a un sistema de energía solar
• Cómo dar vuelta con seguridad un Frambuesa Pi de encendido y apagado
• ¿Cómo construir las piezas impresas en 3D para IOTWeatherPi
• Cómo conectar la estación meteorológica de la IOT (Tweets, textos y CWOP)

CAPÍTULO 3 ■ CONSTRUCCIÓN DE UNA POTENCIA ESTACIÓN METEOROLÓGICA IOT SOLAR
La Figura 3-1. Descripción general de la estación
Todo el mundo habla del tiempo. En este capítulo, vamos a hablar del tiempo con mucho más
detalle que sólo la temperatura.
En el capítulo anterior, nos fijamos en la construcción de aparatos sencillos IOT que medir la temperatura y
compartir esa información con un servidor y otros dispositivos IOT. Era una sencilla aplicación, pero todavía ilustra una
serie de conceptos importantes. En este capítulo, estamos construyendo un proyecto mucho más complejo y flexible
basado en el uso de la Frambuesa Pi como parte del dispositivo IOT.
El IOTWeatherPi no sólo reúne a trece tipos diferentes de datos meteorológicos, que también supervisa e informa de
su propio estado, el estado y la salud.
64

Como ya os comentamos en el capítulo 1 , Lo primero que hay que hacer para entender un proyecto IOT es mirar a nuestros seis
diferentes aspectos de IOT. IOTWeatherPi es un producto complejo, pero la tabla 3-1 se descompone en nuestros seis componentes.
Tabla 3-1. IOTWeatherPi Caracterización (CPLPFC)
comunicaciones 9 conexión WiFi a Internet - puede hacer AdHoc

comunicación de tipo malla y Bluetooth
procesador Power 7 Frambuesa Pi A + / 256 MB de RAM
Local Almacenamiento 8 8 GB de tarjeta SD
El consumo de energía 2 ~ Consumo 200mA - No es razonable para pequeñas

baterías
funcionalidad 8 sistema basado en Linux completo. MySQL, etc.
Costo 2 Caro para muchas aplicaciones. Junta es ~ $ 25
Las calificaciones son del 1-10, siendo 1 el menos adecuado para IOT y 10 es la más adecuada para aplicaciones de IO. Esto
nos da una calificación de 6. Gran CPLPFC para el aprendizaje, no tan bueno para el despliegue para la mayoría de aplicaciones.
Sin lugar a dudas, la Frambuesa Pi es una plataforma muy flexible y potente IOT. Sin embargo, el consumo de energía,
el costo y el tamaño físico del dispositivo hacen que sea más adecuado para la creación de prototipos o para el autónomo,
unidades IOT altamente funcionales.

Con IOTWeatherPi, tenemos una gran cantidad de opciones. Podemos conectar a Internet utilizando el conector WiFi. Podemos
utilizar el bluet ooth para conectar a dispositivos locales y también se puede utilizar la conexión Wi-Fi en modo ad hoc para hacer
conexiones locales. En este capítulo, vamos a utilizar la interfaz WiFi para hablar con el mundo más amplio de dispositivos IOT.
La recolección de datos
El IOTWeatherPi utiliza trece sensores diferentes para detectar conexiones climáticas. Porque yo estoy usando un Frambuesa Pi y tengo
buenos mecanismos de almacenamiento y espacio en disco, utilizo una base de datos MySQL para almacenar todos los datos del tiempo
para el análisis futuro y descarga. También usamos matplotlib para construir gráficos y utilizar una aplicación para iOS llamada
RasPiConnect para mostrar la información a través de Internet.
sesenta y cinco
El proyecto - IOTWeatherPi
WeatherPi es una energía solar Frambuesa Pi Wi-Fi conectado estación meteorológica diseñada para su uso en la IOT por la
compañía del autor. Este es un gran sistema para construir y jugar con. Todo es modificable y se incluye todo el código fuente.
Las siguientes son las funciones más importantes:
• Detecta veinte valores ambientales diferentes
• Completamente con energía solar
• Tiene una base de datos completa que contiene la historia del medio ambiente (MySQL)
• Monitores e informes de datos en el sistema de energía solar - grande para la educación!
• Autónomo y supervisado por caídas de tensión y problemas de energía
• Puede ser modificado de forma remota
• Descargar sus datos para crujir en su PC
• Puede ser modificado para hacer SMS (texto) de mensajería, Twitters, páginas web, y más
• Tiene un panel de control iPad-Based
• Se puede conectar a la IOT a través de Twitter, mensajes de texto, correo electrónico y conexión Wi-Fi Este
capítulo le mostrará cómo construir una conexión Wi-Fi con energía solar Frambuesa Pi de la estación meteorológica. Este
proyecto surgió a partir de una serie de otros proyectos, como la masiva Proyecto Curacao [ www.switchdoc.com/project-curacao-introduction-part-1/
] , un sistema de energía solar de vigilancia ambiental desplegado en la isla tropical del Caribe de Curazao. Proyecto Curacao fue
escrito en una extensa serie de artículos en MAGPI revista (comenzando en el número 18 y continuando a través de emisión 22).
La estación meteorológica Desarrollado IOTWeatherPi solar es un proyecto de educación excelente. Hay

muchos aspectos de este proyecto que puede ser visto y analizado con fines educativos:
• ¿Cómo se comportan los sistemas de energía solar? Limitaciones y ventajas.
• Temperatura, viento, y el análisis de datos de humedad.
• Apagado y puesta en marcha de pequeños ordenadores con energía solar.
• Añadir sus propios sensores de UV, el polvo y la cantidad de polen, y el color de la luz. Figura 3-2 muestra
cómo IOTWeatherPi está conectado a la IOT mientras que la figura 3-3
describe los principales bloques en el proyecto.
66
La Figura 3-2. Diagrama de bloques de WeatherPi y la IOT
Figura 3-3. Diagrama de bloques de IOTWeatherPi
67
Cómo funciona todo esto
El Diagrama de bloques IOTWeatherPi parece mucho más complicado de lo que realmente es.
La primera cosa a notar es que las líneas discontinuas son tablas individuales (WeatherPiArduino y
SunAirPlus), que contienen una gran parte del diagrama de bloques; y la segunda es que todos los sensores a
la izquierda de la clavija de diagrama en la placa WeatherPiArduino, lo que simplifica el cableado. No se deje
intimidar!
los subsistemas
El subsistema de alimentación de IOTWeatherPi utiliza un SunAirPlus [ www.switchdoc.com/
sunairplus-solar-power-controllerdata de colector / ] Regulador de la energía solar que se encarga de los paneles
solares, la carga de la batería, y luego suministra la 5V a la Frambuesa Pi y el resto del sistema. También contiene
sensores que le dirá la corriente y la tensión producida por los paneles solares y consumido por las baterías y el
Raspberry Pi. Recopilar esos datos! Figura 3-4 muestra la placa del cargador solar y el paquete de baterías montado en
la parte superior del recinto. Figura 3-5 muestra las células solares en la parte superior del exterior del recinto.
La Figura 3-4. Regulador de la energía solar
68
Figura 3-5. Células solares
También contiene el temporizador de vigilancia de hardware y la PowerControl USB que en realidad se apaga la
alimentación de la Frambuesa Pi durante un evento de caída de tensión (después del Pi cierra con gracia hacia abajo bajo control
de software).
El Subsistema Sensor de IOTWeatherPi utiliza un WeatherPiArduino [ www.switchdoc. com / weatherpiarduino-desnuda de
a bordo / ] como la unidad de base y luego se enchufa en un montón de sensores opcionales, tales como Velocidad del viento /
dirección / lluvia , Detección de rayos (cómo es fresco es que!), Dentro y fuera de la temperatura y la humedad. Figura 3-6 Los
cuadros de los sensores de viento y lluvia.
69
Figura 3-6. Los sensores de viento / lluvia
los subsistema de software de IOTWeatherPi corre en Python en la Raspberry Pi. Recoge los datos, las tiendas
en una base de datos MySQL, construye gráficos, y hace la limpieza y el poder de supervisión.
El sensor detecta IOTWeatherPi Suite de los siguientes valores ambientales:
• Velocidad del viento
• Dirección del viento
• Lluvia
70
• Temperatura exterior
• Humedad fuera
• Detección de Rayos
• Presión barométrica (y altitud)
• Dentro de la caja de Temperatura
• Dentro de la caja de Humedad
Puede añadir más al bus I2C y Convertidor Analógico a Digital tal como UV, los recuentos de polvo, de color claro (detección
de algunos tipos de contaminación), y mucho más! Es una gran plataforma para la expansión.
La suite sensor está construido sobre la WeatherPiArduino (mostrado en la figura 3-7 ) Bordo, pero
hay varios tableros similares que hay en el mercado.
Figura 3-7. WeatherPiArduino
El bus I2C
WeatherPi hace un amplio uso del bus I2C en la Raspberry Pi.
En SwitchDoc Labs, nos encanta datos. Y nos encanta dispositivos I2C. Nos gusta para recoger los datos utilizando una
gran cantidad de dispositivos I2C en nuestros ordenadores y proyectos. Proyecto Curacao tiene un total de doce, IOTWeatherPi
tiene once dispositivos, y Sunrover (a potencia IOT solar conectado robot en desarrollo en SwitchDoc) tendrá más de veinte y
requerirá un bus I2C
71
sólo para controlar los motores. Siempre nos estamos quedando en conflictos con direccionamiento en el dispositivo I2C. Dado
que no existen normas, a veces múltiples dispositivos tienen la misma dirección, como por ejemplo 0x70; y que está justo fuera de
suerte en el funcionamiento de los dos en el mismo bus I2C sin un montón de Jimmy aparejo. Figura 3-8 Mux I2C muestra el
cableado en el proyecto.
La Figura 3-8. I2CMux en IOTWeatherPi
72
Para solucionar este problema de direccionamiento (y nuestro conflicto con un INA3221 y el sensor dentro de humedad)
añadimos un bus I2C multiplexor al diseño, lo que nos permite disponer de muchos más dispositivos I2C en el autobús,
independientemente de los conflictos de direccionamiento. Mesa 3-2
proporciona una lista de dispositivos I2C en IOTWeatherPi.
Tabla 3-2. Las direcciones I2C en IOTWeatherPi
Dispositivo Dirección I2C
Presión BMP180 o BMP280 barométrica 0x77
Reloj en tiempo real DS3231 0x68
EEPROM ATC 0x56
ADS1015 Convertidor Analógico a Digital 0x49
almacenamiento FRAM no volátil 0x50
ADS1015 en SunAirPlus 0x48
INA3221 3 canales de tensión / Monitor de corriente en SunAirPlus 0x40
Sensor de humedad HTU21D-F 0x40
Embedded detector de rayos aventuras 0x03
AM2315 al aire libre Temperatura / Humedad 0x5C
I2C 4 canales del bus I2C Mux 0x73
Lo que sigue es lo que el bus I2C se ve como en la Raspberry Pi. Hay cuatro buses independientes que se muestran para
el bus I2C, pero tenga en cuenta que sólo utiliza IOTWeatherPi Bus 0 y 1. Figura autobús 3-9 muestra un tablero
WeatherPiArduino completamente poblado.
Prueba SDL_Pi_TCA9545 Versión 1.0 - Laboratorios SwitchDoc
Muestra utiliza 0x73

Programa Iniciado en: 05/10/2015 20:00:56
- - - - - - - - - - - BUS 0 -------------------
registro de control tca9545 B3-B0 = 0x1 ignorar interrupciones si
INT3' - Control tca9545 INT0' no está conectado registrar
interrupciones = 0xc
0 1 2 3 4 5 6 7 8 9 abcdef 00:
03 - - - - - - - - - - - -
10: - - - - - - - - - - - - - - - -20: - - - - - - - - - - - - - - - - -30: - - - - - - - - - - - - -
- - -40 : 40 - - - - - - - - 49 - - - - - -50: 50 - - - - - 56 - - - - - - - - -60: - - - - - -
- - 68 - - - - - - -70: - - - - 73 - - - 77
-----------------------------------
73
- - - - - - - - - - - BUS 1 -------------------
registro de control tca9545 B3-B0 = 0x2
Las interrupciones ignorar si INT3' - INT0' no está conectado tca9545
registro de control interrumpe = 0xe
0 1 2 3 4 5 6 7 8 9 abcdef 00:
-- -- -- -- -- -- -- -- -- -- -- -- --
10: - - - - - - - - - - - - - - - -20: - - - - - - - - - - - - - - - - -30: - - - - - - - - - - - - -
- - -40 : 40 - - - - - - - 48 - - - - - - -50: - - - - - - - - - - - - - - - -60: - - - - - - - - -
- - - - - - -70: - - - 73 - - - -
-----------------------------------
- - - - - - - - - - - BUS 2 -------------------
Las interrupciones ignorar si INT3' - Control tca9545 INT0' no está
conectado registrarse interrupciones = 0xc
0 1 2 3 4 5 6 7 8 9 abcdef 00:
-- -- -- -- -- -- -- -- -- -- -- -- --
10: - - - - - - - - - - - - - - - -20: - - - - - - - - - - - - - - - - -30: - - - - - - - - - - - - -
- - -40 : - - - - - - - - - - - - - - - -50: - - - - - - - - - - - - - - - -60: - - - - - - - - - - -
- - - - -70: - - - 73 - - - -
-----------------------------------
- - - - - - - - - - - BUS 3 -------------------
Las interrupciones ignorar si INT3' - Control tca9545 INT0' no está
conectado registrarse interrupciones = 0xc
0 1 2 3 4 5 6 7 8 9 abcdef 00:
-- -- -- -- -- -- -- -- -- -- -- -- --
10: - - - - - - - - - - - - - - - -20: - - - - - - - - - - - - - - - - -30: - - - - - - - - - - - - -
- - -40 : - - - - - - - - - - - - - - - -50: - - - - - - - - - - - - - - - -60: - - - - - - - - - - -
- - - - -70: - - - 73 - - - -
-----------------------------------
74
Figura 3-9. WeatherPiArduino totalmente cargado con sensores
75
El tamaño de su sistema de energía solar

Una de las primeras cosas que viene en un diseño con energía solar es la forma de diseñar el sistema de energía. Las tres
cuestiones principales a ser formuladas y contestadas son los siguientes:
1. ¿Cuánta potencia necesito?
2. Cuántos paneles solares necesito?
3. Lo batería tamaño necesito?
Lo primero que hay que hacer al diseñar un sistema de energía solar es determinar los requisitos de energía para su diseño
con energía solar. Nuestros criterios son que queremos que el IOTWeatherPi Frambuesa Pi Modelo A para ejecutar todo el día y por
lo menos tres horas antes de la salida del sol y tres horas después de la puesta del sol. Nuestros objetivos y presupuesto influyen en
nuestras opciones de hardware, por lo que no son totalmente independientes. Figura 3-10 muestra los paneles solares con el
AM2315 fuera sensor de temperatura en el lado de la carcasa.
La figura 3-10. Paneles de energía solar en IOTWeatherPi
Mesa 3-3 contiene el consumo de energía estimado para los modelos de la Frambuesa Pi, incluyendo un adaptador
USB inalámbrico. Estamos asumiendo en cada uno de estos que se gira el puerto HDMI fuera, lo que ahorra ~ 20 mA.
76
Tabla 3-3. Consumo de energía estimado para modelos Frambuesa Pi
Un modelo Modelo A + modelo B Modelo B + Modelo B Pi2
Corriente (mA) 260 (200) 195 (135) 480 (420) 290 (230) 304 (240)
Potencia (W) 1,3 (1,0) 0,975 (0,675) 2,4 (2,1) 1,45 (1,15) 1,52 (1,2)
Fuente Mesurado Mesurado Mesurado medido medido
Todas las medidas anteriores incluyen aproximadamente 60 mA para el WiFi Dongle USB. Los números
entre paréntesis son sin 60mA.
Con base en lo anterior, primero voy a presentar a mis supuestos para nuestra Frambuesa Pi Modelo Un diseño
basado +. Las baterías LiPo elegidas almacenar 6600mAh. ¿Por qué elegir el modelo A +? Es la corriente de menor consumo
Frambuesa Pi.
Lo que es mAh (mili Amperios)? Un 6600mAh significa que puede tomar 100 mA durante 66 horas, en teoría. En
realidad, usted no será capaz de obtener más de un 80% en promedio, dependiendo de su batería. ¿Qué tan rápido que
los de descarga también hace una gran diferencia. Cuanto más lenta sea la velocidad de descarga, más mAh que puede
salir de la batería. A modo de comparación, una pila AA llevará a cabo sobre 1000mAh [batería en.wikipedia.org/wiki/AA_]
y una batería D llevará a cabo sobre 10000mAh [en.wikipedia.org/wiki/AA_battery].
En un sistema como este, es mejor para cargar sus baterías LiPo completamente y luego conectar el
ordenador y ver cuánto tiempo se tarda en descargar la batería y morir. Hicimos esta prueba en el sistema
IOTWeatherPi. Los resultados están aquí en switchdoc.com
[ www.switchdoc.com/?p=1926 ] .
supuestos:
• Dos voltáica 3.4W 6V / 530mA células solares (total de 6.8W)
• 8 Horas de sol ejecutan las células por lo menos al 70% del valor máximo de entrega de
corriente a Pi de frambuesa con una eficiencia del 85% (que pierden poder en la circuitería
de carga y aumentar)
• Frambuesa Pi Modelo A + 195mA toma en promedio (con el Dongle USB inalámbrico)
• Frambuesa Pi Modelo A + en funcionamiento 24 horas al día
• Baterías 6600mAh LiPo
Teniendo en cuenta estos podemos calcular total de Frambuesa Pi Modelo Un tiempo de ejecución durante un día típico:
PiRunTime = (8 horas * 70% * 1060mA) * 85% / (195mA) = 25 horas
Nuestro objetivo fue durante 24 horas, lo que parece que nuestro sistema va a funcionar. Así 16 Horas de funcionamiento de la
Frambuesa Pi Modelo A + en las baterías solo se llevará a (195mA / 85%) * 16 Horas = 3670mAh, que es cómodamente menos de
nuestras baterías 6600mAh pueden almacenar. El dongle WiFi añadieron aproximadamente 60 mA en promedio. Fue activado todo el
tiempo la Frambuesa Pi estaba en marcha. No se hizo ningún esfuerzo por minimizar la potencia consumida por el dongle WiFi. Sus
resultados dependerán de qué otras cargas que se circula, como otros dispositivos USB, cargas GPIO, dispositivos I2C, etc.
77
Tenga en cuenta que durante el día, en promedio, estamos poniendo en la batería 6000mAh aproximadamente. Esto también
significa una batería de 6600mAh grande que no hará mucha diferencia a este sistema.
Así, en un día soleado brillante, debemos ser capaces de funcionar 24 horas al día. En cuanto a los resultados de
IOTWeatherPi estar fuera en el sol durante una semana, esto parece ser correcta. Sin embargo, está nublado y lluvioso, y el
sistema se quede sin energía. La siguiente parte más importante del diseño es cómo manejar las caídas de tensión! Consulte
la siguiente sección sobre cómo entregar este pequeño problema desagradable.
Las cuatro partes más importantes de la verificación de su diseño de la energía solar:
• Recopilar datos reales;
• Recopilar más datos reales;
• Reunir aún más datos reales;
• Mira sus datos y lo que le está diciendo sobre el sistema real. Enjuague y repita.
Encendido y Apagado
El sistema de energía en tiempo Pi consta de cuatro partes:
• Dos paneles solares
• Una batería Li-Po 6600Ah
• SunAirPlus Regulador de la energía solar, Pi fuente de alimentación; y el sistema de Recolección
de Datos
• Junta PowerControl USB para control de encendido del Pi
Estamos utilizando 2 3.4W paneles solares voltaicos de Sistemas. Estos son paneles de alta calidad que hemos utilizado en
proyectos anteriores y durar mucho tiempo, incluso bajo el sol tropical. La imagen de arriba es de los mismos paneles en Proyecto
Curacao después de seis meses en el sol. Esas son las nubes reflejadas en los paneles, no suciedad. Los paneles son perfectos.
Se seleccionó una batería de 6600mAh de Adafruit para este diseño. Ver el "Dimensionamiento su Sistema Solar" paso a
continuación.
Estamos utilizando un controlador de energía solar SunAirPlus en este diseño. En figura 3-11 se puede ver cómo se
coloca el control de la energía solar en el recinto, por encima de la Frambuesa Pi.
78
Figura 3-11. Regulador de la energía solar en la parte inferior del cuadro de
SunAirPlus incluye un INA3221 I2C [ www.switchdoc.com/2015/03/sunairplussolar-power-ina3221-python-raspberry-pi-libra

] 3 Canal actual / monitor de voltaje y un I2C 4 canales de 12 bits Convertidor Analógico a Digital (ADS1015). El
INA3221 le permite controlar todas las principales corrientes y tensiones en el sistema (batería / paneles solares /
Carga - Computer). Se puede decir lo que su proyecto de energía solar está haciendo en tiempo real.
A continuación se presentan algunos resultados de la junta SunAirPlus utilizando el INA3221 a bordo. Se puede ver que la batería
está casi completamente cargada, y la tensión de la célula solar (en realidad una fuente de alimentación variable sobre el banco de
pruebas) es 5.19V y es el suministro de 735mA.
Prueba SDL_Pi_INA3221 Versión 1.0 - Laboratorios SwitchDoc
Ejemplo utiliza 0x40 y SunAirPlus INA3221 Junta trabajará con el SwitchDoc del tablero
del desbloqueo laboratorios INA3221
------------------------------
LIPO_Battery Tensión Bus: 4.15 V LIPO_Battery
Shunt Voltaje: -9,12 mV LIPO_Battery Tensión de
carga: 4.14 V LIPO_Battery actual 1: 91,20 mA
79
La célula solar de tensión del bus 2: 5.19 V Solar Voltaje

Shunt Cell 2: -73,52 mV Solar Cell Tensión de carga 2:
5.12 V de la célula solar de corriente 2: 735,20 mA
Tensión de salida Bus 3: 4.88 V de tensión de

salida de derivación 3: 48,68 mV de carga de salida
de tensión 3: 4.93 V Corriente de salida 3: 486,80
mA
Se puede utilizar esta tarjeta para alimentar sus proyectos y añadir un servomotor o paso a paso para que pueda
seguir al sol usando fotorresitores para generar aún más potencia.
La Junta PowerController USB es básicamente un relé de estado sólido controlado para conectar la alimentación dentro y fuera
de la Frambuesa Pi. Esta placa se encuentra entre el Controlador de Energía Solar (SunAirPlus) y una Frambuesa Pi Modelo A +. La
entrada a la junta fue diseñada para venir directamente de una batería Li-Po por lo que el equipo no se activará hasta que la batería
Li-Po fue acusado por encima de ~ 3.8V. Un circuito de histéresis se proporciona para que el tablero no se enciende y luego se
apague inmediatamente debido a que la fuente de alimentación se tiró hacia abajo cuando el equipo se enciende (poniendo
inmediatamente una carga en la batería). Esto realmente sucede !!!! Matas a Frambuesa Pi tarjetas SD de esta manera.
El problema de baja de voltaje
En este importante paso, vamos a discutir el problema de apagar y hasta su Frambuesa Pi. En los sistemas de solar,
esto se llama el "problema de baja de voltaje." Vamos a mostrar cómo utilizar un dispositivo simple, el control de
encendido USB [ www.switchdoc.com/ USB-powercontrol bordo / ] , SwitchDoc de laboratorios para resolver este
problema.
Una de las cuestiones más importantes en el diseño de un sistema de energía solar Frambuesa Pi es el encendido y
apagado. El “problema de baja de voltaje” es un problema real. ¿Por que preocuparse? Si usted tiene una cadena larga de los días
nublados, puede ejecutar su batería hacia abajo. Puede compensar esto en su diseño añadiendo más paneles y más baterías, pero
que puede llegar muy caro y su sistema todavía puede quedarse sin energía, sólo mucho menos frecuencia.
Apagado del Pi
Como cerrar la Frambuesa Pi fuera es bastante fácil. Cuando el voltaje de la batería cae por debajo de un cierto valor, que
acaba de hacer un “apagado sudo -h now” y su Frambuesa Pi se cerrará limpiamente. Después de hacer la prueba habló de
aquí [ www.switchdoc.com/?p=1926 ] , elegimos 3.5V como el voltaje para apagar el Raspberry Pi. Figura 3-12 muestra la gráfica
de los datos después de la aplicación de estos valores.
80
Figura 3-12. Probando el comportamiento del sistema de alimentación IOTWeatherPi
Tenga en cuenta que en la mayoría de los sistemas de energía solar, es necesario controlar el voltaje de la batería y no la fuente de
alimentación de 5V ya que con la mayoría de los sistemas de refuerzo de tensión modernos, los circuitos trabajará muy duro para mantener el
5V ir y luego simplemente renunciar a estrellarse a un mucho menor tensión cuando se queda sin energía.
Esto significa que su equipo tendría poca o ninguna advertencia cuando la tensión está a punto de caer. Mediante el control
de la tensión de la batería, se puede decir cuando la batería está recibiendo suficiente bajo y luego apagar el ordenador de forma
segura. Para las baterías de LiPo, esto será cuando el voltaje se baja a alrededor de 3,5 V o menos. Todo esto se puede controlar
con el controlador de carga solar SunAirPlus que estamos utilizando en IOTWeatherPi.
A partir del Pi
Basta de hablar de apagar el equipo. ¿Qué hay de su puesta en marcha?
La cuestión
No se puede dejar que el poder controlador de la computadora. El problema es que la tensión de alimentación se moverá hacia
arriba y abajo hasta que haya suficiente carga en la batería para abastecer totalmente el equipo. Cuando el equipo se enciende (la
conexión de una carga completa), se le tire de la batería hacia abajo con fuerza suficiente como para dorar el equipo causando la
Frambuesa Pi se bloquee. Este ciclo de reinicio constante puede corromper y arruinar su tarjeta SD y hacer que el equipo no
arranque en absoluto, incluso cuando se restablezca la alimentación. Habíamos esta cosa MUY pasar a nosotros 3500 millas de
distancia con el Proyecto Curacao [ www.switchdoc.com/2015/02/solarpower-project-curacao-update/ ] . Arduino son más tolerantes
con esto, pero de Frambuesa Pi no le gusta una fuente de alimentación portado mal. Simplemente no se puede estar seguro de lo
que el estado del equipo se encenderá en sin una buena fuente de alimentación.
81
Este problema puede ser manejado en un número de maneras. La primera es utilizar otro ordenador (como un
Arduino hecho para ser muy fiable mediante el uso de un perro guardián - ver la serie del ordenador fiable sobre switchdoc.com
[ www.switchdoc.com/2014/11/reliable-projectswatchdog-timers-raspberry-pi-arduinos/ )] para desconectar la alimentación
de la Frambuesa Pi a través de un relé de enclavamiento o MOSFET cuando no hay suficiente energía. Proyecto Curacao
( www.switchdoc.com/project-curacao-introduction-part-1/ ) se utiliza este enfoque.
No queríamos añadir un equipo adicional a IOTWeatherPi, así que elegimos una segunda solución.
Su accionar Pi arriba y abajo con el control de corriente USB

Una segunda (y más barato!) Manera de manejar la bajada de tensión y el encendido problema es utilizar un controlador de
potencia dedicado que apagará la alimentación a la Frambuesa Pi y restaurar la energía cuando el voltaje de la batería es lo
suficientemente alta para evitar trinquete del suministro voltaje arriba y hacia abajo debido a la carga de la Frambuesa Pi. Esto
se llama histéresis. Hemos diseñado un tablero para hacer precisamente esto (llamado el PowerController USB [ www.switchdoc.com/
USB-powercontrol bordo / ] ) que podrá conectar entre el USB que sale del controlador de potencia Solar SunAir y la
Frambuesa Pi como en la figura 3-13 .
Figura 3-13. PowerControl USB
82
El Consejo Regulador de la energía del USB
La junta PowerControl USB es un USB a USB relé de estado sólido.

Cualquier cosa se puede conectar a un puerto USB se puede controlar con PowerControl USB. Es fácil de conectar. Se
conecta una línea de control (GPIO una línea o la salida de una batería Li-Po) a la línea LIPOBATIN en el dispositivo de control de
alimentación USB y si la línea es baja (<~ 3.3V) del puerto USB está apagado. Si es alta (por encima de 3.8V) del puerto USB está
activado y tiene 5V de alimentación al conector USB.
Hay un circuito de histéresis por lo que la junta no se encenderá y luego se apague inmediatamente debido a que la fuente de
alimentación se tiró hacia abajo cuando el equipo se enciende (poniendo una carga en la batería).
Hay poca software para este dispositivo. Se conecta directamente a la batería Li-Po para el control automático! El
único software utilizado detecta el voltaje de la batería y decide cuándo apagar el equipo. El control de potencia USB se
encarga de apagar la alimentación de la Frambuesa Pi cuando el voltaje de la batería se pone lo suficientemente bajo.
Tenga en cuenta que un cierre Frambuesa Pi seguirá gastando (de acuerdo con una medición rápida, alrededor de 100
mA). Figura 3-14 muestra cómo se integra la PowerControl USB en un sistema.
Figura 3-14. El control de la potencia Pi de frambuesa
83
Uno Más Escenario

Un último punto. Después de pensar en la secuencia de apagado, se nos ocurrió un escenario más. Y
si:
1. El voltaje de la batería alcanza 3,5 V y la Frambuesa Pi se apaga.
2. El PowerController USB se desconecte la alimentación cuando la batería alcanza
aproximadamente 3.4V.
Sin embargo, lo que si el sol sale en este momento y se inicia la carga de la batería de nuevo? A continuación, el
PowerController USB nunca alcanzará aproximadamente 3.4V y nunca se apagará. Y el Pi no se reiniciará. No es un buen
escenario!
Hemos fijado esto añadiendo un temporizador de vigilancia de hardware. Para ver un tutorial sobre temporizadores de
vigilancia de hardware, lea la serie SwitchDoc comenzando aquí [ www.switchdoc.com/2014/11/
fiables-proyectos-vigilancia-timers-frambuesa-pi-Arduino / ] . Una imagen del temporizador de vigilancia se da en la figura 3-15 .
Figura 3-15. Temporizador de vigilancia
84
Se utilizó un temporizador de vigilancia Junta dual [ www.switchdoc.com/dual-watchdogtimer/ ] para solucionar este

problema. Hemos establecido el pitón Raspberry Pi a "acariciar al perro" (evitando que el temporizador de vigilancia de activación)
cada 10 segundos. El temporizador está preparado para disparar después de aproximadamente 200 segundos si no se le dio unas
palmaditas. El temporizador está conectado a tirar de la "cout" (TP3) apuntar hacia abajo a tierra en el PowerController USB, que
cierra el Raspberry Pi. Debido al circuito de histéresis en el PowerController USB, el Raspberry Pi permanecerá apagado hasta que
el voltaje de la batería alcanza ~ 3.9V y luego el Pi se reiniciará. Ahora el escenario anterior nunca sucederá. Por cierto, no hay
forma real de la utilización de la vigilancia interna Pi para hacer esto. Usted no desea reiniciar el Pi; desea cortar la energía en este
escenario.
■ Tip SwitchDoc La construcción de cables de la instalación es siempre un dolor. Desea que todos los cables estén juntos y
usted quiere que sean compactos y de aspecto agradable. Una gran manera de hacer esto es para cortar los cables de gancho
hasta la misma longitud y luego los trenzar juntos mediante el uso de un taladro eléctrico. Insertar los cables y luego girar el
taladro lentamente durante la ejecución de los dedos lentamente por los cables. Apuesto cables cada vez! Figura 3-16 muestra el
resultado. De aspecto agradable cables.
Figura 3-16. Los cables trenzados con el taladro
85
¿Qué necesita para construir este proyecto?

Ningún proyecto está completo sin una lista de piezas. Estas son sugerencias. Hay muchas opciones para un número de
estas placas. Si sustituyes, asegúrese de comprobar la compatibilidad. Figura 3-17 Muestra todas las partes.
Figura 3-17. Piezas IOTWeatherPi
• WeatherRack sensores meteorológicos [ www.switchdoc.com/

weatherrack-tiempo-sensores / ]
• BUD NEMA caja de amazon.com [ www.amazon.com/gp/ producto /

B005T57WYI / R & tag = wwwswitchdo05-20 ]
• Panel VoltaicSystems Solar (s) - 2 paneles [ www.voltaicsystems. com / 3-5 vatios

de panel ]
• Frambuesa Pi A + , Frambuesa Pi 2, Frambuesa Pi 3 (menor será la potencia del

mejor)
86
• Frambuesa Pi Wi-Fi compatible USB Dongle
• SunAirPlus Regulador de la energía solar [ www.switchdoc.com/

sunairplus-solar-power-controllerdata de colector / ]
• USB PowerControl [ www.switchdoc.com/usb-powercontrolboard/ ]
• Grove 4 canales I2C Mux del tablero del desbloqueo w / LED de estado [ www.switchdoc.com/grove-i2c-4-channel-m
]
• SwitchDoc laboratorios doble temporizador de vigilancia [ www.switchdoc.com/ doble organismo
de control automático / ]
• WeatherPiArduino Junta Tiempo [ www.switchdoc.com/

weatherboard / ]
• Embedded aventuras I2C Rayo detector MOD-1016 de la junta [ www.embeddedadventures.com/as3935_lig

module_mod-1016.html ]
• DS3231 RTC Con EEPROM [ www.switchdoc.com/ds3231-realtime-clock-module/

]
• Temperatura y humedad al aire libre AM2315 sensor [ www.

switchdoc.com/am2315-encased-i2c-temperature-andhumidity-sensor/ ]
• Barómetro BMP180 y del sensor de temperatura [ www.switchdoc. com / wp-content /

uploads / 2015/01 / BST-BMP180-DS000-09.pdf ]
• Adafruit HTU21D-F Temperatura / Humedad tablero del desbloqueo
• tablero del desbloqueo adafruit 32 KB FRAM I2C
• Junta adafruit ADS1015 4 canales A / D I2C
• Adafruit PKCELL Lithium Ion Battery Pack - 3.7V 6600mAh
• A prueba de agua de 8 pines enchufe de amazon.com [ producto www.amazon.com/gp/ /

B00HG9VO0S / y tag = wwwswitchdo05-20 ]
• 2 Dual Fila 4 posición cubierta Terminal tornillo del bloque de Gaza de

amazon.com [ www.amazon.com/gp/product/B00SUXK2ZM/&tag=w
wwswitchdocc-20 ]
• Panel de control RasPiConnect [ www.milocreek.com/ ]
87
Conectar y probar el hardware

Al igual que con la mayoría de los proyectos, que tienden a "tablero" los circuitos antes de lo ponemos en el recinto. Con
IOTWeatherPi, que extiendo la mano, ellos cableado, aseguramos cada uno de los caminos principales trabajado (y, por
supuesto, tomó la noche friki disparo obligatorio), y luego comenzó a colocarlos en la caja, uniéndolos con tornillos y
mensajes a través de el plástico. Figura 3-18 muestra el proyecto de cable por la noche antes de colocarlo en el recinto.
Figura 3-18. IOTWeatherPi en la noche
Poner el IOTWeatherPi en la caja de Bud Industries era bastante sencillo. Hemos elegido para poner la parte de la energía
solar del circuito en la parte superior y la Frambuesa Pi y la matriz de sensores IOTWeatherPiArduino en el fondo de la caja. Las
partes fueron todos colocados y, a continuación todos los orificios de los tornillos y tornillos externos se sellaron con calafateo de
silicio.
Se utilizó la glándula Conectores para pasar los cables de entrada y salida de la caja. Luego selló el Conectores Glándula. El
Conectores Glándula no son necesariamente resistente al agua, pero hacen cosas más apretado y proporcionar un buen anclaje de
cable. A continuación, utiliza un enchufe desconectable a prueba de agua para atar en los instrumentos del tiempo WeatherRack. Se
puede ver estas conexiones en la figura 3-19 .
88
Figura 3-19. Conexiones IOTWeatherPi
En la construcción de la Estación Meteorológica IOTWeatherPi con energía solar, vimos un par de partes que decidimos que sería
bueno para la impresión 3D. En los doce meses desde que compramos nuestra SwitchDoc laboratorios MakerBot replicador [ makerbot.com/
], Hemos cambiado totalmente la forma en que construimos piezas especiales para la creación de prototipos. Y con las últimas
actualizaciones de firmware de la extrusora y, las rocas MakerBot! He hecho diez copias largas sin ningún problema. Lo que solía ser
cuchillos Xacto y espuma, madera y pegamento, pero ahora que acabamos de construir nuevas partes cuando los necesitamos. Figura 3-20
muestra las piezas impresas en 3D completos. Las tres partes que hemos utilizado para la impresión en 3D son los siguientes:
• Soporte con bisagras para conectar paneles de paneles solares a la intemperie caja estación
(ajustable para la latitud);
• opuesto a las bisagras para colgar paneles de energía solar (las lengüetas en el lado del
rectángulo son sólo para asegurarse de que el soporte es plana!);
• Sun Cubierta de temperatura y sensor de humedad AM2315 que mató al

sensor de humedad por no cubrir la AM2315 en el Proyecto Curacao [ www.switchdoc.com/project-curacaoe
].
89
Figura 3-20. Piezas impresas en 3D
los archivos OpenSCAD para la construcción de estas piezas se encuentran en www.switchdoc.com/wpcontent/uploads/2015/04/WeatherP

.

Mesa 3-4 proporciona la lista cableado completo de IOTWeatherPi. A medida de que conecte, marque cada cable para mayor
exactitud.
Llave:
Frambuesa Pi A +: PiA +
Grove bus I2C Mux: GI2CM
Dual WatchDog la tarjeta del temporizador: WDT
WeatherPiArduino: WPA
Control de energía USB: USBPC
SunAirPlus: SAVIA
90
Tabla 3-4. Lista de cableado IOTWeatherPi
Frambuesa Pi A + (PIA +)
GPIO Encabezamiento
PiA + GPIO / Pin 1: 3.3V IGI2CM JP1 / Pin 3: VCC Mux I2C energía para la tarjeta de
interfaz de ordenador
PiA + GPIO / Pin 2: 5.0V WDT JP1 / Pin 1: VDD Poder para Dual Junta temporizador de
vigilancia
PiA + GPIO / Pin 3: SDA GI2CM JP1 / Pin 2: SDA SDA para I2C Junta Mux
- Interfaz de ordenador
PiA + GPIO / Pin 5: SCL GI2CM JP1 / Pin 1: SCL SCL para I2C Mux tarjeta de
interface de ordenador
PiA + GPIO / Pin 6: GND GI2CM JP1 / Pin4: GND GND para I2C Mux tarjeta de
PiA + GPIO / pin 11 GPIO 17 WDT JP2 / Pin 1: TRIGGER De entrada de disparador para WatchDog 1
DOG1_ Timer (Pat the Dog)
PiA + GPIO / Pin 12: 18 GPIO WPA JP13 / Pin 1: LD-IRQ Solicitud de interrupción de la
AS3935 de Rayo Junta
Detector
PiA + GPIO / pin 16: 23 GPIO WPA JP2 / Pin3: Salida anemómetro del
Anemómetro WeatherRack - Interrumpir
PiA + GPIO / Pin 17: 3.3V Conector Tornillo VCC Para proporcionar más
conexiones de 3.3V
PiA + GPIO / Pin 18: 24 GPIO WPA JP2 / Pin 2: Lluvia Lluvia Cubo de salida de
Cubo WeatherRack - Interrumpir
PiA + GPIO / Pin 22: 25 GPIO SAP JP13 / Pin8: EXTGP0 GP0 a bordo SunAir -
display LED amarillo
Junta Mux I2C Grove (GI2CM)
JP1 - Informática
GI2CM JP1 / Pin 2: SDA PiA + GPIO / Pin 3: SDA SDA a I2C Mux tarjeta de
GI2CM JP1 / Pin 1: SCL PiA + GPIO / Pin 5: SDA SCL a I2C Mux tarjeta de
GI2CM JP1 / Pin 4: GND PiA + GPIO / Pin 6: GND GND para I2C Mux tarjeta de
( continuado)
91
Tabla 3-4. ( continuado)
GI2CM JP1 / Pin 3: VCC PiA + GPIO / Pin 1: 3.3V Energía para I2C Junta Mux
- Computer Interface
JP2 - 0 bus I2C WeatherPiArduino bus I2C
GI2CM JP2 / Pin 3: VDU0 WPA JP1 / Pin 2: VDD 3.3V de la Junta de WPA
GI2CM JP2 / Pin 2: GND WPA JP1 / Pin 1: GND Junta GND para WPA
GI2CM JP2 / Pin 5: SC0 WPA JP4 / Pin 1: SCL SCL para la Junta de WPA
GI2CM JP2 / Pin 4: SD0 WPA JP4 / Pin 2: SDA SDA para la Junta de WPA
JP3 - bus I2C 1 SunAirPlus bus I2C
GI2CM JP3 / Pin 3: VDU1 SPA JP23 / Pin 3: VDD 5.0V para Bus 1 para I2C Mux
GI2CM JP3 / Pin 2: GND SAP JP13 / Pin 4: GND Junta GND para SAP
GI2CM JP3 / Pin 5: SC1 SAP JP13 / Pin 1: EXTSCL SCL para la Junta de SAP
GI2CM JP3 / Pin 4: SD1 SAP JP13 / Pin 2: EXTSDA SDA para la Junta de SAP
JP4 - bus I2C 3 GND auxiliar para la Junta WDT GND para Junta WDT
GI2CM JP4 / Pin 2: GND WDT JP1 / Pin 1: GND GND para Junta WDT
Junta temporizador de vigilancia dual (WDT)
JP1
WDT JP1 / Pin 1: VDD PiA + GPIO / Pin 2: VDD (5.0V)
WDT JP1 / Pin 2: GND GI2CM JP4 / Pin 2: GND GND para Junta WDT
JP2
WDT JP2 / Pin 1: DOG1_ PiA + GPIO / Pin 11: 17 GPIO WDT disparador de
TRIGGER Frambuesa Pi
JP3
WDT JP3 / Pin 1: DOG1_ USBPC: TP3 - COUT Soldadura Cable a TP3
ARDUINORESET - COUT en
PowerControl USB
( continuado)
92
WeatherPiArduino (WPA)
JP1
WPA JP1 / Pin 1: GND GI2CMux JP2 / Pin 2: GND GND para Junta WPA
de I2CMux
WPA JP1 / Pin 2: 3V3 GI2CMux JP2 / Pin 3: 3.3V para I2C Bus 0 de WPA
VDU0
JP2
WPA JP2 / Pin 2: Lluvia Cubo PiA + GPIO / Pin 18: 24 Lluvia Cubo de salida de
GPIO WeatherRack - Interrumpir
WPA JP2 / Pin 3: Anemómetro PiA + GPIO / pin 16: 23 De salida del anemómetro
GPIO de WeatherRack Interrupt
JP4
WPA JP4 / Pin 1: SCL GI2CMux JP4 / Pin 5: SCL SCL de I2C Junta Mux
WPA JP4 / Pin 2: SDA GI2CMux JP4 / Pin 4: SDA SDA de I2C Junta Mux
WPA JP4 / Pin 3: 3V3 Conector Tornillo VCC 3.3V De Pi Conector /

Tornillo
JP13
WPA JP13 / Pin 1: LD-IRQ PiA + GPIO / Pin 12: 18 GPIO Solicitud de interrupción de la
AS3935 de Rayo Junta
Detector
Control de energía USB (USBPC)
USBIN: Conector USB de SAP Un USB OUT de SAP
USBOUT: Conector USB para PiA + Potencia de entrada USB en PiA +
JP1
USBOUT JP1 / Pin 1: LIPOBATIN SAP JP4 / Pin 1: Li-Po SAP Plus de LiPo baterías que están
baterías que están fuera fuera de PowerControl USB
TP3 - COUT: WDT JP3 / Pin 1: DOG1_ Cierra control de corriente USB
ARDUINORESET hacia abajo si Frambuesa Pi se ha
cerrado y LIPOBATIN <~ 3.9V
( continuado)
93
SunAirPlus (SAP)
Un USB de salida: USBIN en USBPC
J5 de la batería: Para LiPo paquete de la batería
J6 solar: Para los paneles solares
JP4
SAP JP4 / Pin 1: USBPC: JP1 / Pin1 SAP Plus de LiPo baterías que están
LIPOBATIN fuera de PowerControl USB
JP10
SAP JP10 / Pin 1: SCL SCL (5.0V) Conectado a temperatura exterior /

sensor AM2315 Hum - funciona
mejor en
5.0V bus I2C
SAP JP10 / Pin 2: SDA SDA (5.0V) Conectado a temperatura exterior /

mejor en
5.0V bus I2C
SAP JP10 / Pin 3: VDD5 VDD5 Conectado a temperatura exterior /

mejor en
5.0V bus I2C
SAP JP10 / Pin 4: GND GND Conectado a temperatura exterior /

mejor en
5.0V bus I2C
JP13
SAP JP13 / Pin 1: EXTSCL GI2CMux JP3 / Pin 5: SC1
SAP JP13 / Pin 2: EXTSDA GI2CMux JP3 / Pin 4: SD1
SAP JP13 / Pin 3: VDD SPA JP23 / Pin 2: VDD5 5V I2C interfaz de SAP
SAVIA JP13 / Pin 4: GND GI2CMux JP3 / Pin 2: GND GND forman Junta I2CMux
SAP JP13 / Pin 8: EXTGP0 PiA + GPIO / Pin 22: 25 Línea de Frambuesa Pi a flash
GPIO LED amarillo en SAP GP0
JP23
SAP JP23 / Pin 2: VDD5 SAP JP13 / Pin 3: VDD 5.0V para SAP bus I2C a
I2CMux
SAP JP23 / Pin 3: VDD5 GI2CMux JP3 / Pin 3: VDU1 5.0V para I2CMux I2C Bus1
94
El software
Una gran parte del Proyecto IOTWeatherPi es el software. Todo el software Python para este proyecto es de hasta en github en
la sección de switchdoclabs [ https://github.com/ switchdoclabs / WeatherPi ] . También he incluido todas las diversas bibliotecas
para los dispositivos I2C que estamos utilizando.
Requisitos que no son normales para su Pi

Usted tendrá que añadir el siguiente software y bibliotecas a su Frambuesa Pi:
• MySQL. Hay un montón de tutoriales en Internet para la instalación de MySQL. Aquí es

el mismo que se utilizó [ raspberrywebserver.com/sqldatabases/using-mysql-on-a-raspberry-pi.html
]. La estructura de la base de datos MySQL en formato WeatherPi mysqldump se
encuentra en github [ https://github.com/switchdoclabs/WeatherPiSQL ] .
Puede utilizar este archivo para construir la base de datos MySQL para el Proyecto
IOTWeatherPi.
• Matplotlib. Este es el subsistema de gráficos con una gran interfaz de Python. Es un poco
más complejos de instalar, así que escribí un tutorial sobre cómo instalarlo en SwitchDoc.com
[ www.switchdoc. com / 2014/01 / matplotlib-frambuesa-pi-MySQL-y-projectcuracao / ] . Tenga
en cuenta que la instalación lleva mucho tiempo, alrededor de ocho horas en un Frambuesa
Pi (en su mayoría sin supervisión).
El software IOTWeatherPi Python

El software IOTWeatherPi es bastante simple. La aplicación fue mucho menos complejo que el software Proyecto
Curacao [, www.switchdoc.com/project-curacao-software-systempart-6/ ] así que decidí no usar el apscheduler paquete
y decidió sólo para utilizar un bucle simple, con un tipo de "cada 15 segundos" de control. Aquí está el bucle
principal:
secondCount = 1 while
True:
# alarmas de proceso de relámpago
si (as3935Interrupt == true):
process_as3935_interrupt ()
# proceso de los comandos de impresión RasPiConnect

"----------------------------------------"
processCommand ()
95
if ((% 10) == secondCount 0):

# imprimir cada 10 segundos
sampleAndDisplay () patTheDog ()
# restablecer el temporizador de vigilancia
blinkSunAirLED2X (2)
# cada 5 minutos, el envío de datos a MySQL y comprobar para el apagado
if ((secondCount% (5 * 60)) == 0):

sampleWeather () sampleSunAirPlus
() writeWeatherRecord ()
writePowerRecord ()
si (batteryVoltage <3,5):
print "--- >>>> hora de apagado <<<< ---" shutdownPi (
"cierre de bajo voltaje")
# cada 15 minutos, construir nuevos gráficos
if ((secondCount% (15 * 60)) == 0):

sampleAndDisplay ()
# cada 48 horas, reiniciar

if ((secondCount% (60 * 60 * 48)) == 0):
# reiniciar cada 48 () horas rebootPi (
"hora reinicio 48")
secondCount = secondCount + 1
# restablecer secondCount para evitar desbordamiento para siempre
si (secondCount == 1000001):
secondCount = 1
time.sleep (1,0)
Tenga en cuenta que reiniciar el Pi cada dos días. ¿Por qué hacemos eso? Nos hemos dado cuenta de que después de un uso
intensivo de matplotlib y / o MySQL, que a veces después de un largo tiempo, que se quede sin recursos, dando todo tipo de comportamiento
extraño. Dado que el Raspberry Pi A + tiene una pequeña cantidad de RAM, la reanudación está la forma más fácil de fijación.
Echa un vistazo a todo el código arriba en github.com [https://github.com/switchdoclabs/ WeatherPi].
El código para el RasPiConnect [ www.milocreek.com/ ] panel de control se discute en la siguiente sección.
96
El panel de control RasPiConnect

Yo uso RasPiConnect para construir nuestros paneles de control para nuestros proyectos. Que nos permite colocar gráficos, controles,
botones, barras de desplazamiento, etc., hasta en nuestras pantallas para iPad / iPhone sin tener que escribir aplicaciones. RasPiConnect
trabaja en Frambuesa Pi de y en Arduino. Hemos utilizado este software en cinco proyectos diferentes, con IOTWeatherPi ser la última.
¿Cómo construir un panel de control para IOTWeatherPi está más allá del alcance de este capítulo, pero
aquí está el tutorial [ www.switchdoc.com/?p=523 ] que escribió para hacer lo que estamos haciendo por
IOTWeatherPi. Estamos utilizando el mismo mecanismo de mando de paso en IOTWeatherPi que usamos en
MouseAir. RasPiConnect viene con un excelente manual, completa aquí [ www.milocreek.com/wiki/index.php/Main_Page
].
Todo el código RasPiConnect que usamos en IOTWeatherPi es bajo en github GitHub. com /
switchdoclabs [ https://github.com/switchdoclabs/WeatherPi-RasPiConnect ] .
Tenga en cuenta que se carga sólo el directorio local, que es el único lugar cambios en el código se hacen como se
explica en el manual RasPiConnect.
El IOTWeatherPi ha estado fuera durante aproximadamente 16 semanas. Funcionando perfectamente. Se puede ver el cuadro
está cargando y luego ir a la energía de la batería cuando el sol se mueve detrás de la casa. Hemos tenido días calientes y noches
frías como estamos empezando a salir de la primavera al verano. No es bastante generar suficiente electricidad para hacer funcionar
las 24 horas en el momento (ya que está en la sombra hasta las 9 am y después de las 3 pm - No bastantes de 8 horas de sol). Este
problema se solucionará cuando lo muevo hasta la parte superior de la casa donde tendrá sol alrededor de 12 horas al día en
promedio (cuando el sol no está detrás de las nubes!). Figura 3-21 muestra el gráfico del rendimiento de la energía solar después de
una semana de sol.
Figura 3-21. Panel de control IOTWeatherPi
97
mejoras
No estamos construyendo gráficos de la velocidad del viento, dirección, y la lluvia todavía. Estamos sólo un informe de los
valores actuales del panel de control RasPiConnect. Todos los datos se guarda en MySQL, sin embargo.
Las indicaciones de temperatura y de rayos necesitan ser fijo y mejorado. Lo bueno es que todo
esto se puede hacer de forma remota!
El piar sus datos meteorológicos

El piar es una gran manera de leer los mensajes cortos de las personas con poco que decir. Con la IOT IOTWeatherPi, puede
unirse a este proyecto épico para ser a la diversión. Por supuesto, algunas personas tienen cosas interesantes que decir y ahora
puede empezar a twittear información sobre el clima IOT. Puede que no tenga una gran cantidad de seguidores, pero usted
puede seguir su IOT IOTWeatherPi desde cualquier lugar!
Empezando
El primero que hay que hacer es instalar el software Twython [ https://twython.readthedocs.org/ es / última / ] . Esta es una
biblioteca de Python que le permitirá a su aplicación a crear nuevos Tweets e interactuar con Twitter fuera del sitio web
de Twitter.
Copiar y pegar estos comandos uno a la vez en su Frambuesa Pi. La mayoría de estos requieren una respuesta para
continuar. Los dos primeros (actualización / actualización) son comandos generales que actualizan su Frambuesa Pi a la mejor
y más nuevo software. Una buena cosa que hacer en general.
sudo apt-get update sudo

apt-get upgrade
sudo apt-get install python-setuptools sudo apt-get
install python-dev sudo sudo pip pip easy_install
instalar twython
sudo apt-get install libffi-dev libssl-dev

sudo PIP instalar --upgrade pyOpenSSL ndg-httpsclient pyasn1 pip pip sudo instalar
solicitudes
Ahora tenemos Twython instalado en su IOTWeatherPi. Figura 3-22 muestra una captura de pantalla iPhone de los
Tweets resultantes.
98
Figura 3-22. El piar IOTWeatherPi
Registro de una aplicación de Twitter
La API de Twitter (Application Programming Interface) es una interfaz REST. Una interfaz (Representational State
Transfer) resto es una estilo de arquitectura de software para construir
escalable servicios web .
REST sistemas normalmente, pero no siempre (y, específicamente, no en cuanto a la interfaz de Twitter), se comunican a
través de Internet con el mismo verbos HTTP (GET, POST, PUT, DELETE, etc.), que los navegadores web utilizan para
recuperar páginas web y para enviar datos a servidores remotos.
La primera cosa que hay que hacer es crear una nueva cuenta de Twitter para su proyecto. En general,
usted no quiere a Tweet su temperatura y las cosas a través de su cuenta personal y a todos sus seguidores.
Hacer eso es una gran manera de des-seguido muy rápidamente. Ir a Twitter y hacerlo ahora. Cuando haya
hecho esto, pasar a la siguiente párrafo.
99
Para utilizar la API de Twitter, usted tendrá que registrar una nueva aplicación (su IOTWeatherPi en este
caso). Hacerlo desde este enlace [ https://apps.twitter.com/app/new ]
- no hay necesidad de especificar un URL de respuesta, y sólo hacer un sitio web si lo desea. Figura 3-23
muestra la pantalla de la aplicación inicial.
Figura 3-23. Pantalla Twitter Aplicación
A continuación, vaya a la Tokens llaves y la conexión y crear un token de acceso. Mantener esta página abierta. Usted
tendrá que poner las fichas en su aplicación.
Mira en el subdirectorio de Twitter en el directorio de software IOTWeatherPi y editar el archivo twitter.py añadir
su ACCESS_KEY (que es el testigo de acceso en la página de Twitter).
# ! / Usr / bin / env python
# twitter.py
# laboratorios SwitchDoc
# 07.23.15
import sys
fecha y hora de importación
de twython Twython importación
100
def sendTweet (gorjeo, tweetString):
# si no se encuentra conflocal.py, por defecto de importación conf.py
# Compruebe si las importaciones de usuario

probar:
importar conflocal como conf

excepto ImportError:
conf importación
hoy = datetime.datetime.utcnow () DateString = today.strftime (

"% H:% M:% S UTC:")
tratar:
SendString = DateString + tweetString
twitter.update_status (estado = SendString) de retorno 0
excepto:
volver 1
El siguiente es el código de inicialización en WeatherPi.py:
# Twitter instalación
de twython Twython importación
Twitter importación
twitterObject = Twython (conf.CONSUMER_KEY, conf.CONSUMER_SECRET, conf.ACCESS_ TOKEN,

conf.ACCESS_TOKEN_SECRET)
Usted pone los códigos de inicialización (CONSUMER_KEY, etc.) en conf.py desde la página de Twitter de desarrollo.
Aquí está el código en IOTWeatherPi que hace que la temperatura y la humedad tweets cada 30 minutos:
# cada 30 minutos, comprobar las conexiones wifi y Tweet
if ((secondCount% (30 * 60)) == 0):

WLAN_check ()
# enviar un tuit
tweetString = "OutsideTemp:% 0.1FC OutsideHum:% 0.1f %% del viento:
0.1fKPH%" % (outsideTemperature, outsideHumidity, currentWindSpeed * 1.6)
twitter.sendTweet (twitterObject, tweetString)
101
Y el tweet advertencia relámpago;
twitter.sendTweet (twitterObject, "IOTWeatherPi relámpago detectado"

+ str (distancia) + "kilómetros de distancia.")
Ahora su IOTWeatherPi está conectado a Twitter. A continuación, vamos a configurar el IOTWeatherPi de

texto nosotros la misma información.
Los mensajes de texto de sus datos meteorológicos

Los mensajes de texto desde su WeatherPi es mucho más simple que incluso twittear. La clave es averiguar qué portadora que está
enviando mensajes de texto a la puerta de entrada e incorporar en su dirección de correo electrónico (tabla 3-5 ).
Tabla 3-5. Texto Las direcciones de mensajería de correo electrónico
Portador E-Mail a la pasarela SMS
Alltel [Insertar número de 10 dígitos] @ message.alltel.com
AT & T [Insertar número de 10 dígitos] @ txt.att.net
Aumentar Móvil [Insertar número de 10 dígitos] @ myboostmobile.com
Sprint [Insertar número de 10 dígitos] @ messaging.sprintpcs.com
T-Mobile [Insertar número de 10 dígitos] @ tmomail.net
US Cellular [Insertar número de 10 dígitos] @ email.uscc.net
Verizon [Insertar número de 10 dígitos] @ vtext.com
Virgin Mobile [Insertar número de 10 dígitos] @ vmobl.com
Más vehículos y puertas de enlace se enumeran aquí [cita https://en.wikipedia.org/ wiki / SMS_GATEWAY ]
El código para enviar mensajes de texto es, pues, el mismo que el código para enviar correos electrónicos.
Aquí está el código para el envío de correos electrónicos en IOTWeatherPi:
def sendEmail (fuente, mensaje, tema, a dirección, fromaddress, nombre de archivo):


probar:

conf importación
# smtplib importación para la función de envío de importación real

smtplib
102
# Estos son los módulos del paquete de correo electrónico que

necesitaremos de MIMEImage importación email.mime.image de
MimeMultipart importación email.mime.multipart de MimeText importación
email.mime.text
COMMASPACE = ''
# Crear el mensaje de correo electrónico contenedor (externa). msg

= MimeMultipart () msg [ 'Asunto'] = sujeto
# Me == dirección de correo electrónico del remitente

# familia = la lista de todos los destinatarios de correo electrónico se dirige msg [
'Desde'] = fromaddress msg [ 'A'] = a dirección
# msg.attach (mensaje)
mainbody = MimeText (mensaje, 'plain') msg.attach

(mainbody)
# Suponemos que sabemos que los archivos de imagen están todos en formato PNG
# Abrir los archivos en modo binario. Dejar que la clase MIMEImage automáticamente
# adivinar el tipo de imagen específico. si

(archivo = ""!):
fp = abierto (nombre de archivo, 'rb') img
= MIMEImage (fp.read ()) fp.close ()
msg.attach (IMG)
# Enviar el correo electrónico a través de nuestro propio servidor SMTP.
tratar:
# abrir una línea con el servidor de s = smtplib.SMTP (
"smtp.gmail.com", 587)
s.ehlo ()
s.starttls ()
s.ehlo ()
# inicio de sesión, enviar correo electrónico, cierre de sesión

s.login (conf.mailUser, conf.mailPassword)
s.sendmail (conf.mailUser, a dirección, msg.as_string ())
# s.close ()
s.quit ()
excepto:
print ( "excepción Sendmail levantado") devuelven 0
103
Tenga en cuenta que las direcciones de hacia y desde se definen en conf.py junto con la información de Twitter.
Y aquí es la única línea de código para enviar un mensaje de texto de advertencia del rayo:
sendemail.sendEmail ( "test", "IOTWeatherPi relámpago Detectado \ n", as3935LastStatus,

conf.textnotifyAddress, conf.textfromAddress, "");
Figura 3-24 muestra que un conjunto de mensajes de texto fue entregado a mí en Curaçao
3.500 millas de distancia de nuestra IOTWeatherPi en SwitchDoc laboratorios.
Figura 3-24. Un relámpago tormenta se mueve por SwitchDoc laboratorios
104
Al remitir sus datos a la World - CWOP

Hay una serie de sitios web y empresas que les encantaría enviarles tus datos meteorológicos. Dos de ellos son
CWOP y WeatherUnderground. A los efectos de este proyecto, vamos a enviar los datos a CWOP (Ciudadanos
Tiempo Programa de Observación).
CWOP
El Programa de Observadores Ciudadanos Tiempo (CWOP) es una red de propiedad privada electrónica estaciones meteorológicas concentrada
en los Estados Unidos, sino que también se encuentra en más de 150 países. participación en la red permite a los voluntarios con
estaciones meteorológicas informatizadas para enviar observaciones meteorológicas de superficie automatizadas para el Servicio
Meteorológico Nacional. Estos datos son utilizados entonces por el Actualizar rápida pronóstico del modelo para producir predicciones a
corto plazo (de 3 a 12 horas en el futuro) de condiciones en todo el 48 estados de los Estados Unidos . Observaciones CWOP también
se redistribuyen al público.
El CWOP fue originalmente creado por los radioaficionados que experimentan con
de radio por paquetes , Pero ahora contiene la mayoría de las estaciones de sólo conectados a Internet. A partir de julio
2015, más de 10.000 emisoras de todo el mundo informan regularmente a la red CWOP.
CWOP software de interfaz a IOTWeatherPi

Cuando hable con el servidor CWOP, se utiliza un protocolo llamado APRS (Automatic paquetes del sistema de informes).
APRS fue originalmente un sistema basado en la radioafición para las comunicaciones en tiempo real de información
de valor inmediato en el área local. Ahora se utiliza en un número de aplicaciones en las que los paquetes de datos necesitan
ser difundido a varias ubicaciones.
El software que estoy usando en este proyecto se basa en el excelente trabajo de Tom Hayward y su proyecto
pywxtd [ https://github.com/kd7lxl/pywxtd ] . Hemos eliminado el código de análisis estación meteorológica y el código
del demonio y sólo estamos usando las bibliotecas APRS para enviar los datos a CWOP.
CWOP Software
El software CWOP lee los datos de la estación IOTWeather y envía un paquete APRS a los servidores CWOP con
nuestros datos de tiempo actuales.
En primer lugar es el código post_CWOP utilizado para enviar el paquete a los servidores CWOP. Instalamos el código CWOP en
el bucle principal IOTWeatherPi para disparar cada 15 minutos:
# cada 15 minutos, construir nuevos gráficos
if ((secondCount% (15 * 60)) == 0):

sampleWeather () sampleSunAirPlus
() doAllGraphs.doAllGraphs ()
# enviar nuestros datos CWOP
105
# dirección del viento - grados desde el norte verdadero

# Velocidad del viento - MPH número entero
# ráfaga de viento - MPH número entero
# temperatura - grados F
# lluvia desde la medianoche - centésimas de pulgadas
# humedad -% donde 100% = 00
# presión - 5 números en décimas de milibares
CWOP.post_CWOP (WIND_DIR = currentWindDirection, wind_ velocidad =

currentWindSpeed, wind_gust = currentWindGust, temperat ura = CtoFInteger
(outsideTemperature), rain_since_midnight = 0, la humedad = convertHumidity
(outsideHumidity), presión = int (BMP1 80SeaLevel * 100 + 0,5))
A continuación, tenemos el código que usamos para construir los paquetes CWOP APRS:
# ! / Usr / bin / env python
# 24 de julio 2015
# Version 1.0
"""
inicialmente de Tom Hayward
construye y presenta una
APRS paquete de tiempo a la APRS-IS / CWOP. Licencia BSD
y otras cosas
Copyright 2010 Tom Hayward <[email protected]> """
import sys, os, tiempo

fecha y hora de la fecha y hora de importación, timedelta
de la toma de importación *
sys.path.append ( '..')

probar:

conf importación
106
def make_aprs_wx (WIND_DIR = Ninguno, WIND_SPEED = Ninguno, wind_gust = Ninguno, temperatura = Ninguno,
rain_since_midnight = Ninguno, humedad = Ninguno, presión = None):
"""
Ensambla la carga útil del paquete meteorológica APRS. """
str_or_dots def (número, longitud):

"""
Si el parámetro es None, llenar el espacio con puntos. Si no, cero-pad. """
si el número es Ninguno:
* Longitud volver otra cosa
'':
format_type = {
'Int': 'd', 'float': '.0f',} [tipo
(número) .__ name__]
retorno '' .join (( '% 0', str (longitud), format_type)) Número%
timeStringZulu = time.strftime ( "% d% H% M") de retorno '@% sz% s /% s_%

s /% sg% st% sP% sh% sb% s% s' % (
timeStringZulu, conf.STATIONLATITUDE,
conf.STATIONLONGITUDE, str_or_dots
(WIND_DIR, 3), str_or_dots (WIND_SPEED, 3),
str_or_dots (wind_gust, 3), str_or_dots (temperatura,
3), str_or_dots (rain_since_midnight, 3), str_or_dots
(humedad, 2 ), str_or_dots (presión, 5),
conf.STATION_TYPE
def post_CWOP (WIND_DIR = Ninguno, WIND_SPEED = Ninguno, wind_gust = Ninguno, temperatura = Ninguno,
rain_since_midnight = Ninguno, humedad = Ninguno, presión = None):
# publicar en APRS
wx = make_aprs_wx (WIND_DIR = WIND_DIR, WIND_SPEED = WIND_SPEED, wind_ ráfaga =
wind_gust, temperatura = temperatura, rain_since_midnight = rain_since_ medianoche, la humedad = humedad,
presión = presión)
time.strftime de impresión ( "% Y-% m-% d% H:% M:% S"), wx
send_aprs (conf.APRS_HOST, conf.APRS_PORT, conf.APRS_USER, conf. APRS_PASS,

conf.CALLSIGN, wx)
regreso
107
Ejemplo CWOP de paquetes

Tuve un tiempo difícil averiguar exactamente qué formato de APRS para enviar. Este es un ejemplo de los paquetes reales que
enviamos:
EW7667> APRS, TCPIP: @ 251954z4739.22N / 11705.11W_158 / 004g006t076P000h49b01015IO TWeatherPi
resultados
Aquí está el paquete y los datos que se recibieron por la ROM del servidor CWOP IOTWeatherPi (nuestro número de registro
CWOP es EW7667). Ahora estamos conectados a la IOT para estaciones meteorológicas!
Éstos son algunos de los paquetes registrados de finds.com:
EW7667> APRS, TCPXX *, QAX, CWOP-3: @ 252056z4739.22N / 11705.11W_045 / 009g013t075P000

h46b10147IOTWeatherPi
Cuando se han recogido una gran cantidad de datos, findu.com mostrará algunos gráficos fresco como se muestra en
findu.com . Ver figura 3-25 [ www.findu.com/cgi-bin/wxpage.cgi?call=EW766 7 y última = 48 y radar = ***] .
108
Figura 3-25. Ejemplo de tiempo completamente ocupado Sitio EW7666
109
Conclusión
En figura 3-26 , Mostramos la IOTWeatherPi con el programa opcional Rayo Pilón en la naturaleza [ www.instructables.com/id/Lightni
].
Figura 3-26. IOTWeatherPi Desplegado
Es increíble lo que puede hacer con el hardware como el Raspberry Pi y fuera de theshelf sensores para detectar el
medio ambiente. Con una calificación de 6 CPLPFC, IOTWeatherPi probablemente no es un sistema de despliegue
comercialmente en el IOT, pero es una gran unidad de base para experimentar y familiarizarse con el hardware y el
software para la IOT.
Aquí están algunas ideas adicionales para proyectos basados en IOTWeatherPi:
• Sustitución de la conexión Wi-Fi con una conexión de datos GSM - Esta sería utilizar la red de
datos móviles para comunicaciones.
• Hacer una costumbre Facebook mensaje con su tiempo - Esto sería utilizar la API de Facebook
para hacer envíos automatizados, al igual que Twitter.
110
• La adición de un receptor GPS y el almacenamiento de esos datos. Ahora tiene una estación
meteorológica móvil! Cuando se pone de nuevo a Wi-Fi, todos los datos almacenados estarán
disponibles. Se podía twittear su ubicación y las condiciones locales sobre la marcha con una conexión
GSM.
• Adición de sensores de calidad del aire adicional, sensores UV, sensores de polvo. Usted tiene una
gran cantidad de pines de entrada / salida y I2C espacio de direccionamiento que se puede llenar con
sensores más interesantes.
El gasto de energía principal en IOTWeatherPi es la Frambuesa Pi. Mediante la sustitución de la Frambuesa Pi

con una pequeña Arduino (y dramáticamente reducir la funcionalidad Arduino no son ni de lejos tan poderosa como la
combinación de la Frambuesa Pi y Linux), se podría mejorar sustancialmente su calificación CPLPFC.
¿Siguiente? Pasamos a utilizar el Raspberry Pi para detectar iBeacons y averiguar dónde se encuentra cuando
transporte la Raspberry Pi con usted. Con IOTBeaconAir, modificaremos las luces con luces Philips Hue para iluminar
su camino.
111
CAPÍTULO 4
Cambiando su entorno con IOT y

iBeacons
Capítulo Objetivo: Reunir Ubicación datos en el dispositivo IOT: localizar dónde se encuentra y ubicación de entrega
depende de los datos y llevar a cabo acciones de dónde se encuentre
• iBeacons y ¿cómo se puede utilizar
• Detectar y leer iBeacons de la Frambuesa Pi
• Buscar su ubicación - trilateralización en un mundo difuso
• Visualizar su ubicación en un panel de control
• Apagar las luces y encendido por su ubicación
en el capítulo 3 , Que viste un sistema de energía solares flexibles para entregar datos a la IOT
(En este caso, incluyendo la Administración Oceánica y Atmosférica Nacional (NOAA) a través de la interfaz de tiempo,
CWOP. IOTWeatherPi entregó una gran cantidad de información sobre una base regular.
En este capítulo, nos tomamos nuestro nuevo dispositivo IOT, IOTBeaconAir, a otro nivel. Ahora estamos
recogiendo menos información (e incluso el envío de menos a la IOT), pero estamos tomando datos sobre el medio
ambiente (donde está) y utilizarlo para cambiar el entorno (la cantidad de iluminación donde se encuentre). Esto nos lleva
a otro nivel de interacción con el IOT.
el IOTBeaconAir
IOTBeaconAir es un proyecto basado Frambuesa Pi portátil que lee los paquetes de “publicidad” emitidas por
iBeacons, más o menos calcula su posición, y luego se enciende las luces que están cerca de usted. El Pi
calcula entonces el brillo en función de lo cerca que está. La idea es que se puede caminar alrededor de su
casa con su pi y las luces te seguirá.
En otras palabras, estoy usando iBeacons para averiguar dónde se encuentra físicamente mi Pi portátil (en una bolsa en
mi cadera mientras camino alrededor de la casa) y luego controlar varios dispositivos con el Pi.

CAPÍTULO 4 ■ CAMBIO de su entorno con IOT Y IBEACONS
El aspecto único de IOTBeaconAir frente a los muchos otros proyectos basados IBeacon Pi existentes es que no estoy
programando la Frambuesa Pi a ser un IBeacon; Estoy haciendo todo lo contrario. Estoy utilizando el Pi a leer otros iBeacons.
Estoy usando iBeacons especializadas en este proyecto, pero también se podría construir sus propias iBeacons de Frambuesa
Pi y después de leerlos a través de Bluetooth con este proyecto.
Este proyecto se basa en un Frambuesa Pi ModelB portátil conectado con un adaptador USB Bluetooth
4.0 y una conexión Wi-Pi dongle USB inalámbrico. El proyecto Pi portátil IOTBeaconAir completo se muestra en
la figura 4-1 .
La Figura 4-1. IOTBeaconAir portátil Pi

Como ya os comentamos en el capítulo 1 , Lo primero que hay que hacer para entender un proyecto IOT es mirar a nuestros
seis diferentes aspectos de IOT. IOTBeaconAir es un proyecto mucho más simple que IOTWeatherPi. Mesa 4-1 muestra los seis
componentes.
114
Tabla 4-1. Componentes del Proyecto IOTBeaconAir
IOTBeaconAir Caracterización (CPLPFC) Aspecto
Clasificación comentarios
comunicaciones 9 conexión WiFi a Internet - puede hacer AdHoc comunicación de tipo

malla y Bluetooth
procesador Power 8 Frambuesa Pi B + / 256 MB de RAM
Almacenamiento local 8 8 GB de tarjeta SD
El consumo de energía 1 ~ Consumo 300mA - No es razonable para pequeñas baterías
funcionalidad 8 sistema basado en Linux completo. MySQL, etc.
Costo 1 Caro para muchas aplicaciones. Junta es ~ $ 25 +
aplicaciones de IO.
Esto nos da una calificación de 5,8 CPLPFC, un poco menos de IOTWeatherPi (6). Grande para el aprendizaje, no tan bueno
para el despliegue para la mayoría de aplicaciones.
Sin lugar a dudas, la Frambuesa Pi es una plataforma muy flexible y potente IOT. Sin embargo, el consumo de energía,
el costo y el tamaño físico del dispositivo hacen que sea más adecuado para la creación de prototipos o para las unidades
funcionales altamente IOT autónomo.
Con IOTBeaconAir, al igual que el capítulo anterior, tenemos una gran cantidad de opciones. Podemos conectar a Internet utilizando
el conector WiFi. Podemos utilizar el Bluetooth para conectar a dispositivos locales, y también podemos utilizar la conexión Wi-Fi en
modo ad hoc para hacer conexiones locales. En este capítulo, vamos a utilizar la interfaz WiFi para hablar con el mundo más amplio
de dispositivos IOT.
Lista de hardware
A continuación se presenta una lista de los equipos que necesita para la construcción de este proyecto:
• Frambuesa Pi Modelo B +
• Paquete de baterías adafruit USB para Frambuesa Pi - 10000mAh - 2 x 5V @ 2A
• Developer Kit Estimote Balizas
• KST Tecnologías de partículas iBeacons
• Micro Adaptador USB Bluetooth 4.0 IOGear - GBU521 Modelo
• Adaptador inalámbrico 802.11n Wi-Pi Pi de frambuesa
115
iBeacons
IBeacon es la marca comercial de Apple para un dispositivo de baja potencia Bluetooth. Un IBeacon es un transmisor de baja potencia
y de bajo costo que puede notificar a los dispositivos cercanos de su presencia y una aproximación de rango. Hay un número de
fabricantes que están produciendo estos dispositivos y la mayoría de smartphones (y de Frambuesa Pi!) Se puede hacer para actuar
como un IBeacon. Utiliza Bluetooth Low Energy (BLE), también conocida como Bluetooth inteligente iBeacons también se puede
recibir el Bluetooth 4.0 dispositivos que soportan el modo dual (como el dongle IOGear especificado anteriormente). Tenga en cuenta
que la recepción de iBeacons en un dongle Bluetooth genérico puede ser bastante problemático. Seguir con el modelo IOGear
GBU521 si es posible.
Aplicaciones de iBeacons incluyen reconocimiento de ubicación de la publicidad, confirmaciones de medios sociales, o las
notificaciones enviadas a su teléfono inteligente o pi. Un IBeacon transmite un paquete de publicidad que contiene un UDID
(identificador de dispositivo único) que identifica el fabricante y a continuación, un número mayor y menor que se puede utilizar
para identificar el dispositivo específico. También envía una RSSI (Indicador de Intensidad de la señal relativa) que se puede
utilizar para aproximar la distancia al dispositivo IBeacon.
Es importante tener en cuenta que casi toda la lógica detrás de un despliegue IBeacon es a través de la aplicación
en el dispositivo de soporte (un Pi de frambuesa en nuestro caso). La única función de la IBeacon es anunciar al
dispositivo de su propia existencia en una ubicación física. En algunos casos, puede conectarse a un dispositivo individual
a través del GATT IBeacon (Perfil general de atributos) aunque algunos iBeacons tienen una interfaz propietaria (como el
Estimote iBeacons) que prohíben esto.
Este requisito de tener el dispositivo de aplicación (como un teléfono inteligente o Frambuesa Pi) leer y realizar acciones
en la posición de los iBeacons sigue siendo un obstáculo para la adopción generalizada de iBeacons en el mercado. Hacerlo de
otra manera (dicen los iBeacons para detectar su teléfono) es un gran problema de privacidad y así las cosas son propensos a
permanecer de esta manera en el futuro previsible. Véase el capítulo 7 , “La seguridad informática y la IOT,” por una serie de
razones por las que esto es una buena cosa.
Los iBeacons hemos utilizado se muestran en la figura 4-2 .
La Figura 4-2. iBeacons
116
He utilizado dos tipos de iBeacons: Estimote y KS Technologies partículas. Tanto trabajado de manera adecuada
con respecto a la recepción de paquetes de publicidad, pero las balizas Estimote tener una interfaz propietaria que hace
que no sea Linux y Frambuesa Pi amable, por lo que recomiendo los iBeacons de partículas, ya que puede leer y
escribir en los dispositivos de la Frambuesa Pi. El Estimote sólo admite un SDK patentada en Android y iPhone. Por
supuesto, siempre se puede rodar su propia IBeacon utilizando un Frambuesa Pi [ www.wadewegner.com/2014/05/
crear-an-IBeacon-transmisor-con-la-frambuesa-pi / ] . The Particle IBeacon se muestra en la figura 4-3 .
La Figura 4-3. Dentro de un IBeacon de partículas
117
Hay cuatro piezas principales de software en IOTBeaconAir: la IBeacon escáner Bluetooth, la interfaz
de Philips Hue, el software principal IOTBeaconAir, y el software de servidor RasPiConnect.
IBeacon escáner Bluetooth

Técnicamente, esta fue la parte más difícil del sistema IOTBeaconAir. El software disponible para hacer esto no
era muy fiable y no produjo el tipo de información que estaba interesado en. La figura 4-4 muestra los iBeacons
cerca de mi mesa de laboratorio utilizando la App BTLExplorer en mi iPhone de KS Technologies.
La Figura 4-4. BTLExplorer App Mostrando iBeacons
Tenga en cuenta que estamos recogiendo en una baliza Estimote y dos balizas de partículas. Curiosamente, también
estamos recogiendo un Apple TV situada a unos 40 pies de distancia. Yo no era consciente de que el Apple TV se emite un
paquete IBeacon, pero en la comprobación de que se utiliza para una forma no documentada de la creación de la Apple TV
desde tu iPhone. Los números no hacen mucho sentido en el paquete de publicidad IBeacon, pero eso es un problema para otro
día.
118
El mayor problema con este proyecto iba a ser capaz de leer los datos de forma fiable IBeacon de un dongle
Bluetooth (estoy usando un USB 4.0 Adaptador Bluetooth IOGear Micro - Modelo GBU521). Varios de los métodos por ahí
en la web eran menos que satisfactorio (haciendo exploraciones hcidump) y, a menudo terminó colgando el Bluetooth en el
pi, lo que requiere un reinicio. Una vez fui a usar mi biblioteca de software, tengo cero obsesiones y el software se ejecuta
durante varios días.
iBeacons utilizan Bluetooth Low Energy (BLE) protocolos de comunicación, que es un tipo relativamente nuevo de
Bluetooth y tiene soporte irregular. Por último, me topé con un programa usando Bluez (Biblioteca Bluetooth Linux) llamadas
nativas, que con una gran cantidad de modificaciones, correcciones de errores y de corte de código que no necesitaba, que
tenía un escáner IBeacon que funcionaba cada vez. He publicado mi versión de trabajo en el github laboratorios SwitchDoc ( github.com/switchdo
) para que pueda descargarlo y probar su configuración.
El programa blescan.py es fácil de probar y usar, pero requiere un poco de configuración en el Raspberry Pi. Consulte
la siguiente sección sobre la instalación de todo el software necesario en el Raspberry Pi.
Aquí está la salida de la programación que se ejecuta en SwitchDoc Labs. Tenemos una gran cantidad de iBeacons sentados
alrededor.
pi @ BeaconAir ~ / blescanner $ sudo python testblescan.py hilo ble comenzó
----------
cf: 68: cc: c7: 33: 10, b9407f30f5f8466eaff925556b57fe6d, 13072,52423, -74, -78 cf: 68: cc: c7: 33:
10,74696d6f74650e160a181033c7cc68cf, 46608,13255, -52, -77 da: f4: 2e: a0: 70: b1,
b9407f30f5f8466eaff925556b57fe6d, 28849,11936, -74, -79 da: f4: 2e: a0: 70:
b1,74696d6f74650e160a18b170a02ef4da, 46769,28832,46, -78 dd: 5d: d3: 35: 09 : dd,
8aefb0316c32486f825be26fa193487d, 1,1, -64, -78 c3: 11: 48: 9b: cf: fa,
8aefb0316c32486f825be26fa193487d, 0,0, -64, -73 fd: 5b: 12: 7f: 02: e4,
b9407f30f5f8466eaff925556b57fe6d , 740,4735, -74, -79 fd: 5b: 12: 7f: 02:
e4,74696d6f74650e160a18e4027f125bfd, 46820,639,18, -80 dd: 5d: d3: 35: 09: dd,
8aefb0316c32486f825be26fa193487d, 1,1, -64, -77
Estamos encontrando ocho iBeacons diferentes, que coincide con el recuento real. Antes de poder hacer esto, es
necesario instalar la última versión de bluez, la pila de Bluetooth para la Frambuesa Pi (instrucciones abajo). Nota: Se
puede usar apt-get, pero la versión de apt-get es antiguo y tiene el apoyo irregular para iBeacons.
Sistema de Iluminación Phillips Hue

El sistema de iluminación Phillips Hue es una manera inalámbrica basada en Zigbee de controlar la intensidad, combinaciones
de colores, y de encendido / apagado de un concentrador Phillips basa en su red local. Las aplicaciones estándar de Android y
iOS son muy potentes, pero para nosotros la gente Raspberry Pi, la mejor parte es que Phillips ha lanzado la API para el centro
de la multitud de bricolaje. Es un poco caro ($ 60 / bombilla) pero robusto y muy fácil de usar y de piratear. Todos los comandos
se envían vía inalámbrica o Ethernet al Hue Hub Phillips y el concentrador comunica a los dispositivos individuales.
119
¿Qué es Zigbee?
ZigBee es una especificación común para un conjunto de protocolos de comunicación de alto nivel que se utilizan para crear
redes de área personal construidos a partir de radios digitales pequeños, de baja potencia. En este sentido, es muy similar a la
conexión Bluetooth Low. La distancia de transmisión está limitada a unos 10-100 metros, dependiendo de la potencia de salida
y el entorno de transmisión. Los dispositivos Phillips Hue ZigBee funcionan bien dentro de una casa, pero a veces se verán las
luces saltar dentro y fuera de la red en lo que parece ser eventos relacionados con la humedad. Teniendo en cuenta las
frecuencias y las características de baja potencia de ZigBee, esto sin duda podría ser el caso.
La tecnología ZigBee está destinado a ser más simple y menos costoso que el Bluetooth y Wi-Fi, no sólo en el costo en
dólares, sino también sobrecarga del procesador para hacer frente al canal de comunicaciones. Imagínese lo que el
procesador tiene que hacer para interpretar un paquete entrante TCP / IP y llegar a los datos del usuario. ZigBee puede ser
utilizado sin el muy “pesado” pila de protocolos para comunicarse con dispositivos locales a través de una red de malla para
llegar Zigbees más distantes (véase el capítulo 6 ) Y luego pasar a un procesador “más robusto”, tales como Raspberry Pi
para enviar información a la IOT en Internet.
ZigBee se usa típicamente en aplicaciones IOT con bajas tasas de datos que requieren una larga vida de la batería (una
característica muy importante!) Y redes seguras. redes ZigBee están protegidos por claves de cifrado simétrico de 128 bits.
Véase el capítulo 7 para una discusión de las claves de cifrado. ZigBee tiene una tasa definida de 250 kbit / s, lo cual no es
muy rápido para el acceso web, pero se puede enviar una gran cantidad de datos con esa velocidad.
El nombre de ZigBee se refiere a la Danza de la abeja de la miel de las abejas después de su regreso a la colmena.
Hue Hub Phillips

El cubo Phillips Hue comunica a través de paquetes JSON autenticados. Hay una serie de paquetes de Python
diseñados para la comunicación con el concentrador Hue Phillips. Se optó por utilizar una escrita por Estudio Imaginaire
( studioimaginaire.com/en ) Phue llamada. Es un grupo de franceses inteligentes que hicieron un gran trabajo que
produce la biblioteca Phue. Teniendo en cuenta el logotipo IOTBeaconAir fue diseñado en Francia, parecía apropiado
utilizar esta biblioteca. Puede descargarlo en github.com/studioimaginaire/phue . Ver instrucciones de instalación.
Nuestras salas de ensayo para IOTBeaconAir tiene 10 Phillips Hue A19 bombillas estándar, 3 Phillips Hue luces BR-30
hacia abajo, lavado y 2 Phillips Amigos de luces Hue Bloom. Era caro, pero vale la pena (A19 bombillas son $ 60 cada uno,
BR30 bulbos $ 60 cada uno, y las flores son $ 80 cada uno). Estos precios deberían disminuir en el futuro.
120
BeaconAir de hardware, software y la configuración

Para trabajar con el BeaconAir, lo que necesita saber sobre el hardware y el software. También es necesario saber acerca de
cómo está configurado el software. Las siguientes subsecciones cubren cada uno de estos temas.
BeaconAir Descripción del hardware

El hardware IOTBeaconAir es bastante sencillo. Utilizamos una acción frambuesa Modelo B + con un adaptador
USB Wi-Fi Pi y un IOGear Bluetooth Dongle USB 4.0. Todo lo demás se hace por software. Figura 4-5 muestra el
sistema, así como mostrar cómo iBeacons que nos permiten encontrar la posición física aproximada de nuestra Pi
portátil IOTBeaconAir.
La Figura 4-5. Diagrama del sistema IOTBeaconAir
BeaconAir Descripción del software

El software IOTBeaconAir consta de cuatro piezas principales. He descrito el escáner IBeacon y la biblioteca Phue
Phillips Hue Python anteriormente. Las dos piezas principales restantes son la principal bucle de programa y el panel de
control / RasPiConnect Local.py.
El diagrama de bloques software IOTBeaconAir se muestra en la figura 4-6 .
121
Figura 4-6. IOTBeaconAir Diagrama de bloques del software
El software principal se ejecuta en un bucle, con un sueño de 0,25 segundos al final. Comprueba si hay dos fuentes de
trabajo. En primer lugar se comprueba una cola que está conectado con el software que se ejecuta IBeacon Escaneado en un
subproceso de fondo. Si la cola está vacía, no tenemos nuevos informes IBeacon así que bajan y comprobar para ver si hay
comandos de espera desde el panel de control RasPiConnect.
si (queueBLE.empty () == false):
resultado = queueBLE.get (Falso)
# comandos de proceso de RasPiConnect

processCommand ()
Si la cola ha IBeacon resultados a la entrega, a continuación, pasar por el bucle principal y procesar la información
IBeacon, establecer varios parámetros informativos, la construcción de la nueva página web para ofrecer a RasPiConnect,
y controlar las luces.
He quitado la información de depuración para hacer las cosas más claras. Todos los cálculos se hacen en metros
y la conversión en píxeles de pantalla.
Lo primero que hacemos es procesar la lista IBeacon entrante para llenar nuestras matrices de baliza. A continuación, limpiamos
los viejos valores.
122
resultado = queueBLE.get (Falso)
utils.processiBeaconList (resultado, currentiBeaconRSSI, currentiBeaconTimeStamp, rollingiBeaconRSSI)
utils.clearOldValues (10, currentiBeaconRSSI, currentiBeaconTimeStamp, rodando iBeaconRSSI)
A continuación se calcula la posición física actual IOTBeaconAir pero sólo si tenemos más de tres
balizas.
# posición de la actualización
if (utils.haveThreeGoodBeacons (rollingiBeaconRSSI)> = 3):
oldbeacons = balizas
balizas = utils.get3ClosestBeacons (rollingiBeaconRSSI) si (CMP
(oldbeacons, balizas) = 0):
bubblelog.writeToBubbleLog ( "closebeacons:% i,% i,% i" % (balizas [0], balizas [1], balizas
[2]))
MyPosition = utils.XgetXYFrom3Beacons
(balizas [0], balizas [1], balizas [2], rollingiBeaconRSSI)
Ahora tengo la última posición calculada. Siguiente calculo la fluctuación en la posición. Un valor grande de
fluctuación dice ya sea que se muda o hay cantidades significativas de ruido en los informes IBeacon o ambos.
# calcular la fluctuación en la posición

jitter = (((lastPosition [0] - MyPosition [0]) / lastPosition [0]) + ((lastPosition [1] - MyPosition
[1]) / lastPosition [1])) / 2,0 jitter = jitter * 100.0 # para llegar a ciento lastPosition =
MyPosition
Ahora escribo a cabo la fluctuación de RasPiconnect a leer y enviar a la gráfica fluctuación en el panel de control.
f = open ( "/ home / pi / BeaconAir / estado / distancejitter.txt", "w")
f.write (str (jitter))

f.close ()
La próxima calcular la distancia desde mi posición para todas las luces y luego encender la luz, el cambio de
brillo, o apagarlo dependiendo de la distancia.
lights.checkForLightTrigger (MyPosition, LIGHT_DISTANCE_SENSITIVITY,

LIGHT_BRIGHTNESS_SENSITIVITY, currentLightState)
123
A continuación, la página web está construido para su visualización en RasPiConnect.
# construir página web

webmap.buildWebMapToFile (MyPosition, rollingiBeaconRSSI, currentLightState, DISPLAY_BEACON_ON,
DISPLAY_LIGHTS_ON)
Por último, se actualiza el recuento de baliza actual y construir el gráfico para su visualización en RasPiConnect.
# construir el gráfico recuento faro
iBeaconChart.iBeacondetect (rollingiBeaconRSSI) otra cosa:
# posición perdida
MyPosition = [-myPosition [0], -myPosition [1]]
Eso es todo el programa principal para IOTBeaconAir. A continuación se presenta la lista completa
del programa principal de IOTBeaconAir:
# ! / Usr / bin / python
# BeaconAir - Lee iBeacons y controla las luces HUE

# SwitchDoc laboratorios de febrero de 2016
#
#
import sys tiempo de
importación utilidades de
importación
sys.path.append ( './ ble ')

sys.path.append (' ./ config')

probar:

conf importación
importación bleThread
luces de importación importar

mapa web bubblelog importación
iBeaconChart importación
124
enhebrar hilo de la importación de la cola

cola de importación
# Variables de estado
currentiBeaconRSSI = []
rollingiBeaconRSSI = []
currentiBeaconTimeStamp = []
# Variables de Estado de luz
currentLightState = []
LIGHT_BRIGHTNESS_SENSITIVITY = 2,0
LIGHT_DISTANCE_SENSITIVITY = 2,0 BEACON_ON
= True
DISPLAY_BEACON_ON = True
DISPLAY_LIGHTS_ON = True
# variables de estado de inicialización de faro

en conf.BeaconList:
currentiBeaconRSSI.append (0)
rollingiBeaconRSSI.append (0)
currentiBeaconTimeStamp.append (time.time ())
# las variables de estado de inicialización de

luz para la luz en conf.LightList:
currentLightState.append (0)
lights.initializeHue ( '192.168.1.6')
lights.setInitialLightState (currentLightState)
# Recieve comandos de ejecución de código RasPiConnect
def CompleteCommand ():
f = open ( "/ home / pi / BeaconAir / estado / BeaconAirCommand.txt", "w")

f.write ( "DONE")
f.close ()
def processCommand ():

LIGHT_BRIGHTNESS_SENSITIVITY mundial
LIGHT_DISTANCE_SENSITIVITY mundial BEACON_ON
mundial DISPLAY_BEACON_ON mundial
DISPLAY_LIGHTS_ON mundial currentLightState
mundial
125
f = open ( "/ home / pi / BeaconAir / estado / BeaconAirCommand.txt", "r") de comando =

f.read ()
f.close ()
si (comando == "") o (comando == "DONE"):

# Nada que ver return
false
# Comprobar si nuestros comandos
imprimir "Comando de procesamiento:", el mando
si (== comando "BEACONON"):

BEACON_ON = True
CompleteCommand ()
devolverá True
si (== comando "BEACONOFF"):

BEACON_ON = False
CompleteCommand ()
devolverá True
si (== comando "ALLLIGHTSON"):

lights.allLights (verdadero, currentLightState)
CompleteCommand () devolverá True
si (== comando "ALLLIGHTSOFF"):

lights.allLights (Falso, currentLightState) CompleteCommand
() devuelven True
si (== comando "BEACONON"):

BEACON_ON = True
CompleteCommand ()
devolverá True
si (== comando "BEACONOFF"):

BEACON_ON = False
CompleteCommand ()
devolverá True
si (== comando "DISPLAYBEACONON"):

DISPLAY_BEACON_ON = True
126
si (== comando "DISPLAYBEACONOFF"):

DISPLAY_BEACON_ON = False
si (== comando "DISPLAYLIGHTSON"):

DISPLAY_LIGHTS_ON = True
si (== comando "DISPLAYLIGHTSOFF"):

DISPLAY_LIGHTS_ON = False
si (comando == "") UPDATESENSITIVITIES:
tratar:
f = open ( "/ home / pi / BeaconAir / estado /
distanceSensitivity.txt", "r") commandresponse =
f.read ()
LIGHT_DISTANCE_SENSITIVITY = flotador (commandresponse)
f.close ()
excepto:
LIGHT_DISTANCE_SENSITIVITY = 2,0 try:

brightnessSensitivity.txt", "r") commandresponse
= f.read ()
f.close ()
LIGHT_BRIGHTNESS_SENSITIVITY = flotador (commandresponse) excepto:
LIGHT_BRIGHTNESS_SENSITIVITY = 2,0 print

"LIGHT_DISTANCE_SENSITIVITY, LIGHT_BRIGHTNESS_
Sensibilidad =", LIGHT_DISTANCE_SENSITIVITY, LIGHT_BRIGHTNESS_SENSITIVITY
CompleteCommand ()
devuelven TRUE
CompleteCommand ()
devuelven TRUE
127
# construir tabla de configuración
# configurar hilo BLE

# configurar una cola de comunicación
queueBLE = Queue ()
BLEThread = Thread (target = bleThread.bleDetect, args = (__ __ nombre, 10, queueBLE,)) BLEThread.daemon =
True BLEThread.start ()
bubblelog.writeToBubbleLog ( "BeaconAir Started")
# el bucle principal de BeaconAir

MyPosition = [0,0] lastPosition = [1,1]
balizas = [] while True:
si (BEACON_ON == true):
# comprobar si hay actualizaciones de impresión IBeacon
"Longitud de la cola =", queueBLE.qsize () si (queueBLE.empty () ==
false):
resultado = queueBLE.get (Falso) print
"------"
utils.processiBeaconList (resultado, currentiBeaconRSSI,

currentiBeaconTimeStamp, rollingiBeaconRSSI) utils.clearOldValues (10,
currentiBeaconRSSI, currenti BeaconTimeStamp, rollingiBeaconRSSI)
para faro en conf.BeaconList:
utils.printBeaconDistance (beacon, currentiBeaconRSSI,

currentiBeaconTimeStamp, rollingiBeaconRSSI)
# posición de la actualización
if (utils.haveThreeGoodBeacons (rollingiBeaconRSSI)
> = 3):
oldbeacons = balizas
balizas = utils.get3ClosestBeacons (rollingi BeaconRSSI)
impresión "faros, balizas =" if (CMP (oldbeacons,

balizas) = 0):
bubblelog.writeToBubbleLog ( "cierre
balizas:% i,% i,% i" % (balizas [0], balizas [1],
balizas [2]))
# configuración para Kludge

# rollingiBeaconRSSI [7] =
rollingiBeaconRSSI [6]
128
MyPosition = utils.getXYFrom3Beacon s (balizas

[0], balizas [1], balizas [2], rollingiBeaconRSSI)
print "myPosition1 =% 3.2f,% 3.2f" % (MyPosition
[0], MyPosition [1])
# bubblelog.writeToBubbleLog ( "posición
actualizada:% 3.2f,% 3.2f" % (MyPosition [0],
MyPosition [1]))
# calcular la fluctuación de fase en la posición jitter =

(((lastPosition [0] MyPosition [0]) / lastPosition [0]) +
((lastPosition [1] - MyPosition [1]) / lastPosition [1])) /
2,0 jitter = jitter * 100.0 # para llegar a ciento
lastPosition = MyPosition de
impresión "jitter =", jitter

distancejitter.txt", "w")
f.write (str (jitter))

f.close ()
para la luz en conf.LightList:

= lightdistance utils. TwoPoints
distanceBetween ([luz [2], la luz [3]],
MyPosition)
impresión "distancia a la luz% i:% 3.2f" % (luz [0],

lightdistance) print "LIGHT_DISTANCE_SENSITIVITY, light_
BRIGHTNESS_SENSITIVITY =", LIGHT_DISTANCE_
SENSIBILIDAD, LIGHT_BRIGHTNESS_SENSITIVITY
lights.checkForLightTrigger (myPositi en,
LIGHT_DISTANCE_SENSITIVITY, light_
BRIGHTNESS_SENSITIVITY, currentLightState) print "
DISPLAY_BEACON_ON, DISPLAY_LIGHTS_ ON",
DISPLAY_BEACON_ON, DISPLAY_LIGHTS_ON
# construir página web

webmap.buildWebMapToFile (MyPosition,
rollingiBeaconRSSI, currentLightState,
DISPLAY_BEACON_ON, DISPLAY_LIGHTS_ON)
129
# construir el gráfico recuento faro
iBeaconChart.iBeacondetect (rollingiBeaconRSSI) otra cosa:
# posición perdido MyPosition =

[-myPosition [0],
- MyPosition [1]]
# imprimir currentiBeaconRSSI
# currentiBeaconTimeStamp de impresión
# final de BEACON_ON - Siempre proceso ordena otra cosa:
si (queueBLE.empty () == false):
resultado = queueBLE.get (Falso) print
"------" imprimir "Beacon discapacitados"
# comandos de proceso de RasPiConnect
processCommand ()
time.sleep (0.25)
Una parte muy interesante de IOTBeaconAir está construyendo el mapa basado en HTML que muestra la posición, balizas
y luces.
A medida que empecé este proyecto, sentí que la construcción de este mapa en directo iba a ser el mayor
problema. Miré a la construcción de un mapa en vivo con Matplotlib en el Pi, pero era computacionalmente caro y
complicado. Entonces miré a soluciones de dibujo HTML y encontré que era casi trivial para hacerlo. Utilicé un Webview
remoto en RasPiConnect para el panel de control. Figura 4-7 muestra el mapa HTML completado.
130
La Figura 4-7. HTML Casa Mapa
Para hacer este mapa de trabajo HTML, siga estos pasos:
1. Construir un archivo JPEG con el plan de su oficina o casa. Yo tomé un

imagen de los planos de la casa y luego se usa GIMP [ www.gimp.org ]
dibujar las paredes en el JPEG y luego eliminar la capa JPEG. Trabajado como un
campeón. Entonces tuve que medir una pared en metros y usar GIMP para medir la
misma pared en píxeles, y tuve mis constantes metros de pixeles (0,0375 m / px en mi
caso). Pongo el punto 0,0 en la parte superior del JPEG y entonces x es positivo ir a
la derecha e Y es positivo por el lado izquierdo.
131
2. En el archivo de configuración, averiguar las posiciones x, y para cada una de las luces
y el faro y poner en el archivo de configuración.
• Ejecutar el software. El código HTML resultante tiene el siguiente aspecto:
<Html> <head> <title> </ title> <style> cuerpo, html, iframe {margin: 0; padding: 0;} </ style> </ head>
<body> <div posición = estilo ': relative ; izquierda: 0; top: 0; '> <img src =' http:
//example.example.com: 9600 / / mainplanfull.png posición '= estilo' estática: relative; top: 0; izquierda:
0; "/>
<Img src = 'http: //example.example.com: 9600 / / iBeacon.png estática' posición = estilo ':
absolute; top: 490px; izquierda: 299px; '/> <img src =' http: //example.example.com: 9600 / /
posición iBeacon.png '= estilo' estática: absolute; top: 19px; izquierda: 122px; '/> <img src ='
http: //example.example.com: 9600 / / posición iBeacon.png '= estilo' estática: absolute; top:
127px; izquierda: 122px; '/> <img src =' http: //example.example.com: 9600 / / posición
iBeacon.png '= estilo' estática: absolute; top: 40px; izquierda: 173px; '/> <img src =' http:
//example.example.com: 9600 / / posición iBeacon.png '= estilo' estática: absolute; top: 118px;
izquierda: 183px; '/> <img src =' http: //example.example.com: 9600 / / posición iBeacon.png '=
estilo' estática: absolute; top: 128px; izquierda: 257px; '/> <img src =' http: 'Style ='
//example.example.com:9600/static/iBeacon.png position: absolute; top: 418px; izquierda:
300px; '/> <img src =' http: //example.example.com: 9600 / / posición iBeacon.png '= estilo'
estática: absolute; top: 453px; izquierda: 275px; '/> <img src =' http: //example.example.com:
9600 / / posición OffLightBulb.png '= estilo' estática: absolute; top: 418px; izquierda: 315px; '/>
<img src =' http: //example.example.com: 9600 / / posición OffLightBulb.png '= estilo' estática:
posición OffLightBulb.png '= estilo' estática: absolute; top: 19px; izquierda: 132px; '/> <img src
=' http: //example.example.com: 9600 / / posición OffLightBulb.png '= estilo' estática: absolute;
top: 30px; izquierda: 173px; '/> <img src =' http: 'Style ='
//example.example.com:9600/static/OffLightBulb.png position: absolute; top: 118px; izquierda:
173px; '/> <img src =' http: //example.example.com: 9600 / / posición OffLightBulb.png '= estilo'
estática: absolute; top: 109px; izquierda: 122px; '/> <img src =' http: //example.example.com:
9600 / / posición OffLightBulb.png '= estilo' estática: absolute; top: 8px; izquierda: 222px; '/>
<img src =' http: //example.example.com: 9600 / / posición OffLightBulb.png '= estilo' estática:
posición OffLightBulb.png '= estilo' estática: absolute; top: 98px; izquierda: 16px; '/> img src =
<' http: //example.example.com: 9600 / / 'style =' estática rojo-pin.png position: absolute; top:
378px; izquierda: 217px; "/> </ div> </ body> <
132
Esto funciona como un campeón. Hice mis iconos con fondo transparente (de nuevo utilizando GIMP).
Archivo de configuración BeaconAir

El archivo de configuración IOTBeaconAir necesita ser establecido antes de que el sistema puede ser utilizado. Está situado debajo de
configuración en el directorio principal. Las tres partes principales del archivo de configuración son los siguientes:
Los factores de escala

Configuración Configuración
Beacon Light
Las siguientes declaraciones muestran dos de los factores de escala utilizados en el proyecto:
def pixelConv (píxeles):

vuelven píxeles * 0,0375 # En metros
meterToPixel def (metros):

retorno int (metros / 0,0375) # En píxeles
Nuestra configuración faro se logra como sigue:
# formato de sonda:
# Poder BeaconNumber, LocalName, x, y, UDID, mayor, menor, medido (a partir de especificaciones), x, en
píxeles, y en píxeles
# BeaconNumber es progresiva desde 0 hasta. No se salte un número BeaconList = []
= 0 BeaconCount
Beacon = [BeaconCount, "Estimote # 0 Beacon", pixelConv (314), pixelConv (507),

"b9407f30f5f8466eaff925556b57fe6d", 64.507, 5.414, -64,
314, 507]
BeaconList.append (Beacon)
BeaconCount + = 1
Por último, no es nuestra configuración de la luz:
# Lista de las luces

# Formato de la luz
# LightNumber, LocalName, x, y, pixel x, pixel y, la luz de encendido / apagado (1/0), huelightnumber
LightList = []
LightCount = 0
Light = [LightCount "Lab izquierda", pixelConv (330), pixelConv (435), 330, 435,0, 2] LightList.append (luz)
LightCount + = 1
133
Usted puede obtener el número ligera tonalidad de la App Phillips bajo visión general de luz, o puede escribir un
programa corto (mirar los ejemplos Phue) para obtener el diccionario de la tonalidad Hub Phillips.
IBeacon Software
Los iBeacons son problemáticos. Ellos no son muy precisos y un montón de diferentes factores ambientales afectan el RSSI
(potencia recibida). Si usted tiene sus sensibilidades IOTBeaconAir de inserción alta, puede sentarse en un lugar y ver las luces
crecen más brillante y oscura como las señales recibidas varían. Es una especie de un mapa visual del espectro electromagnético.
El establecimiento de sus sensibilidades menor brillo aumentará la sensibilidad, mientras que el rango de luz más altas aclara esto.
Hay dos funciones utilizadas por IOTBeaconAir para determinar la posición. En primer lugar es el cálculo de la
distancia de RSSI. Utilizamos una función de suavizado en los valores de RSSI recibidos para reducir la fluctuación. Por
ejemplo:
def calculateDistanceWithRSSI (RSSI, beaconnumber):
baliza = conf.BeaconList [beaconnumber]; txpower =

baliza [7] ratio_db = txpower - RSSI;
ratio_linear = pow (10, ratio_db / 10); r = pow

(ratio_linear, 0,5); r retorno
El resultado de esta función ya se escala en metros.
trilateralización
La segunda pieza clave es el cálculo de la posición mediante el uso de trilateración. Trilateración es el método de
determinación de la posición de un punto, dada la distancia a tres puntos de control. [citación: en.wikipedia.org/wiki/Trilateration
].
■ Nota SwitchDoc Cuando escuchas a alguien hablar acerca de cómo detectar cuando algo es mediante la medición de
distancia de puntos, por lo general dicen “triangulación” cuando quieren decir “Trilateración.” ¿Cuál es la diferencia? Se utiliza la
triangulación cuando se conoce el ángulo de un objeto a partir de dos fuentes diferentes. A continuación, puede localizar el
objeto en un avión. En el caso de iBeacons, todo lo que sabemos es la distancia. No sabemos nada acerca de la dirección.
Podemos utilizar tres distancias (o iBeacons en este caso) y fijar la posición de la Frambuesa Pi en un avión. Se me ocurre que
podríamos poner una antena direccional de Bluetooth en un motor paso a paso y, posiblemente, el uso que para utilizar la
triangulación, lo que significa que solo necesitaría dos iBeacons para encontrar nuestra posición, en lugar de tres como en la
trilateración.
134
El propósito de la siguiente función getXYFrom3Beacons es tomar la información de los tres seleccionados

iBeacons encontrado (a, b, c) y calcular las coordenadas XY de su dispositivo IOTBeaconAir.
getXYFrom3Beacons def (beaconnumbera, beaconnumberb, beaconnumberc,

rollingRSSIArray):
beacona = conf.BeaconList [beaconnumbera]; beaconb =

conf.BeaconList [beaconnumberb]; beaconc =
conf.BeaconList [beaconnumberc]; xa = flotador (beacona
[2]) ya = flotador (beacona [3]) xb = flotador (beaconb [2]) yb
= flotador (beaconb [3]) xc = flotador (beaconc [2]) yc =
flotador (beaconc [3])
ra = flotador (calculateDistanceWithRSSI (rollingRSSIArray [beaconnumbera], beaconnumbera))
rb = flotador (calculateDistanceWithRSSI (rollingRSSIArray [beaconnumberb], beaconnumberb))
rc = flotador (calculateDistanceWithRSSI (rollingRSSIArray [beaconnumberc], beaconnumberc))
S = (pow (xc, 2.) - pow (xb, 2.) + pow (yc, 2.) - pow (YB, 2.) + pow (rb, 2.) - pow (rc, 2.)
) / 2,0
T = (pow (xa, 2.) - pow (xb, 2.) + pow (ya, 2.) - pow (YB, 2.) + pow (rb, 2.) - pow (ra, 2.)
) / 2,0
tratar:
y = ((T * (xb - xc)) - (S * (xb - xa))) / (((ya - yb) * (xb - xc)) - ((yc - yb) * (xb - xa
))) x = ((y * (ya - yb)) - T) / (xb - xa)
excepto ZeroDivisionError como detalle:

imprimir 'el tratamiento de errores en tiempo de ejecución:', detalle de retorno
[-1, -1]
punto = [x, y] punto

de retorno
El panel de control IOTBeaconAir

El panel de control IOTBeaconAir se construye utilizando una aplicación llamada RasPiConnect ( www. milocreek.com ). Se me permite
construir paneles de control elaborados en iPhones y iPads con casi ninguna codificación y sobre todo sin la codificación en absoluto en
el iPad / iPhone. La respuesta es buena, sobre todo en una red local, y obtener una gran cantidad de botones de colores y los controles
para usar y divertidos. He utilizado esta aplicación en cuatro proyectos ahora y yo estoy bastante bueno en usarlo.
135
El panel de control completo se muestra en la figura 4-8 .
La Figura 4-8. Pantalla de control de RasPiConnect para IOTBeaconAir
El lado derecho del panel de control tiene que ver con el mapa y el control de las luces HTML. El control remoto
vista Web HTML ya se ha discutido. El cuadro de la tala verde es un control de burbuja de la charla y se puede configurar
para leer periódicamente desde el servidor y escribir información de registro en el panel de control. El código está
contenido en bubblelog.py en el directorio IOTBeaconAir. En el ejemplo anterior se puede ver las balizas cercanas a la
deriva ligeramente, cambiando el ranking de los cuales baliza es más cercano. Por último, vemos que dos luces se
encienden (se puede ver los resultados en el mapa de la casa). Debajo de eso es un gráfico que muestra cómo se leen
muchas balizas. El gráfico anterior podría ocurrir si caminamos fuera del alcance de los faros y luego volvió a entrar en el
rango.
Los controles en el lado izquierdo se utilizan para ajustar la distancia en metros para que al encender las luces para
y el segundo control ajusta el brillo de la luz. Por ejemplo, se puede ajustar la sensibilidad de brillo a 1 metro y se comienza
a recibir brillante a 1 metro y crecer más brillante a medida que se acerque. Sería fácil modificar el software para cambiar
los colores de las bombillas Phillips Hue según la distancia o la hora del día. El gráfico de la parte inferior del lado derecho
es un control dinámico minigráfico establecido para avanzar cada vez (event driven) hay un cambio en el valor de la
fluctuación. También puede configurarlo para un evento programado, lo que significa que avanza todo el tiempo y sólo
añade nuevos valores a medida que llegan desde IOTBeaconAir.
136
El código para todos los botones es bastante similar. Presionando un botón en el IPAD envía un paquete XML
HTML en el software de Frambuesa Pi, que luego se escribe en un archivo de comandos, que IOTBeaconAir luego toma
y ejecuta las funciones solicitadas.
En RasPiConnectServer (archivo Local.py) el bloque de código para el “All Lights On” (un botón Comentarios
- FB-2) es la siguiente:
# FB-2 - enciende las luces de encendido y apagado si

(== objectServerID "FB-2"):
# comprobar si hay solicitud de validación
# Validar permite RasPiConnect para verificar este objeto es aquí si (== validar "SÍ"):

# No validar la solicitud, por lo que ejecutar
ResponseData = "XXX"
si (objectName es Ninguno):
objectName = "XXX"
lowername = objectName.lower ()
si (== lowername "todas las luces encendidas"):
estado = sendCommandToBeaconAirAndWait ( "ALLLIGHTSON")

ResponseData = "todas las luces off" ResponseData = responseData.title ()
elif (lowername == "todas las luces"):
estado = sendCommandToBeaconAirAndWait ( "ALLLIGHTSOFF")

ResponseData = "todas las luces en" ResponseData = responseData.title ()
# predeterminado en otro
sitio:
estado = sendCommandToBeaconAirAndWait ( "ALLLIGHTSON") lowername
= "todas las luces off" ResponseData = lowername.title ()

137
Cuando el valor del botón viene ( “todas las luces”), el código lo compara, envía una orden al IOTBeaconAir, y luego
cambia el valor ( “todas las luces encendidas”) y lo envía de vuelta a la App RasPiConnect configurar el botón Siguiente
(que será el próximo convertir todas las luces encendidas). El resto del código es repetitivo construcción de la solicitud XML
RasPiConnect y gastos de una condición de error que a veces sucede (el botón se pone en blanco).
El código IOTBeaconAir para manejar la petición de archivo de comandos es simple:
si (== comando "ALLLIGHTSON"):

lights.allLights (verdadero, currentLightState)
si (== comando "ALLLIGHTSOFF"):

lights.allLights (Falso, currentLightState) CompleteCommand
() devuelven True
Todos los controles siguen el mismo patrón de diseño, aunque los controles son de representación gráfica un poco más
complicado. Para seguir cualquier comando a través del sistema, averiguar cuál es el ID de control que busca es (FB-2 en
nuestro ejemplo anterior), y realizar un seguimiento a través de Local.py y luego ver lo que hace el comando en
IOTBeaconAir.py. En algunos casos, como en los gráficos, IOTBeaconAir es la construcción de los datos del gráfico, escribirlo
en un archivo, y luego RasPiConnectServer lo lee en Local.py. La vista Web remoto (el mapa casa, W-10 es el identificador de
objeto) es uno de estos controles que lee en un archivo generado por IOTBeaconAir. py (ver el software en webmap.py). El
archivo de configuración XML para RasPiConnect IOTBeaconAir está en github.com/switchdoclabs.
La última cosa a tener en cuenta es cómo construir el fondo fresco IOTBeaconAir en la pantalla del panel de
control. El truco es construir un archivo JPEG o PNG en cualquier aplicación gráfica (como grafio en el iPad [ tentouchapps.com/grafio/]
o GIMP), añadirlo a la biblioteca de fotos del iPad, y luego seleccionar la imagen del fondo del panel de control
para la página IOTBeaconAir en RaspiConnect. Esto le da un fondo de aspecto profesional instantánea.
Instalación y Bluez Phue en la Raspberry Pi

Ahora es el momento de instalar Bluez y Phue en el Pi. Estar preparado. Las instalaciones tendrán un tiempo, también, sobre
todo la instalación de bluez. Puede utilizar la versión estándar de apt-get de Bluez, pero la versión de apt-get estándar es
antiguo y tiene el apoyo irregular para iBeacons. En lugar de utilizar apt-get para el paquete principal Bluez, estamos
descargando la fuente y compilarlo en la Raspberry Pi. Todos los comandos para hacer esto se incluyen en los siguientes
pasos. Todavía es un muy buen apt-get para el paquete auxiliar, que se instala como se muestra a continuación.
138
BlueZ
Para instalar en un Bluez Frambuesa Pi 3 o una versión anterior del Pi ejecutar la nueva distribución Jessie o posterior
distribución, ejecute los siguientes comandos en una ventana de terminal:
sudo apt-get update && sudo apt-get upgrade
sudo apt-get install libusb-dev

sudo apt-get install libglib2.0-dev sudo --fix-desaparecidos apt-get
install sudo libudev-dev apt-get install libical-dev sudo apt-get install
libreadline-dev sudo apt-get install libdbus-glib-1- dev
sudo apt-get install blueman bluez bluetooth
sudo apt-get install python-bluez sudo shutdown

-r now
Para instalar una nueva versión de Bluez en el pi en las versiones anteriores de la Frambuesa Pi (RPi2 y antes
de la distribución Raspian Jessie), haga lo siguiente:
sudo apt-get install libusb-dev sudo apt-get install

libdbus-1-dev
sudo apt-get install libglib2.0-dev sudo --fix-desaparecidos apt-get
install libudev-dev sudo apt-get install libical-dev sudo apt-get install
libreadline-dev
sudo mkdir bluez cd

bluez
sudo wget www.kernel.org/pub/linux/bluetooth/bluez-5.19.tar.gz sudo gunzip
bluez-5.19.tar.gz sudo tar xvf bluez-5.19.tar cd bluez-5.19
sudo ./configure --disable-systemd sudo make
sudo make install
sudo apt-get install python-bluez
sudo shutdown -r now
139
Ahora usted tiene bluez instaladas y funcionando en su Frambuesa Pi. A continuación, instale el USB Dongle
Bluetooth 4.0 y empezar a pagar. Por ejemplo:
pi @ BeaconAir ~ / BeaconAir / ble $ lsusb
Bus 001 Device 002: ID 0424: 9512 Standard Microsystems Corp. Bus 001 Device 001:
ID 1d6b: 0002 Fundación Linux hub 2.0 raíz Bus 001 Device 003: ID 0424: EC00
Standard Microsystems Corp. Bus 001 Device 004: 0a5c ID: 21e8 Broadcom Corp.
Tenga en cuenta, su dongle Bluetooth USB debe aparecer algo como esto dependiendo de lo que haya
conectado a su bus USB. Se puede ver mucha más información sobre el dispositivo USB escribiendo esto:
sudo lsusb -v -d 0a5c:
Ahora se puede buscar el dispositivo Bluetooth utilizando hciconfig:
pi @ BeaconAir ~ / BeaconAir / ble $ hciconfig hci0: Tipo:

BR / EDR Bus: USB
BD Dirección: 00: 02: 72: CC: DF: D1 ACL MTU: 1021: 8 SCO MTU: 64: 1 de correr
RX bytes: 9071808 acl: 0 sco: 0 eventos: 230151 Errores: 0 bytes TX: 1166
acl: 0 sco: 0 comandos: 100 Errores: 0 Por último, a su vez, en el dispositivo:
pi @ BeaconAir ~ / BeaconAir / ble $ sudo hciconfig hci0 hasta
Y ahora ejecutar el blescanner ( github.com/switchdoclabs/iBeacon-Scanner- )

comando para ver lo que podría ser iBeacons su alrededor. Si usted no tiene un IBeacon, se puede simular en ya sea
con su iPhone o teléfono Android con cualquier número de aplicaciones en la App Store.
cd / home / pi / BeaconAir / ble
pi @ BeaconAir ~ / ble $ sudo python testblescan.py

hilo ble comenzó
----------
cf: 68: cc: c7: 33: 10, b9407f30f5f8466eaff925556b57fe6d, 13072,52423, -74, -78 cf: 68: cc: c7: 33:
10,74696d6f74650e160a181033c7cc68cf, 46608,13255, -52, -77 da: f4: 2e: a0: 70: b1,
b9407f30f5f8466eaff925556b57fe6d, 28849,11936, -74, -79 da: f4: 2e: a0: 70:
b1,74696d6f74650e160a18b170a02ef4da, 46769,28832,46, -78 dd: 5d: d3: 35: 09 : dd,
8aefb0316c32486f825be26fa193487d, 1,1, -64, -78 c3: 11: 48: 9b: cf: fa,
8aefb0316c32486f825be26fa193487d, 0,0, -64, -73 fd: 5b: 12: 7f: 02: e4,
b9407f30f5f8466eaff925556b57fe6d , 740,4735, -74, -79 fd: 5b: 12: 7f: 02:
e4,74696d6f74650e160a18e4027f125bfd, 46820,639,18, -80 dd: 5d: d3: 35: 09: dd,
8aefb0316c32486f825be26fa193487d, 1,1, -64, -77
140
El contenido de cada línea de arriba es la siguiente:
ejemplo: cf: 68: cc: c7: 33: 10, b9407f30f5f8466eaff925556b57fe6d,

13072,52423, -74, -78
Beacon de direcciones MAC, IBeacon UDID, IBeacon Número Major, IBeacon número menor, la potencia TX a 1m,
RSSI
Tenga en cuenta que hay algunos dispositivos impares por encima de que no son mis Estimote
(b9407f30f5f8466eaff925556b57fe6d) o partículas (8aefb0316c32486f825be26fa193487d) iBeacons. El txpower para los
dispositivos Estimote y de partículas se comportan correctamente. Los dispositivos tienen un mayor número impar o en realidad los
números que varían. Información interesante .
Phue
La instalación de Phue en su Pi es simple. Un método consiste en ejecutar la llamada fácil de instalar. Por
ejemplo:
Phue sudo easy_install
La alternativa es invocar la pipa de la siguiente manera:
sudo PIP instalar Phue
Tenga en cuenta que después de la primera vez que se ejecuta en su IOTBeaconAir Frambuesa Pi, la biblioteca se cerrará
Phue que le dice que tiene que empujar el botón Phillips Hue concentrador y vuelva a ejecutar el software. IOTBeaconAir a
continuación, se combina con el tono Hub Phillips.
RasPiConnectServer de inicio
Ahora que todo el código se ha instalado para iBeaconIOT, es necesario poner en marcha el código. Los pasos del procedimiento de
arranque siguen.
Procedimiento de inicio
Para poner en marcha IOTBeaconAir, lo que necesita hacer tres cosas.
1. Encienda el dispositivo Bluetooth de la siguiente manera:
sudo hciconfig hci0 hasta
141
2. Cambiar al directorio IOTBeaconAir. Poner en marcha la

IOTBeaconAir de programación Python, ya sea mediante la invocación
sudo pitón IOTBeaconAir.py ( en su propia ventana de terminal)
o
sudo nohup python IOTBeaconAir.py y ( desde la línea de comandos)
3. Cambiar al directorio RasPiConnectServer. Iniciar el

RasPiConnectServer. Puede ejecutar este comando, ya sea:
sudo sh startserver.sh ( en su propia ventana de terminal)
o este:
sudo sh nohup startserver.sh y ( desde la línea de comandos)
Si utiliza nohup, puede cerrar la ventana de terminal y el programa sigue funcionando en segundo plano hasta que se
reinicie o matar al programa. Todos los datos de depuración entra en un nohup.out archivo en el directorio de inicio. Si usted
quiere ver lo que está pasando usando nohup, vaya al directorio del programa y el tipo nohup.out tail-f en la línea de
comandos.
Haciendo IOTBeaconAir de inicio en el arranque
Puede hacer que se inicia cuando se inicia el IOTBeaconAir Pi editando /etc/rc.local. El archivo / etc / rc.local es un script en el Pi de
frambuesa que se ejecuta cuando se inicia por primera vez Linux. Para editarlo, necesitará privilegios de root. Invocando el editor a
través de sudo es el camino a seguir aquí:
/etc/rc.local sudo nano
A continuación, añadir las siguientes líneas al archivo rc.local. Colocar las líneas recién añadidos antes de
la sentencia exit 0.
sudo hciconfig hci0 hasta
fecha >> /var/log/RasPiConnectServer.log

echo "A partir RasPiConnectServer ..." >> >> /var/log/RasPiConnectServer.log nohup
/home/pi/RasPiConnectServer/startserver.sh / var / log / RasPiConnectServer.log 2> & 1 y
fecha >> /var/log/BeaconAir.log

echo "A partir IOTBeaconAir .." >> /var/log/BeaconAir.log cd / home / pi /
BeaconAir /
nohup sudo python IOTBeaconAir.py >> / var / log / RasPiConnectServer.log 2> & 1 y
142
¿Cómo funciona en la práctica

IOTBeaconAir funciona. Mientras camino por ahí con la IOTBeaconAir portátil Pi en una riñonera, las luces
se enciendan y apaguen. He publicado un vídeo de la acción de
www.switchdoc.com .
Sin embargo, los iBeacons no son muy fiables y pueden variar significativamente sentado en un solo lugar. Usted puede ver el
pequeño rebote pin rojo alrededor del panel de control. Mucho se podría hacer para suavizar esto haciendo un poco de
procesamiento de señales a costa de tiempo de respuesta. Sin duda, hace una demostración interesante para mostrar a la gente.
Cosas para hacer

Puede utilizar las técnicas de los capítulos MQTT 5 y 6 para conectar el IOTBeaconAir a un servidor externo IOT o
tweet como su ubicación en el capítulo 3 .
Una idea que tuve para otro proyecto que gira en torno iBeacons era invertir el sistema. Realizar un IBeacon y
construir una red de malla de Frambuesa Pi de toda la escucha de la IBeacon a través de mi programa de escáner
BLE y luego comunicar la información a un RSSI Pi central que averiguar la ubicación de la IBeacon e informar de ello
al panel de control. Ahora concedido, es más caro que comprar un montón de iBeacons y uno Pi, pero tendría que
algunos flujos de datos muy interesantes y el tiempo de respuesta podría ser excelente. Sería mucho mejor para el
usuario ya que sólo tendría que llevar una pequeña IBeacon en su bolsillo! Mejor para el consciente de la moda de una
riñonera. Figura 4-9 IOTBeaconAir muestra instalada en una riñonera muy consciente de la moda.
Figura 4-9. IOTBeaconAir listo para recorrer
143
Lo primero que me gustaría añadir a esta unidad es la capacidad para la Frambuesa Pi para detectar los niveles de luz en
el ambiente. ¿Por qué encender las luces si ya es brillante en la habitación?
Los problemas Sistema Distribuido Classic

Ahora voy a hablar sobre el problema clásico con grupos de dispositivos IOT. ¿Qué se hace si dos unidades IOT están
diciendo las luces de dos cosas diferentes? ¿Quién gana?
Si fuéramos a construir un montón de estos dispositivos y ponerlos en otros miembros de la familia (otras personas o
el gato), ahora tenemos que construir un sistema de arbitraje. ¿Qué quiero decir con eso? Tenemos que “arbitrar” la
información que viene de los dispositivos IOT. En jerga informática, un grupo de unidades IOTBeaconAir sin coordinador
central se convierte en un sistema distribuido. A partir de la definición de Wikipedia de los sistemas distribuidos [ en.wikipedia.
org / wiki / Distributed_computing ] , “Un sistema distribuido es un sistema de software en el que los componentes situados en
equipos en red se comunican y coordinan sus acciones mediante el paso de mensajes. Los componentes interactúan entre
sí con el fin de lograr un objetivo común. Tres características importantes de los sistemas distribuidos son: la concurrencia
de los componentes, la falta de un reloj mundial, y el fracaso independiente de componentes “Se puede ver de esto que
cualquier grupo de dispositivos IOT encaja dentro de esta definición..
Dado que no hay un servidor global para IOTBeaconAir, no existe un mecanismo definido actualmente para manejar el
arbitraje de acciones basadas en la detección. En general, es más fácil de resolver este tipo de problemas mediante el uso de
un servidor global. Sin embargo, esto hace que el sistema sea más susceptible a fallos del servidor. Grupo de
auto-organización y arbitraje grupo es un mejor camino a seguir, pero es mucho más complicado de diseñar, implementar y
probar.
Estas son algunas de las preguntas para arbitrar una vez que tenga múltiples unidades de IOT IOTBeaconAir:
• ¿Qué IOTBeaconAir enciende las lámparas?
• ¿Qué IOTBeaconAir apaga las luces?
• ¿Cómo se maneja una persona salir de la habitación?
• ¿Cómo clasificar las unidades IOTBeaconAir el uno al otro? Es el gato en la parte inferior o
superior de la lista de prioridades?
• ¿Cómo se maneja la gente encender las luces o con la mano?
• ¿Cómo se detecta una persona que se sienta a leer frente a caminar por la
casa?
Y la lista continúa. Cualquier vez que se ponga más de un dispositivo IOT en control de nada físico en
absoluto, las cosas pueden ser muy complicado.
144
Conclusión
en el capítulo 3 , Hemos construido un dispositivo IOT tiempo que genera y suministra la información al resto de
Internet. En este capítulo hemos visto cómo se invierte IOTBeaconAir eso. Se recopila información de los dispositivos
(IOT) iBeacons alrededor de sí mismo, y luego modifica el ambiente sin salir a Internet (o la más amplia IOT) en
absoluto. Esta es una aplicación IOT mucho más localizada.
en el capítulo 6 , Vamos a extender esta idea aún más mediante la construcción de un RFID (Radio Frequency
IDentification) unidad que va a recabar información de las unidades pasivas (que sólo se activan cuando están
siendo interrogados para obtener información) y luego hacer las dos funciones principales. Enviar datos a
Internet y modificar el entorno local.
Para todo el software, consulte el siguiente:
github / switchdoclabs / BeaconAirPython github / switchdoclabs /
BeaconAirRasPiConnectLocal github / switchdoclabs /
IBeacon-Escáneres
Para más información sobre IOTBeaconAir y discusión: www.switchdoc.com
145
CAPÍTULO 5
Conexión de un dispositivo IOT a un

servidor de la nube - IOTPulse
Capítulo Objetivo: construir un dispositivo portátil para la lectura IOT el pulso
• IOT en una Red Global
• Bluemix y la Internet de las cosas
• El diseño IOTPulse
• La construcción del dispositivo IOTPulse
• Conectar y probar el hardware y software para IOTPulse
• Configuración de IBM bluemix y conexión de IOTPulse
• Analicemos los resultados y las características avanzadas
En este capítulo se va a mostrar al lector cómo conectar un dispositivo IOT a un servidor de la nube, IBM bluemix. La
complejidad de este capítulo no es construir el dispositivo, sino más bien la navegación por el proceso de configuración para
añadir el dispositivo a la nube.
Una parte importante del diseño de dispositivos que se conectarán con la IOT es determinar qué hacer con los datos después de
que haya reunido la misma. Una enorme cantidad de datos y no hay manera de almacenar o analizar no es muy útil. Un dispositivo de
proyecto IOT generalmente es muy limitado CPU y también sólo tiene una cantidad limitada de almacenamiento disponible. En general,
usted tiene que enviar los datos recogidos por un dispositivo sensor de IOT-llenado a un ordenador y el almacenamiento de nube más
grande para realizar un análisis complejo de los recursos que en esos datos.
En este capítulo, estamos construyendo un dispositivo para recoger el pulso de una persona, y luego periódicamente
(cada 10 segundos) lo envían a un sistema de almacenamiento y análisis basado en la nube llamada la Fundación IBM bluemix
IOT.
Antes hemos elegido la IBM bluemix para este capítulo, también hemos buscado en otros tres proveedores. Se determinó
que la solución Amazon IOT era demasiado “pesada” para estos pequeños dispositivos, debido al protocolo y cifrado requerido.
Los otros dos proveedores más pequeños fueron rechazadas debido a la longitud de tiempo en la existencia y la funcionalidad de
análisis limitado. Cabe señalar que los proveedores más pequeños tenían capacidades de visualización netamente superiores de
la caja de cualquiera de las dos mayores.

CAPÍTULO 5 ■ Conexión de un dispositivo IOT a un servidor NUBE - IOTPULSE
El sistema IBM bluemix trajo una buena mezcla de protocolos flexibles, un método de “luz” para el envío de datos, y una
impresionante colección de herramientas analíticas. Ramificaciones de la metodología de IBM bluemix cifrado en comparación
con la solución de Amazon IOT se discutirán en el capítulo 7 , “La seguridad informática y la IOT.”

Como ya comentamos en el capítulo 1 , Lo primero que hay que hacer para entender un proyecto IOT es mirar a nuestros seis
diferentes aspectos de la IO se muestra en la tabla 5-1 . IOTPulse es un proyecto más complejo que LightSwarm y es mucho más
cercano a un dispositivo IOT producción.
Tabla 5-1. IOTPulse Caracterización (CPLPFC)
comunicaciones 9 conexión WiFi a Internet -
procesador Power 7 80MHz Xtensa Harvard arquitectura de CPU, memoria RAM de datos ~ 80KB
/ ~ 35 KB de RAM Instrucción / 200K ROM
El consumo de energía 8 ~ 200 mA de transmisión, recepción ~ 60mA, noWiFi ~ 15 mA, 1 mA

en espera ~
aplicaciones de IO.
Esto nos da una calificación de 8,0 CPLPFC. Grande para el aprendizaje y la experimentación, y que podría ser desplegado
para algunas aplicaciones del mercado.
El ESP8266 proporciona una conexión Wi-Fi transmisor / receptor, una pila TCP / IP, y el firmware para soportar
conexiones de dirección a un punto de acceso WiFi local, que puede conectarse a Internet. Los datos generados por el
diseño IOTPulse serán enviados al sitio de la nube bluemix IOT de IBM.
La Internet de las cosas en la Red Global

Como se dijo en la introducción, ¿qué hacer con todos estos datos se están reuniendo? Si se trata de la edad de la
leche en el refrigerador, la tasa de azúcar en la sangre o el impulso de corriente, o su sistema de seguridad, los datos
tienen que ser almacenados y analizados; o lo que es el punto de recogerla?
A veces no es necesario para almacenar los datos. A veces, los dispositivos locales pueden hacer las acciones
necesarias (como en el proyecto LightSwarm en el capítulo 2 ), Pero hay muchas aplicaciones que requieren más recursos
informáticos que podría estar disponible entre los dispositivos locales IOT.
148
Esta es la situación que ha dado lugar al desarrollo de (a menudo en una nube de computación) de soporte de software
basada en servidor para la próxima explosión IOT. en el capítulo 2 , Se utilizó una Raspberry Pi para reunir los datos de la
LightSwarm y registrar el comportamiento más bien compleja del enjambre propia cooperativa para su posterior análisis. Si usted
tiene unos dispositivos mil, lo más probable es que no va a ser capaz de alojar su servidor en una Raspberry Pi, lo que ha limitado el
poder de la CPU y el almacenamiento. Otro problema importante con basando su sistema en servidores físicos que usted controla
(como Raspberry Pi, sino también para montaje en rack de servidores con capacidad de CPU y memoria mucho más grandes) es la
de escalabilidad. Si de repente usted tiene
10.000 dispositivos de conexión a los servidores en lugar de 1.000 dispositivos, hay que ser capaz de escalar con rapidez y
eficacia.
Es esta comprensión de que los sistemas de IOT necesitan para escalar de forma rápida y eficiente que se ha movido las
aplicaciones de back-end IOT en el ámbito de la computación en nube. Para una aplicación IOT, hay tres áreas principales que
necesitan ser abordados. Son los siguientes: Cloud Computing, Constructores de aplicación y generación de informes y de
software.
Computación en la nube
La computación en nube está evolucionando rápidamente para transformarse en más servicios, extremos traseros ubicuos,
conectividad de red de alta velocidad, y múltiples lenguajes y soluciones. El Instituto Nacional de Ciencia y Tecnología (NIST)
proporciona un documento que define la computación en nube para los propósitos de la administración [ http://csrc.nist.gov/publications/
nistpubs / 800-145 / SP800-145.pdf ] . Mientras que las piezas de lo que ya son anticuadas, que da una buena definición de
base de la nube.
NIST define cloud computing como esto: “La computación en nube es un modelo que permite, acceso ubicuo
conveniente, a pedido de red a un conjunto compartido de recursos informáticos configurables (por ejemplo, redes,
servidores, almacenamiento, aplicaciones y servicios) que pueden ser rápidamente aprovisionado y puesto en libertad con
mínimo esfuerzo de gestión o interacción proveedor de servicios “.
Las características esenciales de computación en la nube son los siguientes:
1. servicios de suministro lata de computación del usuario como - On-Demand
sea necesario, sin requerir la interacción con el proveedor de servicios.
2. La conectividad a Internet de alta - las capacidades de la nube están disponibles
través de la red y se accede a través de mecanismos que promueven el uso de

múltiples plataformas (no sólo los escritorios, pero muchos otros tipos de equipos y
dispositivos).
3. Capacidad de reunir recursos - Los recursos tales como la memoria, la CPU
poder, y el almacenamiento se agruparon para soportar múltiples usuarios y clientes de acuerdo
con la demanda del usuario.
4. Ampliar rápidamente - Capacidades y recursos se pueden aprovisionar

y liberado de forma automática o bajo control del usuario. Con el sistema y el
software adecuado, la nube puede parecer a ser virtualmente ilimitado al usuario o
aplicación.
149
5. Posibilidad de limitar (o metro) Recursos - Una nube será capaz de

limitar los recursos y optimizar el uso de recursos en varios niveles de abstracción.
6. La capacidad de cobro por servicio - Un servicio en la nube es capaz de
cuenta para el uso de recursos, sea capaz de controlar esos recursos, e informar el
uso de una manera transparente tanto para el proveedor y el usuario del sistema.
los creadores de aplicaciones
No hay manera de que un proveedor de nube puede anticipar cada aplicación o uso de los datos que va a necesitar un proveedor de IOT. Un
buen proveedor de la nube apoyará principales tipos de bases de datos y una variedad de interfaces de programación de aplicaciones de
software estándar (API). Además, proporcionará herramientas analíticas para los datos y una variedad de diferentes servicios para la
manipulación de los datos. Una aplicación de la nube (o aplicación nube) es un programa que se ejecuta en un entorno de nube. Tiene algunos
aspectos de una aplicación local de pura (para un iPad o un ordenador de sobremesa) y algunos aspectos de una aplicación basada en la web
pura. Una aplicación local de residirá en su totalidad en el equipo local, mientras que una aplicación web en general se almacena por completo
en un equipo remoto y se entrega a través de una interfaz de navegador. Hay aplicaciones web que son un híbrido (como WebEx) que tienen
un cliente muy ligero en el lado del navegador (todavía una aplicación, pero una pequeña) que se conecta a través de una API para un
programa mucho más complejo en el lado del servidor. Los creadores de aplicaciones de IBM bluemix tienen un cliente pesado (ejecutando los
gráficos y edición de parte de la aplicación) y luego entregar el diseño de usuario a los servidores a través de una API.
En el mundo IOT, una aplicación a menudo tiene ambos aspectos, donde el ordenador local contiene parte de la
aplicación (por ejemplo la recogida de datos del sensor) y la nube contiene el procesamiento de metales pesados back-end
para la aplicación completa. El proyecto IOTPulse es uno de estos tipos mixtos de aplicaciones.
Visualización y generación de informes

Viendo la información pertinente al usuario acerca de los dispositivos IOT del usuario y las acciones que se
están realizando en nombre del usuario es un aspecto importante que dará lugar a la adopción de
aplicaciones generalizadas IOT. Se sostiene por algunos que es importante no abrumar al usuario con
datos sobre lo que está pasando. Sin embargo, creemos que la parte “abrumadora” de la IOT se puede
manejar con interfaces jerárquicas. El más alto nivel de la interfaz de usuario sólo puede mostrar la
información básica necesaria para el usuario (digamos estado de la temperatura y el horno). El autor asistió
a una reunión temprano de lo que se convertiría en la IOT en Microsoft en Redmond, Washington,
Nos pareció que era cierto en lo que se fue, pero con la IOT, la capacidad de un dispositivo y software de interfaz para
mostrar lo que está pasando con los datos sean recogidos es de suma importancia. Un método y la interfaz tiene que ser
proporcionada por el usuario para perforar realmente abajo y ver lo que está sucediendo dentro de su red y dispositivo en varios
niveles diferentes. No como parte de la interfaz de “Modo de la abuela”, pero otro conjunto de interfaces que son accesibles a
cualquier usuario si el usuario deseara.
150
Haciendo esta interfaz jerárquica es una parte clave de establecer la confianza necesaria entre el usuario y
el dispositivo IOT.
Una aplicación basada en la nube bien diseñado e informar sistema de generación tiene que proporcionar al desarrollador de
aplicaciones diferentes maneras de analizar los datos, que actúa sobre los datos, y la visualización de los datos. El desarrollador de la
nube nunca será capaz de suministrar todas las posibles interfaces de construcción que necesitará el desarrollador de la aplicación para
cada aplicación.
El IBM bluemix Internet de las cosas Solución

Bluemix (Figura 5-1 ) Es una aplicación centrada en la IOT de la nube de IBM de arquitectura abierta que permite
crear, desplegar y gestionar aplicaciones en la nube para la Internet de las cosas.
La Figura 5-1. El logotipo de IBM bluemix
Hay un creciente ecosistema de los marcos de tiempo de ejecución y servicios, incluidas las soluciones y aplicaciones de
terceros no son de IBM. Bluemix proporciona un panel de control para que pueda crear, ver y administrar sus aplicaciones,
dispositivos, IOT y servicios deseados Los cuadros de mando bluemix también proporcionan la capacidad de gestionar las
organizaciones, los espacios, y (muy importante!) El acceso de usuarios.
Se encontró que el paradigma de “tablero” en el sistema bluemix algo de un nombre inapropiado y un poco confuso.
En lugar de tener un panel de control, que tiene cuadros de mando para todos los servicios que se adjunta. Es fácil
perderse en la secuencia. Pero con un poco de perseverancia llegamos a través de la curva de aprendizaje.
Bluemix proporciona acceso a una amplia variedad de servicios que pueden ser incorporados en una aplicación de
múltiples proveedores.
151
Para aplicaciones más complejas que el dispositivo IOTPulse, tiene un conjunto de bibliotecas de aplicaciones
que se pueden construir sus aplicaciones que se conectan a una variedad de funciones y estructuras de bases de
datos. Éstos son algunos de los más comunes:
• Node.js
• PHP
• Pitón
• Rubí
Con todo, bluemix es una buena implementación de una plataforma basada en la nube IOT a construir. Tenga en cuenta que
bluemix es una plataforma en evolución, y no habrá cambios de cara al futuro en su proceso de maduración del producto.
Hay muchas características que son gratuitos para prototipos (como IOTPulse), y todas las características
mencionadas en este capítulo son libres para su uso en bluemix. Mirando a través de los servicios de pago y tarifas,
parece que son razonables para los pequeños y grandes aplicaciones.
El diseño IOTPulse
El diseño IOTPulse consta de tres bloques. El primer bloque es el ESP8266 y la batería de 9V, que contiene el
equipo; la interfaz de WiFi; y un único convertidor de analógico a digital (ADC) pines, llamado A en el tablero
ESP8266 y A0 dentro del software de Arduino IDE. El ESP8266 es responsable de hacer el procesamiento de la
señal y la traducción de la señal analógica entrante latidos del corazón a un latidos digitales por minuto (BPM) y
luego enviará periódicamente la última BPM hasta la nube bluemix IOT.
El segundo bloque es el Sensor de Pulso Amped, que es un diseño de hardware de código abierto por www.pulsesensor.com . Figura
5-2 muestra el esquema para el sensor de pulso. La clave para llevar desde el sensor de pulso es que está diseñado para obtener una
medida aproximada de la frecuencia cardíaca a través de la piel de una manera no invasiva. Funciona por el resplandor de un verde
brillante del LED en la piel y luego la detección de los cambios relativos en la intensidad de la luz al sensor. Con una pequeña cantidad
de conformación de señal, se puede detectar la frecuencia del pulso a través de una señal de salida analógica.
La Figura 5-2. Esquemático para el sensor de pulso
152
Para obtener más información sobre la técnica, véase photoplethysmogram [ https: //

en.wikipedia.org/wiki/Photoplethysmogram ] .
El tercer bloque es un divisor de tensión basada en la resistencia. El problema que estamos resolviendo con este divisor
de tensión es que la señal emitida desde el sensor de pulso es de aproximadamente 1,5 V y la entrada al ADC en la ESP8266
sólo llega hasta 1V. Para una descripción completa de cómo funciona un divisor de tensión, consulte el artículo de Wikipedia [ https://en.wikipedia.
Voltage_divider ] .
Tenemos que tomar 1.5V a alrededor de 0,6 V para el ESP8266 y el software para trabajar. El sensor de pulso proporciona una señal
de que en promedio es de aproximadamente 1,5 V, que es demasiado alto para el ESP8266 ADC para que funcione correctamente. Con la
elección de una resistencia de 26K Ohm para R1 en la figura 5-3 y una resistencia de 18K Ohm para R2 en la figura 5-3 , Se obtiene la
siguiente relación de entrada a la tensión de salida:
Vout = Vin * R2 / (R1 + R2)
Vout = 1,5 V * 18K / (26K + 18K) = 0,6 V
La Figura 5-3. Divisor de tensión simple
El 0.6V está cómodamente en el 0,0 - 1,0 V gama del ESP8266 ADC y funciona bien. Prácticamente no hay
fuga de corriente a través de este divisor de tensión debido a la alta resistencia del divisor de tensión (44K Ohms).
¿Por qué funciona esto? Es porque el software en el ESP8266 es el cálculo de los latidos del corazón observando
los cambios relativos en la intensidad de la luz y no la tensión absoluta. Mientras el valor de entrada está cambiando, la
ESP8266 va a recoger el pulso.
153
Si no hemos puesto el divisor de tensión en la salida del sensor de pulso, a continuación, el ADC en el
ESP8266 siempre estaría vinculado al nivel más alto (1,0 V) y el software del sensor no sería capaz de recoger un
pulso.
Debido a que el ADC ESP8266 es tan limitado, hay mejores soluciones que hay para un ADC. Dos de los más fáciles de
usar tablas son las siguientes:
• Seeedstudio Grove I2C ADC - 1 canal, requiere 12 bits (5V - necesita un

poco de ayuda para trabajar con el ESP8266) [ www.seeedstudio.com/wiki/Grove_-_I2C_ADC
]
• SwitchDoc laboratorios Grove I2C ADC - 4 canales, 16 bits de 3.3V / 5V compatible [ www.switchdoc.com/grove-4-chan
]
Figura 5-4 muestra el diagrama de bloques, incluyendo el divisor de tensión, del proyecto IOTPulse. El dispositivo
IOTPulse completado, incluyendo el caso 3D impreso se muestra en la figura 5-5 .
La Figura 5-4. Diagrama de bloques de IOTPulse
154
Figura 5-5. IOTPulse en Caso
La construcción de la IOTPulse
La lista de piezas se muestra en la Tabla 5-2 , Seguido por la lista de cableado. Las piezas para el dispositivo IOTPulse son
fácilmente disponibles y sólo el divisor de tensión se requiere ninguna soldadura.
Tabla 5-2. Lista de partes

por la Junta
Junta Hurra 1 CPU / WiFi tablero de $ 10 http: //www.adafruit. com /

ESP8266 productos / 2471
Sensor de Pulso 1 Sensor de luz I2C $ 25 de www.Pulsesensor.com

Amped
FTDI cable 1 Cable para la programación $ 11 http: //www.switchdoc. com /

de la ESP8266 desde el PC barata-ftdicable-para-arduinoesp8266-incluy
/ Mac /
( continuado)
155

por la Junta
26K ohmios 1 1/4 vatios $ 17 para una gran http: // AMZN. a /

combinación de 1QCASLB
resistencias (Joe sabe
Electrónica)
18K ohmios 1 1/4 vatios $ 17 para una gran http: // AMZN. a /

combinación de 1QCASLB
resistencias (Joe sabe
Electrónica)
Enchufar el cable de FTDI en el ESP8266

Un cable de FTDI está conectado en el extremo de la Adafruit Hurra ESP8266. Asegúrese de alinear el pin GND en el
cable FTDI con el pin GND en el tablero del desbloqueo ESP8266 como se muestra en la figura 5-6 .
Figura 5-6. FTDI esté conectado a la Junta Hurra. Nota Conexión GND
156
Mesa 5-3 contiene la lista de cableado para el proyecto IOTPulse.
Tabla 5-3. Lista de cableado IOTPulse
ESP8266 / GND PulseSensor / GND (Negro Wire) Planta para el sensor de pulso
ESP8266 / 3V PulseSensor / 3.3V (Red Wire) 3.3V de alimentación para el sensor de pulso
PulseSensor / salida 26K / Puerto A Parte superior del divisor resistivo
(púrpura Wire)
26K / Puerto B 18 K / Puerto A Medio del divisor resistivo
18 K / Puerto A ESP8266 / GND Terreno para la parte inferior del divisor resistivo
26K / Puerto B ESP8266 / A0 A0 - analógica a la entrada del convertidor

digital en ESP8266
Impresión de archivos 3D para el caso del IOT
Encontrar un caso para un proyecto personalizado siempre puede ser un problema. Todos los proyectos en los capítulos han sugerido
utilizando la impresión 3D para construir los casos que se ajustan al proyecto, y el proyecto IOTPulse no es diferente. La parte más
interesante de este caso es la forma en que diseñamos un bisel que rodea la base de lo que el caso se ajustará la parte superior sobre la
caja inferior (figura 5-7 ).
La Figura 5-7. Caso IOT
157
Hemos introducido OpenSCAD, un modelador 3D basado en código libre en los capítulos anteriores. Hay
cientos de ejemplos de modelos en Thingverse.com y el sitio web OpenSCAD para elegir y aprender. Listado 5-1 contiene
el código que construye el caso mostrado en la figura 5-7 .
Listado 5-1. OpenSCAD código para el caso del IOT
//
// // Caso IOTPulse
// // SwitchDoc laboratorios de
agosto de 2015 //
incluir <RoundedRect.scad>
módulo rcube (tamaño = [30, 20, 10], radio = [3, 2, 1], centro = true)
casco () {
traducir (centro [0,0,0]: Capacidad / 2) {
cubo (tamaño 2 * radio + [2 * radio [0], 0,0], centro = true); cubo (tamaño 2
* radio + [0,2 * radio de [1], 0], centro = true); cubo (tamaño 2 * radio +
[0,0,2 * radio [2]], centro = true);
para (x = [-0.5,0.5], y = [-0.5,0.5], z = [-0.5,0.5])

traducir ([x * (tamaño [0] - 2 * radio [0]),
y * (tamaño [1] - 2 * radio [1]), z * (tamaño [2] - 2
* radio [2])]) escala ([radio [0], el radio [1], el radio [2]
])
// esfera (1.0, $ fn = 4 * 4); esfera
(1.0, $ fn = 6 * 6);
}}
módulo IOTPulseTopCase () {
diferencia () {
// cubo ([82,62,25]);
rcube (tamaño = [82,62,30], radio = [5,5,5], centro = false);
# traducir ([2,2,2]) del cubo

([78,58,25]);
# translate ([- 10, -10,25]) del cubo

([100,100,50]);
// agujero para 18mm metros pulso
158
translate ([- 5,62 / 2,12.5])

# girar cilindro ([0,90,0]) (h = 10, r
= 10,10);
// agujero para ver la luz

# traducir ([82-20,10, -2]) cilindro (h =
10, r = 5,10);
// agujero para ver la luz wifi

# traducir ([82-43,10, -2]) cilindro (h =
10, r = 5,10);
Unión() {

2, -2,0]) del cubo ([82,62,2]);
translate ([40-2,2,0]) del cubo

([40-2,1.35,20]); traducir ([40-2,26.10 +
3.3,0]) del cubo ([40-2,1.5,20]);
traducen ([79-2,3,0]) del cubo
([1,28,6]);
// plyons para ESP8266
traducir ([70-1.0,35,0])
([70-1.0,56,0])
([70-34,35,0])
([70-34,56,0])
cilindro (h = 10, r1 = 2,2, r2 = 1.35 / 2, $ fn = 100);
// plyons de las resistencias de divisor
// brecha de 2,3 mm
159

([1,5,5]);
traducir ([15 + 3,35,2]) del cubo

([1,5,5]);

([1,5,5]);
traducir ([15 + 3,45,2]) del cubo

([1,5,5]);
// Primer caso
traducir ([0,70,0])
IOTPulseTopCase (); }
El código para el caso IOTPulse se divide en dos secciones principales. El programa principal se basa la parte inferior de
la caja mientras que la parte superior de la caja se encuentra en la función IOTPulseTopCase (). Cuando la construcción de
modelos con OpenSCAD, es una buena idea para romper las diferentes partes en funciones, incluso si sólo está llamando una
vez. Simplifica el código. Ahora, vamos a ver el software para IOTPulse.
software necesario
Para programar la junta de pulso IOT se necesita un Mac o PC para programar el ESP8266 a través del IDE de Arduino.
Véase el capítulo 2 de cómo configurar el IDE Arduino con las bibliotecas ESP8266.
El Código IOTPulse
Hay tres archivos que forman parte de la construcción para el software IOTPulse. El IOTPulse.ino es el archivo principal de
Arduino IDE (en el lenguaje C), y los otros dos archivos (interrupt.h y AllSerialHandling.h) están incluidos en el archivo
principal. Mientras que el código es bastante sencillo, los comentarios deben hacerse para cada módulo.
IOTPulse.ino
IOTPulse.ino es el programa principal para IOTPulse (Listado 5-2 ). Se compone de dos funciones principales, setup
() y loop (). La función de configuración () inicializa el código ESP8266 Wi-Fi, lee una dirección IP mediante DHCP
del punto de acceso inalámbrico del área, e inicializa las variables para contener micros (), que es una función que
devuelve el número de microsegundos desde el reinicio de los micros ESP8266 ( ) es una función de cronometraje.
Tenga en cuenta que la ESP8266 no tiene un reloj en tiempo real a bordo y realmente no sabe qué hora es. Sólo se
sabe cuánto tiempo ha estado funcionando. Si desea fijar la hora del día en la ESP8266, por favor revisar el
protocolo NTP en este instructivo [ http: // www. instructables.com/id/Internet-time-syncronized-clock-for-Arduino/ ] .
160
En el proyecto IOTPulse, realmente no importa qué hora es. El hecho de enviar una muestra a la Plataforma IOT
bluemix, nuestro amigo IBM marca de tiempo de la recepción de los datos. Si nos importaba nuestro tiempo, podríamos
construir un receptor de NTP y sincronizarlo a la hora de red en un servidor específico NTP. Estamos mucho más
interesados en intervalos de tiempo (en concreto 2 milisegundos y los intervalos de 10 segundos) en lugar de tiempo
absoluto.
La función loop () contiene el código para la operación en curso de la operación de recolección de datos IOTPulse.
Básicamente, hacemos cuatro cosas en la función loop ():
• Comprobamos el valor de QS. Si QS es cierto, entonces el software en interrupt.h ha

encontrado un BPM (beats por minuto) e IBI (Intervalo entre latidos) valor para la
frecuencia de pulso actual de nuestra PulseSensor conectado a su oído.
• A continuación, si han transcurrido 10 segundos (10.000.000 microsegundos), enviamos el

valor actual de BPM e IBI a la nube de IBM bluemix IOT. A continuación, restablecer el tiempo
de espera para el siguiente intervalo de 10 segundos, que se almacena en la variable
oldIOTTime. El tiempo real para el siguiente intervalo es oldIOTTime + 10 segundos
(10.000.000 de microsegundos).
• Si han transcurrido 2 milisegundos desde variable de oldPulseTime (inicializado en bucle

()), que llama a la función timerCallback () definido en interrupt.h. A continuación,
restablezca la variable oldPulseTime y esperar a otro de 2 ms.
Nota al final de la función de bucle (), hay una función de rendimiento (). Esto se debe llamar periódicamente
para el software ESP8266 continúe funcionando la interfaz WiFi y otras funciones de mantenimiento. Recuerde, a
diferencia de un Arduino regular, hay una gran cantidad pasando en segundo plano para mantener este chip de
encendido y conectado a la red.
Una de las limitaciones del software ESP8266 actual es que no puede utilizar los temporizadores [ http://www.switchdoc.com
] para generar interrupciones sin causar la conexión Wi-Fi a fallar y detener la conexión al punto de acceso WiFi local
e Internet.
Esto hace que sea muy difícil para generar una interrupción a la computadora cada 2 ms como se requiera por la
PulseSensor. Se podría generar una interrupción cada 2 ms utilizando un temporizador de hardware externo y después
conectar la salida del temporizador de hardware a uno de los pines GPIO en la ESP8266, que todas pueden programarse
para generar una interrupción a la CPU.
Para resolver este problema, se utiliza una técnica de programación que es más intensivo de la CPU (lectura consume más
energía) que el esquema de interrupción. Comprobamos la hora periódicamente y ejecutar el software PulseSensor cada 2 ms y
también para conectar a la IBM bluemix cada 10 segundos.
La mayor desventaja de esto es que no se puede “dormir” el procesador con mucha facilidad. Estamos en busca
de una arquitectura alternativa para este problema y estamos viendo los sitios web de desarrollo de soluciones
ESP8266.
Sin embargo, con la excepción del consumo de energía, la solución actual funciona bien.
161
Listado 5-2. IOTPulse.ino
/*
Código laboratorios SwitchDoc para IOT pulso
Se conecta detector de impulsos a la IBM bluemix la IO usando un procesador ESP8266 basado en el código
pulsecounting de www.pulsesensor.com de noviembre de 2 015
---------------------- Notas ---------------------- ----------------------

Este código:
1) parpadea un LED para vivir Heartbeat PIN del usuario de 0
2) determina BPM
3) envía información a IBM bluemix IOT

*/
extern "C" {
# incluir "user_interface.h"}
# incluir <PubSubClient.h> // https://github.com/knolleary/pubsubclient/ de prensa / tag / v2.3
// ------------------------------------------------ --------------------- // Variables WiFi local
const char * SSID = "yourssid"; const char * password

= "sucontraseña";
# definir IOTPULSEVERSION 004
// IBM bluemix IOT Datos Fundación
# definir ORG "XXXXX"

# definir DEVICE_TYPE "IOTPulse-01"
# definir DEVICE_ID "1"
# definir Token "YYYYYYYYY"
// configura para IOT IBM
servidor char [] = ORG ".messaging.internetofthings.ibmcloud.com"; tema char [] = "IOT-2 /

evt / estado / fmt / json"; Char AuthMethod [] = "uso-token-auth"; Char TOKEN [] =
TOKEN;
Char clientId [] = "D:" ORG ":" DEVICE_TYPE ":" DEVICE_ID;
162
// ------------------------------------------------ ----------------------
// Variables
int pulsePin = A0; // Sensor de Pulso cable violeta conectado al pin analógico
0
int blinkPin = 0; // pin llevó a parpadear en cada latido
int fadePin = 5; // pin para hacer clase de fantasía decoloración abrir y cerrar en cada
latido
int fadeRate = 0; // utilizado a desvanecerse LED con PWM en fadePin
// variables volátiles, utilizados en la rutina de servicio de interrupción! volátil BPM int;

// int que contiene prima analógica en 0. actualiza
cada 2mS
volátil señal int; // contiene los datos de prima entrante
volátil int IBI = 600; // int que contiene el intervalo de tiempo entre latidos!
Debe ser cabeza de serie!
volátil pulso boolean = false; // "True" cuando se detecta los latidos del corazón en directo del
usuario. "Falso", cuando no un "ritmo vivo".
QS booleanos volátiles = false; // se convierte en realidad cuando Arduoino encuentra un latido.
// que respecta salida serie - configurar esta opción a sus necesidades

SerialData boolean estática = true; // Establecer a 'falso' por defecto. Volver a establecer a
'Verdadero' para ver los datos de Monitor de serie Arduino
# incluir "AllSerialHandling.h"
# incluir "interrupt.h"
devolución de llamada vacío (char * tema, byte * carga útil, sin signo int length) {Serial.println (
"devolución de llamada se invoca desde IOT bluemix"); }
WiFiClient wifiClient;
PubSubClient cliente (servidor de 1883, devolución de llamada, wifiClient);
largo oldPulseTime sin signo; largo

oldIOTTime sin signo;
void setup () {
pinMode (blinkPin, OUTPUT); // pin que parpadeará a los latidos del corazón!
Serial.begin (115,200); // estamos de acuerdo en que hablar rápido!
Serial.println ( "----------------"); Serial.println ( "IBM IOTPulse

bluemix IOT"); Serial.println ( "----------------");
163
Serial.print ( "Conexión a"); Serial.print

(SSID);
// NOTA a continuación: Las nuevas versiones de las bibliotecas ESP8266 pueden requerir la siguiente
declaración
// en lugar de otro comunicado. WiFi.SSID () ha cambiado las definiciones en las nuevas versiones
// si (strcmp (WiFi.SSID (). C_str (), SSID)! = 0) {
si (strcmp (WiFi.SSID (), SSID)! = 0) {WiFi.begin (SSID,

contraseña); }

(500);
Serial.print ( ""); }
Serial.print ( "Wi-Fi conectados, dirección IP local:"); Serial.println

(WiFi.localIP ());
// interruptSetup (); // establece para hacer la lectura de la señal del sensor de
pulso cada 2mS
// Nota: Las interrupciones en base a os_timer parece romper la ESP8266 WiFi. Pasando a
micros () Metodología de sondeo oldPulseTime = micros (); oldIOTTime = micros (); }
int SAMPLEcount = 0; int

beatCount = 0;
int beatValue = 0;
newPulseDeltaTime largo sin signo;
newIOTDeltaTime largo sin signo;
// lugar de la magia void loop () {
// SERIALOUTPUT ();
si (QS == true) { // un latido del corazón se encontró

// BPM e IBI se han determinado
// cuantificado de uno mismo "QS" Arduino cierto cuando encuentra un latido del corazón
digitalWrite (blinkPin, LOW); // parpadeo del LED, tenemos un latido.
beatCount ++;
164
serialOutputWhenBeatHappens (); // Un golpe ocurrido, que la salida de serie. QS = false;

// restablecer el indicador cuantificado de auto para la próxima vez
newPulseDeltaTime = micros () - oldPulseTime; // hacer esto se encarga el segundo vuelco 71, debido a
la aritmética unsighned
newIOTDeltaTime = micros () - oldIOTTime; // hacer esto se encarga el segundo vuelco 71, debido
a la aritmética unsighned
// hacer esto cada diez segundos

si (newIOTDeltaTime> 10000000) // comprobar si hay trabajo que hacer 10 seg {
Serial.print ( "tiempo de Delta IOT =");

Serial.println (newIOTDeltaTime);
SAMPLEcount ++;
// carga útil Enviando: { "d": { "IOTPulse": "IP1", "VER": 2 "SC": 0, "BPM": 235, "IBI": 252}}
carga útil String = "{\" d \ ": {\" IOTPulse \ ": \" IP1 \ ""; de carga útil + = "\"
ver \ ":"; carga útil + = IOTPULSEVERSION; de carga útil + = "\ " SC \":";
carga útil + = SAMPLEcount; de carga útil + = "\ " BPM \":"; carga útil + =
BPM; de carga útil + = "\ " IBI \":"; carga útil + = IBI; de carga útil + = "\
"BC \":"; carga útil + = beatCount; carga útil + = "}}";
si (!!! client.connected ()) {

Serial.print ( "volver a conectar al cliente"); Serial.println
(servidor);
mientras que (!!! client.connect (clientId, AuthMethod, token)) {Serial.print ( "");
retardo (500); }
Serial.println (); }
Serial.print ( "Envío IOTPulse carga útil:"); Serial.println (carga

útil);
165
si (client.publish (tema, (char *) payload.c_str ())) {Serial.println ( "bluemix

IOT Publicar ok"); } Else {
Serial.println ( "bluemix IOT no publicar"); }
oldIOTTime = micros ();
// reiniciar el contador restartPulse pulso

(); }
//Serial.print("micros()= "); //Serial.println

(micros ());
si (newPulseDeltaTime> 2000) // comprobar si hay 2ms trabajo por hacer {
tiempo Delta //Serial.print("Pulse = ");

//Serial.println(newPulseDeltaTime); // hacer el trabajo
para timerCallback cálculo de pulso (NULL);
oldPulseTime = micros (); }
rendimiento(); // tomar un descanso }
AllserialHandling.h (Listado 5-3 ) Contiene las rutinas de depuración de salida en serie que
son útiles cuando la modificación del código.
Listado 5-3. AllSerialHandling.h
//////////
Todo ///////// de serie Código de manejo,
///////// Es modificable con la variable 'serialVisual' ///////// Ajústelo en 'verdadero' o 'falso' cuando se declaró
al comienzo del código. /////////
anular sendDataToSerial (símbolo char, datos int);
SERIALOUTPUT vacío () {// decidir la forma de serie de salida.
sendDataToSerial ( 'S', Signal); // va a la función sendDataToSerial

}
// Decide cómo va a salir de BPM e IBI datos

serialOutputWhenBeatHappens void () {
166
si (SerialData == true) { // código para hacer el Monitor de serie

Visualizador trabajo
Serial.print ( "*** latido del corazón pasó ***"); // ASCII Art Madness Serial.print ( "BPM:");
Serial.print (BPM); Serial.print ( "IBI:"); Serial.print (IBI); Serial.println (" "); }}
// Envía datos a pulso el procesamiento de APP sensor, nativo Mac App, o lectores de serie de
terceros.
sendDataToSerial anular (símbolo char, int datos) {Serial.print
(símbolo);
Serial.println (datos); }
Interrupt.h (Listado 5-4 ) Se llama así porque el software original utilizó PulseSensor
un temporizador de Arduino para generar una 2ms de interrupción. Como se explicó anteriormente, la ESP8266 no es
actualmente capaz de hacer lo mismo mientras se mantiene una interfaz Wi-Fi funcional. El timerCallback () en interrupt.h
ahora se llama a una hora programada por la función loop () en el archivo IOTPulse.ino.
Básicamente, timerCallback () actúa como un detector y un filtro de promedio que detecta la fase de expansión en la
salida PulseSensor y luego construye un conjunto de veces para IBI (Intervalo entre latidos) y proporciona un promedio. Se
ajusta a los niveles registrados procedentes de la PulseSensor debido a que el nivel real no es tan importante como el
intervalo de tiempo entre pulsos ajustados de la PulseSensor. El software actúa como un pico y el detector a través de un
sistema de media que elimina el ruido de alta frecuencia.
Listado 5-4. interrupt.h
tasa int volátil [10]; // matriz para contener últimos diez valores IBI
volátil largo sampleCounter unsigned = 0; // se utiliza para determinar el tiempo de pulso volátil largo
lastBeatTime unsigned = 0; // se utiliza para encontrar IBI
volátil int P = 680; // se usa para encontrar el pico en la onda del pulso, se
siembran 512
int volátil T = 680; // usado para encontrar artesa en la onda del pulso, se
siembran 512
volátil int Thresh = 700; // se utiliza para encontrar momento instantáneo de los latidos
del corazón, cabeza de serie 525
volátil int amp = 100; // se utiliza para mantener la amplitud de forma de onda de pulso,
se sembró
volátil Firstbeat boolean = true; // se utiliza para sembrar variedad tasa por lo que
inicio con BPM razonable
167
volátil secondBeat boolean = false; // se utiliza para sembrar variedad tasa por lo que
inicio con BPM razonable
restartPulse vacío () {
sampleCounter = 0; // se utiliza para determinar el tiempo de pulso

lastBeatTime = 0; // se utiliza para encontrar IBI
P = 680; // se usa para encontrar el pico en la onda del pulso, se siembran 512
T = 680; // usado para encontrar artesa en la onda del pulso, se siembran 512
trillar = 700; // se utiliza para encontrar momento instantáneo de los latidos del corazón, cabeza de
serie 525
amp = 100; // se utiliza para mantener la amplitud de forma de onda de pulso, se sembró
Firstbeat = true; // se utiliza para sembrar variedad tasa por lo que inicio con BPM
razonable
secondBeat = false;
}
timerCallback anular (void * pArg);
// temporizador se asegura de que tomamos una lectura cada 2 milisegundos vacío

timerCallback (void * pArg) { // desencadenado en las interrupciones
// cli (); // desactivar las interrupciones mientras hacemos esto
Señal = analogRead (pulsePin); // leer el sensor de pulso

//Serial.print("Signal-A0-: ");
//Serial.println(Signal);
sampleCounter + = 2; // no perder de vista el tiempo en ms con

esta variable
int N = sampleCounter - lastBeatTime; // controlar el tiempo desde el último golpe
para evitar el ruido
// encontrar el máximo y mínimo de la onda de pulso

si (Señal <Thresh && N> (IBI / 5) * 3) {// evitar el ruido dicrótico por
esperando 3/5 del último IBI
si (señal <T) { // T es la artesa
T = de señal; // seguir la pista de punto más bajo de la onda
del pulso
}}
si (señal> Thresh && señal> P) { // condición trillaste ayuda a evitar el

ruido
P = señal; // P es el pico
} // seguir la pista de punto más alto de la onda
del pulso
168
// AHORA ES tiempo para buscar el latido del corazón // señal de sobretensiones

en valor cada vez que se produce un pulso si (N> 250) {
// evitar el ruido de alta frecuencia
if ((señal> trillar) && (Pulse == false) && (N> (IBI / 5) * 3)) {pulso = true;
// establecer el indicador de pulso cuando
pensamos que hay un pulso
digitalWrite (blinkPin, LOW); // encender LED
IBI = sampleCounter - lastBeatTime; // tiempo entre latidos medida en mS
lastBeatTime = sampleCounter; // un seguimiento del tiempo para el próximo pulso
si (secondBeat) { // si esta es la segunda ceñida, si

secondBeat == TRUE
secondBeat = false; // bandera secondBeat clara
for (int i = 0; i <= 9; i ++) { // sembrar el total acumulado para obtener un
BPM realisitic en el arranque
tasa de [i] = IBI; }}
si (Firstbeat) { // si es la primera vez que encontramos el

ritmo, si Firstbeat == TRUE
Firstbeat = false; // bandera Firstbeat clara
secondBeat = true; // establecer la segunda bandera latido
// sei (); // habilitar las interrupciones de nuevo
regreso; // valor IBI no es fiable por lo que
descartarlo
}
// mantener un total acumulado de los últimos 10 IBI valores de palabra

RunningTotal = 0; // borrar la variable RunningTotal
for (int i = 0; i <= 8; i ++) { // desplazamiento de datos en la matriz de tasa
tasa de [i] = velocidad de [i + 1]; // y soltar el valor más antiguo IBI

RunningTotal + = tasa de [i]; // sumar los 9 valores IBI más antiguas
}
tasa de [9] = IBI; // Añadir el último IBI a la matriz tasa
RunningTotal + = tasa de [9]; // Añadir el último IBI a

RunningTotal
RunningTotal / = 10; // el promedio de los últimos 10 valores del IBI
BPM = 60.000 / RunningTotal; // cuántos tiempos pueden caber en un
minuto? eso es BPM!
// reducir al 83% basado en la comparación BPM =
(BPM * 83) / 100; QS = true;
// establecer el indicador Auto cuantificado
// QS bandera no se borra DENTRO DE ESTA ISR}}
169
si (Señal <trillaste && pulso == true) {// cuando los valores se van
abajo, el ritmo es más
digitalWrite (blinkPin, HIGH); // desactivar pin 13 LED
Pulso = false; // restablecer el indicador de impulso para que podamos hacerlo
de nuevo
amp = P - T; // obtener amplitud de la onda del pulso

trillar = amp / 2 + T; // establecer Thresh a 50% de la amplitud
P = trillar; // restablecer éstos para la próxima vez
T = Thresh; }
si (N> 2500) { // si 2,5 segundos pasan sin

un latido
trillar = 512; // establecer por defecto trillaste
P = 512; // conjunto predeterminado P
T = 512; // conjunto T predeterminado
lastBeatTime = sampleCounter; // llevar el lastBeatTime al día

Firstbeat = true; // establecer estos para evitar el ruido
secondBeat = false; // cuando lleguemos el latido del corazón de vuelta
// sei (); // habilitar las interrupciones cuando estás hecho!
} // fin ISR
La revisión de los resultados del Monitor de serie Arduino IDE

Listado 5-5 muestra la salida del monitor de serie en el IDE de Arduino ya que se corre el software. Tenga en cuenta que este
código se ejecuta después de unirse a la IBM bluemix IOT como se muestra más adelante en este capítulo. Si no se han unido al
bluemix IOT, sin embargo, a continuación, verá una “falla la autenticación” error cada vez que el software IOTPulse intenta contactar
bluemix.
Listado 5-5. Salida de monitor de serie
IOTPulse IBM bluemix IOT

----------------
Conexión a gracie ........
Wi-Fi conectados, dirección IP local: 192.168.1.117
* * * Latido del corazón pasó *** BPM: 92 IBI: 534
170

* * * Latido del corazón pasó *** BPM: 91 IBI: 564 IOT tiempo
delta = 10000002
Reconectar cliente para 4183lj.messaging.internetofthings.ibmcloud.com
.
Enviando IOTPulse carga útil: { "d": { "IOTPulse": "IP1", "VER": 4, "SC": 1, "BPM": 91, "I BI": 564, "BC": 14}}
bluemix IOT Publicar ok

* * * Latido del corazón pasó *** BPM: 85 IBI: 572 IOT tiempo
delta = 10000009
Reconectar cliente para 4183lj.messaging.internetofthings.ibmcloud.com
.
Enviando IOTPulse carga útil: { "d": { "IOTPulse": "IP1", "VER": 4, "SC": 2, "BPM": 85, "I BI": 572, "BC": 27}}
bluemix IOT Publicar ok

Figura 5-8 muestra el dispositivo IOTPulse completado en el caso. Tenga en cuenta los agujeros en la parte superior para ver los
LED de la placa ESP8266. Figura 5-9 muestra el sensor de pulso recortado en una oreja. Observe el LED verde se utiliza para detectar la
frecuencia del pulso en el oído.
171
Figura 5-8. IOTPulse en Caso
Figura 5-9. Sensor IOTPulse en la oreja
172
Bluemix unirse a IBM y la Fundación IO

El IBM bluemix y la Fundación IO son los dos principales servicios de nube IOT que vamos a utilizar para conectar el
dispositivo IOTPulse a la nube. Las tareas que hay que hacer para conectar hasta su mayoría tienen que ver con la creación
de cuentas de usuario y poniendo la información de facturación en el sistema. Tenga en cuenta que estamos utilizando los
niveles libres del sistema bluemix, pero IBM todavía requiere información de facturación. La información técnica más
importante nos reuniremos es cómo autenticar nuestro dispositivo IOT a la nube de IBM. Figura 5-10 describe la arquitectura
general de la aplicación en la nube Fundación bluemix / IO.
Figura 5-10. IBM Diagrama de bloques bluemix
La Fundación IO es el servicio de IBM bluemix que vamos a necesitar para conectar el ESP8266 al servicio en la nube
bluemix. Usted tendrá que crear una cuenta de ID de IBM. Puede hacerlo en la página de inicio bluemix muestra en la figura 5-11
.
173
Figura 5-11. IBM bluemix primera página
Los pasos para unirse a IBM bluemix son los siguientes:
1. Crear un ID de IBM cuenta aquí ;
2. Validar su cuenta a través de IBM envió el correo electrónico;
3. Ve a la sitio de IBM bluemix y haga clic en Iniciar sesión;
4. Inicia sesión en la página de inicio de sesión;
5. Ir a la bluemix tablero de instrumentos;
6. Haga clic en servicios de uso o API;
7. Añadir la Internet de los objetos de servicio de Foundation (que es la forma
hacia abajo en la parte inferior de la lista en la página web). A continuación, debe tener una pantalla similar a
la de la figura 5-12 , con la excepción de

el panel “IO Real-Time Insights”, que se añadirá a su cuenta bluemix más adelante en este capítulo.
174
Figura 5-12. bluemix tablero de instrumentos
El envío de sus datos a bluemix

En primer lugar, ¿qué es lo enviamos hasta bluemix de la ESP8266? Resulta que los protocolos de datos son
bastante sencillos Hay dos protocolos más importantes que requieren descripciones.
MQTT y JSON.
MQTT
MQTT es un protocolo de mensajería basados en publicar suscribir- "peso ligero" para su uso en la parte superior del
protocolo TCP / IP, como los paquetes WiFi que estamos utilizando en este proyecto. Está diseñado para conexiones con
lugares remotos donde se requiere una "pequeña huella de código" o el ancho de banda es limitado. Ambas condiciones se
cumplen con un diseño ESP8266 IOT, así que tiene sentido utilizar. También hay una excelente biblioteca disponible para
MQTT para el IDE Arduino [ https://github.com/knolleary/pubsubclient ] . El patrón de mensajería publishsubscribe requiere un
intermediario de mensajes. El corredor es responsable de distribuir mensajes a los clientes interesados basados en el tema
de un mensaje (Figura 5-13 ).
175
Figura 5-13. MQTT publicación-suscripción Protocolo
Publicación-suscripción es un patrón en el que los remitentes de los mensajes, llamados editores (en este caso nuestra
ESP8266 es el editor), no programa los mensajes que se enviarán directamente a los abonados, sino que caracterizan a las
cargas útiles de mensajes en clases sin el conocimiento específico de las cuales los suscriptores de los mensajes se envían a.
Del mismo modo, los abonados (IBM bluemix IOT en este caso) sólo recibirán mensajes que son de interés y sin
conocimientos específicos de los cuales los editores existen. El IBM bluemix funciona como el agente en este sistema y las
rutas de los datos publicados a los abonados correspondientes dentro de bluemix.
De carga útil de datos JSON
JSON es un formato estándar abierto que utiliza texto legible para transmitir objetos de datos que constan de pares atributo-valor.
Es el formato de datos principal que se utiliza para la comunicación de navegador / servidor asíncrono, sustituyendo en gran
medida XML. XML es un protocolo "más pesado", que también es de naturaleza jerárquica, pero con mucha más redundancia
que JSON. Sí, hay guerras de clase pasando para las personas que abogan JSON sobre XML, pero en el mundo actual de alta
velocidad de la comunicación, es raro que importa. Puede hacer que el argumento de que la mayor densidad de datos de JSON
es una mejor opción para aplicaciones IOT.
Este es un ejemplo del paquete de datos que estamos utilizando en el código ESP8266 bluemix en JSON para la carga
de datos LightSwarm:
{"re":
{
"LightSwarm IOT": "LS1",
"SAMPLEcount": 2118, "lightValue":
383}}
176
Autenticación
Tenemos que tener un método seguro de autenticación que nuestro dispositivo ESP8266 se le permite poner los datos en las
ranuras correctas dentro de la IBM bluemix. Esto se hace en nuestro caso mediante el intercambio de una señal criptográfica que
se generan por bluemix e incluidos en nuestro código ESP8266.
Para ello tenemos que ir de nuevo a la cuenta bluemix que se configura en la publicación anterior y completar
los siguientes pasos:
1. Haga clic en el icono de Internet de las Cosas en la Fundación bluemix

tablero.
2. A continuación, haga clic en el botón de lanzamiento salpicadero en “Conectar
sus dispositivos”(Figura 5-14 ).
Figura 5-14. Conectar sus dispositivos a bluemix
3. Ir a la ficha de dispositivos y “Agregar dispositivo” hacia abajo en la parte inferior
La página.
4. Haga clic en “Crear Tipo de dispositivo”, y la pantalla de la figura 5-15

aparece.
177
Figura 5-15. Crear bluemix Tipo de dispositivo
Le sugerimos que utilice IOTPulse-01 para el nombre del tipo de dispositivo. Desplazarse por el resto de los pasos. Hay
muchas opciones de configuración que casi todos se pueden dejar en blanco en nuestra aplicación actual. Usted está obligado a
tener un tipo de dispositivo y un identificador de dispositivo.
Cuando se ha creado el dispositivo, verá la página de credenciales del dispositivo. Asegúrese de guardar los datos, ya
que se utilizan para autenticar su boceto ESP8266 Arduino IDE en el siguiente paso (no hemos encontrado ninguna manera
de recuperar estas credenciales desde el sistema bluemix). Obviamente, no utilice las credenciales en la figura 5-16 . Ellos
no van a funcionar. Es necesario crear el suyo propio.
178
Figura 5-16. Pantalla bluemix Credencial
Viendo datos en tiempo real en la plataforma IBM bluemix IOT
Con el fin de obtener una pantalla que va en la plataforma bluemix, necesitamos conectar nuestro dispositivo al servicio de la IO
Real-Time Insights en bluemix. Las siguientes secciones discuten esto.
Adición de Tiempo Real Insights
Paso 1: Agregue el servicio en Tiempo Real Insights IO a su tablero de instrumentos bluemix. Abrir el salpicadero bluemix (el primer
tablero después de inicio de sesión) y haga clic en “servicios de uso o API” y añadir las IO en tiempo real Insights como un servicio. Es
camino hacia abajo en la parte inferior de la página. A continuación, aparecerá la pantalla de la figura 5-17 .
179
Figura 5-17. IO Real-Time Insights
Paso 2: Conectar nuestro dispositivo a la IO Real-Time Página Insights mediante la generación de una clave de API y luego
generar una fuente de datos. Haga clic en el bloque de la IO Real-Time Insights se muestra en la figura 5-16 .
Paso 3: Generar las claves de la API para el uso de la fuente de datos y crear claves de la API para conectar los dos
servicios (Fundación de la IO IO y visualización en tiempo real):
1. Desde el tablero de instrumentos bluemix, haga clic en el Internet de las Cosas baldosas.
2. Hacer clic tablero de lanzamiento para abrir el Internet de las cosas

Fundación salpicadero.
3. Navegar a Access> claves de la API.
4. Haga clic en Generar clave de API.
5. Tome nota de la clave de la API, Token de autenticación, y

el ID de organización que se muestra en la parte superior del salpicadero Fundación
IO. Esta información se utiliza en la IO RealTime Insights para conectar los servicios. Estas
teclas se continuará mostrando en la fuente de datos.
180
La adición de la fuente de datos
La adición de la fuente de datos (nuestro dispositivo IOTPulse) consiste de los siguientes (Figura 5-18 ):
Figura 5-18. La adición de la fuente de datos
1. Ir a dispositivos> Administrar esquemas y haga clic en Agregar un nuevo mensaje
esquema.
2. Introduzca un nombre para el esquema de mensaje: por ejemplo,

IOTMessageSchema.
3. Hacer clic Vincular nueva fuente de datos y seleccione la fuente de datos y
tipo de dispositivo que corresponde a su instancia y Fundación dispositivo IO. Tipos de

eventos para su dispositivo sean aquí .
4. Añadir uno o más puntos de datos que desea incluir en el

cuadros de mando del dispositivo (SAMPLEcount y lightValue en nuestro ejemplo).
5. Los puntos de datos disponibles se definen en la carga útil JSON de los mensajes que se
envían por un dispositivo.
6. Haga clic en Seleccionar desde el dispositivo conectado.
7. En el diálogo Añadir puntos de datos, seleccione uno o más puntos de datos para agregar y
haga clic DE ACUERDO .
8. Los puntos de datos seleccionados se añaden con la descripción del conjunto del nombre del
punto de datos.
9. A continuación, haga clic en la flecha verde (en el lado izquierdo de la pantalla) para guardar la
información y crear la fuente de datos.
181
Una vez que todos los datos de configuración está en su lugar y la información de autenticación está en su lugar en el programa
IOTPulse, los datos deben empiezan a fluir como se muestra en la figura 5-19 .
Figura 5-19. IOT de datos comienza a fluir
Ahora añadimos las pantallas para visualizar nuestros datos.
Añadiendo el tablero de instrumentos para la IO visualización en tiempo real
Desde la pantalla en la figura 5-20 , Haga clic en Iniciar la IO Real-Time Insights Dashboard en la columna de la derecha
inferior.
182
Figura 5-20. IO Real-Time Insights
Haga clic en el salpicadero y navegar cuadros de mando. Añadir un nuevo tablero de instrumentos. A continuación, haga lo siguiente:
1. Añadir nuevo componente;
2. Seleccionar gráfico;
3. Añadir línea a la carta;
4. Seleccione el dispositivo y luego seleccione lightValue como parámetro;
5. Haga clic en la flecha verde. Figura 5-21 muestra la pantalla de IBM bluemix para el tendido de la interfaz de tablero de
instrumentos.
Figura 5-21. La construcción de su tablero de instrumentos IO en tiempo real

183
Si su ESP8266 está funcionando y enviando datos hasta el IBM bluemix IOT, a continuación, verá los valores
comienzan a poblar la gráfica, como se muestra en la figura 5-22 .
Figura 5-22. Bluemix la IO en tiempo real del tablero de instrumentos Operacional
Temas avanzados
Las ofertas de nube de IBM tienen literalmente cientos de opciones y posibilidades para llevar sus datos a la nube IOT. A
continuación les mostramos algunas de estas “aplicaciones” disponibles en el sistema bluemix. Vamos a mostrar cómo representar
gráficamente los datos históricos IOT e introducir un sistema de programación compleja, pero muy potente,, Nodo-RED.
Información histórica
los datos históricos no son en tiempo real también se pueden ver en bluemix (figura 5-23 ). Esto requiere que usted construya
una aplicación (no es tan compleja como se podría pensar) y luego desplegar la aplicación. Un buen tutorial para esto se
encuentra en el sitio web de IBM bluemix [ https: //www.ng.bluemix. net / docs / entrantes / install_cli.html ] . No requieren la
instalación de una interfaz de línea de comandos para Cloud Foundry en su ordenador.
184
Figura 5-23. Datos Históricos IOTPulse
Una cosa que este gráfico de datos histórica de nuestro pulso muestra es que los datos de IOTPulse podrían
mejorarse más de filtrado. El promedio de la frecuencia cardíaca se ve bien, pero los saltos arriba y abajo vea como el
ruido, sobre todo al principio de la gráfica.
Aplicaciones nodo-RED
Nodo-RED es una herramienta gráfica para cableado juntos dispositivos externos, APIs y servicios en línea. Se utiliza un editor
de flujo basado en navegador que hace que sea fácil de cablear juntos fluye de una extensa biblioteca y es fácil de añadir sus
propios nodos.
Nodo-RED es totalmente compatible con IBM bluemix. Se trata principalmente de un sistema de generación de software basado en
eventos. Si ocurre un evento (como IOTPulse envío de datos), puede tomar esos datos y procesar de varias maneras, enviarlo a otras
aplicaciones, y lo almacenan en bases de datos. Otras entradas pueden causar pantallas que se actualicen, las consultas que se enviarán
a las bases de datos, y muchos otros eventos.
Hemos construido una pequeña aplicación Nodo-RED para IOTPulse se muestra en la figura 5-24 .
185
Figura 5-24. Nodo RED-Flow Solicitud de IOTPulse
Aplicaciones Watson
Una de las clases más excitante de las aplicaciones que se pueden construir en bluemix son los que utilizan el software de IBM
Watson. Todos los servicios de Watson en la plataforma bluemix se accede a través de transferencias HTTP conocidos como servicios
REST. RESTO significa Representación Transferencia de estado y es una forma común de acceso a los servicios basados en la web.
Watson es compatible con una serie de servicios muy sofisticados todos disponibles para su dispositivo y aplicaciones en
bluemix:
• Dictado a texto
• Texto a voz
• Traducción de idiomas
• Soporte para Diálogos de usuario
• La determinación del “tono” de texto
• Reconocimiento visual
• Análisis de Imágenes - objetos, personas y texto
Conclusión
El futuro de la IOT es de datos: cómo reunir, cómo transmitirlo, cómo analizar y mostrarlo, y cómo actuar en él. El
proyecto IOTPulse muestra cómo recopilar los datos y la forma de enviarlo a un sistema de computación en la nube
para el análisis y acciones.
Con un sensor adecuado, el proyecto IOTPulse podría ser un producto comercial. El sensor y el análisis de la
frecuencia cardíaca definitivamente no son de grado médico, pero todavía ilustra los principios del dispositivo IOT y la
relación con el dispositivo de la nube IOT.
186
CAPÍTULO 6
El uso de IOT para la RFID y MQTT y el

Raspberry Pi
Capítulo Objetivo: Construir un dispositivo IOT para la lectura de etiquetas RFID en varios paquetes
• Introducción a la tecnología RFID
• Introducción a MQTT de publicación / suscripción sistemas y servidores
• La construcción de un servidor de Frambuesa Pi basado MQTT
• La construcción de un lector RFID para conectarse a la IOT
• Conexión de su lector de RFID a su Servidor MQTT Frambuesa Pi
• ¿Qué hacer con los datos de RFID en el servidor
El mundo de la IOT está dominado por pequeños ordenadores que tienen pequeñas cantidades de recursos y el
poder para comunicar la información con el resto del mundo. MQTT es una publicación-suscripción, protocolo ligero
para dispositivos IOT para comunicarse con el servidor y el servidor a través de, entre sí. MQTT también está
disponible para redes “malla” tipo, como Zigbee, que permiten la comunicación de dispositivo a dispositivo. RFID
(identificación por radiofrecuencia) es una forma barata de lectura de tarjetas y etiquetas numeradas de forma única a
través de ondas de radio de corta distancia. RFID y su primo, NFC (Near Field Communications) están apareciendo en
más y más aplicaciones.
En este capítulo, construimos un dispositivo RFID y luego conectarse a través de una editorial MQTT a un corredor
de MQTT como en el capítulo 5 , Pero con la diferencia de que estamos sustituyendo el intermediario IBM bluemix MQTT
con un corredor mosquitto se ejecuta en un 20 Frambuesa Pi $.

Como ya comentamos en el capítulo 1 , Lo primero que hay que hacer para entender un proyecto IOT es mirar a nuestros seis
diferentes aspectos de IOT. ITORFID es un proyecto simple que los otros cuatro proyectos, pero el flujo de datos es mucho más
compleja.

CAPÍTULO 6 ■ USO PARA IOT RFID y MQTT Y EL PI FRAMBUESA
Mesa 6-1 que caracteriza a los diferentes aspectos del proyecto. Las calificaciones son del 1-10, siendo 1 el menos adecuado
para IOT y 10 es la más adecuada para aplicaciones de IO. Esto nos da una calificación de 8.3 CPLPFC. Grande para el aprendizaje y
la experimentación, y que podría ser desplegado para algunas aplicaciones del mercado.
Tabla 6-1. IOT Caracterización del Proyecto
comunicaciones 9 conexión WiFi a Internet -
procesador Power 9 80MHz Xtensa Harvard arquitectura de CPU, memoria RAM de datos ~
80KB / ~ 35 KB de RAM Instrucción / 200K ROM
El consumo de energía 8 ~ 200 mA de transmisión, recepción ~ 60mA, noWiFi ~ 15 mA, 1 mA

en espera ~
Tenga en cuenta que el consumo de energía en esta solicitud podría reducirse drásticamente mediante la adición de un modo de
apagado, por ejemplo después de 5 minutos de no usar el lector de RFID.
¿Qué es la tecnología RFID?

Identificación por Radio Frecuencia (RFID) es el uso de ondas de radio para transferir datos, específicamente en el área de
identificación y seguimiento de etiquetas adheridas a los objetos, personas y animales. A menudo, la etiqueta RFID no tiene
ninguna fuente de alimentación y se activa y funciona con ondas de radio de vigas en la etiqueta RFID. Esta tecnología se
remonta a la década de 1940 y fue demostrado por primera vez por Theremin en la Unión Soviética. Curiosamente, se utiliza
esta tecnología para poner un dispositivo de escucha secreta en la sala de conferencias Embajada de Estados Unidos en
1946. Fue utilizado durante seis años, cuando en 1952, se descubrió que el sello contenía un micrófono y una cavidad
resonante que podría ser estimulada de una señal de radio exterior. Mientras que esta utiliza una cavidad resonante que
cambió su forma cuando son estimuladas por las ondas sonoras, y por lo tanto modulada una onda de radio reflejada vigas
en la unidad,
[En.wikipedia.org/wiki/The_Thing_(listening_device)]
Las etiquetas RFID pueden ser (sin carga de la batería - estamos utilizando esta tecnología en este capítulo) activa, pasiva, y
la batería asistidos pasiva. Una etiqueta pasiva no contiene la batería, en lugar de utilizar la energía de radio transmitida por el lector
RFID. Para operar una etiqueta pasiva, tiene que ser golpeado con un nivel de potencia de aproximadamente mil veces mayor que
las transmisiones de la señal resultante.
188
Cuando una etiqueta RFID es golpeado por un haz de ondas de radio desde un transmisor, la etiqueta pasiva se enciende y
transmite de nuevo el número de identificación de la etiqueta y otra información. Esto puede ser un número de serie único, una
serie de valores o mucho, o cualquier otra información específica. Dado que las etiquetas tienen números únicos, el sistema RFID
puede leer varias etiquetas a la vez, con un poco de programación inteligente de receptor y transmisor.
Hay un número de diferentes estándares de RFID de uso común. Hay tres normas para poner los chips de identificación
de animales de compañía, que por supuesto no son compatibles entre sí y requieren diferentes lectores. Las etiquetas de corto
alcance que estamos utilizando en este capítulo operaron a la baja frecuencia de 125 kHz y pueden ir hasta 100 mm (figura 6-1 ).
Otras etiquetas pueden ser recogidos (con tecnología RFID activa) hasta 100 metros.
Mientras que las tecnologías RFID y NFC están diseñados para su uso corta distancia, la adición de un transmisor de gran
potencia y una gran antena puede cambiar el significado de “corta distancia”.
La Figura 6-1. Con formato de tarjeta 125kHz RFID Tag
¿Qué es MQTT?
en el capítulo 5 , Se utilizó un módulo editor MQTT hablar con el agente de IBM en IBM MQTT bluemix.
Para refrescar la memoria del lector, MQTT es un protocolo de mensajería basados en publicar suscribir-“peso ligero”
para su uso en la parte superior del protocolo TCP / IP, como los paquetes WiFi que estamos utilizando en este proyecto. Está
diseñado para conexiones con lugares remotos donde se requiere una “pequeña huella de código” o el ancho de banda es
limitado.
189
Publicación-suscripción es un patrón en el que los remitentes de los mensajes, llamados editores (en este caso nuestro
proyecto IOTRFID es el editor), no programa los mensajes que se enviarán directamente a los abonados, sino que caracterizan
a las cargas útiles de mensajes en clases.
Se puede pensar en él como escribir historias para un periódico en el que no se sabe quién va a suscribirse al
artículo.
Hardware utilizado para IOTRFID

Hay allí las partes principales en el hardware de la IOTRFID (Figura 6-2 ). La primera es la ESP8266 Adafruit
Hurra que hemos visto en los capítulos anteriores.
El circuito de lectura RFID es una pequeña placa de bajo costo de Seeedstudio en China. La razón principal fue
elegido este tablero fue el hecho de que funciona en 3,3 V (que es la misma que la ESP8266) y no requiere
componentes externos (bueno, sí, sí requiere una antena que se incluye).
También compramos una etiqueta RFID 125KHz de Sparkfun. Tenga cuidado de la etiqueta RFID de comprar. No todos son
compatibles.
La Figura 6-2. Diagrama de bloques de IOTRFID
190
La construcción de un MQTT Server en un Frambuesa Pi

Como se describe en el capítulo 5 , MQTT requiere un intermediario de mensajes. El patrón de diseño es la siguiente:
1. IOTRFID publica una carga útil;
2. broker Frambuesa Pi MQTT recibe la carga útil;
3. corredor de Frambuesa Pi MQTT difunde a todos suscriptora

objetos (que pueden ser diferentes procesos en la misma máquina - como en nuestro caso -. o máquinas
diferentes, incluso en su totalidad en el capítulo 5 , Se utilizó el IBM bluemix como el intermediario de
mensajes. En el IOTRFID
proyecto que se va a construir un intermediario de mensajes en la Raspberry Pi.
Figura 6-3 muestra el flujo de datos en toda la aplicación - incluyendo la Frambuesa Pi. El flujo de datos en esta solicitud es
básicamente una manera: desde la etiqueta RFID para el servidor mosquitto Frambuesa Pi. Tenga en cuenta, sin embargo, hay dos
canales disponibles más de la conexión Wi-Fi y se puede enviar comandos de nuevo al proyecto IOTRFID decirle al usuario
información sobre la pieza que se está inventariado. Por ejemplo, puede mostrar el destino de la caja o la fecha de caducidad.
La Figura 6-3. Flujo de datos del sistema completo
191
Hay una serie de corredores MQTT disponible para diferentes máquinas. Para este proyecto, hemos seleccionado uno de los
corredores más populares y estables, “mosquitto.” Tenga en cuenta los dos “t” 's en mosquitto. La pesadilla de los correctores
ortográficos en todas partes.
Mosquitto apoya MQTT v3.1 / 3.1.1 y se instala fácilmente en el Pi de frambuesa y un poco menos fácil de configurar. A
continuación damos un paso a través de la instalación y configuración del agente mosquitto.
El software en el Raspberry Pi
Comenzamos con la creación del software en el Raspberry Pi. Hacemos esto para que nuestra IOTRFID tiene algo que hablar cuando nos
propusimos gire el IOTRFID sucesivamente.
Instalación del MQTT “mosquitto”

Por desgracia, los archivos “apt-get” Frambuesa Pi normales no contienen la versión más reciente del software
mosquitto. Si no instala la última versión del agente, obtendrá errores impares (debido a errores de compatibilidad
de versión) y no va a trabajar. Por lo tanto, lo primero es abrir una ventana de terminal (o iniciar sesión con SSH) a
su Frambuesa Pi y hacer lo siguiente:
sudo wget http://repo.mosquitto.org/debian/mosquitto-repo.gpg.key sudo apt-key

add-mosquitto repo.gpg.key cd /etc/apt/sources.list.d/
sudo wget http://repo.mosquitto.org/debian/mosquitto-wheezy.list sudo apt-get update
sudo apt-get install mosquitto
A continuación podemos instalar las tres partes de mosquitto adecuada.
• mosquitto - el corredor MQTT (o en otras palabras, un servidor)
• mosquitto-clientes - los clientes de línea de comandos, muy útil en la depuración
• python-mosquitto - los enlaces de lenguaje Python Ejecutar el
siguiente comando para instalar estos tres partes:
sudo apt-get install mosquitto mosquitto-clientes pitón-mosquitto
Como es el caso con la mayoría de los paquetes de Debian, se inicia inmediatamente el corredor. Ya que tenemos que
configurar primero, detenerlo:
sudo parada /etc/init.d/mosquitto
192
Configuración e inicio del servidor mosquitto

Antes de utilizar mosquitto, tenemos que configurar el archivo de configuración. El archivo de configuración se encuentra en / etc /
mosquitto.
Abra el archivo de la siguiente manera:
/etc/mosquitto/mosquitto.conf sudo nano
Debería ver lo siguiente:
# Coloque la configuración local en /etc/mosquitto/conf.d/

#
# Una descripción completa del archivo de configuración está en
# /usr/share/doc/mosquitto/examples/mosquitto.conf.example
pid_file /var/run/mosquitto.pid persistencia
verdadera
persistence_location / var / lib / mosquitto /
log_dest /var/log/mosquitto/mosquitto.log archivo
/etc/mosquitto/conf.d include_dir
Cambie la línea “log_dest” a:
tema log_dest
Esto pone a la información de registro como un “tema” para que podamos suscribirse a él más adelante para ver lo que está pasando
en nuestro sistema IOTRFID.
A continuación añadimos las siguientes seis líneas:
log_type información de alerta

de error log_type log_type
aviso log_type
connection_messages cierto
log_timestamp verdadera
Ahora sus archivos /etc/mosquitto.conf deberían tener este aspecto:
# Coloque la configuración local en /etc/mosquitto/conf.d/

#
# Una descripción completa del archivo de configuración está en
# /usr/share/doc/mosquitto/examples/mosquitto.conf.example
pid_file /var/run/mosquitto.pid
persistencia verdadera
persistence_location / var / lib / mosquitto /
193
log_dest error log_type tema

de información notificación de
alerta log_type log_type
log_type
connection_messages cierto
log_timestamp verdadera
/etc/mosquitto/conf.d include_dir
Inicio del servidor mosquitto

Ahora inicie el servidor mosquitto:
inicio sudo /etc/init.d/mosquitto
El servidor debe empezar, y ya está listo para pasar a la prueba.
Probando el servidor mosquitto

Abrir dos ventanas de terminal más.
En Terminal tipo de ventana 1:
mosquitto_sub -d -t hola / mundo
En Terminal tipo de ventana 2:
mosquitto_pub -d -t hola / -m mundo "Hola desde la ventana Terminal 2!"
Cuando haya hecho la segunda declaración debería ver esto en la ventana de la terminal 1.
~ $ sudo mosquitto_sub -d -t hola / Cliente mundo mosqsub / envío de

conectar al cliente mosqsub / 3014-3014-LightSwarm LightSwarm
recibido CONNACK
mosqsub cliente / 3014-LightSwarm envío de SUSCRIPCIÓN (Mid: 1, Tema: hola / mundo, calidad de servicio: 0)
mosqsub Client / 3014-LightSwarm recibido SUBACK suscripciones

(mediados: 1): 0
mosqsub cliente / 3014-LightSwarm recibido PUBLICAR (D0, q0, r0, M0, 'hola / mundo', ... (32 bytes))
Saludos desde la ventana Terminal 2
Ahora se está ejecutando el agente mosquitto éxito. A continuación, vamos a construir

el dispositivo IOTRFID.
194
La construcción de la IOTRFID
El proyecto IOTRFID consta de cuatro partes principales:
• ESP8266
• Lector RFID
• Software para la ESP8266
• Software para la Frambuesa Pi
El propósito de este proyecto es un prototipo de un sistema de control de inventario que utiliza etiquetas RFID. El ESP8266
controla el lector de RFID y los informes de la etiqueta RFID para el servidor Frambuesa Pi. A continuación, utilizamos MQTT
través de la interfaz de conexión Wi-Fi en la ESP8266 para enviar la información de inventario a la Frambuesa Pi. La Raspberry Pi
podría utilizar la información RFID para trabajar con una base de datos, alertar al cliente final, etc.
Las piezas necesarias

El IOTRFID se puede montar de alrededor de $ 35 a partir de las fuentes en la tabla 6-2 .
Tabla 6-2. Lista de piezas para IOTRFID

por la Junta
Junta Hurra 1 CPU bordo / $ 10 productos

ESP8266 Wi-Fi www.adafruit.com/ / 2471
Mini lector de 1 125kHz RFID lector $ 11 www.seeedstudio. com /

RFID 125 kHz de la serie depot /
Mini125Khz-RFID-ModuleExternal-LEDBuzz
Etiquetas RFID 125 1 Tag RFID compatible $2 productos www.sparkfun.com/

kHz con Mini lector de / 8310
RFID 125 kHz
FTDI cable 1 Cable para la $ 11 www.switchdoc.com/

programación de la barata-ftdicable-para-arduinoesp8266-includ
ESP8266 desde el PC cable /
/ Mac
195
Instalación del soporte de Arduino en el PC o Mac

Una vez más, la clave para hacer este trabajo del proyecto es el desarrollo de software. Si bien hay muchas
maneras de programar el ESP8266 (MicroPython [ https://micropython.org] ,
NodeMCU Lua intérprete [ http://nodemcu.com] y el IDE Arduino (entorno de desarrollo integrado) [ https://www.arduino.cc/e
), elegimos el IDE Arduino por su flexibilidad y el gran número de sensores y bibliotecas de dispositivos
disponibles.
Para instalar el IDE Arduino que tiene que hacer lo siguiente:
1. Descargar el paquete de Arduino IDE para su computadora y

instalar el software [ https://www.arduino.cc/en/Guide/ Página de Inicio ] .
2. Descargar las bibliotecas ESP para que pueda utilizar el Arduino

IDE con el tablero del desbloqueo ESP. Adafruit tiene una excelente tutorial
para instalar el soporte ESP8266 para el Arduino IDE [ https://learn.adafruit.com/adafruit-huzzah-esp8266breako
].
el hardware
Los principales elementos de hardware en el dispositivo enjambre son los siguientes:
• ESP8266 - Interfaz de CPU / Wi-Fi
• Mini lector de RFID 125 kHz
• Batería de 9 V - Power
• FTDI Cable - Programación y Poder
El ESP8266 comunica con el Frambuesa Pi mediante la interfaz de WiFi. El ESP8266 utiliza un interfaz serie para
comunicarse con el sensor de luz. El Wi-Fi es un estándar que es muy común. La interfaz serie utilizado es un hilo
(línea Tx en el lector RFID para Rx en el ESP8266 - Pin GPIO # 4 en la ESP8266). En una interfaz serie, un bit a la vez
que se envía junto con detener e iniciar los bits de cada byte. Los datos se envían a 9600 baudios, que es una vieja
manera de decir aproximadamente 9600 bits por segundo.
¿Qué es este sensor estamos usando?

El Mini 125 kHz RFID Reader es un lector simple, barato 125kHz RFID Tag con un intervalo de aproximadamente 70 mm. Tenga en
cuenta que el rango de un lector de esta manera se establece mediante una combinación de la potencia de salida del lector y el diseño
de la antena.
Si usted tiene una antena más grande y más potencia, puede leer las etiquetas RFID a una distancia mucho mayor.
Una rápida búsqueda en la Web mostró el récord de 125 kHz etiquetas RFID pasivas es de alrededor de 10 o 15 metros.
Mejores antenas que se centran en un haz podrían hacer aún mejor que esto. No suponga que alguien no puede leer las
tarjetas en su billetera si realmente quería hacer eso.
196
Impreso caso 3D
El caso impresa en 3D para este proyecto cuenta con un soporte para una batería de 9 voltios, torres de alta tensión para mantener la antena
en su lugar, una ranura para montar el tablero con lector de RFID y torres de alta tensión para el ESP8266. El código es para OpenSCAD, un
sistema CAD 3D gratis que hace un llamamiento a los programadores. Figura 6-4
muestra el caso impresa en 3D con los pilones para el montaje de los tableros.
Figura 6-4. Impreso caso 3D para el Proyecto IOTRFID
El siguiente código OpenSCAD construye la base de montaje paso a paso mediante la fusión de formas básicas tales
como cubos y conos. También construimos un soporte para mantener la batería se deslice en la base.
//
// IOT IOTFRFID Base de montaje //
// // laboratorios SwitchDoc
febrero de 2016 //
Unión() {
197

1, -1,0]) del cubo ([132,62,1]);
translate ([- 30,0,0]) union () {

([40,1.35,20]); traducir ([40,26.10 +
3.3,0]) del cubo ([40,1.5,20]);
traducen ([79,2,0]) del cubo
([1,28,4]);
// plyons para ESP8266
traducir ([70-1.0,35,0])
([70-1.0,56,0])
([70-34,35,0])
([70-34,56,0])
cilindro (h = 10, r1 = 2,2, r2 = 1.35 / 2, $ fn = 100); }
// presentarse a bordo
traducir la unión ([15,40,0]) ()

{

([20,1.35,7]);
traducir ([40,3.55 + 1.35,0]) del cubo
([20,1.35,7]); }
// plyons para el tablero de RFID
traducir la unión ([50,0,0]) ()

{
traducir ([33 + 36.0,10,0])

([33 + 36.0,50,0])
cilindro (h = 10, r1 = 3,2, r2 = 2.40 / 2, $ fn = 100);
198
([36,50,0])
cilindro (h = 10, r1 = 3,2, r2 = 2.40 / 2, $ fn = 100); }
Figura 6-5 muestra la parte posterior del lector de RFID 125 kHz Mini para mostrar claramente las etiquetas pines en la parte posterior
de la placa.
Figura 6-5. Primer plano de mini tablero de RFID
A continuación se presenta la lista completa de cableado para el proyecto IOTRFID. A medida de que conecte, marque cada cable para
mayor exactitud.
La clave para la tabla 6-3 Esta abajo. Mesa 6-3 contiene toda la información de cableado para la construcción de la
IOTRFID. Siga de cerca para que su proyecto funciona la primera vez. Esta tabla contiene todas las conexiones de los cables
individuales para completar el proyecto.
ESP8266 Junta Hurra: ESP8266
Mini lector de RFID 125 kHz: RFIDBoard
9V batería: 9VBat
199
Tabla 6-3. Lista de cableado para el Proyecto IOTRFID
Junta Hurra ESP8266 (ESP8266)
ESP8266 / GND RFIDBoard / G Planta para el tablero con lector de RFID
ESP8266 / 3V RFIDBoard / V 3.3V para el tablero de RFID
ESP8266 / # 5 RFIDBoard / Rx Receptor Junta de RFID (no se utiliza en este

proyecto)
ESP8266 / # 4 RFIDBoard / Tx Junta RFID transmisor de serie
ESP8266 / GND 9VBat / terminal “-” (menos de Terreno para la batería

terminal)
ESP8266 / VBat 9VBat / “+” terminal (además de 9V) 9V de la batería
RFIDBoard / T1 Antena RFID JST2 Plug El plomo de la antena - Empuje el enchufe más de T1
y T2 - el orden no importa
RFIDBoard / T2 Antena RFID JST2 Plug El plomo de la antena - Empuje el enchufe

más de T1 y T2 - el orden no importa
Figura 6-6 muestra el JST2 Plug empujado sobre los dos pasadores en la placa RFID conectar la
placa de RFID con la antena.
Figura 6-6. Primer plano de RFID Antena JST2 Plug
200
Su proyecto IOTRFID completado debe ser similar a la figura 6-7 .
Figura 6-7. El Proyecto IOTRFID Completado
El software para el Proyecto IOTRFID

Ningún proyecto basado en computadora está completa sin el software para hacer que el ordenador y del Consejo realiza las
funciones diseñadas. El principal IOTRFID código es muy corto y hace un buen uso de las bibliotecas existentes.
las Bibliotecas
En este proyecto, estamos utilizando dos bibliotecas. Debido a que no tenemos que modificar las bibliotecas para que
funcionen con la ESP8266, no las hemos reproducido aquí. Las dos bibliotecas son los siguientes:
seeedRFID - La biblioteca para interconectar el ESP8266 al lector RFID.

Básicamente una concha sencilla en torno a las bibliotecas SoftSerial
Arduino. [ https://github.com/Seeed-Studio/ RFID_Library ]
201
PubSubClient - Un cliente simple para MQTT. Esta es una biblioteca muy útil y
bien documentada. Utilizamos esta biblioteca para hablar con el servidor
MQTT (mosquitto) en la Raspberry Pi. [ http://pubsubclient.knolleary.net]
El software principal
El software ESP8266 Arduino IDE para este proyecto es relativamente sencillo. Verá algunas similitudes con el software IBM
bluemix en el último capítulo. La principal diferencia es que ahora están haciendo ambos extremos de las conexiones MQTT.
Recuerde que debe poner su propio punto de acceso WiFi y contraseña en el código, así como introducir la dirección IP de
su Frambuesa Pi.
El flujo general del software consiste en inicializar primero la conexión Wi-Fi y el hardware RFID y después de
entrar en un bucle, la comprobación de eventos RFID Tag.
/*
Código laboratorios SwitchDoc para IOT RFID
IOT RFID utiliza Publique Suscríbete a comunicar a Frambuesa Pi de enero de el año 2016
*/
// BOF preprocesador de errores prevenir - inserte en la parte superior de la placa Arduino-código

# si 1
__asm volátil ( "nop");
# terminara si
// opciones en la placa
# Pragma CCG diagnóstico ignorados "-Wwrite-strings"
extern "C" {
# incluir "user_interface.h"}
# incluir "PubSubClient.h"
# incluir "seeedRFID.h"
# definir RFID_RX_PIN 4
# definir RFID_TX_PIN 5
# PRUEBA undef
SeeedRFID RFID (RFID_RX_PIN, RFID_TX_PIN); etiqueta

RFIDdata;
int count = 0; // contador para la matriz del separador
// Variables
202
int blinkPin = 0; // pin llevó a parpadear en cada recepción del código RFID
# incluir "Utils.h"
// ------------------------------------------------ --------------------- // Variables WiFi local
const char * SSID = "YOURWIFIACCESSPOINT"; const char *

password = "YOURWIFIPASSWORD";
# Definir la información
IOTRFIDVERSION 005 // Frambuesa Pi
# definir ORG "switchdoc"

# definir DEVICE_TYPE "IOTRFID-01"
# definir DEVICE_ID "1"
# definir Token "! ul fjh! y8y0gDREmsA"
// configura para IOT Frambuesa Pi
servidor char [] = "192.168.1.40"; // sustituir con su FRAMBUESA IP Número carbón tema [] =

"IOTRFID";
Char AuthMethod [] = "uso-token-auth"; Char TOKEN
[] = TOKEN; Char clientId [] = "IOTRFID";
devolución de llamada vacío (char * tema, byte * carga útil, sin signo int length) {Serial.println (
"devolución de llamada se invoca desde IOT RFID"); }
WiFiClient wifiClient;
PubSubClient cliente (servidor de 1883, devolución de llamada, wifiClient);
void setup () {
// poner su código de configuración aquí, para ejecutar una vez:
pinMode (0, OUTPUT);
Serial.begin (9600); // estamos de acuerdo en que hablar rápido!
Serial.println ( "----------------");
Serial.println ( "IOTRFID publicación / suscripción de inventario");
Serial.println ( "----------------");
// inicio de la señal de código - tres parpadeos rápidos BlinkLED

(3, 250);
203
Serial.print ( "Conexión a WiFi");
Si {WiFi.begin (SSID, contraseña) (strcmp (WiFi.SSID () c_str (),

SSID) = 0.!); }

(500);
Serial.print ( ""); }
Serial.print ( "Wi-Fi conectados, dirección IP local:"); Serial.println

(WiFi.localIP ());
BlinkLED (5, 500); }
void loop () {
// ponga su código principal aquí, para ejecutar repetidamente:
count = 0;
si (!!! client.connected ()) {

Serial.print ( "volver a conectar al cliente"); Serial.println
(servidor);
mientras que (!!! client.connect (clientId)) {
Serial.print ( ""); retardo
(500); }
// cheque para la RFID disponibles
carga útil de cuerda;
si (RFID.isAvailable ()) {
tag = RFID.data ();

Serial.print ( "número de tarjeta RFID lee:"); Serial.println
(RFID.cardNumber ());
# PRUEBA ifdef
Serial.print ( "RFID datos en bruto:"); for (int i = 0; i
<tag.dataLen; i ++) {Serial.print (tag.raw [i], HEX);
Serial.print ( '\ t'); }
# terminara si
// carga útil de Envío
204
carga útil = "{\" d \ ": {\" IOTRFID \ ": \" IR1 \ ""; carga útil + =
"\" VER \ ": \" "; carga útil + = IOTRFIDVERSION; carga útil
+ = "\", \" RFID_ID \ ": \" "; carga útil + = String
(RFID.cardNumber ()); carga útil + = "\" "; carga útil + = "}}";
// comprobar si hay mensajes
Serial.println (payload.length ());
count = 0;
si (payload.length ()> = 53) // buen mensaje {
Serial.print ( "Envío IOTRFID carga útil:"); Serial.println

(carga útil);
si (client.publish (tema, (char *) payload.c_str ())) {Serial.println ( "IOTRFID

Publicar ok"); BlinkLED (1, 500); } Else {
Serial.println ( "IOTRFID no publicar"); BlinkLED (2, 500); }}

Else {
retardo (500); }}
rendimiento(); // Esto es necesario para la ESP8266 hacer las tareas en segundo plano}
Comprobación del sistema de IOTRFID
Utilizando el IDE de Arduino, el flash de la ESP8266 con el software IOTRFID anteriormente.
Después de que se ha brilló, debería ver lo siguiente en el monitor serie de Arduino:
----------------
IOTRFID publicación / suscripción de inventario
----------------
Conexión a WiFi ......
WiFi local conectada, la dirección IP: 192.168.1.135 cliente
reconexión a 192.168.1.40
205
Deje el IOTRFID corriendo por ahora.
Configuración de la ventana de depuración mosquitto
Vuelve a la ventana Terminal 1 del anteriormente en este capítulo y mantenga presionada la tecla Control y haga clic en
“c” (Ctrl + C) para matar el proceso en ejecución de la etapa anterior. Si lo había cerrado, abrir otra ventana de terminal y
siguiendo las instrucciones a continuación.
Construir un archivo de Python para depurar y nuestra suscripción de registro en el corredor mosquitto:
nano IOTRFIDLogSubscribe.py
Escriba el siguiente código:
#
#
# suscripción pantalla de registro
#
# de enero de el año 2016
#
paho.mqtt.client importación como MQTT
# La devolución de llamada para cuando el cliente recibe una respuesta desde el servidor CONNACK.
def on_connect (cliente, datos de usuario, banderas, rc):

print ( "Conectado con código de resultado" + str (RC))
# La suscripción de on_connect () significa que si se pierde la conexión y

# vuelven a conectar a continuación, se renovarán las suscripciones.
client.subscribe ( "$ SYS / corredor / log / #");
# La devolución de llamada para cuando un mensaje se publica se recibe del servidor. ON_MESSAGE def
(cliente, datos de usuario, msg):
impresión (msg.topic +" "+ str (msg.payload))
client = mqtt.Client ()
client.on_connect = on_connect
client.on_message = ON_MESSAGE
client.connect ( "localhost", 1883, 60)
# bloqueo de llamadas que procesa el tráfico de red, envía devoluciones de llamada y

# se encarga de volver a conectar.
# Otro bucle * () funciones están disponibles que dan una interfaz roscada y una
# interfaz manual.
client.loop_forever ()
206
A continuación, ejecute el código escribiendo esto:
sudo python IOTRFIDLogSubscribe.py
Utilizamos “sudo” para asegurarse de que el pitón se está ejecutando con privilegios de root para evitar problemas de permisos
posibles.
Si usted dejó su ejecución IOTRFID, verá lo siguiente:
Conectado con código de resultado 0

SYS / broker / log / N 1454535157: Cliente IOTRFID ha superado el tiempo de espera, la desconexión.
$ SYS / corredor / log / N 1454535157: Error de socket de cliente IOTRFID, desconectar. $ SYS / corredor / log /
N 1454535157: Nueva conexión de 192.168.1.135 en el puerto
1883.
$ SYS / corredor / log / N 1454535157: Nuevo cliente conectado desde 192.168.1.135 como IOTRFID (c1, k15).
Esto significa que su IOTRFID está conectado al corredor mosquitto MQTT. A continuación, vamos a ir a otra
ventana de terminal y establezca un abonado de la Frambuesa Pi a nuestro dispositivo IOTRFID.
Configurar un suscriptor de la Frambuesa Pi

En otra ventana de terminal en la Raspberry Pi, construir otro archivo pitón escribiendo lo siguiente:
sudo nano IOTRFIDSubscriber.py
Escriba el siguiente código:
#
#
# IOTRFID Subscribe Módulo
#
# Recibe el mensaje de inventario de IOTRFID
# SwitchDoc laboratorios de enero de el año 2016
#
JSON importación
paho.mqtt.client importación como MQTT
def filter_non_printable (str):

retorno '' .join ([c para c en str si ord (c)> 31 o ord (c) == 9])
# La devolución de llamada para cuando el cliente recibe una respuesta desde el servidor CONNACK.
def on_connect (cliente, datos de usuario, banderas, rc):

print ( "Conectado con código de resultado" + str (RC))
207
# La suscripción de on_connect () significa que si se pierde la conexión y

# vuelven a conectar a continuación, se renovarán las suscripciones.
client.subscribe ( "IOTRFID / #")
resultado = json.loads (filter_non_printable (msg.payload)) # resultado es ahora iniciar y detener
caracteres de un dict / filtro
InventoryRFID = resultado de [ 'd'] [ 'RFID_ID']
impresión
print ( "IOTRFID de inventario recibida De ID #" + resultar [ 'd'] [ 'IOTRFID'])
print ( "inventario de artículos =" + InventoryRFID) de impresión
client = mqtt.Client ()
client.on_connect = on_connect
client.on_message = ON_MESSAGE
client.connect ( "localhost", 1883, 60)
# bloqueo de llamadas que procesa el tráfico de red, envía devoluciones de llamada y

# se encarga de volver a conectar.
# Otro bucle * () funciones están disponibles que dan una interfaz roscada y una
# interfaz manual.
client.loop_forever ()
Ejecutar el código escribiendo esto:
sudo python IOTRFIDSubscriber.py
Verá lo siguiente:
Conectado con código de resultado 0
A continuación, vamos a ejecutar la prueba completa del sistema.
Probar el sistema completo IOTRFID

Tome su tarjeta de etiqueta RFID y agitarlo sobre la antena IOTRFID como se muestra en la figura 6-8 .
208
Figura 6-8. Tarjeta de etiqueta RFID sobre el dispositivo IOTRFID
Si su IOTRFID está en marcha, debería ver algo similar a la siguiente en la ventana de serie Arduino
IDE:
Volver a conectar el cliente a 192.168.1.40
número de tarjeta RFID lee: 2413943 53
Enviando IOTRFID carga útil: { "d": { "IOTRFID": "IR1", "VER": "5", "RFID_ ID": "2413943"}}
IOTRFID Publicar ok
Y otra vez en la terminal 2, debería ver algo similar a esto:
IOTRFID { "d": { "IOTRFID": "IR1", "VER": "5", "RFID_ID": "2413943"}} IOTRFID de

inventario recibimos de ID # IR1 artículos de inventario = 2413943
Si nos fijamos en la ventana de depuración en la Terminal 1, debería ver algo como esto si no tiene errores:
209
$ SYS / corredor / log / N 1454536615: tiempo de espera del cliente IOTRFID ha superado, desconectar.
$ SYS / corredor / log / N 1454536615: Error de socket de cliente IOTRFID, desconectar. $ SYS / corredor / log /
N 1454536615: Nueva conexión de 192.168.1.135 en el puerto
1883.
Usted publicó acaba con éxito un formulario de mensajes IOTRFID MQTT al corredor mosquitto MQTT en
la Frambuesa Pi y la recibió en un suscriptor MQTT en la Terminal 2.
Ha conectado el dispositivo IOT en su propio agente MQTT tal como lo hizo con IBM bluemix en el
capítulo anterior.
Lo que hay que hacer con los datos de RFID en el servidor

En nuestro ejemplo de suscriptores, tenemos una muy pequeña porción de código que está manejando la información de inventario
RFID que vienen de IOTRFID. Esta sección es la función “ON_MESSAGE” se muestra a continuación:
resultado = json.loads (filter_non_printable (msg.payload)) # resultado es ahora iniciar y detener
caracteres de un dict / filtro
InventoryRFID = resultado de [ 'd'] [ 'RFID_ID']
impresión
print ( "IOTRFID de inventario recibida De ID #" + resultar [ 'd'] [ 'IOTRFID'])
print ( "inventario de artículos =" + InventoryRFID) de impresión
Aunque sólo estamos imprimirlo a la pantalla, si alguien quisiera construir un sistema de inventario real, esta
función es donde se llame a la base de datos, programas de acción, y otros nodos de publicación-suscripción que
necesitan ser notificado de que esta pieza de inventario tiene sido escaneada.
Conclusión
Debe ser algo sorprendente que podemos duplicar una cantidad significativa de la funcionalidad de IBM bluemix con menos de
sólo el 50 $ de dólares en hardware. En verdad, lo hemos hecho con este proyecto. Sin embargo, hay un montón de cosas que
faltan en nuestra implementación en comparación con el sistema IBM bluemix. Nuestro sistema no tiene redundancia, no hay
manera de ampliarlo para decenas de miles de dispositivos, se carece de un panel de control administrativo real, y no ha
abordado la cuestión muy importante de la seguridad informática y hackability.
210
Los conceptos que hemos explorado en este capítulo deben dar al lector algunas ideas muy sólidas en la
tecnología y la vuelta a un cuadro negro (como IBM bluemix) en algo que es más fácil de entender.
En cuanto a la seguridad informática se aplica a los dispositivos de IOT, esta es una excelente ramificarse en el capítulo siguiente,
“la seguridad informática y la IOT.”
211
CAPÍTULO 7
Seguridad informática y la IOT
Capítulo Objetivo: Conocer los fundamentos de la IOT Computer Security
• Los cinco mejores cosas de qué preocuparse
• La seguridad informática es lo
• Seguridad informática para las Comunicaciones
• Seguridad informática para dispositivos de hardware
• La protección de sus usuarios
¿Por qué estamos preocupados por la seguridad informática en la IOT?

Los hackers están en todas partes. Ellos atacan a nuestros bancos. Ellos atacan a nuestras tiendas Target (piensa). Ellos están
tratando de atacar nuestra infraestructura (electricidad, agua, alcantarillado, etc.). Ahora, con el advenimiento de la IOT, tienen una puerta de
entrada a su casa.
¿Adivina qué? Ellos van a atacar a su dispositivo IOT. Usted puede pensar que está a salvo porque no es muy
importante (ver hay 2 más abajo - no siendo importante, no es una buena defensa.); van a atacar.
Comprender un hecho muy importante. Los hackers atacan raramente algo específico. Utilizan programas para
atacar a miles y decenas de miles de cosas a la vez. Luego sólo tiene que esperar por los resultados. Si está expuesto en
Internet, ellos te encontrarán. Su trabajo es asegurarse de que no pueden hacer nada importante al respecto.
Quiénes son los piratas? Hay la gente de sombrero negro que tratan de hacer dinero de los ataques o
ransomware. Hay estados-nación que hacen esto (y no sólo los Estados Unidos, China y Rusia, tampoco. Corea del
Norte y muchas otras naciones tienen programas). No es sólo tan caro que hacer y el Internet le da acceso a
cualquier lugar.
Hay hackers de sombrero blanco que están tratando de encontrar y solucionar los problemas de seguridad en los programas y en
Internet. Estas personas están tratando de ayudar realmente el problema.
Ah, y luego hay un conjunto de otra categoría de personas que se encuentran en algún punto intermedio. sombreros grises, si
quieres. Estas son personas que no están realmente seguros de lo que están haciendo. Las personas pueden descargar programas de
hacking y ejecutarlos sin tener alguna idea de lo que está pasando. Estas personas se llaman “script kiddies” y pueden causar todo tipo de
daños a propósito o no.

CAPÍTULO 7 ■ COMPUTER de seguridad y la IOT
IOT: Top Cinco cosas que debe saber sobre IOT Computer Security
El autor ha dirigido una compañía de seguridad informática y ha enseñado a la seguridad informática y la guerra de información a
nivel de grado y postgrado en varias universidades. En este capítulo estoy tomando una mirada diferente a la seguridad
informática que la mayoría de los libros técnicos. Mientras que estoy discutiendo métodos de cifrado y autenticación, También
estoy tomando una vista de nivel superior del problema y una visión realista de lo que puede y no se puede hacer con los
pequeños ordenadores que componen la IOT.
Con eso, vamos a empezar con mis pensamientos acerca de los cinco mejores para saber sobre la IOT seguridad informática.
Número 1: Se trata de importante . Puede probar su aplicación es

insegura , pero no se puede probar su aplicación es seguro.
"¿Qué? Eso no tiene ningún sentido. Mi solicitud sólo tiene 200 líneas de código en él y puedo ver que es
seguro!”
Hay dos cosas a considerar aquí. Primero de todo es que esos 200 líneas han sido compiladas por un compilador que tiene
100.000 líneas de código. El sistema operativo que se esté ejecutando en cuenta al menos 25.000 líneas de código (sí, incluso un
Arduino) y millones de líneas de código en una máquina de Frambuesa Pi o Windows. Sus 200 líneas de código interactúan con
decenas de miles de líneas de código. Usted no sabe qué tan grande es su propio programa. Usted no sabe sobre el compilador.
Usted no sabe acerca del sistema operativo. Sí, algunos micro-controladores le permiten configurar todo, pero en los sistemas de
desarrollo de hoy en día esta es la excepción y no la regla.
El segundo aspecto a considerar es un teorema probado desde el excelente libro de Matt Bishop [Computer Security: Arte y
Ciencia, Matt Bishop] sobre seguridad informática: “Es indecidible si un determinado estado de un sistema de protección dado es
seguro para un derecho genérico dado. ”
¿Qué significa esto? Esto significa que “se puede saber si su programa de ordenador es inseguro, pero no se
puede saber si es seguro.”
Ay.
Número 2: la seguridad por oscuridad no es la seguridad

Un sistema de IOT, que se basa en el secreto de las implementaciones o componentes del sistema no es la seguridad. La
oscuridad puede ser parte de una estrategia de defensa en profundidad, pero no debe ser invocado para proporcionar
seguridad. Sí, alguien puede tomar su diseño y técnicas de ingeniería inversa y averiguar todo sobre él. El uso de un puerto
diferente para SSH ni siquiera hace más lento hackers en estos días. La gente puede espiar lo que está enviando y averiguarlo.
Su sistema tiene que depender de la clave de su sistema y no la estructura de la cerradura.
Número 3: Siempre conectado? Siempre vulnerable.

Cada momento que el dispositivo IOT está conectado a Internet oa la red es un momento que puede ser atacado. Mantenga
el dispositivo fuera de la red tanto como sea posible. Esto ahorra energía, también, que es a menudo una definición de los
criterios de diseño.
214
Número 4: Enfoque en lo que se Importante a la seguridad de su

aplicación IOT
¿Le importa a un hacker que la temperatura en el acuario es de 85 grados? Probablemente no. ¿Quieres que sean capaces de
cambiar la temperatura en el acuario? Probablemente no. ¿Quiere que su cerradura de la puerta delantera (que está conectado a
Internet?) Sea segura? Si todo el tiempo. Y no, usted no quiere a los piratas informáticos para ser capaz de decir si la puerta está
bloqueada o desbloqueada. Sólo recuerde toda la encriptación en el mundo no importa si una persona tiene la llave. En este caso,
ya sea una llave física o una clave criptográfica. Ambos pueden abrir su puerta. En nuestra aplicación IOT cerradura de la puerta,
hay que mantener la llave de seguridad.
Número 5: Seguridad informática se basa en tres aspectos principales:

confidencialidad, integridad y disponibilidad
confidencialidad se define como la ocultación de información o recursos. Mantener las cosas en secreto (como llaves) para que
los piratas informáticos no puedan usarlos.
Integridad se define como la fiabilidad de los datos o recursos. Asegurarse de que un hacker no puede forjar las
directivas para abrir la puerta de su casa o del coche puertas. Oh, eso sucede. No es bueno cuando lo hace.
Disponibilidad se refiere a la capacidad de acceder a información o recursos cuando sea necesario. Si alguien está haciendo
una denegación de servicio en su casa o su proveedor de Internet, no se puede llegar a su cerradura de la puerta. Sí, incluso con una
cerradura de la puerta conectado a Internet, usted debe tomar su llave física a lo largo. Y no establecer el código de acceso a su
cumpleaños.
En este capítulo, voy a hablar de algunas de las técnicas aplicables IOT para hacer frente a las tres
partes de la Tríada. La CIA Triad se muestra en la figura 7-1 .
La Figura 7-1. La CIA Tríada
215
Cuáles son los peligros?

Los peligros de la inseguridad equipo depende del tipo de información y actuadores del dispositivo IOT. En primer lugar,
vamos a hablar de los tipos de información.
El peligro de la piratería de su dispositivo para obtener información depende completamente del “valor” de la
información, tanto en un sentido local y en un sentido temporal. Por ejemplo, un sensor de lectura de la temperatura en
su armario, probablemente, no vale mucho en un momento dado y sabiendo que la temperatura de su armario hace diez
horas (valor temporal) es probablemente aún vale menos.
En la otra dirección, la transmisión de la contraseña de su conexión Wi-Fi en el claro de un dispositivo IOT es una pieza
valiosa de información; y en la mayoría de los sistemas, sigue siendo valiosa de diez horas en el pasado.
Por lo tanto, el valor de la información tiene dos componentes principales. Es la información valiosa en el momento de
la producción, y por qué sigue siendo valioso como el tiempo avanza?
Asignación de valor a la información

En un sentido real, el riesgo final de la divulgación de datos se puede describir como el valor de la información divulgada. En la
derrota reciente información de la tienda Target, que era caro. El valor de la información perdida (tarjeta de crédito y la información
del cliente) fue alta, no sólo en el fraude, pero en la prevención del fraude (la sustitución de todas las tarjetas) y, finalmente
costará el CEO de destino su trabajo. Ahora, tenga en cuenta, debido a estas medidas correctivas, el valor de tiempo de la
información perdida declinó rápidamente después de la divulgación. ¿Cuál fue el valor de la información perdida a Target?
Alrededor de $ 10 o $ 15 millones. Mientras que puede parecer una gran cantidad de dinero, que era menos del 1 por ciento de
los ingresos de la compañía.
Después de un reembolso de deducciones seguros e impuestos menos, probablemente era incluso menos. La
sorprendente conclusión después de ver los informes es que las grandes brechas de datos no cuestan casi nada a estas
empresas. números y costes similares se aplican a la Sony y las violaciones de datos de Home Depot. Los costes no son
relevantes para estas grandes empresas.
Todos los consumidores incomodados por conseguir nuevas tarjetas de crédito, o tener el fraude en su tarjeta o su
identidad robada, probablemente sentir de forma diferente.
En una escala mucho más pequeña, he experimentado esto en un nivel más personal. En 2000, empecé un banco (sí, un
verdadero banco real asegurada por la FDIC) y han formado parte del consejo de administración desde entonces. Naturalmente,
he servido como presidente del Comité de Tecnología. Ha sido interesante.
A mediados de la década de 2000, nuestro proveedor de pago Visa se ha visto comprometida y tuvimos un pequeño problema de
fraude con las tarjetas comprometidas (alrededor de $ 2,000) que las normas dicen que éramos responsables. También tuvimos alrededor
de $ 10.000 de costes en la emisión de nuevas tarjetas. Nos dieron una pequeña reembolso de nuestra cyber-seguro, pero tuvimos que ir
después de que el proveedor de pago. Después de seis meses que iban a ninguna parte (que no querían que pagar nada, aunque era
claramente su culpa), nos dimos por vencidos. Por lo que realmente vale la pena en este caso? Usted, el consumidor, con mayores costos
pasados a usted.
216
La mayoría de los trabajos académicos se centran en el costo de la pérdida de datos y la exposición en las empresas grandes y
medianas de tamaño. No es sorprendente que poco trabajo sobre el coste de la pérdida de información y la exposición de IOT.
Así pues, cómo se asigna valor a la información en el IOT? Nos fijamos en lo que significa que el usuario tenga los datos
perdidos o comprometidos y estimar un daño financiero (o personal) para el usuario. Las empresas anteriormente se centran en
costo para ellos. En el IOT que hay que buscar en el costo para el usuario final.
¿Qué pasa si alguien hackea su cerradura de la puerta frontal inalámbrica? ¿Qué hay de su televisor? Según los
informes, el Smart TV de Samsung te escucha, incluso cuando no está hablando con el televisor. Te advierten de no discutir la
información sensible alrededor de su televisor. Buen dolor. Cuando se descubrió que era posible para introducirse en la cámara
de Samsung Smart TV en la parte superior del conjunto, sugirieron poner cinta negro sobre ella o empujándola en el set con un
lápiz. Samsung es una compañía de $ 180 mil millones al año. Se podría pensar que iban a poner un poco más en la seguridad
informática.
las previsiones de Gartner [ www.gartner.com/newsroom/id/3165317 ] que habrá 6.4 mil millones de IOT “cosas” conectada a
finales de 2016. Y se pronostica además que para el año 2020 será de 20 mil millones de “cosas” conectadas. Usando los números
aproximados de las previsiones de Gartner cantidad que se gasta en el mercado mundial de seguridad IOT (alrededor de $ 7 mil
millones en 2015 y el aumento de $ 30 mil millones en 2020), nos encontramos con un número interesante. La cantidad que se gastará
en la obtención de la IOT será de alrededor de $ 1 por cada dispositivo IOT. Ahora bien, esto es algo que podemos usar en nuestro
presupuesto para el desarrollo IOT. Mi sensación de la tripa es que se trata de la derecha.
De nuevo al valor de la información. En 2016, 5.5 millones de dispositivos IOT se conectan todos los días. Estos dispositivos están
conectados incluyen automóviles, electrodomésticos de cocina, televisores inteligentes, relojes de pulsera, juguetes, instrumentos
médicos, etc., etc.
Cuando un dispositivo se conecta IOT, que necesita ser protegido.
La construcción de tres componentes de seguridad básica para IOT

Computadoras
La seguridad informática es un tema complejo con una gran cantidad de interacciones entre diferentes sistemas y subsistemas
en incluso una simple transacción desde un dispositivo IOT a un servidor a través de Internet. Vamos a volver ahora a la CIA
Tríada (confidencialidad, integridad y disponibilidad) y ver lo que podemos hacer con cada uno de estos conceptos en la
práctica de estos pequeños ordenadores.
Confidencialidad - Criptografía
La confidencialidad se define como la ocultación de la información. Como se mencionó anteriormente, casi siempre se puede
obtener información de dispositivo si tiene acceso físico al dispositivo. Lo que nos estamos centrando en esta sección es la
protección del canal de transmisión de la información en lugar del propio dispositivo IOT física.
217
Nota de que no. 2 anterior, la oscuridad no cuenta como lo que va de la seguridad informática. Si estamos
transmitiendo información valiosa, entonces tenemos que cifrarlo utilizando técnicas criptográficas. ¿Qué es la criptografía?
Las técnicas criptográficas incluyen usos para la totalidad de la CIA Tríada, pero aquí nos vamos a centrar en el cifrado que
es un subconjunto de estas técnicas.
Discusión de las técnicas de criptografía y cifrado pueden llenar fácilmente un libro entero así que voy a permanecer
lejos de los cálculos y se centran en la aplicación. La única cosa que necesitamos discutir es que la criptografía moderna
se basa en gran medida en las metodologías matemáticas y ciencias de la computación. Todas estas técnicas de abajo se
puede dividir en base a las consideraciones teóricas de los algoritmos, pero es práctico hacerlo mediante cualquier técnica
conocida. Eso hace que estas técnicas Algún día “Computacionalmente seguro.” En el futuro que puede ser capaz de leer
el termómetro, pero ¿merece la pena? Depende del valor de la información.
Hay una cosa importante tener en cuenta sobre el cifrado y criptografía. Estos algoritmos tienden a ser
computacionalmente costosa en términos de cantidad de relojes de CPU y memoria RAM para hacer estos cálculos.
Recuerde que los dispositivos IOT no tienen una gran cantidad de relojes de CPU o una gran cantidad de memoria RAM. Por
lo tanto, utilizar la cantidad mínima de estas técnicas para proteger sus datos. Tienes que ser inteligente de ahorrar batería y
espacio de memoria RAM.
Criptografía en el Arduino
Existen básicamente dos formas de Arduino para comunicarse con dispositivos externos. Que o bien tienen una
conexión de red (Ethernet, Bluetooth, WiFi, Zigbee, u otras redes), o si tiene un conector en serie (USB, directamente
en serie). Mientras que las técnicas descritas en esta sección son aplicables a ambos tipos de conexiones, nos
centraremos en las técnicas de tipo red. Para el Arduino voy a centrarse en el uso de AES. Mientras que el siguiente
ejemplo se ejecuta en Arduino Mega2560, sino que también se puede ejecutar en un ESP8266 con cambios mínimos.
AES es lo que ellos llaman un cifrado de bloques simétrica utilizada por el gobierno de Estados Unidos para proteger la
información clasificada. Es bastante bueno cifrado y no puede ser rota en la redacción de este capítulo de los ataques de fuerza bruta.
Sin embargo, como Bruce brillante ha dicho, “Los ataques siempre mejoran; nunca empeoran “.
Los siguientes son sólo algunas de las bibliotecas AES disponibles para el Arduino:
• github.com/DavyLandman/AESLib
• spaniakos.github.io/AES/index.html
• utter.chaos.org.uk:/~markt/AES-library.zip
Estamos utilizando un Mega2560 Arduino (que se muestra en la figura 7-2 ) En lugar de un Arduino Uno
porque el Mega2560 tiene 8K bytes de SRAM disponibles frente bytes 2K en el Uno.
218
Figura 7-2. Arduino Mega2560
Vamos a utilizar la biblioteca Davy Landman para nuestros ejemplos. Para instalar en su biblioteca de Arduino, siga las
instrucciones en el archivo README.md. Lo que sigue es un ejemplo de cómo utilizar la biblioteca de AES en un programa de
Arduino. Puede sustituir cualquier Arduino para este ejemplo. Sin embargo, no se compila bajo el Arduino IDE ESP8266 a
menos que se realicen cambios en la propia biblioteca de AES.
// //
// AES biblioteca de prueba // //

SwitchDoc laboratorios febrero
de 2016 //
# incluir <AESLib.h>
// 256 bits clave para AES

clave uint8_t [] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,
17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31};
219
void setup () {
Serial.begin (115,200); }
void loop () {
// ponga su código principal aquí, para ejecutar repetidamente:
// 16 bytes
datos char [] = "01234567890Hello";
int sizeOfArray; int i;
sizeOfArray = sizeof (datos) / sizeof (char);
Serial.println ();
Serial.print ( "los datos se codifiquen (formato ASCII): \ t"); Serial.println (datos);
Serial.print ( "los datos se codifiquen (formato hexadecimal): \ t");
for (i = 0; i <sizeOfArray - 1; i ++) {
if (uint8_t (datos [i]) <0x10) Serial.print (

"0");
Serial.print (uint8_t (datos [i]), HEX);
}
Serial.println ();
// Ahora se encripta los datos utilizando una clave AES de 256 bytes
aes256_enc_single (clave, datos);
// imprimir los datos cifrados a cabo en Hex
Serial.print ( "cifrado (en Hex): \ t \ t \ t");
for (i = 0; i <sizeOfArray - 1; i ++) {
if (uint8_t (datos [i]) <0x10) Serial.print (

"0");
Serial.print (uint8_t (datos [i]), HEX);
}
Serial.println ();
220
// Ahora descifrar los datos e imprimirlo
aes256_dec_single (clave, datos); Serial.print (

"descifrado: \ t \ t \ t \ t"); Serial.println (datos); }
Nota la clave dada al comienzo del programa. Esta clave de 256 bits es lo que necesita tanto para cifrar y descifrar los
datos. Por supuesto, esto no es una muy buena clave en nuestro ejemplo.
A continuación se muestra un ejemplo de los resultados del programa:
los datos a ser cifrados (formato ASCII): los datos 01234567890Hello a cifrar
(formato hexadecimal): 303132333435363738393048656C6C6F
cifrada (en Hex): 438693C632D91AF2283651F416BBA61E
descifrado: 01234567890Hello
Esta es la única pieza de información secreta. Los dos extremos del canal de comunicación necesitan tener
esta tecla para AES para trabajar.
gestión de claves (cómo enviar estas claves alrededor) es un tema clave del diseño de la seguridad informática IOT y
será discutido más adelante en este capítulo.
En cuanto a este programa, se podía ver cómo se puede descompilar el código y recuperar la clave secreta. Este
es un ejemplo de por qué el acceso físico al dispositivo a menudo puede conducir a la capacidad de hackear el
dispositivo y la red de dispositivos.
¿A qué velocidad son estas bibliotecas en un Arduino? Basado en un ATMega328 16MHz, una clave AES de 128 bits puede generar
alrededor de 27.000 bytes por segundo. El uso de una clave de 256 bits que recibe alrededor
20.000 bytes por segundo.

Ahora que es el uso completo de la CPU diámetro interior, por lo que si usted tiene otras cosas que hacer con el procesador (como es
casi seguro que el caso), usted no será capaz de hacer que las tasas de estos datos de forma continua.
Tenga en cuenta que las bibliotecas AES ya están incorporados en el firmware de la ESP8266, pero a partir de la
redacción de este capítulo realmente no hay ejemplos completos de cómo usarlos y la documentación es muy escasa.
Criptografía en la Raspberry Pi
La Raspberry Pi tiene un conjunto mucho más rico de las bibliotecas de criptografía disponibles en el sistema operativo o
descargas tan fácilmente disponibles. Por ejemplo, si se está comunicando usando peticiones web (entre Frambuesa Pi de o
equipos basados en Linux), se puede utilizar SSL para cifrar el tráfico entre los dos nodos. Es altamente estandarizada, y si se
configura correctamente es muy seguro. ¿Por qué no utilizamos SSL en un sistema basado en Arduino o ESP8266? Dos
razones: en primer lugar, la memoria / procesamiento de las limitaciones de potencia; y el segundo es el problema de la
distribución de los certificados necesarios para los enlaces SSL seguras. Esta es otra variante del problema clave de
distribución.
Los mismos AES-256 funciones están disponibles en la Frambuesa Pi para que pudieran ser utilizados en la
comunicación con un Arduino. Sin embargo, este método es muy lejos de la implementación de SSL completa utilizada por
los navegadores web modernos y equipo (piensa https: // en lugar de http: //) .
221
La biblioteca de cifrado AES Spaniakos como antes citada bajo la criptografía en la sección Arduino también está
disponible para la Frambuesa Pi.
Tenga en cuenta que existen implementaciones de hardware de AES empezando a aparecer para Arduino y Raspberry Pi.
Integridad - Autenticación
La integridad se define como la fiabilidad de los datos o recursos. Tenga en cuenta la diferencia entre la integridad y
cifrado. Cuando hablo de la integridad, estoy hablando de asegurarse de que las directivas o los datos enviados a mi
dispositivo IOT no ha sido cambiado en el camino y que yo sepa a ciencia cierta que lo envió. Las directivas o datos pueden
o no pueden ser cifrados.
En cuanto a esto desde el punto de vista de valor de la información, esto significa que en realidad no importa si un hacker se
ve en los datos (estoy encender la calefacción en mi casa), pero nosotros usamos la integridad para asegurarse de que un hacker no
se puede forjar la directiva o los datos y que el hacker no puede cambiar los datos en sí.
Hay muchas maneras de utilizar algoritmos criptográficos para establecer la integridad del contenido
del mensaje y establecer que envió el mensaje.
Estableciendo que el mensaje no ha sido modificado en el camino se puede hacer mediante el uso de lo que se
llama un hash criptográfico en el mensaje. En concepto, se toma cada byte del mensaje y mediante el uso de un algoritmo
criptográfico, se puede determinar que el mensaje no ha sido modificado - con una muy, muy alto grado de certeza.
Los valores hash criptográficas en el Arduino / Frambuesa Pi
Con el fin de probar que el mensaje no ha sido alterado en el tránsito, tendrá que enviar el mensaje + el hash
toda la red. Al igual que el cifrado de ejemplo anterior, es necesario llevar a su mensaje y de hash criptográfica
del mensaje para generar los códigos hash. Vamos a utilizar el tenedor de Cathedrow biblioteca [ https://github.com/maniacbug/
CryptoSuite ] para este ejemplo.
Sin embargo, las bibliotecas requieren algunos ajustes para hacer que funcionen en las versiones más recientes del
IDE de Arduino, así que les han incluido en la descarga de este software como fichas adicionales. Esto funciona con una
placa Arduino y una tabla de ESP8266.
//
// Prueba de hash SHA256 //
// Tanto para el Arduino y ESP8266 // // SwitchDoc

laboratorios
// de febrero de el año 2016
# incluir "sha256.h"
222
printHash anular (uint8_t * hash) {int i;
for (i = 0; i <32; i ++) {

Serial.print ( "0123456789abcdef" [hash de [i] >> 4]); Serial.print (
"0123456789abcdef" [hash de [i] y 0xf]); }
void setup () {
Serial.begin (115,200);
Serial.println ( "Prueba de hash SHA256");
Serial.println ();
void loop () {
* uint8_t de hash;
Sha256.init (); hashMessage
cadena; int i;
while (1) {
hashMessage = "Este es un mensaje a hash"; hashMessage

= hashMessage + String (i% 10); Serial.print ( "Hashing
Mensaje:"); Serial.println (hashMessage); Sha256.print
(hashMessage);
de hash = Sha256.result ();
printHash (hash);
Serial.println (); retardo
(5000);
i ++;
223
Los resultados son los siguientes:
Prueba de hash SHA256
Hash del mensaje: Este es un mensaje para discutir-2

f2a47cefff87600aeb9089cf1f11a51b833ccdd91b808df75b7238fc78ba53f2

5d135bc35a33004cad4c4ed37fc0011c1475f09c6ddd7dec01c348734e575f41

fe1aa898ab0e041d1ce4539b388439c75a221efab0672896fc5e14b699c01492
Si se cambia el mensaje resumido, el hash SHA256 cambiará. Se puede decir que el mensaje no ha sido modificado
en ruta a su dispositivo. Tenga en cuenta que no tenemos la clave criptográfica para intercambiar. SHA256 funcionará igual
en todas partes.
Nota SwitchDoc Demostrando algo que no ha sido alterado durante la transmisión le dirá que está bien. Sin embargo, lo que
si sólo tenemos un mensaje ligeramente dañado? Esto podría ser causado por el ruido en la línea (piense en la comunicación
por satélite). Si desea corregir errores en un mensaje como este, se utiliza otro conjunto de algoritmos. códigos de corrección
de errores Reed-Solomon son un gran ejemplo de estos. Puede corregir los datos, entonces descifrarlo. Obviamente, es
necesario cifrar el mensaje primero y luego poner estos códigos en la parte superior de los datos cifrados para que su canal de
comunicación más fiable. Invirtiendo el orden (el cifrado del código Reed-Solomon) no tiene sentido y no proporcionará la
corrección de errores.
El código de Frambuesa Pi es muy similar.

Por lo tanto, esto parece bastante sencillo. ¿Qué nos falta? Tenemos la prueba de que el mensaje no ha sido
modificado. Genial. Prueba de integridad de datos.
Sin embargo, no hemos probado que los datos no han sido forjada usando un ataque de hombre-en-el-medio. Ahora
tenemos que mirar a la última parte de la integridad de los datos. Prueba en la que está viniendo, o en otras palabras, no
repudio.
No repudio por lo general se basa en alguna variación de cifrado de clave pública / privada.
Funciona así. Bob tiene una clave privada, que sólo él conoce. Él también tiene una clave pública que se da a
cualquier persona que quiera comunicarse con él. Cuando Bob quiere enviar un mensaje a Alice, que codifica el
mensaje con su clave privada y la envía a Alice. Alice utiliza la clave pública que recibió de Bob para descifrar el
mensaje. Si se descifra con éxito, entonces Alice sabe que el mensaje vino de Bob.
Por lo tanto, el uso de este método de clave pública / privada, podemos cifrar el mensaje y demostrar que venía de Bob y no
se altera. Invirtiendo el procedimiento, se puede enviar un mensaje a Bob de Alice con seguridad.
224
OK, se ve perfecto. ¿Cuáles son las complicaciones? Una vez más estamos de vuelta a los intercambios de claves. Tanto nuestro
servidor IOT y el dispositivo IOT tiene que tener las claves privadas y publicar las claves públicas al servidor. Esto suena como un montón
de trabajo. Y es. Aquellos lectores moresophisticated se dará cuenta de que esto se parece mucho a SSH / HTTPS. Correcto. Y como se
señaló anteriormente, esas son las grandes bibliotecas para computadoras pequeñas, aunque la Frambuesa Pi puede manejar la
situación, la clase de procesadores Arduino realmente no puedo. El ESP8266 es apenas capaz de hacer esto (y lo hace por su opción de
actualización sobre el aire) pero no están distribuyendo llaves. Se ponen al día una comunicación unidireccional. Para los enlaces de
comunicación bidireccional, necesita llaves para ambas direcciones.
Hay un nivel adicional de complejidad establecido en la parte superior de esta. Los certificados deben ser trazables a una
autoridad de confianza conocido para probar el sistema no ha sido comprometida.
Mostrando ejemplos del software de clave pública / privada es mucho más allá del alcance de este libro.
Algunas palabras clave para buscar son “Firma Digital, Diffie-Hellman y RSA de clave pública de cifrado” en la
búsqueda de esta tecnología. Un buen ejemplo de un sistema que muestra este tipo de un sistema entre un Arduino y
un PC con Windows está disponible en este enlace: github.com/arpitchauhan/cryptographic-protocols-arduino-and-PC/
La metodología general utilizada es la siguiente:
• Las claves públicas se intercambian de forma segura entre los dos dispositivos (Nota: ambos
tienen su propia clave privada).
• Después de que las claves públicas se intercambian, se puede transferir una clave de cifrado AES.
• Ahora, los dispositivos pueden comunicarse de forma segura y con seguridad usando AES como en el
ejemplo anterior.
Una cosa importante a tener en cuenta es el cifrado de clave pública / privada es mucho más costoso computacionalmente que el
cifrado AES. Esta es la razón por que el intercambio de sus claves AES con este esquema y luego sólo tiene que utilizar AES para enviar los
datos durante el funcionamiento normal.
Disponibilidad - Manejo de DOS / Pérdida de servidor de / perros guardianes
En realidad no hay mucha diferencia entre un ataque a negar el servicio (DOS), el Internet se cae, el reinicio del
router inalámbrico o su horno de microondas volverse loco. Todas estas cosas interrumpir su ruta de
comunicación a su dispositivo IOT.
Una cosa que los dispositivos inalámbricos IOT comerciales son especialmente vulnerables a es la incapacidad
de hablar con el servidor debido a ruido eléctrico en el entorno, ya sea generada por error oa propósito. Cuando usted
está planeando su dispositivo IOT, es necesario asegurarse de que el diseño de modo que el dispositivo puede
manejar una interrupción del servicio de comunicación, si se hace a propósito o por fallo del equipo. Tiene que haber
algún método para decirle al usuario o consumidor que tiene un fallo.
¿De qué manera los militares de evitar esto? Utiliza esquemas complejos como radios de salto de frecuencia, grandes
cantidades de energía radiada por radio a “quemar” el ruido, y grandes antenas. Estas no son las técnicas que están
disponibles a bajo precio a nuestros dispositivos IOT.
225
Gestión de claves
gestión de claves es un problema difícil. Gestión de la configuración de los dispositivos de IOT es difícil. De las secciones
anteriores de este capítulo, tenemos que tener una clave compartida para cifrar AES256 para mantener nuestra comunicación
confidencial. También necesitamos claves para probar que el mensaje ha llegado de la persona o servidor correcto.
Recuerde que cada vez que el dispositivo IOT está comunicando con el Internet o la red de área local,
hay una posibilidad de compromiso.
Hay dos enfoques para la gestión de claves en dispositivos IOT. La primera es mediante el uso de la gestión de claves de
hardware.
Empresas como Infineon construir chips que incluyen claves privadas y públicas que pueden ser utilizados para construir
redes de dispositivos IOT. Puede establecer certificados de confianza (que une a una autoridad de certificados de confianza) en el
momento de la fabricación y el establecimiento de un conjunto de protocolos de software para el uso de estas teclas después del
despliegue. A medida que el proceso y los chips se hacen menos caro, creo que vamos a ver más y más de estos tipos de
sistemas desplegados. Al momento de escribir este libro, estos chips no son baratos. El uso de uno de ellos más o menos el doble
del precio de su dispositivo IOT en muchos casos. ¿Qué pasa con el acceso físico a estos dispositivos? Sí, puede comprometer un
dispositivo de tomarlo y destrozarlo (y no me refiero sólo a tomar los tornillos a cabo. Estoy hablando de retirar el plástico de las
patatas fritas y pasar por el chip con un microscopio. Recuerde nuestra discusión sobre el valor de la información? Es probable que
no vale la pena hacer todo esto para poner en peligro su termostato o tostador.
El segundo método es utilizar software para distribuir las teclas durante la configuración (o incluso
durante la fabricación). Estos métodos se llaman en general PKI (Public Key Infrastructure).
En general, muchos dispositivos IOT son más vulnerables a los ataques que los servidores normales, PC y
teléfonos inteligentes debido a que operan con el software incorporado (firmware) que se ha desarrollado sin seguridad en
línea en mente. Hay muchos ejemplos de fallas de software realmente malas que pueden incluir la gestión de back-end
con contraseñas por defecto que se encuentran fácilmente en Internet y las comunicaciones no cifradas. La gente está
hackeando activamente en cosas como los routers y otros dispositivos conectados y su uso en el DOS (Denegación de
Servicio) ataques. Pensar en nuestros dispositivos LightSwarm en un capítulo anterior. Se podría programar a todos para
empezar a enviar mensajes tan pronto como sea posible y crear su propio ataque DOS. Durante el desarrollo de la
LightSwarm, que sin querer hice esa misma cosa. Me abruma el servidor Frambuesa Pi mediante el envío de mensajes a
la vez,
Otro problema real con dispositivos IOT es que el firmware interno dispositivo IO no puede ser actualizada por años (o la
empresa puede quedar fuera del negocio) y la infraestructura para la actualización de estos dispositivos simplemente no existe o
no.
El uso de métodos de PKI actuales son sólo poco práctico a escala a las próximas múltiples mil millones de dispositivos
IOT proyectados para ser conectado a la red. Debido a esto muchos fabricantes toman atajos para asegurar sus dispositivos. Por
ejemplo, todos los dispositivos IOT puede compartir una clave única (ya sea una clave de cifrado AES o un / par de claves
privadas sola público). Este método hace suministrar una cantidad significativa de la seguridad, pero si se ve comprometida la
clave única (como ha ocurrido muchas veces en la industria informática. Piense Sony y Microsoft), entonces toda la red está
abierta a los piratas informáticos.
La industria tiene las herramientas matemáticas y técnicas para proteger la IOT. Lo que no tenemos es un método
sencillo y seguro para la distribución de las claves para la totalidad de la IOT.
226
Este es un problema que no ha sido resuelto todavía y probablemente no será antes de desplegar otra unos mil
millones de ordenadores.
la administración de actualizaciones
De acuerdo con un experto (en realidad yo), los dos mayores problemas para mantener los dispositivos de seguridad IOT son los siguientes:
• La falta de capacidad de actualización remota
• capacidad de actualización remota
Ser capaz de actualizar el firmware es clave para evitar la obsolescencia y para recuperarse de fallas que salen a la
luz después de la implementación de dispositivos. Este es un canal muy importante de información que necesita ser
asegurado mediante cifrado, tanto desde el punto de vista de la integridad de datos y para asegurarse de que sólo se
actualiza de donde debería ser actualizada (no repudio). Las técnicas anteriores se pueden utilizar para hacer estas
mismas cosas.
Si alguien puede encontrar la manera de engañar a su sistema de actualización, la persona puede volver a programar
todo el sistema.
Conclusión
¿Por qué alguien quiere entrar en el termostato? Para proporcionar una entrada a la red. Recuerde que la violación de datos de
destino que hablé antes? Que se inició a través de una aplicación de mantenimiento del sistema de refrigeración. Se pusieron en
la red a través del aparato de aire acondicionado.
El IOT representa una gran oportunidad para mejorar la vida y experiencias de las personas. Con un gran
poder viene una gran responsabilidad. Al diseñar la Internet de las Cosas aplicación asesina y el dispositivo, la
seguridad en el diseño desde el principio. No virar en al final.
Mira las noticias. En un futuro próximo, verá artículos sobre las personas (y programas) pirateo de coches - oh
espera, que ya lo están haciendo. Verá artículos que tienen la piratería en cerraduras de las puertas del hotel - Oh,
espera, que ya lo están haciendo. Y verá la gente piratería en el termostato de su casa - Oh, espera, que ya están
haciendo eso, también.
A continuación se presenta un ejemplo de una revisión del Amazonas:
El hombre escribió que su esposa lo había dejado por otro hombre y luego se trasladó a
su nuevo hombre en su antigua casa que habían compartido, que tenía un termostato
Honeywell WiFi. La ex amante aún podía controlar el termostato a través de la aplicación
móvil instalada en su teléfono inteligente, por lo que se utiliza para cambiar el entorno
para la pareja que ahora vive en su antigua casa: “Desde el pasado invierno Ohio ha sido
tan fría que he sido jugar con la temperatura, mientras que los nuevos tortolitos están
durmiendo. ¿Cada uno no quiere despertar a las 7 de la mañana a una casa de 40
grados? Cuando están lejos de sus escapadas de fin de semana,
227
manubrio el calor de hasta 80 grados y volver a bajar a 40 antes de llegar a casa. Sólo puedo
imaginar lo que podrían ser sus facturas de electricidad. Me hace sonreír. Sé que esto no va a
durar para siempre, pero no puedo evitar sonreír cada vez que intento acceder y ver que
todavía funciona. Asimismo, no puede esperar a que un clima más cálido cuando puedo girar el
calor de hasta 80 grados, mientras que los tortolitos están durmiendo. Después de todo, ¿quién
no quiere despertar a un hogar de 80 grados en el medio de junio?”
Ahora concedido, que no es realmente un truco técnico - más de una experiencia de ingeniería social, pero
muestra lo que se puede hacer con estos pequeños sistemas.
Su termostato Nest (inserte su propio ejemplo IOT aquí) puede ser una puerta de entrada a su casa. En muchos
sistemas, como el termostato Nest, usted es sólo una contraseña de ser hackeado. Hace un buen argumento para una
buena contraseña en cualquier sistema que se expone a Internet.
Y recuerda que todos los dispositivos son vulnerables a ser hackeado con acceso físico. Así que asegúrese de mantener sus
llaves de metal “reales” seguro, también.
228
APÉNDICE
Sugerencias para otras actividades
El IOT es un área de investigación activa y el despliegue activo. Nadie en la industria ha encontrado aún la “aplicación
asesina” que se llevará a la IOT con el despliegue de consumo masivo, pero es sólo una cuestión de tiempo. Si se toma el
tiempo para construir los proyectos IOT en los capítulos anteriores, ahora tiene un conjunto básico de habilidades para crear
prototipos e innovar en el espacio IOT. No hay mejor forma de aprender un nuevo conjunto de habilidades que realmente
construir cosas. Ese es el lema del Movimiento Maker.
Los siguientes son algunos de los proyectos IOT que actualmente estoy trabajando. Son buenas sugerencias para seguir
trabajando por su cuenta, si usted está tan inclinado.
• OurWeather - un no-soldadura requiere el kit de la estación meteorológica IOT para mayores de 8 años
• dispositivo de Calidad del Aire IOT
• Enlaces bajos de RF de potencia para dispositivos IOT
• Sunrover - Robot con energía solar IOT conector
• SunGrassHopper - IOT pequeño robot funciona con energía solar conectado
• Nubosidad sensor que detecta IOT
• Dispositivos de construcción IOT utilizando conectores Grove para el prototipado rápido y fácil
Otra idea es que buscar en forma regular los siguientes sitios web para los nuevos dispositivos y nuevos sensores:
• www.sparkfun.com
• www.adafruit.com
• www.seeedstudio.com
• www.tinysine.com
Para los usuarios más técnicos:
• www.digkey.com
• www.mouser.com
• www.texasinstruments.com

JC Shovic, Frambuesa Pi IO Proyectos, DOI 10.1007 / 978-1-4842-1377-3
APÉNDICE ■ Sugerencias para otras actividades
Cuando veo a un nuevo sensor que es interesante, yo salto en él, construir un proyecto, y publicarla, ya sea en
revistas o en mi blog. Hay nuevos dispositivos de base IOT (como el Adafruit Hurra) que entrarán en funcionamiento todos
los días. Si usted ve uno y estás interesado, comprarlo y construir algo. Venga a visitar mi blog y unirse a la conversación en
www.switchdoc.com .
Palabras de despedida. . .
El IOT va a ser grande. ¿Qué tan grande, que nadie sabe. Las tecnologías que se están explotando en el mercado son
accesibles a la persona razonablemente técnicamente bien. Como siempre, me siento el mejor aprendizaje es por el hacer.
Si han construido los cinco proyectos en este libro, entonces usted tiene una muy buena idea de lo que está pasando con
los dispositivos en su hogar o lugar de trabajo. IOT, probablemente, no significa “Caja de Negro” para el lector más.
¿Alguna vez has oído hablar de la Ley de Metcalfe? Se dice que “el valor de una red de telecomunicaciones
es proporcional al cuadrado del número de usuarios conectados del sistema.”
Sustituto “Dispositivo IOT conectado” a “usuarios conectados” y leerlo de nuevo. El mundo está en la cúspide
de algo. Sólo podría ser más grande que el de Internet. Oh espera. Será Internet. La Internet de las cosas será
mucho mayor que la de Internet de personas conectadas.
Sigue leyendo los blogs y construir cosas. Mantenerse al día con la tecnología y el futuro no será tan
misteriosa como lo fue cuando se inició este libro.
230
Índice
ESP8266 morir, 11 cable FTDI, 156-157

UNA
diseño IOTPulse, 152 IOTRFID proyecto,
Análogo a digital 195, 199-200 diseño LightSwarm, 12, 17
(ADC), 152-154 de hackers, 213, 215, 226
programación de aplicaciones
Interfaces (APIs), 99, 150 Arduino
Mega2560, 219 de notificación automática de
paquetes
sistema (APRS), 105-107 yo
iBeacons
BlueZ, 139-141 arranque, 142 clásico
segundo
sistema distribuido, 144 panel de control,
Bluetooth de baja energía (BLE), 116, 119, 140 problema de baja 135, 137 Phue, 141 procedimiento de
de voltaje, 80 inicio, 141-142 trilateralización, 134-135
IBM bluemix
do
programa de observación meteorológica ciudadana
(CWOP) Arquitectura, 173 de autenticación, 177, 179
paquetes APRS, 105-108 arquitectura de nube, 151 de origen de datos, 181
EW7667, 108-109 La computación JSON, 176 MQTT, 175-176 conocimientos en tiempo
en nube, 149-150 Criptografía real, 179-180, 182-183 dispositivos de base IOT, 230
IOTBeaconAir
Arduino, 218-221
fidencialidad, 217
hashes criptográficos, 222-225
Frambuesa Pi, 221
BLE, 116 escáner bluetooth, 118-119 confi guración,
133 CPLPFC, 115 de hardware, 115, 121 sistema de
re
iluminación Phillips Hue, 119-120 RSSI, el software
Dynamic Host Confi guración 134
Protocolo (DHCP), 30
EFGH
ESP8266 arquitectura, 122 mapa de
Adafruit Hurra ESP8266, 12 ADC, HTML, el programa de 130-133,
152-154 124-130
© 2016 John Shovic 231

J. Shovic, Frambuesa Pi IO Proyectos, DOI 10.1007 / 978-1-4842-1377-3
■ ÍNDICE
Caracterización IOT, 188 IOT la pruebas, 205, 209-210 lista de

seguridad informática, 214 cableado, 200
la asignación de valores, 216-217 tríada
de la CIA, 215
gestión de confi guración, 226 J, K
criptografía JSON carga útil de datos, 176
Arduino, 218-221
fidencialidad, 217
hashes criptográficos, 222-225 Frambuesa L
Pi, 221 DOS / Pérdida de servidor / arquitectura LightSwarm
CPLPFC, 10 Curacao
Los perros guardianes, 225 peligros de RasPiConnect
hacking, integridad, autenticación 216, 222 componentes panel de control, 55
de seguridad, 220, 222-223, 227 de administración de ESP8266, 11-12 de hardware
actualizaciones de dispositivos IOT
cable de FTDI, 23 de bus I2C,
17-19 TCS34725, 19-20, 22
Arduino IDE, 7-8, 3-5 interfaz Wi-Fi, 17 Lista de
características de Python, cableado, 23 de software Logger
7-8, 229 proyectos IOT
IOTPulse
declaración de valor constante, 45 de bucle
ADC, 152 (), 52-53 Código RaspiConnect, 46-47 código de
APIs, 150 inicio, código del mapa web, 51-52, 48, 50
arquitectura, 154 Arduino RasPiConnect, 15 Restablecer Swarm, 56-57
IDE, 170-172 cloud autoorganización, el software 43
computing, 149 CPLPFC,
148
La impresión en 3D, 157-160
cable de FTDI, 156-157 IBM
bluemix, 151-152 IOTPulse.ino radiodifusión, 36-37
constantes, 27 loop (), 31
AllSerialHandling.h, 166 interrupt.h,
167-168, 170 setup () y loop (), 160-161 verificación del master y actualizar, código de
Nodo-RED, 185 divisor de tensión, 153 interpretación 38-43 de paquetes, 34-36 tipo de
aplicaciones Watson, 186 IOTRFID, 190 paquete, 32-33 Configuración () Función, 28-29
caciones, 25 TCS34725 tablero del desbloqueo,
12-13
instalación Arduino IDE, caso impreso

196, 197-198 3D de hardware, 196
bibliotecas, 201-202 METRO
Ley de Metcalfe, 230
mosquitto ventana de depuración, lista de partes MQTT
206-207, 195 defi nición, 189-190 edificio servidor en el
configuración de Frambuesa Pi, 207-208 Raspberry Pi
enchufe RFID Antena JST2, 200 de mesa RFID, confi guración, 193-194 flujo
199 de datos RFID, 210 de sensor, 196 datafl, 191 instalación, 192
pruebas, 194-195
software, 202-205
232
■ ÍNDICE
NO CWOP ( ver Ciudadano observador meteorológico

programa (CWOP)) funciones, 66
Nodo-RED, 185-186 dispositivos I2C, 71-76 de consumo de energía,
76-77 controlador de potencia, 68 de potencia y de
P, Q potencia abajo, 78-80 software Python, panel de

control 95-96 RasPiConnect, 97 requisitos, 86-87
Phillips Hue hub, 120 solar células, 68-69 laboratorios SwitchDoc, 104-105
sistema de iluminación Phillips Hue, 119-120 API de Twitter, 98-101 de control de potencia USB,
82-83 temporizador de vigilancia, 84 datos
R meteorológicos, mensajes de texto, 102-104

WeatherPiArduino, sensores de viento 71 / lluvia,
Identificación de frecuencia de radio 69-70 lista de cableado, 90-91
(RFID), 188-189
Frambuesa Pi
Bluez e instalación Phue, 138-141
criptografía, 221-222 IOTBeaconAir, 113 Luz
Swarm, 15
proceso de selección de modelo, 2-3 servidor

MQTT
confi guración, 193-194 ow
datafl, 191 instalación, 192 T
pruebas, 194-195 controlador de TCP. Ver control de la transmisión
potencia, 83 Frambuesa Pi 2, 2 protocolo (TCP) TCS34725, 12-13, 19-20,
protocolo de control 22 Transmisión (TCP), 26
indicador de intensidad de señal relativa

(RSSI), 134
RFID Antena JST2 Plug, 200 RSSI. Ver intensidad U, V
de señal relativa Unique er Identifi dispositivo (UDID), protocolo de
indicador (RSSI) datagrama 116 de usuario (UDP), 26
S W, X, Y
sistema de clima IOT alimentado por energía solar aplicaciones Watson, 186
arquitectura, 67 de problemas
Brownout, 80 componentes, 65
Z
conectar y pruebas, 88-90 Zigbee, 120
233

Raspberry PiIoT Projects

Cargado por

Copyright:

Formatos disponibles

Raspberry PiIoT Projects

Cargado por

Información del documento

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Raspberry PiIoT Projects

Cargado por

Copyright:

Formatos disponibles

T ECNOLOGÍA EN AC TI ON ™

Los experimentos de prototipos para Makers

John C. Shovic, PhD

(PBK): 978-1-4842-1378-0 ISBN-13 (electrónico): 978-1-4842-1377-3

Biblioteca del Congreso de control el número: 2016949468 Copyright

© 2016 por John C. Shovic

intención de infracción de la marca.

Gerente: Welmoed Spahr plomo Editor:

licencias a granel Ventas-libro electrónico en especial www.apress.com/bulk-sales .

Impreso en papel libre de ácido

Sobre el Autor ............................................... .............................. xv Sobre el revisor

técnico ............... ........................................ Agradecimientos xvii ........

.................................................. ................ xix Introducción ................................

.................................................. .. capítulos xxi de un vistazo

........................................... ......................... XXIII

■ Capítulo 1: Introducción a la IOT ............................................ ............ 1

■ Capítulo 2: Detectando Su IOT Medio Ambiente ...................................... 9

■ Capítulo 3: La construcción de una estación meteorológica accionada solar IOT ........... 63

■ Capítulo 4: El cambio de su entorno con IOT y iBeacons ... 113

■ Capítulo 5: Conexión de un dispositivo IOT a una nube

■ Capítulo 6: El uso de IOT para la RFID y MQTT y el Raspberry Pi ...... 187

■ Capítulo 7: Seguridad de ordenador y la IOT ................................. 213

■ Apéndice: Sugerencias para otras actividades ................................... 229

Índice ................................................. ............................................. 231

Sobre el Autor ............................................... .............................. xv Sobre el revisor

técnico ............... ........................................ Agradecimientos xvii ........

.................................................. ................ xix Introducción ................................

.................................................. .. capítulos xxi de un vistazo

........................................... ......................... XXIII

■ Capítulo 1: Introducción a la IOT ............................................ ............ 1

Elegir un modelo de Frambuesa Pi ............................................. ................. 2

La elección de un dispositivo IOT .............................................. ............................. 3

La caracterización de un proyecto IOT .............................................. .................... 3

Comunicaciones ................................................. .................................................. 4 ....

Procesador Power ................................................ .................................................. ..... 4

Almacenamiento local ................................................ .................................................. .......... 4

El consumo de energía ................................................ ................................................. 5

Funcionalidad ................................................. .................................................. .......... 5

Costo................................................. .................................................. ........................ 5

Las herramientas adecuadas para hacer frente a hardware ........................................... ........ 5

Escribir código en Python y el IDE Arduino .......................................... . 7

En este libro ............................................... .............................................. 8

■ Capítulo 2: Detectando Su IOT Medio Ambiente ...................................... 9

Redes de sensores IOT ............................................... ...................................... 10

IOT caracterización de este Proyecto ............................................. ......... 10

¿Cómo funciona este dispositivo se conectan a la IOT? ........................................ ... 11

¿Qué es un ESP8266? .................................................. ............................................ 11

El diseño LightSwarm ............................................... .......................................... 12

La construcción de su primer IOT Swarm ............................................. .................. dieciséis

Instalación del soporte de Arduino en el PC o Mac .......................................... ................ dieciséis

Su Primer bosquejo para la ESP8266 ............................................ .............................. dieciséis

El hardware ................................................ .................................................. ....... 17

El software ................................................ .................................................. ........ 25

Auto-organización de Comportamiento .............................................. ........................ 43

Monitoreo y probar el sistema con la Frambuesa Pi (del tipo inteligente en el Bloque)

LightSwarm software de registro escrito en Python ............................................ ....... 44

El panel de control RasPiConnect en Tiempo real ....................................... 54

Resultados ................................................. ................................................. 58

¿Qué más se puede hacer con esta arquitectura? ...................................... 61

Conclusión ................................................. ............................................ 61