Introducción

Ahora que tenemos nuestra placa correctamente instalada y conocemos el entorno de programación para nuestro Arduino, llega el momento de aprender a programar!!. He de decir que esta es la parte difícil y quizás aburrida para muchos, pero del conocimiento del lenguaje de programación va a depender que nuestros programas puedan hacer cosas increíbles.

Estructura

Al empezar a trabajar con Arduino, tenemos que tener muy claro la estructura de trabajo básica, esta estructura es muy simple y debe aparecer en TODOS los programas, se trata de dos funciones, la función “setup” y la función “loop”.

void setup() //configuración
{
  pinMode(13,OUTPUT);
}
void loop() // programa principal
{
  digitalWrite(13,HIGH);
  delay(1000);
  digitalWrite(13,LOW);
  delay(1000);
}

Arriba podemos ver estas dos funciones en un ejemplo que ya conocemos el “blink”, como se aprecia, la función “Setup” declara el Pin 13 como salida, ya que es por este Pin por donde pretendemos sacar información, o en nuestro caso el estado del Led. La función “Setup” solo se invoca una vez al inicio del programa, y se usa para configurar los pines, configurar la comunicación serie o establecer un estado inicial o de partida para algún dispositivo.

La función “Loop” será la función donde se encuentre el grueso de nuestro programa, esta función se repetirá una y otra vez ejecutando lo que se encuentre en su interior, esta repetición es la que posibilita que el programa este actualizándose y respondiendo a los eventos que ocurran.

Las funciones “Loop” y “Setup” son necesarias en todos los programas que hagamos, pero no tienen por qué ser únicas, podemos crear tantas funciones como queramos para organizar el contenido de nuestro programa ó para hacer tareas repetitivas dentro de nuestro programa principal. Las funciones están acotadas por las llaves{}, estas llaves definirán el bloque de la función.

Instrucciones y operadores

Delimitadores: son elementos que acotan o detienen el alcance de una función o instrucción

  • {} Llaves: definen el principio y el final de un bloque de instrucciones o función, podemos encontrarlas en estructuras de control definiendo el bloque al cual afecta la función. Podemos anidar tantos bloques como queramos.
  • ; Punto y coma: Se utiliza para separar instrucciones, es común olvidar colocarlo al final de línea. Si no lo ponemos no reconocerá el fin de la función y el programa dará un problema al compilar.
  • Comentarios: Es muy recomendable usar comentario desde el principio para hacer anotaciones sobre el funcionamiento del programa, esto nos va a ahorrar muchos problemas si nuestro programa se hace muy grande y va a permitir que otras personas entiendan como hemos hecho el programa.
    • /*….*/ Bloque de comentario: Son áreas de texto que pueden abarcar más de una línea, lo que escribamos entre esos símbolos será ignorado por el programa.
    • // Línea de Comentario: Funciona como el bloque de comentario, con la diferencia que solo será ignorado el texto que este a su derecha, al cambiar de línea perderá el efecto.

Operadores

Los operadores son los elementos con los que vamos transformar variables, hacer comparaciones, contar un número determinado de eventos… en definitiva, los operadores se pueden considerar los elementos más importantes del programa junto con las estructuras de control. Dentro de los operadores, podemos encontrarlos de varios tipos

Aritméticos: Son operadores básicos como la suma, resta, multiplicación y división, también podríamos incluir aquí la operación de asignación “=”

1
2
3
4
5
6
/* OPERADORES ARITMÉTICOS */
x = x + 5; //suma x+5 y guarda el valor en x
y = y - 8; //resta 8 a el valor "y" almacena el resultado en "y"
z = z * 2; //multiplica z*2 y guarda el valor en z
k = k / 3; //divide k entre 3 y guarda el valor en k
p = 10; // asigna a p el valor 10

Asignaciones compuestas: Combinan una operación aritmética con una variable ya asignada. Se usan comúnmente en bucles.

1
2
3
4
5
6
7
/* OPERADORES DE ASIGNACIÓN COMPUESTA */
x ++; //equivale a x = x + 1 (incrementa x en 1)
x --; //equivale a x = x - 1 (decrementa x en 1)
x += y; //equivale a x = x + y
x -= y; //equivale a x = x - y
x *= y; //equivale a x = x * y
x /= y; //equivale a x = x / y

De comparación: Este tipo de operadores se usan para comprobar variables o constantes con otras verificar así si una condición es verdadera o no. Suelen utilizarse en conjunto con estructuras de control.

1
2
3
4
5
6
7
/* OPERADORES DE COMPARACIÓN */
 x == y; //x es igual a y
 x != y; //x es distinto de y
 x < y; //x es menor que y
 x > y; //x es mayor que y
 x <= y; //x es menor o igual que y
 x >=y; // x es mayor o igual que y

Booleanos: Son operadores lógicos que se usan para comparar 2 o más expresiones y que no devuelven un valor, sino que dan un estado de “verdadero” (si se cumple la expresión) o “falso” (si no se cumple).

1
2
3
4
/* OPERADORES BOLEANOS */
if (x<3 && x>0) //Cierto si se cumplen las dos expresiones
if (x<7 || x=20) //Cierto si se cumple alguna de las dos expresiones
if (!x=3) //Cierto si x es distinto de 3

Estructuras de control: En las estructuras de control se engloban todos los estamentos que sirven para guiar al programa en una u en otra dirección en función de si se cumplen las condiciones que le marquemos. Dentro de estas estructuras podemos encontrar condicionales, bucles o elementos de salto.

Condicionales: Los condicionales chequean un estado o condición y si esta condición se cumple se pasa a ejecutar las sentencias englobadas dentro de la condición

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
/* CONDICIONALES */
if (x==10) //Si x es igual a 10 ejecuta la instrucción
{
  ejecuta instrucciones
}
if (y != 10) // Si y es distinto de 10 ejecuta la instrucción
{
  ejecuta instrucciones
}
else //si no, ejecuta esta instrucción
{
  ejecuta instrucciones
}

 

Bucles: Los bucles son unos estamentos los cuales harán que el programa entre en un ciclo de repetición mientras se cumplan las condiciones del bucle.

 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
/* BUCLES */
/*Entra en el bucle "for" y se repetirá mientras se cumpla la condición*/
for(int x=0; x<20; x++) //asigna a x el valor 0; condición ; incrementa x en 1
{
  ejecuta instrucciones
}
/* El bucle while se ejecutará siempre que se cumpla la condición*/
while (x!=0)
{
  ejecuta instrucciones
}
/* El bucle "do...while" se ejecuta almenos 1 vez, luego dependerá de si se cumple la condición */
do
{
  instrucciones
}while (x!=0);