1

arduino
programming
notebook
brian w. Evans
edicin espaola
Traduccin:
Jos Manuel Ruiz Gutirrez
Adaptacin:
Jos Manuel Escuder Martinez
http://www.ardumania.es/
ver. .! de "/#"/!#
2
Datos del documento original
Arduino $ote%oo&: A 'e(inner)s Re*erence +ritten and compiled %,
'rian +. Evans
+ith in*ormation or inspiration ta&en *rom:
http :// www .arduino .cc
http :// www .wiring .org .co
http://www.arduino.cc/en/'oo&let/-ome.a(e /enlace roto0
http :// cslibrary .stanford .edu /101/
1ncludin( material written %,:
Massimo 'anzi
-ernando 'arra(2n
3avid 4uartielles
Tom 1(oe
Todd 5urt
3avid Mellis and others
.u%lished:
6irst Edition Au(ust !##7
This wor& is licensed under the 4reative 4ommons
Attri%ution8$oncommercial89hare Ali&e :.# ;icense.
To view a cop, o* this license< visit:
http :// creativecommons .org /licenses /by - nc -/
=r send a letter to:
4reative 4ommons
7 9econd 9treet< 9uite :##
9an 6rancisco< 4ali*ornia< >?#@< A9A
3
contenido
prefacio
estructura de un sketch
setup/0 B
loop/0 7
*unciones "
CD entre llaves >
E punto , coma >
/FG F/ %loHue de comentarios #
// lInea de comentarios #
variables
declaracin de varia%les !
utilizacin de una varia%le !
tipos de datos
%,te ?
int ?
lon( ?
*loat @
arra,s @
aritmtica
asi(naciones compuestas "
operadores de comparacin "
operadores l(icos "
constantes
cierto/*also /true/*alse0 !#
hi(h/low !#
input/output !#
control de fjujo
i* /si condicional0 !
i*G else /siG.. sino ..0 !!
*or !:
while !?
doG while !?
e/s digitales
pinMode/pin< mode0 !B
di(italRead/pin0 !7
di(ital+rite/pin< value0 !7
e/s analgicas
analo(Read/pin0 !"
analo(+rite/pin< value0 !"
control del tiempo
dela,/ms0 :#
4
millis/0 :#
Matemticas
min/J< ,0 :
maJ/J< ,0 :
aleatorios
random9eed/seed0 :!
random/maJ0< random/min< maJ0 :!
comunicacin serie
9erial.%e(in/rate0 :?
9erial.println/data0 :?
9erial.print/data< data t,pe0 :@
9erial.avai%le/0 :B
9erial.Read/0 :7
apndices
salida di(ital :>
entrada di(ital ?#
salida de alta corriente de consumo ?
salida anal(ica del tipo pwm ?!
entrada con potencimetro ?:
entrada conectada a resistencia varia%le ??
salida conectada a servo ?@

prefacio
El propsito del autor ori(inal de este li%ro *ue crear un peHueKo
manual de consulta r2pida so%re los comandos %2sicos , la sintaJis
del len(uaLe de pro(ramacin de Arduino. .ara entrar en los
contenidos con ma,or pro*undidad se pueden consultar otras
p2(inas we%< li%ros< wor&shops , cursos. Esta decisin hizo Hue
Huedaran *uera del contenido *ormas compleLas como los arra,s o
avanzadas *ormas de comunicacin serie.
4omenzando con la estructura %2sica del 4 del Hue deriva el
len(uaLe de pro(ramacin de Arduino este li%ro de notas continua
con la descripcin de los comandos m2s usuales e ilustra su uso con
eLemplos de cdi(o.
Esta traduccin al espaKol la realiz en su dIa Jos Manuel Ruiz
Gutierrez para utilizarla dentro de sus cursos. Entre !## , !# la
comunidad de traductores Huisimos ampliar la documentacin
eJistente en EspaKol para %ene*icio de todos los usuarios Hue
tienen pro%lemas con el in(les. ;amenta%lemente pro%lemas
derivados de la *orma de tra%aLar de una comunidad *ormada
eJclusivamente por voluntarios deLaron este pro,ecto con(elado.
Respetando los trminos de la licencia del documento ori(inal este
li%ro ha sido remaHuetado para adaptarlo al EspaKol. $o de%e
considerarse una o%ra cerrada< si no Hue espero pu%licar *uturas
revisiones ampliando su contenido , adecu2ndolo a las novedades
acontecidas en este mundillo desde la primera edicin de este li%ro.
4ualHuier aportacin< correccin o su(erencia puede ser enviada a:
LosemescuderM(mail.com
!
estructura de un sketch
;a estructura %2sica del len(uaLe de pro(ramacin de Arduino es
%astante simple , se compone de al menos dos partes. Estas dos
partes necesarias< o *unciones< encierran %loHues Hue contienen
declaraciones< estamentos o instrucciones.
void setup()
{
estamentos;
}
void loop()
{
estamentos;
}
En donde setup/0 es la parte encar(ada de reco(er la con*i(uracin
, loop/0 es la Hue contienen el pro(rama Hue se eLecutar2
cIclicamente /de ahI el termino loop N%ucle80. Am%as *unciones son
necesarias para Hue el pro(rama tra%aLe.
;a *uncin de con*i(uracin de%e contener la declaracin de las
varia%les. Es la primera *uncin a eLecutar en el pro(rama< se
eLecuta slo una vez< , se utiliza para con*i(urar o inicializar
pinMode /modo de tra%aLo de las E/90< con*i(uracin de la
comunicacin en serie , otras.
;a *uncin %ucle /loop0 si(uiente contiene el cdi(o Hue se eLecutara
continuamente /lectura de entradas< activacin de salidas< etc0 Esta
*uncin es el nOcleo de todos los pro(ramas de Arduino , la Hue
realiza la ma,or parte del tra%aLo.
setup()
;a *uncin setup/0 se invoca una sola vez cuando el pro(rama
empieza. 9e utiliza para inicializar los modos de tra%aLo de los pins<
o el puerto serie. 3e%e ser incluido en un pro(rama aunHue no ha,a
declaracin Hue eLecutar. AsI mismo se puede utilizar para
esta%lecer el estado inicial de las salidas de la placa.
void setup()
"
{
pinMode(pin, OUTPUT); // configura el 'pin' como
salida
digitalrite(pin, !"#!); // pone el $pin% en estado
// !"#!
}
loop()
3espus de llamar a setup/0< la *uncin loop/0 hace precisamente lo
Hue su(iere su nom%re< se eLecuta de *orma cIclica< lo Hue posi%ilita
Hue el pro(rama este respondiendo continuamente ante los eventos
Hue se produzcan en la placa.
void loop()
{
digitalrite(pin, !"#!); // pone en uno (on, &v) el'pin'
dela(()***); // espera un segundo ()*** ms)
digitalrite(pin, +O); // pone en cero (off, *v,) el
dela(()***); // 'pin'
}
#
funciones
Ana *uncin es un %loHue de cdi(o Hue tiene un nom%re , un
conLunto de instrucciones Hue son eLecutadas cuando se llama a la
*uncin. 9on *unciones setup/0 , loop/0 de las Hue ,a se ha ha%lado.
;as *unciones de usuario pueden ser escritas para realizar tareas
repetitivas , para reducir el tamaKo de un pro(rama. ;as *unciones
se declaran asociadas a un tipo de valor. Este valor ser2 el Hue
devolver2 la *uncin< por eLemplo PintP se utilizar2 cuando la *uncin
devuelva un dato numrico de tipo entero. 9i la *uncin no devuelve
nin(On valor entonces se colocar2 delante la pala%ra QvoidR< Hue
si(ni*ica Q*uncin vacIaR. 3espus de declarar el tipo de dato Hue
devuelve la *uncin se de%e escri%ir el nom%re de la *uncin , entre
parntesis se escri%ir2n< si es necesario< los par2metros Hue se
de%en pasar a la *uncin para Hue se eLecute.
tipo nom-re.unci/n(par0metros)
{
instrucciones;
}
;a *uncin si(uiente devuelve un nOmero entero< dela,Sal/0 se utiliza
para poner un valor de retraso en un pro(rama Hue lee una varia%le
anal(ica de un potencimetro conectado a una entrada de Arduino.
Al principio se declara como una varia%le local< TvT reco(e el valor
leIdo del potencimetro Hue estar2 comprendido entre # , #!:<
lue(o se divide el valor por ? para aLustarlo a un mar(en
comprendido entre # , !@@< *inalmente se devuelve el valor TvT , se
retornarIa al pro(rama principal.
int dela(1al()
{
int v; // crea una varia-le temporal 'v'
v2 analog3ead(pot); // lee el valor del potenci/metro
v /2 4; // convierte *5)*67 a *56&&
return v; // devuelve el valor final
}
$
{} entre llaves
;as llaves sirven para de*inir el principio , el *inal de un %loHue de
instrucciones. 9e utilizan para los %loHues de pro(ramacin setup/0<
loop/0< i*..< etc.
t(pe funcion()
{
instrucciones;
}
Ana llave de apertura QCQ siempre de%e ir se(uida de una llave de
cierre QDR< si no es asI el compilador dar2 errores.
El entorno de pro(ramacin de Arduino inclu,e una herramienta de
(ran utilidad para compro%ar el total de llaves. 9lo tienes Hue hacer
clic& en el punto de insercin de una llave a%ierta e inmediatamente
se marca el correspondiente cierre de ese %loHue /llave cerrada0.
punto ! coma
El punto , coma QER se utiliza para separar instrucciones en el
len(uaLe de pro(ramacin de Arduino. Tam%in se utiliza para
separar elementos en una instruccin de tipo Q%ucle *orR.
int 8 2 )7; // declara la varia-le '8' como tipo
// entero de valor )7
$ota: 9i olvid2is poner *in a una lInea con un punto , coma se
producir2 en un error de compilacin. El teJto de error puede ser
o%vio< , se re*erir2 a la *alta de un punto , coma< o puede Hue no. 9i
se produce un error raro , de di*Icil deteccin lo primero Hue
de%emos hacer es compro%ar Hue los puntos , comas est2n
colocados al *inal de las instrucciones.
10
"#$ #" blo%ue de comentarios
;os %loHues de comentarios< o comentarios multi8lInea son 2reas de
teJto i(norados por el pro(rama Hue se utilizan para las
descripciones del cdi(o o comentarios Hue a,udan a comprender el
pro(rama. 4omienzan con / F , terminan con F / , pueden a%arcar
varias lIneas.
/9 esto es un -lo:ue de comentario no se de-e olvidar
cerrar los comentarios estos de-en estar e:uili-rados 9/
3e%ido a Hue los comentarios son i(norados por el compilador , no
ocupan espacio en la memoria de Arduino pueden ser utilizados con
(enerosidad. Tam%in pueden utilizarse para UcomentarU %loHues de
cdi(o con el propsito de anotar in*ormaciones para depuracin ,
hacerlo mas comprensi%le para cualHuiera.
&ota: 3entro de una misma lInea de un %loHue de comentarios no
se puede escri%ir otra %loHue de comentarios /usando /F..F/0.
"" l'nea de comentarios
Ana lInea de comentario empieza con / / , terminan con la si(uiente
lInea de cdi(o. Al i(ual Hue los comentarios de %loHue< los de lInea
son i(noradas por el pro(rama , no ocupan espacio en la memoria.
// esto es un comentario
Ana lInea de comentario se utiliza a menudo despus de una
instruccin< para proporcionar m2s in*ormacin acerca de lo Hue
hace esta o para recordarla m2s adelante.
11
variables
Ana varia%le es una manera de nom%rar , almacenar un valor numrico
para su uso posterior por el pro(rama. 4omo su nom%re indica< las varia%les
son nOmeros Hue se pueden variar continuamente en contra de lo Hue
ocurre con las constantes cu,o valor nunca cam%ia. Ana varia%le de%e ser
declarada ,< opcionalmente< asi(narle un valor. El si(uiente cdi(o de
eLemplo declara una varia%le llamada varia%leEntrada , lue(o le asi(na el
valor o%tenido en la entrada anal(ica del .1$!:
int varia-le;ntrada 2 *; // declara una varia-le ( le
// asigna el valor *
varia-le;ntrada 2 analog3ead(6); // la varia-le recoge
//el valor anal/gico del P"<6
Pvaria%leEntradaP es la varia%le en sI. ;a primera lInea declara Hue
ser2 de tipo entero QintR. ;a se(unda lInea *iLa a la varia%le el valor
correspondiente a la entrada anal(ica .1$!. Esto hace Hue el valor
de .1$! sea accesi%le en otras partes del cdi(o.
Ana vez Hue una varia%le ha sido asi(nada< o re8asi(nada< usted
puede pro%ar su valor para ver si cumple ciertas condiciones< o
puede utilizar directamente su valor. 4omo eLemplo ilustrativo
veamos tres operaciones Otiles con varia%les: el si(uiente cdi(o
prue%a si la varia%le QentradaSaria%leR es in*erior a ##< si es cierto
se asi(na el valor ## a QentradaSaria%leR ,< a continuacin<
esta%lece un retardo /dela,0 utilizando como valor QentradaSaria%leR
Hue ahora ser2 como mInimo de valor ##:
if (entrada1aria-le = )**) // pregunta si la varia-le es
{ //menor de )**
entrada1aria-le 2 )**; // si es cierto asigna el valor
} //)**
dela((entrada1aria-le); // usa el valor como retardo
&ota: ;as varia%les de%en tomar nom%res descriptivos< para hacer
el cdi(o m2s le(i%le. ;os nom%res de varia%les pueden ser
Qcontacto9ensorR o QpulsadorR< para a,udar al pro(ramador , a
cualHuier otra persona a leer el cdi(o , entender lo Hue representa
la varia%le. $om%res de varia%les como QvarR o QvalorR< *acilitan mu,
poco Hue el cdi(o sea inteli(i%le. Ana varia%le puede ser cualHuier
12
nom%re o pala%ra Hue no sea una pala%ra reservada en el entorno
de Arduino.
declaracin de variables
Todas las varia%les tienen Hue declararse antes de Hue puedan ser
utilizadas. .ara declarar una varia%le se comienza por de*inir su tipo
como int /entero0< lon( /lar(o0< *loat /coma *lotante0< etc<
asi(n2ndoles siempre un nom%re< ,< opcionalmente< un valor inicial.
Esto slo de%e hacerse una vez en un pro(rama< pero el valor se
puede cam%iar en cualHuier momento usando aritmtica ,
reasi(naciones diversas.
El si(uiente eLemplo declara la varia%le entradaSaria%le como una
varia%le de tipo entero QintR< , asi(n2ndole un valor inicial i(ual a
cero. Esto se llama una asi(nacin.
int entrada1aria-le 2 *;
Ana varia%le puede ser declarada en una serie de lu(ares del
pro(rama , en *uncin del lu(ar en donde se lleve a ca%o la
de*inicin esto determinar2 en Hue partes del pro(rama se podr2
hacer uso de ella.
utili(acin de una variable
Ana varia%le puede ser declarada al inicio del pro(rama antes de la
parte de con*i(uracin setup/0< a nivel local dentro de las *unciones<
,< a veces< dentro de un %loHue< como para los %ucles del tipo i*..
*or..< etc. En *uncin del lu(ar de declaracin de la varia%le asI se
determinara el 2m%ito de aplicacin< o la capacidad de ciertas partes
de un pro(rama para hacer uso de ella.
Ana varia%le (lo%al es aHuella Hue puede ser vista , utilizada por
cualHuier *uncin , estamento de un pro(rama. Esta varia%le se
declara al comienzo del pro(rama< antes de setup/0.
Ana varia%le local es aHuella Hue se de*ine dentro de una *uncin o
como parte de un %ucle. 9lo es visi%le , slo puede utilizarse
dentro de la *uncin en la Hue se declar.
13
.or lo tanto< es posi%le tener dos o m2s varia%les del mismo nom%re
en di*erentes partes del mismo pro(rama Hue pueden contener
valores di*erentes. ;a (arantIa de Hue slo una *uncin tiene acceso
a sus varia%les dentro del pro(rama simpli*ica , reduce el potencial
de errores de pro(ramacin.
El si(uiente eLemplo muestra cmo declarar a unos tipos di*erentes
de varia%les , la visi%ilidad de cada varia%le:
int value; // 'value' es visi-le para cual:uier
funci/n
void setup()
{
// no es necesario configurar nada en este e>emplo
}
void loop()
{
for (int i2*; i=6*;) // 'i' solo es visi-le
{ // dentro del -ucle for
i??
} // 'f' es visi-le solo
float f; // dentro de loop()
}
14
tipos de datos
b!te
',te almacena un valor numrico de " %its sin decimales. Tienen un
ran(o entre # , !@@.
-(te una1aria-le 2 )@*; // declara 'una1aria-le' como
// de tipo -(te
int
Enteros son un tipo de datos primarios Hue almacenan valores
numricos de B %its sin decimales comprendidos en el ran(o
:!<7B7 to 8:!<7B".
int una1aria-le 2 )&**; // declara 'una1aria-le' como
// una varia-le de tipo entero
$ota: ;as varia%les de tipo entero QintR pueden so%repasar su valor
m2Jimo o mInimo como consecuencia de una operacin. .or
eLemplo< si J V :!7B7 , una posterior declaracin a(re(a a J< J V J
W entonces el valor se J pasar2 a ser 8:!.7B". /al(o asI como Hue
el valor da la vuelta0.

long
El *ormato de varia%le numrica de tipo eJtendido Qlon(R se re*iere a
nOmeros enteros /tipo :! %its0 sin decimales Hue se encuentran
dentro del ran(o 8!?7?":B?" a !?7?":B?7.
long una1aria-le 2 A****; // declara 'una1aria-le' como
// de tipo long
1
float
El *ormato de dato del tipo Qpunto *lotanteR Q*loatR se aplica a los
nOmeros con decimales. ;os nOmeros de punto *lotante tienen una
ma,or resolucin Hue los de :! %its con un ran(o comprendido
:.?#!"!:@E W:" a W:"8:.?#!"!:@E.
float una1aria-le 2 7,)4; // declara 'una1aria-le' como
// de tipo flotante
&ota: ;os nOmeros de punto *lotante no son eJactos< , pueden
producir resultados eJtraKos en las comparaciones. ;os c2lculos
matem2ticos de punto *lotante son tam%in mucho m2s lentos Hue
los del tipo de nOmeros enteros< por lo Hue de%e evitarse su uso si
es posi%le.
arra!s
An arra, es un conLunto de valores a los Hue se accede con un
nOmero Indice. 4ualHuier valor puede ser reco(ido haciendo uso del
nom%re de la matriz , el nOmero del Indice. El primer valor de la
matriz es el Hue est2 indicado con el Indice #< es decir el primer valor
del conLunto es el de la posicin #. An arra, tiene Hue ser declarado
, opcionalmente asi(nados valores a cada posicin antes de ser
utilizado.
int miBrra(CD 2 {valor*, valor), valor6,,,}
3el mismo modo es posi%le declarar una matriz indicando el tipo de
datos , el tamaKo , posteriormente< asi(nar valores a una posicin
especi*ica:
int miBrra(C&D; // declara un arra( de enteros de E
// posiciones
miBrra(C7D 2 )*; // asigna l valor )* a la posici/n 4
.ara leer de un arra, %asta con escri%ir el nom%re , la posicin a
leer:
8 2 miBrra(C7D; // 8 aFora es igual a )* :ue est0 en
// la posici/n 7 del arra(
1!
;as matrices se utilizan a menudo para estamentos de tipo %ucle< en
los Hue la varia%le de incremento del contador del %ucle se utiliza
como Indice o puntero del arra,. El si(uiente eLemplo usa una matriz
para el parpadeo de un ;E3.
Atilizando un %ucle tipo *or< el contador comienza en cero # , escri%e
el valor Hue *i(ura en la posicin de Indice # en la serie Hue hemos
escrito dentro del arra, parpadeoXY< en este caso "#< Hue se envIa a
la salida anal(ica tipo .+M con*i(urada en el .1$#< se hace una
pausa de !## ms , a continuacin se pasa al si(uiente valor Hue
asi(na el Indice QiR.
int ledPin 2 )*; // +;G en el P"< )*
-(te parpadeoCD 2 {)@*, 7*, 6&&, 6**, )*, A*, )&*, E*};
// arra( de @ valores
void setup()
{
pinMode(ledPin, OUTPUT); // configura la salida
}
void loop()
{
for(int i2*; i=H; i??)
{
analogrite(ledPin, parpadeoCiD);
dela((6**); // espera 6**ms
}
}
1"
aritm)tica
;os operadores aritmticos Hue se inclu,en en el entorno de
pro(ramacin son suma< resta< multiplicacin , divisin. Estos
devuelven la suma< di*erencia< producto< o cociente
/respectivamente0 de dos operandos.
( 2 ( ? 7; 8 2 8 5 H; i 2 > 9 E; r 2 r / &;
;a operacin se e*ectOa teniendo en cuenta el tipo de datos Hue
hemos de*inido para los operandos /int< d%l< *loat< etc..0< por lo Hue<
por eLemplo< si de*inimos > , ? como enteros QintR< > / ? devuelve de
resultado ! en lu(ar de !<!@ ,a Hue el > , ? se valores de tipo entero
QintR /enteros0 , no se reconocen los decimales con este tipo de
datos.
Esto tam%in si(ni*ica Hue la operacin puede su*rir un
des%ordamiento si el resultado es m2s (rande Hue lo Hue puede ser
almacenada en el tipo de datos. Recordemos el alcance de los tipos
de datos numricos Hue ,a hemos eJplicado anteriormente.
9i los operandos son de di*erentes tipos< para el c2lculo se utilizar2
el tipo m2s (rande de los operandos en Lue(o. .or eLemplo< si uno
de los nOmeros /operandos0 es del tipo *loat , otra de tipo inte(er<
para el c2lculo se utilizar2 el mtodo de *loat es decir el mtodo de
coma *lotante.
EliLa el tamaKo de las varia%les de tal manera Hue sea lo
su*icientemente (rande como para Hue los resultados sean lo
precisos Hue usted desea. .ara las operaciones Hue reHuieran
decimales utilice varia%les tipo *loat< pero sea consciente de Hue las
operaciones con este tipo de varia%les son m2s lentas a la hora de
realizarse el computo.
&ota: Atilice el operador /int0 para convertir un tipo de varia%le a otro
so%re la marcha. .or eLemplo< i V /int0 :<B esta%lecer2 i i(ual a :.
1#
asignaciones compuestas
;as asi(naciones compuestas com%inan una operacin aritmtica
con una varia%le asi(nada. Estas son comOnmente utilizadas en los
%ucles tal como se descri%e m2s adelante. Estas asi(naciones
compuestas pueden ser:
8 ?? // igual :ue 8 2 8 ?), o incremento de 8 en ?)
8 55 // igual :ue 8 2 8 5 ), o decremento de 8 en 5)
8 ?2 ( // igual :ue 8 2 8 ? (, o incremento de 8 en ?(
8 52 ( // igual :ue 8 2 8 5 (, o decremento de 8 en 5(
8 92 ( // igual :ue 8 2 8 9 (, o multiplica 8 por (
8 /2 ( // igual :ue 8 2 8 / (, o divide 8 por (
$ota: .or eLemplo< J F V : hace Hue J se convierta en el triple del
anti(uo valor J , por lo tanto J es reasi(nada al nuevo valor.
operadores de comparacin
;as comparaciones de una varia%le o constante con otra se utilizan
con *recuencia en las estructuras condicionales del tipo i*.. para
testear si una condicin es verdadera. En los eLemplos Hue si(uen
en las prJimas p2(inas se ver2 su utilizacin pr2ctica usando los
si(uientes tipo de condicionales:
8 22 ( // 8 es igual a (
8 I2 ( // 8 no es igual a (
8 = ( // 8 es menor :ue (
8 J ( // 8 es ma(or :ue (
8 =2 ( // 8 es menor o igual :ue (
8 J2 ( // 8 es ma(or o igual :ue (
operadores lgicos
;os operadores l(icos son usualmente una *orma de comparar dos
eJpresiones , devolver un SER3A3ER= o 6A;9= dependiendo del
operador. EJisten tres operadores l(icos< A$3 /ZZ0< =R /[[0 , $=T
/\0< Hue a menudo se utilizan en estamentos de tipo i*:
;o(ica A$3:
if (8 J * KK 8 = &) // cierto s/lo si las dos
e8presiones // son ciertas
1$
;o(ica =R:
if (8 J * LL ( J *) // cierto si una cual:uiera de las
// e8presiones es cierta
;o(ica $=T:
if (I8 J *) // cierto solo si la e8presi/n es
// falsa
20
constantes
El len(uaLe de pro(ramacin de Arduino tiene unos valores
predeterminados< Hue son llamados constantes. 9e utilizan para
hacer los pro(ramas m2s *2ciles de leer. ;as constantes se
clasi*ican en (rupos.
cierto"falso (true"false)
Estas son constantes %ooleanas Hue de*inen los niveles -1G- /alto0
, ;=+ /%aLo0 cuando estos se re*ieren al estado de las salidas
di(itales. 6A;9E se asocia con # /cero0< mientras Hue TRAE se
asocia con < pero TRAE tam%in puede ser cualHuier otra cosa
eJcepto cero. .or lo tanto< en sentido %ooleano< 8< ! , 8!## son
todos tam%in se de*ine como TRAE. /esto es importante tenerlo en
cuanta0.
if (- 22 T3U;);
{
e>ecutar las instrucciones;
}
high"low
Estas constantes de*inen los niveles de salida altos o %aLos , se
utilizan para la lectura o la escritura di(ital para las patillas. A;T= se
de*ine como en la l(ica de nivel < =$< @ voltios< mientras Hue
'AJ= es l(ica nivel #< =66< o # voltios.
digitalrite()7, !"#!); // activa la salida )7 con un
// nivel alto (&v,)
input"output
Estas constantes son utilizadas para de*inir< al comienzo del
pro(rama< el modo de *uncionamiento de los pines mediante la
instruccin pinMode de tal manera Hue el pin puede ser una entrada
1$.AT o una salida =AT.AT.
pinMode()7, OUTPUT); // designamos :ue el P"< )7 es
// una salida
21
control de f*u*o
if (si condicional)
i* es un estamento Hue se utiliza para pro%ar si una determinada
condicin se ha alcanzado< como por eLemplo averi(uar si un valor
anal(ico est2 por encima de un cierto nOmero< , eLecutar una serie
de declaraciones /operaciones0 Hue se escri%en dentro de llaves< si
es verdad. 9i es *also /la condicin no se cumple0 el pro(rama salta
, no eLecuta las operaciones Hue est2n dentro de las llaves< El
*ormato para i* es el si(uiente:
if (una1aria-le MM valor)
{
e>ecuta"nstrucciones;
}
En el eLemplo anterior se compara una varia%le con un valor< el cual
puede ser una varia%le o constante. 9i la comparacin< o la
condicin entre parntesis se cumple /es cierta0< las declaraciones
dentro de los corchetes se eLecutan. 9i no es asI< el pro(rama salta
so%re ellas , si(ue.
$ota: Ten(a en cuenta el uso especial del sIm%olo PVP< poner dentro
de i* /J V #0< podrIa parecer Hue es valido pero sin em%ar(o no lo
es ,a Hue esa eJpresin asi(na el valor # a la varia%le J< por eso
dentro de la estructura i* se utilizarIa ]VV# Hue en este caso lo Hue
hace el pro(rama es compro%ar si el valor de J es #.. Am%as cosas
son distintas por lo tanto dentro de las estructuras i*< cuando se
pre(unte por un valor se
de%e poner el si(no do%le de i(ual QVVR.
22
if$ else (si$.. sino ..)
i*G else viene a ser un estructura Hue se eLecuta en respuesta a la
idea Qsi esto no se cumple haz esto otroR. .or eLemplo< si se desea
pro%ar una entrada di(ital< , hacer una cosa si la entrada *ue alto o
hacer otra cosa si la entrada es %aLa< usted escri%irIa Hue de esta
manera:
if (inputPin 22 !"#!)
{
instruccionesB;
}
else
{
instruccionesN;
}
Else puede ir precedido de otra condicin de manera Hue se pueden
esta%lecer varias estructuras condicionales de tipo unas dentro de
las otras /anidamiento0 de *orma Hue sean mutuamente eJclu,entes
pudindose eLecutar a la vez. Es incluso posi%le tener un
nOmero ilimitado de estos condicionales. Recuerde sin em%ar(o
Hu slo un conLunto de declaraciones se llevar2 a ca%o
dependiendo de la condicin pro%ada:
if (inputPin = &**)
{
instruccionesB;
}
else if (inputPin J2 )***)
{
instruccionesN;
{
else
{
instruccionesO;
}
&ota: An estamento de tipo i* prue%a simplemente si la condicin
dentro del parntesis es verdadera o *alsa. Esta declaracin puede
ser cualHuier declaracin v2lida. En el anterior eLemplo< si
cam%iamos , ponemos /input.in VV -1G-0. En este caso< el
23
estamento i* slo cheHuearIa si la entrada especi*icado esta en nivel
alto /-1G-0< o W@v.
for
;a declaracin *or se usa para repetir un %loHue de sentencias
encerradas entre llaves un nOmero determinado de veces. 4ada vez
Hue se eLecutan las instrucciones del %ucle se vuelve a testear la
condicin. ;a declaracin *or tiene tres partes separadas por /E0<
vemos el eLemplo de su sintaJis:
for (inicialiPaci/n; condici/n; e8presi/n)
{
"nstrucciones;
}
;a inicializacin de una varia%le local se produce una sola vez , la
condicin se testea cada vez Hue se termina la eLecucin de las
instrucciones dentro del %ucle. 9i la condicin si(ue cumplindose<
las instrucciones del %ucle se vuelven a eLecutar. 4uando la
condicin no se cumple< el %ucle termina.
El si(uiente eLemplo inicia el entero i en el #< , la condicin es pro%ar
Hue el valor es in*erior a !# , si es cierto i se incrementa en , se
vuelven a eLecutar las instrucciones Hue ha, dentro de las llaves:
for (int i2*; i=6*; i??) // declara i ( prue-a si es
{ // menor :ue 6*, incrementa i,
digitalrite()7, !"#!); // enciende el pin )7
dela((6&*); // espera Q seg,
digitalrite()7, +O); // apaga el pin )7
dela((6&*); // espera Q de seg,
}
&ota: El %ucle en el len(uaLe 4 es mucho m2s *leJi%le Hue otros
%ucles encontrados en al(unos otros len(uaLes de pro(ramacin<
inclu,endo 'A914. 4ualHuiera de los tres elementos de ca%ecera
puede omitirse< aunHue el punto , coma es o%li(atorio. Tam%in las
declaraciones de inicializacin< condicin , eJpresin puede ser
cualHuier estamento v2lido en len(uaLe 4 sin relacin con las
varia%les declaradas. Estos tipos de estados son raros pero
24
permiten disponer soluciones a al(unos pro%lemas de pro(ramacin
raras.
while
An %ucle del tipo while es un %ucle de eLecucin continua mientras
se cumpla la eJpresin colocada entre parntesis en la ca%ecera del
%ucle. ;a varia%le de prue%a tendr2 Hue cam%iar para salir del %ucle.
;a situacin podr2 cam%iar a eJpensas de una eJpresin dentro el
cdi(o del %ucle o tam%in por el cam%io de un valor en una entrada
de un sensor.
RFile (una1aria-le MM valor)
{
e>ecutarSentencias;
}
El si(uiente eLemplo testea si la varia%le UunaSaria%leR es in*erior a
!## ,< si es verdad< eLecuta las declaraciones dentro de los
corchetes , continuar2 eLecutando el %ucle hasta Hue PunaSaria%leP
no sea in*erior a !##.
File (una1aria-le = 6**) // testea si es menor :ue 6**
{
instrucciones; // e>ecuta las instrucciones
// entre llaves
una1aria-le??; // incrementa la varia-le en )
}
do$ while
El %ucle do while *unciona de la misma manera Hue el %ucle while<
con la salvedad de Hue la condicin se prue%a al *inal del %ucle< por
lo Hue el %ucle siempre se eLecutar2 al menos una vez.
do
{
"nstrucciones;
} RFile (una1aria-le MM valor);
El si(uiente eLemplo asi(na el valor leIdo lee9ensor/0 a la varia%le
PJP< espera @# milise(undos< , lue(o continua mientras Hue el valor
de la PJP sea in*erior a ##:
do
{
2
8 2 leeSensor();
dela((&*);
} RFile (8 = )**);
2!
e"s digitales
pin+ode(pin, mode)
Esta instruccin es utilizada en la parte de con*i(uracin setup /0 ,
sirve para con*i(urar el modo de tra%aLo de un .1$ pudiendo ser
1$.AT /entrada0 u =AT.AT /salida0.
pinMode(pin, OUTPUT); // configura $pin% como salida
;os terminales de Arduino< por de*ecto< est2n con*i(urados como
entradas< por lo tanto no es necesario de*inirlos en el caso de Hue
va,an a tra%aLar como entradas. ;os pines con*i(urados como
entrada Huedan< %aLo el punto de vista elctrico< como entradas en
estado de alta impedancia.
Estos pines tienen a nivel interno una resistencia de !# 5^ a las Hue
se puede acceder mediante so*tware. Estas resistencias se accede
de la si(uiente manera:
pinMode(pin, "<PUT); // configura el $pin% como
// entrada
digitalrite(pin, !"#!); // activa las resistencias
// internas
;as resistencias internas normalmente se utilizan para conectar las
entradas a interruptores. En el eLemplo anterior no se trata de
convertir un pin en salida< es simplemente un mtodo para activar
las resistencias interiores.
;os pins con*i(urado como =AT.AT /salida0 se dice Hue est2n en
un estado de %aLa impedancia estado , pueden proporcionar ?# mA
/miliamperios0 de corriente a otros dispositivos , circuitos. Esta
corriente es su*iciente para alimentar un diodo ;E3 /no olvidando
poner una resistencia en serie0< pero no es lo su*iciente (rande
como para alimentar car(as de ma,or consumo como rels<
solenoides< o motores.
An cortocircuito en las patillas Arduino provocar2 una corriente
elevada Hue puede daKar o destruir el chip Atme(a. A menudo es
2"
una %uena idea conectar en la =ATA.T /salida0 una resistencia
eJterna de ?7# o de ### ^.
digital-ead(pin)
;ee el valor de un pin /de*inido como di(ital0 dando un resultado
-1G- /alto0 o ;=+ /%aLo0. El pin se puede especi*icar ,a sea como
una varia%le o una constante /#8:0.
valor 2 digital3ead(Pin); // Face :ue 'valor sea igual
// al estado leTdo en 'Pin'
digital.rite(pin, value)
EnvIa al TpinT de*inido previamente como =AT.AT el valor -1G- o
;=+ /poniendo en o # la salida0. El pin se puede especi*icar ,a
sea como una varia%le o como una constante /#8:0.
digitalrite(pin, !"#!); // deposita en el 'pin' un
valor // !"#! (alto o ))
El si(uiente eLemplo lee el estado de un pulsador conectado a una
entrada di(ital , lo escri%e en el TpinTde salida ;E3:
int led 2 )7; // asigna a +;G el valor )7
int -oton 2 H; // asigna a -ot/n el valor H
int valor 2 *; // define el valor ( le asigna el
// valor *
void setup()
{
pinMode(led, OUTPUT); // configura el led (pin)7) como
salida
pinMode(-oton, "<PUT); // configura -ot/n (pinH) como
entrada
}
void loop()
{
valor 2 digital3ead(-oton); //lee el estado de la
// entrada -ot/n
digitalrite(led, valor); // envTa a la salida 'led'el
} // valor leTdo
2#
e"s analgicas
analog-ead(pin)
;ee el valor de un determinado pin de*inido como entrada anal(ica
con una resolucin
de # %its. Esta instruccin slo *unciona en los pines /#8@0. El ran(o
de valor Hue podemos leer oscila de # a #!:.
valor 2 analog3ead(pin); // asigna a valor lo :ue lee
// en la entrada 'pin'
&ota: ;os pins anal(icos /#8@0 a di*erencia de los pines di(itales< no
necesitan ser declarados como 1$.AT u =A.AT ,a Hue son
siempre 1$.ATTs.
analog.rite(pin, value)
Esta instruccin sirve para escri%ir un pseudo8valor anal(ico
utilizando el procedimiento de modulacin por ancho de pulso
/.+M0 a uno de los pinTs de Arduino marcados como Qpin .+MR. El
m2s reciente Arduino< Hue implementa el chip ATme(aB"< permite
ha%ilitar como salidas anal(icas tipo .+M los pines :< @< B< >< # ,
. ;os modelos de Arduino m2s anti(uos Hue implementan el chip
ATme(a"< solo tiene ha%ilitadas para esta *uncin los pines >< # ,
. El valor Hue se puede enviar a estos pines de salida anal(ica
puede darse en *orma de varia%le o constante< pero siempre con un
mar(en de #8!@@.
analogrite(pin, valor); // escri-e 'valor' en el 'pin'
// definido como anal/gico
9i enviamos el valor # (enera una salida de # voltios en el pin
especi*icadoE un valor de !@@ (enera una salida de @ voltios de
salida en el pin especi*icado. .ara valores de entre # , !@@< el pin
saca tensiones entre # , @ voltios 8 el valor -1G- de salida eHuivale
a @v /@ voltios0. Teniendo en cuenta el concepto de seKal .+M < por
eLemplo< un valor de B? eHuivaldr2 a mantener # voltios de tres
cuartas partes del tiempo , @ voltios a una cuarta parte del tiempoE
un valor de !" eHuivaldr2 a mantener la salida en # la mitad del
2$
tiempo , @ voltios la otra mitad del tiempo< , un valor de >!
eHuivaldr2 a mantener en la salida # voltios una cuarta parte del
tiempo , de @ voltios de tres cuartas partes del tiempo restante.
3e%ido a Hue esta es una *uncin de hardware< en el pin de salida
anal(ica /.+$0 se (enerar2 una onda constante despus de
eLecutada la instruccin analo(+rite hasta Hue se lle(ue a eLecutar
otra instruccin analo(+rite /o una llamada a di(italRead o
di(ital+rite en el mismo pin0.
$ota: ;as salidas anal(icas a di*erencia de las di(itales< no
necesitan ser declaradas como 1$.AT u =AT.AT..
El si(uiente eLemplo lee un valor anal(ico de un pin de entrada
anal(ica< convierte el valor dividindolo por ?< , envIa el nuevo
valor convertido a una salida del tipo .+M o salida anal(ica:
int led 2 )*; // define el pin )* como 'led'
int analog 2 *; // define el pin * como 'analog'
int valor; // define la varia-le 'valor'
void setup(){} // no es necesario configurar
// entradas ( salidas
void loop()
{
valor 2 analog3ead(analog); // lee el pin * ( lo
asocia a //la varia-le valor
valor /2 4; //divide valor entre 4 ( lo
//reasigna a valor
analogrite(led, value); // escri-e en el pin)* valor
}
30
control del tiempo
dela!(ms)
3etiene la eLecucin del pro(rama la cantidad de tiempo en ms Hue
se indica en la propia instruccin. 3e tal manera Hue ### eHuivale a
se(.
dela(()***); // espera ) segundo
millis()
3evuelve el nOmero de milise(undos transcurrido desde el inicio del
pro(rama en Arduino hasta el momento actual. $ormalmente ser2
un valor (rande /dependiendo del tiempo Hue este en marcha la
aplicacin despus de car(ada o despus de la Oltima vez Hue se
puls el %otn QresetR de la tarLeta0.
valor 2 millis(); // valor recoge el nUmero de
// milisegundos
$ota: Este nOmero se des%ordar2 /si no se resetea de nuevo a
cero0< despus de aproJimadamente > horas.
31
+atem/ticas
min(0, !)
4alcula el mInimo de dos nOmeros para cualHuier tipo de datos
devolviendo el nOmero m2s peHueKo.
valor 2 min(valor, )**); // asigna a valor el m0s
// pe:ueVos de los dos
// nUmeros especificados,
9i PvalorP es menor Hue ## valor reco(er2 su propio valor si TvalorT
es ma,or Hue ## valor pasara a valer ##.
ma0(0, !)
4alcula el m2Jimo de dos nOmeros para cualHuier tipo de datos
devolviendo el nOmero ma,or de los dos.
valor 2 ma8(valor, )**); // asigna a valor el ma(or de
// los dos nUmeros 'valor' (
// )**,
3e esta manera nos ase(uramos de Hue valor ser2 como mInimo
##.
32
aleatorios
random1eed(seed)
Esta%lece un valor< o semilla< como punto de partida para la *uncin
random/0.
randomSeed(valor); // Face :ue valor sea la semilla del
// random
3e%ido a Hue Arduino es incapaz de crear un verdadero nOmero
aleatorio< random9eed le permite colocar una varia%le< constante< u
otra *uncin de control dentro de la *uncin random< lo Hue permite
(enerar nOmeros aleatorios Ual azarU. -a, una variedad de semillas<
o *unciones< Hue pueden ser utilizados en esta *uncin< incluido millis
/0 o incluso analo(Read /0 Hue permite leer ruido elctrico a travs
de un pin anal(ico.
random(ma0), random(min, ma0)
;a *uncin random devuelve un nOmero aleatorio entero de un
intervalo de valores especi*icado entre los valores min , maJ.
valor 2 random()**, 6**); // asigna a la varia-le
// 'valor' un numero aleatorio
// comprendido entre )**56**
$ota: Ase esta *uncin despus de usar el random9eed/0.
El si(uiente eLemplo (enera un valor aleatorio entre #8!@@ , lo envIa
a una salida anal(ica .+M :

int rand<um-er; // varia-le :ue almacena el valor
// aleatorio
int led 2 )*; // define led como )*
void setup() {} // no es necesario configurar nada
void loop()
{
33
randomSeed(millis()); // genera una semilla para
// aleatorio a partir
// de la funci/n millis()
rand<um-er 2 random(6&&); // genera nUmero aleatorio
// entre *56&&
analogrite(led, rand<um-er); // envTa a la salida
// led de tipo PM el
// valor
dela((&**); // espera *,& seg,
}
34
comunicacin serie
1erial.begin(rate)
A%re el puerto serie , *iLa la velocidad en %audios para la transmisin
de datos en serie.
El valor tIpico de velocidad para comunicarse con el ordenador es
>B##< aunHue otras velocidades pueden ser soportadas.
void setup()
{
Serial,-egin(AE**); // a-re el Puerto serie
} // configurando la velocidad en AE** -ps
$ota: 4uando se utiliza la comunicacin serie los pins di(ital # /R]0
, /T]0 no puede utilizarse al mismo tiempo.
1erial.println(data)
1mprime los datos en el puerto serie< se(uido por un retorno de carro
autom2tico , salto de lInea. Este comando toma la misma *orma Hue
9erial.print/0< pero es m2s *2cil para la lectura de los datos en el
Monitor 9erie del so*tware.
Serial,println(analog1alue); // envTa el valor
// 'analog1alue' al
// puerto
$ota: .ara o%tener m2s in*ormacin so%re las distintas posi%ilidades
de 9erial.println /0 , 9erial.print /0 puede consultarse el sitio we% de
Arduino.
El si(uiente eLemplo toma de una lectura anal(ica pin# , envIa
estos datos al ordenador cada se(undo.
void setup()
{
Serial,-egin(AE**); // configura el puerto serie a
// AE**-ps
}
void loop()
3
{
Serial,println(analog3ead(*)); // envTa valor anal/gico
dela(()***); // espera ) segundo
}
1erial.print(data, data t!pe)
Suelca o envIa un nOmero o una cadena de carateres< al puerto
serie. 3icho comando puede tomar di*erentes *ormas< dependiendo
de los par2metros Hue utilicemos para de*inir el *ormato de volcado
de los nOmeros.
2ar/metros
data: el nOmero o la cadena de caracteres a volcar o enviar.
data t!pe: determina el *ormato de salida de los valores numricos
/decimal< octal< %inario< etc...0 3E4< =4T< '1$< -E]< '_TE < si no se
pe nada vuelva A9411
ELemplos:
Serial,print(-) // 1uelca o envTa el valor de - como
// un nUmero decimal en caracteres
// BSO"",
int - 2 HA;
Serial,print(-); // imprime la cadena WHAW,
Serial,print(-, !;X); // 1uelca o envTa el valor de
// - como un nUmero Fe8decimal
// en caracteres BSO"" W4.W,
Serial,print(-, OOT); // 1uelca o envTa el valor de
// - como un nUmero Octal en
// caracteres BSO"" W))HW,
Serial,print(-, N"<) // 1uelca o envTa el valor de
// - como un nUmero -inario en
// caracteres BSO"" W)**))))W,
Serial,print(-, NYT;); // Gevuelve el caracter WOW,
// el cual representa el
// caracter BSO"" del valor
// HA, (1er ta-la BSO""),
Serial,print(str); //1uelca o envTa la cadena de
// caracteres como una cadena BSO"",
Serial,print(W!ello orldIW); // vuelca W!ello orldIW,
3!
1erial.avaible()
3evuelve An entero con el nOmero de %,tes disponi%les para leer
desde el %u**er serie< o # si no ha, nin(uno. 9i ha, al(On dato
disponi%le< 9erialAvaila%le/0 ser2 ma,or Hue #. El %u**er serie puede
almacenar como m2Jimo B? %,tes.
int Serial,availa-le() // O-tiene un nUmero entero
// con el nUmero de -(tes
// (caracteres) disponi-les
// para leer o capturar desde
// el puerto serie
ELemplo
int incomingN(te 2 *; // almacena el dato serie
void setup() {
Serial,-egin(AE**); // a-re el puerto serie, ( le asigna
// la velocidad de AE** -ps
}
void loop() {
if (Serial,availa-le() J *) // envTa datos s/lo si
{ // los reci-eZ
incomingN(te 2 Serial,read();// lee el -(te de entradaZ
//lo vuelca a pantalla
Serial,print(W" receivedZ W);
Serial,println(incomingN(te, G;O);
}
}
3"
1erial.-ead()
;ee o captura un %,te /un caracter0 desde el puerto serie.
3evuelve el si(uiente %,te /car2cter0 desde el puerto serie< o 8 si no
ha, nin(uno.
ELemplo:
int incomingN(te 2 *; // almacenar el dato serie
void setup() {
Serial,-egin(AE**); // a-re el puerto serie,( le asigna
// la velocidad de AE** -ps
}
void loop() {
if (Serial,availa-le() J *)// envTa datos s/lo si los
{ // reci-e
incomingN(te 2 Serial,read(); // lee el -(te de
// entrada ( lo vuelca
Serial,print(W" receivedZ W); // a pantalla
Serial,println(incomingN(te, G;O);
}
}
3#
ap)ndices
3$
salida digital
`ste es el eLemplo %2sico eHuivalente al Uhola mundoU de cualHuier
len(uaLe de pro(ramacin haciendo simplemente el encendido ,
apa(ado de un led. En este eLemplo el ;E3 est2 conectado en el
pin:< , se enciende , apa(a QparpadeaR cada se(undo. ;a
resistencia Hue se de%e colocar en serie con el led en este caso
puede omitirse ,a Hue el pin: de Arduino ,a inclu,e en la tarLeta
esta resistencia<
int ledPin 2 )7; // +;G en el pin digital )7
void setup() // configura el pin de salida
{
pinMode(ledPin, OUTPUT); // configura el pin )7 como
salida
}
void loop() // inicia el -ucle del programa
{
digitalrite(ledPin, !"#!); // activa el +;G
dela(()***); // espera ) segundo
digitalrite(ledPin, +O); // desactiva el +;G
dela(()***); // espera ) segundo
}
40
entrada digital
`sta es la *orma m2s sencilla de entrada con slo dos posi%les
estados: encendido o apa(ado. En este eLemplo se lee un simple
switch o pulsador conectado a .1$!. 4uando el interruptor est2
cerrado el pin de entrada se lee A;T= , encender2 un ;E3 colocado
en el .1$:
int ledPin 2 )7; // pin )7 asignado para el +;G de
// salida
int inPin 2 6; // pin 6 asignado para el pulsador
void setup() // Oonfigura entradas ( salidas
{
pinMode(ledPin, OUTPUT); // declara +;G como salida
pinMode(inPin, "<PUT); // declara pulsador como
} // entrada
void loop()
{
if (digital3ead(inPin) 22 !"#!) // testea si la entrada
{ // esta activa !"#!
digitalrite(ledPin, !"#!); // enciende el +;G
dela(()***); // espera ) segundo
digitalrite(ledPin, +O); // apaga el +;G
}
}
41
salida de alta corriente de consumo
A veces es necesario
controlar car(as de m2s
de los ?# mA Hue es
capaz de suministrar la
tarLeta Arduino. En este
caso se hace uso de un
transistor M=96ET Hue
puede alimentar car(as
de ma,or consumo de
corriente. El si(uiente
eLemplo muestra como el
transistor M=96ET
conmuta @ veces cada
se(undo.
$ota: El esHuema
muestra un motor con un diodo de proteccin por ser una car(a
inductiva. En los casos Hue las car(as no sean inductivas no ser2
necesario colocar el diodo.
int outPin 2 &; // pin de salida para el MOS.;T
void setup()
{
pinMode(outPin, OUTPUT); // pin& como salida
}
void loop()
{
for (int i2*; i=2&; i??) // repetir -ucle & veces
{
digitalrite(outPin, !"#!); // activa el MOS.;T
dela((6&*); // espera )/4 segundo
digitalrite(outPin, +O); // desactiva el MOS.;T
dela((6&*); // espera )/4 segundo
}
dela(()***); // espera ) segundo
}
42
salida analgica del tipo pwm
;a Modulacin de 1mpulsos en 6recuencia /.+M0 es una *orma de
conse(uir una Q*alsaR salida anal(ica. Esto podrIa ser utilizado para
modi*icar el %rillo de un ;E3 o controlar un servo motor. El si(uiente
eLemplo lentamente hace Hue el ;E3 se ilumine , se apa(ue
haciendo uso de dos %ucles.
int ledPin 2 A; // pin PM para el +;G
void setup(){} // no es necesario configurar nada
void loop()
{
for (int i2*; i=26&&; i??) // el valor de i asciende
{
analogrite(ledPin, i); // se escri-e el valor de i en
// el P"< de salida del +;G
dela(()**); // pauses for )**ms
}
for (int i26&&; iJ2*; i55) // el valor de i desciende
{
analogrite(ledPin, i); // se escri-e el valor de ii
dela(()**); // pasusa durante )**ms
}
}
43
entrada con potencimetro
/entrada anal(ica0
El uso de un potencimetro , uno de los pines de entrada anal(ica8
di(ital de Arduino /A340 permite leer valores anal(icos Hue se
convertir2n en valores dentro del ran(o de #8#!?. El si(uiente
eLemplo utiliza un potencimetro para controlar un el tiempo de
parpadeo de un ;E3.
int potPin 2 *; // pin entrada para potenci/metro
int ledPin 2 )7; // pin de salida para el +;G
void setup()
{
pinMode(ledPin, OUTPUT); // declara ledPin como SB+"GB
}
void loop()
{
digitalrite(ledPin, !"#!); // pone ledPin en on
dela((analog3ead(potPin)); // detiene la e>ecuci/n
// un tiempo [potPin\
digitalrite(ledPin, +O); // pone ledPin en off
dela((analog3ead(potPin)); // detiene la e>ecuci/n
// un tiempo [potPin\
}
44
entrada conectada a resistencia variable
/entrada anal(ica0
;as resistencias varia%les como los sensores de luz ;43 los
termistores< sensores de es*uerzos< etc< se conectan a las entradas
anal(icas para reco(er valores de par2metros *Isicos. Este eLemplo
hace uso de una *uncin para leer el valor anal(ico , esta%lecer un
tiempo de retardo. Este tiempo controla el %rillo de un diodo ;E3
conectado en la salida.
int ledPin 2 A; // Salida anal/gica PM para
//conectar a +;G
int analogPin 2 *; // resistencia varia-le conectada a la
// entrada anal/gica pin *
void setup(){} // no es necesario configurar entradas ( salidas
void loop()
{
for (int i2*; i=26&&; i??) // incremento de valor de i
{
analogrite(ledPin, i); // configura el nivel -rillo con
// el valor de i
dela((dela(1al()); // espera un tiempo
}
for (int i26&&; iJ2*; i55) // decrementa el valor de i
{
analogrite(ledPin, i); // configura el nivel de -rillo
// con el valor de i
dela((dela(1al()); // espera un tiempo
}
}
int dela(1al()
{
int v; // crea una varia-le temporal
// (local)
v 2 analog3ead(analogPin); // lee valor anal/gico
v /2 @; // convierte el valor leTdo de *5
// )*64 a *5)6@
return v; // devuelve el valor v
}
4
salida conectada a servo
;os servos de modelismo
tienen un motor , unos
en(ranaLes cu,a salida se
puede mover en un arco de
"# a , contienen la
electrnica necesaria para ello. Todo lo Hue se necesita es un pulso
enviado cada !#ms. Este eLemplo utiliza la *uncin servo.ulse para
mover el servo de
#a a 7# a.
int servoPin 2 6; // servo conectado al pin digital 6
int m(Bngle; // 0ngulo del servo de *5)@*
int pulseidtF; // ancFura del pulso para la funci/n
// servoPulse
void setup()
{
pinMode(servoPin, OUTPUT); // configura pin 6 como
} // salida
void servoPulse(int servoPin, int m(Bngle)
{
pulseidtF 2 (m(Bngle 9 )*) ? E**; // determina
// retardo
digitalrite(servoPin, !"#!); // activa el servo
dela(Microseconds(pulseidtF); // pausa
digitalrite(servoPin, +O); // desactiva el servo
dela((6*); // retardo de refresco
}
void loop() // el servo inicia su recorrido en )*] (
{ // gira Fasta )H*]
for (m(Bngle2)*; m(Bngle=2)H*; m(Bngle??)
{
servoPulse(servoPin, m(Bngle);
}
// el servo vuelve desde )H*] Fasta )*]
for (m(Bngle2)H*; m(BngleJ2)*; m(Bngle55)
{
servoPulse(servoPin, m(Bngle);
}
}