22 may 2011

COMUNICACIÓN ENTRE UN PCF8591 EN MODO CONVERSOR DIGITAL/ANALÓGICO (DAC) POR I2C Y UN PIC18F4550


Este ejercicio consiste en la programación de un conversor PCF8591 configurado atraves del PIC18F4550  para que funcione como un conversor DIGITAL/ANALÓGICO utilizando el BUS I2C.

Si leemos las características que nos da el fabricante veremos que para trabajar con el BUS I2C es necesario enviar en Byte la dirección válida del dispositivo.

Esta dirección consta de una parte fija (1001) y una parte programable pertenece a los pines A0A1 y A2 que son las entradas analógicas. Y luego tenemos el último Byte para la configuración de lectura o escritura. Esta dirección debe ser enviada como primer byte justo después de la condición de arranque del protocolo I2C {i2c_start()}.

El segundo Byte que mandamos seria “0100000“, ya que el primer bites fijo y la salida sera analogica. El resto de los  bits los podemos dejar en 0 puesto que no los vamos a utilizar.




////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//   AUTOR: Clara Alonso Fernández              Mayo/2011 //////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//   PROGRAMA:       Conversor Digital-Analógico//////////////////////////////////////////
//   DISPOSITIVO:    PIC 18F4550               COMPILADOR:  CCS 4.068//
//   Entorno IDE:                              SIMULADOR:   ISIS Proteus 7.7 sp2  //
//   TARJETA DE APLICACIÓN: Virtual            DEBUGGER:                   //
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//   CABECERA ////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
#include <18F4550.h>                //PIC que vamos a utilizar.
#fuses INTHS                             //Configurar de los fusibles.
#use delay(internal=8mhz,RESTART_WDT)      //Configuración de la velocidad del oscilador.
#use i2c(Master,sda=PIN_B0,scl=PIN_B1,restart_wdt)    //Configuración para el I2C.
#include <lcd.c>                        //Libreria para el LCD.
#use fast_io(a)
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// VARIABLES GLOBALES /////////////////////////////////////////////////////////////////////
int tension=0;
float a;
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// FUNCIONES ////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// PRINCIPAL //////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void main()
{
   lcd_init();                     //Inicialización del LCD.
   lcd_putc('\f');               //Limpia la pantalla.
   lcd_gotoxy(1,1);
                                     // Declaro variable entera (analógico) y la inicializo a 0.
   i2c_start();                  // Inicio la comunicación I2C.
   delay_ms(20);            // Retardo de 20 mseg.
   i2c_write(0b10010000);   // Configuración para el I2C.
   delay_ms(20);            // Retardo de 20 mseg.
   i2c_write(0b01000000);   // Configuración para que el funcionamiento sea de conversor digital-analógico.
   delay_ms(20);            // Retardo de 20 mseg.
   do
   {
      if((input(pin_a0)==1)&&(tension<255))  //Condición SI pulso aumentar y es menor que 255.
      {
          i2c_write(tension);              
          tension++;                              // Incremento la variable 'analógico'.
          delay_ms(20);                        // Retardo de 20 mseg.
      }
     if((input(pin_a0)==0)&&(tension>0))     //Condición SI pulso decrementar y es mayor que 0.
      {
          i2c_write(tension);                
          tension--;                               // Incremento la variable 'analógico'.
          delay_ms(20);                        // Retardo de 20 mseg.
      }
      lcd_gotoxy(1,1);                       //Coloca el cursor en la posición 1,1 dentro de la pantalla del lcd.
      a=tension*0.01945098;           //Convierte en tensión.
      printf(lcd_putc,"V-->%2.3lfV",a);   //Visualiza en el lcd la tensión.
   }
   while(true);                                //El bucle se repite constantemente.
}

Después paramos a realizar la simulación en PROTEUS:


En la siguiente imagen podemos ver el primer Byte de dirección y el segundo byte de configuración:


Después paramos al ARES para colocar los componentes y dar forma a la placa:


Y las siguientes imágenes muestran el diseño de la placa en 3D para hacernos una idea de su forma real:



Aquí os dejo un enlace para que os podáis descargar el ejercicio: http://cid-64f7131e50857260.office.live.com/self.aspx/DAC/DAC.rar






COMUNICACIÓN ENTRE UN PCF8591 EN MODO CONVERSOR ANALÓGICO DIGITAL (CAD) POR I2C Y UN PIC18F4550



Este ejercicio consiste en la programación de un conversor PCF8591 configurado atraves del PIC18F4550  para que funcione como un conversor ANALÓGICO/DIGITAL utilizando el BUS I2C.

Si leemos las características que nos da el fabricante veremos que para trabajar con el BUS I2C es necesario enviar en Byte la dirección válida del dispositivo.

Esta dirección consta de una parte fija (1001) y una parte programable pertenece a los pines A0, A1 y A2 que son las entradas analógicas. Y luego tenemos el último Byte para la configuración de lectura o escritura. Esta dirección debe ser enviada como primer byte justo después de la condición de arranque del protocolo I2C {i2c_start()}.

El segundo Byte que mandamos se almacena en el registro de control para controlar el dispositivo.

Una vez leídas y entendidas las características del fabricante ya podemos realizar el código:

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//   AUTOR: Clara Alonso Fernández                         Mayo 2011
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//   PROGRAMA: Conversor analogico/digital (I2C) VERSIÓN:    1.0
//   DISPOSITIVO: PIC18F4550                 COMPILADOR: PCWHC Compiler v4,093
//   Entorno IDE:                            SIMULADOR:  Proteus 7.7
//   TARJETA DE APLICACIÓN: Virtual          DEBUGGER:
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//   Comunicacion entre un PIC 18f4550 y un PCF8591 modo
//   Conversor Analogico Digital por I2C                             ///////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// CABECERA /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
#include <18F4550.h>           //PIC que se va a utilizar.          
#fuses INTHS                        //Configuración para los fusibles.                 
#use delay(internal=8mhz,RESTART_WDT)    //Configuración de la velocidad del oscilador.
#use i2c(Master,sda=PIN_B0,scl=PIN_B1,restart_wdt)    //Configuración para el I2C.
#include <LCD_flexible.c>       //Librería para el LCD.

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// VARIABLES GLOBALES //////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
float lectura;
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// FUNCIONES ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// PRINCIPAL ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void main()
{
lcd_init();               //Inicializa el LCD.
lcd_putc("Conversor ANALOGICO/DIGITAL");   //Muestra en e LCD el mensaje.
i2c_start();           // Inicio la comunicación I2C.
i2c_write(0b10010000); // Envío Dirección I2C del dispositivo.
delay_ms(10);      //Retardo de 10 mseg.
i2c_write(0b00000011); //Configuración para que funcione como conversor A/D por AIN0.
delay_ms(10);      //Retarde de 20 mseg.
i2c_start();           // Inicio la comunicación I2C.
i2c_write(0b10011001); // Envío Dirección I2C del dispositivo.
for(;;)
{
lcd_gotoxy(1,2);  //Coloca el cursor en la posición (1,2).
lectura=i2c_read();
lectura=(lectura*5.0)/256.0; //Conversion de 8 bits 
printf(lcd_putc,"I2C:%f V ",lectura); //Mostrar el dato en el LD.
}
}


Una vez hecho el código pasaremos a la simulación en PROTEUS: 


En las siguientes imágenes se muestran el primer Byte y el valor del potenciometro:


Una vez realizado el diseño en el ISIS, pasaremos al ARES para la colocación de los componentes y del cableado de la placa:


Esta es la vista 3D que nos ayuda a hacernos una idea de como quedará la placa en la realidad:




Aquí os dejo un enlace para que os podáis descargar el programa: http://cid-64f7131e50857260.office.live.com/self.aspx/CAD/CAD.rar







8 may 2011

COMUNICACIÓN SPI ENTRE DOS PIC's 18F4550


Este ejercicio consiste en la comunicación de dos pic's 18f4550 mediante el bus SPI. Uno de los pic's funcionará como maestro y el otro como esclavo, y lo que harán será encender y apagar un LED.

Primero realizamos el código para el maestro por ejemplo.


/////////////////////////////////////////////////////////////////////////////////////
//   AUTOR: Clara Alonso Fernández                        Mayo/2011
/////////////////////////////////////////////////////////////////////////////////////
//   PROGRAMA:   Comunicación entre PICs                   VERSIÓN:    1.0
//   DISPOSITIVO: PIC18F4550                               COMPILADOR: CCS vs4.93
//   Entorno IDE:                                          SIMULADOR:  Proteus 7.7 sp2
//   TARJETA DE APLICACIÓN:                                DEBUGGER:
/////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////

/////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////
//CABECERA///////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////
#include <18f4550.h>                 //Es el pic que se va a utilizar.
#fuses inths                         //Configuración para el oscilador interno.
#use delay(internal=8Mhz)           //Configuracion para la frecuencia del oscilador.

/////////////////////////////////////////////////////////////////////////////////////
//VARIABLES GLOBALES////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////
//FUNCIONES/////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////
//PRINCIPAL/////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////
void main( )
{
   setup_spi(spi_master | spi_l_to_h | spi_clk_div_16);    //Configurar spi para que el pic funcione como maestro.
   while(1)
   {
      spi_write(input(pin_a1));              //Escribir en el pin ra1
      delay_ms(1000);
   }
}

Luego hacer el código del esclavo.

/////////////////////////////////////////////////////////////////////////////////////
//   AUTOR: Clara Alonso                     Mayo/2011 
/////////////////////////////////////////////////////////////////////////////////////
//   PROGRAMA:Comunicación entre PICs                     VERSIÓN:1.0
//   DISPOSITIVO:PIC18F4550                                COMPILADOR: CCS vs4.93
//   Entorno IDE:                                          SIMULADOR:Proteus 7.7 sp2
//   TARJETA DE APLICACIÓN:                                DEBUGGER:  
/////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////
//CABECERA///////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////
#include <18f4550.h>                  //Es el pic que se va a utilizar.
#fuses inths                          //Configuración pra el oscilador interno.
#use delay(internal=8Mhz)             //Configuración para la frecuencia del oscilador.
/////////////////////////////////////////////////////////////////////////////////////
//VARIABLES GLOBALES////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////
//FUNCIONES/////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////
//PRINCIPAL/////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////
void main()
{
   setup_spi(spi_slave | spi_l_to_h | spi_clk_div_16);     //Configurar spi para que el pic fincione como esclavo.
   for(;;)
   {
      if(spi_data_is_in())      //Si hay un dato en el spi.
      {       
         output_c(spi_read()); 
      }
   }
}

Seguidamente realizaremos el esquemático con PROTEUS que quedará así:


Luego debemos hacer la PCB en el ARES utilizando el "autorute" para cablear la placa.


Y para ver la PCB lo mas real posible utilizamos la herramienta  "output 3D" y asi verlo en 3D.



Aquí os dejo un enlace para que podáis descargaros los códigos y el esquemático: http://cid-64f7131e50857260.office.live.com/self.aspx/COMUNICACI%C3%93N%20SPI%20ENTRE%20DOS%20PIC%5E4s%2018F4550/M-E.rar

SENSOR DE TEMPERATURA TC77 CON MÓDULO SPI



La finalidad de este ejercicio es la medición de la temperatura con el sensor TC77, utilizando el bus SPI para la comunicación entre el sensor y el PIC18F4550.

Lo primero que hay que hacer es mirar en el datasheet para saber la configuración del sensor. Una vez estudiado la configuración y el funcionamiento del TC77 comenzaremos a  realizar el código para la visualización de la temperatura en el LCD.


////////////////////////////////////////////////////////////////////////////////////
//   AUTOR: Clara Alonso Fernández                      Abril/2011
////////////////////////////////////////////////////////////////////////////////////
//   PROGRAMA:   LEER Tº DEL TC77                       VERSIÓN:    1.0
//   DISPOSITIVO: PIC18F4550                            COMPILADOR: CCS vs4.088
//   Entorno IDE: MPLAB 8.56                            SIMULADOR:  Proteus 7.7 sp2
//   TARJETA DE APLICACIÓN: virtual                     DEBUGGER: virtual 
////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////
//                       LEER LA Tº DEL SENSOR TC77 
////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////
// CABECERA ////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////
#include <18F4550.h>
#fuses INTHS            //Selecciona el oscilador interno
#use delay(internal=8Mhz)   // Selecciona la velocidad del oscilador interno
#include <LCD.c>
////////////////////////////////////////////////////////////////////////////////////
// VARIABLES GLOBALES //////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////
// FUNCIONES ///////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////
// PRINCIPAL ///////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////
void main()
{
long int parte_entera;
long int parte_decimal;
int temp_H;
int temp_L;
setup_spi(spi_MASTER | spi_L_to_H | spi_clk_div_16| SPI_XMIT_L_TO_H);
 lcd_init();
 lcd_putc('\f'); //Borra pantalla
 lcd_gotoxy(1,1);
//Secuencia para leer el Fabricante-----------------------------------------
//1º.- CS goes low to initiate the communication cycle. 
output_low(PIN_A0);
//2º.- Read 16 bits of temperature data from the Temperature register
spi_read(0); 
spi_read(0);
//3º.- Write 16 bits of data (i.e. XXFF hex) to the Configuration register to enter Shutdown mode. 
spi_write(0xff); 
spi_write(0xff);
//4º.- Read the 16 bits from the Manufacturer's ID register   (C15:C8 = 54 hex) 
//     to verify that the sensor is a Microchip device.
spi_read(0); 
spi_read(0); 
//5º.- Write 8 to 16 bits of data (00 or 0000 hex) to enter Continuous Conversion Mode.
spi_write(0x0);
spi_write(0x0); 
//6º.- Return CS high to terminate the communication cycle.
output_high(PIN_A0);
delay_ms(500); //Retardo para que al sensor le de tiempo a actualizar su registro de temperatura
 for (;;)
{
parte_entera=0;
parte_decimal=0;
output_low(PIN_A0);
//Leo el byte alto y bajo del registro de temperatura y sumo el peso de cada bit. El resultado
//lo guardo en las variables "parte_entera" y "parte_decimal"
temp_H=spi_read(0x00);
 if(bit_test(temp_H,6)){parte_entera=parte_entera+128.0;} 
if(bit_test(temp_H,5)){parte_entera=parte_entera+64.0;} 
if(bit_test(temp_H,4)){parte_entera=parte_entera+32.0;} 
if(bit_test(temp_H,3)){parte_entera=parte_entera+16.0;} 
if(bit_test(temp_H,2)){parte_entera=parte_entera+8.0;} 
if(bit_test(temp_H,1)){parte_entera=parte_entera+4.0;} 
if(bit_test(temp_H,0)){parte_entera=parte_entera+2.0;} 
temp_L=spi_read(0x00); //En proteus, esta lectura sale como ?? porque los
  //dos bits de menor peso quedan indefinidos
if(bit_test(temp_L,7)){parte_entera=parte_entera+1.0;} 
if(bit_test(temp_L,6)){parte_decimal=parte_decimal+500;} 
if(bit_test(temp_L,5)){parte_decimal=parte_decimal+250;} 
if(bit_test(temp_L,4)){parte_decimal=parte_decimal+125;} 
output_high(PIN_A0);
delay_ms(100);
lcd_gotoxy(1,1);
//Si el nº es negativo
//le resto 2^9 para encontrar el nº que representa la parte entera.
//(nº+)-(2^n)=(nº-)El nº positivo menos 2^n es igual al nº negativo, en C2, que representa
//La variable de la parte decimal contiene el complemento de las 3 cifras. Es decir, si la temperatura es 4,625ºC
//la variable contiene 275. Por ello, restamos 1000-parte_decimal y obtenemos el valor real.
if(bit_test(temp_H,7)) 
   {
   parte_entera=511-(parte_entera+256);                  
   printf(lcd_putc,"VOLTIOS=-%3lu",parte_entera);
   parte_decimal=1000-parte_decimal;   
   printf(lcd_putc,".%3luC",parte_decimal);
   }
//Si el nº es positivo no hago nada y muestro el contenido de las variables   
else{
   printf(lcd_putc,"VOLTIOS=%3lu",parte_entera);
   printf(lcd_putc,".%3luC",parte_decimal);   
   }   
 }
}

Una vez hecho el código pasaremos a realizar el esquemático con la ayuda del simulador de PROTEUS. El esquemático consta del PIC18F4550, de el sensor TC77, de una pantalla LCD y de un módulo SPI.
Os voy a mostrar cómo quedaría el esquemático.


El siguiente paso es realizar la PCB en el ares. Yo utilizo el "autoruter" para cablear más rápido.


Y si queremos también podemos ver la PCB en 3D con la herramienta "output 3D", que nos ayudará a hacernos una idea de como es la PCB de forma real.




Aquí os dejo un enlace con  el código, el esquemático y el datasheet: http://cid-64f7131e50857260.office.live.com/self.aspx/MEDIDOR%20TEMPERATURA%20TC77/TC77.rar


25 mar 2011

SENSORES DEL ROBOT DE LEGO


A continuación se explicarán los tipos de sensores de los que consta nuestro robot de Lego y la consola central.

  • La consola central es el cerebro del robot. En la consola cargamos los programas realizados con el Labview mediante el cable USB y se quedan guardados en la memoria.

  • El siguiente sensor es el bumper. Este sensor detecta choque y también se puede utilizar como pulsador.
  • Este otro sensor es el ultrasónico. Detecta objetos a una cierta distancia y también detecta sonidos.


  • Y por último tenemos el sensor de luz. Este sensor detecta colores a una distancia de 1 centímetro como máximo y también funciona como lámpara con luz azul, roja o verde.










Twitter Delicious Facebook Digg Stumbleupon Favorites More

 
Design by Free WordPress Themes | Bloggerized by Lasantha - Premium Blogger Themes Powered by Blogger | DSW printable coupons