Archivo de la etiqueta: Librerías Arduino

Crear 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 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

Uso de Librerías Arduino

La instalación, actualización y manejo librerías en Arduino es un aspecto importante a la hora de usar Arduino, veamos unos ejemplos. Para aprender a instalar librerías lo mejor es practicar, veamos unos ejemplos de instalación de algunas librerías muy útiles.

Cuando se va a instalar una librería, la primera tarea es leer la documentación y aprender a usarla, ya sea leyendo el código, viendo los ejemplos o revisando la documentación si está disponible.

Pasos para realizar los ejemplos propuestos:

  • Leer la documentación y entender que hace la librería.
  • Buscar e instalar la librería desde el gestor de librerías, si está disponible.
  • Descargar el .zip del repositorio de github si no está en el gestor de librerías. Botón Download zip
  • Abrir alguno de los ejemplo suministrados por las librerías, leer el código, entender que hace y ejecutarlo en Arduino.

Desinstalar librerías: Para desinstalar una librería simplemente borrar el directorio de la librería situado en la ruta configurada en las preferencias de Arduino y reiniciar el IDE.

Librería MsTimer2

MsTimer2 nos ofrece muchas utilidades de temporización muy útiles en el trabajo diario con Arduino.

Instalar la librería MsTimer2 desde el gestor de librerías. Ejecutar el programa de ejemplo incluido en la librería para hacer blink (FlashLed) en el led integrado sin necesidad de usar la instrucción delay().

Esquema de conexiones:

Documentación de la librería: http://playground.arduino.cc/Main/MsTimer2

Nueva versión de la librería: http://www.pjrc.com/teensy/td_libs_MsTimer2.html

Repositorio: https://github.com/PaulStoffregen/MsTimer2

Librería Timer

La librería Timer es otra de librería de muy interesante de temporización más flexible pero menos exacta de MsTimer2. Esta librería no está disponible en el gestor de librerías.

Documentación de la librería: http://www.doctormonk.com/2012/01/arduino-timer-library.html

Repositorio: https://github.com/JChristensen/Timer

Instalar la librería timer y ejecutar los ejemplos blink2 y read_A0_flashLED.

Esquema conexión blink2 (prestar atención al código y poner los leds a los pines correctos):

Esquema conexión read_A0_flashLED (prestar atención al código y poner el led al pin correcto o cambiar el código):

Comparación comportamiento librería msTimer2 y Timer: https://github.com/jecrespo/Aprendiendo-Arduino/tree/master/Otros/compara_timers

Librería Time

La librería Time que añade funcionalidades de mantenimiento de fecha y hora en Arduino sin necesidad de un hardware externo. También permite obtener fecha y hora como segundo, minuto, hora, día, mes y año.

Librería: http://playground.arduino.cc/Code/Time

Documentación: http://www.pjrc.com/teensy/td_libs_Time.html

Repositorio: https://github.com/PaulStoffregen/Time

Instalar la librería Time desde el gestor y ejecutar el ejemplo TimeSerial. Para ver la hora que debemos mandar a Arduino en el ejemplo ver https://www.epochconverter.com/

Librería para sonda temperatura/humedad DHT.

Librería para manejar un elemento HW como la sonda de temperatura y humedad DHT22.

Señal de comunicación:

Web del sensor: http://www.seeedstudio.com/depot/grove-temperaturehumidity-sensor-pro-p-838.html

Documentación: http://www.seeedstudio.com/wiki/Grove_-_Temperature_and_Humidity_Sensor_Pro

Datasheet: https://arduino-info.wikispaces.com/file/view/DHT22.pdf/556588503/DHT22.pdf

Repositorio: https://github.com/Seeed-Studio/Grove_Temperature_And_Humidity_Sensor

En este caso en el gestor de librerías tenemos dos librerías disponibles:

Pero la tienda donde lo compro me recomienda usar la librería https://github.com/Seeed-Studio/Grove_Temperature_And_Humidity_Sensor

Además de estas tres librerías, existen muchas más. Cualquiera de las librerías para la sonda DHT22 vale para usarla, pero cada una de ellas funciona diferente y cada una de ellas tiene sus ventajas e inconvenientes.

Librerías Arduino

Las librerías son trozos de código reutilizables 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 debemos ser capaces de buscar una librería, instalarla, aprender a usar cualquier librería y usarla en un sketch.

Las librerías son entre otras cosas colecciones de código que facilitan la interconexión de sensores, pantallas, módulos electrónicos, etc. El entorno de arduino ya incluye algunas librerías de manera que facilita, por ejemplo, mostrar texto en pantallas LCD.

Cuando compramos un sensor o un dispositivo nuevo es importante ver la librería que necesitamos para manejarlos. Por ejemplo:

Existen infinidad de librerías desarrolladas por terceros en internet con sus correspondientes forks, que nos ayudarán a conectar prácticamente cualquier dispositivo a los Arduinos de forma muy sencilla o hacer tareas de programación complejas.

Estructura de una Librería Arduino

Las librerías incluyen los siguientes archivos comprimidos en un archivo ZIP o dentro de un directorio:

  • Un archivo .cpp (código de C++). Al menos uno pero puede haber más.
  • Un archivo .h o encabezado de C (header), que contiene las propiedades y métodos o funciones de la librería. Cada archivo .cpp tiene su correspondiente archivo .h. Al menos uno pero puede haber más.
  • Un archivo Keywords.txt, que contiene las palabras clave que se resaltan en el IDE (opcional).
  • Un archivo README.md con información adicional de lo que hace y con instrucciones de como usarla. (opcional)
  • Directorio denominado examples con varios sketchs de ejemplo que nos ayudará a entender cómo usar la librería (opcional).
  • Adicionalmente puede haber otros archivos menos importantes como el de la licencia y otros.

Instalación de Librerías

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

Hay varios métodos de instalar librerías:

  • 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 desde el gestor de librerías o desde http://www.arduinolibraries.info/.

  • Mediante el IDE de Arduino de forma automática. Admite la instalación desde un fichero zip o desde una carpeta ya descomprimida. Es el método adecuado para aquellas librerías que no están disponibles desde el gestor de librerías.

  • Instalación Manual. Descomprimiendo en un directorio la librería y copiandolo en el directorio de librerías. Generalmente es el directorio Mis Documentos – Arduino – libraries. Aquí se guardan las librerías contribuidas por el usuario como lo denomina el IDE.
    En caso de instalación manual, es necesario reiniciar el IDE antes de poder utilizar la librería.

Este enlace explica como actualizar una librería: https://github.com/firmata/arduino#updating-firmata-in-the-arduino-ide—arduino-164-and-higher

IMPORTANTE: Un listado de todas las librerías disponibles en el arduino library manager: https://www.arduino.cc/en/Guide/Libraries se puede ver en http://www.arduinolibraries.info/. En esta web se pueden buscar librerías por categoría, tipo, arquitectura o autor. Por ejemplo sobre timing tenemos http://www.arduinolibraries.info/categories/timing

El propio IDE de Arduino ya trae integradas varias librerías, pero además podemos descargar otras e incorporarlas a nuestro IDE y luego usarlas en nuestros programas.

La librerías instaladas por nosotros por cualquiera de los métodos anteriores, se guardan en el directorio indicado desde las preferencias del IDE.

El listado de librerías incluidas en el IDE, tanto las propias como las de terceros, podemos verlo en este enlace y acceder a la documentación de cada una de ellas para saber como usarlas: http://arduino.cc/en/Reference/Libraries. Estas librerías ya están instaladas en el IDE de Arduino y no es necesario instalarlas.

La librerías incluidas en el IDE tienen ejemplos para comprender su uso. Toda la información en: http://www.arduino.cc/en/Tutorial/LibraryExamples

Por ejemplo, la librería para trabajar con pantallas LCD. En este enlace está la documentación para el uso de esta librería así como los métodos que nos facilita para trabajar con este tipo de pantallas: http://arduino.cc/en/Reference/LiquidCrystal

En el Arduino Playground también tenemos un listado mucho más amplio de librerías, ordenadas por categorías: http://playground.arduino.cc/Main/LibraryList

También tenemos información de como interactuar con diferente HW en http://playground.arduino.cc/Main/InterfacingWithHardware y un conjunto de ejemplos y snippets para usar con Arduino en http://playground.arduino.cc/Main/SketchList

Incluir Librerías en Sketch

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.

Esto también se puede hacer desde el IDE en el menú Programa – Incluir Librería y seleccionar la librería que deseamos incluir y está instalada.

Generalmente cada dispositivo que compramos, shield, sensor, actuador, etc… viene con su propia librería que debemos instalar para poder usarlo. Estas librerías podemos verlas, modificarlas o incluso añadir funcionalidades.

A la hora de elegir un elemento de hardware, uno de los argumentos importantes es la librería que nos ofrece el fabricante o la comunidad y su facilidad de uso.

Por ejemplo si compramos una sonda de temperatura y humedad de tipo DHT11 como esta: http://www.adafruit.com/product/386, para usarla necesitaremos su librería correspondiente.

En la web del fabricante o el vendedor deberemos tener disponible la librería y el datasheet del dispositivo, en este caso.