Su pedido está VACIO.


Siguenos!!

Login





Who's Online
Tenemos 15 invitados conectado
Sensor ultrasonico SRF08 I2C PDF Imprimir Correo electrónico
Escrito por Hector Torres   
Viernes 25 de Marzo de 2011 03:43

Sensor ultrasónico SRF08

 

Descripción

 

Para este ejemplo se hará uso de un sensor ultrasónico, este es un modulo independiente, el cual es controlado vía I2C (Inter-Integrated Circuit) , este protocolo es también conocido como TWI (Two-Wire-Interface). El sensor nos entrega la distancia directamente en centímetros, la que estaremos visualizando a través de una serie de LEDs conectados al microcontrolador.

 

Diagrama Esquemático

 

srf08

 

Materiales


  • Sensor ultrasónico SRF08

  • 6 Resistencias de 220 Ohms

  • 1 Microcontrolador ATmega8

  • Programador USBasp V3.0

 

Introducción


Sensor SRF08

 

El SRF08 Es un medidor ultrasónico de distancias comercial, el cual hace uso de su transmisor y receptor para ofrecer una medida de distancia bastante precisa, el sensor también cuenta con un LDR la cual nos indica la intensidad luminosa del lugar donde lo tengamos.

 

Algunas de las características del sensor son:

-5v de alimentación

-15mA de consumo de corriente

-Frecuencia 40KHz

-Rango de medición: de 3cm a 6mts

-Conexión I2C

-Sensor de iluminación LDR

-Unidades soportadas: uS, mm, pulgadas.

-Tamaño: 43x20x17 mm

 

srf08 2

 

En la imagen superior podemos ver las conexiones del sensor, en este caso como se puede apreciar el cuarto pin no se conecta, y los pines SDA y SCL son los del protocoló I2C los cuales irán conectados al microcontrolador como se ve en el diagrama esquemático.

 

I2C o TWI


I2C es un bus de comunicaciones en serie. Su nombre viene de Inter-Integrated Circuit (Circuitos Inter-Integrados). La versión 1.0 data del año 1992 y la versión 2.1 del año 2000, su diseñador es Philips. La velocidad es de 100Kbits por segundo en el modo estándar, aunque también permite velocidades de 3.4 Mbit/s. Es un bus muy usado en la industria, principalmente para comunicar microcontroladores y sus periféricos en sistemas integrados (Embedded Systems) y generalizando más para comunicar circuitos integrados entre si que normalmente residen en un mismo circuito impreso.

 

La principal característica de I²C es que utiliza dos líneas para transmitir la información: una para los datos y por otra la señal de reloj. También es necesaria una tercera línea, pero esta sólo es la referencia GND.

 

Las líneas se llaman:

SDA: datos

SCL: reloj

GND:

 

En la imagen se puede ver un ejemplo de conexión de un microcontrolador, en modo maestro y varios otros dispositivos conectados como esclavos, como ADCs DACs otros microcontroladores, sensores etc.

 

i2c

 

Algunas de las instrucciones a utilizar del sensor SRF08

 

i2c srf08

 

El sensor SRF08 tiene muchas más instrucciones y diferentes modos de operación, esta tabla solo contiene algunas de las instrucciones que el sensor maneja, esto con la finalidad de entender el código que va en el micrcontrolador, ya que más adelante se hará uso de estas direcciones.

 

Programa en C

 

#include<avr/io.h>

#include<util/delay.h>

#include<avr/interrupt.h>

#include<util/twi.h>

 

#define Clock 1000000                                      //Frecuencia de trabajo del microcontrolador

#define SRF02 0xE0;

 

void TWI_config(unsigned long int);                    //Declarar las funciones

void i2c_transmit(char,char,char);

char i2c_read(char,char);

 

 

 

int main(void)                                                  //Inicio del programa

{

DDRD = 0xFF;

TWI_config(100000);                                      //Llamar la funcion para configurar el I2C o TWI

unsigned char valor=0;

while(1)

{

i2c_transmit(0xE0,0,0x51);                                //Transmitir: direccion 0xE0, registro 0, dato 0x51

_delay_ms(75);

valor = i2c_read(0xE0,3);                                  //leer: direccion 0xE0, registro 3

PORTD = valor;                                               //Mandar el valor leido al puerto D

_delay_ms(100);

}

}

 

 

 

void TWI_config(unsigned long int frecuencia)

{

TWBR = ((Clock/frecuencia) - 16)/8;                   // Registro para la frecuencia de SCL

TWSR=(0<<TWPS1)+(0<<TWPS0);                  // Preescala 1

 

}

char i2c_read(char address, char reg)

{

char read_data = 0;

 

TWCR = 0xA4;                                                 // Mandar el bit de inicio para el bus I2C

while(!(TWCR & 0x80));                                    // Esperando la confirmación

TWDR = address;                                             // Cargar dirección (adress) en el dispositivo

TWCR = 0x84;                                                 // Transmitir

while(!(TWCR & 0x80));                                    // Esperar confirmación de la transmisión

TWDR = reg;                                                   // Enviar número de registro a leer

TWCR = 0x84;                                               // Transmitir

while(!(TWCR & 0x80));                                    // Esperar confirmación de la transmisión

 

TWCR = 0xA4;                                               // Volver a mandar un bit de inicio

while(!(TWCR & 0x80));                                    // Esperar confirmación de la transmisión

TWDR = address+1;                                         // Transmitir dirección por I2C con la lectura habilitada

TWCR = 0xC4;                                                // Borrar la bandera de interrupción de transmisión

while(!(TWCR & 0x80));                                   // Esperar confirmación de la transmisión

TWCR = 0x84;                                                // Transmitir (Solicitud del último byte)

while(!(TWCR & 0x80));                                   // Esperar confirmación de la transmisión

read_data = TWDR;                                        // Tomar el dato

TWCR = 0x94;                                               // Mandar un bit de paro al bus I2C

return read_data;

}

 

void i2c_transmit(char address, char reg, char data)

{

TWCR = 0xA4;                                                  // Mandar el bit de inicio para el bus I2C

while(!(TWCR & 0x80));                                     // Esperar confirmación de la transmisión

TWDR = address;                                              // Cargar dirección (adress) en el dispositivo

TWCR = 0x84;                                                  // Transmitir

while(!(TWCR & 0x80));                                     // Esperar confirmación de la transmisión

TWDR = reg;

TWCR = 0x84;                                                  // Transmitir

while(!(TWCR & 0x80));                                     // Esperar confirmación de la transmisión

TWDR = data;

TWCR = 0x84;                                                 // Transmitir

while(!(TWCR & 0x80));                                     // Esperar confirmación de la transmisión

TWCR = 0x94;                                                  // Mandar un bit de paro al bus I2C

}

 

Detalles del programa


#include<avr/io.h>

#include<util/delay.h>

#include<avr/interrupt.h>

#include<util/twi.h>

 

Se llaman las librerías necesarias para el programa.

 

void TWI_config(unsigned long int);

void i2c_transmit(char,char,char);

char i2c_read(char,char);

 

Se declaran las funciones que a continuación se usaran. Es importante notar en caso de escribir las funciones después del main, es necesario declararlas.

 

TWI_config(100000);

 

Se llama a la función TWI_config con la entrada 1000000 que será la frecuencia del microcontrolador, más adelante se explicara esta función.


i2c_transmit(0xE0,0,0x51);

_delay_ms(75);

valor = i2c_read(0xE0,3);

PORTD = valor;

_delay_ms(100);

 

Se puede ver en esta sección de código que se transmite por el I2C, y se lee el dato el cual se muestra a través del puerto D. las funciones de transmitir y de leer se explican a continuación.

 

void TWI_config(unsigned long int frecuencia)

{

TWBR = ((Clock/frecuencia) - 16)/8;

TWSR=(0<<TWPS1)+(0<<TWPS0);

}

 

twbr

 

El TWBR selecciona el factor de división de la frecuencia del SCL en modo maestro

 

scl i2c

 

Al registro de estado TWSR se le está escribiendo la instrucción (0<<TWPS1)+(0<<TWPS0); la cual nos indica que a los bits TWPS1 y TWPS0 se les está asignando un 0 a cada uno, esto es, para corroborar que se está usando una preescala de 1.

 

twi bit rate

 

char i2c_read(char address, char reg)

{

char read_data = 0;

TWCR = 0xA4;                                              // Mandar el bit de inicio para el bus I2C

while(!(TWCR & 0x80));                                // Esperando la confirmación

TWDR = address;                                          // Cargar dirección (adress) en el dispositivo

TWCR = 0x84;                                              // Transmitir

while(!(TWCR & 0x80));                                // Esperar confirmación de la transmisión

TWDR = reg;                                                // Enviar número de registro a leer

TWCR = 0x84;                                             // Transmitir

while(!(TWCR & 0x80));                               // Esperar confirmación de la transmisión


TWCR = 0xA4;                                             // Volver a mandar un bit de inicio

while(!(TWCR & 0x80));                               // Esperar confirmación de la transmisión

TWDR = address+1;                                    // Transmitir dirección por I2C con la lectura habilitada

TWCR = 0xC4;                                             // Borrar la bandera de interrupción de transmisión

while(!(TWCR & 0x80));                               // Esperar confirmación de la transmisión

TWCR = 0x84;                                             // Transmitir, nack (Solicitud del último byte)

while(!(TWCR & 0x80));                               // Esperar confirmación de la transmisión

read_data = TWDR;                                     // Tomar el dato

TWCR = 0x94;                                             // Mandar un bit de paro al bus I2C

return read_data;

}

 

La función i2c_read, lee el dato que manda el sensor, entre las cosas a destacar en esta función son el uso del registro TWCR y del TWDR:

 

twdr twcr

 

El TWCR se usa para controlar la operación del TWI. En él se habilita el TWI, se inicializa el acceso con la condición de inicio, genera una condición de paro, entre otras cosas

 

En modo de transmisión, el TWDR contiene el siguiente byte para ser transmitido, y en modo de recepción contiene el ultimo byte en ser recibido.

Dentro del la funcion i2c_read se encuentran varias instrucciones importantes las cuales son:

 

TWCR = 0xA4;

Esta instrucción nos indica que los bits 2, 5 y 7 los cuales son TWEN, TWSTA y TWINT respectivamente, del registro TWCR están habilitados.

TWEN: Habilita y activa la comunicación TWI (I2C).

TWSTA: Al habilitarlo, se configura el TWI del microcontrolador como modo maestro.

TWINT: Al escribirle un 1 lógico, se limpia la bandera de interrupción.

 

while(!(TWCR & 0x80));

El 0x80 en el TWCR corresponde a la bandera del bit TWINT, el ciclo espera a la bandera de confirmación.

 

TWDR = address;

Se le asigna la variable address, la cual, como se puede ver en el código, tiene el valor de 0xE0. Este valor es la dirección del dispositivo con el que se está comunicando. En este caso el sensor ultrasónico responde a la dirección 0xE0

 

TWCR = 0x84;

Se limpia la bandera y habilita la comunicación.

 

TWDR = reg;

Envía el registro a leer en el TWDR, en este caso la variable reg es igual a 3 lo que en el sensor indica el ajuste de la ganancia analógica máxima a 103. La finalidad de poder limitar la ganancia máxima es permitirle iniciar mediciones a una frecuencia mayor de 65mS.


read_data = TWDR;

 

Toma el dato y lo coloca en la variable read_data

 

TWCR = 0x94;

Manda un bit de paro, activando también el TWSTO Stop Condition Bit.


void i2c_transmit(char address, char reg, char data)

{

TWCR = 0xA4;                                                  // Mandar el bit de inicio para el bus I2C

while(!(TWCR & 0x80));                                    // Esperar confirmación de la transmisión

TWDR = address;                                             // Cargar dirección (adress) en el dispositivo

TWCR = 0x84;                                                 // Transmitir

while(!(TWCR & 0x80));                                   // Esperar confirmación de la transmisión

TWDR = reg;

TWCR = 0x84;                                                // Transmitir

while(!(TWCR & 0x80));                                  // Esperar confirmación de la transmisión

TWDR = data;

TWCR = 0x84;                                                // Transmitir

while(!(TWCR & 0x80));                                  // Esperar confirmación de la transmisión

TWCR = 0x94; // Mandar un bit de paro al bus I2C

}

 

Las instrucciones de la función para transmitir como podemos ver son casi las mismas que para la función leer, pero no perdamos de vista que al mandar llamar cada función se le asignan distintos valores, entre las principales instrucciones a destacar se encuentran:

 

TWDR = reg;

 

A diferencia de la función read, el registro en este caso tiene un valor de 0 el cual le indica al sensor que inicie la sesión de cálculo de la distancia.

 

TWDR = data;

Se puede ver en el main que a la variable data, se le asigna un 0x51 el cual le indica al sensor que trabaje en modo de cálculo de distancia y este nos da un resultado en centímetros.

Última actualización el Jueves 26 de Mayo de 2011 23:47