MI PRIMER SKETCH ARDUINO

Ejemplo 4.1: Crea un nuevo sketch con el siguiente contenido.

Conecta la placa Arduino a tu computador y ejecuta el IDE oficial. Selecciona (si no lo está ya) el
tipo de placa adecuado (en el menú Tools->Board) y el puerto USB utilizado (en el menú Tools-
>Serial port).

/*Declaración e inicialización de una variable global llamada “mivariable” */

int mivariable=555;
void setup() {
Serial.begin(9600); }
void loop() { Serial.println(mivariable);
mivariable=mivariable+1;
}

Pulsa en el botón “Verify” y seguidamente en el botón “Upload”. No deberías de observar ningún

error en la consola de mensajes. Abre ahora el “Serial monitor” y verás que allí van apareciendo en
tiempo real muchos números uno tras otro, empezando por el 555 y siguiendo por el 556, 557,
558, 559, etc., aumentando sin parar. ¿Por qué? ¿Qué significa este texto (este código) que hemos
introducido en la memoria del microcontrolador de la placa?

ESTRUCTURA GENERAL DE UN SKETCH

Un programa diseñado para ejecutarse sobre un Arduino (un “sketch”) siempre se compone de
tres secciones: La sección de declaraciones de variables globales: ubicada directamente al
principio del sketch. La sección llamada “void setup()”: delimitada por llaves de apertura y cierre.
La sección llamada “void loop()”: delimitada por llaves de apertura y cierre. La primera sección del
sketch (que no tiene ningún tipo de símbolo delimitador de inicio o de final) está reservada para
escribir, tal como su nombre indica, las diferentes declaraciones de variables que necesitemos. En
un apartado posterior explicaremos ampliamente qué significa todo esto. En el interior de las otras
dos secciones (es decir, dentro de sus llaves) deberemos escribir las instrucciones que deseemos
ejecutar en nuestra placa, teniendo en cuenta lo siguiente: Las instrucciones escritas dentro de la
sección “void setup()” se ejecutan una única vez, en el momento de encender (o resetear) la placa
Arduino. Las instrucciones escritas dentro de la sección “void loop()” se ejecutan justo después de
las de la sección “void setup()” infinitas veces hasta que la placa se apague (o se resetee). Es decir,
el contenido de “void loop()” se ejecuta desde la 1ª instrucción hasta la última, para seguidamente
volver a ejecutarse desde la 1ª instrucción hasta la última, para seguidamente ejecutarse desde la
1ª instrucción hasta la última, y así una y otra vez. Por tanto, las instrucciones escritas en la
sección “void setup()” normalmente sirven para realizar ciertas preconfiguraciones iniciales y las
instrucciones del interior de “void loop()” son, de hecho, el programa en sí que está funcionando
continuamente. En el caso concreto del ejemplo 4.1, vemos que en la zona de declaraciones de
variables globales hay una sola línea (int mivariable=555;) que dentro de “void setup()” se ejecuta
una sola instrucción (Serial.begin(9600);) y que dentro de “void loop()” se realiza la ejecución
continua y repetida (hasta que la alimentación de la placa se interrumpa) de dos instrucciones una
tras otra:
Serial.println(mivariable); y mivariable=mivariable+1;. Sobre el significado y sintaxis de todas estas
líneas hablaremos a continuación. Sobre las mayúsculas, tabulaciones y puntos y comas Conviene
aclarar ya pequeños detalles que deberemos tener en cuenta a la hora de escribir nuestros
sketches para evitarnos muchos dolores de cabeza. Por ejemplo, es necesario saber que el
lenguaje Arduino es “case-sensitive”. Esto quiere decir que es totalmente diferente escribir una
letra en mayúscula que en minúscula. Dicho de otra forma: para el lenguaje Arduino “HolA” y
“hOLa” son dos palabras distintas. Esto tiene una implicación muy importante: no es lo mismo
escribir por ejemplo “Serial.begin(9600);” que “serial.begin(9600);”. En el primer caso la
instrucción estaría correctamente escrita, pero en el segundo, en el momento de compilar el
código el IDE se quejaría porque para él “serial” (con “s” minúscula) no tiene ningún sentido. Así
que hay que vigilar mucho con respetar esta distinción en los códigos que escribamos. Otro
detalle: las tabulaciones de las instrucciones contenidas dentro de las secciones “void setup()” y
“void loop()” del sketch del ejemplo 4.1

COMENTARIOS
La primera línea del sketch del ejemplo 4.1 contiene un comentario (concretamente, son las dos
primeras líneas: desde los símbolos /* hasta los símbolos */). Un “comentario” es un texto escrito
intercalado con el código del sketch que se utiliza para informar sobre cómo funciona ese código a
la persona que en algún momento lo esté leyendo. Es decir, los comentarios son texto de ayuda
para los seres humanos que explica el código asociado y ayudan a entenderlo y recordar su
función. Los comentarios son completamente ignorados y desechados por el compilador, por lo
que no forman parte nunca del código binario que ejecuta el microcontrolador (así que no ocupan
Tendrá un valor por defecto (normalmente sin interés para nosotros) hasta que se le asigne un
valor diferente en algún momento de la ejecución de nuestro sketch. La sintaxis general para
asignar un nuevo valor a una variable (ya sea porque no se ha inicializado, o sobre todo porque se
desea sobrescribir un valor anterior por otro nuevo), es: nombreVariable = nuevoValor;.

VARIABLES
La primera línea del sketch del ejemplo 4.1 consiste en declarar una variable global de tipo “int”
llamada “mivariable”, e inicializarla con el valor de 555. Expliquemos todo esto.
Una variable es un elemento de nuestro sketch que actúa como un pequeño “cajoncito”.
El valor de una variable puede haberse obtenido de diversas maneras: puede haber sido asignado
literalmente (como el del ejemplo 4.1, donde nada más empezar asignamos explícitamente a la
variable llamada “mivariable” el valor 555).

Tendrá un valor por defecto (normalmente sin interés para nosotros) hasta que se le asigne un
valor diferente en algún momento de la ejecución de nuestro sketch. La sintaxis general para
asignar un nuevo valor a una variable (ya sea porque no se ha inicializado, o sobre todo porque se
desea sobrescribir un valor anterior por otro nuevo), es: nombreVariable = nuevoValor;.
Salidas digitales
Ejemplo 6.1:
Veamos un código muy sencillo para ilustrar el uso de las funciones pinMode() y digitalWrite(). La
idea es encender y apagar un LED de forma periódica, simplemente. El circuito montado en la
breadboard sería parecido a este:

En él se puede observar que el terminal positivo del LED está conectado al pin-hembra digital
número 4 de la placa Arduino y su terminal negativo está conectado a una resistencia que hace de
divisor de tensión (un valor de 220 ohmios ya estaría bien), la cual está conectada a su vez a tierra.

Notar que no se ha tenido que hacer uso de los pines-hembra “5V” o “Vin” de la placa Arduino;
esto es un hecho que confunde mucho a los principiantes. Los pines-hembra de alimentación
solamente son necesarios cuando queremos aportar electricidad de forma permanente y estable a
algún componente de nuestro circuito (como un LED, por ejemplo) independientemente del
estado de las salidas digitales.

El esquema correspondiente al circuito anterior será este: Y he aquí finalmente el código: void
setup(){ //Inicializamos el pin digital 4 como salida. //Es donde irá conectado nuestro LED.
pinMode(4,OUTPUT); } void loop(){ digitalWrite(4,HIGH); //Decimos que se encienda el LED
delay(1000); //Esperamos un segundo digitalWrite(4,LOW); //Decimos que se apague el LED
delay(1000); //Esperamos un segundo } El sketch anterior es bastante autoexplicativo: tras
establecer el pin digital número 4 como salida, enviamos gracias a la función digitalWrite() una
señal de valor HIGH (5V) a través de ella. Si no se hiciera nada en nuestro código para evitarlo, esta
señal, una vez activada, continuaría enviándose sin interrupción. Pero como lo que queremos es
hacer parpadear el LED, justo después de enviar la señal de valor HIGH.

¿Por qué intercalamos las funciones delay() en medio de las dos digitalWrite()? Porque si no
estuvieran, el envío de la señal HIGH y el de la señal LOW se harían sumamente seguidos (ya que la
velocidad con la que el microcontrolador pasa de ejecutar una línea del sketch a la siguiente es
tremendamente alta; de hecho, eventos escritos en líneas contiguas dentro de la función “loop()”
los podemos considerar prácticamente simultáneos) y nuestro ojo no podría distinguir ningún
parpadeo. La función delay() sirve para pausar (“congelar”) el sketch un determinado tiempo y así
mantener la señal previamente enviada por los dos digitalWrite() de forma que se pueda apreciar.
Es evidente, pues, que escribir un tiempo menor en delay() hará que el parpadeo sea más rápido, y
un tiempo mayor lo contrario. De hecho, si reducimos el parámetro de delay() hasta
aproximadamente 10 milisegundos, veremos que efectivamente el LED deja de parpadear; esto es
porque el parpadeo es tan rápido que nuestro ojo ya es incapaz de observarlo. Como dato curioso,
si con 10 ms de delay() además movemos nuestro montaje de un lado a otro dentro de una
habitación oscura, veremos que el LED deja un camino de luz. Teniendo lo anterior en cuenta,
podríamos jugar un poco con el código. Por ejemplo, si cambiáramos el tiempo de espera de uno
de los delay() podríamos mantener encendido o apagado el LED más tiempo o menos.
Ejemplo 6.3: Veamos otro ejemplo más de salidas digitales. Como se puede ver en las figuras
siguientes, ahora tenemos 3 LEDs conectados en paralelo. Cada uno de ellos recibirá una señal
digital proveniente de un pin-hembra de la placa Arduino (en nuestro ejemplo, son el 6, 7 y 8
respectivamente, pero podrían ser otros cualesquiera). La tarea del circuito es realizar un
encendido de los LEDs de tal forma que simule el efecto “coche fantástico” (sin estela); es decir,
que se enciendan los LEDS por este orden: 6, 7, 8, 7, 6, 7, 8…

Fijarse que como divisor de tensión hemos utilizado una sola resistencia. Podríamos haber
utilizado una resistencia conectada en serie a cada LED (es decir, tres resistencias en total) para
conseguir el mismo objetivo, pero tal como lo hemos hecho nos ahorramos dos resistencias. El
código del sketch que la placa Arduino ha de ejecutar es este:

byte i=0; //Variable contador para los bucles for int del=100; //Variable que marca el tiempo en los
delay() void setup() { /*Inicializamos los pines digitales 6, 7 y 8 como salida. Hacerlo con un for nos
ahorra muchas líneas de código */ for (i = 6; i<=8 ; i++) { pinMode(i, OUTPUT); } } void loop() {
//Parpadean los LEDs del 6 al 8 for (i = 6; i<=8; i++) { digitalWrite(i, HIGH); delay(del); digitalWrite(i,
LOW); } /*Parpadean los LEDs del 8-1 (7) hasta el 6+1 (7). En este caso particular, no habría hecho
falta ningún bucle porque solo hay un LED entre ambos extremos (el 7) pero se deja como
demostración para posibles ampliaciones */ for (i = 7; i>=7; i--) { digitalWrite(i, HIGH); delay(del);
digitalWrite(i, LOW); } }

Ejemplo 6.4: El siguiente es otro ejemplo de código que realiza lo mismo que el anterior, pero
utilizando un array para almacenar los números de pines donde están conectados los LEDs.
Además, introduce una “estela” al mantener iluminados a la vez un LED y el siguiente e ir
avanzando.

//Este array tiene los nº de pines donde se conectan los LED byte leds[]={6,7,8}; byte i=0;
//Variable contador para los bucles for int del=30; //Variable que marca el tiempo en los delay()
void setup() {

//El bucle recorre los tres elementos del array (0, 1 y 2) for (i=0;i<=2;i++) {
pinMode(leds[i],OUTPUT); } } void loop() { //Parpadean los LEDs, del 6 al 8 //Atención a los límites
del bucle for for (i=0;i0;i--) { digitalWrite (leds[i],HIGH); delay(del); digitalWrite(leds[i-1],HIGH);
delay(del); digitalWrite (leds[i],LOW); delay(del*2); } }

Se deja como ejercicio modificar el sketch anterior para que los tres LEDs se iluminen y se apaguen
a la vez. ¡Es muy fácil! Otro ejercicio interesante con tres LEDs en paralelo (si fueran de color
verde, naranja y rojo sería perfecto) es escribir un sketch que simule el comportamiento de un
semáforo. Es decir, hacer que el LED “verde” se encienda durante un rato, que al cabo de un
tiempo empiece a parpadear el LED “naranja”, para seguidamente apagarse ambos y encenderse
el LED “rojo”. Seguidamente se debería de volver a empezar el mismo proceso otra vez. Incluso
con la ayuda de un pulsador (de cuyo uso hablaremos en el siguiente apartado) se podría obligar a
encender el LED “verde” (y apagar los demás), tal como ocurre en algunos semáforos reales.
Ejemplo 6.15:

Para conseguir cambiar la intensidad lumínica de un LED, primero deberemos montar el circuito.
La conexión del LED no tiene ningún misterio: su terminal positivo ha de ir enchufado a un pin
PWM de nuestra placa Arduino (por ejemplo el nº 9) y su terminal negativo a tierra. Se
recomienda también conectarle en serie un divisor de tensión (de unos 220 ohmios está bien).

A continuación, debemos escribir el sketch, el cual modificará el voltaje PWM ofrecido por la salida
analógica donde esté conectado el LED (recordemos, de 0 –valor mínimo– a 255 –valor máximo–).
int brillo = 0; int incremento = 5; //Puede valer negativo (decremento) void setup(){ pinMode(9,
OUTPUT);

//El LED está conectado al pin 9 (PWM) } void loop() { analogWrite(9, brillo);

/*Cambio el brillo un incremento dado (se verá en el próximo analogWrite)

*/ brillo = brillo + incremento; /*Si se llega a los extremos, se invierte la dirección del incremento
*/ if (brillo == 0 || brillo == 255) { incremento = -incremento; } /*Espero 30 milisegundos con la
señal actual de analogWrite()

para ver mejor el efecto. Si se desea que el (incremento o disminución) del brillo se realice a otra
velocidad, basta con modificar el tiempo de espera */ delay(30); } Otro código que hace
exactamente lo mismo es: int brillo = 0; void setup(){ pinMode(9, OUTPUT); //El LED está
conectado al pin 9 (PWM) } void loop(){ //Incrementa el brillo (de mínimo a máximo) for(brillo = 0 ;
brillo<= 255; brillo=brillo+5) { analogWrite(9, brillo); delay(30); }

//Disminuye el brillo (de máximo a mínimo) for(brillo = 255; brillo>=0; brillo=brillo-5) {

analogWrite(9, brillo); delay(30); } }
Material empleado en cada práctica: