A menudo tenemos fragmentos de código con funciones que podemos reutilizar en muchos programas. Algo muy habitual en programación. Creamos una función que resuelve una necesidad concreta y queremos tenerla disponible para reutilizarla en cualquier otro programa en el que debamos resolver la misma necesidad.
Lo habitual —pero no lo más práctico— es copiar el código de esa función especial dentro de cada nuevo programa. Pero conviene tenerla en un formato reutilizable con facilidad, sobre todo si la función es muy extensa.
Para lograrlo, guardamos esa función (y todas las variables y constantes que incluya) en un archivo .ino separado, pero no debemos cargarlo individualmente en una placa Arduino, sino que luego lo incluiremos en cada programa que necesitemos, de al modo que siempre lo tendremos disponible.
( Nota: no le llamamos “sketch” sino “programa” para Arduino. )
¿Cómo incluimos un trozo de programa en otro?
Vamos a crear un código reutilizable, y lo guardaremos en una ubicación conocida del disco, un “reservorio” de funciones útiles que llevan un nombre que nos recuerde qué es y lo que hace.
Quedará con la extensión .INO, pero no es un programa para cargar al Arduino y ejecutarlo. Queda con esa extensión porque todos los programas editados en la IDE de Arduino se graban siempre con la extensión .ino.
El código es uno que hayamos creado como función o grupo de funciones dentro de un programa mayor.
Tomaremos como ejemplo una cantidad de funciones creadas para los distintos movimientos de los motores en un programa para un robot navegador.
El circuito que este programa mueve, para mejor comprensión de los ejemplos, es este:
Veamos el programa original con las funciones incluidas dentro de él:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 |
/* Control de motores CC usando el modulo L298N. El programa activa los motores en un sentido por 4 segundos, los detiene 500 ms, activa los motores en sentido inverso por 4 segundos y por ultimo se detiene por 5 segundos. Luego repite la accion indefinidamente. */ int IN1 = 9; int IN2 = 8; int IN3 = 5; int IN4 = 4; void setup() { pinMode (IN2, OUTPUT); // Input2 conectada al pin 2 pinMode (IN1, OUTPUT); // Input1 conectada al pin 3 pinMode (IN4, OUTPUT); // Input4 conectada al pin 4 pinMode (IN3, OUTPUT); // Input3 conectada al pin 5 } void loop() { // Motor gira adelante adelanteDerecho(); adelanteIzquierdo(); retardo(4000); // Motor no gira pararDerecho(); pararIzquierdo(); retardo(500); // Motor gira atras atrasDerecho(); atrasIzquierdo(); retardo(4000); // Motor no gira pararDerecho(); pararIzquierdo(); retardo(5000); } /* FUNCIONES DE MANEJO DE MOTOR */ void adelanteDerecho() { digitalWrite (IN4, LOW); digitalWrite (IN3, HIGH); } void adelanteIzquierdo() { digitalWrite (IN2, LOW); digitalWrite (IN1, HIGH); } void atrasDerecho() { digitalWrite (IN4, HIGH); digitalWrite (IN3, LOW); } void atrasIzquierdo() { digitalWrite (IN2, HIGH); digitalWrite (IN1, LOW); } void pararDerecho() { digitalWrite (IN4, LOW); digitalWrite (IN3, LOW); } void pararIzquierdo() { digitalWrite (IN2, LOW); digitalWrite (IN1, LOW); } void retardo(int valor) { delay(valor); } |
Ahora vamos a escribir un programa diferente, con otra serie de movimientos. Suponemos que estamos editando en el IDE de Arduino, como sigue:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 |
int IN1 = 9; int IN2 = 8; int IN3 = 5; int IN4 = 4; void setup() { pinMode (IN2, OUTPUT); // Input2 conectada al pin 2 pinMode (IN1, OUTPUT); // Input1 conectada al pin 3 pinMode (IN4, OUTPUT); // Input4 conectada al pin 4 pinMode (IN3, OUTPUT); // Input3 conectada al pin 5 } void loop() { adelanteDerecho(); // Motores giran adelante adelanteIzquierdo(); retardo(1000); atrasDerecho(); // Motores giran atras atrasIzquierdo(); retardo(1000); } |
Pero así no funcionaría, ya que tiene llamados a funciones (como adelanteDerecho, atrasIzquierdo, etc.) que están en otro lugar.
De modo que abrimos el programa que las tiene, copiamos las funciones que necesitamos…
… y las pegamos en una ventana vacía del IDE. Luego las guardamos con Guardar como… en la carpeta que deseemos. A esta carpeta podemos llamarla, por ejemplo: /FuncionesUtiles/
El archivo de funciones que creamos y guardamos es este: FuncionesMotor.ino, y es así:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 |
/* FUNCIONES DE MANEJO DE MOTOR */ void adelanteDerecho() { digitalWrite (IN4, LOW); digitalWrite (IN3, HIGH); } void adelanteIzquierdo() { digitalWrite (IN2, LOW); digitalWrite (IN1, HIGH); } void atrasDerecho() { digitalWrite (IN4, HIGH); digitalWrite (IN3, LOW); } void atrasIzquierdo() { digitalWrite (IN2, HIGH); digitalWrite (IN1, LOW); } void pararDerecho() { digitalWrite (IN4, LOW); digitalWrite (IN3, LOW); } void pararIzquierdo() { digitalWrite (IN2, LOW); digitalWrite (IN1, LOW); } void retardo(int valor) { delay(valor); } |
Ahora sólo debemos ver cómo hacemos para incluir el archivo de funciones auxiliares en nuestro nuevo programa.
Para eso desplegamos el menú Programa en la barra de menúes de la parte superior del IDE. Seleccionamos la opción Añadir fichero… y se nos abre un cuadro de diálogo para que busquemos el .ino que guardamos allí, con las funciones de motor que queremos incluir en este programa nuevo.
Lo abrimos, como si fuera un .ino estándar, pero, debido a la opción que hemos elegido, en lugar de abrirse en una nueva ventana del IDE se abre en una nueva pestaña auxiliar de la misma ventana. Nuestra ventana de trabajo queda como vemos aquí:
Ya podemos regresar a la pestaña principal, compilar y subir el programa al Arduino.
Cuando guardemos este programa principal, y volvamos a abrirlo otro día, el IDE de Arduino se abrirá con las dos pestañas. Si se observa dentro de la carpeta que, como es habitual, lleva el nombre del programa (en este ejemplo Otro_control_de_motores) veremos que dentro de ella están los dos archivos .ino: Otro_control_de_motores.ino y FuncionesMotor.ino
Esto no significa que el IDE haya movido FuncionesMotor.ino desde la carpeta /FuncionesUtiles/ que creamos, sino que sólo lo ha copiado. Así que, por supuesto, este archivo .ino de funciones auxiliares para adjuntar podemos incluirlo en todos los programas donde sea necesario. No será propiedad exclusiva de ninguno de ellos.
