PDF de programación - Capítulo 8/21 - Inter – Integrated Circuit Interface - I2C - Curso sobre Microcontroladores

Curso sobre Microcontroladores
Familia HC9S08 de Freescale

Por Ing. Daniel Di Lella – EduDevices – www.edudevices.com.ar
e-mail: [email protected]

Capítulo 8.-

Inter – Integrated Circuit Interface – I2C
MMIIC – Multi – Master I2C.
Aplicaciones Prácticas .....

Tal como se había prometido en el artículo anterior, se verá un ejemplo práctico
correspondientes al módulo I2C que figura en la “Guía de Prácticas” del HC9S08 del
kit “EDUKIT08” y para aquellos lectores que desean ampliar aún más sus
conocimientos sobre dicho módulo se sugiere consultar la nota de aplicación AN3048
de Freescale.

Introducción
Un módulo muy interesante de la línea HC9S08 es el de comunicación I2C. Este
módulo que se destaca por su sencillez lo aplicaremos en el EDUKIT08 para acceder a
una memoria serie tant para lectura como para escritura. En este ejemplo el usuario
podrá incrementar un contador de forma semejante al programa “Disp7seg04”
(programa demo para el display LED de 7 Segmentos) con la diferencia que la cuenta es
guardada en memoria.

Esta cuenta es recuperada de la memoria cada vez que ocurre un RESET en el
microcontrolador de modo que nunca se pierde la cantidad contada.

El módulo I2C

Ante todo analicemos como se configuró el módulo I2C valiéndonos para ello del
aplicativo “Processor Expert” del entorno integrado “CodeWarrior”:

Entre las categorías mas destacadas están:

• Multiplier Factor: Funciona como un prescaler. Las posibilidades que se nos

ofrecen son 1, 2 y 4. Optamos por la primera que nos proporciona la máxima
velocidad de comunicación entre el microcontrolador y la memoria.

• Clock Rate: También hace las veces de prescaler pero no se trata de una tasa de

división de la frecuencia de reloj. La hoja de datos del microcontrolador nos brinda
una tabla donde se puede obtener la división de reloj en función de este número:

El valor de 20 o $14 introducido desde la ventana del Processor Expert nos
proporciona la tasa de división de 80. No tenemos la necesidad de realizar cálculo
alguno para conocer la frecuencia de reloj pues en la propia ventana se nos muestra la
frecuencia operativa del módulo, 62,5Khz, frecuencia óptima para el funcionamiento de
una memoria I2C.

• Module Enable: Al marcarlo como Enabled el módulo será encendido durante la

inicialización.

El resto de los parámetros no es utilizado en este programa; las interrupciones no se
usan y los pines empleados para la comunicación I2C no se seleccionan.

Subrutina “I2C_leer”

Antes de describir la subrutina que lee bytes de la memoria 24LC256 recordemos el
diagrama de tiempo de una operación de lectura:

Los pasos para poder llevar a cabo la operación completa serían:

• Generar el bit de START.
• Enviar el byte $A0.
• Esperar el bit ACK.
• Enviar la dirección de memoria ( parte alta ).
• Esperar el bit ACK.
• Enviar dirección de memoria ( parte baja ).
• Esperar el bit ACK.
• Generar el bit de START
• Enviar el byte $A1.
• Esperar el bit ACK.
• Leer el byte de la memoria.
• Generar el bit de NACK
• Generar el bit de STOP.

Analicemos paso a paso la subrutina i2c_leer. Lo primero es la generación del bit de
START:

Para lo que actuamos sobre los bits MST y TX de registro IIC1C:

Ahora enviamos el byte $A0:

Tras enviar el byte, escribiendo en el registro IIC1D, nos quedamos esperando que el
bit IICIF del registro IIC1S se haga “1”. Este bit nos garantiza que el módulo este en
condiciones de aceptar otro byte para la transmisión. Dicho bit debe ser apagado por
software escribiéndole un “1”.

El siguiente paso es esperar el bit de ACK, para lo cual consultamos el bit RXAK del
registro IIC1S. Cuando se cumple la condición buscada este bit pasa a “1”.

Enviamos ahora la parte alta de la dirección de memoria a leer:

Hemos dejado la parte alta de la dirección igual a 0. Esto nos permitirá solo trabajar con
direcciones en el rango de 0 a 255. No costará mucho al usuario manejar direcciones en
todo el rango de la memoria modificando el programa.

Igual que en el programa anterior debemos consultar el bit IICIF y luego esperar el
ACK:

Y hacemos otro tanto con la parte baja de la dirección:

Ahora debemos enviar un bit de START y luego el byte $A1:

Escribiendo un “1” en bit RSTA se produce un nuevo bit de START, que se apagará
automáticamente al generarse este bit. El byte $A1 se envía de la forma habitual y luego
se espera el ACK.

Ahora viene lo más importante, pues no es evidente. Ponemos el módulo en modalidad
lectura y nos preparamos para enviar un NACK:

Y ejecutamos una escritura escribiendo en el registro IICD:

En realidad no se producirá ningun envío de bytes, pues estamos en la modalidad de
lectura, pero es necesario escribir en este registro, pues generará 8 pulsos de reloj
indispensables para la lectura de la memoria. Luego de consultar que se haya
completado la operación, generamos un STOP:

Y el resultado que se encuentra en la variable IIC1D lo copiamos a la variable byte.

Repasemos el funcionamiento de esta subrutina: cargamos en la variable dirección, la
posición de memoria que queremos leer e invocamos la subrutina i2c_leer. Al retornar
de ella obtendremos en la variable byte el valor leído.

Subrutina “i2c_escribir”

Ante todo mostremos el diagrama de tiempo de una operación de escritura:

Esta operación consiste de los siguientes pasos:

La generación del bit de START, el envío del byte $A0 y los 2 bytes que forman la
dirección de memoria se hace en forma idéntica a lo hecho en la subrutina de lectura:

El envío del byte a escribir se hace de la misma forma en que ya se han enviado otros
bytes:

Es decir, escribiendo en el registro IIC1D. Esperamos a que el transmisor este listo para
aceptar otro byte y esperamos que la memoria nos devuelva el bit de ACK. Por último
generamos el bit de STOP y damos por concluida la subrutina.

La escritura en una memoria no volátil requiere de un cierto tiempo, por lo general de
varios milisegundos.
Este prohibe realizar otra operación con la memoria durante ese tiempo, lo que suele
garantizarse llamando a una subrutina de demora que bloquee el programa durante un
tiempo prudencial. No la hemos incluído ya que luego llamaremos a una demora
antirrebote que cubre el tiempo con suficiencia.

Descripción del programa principal
Obviaremos la inicialización del LCD que utilizamos en tantos programas y pasaremos
directamente a lo que nos interesa que es el uso de las subrutinas de lectura y escritura
de la memoria I2C.

Lo primero que hacemos es leer la memoria y mostrar el valor en el LCD:

Ponemos a 0 la variable dirección, que contiene la parte baja de la dirección de
memoria a acceder. La parte alta como hemos mostrado anteriormente siempre estará en
0. Este programa solo emplea la dirección $0000 de la memoria I2C.

El valor leído de la memoria es recuperado en la variable byte y este es convertido a
BCD y presentado en el LCD.

El próximo paso es esperar a que el usuario presione el pulsador SW1 para incrementar
el valor presentado en el LCD y guardarlo en memoria:

Siempre trabajamos sobre la variable byte, en este caso para incrementarla. Llamamos a
la subrutina i2c_escribir para almacenar este nuevo valor en memoria, en la misma
posición.
Esto es posible gracias a que la subrutina i2c_escribir toma el valor a guardar de la
variable byte. Como ya hicimos mención la demora de antirrebote cubre el tiempo
que le insume a la memoria efectuar la grabación.

Tras esto el programa vuelve a la línea ciclo donde se refresca el valor indicado en el
LC D y se espera otra pulsación de SW1.

Continuará .......

Nota de Redacción: El lector puede descargar este capítulo y capítulos anteriores del
curso desde la sección “Artículos” (Curso_HC9S08) en el sitio web de EduDevices
(www.edudevices.com.ar )