CAB 5. Lenguaje Arduino. Aspectos Generales

5.1 Introducción

Una vez conocemos nuestra placa Arduino, hemos instalado el IDE y hemos visto que funcionalidades nos ofrece éste, el siguiente paso es programar nuestros Sketchs (recordar que este es el nombre que reciben los programas en Arduino) para conseguir que nuestros montajes adquieran funcionalidad práctica y podamos dotarlos de comportamientos inteligentes, como podemos ver en la Sección de Proyectos y de Robots de esta Web.

El lenguaje de programación de Arduino, que no tiene un nombre concreto como tienen otros lenguajes conocidos C, C++, Pascal, Java, Lisp, Python, etc., suele ser conocido directamente como Lenguaje Arduino.

Es un lenguaje muy similar en sintaxis e incluso en semántica al lenguaje C o C++, aunque como veremos hay diferencias significativas.

Si ya sabes C o C++ pues genial, si sabes programar en cualquier otro lenguaje pues también te resultará útil y si no tienes experiencia previa en lenguajes de programación no te preocupes, pues aquí hay cabida para todos.

Muy pronto, practicando sin miedo a equivocarnos, ya que equivocarse es aprender, estaremos en disposición de poder programar y realizar montajes y proyectos interesantes y divertidos.

Sin más tiempo que perder… ¡ Empecemos nuestra aventura !

5.2 El Estilo de la Programación

Respecto al Estilo de la Programación debemos indicar que nos encontramos ante un lenguaje bastante “relajado” en este tema.

  • No son necesarios un número de espacios concreto entre los distintos elementos del lenguaje
  • No es necesaria una tabulación específica en sus instrucciones ni líneas de código
  • Podemos tener varias instrucciones en una misma línea o una única instrucción separada en varias líneas
  • La regla principal que rige la programación Arduino consiste en que cada instrucción finaliza con un ; que da comienzo a la siguiente instrucción.

Es cuestión de organización y estética del código mantener una ordenación y tabulación adecuadas para facilitar la legibilidad del código fuente.

Los bloques de código vienen determinados por dos llaves { instrucciones código }.

La forma de uso de estas llaves, como hemos indicado, la elegimos libremente, pero suele ser habitual el empleo de una de las dos formas siguientes

void funtion ()
{
instrucciones;
}
void funtion () {
  instrucciones;
}

En nuestro caso vamos a utilizar la segunda notación, pero ambas son igualmente válidas y puedes elegir la que te encuentres más cómodo.

Adicionalmente el IDE de Arduino dispone de una Herrramienta para organizar y tabular el código a la que se accede desde el apartado Herramientas -> Auto Formato o mediante las teclas Control + T.

5.3 Los Comentarios

Los Comentarios son líneas del programa o parte de las mismas cuya función es documentar el código fuente con lenguaje natura, es decir el que usamos los humanos y que no es tan rígido como el empleado por los ordenadores.

Esta documentación tiene dos objetivos:

  • En primer lugar que una tercera persona pueda entender el código escrito por nosotros más fácil y rápidamente.
  • En segundo, que una vez pasado el tiempo nosotros mismos podamos entender y recordar más fácilmente el comportamiento del código que escribimos con anterioridad.

Los comentarios no se compilan, es decir, son ignorados por el compilador y por lo tanto no ocupan espacio en la memoria del microcontrolador Arduino, una vez subimos el código a la placa. Por lo tanto, podremos escribir comentarios más o menos largos, aunque tampoco debemos abusar (el código fuente no es una novela), sin miedo a no disponer de espacio en el Arduino para las instrucciones operativas.

Existen 3 formas de usar los comentarios:

  • Para comentar un fragmento de código. Se emplean líneas completas que empezaremos con los caracteres //
// La siguiente función realiza la inicialización y configuración del Arduino
void setup() {
}
// También la podemos escribir usando varias líneas si el comentario es muy largo
// La siguiente función realiza la inicialización
// y configuración del Arduino
void setup() {
}
  • Para comentar una instrucción concreta en la misma línea . Se usa // a continuación de la instrucción
a = a + 1;   // Incrementamos la variable a en 1
  • Para realizar un comentario largo de varias líneas o bloque. En este caso utilizamos /* para iniciar el comentario y */ para finalizarlo
/* Esta función realiza la suma de los lados
a y b de la forma F(x)=a+b
y nos devuelve un resultado entero
que podremos utilizar en este módulo */

Como consejo, hay que saber que también podremos dar un uso temporal y diferente a los comentarios. Suelen resultar útiles para “inutilizar” líneas de código de forma temporal para el compilador cuando estamos buscando un error o depurando un funcionamiento que no termina de ser el correcto. Comentar una línea de código de esta forma nos permitirá simplificar el código sin borrarlo para poder depurarlo más cómodamente.

5.4 Estructura General de un Sketch

Los Sketchs de Arduino tendrán un aspecto o estructura muy similar a la siguiente

// ================================================
// Librerias
// ================================================


// ================================================
// Declaraciones, Constantes, Variables ...
// ================================================


// ================================================
// Modulo Inicializacion y Configuracion
// ================================================
void setup() {
  // Instrucciones;
}


// ================================================
// Bucle Programa
// ================================================
void loop() {
  // Instrucciones;
}

En esta estructura podemos diferenciar 4 partes o secciones

5.4.1 Librerías.

En esta parte se importan las Librerías necesarias para el Sketch.

Realmente deberíamos utilizar la correcta traducción del inglés Library que es Biblioteca, pero es más común el empleo de Libreria (pese a ser una errónea traducción) en el ámbito de la programación. Por lo tanto y por simplificación, utilizaremos generalmente el término Librería en lugar de Biblioteca en esta Web.

Las Librerías son archivos que contienen código fuente y que nos permiten agilizar la programación reutilizando en nuestro programa ese código y evitando de esta forma tener que escribirlo nosotros mismos.

Las Librerías pueden ser básicamente de dos tipos dependiendo de su finalidad:

  • Librerías Propias
    • Son las que generamos nosotros mismos.
    • Se utilizan para reutilizar código propio sin la necesidad de volver a teclearlo.
    • Generalmente, encapsulan datos y comportamientos de forma organizada.
  • Librerías Externas o Ajenas
    • Son las generadas por terceras personas y que básicamente cumplen una o varias de las siguientes funciones:
      • Añadir funcionalidad, ampliando de esta forma la potencia del lenguaje de programación sin necesidad de tener que teclear esas funciones nosotros mismos.
      • Añadir funcionalidades específicas al lenguaje en un ámbito concreto (matemática, encriptación, gráficos, …)
      • Añadir las funciones necesarias para interactuar cómodamente con otros componentes. Este será un empleo muy habitual en la programación de Aduino. Por ejemplo, si en nuestro montaje o proyecto utilizamos un sensor de distancia el fabricante del mismo suele suministrar las librerías necesarias para poder operar con este componente de forma ágil y cómoda sin necesidad de un profundo conocimiento por nuestra parte para poder operar con el sensor. En este caso, las librerías añaden una capa de abstracción sobre el hardware que nos hace su uso más fácil y cómodo.

La instrucción que se utiliza para añadir una librería a nuestro Sketch es #include <nombre_libreria.h>.

Por ejemplo, con la siguiente instrucción incluiríamos la librería que nos permite utilizar una pantalla de cristal líquido.

#include <LiquidCrystal.h>

Existen muchas librerías que vienen preinstaladas en el IDE de Arduino. Son las llamadas librerías estándar.

Para ver cuales son y qué hace cada una de ellas, puedes ver un listado de las mismas en la Web de Arduino en el apartado de Libraries.

Figura CAB5.1 Librerías Estandar Arduino

Para incluir una librería estándar en el sketch, si conocemos su nombre podemos introducir la orden que hemos visto anteriormente, como por ejemplo

#include <Servo.h> 

Y con esta librería incluida en nuestro sketch ya podríamos controlar un servomotor.

Otra forma de incluir una librería en nuestro programa es mediante el menú Programa –> Incluir Libreria, y a continuación seleccionar la que queramos utilizar.

Figura CAB5.2 Incluir Librería Estándar en nuestro Sketch

También podremos incluir librerías no estándar, es decir, no desarrolladas por el equipo de Arduino sino por terceros, como podría ser el caso de librerías para utilizar componentes de otros fabricantes como Adafruit o Az-Delivery entre otros muchos. En este caso, debemos añadir previamente los ficheros de estas librerías al IDE de Arduino para poder utilizarlas.

5.4.2 Instrucción define

La instrucción #define, es una instrucción un tanto específica y que también la introduciremos en la cabecera de nuestros sketchs compartiendo sección con la anterior instrucción #include.

La palabra reservada #define nos permite definir constantes globales.

Aunque parece redundante e innecesaria, pues el lenguaje Arduino ya tiene una orden para definir constantes, que es const, como veremos en el siguiente capítulo de este curso, sin embargo el funcionamiento de ambas a nivel interno es muy diferente.

  • #define es una orden de pre-compilado. Es decir, el compilador traduce directamente la constante definida por #define a su valor cuando realiza la compilación. Por lo tanto esta instrucción o modificador reduce el uso de memoria dinámica y acelera el tiempo de ejecución.
  • const no tiene este funcionamiento, sino que durante la ejecución cada vez que aparece la constante definida por const su valor se busca en la memoria.

La experiencia nos permitirá decidir cual de ambas fórmulas queremos utilizar en cada ocasión, pero mi recomendación es utilizar la instrucción const, al menos inicialmente, para evitar errores.

Respecto a las instrucciones #include y #define, cabe señalar:

  • Ambas instrucciones o palabras reservadas del lenguaje de programación son conocidas como directivas del compilador, ya que son líneas de código ejecutadas antes de la compilación. También son conocidas como instrucciones de pre-compilado.
  • #include es una directiva de inclusión.
  • #define es una directiva de definición.
  • Ninguna de las dos finaliza con el ; que si lo hacen el resto de instrucciones.

5.4.3 Declaraciones, Constantes, Variables

En esta sección declararemos las Constantes y Variables Globales.

Las Variables Globales son variables que serán visibles y utilizables en cualquier parte del programa, no solo en el ámbito local de la definición (en este caso estas variables no tienen este comportamiento).

De momento no vamos a profundizar más sobre las Variable, pues dada su importancia y amplitud las veremos con mayor profundidad en un capítulo posterior del presente curso.

5.4.4 Módulo de Inicialización y Configuración

Este módulo es el definido por la función setup ()

Este módulo se ejecuta una sola vez, en una de las siguientes dos opciones:

  • Se enciende la placa Arduino
  • Se presiona el Reset de la placa Arduino

En este módulo se ejecutan las instrucciones que necesita el microcontrolador para su configuración inicial.

Se parametrizan los valores y variables necesarios para su correcto funcionamiento, como la definición delos conectores o pines de Entrada y Salida, …

5.4.5 Bucle del Programa

Es el módulo que se define por la función loop ()

Se trata de un bucle que se ejecuta de forma infinita ya que no tiene condición de parada mientras Arduino está encendido y no se presione Reset.

Este es el módulo principal del programa o Sketch y es el bucle que define el comportamiento de la placa y lo que queremos hacer con ella en nuestro Proyecto.

Todo programa Arduino debe contener estos dos módulos de forma obligatoria: setup() y loop().

El orden de los mismos es indiferente y no altera el funcionamiento, pero por pureza en la programación y para facilitar la legibilidad del código del Sketch primero pondremos la función de configuración setup() y después el bucle loop().

5.4.6 Funciones

Las funciones podrán estar definidas en cualquier parte del Sketch.

Las funciones son fragmentos de código que pueden contener entradas y / o salidas de datos o no y que realizan acciones concretas y definidas en la programación.

Las veremos con detalle, además de ver las funciones propias del Lenguaje Arduino, en un capitulo posterior de este curso.

Este sitio web utiliza cookies para que usted tenga la mejor experiencia de usuario. Si continúa navegando está dando su consentimiento para la aceptación de las mencionadas cookies y la aceptación de nuestra política de cookies, pinche el enlace para mayor información.plugin cookies

ACEPTAR
Aviso de cookies