bmp180.go

//--------------------------------------------------------------------------------------------------
//
// Copyright (c) 2018 Denis Dyakov
//
// Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
// associated documentation files (the "Software"), to deal in the Software without restriction,
// including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense,
// and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so,
// subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in all copies or substantial
// portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING
// BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//
//--------------------------------------------------------------------------------------------------

package bsbmp

import (
	"bytes"
	"encoding/binary"
	"errors"
	"fmt"

	i2c "github.com/d2r2/go-i2c"
)

// BMP180 sensors memory map
const (
	// BMP180 general registers
	BMP180_ID_REG        = 0xD0
	BMP180_CNTR_MEAS_REG = 0xF4
	BMP180_RESET         = 0xE0
	// BMP180 specific compensation register's block
	BMP180_COEF_START = 0xAA
	BMP180_COEF_BYTES = 22
	// BMP180 specific 3-byte reading out temprature and preassure
	BMP180_OUT_MSB_LSB_XLSB = 0xF6
)

// Unique BMP180 calibration coefficients
type CoeffBMP180 struct {
	// Registers storing unique calibration coefficients
	COEF_AA uint8
	COEF_AB uint8
	COEF_AC uint8
	COEF_AD uint8
	COEF_AE uint8
	COEF_AF uint8
	COEF_B0 uint8
	COEF_B1 uint8
	COEF_B2 uint8
	COEF_B3 uint8
	COEF_B4 uint8
	COEF_B5 uint8
	COEF_B6 uint8
	COEF_B7 uint8
	COEF_B8 uint8
	COEF_B9 uint8
	COEF_BA uint8
	COEF_BB uint8
	COEF_BC uint8
	COEF_BD uint8
	COEF_BE uint8
	COEF_BF uint8
}

func (v *CoeffBMP180) dig_AC1() int16 {
	return int16(uint16(v.COEF_AA)<<8 | uint16(v.COEF_AB))
}

func (v *CoeffBMP180) dig_AC2() int16 {
	return int16(uint16(v.COEF_AC)<<8 | uint16(v.COEF_AD))
}

func (v *CoeffBMP180) dig_AC3() int16 {
	return int16(uint16(v.COEF_AE)<<8 | uint16(v.COEF_AF))
}

func (v *CoeffBMP180) dig_AC4() uint16 {
	return uint16(v.COEF_B0)<<8 | uint16(v.COEF_B1)
}

func (v *CoeffBMP180) dig_AC5() uint16 {
	return uint16(v.COEF_B2)<<8 | uint16(v.COEF_B3)
}

func (v *CoeffBMP180) dig_AC6() uint16 {
	return uint16(v.COEF_B4)<<8 | uint16(v.COEF_B5)
}

func (v *CoeffBMP180) dig_B1() int16 {
	return int16(uint16(v.COEF_B6)<<8 | uint16(v.COEF_B7))
}

func (v *CoeffBMP180) dig_B2() int16 {
	return int16(uint16(v.COEF_B8)<<8 | uint16(v.COEF_B9))
}

func (v *CoeffBMP180) dig_MB() int16 {
	return int16(uint16(v.COEF_BA)<<8 | uint16(v.COEF_BB))
}

func (v *CoeffBMP180) dig_MC() int16 {
	return int16(uint16(v.COEF_BC)<<8 | uint16(v.COEF_BD))
}

func (v *CoeffBMP180) dig_MD() int16 {
	return int16(uint16(v.COEF_BE)<<8 | uint16(v.COEF_BF))
}

// SensorBMP180 specific type
type SensorBMP180 struct {
	Coeff *CoeffBMP180
}

// Static cast to verify at compile time
// that type implement interface.
var _ SensorInterface = &SensorBMP180{}

// ReadSensorID reads sensor signature. It may be used for validation,
// that proper code settings used for sensor data decoding.
func (v *SensorBMP180) ReadSensorID(i2c *i2c.I2C) (uint8, error) {
	id, err := i2c.ReadRegU8(BMP180_ID_REG)
	if err != nil {
		return 0, err
	}
	return id, nil
}

// ReadCoefficients reads compensation coefficients, unique for each sensor.
func (v *SensorBMP180) ReadCoefficients(i2c *i2c.I2C) error {
	_, err := i2c.WriteBytes([]byte{BMP180_COEF_START})
	if err != nil {
		return err
	}
	var coef1 [BMP180_COEF_BYTES]byte
	err = readDataToStruct(i2c, BMP180_COEF_BYTES,
		binary.LittleEndian, &coef1)
	if err != nil {
		return err
	}
	buf := bytes.NewBuffer(coef1[:])
	coeff := &CoeffBMP180{}
	err = binary.Read(buf, binary.LittleEndian, coeff)
	if err != nil {
		return err
	}
	v.Coeff = coeff
	return nil
}

// IsValidCoefficients verify that compensate registers
// are not empty, and thus are valid.
func (v *SensorBMP180) IsValidCoefficients() error {
	if v.Coeff != nil {
		err := checkCoefficient(uint16(v.Coeff.dig_AC1()), "AC1")
		if err != nil {
			return err
		}
		err = checkCoefficient(uint16(v.Coeff.dig_AC2()), "AC2")
		if err != nil {
			return err
		}
		err = checkCoefficient(uint16(v.Coeff.dig_AC3()), "AC3")
		if err != nil {
			return err
		}
		err = checkCoefficient(v.Coeff.dig_AC4(), "AC4")
		if err != nil {
			return err
		}
		err = checkCoefficient(v.Coeff.dig_AC5(), "AC5")
		if err != nil {
			return err
		}
		err = checkCoefficient(v.Coeff.dig_AC6(), "AC6")
		if err != nil {
			return err
		}
		err = checkCoefficient(uint16(v.Coeff.dig_B1()), "B1")
		if err != nil {
			return err
		}
		err = checkCoefficient(uint16(v.Coeff.dig_B2()), "B2")
		if err != nil {
			return err
		}
		err = checkCoefficient(uint16(v.Coeff.dig_MB()), "MB")
		if err != nil {
			return err
		}
		err = checkCoefficient(uint16(v.Coeff.dig_MC()), "MC")
		if err != nil {
			return err
		}
		err = checkCoefficient(uint16(v.Coeff.dig_MD()), "MD")
		if err != nil {
			return err
		}
	} else {
		err := errors.New("CoeffBMP180 struct does not built")
		return err
	}
	return nil
}

// RecognizeSignature returns description of signature if it valid,
// otherwise - error.
func (v *SensorBMP180) RecognizeSignature(signature uint8) (string, error) {
	switch signature {
	case 0x55:
		return "BMP180", nil
	default:
		return "", errors.New(fmt.Sprintf("signature 0x%x doesn't belong to BMP180 series", signature))
	}
}

// IsBusy reads register 0xF4 for "busy" flag,
// according to sensor specification.
func (v *SensorBMP180) IsBusy(i2c *i2c.I2C) (busy bool, err error) {
	// Check flag to know status of calculation, according
	// to specification about SCO (Start of conversion) flag
	b, err := i2c.ReadRegU8(BMP180_CNTR_MEAS_REG)
	if err != nil {
		return false, err
	}
	b = b & 0x20
	lg.Debugf("Busy flag=0x%0X", b)
	return b != 0, nil
}

// readUncompTemp reads uncompensated temprature from sensor.
func (v *SensorBMP180) readUncompTemp(i2c *i2c.I2C) (int32, error) {
	err := i2c.WriteRegU8(BMP180_CNTR_MEAS_REG, 0x2F)
	if err != nil {
		return 0, err
	}
	_, err = waitForCompletion(v, i2c)
	if err != nil {
		return 0, err
	}
	w, err := i2c.ReadRegU16BE(BMP180_OUT_MSB_LSB_XLSB)
	if err != nil {
		return 0, err
	}
	return int32(w), nil
}

func (v *SensorBMP180) getOversamplingRation(accuracy AccuracyMode) byte {
	var b byte
	switch accuracy {
	case ACCURACY_LOW, ACCURACY_ULTRA_LOW:
		b = 0
	case ACCURACY_STANDARD:
		b = 1
	case ACCURACY_HIGH:
		b = 2
	case ACCURACY_ULTRA_HIGH:
		b = 3
	default:
		// assign accuracy to lowest resolution by default
		b = 0
	}
	return b
}

// readUncompPressure reads atmospheric uncompensated pressure from sensor.
func (v *SensorBMP180) readUncompPressure(i2c *i2c.I2C, accuracy AccuracyMode) (int32, error) {
	oss := v.getOversamplingRation(accuracy)
	lg.Debugf("oss=%v", oss)
	err := i2c.WriteRegU8(BMP180_CNTR_MEAS_REG, 0x34+(oss<<6))
	if err != nil {
		return 0, err
	}
	_, err = waitForCompletion(v, i2c)
	if err != nil {
		return 0, err
	}
	buf, _, err := i2c.ReadRegBytes(BMP180_OUT_MSB_LSB_XLSB, 3)
	if err != nil {
		return 0, err
	}
	up := (int32(buf[0])<<16 + int32(buf[1])<<8 + int32(buf[2])) >> (8 - oss)
	return up, nil
}

// ReadTemperatureMult100C reads and calculates temprature in C (celsius) multiplied by 100.
// Multiplication approach allow to keep result as integer number.
func (v *SensorBMP180) ReadTemperatureMult100C(i2c *i2c.I2C, mode AccuracyMode) (int32, error) {
	ut, err := v.readUncompTemp(i2c)
	if err != nil {
		return 0, err
	}
	err = v.ReadCoefficients(i2c)
	if err != nil {
		return 0, err
	}
	// Calculate temperature according to sensor specification
	x1 := ((ut - int32(v.Coeff.dig_AC6())) * int32(v.Coeff.dig_AC5())) >> 15
	lg.Debugf("x1=%v", x1)
	x2 := (int32(v.Coeff.dig_MC()) << 11) / (x1 + int32(v.Coeff.dig_MD()))
	lg.Debugf("x2=%v", x2)
	b5 := x1 + x2
	lg.Debugf("b5=%v", b5)
	t := ((b5 + 8) >> 4) * 10
	lg.Debugf("t=%v", t)
	return t, nil
}

// ReadPressureMult10Pa reads and calculates atmospheric pressure in Pa (Pascal) multiplied by 10.
// Multiplication approach allow to keep result as integer number.
func (v *SensorBMP180) ReadPressureMult10Pa(i2c *i2c.I2C, accuracy AccuracyMode) (uint32, error) {
	oss := v.getOversamplingRation(accuracy)
	ut, err := v.readUncompTemp(i2c)
	if err != nil {
		return 0, err
	}
	lg.Debugf("ut=%v", ut)

	up, err := v.readUncompPressure(i2c, accuracy)
	if err != nil {
		return 0, err
	}
	lg.Debugf("up=%v", up)

	err = v.ReadCoefficients(i2c)
	if err != nil {
		return 0, err
	}

	// Calculate pressure according to sensor specification
	x1 := ((ut - int32(v.Coeff.dig_AC6())) * int32(v.Coeff.dig_AC5())) >> 15
	lg.Debugf("x1=%v", x1)
	x2 := (int32(v.Coeff.dig_MC()) << 11) / (x1 + int32(v.Coeff.dig_MD()))
	lg.Debugf("x2=%v", x2)
	b5 := x1 + x2
	lg.Debugf("b5=%v", b5)
	b6 := b5 - 4000
	lg.Debugf("b6=%v", b6)
	x1 = (int32(v.Coeff.dig_B2()) * ((b6 * b6) >> 12)) >> 11
	lg.Debugf("x1=%v", x1)
	x2 = (int32(v.Coeff.dig_AC2()) * b6) >> 11
	lg.Debugf("x2=%v", x2)
	x3 := x1 + x2
	lg.Debugf("x3=%v", x3)
	b3 := (((int32(v.Coeff.dig_AC1())*4 + x3) << uint32(oss)) + 2) / 4
	lg.Debugf("b3=%v", b3)
	x1 = (int32(v.Coeff.dig_AC3()) * b6) >> 13
	lg.Debugf("x1=%v", x1)
	x2 = ((int32(v.Coeff.dig_B1()) * (b6 * b6)) >> 12) >> 16
	lg.Debugf("x2=%v", x2)
	x3 = ((x1 + x2) + 2) >> 2
	lg.Debugf("x3=%v", x3)
	b4 := (uint32(v.Coeff.dig_AC4()) * uint32(x3+32768)) >> 15
	lg.Debugf("b4=%v", b4)
	b7 := (uint32(up) - uint32(b3)) * (50000 >> uint32(oss))
	lg.Debugf("b7=%v", b7)
	var p1 int32
	if b7 < 0x80000000 {
		p1 = int32((b7 * 2) / b4)
	} else {
		p1 = int32((b7 / b4) * 2)
	}
	lg.Debugf("p=%v", p1)
	x1 = (p1 >> 8) * (p1 >> 8)
	lg.Debugf("x1=%v", x1)
	x1 = (x1 * 3038) >> 16
	lg.Debugf("x1=%v", x1)
	x2 = (-7357 * p1) >> 16
	lg.Debugf("x2=%v", x2)
	p1 += (x1 + x2 + 3791) >> 4
	lg.Debugf("p=%v", p1)
	p := uint32(p1) * 10
	return p, nil
}

// ReadHumidityMultQ2210 does nothing. Humidity function is not applicable for BMP180.
func (v *SensorBMP180) ReadHumidityMultQ2210(i2c *i2c.I2C, accuracy AccuracyMode) (bool, uint32, error) {
	// Not supported
	return false, 0, nil
}