Sketch en Arduino ¿Qué es, para qué sirve y cómo se estructuran estos programas?

El Sketch es uno de los elementos más importantes que hay en el entorno de programación IDE. Debido a esto es necesario, si quieres convertirte en un verdadero experto, que conozcas cuál es la estructura que tienen los bocetos.

Esta información la podrás encontrar en los siguientes párrafos. Te explicaremos, de manera detallada, qué es un Sketch y para qué sirven estos programas. Además, te mostraremos todas las partes de un código de Arduino.

Te invitamos a que continúes leyendo hasta el final porque encontrarás información de ejemplos de Sketch que puedes usar para aprender a programar. Echa un vistazo.

¿Qué es un Sketch de Arduino y para qué sirven estos programas?

Si vas a crear un proyecto con una placa de Arduino no solo necesitarás usar los pines para conectar los diferentes elementos entre la placa, los circuitos y el hardware que desees. También vas a tener que programar al modelo de Arduino que posees para que emita señales electrónicas y se pueda llevar adelante el proyecto. Por ejemplo, si creas un robot en la primera etapa tendrás que hacer las conexiones necesarias de manera correcta, pero esto no te servirá de nada porque el robot seguirá inmóvil.

Por lo que deberás programar sus movimientos para que tenga sentido el proyecto. Para que el robot, siguiendo con el ejemplo, se mueva debes configurar la placa de Arduino en el entorno IDE. Este es un software que usa un lenguaje especial y divide a cada uno de los proyectos en un Sketch o boceto. Por lo tanto, un Sketch en Arduino es un programa en el que se guardan todos los códigos que se usan para hacer que la placa realice determinadas tareas.

Cuando encuentres un archivo con la extensión .ino significa que es un Sketch. Para que funcione de manera correcta, debes tener presente que el nombre de la carpeta en el que se guarda el boceto tiene estar incluido dentro de un directorio que lleve el mismo nombre que el Sketch.

Puedes guardar un programa de Arduino en diferentes ficheros, pero siempre estas carpetas deberán estar dentro del mismo directorio del fichero principal. Por último, tienes que tener presente que un Sketch está compuesto por 2 instrucciones, una llamada loop() y la otra setup(). Siendo la primera la encargada de ejecutar de manera cíclica, o por bucle, las instrucciones del programa, mientras que la segunda es el estamento que se usa para llevar adelante la configuración.

Estructura de un Sketch ¿Cuáles son todas las partes del código de un Arduino?

Como te mencionamos antes setup() y loop() forman parte de un Sketch, pero esto no son los únicos componentes que puedes encontrar en un programa de Arduino.

Te mostraremos a continuación cuáles son todas las partes del código de una placa electrónica que puedes usar en el IDE:

Estructura

Analizando un poco más profundo la estructura del Sketch, se puede decir que el setup() se utiliza para comenzar un boceto, inicializando bibliotecas, variables y modo en que se utilizarán los pines de la placa, entre otras cosas. Se usa cada vez que se produce el encendido o el reinicio de Arduino. Por lo tanto, se debe escribir una sola vez y al comienzo del código.

Un ejemplo de esto es: 

int buttonPin = 5;

void setup() {

begin(9600);

pinMode(buttonPin, INPUT);

}

void loop() {

// ...

}

El otro componente que integra el Sketch es el loop(). Este estamento o instrucción se lo utiliza después de haber creado el setup() para indicar los valores iniciales que tendrá una determinada función. De esta manera se puede controlar la placa mucho más fácil cada vez que se utilizan estos bucles.

Su uso es el siguiente: 

int buttonPin = 5;

// setup initializes serial and the button pin

void setup() {

begin(9600);

pinMode(buttonPin, INPUT);

}

// para controlar el pin 5,

// además, si Se presiona enviará Serial

void loop() {

if (digitalRead(buttonPin) == HIGH) {

write('H');

}

else {

write('L');

}

delay(1000);

}

Se pueden ver en los ejemplos anteriores que se utilizan otros comparadores, por lo que la estructura de un Sketch también se puede subdividir en más variables.

Dentro de estos componentes se puede encontrar: 

• De control: usados para establecer condiciones o ejecutar un procedimiento determinado. En este grupo se encuentran break; continue; do... while; for; goto; if; if...else; return; switch case y while.
• Aritméticos: hay que usar estas funciones cuando se necesite programar una operación primaria de matemáticas en el entorno de Arduino. Estos compradores son =; +; -; /; * y %.
• De sintaxis: ayudan a introducir comentarios de una o varias líneas, como así también para dar nombre a un valor constante o incluirlo en una compilación del programa. Se usan en este caso #define; #include; {}; punto y coma (;); // para comentarios de una línea al lado del código y /* */ para abrir y cerrar un comentario de varias líneas.
• Booleanos: cuando se necesita introducir una variable lógica hay que usar estos operadores en el IDE. Dentro de los mismos están || (or); && (and) y ! (not).
• De comparación: esta subcategoría es una de las más usadas en la programación como su nombre lo indica se utiliza para comparar una condición y arrojar un resultado para seguir con el procedimiento. En este grupo se usa = = (igual a); > (mayor que); >= (mayor que o igual a); < (menor que); <= (menor que o igual a) y != (no igual a).
• Compuestos: se usa dentro de una estructura del Sketch estos operadores cuando se necesite realizar una combinación de otros componentes. Es decir, cumplen una doble función. Debido a esto se puede usar &= (and bit a bit compuesto); -- (disminución); /= (división con método compuesto); ++ (incremento); %= (módulo compuesto); *= (multiplicación compuesta); |= (or bit a bit compuesto); -=(resta compuesta) y += (suma compuesta).
• Bit a bit: los operadores bit a bit trabajan con los números binarios en los cuales se debe establecer una relación de acuerdo con una regla determinada. Se utilizan los operadores >> (ir a la derecha); << (ir a la izquierda); ~ (no bit a bit); | (o bit a bit); ^ (xor bit a bit) y & (y bit a bit).
• Acceso al puntero: * y & son los operadores que puedes usar en este grupo.

Valores

En esta sección se encuentran las constantes, calificadores, alcance y los tipos de datos que se utilizan en la programación de una placa de Arduino.

Se puede dividir a las variables en:

• Constantes: se usan para hacer más fácil la lectura del lenguaje de la placa. Se puede encontrar los valores que puede tomar un pin y el modo de configuración de entrada o de salida. Los más usados son false; floating point constants; HIGH; LOW; INPUT; INPUT_PULLUP; integer constants; LED_BUILTIN; OUTPUT y true.
• Clases de datos: cuando se necesita indicar en el lenguaje de programación qué tipo de dato es con el que se trabaja hay utilizar este grupo. Por lo que se pueden agrupar en esta categoría a array; boolean; byte; char; double; float; int; long; short; string (como una matriz de caracteres); string (Objeto); unsigned char; unsigned int; unsigned long; void y word.
• De usos: esta categoría de variables se usa para que el programa devuelva un número determinado de bytes de una matriz. Por lo que se puede ingresar en el IDE PROGMEM y sizeof.
• De conversación: las variables que se encuentran en este grupo convierten un valor en un determinado tipo de dato. Se encuentran byte; char; float; int; long y word.
• Calificadores de alcance: se utilizan estas variables para modificar el comportamiento de la propia variable. De esta manera se indica que sólo es de lectura o es una variable global, entre otras funciones. Las más comunes son const; static; variable scope y volatile.

Funciones

En el lenguaje que se utiliza en el código de Arduino, la parte de funciones es aquella destinada a indicarle al programa qué tipo de acción debe realizar una variable.

Se pueden dividir:

• De entrada y salida: se trabaja con estos componentes cuando se necesita establecer un destino a la corriente o a la onda que recibe la placa. Se utilizan noTone; pulseIn; pulseInLong; shiftIn; shiftOut y tono.
• De tiempo: en un código es posible usar estos componentes para indicar una acción que esté relacionada con el tiempo, por ejemplo, los milisegundos que debe esperar la plata antes de entregar una acción. Se usa para estos componentes delay; delayMicroseconds; micros y milis.
• Digital: se usa para configurar las entradas y salidas de los pines digitales que tiene una la placa. Por lo tanto, es posible encontrar las funciones digitalRead; digitalWrite y pinMode.
• Analógica: al igual que ocurre con las funciones anteriores, estas acciones se dedican a configurar pines analógicos que tiene una placa de Arduino. Debido a esto se puede encontrar analogRead; analogWrite y analogReference (PWM). Pero cuando uses un modelo Arduino DUE o Arduino ZERO tendrás que ingresar las funciones analogReadResolution y analogWriteResolution para trabajar.
• Matemáticas: estas funciones permiten realizar cálculos matemáticos dentro del código del programa. Las más usadas son abs; constrain; map; max; min; pow y sqrt.
• Interrupciones: se usan estas funciones para activar o desactivar un proceso determinado. Dentro de este grupo se encuentran interrupts y noInterrupts. En cambio, si se necesita una interrupción externa las que se utilizan son attachInterrupt y detachInterrupt.
• Bits y bytes: estas herramientas de programación se utilizan para indicar que se debe extraer bits o bytes dentro de una variable. Por lo tanto, las funciones usadas por lo general son bit; bitClear; bitRead; bitSet; bitWrite; highByte y lowByte.
• De comunicación: este grupo es uno de los más utilizados en la programación IDE, ya que permite comunicar a la placa de Arduino con un ordenador o con cualquier otro hardware. Las funciones que puedes encontrar son Serial y Stream.
• Números aleatorios: estas funciones permiten generar números para crear una secuencia que siempre será la misma. Las que se encuentran en este grupo son randomSeed y random. Pero cuando trabajes con modelos DUE y ZERO en 32u4 y necesites conectar el ratón y el teclado, las funciones que usarás son Keyboard y Mouse.

Aprende paso a paso cómo programar un Sketch sencillo para tu proyecto Arduino

En esta sección llevaremos a la práctica todo lo que se mostró en los párrafos anteriores, por lo que deberás prestar atención y, si por algún motivo te equivocaste, te recomendamos reiniciar los pasos para no arrastrar el error.

El proceso que deberás hacer en la programación de un proyecto sencillo de Arduino son los siguientes:

Comentarios

Los comentarios son todas las anotaciones que se realizan en el código para introducir el funcionamiento del programa, ser el autor o por qué se utiliza una función en lugar de otra. Existen dos tipos de comentarios, los de multilinea (que se encuentran entre los símbolos /* y */) y los la línea sola (los cuales son representados mediante el uso de //). Debes tener en cuenta que los comentarios no forman parte del programa y por lo tanto es ignorado por el Arduino.

Un ejemplo de esto es:

/*

Internet Paso a Paso

Se toma como ejemplo para Arduino encender un LED por un segundo, luego se apagará y se armará un bucle

Se trabaja con el pin número de 13, ya que es genérico para casi todas las placas

en donde existe un LED.

También se necesita de una resistencia, la cual está incorporada en el Arduino

*/

Variables

Las variables se componen por un tipo, un nombre y un valor. Estas se utilizan para que, cada vez que se escriba el nombre del código, se pueda recuperar el valor de la variable.

Por ejemplo, si dentro del programa que se está creando para encender y apagar un LED conectado al pin 13 de la placa, se tiene que escribir:

int ledPin = 13;

Esto significa que se ha creado el nombre de la variable ledPin para cambiar (si lo desea en el futuro) el valor, el tipo es int y su valor es 13.

Funciones

No debes olvidarte que las funciones son acciones que se introducen para que una variable realiza un procedimiento determinado.

De esta manera se debería ingresar en el software que se está programando:

void setup()

{

pinMode(ledPin, OUTPUT); // para indicar una salida en un pin digital

}

La línea setup() muestra los datos del tipo de función, el tipo de retorno que tendrá el código son void y (), mientras que el cuerpo de la función es { pinMode(ledPin, OUTPUT);      // para indicar una salida en un pin digital }. Dentro de ese cuerpo se encuentra pinMode . Esta función indica que los parámetros ledPin y OUTPUT deben pasar por un pin digital como salida (es por esto que se aclara en el comentario // para indicar una salida en un pin digital).

pinMode (), digitalWrite () y delay ()

Estas funciones brindan indicaciones específicas al comando, por lo que tendrás que conocer a cada una:

• pinMode(): se usa para establecer si un pin de la placa Arduino trabajará como entrada o salida del circuito. Si es una entrada entonces el conector detectará un sensor, mientras que si es un pin de salida será un actuador (en el ejemplo que estamos desarrollando será el led).
• digitalWrite(): en esta función se puede establecer el valor de un pin. Se relaciona de manera directa con HIGH y LOW, ya que estos indicadores configurarán el tipo de voltaje. Un ejemplo de esto sería colocar la función pinMode en 5V, para ello habrá que ingresar digitalWrite(ledPin, HIGH);. Si se necesita que trabaje en 0 voltios hay que escribir digitalWrite(ledPin, LOW);.
• delay(): esta función es la encargada de retrasar el proceso antes de continuar a la siguiente línea del código. Se expresa en milisegundos, por lo que el valor 1000 representa 1 segundo. Su uso es delay(1000);.

Configuración () y Bucle ()

Ya hemos hablado que setup() es la función encargada de configurar opciones dentro de un código, pero esta herramienta no es la única que se debe usar con frecuencia en la programación de una placa Arduino. También está loop(), la cual permitirá controlar la placa de forma permanente. Con esta función podrás saber si vas por buen camino y las funciones que agregas están trabajando de acuerdo con lo que tú necesitas.

Un ejemplo de cómo se usan setup() y loop() es:

int buttonPin = 3;

// esta configuración sireve para inicializar el serial y el pin

void setup() {

begin(9600);

pinMode(buttonPin, INPUT);

}

// para comprobar el botón se usará este bucle y enviará serial cada vez que se pulse

// el retraso será de 1 segundo

void loop() {

if (digitalRead(buttonPin) == HIGH) {

write('H');

}

else {

write('L');

}

delay(1000);

}

Ejemplos de Sketch de Arduino para que aprendas a programar los tuyos

Lo que verás a continuación te ayudará a practicar tú mismo diferentes proyectos.

Presta atención a los detalles y repítelos una y otra vez para que comprendas todo el proceso:

Sketch blink

Este proyecto te ayudará a hacer parpadear un led integrado en la placa de Arduino, el cual posee la mayoría de los modelos de placa. En la versión UNO, Yún y Zero, el pin usado es el número 13, mientras que en la MKR1000 (por ejemplo) es el digital 6.

El código que utilizarás es:

void setup() {

pinMode(ledPin, OUTPUT);

}

{

digitalWrite(ledPin, HIGH);

delay(1000);

digitalWrite(ledPin, LOW);

delay(1000);

}

Robot que esquiva obstáculos

En este proyecto te mostraremos el flujo de procesos que debes tener en cuenta a la hora de programar, de manera correcta, un dispositivo que esquive obstáculos. El diagrama que te mostramos en la siguiente figura te ayudará a comprender mejor el proceso.

Mientras que el código del proyecto será algo parecido a esto:

#include <AFMotor.h>

#include <NewPing.h>

#include <Servo.h>

#define TRIG_PIN A4

#define ECHO_PIN A5

#define MAX_DISTANCE 200

#define MAX_SPEED 190

#define MAX_SPEED_OFFSET 20

NewPing sonar(TRIG_PIN, ECHO_PIN, MAX_DISTANCE);

AF_DCMotor motor1(1, MOTOR12_1KHZ);

AF_DCMotor motor2(3, MOTOR12_1KHZ);

Servo myservo;

boolean goesForward=false;

int distance = 100;

int speedSet = 0;

void setup() {

attach(9);

write(115);

delay(2000);

distance = readPing();

delay(100);

distance = readPing();

delay(100);

distance = readPing();

delay(100);

distance = readPing();

delay(100);

}

void loop() {

int distanceR = 0;

int distanceL = 0;

delay(40);

if(distance<=15)

{

moveStop();

delay(100);

moveBackward();

delay(300);

moveStop();

delay(200);

distanceR = lookRight();

delay(200);

distanceL = lookLeft();

delay(200);

if(distanceR>=distanceL)

{

turnRight();

moveStop();

}else

{

turnLeft();

moveStop();

}

}else

{

moveForward();

}

distance = readPing();

}

int lookRight()

{

write(50);

delay(500);

int distance = readPing();

delay(100);

write(115);

return distance;

}

int lookLeft()

{

write(170);

delay(500);

int distance = readPing();

delay(100);

write(115);

return distance;

delay(100);

}

int readPing() {

delay(70);

int cm = sonar.ping_cm();

if(cm==0)

{

cm = 250;

}

return cm;

}

oid moveStop() {

run(RELEASE);

run(RELEASE);

}

void moveForward() {

if(!goesForward)

{

goesForward=true;

run(FORWARD);

run(FORWARD);

for (speedSet = 0; speedSet < MAX_SPEED; speedSet +=2)

{

setSpeed(speedSet);

setSpeed(speedSet+MAX_SPEED_OFFSET);

delay(5);

}

}

}

void moveBackward() {

goesForward=false;

run(BACKWARD);

run(BACKWARD);

for (speedSet = 0; speedSet < MAX_SPEED; speedSet +=2)

{

setSpeed(speedSet);

setSpeed(speedSet+MAX_SPEED_OFFSET);

delay(5);

}

}

void turnRight() {

run(FORWARD);

run(BACKWARD);

delay(300);

run(FORWARD);

run(FORWARD);

}

void turnLeft() {

run(BACKWARD);

run(FORWARD);

delay(300);

run(FORWARD);

run(FORWARD);

}

Sistema de control de acceso mediante lectura de tarjetas RFID

Primero es importante definir que es una tarjeta RFID es un dispositivo que trabaja con radiofrecuencia y se utiliza para enviar información que sirva para identificar o transmitir un dato específico de un objeto. Debido a ello se puede utilizar de manera práctica una placa de Arduino para crear un lector que permita controlar el acceso de las personas.

Luego de haber practicado los dos proyectos anteriores, estarás en condiciones de programar este Sketch un poco más complejo. Debido a esto te mostraremos primero el diagrama de flujo de las operaciones para que puedas llevar adelante tu tarea sin errores. Lo que deberás hacer ahora es escribir estos códigos, los cuales no son definitivos, que te ayudarán a comparar lo que tú ingresaste en el entorno IDE de Arduino.

Para esto tendrás que escribir:

#include <SPI.h>

#include <MFRC522.h>

#define RST_PIN 9

#define SS_PIN 10

MFRC522 mfrc522(SS_PIN, RST_PIN);

void setup() {

begin(9600);

while (!Serial);

begin();

PCD_Init();

delay(4);

PCD_DumpVersionToSerial();

println(F("Scan PICC to see UID, SAK, type, and data blocks..."));

}

void loop() {

if ( ! mfrc522.PICC_IsNewCardPresent()) {

return;

}

if ( ! mfrc522.PICC_ReadCardSerial()) {

return;

}

PICC_DumpToSerial(&(mfrc522.uid));

}

Lo que tendrás que hacer ahora es cambiar la clave de un sector usando Key-A: A0 A1 A2 A3 A4 y Key-B: B0 B1 B2 B3 B4.

Deberás escribir:

#include <SPI.h>

#include <MFRC522.h>

#define RST_PIN 9

#define SS_PIN 10

MFRC522 mfrc522(SS_PIN, RST_PIN);

MFRC522::MIFARE_Key keyA = {keyByte: {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}};

MFRC522::MIFARE_Key keyB = {keyByte: {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}};

// Nuevas claves para el cifrado

MFRC522::MIFARE_Key nuevaKeyA = {keyByte: {0xA0, 0xA1, 0xA2, 0xA3, 0xA4, 0xA5}};

MFRC522::MIFARE_Key nuevaKeyB = {keyByte: {0xB0, 0xB1, 0xB2, 0xB3, 0xB4, 0xB5}};

// Datos del sector al cual pertenece el usuario aceptado

byte sector = 15;

void mostrarByteArray(byte* buffer, byte bufferSize) {

for (byte i = 0; i < bufferSize; i++) {

print(buffer[i] < 0x10 ? " 0" : " ");

print(buffer[i], HEX);

}

}

void setup() {

begin(9600);

while (!Serial);

begin();

PCD_Init();

println(F("Acerque la tarjeta al lecto."));

println(F("Las claves de esta tarjeta deben ser:"));

print("Key-A: ");

mostrarByteArray(keyA.keyByte, MFRC522::MF_KEY_SIZE);

println();

print("Key-B: ");

mostrarByteArray(keyB.keyByte, MFRC522::MF_KEY_SIZE);

println();

println(F("MUY IMPORTANTE: durante el proceso de actualización de las claves "));

println(F("no separes la tarjeta del lector hasta que no termine."));

}

void loop() {

// Si no hay una tarjeta para usar el programa no avanza

if (!mfrc522.PICC_IsNewCardPresent()) {

return;

}

if (!mfrc522.PICC_ReadCardSerial()) {

return;

}

Después de esto vas a tener que programar para que aparezca la información en el monitor serie:

print(F("UID de la tarjeta:"));

mostrarByteArray(mfrc522.uid.uidByte, mfrc522.uid.size);

println();

print(F("Tipo de tarjeta: "));

MFRC522::PICC_Type piccType = mfrc522.PICC_GetType(mfrc522.uid.sak);

println(mfrc522.PICC_GetTypeName(piccType));

boolean resultado = cambiarKeys(&keyA, &keyB, &nuevaKeyA, &nuevaKeyB, sector);

if (resultado) {

print(F("Claves del sector "));

println(sector);

print(F("Key-A: "));

mostrarByteArray(nuevaKeyA.keyByte, MFRC522::MF_KEY_SIZE);

println();

print(F("Key-B: "));

mostrarByteArray(nuevaKeyB.keyByte, MFRC522::MF_KEY_SIZE);

println();

} else {

print(F("Claves del sector "));

println(sector);

print(F("Key-A: "));

mostrarByteArray(keyA.keyByte, MFRC522::MF_KEY_SIZE);

println();

print(F("Key-B: "));

mostrarByteArray(keyB.keyByte, MFRC522::MF_KEY_SIZE);

println();

}

// Autenticar utilizando la clave Key-A

estado = (MFRC522::StatusCode)mfrc522.PCD_Authenticate(MFRC522::PICC_CMD_MF_AUTH_KEY_A, bloqueTrailer, antiguaKeyA, &(mfrc522.uid));

// Si no consigue autenticar que no continúe

if (estado != MFRC522::STATUS_OK) {

print(F("Fallo en la autenticación Key-A: "));

println(mfrc522.GetStatusCodeName(estado));

return false;

}

// Mostrar el sector completo del usuario

println(F("Informción en el sector:"));

PICC_DumpMifareClassicSectorToSerial(&(mfrc522.uid), antiguaKeyA, sector);

println();

// Leyendo datos del bloque

print(F("Leyendo datos del bloque ")); Serial.print(bloqueTrailer);

println(F(" ..."));

estado = (MFRC522::StatusCode) mfrc522.MIFARE_Read(bloqueTrailer, buffer, &size);

if (estado != MFRC522::STATUS_OK) {

print(F("Fallo al leer el bloque: "));

println(mfrc522.GetStatusCodeName(estado));

return false;

}

print(F("Información en el bloque ")); Serial.print(bloqueTrailer); Serial.println(F(":"));

mostrarByteArray(buffer, 16); Serial.println();

println();

// Autenticar utilizando la clave Key-B

estado = (MFRC522::StatusCode)mfrc522.PCD_Authenticate(MFRC522::PICC_CMD_MF_AUTH_KEY_B, bloqueTrailer, antiguaKeyB, &(mfrc522.uid));

// Si no consigue autenticar que no continúe

if (estado != MFRC522::STATUS_OK) {

print(F("Fallo en la uatenticación Key-B: "));

println(mfrc522.GetStatusCodeName(estado));

return false;

}

if (nuevaKeyA != nullptr || nuevaKeyB != nullptr) {

// Para recoorer todos los bytes que tiene la clave elegida.

for (byte i = 0; i < MFRC522::MF_KEY_SIZE; i++) {

if (nuevaKeyA != nullptr) {

buffer[i] = nuevaKeyA->keyByte[i];

}

if (nuevaKeyB != nullptr) {

buffer[i + 10] = nuevaKeyB->keyByte[i];

}

}

}

return true;

}