Arreglos unidimensionales

En esta sección utilizarás arreglos unidimensionales para almacenar y manipular datos del mismo tipo en la resolución de problemas.

Existen problemas como la predicción del clima o los sismógrafos, los cuales requieren para su solución manipular grandes cantidades de datos. Para poder solucionar estos problemas con la computadora es conveniente almacenar los datos en estructuras que faciliten su proceso. En lo particular, en esta práctica conocerás la estructura de datos llamada arreglo.

¿Qué es un arreglo?

Un arreglo es un conjunto finito y ordenado de elementos homogéneos. (Joyanes, 2008)

Un arreglo está formado por un conjunto de elementos del mismo tipo de datos, identificados bajo un mismo nombre, donde cada elemento es identificado por un índice. Cabe aclarar que algunos lenguajes de programación son capaces de manejar arreglos de elementos con tipos de datos distintos, sin embargo, para el propósito de esta práctica, asumiremos que el arreglo tiene elementos homogéneos.

Los arreglos pueden tener una o varias dimensiones. Cuando tienen una sola dimensión, se denominan unidimensionales (en matemáticas son conocidos como vectores), cuando tienen dos dimensiones se llaman bidimensionales (en matemáticas son conocidos como matrices) y son multidimensionales cuando tienen tres o más dimensiones.

Revisa la siguiente representación gráfica de un arreglo  para que entiendas mejor el concepto de arreglo y reconozcas sus  componentes (Figura 1):

Como se observa en la Figura 1, un arreglo se compone de lo siguiente:

• Nombre del arreglo:  Es el nombre o identificador que se le asigna al arreglo, es similar al nombre de una variable.
• Elementos: Cada uno de las datos almacenados que componen el arreglo.
• Celda: Cada uno de los espacios de almacenamiento.
• índice: El número de cada celda que forma el arreglo. Comienza con el número 0.

Declaración de arreglos

En Arduino, la declaración de un arreglo se hace de la siguiente manera:

Sintaxis

tipoDato nombreArreglo [tamaño];

Ejemplos:

Declaración de un arreglo llamado lecturas de 8 celdas que almacena números enteros.

int lecturas[8]; 

Declaración de un arreglo llamado valSensor de 5 celdas que almacena números reales.

float valSensor[5];

Declaración de un arreglo llamado digitos de 10 celdas que almacena valores de tipo byte.

byte digitos[10];

Declaración e inicialización de un arreglo

También es posible darle un valor inicial a los valores del arreglo  en la misma instrucción en la cual lo creas, es decir, puedes declarar e inicializar un arreglo en una misma instrucción.

Sintaxis

tipoDato nombreArreglo [tamaño] = { valor1, valor2, valor3, . . .valorN};

Ejemplos:

Declaración e inicialización de un arreglo llamado lecturas que almacena los valores 12, 1, 24, 8, 95, 253, 7 y 46.

int lecturas[8] = {12, 1, 24, 8, 95, 253, 7, 46}; 

Declaración de un arreglo  valSensor de  que almacena  valores numéricos reales sin indicar el tamaño, en este caso, el compilador de  Arduino cuenta los elementos y crea el arreglo del tamaño correspondiente.

float valSensor[ ] = {7.5, 4.8, 3.7, 9.7, 5.9};

Acceso a los valores de un arreglo

Durante la ejecución de un  programa se puede asignar o modificar el  valor de algún elemento de un arreglo (asignación)  o la recuperación (lectura) de algún valor. El acceso a los valores de un arreglo se hace mediante su índice. La sintaxis de la instrucción es: 

Sintaxis

nombreArreglo[índice]

Donde:

nombreArreglo: Identificador con el que se desea nombrar el arreglo.

índice:  El número de la celda que guarda el valor

A continuación, te presentamos algunos ejemplos de instrucciones de asignación de valores a un elemento del arreglo valSensor :

float valSensor[5]; // Se declara el  arreglo valSensor
valSensor[0] = 7.5; // Se asigna el valor 7.5 en la celda 0
valSensor[1] = 4.8; // Se asigna el valor 4.8 en la celda 1
valSensor[4] = 5.9; // Se asigna el valor 5.9 en la celda 4

Los siguientes ejemplos son de recuperación de valores almacenados en el arreglo lecturas:

int lecturas[8] = {12, 1, 24, 8, 95, 253, 7, 46};  // Se declara y asignan valores al arreglo
int valor1 = lecturas[2];  // Se recupera el elemento de la celda 2 (valor 24) y se almacena en la variable valor1
int valor2 = lecturas[4];  // Se recupera el elemento de la celda 4 (valor 95) y se almacena en la variable valor2

Acceso a elementos del arreglo con ciclos

Cuando se requiere acceder a todos los elementos de un arreglo (barrido o recorrido) se puede realizar utilizando la estructura de iteracción for.  Recordamos que la estructura de control  for  se  caracteriza por realizar un número específico de repeticiones, que en el caso de los arreglos corresponde a su longitud (número de elementos).

Ejemplo:

 Se declara un arreglo con el nombre pinPWM  que almacena el número de los pines PWM de la placa Arduino.

int pinPWM [6]={3,5,6,9,10,11};

Se realiza el barrido del arreglo pinPWM para  configurar cada pin PWM como salida,  utilizando la instrucción pinMode dentro de un ciclo for:

int i; // Declaración de la variable i con tipo de dato entero
for (i=0; i<=6; i++) { // Ciclo for i inicia con valor 0, cada ciclo se incrementa en 1 y termina cuando i es mayor que 6 
    pinMode(pinPWM[i], OUTPUT); // Configura el pin PWM como salida
}

Ahora que hemos revisado la declaración, inicialización y manipulación de arreglos, vamos a realizar el siguiente ejemplo:

Se desea programar un circuito electrónico que toque una melodía con un buzzer utilizando un arreglo para el almacenamiento de las frecuencias de las notas y otro arreglo para el  tiempo de cada nota (ver Figura 2). 

En este circuito, para tocar la melodía, se declaran las notas musicales como constantes asignando el valor numérico que corresponde a la frecuencia de la señal que vamos a generar y que es la que variará el tono del sonido.

const int Do= 261;
const int Re =294;
const int Mi =330;
const int Fa =349;
const int Sol =392;
const int La =440;
const int Si =494;
const int Doa =523;
const int Rea =587;
const int Sib =987;
const int Silen=0;

Se declara un arreglo con el nombre notas, de tipo entero, con 16 elementos y se inicializa con los las notas musicales de la melodía a tocar.

int notas[16]={Do, La, Sol, Fa, Mi, Rea, La, Sol, Fa, Mi, Rea, La, Sol, La, Sol, Mi};

Se declaran un arreglo de nombre duración, de tipo entero, con 16 elementos y se inicializa con el tiempo que se debe de tocar cada nota, los número van de de1 a 8 tiempos.

int duración[16] = {4,4,1,1,1,4,2,1,1,1,4,2,1,1,1,8}

El buzzer se encuentra conectado al pin PWM 3 y configurado como salida, para ello se declarar una variable de tipo entero pinBuzzer y se inicializa con el valor 3

int pinBuzzer = 3;

En la sección setup, se configura pinBuzzer como salida OUTPUT;

pinMode(pinBuzzer, OUTPUT);

Una vez realizadas las declaraciones se procede realizar el barrido del arreglo notas [ ] y duración [ ] con el uso de una estructura for. Dentro de la estructura for se utiliza la instrucción tone para que el  buzzer produzca el sonido  con el valor de la frecuencia almacenada en el arreglo. 

tone(pinBuzzer, notas[i]);

Para controlar el tiempo que la nota es tocada, se utiliza el arreglo duración. El tiempo de cada nota se multiplica por 200 milisegundos para dar el total de tiempo que debe sonar cada nota.

delay(duracion[i]*200);

El for completo para barrer el arreglo notas[ ] y duración[ ] con las instrucciones tone y delay es el siguiente:

for (i = 0; i<=15; i++)
{
    tone(pinBuzzer, notas[i]);
    delay(duracion[i]*200);
}

Al final se indica que deje de tocar el buzzer con la instrucción notone.

noTone(pinBuzzer);

 

Manos a la obra

Materiales

Los materiales que necesitas para realizar la práctica son:

Lo  materiales ya los hemos utilizado en prácticas anteriores de este manual, si no te acuerdas o deseas repasar las características técnicas y funcionamiento de alguno de los componentes electrónicos, puedes dar clic sobre su imagen para consultar su información. 

Construcción del circuito electrónico

Realiza las conexiones del circuito electrónico que se muestra en el diagrama esquemático de la Figura 3. Recuerda que una terminal del zumbador va al pin 3 y el otro extremo a tierra.

Programación del circuito electrónico

Captura el código del programa en el IDE de Arduino. Te recomendamos que no lo copies y pegues, sino que tú lo escribas para que aprendas las instrucciones. 

/* Manual de programación con Arduino
* Práctica: Uso de arreglos unidimensionales
* Objetivo: Programa que reproduce una melodía con un buzzer
* Fecha: noviembre 2020
* Autor: Milagros Pacheco Castañeda
*/

// Declaración de las constantes de las notas 
// con las frecuencias 
const int Do= 261;
const int Re =294;
const int Mi =330;
const int Fa =349;
const int Sol =392;
const int La =440;
const int Si =494;
const int Doa =523;
const int Rea =587;
const int Sib =987; 
const int Silen=0;

int pinBuzzer = 3; // Declaración de la variable buzzer 
int i=0;

// Declaración de arreglo con las notas de la melodía
int notas[16]={Do, La, Sol, Fa, Mi, Rea, La, Sol, Fa, Mi, Rea, La, Sol, La, Sol, Mi};
// Declaración de arreglo con los tiempos de cada nota de la melodía
int duracion[16] = {4,4,1,1,1,4,2,1,1,1,4,2,1,1,1,8};

void setup() {
  pinMode(pinBuzzer, OUTPUT);
}

void loop() {

  // Toca la melodía

   for (i = 0; i <=15; i++) //El for realiza el barrido por los elementos del arreglo
   {
      tone(pinBuzzer, notas[i]); // Reproduce el tono de la nota
      delay(duracion[i]*200); // Tiempo que dura la nota
   }
   noTone(pinBuzzer); // Detiene el sonido
   delay (500);

}

Prueba el funcionamiento de tu circuito electrónico. Verifica que el circuito funcione como la simulación que se muestra a continuación. Presiona el botón Iniciar simulación y escucha la melodía ¿Ya adivinaste qué canción es?

Si en tu navegador no se muestra la simulación, ingresa al enlace https://www.tinkercad.com/embed/kcJQfjkxOnJ?

Bañuelos M. A. (2020). Arduino. Módulo 8.1 Experimentos. Zumbador piezoeléctrico. [Video]  https://youtu.be/LK4twOXFbC0