请教sht10温湿度传感器问题

最近用一个arm的cortex-m0 MCU做一个温湿度传感器，使用的传感器芯片是SHT10,，使用过程中遇到一些问题，特发此贴寻求帮助。
1、关于硬件电路，基本上按照官方给的datasheet做的，只是VDD使用的是3.3V。
2、软件实现在下面给出，基本是官方给的样例修改的。
3、遇到的问题，温度结果过高，湿度结果过低。但是总体上是成线性的。在24~25度室温下，测出温度为30~31度，湿度更谈不上准确。在低温环境下，温度数值也立刻下降，比如放在零度左右，测得8度。
4、我想请问你们用这款传感器时温度是否需要修正，谢谢。

1. void SHT10_con_init()
   
2. {
   
3.     SHT10_SCL_CFG();
   
4.     SHT10_SDA_CFG();
   
5. 
   
6.     SHT10_SCL_OUTPUT();
   
7.     SHT10_SCL_LOW();
   
8.     SHT10_SDA_INPUT();
   
9.     SHT10_delay_half();
   
10. }
    
11. 
    
12. void SHT10_con_wait()
    
13. {
    
14.     SHT10_SCL_LOW();
    
15.     SHT10_delay_half();
    
16.     SHT10_SDA_INPUT();
    
17.     SHT10_delay_half();
    
18. }
    
19. 
    
20. void SHT10_con_reset()
    
21. {
    
22.     uint8_t i;
    
23.     SHT10_SDA_OUTPUT();
    
24.     SHT10_SDA_HIGH();
    
25.     SHT10_SCL_LOW();
    
26.     SHT10_delay_half();
    
27.     for( i=0 ; i<9 ; i++ )
    
28.     {
    
29.         SHT10_SCL_HIGH();
    
30.         SHT10_delay();
    
31.         SHT10_SCL_LOW();
    
32.         SHT10_delay();
    
33.     }
    
34. 
    
35.     SHT10_start_transfers();
    
36. }
    
37. 
    
38. void SHT10_start_transfers()
    
39. {
    
40.     SHT10_SDA_OUTPUT();
    
41.     SHT10_SDA_HIGH();
    
42.     SHT10_SCL_LOW();
    
43.     SHT10_delay_half();
    
44. 
    
45.     SHT10_SCL_HIGH();
    
46.     SHT10_delay_half();
    
47.     SHT10_SDA_LOW();
    
48.     SHT10_delay_half();
    
49. 
    
50.     SHT10_SCL_LOW();
    
51.     SHT10_delay();
    
52. 
    
53.     SHT10_SCL_HIGH();
    
54.     SHT10_delay_half();
    
55.     SHT10_SDA_HIGH();
    
56.     SHT10_delay_half();
    
57.    
    
58.     SHT10_SCL_LOW();
    
59. }
    
60. 
    
61. int SHT10_write_byte(uint8_t data)
    
62. {
    
63.     uint8_t i;
    
64.     SHT10_SDA_OUTPUT();
    
65.     for (i=0x80;i>0;i>>=1)
    
66.     {   
    
67.         if(i&data)
    
68.                 {
    
69.             SHT10_SDA_HIGH();
    
70.                 }
    
71.         else{
    
72.            SHT10_SDA_LOW();
    
73.                 }
    
74.         SHT10_delay_half();
    
75.         SHT10_SCL_HIGH();
    
76.         SHT10_delay();
    
77.                 SHT10_SCL_LOW();
    
78.         SHT10_delay_half();
    
79.     }
    
80.     SHT10_SCL_LOW();
    
81.     SHT10_SDA_INPUT();
    
82.     SHT10_delay();
    
83.     SHT10_SCL_HIGH();
    
84.    
    
85.     if(SHT10_SDA_READ())
    
86.     {
    
87.         SHT10_SCL_LOW();
    
88.         return -1;
    
89.     }
    
90.     SHT10_SCL_LOW();
    
91.     return 0;
    
92. }
    
93. 
    
94. uint8_t SHT10_read_byte(uint8_t ack)
    
95. {
    
96.     uint8_t i;
    
97.         uint8_t value;
    
98.     SHT10_SDA_OUTPUT();
    
99.     SHT10_SDA_HIGH();
    
100.     SHT10_delay_half();
     
101.     SHT10_SDA_INPUT();
     
102. 
     
103.     value = 0;
     
104.     for(i=0x80;i>0;i>>=1)
     
105.     {
     
106.         SHT10_SCL_HIGH();
     
107.         SHT10_delay_half();
     
108.         if(SHT10_SDA_READ())
     
109.                 {
     
110.                         value |=i;
     
111.                 }
     
112.                 );
     
113.         SHT10_delay_half();
     
114.         SHT10_SCL_LOW();
     
115.         SHT10_delay();
     
116.     }
     
117.     SHT10_SDA_OUTPUT();
     
118.         if(ack)
     
119.         {
     
120.         SHT10_SDA_LOW();
     
121.     }else{
     
122.                 SHT10_SDA_HIGH();
     
123.         }
     
124.         SHT10_delay_half();
     
125.     SHT10_SCL_HIGH();
     
126.     SHT10_delay();
     
127.     SHT10_SCL_LOW();
     
128.     SHT10_SDA_INPUT();
     
129.     return value;
     
130. }
     
131. 
     
132. int SHT10_reset()
     
133. {
     
134.     SHT10_con_reset();
     
135.         return SHT10_write_byte(SHT10_CMD_RESET);
     
136. }
     
137. int SHT10_set_status(uint8_t status)
     
138. {
     
139.     SHT10_start_transfers();
     
140.         if(SHT10_write_byte(SHT10_CMD_STATUS_WRITE))
     
141.         {
     
142.                 return -1;
     
143.         }
     
144.         return SHT10_write_byte(status);       
     
145. }
     
146. int SHT10_read_status(uint8_t *status)
     
147. {
     
148.     uint8_t ack;
     
149.         SHT10_start_transfers();
     
150.         if(SHT10_write_byte(SHT10_CMD_STATUS_READ))
     
151.         {
     
152.                 return -1;
     
153.         }
     
154.     *status = SHT10_read_byte(1);
     
155.         ack = SHT10_read_byte(1);
     
156.         return  0;
     
157. }
     
158. int SHT10_temp_measure_start()
     
159. {
     
160.     uint16_t result = 0;
     
161.         SHT10_start_transfers();
     
162.         if(SHT10_write_byte(SHT10_CMD_TEMP_MS))
     
163.         {
     
164.                 return -1;
     
165.         }
     
166.         SHT10_con_wait();
     
167.         sensor_mod = SHT10_Measure_Temperature;
     
168.         app_timer_start(sht10_time,MEASURE_TEMP_WAIT_TICK,NULL);
     
169.         return 0;
     
170.        
     
171. }
     
172. int SHT10_humi_measure_start()
     
173. {
     
174.         uint16_t result = 0;
     
175.         SHT10_start_transfers();
     
176.         if(SHT10_write_byte(SHT10_CMD_HUMI_MS))
     
177.         {
     
178.                 return -1;
     
179.         }
     
180. 
     
181.         SHT10_con_wait();
     
182.         sensor_mod = SHT10_Measure_Humidity;
     
183.         app_timer_start(sht10_time,MEASURE_HUMI_WAIT_TICK,NULL);
     
184.         return 0;
     
185.        
     
186. }
     
187. /*测量结果是使用一个定时器触发后再去读取的，没有使用循环等待*/
     
188. int SHT10_receive_value(uint16_t *value)
     
189. {
     
190.         uint16_t data,count;
     
191.         uint8_t values[3] = {0,0,0};
     
192.         count = 0;
     
193.     while(SHT10_SDA_READ())
     
194.     {
     
195.                 count++;
     
196.                 if(count>=1000)
     
197.                 {
     
198.                         return -1;
     
199.                 }
     
200.                 nrf_delay_ms(1);
     
201.     }
     
202.         values[0] = SHT10_read_byte(1);
     
203.         values[1] = SHT10_read_byte(0);
     
204.         *value  = (values[0] << 8) + values[1];
     
205.         return 0;
     
206. }
     
207. float SHT10_get_temp_value(float temp)
     
208. {
     
209.     return (temp * 0.01 - 40.1);
     
210. }
     
211. float SHT10_get_humi_value(float humi)
     
212. {
     
213.     const float c1=-4.0;      // for 12 Bit
     
214.     const float c2=0.0405;     // for 12 Bit
     
215.     const float c3=-2.8E-6;     // for 12 Bit
     
216.     const float t1=0.01;      // for 14 Bit @ 5V
     
217.     const float t2=0.00008;     // for 14 Bit @ 5V
     
218.         float linear,value;
     
219.         linear = humi * humi *(c3)+(humi)*c2+c1;
     
220.         value = (temperature_value - 25.0)*(t1+t2*humi)+linear;
     
221.         return value;
     
222. }
     
223. 
     
224. void app_sht10_timeout_handler_t(void * p_context)
     
225. {
     
226.         uint16_t result = 0;
     
227.         //UNUSED_PARAMETER(p_context);
     
228.         if(sensor_mod == SHT10_Measure_Temperature)
     
229.         {
     
230.                 if(SHT10_receive_value(&result))
     
231.             {
     
232.                         sensor_mod = SHT10_ERROR;
     
233.             }
     
234.             temperature_value = SHT10_get_temp_value((float)result);
     
235.                 SHT10_humi_measure_start();
     
236.         }else if(sensor_mod == SHT10_Measure_Humidity)
     
237.         {
     
238.                 if(SHT10_receive_value(&result))
     
239.             {
     
240.                         sensor_mod = SHT10_ERROR;
     
241.             }
     
242. 
     
243.             humidity_value = SHT10_get_humi_value((float)result);
     
244.                 sensor_mod = SHT10_Measure_Free;
     
245.                 is_SHT10_busy = 0;
     
246.         }
     
247. }
     
248. int SHT10_init()
     
249. {
     
250.         uint8_t status;
     
251.         if(is_SHT10_busy)
     
252.                 return -1;
     
253.         is_SHT10_busy = 0;
     
254.         nrf_delay_ms(20);
     
255.         SHT10_con_init();
     
256.     SHT10_reset();
     
257.         nrf_delay_ms(11);
     
258.         sensor_mod = SHT10_Measure_Free;
     
259.         SHT10_set_status(0);
     
260.         app_timer_create(&sht10_time,APP_TIMER_MODE_SINGLE_SHOT,app_sht10_timeout_handler_t);
     
261.         return 0;
     
262. }
     
263. int SHT10_measure_start()
     
264. {
     
265.         if(is_SHT10_busy)
     
266.                 return -1;
     
267.         is_SHT10_busy = 1;
     
268.         if(SHT10_temp_measure_start())
     
269.         {
     
270.                 SHT10_con_reset();
     
271.                 is_SHT10_busy = 0;
     
272.                 return -1;
     
273.         }
     
274.         return 0;
     
275. }
     
276. int SHT10_pop_value(float *temp,float *humi)
     
277. {
     
278.         if(is_SHT10_busy)
     
279.                 return -1;
     
280.         *temp = temperature_value;
     
281.         *humi = humidity_value;
     
282.         return 0;
     
283. }

复制代码