Almacenamiento de información (parte 3)


GENERANDO NÚMERO ALEATORIOS

Antes de continuar con el método de almacenamiento de información, necesitaremos tener un código que genere números aleatorios y los almacene en memoria temporal. Puedes modificar estos programas para almacenarlo en la memoria EEPROM interna.







Generaremos números aleatorios con la función random de PICAXE, pero la cual nos da una secuencia de valores aleatorios, así que si quieres que te salga valores más variados debes cambiar el valor de la variable antes de la función random para cambiar dicho valor. El comando sertxd sirve para enviar datos del PICAXE al PC y que se puedan desplegar en la ventana de PICAXE presionando F8.

main:
            random b0
            sertxd("valor aleatorio: ",#b0,13,10)
            pause 150       
goto main

Con memoria EEPROM interna:

for b0 = 0 to 10
            random b1
            write b0,b1
next b0

pause 2500

for b0=0 to 10
            read b0,b2
            sertxd("dato: ",#b2,13,10)
next b0







Se generarán 20 números aleatorios usando la función rand(), la cual es dividida por 1767 para colocar número inferiores de 20 en el arreglo. La función rand() al igual que la de PICAXE, genera números aleatorios en secuencia, así que si se quiere variar más los números se debe utilizar el comando srand().

int aleatorio[21],i;
char info[8], inf2[8];

void main(){
     Lcd_Init(&PORTB);
     Lcd_Cmd(Lcd_CLEAR);
     Lcd_Cmd(Lcd_CURSOR_OFF);

     for (i=0; i<=20;i++){
          aleatorio[i] = (rand()/1767);  //1767 es un valor para reducir el número aleatorio
          Lcd_out (1,1, "posicion: ");
          IntToStr(i,info); //convierte valor entero a char
          Lcd_out (1,11, info);
          IntToStr(aleatorio[i],inf2);
          Lcd_out (2,4,inf2);
          delay_ms(1000);
          Lcd_Cmd(Lcd_CLEAR);
     }
}











Utilizamos la función que proporciona el lenguaje para generar un número aleatorio y almacenarlo en un arreglo de 10 posiciones. Cabe destacar que la funcion Random siempre tiene la misma secuencia, así que si quieres que en tu programa genere varias veces números al azar y que no sean los mismos, debes usar randomSeed(valordereferencia) para hacer que se ajuste la aleatorización.

int datos[10],val;

void setup() {
  Serial.begin(9600);
  for (int j=0;j<11;j++){
    randomSeed(j+val);
    datos[j] = random(0, 50);
    val++;
    }
  for (int i=0;i<11;i++){ 
    Serial.println(datos[i]);
  }
  Serial.println("-----------");
}

void loop() {
 
}

BUSQUEDA DE INFORMACIÓN

Cuando almacenamos de una forma desordenada los datos en el microcontrolador, no tenemos un orden o un carácter de criterio para almacenar. A este tipo de arreglo de datos se les llama “Arreglos desordenados”.

Imaginemos el siguiente ejemplo: hemos creado un arreglo y queremos que a través de un ID tag busquemos el valor censado en el arreglo y si lo encuentra enciende un LED verde. Sino un LED rojo.

Así que tenemos que implementar una búsqueda, en un arreglo desordenado. La búsqueda se utiliza generalmente para recuperar datos que se habían almacenado antes. Los métodos de búsqueda pueden ser internos y externos.

La búsqueda interna trabaja con los elementos almacenados en la memoria del microcontrolador.

La búsqueda externa trabaja con los elementos almacenados en una memoria externa.

El único método que podemos utilizar (y el que pensamos utilizar casi intuitivamente) en un arreglo desordenado es una búsqueda secuencial desordenada. La cual consiste en revisar elemento tras elemento hasta encontrar el dato.

BUSQUEDA SECUENCIAL DESORDENADA – MEMORIA EEPROM INTERNA

El siguiente algoritmo muestra una búsqueda secuencial desordenada, en la cual lo que se busca comprobar es la posición del dato en el arreglo.

I: variable tipo entero.
X: elemento de un arreglo desordenado
V: arreglo
N: datos

Hacer I = 0
Mientras ((I<=N)y(v[I]<>X)) repetir
            Hacer I = I +1
{fin del ciclo}
Si (I>N)
            Entonces
                        Escribir: “no se encuentra la información”
            Si no
                        Escribir: “la información se encuentra en la posición: “, I
{fin de condición}

Ahora traducimos el algoritmo a cada uno de los microcontroladores que utilizamos:








Utilizaremos la función generadora de valores aleatorios y almacenaremos 11 datos al azar, buscaremos un número específico (11) y comprobaremos la funcionalidad del algoritmo. Debido a que PICAXE no tiene para arreglos, el programa se probará en la memoria EEPROM interna y además el algoritmo sufre un leve cambio ya que no se pueden implementar arreglos en este lenguaje.

#no_data 'no sobrescribe la EEPROM al momento de grabar este programa

pause 2500

b3 = 0
b5 = 0
do
            read b5,b4
            b3 = b3+1
            b5 = b5+1
loop while b3<=10 and b4<>11

if b3 > 10 then
            sertxd ("dato no encontrado")
else
            sertxd ("dato encontrado en posición: ", #b3,13,10)
endif







Utilizamos el código para generar números aleatorios, y comprobaremos la funcionalidad del algoritmo, buscando el número 7. El proceso lo realizaremos en memoria RAM, se hace esto para reducir el uso en la memoria EEPROM del microcontrolador.

int aleatorio[21],i,j;
char info[8],inf2[8];

void main(){
     TRISA.F0 = 0;
     Lcd_Init(&PORTB);
     Lcd_Cmd(Lcd_CLEAR);
     Lcd_Cmd(Lcd_CURSOR_OFF);
     PORTA.F0=0;

     for (j=0; j<=20;j++){
          aleatorio[j] = (rand()/1767);  //1767 es un valor para reducir el número aleatorio
     }

     /*for (i=0; i<=20;i++){  //se puede usar este ciclo para desplegar el arreglo y comprobar en que posición esta el número 7
          aleatorio[i] = (rand()/1767);
          Lcd_out (1,1, "posicion: ");
          IntToStr(i,info);
          Lcd_out (1,11, info);
          IntToStr(aleatorio[i],inf2);
          Lcd_out (2,4,inf2);
          delay_ms(1000);
          Lcd_Cmd(Lcd_CLEAR);
     } */

    
     delay_ms(750);
    
     i = 0;
     while ((i<=20) && (aleatorio[i]!=7)) {
           i++;
     }
     if (i>20){
        Lcd_Out(1,1,"no encontrado");
        }
     else{
        PORTA.F0=1;
        Lcd_Out(1,1,"posicion:");
        IntToStr(i, info);
        Lcd_Out(1,10,info);
     }
}












Utilizaremos la función generadora de valores aleatorios y almacenaremos 60 datos al azar, buscaremos un número específico (30) y comprobaremos la funcionalidad del algoritmo. El proceso lo realizaremos en memoria RAM.

int datos[60],val;

void setup() {
  Serial.begin(9600);
  for (int j=0;j<61;j++){ //generación de número aleatorios
    randomSeed(j+val);
    datos[j] = random(0, 80);
    val++;
    }
  for (int i=0;i<61;i++){   //despliega el arreglo
    Serial.print(i);
    Serial.print(": ");
    Serial.println(datos[i]);
  }
  Serial.println("-----------");
  int I = 1;  //algoritmo de búsqueda
  while (I<61 && datos[I]!=30)
  {
    I++;
  }
  if (I > 60)  {
    Serial.println("dato no encontrado");
    }
  else{
    Serial.print("la informacion se encuentra en la posicion: ");
    Serial.println(I);
  }   
}

void loop() {
 
}

El algoritmo anterior esta diseñado para buscar el primer valor y desplegarlo o si no se encontró, el siguiente algoritmo posee recursividad, lo cual significa que aunque encontró un valor, buscará los demás que son iguales.

I: variable tipo entero que inicia en 0.
X: elemento de un arreglo desordenado
V: arreglo
N: datos

Si (I>N)
            Entonces
                        Escribir: “información no encontrada”
            Si no
                        Si (V[I]=X)
                                   Entonces
                                               Escribir: “la información se encuentra en la posición”, I
                        {fin de la condición}
                        I = I +1
                        Regresar al paso 1 del algoritmo
{fin de la condición}







Generaremos 60 valores aleatorios y se realizará una búsqueda para encontrar el número 11 y que despliegue en pantalla en donde se encontró. Se ha agregado un ciclo para desplegar los valores y así comprobar la efectividad del ciclo de búsqueda.

for b0 = 0 to 60 'almacena valores
            random b1
            write b0,b1
next b0

'pause 1000   'ciclo para mostrar los valores almacenados (opcional)
'sertxd("datos",13,10)

'for b0=0 to 60
'           read b0,b2
'           sertxd("dato: ",#b2,13,10)
'next b0

pause 2500
sertxd ("buscando...",13,10)

b2= 0 'ciclo de busqueda
ciclo: if b2 > 60 then
                        sertxd("busqueda finalizada")
             else
                        read b2,b3
                        if b3 = 11 then
                                   sertxd("información encontrada en ",#b2,13,10)
                        endif
                        b2 = b2 +1
                        goto ciclo
             endif
stop







Se generan 20 números aleatorios, de los cuales se buscarán todos los números 7. Se esta utilizando un arreglo, así que si quieres hacer pruebas con la EEPROM del microcontrolador, debes modificar un poco el código. NOTA: el algorimo se modifico un poco, específicamente en la parte del salto para volver al primer paso del algoritmo. Se utilizo una sentencia while y un if.

int aleatorio[21],i,j;
char info[8],inf2[8];

void main(){
     TRISA.F0 = 0;
     Lcd_Init(&PORTB);
     Lcd_Cmd(Lcd_CLEAR);
     Lcd_Cmd(Lcd_CURSOR_OFF);
     PORTA.F0=0;

     for (j=0; j<=20;j++){
          aleatorio[j] = (rand()/1767);  //1767 es un valor para reducir el número aleatorio
     }

     /*for (i=0; i<=20;i++){  //se puede usar este ciclo para desplegar el arreglo y comprobar en que posición esta el número 7
          aleatorio[i] = (rand()/1767);
          Lcd_out (1,1, "posicion: ");
          IntToStr(i,info);
          Lcd_out (1,11, info);
          IntToStr(aleatorio[i],inf2);
          Lcd_out (2,4,inf2);
          delay_ms(1000);
          Lcd_Cmd(Lcd_CLEAR);
     }*/

     delay_ms(750);

     i = 0;          // ciclo de búsqueda
     while (i <= 20){
           if (aleatorio[i] == 7 ){
                    Lcd_Cmd(Lcd_CLEAR);
                    Lcd_Out(1,1,"posicion:");
                    IntToStr(i, info);
                    Lcd_Out(1,10,info);
                    delay_ms(700);
           }
           i++;
     }
     if (i > 20){
        Lcd_Cmd(Lcd_CLEAR);
        Lcd_Out(1,1,"busqueda fin.");
     }
}











Grabaremos 60 números aleatorios, de los cuales desplegaremos todos los números 4 que se encuentren  y se desplieguen en el monitor serial de Arduino. NOTA: el código para esta búsqueda tiene el mismo cambio que el que se hizo para PIC.

int datos[60],val;

void setup() {
  Serial.begin(9600);
  for (int j=0;j<61;j++){ //generación de número aleatorios
    randomSeed(j+val);
    datos[j] = random(0, 80);
    val++;
    }
  for (int i=0;i<61;i++){   //despliega el arreglo
    Serial.print(i);
    Serial.print(": ");
    Serial.println(datos[i]);
  }
  Serial.println("-----------");
 
  int I = 0; //algoritmo de búsqueda
  while (I <= 60){
    if (datos[I] == 4){
      Serial.print("posicion: ");
      Serial.println(I);
    }
    I++;
  }
  if (I > 60){
    Serial.println("busqueda finalizada");
   }
}

void loop() {
 
}

BUSQUEDA SECUENCIAL DESORDENADA – MEMORIA EEPROM EXTERNA

Para realizar una búsqueda externa se requiere de más tiempos de proceso por lo que la búsqueda es más lenta, si queremos optimizar y reducir el tiempo de lectura y escritura, debemos ordenar la memoria (tema que discutiremos en otra entrada).

El algoritmo para una búsqueda externa es el mismo para ambos casos, salvo que en este tipo de búsqueda se necesita identificar qué dispositivo externo es por lo tanto debemos utilizar correctamente el CS (bus SPI) o la dirección del dispositivo por I2C.







Utilizaremos el algoritmo de generación de números aleatorios y de búsqueda secuencial desordenada, almacenará 35 datos en la memoria EEPROM 24LC256 y buscará el número 11.



hi2csetup i2cmaster, %10100000, i2cslow, i2cword
pause 1500

main:
            for b1 = 0 to 35 'ciclo de almacenamiento aleatorio
                        random b0
                        sertxd("valor aleatorio ",#b1,": ",#b0,13,10)
                        hi2cout b1,(b0)
                        pause 10
            next b1

            b3 = 0 'ciclo de búsqueda
            b5 = 0
            sertxd(“buscando…”,13,10)
            do
                        hi2cin b5,(b4)
                        if b4 <> 11 then
                                   b3 = b3+1
                                   b5 = b5+1
                        endif
            loop while b3<=35 and b4<>11

            if b3 > 35 then
                        sertxd ("dato no encontrado")
            else
                        sertxd ("dato encontrado en posición: ", #b3,13,10)
            endif

El siguiente código es para la búsqueda secuencial desordenada con recursividad, con la misma configuración de datos de búsqueda del algoritmo pasado.

hi2csetup i2cmaster, %10100000, i2cslow, i2cword
pause 1500

main:
            for b1 = 0 to 35 'ciclo de almacenamiento aleatorio
                        random b0
                        sertxd("valor aleatorio ",#b1,": ",#b0,13,10)
                        hi2cout b1,(b0)
                        pause 10
            next b1

            sertxd ("buscando...",13,10)

            b2= 0 'ciclo de busqueda
            ciclo: if b2 > 35 then
                                   sertxd("busqueda finalizada")
                         else
                                    hi2cin b2,(b3)
                                   if b3 = 11 then
                                               sertxd("información encontrada en ",#b2,13,10)
                                   endif
                        b2 = b2 +1
                        goto ciclo
             endif
stop











El siguiente programa almacena 10 datos aleatorios en la memoria EEPROM 25LC256 y realiza una búsqueda secuencial desordenada. Pon atención en como esta trabajando el código y sus cambios que sufre al convertirse de un arreglo a un dispositivo externo SPI. Observa que hay un cambio en el algoritmo para incrementar I.



#include <SPI.h>
int datos,val,resultado=0;

void setup() {
  Serial.begin(9600);
  pinMode(10,OUTPUT);
  pinMode(2,OUTPUT);
  digitalWrite(10, HIGH);
  digitalWrite(2, HIGH);
  SPI.begin(); 
  SPI.setDataMode(SPI_MODE3);  //configura protocolo SPI
  SPI.setClockDivider(SPI_CLOCK_DIV2); // 10 Mhz max para 25LC256
  SPI.setBitOrder(MSBFIRST);
 
  digitalWrite(10, LOW);
  SPI.transfer(6);  // escritura habilitada 6
  digitalWrite(10, HIGH);
 
  digitalWrite(10, LOW);
  SPI.transfer(1); // remueve protección de bloque 1,0
  SPI.transfer(0);
  digitalWrite(10, HIGH);
  delay(5);
 
  for (int j=0;j<11;j++){ //generación de número aleatorios
    randomSeed(j+val);
    datos = random(0, 80);
   
    digitalWrite(10, LOW);
    SPI.transfer(6); // escritura habilitada 6
    digitalWrite(10, HIGH);
     
    digitalWrite(10, LOW);
    SPI.transfer(2); // write 2,0
    SPI.transfer(0);
    SPI.transfer(j); // registro
    SPI.transfer(datos); // dato a almacenar
    digitalWrite(10, HIGH);
    delay(5);
     
    digitalWrite(10, LOW);
    SPI.transfer(6); // escritura habilitada 6
    digitalWrite(10, HIGH);
   
    val++;
    Serial.print(j); //despliega el arreglo
    Serial.print(": ");
    Serial.println(datos);
    }
  digitalWrite(10, LOW);
  SPI.transfer(4); // escritura deshabilitada 4
  digitalWrite(10,HIGH);
  Serial.println("--------");
 
  int I = 0;  //algoritmo de búsqueda secuencial   
  while (I<11 && resultado!=56) //se busca el número 56
  {
    digitalWrite(10, LOW);
    SPI.transfer(3); // lee 3,0
    SPI.transfer(0);
    SPI.transfer(I);
    resultado = SPI.transfer(0x00);
    digitalWrite(10, HIGH);
   
    if (resultado != 56){ //si se cambia el número de búsqueda, cambiarlo también aquí
      I++;
    }
  }
  if (I > 10)  {
    Serial.println("dato no encontrado");
    }
  else{
    Serial.print("la informacion se encuentra en la posicion: ");
    Serial.println(I);
  }
}

void loop() {
}

Espera la próxima entrada y la última de almacenamiento de información, donde hablaremos sobre los arreglos ordenados.