gobot.io/x/gobot/v2@v2.1.0/platforms/intel-iot/curie/imu_driver_test.go (about)

     1  package curie
     2  
     3  import (
     4  	"bytes"
     5  	"errors"
     6  	"io"
     7  	"strings"
     8  	"testing"
     9  
    10  	"gobot.io/x/gobot/v2"
    11  	"gobot.io/x/gobot/v2/gobottest"
    12  
    13  	"gobot.io/x/gobot/v2/platforms/firmata"
    14  	"gobot.io/x/gobot/v2/platforms/firmata/client"
    15  )
    16  
    17  var _ gobot.Driver = (*IMUDriver)(nil)
    18  
    19  type readWriteCloser struct{}
    20  
    21  func (readWriteCloser) Write(p []byte) (int, error) {
    22  	return testWriteData.Write(p)
    23  }
    24  
    25  var testReadData = []byte{}
    26  var testWriteData = bytes.Buffer{}
    27  
    28  func (readWriteCloser) Read(b []byte) (int, error) {
    29  	size := len(b)
    30  	if len(testReadData) < size {
    31  		size = len(testReadData)
    32  	}
    33  	copy(b, []byte(testReadData)[:size])
    34  	testReadData = testReadData[size:]
    35  
    36  	return size, nil
    37  }
    38  
    39  func (readWriteCloser) Close() error {
    40  	return nil
    41  }
    42  
    43  type mockFirmataBoard struct {
    44  	disconnectError error
    45  	gobot.Eventer
    46  	pins []client.Pin
    47  }
    48  
    49  func newMockFirmataBoard() *mockFirmataBoard {
    50  	m := &mockFirmataBoard{
    51  		Eventer:         gobot.NewEventer(),
    52  		disconnectError: nil,
    53  		pins:            make([]client.Pin, 100),
    54  	}
    55  
    56  	m.pins[1].Value = 1
    57  	m.pins[15].Value = 133
    58  
    59  	m.AddEvent("I2cReply")
    60  	return m
    61  }
    62  
    63  func (mockFirmataBoard) Connect(io.ReadWriteCloser) error { return nil }
    64  func (m mockFirmataBoard) Disconnect() error {
    65  	return m.disconnectError
    66  }
    67  func (m mockFirmataBoard) Pins() []client.Pin {
    68  	return m.pins
    69  }
    70  func (mockFirmataBoard) AnalogWrite(int, int) error      { return nil }
    71  func (mockFirmataBoard) SetPinMode(int, int) error       { return nil }
    72  func (mockFirmataBoard) ReportAnalog(int, int) error     { return nil }
    73  func (mockFirmataBoard) ReportDigital(int, int) error    { return nil }
    74  func (mockFirmataBoard) DigitalWrite(int, int) error     { return nil }
    75  func (mockFirmataBoard) I2cRead(int, int) error          { return nil }
    76  func (mockFirmataBoard) I2cWrite(int, []byte) error      { return nil }
    77  func (mockFirmataBoard) I2cConfig(int) error             { return nil }
    78  func (mockFirmataBoard) ServoConfig(int, int, int) error { return nil }
    79  func (mockFirmataBoard) WriteSysex(data []byte) error    { return nil }
    80  
    81  func initTestIMUDriver() *IMUDriver {
    82  	a := firmata.NewAdaptor("/dev/null")
    83  	a.Board = newMockFirmataBoard()
    84  	a.PortOpener = func(port string) (io.ReadWriteCloser, error) {
    85  		return &readWriteCloser{}, nil
    86  	}
    87  	return NewIMUDriver(a)
    88  }
    89  
    90  func TestIMUDriverStart(t *testing.T) {
    91  	d := initTestIMUDriver()
    92  	gobottest.Assert(t, d.Start(), nil)
    93  }
    94  
    95  func TestIMUDriverHalt(t *testing.T) {
    96  	d := initTestIMUDriver()
    97  	gobottest.Assert(t, d.Halt(), nil)
    98  }
    99  
   100  func TestIMUDriverDefaultName(t *testing.T) {
   101  	d := initTestIMUDriver()
   102  	gobottest.Assert(t, strings.HasPrefix(d.Name(), "CurieIMU"), true)
   103  }
   104  
   105  func TestIMUDriverSetName(t *testing.T) {
   106  	d := initTestIMUDriver()
   107  	d.SetName("mybot")
   108  	gobottest.Assert(t, d.Name(), "mybot")
   109  }
   110  
   111  func TestIMUDriverConnection(t *testing.T) {
   112  	d := initTestIMUDriver()
   113  	gobottest.Refute(t, d.Connection(), nil)
   114  }
   115  
   116  func TestIMUDriverReadAccelerometer(t *testing.T) {
   117  	d := initTestIMUDriver()
   118  	d.Start()
   119  	gobottest.Assert(t, d.ReadAccelerometer(), nil)
   120  }
   121  
   122  func TestIMUDriverReadAccelerometerData(t *testing.T) {
   123  	_, err := parseAccelerometerData([]byte{})
   124  	gobottest.Assert(t, err, errors.New("Invalid data"))
   125  
   126  	result, err := parseAccelerometerData([]byte{0xF0, 0x11, 0x00, 0x00, 0x0f, 0x00, 0x0f, 0x00, 0x0f, 0xf7})
   127  	gobottest.Assert(t, err, nil)
   128  	gobottest.Assert(t, result, &AccelerometerData{X: 1920, Y: 1920, Z: 1920})
   129  }
   130  
   131  func TestIMUDriverReadGyroscope(t *testing.T) {
   132  	d := initTestIMUDriver()
   133  	d.Start()
   134  	gobottest.Assert(t, d.ReadGyroscope(), nil)
   135  }
   136  
   137  func TestIMUDriverReadGyroscopeData(t *testing.T) {
   138  	_, err := parseGyroscopeData([]byte{})
   139  	gobottest.Assert(t, err, errors.New("Invalid data"))
   140  
   141  	result, err := parseGyroscopeData([]byte{0xF0, 0x11, 0x01, 0x00, 0x0f, 0x00, 0x0f, 0x00, 0x0f, 0xf7})
   142  	gobottest.Assert(t, err, nil)
   143  	gobottest.Assert(t, result, &GyroscopeData{X: 1920, Y: 1920, Z: 1920})
   144  }
   145  
   146  func TestIMUDriverReadTemperature(t *testing.T) {
   147  	d := initTestIMUDriver()
   148  	d.Start()
   149  	gobottest.Assert(t, d.ReadTemperature(), nil)
   150  }
   151  
   152  func TestIMUDriverReadTemperatureData(t *testing.T) {
   153  	_, err := parseTemperatureData([]byte{})
   154  	gobottest.Assert(t, err, errors.New("Invalid data"))
   155  
   156  	result, err := parseTemperatureData([]byte{0xF0, 0x11, 0x02, 0x00, 0x02, 0x03, 0x04, 0xf7})
   157  	gobottest.Assert(t, err, nil)
   158  	gobottest.Assert(t, result, float32(31.546875))
   159  }
   160  
   161  func TestIMUDriverEnableShockDetection(t *testing.T) {
   162  	d := initTestIMUDriver()
   163  	d.Start()
   164  	gobottest.Assert(t, d.EnableShockDetection(true), nil)
   165  }
   166  
   167  func TestIMUDriverShockDetectData(t *testing.T) {
   168  	_, err := parseShockData([]byte{})
   169  	gobottest.Assert(t, err, errors.New("Invalid data"))
   170  
   171  	result, err := parseShockData([]byte{0xF0, 0x11, 0x03, 0x00, 0x02, 0xf7})
   172  	gobottest.Assert(t, err, nil)
   173  	gobottest.Assert(t, result, &ShockData{Axis: 0, Direction: 2})
   174  }
   175  
   176  func TestIMUDriverEnableStepCounter(t *testing.T) {
   177  	d := initTestIMUDriver()
   178  	d.Start()
   179  	gobottest.Assert(t, d.EnableStepCounter(true), nil)
   180  }
   181  
   182  func TestIMUDriverStepCountData(t *testing.T) {
   183  	_, err := parseStepData([]byte{})
   184  	gobottest.Assert(t, err, errors.New("Invalid data"))
   185  
   186  	result, err := parseStepData([]byte{0xF0, 0x11, 0x04, 0x00, 0x02, 0xf7})
   187  	gobottest.Assert(t, err, nil)
   188  	gobottest.Assert(t, result, int16(256))
   189  }
   190  
   191  func TestIMUDriverEnableTapDetection(t *testing.T) {
   192  	d := initTestIMUDriver()
   193  	d.Start()
   194  	gobottest.Assert(t, d.EnableTapDetection(true), nil)
   195  }
   196  
   197  func TestIMUDriverTapDetectData(t *testing.T) {
   198  	_, err := parseTapData([]byte{})
   199  	gobottest.Assert(t, err, errors.New("Invalid data"))
   200  
   201  	result, err := parseTapData([]byte{0xF0, 0x11, 0x05, 0x00, 0x02, 0xf7})
   202  	gobottest.Assert(t, err, nil)
   203  	gobottest.Assert(t, result, &TapData{Axis: 0, Direction: 2})
   204  }
   205  
   206  func TestIMUDriverEnableReadMotion(t *testing.T) {
   207  	d := initTestIMUDriver()
   208  	d.Start()
   209  	gobottest.Assert(t, d.ReadMotion(), nil)
   210  }
   211  
   212  func TestIMUDriverReadMotionData(t *testing.T) {
   213  	_, err := parseMotionData([]byte{})
   214  	gobottest.Assert(t, err, errors.New("Invalid data"))
   215  
   216  	result, err := parseMotionData([]byte{0xF0, 0x11, 0x06, 0x00, 0x0f, 0x00, 0x0f, 0x00, 0x0f, 0x00, 0x0f, 0x00, 0x0f, 0x00, 0x0f, 0xf7})
   217  	gobottest.Assert(t, err, nil)
   218  	gobottest.Assert(t, result, &MotionData{AX: 1920, AY: 1920, AZ: 1920, GX: 1920, GY: 1920, GZ: 1920})
   219  }
   220  
   221  func TestIMUDriverHandleEvents(t *testing.T) {
   222  	d := initTestIMUDriver()
   223  	d.Start()
   224  
   225  	gobottest.Assert(t, d.handleEvent([]byte{0xF0, 0x11, 0x00, 0x00, 0x0f, 0x00, 0x0f, 0x00, 0x0f, 0xf7}), nil)
   226  	gobottest.Assert(t, d.handleEvent([]byte{0xF0, 0x11, 0x01, 0x00, 0x0f, 0x00, 0x0f, 0x00, 0x0f, 0xf7}), nil)
   227  	gobottest.Assert(t, d.handleEvent([]byte{0xF0, 0x11, 0x02, 0x00, 0x02, 0x03, 0x04, 0xf7}), nil)
   228  	gobottest.Assert(t, d.handleEvent([]byte{0xF0, 0x11, 0x03, 0x00, 0x02, 0xf7}), nil)
   229  	gobottest.Assert(t, d.handleEvent([]byte{0xF0, 0x11, 0x04, 0x00, 0x02, 0xf7}), nil)
   230  	gobottest.Assert(t, d.handleEvent([]byte{0xF0, 0x11, 0x05, 0x00, 0x02, 0xf7}), nil)
   231  	gobottest.Assert(t, d.handleEvent([]byte{0xF0, 0x11, 0x06, 0x00, 0x0f, 0x00, 0x0f, 0x00, 0x0f, 0x00, 0x0f, 0x00, 0x0f, 0x00, 0x0f, 0xf7}), nil)
   232  }