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); } }

Conexión de shift register 74LS595 a 16F676

Cuando utilizamos un micro como el 16F676 los puertos disponibles deben aprovecharse al máximo, ya que su  número es reducido.
En este proyecto queremos medir una señal analógica (fotodiodo) y mostrar el valor en un display cuadruple de 7 segmentos.
Para ahorrarnos puertos podemos utilizar un registro de desplazamiento serial a paralelo (shift register) , en este caso el 74LS595, con el objeto de controlar los siete segmentos del display. La información se envia en modo serial al 74LS595 y este lo distribuye a los 7 segmentos. De esta forma en lugar de utilizar 7 pines utilizamos 3.

Los cuatro primeros pines del puerto C del micro se utilizan para seleccionar el display que corresponda, ya que vamos a utilizar multiplexado, es decir , seleccionamos un display y enviamos el dígito  respectivo, y asi en un ciclo sin fin.

A continuación tenemos el  programa en PICBASIC PRO:

'**************************************************************** '* Name : ana01.BAS * '* Author : JLG * '* Notice : Copyright (c) 2015 * '* Device : 16F676 * '* Date : 06/03/2015 * '* Version : 1.0 * '* Notes : Se lee valor analógico en pin A.4 y se envia * '* al shitf register por los pines A.0 A.1 y A.2 * '**************************************************************** @ __config _INTRC_OSC_NOCLKOUT & _WDT_ON & _MCLRE_ON & _CP_OFF Include "modedefs.bas" DEFINE SHIFT_PAUSEUS 0 ' Define ADCIN parameters Define ADC_BITS 10 ' Set number of bits in result Define ADC_CLOCK 3 ' Set clock source (3=rc) Define ADC_SAMPLEUS 50 ' Set sampling time in uS vars: DIGIT var byte A var word i var byte p var word v var word ' Definiciones para el shit register D2PIN Var PORTA.0 ' Shift data pin C2PIN Var PORTA.1 ' Shift clock pin L2PIN Var PORTA.2 ' Shift latch pin bvar Var byte init: TRISA = %011000 ' PORTA output except P3 (MCLR ) and P4 Analog TRISC = 0000 ' PORTC output CMCON = 7 ' No comparator ' 1 0 0 011 01 ADCON0 = %10001101 ' Right Justify VDD VRefer. N/A Canal AN3 ' 0 101 0000 ADCON1 = %01010000 ' N/A Fosc/16(4us a 4Mhz) N/A ANSEL = 001000 ' Se utiliza el Canal 3 ( PA.4 ) Define OSCCAL_1K 1 ' Set OSCCAL for 1K flash DEFINE OSC 4 ' 4 MHz OSC PORTA=0 PORTC=0 mainloop: p=0 for i= 1 to 10 adcin 3,V p = p + V gosub display next i a= p / 10 label: gosub display goto mainloop display: DIGIT = A dig 0 gosub look PORTC = %1000 pause 4 DIGIT = A dig 1 gosub look PORTC = %0100 pause 4 DIGIT = A dig 2 gosub look PORTC = 10 pause 4 DIGIT = A dig 3 gosub look PORTC = 01 pause 5 PORTC = 00 return look: Lookup DIGIT,[%01000000,%01111001,100100,110000,_ 011001,010010,000011,%01111000,_ 000000,011000,%01111111],bvar PORTC = 00 LOW L2PIN : Shiftout D2PIN, C2PIN, MSBFIRST,[bvar] HIGH L2PIN : LOW L2PIN return End    

La señal analógica proveniente del fotodiodo se lee diez veces para obtener un valor promedio.

Es importante comentar que se llama a la subrutina display en el lazo de lectura analógica ya que tenemos que refrescar el display.

La subrutina look determina que pines se encienden/apagan dependiendo del dígito a mostrar. Luego se utiliza la instaruccion Shifout para enviar el byte con la información al 74LS595. Los valores presentes en la instrucción Lookup corresponden a las conexiones entre las salidas del 74LS595 y los pines de los siete segmentos del display para cada dígito 0,1,2,3...9.

En la imagen el proyecto en protoboard:

Escritura y Lectura de memorias eeprom externas 24LCxxB (16F630 16F676)

En ocasiones necesitamos guardar información en memoria que no debe perderse si la fuente de alimentación de nuestro circuito deja de funcionar.
Para ello se puede utilizar la memoria interna eeprom del micro. Sin embargo, esta memoria no suele ser muy gande. Es entonces cuando podemos utilizar las memorias eeprom externas.

En el mercado hay una gran variedad de memorias de este tipo. Vamos a trabajar con la familia 24LCxxB de Microchip, que utiliza la interfase I2C.
Los números presentes en los dígitos xx indican el número de kilobits de la memoria. Por ejemplo, el código 24LC04B nos indica que tenemos 4kilobit de memoria (4016 bits), lo cual equivale a 512 bytes. Esta es la memoria que vamos a utilizar para nuestro proyecto.

Las memorias de 1,2,4,8 y 16 Kbits tienen una dirección de acceso única, sin embargo las memorias de mayor capacidad (32Kb, 64Kb,etc) disponen de tres pines para establecer la dirección de acceso al chip.

Otra característica de las memorias de menor capacidad es que deben ser accesadas por bancos de 256 bytes. Esto quiere decir que en nuestro caso tenemos 2 bancos de 256 bytes.

Si utilizamos el compilador PICBASIC PRO para programar el micro tenemos a nuestra disposición las instrucciones I2CREAD e I2CWRITE para leer y escribir en la memoria. El tercer parámetro de estas instrucciones (control) indica , entre otras cosas, el banco en el cual estamos trabajando. De tal forma que si queremos leer alguna posición desde 0 hasta 255 , debemos indicar que trabajamos con el banco 0, y para posiciones superiores a 255 debemos indicar que vamos a trabajar con el banco 1.

En el programa anexo hemos elaborado dos subrutinas de lectura/escritura que generan automaticamente los bits correspondientes.

'**************************************************************** '* Name : eep02.BAS * '* Author : JLG * '* Notice : Copyright (c) 2015 * '* Device : 16F630 * '* Date : 06/03/2015 * '* Version : 1.0 * '* Notes : 24LC04B 512Bytes 2 banks * '**************************************************************** @ __config _INTRC_OSC_NOCLKOUT & _WDT_ON & _MCLRE_ON & _CP_OFF Include "modedefs.bas" vars: eee_size con 511 ' external eeprom size minus 1 (512 -1 = 511) MODE var word ' WORD for MODE value PICSO var PORTA.5 ' Defines PORTA.5 name as PICSO DPIN Var PORTC.4 ' I2C data pin CPIN Var PORTC.5 ' I2C clock pin cont var byte B1 Var byte B3 Var byte bank var byte addr0 var word addr1 var byte init: TRISA = 1000 ' PORTA output except pin 3 (MCLR ) TRISC = 0000 ' PORTC output CMCON = 7 ' No comparator Define OSCCAL_1K 1 ' Set OSCCAL for 1K flash DEFINE OSC 4 ' 4 MHz OSC mode = 188 ' 4800bps for 4Mhz clock PORTA=0 PORTC=0 pause 500 Serout2 PICSO,mode,[" ",10,"Writing eeeprom",10] for addr0 = 0 to eee_size gosub eeer_write next addr0 mainloop: Serout2 PICSO,mode,[10,10,"eeeprom values",10,"0000 "] B3=0 for addr0 = 0 to eee_size gosub eeer_read if b1>15 then Serout2 PICSO, Mode,[ihex (B1)," "] else Serout2 PICSO, Mode,[" ",ihex (B1)," "] endif b3 = B3 + 1 if (B3 >15) and (addr0<eee_size ) then if addr0=15 then Serout2 PICSO, Mode,[10,"0010 "] else Serout2 PICSO, Mode,[10,hex4 addr0+1," "] endif B3=0 endif next addr0 Serout2 PICSO, Mode,[10] pause 15000 goto mainloop eeer_read: bank = addr0 / 256 addr1= addr0 - (256 * bank) cont = $A0 + ( bank * 2 ) I2CREAD DPIN,CPIN,cont,addr1,[B1] return eeer_write: bank = addr0 / 256 addr1= addr0 - (256 * bank) cont = $A0 + ( bank * 2 ) I2CWRITE DPIN,CPIN,cont,addr1,[addr1] Pause 10 return End
En la sección init: escribimos en cada posición de memoria el primer byte de su dirección.
En la sección mainloop: leemos la memoria y mostramos el contenido en la pantalla del ordenador mediante un puerto serial/software.

En la pantalla adjunta podemos ver el resultado de la escritura/lectura en la utilidad Serial Communicator del compilador PICBASIC PRO

Programadores PIC

Un programador es un dispositivo que nos permite grabar en la memoria flash del micro el código hexadecimal generado por el compilador/ensamblador de nuestra preferencia.
Tenemos dos opciones: Adquirir uno en el mercado o construirlo nosotros mismos.
Los programadores mas populares son los de la empresa Microchip o sus clones, ya que esta empresa liberó los esquemas electrónicos de los mismos asi como también el software asociado.
Originalmente estos dispositivos utilizaban los puertos serial o paralelo para comunicarse con el computador. Hoy en día estos puertos han sido sustituidos por puertos USB.
Hay dos posibilidades para conectar el micro al que deseamos grabar el código hexadecimal:

• Mediante una base donde se coloca el micro
• Mediante programación en el circuito (ICSP) : No tenemos que retirar el micro del circuito, sin embargo, no todos los micros aceptan esta tecnología.

A continuación una relación reducida de algunos programadores:

• PICkit 2 
• PICkit 3
• usbpicprog : Es un programador USB open source basado en un micro 18F2550
• JDM2 : Versión actualizada del mítico programador por puerto serial JDM
• Open Programmer: Programador USB open source muy completo basado en el 18F2550.
• Arduino como programador para 18F2550
• Arduino como programador para la familia 16
• Arduino como programador de la familia 12
• Otra versión de Arduino como programador PIC
• Arduino como programador del PIC32MX

El programador requiere para su utilización del software necesario para grabar el archivo hexadecimal en el micro.
Algunos programas disponibles:

• PICPgm
• WinPicProg
• WinPic800
• EPICWin
• PonyProg 
• IC-Prog 

Reloj interno, cristal o resonador ?

Cuando trabajamos en un proyecto una de las decisiones que debemos tomar está relacionada con el oscilador del microcontrolador.
En general tenemos tres opciones : Reloj interno del micro (en caso de que lo tenga), cristal de cuarzo o resonador cerámico.
A continuación las ventajas y desventajas:

• Reloj interno: Es la opción mas económica ya que no necesitamos adquirir componentes adicionales. Por otro lado dejamos libres dos pines del micro que pueden ser utilizados como puertos de entrada/salida. La desventaja es su precisión, que por lo general tiene un error del 1%.
• Resonador cerámico: Es la opción mas económica si necesitamos mayor precisión. El error suele estar entre 0.1% y 1%. Además del costo de un componente adicional tenemos que dedicar dos pines para su conexión.
• Cristal de cuarzo : Es la opción mas precisa , en el rango de 10 a 50 partes por millón, aunque mas costoso que el resonador. Al igual que con el resonador debemos utilizar dos pines del micro y se requiere adicionalmente dos condensadores iguales entre los dos pines y tierra , por lo general de 22pf o 33pf.

 En resumen podríamos decir:

• Un proyecto personal : Utilizar el reloj interno del micro. En caso de que no lo tenga utilizar un cristal de cuarzo. La diferencia de precio con el resonador es asumible.
• Proyecto masivo donde no se necesita precisión y no se dispone de reloj interno: Usar el resonador. La diferencia en precio con el cristal se vuelve significativa cuando hablamos de cantidades grandes.
• Proyecto donde se requiere preción: Utilizar cristal de cuarzo.