From 4b3477e9eb281d249a70f683cb231c0aa7af71a2 Mon Sep 17 00:00:00 2001 From: JohnTrunix Date: Wed, 23 Aug 2023 15:14:19 +0200 Subject: [PATCH 01/23] feat(as7262): init driver for new device --- as7262/as7262.go | 132 +++++++++++++++++++++++++++++ as7262/as7262_test.go | 187 ++++++++++++++++++++++++++++++++++++++++++ as7262/registers.go | 70 ++++++++++++++++ 3 files changed, 389 insertions(+) create mode 100644 as7262/as7262.go create mode 100644 as7262/as7262_test.go create mode 100644 as7262/registers.go diff --git a/as7262/as7262.go b/as7262/as7262.go new file mode 100644 index 000000000..bc90e81c7 --- /dev/null +++ b/as7262/as7262.go @@ -0,0 +1,132 @@ +// Package as7262 provides a driver for the as7262 6-channel visible spectral_id device +// +// Datasheet: https://ams.com/documents/20143/36005/AS7262_DS000486_5-00.pdf + +package as7262 // import "tinygo.org/x/drivers/as7262" + +import ( + "math" + "time" + "tinygo.org/x/drivers" + "tinygo.org/x/drivers/internal/legacy" +) + +type Device struct { + bus drivers.I2C + buf []byte + Address uint8 +} + +// New returns AS7262 device for the provided I2C bus using default address of 0x49 (1001001) +func New(i2c drivers.I2C) *Device { + return &Device{ + bus: i2c, + buf: make([]byte, 4), + Address: DefaultAddress, + } +} + +// Configure soft resets device and returns +func (d *Device) Configure() (err error) { + controlRegValue := d.readByte(ControlReg) + controlRegValue |= 0x80 + + // soft reset device 0x04:7 + d.writeByte(ControlReg, controlRegValue) + time.Sleep(100 * time.Millisecond) + return +} + +// Connected returns if HardwareVersion (Device type == 01000000) +func (d *Device) Connected() bool { + data := []byte{0} + err := legacy.ReadRegister(d.bus, d.Address, HardwareVersionReg, data) + if err != nil { + return false + } + return data[0] == 0x40 +} + +/* + Communication Functions +*/ + +// readByte read byte from device register +func (d *Device) readByte(reg uint8) byte { + legacy.ReadRegister(d.bus, d.Address, reg, d.buf) + return d.buf[0] +} + +func (d *Device) readUint32(reg uint8) uint32 { + legacy.ReadRegister(d.bus, d.Address, reg, d.buf) + // shift bytes for uint32 from reg (start) + 3 more regs + return uint32(d.buf[0])<<24 | uint32(d.buf[1])<<16 | uint32(d.buf[2])<<8 | uint32(d.buf[3]) +} + +// writeByte write byte to device register +func (d *Device) writeByte(reg uint8, data byte) { + d.buf[0] = reg + d.buf[1] = data + d.bus.Tx(uint16(d.Address), d.buf, nil) +} + +/* + Data Caller Functions +*/ + +func (d *Device) getColors() [6]float32 { + v := d.getViolet() + b := d.getBlue() + g := d.getGreen() + y := d.getYellow() + o := d.getOrange() + r := d.getRed() + return [6]float32{v, b, g, y, o, r} +} + +// getRGB returns RGB Values +func (d *Device) getRGB() [3]float32 { + return [3]float32{d.getRed(), d.getGreen(), d.getBlue()} +} + +// getViolet returns Violet measurement +func (d *Device) getViolet() float32 { + value := d.readUint32(VCalReg) + return math.Float32frombits(value) +} + +// getBlue returns Blue measurement +func (d *Device) getBlue() float32 { + value := d.readUint32(BCalReg) + return math.Float32frombits(value) +} + +// getGreen returns Green measurement +func (d *Device) getGreen() float32 { + value := d.readUint32(GCalReg) + return math.Float32frombits(value) +} + +// getYellow returns Yellow measurement +func (d *Device) getYellow() float32 { + value := d.readUint32(YCalReg) + return math.Float32frombits(value) +} + +// getOrange returns Orange measurement +func (d *Device) getOrange() float32 { + value := d.readUint32(OCalReg) + return math.Float32frombits(value) +} + +// getRed returns Red measurement +func (d *Device) getRed() float32 { + value := d.readUint32(RCalReg) + return math.Float32frombits(value) +} + +// getTemp returns Temperature of Sensor in °C +func (d *Device) getTemp() int { + value := d.readByte(TempReg) + return int(value) +} diff --git a/as7262/as7262_test.go b/as7262/as7262_test.go new file mode 100644 index 000000000..fb24cabe1 --- /dev/null +++ b/as7262/as7262_test.go @@ -0,0 +1,187 @@ +package as7262 + +import ( + "testing" + + qt "github.com/frankban/quicktest" + "tinygo.org/x/drivers/tester" +) + +func TestDefaultI2CAddress(t *testing.T) { + c := qt.New(t) + bus := tester.NewI2CBus(c) + dev := New(bus) + c.Assert(dev.Address, qt.Equals, uint8(DefaultAddress)) +} + +func TestWhoAmI(t *testing.T) { + c := qt.New(t) + bus := tester.NewI2CBus(c) + fake := tester.NewI2CDevice(c, DefaultAddress) + copy(fake.Registers[:], defaultRegisters()) + bus.AddDevice(fake) + + dev := New(bus) + c.Assert(dev.Connected(), qt.Equals, true) + + fake.Registers[HardwareVersionReg] = 0xFF + c.Assert(dev.Connected(), qt.Equals, false) +} + +func TestGetViolet(t *testing.T) { + c := qt.New(t) + bus := tester.NewI2CBus(c) + fake := tester.NewI2CDevice(c, DefaultAddress) + copy(fake.Registers[:], defaultRegisters()) + bus.AddDevice(fake) + + dev := New(bus) + c.Assert(dev.getViolet(), qt.Equals, float32(0.15625)) + + fake.Registers[VCalReg+1] = byte(0b00111111) + c.Assert(dev.getViolet(), qt.Not(qt.Equals), float32(0.15625)) + +} + +func TestGetBlue(t *testing.T) { + c := qt.New(t) + bus := tester.NewI2CBus(c) + fake := tester.NewI2CDevice(c, DefaultAddress) + copy(fake.Registers[:], defaultRegisters()) + bus.AddDevice(fake) + + dev := New(bus) + c.Assert(dev.getBlue(), qt.Equals, float32(0.22222)) + + fake.Registers[BCalReg+1] = byte(0b00111111) + c.Assert(dev.getBlue(), qt.Not(qt.Equals), float32(0.22222)) + +} + +func TestGetGreen(t *testing.T) { + c := qt.New(t) + bus := tester.NewI2CBus(c) + fake := tester.NewI2CDevice(c, DefaultAddress) + copy(fake.Registers[:], defaultRegisters()) + bus.AddDevice(fake) + + dev := New(bus) + c.Assert(dev.getGreen(), qt.Equals, float32(1.45)) + + fake.Registers[GCalReg+1] = byte(0b00000001) + c.Assert(dev.getGreen(), qt.Not(qt.Equals), float32(1.45)) + +} + +func TestGetYellow(t *testing.T) { + c := qt.New(t) + bus := tester.NewI2CBus(c) + fake := tester.NewI2CDevice(c, DefaultAddress) + copy(fake.Registers[:], defaultRegisters()) + bus.AddDevice(fake) + + dev := New(bus) + c.Assert(dev.getYellow(), qt.Equals, float32(0.00002)) + + fake.Registers[YCalReg+1] = byte(0b00000001) + c.Assert(dev.getYellow(), qt.Not(qt.Equals), float32(0.00002)) + +} + +func TestGetOrange(t *testing.T) { + c := qt.New(t) + bus := tester.NewI2CBus(c) + fake := tester.NewI2CDevice(c, DefaultAddress) + copy(fake.Registers[:], defaultRegisters()) + bus.AddDevice(fake) + + dev := New(bus) + c.Assert(dev.getOrange(), qt.Equals, float32(0.15625)) + + fake.Registers[OCalReg+1] = byte(0b00000001) + c.Assert(dev.getOrange(), qt.Not(qt.Equals), float32(0.15625)) + +} + +func TestGetRed(t *testing.T) { + c := qt.New(t) + bus := tester.NewI2CBus(c) + fake := tester.NewI2CDevice(c, DefaultAddress) + copy(fake.Registers[:], defaultRegisters()) + bus.AddDevice(fake) + + dev := New(bus) + c.Assert(dev.getRed(), qt.Equals, float32(0.15625)) + + fake.Registers[RCalReg+1] = byte(0b00000001) + c.Assert(dev.getRed(), qt.Not(qt.Equals), float32(0.15625)) + +} + +func TestGetRGB(t *testing.T) { + c := qt.New(t) + bus := tester.NewI2CBus(c) + fake := tester.NewI2CDevice(c, DefaultAddress) + copy(fake.Registers[:], defaultRegisters()) + bus.AddDevice(fake) + + dev := New(bus) + c.Assert(dev.getRGB(), qt.Equals, [3]float32{0.15625, 1.45, 0.22222}) +} + +func TestGetColors(t *testing.T) { + c := qt.New(t) + bus := tester.NewI2CBus(c) + fake := tester.NewI2CDevice(c, DefaultAddress) + copy(fake.Registers[:], defaultRegisters()) + bus.AddDevice(fake) + + dev := New(bus) + c.Assert(dev.getColors(), qt.Equals, [6]float32{0.15625, 0.22222, 1.45, 0.00002, 0.15625, 0.15625}) +} + +func TestGetTemp(t *testing.T) { + c := qt.New(t) + bus := tester.NewI2CBus(c) + fake := tester.NewI2CDevice(c, DefaultAddress) + copy(fake.Registers[:], defaultRegisters()) + bus.AddDevice(fake) + + dev := New(bus) + c.Assert(dev.getTemp(), qt.Equals, int(25)) + + fake.Registers[TempReg] = byte(0b01010011) + c.Assert(dev.getTemp(), qt.Equals, int(83)) + +} + +func defaultRegisters() []uint8 { + return []uint8{ + HardwareVersionReg: 0x40, // = 01000000 + TempReg: byte(0b00011001), // = 25 + VCalReg: byte(0b00111110), + VCalReg + 0x01: byte(0b00100000), + VCalReg + 0x02: byte(0b00000000), + VCalReg + 0x03: byte(0b00000000), // = 0.15625 + BCalReg: byte(0b00111110), + BCalReg + 0x01: byte(0b01100011), + BCalReg + 0x02: byte(0b10001101), + BCalReg + 0x03: byte(0b10100100), // = 0.22222 + GCalReg: byte(0b00111111), + GCalReg + 0x01: byte(0b10111001), + GCalReg + 0x02: byte(0b10011001), + GCalReg + 0x03: byte(0b10011010), // = 1.45 + YCalReg: byte(0b00110111), + YCalReg + 0x01: byte(0b10100111), + YCalReg + 0x02: byte(0b11000101), + YCalReg + 0x03: byte(0b10101100), // = 0.00002 + OCalReg: byte(0b00111110), + OCalReg + 0x01: byte(0b00100000), + OCalReg + 0x02: byte(0b00000000), + OCalReg + 0x03: byte(0b00000000), // = 0.15625 + RCalReg: byte(0b00111110), + RCalReg + 0x01: byte(0b00100000), + RCalReg + 0x02: byte(0b00000000), + RCalReg + 0x03: byte(0b00000000), // = 0.15625 + } +} diff --git a/as7262/registers.go b/as7262/registers.go new file mode 100644 index 000000000..3c9c2dda9 --- /dev/null +++ b/as7262/registers.go @@ -0,0 +1,70 @@ +package as7262 + +const ( + // DefaultAddress Address is default I2C address of AS7262 + DefaultAddress = 0x49 + + /* + Version Registers + */ + // HardwareVersionReg Hardware Version Register (0x00:0x01) + HardwareVersionReg = 0x00 // device type number 0x00, hardware version 0x01 + // FirmwareVersionReg Firmware Version Register (0x02:0x03) + FirmwareVersionReg = 0x02 // + + /* + Control Registers + */ + // ControlReg Control Register + ControlReg = 0x04 + // IntegrationReg Integration Time Register + IntegrationReg = 0x05 + // TempReg Temperature Register + TempReg = 0x06 + // LedReg Control LED Register + LedReg = 0x7 + + /* + Sensor Raw Data Registers + */ + // VHighRawReg Channel V High Data Byte + VHighRawReg = 0x08 + // VLowRawReg Channel V Low Data Byte + VLowRawReg = 0x09 + // BHighRawReg Channel B High Data Byte + BHighRawReg = 0x0A + // BLowRawReg Channel B Low Data Byte + BLowRawReg = 0x0B + // GHighRawReg Channel G High Data Byte + GHighRawReg = 0x0C + // GLowRawReg Channel G Low Data Byte + GLowRawReg = 0x0D + // YHighRawReg Channel Y High Data Byte + YHighRawReg = 0x0E + // YLowRawReg Channel Y Low Data Byte + YLowRawReg = 0x0F + // OHighRawReg Channel O High Data Byte + OHighRawReg = 0x10 + // OLowRawReg Channel O Low Data Byte + OLowRawReg = 0x11 + // RHighRawReg Channel R High Data Byte + RHighRawReg = 0x12 + // RLowRawReg Channel R Low Data Byte + RLowRawReg = 0x13 + + /* + Sensor Calibrated Data Registers + */ + // VCalReg address for Channel V Calibrated Data + VCalReg = 0x14 + // BCalReg address for Channel B Calibrated Data + BCalReg = 0x18 + // GCalReg address for Channel G Calibrated Data + GCalReg = 0x1C + // YCalReg address for Channel Y Calibrated Data + YCalReg = 0x20 + // OCalReg address for Channel O Calibrated Data + OCalReg = 0x24 + // RCalReg address for Channel R Calibrated Data + RCalReg = 0x28 +) From f54b4880385ca1f75f3748b8bad5ac07e5528f67 Mon Sep 17 00:00:00 2001 From: JohnTrunix Date: Fri, 25 Aug 2023 09:06:36 +0200 Subject: [PATCH 02/23] fix(as7262): export read functions --- as7262/as7262.go | 50 ++++++++++++++++++++++++------------------------ 1 file changed, 25 insertions(+), 25 deletions(-) diff --git a/as7262/as7262.go b/as7262/as7262.go index bc90e81c7..9dce66510 100644 --- a/as7262/as7262.go +++ b/as7262/as7262.go @@ -71,62 +71,62 @@ func (d *Device) writeByte(reg uint8, data byte) { } /* - Data Caller Functions + Data Reader Functions */ -func (d *Device) getColors() [6]float32 { - v := d.getViolet() - b := d.getBlue() - g := d.getGreen() - y := d.getYellow() - o := d.getOrange() - r := d.getRed() +func (d *Device) ReadColors() [6]float32 { + v := d.ReadViolet() + b := d.ReadBlue() + g := d.ReadGreen() + y := d.ReadYellow() + o := d.ReadOrange() + r := d.ReadRed() return [6]float32{v, b, g, y, o, r} } -// getRGB returns RGB Values -func (d *Device) getRGB() [3]float32 { - return [3]float32{d.getRed(), d.getGreen(), d.getBlue()} +// ReadRGB returns RGB Values +func (d *Device) ReadRGB() [3]float32 { + return [3]float32{d.ReadRed(), d.ReadGreen(), d.ReadBlue()} } -// getViolet returns Violet measurement -func (d *Device) getViolet() float32 { +// ReadViolet returns Violet measurement +func (d *Device) ReadViolet() float32 { value := d.readUint32(VCalReg) return math.Float32frombits(value) } -// getBlue returns Blue measurement -func (d *Device) getBlue() float32 { +// ReadBlue returns Blue measurement +func (d *Device) ReadBlue() float32 { value := d.readUint32(BCalReg) return math.Float32frombits(value) } -// getGreen returns Green measurement -func (d *Device) getGreen() float32 { +// ReadGreen returns Green measurement +func (d *Device) ReadGreen() float32 { value := d.readUint32(GCalReg) return math.Float32frombits(value) } -// getYellow returns Yellow measurement -func (d *Device) getYellow() float32 { +// ReadYellow returns Yellow measurement +func (d *Device) ReadYellow() float32 { value := d.readUint32(YCalReg) return math.Float32frombits(value) } -// getOrange returns Orange measurement -func (d *Device) getOrange() float32 { +// ReadOrange returns Orange measurement +func (d *Device) ReadOrange() float32 { value := d.readUint32(OCalReg) return math.Float32frombits(value) } -// getRed returns Red measurement -func (d *Device) getRed() float32 { +// ReadRed returns Red measurement +func (d *Device) ReadRed() float32 { value := d.readUint32(RCalReg) return math.Float32frombits(value) } -// getTemp returns Temperature of Sensor in °C -func (d *Device) getTemp() int { +// ReadTemp returns Temperature of Sensor in °C +func (d *Device) ReadTemp() int { value := d.readByte(TempReg) return int(value) } From 85b6d2a77f1f618f265f532023aa36369f21f23f Mon Sep 17 00:00:00 2001 From: JohnTrunix Date: Fri, 25 Aug 2023 09:07:27 +0200 Subject: [PATCH 03/23] test(as7262): rename test functions & function calls --- as7262/as7262_test.go | 50 +++++++++++++++++++++---------------------- 1 file changed, 25 insertions(+), 25 deletions(-) diff --git a/as7262/as7262_test.go b/as7262/as7262_test.go index fb24cabe1..9fd0da0ba 100644 --- a/as7262/as7262_test.go +++ b/as7262/as7262_test.go @@ -28,7 +28,7 @@ func TestWhoAmI(t *testing.T) { c.Assert(dev.Connected(), qt.Equals, false) } -func TestGetViolet(t *testing.T) { +func TestReadViolet(t *testing.T) { c := qt.New(t) bus := tester.NewI2CBus(c) fake := tester.NewI2CDevice(c, DefaultAddress) @@ -36,14 +36,14 @@ func TestGetViolet(t *testing.T) { bus.AddDevice(fake) dev := New(bus) - c.Assert(dev.getViolet(), qt.Equals, float32(0.15625)) + c.Assert(dev.ReadViolet(), qt.Equals, float32(0.15625)) fake.Registers[VCalReg+1] = byte(0b00111111) - c.Assert(dev.getViolet(), qt.Not(qt.Equals), float32(0.15625)) + c.Assert(dev.ReadViolet(), qt.Not(qt.Equals), float32(0.15625)) } -func TestGetBlue(t *testing.T) { +func TestReadBlue(t *testing.T) { c := qt.New(t) bus := tester.NewI2CBus(c) fake := tester.NewI2CDevice(c, DefaultAddress) @@ -51,14 +51,14 @@ func TestGetBlue(t *testing.T) { bus.AddDevice(fake) dev := New(bus) - c.Assert(dev.getBlue(), qt.Equals, float32(0.22222)) + c.Assert(dev.ReadBlue(), qt.Equals, float32(0.22222)) fake.Registers[BCalReg+1] = byte(0b00111111) - c.Assert(dev.getBlue(), qt.Not(qt.Equals), float32(0.22222)) + c.Assert(dev.ReadBlue(), qt.Not(qt.Equals), float32(0.22222)) } -func TestGetGreen(t *testing.T) { +func TestReadGreen(t *testing.T) { c := qt.New(t) bus := tester.NewI2CBus(c) fake := tester.NewI2CDevice(c, DefaultAddress) @@ -66,14 +66,14 @@ func TestGetGreen(t *testing.T) { bus.AddDevice(fake) dev := New(bus) - c.Assert(dev.getGreen(), qt.Equals, float32(1.45)) + c.Assert(dev.ReadGreen(), qt.Equals, float32(1.45)) fake.Registers[GCalReg+1] = byte(0b00000001) - c.Assert(dev.getGreen(), qt.Not(qt.Equals), float32(1.45)) + c.Assert(dev.ReadGreen(), qt.Not(qt.Equals), float32(1.45)) } -func TestGetYellow(t *testing.T) { +func TestReadYellow(t *testing.T) { c := qt.New(t) bus := tester.NewI2CBus(c) fake := tester.NewI2CDevice(c, DefaultAddress) @@ -81,14 +81,14 @@ func TestGetYellow(t *testing.T) { bus.AddDevice(fake) dev := New(bus) - c.Assert(dev.getYellow(), qt.Equals, float32(0.00002)) + c.Assert(dev.ReadYellow(), qt.Equals, float32(0.00002)) fake.Registers[YCalReg+1] = byte(0b00000001) - c.Assert(dev.getYellow(), qt.Not(qt.Equals), float32(0.00002)) + c.Assert(dev.ReadYellow(), qt.Not(qt.Equals), float32(0.00002)) } -func TestGetOrange(t *testing.T) { +func TestReadOrange(t *testing.T) { c := qt.New(t) bus := tester.NewI2CBus(c) fake := tester.NewI2CDevice(c, DefaultAddress) @@ -96,14 +96,14 @@ func TestGetOrange(t *testing.T) { bus.AddDevice(fake) dev := New(bus) - c.Assert(dev.getOrange(), qt.Equals, float32(0.15625)) + c.Assert(dev.ReadOrange(), qt.Equals, float32(0.15625)) fake.Registers[OCalReg+1] = byte(0b00000001) - c.Assert(dev.getOrange(), qt.Not(qt.Equals), float32(0.15625)) + c.Assert(dev.ReadOrange(), qt.Not(qt.Equals), float32(0.15625)) } -func TestGetRed(t *testing.T) { +func TestReadRed(t *testing.T) { c := qt.New(t) bus := tester.NewI2CBus(c) fake := tester.NewI2CDevice(c, DefaultAddress) @@ -111,14 +111,14 @@ func TestGetRed(t *testing.T) { bus.AddDevice(fake) dev := New(bus) - c.Assert(dev.getRed(), qt.Equals, float32(0.15625)) + c.Assert(dev.ReadRed(), qt.Equals, float32(0.15625)) fake.Registers[RCalReg+1] = byte(0b00000001) - c.Assert(dev.getRed(), qt.Not(qt.Equals), float32(0.15625)) + c.Assert(dev.ReadRed(), qt.Not(qt.Equals), float32(0.15625)) } -func TestGetRGB(t *testing.T) { +func TestReadRGB(t *testing.T) { c := qt.New(t) bus := tester.NewI2CBus(c) fake := tester.NewI2CDevice(c, DefaultAddress) @@ -126,10 +126,10 @@ func TestGetRGB(t *testing.T) { bus.AddDevice(fake) dev := New(bus) - c.Assert(dev.getRGB(), qt.Equals, [3]float32{0.15625, 1.45, 0.22222}) + c.Assert(dev.ReadRGB(), qt.Equals, [3]float32{0.15625, 1.45, 0.22222}) } -func TestGetColors(t *testing.T) { +func TestReadColors(t *testing.T) { c := qt.New(t) bus := tester.NewI2CBus(c) fake := tester.NewI2CDevice(c, DefaultAddress) @@ -137,10 +137,10 @@ func TestGetColors(t *testing.T) { bus.AddDevice(fake) dev := New(bus) - c.Assert(dev.getColors(), qt.Equals, [6]float32{0.15625, 0.22222, 1.45, 0.00002, 0.15625, 0.15625}) + c.Assert(dev.ReadColors(), qt.Equals, [6]float32{0.15625, 0.22222, 1.45, 0.00002, 0.15625, 0.15625}) } -func TestGetTemp(t *testing.T) { +func TestReadTemp(t *testing.T) { c := qt.New(t) bus := tester.NewI2CBus(c) fake := tester.NewI2CDevice(c, DefaultAddress) @@ -148,10 +148,10 @@ func TestGetTemp(t *testing.T) { bus.AddDevice(fake) dev := New(bus) - c.Assert(dev.getTemp(), qt.Equals, int(25)) + c.Assert(dev.ReadTemp(), qt.Equals, int(25)) fake.Registers[TempReg] = byte(0b01010011) - c.Assert(dev.getTemp(), qt.Equals, int(83)) + c.Assert(dev.ReadTemp(), qt.Equals, int(83)) } From 519222318e0b905746e9db3bd7925d79e701f56f Mon Sep 17 00:00:00 2001 From: JohnTrunix Date: Sat, 26 Aug 2023 12:28:36 +0200 Subject: [PATCH 04/23] test(as7262): add example for as7262 --- examples/as7262/main.go | 35 +++++++++++++++++++++++++++++++++++ 1 file changed, 35 insertions(+) create mode 100644 examples/as7262/main.go diff --git a/examples/as7262/main.go b/examples/as7262/main.go new file mode 100644 index 000000000..c8ecbebc9 --- /dev/null +++ b/examples/as7262/main.go @@ -0,0 +1,35 @@ +package main + +import ( + "fmt" + "machine" + "time" + "tinygo.org/x/drivers/as7262" +) + +var ( + i2c = machine.I2CO + sensor = as7262.New(i2c) +) + +func main() { + + i2c.Configure(machine.I2CConfig{Frequency: machine.TWI_FREQ_100KHZ}) + sensor.Configure() + + if sensor.Connected() { + for { + // read sensor colors (will read all 6 colors) + colors := sensor.ReadColors() + fmt.Printf("Colors: %v", colors) + time.Sleep(time.Second) + + // read sensor temperature + temp := sensor.ReadTemp() + fmt.Printf("Temperature: %d", temp) + time.Sleep(time.Second) + } + } else { + panic("as7262 not connected to I2C") + } +} From 1df68f7dc3f1e5597405788d0ed2260c53ffee68 Mon Sep 17 00:00:00 2001 From: JohnTrunix Date: Sat, 26 Aug 2023 12:29:26 +0200 Subject: [PATCH 05/23] test(as7262): add as7262 to smoketest --- smoketest.sh | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/smoketest.sh b/smoketest.sh index 9b3ff4950..705d72d23 100755 --- a/smoketest.sh +++ b/smoketest.sh @@ -131,4 +131,5 @@ tinygo build -size short -o ./build/test.uf2 -target=pico ./examples/mpu6886/mai tinygo build -size short -o ./build/test.hex -target=arduino-nano33 ./examples/ttp229/main.go tinygo build -size short -o ./build/test.hex -target=pico ./examples/ndir/main_ndir.go tinygo build -size short -o ./build/test.hex -target=microbit ./examples/ndir/main_ndir.go -tinygo build -size short -o ./build/test.hex -target=arduino-nano33 ./examples/ndir/main_ndir.go \ No newline at end of file +tinygo build -size short -o ./build/test.hex -target=arduino-nano33 ./examples/ndir/main_ndir.go +tinygo build -size short -o ./build/test.hex -target=arduino ./examples/as7262/main.go \ No newline at end of file From e37293c9d75230e807e9579bac010fd288287ff2 Mon Sep 17 00:00:00 2001 From: JohnTrunix Date: Sat, 26 Aug 2023 12:47:46 +0200 Subject: [PATCH 06/23] test(as7262): fix typo in i2c init --- examples/as7262/main.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/examples/as7262/main.go b/examples/as7262/main.go index c8ecbebc9..9db18d1f0 100644 --- a/examples/as7262/main.go +++ b/examples/as7262/main.go @@ -8,7 +8,7 @@ import ( ) var ( - i2c = machine.I2CO + i2c = machine.I2C0 sensor = as7262.New(i2c) ) From d18a337558be31644f36dc16b5543eb1a38874fb Mon Sep 17 00:00:00 2001 From: JohnTrunix Date: Sun, 27 Aug 2023 12:56:42 +0200 Subject: [PATCH 07/23] perf(as7262): remove fmt library from example for arduino uno compatibility --- examples/as7262/main.go | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/examples/as7262/main.go b/examples/as7262/main.go index 9db18d1f0..f623b750c 100644 --- a/examples/as7262/main.go +++ b/examples/as7262/main.go @@ -1,7 +1,6 @@ package main import ( - "fmt" "machine" "time" "tinygo.org/x/drivers/as7262" @@ -13,20 +12,21 @@ var ( ) func main() { - i2c.Configure(machine.I2CConfig{Frequency: machine.TWI_FREQ_100KHZ}) sensor.Configure() if sensor.Connected() { + colorNames := [6]string{"Violet", "Blue", "Green", "Yellow", "Orange", "Red"} for { // read sensor colors (will read all 6 colors) colors := sensor.ReadColors() - fmt.Printf("Colors: %v", colors) - time.Sleep(time.Second) + for i, c := range colors { + println(colorNames[i], ": ", c) + } // read sensor temperature temp := sensor.ReadTemp() - fmt.Printf("Temperature: %d", temp) + println("Temperature: ", temp) time.Sleep(time.Second) } } else { From 608b0df0441558667425ed39364cbf5b44ac0122 Mon Sep 17 00:00:00 2001 From: JohnTrunix Date: Wed, 20 Sep 2023 21:27:22 +0200 Subject: [PATCH 08/23] fix(as7262): rm error code & create virtual registers --- as7262/as7262.go | 173 ++++++++++++++++++------------------- as7262/registers.go | 30 +++---- as7262/vControlRegister.go | 70 +++++++++++++++ 3 files changed, 166 insertions(+), 107 deletions(-) create mode 100644 as7262/vControlRegister.go diff --git a/as7262/as7262.go b/as7262/as7262.go index 9dce66510..f7259e19c 100644 --- a/as7262/as7262.go +++ b/as7262/as7262.go @@ -1,132 +1,125 @@ -// Package as7262 provides a driver for the as7262 6-channel visible spectral_id device -// -// Datasheet: https://ams.com/documents/20143/36005/AS7262_DS000486_5-00.pdf - -package as7262 // import "tinygo.org/x/drivers/as7262" +package as7262 import ( - "math" "time" "tinygo.org/x/drivers" - "tinygo.org/x/drivers/internal/legacy" ) +type Error uint8 + +const ( + ErrInvalidID Error = 0x1 + TxValid byte = 0x02 + RxValid byte = 0x01 +) + +func (e Error) Error() string { + switch e { + case ErrInvalidID: + return "Invalid chip ID" + default: + return "Unknown error" + } +} + type Device struct { bus drivers.I2C buf []byte Address uint8 } -// New returns AS7262 device for the provided I2C bus using default address of 0x49 (1001001) func New(i2c drivers.I2C) *Device { return &Device{ bus: i2c, - buf: make([]byte, 4), + buf: []byte{0}, Address: DefaultAddress, } } -// Configure soft resets device and returns -func (d *Device) Configure() (err error) { - controlRegValue := d.readByte(ControlReg) - controlRegValue |= 0x80 - - // soft reset device 0x04:7 - d.writeByte(ControlReg, controlRegValue) - time.Sleep(100 * time.Millisecond) - return -} - -// Connected returns if HardwareVersion (Device type == 01000000) -func (d *Device) Connected() bool { - data := []byte{0} - err := legacy.ReadRegister(d.bus, d.Address, HardwareVersionReg, data) - if err != nil { - return false - } - return data[0] == 0x40 -} - /* - Communication Functions + Internal Functions */ -// readByte read byte from device register -func (d *Device) readByte(reg uint8) byte { - legacy.ReadRegister(d.bus, d.Address, reg, d.buf) +// deviceStatus returns StatusReg of as7262 +func (d *Device) deviceStatus() byte { + d.buf[0] = 0 + d.bus.ReadRegister(DefaultAddress, StatusReg, d.buf) return d.buf[0] } -func (d *Device) readUint32(reg uint8) uint32 { - legacy.ReadRegister(d.bus, d.Address, reg, d.buf) - // shift bytes for uint32 from reg (start) + 3 more regs - return uint32(d.buf[0])<<24 | uint32(d.buf[1])<<16 | uint32(d.buf[2])<<8 | uint32(d.buf[3]) +// writeReady returns true if as7262 is ready to write write-register +func (d *Device) writeReady() bool { + return d.deviceStatus()&TxValid == 0 } -// writeByte write byte to device register -func (d *Device) writeByte(reg uint8, data byte) { - d.buf[0] = reg - d.buf[1] = data - d.bus.Tx(uint16(d.Address), d.buf, nil) +// readReady return true if as7262 is ready to read read-register +func (d *Device) readReady() bool { + return d.deviceStatus()&RxValid != 0 } -/* - Data Reader Functions -*/ +func (d *Device) readByte(reg byte) byte { + for { + if d.writeReady() { + break + } + } -func (d *Device) ReadColors() [6]float32 { - v := d.ReadViolet() - b := d.ReadBlue() - g := d.ReadGreen() - y := d.ReadYellow() - o := d.ReadOrange() - r := d.ReadRed() - return [6]float32{v, b, g, y, o, r} -} + d.bus.WriteRegister(d.Address, WriteReg, []byte{reg}) -// ReadRGB returns RGB Values -func (d *Device) ReadRGB() [3]float32 { - return [3]float32{d.ReadRed(), d.ReadGreen(), d.ReadBlue()} -} + for { + if d.readReady() { + break + } + } -// ReadViolet returns Violet measurement -func (d *Device) ReadViolet() float32 { - value := d.readUint32(VCalReg) - return math.Float32frombits(value) + d.bus.ReadRegister(d.Address, ReadReg, d.buf) + return d.buf[0] } -// ReadBlue returns Blue measurement -func (d *Device) ReadBlue() float32 { - value := d.readUint32(BCalReg) - return math.Float32frombits(value) -} +func (d *Device) writeByte(reg byte, value byte) { + for { + if d.writeReady() { + break + } + } -// ReadGreen returns Green measurement -func (d *Device) ReadGreen() float32 { - value := d.readUint32(GCalReg) - return math.Float32frombits(value) -} + d.bus.WriteRegister(d.Address, WriteReg, []byte{reg | 0x80}) -// ReadYellow returns Yellow measurement -func (d *Device) ReadYellow() float32 { - value := d.readUint32(YCalReg) - return math.Float32frombits(value) -} + for { + if d.writeReady() { + break + } + } -// ReadOrange returns Orange measurement -func (d *Device) ReadOrange() float32 { - value := d.readUint32(OCalReg) - return math.Float32frombits(value) + d.buf[0] = value + d.bus.WriteRegister(d.Address, WriteReg, d.buf) } -// ReadRed returns Red measurement -func (d *Device) ReadRed() float32 { - value := d.readUint32(RCalReg) - return math.Float32frombits(value) +// Configure as7262 behaviour +func (d *Device) Configure(reset bool, gain float32, integrationTime float32, mode int) { + cr := newVControlReg() + cr.setReset(reset) + cr.setGain(gain) + cr.setMode(mode) + crEncoded := cr.encode() + + // write ControlReg and read full ControlReg + d.writeByte(ControlReg, crEncoded) + time.Sleep(time.Second * 2) + d.readByte(ControlReg) + cr.decode(d.buf[0]) + + // set integrationTime: float32 as ms + t := byte(int(integrationTime*2.8) & 0xff) + d.writeByte(IntegrationTimeReg, t) } -// ReadTemp returns Temperature of Sensor in °C -func (d *Device) ReadTemp() int { - value := d.readByte(TempReg) - return int(value) +func (d *Device) Led(status bool) { + var led byte + if status { + led = 0b00000111 + } else { + led = 0b00000110 + } + d.writeByte(LedRegister, led) } diff --git a/as7262/registers.go b/as7262/registers.go index 3c9c2dda9..0719b8f93 100644 --- a/as7262/registers.go +++ b/as7262/registers.go @@ -4,25 +4,21 @@ const ( // DefaultAddress Address is default I2C address of AS7262 DefaultAddress = 0x49 - /* - Version Registers - */ - // HardwareVersionReg Hardware Version Register (0x00:0x01) - HardwareVersionReg = 0x00 // device type number 0x00, hardware version 0x01 - // FirmwareVersionReg Firmware Version Register (0x02:0x03) - FirmwareVersionReg = 0x02 // + // StatusReg + StatusReg = 0x00 + // WriteReg + WriteReg = 0x01 + // ReadReg + ReadReg = 0x02 - /* - Control Registers - */ - // ControlReg Control Register + // ControlReg ControlReg = 0x04 - // IntegrationReg Integration Time Register - IntegrationReg = 0x05 - // TempReg Temperature Register - TempReg = 0x06 - // LedReg Control LED Register - LedReg = 0x7 + // IntegrationTimeReg + IntegrationTimeReg = 0x05 + // TempRegister + TempRegister = 0x06 + // LedRegister + LedRegister = 0x07 /* Sensor Raw Data Registers diff --git a/as7262/vControlRegister.go b/as7262/vControlRegister.go new file mode 100644 index 000000000..d5f56ba32 --- /dev/null +++ b/as7262/vControlRegister.go @@ -0,0 +1,70 @@ +package as7262 + +type vControlReg struct { + reset byte + interrupt byte + gain byte + bank byte + dataReady byte +} + +func newVControlReg() *vControlReg { + return &vControlReg{ + reset: 0b10000000, + interrupt: 0b01000000, + gain: 0b00110000, + bank: 0b00001100, // measurement mode + dataReady: 0b00000010, + } +} + +func (r *vControlReg) encode() byte { + return r.reset | r.interrupt | r.gain | r.bank | r.dataReady +} + +func (r *vControlReg) decode(encoded byte) { + r.reset = encoded & 0b10000000 + r.interrupt = encoded & 0b01000000 + r.gain = encoded & 0b00110000 + r.bank = encoded & 0b00001100 + r.dataReady = encoded & 0b00000010 +} + +func (r *vControlReg) setReset(reset bool) { + if reset { + r.reset |= 0b10000000 + } else { + r.reset &= 0b01111111 + } +} + +// setGain sets bit 4:5 of VControlReg for gain +func (r *vControlReg) setGain(gain float32) { + // set gain (defaults to 64) + // values: 1, 3.7, 16, 64 + var g byte + switch gain { + case 1: + g = 0b00 + case 3.7: + g = 0b01 + case 16: + g = 0b10 + default: + g = 0b11 + } + + // bitwise clear operation & setting bit 4:5 + r.gain &= 0b11001111 + r.gain |= g << 4 +} + +// setMode sets bit 2:3 of VControlReg for mode +func (r *vControlReg) setMode(mode int) { + // set mode: 0, 1, 2, 3 + m := byte(mode) + + // bitwise clear operation & setting bit 4:5 + r.bank &= 0b11110011 + r.bank |= m << 2 +} From 55ea0ea541962092e7ed98fc2e252724b03eef6b Mon Sep 17 00:00:00 2001 From: JohnTrunix Date: Wed, 20 Sep 2023 21:27:48 +0200 Subject: [PATCH 09/23] fix(as7262): temp fix example code --- examples/as7262/main.go | 26 ++++++++------------------ 1 file changed, 8 insertions(+), 18 deletions(-) diff --git a/examples/as7262/main.go b/examples/as7262/main.go index f623b750c..8cc93cca7 100644 --- a/examples/as7262/main.go +++ b/examples/as7262/main.go @@ -12,24 +12,14 @@ var ( ) func main() { - i2c.Configure(machine.I2CConfig{Frequency: machine.TWI_FREQ_100KHZ}) - sensor.Configure() + i2c.Configure(machine.I2CConfig{Frequency: machine.KHz * 100}) + sensor.Configure(true, 64, 17.857, 2) - if sensor.Connected() { - colorNames := [6]string{"Violet", "Blue", "Green", "Yellow", "Orange", "Red"} - for { - // read sensor colors (will read all 6 colors) - colors := sensor.ReadColors() - for i, c := range colors { - println(colorNames[i], ": ", c) - } - - // read sensor temperature - temp := sensor.ReadTemp() - println("Temperature: ", temp) - time.Sleep(time.Second) - } - } else { - panic("as7262 not connected to I2C") + println("Starting ...") + for { + sensor.Led(true) + time.Sleep(time.Millisecond * 800) + sensor.Led(false) + time.Sleep(time.Millisecond * 800) } } From f7a38f63039b0c5c43d41b3597370205bd713b26 Mon Sep 17 00:00:00 2001 From: JohnTrunix Date: Wed, 20 Sep 2023 21:32:34 +0200 Subject: [PATCH 10/23] test(as7262): rm test --- as7262/as7262_test.go | 187 ------------------------------------------ 1 file changed, 187 deletions(-) delete mode 100644 as7262/as7262_test.go diff --git a/as7262/as7262_test.go b/as7262/as7262_test.go deleted file mode 100644 index 9fd0da0ba..000000000 --- a/as7262/as7262_test.go +++ /dev/null @@ -1,187 +0,0 @@ -package as7262 - -import ( - "testing" - - qt "github.com/frankban/quicktest" - "tinygo.org/x/drivers/tester" -) - -func TestDefaultI2CAddress(t *testing.T) { - c := qt.New(t) - bus := tester.NewI2CBus(c) - dev := New(bus) - c.Assert(dev.Address, qt.Equals, uint8(DefaultAddress)) -} - -func TestWhoAmI(t *testing.T) { - c := qt.New(t) - bus := tester.NewI2CBus(c) - fake := tester.NewI2CDevice(c, DefaultAddress) - copy(fake.Registers[:], defaultRegisters()) - bus.AddDevice(fake) - - dev := New(bus) - c.Assert(dev.Connected(), qt.Equals, true) - - fake.Registers[HardwareVersionReg] = 0xFF - c.Assert(dev.Connected(), qt.Equals, false) -} - -func TestReadViolet(t *testing.T) { - c := qt.New(t) - bus := tester.NewI2CBus(c) - fake := tester.NewI2CDevice(c, DefaultAddress) - copy(fake.Registers[:], defaultRegisters()) - bus.AddDevice(fake) - - dev := New(bus) - c.Assert(dev.ReadViolet(), qt.Equals, float32(0.15625)) - - fake.Registers[VCalReg+1] = byte(0b00111111) - c.Assert(dev.ReadViolet(), qt.Not(qt.Equals), float32(0.15625)) - -} - -func TestReadBlue(t *testing.T) { - c := qt.New(t) - bus := tester.NewI2CBus(c) - fake := tester.NewI2CDevice(c, DefaultAddress) - copy(fake.Registers[:], defaultRegisters()) - bus.AddDevice(fake) - - dev := New(bus) - c.Assert(dev.ReadBlue(), qt.Equals, float32(0.22222)) - - fake.Registers[BCalReg+1] = byte(0b00111111) - c.Assert(dev.ReadBlue(), qt.Not(qt.Equals), float32(0.22222)) - -} - -func TestReadGreen(t *testing.T) { - c := qt.New(t) - bus := tester.NewI2CBus(c) - fake := tester.NewI2CDevice(c, DefaultAddress) - copy(fake.Registers[:], defaultRegisters()) - bus.AddDevice(fake) - - dev := New(bus) - c.Assert(dev.ReadGreen(), qt.Equals, float32(1.45)) - - fake.Registers[GCalReg+1] = byte(0b00000001) - c.Assert(dev.ReadGreen(), qt.Not(qt.Equals), float32(1.45)) - -} - -func TestReadYellow(t *testing.T) { - c := qt.New(t) - bus := tester.NewI2CBus(c) - fake := tester.NewI2CDevice(c, DefaultAddress) - copy(fake.Registers[:], defaultRegisters()) - bus.AddDevice(fake) - - dev := New(bus) - c.Assert(dev.ReadYellow(), qt.Equals, float32(0.00002)) - - fake.Registers[YCalReg+1] = byte(0b00000001) - c.Assert(dev.ReadYellow(), qt.Not(qt.Equals), float32(0.00002)) - -} - -func TestReadOrange(t *testing.T) { - c := qt.New(t) - bus := tester.NewI2CBus(c) - fake := tester.NewI2CDevice(c, DefaultAddress) - copy(fake.Registers[:], defaultRegisters()) - bus.AddDevice(fake) - - dev := New(bus) - c.Assert(dev.ReadOrange(), qt.Equals, float32(0.15625)) - - fake.Registers[OCalReg+1] = byte(0b00000001) - c.Assert(dev.ReadOrange(), qt.Not(qt.Equals), float32(0.15625)) - -} - -func TestReadRed(t *testing.T) { - c := qt.New(t) - bus := tester.NewI2CBus(c) - fake := tester.NewI2CDevice(c, DefaultAddress) - copy(fake.Registers[:], defaultRegisters()) - bus.AddDevice(fake) - - dev := New(bus) - c.Assert(dev.ReadRed(), qt.Equals, float32(0.15625)) - - fake.Registers[RCalReg+1] = byte(0b00000001) - c.Assert(dev.ReadRed(), qt.Not(qt.Equals), float32(0.15625)) - -} - -func TestReadRGB(t *testing.T) { - c := qt.New(t) - bus := tester.NewI2CBus(c) - fake := tester.NewI2CDevice(c, DefaultAddress) - copy(fake.Registers[:], defaultRegisters()) - bus.AddDevice(fake) - - dev := New(bus) - c.Assert(dev.ReadRGB(), qt.Equals, [3]float32{0.15625, 1.45, 0.22222}) -} - -func TestReadColors(t *testing.T) { - c := qt.New(t) - bus := tester.NewI2CBus(c) - fake := tester.NewI2CDevice(c, DefaultAddress) - copy(fake.Registers[:], defaultRegisters()) - bus.AddDevice(fake) - - dev := New(bus) - c.Assert(dev.ReadColors(), qt.Equals, [6]float32{0.15625, 0.22222, 1.45, 0.00002, 0.15625, 0.15625}) -} - -func TestReadTemp(t *testing.T) { - c := qt.New(t) - bus := tester.NewI2CBus(c) - fake := tester.NewI2CDevice(c, DefaultAddress) - copy(fake.Registers[:], defaultRegisters()) - bus.AddDevice(fake) - - dev := New(bus) - c.Assert(dev.ReadTemp(), qt.Equals, int(25)) - - fake.Registers[TempReg] = byte(0b01010011) - c.Assert(dev.ReadTemp(), qt.Equals, int(83)) - -} - -func defaultRegisters() []uint8 { - return []uint8{ - HardwareVersionReg: 0x40, // = 01000000 - TempReg: byte(0b00011001), // = 25 - VCalReg: byte(0b00111110), - VCalReg + 0x01: byte(0b00100000), - VCalReg + 0x02: byte(0b00000000), - VCalReg + 0x03: byte(0b00000000), // = 0.15625 - BCalReg: byte(0b00111110), - BCalReg + 0x01: byte(0b01100011), - BCalReg + 0x02: byte(0b10001101), - BCalReg + 0x03: byte(0b10100100), // = 0.22222 - GCalReg: byte(0b00111111), - GCalReg + 0x01: byte(0b10111001), - GCalReg + 0x02: byte(0b10011001), - GCalReg + 0x03: byte(0b10011010), // = 1.45 - YCalReg: byte(0b00110111), - YCalReg + 0x01: byte(0b10100111), - YCalReg + 0x02: byte(0b11000101), - YCalReg + 0x03: byte(0b10101100), // = 0.00002 - OCalReg: byte(0b00111110), - OCalReg + 0x01: byte(0b00100000), - OCalReg + 0x02: byte(0b00000000), - OCalReg + 0x03: byte(0b00000000), // = 0.15625 - RCalReg: byte(0b00111110), - RCalReg + 0x01: byte(0b00100000), - RCalReg + 0x02: byte(0b00000000), - RCalReg + 0x03: byte(0b00000000), // = 0.15625 - } -} From e3142efbbdcf0a0f52374566fa10aff277192875 Mon Sep 17 00:00:00 2001 From: JohnTrunix Date: Wed, 20 Sep 2023 21:41:36 +0200 Subject: [PATCH 11/23] fix(as7262): fix drivers/internal/legacy dependency --- as7262/as7262.go | 16 +++++++++++----- 1 file changed, 11 insertions(+), 5 deletions(-) diff --git a/as7262/as7262.go b/as7262/as7262.go index f7259e19c..9f5378984 100644 --- a/as7262/as7262.go +++ b/as7262/as7262.go @@ -3,6 +3,7 @@ package as7262 import ( "time" "tinygo.org/x/drivers" + "tinygo.org/x/drivers/internal/legacy" ) type Error uint8 @@ -28,6 +29,7 @@ type Device struct { Address uint8 } +// New returns pointer of new as7262 device func New(i2c drivers.I2C) *Device { return &Device{ bus: i2c, @@ -43,7 +45,7 @@ func New(i2c drivers.I2C) *Device { // deviceStatus returns StatusReg of as7262 func (d *Device) deviceStatus() byte { d.buf[0] = 0 - d.bus.ReadRegister(DefaultAddress, StatusReg, d.buf) + legacy.ReadRegister(d.bus, DefaultAddress, StatusReg, d.buf) return d.buf[0] } @@ -64,7 +66,7 @@ func (d *Device) readByte(reg byte) byte { } } - d.bus.WriteRegister(d.Address, WriteReg, []byte{reg}) + legacy.WriteRegister(d.bus, d.Address, WriteReg, []byte{reg}) for { if d.readReady() { @@ -72,7 +74,7 @@ func (d *Device) readByte(reg byte) byte { } } - d.bus.ReadRegister(d.Address, ReadReg, d.buf) + legacy.ReadRegister(d.bus, d.Address, ReadReg, d.buf) return d.buf[0] } @@ -83,7 +85,7 @@ func (d *Device) writeByte(reg byte, value byte) { } } - d.bus.WriteRegister(d.Address, WriteReg, []byte{reg | 0x80}) + legacy.WriteRegister(d.bus, d.Address, WriteReg, []byte{reg | 0x80}) for { if d.writeReady() { @@ -92,9 +94,13 @@ func (d *Device) writeByte(reg byte, value byte) { } d.buf[0] = value - d.bus.WriteRegister(d.Address, WriteReg, d.buf) + legacy.WriteRegister(d.bus, d.Address, WriteReg, d.buf) } +/* + Official as7262 functions (exported) +*/ + // Configure as7262 behaviour func (d *Device) Configure(reset bool, gain float32, integrationTime float32, mode int) { cr := newVControlReg() From f560c70677ec716bfe5cfccbeb943028ddaa8250 Mon Sep 17 00:00:00 2001 From: JohnTrunix Date: Wed, 20 Sep 2023 21:42:24 +0200 Subject: [PATCH 12/23] docs(as7262): add more info context --- as7262/vControlRegister.go | 3 +++ 1 file changed, 3 insertions(+) diff --git a/as7262/vControlRegister.go b/as7262/vControlRegister.go index d5f56ba32..e4101f4d1 100644 --- a/as7262/vControlRegister.go +++ b/as7262/vControlRegister.go @@ -18,10 +18,12 @@ func newVControlReg() *vControlReg { } } +// encode register to a complete byte for writing func (r *vControlReg) encode() byte { return r.reset | r.interrupt | r.gain | r.bank | r.dataReady } +// decode register to represent as7262 internal state func (r *vControlReg) decode(encoded byte) { r.reset = encoded & 0b10000000 r.interrupt = encoded & 0b01000000 @@ -30,6 +32,7 @@ func (r *vControlReg) decode(encoded byte) { r.dataReady = encoded & 0b00000010 } +// setReset bit which will soft reset the as7262 sensor func (r *vControlReg) setReset(reset bool) { if reset { r.reset |= 0b10000000 From dfd8f1f5b39cbe00862a864e381b4133fd0bf4d1 Mon Sep 17 00:00:00 2001 From: JohnTrunix Date: Wed, 20 Sep 2023 21:43:44 +0200 Subject: [PATCH 13/23] refactor(as7262): split Led functionality in new file --- as7262/as7262.go | 10 ---------- as7262/vLedRegister.go | 11 +++++++++++ 2 files changed, 11 insertions(+), 10 deletions(-) create mode 100644 as7262/vLedRegister.go diff --git a/as7262/as7262.go b/as7262/as7262.go index 9f5378984..3b7c36361 100644 --- a/as7262/as7262.go +++ b/as7262/as7262.go @@ -119,13 +119,3 @@ func (d *Device) Configure(reset bool, gain float32, integrationTime float32, mo t := byte(int(integrationTime*2.8) & 0xff) d.writeByte(IntegrationTimeReg, t) } - -func (d *Device) Led(status bool) { - var led byte - if status { - led = 0b00000111 - } else { - led = 0b00000110 - } - d.writeByte(LedRegister, led) -} diff --git a/as7262/vLedRegister.go b/as7262/vLedRegister.go new file mode 100644 index 000000000..1537235c2 --- /dev/null +++ b/as7262/vLedRegister.go @@ -0,0 +1,11 @@ +package as7262 + +func (d *Device) Led(status bool) { + var led byte + if status { + led = 0b00000111 + } else { + led = 0b00000110 + } + d.writeByte(LedRegister, led) +} From 12f8e2f8c9b8e756c800444ac184995ad3ef1797 Mon Sep 17 00:00:00 2001 From: JohnTrunix Date: Wed, 20 Sep 2023 22:42:58 +0200 Subject: [PATCH 14/23] feat(as7262): init virtual led register --- as7262/vLedRegister.go | 36 +++++++++++++++++++++++++++++------- 1 file changed, 29 insertions(+), 7 deletions(-) diff --git a/as7262/vLedRegister.go b/as7262/vLedRegister.go index 1537235c2..2621f62fa 100644 --- a/as7262/vLedRegister.go +++ b/as7262/vLedRegister.go @@ -1,11 +1,33 @@ package as7262 -func (d *Device) Led(status bool) { - var led byte - if status { - led = 0b00000111 - } else { - led = 0b00000110 +type vLedControlReg struct { + illuminationCurrentLimit byte + illuminationStatus byte + indicatorCurrentLimit byte + indicatorStatus byte +} + +func newVLedControlReg() *vLedControlReg { + return &vLedControlReg{ + illuminationCurrentLimit: 0b00110000, + illuminationStatus: 0b00001000, + indicatorCurrentLimit: 0b00000110, + indicatorStatus: 0b00000001, } - d.writeByte(LedRegister, led) +} + +// encode register to a complete byte for writing +func (r *vLedControlReg) encode() byte { + return r.illuminationCurrentLimit | + r.illuminationStatus | + r.indicatorCurrentLimit | + r.indicatorStatus +} + +// decode register to represent as7262 internal state +func (r *vLedControlReg) decode(encoded byte) { + r.illuminationCurrentLimit = encoded & 0b00110000 + r.illuminationStatus = encoded & 0b00001000 + r.indicatorCurrentLimit = encoded & 0b00000110 + r.indicatorStatus = encoded & 0b00000001 } From dbf863d8358dc3b03a6c26c0331d5839fd8948fc Mon Sep 17 00:00:00 2001 From: JohnTrunix Date: Wed, 20 Sep 2023 22:45:48 +0200 Subject: [PATCH 15/23] fix(as7262): fix buffer handling --- as7262/as7262.go | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/as7262/as7262.go b/as7262/as7262.go index 3b7c36361..229de36f7 100644 --- a/as7262/as7262.go +++ b/as7262/as7262.go @@ -44,7 +44,7 @@ func New(i2c drivers.I2C) *Device { // deviceStatus returns StatusReg of as7262 func (d *Device) deviceStatus() byte { - d.buf[0] = 0 + d.buf[0] = 0b00000000 legacy.ReadRegister(d.bus, DefaultAddress, StatusReg, d.buf) return d.buf[0] } @@ -60,6 +60,7 @@ func (d *Device) readReady() bool { } func (d *Device) readByte(reg byte) byte { + d.buf[0] = 0b00000000 for { if d.writeReady() { break @@ -93,8 +94,7 @@ func (d *Device) writeByte(reg byte, value byte) { } } - d.buf[0] = value - legacy.WriteRegister(d.bus, d.Address, WriteReg, d.buf) + legacy.WriteRegister(d.bus, d.Address, WriteReg, []byte{value}) } /* From b1d3c764e3a24354796aecb07633d6a753e78c83 Mon Sep 17 00:00:00 2001 From: JohnTrunix Date: Wed, 20 Sep 2023 22:47:46 +0200 Subject: [PATCH 16/23] fix(as7262): rmv Led example because of refactoring --- examples/as7262/main.go | 6 ++---- 1 file changed, 2 insertions(+), 4 deletions(-) diff --git a/examples/as7262/main.go b/examples/as7262/main.go index 8cc93cca7..56ea9c91f 100644 --- a/examples/as7262/main.go +++ b/examples/as7262/main.go @@ -13,13 +13,11 @@ var ( func main() { i2c.Configure(machine.I2CConfig{Frequency: machine.KHz * 100}) - sensor.Configure(true, 64, 17.857, 2) + sensor.Configure(true, 64, 20, 2) println("Starting ...") for { - sensor.Led(true) - time.Sleep(time.Millisecond * 800) - sensor.Led(false) + println("need more context") time.Sleep(time.Millisecond * 800) } } From dd631485ac9c4f4169a03ca61cc840d2088171eb Mon Sep 17 00:00:00 2001 From: JohnTrunix Date: Thu, 21 Sep 2023 21:40:00 +0200 Subject: [PATCH 17/23] refactor(as7262): move Configure(...) to vControlRegister.go --- as7262/as7262.go | 24 ------------------------ as7262/vControlRegister.go | 21 +++++++++++++++++++++ 2 files changed, 21 insertions(+), 24 deletions(-) diff --git a/as7262/as7262.go b/as7262/as7262.go index 229de36f7..77c257ea2 100644 --- a/as7262/as7262.go +++ b/as7262/as7262.go @@ -1,7 +1,6 @@ package as7262 import ( - "time" "tinygo.org/x/drivers" "tinygo.org/x/drivers/internal/legacy" ) @@ -96,26 +95,3 @@ func (d *Device) writeByte(reg byte, value byte) { legacy.WriteRegister(d.bus, d.Address, WriteReg, []byte{value}) } - -/* - Official as7262 functions (exported) -*/ - -// Configure as7262 behaviour -func (d *Device) Configure(reset bool, gain float32, integrationTime float32, mode int) { - cr := newVControlReg() - cr.setReset(reset) - cr.setGain(gain) - cr.setMode(mode) - crEncoded := cr.encode() - - // write ControlReg and read full ControlReg - d.writeByte(ControlReg, crEncoded) - time.Sleep(time.Second * 2) - d.readByte(ControlReg) - cr.decode(d.buf[0]) - - // set integrationTime: float32 as ms - t := byte(int(integrationTime*2.8) & 0xff) - d.writeByte(IntegrationTimeReg, t) -} diff --git a/as7262/vControlRegister.go b/as7262/vControlRegister.go index e4101f4d1..e4066fbf6 100644 --- a/as7262/vControlRegister.go +++ b/as7262/vControlRegister.go @@ -1,5 +1,7 @@ package as7262 +import "time" + type vControlReg struct { reset byte interrupt byte @@ -71,3 +73,22 @@ func (r *vControlReg) setMode(mode int) { r.bank &= 0b11110011 r.bank |= m << 2 } + +// Configure as7262 behaviour +func (d *Device) Configure(reset bool, gain float32, integrationTime float32, mode int) { + cr := newVControlReg() + cr.setReset(reset) + cr.setGain(gain) + cr.setMode(mode) + crEncoded := cr.encode() + + // write ControlReg and read full ControlReg + d.writeByte(ControlReg, crEncoded) + time.Sleep(time.Second * 2) + d.readByte(ControlReg) + cr.decode(d.buf[0]) + + // set integrationTime: float32 as ms + t := byte(int(integrationTime*2.8) & 0xff) + d.writeByte(IntegrationTimeReg, t) +} From 32b7610d8f91ac714830bce1bfbb2c218853a7e4 Mon Sep 17 00:00:00 2001 From: JohnTrunix Date: Thu, 21 Sep 2023 21:40:27 +0200 Subject: [PATCH 18/23] fix(as7262): fix integrationTime --- examples/as7262/main.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/examples/as7262/main.go b/examples/as7262/main.go index 56ea9c91f..adada2d8f 100644 --- a/examples/as7262/main.go +++ b/examples/as7262/main.go @@ -13,7 +13,7 @@ var ( func main() { i2c.Configure(machine.I2CConfig{Frequency: machine.KHz * 100}) - sensor.Configure(true, 64, 20, 2) + sensor.Configure(true, 64, 30, 2) println("Starting ...") for { From 503beb9ca8e90b320cfc70a95a86a77d0ad7926d Mon Sep 17 00:00:00 2001 From: JohnTrunix Date: Thu, 21 Sep 2023 22:06:36 +0200 Subject: [PATCH 19/23] feat(as7262): add led control --- as7262/vLedRegister.go | 73 +++++++++++++++++++++++++++++++++++++++++ examples/as7262/main.go | 1 + 2 files changed, 74 insertions(+) diff --git a/as7262/vLedRegister.go b/as7262/vLedRegister.go index 2621f62fa..befedfad2 100644 --- a/as7262/vLedRegister.go +++ b/as7262/vLedRegister.go @@ -31,3 +31,76 @@ func (r *vLedControlReg) decode(encoded byte) { r.indicatorCurrentLimit = encoded & 0b00000110 r.indicatorStatus = encoded & 0b00000001 } + +// setIlCur +func (r *vLedControlReg) setIlCr(ilCurLim float32) { + // values: 12.5, 25, 50, 100 (defaults to 50) + var cr byte + switch ilCurLim { + case 12.5: + cr = 0b00 + case 25: + cr = 0b01 + case 100: + cr = 0b11 + default: + cr = 0b10 + } + + //bitwise clear operation & setting bit 4:5 + r.illuminationCurrentLimit &= 0b11001111 + r.illuminationCurrentLimit |= cr << 4 +} + +// setIlOn +func (r *vLedControlReg) setIlOn(ilOn bool) { + if ilOn { + r.illuminationStatus |= 0b00001000 + } else { + r.illuminationStatus &= 0b11110111 + } +} + +// setInCur +func (r *vLedControlReg) setInCur(inCurLim float32) { + // values: 1, 2, 4, 8 (defaults to 8) + var cr byte + switch inCurLim { + case 1: + cr = 0b00 + case 2: + cr = 0b01 + case 4: + cr = 0b10 + default: + cr = 0b11 + } + + //bitwise clear operation & setting bit 4:5 + r.indicatorCurrentLimit &= 0b11111001 + r.indicatorCurrentLimit |= cr << 1 +} + +// setInOn +func (r *vLedControlReg) setInOn(inOn bool) { + if inOn { + r.indicatorStatus |= 0b00000001 + } else { + r.indicatorStatus &= 0b11111110 + } +} + +// ConfigureLed with all possible configurations +func (d *Device) ConfigureLed(ilCurLim float32, ilOn bool, inCurLim float32, inOn bool) { + lr := newVLedControlReg() + lr.setIlCr(ilCurLim) + lr.setIlOn(ilOn) + lr.setInCur(inCurLim) + lr.setInOn(inOn) + lrEncoded := lr.encode() + + // write ControlReg and read full ControlReg + d.writeByte(LedRegister, lrEncoded) + d.readByte(LedRegister) + lr.decode(d.buf[0]) +} diff --git a/examples/as7262/main.go b/examples/as7262/main.go index adada2d8f..7d41bb7d3 100644 --- a/examples/as7262/main.go +++ b/examples/as7262/main.go @@ -14,6 +14,7 @@ var ( func main() { i2c.Configure(machine.I2CConfig{Frequency: machine.KHz * 100}) sensor.Configure(true, 64, 30, 2) + sensor.ConfigureLed(12.5, false, 8, true) println("Starting ...") for { From a83b16980cebdf236eabdcda81b6b948aff0c78f Mon Sep 17 00:00:00 2001 From: JohnTrunix Date: Thu, 21 Sep 2023 22:17:55 +0200 Subject: [PATCH 20/23] refactor(as7262): move virtual registers to device struct --- as7262/as7262.go | 16 ++++++---- as7262/vControlRegister.go | 53 +++++++++++++++++--------------- as7262/vLedRegister.go | 63 +++++++++++++++++++------------------- 3 files changed, 69 insertions(+), 63 deletions(-) diff --git a/as7262/as7262.go b/as7262/as7262.go index 77c257ea2..f06307204 100644 --- a/as7262/as7262.go +++ b/as7262/as7262.go @@ -23,17 +23,21 @@ func (e Error) Error() string { } type Device struct { - bus drivers.I2C - buf []byte - Address uint8 + bus drivers.I2C + buf []byte + Address uint8 + vControlReg *vControlReg + vLedControlReg *vLedControlReg } // New returns pointer of new as7262 device func New(i2c drivers.I2C) *Device { return &Device{ - bus: i2c, - buf: []byte{0}, - Address: DefaultAddress, + bus: i2c, + buf: []byte{0}, + Address: DefaultAddress, + vControlReg: newVControlReg(), + vLedControlReg: newVLedControlReg(), } } diff --git a/as7262/vControlRegister.go b/as7262/vControlRegister.go index e4066fbf6..f37bb8ffb 100644 --- a/as7262/vControlRegister.go +++ b/as7262/vControlRegister.go @@ -20,31 +20,35 @@ func newVControlReg() *vControlReg { } } -// encode register to a complete byte for writing -func (r *vControlReg) encode() byte { - return r.reset | r.interrupt | r.gain | r.bank | r.dataReady +// encodeCReg register to a complete byte for writing +func (d *Device) encodeCReg() byte { + return d.vControlReg.reset | + d.vControlReg.interrupt | + d.vControlReg.gain | + d.vControlReg.bank | + d.vControlReg.dataReady } -// decode register to represent as7262 internal state -func (r *vControlReg) decode(encoded byte) { - r.reset = encoded & 0b10000000 - r.interrupt = encoded & 0b01000000 - r.gain = encoded & 0b00110000 - r.bank = encoded & 0b00001100 - r.dataReady = encoded & 0b00000010 +// decodeCReg register to represent as7262 internal state +func (d *Device) decodeCReg(encoded byte) { + d.vControlReg.reset = encoded & 0b10000000 + d.vControlReg.interrupt = encoded & 0b01000000 + d.vControlReg.gain = encoded & 0b00110000 + d.vControlReg.bank = encoded & 0b00001100 + d.vControlReg.dataReady = encoded & 0b00000010 } // setReset bit which will soft reset the as7262 sensor -func (r *vControlReg) setReset(reset bool) { +func (d *Device) setReset(reset bool) { if reset { - r.reset |= 0b10000000 + d.vControlReg.reset |= 0b10000000 } else { - r.reset &= 0b01111111 + d.vControlReg.reset &= 0b01111111 } } // setGain sets bit 4:5 of VControlReg for gain -func (r *vControlReg) setGain(gain float32) { +func (d *Device) setGain(gain float32) { // set gain (defaults to 64) // values: 1, 3.7, 16, 64 var g byte @@ -60,33 +64,32 @@ func (r *vControlReg) setGain(gain float32) { } // bitwise clear operation & setting bit 4:5 - r.gain &= 0b11001111 - r.gain |= g << 4 + d.vControlReg.gain &= 0b11001111 + d.vControlReg.gain |= g << 4 } // setMode sets bit 2:3 of VControlReg for mode -func (r *vControlReg) setMode(mode int) { +func (d *Device) setMode(mode int) { // set mode: 0, 1, 2, 3 m := byte(mode) // bitwise clear operation & setting bit 4:5 - r.bank &= 0b11110011 - r.bank |= m << 2 + d.vControlReg.bank &= 0b11110011 + d.vControlReg.bank |= m << 2 } // Configure as7262 behaviour func (d *Device) Configure(reset bool, gain float32, integrationTime float32, mode int) { - cr := newVControlReg() - cr.setReset(reset) - cr.setGain(gain) - cr.setMode(mode) - crEncoded := cr.encode() + d.setReset(reset) + d.setGain(gain) + d.setMode(mode) + crEncoded := d.encodeCReg() // write ControlReg and read full ControlReg d.writeByte(ControlReg, crEncoded) time.Sleep(time.Second * 2) d.readByte(ControlReg) - cr.decode(d.buf[0]) + d.decodeCReg(d.buf[0]) // set integrationTime: float32 as ms t := byte(int(integrationTime*2.8) & 0xff) diff --git a/as7262/vLedRegister.go b/as7262/vLedRegister.go index befedfad2..821015dd6 100644 --- a/as7262/vLedRegister.go +++ b/as7262/vLedRegister.go @@ -16,24 +16,24 @@ func newVLedControlReg() *vLedControlReg { } } -// encode register to a complete byte for writing -func (r *vLedControlReg) encode() byte { - return r.illuminationCurrentLimit | - r.illuminationStatus | - r.indicatorCurrentLimit | - r.indicatorStatus +// encodeLedReg register to a complete byte for writing +func (d *Device) encodeLedReg() byte { + return d.vLedControlReg.illuminationCurrentLimit | + d.vLedControlReg.illuminationStatus | + d.vLedControlReg.indicatorCurrentLimit | + d.vLedControlReg.indicatorStatus } -// decode register to represent as7262 internal state -func (r *vLedControlReg) decode(encoded byte) { - r.illuminationCurrentLimit = encoded & 0b00110000 - r.illuminationStatus = encoded & 0b00001000 - r.indicatorCurrentLimit = encoded & 0b00000110 - r.indicatorStatus = encoded & 0b00000001 +// decodeLedReg register to represent as7262 internal state +func (d *Device) decodeLedReg(encoded byte) { + d.vLedControlReg.illuminationCurrentLimit = encoded & 0b00110000 + d.vLedControlReg.illuminationStatus = encoded & 0b00001000 + d.vLedControlReg.indicatorCurrentLimit = encoded & 0b00000110 + d.vLedControlReg.indicatorStatus = encoded & 0b00000001 } -// setIlCur -func (r *vLedControlReg) setIlCr(ilCurLim float32) { +// setIlCr +func (d *Device) setIlCr(ilCurLim float32) { // values: 12.5, 25, 50, 100 (defaults to 50) var cr byte switch ilCurLim { @@ -48,21 +48,21 @@ func (r *vLedControlReg) setIlCr(ilCurLim float32) { } //bitwise clear operation & setting bit 4:5 - r.illuminationCurrentLimit &= 0b11001111 - r.illuminationCurrentLimit |= cr << 4 + d.vLedControlReg.illuminationCurrentLimit &= 0b11001111 + d.vLedControlReg.illuminationCurrentLimit |= cr << 4 } // setIlOn -func (r *vLedControlReg) setIlOn(ilOn bool) { +func (d *Device) setIlOn(ilOn bool) { if ilOn { - r.illuminationStatus |= 0b00001000 + d.vLedControlReg.illuminationStatus |= 0b00001000 } else { - r.illuminationStatus &= 0b11110111 + d.vLedControlReg.illuminationStatus &= 0b11110111 } } // setInCur -func (r *vLedControlReg) setInCur(inCurLim float32) { +func (d *Device) setInCur(inCurLim float32) { // values: 1, 2, 4, 8 (defaults to 8) var cr byte switch inCurLim { @@ -77,30 +77,29 @@ func (r *vLedControlReg) setInCur(inCurLim float32) { } //bitwise clear operation & setting bit 4:5 - r.indicatorCurrentLimit &= 0b11111001 - r.indicatorCurrentLimit |= cr << 1 + d.vLedControlReg.indicatorCurrentLimit &= 0b11111001 + d.vLedControlReg.indicatorCurrentLimit |= cr << 1 } // setInOn -func (r *vLedControlReg) setInOn(inOn bool) { +func (d *Device) setInOn(inOn bool) { if inOn { - r.indicatorStatus |= 0b00000001 + d.vLedControlReg.indicatorStatus |= 0b00000001 } else { - r.indicatorStatus &= 0b11111110 + d.vLedControlReg.indicatorStatus &= 0b11111110 } } // ConfigureLed with all possible configurations func (d *Device) ConfigureLed(ilCurLim float32, ilOn bool, inCurLim float32, inOn bool) { - lr := newVLedControlReg() - lr.setIlCr(ilCurLim) - lr.setIlOn(ilOn) - lr.setInCur(inCurLim) - lr.setInOn(inOn) - lrEncoded := lr.encode() + d.setIlCr(ilCurLim) + d.setIlOn(ilOn) + d.setInCur(inCurLim) + d.setInOn(inOn) + lrEncoded := d.encodeLedReg() // write ControlReg and read full ControlReg d.writeByte(LedRegister, lrEncoded) d.readByte(LedRegister) - lr.decode(d.buf[0]) + d.decodeLedReg(d.buf[0]) } From 14750466bf9d58cb4c61220ab072fb99fe519c61 Mon Sep 17 00:00:00 2001 From: JohnTrunix Date: Tue, 26 Sep 2023 21:31:04 +0200 Subject: [PATCH 21/23] feat(as7262): add reading colors functionalities --- as7262/as7262.go | 68 +++++++++++++++++++++++++++++++++++++++++++++--- 1 file changed, 64 insertions(+), 4 deletions(-) diff --git a/as7262/as7262.go b/as7262/as7262.go index f06307204..ec354e46c 100644 --- a/as7262/as7262.go +++ b/as7262/as7262.go @@ -1,6 +1,8 @@ package as7262 import ( + "encoding/binary" + "math" "tinygo.org/x/drivers" "tinygo.org/x/drivers/internal/legacy" ) @@ -41,10 +43,6 @@ func New(i2c drivers.I2C) *Device { } } -/* - Internal Functions -*/ - // deviceStatus returns StatusReg of as7262 func (d *Device) deviceStatus() byte { d.buf[0] = 0b00000000 @@ -99,3 +97,65 @@ func (d *Device) writeByte(reg byte, value byte) { legacy.WriteRegister(d.bus, d.Address, WriteReg, []byte{value}) } + +func (d *Device) read32Bit(reg byte) float32 { + var bytes [4]byte + + for i := 0; i < 4; i++ { + bytes[3-i] = d.readByte(reg + byte(i)) + } + floatValue := math.Float32frombits(binary.BigEndian.Uint32(bytes[:])) + return floatValue +} + +// Temperature returns sensor temperature +func (d *Device) Temperature() byte { + return d.readByte(TempRegister) +} + +// GetColors set pointer array: V, B, G, Y, O, R +func (d *Device) GetColors(arr *[6]float32) { + arr[0] = d.GetViolet() + arr[1] = d.GetBlue() + arr[2] = d.GetGreen() + arr[3] = d.GetYellow() + arr[4] = d.GetOrange() + arr[5] = d.GetRed() +} + +// GetRGB set pointer array: R, G, B +func (d *Device) GetRGB(arr *[3]float32) { + arr[0] = d.GetRed() + arr[1] = d.GetGreen() + arr[2] = d.GetBlue() +} + +// GetViolet returns violet value +func (d *Device) GetViolet() float32 { + return d.read32Bit(VCalReg) +} + +// GetBlue returns blue value +func (d *Device) GetBlue() float32 { + return d.read32Bit(BCalReg) +} + +// GetGreen returns green value +func (d *Device) GetGreen() float32 { + return d.read32Bit(GCalReg) +} + +// GetYellow returns yellow value +func (d *Device) GetYellow() float32 { + return d.read32Bit(YCalReg) +} + +// GetOrange returns orange value +func (d *Device) GetOrange() float32 { + return d.read32Bit(OCalReg) +} + +// GetRed returns red value +func (d *Device) GetRed() float32 { + return d.read32Bit(RCalReg) +} From 1b4e4f3582fab8e24b998b8601e2a70159ad8d9b Mon Sep 17 00:00:00 2001 From: JohnTrunix Date: Tue, 26 Sep 2023 21:31:51 +0200 Subject: [PATCH 22/23] test(as7262): example main.go changes --- examples/as7262/main.go | 9 ++++++--- 1 file changed, 6 insertions(+), 3 deletions(-) diff --git a/examples/as7262/main.go b/examples/as7262/main.go index 7d41bb7d3..7cb0b5b6e 100644 --- a/examples/as7262/main.go +++ b/examples/as7262/main.go @@ -1,3 +1,5 @@ +// tinygo flash -target arduino examples/as7262/main.go && tinygo monitor -baudrate 9600 + package main import ( @@ -13,12 +15,13 @@ var ( func main() { i2c.Configure(machine.I2CConfig{Frequency: machine.KHz * 100}) - sensor.Configure(true, 64, 30, 2) - sensor.ConfigureLed(12.5, false, 8, true) + sensor.Configure(true, 64, 17.857, 2) + //sensor.ConfigureLed(12.5, true, 8, true) println("Starting ...") + for { - println("need more context") + println("Value: ", sensor.Temperature()) time.Sleep(time.Millisecond * 800) } } From 3173884704efe1855681731e3bd949ec5ad6313d Mon Sep 17 00:00:00 2001 From: JohnTrunix Date: Tue, 26 Sep 2023 21:32:30 +0200 Subject: [PATCH 23/23] fix(as7262): reduce config timeout --- as7262/vControlRegister.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/as7262/vControlRegister.go b/as7262/vControlRegister.go index f37bb8ffb..51d895769 100644 --- a/as7262/vControlRegister.go +++ b/as7262/vControlRegister.go @@ -87,7 +87,7 @@ func (d *Device) Configure(reset bool, gain float32, integrationTime float32, mo // write ControlReg and read full ControlReg d.writeByte(ControlReg, crEncoded) - time.Sleep(time.Second * 2) + time.Sleep(time.Second) d.readByte(ControlReg) d.decodeCReg(d.buf[0])