1

Puede declarar una matriz sin inicializarla como en myInts. En

LABORATORIO 5
PRACTICA DE ARRAYS EN ARDUINO
BRYAN CAMILO RODRGUEZ

20131007120
CARLOS ANDRES BELTRAN

20122007014
BAEZ SILVA

EDWIN
20071007005
GONZALO JIMENES
UNIVERSIDAD DISTRITAL

BOGOT
I. INTRODUCCIN
Dentro de la programacin de arduino existen varias manera
de realiza las operaciones dentro del sistema, una de esas
maneras es manejar arreglos. En los arreglos o que se busca es
generar matrices de datos, con el cual arduino pueda
implementar funciones o requerimientos usando un conjunto
de datos, ya sea para tabulaciones o para muestreo. As que es
muy importante tener conocimientos acerca de este tipo de
variables y de cmo se pueden aplicar en el sistema.
II.

OBJETIVOS

aprender el uso de arrays en arduino, conociendo su

metodologa y funcionamiento
generar un cdigo que permita escribir una palabra en
varios displays de 7 segmentos, y a su vez estas letras
que conforman la palabra se logren desplazar.
Usando arreglos
usar las herramientas de interrupciones para generar
un sistema que al generar un pulso hacia el arduino se
reinicie el sistema.
III.

MARCO TERICO

Arrays
Una matriz es un conjunto de variables que se accede con un
nmero de ndice. Arreglos en el lenguaje de programacin C,
en el que se basa Arduino, puede ser complicado, pero
utilizando matrices simples es relativamente sencillo.
Creacin (Declarando) una matriz
Todos los siguientes mtodos son formas vlidas para crear
(declarar) una matriz.
int myInts [6];
int myPins [] = {2, 4, 8, 3, 6};
int mySensVals [6] = {2, 4, -8, 3, 2};
mensaje char [6] = "hello ";

2015
myPins declaramos un arreglo sin elegir explcitamente un
tamao. El compilador cuenta los elementos y crea una matriz
de tamao adecuado.
Por ltimo, puede tanto inicializar y tamao de la matriz,
como en mySensVals. Tenga en cuenta que cuando se declara
una matriz de tipo char, se requiere un elemento ms de su
inicializacin, para mantener el carcter nulo necesario.
Acceso a una matriz
Las matrices se cero indexados, es decir, refirindose a la
inicializacin de la matriz anterior, el primer elemento de la
matriz est en el ndice 0, por lo tanto, mySensVals [0] == 2,
mySensVals [1] == 4, y as sucesivamente.
Tambin significa que, en una matriz con diez elementos, el
ndice de nueve es el ltimo elemento. Por lo tanto:
int myArray [10] = {9,3,2,4,3,2,7,8,9,11};
// myArray [9] contiene 11
// myArray [10] no es vlido y contiene informacin
aleatoria (otra direccin de memoria)
Por esta razn, usted debe tener cuidado en el acceso a las
matrices. Acceso a ms all del final de una matriz (utilizando
un nmero de ndice mayor que el tamao de su arsenal
declarado - 1) es la lectura de la memoria que se utiliza para
otros fines. La lectura de estos lugares probablemente no va a
hacer mucho, excepto datos no vlidos rendimiento.
Escribiendo a posiciones de memoria al azar es
definitivamente una mala idea y, a menudo puede conducir a
resultados infelices como accidentes o mal funcionamiento del
programa. Esto tambin puede ser un error difcil de rastrear.
A diferencia de BASIC o Java, el compilador de C no hace la
comprobacin para ver si el acceso matriz est dentro de los
lmites legales del tamao de la matriz que ha declarado.
Para asignar un valor a una matriz:

mySensVals [0] = 10;

Para recuperar un valor de una matriz:

x = mySensVals [4];
Arrays y para los bucles
Las matrices son manipulados a menudo dentro de los bucles,
donde el contador de bucle se utiliza como ndice para cada
elemento de la matriz. Por ejemplo, para imprimir los
elementos de una matriz a travs del puerto serie, que podra
hacer algo como esto:
int i;
for (i = 0; i <5; i = i + 1)
{Serial.println (myPins
[i]);}
}
IV.

ANLISIS DE RESULTADOS

Como se mencion en los objetivos anteriores, el fin de esta

prctica es generar un cdigo para mostrar el conjunto de
nombres de todos los miembros del laboratorio en un conjunto
de displays de 7 segmentos, y a su vez este programa
permitiera el desplazamiento de las letras para visualizar un
movimiento de letras en el sistema. Para lo cual lo ms
conveniente es usar arreglos con el fin de que el cdigo en
arduino sea lo ms sencillo posible.
En la primera parte se define un arreglo que contenga las
variables de salida hacia los pines de los displays, luego se
genera un algoritmo que describa la ubicacin de los leds en
los displays para que me indiquen que letra va a aparecer, y
por ltimo se genera un sistema que me permita activar estos
leds y cambiar las letras de posicin, como se presenta en el
siguiente cdigo.
const int pinessalida[]={2,3,4,5,6,7,8,9,10,11,12};
void setup() {
// put your setup code here, to run once:
for (byte i = 0; i < 12; i++) {
pinMode(pinessalida[i], OUTPUT);
}
pinMode(13,OUTPUT);
attachInterrupt(3, stateChange, CHANGE);
}
const byte alfabeto[27][7] = {
{ 0, 0, 0, 0, 0, 0, 0 }, // Nada, espacio
{ 1, 1, 1, 0, 1, 1, 1 }, // A 1
{ 1, 1, 1, 1, 1, 1, 1 }, // B 2
{ 0, 0, 0, 1, 1, 0, 1 }, // c 3
{ 0, 1, 1, 1, 1, 0, 1 }, // D 4
{ 1, 0, 0, 1, 1, 1, 1 }, // E 5
{ 1, 0, 0, 0, 1, 1, 1 }, // F 6
{ 1, 0, 1, 1, 1, 1, 1 }, // G 7
{ 0, 0, 1, 0, 1, 1, 1 }, // h 8
{ 0, 1, 1, 0, 0, 0, 0 }, // I 9
{ 0, 1, 1, 1, 1, 0, 0 }, // J 10
{ 1, 0, 0, 1, 1, 1, 0 }, // C 11
{ 0, 0, 0, 1, 1, 1, 0 }, // L 12

{ 1, 1, 1, 0, 1, 1, 0 }, // N 13
{ 1, 0, 1, 0, 1, 0, 1 }, // 14
{ 1, 1, 1, 1, 1, 1, 0 }, // 0 15
{ 1, 1, 0, 0, 1, 1, 1 }, // P 16
{ 1, 1, 1, 0, 0, 1, 1 }, // q 17
{ 0, 0, 1, 0, 0, 0, 1 }, // r 18
{ 1, 0, 1, 1, 0, 1, 1 }, // S 19
{ 0, 0, 0, 1, 1, 1, 1 }, // t 20
{ 0, 1, 1, 1, 1, 1, 0 }, // U 21
{ 0, 0, 1, 1, 1, 0, 0 }, // v 22
{ 0, 0, 1, 1, 1, 0, 0 }, // v 23
{ 0, 1, 1, 0, 1, 1, 1 }, // X 24
{ 0, 1, 1, 1, 0, 1, 1 }, // y 25
{ 1, 1, 0, 1, 1, 0, 1 }, // Z 26
};
int m=0;
int numLetra[4]={0,0,0,0};
byte escritura[7][4];
void loop() {
// put your main code here, to run repeatedly:
int
escriba[]={0,0,0,15,12,9,13,1,3,0,0,13,9,21,4,5,0,0,19,15,12,1
8,1,3,0,0,0,0};
for( int f=0;f<4;f++){
numLetra[f]=escriba[25-f-m]; //el perimer dato debe
ser tamano de escriba -1 // numero de letras +4
}
m++;
if(m >=25){ //m debe ser menor que el tamano de escriba
-2 // numero de letras +5
m=0;
}
actualize();
escriba();
}
void actualize(){
for(int i=0;i<4;i++){
for(int j=0;j<7;j++){
escritura[j][i]= alfabeto[numLetra[i]] [j];
}
}
}
void escriba(){
for(int i=0;i<20;i++){
for(int j=0;j<4;j++){
for(int k=0; k<7;k++){
if (escritura[k][j] == 1) {
digitalWrite(pinessalida[k], HIGH);
}
else {
digitalWrite(pinessalida[k], LOW);
}
}

digitalWrite(pinessalida[(j + 7)], LOW); // Prende el

display que le toca ANODO-CATODO
delay(5);
digitalWrite(pinessalida[j + 7], HIGH); // Lo quita
}
}
}

optimo numero de displays fue de 4 lo que permiti que el

programa se desarrollara de la manera ms sencilla posible,
otra observacin que se puede agregar, es que no todas las
letras del alfabeto se `pueden mostrar en el display de 7
segmentos para lo cual limita en cierta manera las
posibilidades del sistema para lo cual se debe tener en cuenta a
la hora de escribir las palabras, para que no exista este
inconveniente.

void stateChange(){
m=0;
numLetra[0]=0;
numLetra[1]=0;
numLetra[2]=0;
numLetra[3]=0;
digitalWrite(13, HIGH);
delay(500);
digitalWrite(13, LOW);
}
De acuerdo a este sistema se guardan las letras del alfabeto, en
un vector, para luego en el vector que se quiera mostrar se
hace se extraigan nicamente estas posiciones del vector del
alfabeto, para luego recorrer
un vector con las
configuraciones de los leds de acuerdo a la letra escogida, y
mostrarlos en el sistema. Al generar el pulso lo que se haca
era que si se detectaba el cambio del sistema, el programa
reiniciaba la operacin haciendo que la ltima posicin del
recorrido fuese 1 nuevamente y as iniciar de nuevo el sistema.
Durante esta prctica observamos que el sistema tiene un
lmite de uso de displays, ya que adems de las 7 salidas que
se necesitan, se deben tener las salidas adicionales que
permitan la intercalacin de los displays, para lo cual el mas

V. CONCLUSIONES
Despus de realizar este laboratorio concluimos que:

el uso de arreglos en el sistema arduino permite reducir

las variables en el cdigo, sino que generar un solo grupo
de elementos en una variable y que el programa solo
tenga que hacer un barrido en el sistema para extraer lo
necesario.
Se puede observar en la ejecucin del sistema que si se
realizan rpido los cambios, se observa como si la palabra
estuviese desplazando, pero al realizarse ms lento y
progresivo, estos cambios se hacen mucho ms lento y se
puede observar lo que hace exactamente el sistema.