Hola, yo he adaptado el ejemplo de la web al compilador ccs,
http://www.sensirion.com/en/pdf/Sample_Code_SHT11
te lo voy a pegar aqui, pero quiero dejar claro que no lo he probado aún, solo he adaptado el codigo y lo he compilado sin problema, me gustaria probarlo, pero este mes estoy fatal de tiempo a ver si me pongo a probarlo porque tengo el sensor ahora mismo por ahi tirado.....
Me gustaría, que si consigues hacerlo funcionar comentases cual fue tu experiencia, y si no te funciona y consigues retocarlo para que rule, que comentases por aqui los cambios que has realizado para que todos tengamos el codigo.
De todos modos si no quieres usar la libreria que he adaptado, y quieres usar la "tuya", no tienes mas que fijarte en el ejemplo y asi podras adaptar las funciones....
Tambien te recomiendo que te estudies bien el datasheet, para saber muy bien como funciona, ya que puedes elegir las resoluciones de las capturas, puedes usar la funcion calentador, vamos que tiene varias opciones y es recomendable conocerlas...
Buena suerte, y espero comentarios.
Codigo:--------------------------------------------------------------------------------
#include <16F876A.h>
#use delay(clock=4000000) //Oscilador de 4Mhz
#fuses XT,NOWDT,NOPROTECT
#include <libreria_sht11_trelles.c> //funciones de escritura y lectura del registro y medida de Tª y humedad en el sht11
#include <lcd.c> //funciones para gestionar el lcd
//declaracion de variables para la medicion del sht11
typedef union
{ unsigned int i;
float f;
} valor;
///variables globales
valor humedad,temperatura; //variables de tipo valor para almacenar tº y humedad
void main(void)
{
unsigned char error,checksum;
unsigned int i;
//medida sensor digital
conexion_al_reset();
while(1)
{
error=0;
error+=medicion((unsigned char*) &humedad.i,&checksum,HUMI); //si existe algun error sera almacenado
error+=medicion((unsigned char*) &temperatura.i,&checksum,TEMP);
if(error!=0)
conexion_al_reset();
else
{
humedad.f=(float)humedad.i; //casting de entero a float para la funcion calculos_sht11
temperatura.f=(float)temperatura.i;
calculos_sht11(&humedad.f,&temperatura.f);
lcd_gotoxy(1,1);
printf(lcd_putc,"Tª2:%5.1fC humi:%5.1f%%\n",temperatura.f,humedad.f);
delay_ms(600);
}
}
}
--------------------------------------------------------------------------------
La liberia
Codigo:--------------------------------------------------------------------------------
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
// FUNCIONES PARA EL CALCULO DE HUMEDAD Y TEMPERATURA DEL SHT11
//
// Adaptacion de Oshow del codigo de ejemplo del sensor
// SHT11 de sensirion, realizado con el compilador KEIL para
// un microcontrolador 8051.
//
// Adaptado para compilador PCW de CCS
//
//
//
//
////////////////////////////////////////////////////////////////////////////////
#bit DATOS = 0x05.2 //definicion de los bits del sht11 datos en RA2
#bit SCK = 0x05.1 //sck en RA1
//Estos defines se pueden simplificar en lugar de tener 3 parejas de defines
#define noACK 0
#define ACK 1
/*
#define CALENTADOR_ON 1
#define CALENTADOR_OFF 0
#define RESOLUCION_14_12_BITS 0
#define RESOLUCION_12_8_BITS 1
*/
// PROTOTIPOS DE LAS FUNCIONES
char escribir_byte(unsigned char valor);
char leer_byte(unsigned char ack);
void inicializacion(void);
char reset(void);
void conexion_al_reset(void);
char leer_registro_de_estado(unsigned char *p_valor, unsigned char *p_checksum);
char escribir_registro_de_estado(unsigned char *p_valor);
char medicion(unsigned char *p_valor, unsigned char *p_checksum, unsigned char modo);
void calculos_sht11(float *p_humedad ,float *p_temperatura);
//float calculo_rocio(float h,float t);
//char calentador_sht11(byte onoff);
//char resolucion_de_capturas(byte res);
////////////////////////////////////////////////////////////////////////////////
// Direcciones hexadecimales para escribir y leer en el sensor.
////////////////////////////////////////////////////////////////////////////////
#define STATUS_REG_W 0x06
#define STATUS_REG_R 0x07
#define MEASURE_TEMP 0x03
#define MEASURE_HUMI 0x05
#define RESET 0x1E
enum {TEMP,HUMI}; //tambien podemos hacer defines
////////////////////////////////////////////////////////////////////////////////
// Escribe un byte en el sensor y chequear si es reconocido
////////////////////////////////////////////////////////////////////////////////
char escribir_byte(unsigned char valor)
{
unsigned char i,error=0;
for (i=0x80;i>0;i/=2)
{
if (i & valor)
DATOS=1;
else
DATOS=0;
SCK=1;
delay_us(5);
SCK=0;
}
DATOS=1;
SCK=1;
error=DATOS;
SCK=0;
return error;
}
////////////////////////////////////////////////////////////////////////////////
// Lee un byte en el sensor y da el reconocimeinto si ack es igual a 1
////////////////////////////////////////////////////////////////////////////////
char leer_byte(unsigned char ack)
{
unsigned char i,valor=0;
DATOS=1;
for (i=0x80;i>0;i/=2)
{
SCK=1;
if (DATOS)
valor=(valor | i);
SCK=0;
}
DATOS=!ack;
SCK=1;
delay_us(5);
SCK=0;
DATOS=1;
return valor;
}
////////////////////////////////////////////////////////////////////////////////
//Rutina de inicializacion del sensor, utilizar despues del reset.
////////////////////////////////////////////////////////////////////////////////
// Genera un comienzo de trasmision.
// ______ _______
// DATOS: |_______|
// ___ ___
// SCK : ___| |___| |_____
////////////////////////////////////////////////////////////////////////////////
void inicializacion(void)
{
DATOS=1;
SCK=0;
delay_us(2);
SCK=1;
delay_us(2);
DATOS=0;
delay_us(2);
SCK=0;
delay_us(5);
SCK=1;
delay_us(2);
DATOS=1;
delay_us(2);
SCK=0;
}
////////////////////////////////////////////////////////////////////////////////
//Reseteo del sensor; linea de datos a 1 seguido de 9 ciclos de reloj y de
// la funcion inicializacion()
////////////////////////////////////////////////////////////////////////////////
//
// _____________________________________________________ ________
// DATA: |_________|
// _ _ _ _ _ _ _ _ _ _____ _____
// SCK : __| |__| |__| |__| |__| |__| |__| |__| |__| |______| |___| |___
//
////////////////////////////////////////////////////////////////////////////////
void conexion_al_reset(void)
{
unsigned char i;
DATOS=1;
SCK=0;
for(i=0;i<9;i++)
{
SCK=1;
delay_us(2);
SCK=0;
delay_us(2);
}
inicializacion();
}
////////////////////////////////////////////////////////////////////////////////
// Resetea el sensor
////////////////////////////////////////////////////////////////////////////////
char soft_reset (void)
{
unsigned char error=0;
conexion_al_reset();
error+=escribir_byte(RESET);
return error;
}
////////////////////////////////////////////////////////////////////////////////
// Lectura del registro de estado con checksum de 8 bits
////////////////////////////////////////////////////////////////////////////////
char leer_registro_de_estado(unsigned char *p_valor, unsigned char *p_checksum)
{
unsigned char error=0;
inicializacion();
error=escribir_byte(STATUS_REG_R);
*p_valor=leer_byte(ACK);
*p_checksum=leer_byte(noACK);
return error;
}
////////////////////////////////////////////////////////////////////////////////
//Escribimos en el registro de estado con un checksum de 8 bits
////////////////////////////////////////////////////////////////////////////////
char escribir_registro_de_estado(unsigned char *p_valor)
{
unsigned char error=0;
inicializacion();
error+=escribir_byte(STATUS_REG_W);
error+=escribir_byte(*p_valor);
return error;
}
////////////////////////////////////////////////////////////////////////////////
// Realiza la medicion de temperatura y humedad con checksum incluido
// Todavia no es la medicion real, se debe hacer la compensacion
////////////////////////////////////////////////////////////////////////////////
char medicion(unsigned char *p_valor, unsigned char *p_checksum, unsigned char modo)
{
unsigned error=0;
unsigned long i;
inicializacion(); //transmission start
switch(modo)
{
case TEMP : error+=escribir_byte(MEASURE_TEMP); break;
case HUMI : error+=escribir_byte(MEASURE_HUMI); break;
default : break;
}
for (i=0;i<65535;i++)
if(DATOS==0)
break;
if(DATOS) error+=1;
*(p_valor) =leer_byte(ACK);
*(p_valor+1)=leer_byte(ACK);
*p_checksum =leer_byte(noACK);
return error;
}
////////////////////////////////////////////////////////////////////////////////
// Calculo de la temperatura en ºC y humedad en %
// Entrada proviniente del sensor:
// Humedad - 12 bits (por defecto)
// Temperatura - 14 bits (por defecto)
// Salida hacia el LCD:
// Humedad - RH%
// Temperatura - ºC
////////////////////////////////////////////////////////////////////////////////
void calculos_sht11(float *p_humedad ,float *p_temperatura)
{
const float C1=-4.0;
const float C2= 0.0405;
const float C3=-0.0000028;
const float T1=0.01;
const float T2=0.00008;
float rh;
float t;
float rh_lin;
float rh_true;
float t_C;
rh=*p_humedad;
t=*p_temperatura;
t_C=t*0.01 - 40;
rh_lin=C3*rh*rh + C2*rh + C1;
rh_true=(t_C-25)*(T1+T2*rh)+rh_lin;
if(rh_true>100)
rh_true=100;
if(rh_true<0.1)
rh_true=0.1;
*p_temperatura=t_C;
*p_humedad=rh_true;
}
/////////////REVISAR ESTAS FUNCIONES, OJO!!!!ESTAN SIN REVISAR//////////////////
////////////////////////////////////////////////////////////////////////////////
// Funciones que se pueden utilizar a deseo del usuario
// Para utilizarlas, quitar los comentarios.
////////////////////////////////////////////////////////////////////////////////
//Funcion para el calculo del rocio. Para utilizarla, incluir libreria matematica
// #include <math.h> debido a que se usa un logaritmo
////////////////////////////////////////////////////////////////////////////////
/*float calculo_rocio(float h,float t)
{
float logEx,punto_rocio;
logEx=0.66077+7.5*t/(237.3+t)+(log10(h)-2);
punto_rocio = (logEx - 0.66077)*237.3/(0.66077+7.5-logEx);
return punto_rocio;
}
////////////////////////////////////////////////////////////////////////////////
// Funcion para activar el calentador del sht11
// Esta funcion activa el calentador del sensor, el sensor
// se "autocalienta" unos 5ºC
////////////////////////////////////////////////////////////////////////////////
char calentador_sht11(byte onoff)
{
byte valor, checksum,
char error=0;
conexion_al_reset();
error += leer_registro_de_estado(&valor, &checksum);
conexion_al_reset();
if (!error && (((valor>>2) & 0x01) != onoff))
{
onoff?bit_set(valor,2):bit_clear(valor,2);
error += escribir_registro_de_estado(&valor);
}
return error;
}
////////////////////////////////////////////////////////////////////////////////
// Eleccion de resolucion en las medidas
// Por defecto: 14 bits temepratura y 12 bits humedad
// Opcion: 12 bits temperatura y 8 bits humedad
////////////////////////////////////////////////////////////////////////////////
char resolucion_de_capturas(byte res)
{ //eleccion de resolucion
byte valor, checksum;
char error=0;
conexion_al_reset();
error += escribir_registro_de_estado(&valor, &checksum);
conexion_al_reset();
if (!error && ((valor & 0x01) != res))
{
res?bit_set(valor,0):bit_clear(valor,0);
error += escribir_registro_de_estado(&valor);
}
return error;
}
*/
--------------------------------------------------------------------------------