Apuntes Arduino Nivel Inicial
Apuntes Arduino Nivel Inicial
Apuntes Arduino Nivel Inicial
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
ATmega328
5V
7 12 V
6 20 V
14 (6 proporcionan PWM)
6
40 mA
50 mA
300 mA
32 KB (0,5 KB para bootloader)
2 KB
1 KB
16 MHz
DGG
2 de 28
Arduino
Nivel Enteraillo
analogReference(EXTERNAL);
/* toma como referencia la tensin que
haya en el pin AREF. Si quiero que esa tensin sea 3,3 V, lo nico que tendr
que hacer ser conectar el pin 3,3V con el pin AREF */
analogReference(DEFAULT);
Para que surja efecto los nuevos valores de referencia de la tensin en las
entradas analgicas, debemos llamar a la funcin analogReference() antes
de utilizar la funcin analogRead().
Los pines A0A5 tambin pueden utilizarse como entradas digitales o como
salidas analgicas y digitales. No tenemos ms que incluirlas en el void
setup() como los siguientes pines despes del 13, es decir: el 14, 15, 16, 17,
18, 19 (que corresponden al A0, A1, A2, A3, A4, A5):
pinMode(16,OUTPUT); //utilizar el pin A2 como salida
Asimismo, no es estrictamente necesario configurar los pines como INPUT u
OUTPUT dentro de void setup(). Simplemente debemos interpretar al bloque
void setup() como una parte del cdigo que Arduino solamente la corre una
vez (al principio), y en la que podemos ejecutar cualquier funcin.
2. TIPOS DE VARIABLES
Los tipos de variables son:
boolean: almacena un valor con dos posibilidades: 0 o 1, o verdadero o falso.
char: almacena un caracter, como una letra o smbolo. Tambin se puede
emplear para un nmero entero entre -128 a 127 (1 byte).
byte: almacena un nmero natural entre 0 y 255 (1 byte).
int: almacena un nmero entero entre -32769 y 32767 (2 bytes).
unsigned int: almacena un nmero natural entre 0 y 65536 (2 bytes).
DGG
3 de 28
Arduino
Nivel Enteraillo
x=int(pi);
/*x pasar a valer 3, pues es el resultado de eliminar la parte
decimal. Es igualmente vlida la siguiente nomenclatura:
x=(int)pi;
*/
En el caso de que vayamos a declarar varias variables del mismo tipo, podemos
acortar nuestro cdigo separando las variables por coma:
int a=6,b=9,c=11;
3. ARRAYS
ARRAY: almacena una lista de variables, accediendo a cada una de ellas a travs de su
ndice (el primero siempre es el cero):
int datos[] = {4,7,9,12,18};
siendo
En este caso no ha sido necesario especificar el tamao del array porque hemos
incluido el valor de todas las variables, pero si no declaro los valores iniciales,
debo especificar el tamao del array:
int datos[5];
DGG
4 de 28
Arduino
Nivel Enteraillo
Existe tambin otra forma de llamar los distintos elementos del array, a travs de
un puntero. El primer elemento corresponde a *datos, y para llamar a los
siguientes no tenemos ms que sumar su posicin relativa:
*datos
*datos+1
*datos+2
*datos+n
==
==
==
==
==
datos[0]
datos[1]
datos[2]
datos[n]
char texto[16]='!';
DGG
5 de 28
Arduino
Nivel Enteraillo
Si por ejemplo quisiera hacer algo parecido con un array del tipo int, debera
poner:
for (i=0; i < sizeof(datos)/2; i++){
4. DEFINIR FUNCIONES
DGG
6 de 28
Arduino
Nivel Enteraillo
donde a y b seran variables que la funcin debera utilizar (por supuesto, habr
funciones que no necesiten de ninguna variable). Si dichas variables no estaban
declaradas con anterioridad, habr que declararlas en ese mismo momento:
void funcion (int a,int b) {}
Si la funcin que vamos a definir quiero que me devuelva un valor, debo
declararla como si de una variable se tratara, especificando qu tipo de variable
es dicho valor (int, long, float,). Para que la funcin tome un valor,
debemos utilizar la funcin return acompaada de la variable cuyo valor quiero
asignar a la funcin.
int funcion (a,b) {
//tambin puede manejar variables
int val=0;
;
val= ;
return val;
}
Si deseo en algn momento del cdigo de la funcin interrumpirla y salir de ella (de
manera anloga al break en las estructuras), y seguir el programa por la siguiente lnea
despus de la llamada de la funcin, utilizar el comando return; (sin acompaarlo de
ninguna variable o dato, con lo cual devuelve un valor vaco).
Proyecto 1. Emisor de seal de emergencia luminoso: S.O.S. en cdigo Morse
Emplearemos un simple LED para enviar nuestra seal de socorro en cdigo Morse
S.O.S. (Save Our Souls), es decir: (S) (O) (S).
Tendramos dos opciones a la hora de realizar el programa:
Hacerlo verdaderamente sencillo, con mucho copiar y pegar lneas como:
digitalWrite(ledPin,HIGH); delay(200); digitalWrite(ledPin,LOW); delay(200)
para cada punto o raya (la raya sera con un delay(500)).
DGG
7 de 28
Arduino
Nivel Enteraillo
}
Observamos que podemos definir la funcin al final del cdigo. Asimismo, debemos
tener cierto cuidado con los arrays, pues en este caso, tiempo no es ninguna variable
que haya sido definida, sino que las variables son:
tiempo[0], tiempo[1], tiempo[8].
5. FUNCIONES DE TIEMPO
delay(); millis();
micros ( );
x = micros();
255u
1000L
32767ul
De esta
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();
}
}
6. FUNCIONES MATEMTICAS
x = abs(val);
x = max(a,b);
x = abs(a);
//asigna a x el valor a2
x = pow(a,b);
//asigna a x el valor ab
x = sqrt(a);
x = sin(a);
x = cos(a);
x = tan(a);
DGG
9 de 28
Arduino
Nivel Enteraillo
7. OPERADORES BINARIOS
X = 1 & 0;
Arduino posee una serie de funciones con los que operar dos bits (bit a bit), que
permiten resolver muchos problemas comunes en programacin.
&
Si por ejemplo aplicamos este operador a dos variables tipo int, que
recordemos que eran nmero de 16 bits, los bits se multiplicaran uno a uno, sin
tener en cuenta los acarreos. Ejemplo:
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
Si por ejemplo aplicamos este operador a los dos int del ejemplo 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
DGG
10 de 28
Arduino
Nivel Enteraillo
Bitshift left: desplaza los bits que componen una variable hacia la
izquierda, rellenando los huecos que se van generando a la derecha con
ceros, y perdindose todos aquellos bits que han rebosado por la
izquierda.
>>
1<<1 == 2
1<<5 == 32
1<<2 == 4
1<<6 == 64
1<<3 == 8
1<<7 == 128 ...
Bitshift right: desplaza los bits que componen una variable hacia la
derecha, rellenando los huecos que se van generando a la derecha con
ceros o unos dependiendo de si el signo del valor decimal de la variable es
positivo o negativo, respectivamente, y perdindose todos aquellos bits
que han rebosado por la derecha.
8. ESTRUCTURAS
while(){}; do{}while();
Hasta ahora ya hemos visto tres tipos de estructura para los programas de Arduino:
for
if
DGG
11 de 28
Arduino
Nivel Enteraillo
switch
switch(val){
case 3:; break; case 12: ; break; default:; }
Veamos ahora otras estructuras: while y dowhile.
while
while(condicin){}
do while
do{}while(condicin); /*bsicamente es similar a la estructura while, con la
diferencia de que al menos una vez hace lo que est
entre llaves, y luego lo seguir haciendo mientras se
cumpla la condicin especificada en while */
Existen dos rdenes que pueden incluirse dentro de cualquier bucle (instrucciones
comprendidas entre las llaves) de las estructuras anteriores: break y continue.
break;
DGG
12 de 28
Arduino
Nivel Enteraillo
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 */
}
9. DISPLAY 7-SEGMENTOS
Un dispositivo de salida muy empleado es el display 7-segmentos, empleado
normalmente para mostrar en l un nmero del 0 a 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);
}
}
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
La forma de poder representar una imagen formada por estos 64 puntos es hacer
barridos por las distintas filas o columnas, de manera anloga a como se trabajaba con
el display de 4 dgitos. Para evitar variaciones en la intensidad de brillo de los LEDs, si
el barrido lo hacemos por filas deberemos colocar las resistencias limitadoras de
corriente (120 470 ) en los pines reservados a las columnas (como aparece en la
figura), pero si el barrido lo hacemos por columnas deber ser en los pines reservados
para las filas donde intercalemos las resistencias.
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};
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
case
case
case
case
case
case
case
case
case
case
case
' ':
'"':
'$':
'&':
')':
'+':
'-':
':':
'<':
'>':
'?':
'_':
returnValue
returnValue
returnValue
returnValue
returnValue
returnValue
returnValue
returnValue
returnValue
returnValue
returnValue
returnValue
}
return returnValue;
=
=
=
=
=
=
=
=
=
=
=
=
espacio; break;
case '!':
comillas; break; case '#':
dollar; break;
case '%':
ampersand; break; case '(':
parentesisCerrado; break;
mas; break;
case ',':
menos; break;
case '/':
dosPuntos; break; case ';':
menor; break;
case '=':
mayor; break;
case '':
interroganteCerrado; break;
guionBajo; break; case '.':
#include <LiquidCrystal.h>
Uno de los dispositivos ms espectaculares para nuestra Arduino es sin duda la pantalla
LCD. En el mercado podemos encontrar gran variedad, pero el modelo HD44780 es el
ms extendido, incluso se encuentran montadas sobre un shield para Arduino UNO:
Pin LCD
A0
DGG
FUNCIN
Definida por el programador
11
DB4
12
DB5
13
DB6
14
DB7
RS (register select)
E (enable)
Habilita la conexin
10
15
Backlight
Controla la luminosidad
Potencimetro
Controla el contraste
Bus de 4 bits
21 de 28
Arduino
Nivel Enteraillo
DGG
22 de 28
Arduino
Nivel Enteraillo
Pin LCD
DGG
VSS
0V
VDD
5V
V0
RS
Register select
R/W
enable
DB0
DB1
DB2
10
DB3
11
DB4
12
DB5
13
DB6
14
DB7
15
LED+
16
LED-
23 de 28
Arduino
Nivel Enteraillo
DGG
24 de 28
Arduino
Nivel Enteraillo
nombreLcd.scrollDisplayRight();
nombreLcd.scrollDisplayLeft();
DGG
25 de 28
Arduino
Nivel Enteraillo
Esta funcin permite desplazar lo que est en la pantalla una posicin hacia la derecha
o a la izquierda, dependiendo de qu funcin estemos utilizando.
Proyecto 6. El pez nadador en su pecera LCD
Consistir en mostrar en nuestra pantalla LCD un pez que de desplaza por la pantalla, y
va haciendo pequeas pompitas. El programa puede ser el siguiente:
#include <LiquidCrystal.h>
LiquidCrystal lcd(8,9,4,5,6,7);
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();
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:
DGG
28 de 28