Este manual aborda todos los conceptos básicos de Arduino y es una excelente guía para

todo aquel que quiera iniciarse en este apasionante mundo.

El manual ha sido confeccionado por Raúl Diosdado usando para ello la siguiente
información y recursos:
http://www.arduino.cc (Pagina oficial de Arduino)

Fritzing (Elaboración de esquemáticos y montajes) http://fritzing.org

http://www.zonamaker.com (Recursos propios)

Está permitida la impresión, distribución y modificación de este manual siempre que se

reconozca a su autor y las fuentes de las que se extrajo su información.
No está permitida la comercialización o venta de este manual.

Primera edición publicada en Septiembre de 2014

Este manual esta bajo licencia Creative Commons Reconocimiento-NoComercial-CompartirIgual

http://creativecommons.org/licenses/by-nc-sa/4.0/legalcode
 6. Entradas y salidas E/S
6.1 E/S digitales
INDICE
6.1.1 Lectura de entradas digitales (digitalRead)
6.1.2 Escritura de salidas digitales (digitalWrite)
1. Estructura de un programa
6.2 E/S Analógicas
1.1 Funciones
6.2.1 Lectura de entradas analógicas (analogRead)
1.1.1 Setup()
6.2.2 Escritura de salidas analógicas (analogWrite)
1.1.2 Loop()

1.2 Llaves {} 7. Puerto serie

1.3 Punto y coma ; 7.1 Inicialización de la comunicación serie (Serial.begin)
1.4 Bloque de comentario /*...*/ 7.2 Escritura del puerto serie (Serial.print)
1.5 Línea de comentario // 7.3 Lectura del puerto serie (Serial.read)

2. Variables 8. Otras instrucciones de interés

2.1 Utilización de las variables 8.1 Delay (ms)
2.2 Tipos de variables 8.2 DelayMicroseconds (µs)
8.3 Millis ()
3. Constantes
8.4 Min(x,y)
4. Operadores 8.5 Max(x,y)
4.1 Operadores aritméticos
4.2 Asignaciones compuestas
ANEXO
4.3 Operadores de comparación
Conexionado de entradas y salidas en Arduino
4.4 Operadores boleanos
Instalación de Arduino y entorno de programación
5. Estructuras de control
5.1 Condicionales
5.1.1 If (si...)
5.1.2 If...else (si... si no...)

5.2 Bucles
5.2.1 For
5.2.2 While
5.2.3 Do... while

5.3 Elementos de control de flujo

5.3.1 Goto
5.3.2 Return
5.3.3 Break
 Manual de Arduino Manual de Arduino
Programación y conceptos básicos Programación y conceptos básicos

int j =3;
1. Estructura de un programa int k;

La estructura de un programa en Arduino puede llegar a ser muy diferente en función k = multiplicación(i, j); //llama a la función multiplicación pasándole los
de la complejidad de la aplicación que queramos crear, pero como en la mayoría de //parámetros "i" y "j"
}
lenguajes de programación esta estructura está formada por funciones, sentencias,
bucles y otros elementos que conforman la estructura de programa. En Arduino los programas pueden estar compuestos por infinidad de funciones,
pero existe una estructura básica que deben de cumplir todos los programas.
1.1 Funciones
Esta estructura básica, está formada por dos funciones totalmente
Una función es un bloque de código con un nombre y un conjunto de estamentos que necesarias para la ejecución del programa, la función setup() y loop().
son ejecutados cuando se llama a dicha función. Las funciones de usuario se crean para
realizar tareas repetitivas reduciendo de esa manera el tamaño del programa. 1.1.1 Setup ()
La función setup() se invoca una sola vez al comienzo del programa. Esta función
Las funciones están asociadas a un tipo de valor "type", este es el valor que devolverá
se usa para realizar la configuración inicial, dentro de esta configuración
la función una vez termine su ejecución.
podemos establecer el modo de trabajo de los pines o inicializar la comunicación
type nombreFunción (parámetros) serie entre otras cosas.
{
Estamentos o instrucciones; void setup()
} {
Estamentos o instrucciones;
}
Si la función no devuelve ningún valor, se le asignará el tipo "void" o función vacía.
No es obligatorio pasarles parámetros a la función, se pueden crear funciones
1.1.2 Loop ()
independientes que obtengan sus propios parámetros para trabajar.
La función loop() es la función principal dentro del programa. Esta función se va a
Ejemplo de función: ejecutar continuamente de manera cíclica, ejecutando todas las instrucciones
/* Define la función "multiplicar" a la que se le pasarán los 2 números que que se encuentren en su interior.
se deseen multiplicar devolviendo un valor entero (int). */
void loop()
{
int multiplicar (int x, int y) //función multiplicar
Estamentos o instrucciones;
{
}
int resultado; //declara la variable donde se almacena el resultado
resultado = x * y; //ejecuta la operación de multiplicar
return resultado; //devuelve el resultado de la multiplicación
}
Además de las funciones principales, existen otros elementos de la estructura de
programa que ayudan a definir, delimitar, estructurar y a hacer más claro el
Para hacer uso de la función anterior, tan solo habrá que llamarla desde contenido del programa.
cualquier parte del programa. Esta llamada a la función se realiza de la siguiente
manera: 1.2 Llaves {}
Las llaves definen el principio y el final de un bloque de instrucciones. Se usan para
void loop()
{ delimitar el inicio y fin de funciones como setup()o para delimitar el alcance de los
int i =2; bucles y condicionales del programa.

1 2
 Manual de Arduino Manual de Arduino
Programación y conceptos básicos Programación y conceptos básicos

funcion() 2. Variables
{
Estamentos o instrucciones; Las variables son elementos donde se almacenan valores numéricos que serán usados
}
por el programa. Como su nombre indica, las variables van a cambiar de valor con la
evolución del programa y nos van a permitir crear la lógica del programa en función de
1.3 Punto y coma ; estos cambios.

El punto y coma ";" se utiliza para definir el final de una instrucción y separarla de int variable_entrada = 0; //declara una variable y le asigna el valor 0
la siguiente. Si no colocamos punto y coma, el programa va a interpretar mal las variable_entrada = analogRead(2); //la variable toma el valor de la entrada analógica 2
instrucciones y se va a producir un error de compilación.
Una variable debe ser declarada y opcionalmente asignarle un valor antes de ser usada
digitalWrite (10, HIGH); por el programa, si no hemos declarado la variable o lo hemos hecho con posterioridad
a su uso va a dar un error al compilar el programa.
El error más común a la hora de programar suele ser olvidar poner punto y coma
Es recomendable asignarle un valor inicial a las variables para no tener un valor
al final de la instrucción.
indeterminado que pudiera ocasionar algún error a la hora de la ejecución del
1.4 Bloque de comentarios /*...*/ programa.

Los bloques de comentarios son áreas de texto que nos ayudan a describir o Cuando se asignen nombres a las variables, se deben de usar nombres que
comentar un programa, estos bloques serán ignorados a la hora de compilar el identifiquen claramente a dichas variables, para ello se usan nombres como
programa en nuestro Arduino. "pulsador", "led", "entrada_1".... esto va a ayudar a hacer un código legible y fácil de
entender.
/*El bloque de comentario ayuda
al programador a describir el programa
*/
2.1 Utilización de las variables
Las variables pueden ser declaradas en diferentes lugares del programa, en
Se pueden introducir todas las líneas de texto que se deseen siempre que se función del lugar donde sean declaradas, las variables van a ser de tipo global o
encuentren entre los caracteres /*...*/. local, determinando esto el ámbito de aplicación o la capacidad de ciertas partes
Se recomienda el uso de bloques de comentarios siempre que se pueda, ya que del programa para hacer uso de las mismas.
ayudan a la comprensión del programa a personas ajenas al mismo, además, estos
Una variable global es aquella que puede ser vista y utilizada por cualquier función
comentarios no van a ocupar espacio de programa, ya que son ignorados a la hora
yestamento de un programa. Las variables globales se declaran al comienzo del
de compilar.
programa, antes de la función setup().
1.5 Línea de comentarios //
Una variable local es aquella que se define dentro de una función o como parte de
La línea de comentarios tienen la misma función que los bloques de comentarios, un bucle. Solo será visible y podrá utilizarse dentro de la función o bucle donde es
la única diferencia es que las líneas de comentarios suelen usarse para comentar declarada.
instrucciones ya que solo afectan a una línea.
La existencia de variables globales y locales, permite el uso de variables con el
mismo nombre en partes diferentes del programa, estas variables podrán
int x = 10; //declara la variable 'x' como tipo entero de valor 13 almacenar valores distintos sin que se produzca ningún conflicto, ya que a las
variables locales solo tendrán acceso las funciones donde se declaren dichas
variables.

3 4
 Manual de Arduino Manual de Arduino
Programación y conceptos básicos Programación y conceptos básicos

Ejemplo de variables globales y locales: Si queremos definir una constante, podemos hacerlo de manera muy similar a como
definíamos las variables, tan solo hay que indicar al programa que se trata de un valor
int led = 10; //"led" es una variable global visible para cualquier función
void setup()
"no modificable", para ello hay que añadir antes del "tipo" la palabra "const", que va a
{ hacer que la variable sea de solo lectura.
pinMode (led, OUTPUT); //establece el pin "led" como salida
} const float pi = 3.1415; //crea una constante de tipo "float" y le asigna el valor 3.1415
void loop ()
{
float valor; //"valor" es una variable local solo visible dentro de "loop" Es posible crear constantes usando #define, esta sentencia va a nombrar las constantes
for (int i=0; i<20; i++) //"i" es una variable local usada por el bucle for antes de ser compiladas por Arduino. Las constantes creadas de esta manera no van a
{
ocupar memoria de programa, ya que el compilador va a remplazar estas constantes
digitalWrite (led, HIGH); //uso de la variable global "led"
} con el valor definido en el momento de compilar.
}
#define pi 3.1415 //crea una constante usando #define a la que le asigna el valor 3.1415
2.2 Tipos de variables Hay que tener cuidado a la hora de usar #define, ya que la sintaxis es diferente, no hay
A la hora de usar una variable dentro del programa debemos de pararnos a pensar que poner el operador de asignación "=" ni cerrar sentencia con el punto y coma ";".
que información o qué tipo de operaciones vamos a aplicar a estas variables y en
Usar #define puede ser problemático, ya que si existe en cualquier parte del programa
función de esto asignarle un tipo u otro. Debemos de asegurarnos que el tipo de
alguna constante o variable con el mismo nombre que tengamos asignado en #define,
variable que estemos usando tiene rango suficiente para almacenar los datos sin
el programa lo va a sustituir con el valor que tengamos asignado a esta constante, por
llegar a ser desproporcionada, ya que usar variables grandes va a consumir más
ello se debe tener cuidado a la hora de asignar constantes con #define y no crear
recursos de memoria.
constantes muy genéricas como #define x 10,ya que "x" es muy común usarlo como
variable dentro de alguna función o bucle.
Tipo de variables Memoria que ocupa Rango de valores
boolean 8 bit's 0 o 1 (true o false) 4. Operadores
char* 8 bit's -128 a 127
int 16 bit's -32.768 a 32.767 Los operadores son los elementos con los que vamos transformar las variables del
unsigned int 16 bit's 0 a 65.535 programa, hacer comparaciones, contar un número determinado de eventos… .Los
long 32 bit's -2.146.483.648 a 2.147483.647 operadores se pueden considerar como uno de los elementos más importantes junto
unsigned long 32 bit's 0 a 4.294.967.295 con las estructuras de control. Dentro de los operadores, podemos encontrarlos de
float* 32 bit's -3'4028235 E+38 a 3'4028235 E+38 varios tipos.
*char: el tipo "char" se utiliza para almacenar caracteres en formato ASCII
*float: el tipo "float" se utiliza para datos con decimales, aunque cuenta con 32bit's, tan 4.1 Operadores aritméticos
solo tiene una precisión de 7 dígitos en sus decimales. Los operadores aritméticos son operadores que nos van a permitir realizar
operaciones básicas como sumar, restar, dividir, multiplicar...

3. Constantes
x = x + 5; //suma x+5 y guarda el valor en x
La diferencia fundamental entre una variable y una constante es que la constante va a 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
ser un valor de solo lectura que no va a poder ser modificado con la evolución del
k = k / 3; //divide k entre 3 y guarda el valor en k
programa. p = 10; // asigna a p el valor 10

5 6
 Manual de Arduino Manual de Arduino
Programación y conceptos básicos Programación y conceptos básicos

Hay que tener en cuenta el tipo de variable que estamos usando a la hora de 5. Estructuras de control
realizar operaciones, ya que si vamos a efectuar una operación que da como
resultado un numero con decimales y hemos definido estas variables como int Dentro de las estructuras de control se engloban todos los estamentos que sirven para
(entero), el resultado no va a mostrar la parte decimal (10 / 3 va a devolver 3 en guiar al programa en una u en otra dirección en función de si se cumplen o no las
lugar de 3.33). condiciones que le marquemos al programa. Dentro de estas estructuras podemos
encontrar condicionales, bucles o elementos de control de flujo.
4.2 Asignaciones compuestas
Las asignaciones compuestas combinan una operación aritmética con una variable 5.1 Condicionales
asignada. Estas asignaciones son usadas comúnmente en bucles. Los condicionales son elementos que chequean un estado o condición y si esta
condición se cumple se pasa a ejecutar las sentencias englobadas dentro de la
x ++; //equivale a x = x + 1 (incrementa x en 1)
condición.
x --; //equivale a x = x - 1 (decrementa x en 1)
x += y; //equivale a x = x + y
5.1.1 If (si...)
x -= y; //equivale a x = x - y
x *= y; //equivale a x = x * y If es un estamento que se utiliza para comprobar si una determinada
x /= y; //equivale a x = x / y
condición se cumple. Si la condición se cumple, se pasará a ejecutar las
sentencias encerradas dentro del bloque if, si no se cumple la condición, el
4.3 Operadores de comparación
programa saltará este bloque sin ejecutar ninguna instrucción.
Los operadores de comparación se usan con frecuencia en estructuras
condicionales para comprobar si una condición se cumple o no. Normalmente if (x==10) //Si x es igual a 10 ejecuta la instrucción
estos condicionales realizan la comparación entre las variables y constantes del {
programa. ejecuta instrucciones;
}
x == y; //x es igual a y
x != y; //x es distinto de y
5.1.2 If... else (si... si no...)
x < y; //x es menor que y
x > y; //x es mayor que y If... elsefunciona de igual forma que if, pero añade la posibilidad de que la
x <= y; //x es menor o igual que y
condición no se cumpla,pasando a ejecutar las instrucciones encerradas
x >=y; // x es mayor o igual que y
dentro de else.
4.4 Operadores Boleanos if (y != 10) // Si "y" es distinto de 10 ejecuta las instrucciones
{
Son operadores lógicos que se usan para comparar 2 o más expresiones y que no
ejecuta instrucciones;
devuelven un valor, sino que dan un estado de “verdadero” (si se cumple la }
expresión) o “falso” (si no se cumple). Existen 3 operadores lógicos, AND "&&", OR else //si no, ejecuta esta instrucción
"||" y NOT "!". {
ejecuta instrucciones;
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 Este condicional puede ir precedido de otras estructuras condicionales del
mismo tipo, anidando unas dentro de otras y haciendo que sean
mutuamente excluyentes.

7 8
 Manual de Arduino Manual de Arduino
Programación y conceptos básicos Programación y conceptos básicos

if (valor < 100) // Si valor es menor que 100 ejecuta la instrucción usar variables que cambien dentro del propio bucle o que tomen el valor de
{ alguna de las entradas de Arduino que podemos tener asociadas a sensores
ejecuta instrucciones;
}
u otros elementos.
else if (valor >=500) // Si valor es mayor o igual que 500 ejecuta la instrucción
while (sensor < 150) //ejecuta el bucle mientras "sensor" sea menor a 150
{
{
ejecuta instrucciones;
ejecuta instrucciones;
}
}
else //si no se cumplen las condiciones anteriores, ejecuta esta instrucción
{
ejecuta instrucciones;
}
5.2.3 Do... while
El bucle do... while funciona de la misma manera que while, con la única
5.2 Bucles diferencia de que va a ejecutar al menos 1 vez el bucle, ya que la condición
Los bucles son elementos que hacen que el programa entre en un ciclo de del mismo se comprueba al final.
repetición mientras se cumplan las condiciones del bucle.
do
{
5.2.1 For sensor = analogRead (1); //asigna a "sensor" el valor de la entrada analógica 1
El bucle for se usa para repetir un bloque de sentencias un número }while (sensor < 150) //repite el bucle mientras "sensor" sea menor que 150
determinado de veces. Cada vez que se terminan de ejecutar las sentencias
encerradas dentro del bucle, se comprobará la condición inicial, repitiéndose
el buche mientras se cumpla dicha condición. 5.3 Elementos de control de flujo
El lenguaje de programación de Arduino, como muchos lenguajes de
for (inicialización; condición; expresión)
programación, ha heredado características de los primeros lenguajes de
{
ejecuta instrucciones; programación BASIC, estas características incluyen sentencias para el control del
} flujo como Goto, Return y Break. Estas sentencias no son muy apreciadas a la hora
de programar, ya que en muchas ocasiones rompen el flujo de programa y
El buche for está formado por 3 partes, la inicialización, la condición del dificultan la comprensión del mismo. Además en lenguajes de programación de
bucle y una expresión (la expresión no es necesaria o puede ponerse dentro
alto nivel como el que usa Arduino se pueden usar funciones y otros elementos
de las sentencias del bucle).
alternativos para realizar las mismas tareas, aunque conviene conocer la
Ejemplo de bucle for: existencia de estas funciones ya que pueden ser de utilidad en algunasocasiones.
for (int x=0; x<10; x++) //declara la variable x y la inicializa a 0, comprueba la 5.3.1 Goto
//condición (x<10), incrementa x en 1
{ Esta sentencia realiza un salto a cualquier parte del programa que este
digitalWrite (13, HIGH); //envía un 1 al pin 13 marcada con la etiqueta correspondiente, la posición desde la que
delay (500); //espera 500ms
realicemos el salto quedará almacenada en la pila del programa para que
digitalWrite (13, LOW); //envía un 0 al pin 13
delay (500); //espera 500ms podamos regresar al lugar desde donde realicemos el salto.
}
if (x == 110)
5.2.2 While {
goto marca1; //salta a la etiqueta "marca1"
El bucle while es un bucle que se repetirá constantemente mientras se }
cumpla la expresión del bucle. Dentro de la expresión del bucle se pueden

9 10
 Manual de Arduino Manual de Arduino
Programación y conceptos básicos Programación y conceptos básicos

marca1: //etiqueta a la que se saltará (puede estar en cualquier parte)

Los saltos que podemos realizar con Arduino están limitados a la pila de
programa, no pueden ser infinitos, por lo que no es recomendable anidar
bucles y saltos, ya que podemos romper el flujo de programa

5.3.2 Return
Esta sentencia se usa para volver de un salto goto. En el momento que es
leída por el programa, se cargará la ultima dirección almacenada en la pila
de programa, esto hará que se regrese a la posición desde la que se realizó el
último salto.

5.3.3 Break
La sentencia break es una sentencia que se debe de evitar a toda costa, tan
solo debemos usarla cuando sea totalmente necesario. Esta sentencia
rompe la iteración del bucle donde se encuentre, haciendo salir al programa
del bucle sin tener en cuenta que se cumplan las condiciones para salir del
Antes de empezar a trabajar con Arduino, deben de ser configurados los pines de la
mismo.
placa que vayan a ser usados, asignándolos como entradas o como salidas. En ningún
for (x = 0; x < 255; x ++) caso un mismo pin podrá hacer de entrada y de salida al mismo tiempo.
{
while (sensor < 100) La configuración de los pines se hará dentro de la función setup(), estableciendo el
{ modo de trabajo del pin como entrada o como salida.
x = 0;
break; //Rompe el bucle while saliendo al bucle for La instrucción que se utiliza para realizar la configuración de los pines es pinMode,
} donde habrá que asignarle el pin que queremos configurar y si queremos que actúe
}
como entrada (INPUT) o como salida (OUTPUT).

void setup()
6. Entradas y salidas E/S {
pinMode (10, OUTPUT);//configura el pin 10 como salida
Arduino es una plataforma de desarrollo Hardware que cuenta con pines E/S para }
comunicarse con el exterior. Estos pines E/S tienen características especiales que los
hacen propicios para una u otra tarea en función del tipo de pin. Estas E/S pueden
Los pines de Arduino están configurados por defecto como entradas, por lo que no es
englobarse en 3 tipos básicos, E/S analógicas, E/S digitales y E/S para la comunicación
necesario indicarles el modo de trabajo si vamos a trabajar con ellos como entradas.
serie. Existen también pines de propósito especiales como salidas de reloj u
osciladores y pines de alimentación con los que podemos suministrar diferentes La razón de tener los pines configurados por defecto como entradas, es que las
tensiones a placas externas entradas se encuentran en un estado de alta impedancia, lo que va a evitar en muchos
casos que dañemos la placa al realizar una mala conexión. Si establecemos un pin
como salida y por error entra corriente por dicho pin lo más seguro es que dañemos el
microcontrolador de manera irreversible.

11 12
 Manual de Arduino Manual de Arduino
Programación y conceptos básicos Programación y conceptos básicos

Los pines que tengamos configurados como salida (OUTPUT) van a suministrar una void loop()
corriente máxima de 40mA por separado, sin que la corriente total de las salidas pueda {
valor = digitalRead (pulsador); //lee el estado del pulsador y lo asigna a valor
superar los 200mA. Esta corriente es suficiente para hacer brillar un led, pero digitalWrite (led, valor); //asigna a led el estado de la variable valor
insuficiente para activar elementos de mayor potencia. }

6.1 E/S Digitales

6.2 E/S Analógicas
Los pines asignados a E/S digitales, son pines que trabajan con dos estados HIGH
(alto) o LOW (BAJO). Según el modelo de Arduino que estemos usando, va a tomar Vivimos en un mundo analógico, y en muchas ocasiones, para poder interactuar
el estado HIGH (alto) como 5v o como 3.3v, el estado LOW (bajo) está asociado a con el entono no nos es suficiente con detectar o no una señal o poder activar o
un nivel de voltaje 0. desactivar cosas, sino que necesitamos cuantificar el valor de magnitudes reales y
responder en proporción.
6.1.1 Lectura de entradas digitales (digitalRead)
Para poder leer y escribir valores analógicos, Arduino cuenta con una serie de E/S
Al hacer una lectura digital, vamos a leer el valor de un pin almacenando el
destinadas a este fin, con las que podremos leer y escribir niveles de tensión que
resultado como HIGH (alto o 1) o como LOW (bajo o 0).
irán de 0 a 5 o 3.3v (dependiendo del modelo de Arduino que estemos usando).
valor = digitalRead (pin); //la variable "valor" toma el estado asociado al pin
6.2.1 Lectura de entradas analógicas (analogRead)
La función analogRead realizará una lectura del pin analógico que se le
Podemos especificar el pin asignándole directamente la numeración del pin
indique, almacenando el valor leído en un registro de 10bit's. Almacenar
digital que queremos leer o con una variable o constante previamente
este valor en un registro de 10 bit's va a implicar que tengamos un rango de
definida.
valores que va de 0 a 1023, asignándole el 0 a un nivel de 0 voltios y el 1024
6.1.2 Escritura de salidas digitales (digitalWrite) a un nivel de 5 voltios, lo que va a determinar la resolución que podemos
obtener al hacer lecturas analógicas.
Cuando hacemos una escritura digital vamos a mandar al pin definido
previamente como salida el valor HIGH o LOW. El valor HIGH se va a traducir valor = analoRead (pin); //la variable valor toma el nivel del pin analógico
(en función del tipo de Arduino) por una señal de 5 o 3.3 voltios.
Los pines de entrada analógicos no necesitan ser declarados como entrada
digitalWrite (pin, HIGH); //Establece el pin en estado alto (5 o 3.3v) (INPUT), ya que son siempre entradas.

6.2.2 Escritura de salidas analógicas (analogWrite)

Ejemplo E/S digital
Las salidas analógicas están asociadas a los pines PWM (Pulse Width
#define led 13 //asigna a "led" el valor 13
Modultation) o modulación por ancho de pulso, estos pines, son pines
#define pulsador 7 //asigna a "pulsador" el valor 7
boolean valor; digitales, pero con la particularidad de poseer el PWM, y es que realmente
Arduino no entrega a la salida una señal analógica pura, sino que consigue
void setup() un nivel de tensión determinado por medio de la modulación del ancho de
{
pulso.
pinMode (led, OUTPUT); //establece led (pin 13) como salida
pinMode (pulsador, INPUT); //establece pulsador (pin 7) como entrada
}

13 14
 Manual de Arduino Manual de Arduino
Programación y conceptos básicos Programación y conceptos básicos

7. Puerto serie
Arduino cuenta con una serie de pines que tienen la capacidad de comunicarse con
otros dispositivos usando la comunicación serie para ello. Con esta comunicación serie
se puede realizar también una comunicación con el ordenador a través del USB gracias
al chip FDTI que incorpora la placa y que realiza la conversión USB-serie.

La capacidad de comunicarse con otros dispositivos, hace de Arduino una herramienta

muy potente, ya que se pueden crear proyectos muy complejos con multitud de
dispositivos que se comuniquen e interactúen entre sí, pero cuando se empieza a
programar, es mucho más interesante el poder establecer una comunicación entre
nuestro ordenador y Arduino, ya que de esta forma podemos intercambiar
información con la placa, pudiendo ver cómo evolucionan las variables del sistema y de
esta forma poder detectar posibles problemas de programación.

7.1 Inicialización de la comunicación serie (Serial.begin)

Para poder utilizar el puerto serie hay que inicializarlo estableciendo la velocidad
El nivel de tensión que tendremos a la salida del pin, va a ser igual al nivel de de la conexión. Esta inicialización se hace siempre dentro de la función setup() .
tensión promedio proporcional al ancho de los pulsos.
Un valor típico para realizar la conexión es 9600 baudios , aunque se pueden
Como se observa en la imagen superior, variando en ancho del pulso, asignar otros muchos valores.
podemos obtener una señal promedio equivalente. Para la primera señal,
cuyo ancho de pulso es del 10%, nos daría una señal analógica de 0.5v (el void setup()
{
10% de 5V), para la segunda una señal de 2.5v y para la tercera señal Serial.begin (9600); //abre el puerto serie estableciendo la velocidad en 9600
obtendríamos una señal equivalente de 4.5v. } //baudios

Las salidas analógicas trabajan con registros de 8bit's, o lo que es lo mismo,

pueden tomar valores comprendidos entre 0 y 255, correspondiendo el 0 a Según el modelo de Arduino que estemos usando, puede tener 1 o más puertos
un nivel de 0 voltios y el 255 al máximo voltaje (5 o 3.3 voltios dependiendo para la comunicación serie, estos puertos estarán numerados y deberán de abrirse
de la placa que estemos usando). de manera independiente según los que queramos usar.

analogWrite (pin, valor); //saca por el pin el nivel de tensión equivalente a valor En el Arduino MEGA se disponen de 4 puertos para la conexión serie, si se desean
abrir los 4 puertos el programa quedará de la siguiente manera:

Cuando trabajemos con entradas y salidas analógicas hay que tener en void setup()
cuenta que al realizar una lectura analógica el resultado se guarda en una {
variable de 10 bit's, pero la escritura se hace con una variable de 8 bit's, por Serial.begin(9600);
Serial1.begin(9600);
lo que si queremos usar el valor leído para escribir en algún pin, primero Serial2.begin(9600);
deberemos de adaptar la variable de 10 a 8 bit's, si no hacemos esto, el valor Serial3.begin(9600);
que escribamos va a estar fuera de rango y no va a mostrar el nivel de }
tensión correcto.

15 16
 Manual de Arduino Manual de Arduino
Programación y conceptos básicos Programación y conceptos básicos

Debe de tenerse en cuenta que si se inicializa la comunicación serie, los pines Además de mostrar datos en pantalla, también es posible mandar cadenas de
asociados al puerto serie que estemos utilizando no podrán ser usados para otro caracteres, para ello tan solo hay que encerrar el texto que queramos mostrar
propósito. entre comillas.

7.2 Escritura en el puerto serie (Serial.print) Serial.print("Hola mundo"); //muestra en pantalla "hola mundo"

Si queremos que Arduino muestre información a través del puerto serie, debemos Cuando mandamos datos a través del puerto serie y queremos visualizar estos
de usar instrucciones que "impriman" en pantalla dicha información. datos en pantalla, es recomendable introducir espacios y saltos de línea, ya que si
no lo hacemos los datos nos van a aparecer de manera continua y no vamos a
Para imprimir estos datos se usa el comando Serial.print, que mandará a través del
poder diferenciar unos de otros. Para ordenar estos datos, podemos introducir
puerto serie el dato o la cadena de caracteres que le indiquemos. Esta instrucción
tabulaciones o saltos de línea con los siguientes comandos:
tiene algunas variantes, que veremos a continuación.
Serial.print("\t"); //introduce una tabulación entre los datos
Serial.print(dato, tipo de dato) Serial.print("\n"); //introduce un salto de línea

Esta es la instrucción más común a la hora de enviar datos a través del puerto Si queremos crear datos en líneas diferentes, se puede optar por una variante del
serie, tan solo hay que indicar el dato que queremos enviar y el formato en el que Serial.print que introduce automáticamente un salto de línea, haciendo que el
queremos que muestre dicho dato. siguiente dato que se vaya a escribir aparezca en la siguiente línea.

*nota: el tipo de dato es un campo opcional, si no le indicamos ningún tipo, Serial.println(dato, tipo de dato)
mostrará el dato en formato decimal.
Como en el caso anterior, el tipo de dato será un campo opcional, si no se rellena
El "tipo de dato" puede tomar los valores BIN (binario), OCT (octal), DEC (decimal) este campo, el dato aparecerán en formato decimal.
y HEX (hexadecimal). En versiones antiguas de Arduino, también estaba disponible
el sacar los datos en formato "BYTE", pero este formato fue eliminado, si La función Serial.println es equivalente a poner:
queremos sacar un byte en pantalla, podemos utilizar la función Serial.print (dato, tipo de dato);
Serial.write(valor). Serial.print ("\n");

Serial.print(78, BIN); // manda el dato "1001110"

Serial.print(78, OCT); // manda el dato "116" 7.3 Lectura del puerto serie (Serial.read)
Serial.print(78, DEC); // manda el dato "78"
Serial.print(78, HEX); // manda el dato "4E" La instrucción Serial.read es una instrucción que va a leer datos entrantes del
puerto serie. Estos datos deben de ser almacenados en variables para poder
Si estamos trabajando con datos que tienen decimales (float) y queremos trabajar con ellos.
mostrar un número concreto de ellos, podemos hacerlo poniendo en tipo de
dato el número de decimales que queremos mostrar. Por defecto mostrará dos valor = Serial.read(); //almacena el dato del puerto serie en la variable valor
decimales. Serial.print(valor); //"imprime" el dato valor

Serial.println(1.23456, 0); //manda por el puerto serie el valor "1"

Serial.println(1.23456, 1); //manda por el puerto serie el valor "1.2" Si hacemos uso de las instrucciones anteriores, vamos a estar constantemente
Serial.println(1.23456, 2); //manda por el puerto serie el valor "1.23" leyendo el puerto serie, pero quizás no haya nada que leer y el dato que estemos
Serial.println(1.23456, 3); //manda por el puerto serie el valor "1.234"
Serial.println(1.23456, 4); //manda por el puerto serie el valor "1.2346"
almacenando en la variable "valor" sea un dato erróneo. Para evitar estos
problemas y optimizar el programa, existe la instrucción Serial.available().

17 18
 Manual de Arduino Manual de Arduino
Programación y conceptos básicos Programación y conceptos básicos

Esta instrucción se usa para comprobar si hay caracteres disponibles para leer en La instrucción delay () es muy útil cuando ejecutamos tareas que requieren un
el puerto serie. Serial.available va a tomar un valor entero con el número de bytes tiempo mínimo para dicha ejecución, como por ejemplo, para leer memorias
disponibles para leer que están almacenados en el buffer del puerto serie. Si no externas o comunicarnos con algunos dispositivos vamos a necesitar un tiempo
hay ningún dato disponible Serial.avaible va a valer 0, por lo que es muy fácil el mínimo para acceder a la memoria o establecer la comunicación, este tiempo lo
uso de esta función combinada con el condicional if. obtenemos deteniendo el programa los milisegundos suficientes para realizar
dichas acciones.
if (Serial.available() > 0) //si hay algún dato disponible para leer
{
8.2 DelayMicroseconds(µs)
valor = Serial.read(); //almacena el dato del puerto serie en la variable valor
} La instrucción delayMicroseconds() funciona igual que delay(), con la diferencia de
realizar las temporizaciones usando microsegundos (µs) en lugar de milisegundos
Arduino tiene un buffer que puede almacenar como máximo 64 bytes, una vez (ms).
sobrepasada esta capacidad se empezaran a escribir los datos uno encima de otro, Esta instrucción nos va a permitir realizar temporizaciones mucho menores,
perdiendo la información. haciendo que el tiempo que detenemos el flojo de programa sea prácticamente
imperceptible.
8. Otras instrucciones de interés
delayMicroseconds (10); //espera durante 0'00001 segundos
Arduino, como otros lenguajes de programación, cuenta con una serie de instrucciones
básicas que son muy frecuentes a la hora de programar y que en muchas ocasiones
nos ayudan a dar una solución sencilla a los diversos problemas que podamos 8.3 Millis ()
encontrarnos.
La instrucción millis() va a devolver el tiempo en milisegundos trascurridos desde
Aquí voy a mostrar algunas de las instrucciones que Arduino trae por defecto, pero no el inicio del programa hasta el momento actual. Esta instrucción es muy
son las únicas, ya que se pueden cargar librerías muy interesantes (como la librería de interesante, ya que nos permite realizar temporizaciones NO bloqueantes basadas
matemáticas) que añaden funciones con las que podemos realizar tareas complejas de en eventos.
manera muy sencilla.
tiempo = millis(); //la variable "tiempo" toma el valor del tiempo transcurrido

8.1 Delay(ms)
Esta instrucción detiene la ejecución del programa un tiempo determinado. El Millis está asociado a un registro de 32bit's, lo que le da la capacidad de
tiempo habrá que indicarlo entre paréntesis en milisegundos (1 segundo = 1000 temporizar unos 4.294.967.296 milisegundos o lo que es lo mismo 49 días y 17
milisegundos). horas. una vez transcurrido este tiempo el registro se desbordará comenzando la
cuenta de nuevo.
delay (1000); //espera durante 1 segundo (1000ms)
Un ejemplo de temporización con millis():
Hay que tener mucho cuidado cuando se usa esta función, ya que se trata de una
#define led 11
función bloqueante. Esta función va a detener el flujo de programa, haciendo que
#define puls 10
durante este tiempo no se detecten eventos como pueden ser presionar un boolean pulsador;
pulsador o la activación de un sensor, esto puede ocasionar graves problemas en unsigned long tiempo;
la aplicación, por lo que siempre que se pueda hay que evitar usar la instrucción
void setup()
delay().
{
pinMode(led, OUTPUT);

19 20
 Manual de Arduino
Programación y conceptos básicos

pinMode(puls, INPUT);
}

voidloop()
{
pulsador = digitalRead(puls);
if(pulsador == HIGH)
{
tiempo = millis() + 5000;
digitalWrite(led, HIGH);
}

if(tiempo == millis())
{
digitalWrite(led, LOW);
tiempo = 0;
}
}

8.4 Min(x,y)
La instrucción min(x, y) va a comparar dos valores devolviendo el menor de ellos.

dato = min(sensor, 100); //dato toma el valor más pequeño entre "sensor" o 100

En el ejemplo anterior "dato" va a tomar el valor del sensor siempre que este
valga menos de 100, si es mayor tomará el valor 100. Esa instrucción puede usarse
para limitar superiormente el valor de "dato".

8.5 Max (x, y)

La instrucción max(x, y) va a comparar dos valores devolviendo el mayor de ellos.

dato =max(sensor, 100);

Esta instrucción funciona igual que min(x, y), la diferencia es que va a entrega el
mayor de los dos números, esto puede ser utilizado para inferiormente el valor
que tomará la variable "dato".

21