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

contenido
prefacio estructura de un sketch
setup/0 loop/0 *unciones CD entre llaves E punto , coma /FG F/ %loHue de comentarios // lInea de comentarios declaracin de varia%les utilizacin de una varia%le %,te int lon( *loat arra,s asi(naciones compuestas operadores de comparacin operadores l(icos cierto/*also /true/*alse0 hi(h/low input/output i* /si condicional0 i*G else /siG.. sino ..0 *or while doG while pinMode/pin< mode0 di(italRead/pin0 di(ital+rite/pin< value0 analo(Read/pin0 analo(+rite/pin< value0 dela,/ms0 B 7 " > > # # ! ! ? ? ? @ @ " " " !# !# !# ! !! !: !? !? !B !7 !7 !" !" :#

variables

tipos de datos

aritmtica

constantes

control de fjujo

e/s digitales

e/s analgicas

control del tiempo

4 Matemticas aleatorios
millis/0 min/J< ,0 maJ/J< ,0 random9eed/seed0 random/maJ0< random/min< maJ0 9erial.%e(in/rate0 9erial.println/data0 9erial.print/data< data t,pe0 9erial.avai%le/0 9erial.Read/0 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 :# : : :! :! :? :? :@ :B :7 :> ?# ? ?! ?: ?? ?@

comunicacin serie

apndices

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 digital rite(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() { digital rite(pin, !"#!); // pone en uno (on, &v) el'pin' dela(()***); // espera un segundo ()*** ms) digital rite(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; v2 analog3ead(pot); v /2 4; return v; }

// crea una varia-le temporal 'v' // lee el valor del potenci/metro // convierte *5)*67 a *56&& // 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; funci/n // 'value' es visi-le para cual:uier

void setup() { // no es necesario configurar } void loop() { for (int i2*; i=6*;) // { // i?? } // float f; // }

nada en este e>emplo

'i' solo es visi-le dentro del -ucle for 'f' es visi-le solo 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

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; miBrra(C7D 2 )*; // declara un arra( de enteros de E // posiciones // 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??) { analog rite(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 8 8 8 8 8 ?? 55 ?2 52 92 /2 // // // // // // igual igual igual igual igual igual :ue :ue :ue :ue :ue :ue 8 8 8 8 8 8 2 2 2 2 2 2 8 8 8 8 8 8 ?), o incremento de 8 en ?) 5 ), o decremento de 8 en 5) ? (, o incremento de 8 en ?( 5 (, o decremento de 8 en 5( 9 (, o multiplica 8 por ( / (, 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 8 8 8 8 8 22 ( I2 ( = ( J ( =2 ( J2 ( // // // // // // 8 8 8 8 8 8 es no es es es es igual a ( es igual a ( menor :ue ( ma(or :ue ( menor o igual :ue ( 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.
digital rite()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??) { digital rite()7, !"#!); dela((6&*); digital rite()7, +O ); dela((6&*); } // // // // // // declara i ( prue-a si es menor :ue 6*, incrementa i, enciende el pin )7 espera Q seg, apaga el pin )7 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**) // { instrucciones; // // una1aria-le??; // } testea si es menor :ue 6** e>ecuta las instrucciones entre llaves 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); digital rite(pin, !"#!); // // // // configura el $pin% como entrada 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.
digital rite(pin, !"#!); valor // deposita en el 'pin' un // !"#! (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 digital rite(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(a B"< 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!@@.
analog rite(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 )*; int analog 2 *; int valor; void setup(){} // define el pin )* como 'led' // define el pin * como 'analog' // define la varia-le 'valor' // 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 analog rite(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; int led 2 )*; void setup() {} void loop() { // varia-le :ue almacena el valor // aleatorio // define led como )* // no es necesario configurar nada

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&& analog rite(led, rand<um-er); // envTa a la salida // led de tipo P M 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 { digital rite(ledPin, !"#!); // activa el +;G dela(()***); // espera ) segundo digital rite(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; int inPin 2 6;

// pin )7 asignado para el +;G de // salida // 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 !"#!) // { // digital rite(ledPin, !"#!); // dela(()***); // espera digital rite(ledPin, +O ); // } }

testea si la entrada esta activa !"#! enciende el +;G ) segundo 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 { digital rite(outPin, !"#!); // activa el MOS.;T dela((6&*); // espera )/4 segundo digital rite(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 P M para el +;G

void setup(){} // no es necesario configurar nada void loop() { for (int i2*; i=26&&; i??) // el valor de i asciende { analog rite(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 { analog rite(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 *; int ledPin 2 )7; // pin entrada para potenci/metro // pin de salida para el +;G

void setup() { pinMode(ledPin, OUTPUT); // declara ledPin como SB+"GB } void loop() { digital rite(ledPin, !"#!); dela((analog3ead(potPin)); digital rite(ledPin, +O ); dela((analog3ead(potPin)); }

// // // // // //

pone ledPin en on detiene la e>ecuci/n un tiempo [potPin\ pone ledPin en off 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 // Salida anal/gica P M 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 { analog rite(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 { analog rite(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 } A;

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; int m(Bngle; int pulse idtF; // // // // servo conectado al pin digital 6 0ngulo del servo de *5)@* 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) { pulse idtF 2 (m(Bngle 9 )*) ? E**; // determina // retardo digital rite(servoPin, !"#!); // activa el servo dela(Microseconds(pulse idtF); // pausa digital rite(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); } }