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

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

Generar y leer una señal analógica

Como en anteriores ejercicios, utilizando un DAQ 6008 y Labview, debemos generar una señal analógica y luego leerla.

Este ejercicio, para entenderlo mejor estará dvidido en dos partes. La primera que será donde genero la función deseada, símplemente usando un generador de señales. Luego esta señal estará configurada como salida analógica para así en la segunda parte del ejercicio poder leerla como un dato de entrada. 

Viendo el panel frontal nos encontramos dos Wavefrom Chart, el primero correspone a la función generada y el de abajo a la leida. Habrá que jugar con el rate y the samples per channel para obtener la configuración mas satisfactoria.

DESCARGA EL EJERCICIO

Múltiples canales con DAQ 6008

Utilizando un DAQ 6008 y Labview, debemos de leer varios canales (5 en mi caso).


Lo primero que debemos hacer es ir al MAX para configurar cada canal que vayamos a utilizar. Así evitaremos futuros conflictos entre los canales usados.

Como se ve he configurado una tarea con los 5 canales que voy a utilizar para llevar a cabo esta práctica.

 El código es muy sencillo, ya que tenemos nuestra entrada analógica (voltage) al cual le asignamos la tarea previamente hecha con el MAX, en el que está la configuración de nuestros canales.

 

Si pasamos al Front Panel veremos como podemos leer la distintas tensiones que tenemos en cada canal al mismo tiempo.

 

 DESCARGA EL EJERCICIO

 

Carga y descarga de condensador

Con Labview y un DAQ 6008 debemos crear una señal analógica, que será la carga y descarga de un condensador. Ésta se tendrá que ver gráficamente.

Con este código leemos una entrada analógica (con el AI Voltage). Esta entrada se puede configurar con el MAX (Measurement & Automation Explorer), una aplicación de National Instruments.

Podemos crear canales y tareas como se ve en la imagen para poder tener distintas configuraciones para futuros proyectos.


Y directamente la podemos visualizar en un Waveform chart

con el que debermos jugar con el rate y samples per channel para obtener la visualización que nos convenga.




DESCARGAR EL EJERCICIO

Escribir y leer array en excel

Mediante LabVIEW, un programa de National Instruments, vamos a guardar un array de datos en Excel y posteriormente los leeremos, indicando la celda correspondiente.


He generado una función, en este caso senoidal y los datos de esta serán los que compongan el array.

 Como se ve en la imagen, a la entrada del array hay varias operaciones pero simplemente son para que haya mayor número de filas en el array y se pueda observar mejor.
Al ejecutarlo nos dirá donde queremos guardar los datos y elegimos un archivo de excel (.csv).


Ahora en el panel frontal podemos elegir la celda exacta que queremos leer.

DESCARGA EL EJERCICIO