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.