mirror of
https://github.com/hybridgroup/gobot.git
synced 2025-04-29 13:49:14 +08:00
290 lines
8.2 KiB
Go
290 lines
8.2 KiB
Go
package i2c
|
|
|
|
import (
|
|
"errors"
|
|
"fmt"
|
|
"image"
|
|
"reflect"
|
|
"strings"
|
|
"testing"
|
|
|
|
"gobot.io/x/gobot"
|
|
"gobot.io/x/gobot/gobottest"
|
|
)
|
|
|
|
var _ gobot.Driver = (*SSD1306Driver)(nil)
|
|
|
|
func TestDisplayBuffer(t *testing.T) {
|
|
width := 128
|
|
height := 64
|
|
size := 1024 // (width*height) / 8
|
|
display := NewDisplayBuffer(width, height, 8)
|
|
|
|
if display.Size() != size {
|
|
t.Errorf("invalid Size() (%d, expected %d)",
|
|
display.Size(), size)
|
|
}
|
|
if len(display.buffer) != size {
|
|
t.Errorf("allocated buffer size invalid (%d, expected %d)",
|
|
len(display.buffer), size)
|
|
}
|
|
|
|
gobottest.Assert(t, display.buffer[0], byte(0))
|
|
gobottest.Assert(t, display.buffer[1], byte(0))
|
|
|
|
display.SetPixel(0, 0, 1)
|
|
display.SetPixel(1, 0, 1)
|
|
display.SetPixel(2, 0, 1)
|
|
display.SetPixel(0, 1, 1)
|
|
gobottest.Assert(t, display.buffer[0], byte(3))
|
|
gobottest.Assert(t, display.buffer[1], byte(1))
|
|
|
|
display.SetPixel(0, 1, 0)
|
|
gobottest.Assert(t, display.buffer[0], byte(1))
|
|
gobottest.Assert(t, display.buffer[1], byte(1))
|
|
}
|
|
|
|
// --------- HELPERS
|
|
func initTestSSD1306Driver(width, height int, externalVCC bool) (driver *SSD1306Driver) {
|
|
driver, _ = initTestSSD1306DriverWithStubbedAdaptor(width, height, externalVCC)
|
|
return
|
|
}
|
|
|
|
func initTestSSD1306DriverWithStubbedAdaptor(width, height int, externalVCC bool) (*SSD1306Driver, *i2cTestAdaptor) {
|
|
adaptor := newI2cTestAdaptor()
|
|
return NewSSD1306Driver(adaptor, WithSSD1306DisplayWidth(width), WithSSD1306DisplayHeight(height), WithSSD1306ExternalVCC(externalVCC)), adaptor
|
|
}
|
|
|
|
// --------- TESTS
|
|
|
|
func TestNewSSD1306Driver(t *testing.T) {
|
|
// Does it return a pointer to an instance of SSD1306Driver?
|
|
var bm interface{} = NewSSD1306Driver(newI2cTestAdaptor())
|
|
_, ok := bm.(*SSD1306Driver)
|
|
if !ok {
|
|
t.Errorf("new should have returned a *SSD1306Driver")
|
|
}
|
|
|
|
b := NewSSD1306Driver(newI2cTestAdaptor())
|
|
gobottest.Refute(t, b.Connection(), nil)
|
|
}
|
|
|
|
// Methods
|
|
|
|
func TestSSD1306DriverStartDefaul(t *testing.T) {
|
|
s, _ := initTestSSD1306DriverWithStubbedAdaptor(128, 64, false)
|
|
gobottest.Assert(t, s.Start(), nil)
|
|
}
|
|
|
|
func TestSSD1306DriverStart128x32(t *testing.T) {
|
|
s, _ := initTestSSD1306DriverWithStubbedAdaptor(128, 32, false)
|
|
gobottest.Assert(t, s.Start(), nil)
|
|
}
|
|
|
|
func TestSSD1306DriverStart96x16(t *testing.T) {
|
|
s, _ := initTestSSD1306DriverWithStubbedAdaptor(96, 16, false)
|
|
gobottest.Assert(t, s.Start(), nil)
|
|
}
|
|
|
|
func TestSSD1306DriverStartExternalVCC(t *testing.T) {
|
|
s, _ := initTestSSD1306DriverWithStubbedAdaptor(128, 32, true)
|
|
gobottest.Assert(t, s.Start(), nil)
|
|
}
|
|
|
|
func TestSSD1306StartConnectError(t *testing.T) {
|
|
d, adaptor := initTestSSD1306DriverWithStubbedAdaptor(128, 64, false)
|
|
adaptor.Testi2cConnectErr(true)
|
|
gobottest.Assert(t, d.Start(), errors.New("Invalid i2c connection"))
|
|
}
|
|
|
|
func TestSSD1306StartSizeError(t *testing.T) {
|
|
d, _ := initTestSSD1306DriverWithStubbedAdaptor(128, 54, false)
|
|
//adaptor.Testi2cConnectErr(false)
|
|
gobottest.Assert(t, d.Start(), errors.New("128x54 resolution is unsupported, supported resolutions: 128x64, 128x32, 96x16"))
|
|
}
|
|
|
|
func TestSSD1306DriverHalt(t *testing.T) {
|
|
s := initTestSSD1306Driver(128, 64, false)
|
|
|
|
gobottest.Assert(t, s.Halt(), nil)
|
|
}
|
|
|
|
// Test Name & SetName
|
|
func TestSSD1306DriverName(t *testing.T) {
|
|
s := initTestSSD1306Driver(96, 16, false)
|
|
|
|
gobottest.Assert(t, strings.HasPrefix(s.Name(), "SSD1306"), true)
|
|
s.SetName("Ole Oled")
|
|
gobottest.Assert(t, s.Name(), "Ole Oled")
|
|
}
|
|
|
|
func TestSSD1306DriverOptions(t *testing.T) {
|
|
s := NewSSD1306Driver(newI2cTestAdaptor(), WithBus(2), WithSSD1306DisplayHeight(32), WithSSD1306DisplayWidth(128))
|
|
gobottest.Assert(t, s.GetBusOrDefault(1), 2)
|
|
gobottest.Assert(t, s.displayHeight, 32)
|
|
gobottest.Assert(t, s.displayWidth, 128)
|
|
}
|
|
|
|
func TestSSD1306DriverDisplay(t *testing.T) {
|
|
s, _ := initTestSSD1306DriverWithStubbedAdaptor(96, 16, false)
|
|
s.Start()
|
|
gobottest.Assert(t, s.Display(), nil)
|
|
}
|
|
|
|
func TestSSD1306DriverShowImage(t *testing.T) {
|
|
s, _ := initTestSSD1306DriverWithStubbedAdaptor(128, 64, false)
|
|
s.Start()
|
|
img := image.NewRGBA(image.Rect(0, 0, 640, 480))
|
|
gobottest.Assert(t, s.ShowImage(img), errors.New("image must match display width and height: 128x64"))
|
|
|
|
img = image.NewRGBA(image.Rect(0, 0, 128, 64))
|
|
gobottest.Assert(t, s.ShowImage(img), nil)
|
|
}
|
|
|
|
func TestSSD1306DriverCommand(t *testing.T) {
|
|
s, adaptor := initTestSSD1306DriverWithStubbedAdaptor(128, 64, false)
|
|
s.Start()
|
|
|
|
adaptor.i2cWriteImpl = func(got []byte) (int, error) {
|
|
expected := []byte{0x80, 0xFF}
|
|
if !reflect.DeepEqual(got, expected) {
|
|
t.Logf("sequence error, got %+v, expected %+v", got, expected)
|
|
return 0, fmt.Errorf("oops")
|
|
}
|
|
return 0, nil
|
|
}
|
|
err := s.command(0xFF)
|
|
gobottest.Assert(t, err, nil)
|
|
}
|
|
|
|
func TestSSD1306DriverCommands(t *testing.T) {
|
|
s, adaptor := initTestSSD1306DriverWithStubbedAdaptor(128, 64, false)
|
|
s.Start()
|
|
|
|
adaptor.i2cWriteImpl = func(got []byte) (int, error) {
|
|
expected := []byte{0x80, 0x00, 0x80, 0xFF}
|
|
if !reflect.DeepEqual(got, expected) {
|
|
t.Logf("sequence error, got %+v, expected %+v", got, expected)
|
|
return 0, fmt.Errorf("oops")
|
|
}
|
|
return 0, nil
|
|
}
|
|
err := s.commands([]byte{0x00, 0xFF})
|
|
gobottest.Assert(t, err, nil)
|
|
}
|
|
|
|
func TestSSD1306DriverOn(t *testing.T) {
|
|
s, adaptor := initTestSSD1306DriverWithStubbedAdaptor(128, 64, false)
|
|
s.Start()
|
|
|
|
adaptor.i2cWriteImpl = func(got []byte) (int, error) {
|
|
expected := []byte{0x80, ssd1306SetDisplayOn}
|
|
if !reflect.DeepEqual(got, expected) {
|
|
t.Logf("sequence error, got %+v, expected %+v", got, expected)
|
|
return 0, fmt.Errorf("oops")
|
|
}
|
|
return 0, nil
|
|
}
|
|
err := s.On()
|
|
gobottest.Assert(t, err, nil)
|
|
}
|
|
|
|
func TestSSD1306DriverOff(t *testing.T) {
|
|
s, adaptor := initTestSSD1306DriverWithStubbedAdaptor(128, 64, false)
|
|
s.Start()
|
|
|
|
adaptor.i2cWriteImpl = func(got []byte) (int, error) {
|
|
expected := []byte{0x80, ssd1306SetDisplayOff}
|
|
if !reflect.DeepEqual(got, expected) {
|
|
t.Logf("sequence error, got %+v, expected %+v", got, expected)
|
|
return 0, fmt.Errorf("oops")
|
|
}
|
|
return 0, nil
|
|
}
|
|
err := s.Off()
|
|
gobottest.Assert(t, err, nil)
|
|
}
|
|
|
|
func TestSSD1306Reset(t *testing.T) {
|
|
s, adaptor := initTestSSD1306DriverWithStubbedAdaptor(128, 64, false)
|
|
s.Start()
|
|
|
|
adaptor.i2cWriteImpl = func(got []byte) (int, error) {
|
|
expectedOff := []byte{0x80, ssd1306SetDisplayOff}
|
|
expectedOn := []byte{0x80, ssd1306SetDisplayOn}
|
|
if !reflect.DeepEqual(got, expectedOff) && !reflect.DeepEqual(got, expectedOn) {
|
|
t.Logf("sequence error, got %+v, expected: %+v or %+v", got, expectedOff, expectedOn)
|
|
return 0, fmt.Errorf("oops")
|
|
}
|
|
return 0, nil
|
|
}
|
|
err := s.Reset()
|
|
gobottest.Assert(t, err, nil)
|
|
}
|
|
|
|
// COMMANDS
|
|
|
|
func TestSSD1306DriverCommandsDisplay(t *testing.T) {
|
|
s := initTestSSD1306Driver(128, 64, false)
|
|
s.Start()
|
|
|
|
result := s.Command("Display")(map[string]interface{}{})
|
|
gobottest.Assert(t, result.(map[string]interface{})["err"], nil)
|
|
}
|
|
|
|
func TestSSD1306DriverCommandsOn(t *testing.T) {
|
|
s := initTestSSD1306Driver(128, 64, false)
|
|
s.Start()
|
|
|
|
result := s.Command("On")(map[string]interface{}{})
|
|
gobottest.Assert(t, result.(map[string]interface{})["err"], nil)
|
|
}
|
|
|
|
func TestSSD1306DriverCommandsOff(t *testing.T) {
|
|
s := initTestSSD1306Driver(128, 64, false)
|
|
s.Start()
|
|
|
|
result := s.Command("Off")(map[string]interface{}{})
|
|
gobottest.Assert(t, result.(map[string]interface{})["err"], nil)
|
|
}
|
|
|
|
func TestSSD1306DriverCommandsClear(t *testing.T) {
|
|
s := initTestSSD1306Driver(128, 64, false)
|
|
s.Start()
|
|
|
|
result := s.Command("Clear")(map[string]interface{}{})
|
|
gobottest.Assert(t, result.(map[string]interface{})["err"], nil)
|
|
}
|
|
|
|
func TestSSD1306DriverCommandsSetContrast(t *testing.T) {
|
|
s, adaptor := initTestSSD1306DriverWithStubbedAdaptor(128, 64, false)
|
|
s.Start()
|
|
|
|
adaptor.i2cWriteImpl = func(got []byte) (int, error) {
|
|
expected := []byte{0x80, ssd1306SetContrast, 0x80, 0x10}
|
|
if !reflect.DeepEqual(got, expected) {
|
|
t.Logf("sequence error, got %+v, expected %+v", got, expected)
|
|
return 0, fmt.Errorf("oops")
|
|
}
|
|
return 0, nil
|
|
}
|
|
|
|
result := s.Command("SetContrast")(map[string]interface{}{
|
|
"contrast": byte(0x10),
|
|
})
|
|
gobottest.Assert(t, result.(map[string]interface{})["err"], nil)
|
|
}
|
|
|
|
func TestSSD1306DriverCommandsSet(t *testing.T) {
|
|
s := initTestSSD1306Driver(128, 64, false)
|
|
s.Start()
|
|
|
|
gobottest.Assert(t, s.buffer.buffer[0], byte(0))
|
|
s.Command("Set")(map[string]interface{}{
|
|
"x": int(0),
|
|
"y": int(0),
|
|
"c": int(1),
|
|
})
|
|
gobottest.Assert(t, s.buffer.buffer[0], byte(1))
|
|
}
|