Arduino

Nivel Enteraillo
Apuntes de
ARDUINO
Nivel Enteraillo
Daniel Gallardo Garca
Profesor de Tecnologa del IES Laguna de Tolln
DGG 1 de 28
Arduino
Nivel Enteraillo
1. CARACTERSTICAS DE ARDUINO
Las caractersticas tcnicas de la Arduino UNO son
!icrocontrolador AT"ega#$%
Tensin de funciona"iento & '
Tensin de entrada (reco"endada) * + ,$ '
Tensin de entrada (l"ite) - + $. '
Pines de Entradas/Salidas Digitales ,0 (- proporcionan P1!)
Pines de Entradas Analgicas -
Intensidad 2323 por pines de E/S 0. "A
Intensidad 2323 por el pin de #4# ' &. "A
Intensidad 2323 por el pin de & ' #.. "A
!e"oria 5las6 #$ 78 (.4& 78 para 9ootloader)
S:A! $ 78
EEP:O! , 78
5recuencia se;al de relo< ,- !=>
'ea"os algunos pines ?ue pasa"os por alto en el Nivel Pardillo
pin0 RX se usa para reci9ir datos del P2 (serial data)3 En caso de esta9lecer
una co"unicacin Serial en nuestro progra"a4 no conectare"os nada a este pin3
pin1 TX se usa para trans"itir datos al P2 (serial data)3 En caso de esta9lecer
una co"unicacin Serial en nuestro progra"a4 no conectare"os nada a este pin3
RESET funciona igual ?ue el 9otn de reset3 2uando a este pin le llega un pulso
de tensin de valor de . ' (es decir4 poner . ' @ luego volver a ?uitar el . ')4 la
Arduino se resetea4 co"en>ando a e<ecutar desde el principio el progra"a ?ue
estA funcionando3
DGG 2 de 28
Arduino
Nivel Enteraillo
ARE en el caso de utili>ar sensores ?ue generen un rango de tensin por
de9a<o de & '4 pode"os incre"entar la precisin de la lectura 6aciendo ?ue los
,.$0 valores posi9le no va@an desde los . ' a los & '4 sino a un rango "enor de
tensin (de . a ,4, 'B o de . a #4# ')3 Para ello e"plea"os la funcin
ana!o"Re#erence$ %4 ?ue presenta tres variantes
analogReference(INTERNAL); // to"a co"o tensin de referencia ,4, '
analogReference(EXTERNAL); /C to"a co"o referencia la tensin ?ue
6a@a en el pin A:E53 Si ?uiero ?ue esa tensin sea #4# '4 lo Dnico ?ue tendrA
?ue 6acer serE conectar el pin #4#' con el pin A:E5 C/
analogReference(DEFAULT); // to"a el valor por defecto & '
Para ?ue sur<a efecto los nuevos valores de referencia de la tensin en las
entradas analgicas4 de9e"os lla"ar a la funcin analogReference() antes
de utili>ar la funcin analogRead()3
Los pines A0&A' ta"9iAn pueden utili>arse co"o entradas digitales o co"o
salidas analgicas @ digitales3 No tene"os "Es ?ue incluirlas en el void
setup() co"o los siguientes pines despDes del ,#4 es decir el ,04 ,&4 ,-4 ,*4
,%4 ,F (?ue corresponden al A.4 A,4 A$4 A#4 A04 A&)
pinMode(16,OUTPUT); //utili>arA el pin A$ co"o salida
Asi"is"o4 no es estricta"ente necesario configurar los pines co"o INPUT u
OUTPUT dentro de void setup()3 Si"ple"ente de9e"os interpretar al 9lo?ue
void setup() co"o una parte del cdigo ?ue Arduino sola"ente la corre una
ve> (al principio)4 @ en la ?ue pode"os e<ecutar cual?uier funcin3
(. TI)OS DE *ARIA+,ES
Los tipos de -aria.!es son
boolean al"acena un valor con dos posi9ilidades . o ,4 o verdadero o falso3
char al"acena un caracter4 co"o una letra o s"9olo3 Ta"9iAn se puede
e"plear para un nD"ero entero entre G,$% a ,$* (, 9@te)3
byte al"acena un nD"ero natural entre . @ $&& (, 9@te)3
int al"acena un nD"ero entero entre G#$*-F @ #$*-* ($ 9@tes)3
unsigned int al"acena un nD"ero natural entre . @ -&&#- ($ 9@tes)3
DGG 3 de 28
Arduino
Nivel Enteraillo
long al"acena un nD"ero entero entre G$,0*0%#-0% @ $,0*0%#-0* (0 9@tes)3
unsigned long al"acena un nD"ero entero entre . @ 0$F0F-*$F& (0 9@tes)3
float al"acena un nD"ero deci"al con un rango entre G#30.$%$#&H,.
38
@
#30.$%$#&H,.
38
(0 9@tes)3
double en el lengua<e 24 al"acenara un nD"ero deci"al con "uc6si"a
precisin4 con un valor "EIi"o de ,4*F*-F#,#0%-$#,&*H,.
308
3 Sin e"9argo4 en
Arduino es lo "is"o ?ue float (0 9@tes)3
const especifica ?ue la varia9le definida no podrE ser ca"9iada durante el
progra"a4 siendo sie"pre un valor constante
const float pi=3.1415;
Una varia9le @a declarada se puede ca/.iar de tipo de -aria.!e durante el progra"a
float pi=3.1415;
int x;

x=int(pi); /CI pasarE a valer #4 pues es el resultado de eli"inar la parte

deci"al3 Es igual"ente vElida la siguiente no"enclatura
x=(int)pi; C/
En el caso de ?ue va@a"os a dec!arar -arias -aria.!es de! /is/o tipo4 pode"os
acortar nuestro cdigo separando las varia9les por co"a
int a=6,b=9,c=11;
0. ARRA1S
ARRA12 al"acena una lista de varia9les4 accediendo a cada una de ellas a travAs de su
ndice (el pri"ero sie"pre es el cero)
int datos[] = {4,7,9,12,18};
siendo datos[0]=4; datos[1]=7; . datos[4]=18;
En este caso no 6a sido necesario especificar el ta"a;o del arra@ por?ue 6e"os
incluido el valor de todas las varia9les4 pero si no declaro los valores iniciales4
de9o especificar el ta"a;o del arra@
int datos[5];
DGG 4 de 28
Arduino
Nivel Enteraillo
EIiste ta"9iAn otra for"a de lla"ar los distintos ele"entos del arra@4 a travAs de
un puntero3 El pri"er ele"ento corresponde a *datos4 @ para lla"ar a los
siguientes no tene"os "Es ?ue su"ar su posicin relativa
*datos == datos[0]
*datos+1 == datos[1]
*datos+2 == datos[2]
. == .
*datos+n == datos[n]
Ta"9iAn es posi9le al"acenar datos ordenados en for"a de /atri3 o arra4
/u!tidi/ensiona! donde cada dato estarE locali>ado por un do9le ndice (o triple4
o cuEdruple4 etcJ)3 En los arra@s "ultidi"ensionales s es necesario
especi#icar e! ta/a5o de !as respecti-as di/ensiones (eIcepto la pri"era)
aun?ue declares todos sus ele"entos3
int matriz[3][3] = {{2,4,8},{3,9,27},{5,25,125}};
siendo matriz[0][0]=2; matriz[0][1]=4; . matriz[2][2]=125;
Arra4 de CARACTERES o STRIN62 al"acena una cadena de caracteres4 @ se e"plea
para al"acenar teItos3 EIisten varias opciones
char letra='a';
Al"acena un carEcter3
char texto[]=Me gusta Arduino!;
Los ,% caracteres ?ue co"ponen la cadena de teIto (,* caracteres K , para
indicar el fin de la cadena4 ?ue aun?ue no apare>ca4 estE a6 '\0') son
al"acenados co"o ele"entos separados en el arra@3 Por e<e"plo
char texto[0]='M'; char texto[2]=' '; char texto[16]='!';
Ntese ?ue se e"plean co"illas do9les ( ) para cadenas @ co"illas si"ples
(' ') para caracteres individuales3
char texto[]={'M','e',' ','g','u','s','t','a',' ',
'A','r','d','u','i','n','o','!'};
De esta otra for"a4 vElida pero "Es la9oriosa4 declaro individual"ente todos los
caracteres ?ue co"ponen el arra@3
char* palabra=Arduino;
char* frase=Me gusta Arduino;
char* color[]={Rojo,Azul,Verde limn};
Esta otra variante4 con el asterisco (*)4 se utili>a para al"acenar pala9ras4 frases4
o un arra@ de pala9ras @ frases4 donde cada ele"ento del arra@ es un grupo de
caracteres
char* color[0]=Rojo; char* color[2]=Verde limn;
DGG 5 de 28
Arduino
Nivel Enteraillo
La funcin si3eo# $ % per"ite reconocer el ta"a;o del arra@4 en nD"ero de 9@tes
sizeof(datos);
Por e<e"plo
int edades[]={36,5,68,15,22,41};
char texto[]= Me llamo Daniel;
int x=sizeof(edades); /C x to"arE un valor de ,$ (cada varia9le
definida co"o int ocupa $ 9@tes C/
int y=sizeof(texto); /C y to"arE un valor de ,- (cada caracter ocupa
, 9@tes K , ?ue indica el final de la cadena C/
Esta funcin slo se utili>a en los casos en los ?ue se e"plee el ta"a;o del arra@
@ sea pro9a9le ca"9iar dic6o arra@ sin tener ?ue ca"9iar el resto de cdigo del
progra"a3 Ejemplo: imprimir un mensaje letra a letra
char mensaje[]=Leeme despacito, pisha; //ocupa 22+1 bytes
int i;
void setup(){
Serial.begin(9600);
}
void loop() {
for (i=0; i < sizeof(mensaje)-1; i++){ //imprimir los 22 caracteres
Serial.print(i,DEC);
Serial.print(" = ");
Serial.println(mensaje[i],BYTE);
delay(500);
}
}
Si por e<e"plo ?uisiera 6acer algo parecido con un arra@ del tipo int4 de9era
poner
for (i=0; i < sizeof(datos)/2; i++){ //cada nmero ocupa 2 bytes
7. DEINIR UNCIONES void funcin(){ int funcin(){
SegDn las caractersticas de un progra"a4 se puede volver "u@ Dtil la utili>acin de
funciones definidas por nosotros "is"os3 Todo lengua<e de progra"acin de9e
prestarse a esta posi9ilidad4 @ Arduino no es una eIcepcin3 EIisten varias for"as de
definir una funcin
Si de la funcin ?ue ?uere"os definir no se espera ningDn valor de retorno4 @ se
li"ita a reali>ar una serie de rdenes ?ue dependan (o no) de ciertas varia9les4
entonces la funcin (?ue sera una "era su.rutina) se define de la siguiente
"anera
void funcion (a,b) {}
DGG 6 de 28
Arduino
Nivel Enteraillo
donde a @ b seran varia9les ?ue la funcin de9era utili>ar (por supuesto4 6a9rE
funciones ?ue no necesiten de ninguna varia9le)3 Si dic6as varia9les no esta9an
declaradas con anterioridad4 6a9rE ?ue declararlas en ese "is"o "o"ento
void funcion (int a,int b) {}
Si la funcin ?ue va"os a definir ?uiero ?ue /e de-ue!-a un -a!or4 de9o
declararla co"o si de una varia9le se tratara4 especificando ?uA tipo de varia9le
es dic6o valor (int4 long4 float4J)3 Para ?ue la funcin to"e un valor4
de9e"os utili>ar la funcin return aco"pa;ada de la varia9le cu@o valor ?uiero
asignar a la funcin3
int funcion (a,b) { //ta"9iAn puede "ane<ar varia9les
int val=0;
;
val= ;
return val;
}
Si deseo en algDn "o"ento del cdigo de la funcin interru"pirla @ salir de ella (de
"anera anEloga al break en las estructuras)4 @ seguir el progra"a por la siguiente lnea
despuAs de la lla"ada de la funcin4 utili>arA el co"ando return; (sin aco"pa;arlo de
ninguna varia9le o dato4 con lo cual devuelve un valor vaco)3
Proyecto 1. Emisor de seal de emergencia luminoso: S.O.S. en cdigo orse
E"pleare"os un si"ple LED para enviar nuestra se;al de socorro en cdigo !orse
S3O3S3 (Save Our Souls)4 es decir 8 8 8 (S) 9 9 9 (O) 8 8 8 (S)3
Tendra"os dos opciones a la 6ora de reali>ar el progra"a
=acerlo verdadera"ente sencillo4 con "uc6o copiar @ pegar lneas co"o
digitalWrite(ledPin,HIGH); delay(200); digitalWrite(ledPin,LOW); delay(200)
para cada punto o ra@a (la ra@a sera con un delay(500))3
O acortar "uc6o (@ por ?uA no4 e"9ellecer) el cdigo de nuestro progra"a e"pleando
dos cosas definiendo una funcin ?ue 6arE el pulso de lu> (flas6) @ un arra@ para la
duracin de dic6os pulsos
int ledPin=13;
int tiempo[]={200,200,200,500,500,500,200,200,200};
void setup(){
pinMode(ledPin,OUTPUT);
}
void loop(){
for(int i=0;i<9;i++) flash(tiempo[i]);
delay(800);
}
void flash(int duracion){
digitalWrite(ledPin,HIGH); delay(duracion);
digitalWrite(ledPin,LOW); delay(duracion);
DGG 7 de 28
Arduino
Nivel Enteraillo
}
O9serva"os ?ue pode"os definir la funcin al final del cdigo3 Asi"is"o4 de9e"os
tener cierto cuidado con los arra@s4 pues en este caso4 tiempo no es ninguna varia9le
?ue 6a@a sido definida4 sino ?ue las varia9les son
tiempo[0], tiempo[1], tiempo[8].
'. UNCIONES DE TIE:)O delay(); millis();
La vi"os anterior"ente la funcin de!a4 $ %;
delay(1000); //reali>a una pausa en el progra"a de ,... "s
'ea"os a6ora otras funciones de tie"po
de!a4:icroseconds $ %; /i!!is $ %; /icros $ %;
delayMicroseconds(350); //reali>a una pausa en el progra"a de #&. s
x = millis(); /Casigna a x el nD"ero de "ilisegundos ?ue 6an pasado desde ?ue
la placa Arduino fue reseteada (es una varia9le del tipo unsigned
long)3 Se producira un des9orda"iento a los &. das C/
x = micros(); /Casigna a x el nD"ero de "icrosegundos ?ue 6an pasado desde
?ue la placa Arduino fue reseteada (es una varia9le del tipo
unsigned long)3 Se producira un des9orda"iento a los *. "inutos C/
De9e"os tener presente a!"unas consideraciones so9re estas funciones de tie"po
Puede ?ue sea necesario declarar los argu"entos para delay() @
delayMicroseconds() co"o varia9les del tipo long o unsigned long si lo
?ue ?uere"os es e"plear pausas largas (del orden del "inuto4 por e<e"plo)3 Si
considera"os delay(60*1000); no 6arE una pausa de , "inuto4 pues al
utili>ar los nD"eros -. @ ,...4 Arduino los interpreta co"o enteros (int) @ el
resultado so9repasa el l"ite de #$*-*4 @ por el contrario dara un valor de G&&#-3
Es posi9le indicar a Arduino ?ue interprete un nD"ero co"o long4 co"o
unsigned o co"o a"9os colocando tras Al las letras l o L4 @/o u o U
255u considera a la constante $&& co"o una varia9le del tipo unsigned int
1000L considera a la constante ,... co"o una varia9le del tipo long
32767ul considera a la constante #$*-* co"o una varia9le del tipo unsiged long
De esta for"a4 delay(60*1000L); 6arE una pausa de , "inuto.
En el caso de no ?uerer detener el progra"a4 por e<e"plo al 6acer parpadear un
LED (co"o ocurre con delay())4 @ ?ue pueda reali>ar otras tareas "ientras
parpadea4 de9e"os 6acer uso de la funcin millis()3 Un e<e"plo sera
int estado = LOW;
unsigned long tiempo = 0;
unsigned long intervalo = 500;
DGG 8 de 28
Arduino
Nivel Enteraillo
void setup(){pinMode(13,OUTPUT);}
void loop(){
if(tiempo+intervalo < millis()){
estado = !estado;
digitalWrite(13,estado);
tiempo = millis();
}
}
Otra funcin ?ue se utili>a en las entradas digitales es pu!seIn$pin<val%;
?ue deter"ina el tie"po transcurrido 6asta ?ue se vuelva a repetir el "is"o valor de
lectura en la entrada digital nM pin3 Es una funcin "u@ utili>ada4 por e<e"plo4 para leer
sensores de infrarro<o (I:)4 de ultrasonido (donde Tigger @ Ec6o sean el "is"o pin) o
aceler"etros4 ?ue producen co"o salida pulsos de duracin varia9le3
x = pulseIn(7,HIGH); /Casigna a x el tie"po transcurrido 6asta el prIi"o
pulso en estado HIGH C/
=. UNCIONES :ATE:>TICAS x = abs(val);
Arduino inclu@e en su lengua<e "uc6as #unciones /ate/?ticas3 'eE"oslas
x = min(a,b); //asigna a x el valor "Es pe?ue;o entre a @ b
x = max(a,b); //asigna a x el valor "Es grande entre a @ b
x = abs(a); //asigna a x el valor a9soluto de a
x = constrain(val,a,b); /Casigna a x el valor de val sie"pre @ cuando val
estA co"prendido entre a @ b3 En caso de val salga de dic6o
intervalo4 to"arE los valores eItre"os de este
x = sq(a); //asigna a x el valor a
2
x = pow(a,b); //asigna a x el valor a
b
x = sqrt(a); //asigna a x el valor ra> cuadrada de a
x = sin(a); //asigna a x el seno(a)4 estando a en radianes
x = cos(a); //asigna a x el coseno(a)4 estando a en radianes
x = tan(a); //asigna a x la tangente(a)4 estando a en radianes
DGG 9 de 28
Arduino
Nivel Enteraillo
@. O)ERADORES +INARIOS = ! " #;
Arduino posee una serie de funciones con los ?ue operar dos .its $.it a .it%4 ?ue
per"iten resolver "uc6os pro9le"as co"unes en progra"acin3
A AND2 "ultiplicacin 9ooleana de dos 9its
x = bit1 & bit2
& 0 1
0 0 0
1 0 1
Si por e<e"plo aplica"os este operador a dos varia9les tipo int4 ?ue
recorde"os ?ue eran nD"ero de ,- 9its4 los 9its se "ultiplicaran uno a uno4 sin
tener en cuenta los acarreos3 E<e"plo
int a=92; //en binario es 0000000001011100
int b=101; //en binario es 0000000001100101
int x=a&b; //el resultado es 0000000001000100, que corresponde al 68
B OR2 su"ador 9ooleano de dos 9its
x = bit1 | bit2
| 0 1
0 0 0
1 0 1
Si por e<e"plo aplica"os este operador a los dos int del e<e"plo anterior
int a=92; //en binario es 0000000001011100
int b=101; //en binario es 0000000001100101
int x=a|b; //el resultado es 0000000001111111, que corresponde al 125
C XOR2 su"ador eIclusivo 9ooleano de dos 9its
x = bit1 ^ bit2
^ 0 1
0 0 0
1 0 1
D NOT2 inversor 9ooleano
x = ~ bit1
~
0 1
1 0
DGG 10 de 28
Arduino
Nivel Enteraillo
Si por e<e"plo aplica"os este operador a una varia9le tipo int
int a=103; //en binario es 0000000001100111
int x=~a; //el resultado es 1111111110011000, que corresponde al -104
Arduino ta"9iAn posee dos #unciones de desp!a3a/iento de .its
EE +itsFi#t !e#t2 despla>a los 9its ?ue co"ponen una varia9le 6acia la
i>?uierda4 rellenando los 6uecos ?ue se van generando a la derec6a con
ceros4 @ perdiAndose todos a?uellos 9its ?ue 6an Nre9osadoO por la
i>?uierda3
'ea"os algDn e<e"plo
int a=5; //en binario es 0000000000000101
int b=a<<3; //en binario es 0000000000101000, que corresponde al 40
int c=a<<14; //en binario es 0100000000000000, y se pierde el primer 1
Es "u@ Dtil co"o "ultiplicador de potencias de $
1<<0 == 1 1<<1 == 2 1<<2 == 4 1<<3 == 8
1<<4 == 16 1<<5 == 32 1<<6 == 64 1<<7 == 128 ...
GG +itsFi#t ri"Ft2 despla>a los 9its ?ue co"ponen una varia9le 6acia la
derec6a4 rellenando los 6uecos ?ue se van generando a la derec6a con
ceros o unos dependiendo de si el signo del valor deci"al de la varia9le es
positivo o negativo4 respectiva"ente4 @ perdiAndose todos a?uellos 9its
?ue 6an Nre9osadoO por la derec6a3
'ea"os algDn e<e"plo
int a=-16; //en binario es 1111111111110000
int b=a>>3; //en binario es 1111111111111110, se rellena con 1s
int c=(unsigned int)a>>3; // 0001111111111110, se rellena con 0s
Es "u@ Dtil co"o divisor de potencias de $
int a=1000;
int x=a>>3; //es como dividir entre 8, siendo x=125
H. ESTRUCTURAS $%ile(){&; do{&$%ile();
=asta a6ora @a 6e"os visto tres tipos de estructura para los progra"as de Arduino
#or
for (incio; condicin; incremento) {}
i#
if() {}
if() {} else {}
if() {} else if() {} else if() {} else {}
DGG 11 de 28
Arduino
Nivel Enteraillo
sIitcF
switch(val){
case 3:; break; case 12: ; break; default:; }
'ea"os a6ora otras estructuras P6ile @ doJP6ile3
IFi!e
while(condicin){} /C"ientras se cu"pla la condicin eIpresada en el
parAntesis4 Arduino reali>arE las rdenes incluidas
entre las llaves3 En caso de no cu"plirse4 se saltarE
dic6o 9lo?ue C/
do & IFi!e
do{}while(condicin); /C9Esica"ente es si"ilar a la estructura while4 con la
diferencia de ?ue al "enos una ve> 6ace lo ?ue estE
entre llaves4 @ luego lo seguirE 6aciendo "ientras se
cu"pla la condicin especificada en while C/
EIisten dos rdenes ?ue pueden incluirse dentro de cual?uier 9ucle (instrucciones
co"prendidas entre las llaves) de las estructuras anteriores .reaJ @ continue3
break; /Cro"pe el 9ucle @ el progra"a continDa por los cdigos ?ue
aparecen detrEs del 9lo?ue C/
continue; /Csalta el resto de cdigo del 9lo?ue para co"en>arlo nueva"ente
desde el principio3 Se utili>a en las estructuras #or< IFi!e @ do C/
'ea"os un e<e"plo si tene"os conectados & LEDs en los pines del
F al ,#4 @ ?uiero ?ue parpadeen en secuencia sola"ente los ?ue
ocupan posicin i"par4 puedo utili>ar el siguiente tro>o de cdigo
for(int i=9; i<=13; i++) {
if(i%2==0) continue; //como i es par, me lo salto
digitalWrite(i,HIGH); delay(500);
digitalWrite(i,LOW); delay (500);
}
En caso de ser i un nD"ero par4 al dividirlo entre $ darE un "dulo
igual a cero4 @ el co"ando continue 6arE ?ue Arduino se salte
todo el resto del cdigo dentro del 9ucle for para co"en>arlo de
nuevo4 pero incre"entando i en ,3
DGG 12 de 28
Arduino
Nivel Enteraillo
Proyecto !. "ectura en cm de la distancia de un o#jeto
Para este pro@ecto e"pleare"os un sensor de
u!trasonido co"o el de la i"agen3 En este caso posee 0
patas dos para ali"entacin (& ' @ GND)4 una para el
disparador de ultrasonido (Trigger) @ otro para el receptor
del eco del ultrasonido (Ec6o)3 Ta"9iAn eIiste otro
"odelo con solo tres patas dos de ali"entacin @ una
tercera ?ue 6a9rE ?ue declararla co"o OUPUT cuando
6aga"os el disparo4 @ luego declararla co"o INPUT para
reci9ir el re9ote4 @ "edir el tie"po a travAs de
pulseIn(pinSensor,HIGH)3
La idea es sencilla con el disparador envia"os un pulso
en HIGH4 @ calcula"os el tie"po ?ue tarda dic6a se;al en
llegar re9otada al receptor3 Luego 6ace"os una
conversin entre los "ilisegundos ?ue e"plea la se;al
para llegar al receptor @ los cent"etros ?ue 6a9rE desde
el sensor al o9<eto ?ue produce el re9ote3
El progra"a podra ser el siguiente
int disparo=8, eco=7; //pines para el sensor de distancia
long tiempoInicial,tiempoFinal,duracion; /*variables que utilizaremos para
obtener el tiempo hasta el rebote */
int cm,senalEco; //variables para los centmetros y para detectar el rebote
void setup(){
Serial.begin(9600);
pinMode(disparo,OUTPUT);
pinMode(eco,INPUT);
}
void loop(){
//Hago un disparo: lanzo un pulso de 5 us de duracin
digitalWrite(disparo,LOW);
delayMicroseconds(2);
digitalWrite(disparo,HIGH);
delayMicroseconds(5);
tiempoInicial=micros(); //pongo el cronmetro a cero
digitalWrite(disparo,LOW);
//Detectar el tiempo que tarda en llegar el rebote
senalEco=digitalRead(eco);
while(senalEco==LOW){
senalEco=digitalRead(eco); //para saber cundo salgo del valor LOW
}
while(senalEco==HIGH){
senalEco=digitalRead(eco);
tiempoFinal=micros();
}
//Calculo la duracin del recorrido sensor-obstculo-sensor
duracion=tiempoFinal-tiempoInicial;
cm=int(duracion/58); /*el sonido se desplaza a 340m/s o 29ms/cm
y como tiene que recorrer dos veces la distancia hasta el objeto,
deberemos dividir entre 2*29 los microsegundos transcurridos */
DGG 13 de 28
Arduino
Nivel Enteraillo
Serial.print("tiempo empleado: "); Serial.print(duracion);
Serial.print(" ms"); Serial.print('\t');
Serial.print("distancia: "); Serial.print(cm); Serial.print(" cm");
/*expresaremos la distancia a travs del Serial Monitor, pero se
podra hacer con un display de 2 dgitos */
delay(1000); /*una pausa es necesaria para poder leer con comodidad los
datos en el Serial Monitor */
}
K. DIS),A1 @LSE6:ENTOS
Un dispositivo de salida "u@ e"pleado es el displa@ *Gseg"entos4 e"pleado
nor"al"ente para "ostrar en Al un nD"ero del . a F3

Este displa@ posee ,. patillas
Los * seg"entos ?ue for"an el nD"ero (a494c4d4e4f4g)3
El punto (dp)3
Dos pines para el Enodo co"Dn3
De9e"os conectar nuestro displa@ de la siguiente "anera
2onectare"os una de las dos patas de Enodo co"Dn a la
tensin de & '4 @ cada una de las restantes patas (seg"entos
@ el punto) a un pin de salida digital a travAs de una
resistencia (de 0*. Q4 por e<e"plo)3
De esta "anera se encenderEn los seg"entos conectados a una salida digital de LOW3
Proyecto $. "a cuenta atr%s
int pinSegmentos[]={9,8,18,17,16,10,11,19}; //(a,b,c,d,e,f,g,.)
//utilizar los pines A2,A3,A4,A5 como salidas digitales
byte segmentosNumero[10][8]={
{1,1,1,1,1,1,0,0}, //nmero 0
{0,1,1,0,0,0,0,0}, //nmero 1
{1,1,0,1,1,0,1,0}, //nmero 2
{1,1,1,1,0,0,1,0}, //nmero 3
{0,1,1,0,0,1,1,0}, //nmero 4
{1,0,1,1,0,1,1,0}, //nmero 5
{1,0,1,1,1,1,1,0}, //nmero 6
{1,1,1,0,0,0,0,0}, //nmero 7
{1,1,1,1,1,1,1,0}, //nmero 8
{1,1,1,1,0,1,1,0}}; //nmero 9
DGG 14 de 28
Arduino
Nivel Enteraillo
void setup(){
for(int i=0;i<8;i++) pinMode(pinSegmentos[i],OUTPUT);
}
void loop(){
for(int i=9;i>=0;i--) {
for(int j=0;j<8;j++) digitalWrite(pinSegmentos[j],!segmentosNumero[i][j]);
/*recordemos que a la hora de interpretar una seal digital, 1,HIGH y TRUE
es lo mismo. Asimismo, lo mismo ocurre con 0,LOW y FALSE.
Como cada segmento encender cuando el pin est en LOW, tal y como hemos
definido nuestros nmero, debemos indicar que en el pin j escriba lo
contrario de los que indica: si es un 1 pues que ponga un LOW, y si es
un 0 pues que ponga un HIGH */
delay(1000);
}
}
10. DIS),A1 7 D6ITOS @LSE6:ENTOS
Otro dispositivo de salida "u@ prEctico es el displa@ de 0 dgitos *Gseg"entos4 e"pleado
nor"al"ente para "ostrar en Al cuatro nD"eros del . a F3

Este displa@ posee ,. patillas
Los * seg"entos ?ue for"an el nD"ero
(a494c4d4e4f4g)3
El punto (dp)3
Un pin para el Enodo co"Dn para cada
uno de los cuatro dgitos3
De9e"os conectar nuestro displa@ de la siguiente "anera
2onectare"os cada uno de los 0 pines de Enodo co"Dn a una salida digital (solo se
activarE el dgito cu@o pin estA en HIGH)4 @ cada una de las restantes patas (seg"entos
@ el punto) a un pin de salida digital a travAs de una resistencia (de 0*. Q4 por e<e"plo)3
De esta "anera se encenderEn los seg"entos conectados una salida digital de LOW3
Proyecto &. 'eloj con minutos y segundos
int segmentosPines[]={7,5,17,15,14,6,18,16}; //(a,b,c,d,e,f,g,.)
int digitosPines[]={10,9,8,19}; //(dgito1,dgito2,dgito3,dgito4)
DGG 15 de 28
Arduino
Nivel Enteraillo
byte segmentosNumeros[10][8]={
{1,1,1,1,1,1,0,0}, //nmero 0
{0,1,1,0,0,0,0,0}, //nmero 1
{1,1,0,1,1,0,1,0}, //nmero 2
{1,1,1,1,0,0,1,0}, //nmero 3
{0,1,1,0,0,1,1,0}, //nmero 4
{1,0,1,1,0,1,1,0}, //nmero 5
{1,0,1,1,1,1,1,0}, //nmero 6
{1,1,1,0,0,0,0,0}, //nmero 7
{1,1,1,1,1,1,1,0}, //nmero 8
{1,1,1,1,0,1,1,0} //nmero 9
};
int unidadesSeg=0,decenasSeg=0,unidadesMin=0,decenasMin=0;
long tiempo=0,intervalo=1000; /*si pusiera intervalo=10 tendra un cronmetro
con una precisin de centsimas de segundo*/
void setup(){
for(int i=0;i<8;i++) pinMode(segmentosPines[i],OUTPUT);
for(int j=0;j<4;j++) pinMode(digitosPines[j],OUTPUT);
}
void loop(){
ponHora(unidadesSeg,decenasSeg,unidadesMin,decenasMin);
if(tiempo+intervalo<millis()){
unidadesSeg++;
if(unidadesSeg==10){unidadesSeg=0; decenasSeg++;}
if(decenasSeg==6){decenasSeg=0; unidadesMin++;}
if(unidadesMin==10){unidadesMin=0; decenasMin++;}
if(decenasMin==6) decenasMin=0;
tiempo=millis();
}
}
void ponHora(int x,int y,int z, int t){
int valores[]={t,z,y,x};
for(int pin=0;pin<4;pin++) { /*har todo dentro de un for: ir llamando a
cada uno de los dgitos e ir colocando en el
display su valor correspondiente*/
for(int i=0;i<4;i++) digitalWrite(digitosPines[i],LOW);
//pongo a LOW todos los pines de dgitos y solo activo uno
digitalWrite(digitosPines[pin],HIGH);
for(int j=0;j<8;j++)
digitalWrite(segmentosPines[j],!segmentosNumeros[valores[pin]][j]);
int punto=x%2; //separar minutos y segundos con un punto parpadeante
if(punto==0 && pin==1) digitalWrite(segmentosPines[7],LOW);
delay(5); /*entre dgito y dgito debemos hacer una pequea pausa
de 3-5 ms sin pausa la lectura es confusa, y con ms
pausa, molesta la lentitud de refresco*/
}
}
DGG 16 de 28
Arduino
Nivel Enteraillo
11. :ATRIM DE ,EDS H N H
Un Dlti"o dispositivo de salida "u@ usado es la "atri> de LEDs4 en este caso una %I%
9icolor (-0 LEDs ro<os @ -0 LEDs verdes)4 con $0 pines de control3 Un es?ue"a de
c"o 6e"os de conectar dic6a "atri> es el siguiente
La for"a de poder representar una i"agen for"ada por estos -0 puntos es 6acer
9arridos por las distintas filas o colu"nas4 de "anera anEloga a co"o se tra9a<a9a con
el displa@ de 0 dgitos3 Para evitar variaciones en la intensidad de 9rillo de los LEDs4 si
el 9arrido lo 6ace"os por filas de9ere"os colocar las resistencias li"itadoras de
corriente (,$. + 0*. Q) en los pines reservados a las colu"nas (co"o aparece en la
figura)4 pero si el 9arrido lo 6ace"os por colu"nas de9erE ser en los pines reservados
para las filas donde intercale"os las resistencias3
Proyecto (. ensaje din%mico a trav)s de una matri* +,+
En este caso4 pondre"os las resistencias en los pines de control de filas3 El progra"a
podra ser el siguiente
int numeroPantallas=20; /*numero de veces que repite una "pantalla" antes de desplazarla un
lugar. Evidentemente este parmetro decidir tambin la velocidad de
avance del texto por la matriz */
int tiempoBarridoColumna=500; /*microseconds en el que est activa cada una de las columnas.
Tardar 8*500 us en barrer toda la "pantalla" */
/* AQUI ES DONDE DEBEMOS ESCRIBIR LA FRASE QUE QUEREMOS QUE "CIRCULE" POR NUESTRA MATRIZ 8X8
Se debe empezar por un doble espacio, y se sustituyen la por ` y la por ^ */
char fraseDinamica[]=" Esto parece una FARMACIA DE GUARDIA + + + ";
int index = 1; //ser la posicin del caracter de la cadena que est siendo mostrado
int offset = 0; //marcar el deslizamiento de las columnas
int filaMatriz[] = {13,12,11,10,19,18,17,16}; //pines para el control de las filas de la matriz
int columnaMatriz[] = {9,8,7,6,5,4,3,2}; //pines para el control de las columnas de LED rojos
//Necesitaremos especificar la posicin de cada caracter en letras[][] declarado ms abajo
//comenzamos por los nmeros
DGG 17 de 28
Arduino
Nivel Enteraillo
const int cero=0,uno=1,dos=2,tres=3,cuatro=4,cinco=5,seis=6,siete=7,ocho=8,nueve=9;
//las letras minsculas
const int a=10,b=11,c=12,d=13,e=14,f=15,g=16,h=17,i=18,j=19,k=20,l=21,m=22,n=23,
enhe=24,o=25,p=26,q=27,r=28,s=29,t=30,u=31,v=32,w=33,x=34,y=35,z=36;
//las letras maysculas
const int A=37,B=38,C=39,D=40,E=41,F=42,G=43,H=44,I=45,J=46,K=47,L=48,M=49,N=50,
ENHE=51,O=52,P=53,Q=54,R=55,S=56,T=57,U=58,V=59,W=60,X=61,Y=62,Z=63;
//y algunos smbolos
const int espacio=64,exclamacion=65,comillas=66,almohadilla=67,dollar=68,porcentaje=69,
ampersand=70,parentesisAbierto=71,parentesisCerrado=72,asterisco=73,mas=74,
coma=75,menos=76,barra=77,dosPuntos=78,puntoComa=79,menor=80,igual=81,mayor=82,
interroganteAbierto=83,interroganteCerrado=84,arroba=85,guionBajo=86,punto=87;
byte datos[] = {0,0,0,0,0,0,0,0}; /*este array almacenar los 8 nmeros (de 8 cifras cada uno)
que configuran las 8 columnas mostradas en cada "pantallazo" */
//construiremos los bitmap (8x7) de cada caracter, siendo 1=ON y 0=OFF
//primero los nmeros (el _ ser para distinguir a los bitmaps de los posicionadores
const int _cero[]= {B01110, B10001, B10011, B10101, B11001, B10001, B01110, B00000};
const int _uno[]= {B00100, B01100, B00100, B00100, B00100, B00100, B01110, B00000};
const int _dos[]= {B01110, B10001, B00001, B00010, B00100, B01000, B11111, B00000};
const int _tres[]= {B11111, B00010, B00100, B00010, B00001, B10001, B01110, B00000};
const int _cuatro[]= {B00010, B00110, B01010, B10010, B11111, B00010, B00010, B00000};
const int _cinco[]= {B11111, B10000, B11110, B00001, B00001, B10001, B01110, B00000};
const int _seis[]= {B00110, B01000, B10000, B11110, B10001, B10001, B01110, B00000};
const int _siete[]= {B11111, B10001, B00010, B00100, B01000, B01000, B01000, B00000};
const int _ocho[]= {B01110, B10001, B10001, B01110, B10001, B10001, B01110, B00000};
const int _nueve[]= {B01110, B10001, B10001, B01111, B00001, B00010, B01100, B00000};
//las letras minsculas
const int _a[]= {B00000, B00000, B01110, B00001, B01111, B10001, B01111, B00000};
const int _b[]= {B10000, B10000, B10110, B11001, B10001, B10001, B11110, B00000};
const int _c[]= {B00000, B00000, B01110, B10000, B10000, B10001, B01110, B00000};
const int _d[]= {B00001, B00001, B01101, B10011, B10001, B10001, B01111, B00000};
const int _e[]= {B00000, B00000, B01110, B10001, B11111, B10000, B01110, B00000};
const int _f[]= {B00110, B01001, B01000, B11100, B01000, B01000, B01000, B01000};
const int _g[]= {B00000, B00000, B01111, B10001, B01111, B00001, B00001, B01110};
const int _h[]= {B10000, B10000, B10110, B11001, B10001, B10001, B10001, B00000};
const int _i[]= {B00100, B00000, B00100, B01100, B00100, B00100, B01110, B00000};
const int _j[]= {B00010, B00000, B00110, B00010, B00010, B00010, B10010, B01100};
const int _k[]= {B01000, B01000, B01001, B01010, B01100, B01010, B01001, B00000};
const int _l[]= {B01100, B00100, B00100, B00100, B00100, B00100, B01110, B00000};
const int _m[]= {B00000, B00000, B11010, B10101, B10101, B10101, B10101, B00000};
const int _n[]= {B00000, B00000, B10110, B11001, B10001, B10001, B10001, B00000};
const int _enhe[] = {B01110, B00000, B10110, B11001, B10001, B10001, B10001, B00000};
const int _o[]= {B00000, B00000, B01110, B10001, B10001, B10001, B01110, B00000};
const int _p[]= {B00000, B00000, B11110, B10001, B11110, B10000, B10000, B10000};
const int _q[]= {B00000, B00000, B01101, B10011, B01111, B00001, B00011, B00001};
const int _r[]= {B00000, B00000, B10110, B11001, B10000, B10000, B10000, B00000};
const int _s[]= {B00000, B00000, B01110, B10000, B01110, B00001, B11110, B00000};
const int _t[]= {B01000, B01000, B11100, B01000, B01000, B01001, B00110, B00000};
const int _u[]= {B00000, B00000, B10001, B10001, B10001, B10011, B01101, B00000};
const int _v[]= {B00000, B00000, B10001, B10001, B10001, B01010, B00100, B00000};
const int _w[]= {B00000, B00000, B10001, B10001, B10101, B10101, B01010, B00000};
const int _x[]= {B00000, B00000, B10001, B01010, B00100, B01010, B10001, B00000};
const int _y[]= {B00000, B00000, B10001, B10001, B01111, B00001, B00001, B01110};
const int _z[]= {B00000, B00000, B11111, B00010, B00100, B01000, B11111, B00000};
//las letras maysculas
const int _A[] = {B01110, B10001, B10001, B10001, B11111, B10001, B10001, B00000};
const int _B[] = {B11110, B10001, B10001, B11110, B10001, B10001, B11110, B00000};
const int _C[] = {B01110, B10001, B10000, B10000, B10000, B10001, B01110, B00000};
const int _D[] = {B11110, B10001, B10001, B10001, B10001, B10001, B11110, B00000};
const int _E[] = {B11111, B10000, B10000, B11110, B10000, B10000, B11111, B00000};
const int _F[] = {B11111, B10000, B10000, B11110, B10000, B10000, B10000, B00000};
const int _G[] = {B01110, B10001, B10000, B10011, B10001, B10001, B01111, B00000};
const int _H[] = {B10001, B10001, B10001, B11111, B10001, B10001, B10001, B00000};
const int _I[] = {B01110, B00100, B00100, B00100, B00100, B00100, B01110, B00000};
const int _J[] = {B00111, B00010, B00010, B00010, B00010, B10010, B01100, B00000};
const int _K[] = {B10001, B10010, B10100, B11000, B10100, B10010, B10001, B00000};
const int _L[] = {B10000, B10000, B10000, B10000, B10000, B10000, B11111, B00000};
const int _M[] = {B10001, B11011, B10101, B10101, B10001, B10001, B10001, B00000};
const int _N[] = {B10001, B10001, B11001, B10101, B10011, B10001, B10001, B00000};
const int _ENHE[] = {B01110, B00000, B10001, B11001, B10101, B10011, B10001, B00000};
const int _O[] = {B01110, B10001, B10001, B10001, B10001, B10001, B01110, B00000};
const int _P[] = {B11110, B10001, B10001, B11110, B10000, B10000, B10000, B00000};
const int _Q[] = {B01110, B10001, B10001, B10001, B10101, B10010, B01101, B00000};
const int _R[] = {B11110, B10001, B10001, B11110, B10100, B10010, B10001, B00000};
const int _S[] = {B01110, B10001, B10000, B01110, B00001, B10001, B01110, B00000};
DGG 18 de 28
Arduino
Nivel Enteraillo
const int _T[] = {B11111, B00100, B00100, B00100, B00100, B00100, B00100, B00000};
const int _U[] = {B10001, B10001, B10001, B10001, B10001, B10001, B01110, B00000};
const int _V[] = {B10001, B10001, B10001, B10001, B10001, B01010, B00100, B00000};
const int _W[] = {B10001, B10001, B10001, B10101, B10101, B10101, B01010, B00000};
const int _X[] = {B10001, B10001, B01010, B00100, B01010, B10001, B10001, B00000};
const int _Y[] = {B10001, B10001, B10001, B01010, B00100, B00100, B00100, B00000};
const int _Z[] = {B11111, B00001, B00010, B00100, B01000, B10000, B11111, B00000};
//caracteres especiales
const int _espacio[] = {B00000, B00000, B00000, B00000, B00000, B00000, B00000, B00000};
const int _exclamacion[] = {B00100, B00100, B00100, B00100, B00100, B00000, B00100, B00000};
const int _comillas[] = {B01010, B01010, B01010, B00000, B00000, B00000, B00000, B00000};
const int _almohadilla[] = {B01010, B01010, B11111, B01010, B11111, B01010, B01010, B00000};
const int _dollar[] = {B00100, B01111, B10100, B01110, B00101, B11110, B00100, B00000};
const int _porcentaje[] = {B11000, B11001, B00010, B00100, B01000, B10011, B00011, B00000};
const int _ampersand[] = {B01100, B10010, B10100, B01000, B10101, B10010, B01101, B00000};
const int _parentesisAbierto[] = {B00010, B00100, B01000, B01000, B01000, B00100, B00010, B00000};
const int _parentesisCerrado[] = {B01000, B00100, B00010, B00010, B00010, B00100, B01000, B00000};
const int _asterisco[] = {B00000, B00000, B00100, B10101, B01110, B10101, B00100, B00000};
const int _mas[] = {B00000, B00000, B00100, B00100, B11111, B00100, B00100, B00000};
const int _coma[] = {B00000, B00000, B00000, B00000, B00000, B01100, B00100, B01000};
const int _menos[] = {B00000, B00000, B00000, B00000, B11111, B00000, B00000, B00000};
const int _barra[] = {B00000, B00000, B00001, B00010, B00100, B01000, B10000, B00000};
const int _dosPuntos[] = {B00000, B01100, B01100, B00000, B01100, B01100, B00000, B00000};
const int _puntoComa[] = {B00000, B00000, B01100, B01100, B00000, B01100, B00100, B01000};
const int _menor[] = {B00010, B00100, B01000, B10000, B01000, B00100, B00010, B00000};
const int _igual[] = {B00000, B00000, B11111, B00000, B11111, B00000, B00000, B00000};
const int _mayor[] = {B01000, B00100, B00010, B00001, B00010, B00100, B01000, B00000};
const int _interroganteAbierto[]={B00100, B00000, B00100, B01000, B10000, B10001, B01110, B00000};
const int _interroganteCerrado[]={B01110, B10001, B00001, B00010, B00100, B00000, B00100, B00000};
const int _arroba[] = {B01110, B10001, B00001, B01101, B10101, B10101, B01110, B00000};
const int _guionBajo[] = {B00000, B00000, B00000, B00000, B00000, B00000, B11111, B00000};
const int _punto[] = {B00000, B00000, B00000, B00000, B00000, B01100, B01100, B00000};
/*declaro el abecedario: un array con los arrays de los bitmap de los distintos carateres que voy
a mostrar en la matriz. Como los elementos del array con cadenas de caracteres utilizo int* */
const int* letras[]={ _cero,_uno,_dos,_tres,_cuatro,_cinco,_seis,_siete,_ocho,_nueve, //del 0 al 9
_a,_b,_c,_d,_e,_f,_g,_h,_i,_j, //del 10 al 19
_k,_l,_m,_n,_enhe,_o,_p,_q,_r,_s, //del 20 al 29
_t,_u,_v,_w,_x,_y,_z,_A,_B,_C, //del 30 al 39
_D,_E,_F,_G,_H,_I,_J,_K,_L,_M, //del 40 al 49
_N,_ENHE,_O,_P,_Q,_R,_S,_T,_U,_V, //del 50 al 59
_W,_X,_Y,_Z,_espacio,_exclamacion,_comillas,_almohadilla,_dollar,_porcentaje,// 60 al 69
_ampersand,_parentesisAbierto,_parentesisCerrado,_asterisco,_mas,
_coma,_menos,_barra,_dosPuntos,_puntoComa, //del 70 al 79
_menor,_igual,_mayor,_interroganteAbierto,_interroganteCerrado,
_arroba,_guionBajo,_punto }; //del 80 al 86
void setup() {
for(int i=0; i<8; i++){ //configuro los pines de control
pinMode(filaMatriz[i], OUTPUT);
pinMode(columnaMatriz[i], OUTPUT);
}
}
void loop() {
actualizaMatriz();
}
void actualizaMatriz(){
construyePantalla();
muestraPantalla(numeroPantallas);
}
//Utilizar el siguiente array con potencias de 2 para manejar los bits de cada bitmap
const int potencias[] = {1,2,4,8,16,32,64,128};
//cada nmero corresponde, en binario, a 00000001, 00000010, 00000100,..., 10000000
void construyePantalla(){ //carga el actual estado de desplazamiento al array datos[]
int caracterAnterior = cogeCaracter(fraseDinamica[index-1]); //por esto empezamos en index=1
int caracterActual = cogeCaracter(fraseDinamica[index]);
int caracterPosterior = cogeCaracter(fraseDinamica[index+1]);
for(int fila=0; fila<8; fila++){ //hago un barrido por la fila
datos[fila]=0; //reseteo a 0 la fila que estoy considerando
for(int columna=0; columna<8; columna++){ //hago un barrido por la columna
/*construir un nmero decimal a base de sumas de tal forma que tenga unos en los lugares
donde quiero que se encienda el LED */
datos[fila] = datos[fila] +
DGG 19 de 28
Arduino
Nivel Enteraillo
(potencias[columna] & (letras[caracterAnterior][fila] << (offset+7) ));
/*cuando muestro un caracter en el borde derecho de la matriz (offset==0), se deberan mostrar
en las dos columnas del borde izquierdo las dos ltimas columnas del caracter anterior */
datos[fila] = datos[fila] +
(potencias[columna] & (letras[caracterActual][fila] << offset ));
//muestro el caracter actual, y lo voy desplazando a travs del offset hacia la izquierda
datos[fila] = datos[fila] +
(potencias[columna] & (letras[caracterPosterior][fila] >> (7-offset) ));
/*cuando voy desplazando el caracter actual, ir apareciendo por la derecha las primeras
columnas del caracter posterior. Se ha puesto (offset+7) y (7-offset) porque los caracteres
tienen una anchura de 5 columnas, y quiero que entre caracter y caracter haya 2 columnas
de separacin */
}
}
offset++; //he terminado una fila, pasara a construir la siguiente
if(offset==6){ //significara que he desplazado una letra entera
offset=0; index++; //cargo un caracter nuevo y pongo offset a cero
if(index==sizeof(fraseDinamica)-2) index=1; //si termina la frase, la reinicio
}
}
void muestraPantalla(int repeticiones){
for(int n=0; n<repeticiones; n++){ //muestra la pantalla acutal un nmero de repeticones
for(int columna=0; columna<8; columna++){ //har el barrido de la matriz columna por columna
for(int i=0; i<8; i++) digitalWrite(filaMatriz[i], LOW); /*pone a LOW todos los pines de
control de filas */
for(int i=0; i<8; i++){ //solo pondr en LOW el pin de la columna que estamos considerando
if(i==columna) digitalWrite(columnaMatriz[i], LOW);
else digitalWrite(columnaMatriz[i], HIGH); /*el resto de pines los pongo a HIGH
(apago la columna de LEDs) */
}
for(int fila=0; fila<8; fila++){ //har el barrido, dentro de la columna activa, por la fila
int Bit=(datos[columna] >> fila) & 1; /*detectar los "1" de las fila si
al multiplicarlo por 1 da 1 */
if(Bit==1) digitalWrite(filaMatriz[fila], HIGH); /*si el bit en el array datos[] es un 1,
encender el LED */
}
delayMicroseconds(tiempoBarridoColumna); //es el tiempo que cada columna est encendida
}
}
}
// veamos como asociamos cada caracter de la cadena con su bitmap
int cogeCaracter(char caracter){
int returnValue;
switch(caracter){
case '0': returnValue = cero; break; case '1': returnValue = uno; break;
case '2': returnValue = dos; break; case '3': returnValue = tres; break;
case '4': returnValue = cuatro; break; case '5': returnValue = cinco; break;
case '6': returnValue = seis; break; case '7': returnValue = siete; break;
case '8': returnValue = ocho; break; case '9': returnValue = nueve; break;
case 'A': returnValue = A; break; case 'a': returnValue = a; break;
case 'B': returnValue = B; break; case 'b': returnValue = b; break;
case 'C': returnValue = C; break; case 'c': returnValue = c; break;
case 'D': returnValue = D; break; case 'd': returnValue = d; break;
case 'E': returnValue = E; break; case 'e': returnValue = e; break;
case 'F': returnValue = F; break; case 'f': returnValue = f; break;
case 'G': returnValue = G; break; case 'g': returnValue = g; break;
case 'H': returnValue = H; break; case 'h': returnValue = h; break;
case 'I': returnValue = I; break; case 'i': returnValue = i; break;
case 'J': returnValue = J; break; case 'j': returnValue = j; break;
case 'K': returnValue = K; break; case 'k': returnValue = k; break;
case 'L': returnValue = L; break; case 'l': returnValue = l; break;
case 'M': returnValue = M; break; case 'm': returnValue = m; break;
case 'N': returnValue = N; break; case 'n': returnValue = n; break;
case '^': returnValue = ENHE; break; case '`': returnValue = enhe; break;
case 'O': returnValue = O; break; case 'o': returnValue = o; break;
case 'P': returnValue = P; break; case 'p': returnValue = p; break;
case 'Q': returnValue = Q; break; case 'q': returnValue = q; break;
case 'R': returnValue = R; break; case 'r': returnValue = r; break;
case 'S': returnValue = S; break; case 's': returnValue = s; break;
case 'T': returnValue = T; break; case 't': returnValue = t; break;
case 'U': returnValue = U; break; case 'u': returnValue = u; break;
case 'V': returnValue = V; break; case 'v': returnValue = v; break;
case 'W': returnValue = W; break; case 'w': returnValue = w; break;
case 'X': returnValue = X; break; case 'x': returnValue = x; break;
case 'Y': returnValue = Y; break; case 'y': returnValue = y; break;
case 'Z': returnValue = Z; break; case 'z': returnValue = z; break;
DGG 20 de 28
Arduino
Nivel Enteraillo
case ' ': returnValue = espacio; break; case '!': returnValue = exclamacion; break;
case '"': returnValue = comillas; break; case '#': returnValue = almohadilla; break;
case '$': returnValue = dollar; break; case '%': returnValue = porcentaje; break;
case '&': returnValue = ampersand; break; case '(': returnValue = parentesisAbierto; break;
case ')': returnValue = parentesisCerrado; break; case '*': returnValue = asterisco; break;
case '+': returnValue = mas; break; case ',': returnValue = coma; break;
case '-': returnValue = menos; break; case '/': returnValue = barra; break;
case ':': returnValue = dosPuntos; break; case ';': returnValue = puntoComa; break;
case '<': returnValue = menor; break; case '=': returnValue = igual; break;
case '>': returnValue = mayor; break; case '': returnValue = interroganteAbierto; break;
case '?': returnValue = interroganteCerrado; break; case '@': returnValue = arroba; break;
case '_': returnValue = guionBajo; break; case '.': returnValue = punto; break;
}
return returnValue;
}
1(. )ANTA,,A ,CD 1=N( 'include (Li)uid*rystal+%,
Uno de los dispositivos "Es espectaculares para nuestra Arduino es sin duda la pantalla
L2D3 En el "ercado pode"os encontrar gran variedad4 pero el "odelo =D00*%. es el
"Es eItendido4 incluso se encuentran "ontadas so9re un s6ield para Arduino UNO
RSuA pines de nuestra Arduino se utili>an para controlar la pantalla L2DT
)in Arduino )in ,CD UNCION
A. 8otones (select4 up4 rig6t4 doPn and left) Definida por el progra"ador
0 ,, D80
8us de 0 9its
& ,$ D8&
- ,# D8-
* ,0 D8*
% 0 :S (register select) !anda datos e instrucciones
F - E (ena9le) =a9ilita la coneIin
,. ,& 8acUlig6t 2ontrola la lu"inosidad
# Potenci"etro 2ontrola el contraste
DGG 21 de 28
Arduino
Nivel Enteraillo
Una opcin "Es 9arata es ad?uirir la L2D @ soldarle una 6ilera de ,- pines
DGG 22 de 28
Arduino
Nivel Enteraillo

En este caso4 los pines corresponden a

)in ,CD
, 'SS . '
$ 'DD & '
# '.
Potenci"etro (de . ' a & ') para controlar el contraste de
la pantalla4 o una resistencia de $4$7 a . '3
0 :S :egister select
& :/1 . ' (solo va"os a escri9ir4 no a leer datos)
- E ena9le
* D8.
(slo para trans"itir datos a % 9its4 cosa ?ue no serE
necesaria nunca)
% D8,
F D8$
,. D8#
,, D80
8US de trans"isin de datos a 0 9its
,$ D8&
,# D8-
,0 D8*
,& LEDK
& ' con una resistencia de $$. Q
(para L2D con retroilu"inacin)
,- LEDG . ' (para L2D con retroilu"inacin)
DGG 23 de 28
Arduino
Nivel Enteraillo
'ea"os c"o controlar nuestro dispositivo L2D a travAs de Arduino
En pri"er lugar4 de9e"os a9rir la li9rera LiquidCrystal.h4 a travAs de
SUetc6 / I"port Li9rar@ / Li?uid2r@stal
Luego de9e"os declarar4 co"o si de varia9les fuera4 nuestra pantalla L2D @
de9e"os asignarle un no"9re3 Ade"Es de9e"os especificar los pines ?ue
va"os a usar para co"unicar Arduino con la L2D
En el caso de la S6ield LD:4 tal @ co"o estE construida4 son los pines %4 F4 04
&4 -4 *B ?ue corresponderEn a :S (register select)4 E (ena9le)4 D804 D8&4
D8-4 D8* (9us de datos)3
En el caso de una LD: si"ple4 pode"os escoger los pines ?ue ?uera"os de
nuestra Arduino3
Esta declaracin se 6ace con el siguiente co"ando
LiquidCrystal nombreLcd(rs,e,db4,db5,db6,db7);
2on la configuracin de la s6ield L2D ?uedara as
LiquidCrystal miLcd(8,9,4,5,6,7);
2on la configuracin de la pantalla L2D si"ple4 podra ?uedar as
LiquidCrystal miLcd(5,6,7,8,9,10);
La patilla LEDK de nuestra L2D controla la lu"inosidad de la pantalla4 @ en
nuestro dispositivo L2D estE conectada a la salida analgica pin ,.4 @ se controla
la lu"inosidad a travAs de un analogWrite(10,brillo);
Dentro del void setup() de9e"os iniciar la li9rera para nuestra L2D4 utili>ando la
funcin begin() @ especificando el ta"a;o4 ?ue en nuestro caso es de ,-I$
caracteres
nombreLcd.begin(16,2);
DGG 24 de 28
Arduino
Nivel Enteraillo
Las funciones para controlar nuestra L2D son
nombreLcd.setCursor(0,7);
SitDa el cursor de nuestra pantalla de ,-I$ en la pri"era lnea4 en el seIto carEcter3
nombreLcd.print("Hola!");
I"pri"e en la posicin fi<ada con anterioridad lo ?ue estA entre co"illas4 @ sitDa el cursor
tras el Dlti"o caracter3 ActDa de "anera anEloga al print en Serial.print()B Por
e<e"plo lcd.print(val,DEC); // i"pri"e el valor val en 9ase ,.
nombreLcd.clear();
8orra todo lo ?ue 6u9iera en la pantalla 6asta ese "o"ento @ sitDa el cursor en la
posicin (.4.)3
nombreLcd.write(symbol[i]);
Se e"plea para "andar un caracter a la L2D3 Puedo "andar el caracter VKV (cu@o
cdigo AS2II es el 0#) de varias for"as
byte suma=B00101011; //la 8 es para especificar ?ue estE en 9inario
nombeLcd.write(suma); //lo puede "andar co"o varia9le
nombreLcd.write(B00101011); //lo puede "andar en cdigo 9inario
nombreLcd.write(43); //lo puede "andar en 9ase deci"al
nombreLcd.write(0x2B); //lo puede "andar en 9ase 6eIadeci"al
nombreLcd.createChar(nmero,dato);
Esta funcin per"ite i"pri"ir un s"9olo creado por nosotros "is"os4 puesto ?ue cada
caracter posee una "atri> de &I% pIeles3 Para ello de9e"os generar dic6o s"9olo a
travAs de % nD"eros 9inarios de & 9its4 correspondientes a cada una de las filas ?ue
co"ponen dic6o s"9olo3 Nuestro displa@ L2D puede al"acenar % s"9olos dise;ados
por nosotros4 @ de9e"os indicar dnde lo al"acena a travAs de dic6o nD"ero (de . a *)3
Se suele incluir dentro del void setup4 @ luego4 para i"pri"ir dic6o s"9olo en la
pantalla utili>a"os la funcin nombreLcd.write(nmero).
'ea"os un e<e"plo i"pri"ire"os una carita sonriendo
byte sonrisa[]={B00000, B00000, B01010, B00000, B10001, B01110, B00000,
B00000};
void setup(){
nombreLcd.createChar(0,sonrisa);
}
void loop(){
nombreLcd.write(0);
}
nombreLcd.scrollDisplayRight();
nombreLcd.scrollDisplayLeft();
DGG 25 de 28
Arduino
Nivel Enteraillo
Esta funcin per"ite despla>ar lo ?ue estA en la pantalla una posicin 6acia la derec6a
o a la i>?uierda4 dependiendo de ?uA funcin este"os utili>ando3
Proyecto -. El pe* nadador en su pecera ".D
2onsistirE en "ostrar en nuestra pantalla L2D un pe> ?ue de despla>a por la pantalla4 @
va 6aciendo pe?ue;as po"pitas3 El progra"a puede ser el siguiente
#include <LiquidCrystal.h>
LiquidCrystal lcd(8,9,4,5,6,7); //configurado para la shield LCD
byte pescadoIzquierda[]={B00000,B00000,B00000,B00000,B01101,B11110,B01101,
B00000};
byte pescadoDerecha[]={B00000,B00000,B00000,B00000,B10110,B01111,B10110,
B00000};
byte pescadoCentro[]={B00000,B00000,B00000,B00000,B00100,B01110,B00100,
B00000};
byte burbuja1[]={B00010,B00000,B00100,B00010,B00100,B01110,B00100,B00000};
byte burbuja2[]={B00000,B00100,B00010,B00000,B00100,B01110,B00100,B00000};
byte burbuja3[]={B00100,B00000,B00000,B00000,B00100,B01110,B00100,B00000};
byte x=0; //x e y son nmeros muy pequeos,
byte y=0; //as que los defino como byte para optimizar memoria
int tiempo=600;
void setup(){
lcd.begin(16,2);
lcd.createChar(0,burbuja1); //creo los caracteres de los peces
lcd.createChar(1,burbuja2);
lcd.createChar(2,burbuja3);
lcd.createChar(3,pescadoIzquierda);
lcd.createChar(4,pescadoDerecha);
lcd.createChar(5,pescadoCentro);
}
void loop(){
desplazarDerecha(9); //el pez nadar hacia la derecha 10 posiciones
pararCentro(); //se parar mirando al frente
pompas(); //respirar echando pompas
y=1; //bajar a la fila de abajo
desplazarIzquierda(5);//ahora nadar hacia la izquierda 6 posiciones
pararCentro(); //se parar otra vez
pompas(); //har pompas otra vez
y=0; //subir a la fila de arriba
desplazarDerecha(11); //nadar hacia la derecha 12 posiciones y se perder
delay(tiempo*10); //tras un tiempo considerable...
x=0;
y=0; //...aparecer de nuevo en la posicin 0,0
}
void desplazarDerecha(int posiciones) {
lcd.setCursor(x,y);
lcd.write(4);
delay(tiempo);
for(int i=0;i<posiciones;i++) {
lcd.scrollDisplayRight();
delay(tiempo);
x++;
DGG 26 de 28
Arduino
Nivel Enteraillo
}
lcd.clear();
}
void desplazarIzquierda(int posiciones) {
lcd.setCursor(x,y);
lcd.write(3);
delay(tiempo);
for(int i=0;i<posiciones;i++) {
lcd.scrollDisplayLeft();
delay(tiempo);
x--;
}
lcd.clear();
}
void pararCentro(){
lcd.setCursor(x,y);
lcd.write(5);
delay(tiempo);
lcd.clear();
}
void pompas(){
for(int i=0;i<3;i++) {
lcd.setCursor(x,y);
lcd.write(i);
delay(tiempo);
}
lcd.clear();
}
Proyecto /. 0otones de la S1ield ".D
Este otro progra"a per"itirE testear los 9otones ?ue incorpora la s6ield L2D
#include <LiquidCrystal.h>
LiquidCrystal lcd(8, 9, 4, 5, 6, 7); //configurado para la shield LCD
// definimos algunas variables que usaremos en este programa:
int botonApretado = 0;
int lecturaAnalogica = 0;
#define botonRIGHT 0
#define botonUP 1
#define botonDOWN 2
#define botonLEFT 3
#define botonSELECT 4
#define botonNONE 5
// veamos cmo leer los botones
int leerBotonesLCD(){
lecturaAnalogica = analogRead(0); //lee el valor de la entrada analgica A0
/* los botones estn configurados de tal forma que el valor de entrada en A0
valen, respectivamente: 0, 144, 329, 504, 741, 1023 */
if (lecturaAnalogica > 1000) return botonNONE; /* el valor ms habitual
ser el de no estar accionando ningn botn, por eso lo pongo en primer
lugar, para que el programa gane en velocidad (aunque no creo que se note)*/
DGG 27 de 28
Arduino
Nivel Enteraillo
if (lecturaAnalogica < 50) return botonRIGHT;
if (lecturaAnalogica < 195) return botonUP;
if (lecturaAnalogica < 380) return botonDOWN;
if (lecturaAnalogica < 555) return botonLEFT;
if (lecturaAnalogica < 790) return botonSELECT;
return botonNONE; // si no se cumple ninguna, que devuelva botonNONE
}
void setup(){
lcd.begin(16, 2); // iniciamos la librera
lcd.setCursor(0,0);
lcd.print("Aprieta los botones"); // imprime este mensaje
}

void loop(){
lcd.setCursor(9,1); //sita al cursor en la 10 columna, 2 fila
lcd.print(millis()/1000); // muestra los segundos transcurridos
lcd.setCursor(0,1); // cursor al principio de la 2 fila
botonApretado = leerBotonesLCD(); // hace lectura de los botones
switch (botonApretado) { /* dependiendo de qu botn pulsemos, har
una accin u otra */
case botonRIGHT: {
lcd.print("DERECHA");
break;
}
case btnLEFT: {
lcd.print("IZQUIERDA");
break;
}
case botonUP: {
lcd.print("ARRIBA");
break;
}
case botonDOWN: {
lcd.print("ABAJO");
break;
}
case botonSELECT: {
lcd.print("SELECT");
break;
}
case botonNONE: {
lcd.print("NINGUNO");
break;
}
}
}
Bibliografa: - Curso de Arduino de Francis Perea.
- Getting Started Wit Arduino !"assimo Ban#i$.
- Beginning Arduino Programming !Brian %&ans$.
- '( Arduino Projects for e %&il Genios !Simon "on)$.
DGG 28 de 28