2.6 Marcadores sintácticos

Antes de proseguir vamos a explicar algunos marcadores que hemos visto en ejemplos anteriores sin explicarlos debidamente:

 2.6.1 Fin de instrucción: “;

Habrás observado que todas las declaraciones e instrucciones terminan en un punto y coma:

int a = 13;

Esta es una convención sintáctica que conviene no olvidar si no queremos tener que vérnoslas con un impenetrable y aparentemente ilógico error del compilador.

 

2.6.2 Llaves (“curly brackets”)  “{}”

Las llaves de apertura y cierre son una parte importantísima de la sintaxis del lenguaje de programación de C. Se utilizan en diversas estructuras (que veremos a continuación) y son frecuentemente una fuente de dolores de cabeza para los principiantes.

La llave de apertura “{” debe de ser complementada siempre por una llave de cierre “}”. El IDE de Arduino IDE (entorno de desarrollo integrado) incluye una función que nos ayuda a comprobar este equilibrio entre llaves de apertura y de cierre. Simplemente con seleccionar una llave de apertura/cierre, el IDE nos indicará donde está la llave de cierre/apertura que “casa” con la seleccionada (“logical companion”). No te fíes demasiado de esta funcionalidad del IDE ya que a veces se puede equivocar y señalar una “compañera” equivocada.

Dado que el uso de las llaves es tan variado y extendido en C, se recomienda escribir la llave de cierre justo después de la de apertura para ir “rellenando” el interior con código y evitar así olvidarnos de escribir la llave de cierre al final (piensa que probablemente vas a escribir bucles, funciones, etc. dentro de estas llaves que llevaran a su vez llaves de apertura y cierre. De esta manera evitas olvidos que te llevarían a errores bastante impenetrables del compilador que pueden a veces ser difíciles de localizar en un programa grande. Por otra parte, ten en cuenta que las llaves de apertura y cierre son el marcador sintáctico más importante del lenguaje y su uso en una posición incorrecta pueden llevarte a una ejecución del programa totalmente diferente de la que habías previsto.

Un pequeño resumen de los usos más frecuentes de las llaves de apertura y cierre:

En funciones:

void myfunction(datatype argument){
    instruccion(es)
  }

En bucles:

while (boolean expression)
  {
     instruccion(es)  
  }
  do
  {
     instruccion(es)
  } while (boolean expression);

  for (initialisation; termination condition; incrementing expr)
  {
     instruccion(es)
  } 

En instrucciones condicionales:

if (boolean expression)
  {
      instruccion(es)
  }
else if (boolean expression)
  {
     instruccion(es)
  } 
  else
  {    instruccion(es)
  } 

2.6.3 Comentarios dentro de un programa (documentando nuestros programas)

Habrás notado que muy frecuentemente añadimos comentarios al código de un sketch o programa con el efecto de hacerlo más legible, fácil de entender (y mantener) por otro programador, en definitiva, mejor documentado.

Generalmente los comentarios se utilizan para informar sobre la manera en que trabaja el programa (a otros programadores, o recordase a sí mismo cuando tienes que modificar un programa que escribiste hace tiempo) Los comentarios son ignorados por el compilador y no se exportan al procesador, así que no toman ningún espacio en el microprocesador ni en la memoria de ejecución. Dependiendo de su extensión, hay dos maneras diferentes de formular comentarios:

x = 5;     // Esto es un comentario de una sola línea.   
           // Todo lo que hay desde la doble barra inclinada 
           //y hasta el final de la línea es un comentario. 
/* esto es un comentario de bloque –que ocupa varias líneas –Se suele usar para comentar un bloque de código (en vez de una sola instrucción como el comentario de línea de arriba */ 

Nota: se pueden incluir comentarios de línea dentro de un comentario de bloque, pero no viceversa. Hay que tener mucho cuidado y cerrar el comentario de bloque con un */.

De lo contrario el compilador producirá un mensaje de error.

Poner entre comentarios de bloque (/*…*/) una bloque entero de código que da problemas es una buena idea de cara a identificar el elemento que da problemas sin tener que borrar (y reescribir) todo el código del bloque en cuestión.

 

2.6.4 #define: definiendo valores constantes

El #define es un componente útil de C que permite que el programador dé un nombre a un valor constante antes de que se compile el programa. Las constantes definidas en Arduino no usan memoria del programa en el microprocesador. El compilador substituirá referencias a estas constantes por el valor definido durante la compilación.

Sin embargo, esto puede tener algunos efectos secundarios indeseados. Por ejemplo, el valor de una constante que ha sido declarada con #define será incluido automáticamente en todos los nombres de constantes o variables que incluyan este nombre como parte de su propio nombre. Veamos un ejemplo de esto último:

#define PinLed 3
const PinLedRojo = 8;

El compilador sustituirá el nombre de la constante PinLedRojo por 3Rojo.

La sintaxis del #define es:

#define Nombreconstante  valor

(nota que el # debe de ir pegado al define y es obligatorio)

Example

#define ledPin 3
 
 
 
 
  • Nota importante: Recuerda que NO hay punto y coma tras la instrucción #define. Si lo pones el compilador te agrederá con una serie de mensajes ininteligibles mensajes de error.
  • #define PinLed 4;    // ¡erroneo!!. ¡No pongas el ; al final!
 

Del mismo modo incluir un signo igual tras el nombre de la constante conseguirá también irritar igualmente al compilador.

#define PinLed =5  //¡Error!!. ¡No pongas el signo igual! 

2.6.5 #include: Incluyendo bibliotecas externas.

La instrucción “#include” se utiliza para incluir bibliotecas externas en un sketch. Esto da el programador el acceso a un gran número de bibliotecas estándar del lenguaje C (una librería es fundamentalmente un grupo de funciones ya desarrolladas), asi como de un muchas bibliotecas escritas especialmente para Arduino.

Puedes encontrar la página principal de referencia para las bibliotecas de C del AVR (el AVR es una referencia a los microprocesadores de Atmel en los cuales se basa el Arduino) en la siguiente dirección:

http://www.nongnu.org/avr-libc/user-manual/modules.html

Observa que el #include, del mismo similar que el #define, no admite punto y coma al final.

El ejemplo expuesto a continuación incluye una biblioteca utilizada para poner datos en la memoria flash en vez de usar la RAM. Esto ahorra espacio en la RAM que puede ser usado como memoria dinámica y hace que las operaciones de búsqueda en grandes tablas mucho más prácticas y rápidas.

#include <avr/pgmspace.h>
prog_uint16_t myConstants[] PROGMEM = {0, 21140, 702  , 9128,  0, 25764, 8456,
0,0,0,0,0,0,0,0,29810,8968,29762,29762,4500};