Conversor digital analógico (DAC) I2C

La finalidad de este ejercicio es, usando el protocolo I2C, comunicar un pic 18F4550 con el conversor PCF8591 para así poder realizar una conversión digital- analógica.

Lo primero que debemos tener en cuenta para la realización del ejercicio es como tenemos que configurar el componente para que realice la comunicación I2C correctamente.

Como siempre nos vamos a guiar del datasheet del PCF8591. Cuando sepamos como configurarlo para que realice la comunicación I2C es hora de diseñar y montar el circuito en cuestión.

Colocamos el pic que vamos a utilizar, en este caso el 18F4550, el conversor (PCF8591), y un lcd para poder observar la tensión que hay en cada momento.

El código que hemos utilizado es el siguiente:

////////////////////////////////////////////////////////////////////////////////////
//   AUTOR: Diego Lavín Fernández                                               
////////////////////////////////////////////////////////////////////////////////////
//   PROGRAMA:       Conversor Digital-Analógico                                 
//   DISPOSITIVO:    PIC18F4550               COMPILADOR:  CCS 4.                
//   Entorno IDE:                              SIMULADOR:  Proteus 7.7 sp2       
//   TARJETA DE APLICACIÓN:                    DEBUGGER:                         
////////////////////////////////////////////////////////////////////////////////////
//Comunicación entre PIC 18F4550 y PCF8591  mediante protocolo I2C                  
////////////////////////////////////////////////////////////////////////////////////
//   CABECERA //////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////
#include <18F4550.h>                     //librería pic
#fuses INTHS
#use delay(internal=8mhz,RESTART_WDT)
#use i2c(Master,sda=PIN_B0,scl=PIN_B1,restart_wdt)
#include                            //librería lcd
///////////////////////////////////////////////////////////////////////////////
// VARIABLES GLOBALES /////////////////////////////////////////////////////////
int tension=0;
float a;
///////////////////////////////////////////////////////////////////////////////
// FUNCIONES //////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
// PRINCIPAL //////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
void main()
{
   lcd_init();
   lcd_putc('\f');
   lcd_gotoxy(1,1);
          
   i2c_start();            
   delay_ms(20);           
   i2c_write(0b10010000);   // direcciono para escritura
   delay_ms(20);           
   i2c_write(0b01000000);   // Configuro en modo conversor digital-analógico
   delay_ms(20);          
   do
   {
      if((input(pin_a0)==1)&&(tension<400))     //si pulso aumentar y es menor que 500
      {
          i2c_write(tension);               
          tension++;                           // Incremento la variable
          delay_ms(20);                       
      }
  
      lcd_gotoxy(1,1);                   
      a=tension*0.01945098;              //convierto en tensión
      printf(lcd_putc,"V=%2.3lfV",a);   
   }
   while(1);                          
}

Una vez hecho el código lo compilamos para asegurarnos que no existe ningún error y lo insertamos en el pic. Si todo ha ido bien el conversor estará funcionando como en la imagen que se muestra a continuación:

Ahora podemos crear el layout con el Ares y ver como quedaría en 3d.

Puede ser que al abrir el Ares nos de problemas con los packages de los componentes, esto se debe a que en proteus debemos indicar en propiedades el tipo de encapsulado que queremos.

Medidor de temperatura TC77 con SPI

En este ejercicio, debemos leer la temperatura mediante un TC77 utilizando la comunicación SPI y un PIC18F4550. Se mostrará la temperatura en un lcd.

Antes de nada debemos estudiar el funcionamiento del TC77, para ello vamos al datasheet.
Una vez tengamos las cosas mas claras es hora de pasar a programar el pic, con el Pic c Compiler, como hasta ahora.

//////////////////////////////////////////////////////////////////////////////
//   AUTOR: Diego Lavín Fernández                         Abril-2011      //
//////////////////////////////////////////////////////////////////////////////
//   PROGRAMA:   LEER TEMPERATURA DE UN TC77     VERSIÓN:   
//   DISPOSITIVO: PIC18F4550                     COMPILADOR: CCS vs4.93
//   Entorno IDE:                                SIMULADOR:  Proteus 7.7 sp2
//   TARJETA DE APLICACIÓN:                      DEBUGGER:   
//////////////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////////////////
//Leer temperatura desde tc77                                         //
//////////////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////////////////
// CABECERA //////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////
#include <18F4550.h>
#fuses INTHS                //oscilador interno
#use delay(internal=8Mhz)  
#include

//////////////////////////////////////////////////////////////////////////////
// VARIABLES GLOBALES ////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////
long int a,b;
int th,tl;

//////////////////////////////////////////////////////////////////////////////
// FUNCIONES /////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////////////////
// PRINCIPAL /////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////
void main(void)
{
   setup_spi(spi_master | spi_l_to_h | spi_clk_div_16);           //configurar spi como maestro
   lcd_init();                                                    //iniciar lcd
   lcd_gotoxy(1,1);                                               //cursor lcd a posicion 1,1
   lcd_putc("Temperatura:");                                      //escribe en lcd
  
   for (;;)
   {
      a=0;
      b=0;
     
      output_low(pin_a0);                                         //habilito cs
      th=spi_read(0x00);                                          //leo valor de th
      
      if(bit_test(th,6)){a=a+128.0;}
      if(bit_test(th,5)){a=a+64.0;}
      if(bit_test(th,4)){a=a+32.0;}
      if(bit_test(th,3)){a=a+16.0;}
      if(bit_test(th,2)){a=a+8.0;}
      if(bit_test(th,1)){a=a+4.0;}
      if(bit_test(th,0)){a=a+2.0;}
     
      tl=spi_read(0x00);
      if(bit_test(tl,7)){a=a+1.0;}
      if(bit_test(tl,6)){b=b+500;}
      if(bit_test(tl,5)){b=b+250;}
      if(bit_test(tl,4)){b=b+125;}
                          
      output_high(pin_a0);
      delay_ms(100);
     
      lcd_gotoxy(1,2);
      if(bit_test(th,7))
         {
         a=511-(a+256);                 
         printf(lcd_putc,"-%lu",a);
        
         b=1000-b;  
         }
      else{
         printf(lcd_putc,"%lu",a);
         }
      printf(lcd_putc,".%lu ",b);
  
 }
}   

Cuando finalicemos, hay que montar el circuito en Proteus y comprobar que la temperatura que marca el TC77 es igual a la que se nos muestra por el lcd (milésimas arriba o abajo, ya que cuanto más preciso lo querramos, mas largo se hace el programa).

También hay que comprobar que en el SPI debugger esté actuando correctamente y que envíe los datos que debe enviar.

Cuando comprobemos que todo está bien, vamos al Ares y creamos nuestra placa:

Vista en 3d:

Para descargar los archivos: AQUI

EEPROM SPI

El ejercicio consiste en escribir y leer de una eeprom 25LC020, que está disponible en Proteus, utilizando el bus SPI. Todo ello utilizando el PIC18F4550.


Empezaremos haciendo el código en C (Pic c Compiler).
Hay comentarios para aclarar las distintas funciones que se utilizan:

///////////////////////////////////////////////////////////////////////////////
//   AUTOR: Diego Lavín                       Abril/2011
//////////////////////////////////////////////////////////////////////////////
//   PROGRAMA:Escribir en eeprom             VERSIÓN:    1.0
//   DISPOSITIVO: PIC 18F4550                   COMPILADOR: Pic c Compiler 4,093
//   Entorno IDE:                                         SIMULADOR:  Proteus 7.7 sp2
//   TARJETA DE APLICACIÓN:                    DEBUGGER:   
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
//Escribir en una eeprom con el PIC 18F4550 utilizando el bus SPI.
//Se mostrará en un lcd los datos escritos y los que ha leido.
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
// CABECERA ///////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
#include <18F4550.h>
#fuses inths                 //oscilador interno
#use delay(internal=8Mhz)  
#include
///////////////////////////////////////////////////////////////////////////////
// VARIABLES GLOBALES /////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
int a,b;
///////////////////////////////////////////////////////////////////////////////
// FUNCIONES //////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
// PRINCIPAL //////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
void main()
{
                          
   setup_spi(spi_master | spi_l_to_h | spi_clk_div_16);     //spi como maestro
   lcd_init();                                              //iniciar lcd
   do{
      output_low(pin_a0);              //habilita cs
      lcd_putc("\fEscribe\n ");        //escribe en lcd
      for(a=0x00;a<=0x09;a++)          //cuenta desde 0 a 9
   {                               
         spi_write(a);                 //escribe el valor de a       
         printf(lcd_putc,"%u",a);      //muestra el valor de a por lcd
         delay_ms(200);               
   }
      output_high(pin_a0);             //deshabilita cs
      delay_ms(1500);          
      lcd_putc("\fLee\n ");            //escribe en lcd
      output_low(pin_a0);              //habilita cs
      spi_read(0x03);                  //configurar lectura
      spi_read(0x00);                  //lee desde la posicion 0
      for(b=0x00;b<=0x09;b++)          //desde la 0 hasta la 9
   {       
         a=(spi_read(b));              //lee el puerto b
         printf(lcd_putc,"%u",a);      //escribe el valor de a
         delay_ms(200);                 
   }                                  
  
      output_high(pin_a0);             //deshabilita cs
      delay_ms(2000);
}while(1);
} 

Ahora nos queda relizar el esquemático con Proteus

Así queda el circuito con todos sus componentes, ahora vamos a ver el funcionamiento del programa en sí.

Podemos ver como escribimos y leemos, en este caso una secuencia de 0-9 como se programó en C. 
Lo que se muestra por el LCD es lo mismo que muestra la eeprom.

Para descargar el ejercicio: AQUI