¿Qué son las matrices?  Empecemos con una analogía… 

En los viejos tiempos, antes de que la información médica se volviera digital, había registros médicos en papel. Estos eran paquetes de información sobre cuándo naciste, cualquier condición que hayas tenido y tal vez una foto de la tenia que te sacaron del vientre en la escuela secundaria. El propósito del registro era organizar la información sobre su historial médico de una manera que permitiera a un profesional de la salud encontrar y revisar fácilmente su caso. 

Los programas informáticos pueden organizar la información de manera similar. Estos registros se denominan estructuras de datos: son formas organizadas de almacenar datos. Una estructura de datos inmensamente útil es la matriz. Las matrices son geniales porque se crean e indexan fácilmente. 

La indexación es la forma en que se encuentra la información en la estructura de datos. Con el ejemplo de la historia clínica, es posible que todas sus vacunas estén enumeradas en la página 5. Independientemente de la historia clínica del paciente que revise, usted sabe que la página 5 proporcionará sus datos de vacunación. 

Una matriz tiene varios elementos, lo que equivaldría a las páginas de una historia clínica. La primera página comienza en cero. 

Si te parece extraño empezar la cuenta desde cero, no te preocupes, no estás solo. Es extraño al principio, pero muy útil como descubrirás. A esto se le llama cero indexado. Eso significa que si tiene 5 elementos en su matriz, el quinto elemento se indexaría con un 4. 

 

 

 Las matrices pueden contener cualquier cosa que desee, siempre que el contenido sea del mismo tipo de datos. Cuando se declara una matriz, se dice lo que contendrá la matriz. Por ejemplo: 

int myArray[]; //Esta matriz contendrá números enteros 

dogs myArray[]; // Esta matriz contendrá dogs 

 

Para inicializar una matriz (poner cosas en ella), todo lo que tienes que hacer es lo siguiente: 

myArray[] = {spot, pluto, clifford, ruff}; 

Puede declarar e inicializar al mismo tiempo: 

dogs myArray[] = {spot, pluto, clifford, ruff}; 

Si lo desea, puede especificar el número de elementos de la matriz cuando la declare:

dogs myArray[4] = {spot, pluto, clifford, ruff}; 

Si pones más elementos en la declaración de los que usas para inicializar, se agregan espacios vacíos al final de la matriz y puedes agregar cosas más adelante: 

dogs myArray[42] = {spot, pluto, clifford, ruff}; 

En esta declaración, la matriz es lo suficientemente grande como para albergar 42 dogs, pero solo pones 4 para empezar, por lo que tienes 38 dogs más que podrías agregar más adelante. 

 

Entonces, ¿cómo hago referencia a ese 4º dog? ¿Qué pasaría si alguien le preguntara: “Señor, ¿cómo se llama el cuarto dog de su grupo?”  

Su respuesta sería 

myArray [3]; // Esto se refiere al 4º elemento de la matriz 

 Recuerde que las matrices están indexadas en CERO. En este ejemplo: 

dogs myArray[4] = {spot, pluto, clifford, ruff}; 

myArray [0] equals spot 

myArray[1] equals pluto 

myArray[2] equals clifford 

myArray[3] equals ruff 

Bien, esa es la introducción a las matrices, pasemos al código y al circuito para mojarnos los pies. 

NOTA: las matrices y los bucles for son como hermanas que siempre pasan el rato – para comprender mejor esta sección, asegúrate de que entiendes los bucles for de la lección anterior. 

Necesitarás: 

 

 

 Código 

/* 

Matrices 

Muestra el uso de una matriz para contener pines de números  

para iterar sobre los pines en una secuencia. 

Enciende varios LED en secuencia y luego al revés. 

A diferencia del tutorial For Loop, donde los pines tienen que estar 

contiguos, aquí los pines pueden estar en cualquier orden aleatorio. 

El circuito: 

* LED desde los pines 2 a 7 a tierra 

Creado en 2006 

por David A. Mellis 

modificado 30 Ago 2011 

por Tom Igoe 

Este código de ejemplo es de dominio público. 

http://www.arduino.cc/en/Tutorial/Array 

*/ 

int timer = 100; // Cuanto mayor sea el número, más lento será el tiempo. 

int ledPins[] = { 

2, 7, 4, 6, 5, 3 }; // una matriz de números de pin a los que se conectan los LED 

int pinCount = 6; //el número de pines (es decir, la longitud de la matriz) 

void setup() { 

//los elementos de la matriz se numeran de 0 a (pinCount - 1). 

//Utilice un bucle for para inicializar cada pin como salida: 

for (int thisPin = 0; thisPin < pinCount; thisPin++) { 

pinMode(ledPins[thisPin], OUTPUT); 

} 

} 

void loop() { 

//Bucle desde el pin más bajo hasta el más alto: 

for (int thisPin = 0; thisPin < pinCount; thisPin++) { 

//Enciende el PIN: 

digitalWrite(ledPins[thisPin], HIGH); 

delay(timer); 

// Apague el pasador: 

digitalWrite(ledPins[thisPin], LOW); 

} 

// Bucle desde el pin más alto hasta el más bajo: 

for (int thisPin = pinCount - 1; thisPin >= 0; thisPin--) { 

// Enciende el PIN: 

digitalWrite(ledPins[thisPin], HIGH); 

delay(timer); 

// Apague el pasador: 

digitalWrite(ledPins[thisPin], LOW);                                     

} 

} 

 

 

 Instrucciones paso a paso 

  • Conecte un lado de una resistencia en el pin 2, conecte el otro lado en una fila en la placa de pruebas. 
  • Conecte la pata larga del LED a la fila de la placa de pruebas donde conectó la resistencia. 
  • Conecte la pata corta del LED a una de las columnas de regletas de enchufes de su placa de pruebas. 
  • Ahora conecte una resistencia al pin 3 y coloque la otra pata en una fila en la placa de pruebas (una diferente a su primer LED). 
  • Conecte un LED de la misma manera: asegúrese de que la pata corta vaya en la MISMA columna de regleta que el LED anterior. 
  • Agregue LED y resistencias de esta manera a través del pin 7. 
  • Con un cable de puente, conecte la regleta de enchufes común a un pin GND en el Arduino. 
  • Conecta el Arduino a tu ordenador. 
  • Abre el IDE de Arduino. 
  • Abra el boceto de esta sección. 
  • Haga clic en el botón Verificar (arriba a la izquierda). El botón se volverá naranja y luego azul una vez que haya terminado. 
  • Haga clic en el botón Cargar. El botón se volverá naranja y luego azul cuando termine. 
  • Observe con asombro cómo sus LED se encienden y apagan en una secuencia mixta. 

 

Comentando el código 

Esta primera pieza de código ejecutable es la declaración e inicialización de variables: 

int timer = 100; // Cuanto mayor sea el número, más lento será el tiempo. 

int ledPins[] = { 2, 7, 4, 6, 5, 3 }; // una matriz de números de pin al que se conectan los LED 

int pinCount = 6; // el número de pines (i.e. la longitud de la matriz) 

A estas alturas ya debería estar muy familiarizado con la forma de declarar e inicializar variables enteras, pero echemos un vistazo a la matriz que se está creando: 

int ledPins[] = { 2, 7, 4, 6, 5, 3 }; // una matriz de números de pin a los que se conectan los LED 

Esta es una matriz que contendrá números enteros como nos dice el int anterior. Tenga en cuenta que los elementos de esta matriz representan pines donde se conectan los LED. Hemos dejado los corchetes que siguen al nombre de la matriz vacíos, lo que significa que el compilador (el programa integrado con el IDE de Arduino que convierte nuestro código legible por humanos en código legible por máquina), contará los elementos de la matriz y establecerá su tamaño, en este caso como una matriz de 6 elementos (cuéntalos,  ¡Te reto!). El nombre de la matriz puede ser el que quieras; Los nombres descriptivos siempre son buenos. 

El siguiente bloque de código es la función setup(). Aquí asignamos modos de pin usando una combinación de nuestra matriz y un bucle for: 

void setup() { 

for (int thisPin = 0; thisPin < pinCount; thisPin++) { 

pinMode(ledPins[thisPin], OUTPUT); 

} 

} 

Ok, ¿qué está pasando aquí? Tenemos un bucle for, la condición es: 

thisPin < pinCount 

Podemos ver que thisPin se inicializa en 0 y pinCount es igual a 6 (recordemos que pinCount fue una de las variables que declaramos en la parte superior). Cada vez que pasa por el bucle for, thisPin se incrementa agregando 1. 

El código ejecutado entre llaves hace uso de nuestra matriz y usa thisPin como contador de índices. La función es nuestro viejo amigo pinMode() que toma dos argumentos: 1) Qué pin configurar el modo y 2) Qué modo configuramos: 

pinMode(ledPins[thisPin], OUTPUT); 

Para determinar el resultado de esta línea de código, recuerde que el valor de thisPin se estableció en cero. Entonces, ¿a qué se refiere ledPins[0]? 

Echemos un vistazo a lo anterior  

int ledPins[] = { 2, 7, 4, 6, 5, 3 };  

0, 1, 2, 3, 4, 5 index of each element 

 

Dado que cero indexa el primer elemento de la matriz, parece que el pin 2 será el primer pin en establecer su modo en OUTPUT. La próxima vez que pase por el bucle for, la variable thisPin será igual a 1 (ya que se incrementa cada vez a través del bucle for). ¿A qué se referirá ledPins[1]? Pin 7, ya que el pin 7 es el segundo elemento de la matriz. 

Todos los pines tendrán su modo configurado en OUTPUTs de esta manera. Una vez que thisPin sea mayor que 5, el bucle for se detendrá. Así que ahora has probado el uso de un bucle for y una matriz juntos. La variable de contador del bucle for actúa como el número de indexación de la matriz. A medida que se incrementa la variable de contador, hacemos referencia a la matriz elemento por elemento. Tendremos otra oportunidad de ver esta unión en el loop(). 

 

 

 

 

 

El primer bloque de código en loop() es: 

for (int thisPin = 0; thisPin < pinCount; thisPin++) { 

// Enciende el PIN: 

digitalWrite(ledPins[thisPin], HIGH); 

delay(timer); 

// Apague el PIN: 

digitalWrite(ledPins[thisPin], LOW); 

} 

Imagínese eso: ¡otro bucle for y otra matriz! Vamos a ver qué hace este… 

Tenemos exactamente las mismas declaraciones en el bucle for que antes: establecemos thisPin igual a 0, la condición es thisPin < pinCount, e incrementamos thisPin en 1 cada vez que pasamos por el bucle for: 

for (int thisPin = 0; thisPin < pinCount; thisPin++) 

El código dentro de los corchetes del bucle for encenderá y apagará los LED. Para ello, utilizamos la función digitalWrite(). Recordemos que digitalWrite() toma dos argumentos: 1) quiere saber qué pin y 2) si desea que se aplique un voltaje ALTO o BAJO. Le decimos a la función qué pin usando una matriz: 

digitalWrite(ledPins[thisPin], HIGH); 

La primera vez que pase por el bucle for, la matriz se indexará como: 

ledPins[0] 

Este es el primer elemento de la matriz, que es el número 2. Ahora el LED en el pin 2 se encenderá porque estamos aplicando 5 voltios a ese pin. Si avanzamos rápidamente a la próxima vez que lleguemos a esta función, thisPin se habrá incrementado y el valor de thisPin será 1 de la siguiente manera: 

ledPins[1] 

Esto hará digitalWrite() en el segundo elemento de la matriz, que es 7. Por lo tanto, nuestro LED en el pin 7 se encenderá. Pero me estoy adelantando. Primero tenemos que disfrutar del brillo, para ello retrasamos el programa: 

delay(timer); //Nothing new here 

Ahora queremos apagar el LED. La función es exactamente la misma, simplemente escribimos BAJO voltaje en el pin: 

digitalWrite(ledPins[thisPin], LOW); 

Esto continúa a través del bucle for encendiendo y apagando cada LED al que se hace referencia en la matriz. Tenga en cuenta que, dado que los números de pines de la matriz no son secuenciales, los LED “saltan” a medida que se encienden. 

Ahora, esto estaría muy bien, pero mantengámoslo interesante y comencemos con el último elemento de la matriz y pasemos al primer elemento, invirtiendo el orden en que los LED se encienden y apagan. 

for (int thisPin = pinCount – 1; thisPin >= 0; thisPin--) { 

Enciende el PIN: 

digitalWrite(ledPins[thisPin], HIGH); 

delay(timer); 

// Apague el PIN: 

digitalWrite(ledPins[thisPin], LOW); 

} 

Echemos un vistazo de cerca a las declaraciones que configuran el siguiente bucle for: 

for (int thisPin = pinCount – 1; thisPin >= 0; thisPin--) 

thisPin ahora se inicializa en pinCount-1 (pinCount menos uno). Tenga en cuenta que pinCount se inicializó en el valor 6 al principio de nuestro programa. pinCount es el número de pines donde se conectan los LED, y también es el tamaño de la matriz. Pero si queremos acceder al último elemento de la matriz, debemos comenzar en pinCount menos uno (debido a nuestro índice 0). Esto es peculiar al principio, pero después de escribir un par de bucles for con matrices, será muy fácil. 

Cada vez que pasamos por el bucle for, disminuimos la variable thisPin, trabajando así a través de la matriz de derecha a izquierda. Echemos un vistazo a los valores reales a medida que trabajamos en el bucle for: 

Como recordatorio, esto es lo que almacenamos en nuestra matriz: 

ledPins[] = { 2, 7, 4, 6, 5, 3 }; 

0, 1, 2, 3, 4, 5 index of each element 

 //Primera vez a través de 

ledPins [5] <=> Este es el sexto elemento de la matriz, que es el valor 3 

//La próxima vez a través del bucle for, recuerde que thisPin está disminuido … 

LedPins [4] <==> El 5º elemento de la matriz es 5 

La próxima vez a través del bucle for 

LedPins [3] <==> El 4º elemento de la matriz es 6 

//La próxima vez a través del bucle for 

LedPins [2] <==> El 3er elemento de la matriz es 4 

Creo que te haces una idea. Cuando thisPin se reduce a menos de 0, el bucle for se detiene. De esta manera, todos los pines se encienden y apagan en orden inverso. Una vez hecho esto, comenzamos en la parte superior del bucle () y volvemos a hacerlo. 

Una nota final sobre la indexación de matrices: digamos que pones 3 elementos en una matriz… 

dogs poundArray[3] = {Spike, Scooby, Lassie}; 

 … Pero luego intentas obtener el elemento 15 en esa matriz. Tú y yo sabemos que no hay un elemento 15. Solo ponemos tres elementos en la matriz, si intentamos indexar el elemento 15: 

poundArray[14] 

Al programa no le gusta esto… En absoluto. Y aunque puede compilarse correctamente, no funcionará correctamente. Si su programa comienza a actuar de manera extraña, o no actúa en absoluto, verifique su índice y asegúrese de que no indexó fuera del tamaño de las matrices.