Curso XC8 - Capii

MODULO II

Memoria EEPROM interna del PIC.La EEPROM es una matriz de memoria permanente, separada de la RAM de datos y de la FLASH,se utiliza para almacenar variables que se desean conservar cuando el controlador se desconecte o quede sin energa. No est mapeada directamente dentro de los registros o en la memoria de programa, sino que se trata indirectamente a travs de registros especiales. La EEPROM se puede leer y escribir durante la ejecucin del programa.

Cuatro registros se utilizan para leer y para escribir los datos en la EEPROM.

EECON1 EECON2 EEDATA EEADR

En la EEPROM se permite la lectura y escritura de bytes. El registro EEDATA es el encargado de manejar los datos ya sea tanto cuando se leer o se escribe y el registro EEADR lleva a cabo el direccionamiento de la localizacin en la EEPROM. La EEPROM es muy resistente a los ciclos de escritura/borrado. Cuando se escribe un byte automticamente se sobreescribe el byte anterior. El tiempo de escritura se controla con un temporizador integrado en el chip, variar con la tensin y la temperatura as como de chip a chip. Como se coment el acceso a los datos se controla con dos registros: EECON1 y EECON2. stos son iguales que los del acceso de control a la memoria del programa (FLASH) y se utilizan deuna manera similar para los datos en la EEPROM.

El registro EECON1 es el registro de control para el acceso a memoria de datos y de programa. Controlando el bit, EEPGD, se determina si el acceso es a la memoria de programa o a la memoria de datos EEPROM. Cuando est borrado, las operaciones se hacen a la memoria EERPOM. Cuandoest activado, se dirige a la memoria FLASH.

Controlando el bit, CFGS se determina si el acceso es a los registros de configuracin o a la memoria del FLASH/EEPROM. Cuando est activado, las operaciones siguientes tienen acceso a los registros de configuracin. Cuando CFGS est borrado, el bit EEPGD selecciona la FLASH o la memoria EEPROM.

El bit WREN, cuando est activado, permitir una operacin de escritura. Por defecto este bit esta en cero.

El bit WRERR se activa por hardware y el bit WREN se borra cuando finaliza el timer interno y se completa la operacin de escritura.

Durante la operacin normal, el WRERR se lee como 1. Esto puede indicar que ha finalizado una operacin de escritura prematuramente cerca de un reset o una operacin de escritura finaliza incorrectamente!!!!!.

El bit de control WR inicia operaciones de escritura. Este bit no se puede borrar, slo est activar por software y se borra por hardware al terminar la operacin de escritura.

Programacin en XC8 Pagina 55 de 174

Se activa el flag de la interrupcin EEIF (PIR2) cuando la escritura se completa.Debe desactivarse por software!!!. Controlando los bits, RD y WR, comienzan las operaciones lectura y escritura, respectivamente. Estos bits se activa por software y se desactiva por hardware al terminar la operacin.

El bit RD no se puede activar al tener acceso a la memoria de programa (EEPGD=1). El registro EECON2 no es un registro fsico. Se utiliza exclusivamente en las secuencias de escribir y borrar en la memoria. La lectura EECON2 leer todo ceros.

Un ejemplo de manejo de la EEPROM interna.

/* ******************************************************************************* Nombre : main.c** Descripcion : Uso de la memoria EEPROM interna del PIC ** Autor : Firtec - www.firtec.com.ar** IDE : Microchip MPLAB-X ** Compilador : XC8** XTAL : 20MHZ ** ****************************************************************************/#include #define _XTAL_FREQ 20000000UL#pragma config OSC=HS,PWRT=ON,MCLRE=ON,LVP=OFF,WDT=OFF#include #include #include

#include "C:\ELECTRNICA\EJERCICIOS_XC8\lcd_xc8.c"#include "C:\ELECTRONICA\EJERCICIOS_XC8\lcd_xc8.h"

unsigned int direccion; // 1024 Vectores disponiblesunsigned char dato;char str_int[16];

__EEPROM_DATA(1,2,3,4,5,6,7,8); // Macro para colocar valores por defecto si // fuera necesario. (No es este el caso)

void main(void){ lcd_init(); lcd_gotoxy(4,1); lcd_putrs("EEPROM PIC\n"); direccion = 12; // La direccin sera cero (0) dato = 12; // El dato a guardar 25


eeprom_write (direccion, dato); // Escribe el dato en la direccin indicada Busy_eep (); // Espera que termine de escribir dato=0; sprintf(str_int,"Dato memoria:%03d ",eeprom_read(direccion)); lcd_puts(str_int); // Lee la direccin indicada while(1); // Bucle infinito}XC8 tiene dos funciones para el manejo de la EEPROM interna.

eeprom_write (unsigned char, unsigned int) Escribe un byte en una posicin de memoria. eeprom_read(unsigned int) Lee un byte desde una posicin de memoria.

Trabajo practicoSe pide que realice un programa para el control de acceso de una puerta que cumpla con las siguientes consignas:

La apertura de la puerta se har efectiva cuando se ingrese una clave numrica de cuatro cifras que ser comparada con un nmero almacenado enEEPROM.

Los nmeros de la clave sern generados con un potencimetro colocado en un canal A/D que irn desfilando en una pantalla de uno en uno mientras el usuario mueve el potencimetro, los nmeros mostrados solo pueden ir de 1 a 9.

Cada vez que un nmero que forma la clave de cuatro cifras se hace visible en la pantalla se lo valida con el botn de usuario que oficiar como botn deEnter.

Para indicar que la accin ha sido vlida utilizar un LED.


Funcionamiento de la USARTEn la actualidad y ante la ausencia de puertosRS232 en las computadoras, acostumbramos atrabajar con puentes USB-RS232 que solucionanmuchos o todos los problemas a la hora devincularnos con computadoras a travs del viejoprotocolo 232.Es interesante comentar que debido a ladesaparicin de estos puertos en arquitecturas de computadoras uno tiende a pensar que el puerto RS-232 est extinguido, nada mas alejado de la realidad ya que arquitecturas en 16 y 32 bits no soloincorporan uno de estos puestos sino varios.

El controlador no resuelve la capa fsica, es decir que para implementar las comunicaciones deberemos utilizar ya sea el clsico MAX232 o los modernos puentes USB-232.Esto es particularmente interesante porque con esta tecnologa podemos reutilizar los viejos programas en puertos COM que por cuestiones de licencias o complejidad son mas simples de implementar que las aplicaciones USB nativas.

El ejemplo que vamos a ver recibe los datos enviados desde el teclado de una PC y los re-transmite como un eco por el mismo puerto serial.

/* ******************************************************************************* Nombre : main.c** Descripcion : Uso de la memoria EEPROM interna del PIC ** Autor : Firtec - www.firtec.com.ar** IDE : Microchip MPLAB-X ** Compilador : XC8** XTAL : 20MHZ ** ****************************************************************************/#include #include #include

#include

#pragma config OSC=HS,PWRT=ON,MCLRE=OFF,LVP=OFF,WDT=OFF#define _XTAL_FREQ 20000000

#include "C:\ELECTRNICA\EJERCICIOS_XC8\USART.X\lcd_xc8.c"#include "C:\ELECTRONICA\EJERCICIOS_XC8\USART .X\lcd_xc8.h"volatile char Data, Kbhit=0;

Se discrimina el origen de la interrupcinvoid interrupt high_isr (void){if (PIR1bits.RCIF==1){ // Discrimina la interrupcinData=getcUSART(); // Se lee dato recibidoKbhit=1; // Indica que se ha recibido un datoPIR1bits.RCIF=0; // Borra bandera de interrupcin }}


Funcin Principalvoid main(void){unsigned char base =1;// Inicializa el USART y lo configura a 8N1, 9600 baudOpenUSART (USART_TX_INT_OFF & // TX sin interrupcin USART_RX_INT_ON & // RX con interrupcines USART_ASYNCH_MODE & // Modo asincrnico USART_EIGHT_BIT & // Modo alta velocidad USART_CONT_RX & // Recepcin continua USART_BRGH_HIGH,129); // 9600 baudios a 20Mhz

Para configurar los baudios podemos usar la herramienta Pic Baud Rate

RCONbits.IPEN = 0; // Deshabilitamos prioridadesINTCONbits.PEIE=1; // Habilitamos la interrupcion de perifericoslcd_init();//Delay1KTCYx(25);lcd_putrs("USART PIC18F4620"); // Cartel inicialINTCONbits.GIE=1; //Habilita interrupcin globalwhile(1){if(Kbhit !=0){ // Indica que hay nueos datos recibidosKbhit = 0; // Borra la marca de ISRif(Data!=0x00){ // El dato es distinto de 0?if(Data==0x08 & base > 0){ // Backspace & base son verdaderos?base--;lcd_gotoxy(base,2);lcd_putc(" ");}else{lcd_gotoxy(base,2);lcd_putc(Data);// Muestra el dato en pantallaputcUSART (Data);base++; } } } }}


Para visualizar los datos recibidos vamos a usar la aplicacin terminal.exe que se encuentra entre las herramientas del curso.

Se recibe el mismo dato enviado por la USART.


Trabajo practicoSe pide que escriba un programa que enve por el puerto serial RS-232 los datos obtenidos de un canal analgico donde se ha conectado un potencimetro.El resultado deber ser como el que se observa en la imagen.


El protocolo I2C.Diseado por Philips, este sistema de intercambio de informacin a travs de tan solo dos cables permite a circuitos integrados y mdulos OEM interactuar entre s a velocidades relativamente lentas. Emplea comunicacin serie, utilizando un conductor para manejar el reloj y otro para intercambiar datos. Este bus se basa en tres seales:

SDA (System Data) por la cual viajan los datos entre los dispositivos. SCL (System Clock) por la cual transitan los pulsos de reloj que sincronizan el sistema. GND (Masa) Interconectada entre todos los dispositivos "enganchados" al bus.

Las lneas SDA y SCL son del tipo drenador abierto, similares a las de colector abierto pero asociadas a un transistor de efecto de campo ( FET). Se deben poner en estado alto (conectar a la alimentacin por medio de resistores Pull-Up) para construir una estructura de bus tal que se permita conectar en paralelo mltiples entradas y salidas.

En el diagrama se observa la configuracin elctrica bsica del bus. Las dos lneas de comunicacindisponen de niveles lgicos altos cuando estn inactivas. Inicialmente el nmero de dispositivos quese puede conectar al bus es ilimitado, pero observe que que las lneas tienen una especificacin mxima de 400pF en lo que respecta a capacidad de carga. La mxima velocidad de transmisin de datos que se puede obtener es de aproximadamente 100Kbits por segundo.

Las definiciones o trminos utilizados en relacin con las funciones del bus I2C son las siguientes: Maestro (Master): Dispositivo que determina la temporizacin y la direccin del trfico de

datos en el bus. Es el nico que aplica los pulsos de reloj en la lnea SCL. Cuando se conectan varios dispositivos maestros a un mismo bus la configuracin obtenida se denomina "multi-maestro".

Esclavo (Slave): Cualquier dispositivo conectado al bus incapaz de generar pulsos de reloj.


Reciben seales de comando y de reloj proveniente del dispositivo maestro. Bus Desocupado (Bus Free): Estado en el cual ambas lneas (SDA y SCL) estn inactivas,

presentando un estado lgico alto. Unicamente en este momento es cuando un dispositivo maestro puede comenzar a hacer uso del bus.

Comienzo (Start): Sucede cuando un dispositivo maestro hace ocupacin del bus, generando esta condicin. La lnea de datos (SDA) toma un estado bajo mientras que la lneade reloj (SCL) permanece alta.

Parada (Stop): Un dispositivo maestro puede generar esta condicin dejando libre el bus. La lnea de datos toma un estado lgico alto mientras que la de reloj permanece tambin en ese estado.

Dato Vlido (Valid Data): Sucede cuando un dato presente en la lnea SDA es estable mientras la lnea SCL est a nivel lgico alto.

Formato de Datos (Data Format): La transmisin de datos a travs de este bus consta de 8 bits de datos ( 1 byte). A cada byte le sigue un noveno pulso de reloj durante el cual el dispositivo receptor del byte debe generar un pulso de reconocimiento, conocido como ACK(del ingls Acknowledge). Esto se logra situando la lnea de datos a un nivel lgico bajo mientras transcurre el noveno pulso de reloj.

Direccin (Address): Cada dispositivo diseado para funcionar en este bus dispone de su propia y nica direccin de acceso, que viene pre-establecida por el fabricante. Hay dispositivos que permiten establecer externamente parte de la direccin de acceso. Esto permite que una serie del mismo tipo de dispositivos se puedan conectar en un mismo bus sin problemas de identificacin. La direccin 00 es la denominada "de acceso general", por la cual responden todos los dispositivos conectados al bus.

Lectura/Escritura (Bit R/W): Cada dispositivo dispone de una direccin de 7 bits. El octavo bit (el menos significativo LSB) enviado durante la operacin de direccionamiento corresponde al bit que indica el tipo de operacin a realizar. Si este bit es alto el dispositivo maestro lee informacin proveniente de un dispositivo esclavo. En cambio, si este bit fuese bajo el dispositivo maestro escribe informacin en un dispositivo esclavo.

Funcionamiento del protocolo I2C.Como es lgico, para iniciar una comunicacin entre dispositivos conectados al bus I2C se debe respetar un protocolo. Tan pronto como el bus est libre, un dispositivo maestro puede ocuparlo generando una condicin de inicio. El primer byte transmitido despus de la condicin de inicio contiene los siete bits que componen la direccin del dispositivo de destino seleccionado y un octavo bit correspondiente a la operacin deseada (lectura o escritura). Si el dispositivo cuya direccin se apunt en los siete bits est presente en el bus ste responde enviando el pulso de reconocimiento ACK. Seguidamente puede comenzar el intercambio de informacin entre los dispositivos.

Cuando la seal R/W est previamente a nivel lgico bajo, el dispositivo maestro enva datos al dispositivo esclavo hasta que deja de recibir los pulsos de reconocimiento, o hasta que se hayan transmitido todos los datos.En el caso contrario, es decir cuando la seal R/W estaba a nivel lgico alto, el dispositivo maestro genera pulsos de reloj durante los cuales el dispositivo esclavo puede enviar datos. Luego de cada byte recibido el dispositivo maestro (que en este momento est recibiendo datos) genera un pulso dereconocimiento.


El dispositivo maestro puede dejar libre el bus generando una condicin de parada (Stop). Si se desea seguir transmitiendo, el dispositivo maestro puede generar otra condicin de inicio el lugar deuna condicin de parada. Esta nueva condicin de inicio se denomina "inicio repetitivo" y se puede emplear para direccionar un dispositivo esclavo diferente para alterar el estado del bit de lectura/escritura (R/W).

Memoria 24LC256.La memoria 24LC256 fabricada por Microchip tiene una capacidad de almacenamiento de 256Kbits(32 Kbytes). Sobre el mismo bus pueden conectarse hasta ocho memorias 24LC256, permitiendo alcanzar una capacidad de almacenamiento mxima de 256 Kbytes. Como en todas las memorias de la familia 24XXXXX, la direccin de identificacin o byte de control comienza con 1010. Seguidamente, tres bits llamados A2, A1 y A0 permiten seleccionar una de las ocho posibles memorias conectadas en el bus.

La memoria se compone de 512 pginas de 64 bytes cada una.

Cuando se requiere transferir volmenes considerables de informacin, la escritura de bytes resulta ser bastante ineficiente, pero la escritura por pginas mejora notablemente el rendimiento. Para


Memoria 24LC256 con XC8./* ***************************************************************************** File Name : 24LC256.c** Version : 1.0** Description : Control de una memoria 24LC256** Memoria de 32Kx8=256Kbit 64Bytes x Paginas** Target : 40PIN PIC18F4620** Compiler : Microchip XC8 ** IDE : Microchip MPLAB IDE v8.50** XTAL : 20MHZ ** ****************************************************/#include #include #include #include

#include "24LC256.h"

#pragma config OSC=HS,PWRT=ON,MCLRE=OFF,LVP=OFF,WDT=OFF

#define _XTAL_FREQ 20000000

#include "C:\ELECTRNICA\Programas PIC\2014\EJERCICIOS_XC8\24LC256.X\lcd_xc8.c"#include "C:\ELECTRNICA\Programas PIC\2014\EJERCICIOS_XC8\24LC256.X\lcd_xc8.h"

FUNCIN PRINCIPAL DEL PROGRAMAvoid main(void){unsigned char dir_hi =0, dir_low= 500;unsigned char Dato=54; // Dato cualquiera a guardar en Memoriachar str_int[14]; lcd_init(); OpenI2C(MASTER,SLEW_OFF); // Modo Master SSPADD = 49; // 100KHz para 20MHz Escribe_Byte(0xA0,dir_hi,dir_low,Dato); // Escribe la memoria

lcd_putrs(" Memoria 24C256"); lcd_gotoxy(1,2); sprintf(str_int,"Dato memoria:%02d ",Lee_Byte(0xA0,dir_hi,dir_low)); lcd_puts(str_int);while(1);}

Para el funcionamiento de este ejemplonecesitamos de dos archivos encargados delidiar con las funciones relativas a lamemoria I2C.

24LC256 Contiene las funciones decontrol de la memoria.

24LC256.H Contiene lasdeclaraciones de estas funciones.

Todo lo referente al propio bus I2C estacontenido en el archivo de cabecera i2c.hprovisto por el compilador.


El programa ejemplo solo escribe un byte en la posicin 500 y lo recupera para hacerlo visible en elLCD.

Trabajo practicoEscriba un cdigo utilizando I2C2 cambiando lo pines dedicados que complete 500 vectores de la memoria con los datos de un contador.


RTC DS1307 (Real Time Clock).Siguiendo con los dispositivos I2C el DS1307 de Dallas Semiconductor (Maxim) es una solucin muy interesante cuando necesitamos trabajar con eventos que requieren puntualidad y exactitud a lolargo del tiempo. Este pequeo circuito integrado es uno de los ms populares relojes RTC del mercado por su sencillez de uso y por su confiabilidad a largo plazo. Preparado para ofrecerte la hora hasta el ao 2100 con ajuste de aos bisiestos. /* ******************************************************************************* Nombre : main_1307.c** Descripcin : Control de un DS1307 & LCD 16x2 & INT ** Target : PIC18F4620** Compilador : XC8** IDE : MPLAB** XTAL : 20MHZ ** Autor : Firtec - www.firtec.com.ar** ****************************************************************************/#include #include #include #include

#include

#include "DS1307.h"



#include "C:\ELECTRNICA\Programas PIC\2014\EJERCICIOS_XC8\DS1307.X\lcd_xc8.c"#include "C:\ELECTRNICA\Programas PIC\2014\EJERCICIOS_XC8\DS1307.X\lcd_xc8.h"

void Ajustar_Dato(unsigned char dato); // Ajusta datos del DS1307void Un_Segundo(void); // Prototipo de la Interrupcin

volatile unsigned char bandera =0; // Variable usada en la Interrupcinunsigned char Unidad, Decena; // Variables del Programa#define chip 0xD0 // ID I2C de Chip para el DS1307

Rutina de Interrupcinvoid interrupt high_isr (void){ if(INTCON3bits.INT2IF) // Pregunta por bandera de INT2{ bandera =1; // Marca para actualizar el calendario INTCON3bits.INT2IF = 0; // Limpia bandera } }

FUNCIN PRINCIPAL DEL PROGRAMAvoid main(void){PORTB=0;TRISBbits.TRISB5=0;ADCON1=0x0F; // No hay canales analgicoslcd_init();

OpenI2C(MASTER,SLEW_OFF); // Master, 100KHz SSPADD = 49; // 100KHz para 20MHz


__delay_us(500); ByteWriteI2C(chip,0,128);

Se definen valores por defecto para el RelojByteWriteI2C(chip,1,0x59); // Ajusta MinutosByteWriteI2C(chip,2,0x23); // Ajusta HoraByteWriteI2C(chip,4,0x31); // Ajusta el DaByteWriteI2C(chip,5,0x12); // Ajusta MesByteWriteI2C(chip,6,0x14); // Ajusta AoByteWriteI2C(chip,0x07,0X90); // Registro de Control (1Hz pin 7)ByteWriteI2C(chip,0,0x50); // Ajusta Segundos

OpenRB2INT(PORTB_CHANGE_INT_ON & FALLING_EDGE_INT & PORTB_PULLUPS_ON);

RCONbits.IPEN=0; // No hay prioridades de interrupcionesINTCONbits.GIEH = 1; // Habilitador general de interrupciones activo WriteTimer0(100); lcd_putrs("Fecha ??|??|??"); lcd_gotoxy(1,2); lcd_putrs("Hora ??|??|?? ");

Bucle Infinitowhile(1){if(bandera){ // Bandera puesta en la interrupcinPORTBbits.RB5 = ~PORTBbits.RB5; // Cambia el estado del pin RB5lcd_gotoxy(7,1); // Coloca el cursor en la primera lneaAjustar_Dato(ByteReadI2C(chip,4)); // Lee el Dalcd_putrs("/"); // Barra separadora xx/xx/xxAjustar_Dato(ByteReadI2C(chip,5)); // Lee el Meslcd_putrs("/");lcd_putrs("20"); // Imprime 20 para leer 20xxAjustar_Dato(ByteReadI2C(chip,6)); // Lee el Aolcd_gotoxy(6,2); // Cambia la lnea en el LCDAjustar_Dato(ByteReadI2C(chip,2)); // Lee Horalcd_putrs(":"); // Puntos separadores xx:xx:xxAjustar_Dato(ByteReadI2C(chip,1)); // Lee Minutoslcd_putrs(":");Ajustar_Dato(ByteReadI2C(chip,0)); // Lee Segundosbandera =0; // Borra la bandera para el prximo segundo }Sleep(); // Espera en bajo consumo }}

Ajusta los datos del RTCvoid Ajustar_Dato(unsigned char dato){ char cadena[4]; Unidad = (dato & 0x0F); // Mascara y prepara dato para el LCD. Decena = ((dato/16) & 0x0F); // Intercambia nibles.sprintf(cadena,"%u", Decena);lcd_puts(cadena);sprintf(cadena,"%u", Unidad);lcd_puts(cadena);}


Registros Internos

Mapa de memoria


NOTA:El DS1307 solo manejas datos BCD por lo que es necesario ajustar los binarios.

Circuito de la AplicacinEl pin siete del DS1307 ha sido configurado a travs del registro de control para genera un pulso cada segundo, este pulso se conecta al pin 35 (INT2) del controlador generando una interrupcin cada segundo. Esta interrupcin cambia el estado de una bandera que se utiliza como indicativo quehay valores del reloj a actualizar en pantalla. Cada vez que se actualizan los datos en pantalla se cambia de estado el LED colocado en el pin 38 para tener una indicacin visual que la interrupcin esta funcionado al ritmo de un segundo.Han sido necesario varios archivos de cabecera para esta aplicacin.

plib/i2c.h Contiene las funciones para el manejo del bus I2C plib/portb.h Contiene las funciones para el manejo de las interrupciones INTx. DS1307.h Contiene las funciones para el control del RTC.

La lnea que configura la interrupcin por el pin 35 dice lo siguiente:

PORTB_CHANGE_INT_ON Mscara de interrupcin activada. FALLING_EDGE_INT Interrupcin por flanco de bajada. PORTB_PULLUPS_ON) Las resistencias del puerto B estn activadas.


PCF 8591.

Otro dispositivo I2C interesante es el PCF 8591, unconversor analgico digital y digital analgico de 8bits, que se conecta directamente al bus I2C delmicrocontrolador. En el trabajo propuestocontrolaremos el PCF8591 en sus dos modos, primerolo pondremos en modo conversor analgico digital leyendo la tensin de dos potencimetros asociados al canal 0 y 1, que estar conectado entre VCC y GND (5V y 0V).

En la segunda parte del programa cambiaremos el modo de funcionamiento del PCF8591, y lo utilizamos digital analgico (DAC) sacando por el pin de salida analgica un voltaje que se corresponde con el dato enviado, por ejemplo en ese modo si enviamos el nmero 128 por el pin analgico leemos 2,5V aproximados al 50% de Vdd.Las dos partes del programa ejemplo son controladas por un botn colocado en RA0 (pin2).

La direccin del dispositivo. Esta tiene 3 bits, con lo que podremos tener asta 8dispositivos iguales en el bus I2C, la direccin sera lasiguiente 1001xxxy donde los 4 bits de mayor pesoson fijos (0x90 es el identificador I2C para este chip), lostres siguientes bits son definidos por el programador yhacen referencia a su direccin en el bus, el bit de menor peso se utiliza para decir si el PCF8591 vaa estar en modo lectura o en su defecto modo escritura, siendo el 1 para la lectura y el 0 para la escritura. El mecanismo es casi el mismo que para el acceso de una memoria I2C solo que aqu leemos en la dir 0,1,2, 3 o 4 dependiendo del canal apuntado desde el PIC.

Otro punto importante que debemos conocer es la manera de configurar el byte de control del dispositivo, podemos elegir las entradas analgicas para la lectura con respecto a masa o en modos diferenciales, tambin podemos activar la salida analgica, en nuestro caso, utilizaremos una configuracin en la cual la salida analgica est deshabilitada, y las lecturas de las entradas analgicas estn tomadas respecto a masa. (Consultar la hoja de datos del dispositivo).

/* ****************************************************************************** Nombre : PCF8591.c** Descripcion : Midiendo en dos canales del ADC y funcionamiento del DAC** Target : PIC18F4620** Compilador : Microchip XC8** XTAL : 20MHZ ** ***************************************************************************** El pulsador colocado en RA0 controla el flujo del programa.*******************************************************************************/#include #include #include #include #pragma config OSC=HS,PWRT=ON,MCLRE=OFF,LVP=OFF,WDT=OFF

#include "C:\ELECTRNICA\Programas PIC\2014\EJERCICIOS_XC8\PCF8591.X\lcd_xc8.c"#include "C:\ELECTRNICA\Programas PIC\2014\EJERCICIOS_XC8\PCF8591.X\lcd_xc8.h"#define _XTAL_FREQ 20000000static bit bandera1 = 0; // Bandera para cambiar el canal.unsigned char bandera2 = 0;


char Str_float[5]; // Cadena para convertir el float en ASCII.float voltaje = 0.00; // Contenedor para guardar la medicin.

unsigned char Lee_Byte( unsigned char ByteControl, unsigned char Direccion){unsigned char Valor;IdleI2C(); // El modulo esta activo?StartI2C(); // Condicin de STARTwhile ( SSPCON2bits.SEN ); // Espera a que la condicin de inicio termineWriteI2C( ByteControl );WriteI2C( Direccion );

RestartI2C(); // Enva ReStart while ( SSPCON2bits.RSEN ); // Si se ha recibido el byte sigue WriteI2C( ByteControl | 0x01 ); // Cambia bit 0 de ByteControl para leer.

Valor=ReadI2C(); // Realiza lectura.NotAckI2C(); // Enva NACKwhile ( SSPCON2bits.ACKEN ); // Espera a que de ASK termineStopI2C(); // Condicin de STOPwhile ( SSPCON2bits.PEN ); // Espera fin de condicin de stop return ( Valor ); // Retorna Lectura

}FUNCIN PARA EL CONTROL DEL ADC

void ADC(void){ switch(bandera1){ // Se discrimina en cual canal se medir. case 0:{ // Si es "0" se lee en el canal cero. voltaje =Lee_Byte(0x90,0); // En voltaje se guarda el dato desde el A/D. __delay_ms(10); bandera1 =1; // Se cambia bandera para el siguiente canal. break; }case 1:{ voltaje =Lee_Byte(0x90,1); __delay_ms(10); bandera1 =0; break; } } voltaje = (voltaje*5.0)/256; // Se escala el valor para medir entre 0 y 5V sprintf(Str_float,"%1.2f ",voltaje); // El float es convertido a ASCII if(bandera1 ==0) // Si bandera es cero se coloca el cursor en el lugar lcd_gotoxy(4,2); // indicado junto al cartel que le corresponde. else lcd_gotoxy(13,2); // Si bandera es uno se coloca el cursor en el lugar lcd_puts(Str_float); // indicado junto al cartel que le corresponde.}

FUNCIN VERIFICA LA PRESENCIA DEL PCF8591void check_PCF8591(unsigned short dir){ StartI2C(); // Condicin de inicio en el bus. if (WriteI2C(dir)){ // Escribe la direccin del chip en el bus. lcd_gotoxy(2,2); // Si retorna "1" no hay sensor en el bus.lcd_putrs("PCF8591 ERROR!!"); // Aviso de que no hay sensor en el BUS.while(1); // Programa termina. } else { lcd_gotoxy(3,1); lcd_putrs("Chip PCF8591"); // Cartel incial para indicar la presencia } // del chip en el bus I2C. StopI2C();}


FUNCIN PRINCIPAL DEL PROGRAMAvoid main() {TRISA=0X01; // Configura el pin 2 como entrada digital ADCON1 = 0X0F; // Configura los pines del PORT A como I/O Digitales

OpenI2C(MASTER,SLEW_OFF); // Modo Master. SSPADD = 49; // 100KHz para 20MHz. lcd_init(); // Configura el LCD a valores por defecto. check_PCF8591(0x90); // Verifica la presencia del chip en el BUS.

While(1){ // El boton en RA0 es el encargado de cambiar al DAC o al ADC if(PORTAbits.RA0!=1 && bandera2== 1){ while(!PORTAbits.RA0); // Espera a que el botn se suelte lcd_gotoxy(1,2); lcd_putrs(" "); // Limpia la lnea inferior para el ADC bandera2=0; // Coloca la bandera para que el ADC sea el modo por defecto } if(PORTAbits.RA0!=1 && bandera2== 0){ // Pasa al modo DAC while(!PORTAbits.RA0); // Espera a que el botn se suelte bandera2++; lcd_gotoxy(1,2); lcd_putrs(" Conversor DAC "); StartI2C(); WriteI2C(0x90); __delay_ms(2); WriteI2C(0x40); __delay_ms(2); WriteI2C(128); // Saca por el pin analgico 2.5V aprox. (256/2=128) StopI2C(); // Condicin de STOP while ( SSPCON2bits.PEN ); // Espera que termine la condicin de STOP } if(bandera2==0){ // Si bandera es 0 se activa el modo por defecto (ADC) lcd_gotoxy(1,2); // Coloca los carteles para los canales analgicos lcd_putrs("A0:"); lcd_gotoxy(10,2); lcd_putrs("A1:"); ADC(); // LLama a la funcin del conversor analgico } }}


Sensor de temperatura I2C TC4A3.El chip TC74 es un sensor de temperaturaserie accesible a travs del bus I2C fabricadopor Microchip Technology que mide con unaresolucin de 1C. La temperatura est disponible en un byte quees almacenado en un registro interno.

El dato de temperatura es almacenado enformato binario con complemento a 2 y el bitms significativo es el bit de signo, que seestablece en 1 para temperaturas negativas porlo tanto, la temperatura mxima positiva es de+ 127 C (0111 1111). Tambin existe otroregistro de configuracin (RWCR) que seutiliza para poner el dispositivo en bajoconsumo (5A), en este modo se detiene elconvertidor A / D.

/* ******************************************************************************* Nombre : TC74A3.c** Descripcion : Sensor de Microchip I2C de 8 bits. (-40 a +125 grados)** Target : PIC18F4620** Compilador : Microchip XC8** XTAL : 20MHZ ** ****************************************************************************/#include #include #include #include #pragma config OSC=HS,PWRT=ON,MCLRE=OFF,LVP=OFF,WDT=OFF

#include "C:\ELECTRNICA\Programas PIC\2014\EJERCICIOS_XC8\TC74.X\lcd_xc8.c"#include "C:\ELECTRNICA\Programas PIC\2014\EJERCICIOS_XC8\TC74.X\lcd_xc8.h"

#define _XTAL_FREQ 20000000void delay(unsigned int t){ while(--t) __delay_ms(1);} unsigned short num=0; const int TC74A3 = 0x96; // Direccin I2C del sensor

FUNCIN PARA VERIFICAR EL SENSORvoid check_sensor(unsigned short dir){ StartI2C(); if (WriteI2C(dir)){ lcd_gotoxy(1,2);lcd_putrs("Sensor ERROR!!"); // Aviso de que no hay sensor en el BUS.while(1); } else { lcd_gotoxy(2,1); lcd_putrs("Sensor TC74A3"); // Cartel inicial. } StopI2C();


}FUNCIN PARA LEER LA TEMPERTAURA

unsigned short Leer_Temp(){unsigned short dato; IdleI2C(); // Pregunta si el bus est libre. StartI2C(); // Pone la condicin de inicio. IdleI2C(); // Espera que termine. WriteI2C(TC74A3); // Direcciona el sensor while(SSPCON2bits.ACKSTAT); // Espera el ACK IdleI2C(); // Espera por el bus libre. WriteI2C(0x00); // Escribe la dir 0 (registro de la temp)while(SSPCON2bits.ACKSTAT); // Espera el ACK IdleI2C(); // Espera a que el bus est libre RestartI2C(); // Re-inicio del bus IdleI2C(); // Espera que termine WriteI2C(TC74A3+1); // Enva rden de lectura en la dir. 0 while(SSPCON2bits.ACKSTAT); // Espera por ACK dato = ReadI2C(); // Lee el registro y lo guarda en dato IdleI2C(); // Espera que termine NotAckI2C(); // No hay ACK IdleI2C(); // Espera que termine StopI2C(); // Condicin de fin de transaccin. return dato; // Retorna la temperatura}

FUNCION PRINCIPAL DEL PROGRAMAvoid main() { char temperatura[] = "000"; OpenI2C(MASTER,SLEW_OFF); // Modo Master SSPADD = 49; // 100KHz para 20MHz lcd_init(); // Configura el LCD a valores por defecto. lcd_gotoxy(1,2); lcd_putrs("Grados:"); // Cartel inicial II. check_sensor(TC74A3); // Verifica la presencia del sensor en el BUS. while(1) { num = Leer_Temp(); // Lee la temperatura desde el sensor. if (num > 127) { // Verifica si la temperatura es negativa. num = ~num +1; // Ajusta la temperatura si es negativa sprintf(temperatura,"-%d ",num); // Completa el string para el LCD } else{ sprintf(temperatura,"+%d ",num); // Temperatura positiva. } lcd_gotoxy(8,2); lcd_puts(temperatura); // Muestra la temperatura. delay(500); } }


PCF8574. Es un expansor de puertos compatible con la mayora demicrocontroladores, permite una comunicacin bidireccional, necesitandosolo dos lneas a travs del bus I2C.

Caractersticas del mdulo Tensin de alimentacin de 2.5 a 6 V CC. Bajo consumo en standby (mximo 10 microamperios). Conversin de datos de I2C a paralelo y viceversa. Un Pin de interrupcin de salida a drenador abierto (necesita resistencia pul-up). Un puerto cuasi-bidireccional de ocho bits (necesitan resistencias pul-up). Tres pines disponible para configurar por hardware la direccin del dispositivo. Disponible en encapsulados DIP y SMD.

Este mdulo dispone de dos modelos (PCF8574 y PCF8574A) cuya nica diferencia es su direccin.

Los primeros cuatro bits vienen configurados de fbrica y los tres ltimos son configurables por hardware, por lo que podemos tener 8 mdulos conectados al mismo bus I2C (y si combinamos ambas versiones hasta 16).

Una trama de datos en una transmisin consta de:

Un bit de inicio de la comunicacin. Un byte formado por siete bits que identifican la direccin del esclavo + un bit para indicar

si se va hacer una lectura (R/W=1) o escritura (R/W=0) en el mdulo. Los datos en s (de transmisin o recepcin); el nmero de bytes de datos a transmitir o

recibir entre el comienzo de la comunicacin y la condicin de fin de transmisin (bit de parada) no est limitada.

Un ACK de reconocimiento. A cada byte transmitido le sigue un bit de reconocimiento,


cuando el esclavo recibe un byte este enva el ACK para indicarle al maestro que lo ha recibido correctamente, cuando la peticin del maestro al esclavo es de lectura este debe de enviar un ACK al esclavo para indicarle que ha recibido el byte correctamente.

Un bit de parada. La condicin de parada (P) ocurre cuando la lnea SDA cambia de nivel alto a bajo mientras la lnea de reloj se encuentra a nivel alto y es controlada por el dispositivo maestro (en nuestro caso el microcontrolador).

/******************************************************************************* * File: PCF8574.c * Author: Firtec * www.firtec.com.ar - [email protected] * Created on 24 de mayo de 2014 ******************************************************/

#include #include #include #include

#include "PCF8574.h"



#define chip 0x40 // Valor de Chip para el PCF8574

FUNCIN PRINCIPAL DEL PROGRAMAvoid main(void){ unsigned char byte =0;PORTB=0;TRISCbits.TRISC4=1;TRISB = 0;ADCON1=0x0F; // No hay canales analgicosOpenI2C(MASTER,SLEW_OFF); // Master, 100KHzSSPADD = 49;

(Fos/Fck*4)-1 donde Fos 20Mhz (20000Kc) y Fck 100Kz (20000Kc/400kc)-1 = 49 para 20Mhz y Ck I2c 100K

BUCLE INFINITOwhile(1){byte = ByteReadI2C(chip); // Lee el puerto del PCF8574byte = ((byte >> 4) & 0x0f) | ((byte

Protocolo 1-wire.Es un protocolo de comunicaciones en serie diseado por Dallas. Est basado en un bus, un maestroy varios esclavos en una sola lnea de datos en la que tambin se alimentan. Por supuesto, necesita una referencia a tierra comn a todos los dispositivos. El bus tiene un funcionamiento bastante particular, se mantiene la seal de datos a 0 voltios durante 480 microsegundos. Se reinician todos los dispositivos conectados al bus (les retira la alimentacin). Los dispositivos reiniciados indican su presencia manteniendo la seal de datos a 0 voltios durante 60 microsegundos. En la actualidad los microcontroladores PIC no tienen un puerto nativo para este protocolo de comunicaciones.

Seales del Bus.


Envo y recepcin de datos por 1-Wire.Para enviar un bit a 1 el maestro se lleva a 0 voltios la lnea de datos durante 1-15 microsegundos. Para enviar un bit a 0 el maestro se lleva a 0 voltios la lnea de datos durante 60 microsegundos.Los dispositivos esclavos leen el bit aproximadamente a los 30 microsegundos despus del flanco de bajada de cada bit.Cuando el maestro lee los datos del dispositivo esclavo el pone 0 voltios durante 1-15 microsegundos en la lnea de datos y a partir de ese momento el esclavo no hace nada (la seal pasa a vale 5 voltios) si quiere mandar un 1 lgico o mantiene la seal en 0 voltios hasta los 60 microsegundos si quiere mandar un 0 lgico.Los datos se envan o reciben en grupos de 8 bits. Para iniciar una comunicacin se reinicia el bus. El protocolo puede incluir deteccin de errores transmitiendo cdigos de deteccin de errores (CRC).Como en el bus puede haber muchos dispositivos el protocolo incluye el direccionamiento de los mismos empleando un cdigo nico de 64 bits de los cuales el byte ms significativo indica el tipo de dispositivo, y el ltimo es un cdigo de deteccin de errores (CRC) de 8 bits.Los comandos que pueden interpretar los dispositivos esclavos dependern de estos.Para encontrar los dispositivos presentes en el bus el maestro puede enviar un comando de enumeracin que respondern todos los dispositivos.

Sensor de temperatura 1-wire DS18B20.Veamos un ejemplo con un sensor de temperatura muy interesante que muestra el funcionamiento de este protocolo de comunicaciones.

/* ******************************************************************************* File Name : DS1820.c** Version : 1.0** Description : Dallas/Maxim Sensores Temp. DS1820, DS18S20 o DS18B20 ** conectado al pin 6 (RA4) (Sin Rom Code).** Author : www.firtec.com.ar** Target : 40PIN PIC18F4620** Compiler : Microchip XC8** IDE : Microchip MPLAB-X** XTAL : 20MHZ ** ****************************************************************************/

#include #include #include #pragma config OSC=HS,PWRT=ON,MCLRE=OFF,LVP=OFF,WDT=OFF#define _XTAL_FREQ 20000000#include "C:\ELECTRNICA\DS1820.X\lcd_xc8.c"#include "C:\ELECTRNICA\DS1820.X\lcd_xc8.h"

#include "1wire.h"

FUNCIN PRINCIPALvoid main(void){

float Grados; // Variable para contener el dato temperaturachar TempStr[5];lcd_init();lcd_gotoxy(2,1);lcd_putrs("SENSOR DS18B20"); // Cartel iniciallcd_gotoxy(1,2);lcd_putrs("Temperatura: ");


while(1){ Medir_Temperatura(); // Inicia la conversion Grados = Leer_DS18B20(); // DS18B20 12 BITS //Grados = Leer_DS18S20(); // DS1820 10 BITS sprintf(TempStr,"%2.1f", Grados); lcd_gotoxy(13,2); // Coloca el cursor en posicin lcd_puts(TempStr); }}

Como se coment anteriormente, estos microcontroladores no tienen puerto nativo para esta comunicacin por lo que es necesaria construirlo por software.El archivo que contiene todo el saber de esta comunicacin es 1wire.c donde encontramos funciones para leer temperatura tanto con el DS18B20 o con el veterano DS1820 a 10 bits de resolucin.El contenido del archivo 1wire.c contiene la librera para el manejo de este dispositivo en XC8.

/////////////////////////////////////////////////////////////////////////// Driver para el manejo de las comunicaciones entre un pic y un //////// dispositivo Dallas/Maxim 1-wire //// //// Los tiempos han sido calculados para un cristal de 20Mhz //////// El pin de datos se ha dispuesto por RA4 //////// WEB: www.firtec.com.ar //////// mail: [email protected] ///////////////////////////////////////////////////////////////////////////// NOTA: No olvidar la resistencia de 4,7K entre el pin RA4 y Vdd. ///////////////////////////////////////////////////////////////////////


#include #include #include #include "1wire.h"#ifndef _XTAL_FREQ#define _XTAL_FREQ 20000000#endif

#define Pin_BAJO PORTAbits.RA4=0; TRISA = 0b00000000;#define Pin_Entrada TRISA = 0b00010001;#define Pin_Lee PORTAbits.RA4;

/***************************** Reset_1Wire *****************************//*Esta funcin inicializa el buz 1wire *//*Argumentos: ninguno *//*Retorna: 0 si todo OK *//***********************************************************************/int Reset_1wire(void){

int result=1;Pin_BAJO

__delay_us(500); Pin_Entrada; __delay_us(60);

result = (int)Pin_Lee; __delay_us(240);

return (result);}/*********************** Escribir_Bit() ******************************//* Esta funcin escribe un bit en el sensor. *//* Argumentos: Un bit (El bit a escribir en el bus 1-wire) *//* Retorna: nada *//*********************************************************************/void Escribir_Bit(int _bit){

if (_bit) {

Pin_BAJO;__delay_us(6);Pin_Entrada;__delay_us(60);

}else{

Pin_BAJO __delay_us(60);

Pin_Entrada;} __delay_us(10);

}

/*********************** Leer_Bit() ******************************//* Esta funcin lee un bit desde el sensor. *//* Argumentos: ninguno *//* Retorna: El estado del bit en el pin DQ del sensor *//***********************************************************************/int Leer_Bit(void){

int result=0;Pin_BAJO;

__delay_us(6);


Pin_Entrada; __delay_us(6);

result = (int)Pin_Lee; __delay_us(60); return (result); }

/*********************** Escribir_Byte() ******************************//* Esta funcin escribe un byte en el sensor. *//* Argumentos: byte (El byte a escribir en el bus 1-wire) *//* Retorna: nada *//***********************************************************************/void Escribir_Byte(int data){

int loop;for (loop = 0; loop < 8; loop++){

Escribir_Bit(data & 0x01);data >>= 1;

}}

/*********************** leer_Byte() **********************************//* Esta funcin lee 8 bits desde el sensor 1-wire. *//* Argumentos: ninguno *//* Retorna: 8 bits (1-byte) los datos desde el sensor *//***********************************************************************/int Leer_Byte(void){

int loop, result=0;for (loop = 0; loop < 8; loop++){

result >>= 1;if (Leer_Bit())result |= 0x80;

}return result;

}

/*********************** Medir_Temperatura() ***************************//* Esta funcin inicia la conversin para medir la temperatura. *//* Argumentos: ninguno *//* Retorna: nada *//***********************************************************************/void Medir_Temperatura(void){

Reset_1wire(); Escribir_Byte(0xCC);Escribir_Byte(0x44);

while(Leer_Bit() == 0); Reset_1wire();

}

/*********************** Leer_DS18S20() ***************************//* Esta funcin lee la temperatura de un sensor DS1820. *//* Argumentos: ninguno *//* Retorna: La temperatura con signo *//******************************************************************/float Leer_DS18S20(void){

unsigned char get[10];


int k, temp;float ftemp;Escribir_Byte(0xCC);Escribir_Byte(0xBE);for (k=0; k 0x80)

temp = temp * -1;ftemp = temp;

return (ftemp/2);}/*********************** Leer_DS18B20() ***************************//* Esta funcin lee la temperatura de un sensor DS18B20. *//* Argumentos: ninguno *//* Retorna: La temperatura con signo *//******************************************************************/float Leer_DS18B20(void){ unsigned char temp1, temp2; int temp3; float result; Reset_1wire(); Escribir_Byte(0xCC); Escribir_Byte(0x44); Reset_1wire(); Escribir_Byte(0xCC); Escribir_Byte(0xBE); temp1 = Leer_Byte(); temp2 = Leer_Byte(); temp3 = (( int) (((( int )( temp2 ))

En ocasiones puede ser necesario necesitar leer el cdigo ROM de los sensores.En el ejemplo siguiente vemos la forma de leer este cdigo y mostrarlo en un LCD. Este nmero de 64 bits puede sernos til para realizar una red de sensores e interrogarlos por su nmero ROM.

Podramos tener varios sensores y tratarlos por su nmero de RED. A continuacin el ejemplo para leer el nmero de serie de casa sensor.

/* ******************************************************************************* File Name : RomCode.c** Author : www.firtec.com.ar** Target : 40PIN PIC18F4620** Compiler : Microchip XC8** IDE : Microchip MPLAB-X** XTAL : 20MHZ ** *****************************************************/#include #include #include #include

#include "1wire.h"

#include "RomCode.h"



#include "C:\ELECTRNICA\Programas PIC\DS1820_ROM.X\lcd_xc8.c"#include "C:\ELECTRNICA\Programas PIC\DS1820_ROM.X\lcd_xc8.h"

unsigned char ROM_DATA [8]; // Array donde se guardar el codigo ROMunsigned char puntero_array = 0;

void main (void){unsigned char b; // Variable de uso multiplechar a[2];lcd_init(); // Inicializa el LCDlcd_gotoxy(1,1);lcd_putrs("CODIGO ROM 64bit"); // Cartel inicial

while(OWReset()){ // Si no es cero SENSOR ERROR


lcd_gotoxy(1,2);lcd_putrs(" SENSOR ERROR!!");}lcd_gotoxy(1,2);lcd_putrs(" "); // Limpia pantallaLEER_ROM(); // Se leen los 64 bit's del sensorlcd_gotoxy(1,2);for(puntero_array=0;puntero_array

Documents

Curso XC8 - Capii