Cuando hay que hacer algo de forma repetitiva, sería muy tedioso tener que escribir lo mismo muchas veces, cuando lo único que cambia es un número. Para eso están los ciclos de control, y en este instructable hablamos de los ciclos for. Utilizamos un ejemplo de caminadores aleatorios en una pantalla OLED. Es un ejemplo muy simple y en el aprendemos a utilizar arreglos y ciclos de control.

Step 1: Arreglos

Un arreglo es una estructura de elementos consecutivos del mismo tipo, que se accesan utilizando un número única ordenado que llamamos índice. Es como tener una archivador de varias gavetas, cada gaveta con un número único del 0 en adelante. Así la primera gaveta es 0, la segunda es 1 y así sucesivamente.

Hay varias maneras de crear arreglos en C. La más directa es:

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

En este caso, se crea un arreglo, llamado gavetas, de variables tipo entero int. Noten como luego del nobre gavetas, se utiliza los paréntesis cuadrados "[" y "]". Estos son los que luego se utilizan para accesar los valores del arreglo. En este ejemplo también se "llenan" las gavetas de una vez con los valores "{ 2, 7, 4, 6, 5, 3}". Es decir, al final, quedamos con una arreglo de 6 valores. Otra manera de hacer lo mismo es:

int gavetas[6];

Declarar primero el arreglo vacío, y luego agregar los valores:

gavetas[0] = 2;
gavetas[1] = 7;
gavetas[2] = 4;
gavetas[3] = 6;
gavetas[4] = 5;
gavetas[5] = 3;

Como ven, asignamos los valores de cada gaveta, colocando la posición que queremos llenar en paréntesis. Si quisiéramos utilizar esos valores, por ejemplo escribiríamos,

int suma = gavetas[0] + gavetas[3];

De esa forma en la variable suma, queda almacenado el valor 8. En este istructable utilizaremos arreglos y utilizaremos ciclos for para manipularlos.

Step 2: Ciclos "for"

un ciclo for con un iterador que llamamos i, se declararía de la siguiente manera:

for(int i = 0; i < 5; i++){
  hace algo...
}

Cuando se declara el for() hay que especificar varias cosas como se muestra en la foto. Primero declaramos el iterador y el tipo en este caso "int i=0" lo que indica que el iterador comeinza en 0. Luego ";" seguido del limite máximo, en este caso " i < 5", es decir el for se detendrá en i = 4. Punto y coma y luego "i++", que indica que cada ciclo se incrementa en 1. Veamos por ejemplo este código:

void setup(){
  Serial.begin(9600);
}
void loop(){
  for(int i = 0; i < 5; i++){
    Serial.print(i);
  }
  Serial.println();
}

Si por ejemplo en el for, cambian el iterador i, en lugar de "i++" coloquen "i+=2" o "i+=3", vean el resultado. Juegeune un rato cambiando los valores de límite superior y de incremente y vean los resultados, con eso ya tendrán una buena idea operacional del ciclo for.

Step 3: Materiales Y Connexión

Ocupamos:

Arduino UNO
Pantalla OLED
calbes

Las conexiones son las mismas que este instructable

Step 4: Código

En este ejemplo, vamos a crear un montón de caminadores aleatorios. Son como partículas que caminan en cualquier dirección. Para crear aleatoriedad utilizamos la función random(), y como verán por el resultado, en Arduino es bastante mala, pero para aplicaciones simples, funciona bien. Todo lenguaje de programación tiene algún tipo de función random, dado que esta función es fundamental para muchos aspectos de cálculo, simulaciones y desarrollo de hardware y software en general.

Para hacer un caminador aleatorio, debemos mantener posiciones x,y de varias "partículas", y para eso usamos dos arreglos, posX[] y posY[], para guardar x,y respectivamente. Estas coordenadas las vamos cambiando por cada ciclo loop del Aduino, y vamos dibujando un círculo utilizando estas posiciones.

Veamos varias cosas del código. De las líneas 2 a la 4, se cargan las librerías que vamos a utilizar para la pantalla OLED. Pueden ir a este instructable para la explicación de estas librerías y su utilización.

En las líneas 6 a 8, creamos dos arreglos de enteros:

const int num = 10;
int posX[num] ;
int posY[num];

Vean que la primera línea de ese código utilizamos "const", esto lo que indica es que la variable num, es una constante, es decir, que no cambiará su valor en ninguna parte del proagrama. Si no le agregan "const", les daría el siguiente error:

IntroC_For:7: error: array bound is not an integer constant before ']' token
int posX[num];

Esto es porque este tipo de arreglos son estáticos, es decir, se construyen y el micro-controlador asigna de inmediato el espacio de memoria y no se puede cambiar su tamaño en ningún momento después de creados. "num" debe ser necesariamente una constante, y por eso esto se corrige indicando que es una constante agregando "const" al inicio de la declaración.

Los arreglos posX[num] y posY[num], almacenan valores de tipo entero, y como definicmos num que sea igual a 10, entonces, habrá 10 "gavetas" en cada arreglo.

En la función setup(), las líneas 16 a 19, inicializamos cada variable en el arreglo, para colocarlos en el centro de la pantalla,

for (int i = 0; i < num; i++) {
    posX[i] = 64;
    posY[i] = 32;
  }

Acá utilizamos el ciclo for, para ir por cada elemento del arreglo y asignarle el valor inicial del centro de pantalla en posición x,y. Noten como el iterador i, se utiliza para indicar que elemento del arreglo vamos a asignar, y el ciclo se encarga de cambiar i, desde 0 a 5.

En la sección loop(),

for (int i = 0; i < num; i++) {
    posX[i] = constrain(posX[i] + random(-3, 3),1,127);
    posY[i] = constrain(posY[i] + random(-3, 3),1,63);
    display.fillCircle(posX[i], posY[i],  1, WHITE);
    display.display(); 
  }

Volvemos a utilizar un ciclo for, para cambiar los valores de posición x,y. En la línea,

posX[i] = constrain(posX[i] + random(-3, 3),1,127);

Se utilizan varias cosas. Veamoslo de adentro hacia afuera. Lo primero es la función random(-3,3). Esta función lo que hace es generar un número aleatorio entre -3 y 3. Una vez creado el número, esta se la sumamos a la posX[i], que era la posición en la que estaba antes. Luego utilizamos la función constrain(posX[i] + random(-3, 3),1,127);, esta lo que hace es asegurar que el cualquiera que sea el resultado, este nunca sea menos que 1 o mayor que 127. Pueden ver su uso en la referencia de Arduino. Hacemos lo mismo con posY[i].

Una vez re-calculada la nueva posición, dibujamos un círculo condisplay.fillCircle(posX[i], posY[i], 1, WHITE), y luego actualizamos el display con display.display();

Eso es todo. ahora verlo funcionando.

IntroC_For.ino
Download

Step 5: Funcionando

Listo, cargar y listo.

Cada vez que se reinicia comienza de nuevo. Como ven la función random() de Arduino no es muy buena. en principio debería haber una distribución por toda la pantalla de puntos, sin embargo tienen a moverse hacia arriba e izquierda, más que hacia otros lados.

Pueden cambiar el número de partículas, y el rango de movimiento random para que vean el resultado.