Estructuras de control en Arduino ¿Qué son, para qué sirven y cuáles son las más importantes que debes conocer?

Las estructuras de control dentro del IDE de Arduino te ayudarán a crear los programas para tus proyectos con la placa Arduino. Por tal motivo, es importante que conozcas los secretos de esta herramienta del lenguaje de programación, los cuales te mostraremos a continuación.

Lo primero que haremos es analizar los diferentes tipos de estructuras de control en Arduino y entender por qué son tan importantes para llevar adelante el boceto.

También mencionaremos las demás estructuras en la programación de Arduino que debes conocer para desarrollar tus propios proyectos desde cero. Presta atención a cada detalle para convertirte en un verdadero experto en electrónica.

¿Qué son las estructuras de control y para qué sirven en la programación de proyectos Arduino?

Las estructuras de control en el entorno de programación de Arduino son herramientas que se utilizan para elegir una secuencia o un camino alternativo dentro de la estructura del software. Esto quiere decir que, son instrucciones que permiten romper la secuencia metódica de los códigos, ya que existe una expresión lógica con la cual se debe decidir si se elige una ruta u otra para que ambas puedan llegar más adelante al mismo final del proceso.

Para obtener una mejor administración y lectura del código de programación es necesario utilizar en forma correcta la tabulación en cada estructura. Esto ayudará a encontrar más rápidos los errores o las secuencias que se quieren repetir.

Tipos de estructuras de control en Arduino ¿Cuáles son todas las que existen?

Existen dos tipos de estructura de control dentro de la programación de Arduino, las cuales son:

Estructuras de decisión

Este tipo de estructura se refiere al camino que debe realizar el programa cuando existe una variable que divide la secuencia de los códigos en dos. Para ello, se evalúa una condición y devuelve un valor (verdadero o falso) para tomar la decisión de qué instrucciones ejecutar, según la respuesta.

En Arduino encontrarás las siguientes sentencias condicionales: 

if

Deberás utilizar esta herramienta cuando quieras conocer si una variable alcanzó una determinada condición.

Su sintaxis es: 

if (condition) { // Siendo condition una expresión de TRUE o FALSE.

//statement(s)

}

Por ejemplo: 

if (x > 120) digitalWrite(LEDpin, HIGH);

if (x > 120)

digitalWrite(LEDpin, HIGH);

if (x > 120) {digitalWrite(LEDpin, HIGH);}

if (x > 120) {

digitalWrite(LEDpin1, HIGH);

digitalWrite(LEDpin2, HIGH);

}

// todo está correcto

En caso de agregar else, entonces lo que se busca es que, si no cumple con una condición, de esta forma el programa deberá realizar una acción determinada.

else

Con esta herramienta de estructura de control se pueden elegir varias condiciones que sean excluyentes entre sí cuando se produce una situación determinada.

Se tiene que usar con la siguiente estructura: 

if (condition1) {

// do Thing A

}

else if (condition2) {

// do Thing B

}

else {

// do Thing C

}

switch - case

Es posible utilizar esta estructura cuando se necesita que el programa decida sobre una instrucción precisa cuando existe la posibilidad de comparar el valor de la variable en relación con valores establecidos de antemano.

Su sintaxis se establece de la siguiente manera: 

switch (var) {

case label1:

// statements

break;

case label2:

// statements

break;

default:

// statements

break;

}

En donde var es la variable que el programa tiene que comparar con otros datos (siempre que sean del tipo int y char). Y label son las constantes ejecutadas. Se usa break para salir del switch y default para ejecutar el bloque de códigos cuando no se cumplan con las condiciones solicitadas.

Estructuras de repetición

Estas estructuras de bucles son herramientas que permiten ejecutar las instrucciones que tiene el programa de manera repetida.

Entre las sentencias más usadas en Arduino se encuentran:

for

Podrás repetir las secuencias de los códigos que se encuentren entre llaves las veces que indiques en el IDE de Arduino. Para ello, se analizará que se cumplan las condiciones para que se vuelvan a ejecutar esta serie de estructuras de control.

Se desarrolla siguiendo estos parámetros:

for (initialization; condition; increment) {

// statement(s);

}

En donde initialization significa que estará una vez y en el principio de la estructura. Condition es la sentencia que debe ocurrir en el programa para que ingrese al bucle en cuestión (hay que tener presente que el ciclo terminará cuando entregue la condición FALSE). En caso de que el bucle arroje TRUE, entonces se ejecutará por medio del increment.

while

Con esta herramienta podrás ejecutar el bucle de forma continua y todas las veces que sea necesario, siempre que se cumpla con la condición establecida al comienzo de bucle entre paréntesis. Si arroja un valor falso se sale de la expresión y termina la acción.

Su estructura es:

while (condition) { // la condición debe ser TRUE o FALSE

// statement(s)

}

do while

Este bucle se usa de la misma manera que la sentencia mencionada antes, while. Pero en este caso la condición para que se repita la estructura se encuentra al final del bloque, encerrado entre paréntesis.

Su sintaxis es:

do {

// statement block

} while (condition);

Un ejemplo de esto es:

int x = 0;

do {

delay(50); // para esperar que se estabilice el sensor

x = readSensors(); // lectura de los sensores

} while (x < 100);

goto

Esta herramienta es muy útil cuando se necesita que el programa se transfiera a un punto determinado, de acuerdo con la etiqueta establecida con anterioridad.

Por ejemplo:

for (byte r = 0; r < 255; r++) {

for (byte g = 255; g > 0; g--) {

for (byte b = 0; b < 255; b++) {

if (analogRead(0) > 250) {

goto bailout;

}

// más declaraciones de códigos del programa

}

}

}

bailout:

// más declaraciones

break

Cuando necesites salir de la estructura de control vas a tener que usar esta sentencia. Se debe usar con do, for o while.

Un código de ejemplo es:

int threshold = 40;

for (int x = 0; x < 255; x++) {

analogWrite(PWMpin, x);

sens = analogRead(sensorPin);

if (sens > threshold) { // rescatar en la detección del sensor

x = 0;

break;

}

delay(50);

}

continue

Para saltar el resto de las secuencias plasmadas en el programa, es necesario usar esta herramienta junto a do, for o while.

Por ejemplo:

for (int x = 0; x <= 255; x ++) {

if (x > 40 && x < 120) { // crear salto en los valores

continue;

}

analogWrite(PWMpin, x);

delay(50);

}

Otras estructuras en la programación Arduino que debes conocer para desarrollar tus propios proyectos

Además de las estructuras mencionadas antes, existen otras herramientas que también deben ser tenidas en cuenta a la hora de programar tu placa Arduino.

Mira a continuación:

Bosquejo

El bosquejo, también conocido como sketch de Arduino, es la estructura de programación en la cual se incluyen todos los códigos que permiten llevar adelante el proyecto para que la placa realice las acciones deseadas. Está compuesto de variables, funciones agregadas por el operador, las herramientas setup() y loop() y los comentarios realizados por el programador.

Dentro de este entorno de programación es posible encontrar un área de mensajes para mostrar los errores o el correcto funcionamiento del programa. También se utiliza la barra de herramientas con la cual se accede a los diferentes comandos. Es importante mencionar que la extensión de un bosquejo es .ino y para que funcione el sketch es necesario que el directorio tenga el mismo nombre del croquis, aunque es posible que el sketch esté en otro fichero, pero debe pertenecer a un directorio con el mismo nombre.

La estructura del boceto es: 

void setup() {

// agrega tu código de configuración aquí para ejecutar una vez:

}

void loop() {

// ingresa el código principal aquí para que se ejecute de forma repetida:

}

Operadores aritméticos

Los operadores aritméticos son símbolos que se utilizan dentro de la programación de un software de Arduino para incluir funciones de suma, resta, multiplicación y división. Hay que tener presente que los valores devueltos están en función de los datos que se han definido en los operandos, por ejemplo, int (en este caso los resultados obtenidos no tendrán decimales).

Teniendo en cuenta lo anterior, es posible plantear el siguiente ejemplo:

int a = 5;

int b = 10;

int c = 0;

c = a + b; // la variable c obtiene un valor de 15 después de que se ejecuta esta declaración

Si por algún motivo los operandos son de diferentes tipos, programa tomará el operando más importante y devolverá un valor basado en ese criterio. Por ejemplo, si hay 2 datos (uno de tipo int y el otro float, siendo este mayor) el C++ devolverá un resultado en coma flotante.

De esto se desprende el ejemplo que te mostramos a continuación:

float a = 5.5;

float b = 6.6;

int c = 0;

c = a + b; // la variable 'c' almacena un valor de 12 solo en contraposición a la suma esperada de 12.1

Operadores de comparación

Al igual que los operadores aritméticos, en este grupo se incluyen símbolos que ayudan a una mejor programación, pero teniendo en cuenta una variable condicional.

Por lo tanto, es posible encontrar en este conjunto los siguientes símbolos:

x == y (la variable x es igual a y). Hay que tener presente que se usa el doble igual (==), ya que un solo = representará otra asignación.

x! = y (la variable x no es igual a y)

x < y (la variable x es menor que y)

x > y (la variable x es mayor que y)

x < = y (la variable x es menor o igual que y)

x > = y (la variable x es mayor o igual que y)

Un ejemplo de una estructura de programación con operadores de comparación es:

if (x > 120) digitalWrite(LEDpin, HIGH);

if (x > 120)

digitalWrite(LEDpin, HIGH);

if (x > 120) {digitalWrite(LEDpin, HIGH);}

if (x > 120) {

digitalWrite(LEDpin1, HIGH);

digitalWrite(LEDpin2, HIGH);

}

// todas las condicionales son correctas