embedded
/
devices
mirror of https://github.com/periph/devices
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

mcp9808: add experimental support for digital temperature sensor (#356)

Browse Source 
* mcp9808: add support for digital temperature sensor

Add support for microchip i2c MCP9808 temperature sensor.
pull/1/head
NeuralSpaz 8 years ago committed by GitHub
parent a8429b61f9
commit d1d3b72147
5 changed files with 1548 additions and 0 deletions
Show Stats Download Patch File Download Diff File

18
experimental/devices/mcp9808/doc.go
Unescape Escape View File

@ -0,0 +1,18 @@
// Copyright 2018 The Periph Authors. All rights reserved.
// Use of this source code is governed under the Apache License, Version 2.0
// that can be found in the LICENSE file.
// Package mcp9808 controls a Microchip MCP9808 digital I²C temperature sensor.
//
// Features
//
// -40°C and +125°C Operating Range.
//
// User-Selectable Measurement Resolution: +0.5°C, +0.25°C, +0.125°C, +0.0625°C.
//
// User-Programmable Temperature Alerts.
//
// Datasheet
//
// http://ww1.microchip.com/downloads/en/DeviceDoc/25095A.pdf
package mcp9808

81
experimental/devices/mcp9808/example_test.go
Unescape Escape View File

@ -0,0 +1,81 @@
// Copyright 2018 The Periph Authors. All rights reserved.
// Use of this source code is governed under the Apache License, Version 2.0
// that can be found in the LICENSE file.
package mcp9808_test
import (
"fmt"
"log"
"periph.io/x/periph/conn/i2c/i2creg"
"periph.io/x/periph/conn/physic"
"periph.io/x/periph/experimental/devices/mcp9808"
"periph.io/x/periph/host"
)
func ExampleDev_SenseTemp() {
// Make sure periph is initialized.
if _, err := host.Init(); err != nil {
log.Fatal(err)
}
// Open default I²C bus.
bus, err := i2creg.Open("")
if err != nil {
log.Fatalf("failed to open I²C: %v", err)
}
defer bus.Close()
// Create a new temperature sensor.
sensor, err := mcp9808.New(bus, &mcp9808.DefaultOpts)
if err != nil {
log.Fatalln(err)
}
// Read values from sensor.
measurement, err := sensor.SenseTemp()
if err != nil {
log.Fatalln(err)
}
fmt.Println(measurement)
}
func ExampleDev_SenseWithAlerts() {
// Make sure periph is initialized.
if _, err := host.Init(); err != nil {
log.Fatal(err)
}
// Open default I²C bus.
bus, err := i2creg.Open("")
if err != nil {
log.Fatalf("failed to open I²C: %v", err)
}
defer bus.Close()
// Create a new temperature sensor.
sensor, err := mcp9808.New(bus, &mcp9808.DefaultOpts)
if err != nil {
log.Fatalln(err)
}
lower := physic.ZeroCelsius
upper := physic.ZeroCelsius + 25*physic.Celsius
critical := physic.ZeroCelsius + 32*physic.Celsius
// Read values from sensor.
temperature, alerts, err := sensor.SenseWithAlerts(lower, upper, critical)
if err != nil {
log.Fatalln(err)
}
for _, alert := range alerts {
fmt.Println(alert)
}
fmt.Println(temperature)
}

426
experimental/devices/mcp9808/mcp9808.go
Unescape Escape View File

@ -0,0 +1,426 @@
// Copyright 2018 The Periph Authors. All rights reserved.
// Use of this source code is governed under the Apache License, Version 2.0
// that can be found in the LICENSE file.
package mcp9808
import (
"encoding/binary"
"errors"
"sync"
"time"
"periph.io/x/periph/conn"
"periph.io/x/periph/conn/i2c"
"periph.io/x/periph/conn/mmr"
"periph.io/x/periph/conn/physic"
)
// Opts holds the configuration options.
//
// Slave Address
//
// Depending which pins the A0, A1 and A2 pins are connected to will change the
// slave address. Default configuration is address 0x18 (Ax pins to GND). For a
// full address table see datasheet.
type Opts struct {
Addr int
Res resolution
}
// DefaultOpts is the recommended default options.
var DefaultOpts = Opts{
Addr: 0x18,
Res: Maximum,
}
// New opens a handle to an mcp9808 sensor.
func New(bus i2c.Bus, opts *Opts) (*Dev, error) {
i2cAddress := DefaultOpts.Addr
if opts.Addr != 0 {
if opts.Addr < 0x18 || opts.Addr > 0x1f {
return nil, errAddressOutOfRange
}
i2cAddress = opts.Addr
}
dev := &Dev{
m: mmr.Dev8{
Conn: &i2c.Dev{Bus: bus, Addr: uint16(i2cAddress)},
Order: binary.BigEndian,
},
stop: make(chan struct{}, 1),
res: opts.Res,
enabled: false,
}
if err := dev.setResolution(opts.Res); err != nil {
return nil, err
}
if err := dev.enable(); err != nil {
return nil, err
}
return dev, nil
}
// Dev is a handle to the mcp9808 sensor.
type Dev struct {
m mmr.Dev8
stop chan struct{}
res resolution
mu sync.Mutex
sensing bool
critical physic.Temperature
upper physic.Temperature
lower physic.Temperature
enabled bool
}
// Sense reads the current temperature.
func (d *Dev) Sense(e *physic.Env) error {
t, _, err := d.readTemperature()
e.Temperature = t
return err
}
// SenseContinuous returns measurements as °C, on a continuous basis.
// The application must call Halt() to stop the sensing when done to stop the
// sensor and close the channel.
// It's the responsibility of the caller to retrieve the values from the channel
// as fast as possible, otherwise the interval may not be respected.
func (d *Dev) SenseContinuous(interval time.Duration) (<-chan physic.Env, error) {
switch d.res {
case Maximum:
if interval < 250*time.Millisecond {
return nil, errTooShortInterval
}
case High:
if interval < 130*time.Millisecond {
return nil, errTooShortInterval
}
case Medium:
if interval < 65*time.Millisecond {
return nil, errTooShortInterval
}
case Low:
if interval < 30*time.Millisecond {
return nil, errTooShortInterval
}
}
env := make(chan physic.Env)
d.mu.Lock()
d.sensing = true
d.mu.Unlock()
var wg sync.WaitGroup
wg.Add(1)
go func() {
for {
select {
case <-time.After(interval):
t, _, _ := d.readTemperature()
env <- physic.Env{Temperature: t}
case <-d.stop:
wg.Done()
return
}
}
}()
go func() {
wg.Wait()
close(env)
d.mu.Lock()
d.sensing = false
d.mu.Unlock()
}()
return env, nil
}
func (d *Dev) Precision(e *physic.Env) {
switch d.res {
case Maximum:
e.Temperature = 62500 * physic.MicroKelvin
case High:
e.Temperature = 125 * physic.MilliKelvin
case Medium:
e.Temperature = 250 * physic.MilliKelvin
case Low:
e.Temperature = 500 * physic.MilliKelvin
}
}
// SenseTemp reads the current temperature.
func (d *Dev) SenseTemp() (physic.Temperature, error) {
t, _, err := d.readTemperature()
return t, err
}
// SenseWithAlerts reads the ambient temperature and returns an slice of any
// alerts that have been tripped. Lower must be less than upper which must be
// less than critical.
func (d *Dev) SenseWithAlerts(lower, upper, critical physic.Temperature) (physic.Temperature, []Alert, error) {
if critical > upper && upper > lower {
if err := d.setCriticalAlert(critical); err != nil {
return 0, nil, err
}
if err := d.setUpperAlert(upper); err != nil {
return 0, nil, err
}
if err := d.setLowerAlert(lower); err != nil {
return 0, nil, err
}
} else {
return 0, nil, errAlertInvalid
}
t, alertBits, err := d.readTemperature()
if err != nil {
return 0, nil, err
}
// Check for Alerts.
if alertBits&0xe0 > 0 {
var as []Alert
if alertBits&0x80 > 0 {
// Critical Alert bit set.
crit, err := d.m.ReadUint16(critAlert)
if err != nil {
return t, nil, errReadCriticalAlert
}
t := alertBitsToTemperature(crit)
as = append(as, Alert{"critical", t})
}
if alertBits&0x40 > 0 {
// Upper Alert bit set.
upper, err := d.m.ReadUint16(upperAlert)
if err != nil {
return t, nil, errReadUpperAlert
}
t := alertBitsToTemperature(upper)
as = append(as, Alert{"upper", t})
}
if alertBits&0x20 > 0 {
// Lower Alert bit set.
lower, err := d.m.ReadUint16(lowerAlert)
if err != nil {
return t, nil, errReadLowerAlert
}
t := alertBitsToTemperature(lower)
as = append(as, Alert{"lower", t})
}
return t, as, nil
}
return t, nil, nil
}
// Halt put the mcp9808 into shutdown mode. It will not read temperatures while
// in shutdown mode.
func (d *Dev) Halt() error {
d.mu.Lock()
if d.sensing {
d.stop <- struct{}{}
}
d.mu.Unlock()
if err := d.m.WriteUint16(configuration, 0x0100); err != nil {
return errWritingConfiguration
}
d.mu.Lock()
d.enabled = false
d.mu.Unlock()
return nil
}
func (d *Dev) String() string {
return "MCP9808"
}
func (d *Dev) enable() error {
d.mu.Lock()
defer d.mu.Unlock()
if !d.enabled {
if err := d.m.WriteUint16(configuration, 0x0000); err != nil {
return errWritingConfiguration
}
d.enabled = true
}
return nil
}
func (d *Dev) readTemperature() (physic.Temperature, uint8, error) {
if err := d.enable(); err != nil {
return 0, 0, err
}
tbits, err := d.m.ReadUint16(temperature)
if err != nil {
return 0, 0, errReadTemperature
}
// Convert to physic.Temperature 0.0625°C per bit
t := physic.Temperature(tbits&0x0FFF) * 62500 * physic.MicroKelvin
if tbits&0x1000 > 0 {
// Check for bit sign.
t = -t
}
t += physic.ZeroCelsius
return t, uint8(tbits>>8) & 0xe0, nil
}
func (d *Dev) setResolution(r resolution) error {
switch r {
case Low:
if err := d.m.WriteUint8(resolutionConfig, 0x00); err != nil {
return errWritingResolution
}
case Medium:
if err := d.m.WriteUint8(resolutionConfig, 0x01); err != nil {
return errWritingResolution
}
case High:
if err := d.m.WriteUint8(resolutionConfig, 0x02); err != nil {
return errWritingResolution
}
case Maximum:
if err := d.m.WriteUint8(resolutionConfig, 0x03); err != nil {
return errWritingResolution
}
default:
return errInvalidResolution
}
return nil
}
func (d *Dev) setCriticalAlert(t physic.Temperature) error {
d.mu.Lock()
defer d.mu.Unlock()
if t == d.critical {
return nil
}
crit, err := alertTemperatureToBits(t)
if err != nil {
return err
}
if err := d.m.WriteUint16(critAlert, crit); err != nil {
return errWritingCritAlert
}
d.critical = t
return nil
}
func (d *Dev) setUpperAlert(t physic.Temperature) error {
d.mu.Lock()
defer d.mu.Unlock()
if t == d.upper {
return nil
}
upper, err := alertTemperatureToBits(t)
if err != nil {
return err
}
if err := d.m.WriteUint16(upperAlert, upper); err != nil {
return errWritingUpperAlert
}
d.upper = t
return nil
}
func (d *Dev) setLowerAlert(t physic.Temperature) error {
d.mu.Lock()
defer d.mu.Unlock()
if t == d.lower {
return nil
}
lower, err := alertTemperatureToBits(t)
if err != nil {
return err
}
if err := d.m.WriteUint16(lowerAlert, lower); err != nil {
return errWritingLowerAlert
}
d.lower = t
return nil
}
type Alert struct {
AlertMode string
AlertLevel physic.Temperature
}
const (
// Register addresses.
configuration byte = 0x01
upperAlert byte = 0x02
lowerAlert byte = 0x03
critAlert byte = 0x04
temperature byte = 0x05
manifactureID byte = 0x06
deviceID byte = 0x07
resolutionConfig byte = 0x08
)
var (
errReadTemperature = errors.New("failed to read ambient temperature")
errReadCriticalAlert = errors.New("failed to read critical temperature")
errReadUpperAlert = errors.New("failed to read upper temperature")
errReadLowerAlert = errors.New("failed to read lower temperature")
errAddressOutOfRange = errors.New("i2c address out of range")
errInvalidResolution = errors.New("invalid resolution")
errWritingResolution = errors.New("failed to write resolution configuration")
errWritingConfiguration = errors.New("failed to write configuration")
errWritingCritAlert = errors.New("failed to write critical alert configuration")
errWritingUpperAlert = errors.New("failed to write upper alert configuration")
errWritingLowerAlert = errors.New("failed to write lower alert configuration")
errAlertOutOfRange = errors.New("alert setting exceeds operating conditions")
errAlertInvalid = errors.New("invalid alert temperature configuration")
errTooShortInterval = errors.New("too short interval for resolution")
)
func alertBitsToTemperature(b uint16) physic.Temperature {
b = (b >> 2) & 0x07FF
t := physic.Temperature(b&0x03FF) * 250 * physic.MilliKelvin
if b&0x400 > 0 {
t = -t
}
t += physic.ZeroCelsius
return t
}
func alertTemperatureToBits(t physic.Temperature) (uint16, error) {
const maxAlert = 125*physic.Kelvin + physic.ZeroCelsius
const minAlert = -40*physic.Kelvin + physic.ZeroCelsius
if t > maxAlert || t < minAlert {
return 0, errAlertOutOfRange
}
t -= physic.ZeroCelsius
// 0.25°C per bit.
t /= 250 * physic.MilliKelvin
var bits uint16
if t < 0 {
t = -t
bits |= 0x400
}
bits |= uint16(t)
bits = bits << 2
return bits, nil
}
type resolution uint8
const (
Maximum resolution = 0
Low resolution = 1
Medium resolution = 2
High resolution = 3
)
var _ conn.Resource = &Dev{}
var _ physic.SenseEnv = &Dev{}

947
experimental/devices/mcp9808/mcp9808_test.go
Unescape Escape View File

@ -0,0 +1,947 @@
// Copyright 2018 The Periph Authors. All rights reserved.
// Use of this source code is governed under the Apache License, Version 2.0
// that can be found in the LICENSE file.
package mcp9808
import (
"encoding/binary"
"reflect"
"testing"
"time"
"periph.io/x/periph/conn/i2c"
"periph.io/x/periph/conn/i2c/i2ctest"
"periph.io/x/periph/conn/mmr"
"periph.io/x/periph/conn/physic"
)
func TestNew(t *testing.T) {
tests := []struct {
name string
opts Opts
tx []i2ctest.IO
want error
}{
{
name: "defaults",
opts: DefaultOpts,
tx: []i2ctest.IO{
{Addr: 0x18, W: []byte{resolutionConfig, 0x03}, R: []byte{}},
{Addr: 0x18, W: []byte{configuration, 0x00, 0x00}, R: []byte{}},
},
want: nil,
},
{
name: "bad address",
opts: Opts{Addr: 0x40},
want: errAddressOutOfRange,
},
{
name: "io error",
opts: Opts{Addr: 0x18},
want: errWritingResolution,
},
{
name: "enabled error",
opts: DefaultOpts,
tx: []i2ctest.IO{
{Addr: 0x18, W: []byte{resolutionConfig, 0x03}, R: []byte{}},
},
want: errWritingConfiguration,
},
}
for _, tt := range tests {
bus := i2ctest.Playback{
Ops: tt.tx,
DontPanic: true,
}
_, err := New(&bus, &tt.opts)
if err != tt.want {
t.Errorf("New(%s) expected %v but got %v ", tt.name, tt.want, err)
}
}
}
func TestSense(t *testing.T) {
tests := []struct {
name string
want physic.Temperature
tx []i2ctest.IO
enabled bool
err error
}{
{
name: "0C",
tx: []i2ctest.IO{
{Addr: 0x18, W: []byte{temperature}, R: []byte{0x00, 0x00}},
},
enabled: true,
want: physic.ZeroCelsius,
err: nil,
},
{
name: "10C",
tx: []i2ctest.IO{
{Addr: 0x18, W: []byte{temperature}, R: []byte{0x00, 0xa0}},
},
enabled: true,
want: physic.ZeroCelsius + 10*physic.Kelvin,
err: nil,
},
{
name: "-10C",
tx: []i2ctest.IO{
{Addr: 0x18, W: []byte{temperature}, R: []byte{0x10, 0xa0}},
},
enabled: true,
want: physic.ZeroCelsius - 10*physic.Kelvin,
err: nil,
},
{
name: "io error",
tx: []i2ctest.IO{},
enabled: true,
err: errReadTemperature,
},
{
name: "enable error",
enabled: false,
want: physic.ZeroCelsius + 10*physic.Kelvin,
err: errWritingConfiguration,
},
}
for _, tt := range tests {
bus := i2ctest.Playback{
Ops: tt.tx,
DontPanic: true,
}
mcp9808 := &Dev{
m: mmr.Dev8{
Conn: &i2c.Dev{Bus: &bus, Addr: 0x18},
Order: binary.BigEndian},
enabled: tt.enabled,
}
e := &physic.Env{}
err := mcp9808.Sense(e)
if err == nil && tt.want != e.Temperature {
t.Errorf("%s Sense() expected %v but got %v ", tt.name, tt.want, e.Temperature)
}
if err != tt.err {
t.Errorf("%s Sense() expected %v but got %v ", tt.name, tt.err, err)
}
}
}
func TestSenseContinuous(t *testing.T) {
tests := []struct {
name string
want physic.Temperature
res resolution
interval time.Duration
tx []i2ctest.IO
enabled bool
Halt bool
err error
}{
{
name: "errTooShortInterval Max",
res: Maximum,
interval: 249 * time.Millisecond,
err: errTooShortInterval,
},
{
name: "errTooShortInterval High",
res: High,
interval: 129 * time.Millisecond,
err: errTooShortInterval,
},
{
name: "errTooShortInterval Med",
res: Medium,
interval: 64 * time.Millisecond,
err: errTooShortInterval,
},
{
name: "errTooShortInterval Low",
res: Low,
interval: 29 * time.Millisecond,
err: errTooShortInterval,
},
{
name: "Halt",
tx: []i2ctest.IO{
{Addr: 0x18, W: []byte{temperature}, R: []byte{0x00, 0xa0}},
{Addr: 0x18, W: []byte{configuration, 0x01, 0x00}, R: nil},
},
want: physic.ZeroCelsius + 10*physic.Celsius,
res: Low,
interval: 30 * time.Millisecond,
enabled: true,
Halt: true,
err: nil,
},
}
for _, tt := range tests {
bus := i2ctest.Playback{
Ops: tt.tx,
DontPanic: true,
}
mcp9808 := &Dev{
m: mmr.Dev8{
Conn: &i2c.Dev{Bus: &bus, Addr: 0x18},
Order: binary.BigEndian,
},
res: tt.res,
enabled: tt.enabled,
stop: make(chan struct{}, 1),
}
env, err := mcp9808.SenseContinuous(tt.interval)
if tt.Halt {
e := <-env
err := mcp9808.Halt()
if err != tt.err {
t.Errorf("SenseContinuous() %s wanted err: %v, but got: %v", tt.name, tt.err, err)
}
if err == nil && e.Temperature != tt.want {
t.Errorf("SenseContinuous() %s wanted %v, but got: %v", tt.name, tt.want, e.Temperature)
}
}
if err != tt.err {
t.Errorf("SenseContinuous() %s wanted err: %v, but got: %v", tt.name, tt.err, err)
}
mcp9808.Halt()
}
}
func TestPrecision(t *testing.T) {
tests := []struct {
name string
want physic.Temperature
res resolution
}{
{
name: "Maximum",
want: 62500 * physic.MicroKelvin,
res: Maximum,
},
{
name: "High",
want: 125 * physic.MilliKelvin,
res: High,
},
{
name: "Medium",
want: 250 * physic.MilliKelvin,
res: Medium,
},
{
name: "Low",
want: 500 * physic.MilliKelvin,
res: Low,
},
}
for _, tt := range tests {
d := &Dev{res: tt.res}
e := &physic.Env{}
d.Precision(e)
if e.Temperature != tt.want {
t.Errorf("Precision(%s) wanted %v but got %v", tt.name, tt.want, e.Temperature)
}
}
}
func TestSenseTemp(t *testing.T) {
tests := []struct {
name string
want physic.Temperature
tx []i2ctest.IO
err error
}{
{
name: "0C",
tx: []i2ctest.IO{
{Addr: 0x18, W: []byte{temperature}, R: []byte{0x00, 0x00}},
},
want: physic.ZeroCelsius,
err: nil,
},
{
name: "10C",
tx: []i2ctest.IO{
{Addr: 0x18, W: []byte{temperature}, R: []byte{0x00, 0xa0}},
},
want: physic.ZeroCelsius + 10*physic.Kelvin,
err: nil,
},
{
name: "-10C",
tx: []i2ctest.IO{
{Addr: 0x18, W: []byte{temperature}, R: []byte{0x10, 0xa0}},
},
want: physic.ZeroCelsius - 10*physic.Kelvin,
err: nil,
},
{
name: "io error",
tx: []i2ctest.IO{},
err: errReadTemperature,
},
}
for _, tt := range tests {
bus := i2ctest.Playback{
Ops: tt.tx,
DontPanic: true,
}
mcp9808 := &Dev{
m: mmr.Dev8{
Conn: &i2c.Dev{Bus: &bus, Addr: 0x18},
Order: binary.BigEndian},
enabled: true,
}
got, err := mcp9808.SenseTemp()
if tt.want != got {
t.Errorf("%s SenseTemp() expected %v but got %v ", tt.name, tt.want, got)
}
if err != tt.err {
t.Errorf("%s SenseTemp() expected %v but got %v ", tt.name, tt.err, err)
}
}
}
func TestSenseWithAlerts(t *testing.T) {
tests := []struct {
name string
critical physic.Temperature
upper physic.Temperature
lower physic.Temperature
temp physic.Temperature
alerts []Alert
tx []i2ctest.IO
err error
}{
{
name: "read no alert",
critical: physic.ZeroCelsius + 10*physic.Kelvin,
upper: physic.ZeroCelsius + 5*physic.Kelvin,
lower: physic.ZeroCelsius,
temp: physic.ZeroCelsius + 1*physic.Kelvin,
alerts: nil,
tx: []i2ctest.IO{
{Addr: 0x18, W: []byte{critAlert, 0x00, 0xa0}, R: nil},
{Addr: 0x18, W: []byte{upperAlert, 0x00, 0x50}, R: nil},
{Addr: 0x18, W: []byte{lowerAlert, 0x00, 0x00}, R: nil},
{Addr: 0x18, W: []byte{temperature}, R: []byte{0x00, 0x10}},
},
err: nil,
},
{
name: "get lower Alert",
critical: physic.ZeroCelsius + 10*physic.Kelvin,
upper: physic.ZeroCelsius + 5*physic.Kelvin,
lower: physic.ZeroCelsius,
temp: physic.ZeroCelsius - 1*physic.Kelvin,
alerts: []Alert{
{"lower", physic.ZeroCelsius},
},
tx: []i2ctest.IO{
{Addr: 0x18, W: []byte{critAlert, 0x00, 0xa0}, R: nil},
{Addr: 0x18, W: []byte{upperAlert, 0x00, 0x50}, R: nil},
{Addr: 0x18, W: []byte{lowerAlert, 0x00, 0x00}, R: nil},
{Addr: 0x18, W: []byte{temperature}, R: []byte{0x30, 0x10}},
{Addr: 0x18, W: []byte{lowerAlert}, R: []byte{0x00, 0x00}},
},
err: nil,
},
{
name: "get upper Alert",
critical: physic.ZeroCelsius + 10*physic.Kelvin,
upper: physic.ZeroCelsius + 5*physic.Kelvin,
lower: physic.ZeroCelsius,
temp: physic.ZeroCelsius + 7*physic.Kelvin,
alerts: []Alert{
{"upper", physic.ZeroCelsius + 5*physic.Kelvin},
},
tx: []i2ctest.IO{
{Addr: 0x18, W: []byte{critAlert, 0x00, 0xa0}, R: nil},
{Addr: 0x18, W: []byte{upperAlert, 0x00, 0x50}, R: nil},
{Addr: 0x18, W: []byte{lowerAlert, 0x00, 0x00}, R: nil},
{Addr: 0x18, W: []byte{temperature}, R: []byte{0x40, 0x70}},
{Addr: 0x18, W: []byte{upperAlert}, R: []byte{0x00, 0x50}},
},
err: nil,
},
{
name: "get critical Alert",
critical: physic.ZeroCelsius + 10*physic.Kelvin,
upper: physic.ZeroCelsius + 5*physic.Kelvin,
lower: physic.ZeroCelsius,
temp: physic.ZeroCelsius + 15*physic.Kelvin,
alerts: []Alert{
{"critical", physic.ZeroCelsius + 10*physic.Kelvin},
{"upper", physic.ZeroCelsius + 5*physic.Kelvin},
},
tx: []i2ctest.IO{
{Addr: 0x18, W: []byte{critAlert, 0x00, 0xa0}, R: nil},
{Addr: 0x18, W: []byte{upperAlert, 0x00, 0x50}, R: nil},
{Addr: 0x18, W: []byte{lowerAlert, 0x00, 0x00}, R: nil},
{Addr: 0x18, W: []byte{temperature}, R: []byte{0xc0, 0xf0}},
{Addr: 0x18, W: []byte{critAlert}, R: []byte{0x00, 0xa0}},
{Addr: 0x18, W: []byte{upperAlert}, R: []byte{0x00, 0x50}},
},
err: nil,
},
{
name: "set critical error",
critical: physic.ZeroCelsius + 10*physic.Kelvin,
upper: physic.ZeroCelsius + 5*physic.Kelvin,
lower: physic.ZeroCelsius,
err: errWritingCritAlert,
},
{
name: "set upper error",
critical: physic.ZeroCelsius + 10*physic.Kelvin,
upper: physic.ZeroCelsius + 5*physic.Kelvin,
lower: physic.ZeroCelsius,
tx: []i2ctest.IO{
{Addr: 0x18, W: []byte{critAlert, 0x00, 0xa0}, R: nil},
},
err: errWritingUpperAlert,
},
{
name: "set lower error",
critical: physic.ZeroCelsius + 10*physic.Kelvin,
upper: physic.ZeroCelsius + 5*physic.Kelvin,
lower: physic.ZeroCelsius,
tx: []i2ctest.IO{
{Addr: 0x18, W: []byte{critAlert, 0x00, 0xa0}, R: nil},
{Addr: 0x18, W: []byte{upperAlert, 0x00, 0x50}, R: nil},
},
err: errWritingLowerAlert,
},
{
name: "invalid alert config",
critical: physic.ZeroCelsius + 1*physic.Kelvin,
upper: physic.ZeroCelsius + 5*physic.Kelvin,
lower: physic.ZeroCelsius,
tx: []i2ctest.IO{},
err: errAlertInvalid,
},
{
name: "temperature io error",
critical: physic.ZeroCelsius + 10*physic.Kelvin,
upper: physic.ZeroCelsius + 5*physic.Kelvin,
lower: physic.ZeroCelsius,
tx: []i2ctest.IO{
{Addr: 0x18, W: []byte{critAlert, 0x00, 0xa0}, R: nil},
{Addr: 0x18, W: []byte{upperAlert, 0x00, 0x50}, R: nil},
{Addr: 0x18, W: []byte{lowerAlert, 0x00, 0x00}, R: nil},
},
err: errReadTemperature,
},
{
name: "read critical io error",
critical: physic.ZeroCelsius + 10*physic.Kelvin,
upper: physic.ZeroCelsius + 5*physic.Kelvin,
lower: physic.ZeroCelsius,
temp: physic.ZeroCelsius + 15*physic.Kelvin,
tx: []i2ctest.IO{
{Addr: 0x18, W: []byte{critAlert, 0x00, 0xa0}, R: nil},
{Addr: 0x18, W: []byte{upperAlert, 0x00, 0x50}, R: nil},
{Addr: 0x18, W: []byte{lowerAlert, 0x00, 0x00}, R: nil},
{Addr: 0x18, W: []byte{temperature}, R: []byte{0xc0, 0xf0}},
},
err: errReadCriticalAlert,
},
{
name: "read upper io error",
critical: physic.ZeroCelsius + 10*physic.Kelvin,
upper: physic.ZeroCelsius + 5*physic.Kelvin,
lower: physic.ZeroCelsius,
temp: physic.ZeroCelsius + 15*physic.Kelvin,
tx: []i2ctest.IO{
{Addr: 0x18, W: []byte{critAlert, 0x00, 0xa0}, R: nil},
{Addr: 0x18, W: []byte{upperAlert, 0x00, 0x50}, R: nil},
{Addr: 0x18, W: []byte{lowerAlert, 0x00, 0x00}, R: nil},
{Addr: 0x18, W: []byte{temperature}, R: []byte{0xc0, 0xf0}},
{Addr: 0x18, W: []byte{critAlert}, R: []byte{0x00, 0xa0}},
},
err: errReadUpperAlert,
},
{
name: "read lower io error",
critical: physic.ZeroCelsius + 10*physic.Kelvin,
upper: physic.ZeroCelsius + 5*physic.Kelvin,
lower: physic.ZeroCelsius,
temp: physic.ZeroCelsius - 1*physic.Kelvin,
alerts: nil,
tx: []i2ctest.IO{
{Addr: 0x18, W: []byte{critAlert, 0x00, 0xa0}, R: nil},
{Addr: 0x18, W: []byte{upperAlert, 0x00, 0x50}, R: nil},
{Addr: 0x18, W: []byte{lowerAlert, 0x00, 0x00}, R: nil},
{Addr: 0x18, W: []byte{temperature}, R: []byte{0x30, 0x10}},
},
err: errReadLowerAlert,
},
}
for _, tt := range tests {
bus := i2ctest.Playback{
Ops: tt.tx,
DontPanic: true,
}
mcp9808 := &Dev{
m: mmr.Dev8{
Conn: &i2c.Dev{Bus: &bus, Addr: 0x18},
Order: binary.BigEndian},
enabled: true,
}
temp, alerts, err := mcp9808.SenseWithAlerts(tt.lower, tt.upper, tt.critical)
if err != tt.err {
t.Errorf("SenseWithAlerts(%s) wanted err: %v but got: %v", tt.name, tt.err, err)
}
if temp != tt.temp {
t.Errorf("SenseWithAlerts(%s) wanted temp: %s but got: %s", tt.name, tt.temp, temp)
}
if !reflect.DeepEqual(alerts, tt.alerts) {
t.Errorf("SenseWithAlerts(%s) expected alerts %+v but got %+v ", tt.name, tt.alerts, alerts)
}
}
}
func TestDevHalt(t *testing.T) {
tests := []struct {
name string
tx []i2ctest.IO
enabled bool
want bool
err error
}{
{
name: "shutdown",
tx: []i2ctest.IO{
{Addr: 0x18, W: []byte{configuration, 0x01, 0x00}, R: nil},
},
enabled: true,
want: false,
err: nil,
},
{
name: "io error",
tx: []i2ctest.IO{
// {Addr: 0x18, W: []byte{configuration, 0x01, 0x00}, R: nil},
},
enabled: true,
want: true,
err: errWritingConfiguration,
},
}
for _, tt := range tests {
bus := i2ctest.Playback{
Ops: tt.tx,
DontPanic: true,
}
mcp9808 := &Dev{
m: mmr.Dev8{
Conn: &i2c.Dev{Bus: &bus, Addr: 0x18},
Order: binary.BigEndian},
enabled: tt.enabled,
}
if err := mcp9808.Halt(); err != tt.err {
t.Errorf("Halt(%s) wanted error: %v but got: %v", tt.name, tt.err, err)
}
if mcp9808.enabled != tt.want {
t.Errorf("Halt(%s) expected dev to be: %t but is: %t", tt.name, tt.want, mcp9808.enabled)
}
}
}
func TestDevString(t *testing.T) {
mcp9808 := &Dev{}
want := "MCP9808"
if want != mcp9808.String() {
t.Errorf("mpc9808.String() expected %s but got %s", want, mcp9808.String())
}
}
func TestDev_enable(t *testing.T) {
tests := []struct {
name string
tx []i2ctest.IO
enabled bool
want bool
err error
}{
{
name: "shutdown",
tx: []i2ctest.IO{
{Addr: 0x18, W: []byte{configuration, 0x00, 0x00}, R: nil},
},
enabled: false,
want: true,
err: nil,
},
{
name: "io error",
tx: []i2ctest.IO{
// {Addr: 0x18, W: []byte{configuration, 0x01, 0x00}, R: nil},
},
enabled: false,
want: false,
err: errWritingConfiguration,
},
}
for _, tt := range tests {
bus := i2ctest.Playback{
Ops: tt.tx,
DontPanic: true,
}
mcp9808 := &Dev{
m: mmr.Dev8{
Conn: &i2c.Dev{Bus: &bus, Addr: 0x18},
Order: binary.BigEndian},
enabled: tt.enabled,
}
if err := mcp9808.enable(); err != tt.err {
t.Errorf("enable(%s) wanted error: %v but got: %v", tt.name, tt.err, err)
}
if mcp9808.enabled != tt.want {
t.Errorf("enable(%s) expected dev to be: %t but is: %t", tt.name, tt.want, mcp9808.enabled)
}
}
}
func TestDev_setResolution(t *testing.T) {
succeeds := []struct {
name string
res resolution
tx []i2ctest.IO
err error
}{
{
name: "Low",
res: Low,
tx: []i2ctest.IO{
{Addr: 0x18, W: []byte{resolutionConfig, 0x00}, R: nil},
},
err: nil,
}, {
name: "Medium",
res: Medium,
tx: []i2ctest.IO{
{Addr: 0x18, W: []byte{resolutionConfig, 0x01}, R: nil},
},
err: nil,
}, {
name: "High",
res: High,
tx: []i2ctest.IO{
{Addr: 0x18, W: []byte{resolutionConfig, 0x02}, R: nil},
},
err: nil,
}, {
name: "Maximum",
res: Maximum,
tx: []i2ctest.IO{
{Addr: 0x18, W: []byte{resolutionConfig, 0x03}, R: nil},
},
err: nil,
},
}
fails := []struct {
name string
res resolution
tx []i2ctest.IO
err error
}{
{
name: "Low",
res: Low,
err: errWritingResolution,
}, {
name: "Medium",
res: Medium,
err: errWritingResolution,
}, {
name: "High",
res: High,
err: errWritingResolution,
}, {
name: "Maximum",
res: Maximum,
err: errWritingResolution,
}, {
name: "Unknown",
res: resolution(5),
err: errInvalidResolution,
},
}
for _, tt := range succeeds {
bus := i2ctest.Playback{
Ops: tt.tx,
DontPanic: true,
}
mcp9808 := &Dev{
m: mmr.Dev8{
Conn: &i2c.Dev{Bus: &bus, Addr: 0x18},
Order: binary.BigEndian},
}
if err := mcp9808.setResolution(tt.res); err != tt.err {
t.Errorf("setResolution(%s) expected %v but got %v", tt.name, tt.err, err)
}
}
for _, tt := range fails {
bus := i2ctest.Playback{
Ops: tt.tx,
DontPanic: true,
}
mcp9808 := &Dev{
m: mmr.Dev8{
Conn: &i2c.Dev{Bus: &bus, Addr: 0x18},
Order: binary.BigEndian},
}
if err := mcp9808.setResolution(tt.res); err != tt.err {
t.Errorf("setResolution(%s) expected %v but got %v", tt.name, tt.err, err)
}
}
}
func TestDev_setCriticalAlert(t *testing.T) {
tests := []struct {
name string
alert physic.Temperature
crit physic.Temperature
tx []i2ctest.IO
err error
}{
{
name: "0C",
alert: physic.ZeroCelsius,
tx: []i2ctest.IO{
{Addr: 0x18, W: []byte{critAlert, 0x00, 0x00}, R: nil},
},
err: nil,
},
{
name: "126C",
alert: physic.ZeroCelsius + 126*physic.Kelvin,
tx: []i2ctest.IO{},
err: errAlertOutOfRange,
},
{
name: "io error",
alert: physic.ZeroCelsius,
tx: []i2ctest.IO{},
err: errWritingCritAlert,
},
{
name: "nop",
alert: physic.ZeroCelsius,
crit: physic.ZeroCelsius,
tx: []i2ctest.IO{},
err: nil,
},
}
for _, tt := range tests {
bus := i2ctest.Playback{
Ops: tt.tx,
DontPanic: true,
}
mcp9808 := &Dev{
m: mmr.Dev8{
Conn: &i2c.Dev{Bus: &bus, Addr: 0x18},
Order: binary.BigEndian},
critical: tt.crit,
}
if err := mcp9808.setCriticalAlert(tt.alert); err != tt.err {
t.Errorf("setCriticalAlert(%s) expected %v but got %v", tt.name, tt.err, err)
}
}
}
func TestDev_setUpperAlert(t *testing.T) {
tests := []struct {
name string
alert physic.Temperature
tx []i2ctest.IO
upper physic.Temperature
err error
}{
{
name: "0C",
alert: physic.ZeroCelsius,
tx: []i2ctest.IO{
{Addr: 0x18, W: []byte{upperAlert, 0x00, 0x00}, R: nil},
},
err: nil,
},
{
name: "126C",
alert: physic.ZeroCelsius + 126*physic.Kelvin,
tx: []i2ctest.IO{},
err: errAlertOutOfRange,
},
{
name: "io error",
alert: physic.ZeroCelsius,
tx: []i2ctest.IO{},
err: errWritingUpperAlert,
},
{
name: "nop",
alert: physic.ZeroCelsius,
upper: physic.ZeroCelsius,
tx: []i2ctest.IO{},
err: nil,
},
}
for _, tt := range tests {
bus := i2ctest.Playback{
Ops: tt.tx,
DontPanic: true,
}
mcp9808 := &Dev{
m: mmr.Dev8{
Conn: &i2c.Dev{Bus: &bus, Addr: 0x18},
Order: binary.BigEndian},
upper: tt.upper,
}
if err := mcp9808.setUpperAlert(tt.alert); err != tt.err {
t.Errorf("setUpperAlert(%s) expected %v but got %v", tt.name, tt.err, err)
}
}
}
func TestDev_setLowerAlert(t *testing.T) {
tests := []struct {
name string
alert physic.Temperature
tx []i2ctest.IO
lower physic.Temperature
err error
}{
{
name: "0C",
alert: physic.ZeroCelsius,
tx: []i2ctest.IO{
{Addr: 0x18, W: []byte{lowerAlert, 0x00, 0x00}, R: nil},
},
err: nil,
},
{
name: "126C",
alert: physic.ZeroCelsius + 126*physic.Kelvin,
tx: []i2ctest.IO{},
err: errAlertOutOfRange,
},
{
name: "io error",
alert: physic.ZeroCelsius,
tx: []i2ctest.IO{},
err: errWritingLowerAlert,
},
{
name: "nop",
alert: physic.ZeroCelsius,
lower: physic.ZeroCelsius,
tx: []i2ctest.IO{},
err: nil,
},
}
for _, tt := range tests {
bus := i2ctest.Playback{
Ops: tt.tx,
DontPanic: true,
}
mcp9808 := &Dev{
m: mmr.Dev8{
Conn: &i2c.Dev{Bus: &bus, Addr: 0x18},
Order: binary.BigEndian},
lower: tt.lower,
}
if err := mcp9808.setLowerAlert(tt.alert); err != tt.err {
t.Errorf("setLowerAlert(%s) expected %v but got %v", tt.name, tt.err, err)
}
}
}
func Test_alertBitsToTemperature(t *testing.T) {
tests := []struct {
name string
bits uint16
want physic.Temperature
}{
{"0°C", 0x0000, physic.ZeroCelsius},
{"0.25°C", 0x0004, physic.ZeroCelsius + 250*physic.MilliKelvin},
{"-0.25°C", 0x1004, physic.ZeroCelsius - 250*physic.MilliKelvin},
}
for _, tt := range tests {
if got := alertBitsToTemperature(tt.bits); got != tt.want {
t.Errorf("alertBitsToTemperature(%s) = %v, want %v", tt.name, got, tt.want)
}
}
}
func Test_temperatureToAlertBits(t *testing.T) {
succeeds := []struct {
name string
alert physic.Temperature
want uint16
}{
{"0°C", physic.ZeroCelsius, 0x0000},
{"0.25°C", physic.ZeroCelsius + 250*physic.MilliKelvin, 0x0004},
{"-0.25°C", physic.ZeroCelsius - 250*physic.MilliKelvin, 0x1004},
{"124.75°C", physic.ZeroCelsius + 124750*physic.MilliKelvin, 0x07cc},
{"-39.75°C", physic.ZeroCelsius - 39750*physic.MilliKelvin, 0x127c},
}
fails := []struct {
name string
alert physic.Temperature
want error
}{
{"126°C", physic.ZeroCelsius + 126*physic.Kelvin, errAlertOutOfRange},
{"-41°C", physic.ZeroCelsius - 41*physic.Kelvin, errAlertOutOfRange},
}
for _, tt := range succeeds {
got, err := alertTemperatureToBits(tt.alert)
if got != tt.want && err == nil {
t.Errorf("alertBitsToTemperature(%s) = %x, want %x", tt.name, got, tt.want)
}
if err != nil {
t.Errorf("alertBitsToTemperature(%s) got unexpected error: %v", tt.name, err)
}
}
for _, tt := range fails {
if _, err := alertTemperatureToBits(tt.alert); err == nil {
t.Errorf("alertBitsToTemperature(%s) expected error %v", tt.name, tt.want)
}
}
}

76
experimental/devices/mcp9808/mcp9808smoketest/mcp9808smoketest.go
Unescape Escape View File

@ -0,0 +1,76 @@
// Copyright 2018 The Periph Authors. All rights reserved.
// Use of this source code is governed under the Apache License, Version 2.0
// that can be found in the LICENSE file.
package mcp9808smoketest
import (
"errors"
"flag"
"fmt"
"periph.io/x/periph/conn/i2c/i2creg"
"periph.io/x/periph/experimental/devices/mcp9808"
"periph.io/x/periph/host"
)
// SmokeTest is imported by periph-smoketest.
type SmokeTest struct {
}
// Name implements the SmokeTest interface.
func (s *SmokeTest) Name() string {
return "mcp9808"
}
// Description implements the SmokeTest interface.
func (s *SmokeTest) Description() string {
return "Tests MCP9808 over I²C"
}
// Run implements the SmokeTest interface.
func (s *SmokeTest) Run(f *flag.FlagSet, args []string) (err error) {
i2cID := f.String("i2c", "", "I²C bus to use")
i2cAddr := f.Int("ia", 0x18, "I²C bus address use: 0x18 to 0x1f")
if err := f.Parse(args); err != nil {
return err
}
if f.NArg() != 0 {
f.Usage()
return errors.New("unrecognized arguments")
}
fmt.Println("Starting MCP9808 Temperature Sensor\nctrl+c to exit")
if _, err := host.Init(); err != nil {
return err
}
// Open default i2c bus.
bus, err := i2creg.Open(*i2cID)
if err != nil {
return err
}
defer func() {
if err2 := bus.Close(); err == nil {
err = err2
}
}()
// Create a new temperature sensor a with maximum resolution.
config := mcp9808.Opts{
Addr: *i2cAddr,
Res: mcp9808.Maximum,
}
sensor, err := mcp9808.New(bus, &config)
if err != nil {
return err
}
t, err := sensor.SenseTemp()
if err != nil {
return err
}
fmt.Println(t)
return nil
}
Write Preview
Loading…
Cancel
Save