Este proyecto consiste en comunicar el PIC18F4550 con el sensor de temperatura TC77 y mostrar las temperaturas en un LCD alfanumérico.
El bus interfaz con periféricos serie (SPI) fue desarrollado originalmente por Motorola a finales de los 80 en los microcontroladores serie 68000. Hoy en día se puede encontrar en teléfonos móviles, PDA, etc, para comunicar la CPU con los distintos periféricos.
El Bus SPI es un bus de tres líneas sobre el que se transmiten paquetes de información de 8bits. Cada dispositivo conectado al bus puede funcionar como transmisor y receptor al mismo tiempo, este tipo de comunicación se denomina full dúplex.
Hay dispositivos que solo son transmisores y otros solo receptores. Algunos, como las memorias EEPROM, son transmisores y receptores.
Los dispositivos conectados se pueden dividir en maestros y esclavos.
Los maestros son los que inician la transferencia de información y generan las señales de reloj y control.
Los esclavos son los dispositivos controlados por el maestro.
El bus utiliza las siguientes líneas:
Master Out - Slave In (MOSI): Conexión para la entrada de datos serie.
Master in- Slave out (MISO): Conexión para la salida de datos.
Clock (SCLK): Señal de reloj.
Slave select (SS): Seleccion.
Con respecto al I2C. el SPI alcanza velocidades muy superiors al utilizer lineas independientes de transmission y recepción.
En los PIC18 el SPI puede alcanzar frecuencias de 12 Mhz frente a 1Mhz del I2C.
La ventaja del I2C es que solo utiliza dos líneas, la de datos y la de reloj ( Sin contar GND) independientemente de los esclavos que tengas conectados dado que se seleccionan por software, por el contrario el SPI utiliza tres líneas para comunicarse y otra más para seleccionar.
Después de esta breve explicación del Bus SPI nos metemos ya en el programa.
Utilizamos la librería del LCD para mostrar las temperaturas en un LCD alfanumérico.
Esta vez manejaremos el LCD por el puerto D del PIC, esto se configura en las primeras líneas de la librería.
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// flex_lcd.c
// These pins are for the Microchip PicDem2-Plus board,
// which is what I used to test the driver. Change these
// pins to fit your own board.
#define LCD_DB4 PIN_D4
#define LCD_DB5 PIN_D5
#define LCD_DB6 PIN_D6
#define LCD_DB7 PIN_D7
//
#define LCD_RS PIN_D0
#define LCD_RW PIN_D1
#define LCD_E PIN_D2
// If you only want a 6-pin interface to your LCD, then
// connect the R/W pin on the LCD to ground, and comment
// out the following line.
#define USE_LCD_RW 1
//========================================
#define lcd_type 2 // 0=5x7, 1=5x10, 2=2 lines
#define lcd_line_two 0x40 // LCD RAM address for the 2nd line
int8 const LCD_INIT_STRING[4] =
{
0x20 | (lcd_type << 2), // Func set: 4-bit, 2 lines, 5x8 dots
0xc, // Display on
1, // Clear display
6 // Increment cursor
};
//-------------------------------------
void lcd_send_nibble(int8 nibble)
{
// Note: !! converts an integer expression
// to a boolean (1 or 0).
output_bit(LCD_DB4, !!(nibble & 1));
output_bit(LCD_DB5, !!(nibble & 2));
output_bit(LCD_DB6, !!(nibble & 4));
output_bit(LCD_DB7, !!(nibble & 8));
delay_cycles(1);
output_high(LCD_E);
delay_us(2);
output_low(LCD_E);
}
//-----------------------------------
// This sub-routine is only called by lcd_read_byte().
// It's not a stand-alone routine. For example, the
// R/W signal is set high by lcd_read_byte() before
// this routine is called.
#ifdef USE_LCD_RW
int8 lcd_read_nibble(void)
{
int8 retval;
// Create bit variables so that we can easily set
// individual bits in the retval variable.
#bit retval_0 = retval.0
#bit retval_1 = retval.1
#bit retval_2 = retval.2
#bit retval_3 = retval.3
retval = 0;
output_high(LCD_E);
delay_cycles(1);
retval_0 = input(LCD_DB4);
retval_1 = input(LCD_DB5);
retval_2 = input(LCD_DB6);
retval_3 = input(LCD_DB7);
output_low(LCD_E);
return(retval);
}
#endif
//---------------------------------------
// Read a byte from the LCD and return it.
#ifdef USE_LCD_RW
int8 lcd_read_byte(void)
{
int8 low;
int8 high;
output_high(LCD_RW);
delay_cycles(1);
high = lcd_read_nibble();
low = lcd_read_nibble();
return( (high<<4) | low);
}
#endif
//----------------------------------------
// Send a byte to the LCD.
void lcd_send_byte(int8 address, int8 n)
{
output_low(LCD_RS);
#ifdef USE_LCD_RW
while(bit_test(lcd_read_byte(),7)) ;
#else
delay_us(60);
#endif
if(address)
output_high(LCD_RS);
else
output_low(LCD_RS);
delay_cycles(1);
#ifdef USE_LCD_RW
output_low(LCD_RW);
delay_cycles(1);
#endif
output_low(LCD_E);
lcd_send_nibble(n >> 4);
lcd_send_nibble(n & 0xf);
}
//----------------------------
void lcd_init(void)
{
int8 i;
output_low(LCD_RS);
#ifdef USE_LCD_RW
output_low(LCD_RW);
#endif
output_low(LCD_E);
delay_ms(15);
for(i=0 ;i < 3; i++)
{
lcd_send_nibble(0x03);
delay_ms(5);
}
lcd_send_nibble(0x02);
for(i=0; i < sizeof(LCD_INIT_STRING); i++)
{
lcd_send_byte(0, LCD_INIT_STRING[i]);
// If the R/W signal is not used, then
// the busy bit can't be polled. One of
// the init commands takes longer than
// the hard-coded delay of 60 us, so in
// that case, lets just do a 5 ms delay
// after all four of them.
#ifndef USE_LCD_RW
delay_ms(5);
#endif
}
}
//----------------------------
void lcd_gotoxy(int8 x, int8 y)
{
int8 address;
if(y != 1)
address = lcd_line_two;
else
address=0;
address += x-1;
lcd_send_byte(0, 0x80 | address);
}
//-----------------------------
void lcd_putc(char c)
{
switch(c)
{
case '\f':
lcd_send_byte(0,1);
delay_ms(2);
break;
case '\n':
lcd_gotoxy(1,2);
break;
case '\b':
lcd_send_byte(0,0x10);
break;
default:
lcd_send_byte(1,c);
break;
}
}
//------------------------------
#ifdef USE_LCD_RW
char lcd_getc(int8 x, int8 y)
{
char value;
lcd_gotoxy(x,y);
// Wait until busy flag is low.
while(bit_test(lcd_read_byte(),7));
output_high(LCD_RS);
value = lcd_read_byte();
output_low(lcd_RS);
return(value);
}
#endif
void lcd_setcursor_vb(short visible, short blink) {
lcd_send_byte(0, 0xC|(visible<<1)|blink);
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
El programa principal.
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////
// AUTOR: José Antonio Pelayo NOVIEMBRE/2011
/////////////////////////////////////////////////////////////////////////////////
// PROGRAMA: LEER TEMPERATURA SPI TC77 VERSIÓN: 1.0
// DISPOSITIVO: PIC 18F4550 COMPILADOR: CCS vs4.109
// Entorno IDE: MPLAB SIMULADOR: Proteus 7.7 sp2
// TARJETA DE APLICACIÓN: ___ DEBUGGER: ICD3
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
/*
CONFIGURACIÓN DE LECTURA SEGÚN FABRICANTE
1. CS goes low to initiate the communication cycle.
2. Read 16 bits of temperature data from the
Temperature register.
3. Write 16 bits of data (i.e. XXFF hex) to the Configuration register to enter Shutdown mode.
4. Read the 16 bits from the Manufacturer's ID register (C15:C8 = 54 hex) to verify that the sensor
is a Microchip device.
5. Write 8 to 16 bits of data (00 or 0000 hex) to
enter Continuous Conversion Mode.
6. Return CS high to terminate the communication
cycle.
The time between a complete temperature conversion
and data transmission is approximately 300 msec
------------------------------------------------------------------------------------
El registro da la temperatura en complemento a 2 y trabaja de la siguiente forma:
bit15 bit14 bit13 bit12 bit11 bit10 bit9 bit8 bit7 bit6 bit5 bit4 bit3 bit2 bit1 bit0
T15 T14 T13 T12 T11 T10 T9 T8 T7 T6 T5 T4 T3 T2 T1 T0
2^8 2^7 2^6 2^5 2^4 2^3 2^2 2^1 2^0 2^-1 2^-2 2^-3 2^-4 * X X
EJEMPLO:
Temperature = 85.125°C
Temperature Register = 00101010 10010111b
= 2^6 + 2^4 + 2^2 + 2^0 + 2^-3
= 64 + 16 + 4 + 1 + 0.125
= 85.125°C
*/
////////////////////////////////////////////////////////////////////////////////////
// CABECERA ////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////
#include <c:\h\18F4550.h>
#FUSES HS //External clock
#FUSES MCLR //Master Clear pin enabled
#use fast_io(c)
#use fast_io(b)
#use delay(clock=20000000)
#define CS PIN_A0
//#fuses INTHS //Selecciona el oscilador interno
//#use delay(internal=1Mhz) // Selecciona la velocidad del oscilador interno
#include <LCD_Flexible_1.c>
/*
Mientras no empleemos el bus USB, se utilizará el oscilador interno para simplificar
la configuración de reloj y reducir componentes externos.
*/
////////////////////////////////////////////////////////////////////////////////////
// VARIABLES GLOBALES //////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////
int Templ=0;
int Temph=0;
signed int16 Temp16Bits=0;
float decimales=0;
float enteros=0;
int1 banderanegativo=0;
float Temperatura;
////////////////////////////////////////////////////////////////////////////////////
// FUNCIONES ///////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////
// PRINCIPAL ///////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////
void main()
{
set_tris_b(0b00000001);
set_tris_c(0X00);
setup_spi(spi_master|spi_l_to_h| spi_ss_disabled);
lcd_init();
//configuracion del sensor en modo continuo
/*
output_low(CS);
spi_read(0);//leemos byte alto
spi_read(0);//leemos byte bajo
spi_write(0x00);
spi_write(0xFF);
spi_read(0);//leemos byte alto
spi_read(0);//leemos byte bajo
spi_write(0x00);
spi_write(0x00);
output_high(CS);
*/
while(1){
lcd_gotoxy(1,1);
output_low(CS);
Temph=spi_read(0);//obtenemos el Temp alto del registro de temperatura
Templ=spi_read(0);//obtenemos el Temp bajo del registro de temperatura
output_high(CS);
Temp16Bits=make16(Temph,Templ);//convertimos a un registro de 16Bits
banderanegativo=0;
if (Temp16Bits<0){
banderanegativo=1;
Temp16Bits=~Temp16Bits+8;
}//si es negativo lo complementamos a 2 y le sumamos 8
Temp16Bits=Temp16Bits>>3;//descartamos los 3 bits menos significativos
decimales=(float)(Temp16Bits&0b0000000000001111)*0.0625;//damos formato a los decimales
enteros=(float)(Temp16Bits>>4); //damos formato a los enteros, solo descartando los decimales
if (banderanegativo){
Temperatura=-1*(enteros+decimales);
}
else{
Temperatura=(enteros+decimales);
}
lcd_gotoxy(1,1);
printf(lcd_putc,"Temp=%3.4fC \n",(Temperatura));
delay_ms(100);
}
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
La complejidad de este programa es debido a que no hemos utilizado ninguna librería para controlar el TC77, el programa principal se comunica directamente con el dispositivo.
Simulación en Proteus:
Programa en Tarjeta:
