Inicio » I2C AVR Ejemplos
I2C AVR Ejemplos Compartir:
0
0
0
0
0
Anterior: I2C AVR Comunicación Serial. I2C AVR ejemplos, en esta sección se realizarán algunos ejemplos realizados con el ATMEL ATMEL STUDIO sobre la utilización del del módulo TWI para la comunicación serial I2C AVR, esta es la parte práctica de lo que se vio aquí, por lo que se recomienda antes de continuar visitar visitar el enlace enlace indicado dicado.. Se utilizará el archivo de cabecera i2c.h que se obtuvo para la transmisión y recepción de datos con el I2C AVR, el microcontrolador AVR para realizar el I2C AVR ejemplos será el ATMEGA88 en un inicio, luego se compl co mplementará ementará con otros o tros AVRS. AVRS. El archivo de cabecera i2c.h que se obtuvo para ser utilizado con el ATMEGA88 en el que l que la a Fosc=8Mhz, Fosc=8Mhz, la velocidad de comunicación de 400Khz con un prescaler de 1 es el siguiente, con algunas pequeñas modificaciones se puede utilizar en cualquier otro ATMEGAxxx, si se utiliza otra Fosc y/o otra velocidad de comunicación hay que hacer los cálculos 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 módulo TWI I2C AVR con el ATMEL STUIDO/// //para el ATMEGA88 como maestro, la comunicación será a 400Khz///// //la frecuencia de trabajo del ATMEGA88 es de 8Mhz, el archivo ///// //puede ser utilizado en otros AVR fácilmente realizandole pequeños/// //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();
//función para iniciar el módulo TWI I2C AVR //función de espera //función que inicia la comunicación 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();
//función que detiene la comunicación I2C AVR void i2c_envia_dato( unsigned char ); //función para enviar o escribir //datos en el esclavo unsigned char i2c_recibe_dato_ack(); //función para recibir o leer datos del esclavo //enviando el bit ACK si se quiere leer mas datos //después del último leído unsigned char i2c_recibe_dato_nack(); //función para recibir o leer datos del esclavo //sin enviar el bit ACK si no se quiere leer mas //después del último leido uint8_t i2c_estado_com(); //función para averiguar el estado de la comunicación I2C AVR //útil para detectar errores /////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////// //inicialización del módulo TWI I2C AVR en el ATMEL STUDIO en una función//// //para el ATMEGA88 como maestro //a 400KHz con un oscilador de 8Mhz void i2c_iniciar(){
PORTC|=((1<<4)|(1<<5)); TWBR=2; TWCR|=(1<
//activa resistencias pull upp para SCL y SDA //velocidad 400Khz, Fosc 8Mhz, prescaler de 1 //módulo TWI iniciado
}
//////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////// // Función de espera: mientras el bit7 o bit TWINT del registro // TWCR sea 0, el IC2 AVR se esperará // antes de realizar algún trabajo
void i2c_espera(){ while ((TWCR & (1<
bit de interrupcion sea 0
} //////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////// // Función de inicio de la comunicación I2C AVR void i2c_inicia_com() {
TWCR = (1<
//////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////// // Función de parada de la comunicación I2C I2C void i2c_detener() {
TWCR = (1<
TWDR = dato; TWCR = (1<
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
///////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////// //Función de recepción de datos enviados por el esclavo al maestro //esta función es para leer los datos que están 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<
//mas
datos
TWCR = (1<
///////////////////////////////////////////////////////////////// Política y privacidad //función para averiguar el estado de la comunicación I2C AVR de Cookies //útil para detectar errores, el valor que retorna esta función //se compara con el estado que deberían indicar los bits del 7 al 3 //del registro TWSR según tabla, durante la comunicación I2C AVR, uint8_t i2c_estado_com(){ uint8_t estado; estado = TWSR & 0xf8;
return estado;
//variable donde se almacena el estado de la comunicación //I2C AVR //en la variable estado se guarda el valor de los 5 bits de //mas peso del registro TWSR seguidos de 3 ceros, //el número obtenido indica //el estado en que se encuentra la comunicación I2C AVR //la función retorna el estado de la comunicación
} #endif /* I2C_H_ */
I2C AVR EJEMPLOS I2C AVR ejemplos 1 En este primer ejemplo se realizará la comunicación 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 comunicación I2C, este integrado trae una dirección de fábrica 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 dirección sea 1010000, aunque se puede elegir otra combinación. El pin 8 es para la alimentación, 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 guardarán los datos están constituidos por 2 bytes, en este integrado se pueden almacenar hasta 256Kbites. El el ejemplo se enviarán o escribirán datos en la EEPROM mediante la comunicación I2C, luego se leerán los datos enviados a la EEPROM y serán vistos en forma binaria en el puerto D del ATMEGA88 que será el maestro. El ejemplo es sencillo para no complicar el código, pero se puede hacer lo que se quiera mediante la comunicación 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 comunicación 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 comunicación serial con el módulo TWI I2C AVR El circuito utilizado para el I2C AVR ejemplos 1 es el siguiente:
En el código para el ATMEGA88 que será el maestro se tiene que crear una función para la escritura y otra función para la lectura de la memoria EEPROM, hay que seguir un orden en cuanto a la lectura y escritura en la comunicación serial I2C AVR, eso se puede ver aquí, será realizado en el ATMEL STUDIO, los pasos que se siguen estarán comentados en el código, en caso de utilizar otro dispositivo como esclavo se seguirán 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 código para el maestro ATMEGA88* // ///////********************************/////// #define F_CPU 8000000ul #include
#include #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 módulo SSP en modo I2C PIC void escribe_eeprom(uint16_t dir_men_eep, unsigned char dato); //prototipo de función
//para escribir o enviar datos a la memoria EEPROM 24LC256 unsigned char leer_eeprom(uint16_t dir_men_eep);
//prototipo de función 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 permitirán ver el dato leido desde la EEPROM en forma binaria PORTD=0x00; //Los leds inician apagados
i2c_iniciar();
//función para iniciar el módulo TWI I2C AVR
while(1)
{ for(uint8_t i=0;i<=100;i++){
escribe_eeprom(i,i); _delay_ms(20); } for(uint8_t i=0;i<=100;i++){
PORTD=leer_eeprom(i);
_delay_ms(1000); }
//en las direccienes que van desde 0 a 100 //de la EEPROM se enviarán o escribirán sus //mismas direcciones //pausa de 20ms para darle tiempo a la eeprom //a que reciba bien los datos //para las direcciones de memoria de la EEPROM //de la 0 a la 100 //menvia al puerto D el valor leido en la //posición de memoria, será visto en forma //binaria con leds //pausa para que el dato leído en el puerto D //sea visto cada segundo
} } //Función para enviar o escribir datos en la memoria EEPROM 24LC256 //creada con las funciones que están en el archivo de cabecera i2c.h //la función se le ha llamado leer_eeprom, hay que darle dos parámetros //uno será la dirección 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 comunicación 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);
//envía la dirección del esclavo con el que el maestro se //se quiere comunicar, en este cado de la EEPROM de quien su //dirección 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 dirección 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 envía primero la parte alta de esta dirección //y luego la parte baja de esta dirección 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 dirección del registro de la memoria EEPROM //donde se guardará el dato. i2c_envia_dato(dato); //envia o escribe el dato en la dirección del registro //elegido de la memoria EEPROM //una vez que el esclavo recibe el dato se terminará la comunicación I2C AVR i2c_detener(); //finaliza la comunicación I2C AVR } //Función para recibir o leer datos desde la memoria EEPROM 24LC256 //creada con las funciones que están en el archivo de cabecera i2c.h //la función se le ha llamado leer_eeprom, hay que darle un parámetro //que será la dirección 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 leído desde la EEPROM
i2c_inicia_com();
//inicia la comunicación serial i2C AVR
i2c_envia_dato(0xa0);
//envía la dirección del esclavo con el que el maestro se //se quiere comunicar, en este cado de la EEPROM de quien su //dirección 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 dirección 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 envía primero la parte alta de esta dirección //y luego la parte baja de esta dirección 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 //comunicación serial I2C PIC se hace con la misma función //i2c_inicia_com(); el módulo TWI reconoce que se reiniciará la comunicación I2C AVR i2c_inicia_com(); //para reiciar la comunicación I2C AVR //a continuación se vuelve a enviar la dirección del esclavo con el que el maestro s //está comunicanco, en este cado de la EEPROM de quien su dirección es de 7 bits (10 //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); //dirección 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 ubicación de la memoria elegida de la EEPROM //y se guarda en la variable dato creada en un inicio dentro de esta función dato=i2c_recibe_dato_nack(); //lectura del dato de la ubicación de la memoria elegid //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 comunicación I2C AVR i2c_detener(); //finaliza la comunicación I2C AVR return dato; //la función devolverá el dato leído desde la EEPROM y guardado en
//la variable dato
En el ejemplo no se ha utilizado la función i2c_estado_com() para no complicar el ejemplo, esta función es muy útil y se verá la manera de utilizarla en próximos ejemplos. La siguiente es una imagen del circuito de prueba realizado para el I2C AVR ejemplos 1
I2C PIC ejemplos 2 Compartir:
0
0
0
0
Buscar
MAS DE ELECTRÓNICA AQUÍ
mrelbernitutoriales.com Lista de Reproducción Microcontroladores PIC
Microcontroladores ...
Lista de Reproducción Microcontroladores AVR Microcontrolador AV...
Google Maps
Datos de mapas ©2016 Google 50 km
Compartir 0
0
0
0
MrElberni El... 333 Me gusta
Me gusta esta página
Sé el primero de tus amigos en indicar que le gusta esto.
MrElberni Electrónica Electricidad 30 de noviembre de 2015
Amplificador operacional funcionamiento: https:/ /t.co/vJEEigBedd vía @YouTube
Enlaces del sitio › INICIO › MICROCONTROLADORES PIC ›
Introducción
›
Bits de configuración PIC
›
Entradas s alidas digitales PIC
›
Temporizador conta dor P IC
›
›
Timer0 PIC
›
Timer1 PIC
›
Timer2 PIC
Interrupciones con el PIC
›
Interrupción Externa P IC
›
Interrupción timer0 PIC
›
Interrupción po r cambio de e stado en e l puerto B PIC
›
Interrupción ADC PIC
›
Interrupción USART PIC
›
Converso r analógico digital PIC
›
Módulo CCP
›
›
CCP P IC modo captura
›
CCP PIC modo comparación
›
CCP P IC modo P WM modulación por ancho de pulso
USART PIC Co municación se rial
› ›
I2C PIC comunicación serial
› ›
USART PIC e jemplos
I2C PIC ejemplos
EEPROM PIC Memoria interna
› MICROCONTROLADORES AVR ›
Introducción
›
Entradas salidas digitales con el AVR
›
Temporizado r AVR
›
›
›
Timer0 AVR
›
Timer1 AVR
›
Timer2 AVR
PW M AVR modulación por ancho de p ulso
›
PW M timer0 AVR modo rápido
›
PW M timer0 AVR Fas e correcta
›
PW M timer1 AVR modo rápido
›
PW M timer1 AVR Fas e correcta
›
PW M timer2 AVR modo rápido
›
PW M timer2 AVR fas e correcta
Interrupciones con el AVR
›
Interrupción externa AVR
›
Interrupción timer0 AVR
›
Interrupción timer1 AVR
›
Interrupción timer2 AVR
›
Interrupción ADC AVR
›
Interrupción USART AVR
›
Convertidor Analógico Digital AVR
›
USART AVR Comunicación serial
›
USART AVR ejemplos
›
I2C AVR Comunicación s erial TWI
› ›
I2C AVR Ejemplos
EEP ROM AVR Memoria inte rna
› ARDUINO ›
Introducción
›
Entradas salidas digitales Arduino
›
Temporizador Contador ARDUINO
› Programación C C++ › Dispositivos Electrónicos ›
Teclado matricial y de punto común
›
Pantallas LCD
›
LCD con e l AVR
› Proyectos PIC ›
Proyectos entrada s sa lidas digitales PIC
› Proyectos AVR ›
PW M AVR control velocidad motor 12VCC
· © 2016 MICRO C ONTROLADORES · Designed by Press C ustomizr · Powered by ·
