curso-arduino.pdf

I
INTRODU
NTRODUCCIÓN
CCIÓN AL
AL A
ARDUINO
RDUINO
C
CENTRO DE
ENTRO DE I
INVESTIGACIÓN DE
NVESTIGACIÓN DE T
TECNOLOG
ECNOLOGÍAS DE
ÍAS DE LA
LA
I
INFORMACIÓN
NFORMACIÓN (CIDETI)
(CIDETI)
D
DR
R.
. A
ANTONIO
NTONIO N
NAVARRETE
AVARRETE G
GUZMÁN
UZMÁN
anavarrete@ittepic.edu.mx
anavarrete@ittepic.edu.mx
E
ENERO
NERO 2018
2018

Introducción
Introducción
I
INTRODUCCIÓN
NTRODUCCIÓN
Arduino es
Arduino es una plataforma prototipo (open-sour
una plataforma prototipo (open-source)
ce)
basada en hardware y software fácil de usar.
basada en hardware y software fácil de usar.
Consiste en una placa de circuito que se puede
Consiste en una placa de circuito que se puede
programar (microcontrolador) y un software listo para usar
programar (microcontrolador) y un software listo para usar
llamado
llamado Arduino IDE
Arduino IDE (por sus siglas en inglés Entorno de
(por sus siglas en inglés Entorno de
desarrollo integrado), que se utiliza para escribir y cargar
desarrollo integrado), que se utiliza para escribir y cargar
código de la computadora en la placa física.
código de la computadora en la placa física.

Introducción
Introducción
P
PRINCIP
RINCIPALES
ALES CARACTERÍSTICAS
CARACTERÍSTICAS
Las tarjetas Arduino son capaz de leer entradas de
Las tarjetas Arduino son capaz de leer entradas de
señales analógicas y digitales desde diferentes sensores
señales analógicas y digitales desde diferentes sensores
y convertirlo en una salida tal que activa un actuador,
y convertirlo en una salida tal que activa un actuador,
encienda o apague un led, se conecte a la nube o
encienda o apague un led, se conecte a la nube o
cualquier otra acción.
cualquier otra acción.
Se pueden controlar funciones de la tarjeta por envió de
Se pueden controlar funciones de la tarjeta por envió de
instrucc
instrucciones al
iones al microc
microcontrolad
ontrolador
or sobre la
sobre la tarjet
tarjeta
a via
via
Arduino IDE.
Arduino IDE.
La tarjeta Arduino no necesita un programador externo
La tarjeta Arduino no necesita un programador externo
para cargar un nuevo codigo dentro de la tarjeta, solo se
para cargar un nuevo codigo dentro de la tarjeta, solo se
necesita un simple cable USB.
necesita un simple cable USB.

Introducción
Introducción
El Arduino IDE usa una simpliﬁcada versión de C++,
El Arduino IDE usa una simpliﬁcada versión de C++,
haciendo faci
haciendo facill aprender a
aprender a progr
programar
amar
Arduino proporciona una forma estándar que divide las
Arduino proporciona una forma estándar que divide las
funciones del microcontroladoe en un paquete más
funciones del microcontroladoe en un paquete más
accesible
accesible

Introducción
Introducción
T
TIPOS DE TARJETAS
IPOS DE TARJETAS
Existen diferentes tipos de tarjetas disponibles, las cuales
Existen diferentes tipos de tarjetas disponibles, las cuales
poseen diferentes microcontroladores.
poseen diferentes microcontroladores.
Sin embargo, todas las tarjetas son programadas a través
Sin embargo, todas las tarjetas son programadas a través
del Arduino IDE
del Arduino IDE
Las diferencias son el número de entradas y salidas,
Las diferencias son el número de entradas y salidas,
velocidad, voltaje de operación, factor de forma, etc.
velocidad, voltaje de operación, factor de forma, etc.
Algunas tarjetas están diseñadas para ser embebidas y
Algunas tarjetas están diseñadas para ser embebidas y
no
no tener interf
tener interface de
ace de progr
programación (hardwa
amación (hardware), el
re), el cual se
cual se
necesita comprar por separado. Algunas funcionan
necesita comprar por separado. Algunas funcionan
directamente desde 3.7 V y otras necesitan al menos 5 V.
directamente desde 3.7 V y otras necesitan al menos 5 V.

Introducción
Introducción
T
TIPOS DE TARJETAS
IPOS DE TARJETAS

Introducción
ENHANCED FEATURES

Introducción
INTERNET OF THINGS

Introducción
MICROCONTROLADOR ATMEGA 328

Introducción
MICROCONTROLADOR ATMEGA 32U4

Introducción MICROCONTROLADOR ATMEGA 2560
MICROCONTROLADOR AT91SAM3X8E

Introducción
DESCRIPCIÓN DE LA TARJETA ARDUINO
1. Esta entrada se utiliza como alimentación o para cargar el
programa a la tarjeta.
2. Puede ser alimentado directamente usando un eliminador
de baterías.
3. Incluye un regulador de voltaje de entrada para estabilizar
los voltajes usados por el procesador u otros elementos.
4. El cristal oscilador proporcionar una señal de reloj estable
que ayuda al Arduino a lidiar con los problemas de tiempo a
una frecuencia por lo regular de 16 MHz.

Introducción
5. Reset externo.
6. Fuente de voltaje de salida de 3.3 V.
7. Fuente de voltaje de salida de 5 V.
8. Pines de tierra (GND).
9. Este pin puede ser usado para alimentar la tarjeta Arduino
desde uns fuente externa.
10. La tarjeta Arduino incluye 6 entradas analógicas de A0 hasta
A5, Estos pines pueden leer la señal desde un sensor
analógico y convertir estas señales a digitales las cuales
pueden ser leídas por el microprocesador.

Introducción
11. Cada tarjeta Arduino tiene su propio microcontrolador principal,el cual es el
cerebro de la tarjeta y cambia ligeremente dependiendo del Arduino que se
este utilizando, usualmente son de la compañía ATMEL.
12. Pines ICSP (In Circuit Serial Programming) tiene acceso a la memoria de
programa del AVR (Flash), ésto es, que puede grabar directamente desde el
PC al microcontrolador cualquier programa sin usar el puerto USB. Uno de
ellos, el mismo Bootloader de Arduino.
13. Led indicador de encendido .
14. Leds TX y RX, parpadean cuando (TX) transmiten información de la tarjeta al
PC, o cuando (RX) reciben instrucciones del PC a la controladora. Les
veremos por ejemplo parpadear cuando se cargue el programa del PC en el
controlador y cuando enviemos datos sincronos en un sentido o en otro
durante el procesamiento del programa. Los leds parpadean para indicar
actividad en el puerto serie a través de la USART.

Introducción
15. La tarjeta Arduino tiene 14 pines de entradas/salidas
digitales de las cuales 6 son de salida PWM (∼). El pin
13 tiene asociado un Led de prueba.
16. El pin AREF nos nos permite utilizar un voltaje de
referencia externo (entre 0 y 5 volts).
17. Botón de reset.

Introducción
INSTALACIÓN
Las tarjetas Arduino uno, Mega 2560, necesitan para su
conexión con la PC un cable estandar USB.
En el caso de los Arduino Nano, se necesita un cable mini usb.
Y en el caso del Arduino Leonardo, su programación es usando
un cable micro usb

Introducción
INSTALACIÓN
1. Descargar el Arduino IDE de la pagina oﬁcial de
Arduino, seleccionando el sistema operativo
(Windows, IOS o Linux).
http://arduino.cc/en/Main/Software
2. El encendido de la tarjeta es automáticamente al
conectar el USB a la PC. (Si no se va a realizar algún
cambio en la programación se puede conectar
directamente a un eliminador de baterías).

Introducción
EJECUTANDO EL PROGRAMA
Una vez instalado el programa lo ejecutamos y aparecera
la siguiente ventana
y el aspecto del IDE

Introducción
CARGANDO PROGRAMA A LA TARJETA
ARDUINO
Una vez que tenemos todo instalado, necesitamos probar
el funcionamiento de la tarjeta y podemos utilizar dos
opciones:
1. Crear un proyecto nuevo.
2. Abrir un proyecto de ejemplo.

Introducción
EJEMPLO BLINK
El siguiente ejemplo hará que el LED (pin 13)integrado a
la tarjeta Arduino uno, prenda y apaga cada segundo.
(a) Ejemplo 1 (b) Ejemplo 2

Introducción
ARDUINO
Una vez seleccionado el programa seleccionamos la
tarjeta y el puerto en al que esta conectado.
(c) Tarjeta Arduino (d) Puerto

Introducción
ARDUINO
Una vez seleccionada la tarjeta y el puerto, se carga el
programa. Pero antes de cargar el programa
describiremos los símbolos que aparecen en el Arduino
IDE
Veriﬁcar.Es usado para revisar los errores de
compilación.
Subir. Carga el programa a la tarjeta Arduino.
Nuevo. Crea un nuevo sketch.
Abrir. Abre directamente los sketch de ejemplos.
Salvar. Guardar el sketch.
Monitor serie. Es utilizado para recibir datos desde la
tarjeta y enviar datos seriales a la tarjeta.

Introducción
ESTRUCTURA DEL PROGRAMA
La estructura del los programas puede estar dividida en tres
principales partes: Estructura, Valores (Variables y
constantes) y Funciones.
ESTRUCTURA
La estructura del software consiste de dos principales
funciones
setup(). Es la parte encargada de recoger la conﬁguración
loop(). Es la que contiene el programa que se ejecutará
cíclicamente (de ahí el término loop–bucle-).
Ambas funciones son necesarias para que el programa
trabaje.

Introducción
SETUP()
La función setup() debe de contener la declaración de las
variables Es la primera función a ejecutar en el programa,
se ejecuta una sola vez cuando el programa empieza. Se
utiliza para inicializar los modos de trabajo de los pins, o
el puerto serie. Debe ser incluido en un programa aunque
no haya declaración que ejecutar. Así mismo se puede
utilizar para establecer el estado inicial de las salidas de
la placa.

Introducción
LOOP()
La función loop() se ejecuta despues de llamar a setup()
hace precisamente lo que sugiere su nombre, se ejecuta
de forma cíclica, lo que posibilita que el programa esté
respondiendo continuamente ante los eventos que se
produzcan en la placa. contiene el código que se
ejecutara continuamente (lectura de entradas, activación
de salidas, etc) Esta función es el núcleo de todos los
programas de Arduino y la que realiza la mayor parte del
trabajo.

Introducción
EJEMPLO 1: DE LA APLICACIÓN DE
VARIABLES
/* Declaración e inicialización de una variable global
llamada “mivariable”*/
int mivariable=555; //Variable global
void setup(){
Serial.begin(9600); /*Abre el puerto serie y
fija la velocidad en baudios
para el envio de datos en
serie*/
}
void loop(){
Serial.println(mivariable);/*Imprime los datos en
el puerto serie, seguido por un
retorno de carro y salto de
línea*/
}
mivariable=mivariable+1;
}
Pulsamos “Veriﬁcar” y después “Subir”. No hay ningún error en
la consola de mensajes. Abrimos el “Monitor serie” y allí
aparecen en tiempo real los números uno tras otro, empezando
por el 555 y siguiendo por el 556, 557,. . . , aumentando sin
parar.

Introducción
VARIABLES
La sintaxis general de una declaración es siempre una
línea escrita así: tipoVariable nombreVariable;.
En el caso concreto de querer declarar varias variables
del mismo tipo, en vez de escribir una declaración por
separado para cada una de ellas, es posible declararlas
todas en una misma línea, genéricamente así:
tipoVariable nombreVariable1, nombreVariable2;
La sintaxis general de una inicialización es siempre una
línea escrita así:
tipoVariable nombreVariable = valorInicialVariable;

Introducción
TIPOS DE VARIABLES
La siguiente tabla proporciona el tipo de dato que se
pueden utilizar durante la programación de Arduino
void Boolean char Unsigned byte int Unsigned word
char int
long Unsigned short ﬂoat double array String-char String-
long array object

Introducción
void. Es usado solamente en declaración de funciones.
Boolean.Las variables de este tipo solo pueden tener dos
valores: cierto o falso. El valor guardado en una variable
booleana ocupa siempre un byte de memoria.
Char. El valor que puede tener una variable de este tipo
es siempre un solo carácter (una letra, un dígito, un signo
de puntuación...); el valor de esta variable es un byte de
memoria; deberemos tener la precaución de escribir ese
carácter entre comillas simples char
mivariable=’A’;
Unsigned char el valor de esta variable es de un byte de
memoria. Se utiliza para codiﬁcar números de 0 hasta
255.

Introducción byte. Un número entero del 0 al 255 codificado en un 1
byte (8 bits).
int. Un número entero entre 32,767(215 − 1) y
-32,768(−215) codificado en 2-bytes (16 bits).
Unsigned int. Un número natural (entero positivo)
almacenado en 16 bits (2 bytes) y comprendido entre 0 y
65,545
word Lo mismo que unsigned int.
Long. Un entero comprendido entre 2,147,483,647 y
-2,147,483,648 y codificado en 32 bits (equivalente a 4
bytes).
Unsigned Long. Un número natural (entero positivo)
almacenado en 32 bits (4 bytes) y comprendido entre 0 y
4,294,967,295 (232 − 1)

Introducción
short. En todas las placas arduino short almacena 16-bit
(2 bytes) en el rango entre 32,767(215 − 1) y
-32,768(−215).
ﬂoat. Un número real (con decimales) almacenado en 4
bytes (es decir 32 bits) y comprendido entre
3.4028325E+38 y -3.4028325E+38.
double. Es un sinónimo exactamente equivalente del tipo
“ﬂoat”, y por tanto no aporta ningún aumento de precisión
respecto a este necesita 4 bytes de memoria.

Introducción
Introducción
array
array.
.
Este tipo de datos en realidad no existe como tal. Lo que
Este tipo de datos en realidad no existe como tal. Lo que
existen son arrays de variables de tipo “boolean”, arrays
existen son arrays de variables de tipo “boolean”, arrays
de variables de tipo “int”, arrays de variables de tipo
de variables de tipo “int”, arrays de variables de tipo
“float”, etc. En definitiva: arrays de variables de cualquier
“float”, etc. En definitiva: arrays de variables de cualquier
tipo de los mencionados hasta ahora.
tipo de los mencionados hasta ahora.
Un array (también llamado “vector
Un array (también llamado “vector”) es
”) es una colección de
una colección de
variables de un tipo concreto que tienen todas el mismo y
variables de un tipo concreto que tienen todas el mismo y
único nombre, pero que pueden distinguirse entre sí por
único nombre, pero que pueden distinguirse entre sí por
un número a modo de índice.
un número a modo de índice.
Los arrays sirven para ganar claridad y simplicidad en el
Los arrays sirven para ganar claridad y simplicidad en el
código, además de facilitar la programación.
código, además de facilitar la programación.

Introducción
Introducción
E
EJEMPLO
JEMPLO 2
2:
: CAMBIO DE VARIABLES
CAMBIO DE VARIABLES
/
/*
*Cam
Cambio
bio de
de var
variab
iable
le “Ca
“Casti
sting”
ng”*
*/
/
float
floatvariablefloat=3.4;
variablefloat=3.4;
byte
byte variablebyte=126;
variablebyte=126;
void
void setup()
setup(){
{
Serial.begin
Serial.begin(9600);
(9600);
Serial.println
Serial.println(
(byte
byte(variablefloat));
(variablefloat));
Serial.println
Serial.println(
(int
int(variablefloat));
(variablefloat));
Serial.println
Serial.println(
(word
word(variablefloat));
(variablefloat));
Serial.println
Serial.println(
(long
long(variablefloat));
(variablefloat));
Serial.println
Serial.println(
(char
char(variablefloat));
(variablefloat));
Serial.println
Serial.println(
(float
float(variablefloat));
(variablefloat));
}
}
void
void loop()
loop(){
{
//
//No
No s
se
e ej
ejec
ecut
uta
a na
nada
da aq
aquí
uí
}
}

Introducción
Introducción
E
EJEMPLO
JEMPLO 3
3:
: USO DE VARIABLES
USO DE VARIABLES
//
//Pr
Prob
oble
lema
ma de
del
l us
uso
o de
de di
dist
stin
inta
tas
s va
vari
riab
able
les
s
float
float resultado;
resultado;
int
int numerador=5;
numerador=5;
int
int denominador=2;
denominador=2;
void
void setup()
setup() {
{
Serial.begin
Serial.begin(9600);
(9600);
resultado=numerador/denominador;
Serial.println
Serial.println(resultado);
(resultado);
}
}
void
void loop()
loop() {
{
}
}

Introducción
EJEMPLO 3: USO DE VARIABLES
//Problema del uso de distintas variables
float resultado;
int numerador=5;
int denominador=2;
void setup() {
Serial.begin(9600);
}
void loop() {
}
Las variables numerador como denominador son
enteros, y por tanto, el resultado siempre será entero, a
pesar de que lo guardemos en una variable de tipo
“ﬂoat”.

Introducción
EJEMPLO 4 USO DE VARIABLES
int numero=100;
long resultado;
void setup() {
Serial.begin(9600);
resultado=numero*1000;
}
void loop() {
}

Introducción
int numero=100;
long resultado;
void setup() {
Serial.begin(9600);
}
void loop() {
}
Para evitar esto, lo más fácil sería forzar a que alguno de los
elementos presentes en el cálculo sea del mismo tipo que el de la
variable “resultado”, debido a que el numero 1000 es de tipo “int”.

Introducción
int numero=100;
long resultado;
void setup() {
Serial.begin(9600);
}
void loop() {
}
Para evitar esto, lo más fácil sería forzar a que alguno de los
elementos presentes en el cálculo sea del mismo tipo que el de la
variable “resultado”, debido a que el numero 1000 es de tipo “int”.
Dentro del código Arduino si tras su valor literal añadimos la letra
“U”, su tipo por defecto será “word”, si añadimos “L”, su tipo será
“long” y si se añadimos “UL”, su tipo será “unsigned long”. Es decir,
una línea como resultado=numero*1000L; hubiera conseguido
el mismo efecto que la solución anterior.

Introducción
COMUNICACIÓN SERIE CON ARDUINO
El microcontrolador ATmega328P dispone de un
receptor/transmisor serie de tipo TTL-UART que permite
comunicar la placa Arduino con otros dispositivos
(normalmente, nuestra PC), para así poder transferir
datos entre ambos.
El canal físico de comunicación en estos casos suele ser
el cable USB, pero también pueden ser los pines digitales
0 (RX) y 1 (TX) de la placa.

Introducción
Si se usan estos dos pines para comunicar la placa con
un dispositivo externo, tendremos que conectar
concretamente el pin TX de la placa con el pin RX del
dispositivo, el RX de la placa con el TX del dispositivo y
compartir la tierra de la placa con la tierra del dispositivo.
Hay que tener en cuenta que si se utilizan estos dos
pines para la comunicación serie, no podrán ser usados
entonces como entradas/salidas digitales estándar.

Introducción
Introducción
Serial.begin()
Serial.begin()
Abre el canal serie para que pueda empezar la
Abre el canal serie para que pueda empezar la
comunicación por él. Por tanto, su ejecución es
comunicación por él. Por tanto, su ejecución es
impresc
imprescindib
indible
le antes de
antes de realizar cualquiertransm
realizar cualquiertransmisión por
isión por
dicho canal. Por eso normalmente se suele escribir
dicho canal. Por eso normalmente se suele escribir
dentro de la sección “void setup()”.
dentro de la sección “void setup()”.
Además, mediante su único parámetro –de tipo “long” y
Además, mediante su único parámetro –de tipo “long” y
obligatorio–, especiﬁca la velocidad en bits/s a la que se
obligatorio–, especiﬁca la velocidad en bits/s a la que se
producir
producirá
á la transf
la transferencia serie
erencia serie de los
de los datos
datos.
.

Introducción
Introducción
Serial.begin()
Serial.begin()
Lo que sí es importante es que el valor escrito como
Lo que sí es importante es que el valor escrito como
parámetro coincida con el que se especiﬁque en el
parámetro coincida con el que se especiﬁque en el
desplegable que aparece en el “Serial Monitor” del IDE de
desplegable que aparece en el “Serial Monitor” del IDE de
Arduino, o si no la comunicación no estará bien
Arduino, o si no la comunicación no estará bien
sincronizada y se mostrarán símbolos sin sentido. Esta
sincronizada y se mostrarán símbolos sin sentido. Esta
instrucc
instrucción no
ión no tiene valor de
tiene valor de retorno
retorno.
.

Introducción
Introducción
Serial.end()
Serial.end()
No tiene ningún argumento ni devuelve nada, y que se
No tiene ningún argumento ni devuelve nada, y que se
encarga de cerrar el canal serie; de esta manera, la
encarga de cerrar el canal serie; de esta manera, la
comunicación serie se deshabilita y los pines RX y TX
comunicación serie se deshabilita y los pines RX y TX
vuelven a estar disponibles para la entrada/salida
vuelven a estar disponibles para la entrada/salida
general. Para reabrir el canal serie otra vez, se debería
general. Para reabrir el canal serie otra vez, se debería
usar de nuevo Serial.begin().
usar de nuevo Serial.begin().

Introducción
INSTRUCCIONES PARA ENVIAR DATOS DESDE
LA PLACA AL EXTERIOR
Serial.print()
Envía a través del canal serie un dato (especiﬁcado como
parámetro) desde el microcontrolador hacia el exterior.
Ese dato puede ser de cualquier tipo: carácter, cadena,
número entero, número decimal (por defecto de dos
decimales), etc. Si el dato se especiﬁca explícitamente
(en vez de a través de una variable), hay que recordar
que los caracteres se han de escribir entre comillas
simples y las cadenas entre comillas dobles.

Introducción
Serial.println()
Hace exactamente lo mismo que Serial.print(), pero
además, añade automáticamente al ﬁnal de los datos
enviados dos caracteres extra: el de retorno de carro
(código ASCII no 13) y el de nueva línea (código ASCII no
10). La consecuencia es que al ﬁnal de la ejecución de
Serial.println() se efectúa un salto de línea. Tiene los
mismos parámetros y los mismos valores de retorno que
Serial.print()

Introducción Serial.write()
Envía a través del canal serie un dato (especiﬁcado como
parámetro) desde el microcontrolador hacia el exterior. El
dato a enviar solo puede ocupar un byte. Por lo tanto, ha
de ser básicamente de tipo “char” o “byte”.
En realidad, también es capaz de transmitir cadenas de
caracteres porque las trata como una mera secuencia de
bytes independientes uno tras otro. En cambio, otros tipos
de datos que ocupen más de un byte indisolublemente
(como los “int”, “word”, “ﬂoat”....) no serán enviados
correctamente. Su valor de retorno es, al igual que en
Serial.print(), un dato de tipo “byte” que vale el número de
bytes enviados.

Introducción
EJEMPLO 5: ESCRITURA
char cadena[]=”hola”;
byte bytesDevueltos;
void setup(){
Serial.begin(9600);
bytesDevueltos=Serial.write(cadena);
Serial.println(bytesDevueltos);
}
void loop() {
}

Introducción
Existe otra manera de utilizar Serial.write(), que es para enviar
de golpe un array de datos de tipo “byte”. En ese caso, esta
instrucción tiene dos parámetros: el nombre de ese array y el
número de los elementos (empezando siempre por el primero)
que se quieren enviar. Este último valor no tiene por qué
coincidir con el número total de elementos del array.
//El array ha de ser de tipo “byte” (o “char”)
byte arraybytes[ ]={65,66,67,68};
void setup(){
Serial.begin(9600);
/*Se envían solo los dos primeros
elementos de ese array /*
Serial.write(arraybytes,2);
}
void loop() {
}

Introducción
INSTRUCCIONES PARA RECIBIR DATOS DESDE
EL EXTERIOR
Para enviar datos desde el “Monitor serie” al Arduino,
debemos escribir lo que queramos en la caja de texto y
pulsar el botón “Send”. Necesitamos recibir
convenientemente en nuestros sketches los datos que
lleguen a la placa vía comunicación serie. Para ello,
disponemos de dos instrucciones básicas:
Serial.available() y Serial.read()

Introducción
Serial.available()
Devuelve el número de bytes –caracteres– disponibles
para ser leídos que provienen del exterior a través del
canal serie (vía USB o vía pines TX/RX). Estos bytes ya
han llegado al microcontrolador y permanecen
almacenados temporalmente en una pequeña memoria
de 64 bytes que tiene el chip TTL-UART –llamada
“buffer”– hasta que sean procesadosmediante la
instrucción Serial.read(). Si no hay bytes para leer,
esta instrucción devolverá 0. No tiene parámetros.

Introducción
Serial.read()
Devuelve el primer byte aún no leído de los que estén
almacenados en el buffer de entrada del chip TTL-UART.
Al hacerlo, lo elimina de ese buffer. Para devolver (leer) el
siguiente byte, se ha de volver a ejecutar
Serial.read(). Y hacer así hasta que se hayan leído
todos. Cuando no haya más bytes disponibles,
Serial.read() devolverá -1. No tiene parámetros.

Introducción
EJEMPLO 7: LECTURA DE DATOS
byte byteRecibido = 0;
void setup() {
Serial.begin(9600);
}
void loop() {
if (Serial.available() > 0) {
byteRecibido = Serial.read();
Serial.write(”Byte recibido: ”);
Serial.write(byteRecibido);
}
}

Introducción
Serial.ﬁnd()
Lee datos del buffer de entrada (eliminándolos de allí)
hasta que se encuentre la cadena de caracteres (o un
carácter individual) especiﬁcada como parámetro, o bien
se hayan leído todos los datos actualmente en el buffer.
La instrucción devuelve “true” si se encuentra la cadena o
“false” si no.

Introducción
boolean encontrado;
void setup() {
Serial.begin(9600);
}
void loop() {
encontrado=Serial.find(”Hola”);
if (encontrado == true) {
Serial.println(”Encontrado”);
}
}

Introducción
Serial.readBytes()
Lee del buffer de entrada (eliminándolos de allí) la
cantidad de bytes especificada como segundo parámetro
(o bien, si no llegan suficientes bytes, hasta que se haya
superado el tiempo especificado por
Serial.setTimeout()) . En cualquier caso, los bytes
leídos se almacenan en un array –de tipo “char[]”–
especificado como primer parámetro. Esta instrucción
devuelve el número de bytes leídos del buffer (por lo que
un valor 0 significa que no se encontraron datos válidos)

Introducción
Serial.setTimeout()
Tiene un parámetro (de tipo “long”) que sirve para
establecer el número de milisegundos máximo que las
instrucciones Serial.readBytesUntil() y
Serial.readBytes() esperarán a la llegada de datos
al buffer de entrada serie. Si alguna de estas dos
instrucciones no recibe ningún dato y se supera ese
tiempo, el sketch continuará su ejecución en la línea
siguiente. El tiempo de espera por defecto es de 1000
milisegundos. Esta instrucción se suele escribir en “void
setup ()”. No tiene valor de retorno.

Introducción
char a[10];
const int timeout=1000;
void setup() {
Serial.begin(9600);
Serial.setTimeout(timeout);
}
void loop() {
Serial.println(”Escribe un carácter”);
int b = Serial.readBytes(a, 10);
Serial.print(”bytes leídos:t”);
Serial.println(b);
delay(1000);
}

Introducción
Serial.parseFloat()
Lee del buffer de entrada (eliminándolos de allí) todos los datos
hasta que se encuentre con un número decimal. Su valor de
retorno –de tipo “long”– será entonces ese número decimal
encontrado. Cuando detecte el primer carácter posterior no
válido, dejará de leer (y por tanto, no seguirá eliminando datos
del buffer). Esta instrucción no tiene parámetros.
Serial.parseInt()
Lee del buffer de entrada (eliminándolos de allí) todos los datos
hasta que se encuentre con un número entero. Su valor de
retorno –de tipo “long”– será entonces ese número entero
encontrado. Cuando detecte el primer carácter posterior no
válido, dejará de leer (y por tanto, no seguirá eliminando datos
del buffer). Esta instrucción no tiene parámetros.

Introducción
EJEMPLO 10 LECTURA DE DATOS
float numero;
void setup() {
Serial.begin(9600);
}
void loop(){
/* Vacía el buffer hasta reconocer algún
número decimal o vaciarlo del todo */
numero=Serial.parseFloat();
/*Imprime el número decimal detectado, y si no
se ha encontrado ninguno, imprime 0.00 */
Serial.println(numero);
/*Lee un byte más y lo imprime. Si se hubiera
detectado un número decimal, ese byte sería el
carácter que está justo después de él. Si el
buffer está vacío porque Serial.parseFloat()
no encontró ningún número decimal, entonces
devuelve -1 */
Serial.println(Serial.read());
}

Introducción
Otros modelos de placa Arduino disponen de más objetos de
este tipo, y por tanto, de una mayor versatilidad en el uso de la
comunicación serie. La placa Arduino Mega dispone de cuatro
chips TTL-UART. Esto signiﬁca que podemos utilizar hasta
cuatro objetos serie, llamados “Serial”, “Serial1”, “Serial2” y
“Serial3”. El primero sigue estando asociado a los pines 0 y 1,
el objeto “Serial1” está asociado a los pines 18 (TX) y 19 (RX),
el “Serial2” a los pines 16 (TX) y 17 (RX) y el “Serial3” a los
pines 14 (TX) y 15 (RX). Cada uno de estos objetos se puede
abrir independientemente (escribiendo
Serial.begin(9600); Serial1.begin(9600);
Serial2.begin(9600); o Serial3.begin(9600);
respectivamente), y pueden enviar y recibir datos también
independientemente. No obstante, el único objeto asociado
también a la conexión USB es “Serial” (porque es el único
conectado al chip conversor ATmega16U2)

Introducción
INSTRUCCIONES DE GESTIÓN DEL
TIEMPO
Estas instrucciones no pertenecen a ningún objeto, así
que se escriben directamente:
millis():
Devuelve el número de milisegundos (ms) desde que la placa
Arduino empezó a ejecutar el sketch actual. Este número se
reseteará a cero aproximadamente después de 50 días
(cuando su valor supere el máximo permitido por su tipo, que
es “unsigned long”).
micros():
Devuelve el número de microsegundos (µs) desde que la placa
Arduino empezó a ejecutar el sketch actual. Este número –de
tipo “unsigned long”– se reseteará a cero aproximadamente
después de 70 minutos. Esta instrucción tiene una resolución
de 4 µs (es decir, que el valor retornado es siempre un múltiplo
de cuatro).

Introducción
INSTRUCCIONES DE GESTIÓN DEL
TIEMPO
Estas instrucciones no pertenecen a ningún objeto, así
que se escriben directamente:
delay():
Pausa el sketch durante la cantidad de milisegundos
especiﬁcados como parámetro ?de tipo ?unsigned long??. No
tiene valor de retorno.
delayMicroseconds():
Pausa el sketch durante la cantidad de microsegundos
especiﬁcados como parámetro –de tipo “unsigned long”– .
Actualmente el máximo valor que se puede utilizar con
precisión es de 16383. Para esperas mayores que esta, se
recomienda usar la instrucción delay(). El mínimo valor que se
puede utilizar con precisión es de 3 µs. No tiene valor de
retorno.

Introducción
INSTRUCCIONES MATEMÁTICAS, TRIGONOMÉTRICAS Y
DE PSEUDOALEATORIEDAD
El lenguaje Arduino dispone de una serie de instrucciones
matemáticas y de pseudoaleatoriedad que nos pueden venir
bien en nuestros proyectos. Son estas:
abs(). Devuelve el valor absoluto de un número pasado por
parámetro (el cual puede ser tanto entero como decimal).
min(). Devuelve el mínimo de dos números pasados por
parámetros.
max(). Devuelve el máximo de dos números pasados por
parámetros.
constrain(). Recalcula el valor pasado como primer
parámetro (llamémosle “x”) dependiendo de si está dentro o
fuera del rango delimitado por los valores pasados como
segundo y tercer parámetro (llamémoslos “a” y “b”
respectivamente, donde “a” siempre ha de ser menor que
“b”). Los tres parámetros pueden ser tanto enteros como
decimales.

Introducción
map(). Modifica un valor –especificado como primer parámetro– el cual
inicialmente está dentro de un rango (delimitado con su mínimo –segundo
parámetro– y su máximo –tercer parámetro–) para que esté dentro de otro
rango (con otro mínimo –cuarto parámetro– y otro máximo –quinto
parámetro–) de forma que la transformación del valor sea lo más
proporcional posible.
El valor mínimo del rango inicial (0) se mapea al valor mínimo del rango final
(200), el valor 25 (una cuarta parte del rango inicial) se mapea al valor 250
(una cuarta parte del rango final) y que un valor fuera del rango inicial (500)

Introducción
pow(). Devuelve el valor resultante de elevar el
número pasado como primer parámetro (la “base”) al
número pasado como segundo parámetro (el
“exponente”, el cual puede ser incluso una fracción).
sq(). Devuelve el el cuadrado del número pasado
como parámetro y cuyo resultado se devuelve en forma
de número de tipo “double”.
sqrt(). Devuelve la raíz cuadrada del número pasado
como parámetro (que puede ser tanto entero como
decimal). El valor devuelto es de tipo “double”.
funciones trigonométricas: sin(), cos(), tan()

Introducción
NÚMERO PSEUDOALEATORIO
Un número pseudoaleatorio no es estrictamente un número
aleatorio según la definición matemática rigurosa, pero para
nuestros propósitos el nivel de aleatoriedad que alcanzan las
siguientes funciones será más que suficiente:
randomSeed(). Inicializa el generador de números
pseudoaleatorios. Se suele ejecutar en la sección “setup()”
para poder utilizar a partir de entoncesnúmeros
pseudoaleatorios en nuestro sketch. Esta instrucción tiene un
parámetro de tipo “int” o “long” llamado “semilla” que indica el
valor a partir del cual empezará la secuencia de números.
Semillas iguales generan secuencias iguales, así que
interesará en múltiples ejecuciones de randomSeed()
utilizar valores diferentes de semilla para aumentar la
aleatoriedad. También nos puede interesar a veces lo
contrario: fijar la semilla para que la secuencia de números
aleatorios se repita exactamente. No tiene ningún valor de
retorno.

Introducción
random(). Una vez inicializado el generador de números
pseudoaleatorios con randomSeed(), esta instrucción
retorna un número pseudoaleatorio de tipo “long”
comprendido entre un valor mínimo (especificado como
primer parámetro –opcional–) y un valor máximo
(especificado como segundo parámetro) menos uno. Si no se
especifica el primer parámetro, el valor mínimo por defecto es
0. El tipo de ambos parámetros puede ser cualquiera
mientras sea entero.

Introducción
EJEMPLO 13
void setup() {
Serial.begin(9600);
randomSeed(100);
}
void loop(){
Serial.println(random(1,30));
delay(1000);
}

Introducción
OPERADORES ARITMÉTICOS
Algunos de los operadores aritméticos, funcionan tanto
para números enteros como decimales y son los
siguientes:
Operadores aritméticos
+ Operador suma
− Operador resta
∗ Operador multiplicación
/ Operador división
% Operador módulo
El operador módulo sirve para obtener el resto de una
división. Por ejemplo: 275=2 . Es el único operador que
no funciona con “ﬂoats”.

Introducción
INSTRUCCIONES DE GESTIÓN DE
CADENAS
Ejemplo 14:

Introducción
INSTRUCCIONES DE GESTIÓN DE
CADENAS

Introducción
CREACIÓN DE INSTRUCCIONES
(FUNCIONES) PROPIAS
Para crear una función propia, debemos “declararlas”. Esto se
hace en cualquier lugar fuera de “void setup()” y “void
loop()” –por tanto, bien antes o después de ambas
secciones– , siguiendo la sintaxis marcada por la plantilla
siguiente:
tipoRetorno nombreFuncion (tipo param1, tipo
param2,...) { // Código interno de la función
}
tipoRetorno es uno de los tipos ya conocidos (“byte”, “int”,
“ﬂoat”, etc.) e indica el tipo de valor que la función devolverá al
sketch principal una vez ejecutada.
tipo param1, tipo param2,... son las declaraciones de
los parámetros de la función, que no son más que variables
internas cuya existencia solo perdura mientras el código de
esta se esté ejecutando.

Introducción
CREACIÓN DE UNA FUNCIÓN QUE DEVUELVE EL RESULTADO DE
MULTIPLICAR DOS NÚMEROS PASADOS COMO PARÁMETROS
Ejemplo 15:

Introducción
BLOQUES CONDICIONALES
Lo primero que debemos saber es que para escribir
correctamente en nuestro sketch estas condiciones
necesitaremos utilizar alguno de los llamados
operadores, que son los siguientes:
Operadores de comparación
== Comparación de igualdad
! = Comparación de diferencia
> Comparación de mayor que
>= Comparación de mayor o igual que
< Comparación de menor que
<= Comparación de menor o igual que
Operadores lógicos
& AND
|| OR
! NOT

Introducción
if y if/else
if (condición) {
//Instrucciones -una o más- que se
ejecutan si la condición es cierta
} else if (otra condición) {
/*Instrucciones -una o más- que se
ejecutan si la condición del anterior “if”
es falsa pero la actual es cierta */
} else if (otra condición) {
/*Instrucciones -una o más- que se
ejecutan si la condición del anterior ?if?
es falsa pero la actual es cierta */
} else {
//Instrucción(es) que se ejecutan si todas
las condiciones anteriores eran falsas
}

Introducción
EJEMPLO CON “STRING‘”
Ejemplo 17:

Introducción
switch
Ejemplo 18:

Introducción
while y do
while
Ejemplo 19:
do (condición) {
//Instrucciones que se repetirán mientras
la condición sea cierta -“true”,1-
} while ( condición)

Introducción
for
Operadores compuestos
x++ Incremento
x– Decremento
x+=3 x=x+3
x-=3 x=x-3
x*=3 x=x*3
x/=3 x=x/3
Ejemplo 20:

Introducción
ENTRADAS Y SALIDAS
pinMode(): Conﬁgura un pin digital (primer parámetro) como
entrada o de corriente (segundo parámetro, INPUT o OUTPUT).
INPUT_PULLUP activa la resistencia “pull-up” de 20 K Ω que
todo pin digital incorpora. La constante INPUT desactiva
explícitamente estas resistencias “pull-ups” internas.
digitalWrite(): envía un valor ALTO (HIGH) o BAJO
(LOW) a un pin digital. El pin al que se le envía la señal se
especiﬁca como primer parámetro (HIGH o LOW, ambas de
tipo “int”).
HIGH equivale a una señal de salida de hasta 40 mA y de 5 V
(3,3 V en las placas que trabajen a ese voltaje), LOW equivale a
una señal de salida de 0 V.

Introducción
Si el pin está conﬁgurado como entrada usando la constante
INPUT, enviar un valor HIGH equivale a activar la resistencia
interna “pull-up” en ese momento (similar a INPUT_PULLUP), y
enviar un valor LOW equivale a desactivarla de nuevo.
Si un pin de entrada tiene su resistencia “pull-up” interna
desactivada, en el momento que no esté conectado a nada
puede recibir ruido eléctrico del entorno o de algún pin cercano
y provocar así inconsistencias en los valores de entrada
obtenidos (ya que estos cambiarán aleatoriamente en cualquier
momento).
(e) pull-down (f) pull-up

Introducción
digitalRead(): devuelve el valor leído del pin digital
(conﬁgurado como entrada mediante pinMode()) cuyo
número se haya especiﬁcado como parámetro. Este valor
de retorno es de tipo “int”.
Si la entrada es de tipo INPUT, el valor HIGH se
corresponde con una señal de entrada mayor de 3 V y el
valor LOW con una señal menor de 2 V. Si la entrada es de
tipo INPUT_PULLUP, al tener la entrada conectada una
resistencia “pull-up”, las lecturas son al revés: el valor
HIGH indica que no se recibe señal de entrada y el valor
LOW que sí.

Introducción
Diagrama de conexión

Introducción
EJERCICIO 1
Modiﬁcar el sketch anterior para que los tres
LEDs se iluminen y se apaguen a la vez

Introducción
EJERCICIO 2
Explique el funcionamiento antes de cargar el sketch a la
placa Arduino

Introducción
EJERCICIO 3 Y4
3. Realizar un programa que realice lo siguiente:
Usar un botón que no se tenga que mantener
pulsado para activar una salida, sino que pulsándolo
una vez ya se active y pulsándolo otra vez se
desactive
4. Modiﬁcar el código anterior para que se imprima
en “monitor serial” una cuenta atrás de 10
pulsaciones y que al llegar a 0 (es decir, al hacer
diez pulsaciones) se imprima un mensaje ﬁnal

Introducción
EJEMPLO 29 “ELIMINADOR DE REBOTES”

Introducción
EJERCICIO 5
El circuito constará de tres LEDs estos se irán
encendiendo y apagando de forma secuencial, y cuando
el LED del medio se encienda, el jugador debe apretar en
un pulsador. Si acierta, se mostrará un mensaje por el
“Monitor Serie” y la velocidad de la secuencia de
iluminación de los LEDs aumentará (y también lo hará por
tanto la diﬁcultad).
En nuestro sketch los LEDs están conectados a los pines
digitales 5, 6 y 7, y el pulsador al pin 8. El tiempo inicial
entre encendido y encendido de los LEDs es 200 ms,
pero si el jugador acierta, este tiempo disminuirá en 20
ms, hasta llegar a un tiempo entre encendidos de 10 ms,
momento en el cual se volverá al tiempo inicial de 200 ms.

Introducción
EJERCICIO 6
Se trata de implementar un juego, en el cual tenemos tres
LEDs que durante un breve lapso de tiempo se iluminan
en una secuencia rápida y aleatoria. El usuario deberá
adivinar cuál de los tres LEDs es el último en iluminarse
apretando el pulsador correspondiente.
Existe un pulsador por cada LED, y en el código se han
conﬁgurado con las resistencias “pullup” internas de la
placa Arduino, por lo que su conexión no requiere
ninguna resistencia externa. Si el usuario acierta, se
enviará un mensaje de felicitación por el canal serie; si
no, se enviará un mensaje de consuelo.

Introducción
Entradas y salidas analógicas
analogWrite(): Envía un valor de tipo “byte”
(especificado como segundo parámetro) que representa
una señal PWM, a un pin digital configurado como
OUTPUT (especificado como primer parámetro). En la
placa Arduino UNO son los pines 3, 5, 6, 9, 10 y 11 ( ∼ ).
Cada vez que se ejecute esta función se regenerará la
señal.
Una señal PWM es una señal digital cuadrada que simula ser una
señal analógica. El valor simulado de la señal analógica dependerá de
la duración que tenga el pulso digital.
Si el segundo parámetro de esta función vale 0, el pulso no dura nada
(no hay señal) y por tanto su valor analógico “simulado” será 0V.
Si vale 255 (resolución de 8 bits), el pulso dura todo el período de la
señal (señal continua) y su valor analógico “simulado” será el máximo
de la placa (5 V).

Introducción
analogRead(): Devuelve el valor leído del pin de
entrada analógico cuyo número (0, 1, 2...) se ha
especiﬁcado como parámetro. Este valor se obtiene
mapeando proporcionalmente la entrada analógica
obtenida (que debe oscilar entre 0 y un voltaje llamado
voltaje de referencia, el cual por defecto es 5 V) a un valor
entero entre 0 y 1023. Esto implica que la resolución de
lectura es de 5V/1024, es decir, de 0,049 V.

Introducción
Los pines analógicos por defecto solamente funcionan
como entradas de señales analógicas, no es necesario
utilizar previamente la función pinMode().
Pero si se necesitarán utilizar más pines de
entrada/salida digitales de los que la placa Arduino
ofrece, estos pines pueden ser utilizados, simplemente
identiﬁcándolos con un número correlativo más allá del
pin 13, que es el último pin digital. Es decir, el pin “A0”,. . .,
“A5” sería el número 14,. . ., hasta el 19, respectivamente.
Si quisiéramos que el pin analógico “A3” funcionara como
salida digital y además enviara un valor BAJO,
escribiríamos primero pinMode(17,OUTPUT); y luego
digitalWrite(17,LOW);

Introducción
Si un pin analógico no está conectado a nada, el valor
devuelto por analogRead() ﬂuctuará debido a múltiples
factores como por ejemplo los valores que puedan tener
las otras entradas analógicas, o lo cerca que esté nuestro
cuerpo a la placa, etc.
Por otro lado, hay que saber que el convertidor
analógico/digital tarda alrededor de 100 microsegundos
(0,0001s) en procesar la conversión y obtener el valor
digital, por lo que el ritmo máximo de lectura en los pines
analógicos es de 10000 veces por segundo.
Esto hay que tenerlo en cuenta en nuestros sketches.

Introducción
Ejemplos con entradas analógicas
(potenciómetros)

Introducción
Ejemplo 35
Ejercicio 7: Enviar al LED una señal digital con
digitalWrite() –es decir, se enciende (HIGH) o se apaga
(LOW)– para hacerlo parpadear y utilizar entonces la lectura
del potenciómetro como parámetro de delay() para
establecer el tiempo de parpadeo.
Ejercicio 9: Encender el LED solamente si el valor leído del
potenciómetro supera un determinado umbral:

Introducción
CAMBIAR EL VOLTAJE DE REFERENCIA DE LAS
LECTURAS ANALÓGICAS
analogReference(): Configura el voltaje de referencia
usado para la conversión interna de valores analógicos en
digitales. Dispone de un único parámetro, que en la placa
Arduino UNO puede tener los siguientes valores: la constante
predefinida DEFAULT (que equivale a establecer el voltaje de
referencia es 5 V – o 3,3 V en las placas que trabajen a esa
tensión–, el cual es el valor por defecto), o la constante
predefinida INTERNAL (donde el voltaje de referencia entonces
es de 1,1 V) o la constante predefinida EXTERNAL (donde el
voltaje de referencia entonces es el voltaje que se aplique al
pin AREF –“Analogue REFerence”–).
Es muy importante ejecutar siempre esta función antes de
cualquier lectura realizada con analogRead() para evitar
daños en la placa.

Introducción
SENSORES DE LUZ VISIBLE
Los sensores de luz, tal como su nombre indica, son
sensores que permiten detectar la presencia de luz en el
entorno. A veces se les llama “celdas CdS” (sulfuro de
cadmio) o “fotorresistores” y LDRs (del inglés “Light
Dependent Resistor”), ya que básicamente se componen
de una resistencia que cambia su valor dependiendo de
la cantidad de luz que esté incidiendo sobre su superﬁcie.
Concretamente, reducen su resistencia a medida que
reciben más intensidad de luz.

Introducción
Si usamos una resistencia “pull-down”, cuanto mayor voltaje
recibamos por la entrada analógica de la placa Arduino
signiﬁcará que más luz incide en el sensor, por lo que, el
montaje sería similar a este:
El circuito anterior se puede entender usando la la siguiente fórmula:
V med =
R
pull
R
pull + R
LDR
V
fuente
Cuando aumenta la intensidad de luz (como la resistencia del
fotorresistor disminuye), también aumenta el voltaje medido, y
viceversa.

Introducción
V med necesita un ajuste debido a que no es el valor con el que
trabajamos en nuestra placa Arduino y necesita un mapeo de
todos valores analógicos recibidos (entre 0 V y 5 V ) a valores
digitales (entre 0 y 1023).
La conversión de valores analógicos a digitales se puede
expresar por una simple regla de proporcionalidad así:
V convertido =
V med × 1023
5
.
Sustituyendo en la fórmula de V med , y despejamos R LDR , se
obtiene:
R LDR = (
R
pull × 1023
V
convertido
) − R
pull .
Obtenemos el valor actual de la resistencia del fotorresistor a
partir del voltaje digitalizado obtenido por la placa Arduino.

Introducción
Ejercicio 8
Realizar un detector de presencia. Si se mantiene
iluminado el fotorresistor de forma constante, al
interponerse algún obstáculo entre la fuente de luz y
el fotorresistor, este detectaría una bajada brusca de
intensidad lumínica
Se encendiende el LED si el fotorresistor detectara
un valor por debajo de un cierto valor umbral
detectando que alguien se interpone entre la luz y el
sensor.
O que apague el LED si el valor “valorcds” fuera
mayor que dicho umbral (y por tanto, se detectara
una incidencia “normal” de la luz en el sensor.

curso-arduino.pdf

Recomendados

Recomendados

Más contenido relacionado

La actualidad más candente

La actualidad más candente (20)

Similar a curso-arduino.pdf

Similar a curso-arduino.pdf (20)

Más de cesarbaquero4

Más de cesarbaquero4 (13)

Último

Último (11)

curso-arduino.pdf