25- Arduino, Usando las Bibliotecas

Las bibliotecas son una herramienta muy poderosa cuando se trabaja con Arduino, especialmente para principiantes. Una biblioteca es un archivo (un conjunto de archivos) que contiene exactamente el mismo código C ++ en el que escribimos un boceto (a veces también hay inserciones de ensamblador). Podemos conectar la biblioteca a nuestro código y utilizar las capacidades que proporciona, y hay muchas opciones: “herramientas” listas para usar y para trabajar con sensores y módulos externos, para trabajar con los periféricos internos del microcontrolador (temporizadores, ADC, memoria), bibliotecas de diversas herramientas, matemáticas y mucho más. Mi lista personal de bibliotecas interesantes, compilada a lo largo de los años de trabajo con la plataforma, se puede ver aquí.

La belleza de trabajar con una biblioteca es que no necesitamos saber cómo funciona el código que contiene, utilizamos herramientas listas para usar proporcionadas por el desarrollador de la biblioteca. Muy a menudo hay descripciones / documentación y ejemplos de uso de bibliotecas.


Cómo instalar las bibliotecas.

Asistente de bibliotecas

Como dije antes, una biblioteca es una colección de archivos de texto con código. La biblioteca se puede instalar de dos formas: desde el repositorio oficial o manualmente. Arduino tiene varias bibliotecas que se pueden obtener directamente del programa Arduino IDE utilizando el administrador de bibliotecas incorporado, que le permite instalar, eliminar y actualizar bibliotecas. Esto es estupendo, pero esta lista no incluye todas las bibliotecas existentes y el administrador no proporciona una descripción normal. Para instalar una biblioteca del repositorio oficial de Arduino, vaya a Programa / Incluir librería … Se abrirá el administrador de la biblioteca, en el que puede encontrar e instalar una biblioteca de la lista con un solo clic.

Gestor de bibliotecas del arduino Ide
Gestor de bibliotecas del arduino Ide

Instalación manual

La instalación manual de la biblioteca significa mover la carpeta con la biblioteca a la carpeta en la que Arduino IDE buscará esta biblioteca. Hay dos carpetas de este tipo: una se encuentra en la carpeta del programa:

  • Windows de 64 bits – C: \ Archivos de programa (x86) \ Arduino \ libraries \
  • Windows 32bit –  C: \ Archivos de programa \ Arduino \ libraries \

El segundo se encuentra a lo largo de la ruta especificada en la configuración. Por defecto, este es Documentos / Arduino . Recomiendo instalar las bibliotecas en la carpeta del programa. Mueva la biblioteca que usted necesita a la carpeta de bibliotecas, en la carpeta con el nombre de la biblioteca están los archivos de la biblioteca (archivos con las extensiones .H ,. Cpp , archivos de palabras clave , la carpeta de los ejemplos …).

Ruta de las librerías de arduino
Ruta de las librerías de arduino

A la carpeta con el boceto

Puede colocar la biblioteca en la carpeta del proyecto, por ejemplo, si realiza cambios en el código de la biblioteca que son necesarios solo para este proyecto. En este caso, los archivos de la biblioteca deben estar junto al archivo de boceto .ino, y en el boceto, la biblioteca debe estar conectada mediante comillas dobles, para que el compilador comience a buscar la biblioteca desde la carpeta con el boceto:

Al mismo tiempo, las bibliotecas que contienen varios archivos en diferentes carpetas, se niegan a funcionar. Quizás este sea un problema del propio IDE de Arduino:


¿Dónde conseguir bibliotecas?

Es muy común encontrar un proyecto publicado por alguien que usa bibliotecas. El autor puede adjuntar directamente los archivos de la biblioteca que utilizó, puede dar un enlace a la biblioteca o simplemente indicar su nombre. También se encuentran bibliotecas interesantes en foros donde las personas simplemente escriben para sí mismos y comparten con otros. En el sitio web oficial de la biblioteca o en su página en GitHub, puede encontrar una descripción detallada de la biblioteca (documentación, wiki), consejos de uso, diagramas y otra información útil.

La mayoría de las bibliotecas se publican en el sitio de GitHub , una persona no preparada puede tener problemas para descargar archivos de este recurso. Digamos que se topó con una biblioteca interesante y quería descargarla. Por ejemplo, IRLremote es una biblioteca para trabajar con receptores de infrarrojos. No importa en qué carpeta del repositorio se encuentre, siempre puede hacer clic en el nombre de la biblioteca ( nombre del autor / nombre del repositorio ) e ir a la página principal del repositorio.

Bibliotecas arduino en github
Bibliotecas arduino en github

Desde la página principal, puede descargar todo el repositorio como un archivo haciendo clic en Clonar o descargar, también Descargar ZIP. Este método es universal para todas las bibliotecas.

Descarga de bibliotecas arduino de github
Descarga de bibliotecas arduino de github

Esto descargará el código fuente de la biblioteca, que puede contener archivos que no están relacionados con la biblioteca en sí. La mayoría de los autores publican versiones de lanzamiento (release) de bibliotecas, que se encuentran en la pestaña Lanzamientos.

Desde la pestaña Versiones, puede descargar el archivo con la biblioteca de la versión requerida.

GitHub también te permite abrir para leer o descargar un solo archivo del repositorio. Para hacer esto, debe abrir el archivo y hacer clic en el botón Raw.

Inspeccionar archivos en github
Inspeccionar archivos en github

Resolución de conflictos.

A veces hay un conflicto de bibliotecas, lo que significa que el IDE encuentra varias bibliotecas idénticas en la computadora. Esto se informa en el registro de compilación con una advertencia: » varias bibliotecas encontradas … «. Si instaló algunas bibliotecas a través del administrador ( Programas/ Incluir libreria … ), chocará con las bibliotecas instaladas manualmente en la carpeta del programa. ¿Dónde están las bibliotecas en general?

  • Bibliotecas compartidas estándar: en la carpeta Archivos de programa / libraries
    • Windows de 64 bits – C: \ Archivos de programa (x86) \ Arduino \ libraries \ 
    • Windows 32 bit –  C: \ Archivos de programa \ Arduino \ libraries \
  • Instalado a través del administrador – Documentos \ Arduino \ libraries
  • Bibliotecas de núcleos específicos:
    • Arduino Standard Core – C: \ Archivos de programa (x86) \ Arduino \ hardware \ arduino \ avr \ libraries
    • Otros kernels – C: \ Users \ username \ AppData \ Local \ Arduino15 \ packages \ kernel \ hardware \ platform \ version \ libraries

Los núcleos también pueden entrar en conflicto, por lo que una instalación limpia del IDE de Arduino con la eliminación de los restos de la versión anterior puede ser la solución a todos los problemas. Eliminamos el programa como tal y borramos manualmente las carpetas:

  • Carpeta de programa
    • Windows de 64 bits – C: \ Archivos de programa (x86) \ Arduino \ libraries \ 
    • Windows 32bit –  C: \ Archivos de programa \ Arduino \ libraries \
  • Documentos \ Arduino \
  • C: \ Usuarios \ nombre de usuario \ AppData \ Local \ Arduino15 \

«Dentro» de la biblioteca.

La biblioteca, dependiendo de la cantidad de código y el estado de ánimo del programador, se puede diseñar de forma muy compacta y detallada, con un montón de archivos y carpetas adicionales. Consideremos la composición clásica de la biblioteca. Para mayor comodidad, recomiendo habilitar la visibilidad de las extensiones de archivo . Todos los siguientes archivos de muestra son archivos de texto ordinarios, puede abrirlos con un bloc de notas normal. También recomiendo usar el «bloc de notas de programador» – Notepad ++ ( enlace al sitio oficial ), que resalta la sintaxis y, en general, es una herramienta muy adecuada para el desarrollador.

<nombre de biblioteca>.h: archivo de encabezado, el archivo de biblioteca más importante. Es tan importante que la biblioteca solo puede estar formada por él. Por lo general, se encuentra en la raíz de la biblioteca o en la carpeta src, source (fuente). Este archivo generalmente enumera todas las clases / métodos / funciones / tipos de datos, contiene información sobre la biblioteca, a menudo hay una descripción extendida para cada método o función. Muy a menudo, el archivo de encabezado principal es la mini documentación de la biblioteca. Una biblioteca puede tener una estructura de varios archivos con una gran cantidad de archivos de encabezado, pero el archivo de encabezado principal siempre es uno, tiene el mismo nombre que la carpeta con la biblioteca.

Un archivo con la extensión .cpp es un archivo de implementación que contiene el código ejecutable principal del programa. Por lo general, va en parejo a su archivo .h de encabezado , es decir, <nombre de la biblioteca> .cpp .

keywords.txt: un archivo que enumera los nombres de funciones, métodos y otros nombres de trabajo de la biblioteca resaltados en el IDE de Arduino (resaltados en un color diferente) en el código.

Archivo library.properties: archivo que contiene información sobre la biblioteca para los desarrolladores y el administrador de la biblioteca (nombre, versión, autor, categoría, etc.).

Carpeta Src: esta carpeta puede contener los archivos de la biblioteca principal ( .h , .cpp , .c ).

La carpeta de ejemplos es una carpeta con ejemplos de uso de la biblioteca.

Además de los archivos y carpetas enumerados, la carpeta con la biblioteca puede contener otros archivos y carpetas de servicio, a veces incluso puede encontrar documentación completa en forma de archivos de texto o páginas html.


¿Cómo trabajar con la biblioteca?

Digamos que compró algún tipo de módulo o sensor, buscó información en Google sobre él, encontró un artículo con un ejemplo. Los ejemplos suelen ser sencillos, muestran cómo se conecta y funciona. Descargamos la biblioteca del artículo, lo probamos, todo funciona. ¿Que sigue? A continuación, debe abrir la carpeta con la biblioteca y ver los ejemplos oficiales, averiguar cómo funcionan y qué pueden hacer. Los ejemplos se encuentran en la carpeta de ejemplos en la carpeta de la biblioteca.

Los ejemplos generalmente no revelan todas las capacidades de la biblioteca, por lo que abrimos y leemos el archivo de encabezado, que es library_name.h. Contiene literalmente una lista de herramientas de biblioteca, a menudo con descripciones para cada una. Con esta información, puede extraer del módulo todas las funciones que el desarrollador de la biblioteca le ha prescrito. Echemos un vistazo a la biblioteca de servo.h, creo que la mayoría ha trabajado con ella.

Veamos los ejemplos que están en la carpeta de la biblioteca:

knob.ino

/ *
 Controlar la posición de un servo usando un potenciómetro (resistencia variable)
 por Michal Rinott <http://people.interaction-ivrea.it/m.rinott>
 modificado el 8 de noviembre de 2013
 por Scott Fitzgerald
 http://www.arduino.cc/en/Tutorial/Knob
* /
#include <Servo.h>
Servo myservo; // crea un objeto servo para controlar un servo
int potpin = 0; // pin analógico utilizado para conectar el potenciómetro
int val;   // variable para leer el valor del pin analógico
void setup() {
  myservo.attach(9); // conecta el servo en el pin 9 al objeto servo
}
void loop() {
  val = analogRead ( potpin ) ;           // lee el valor del potenciómetro (valor entre 0 y 1023)
  val = map ( val, 0, 1023, 0, 180 ) ;    // escalarlo para usarlo con el servo (valor entre 0 y 180)
  myservo.write(val);                 // establece la posición del servo de acuerdo con el valor escalado
  delay(15);                        // espera a que llegue el servo
}

sweep.ino

/ * sweep
 por BARRAGAN <http://barraganstudio.com>
 Este código de ejemplo es de dominio público.
 modificado el 8 de noviembre de 2013
 por Scott Fitzgerald
 http://www.arduino.cc/en/Tutorial/Sweep
* /
#include <Servo.h>
Servo myservo; // crea un objeto servo para controlar un servo
// Se pueden crear doce objetos servo en la mayoría de las placas
int pos = 0;   // variable para almacenar la posición del servo
void setup() {
  myservo.attach(9); // conecta el servo en el pin 9 al objeto servo
}
void loop() {
  for ( pos = 0; pos < = 180; pos + = 1 ) { // va de 0 grados a 180 grados  
    // en pasos de 1 grado
    myservo.write(pos);           // decirle al servo que vaya a la posición en la variable 'pos'
    delay ( 15 ) ;                      // espera 15ms a que el servo alcance la posición
  }
  for ( pos = 180; pos > = 0; pos - = 1 ) { // va de 180 grados a 0 grados  
     myservo.write(pos) ;             // decirle al servo que vaya a la posición en la variable 'pos'
    delay (15) ;                      // espera 15ms a que el servo alcance la posición
  }
}

De estos ejemplos, aprendimos que existe una clase Servo y necesitamos crear un objeto de esta clase. En el bloque de configuración, podemos especificar a qué pin está conectado el servo (el método attach() ), y podemos rotar el servo al ángulo deseado (en grados) usando el método write (). Esto es básicamente todo lo que aprendimos del ejemplo oficial. Abramos ahora el archivo de encabezado Servo.h, que se encuentra en la carpeta src (se adjunta todo el código después de la descripción).

servo.h

#define Servo_VERSION 2 // versión de software de esta biblioteca
#define MIN_PULSE_WIDTH 544 // el pulso más corto enviado a un servo  
#define MAX_PULSE_WIDTH 2400 // el pulso más largo enviado a un servo 
#define DEFAULT_PULSE_WIDTH 1500 // ancho de pulso predeterminado cuando el servo está conectado
#define REFRESH_INTERVAL 20000 // tiempo mínimo para actualizar los servos en microsegundos 
#define SERVOS_PER_TIMER 12 // el número máximo de servos controlados por un temporizador 
#define MAX_SERVOS (_Nbr_16timers * SERVOS_PER_TIMER)
#define INVALID_SERVO 255 ​​// bandera que indica un índice de servo no válido
#if! !defined(ARDUINO_ARCH_STM32F4)
typedef struct {   
  uint8_t nbr: 6;            // un número de pin de 0 a 63
  uint8_t isActive: 1;            // verdadero si este canal está habilitado, pin no pulsado si es falso
} ServoPin_t   ;  
typedef struct {
  ServoPin_t Pin;
  volatile unsigned int ticks;
} servo_t;
class Servo
{
public:
  Servo () ;
  uint8_t attach ( pin int ) ;          // adjunta el pin dado al siguiente canal libre, establece pinMode, devuelve el número de canal o 0 si falla 
  uint8_t attach ( int pin, int min, int max ) ; // como arriba pero también establece valores mínimos y máximos para escrituras. 
  detach vacío () ; 
  void write(int value);            // si el valor es <200, se trata como un ángulo, de lo contrario como ancho de pulso en microsegundos 
  void writeMicroseconds(int value) ; // Escribe el ancho del pulso en microsegundos 
  int read () ;                       // devuelve el ancho de pulso actual como un ángulo entre 0 y 180 grados 
  int readMicroseconds () ;           // devuelve el ancho de pulso actual en microsegundos para este servo (fue read_us () en la primera versión) 
  bool attached();                  // devuelve verdadero si este servo está adjunto, de lo contrario falso 
private :
  uint8_t servoIndex;              // indexa los datos del canal para este servo
  int8_t min;                      // mínimo es este valor multiplicado por 4 añadido a MIN_PULSE_WIDTH    
  int8_t max;                      // máximo es este valor multiplicado por 4 sumado a MAX_PULSE_WIDTH   
} ;

¿Qué podemos aprender de este código? ¡Muchas cosas interesantes!

  • Impulso mínimo * – 544 μs
  • Impulso máximo * – 2400 μs
  • Impulso estándar después attach() – 1500 μs – ¡esto significa que el servo girará al ángulo apropiado después de conectarse!
  • El número máximo de servos se puede definir se muestra con la definición MAX_SERVOS al puerto (Serial.print(MAX_SERVOS)) – para Arduino NANO será 12 servos
  • En la clase Servo, podemos ver métodos que no fueron cubiertos en los ejemplos:
    • Versión attach() con la capacidad de especificar min. y máx. longitud del pulso * manualmente!
    • dettach() – desconectar el servo del control
    • writeMicroseconds () – aplicar una señal de control en μs, no en grados
    • read() – leer la posición actual del servo (último enviado vía write())
    • Y algunos otros 

* Longitud de pulso: el servo está controlado por una señal PWM con una cierta longitud de pulso, esta longitud para el ángulo máximo y mínimo de rotación del servo difiere en los diferentes fabricantes (mínimo – 450-600, máximo – 2000-2400), por lo que ¡la biblioteca de servos es una herramienta muy versátil!

También hay una descripción muy detallada de la biblioteca y algunas sutilezas antes del código. Lo que quiero decir con esto: muy a menudo es el archivo de encabezado el que contiene la mayor parte de la información útil sobre las capacidades de la biblioteca, y lo más probable es que no encuentre esta información en los “artículos” sobre módulos y sensores. Siempre estudie el archivo de encabezado si necesita trabajar seriamente con un módulo o con la biblioteca en general.


Deja un comentario