le tu inquietud y es fcil de trabajar con este RTC.

El emplea el bus I2C para comunicarse con un dispositivo "maestro", que en este caso es el microcontrolador. el bus I2C usa dos lneas, una de reloj: SCL y una de datos: SDA. La comunicacin siempre la inicia un dispositivo con algo de inteligencia, en este caso el micro, y funciona como un "maestro". El perifrico que quieres controlar acta como "esclavo" y responde al llamado del maestro. Las lneas SCL es controlada por el micro pues el manda los pulsos de sincrona, y el flujo de informacion en la lna SDA es determinado por el dispositivo que solicita o envia informacion. Este tipo de bus no hace uso de un "chip Select" puesto que el primer byte que uno transmite es la direccin del perifrico a controlar. Se transmiten octetos o grupo de 8 bits acompaados de la seal de reloj, que tambien son 8 pulsos mas uno de ACK; en total seran 9 pulsos de reloj para 8 bits de data mas uno de ACK. Se transfiere el bit mas significativo primero. La comunicacin inicia con un BIT de START, que es un cambio de nivel en las lineas SCL y SDA; su estado inicial es HI (ambas) y la primera lnea que va a LO es SDA, seguida de SCL. Seguido de esto, se transmite el primer byte de forma sincronica con los pulsos de reloj, donde hay dos condiciones: de CAMBIO PERMITIDO y de DATO VALIDO, establecidas por el cambio de la lna SCL (clock). Cuando SCL es HI (1) el valor de la lnea SDA (bit) ser un bit vlido, es decir, que si SDA = 0, ese bit tendr un valor de 0. Cuando SCL es LO (0), el valor de SDA puede cambiar, solo en ese momento. De esta manera, a partir del bit de START, se deben generar 8 pulsos de reloj para transmitir el primer byte, y generar un 9 pulso de reloj para que el micro revise el estado de la lnea SDA, es decir, debe mirar si hay un ACK o no por parte de un dispositivo esclavo; en este noveno pulso el micro debe cambiar el estado del pin SDA de salida a entrada para chequear si alguien en el bus recibi el byte de manera correcta. bit START 1 -----------------\ / \ / \ / 0 ------------1 -----------\ / \ / 0 --------------------BIT_VALIDO CAMBIO

SCL

SDA

El primer byte que se transmite es la direccin del dispositivo esclavo. Para el RTC, el DS1307, este byte es 0xD0 (0b1101000x). El ltimo bit especifca que operacin se quiere hacer, Escritura o Lectura (Read = 1, /Write = 0). El segundo byte que se transmite es la direccin interna del dispositivo, que hace referencia a algn registro o a un mapa de memoria (si fuera una SE2PROM). Dependiendo del dispositivo, se transmiten tantas "palabras" o bytes de direccin interna como lo requiera este (algunas SE2PROM usan dos bytes - hi_addr y lo_addr -). PAra el RTC, basta un solo byte, que indica el registro al que se tendr acceso (p.9, DS1307 64 x 8, Serial, I2C Real-Time Clock, DallasMAxim).

Despes de enviar la direccin interna del dispositivo, el micro debe seguir transmitiendo informacin o recibir la data que debe esperar del dispositivo I2C (la hora o fecha para el RTC). Para liberar el bus, el micro debe restablecer las lneas SCL y SDA a nivel HI(1) con un bit de STOP. Dicha condicin se cumple despus de revisar el ltimo bit ACK; SCL debe llegar primero a nivel HI, y se hace vlido cuando SDA hace la transicin de LO a HI.

La secuencia de comunicacion con cualquier dispositivo I2C sera as: ESCRITURA BIT_START + DEVICE_ADDRESS(ultimo bit R/W = 0) bitACK WORD_ADDRESS_HI + bitACK WORD_ADDRESS_LO + bitACK (si aplica) DATA_1 + bitACK DATA_2 + bitACK .... DATA_n + bitACK BIT_STOP LECTURA BIT_START + DEVICE_ADDRESS(ultimo bit R/W = 0) WRITE bitACK WORD_ADDRESS_HI + bitACK WORD_ADDRESS_LO + bitACK (si aplica) BIT_START + DEVICE_ADDRESS(ultimo bit R/W = 1) READ bitACK(de disp. esclavo) -- aqui el micro debe leer a travs de la lnea SDA DATA_1_rx + bitACK=0 (generado por micro) DATA_2_rx + bitACK=0 (generado por micro) ... DATA_n_rx + bitNACK=1 (generado por micro) BIT_STOP

Las dos lneas, SDA y SCL, deben estar conectadas con resistencias de pull-up, es decir, conectadas al mismo voltaje de alimentacin del micro (para el JK3 sera 5V, el mismo que usara el RTC). Espero haya sido de ayuda este resumen. Recomiendo que busques la nota de aplicacion AN2509 y AN1820 de freescale, y este link de Phillips (NXP) que es el autor de este tipo de conexin, buscalo por google como "I2C specification" ( no me dejan poner links, que chafa ). Mucha suerte y cualquier inquietud a jedi_hyoga@hotmail.com

Ejemplo comunicacin serie I2C entre un PIC y la memoria EEPROM 24LC256A

Detalles
ltima actualizacin el Mircoles, 05 Septiembre 2012 18:01 Escrito por Biblioman

En este ejemplo voy a mostrar lo fcil que es leer y grabar datos en una memoria EEPROM Externa desde un PIC utilizando el lenguaje C y el compilador CCS, concretamente la memoria a utilizar ser la 24LC256A fabricada por Microchip. Para empezar vamos a describir algunas caractersticas del nuevo componente que vamos a utilizar y cuyo patillaje tenis en la figura de abajo.

Esta es una memoria que tiene un tamao de 32 Kbytes, su estructura est organizada en palabras de 1 byte (8 bits) de longitud, por lo tanto dispondremos en total de 32x8=256 kbits para almacenar informacin. La caracterstica principal de esta memoria es que implementa el interfaz I2C para su comunicacin serie con otros dispositivos electrnicos. El protocolo I2C fue desarrollado por la empresa Philips, ahora llamada NXP, hace ya bastante tiempo impulsado por la necesidad en el mercado de establecer una interfaz que comunicara entre si varios dispositivos electrnicos y que ahorrara el mximo numero de patillas en los componentes, hay mucha informacin en la red sobre este protocolo por lo que solo voy ha citar a modo de resumen las caractersticas que considero mas relevantes acerca de este protocolo. Al final del artculo pondr los enlaces a varias fuentes para el que quiera profundizar en este protocolo de comunicacin.

Caractersticas bsicas del protocolo I2C

El bus de comunicacin utiliza dos cables. Uno para transmitir los datos (SDA) y otro para la seal de reloj (SCL). Ambas lneas se tienen que conectar a la alimentacin (Vcc) a travs de resistencias Pull-UP (en el esquema del ejemplo se muestra el conexionado). Adems la masa de los componentes que se interconexionan entre si debe de ser comn. El protocolo de comunicacin es del tipo Maestro-Esclavo, aunque el protocolo permite que haya varios maestros, lo normal es que solo haya uno, el dispositivo que hace de maestro es el que gobierna la comunicacin y es el que controla la seal de reloj (SCL). Los dispositivos que hacen de esclavos responden a las peticiones del maestro. Cada dispositivo conectado al bus se identifica por una nica direccin, el protocolo admite utilizar 7 10 bits para el direccionamiento, aunque lo normal es que sean siete.

Los cuatro primeros bits estn asignados al fabricante del dispositivo y los tres ltimos son configurables por hardware. En el caso de la memoria que estamos viendo el cdigo del fabricante es: 1010, como tenemos tres bits configurables

podremos conectar entre si hasta ocho memorias 24LC256 juntas. La trama de un mensaje simple donde el dispositivo que hace de maestro enva datos para ser escritos en la EEPROM sera el siguiente:

Se enva el bit de inicio (S) Se enva la direccin del esclavo, en este caso la memoria EEPROM Se enva un bit ms junto con la direccin del esclavo (R/W) para indicar que lo que se quiere es leer o escribir. Si este bit es cero el proceso ser de escritura. Despus el maestro manda un pulso de la seal de reloj, durante el cual el esclavo debe contestar con un ACK (seal de reconocimiento), si el maestro no recibe esta seal interrumpe la comunicacin. Despus se envan los bytes de direccin necesarios para identificar el registro de la EEPROM donde queremos realizar el proceso de escritura. Mandamos el dato que se almacenar en la EEPROM Y por ltimo se manda el bit de parada para finalizar la comunicacin.

Como se gestiona todo esto en C y con el compilador CCS?

CCS dispone de libreras especficas para gestionar la comunicacin I2C de determinados componentes, entre ellos algunas memorias EEPROM. Basta con incluir la librera correspondiente por medio de la directiva #include y utilizar sin ms las funciones de la librera. Pero si el componente que queremos utilizar no dispone del driver pertinente en CCS, tenemos otra opcin, que es desarrollar nuestro propio driver, para ello disponemos como ayuda de una directiva homologa a #use rs232 (options), se trata de #use i2c (options). Al incluir esta directiva el compilador nos permite utilizar las siguientes funciones para controlar la comunicacin serie I2C entre varios dispositivos: i2c_isr_state() i2c_poll() i2c_read() i2c_slaveaddr() i2c_start() i2c_stop() i2c_write()

Adems los pics que soportan este tipo de comunicacin disponen de modulos y registros especficos para facilitar la comunicacin I2C por hardware, lo mismo que tenamos con la comunicacin serie RS232. Como veis esto da pie a muchos ejemplos, ya que hay bastantes dispositivos (Relojes en tiempo real, convertidores A/D, expansin de puertos de E/S, LCDs, etc) que implementan esta interfaz, tambin tenemos la posibilidad de comunicar varios PICs entre si, uno haciendo de maestro y los otros de esclavos. Pero vamos poco a poco y para empezar vamos hacer el ejemplo del contador "su turno" que ya tenamos hecho, pero en vez de guardar los datos en la memoria EEPROM interna del PIC lo vamos hacer en la memoria externa 24LC256. El esquema modificado en Proteus ser el siguiente:

Como veis en la imagen de arriba el circuito es el mismo que habamos hecho para el ejemplo del uso de la memoria EEPROM interna del PIC incluyendo la memoria 24LC256. Las patillas A0, A1 y A2 de la memoria estn a masa, por lo que la direccin fsica del componente en la red ser: 1010000. Los pines SDA y SCL son los que se conectan al bus IC2, a travs de las resistencias pullup. Puede que alguien se pregunte que valor hay que poner a estas resistencias (pullup) en un circuito real, pues la verdad es que no existe un valor ideal para todos los casos, depender de factores como la velocidad a la que hagamos trabajar el bus (100-400 kbps) y de la carga capacitiva que tenga el circuito (max. 400 pF), un valor que se aconseja como estndar es de 4k7. Pero para que el circuito simule bien en Proteus se deben poner las genricas pullup. El pin 7 de la memoria (WP) es para proteger no los datos guardados en la memoria, si est a masa los datos no estn protegidos y se puede escribir o sobreescribir los datos ya guardados. Si est a uno (Vcc), no es posible escribir en la EEPROM. Otro componente de Proteus incluido en el circuito es el I2C Debugger con el cual podemos ver la trama de datos en tiempo de ejecucin. En la figura de abajo se detallan los bits de la trama en un proceso de escritura en la EEPROM.

El cdigo fuente del Microcontrolador es el siguiente: 01./*----------------------------------------------------------------------*\ 02.|Ejemplo comunicacin serie I2C entre un PIC y la memoria EEPROM 24LC256A | 03.|autor: biblioman | 04.|www.aquihayapuntes.com | 05.\*-----------------------------------------------------------------------*/ 06. 07.#include <16F877.h> 08.//Configuracin de los fusibles. 09.#FUSES NOWDT, XT, NOPUT, NOPROTECT, NOBROWNOUT, NOLVP, NOCPD, NOWRT, NODEBUG 10.#use delay(clock=4000000) //Frecuencia de reloj 4MHz 11.#byte puerto_D = 0x08 // Identificador para el puerto C. 12.#include "24256.c" //Incluimos librera 24256 13. 14.#int_EXT 15. 16.void EXT_isr( void ) 17.{ 18. 19.if ((read_ext_eeprom(0)==0x99)||(read_ext_eeprom(0)==0xFF)) 20.{ 21.write_ext_eeprom(0,0); 22.puerto_D=read_ext_eeprom(0); 23.}

24.else if ((read_ext_eeprom(0) & 0x0F)<0x09) 25.{ 26.write_ext_eeprom(0,(read_ext_eeprom(0))+1); 27.puerto_D=read_ext_eeprom(0); 28.} 29.else if ((read_ext_eeprom(0) & 0x0F)>=0x09) 30.{ 31.write_ext_eeprom(0,(read_ext_eeprom(0))+7); 32.puerto_D=read_ext_eeprom(0); 33.} 34. 35.} 36. 37.void main() 38.{ 39.set_tris_b(0xFF); //Puerto B como entrada 40.set_tris_d(0x00);//Puerto D como salida 41.enable_interrupts(GLOBAL); // Se habilita la interrupcin global 42.enable_interrupts(INT_EXT); // Se habilita la interrupcin externa 43.puerto_D =0xFF; //inicializo puerto D 44. 45.init_ext_eeprom();//inicializamos memoria EEPROM externa 46.//write_ext_eeprom(0,0xFF);//Resetear registro 00 EEPROM 47. 48.while(true) 49.{ 50.//Resto del programa 51. 52.} 53.}

Comentario del programa

Como he dicho anteriormente en este primer ejemplo del uso del protocolo serie I2C vamos a utilizar el driver que nos facilita CCS. Para ello simplemente lo incluimos en nuestro programa por medio de la directiva #include:

#include "24256.c" //Incluimos librera 24256 Nota: por defecto la librera define los pines RB1 y RB0 como SDA y SCL, como en
nuestro ejemplo RB0 ya est ocupado. Hay que modificar esos valores en la librera y sustituirlos por RC4 y RC3, de la siguiente manera. Donde pone:

#define EEPROM_SDA PIN_B1 #define EEPROM_SCL PIN_B0

poner:

#define EEPROM_SDA PIN_C4

#define EEPROM_SCL PIN_C3

Las funciones que incluye esta librera son:

init_ext_eeprom(); //llamada a la funcin de inicializacin. Debe de ir

antes que las dos de abajo

write_ext_eeprom(a, d); //Escribe el byte d en la direccin a d = read_ext_eeprom(a); // lee el valor que hay en la direccin a y se lo asigna a la variable d

Pues bien la nica modificacin que hay que hacerle al cdigo, con respecto al que habamos hecho para grabar los datos en la EEPROM interna del PIC es sustituir estas funciones, segn se muestra en el cdigo fuente, fcil no!!. Proteus nos permite tambin ver el estado de los registros de est memoria en el proceso de simulacin.