Documentos de Académico
Documentos de Profesional
Documentos de Cultura
(Henry Ford)
FabLab León 1
Taller 1: Introducción a Arduino. Jugando con Leds y pulsadores
Índice:
FabLab León 2
Taller 1: Introducción a Arduino. Jugando con Leds y pulsadores
7.18.3 for................................................................ 34
FabLab León 3
Taller 1: Introducción a Arduino. Jugando con Leds y pulsadores
FabLab León 4
Taller 1: Introducción a Arduino. Jugando con Leds y pulsadores
FabLab León 5
Taller 1: Introducción a Arduino. Jugando con Leds y pulsadores
Glosario:
FabLab León 6
Taller 1: Introducción a Arduino. Jugando con Leds y pulsadores
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.
FabLab León 7
Taller 1: Introducción a Arduino. Jugando con Leds y pulsadores
FabLab León 8
Taller 1: Introducción a Arduino. Jugando con Leds y pulsadores
FabLab León 9
Taller 1: Introducción a Arduino. Jugando con Leds y pulsadores
Arduino UNO
FabLab León 10
Taller 1: Introducción a Arduino. Jugando con Leds y pulsadores
FabLab León 11
Taller 1: Introducción a Arduino. Jugando con Leds y pulsadores
3 Software de Arduino
FabLab León 12
Taller 1: Introducción a Arduino. Jugando con Leds y pulsadores
3.1 Programación
El Arduino Uno puede ser programado con el software gratuito
Arduino (descargable de su página web). Una vez descargado no es
necesario instalarlo basta con descomprimir la carpeta y ejecutar
arduino.exe.
FabLab León 13
Taller 1: Introducción a Arduino. Jugando con Leds y pulsadores
FabLab León 14
Taller 1: Introducción a Arduino. Jugando con Leds y pulsadores
vo i d se t u p ()
{
i n str u cci o n e s;
}
vo i d l oo p ()
{
i n str u cci o n e s;
}
5.1 setup()
La función 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
declaración que ejecutar. Así mismo se puede utilizar para establecer
el estado inicial de las salidas de la placa.
FabLab León 15
Taller 1: Introducción a Arduino. Jugando con Leds y pulsadores
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()
Después de finalizar setup(), la función loop() hace
precisamente lo que sugiere su nombre, se ejecuta de forma cíclica,
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 León 16
Taller 1: Introducción a Arduino. Jugando con Leds y pulsadores
6 Ejemplos a implementar
FabLab León 17
Taller 1: Introducción a Arduino. Jugando con Leds y pulsadores
6.1.1 Código
El código 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 ) ; / / se t t h e LED o n
d e la y ( 1 00 0 ) ; // wa i t fo r a se co n d
d i gi talW rit e ( 12 , L OW ) ; / / set t h e LED o f f
d e la y ( 1 00 0 ) ; // wa i t fo r a se co n d
}
6.1.2 Circuito
FabLab León 18
Taller 1: Introducción a Arduino. Jugando con Leds y pulsadores
6.1.4 Ejercicio 1:
Construir y programar una tira de 5 Leds que simule el efecto
“coche fantástico”
FabLab León 19
Taller 1: Introducción a Arduino. Jugando con Leds y pulsadores
FabLab León 20
Taller 1: Introducción a Arduino. Jugando con Leds y pulsadores
6.2.1 Código
No te preocupes si ahora no comprendes todo el código, 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 ; / / vari a bl e fo r r e ad in g t h e p u sh bu t t o n
st a t u s
vo i d se t u p () {
/ / 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 León 21
Taller 1: Introducción a Arduino. Jugando con Leds y pulsadores
FabLab León 22
Taller 1: Introducción a Arduino. Jugando con Leds y pulsadores
6.2.4 Ejercicio 2:
A partir del ejercicio 1 hacer que la tira de leds se detenga al
pulsar el botón.
http://www.arduino.cc/
http://www.fablableon.org/
http://www.arduinoacademy.com/
david.beneitez@fablableon.org
FabLab León 23
Taller 1: Introducción a Arduino. Jugando con Leds y pulsadores
7.1 Funciones
Una función es un bloque de código que tiene un nombre y un conjunto de
instrucciones que son ejecutadas cuando se llama a la función. 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 tamaño de un programa.
Las funciones se declaran asociadas a un tipo de valor. Este valor será el que
devolverá la función, por ejemplo 'int' se utilizara cuando la función devuelva un
dato numérico de tipo entero. Si la función no devuelve ningún valor entonces se
colocara delante la palabra “void”, que significa “función vacía”. Después de
declarar el tipo de dato que devuelve la función se debe escribir el nombre de la
función y entre paréntesis se escribirán, si es necesario, los parámetros que se
deben pasar a la función 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)
{
i n str u cci o n e s;
}
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
}
t yp e f u n ci ó n( )
{
i n str u cci o n e s;
}
FabLab León 24
Taller 1: Introducción a Arduino. Jugando con Leds y pulsadores
Una llave de apertura “{“ siempre debe ir seguida de una llave de cierre “
}”, si no es así el compilador dará errores. El entorno de programación de Arduino
incluye una herramienta de gran utilidad para comprobar el total de llaves. Solo
tienes que hacer clic en el punto de inserción de una llave abierta e
inmediatamente se marca el correspondiente cierre de ese bloque (llave cerrada).
Nota: Si olvidáis poner fin a una línea con un punto y coma se producirá en
un error de compilación. 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 difícil detección
lo primero que debemos hacer es comprobar que los puntos y comas están
colocados al final de las instrucciones.
/ * 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 */
/ / Est o e s u n co me n t a ri o
FabLab León 25
Taller 1: Introducción a Arduino. Jugando con Leds y pulsadores
7.6 Variables
Una variable es una manera de nombrar y almacenar un valor numérico
para su uso posterior por el programa. Como su nombre indica, las variables son
números 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 código de ejemplo declara una
variable llamada variableEntrada y luego le asigna el valor obtenido en la entrada
analógica 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
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 código
más legible. Los nombres de variables pueden ser “contactoSensor” o “pulsador
”, para ayudar al programador y a cualquier otra persona a leer el código y
entender lo que representa la variable. Nombres de variables como “var” o “
valor”, facilitan muy poco que el código sea inteligible. Una variable puede ser
cualquier nombre o palabra que no sea una palabra reservada en el entorno de
Arduino.
FabLab León 26
Taller 1: Introducción a Arduino. Jugando con Leds y pulsadores
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
función del lugar en donde se lleve a cabo la definición esto determinara en que
partes del programa se podrá hacer uso de ella.
Una variable global es aquella que puede ser vista y utilizada por cualquier
función 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 función o como
parte de un bucle. Solo es visible y solo puede utilizarse dentro de la función en la
que se declaró.
Por lo tanto, es posible tener dos o más variables del mismo nombre en
diferentes partes del mismo programa que pueden contener valores diferentes. La
garantía de que solo una función tiene acceso a sus variables dentro del programa
simplifica y reduce el potencial de errores de programación.
FabLab León 27
Taller 1: Introducción a Arduino. Jugando con Leds y pulsadores
/ / 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.1 Byte
Byte almacena un valor numérico de 8 bits sin decimales. Tienen un rango
entre 0 y 255.
7.9.2 Int
Enteros son un tipo de datos primarios que almacenan valores numéricos de
16 bits sin decimales comprendidos en el rango 32,767 to -32,768.
7.9.3 Long
El formato de variable numérica de tipo extendido “long” se refiere a
números enteros (tipo 32 bits) sin decimales que se encuentran dentro del rango -
2147483648 a 2147483647.
7.9.4 Float
El formato de dato del tipo “punto flotante” “float” se aplica a los
números con decimales. Los números de punto flotante tienen una mayor
resolución que los de 32 bits con un rango comprendido 3.4028235E +38 a +38-
3.4028235E.
FabLab León 28
Taller 1: Introducción a Arduino. Jugando con Leds y pulsadores
7.9.5 arrays
Un array es un conjunto de valores a los que se accede con un número
índice. Cualquier valor puede ser recogido haciendo uso del nombre de la matriz y
el número 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 posición 0. Un array tiene
que ser declarado y opcionalmente asignados valores a cada posición antes de ser
utilizado.
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
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
posición de índice 0 en la serie que hemos escrito dentro del array parpadeo[], en
este caso 180, que se envía a la salida analógica tipo PWM configurada en el PIN10,
se hace una pausa de 200 ms y a continuación 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 León 29
Taller 1: Introducción a Arduino. Jugando con Leds y pulsadores
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 aritmética
Los operadores aritméticos que se incluyen en el entorno de programación
son suma, resta, multiplicación y división. Estos devuelven la suma, diferencia,
producto, o cociente (respectivamente) de dos operandos.
y = y + 3; x = x - 7; i = j * 6; r = r / 5;
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.
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 León 30
Taller 1: Introducción a Arduino. Jugando con Leds y pulsadores
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
x - = 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
x * = y / / i g u al q u e x = x * y, o mu l t i plica x p o r y
x / = y / / i g u al q ue x = x / y, o d i vi d e x p o r y
x == y / / x e s i g u al a y
x ! = y / / x n o e s ig u al a y
x < y / / x e s me n o r q u e y
x > y / / x e s ma yo r q u e y
x <= y / / x e s me n o r o i gu a l q u e y
x >= y / / x e s ma yo r o i g ual q u e y
Lógica 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
Lógica 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 programación de Arduino tiene unos valores
predeterminados, que son llamados constantes. Se utilizan para hacer los
programas más fáciles de leer. Las constantes se clasifican en grupos.
FabLab León 31
Taller 1: Introducción a Arduino. Jugando con Leds y pulsadores
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 lógica de
nivel 1, ON, o 5 voltios, mientras que BAJO es lógica nivel 0, OFF, o 0 voltios.
7.17 Input/Output
Estas constantes son utilizadas para definir, al comienzo del programa, el
modo de funcionamiento de los pines mediante la instrucción 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
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 ;
}
FabLab León 32
Taller 1: Introducción a Arduino. Jugando con Leds y pulsadores
Nota: Tenga en cuenta el uso especial del símbolo '=', poner dentro de if (x
= 10), podría parecer que es válido pero sin embargo no lo es ya que esa expresión
asigna el valor 10 a la variable x, por eso dentro de la estructura if se utilizaría
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
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;
}
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 ;
}
FabLab León 33
Taller 1: Introducción a Arduino. Jugando con Leds y pulsadores
7.18.3 for
La declaración for se usa para repetir un bloque de sentencias encerradas
entre llaves un número determinado de veces. Cada vez que se ejecutan las
instrucciones del bucle se vuelve a testear la condición. La declaración 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;
}
7.18.4 while
Un bucle del tipo while es un bucle de ejecución continua mientras se
cumpla la expresión colocada entre paréntesis en la cabecera del bucle. La variable
de prueba tendrá que cambiar para salir del bucle. La situación podrá cambiar a
expensas de una expresión dentro el código del bucle o también por el cambio de
un valor en una entrada de un sensor.
FabLab León 34
Taller 1: Introducción a Arduino. Jugando con Leds y pulsadores
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;
}
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) ;
do
{
x = l e e Se n so r () ;
d e l a y( 5 0) ;
} wh i l e ( x < 1 0 0 ) ;
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
FabLab León 35
Taller 1: Introducción a Arduino. Jugando con Leds y pulsadores
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
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 ´
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 León 36
Taller 1: Introducción a Arduino. Jugando con Leds y pulsadores
{
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.1 analogRead(pin)
Lee el valor de un determinado pin definido como entrada analógica con una
resolución de 10 bits. Esta instrucción 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'
FabLab León 37
Taller 1: Introducción a Arduino. Jugando con Leds y pulsadores
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.1 delay(ms)
Detiene la ejecución del programa la cantidad de tiempo en ms
que se indica en la propia instrucción. 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 número 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 aplicación después de cargada o
después de la última vez que se pulso el botón “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
FabLab León 38
Taller 1: Introducción a Arduino. Jugando con Leds y pulsadores
7.22 Matemáticas
7.22.1 min(x, y)
Calcula el mínimo de dos números para cualquier tipo de datos devolviendo
el número más pequeño.
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.
7.22.2 max(x, y)
Calcula el máximo de dos números para cualquier tipo de datos devolviendo
el número 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 mínimo 100.
7.23 aleatorios
7.23.1 randomSeed(seed)
Establece un valor, o semilla, como punto de partida para la función
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
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 León 39
Taller 1: Introducción a Arduino. Jugando con Leds y pulsadores
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 vía 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.1 Serial.begin(rate)
Abre el puerto serie y fija la velocidad en baudios para la transmisión de
datos en serie. El valor típico 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
7.24.2 Serial.println(data)
Imprime los datos en el puerto serie, seguido por un retorno de carro
automático y salto de línea. Este comando toma la misma forma que Serial.print(),
pero es mas fácil para la lectura de los datos en el Monitor Serie del software.
El siguiente ejemplo toma de una lectura analógica pin0 y envía estos datos
al ordenador cada 1 segundo.
FabLab León 40
Taller 1: Introducción a Arduino. Jugando con Leds y pulsadores
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 vía 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
}
Ejemplos:
7.24.4 Serial.avaible()
Devuelve Un entero con el número de bytes disponibles para leer desde el
buffer serie, o 0 si no hay ninguno. Si hay algún dato disponible, SerialAvailable()
será mayor que 0. El buffer serie puede almacenar como máximo 64 bytes.
FabLab León 41
Taller 1: Introducción a Arduino. Jugando con Leds y pulsadores
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
vo i d se t u p () {
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 carácter) desde el puerto serie. Devuelve el
siguiente byte (carácter) 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
vo i d se t u p () {
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 vía 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 León 42