En este tema, vamos a explicar cómo crear una librería para Arduino. Se comienza con un programa que realiza,
mediante encendido y apagado de un led, el código Morse y se explica cómo convertir este en una función de
librería. Esto permite a otras personas utilizar fácilmente el código que has escrito cargándolo de una forma
sencilla.
Se comienza con el programa de un sencillo código Morse: La palabra a generar es SOS (... --- ...).
// Genera SOS en código Morse luminoso
int pin = 13;
void setup()
{
pinMode(pin, OUTPUT);
}
void loop() //Programa principal que gerera “. . . “- - -“ y “. . . “
{
punto(); punto(); punto(); //Genera la S (. . . )
raya(); raya(); raya(); // Genera la O (- - -)
punto(); punto(); punto(); // Genera la S (. . . )
delay(3000); // Espera un tiempo
}
void punto() //Procedimiento para generar un punto
{
digitalWrite(pin, HIGH);
delay(250);
digitalWrite(pin, LOW);
delay(250);
}
void raya() //Procedimiento para generar una raya
{
digitalWrite(pin, HIGH);
delay(1000);
digitalWrite(pin, LOW);
delay(250);
}
Si se ejecuta este programa, se ejecuta el código SOS (llamada de solicitud de auxilio) en la salida PIN13.
El programa tiene distintas partes que tendremos que poner en nuestra librería. En primer lugar, por
supuesto, tenemos las funciones punto() y raya() que se encargan de que el
LED parpadee de manera corta o larga respectivamente. En segundo lugar, tenemos la instruccién ledPin que
utilizamos para determinar el pin a utilizar. Por último, está la llamada a la función
pinMode() que inicializa el pin como salida.
Vamos a empezar a convertir el programa en una librería.
Necesitamos por lo menos dos archivos en una librería: un archivo de cabecera (w / la extensión .H) y el
archivo fuente (w / extensión .CPP). El fichero de cabecera tiene definiciones para la librería:
básicamente una lista de todo lo que contiene, mientras que el archivo fuente tiene el código real. Vamos a
llamar a nuestra biblioteca "Morse", por lo que nuestro fichero de cabecera será Morse.h. Echemos un vistazo
a lo que sucede en ella. Puede parecer un poco extraño al principio, pero lo entenderemos una vez que veamos
el archivo de origen que va con ella.
El núcleo del archivo de cabecera consiste en una línea para cada función en la biblioteca, envuelto en una
clase junto con las variables que necesitaremos:
class Morse
{
public:
Morse(int pin);
void punto();
void raya();
private:
int _pin;
};
Una clase es simplemente una colección de funciones y variables que se mantienen unidos todos en un solo
lugar. Estas funciones y variables pueden ser públicos, lo que significa que pueden ser utilizadas por
quienes utilizan la librería, o privadas, lo que significa que sólo se puede acceder desde dentro de la
propia clase. Cada clase tiene una función especial conocida como un constructor, que se
utiliza para crear una instancia de la clase. El constructor tiene el mismo nombre que la clase, y no
devuelve nada.
Usted necesita dos cosas más en el fichero de cabecera. Uno de ellos es un # include
declaración que le da acceso a los tipos estándar y las constantes del lenguaje de Arduino (esto se añade
automáticamente en todos los programas que hacemos con Arduino, pero no a las librerías). Por lo que
debemos incluirlas (poniéndolas por encima de la definición de clase dada anteriormente):
# include "WConstants.h"
Por último, se colocara delante del código la cabecera siguiente:
# ifndef Morse_h
#define Morse_h
// El estamento #include y el resto del código va aquí...
#endif
Básicamente, esto evita problemas si alguien accidentalmente pone # include en la librería dos veces.
Por último, por lo general, se pone un comentario en la parte superior de la librería con su nombre, una
breve descripción de lo que hace, quien la escribió, la fecha y la licencia.
Echemos un vistazo a la completa disposición del fichero de cabecera .h.
/* Morse.h - Biblioteca para flashear el código Morse.
Creado por Fun Tech Academy, 9 de Abril de 2021.
Publicado en el dominio público. */
#ifndef Morse_h
#define Morse_h
#include "WConstants.h"
class Morse
{
public:
Morse(int pin);
void punto();
void raya();
private:
int _pin;
};
#endif
Ahora vamos a escribir las diversas partes del archivo fuente de la librería, Morse.cpp.
Primero se ponen un par de declaraciones mediante “# include”. Estas incluyen resto del código de acceso a
las funciones estándar de Arduino, ya que en las definiciones figuran en el archivo de cabecera:
#include "WProgram.h"
#include "Morse.h"
Luego viene el constructor. Ahora se indicará lo que debería suceder cuando alguien crea una
instancia a la clase. En este caso, el usuario especifica el pin que les gustaría utilizar. Configuramos el
pin como salida guardándolo en una variable privada para su uso en las otras funciones:
Morse::Morse(int pin)
{
pinMode(pin, OUTPUT);
_pin = pin;
}
Hay un par de cosas extrañas en este código. El primero es el Morse:: antes del nombre de la
función. Esto indica que la función es parte de la clase Morse. Veremos esto de nuevo en las
otras funciones en la clase.
La segunda cosa inusual es el guión bajo en el nombre de nuestra variable privada, _pin.
Esta variable puede tener cualquier nombre que desee, siempre y cuando coincida con la definición que figura
en el fichero de cabecera. La adición de un guión bajo al comienzo del nombre es una convención para dejar
claro que las variables son privadas, y también a distinguir el nombre de la del argumento a la función
(pin en este caso).
Después viene el código del programa que queremos convertir en una función (¡por fin!). Parece casi igual,
excepto por Morse:: delante de los nombres de las funciones, y _pin en
lugar de pin:
void Morse::punto()
{
digitalWrite(_pin, HIGH);
delay(250);
digitalWrite(_pin, LOW);
delay(250);
}
void Morse::raya()
{
digitalWrite(_pin, HIGH);
delay(1000);
digitalWrite(_pin, LOW);
delay(250);
}
Por último, es típico incluir el comentario de cabecera en la parte superior de la fuente así como el
archivo. Vamos a ver el fichero completo.
/* Morse.h - Biblioteca para flashear el código Morse.
Creado por Fun Tech Academy, 9 de Abril de 2021.
Publicado en el dominio público. */
#include "WProgram.h"
#include "Morse.h"
Morse::Morse(int pin)
{
pinMode(pin, OUTPUT);
_pin = pin;
}
void Morse::punto()
{
digitalWrite(_pin, HIGH);
delay(250);
digitalWrite(_pin, LOW);
delay(250);
}
void Morse::raya()
{
digitalWrite(_pin, HIGH);
delay(1000);
digitalWrite(_pin, LOW);
delay(250);
}
Y eso es todo lo que necesita (hay algunas otras cosas opcionales, pero vamos a hablar de eso más adelante).
Ahora vamos a ver cómo se utiliza la librería.
En primer lugar, debemos crear una carpeta llamada Morse dentro del subdirectorio
hardware/libraries de la aplicación Arduino. Copiar o mover los archivos
Morse.h y Morse.cpp a esa carpeta. Ahora lanzar la aplicación Arduino.
Cuando se inicia, compilará la recién creada librería, generando un fichero objeto (Morse.o)
y mostrando cualquier tipo de advertencias o errores. Si abrimos el menú
Sketch> Import Library, deberíamos ver el interior el fichero objeto Morse. Como trabajamos
con nuestra librería, tendremos que borrar el archivo Morse.o y relanzar Arduino (o elegir una nueva tarjeta
en el menú Tools>Boards) para recompilar su biblioteca.
Si la biblioteca no seconstruye, asegúrate de que están realmente los archivos CPP y. H (con y sin suplemento
alguno .Pde o la extensión .Txt, por ejemplo).
Veamos como podemos escribir nuestro nuevo programa SOS haciendo uso de la nueva librería.
}
#include
Morse morse(13);
void setup()
{
}
void loop()
{
morse.punto(); morse.punto(); morse.punto();
morse.raya(); morse.raya(); morse.raya();
morse.punto(); morse.punto(); morse.punto();
delay(3000);
}
Hay algunas diferencias con respecto al antiguo programa (además del hecho de que algunos de los códigos se
han incorporado a la librería).
En primer lugar, hemos añadido un estamento “# include” en la parte superior del programa.
Esto hace que la librería Morse quede a disposición del programa y la incluye en el código. Esto significa
que ya no necesitan una librería en el programa, debemos borrar el # include para ahorrar espacio.
En segundo lugar, nosotros ahora podemos crear una instancia de la clase Morse llamado
morse:
Morse morse(13);
Cuando esta línea se ejecuta (que en realidad sucede antes incluso de setup()), el
constructor de la clase Morse será invocado y le pasara el argumento que se ha dado aquí (en este caso, sólo
13).
Tendremos en cuenta que nuestra parte setup() del programa está vacía, porque la llamada a
pinMode() se lleva a cabo en el interior de la librería (cuando la instancia se construye).
Por último, para llamar a las funciones punto() y raya(), es necesario
colocar el prefijo morse. delante de la instancia que queremos usar. Podríamos tener varias
instancias de la clase Morse, cada uno en su propio pin almacenados en la variable privada _pin de esa
instancia. Al llamar una función en un caso particular, especificaremos qué variables del ejemplo debe
utilizarse durante esa llamada a una función. Es decir, si hemos escrito:
Morse morse(13); Morse morse2(12);
Entonces dentro de una llamada a morse2.punto(), _pin sería 12.
Si hemos escrito el nuevo programa, probablemente te habrás dado cuenta de que ninguna de nuestras funciones
de la librería fue reconocida por el entorno de Arduino destacando su color. Por desgracia, el software de
Arduino no puede averiguar automáticamente lo que se ha definido en su librería (a pesar de que sería una
característica interesante), lo que tiene que darle un poco de ayuda.
Para hacer esto, cree un archivo llamado keywords.txt Morse en el directorio. Debe tener un
aspecto como este:
Morse KEYWORD1
raya KEYWORD2
punto KEYWORD2
Cada línea tiene el nombre de la palabra clave, seguida de un código (sin espacios), seguido por el tipo de
palabra clave. Las clases deben ser KEYWORD1 y son de color naranja; funciones deben ser KEYWORD2 y serán de
color marrón. Tendrás que reiniciar el entorno Arduino para conseguir reconocer las nuevas palabras clave.
Es interesante que quienes utilicen la libreia Morse tengan algun ejemplo guardado y que aparezca en el IDE
Arduino cuando seleccionamos dentro de la carpeta ejemplos (Sketch). Para hacer esto, se crea una carpeta de
ejemplos dentro de la carpeta que contiene la librería Morse. A continuación, movemos o
copiamos el directorio que contiene el programa (lo llamaremos SOS) que hemos escrito anteriormente en el
directorio de ejemplos. (Puedes encontrar el ejemplo mediante el menú
Sketch> Sketch Show Folder.) Si reiniciamos Arduino, al reiniciar veremos una
Library_Morse dentro del menú File > Sketchbook > Examples que contiene su
ejemplo. Es posible que desee añadir algunos comentarios que expliquen mejor cómo utilizar la biblioteca.