mirror of
https://github.com/kidoman/embd
synced 2025-07-03 11:57:38 +02:00
- use glog instead of Debug flag
- use glog instead of log - make code conform to the Go code guidelines
This commit is contained in:
parent
ca17879e6e
commit
9ab49745bc
23 changed files with 554 additions and 703 deletions
|
@ -2,7 +2,6 @@
|
|||
package bh1750fvi
|
||||
|
||||
import (
|
||||
"log"
|
||||
"sync"
|
||||
"time"
|
||||
|
||||
|
@ -61,35 +60,32 @@ func NewHigh2Mode(bus embd.I2CBus) *BH1750FVI {
|
|||
return New(High2, bus)
|
||||
}
|
||||
|
||||
func (d *BH1750FVI) measureLighting() (lighting float64, err error) {
|
||||
err = d.Bus.WriteByte(d.i2cAddr, d.operationCode)
|
||||
if err != nil {
|
||||
log.Print("bh1750fvi: Failed to initialize sensor")
|
||||
return
|
||||
func (d *BH1750FVI) measureLighting() (float64, error) {
|
||||
if err := d.Bus.WriteByte(d.i2cAddr, d.operationCode); err != nil {
|
||||
return 0, err
|
||||
}
|
||||
time.Sleep(180 * time.Millisecond)
|
||||
|
||||
var reading uint16
|
||||
if reading, err = d.Bus.ReadWordFromReg(d.i2cAddr, defReadReg); err != nil {
|
||||
return
|
||||
reading, err := d.Bus.ReadWordFromReg(d.i2cAddr, defReadReg)
|
||||
if err != nil {
|
||||
return 0, err
|
||||
}
|
||||
|
||||
lighting = float64(int16(reading)) / measurementAcuuracy
|
||||
return
|
||||
return float64(int16(reading)) / measurementAcuuracy, nil
|
||||
}
|
||||
|
||||
// Lighting returns the ambient lighting in lx.
|
||||
func (d *BH1750FVI) Lighting() (lighting float64, err error) {
|
||||
func (d *BH1750FVI) Lighting() (float64, error) {
|
||||
select {
|
||||
case lighting = <-d.lightingReadings:
|
||||
return
|
||||
case lighting := <-d.lightingReadings:
|
||||
return lighting, nil
|
||||
default:
|
||||
return d.measureLighting()
|
||||
}
|
||||
}
|
||||
|
||||
// Run starts continuous sensor data acquisition loop.
|
||||
func (d *BH1750FVI) Run() (err error) {
|
||||
func (d *BH1750FVI) Run() {
|
||||
go func() {
|
||||
d.quit = make(chan bool)
|
||||
|
||||
|
@ -101,7 +97,8 @@ func (d *BH1750FVI) Run() (err error) {
|
|||
select {
|
||||
case d.lightingReadings <- lighting:
|
||||
case <-timer:
|
||||
if l, err := d.measureLighting(); err == nil {
|
||||
l, err := d.measureLighting()
|
||||
if err == nil {
|
||||
lighting = l
|
||||
}
|
||||
if err == nil && d.lightingReadings == nil {
|
||||
|
|
|
@ -3,11 +3,11 @@
|
|||
package bmp085
|
||||
|
||||
import (
|
||||
"log"
|
||||
"math"
|
||||
"sync"
|
||||
"time"
|
||||
|
||||
"github.com/golang/glog"
|
||||
"github.com/kidoman/embd"
|
||||
)
|
||||
|
||||
|
@ -43,8 +43,6 @@ type BMP085 struct {
|
|||
Bus embd.I2CBus
|
||||
Poll int
|
||||
|
||||
Debug bool
|
||||
|
||||
oss uint
|
||||
|
||||
ac1, ac2, ac3 int16
|
||||
|
@ -65,109 +63,109 @@ func New(bus embd.I2CBus) *BMP085 {
|
|||
return &BMP085{Bus: bus, Poll: pollDelay}
|
||||
}
|
||||
|
||||
func (d *BMP085) calibrate() (err error) {
|
||||
func (d *BMP085) calibrate() error {
|
||||
d.cmu.RLock()
|
||||
if d.calibrated {
|
||||
d.cmu.RUnlock()
|
||||
return
|
||||
return nil
|
||||
}
|
||||
d.cmu.RUnlock()
|
||||
|
||||
d.cmu.Lock()
|
||||
defer d.cmu.Unlock()
|
||||
|
||||
readInt16 := func(reg byte) (value int16, err error) {
|
||||
var v uint16
|
||||
if v, err = d.Bus.ReadWordFromReg(address, reg); err != nil {
|
||||
return
|
||||
readInt16 := func(reg byte) (int16, error) {
|
||||
v, err := d.Bus.ReadWordFromReg(address, reg)
|
||||
if err != nil {
|
||||
return 0, err
|
||||
}
|
||||
value = int16(v)
|
||||
return
|
||||
return int16(v), nil
|
||||
}
|
||||
|
||||
readUInt16 := func(reg byte) (value uint16, err error) {
|
||||
var v uint16
|
||||
if v, err = d.Bus.ReadWordFromReg(address, reg); err != nil {
|
||||
return
|
||||
readUInt16 := func(reg byte) (uint16, error) {
|
||||
v, err := d.Bus.ReadWordFromReg(address, reg)
|
||||
if err != nil {
|
||||
return 0, err
|
||||
}
|
||||
value = uint16(v)
|
||||
return
|
||||
return uint16(v), nil
|
||||
}
|
||||
|
||||
var err error
|
||||
d.ac1, err = readInt16(calAc1)
|
||||
if err != nil {
|
||||
return
|
||||
return err
|
||||
}
|
||||
d.ac2, err = readInt16(calAc2)
|
||||
if err != nil {
|
||||
return
|
||||
return err
|
||||
}
|
||||
d.ac3, err = readInt16(calAc3)
|
||||
if err != nil {
|
||||
return
|
||||
return err
|
||||
}
|
||||
d.ac4, err = readUInt16(calAc4)
|
||||
if err != nil {
|
||||
return
|
||||
return err
|
||||
}
|
||||
d.ac5, err = readUInt16(calAc5)
|
||||
if err != nil {
|
||||
return
|
||||
return err
|
||||
}
|
||||
d.ac6, err = readUInt16(calAc6)
|
||||
if err != nil {
|
||||
return
|
||||
return err
|
||||
}
|
||||
d.b1, err = readInt16(calB1)
|
||||
if err != nil {
|
||||
return
|
||||
return err
|
||||
}
|
||||
d.b2, err = readInt16(calB2)
|
||||
if err != nil {
|
||||
return
|
||||
return err
|
||||
}
|
||||
d.mb, err = readInt16(calMB)
|
||||
if err != nil {
|
||||
return
|
||||
return err
|
||||
}
|
||||
d.mc, err = readInt16(calMC)
|
||||
if err != nil {
|
||||
return
|
||||
return err
|
||||
}
|
||||
d.md, err = readInt16(calMD)
|
||||
if err != nil {
|
||||
return
|
||||
return err
|
||||
}
|
||||
|
||||
d.calibrated = true
|
||||
|
||||
if d.Debug {
|
||||
log.Print("bmp085: calibration data retrieved")
|
||||
log.Printf("bmp085: param AC1 = %v", d.ac1)
|
||||
log.Printf("bmp085: param AC2 = %v", d.ac2)
|
||||
log.Printf("bmp085: param AC3 = %v", d.ac3)
|
||||
log.Printf("bmp085: param AC4 = %v", d.ac4)
|
||||
log.Printf("bmp085: param AC5 = %v", d.ac5)
|
||||
log.Printf("bmp085: param AC6 = %v", d.ac6)
|
||||
log.Printf("bmp085: param B1 = %v", d.b1)
|
||||
log.Printf("bmp085: param B2 = %v", d.b2)
|
||||
log.Printf("bmp085: param MB = %v", d.mb)
|
||||
log.Printf("bmp085: param MC = %v", d.mc)
|
||||
log.Printf("bmp085: param MD = %v", d.md)
|
||||
if glog.V(1) {
|
||||
glog.Info("bmp085: calibration data retrieved")
|
||||
glog.Infof("bmp085: param AC1 = %v", d.ac1)
|
||||
glog.Infof("bmp085: param AC2 = %v", d.ac2)
|
||||
glog.Infof("bmp085: param AC3 = %v", d.ac3)
|
||||
glog.Infof("bmp085: param AC4 = %v", d.ac4)
|
||||
glog.Infof("bmp085: param AC5 = %v", d.ac5)
|
||||
glog.Infof("bmp085: param AC6 = %v", d.ac6)
|
||||
glog.Infof("bmp085: param B1 = %v", d.b1)
|
||||
glog.Infof("bmp085: param B2 = %v", d.b2)
|
||||
glog.Infof("bmp085: param MB = %v", d.mb)
|
||||
glog.Infof("bmp085: param MC = %v", d.mc)
|
||||
glog.Infof("bmp085: param MD = %v", d.md)
|
||||
}
|
||||
|
||||
return
|
||||
return nil
|
||||
}
|
||||
|
||||
func (d *BMP085) readUncompensatedTemp() (temp uint16, err error) {
|
||||
if err = d.Bus.WriteByteToReg(address, control, readTempCmd); err != nil {
|
||||
return
|
||||
func (d *BMP085) readUncompensatedTemp() (uint16, error) {
|
||||
if err := d.Bus.WriteByteToReg(address, control, readTempCmd); err != nil {
|
||||
return 0, err
|
||||
}
|
||||
time.Sleep(tempReadDelay)
|
||||
if temp, err = d.Bus.ReadWordFromReg(address, tempData); err != nil {
|
||||
return
|
||||
temp, err := d.Bus.ReadWordFromReg(address, tempData)
|
||||
if err != nil {
|
||||
return 0, err
|
||||
}
|
||||
return
|
||||
return temp, nil
|
||||
}
|
||||
|
||||
func (d *BMP085) calcTemp(utemp uint16) uint16 {
|
||||
|
@ -181,69 +179,59 @@ func (d *BMP085) calcTemp(utemp uint16) uint16 {
|
|||
return uint16((d.b5 + 8) >> 4)
|
||||
}
|
||||
|
||||
func (d *BMP085) measureTemp() (temp uint16, err error) {
|
||||
if err = d.calibrate(); err != nil {
|
||||
return
|
||||
func (d *BMP085) measureTemp() (uint16, error) {
|
||||
if err := d.calibrate(); err != nil {
|
||||
return 0, err
|
||||
}
|
||||
|
||||
var utemp uint16
|
||||
if utemp, err = d.readUncompensatedTemp(); err != nil {
|
||||
return
|
||||
utemp, err := d.readUncompensatedTemp()
|
||||
if err != nil {
|
||||
return 0, err
|
||||
}
|
||||
if d.Debug {
|
||||
log.Printf("bcm085: uncompensated temp: %v", utemp)
|
||||
}
|
||||
temp = d.calcTemp(utemp)
|
||||
if d.Debug {
|
||||
log.Printf("bcm085: compensated temp %v", temp)
|
||||
}
|
||||
return
|
||||
glog.V(1).Infof("bcm085: uncompensated temp: %v", utemp)
|
||||
temp := d.calcTemp(utemp)
|
||||
glog.V(1).Infof("bcm085: compensated temp %v", temp)
|
||||
return temp, nil
|
||||
}
|
||||
|
||||
// Temperature returns the current temperature reading.
|
||||
func (d *BMP085) Temperature() (temp float64, err error) {
|
||||
|
||||
func (d *BMP085) Temperature() (float64, error) {
|
||||
select {
|
||||
case t := <-d.temps:
|
||||
temp = float64(t) / 10
|
||||
return
|
||||
temp := float64(t) / 10
|
||||
return temp, nil
|
||||
default:
|
||||
if d.Debug {
|
||||
log.Print("bcm085: no temps available... measuring")
|
||||
}
|
||||
var t uint16
|
||||
t, err = d.measureTemp()
|
||||
glog.V(1).Infof("bcm085: no temps available... measuring")
|
||||
t, err := d.measureTemp()
|
||||
if err != nil {
|
||||
return
|
||||
return 0, err
|
||||
}
|
||||
temp = float64(t) / 10
|
||||
return
|
||||
temp := float64(t) / 10
|
||||
return temp, nil
|
||||
}
|
||||
}
|
||||
|
||||
func (d *BMP085) readUncompensatedPressure() (pressure uint32, err error) {
|
||||
if err = d.Bus.WriteByteToReg(address, control, byte(readPressureCmd+(d.oss<<6))); err != nil {
|
||||
return
|
||||
func (d *BMP085) readUncompensatedPressure() (uint32, error) {
|
||||
if err := d.Bus.WriteByteToReg(address, control, byte(readPressureCmd+(d.oss<<6))); err != nil {
|
||||
return 0, err
|
||||
}
|
||||
time.Sleep(time.Duration(2+(3<<d.oss)) * time.Millisecond)
|
||||
|
||||
data := make([]byte, 3)
|
||||
if err = d.Bus.ReadFromReg(address, pressureData, data); err != nil {
|
||||
return
|
||||
if err := d.Bus.ReadFromReg(address, pressureData, data); err != nil {
|
||||
return 0, err
|
||||
}
|
||||
|
||||
pressure = ((uint32(data[0]) << 16) | (uint32(data[1]) << 8) | uint32(data[2])) >> (8 - d.oss)
|
||||
pressure := ((uint32(data[0]) << 16) | (uint32(data[1]) << 8) | uint32(data[2])) >> (8 - d.oss)
|
||||
|
||||
return
|
||||
return pressure, nil
|
||||
}
|
||||
|
||||
func (d *BMP085) calcPressure(upressure uint32) (p int32) {
|
||||
func (d *BMP085) calcPressure(upressure uint32) int32 {
|
||||
var x1, x2, x3 int32
|
||||
|
||||
l := func(s string, v interface{}) {
|
||||
if d.Debug {
|
||||
log.Printf("bcm085: %v = %v", s, v)
|
||||
}
|
||||
glog.V(1).Infof("bcm085: %v = %v", s, v)
|
||||
}
|
||||
|
||||
b6 := d.b5 - 4000
|
||||
|
@ -271,6 +259,7 @@ func (d *BMP085) calcPressure(upressure uint32) (p int32) {
|
|||
l("x3", x3)
|
||||
l("b4", b4)
|
||||
|
||||
var p int32
|
||||
b7 := (uint32(upressure-uint32(b3)) * (50000 >> d.oss))
|
||||
if b7 < 0x80000000 {
|
||||
p = int32((b7 << 1) / b4)
|
||||
|
@ -290,83 +279,70 @@ func (d *BMP085) calcPressure(upressure uint32) (p int32) {
|
|||
l("x3", x3)
|
||||
l("p", p)
|
||||
|
||||
return
|
||||
return p
|
||||
}
|
||||
|
||||
func (d *BMP085) calcAltitude(pressure int32) float64 {
|
||||
return 44330 * (1 - math.Pow(float64(pressure)/p0, 0.190295))
|
||||
}
|
||||
|
||||
func (d *BMP085) measurePressureAndAltitude() (pressure int32, altitude float64, err error) {
|
||||
if err = d.calibrate(); err != nil {
|
||||
return
|
||||
func (d *BMP085) measurePressureAndAltitude() (int32, float64, error) {
|
||||
if err := d.calibrate(); err != nil {
|
||||
return 0, 0, err
|
||||
}
|
||||
|
||||
var upressure uint32
|
||||
if upressure, err = d.readUncompensatedPressure(); err != nil {
|
||||
return
|
||||
upressure, err := d.readUncompensatedPressure()
|
||||
if err != nil {
|
||||
return 0, 0, err
|
||||
}
|
||||
if d.Debug {
|
||||
log.Printf("bcm085: uncompensated pressure: %v", upressure)
|
||||
}
|
||||
pressure = d.calcPressure(upressure)
|
||||
if d.Debug {
|
||||
log.Printf("bcm085: compensated pressure %v", pressure)
|
||||
}
|
||||
altitude = d.calcAltitude(pressure)
|
||||
if d.Debug {
|
||||
log.Printf("bcm085: calculated altitude %v", altitude)
|
||||
}
|
||||
return
|
||||
glog.V(1).Infof("bcm085: uncompensated pressure: %v", upressure)
|
||||
pressure := d.calcPressure(upressure)
|
||||
glog.V(1).Infof("bcm085: compensated pressure %v", pressure)
|
||||
altitude := d.calcAltitude(pressure)
|
||||
glog.V(1).Infof("bcm085: calculated altitude %v", altitude)
|
||||
return pressure, altitude, nil
|
||||
}
|
||||
|
||||
// Pressure returns the current pressure reading.
|
||||
func (d *BMP085) Pressure() (pressure int, err error) {
|
||||
if err = d.calibrate(); err != nil {
|
||||
return
|
||||
func (d *BMP085) Pressure() (int, error) {
|
||||
if err := d.calibrate(); err != nil {
|
||||
return 0, err
|
||||
}
|
||||
|
||||
select {
|
||||
case p := <-d.pressures:
|
||||
pressure = int(p)
|
||||
return
|
||||
return int(p), nil
|
||||
default:
|
||||
if d.Debug {
|
||||
log.Print("bcm085: no pressures available... measuring")
|
||||
}
|
||||
var p int32
|
||||
p, _, err = d.measurePressureAndAltitude()
|
||||
glog.V(1).Infof("bcm085: no pressures available... measuring")
|
||||
p, _, err := d.measurePressureAndAltitude()
|
||||
if err != nil {
|
||||
return
|
||||
return 0, err
|
||||
}
|
||||
pressure = int(p)
|
||||
return
|
||||
return int(p), nil
|
||||
}
|
||||
}
|
||||
|
||||
// Altitude returns the current altitude reading.
|
||||
func (d *BMP085) Altitude() (altitude float64, err error) {
|
||||
if err = d.calibrate(); err != nil {
|
||||
return
|
||||
func (d *BMP085) Altitude() (float64, error) {
|
||||
if err := d.calibrate(); err != nil {
|
||||
return 0, err
|
||||
}
|
||||
|
||||
select {
|
||||
case altitude = <-d.altitudes:
|
||||
return
|
||||
case altitude := <-d.altitudes:
|
||||
return altitude, nil
|
||||
default:
|
||||
if d.Debug {
|
||||
log.Print("bcm085: no altitudes available... measuring")
|
||||
}
|
||||
_, altitude, err = d.measurePressureAndAltitude()
|
||||
glog.V(1).Info("bcm085: no altitudes available... measuring")
|
||||
_, altitude, err := d.measurePressureAndAltitude()
|
||||
if err != nil {
|
||||
return
|
||||
return 0, err
|
||||
}
|
||||
return
|
||||
return altitude, nil
|
||||
}
|
||||
}
|
||||
|
||||
// Run starts the sensor data acquisition loop.
|
||||
func (d *BMP085) Run() (err error) {
|
||||
func (d *BMP085) Run() {
|
||||
go func() {
|
||||
d.quit = make(chan struct{})
|
||||
timer := time.Tick(time.Duration(d.Poll) * time.Millisecond)
|
||||
|
|
|
@ -3,11 +3,11 @@
|
|||
package bmp180
|
||||
|
||||
import (
|
||||
"log"
|
||||
"math"
|
||||
"sync"
|
||||
"time"
|
||||
|
||||
"github.com/golang/glog"
|
||||
"github.com/kidoman/embd"
|
||||
)
|
||||
|
||||
|
@ -43,8 +43,6 @@ type BMP180 struct {
|
|||
Bus embd.I2CBus
|
||||
Poll int
|
||||
|
||||
Debug bool
|
||||
|
||||
oss uint
|
||||
|
||||
ac1, ac2, ac3 int16
|
||||
|
@ -65,109 +63,109 @@ func New(bus embd.I2CBus) *BMP180 {
|
|||
return &BMP180{Bus: bus, Poll: pollDelay}
|
||||
}
|
||||
|
||||
func (d *BMP180) calibrate() (err error) {
|
||||
func (d *BMP180) calibrate() error {
|
||||
d.cmu.RLock()
|
||||
if d.calibrated {
|
||||
d.cmu.RUnlock()
|
||||
return
|
||||
return nil
|
||||
}
|
||||
d.cmu.RUnlock()
|
||||
|
||||
d.cmu.Lock()
|
||||
defer d.cmu.Unlock()
|
||||
|
||||
readInt16 := func(reg byte) (value int16, err error) {
|
||||
var v uint16
|
||||
if v, err = d.Bus.ReadWordFromReg(address, reg); err != nil {
|
||||
return
|
||||
readInt16 := func(reg byte) (int16, error) {
|
||||
v, err := d.Bus.ReadWordFromReg(address, reg)
|
||||
if err != nil {
|
||||
return 0, err
|
||||
}
|
||||
value = int16(v)
|
||||
return
|
||||
return int16(v), nil
|
||||
}
|
||||
|
||||
readUInt16 := func(reg byte) (value uint16, err error) {
|
||||
var v uint16
|
||||
if v, err = d.Bus.ReadWordFromReg(address, reg); err != nil {
|
||||
return
|
||||
readUInt16 := func(reg byte) (uint16, error) {
|
||||
v, err := d.Bus.ReadWordFromReg(address, reg)
|
||||
if err != nil {
|
||||
return 0, err
|
||||
}
|
||||
value = uint16(v)
|
||||
return
|
||||
return uint16(v), nil
|
||||
}
|
||||
|
||||
var err error
|
||||
d.ac1, err = readInt16(calAc1)
|
||||
if err != nil {
|
||||
return
|
||||
return err
|
||||
}
|
||||
d.ac2, err = readInt16(calAc2)
|
||||
if err != nil {
|
||||
return
|
||||
return err
|
||||
}
|
||||
d.ac3, err = readInt16(calAc3)
|
||||
if err != nil {
|
||||
return
|
||||
return err
|
||||
}
|
||||
d.ac4, err = readUInt16(calAc4)
|
||||
if err != nil {
|
||||
return
|
||||
return err
|
||||
}
|
||||
d.ac5, err = readUInt16(calAc5)
|
||||
if err != nil {
|
||||
return
|
||||
return err
|
||||
}
|
||||
d.ac6, err = readUInt16(calAc6)
|
||||
if err != nil {
|
||||
return
|
||||
return err
|
||||
}
|
||||
d.b1, err = readInt16(calB1)
|
||||
if err != nil {
|
||||
return
|
||||
return err
|
||||
}
|
||||
d.b2, err = readInt16(calB2)
|
||||
if err != nil {
|
||||
return
|
||||
return err
|
||||
}
|
||||
d.mb, err = readInt16(calMB)
|
||||
if err != nil {
|
||||
return
|
||||
return err
|
||||
}
|
||||
d.mc, err = readInt16(calMC)
|
||||
if err != nil {
|
||||
return
|
||||
return err
|
||||
}
|
||||
d.md, err = readInt16(calMD)
|
||||
if err != nil {
|
||||
return
|
||||
return err
|
||||
}
|
||||
|
||||
d.calibrated = true
|
||||
|
||||
if d.Debug {
|
||||
log.Print("bmp085: calibration data retrieved")
|
||||
log.Printf("bmp085: param AC1 = %v", d.ac1)
|
||||
log.Printf("bmp085: param AC2 = %v", d.ac2)
|
||||
log.Printf("bmp085: param AC3 = %v", d.ac3)
|
||||
log.Printf("bmp085: param AC4 = %v", d.ac4)
|
||||
log.Printf("bmp085: param AC5 = %v", d.ac5)
|
||||
log.Printf("bmp085: param AC6 = %v", d.ac6)
|
||||
log.Printf("bmp085: param B1 = %v", d.b1)
|
||||
log.Printf("bmp085: param B2 = %v", d.b2)
|
||||
log.Printf("bmp085: param MB = %v", d.mb)
|
||||
log.Printf("bmp085: param MC = %v", d.mc)
|
||||
log.Printf("bmp085: param MD = %v", d.md)
|
||||
if glog.V(1) {
|
||||
glog.Info("bmp180: calibration data retrieved")
|
||||
glog.Infof("bmp180: param AC1 = %v", d.ac1)
|
||||
glog.Infof("bmp180: param AC2 = %v", d.ac2)
|
||||
glog.Infof("bmp180: param AC3 = %v", d.ac3)
|
||||
glog.Infof("bmp180: param AC4 = %v", d.ac4)
|
||||
glog.Infof("bmp180: param AC5 = %v", d.ac5)
|
||||
glog.Infof("bmp180: param AC6 = %v", d.ac6)
|
||||
glog.Infof("bmp180: param B1 = %v", d.b1)
|
||||
glog.Infof("bmp180: param B2 = %v", d.b2)
|
||||
glog.Infof("bmp180: param MB = %v", d.mb)
|
||||
glog.Infof("bmp180: param MC = %v", d.mc)
|
||||
glog.Infof("bmp180: param MD = %v", d.md)
|
||||
}
|
||||
|
||||
return
|
||||
return nil
|
||||
}
|
||||
|
||||
func (d *BMP180) readUncompensatedTemp() (temp uint16, err error) {
|
||||
if err = d.Bus.WriteByteToReg(address, control, readTempCmd); err != nil {
|
||||
return
|
||||
func (d *BMP180) readUncompensatedTemp() (uint16, error) {
|
||||
if err := d.Bus.WriteByteToReg(address, control, readTempCmd); err != nil {
|
||||
return 0, err
|
||||
}
|
||||
time.Sleep(tempReadDelay)
|
||||
if temp, err = d.Bus.ReadWordFromReg(address, tempData); err != nil {
|
||||
return
|
||||
temp, err := d.Bus.ReadWordFromReg(address, tempData)
|
||||
if err != nil {
|
||||
return 0, err
|
||||
}
|
||||
return
|
||||
return temp, nil
|
||||
}
|
||||
|
||||
func (d *BMP180) calcTemp(utemp uint16) uint16 {
|
||||
|
@ -181,69 +179,59 @@ func (d *BMP180) calcTemp(utemp uint16) uint16 {
|
|||
return uint16((d.b5 + 8) >> 4)
|
||||
}
|
||||
|
||||
func (d *BMP180) measureTemp() (temp uint16, err error) {
|
||||
if err = d.calibrate(); err != nil {
|
||||
return
|
||||
func (d *BMP180) measureTemp() (uint16, error) {
|
||||
if err := d.calibrate(); err != nil {
|
||||
return 0, err
|
||||
}
|
||||
|
||||
var utemp uint16
|
||||
if utemp, err = d.readUncompensatedTemp(); err != nil {
|
||||
return
|
||||
utemp, err := d.readUncompensatedTemp()
|
||||
if err != nil {
|
||||
return 0, err
|
||||
}
|
||||
if d.Debug {
|
||||
log.Printf("bcm085: uncompensated temp: %v", utemp)
|
||||
}
|
||||
temp = d.calcTemp(utemp)
|
||||
if d.Debug {
|
||||
log.Printf("bcm085: compensated temp %v", temp)
|
||||
}
|
||||
return
|
||||
glog.V(1).Infof("bcm085: uncompensated temp: %v", utemp)
|
||||
temp := d.calcTemp(utemp)
|
||||
glog.V(1).Infof("bcm085: compensated temp %v", temp)
|
||||
return temp, nil
|
||||
}
|
||||
|
||||
// Temperature returns the current temperature reading.
|
||||
func (d *BMP180) Temperature() (temp float64, err error) {
|
||||
|
||||
func (d *BMP180) Temperature() (float64, error) {
|
||||
select {
|
||||
case t := <-d.temps:
|
||||
temp = float64(t) / 10
|
||||
return
|
||||
temp := float64(t) / 10
|
||||
return temp, nil
|
||||
default:
|
||||
if d.Debug {
|
||||
log.Print("bcm085: no temps available... measuring")
|
||||
}
|
||||
var t uint16
|
||||
t, err = d.measureTemp()
|
||||
glog.V(1).Infof("bcm085: no temps available... measuring")
|
||||
t, err := d.measureTemp()
|
||||
if err != nil {
|
||||
return
|
||||
return 0, err
|
||||
}
|
||||
temp = float64(t) / 10
|
||||
return
|
||||
temp := float64(t) / 10
|
||||
return temp, nil
|
||||
}
|
||||
}
|
||||
|
||||
func (d *BMP180) readUncompensatedPressure() (pressure uint32, err error) {
|
||||
if err = d.Bus.WriteByteToReg(address, control, byte(readPressureCmd+(d.oss<<6))); err != nil {
|
||||
return
|
||||
func (d *BMP180) readUncompensatedPressure() (uint32, error) {
|
||||
if err := d.Bus.WriteByteToReg(address, control, byte(readPressureCmd+(d.oss<<6))); err != nil {
|
||||
return 0, err
|
||||
}
|
||||
time.Sleep(time.Duration(2+(3<<d.oss)) * time.Millisecond)
|
||||
|
||||
data := make([]byte, 3)
|
||||
if err = d.Bus.ReadFromReg(address, pressureData, data); err != nil {
|
||||
return
|
||||
if err := d.Bus.ReadFromReg(address, pressureData, data); err != nil {
|
||||
return 0, err
|
||||
}
|
||||
|
||||
pressure = ((uint32(data[0]) << 16) | (uint32(data[1]) << 8) | uint32(data[2])) >> (8 - d.oss)
|
||||
pressure := ((uint32(data[0]) << 16) | (uint32(data[1]) << 8) | uint32(data[2])) >> (8 - d.oss)
|
||||
|
||||
return
|
||||
return pressure, nil
|
||||
}
|
||||
|
||||
func (d *BMP180) calcPressure(upressure uint32) (p int32) {
|
||||
func (d *BMP180) calcPressure(upressure uint32) int32 {
|
||||
var x1, x2, x3 int32
|
||||
|
||||
l := func(s string, v interface{}) {
|
||||
if d.Debug {
|
||||
log.Printf("bcm085: %v = %v", s, v)
|
||||
}
|
||||
glog.V(1).Infof("bcm085: %v = %v", s, v)
|
||||
}
|
||||
|
||||
b6 := d.b5 - 4000
|
||||
|
@ -271,6 +259,7 @@ func (d *BMP180) calcPressure(upressure uint32) (p int32) {
|
|||
l("x3", x3)
|
||||
l("b4", b4)
|
||||
|
||||
var p int32
|
||||
b7 := (uint32(upressure-uint32(b3)) * (50000 >> d.oss))
|
||||
if b7 < 0x80000000 {
|
||||
p = int32((b7 << 1) / b4)
|
||||
|
@ -290,83 +279,70 @@ func (d *BMP180) calcPressure(upressure uint32) (p int32) {
|
|||
l("x3", x3)
|
||||
l("p", p)
|
||||
|
||||
return
|
||||
return p
|
||||
}
|
||||
|
||||
func (d *BMP180) calcAltitude(pressure int32) float64 {
|
||||
return 44330 * (1 - math.Pow(float64(pressure)/p0, 0.190295))
|
||||
}
|
||||
|
||||
func (d *BMP180) measurePressureAndAltitude() (pressure int32, altitude float64, err error) {
|
||||
if err = d.calibrate(); err != nil {
|
||||
return
|
||||
func (d *BMP180) measurePressureAndAltitude() (int32, float64, error) {
|
||||
if err := d.calibrate(); err != nil {
|
||||
return 0, 0, err
|
||||
}
|
||||
|
||||
var upressure uint32
|
||||
if upressure, err = d.readUncompensatedPressure(); err != nil {
|
||||
return
|
||||
upressure, err := d.readUncompensatedPressure()
|
||||
if err != nil {
|
||||
return 0, 0, err
|
||||
}
|
||||
if d.Debug {
|
||||
log.Printf("bcm085: uncompensated pressure: %v", upressure)
|
||||
}
|
||||
pressure = d.calcPressure(upressure)
|
||||
if d.Debug {
|
||||
log.Printf("bcm085: compensated pressure %v", pressure)
|
||||
}
|
||||
altitude = d.calcAltitude(pressure)
|
||||
if d.Debug {
|
||||
log.Printf("bcm085: calculated altitude %v", altitude)
|
||||
}
|
||||
return
|
||||
glog.V(1).Infof("bcm085: uncompensated pressure: %v", upressure)
|
||||
pressure := d.calcPressure(upressure)
|
||||
glog.V(1).Infof("bcm085: compensated pressure %v", pressure)
|
||||
altitude := d.calcAltitude(pressure)
|
||||
glog.V(1).Infof("bcm085: calculated altitude %v", altitude)
|
||||
return pressure, altitude, nil
|
||||
}
|
||||
|
||||
// Pressure returns the current pressure reading.
|
||||
func (d *BMP180) Pressure() (pressure int, err error) {
|
||||
if err = d.calibrate(); err != nil {
|
||||
return
|
||||
func (d *BMP180) Pressure() (int, error) {
|
||||
if err := d.calibrate(); err != nil {
|
||||
return 0, err
|
||||
}
|
||||
|
||||
select {
|
||||
case p := <-d.pressures:
|
||||
pressure = int(p)
|
||||
return
|
||||
return int(p), nil
|
||||
default:
|
||||
if d.Debug {
|
||||
log.Print("bcm085: no pressures available... measuring")
|
||||
}
|
||||
var p int32
|
||||
p, _, err = d.measurePressureAndAltitude()
|
||||
glog.V(1).Infof("bcm085: no pressures available... measuring")
|
||||
p, _, err := d.measurePressureAndAltitude()
|
||||
if err != nil {
|
||||
return
|
||||
return 0, err
|
||||
}
|
||||
pressure = int(p)
|
||||
return
|
||||
return int(p), nil
|
||||
}
|
||||
}
|
||||
|
||||
// Altitude returns the current altitude reading.
|
||||
func (d *BMP180) Altitude() (altitude float64, err error) {
|
||||
if err = d.calibrate(); err != nil {
|
||||
return
|
||||
func (d *BMP180) Altitude() (float64, error) {
|
||||
if err := d.calibrate(); err != nil {
|
||||
return 0, err
|
||||
}
|
||||
|
||||
select {
|
||||
case altitude = <-d.altitudes:
|
||||
return
|
||||
case altitude := <-d.altitudes:
|
||||
return altitude, nil
|
||||
default:
|
||||
if d.Debug {
|
||||
log.Print("bcm085: no altitudes available... measuring")
|
||||
}
|
||||
_, altitude, err = d.measurePressureAndAltitude()
|
||||
glog.V(1).Info("bcm085: no altitudes available... measuring")
|
||||
_, altitude, err := d.measurePressureAndAltitude()
|
||||
if err != nil {
|
||||
return
|
||||
return 0, err
|
||||
}
|
||||
return
|
||||
return altitude, nil
|
||||
}
|
||||
}
|
||||
|
||||
// Run starts the sensor data acquisition loop.
|
||||
func (d *BMP180) Run() (err error) {
|
||||
func (d *BMP180) Run() {
|
||||
go func() {
|
||||
d.quit = make(chan struct{})
|
||||
timer := time.Tick(time.Duration(d.Poll) * time.Millisecond)
|
||||
|
|
|
@ -3,11 +3,11 @@ package l3gd20
|
|||
|
||||
import (
|
||||
"fmt"
|
||||
"log"
|
||||
"math"
|
||||
"sync"
|
||||
"time"
|
||||
|
||||
"github.com/golang/glog"
|
||||
"github.com/kidoman/embd"
|
||||
)
|
||||
|
||||
|
@ -122,8 +122,6 @@ type L3GD20 struct {
|
|||
|
||||
orientations chan Orientation
|
||||
closing chan chan struct{}
|
||||
|
||||
Debug bool
|
||||
}
|
||||
|
||||
// New creates a new L3GD20 interface. The bus variable controls
|
||||
|
@ -132,7 +130,6 @@ func New(bus embd.I2CBus, Range *Range) *L3GD20 {
|
|||
return &L3GD20{
|
||||
Bus: bus,
|
||||
Range: Range,
|
||||
Debug: false,
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -162,42 +159,38 @@ func (vs values) mean() float64 {
|
|||
return sum / float64(len(vs))
|
||||
}
|
||||
|
||||
func (d *L3GD20) calibrate(a *axis) (ac axisCalibration, err error) {
|
||||
if d.Debug {
|
||||
log.Printf("l3gd20: calibrating %v axis", a)
|
||||
}
|
||||
func (d *L3GD20) calibrate(a *axis) (axisCalibration, error) {
|
||||
glog.V(1).Infof("l3gd20: calibrating %v axis", a)
|
||||
|
||||
values := make(values, 0)
|
||||
for i := 0; i < 20; i++ {
|
||||
again:
|
||||
var available bool
|
||||
if available, err = d.axisStatus(a); err != nil {
|
||||
return
|
||||
available, err := d.axisStatus(a)
|
||||
if err != nil {
|
||||
return axisCalibration{}, err
|
||||
}
|
||||
if !available {
|
||||
time.Sleep(100 * time.Microsecond)
|
||||
goto again
|
||||
}
|
||||
var value float64
|
||||
if value, err = d.readOrientationDelta(a); err != nil {
|
||||
return
|
||||
value, err := d.readOrientationDelta(a)
|
||||
if err != nil {
|
||||
return axisCalibration{}, err
|
||||
}
|
||||
values = append(values, value)
|
||||
}
|
||||
ac.min, ac.max, ac.mean = values.min(), values.max(), values.mean()
|
||||
ac := axisCalibration{min: values.min(), max: values.max(), mean: values.mean()}
|
||||
|
||||
if d.Debug {
|
||||
log.Printf("l3gd20: %v axis calibration (%v)", a, ac)
|
||||
}
|
||||
glog.V(1).Infof("l3gd20: %v axis calibration (%v)", a, ac)
|
||||
|
||||
return
|
||||
return ac, nil
|
||||
}
|
||||
|
||||
func (d *L3GD20) setup() (err error) {
|
||||
func (d *L3GD20) setup() error {
|
||||
d.mu.RLock()
|
||||
if d.initialized {
|
||||
d.mu.RUnlock()
|
||||
return
|
||||
return nil
|
||||
}
|
||||
d.mu.RUnlock()
|
||||
|
||||
|
@ -206,63 +199,66 @@ func (d *L3GD20) setup() (err error) {
|
|||
|
||||
d.orientations = make(chan Orientation)
|
||||
|
||||
if err = d.Bus.WriteByteToReg(address, ctrlReg1, ctrlReg1Default); err != nil {
|
||||
return
|
||||
if err := d.Bus.WriteByteToReg(address, ctrlReg1, ctrlReg1Default); err != nil {
|
||||
return err
|
||||
}
|
||||
if err = d.Bus.WriteByteToReg(address, ctrlReg4, d.Range.value); err != nil {
|
||||
return
|
||||
if err := d.Bus.WriteByteToReg(address, ctrlReg4, d.Range.value); err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
// Calibrate
|
||||
var err error
|
||||
if d.xac, err = d.calibrate(ax); err != nil {
|
||||
return
|
||||
return err
|
||||
}
|
||||
if d.yac, err = d.calibrate(ay); err != nil {
|
||||
return
|
||||
return err
|
||||
}
|
||||
if d.zac, err = d.calibrate(az); err != nil {
|
||||
return
|
||||
return err
|
||||
}
|
||||
|
||||
d.initialized = true
|
||||
|
||||
return
|
||||
return nil
|
||||
}
|
||||
|
||||
func (d *L3GD20) axisStatus(a *axis) (available bool, err error) {
|
||||
var data byte
|
||||
if data, err = d.Bus.ReadByteFromReg(address, statusReg); err != nil {
|
||||
return
|
||||
func (d *L3GD20) axisStatus(a *axis) (bool, error) {
|
||||
data, err := d.Bus.ReadByteFromReg(address, statusReg)
|
||||
if err != nil {
|
||||
return false, err
|
||||
}
|
||||
|
||||
if data&zyxAvailable == 0 {
|
||||
return
|
||||
return false, nil
|
||||
}
|
||||
|
||||
available = data&a.availableMask != 0
|
||||
available := data&a.availableMask != 0
|
||||
|
||||
return
|
||||
return available, nil
|
||||
}
|
||||
|
||||
func (d *L3GD20) readOrientationDelta(a *axis) (value float64, err error) {
|
||||
func (d *L3GD20) readOrientationDelta(a *axis) (float64, error) {
|
||||
rl, rh := a.regs()
|
||||
var l, h byte
|
||||
if l, err = d.Bus.ReadByteFromReg(address, rl); err != nil {
|
||||
return
|
||||
l, err := d.Bus.ReadByteFromReg(address, rl)
|
||||
if err != nil {
|
||||
return 0, err
|
||||
}
|
||||
if h, err = d.Bus.ReadByteFromReg(address, rh); err != nil {
|
||||
return
|
||||
h, err := d.Bus.ReadByteFromReg(address, rh)
|
||||
if err != nil {
|
||||
return 0, err
|
||||
}
|
||||
|
||||
value = float64(int16(h)<<8 | int16(l))
|
||||
value := float64(int16(h)<<8 | int16(l))
|
||||
value *= d.Range.sensitivity
|
||||
|
||||
return
|
||||
return value, nil
|
||||
}
|
||||
|
||||
func (d *L3GD20) calibratedOrientationDelta(a *axis) (value float64, err error) {
|
||||
if value, err = d.readOrientationDelta(a); err != nil {
|
||||
return
|
||||
func (d *L3GD20) calibratedOrientationDelta(a *axis) (float64, error) {
|
||||
value, err := d.readOrientationDelta(a)
|
||||
if err != nil {
|
||||
return 0, err
|
||||
}
|
||||
|
||||
switch a {
|
||||
|
@ -274,63 +270,64 @@ func (d *L3GD20) calibratedOrientationDelta(a *axis) (value float64, err error)
|
|||
value = d.zac.adjust(value)
|
||||
}
|
||||
|
||||
return
|
||||
return value, nil
|
||||
}
|
||||
|
||||
func (d *L3GD20) measureOrientationDelta() (dx, dy, dz float64, err error) {
|
||||
if err = d.setup(); err != nil {
|
||||
return
|
||||
func (d *L3GD20) measureOrientationDelta() (float64, float64, float64, error) {
|
||||
if err := d.setup(); err != nil {
|
||||
return 0, 0, 0, err
|
||||
}
|
||||
|
||||
if dx, err = d.calibratedOrientationDelta(ax); err != nil {
|
||||
return
|
||||
dx, err := d.calibratedOrientationDelta(ax)
|
||||
if err != nil {
|
||||
return 0, 0, 0, err
|
||||
}
|
||||
if dy, err = d.calibratedOrientationDelta(ay); err != nil {
|
||||
return
|
||||
dy, err := d.calibratedOrientationDelta(ay)
|
||||
if err != nil {
|
||||
return 0, 0, 0, err
|
||||
}
|
||||
if dz, err = d.calibratedOrientationDelta(az); err != nil {
|
||||
return
|
||||
dz, err := d.calibratedOrientationDelta(az)
|
||||
if err != nil {
|
||||
return 0, 0, 0, err
|
||||
}
|
||||
|
||||
return
|
||||
return dx, dy, dz, nil
|
||||
}
|
||||
|
||||
// Orientation returns the current orientation reading.
|
||||
func (d *L3GD20) OrientationDelta() (dx, dy, dz float64, err error) {
|
||||
func (d *L3GD20) OrientationDelta() (float64, float64, float64, error) {
|
||||
return d.measureOrientationDelta()
|
||||
}
|
||||
|
||||
// Temperature returns the current temperature reading.
|
||||
func (d *L3GD20) Temperature() (temp int, err error) {
|
||||
if err = d.setup(); err != nil {
|
||||
return
|
||||
func (d *L3GD20) Temperature() (int, error) {
|
||||
if err := d.setup(); err != nil {
|
||||
return 0, err
|
||||
}
|
||||
|
||||
var data byte
|
||||
if data, err = d.Bus.ReadByteFromReg(address, tempData); err != nil {
|
||||
return
|
||||
data, err := d.Bus.ReadByteFromReg(address, tempData)
|
||||
if err != nil {
|
||||
return 0, err
|
||||
}
|
||||
|
||||
temp = int(int8(data))
|
||||
temp := int(int8(data))
|
||||
|
||||
return
|
||||
return temp, nil
|
||||
}
|
||||
|
||||
// Orientations returns a channel which will have the current temperature reading.
|
||||
func (d *L3GD20) Orientations() (orientations <-chan Orientation, err error) {
|
||||
if err = d.setup(); err != nil {
|
||||
return
|
||||
func (d *L3GD20) Orientations() (<-chan Orientation, error) {
|
||||
if err := d.setup(); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
orientations = d.orientations
|
||||
|
||||
return
|
||||
return d.orientations, nil
|
||||
}
|
||||
|
||||
// Start starts the data acquisition loop.
|
||||
func (d *L3GD20) Start() (err error) {
|
||||
if err = d.setup(); err != nil {
|
||||
return
|
||||
func (d *L3GD20) Start() error {
|
||||
if err := d.setup(); err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
d.closing = make(chan chan struct{})
|
||||
|
@ -346,7 +343,7 @@ func (d *L3GD20) Start() (err error) {
|
|||
case <-timer:
|
||||
dx, dy, dz, err := d.measureOrientationDelta()
|
||||
if err != nil {
|
||||
log.Printf("l3gd20: %v", err)
|
||||
glog.Errorf("l3gd20: %v", err)
|
||||
} else {
|
||||
x += dx * mult
|
||||
y += dy * mult
|
||||
|
@ -364,25 +361,25 @@ func (d *L3GD20) Start() (err error) {
|
|||
}
|
||||
}()
|
||||
|
||||
return
|
||||
return nil
|
||||
}
|
||||
|
||||
// Stop the data acquisition loop.
|
||||
func (d *L3GD20) Stop() (err error) {
|
||||
func (d *L3GD20) Stop() error {
|
||||
if d.closing != nil {
|
||||
waitc := make(chan struct{})
|
||||
d.closing <- waitc
|
||||
<-waitc
|
||||
d.closing = nil
|
||||
}
|
||||
if err = d.Bus.WriteByteToReg(address, ctrlReg1, ctrlReg1Finished); err != nil {
|
||||
return
|
||||
if err := d.Bus.WriteByteToReg(address, ctrlReg1, ctrlReg1Finished); err != nil {
|
||||
return err
|
||||
}
|
||||
d.initialized = false
|
||||
return
|
||||
return nil
|
||||
}
|
||||
|
||||
// Close.
|
||||
func (d *L3GD20) Close() (err error) {
|
||||
func (d *L3GD20) Close() error {
|
||||
return d.Stop()
|
||||
}
|
||||
|
|
|
@ -2,11 +2,11 @@
|
|||
package lsm303
|
||||
|
||||
import (
|
||||
"log"
|
||||
"math"
|
||||
"sync"
|
||||
"time"
|
||||
|
||||
"github.com/golang/glog"
|
||||
"github.com/kidoman/embd"
|
||||
)
|
||||
|
||||
|
@ -53,8 +53,6 @@ type LSM303 struct {
|
|||
headings chan float64
|
||||
|
||||
quit chan struct{}
|
||||
|
||||
Debug bool
|
||||
}
|
||||
|
||||
// New creates a new LSM303 interface. The bus variable controls
|
||||
|
@ -118,15 +116,13 @@ func (d *LSM303) Heading() (float64, error) {
|
|||
case heading := <-d.headings:
|
||||
return heading, nil
|
||||
default:
|
||||
if d.Debug {
|
||||
log.Print("lsm303: no headings available... measuring")
|
||||
}
|
||||
glog.V(2).Infof("lsm303: no headings available... measuring")
|
||||
return d.measureHeading()
|
||||
}
|
||||
}
|
||||
|
||||
// Run starts the sensor data acquisition loop.
|
||||
func (d *LSM303) Run() (err error) {
|
||||
func (d *LSM303) Run() error {
|
||||
go func() {
|
||||
d.quit = make(chan struct{})
|
||||
|
||||
|
@ -153,7 +149,7 @@ func (d *LSM303) Run() (err error) {
|
|||
}
|
||||
}()
|
||||
|
||||
return
|
||||
return nil
|
||||
}
|
||||
|
||||
// Close the sensor data acquisition loop and put the LSM303 into sleep mode.
|
||||
|
|
|
@ -4,11 +4,11 @@ package tmp006
|
|||
import (
|
||||
"errors"
|
||||
"fmt"
|
||||
"log"
|
||||
"math"
|
||||
"sync"
|
||||
"time"
|
||||
|
||||
"github.com/golang/glog"
|
||||
"github.com/kidoman/embd"
|
||||
)
|
||||
|
||||
|
@ -57,8 +57,6 @@ type TMP006 struct {
|
|||
Bus embd.I2CBus
|
||||
// Addr of the sensor.
|
||||
Addr byte
|
||||
// Debug turns on additional debug output.
|
||||
Debug bool
|
||||
// SampleRate specifies the sampling rate for the sensor.
|
||||
SampleRate *SampleRate
|
||||
|
||||
|
@ -89,143 +87,122 @@ func (d *TMP006) validate() error {
|
|||
}
|
||||
|
||||
// Close puts the device into low power mode.
|
||||
func (d *TMP006) Close() (err error) {
|
||||
if err = d.setup(); err != nil {
|
||||
return
|
||||
func (d *TMP006) Close() error {
|
||||
if err := d.setup(); err != nil {
|
||||
return err
|
||||
}
|
||||
if d.closing != nil {
|
||||
waitc := make(chan struct{})
|
||||
d.closing <- waitc
|
||||
<-waitc
|
||||
}
|
||||
if d.Debug {
|
||||
log.Print("tmp006: resetting")
|
||||
glog.V(1).Infof("tmp006: resetting")
|
||||
if err := d.Bus.WriteWordToReg(d.Addr, configReg, reset); err != nil {
|
||||
return err
|
||||
}
|
||||
if err = d.Bus.WriteWordToReg(d.Addr, configReg, reset); err != nil {
|
||||
return
|
||||
}
|
||||
return
|
||||
return nil
|
||||
}
|
||||
|
||||
// Present checks if the device is present at the given address.
|
||||
func (d *TMP006) Present() (status bool, err error) {
|
||||
if err = d.validate(); err != nil {
|
||||
return
|
||||
func (d *TMP006) Present() (bool, error) {
|
||||
if err := d.validate(); err != nil {
|
||||
return false, err
|
||||
}
|
||||
var mid, did uint16
|
||||
if mid, err = d.Bus.ReadWordFromReg(d.Addr, manIdReg); err != nil {
|
||||
return
|
||||
}
|
||||
if d.Debug {
|
||||
log.Printf("tmp006: got manufacturer id %#04x", mid)
|
||||
mid, err := d.Bus.ReadWordFromReg(d.Addr, manIdReg)
|
||||
if err != nil {
|
||||
return false, err
|
||||
}
|
||||
glog.V(1).Infof("tmp006: got manufacturer id %#04x", mid)
|
||||
if mid != manId {
|
||||
err = fmt.Errorf("tmp006: not found at %#02x, manufacturer id mismatch", d.Addr)
|
||||
return
|
||||
return false, fmt.Errorf("tmp006: not found at %#02x, manufacturer id mismatch", d.Addr)
|
||||
}
|
||||
if did, err = d.Bus.ReadWordFromReg(d.Addr, devIdReg); err != nil {
|
||||
return
|
||||
}
|
||||
if d.Debug {
|
||||
log.Printf("tmp006: got device id %#04x", did)
|
||||
did, err := d.Bus.ReadWordFromReg(d.Addr, devIdReg)
|
||||
if err != nil {
|
||||
return false, err
|
||||
}
|
||||
glog.V(1).Infof("tmp006: got device id %#04x", did)
|
||||
if did != devId {
|
||||
err = fmt.Errorf("tmp006: not found at %#02x, device id mismatch", d.Addr)
|
||||
return
|
||||
return false, fmt.Errorf("tmp006: not found at %#02x, device id mismatch", d.Addr)
|
||||
}
|
||||
|
||||
status = true
|
||||
|
||||
return
|
||||
return true, nil
|
||||
}
|
||||
|
||||
func (d *TMP006) setup() (err error) {
|
||||
func (d *TMP006) setup() error {
|
||||
d.mu.RLock()
|
||||
if d.initialized {
|
||||
d.mu.RUnlock()
|
||||
return
|
||||
return nil
|
||||
}
|
||||
d.mu.RUnlock()
|
||||
|
||||
d.mu.Lock()
|
||||
defer d.mu.Unlock()
|
||||
|
||||
if err = d.validate(); err != nil {
|
||||
return
|
||||
if err := d.validate(); err != nil {
|
||||
return err
|
||||
}
|
||||
if d.SampleRate == nil {
|
||||
if d.Debug {
|
||||
log.Printf("tmp006: sample rate = nil, using SR16")
|
||||
}
|
||||
glog.V(1).Infof("tmp006: sample rate = nil, using SR16")
|
||||
d.SampleRate = SR16
|
||||
}
|
||||
if d.Debug {
|
||||
log.Printf("tmp006: configuring with %#04x", configRegDefault|d.SampleRate.enabler)
|
||||
}
|
||||
if err = d.Bus.WriteWordToReg(d.Addr, configReg, configRegDefault|d.SampleRate.enabler); err != nil {
|
||||
return
|
||||
glog.V(1).Infof("tmp006: configuring with %#04x", configRegDefault|d.SampleRate.enabler)
|
||||
if err := d.Bus.WriteWordToReg(d.Addr, configReg, configRegDefault|d.SampleRate.enabler); err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
d.initialized = true
|
||||
|
||||
return
|
||||
return nil
|
||||
}
|
||||
|
||||
func (d *TMP006) measureRawDieTemp() (temp float64, err error) {
|
||||
if err = d.setup(); err != nil {
|
||||
return
|
||||
func (d *TMP006) measureRawDieTemp() (float64, error) {
|
||||
if err := d.setup(); err != nil {
|
||||
return 0, err
|
||||
}
|
||||
var raw uint16
|
||||
if raw, err = d.Bus.ReadWordFromReg(d.Addr, tempAmbReg); err != nil {
|
||||
return
|
||||
raw, err := d.Bus.ReadWordFromReg(d.Addr, tempAmbReg)
|
||||
if err != nil {
|
||||
return 0, err
|
||||
}
|
||||
raw >>= 2
|
||||
if d.Debug {
|
||||
log.Printf("tmp006: raw die temp %#04x", raw)
|
||||
}
|
||||
glog.V(2).Infof("tmp006: raw die temp %#04x", raw)
|
||||
|
||||
temp = float64(int16(raw)) * 0.03125
|
||||
temp := float64(int16(raw)) * 0.03125
|
||||
|
||||
return
|
||||
return temp, nil
|
||||
}
|
||||
|
||||
func (d *TMP006) measureRawVoltage() (volt int16, err error) {
|
||||
if err = d.setup(); err != nil {
|
||||
return
|
||||
func (d *TMP006) measureRawVoltage() (int16, error) {
|
||||
if err := d.setup(); err != nil {
|
||||
return 0, err
|
||||
}
|
||||
var vlt uint16
|
||||
if vlt, err = d.Bus.ReadWordFromReg(d.Addr, vObjReg); err != nil {
|
||||
return
|
||||
vlt, err := d.Bus.ReadWordFromReg(d.Addr, vObjReg)
|
||||
if err != nil {
|
||||
return 0, err
|
||||
}
|
||||
volt = int16(vlt)
|
||||
if d.Debug {
|
||||
log.Printf("tmp006: raw voltage %#04x", volt)
|
||||
}
|
||||
return
|
||||
volt := int16(vlt)
|
||||
glog.V(2).Infof("tmp006: raw voltage %#04x", volt)
|
||||
return volt, nil
|
||||
}
|
||||
|
||||
func (d *TMP006) measureObjTemp() (temp float64, err error) {
|
||||
if err = d.setup(); err != nil {
|
||||
return
|
||||
func (d *TMP006) measureObjTemp() (float64, error) {
|
||||
if err := d.setup(); err != nil {
|
||||
return 0, err
|
||||
}
|
||||
tDie, err := d.measureRawDieTemp()
|
||||
if err != nil {
|
||||
return
|
||||
}
|
||||
if d.Debug {
|
||||
log.Printf("tmp006: tdie = %.2f C", tDie)
|
||||
return 0, err
|
||||
}
|
||||
glog.V(2).Infof("tmp006: tdie = %.2f C", tDie)
|
||||
tDie += 273.15 // Convert to K
|
||||
vo, err := d.measureRawVoltage()
|
||||
if err != nil {
|
||||
return
|
||||
return 0, err
|
||||
}
|
||||
vObj := float64(vo)
|
||||
vObj *= 156.25 // 156.25 nV per LSB
|
||||
vObj /= 1000 // nV -> uV
|
||||
if d.Debug {
|
||||
log.Printf("tmp006: vObj = %.5f uV", vObj)
|
||||
}
|
||||
glog.V(2).Infof("tmp006: vObj = %.5f uV", vObj)
|
||||
vObj /= 1000 // uV -> mV
|
||||
vObj /= 1000 // mV -> V
|
||||
|
||||
|
@ -238,17 +215,17 @@ func (d *TMP006) measureObjTemp() (temp float64, err error) {
|
|||
Vos := b0 + b1*tdie_tref + b2*tdie_tref*tdie_tref
|
||||
fVobj := (vObj - Vos) + c2*(vObj-Vos)*(vObj-Vos)
|
||||
|
||||
temp = math.Sqrt(math.Sqrt(tDie*tDie*tDie*tDie + fVobj/s))
|
||||
temp := math.Sqrt(math.Sqrt(tDie*tDie*tDie*tDie + fVobj/s))
|
||||
temp -= 273.15
|
||||
|
||||
return
|
||||
return temp, nil
|
||||
}
|
||||
|
||||
// RawDieTemp returns the current raw die temp reading.
|
||||
func (d *TMP006) RawDieTemp() (temp float64, err error) {
|
||||
func (d *TMP006) RawDieTemp() (float64, error) {
|
||||
select {
|
||||
case temp = <-d.rawDieTemps:
|
||||
return
|
||||
case temp := <-d.rawDieTemps:
|
||||
return temp, nil
|
||||
default:
|
||||
return d.measureRawDieTemp()
|
||||
}
|
||||
|
@ -260,10 +237,10 @@ func (d *TMP006) RawDieTemps() <-chan float64 {
|
|||
}
|
||||
|
||||
// ObjTemp returns the current obj temp reading.
|
||||
func (d *TMP006) ObjTemp() (temp float64, err error) {
|
||||
func (d *TMP006) ObjTemp() (float64, error) {
|
||||
select {
|
||||
case temp = <-d.objTemps:
|
||||
return
|
||||
case temp := <-d.objTemps:
|
||||
return temp, nil
|
||||
default:
|
||||
return d.measureObjTemp()
|
||||
}
|
||||
|
@ -275,9 +252,9 @@ func (d *TMP006) ObjTemps() <-chan float64 {
|
|||
}
|
||||
|
||||
// Start starts the data acquisition loop.
|
||||
func (d *TMP006) Start() (err error) {
|
||||
if err = d.setup(); err != nil {
|
||||
return
|
||||
func (d *TMP006) Start() error {
|
||||
if err := d.setup(); err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
d.rawDieTemps = make(chan float64)
|
||||
|
@ -307,14 +284,14 @@ func (d *TMP006) Start() (err error) {
|
|||
case <-timer:
|
||||
var rdt float64
|
||||
if rdt, err = d.measureRawDieTemp(); err != nil {
|
||||
log.Printf("tmp006: %v", err)
|
||||
glog.Errorf("tmp006: %v", err)
|
||||
} else {
|
||||
rawDieTemp = rdt
|
||||
rdtAvlb = true
|
||||
}
|
||||
var ot float64
|
||||
if ot, err = d.measureObjTemp(); err != nil {
|
||||
log.Printf("tmp006: %v", err)
|
||||
glog.Errorf("tmp006: %v", err)
|
||||
} else {
|
||||
objTemp = ot
|
||||
otAvlb = true
|
||||
|
@ -333,5 +310,5 @@ func (d *TMP006) Start() (err error) {
|
|||
}
|
||||
}()
|
||||
|
||||
return
|
||||
return nil
|
||||
}
|
||||
|
|
|
@ -2,10 +2,10 @@
|
|||
package us020
|
||||
|
||||
import (
|
||||
"log"
|
||||
"sync"
|
||||
"time"
|
||||
|
||||
"github.com/golang/glog"
|
||||
"github.com/kidoman/embd"
|
||||
)
|
||||
|
||||
|
@ -37,8 +37,6 @@ type US020 struct {
|
|||
|
||||
initialized bool
|
||||
mu sync.RWMutex
|
||||
|
||||
Debug bool
|
||||
}
|
||||
|
||||
// New creates a new US020 interface. The bus variable controls
|
||||
|
@ -47,11 +45,11 @@ func New(echoPin, triggerPin embd.DigitalPin, thermometer Thermometer) *US020 {
|
|||
return &US020{EchoPin: echoPin, TriggerPin: triggerPin, Thermometer: thermometer}
|
||||
}
|
||||
|
||||
func (d *US020) setup() (err error) {
|
||||
func (d *US020) setup() error {
|
||||
d.mu.RLock()
|
||||
if d.initialized {
|
||||
d.mu.RUnlock()
|
||||
return
|
||||
return nil
|
||||
}
|
||||
d.mu.RUnlock()
|
||||
|
||||
|
@ -68,36 +66,30 @@ func (d *US020) setup() (err error) {
|
|||
if temp, err := d.Thermometer.Temperature(); err == nil {
|
||||
d.speedSound = 331.3 + 0.606*temp
|
||||
|
||||
if d.Debug {
|
||||
log.Printf("read a temperature of %v, so speed of sound = %v", temp, d.speedSound)
|
||||
}
|
||||
glog.V(1).Infof("us020: read a temperature of %v, so speed of sound = %v", temp, d.speedSound)
|
||||
} else {
|
||||
d.speedSound = 340
|
||||
}
|
||||
|
||||
d.initialized = true
|
||||
|
||||
return
|
||||
return nil
|
||||
}
|
||||
|
||||
// Distance computes the distance of the bot from the closest obstruction.
|
||||
func (d *US020) Distance() (distance float64, err error) {
|
||||
if err = d.setup(); err != nil {
|
||||
return
|
||||
func (d *US020) Distance() (float64, error) {
|
||||
if err := d.setup(); err != nil {
|
||||
return 0, err
|
||||
}
|
||||
|
||||
if d.Debug {
|
||||
log.Print("us020: trigerring pulse")
|
||||
}
|
||||
glog.V(2).Infof("us020: trigerring pulse")
|
||||
|
||||
// Generate a TRIGGER pulse
|
||||
d.TriggerPin.Write(embd.High)
|
||||
time.Sleep(pulseDelay)
|
||||
d.TriggerPin.Write(embd.Low)
|
||||
|
||||
if d.Debug {
|
||||
log.Print("us020: waiting for echo to go high")
|
||||
}
|
||||
glog.V(2).Infof("us020: waiting for echo to go high")
|
||||
|
||||
// Wait until ECHO goes high
|
||||
for {
|
||||
|
@ -113,9 +105,7 @@ func (d *US020) Distance() (distance float64, err error) {
|
|||
|
||||
startTime := time.Now() // Record time when ECHO goes high
|
||||
|
||||
if d.Debug {
|
||||
log.Print("us020: waiting for echo to go low")
|
||||
}
|
||||
glog.V(2).Infof("us020: waiting for echo to go low")
|
||||
|
||||
// Wait until ECHO goes low
|
||||
for {
|
||||
|
@ -132,12 +122,12 @@ func (d *US020) Distance() (distance float64, err error) {
|
|||
duration := time.Since(startTime) // Calculate time lapsed for ECHO to transition from high to low
|
||||
|
||||
// Calculate the distance based on the time computed
|
||||
distance = float64(duration.Nanoseconds()) / 10000000 * (d.speedSound / 2)
|
||||
distance := float64(duration.Nanoseconds()) / 10000000 * (d.speedSound / 2)
|
||||
|
||||
return
|
||||
return distance, nil
|
||||
}
|
||||
|
||||
// Close.
|
||||
func (d *US020) Close() {
|
||||
d.EchoPin.SetDirection(embd.Out)
|
||||
func (d *US020) Close() error {
|
||||
return d.EchoPin.SetDirection(embd.Out)
|
||||
}
|
||||
|
|
|
@ -14,8 +14,6 @@ type WaterSensor struct {
|
|||
|
||||
initialized bool
|
||||
mu sync.RWMutex
|
||||
|
||||
Debug bool
|
||||
}
|
||||
|
||||
// New creates a new WaterSensor struct
|
||||
|
@ -48,9 +46,7 @@ func (d *WaterSensor) IsWet() (bool, error) {
|
|||
return false, err
|
||||
}
|
||||
|
||||
if d.Debug {
|
||||
glog.Infof("watersensor: reading")
|
||||
}
|
||||
glog.V(1).Infof("watersensor: reading")
|
||||
|
||||
value, err := d.Pin.Read()
|
||||
if err != nil {
|
||||
|
|
Loading…
Add table
Add a link
Reference in a new issue