shtxx.c

用mega8写的SHTXX系列温湿度芯片的驱动程序

/********************************************* 
This program was produced by the 
CodeWizardAVR V1.23.8c Professional 
Automatic Program Generator 
?Copyright 1998-2003 HP InfoTech s.r.l. 
http://www.hpinfotech.ro 
e-mail:[e-mail] 

Project :  
Version :  
Date    : 30.03.2004 
Author  : Nick Schres                      
Company :                                  
Comments:  


Chip type           : ATmega8 
Program type        : Application 
Clock frequency     : 8,000000 MHz 
Memory model        : Small 
External SRAM size  : 0 
Data Stack size     : 256 
*********************************************/ 

#include <mega8.h>  
#include <delay.h>       
#include <stdlib.h> 

// Alphanumeric LCD Module functions 
#asm 
   .equ __lcd_port=0x12 
#endasm 
#include <lcd.h> 

// Declare your global variables here    

char s_write_byte(unsigned char value);  
char s_read_byte(unsigned char ack);    
void s_transstart(void);            
void s_connectionreset(void);           
char s_softreset(void);      
char s_read_statusreg(unsigned char *p_value, unsigned char *p_checksum); 
char s_write_statusreg(unsigned char *p_value); 
char s_measure(unsigned char *p_value, unsigned char *p_checksum, unsigned char mode); 
void calc_sth11(float *p_humidity ,float *p_temperature); 




typedef union  
{ unsigned int i; 
  float f; 
} value; 
  

enum {TEMP,HUMI}; 

#define        DATA_OUT           PORTC.0 
#define DATA_IN                PINC.0 
#define        SCK                   PORTC.1  

#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 

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


// Input/Output Ports initialization 
// Port B initialization 
// Func0=In Func1=In Func2=In Func3=In Func4=In Func5=In Func6=In Func7=In  
// State0=T State1=T State2=T State3=T State4=T State5=T State6=T State7=T  
PORTB=0x00; 
DDRB=0x00; 

// Port C initialization 
// Func0=In Func1=Out Func2=In Func3=In Func4=In Func5=In Func6=In  
// State0=T State1=0 State2=T State3=T State4=T State5=T State6=T  
PORTC=0x00; 
DDRC=0x02; 

// Port D initialization 
// Func0=In Func1=In Func2=In Func3=In Func4=In Func5=In Func6=In Func7=In  
// State0=T State1=T State2=T State3=T State4=T State5=T State6=T State7=T  
PORTD=0x00; 
DDRD=0x00; 

// Timer/Counter 0 initialization 
// Clock source: System Clock 
// Clock value: Timer 0 Stopped 
TCCR0=0x00; 
TCNT0=0x00; 

// Timer/Counter 1 initialization 
// Clock source: System Clock 
// Clock value: Timer 1 Stopped 
// Mode: Normal top=FFFFh 
// OC1A output: Discon. 
// OC1B output: Discon. 
// Noise Canceler: Off 
// Input Capture on Falling Edge 
TCCR1A=0x00; 
TCCR1B=0x00; 
TCNT1H=0x00; 
TCNT1L=0x00; 
OCR1AH=0x00; 
OCR1AL=0x00; 
OCR1BH=0x00; 
OCR1BL=0x00; 

// Timer/Counter 2 initialization 
// Clock source: System Clock 
// Clock value: Timer 2 Stopped 
// Mode: Normal top=FFh 
// OC2 output: Disconnected 
ASSR=0x00; 
TCCR2=0x00; 
TCNT2=0x00; 
OCR2=0x00; 

// External Interrupt(s) initialization 
// INT0: Off 
// INT1: Off 
GICR|=0x00; 
MCUCR=0x00; 

// Timer(s)/Counter(s) Interrupt(s) initialization 
TIMSK=0x00; 

// Analog Comparator initialization 
// Analog Comparator: Off 
// Analog Comparator Input Capture by Timer/Counter 1: Off 
// Analog Comparator Output: Off 
ACSR=0x80; 
SFIOR=0x00; 

// LCD module initialization 
lcd_init(20); 


// sample program that shows how to use SHT11 functions 
// 1. connection reset  
// 2. measure humidity [ticks](12 bit) and temperature [ticks](14 bit) 
// 3. calculate humidity [%RH] and temperature [癈] 
// 4. print temperature, humidity 
    
    s_connectionreset();      
   
  while(1) 
  { error=0;             
//    delay_ms(200);          
//    error+=s_measure((unsigned char*) &humi_val.i,&checksum,HUMI);  //measure humidity 
//    delay_ms(200); 
//    error+=s_measure((unsigned char*) &temp_val.i,&checksum,TEMP);  //measure temperature     

              
       error += s_read_statusreg(&inp, &checksum); 

    if(error!=0)  
       {s_connectionreset();                 //in case of an error: connection reset 
       lcd_clear(); 
       lcd_gotoxy(0,0); 
       lcd_putsf("Error");       
  
  
       }        
    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 
       
      itoa(inp,&outp);  
                            
      lcd_clear(); 
      lcd_gotoxy(0,0); 
      lcd_puts(&outp);               
                                     
      itoa(humi_val.i,&outp);        
      lcd_gotoxy(0,2); 
      lcd_puts(&outp);               
    } 
    //----------wait approx. 0.8s to avoid heating up SHTxx------------------------------       
    delay_ms(800); 
    //-----------------------------------------------------------------------------------                        
  } 
}                              


//---------------------------------------------------------------------------------- 
// writes a byte on the Sensibus and checks the acknowledge  
//---------------------------------------------------------------------------------- 
    
    
char s_write_byte(unsigned char value) 
{  
  unsigned char i,error=0;   
  DDRC = 0b00000011;    // DATA Ausgang 
  for (i=0x80;i>0;i/=2)                     //shift bit for masking 
  {  
    if (i & value)         DATA_OUT=1;                //masking value with i , write to SENSI-BUS 
    else DATA_OUT=0;    
    delay_us(2);                      
    SCK=1;                          //clk for SENSI-BUS 
    delay_us(5);                                                //pulswith approx. 5 us           
    SCK=0;        
  }       
  DATA_OUT=0;                           
  DDRC = 0b00000010;    // DATA Eingang 
  SCK=1;                           //clk #9 for ack  
  delay_us(2); 
  error=DATA_IN;                    //check ack (DATA will be pulled down by SHT11) 
  delay_us(2); 
  SCK=0;         
  return error;                             //error=1 in case of no acknowledge 
} 
 /* 
 char s_write_byte(unsigned char value) 
{  
  unsigned char i,error=0;        
  DDRC = 0b00000011;    // DATA Ausgang 
  for (i=0x80;i>0;i/=2)                //shift bit for masking 
  { if (i & value) DATA_OUT=1;         //masking value with i , write to SENSI-BUS 
    else DATA_OUT=0;      
                    
    SCK=1;                             //clk for SENSI-BUS 
    delay_us(5);                       //pulswith approx. 5 us           
    SCK=0; 
  } 
  DDRC = 0b00000010;    // DATA Eingang   
  delay_us(2);                       //pulswith approx. 5 us           
  SCK=1;                               //clk #9 for ack          
  delay_us(5);                       //pulswith approx. 5 us           
  error=DATA_IN;                       //check ack (DATA will be pulled down by SHT11) 
  SCK=0;        
  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 s_read_byte(unsigned char ack) 
{  
  unsigned char i,val=0; 
  DDRC = 0b00000010;    // DATA Eingang 
  for (i=0x80;i>0;i/=2)             //shift bit for masking 
  { SCK=1;                          //clk for SENSI-BUS        
    delay_us(2); 
    if (DATA_IN) val=(val | i);        //read bit   
    SCK=0;                                            
    delay_us(2); 
  }    
  DDRC = 0b00000011;    // DATA Ausgang 
  DATA_OUT=!ack;                        //in case of "ack==1" pull down DATA-Line 
  SCK=1;                            //clk #9 for ack 
  delay_us(5);          //pulswith approx. 5 us  
  SCK=0;                                                                          
  DDRC = 0b00000010;    // DATA Eingang 
  return val; 
} 
                          

//---------------------------------------------------------------------------------- 
// generates a transmission start  
//       _____         ________ 
// DATA:      |_______| 
//           ___     ___ 
// SCK : ___|   |___|   |______ 
//---------------------------------------------------------------------------------- 

void s_transstart(void) 
{           
   DDRC = 0b00000011;    // DATA Ausgang 
   DATA_OUT=1; SCK=0;                   //Initial state 
   delay_us(2); 
   SCK=1; 
   delay_us(2); 
   DATA_OUT=0; 
   delay_us(2); 
   SCK=0;   
   delay_us(5); 
   SCK=1; 
   delay_us(2); 
   DATA_OUT=1;                    
   delay_us(2); 
   SCK=0;       
   DDRC = 0b00000010;    // DATA Eingang 
}                                        

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

void s_connectionreset(void) 
{   
  unsigned char i;  
  DDRC = 0b00000011;    // DATA Ausgang 
  DATA_OUT=1; SCK=0;                    //Initial state 
  for(i=0;i<9;i++)                  //9 SCK cycles 
  { SCK=1;  
    delay_us(1); 
    SCK=0; 
    delay_us(1); 
  } 
  s_transstart();                   //transmission start 
  DDRC = 0b00000010;    // DATA Eingang 
} 
           
//---------------------------------------------------------------------------------- 
// resets the sensor by a softreset  
//---------------------------------------------------------------------------------- 

char s_softreset(void) 
{  
  unsigned char error=0;   
  s_connectionreset();              //reset communication 
  error+=s_write_byte(RESET);       //send RESET-command to sensor 
  return error;                     //error=1 in case of no response form the sensor 
} 
            
//---------------------------------------------------------------------------------- 
// 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=s_write_byte(STATUS_REG_R); //send command to sensor 
  *p_value=s_read_byte(ACK);        //read status register (8-bit) 
  *p_checksum=s_read_byte(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+=s_write_byte(STATUS_REG_W);//send command to sensor 
  error+=s_write_byte(*p_value);    //send value of status register 
  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; 

  s_transstart();                   //transmission start     

  switch(mode){                     //send command to sensor 
    case TEMP        : error+=s_write_byte(MEASURE_TEMP); break; 
    case HUMI        : error+=s_write_byte(MEASURE_HUMI); break; 
    default     : break;          
  }                   
  DDRC = 0b00000010;    // DATA Eingang        
  while (1) 
  { 
   if(DATA_IN==0) break; //wait until sensor has finished the measurement 
  } 
  
  
  if(DATA_IN) error+=1;                // or timeout (~2 sec.) is reached      
               
  if (error!=0) 
 { 
 lcd_clear(); 
 lcd_gotoxy(0,0); 
 lcd_putsf("FEHLER"); 
 while(1);  
  
 } 
   
  *(p_value)  =s_read_byte(ACK);    //read the first byte (MSB) 
  *(p_value+1)=s_read_byte(ACK);    //read the second byte (LSB) 
  *p_checksum =s_read_byte(noACK);  //read checksum      
  return error; 
} 

//---------------------------------------------------------------------------------------- 
// calculates temperature [癈] and humidity [%RH]  
// input :  humi [Ticks] (12 bit)  
//          temp [Ticks] (14 bit) 
// output:  humi [%RH] 
//          temp [癈] 
//---------------------------------------------------------------------------------------- 
  
  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 T1=+0.01;             // for 14 Bit @ 5V 
  const float T2=+0.00008;           // for 14 Bit @ 5V         
   
void calc_sth11(float *p_humidity ,float *p_temperature) 
{ 

  float rh; 
  float t; 
  float rh_lin;                     // rh_lin:  Humidity linear 
  float rh_true;                    // rh_true: Temperature compensated humidity 
  float t_C;                        // t_C   :  Temperature [癈] 
            
  rh =*p_humidity;             // rh:      Humidity [Ticks] 12 Bit  
  t =*p_temperature;           // t:       Temperature [Ticks] 14 Bit 
   
  t_C=t*0.01 - 40;                  //calc. temperature from ticks to [癈] 
  rh_lin=C3*rh*rh + C2*rh + C1;     //calc. humidity from ticks to [%RH] 
  rh_true=(t_C-25)*(T1+T2*rh)+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] 
}