Archivo de la etiqueta: Librerías Arduino

Protocolo HTTP

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 la pila TCP/IP ya están implementadas por Hardware, ya sea con la ethernet shield o el módulo WiFi correspondiente. 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.

Veamos algunos protocolos de la capa de aplicación que serán los que tengamos que implementar en nuestro arduino directamente o usando la librería adecuada:

HTTP es un protocolo muy importante puesto que es el que se va a usar para comunicar Arduino con cualquier elemento de la WWW o de una intranet. En el IoT es uno de los protocolos más usados y sobre todo si queremos obtener o mandar datos a servidores o usar las APIs que nos ofrecen algunos servicios para obtención de información, por ejemplo, para obtener el tiempo meteorológico de la AEMET https://opendata.aemet.es/centrodedescargas/inicio y con esos datos que Arduino actúe de una forma u otra.

Hypertext Transfer Protocol o HTTP (en español protocolo de transferencia de hipertexto) es el protocolo usado en cada transacción de la World Wide Web. HTTP fue desarrollado por el World Wide Web Consortium y la Internet Engineering Task Force.

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.

Más información sobre HTTP:

Para intercambio de archivos por HTTP usamos MIME: http://es.wikipedia.org/wiki/Multipurpose_Internet_Mail_Extensions

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:

Interesante HTTP quick guide: https://www.tutorialspoint.com/http/http_quick_guide.htm

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 simple:

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

Ejemplo con parámetros:

GET /index.php?page=main&lang=es HTTP/1.1

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.

Los otros métodos de HTTP:

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 (request) 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, sino el servidor nos mandará un mensaje de error.

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

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, como devolución a un request mandado por un cliente como puede ser un browser o navegador. De esta forma puedo implementar en Arduino una web embebida.

Por lo tanto Arduino podemos programarlo para comportarse como cliente, como servidor o como ambos.

Veamos esto gráficamente:

Ejercicio: Ver las tramas HTTP con las funciones de depuración del navegador y también con wireshark, un web sniffer on-line y algún plugin para el navegador.

Listado de web sniffers: http://scraping.pro/web-sniffers-review/

Servidor Web Embebido en Arduino

Para poder implementar un servidor web embebido en un Arduino e interactuar con él, se debe programar los mensajes http en Arduino para responder al navegador de forma adecuada.

La secuencia que se produce en una web embebida para encender y apagar un led es:

  • El navegador manda un http request GET a la IP de Arduino cuando pongo su IP en el navegador. p.e. http://192.168.1.15
  • Arduino recibe la petición que comienza por “GET / HTTP/1.1”
  • Arduino devuelve el http response con “HTTP/1.0 200K” y luego la web con el código html, haciendo print sobre el cliente ethernet y cierra la comunicación.
  • El navegador recibe el http respnse y muestra la web, en este caso un botón.
  • Al pulsar el botón en el navegador, el código HTML ya está configurado para mandar una petición POST.
  • Arduino recibe la petición que comienza por “POST / HTTP/1.1” y enciende o apaga el led según corresponda.
  • Luego Arduino muestra la web con el estado del led actualizado.

Ver este proceso con wireshark o con las herramienta de desarrollador del navegador pulsando F12.

Ver sketch en: https://github.com/jecrespo/aprendiendoarduino-Curso_Arduino_2017/tree/master/Ejercicio40-Boton_Mejorado_DHCP

Diagrama de flujo:

Más información:

Programa botón para diferentes Arduino. Comparar:

Librerías HTTP

Libreria Webduino

Webduino es una librería muy popular que nos permite implementar un servidor web en nuestro Arduino.

La web del creador: https://code.google.com/p/webduino/

El reference de la librería: https://code.google.com/p/webduino/wiki/Documentation

Repositorio de la librería: https://github.com/sirleech/Webduino

Snippet Webduino en el playground: http://playground.arduino.cc/Main/WebduinoFileServer

Para Shields con Microchip ENC28J60 no es válida esta librería puesto que necesita SW adicional para implementar la pila TCP/IP.

Una presentación que explica como funciona: https://docs.google.com/presentation/d/1QUG4XJTK3jKtU-eYUfM1DvUdRaKBrp__LEwZQfz9s6E/edit#slide=id.i0

Hilo de soporte de la librería: http://forum.arduino.cc/index.php/topic,37851.0.html

Ejercicio 29-Webduino Entender cómo funciona la librería y ver el ejemplo webdemo

Luego hacer la aplicación web buzzer.

Streaming: http://arduiniana.org/libraries/streaming/

Class Templates: http://www.cprogramming.com/tutorial/templates.html

Solución en https://github.com/jecrespo/Aprendiendo-Arduino/tree/master/Ejercicio29-Webduino

Otras Librerías

Otras librerías para implementar un servidor web en Arduino:

Y una librería para implementar un cliente HTTP:

Librería http client: https://github.com/amcewen/HttpClient

Anuncios

Librerías Arduino

Las librerías son trozos de código hechos por terceros que usamos en nuestro sketch. Esto nos facilita mucho la programación y hace que nuestro programa sea más sencillo de hacer y de entender. En este curso no veremos como hacer o modificar una librería pero en este curso debemos ser capaces de buscar una librería, instalarla, aprender a usar cualquier librería y usarla en un sketch.

Las librerías normalmente incluyen los siguientes archivos comprimidos en un archivo ZIP o dentro de un directorio. Estas siempre contienen:

  • Un archivo .cpp (código de C++)
  • Un archivo .h o encabezado de C, que contiene las propiedades y métodos o funciones de la librería.
  • Un archivo Keywords.txt, que contiene las palabras clave que se resaltan en el IDE (opcional).
  • Muy posiblemente la librería incluye un archivo readme con información adicional de lo que hace y con instrucciones de como usarla.
  • Directorio denominado examples con varios sketchs de ejemplo que nos ayudará a entender cómo usar la librería (opcional).

Como instalar librerías: http://arduino.cc/en/Guide/Libraries

Hay varios métodos de instalar librerías:

  • Mediante el IDE de Arduino de forma automática. Admite la instalación desde un fichero zip o desde una carpeta ya descomprimida.
  • Instalación Manual. Descomprimiendo en un directorio la librería y copiandolo en el directorio de librerías. Generalmente Mi Documentos – Arduino – libraries. Aquí se guardan las librerías contribuidas por el usuario como lo denomina el IDE.
  • Desde el gestor de librerías. A partir de la versión 1.6.2 del IDE de Arduino se incorpora el gestor de librerías que facilita el trabajo. Esta herramienta es accesible desde Programa → Incluir Librería → Gestionar Librerías. Desde aquí podemos ver las librerías instaladas, buscar librerías disponibles, instalar librerías y actualizarlas.
    Esta herramienta también nos permite gestionar las librerías instaladas manualmente.
    Desde C:\Users\nombre_usuario\AppData\Local\Arduino15, podemos ver en formato json el listado de librerías y placas disponibles desde el gestor de librerías y tarjetas.

La librerías instaladas se guardan en el directorio indicado desde las preferencias del IDE.

Todas las librerías disponibles en el gestor de librerías pueden encontrarse en http://www.arduinolibraries.info/

IMPORTANTE: Para añadir una librería a nuestro proyecto simplemente se añade a nuestro código la palabra clave #include seguido del nombre de la librería.

Más información: https://aprendiendoarduino.wordpress.com/2017/06/20/librerias-arduino-3/

Práctica: Instalación de Librerías

Instalar las librerías:

Más información: https://aprendiendoarduino.wordpress.com/2017/06/20/uso-de-librerias-arduino/

Práctica: Comparación de Timers

Compara el funcionamiento y limitaciones de las librerías MsTimer2.h y Timer.h

Ejecutar el ejercicio04 y comparar el funcionamiento de los dos timers.

Solución Ejercicio04: https://github.com/jecrespo/aprendiendoarduino-Curso_Arduino_Avanzado_2017/tree/master/Ejercicio04-Compara_Timers

MsTimer2 – Solo permite un temporizador que se ejecuta gracias a la interrupción asociada al timer 2 que dispone Arduino. Tiene prioridad de ejecución por encima de cualquier otra operación que se esté ejecutando.

Timer – Permite muchos temporizadores. Ejecuta la instrucción temporizada cuando puede en función de cuando se llama a “t.update();”, si hay retrasos en el loop la función se retrasa.

¿Alguna otra librería que queráis aprender a manejar? Enviar correo a aprendiendoarduino@gmail.com

Crear Librerías Arduino


NOTA: antes de crear una librería, es importante saber como son las librería de Arduino, como instalarlas y como usarlas. Recomiendo leer estos dos capítulos antes de empezar a crear tu librería Arduino:


Las librerías son trozos de código hechos por terceros que usamos en nuestro sketch. Esto nos facilita mucho la programación y permite la abstracción haciendo que nuestro programa sea más sencillo de hacer y de entender. En este apartado veremos cómo escribir o modificar librerías.

Librerías Arduino: https://www.arduino.cc/en/Main/Libraries

El IDE de Arduino incluye una serie de librerías ya instaladas: https://www.arduino.cc/en/Reference/Libraries

Listado de librerías del playground de Arduino: http://playground.arduino.cc/Main/LibraryList, pero existen otras muchas librerías creadas por usuarios o por los fabricantes de HW para facilitar el uso de esos dispositivos con Arduino.

Este tutorial explica como crear una librería: http://arduino.cc/en/Hacking/LibraryTutorial. Explica cómo convertir la función morse en en una librería.

Ejemplo ‘morse.ino’:

 
int pin = 13;

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

void loop()
{
  dot(); dot(); dot();
  dash(); dash(); dash();
  dot(); dot(); dot();
  delay(3000);
}

void dot()
{
  digitalWrite(pin, HIGH);
  delay(250);
  digitalWrite(pin, LOW);
  delay(250);
}

void dash()
{
  digitalWrite(pin, HIGH);
  delay(1000);
  digitalWrite(pin, LOW);
  delay(250);
}

Para convertir en una librería de código morse, vemos que hay dos funciones dot() y dash() para iluminar un led durante 250 ms y 1 segundo y  una variable que es ledPin que determina que pin usar. Este es un estilo de programación clásico usando funciones en lugar de objetos.

Para una librería se necesitan al menos dos ficheros:

  • Un fichero de cabecera con la extensión .h. Este fichero tiene las definiciones de la librería, básicamente un listado de todo lo que hay dentro de la librería
  • Un fichero fuente con la extensión .cpp. Este fichero el que contiene el código

En este caso la librería se va a llamar morse y generamos un fichero de cabecera llamado morse.h.

Veamos el código de morse.h donde se define la clase Morse donde tiene una línea por cada función o método y también una línea por cada variable o propiedad de la clase.

 
class Morse
{
  public:
    Morse(int pin);	//constructor
    void dot();
    void dash();
  private:
    int _pin;
};

Una clase es una colección de funciones (métodos) y variables (propiedades) que se guardan todas juntas en un solo lugar. Las funciones pueden ser públicas (public), es decir, pueden llamarse por quien usa la librería o privadas (private), es decir, que solo pueden llamarse desde dentro de la propia clase. Todas las clases tienen una función llamada constructor, que es usada para crear una instancia de la clase. El constructor tiene el mismo nombre que la clase y no tiene tipo de variable de devolución.

En el fichero de cabecera de una librería es necesario la declaración #include que de acceso a los tipos y constantes estándar del lenguaje de Arduino (esto se añade automáticamente en los sketches pero no a las librerías). Esta declaración debe ponerse antes de la definición de la clase. La declaración debe ser:

  • Versión IDE 1.x: #include “Arduino.h”
  • Versión IDE 0.x: #include “WProgram.h”

También es común poner todo el fichero de cabecera entre estas instrucciones:

 
#ifndef Morse_h
#define Morse_h

// the #include statment and code go here...

#endif

Esto evita problemas si alguien accidentalmente incluye dos veces la librería, lo que provocaría un error de compilación. A esto se llama guardián de inclusión múltiple o include guard.

 
// Guardián de inclusión múltiple
#ifndef FICHERO_YA_INCLUIDO
#define FICHERO_YA_INCLUIDO

Así se evita que un compilador poco sofisticado abra otra vez el mismo conjunto de ficheros cuando se incluye un fichero de cabecera dos o más veces. Puede darse el caso de no poner las inclusiones en el inicio de un fichero.

La directiva #include existe en dos versiones. En una se pone el nombre de fichero entre comillas, en la otra entre paréntesis angulares (el signo menor y mayor como “comillas”).

 
#include "fichero_con_comillas.h"
#include <fichero_entre_menor_y_mayor.h>

La versión con los paréntesis angulares busca los ficheros en todos los directorios que se han especificado en la llamada al compilador – normalmente con la opción “-I”. Estos directorios se suelen rastrear por el fichero incluido en el orden en que aparecen en la línea de comando.

Cuando se incluye un fichero entre comillas, entonces el compilador busca este fichero primero en el mismo directorio que el fichero actualmente compilado y después en los demás directorios. Es decir, la versión con comillas se diferencia de la versión con paréntesis angulares únicamente por buscar primero en el directorio del fichero compilado. Tras no encontrarlo ahí actaa igual.

Cuando se crea una librería se debe documentar poniendo un comentario al comienzo de la librerías con el nombre, breve descripción, quien la ha escrito, fecha, licencia, etc…

El fichero de cabecera ‘Morse.h’ queda:

 
/*
  Morse.h - Library for flashing Morse code.
  Created by David A. Mellis, November 2, 2007.
  Released into the public domain.
*/
#ifndef Morse_h
#define Morse_h

#include "Arduino.h"

class Morse
{
  public:
    Morse(int pin);
    void dot();
    void dash();
  private:
    int _pin;
};

#endif

Una vez hecho el fichero de cabecera hay que codificar el fichero fuente ‘Morse.cpp’.

Primero deben ponerse las declaraciones, esto da al resto de código acceso a las funciones estándar de Arduino y a las definiciones del fichero de cabecera:

 
#include "Arduino.h"
#include "Morse.h"

Lo siguiente es poner el constructor de la clase. Esto define que ocurre cuando se crea una instancia de la clase. En este caso el usuario debe especificar cual es el pin que se va a usar. Configuramos el pin como salida y los guardamos en una variable privada para usarlo desde otras funciones.

 
Morse::Morse(int pin)
{
  pinMode(pin, OUTPUT);
  _pin = pin;
}

El código “Morse::” antes del nombre de la función indica que la función es parte de la clase Morse. Esto se ve en todas las funciones de la clase. La variable llamada “_pin” es una variable privada tal y como se ha definido en el fichero de cabecera y se pone el simbolo “_” delante por convención para indicar que es privada y para diferenciarlo del argumento de la función, pero puede llamarse de cualquier forma mientras coincida con la definición en el fichero de cabecera.

Después de definir el constructor, se deben definir las funciones o métodos de la clase. Son las funciones que se habían definido anteriormente en el sketch:

 
void Morse::dot()
{
  digitalWrite(_pin, HIGH);
  delay(250);
  digitalWrite(_pin, LOW);
  delay(250);  
}

void Morse::dash()
{
  digitalWrite(_pin, HIGH);
  delay(1000);
  digitalWrite(_pin, LOW);
  delay(250);
}

También es habitual añadir el comentario del fichero al principio del fichero. El fichero ‘Morse.cpp’ queda de la siguiente forma:

 
/*
  Morse.cpp - Library for flashing Morse code.
  Created by David A. Mellis, November 2, 2007.
  Released into the public domain.
*/

#include "Arduino.h"
#include "Morse.h"

Morse::Morse(int pin)
{
  pinMode(pin, OUTPUT);
  _pin = pin;
}

void Morse::dot()
{
  digitalWrite(_pin, HIGH);
  delay(250);
  digitalWrite(_pin, LOW);
  delay(250);  
}

void Morse::dash()
{
  digitalWrite(_pin, HIGH);
  delay(1000);
  digitalWrite(_pin, LOW);
  delay(250);
}

De esta forma ya tenemos una librería completa. Ahora para incluirla en nuestro IDE debemos crear un directorio Morse dentro del subdirectorio “libraries” del directorio de nuestro entorno de trabajo definido en las propiedades del IDE. Copiar Morse.h y Morse.cpp dentro del directorio Morse y abrir o reiniciar el IDE de Arduino. A partir de este momento veremos nuestra librería disponible en el IDE y podremos incluirla en los sketches con la declaración #include <Morse.h>. La librería será compilada por los sketches que la usen.

El anterior sketch quedaría ahora sustituido por:

 
#include <Morse.h>

Morse morse(13);

void setup()
{
}

void loop()
{
  morse.dot(); morse.dot(); morse.dot();
  morse.dash(); morse.dash(); morse.dash();
  morse.dot(); morse.dot(); morse.dot();
  delay(3000);
}

Podemos ver que primero se llama a la declaración de la librería Morse. Esto hace que la librería esté disponible en el sketch y lo incluye en el código enviado a la placa Arduino, lo que hace que si la librería es muy pesada, ocupe mucha más memoria nuestro sketch y si no voy a usar una librería es mejor no incluirla para ahorrar espacio.

También observamos que creamos una instancia de la clase Morse llamada “morse”. Al ejecutar esta línea el constructor de la clase es llamado pasando un argumento, creando así el objeto “morse” en nuestro sketch. Luego podemos llamar a los métodos dot() y dash() precedidos del prefijo morse del nombre del objeto.

Es posible tener múltiples instancias de la clase Morse, cada una un pin diferente guardado en la variable privada “_pin”.

Si creamos una librería es conveniente crear el fichero keywords.txt dentro del directorio Morse. De esta forma conseguiremos resaltar las palabras clave que definamos en el fichero keywords. En cada línea del fichero keywords.txt se indica el nombre de la palabra clave y seguido por un tabulador, el tipo de keyword.

  • Las clases deben ser del tipo KEYWORD1 que se resaltan en naranja.
  • Las funciones deben ser del tipo KEYWORD2 que se resaltan en marrón

Para que el fichero keywords.txt se aplique al IDE es necesario reiniciar el IDE.

El fichero keywords.txt quedaría:

Morse KEYWORD1
dash KEYWORD2
dot KEYWORD2

También es aconsejable ofrecer ejemplos de uso de la librería para que los posibles usuarios sepan usarla. Esto se hace creando un directorio “examples” dentro del directorio Morse y añadir en el subdirectorio los sketches de ejemplos que serán visibles desde el IDE.

La librerías morse con los ejemplos y el fichero keywords.txt se puede descargar en: http://www.arduino.cc/en/uploads/Hacking/Morse.zip

Para más información sobre la creación de librerías con un buen “estilo Arduino”, ver la Guía de Estilo de API. Guia de estilo para escribir librerías: http://arduino.cc/en/Reference/APIStyleGuide

IMPORTANTE: Como se ve en el código de una librería usamos código de de Arduino y por lo tanto podría la librería funcionará con cualquier placa compatible. Pero generalmente las librerías tienen código a bajo nivel que puede que solo valga para un tipo de procesadores y en ese caso habrá que adaptar la librería a las instrucciones del microprocesador con el que queramos usar la librería.

Ejercicios Librerías

Hacer Librería Morse

Ejercicio15: Hacer la librería Morse y probrala con los leds del montaje.

Github clone link: https://github.com/curso-programacion-arduino/Ejercicio15.git  

Solución: https://github.com/jecrespo/aprendiendoarduino-Curso_Programacion_Arduino

Hacer Librería Coche

Ejercicio13: Hacer la librería coche para aplicar en un sketch como el visto en https://aprendiendoarduino.wordpress.com/2017/07/08/clases-y-objetos/

 
#include “Coche.h”
 
Coche MiCocheRC(6,7)
 
void setup() {
MiCoche.Arranca()
}
 
void loop() {
char valor = leeBluetooth();
 
switch (valor) {
    case ‘F’:
      MiCoche.Adelante();
      break;
    case ‘R’:
      MiCoche.Derecha();
      break;
    case ‘L’:
       MiCoche.Izquierda();
      break;
    case ‘B’:
       MiCoche.Atras();
      break;
    case ‘S’:
       MiCoche.Para();
      break;
  }
}

Crear los métodos y configurarlos:

  • Arranca()
  • Adelante()
  • Derecha()
  • Izquierda()
  • Atras()
  • Para()
  • MuestraGasolina()
  • EchaGasolina()
  • EncidendeLuces()
  • ApagaLuces()
  • Pita()

Github clone link: https://github.com/curso-programacion-arduino/Ejercicio13.git   

Solución: https://github.com/jecrespo/aprendiendoarduino-Curso_Programacion_Arduino

Crear una librería para NTP

Ejercicio: A partir del ejemplo de Arduino para obtener la hora de un servidor NTP https://www.arduino.cc/en/Tutorial/UdpNtpClient, crear una librería para obtener de forma sencilla la hora con una llamada a la función readNTP().

Ver Ejercicio39-NTP para obtener fecha y hora en Arduino sin necesidad de un RTC usando NTP: https://github.com/jecrespo/Aprendiendo-Arduino/tree/master/Ejercicio39-NTP

Basado en:

Protocolo:

Las firmas de tiempo que se usan en NTP, son de 32 bits indicando la parte entera en segundos desde  el 1 de Enero de 1900, y una parte fraccionaria también de 32 bits. Por ello la resolución teórica de NTP sería de 232 segundos =136 años, y una resolución teórica de 2E-32 segundos, o sea 0,233 nanosegundos.

Nota: Ojo al llamar al constructor de algo p.e. ethernet sin hacer el begin ethernet antes.

Solución: https://github.com/jecrespo/simpleNTP  

Uso de Librerías Arduino

Las librerías son trozos de código hechas por terceros que usamos en nuestro sketch. Esto nos facilita mucho la programación y permite la abstracción haciendo que nuestro programa sea más sencillo de hacer y de entender. En este apartado también veremos cómo escribir o modificar librerías.

Disponemos de infinidad de librerías a nuestra disposición para facilitarnos el trabajo, todas ellas son open source y disponemos de su código.

Las librerías normalmente incluyen los siguientes archivos comprimidos en un archivo ZIP o dentro de un directorio. Estas siempre contienen:

  • Un archivo .cpp (código de C++)
  • Un archivo .h o encabezado de C, que contiene las propiedades y métodos o funciones de la librería.
  • Un archivo Keywords.txt, que contiene las palabras clave que se resaltan en el IDE (opcional).
  • Muy posiblemente la librería incluye un archivo readme con información adicional de lo que hace y con instrucciones de como usarla.
  • Directorio denominado examples con varios sketchs de ejemplo que nos ayudará a entender cómo usar la librería (opcional).

Para usar una librería que acabamos de instalar, lo que hay que hacer es leer la documentación de esa librería si es que está disponible y luego leer y probar los ejemplos que dispone la librerías.

Pero ahora que ya sabemos manejar clases y objetos, si queremos entrar a fondo en una librería para saber usarla, podemos abrir el fichero del encabezado (.h) y ver las propiedades y métodos, ver si hereda de otra librería, etc… y luego incluso ver cómo funciona la propia librería leyendo el código en el fichero .cpp e incluso si nos atrevemos añadir nuevos métodos o modificar un método que nos interese.

Problemas comunes con las librerías: https://learn.adafruit.com/adafruit-all-about-arduino-libraries-install-use/common-library-problems

Librería Time y Timezone

Como ejemplo para aprender a usar una librería, veamos las librerías Time y Timezone.

Para aprender a manejarlas, simplemente leer el fichero readme que viene en el repositorio de github y luego los ejemplos.

Algunas funciones librería Time:

  • hour();            // the hour now  (0-23)
  • minute();          // the minute now (0-59)
  • second();          // the second now (0-59)
  • day();             // the day now (1-31)
  • weekday();         // day of the week, Sunday is day 0
  • month();           // the month now (1-12)
  • year();            // the full four digit year: (2009, 2010 etc)
  • hourFormat12();    // the hour now in 12 hour format
  • isAM();            // returns true if time now is AM
  • isPM();            // returns true if time now is PM
  • now();             // returns the current time as seconds since Jan 1 1970
  • setSyncProvider(getTimeFunction);  // set the external time provider
  • setSyncInterval(interval);         // set the number of seconds between re-sync

Algunas funciones librería Timezone:

  • time_t toLocal(time_t utc); Converts the given UTC time to local time, standard or daylight as appropriate.
  • TimeChangeRule myRule = {abbrev, week, dow, month, hour, offset};
    • abbrev is a character string abbreviation for the time zone; it must be no longer than five characters.
    • week is the week of the month that the rule starts.
    • dow is the day of the week that the rule starts.
    • hour is the hour in local time that the rule starts (0-23).
    • offset is the UTC offset in minutes for the time zone being defined.

Ejemplos:

  • TimeChangeRule usEDT = {“EDT”, Second, Sun, Mar, 2, -240};  //UTC – 4 hours
  • TimeChangeRule usEST = {“EST”, First, Sun, Nov, 2, -300};   //UTC – 5 hours

Una vez visto el manual de la librería, veamos cómo está escrita la librería Time de Arduino que nos ofrece funcionalidades para mantener la fecha y hora con un hardware externo o sin él. Nos permite obtener la fecha y hora como: segundo, minuto, hora, día, mes y año. También da el tiempo con el tipo de dato del estándar C time_t, siendo sencillo el cálculo del tiempo transcurrido.

Existe una nueva versión de la librería Time cuyo código está derivado librería DateTime del Arduino Playground pero está actualizada para ofrecer una API que es más flexible y fácil de usar.

Más información de la librería time: http://www.prometec.net/time-arduino/

La librería Time no requiere de ningún HW especial. Internamente depende de la función millis() de Arduino para llevar un registro del tiempo transcurrido. El tiempo se puede sincronizar con varios tipos de HW como GPS, NTP, RTC, etc…

La librería Time no dispone de ajuste de hora por zona horaria (time zone o TZ) ni ajuste de DST (Daylight Saving Time): https://en.wikipedia.org/wiki/Daylight_saving_time. Se podría añadir estas funcionalidades a la librería Time o se puede crear una nueva librería que implemente estas funcionalidades y haga uso de la librería Time.

Para solucionar esta carencia disponemos de la librería Time zone https://github.com/JChristensen/Timezone. Esta librería no es accesible desde el gestor de librerías, por lo que habrá que hacer una instalación manual de la misma.

La librería Timezone está diseñada para trabajar en conjunto con la librería Time y debe ser referenciada en el sketch que se use con timezone. Esta librería convierte el Universal Coordinated Time (UTC) a la hora local correcta incluso si hay Daylight Saving Time (DST). La hora puede obtenerse de un GPS, NTP server o un RTC.

La librería Timezone implementa dos objetos para facilitar la conversión de zona:

  • Un objeto TimeChangeRule que describe cuando la hora local cambia de hora estándar a hora de verano y viceversa.
  • Un objeto Timezone que usa TimeChangeRule para hacer las conversiones y las funciones relacionadas. También puede escribir y leer de la EEPROM el TimeChangeRule. Es posible implementar varias zonas horarias definiendo varios objetos Timezone.

Para establecer la TimeChangeRule se hace mediante dos reglas por zona, una para definir cuando comienza el horario de verano y otra cuando comienza el horario estándar. En España el cambio de horario se produce el último domingo de octubre a las 3.00 y el último domingo de marzo a las 2.00 (https://es.wikipedia.org/wiki/Horario_de_verano_en_el_mundo)

Definir un Timezone:

  • TimeChangeRule SDT = {“SDT”, Last, Sun, Mar, 2, 60};  //Spain Daylight Time UTC + 0 hours
    TimeChangeRule SST = {“SST”, Last, Sun, Oct, 3, 180};   //Spain Standard Time UTC + 1 hours
  • Timezone spainTZ(SDT,SST)

Métodos asociados:

  • toLocal(time_t utc) — Convierte la hora obtenida en UTC a hora local

Práctica: Usar librerías Time y Timezone con NTP

NTP: https://es.wikipedia.org/wiki/Network_Time_Protocol

Ejercicio14: Hacer un reloj con Arduino que muestre por el puerto serie la hora en la zona local en la que nos encontramos. Usar las librerías Time y Timezone. Encender un led cada 15 segundos de forma que los leds muestran los cuartos de minuto.

Para obtener la hora actual usar NTP con la librería https://github.com/jecrespo/simpleNTP y ver el ejemplo para entender cómo funciona. Usar el ejemplo como base para hacer el ejercicio.

Github clone link: https://github.com/curso-programacion-arduino/Ejercicio14.git

Solución: https://github.com/jecrespo/aprendiendoarduino-Curso_Programacion_Arduino

Librería Ethernet

La librería Ethernet es la usada para manejar el Ethernet Shield que es un shield que implementa la pila de protocolos TCP/IP y luego dentro de la programación 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 clientes conectados al servidor.
  • print() – Escribe datos a todos los clientes conectados al servidor.
  • println() – Escribe datos a todos los cliente conectados al servidor seguido de una nueva línea.

NOTA: Cuando se crea un servidor con la clase server, dejo un puerto escuchando peticiones por ese puerto. En el caso que entre una nueva petición, esta queda en el buffer. Cuando el buffer tiene datos, llamo a la función server.available() que devuelve un cliente (de la clase client) que está conectado al servidor y está disponible para leer.

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

EthernetUDP Class

Habilita el envío y recepción de mensajes UDP.

  • begin() – Inicializar la librería UDP
  • read() – Lee datos UDP
  • write() – Escribe datos UDP a la conexión remota.
  • beginPacket() – Comienza una conexión para escribir paquetes UDP
  • endPacket() – Finaliza una conexión UDP después de escribir
  • parsePacket() – Comprueba la presencia de un paquete UDP
  • available() – Devuelve el nº de bytes disponible para leer en el buffer
  • stop() – Desconecta del servidor
  • remoteIP() – Obtiene la IP de la conexión remota
  • remotePort() – Obtiene el puerto de la conexión remota

Más información sobre el protocolo UDP: http://es.wikipedia.org/wiki/User_Datagram_Protocol

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

Snippets para ethernet: http://playground.arduino.cc/Main/SketchList#ethernetShield

Librería Ethernet2

Para usar la nueva Arduino Ethernet Shield 2 con el W5500, es necesaria la librería Ethernet 2: https://www.arduino.cc/en/Reference/Ethernet

El uso de esta librería es similar a la de Ethernet y los métodos son los mismos. Por lo tanto un sketch para Ethernet funciona con ethernet2 simplemente cambiando la llamada a la librería correcta, es decir, poner #include <Ethernet2.h> en lugar de #include <Ethernet.h>

Esta librería hay que usarla para el Arduino Ethernet Shield 2, Arduino Leonardo Ethernet y cualquier otra placa o shield con chip W5500.

Por otra parte el propio fabricante de los chips ethernet Wiznet ha liberado una librería para sus dispositivos: https://github.com/Wiznet/WIZ_Ethernet_Library y adafruit también ha desarrollado una librería ethernet 2: https://github.com/adafruit/Ethernet2