Documentos de Académico
Documentos de Profesional
Documentos de Cultura
brian w. Evans
edicin espaola
Traduccin: Jos Manuel Ruiz Gutirrez Adaptacin: Jos Manuel Escuder Martinez
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
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
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.
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.
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; // }
'i' solo es visi-le dentro del -ucle for 'f' es visi-le solo dentro de loop()
14
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".
$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
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
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
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!
;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#
&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
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.
$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
$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 }
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
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$ :
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
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
;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;
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
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
;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;
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); } }