Agus Kurniawan Arduino Programming With .NET and Sketch - En.es

Arduino
programación con
. NET y Croquis
Agus Kurniawan
Programación de Arduino con .NET y Croquis
Agus Kurniawan
Depok Indonesia
ISBN-13 (PBK): 978-1-4842-2658-2 ISBN-13 (electrónico): 978-1-4842-2659-9

DOI 10.1007 / 978-1-4842-2659-9
Biblioteca del Congreso de control el número: 2017936052 Copyright
© 2017 por Agus Kurniawan
Cualquier código fuente u otro material complementario al que hace referencia el autor de este libro está disponible para los lectores en
GitHub a través de la página del producto del libro, que se encuentra en www.apress.com/ 9781484226582 . Para obtener información
más detallada, por favor visite http://www.apress.com/ código fuente .
Mapa de contenidos
■ Capítulo 1: Introducción a las Juntas y el Desarrollo 1 Arduino
■ Capítulo 2: NET Interconexión y Arduino 21
■ Capítulo 3: Detección y accionar 45
■ Capítulo 4: Windows Arduino remoto 69
■ Capítulo 5: Construcción de su propio IO Uso de Arduino y NET 109
índice 165 Introducción xv

Contenido
introducción xv
■ Capítulo 1: Introducción a las Juntas y el Desarrollo 1 Arduino
Explorar la placa Arduino 1

Placas Arduino para principiantes 2 placas Arduino para usuarios avanzados 3 Arduino
para la Internet de las cosas 4 Arduino-Compatible 7
Configuración del entorno de desarrollo 9 Construir su primer proyecto:
Parpadeo 11 Programación del bosquejo 15 Programación Usando Arduino
visual Studio 15 Resumen 19
■ Capítulo 2: NET Interconexión y Arduino 21
Comunicación Arduino E / S 21
Comunicación en serie - UART 22 Cómo funciona el programa 25 Comunicación SPI 26
Cómo funciona el programa 29

TWI / Comunicación I2C 29 Cómo funciona el programa 33
El control de la placa Arduino NET 34

Cómo funciona el programa 38
La introducción de Protocolo Firmata 39 Resumen 44
■ Capítulo 3: Detección y accionar 45
Visión general de detección y accionamiento de Arduino 45 Sensor de
exploración y las instalaciones de actuación 46

Los dispositivos sensores 46 Cómo funciona el programa 52 Los dispositivos actuadores
53
Creación de una aplicación de detección de uso de red 58 Arduino

Cómo funciona el programa 60 Cómo funciona el programa 63
Creación de una aplicación de accionamiento Arduino uso de red de 65
Resumen 68
■ Capítulo 4: Windows Arduino remoto 69
La creación de Arduino Arduino para Windows remoto 70 Construcción de su
primer programa para Arduino remoto de Windows 71

alambrado 71 Programa de Arduino 72 Programa de Aplicación NET 73 Adición de una
remota de Windows Biblioteca rduino 75 Programa de Escritura NET 77 Pruebas 82

Control de Arduino E / S analógica 85
alambrado 86 Creación de un proyecto UWP 87 Programa de Arduino 87 Escribir el UWP
programa 87 Pruebas 91
Arduino remota a través del bus I2C 92

Cableado para I2C Aplicación 93 Creación de un proyecto UWP 94 Programa de
Escritura UWP 95 Pruebas 99
Windows remoto Arduino mediante tecnología Bluetooth 100

Cableado para la ERH con Bluetooth 101 El emparejamiento Arduino Bluetooth y
ordenador 102 Creación de un proyecto UWP 104 Escribir un programa de Arduino 105
Escribir un programa UWP 105 Prueba 107
resumen 107
■ Capítulo 5: Construcción de su propio IO Uso de Arduino y NET 109
Introducción a la Internet de las cosas y Arduino Arduino 109 Conexión a la
red de Internet 110

Conexión a una red cableada 110 Conexión a una red Wi-Fi 114
Acceso a Arduino través de una red de la Solicitud de NET 121

alambrado 122 la construcción de un Programa Boceto 124
La construcción de una aplicación UWP 129 Prueba 133
Ventanas Arduino remoto (MEF) a través de WiFi 134

Configurar Arduino para MEF a través de WiFi 134 la construcción de una aplicación
UWP 135 Prueba 140
La comunicación RF para Arduino 141

Configuración de XBee IEEE 802154 143 la construcción de un Programa Boceto Arduino
145 la construcción de un Programa UWP 146 pruebas 151
La construcción de una red LoRa para Arduino 152 Aplicación basada en la
ubicación para Arduino 156 Arduino y servidor de la nube 161
Nube Arduino 161
resumen 163
índice 165
Introducción
Arduino es una plataforma de desarrollo de juntas con la que podemos desarrollar una aplicación embebida con varios dispositivos
de sensores y actuadores. Arduino es un hardware basado en código abierto. Hay muchos modelos de Arduino que se pueden
utilizar para desarrollar. Este libro está diseñado para desarrolladores (especialmente para los desarrolladores de .NET) que
quieren construir programas de Arduino para fines generales o específicos.
Para los lectores

Este libro asume que pueda tener experiencia previa en programación. El libro también está escrito para alguien que
pudo haber desarrollado programas utilizando .NET y quiere desarrollar un programa integrado con la placa Arduino.
¿Cómo está organizado este libro

Este libro está diseñado con un enfoque paso a paso. Usted aprenderá cómo construir programas de Arduino utilizando
croquis y .NET, y explorar las capacidades de Arduino, como el procesamiento digital y analógica de E / S, la comunicación
serie, SPI y bus I2C.
Va a descubrir cómo NET colabora con programas de dibujo en Arduino para controlar los dispositivos de sensores y
actuadores de forma remota. Se introduce el tema Internet de los objetos (IO), incluida su aplicación. Por último, un servidor
de la nube se utiliza para conectarse a la placa Arduino.
Necesidad de software, materiales y equipo

En general, un ordenador con sistema operativo Windows. Se recomienda Windows 10 instalado. Debe instalar el
software de Arduino y Visual Studio en el ordenador.
Es necesario varios modelos de Arduino para implementar nuestra demo. Por otra parte, se debe proporcionar varios
dispositivos sensores y actuadores y varios módulos de red, tales como Wi-Fi, Bluetooh, GPS y LoRa.
CAPÍTULO 1
Introducción a las Juntas y

Desarrollo Arduino
Arduino es una de las más famosas tarjetas de desarrollo. Puede conectar dispositivos de sensores y actuadores fácilmente
en el tablero. En este capítulo se explorará cómo trabajar con el desarrollo Arduino y prepararse para una máquina de
desarrollo. Para trabajar en este capítulo, debe tener uno de los modelos de placas de Arduino para su implementación.
Este capitulo cubre los siguientes topicos:
• Explorar la placa Arduino.
• Configuración de desarrollo.
• La construcción de su primer proyecto.
• Boceto de programación.
• la programación de Arduino utilizando Visual Studio.
Explorar la placa Arduino

Arduino es una plataforma de desarrollo de juntas con la que podemos desarrollar una aplicación embebida con varios
dispositivos de sensores y actuadores. Arduino es un hardware basado en código abierto. Esto significa que podemos
desarrollar nuestra propia placa Arduino, pero no se debe utilizar el nombre Arduino porque es una marca comercial.
Actualmente las placas Arduino son producidos por Arduino LLC ( www.arduino.cc ) y Arduino SRL ( www.arduino.org ). Algunos
modelos de Arduino que son producidos por Arduino LLC y Arduino SRL son diferentes.
En general, una placa Arduino tiene varios pines I / O, que se utilizan para detectar y accionar con dispositivos externos
digital y analógica. Además, Arduino proporciona UART, SPI, y protocolos I2C. Cada modelo de Arduino tiene características
y formas únicas. Asegúrese de que usted no elige el modelo de la placa equivocada. Una de las muestras de placa Arduino
se puede ver en la figura 1-1 .
Capítulo 1 ■ Introducción a las Juntas y el desarrollo Arduino
La Figura 1-1. placa Arduino UNO R3
La ventaja de una placa Arduino es que es fácil de usar. No es necesario para soldar componentes electrónicos. Una
placa Arduino está listo para usar. Que acaba de conectar dispositivos de sensores y actuadores en la placa a través de cables
de puente.
En esta sección, exploramos diferentes de placas Arduino Arduino Arduino LLC y SRL. Cada modelo de Arduino
tiene características únicas. Para optimizar el uso de la placa Arduino, usted debe saber y entender qué tipo de modelo
de Arduino que es. Voy a presentar varios modelos basados en Arduino nivel de complejidad y variedad de uso.
Vamos a empezar a explorar las placas Arduino.
Placas Arduino para principiantes

Una placa Arduino Uno es una placa de desarrollo que recomiendo a cualquier persona que quiera aprender programación de
Arduino. Hay muchos escudos de Arduino que se adjuntan a la junta. Por otra parte, la mayoría de los tutoriales y libros utilizan
Arduino como una junta experimental. Arduino UNO ha completado protocolos de E / S, tales como digital y analógica de E / S,
SPI, UART, I2C y / TWI, para que pueda utilizar estos pines I / O para trabajar con dispositivos de sensores y actuadores.
Arduino Uno es más fácil de encontrar y comprar.
Puede revisar la placa Arduino UNO en este sitio web: https://www.arduino.cc/ es / Principal /
ArduinoBoardUno . También puede revisar la placa Arduino UNO de Arduino SRL en este sitio: http://www.arduino.org/products/board
.
2
La Figura 1-2. tablero de Arduino UNO de Arduino LLC
Placas Arduino para usuarios avanzados

En algunos casos se desea optimizar de su tarjeta de E / S o desea depurar sus programas. El Arduino MEGA 2560
placa proporciona más pins E / S (alrededor de 54 pines I / O) y avanzado MCU para acelerar su programa. Este
tablero se ejecuta en la parte superior de MCU ATmega 2560 con una memoria flash interna de 256 KB. El Arduino
MEGA 2560 junta también tiene dos UART. Puede revisar este tablero en este sitio: https://www.arduino.cc/en/Main/
ArduinoBoardMega2560 . Para Arduino MEGA 2560 de Arduino SRL, se pueden revisar en http://www.arduino.org/products/boards/
. Se puede ver la placa Arduino MEGA 2560 en la figura 1-3 .
La Figura 1-3. Arduino Mega 2560
3
La mayoría de las placas Arduino no tienen incorporado un chip de depuración, por lo que si desea depurar nuestro
programa, se debe añadir una herramienta de depuración adicional. Afortunadamente, podemos utilizar la placa Arduino CERO ( https://www.arduino.cc/en
) de Arduino LLC y la placa Arduino M0 PRO ( http://www.arduino.org/products/boards/arduinom0-pro ) de Arduino SRL, que están
soportados para la depuración sin necesidad de herramientas adicionales. Estas placas tienen depurador incrustado de Atmel
(EDBG) que se utilizará para la depuración. Le sugiero que utilizar estos modelos Arduino si tiene alguna preocupación acerca de
la depuración sin necesidad de herramientas adicionales. Una forma de placa Arduino Zero se muestra en la figura 1-4 .
La Figura 1-4. Arduino CERO
Arduino para la Internet de las cosas

Hoy en día Internet es un término común usado para describir cómo acceder a los datos desde un sitio remoto. Podemos
acceder a los datos desde cualquier dispositivo y en cualquier lugar. En el contexto de Arduino, es muy útil si nuestras tablas se
pueden conectar a Internet. Imagine que sus tableros detectan el objeto físico y luego se envían a nuestro smartphone. Esto
sucede si nuestras tablas están conectadas a Internet.
Hay muchas opciones para Arduino escudos para módulos de red para hacer que nuestras placas Arduino conectarse
a Internet. Esto significa que usted debe comprar módulos adicionales para hacer que sus juntas se conectan a Internet.
Afortunadamente, varios modelos de placas Arduino tienen un módulo de red integrado en el tablero. Exploramos algunos
modelos de placas Arduino con capacidad de conexión a Internet.
Arduino UNO WiFi es una placa Arduino UNO con un chip adicional (ESP8266). Este chip puede ser utilizado
para conectar redes WiFi existentes y también puede funcionar como un punto de acceso de nodo (AP). Arduno UNO
WiFi es fabricado por Arduino SRL. Se puede ver la forma de Arduino UNO Wi-Fi en la figura 1-5 . Para obtener más
información acerca de Arduino UNO Wi-Fi, se pueden revisar en este sitio: http://www.arduino.org/products/boards/
arduino-uno-wifi .
4
Figura 1-5. WiFi Arduino UNO
Arduino / Genuino MKR1000 es una placa de desarrollo con un escenario listo para la IO que es fabricado
por Arduino LLC. La junta se ejecuta con ATSAMW25 SoC, que consiste en SAMD21 Cortex-M0 +, módulo WiFi
WINC1500, y ECC508 CryptoAuthentication. Está diseñado para la conectividad de la IO, incluyendo el acceso al
servidor de la nube. Más información sobre Arduino / Genuino MKR1000 se puede leer en
https://www.arduino.cc/en/Main/ArduinoMKR1000 . Este tamaño de la placa, que se muestra en la figura 1-6 , es pequeño.
Figura 1-6. Arduino / Genuino MKR1000
5
La mayoría de las placas Arduino trabajan con un entorno RTOS. Arduino YUN combina MCU MCU y WiFi, que se
extiende OpenWrt Linux (llamada Linino OS). Este tablero le gusta un mini-ordenador con sistema operativo Linux. Puede
controlar Arduino MCU ATmega32u4 desde Linux. También podemos acceder a la API de Linux desde el programa de
Arduino. La placa Arduino YUN ha incorporado módulos WiFi y Ethernet para resolver sus casos de la IO. Figura 1-7 es una
forma de Arduino YUN. Puede revisar y comprar este tablero en este sitio: http://www.arduino.org/ productos / placas /
Arduino-yun .
Figura 1-7. Arduino YUN
Si usted está buscando un Arduino con capacidad de conectividad BLE, se puede considerar el uso de la placa
Arduino / Genuino 101, que se muestra en la figura 1-8 . Esta placa utiliza Intel Curie como MCU, que tiene un módulo
incorporado BLE. Puede controlar este tablero a través de Bluetooth en su teléfono inteligente, como los teléfonos
inteligentes Android y iPhone. Para más información acerca de Arduino / Genuino 101, recomiendo la lectura de este sitio
web:
https://www.arduino.cc/en/Main/ArduinoBoard101 .
6
Figura 1-8. Arduino / 101 Genuino
Arduino-Compatible
En general, el precio original placa Arduino es caro. Si tiene problemas de precios en su proceso de aprendizaje de Arduino, usted
podría comprar un tablero compatible con Arduino. Como sabemos, Arduino comparte su diseño y esquema en virtud de un
proyecto de código abierto. Esto significa que podemos construir nuestra propia placa Arduino sin usar el nombre “Arduino” para
nuestra junta. tableros Arduinocompatible por lo general son fabricados por compañías de terceros. En esta sección se pasará a
través de diversas juntas compatibles con Arduino en el mercado.
Sparkfun Redboard es una especie de tablero compatible con Arduino que es fabricada por Sparkfun. Esta placa
tiene una forma como la placa Arduino UNO y utiliza ATmega328 como MCU con instalado Optiboot (UNO) del cargador
de arranque. Para el desarrollo, podemos utilizar Arduino IDE para escribir un programa bosquejo y luego actualizar el
programa a la junta. Si usted está interesado en Sparkfun Redboard, puede comprar en https://www.sparkfun.com/
productos / 12757 . Se puede ver en la figura Sparkfun Redboard 1-9 .
Figura 1-9. Sparkfun Redboard
7
Realmente desnudo Junta Huesos (BRD) es una placa compatible con Arduino que está diseñado por dispositivo
moderno. Esta placa no proporciona un módulo de serie por lo que si se quiere desarrollar un programa de boceto, se
necesitaría una herramienta de serie, como cable de FTDI. Junta BRD se muestra en la figura 1-10 . Para más información
sobre este tablero, puede revisar y comprarlo en https://moderndevice.com/product/rbbb-kit/ .
Figura 1-10. Realmente Bare Bones Junta (BRD)
Pluma es una marca de desarrollo Arduino de Adafruit. Adafruit pluma 32u4 Adalogger es uno de los modelos de
placas de pluma. Esta placa proporciona un módulo de MicroSD para almacenar datos. Podemos desarrollar un
programa de Arduino usando Adafruit pluma 32u4 Adalogger. Para más información, puede revisar y comprar este
tablero en https: //www.adafruit. com / productos / 2795 .
Figura 1-11. Adafruit pluma 32u4 Adalogger
En la siguiente sección, vamos a configurar nuestro entorno de desarrollo en un ordenador. Vamos a utilizar la
aplicación oficial para el desarrollo Arduino.
8
Configuración del entorno de desarrollo

La ventaja de desarrollo Arduino es que es más fácil de configurar un entorno de desarrollo, ya que soporta múltiples
plataformas como Windows, Linux y Mac. En este libro, nos centramos en la plataforma Windows. También exploramos
la tecnología .NET para acceder a la placa Arduino.
Lo primero que debe preparar es instalar el software de Arduino. Dependiendo de qué tipo de
módulo Arduino, si tiene placas Arduino Arduino desde LLC, se puede descargar el software de Arduino
en https://www.arduino.cc/en/Main/Software .
De lo contrario, las placas Arduino desde SRL pueden descargar software de Arduino desde esta página:
http://www.arduino.org/downloads .
Después de descargar e instalar el software de Arduino, puede ejecutar el programa. Se puede ver la forma
de Arduino Arduino LLC en la figura 1-12 .
Figura 1-12. Arduino IDE
9
Ahora se puede conectar la placa Arduino en el ordenador. Si tiene placas Arduino basado en ATtiny
y ATMega MCU como Arduino UNO, no es necesario instalar un controlador. software de Arduino ha
instalado por usted.
Por ejemplo, adjunto mi Arduino UNO en Windows 10; Obtuve que mi placa Arduino UNO es reconocido como
COM5, que se muestra en la figura 1-13 .
Figura 1-13. Arduino UNO se reconoce en el Administrador de dispositivos en Windows 10
También es necesario Visual Studio para desarrollar una aplicación .NET, que accede a la placa Arduino. Si
usted no tiene una licencia de Visual Studio, puede descargar e instalar Visual Studio Express edición en esta URL: https://www.visualstudio.c
. Para la prueba, uso de Visual Studio 2015 con la actualización 2. Se muestra en la figura 1-14 .
10
Figura 1-14. Visual Studio 2015
Aprendemos cómo desarrollar una aplicación .NET para controlar nuestras placas Arduino en el siguiente capítulo. Asegúrate
de que tienes la herramienta Visual Studio. En la siguiente sección, tratamos de construir un programa de Arduino sencilla utilizando
el software de Arduino. Utilizamos un built-in LED en una placa Arduino.
Construir su primer proyecto: Parpadeo

Cuando puedo obtener una nueva placa Arduino, lo primero que hago es construir una aplicación sencilla: intermitente. Esta
aplicación se ejecuta al encender / apagar un LED. La mayoría de las placas Arduino tienen un LED incorporado que se adjunta en el
pin digital 13.
En esta sección, aprendemos cómo construir una aplicación Arduino para activar / desactivar el LED. Podemos utilizar una
muestra de programa de software de Arduino. Puede encontrar haciendo clic en el menú Archivo ➤
Ejemplos ➤ 01.Basic ➤ Parpadeo. Después de hacer clic, usted debe ver el programa, que se muestra en la figura 1-15 .
11
Figura 1-15. programa de abrir y cerrar el software de Arduino
En general, se debe utilizar el siguiente código:
void setup () {
// inicializar pin digital 13 como una salida. pinMode (13,
OUTPUT); }
// la función de bucle se ejecuta una y otra vez para siempre void loop () {
digitalWrite (13, HIGH); // enciende el LED (HIGH es el nivel de tensión) de retardo (1000);
// Espera un segundo
digitalWrite (13, LOW); // apagar el LED, haciendo que el voltaje BAJO
retardo (1000); // Espera un segundo
}
12
Puede ver el número 13 se sustituye por LED_BUILTIN, que se muestra en el siguiente código:
void setup () {
// inicializar pin digital 13 como una salida. pinMode
(LED_BUILTIN, OUTPUT); }
// la función de bucle se ejecuta una y otra vez para siempre void loop () {
digitalWrite (LED_BUILTIN, HIGH); // enciende el LED (HIGH es el nivel de tensión) de retardo (1000);
digitalWrite (LED_BUILTIN, LOW); // apagar el LED, haciendo que el retardo de baja tensión (1000);
}
Guardar este programa. Para compilar el programa, puede hacer clic en el icono Verificar. Antes de cargar el programa en
una placa Arduino, debe configurar el IDE. Cambia el objetivo placa Arduino haciendo clic en el menú Herramientas ➤ Junta
(Figura 1-16 ). Entonces, también es necesario para establecer un puerto serie de la placa Arduino adjunto haciendo clic en el
menú Herramientas ➤ Puerto.
Figura 1-16. Configurar objetivo bordo y el puerto
13
Después de que se ha configurado, puede compilar y cargar el programa. Haga clic en el icono Cargar. Se puede ver
comprobar y cargar los iconos en la figura 1-17 .
Figura 1-17. Compilar y cargar el programa de software de Arduino
Si tiene éxito, debería ver un built-in LED parpadea. Por ejemplo, Arduino UNO tiene un LED incorporado que
se muestra en la figura 1-18 .
Figura 1-18. LED parpadeante en Arduino UNO
14
Programación boceto
Para desarrollar una aplicación Arduino, usted debe saber la programación del bosquejo. En general, el programa Bosquejo utiliza C / C
++ sintaxis. Si usted tiene experiencia en C / C ++, debe ser capaz de escribir un programa de Arduino fácilmente.
Lo que usted debe saber es entender un modelo de programación boceto. Un programa de dibujo utiliza dos
funciones para ejecutar un programa de Arduino. El siguiente es un programa de dibujo en general.
preparar() {
// hacer algo }
lazo(){
// hacer algo }
En función de configuración (), el programa de esbozo se ejecutará una vez. Sin embargo, la función de bucle () es una función que
se ejecuta continuamente.
Si usted puede construir sus propias funciones, luego ponerlos en cualquiera de las funciones de configuración () o la función loop ().
Por ejemplo, he creado foo () y las funciones de realizar () y los ejecutaron en mi programa Boceto de la siguiente manera.
setup () {// hacer algo foo ();} loop () {// hacer

algo realizar ();} foo () {
realizar () {
También necesitamos saber algunas API en el programa del bosquejo. Le recomiendo que lea estos en el
sitio web oficial. Puede leerlo en https://www.arduino.cc/en/Reference/ Página de Inicio de Arduino LLC. Arduino
SRL ofrece la web de referencia en http: // www. arduino.org/learning/reference .
Programación de Arduino con Visual Studio

Si amas Visual Studio como herramienta de desarrollo, puede utilizar esta herramienta para desarrollar un programa de Arduino.
Podemos utilizar Visual Micro como una herramienta de complemento para Visual Studio. Puede descargarlo en http://www.visualmicro.com
. Una vez instalado, debería ver nuevas plantillas de proyecto, que se muestran en la figura 1-19 . Para trabajar con Visual Micro,
todavía se necesita instalar software de Arduino.
15
Figura 1-19. plantilla de proyecto Arduino en Visual Studio 2015
Ahora usted puede traer su programa Boceto en Visual Studio. Puede escribir programa Boceto en Visual
Studio. Por ejemplo, podemos escribir programa Bosquejo seleccionando Blink Led Ejemplo de Visual C ++ ➤ Visual
Micro.
Después de que se ha seleccionado, podemos ver un programa Boceto parpadeando en el editor de Visual Studio (véase la
figura 1-20 ). Usted debe encontrar xxx.ino archivo donde xxx es un archivo del bosquejo.
dieciséis
La figura 1-20. Boceto programa en Visual Studio 2015 editor
Antes de construir y enviar boceto, se debe configurar un destino placa Arduino. Debería ver una lista de
modelo de la placa Arduino. Se puede ver en la figura 1-21 . Seleccione el modelo de placa Arduino de la lista.
Figura 1-21. Seleccionar modelo de la placa Arduino para el objetivo bordo
17
También es necesario configurar un puerto serie para Arduino. Se puede ver su configuración en un menú que se muestra en la
figura 1-22 . Construir y menús de carga también se pueden encontrar en esa barra de herramientas.
Figura 1-22. Menú de selección de puerto serie, la construcción, y la carga
Guarde su dibujo. A continuación, tratar de construir y cargar el programa. El programa se ejecutará en una placa Arduino.
Depurador de Visual Studio también se ejecuta. Se puede ver en la figura 1-23 .
Figura 1-23. Correr y depurar boceto Arduino en Visual Studio
18
Resumen
Hemos explorado diversos modelos de Arduino y trató de construir un programa de Arduino sencilla utilizando el software de
Arduino. También construimos un programa de Arduino utilizando Visual Studio y luego desplegado en una placa Arduino.
Ahora puede practicar el desarrollo de programas de Arduino con el boceto. En el siguiente capítulo, construimos un
programa de interfaz para la comunicación entre una aplicación .NET y la placa Arduino.
19
CAPITULO 2
Interfaz .NET y Arduino
. NET es una tecnología completa para resolver sus casos de negocio, incluyendo la programación de hardware. En este
capítulo, vamos a aprender a controlar las placas Arduino desde una aplicación .NET. Varios modelos de comunicación
Arduino I / O se introducen, por lo que nuestra aplicación .NET pueden controlar la placa Arduino. El último tema es aprender
protocolo Firmata, uno de los protocolos para la comunicación entre una placa Arduino y un ordenador.
• Comunicación Arduino E / S
• El control de Arduino de .NET
• Introducción al protocolo Firmata
Comunicación Arduino E / S
placas Arduino suelen proporcionar pines I / O por lo que atribuimos a nuestros dispositivos sensores o actuadores en el tablero. Cada
placa Arduino tiene un diseño de E / S por lo que debe comprobar que funciona. Por ejemplo, Arduino UNO puede ser descrito para la
disposición de I / O, como se muestra en la figura 2-1 . Esta disposición se ha tomado de la página web PigHixxx, http://www.pighixxx.com/test/portfolio-ite
.
Capitulo 2 ■ La interfaz .NET y Arduino
La Figura 2-1. Arduino Uno de E / S de diseño
Para acceder a un recurso externo de Arduino de E / S, hay que tratar con formato de protocolo. En general,
las placas Arduino tienen los tres modelos de comunicación siguientes:
• comunicación serial
• la comunicación SPI
• TWI / comunicación I2C
Utilizamos estos modelos de comunicación para comunicarse con una aplicación .NET. Cada comunicación se
explicará en la siguiente sección. Esbozo se utiliza para describir cómo éstos E / S trabajo de comunicación.
¡Vamos a explorar!
Comunicación en serie - UART

comunicación en serie a veces se llama UART (Universal Asynchronous Receiver Transmitter) -es un viejo modelo de
comunicación. En el método de comunicación en serie, enviamos un bit a la vez, de forma secuencial, por un canal de
comunicación. Si usted tiene 32 bits de datos, los datos se envíe una por un bit. Una velocidad de envío está en función de una
velocidad de datos en serie, llamada velocidad de transmisión.
La mayoría de las placas Arduino tienen capacidad de comunicación serie a través de pines UART. Por ejemplo, la placa
Arduino UNO tiene pines UART en el pin digital de 0 y 1.
22
En el programa del bosquejo, podemos utilizar la biblioteca de serie ( https://www.arduino.cc/en/ Referencia /

Serial ) para comunicarse pines UART en la placa Arduino. Serial.print funciones () y Serial.read () se utilizan para
escribir y leer datos de Arduino UART.
Para la prueba, construimos un croquis para escribir datos en Arduino UART. Solía Arduino UNO. Este programa va a escribir
datos en el puerto serie de Arduino. Para la prueba, se escribe los números secuenciales en un puerto serie. Entonces, escuchamos
los mensajes entrantes de puerto serie con el Monitor de serie, una herramienta de software de Arduino.
Ahora se puede abrir Arduino IDE y escribir el código siguiente.
int LED = 13; int val

= 10; void setup () {
pinMode (LED, OUTPUT);

Serial.begin (9600); }
void loop () {
digitalWrite (LED, HIGH);
Serial.print ( "val =");
Serial.println (val); retardo
(1000);
digitalWrite (led, LOW); val ++;

si (val> 50) val = 10; }
Voy a explicar cómo funciona este bosquejo después de este paso siguiente. Guardar este programa como
“SerialDemo.”
Compilar y cargar boceto en una placa Arduino. Para ver la salida del programa de E / S serie, podemos usar un monitor de serie.
Esta herramienta está disponible en el software de Arduino. Simplemente haga clic en el menú Herramientas ➤ Serial Monitor. Ver figura 2-2 .
23
La Figura 2-2. herramienta Monitor de serie abierta sobre Arduino IDE
Después de abrir la herramienta Monitor de serie, debería ver un cuadro de diálogo, que se muestra en la figura 2-3 .
Cambiar la velocidad en baudios a 9600 porque nuestro programa utiliza velocidad de transmisión 9600 para comunicarse con Arduino serie.
24
La Figura 2-3. La salida del programa en la herramienta Monitor de serie
Usted debe ver “Value = xx.” Xx es un número secuencial que se genera a partir de nuestro programa de Dibujo.
Cómo funciona el programa

Ahora voy a explicar cómo funciona el programa anterior. En primer lugar, inicializamos nuestro puerto serie con velocidad de transmisión
9600. También utilizamos un sistema incorporado en LED en el pin 13. Esto sucede en preparar() función.
int LED = 13; int val

= 10; void setup () {
pinMode (LED, OUTPUT);

Entonces, enviamos el mensaje “value = xx” de salida en serie. xx es un número secuencial a partir de 10 a 50.
Llevamos a cabo en lazo() función. Para escribir datos en serie de salida, que llamamos Serial.print () y Serial.println () funciones.
void loop () {
digitalWrite (LED, HIGH);
Serial.print ( "val =");
Serial.println (val); retardo
(1000);
25
digitalWrite (led, LOW); val ++;

si (val> 50) val = 10; }
Se trata de un programa sencillo. Sin embargo, se puede hacer más práctica usando la biblioteca de serie del programa de
bosquejo. Por ejemplo, se envían datos de sensores tales como la temperatura y la humedad al puerto serie.
Comunicación SPI
Desde UART no utiliza un reloj para controlar el transmisor y el receptor, los mensajes pueden tener problemas en la
comunicación. Tenemos un problema en la UART cuando queremos conectar más dispositivos al bus UART. protocolo SPI está
diseñado para trabajar con varios dispositivos de bus serie.
Serial Peripheral Interface (SPI) utiliza maestro y esclavo de reloj para determinar qué dispositivo se comunicará. SPI
por lo general se lleva a cabo en tres pines: SCK para el reloj, MOSI para la salida principal Slave In, y MISO para Master en
Slave Out. SS (Slave Select) señales se utilizan para el maestro para controlar muchos dispositivos esclavos. La placa Arduino
UNO, por ejemplo, tiene pasadores de SPI en 10 (SS), 11 (MOSI), 12 (MISO), y 13 (SCK).
Hay muchas opciones para los dispositivos de sensores y actuadores que utilizan el protocolo SPI. Por
ejemplo, Sparkfun Triple acelerómetro del eje del desbloqueo de Sparkfun ( https: //
www.sparkfun.com/products/11446 ). Esta ruptura utiliza IC ADXL362 para gestionar el sensor acelerómetro. Esto se
puede ver en la figura ruptura 2-4 .
La Figura 2-4. Sparkfun Triple acelerómetro del eje del desbloqueo de Sparkfun
Para probar nuestra Arduino con el protocolo SPI, podemos conectar MOSI y MISO pines utilizando un cable de puente. Nos
conectamos pin digital 11 al pin digital 12, como se muestra en la figura 2-5 .
26
La Figura 2-5. Pasadores de conexión miso y MISO
Ahora empezamos a construir el programa de Arduino. En este caso, enviamos datos a través de SPI y esperar a que los
datos entrantes de SPI. Este programa es un bucle de retorno SPI en la que están conectados de entrada y salida pasadores SPI.
Podemos utilizar la librería SPI ( https://www.arduino.cc/en/ Referencia / SPI ) para acceder al protocolo SPI. En la librería SPI,
podemos utilizar SPI.transfer ()
función para enviar y recibir datos. El programa enviará números aleatorios para SPI. Abrir Arduino IDE y escribir
el siguiente código.
# incluir <SPI.h>
byte sendData, recvData; void

setup () {SPI.begin ();
Serial.begin (9600);
// fuente:
// http://forum.arduino.cc/index.php?topic=197633.0 randomDigit byte ()
{
unsigned long t = micros (); byte r = (t% 10)
+ 1; para (byte i = 1; i <= 4; i ++) {t / = 10;
r * = ((% 10 t) + 1);
27
r% = 11; }
de retorno (r - 1); }
void loop () {
sendData = randomDigit ();
recvData = SPI.transfer (sendData);
Serial.print ( "Enviar ="); Serial.println

(sendData, DEC); Serial.print ( "Recv =");
Serial.println (recvData, DEC); retardo
(800); }
Guardar este bosquejo como “SPIDemo.”
Ahora puede compilar y cargar el programa Boceto en Arduino UNO. Abra una herramienta Monitor de serie para ver la
salida del programa. No se olvide de cambiar la velocidad en baudios a 9600. Una muestra del programa puede verse en la
figura 2-6 .
La Figura 2-6. La salida del programa programa de SPI Boceto para
28

Para acceder a la biblioteca de SPI, que llamamos SPI.begin () en función de preparar() función. Para trabajar con la librería SPI, es
necesario incluir el archivo de cabecera SPI.h en su programa. En general, este archivo de cabecera ya está instalado en el software
de Arduino.
# incluir <SPI.h>
byte sendData, recvData; void

setup () {SPI.begin ();
En función de bucle (), llevamos a cabo para enviar un número aleatorio a través de SPI. Este número aleatorio se
genera llamando randomDigit () función. Podemos utilizar el SPI.transfer ()
funcionar para enviar y recuperar datos en el bus SPI. Por último, mostramos los datos que se envían y se reciben en el puerto serie para
que podamos controlarlo a través de herramienta Monitor de serie.
void loop () {
sendData = randomDigit (); recvData =
SPI.transfer (sendData);
Serial.print ( "Enviar ="); Serial.println

(sendData, DEC); Serial.print ( "Recv =");
Serial.println (recvData, DEC); retardo
(800); }
Usted ha aprendido cómo acceder a SPI por aplicación de un marco de bucle invertido SPI. Si desea obtener práctica más
avanzada, le recomiendo que utilice dispositivos sensores o actuadores basados en el protocolo SPI. Por favor, recuerde que
cada dispositivo sensor / actuador tiene comandos específicos más de SPI para interactuar con la placa Arduino. Usted debe
comprobar en sus documentos de hoja de datos.
TWI / Comunicación I2C

Como sabemos, el protocolo SPI necesita cuatro pines para comunicarse entre dispositivos. Esto es un inconveniente en el
protocolo SPI. SPI sólo permite un maestro en el bus con múltiples dispositivos esclavos. Por otro lado, I2C (Inter-Integrated
Circuit) / TWI (Two-Wire Interface) es también un protocolo síncrono que necesita dos pines para comunicarse entre
dispositivos. protocolo I2C tiene dispositivos con varios maestros que hablan a dispositivos multi-esclavo.
protocolos I2C tienen dos alambres: SDA y SCL. placas Arduino por lo general tienen un bus I2C. Por ejemplo, la placa
Arduino UNO tiene I2C en los pines A4 (SDA) y A5 (SCL). Por favor, compruebe su modelo de Arduino para ver la asignación de
pines I2C. Podemos acceder I2C utilizando la librería Wire ( https: // www.arduino.cc/en/Reference/Wire ).
29
Hay muchos dispositivos que utilizan I2C que se une a la placa Arduino. Un dispositivo sensor I2C es Sparkfun
Humedad y del sensor de temperatura del desbloqueo de Sparkfun ( https://www.sparkfun.com/products/13763 ). Esta
ruptura utiliza IC Si7021 para detectar la humedad y la temperatura. Los datos de sensor se pueden acceder usando el
protocolo I2C. Esto se puede ver en la figura ruptura 2-7 .
Figura 2-7. Sparkfun Humedad y del desbloqueo del sensor de temperatura de Sparkfun
Otro módulo es el módulo PCF8591 AD / DA. No es un módulo caro. Lo puede encontrar en http://www.electrodragon.com/prod
. EBay y sitios web chinos también venden este módulo. La ventaja de este módulo es que el módulo
proporciona tres entradas de muestra: termistor, fotocélula, y el potenciómetro. Figura 2-8 es una forma del
módulo PCF8591 AD / DA. En este caso, lo uso para la prueba de I2C en una placa Arduino UNO.
La Figura 2-8. PCF8591 AD módulo / DA
30
Para una demostración de I2C en una placa Arduino, se utiliza un módulo de PCF8591 AD / DA. Vamos a acceder termistor,
fotocélula, y el potenciómetro a través del protocolo I2C mediante el programa de Dibujo.
Para la implementación de cableado, puede conectar el módulo PCF8591 AD / DA a una placa Arduino UNO de la
siguiente manera:
• Conecte el pin SDA a Arduino pin SDA (A4).
• Conecte el pin SCL a Arduino pin SCL (A5).
• Conecte el pin GND a GND Arduino.
• Conecte el pin VCC a Arduino VCC 3.3V. Usted puede
ver mi cableado en la figura 2-9 .
Figura 2-9. Cableado PCF8591 AD módulo / DA y Arduino UNO
Podemos utilizar la librería Wire para acceder al bus I2C. El módulo PCF8591 AD / DA se ejecuta en la dirección
(0x90 >> 1) o 0x48. Pasamos esta dirección a la librería Wire. Sobre la base de un documento desde el módulo de
PCF8591 AD / DA, termistor se ejecuta en 0x00 canal, la fotocélula en 0x01, y el potenciómetro en 0x03.
Ahora abre Arduino IDE y escribir este código:
# incluir "Wire.h"
# definir PCF8591 (0x90 >> 1) // dirección de bus I2C
# definir PCF8591_ADC_CH0 0x00 // termistor
# definir PCF8591_ADC_CH1 0x01 // célula fotovoltaica
# definir PCF8591_ADC_CH2 0x02
# definir PCF8591_ADC_CH3 0x03 // potenciómetro bytes ADC1,
ADC2, ADC3;
31
void setup () {
Wire.begin ();
void loop () {
// leer termistor
Wire.beginTransmission (PCF8591); Wire.write
(PCF8591_ADC_CH0); Wire.endTransmission
(); Wire.requestFrom (PCF8591, 2); ADC1 =
Wire.read (); ADC1 = Wire.read ();
Serial.print ( "termistor ="); Serial.println

(ADC1);
// leer Wire.beginTransmission célula

fotovoltaica (PCF8591); Wire.write
Serial.print ( "Photo-voltaica celular =");

Serial.println (ADC2);
// potenciómetro
Serial.print ( "potenciómetro =");

Serial.println (ADC3);
retardo (500); }
Guardar este bosquejo como “I2CSensor.”
Compilar y cargar el programa en la placa Arduino. Se puede ver la salida utilizando la herramienta Monitor de
serie. Un ejemplo del resultado se puede ver en la figura 2-10 .
32
Figura 2-10. La salida del programa para el programa Boceto I2C

El programa requiere una biblioteca de alambre, por lo que debe incluir un archivo de cabecera Wire.h en nuestro programa de
Dibujo. También declaramos direcciones I2C y comandos para el módulo PCF8591 AD / DA.
# incluir "Wire.h"
# definir PCF8591 (0x90 >> 1) // dirección de bus I2C
# definir PCF8591_ADC_CH0 0x00 // termistor
# definir PCF8591_ADC_CH1 0x01 // célula fotovoltaica
# definir PCF8591_ADC_CH2 0x02
# definir PCF8591_ADC_CH3 0x03 // potenciómetro bytes ADC1,
ADC2, ADC3;
Activamos nuestra librería Wire en preparar() llamando a la función Wire.begin () función. También es necesario para
activar la biblioteca de serie con el fin de enviar un resultado de lectura I2C llamando Serial.begin () función.
void setup () {
Wire.begin (); Serial.begin

(9600); }
Para leer los datos desde el módulo del termistor PCF8591 AD / DA, se envía el modo de canal, 0x00, en PCF8591 AD
dirección I2C / DA. Entonces, usted debe leer dos bytes para obtener datos del termistor.
33

Serial.print ( "termistor ="); Serial.println

(ADC1);
Llevamos a cabo la misma tarea de leer la fotocélula, y el potenciómetro de PCF8591 AD / DA I2C. Usted sólo tiene que
pasar los valores PCF8591_ADC_CH1 y PCF8591_ADC_CH3 al módulo. A continuación, esperar a que entrantes dos bytes desde
PCF8591 AD / DA.
Ahora que hemos aprendido a trabajar con Arduino comunicación de E / S, vamos a seguir para controlar
la placa Arduino desde nuestra aplicación .NET.
El control de la placa Arduino .NET

Hemos aprendido varias juntas las comunicaciones utilizando la programación de Arduino Boceto I /. Ahora continuamos acceder a
la Arduino E / S desde una aplicación .NET.
En esta sección, te muestro una simple comunicación entre una aplicación .NET y Arduino. Yo uso la comunicación
serie. Como sabemos, una placa Arduino puede conectarse a un ordenador a través de USB de serie. Utilizamos esta
función en nuestro programa. La idea es enviar un comando para Arduino para hacer algo a través del protocolo de
comunicación en serie.
Para la prueba, construimos una aplicación .NET para controlar tres LEDs. Enviamos comandos enviando el mensaje “1”
para activar el LED 1, “2” para activar el LED 2, y “3” para encender el LED 3 mediante la comunicación serie. En .NET, podemos
utilizar un objeto SerialPort acceder a la serie E / S o UART. En primer lugar, conecte tres LEDs en la placa Arduino. El siguiente es
nuestro cableado:
• Conectar LED 1 a pin digital 12.
• Conectar todos los otros pines LED (pin GND) al pin GND. Esto se puede
ver en la figura cableado 2-11 .
34
Figura 2-11. Cableado para el programa de control de LED
Para que nuestro Arduino para entender nuestros comandos desde una aplicación .NET, debemos utilizar un programa
Boceto para recibir comandos desde una aplicación .NET. Escribir el programa en Arduino IDE de la siguiente manera:
int LED1 = 12; int

LED2 = 11; int
LED3 = 10;
void setup () {
pinMode (LED1, OUTPUT);
35
void loop () {
si (Serial.available ()> 0) {
Char datosEntrada = Serial.read (); si

(datosEntrada == '1') {
digitalWrite (LED1, HIGH);
digitalWrite (LED2, LOW);
digitalWrite (LED3, LOW); }
si (datosEntrada == '2') {digitalWrite

(LED1, LOW); digitalWrite (LED2,
HIGH); digitalWrite (LED3, LOW); }
si (datosEntrada == '3') {digitalWrite

(LED1, LOW); digitalWrite (LED2,
LOW); digitalWrite (LED3, HIGH); }
Este programa va a escuchar los mensajes entrantes de puerto serie de lazo() función. Si recibimos datos “1”, que
encendemos LED 1. De lo contrario, si obtenemos datos “2” o “3” en el puerto serie de Arduino, encendemos LED 2 o LED
3.
Guardar este programa como “ledcontrol”. Después de eso, puede compilar y cargar el programa Boceto en la
placa Arduino.
El siguiente paso es escribir una aplicación .NET utilizando Visual Studio. Crear un proyecto de aplicación de consola de
Visual Studio. En el archivo Program.cs, escribimos un programa para acceder al puerto serie y enviar el mensaje de “1”, “2” y
“3”. Estas entradas provienen del usuario. Utilizando Console.ReadLine (), podemos obtener datos de entrada de la terminal. A
continuación, enviarlo al puerto de serie. Escribir este programa:
using System;
usando System.Collections.Generic; usando
System.Linq; usando System.Text;
usando System.Threading.Tasks; usando

System.IO.Ports;
DotnetBlinking espacio de nombres {
Programa de la clase {
bool funcionamiento estático = true;
36
static void main (String [] args) {
tratar
SerialPort SerialPort = new SerialPort ( "COM5");

serialPort.BaudRate = 9,600;
Console.CancelKeyPress + = delegado (remitente del objeto,

ConsoleCancelEventArgs e) {
e.Cancel = true;
corriendo = false; };
serialPort.Open ();
Console.WriteLine ( "Press 1, 2, 3 para encender el LED 1, 2, 3 y presiona
ENTRAR");
Console.WriteLine ( "Presione CTRL + C para salir"); mientras
corre) {
Console.Write ( ">>"); datos de cadena =

Console.ReadLine (); if (! String.IsNullOrEmpty
(datos)) {
serialPort.Write (datos);
Console.WriteLine ( "Enviado a Arduino: {0}", los datos); }}
serialPort.Close (); }
captura (err Excepción) {
Console.WriteLine (err); }
Console.WriteLine ( "Programa de salida Presione ENTRAR para cerrar.");

Console.ReadLine (); }}}
Guardar este programa. Ejecutar este programa desde Visual Studio. Por favor cambia su puerto de Arduino antes de ejecutar el
programa. Usted debe obtener un terminal. Trata de llenar “1” para activar el LED 1 o “2” para activar el LED 2. Una muestra de la salida
del programa se puede ver en la figura 2-12 . Si se tienen problemas debido a la seguridad, es probable que pueda ejecutar este programa
a nivel de administrador.
37
Figura 2-12. La salida del programa de aplicación de control LED

¿Cómo funciona esta aplicación .NET? La idea de la aplicación es un enfoque simple. Abrimos un puerto serie de
Arduino. Entonces, la aplicación está esperando datos de entrada del usuario.
Console.CancelKeyPress + = delegado (remitente del objeto, ConsoleCancelEventArgs e) {
e.Cancel = true;
serialPort.Open ();
Una vez que se reciben los datos, la aplicación pasa a un puerto serie utilizando Puerto serial. Escribir() método.
Ejecutamos el bucle infinito utilizando mientras() sintaxis. Este bucle se detendrá si el usuario presiona las teclas CTRL + C, que
nuestro programa está escuchando a través de una
Console.CancelKeyPress evento.
mientras corre) {
Console.Write ( ">>");
datos de cadena = Console.ReadLine (); if (!
String.IsNullOrEmpty (datos)) {
serialPort.Write (datos);
Console.WriteLine ( "Enviado a Arduino: {0}", los datos); }}
38
Así es como funciona nuestra aplicación. Es probable que pueda realizar experimentos mediante la aplicación de Windows
Forms. Por favor, recuerde el acceso bloqueado, ya que nuestra aplicación .NET intenta realizar el bloqueo en la espera de la entrada
del usuario.
La introducción de Protocolo Firmata

Firmata es un protocolo para la comunicación con microcontroladores de software en un ordenador.
Básicamente, hemos puesto en marcha el mismo enfoque en el apartado anterior. Sin embargo, el protocolo
Firmata proporciona un modelo más general para la comunicación entre la placa Arduino y el ordenador. Para
más información sobre el protocolo Firmata, te sugiero leer esta página web: https://github.com/firmata/protocol .
Con el fin de Arduino para entender nuestros comandos del ordenador, hay que ejecutar el programa Firmata
en las placas Arduino. Puede encontrar este programa en Arduino IDE, haciendo clic en el menú Archivo ➤ Ejemplos ➤
firmata ➤ StandardFirmata.
Figura 2-13. Añadiendo programa Firmata Sketh
39
Después se hace clic, se puede ver el programa Boceto para Firmata en Arduino IDE. Se puede ver en la figura 2-14
. Puede configurar el destino de Arduino y su puerto antes de parpadear a la placa Arduino. Si se hace boceto parpadea,
la placa Arduino está listo para recibir órdenes a través del protocolo Firmata.
Figura 2-14. programa de esbozo para el estándar Firmata
Para acceder a Arduino a través del protocolo Firmata, debemos enviar comandos basadas en el protocolo Firmata. Sin
embargo, podemos utilizar varias bibliotecas de cliente FIRMATA, que la gente de la comunidad crearon. Se puede comprobar en https://github.com/firmat
. Debido a que utilizamos .NET para comunicarse con una placa Arduino, utilizamos un cliente Firmata para una plataforma .NET.
40
Yo uso para el cliente SolidSoils4Arduino Firmata en .NET. Esta biblioteca es compatible con estándar
Firmata 2.4. Descargar esta biblioteca https://github.com/SolidSoils/ Arduino . A continuación, abrirlo con Visual
Studio y compilar el proyecto con su actual
. NET Framework. Una lista de proyectos de SolidSoils4Arduino puede verse en la figura 2-15 .
Figura 2-15. solución de proyecto desde SolidArduino
Después de que se compila, se puede obtener un archivo DLL * en un proyecto Solid.Arduino. Será utilizado en nuestro
proyecto. Este escenario se puede implementar si se separa la aplicación o probablemente cambia la versión .NET con un objetivo
específico. De lo contrario, puede añadir este proyecto en su proyecto de aplicación .NET mediante la adición de una referencia de
proyecto.
En este escenario, construimos una aplicación de consola para reducir una interfaz gráfica de usuario de la complejidad
. NET. Ahora cree un nuevo proyecto en Visual Studio. Seleccione “Aplicación de consola” para el tipo de proyecto. Por
ejemplo, mi nombre del proyecto es “FirmataApp”, que se muestra en la figura 2-16 .
41
Figura 2-16. Añadir SolidSoils4Arduino (SolidArduino.dll) en nuestro proyecto
Además, añadimos un proyecto de biblioteca Solid.Arduino en su proyecto. Puedes añadir a través del Administrador de
referencia.
En este escenario, se utiliza el mismo cableado de la sección anterior. Utilizamos tres LEDs y tratar de
controlar estos LEDs de .NET.
Después de crear un proyecto en Visual Studio, puede modificar Program.cs. En primer lugar, creamos una
instancia nuestra SerialConnection y ArduinoSession objeto. Cambiar el puerto Arduino función de la configuración.
Para acceder a la salida digital en Arduino, establecemos el modo digital, utilizando el pin
SetDigitalPinMode () método. Podemos encender / apagar el LED mediante el SetDigitalPin ()
método.
Para una demostración, construimos una aplicación para encender / apagar tres LEDs de forma secuencial. Ahora escriba los
siguientes códigos en un archivo Program.cs:
using System;
usando System.Threading;
usando Solid.Arduino;
usando Solid.Arduino.Firmata;
FirmataApp espacio de nombres {
bool funcionamiento estático = true; static

void main (String [] args) {
tratar
42
conexión var = new SerialConnection ( "COM5",

SerialBaudRate.Bps_57600);
sesión var = new ArduinoSession (conexión, timeout: 250);

e.Cancel = true;
IFirmataProtocol firmata = (IFirmataProtocol) de sesiones;
int LED1 = 12; int

LED2 = 11; int
LED3 = 10;
firmata.SetDigitalPinMode (LED1, PinMode.DigitalOutput);

mientras corre) {
// llevado 1
Console.WriteLine ( "Activar el LED 1");
firmata.SetDigitalPin (LED1, true);
firmata.SetDigitalPin (LED2, false);
firmata.SetDigitalPin (LED3, false); Thread.Sleep
(1000); // dormir
// llevado 2
Console.WriteLine ( "Activar el LED 2");
firmata.SetDigitalPin (LED2, true);
firmata.SetDigitalPin (LED3, false); Thread.Sleep
(1000);
// llevado 3
Console.WriteLine ( "Activar LED 3");
firmata.SetDigitalPin (LED3, true); Thread.Sleep
(1000); }
// apagar LEDs
Connection.close (); }
43
Console.WriteLine (err);
}
Console.ReadLine ();
}}}
Guardar el programa. A continuación, ejecute el programa. Debería ver tres LEDs parpadeantes. En la terminal, también se puede
ver los mensajes, que se muestra en la figura 2-17 como muestra.
Figura 2-17. La salida del programa para el control de LEDs de aplicación .NET
Usted puede construir su propia aplicación .NET con un problema específico para el control de la placa Arduino a través del
protocolo Firmata. Puede utilizar la biblioteca SolidSoils4Arduino para controlar la placa Arduino a través del protocolo Firmata. Por
ejemplo, se envía un comando a la placa Arduino para abrir una puerta después de una aplicación .NET recibe una orden de los
mensajes. Por otra parte, se puede construir un Windows Forms y una aplicación de WPF para comunicarse con la placa Arduino.
Resumen
Hemos aprendido varias comunicaciones Arduino de E / S y tratamos de construir programas de croquis para acceder a ellos.
Por otra parte, hemos aprendido cómo controlar Arduino desde una aplicación .NET. Esta aplicación envía un comando
específico a través de la comunicación Arduino Arduino E / S. En la última sección, continuamos a utilizar un protocolo Firmata,
uno de los protocolos de comunicación de Arduino de la aplicación, para controlar nuestra Arduino de la aplicación .NET. En el
siguiente capítulo, vamos a aprender a sentir y actuar sobre la placa Arduino.
44
CAPÍTULO 3
Detección y accionamiento
Al sentir y accionar son actividades comunes en un sistema de control integrado. Estos implican dispositivos externos, como
sensores y actuadores. En este capítulo, aprendemos varios dispositivos de sensores y actuadores en placas Arduino
utilizando un programa de bosquejo y luego se van a utilizar por una aplicación .NET.
• Descripción general de la detección y de accionamiento en Arduino
• Exploración de dispositivos de sensores y actuadores
• Creación de una aplicación de detección de Arduino utilizando .NET
• Creación de una aplicación de accionamiento Arduino utilizando .NET
Visión general de detección y accionamiento en Arduino

Sensing es un proceso de conversión de objeto físico a los datos digitales. Por ejemplo, la detección de la temperatura. Un
dispositivo de sensor puede detectar su temperatura ambiente y luego se convertir a forma digital. De accionamiento es un
proceso en el que una MCU envía datos digitales a un dispositivo accionador para realizar algo, tal como un LED y el motor.
Figura 3-1 muestra el proceso de ambos. Para capturar y convertir objeto físico a forma digital, Arduino utiliza dispositivos
sensores tales como una cámara para medir la temperatura y la humedad. Después de obtener la forma digital de un objeto
físico, podemos realizar un cálculo basado en su escenario. Por otro lado, si usted quiere hacer Arduino hacer algo, se puede
realizar un proceso de accionamiento mediante dispositivos de accionamiento tal como un motor servo y un módulo de relé.
La Figura 3-1. Al sentir y accionar en la placa Arduino

Capítulo 3 ■ Detección y accionamiento
Arduino es una placa de desarrollo que está diseñado para ser conectado al sensor y dispositivos de accionamiento a
través de sus pines de E / S o módulo escudo Arduino. Estos dispositivos externos, que están conectados a una placa Arduino,
se puede acceder a través de protocolos de E / S que ya hemos aprendido en el capítulo anterior.
Arduino puede detectar y accionar simultáneamente. Por ejemplo, Arduino detecta la temperatura y la humedad. Si el
resultado de la medición se consigue de un cierto umbral, Arduino puede realizar algo a través de dispositivos de
accionamiento, tales como el encendido de un módulo de relé o un servomotor.
En la siguiente sección, se exploran los dispositivos de sensores y actuadores como ejemplo, por lo que utilizar dichos dispositivos en
nuestra demo.
Exploración de sensores y dispositivos actuadores

En esta sección, revisaremos varios sensores y actuadores y luego ver cómo usarlos de una placa Arduino usando
Boceto. Estos dispositivos se pueden unir a una placa Arduino, pero algunos de estos dispositivos necesitan un
tratamiento adicional tal como los códigos de comando, longitud de datos, y la máxima tensión, con el fin de Arduino para
comunicarse con estos dispositivos. Usted debe verificar su ficha técnica del fabricante.
Los dispositivos sensores
Los dispositivos sensores generalmente convertir de objetos físicos a forma digital. Hay muchos dispositivos sensores cuyas
características de detección puede integrar con la placa Arduino. Una muestra de una lista dispositivo sensor se encuentra en el sitio
web de Sparkfun, en su tienda de electrónica en línea:
https://www.sparkfun.com/categories/23 .
En general, cada dispositivo de sensor tiene una característica para detectar el objeto físico, por ejemplo,
aceleración, temperatura, y humedad. Sin embargo, algunos dispositivos sensores tienen más de una función de
detección, por ejemplo, el módulo de DHT22 ( https: // www.adafruit.com/products/385 de Adafruit, y https://www.sparkfun.com/
productos / 10167 de Sparkfun). Este módulo sensor puede detectar la temperatura y la humedad en un único módulo.
Este módulo es fácil de utilizar con la placa Arduino. Se puede ver una forma de módulo DHT22 en la figura 3-2 .
46
La Figura 3-2. módulo de DHT22
Otro dispositivo sensor es Sparkfun Electret Micrófono Breakout de Sparkfun ( https://www.sparkfun.com/products/12758

). Este módulo puede convertir el sonido a la forma analógica. Podemos conectar este sensor para Arduino pines
analógicos. Se puede ver un Sparkfun Micrófono Electret Breakout en la figura 3-3 .
Figura 3-3. Sparkfun Micrófono Electret Breakout de Sparkfun
En la siguiente sección, vamos a construir un programa de Arduino para que pueda entender cómo Arduino sentidos a través
de dispositivos sensores.
47
El acceso y la Prueba del sensor

Para entender cómo trabajar con detección de Arduino, vamos a construir un simple programa Boceto para acceder a un dispositivo
sensor. En este caso, se utiliza un módulo de DHT22 para detectar la temperatura y la humedad. La disposición de módulo de DHT22
puede ser descrito en la figura 3-4 .
La Figura 3-4. diseño de módulo de DHT22
Se puede ver un diseño DHT22 en la figura 3-4 . Podemos conectar a nuestro Arduino DHT22
tablero. El siguiente es nuestro cableado:
• DHT22 pin 1 a Arduino VCC 3.3V
• DHT22 pin 2 a Arduino pin digital 8
• DHT22 pin GND a GND Arduino Se puede ver la implementación de cableado en la figura 3-5 .
Puede conectar este sensor

a una placa Arduino a través de cables de puente. Por otro enfoque, se puede utilizar un tablero como un medio al
que una placa Arduino y dispositivos sensores están conectados.
48
Figura 3-5. Cableado para el módulo de DHT22 y placa Arduino
El siguiente paso es la construcción de un programa de Dibujo. Para acceder a DHT22, podemos utilizar la biblioteca sensor de
DHT de Adafruit. Se puede instalar desde Arduino IDE. Haga clic en Croquis menú
➤ incluir Biblioteca ➤ Administrar bibliotecas. Después se hace clic, debería ver un cuadro de diálogo que muestra una lista de las
bibliotecas de Arduino. Encontrar e instalar el biblioteca sensor de DHT. Se puede ver en la figura 3-6 . Asegúrese de que su
ordenador está conectado a Internet para instalar una biblioteca adicional.
49
Figura 3-6. Instalar biblioteca sensor DHT de Adafruit
Para la prueba, se escribe un programa para leer la temperatura y la humedad del módulo DHT22. Después de que se
detecta es la impresión de los datos del sensor a un puerto UART. Ahora abre Arduino IDE y configurarlo para su modelo de la
placa Arduino y el puerto. Escribir el siguiente código:
# incluir "DHT.h"
// define DHT22
# Definir DHTTYPE DHT22 //
define pines en DHT22
# definir DHTPIN 8
DHT DHT (DHTPIN, DHTTYPE);
void setup () {
dht.begin (); }
void loop () {retardo

(2000);
// temperatura o la humedad de lectura se tarda unos 250 milisegundos! lecturas // sensor también
pueden ser de hasta 2 segundos (que es un muy lento sensor) flotador H = dht.readHumidity ();
// temperatura Lee como Celsius (el valor predeterminado) flotador t

= dht.readTemperature ();
50
// Comprobar si los hay lecturas fallidas y salida temprana (para volver a intentarlo). si (isnan
(h) || isnan (t)) {
Serial.println ( "No se pudo leer desde el sensor DHT!"); regreso; }
// índice Compute calor en Celsius (isFahreheit = false) flotar HIC =

dht.computeHeatIndex (t, h, false);
Serial.print ( "Humedad:"); Serial.print

(h); Serial.print ( "% \ t");
Serial.print ( "Temperatura:"); Serial.print

(t); Serial.print ( "C * \ t"); Serial.print (
"Índice de calor:"); Serial.print (HIC);
Serial.println ( "* C"); }
Guardar este programa como “ArduinoDHT”.

A continuación, puede compilar y cargar el programa en la placa Arduino. Para ver nuestra salida del programa, puede
ejecutar la herramienta Monitor de serie. Una muestra de la salida del programa se puede ver en la figura 3-7 .
Figura 3-7. La salida del programa de DHT22
51

Declaramos nuestro objeto DHT DHT y pasando tipo de módulo y el pin de datos a través del pin digital de 8. Esto necesita un archivo de
cabecera DHT.h a trabajar con un objeto DHT.
# incluir "DHT.h"
// define DHT22
# definir DHTPIN 8
Activamos nuestras bibliotecas de DHT y la serie en preparar() llamando a la función empezar()

la función de estas bibliotecas.
void setup () {
dht.begin (); }
En lazo() función del programa Croquis, se lee la temperatura, la humedad, y un índice de calor usando una biblioteca de
DHT. Todas las funciones de DHT ya están disponibles para usted.
flotador h = dht.readHumidity ();

(h) || isnan (t)) {

Después de leer los datos del sensor de un módulo de DHT, se muestra estos datos en un puerto serie para que podamos ver que los
datos utilizando una herramienta Monitor de serie.
Serial.print ( "Humedad:"); Serial.print

(h); Serial.print ( "% \ t");
Serial.print ( "Temperatura:"); Serial.print

(t); Serial.print ( "C * \ t"); Serial.print (
"Índice de calor:"); Serial.print (HIC);
Serial.println ( "* C");
52
Eso es; Ahora usted puede construir su propia demo con varios dispositivos sensores. En la siguiente sección, vamos a
explorar las instalaciones de actuación e interactuar con ellos desde la placa Arduino.
Los dispositivos actuadores
Arduino puede accionar para llevar a cabo algo como parpadear LEDs, generando sonidos, y los motores en movimiento.
Esta tarea normalmente tiene el objetivo de informar y de dar notificación a los usuarios o sistemas para que puedan tener
una respuesta.
Uno de los dispositivos de accionamiento es un LED RGB. Se puede mostrar un color determinado mediante la
combinación de los tres colores: rojo, verde y azul. El LED RGB podría tener dos formas: ánodo común ( https://www.sparkfun.com/products
) y el cátodo común ( https://www.sparkfun.com/products/9264 ). Se puede ver un ejemplo de formulario de un RGB LED en la
figura 3-8 .
La Figura 3-8. RGB LED con forma de ánodo común
Otro dispositivo actuador es servo. Hay muchos modelos de servo que pueden ser utilizados en nuestras placas
Arduino. Se puede encontrar un dispositivo servo fácilmente en su tienda local o en línea, por ejemplo, Sparkfun ( https://www.sparkfun.com
). Figura 3-9
muestra un motor servo de Sparkfun que puede ser aplicado en placas Arduino.
53
Figura 3-9. Servo motor
El acceso y la Prueba del actuador

Como he explicado en la sección anterior, el actuador es un dispositivo en el que Arduino hace realizar algo. Para ilustrar
cómo trabajar con un dispositivo de accionamiento, os muestro cómo utilizar uno de los actuadores más baratos, RGB
LED. LED RGB es un actuador útil que se utiliza para mostrar un indicador, por ejemplo, mientras Arduino está calculando
algo. Arduino puede enviar un indicador de este estado mostrando un color específico en un LED RGB.
En general, RGB disposición de las clavijas de LED se puede describir, como se muestra en la figura 3-10 , como sigue:
• El pin 1 es un pin rojo.
• Pin 2 es VCC o GND. Depende del modo RGB: RGB ánodo común o cátodo
común RGB.
• Pin 3 es un marcador de color verde.
• Pin 4 es un pin azul.
54
La figura 3-10. RGB LED disposición de las clavijas
Un LED RGB puede funcionar si atribuimos a este dispositivo PMW (modulación por ancho de pulso) pasadores. En
general, los pines PWM en una placa Arduino se identifica mediante un signo (~) en los pines digitales. Puede comprobar estos
pines en la hoja de datos de Arduino; por ejemplo, Arduino UNO ( https: // www.arduino.cc/en/Main/ArduinoBoardUno ) tiene
pasadores PWM en 3, 5, 6, 9, 10, y 11. Para la prueba, utilizo una placa Arduino UNO. Utilizo pasadores PWM en 9, 10 y 11. Un
LED RGB está unido a Arduino con el siguiente cableado:
• Pin 1 (pin rojo) está conectado a Arduino pin digital 9.
• Pin 2 (pin común) está conectado a Arduino VCC 3.3V o GND.
• Pin 1 (pin verde) está conectado a Arduino pin digital 10.
• El pin 1 (pin azul) está conectado al Arduino pin digital 11. Esto se puede ver
en la figura cableado 3-11 .
55
Figura 3-11. Cableado LED RGB y UNO Arduino
Seguimos a escribir un programa Boceto. Vamos a construir un programa para mostrar varios colores en un LED RGB.
La idea del programa para mostrar varios colores es la combinación de valores de rojo, verde y azul a un LED RGB. Usted
puede hacer su propio experimento para mostrar un color específico. En este programa, se construyen varios colores como el
rojo, verde, azul, amarillo, púrpura, y Aqua. Ahora se puede abrir un IDE de Arduino y escribir el siguiente código:
int redPin = 9; int

greenPin = 10; int
BluePin = 11;
void setup () {
pinMode (redPin, OUTPUT); pinMode

(greenPin, OUTPUT); pinMode
(BluePin, OUTPUT); Serial.begin
(9600); }
56
void loop () {
setColor (0, 255, 255); // Serial.println rojo

( "rojo"); retardo (1000);
setColor (255, 0, 255); // Serial.println verde (

"verde"); retardo (1000);
setColor (255, 255, 0); // azul Serial.println (

"azul"); retardo (1000);
setColor (0, 0, 255); // Serial.println amarillo

( "amarilla"); retardo (1000);
setColor (80, 255, 80); // Serial.println púrpura

( "púrpura"); retardo (1000);
setColor (255, 0, 0); // aqua Serial.println

( "aqua"); retardo (1000); }
setColor vacío (int rojo, verde, int azul) {
analogWrite (redPin, rojo); analogWrite

(greenPin, verde); analogWrite (BluePin,
azul); }
Como se puede ver en el código anterior, hemos creado un color específico llamando al setColor ()
función, que establece los valores de color en parámetros de color rojo, verde y azul. Usamos el
analogWrite () función para escribir un valor de PWM de Arduino.
Guardar este programa como “RGBLED”. A continuación, compilar y cargar el programa en la placa Arduino. Debe
ver el LED RGB que muestra varios colores. También puede ver la salida del programa usando un monitor de serie, como
se muestra en la figura 3-12 .
57
Figura 3-12. La salida del programa de aplicación RGB
Creación de un .NET Arduino Sensing aplicación usando

En la sección anterior, hemos aprendido cómo acceder a los dispositivos de sensores y actuadores de las placas Arduino utilizando
Boceto. En esta sección, exploramos cómo acceder a los dispositivos de sensores desde una aplicación .NET a través de Arduino.
Hemos aprendido modelos de comunicación entre una placa Arduino y un ordenador. Es importante ya que podemos utilizar estos
modelos de comunicación para recuperar datos de los sensores o para realizar tareas a través de las instalaciones de actuación.
datos de sensores de Arduino se realiza mediante la creación de un programa de bosquejo y luego publicar a la comunicación en
serie, SPI, o el protocolo I2C. Sin embargo, también se puede poner en práctica un protocolo Firmata para comunicarse con una placa
Arduino.
El nuevo enfoque que quiero compartir acerca de detección es el uso de JSON como formato de mensajes entre
Arduino y un ordenador. La idea es que un ordenador envía los datos al Arduino a través de un protocolo específico, por
ejemplo, UART. Entonces, Arduino enviará una respuesta en JSON, también. Este enfoque es fácil de implementar.
También es útil si desea comunicarse con un servidor externo como servidor REST.
Afortunadamente, podemos utilizar una biblioteca ArduinoJson ( https://github.com/bblanchon/ ArduinoJson ) para generar y
analizar un mensaje JSON. Puede descargarlo e instalarlo manualmente. De lo contrario, también puede instalarlo a través de
Administrador de bibliotecas, que se muestra en la figura 3-13 .
58
Figura 3-13. instalar ArduinoJson
Después de instalar ArduinoJson, podemos construir un programa Boceto. Para un caso escenario, utilizo un módulo DHT22
para detectar la temperatura y la humedad. Nuestro programa Boceto detectará y luego enviar datos a un puerto serie en formato
JSON.
En la sección anterior, que ya aprendimos cómo acceder a DHT22 usando Boceto. En este programa, vamos a utilizar
de nuevo. Después de obtener los datos DHT22, envolvemos los datos en formato JSON utilizando una JSONObject objeto.
Ahora abre el IDE Arduino y escribir el siguiente código:
# incluir "DHT.h"
# incluir <ArduinoJson.h>
// define DHT22
# definir DHTPIN 8
StaticJsonBuffer <200> jsonBuffer;

JSONObject y root = jsonBuffer.createObject ();
void setup () {
dht.begin (); }
59
void loop () {retardo

(2000);
// temperatura o la humedad de lectura se tarda unos 250 milisegundos! lecturas // sensor también pueden
ser de hasta 2 segundos 'viejo' (es un muy lento sensor) flotador h = dht.readHumidity ();

(h) || isnan (t)) {

raíz [ "Humedad"] = double_with_n_digits (h, 2); raíz [ "temperatura"]

= double_with_n_digits (t, 2); root.printTo (Serial); Serial.println ( ""); }

Creamos una instancia nuestra JSON utilizando una StaticJsonBuffer objeto con 200 caracteres. A continuación, creamos un
objeto JSON llamando Crear objeto() función.
StaticJsonBuffer <200> jsonBuffer;

JSONObject y root = jsonBuffer.createObject ();
En lazo() función, leemos los datos del sensor a través de DHT22. Obtenemos la humedad marido y la temperatura t. A continuación,
se pasa estos valores en los datos JSON. Después de eso, pasamos datos JSON en un puerto serie para nuestro programa, tales como
una aplicación .NET, lee los datos.
raíz [ "Humedad"] = double_with_n_digits (h, 2); raíz [ "temperatura"]

= double_with_n_digits (t, 2); root.printTo (Serial); Serial.println ( "");
Guardar este programa como “DHTJson”. Compilar y cargar este programa en la placa Arduino.
El siguiente paso es la construcción de una aplicación .NET. En este escenario, yo uso Json.NET ( http: // www.newtonsoft.com/json ) JSON
para analizar los datos que provienen de Arduino. Se puede instalar a través de la consola de Administrador de paquetes escribiendo el
siguiente comando:
PM> Install-Package Newtonsoft.Json
60
Se puede ver el proceso de instalación en la figura 3-14 .
Figura 3-14. Instalar Json.NET a través de la consola de Administrador de paquetes
Utilizando Visual Studio, construimos una aplicación .NET. Construimos un programa para leer los datos de un puerto serie. Crear
un nuevo proyecto de aplicación de consola con el llamado “DotnetDHT”. Después de que se ha creado, a través de la instalación
Json.NET consola Administrador de paquetes. Asegúrese de que su ordenador está conectado a Internet.
Ahora crea un objeto del sensor mediante la adición de una clase llamada “sensor”. Luego, escribe los siguientes
códigos:
using System;
DotnetDHT espacio de nombres {
Sensor de clase {
Humedad cadena pública {set; obtener; } {Cadena pública de

temperatura establecido; obtener; }}}
Un objeto del sensor se utiliza para mantener los datos del sensor de Arduino. Nos analizar los datos JSON y lo ponemos en un
objeto del sensor. Nosotros podemos usar JsonConvert.DeserializeObject <Sensor> () para analizar una cadena a un objeto. Ahora se puede
modificar el archivo Program.cs para leer los mensajes entrantes de comunicación en serie y luego analizarlos. Los siguientes son los
códigos en el archivo Program.cs:
using System;
usando System.Collections.Generic; usando
System.Linq; usando System.Text;
usando System.Threading.Tasks; usando

System.IO.Ports;
usando Newtonsoft.Json;
espacio de nombres DotnetDHT
61
{
bool funcionamiento estático = true;

static void main (String [] args) {
tratar


e.Cancel = true;
serialPort.Open ();
mientras corre) {
datos de cadena = serialPort.ReadLine (); if (!

Console.WriteLine (datos); si (data.Contains (

"Humedad") && datos. Contiene ( "Temperatura")) {
Sensor s = JsonConvert.DeserializeObject <Sensor

> (Datos);
Console.WriteLine ( "Temperatura: {0} ^ C",

s.Temperature);
Console.WriteLine ( "Humedad: {0}", s.Humidity); }}}
serialPort.Close (); }
Console.WriteLine (err); }

Console.ReadLine ();
}}
62
Guardar el programa. Por favor, cambie el puerto serie para la placa Arduino. Este programa utiliza COM5 desde que
se detectó mi Arduino como COM5 en Windows. Se debe cambiar por su puerto serie Arduino. Por favor, lea el capítulo 1 para
comprobar un puerto serie de una placa Arduino.
Ahora se puede compilar y ejecutar el programa de Visual Studio directamente. Debería ver los mensajes
entrantes de Arduino. Estos mensajes se analizan y muestran en la Terminal para los valores de temperatura y
humedad.
Se puede ver la muestra de la salida del programa en la figura 3-15 .
Figura 3-15. La salida del programa para la lectura de los datos del sensor de Arduino

El programa configura un puerto serie de Arduino. En este caso, yo uso para mi COM5 Arduino. Se debe cambiar
con un puerto serie de Arduino en Windows.

63
Dado que nuestro programa se ejecuta de forma continua, tenemos que romper nuestro programa presionando CTRL + C.
utilizamos CancelKeyPress eliminar de Consola objeto. Si el usuario presiona CTRL + C, cambiamos corriendo valor en falso por lo
que nuestro programa de bucle se romperá.
Console.CancelKeyPress + = delegado (remitente del objeto, ConsoleCancelEventArgs e) {
e.Cancel = true;
A continuación, el programa abre un puerto serie y lee los datos de entrada de un puerto serie utilizando ReadLine () método. A
continuación, mostramos nuestros datos del sensor al terminal. Puesto que los datos del sensor es formato JSON, debemos analizar
los datos JSON usando JsonConvert. DeserializeObject <> (). Obtendremos Sensor datos como resultado de que el analizador JSON.
Por último, cerramos nuestra conexión de puerto serie llamando Cerca() método.
serialPort.Open ();
mientras corre) {
datos de cadena = serialPort.ReadLine (); if (!

Console.WriteLine (datos);
si (data.Contains ( "Humedad") && data.Contains ( "Temperatura")) {
Sensor s = JsonConvert.DeserializeObject <Sensor> (datos);
Console.WriteLine ( "Temperatura: {0} ^ C", s.Temperature); Console.WriteLine

( "Humedad: {0}", s.Humidity); }}}
serialPort.Close ();
Este es el último de nuestros programas .NET para detectar de Arduino. Usted puede hacer más práctica utilizando otro
dispositivo sensor. A continuación, un programa .NET leerá los datos del sensor.
64
Creación de un .NET Arduino accionamiento aplicación usando

Hemos aprendido a acceder a los datos del sensor de Arduino utilizando .NET. Puede obtener más práctica al tratar de trabajar
algunos dispositivos sensores. En este apartado, construimos una aplicación .NET para accionar a través de las instalaciones de
actuación.
Para las pruebas, utilizo un RGB LED como un dispositivo accionador. Ya hemos aprendido a trabajar con LED RGB
usando Boceto. Ahora vamos a trabajar con este actuador utilizando .NET. Cambiamos el color de LEDs RGB de nuestra
aplicación .NET. La comunicación entre Arduino y un ordenador utiliza el protocolo Firmata por lo que debe instalar un
estándar Firmata Boceto en la placa Arduino.
Abra Visual Studio y crear una aplicación de Windows Forms llamado “RGBControlApp”. Construimos un formulario de interfaz de
usuario, que se muestra en la figura 3-16 .
Figura 3-16. Construir la aplicación de interfaz de usuario
Después de crear el proyecto, hay que añadir una biblioteca SolidSoils4Arduino ( https: //
github.com/SolidSoils/Arduino ) en nuestro proyecto. Es un cliente Firmata para .NET. Hemos aprendido que en el
capítulo anterior.
En nuestro formulario de Windows (Form1.cs), añadimos una biblioteca SolidSoils4Arduino escribiendo estos códigos:
usando Solid.Arduino; usando

Solid.Arduino.Firmata;
sesenta y cinco
Declaramos varias variables y establecer los valores de inicialización de una Barra de seguimiento objeto sobre un constructor de Formar.
public partial class Form1: Formulario {
redVal int privado; Greenval

int privado; blueVal int
privado; Public Form1 () {
InitializeComponent ();
redVal = trackRed.Value; Greenval =

trackGreen.Value; blueVal =
trackBlue.Value;
Mientras que los usuarios cambien los valores de color en Barra de seguimiento objetos, que deben atrapar a este evento. Podemos
utilizar una ValueChanged evento. Usted debe cogerlo para todos Barra de seguimiento objetos. A continuación, se lee un valor de color de Barra
de seguimiento y actualizar nuestro color del panel.
trackRed_ValueChanged vacío (object sender, EventArgs e) {privado
redVal = trackRed.Value; lbRed.Text =

redVal.ToString (); UpdateColorPanel (); }
trackGreen_ValueChanged vacío (object sender, EventArgs e) {privado
Greenval = trackGreen.Value; lbGreen.Text =

greenVal.ToString (); UpdateColorPanel (); }
trackBlue_ValueChanged vacío (object sender, EventArgs e) {privado
blueVal = trackBlue.Value; lbBlue.Text =

blueVal.ToString (); UpdateColorPanel (); }
UpdateColorPanel () función actualiza el color del panel cambiando BackColor de las propiedades del panel.
66
UpdateColorPanel private void () {
panelColor.BackColor = Color.FromArgb (redVal, Greenval, blueVal);
Cuando los usuarios hacen clic en el botón de ejecución, el programa se conectará a la placa Arduino y cambiar el
color del LED RGB. Por favor, cambie el puerto de Arduino. En este caso, mi Arduino se detectó como COM5. Se debe
cambiar para su puerto serie Arduino.
btnExecute_Click vacío (object sender, EventArgs e) {privado
tratar
conexión var = new SerialConnection ( "COM5", SerialBaudRate Bps_57600.);
sesión var = new ArduinoSession (conexión, timeout: 250);
IFirmataProtocol firmata = (IFirmataProtocol) de sesiones;
int redPin = 9; int

greenPin = 10; int
BluePin = 11;
firmata.SetDigitalPinMode (redPin, PinMode.PwmOutput);

firmata.SetDigitalPinMode (greenPin, PinMode.PwmOutput);
firmata.SetDigitalPinMode (BluePin, PinMode.PwmOutput);
firmata.SetDigitalPin (redPin, redVal); firmata.SetDigitalPin

(greenPin, Greenval); firmata.SetDigitalPin (BluePin,
blueVal);
Connection.close (); }
MessageBox.Show (err.Message); }
Se puede ver el programa anterior. Cuando los usuarios hacen clic en el botón Ejecutar, el programa enviará valores de
rojo, verde y azul a través de Arduino Firmata llamando a un SetDigitalPin ()
método. Antes de llamar a este método, puede declarar las patas como las PwmOutput llamando a un SetDigitalPinMode
() método.
Guardar el programa. Ahora se puede ejecutar el programa. Después de correr, puede cambiar los valores de rojo, verde y azul,
cambiando Barra de seguimiento. Después de que se ha seleccionado, haga clic en el botón Ejecutar. Entonces, usted debe ver que el
LED RGB se iluminaba con el color elegido. Usted puede ver mi formulario de solicitud en la figura 3-17 .
67
Figura 3-17. Ejecución de solicitud de RGBControlApp
Resumen
Hemos aprendido a acceder a los dispositivos de sensores y actuadores en Arduino usando un programa de dibujo. Utilizamos un RGB
LED y un módulo de DHT22 como una muestra de accionador y sensor. Por otra parte, hemos construido un programa .NET para
acceder a los dispositivos de sensores y actuadores en Arduino. En el siguiente capítulo, vamos a aprender a trabajar de Windows
Arduino remoto (MEF) para una plataforma de aplicaciones de Windows universal (UWP). Esta plataforma se puede ejecutar en
Frambuesa Pi, tableta de Windows, y escritorio de Windows.
68
CAPÍTULO 4
Arduino remoto de Windows
Microsoft está trabajando en el desarrollo de la IO intensiva. La principal tecnología de Microsoft, .NET Microsoft, está siendo
empujado con el fin de llevar a cabo con las plataformas actuales de la IO como Arduino y Raspberry Pi. Microsoft lanzó la biblioteca
Arduino remoto de Windows para permitir a la plataforma de Microsoft de Windows (llamado Plataforma Windows universal, o UWP)
para trabajar en una plataforma Arduino. La tecnología uwp hace que nuestro programa funciona en cualquier plataforma Windows, tal
como un ordenador, tableta, teléfono inteligente, y los tableros de la IO.
• La creación de Arduino para Arduino remoto de Windows
• La construcción de su primer programa para Arduino remoto de Windows
• El control de Arduino analógica I / O
• Arduino comunicación remota a través de bus I2C
• Arduino ventanas a distancia a través de Bluetooth
En el capítulo anterior, hemos aprendido a sentir y accionar el Arduino desde una

. NET. También tratamos de comunicar con Arduino a través del protocolo Firmata. En este capítulo, vamos a aprender
cómo acceder a una placa Arduino a partir de Windows .NET utilizando Arduino remoto.
Ventanas Arduino es una biblioteca remota de Microsoft en el que un marco basado en .NET aplicación de
Windows puede controlar a través de una placa Arduino USB y la comunicación Bluetooth. Lo que quiero decir en
este caso por “.NET framework” es marco .NET de la plataforma de Windows universal. Microsoft ha introducido
una plataforma universal de Windows (UWP) en Windows 8 o posterior.
A través de la plataforma de Windows universal (UWP), podemos desarrollar una aplicación .NET que se ejecuta en
cualquier plataforma Windows, como escritorio, teléfonos inteligentes, tabletas y las juntas de la IO. Técnicamente, algunas API
.NET se cortan generalizar arquitectura de la aplicación. Para más información sobre plataforma Windows universal, le sugiero
que lea este sitio web:
https://msdn.microsoft.com/en-us/windows/uwp/get-started/whats-a-uwp .
Figura 4-1 muestra cómo interactúa uwp entre los dispositivos.
Capítulo 4 ■ Arduino remoto de Windows
La Figura 4-1. objetivos de la plataforma de Windows universal
Ventanas Arduino remoto está diseñado para la plataforma de Windows universal, por lo que si usted tiene tabletas de
Windows, como Microsoft Surface, podemos controlar nuestro Arduino para recuperar la información del sensor o para accionar
algunos objetos físicos que rodean una placa Arduino.
La tecnología UWP utiliza un marco .NET de la base del programa. Significa marco UWP es un subconjunto del
marco .NET. Gráfica Unidad de interfaz de usuario (GUI) en UWP utiliza la tecnología de XAML. Usted debe estar
familiarizado XAML en Windows Presentation Foundation (WPF), por lo que no es necesario invertir más en el aprendizaje
de uwp si tiene experiencia en WPF.
La creación de Arduino para Arduino remoto de Windows

No hay ningún requisito especial para trabajar con Windows Arduino remoto. Cada placa Arduino debe
implementarse en un programa Firmata Boceto para que la placa Arduino a comunicarse con otro dispositivo.
Lo que usted debe entender es que Windows Arduino remoto funciona en la parte superior de la plataforma de
Windows universal. Para desarrollar esta aplicación, debe instalar Windows 8 o posterior. Actualmente, recomiendo el uso de
Windows 10 para el desarrollo.
Desarrollar plataforma Windows universal (UWP), podemos utilizar Visual Studio 2015 o más tarde. Se ha instalado
plantillas de proyecto UWP. Se puede ver en la figura 4-2 .
70
La Figura 4-2. Las plantillas de proyecto para la plataforma Windows universal (UWP)
La construcción de su primer programa para Arduino remoto de

Windows
En este apartado, construimos el primer programa para Windows Arduino remoto. Desarrollamos una aplicación de LED
intermitente para la plataforma de Windows universal. En este caso, necesitamos tres LEDs. También necesitamos un
ordenador con Windows 10 SO instalado. Estos tres LEDs se encenderán / apagado manual de la aplicación.
¡Empecemos!
Alambrado
Para llevar a cabo nuestra demo, hay que conectar nuestros componentes. Nuestros tres LEDs están asociadas a Arduino con el
siguiente esquema:
• LED 1 está conectado a Arduino pin digital 12.
Es posible usar una resistencia de cada LED para proteger el LED. Por último, se puede ver mi cableado en la figura 4-3 .
71
La Figura 4-3. Cableado para parpadear LEDs
Programa de Arduino
Para que nuestra aplicación para comunicarse con la placa Arduino, tenemos que configurar nuestras tablas.
Ventanas Arduino remoto requiere un programa Firmata Boceto instalado en la placa Arduino.
Para instalar Firmata Boceto, puede abrir Arduino IDE. A continuación, haga clic en el menú Archivo ➤
Ejemplos ➤ firmata ➤ StandardFirmata. Debería ver el programa Firmata Croquis en Arduino IDE. Después de eso, se debe
cambiar la velocidad en baudios a 57600. Se puede ver en la figura 4-4 .
72
La Figura 4-4. Cambiar la velocidad en baudios en el Boceto Firmata
Ahora puede compilar y cargar el programa Firmata Boceto en la placa Arduino. Si se hace, su
tablero está listo para recibir comandos desde una aplicación .NET.
. Programa de Aplicación NET

El siguiente paso es crear un proyecto para un objetivo universal plataforma Windows. En Visual Studio 2015, puede crear
un nuevo proyecto seleccionando “plantilla de proyecto” en Windows
➤ Universal ➤ App blanco (Universal Windows), como se muestra en la figura 4-5 . Dar un nombre al proyecto: “BlinkingLed”.
Si le hacen, haga clic en el botón OK.
73
La Figura 4-5. Añadir un nuevo proyecto universal de Windows
Después de crear un proyecto, se le pedirá para una versión de destino. Seleccione la versión más reciente en versión de destino.
Se puede ver en la figura 4-6 .
Figura 4-6. Seleccionar versión de destino para la plataforma de Windows universal
Si tiene éxito, debe consultar a su proyecto con XAML interfaz gráfica de usuario. Se puede ver la lista de archivos de proyecto en la
figura 4-7 .
74
La Figura 4-7. archivo de esquema de proyecto para la aplicación de Windows universal
La adición de ventanas de la biblioteca Arduino remoto
Para permitir que nuestra aplicación de Windows universal (UWP) para comunicarse con Arduino, hay que añadir ventanas de la biblioteca
Arduino remoto. Puede hacer clic en el menú de Visual Studio 2015: Herramientas ➤ NuGet Administrador de paquetes ➤ Consola del gestor
de paquetes. A continuación, debería ver la consola de Administrador de paquetes en Visual Studio. Asegúrese de seleccionar nuestro
proyecto. A continuación, escriba el siguiente comando:
Instalar Paquete Windows remoto en Arduino
Esta tarea requiere la comunicación por Internet. Se puede ver la salida del programa en la figura 4-8 .
75
La Figura 4-8. Instalar Arduino remoto de Windows a través de la consola Administrador de paquetes
Después de que éste se agrega, debería ver esta biblioteca en el esquema de proyecto, que se muestra en la figura 4-9 .
Debería ver Windows remoto en Arduino en el menú Referencias.
Figura 4-9. Arduino biblioteca remota de Windows en proyecto
76
Programa de escritura .NET

Utilizamos USB como medio de comunicación para el control de la placa Arduino de la aplicación. Desde nuestra
aplicación utiliza USB, debemos activar esta capacidad. La información acerca de las capacidades de aplicación se
puede ver en el archivo Package.appxmanifest. Si abre este archivo, debe obtener estas configuraciones:
Capacidades <>
<Capacidad Name = "internetClient" />
</ Capacidades>
Ahora deberíamos tener una capacidad de comunicación en serie. Se pueden añadir los siguientes scripts en negrilla:
Capacidades <>
<DeviceCapability Name = "serialcommunication"> <Device Id =

"any">
<Función Tipo = "Nombre: SERIALPORT" /> </
dispositivo>
</ DeviceCapability>
</ Capacidades>
Si le hacen, guardar el archivo.

El siguiente paso es la construcción de la interfaz gráfica de usuario de la aplicación. Añadimos tres casillas de verificación, uno
Textblock, y un componente de botón. Diseñamos nuestra interfaz gráfica de usuario en el archivo MainPage.xaml, que se muestra en la
figura 4-10 .
Figura 4-10. Diseño interfaz gráfica de usuario para la aplicación BlinkingLed
77
El siguiente es un resumen del archivo MainPage.xaml:
<Página
x: Class = "BlinkingLed.MainPage"
xmlns = "http://schemas.microsoft.com/winfx/2006/xaml/presentation" xmlns: x =
"http://schemas.microsoft.com/winfx/2006/xaml" xmlns: Local = "usando: BlinkingLed "
xmlns: d = "http://schemas.microsoft.com/expression/blend/2008" xmlns: mc =

"http://schemas.openxmlformats.org/markup-compatibility/2006" MC: se ignoran = "d">
<Fondo de la red = "{} ThemeResource ApplicationPageBackgroundThemeBrush">

<CheckBox x: Name = "chkLed1" Content = "LED 1" A cuadros = "HandleCheck" Unchecked =
"HandleUnchecked" HorizontalAlignment = "izquierda" Margen = "40,20,0,0" VerticalAlignment =
"top" width = "85 "/> <CheckBox x: Name =" content = "chkLed2" LED 2" marcada =
"HandleCheck" Desactivada = "HandleUnchecked" HorizontalAlignment = "izquierda" Margen =
"40,52,0,0" VerticalAlignment = "top" Ancho = "85" /> <CheckBox x: Name = contenido "chkLed3"
= "LED 3" A cuadros = "HandleCheck" Unchecked = "HandleUnchecked" HorizontalAlignment =
"izquierda" Margen = "40,84,0,0" VerticalAlignment =" top "width = "85"/> <TextBlock x: Name =
"txtStatus" HorizontalAlignment ="Izquierda" Margen = "40,121,0,0" TextWrapping = "" Text =
"Wrap Estado" VerticalAlignment = "top" width = "256"/> <Botón x: Name = "btnClose" content =
"Desactivar todos los LED" HorizontalAlignment = "izquierda" Margen = "135,30,0,0"
VerticalAlignment = "top" click = "TurnOffLeds" />
</
Cuadrícula> </ Página>
Se puede ver en XAML botón cuales evento Click se pasa por TurnOffLeds método. Esto se llevará a
cabo en MainPage.xaml.cs.
Dentro MainPage.xaml.cs, debemos modificar nuestros códigos de trabajar con nuestro escenario. En primer lugar, añadimos
nuestras bibliotecas necesarias.
usando Microsoft.Maker.Serial; usando

Microsoft.Maker.RemoteWiring;
Añadimos variables adicionales en la clase MainPage.
usbserial conexión privada; Arduino

RemoteDevice privado; const byte LED1
privado = 12; const byte LED2 privado =
11; const byte LED3 privado = 10;
Inicializamos Arduino remoto de Windows en el constructor MainPage. Nosotros creamos

InitWRA () método con los siguientes códigos.
78
MainPage pública () {
this.InitializeComponent (); this.Unloaded + =

MainPage_Unloaded;
InitWRA (); }
MainPage_Unloaded vacío (object sender, RoutedEventArgs e) {privado
arduino.Dispose (); }
InitWRA private void () {
conexión = new usbserial ( "VID_2341", "PID_0043"); Arduino = new

RemoteDevice (conexión);
connection.ConnectionEstablished + = Connection_ConnectionEstablished; connection.begin

(57600, SerialConfig.SERIAL_8N1);
En este código, mi Arduino USB es reconocido como VID_2341 y PID_0043 parámetros para usbserial objeto.
Para obtener estos datos, se debe abrir la propiedad de Arduino USB que es detectada por el ordenador. Abra
Administrador de dispositivos y ampliar su Arduino USB. Se puede ver en la figura 4-11 .
79
Figura 4-11. Arduino Uno es detectado como COM5 en la herramienta Administrador de dispositivos
Abrir la propiedad de Arduino USB, de modo que obtenga un cuadro de diálogo. Haga clic en la pestaña Detalles. A continuación,
seleccione ID de hardware en la propiedad. Debería ver los valores de VID y PID para su USB Arduino. Se los puede ver en mi Arduino
USB, que se muestra en la figura 4-12 . Estos valores deben ser insertados en nuestro programa.
80
Figura 4-12. Los valores de VID y el PID para Arduino USB
Ahora volvemos a los códigos de MainPage.xaml.cs. En nuestro método, InitWRA (), ponemos en práctica nuestra Connection_ConnectionEs
evento. También aplicamos nuestro evento marcado y sin marcar en el componente Casilla de verificación mediante la
implementación HandleCheck ()
y HandleUnchecked () métodos. Finalmente, se aplica TurnOffLeds () el evento Click de un botón. La siguiente
es la implementación.
Connection_ConnectionEstablished private void () {
arduino.pinMode (LED1, PinMode.OUTPUT);

txtStatus.Text = "conectado"; }
private void HandleCheck (remitente del objeto, RoutedEventArgs e) {
CheckBox cb = remitente como CheckBox; si (==

cb.Name "chkLed1") {
arduino.digitalWrite (LED1, PinState.HIGH); }
81
si (== cb.Name "chkLed2") {
private void HandleUnchecked (remitente del objeto, RoutedEventArgs e) {
CheckBox cb = remitente como CheckBox; si (==

cb.Name "chkLed1") {
arduino.digitalWrite (LED1, PinState.LOW); }
arduino.digitalWrite (LED2, PinState.LOW); }
arduino.digitalWrite (LED3, PinState.LOW); }}
TurnOffLeds private void (object sender, RoutedEventArgs e) {
chkLed1.IsChecked = false;
chkLed2.IsChecked = false;
chkLed3.IsChecked = false; }
Guardar todos los cambios. Nuestro programa está listo para la prueba.
Pruebas
Se puede compilar nuestro programa. Antes de ejecutar el programa, debe implementar el programa a un entorno UWP.
Haga clic derecho en el proyecto y luego seleccione Implementar en un menú contextual. Se muestra en la figura 4-13 .
82
Figura 4-13. Implementar el programa
Ahora se puede ejecutar el programa haciendo clic en una flecha verde con el blanco de la máquina local. Después se hace clic,
debería ver nuestro programa de diálogo, como se muestra en la figura 4-14 .
Figura 4-14. Ejecuta el programa
Para la prueba, se puede activar el LED 1, 2 LED o LED 3 haciendo clic en la casilla de verificación.
83
Figura 4-15. El programa se está ejecutando
Si marcó la casilla de verificación en LED 1 y 2, debería ver la iluminación LED LED 1 y 2. Para desactivar todos
los LED, puede hacer clic en el Apagar todos los LED botón.
Figura 4-16. Activar el LED 1 y 2
Ahora hemos visto cómo acceder a E / S digital en Arduino Arduino a través de Windows remoto. En la siguiente
sección, continuamos acceder a módulos de E / S en Arduino.
84
Control de Arduino E / S analógica

Hay entrada analógica y salida analógica, llamado PWM esquemas (Modulación de Ancho de Pulso) en la placa Arduino.
Aprender analógica I / O es importante porque varios dispositivos de sensores y actuadores de trabajo Uso de E / S
analógica.
En esta sección, se aprende cómo trabajar con módulos de E / S en Arduino Arduino a través de la biblioteca remota de
Windows. Para la prueba, se utiliza LED RGB. Ya hemos trabajado con él en el capítulo 3 . Ahora tratamos de acceder a ella usando la
biblioteca de Arduino remoto de Windows. En general, los LED RGB tiene cuatro pasadores: rojo, GND / VCC, verde y azul Botones.
En el pin 2, podría ser GND o VCC, dependiendo de qué tipo de RGB LED (ánodo o LED cátodo). Esto se puede ver en la figura
disposición de las clavijas 4-17 .
Figura 4-17. pinout LED RGB
85
Alambrado
Para llevar a cabo nuestro cableado de demostración, hace lo siguiente cableado:
• Contacto rojo de LED RGB está conectado al pin digital 9 Arduino.
• GND / VCC pin de RGB LED está conectado a GND / VCC Arduino.
• Contacto verde de LED RGB está conectado al pin digital 10 Arduino.
• pin azul de LED RGB está conectado al pin digital 11 Arduino. Esto se puede ver en
la figura cableado 4-18 .
Figura 4-18. Cableado para el proyecto de LED RGB
86
Creación de un proyecto UWP
Puede crear un proyecto uwp desde Visual Studio. Usted ha aprendido que en la sección anterior. Nombre del proyecto “RGBDemo”. A
continuación, agregue la biblioteca de Arduino remoto de Windows a través de la consola Administrador de paquetes. Después de que se
ha creado, se debe añadir la capacidad del dispositivo adicional sobre Package.appxmanifest. La secuencia de comandos en negrita es
nuestro script adicional.
Capacidades <>
"any">
<Función Tipo = "Nombre: SERIALPORT" /> </
dispositivo>
</ Capacidades>
Programa de Arduino
Para trabajar con un programa UWP, se debería instalar un programa Firmata Skecth en Arduino como en la sección.
Seleccionar StandardFirmata. Se llevará a cabo esta tarea de construir un proyecto uwp en este capítulo. Después
StandardFirmata se carga en Arduino IDE, parpadeará el programa en la placa Arduino.
■ Nota todos los programas de Arduino relacionados con un proyecto de aplicación UWP deben ser instalados y desplegados
como programas standardFirmata en la placa Arduino.
Escribir el Programa UWP

La idea de nuestro programa es el control de LEDs RGB desde una aplicación UWP. Mostramos un lienzo cuyo color puede
cambiarse deslizando los controles de color rojo, verde y azul. Vamos a utilizar nuestra aplicación GUI, que se muestra en la figura 4-19
.
87
Figura 4-19. El diseño de la interfaz de usuario para la aplicación de LED RGB
Ponemos un lienzo para mostrar el color actual, tres controles deslizantes y un botón para solicitar el cambio de color. Se
puede ver los códigos completos para XAML de la siguiente manera:
<Página
x: Class = "RGBDemo.MainPage"
"http://schemas.microsoft.com/winfx/2006/xaml" xmlns: Local = "usando: RGBDemo "


<Deslizador x: Name = "redSlider" HorizontalAlignment = "izquierda" Margen = "153,17,0,0"
VerticalAlignment = "top" width = "100" height = "43" ValueChanged = "ChangeRedColor" máxima =
"255" /> <TextBlock x: Name = "textBlock" HorizontalAlignment = "izquierda" Margen = "109,24,0,0"
TextWrapping = texto "Wrap" = "rojo" VerticalAlignment = "top" />
<Deslizador x: Name = "greenSlider" HorizontalAlignment = "izquierda" Margen = "153,52,0,0"

VerticalAlignment = "top" width = "100" height = "43" ValueChanged = "ChangeGreenColor" máxima =
"255" /> <TextBlock x: Name = "textBlock_Copy" HorizontalAlignment = "izquierda" Margen =
"109,59,0,0" TextWrapping = texto "Wrap" = "verde" VerticalAlignment = "top" />
<Deslizador x: Name = "blueSlider" HorizontalAlignment = "izquierda" Margen = "153,91,0,0"

VerticalAlignment = "top" width = "100" height = "43" ValueChanged = "ChangeBlueColor" máxima =
"255" />
88
<TextBlock x: Name = "textBlock_Copy1" HorizontalAlignment = "izquierda" Margen =

"109,98,0,0" TextWrapping = texto "Wrap" = "Blue" VerticalAlignment = "top" />
<Botón x: Name = "botón" content = "Cambio" HorizontalAlignment = "izquierda" Margen =

"10,86,0,0" VerticalAlignment = "top" Click = "changeColor" /> <lienzo x: Name = "cvColorView
"HorizontalAlignment =" "height = "izquierda" Margen = "65 10,14,0,0" VerticalAlignment = "top"
width = "71" Antecedentes = "# FFC81010"/>
</
Dentro de los controles deslizantes, cogemos ValueChanged evento llamando ChangeRedColor (), ChangeGreenColor
(), y ChangeBlueColor () métodos. También cogemos Haga clic en el botón evento llamando al método changeColor (). Vamos a
ponerlas en práctica en el código MainPage.xaml.cs.
Ahora debemos modificar MainPage.xaml.cs. En primer lugar, añadimos las bibliotecas necesarias escribiendo estas
bibliotecas:

A continuación, añadimos varias variables para administrar nuestros alfileres y colores.

RemoteDevice privado; byte private const
ROJO = 9; const bytes verdes privadas =
10; byte private const AZUL = 11; byte
privada rojo; byte verde privada; Blue Byte
privado;
En el constructor, inicializamos nuestra biblioteca MEF. Hemos establecido todos los pines que se utilizan para LEDs
RGB en modo PWM. Cambio de valores “PID_0043” para su Arduino USB, lo que hemos aprendido en la sección anterior
“VID_2341” y.
this.InitializeComponent ();
rojo = 0;
verde = 0;
azul = 0;
this.Unloaded + = MainPage_Unloaded; InitWRA

();
}
89
conexión = new usbserial ( "VID_2341", "PID_0043");

Arduino = new RemoteDevice (conexión);

}
System.Diagnostics.Debug.WriteLine ( "conectado");
arduino.pinMode (RED, PinMode.PWM);

arduino.pinMode (verde, PinMode.PWM);
arduino.pinMode (azul, PinMode.PWM);
En el archivo MainPage.xaml, fijamos nuestros eventos para ValueChanged y Hacer clic evento para el botón. Podemos
implementar de la siguiente manera:
ChangeGreenColor private void (object sender, RangeBaseValueChangedEventArgs e) {
rojo = (byte) redSlider.Value;

UpdatePanel (); }
ChangeRedColor private void (object sender, RangeBaseValueChangedEventArgs e) {
verde = (byte) greenSlider.Value; UpdatePanel

();
ChangeBlueColor private void (object sender, RangeBaseValueChangedEventArgs e) {
azul = (byte) greenSlider.Value;

UpdatePanel (); }
90
ChangeColor private void (object sender, RoutedEventArgs e) {
// cambio de color en RGB LED

arduino.analogWrite (rojo, rojo);
arduino.analogWrite (verde, verde);
arduino.analogWrite (azul, azul); }
UpdatePanel private void () {
cvColorView.Background = new SolidColorBrush (Color.FromArgb (255, (byte) rojo, (byte) verde,

(byte) azul)); }
Puede ver los otros códigos que nos planteamos LED RGB de tres entradas de color. Si se hace, guardar todos los archivos.
Pruebas
Ahora puede compilar y ejecutar el programa. Si se produce un error durante la ejecución del programa, debe implementar
el programa y luego ejecutarlo. Se puede ver el programa, como se muestra en la figura 4-20 .
Figura 4-20. RGB LED aplicación se está ejecutando
91
Cambiar el color actual deslizando tres colores: rojo, verde y azul-en los controles deslizantes. Si se hace, haga clic en el
botón Cambiar para aplicar el color seleccionado para LED RGB. Se puede ver la muestra de salida del LED RGB en la figura 4-21
.
Figura 4-21. RGB LED de iluminación basado en la selección de los colores rojo, verde y azul
Arduino remota a través del bus I2C

El I2C (Inter-Integrated Circuit) o bus TWI (dos hilos) de interfaz se utiliza para la comunicación entre la MCU y varios
dispositivos externos. El bus I2C consta de dos cables: SDA (Serial Line de datos) y SCL (Serial Line Reloj). Cada
placa Arduino tiene I2C en los pines específicos. Puede comprobar pines I2C en el diseño de Arduino; por ejemplo,
UNO Arduino (basado en el documento https://www.arduino.cc/en/Main/ArduinoBoardUno ) tiene pines I2C en el pin
SDA en A4 y clavija en el pin SCL A5.
En esta sección, aprendemos cómo acceder a I2C desde una aplicación .NET a través de la biblioteca de Arduino remoto
de Windows. Para la prueba, utilizo un módulo PCF8591 AD / DA que consta de termistor, fotorresistencia, y el potenciómetro.
Dado que este módulo utiliza IC PCF8591, este módulo se puede acceder en I2C. Puede encontrar este módulo fácilmente en
una tienda en línea, por ejemplo, eBay y Aliexpress.
92
Figura 4-22. PCF8591 AD módulo / DA
Cableado para I2C Aplicación

Podemos conectar un módulo PCF8591 AD / DA a una placa Arduino UNO directamente con el siguiente cableado:
• módulo PCF8591 VCC está conectado a Arduino 3.3V.
• módulo PCF8591 GND está conectado a Arduino GND.
• Módulo PCF8591 SDA está conectado al Arduino SDA (patilla A4).
• módulo PCF8591 SCL está conectado a Arduino SCL (pin A5). Una muestra de mi cableado de
hardware se puede ver en la figura 4-23 . A PCF8591 AD / DA

módulo se coloca en una placa. Para conectar con Arduino, utilizo cables de puente.
93
Figura 4-23. Cableado para demostración I2C con la ERH
Utilizando Visual Studio 2015, puede crear un nuevo proyecto con una plantilla en blanco Aplicación (Universal Windows). Después de
eso, instale la biblioteca Arduino remoto de Windows. A continuación, también debe configurar el archivo Package.appxmanifest a la
capacidad adicional para acceder a USB. Puede escribir estos códigos en negrilla de la siguiente manera:
Capacidades <>
"any">
<Función Tipo = "Nombre: SERIALPORT" /> </ dispositivo>
</ Capacidades>
Guardar este programa. El siguiente paso es escribir un programa .NET.

Por favor, instale un programa de dibujo StandardFirmata en la placa Arduino, antes de continuar nuestro proyecto.
94
Escribiendo Programa UWP
El primer paso para construir un programa UWP es construir la interfaz de usuario de la aplicación. Acabamos de poner Textblock para
mostrar información sobre los valores del termistor, fotovoltaicos y el potenciómetro. Se puede ver la interfaz de usuario de la aplicación de la
figura 4-24 .
Figura 4-24. Interfaz de usuario para la aplicación I2C
El siguiente es un script de XmaI para nuestra interfaz de usuario de la aplicación en el archivo MainPage.xaml:

<TextBlock x: Name = "textBlock" HorizontalAlignment = "izquierda" Margen =
"10,52,0,0" TextWrapping = texto "Wrap" = "termistor:" VerticalAlignment = "top" />
<TextBlock x: Name = "textBlock1" HorizontalAlignment = Margen = "10,77,0,0" TextWrapping =

texto "Wrap" = "célula fotovoltaica:" "Izquierda" VerticalAlignment = "top" />
<TextBlock x: Name = "textBlock2" HorizontalAlignment = "izquierda" Margen = "10,102,0,0"

TextWrapping = "Wrap" Text = "Potenciómetro:" VerticalAlignment = "top"
RenderTransformOrigin = "- 1.593, -0.469" /> <TextBlock x: Name = "txtThermistor"
HorizontalAlignment = "izquierda" Margen = "163,52,0,0" TextWrapping = texto "Wrap" = "-"
VerticalAlignment = "top" />
<TextBlock x: Name = "txtPhoto" HorizontalAlignment = "izquierda" Margen =

"163,77,0,0" TextWrapping = texto "Wrap" = "-" VerticalAlignment = "top" />
95
<TextBlock x: Name = "txtPot" HorizontalAlignment = "izquierda" Margen =

"163,102,0,0" TextWrapping = texto "Wrap" = "-" VerticalAlignment = "top" />
</ Cuadrícula>
El siguiente paso es modificar nuestros códigos en MainPage.xaml.cs. En primer lugar, añadimos las bibliotecas necesarias que
se utilizan en la aplicación.
usando System.Text;
usando Windows.ApplicationModel.Core; usando
Microsoft.Maker.Serial; usando
A continuación, se agregan variables para el procesamiento de Arduino y el módulo PCF8591 AD / DA. También definimos la
variable, llamada i2cReading, como la recogida de cola, que se utiliza para almacenar la lectura de datos desde el módulo. En el proceso
de lectura, se implementa un método asíncrono, por lo que utilizar un temporizador a través de DispatcherTimer objeto para leer los
datos del sensor en un tiempo continuo.

RemoteDevice privado;
byte private const NUM_DIGITAL_PINS = 14; // Arduino Uno privada bytes
const SDA = 4; byte const SCL privada = 5;
privada PCF8591 byte = const (0x90 >> 1); // Dispositivo dirección de byte private const
PCF8591_ADC_CH0 = 0x40; // termistor privada bytes const PCF8591_ADC_CH1 = 0x41;
// fotovoltaica celda privada bytes const PCF8591_ADC_CH2 = 0x42;
const byte PCF8591_ADC_CH3 privada = 0x43; // potenciómetro int index privado

= 0;
Cola privada <int> = i2cReading nueva cola <int> (); isReading bool
privado;
temporizador DispatcherTimer privado;
En el constructor, inicializamos nuestra biblioteca MEF. Hemos establecido todos los pines que se utilizan para la aplicación
I2C. Cambio de valores “PID_0043” para su Arduino USB, lo que hemos aprendido “VID_2341” y.
this.InitializeComponent (); this.Unloaded + =

MainPage_Unloaded;
InitWRA (); }
96
connection.end ();
conexión = new usbserial ( "VID_2341", "PID_0043"); Arduino = new

RemoteDevice (conexión);

Una vez que la aplicación está conectada a USB, activamos nuestra hora de comienzo para leer datos de un módulo
PCF8591 AD / DA. datos I2C está viniendo I2cReplyEvent evento después de que denominamos Readadc () método.
System.Diagnostics.Debug.WriteLine ( "conectado"); arduino.pinMode

(NUM_DIGITAL_PINS + SDA, PinMode.I2C); arduino.pinMode
(NUM_DIGITAL_PINS + SCL, PinMode.I2C);
index = 0;
temporizador = new DispatcherTimer ();

Timer.Interval = TimeSpan.FromMilliseconds (2000); timer.Tick + =
Timer_Tick; timer.Start ();
I2c_I2cReplyEvent private void (address_ byte, el byte REG_, Windows.Storage. Streams.DataReader

respuesta) {
byte [] datos = new byte [2];

response.ReadBytes (datos); int curr =
i2cReading.Dequeue (); UpdateData (curr, los
datos [1]);
System.Diagnostics.Debug.WriteLine ( "" + Convert.ToString (address_) + "-"
+ curr.ToString () + ":" + BitConverter.ToString (datos)); isReading = false; }
97
Timer_Tick private void (remitente del objeto, objeto e) {
si (isReading)
regreso;
isReading = true;
interruptor (índice) {
caso 0:
i2cReading.Enqueue (index);
System.Diagnostics.Debug.WriteLine ( "PCF8591_ADC_CH0"); Readadc
(PCF8591_ADC_CH0); descanso; caso 1:
(PCF8591_ADC_CH1); descanso; caso 2:
(PCF8591_ADC_CH2); descanso;
}
índice ++;
si (índice> 2)
index = 0;
El último paso es definir Readadc () métodos. En este método, hacemos posible que el modo I2C y enviar datos al bus I2C para
recuperar datos desde el módulo. Cada resultado de la lectura se almacena en el objeto de cola. Para actualizar los datos en la interfaz
de usuario, definimos Actualizar datos() método. Ponemos en práctica el método asíncrono porque trabajamos en modo asíncrono por lo
que debemos realizar para cruzar entre las roscas.
readadc anular (byte de configuración) {
arduino.I2c.enable ();
arduino.I2c.I2cReplyEvent + = I2c_I2cReplyEvent;
arduino.I2c.beginTransmission (PCF8591);
arduino.I2c.write (config); arduino.I2c.endTransmission
();
arduino.I2c.requestFrom (PCF8591, 2);
98
UpdateData privadas asíncronas void (int index, valor de byte) {
esperan CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync (Windows.

UI.Core.CoreDispatcherPriority.Normal,
() => {
interruptor (índice) {
caso 0:
txtThermistor.Text = Convert.ToString (valor); descanso; caso
1:
txtPhoto.Text = Convert.ToString (valor); descanso; caso

2:
txtPot.Text = Convert.ToString (valor); descanso; }});
Guarde todos los códigos.
Pruebas
Ahora puede compilar el programa. En primer lugar, implementar el programa y luego ejecutarlo. Debería ver la información de
termistor, fotovoltaicos y el potenciómetro. Se puede ver en la figura 4-25 .
Figura 4-25. I2C aplicación se está ejecutando
99
Windows remoto Arduino mediante tecnología Bluetooth

En la sección anterior, se accede a través de Arduino Arduino remoto de Windows a través de cable USB. En esta sección,
se aprende a acceder Arduino a través de Bluetooth. Con el fin de trabajar con Windows Arduino remoto a través de
Bluetooth, necesitamos dos dispositivos Bluetooth para Arduino y el ordenador. Para la placa Arduino, se puede utilizar
cualquier módulo Bluetooth de serie, tales como plata mate Sparkfun Bluetooth. Puede revisar y comprar este módulo
Bluetooth
https://www.sparkfun.com/products/12576 . La forma de plata mate Sparkfun Bluetooth se puede ver en la
figura 4-26 .
Figura 4-26. Plata mate Sparkfun Bluetooth
Para una demostración, utilizo una serie de Bluetooth barato: HC-06. Este módulo está disponible en las tiendas en línea
como eBay, Aliexpress, y Banggood. Se puede ver en la figura 4-27 . módulo Bluetooth HC-06 tiene cuatro pines: Tx, Rx, VCC,
GND y.
100
Figura 4-27. módulo HC-06 de Bluetooth
En el lado del ordenador, es necesario un dispositivo Bluetooth que sea compatible con el módulo Bluetooth de
Arduino. Varios ordenadores por lo general han incorporado Bluetooth 4.0, por lo que puede usar eso. Para las pruebas,
yo uso un módulo externo USB Bluetooth 4.0. Puede comprobarlo en https://www.adafruit.com/product/1327 . Sólo tiene
que conectarlo a su ordenador. Entonces, el equipo debe reconocerlo.
En esta sección, vamos a utilizar el mismo grupo demográfico como la primera demostración en este capítulo: iluminación LED
mediante la aplicación UWP. Esta demo utilizará un módulo Bluetooth para la comunicación entre una placa Arduino y un ordenador.
Para las pruebas, yo uso HC-06 de Bluetooth para Arduino y Bluetooth 4.0 USB (RSE) para mi equipo. Vamos a
controlar LEDs para ser encendido / apagado. la comunicación Bluetooth entre Arduino y el ordenador se realiza
mediante Windows Arduino remoto.
Cableado para la ERH con Bluetooth

Ahora se puede conectar Bluetooth y LEDs para una placa Arduino. En general, Bluetooth HC-06 tiene cuatro pines: Tx, Rx,
VCC, GND y. Por lo tanto, en nuestro cableado, se implementa de la siguiente manera:
• HC-06 Tx pin está conectado a Arduino Rx pin (pin digital 0).
• HC-06 pin Rx está conectado a Arduino Tx pin (pin digital 1).
• HC-06 pin VCC está conectado al pin Arduino 3.3V.
• HC-06 pin GND está conectado al pin Arduino GND.
• LED 1, LED 2, y el LED 3 están conectados a Arduino pin digital 12, 11 y 10.
Se puede ver mi implementación de cableado, como se muestra en la figura 4-28 .
101
Figura 4-28. Cableado para HC-06, LED y Arduino Uno
El emparejamiento de Arduino Bluetooth y ordenador
El siguiente paso consiste en emparejar Arduino Bluetooth Bluetooth a la computadora para que puedan comunicarse
entre sí. Después de que la placa Arduino está activada, el módulo Arduino Bluetooth (HC-06) emitirá señales de
Bluetooth. En el lado del ordenador, hay que encender el dispositivo Bluetooth, también.
En Windows 10, podemos ver un cuadro de diálogo Administrar dispositivo Bluetooth en Ajustes. Debería ver nuestra
Arduino Bluetooth en este panel. Usted puede ver mi HC-06 de Bluetooth, que se reconoce en mi escritorio de Windows 10
en la figura 4-29 .
102
Figura 4-29. Asociar dispositivo Bluetooth en Windows 10 escritorio
Puede emparejar HC-06 de Bluetooth con Bluetooth ordenador. La clave por defecto para el emparejamiento de HC-06 es 1234.
Después de que se empareja, debería ver Arduino Bluetooth en el Administrador de dispositivos. Por ejemplo, mi HC-06 se reconoce como
HC-06 en Administrador de dispositivos, que se muestra en la figura 4-30 .
103
Figura 4-30. Paired Bluetooth HC-06 se muestra en el Administrador de dispositivos
Utilizando Visual Studio 2015, puede crear un nuevo proyecto con una plantilla en blanco Aplicación (Universal Windows). Por
ejemplo, el nombre del proyecto es “BlinkingLedBL”. Después de eso, instale la biblioteca Arduino remoto de Windows. A
continuación, también debe configurar el paquete. appxmanifest archivo de capacidad adicional para acceder a Bluetooth USB.
Puede escribir estos códigos en negrilla de la siguiente manera:
Capacidades <>
<DeviceCapability Name = "bluetooth.rfcomm"> <Device Id =
"any">
<Función Tipo = "Nombre: SERIALPORT" /> </ dispositivo>
</ Capacidades>
Guardar este programa. El siguiente paso es escribir un programa .NET Arduino y.
104
Escribir un programa de Arduino

Para trabajar con un programa UWP, se debería instalar un programa Firmata Skecth en Arduino. Seleccionar
StandardFirmata. A continuación, parpadeará el programa Firmata Boceto en la placa Arduino. Antes de realizar
intermitente Firmata Boceto, debe conectar el módulo Bluetooth desde Arduino. Puesto que el módulo Bluetooth utiliza
Arduino UART, no podemos cargar el programa a una placa Arduino. Después de completar parpadeo, se podría conectar
el módulo Bluetooth de nuevo a una placa Arduino.
Escribir un programa UWP

Básicamente, desarrollamos BlinkingLedBL como BlinkingLed, pero este programa utiliza Bluetooth para la
comunicación entre la placa Arduino y el ordenador.
Construir su interfaz de usuario de aplicación como la aplicación BlinkingLed. A continuación, modificamos el archivo
MainPage.xaml.cs. Nos basta con sustituir el tipo de clase conexión variable. declaramos
conexión variable como BluetoothSerial.
pública sellada MainPage clase parcial: Página {
BluetoothSerial conexión privada;

Arduino RemoteDevice privado; const
byte LED1 privado = 12; const byte LED2
privado = 11;
En InitWRA () método, se modifica para instanciar el objeto BluetoothSerial pasando un nombre de dispositivo Bluetooth
emparejado. Debe cambiar la velocidad en baudios también. En este caso, el dispositivo Bluetooth utiliza la tasa de baudios 9600.
conexión = new BluetoothSerial ( "Dev B"); // HC-06

Arduino = new RemoteDevice (conexión);
connection.ConnectionEstablished + = Connection_ConnectionEstablished;
connection.ConnectionFailed + = Connection_ConnectionFailed; connection.ConnectionLost + =
Connection_ConnectionLost;
connection.begin (9,600, 0);
Se puede ver que el objeto BluetoothSerial necesita un nombre de serie Bluetooth. Por ejemplo, mi módulo HC-06 se
reconoce con el nombre “Dev B”. ¿Cómo conseguir este nombre? En primer lugar, abrir la propiedad de la Bluetooth
emparejado en el equipo. Una muestra de un Bluetooth emparejado se muestra en la figura 4-31 .
105
Figura 4-31. Propiedad de Bluetooth emparejado en Windows 10
Hacer clic puertos COM propiedad. Debería ver un Bluetooth emparejado. Muestra COM entrante y saliente.
Se puede observar en la figura 4-32 . Se puede ver “Dev B” para COM de salida, que se utiliza en nuestra aplicación.
106
Figura 4-32. puertos COM para Bluetooth emparejado
Pruebas
Ahora puede probar el programa después de que se compila y se despliega. Puede activar el LED con la comprobación
de la caja. Debe ver la iluminación LED.
Resumen
En este capítulo, hemos aprendido cómo construir programas de Windows remoto Arduino (MEF) en la plataforma de Windows
universal. Empezamos desde el control digital y analógica de E / S hasta que el acceso a Arduino a través del bus I2C. También
aprendimos cómo configurar MEF a través de Bluetooth, por lo que podemos controlar Arduino de una pila de Bluetooth basados en
programas UWP. En el siguiente capítulo, vamos a explorar cómo nuestra Arduino interactúa con un servidor de la nube.
107
CAPÍTULO 5
Construcción de su propio IO Uso de

Arduino y .NET
En general, Internet de las Cosas (IOT) juntas han limitado almacenamiento para almacenar los datos de los sensores. No podemos
guardar los datos de los sensores en el almacenamiento local. En este capítulo, se aprende cómo publicar nuestros datos del sensor
por lo que los datos pueden ser consumidos por otro sistema. Proponemos servidor web, servidor personalizado, y el servidor de la
nube para almacenar sus datos y la que publicamos, a partir de la forma de conectar la placa Arduino a una red de Internet y haciendo
datos de sensores y publicación. Varias técnicas para comunicarse con los servidores se introducen con varios protocolos de
comunicación. También vamos a aprender a interactuar entre una aplicación .NET y Arduino para comunicarse a través de una red.
En este capítulo vamos a explorar los siguientes temas:
• Introducción a la Internet de las cosas y Arduino
• Conexión a la red de Internet Arduino
• Acceso a Arduino través de la red de la aplicación .NET
• Ventanas Arduino remoto (MEF) a través de WiFi
• comunicación por RF para Arduino
• La construcción de la red LoRa para Arduino
• aplicación basada en ubicación para Arduino
• Arduino y servidor de la nube
Introducción a la Internet de las cosas y Arduino

IO es una tecnología reciente famosa. Construimos tablas que están conectados a una red de Internet. Cada tarjeta
tiene su propio propósito para conectar una red. Arduino, por defecto, no proporciona capacidades de red. De lo
contrario, varios tipos de placa Arduino Arduino como MKR1000, Arduino UNO WiFi, y Arduino YUN tienen
capacidades de red. Estas placas pueden comunicarse con otros a través de una red. Se puede ver la ilustración de
cómo se conecta a una red de Arduino en la figura 5-1 .
Capítulo 5 ■ La construcción de su propia IOT usando Arduino y .net
La Figura 5-1. Comunicación para la placa Arduino
En este capítulo, no entrar en detalles sobre la IO. Usted puede leer acerca de un concepto y la arquitectura de la IO y la
forma de construirlos. Lo que aprendemos en este capítulo es explorar cómo una placa Arduino se conecta a otro sistema a
través de una red.
pilas de red, tales como redes alámbricas e inalámbricas pueden ser utilizadas por las placas Arduino. Si una placa
Arduino no tiene capacidades de red, puede conectar la placa Arduino a una computadora o un mini-ordenador, como
Raspberry Pi, siendo una puerta de enlace. Este equipo se utiliza para enviar y recibir datos desde otro sistema.
En la siguiente sección, vamos a aprender cómo Arduino se conecta a una red de Internet y luego enviar datos a
un sistema de red.
Conexión a la red de Internet Arduino

Por defecto, las placas Arduino no tienen capacidad de conectividad. Sin embargo, algunos modelos de placas Arduino
Arduino como Yun, Arduino MKR1000, Arduino 101, y Arduino UNO WiFi tienen capacidad de conectividad. Como otro
enfoque para conectarse a una red de Internet, podemos utilizar escudos Arduino adicionales para que nuestra junta para
conectarse a una red externa. En esta sección, exploramos cómo una placa Arduino se conecta a una red.
Conexión a una red cableada

Podemos conectar nuestra placa Arduino a una red a través de Ethernet. Para aplicar esta capacidad, podemos
añadir escudo Ethernet, por ejemplo, Arduino Ethernet escudo 2 con PoE, que se muestra en la figura 5-2 . Este
escudo es fabricado por Arduino SRL. Puede encontrar este escudo en una tienda de electrónica. Lo puedes
comprar en el sitio web oficial, http: // www.arduino.org/products/shields/arduino-ethernet-shield-2 . También puede
comprar más barato el escudo del fabricante chino.
110
La Figura 5-2. Arduino Ethernet Shield 2 con PoE
Un protector de Ethernet es fácil de usar. Que acaba de conectar este escudo en una placa Arduino. También se
puede encontrar este escudo en el sitio web oficial o comprar un escudo de Ethernet del fabricante chino con precios
bajos. Tengo un escudo Arduino Ethernet que se adjunta en la placa Arduino UNO. Se puede ver en la figura 5-3 .
La Figura 5-3. Arduino UNO y el escudo de Ethernet
111
Para la prueba, se utiliza un bosquejo muestra de Arduino: WebServer. Se puede encontrar desde Arduino IDE en el menú
Archivo ➤ Ejemplos ➤ Ethernet ➤ Servidor web. Después de que se ha seleccionado, usted debe debe obtener el siguiente esquema:
# incluir <SPI.h>
# incluir <Ethernet.h>
// Introducir una dirección MAC y la dirección IP para el dispositivo de abajo. // La dirección

IP será dependiente de la red local: Byte mac [] = {
0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED};
// Dirección IP ip (192, 168, 1, 177);
// Inicializar la biblioteca de servidor Ethernet // con la dirección IP

y el puerto que desea utilizar // (puerto 80 es por defecto para
HTTP): servidor EthernetServer (80);
void setup () {
// Abrir las comunicaciones serie y esperar a que el puerto de abrir:
Serial.begin (9600); while (! Serial) {
; // espera para el puerto serie para conectar. Necesario para el puerto USB nativo solamente}
// inicia la conexión Ethernet y el servidor: Ethernet.begin (mac);

server.begin ();
Serial.print ( "servidor está en"); Serial.println

(Ethernet.localIP ()); }
void loop () {
// detectar clientes entrantes
cliente EthernetClient = server.available (); si (cliente) {
Serial.println ( "nuevo cliente");

// una solicitud HTTP termina con una línea en blanco
boolean currentLineIsBlank = true; while
(client.connected ()) {if (client.available ()) {char c =
client.read (); Serial.write (c);
// Si ha llegado hasta el final de la línea (recibido una nueva línea // caracteres) y la línea está
en blanco, la petición HTTP ha terminado, // por lo que puede enviar una respuesta
si (c == '\ n' && currentLineIsBlank) {
112
// enviar un client.println norma cabecera de respuesta

HTTP ( "HTTP / 1.1 200 OK"); client.println ( "Content-Type:
text / html");
client.println ( "Connection: close"); // la conexión se cerrará después de la finalización de
la respuesta
client.println ( "Refresh: 5"); // actualizar la página automáticamente cada 5 segundos
client.println ();
client.println ( "<! DOCTYPE HTML>");

client.println ( "<html>");
// salida el valor de cada pin de entrada analógica
for (int analogChannel = 0; analogChannel <6; analogChannel ++) {int sensorReading =
analogRead (analogChannel); client.print ( "entrada analógica"); client.print
(analogChannel); client.print ( "es"); client.print (sensorReading); client.println ( "/> <br"); }
client.println ( "</ html>"); descanso; }
si (c == '\ n') {
// vas a empezar una nueva línea
currentLineIsBlank = true; } Else if (c! = '\
R') {
// que ha llegado a un personaje en la línea actual
currentLineIsBlank = false; }}}
// dar tiempo al navegador web para recibir el retraso de datos (1);
// cerrar la conexión: client.stop ();
Serial.println ( "el cliente está desconectado"); }}
Guardar este programa. Intente compilar y cargar el programa Boceto de una placa Arduino. Asegúrese de que
su escudo de Ethernet está conectado a un cable de red.
Por defecto, el programa se ejecuta como cliente DHCP para recuperar una dirección IP. Su red debe tener un
servidor DHCP en la red. Se puede utilizar un router que está conectado a una red.
Después de ejecutar el programa, Serial Monitor abierta para ver la dirección IP de su Arduino. Usted puede ver
mi dirección IP de mi Arduino UNO, como se muestra en la figura 5-4 .
113
La Figura 5-4. Dirección IP en pantalla herramienta Monitor de serie
Después de conocer la dirección IP de la placa Arduino, puede abrir un navegador y vaya a la dirección IP de
Arduino. Si tiene éxito, debería ver información acerca de entrada analógica en A0 ... A5. Se puede ver la salida de la
muestra en la figura 5-5 .
Figura 5-5. información analógica de Arduino sobre el navegador
Conexión a una red Wi-Fi

Conectar una placa Arduino a una red cableada hace su tablero incapaz de moverse en cualquier lugar debido a que la
junta debe estar conectado a una red a través de un cable. Si quieres que tu placa Arduino puede colocar en cualquier
área determinada, se puede considerar la conexión de la placa Arduino a una red WiFi.
Como he explicado, por defecto, placa Arduino no tiene un módulo Wi-Fi. Hay que añadir un Escudo WiFi (por
ejemplo, Arduino Yun Shield), que se muestra en la figura 5-6 . También podríamos utilizar Arduino MKR1000 para
conectar la red Wi-Fi existente. Arduino MKR1000 tiene un módulo WiFi incorporado. Puede revisar este tablero en
este sitio: https: // www.arduino.cc/en/Main/ArduinoMKR1000 .
114
Figura 5-6. Arduino Yun Escudo
También puede utilizar las placas Arduino como Arduino Arduino Yun y MKR1000, que están listos para la conexión
Wi-Fi. Puede utilizar Arduino Yun del blindaje por una placa Arduino ( https://www.arduino.cc/en/Main/ArduinoYunShield ), como
se muestra en la figura 5-6 . Para las pruebas, yo uso Arduino MKR1000 para mostrar cómo una placa Arduino se conecta a la
tienda picante WiFi existente.
Con el fin de Arduino MKR1000 para trabajar con el software de Arduino, hay que instalar
Juntas Samd Arduino. Puede abrir el Administrador de Juntas y buscar “Juntas Samd Arduino”. Si se detecta,
puede instalarlo. Se puede ver en la figura 5-7 . Asegúrese de que su ordenador ya está conectado a una red
de Internet.
La Figura 5-7. Activar el software de Arduino para Arduino MKR1000
115
Una vez instalado, se puede conectar Arduino MKR1000 a su ordenador. Usted puede ver mi Arduino MKR100
conectado a mi equipo, como se muestra en la figura 5-8 .
Figura 5-8. Arduino conectarse a un ordenador MKR1000
Después de Arduino MKR1000 está conectado a un ordenador con sistema operativo Windows, se puede ver el tablero será
reconocido como COMx. Mi placa Arduino MKR1000 se detecta como COM7, que se muestra en la figura 5-9 .
116
Figura 5-9. Arduino MKR1000 es reconocido como COM7 en Administrador de dispositivos
El siguiente paso es empezar a construir un programa. Con el fin de acceder a una red Wi-Fi, necesitamos una biblioteca de conexión
Wi-Fi para la placa Arduino MKR1000. Podemos utilizar la biblioteca WiFi101. Puede instalar la biblioteca WiFi101 desde el Administrador de
Biblioteca. Encontrar e instalar la biblioteca WiFi101. Esto se puede ver en la figura biblioteca 5-10 .
117
Figura 5-10. Instalar la biblioteca WiFi101 para Arduino MKR1000
Construimos un programa Boceto para hacer que la placa Arduino MKR1000 conectarse a una red Wi-Fi existente. Por
ejemplo, nos conectamos a un punto de acceso WiFi con seguridad WPA. Para la prueba, se puede utilizar una muestra del
programa de Arduino Software, ConnectWithWPA.
Después de cargar el programa Boceto para ConnectWithWPA, puede modificar los valores de SSID y pasar por el
WiFi SSID y la clave WiFi. Se puede ver el siguiente programa Boceto:
# incluir <SPI.h>
# incluir <WiFi101.h>
Char SSID [] = "wifi"; // el SSID de la red (nombre)

Char pasar [] = "wifi_key"; // la contraseña de red
int estado = WL_IDLE_STATUS; // el estado de la radio Wi-Fi
void setup () {
// Inicializar serie y esperar a que el puerto de abrir: Serial.begin
(9600); while (! Serial) {
; // espera para el puerto serie para conectar. Necesario para el puerto USB nativo solamente}
// comprobar la presencia de la pantalla: if (WiFi.status () ==

WL_NO_SHIELD) {Serial.println ( "escudo WiFi no
presentan"); // no continúe: while (true); }
118
// intento de conectarse a la red Wi-Fi: tiempo (estado

= WL_CONNECTED!) {
Serial.print ( "Si intenta conectarse a WPA SSID:"); Serial.println (SSID);
// conectarse a la red / WPA2 WPA: status =

(, pasar SSID) WiFi.begin;
// esperar 10 segundos para la conexión: retardo

(10000); }
// que estés conectado ahora, para imprimir los datos: Serial.print (

"Usted está conectado a la red"); printCurrentNet (); printWifiData ();
void loop () {
// comprobar la conexión de red una vez cada 10 segundos: de retardo (10
000); printCurrentNet (); }
printWifiData vacío () {
// imprimir la dirección IP de su escudo WiFi: Dirección
IP ip = WiFi.localIP (); Serial.print ( "Dirección IP:");
Serial.println (ip); Serial.println (ip);
// imprimir su dirección MAC: Mac

byte [6];
WiFi.macAddress (mac);
Serial.print ( "dirección MAC:"); Serial.print
(mac [5], HEX); Serial.print ( ":");
Serial.print (mac [4], HEX); Serial.print (
":"); Serial.print (mac [3], HEX); Serial.print
( ":"); Serial.print (mac [2], HEX);
Serial.print ( ":"); Serial.print (mac [1],
HEX); Serial.print ( ":");
Serial.println (mac [0], HEX);
119
printCurrentNet vacío () {
// imprimir el SSID de la red a la que está conectado a: Serial.print (
"SSID:"); Serial.println (WiFi.SSID ());
// imprimir la dirección MAC del router que está conectado a: BSSID byte [6];
WiFi.BSSID (BSSID); Serial.print ( "BSSID:"); Serial.print (BSSID [5], HEX);
Serial.print ( ":");
Serial.print (BSSID [4], HEX);

Serial.println (BSSID [0], HEX);
// imprimir la intensidad de señal recibida: long RSSI

= WiFi.RSSI ();
Serial.print ( "intensidad de la señal (RSSI):");
Serial.println (RSSI);
// imprimir el tipo de cifrado:

cifrado byte = WiFi.encryptionType (); Serial.print ( "Tipo
de cifrado:"); Serial.println (cifrado, HEX); Serial.println ();
}
Guardar el programa. Ahora puede compilar y cargar el programa a Arduino MKR1000. Abra la herramienta
Monitor de serie para ver la dirección IP de Arduino MKR1000. Usted puede ver mi muestra de salida bordo en la figura 5-11
.
120
Figura 5-11. La salida del programa en el monitor de serie
Si tiene problemas en Arduino MKR1000, es posible actualizar el módulo Wi-Fi en Arduino MKR1000.
Puede seguir estas instrucciones para actualizar el firmware de Arduino MKR1000: https://www.arduino.cc/en/Tutorial/Firmware
.
Acceso a Arduino a través de una red de Aplicación .NET
En la sección anterior, hemos aprendido cómo hacer que nuestras placas Arduino conectarse a una red existente a través
de Ethernet y un módulo Wi-Fi. Ahora tratamos de construir una aplicación .NET para acceder a las placas Arduino sobre el
aire.
Nuestro escenario es construir una aplicación .NET (aplicación UWP) para controlar LED a través de WiFi. Utilizamos Arduino
MKR1000 como una placa de desarrollo. Para construir nuestro laboratorio, necesitamos los siguientes dispositivos:
• Arduino MKR1000
• tres LED
• Computadora con Windows instalado y Visual Studio 2015 o con posterioridad Vamos a encender / apagar los LEDs a
través de Wi-Fi desde una aplicación UWP. Aplicamos HTTP GET para encender / apagar los LEDs. Se puede ver nuestra asignación de
dirección URL HTTP GET para la demostración en la tabla 5-1 . Ponemos en práctica este mapeo URL para nuestra demostración.
121
Tabla 5-1. Peticiones HTTP GET para encender / apagar los LED
URL Nota
http: // <IP Arduino> / GPIO1 / 1 Encienda el LED 1
http: // <IP Arduino> / GPIO1 / 0 Desactivar LED 1
http: // <IP Arduino> / GPIO2 / 1 Encienda el LED 2
http: // <IP Arduino> / GPIO2 / 0 Apague el LED 2
http: // <IP Arduino> / GPIO3 / 1 Encienda LED 3
http: // <IP Arduino> / GPIO3 / 0 Desactivar LED 3
Para llevar a cabo nuestro programa, vamos a construir un programa de dibujo y una aplicación UWP. Necesitamos un
programa de dibujo con el fin de interactuar con una aplicación externa, como una aplicación UWP. El programa de esbozo
escuchará los comandos de entrada (HTTP GET) para ser ejecutado. Por otra parte, una aplicación UWP es una aplicación
cliente que envía comandos a Arduino para realizar algo.
Vamos a empezar a desarrollar.
Alambrado
El siguiente es el cableado de demostración:
• LED 1 está conectado al pin digital 5 de Arduino MKR1000.
• LED 2 está conectada a pin digital 4 de Arduino MKR1000.
• LED 3 está conectado al pin digital 3 de Arduino MKR1000.
• Todos los pines GND LED están conectados al pin GND en el tablero. Si va a preocuparse por sus LEDs, se
puede poner una resistencia en cada LED para evitar un alto voltaje. Se puede ver el cableado en la figura 5-12 .
122
Figura 5-12. Cableado para los LED y Arduino MKR1000
Se puede ver mi implementación de cableado, como se muestra en la figura 5-13 . Tres LEDs son
unido a una placa Arduino MKR1000.
123
Figura 5-13. implementación de cableado para los LED y MKR1000
La construcción de un Programa Boceto
Construimos un programa Boceto para recibir comandos para activar / desactivar el LED basado en la asignación de URL,
que se describe en la tabla 5-1 . Puede escribir los guiones de software de Arduino:
int LED1 = 5; int

LED2 = 4; int
LED3 = 3;
const char * SSID = "SSID"; const char *

password = "ssid_key"; int estado =
WL_IDLE_STATUS;
servidor WiFiServer (80);
void setup () {
Serial.begin (9600); de
retardo (10);
124
// preparar GPIO5 pinMode

(LED1, OUTPUT); pinMode
(LED2, OUTPUT); pinMode
(LED3, OUTPUT); digitalWrite
(LED1, 0); digitalWrite (LED2,
0); digitalWrite (LED3, 0);
// conectarse a la red Wi-Fi, mientras que

(estado! = WL_CONNECTED) {
Serial.print ( "intento de conectar con el SSID:"); Serial.println
(SSID);
estado = WiFi.begin (SSID, contraseña);
// esperar 10 segundos para la conexión: retardo

(10000); }
Serial.println ( "");
Serial.println ( "WiFi conectado");
// Iniciar la server.begin
servidor ();
Serial.println ( "Servidor comenzó");
// Imprimir las ips de char

dirección IP [24];
Dirección IP ip = WiFi.localIP ();
sprintf (ips, "..% d% d% d% d", ip [0], ip [1], ip [2], ip [3]); Serial.println (ips); }
void loop () {
// Comprobar si un cliente se ha conectado WiFiClient
cliente = server.available (); si (cliente!) {return; }
// Espera hasta que el cliente envía algunos datos

Serial.println ( "nuevo cliente"); mientras {retardo (1)
(client.available ()!); }
// Leer la primera línea de la req solicitud String =

client.readStringUntil ( '\ r'); Serial.println (req); client.flush
();
125
// coincidir la solicitud int

val1 = 0; int val2 = 0; int val3
= 0; int ledreq = 0;
si (req.indexOf ( "/ GPIO1 / 0") = -1) {val1 = 0;

ledreq = 1; }
else if (req.indexOf ( "/ GPIO1 / 1") = -1) {val1 = 1; ledreq

= 1; }

= 2; }

= 2; }

= 3; }

= 3; }
else {
Serial.println ( "petición no válida"); client.stop ();
regreso; }
// Establecer GPIO2 de acuerdo con la solicitud si (ledreq

== 1)
digitalWrite (LED1, val1); si (ledreq
== 2)
digitalWrite (LED2, val2); si (==
ledreq 3)
digitalWrite (LED3, val3);
client.flush ();
// Preparar la respuesta
String s = "HTTP / 1.1 200 OK \ r \ nContent-Type: text / html \ r \ n \ r \ n \ r \ n <html> \ r \ n <HTML!
DOCTYPE>";
126
si (ledreq == 1) {s + =
"LED1 es";
s + = (val1)? "ENCENDIDO APAGADO";
} Else if (ledreq == 2) {s + = "LED2 es";
s + = (val2)? "ENCENDIDO APAGADO";

} Else if (ledreq == 3) {s + = "LED3 es";
s + = (val3)? "ENCENDIDO APAGADO"; }
s + = "</ html> \ n";
// Enviar la respuesta a la client.print (s) cliente;

retardo (1); client.stop ();
Serial.println ( "Cliente disonnected");
Debe cambiar el SSID y ssid_key de SSID y la clave SSID. Guardar estos scripts como “IoTDemo”. Intente compilar y
cargar un programa en Croquis para Arduino MKR1000. Si se hace, se puede abrir una herramienta Monitor de serie para ver
la dirección IP de Arduino MKR1000. Usted puede ver mi dirección IP de la junta en la figura 5-14 .
Figura 5-14. La herramienta de seguimiento de serie muestra la dirección IP para Arduino MKR1000
127
Ahora puede probar mediante la apertura de un navegador. Navegar a http: // <servidor> / GPIO1 / 1 para encender el LED
de 1. Debe cambiar <servidor> a la dirección IP de Arduino MKR1000.
Si tiene éxito, debería ver una respuesta de Arduino MKR1000. Para una muestra, se puede ver una respuesta
de mi Arduino, que se muestra en la figura 5-15 .
Figura 5-15. Respuesta de Arduino en un navegador
Se puede ver su iluminación LED para el LED 1 en la figura 5-16 mientras que usted está enviando un comando para activar
el LED 1.
Figura 5-16. LED 1 es iluminación
128
Si abre herramienta Monitor de serie de Arduino, debería ver las solicitudes de Arduino MKR1000. Se puede
ver que es una salida del programa, que se muestra en la figura 5-17 .
Figura 5-17. Respuesta de Arduino en la herramienta de seguimiento de serie
La construcción de una aplicación UWP
En esta sección, desarrollamos una aplicación UWP. Este programa funcionará como una “aplicación cliente”, que envía comandos
a Arduino para encender / apagar los LED. Nuestro programa de dibujo en Arduino funciona como un servidor web que recibe
comandos HTTP GET.
Crear un proyecto UWP con el nombre del proyecto “WiFiLed”. Luego construir la siguiente interfaz de usuario. Se puede ver nuestra
interfaz de usuario, como se muestra en la figura 5-18 .
129
Figura 5-18. Diseño de interfaz de usuario para la aplicación WiFiLed
Nosotros ponemos Caja de texto y Interruptor de palanca en un lienzo de la interfaz de usuario. Puede escribir las siguientes
secuencias de comandos para construir nuestra interfaz de usuario:
<Página
x: Class = "WiFiLed.MainPage"
"http://schemas.microsoft.com/winfx/2006/xaml" xmlns: Local = "usando: WiFiLed "


<TextBox x: Name = "txtIP" HorizontalAlignment = "izquierda" Margen =
"32,35,0,0" TextWrapping = texto "Wrap" = "" VerticalAlignment = "top"
width = "194" />
<TextBlock x: Name = "textBlock" HorizontalAlignment = "izquierda" Margen = "32,10,0,0"
TextWrapping = texto "Wrap" = "Dirección IP Arduino MKR1000" VerticalAlignment = "top" />
<ToggleSwitch x: Name = "toggleLed1" Header = "LED 1" HorizontalAlignment =

"izquierda" Margen = "32,87,0,0" VerticalAlignment = "top" width = "94" toggled =
"ToggleLed1" />
130
<ToggleSwitch x: Name = "toggleLed2" Header = "Led 2" HorizontalAlignment = "izquierda" Margen =

"32,147,0,0" VerticalAlignment = "top" toggled = "ToggleLed2" /> <ToggleSwitch x: Name =
"toggleLed3" Header = "Led 3" HorizontalAlignment = "izquierda" Margen = "32,212,0,0"
VerticalAlignment = "top" toggled = "ToggleLed3" /> <TextBlock x: Name = "txtStatus"
HorizontalAlignment = Margen de "izquierda" = "32277 , 0,0" TextWrapping = "" Text = "recapitulación
listo" VerticalAlignment = "top" width = "253" FocusVisualPrimaryBrush = "# FFD71C 1C" primer plano
= "# FFEE2121" />
</
Ahora trabajamos en MainPage.xaml.cs. En primer lugar, añadimos nuestro espacio de nombres requisito para nuestro programa.
usando Windows.Web.Http;
Si ve guiones XAML, se pasa a un método en un evento de activar y desactivar. Construimos tres métodos: ToggleLed1,
ToggleLed2, y ToggleLed3. Estos métodos son escuchar el estado del LED. Si están alternados, encendemos el LED.
La siguiente es la aplicación de estos métodos:
private void ToggleLed1 (remitente del objeto, RoutedEventArgs e) {
cadena SVR = txtIP.Text;

string url = string.Format ( "http: // {0} / GPIO1 / 0", SVR); int estado = 0;
si (toggleLed1.IsOn) {
url = string.Format ( "http: // {0} / GPIO1 / 1", SVR); STATE = 1; }
SendCommand (url);
UpdateStatus (1, estado); }

131
SendCommand (url);
UpdateStatus (2, estado); }

SendCommand (url);
UpdateStatus (3, Estado); }
Como se puede ver, que llamamos cada método Biestado SendCommand () para enviar datos a Arduino y MKR1000 Estado de
actualización() para actualizar nuestra interfaz de usuario. La siguiente es nuestra aplicación:
private void UpdateStatus (int llevado, estado int) {
si (== estado 1)
txtStatus.Text = string.Format ( "LED {0} es ON", LED); más
txtStatus.Text = string.Format ( "LED {0} es OFF", LED); }
asíncrono vacío sendCommand (String url) {privado
HttpClient HttpClient = new HttpClient (); cabeceras var =

httpClient.DefaultRequestHeaders;
Uri uri = new RequestURI (url);

HttpResponseMessage HTTPResponse = new HttpResponseMessage ();
tratar
// enviar la solicitud GET
132
HTTPResponse = esperar httpClient.GetAsync (RequestURI, HttpCompletion

Option.ResponseHeadersRead); httpResponse.EnsureSuccessStatusCode ();
}
catch (Exception ex) {
System.Diagnostics.Debug.WriteLine (ex.Message); }
Guarde todos los programas. También puede añadir capacidades adicionales en una solicitud de UWP. Añadir una internetClient característica
en nuestra aplicación.
Capacidades <> < Capacidad de Name = "internetClient"

/>
</ Capacidades>
Pruebas
Guardar el proyecto UWP. A continuación, tratar de compilar y ejecutar el programa. Por favor, rellene la dirección IP de Arduino MKR1000.
Ahora se puede activar el LED de encendido / apagado haciendo clic en los controles de activar y desactivar.
Figura 5-19. WiFiLed aplicación se está ejecutando
133
Ventanas Arduino remoto (MEF) a través de WiFi

en el capítulo 3 , Aprendimos a trabajar con Windows Arduino remoto (MEF) a través de USB y Bluetooth. En esta
sección, tratamos de construir una aplicación uwp acceder a través de Arduino Arduino remoto de Windows a través de
WiFi.
Para la prueba, se utiliza una placa Arduino MKR1000. Vamos a utilizar el mismo problema de la sección anterior: que
encender / apagar los LEDs a través de WiFi.
¡Empecemos!
Configurar Arduino para MEF a través de WiFi

Para permitir que nuestra placa Arduino a ser controlado a través de WiFi, debe implementar un programa
StandardFirmataWiFi Boceto en el tablero. Lo puede encontrar en el menú Archivo ➤
Ejemplos ➤ firmata ➤ StandardFirmataWiFi. Entonces, usted debe ver el programa de esbozo, como se muestra en la figura 5-20 .
Figura 5-20. programa de esbozo para StandardFirmataWiFi
134
El siguiente paso es configurar los ajustes de Wi-Fi para Arduino. Lo configuramos en wifiConfig.h. Debido a que
utilizamos Arduino MKR1000, debe descomentar para WIFI_101. Debe cambiar SSID y la clave SSID. El puerto
predeterminado para el servidor es 3030. Puede cambiarlo si lo desea.
Figura 5-21. Configurar WiFi para boceto StandardFirmataWiFi
Si al terminar de configurar los ajustes Wi-Fi, puede compilar y cargar un programa Boceto en Arduino
MKR1000. Ahora su tablero está listo para recibir comandos desde una aplicación UWP.
La construcción de una aplicación UWP
Ahora se puede crear una aplicación uwp llamado “WiFiWRA” utilizando Visual Studio. Instalar MEF a través Nuget. Lea cómo
implementarlo en el capítulo 3 . Construimos una interfaz de usuario para una aplicación UWP, que se muestra en la figura 5-22 .
135
Figura 5-22. Construir la interfaz de usuario para la aplicación UWP
Construimos la misma interfaz de usuario como en la sección anterior, pero se añade un botón para conectar Arduino a
través de WiFi. Los siguientes scripts de XAML para la aplicación WiFiWRA:
<Página
x: Class = "WiFiWRA.MainPage"
"http://schemas.microsoft.com/winfx/2006/xaml" xmlns: Local = "usando: WiFiWRA "


<TextBox x: Name = "txtIP" HorizontalAlignment = "izquierda" Margen =
"32,35,0,0" TextWrapping = texto "Wrap" = "" VerticalAlignment = "top"
width = "194" />
TextWrapping = texto "Wrap" = "Dirección IP Arduino MKR1000" VerticalAlignment = "top" />
136
<ToggleSwitch x: Name = "toggleLed1" Header = "LED 1" HorizontalAlignment = "izquierda" Margen =

"32,87,0,0" VerticalAlignment = "top" width = "94" toggled = "ToggleLed1" /> <ToggleSwitch x: Name =
"toggleLed2" Header = "Led 2" HorizontalAlignment = Margen de "izquierda" = "32,147,0,0"
VerticalAlignment = "top" toggled = "ToggleLed2" /> <ToggleSwitch x: Name = "toggleLed3" Header =
"Led 3" de "izquierda" Margen HorizontalAlignment = = "32,212,0,0" VerticalAlignment = "top" toggled
= "ToggleLed3" /> <TextBlock x: Name = "txtStatus" HorizontalAlignment = Margen de "izquierda" =
"32,277,0 , 0" TextWrapping = "Wrap" Text = "Listo" VerticalAlignment = "top" width ="253"
FocusVisualPrimaryBrush = "# FFD71C 1C" primer plano = "# FFEE2121" />
<Botón x: Name = "botón" Content = "Conectar" HorizontalAlignment = "izquierda" Margen =

"231,35,0,0" VerticalAlignment = "top" Click = "ConnectToServer" />
<TextBlock x: Name = "txtServerState" HorizontalAlignment = "izquierda" de texto Margen =

"231,72,0,0" TextWrapping = "Wrap" = "No conectado" VerticalAlignment = "top"
FocusVisualPrimaryBrush = "# FFCE2E2E" primer plano =" # FFCA1A1A "/>
</
En MainPage.xaml.cs, añadimos códigos para capturar un evento hecho clic en el botón y alternar los controles. En primer lugar, se
añade un espacio de nombres necesario.

Microsoft.Maker.RemoteWiring; usando
Windows.Networking;
Añadimos varias variables para los tres LEDs. Escribir estos códigos:
NetworkSerial conexión privada; Arduino

RemoteDevice privado;
byte const LED1 privada = 5; byte

const LED2 privada = 4; byte const
LED3 privada = 3; byte privada
currentLed; currentState int privado;
137
Cuando se hace clic en el botón “Conectar”, tratamos de conectar a Arduino MKR1000 a través de WiFi. Después de que esté
conectado, establecemos el modo de patillas para tres LEDs. La siguiente es nuestra implementación del código:
ConnectToServer private void (object sender, RoutedEventArgs e) {
InitWRA (); }

conexión = new NetworkSerial (nuevo nombre de host (RVS), 3030); Arduino =
new RemoteDevice (conexión);
arduino.DeviceConnectionLost + = Arduino_DeviceConnectionLost;
connection.ConnectionEstablished + = Connection_ConnectionEstablished;
connection.ConnectionFailed + = Connection_ConnectionFailed;
connection.begin (115200, SerialConfig.SERIAL_8N1); }
private void Arduino_DeviceConnectionLost (mensaje de cadena) {
System.Diagnostics.Debug.WriteLine ( "Dispositivo es pérdida de conexión"); }
private void Connection_ConnectionFailed (mensaje de cadena) {
txtServerState.Text = "no conectado"; }
txtServerState.Text = "conectado";
System.Diagnostics.Debug.WriteLine ( "conectado");

En eventos conmutado, llevamos a cabo para encender / apagar los LED llamando Ejecutar() y
Estado de actualización() métodos.
138
currentState = 0;
si (toggleLed1.IsOn)
currentState = 1; currentLed
= 1;
Ejecutar();
UpdateStatus (1, currentState); }
currentState = 0;
= 2;
Ejecutar();

currentState = 0;
= 3;
Ejecutar();
Ejecutar() y Estado de actualización() métodos se utilizan para ejecutar su vez sobre los indicadores LED de encendido / apagado y
actualizar la interfaz de usuario de una aplicación UWP.
private void UpdateStatus (int llevado, estado int) {
si (== estado 1)
txtStatus.Text = string.Format ( "LED {0} es ON", LED); más
txtStatus.Text = string.Format ( "LED {0} es OFF", LED); }
139
Ejecutar private void () {
si (== currentState 1)
arduino.digitalWrite (currentLed, PinState.HIGH); más
arduino.digitalWrite (currentLed, PinState.LOW);
System.Diagnostics.Debug.WriteLine ( "comando escrito a Arduino"); }
Guardar el programa. También debe agregar capacidades en una aplicación uwp para acceder a
Internet.
Capacidades <>
<Capacidad Name = "internetClient" /> <Capacidad Name =
"internetClientServer" /> <Capacidad name =
"privateNetworkClientServer" /> </ Capacidades>
Pruebas
Ahora se puede ejecutar el programa. Rellene la dirección IP del Arduino MKR1000. A continuación, haga clic en el botón Conectar. Si está
conectado, se puede encender / apagar los LEDs haciendo clic en los controles toggled (figura 5-23 ).
Figura 5-23. Ejecución de la aplicación para el control de LED sobre WRA WiFi
140
La comunicación RF para Arduino

la comunicación RF es un clásico comunicación para que cada dato de cambio de entidad. Hay muchos módulos de
RF que se pueden aplicar a la placa Arduino. Hay muchos módulos de RF que pueden trabajar con la placa Arduino.
En esta sección, exploramos uno de los módulos de RF famosos, XBee IEEE 802.15.4. Este módulo se utiliza
generalmente para un área de red de sensores inalámbricos (WSN). La placa Arduino detecta su entorno físico y luego
envía los datos del sensor a una puerta de enlace. Se puede ver XBee 802.15.4 del IEEE en la figura 5-24 . Usted puede
leer acerca de este módulo en este sitio: https: // www.digi.com/products/xbee-rf-solutions/modules/xbee-802-15-4 .
Figura 5-24. XBee IEEE 802.15.4 de Digi International
Para adjuntar un módulo XBee, necesita un escudo XBee a Arduino. Por ejemplo, se puede utilizar un
escudo Arduino SD inalámbrica ( https://www.arduino.cc/en/Main/ ArduinoWirelessShield ). Esto se puede ver en
la figura escudo 5-25 .
141
Figura 5-25. Arduino SD Wireless Shield
En este apartado, construimos una aplicación XBee en Arduino y un ordenador. La aplicación Arduino XBee enviará un
número aleatorio a un ordenador a través de un módulo XBee. Para la prueba, construimos nuestra demo con los siguientes
elementos:
• Arduino
• escudo XBee para Arduino
• Dos dispositivos XBee IEEE 802.15.4
• módulo USB XBee
Como otra opción, puede utilizar el kit inalámbrico XBee de Sparkfun. Puede comprobar este producto en este
sitio: https://www.sparkfun.com/products/13197 . Esto se puede ver en la figura kit 5-26 .
142
Figura 5-26. Kit de Sparkfun XBee inalámbrico
Ahora tratamos de construir la comunicación de RF usando XBee 802.15.4 IEEE módulos de Arduino. Ponemos en práctica
una sencilla aplicación para enviar un número aleatorio. Necesitamos dos módulos XBee para demostración. Un módulo funcionará
como remitente. De lo contrario, funciona como un receptor. En la subsección siguiente, vamos a implementar nuestra demo.
Configuración de XBee IEEE 802.15.4

Para la aplicación de demostración, utilizo Arduino UNO con el escudo XBee y XBee módulo de IEEE 802.15.4 XBee con USB. Se
puede ver mis dispositivos de demostración en la figura 5-27 .
Figura 5-27. muestra de demostración para XBee y Arduino
143
Antes de conectar un módulo XBee en un escudo XBee, debemos configurar todos los módulos XBee.
Podemos utilizar una aplicación XCTU de Digi International. Puede descargarlo en https://www.digi.com/products/xbee-rf-solutions
.
Descargar e instalar este programa.
Ejecutar el programa XCTU. Coloque su módulo XBee en XBee USB para que el ordenador detecta los módulos. A
continuación, agregue un módulo XBee en XCTU. Se puede ver en la figura 5-28 . Debe establecer características XBee, que se
muestra en la tabla 5-2 . Si ha terminado, se ahorra haciendo clic en el Escribir incono para escribir estos valores en el firmware
XBee.
Figura 5-28. XBee configurar utilizando XCTU
144
Tabla 5-2. configuración XBee en la solicitud de XCTU
XBee Mdoule Caracteristicas
XBee 1 ID = 3001 MI
= 1 DL = 2
MM = 1 AP =
XBee 2 ID = 3001 MI
= 2 DL = 1
MM = 1 AP =
La construcción de un programa de Arduino Boceto
Básicamente, después de que configuramos nuestros módulos XBee 802.15.4 del IEEE en la sección anterior, los módulos se
pueden comunicar con otros en el modo transparente. Esto significa que cuando un módulo XBee difunde un mensaje en el
UART, otros módulos XBee recibirán este mensaje del UART. A partir de este escenario, construimos un programa Boceto para
enviar un número aleatorio a partir de Arduino a un ordenador a través de XBee IEEE 802.15.4. Se puede escribir el siguiente
programa Boceto:
largo randNumber;
void setup () {
Serial.begin (9600); randomSeed
(analogRead (0)); }
void loop () {
randNumber = aleatorio (20, 80);
Serial.println (randNumber); retardo
(2000); }
Guardar este programa como “XBeeArduino”. Compilar y cargar el programa a la placa Arduino.
Ahora puede adjuntar XBee 1 en un escudo XBee y luego poner el escudo en una placa Arduino. Además, XBee 2
está unido en XBee USB y luego enchufado en un ordenador. Usando la herramienta de monitor de serie, navegue esta
herramienta para el puerto serie al que está unido XBee USB. Debería ver un número entrante en la herramienta Monitor
de serie. Se puede ver en la figura 5-29 . Este valor proviene de Arduino.
145
Figura 5-29. La salida del programa de XBee en la herramienta Monitor de serie
La construcción de un Programa UWP
En este apartado, construimos un programa UWP. Este programa funcionará como el receptor XBee el que escucha los
mensajes entrantes desde un puerto serie del ordenador. Cuando se le concede el módulo XBee y ruptura del USB con el
fin de conectar a un ordenador mediante un cable USB. Usamos SerialDevice objeto para comunicarse con el puerto serie.
Ahora podemos crear un nuevo proyecto para una plantilla UWP, llamado “XBeeApp”. A continuación, construir una interfaz de usuario,
que se muestra en la figura 5-30 . Añadimos Cuadro de lista y Botón. XBee de datos se visualiza en texto.
Figura 5-30. Interfaz de usuario para la aplicación XBee UWP
146
La implementación de la interfaz de usuario XAML puede ser escrita en los siguientes guiones:
<Página
x: Class = "XBeeApp.MainPage"
"http://schemas.microsoft.com/winfx/2006/xaml" xmlns: Local = "usando: XBeeApp "


< ListBox x: Name = "listXBee" HorizontalAlignment = "izquierda" height = "100" Margen =
"10,45,0,0" VerticalAlignment = "top" width = "285">
<ListBox.ItemTemplate>
<DataTemplate>
<TextBlock Text = "{Binding} Nombre" /> </
DataTemplate> </ListBox.ItemTemplate> </ ListBox>

TextWrapping = texto "Wrap" = "XBee puerto serie Lista" VerticalAlignment = "top" />
<Botón x: Name = "btnConnect" content = "Conectar" HorizontalAlignment = "izquierda" Margen =

"10,165,0,0" VerticalAlignment = "top" Click = "ConnectToXBee" /> <Botón x: Name =
"btnDisconnect" contenido = "Desconectar" HorizontalAlignment = "izquierda" Margen =
"90,165,0,0" VerticalAlignment = "top" Click = "Desconectar" /> <TextBlock x: Name = "txtState"
HorizontalAlignment = Margen de "izquierda" = "188,177,0 , 0" TextWrapping = "Wrap" Text = "No
conectado" VerticalAlignment = "top" primer plano = "# FFCA1E1E" /> <TextBlock x: Name =
"textBlock1" HorizontalAlignment = "" Margen = "izquierda 10,225,0,0" TextWrapping = texto
"Wrap" = "Un valor de XBee:"VerticalAlignment = "top" />
<TextBlock x: Name = "txtValue" HorizontalAlignment = "izquierda" Margen =

"154,225,0,0" TextWrapping = texto "Wrap" = "- 0" VerticalAlignment = "top" />
</
En MainPage.xaml.cs, añadimos códigos. En primer lugar, se añade el espacio de nombres se requiere de la siguiente
manera:
usando System.Collections.ObjectModel; usando

Windows.Devices.Enumeration; usando
Windows.Devices.SerialCommunication;
147
usando Windows.Storage.Streams; usando

System.Threading; usando
System.Threading.Tasks;
A continuación, se agregan variables.
SerialDevice SERIALPORT privada = null; DataReader

privada dataReaderObject = null;
ObservableCollection privada <DeviceInformation> listUART;
ReadCancellationTokenSource CancellationTokenSource privado;
Recuperamos una lista de puertos serie, mientras que llamar en el constructor.
this.InitializeComponent ();
listUART = new ObservableCollection <DeviceInformation> (); GetListOfXBee ();
}
asíncrono GetListOfXBee private void () {
tratar
cadena aqs = SerialDevice.GetDeviceSelector (); DIS var = esperan

DeviceInformation.FindAllAsync (AQS);
for (int i = 0; i <dis.Count; i ++) {
listUART.Add (dis [i]); }
listXBee.ItemsSource = listUART;
listXBee.SelectedIndex = -1;
btnConnect.IsEnabled = true;
btnDisconnect.IsEnabled = false; }
System.Diagnostics.Debug.WriteLine (ex.Message); }}
148
Ponemos en contacto a XBee USB haciendo clic en el botón Conectar. Si desea desconectar de XBee USB, haga clic
en el botón Desconectar. Ponemos en práctica estos códigos:
ConnectToXBee privada async vacío (remitente del objeto, RoutedEventArgs e) {
selección var = listXBee.SelectedItems;
si (selection.Count <= 0) {
txtState.Text = "Seleccionar un puerto serie!"; regreso; }
entrada DeviceInformation = selección (DeviceInformation) [0];
tratar
SerialPort = esperan SerialDevice.FromIdAsync (entry.Id);
// Establecer la configuración de serie

serialPort.WriteTimeout = TimeSpan.FromMilliseconds (1000);
serialPort.ReadTimeout = TimeSpan.FromMilliseconds (1000);
serialPort.BaudRate = 9,600; serialPort.Parity = SerialParity.None;
serialPort.StopBits = SerialStopBitCount.One; serialPort.DataBits = 8;
serialPort.Handshake = SerialHandshake.None;
// crear token de cancelación

ReadCancellationTokenSource = new CancellationTokenSource ();
btnConnect.IsEnabled = false;
btnDisconnect.IsEnabled = true; txtState.Text
= "conectado"; ReadDataXBee (); }
System.Diagnostics.Debug.WriteLine (ex.Message);
btnConnect.IsEnabled = true; }
Desconectar private void (object sender, RoutedEventArgs e) {
CloseXBee ();
txtState.Text = "no conectado"; }
149
Dentro hecho clic en evento Conectar y Desconectar botones que llamamos CloseXBee () y
ReadDataXbee () métodos. Ponemos en práctica estos códigos de la siguiente manera:
CloseXBee private void () {
tratar
CancelReadTask (); }
catch (Exception) {}
if (! SERIALPORT = null) {
serialPort.Dispose (); }
SerialPort = null;
btnConnect.IsEnabled = true;
btnDisconnect.IsEnabled = false; }
ReadDataXBee vacío asíncrono privada () {
tratar
if (! SERIALPORT = null) {
dataReaderObject = new DataReader (serialPort.InputStream);
// seguir leyendo la entrada serial while (true)

{
esperar ReadXBeeAsync (ReadCancellationTokenSource.Token); }}}
CloseXBee ();
System.Diagnostics.Debug.WriteLine (ex.Message); }
finalmente {
// limpieza de una vez completa si

(dataReaderObject! = Null) {
dataReaderObject.DetachStream ();
dataReaderObject = null;
150
}}}
CancelReadTask private void () {
si (ReadCancellationTokenSource! = null) {
if (! ReadCancellationTokenSource.IsCancellationRequested) {
ReadCancellationTokenSource.Cancel (); }}}
asíncrono privada de tareas ReadXBeeAsync (CancellationToken CancellationToken) {
Tarea <UInt32> loadAsyncTask;
uint ReadBufferLength = 1,024;
// Si se solicitó la cancelación de tareas, cumplir

cancellationToken.ThrowIfCancellationRequested (); dataReaderObject.InputStreamOptions
= InputStreamOptions.Partial; loadAsyncTask = dataReaderObject.LoadAsync
(ReadBufferLength). AsTask (CancellationToken);
UInt32 BytesRead = esperan loadAsyncTask; si

(BytesRead> 0) {
cadena txt = dataReaderObject.ReadString (BytesRead); si (txt.IndexOf (

'\ r')! = -1) {
cadena val = txt.Replace ( '\ r', '\ 0'); val =

txt.Replace ( '\ n', '\ 0'); txtValue.Text = val; }}}
Guardar este programa.
Pruebas
Ahora se puede ejecutar este programa. Debería ver una lista de los puertos serie conectados en el equipo. Por favor, seleccione un
puerto serie para XBee. Después de que se ha seleccionado, debería ver los datos de entrada de texto acerca de una serie que se
envía desde Arduino XBee través de IEEE 802.15.4. Una muestra de la salida del programa se puede ver en la figura 5-31 .
151
Figura 5-31. XBeeApp se está ejecutando
La construcción de una red LoRa para Arduino

Lora es una tecnología inalámbrica desarrollada para crear el bajo consumo de energía, redes de área amplia (LPWANs) que se
requieren para la máquina a máquina (M2M) y la Internet de las aplicaciones de los objetos (IO). Usted puede aprender más sobre
LoRa al visitar este sitio: https://www.loraalliance.org . En esta sección, aprendemos cómo Arduino se conecta a otro dispositivo a
través de módulos de Lora.
Usted puede encontrar fácilmente los módulos Lora o escudos. En esta sección, exploramos productos Lora del Dragino.
Dragino Lora Shield es un transmisor-receptor de largo alcance en un factor de forma de escudo Arduino y basado en una
biblioteca de código abierto. Se puede ver una lista de productos Dragino Lora en este sitio: http://www.dragino.com/products/lora.html
. Se puede ver una muestra de escudo Dragino LoRa para Arduino en la figura 5-32 .
152
Figura 5-32. escudo Dragino LoRa de placas Arduino
Para las pruebas en esta sección, utilizo Arduino Mega 2560 y Arduino Leonardo. Yo uso dos escudos Dragino Lora.
Usted puede ver mi aplicación en la figura 5-33 . Para desarrollar una aplicación LoRa en Arduino, podemos utilizar la
biblioteca de Radiohead Packet Radio. Puede comprobarlo en este sitio: http://www.airspayce.com/mikem/arduino/RadioHead/
.
La figura 5-33. dispositivos de demostración para mi aplicación
153
En primer lugar, descargar y extraer biblioteca Radiohead Radio por Paquetes ( http: // www.
airspayce.com/mikem/arduino/RadioHead/ ) para la placa Arduino. Usted debe ZIP el archivo. Puede extraer esta biblioteca
utilizando el software de Arduino. Haga clic en Croquis menú ➤ incluir Biblioteca
➤ Agregar biblioteca .ZIP. A continuación, vaya al archivo de biblioteca postal para Radiohead Packet Radio.
Si se hace, la biblioteca de Radiohead se debe mostrar en la biblioteca de Arduino. Se puede ver en la figura 5-34 . Ahora
reinicia el software de Arduino con el fin de recargar todas las bibliotecas de Arduino.
La figura 5-34. La adición de la biblioteca RadioHead en Arduino
Ahora puede comenzar a escribir un programa de dibujo. Para la prueba, se utiliza una muestra del programa de Radiohead. Las
siguientes son las secuencias de comandos de dibujo:
# incluir <SPI.h>
# incluir <RH_RF95.h>
// ejemplo Singleton de la rf95 conductor RH_RF95 radio;
void setup () {
mientras que (de serie!); // Espera a puerto serie que esté disponible if (! Rf95.init
())
Serial.println ( "init no"); }
154
void loop () {
Serial.println ( "Envío a rf95_server"); // Enviar un mensaje

a rf95_server
uint8_t de datos [] = "Hello World!" de Mega256; rf95.send
(datos, sizeof (datos));
rf95.waitPacketSent (); // Ahora

esperar una respuesta
uint8_t buf [RH_RF95_MAX_MESSAGE_LEN];
uint8_t len = sizeof (buf);
si (rf95.waitAvailableTimeout (3000)) {
// debe ser un mensaje de respuesta para nosotros ahora si

(rf95.recv (buf, y len)) {
Serial.print ( "got respuesta:");

Serial.println ((char *) buf); } Else {
Serial.println ( "recv falló"); }} Else {
Serial.println ( "Si no responde, se está ejecutando rf95_server?"); }
retardo (400); }
Puede cambiar el valor de datos variables, por ejemplo, “Hola mundo desde Mega256” para Arduino Mega 2560 y
“Hola mundo de Leonardo!” Para Arduino Leonardo. Guarde todos los programas.
Ahora puede compilar y cargar un programa de dibujo para todas las placas Arduino. Debe ejecutar un
programa para un ordenador. Puede ejecutar dos programas de Lora con biblioteca de Radiohead en un equipo.
Para las pruebas, tengo mi Arduino Mega 2560 en Windows y Arduino Leonardo en Mac.
Después de cargar un programa de dibujo, se puede abrir el Monitor de serie. Debería ver los mensajes. Se
puede ver la salida del programa en las Figuras 5-35 y 5-36 .
155
Figura 5-35. La salida del programa de Arduino Mega 2560
La figura 5-36. La salida del programa de Arduino UNO
¿Que sigue? Después nos podemos comunicar entre Arduino través de una red Lora, desarrollamos una aplicación uwp
para transferir datos a través de una red LoRa través de Arduino. También puede desarrollar cualquier aplicación mediante la
aplicación de una red LoRa.
Aplicación basada en la localización para Arduino

En algunos casos es posible que necesite información sobre la localización; por ejemplo, desea recuperar información sobre la
temperatura y la humedad en un lugar determinado. Podemos resolver este caso mediante la implementación de un sistema basado en la
localización.
156
Oneof solución es la aplicación de un módulo GPS en nuestra junta. Hay muchos módulos GPS que
trabajan con placas Arduino. El chip GPS es famosa U-Blox ( https://www.u-blox.com/ ). Se puede ver una
forma módulo GPS en la figura 5-37 .
La figura 5-37. Módulo GPS con el dispositivo U-Blox
Puede encontrar módulos GPS en una tienda en línea, tales como Aliexpress, eBay, Sparkfun y Adafruit. Un
módulo GPS se puede ver en la figura 5-37 . Este módulo se puede utilizar para Arduino y Raspberry Pi.
Este módulo GPS tiene cinco pines VCC, GND, TX, RX, y PPS. Para las pruebas, agrego este módulo en la placa Arduino UNO de
la siguiente manera:
• módulo GPS VCC está conectado a 5V / V3.3 Arduino.
• módulo GPS GND está conectado a GND Arduino.
• TX módulo GPS está conectado al pin digital 5 Arduino.
• GPS RX módulo está conectado al pin digital 11 Arduino.
• PPS módulo GPS está conectado a GND Arduino. Se puede ver mi
implementación de cableado en la figura 5-38 .
157
Figura 5-38. Cableado para el módulo GPS y Arduino
Para desarrollar una aplicación GPS para Arduino, podemos utilizar la biblioteca TinyGPS ( https: //
github.com/mikalhart/TinyGPS ). Puede descargar esta biblioteca y luego instalarlo a través del software de Arduino. Si ha
terminado, debería ver TinyGPS en la ruta de la biblioteca de Arduino, que se muestra en la figura 5-39 . Reinicie el Arduino con
el fin de recargar todas las rutas de bibliotecas.
Figura 5-39. TinyGPS biblioteca en la ruta de la biblioteca de Arduino
158
Ahora vamos a crear una aplicación de GPS en el software de Arduino. Este programa leerá los datos del GPS en UART para
recuperar la posición actual. Después de que ha recibido, los datos GPS serán analizados y el resultado se muestra en la UART.
Escribir el siguiente esquema:
# incluir <SoftwareSerial.h>
# incluir <TinyGPS.h>
// D5 >>> Rx, D11 >>> gps Tx SoftwareSerial (5,

11); // RX, TX carbón val;
TinyGPS gps_mod;
void setup () {
Serial.begin (9600); pinMode
(13, OUTPUT); gps.begin
(9600);
Serial.println ( "GPS En .."); }
void loop () {
bool newData = false; caracteres
de largo sin signo;
frases cortas sin firmar, fracasaron;
// leer la posición GPS cada 3 segundos

para (unsigned long de inicio = millis (); Millis () - empezar <3,000;) {while (gps.available ())
{char c = gps.read (); //Serial.println(c); si (gps_mod.encode (c)) newData = true; }}
si (newData) {float plana,

flon; la edad largo sin
signo;
digitalWrite (13, HIGH);

gps_mod.f_get_position (y plana, y flon, y la edad); print_data (
"= LAT");
print_num_data (TinyGPS == planas :: GPS_INVALID_F_ANGLE 0,0:? plana, 6); print_data ( "LON
=");
print_num_data (flon == TinyGPS :: GPS_INVALID_F_ANGLE 0,0:? flon, 6); print_data ( "SAT =");
print_num_data (gps_mod.satellites () == TinyGPS :: GPS_INVALID_SATELLITES 0:?

gps_mod.satellites ()); print_data ( "PREC =");
159
print_num_data (gps_mod.hdop () == 0 TinyGPS :: GPS_INVALID_HDOP:? gps_ mod.hdop ());
linea de quiebre();
digitalWrite (13, LOW); }}
print_data void (char msg [30]) {Serial.print

(msg); }
print_num_data void (msg flotador, int n) {Serial.print

(msg, n); }
print_num_data anular (int msg)

{Serial.print (msg); }
BREAK_LINE vacío ()
{Serial.println ( ""); }
Guardar este programa como “ GPSArduino ”.
Compilar y cargar el programa de esbozo en Arduino. Abra la herramienta Monitor de serie para ver los datos del GPS. Se
puede ver la salida de la muestra en la figura 5-40 .
La figura 5-40. Ejecución de la aplicación GPS para Arduino
160
Arduino y servidor de la nube

Un servidor que desarrollas puede no tener un buen rendimiento si hay muchas solicitudes de Arduino. escalabilidad del
servidor no se puede lograr. Debido a esta situación, se podría considerar el uso de un servidor de la nube. Este servidor está
diseñado para manejar muchas peticiones.
En esta sección, se revisan varios servidores de la nube con la que nuestro Arduino puede comunicarse.
¡Vamos a explorar!
Nube Arduino
nube de Arduino es un servidor de la nube de Arduino LLC. Se puede acceder a la nube en Arduino
https://cloud.arduino.cc/ . Usted necesita registro para permitir el acceso a este código. Se puede ver en la figura 5-41 .
La figura 5-41. nube de Arduino
Actualmente, Arduino nube es compatible con Arduino MKR1000, Wi-Fi 101 escudo, y Arduino Yun. Es
necesario registrar su placa Arduino a esta nube. Después de que se ha registrado, debe obtener un ID y una
contraseña para su tablero.
Después se ha registrado en su tablero, se debe añadir una propiedad de atrapar sus datos. Por ejemplo, añado dos
propiedades: humedad y temperatura (véase la figura 5-41 ). Arduino proporciona una muestra Boceto para el envío de datos. El
siguiente es un programa de dibujo modificado para enviar la humedad y la temperatura para Arduino nube. Yo uso una placa
Arduino MKR1000. Se puede utilizar o Arduino con un escudo 101 WiFi.
161
# incluir <ArduinoCloud.h>
/////// configuración WiFi /////// Char SSID

[] = "SSID"; Char pase [] = "clave SSID";
// Arduino Nube configuración y credenciales const

nomUsuario char [] = "<nombre de usuario>"; const char
thingName [] = "<nombre Arduino>"; const char thingId [] =
"<bordo id>"; const char thingPsw [] = "<contraseña>";
WiFiSSLClient SSLClient;
// crear un nuevo objeto "KCloud"

ArduinoCloudThing KCloud;
void setup () {
// intento de conectarse a la red Wi-Fi:

Serial.print ( "Si intenta conectarse a WPA SSID:"); Serial.println (SSID);
while (! WiFi.begin (SSID, pass) = WL_CONNECTED) {// éxito,

vuelve a intentar en 4 segundos Serial.print ( "fallado ..."); retardo
(4000);
Serial.print ( "volver a intentar ..."); }
Serial.println ( "conectado a wifi");
KCloud.begin (thingName, nombre de usuario, thingId, thingPsw, SSLClient);

KCloud.enableDebug (); // definir las propiedades
KCloud.addProperty ( "humedad", FLOAT, R);

KCloud.addProperty ( "temperatura", FLOAT, R);
Serial.println ( "conectado");
randomSeed (analogRead (0)); }
void loop ()
{KCloud.poll ();
largo temp = aleatorio (10, 20); largo

humedad = aleatorio (20, 80);
162
temp = temp + 0,21 * temp;

humedad = humedad + 0,45 * humedad;
KCloud.writeProperty ( "humedad", String (humedad, 2));

KCloud.writeProperty ( "temperatura", String (temp, 2));
retardo (2000);
Cambiar los valores de SSID, pasar, nombre de usuario, thingName, thingId y thingPsw. Si le hacen, compilar y
cargar el programa Boceto en Arduino. Debería ver los datos de humedad relativa y temperatura y en la nube
Arduino.
Puede combinar este programa con una aplicación uwp para recuperar datos de la nube de Arduino y
mostrarlo en una aplicación.
Resumen
En este capítulo, hemos aprendido cómo nuestra placa Arduino se conecta a Internet a través de una conexión por cable y Wi-Fi. Hemos
construido un sencillo programa de la IO para encender / apagar los LED que están fijados en una placa Arduino a partir de un programa
de UWP. Continuamos nuestro viaje para aprender cómo extender un programa MEF a través de WiFi por lo que nuestro programa UWP
se puede comunicar con Arduino a través de WiFi.
Por otra parte, hemos explorado la comunicación RF para Arduino. Aplicamos módulos XBee y Lora de
comunicarse con otros sistemas. También participan un módulo GPS para detectar la localización actual en una placa
Arduino.
En la última sección, conectamos nuestra placa Arduino a un servidor de la nube. Utilizamos Arduino Cloud como
muestra. El envío de datos a la nube de Arduino se realizó utilizando un programa de dibujo.
Para actualizar su habilidad para el desarrollo de Arduino, se puede tratar de utilizar varios sensores y dispositivos de
accionamiento en sus proyectos. Conectarlos a un sistema externo utilizando métodos de conectividad que hemos aprendido. Ahora
usted puede construir sus propios proyectos de automatización y la IO.
163
Índice
??????????????????
UN ??????????????????
re
instalaciones de actuación de 45 módulo de DHT22, 46-51 biblioteca DHT
. RED sensor, 49-50 DotnetDHT, escudo 61
COM5, 67 Dragino Lora, 152-153
RGBControlApp, 65 RGB LED,
53-57, 65 SolidSoils4Arduino, 65, 67
Servo, 53-54
??????????????????
mi
Adafruit pluma 32u4 Adalogger, 8 depurador Ethernet Shield
incrustado de Atmel con PoE, 111 y UNO,
(EDBG), 4 111 WebServer, 112-113
??????????????????
segundo
BLE, 6 de
??????????????????
F
Bluetooth modelos de placas de pluma, 8 de
MEF sobre, 100 protocolo Firmata
programa de Arduino, escritura, 105 de añadir programa de esbozo, 39
emparejamiento Bluetooth Arduino y el SolidArduino, 41 SolidSoils4Arduino,
ordenador, 102-103 pruebas, 107 42-44 programa de dibujo estándar, 40
UWP programa, la escritura,

105-106 proyecto UWP, 104
cableado, 101-102
??????????????????
GRAMO
Genuino 101 de planchar, 6-7
Genuino MKR1000, 5 módulos
GPS
??????????????????
do pines, 157 herramienta Monitor Serial, 160
aplicación cliente, 129 biblioteca TinyGPS, 158 UART, 159-160
Nube, 161-163 U-Blox, 157 Graphical unidad de interfaz
puertos COM, Bluetooth, 106-107 analógico de (GUI), 70
control de E / S, la ERH, 85
programa de Arduino, 87
pruebas, 91-92 proyecto UWP,
87 de cableado, 86
??????????????????
MARIDO
programa de escritura de UWP, 87-91 HC-06 módulo Bluetooth, 100-101, 103
■ ÍNDICE
. RED
??????????????????
yo
cableado demo, 122 HTTP GET asignación de
IDE, 9 dirección URL, 122 LED 1 iluminación, 128 LEDs
InitWRA método (), 105 programa Croquis, 124-127 respuesta en el
Inter-Integrated Circuit (I2C) navegador, 128 herramienta Serial monitor, 127,
PCF8591 AD / DA módulo, 30-33 Sparkfun de mapeo 129 URL, 121-122, 124 de cableado para
humedad y temperatura los LED, 123-124 Serial La herramienta de
Sensor Breakout, 30 seguimiento, 120 WiFi101 biblioteca, 117-118
alambres, 29
WRA a través de, 92
pruebas, 99 proyecto
UWP, 94 cableado,
93-94
programa de escritura de UWP, 95-99 de ??????????????????
norte
Internet, 4-7 . RED
Wi-Fi, cable accionamiento de aplicaciones, 65, 67-68
114-121, 110-114 programa de aplicación, 73-74 LEDs, 34
Internet de los objetos (IO), 4-7, 109-110 que la
comunicación de E / S programa, Visual Studio 35-36,
modelos de comunicación, 22 de 36-37 cableado, 34 aplicaciones de
comunicación I2C, 29-33 de detección, 58-61, 63-64 programa de
comunicación en serie, escritura, 77-82 pilas de red, 110
22, 24-29
UNO, 21-22
??????????????????
J, K ??????????????????
O
JSON, 58-59 hardware basado en código abierto, 1
OpenWrt Linux, 6
??????????????????
L
LED parpadeante ??????????????????
P, Q
código, 12-13 PCF8591 AD / DA módulo, 30-33, 92-93,
programa, 14 configuración 96-97
IDE, 13 de destino y el puerto, 13 Pulse Width Modulation (PMW), 55, 85
UNO, 14 Linux OS, 6 LLC, 1, 5
compilar
??????????????????
R
biblioteca Radiohead Packet Radio, 154-155 readadc ()
red Lora, 152-156 métodos, 98 Realmente Bare Bones Junta (BRD), la
comunicación 8 RF
??????????????????
METRO
definido, 141 Wireless SD Shield, 142
Master en Slave Out (MISO), 26-27 Maestro XBee IEEE 802.15.4 módulo,
Fuera Slave In (MOSI), 26-27 Mega 2560, 3,
155-156 MKR1000, 117 141-143
RGBControlApp, 65, 68 RGB
COMx, 116 LED
ConnectWithWPA, 118-120 administrador displays, 54 formularios,
de dispositivos, 117 Activar el software, 115 Esquemas de 53 pin, 54-55
166
■ ÍNDICE
PMW, 55
??????????????????
T
programa de esbozo, 56-58
cableado, 55-56 dispositivo de U-Blox, 157 Universal
Asynchronous Receiver
Transmisor (UART). Ver Plataforma de
??????????????????
S comunicación serial universal de Windows
Juntas Samd, 115 (UWP), 69
dispositivos sensores, 45 . NET, el programa 69
módulo de DHT22, 46-47
biblioteca sensor de DHT, 49-50 pines control de E / S analógicas, bus I2C 87-91,
diseño, 48 95-99 MEF a través de Bluetooth, 105-106
programa para leer la temperatura y la proyecto
humedad, 50-52 cableado, 48-49 función, 46

control de E / S analógicas, bus I2C
87, 94, 71 plantillas de MEF a través de
. NET, 58-64 Bluetooth, 104 blancos, 70, 70 WRA
Sparkfun micrófono electret tecnología, 70 tableros UNO
Breakout, 47 de
comunicación en serie
herramienta Monitor de serie, 23-25
programa de esbozo, 23
Sparkfun Triple ejes Acelerómetro principiantes, 2-3 LLC, 3 de
Ruptura, la comunicación SPI mesa R3, 2 WiFi, método 4-5
26, 26, 28 herramienta Monitor de serie, UpdateData (), 98 de aplicación
23-25 Serial Peripheral Interface (SPI) UWP, 121-122
biblioteca, 27, 29
Miso y MISO pins, 27 pins, 26 LEDs, 137-139 MKR1000, 132-133
de prueba, 133 método Biestado,
programa de esbozo, 28 131-132 UI, 130-131 WiFiWRA,
Servo, 53-54 SolidArduino, 41 135-137
SolidSoils4Arduino, 42-44 Sparkfun

Bluetooth del compañero
Plata, 100
??????????????????
V
Sparkfun micrófono electret
Breakout, 47 Visual Micro, 15 de Visual
Sparkfun de humedad y temperatura Studio 2015
Sensor Breakout, 30 redactor, 17, 16 plantillas de proyecto en
Sparkfun Redboard, 7 ejecución y depuración, 18 configuración
Sparkfun Triple ejes Acelerómetro del puerto serie, 18, 11 página de inicio de
Breakout, 26 Visual Micro, 15
SRL, 1, 4
Boceto StandardFirmataWiFi
programa, 134-135
??????????????????
W
??????????????????
T biblioteca WiFi101, la red
biblioteca TinyGPS, 158 método TurnOffLeds, 78 117 WiFi
de dos hilos Interface (TWI). Ver Enterrar- MKR1000, 114-121
Juntas Samd, 115 YUN
Circuito integrado (I2C) Escudo, 115
167
■ ÍNDICE
WiFiWRA, 135-137 la creación de Arduino para, 70

Windows 10, 10, 70, 71, 102, 103, 106 de StandardFirmataWiFi Boceto
Windows Presentation Foundation programa, 134-135
(WPF), 70 pruebas, 140 uwp aplicación,
Ventanas Arduino remoto (MEF), 69 135-140 red por cable, 110-114
la construcción del primer programa, 71 Wireless SD Shield, 141-142
la adición de biblioteca, 75-76 Wireless Sensor Network
programa Arduino, 72
. programa de aplicación NET, 73-74 pruebas, (WSN), 141
82-84 cableado, 71
NET programa escrito, 77-82 de control de E

??????????????????
X
/ S analógicas, 85 La tecnología XAML, 70
programa de Arduino, 87 XBeeApp, 146
pruebas, 91-92 proyecto UWP, módulo XBee IEEE 802.15.4, 143
87 de cableado, 86 configurar, 143-144 programa
de esbozo, 145 Sparkfun,
programa de escritura de UWP, 87-91 bus 142-143 pruebas, 142, 151-152
I2C, a través de, 92 programa UWP, 146-151 WSN,
pruebas, 99 proyecto 141 XCTU aplicación, 144-145
UWP, 94 cableado,
93-94
programa de escritura de UWP, 95-99 a
través de Bluetooth, 100
programa de Arduino, escritura, 105 de
??????????????????
Y
emparejamiento Bluetooth Arduino y el Junta YUN, 6 Yun
ordenador, 102-103 pruebas, 107 Shield, 115
UWP programa, la escritura, 105-106 proyecto

UWP, 104 cableado, 101-102 ??????????????????
Z
Zero bordo, 4
168

Agus Kurniawan Arduino Programming With .NET and Sketch - En.es

Cargado por

Copyright:

Formatos disponibles

Agus Kurniawan Arduino Programming With .NET and Sketch - En.es

Cargado por

Información del documento

Título original

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

Agus Kurniawan Arduino Programming With .NET and Sketch - En.es

Cargado por

Copyright:

Formatos disponibles

Arduino

ISBN-13 (PBK): 978-1-4842-2658-2 ISBN-13 (electrónico): 978-1-4842-2659-9

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

© 2017 por Agus Kurniawan

■ Capítulo 1: Introducción a las Juntas y el Desarrollo 1 Arduino

■ Capítulo 2: NET Interconexión y Arduino 21

■ Capítulo 3: Detección y accionar 45

■ Capítulo 4: Windows Arduino remoto 69

■ Capítulo 5: Construcción de su propio IO Uso de Arduino y NET 109

índice 165 Introducción xv

■ Capítulo 1: Introducción a las Juntas y el Desarrollo 1 Arduino

Explorar la placa Arduino 1

para la Internet de las cosas 4 Arduino-Compatible 7

Configuración del entorno de desarrollo 9 Construir su primer proyecto:

Parpadeo 11 Programación del bosquejo 15 Programación Usando Arduino

visual Studio 15 Resumen 19

■ Capítulo 2: NET Interconexión y Arduino 21

Cómo funciona el programa 29

El control de la placa Arduino NET 34

La introducción de Protocolo Firmata 39 Resumen 44

■ Capítulo 3: Detección y accionar 45

Visión general de detección y accionamiento de Arduino 45 Sensor de

exploración y las instalaciones de actuación 46

Creación de una aplicación de detección de uso de red 58 Arduino

Creación de una aplicación de accionamiento Arduino uso de red de 65

■ Capítulo 4: Windows Arduino remoto 69

La creación de Arduino Arduino para Windows remoto 70 Construcción de su

primer programa para Arduino remoto de Windows 71

remota de Windows Biblioteca rduino 75 Programa de Escritura NET 77 Pruebas 82

Arduino remota a través del bus I2C 92

Escritura UWP 95 Pruebas 99

Windows remoto Arduino mediante tecnología Bluetooth 100

Escribir un programa UWP 105 Prueba 107

■ Capítulo 5: Construcción de su propio IO Uso de Arduino y NET 109

Introducción a la Internet de las cosas y Arduino Arduino 109 Conexión a la

red de Internet 110

Acceso a Arduino través de una red de la Solicitud de NET 121

Ventanas Arduino remoto (MEF) a través de WiFi 134

UWP 135 Prueba 140

La comunicación RF para Arduino 141

145 la construcción de un Programa UWP 146 pruebas 151

La construcción de una red LoRa para Arduino 152 Aplicación basada en la

ubicación para Arduino 156 Arduino y servidor de la nube 161

Nube Arduino 161

Para los lectores

¿Cómo está organizado este libro

Necesidad de software, materiales y equipo

Introducción a las Juntas y

Este capitulo cubre los siguientes topicos:

• Explorar la placa Arduino.

• La construcción de su primer proyecto.

• la programación de Arduino utilizando Visual Studio.

Explorar la placa Arduino

La Figura 1-1. placa Arduino UNO R3

Vamos a empezar a explorar las placas Arduino.

Placas Arduino para principiantes

La Figura 1-2. tablero de Arduino UNO de Arduino LLC

Placas Arduino para usuarios avanzados

La Figura 1-3. Arduino Mega 2560