Mostrando entradas con la etiqueta PIC's. Mostrar todas las entradas
Mostrando entradas con la etiqueta PIC's. Mostrar todas las entradas

2 jun 2011

POTENCIOMETRO DIGITAL MCP41010 CON SPI



La finalidad de este ejercicio es el estudio del potenciometro digital MCP41010 controlado con el pic 18F4550 mediante el bus SPI.

Deberéis leeros las características del potenciometro en el datasheet que os dejare en el enlace de descarga o también lo podéis ver AQUÍ.

En el CCS hay una librería para el MCP41010 que sirve como guía para hacer el programa principal, pero que también debe ser incluida para que funcione el programa, al igual que la del LCD, os las paso con el programa.

Una vez echado un vistazo a esa librería comenzaremos a realizar el código del programa, yo le he hacho de tal manera que escribo un dato desde la dirección 0x00 hasta la 0x0A, pero puedes poner la dicección que quieras sin pasarte de la 0xFF, y sale el valos 351,56 ohm en el LCD, luego espera 4 segundos y vuelve a empezar.

///////////////////////////////////////////////////////////////////////////////
//   AUTOR: Clara Alonso Fernández                       Junio/2011
//////////////////////////////////////////////////////////////////////////////
//   PROGRAMA: Potenciometro MCP41010        VERSIÓN:    1.0
//   DISPOSITIVO: PIC 18F4550                COMPILADOR: PCWHC Compiler v4,093
//   Entorno IDE:                            SIMULADOR:  Proteus 7.7 sp2
//   TARJETA DE APLICACIÓN: Virtual          DEBUGGER: Virtual
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
// CABECERA ///////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
#include <18F4550.h>    //Pic que se va a utilizar.
#fuses INTHS            //Configuración para el oscilador interno.
#use delay(internal=8Mhz)   //Configuración de la velocidad del oscilador interno.
#include <LCD_flexible5.c>    //Librería para ql funcionamiento del LCD.
#include <mcp410101.C>  //Librería para el funcionamiento del potenciometro digital.
///////////////////////////////////////////////////////////////////////////////
// VARIABLES GLOBALES /////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
int a;      //Dato que se escribe en el potenciometro.
float b;    //Dato en ohmios.
///////////////////////////////////////////////////////////////////////////////
// FUNCIONES //////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
// PRINCIPAL //////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
void main()
{
lcd_init();                     //Esta función inicializa LCD.
lcd_putc("     MCP41010");      //Muestra en el LCD ese mensaje.
do{                             //Se crea un bucle infinito para que esté todo el rato en funcionamiento el potenciometro.
for(a=0x00;a<0x0A;a++) //Escribimos el valor que queremos. En este caso e puesto de 0x00 a
                                        //0xxA para que el potenciometo tenga un valor de 315,56 ohmios.
{                                                                        
set_pot(a);                     //Con esta función mandamos el dato del valor al potenciometro.
lcd_gotoxy(1,2);                //Movemos el cursor a la segunda fila del LCD.
b=(a*10000.0)/256.0;            //Esta es la ecuación para obtener los ohmios.
printf(lcd_putc,"%f Ohm    ",b);   //Se muestra en el LCD el calculo.
delay_ms(200);                  //Retardo de 200ms
}
delay_ms(4000);                //Retardo de 4 seg para que de tiempo a ver bien el valor del potenciometro.
}while(1);
}

Después hacemos la simulación y el diseño con el PROTEUS. Con el ISIS hacemos la simulación, para ello necesitamos los siguientes componentes: el PIC18F4550, el potenciometro digital MCP41010, un pulsador para el reset, una resistencia de 10K y otra de 470R, y una regleta de dos entradas.


luego pasamos al ARES para el diseño de la PCB. Colocamos los componentes y le damos al "auto-route" para tirar las pistas y ya tenemos el diseño hecho.


Para hacernos una idea de como quedaría la placa utilizamos el "3D visualization"




Aquí os dejo un enlace para que podáis descargaros el código, la simulación, las librerías y el datasheet del MCP41010: http://cid-64f7131e50857260.office.live.com/self.aspx/POTENCIOMETRO/POT.rar




23 may 2011

COMUNICACIÓN ENTRE UN PIC18F4550 Y UNA MEMORIA EEPROM MEDIANTE SPI



En este ejercicio realizaremos la lectura y escritura de una EEPROM mediante un módulo SPI y programando un PIC18f4550. La EEprom que utilizaremos es 25LC020

Lo primero es realizar el código del programa para poder escribir y leer en la memoria EEPROM.

///////////////////////////////////////////////////////////////////////////////////////////////////
//   AUTOR: Clara Alonso Fernández                      Mayo/2011
//////////////////////////////////////////////////////////////////////////////////////////////////
//   PROGRAMA:Escritura y Lectura de una EEPROM con un SPI    VERSIÓN:    1.0
//   DISPOSITIVO: PIC 18F4550                COMPILADOR: PCWHC Compiler v4,093
//   Entorno IDE:                            SIMULADOR:  Proteus 7.6 sp0
//   TARJETA DE APLICACIÓN: Virtual                  DEBUGGER:
///////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////
//Ejercicio; Escribir en una EEPROM con un 18F4550 mediante el bus SPI

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

///////////////////////////////////////////////////////////////////////////////////////////////////
// CABECERA //////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////
#include <18F4550.h>       //PIC que se va a utilizar.
#fuses INTHS//oscilador interno        //Configuración de los fusibles.
#use delay(internal=8Mhz)    //Configuración de la velocidad del oscilador.
#include <LCD_flexible.c>    //Librería del LCD.
/////////////////////////////////////////////////////////////////////////////////////////////////
// VARIABLES GLOBALES ///////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////
int a;
int p;
//////////////////////////////////////////////////////////////////////////////////////////////
// FUNCIONES ////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////
escribir()
{
   output_bit(pin_a0,1);                      //Habilita la salida CS.
   spi_write(0x06);                            //Con esta instrucción habilitamos la escritura en la EEPROM.
   spi_write(0x02);                           //Dirección para configurar que vamos a escribir.
   spi_write(0x00);                           //Dirección de la memoria.       
   lcd_putc("ESCITURA: ");
   lcd_gotoxy(1,0);
   for(a=0;a<5;a++)
      {                                            //Configuración para escribir datos desde 0x00 hasta 0x07.
         spi_write(a);                        //Escribe en el SPI el valor de los datos.
         printf(lcd_putc,"%u",a);        //Muestra en el LCD el valor de los datos.
         delay_ms(500);                   //Retardo de 500 mseg.
      }
}

leer()
{
   output_high(pin_a0);                 //Deshabilita la salida CS.
   delay_ms(1000);                      //Retardo de 1 seg.
   lcd_putc("\f");                          //Muestra en la segunda fila del LCD la palabra LECTURA.
   delay_ms(300);
   lcd_putc("LECTURA: ");
   lcd_gotoxy(1,0);
   output_low(PIN_A0);                //Volvemos ha habilitar la salida CS.
   spi_read(0x03);                      //Configurar la operación de escritura.
   spi_read(0x00);                      //Dirección de lectura.
   for(p=0;p<5;p++)
      {
      a=(spi_read(p));                 //Lee de la direccion 0×00 hasta la 0×09.
      printf(lcd_putc,"%u",a);       //Lo muestra en el LCD.
      delay_ms(500);                  //Retardo de 500 mseg.
      }                                   
      output_high(PIN_A0);         //Volvemos a deshabilitar la salida CS.
}
///////////////////////////////////////////////////////////////////////////////
// PRINCIPAL //////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
void main()
{
   lcd_init();                         //Inicializa el LCD.
   setup_spi(spi_MASTER | spi_L_to_H | spi_clk_div_16);
   //ESCRITURA EN EEPROM
   output_bit(pin_A0,1);        //Se vuelve ha habilitar CS.
   spi_write(0x06);               //Se habilitar la escritura.
   spi_write(0x02);               //Direcccion para configurar que vamos a escribir.
   spi_write(0x00);               //Direccion de la memoria donde se guarda.       
   delay_ms(300);               //Retardo de 300 mseg.
   escribir();                       //Función de escritura.
   leer();                            //Función de lectura.
   }


Después haremos el esquemático en el PROTEUS para poder simular su funcionamiento y realizar luego el diseño de la placa en el otro entorno de proteus, el ARES.


La siguiente imagen muestra la ventana donde se ve si la EEPROM tiene contenido escrito:




Una vez terminado el esquemático pasamos a realizar el diseño en ARE:


Con la siguiere imagen nos podemos hacer una idea bastante aproximada de cómo quedaría la placa en la realidad:




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










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


Twitter Delicious Facebook Digg Stumbleupon Favorites More

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