Archivo de la etiqueta: Librerías Arduino

Programación Arduino

La programación de Arduino es la programación de un microcontrolador. Esto era algo más de los ingenieros electrónicos, pero Arduino lo ha extendido a todo el público. Arduino ha socializado la tecnología.

Programar Arduino consiste en traducir a líneas de código las tareas automatizadas que queremos hacer leyendo de los sensores y en función de las condiciones del entorno programar la interacción con el mundo exterior mediante unos actuadores.

Arduino proporciona un entorno de programación sencillo y potente para programar, pero además incluye las herramientas necesarias para compilar el programa y “quemar” el programa ya compilado en la memoria flash del microcontrolador. Además el  IDE nos ofrece un sistema de gestión de librerías y placas muy práctico. Como IDE es un software sencillo que carece de funciones avanzadas típicas de otros IDEs, pero suficiente para programar.

Estructura de un Sketch

Un programa de Arduino se denomina sketch o proyecto y tiene la extensión .ino. Importante: para que funcione el sketch, el nombre del fichero debe estar en un directorio con el mismo nombre que el sketch.

No es necesario que un sketch esté en un único fichero, pero si es imprescindible que todos los ficheros estén dentro del mismo directorio que el fichero principal.

void setup() {
 // put your setup code here, to run once:
}

void loop() {
 // put your main code here, to run repeatedly:
}

La estructura básica de un sketch de Arduino es bastante simple y se compone de al menos dos partes. Estas dos partes son obligatorios y encierran bloques que contienen declaraciones, estamentos o instrucciones.

Adicionalmente se puede incluir una introducción con los comentarios que describen el programa y la declaración de las variables y llamadas a librerías.

setup() es la parte encargada de recoger la configuración y loop() es la que contiene el programa que se ejecuta cíclicamente (de ahí el término loop –bucle-). Ambas funciones son necesarias para que el programa trabaje.

La estructura del sketch está definida en el siguiente enlace: http://arduino.cc/en/Tutorial/Sketch

Se puede resumir un sketch de Arduino en los siguientes diagramas de flujo:

Un ejemplo puede ser el diagrama de flujo de un sistema de arranque y parada de un motor DC:

Esquema de conexiones:

El código asociado a este diagrama se puede encontrar en https://github.com/jecrespo/Aprendiendo-Arduino-Proyectos/tree/master/Proyecto_02-Motor_DC_Controlado

Lenguaje de Programación Arduino

El lenguaje de programación de Arduino es C++. No es un C++ puro sino que es una adaptación que proveniente de avr-libc que provee de una librería de C de alta calidad para usar con GCC (compilador de C y C++) en los microcontroladores AVR de Atmel y muchas utilidades específicas para las MCU AVR de Atmel como avrdude: https://learn.sparkfun.com/tutorials/pocket-avr-programmer-hookup-guide/using-avrdude

Las herramientas necesarias para programar los microcontroladores AVR de Atmel son avr-binutils, avr-gcc y avr-libc y ya están incluidas en el IDE de Arduino, pero cuando compilamos y cargamos un sketch estamos usando estas herramientas.

Aunque se hable de que hay un lenguaje propio de programación de Arduino, no es cierto, la programación se hace en C++ pero Arduino ofrece una api o core que facilitan la programación de los pines de entrada y salida y de los puertos de comunicación, así como otras librerías para operaciones específicas. El propio IDE ya incluye estas librerías de forma automática y no es necesario declararlas expresamente. Otra diferencia frente a C++ standard es la estructuctura del programa que ya hemos visto anteriormente.

Toda la información para programar Arduino se encuentra en el reference de la web de Arduino: https://www.arduino.cc/en/Reference/HomePage y es la capa superior que ofrece Arduino para programar los microcontroladores de una forma sencilla y con un lenguaje de programación entendible fácilmente.

Un manual sencillo de entender para la programación es el “arduino programming notebook” de brian w. Evans. Puedes consultarlo o descargarlo desde:

En contraposición al core de Arduino, es posible usar comandos estándar de C++ en la programación de Arduino siempre que estén incluidos en el avr libc:

Cuando compilamos y cargamos el programa en Arduino esto es lo que ocurre:

Además todo esto no solo es válido para las placas Arduino, sino para muchas otras placas y microcontroladores que usando el mismo lenguaje de programación tenemos soporte para compilarlo y transferir el código binario a la memoria flash del microcontrolador.

Un ejemplo de uso de funciones AVR que no dispone el entorno de Arduino es cuando queremos hacer delays muy pequeños. La función delayMircoseconds() puede hacer el delay más pequeño con el lenguaje de Arduino que es de 2 microsegundos.

Para delays menores es necesario usar ensamblador y en concreto la función ‘nop’ (no operation. Cada llamada a ‘nop’ ejecuta un ciclo de reloj que para 16 MHz es un retraso de 62,5 ns.

__asm__("nop\n\t"); 
__asm__("nop\n\t""nop\n\t""nop\n\t""nop\n\t");

Otra característica propia de la programación de microcontroladores en C++ son el acceso a los elementos de HW mediante la lectura y escritura en los registros del microcontrolador.

Los registros son unas zonas concretas de la memoria RAM accesibles directamente desde la CPU o desde otros elementos del microcontrolador que permite hacer operaciones directas.

Cálculos de la velocidad de las operaciones en Arduino: http://forum.arduino.cc/index.php?topic=200585.0

Librerías

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).

La instalación de librerías se puede hacer directamente desde el gestor de librerías o manualmente.

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

Además de estas librerías “oficiales” que podemos obtener desde el gestor de librerías y las publicadas en el playground de Arduino, existen muchos desarrollos disponibles en Internet y los propios fabricantes de componentes HW publican las librerías para poder usarlo o incluso la propia comunidad de usuarios.

Ejemplo de librería: https://github.com/jecrespo/simpleNTP

Ejemplo de Programación

Como ejemplo del proceso de programación con Arduino es el contador de minutos para charlas hecho con una matriz 8×8 de leds tricolor: https://www.adafruit.com/product/1487

Este contador marca los minutos que llevas durante la charla y marca en bloque de 10 colores para indicar la finalización de cada capítulo de 10 minutos

Pasos:

  1. Leer caracteristicas del HW y como conectarlo: https://learn.adafruit.com/adafruit-neopixel-uberguide
  2. Elegir una librería para manejarlo: http://fastled.io/
  3. Instalar la librería: https://github.com/FastLED/FastLED
  4. Leer cómo manejar la librería: https://github.com/FastLED/FastLED/wiki/Basic-usage
  5. Escribir el código y publicarlo: https://github.com/jecrespo/Aprendiendo-Arduino/blob/master/Otros/Neopixel_contador/Neopixel_contador.ino

Computación Física

La computación física (physical computing) se refiere al diseño y construcción de sistemas físicos que usan una mezcla de software y hardware para medir e interactuar con el medio que le rodea.

La computación física significa la construcción de sistemas físicos interactivos mediante el uso de software y hardware que pueden detectar y responder al mundo analógico. En un sentido amplio, la computación física es un marco creativo para entender la relación de los seres humanos con el mundo digital. En el uso práctico, el término describe con mayor frecuencia proyectos artesanales, de diseño o de hobby que utilizan sensores y microcontroladores para traducir entradas analógicas a un sistema de software y controlar dispositivos electromecánicos tales como motores, servos, iluminación u otro hardware.

La computación física es un enfoque para aprender cómo los seres humanos se comunican a través de computadoras que comienza por considerar cómo los seres humanos se expresan físicamente. La interacción clásica con los ordenadores es a través de teclados, ratones, pantalla, altavoces, etc… y toda la programación se hace con esos límites. En el caso de la computación física, no existen esos límites sino los del ser humano que interactúa.

Programación en Tiempo Real (RTC)

En informática, la programación en tiempo real (RTC) o reactive computing describe sistemas de hardware y software sujetos a una “restricción en tiempo real”, por ejemplo, un evento a una respuesta del sistema. Los programas en tiempo real deben garantizar la respuesta dentro de las limitaciones de tiempo especificadas. A menudo se entiende que las respuestas en tiempo real están en el orden de milisegundos, ya veces microsegundos. Un sistema no especificado como en tiempo real normalmente no puede garantizar una respuesta dentro de un periodo de tiempo, aunque pueden darse tiempos de respuesta reales o esperados.

Un sistema en tiempo real ha sido descrito como aquel que “controla un entorno recibiendo datos, procesándolos y devolviendo los resultados lo suficientemente rápido para afectar el entorno en ese momento”. El término “tiempo real” se utiliza en el control de procesos y sistemas empresariales significa “sin demora significativa”.

El software en tiempo real puede usar:

Con Arduino hacemos una programación en tiempo real recibiendo continuamente datos de los sensores o de los puertos de comunicación, analizandolos y respondiendo al entorno mediante los actuadores o las comunicaciones en un tiempo muy rápido.

Los sistemas operativos en tiempo real (RTOS) son sistemas que responden a la entrada inmediatamente. Se utilizan para tareas tales como la navegación, en las que el ordenador debe reaccionar a un flujo constante de nueva información sin interrupción. La mayoría de los sistemas operativos de uso general no son en tiempo real porque pueden tardar unos segundos, o incluso minutos, en reaccionar.

Implementación de multitarea:

Existen sistemas operativos en tiempo real (RTOS) para Arduino como freeRTOS: http://www.freertos.org/

freeRTOS en Arduino: https://feilipu.me/2015/11/24/arduino_freertos/

Arduino Sleep Mode

En muchos proyectos donde no es posible tener alimentación eléctrica o de movilidad tenemos que alimentar el microcontrolador mediante batería, para conseguir alimentar un microcontrolador durante mucho tiempo con batería podemos usar el modo sleep donde el consumo se reduce drásticamente.

Ya vimos en el apartado de alimentación Arduino que no tiene sentido alimentar una placa de Arduino con una batería, incluso aunque pongamos la MCU en modo sleep, puesto que los componentes de la placa son altamente ineficientes. Sencillamente porque la eficiencia nunca entró en las especificaciones de diseño, hasta los nuevos modelos.

Normalmente, hay muchos proyectos en los que hay que realizar acciones periódicas de tiempo en tiempo, como tomar lecturas de sensores o enviar mensajes a un servidor central, pero la mayor parte del tiempo nuestro Arduino no está haciendo nada más que un loop continuo.

Sin embargo no hacer nada para un procesador, sigue suponiendo miles de instrucciones por segundo que consumen una energía preciosa, cuando funciona a baterías.

Cuando el microcontrolador entra en modo de suspensión (sleep) por su código, la ejecución del código se detendrá en ese punto. Para reanudar la ejecución de su código, el microcontrolador debe ser despertado desde el modo de suspensión por uno de sus módulos internos de hardware, temporizador expirado, interrupción externa, WDT, etc.

La librería estándar de Arduino, por ahora no permite acceso a las funciones que hacen dormir al MCU (Microcontrolador) y hay que usar la librería AVR directamente o librerías de terceros que nos ayuden a usar el modo sleep.

Para más información ver la documentación del ATmega328p http://www.atmel.com/Images/Atmel-42735-8-bit-AVR-Microcontroller-ATmega328-328P_datasheet.pdf en las página 62

Tenemos en el Atmega328p seis modos de Sleep:

  • Idle
  • ADC Noise Reduction
  • Power-save
  • Power-down
  • Standby
  • Extended Standby

El consumo para cada modo es:

  • SLEEP_MODE_IDLE: 15 mA
  • SLEEP_MODE_ADC: 6.5 mA
  • SLEEP_MODE_PWR_SAVE: 1.62 mA
  • SLEEP_MODE_EXT_STANDBY: 1.62 mA
  • SLEEP_MODE_STANDBY : 0.84 mA
  • SLEEP_MODE_PWR_DOWN : 0.36 mA

Los registros usados para manejar el modo sleep:

  • Sleep Mode Control Register The Sleep Mode Control Register contains control bits for power management. When addressing I/O Registers as data space using LD and ST instructions, the provided offset must be used. When using the I/O specific commands IN and OUT, the offset is reduced by 0x20, resulting in an I/O address offset within 0x00 – 0x3F.
    Name:  SMCR
  • MCU Control Register When addressing I/O Registers as data space using LD and ST instructions, the provided offset must be used. When using the I/O specific commands IN and OUT, the offset is reduced by 0x20, resulting in an I/O address offset within 0x00 – 0x3F.
    Name:  MCUCR
  • Power Reduction Register
    Name:  PRR

Sleep mode select del registro SMCR:

En avr-libc la librería que gestiona el modo sleep es <avr/sleep.h>

Más información:

Librerías Modo Sleep Arduino

La librería más ampliamente usada es la low power:

También hay otras librerías como Enerlib http://playground.arduino.cc/Code/Enerlib o usar las funciones de avr-libc http://www.engblaze.com/hush-little-microprocessor-avr-and-arduino-sleep-mode-basics/

Con la librería lowpower es muy fácil poner en modo sleep a Arduino con una línea como:

LowPower.powerDown(SLEEP_8S, ADC_OFF, BOD_OFF);

Hay tres maneras de despertar un Arduino del modo Sleep:

  • Interrupciones hardware
  • Timers y WDT que es un timer un tanto peculiar
  • UART o puerto serie.

Si por un error de programación dejamos arduino en modo sleep permanente, hay que vaciar la flash de programa y la forma más sencilla es reinstalar reprogramarlo con el blinking led o cualquier otro programa que no incluya instrucciones de dormir.

En este caso estamos usando el Watch Dog Timer y es una interrupción periódica que se dispara, si el contador llega a 0. EL WatchDog Timer acepta diferentes periodos de disparo, de entre una tabla:

  • SLEEP_15MS
  • SLEEP_30MS
  • SLEEP_60MS
  • SLEEP_120MS
  • SLEEP_250MS
  • SLEEP_500MS
  • SLEEP_1S
  • SLEEP_2S
  • SLEEP_4S
  • SLEEP_8S
  • SLEEP_FOREVER

Esta sencilla instrucción (powerdown) es la de menor consumo de energía, pero hay otros modos que pueden mantener encendidos ciertos circuitos del procesador interno del UNO y del Nano y pueden ser útiles:

  • idle
  • adcNoiseReduction   
  • powerDown
  • powerSave
  • powerStandby   
  • powerExtStandby
  • standby

Lista de lo que hace cada modo:

Le pasamos dos parámetros más además del tiempo de despertar, que son:

  • ADC_OFF: Apaga los convertidores Analógico a digital
  • BOD_OFF: Apaga el circuito de Brown Out Detection, que es un circuito para detectar niveles bajos de tensión. Si no fuera por este detector BOD, cuando las pilas se fueran agotando la tensión podría descender de un cierto nivel y dañar los circuitos. Apagarlo ayuda a reducir consumo, pero ciertamente corres otros peligros.

Usar el WatchDog Timer (del que ya hemos hablado) para despertar cada 8 segundos es una solución, sin embargo en un proyecto que requiera tomar lecturas cada media hora, despertar nuestro MCU cada 8 segundos es excesivo, cuando tenemos que estrujar al máximo la capacidad de la batería.

Para solucionar esto hay un modo de dormir nuestro procesador especialmente útil, que es el de duérmete sin fecha de despertar, pero despierta cuando recibas una interrupción, es decir cuando ocurra algo que estamos esperando.

Para ello usamos el ejemplo:

void loop()
   {   	attachInterrupt( 0, ServicioBoton, FALLING);
   	LowPower.powerDown(SLEEP_FOREVER, ADC_OFF, BOD_OFF);
   	detachInterrupt(0);

   	if (n != contador)
      	{     Serial.println(contador);
            	n = contador ;
            	Serial.flush();
      	}
   }

La primera línea del loop() engancha una interrupción llamada ServicioBoton que se dispara cuando usamos el pulsador, y que simplemente incrementa contador, para saber cuántas veces se ha pulsado.

La segunda línea, pone nuestro Arduino a dormir ay va a seguir así hasta que reciba una interrupción. Cuando detecte una interrupción hardware en el pin 2, despierta súbitamente, Incrementa el valor de contador y sigue el ciclo normal del programa, donde se encuentra lo primero con un detachInterrupt, es decir, deshabilitamos las interrupciones hasta que hagamos nuestra tarea, que en este caso son simplemente comprobar si contador (Que se incrementó con la interrupción) es diferente de n (El valor último registrador de contador) y si es así imprime el valor de contador.

Fijaros que no estamos haciendo un debouncing del pulsador. Sería una muy mala idea hacerlo aquí con un delay, porque el tiempo que durase el delay, nuestro procesador está activo y consumiendo y eso es algo que no interesa.

También usamos un flush() al final para asegurarnos de que se vacía la cola.

Ejemplo de reducción de consumo:

Tutorial en 5 partes sobre modo sleep:

También hay otra librería de bajo consumo de JeeLib. Para reducir el consumo al máximo lo mejor es utilizar un microcontrolador solamente y en el skech incluir la librería de bajo consumo JeeLib.

JeeLib es una colección de ficheros de cabecera, clases y sketches de muestra para su uso con el IDE de Arduino. Fue escrito y extendido durante los años para simplificar la experimentación y la exploración del JeeNode y otros productos de JeeLabs.

La clase sleepy es muy sencilla de usar y muy eficaz para hacer sketchs de bajo consumo y su uso está documentada en: http://jeelabs.org/pub/docs/jeelib/classSleepy.html

Más información:

Arduinos Compatibles Bajo Consumo

En el mercado tenemos modelos de Arduino y compatible diseñados para tener bajo consumo y ser alimentados por batería. Combinando este HW con una programación eficiente podemos lograr dispositivos alimentados por batería durante años:

Estas placas están diseñadas para consumir poco y usan elementos eficientes. Como se puede ver son placas que prescinden de elementos innecesarios simplificando mucho las placas.

El arduino UNO es altamente ineficiente puesto que el diodo de protección y el regulador de tensión consumen mucho aunque la MCU esté en modo sleep. Intentar alimentar una placa Arduino UNO con una pila de 9V no es posible si quieres que dure más de un día.

Moteino es una plataforma de desarrollo compatible con Arduino inalámbrico de bajo coste de bajo consumo basada en el popular chip ATmega328p utilizado en Arduinos tradicionales, lo que la hace 100% compatible con el IDE de Arduino. Moteino no incluye un convertidor USB-Serial (como los Arduinos tradicionales), en su lugar es necesario utilizar un adaptador FTDI externo para cargar los sketches, las ventajas son un menor costo y menor tamaño. Sin embargo, hay una variante MoteinoUSB que el convertidor serie integrado. Son dispositivos compatibles con Arduino que utilice el popular transceptor HopeRF RFM69 o el RFM12B más antiguo. Moteino también viene con un chip de memoria flash SPI opcional para programación inalámbrica o registro de datos.

Más información:

Para Arduinos alimentados por batería es interesante usar un dispositivo de medida de voltaje de la batería y saber su capacidad.Esto puede medirse directamente de la batería usando un divisor de tensión:

Librerías Arduino

Manejar 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).

La distintas formas de instalar librerías se puede ver en https://aprendiendoarduino.wordpress.com/2016/06/27/librerias-3/

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

Con el nuevo gestor de librerías es mucho más fácil gestionar las librerías instaladas así como su versión y actualización, algo que antes había que hacer manualmente

El listado de librerías se actualiza de internet y se guarda en:

  • C:\Users\usuario\AppData\Local\Arduino15\library_index.json

Las placas se actualiza de internet (del gestor de tarjetas) y se guarda en:

  • C:\Users\usuario\AppData\Local\Arduino15\package_index.json

El fichero library_index.json se actualiza al abrir el IDE y en caso de tener problemas, se puede borrar y se genera de nuevo al abrir el IDE.

Es importante darse de alta en github puesto que nos permite estar al día de las novedades en las librerías y recibir notificaciones cada vez que haya una modificación en las mismas. Además podemos fácilmente actualizar nuestro repositorio de librerías con el comando PULL de git y poner una u otra versión en nuestro repositorio con el comando checkout.

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…

Veamos cómo está escrita la librería. El código lo encontramos en https://github.com/PaulStoffregen/Time. En el readme.txt explica con detalle el uso de la librería. Explica las funciones disponibles, los ejemplos dentro del directorio examples y el funcionamiento interno de la librería. también hay un fichero keywords.txt con las palabras clave que se van a resaltar en el IDE.

También pueden verse los ficheros:

  • library.json – Información de la librería
  • library.properties – datos de la librería y clasificación que sale en el Gestor de Librerías

Los ficheros que componen la librería son:

  • Time.h — Simplemente incluye a TimeLib.h, se hace por temas de compatibilidad
  • TimeLib.h — Fichero de cabecera de la libreria Time.
  • Time.cpp — código de la librería time
  • DateStrings.cpp — contiene los strings de las fecha en inglés, pero se podría hacer una versión modificada para español.

Fichero TimeLib.h:

  • #ifdef __cplusplus permite a la sección del programa que está dentro ser compilado solo si la macro especificada como parámetro de ha definido. en este caso __cplusplus es una macro definida cuando el compilador de c++ está en uso. Esto se usa para comprobar si una cabecera está compilada bajo C o C++
  • #include <inttypes.h> incluye la cabecera de inttypes.h que está en C:\Program Files (x86)\Arduino\hardware\tools\avr\avr\include, cuyo propósito es proveer un conjunto de tipos de enteros cuyas definiciones sean consistentes en todas las máquinas e independientes de sistemas operativos. Define una serie de macros para usar con printf y scanf, así como funciones para trabajar con el tipo de dato intmax_t que es un entero con el máximo de anchura soportado. Ver http://www.cplusplus.com/reference/cstdint/
  • Se define el tipo de dato http://www.cplusplus.com/reference/ctime/time_t/ del estandar C++ que no dispone el avr libc y se “simula” la librería time.h de C++ que no tiene implementada AVR.
  • Se definen una serie de variables enumeradas con typedef enum y typedef struct
  • Se definen unas macros para convertir los años de tmYear a un valor de 4 dígitos
  • El valor de domingo es 1 como se puede ver en:
    typedef enum {dowInvalid, dowSunday, dowMonday, dowTuesday, dowWednesday, dowThursday, dowFriday, dowSaturday} timeDayOfWeek_t; y como lo define en la macro #define dayOfWeek(_time_)
  • Se definen luego las funciones y se puede ver que hay sobrecarga en las funciones. Por ejemplo en la función setTime que puede ajustar el tiempo pasando un time_t o los datos de hora, minuto, segundo, día, mes y año.

Ficheros Time.cpp y DateStrings.cpp:

  • La función más importante es now() que calcula el numero de segundo transcurridos desde la última llamada a now()
  • En la función now() es donde comprueba si toca sincronizar de nuevo la hora con (nextSyncTime <= sysTime)
  • En la variable sysTime se guarda la hora, es una variable privada.
  • Se definen primero las funciones públicas en Time.cpp y luego las funciones de bajo nivel.
  • Para sincronizar la hora externamente se definen las funciones:
    • setSyncProvider(getTimeFunction);  // set the external time provider
    • setSyncInterval(interval);         // set the number of seconds between re-sync
  • En DateStrings.cpp está la definición de los strings de fechas. Los strings los guarda en la memoria flash para no ocupar memoria RAM. Para ello usa PROGMEM y si no es para AVR, define el PROGMEM y las funciones de progmem de AVR.
  • Se modifican las funciones que devuelven el string del día y del mes pasando el entero con el número de día o mes.

Adicionalmente tenemos otras librería:

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

Ficheros librería:

  • Timezone.h
    • Implementa compatibilidad con IDEs Arduino anteriores a version 1.x comprobando la versión de ARDUINO
    • Incluye la librería Time
    • Define las constantes de los nombres con enum y el número de inicio. Define como día 1 el Domingo en lugar del Lunes
    • TimeChangeRule es un struct con el nombre (abbrev), 4 bytes para: semana, día de la semana, mes y hora y un entero para el offset de la zona horaria
    • Clase Timezone con dos constructores, 7 métodos públicos, 2 métodos privados y 6 variables privadas.
  • Timezone.cpp
    • __AVR__ es una macro que indica si el compilador puede usar procesadores AVR y en ese caso uso la librería EEPROM
    • Puedo construir un objeto Timezone con el par de reglas DST o si la tengo guarda en la EEPROM, pasando la dirección donde la tengo guardada.
    • calcTimeChanges() calcula el nuevo dst start y std start al llamarlo.
    • Al usar toLocal() ya autocalculo las fechas de dst start y std start. Ver ejemplo https://github.com/JChristensen/Timezone/blob/master/examples/Clock/Clock.pde

Más información del uso de la librería Timezone en:

NOTA: la librería timezone no soporta leapsecond https://es.wikipedia.org/wiki/Segundo_intercalar pero podría implementarse en la librería. Ver http://stackoverflow.com/questions/9168970/arduino-leap-second-clock

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

Ver ejemplos simples de librerías:

Más información:

Guía de estilo para escribir una librería de Arduino

Para facilitar el entendimiento de las librerías o APIs de Arduino y hacer que el entorno de Arduino sea más homogéneo, desde arduino.cc dan unas pautas para escribir librerías al “estilo Arduino”. Algunas de estas prácticas van en contra de la programación programación profesional, pero esto hace posible a los principiantes comenzar a trabajar de forma sencilla con Arduino.

  • Se amable con el usuario. Tener una modelo claro del concepto que va tratar la librería y las funciones que se van a implementar.
  • Organizar las funciones pública alrededor de los datos y funcionalidades que el usuario quiere. Frecuentemente el conjunto de comandos para un módulo electrónico son demasiado complicado, pero podemos reorganizar las funciones desde un punto de vista de uso a alto nivel. Pensar en lo que hace la mayoría de las personas y organizar la API en función de ese uso. Un ejemplo es la librería https://github.com/adafruit/Adafruit-BMP085-Library. La función readPressure() hace todos los pasos para obtener la presión final, siendo transparente para el usuario todos los complejos pasos intermedios. Esto abstrae al usuario no solo de los comandos I2C necesarios, sino de de los cálculos intermedios.
  • Usar palabras claras para escribir la librerías. Usar nombres de funciones y variables claros que expresen claramente lo que son o hacen y no usar términos técnicos.
  • Evitar palabras que tengan diferente significado para el público en general.
  • Documentar todo. Al escribir ejemplos usar esta guía: http://www.arduino.cc/en/Reference/StyleGuide
  • Usar las librerías del core de Arduino y su estilo:
    • Usar read() para leer entradas y write() para escribir salidas
    • Usar las librerías Stream.h y print.h cuando se estén manejando byte streams. Si no es posible al menos intentar usar su modelo de API.
    • Para aplicaciones de redes, usar las librerías de Client y Server como base.
    • Usar begin() para inicializar unas instancia de una librería, normalmente con unos parámetros de configuración. Usar end() para finalizarla.
  • Usar funciones camel case, no con guión bajo. Por ejemplo analogRead en lugar de analog_read. Esto es una adopción de processing por motivos de facilidad la lectura.
  • No usar nombre de constantes largos que son difíciles de leer.
  • Evitar usar argumentos booleanos. En su lugar es preferible ofrecer dos funciones diferentes con nombres que describan la diferencia entre ellas.
  • No asumir conocimiento de punteros. Los principiantes en C suelen encontrar dificultades con el uso de & y *, en la medida de lo posible tratar de evitar el uso de punteros.
  • Al usar la comunicación serie de cualquier tipo, permitir al usuario especificar el objeto de stream en lugar de solo “Serial”, esto hará la librería compatible con los los puertos del Arduino Mega y Due y también poder usar interfaces alternativos como el SoftwareSerial. ver el uso de begin(Stream &serial) en las librerías https://github.com/firmata/arduino y https://github.com/andrewrapp/xbee-arduino
  • Cuando se escriba una librería que ofrezca comunicación byte-stream heredada de la la clase Stream de Arduino, de forma que la librería pueda ser usada por otras librerías que acepte objetos Stream: si es posible, el método read() inmediatamente accede a los datos del buffer sin esperar a que lleguen más datos y si es posible el método write() debe guardar los datos al buffer de transmisión, pero debe esperar si el buffer no tiene suficiente espacio para guardar inmediatamente todo los datos salientes. La función yield() debe llamarse mientras se espera. De esta forma mantenemos compatibilidad con el restos de librerías Stream.

Unos ejemplos de librerías que definen realmente bien las funciones de alto nivel son:

Viendo los métodos públicos que definen es muy fácil entender que es lo que hacen.

Otro buen ejemplo de abstracción de la librerías wire (I2C) se puede ver en: https://github.com/adafruit/RTClib donde con una serie de métodos obtengo los datos del RTC siendo totalmente transparente para el usuario el uso de la librería wire.

Es frecuente que nos encontremos que algunas librerías se quedan cortas para algunas funcionalidades avanzadas, puesto que como se ha visto en la guía de estilo se tiende a simplificar. Un ejemplo de esto es la librería ethernet donde muchas de las funcionalidades del Wiznet 5100 no están implementadas en la librería, pero esto no impide que nosotros podamos añadirlas.

Más información: https://www.arduino.cc/en/Reference/APIStyleGuide

Modificar librerías

Es habitual que al usar una librería necesitemos una propiedad o un método que no esté implementado o queramos modificar el comportamiento, para ello podemos modificar localmente la librería que tengamos instalada en nuestro IDE.

En el caso que queramos colaborar en una librería hecha, podemos hacer un fork de esa librería en nuestra cuenta de github y añadir una nueva funcionalidad o corregir ese fallo e incluso podemos hacer un pull request para que se añada en la librería original nuestra modificación. También podemos tener nuestra propia librería como un fork de la librería original.

Un pull request es una petición que el propietario de un fork de un repositorio hace al propietario del repositorio original para que este último incorpore los commits que están en el fork. Explicación de pull request: http://aprendegit.com/que-es-un-pull-request/

Para modificar la librería time y añadir una funcionalidad, lo primero es hacer un fork del código https://github.com/PaulStoffregen/Time en tu repositorio, en mi caso en https://github.com/jecrespo/Time y luego clonarlo en el ordenador para modificarlo.

Ejercicios Librerías

Modificar Librería Ethernet

Ver como averiguar la IP de quien se ha conectado y  modificar librería ethernet para implementar un método que de devuelva la IP de origen.

Librería ethernet modificada en https://github.com/jecrespo/Aprendiendo-Arduino/tree/master/Otros/Ethernet%20Modificada

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  

Funciones definidas por usuario

Una función es un bloque de código que tiene un nombre y un conjunto de instrucciones que son ejecutadas cuando se llama a la función. Son funciones setup() y loop() de las que ya se ha hablado.

Las funciones de usuario pueden ser escritas para realizar tareas repetitivas y para reducir el tamaño de un programa. Segmentar el código en funciones permite crear piezas de código que hacen una determinada tarea y volver al área del código desde la que han sido llamadas.

Las funciones se declaran asociadas a un tipo de valor. Este valor será el que devolverá la función, por ejemplo ‘int’ se utilizará cuando la función devuelva un dato numérico de tipo entero. Si la función no devuelve ningún valor entonces se colocará delante la palabra “void”, que significa “función vacía”

Sintaxis:

tipo nombreFunción (parámetros) {

  instrucciones;

}

Para llamar a una función, simplemente:

nombreFunción(parámetros);

En una función que devuelve un valor siempre debe tener la instrucción Return, este termina una función y devuelve un valor a quien ha llamado a la función: http://arduino.cc/en/Reference/Return

Ventajas del uso de funciones:

  • Ayuda a tener organizado el código.
  • Una función codifica una tarea en un lugar de nuestro sketch, así que la función solo debe ser pensada una sola vez.
  • Reduce la probabilidad de errores al modificar el código.
  • Hacen que el tamaño del sketch sea menor porque el código de la función es reutilizado.
  • Facilita la lectura del código.
  • Hace más sencillo reutilizar código en otros sketches.

Más información: http://arduino.cc/en/Reference/FunctionDeclaration

Nombres de funciones

Generalmente los nombres de las funciones deben ser en minúscula, con las palabras separadas por un guión bajo, aplicándose éstos tanto como sea necesario para mejorar la legibilidad.

“mixedCase” (primera palabra en minúscula) es aceptado únicamente en contextos en donde éste es el estilo predominante con el objetivo de mantener la compatibilidad con versiones anteriores.

En el caso de las clases, los nombres deben utilizar la convención “CapWords” (palabras que comienzan con mayúsculas).

Las funciones en Arduino pueden estar dentro del mismo fichero .ino o en otro fichero con extensión .ino dentro del directorio del sketch.

Paso por Valor y Paso por Referencia

Hasta ahora siempre hemos declarado los parámetros de nuestras funciones del mismo modo. Sin embargo, éste no es el único modo que existe para pasar parámetros.

La forma en que hemos declarado y pasado los parámetros de las funciones hasta ahora es la que normalmente se conoce como “por valor”. Esto quiere decir que cuando el control pasa a la función, los valores de los parámetros en la llamada se copian a “objetos” locales de la función, estos “objetos” son de hecho los propios parámetros.

int funcion(int n, int m) { 
  n = n + 2; 
  m = m - 5; 
  return n+m; 
}

int a = 10;
int b = 20;
Serial.println(funcion(a,b));
Serial.println(funcion(10,20));

Empezamos haciendo a = 10 y b = 20, después llamamos a la función “funcion” con las objetos a y b como parámetros. Dentro de “funcion” esos parámetros se llaman n y m, y sus valores son modificados. Sin embargo al retornar al programa que lo llama, a y b conservan sus valores originales. Lo que pasamos no son los objetos a y b, sino que copiamos sus valores a los objetos n y m. Es lo mismo que hacer funcion(10,20), cuando llamamos a la función con parámetros constantes. Si los parámetros por valor no funcionasen así, no sería posible llamar a una función con valores constantes o literales.

Las referencias sirven para definir “alias” o nombres alternativos para un mismo objeto. Para ello se usa el operador de referencia (&).

Por ejemplo:

int a;
int &r = a;
a = 10;
Serial.println(r);

En este ejemplo los identificadores a y r se refieren al mismo objeto, cualquier cambio en una de ellos se produce en el otro, ya que son, de hecho, el mismo objeto. El compilador mantiene una tabla en la que se hace corresponder una dirección de memoria para cada identificador de objeto. A cada nuevo objeto declarado se le reserva un espacio de memoria y se almacena su dirección. En el caso de las referencias, se omite ese paso, y se asigna la dirección de otro objeto que ya existía previamente. De ese modo, podemos tener varios identificadores que hacen referencia al mismo objeto, pero sin usar punteros.

Si queremos que los cambios realizados en los parámetros dentro de la función se conserven al retornar de la llamada, deberemos pasarlos por referencia. Esto se hace declarando los parámetros de la función como referencias a objetos. Por ejemplo:

int funcion(int &n, int &m) {
   n = n + 2; 
   m = m - 5; 
   return n+m;
}

int a = 10;
int b = 20;

Serial.println(funcion(a,b));
Serial.println("a = " + String(a) + " b = " + String(b));
//es ilegal pasar constantes como parámetros cuando estos son referencias
Serial.println(funcion(10,20));

En este caso, los objetos “a” y “b” tendrán valores distintos después de llamar a la función. Cualquier cambio de valor que realicemos en los parámetros dentro de la función, se hará también en los objetos referenciadas. Esto quiere decir que no podremos llamar a la función con parámetros constantes, ya que aunque es posible definir referencias a constantes, en este ejemplo, la función tiene como parámetros referencias a objetos variables. Y si bien es posible hacer un casting implícito de un objeto variable a uno constante, no es posible hacerlo en el sentido inverso. Un objeto constante no puede tratarse como objeto variable.

Una const reference es una referencia a que no permite cambiar la variable a través de esa referencia. Por ejemplo const int &r = a; en r tengo el valor de a pero no puedo cambiar el valor de a usando r.

No confundir este concepto con el modificador de variable static, que es utilizado para crear variables que solo son visibles dentro de una función, sin embargo, al contrario que las variables locales que se crean y destruyen cada vez que se llama a la función, las variables estáticas mantienen sus valores entre las llamadas a las funciones.

Más información:

Sobrecarga de Funciones

Hay operadores que tienen varios usos, como por ejemplo *, &, << o >>. Esto es lo que se conoce en C++ como sobrecarga de operadores. Con las funciones existe un mecanismo análogo, de hecho, en C++, los operadores no son sino un tipo especial de funciones, aunque eso sí, algo peculiares.

Así que en C++ podemos definir varias funciones con el mismo nombre, con la única condición de que el número y/o el tipo de los argumentos sean distintos. El compilador decide cuál de las versiones de la función usará después de analizar el número y el tipo de los parámetros. Si ninguna de las funciones se adapta a los parámetros indicados, se aplicarán las reglas implícitas de conversión de tipos.

Las ventajas son más evidentes cuando debemos hacer las mismas operaciones con objetos de diferentes tipos o con distinto número de objetos. También pueden usarse macros para esto, pero no siempre es posible usarlas, y además las macros tienen la desventaja de que se expanden siempre, y son difíciles de diseñar para funciones complejas. Sin embargo las funciones serán ejecutadas mediante llamadas, y por lo tanto sólo habrá una copia de cada una.

Ejemplo:

int mayor(int a, int b);
char mayor(char a, char b); 
float mayor(float a, float b);
int mayor(int a, int b, int c, int d);

int mayor(int a, int b) { 
   if(a > b) return a; else return b; 
}
 
char mayor(char a, char b) { 
   if(a > b) return a; else return b; 
}
 
float mayor(float a, float b) { 
   if(a > b) return a; else return b; 
}

int mayor(int a, int b, int c, int d) { 
   return mayor(mayor(a, b), mayor(c, d)); 
}

Las llamadas a funciones sobrecargadas se resuelven en la fase de compilación. Es el compilador el que decide qué versión de la función debe ser invocada, después de analizar, y en ciertos casos, tratar los argumentos pasados en la llamadas. A este proceso se le llama resolución de sobrecarga.

Tener en cuenta que el tipo de retorno de la función no se considera en la sobrecarga de funciones. Consideremos el caso en el que desea escribir una función que devuelve un número aleatorio, pero se necesita una versión que devolverá un entero, y otra versión que devolverá un doble.

int getRandomValue();
double getRandomValue();

Pero el compilador toma esto como un error. Estas dos funciones tienen los mismos parámetros (ninguno) y en consecuencia, la segunda getRandomValue () serán tratada como una redeclaración errónea de la primera. En consecuencia, tendrán que ser dado diferentes nombres a estas funciones.

Más información:

Sobrecarga de operadores:

Ámbito de las variables

Una variable puede ser declarada al inicio del programa antes de la parte de configuración setup(), a nivel local dentro de las funciones, y, a veces, dentro de un bloque, como para los bucles del tipo if.. for.., etc. En función del lugar de declaración de la variable así se determinará el ámbito de aplicación, o la capacidad de ciertas partes de un programa para hacer uso de ella.

Una variable global es aquella que puede ser vista y utilizada por cualquier función y estamento de un programa. Esta variable se declara al comienzo del programa, antes de setup().

Recordad que al declarar una variable global, está un espacio en memoria permanente en la zona de static data y el abuso de variables globales supone un uso ineficiente de la memoria.

Una variable local es aquella que se define dentro de una función o como parte de un bucle. Sólo es visible y sólo puede utilizarse dentro de la función en la que se declaró. Por lo tanto, es posible tener dos o más variables del mismo nombre en diferentes partes del mismo programa que pueden contener valores diferentes, pero no es una práctica aconsejable porque complica la lectura de código.

En el reference de Arduino hay una muy buena explicación del ámbito de las variables:http://arduino.cc/en/Reference/Scope

La variables estáticas solo se crean e inicializan la primera vez que la función es llamada. Ver ejemplo en: http://arduino.cc/en/Reference/Static

Más información:

Inline

Cuando usamos el nombre de una función, indicando valores para sus argumentos, dentro de un programa, decimos que llamamos o invocamos a esa función. Esto quiere decir que el procesador guarda la dirección actual, “salta” a la dirección donde comienza el código de la función, la ejecuta, recupera la dirección guardada previamente, y retorna al punto desde el que fue llamada.

Esto es cierto para las funciones que hemos usado hasta ahora, pero hay un tipo especial de funciones que trabajan de otro modo. En lugar de existir una única copia de la función dentro del código, si se declara una función como inline, lo que se hace es insertar el código de la función, en el lugar (y cada vez) que sea llamada. Esta indica al compilador que cada llamada a la función inline deberá ser reemplazado por el cuerpo de esta función. En la práctica la función inline es utilizado sólo cuando las funciones son pequeñas para evitar generar un ejecutable de tamaño considerable.

La palabra reservada inline tiene la ventaja de acelerar un programa si éste invoca regularmente a la función inline. Permite reducir considerablemente el código, en particular para los accesadores de una clase. Un accesador de clase es típicamente una función de una línea.

Ejemplo:

inline int mayor(int a, int b) {
  if(a > b) return a; 
  return b; 
}

Más información de inline:

Prototipos de Funciones

Primero recordar que en el lenguaje de Arduino al contrario que en estandar C, no es necesario declarar los prototipos de las funciones, puesto que de eso se encarga el de incluirlo el arduino builder, al igual que de añadir el main..

En C++ es obligatorio usar prototipos. Un prototipo es una declaración de una función. Consiste en una presentación de la función, exactamente con la misma estructura que la definición, pero sin cuerpo y terminada con un “;”.

En general, el prototipo de una función se compone de las siguientes secciones:

  • Opcionalmente, una palabra que especifique el tipo de almacenamiento, puede ser extern o static. Si no se especifica ninguna, por defecto será extern.
  • El tipo del valor de retorno, que puede ser void, si no necesitamos valor de retorno.
  • Modificadores opcionales.
  • El identificador de la función. Es costumbre, muy útil y muy recomendable, poner nombres que indiquen, lo más claramente posible, qué es lo que hace la función, y que permitan interpretar qué hace el programa con sólo leerlos.
  • Una lista de declaraciones de parámetros entre paréntesis. Los parámetros de una función son los valores de entrada (y en ocasiones también de salida).

Un prototipo sirve para indicar al compilador los tipos de retorno y los de los parámetros de una función, de modo que compruebe si son del tipo correcto cada vez que se use esta función dentro del programa, o para hacer las conversiones de tipo cuando sea necesario.

Normalmente, los prototipos de las funciones se declaran dentro del fichero del programa, o bien se incluyen desde un fichero externo, llamado fichero de cabecera, (para esto se usa la directiva #include).

Ya lo hemos dicho más arriba, pero las funciones son extern por defecto. Esto quiere decir que son accesibles desde cualquier punto del programa, aunque se encuentren en otros ficheros fuente del mismo programa. En contraposición las funciones declaradas static sólo son accesibles dentro del fichero fuente donde se definen.

Más información:

Bibliotecas/Librerías en C++

Junto con los compiladores de C y C++, se incluyen ciertos archivos llamados bibliotecas más comúnmente librerías. Las bibliotecas contienen el código objeto de muchos programas que permiten hacer cosas comunes, como leer el teclado, escribir en la pantalla, manejar números, realizar funciones matemáticas, etc.

Las bibliotecas están clasificadas por el tipo de trabajos que hacen, hay bibliotecas de entrada y salida, matemáticas, de manejo de memoria, de manejo de textos y como imaginarás existen muchísimas librerías disponibles y todas con una función específica.

La declaración de librerías, tanto en C como en C++, se debe hacer al principio de todo nuestro código, antes de la declaración de cualquier función o línea de código, debemos indicarle al compilador que librerías usar, para el saber qué términos están correctos en la escritura de nuestro código y cuáles no. La sintaxis es la siguiente: #include <nombre de la librería> o alternativamente #include “nombre de la librería”. En tu código puedes declarar todas las librerías que quieras aunque en realidad no tienen sentido declarar una librería que no vas a usar en tu programa, sin embargo no existe límite para esto.

La directiva de preprocesador #include se usa en los lenguajes C y C++ para “incluir” las declaraciones de otro fichero en la compilación. Esta directiva no tiene más misterio para proyectos pequeños. En cambio, puede ayudar aprovechar bien esta directiva en proyectos con un gran número de subdirectorios.

Ejemplo:

#include “iostream”
#include “string”
#include <math.h>
using namespace std;

Lo único adicional, es la línea que dice using namespace std; esta línea nos ayuda a declarar un espacio de nombre que evita tener que usarlo cada que accedemos a alguna función específica de una librería. Teniendo este namespace declarado podemos llamar por ejemplo el comando cout >>, que pertenece a la librería iostream, sin embargo sin este namespace sería std::cout >>, imagina tener que hacer esto cada vez que uses algún comando o función de las librerías, sería bastante tedioso.

A continuación pondré algunas de las librerías de uso más común de C++ y que forman parte de las librerías estándar de este lenguaje.

  • fstream: Flujos hacia/desde ficheros. Permite la manipulación de archivos desde el programar, tanto leer como escribir en ellos.
  • iosfwd: Contiene declaraciones adelantadas de todas las plantillas de flujos y sus typedefs estándar. Por ejemplo ostream.
  • iostream: Parte del a STL que contiene los algoritmos estándar, es quizá la más usada e importante (aunque no indispensable).
  • math: Contiene los prototipos de las funciones y otras definiciones para el uso y manipulación de funciones matemáticas.
  • memory: Utilidades relativas a la gestión de memoria, incluyendo asignadores y punteros inteligentes (auto_ptr). “auto_ptr” es una clase que conforma la librería memory y permite un fácil manejo de punteros y su destrucción automáticamente.
  • ostream: Algoritmos estándar para los flujos de salida.
  • Librería stdio: Contiene los prototipos de las funciones, macros, y tipos para manipular datos de entrada y salida.
  • Librería stdlib: Contiene los prototipos de las funciones, macros, y tipos para utilidades de uso general.
  • string: Parte de la STL relativa a contenedores tipo string; una generalización de las cadenas alfanuméricas para albergar cadenas de objetos.
  • vector: Parte de la STL relativa a los contenedores tipo vector; una generalización de las matrices unidimensionales C/C++
  • list: Permite implementar listas doblemente enlazadas (listas enlazadas dobles) fácilmente.
  • iterator: Proporciona un conjunto de clases para iterar elementos.
  • regex: Proporciona fácil acceso al uso de expresiones regulares para la comparación de patrones.
  • thread: Útil para trabajar programación multihilos y crear múltiples hilos en nuestra aplicación.

Más información:

Ejercicios Funciones

Ver ejemplo sencillo de uso de funciones: https://github.com/jecrespo/Aprendiendo-Arduino/tree/master/Ejercicio02-Funciones

Comparar las funciones con librerías: https://github.com/jecrespo/Aprendiendo-Arduino/tree/master/Ejercicio03-Librerias

Ejercicio: Menú interactivo con Arduino. Con todo lo visto de Strings, operadores, estructuras de control y funciones, hacer un ejemplo de un menú interactivo donde se dan varias opciones y pulsando cada una de ellas se ejecuta una acción concreta. Si el valor pulsado no es ninguna de las opciones avisar y volver a mostrar el menú hasta que se pulse una opción correcta.

Solución: https://github.com/jecrespo/Aprendiendo-Arduino/tree/master/Ejercicio46-Estructuras_de_Control

Librerías vs Funciones en Arduino

Como se ha visto anteriormente, las librerías son trozos de código hechas 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 luego de entender. Más adelante veremos cómo hacer una librería.

Las librerías en Arduino 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).

Más información: https://aprendiendoarduino.wordpress.com/2016/06/27/librerias-3/

Una librería a diferencia de las funciones debe estar al menos en un fichero diferente con extensión .h y opcionalmente en otro .cpp y además debe ser llamada con #include desde el sketch de arduino y estar en una ruta accesible desde el IDE de Arduino, ya sea el mismo directorio del sketch o en algunas de las rutas configuradas para librerías.

La ventaja de usar librerías frente a las funciones es que no es necesario incluir el código cada vez que se va a reutilizar sino que con tener la librería instalada en el IDE y llamarla mediante #include ya la puedo usar en mi código.

Al llamar a una librería desde un sketch, la librería completa es cargada a la placa de Arduino incrementando el tamaño del espacio usado en el microcontrolador, tanto en la memoria flash como en la RAM.

NOTA: Como instalar una librería de github: http://scidle.com/install-github-libraries-on-arduino-ide/ habla de quitar caracteres no ASCII, pero comprueba también que no funcione porque haya subdirectorios.

Las librerías que usamos para los sketches tienen una versión, que se suelen actualizar con frecuencia. También tenemos un control de versiones en el nuevo IDE a partir de 1.6.4 que nos facilita la gestión de la versión de las librerías usadas. Este aspecto es importante porque un sketch que funciona con una versión de una librería es posible que al compilarlo con otra versión en otro IDE no funcione. Por ello es importante documentar con que versión de librería está hecho o distribuir el sketch con la librería con la que se ha creado. Generalmente las librerías tienen compatibilidad hacia atrás, pero puede que no ocurra o que el comportamiento de la librería sea diferente.

Al cambiar el IDE también nos podemos encontrar que nuestro sketch no es compatible con la versión de la librería que estemos usando, que es diferente con la que se diseñó originalmente el sketch.

Listado de librerías: http://playground.arduino.cc/Main/LibraryList

Ejercicio Librerías vs Funciones

Ya hemos visto lo que son las librerías y las funciones definidas por usuario, el uso de unas u otras dependerá de varios factores como la posibilidad de reutilización del código o la experiencia del programador con el uso de librerías.

Ejemplos simples de librerías:

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.

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.

Práctica: Instalación de Librerías

Instalar varias librerías como las del siguiente capítulo https://aprendiendoarduino.wordpress.com/2016/06/28/instalacion-librerias/

Compara el funcionamiento y limitaciones de las librerías MsTimer2.h y Timer.h con el ejemplo https://github.com/jecrespo/Aprendiendo-Arduino/tree/master/Otros/compara_timers