Lo Último en IP@P
- UGREEN Nexode Pro: El Cargador Ultradelgado que revoluciona la carga de dispositivos móviles
- La computación en la nube está transformando los juegos Online y estas son sus grandes ventajas
- Actualizaciones del Programa de Afiliados de TEMU: ¡Hasta MX$500,000 al mes!
- ¿Aún es rentable invertir en oro en comparación con la inversión en criptomonedas?
- ¡Netflix sigue siendo el rey! Estas son las plataformas de streaming con más usuarios en el mundo
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.
Más en Informática
- Tipos de memoria caché: ¿Qué son, para qué sirven y cómo se clasifican estas memorias temporales?
- Crippleware ¿Qué es, para qué sirve y cómo funciona esta licencia de software?
- Archivos Torrent ¿Qué son, para qué sirven y cómo podemos descargarlos?
- Computadoras y ordenadores personales ¿Qué son, para qué sirven y qué usos tienen?
- Archivos Digitales ¿Cuáles son los principales tipos de archivos que existen y cómo puedo identificarlos?
SÍGUENOS EN 👉 YOUTUBE TV
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