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.

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

Comunicación SPI entre PIC´s

En este ejercicio vamos a comunicar dos PIC18F4550, utilizando el bus SPI (Serial Peripheral Interface). 
Como en el ejercicio anterior vamos a utilizar el CCS C para programar y compilar en C y el Proteus 7.7 sp2 para simular el circuito. Finalmente usaremos el Ares para diseñar el pcb y ver como quedaría finalmente.

En este caso existen dos PIC´s, por lo que tendrá que haber dos progrmas distintos, uno para cada pic. El primero actuará como maestro que se encargará de mandar un dato al otro pic, el esclavo que leerá el dato.

En la imagen se ve como en el primer pic (maestro) hay un switch y en el segundo (esclavo) hay un diodo led rojo, el otro símplemente es de prueba. Cuando el switch está activado se enciende el led, por lo que está habiendo una comunicación entre pic´s.

El código del maestro, en el que configuro el pic como maestro para el uso del SPI y escribo en un pin:

/////////////////////////////////////////////////////////////////////////////////////

//   AUTOR: Diego Lavín                        Febrero/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:  

/////////////////////////////////////////////////////////////////////////////////////

/////////////////////////////////////////////////////////////////////////////////////

//Comunicar 2 PICs 18F4550 utilizando el protocolo SPI. Cuando hay un "1" lógico
//en el pin ra1 se enciende un diodo led.

//

/////////////////////////////////////////////////////////////////////////////////////

/////////////////////////////////////////////////////////////////////////////////////

//CABECERA///////////////////////////////////////////////////////////////

/////////////////////////////////////////////////////////////////////////////////////

#include < 18f4550.h>                  //pic a utilizar
#fuses inths                                    //oscilador interno
#use delay(internal=8Mhz)           //frecuencia del oscilador

/////////////////////////////////////////////////////////////////////////////////////

//VARIABLES GLOBALES////////////////////////////////////////

/////////////////////////////////////////////////////////////////////////////////////

/////////////////////////////////////////////////////////////////////////////////////

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

/////////////////////////////////////////////////////////////////////////////////////

/////////////////////////////////////////////////////////////////////////////////////

//PRINCIPAL/////////////////////////////////////////////////////////////

/////////////////////////////////////////////////////////////////////////////////////
void main( )
{
   setup_spi(spi_master | spi_l_to_h | spi_clk_div_16);    //configurar spi como maestro
   while(1)
   {
    //  spi_write(input(pin_a0));    //escribir en el pin ra0
      spi_write(input(pin_a1));    //escribir en el pin ra1
      delay_ms(1000);
   }
} 

Código del esclavo, aquí configuro el pic como esclavo y leo continuamente si hay dato en el SPI y si le hay que active el puerto c como salida:

/////////////////////////////////////////////////////////////////////////////////////

//   AUTOR: Diego Lavín                        Febrero/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:  

/////////////////////////////////////////////////////////////////////////////////////

/////////////////////////////////////////////////////////////////////////////////////

//Comunicar 2 PICs 18F4550 utilizando el protocolo SPI. Cuando hay un "1" lógico
//en el pin ra1 se enciende un diodo led.

//

/////////////////////////////////////////////////////////////////////////////////////

/////////////////////////////////////////////////////////////////////////////////////

//CABECERA///////////////////////////////////////////////////////////////

/////////////////////////////////////////////////////////////////////////////////////

#include < 18f4550.h>                  //pic a utilizar
#fuses inths                                    //oscilador interno
#use delay(internal=8Mhz)           //frecuencia del oscilador

/////////////////////////////////////////////////////////////////////////////////////

//VARIABLES GLOBALES////////////////////////////////////////

/////////////////////////////////////////////////////////////////////////////////////

/////////////////////////////////////////////////////////////////////////////////////

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

/////////////////////////////////////////////////////////////////////////////////////

/////////////////////////////////////////////////////////////////////////////////////

//PRINCIPAL/////////////////////////////////////////////////////////////

/////////////////////////////////////////////////////////////////////////////////////
void main()
{
   setup_spi(spi_slave | spi_l_to_h | spi_clk_div_16);     //configurar spi como esclavo
   for(;;)
   {
      if(spi_data_is_in())      //si hay un dato en el spi
      {      
         //output_d(spi_read()); 
         output_c(spi_read());
      }
   }
}

Vista en Ares y como dije anteriormente cuidado con los packages de los componentes porque pueden faltar al no haber sido asignados en el Proteus o porque no existe package de ese componente:

3D:

DESCARGA EL EJERCICIO

LCD gráfico y PIC18F4550

En esta práctica vamos a utilizar un LCD gráfico, el cual será controlado por un PIC18F4550. La programación la llevaremos a cabo con el CCS C Compiler y la posterior simulación será realizada con Proteus (7.7 sp2).

 

En Proteus podeis encontrar varios tipos de LCD gráfico pero en mi caso he utilizado el LGM12641BS1R.

Ahora vamos a empezar con la programación del PIC, para ello debemos de crear un nuevo proyecto desde el CCS C y empezar con la programación en sí.

El código programado en el PIC es el siguiente:

/////////////////////////////////////////////////////////////////////////////////////

//   AUTOR: Diego Lavín                        Febrero/2011 

/////////////////////////////////////////////////////////////////////////////////////

//   PROGRAMA:   LCD Gráfico                    VERSIÓN:    1.0
//   DISPOSITIVO: PIC18F4550                   COMPILADOR: CCS vs4.93
//   Entorno IDE:                                              SIMULADOR:  Proteus 7.7 sp2
//   TARJETA DE APLICACIÓN:                  DEBUGGER:  

/////////////////////////////////////////////////////////////////////////////////////

/////////////////////////////////////////////////////////////////////////////////////

//Muestra distintos caracteres por un lcd gráfico

//

/////////////////////////////////////////////////////////////////////////////////////

/////////////////////////////////////////////////////////////////////////////////////

//CABECERA///////////////////////////////////////////////////////////////

/////////////////////////////////////////////////////////////////////////////////////

#include <18F4550.h>
#fuses inths                               //oscilador interno
#use delay(internal=8Mhz)      //frecuencia del oscilador
#include < hdm64gs12.c>        //drivers lcd
#include < graphics.c>         //contiene funciones para dibujar círculos, lineas...

/////////////////////////////////////////////////////////////////////////////////////

//VARIABLES GLOBALES////////////////////////////////////////

/////////////////////////////////////////////////////////////////////////////////////

char voltext[ ]="Diego";       //introduzco variables para introducir texto
char voltext3[ ]="Lavin";
char voltext2[ ]="2011";

/////////////////////////////////////////////////////////////////////////////////////

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

/////////////////////////////////////////////////////////////////////////////////////

/////////////////////////////////////////////////////////////////////////////////////

//PRINCIPAL/////////////////////////////////////////////////////////////

/////////////////////////////////////////////////////////////////////////////////////

void main( )
{
   glcd_init(on);                                         //enciende lcd
   glcd_line(20,47,80,53,on);                    //dibuja una linea
   glcd_rect(100,5,120,20,yes,ON);        // dibuja un rectángulo con relleno
   glcd_text57(1,1,voltext,1,ON);            //introduzco las variables de texto
   glcd_text57(35,1,voltext3,1,ON);
   glcd_text57(100,55,voltext2,1,ON);
  
   glcd_circle(30,25,15,no,on);              //dibuja círculo       
   glcd_circle(30,24,5,yes,ON);            //dibuja un círculo con  relleno
   glcd_circle(70,25,15,no,on);
   glcd_circle(70,24,5,yes,ON);
} 

 

Ahora vamos a ver como queda la placa una vez finalizada. Hay que tener precaución con los packages usados en Proteus ya que algunos componentes no tienen o no se puede simular por lo que hay que deshabilitarlo para que la simulación se realize correctamente. De todas maneras en el Ares se pueden modificar los Footprints para que aquí ya sean los definitivos. 

Vista en Ares:

Vista en 3D:

DESCARGA EL EJERCICIO