sht11.c

用于SHT11温湿度采集模块的单片机驱动

/*********************************************
SHT1X Humidity and Temperature Sensor

Pin 1 	GND
Pin 2	Data			(PB0)
Pin 3	Serial Clock            (PB1)
Pin 4	VDD (2.4V to 5.5V) 


*********************************************/

#include "REG2051.H"
#include <stdio.h>
#include <math.h>
#include <intrins.h>

// Declare your global variables here
 
typedef union
{ unsigned int i; float f;} value; 
 
 
enum {TEMP,HUMI};

sbit SHT_DATA_IN = 0xB4;
sbit SHT_DATA_OUT = 0xB4;
sbit SHT_SCK = 0xB5;
 
#define		noACK	0
#define		ACK		1
                            //adr  command  r/w
#define STATUS_REG_W 0x06   //000   0011    0
#define STATUS_REG_R 0x07   //000   0011    1
#define MEASURE_TEMP 0x03   //000   0001    1
#define MEASURE_HUMI 0x05   //000   0010    1
#define RESET        0x1e   //000   1111    0 

const float C1=-4.0;              // for 12 Bit
const float C2=+0.0405;           // for 12 Bit
const float C3=-0.0000028;        // for 12 Bit
const float TC1=+0.01;             // for 14 Bit @ 5V
const float TC2=+0.00008;          // for 14 Bit @ 5V				
		                   
  
                                          
// Function Prototypes          
char not_leap(void);

//SHT Functions
char SHT_WriteByte(unsigned char value);
char SHT_ReadByte(unsigned char ack);
void s_transstart(void);
void s_connectionreset(void);
char s_softreset(void);
char s_measure(unsigned char *p_value, unsigned char *p_checksum, unsigned char mode);
void calc_sth11(float *p_humidity ,float *p_temperature);
float calc_dewpoint(float h,float t); 
void delay_ms(int t);
void delay_us(int t);

char s_write_statusreg(unsigned char *p_value); 
char s_read_statusreg(unsigned char *p_value, unsigned char *p_checksum);

void main(void)
{ 
// Declare your local variables here
           
value humi_val, temp_val;
unsigned char error, checksum, status;
float dew_point;


//s_softreset();
s_connectionreset();

/*
while (1)
	{
	s_transstart();				//transmission start
                     
	error+=SHT_WriteByte(MEASURE_TEMP); 	//send command to sensor
    	 
  	for (i=0;i<65535;i++) 
  		if(SHT_DATA_IN==0) break; 	//wait until sensor has finished the measurement
  
  	if(SHT_DATA_IN) error+=1;		//or timeout (~2 sec.) is reached
  
  	MSB  =SHT_ReadByte(ACK);    //read the first byte (MSB)
  	LSB  =SHT_ReadByte(ACK);    //read the second byte (LSB)
  	checksum =SHT_ReadByte(noACK);  //read checksum
  
 //sprintf(lcd_buffer,"T= %u %u %u",MSB,LSB,checksum);
//lcd_gotoxy(0,1);
//lcd_puts(lcd_buffer);
 
	delay_ms(500);
	}
*/


while (1)
	{


	error=0;
//	 		status = 0x04;	// Heater On
	status = 0x00;		// Heater Off
	s_write_statusreg(&status);
	
	error+=s_measure((unsigned char*) &humi_val.i,&checksum,HUMI);
    error+=s_measure((unsigned char*) &temp_val.i,&checksum,TEMP);
    if(error!=0) s_connectionreset();
    else{
    	humi_val.f=(float)humi_val.i;                   //converts integer to float
      	temp_val.f=(float)temp_val.i;                   //converts integer to float
      	calc_sth11(&humi_val.f,&temp_val.f);            //calculate humidity, temperature
      	dew_point=calc_dewpoint(humi_val.f,temp_val.f); //calculate dew point
  		delay_ms(1000);
  		} 
 	}
}
//----------------------------------------------------------------------------------
// writes a byte on the Sensibus and checks the acknowledge
//----------------------------------------------------------------------------------
char SHT_WriteByte( char value) 
{ 
  unsigned char i,error=0; 
  	SHT_SCK=0;
  for (i=0x80;i>0;i/=2)             	//shift bit for masking
  	{
  	if (i & value) 	SHT_DATA_OUT=1;		//masking value with i , write to SENSI-BUS
    else SHT_DATA_OUT=0; 
    delay_us(1);                   
    SHT_SCK=1;                          //clk for SENSI-BUS
    delay_us(1);						//pulswith approx. 5 us  
	SHT_SCK=0;
  	}
  SHT_DATA_OUT=0;                       //release DATA-line
  SHT_SCK=1;                            //clk #9 for ack 
  error=SHT_DATA_IN;                    //check ack (DATA will be pulled down by SHT11)
  delay_us(1);                   
  SHT_SCK=0; 
  SHT_DATA_OUT=1;                      
  return error;                     	//error=1 in case of no acknowledge
}

//----------------------------------------------------------------------------------
// reads a byte form the Sensibus and gives an acknowledge in case of "ack=1"
//----------------------------------------------------------------------------------
char SHT_ReadByte(unsigned char ack) 
{ 
  unsigned char i,val=0;
//  SHT_DATA_OUT=1;             			//release DATA-line
  for (i=0x80;i>0;i/=2)             	//shift bit for masking
    { 
	delay_us(1); 
    SHT_SCK=1;          				//clk for SENSI-BUS
    if (SHT_DATA_IN) val=(val | i);   	//read bit  
	delay_us(1);                   
    SHT_SCK=0;
	}
  delay_us(1);                   				 
  SHT_DATA_OUT=ack;               		//in case of "ack==1" pull down DATA-Line
  SHT_SCK=1;                            //clk #9 for ack
  delay_us(1);         					//pulswith approx. 5 us 
  SHT_SCK=0;						    
//  SHT_DATA_OUT=1;                 		//release DATA-line
  return val;
}

//----------------------------------------------------------------------------------
// generates a transmission start 
//       _____         ________
// DATA:      |_______|
//           ___     ___
// SCK : ___|   |___|   |______
//----------------------------------------------------------------------------------
void s_transstart(void)
{                                
   SHT_DATA_OUT=1; 
   SHT_SCK=0;                   //Initial state
   delay_us(1);
   SHT_SCK=1;
   delay_us(1);
   SHT_DATA_OUT=0;
   delay_us(1);
   SHT_SCK=0;  
   delay_us(2);
   SHT_SCK=1;
   delay_us(1);
   SHT_DATA_OUT=1;		   
   delay_us(1);
   SHT_SCK=0;		   
}

//----------------------------------------------------------------------------------
// communication reset: DATA-line=1 and at least 9 SCK cycles followed by transstart
//       _____________________________________________________         ________
// DATA:                                                      |_______|
//          _    _    _    _    _    _    _    _    _        ___     ___
// SCK : __| |__| |__| |__| |__| |__| |__| |__| |__| |______|   |___|   |______
//----------------------------------------------------------------------------------

void s_connectionreset(void)
{  
  unsigned char i; 
  SHT_DATA_OUT=1; SHT_SCK=0;     	//Initial state
  for(i=0;i<9;i++)                  //9 SCK cycles
  	{ 
  	SHT_SCK=1;
  	delay_us(1);
    SHT_SCK=0;
  	delay_us(1);
  }
  s_transstart();                   //transmission start
}

//----------------------------------------------------------------------------------
// resets the sensor by a softreset  
//----------------------------------------------------------------------------------
 
char s_softreset(void)
{ 
  unsigned char error=0;  
  s_connectionreset();              //reset communication
  error+=SHT_WriteByte(RESET);      //send RESET-command to sensor
  return error;                     //error=1 in case of no response form the sensor
}

//----------------------------------------------------------------------------------
// makes a measurement (humidity/temperature) with checksum
//----------------------------------------------------------------------------------
char s_measure(unsigned char *p_value, unsigned char *p_checksum, unsigned char mode)
{ 
  unsigned error=0;
  unsigned int i;

  s_transstart();                   //transmission start
  switch(mode){                     //send command to sensor
    case TEMP	: error+=SHT_WriteByte(MEASURE_TEMP); break;
    case HUMI	: error+=SHT_WriteByte(MEASURE_HUMI); break;
    default     : break;	 
  }
  for (i=0;i<65535;i++) if(SHT_DATA_IN==0) break; //wait until sensor has finished the measurement
  if(SHT_DATA_IN) error+=1;                // or timeout (~2 sec.) is reached
  *(p_value)  =SHT_ReadByte(noACK);    //read the first byte (MSB)
  *(p_value+1)  =SHT_ReadByte(noACK);    //read the second byte (LSB)
  *p_checksum =SHT_ReadByte(ACK);  //read checksum
  return error;
}   

//----------------------------------------------------------------------------------------
// calculates temperature [癈] and humidity [%RH] 
// input :  humi [Ticks] (12 bit) 
//          temp [Ticks] (14 bit)
// output:  humi [%RH]
//          temp [癈] 
//----------------------------------------------------------------------------------------

void calc_sth11(float *p_humidity ,float *p_temperature)
{ 

  float rh_lin;                     // rh_lin:  Humidity linear
  float rh_true;                    // rh_true: Temperature compensated humidity
  float t_C;                        // t_C   :  Temperature [癈]

  t_C=*p_temperature*0.01 - 40;                  //calc. temperature from ticks to [癈]
  rh_lin=C3*(*p_humidity)*(*p_humidity) + C2*(*p_humidity) + C1;     //calc. humidity from ticks to [%RH]
  rh_true=(t_C-25)*(TC1+TC2*(*p_humidity))+rh_lin;   //calc. temperature compensated humidity [%RH]
  if(rh_true>100)rh_true=100;       //cut if the value is outside of
  if(rh_true<0.1)rh_true=0.1;       //the physical possible range

  *p_temperature=t_C;               //return temperature [癈]
  *p_humidity=rh_true;              //return humidity[%RH]
}

//--------------------------------------------------------------------
// calculates dew point
// input:   humidity [%RH], temperature [癈]
// output:  dew point [癈]
//--------------------------------------------------------------------

float calc_dewpoint(float h,float t)
{ 
  float logEx,dew_point;
  logEx=0.66077+7.5*t/(237.3+t)+(log10(h)-2);
  dew_point = (logEx - 0.66077)*237.3/(0.66077+7.5-logEx);
  return dew_point;
}   

//----------------------------------------------------------------------------------
// reads the status register with checksum (8-bit)
//----------------------------------------------------------------------------------
char s_read_statusreg(unsigned char *p_value, unsigned char *p_checksum)
{ 
  unsigned char error=0;
  s_transstart();                   //transmission start
  error=SHT_WriteByte(STATUS_REG_R); //send command to sensor
  *p_value=SHT_ReadByte(ACK);        //read status register (8-bit)
  *p_checksum=SHT_ReadByte(noACK);   //read checksum (8-bit)  
  return error;                     //error=1 in case of no response form the sensor
}

//----------------------------------------------------------------------------------
// writes the status register with checksum (8-bit)
//----------------------------------------------------------------------------------
char s_write_statusreg(unsigned char *p_value)
{ 
  unsigned char error=0;
  s_transstart();                   //transmission start
  error+=SHT_WriteByte(STATUS_REG_W);//send command to sensor
  error+=SHT_WriteByte(*p_value);    //send value of status register
  return error;                     //error>=1 in case of no response form the sensor
}


void delay_us(int t)
{int i;
	for(i=0;i<t;i++)
	{	
		_nop_();
	}
}

void delay_ms(int t)
{int i;
	for(i=0;i<t;i++)
	delay_us(1000);
}