Generador de números pseudoaleatorios en display de 7segmentos

Este proyecto,  desarrollado en PICBASIC PRO  para el micro 16F630, tiene por objeto mostrar en un display de 7 segmentos números pseudoaleatorios de 4 dígitos.
Para ello utilizamos la función RANDOM del compilador, la cual genera números de 16 bits ( 0 - 65635 ). Como disponemos de cuatro dígitos en el display, solo se mostrarán los primeros cuatro dígitos del número generado.

El programa se muestra a continuación:

'**************************************************************** '* Name : rnd00.BAS * '* Author : JLG * '* Notice : Copyright (c) 2015 * '* Device : 16F630 * '* Date : 24/05/2015 * '* Version : 1.0 * '* Notes : * '**************************************************************** @ __config _INTRC_OSC_NOCLKOUT & _WDT_ON & _MCLRE_ON & _CP_OFF vars: i Var byte r var word digit var byte A var byte D var byte init: TRISA = %1000 ' PORTA output except pin 3 (MCLR) TRISC = 0 ' PORTC output CMCON = 7 ' No comparator Define OSCCAL_1K 1 ' Set OSCCAL for 1K flash DEFINE OSC 4 ' 4 MHz OSC PORTA=0 PORTC=0 mainloop: random r for i= 1 to 100 gosub display_n next i for i= 1 to 20 gosub display_g next i goto mainloop End display_n: D = %01 : DIGIT = r dig 3 : gosub LOOk D = %10 : DIGIT = r dig 2 : gosub LOOk D = %0100 : DIGIT = r dig 1 : gosub LOOk D = %1000 : DIGIT = r dig 0 : gosub LOOk PORTA.5 = 0 Return display_g: DIGIT = 10 D = %01 : gosub LOOk D = %10 : gosub LOOk D = %0100 : gosub LOOk D = %1000 : gosub LOOk PORTA.5 = 0 Return LOOK : PORTC.4 = 0 PORTC.5 = 0 PORTA.4 = 0 PORTA.5 = 0 Lookup DIGIT,[%1000000,%1111001,%0100100,%0110000,%11001,%10010,%00011,%1111000,%00000,%11000,%0111111],A PORTA.0 = A PORTA.1 = A >> 1 PORTA.2 = A >> 2 PORTC.0 = A >> 3 PORTC.1 = A >> 4 PORTC.2 = A >> 5 PORTC.3 = A >> 6 PORTC.4 = D PORTC.5 = D >> 1 PORTA.4 = D >> 2 PORTA.5 = D >> 3 pause 5 RETURN
Como tenemos que multiplexar los dígitos, utilizamos un lazo que muestra el número generado durante unos segundos. Luego mostramos cuatro guiones en el display para indicar que se va a generar un nuevo número.

Números pseudo aleatorios en microcontroladores

Los números aleatorios son importantes para temas como el encriptado de información y la generación de claves de acceso.
El obtener números aleatorios no es algo trivial, y para ello se requiere utilizar principios físicos como el ruido presente en componentes y circuitos electrónicos. Algo que por lo general es indeseable, en este caso tiene una utilidad práctica.
Si no contamos con circuitos externos no podemos obtener números aleatorios verdaderos.
Por lo general todos los compiladores incluyen un función que permite generar números pseudoaleatorios, es decir números que se aproximan pero no son estadísticamente aleatorios verdaderos. Estas funciones generan secuencias de números que después de cierto tiempo se repiten.
Como la generación de números aleatorios o pseudoaleatorios es importante para temas de seguridad, se han hecho muchos estudios al respecto, y hay disponible una gran cantidad de algoritmos en internet.
Es evidente que un algoritmo es mejor mientras la secuencia de números que genere esté mejor distribuida desde el punto de vista estadístico.
Uno de los algoritmos disponibles lo podemos ver en este programa en CCSC C para el micro 16F628A:

//16f628A //ccsc // pseudo random numbers #include <16f628A.h> #include <math.h> #include <stdlib.h> #use delay(clock=4000000) #fuses NOWDT,INTRC_IO,PUT,NOPROTECT,BROWNOUT,MCLR,NOCPD #use rs232(baud=4800, xmit=PIN_A4) #define RANDMAX1 2147483646; int i,j; int32 r; float x; int32 random1 (int seed = 0) { static signed int32 next = 1; static int32 A = 1687; static int32 M = 2147483647; static int32 q = 127773; static int32 r = 2836; if (seed!=0) next=seed; next = A * (next % q) - r * (next /q); if (next <0) next +=M; return next; } void init(void) // Hardware initialization { set_tris_a(0b00001000); // Port A output,A.3 mode input setup_comparator(NC_NC_NC_NC); // disable comparator module r=random1(get_rtcc()); // Pseudorandom seed initialization } void main() { init(); // Configure peripherals/hardware j=0; for (i=1;i<5;i++) printf("int32 float(0-1) int16 "); printf("\r\n"); for (i=0;i<24;i++) { r=random1(0); x= (float) r / (float) RANDMAX1; printf("%10Lu %10.8f %5Lu ",r,x,rand()); j++; if (j>3){ printf("\r\n"); j=0; } } printf("\r\n"); }

EL programa genera números enteros pseudoaleatorios de 32bits y el equivalente de punto flotante en el rango (0,1).
Si invocamos la función random1()  con un parámetro distinto a 0, este valor se toma como la semilla (seed).
Podemos ver que en la subrutina init() invocamos la función y utilizamos como parámetro el valor del timer 0, de esta forma nos aseguramos que cada vez que el circuito empieza a funcionar la semilla, y la sequencia de números generados, es diferente.
El valor de la semilla es muy importante, por lo que se han ideado muchos procedimientos para una selección de la misma. Además de la lectura del reloj interno podemos mencionar:

• Al inicio leer una posición de memoria ram: En principio el valor no es predecible.
• Guardar en memoria eeprom el valor del reloj interno al ocurrir algún envento específico (por ejemplo la lectura de información por el puerto serial). Al inicio se lee este valor y se utiliza como semilla.

Podemos ver una imagen donde tenemos cuatro sets de números : int32 y punto flotante generados por el algoritmo y un entero generado por la función incluida en el compilador.

La ventaja del algoritmo en relación a la función incluida en el compilador es que en lugar de generar un número entero de 16bits tenemos uno de 32bits, lo cual, en principio, nos asegura que la secuencia de números disponibles es mayor antes de que la misma se repita.

Matemáticas y microcontroladores

No tiene mucho sentido tratar de resolver problemas matemáticos utilizando microcontroladores. Para empezar, el uso básico de un microcontrolador es tomar decisiones en base a señales físicas (digitales o analógicas) y generar otras señales (digitales o analógicas). Por otro lado, los microcontroladores no incluyen coprocesador matemático, por lo que todas las funciones matemáticas se calculan mediante rutinas incluidas en los compiladores a utilizar.
Sin embargo, y seguramente sin ningún uso práctico, me parece interesante ver hasta donde podemos llegar con estos animalitos con tan pocos recursos de cálculo.
A continución podemos ver un programa (en lenguaje CCSC C) para el micro 16F628A que permite generar los números de fibonacci, lucas y el famoso coeficiente de oro (golden ratio). Aunque utilizamos variables enteras de 32bits, solo podemos calcular hasta el número 46. Podemos ver que el golden ratio se estabiliza muy rápidamente. Recordemos que este micro tiene apenas 2KWords flash y 224Bytes ram.
La primera columna es el contador , la segunda el número de fibonacci, la tercera el número de Lucas y la cuarta el godlen ratio.

//16f628A //ccsc // fibonacci golden rate and lucas numbers #include <math.h> #use delay(clock=4000000) #fuses NOWDT,INTRC_IO,PUT,NOPROTECT,BROWNOUT,MCLR,NOCPD #use rs232(baud=4800, xmit=PIN_A4) unsigned int32 i,f,f0,f1 ; void init(void) // Hardware initialization { set_tris_a(0b00001000); // Port A output,A.3 mode input setup_comparator(NC_NC_NC_NC); // disable comparator module } void main() { init(); // Configure peripherals/hardware f0=0; f1=1; printf("%3Lu %10Lu 0000000002\r\n",f0,f0 ); printf("%3Lu %10Lu 0000000001\r\n",f1,f1); for (i=2;i<=46;i+=1) { f=f0+f1; f0=f1; f1=f; printf("%3Lu %10Lu %10Lu %10.8f\r\n",i,f,f+2*f0,(float)f1/(float)f0); } }

Si quisieramos utilizar un micro mas modesto , por ejemplo el 16F630 ( que sólo tiene 1KWord flash y 64Bytes ram ) no podríamos calcular el golden ratio porque no tendríamos flash suficiente para el código generado (el cálculo en punto flotante consume casi 500Words).

A continuación tenemos otro programa (también en lenguaje CCSC C y para el 16F628A) que genera los valores de seno(x),coseno(x),tangente(x) y como validacion la fórmula sen(x)*sen(x)+cos(x)*cos(x),  que debe ser el número 1. Podemos ver que no utilizamos las subrutinas del compilador, en su defecto hemos creado unas a partir de aproximaciones Chebyshev para valores de x entre 0 y 45º. Estas aproximaciones son algo mas precisas que las que vienen en el compilador (en la última cifra significativa) y el código generado es mas pequeño.

//16f628a //ccsc #include <16f628A.h> #include <math.h> #use delay(clock=4000000) #fuses NOWDT,INTRC_IO,PUT,NOPROTECT,BROWNOUT,MCLR,NOCPD #use rs232(baud=4800, xmit=PIN_A4) float phase,t,s,c; float pi2 = 3.141592653589 ; int16 i; void init(void) // Hardware initialization { set_tris_a(0b00001000); // Port A output,A.3 mode input setup_comparator(NC_NC_NC_NC); // disable comparator module } float sin1( float x) { float a2 =-0.1666666664; float a4 = 0.0083333315; float a6 =-0.0001984090; float a8 = 0.0000027526; float a10=-0.0000000239; float x2; x2=x*x; return(x*(1.0 + x2*(a2 + x2*(a4 + x2*(a6 + x2*(a8 + a10*x2)))))); } float cos1( float x) { float a20 =-0.4999999963; float a40 = 0.0416666418; float a60 =-0.0013888397; float a80 = 0.0000247609; float a100=-0.0000002605; float x2; x2=x*x; return((1.0 + x2*(a20 + x2*(a40 + x2*(a60 + x2*(a80 + a100*x2)))))); } void main() { init(); // Configure peripherals/hardware for (i=0; i<=45; i+=1) { phase= (float)i * pi2 / 180.0 ; s=sin1(phase); c=cos1(phase); t=s/c; printf("%3Lu %10.8f %10.8f %10.8f %10.8f\r\n",i,s,c,t,s*s+c*c); } }