Debian Codegraph @

bmp280.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 // BMP280 sensors memory map
34 const (
35 // BMP280 general registers
36 BMP280_ID_REG = 0xD0
37 BMP280_STATUS_REG = 0xF3
38 BMP280_CNTR_MEAS_REG = 0xF4
39 BMP280_CONFIG = 0xF5 // TODO: support IIR filter settings
40 BMP280_RESET = 0xE0
41 // BMP280 specific compensation register's block
42 BMP280_COEF_START = 0x88
43 BMP280_COEF_BYTES = 12 * 2
44 // BMP280 specific 3-byte reading out temprature and preassure
45 BMP280_PRESS_OUT_MSB_LSB_XLSB = 0xF7
46 BMP280_TEMP_OUT_MSB_LSB_XLSB = 0xFA
47 )
48
49 // Unique BMP280 calibration coefficients
50 type CoeffBMP280 struct {
51 // Registers storing unique calibration coefficients
52 COEF_88 uint8
53 COEF_89 uint8
54 COEF_8A uint8
55 COEF_8B uint8
56 COEF_8C uint8
57 COEF_8D uint8
58 COEF_8E uint8
59 COEF_8F uint8
60 COEF_90 uint8
61 COEF_91 uint8
62 COEF_92 uint8
63 COEF_93 uint8
64 COEF_94 uint8
65 COEF_95 uint8
66 COEF_96 uint8
67 COEF_97 uint8
68 COEF_98 uint8
69 COEF_99 uint8
70 COEF_9A uint8
71 COEF_9B uint8
72 COEF_9C uint8
73 COEF_9D uint8
74 COEF_9E uint8
75 COEF_9F uint8
76 }
77
78 func (v *CoeffBMP280) dig_T1() uint16 {
79 return uint16(v.COEF_89)<<8 | uint16(v.COEF_88)
80 }
81
82 func (v *CoeffBMP280) dig_T2() int16 {
83 return int16(uint16(v.COEF_8B)<<8 | uint16(v.COEF_8A))
84 }
85
86 func (v *CoeffBMP280) dig_T3() int16 {
87 return int16(uint16(v.COEF_8D)<<8 | uint16(v.COEF_8C))
88 }
89
90 func (v *CoeffBMP280) dig_P1() uint16 {
91 return uint16(v.COEF_8F)<<8 | uint16(v.COEF_8E)
92 }
93
94 func (v *CoeffBMP280) dig_P2() int16 {
95 return int16(uint16(v.COEF_91)<<8 | uint16(v.COEF_90))
96 }
97
98 func (v *CoeffBMP280) dig_P3() int16 {
99 return int16(uint16(v.COEF_93)<<8 | uint16(v.COEF_92))
100 }
101
102 func (v *CoeffBMP280) dig_P4() int16 {
103 return int16(uint16(v.COEF_95)<<8 | uint16(v.COEF_94))
104 }
105
106 func (v *CoeffBMP280) dig_P5() int16 {
107 return int16(uint16(v.COEF_97)<<8 | uint16(v.COEF_96))
108 }
109
110 func (v *CoeffBMP280) dig_P6() int16 {
111 return int16(uint16(v.COEF_99)<<8 | uint16(v.COEF_98))
112 }
113
114 func (v *CoeffBMP280) dig_P7() int16 {
115 return int16(uint16(v.COEF_9B)<<8 | uint16(v.COEF_9A))
116 }
117
118 func (v *CoeffBMP280) dig_P8() int16 {
119 return int16(uint16(v.COEF_9D)<<8 | uint16(v.COEF_9C))
120 }
121
122 func (v *CoeffBMP280) dig_P9() int16 {
123 return int16(uint16(v.COEF_9F)<<8 | uint16(v.COEF_9E))
124 }
125
126 // SensorBMP280 specific type
127 type SensorBMP280 struct {
128 Coeff *CoeffBMP280
129 }
130
131 // Static cast to verify at compile time
132 // that type implement interface.
133 var _ SensorInterface = &SensorBMP280{}
134
135 // ReadSensorID reads sensor signature. It may be used for validation,
136 // that proper code settings used for sensor data decoding.
137 func (v *SensorBMP280) ReadSensorID(i2c *i2c.I2C) (uint8, error) {
138 id, err := i2c.ReadRegU8(BMP280_ID_REG)
139 if err != nil {
140 return 0, err
141 }
142 return id, nil
143 }
144
145 // ReadCoefficients reads compensation coefficients, unique for each sensor.
146 func (v *SensorBMP280) ReadCoefficients(i2c *i2c.I2C) error {
147 _, err := i2c.WriteBytes([]byte{BMP280_COEF_START})
148 if err != nil {
149 return err
150 }
151 var coef1 [BMP280_COEF_BYTES]byte
152 err = readDataToStruct(i2c, BMP280_COEF_BYTES,
153 binary.LittleEndian, &coef1)
154 if err != nil {
155 return err
156 }
157 buf := bytes.NewBuffer(coef1[:])
158 coeff := &CoeffBMP280{}
159 err = binary.Read(buf, binary.LittleEndian, coeff)
160 if err != nil {
161 return err
162 }
163 v.Coeff = coeff
164 return nil
165 }
166
167 // IsValidCoefficients verify that compensate registers
168 // are not empty, and thus are valid.
169 func (v *SensorBMP280) IsValidCoefficients() error {
170 if v.Coeff != nil {
171 err := checkCoefficient(v.Coeff.dig_T1(), "dig_T1")
172 if err != nil {
173 return err
174 }
175 err = checkCoefficient(uint16(v.Coeff.dig_T2()), "dig_T2")
176 if err != nil {
177 return err
178 }
179 err = checkCoefficient(uint16(v.Coeff.dig_T3()), "dig_T3")
180 if err != nil {
181 return err
182 }
183 err = checkCoefficient(v.Coeff.dig_P1(), "dig_P1")
184 if err != nil {
185 return err
186 }
187 err = checkCoefficient(uint16(v.Coeff.dig_P2()), "dig_P2")
188 if err != nil {
189 return err
190 }
191 err = checkCoefficient(uint16(v.Coeff.dig_P3()), "dig_P3")
192 if err != nil {
193 return err
194 }
195 err = checkCoefficient(uint16(v.Coeff.dig_P4()), "dig_P4")
196 if err != nil {
197 return err
198 }
199 err = checkCoefficient(uint16(v.Coeff.dig_P5()), "dig_P5")
200 if err != nil {
201 return err
202 }
203 err = checkCoefficient(uint16(v.Coeff.dig_P6()), "dig_P6")
204 if err != nil {
205 return err
206 }
207 err = checkCoefficient(uint16(v.Coeff.dig_P7()), "dig_P7")
208 if err != nil {
209 return err
210 }
211 err = checkCoefficient(uint16(v.Coeff.dig_P8()), "dig_P8")
212 if err != nil {
213 return err
214 }
215 err = checkCoefficient(uint16(v.Coeff.dig_P9()), "dig_P9")
216 if err != nil {
217 return err
218 }
219 } else {
220 err := errors.New("CoeffBMP280 struct does not build")
221 return err
222 }
223 return nil
224 }
225
226 // RecognizeSignature returns description of signature if it valid,
227 // otherwise - error.
228 func (v *SensorBMP280) RecognizeSignature(signature uint8) (string, error) {
229 switch signature {
230 case 0x58:
231 return "BMP280", nil
232 case 0x56, 0x57:
233 return "BMP280 (sample)", nil
234 default:
235 return "", errors.New(fmt.Sprintf("signature 0x%x doesn't belong to BMP280 series", signature))
236 }
237 }
238
239 // IsBusy reads register 0xF3 for "busy" flag,
240 // according to sensor specification.
241 func (v *SensorBMP280) IsBusy(i2c *i2c.I2C) (busy bool, err error) {
242 // Check flag to know status of calculation, according
243 // to specification about SCO (Start of conversion) flag
244 b, err := i2c.ReadRegU8(BMP280_STATUS_REG)
245 if err != nil {
246 return false, err
247 }
248 b = b & 0x8
249 lg.Debugf("Busy flag=0x%0X", b)
250 return b != 0, nil
251 }
252
253 func (v *SensorBMP280) getOversamplingRation(accuracy AccuracyMode) byte {
254 var b byte
255 switch accuracy {
256 case ACCURACY_ULTRA_LOW:
257 b = 1
258 case ACCURACY_LOW:
259 b = 2
260 case ACCURACY_STANDARD:
261 b = 3
262 case ACCURACY_HIGH:
263 b = 4
264 case ACCURACY_ULTRA_HIGH:
265 b = 5
266 default:
267 // assign accuracy to lowest resolution by default
268 b = 1
269 }
270 return b
271 }
272
273 // readUncompTemprature reads uncompensated temprature from sensor.
274 func (v *SensorBMP280) readUncompTemprature(i2c *i2c.I2C, accuracy AccuracyMode) (int32, error) {
275 var power byte = 1 // Forced mode
276 osrt := v.getOversamplingRation(accuracy)
277 err := i2c.WriteRegU8(BMP280_CNTR_MEAS_REG, power|(osrt<<5))
278 if err != nil {
279 return 0, err
280 }
281 _, err = waitForCompletion(v, i2c)
282 if err != nil {
283 return 0, err
284 }
285 buf, _, err := i2c.ReadRegBytes(BMP280_TEMP_OUT_MSB_LSB_XLSB, 3)
286 if err != nil {
287 return 0, err
288 }
289 ut := int32(buf[0])<<12 + int32(buf[1])<<4 + int32(buf[2]&0xF0)>>4
290 return ut, nil
291 }
292
293 // readUncompPressure reads atmospheric uncompensated pressure from sensor.
294 func (v *SensorBMP280) readUncompPressure(i2c *i2c.I2C, accuracy AccuracyMode) (int32, error) {
295 var power byte = 1 // Forced mode
296 osrp := v.getOversamplingRation(accuracy)
297 err := i2c.WriteRegU8(BMP280_CNTR_MEAS_REG, power|(osrp<<2))
298 if err != nil {
299 return 0, err
300 }
301 _, err = waitForCompletion(v, i2c)
302 if err != nil {
303 return 0, err
304 }
305 buf, _, err := i2c.ReadRegBytes(BMP280_PRESS_OUT_MSB_LSB_XLSB, 3)
306 if err != nil {
307 return 0, err
308 }
309 up := int32(buf[0])<<12 + int32(buf[1])<<4 + int32(buf[2]&0xF0)>>4
310 return up, nil
311 }
312
313 // readUncompTempratureAndPressure reads temprature and
314 // atmospheric uncompensated pressure from sensor.
315 // BMP280 allows to read temprature and pressure in one cycle,
316 // BMP180 - doesn't.
317 func (v *SensorBMP280) readUncompTempratureAndPressure(i2c *i2c.I2C,
318 accuracy AccuracyMode) (temprature int32, pressure int32, err error) {
319 var power byte = 1 // Forced mode
320 osrt := v.getOversamplingRation(ACCURACY_STANDARD)
321 osrp := v.getOversamplingRation(accuracy)
322 err = i2c.WriteRegU8(BMP280_CNTR_MEAS_REG, power|(osrt<<5)|(osrp<<2))
323 if err != nil {
324 return 0, 0, err
325 }
326 _, err = waitForCompletion(v, i2c)
327 if err != nil {
328 return 0, 0, err
329 }
330 buf, _, err := i2c.ReadRegBytes(BMP280_TEMP_OUT_MSB_LSB_XLSB, 3)
331 if err != nil {
332 return 0, 0, err
333 }
334 ut := int32(buf[0])<<12 + int32(buf[1])<<4 + int32(buf[2]&0xF0)>>4
335 buf, _, err = i2c.ReadRegBytes(BMP280_PRESS_OUT_MSB_LSB_XLSB, 3)
336 if err != nil {
337 return 0, 0, err
338 }
339 up := int32(buf[0])<<12 + int32(buf[1])<<4 + int32(buf[2]&0xF0)>>4
340 return ut, up, nil
341 }
342
343 // ReadTemperatureMult100C reads and calculates temrature in C (celsius) multiplied by 100.
344 // Multiplication approach allow to keep result as integer number.
345 func (v *SensorBMP280) ReadTemperatureMult100C(i2c *i2c.I2C, accuracy AccuracyMode) (int32, error) {
346 ut, err := v.readUncompTemprature(i2c, accuracy)
347 if err != nil {
348 return 0, err
349 }
350 err = v.ReadCoefficients(i2c)
351 if err != nil {
352 return 0, err
353 }
354
355 var1 := ((ut>>3 - int32(v.Coeff.dig_T1())<<1) * int32(v.Coeff.dig_T2())) >> 11
356 lg.Debugf("var1=%v", var1)
357 var2 := (((ut>>4 - int32(v.Coeff.dig_T1())) * (ut>>4 - int32(v.Coeff.dig_T1()))) >> 12 *
358 int32(v.Coeff.dig_T3())) >> 14
359 lg.Debugf("var1=%v", var2)
360 tFine := var1 + var2
361 lg.Debugf("t_fine=%v", tFine)
362 t := (tFine*5 + 128) >> 8
363 return t, nil
364 }
365
366 // ReadPressureMult10Pa reads and calculates atmospheric pressure in Pa (Pascal) multiplied by 10.
367 // Multiplication approach allow to keep result as integer number.
368 func (v *SensorBMP280) ReadPressureMult10Pa(i2c *i2c.I2C, accuracy AccuracyMode) (uint32, error) {
369 ut, up, err := v.readUncompTempratureAndPressure(i2c, accuracy)
370 if err != nil {
371 return 0, err
372 }
373 lg.Debugf("ut=%v, up=%v", ut, up)
374
375 err = v.ReadCoefficients(i2c)
376 if err != nil {
377 return 0, err
378 }
379
380 var01 := ((ut>>3 - int32(v.Coeff.dig_T1())<<1) * int32(v.Coeff.dig_T2())) >> 11
381 lg.Debugf("var01=%v", var01)
382 var02 := (((ut>>4 - int32(v.Coeff.dig_T1())) * (ut>>4 - int32(v.Coeff.dig_T1()))) >> 12 *
383 int32(v.Coeff.dig_T3())) >> 14
384 lg.Debugf("var01=%v", var02)
385 tFine := var01 + var02
386
387 var1 := int64(tFine) - 128000
388 lg.Debugf("var1=%v", var1)
389 var2 := var1 * var1 * int64(v.Coeff.dig_P6())
390 lg.Debugf("var2=%v", var2)
391 var2 += (var1 * int64(v.Coeff.dig_P5())) << 17
392 var2 += int64(v.Coeff.dig_P4()) << 35
393 lg.Debugf("var2=%v", var2)
394 var1 = (var1*var1*int64(v.Coeff.dig_P3()))>>8 + (var1*int64(v.Coeff.dig_P2()))<<12
395 var1 = ((int64(1)<<47 + var1) * int64(v.Coeff.dig_P1())) >> 33
396 lg.Debugf("var1=%v", var1)
397 if var1 == 0 {
398 return 0, nil
399 }
400 p1 := int64(1048576) - int64(up)
401 p1 = ((p1<<31 - var2) * 3125) / var1
402 var1 = (int64(v.Coeff.dig_P9()) * (p1 >> 13) * (p1 >> 13)) >> 25
403 var2 = (int64(v.Coeff.dig_P8()) * p1) >> 19
404 p1 = (p1+var1+var2)>>8 + int64(v.Coeff.dig_P7())<<4
405 p2 := p1 * 10 / 256
406 p := uint32(p2)
407
408 return p, nil
409 }
410
411 // ReadHumidityMultQ2210 does nothing. Humidity function is not applicable for BMP280.
412 func (v *SensorBMP280) ReadHumidityMultQ2210(i2c *i2c.I2C, accuracy AccuracyMode) (bool, uint32, error) {
413 // Not supported
414 return false, 0, nil
415 }