Cursointroarduino

Introduccin a Arduino I:
Jugando con Leds y

pulsadores
Taller 1: Introduccin a Arduino. Jugando con Leds y pulsadores
"El verdadero progreso es el que pone la

tecnologa al alcance de todos."
(Henry Ford)
FabLab Len
ndice:
Qu es FabLab Len?........................................................... 9
Plataforma electrnica Arduino UNO ...................................... 10
Software de Arduino ........................................................... 12

3.1
Programacin ..................................................... 13
Estructura bsica de Lenguaje Arduino .................................. 15

5.1
setup() .............................................................. 15
5.2
loop() ................................................................ 16
Ejemplos a implementar ...................................................... 17

6.1
Led intermitente.................................................. 17
6.1.1 Cdigo ............................................................ 18

6.1.2
Circuito .......................................................... 18
6.1.3
Montaje en Protoboard ..................................... 19
6.1.4 Ejercicio 1: ...................................................... 19

6.2
Botones o pulsadores ........................................... 20
6.2.1 Cdigo ............................................................ 21

6.2.2 Circuito ........................................................... 21
6.2.3
Montaje en Protoboard ..................................... 22
6.2.4 Ejercicio 2: ...................................................... 23

6.2.5 Ejercicio 3 complementario: ............................... 23
7
Anexo: Gua de lenguaje Arduino. ......................................... 24

7.1
Funciones ........................................................... 24
7.2
{} entre llaves .................................................... 24
7.3
; punto y coma ................................................... 25
FabLab Len
7.4
/* */ bloque de comentarios ............................... 25
7.5
// lnea de comentarios ........................................ 25
7.6
Variables ............................................................ 26
7.7
Declaracin de variables ....................................... 27
7.8
utilizacin de una variable .................................... 27
7.9
Tipos de datos .................................................... 28
7.9.1 Byte ............................................................... 28

7.9.2 Int ................................................................. 28
7.9.3 Long .............................................................. 28
7.9.4 Float .............................................................. 28
7.9.5 arrays ............................................................ 29
7.10
aritmtica .......................................................... 30
7.11
asignaciones compuestas ..................................... 30
7.12
operadores de comparacin .................................. 31
7.13
operadores lgicos ............................................... 31
7.14
constantes ......................................................... 31
7.15
cierto/falso (true/false) ........................................ 32
7.16
High/Low ........................................................... 32
7.17
Input/Output ...................................................... 32
7.18
Control de flujo ................................................... 32
7.18.1 if (si condicional) ............................................ 32

7.18.2 if else (si.. sino ..) ...................................... 33
7.18.3 for................................................................ 34
7.18.4 while ............................................................ 34
7.18.5 do while ...................................................... 35
7.19
e/s digitales ........................................................ 35
FabLab Len
7.19.1 pinMode(pin, mode) ........................................ 35

7.19.2 digitalRead(pin) ............................................. 36
7.19.3 digitalWrite(pin, value) .................................... 36
7.20
E/s analgicas..................................................... 37
7.20.1 analogRead(pin) ............................................. 37

7.20.2 analogWrite(pin, value) ................................... 37
7.21
Control del tiempo ............................................... 38
7.21.1 delay(ms) ..................................................... 38

7.21.2 millis() .......................................................... 38
7.22
Matemticas ....................................................... 39
7.22.1 min(x, y)....................................................... 39

7.22.2 max(x, y) ...................................................... 39
7.23
aleatorios ........................................................... 39
7.23.1 randomSeed(seed) ......................................... 39

7.23.2 random(max), random(min, max) .................... 39
7.24
comunicacin serie .............................................. 40
7.24.1 Serial.begin(rate) ........................................... 40

7.24.2 Serial.println(data) ......................................... 40
7.24.3 Serial.print(data, data type) ............................. 41
7.24.4 Serial.avaible() .............................................. 41
7.24.5 Serial.Read() ................................................. 42
FabLab Len
Materiales: por alumno
1 x Arduino Uno, con su cable USB.

5 x Led (colores varios).
5x resistencias 220 ohm.
15 x cables de conexin.
2 x Pulsadores PCB
2 x Resistencias 10K
1 x Protoboard
1 x Ordenador (PC) por alumno.
FabLab Len
Glosario:
ATmega8U2: Microcontrolador usado en las placas Arduino para establecer
la conexin USB
Bit: es el acrnimo de Binary digit o dgito binario. Un bit es un dgito del
sistema de numeracin binario
Bootloader: Es un gestionador de arranque. Es una programacin de que
disponen todos los micros de Arduino para facilitar la comunicacin con el
PC y la programacin.
Byte: secuencia de 8 bits contiguos.
CAD: Computer Aided Design o diseo asistido por ordenador
CAN: es un protocolo de comunicaciones desarrollado por la firma alemana
Robert Bosch GmbH, basado en una topologa bus para la transmisin de
mensajes en ambientes distribuidos, adems ofrece una solucin a la
gestin de la comunicacin entre mltiples CPUs (unidades centrales de
proceso).
Clavija: Parte macho de un conector.
CPU: Central Proces Unit o unidad central de proceso
Conversor A/D: Dispositivo electrnico encargado de convertir una seal
analgica en una sucesin de bits o seal digital
Drivers: Son pequeos programas que permiten que el Sistema Operativo
sepa utilizar las capacidades de un perifrico. Software que se encarga de
interactuar entre el sistema operativo y los dispositivos (hardware).
DFU: (Device Firmware Update), Actualizacin del Firmware del Dispositivo
se trata de un modo que disponen muchos dispositivos que permite
reprogramarle. Es posible reprogramar el dispositivo mientras esta
encendido sin necesidad de programador externo.
EEPROM: son las siglas de Electrically-Erasable Programmable Read-Only
Memory (ROM programable y borrable elctricamente). En espaol se la
suele denominar "EPROM" y en ingls "E-Squared-PROM". Es un tipo de
memoria no voltil que puede ser programado, borrado y reprogramado
elctricamente.
Firmware: Programacin interna de un dispositivo que le permite controlar
su propio hardware.
FLASH: La memoria flash es una forma desarrollada de la memoria
EEPROM que permite que mltiples posiciones de memoria sean escritas o
borradas en una misma operacin de programacin mediante impulsos
elctricos, frente a las anteriores que slo permite escribir o borrar una
nica celda cada vez. Por ello, flash permite funcionar a velocidades muy
FabLab Len
superiores cuando los sistemas emplean lectura y escritura en diferentes

puntos de esta memoria al mismo tiempo.
I2C: es un bus de comunicaciones serie. Su nombre viene de InterIntegrated Circuit. La principal caracterstica de IC es que utiliza dos lneas
para transmitir la informacin: una para los datos y por otra la seal de
reloj.
PAD: o huella de un componente es la forma que deben tener las pistas del
circuito impreso para recibir el componente y as pueda ser soldado
correctamente. Cada componente tiene una huella distinta.
Patilla: tambin llamado terminal. Son los contactos terminales de un
conector o componente electrnico, fabricado de un material conductor de
la electricidad. Estos se utilizan para poder realizar una conexin sin soldar.
PCB: Printed Circuit Board o circuito impreso, es un medio para sostener
mecnicamente y conectar elctricamente componentes electrnicos, a
travs de rutas o pistas de material conductor, grabados en hojas de cobre
laminadas sobre un sustrato no conductor.
Pines: tambin llamados terminales. Son los contactos terminales de un
conector o componente electrnico, fabricados de un material conductor de
la electricidad. Estos se utilizan para poder realizar una conexin sin soldar.
Puerto COM: Un puerto serie o puerto serial es una interfaz de
comunicaciones de datos digitales, frecuentemente utilizada por
computadoras y perifricos, donde la informacin es transmitida bit a bit
enviando un solo bit a la vez. Puerto muy usado hasta la aparicin del USB
(que es una versin del COM).
Resistencias Pull-up: Son resistencias que permiten que una entrada
nunca quede desconectada. Son de valor alto (5K o 10K) y conectan la
entrada con el negativo o positivo de modo que en ausencia de seal el
valor en la entrada es bajo o alto respectivamente.
PWM: Pulse-Width Modulation en ingls o modulacin por ancho de pulsos
de una seal o fuente de energa es una tcnica en la que se modifica el
ciclo de trabajo de una seal peridica (por ejemplo sinusoidal o cuadrada)
ya sea para transmitir informacin a travs de un canal de comunicaciones
o como control de la cantidad de energa que se enva a una carga.
RAM: (en ingls: Random Access Memory cuyo acrnimo es RAM) es la
memoria desde donde el procesador recibe las instrucciones y guarda los
resultados.
Rpm: revoluciones por minuto
SRAM: Static Random Access Memory o memoria esttica de acceso
aleatorio.
FabLab Len
SMD: Surface Mount Device o dispositivos de montaje superficial. Se trata

de los componentes electrnicos que se sueldan sobre la superficie de una
placa electrnica sin necesidad de hacer agujeros
Socket: en ingls zcalo. Parte hembra de un conector.
SPI: (Serial Peripheral Interface Bus): Es un bus de comunicaciones serie
estandarizado por Motorola que opera en modo full dplex. Los dispositivos
son esclavos/maestros donde el maestro inicia las comunicaciones. Este bus
admite mltiples dispositivos conectados simultneamente con distintos
nmeros de esclavo identificativos. Esta comunicacin necesita 4 hilos.
Sketch: Un sketch es el nombre que usa Arduino para un programa. Es la
unidad de cdigo que se sube y ejecuta en la placa Arduino.
TTL: es la sigla en ingls de transistor-transistor logic, es decir, "lgica
transistor a transistor". Es una familia lgica o lo que es lo mismo, una
tecnologa de construccin de circuitos electrnicos digitales. En los
componentes fabricados con tecnologa TTL los elementos de entrada y
salida del dispositivo son transistores bipolares. Los niveles lgicos vienen
definidos por el rango de tensin comprendida entre 0,2V y 0,8V para el
estado L (bajo) y los 2,4V y Vcc para el estado H (alto).
TWI: I2C es un bus de comunicaciones en serie. Su nombre viene de InterIntegrated Circuit. Se necesitan solamente dos lneas, la de datos (SDA) y
la de reloj (SCL). Cada dispositivo conectado al bus tiene un cdigo de
direccin seleccionable mediante software. Habiendo permanentemente una
relacin Master/ Slave entre el micro y los dispositivos conectados. El bus
permite la conexin de varios Masters, ya que incluye un detector de
colisiones. El protocolo de transferencia de datos y direcciones posibilita
disear sistemas completamente definidos por software. Los datos y
direcciones se transmiten con palabras de 8 bits.
USB: Universal Serial Bus o bus universal serie, abreviado comnmente
USB, es un puerto que sirve para conectar perifricos a un ordenador.
UART: El corazn del sistema de comunicaciones serie es la UART,
acrnimo de Universal Asynchronous Receiver-Transmitter. Es un chip cuya
misin principal es convertir los datos recibidos del bus del PC en formato
paralelo, a un formato serie que ser utilizado en la transmisin hacia el
exterior. Tambin realiza el proceso contrario: transformar los datos serie
recibidos del exterior en un formato paralelo entendible por el bus.
FabLab Len
1 Qu es FabLab Len?
La misin de Fab Lab Len es convertirse en un ecosistema que
aliente y ayude a las personas a construir (casi) todo lo que puedan
imaginar.
Un Fab Lab es un proyecto de la organizacin sin nimo de
lucro tMA, y consiste en un espacio de trabajo comunitario, a un
coste razonable, que sirve como incubadora de investigacin, de
iniciativas creativas y de negocios, que permite el crecimiento
personal, el desarrollo econmico e incrementa las capacidades
locales.
El concepto de Fab Lab refleja un nuevo paradigma de la
fabricacin en el que las personas definen los problemas, crean las
soluciones y comercializan los productos.
El Fab Lab elimina barreras como el capital fundacional, el
acceso a equipamiento y el acceso a expertos, alentando un cambio
sistmico de
los entornos educacionales,
de
innovacin y
de
emprendimiento.
FabLab Len
2 Plataforma electrnica Arduino UNO

Arduino es una plataforma de electrnica abierta para la
creacin de prototipos basada en software y hardware flexibles y
fciles de usar. Se cre para artistas, diseadores, aficionados y
cualquiera interesado en crear entornos u objetos interactivos.
Arduino UNO
Arduino puede tomar informacin del entorno a travs de sus

pines de entrada de toda una gama de sensores y puede afectar
aquello que le rodea controlando luces, motores y otros actuadores.
El microcontrolador en la placa Arduino se programa mediante el
lenguaje de programacin Arduino (basado en Wiring) y el entorno de
desarrollo Arduino (basado en Processing). Los proyectos hechos con
Arduino pueden ejecutarse sin necesidad de conectar a un ordenador,
si bien tienen la posibilidad de hacerlo y comunicar con diferentes
tipos de software (p.ej. Flash, Processing, MaxMSP).
FabLab Len
10
Las placas pueden ser hechas a mano o compradas montadas

de fbrica; el software puede ser descargado de forma gratuita. Los
ficheros de diseo de referencia (CAD) estn disponibles bajo una
licencia abierta, as pues eres libre de adaptarlos a tus necesidades.
Existen diversas tarjetas con diferentes microcontroladores,
cada una con unas caractersticas concretas. Nosotros usaremos
Arduino UNO por ser el buque insignia de la familia Arduino. Adems
una vez que eres capaz de comprender el funcionamiento de la UNO,
ya puedes usar cualquiera de las dems.
FabLab Len
11
3 Software de Arduino
La Arduino Uno tiene una gran cantidad de posibilidades para la
comunicacin
con
microcontrolador
un
de
ordenar,
esta
otros
placa
microcontroladores.
(Atmega328)
El
proporciona
comunicacin serie UART TTL (5V), que est disponible en los pines
digitales 0 (RX) y 1 (TX). El ATmega8U2 integrado en la tarjeta
permite transfiere esta comunicacin sobre el USB y aparece con un
puerto COM virtual para el software del ordenador. El firmware del
8U2 emplea los drivers estndar para el puerto USB, por lo tanto no
son necesarios drivers externos. Sin embargo bajo Windows es
necesario un archivo .inf. El software the Arduino incluye un monitor
serie que permite el envo y recepcin de datos de texto plano entre
el ordenador y la tarjeta. Los leds de RX y TX se iluminaran durante
la transmisin de los datos
va el chip conversor USB-a-serie y la
conexin USB al ordenador

La librera SoftwareSerial permite la comunicacin serie en
cualquiera de los pines digitales de la Uno.
El ATmega328 tambin soporta comunicaciones I2C (TWI) y
SPI. El software de Arduino incluye la librera Wire para simplificar el
uso del bus I2C; ver la documentacin para ms informacin. Para la
comunicacin SPI se usa la librera SPI.
Encabezado del software de Arduino
FabLab Len
12
Sencillez en la interfaz del software Arduino
3.1 Programacin
El Arduino Uno puede ser programado con el software gratuito
Arduino (descargable de su pgina web). Una vez descargado no es
necesario instalarlo basta con descomprimir la carpeta y ejecutar
arduino.exe.
A continuacin se debe conectar la tarjeta con su cable USB.
Windows tratara de buscar el controlador adecuado, como no lo
encontrara, nosotros debemos de actualizar el controlador.
FabLab Len
13
Para ello debemos acceder al administrador de dispositivos y

hacer clic derecho sobre el dispositivo recin instalado, actualizamos
el controlador eligiendo como carpeta donde se encuentra el driver la
de Arduino (recin descomprimida).
Una vez hecho lo anterior estamos listos para comenzar a
programar la tarjeta. Solo es necesario una vez en la interfaz
seleccionar Arduino Uno en el men Tools > Board.
El chip ATmega328 que usa Arduino Uno viene pre programado
con un bootloader (consultar glosario) que permite introducirle nuevo
cdigo sin necesidad de un programador externo. Se comunica
usando el protocolo STK500.
Tambin es posible ignorar el bootloader y programar el
microcontrolador a travs del conector ICSP (In-Circuit
Serial
Programming).
El firmware que usa el ATmega8U2 tambin est disponible.
Este chip est cargado con un bootloader DFU, que puede ser
activado conectando el jumper de soldadura en la parte posterior de
la placa y posteriormente reseteando el 8U2. As despus se podr
hacer la programacin con un programador DFU (no usado en este
taller).
FabLab Len
14
5 Estructura bsica de Lenguaje Arduino

La estructura bsica del lenguaje de programacin de Arduino
es bastante simple y se compone de al menos dos partes. Estas dos
partes necesarias, o funciones, encierran bloques que contienen
declaraciones, estamentos o instrucciones.
vo i d se t u p ()
{
i n str u cci o n e s;
}
vo i d l oo p ()
{
}
En donde setup() es la parte encargada de recoger la

configuracin y loop() es la que contienen el programa que se
ejecutar cclicamente (de ah el termino loop bucle-). Ambas
funciones
son
correctamente.
necesarias
La
funcin
para
de
que
el
configuracin
programa
debe
funcione
contener
la
declaracin de las variables. Es la primera funcin a ejecutar en el

programa, se ejecuta slo una vez, y se utiliza para configurar o
inicializar pinMode (modo de trabajo de las E/S), configuracin de la
comunicacin en serie y otras.
La funcin bucle (loop) siguiente contiene el cdigo que se
ejecutara continuamente (lectura de entradas, activacin de salidas,
etc.) Esta funcin es el ncleo de todos los programas de Arduino y la
que realiza la mayor parte del trabajo.
5.1 setup()
La funcin setup() se invoca una sola vez cuando el programa
empieza. Se utiliza para inicializar los modos de trabajo de los pines,
o el puerto serie. Debe ser incluido en un programa aunque no haya
declaracin que ejecutar. As mismo se puede utilizar para establecer
el estado inicial de las salidas de la placa.
FabLab Len
15

vo i d se t u p ()
{
p i n Mo d e( pi n , O UT PUT ) ; / / co n fi g ur a el 'pi n ' co mo
sa li d a
d i gi t alW rit e ( pi n , HI G H) ; / / p o n e e l p in e n e st a do
/ / HI G H
}
5.2 loop()
Despus
de
finalizar
setup(),
la
funcin
loop()
hace
precisamente lo que sugiere su nombre, se ejecuta de forma cclica,

lo que posibilita que el programa este respondiendo continuamente
ante los eventos que se produzcan en la placa.
vo i d l oo p ()
{
d i gi t alW rit e ( pi n , HI G H) ; / / p o n e e n u no ( o n , 5 v) el p in
d e l a y( 1 0 00 ) ; / / e sp e ra u n seg u n d o ( 10 0 0 ms)
d i gi t alW rit e ( pi n , L OW ) ; / / p o n e e n ce ro ( o f f , 0 v. ) el
d e l a y( 1 0 00 ) ; / / pi n
}
FabLab Len
16
6 Ejemplos a implementar
6.1 Led intermitente
En la mayora de los lenguajes de programacin, el primer
programa que escribes imprime en la pantalla del ordenador la frase
"Hola Mundo". Ya que una placa Arduino no tiene una pantalla (ya la
se la pondremos), podemos hacer parpadear un Led.
Las placas estn diseadas para que hacer parpadear un Led
sea muy fcil. Algunas tienen un Led directamente incorporado en la
placa para este pin. Si no lo tiene, usarlo es igual de sencillo solo
necesitamos una resistencia de 220 Ohm y el Led.
Los Leds tienen polaridad, lo que significa que solo encendern
si estn correctamente polarizados. El terminal ms largo es el
positivo y deber estar conectado al pin elegido. El terminal corto
debe conectarse con la tierra (GND), la capsula del LED tiene un
borde plano en este extremo. Si el LED no enciende, trata de
conectarlo de manera opuesta, intercambiando los terminales de
posicin (no daaras el LED si lo conectas en sentido opuesto).
FabLab Len
17
6.1.1 Cdigo
El cdigo de ejemplo es sencillo:
/*
Bli n k
T u r n s o n a n L ED o n f o r o n e se co n d , t h e n o f f f o r on e se co nd ,
r e p e a t edl y.
T hi s e xa mp l e co d e i s i n t h e p u bli c do ma i n .
*/
vo i d se t u p () {
/ / ini ti al i ze t h e d igi t al pi n a s a n o ut pu t .
/ / Pi n 1 2 h a s a n L ED co n n e ct e d o n mo st Ar d u i n o b o a rd s:
p i n Mo d e( 1 2 , O UT PUT ) ;
}
vo i d l oo p () {
d i gi talW rit e ( 12 , HI G H ) ;
d e la y ( 1 00 0 ) ;
//
d i gi talW rit e ( 12 , L OW ) ;
d e la y ( 1 00 0 ) ;
//
}
/ / se t t h e
wa i t fo r a
/ / set t h e
wa i t fo r a
LED o n
se co n d
LED o f f
se co n d
6.1.2 Circuito
FabLab Len
18
6.1.3 Montaje en Protoboard
6.1.4 Ejercicio 1:
Construir y programar una tira de 5 Leds que simule el efecto
coche fantstico
FabLab Len
19
6.2 Botones o pulsadores

Los pulsadores o switches conectan dos puntos de un circuito al
ser pulsados.
Conecta tres cables a la placa Arduino. Los dos primeros, rojo y
negro, conectan a las dos hileras largas verticales de los laterales de
la placa universal (breadboard ) para proporcionar acceso a la fuente
de 5 voltios y a masa (ground). El tercer cable va desde el pin digital
2 a una patilla del pulsador. Esa misma patilla del pulsador se
conecta a travs de una resistencia pull-down (en este caso 10
KOhms) a masa. El otro extremo del pulsador se conecta a la fuente
de 5 voltios.
Cuando el pulsador est abierto (sin pulsar) no hay conexin
entre las dos patas del pulsador, de forma que el pin est conectado
a tierra (a travs de la resistencia pull-down) y leemos un LOW (bajo
0). Cuando el botn se cierra (pulsado), se establece la unin entre
sus dos extremos, conectando el pin a 5 voltios, por lo que leemos un
HIGH (alto 1).
Tambin puedes cablear el circuito en sentido contrario, con
una resistencia "pull-up" que mantenga la entrada en HIGH, y que
pase a LOW cuando se pulse el botn. As, el comportamiento del
programa (sketch) se invertir, con el LED normalmente encendido y
apagado cuando se pulsa el botn.
Si se desconectas el pin digital de E/S del todo, el LED puede
parpadear de forma errtica. Esto se debe a la entrada es "flotante",
es decir, al azar se tornar en HIGH o LOW. Por eso se necesita la
resistencia pull-up o pull-down en el circuito.
Combinando el primer ejemplo y este podemos controlar el led
con el pulsador.
FabLab Len
20
6.2.1 Cdigo
No te preocupes si ahora no comprendes todo el cdigo, basta
con que sepas modificar alguna parte y veas lo que va sucediendo.
/*
Bu t t o n
*/
/ / co n st a n t s wo n ' t ch a n g e . T h e y' r e u s e d h e r e t o
/ / se t pi n nu mb e r s:
co n st in t b u tt o n Pin = 2 ;
/ / t h e n u mb e r o f th e p u shb u t t o n pi n
co n st in t l e d Pi n = 1 2;
/ / t h e n u mb e r o f t he L ED pi n
/ / va ri a bl e s will ch an g e :
i n t bu t t o n St a te = 0 ;
st a t u s
/ / vari a bl e fo r r e ad in g t h e p u sh bu t t o n
/ / ini ti al i ze t h e L ED p in a s a n o u t p u t:
p i n Mo d e(l e d Pi n , O UT PUT) ;
/ / ini ti al i ze t h e p u sh b u tt o n pi n a s a n i n pu t :
p i n Mo d e( b u t to n Pi n, I NPUT ) ;
}
vo i d l oo p () {
/ / r e a d t h e st at e o f th e p u shb u t t o n va l u e:
b u t t o n St a t e = di gi t al Re a d( b u t t on Pi n) ;
/ / ch e ck i f t he p u shb u t t o n i s p r e ssed.
/ / if i t i s, t h e b u t t o n St at e i s HI G H:
i f ( b u t t on St a t e == HI G H) {
/ / t u rn L ED o n :
di gi t alW ri t e (le d Pin , HI G H) ;
}
e l se {
/ / t u rn L ED o f f :
di gi t alW ri t e (le d Pin , L OW ) ;
}
}
6.2.2 Circuito
FabLab Len
21
6.2.3 Montaje en Protoboard
FabLab Len
22
6.2.4 Ejercicio 2:
A partir del ejercicio 1 hacer que la tira de leds se detenga al
pulsar el botn.
6.2.5 Ejercicio 3 complementario:
Con los montajes anteriores colocar 2 pulsadores uno que
encienda el efecto coche fantstico y otro que lo apague.
Pginas web de consulta:

http://www.arduino.cc/
http://www.fablableon.org/
http://www.arduinoacademy.com/
Si tienes alguna duda pregntame:

Arduino y electrnica Fab Lab Len: David Benitez
david.beneitez@fablableon.org
FabLab Len
23
7 Anexo: Gua de lenguaje Arduino.

7.1 Funciones
Una funcin es un bloque de cdigo que tiene un nombre y un conjunto de
instrucciones que son ejecutadas cuando se llama a la funcin. Son funciones
setup() y loop() de las que ya se ha hablado. Las funciones de usuario pueden ser
escritas para realizar tareas repetitivas y para reducir el tamao de un programa.
Las funciones se declaran asociadas a un tipo de valor. Este valor ser el que
devolver la funcin, por ejemplo 'int' se utilizara cuando la funcin devuelva un
dato numrico de tipo entero. Si la funcin no devuelve ningn valor entonces se
colocara delante la palabra void, que significa funcin vaca. Despus de
declarar el tipo de dato que devuelve la funcin se debe escribir el nombre de la
funcin y entre parntesis se escribirn, si es necesario, los parmetros que se
deben pasar a la funcin para que se ejecute.
t i p o n o mb r e F u n ci n (p a r me t r o s)
{
}
La funcin siguiente devuelve un numero entero, delayVal() se utiliza para
poner un valor de retraso en un programa que lee una variable analgica de un
potencimetro conectado a una entrada de Arduino. Al principio se declara como
una variable local, v recoge el valor ledo del potencimetro que estar
comprendido entre 0 y 1023, luego se divide el valor por 4 para ajustarlo a un
margen comprendido entre 0 y 255, finalmente se devuelve el valor v y se
retornara al programa principal.
i n t del a yVal ( )
{
i n t v; / / cr ea u n a va ri a bl e te mp o r a l ' v'
v= a n a lo g Re a d( p o t ); / / l e e e l val o r del p o te n ci me t r o
v / = 4 ; / / co n vi er t e 0 - 1 0 2 3 a 0 -2 5 5
r e t u r n v; / / d e vu el ve el val or fi n al
}
7.2 {} entre llaves

Las llaves sirven para definir el principio y el final de un bloque de
instrucciones. Se utilizan para los bloques de programacin setup(), loop(), if.., etc.
t yp e f u n ci n( )
{
}
FabLab Len
24

Una llave de apertura { siempre debe ir seguida de una llave de cierre
}, si no es as el compilador dar errores. El entorno de programacin de Arduino
incluye una herramienta de gran utilidad para comprobar el total de llaves. Solo
tienes que
hacer
clic
en
el
punto de
insercin
de
una llave
abierta e
inmediatamente se marca el correspondiente cierre de ese bloque (llave cerrada).
7.3 ; punto y coma

El punto y coma ; se utiliza para separar instrucciones en el lenguaje de
programacin de Arduino. Tambin se utiliza para separar elementos en una
instruccin de tipo bucle for.
i n t x = 1 3 ; / / de cl a r a l a va ri a bl e ' x' como t i p o
/ / e n t e ro d e val or 1 3
Nota: Si olvidis poner fin a una lnea con un punto y coma se producir en
un error de compilacin. El texto de error puede ser obvio, y se referir a la falta de
un punto y coma, o puede que no. Si se produce un error raro y de difcil deteccin
lo primero que debemos hacer es comprobar que los puntos y comas estn
colocados al final de las instrucciones.
7.4 /* */ bloque de comentarios

Los bloques de comentarios, o comentarios multi-linea son reas de texto
ignorados por el programa que se utilizan para las descripciones del cdigo o
comentarios que ayudan a comprender el programa. Comienzan con / * y terminan
con * / y pueden abarcar varias lneas.
/ * e st o e s u n bl oq u e de co me n t a r i o no se d e b e ol vid a r
ce r r a r lo s co me n t a r i o s e st o s d eb e n est a r e q uili br a d o s */
Debido a que los comentarios son ignorados por el compilador y no ocupan
espacio en la memoria de Arduino pueden ser utilizados con generosidad. Tambin
pueden utilizarse para "comentar" bloques de cdigo con el propsito de anotar
informaciones para depuracin y hacerlo ms comprensible para cualquiera.
Nota: Dentro de una misma lnea de un bloque de comentarios no se puede
escribir otra bloque de comentarios (usando /*..*/).
7.5 // lnea de comentarios

Una lnea de comentario empieza con / / y terminan con la siguiente lnea de
cdigo. Al igual que los comentarios de bloque, los de lnea son ignoradas por el
programa y no ocupan espacio en la memoria.
/ / Est o e s u n co me n t a ri o
FabLab Len
25

Una lnea de comentario se utiliza a menudo despus de una instruccin,
para proporcionar ms informacin acerca de lo que hace esta o para recordarla
ms adelante.
7.6 Variables
Una variable es una manera de nombrar y almacenar un valor numrico
para su uso posterior por el programa. Como su nombre indica, las variables son
nmeros que se pueden variar continuamente en contra de lo que ocurre con las
constantes cuyo valor nunca cambia. Una variable debe ser declarada y,
opcionalmente, asignarle un valor. El siguiente cdigo de ejemplo declara una
variable llamada variableEntrada y luego le asigna el valor obtenido en la entrada
analgica del PIN2:
i n t vari a bl e En tr a d a = 0 ; / / d e cl ar a u na va ri a bl e y le
/ / a sig n a el valo r 0
va r ia bl e En t r ad a = a n al og Re a d (2 ) ; / / la va ri a bl e r e co g e
/ / e l va lo r an al gi co de l PI N2
'variableEntrada' es la variable en s. La primera lnea declara que ser de
tipo entero int. La segunda lnea fija a la variable el valor correspondiente a la
entrada analgica PIN2. Esto hace que el valor de PIN2 sea accesible en otras
partes del cdigo. Una vez que una variable ha sido asignada, o re-asignada, usted
puede probar su valor para ver si cumple ciertas condiciones, o puede utilizar
directamente su valor. Como ejemplo ilustrativo veamos tres operaciones tiles con
variables: el siguiente cdigo prueba si la variable entradaVariable es inferior a
100, si es cierto se asigna el valor 100 a entradaVariable y, a continuacin,
establece un retardo (delay) utilizando como valor entradaVariable que ahora
ser como mnimo de valor 100:
i f (e n t r ad a Va ri a bl e < 1 0 0 ) / / p re g u n t a si l a vari a bl e e s
{ / / me n o r d e 1 0 0
e n t r a d a Vari a bl e = 1 00 ; / / si e s ci er t o a si g na el val or
} //100
d e l a y( e n tr a d a Va ria bl e ) ; // u sa el va lor co mo r e t a r d o
Nota: Las variables deben tomar nombres descriptivos, para hacer el cdigo
ms legible. Los nombres de variables pueden ser contactoSensor o pulsador
, para ayudar al programador y a cualquier otra persona a leer el cdigo y
entender lo que representa la variable. Nombres de variables como var o
valor, facilitan muy poco que el cdigo sea inteligible. Una variable puede ser
cualquier nombre o palabra que no sea una palabra reservada en el entorno de
Arduino.
FabLab Len
26
7.7 Declaracin de variables

Todas las variables tienen que declararse antes de que puedan ser
utilizadas. Para declarar una variable se comienza por definir su tipo como int
(entero), long (largo), float (coma flotante), etc., asignndoles siempre un nombre,
y, opcionalmente, un valor inicial. Esto solo debe hacerse una vez en un programa,
pero el valor se puede cambiar en cualquier momento usando aritmtica y
reasignaciones diversas.
El siguiente ejemplo declara la variable entradaVariable como una variable
de tipo entero int, y asignndole un valor inicial igual a cero. Esto se llama una
asignacin.
i n t en t r ad a Va ri a bl e = 0;
Una variable puede ser declarada en una serie de lugares del programa y en
funcin del lugar en donde se lleve a cabo la definicin esto determinara en que
partes del programa se podr hacer uso de ella.
7.8 utilizacin de una variable

Una variable puede ser declarada al inicio del programa antes de la parte de
configuracin setup(), a nivel local dentro de las funciones, y, a veces, dentro de un
bloque, como para los bucles del tipo if.. for.., etc. En funcin del lugar de
declaracin de la variable as se determinara el mbito de aplicacin, o la capacidad
de ciertas partes de un programa para hacer uso de ella.
Una variable global es aquella que puede ser vista y utilizada por cualquier
funcin y estamento de un programa. Esta variable se declara al comienzo del
programa, antes de setup().
Una variable local es aquella que se define dentro de una funcin o como
parte de un bucle. Solo es visible y solo puede utilizarse dentro de la funcin en la
que se declar.
Por lo tanto, es posible tener dos o ms variables del mismo nombre en
diferentes partes del mismo programa que pueden contener valores diferentes. La
garanta de que solo una funcin tiene acceso a sus variables dentro del programa
simplifica y reduce el potencial de errores de programacin.
El siguiente ejemplo muestra como declarar a unos tipos diferentes de
variables y la visibilidad de cada variable:
i n t valu e ; / / ' val u e' e s vi si bl e pa r a cua l q uie r
f u n ci n
vo i d se t u p ()
{
FabLab Len
27

/ / n o e s ne ce sa ri o co n fi g ur a r na d a e n e st e e je mp l o
}
vo i d l oo p ()
{
f o r (i n t i =0 ; i <20 ; ) / / 'i ' so lo e s vi si bl e
{ / / d e n tr o d el b u cl e f or
i ++
} / / ' f' e s vi si bl e so lo
f l o a t f ; / / de n t r o d e l o op ( )
}
7.9 Tipos de datos

7.9.1 Byte
Byte almacena un valor numrico de 8 bits sin decimales. Tienen un rango
entre 0 y 255.
b yt e u n a Va ri abl e = 1 8 0 ; / / d e cl ar a 'u na Va r i abl e ' co mo
/ / d e ti p o b y t e
7.9.2 Int
Enteros son un tipo de datos primarios que almacenan valores numricos de
16 bits sin decimales comprendidos en el rango 32,767 to -32,768.
i n t u n a Vari a bl e = 1 50 0 ; / / d e cl a r a ' u na Va r i abl e ' co mo

/ / u n a var ia bl e d e ti p o e nt e r o
Nota: Las variables de tipo entero int pueden sobrepasar su valor
mximo o mnimo como consecuencia de una operacin. Por ejemplo, si x = 32767
y una posterior declaracin agrega 1 a x, x = x + 1 entonces el valor se x pasara a
ser -32.768. (algo as como que el valor da la vuelta).
7.9.3 Long
El formato de variable numrica de tipo extendido long se refiere a
nmeros enteros (tipo 32 bits) sin decimales que se encuentran dentro del rango 2147483648 a 2147483647.
l o n g u n a Va ri abl e = 9 0 0 00 ; / / de cl a r a 'u n a Va ri a bl e' co mo
/ / d e ti p o l on g
7.9.4 Float
El formato de dato del tipo punto flotante float se aplica a los
nmeros con decimales. Los nmeros de punto flotante tienen una mayor
resolucin que los de 32 bits con un rango comprendido 3.4028235E +38 a +383.4028235E.
FabLab Len
28

f l o a t u n a Va ri abl e = 3 . 1 4; / / d e cl ar a ' un a Va r ia bl e ' co mo
/ / d e ti p o flo t a n t e
Nota: Los nmeros de punto flotante no son exactos, y pueden producir
resultados extraos en las comparaciones. Los clculos matemticos de punto
flotante son tambin mucho ms lentos que los del tipo de nmeros enteros, por lo
que debe evitarse su uso si es posible.
7.9.5 arrays
Un array es un conjunto de valores a los que se accede con un nmero
ndice. Cualquier valor puede ser recogido haciendo uso del nombre de la matriz y
el nmero del ndice. El primer valor de la matriz es el que est indicado con el
ndice 0, es decir el primer valor del conjunto es el de la posicin 0. Un array tiene
que ser declarado y opcionalmente asignados valores a cada posicin antes de ser
utilizado.
i n t mi Ar r a y[ ] = { val o r 0, val o r 1, val o r2 .. . }
Del mismo modo es posible declarar una matriz indicando el

tipo de datos y el tamao y posteriormente, asignar valores a una
posicin especifica:
i n t mi Ar r a y[ 5 ]; / / d e cla r a un a rr a y d e e n t e r o s d e 6
/ / p o si cio n e s
mi Ar r a y[ 3 ] = 1 0 ; / / a s i gn a l val or 1 0 a l a po si ci n 4
Para leer de un array basta con escribir el nombre y la posicin a leer:
x = mi Ar r a y[ 3 ] ; / / x a h o r a e s i gu al a 10 q u e e st e n
/ / l a p o si ci n 3 d el a rr a y
Las matrices se utilizan a menudo para estamentos de tipo bucle, en los que
la variable de incremento del contador del bucle se utiliza como ndice o puntero del
array. El siguiente ejemplo usa una matriz para el parpadeo de un LED. Utilizando
un bucle tipo for, el contador comienza en cero 0 y escribe el valor que figura en la
posicin de ndice 0 en la serie que hemos escrito dentro del array parpadeo[], en
este caso 180, que se enva a la salida analgica tipo PWM configurada en el PIN10,
se hace una pausa de 200 ms y a continuacin se pasa al siguiente valor que
asigna el ndice i.
i n t l ed Pi n = 1 0 ; / / L ED e n el PI N 1 0
b yt e p a rp a d e o [] = { 1 8 0, 3 0 , 25 5 , 2 00 , 1 0 , 9 0 , 1 5 0 , 6 0} ;
/ / a r r a y d e 8 va lo r e s
vo i d se t u p ()
{
p i n Mo d e( le d Pin , O UT PUT) ; / / con fi g ur a l a sali d a
}
FabLab Len
29

vo i d l oo p ()
{
f o r (i n t i =0 ; i <7 ; i ++)
{
a n a lo gW ri t e( le d Pin , p ar p a d e o[ i] ) ;
d e l a y( 2 0 0) ; / / e sp e r a 2 0 0 ms
}
}
7.10 aritmtica
Los operadores aritmticos que se incluyen en el entorno de programacin
son suma, resta, multiplicacin y divisin. Estos devuelven la suma, diferencia,
producto, o cociente (respectivamente) de dos operandos.
y = y + 3; x = x - 7; i = j * 6; r = r / 5;
La operacin se efecta teniendo en cuenta el tipo de datos que hemos
definido para los operandos (int, dbl, float, etc..), por lo que, por ejemplo, si
definimos 9 y 4 como enteros int, 9 / 4 devuelve de resultado 2 en lugar de
2,25 ya que el 9 y 4 se valores de tipo enteroint (enteros) y no se reconocen
los decimales con este tipo de datos.
Esto tambin significa que la operacin puede sufrir un desbordamiento si el
resultado es ms grande que lo que puede ser almacenada en el tipo de datos.
Recordemos el alcance de los tipos de datos numricos que ya hemos explicado
anteriormente. Si los operandos son de diferentes tipos, para el clculo se utilizara
el tipo ms grande de los operandos en juego. Por ejemplo, si uno de los nmeros
(operandos) es del tipo float y otra de tipo integer, para el clculo se utilizara el
mtodo de float es decir el mtodo de coma flotante.
Elija el tamao de las variables de tal manera que sea lo suficientemente
grande como para que los resultados sean lo precisos que usted desea. Para las
operaciones que requieran decimales utilice variables tipo float, pero sea consciente
de que las operaciones con este tipo de variables son ms lentas a la hora de
realizarse el cmputo.
Nota: Utilice el operador (int) para convertir un tipo de variable a otro sobre
la marcha. Por ejemplo, i = (int) 3,6 establecer i igual a 3.
7.11 asignaciones compuestas

Las asignaciones compuestas combinan una operacin aritmtica con una
variable asignada. Estas son comnmente utilizadas en los bucles tal como se
describe mas adelante. Estas asignaciones compuestas pueden ser:
x ++ / / i g u al q u e x = x +1 , o i n cre me n t o d e x e n +1
x - - / / i gu al q u e x = x - 1 , o d e cre me n t o d e x e n - 1
FabLab Len
30

x
x
x
x
+= y / / i g u al q u e x = x + y, o i n cre me n t o d e x e n +y
- = y / / i g u al qu e x = x - y, o d e cr e me n t o d e x e n - y
* = y / / i g u al q u e x = x * y, o mu l t i plica x p o r y
/ = y / / i g u al q ue x = x / y, o d i vi d e x p o r y
Nota: Por ejemplo, x * = 3 hace que x se convierta en el triple del antiguo

valor x y por lo tanto x es reasignada al nuevo valor.
7.12 operadores de comparacin

Las comparaciones de una variable o constante con otra se utilizan con
frecuencia en las estructuras condicionales del tipo if.. para testear si una condicin
es verdadera. En los ejemplos que siguen en las prximas pginas se ver su
utilizacin prctica usando los siguientes tipo de condicionales:
x
x
x
x
x
x
== y / / x e s i g u al a y
! = y / / x n o e s ig u al a y
< y / / x e s me n o r q u e y
> y / / x e s ma yo r q u e y
<= y / / x e s me n o r o i gu a l q u e y
>= y / / x e s ma yo r o i g ual q u e y
7.13 operadores lgicos

Los operadores lgicos son usualmente una forma de comparar dos
expresiones y devolver un VERDADERO o FALSO dependiendo del operador. Existen
tres operadores lgicos, AND (&&), OR (||) y NOT (!), que a menudo se utilizan en
estamentos de tipo if: Lgica AND:
i f ( x > 0 && x < 5 ) / / ci er t o sl o si l a s d o s
e xp r e si o n e s / / so n ci er t a s
Lgica OR:
i f ( x > 0 || y > 0 ) / / ci e r to si u n a cu al qu i er a d e la s
/ / e xp r e si on e s e s ci er t a
Lgica NOT:
i f (! x > 0 ) / / cie r t o so lo si l a e xp r e si n e s
/ / f al sa
7.14 constantes
El
lenguaje
de
programacin
de
Arduino
tiene
unos
valores
predeterminados, que son llamados constantes. Se utilizan para hacer los

programas ms fciles de leer. Las constantes se clasifican en grupos.
FabLab Len
31
7.15 cierto/falso (true/false)

Estas son constantes booleanas que definen los niveles HIGH (alto) y LOW
(bajo) cuando estos se refieren al estado de las salidas digitales. FALSE se asocia
con 0 (cero), mientras que TRUE se asocia con 1, pero TRUE tambin puede ser
cualquier otra cosa excepto cero. Por lo tanto, en sentido booleano, -1, 2 y -200
son todos tambin se definen como TRUE. (esto es importante tenerlo en cuanta).
i f (b == T RUE) ;
{
e je cu t a r l a s in st r u cci o ne s;
}
7.16 High/Low
Estas constantes definen los niveles de salida altos o bajos y se utilizan para
la lectura o la escritura digital para las patillas. ALTO se define como en la lgica de
nivel 1, ON, o 5 voltios, mientras que BAJO es lgica nivel 0, OFF, o 0 voltios.
d i gi t alW rit e ( 1 3, HI G H) ; / / a cti va l a sal i d a 1 3 co n u n
/ / n i ve l al t o (5 v. )
7.17 Input/Output
Estas constantes son utilizadas para definir, al comienzo del programa, el
modo de funcionamiento de los pines mediante la instruccin pinMode de tal
manera que el pin puede ser una entrada INPUT o una salida OUTPUT.
p i n Mo d e( 1 3 , O UT PUT ) ; / / d e si g n a mo s q u e el PI N 1 3 e s
/ / u n a sali d a
7.18 Control de flujo

7.18.1
if (si condicional)
if es un estamento que se utiliza para probar si una determinada condicin

se ha alcanzado, como por ejemplo averiguar si un valor analgico est por encima
de un cierto nmero, y ejecutar una serie de declaraciones (operaciones) que se
escriben dentro de llaves, si es verdad. Si es falso (la condicin no se cumple) el
programa salta y no ejecuta las operaciones que estn dentro de las llaves, El
formato para if es el siguiente:
i f (u n a Va ri ab le ? ? val or )
{
e je cu t a I n st r u cci o n e s ;
}
En el ejemplo anterior se compara una variable con un valor, el cual puede
ser una variable o constante. Si la comparacin, o la condicin entre parntesis se
FabLab Len
32

cumple (es cierta), las declaraciones dentro de los corchetes se ejecutan. Si no es
as, el programa salta sobre ellas y sigue.
Nota: Tenga en cuenta el uso especial del smbolo '=', poner dentro de if (x
= 10), podra parecer que es vlido pero sin embargo no lo es ya que esa expresin
asigna el valor 10 a la variable x, por eso dentro de la estructura if se utilizara
X==10 que en este caso lo que hace el programa es comprobar si el valor de x es
10.. Ambas cosas son distintas por lo tanto dentro de las estructuras if, cuando se
pregunte por un valor se debe poner el signo doble de igual ==.
7.18.2
if else (si.. sino ..)
if else viene a ser un estructura que se ejecuta en respuesta a la idea si

esto no se cumple haz esto otro. Por ejemplo, si se desea probar una entrada
digital, y hacer una cosa si la entrada fue alto o hacer otra cosa si la entrada es
baja, usted escribira que de esta manera:
i f (in p u t Pi n == HI G H)
{
i n str u cci o n e sA;
}
e l se
{
i n str u cci o n e sB;
}
Else puede ir precedido de otra condicin de manera que se pueden
establecer varias estructuras condicionales de tipo unas dentro de las otras
(anidamiento) de forma que sean mutuamente excluyentes pudindose ejecutar a
la vez. Es incluso posible tener un nmero ilimitado de estos condicionales.
Recuerde sin embargo que solo un conjunto de declaraciones se llevara a cabo
dependiendo de la condicin probada:
i f (in p u t Pi n < 5 0 0)
{
i n str u cci o n e sA;
}
e l se i f (i n p u t Pi n >= 1 00 0 )
{
i n str u cci o n e sB;
{
e l se
{
i n str u cci o n e sC ;
}
Nota: Un estamento de tipo if prueba simplemente si la condicin dentro del
parntesis es verdadera o falsa. Esta declaracin puede ser cualquier declaracin
valida. En el anterior ejemplo, si cambiamos y ponemos (inputPin == HIGH). En
FabLab Len
33

este caso, el estamento if solo comprobara si la entrada especificada esta en nivel
alto (HIGH), o +5v.
7.18.3
for
La declaracin for se usa para repetir un bloque de sentencias encerradas

entre llaves un nmero determinado de veces. Cada vez que se ejecutan las
instrucciones del bucle se vuelve a testear la condicin. La declaracin for tiene tres
partes separadas por (;), vemos el ejemplo de su sintaxis:
f o r (i ni ci ali za ci n; co n di ci n ; e xp r e si n )
{
I n st r u cci o n e s;
}
La inicializacin de una variable local se produce una sola vez y la condicin
se testea cada vez que se termina la ejecucin de las instrucciones dentro del
bucle. Si la condicin sigue cumplindose, las instrucciones del bucle se vuelven a
ejecutar. Cuando la condicin no se cumple, el bucle termina.
El siguiente ejemplo inicia el entero i en el 0, y la condicin es probar que el
valor es inferior a 20 y si es cierto i se incrementa en 1 y se vuelven a ejecutar las
instrucciones que hay dentro de las llaves:
f o r (i n t i =0 ; i <20 ; i ++) / / d e cla r a i y p ru e b a si e s
{ / / me n o r q u e 2 0 , i n cr e me n t a i .
d i gi t alW rit e ( 1 3, HI G H) ; / / e n ci e n de el p i n 1 3
d e l a y( 2 5 0) ; / / e sp e r a se g .
d i gi t alW rit e ( 1 3, L OW ) ; // a p a ga el pi n 1 3
d e l a y( 2 5 0) ; / / e sp e r a d e se g .
}
Nota: El bucle en el lenguaje C es mucho ms flexible que otros bucles
encontrados en algunos otros lenguajes de programacin, incluyendo BASIC.
Cualquiera de los tres elementos de cabecera puede omitirse, aunque el punto y
coma es obligatorio. Tambin las declaraciones de inicializacin, condicin y
expresin puede ser cualquier estamento valido en lenguaje C sin relacin con las
variables declaradas. Estos tipos de estados son raros pero permiten disponer
soluciones a algunos problemas de programacin raras.
7.18.4
while
Un bucle del tipo while es un bucle de ejecucin continua mientras se

cumpla la expresin colocada entre parntesis en la cabecera del bucle. La variable
de prueba tendr que cambiar para salir del bucle. La situacin podr cambiar a
expensas de una expresin dentro el cdigo del bucle o tambin por el cambio de
un valor en una entrada de un sensor.
FabLab Len
34

wh i l e ( u n a Va ri ab le ? ? v alo r )
{
e je cu t a r Se n t e n ci a s;
}
El siguiente ejemplo testea si la variable "unaVariable es inferior a 200 y,
si es verdad, ejecuta las declaraciones dentro de los corchetes y continuara
ejecutando el bucle hasta que 'unaVariable' no sea inferior a 200.
W hil e (u n a Va ri a ble < 2 0 0) / / t e ste a si e s me n o r q u e 2 0 0
{
i n str u cci o n e s; / / e je cu t a l a s i n st ru ccio n e s
/ / e n t r e ll a ve s
u n a Va ri a bl e ++; / / i n cr e me n t a l a vari ab l e e n 1
}
7.18.5
do while
El bucle do while funciona de la misma manera que el bucle while, con la

salvedad de que la condicin se prueba al final del bucle, por lo que el bucle
siempre se ejecutara al menos una vez.
do
{
I n st r u cci o n e s;
} wh i l e ( u na Va ri a bl e ?? val o r) ;
El siguiente ejemplo asigna el valor ledo leeSensor() a la variable 'x', espera
50 milisegundos, y luego contina mientras que el valor de la 'x' sea inferior a 100:
do
{
x = l e e Se n so r () ;
d e l a y( 5 0) ;
} wh i l e ( x < 1 0 0 ) ;
7.19 e/s digitales

7.19.1
pinMode(pin, mode)
Esta instruccin es utilizada en la parte de configuracin setup () y sirve

para configurar el modo de trabajo de un PIN pudiendo ser INPUT (entrada) u
OUTPUT (salida).
p i n Mo d e( pi n , O UT PUT ) ; / / co n fi g ur a p i n co mo sa li d a
Los terminales de Arduino, por defecto, estn configurados como entradas,
por lo tanto no es necesario definirlos en el caso de que vayan a trabajar como
entradas. Los pines configurados como entrada quedan, bajo el punto de vista
elctrico, como entradas en estado de alta impedancia. Estos pines tienen a nivel
interno una resistencia de 20 K a las que se puede acceder mediante software.
Estas resistencias se acceden de la siguiente manera:
FabLab Len
35

p i n Mo d e( pi n , I NPUT ); / / co n fig u r a e l p i n co mo
/ / e n t r ad a
d i gi t alW rit e ( pi n , HI G H) ; / / a cti va l a s re si st en cia s
/ / i nt e r n a s
Las resistencias internas normalmente se utilizan para conectar las entradas
a interruptores. En el ejemplo anterior no se trata de convertir un pin en salida, es
simplemente un mtodo para activar las resistencias interiores. Los pines
configurado como OUTPUT (salida) se dice que estn en un estado de baja
impedancia estado y pueden proporcionar 40 mA (miliamperios) de corriente a
otros dispositivos y circuitos. Esta corriente es suficiente para alimentar un diodo
LED (no olvidando poner una resistencia en serie), pero no es lo suficiente grande
como para alimentar cargas de mayor consumo como rels, solenoides, o motores.
Un cortocircuito en las patillas Arduino provocara una corriente elevada que
puede daar o destruir el chip Atmega. A menudo es una buena idea conectar en la
OUTUPT (salida) una resistencia externa de 470 o de 1000 .
7.19.2
digitalRead(pin)
Lee el valor de un pin (definido como digital) dando un resultado HIGH (alto)
o LOW (bajo). El pin se puede especificar ya sea como una variable o una constante
(0-13).
va l or = di gi t al Re a d( Pin ) ; / / h a ce qu e 'va l or se a i gu al
/ / a l e st a d o le d o en Pi n
7.19.3
digitalWrite(pin, value)
Enva al pin definido previamente como OUTPUT el valor HIGH o LOW

(poniendo en 1 o 0 la salida). El pin se puede especificar ya sea como una variable
o como una constante (0-13).
d i gi t alW rit e ( pi n , HI G H) ; / / d e p o s i t a e n e l ' pi n ' u n
va l or / / HI G H ( al t o o 1 )
El siguiente ejemplo lee el estado de un pulsador conectado a una entrada
digital y lo escribe en el pinde salida LED:
i n t l ed = 1 3 ; / / a si g n a a L ED el val o r 1 3
i n t bo t o n = 7 ; / / a si g na a b o t n el valo r 7
i n t v alo r = 0 ; // d e fi n e el val o r y le a sig n a el
/ / va lo r 0
vo i d se t u p ()
{
p i n Mo d e( le d , O UT PUT ) ; / / co n fi g ur a el l e d ( pi n 1 3) co mo
sa li d a
p i n Mo d e( b o t o n, I NPUT ) ; / / co n fi g ur a b o t n (p in 7 ) co mo
entrada
}
vo i d l oo p ()
FabLab Len
36

{
va l or = di gi t al Re a d( b o to n ) ; / /le e el e st a d o d e l a
/ / e n t r ad a b o t n
d i gi t alW rit e (l e d , val o r) ; / / e n v a a l a sa li d a l e d el
} / / val o r le d o
7.20 E/s analgicas

7.20.1
analogRead(pin)
Lee el valor de un determinado pin definido como entrada analgica con una
resolucin de 10 bits. Esta instruccin solo funciona en los pines (0-5). El rango de
valor que podemos leer oscila de 0 a 1023.
va l or = a n al o g Re a d (p in ) ; / / a si g n a a va l or l o q ue l e e
/ / e n l a e nt r a d a pi n'
Nota: Los pines analgicos (0-5) a diferencia de los pines digitales, no
necesitan ser declarados como INPUT u OUPUT ya que son siempre Inputs.
7.20.2
analogWrite(pin, value)
Esta instruccin sirve para escribir un pseudo-valor analgico utilizando el

procedimiento de modulacin por ancho de pulso (PWM) a uno de los pines de
Arduino marcados como pin PWM. El ms reciente Arduino, que implementa el
chip ATmega168, permite habilitar como salidas analgicas tipo PWM los pines 3, 5,
6, 9, 10 y
11. Los modelos de Arduino ms antiguos que implementan el chip
ATmega8, solo tiene habilitadas para esta funcin los pines 9, 10 y 11. El valor que
se puede enviar a estos pines de salida analgica puede darse en forma de variable
o constante, pero siempre con un margen de 0-255.
a n a lo gW ri t e( pi n , val or ) ; / / e scri b e ' valo r ' e n el ' pin '
/ / d e fi ni d o co mo a n al gi co
Si enviamos el valor 0 genera una salida de 0 voltios en el pin especificado;
un valor de 255 genera una salida de 5 voltios de salida en el pin especificado. Para
valores de entre 0 y 255, el pin saca tensiones entre 0 y 5 voltios - el valor HIGH
de salida equivale a 5v (5 voltios). Teniendo en cuenta el concepto de seal PWM,
por ejemplo, un valor de 64 equivaldr a mantener 0 voltios de tres cuartas partes
del tiempo y 5 voltios a una cuarta parte del tiempo; un valor de 128 equivaldr a
mantener la salida en 0 la mitad del tiempo y 5 voltios la otra mitad del tiempo, y
un valor de 192 equivaldr a mantener en la salida 0 voltios una cuarta parte del
tiempo y de 5 voltios de tres cuartas partes del tiempo restante. Debido a que esta
es una funcin de hardware, en el pin de salida analgica (PWN) se generara una
onda constante despus de ejecutada la instruccin analogWrite hasta que se llegue
FabLab Len
37

a ejecutar otra instruccin analogWrite (o una llamada a digitalRead o digitalWrite
en el mismo pin).
Nota: Las salidas analgicas a diferencia de las digitales, no necesitan ser
declaradas como INPUT u OUTPUT..
El siguiente ejemplo lee un valor analgico de un pin de entrada analgica,
convierte el valor dividindolo por 4, y enva el nuevo valor convertido a una salida
del tipo PWM o salida analgica:
i n t l ed = 1 0 ; / / d e fi n e e l pi n 1 0 co mo l e d
i n t an al o g = 0 ; / / d e fi ne el pi n 0 co mo a n al o g
i n t valo r ; / / d e fi n e l a va ri a bl e val or
vo i d se t u p () { } / / n o e s n e ce sari o co n fig u r a r
/ / e n t r ad a s y sali d a s
vo i d l oo p ()
{
va l or = a n al o g Re a d (a n al o g) ; / / l e e el p i n 0 y l o
a so ci a a / /l a vari a bl e valo r
va l or / = 4 ; / /d i vid e val o r e n t re 4 y l o
/ / r e a si g n a a val o r
a n a lo gW ri t e( le d , val ue ) ; / / e scri b e e n e l pi n1 0 val or
}
7.21 Control del tiempo

7.21.1
delay(ms)
Detiene la ejecucin del programa la cantidad de tiempo en ms

que se indica en la propia instruccin. De tal manera que 1000
equivale a 1seg.
d e l a y( 1 0 00 ) ; / / e sp e ra 1 se gu n d o
7.21.2
millis()
Devuelve el nmero de milisegundos transcurrido desde el inicio del

programa en Arduino hasta el momento actual. Normalmente ser un valor grande
(dependiendo del tiempo que est en marcha la aplicacin despus de cargada o
despus de la ltima vez que se pulso el botn reset de la tarjeta).
va l or = mi lli s( ) ; / / val o r r e co ge el n me r o d e
/ / mi l i se g u n do s
Nota: Este nmero se desbordara (si no se resetea de nuevo a cero),
despus de aproximadamente 9 horas.
FabLab Len
38
7.22 Matemticas
7.22.1
min(x, y)
Calcula el mnimo de dos nmeros para cualquier tipo de datos devolviendo

el nmero ms pequeo.
va l or = mi n ( val o r , 10 0 ) ; / / a si g n a a val o r el m s
/ / p e q u e o s d e l o s d o s
/ / n me r o s e sp e ci fi ca d o s.
Si 'valor' es menor que 100 valor recoger su propio valor si valor es
mayor que 100 valor pasara a valer 100.
7.22.2
max(x, y)
Calcula el mximo de dos nmeros para cualquier tipo de datos devolviendo

el nmero mayor de los dos.
va l or = ma x( va l o r , 1 0 0 ) ; / / a si g na a va l or el ma yo r d e
/ / l o s d o s n me r o s ' val or ' y
// 100.
De esta manera nos aseguramos de que valor ser como mnimo 100.
7.23 aleatorios
7.23.1
randomSeed(seed)
Establece un valor, o semilla, como punto de partida para la funcin

random().
r a n d o mSe e d ( va l or ) ; / / h a ce qu e val or se a la se mi ll a d el
// random
Debido a que Arduino es incapaz de crear un verdadero numero aleatorio,
randomSeed le permite colocar una variable, constante, u otra funcin de control
dentro de la funcin random, lo que permite generar nmeros aleatorios "al azar".
Hay una variedad de semillas, o funciones, que pueden ser utilizados en esta
funcin, incluido millis () o incluso analogRead () que permite leer ruido elctrico a
travs de un pin analgico.
7.23.2
random(max), random(min, max)
La funcin random devuelve un nmero aleatorio entero de un intervalo de

valores especificado entre los valores min y max.
va l or = r a nd o m( 1 0 0 , 2 0 0 ) ; / / a si g n a a l a vari a bl e
/ / ' val o r' u n n u me r o a l ea t o ri o
/ / co mp r e n d i d o e n t r e 1 0 0 -2 0 0
FabLab Len
39

Nota: Use esta funcin despus de usar el randomSeed().
El siguiente ejemplo genera un valor aleatorio entre 0-255 y lo enva a una
salida analgica PWM :
i n t r a n d Nu mb e r ; / / va ria bl e q ue al ma c e n a el val or
/ / a le a t o rio
i n t l ed = 1 0 ; / / d e fi n e l ed co mo 1 0
vo i d se t u p () { } / / n o e s n e ce sari o co nfi g ur a r na d a
vo i d l oo p ()
{
r a n d o mSe e d ( mi lli s() ) ; / / g e n er a u na se mi l l a p a r a
/ / a le a t o rio a p ar ti r
/ / d e l a f un ci n mi lli s()
r a n d Nu mb e r = r a n d o m( 2 5 5 ) ; / / g e n er a n me r o a l e a t ori o
/ / e n t r e 0 - 2 55
a n a lo gW ri t e( le d , ra n d Nu mb e r ) ; / / e n va a la sali d a
/ / l ed d e ti po PW M el
/ / va lo r
d e l a y( 5 0 0) ; / / e sp e r a 0 , 5 seg .
}
7.24 comunicacin serie

7.24.1
Serial.begin(rate)
Abre el puerto serie y fija la velocidad en baudios para la transmisin de

datos en serie. El valor tpico de velocidad para comunicarse con el ordenador es
9600, aunque otras velocidades pueden ser soportadas.
vo i d se t u p ()
{
Se r i al . be gi n ( 96 0 0 ); / / a br e el Pu er t o se r ie
} / / co n fi gu r a n do l a vel o ci d ad e n 96 00 b p s
Nota: Cuando se utiliza la comunicacin serie los pines digital 0 (RX) y 1
(TX) no puede utilizarse al mismo tiempo.
7.24.2
Serial.println(data)
Imprime los datos en el puerto serie, seguido por un retorno de carro

automtico y salto de lnea. Este comando toma la misma forma que Serial.print(),
pero es mas fcil para la lectura de los datos en el Monitor Serie del software.
Se r i al . pri n tl n (a n al o g Val u e) ; / / e n v a el val or
/ / ' a n al og Va lu e ' a l
/ / p u e r to
Nota: Para obtener ms informacin sobre las distintas posibilidades de
Serial.println () y Serial.print () puede consultarse el sitio web de Arduino.
El siguiente ejemplo toma de una lectura analgica pin0 y enva estos datos
al ordenador cada 1 segundo.
FabLab Len
40

vo i d se t u p ()
{
Se r i al . be gi n ( 96 0 0 ); / / co n fig u r a e l p ue r t o se rie a
// 9600bps
}
vo i d l oo p ()
{
Se r i al . pri n tl n (a n al o g Rea d ( 0) ) ; / / e n va va lo r a nal gi co
d e l a y( 1 0 00 ) ; / / e sp e ra 1 se gu n d o
}
7.24.3
Serial.print(data, data type)
Vuelca o enva un nmero o una cadena de caracteres, al puerto serie. Dicho

comando puede tomar diferentes formas, dependiendo de los parmetros que
utilicemos para definir el formato de volcado de los nmeros.
Parmetros data: el nmero o la cadena de caracteres a volcar o enviar.
Data type: determina el formato de salida de los valores numricos (decimal,
octal, binario, etc...) DEC, OCT, BIN, HEX, BYTE , si no se pone nada vuelca ASCII
Ejemplos:
Se r i al . pri n t (b ) / / Vu el ca o e n va el valo r d e b co mo
/ / u n n me r o d e ci ma l e n ca r a ct e r e s
/ / ASCI I .
int b = 79;
Se r i al . pri n t (b ) ; / / i mp r i me l a ca de n a "7 9 " .
Se r i al . pri n t (b , HEX) ; / / Vu el ca o e n va e l val o r de
/ / b co mo u n n me r o h e xa d e ci ma l
/ / e n ca ra ct e r e s ASCI I " 4 F " .
Se r i al . pri n t (b , O CT) ; / / Vu el ca o e n va e l val o r de
/ / b co mo u n n me r o O ct a l e n
/ / ca r a ct er e s ASCI I " 1 1 7" .
Se r i al . pri n t (b , BI N) / / Vu el ca o e n v a e l val or d e
/ / b co mo u n n me r o b i n a ri o e n
/ / ca r a ct er e s ASCI I " 1 0 01 1 1 1 " .
Se r i al . pri n t (b , BYT E) ; / / De vue l ve el ca r ct e r " O " ,
/ / e l cu al r ep r e sen t a el
/ / ca r ct er ASCI I d el val o r
/ / 7 9 . ( Ve r t a bl a ASCI I ) .
Se r i al . pri n t ( str ) ; // Vu el ca o en v a l a ca d e n a d e
/ / ca r a ct er e s co mo u n a ca d e na ASCI I .
Se r i al . pri n t (" Hel lo W o rl d! ") ; / / vu el ca " He ll o W orl d! " .
7.24.4
Serial.avaible()
Devuelve Un entero con el nmero de bytes disponibles para leer desde el

buffer serie, o 0 si no hay ninguno. Si hay algn dato disponible, SerialAvailable()
ser mayor que 0. El buffer serie puede almacenar como mximo 64 bytes.
i n t Se ria l. a vail a bl e( ) / / Ob ti e n e u n n me r o e n t e r o
/ / co n el n me r o d e b yte s
/ / ( ca r a ct e r e s) di sp o ni ble s
/ / p a r a l ee r o ca p t u ra r d e sd e
/ / e l p u e rt o se ri e
FabLab Len
41

Ejemplo
i n t i n co mi n g Byt e = 0 ; / / al ma ce n a e l da t o se ri e
Se r i al . be gi n ( 96 0 0 ); / / a b r e el pu e r t o se r ie , y l e a si gn a
/ / l a vel o ci d a d d e 9 6 00 b p s
}
vo i d l oo p () {
i f ( Seri al . a vail a bl e( ) > 0) / / e n v a d a tos s l o si
{ / / l o s r e cib e :
i n co mi n g Byt e = Se ri al . re a d () ; / / l e e el b yt e d e e nt r a da :
/ / l o vu el ca a pa n t all a
Se r i al . pri n t (" I r e ce i ve d : ") ;
Se r i al . pri n tl n (in co mi n g Byt e , DEC) ;
}
}
7.24.5
Serial.Read()
Lee o captura un byte (un carcter) desde el puerto serie. Devuelve el

siguiente byte (carcter) desde el puerto serie, o -1 si no hay ninguno.
Ejemplo:
i n t i n co mi n g Byt e = 0 ; / / al ma ce n a r el d a t o se ri e
Se r i al . be gi n ( 96 0 0 ); / / a br e el pu e r t o se r ie , y l e a si gn a
/ / l a vel o ci d a d d e 9 6 00 b p s
}
vo i d l oo p () {
i f ( Seri al . a vail a bl e( ) > 0) / / e n va d a t os s l o si lo s
{ / / r e ci be
i n co mi n g Byt e = Se ri al . re a d () ; / / l ee el b yt e d e
/ / e n t r ad a y l o vue l ca
Se r i al . pri n t (" I r e ce i ve d : ") ; / / a p a n t alla
Se r i al . pri n tl n (in co mi n g Byt e , DEC) ;
}
}
FabLab Len
42

Cursointroarduino

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Cursointroarduino

Uploaded by

Copyright:

Available Formats

Introduccin a Arduino I:

Jugando con Leds y

Taller 1: Introduccin a Arduino. Jugando con Leds y pulsadores

"El verdadero progreso es el que pone la

Taller 1: Introduccin a Arduino. Jugando con Leds y pulsadores

Plataforma electrnica Arduino UNO ...................................... 10

Software de Arduino ........................................................... 12

Estructura bsica de Lenguaje Arduino .................................. 15

Ejemplos a implementar ...................................................... 17

6.1.1 Cdigo ............................................................ 18

Montaje en Protoboard ..................................... 19

6.1.4 Ejercicio 1: ...................................................... 19

Botones o pulsadores ........................................... 20

6.2.1 Cdigo ............................................................ 21

Montaje en Protoboard ..................................... 22

6.2.4 Ejercicio 2: ...................................................... 23

Anexo: Gua de lenguaje Arduino. ......................................... 24

{} entre llaves .................................................... 24

; punto y coma ................................................... 25

Taller 1: Introduccin a Arduino. Jugando con Leds y pulsadores

/* */ bloque de comentarios ............................... 25

// lnea de comentarios ........................................ 25

Declaracin de variables ....................................... 27

utilizacin de una variable .................................... 27

Tipos de datos .................................................... 28

7.9.1 Byte ............................................................... 28

asignaciones compuestas ..................................... 30

operadores de comparacin .................................. 31

operadores lgicos ............................................... 31

cierto/falso (true/false) ........................................ 32

Control de flujo ................................................... 32

7.18.1 if (si condicional) ............................................ 32

e/s digitales ........................................................ 35

Taller 1: Introduccin a Arduino. Jugando con Leds y pulsadores

7.19.1 pinMode(pin, mode) ........................................ 35

7.20.1 analogRead(pin) ............................................. 37

Control del tiempo ............................................... 38

7.21.1 delay(ms) ..................................................... 38

7.22.1 min(x, y)....................................................... 39

7.23.1 randomSeed(seed) ......................................... 39

comunicacin serie .............................................. 40

7.24.1 Serial.begin(rate) ........................................... 40

Taller 1: Introduccin a Arduino. Jugando con Leds y pulsadores

Materiales: por alumno

1 x Arduino Uno, con su cable USB.

Taller 1: Introduccin a Arduino. Jugando con Leds y pulsadores

Taller 1: Introduccin a Arduino. Jugando con Leds y pulsadores

superiores cuando los sistemas emplean lectura y escritura en diferentes

Taller 1: Introduccin a Arduino. Jugando con Leds y pulsadores

SMD: Surface Mount Device o dispositivos de montaje superficial. Se trata

Taller 1: Introduccin a Arduino. Jugando con Leds y pulsadores

los entornos educacionales,

Taller 1: Introduccin a Arduino. Jugando con Leds y pulsadores

2 Plataforma electrnica Arduino UNO

Arduino puede tomar informacin del entorno a travs de sus

Taller 1: Introduccin a Arduino. Jugando con Leds y pulsadores

Las placas pueden ser hechas a mano o compradas montadas

Taller 1: Introduccin a Arduino. Jugando con Leds y pulsadores

va el chip conversor USB-a-serie y la

conexin USB al ordenador

Encabezado del software de Arduino

Taller 1: Introduccin a Arduino. Jugando con Leds y pulsadores

Sencillez en la interfaz del software Arduino