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.

Contador con display de siete segmentos 16F630

Este proyecto utiliza todos los pines del micro 16F630 y su objetivo es desarrollar un contador de minutos/segundos utilizando un display cuadruple de 7 segmentos.

Como podemos ver en la figura no utilizamos resistencias para los segmentos , las utilizamos para los pines de selección de cada dígito, con lo que la luminosidad será diferente dependiendo del número mostrado.
El boton de reset permite iniciar el contador a 00:00
Tomando en cuenta que se utiliza el oscilador interno, la precisión no es muy buena (se adelanta un segundo cada 10 minutos con el micro utilizado).
El programa se muestra a continuación:

'**************************************************************** '* Name : clock00.BAS * '* Author : JLG * '* Notice : Copyright (c) 2015 * '* Device : 16F630 * '* Date : 06/03/2015 * '* Version : 1.0 * '* Notes : * '**************************************************************** @ __config _INTRC_OSC_NOCLKOUT & _WDT_ON & _MCLRE_ON & _CP_OFF vars: ticks Var byte ' Define pieces of seconds variable update Var byte ' Define variable to indicate update i Var byte j Var byte sec var byte minute var byte digit var byte A var byte D 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 PORTA=0 PORTC=0 OPTION_REG = %11010101 ' $D5 Set TMR0 configuration ' 101 prescaler 1:64 every 16.384 ms INTCON = %10100000 ' $A0 Enable TMR0 interrupts On Interrupt Goto tickint ticks = 0 update = 1 sec = 0 minute = 0 mainloop: If update = 1 Then INTCON = %10000000 ' $80 No interrupts sec = sec + 1 if sec = 60 then sec = 0 minute = minute +1 if minute=60 then minute=0 endif update = 0 ' Screen updated INTCON = %10100000 ' $A0 Enable TMR0 interrupts Endif gosub display_n goto mainloop Disable ' Disable interrupts during interrupt handler tickint: ticks = ticks + 1 ' Count pieces of seconds If ticks = 61 Then update=1 ticks = 0 endif INTCON.2 = 0 ' Reset timer interrupt flag Resume enable End display_n: D = 01 : DIGIT = minute dig 1 : gosub LOOk D = 10 : DIGIT = minute dig 0 : gosub LOOk D = %0100 : DIGIT = sec dig 1 : gosub LOOk D = %1000 : DIGIT = sec dig 0 : 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],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
El proyecto utiliza interrupciones generadas por el reloj interno TMR0 .
Es interesante mencionar la línea al principio del programa :

  @  __config _INTRC_OSC_NOCLKOUT & _WDT_ON & _MCLRE_ON & _CP_OFF 

Esta línea establece los parámetros del micro (fuses), ya que en el archivo 16F630.INI se comentó la misma línea para poder incorporarla en todos los programas y seleccionar los  valores de interés.

PIC Fuses PICBASIC Pro

Cuando compilamos un programa en PICBASIC Pro el compilador agrega a nuestro código las definiciones presentes en el archivo INC correspondiente al micro utilizado.
Si por ejemplo estamos utilizando el micro 16F630 tendremos el siguiente contenido:

;**************************************************************** ;* 16F630.INC * ;* * ;* By : Leonard Zerman, Jeff Schmoyer * ;* Notice : Copyright (c) 2005 microEngineering Labs, Inc. * ;* All Rights Reserved * ;* Date : 08/31/05 * ;* Version : 2.46a * ;* Notes : * ;**************************************************************** NOLIST ifdef PM_USED LIST include 'M16F630.INC' ; PM header device pic16F630, intrc_osc_noclkout, wdt_on, mclr_on, protect_off XALL NOLIST else LIST LIST p = 16F630, r = dec, w = -302 INCLUDE "P16F630.INC" ; MPASM Header __config _INTRC_OSC_NOCLKOUT & _WDT_ON & _MCLRE_ON & _CP_OFF NOLIST endif LIST Podemos observar que dependiendo del ensamblador que utilicemos (PM o MPASM) el encabezado es diferente.
Si quisieramos modificar alguno de los fusibles en nuestro programa, por ejemplo deshabilitar la función MCLR del micro 16F630 y utilizar el pin en su función como PORTA.3 , tenemos dos opciones:

• Modificar el archivo 16F630.INI y colocar _MCLRE_OFF en lugar de _MCLRE_ON (para MPASM). En este caso la modificación aplicaría para todos los programas que compilemos.
• Comentar la línea en el archivo 16F630.INI colocando punto y coma al principio de la misma, y agregando la línea @  __config _INTRC_OSC_NOCLKOUT & _WDT_ON & _MCLRE_ON & _CP_OFF  al principio de nuestro programa (en el caso de MPASM). De esta forma podemos seleccionar valores diferentes para cada programa.

Interrupciones por Reloj 16F630

Ya sabemos que los micros PIC tienen relojes internos (de 8 y 16 bits) y manejan interrupciones.
La combinación de estos dos conceptos permite la generación de una interrupción a partir de uno de los relojes internos del micro.
Aunque el concepto es sencillo, para su implementación hay que ser muy cuidadoso y tomar en cuenta varios puntos fundamentales.
Vamos a analizar un programa muy sencillo en PICBASIC Pro  (basado en otros aportes de la web) utilizando el micro 16F630. El objetivo del programa es encender y apagar un led  conectado al pin 0 del puerto A (se utiliza un led colocado en el pin 1 del mismo puerto para validar cada vez que se produce una interrupción).

'**************************************************************** '* Name : int01.BAS * '* Author : JLG * '* Notice : Copyright (c) 2015 * '* Device : 16F630 * '* Date : 06/03/2015 * '* Version : 1.0 * '* Notes : * '**************************************************************** vars: ticks Var byte ' Define pieces of seconds variable update Var byte ' Define variable to indicate update of LCD 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 PORTA=0 PORTC=0 OPTION_REG = %11010101 ' $D5 Set TMR0 configuration ' 101 prescaler 1:64 every 16.384 ms INTCON = %10100000 ' $A0 Enable TMR0 interrupts On Interrupt Goto tickint ticks = 0 update = 1 mainloop: If update = 1 Then INTCON = %10000000 ' $80 Disable TRM0 interrupts toggle PORTA.0 update = 0 INTCON = %10100000 ' $A0 Enable TMR0 interrupts Endif goto mainloop Disable ' Disable interrupts during interrupt handler tickint: toggle PORTA.1 ticks = ticks + 1 ' Count pieces of seconds If ticks <61 Then tiexit update=1 ticks = 0 tiexit: INTCON.2 = 0 ' Reset timer interrupt flag Resume enable End
Puntos a considerar:

• Vamos a utilizar el oscilador interno del micro. En el caso del 16F630 ( y otros ) se necesita calibrar dicho oscilador. Para ello se utiliza la instrucción  Define OSCCAL_1K 1  (ya que tenemos un micro con 1K de flash, en el caso de micros con 2K de flash la instrucción sería Define OSCCAL_2K 1 ). Esta instrucción toma un valor grabado de fábrica ubicado en las posiciones finales de la memoria flash, de ahí la importancia de indicar si el micro tiene 1K o 2K de flash.
• Como el reloj interno es de 4Mhz, debemos indicarle al compilador dicho valor mediante la instrucción DEFINE OSC 4 .
• Lo siguiente que debemos hacer es utilizar los registros internos del micro  para establecer los parámetros del timer y las interrupciones. Para ello tenemos que revisar la hoja de especificaciones del micro que estemos utilizando.  En nuestro caso, para el 16F630, dichos registros son OPTION_REG e INTCON.
• La instrucción OPTION_REG = %11010101 permite utilizar un divisor  de 1/64 , lo que equivale a 16.384 milisegundos.
• La instrucción INTCON  = %10100000 activa las interrupciones en general y la del reloj en particular.
• La instrucción On Interrupt Goto tickint permite que cada vez que ocurra una interrupción se ejecute el codigo ubicado en la etiqueta tickint.
• Revisando el código de la etiqueta tickint podemos ver los siguientes detalles:
• Antes de la etiqueta tickint tenemos la instrucción DISABLE , ya que no queremos que ocurran otras interrupciones mientras estamos procesando la presente.
• La instrucción INTCON.2 = 0 al final de la sección permite poner a cero el reloj
• La instrucción RESUME permite regresar al código donde estabamos antes de la interrupción.
• ENABLE habilita de nuevo las interrupciones
•  En el lazo principal (mainloop) procesamos el valor de la variable update . Como tampoco queremos que ocurran otras interrupciones mientras ejecutamos este código, utilizamos las instrucciones INTCON = %10000000 e INTCON = %10100000 que deshabilita y habilita las interrupciones a partir del reloj interno.

En la literatura disponible en la web hay cierta confusión en relación a la ubicación de las instrucciones ENABLE y DISABLE .  En una subrutina lo lógico es que estas instrucciones estén dentro de la misma, pero en este caso no es una subrutina, por lo que su posición es diferente.

También debemos considerar que la interrupción se ejecuta entre instrucciones, por lo que si estamos ejecutando una instrucción particular, como SERIN/SERIN2 , la interrupción se procesará después de ejecutarse la misma.

Microcontroladores PIC

Mis primeras experiencias con microcontroladores fueron hace muchos años, y con la familia MCS-51 de la Intel (años aquellos). Después de mucho tiempo alejado del tema, volví a los micros a traves del Arduino. Que diferencia !!!

Arduino es un concepto  muy interesante y muy exitoso que trasciende los micros Atmel.

Parece dificil de creer, pero aunque había oido de los micros PIC de Microchip, no había tenido la oportunidad de "jugar" con ellos.

Recientemente me decidí  a probar las bondades de estos micros.

Y entonces me di cuenta de las diferencias entre el Arduino y la familia PIC.

Mi idea no es contribuir a la controversia entre PIC y Arduino. Creo que muchas veces lo que vemos en la red realmente no aporta ningún valor.

Mi opinión es que son dos conceptos diferentes, cada uno tiene sus ventajas y sus desventajas, que se manifestarán dependiendo del proyecto en cuestión.

Y el punto es ese, si podemos decidir, lo mas sabio es seleccionar el micro que mas se adecue a nuestras necesidades.

Entonces entremos en materia.

Para trabajar con un micro PIC debemos tener:

• Un PC. En mi caso voy a trabajar con un portatil con el S/O windows Vista.
• Un programador de PICS : Hay muchos en el mercado. Yo me decidí por un clon del PICKit2
• Un programa para grabar el PIC : En mi caso viene con el programador
• Un ambiente de desarrollo
• Un micro PIC

Los tres primeros requisitos son los mas sencillos, pero los dos últimos son para meditar.

La razón es que en el mercado hay muchos ambientes de desarrollo y la empresa Microchip tiene una cantidad impresionante de diferentes micros.

En otra entrada detallaré mi experiencia con diferentes ambientes de desarrollo, sin embargo, por los momentos, me decidi por la combinación del IDE Micro Code Studio y el compilador PICBASIC Pro

En relación al micro, empecé por dos de la gama baja:

• 12F675 : 8 pines, 1KW flash, 64B ram,128B rom, 6 puertos, 4 A/D 10 bits
• 16F684 : 16 pines, 2KW flash, 128B ram, 256B rom, 12 puertos, 8 A/D 10 bits

Tal vez mi decisión parecerá muy modesta, pero siempre me ha interesado el sacar el máximo provecho de un micro, y mas importante, no deja de deslumbrame lo que podemos hacer con un micro de 8/16 pines !!!

El proyecto que voy a presentar tiene por objeto utilizar varias funcionalidades del 16F684:

• Uso de pines digitales para encender/apagar leds
• Comunicación serial a traves de cualquier pin
• Generación de sonido mediante un altavoz conectado a un puerto digital

El programa utilizado (tomando como base aportes previos en la web) es el mostrado a continuación:

'**************************************************************** '* Name : TEST00.BAS * '* Author : JLG * '* Notice : Copyright (c) 2015 * '* Device : 16F684 * '* Date : 06/03/2015 * '* Version : 1.0 * '* Notes : * '**************************************************************** Include "modedefs.bas" vars: MODE var word ' WORD for MODE value Command var byte ' BYTE for Command value LED1 var PORTA.0 ' Defines PORTA.0 name as LED1 LED2 var PORTA.1 ' Defines PORTA.1 name as LED2 LED3 var PORTA.2 ' Defines PORTA.1 name as LED3 PICSI var PORTC.0 ' Defines PORTC.0 name as PICSI PICSO var PORTC.1 ' Defines PORTC.1 name as PICSO LEDS VAR PORTA B0 var byte B1 var byte B3 var byte init: TRISA = 1000 ' PORTA output except pin 3 ( MCLR ) ANSEL = 0 ' Changes analog bits to digital. OSCCON = $70 ' Sets the internal clock to 8MHz define OSC 8 ' Compiler must know de new frequency CMCON0 = 7 ' No comparador TRISC.0 = 1 ' Port C0 input mode = 84 ' 9600bps, 8bits, no parity, 1 stop bit gosub leds_show Serout2 PICSO, Mode, ["Initializing...",10,13] gosub help mainloop: Command=0 serin2 PICSI,Mode, 30000,timeout,[Command] Select case Command case "a" HIGH LED1 Serout2 PICSO, Mode, ["LED1 ON",10,13] case "b" low LED1 Serout2 PICSO, Mode, ["LED1 OFF",10,13] case "c" HIGH LED2 Serout2 PICSO, Mode, ["LED2 ON",10,13] case "d" low LED2 Serout2 PICSO, Mode, ["LED2 OFF",10,13] case "e" low LED1 low LED2 Serout2 PICSO, Mode, ["LED1,LED2 OFF",10,13] case "f" high LED1 high LED2 Serout2 PICSO, Mode, ["LED1,LED2 ON",10,13] case "l" gosub leds_show case "h" gosub help: case "r" Serout2 PICSO, Mode, ["Read EEPROM",10,13] B3=0 Serout2 PICSO, Mode,["00 "] For B0 = 0 To 255 Read B0,B1 if b1>15 then Serout2 PICSO, Mode,[ihex (B1)," "] else Serout2 PICSO, Mode,[" ",ihex (B1)," "] endif b3 = B3 + 1 if (B3 >15) and (B0<255) then if b0=15 then Serout2 PICSO, Mode,[10,13,"0F "] else Serout2 PICSO, Mode,[10,13,hex B0+1," "] endif B3=0 endif Next B0 Serout2 PICSO, Mode,[10,13] case "v" Serout2 PICSO, Mode, ["Write EEPROM with address",10,13] B3=0 For B0 = 0 To 255 write B0,b0 Next B0 case "z" Serout2 PICSO, Mode, ["Write EEPROM with FF",10,13] B3=0 For B0 = 0 To 255 write B0,0 Next B0 end select GoTo mainloop timeout: Serout2 PICSO, Mode, ["Timeout",10,13] SOUND PORTC.5,[100,10,50,10] GoTo mainloop End help: serout2 PICSO, MODE, ["Type command:",10,13] serout2 PICSO, MODE, [" a on LED1",10,13] serout2 PICSO, MODE, [" b off LED1",10,13] serout2 PICSO, MODE, [" c on LED2",10,13] serout2 PICSO, MODE, [" d off LED2",10,13] serout2 PICSO, MODE, [" e off LED1,LED2",10,13] serout2 PICSO, MODE, [" f on LED1,LED2",10,13] serout2 PICSO, MODE, [" l leds show",10,13,10,13] serout2 PICSO, MODE, [" r read EEPROM",10,13] serout2 PICSO, MODE, [" v write EEPROM with address",10,13] serout2 PICSO, MODE, [" z write EEPROM with FF",10,13] Return leds_show: LEDS = 0 LEDS = 1 : Pause 500 LEDS = %010 : Pause 500 LEDS = %100 : Pause 500 LEDS = 0 : Pause 500 LEDS = %111 : Pause 500 LEDS = 0 : Pause 500 LEDS = %111 : Pause 500 LEDS = 0 : Pause 500 Return    

Un punto a tener en consideración del programa mostrado es que se trata de ordenar en secciones las diferentes funciones del mismo, lo cual le da "elegancia" y ayuda mucho a la hora de realizarle modificaciones.

Para poder utilizar la interfase serial debemos conectar un convertidor serial/usb a los puertos C.0 y C.1

Adicionalmente debemos hacer uso de un programa de comunicación serial en nuestro PC (uno muy utilizado es putty), sin embargo yo utilizo uno propio (MiniTerminal).

Podemos ver en la imágen el mensaje inicial del micro y la ejecución del comando r

El altavoz va conectado al pin C.5 mediante un condensador electrolítico de 10uF