Inicio I2C AVR Ejemplos

I2C AVR Ejemplos

Compartir:

Anterior: I2C AVR Comunicacin Serial.

I2C AVR ejemplos, en esta seccin se realizarn algunos ejemplos realizados con el
ATMEL STUDIO sobre la utilizacin del mdulo TWI para la comunicacin serial I2C AVR,
esta es la parte prctica de lo que se vio aqu, por lo que se recomienda antes de
continuar visitar el enlace indicado. Se utilizar el archivo de cabecera i2c.h que se
obtuvo para la transmisin y recepcin de datos con el I2C AVR, el microcontrolador
AVR para realizar el I2C AVR ejemplos ser el ATMEGA88 en un inicio, luego se
complementar con otros AVRS.
El archivo de cabecera i2c.h que se obtuvo para ser utilizado con el ATMEGA88 en el
que la Fosc=8Mhz, la velocidad de comunicacin de 400Khz con un prescaler de 1 es el
siguiente, con algunas pequeas modificaciones se puede utilizar en cualquier otro
ATMEGAxxx, si se utiliza otra Fosc y/o otra velocidad de comunicacin hay que hacer
los clculos con TWBR=((Fosc/Velocidad)-16)/(2*prescaler) para el nuevo valor a
cargar en TWBR.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
//Archivo de cabecera para el uso del mdulo TWI I2C AVR con el ATMEL STUIDO///
//para el ATMEGA88 como maestro, la comunicacin ser a 400Khz/////
//la frecuencia de trabajo del ATMEGA88 es de 8Mhz, el archivo /////
//puede ser utilizado en otros AVR fcilmente realizandole pequeos///
//cambios como los pines SCL y SDA, la Fosc, siempre revisar la hoja//
//de datos del AVR utilizado para comprobar los registros/////////////
///////////////////////////////////////////////////////////////////////
#ifndef I2C_H_
#define I2C_H_
void i2c_iniciar();
void i2c_espera();
void i2c_inicia_com();

//funcin para iniciar el mdulo TWI I2C AVR

//funcin de espera
//funcin que inicia la comunicacin I2C AVR

18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82

void i2c_detener();
//funcin que detiene la comunicacin I2C AVR
void i2c_envia_dato(unsigned char ); //funcin para enviar o escribir
//datos en el esclavo
unsigned char i2c_recibe_dato_ack(); //funcin para recibir o leer datos del esclavo
//enviando el bit ACK si se quiere leer mas datos
//despus del ltimo ledo
unsigned char i2c_recibe_dato_nack(); //funcin para recibir o leer datos del esclavo
//sin enviar el bit ACK si no se quiere leer mas datos
//despus del ltimo leido
uint8_t i2c_estado_com(); //funcin para averiguar el estado de la comunicacin I2C AVR
//til para detectar errores
///////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
//inicializacin del mdulo TWI I2C AVR en el ATMEL STUDIO en una funcin////
//para el ATMEGA88 como maestro
//a 400KHz con un oscilador de 8Mhz
void i2c_iniciar(){
PORTC|=((1<<4)|(1<<5)); //activa resistencias pull upp para SCL y SDA
TWBR=2;
//velocidad 400Khz, Fosc 8Mhz, prescaler de 1
TWCR|=(1<<TWEN);
//mdulo TWI iniciado
}

////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////
// Funcin de espera: mientras el bit7 o bit TWINT del registro
// TWCR sea 0, el IC2 AVR se esperar
// antes de realizar algn trabajo

MICROCONTROLADORES

void i2c_espera(){
while ((TWCR & (1<<TWINT)) == 0);//espera mientras el bit de interrupcion sea 0
}
////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////
// Funcin de inicio de la comunicacin I2C AVR

void i2c_inicia_com() {
TWCR = (1<<TWINT)|(1<<TWSTA)|(1<<TWEN);//bandera de interrupcin a 1, start, habilita I2C A
i2c_espera();
//espera mientras el bit TWINT sea 0
}

////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////
// Funcin de parada de la comunicacin I2C I2C

void i2c_detener() {
TWCR = (1<<TWINT)|(1<<TWSTO)|(1<<TWEN);//bandera de interrupcin a 1, detener, habilita I2C
}
/////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////
//Funcin de transmisin de datos del maestro al esclavo
void i2c_envia_dato(unsigned char dato) {
TWDR = dato;
TWCR = (1<<TWINT)|(1<<TWEN);//para empezar a enviar el dato
i2c_espera();//cuando TWINT se ponga a 1 se habr terminado de enviar el dato
}

83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126

/////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////
//Funcin de recepcin de datos enviados por el esclavo al maestro
//esta funcin es para leer los datos que estn en el esclavo
//en forma continua, esto es tras leer uno se volver a leer otro
unsigned char i2c_recibe_dato_ack(){//maestro envia ack para seguir recibiendo
//mas datos
TWCR = (1<<TWINT)|(1<<TWEN)|(1<<TWEA);
i2c_espera();
return TWDR;
}
/////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////
//Funcin de recepcin de datos enviados por el esclavo al maestro
//esta funcin es para leer solo un dato desde el esclavo
//esto es tras leer uno ya no se volver a leer otro
unsigned char i2c_recibe_dato_nack(){//maestro no envia ack para no seguir recibiendo
//mas datos
TWCR = (1<<TWINT)|(1<<TWEN);
i2c_espera();
return TWDR;
}

/////////////////////////////////////////////////////////////////
//funcin para averiguar el estado de la comPoltica
unicaci
I2C AVR de Cookies
ynprivacidad
//til para detectar errores, el valor que retorna esta funcin
//se compara con el estado que deberan indicar los bits del 7 al 3
//del registro TWSR segn tabla, durante la comunicacin I2C AVR,

uint8_t i2c_estado_com(){
uint8_t estado;
//variable donde se almacena el estado de la comunicacin
//I2C AVR
estado = TWSR & 0xf8; //en la variable estado se guarda el valor de los 5 bits de
//mas peso del registro TWSR seguidos de 3 ceros,
//el nmero obtenido indica
//el estado en que se encuentra la comunicacin I2C AVR
return estado;

//la funcin retorna el estado de la comunicacin

}
#endif /* I2C_H_ */

I2C AVREJEMPLOS
I2C AVR ejemplos 1 En este primer ejemplo se realizar la comunicacin serial I2C
AVR entre el ATMEGA88, y la memoria EEPROM 24LC256 (revisar su hoja de datos) la
que est fabricada para ser utilizada como esclavo en la comunicacin I2C, este
integrado trae una direccin de fbrica para ser utilizado como esclavo de 7 bits, que es
1010(A2)(A1)(A0) los primeros 4 bits son fijos los siguientes 3 se pueden elegir
poniendo los pines A2, A1 y A0 a 0 o a 1, si se utiliza una sola de estas memorias
normalmente estos pines se ponen a 0 para que su direccin sea 1010000, aunque se
puede elegir otra combinacin.
El pin 8 es para la alimentacin, el pin 4 es para el negativo, el pin 7 es para bloquear la
escritura en la eeprom si se pone a 1, se el pin 7 no se conecta o se pone a 0 se podr
escribir en la eeprom.

El pin 6 SCL se conectar al pin SCL del

ATMEGA88 y el pin 5 SDA se conectar al pin
SDA del AVR.
Las direcciones de los registros de la EEPROM
24LC256 donde se guardarn los datos estn
constituidos por 2 bytes, en este integrado se
pueden almacenar hasta 256Kbites.
El el ejemplo se enviarn o escribirn datos en
la EEPROM mediante la comunicacin I2C,
luego se leern los datos enviados a la
EEPROM y sern vistos en forma binaria en el
puerto D del ATMEGA88 que ser el maestro.
El ejemplo es sencillo para no complicar el cdigo, pero se puede hacer lo que se quiera
mediante la comunicacin I2C. La idea es muy similar por no decir la misma si se utiliza
otro tipo de dispositivo que se pueda utilizar como esclavo en la comunicacin I2C AVR.
En este ejemplo lo que se busca es que se vea como utilizar el archivo de cabecera
i2c.h ya que ser el utilizado en los siguientes I2C AVR ejemplos.
En la siguiente imagen se ha creado un proyecto llamado i2c, con el archivo fuente
llamado i2c_ejemplo1.c, el la parte resaltada i2c_ejemplo1 se hace click derecho y
en Add se selecciona New Item, en la ventana que aparece se selecciona Include
File y en name se le da el nombre de i2c.h, y se pulsa sobre Add as se crear
el archivo llamado i2c.h, luego se hace doble click sobre el archivo i2c.h creado para
abrir el editor i2c.h, se borra todo lo que el programa genere, que quede limpio, se
copia el contenido mostrado lineas arriba para el archivo de cabecera y se pega dentro
de i2c.h, el resultado debe ser similar al que se ve en la siguiente imagen.

A partir de este momento ya se puede utilizar el archivo de cabecera i2c.h para realizar
la comunicacin serial con el mdulo TWI I2C AVR
El circuito utilizado para el I2C AVR ejemplos 1 es el siguiente:

En el cdigo para el ATMEGA88 que ser el maestro se tiene que crear una funcin para
la escritura y otra funcin para la lectura de la memoria EEPROM, hay que seguir un
orden en cuanto a la lectura y escritura en la comunicacin serial I2C AVR, eso se puede
ver aqu, ser realizado en el ATMEL STUDIO, los pasos que se siguen estarn
comentados en el cdigo, en caso de utilizar otro dispositivo como esclavo se seguirn
los mismos pasos.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56

/////////////////////////////////////////////
///////*********************************///////
///*** microcontroladores-mrelberni.com ***////
///////*****************************//////////
//* I2C AVR ejemplos 1 cdigo para el maestro ATMEGA88* //
///////********************************///////
#define F_CPU 8000000ul
#include <avr/io.h>
#include <util/delay.h>
#include "i2c.h"
//incluye el archivo de cabecera el que se ha creado
//en Header Files para utilizar la funciones necesarias,
//para el uso del mdulo SSP en modo I2C PIC
void escribe_eeprom(uint16_t dir_men_eep, unsigned char dato); //prototipo de funcin
//para escribir o enviar datos a la memoria EEPROM 24LC256
unsigned char leer_eeprom(uint16_t dir_men_eep); //prototipo de funcin para leer
//o recibir datos de la memoria EEPROM 24LC256
int main(void)
{
DDRD=0b11111111; //todos los pines de puerto D como salidas para conectar los leds
//que permitirn ver el dato leido desde la EEPROM en forma binaria
PORTD=0x00;
//Los leds inician apagados

i2c_iniciar();

//funcin para iniciar el mdulo TWI I2C AVR

while(1)
{
for(uint8_t i=0;i<=100;i++){ //en las direccienes que van desde 0 a 100
escribe_eeprom(i,i);
//de la EEPROM se enviarn o escribirn sus
//mismas direcciones
_delay_ms(20);
//pausa de 20ms para darle tiempo a la eeprom
}
//a que reciba bien los datos
for(uint8_t i=0;i<=100;i++){ //para las direcciones de memoria de la EEPROM
//de la 0 a la 100
PORTD=leer_eeprom(i);
//menvia al puerto D el valor leido en la
//posicin de memoria, ser visto en forma
//binaria con leds
_delay_ms(1000);
}

//pausa para que el dato ledo en el puerto D

//sea visto cada segundo

}
}
//Funcin para enviar o escribir datos en la memoria EEPROM 24LC256
//creada con las funciones que estn en el archivo de cabecera i2c.h
//la funcin se le ha llamado leer_eeprom, hay que darle dos parmetros
//uno ser la direccin del registro de la memoria EEPROM que se desea leer
//o de donde se quiere recibir el dato y el otro el dato a enviar
void escribe_eeprom(uint16_t dir_men_eep, unsigned char dato){
i2c_inicia_com();
//inicia la comunicacin serial i2C AVR

57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121

i2c_envia_dato(0xa0);

//enva la direccin del esclavo con el que el maestro se

//se quiere comunicar, en este cado de la EEPROM de quien su
//direccin es de 7 bits (1010000) junto con el bit 0
//que es el que le indica al esclavo que el maestro quiere
//enviar o escribir un dato en la EEPROM,
//por lo que se envia 10100000 que en hexadecimal es 0xa0

//lo que sigue es enviar la direccin del registro de la memoria EEPROM donde se
//escribir el dato enviado por el maestro ATMEGA88, como estas direcciones en
//la EEPROM 24LC256 son de 2 bytes, se enva primero la parte alta de esta direccin
//y luego la parte baja de esta direccin
i2c_envia_dato(dir_men_eep>>8); //envia parte alta de la direccion del registro
//de la EEPROM donde se guardar el dato
i2c_envia_dato(dir_men_eep);
//envia parte baja de la direccion del registro
//de la EEPROM donde se guardar el dato
//Lo que sigue es enviar el dato a la direccin del registro de la memoria EEPROM
//donde se guardar el dato.
i2c_envia_dato(dato); //envia o escribe el dato en la direccin del registro
//elegido de la memoria EEPROM
//una vez que el esclavo recibe el dato se terminar la comunicacin I2C AVR
i2c_detener(); //finaliza la comunicacin I2C AVR
}
//Funcin para recibir o leer datos desde la memoria EEPROM 24LC256
//creada con las funciones que estn en el archivo de cabecera i2c.h
//la funcin se le ha llamado leer_eeprom, hay que darle un parmetro
//que ser la direccin del registro de la memoria EEPROM que se desea leer
//o de donde se quiere recibir el dato
unsigned char leer_eeprom(uint16_t dir_men_eep){
unsigned char dato;//variable donde se guardar el dato ledo desde la EEPROM
i2c_inicia_com();

//inicia la comunicacin serial i2C AVR

i2c_envia_dato(0xa0);

//enva la direccin del esclavo con el que el maestro se

//se quiere comunicar, en este cado de la EEPROM de quien su
//direccin es de 7 bits (1010000) junto con el bit 0
//que es el que le indica al esclavo que el maestro quiere
//enviar o escribir un dato en la EEPROM,
//por lo que se envia 10100000 que en hexadecimal es 0xa0

//lo que sigue es enviar la direccin del registro de la memoria EEPROM de donde
//el maestro AATMEGA88 leer o recibir el dato, como estas direcciones en
//la EEPROM 24LC256 son de 2 bytes, se enva primero la parte alta de esta direccin
//y luego la parte baja de esta direccin
i2c_envia_dato(dir_men_eep>>8); //envia la parte alta de la direccion del registro
//de la EEPROM de donde se leer el dato
i2c_envia_dato(dir_men_eep);
//envia la parte baja de la direccion del registro
//de la EEPROM de donde se leer el dato
//lo que sigue una vez que ya se le dijo al esclavo donde se leer es reiniciar la
//comunicacin serial I2C PIC se hace con la misma funcin
//i2c_inicia_com(); el mdulo TWI reconoce que se reiniciar la comunicacin I2C AVR
i2c_inicia_com(); //para reiciar la comunicacin I2C AVR

//a continuacin se vuelve a enviar la direccin del esclavo con el que el maestro se
//est comunicanco, en este cado de la EEPROM de quien su direccin es de 7 bits (1010000)
//pero esta vez junto con el bit 1 que es el que le indica al esclavo que el maestro
//quiere leer o recibir un dato de la EEPROM, por lo que se envia 10100001
//que en hexadecimal es 0xa1
i2c_envia_dato(0xa1); //direccin de la eeprom junto con el 1 para lectura

122
123
124
125
126
127
128
129
130
131
132
133 }

//luego se lee el dato de la ubicacin de la memoria elegida de la EEPROM

//y se guarda en la variable dato creada en un inicio dentro de esta funcin
dato=i2c_recibe_dato_nack(); //lectura del dato de la ubicacin de la memoria elegida
//se utiliza nack porque no se quiere leer los datos en
//forma continua, para poder verlos en los leds
//una vez que el maestro lee o recibe el dato se terminar la comunicacin I2C AVR
i2c_detener(); //finaliza la comunicacin I2C AVR
return dato; //la funcin devolver el dato ledo desde la EEPROM y guardado en
//la variable dato

En el ejemplo no se ha utilizado la funcin i2c_estado_com() para no complicar el

ejemplo, esta funcin es muy til y se ver la manera de utilizarla en prximos
ejemplos.
La siguiente es una imagen del circuito de prueba realizado para el I2C AVR ejemplos 1

I2C PIC ejemplos 2

Compartir:

Buscar

MAS DE ELECTRNICA AQU

mrelbernitutoriales.com
Lista de Reproduccin Microcontroladores PIC

Microcontroladores ...

Lista de Reproduccin Microcontroladores AVR

Microcontrolador AV...

Google Maps

Datos de mapas 2016 Google

50 km

Compartir
0

MrElberni El...
333 Me gusta

Me gusta esta pgina

S el primero de tus amigos

en indicar que le gusta esto.

MrElberni
Electrnica
Electricidad
30 de noviembre de
2015

Amplificador operacional
funcionamiento:
https://t.co/vJEEigBedd va
@YouTube

Enlaces del sitio

INICIO
MICROCONTROLADORES PIC
Introduccin
Bits de configuracin PIC
Entradas salidas digitales PIC
Temporizador contador PIC
Timer0 PIC
Timer1 PIC
Timer2 PIC
Interrupciones con el PIC
Interrupcin Externa PIC
Interrupcin timer0 PIC
Interrupcin por cambio de estado en el puerto B PIC

 Interrupcin ADC PIC

Interrupcin USART PIC
Conversor analgico digital PIC
Mdulo CCP
CCP PIC modo captura
CCP PIC modo comparacin
CCP PIC modo PWM modulacin por ancho de pulso
USART PIC Comunicacin serial
USART PIC ejemplos
I2C PIC comunicacin serial
I2C PIC ejemplos
EEPROM PIC Memoria interna
MICROCONTROLADORES AVR
Introduccin
Entradas salidas digitales con el AVR
Temporizador AVR
Timer0 AVR
Timer1 AVR
Timer2 AVR
PWM AVR modulacin por ancho de pulso
PWM timer0 AVR modo rpido
PWM timer0 AVR Fase correcta
PWM timer1 AVR modo rpido
PWM timer1 AVR Fase correcta
PWM timer2 AVR modo rpido
PWM timer2 AVR fase correcta
Interrupciones con el AVR
Interrupcin externa AVR
Interrupcin timer0 AVR
Interrupcin timer1 AVR
Interrupcin timer2 AVR
Interrupcin ADC AVR
Interrupcin USART AVR
Convertidor Analgico Digital AVR
USART AVR Comunicacin serial
USART AVR ejemplos

 I2C AVR Comunicacin serial TWI

I2C AVR Ejemplos
EEPROM AVR Memoria interna
ARDUINO
Introduccin
Entradas salidas digitales Arduino
Temporizador Contador ARDUINO
Programacin C C++
Dispositivos Electrnicos
Teclado matricial y de punto comn
Pantallas LCD
LCD con el AVR
Proyectos PIC
Proyectos entradas salidas digitales PIC
Proyectos AVR
PWM AVR control velocidad motor 12VCC

2016 MIC ROC ONTROLADORES Designed by Press C ustomizr Powered by