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

Leer una base de datos (Access) y mostrar los resultados gráficamente

El ejercicio consiste en leer una tabla de una base de datos de Access y posteriormente mostrar todos esos datos en una gráfica mediante Labview.
En mi ejercicio voy a simular la tempertaura en 30 días aleatorios utilizando unas temperaturas también aleatorias comprendidas entre -5 y 30 ºC.

Lo primero que vamos a hacer es crear nuestro get udl personal, que será donde se especifique la ruta en la que está guardada la base de datos que vamos a utilizar.

Después de abrir y limpiar los posibles datos que haya anteriormente en esa tabla, creamos una nueva con datos aleatorios.

Cada vez que se nos muestra por pantalla el gráfico, es porque ha creado una base de datos nueva y los ha generado como una función.

DESCARGA EL EJERCICIO

Medir un objeto con visión artificial

El ejercicio consiste en medir la longitud de un objeto utilizando el programa Vision Builder 2009.
Utilizando este programa y una webcam seremos capaces de saber la longitud de cualquier objeto que pase ante la cam en tiempo real.
El primer paso que debemos hacer es seleccionar la cámara que vamos a utilizar:

Una vez seleccionada debemos filtrar la imagen, ya que algunos de los pasos que vamos a realizar así lo exigen. Para ello nos vamos a la pestaña Inspection Steps: Enhance Images y escogemos la opción de Vision Assistant, cuando nos pregunte por la región de interes marcamos Full Image y luego vamos a Edit. Aquí se nos abre una nueva ventana con otra aplicación de Vision. En esta lo que vamos a hacer va a ser extraer el color

Ahora ya podemos seguir.
El siguiente paso va a ser calibrar la imagen. Podemos poner una regla en frente de la cámara y así calibrar la distancia que deseemos.
Una vez hecha la calibración, escogeremos la opción Caliper para seleccionar la zona donde queremos que se realize la medición.

Lo último que nos queda es mostrar la medida, teniendo como referencia la calibración hecha anteriormente.

Ya está finalizado, ahora podemos poner un objeto y nos lo medirá en tiempo real

DESCARGA EL EJERCICIO