Archivo de la categoría: Comunicación

Enviar emails con Arduino

El Simple Mail Transfer Protocol (SMTP) (Protocolo para la transferencia simple de correo electrónico), es un protocolo de red utilizado para el intercambio de mensajes de correo electrónico entre ordenadores u otros dispositivos (Arduino, teléfonos móviles, etc.). Fue definido en el RFC 2821 y es un estándar oficial de Internet.

El funcionamiento de este protocolo se da en línea, de manera que opera en los servicios de correo electrónico. Sin embargo, este protocolo posee algunas limitaciones en cuanto a la recepción de mensajes en el servidor de destino (cola de mensajes recibidos). Como alternativa a esta limitación se asocia normalmente a este protocolo con otros, como el POP o IMAP, otorgando a SMTP la tarea específica de enviar correo, y recibirlos empleando los otros protocolos antes mencionados (POP O IMAP).

Más información en: http://es.wikipedia.org/wiki/Simple_Mail_Transfer_Protocol y http://es.kioskea.net/contents/279-protocolos-de-mensajeria-smtp-pop3-e-imap4

Éste es un protocolo que funciona en línea, encapsulado en una trama TCP/IP. El correo se envía directamente al servidor de correo del destinatario. El protocolo SMTP funciona con comandos de textos enviados al servidor SMTP (al puerto 25 de manera predeterminada). A cada comando enviado por el cliente (validado por la cadena de caracteres ASCII CR/LF, que equivale a presionar la tecla Enter) le sigue una respuesta del servidor SMTP compuesta por un número y un mensaje descriptivo.

Esta es la secuencia de envío de un correo:

  • Al abrir la sesión SMTP, el primer comando que se envía es el comando HELO seguido por un espacio (escrito <SP>) y el nombre de dominio de su equipo (para decir «hola, soy este equipo»), y después validado por Enter (escrito <CRLF>). Desde abril de 2001, las especificaciones para el protocolo SMTP, definidas en RFC 2821, indican que el comando HELO sea remplazado por el comando EHLO.
  • El segundo comando es «MAIL FROM:» seguido de la dirección de correo electrónico del remitente. Si se acepta el comando, el servidor responde con un mensaje «250 OK».
  • El siguiente comando es «RCPT TO:» seguido de la dirección de correo electrónico del destinatario. Si se acepta el comando, el servidor responde con un mensaje «250 OK».
  • El comando DATA es la tercera etapa para enviar un correo electrónico. Anuncia el comienzo del cuerpo del mensaje. Si se acepta el comando, el servidor responde con un mensaje intermediario numerado 354 que indica que puede iniciarse el envío del cuerpo del mensaje.
  • Si se acepta el comando, el servidor responde con un mensaje «250 OK».

smtp

Las especificaciones básicas del protocolo SMTP indican que todos los caracteres enviados están codificados mediante el código ASCII de 7 bits y que el 8º bit sea explícitamente cero. Por lo tanto, para enviar caracteres acentuados es necesario recurrir a algoritmos que se encuentren dentro de las especificaciones MIME.

Ejemplo de Conversación SMTP mediante telnet:

RFC 2821:

Para enviar correos electrónicos desde arduino, es como si lo hiciéramos utilizando telnet. Esto se hacía mucho antiguamente cuando los  servidores de correo no solían estar protegidos contra el reenvío de emails y cualquiera podía conectarse al puerto  25 de un servidor de correo y enviar un correo con un remitente falso.

Un ejemplo de como mandar correo electrónico con Arduino directamente:

Obviamente para poder enviar un correo de la forma anteriormente vista necesitamos un servidor SMTP no protegido. La gran mayoría de los servidores de correo requieren que nos autentiquemos por lo que se complica un poco el proceso de enviar correo a través de telnet pero esto no significa que no podamos hacerlo.

Podemos montar una raspberry pi que haga de servidor SMTP que reciba los correos de nuestro arduino y usar la raspberry pi para que reenvíe los correos a través de gmail u otro servicio de correo.

Por supuesto disponemos de librerías que implementan un cliente SMTP en arduino:

Ejercicio31-MandaCorreo: Mandar un correo desde Arduino

Solución: https://github.com/jecrespo/Aprendiendo-Arduino/tree/master/Ejercicio31-MandaCorreo

Otra estrategia para mandar correos desde Arduino es dejarlo en manos de un servidor, es decir, con Arduino mando un POST HTTP que recoge el servidor y este mediante PHP, python u otro lenguaje se encarga de mandar el correo con las librería que tiene disponibles.

Wifi en Arduino

El wifi es un mecanismo de conexión de dispositivos electrónicos de forma inalámbrica. Los dispositivos habilitados con wifi como Arduino, pueden conectarse a internet a través de un punto de acceso de red inalámbrica.

Wi-Fi es una marca de la Alianza Wi-Fi, la organización comercial que adopta, prueba y certifica que los equipos cumplen con los estándares 802.11 relacionados a redes inalámbricas de área local.

  • Los estándares IEEE 802.11b, IEEE 802.11g e IEEE 802.11n disfrutan de una aceptación internacional debido a que la banda de 2,4 GHz está disponible casi universalmente, con una velocidad de hasta 11 Mbit/s, 54 Mbit/s y 300 Mbit/s, respectivamente.
  • En la actualidad ya se maneja también el estándar IEEE 802.11ac, conocido como WIFI 5, que opera en la banda de 5 GHz y que disfruta de una operatividad con canales relativamente limpios. La banda de 5 GHz ha sido recientemente habilitada y, además, no existen otras tecnologías (Bluetooth, microondas, ZigBee) que la estén utilizando, por lo tanto existen muy pocas interferencias. Su alcance es algo menor que el de los estándares que trabajan a 2,4 GHz (aproximadamente un 10 %), debido a que la frecuencia es mayor (a mayor frecuencia, menor alcance).

Existen otras tecnologías inalámbricas como Bluetooth que también funcionan a una frecuencia de 2,4 GHz, por lo que puede presentar interferencias con la tecnología wifi. Debido a esto, en la versión 1.2 del estándar Bluetooth actualizó su especificación para que no existieran interferencias con la utilización simultánea de ambas tecnologías, además se necesita tener 40 000 kbit/s.

Existen varias alternativas para garantizar la seguridad de estas redes. Las más comunes son la utilización de protocolos de cifrado de datos para los estándares wifi como el WEP, el WPA, o el WPA2 que se encargan de codificar la información transmitida para proteger su confidencialidad, proporcionados por los propios dispositivos inalámbricos. La mayoría de las formas son las siguientes:

  • WEP, cifra los datos en su red de forma que sólo el destinatario deseado pueda acceder a ellos. Los cifrados de 64 y 128 bits son dos niveles de seguridad WEP. WEP codifica los datos mediante una “clave” de cifrado antes de enviarlo al aire. Este tipo de cifrado no está recomendado debido a las grandes vulnerabilidades que presenta ya que cualquier cracker puede conseguir sacar la clave, incluso aunque esté bien configurado y la clave utilizada sea compleja.
  • WPA: presenta mejoras como generación dinámica de la clave de acceso. Las claves se insertan como dígitos alfanuméricos.
  • WPA2 (estándar 802.11i): que es una mejora relativa a WPA. En principio es el protocolo de seguridad más seguro para Wi-Fi en este momento. Sin embargo requieren hardware y software compatibles, ya que los antiguos no lo son. Utiliza el algoritmo de cifrado AES (Advanced Encryption Standard).
  • IPSEC (túneles IP) en el caso de las VPN y el conjunto de estándares IEEE 802.1X, que permite la autenticación y autorización de usuarios.
  • Filtrado de MAC, de manera que solo se permite acceso a la red a aquellos dispositivos autorizados. Es lo más recomendable si solo se va a usar con los mismos equipos, y si son pocos.
  • Ocultación del punto de acceso: se puede ocultar el punto de acceso (router) de manera que sea invisible a otros usuarios.

Dispositivos de distribución o de red en wifi son:

  • Los puntos de acceso son dispositivos que generan un set de servicio, que podría definirse como una red wifi a la que se pueden conectar otros dispositivos. Los puntos de acceso permiten, en resumen, conectar dispositivos de forma inalámbrica a una red existente. Pueden agregarse más puntos de acceso a una red para generar redes de cobertura más amplia, o conectar antenas más grandes que amplifiquen la señal.
  • Los repetidores inalámbricos son equipos que se utilizan para extender la cobertura de una red inalámbrica, éstos se conectan a una red existente que tiene señal más débil y crean una señal limpia a la que se pueden conectar los equipos dentro de su alcance. Algunos de ellos funcionan también como punto de acceso.
  • Los enrutadores inalámbricos son dispositivos compuestos, especialmente diseñados para redes pequeñas (hogar o pequeña oficina). Estos dispositivos incluyen, un enrutador (encargado de interconectar redes, por ejemplo, nuestra red del hogar con Internet), un punto de acceso (explicado más arriba) y generalmente un conmutador que permite conectar algunos equipos vía cable (Ethernet y USB). Su tarea es tomar la conexión a Internet, y brindar a través de ella acceso a todos los equipos que conectemos, sea por cable o en forma inalámbrica.

Los estándares 802.11b y 802.11g utilizan la banda de 2,4 GHz. En esta banda se definieron 11 canales utilizables por equipos wifi, que pueden configurarse de acuerdo a necesidades particulares. Sin embargo, los 11 canales no son completamente independientes (un canal se superpone y produce interferencias hasta un canal a 4 canales de distancia). El ancho de banda de la señal (22 MHz) es superior a la separación entre canales consecutivos (5 MHz), por eso se hace necesaria una separación de al menos 5 canales con el fin de evitar interferencias entre celdas adyacentes, ya que al utilizar canales con una separación de 5 canales entre ellos (y a la vez cada uno de estos con una separación de 5 MHz de su canal vecino) entonces se logra una separación final de 25 MHz, lo cual es mayor al ancho de banda que utiliza cada canal del estándar 802.11, el cual es de 22 MHz. Tradicionalmente se utilizan los canales 1, 6 y 11, aunque se ha documentado que el uso de los canales 1, 5, 9 y 13 (en dominios europeos) no es perjudicial para el rendimiento de la red.

Esta asignación de canales usualmente se hace sólo en el Punto de acceso, pues los “clientes” automáticamente detectan el canal, salvo en los casos en que se forma una red “Ad-Hoc” o punto a punto cuando no existe punto de acceso.

Canales en 802.11 (wifi) frente a 802.15.4 (zigbee):

Y dentro del espectro electromagnético:

ISM (Industrial, Scientific and Medical) son bandas reservadas internacionalmente para uso no comercial de radiofrecuencia electromagnética en áreas industrial, científica y médica. En la actualidad estas bandas han sido popularizadas por su uso en comunicaciones WLAN (e.g. Wi-Fi) o WPAN (e.g. Bluetooth).

El uso de estas bandas de frecuencia está abierto a todo el mundo sin necesidad de licencia, respetando las regulaciones que limitan los niveles de potencia transmitida. Este hecho fuerza a que este tipo de comunicaciones tengan cierta tolerancia frente a errores y que utilicen mecanismos de protección contra interferencias, como técnicas de ensanchado de espectro

El espectro de RF para las comunicaciones inalámbricas pertenecientes a dispositivos compatibles con IEEE 802.11 opera en bandas de frecuencias de 2,4 GHz y 5 GHz y cada una de estas bandas tiene su propio comportamiento único que tiene un impacto directo en el rendimiento de la red.

Además, el 802.11n puede utilizar la banda de 5 GHz, que es casi siempre menos concurrida y con menos interferencia que la banda de 2,4 GHz. Pero también funciona en 2,4 GHz, y los clientes 802.11n pueden asociarse con facilidad allí. La Tabla 1 muestra las frecuencias disponibles para los diferentes tipos de clientes inalámbricos.

IEEE 802.11ac (también conocido como WiFi 5G o WiFi Gigabit) es una mejora a la norma IEEE 802.11n, se ha desarrollado entre el año 2011 y el 2013, y finalmente aprobada en enero de 2014.

El estándar consiste en mejorar las tasas de transferencia hasta 433 Mbit/s por flujo de datos, consiguiendo teóricamente tasas de 1.3 Gbit/s empleando 3 antenas. Opera dentro de la banda de 5 GHz, amplía el ancho de banda hasta 160 MHz (40 MHz en las redes 802.11n), utiliza hasta 8 flujos MIMO e incluye modulación de alta densidad (256 QAM).

Wi-Fi Direct es una norma que permite que varios dispositivos Wi-Fi se conecten entre sí sin necesidad de un punto de acceso intermedio.

Wi-Fi Direct incrusta en esencia un punto de acceso en forma de software (Soft AP), en cualquier dispositivo que deba soportar Direct. El soft AP proporciona una versión de Wi-Fi Protected Setup al ser pulsado el botón o con la configuración basada en PIN. Cuando un dispositivo ingresa al rango del anfitrión Wi-Fi Direct, éste se puede conectar usando el protocolo ad hoc existente, y luego recolecta información de configuración usando una transferencia del mismo tipo de la de Protected Setup. La conexión y configuración se simplifica de tal forma que algunos sugieren que esto podría reemplazar al Bluetooth en algunas situaciones. El estándar también incluye seguridad WPA2 y ofrece controlar el acceso a redes corporativas. Los dispositivos certificados para Wi-Fi Direct se pueden conectar «uno a uno» o «uno a muchos», y no todos los productos conectados necesitan tener Wi-Fi Direct. Con un solo dispositivo Wi-Fi Direct habilitado se pueden conectar dispositivos con el estándar previo de Wi-Fi.

Además de funcionar en diferentes canales, varias redes Wi-Fi pueden compartir canalesUn conjunto de servicios (Sevice Set) es el conjunto de todos los dispositivos asociados con una red Wi-Fi particular. El conjunto de servicios puede ser local, independiente, extendido o de malla. Cada conjunto de servicios tiene un identificador asociado, el identificador de conjunto de servicios (SSID) de 32 bytes, que identifica la red en particular. El SSID se configura dentro de los dispositivos que se consideran parte de la red, y se transmite en los paquetes. Los receptores ignoran paquetes inalámbricos de redes con un SSID diferente.

Los nodos Wi-Fi que funcionan en modo ad-hoc se refieren a dispositivos que hablan directamente entre sí sin necesidad de hablar primero con un punto de acceso. Por ejemplo las impresoras.

Cada vez más en los últimos años, se han incorporado módulos Wi-Fi embebidos que incorporan un sistema operativo en tiempo real y proporcionan un medio simple de comunicación sin cables para cualquier dispositivo que que disponga de un puerto serie. Esto permite el diseño de dispositivos de monitorización simples. Un ejemplo es un dispositivo portátil de electrocardiograma que monitorea a un paciente en casa. Este dispositivo habilitado para Wi-Fi puede comunicarse a través de Internet usando la red wifi del paciente.

Estos módulos Wi-Fi están diseñados por OEMs para que los implementadores sólo necesiten un conocimiento mínimo de Wi-Fi para proporcionar conectividad Wi-Fi para sus productos.

En junio de 2014, Texas Instruments presentó el primer microcontrolador ARM Cortex-M4 con una MCU dedicada Wi-Fi embebida, el SimpleLink CC3200. Hace que los sistemas embebidos con conectividad Wi-Fi sean posibles de construir como dispositivos de un solo chip, lo que reduce su costo y tamaño mínimo, lo que hace más práctico para construir controladores de red inalámbrica en objetos ordinarios de bajo costo

Otro ejemplo es el del Arduino MKR1000 que usa el microcontrolador ATSAMW25 (http://www.atmel.com/devices/ATSAMW25.aspx) con un módulo wifi y otro de criptoauteticación incluido.

Más información:

A Arduino es posible añadirle conectividad Wifi de forma muy sencilla y ampliar las posibilidades de este microcontrolador con comunicación inalámbrica Wifi.

Hay varias formas de añadir hardware Wifi a Arduino, ya sea con un shield, una breakout board específica, con microcontroladores que tenga wifi integrado o con placas Arduinos que tenga chip wifi en la misma placa. Veamos varios casos de estos tipos, como conectarlos y usarlos, así como las librerías a usar en cada caso.

Buena parte de los visto en Ethernet con Arduino, es válido para wifi, puesto que el protocolo tcp/ip usado es el mismo y solo cambia el medio de comunicación. Trasladar un proyecto de ethernet a wifi es sencillo, solo cambiando la librería para usar el hardware y adaptar los comando en función de los métodos que tengan las librerías.

ESP8266

El ESP8266 es un chip Wi-Fi de bajo coste con pila TCP/IP completa y capacidad de MCU (Micro Controller Unit) producida por el fabricante chino Espressif Systems, con sede en Shanghai.

El chip primero llegó a la atención de los fabricantes occidentales en agosto de 2014 con el módulo ESP-01. Este pequeño módulo permite a los microcontroladores conectarse a una red Wi-Fi y realizar conexiones TCP/IP sencillas utilizando comandos de tipo Hayes. Sin embargo, en ese momento casi no había documentación en inglés sobre el chip y los comandos que aceptaba. El precio muy bajo y el hecho de que había muy pocos componentes externos en el módulo que sugiere que podría ser muy barato en el volumen, atrajo a muchos hackers para explorar el módulo, el chip y el software en él, así como para traducir La documentación china.

El ESP8285 es un ESP8266 con 1 MB de flash incorporado, lo que permite dispositivos de un solo chip capaces de conectarse a Wi-Fi. Muchos encapsulados del ESP8266 viene con 1 MB de flash.

El esp8266 es un módulo muy de moda que va alimentado a 3.3V y que hay mucha documentación en internet. Este se presenta con muchos encapsulados: http://www.esp8266.com/wiki/doku.php?id=esp8266-module-family

Características:

  • 32-bit RISC CPU: Tensilica Xtensa LX106 running at 80 MHz*
  • 64 KiB of instruction RAM, 96 KiB of data RAM
  • External QSPI flash – 512 KiB to 4 MiB* (up to 16 MiB is supported)
  • IEEE 802.11 b/g/n Wi-Fi
  • 16 GPIO pins
  • SPI, I²C,
  • I²S interfaces with DMA (sharing pins with GPIO)
  • UART on dedicated pins, plus a transmit-only UART can be enabled on GPIO2
  • 1 port 10-bit ADC

* Both the CPU and flash clock speeds can be doubled by overclocking on some devices. CPU can be run at 160 MHz and flash can be sped up from 40 MHz to 80 MHz.

A finales de octubre de 2014, Espressif lanzó un kit de desarrollo de software (SDK) que permite programar el chip, eliminando la necesidad de un microcontrolador por separado. Desde entonces, ha habido muchos lanzamientos oficiales de SDK; Espressif mantiene dos versiones del SDK – una basada en RTOS y la otra basada en callbacks.

Una alternativa al SDK oficial de Espressif es el open source esp-open-sdk que se basa en la cadena de herramientas (toolchain) GCC. ESP8266 utiliza el microcontrolador Cadence Tensilica LX106 y la cadena de herramientas GCC que es de código abierto y mantenida por Max Filippov. Otra alternativa es «Unofficial Development Kit» de Mikhail Grigorev.

Otros SDK de código abierto para el ESP8266:

  • NodeMCU: un firmware basado en Lua.
  • Arduino: un firmware basado en C ++. Este núcleo permite que la CPU ESP8266 y sus componentes Wi-Fi sean programados como cualquier otro dispositivo Arduino. El Arduino Core ESP8266 está disponible a través de GitHub: https://github.com/esp8266/Arduino y cuyo reference es https://github.com/esp8266/Arduino/blob/master/doc/reference.md
  • MicroPython: una implementación de Python para dispositivos embebidos a la plataforma ESP8266.
  • ESP8266 BASIC: Un intérprete básico de código abierto específicamente diseñado para el Internet de las cosas.
  • Mongoose Firmware: Un firmware de código abierto con servicio gratuito en la nube: https://github.com/cesanta/mongoose-iot

Github del foro ESP8266: https://github.com/esp8266

El módulo WIFI ESP8266, que es algo muy parecido a los módulos Bluetooth y que al igual que ellos incluye toda la electrónica necesaria para la comunicación Radio Frecuencia en la banda WFI, así como la pila TCP/IP y que se comunica con nosotros a través de un puerto serie. De hecho, exactamente igual que los modos HC-06 y HC-05 se gobierna mediante comandos AT (comandos hayes https://es.wikipedia.org/wiki/Conjunto_de_comandos_Hayes) y todo por un precio similar al de los Bluetooth.

Dentro de la gran cantidad de usos para este módulo caben destacar los siguientes:

  • Electrodomésticos conectados.
  • Automatización del hogar.
  • Automatización de la industria.
  • Cámaras IP.
  • Redes de sensores.
  • Wereables.
  • IoT (Internet of Things o Internet de las Cosas)
  • IIoT (Industrial Internet of Things o Internet de las Cosas para el sector Industrial)

Más información:

Características

Datos de ESP8266 de datasheet:

  • 802.11 b/g/n
  • Integrated low power 32-bit MCU
  • Integrated 10-bit ADC • Integrated TCP/IP protocol stack
  • Integrated TR switch, balun, LNA, power amplifier and matching network
  • Integrated PLL, regulators, and power management units
  • Supports antenna diversity
  • WiFi 2.4 GHz, support WPA/WPA2
  • Support STA/AP/STA+AP operation modes
  • Support Smart Link Function for both Android and iOS devices
  • SDIO 2.0, (H) SPI, UART, I2C, I2S, IR Remote Control, PWM, GPIO
  • STBC, 1×1 MIMO, 2×1 MIMO
  • A-MPDU & A-MSDU aggregation & 0.4s guard interval
  • Deep sleep power <10uA, Power down leakage current < 5uA
  • Wake up and transmit packets in < 2ms
  • Standby power consumption of < 1.0mW (DTIM3) • +20 dBm output power in 802.11b mode
  • Operating temperature range -40C ~ 125C
  • FCC, CE, TELEC, WiFi Alliance, and SRRC certified

EL ESP8266 no tiene ROM y usa una ROM externa SPI y soporta hasta 16MB.

Web Oficial del producto: https://espressif.com/en/products/hardware/esp8266ex/overview

Recursos: https://espressif.com/en/products/hardware/esp8266ex/resources

Datasheet: https://espressif.com/sites/default/files/documentation/0a-esp8266ex_datasheet_en.pdf

Tabla de consumo del módulo ESP8266:

Si queremos alimentar el módulo ESP8266 con Arduino debemos ver las limitaciones de Arduino: pin power limitations: http://playground.arduino.cc/Main/ArduinoPinCurrentLimitations, a 5V la limitación es de 1A del regulador de tensión. Como va alimentado a 3.3V la limitación es de 150mA limitado por el regulador de tensión. Regulador http://www.ti.com/lit/ds/symlink/lp2985-33.pdf, por lo tanto alimentar el ESP8266 desde el pin de 3.3V puede dar problemas y es recomendable usar otra fuente de alimentación.

Pinout ESP8266:

Pinout placas: http://www.pighixxx.com/test/portfolio-items/esp8266/?portfolioID=360

Diagrama de bloques

Los módulos ESP8266 los podemos encontrar en diferentes encapsulados y placas:

Interesante artículo sobre que módulo wifi ESP8266 elegir: http://polaridad.es/esp8266-modulo-wifi-elegir-caracteristicas/

ESP WROOM otro encapsulado ya trae una memoria Flash SPI de 2MB y con certificación FCC y CE:

Características de los módulos:

Name Active pins Pitch Form factor LEDs Antenna Shielded? dimensions (mm) Notes
ESP-01 6 0.1″ 2×4 DIL Yes PCB trace No 14.3 × 24.8
ESP-02 6 0.1″ 2×4 castellated No U-FL connector No 14.2 × 14.2
ESP-03 10 2 mm 2×7 castellated No Ceramic No 17.3 × 12.1
ESP-04 10 2 mm 2×4 castellated No None No 14.7 × 12.1
ESP-05 3 0.1″ 1×5 SIL No U-FL connector No 14.2 × 14.2
ESP-06 11 misc 4×3 dice No None Yes 14.2 × 14.7 Not FCC approved
ESP-07 14 2 mm 2×8 pinhole Yes Ceramic + U-FL connector Yes 20.0 × 16.0 Not FCC approved
ESP-08 10 2 mm 2×7 castellated No None Yes 17.0 × 16.0 Not FCC approved
ESP-09 10 misc 4×3 dice No None No 10.0 × 10.0
ESP-10 3 2 mm? 1×5 castellated No None No 14.2 × 10.0
ESP-11 6 0.05″ 1×8 pinhole No Ceramic No 17.3 × 12.1
ESP-12 14 2 mm 2×8 castellated Yes PCB trace Yes 24.0 × 16.0 FCC and CE approved[14]
ESP-12E 20 2 mm 2×8 castellated Yes PCB trace Yes 24.0 × 16.0 4 MB Flash
ESP-12F 20 2 mm 2×8 castellated Yes PCB trace Yes 24.0 × 16.0 FCC and CE approved. Improved antenna performance. 4 MB Flash
ESP-13 16 1.5 mm 2×9 castellated No PCB trace Yes W18.0 x L20.0 Marked as ″FCC″. Shielded module is placed sideways, as compared to the ESP-12 modules.
ESP-14 22 2 mm 2×8 castellated +6 No PCB trace Yes 24.3 x 16.2

En nuestro caso vamos a usar el ESP-01:

Esquemático:

Wiki: https://nurdspace.nl/ESP8266

Módulo usado:

También tenemos placas basadas en ESP8266 e incluso con puerto USB integrado:

Y un Shield ESP8266 para Arduino: https://www.sparkfun.com/products/13287

Más información:

El sucesor del ESP8266 puede que sea el ESP32 https://espressif.com/en/products/hardware/esp32/overview con wifi + bluetooth y más potente.

Datasheet ESP32: https://espressif.com/sites/default/files/documentation/esp32_datasheet_en.pdf

Primeras impresiones sobre el ESP32: https://www.sparkfun.com/news/2017

Características ESP32:

  • CPU: Xtensa Dual-Core 32-bit LX6 microprocessor, operating at 160 or 240 MHz and performing at up to 600 DMIPS
  • Memory: 520 KiB SRAM
  • Wireless connectivity:
    • Wi-Fi: 802.11b/g/n/e/i
    • Bluetooth: v4.2 BR/EDR and BLE
  • Peripheral interfaces:
    • 12-bit SAR ADC up to 18 channels
    • 2 × 8-bit DACs
    • 10 × touch sensors
    • Temperature sensor
    • 4 × SPI
    • 2 × I²S
    • 2 × I²C
    • 3 × UART
    • 1 SD/SDIO/MMC host
    • 1 slave (SDIO/SPI)
    • Ethernet MAC interface with dedicated DMA and IEEE 1588 support
    • CAN bus 2.0
    • IR (TX/RX)
    • Motor PWM
    • LED PWM up to 16 channels
    • Hall effect sensor
    • Ultra low power analog pre-amplifier
  • Security:
    • IEEE 802.11 standard security features all supported, including WFA, WPA/WPA2 and WAPI
    • Secure boot
    • Flash encryption
    • 1024-bit OTP, up to 768-bit for customers
    • Cryptographic hardware acceleration: AES, SHA-2, RSA, ECC, Random Number Generator (RNG)

Uso ESP8266 con Arduino (Puerto Serie)

El ESP8266 se puede usar con un microcontrolador como Arduino conectado por puerto serie y manejarlo con comandos hayes o programarlo como si de un microcontrolador se tratara con el IDE de Arduino usando el SDK https://github.com/esp8266/Arduino y usar el lenguaje de programación de Arduino (el core de Arduino).

Pines:

  • TX (goes to the 3.3V Rx of the UART USB adapter to the PC)
  • CH_PD (enable/power down, must be pulled to 3.3v directly or via resistor)
  • RESET
  • VCC (3.3v power supply)
  • GND (connect to power ground)
  • GPIO 2
  • GPIO 0 (leave open or pull up for normal, pull down to upload new firmware)
  • RX (goes to the 3.3V Tx of the UART USB adapter to the PC)

Para usar el ESP8266 con Arduino vamos a conectarnos por el puerto serie y mandar comandos AT (hayes) para manejarlo. Este es el esquema.

IMPORTANTE:

  • El ESP8266 va alimentado a 3,3V, ¡no alimentarlo con 5 voltios!
  • El ESP8266 necesita comunicarse vía serie a 3.3V y no tiene entradas tolerantes 5V, por lo que necesita la conversión de nivel para comunicarse con un microcontrolador 5V como la mayoría de los Arduinos

Sin embargo, esta segunda advertencia puede ser ignorada y conectar el puerto serie directamente a Arduino, pero existe el peligro de dañar el módulo.

Con un programador FTDI que tenga salida a 3.3V podemos hacer lo mismo que con un Arduino pero sin ningún peligro.

ESP8266 quick start guide: http://rancidbacon.com/files/kiwicon8/ESP8266_WiFi_Module_Quick_Start_Guide_v_1.0.4.pdf

Guia sparkfun del ESP8266: https://learn.sparkfun.com/tutorials/esp8266-thing-hookup-guide

Ejemplo de level shifter para usar con Arduino:

Cheatsheet: https://cdn.sparkfun.com/datasheets/Wireless/WiFi/ESP8266ModuleV1.pdf

Por lo tanto la primera forma de usar el módulo ESP8266 es comunicarse con él a través del puerto serie y manejarlo mediante los comandos AT (hayes) que tiene en su firmware.

El conjunto de comandos Hayes es un lenguaje desarrollado por la compañía Hayes Communications que prácticamente se convirtió en estándar abierto de comandos para configurar y parametrizar módems. Los caracteres «AT», que preceden a todos los comandos, significan «Atención», e hicieron que se conociera también a este conjunto de comandos como comandos AT. Midiendo la longitud de los bits se puede determinar en detalle la velocidad de transmisión.

Comandos hayes:

Comandos Hayes para ESP8266:

Proyectos con ESP8266:

Más información:

Videos:

Uso ESP8266 con IDE Arduino

Hemos visto como realizar las conexiones y vimos los comandos AT que nos permiten configurar las acciones del WIFI. El ESP8266 dispone internamente de un pequeño procesador, prácticamente es capaz de replicar casi cualquier cosa los Arduinos puedan hacer. Así que los proyectos con sensores más Arduinos que envían los datos a la WIFI mediante un ESP8266, es muy probable que podamos ahorrarnos el Arduino en el proceso.

Gracias a un firmware basado en C ++, permite que la CPU ESP8266 y sus componentes Wi-Fi sean programados como cualquier otro dispositivo Arduino.

  • Puedes desarrollar con el mismo IDE que ya conoces
  • Han hecho un Cross compiler, de forma que prácticamente utilizas los mismos comandos que utilizas con Arduino, con lo que te ahorras aprender nada nuevo
  • Dependiendo del modelo de ESP8266 que tengas, dispones de más o menos pines disponibles con PWM y otras cosas más como I2C y SPI, pero para el modelo ESP8266-01 solo tienes dos pines disponibles GPIO0 y GPIO2
  • Puedes programar el procesador de tu ESP8266 exactamente como si fuera un Arduino con los mismos comandos, y en lo que se refiere a la WIFI, puedes olvidarte de los comandos AT, porque incluye una serie de librerías, que imitan la librería WIFI de Arduino con lo que se pueden reutilizar muchos programas.  

El Arduino Core ESP8266 está disponible a través de GitHub: https://github.com/esp8266/Arduino

Reference de Arduino core a ESP8266: https://github.com/esp8266/Arduino/blob/master/doc/reference.md

Toda la documentación del soporte de Arduino core a ESP8266: https://github.com/esp8266/Arduino/tree/master/doc

Documentación de la librería esp8266wifi: https://github.com/esp8266/Arduino/tree/master/doc/esp8266wifi que usa los mismos métodos que https://www.arduino.cc/en/Reference/WiFi

Podemos descargar un IDE ya configura para ESP8266 de https://github.com/esp8266/Arduino/releases/

O podemos instalar el soporte a terceros en nuestro IDE simplemente añadiendo el texto “http://arduino.esp8266.com/stable/package_esp8266com_index.json” en propiedades:

Y luego desde el gestor de tarjetas dar a instalar al soporte para ESP8266.

ESP8266 Community: http://arduino.esp8266.com/stable/package_esp8266com_index.json

  • Generic ESP8266 modules
  • Olimex MOD-WIFI-ESP8266
  • NodeMCU 0.9 (ESP-12)
  • NodeMCU 1.0 (ESP-12E)
  • Adafruit HUZZAH ESP8266 (ESP-12)
  • SparkFun Thing
  • SweetPea ESP-210
  • WeMos D1
  • WeMos D1 mini

Para instalar el Arduino Core ESP8266 en nuestro IDE de Arduino seguir las instrucciones: http://www.instructables.com/id/Setting-Up-the-Arduino-IDE-to-Program-ESP8266/?ALLSTEPS

IMPORTANTE: Cuando cargas un sketch en el ESP8266 con el IDE Arduino estamos cargando en la flash de ESP8266 un nuevo firmware borrando el que viene por defecto visto anteriormente para manejar el módulo con comando hayes.

Otras características de este soporte:

  • Actualización OTA
  • Soporta muchas de las librerías de Arduino y otras librerías hechas por terceros está ya adaptadas para usar con el ESP8266.

Más información:

Firmware ESP8266

Como hemos hablado el módulo ESP8266 es un microcontrolador como los que hemos visto con Arduino y podemos cargarle un firmware con un programa que hayamos hecho y compilado con el IDE de Arduino o usar un firmware como el que viene por defecto que es el de comandos hayes.

Además de los firmwares anteriores tenemos otros firmware disponibles como el oficial basado en un RTOS.

Para descargar las herramientas y últimas versiones del firmware usar la web: https://espressif.com/en/products/hardware/esp8266ex/resources

Más información de como actualizar firmware (version actualizada en la parte de ejercicios):

Ejercicios ESP8266

Conexión a Arduino

Lo primero es decir que este es módulo muy sencillo y diseñado desde el principio con la Internet of Things en mente (IOT), y por eso incluye todo lo necesario para conectarse a un punto de acceso WIFI mediante comandos de texto AT, vía un puerto serie, que puede ser configurada a diferentes velocidades.

Una vez que lo configuramos para que se conecte a nuestra WIFI, el módulo es capaz de enviar información que le remitimos vía la puerta serie a una dirección IP y puerto que deseemos.

Cuando se trata de recibir, limpia todo el empaquetado TCP/IP y nos reenvía por la puerta serie la información de datos limpia, con lo que tiene la enorme virtud de permitirnos olvidarnos de la gestión del TCP/IP y de las demandas de procesador y memoria que suponen. A cambio no es exactamente una conexión WIFI, porque no tenemos acceso al stack o al socket IP pero para el Arduino esto es casi una ventaja.

La fuente interna de 3.3V del Arduino da un máximo de 150 mA, cuando el consumo del módulo suele ser en el arranque bastante superior a esto, lo que le llevará a unos arranques poco fiables, y aunque se acaba consiguiendo, deben repetirse una y otra vez. En nuestro caso usaremos una fuente externa de alimentación de 3.3V para alimentar este módulo ESP8266.

ESP8266 programado por puerto serie

Conexión con programador FTDI:

Conexión con Arduino:

Conectar un terminal serie a 115200-8-N y mandar el comando AT, si nos responde OK es que ya estamos conectados con el módulo.

Manual oficial de comandos: http://www.espressif.com/sites/default/files/4a-esp8266_at_instruction_set_en_v1.5.4_0.pdf

Ejecutar los siguientes comandos y ver lo que devuelve:

  • AT+RST: reinicia el módulo
  • AT+GMR: versión de firmware
  • AT+CWMODE=3: activa modo AP, comprobar redes wifi
  • AT+CWLAP: para ver las redes wifi
  • AT+CWJAP=»SSID»,»password»: Conectarse a una red wifi (AT+CWJAP=»AndroidAP4628″,»esp8266wifi»)
  • AT+CIFSR: comprobar la IP asignada

Actuar como un cliente TCP:

  • AT+CIPMUX=1: Habilitar múltiples conexiones
  • AT+CIPSTART=4,»TCP»,»google.com»,80: Especifica el canal de conexión que desea conectar (0 – 4), el tipo de protocolo (TCP / UDP), la dirección IP (o el dominio si tiene acceso a DNS) y el número de puerto
  • A continuación, debe especificar la cantidad de datos que desea enviar (después de especificar qué canal). Vamos a enviar «GET / HTTP / 1.0 \r \n \r \n» que es 18 bytes: AT+CIPSEND=4,18
  • Y recibiremos la respuesta del servidor:

+IPD,4,559:HTTP/1.0 301 Moved Permanently
Location: http://www.google.com/
Content-Type: text/html; charset=UTF-8
Date: Sat, 12 Nov 2016 16:37:23 GMT
Expires: Mon, 12 Dec 2016 16:37:23 GMT
Cache-Control: public, max-age=2592000
Server: gws
Content-Length: 219
X-XSS-Protection: 1; mode=block
X-Frame-Options: SAMEORIGIN
Connection: close
<HTML><HEAD><meta http-equiv=»content-type» content=»text/html;charset=utf-8″>
<TITLE>301 Moved</TITLE></HEAD><BODY>
<H1>301 Moved</H1>
The document has moved
<A HREF=»http://www.google.com/»>here</A>.
</BODY></HTML>
4,CLOSED

Actuar como servidor:

  • Comprobar que IP tenemos con AT+CIFSR
  • AT+CIPSERVER=1,1336:  para poner a escuchar en un puerto, en este caso el 1336
  • Desde otro dispositivo en la red: telnet 192.168.1.2 1336
  • En el puerto serie veré todo lo que se escriba por telnet
  • Para responder desde el ESP8266 debo usar AT+CIPSEND=0,8 seguido del texto. En este caso es el canal 0 y mando 8 caracteres.

Hacer lo mismo pero usando Arduino, para ello conectarlo según el esquema superior y cargar el programa:

#include <SoftwareSerial.h>
SoftwareSerial BT1(3, 2); // RX | TX
void setup()
{ Serial.begin(9600);
 BT1.begin(115200);
}
void loop()
{
 if (BT1.available())
 { char c = BT1.read();
   Serial.print(c);
 }
 if (Serial.available())
 { char c = Serial.read();
   BT1.print(c);
 }
}

Configurar el baud rate de ESP8266 a 9600 para que funcione mejor con el comando “AT+UART_DEF=9600,8,1,0,0”, puesto que a 115200 da problemas con el puerto serie software.

Para hacer una reseteo de la configuración de fábrica usar el comando: “AT+RESTORE

Hacer un programa con Arduino que se conecte automáticamente a una red y nos puestre la IP asignada:

  • AT+CWMODE_DEF=1
  • AT+CWJAP=»SSID»,»paswword»)
  • AT+CIFSR: comprobar la IP asignada

Solución: Ejercicio 61 https://github.com/jecrespo/Aprendiendo-Arduino/tree/master/Ejercicio61-ESP8266

Más información:

Configuración como punto de acceso

Podemos poner el ESP8266 en modo punto de acceso para que se conecten otros dispositivos wifi, recordad que es un modo soft AP.

Escribir la siguiente secuencia de comandos:

  • AT+CWSAP=»NoWorriESSID»,»password»,3,0
  • AT+CWMODE=3
  • AT+CWLIF: IP de los dispositivos conectados

Para saber el significado de cada parámetro y sus opciones ver https://espressif.com/sites/default/files/documentation/4a-esp8266_at_instruction_set_en.pdf

Más información:

ESP8266 programado con IDE Arduino

Conectar al programador FTDI como hemos visto anteriormente. Pero para programar el módulo (Y para actualizar el firmware) necesitáis colocar el módulo en estado de programación y eso se consigue poniendo a GND la patilla GPIO0.

Vamos a programar el blink de Arduino en la patilla GPIO2, que es la que nos queda libre:

void setup()
  { pinMode(2, OUTPUT); }

void loop()
  { digitalWrite(2, HIGH);  
    delay(1000);  
    digitalWrite(2, LOW);
    delay(1000);   
  }

Para probarlo.

IMPORTANTE: Al cargar un programa pierdo el firmware original.

Más información:

Veamos los ejemplos de ESP8266 que vienen en el soporte para el IDE de Arduino, usando la librería ESP8266WiFi.h:

  • Blink
  • ESP8266Wifi/Wifiscan: Scan networks
  • ESP8266Wifi/WifiClient Conectar a wifi
  • ESP8266WebSerber/HelloServer: Servidor web wifi

El reference para programar:

Firmware Update

Para actualizar el firmware necesitamos descargar la herramienta “flash download tools” para el ESP8266 y el firmware con los comandos hayes, además aprovechamos para actualizar a la última versión del firmware.

Para programar recordar y actualizar firmware recordar que el pin GPIO0 debe estar a masa y que hay que un reset del módulo para comenzar la carga del nuevo firmware.

Descarga: https://espressif.com/en/products/hardware/esp8266ex/resources

Descargar la última versión de:

  • Tools/Flash Download Tools V3.4.2 (ESP8266 & ESP32)
  • SDK & demos/ESP8266 NONOS SDK V2.0.0 20160810

Abrir la aplicación Flash download tool y elegir ESP8266. Luego configurar de la siguiente forma:

esp8266

Configurando los ficheros para BOOT MODE Flash size 8Mbit: 512KB+512KB:

  • boot_v1.2+.bin              0x00000
  • user1.1024.new.2.bin        0x01000
  • esp_init_data_default.bin   0xfc000 (optional)
  • blank.bin                   0x7e000
  • blank.bin                  0xfe000

Que se encuentran en el directorio bin del fichero de SDK que nos hemos descargado.

Para comprobar la frecuencia de cristal del módulo y la flash, simplemente dando a start sin seleccionar los ficheros y reseteando el módulo obtendremos la información.

Más información sobre el Firmware update (como referencia no están actualizados):

IMPORTANTE: no descargar nada de fuentes no fiables

NODEMCU

NodeMCU es una plataforma IoT de código abierto. Incluye firmware que se ejecuta en el ESP8266 Wi-Fi SoC de Espressif Systems y el hardware que se basa es el módulo ESP-12.

El término «NodeMCU» por defecto se refiere al firmware en lugar de los kits de desarrollo de ESP8266. El firmware utiliza el lenguaje de secuencias de comandos Lua. Se basa en el proyecto eLua, y está basado en el SDK Espressif Non-OS SDK for ESP8266.

Un grupo de desarrolladores chinos de plataformas abiertas de hardware, quienes se basaron en el ESP8266 para lanzar un kit llamado NodeMCU para el desarrollo de prototipos compatible con Arduino, que se programa en lenguaje Lua, con conectividad USB y Wi-Fi, y a un precio sorprendentemente bajo.

Pinout:

Web oficial: http://www.nodemcu.com/index_en.html

Github: https://github.com/nodemcu

Documentación: http://nodemcu.readthedocs.io/en/master/

Lua: https://en.wikipedia.org/wiki/Lua_(programming_language)

Firmware: https://github.com/nodemcu/nodemcu-firmware

Node mcu flasher: https://github.com/nodemcu/nodemcu-flasher

Más información:

Tutorial de uso: http://blog.nyl.io/esp8266-meets-nodemcu/

Proyectos con nodemcu:

Arduino UNO Wifi

Se trata de una nueva placa de arduino.org que es el clásico Arduino UNO al que le añade en la misma placa y con el formato del Arduino UNO un chip ESP8266, obteniendo al final un Arduino UNO con conectividad wifi. Es el módulo perfecto para comenzar un proyectos de IoT.

Datasheets:

A nivel de entradas y salidas y otras características físicas es exactamente igual a un Arduino UNO, pero se le ha añadido un módulo wifi ESP8266 que es un SoC con la pila de protocolos TCP/IP integrada que puede dar acceso a la red wifi o el puede actuar como un punto de acceso.

Una de las características más interesantes de el Arduino UNO wifi es que soporta programación OTA (over-the-air), tanto para transferir sketches como para actualizar el firmware wifi.

Información de producto http://www.arduino.org/products/boards/arduino-uno-wifi

En el Arduino UNO wifi, hay un chip SC16IS750IBS con una UART y un interfaz I2C/SPI que permite la comunicación entre el AtMega16u2, AtMega328p y el ESP8266EX. Este chip tiene un interfaz I2C/SPI esclavo que hace de interfaz a una UART, así como 8 pines I/O programables, ofreciendo una conversión de I2C/SPI a serie (RS232/RS485) bidireccional.

http://www.arduino.org/images/products/details/ArduinoUNOWIFI_drawing2.jpg

Datasheet SC16IS750IBS: http://www.nxp.com/documents/data_sheet/SC16IS740_750_760.pdf

Arduino UNO wifi permite comunicar vía wifi con los sensores o actuadores montados en la placa. Es posible usarlo como cliente de una red wifi, como servidor para conectar otros clientes o crear una conexión wifi ad-hoc.

Arduino UNO wifi tiene precargado un sketch con un servidor REST (RestServer) que permite manejar el arduino desde un navegador simplemente conectando a la SSID del Arduino (Arduino-Uno-WiFi-xxxxxx) y entrando a la IP 192.168.240.1 para gestionarlo y usar los siguientes comandos para manejar los pines:

  • «/arduino/digital/13»     -> digitalRead(13)
  • «/arduino/digital/13/1»   -> digitalWrite(13, HIGH)
  • «/arduino/analog/2/123»   -> analogWrite(2, 123)
  • «/arduino/analog/2»       -> analogRead(2)
  • «/arduino/mode/13/input»  -> pinMode(13, INPUT)
  • «/arduino/mode/13/output» -> pinMode(13, OUTPUT)

Esquemático: http://download.arduino.org/products/UNOWIFI/Arduino-UNO-WiFi-V4_AF1.pdf

http://www.arduino.org/images/products/details/ArduinoUNOWIFI_drawing1.jpg

Programación

El Arduino UNO wifi puede programarse como un Arduino normal por el puerto serie o por wifi de la misma forma que el Arduino Yun

Para usar este Arduino tendremos que utilizar el IDE de arduino.org: http://www.arduino.org/downloads

Si al conectar el Arduino UNO wifi no lo reconoce Windows, instalar los drivers que hay en la carpeta drivers del IDE de Arduino.org

Después de alimentar Arduino UNO wifi, conectarse a la red Arduino-Uno-WiFi-xxxxxx y abrir el enlace http://192.168.240.1/

http://labs.arduino.org/dl1542?display&scale=0.7

Y desde la web podemos conectar Arduino UNO wifi a cualquier red wifi donde queramos integrarlo.

Más información en: http://www.arduino.org/learning/getting-started/getting-started-with-arduino-uno-wifi

NOTA: para programar por wifi, es necesario que el ordenador y el Arduino estén conectados a la misma red wifi y la placa está en modo STA.

Tutoriales Arduino UNO wifi:

La diferencia entre el Arduino UNO wifi y el wifi shield es que el wifi shield usa el SPI y este Arduino usa el I2C para conectarse al puerto serie del ESP8266 para mandar los comandos y transmitir por wifi.

La librería usada es la arduinowifi.h que aún no está documentada oficialmente, pero indagando en la librería “ArduinoWiFi.h” vemos que hace “extern ArduinoWifiClass Wifi; “, es decir crea el objeto Wifi de la clase ArduinoWifiClass y por eso podemos llamarlo desde el programa sin tener que instanciarlo previamente.

Código de la librería arduinowifi.h https://github.com/arduino-org/arduino-library-arduino-wifi

Es una librería para configuración y manejo del ESP8266 por el bus I2C.

El reference para la librería wifi es http://www.arduino.org/learning/reference/WiFi pero aunque es para el wifi shield, han diseñado la librería de Arduino Uno Wifi para que comparta nombre de las funciones y uso similar.

Al arrancar el Arduino UNO Wifi se inicia en modo AP y podemos conectarnos vía wifi para configurarlo y que luego se conecte a una red wifi.

Como cambiar el firmware: http://www.arduino.org/learning/tutorials/advanced-guides/how-to-change-the-firmware-on-an-arduino-uno-wifi

En el Arduino UNO wifi ciao está integrado y puede usarse la librería http://www.arduino.org/learning/reference/ciao-library.

Más información sobre CIAO: http://www.arduino.org/learning/tutorials/advanced-guides/content/ciao

Ejemplo con CIAO:

Ejercicio con Arduino UNO Wifi: basado en el ejercicio 27 del botón mejorado:  https://github.com/jecrespo/Aprendiendo-Arduino/tree/master/Ejercicio27-Boton_Mejorado_UNO_WIFI

Comparar el código de:

Wifi Shield

El WiFi Shield de Arduino conecta Arduino a Internet de forma inalámbrica.

http://arduino.cc/en/uploads/Main/A000058_front_450.jpg

Toda la información sobre este Shield en :

Y los datasheet de los integrados:

Para conectarte al 32UC3: http://arduino.cc/en/Hacking/WiFiShield32USerial

Y la librería para manejar el shield en: http://arduino.cc/en/Reference/WiFi

Actualizar su firmware: http://arduino.cc/en/Hacking/WiFiShieldFirmwareUpgrading

http://arduino.cc/en/uploads/Main/ArduinoWiFiShieldPinUseDescribed_2.jpg

Wifi library:

Un proyecto hecho con Ethernet pasarlo a wifi con el wifi shield, simplemente se trata de cambiar las líneas de código de la parte de red de la librería ethernet a las equivalentes de la librería wifi.

Ejercicio 27. Botón mejorado Wifi.

Partiendo del ejercicio 27 del botón mejorado que enciende y apaga un led desde una web embebida en arduino con un ethernet shield, modificarlo para que funcione con un Arduino con el shield wifi.

Ejercicio con Ethernet: https://github.com/jecrespo/Aprendiendo-Arduino/tree/master/Ejercicio27-Boton_Mejorado

Solución: https://github.com/jecrespo/Aprendiendo-Arduino/tree/master/Ejercicio27-Boton_Mejorado_WIFI

WiFi Shield 101

Arduino WiFi Shield 101 es un shield potente para aplicaciones IoT con autenticación criptográfica, desarrollado con ATMEL, que conecta la placa Arduino a Internet de forma inalámbrica. La conexión a una red WiFi es simple, no se necesita ninguna configuración adicional además del SSID y la contraseña. El WiFi Shield 101 viene con una biblioteca fácil de usar que permite conectar la placa Arduino a Internet con pocas instrucciones. Como siempre, cada elemento de la plataforma – hardware, software y documentación está libremente disponible y de código abierto. Se basa en el módulo Atmel SmartConnect-WINC1500, compatible con la norma IEEE 802.11 b/g/n

Características:

  • Operating voltage both 3.3V and 5V (supplied from the host board)
  • Connection via: IEEE 802.11 b/g/n for up to 72 Mbps networks
  • Encryption types: WEP and WPA2 Personal
  • Support TLS 1.1 (SHA256)
  • Connection with Arduino or Genuino on SPI port
  • Onboard CryptoAuthentication by ATMEL

Web del producto https://www.arduino.cc/en/Main/ArduinoWiFiShield101

La de Adafruit https://www.adafruit.com/products/2891

El módulo wifi WINC1500 integrado es un controlador de red capaz de protocolos TCP y UDP. El Wifi Shield 101 también cuenta con un hardware de seguridad de cifrado / descifrado proporcionado por el chip ATCC508A CryptoAuthentication que es un método ultra seguro para proporcionar un acuerdo clave para el cifrado/descifrado, diseñado específicamente para el mercado de IoT.

Datasheet módulo wifi: http://www.atmel.com/devices/atwinc1500.aspx

El pin digital 7 se utiliza como un pin de handshake entre el shield WiFi 101 y Arduino, y no se debe utilizar. El pin digital 5 se utiliza como pin RESET entre el shield WiFi 101 yArduino, y no debe utilizarse.

Tener en cuenta que Uno + WiFi Shield 101 no es compatible con la biblioteca Serial de software. El WiFi Shield 101 usa una biblioteca que es muy compleja y ocupa más del 60% de la memoria disponible, dejando poco espacio para los sketches. Tener en cuenta que para un uso básico es compatible con el Uno, pero para proyectos complejos se recomienda usar el shield WiFi 101 con un Arduino / Genuino Zero, 101 o Mega 2560.

El Wifi Shield 101 se usa con la librería Wifi101 https://www.arduino.cc/en/Reference/WiFi101

Ejemplo sencillo por con el wifi shield 101: https://www.arduino.cc/en/Tutorial/Wifi101SimpleWebServerWiFi

Más información:

MKR1000

Es un nuevo Arduino con un microcontrolador que lleva integrado wifi y mucho más. El Arduino MKR1000 ha sido diseñado para ofrecer una solución práctica y económica buscando conectividad WiFi para gente con mínima experiencia en redes.

Este Arduino está basado en la MCU ATSAMW25 especialmente diseñado para proyectos IoT. Este SoC está compuesto de tres bloques principales:

  • SAMD21 Cortex-M0+ 32bit low power ARM MCU
  • WINC1500 low power 2.4GHz IEEE® 802.11 b/g/n Wi-Fi
  • ECC508 CryptoAuthentication

Microcontrolado ATSAMW25 http://www.atmel.com/devices/ATSAMW25.aspx

Este Arduino también incluye un circuito para cargar baterías Li-Po y utilizar el MKR1000 alimentándose con este tipo de baterías.

IMPORTANTE: Arduino MKR1000 funciona a 3.3V, el máximo voltaje que pueden tolerar los pines es de 3.3V y aplicar voltajes mayores podría dañar la placa. Mientras que una salida de 5V digital es posible, para una comunicación bidireccional de 5V es necesario level shifting.

Datasheet MCU: http://www.atmel.com/devices/ATSAMW25.aspx  

Esquemático: https://www.arduino.cc/en/uploads/Main/MKR1000-schematic.pdf

Pinout:

Web del producto https://www.arduino.cc/en/Main/ArduinoMKR1000

MKR1000 usa la librería wifi101: https://www.arduino.cc/en/Reference/WiFi101

Empezar con MKR1000

Getting Started https://www.arduino.cc/en/Guide/MKR1000

Para programar el MKR1000 es necesario añadir al IDE de Arduino soporte para esta placa, ya que el microcontrolador no es un AVR sino un ARM Cortex-M0 de 32 bits. SAMD Core.

En este enlace explica como añadir soporte (Arduino Cores) para nuevas placas: https://www.arduino.cc/en/Guide/Cores

El MKR1000 y Arduino Zero tienen unas librerías específicas por su microcontrolador:

Tutoriales MKR1000:

Proyectos interesantes:

MKR1000 como access point https://www.arduino.cc/en/Reference/WiFi101BeginAP (AP soft)

Ejercicio 39 NTP con MKR1000: https://github.com/jecrespo/Aprendiendo-Arduino/tree/master/Ejercicio39-NTP_MKR1000

Arduino Yun

Otra forma de añadir la funcionalidad de Wifi a Arduino es usar Arduino Yun que tiene wifi integrado y la librería bridge para conectar el microcontrolador con el microprocesador que tiene wifi integrado.

Arduino Yun: http://www.arduino.org/products/boards/4-arduino-boards/arduino-yun con MCU Atmel AVR de 8 bits ATmega32U4 y procesador MIPS Qualcomm Atheros AR9331 a 400 MHz con wifi integrado y SO linux Linino basado en OpenWRT y ethernet. Su principal característica es la capacidad de comunicar la MCU con el SO linux mediante un puerto serie interno. Esta placa no es 100% hardware libre, al no hacerse público la parte donde se encuentra el procesador Atheros AR9331. También hay disponible una version Yun mini para protoboards: http://www.arduino.org/products/boards/4-arduino-boards/arduino-yun-mini

Web del producto https://www.arduino.cc/en/Main/ArduinoBoardYun

Librería Bridge:

  • Bridge – Simple REST style calls to access analog and digital pins

Recientemente ha aparecido el Arduino Yun Shield que es una placa para añadir las funcionalidades del Arduino Yun a cualquier Arduino.

Web del producto https://www.arduino.cc/en/Main/ArduinoYunShield

Ejemplo de uso con Arduino Yun: https://github.com/jecrespo/Coche_AprendiendoArduino

Para comenzar una vez actualizado:

CC3000

Otro integrado wifi muy usado con arduino es el CC3000, pero que se ha quedado un poco obsoleto.

Chip CC3000:

Y la librería: https://github.com/sparkfun/SFE_CC3000_Library

Y un buen paso a paso para usar esta shield:

Y un ejemplo de uso práctico para hacer domótica en casa:

Otros Módulos Wifi

ESP32 el sucesor de ESP8266:

Soporte para el IDE de Arduino:

Primeras impresiones: https://www.sparkfun.com/news/2017

Tutorial http://www.instructables.com/id/Beginners-ESP32-Guide-to-Assembly-Testing/

Tabla comparativa: http://www.cnx-software.com/2016/03/25/esp8266-and-esp32-differences-in-one-single-table/

WiFi3 Click

Otro módulo derivado de esp8266:

NL6621 como alternativa al ESP8266

The NL6621 WiFi SOC is powered by a 160 MHz ARM Cortex-M3 with 448 KB of RAM, and everything else is integrated in the SOC. The module has 32 GPIOs, SPI, I2C, I2S digital audio, and most of the peripherals that you’d expect.

Comunicaciones IP

Capas OSI

Según la clasificación OSI, la comunicación de varios dispositivos se puede estudiar dividiéndola en 7 niveles, que son expuestos desde su nivel más alto hasta el más bajo:

Nivel Nombre Categoría
Capa 7 Nivel de aplicación Aplicación
Capa 6 Nivel de presentación
Capa 5 Nivel de sesión
Capa 4 Nivel de transporte
Capa 3 Nivel de red Transporte de datos
Capa 2 Nivel de enlace de datos
Capa 1 Nivel físico

Protocolo TCP/IP

El modelo TCP/IP describe un conjunto de guías generales de diseño e implementación de protocolos de red específicos para permitir que un equipo pueda comunicarse en una red. TCP/IP provee conectividad de extremo a extremo especificando como los datos deberían ser formateados, direccionados, transmitidos, enrutados y recibidos por el destinatario.

La importancia del modelo TCP/IP es que es el modelo usado para acceder a Internet o a redes internas (Intranet) de ordenadores. Arduino va a permitir conectarse a Internet o a una red interna mediante TCP/IP y poder realizar múltiples operaciones o usarse como pasarela para conectar a Internet dispositivos que no tienen esa capacidad. La implementación de la pila de protocolos de TCP/IP en Arduino se hace mediante un shield o HW adicional que nos da la capa de acceso a red (ethernet o WiFi), internet (IP) y transporte. La capa de aplicación deberemos implementarla dentro de Arduino ya sea directamente o mediante una librería.

En el caso del protocolo TCP/IP la pila OSI se simplifica:

Capa de Aplicación. Invoca programas que acceden servicios en la red. Interactúan con uno o más protocolos de transporte para enviar o recibir datos, en forma de mensajes o bien en forma de flujos de bytes.
Capa de Transporte. Provee comunicación extremo a extremo desde un programa de aplicación a otro. Regula el flujo de información. Puede proveer un transporte confiable asegurándose que los datos lleguen sin errores y en la secuencia correcta. Coordina a múltiples aplicaciones que se encuentren interactuando con la red simultáneamente de tal manera que los datos que envíe una aplicación sean recibidos correctamente por la aplicación remota, esto lo hace añadiendo identificadores de cada una de las aplicaciones. Realiza además una verificación por suma, para asegurar que la información no sufrió alteraciones durante su transmisión.
Capa Internet. Controla la comunicación entre un equipo y otro, decide qué rutas deben seguir los paquetes de información para alcanzar su destino. Conforma los paquetes IP que será enviados por la capa inferior. Desencapsula los paquetes recibidos pasando a la capa superior la información dirigida a una aplicación.
Capa de Interfaz de Red. Emite al medio físico los flujos de bit y recibe los que de él provienen. Consiste en los manejadores de los dispositivos que se conectan al medio de transmisión.

Más información en: http://www.uca.edu.sv/investigacion/tutoriales/tcp-ip.html

Conexión y desconexión TCP/IP

El proceso de establecimiento de una conexión TCP se denomina “three way handshake” Durante el establecimiento de la conexión, se configuran algunos parámetros tales como el número de secuencia con el fin de asegurar la entrega ordenada de los datos y la robustez de la comunicación.

Aunque es posible que un par de entidades finales comiencen una conexión entre ellas simultáneamente, normalmente una de ellas abre un socket en un determinado puerto TCP y se queda a la escucha de nuevas conexiones. Es común referirse a esto como apertura pasiva, y determina el lado servidor de una conexión. El lado cliente de una conexión realiza una apertura activa de un puerto enviando un paquete SYN inicial al servidor como parte de la negociación en tres pasos. En el lado del servidor (este receptor también puede ser una PC o alguna estación terminal) se comprueba si el puerto está abierto, es decir, si existe algún proceso escuchando en ese puerto, pues se debe verificar que el dispositivo de destino tenga este servicio activo y esté aceptando peticiones en el número de puerto que el cliente intenta usar para la sesión. En caso de no estarlo, se envía al cliente un paquete de respuesta con el bit RST activado, lo que significa el rechazo del intento de conexión. En caso de que sí se encuentre abierto el puerto, el lado servidor respondería a la petición SYN válida con un paquete SYN/ACK. Finalmente, el cliente debería responderle al servidor con un ACK, completando así la negociación en tres pasos (SYN, SYN/ACK y ACK) y la fase de establecimiento de conexión. Es interesante notar que existe un número de secuencia generado por cada lado, ayudando de este modo a que no se puedan establecer conexiones falseadas (spoofing).

Más información:

La fase de finalización de la conexión utiliza una negociación en cuatro pasos (four-way handshake), terminando la conexión desde cada lado independientemente. Sin embargo, es posible realizar la finalización de la conexión en 3 fases; enviando el segmento FIN y el ACK en uno solo. Cuando uno de los dos extremos de la conexión desea parar su «mitad» de conexión transmite un segmento con el flag FIN en 1, que el otro interlocutor asentirá con un ACK. Por tanto, una desconexión típica requiere un par de segmentos FIN y ACK desde cada lado de la conexión.

Una conexión puede estar «medio abierta» en el caso de que uno de los lados la finalice pero el otro no. El lado que ha dado por finalizada la conexión no puede enviar más datos pero la otra parte si podrá.

Es importante conocer este apartado porque a pesar que esta negociación la hace el shield de Ethernet o Wifi y no se programa en Arduino, sirve para saber qué está pasando cuando Arduino actúa como cliente o servidor y poder hacer depuración cuando tenemos errores.

Librería Ethernet

La librería Ethernet es la usada para manejar el Ethernet Shield que implementa la pila de protocolos TCP/IP y dentro de Arduino se implementan los protocolos en la capa de aplicación. La librería se usa entre otras cosas para mandar por Ethernet el protocolo programado en Arduino.

Para manejar el Ethernet Shield deberemos conocer todos los métodos que nos ofrece la librería Ethernet y así poder usarla.

Reference de librería Ethernet: http://arduino.cc/en/Reference/Ethernet

La librería ethernet se compone de 5 clases, cada una con sus métodos

Ethernet Class

Inicializa la librería ethernet y las configuraciones de red.

  • begin() – Inicializa la librería Ethernet (Constructor)
  • localIP() – Obtiene la dirección IP. Útil al usar DHCP
  • maintain() – Solicita una renovación al servidor DHCP

IPAddress Class

Trabaja con IPs locales y remotas. Facilita el trabajo con direcciones IPs.

Server Class

Crea un servidor que puede mandar y recibir datos de los clientes conectados.

  • Server() – Constructor de la clase server. No se usa directamente
  • EthernetServer() – Crea un servidor que escucha por las conexiones entrantes del puerto definido.
  • begin() – Le dice al servidor que comience a escuchar.
  • available() – Devuelve el cliente que está conectado al servidor y tiene datos disponibles a leer.
  • write() – Escribe datos a todos los cliente conectados al servidor.
  • print() – Escribe datos a todos los cliente conectados al servidor.
  • println() – Escribe datos a todos los cliente conectados al servidor seguido de una nueva línea.

Client Class

Crea un cliente que se conecta a un servidor y puede mandar y recibir datos.

  • Client – Constructor de la clase client. No se usa directamente
  • EthernetClient() – Crea un cliente que se conecta a una determinada IP y puerto
  • if (EthernetClient) – Indica si el cliente Ethernet está preparado
  • connected() – Devuelve si el cliente está o no conectado
  • connect() – Conecta a una IP y puerto especificado. Soporta DNS lookup. Devuelve unos códigos en función del éxito o fallo de la conexión.
  • write() – Escribe datos al servidor al que está conectado.
  • print() – Escribe datos al servidor al que está conectado
  • println() – Escribe datos al servidor al que está conectado, seguido de una nueva línea
  • available() – Devuelve el número de bytes disponibles para leer.
  • read() – Lee el siguiente byte recibido desde el servidor.
  • flush() – Borrar todos los bytes que han sido escritos en el cliente pero no leidos
  • stop() – Desconecta el cliente del servidor

Arduino nos ofrece varios ejemplo para comprender el uso de la librería:

Protocolo HTTP

Hypertext Transfer Protocol o HTTP (en español protocolo de transferencia de hipertexto) es el protocolo de comunicación que permite las transferencias de información en la WWW. Se trata de un protocolo de capa 7 de aplicación.

En arduino con la librería ethernet solo trabajamos con la capa de aplicación, todas las otras capas de TCP/IP ya están implementadas por Hardware, ya sea con la ethernet shield o el módulo WiFi. Aunque si queremos realizar algunas funciones de capas inferiores, podemos hacerlo con los comandos adecuados comunicándonos con el chip ethernet o wifi via SPI.

HTTP define la sintaxis y la semántica que utilizan los elementos de software de la arquitectura web (clientes, servidores, proxies) para comunicarse. Es un protocolo orientado a transacciones y sigue el esquema petición-respuesta entre un cliente y un servidor. Al cliente que efectúa la petición (un navegador web) se lo conoce como «user agent» (agente del usuario). A la información transmitida se la llama recurso y se la identifica mediante un localizador uniforme de recursos (URL).

HTTP es un protocolo sin estado, es decir, que no guarda ninguna información sobre conexiones anteriores. El desarrollo de aplicaciones web necesita frecuentemente mantener estado. Para esto se usan las cookies, que es información que un servidor puede almacenar en el sistema cliente. Esto le permite a las aplicaciones web instituir la noción de «sesión», y también permite rastrear usuarios ya que las cookies pueden guardarse en el cliente por tiempo indeterminado.

Una transacción HTTP está formada por un encabezado seguido, opcionalmente, por una línea en blanco y algún dato. El encabezado especificará cosas como la acción requerida del servidor, o el tipo de dato retornado, o el código de estado. El uso de campos de encabezados enviados en las transacciones HTTP le dan gran flexibilidad al protocolo. Estos campos permiten que se envíe información descriptiva en la transacción, permitiendo así la autenticación, cifrado e identificación de usuario. Ejemplos de encabezados: HTTP_ACCEPT y HTTP_USER_AGENT.

Líneas de encabezado o headers, son muy importantes y dan información adicional de la conexión y el comportamiento puede cambiar en función de ellas:

Métodos de petición HTTP

Lo más importante para comunicar arduino por HTTP con otros dispositivos, ya sean servidores, ordenadores, otros Arduinos, etc… es conocer los métodos GET y POST del protocolo HTTP. HTTP define 8 métodos que indica la acción que desea que se efectúe sobre el recurso identificado. Lo que este recurso representa, si los datos pre-existentes o datos que se generan de forma dinámica, depende de la aplicación del servidor. A menudo, el recurso corresponde a un archivo o la salida de un ejecutable que residen en el servidor.

GET

GET: Pide una representación del recurso especificado. Por seguridad no debería ser usado por aplicaciones que causen efectos ya que transmite información a través de la URI agregando parámetros a la URL. La petición puede ser simple, es decir en una línea o compuesta de la manera que muestra el ejemplo.

Ejemplo:

GET /images/logo.png HTTP/1.1 obtiene un recurso llamado logo.png

Ejemplo con parámetros:

/index.php?page=main&lang=es

POST

POST: Envía los datos para que sean procesados por el recurso identificado. Los datos se incluirán en el cuerpo de la petición. Esto puede resultar en la creación de un nuevo recurso o de las actualizaciones de los recursos existentes o ambas cosas.

Más información:

Entender los métodos get y post:

Un explicación muy buena de HTTP también se puede encontrar en:  http://www.ntu.edu.sg/home/ehchua/programming/webprogramming/HTTP_Basics.html

HTTP request

Un cliente HTTP debe formar una petición HTTP al servidor de una forma determinada para que sea entendida por el servidor. Cuando Arduino trabaja como cliente hay que programar esta petición correctamente.

Formación de un HTTP request, esta petición habrá que programar en Arduino:

http

Trama en HTTP, fijaros en el uso de cr (retorno de carro – carriage return – ASCII 13) y lf (line feed – nueva linea – ASCII 10): http://www1.ju.edu.jo/ecourse/abusufah/cpe532_Spr06/notes/BookOnLine/HTTP%20Request%20Message.htm

HTTP/1.1 se definió en el estándar RFC2616,que es la más usada actualmente. En junio de 2014 RFC2616 se retiró y HTTP/1.1 se redefinió en RFCs 7230, 7231, 7232, 7233, 7234, and 7235, HTTP/2 está en proceso de definición.

Y cuando usar GET o POST?: http://www.w3.org/2001/tag/doc/whenToUseGet.html#checklist

HTTP response

Después de recibir e interpretar el servidor un HTTP request, el servidor debe responder con un mensaje de respuesta:

Para cumplir con el protocolo HTTP, arduino debe implementar estas respuestas cuando lo uso como servidor web.

Veamos esto gráficamente:

Práctica: Comunicaciones IP

Ver diferencia de configuración en Arduino entre DHCP e IP fija:

Realizar las prácticas de Arduino Web Client: https://aprendiendoarduino.wordpress.com/2016/07/05/arduino-web-client/

Realizar las prácticas de Arduino Web Server: https://aprendiendoarduino.wordpress.com/2016/07/06/arduino-web-server/

Arduino Web Server

Crear un servidor web sencillo que saque por el puerto serie y también devuelva al navegador que le ha llamado la petición http que le ha llegado.

Luego añadir el valor leído en la entrada analógica A0.

Por último leer línea a línea la petición, esto es útil cuando hay que analizar el http request y que Arduino devuelva una cosa u otra en función de la petición que llegue.

Tutorial webserver: http://playground.arduino.cc/Code/WebServerST

Solución: https://github.com/jecrespo/Aprendiendo-Arduino/tree/master/Ejercicio26-EthernetServer

Otro ejemplo similar muy bien explicado: https://wngeek.wordpress.com/2013/07/24/185/

Al igual que hemos hecho un web server podríamos implementar un telnet server escuchando por el puerto 23. Ejemplos:

Web Embebida con Arduino

Crea una web embebida en Arduino con un botón que al pulsarlo desde el navegador encienda un led y al volver a pulsarlo apague un led.

Al recibir un get Arduino muestra una web para encender o apagar el led en función del estado del led.

Cuando pulso el botón de la web, el navegador manda un post con la instrucción de encender o apagar el led, Arduino la ejecuta y devuelve el estado en que queda el led y te da la opción de volver a la página anterior.

NOTA: Aquí además de programar arduino, se usan conceptos de HTML

Solución: https://github.com/jecrespo/Aprendiendo-Arduino/tree/master/Ejercicio27-Boton

Otro tutorial similar: http://diymakers.es/crear-servidor-web-con-arduino/

Webserver con Ajax

Crear una web embebida que controle el encendido y apagado de un led tanto manualmente pulsando un botón como automáticamente al sobrepasar un umbral que pasamos a Arduino como parámetro mediante la web con una entrada numérica. Podría asemejarse a un termostato donde la entrada es una sonda de temperatura y su valor lo comparo con la temperatura que le paso como parámetro.

La web mostrará el estado de varias entradas analógicas, un botón para encender manualmente el led y una entrada numérica para enviar el dato del umbral.

web_ajax

NOTA: aquí se usa programación en javascript para ajax.

Ajax es una técnica muy eficaz para estos casos porque para mostrar los datos actualizados dinámicamente no es necesario cargar la web completamente, sino que sólo manda los datos que se actualizan en la web que son unos pocos bytes.

Mediante Ajax podemos actualizar los datos de la web embebida en Arduino sin necesidad de cargar toda la web, sino solo mandando los datos actualizados, economizando los datos mandados a través de la red.

Ajax:

Solución: https://github.com/jecrespo/Aprendiendo-Arduino/tree/master/Ejercicio42-Ajax

Web Embebida en Linux

Otra técnica para tener una web embebida en Arduino es usar los Arduino Yun o Tian que tiene un procesador MIPS con un linux embebido y usar un servidor web linux para servir las páginas. Luego mediante las librerías bridge o ciao se puede comunicar el microntrolador de Arduino con el procesador MIPS.

En este caso la web está en un servidor web del sistema operativo openWRT basado en linux y al interactuar con él la librería bridge se encarga de comunicar internamente linux con el microcontrolador del Arduino Yun.

Ejemplo para controlar los leds de un neopixel mediante una web en un Arduino Yun: https://github.com/jecrespo/NeoPixel

Neopixel: https://www.adafruit.com/category/168

Control del coche: https://github.com/jecrespo/Coche_AprendiendoArduino

Arduino Web Client

Conexión a una web

Crear un cliente ethernet que se conecte a una web y escriba los datos recogidos. También guarde los datos en un string.

Probar a conectar a varias páginas web y usa el servicio DNS poniendo la url en lugar de la IP.

Trata de conectarte a la AEMET para ver si sería posible obtener el tiempo de logroño.

AEMET API: http://www.aemet.es/es/datos_abiertos/catalogo (open data)

Tiempo en logroño: http://www.aemet.es/xml/municipios/localidad_26089.xml

Usa la API de http://www.openweathermap.org/ para obtener los datos del tiempo en una ciudad en concreto.

Avanzado: Obtener la temperatura en logroño actualizada por el display LCD sin necesidad de un sensor de temperatura.

Tutorial: webclient con ejemplo de métodos get y post: http://playground.arduino.cc/Code/WebClient

Solución: https://github.com/jecrespo/Aprendiendo-Arduino/tree/master/Ejercicio25-EthernetClient

Un poco de información:

Open data:

NTP básico

Montar un Arduino para que recoja y mantenga la fecha y hora de un servidor NTP y así teniendo un Arduino conectado a Internet no siendo necesario usar un RTC para mantener la fecha y hora en Arduino.

Network Time Protocol (NTP) es un protocolo de Internet para sincronizar los relojes de los sistemas informáticos a través del enrutamiento de paquetes en redes con latencia variable. NTP utiliza UDP como su capa de transporte, usando el puerto 123. Está diseñado para resistir los efectos de la latencia variable.

Servidores NTP: http://www.pool.ntp.org/es/use.html

Este es un ejemplo de cliente web, pero UDP en lugar de TCP.

Conceptos a manejar:

Solución: https://github.com/jecrespo/Aprendiendo-Arduino/tree/master/Ejercicio39-NTP

Al igual que hacemos un cliente web con Arduino podríamos hacer un cliente telnet conectándose al puerto correspondiente. Ver ejemplo en https://www.arduino.cc/en/Tutorial/TelnetClient