Debian Codegraph @

bme280.go

raw
1 //--------------------------------------------------------------------------------------------------
2 //
3 // Copyright (c) 2018 Denis Dyakov
4 //
5 // Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
6 // associated documentation files (the "Software"), to deal in the Software without restriction,
7 // including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense,
8 // and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so,
9 // subject to the following conditions:
10 //
11 // The above copyright notice and this permission notice shall be included in all copies or substantial
12 // portions of the Software.
13 //
14 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING
15 // BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
16 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
17 // DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
18 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
19 //
20 //--------------------------------------------------------------------------------------------------
21
22 package bsbmp
23
24 import (
25 "bytes"
26 "encoding/binary"
27 "errors"
28 "fmt"
29
30 i2c "github.com/d2r2/go-i2c"
31 )
32
33 // BME280 sensors memory map
34 const (
35 // BME280 general registers
36 BME280_ID_REG = 0xD0
37 BME280_CTRL_HUM = 0xF2
38 BME280_STATUS = 0xF3
39 BME280_CTRL_MEAS = 0xF4
40 BME280_CONFIG = 0xF5 // TODO: support IIR filter settings
41 BME280_RESET = 0xE0
42 // BME280 specific compensation register's blocks
43 BME280_COEF_PART1_START = 0x88
44 BME280_COEF_PART1_BYTES = 12 * 2
45 BME280_COEF_PART2_START = 0xA1
46 BME280_COEF_PART2_BYTES = 1
47 BME280_COEF_PART3_START = 0xE1
48 BME280_COEF_PART3_BYTES = 1*2 + 5
49 // BME280 specific 3-byte reading out temprature and preassure
50 BME280_PRESS_OUT_MSB_LSB_XLSB = 0xF7
51 BME280_TEMP_OUT_MSB_LSB_XLSB = 0xFA
52 BME280_HUM_OUT_MSB_LSB = 0xFD
53 )
54
55 // Unique BME280 calibration coefficients
56 type CoeffBME280 struct {
57 // Registers storing unique calibration coefficients.
58 // Block 1
59 COEF_88 uint8
60 COEF_89 uint8
61 COEF_8A uint8
62 COEF_8B uint8
63 COEF_8C uint8
64 COEF_8D uint8
65 COEF_8E uint8
66 COEF_8F uint8
67 COEF_90 uint8
68 COEF_91 uint8
69 COEF_92 uint8
70 COEF_93 uint8
71 COEF_94 uint8
72 COEF_95 uint8
73 COEF_96 uint8
74 COEF_97 uint8
75 COEF_98 uint8
76 COEF_99 uint8
77 COEF_9A uint8
78 COEF_9B uint8
79 COEF_9C uint8
80 COEF_9D uint8
81 COEF_9E uint8
82 COEF_9F uint8
83 // Block 2
84 COEF_A1 uint8
85 // Block 3
86 COEF_E1 uint8
87 COEF_E2 uint8
88 COEF_E3 uint8
89 COEF_E4 uint8
90 COEF_E5 uint8
91 COEF_E6 uint8
92 COEF_E7 uint8
93 }
94
95 func (v *CoeffBME280) dig_T1() uint16 {
96 return uint16(v.COEF_89)<<8 | uint16(v.COEF_88)
97 }
98
99 func (v *CoeffBME280) dig_T2() int16 {
100 return int16(uint16(v.COEF_8B)<<8 | uint16(v.COEF_8A))
101 }
102
103 func (v *CoeffBME280) dig_T3() int16 {
104 return int16(uint16(v.COEF_8D)<<8 | uint16(v.COEF_8C))
105 }
106
107 func (v *CoeffBME280) dig_P1() uint16 {
108 return uint16(v.COEF_8F)<<8 | uint16(v.COEF_8E)
109 }
110
111 func (v *CoeffBME280) dig_P2() int16 {
112 return int16(uint16(v.COEF_91)<<8 | uint16(v.COEF_90))
113 }
114
115 func (v *CoeffBME280) dig_P3() int16 {
116 return int16(uint16(v.COEF_93)<<8 | uint16(v.COEF_92))
117 }
118
119 func (v *CoeffBME280) dig_P4() int16 {
120 return int16(uint16(v.COEF_95)<<8 | uint16(v.COEF_94))
121 }
122
123 func (v *CoeffBME280) dig_P5() int16 {
124 return int16(uint16(v.COEF_97)<<8 | uint16(v.COEF_96))
125 }
126
127 func (v *CoeffBME280) dig_P6() int16 {
128 return int16(uint16(v.COEF_99)<<8 | uint16(v.COEF_98))
129 }
130
131 func (v *CoeffBME280) dig_P7() int16 {
132 return int16(uint16(v.COEF_9B)<<8 | uint16(v.COEF_9A))
133 }
134
135 func (v *CoeffBME280) dig_P8() int16 {
136 return int16(uint16(v.COEF_9D)<<8 | uint16(v.COEF_9C))
137 }
138
139 func (v *CoeffBME280) dig_P9() int16 {
140 return int16(uint16(v.COEF_9F)<<8 | uint16(v.COEF_9E))
141 }
142
143 func (v *CoeffBME280) dig_H1() uint8 {
144 return uint8(v.COEF_A1)
145 }
146
147 func (v *CoeffBME280) dig_H2() int16 {
148 return int16(uint16(v.COEF_E2)<<8 | uint16(v.COEF_E1))
149 }
150
151 func (v *CoeffBME280) dig_H3() uint8 {
152 return uint8(v.COEF_E3)
153 }
154
155 func (v *CoeffBME280) dig_H4() int16 {
156 return int16(uint16(v.COEF_E4)<<4 | uint16(v.COEF_E5&0x0F))
157 }
158
159 func (v *CoeffBME280) dig_H5() int16 {
160 return int16(uint16(v.COEF_E6)<<4 | uint16((v.COEF_E5>>4)&0x0F))
161 }
162
163 func (v *CoeffBME280) dig_H6() int8 {
164 return int8(v.COEF_E7)
165 }
166
167 // SensorBME280 specific type
168 type SensorBME280 struct {
169 Coeff *CoeffBME280
170 }
171
172 // Static cast to verify at compile time
173 // that type implement interface.
174 var _ SensorInterface = &SensorBME280{}
175
176 // ReadSensorID reads sensor signature. It may be used for validation,
177 // that proper code settings used for sensor data decoding.
178 func (v *SensorBME280) ReadSensorID(i2c *i2c.I2C) (uint8, error) {
179 id, err := i2c.ReadRegU8(BME280_ID_REG)
180 if err != nil {
181 return 0, err
182 }
183 return id, nil
184 }
185
186 // ReadCoefficients reads compensation coefficients, unique for each sensor.
187 func (v *SensorBME280) ReadCoefficients(i2c *i2c.I2C) error {
188 // read coefficients #1
189 _, err := i2c.WriteBytes([]byte{BME280_COEF_PART1_START})
190 if err != nil {
191 return err
192 }
193 var coef1 [BME280_COEF_PART1_BYTES]byte
194 err = readDataToStruct(i2c, BME280_COEF_PART1_BYTES,
195 binary.LittleEndian, &coef1)
196 if err != nil {
197 return err
198 }
199
200 // read coefficients #2
201 _, err = i2c.WriteBytes([]byte{BME280_COEF_PART2_START})
202 if err != nil {
203 return err
204 }
205 var coef2 [BME280_COEF_PART2_BYTES]byte
206 err = readDataToStruct(i2c, BME280_COEF_PART2_BYTES,
207 binary.LittleEndian, &coef2)
208 if err != nil {
209 return err
210 }
211
212 // read coefficients #3
213 _, err = i2c.WriteBytes([]byte{BME280_COEF_PART3_START})
214 if err != nil {
215 return err
216 }
217 var coef3 [BME280_COEF_PART3_BYTES]byte
218 err = readDataToStruct(i2c, BME280_COEF_PART3_BYTES,
219 binary.LittleEndian, &coef3)
220 if err != nil {
221 return err
222 }
223
224 // combine coefficients altogether in single structure
225 arr := coef1[:]
226 arr = append(arr, coef2[:]...)
227 arr = append(arr, coef3[:]...)
228 buf := bytes.NewBuffer(arr)
229 coeff := &CoeffBME280{}
230 err = binary.Read(buf, binary.LittleEndian, coeff)
231 if err != nil {
232 return err
233 }
234 v.Coeff = coeff
235 return nil
236 }
237
238 // IsValidCoefficients verify that compensate registers
239 // are not empty, and thus are valid.
240 func (v *SensorBME280) IsValidCoefficients() error {
241 if v.Coeff != nil {
242 err := checkCoefficient(v.Coeff.dig_T1(), "dig_T1")
243 if err != nil {
244 return err
245 }
246 err = checkCoefficient(uint16(v.Coeff.dig_T2()), "dig_T2")
247 if err != nil {
248 return err
249 }
250 err = checkCoefficient(uint16(v.Coeff.dig_T3()), "dig_T3")
251 if err != nil {
252 return err
253 }
254 err = checkCoefficient(v.Coeff.dig_P1(), "dig_P1")
255 if err != nil {
256 return err
257 }
258 err = checkCoefficient(uint16(v.Coeff.dig_P2()), "dig_P2")
259 if err != nil {
260 return err
261 }
262 err = checkCoefficient(uint16(v.Coeff.dig_P3()), "dig_P3")
263 if err != nil {
264 return err
265 }
266 err = checkCoefficient(uint16(v.Coeff.dig_P4()), "dig_P4")
267 if err != nil {
268 return err
269 }
270 err = checkCoefficient(uint16(v.Coeff.dig_P5()), "dig_P5")
271 if err != nil {
272 return err
273 }
274 err = checkCoefficient(uint16(v.Coeff.dig_P6()), "dig_P6")
275 if err != nil {
276 return err
277 }
278 err = checkCoefficient(uint16(v.Coeff.dig_P7()), "dig_P7")
279 if err != nil {
280 return err
281 }
282 err = checkCoefficient(uint16(v.Coeff.dig_P8()), "dig_P8")
283 if err != nil {
284 return err
285 }
286 err = checkCoefficient(uint16(v.Coeff.dig_P9()), "dig_P9")
287 if err != nil {
288 return err
289 }
290 } else {
291 err := errors.New("CoeffBME280 struct does not build")
292 return err
293 }
294 return nil
295 }
296
297 // RecognizeSignature returns description of signature if it valid,
298 // otherwise - error.
299 func (v *SensorBME280) RecognizeSignature(signature uint8) (string, error) {
300 switch signature {
301 case 0x60:
302 return "BME280", nil
303 default:
304 return "", errors.New(fmt.Sprintf("signature 0x%x doesn't belong to BME280 series", signature))
305 }
306 }
307
308 // IsBusy reads register 0xF3 for "busy" flag,
309 // according to sensor specification.
310 func (v *SensorBME280) IsBusy(i2c *i2c.I2C) (busy bool, err error) {
311 // Check flag to know status of calculation, according
312 // to specification about SCO (Start of conversion) flag
313 b, err := i2c.ReadRegU8(BME280_STATUS)
314 if err != nil {
315 return false, err
316 }
317 b = b & 0x8
318 lg.Debugf("Busy flag=0x%0X", b)
319 return b != 0, nil
320 }
321
322 func (v *SensorBME280) getOversamplingRation(accuracy AccuracyMode) byte {
323 var b byte
324 switch accuracy {
325 case ACCURACY_ULTRA_LOW:
326 b = 1
327 case ACCURACY_LOW:
328 b = 2
329 case ACCURACY_STANDARD:
330 b = 3
331 case ACCURACY_HIGH:
332 b = 4
333 case ACCURACY_ULTRA_HIGH:
334 b = 5
335 default:
336 // assign accuracy to lowest resolution by default
337 b = 1
338 }
339 return b
340 }
341
342 // readUncompTemprature reads uncompensated temprature from sensor.
343 func (v *SensorBME280) readUncompTemprature(i2c *i2c.I2C, accuracy AccuracyMode) (int32, error) {
344 var power byte = 1 // Forced mode
345 osrt := v.getOversamplingRation(accuracy)
346 err := i2c.WriteRegU8(BME280_CTRL_MEAS, power|(osrt<<5))
347 if err != nil {
348 return 0, err
349 }
350 _, err = waitForCompletion(v, i2c)
351 if err != nil {
352 return 0, err
353 }
354 buf, _, err := i2c.ReadRegBytes(BME280_TEMP_OUT_MSB_LSB_XLSB, 3)
355 if err != nil {
356 return 0, err
357 }
358 ut := int32(buf[0])<<12 + int32(buf[1])<<4 + int32(buf[2]&0xF0)>>4
359 return ut, nil
360 }
361
362 // readUncompPressure reads uncompensated atmospheric pressure from sensor.
363 func (v *SensorBME280) readUncompPressure(i2c *i2c.I2C, accuracy AccuracyMode) (int32, error) {
364 var power byte = 1 // Forced mode
365 osrp := v.getOversamplingRation(accuracy)
366 err := i2c.WriteRegU8(BME280_CTRL_MEAS, power|(osrp<<2))
367 if err != nil {
368 return 0, err
369 }
370 _, err = waitForCompletion(v, i2c)
371 if err != nil {
372 return 0, err
373 }
374 buf, _, err := i2c.ReadRegBytes(BME280_PRESS_OUT_MSB_LSB_XLSB, 3)
375 if err != nil {
376 return 0, err
377 }
378 up := int32(buf[0])<<12 + int32(buf[1])<<4 + int32(buf[2]&0xF0)>>4
379 return up, nil
380 }
381
382 // readUncompHumidity reads uncompensated humidity from sensor.
383 func (v *SensorBME280) readUncompHumidity(i2c *i2c.I2C, accuracy AccuracyMode) (int32, error) {
384 var power byte = 1 // Forced mode
385 osrt := v.getOversamplingRation(accuracy)
386 err := i2c.WriteRegU8(BME280_CTRL_MEAS, power|(osrt<<5))
387 if err != nil {
388 return 0, err
389 }
390 _, err = waitForCompletion(v, i2c)
391 if err != nil {
392 return 0, err
393 }
394 osrh := v.getOversamplingRation(ACCURACY_ULTRA_LOW)
395 err = i2c.WriteRegU8(BME280_CTRL_HUM, osrh)
396 if err != nil {
397 return 0, err
398 }
399 _, err = waitForCompletion(v, i2c)
400 if err != nil {
401 return 0, err
402 }
403 buf, _, err := i2c.ReadRegBytes(BME280_HUM_OUT_MSB_LSB, 2)
404 if err != nil {
405 return 0, err
406 }
407 uh := int32(buf[0])<<8 + int32(buf[1])
408 return uh, nil
409 }
410
411 // readUncompTempratureAndPressure reads temprature and
412 // atmospheric uncompensated pressure from sensor.
413 // BME280 allows to read temprature and pressure in one cycle,
414 // BMP180 - doesn't.
415 func (v *SensorBME280) readUncompTempratureAndPressure(i2c *i2c.I2C,
416 accuracy AccuracyMode) (temprature int32, pressure int32, err error) {
417 var power byte = 1 // Forced mode
418 osrt := v.getOversamplingRation(ACCURACY_STANDARD)
419 osrp := v.getOversamplingRation(accuracy)
420 err = i2c.WriteRegU8(BME280_CTRL_MEAS, power|(osrt<<5)|(osrp<<2))
421 if err != nil {
422 return 0, 0, err
423 }
424 _, err = waitForCompletion(v, i2c)
425 if err != nil {
426 return 0, 0, err
427 }
428 buf, _, err := i2c.ReadRegBytes(BME280_TEMP_OUT_MSB_LSB_XLSB, 3)
429 if err != nil {
430 return 0, 0, err
431 }
432 ut := int32(buf[0])<<12 + int32(buf[1])<<4 + int32(buf[2]&0xF0)>>4
433 buf, _, err = i2c.ReadRegBytes(BME280_PRESS_OUT_MSB_LSB_XLSB, 3)
434 if err != nil {
435 return 0, 0, err
436 }
437 up := int32(buf[0])<<12 + int32(buf[1])<<4 + int32(buf[2]&0xF0)>>4
438 return ut, up, nil
439 }
440
441 // ReadTemperatureMult100C reads and calculates temrature in C (celsius) multiplied by 100.
442 // Multiplication approach allow to keep result as integer number.
443 func (v *SensorBME280) ReadTemperatureMult100C(i2c *i2c.I2C, accuracy AccuracyMode) (int32, error) {
444 ut, err := v.readUncompTemprature(i2c, accuracy)
445 if err != nil {
446 return 0, err
447 }
448 err = v.ReadCoefficients(i2c)
449 if err != nil {
450 return 0, err
451 }
452
453 var1 := ((ut>>3 - int32(v.Coeff.dig_T1())<<1) * int32(v.Coeff.dig_T2())) >> 11
454 lg.Debugf("var1=%v", var1)
455 var2 := (((ut>>4 - int32(v.Coeff.dig_T1())) * (ut>>4 - int32(v.Coeff.dig_T1()))) >> 12 *
456 int32(v.Coeff.dig_T3())) >> 14
457 lg.Debugf("var1=%v", var2)
458 tFine := var1 + var2
459 lg.Debugf("t_fine=%v", tFine)
460 t := (tFine*5 + 128) >> 8
461 return t, nil
462 }
463
464 // ReadPressureMult10Pa reads and calculates atmospheric pressure in Pa (Pascal) multiplied by 10.
465 // Multiplication approach allow to keep result as integer number.
466 func (v *SensorBME280) ReadPressureMult10Pa(i2c *i2c.I2C, accuracy AccuracyMode) (uint32, error) {
467 ut, up, err := v.readUncompTempratureAndPressure(i2c, accuracy)
468 if err != nil {
469 return 0, err
470 }
471 lg.Debugf("ut=%v, up=%v", ut, up)
472
473 err = v.ReadCoefficients(i2c)
474 if err != nil {
475 return 0, err
476 }
477
478 var01 := ((ut>>3 - int32(v.Coeff.dig_T1())<<1) * int32(v.Coeff.dig_T2())) >> 11
479 lg.Debugf("var01=%v", var01)
480 var02 := (((ut>>4 - int32(v.Coeff.dig_T1())) * (ut>>4 - int32(v.Coeff.dig_T1()))) >> 12 *
481 int32(v.Coeff.dig_T3())) >> 14
482 lg.Debugf("var01=%v", var02)
483 tFine := var01 + var02
484
485 var1 := int64(tFine) - 128000
486 lg.Debugf("var1=%v", var1)
487 var2 := var1 * var1 * int64(v.Coeff.dig_P6())
488 lg.Debugf("var2=%v", var2)
489 var2 += (var1 * int64(v.Coeff.dig_P5())) << 17
490 var2 += int64(v.Coeff.dig_P4()) << 35
491 lg.Debugf("var2=%v", var2)
492 var1 = (var1*var1*int64(v.Coeff.dig_P3()))>>8 + (var1*int64(v.Coeff.dig_P2()))<<12
493 var1 = ((int64(1)<<47 + var1) * int64(v.Coeff.dig_P1())) >> 33
494 lg.Debugf("var1=%v", var1)
495 if var1 == 0 {
496 return 0, nil
497 }
498 p1 := int64(1048576) - int64(up)
499 p1 = ((p1<<31 - var2) * 3125) / var1
500 var1 = (int64(v.Coeff.dig_P9()) * (p1 >> 13) * (p1 >> 13)) >> 25
501 var2 = (int64(v.Coeff.dig_P8()) * p1) >> 19
502 p1 = (p1+var1+var2)>>8 + int64(v.Coeff.dig_P7())<<4
503 p2 := p1 * 10 / 256
504 p := uint32(p2)
505
506 return p, nil
507 }
508
509 // ReadHumidityMultQ2210 reads and calculate humidity in %RH.
510 // Multiplication approach allow to keep result as integer number.
511 // To get real value it's necessary to divide result by 1024.
512 func (v *SensorBME280) ReadHumidityMultQ2210(i2c *i2c.I2C,
513 accuracy AccuracyMode) (supported bool, humidity uint32, erro error) {
514
515 ut, err := v.readUncompTemprature(i2c, accuracy)
516 if err != nil {
517 return true, 0, err
518 }
519 uh, err := v.readUncompHumidity(i2c, accuracy)
520 if err != nil {
521 return true, 0, err
522 }
523 lg.Debugf("ut=%v, uh=%v", ut, uh)
524 err = v.ReadCoefficients(i2c)
525 if err != nil {
526 return true, 0, err
527 }
528
529 var01 := ((ut>>3 - int32(v.Coeff.dig_T1())<<1) * int32(v.Coeff.dig_T2())) >> 11
530 lg.Debugf("var01=%v", var01)
531 var02 := (((ut>>4 - int32(v.Coeff.dig_T1())) * (ut>>4 - int32(v.Coeff.dig_T1()))) >> 12 *
532 int32(v.Coeff.dig_T3())) >> 14
533 lg.Debugf("var01=%v", var02)
534 tFine := var01 + var02
535 lg.Debugf("t_fine=%v", tFine)
536
537 // Alternative version of humidity calculation from raw value
538 // based on float ariphmetics.
539 //
540 // var var_H float64
541 // var_H = float64(tFine) - 76800.0
542 // var_H = (float64(uh) - ((float64(v.Coeff.dig_H4()))*64.0 + (float64(v.Coeff.dig_H5()))/16384.0*var_H)) *
543 // (float64(v.Coeff.dig_H2()) / 65536.0 * (1.0 + (float64(v.Coeff.dig_H6()) / 67108864.0 * var_H *
544 // (1.0 + (float64(v.Coeff.dig_H3()) / 67108864.0 * var_H)))))
545 // var_H = var_H * (1.0 - (float64(v.Coeff.dig_H1()) * var_H / 524288.0))
546 // if var_H > 100.0 {
547 // var_H = 100.0
548 // }
549 // if var_H < 0.0 {
550 // var_H = 0.0
551 // }
552 // return true, uint32(var_H * 1024), nil
553
554 var v_x1 int32
555 v_x1 = tFine - 76800
556 lg.Debugf("v_x1=%v", v_x1)
557
558 v_x1 = ((((uh << 14) - (int32(v.Coeff.dig_H4()) << 20) - (int32(v.Coeff.dig_H5()) * v_x1)) +
559 16384) >> 15) * (((((((v_x1*int32(v.Coeff.dig_H6()))>>10)*(((v_x1*
560 int32(v.Coeff.dig_H3()))>>11)+32768))>>10)+2097152)*
561 int32(v.Coeff.dig_H2()) + 8192) >> 14)
562
563 lg.Debugf("v_x1=%v", v_x1)
564
565 v_x1 = v_x1 - (((((v_x1 >> 15) * (v_x1 >> 15)) >> 7) * int32(v.Coeff.dig_H1())) >> 4)
566 lg.Debugf("v_x1=%v", v_x1)
567
568 if v_x1 < 0 {
569 v_x1 = 0
570 } else if v_x1 > 419430400 {
571 v_x1 = 419430400
572 }
573 lg.Debugf("v_x1=%v", v_x1)
574 v_x1 = v_x1 >> 12
575 lg.Debugf("v_x1=%v", v_x1)
576 return true, uint32(v_x1), nil
577 }