gobot.io/x/gobot@v1.16.0/platforms/dexter/gopigo3/driver_test.go (about) 1 package gopigo3 2 3 import ( 4 "encoding/hex" 5 "testing" 6 7 "gobot.io/x/gobot" 8 "gobot.io/x/gobot/drivers/spi" 9 "gobot.io/x/gobot/gobottest" 10 ) 11 12 var _ gobot.Driver = (*Driver)(nil) 13 var negativeEncoder = false 14 15 func initTestDriver() *Driver { 16 d := NewDriver(&TestConnector{}) 17 d.Start() 18 return d 19 } 20 21 func TestDriverStart(t *testing.T) { 22 d := initTestDriver() 23 gobottest.Assert(t, d.Start(), nil) 24 } 25 26 func TestDriverHalt(t *testing.T) { 27 d := initTestDriver() 28 gobottest.Assert(t, d.Halt(), nil) 29 } 30 31 func TestDriverManufacturerName(t *testing.T) { 32 expectedName := "Dexter Industries" 33 d := initTestDriver() 34 name, err := d.GetManufacturerName() 35 if err != nil { 36 t.Error(err) 37 } 38 if name != expectedName { 39 t.Errorf("Expected name: %x, got: %x", expectedName, name) 40 } 41 } 42 43 func TestDriverBoardName(t *testing.T) { 44 expectedBoardName := "GoPiGo3" 45 d := initTestDriver() 46 name, err := d.GetBoardName() 47 if err != nil { 48 t.Error(err) 49 } 50 if name != expectedBoardName { 51 t.Errorf("Expected name: %s, got: %s", expectedBoardName, name) 52 } 53 } 54 55 func TestDriverHardwareVersion(t *testing.T) { 56 expectedHwVer := "3.1.3" 57 d := initTestDriver() 58 ver, err := d.GetHardwareVersion() 59 if err != nil { 60 t.Error(err) 61 } 62 if ver != expectedHwVer { 63 t.Errorf("Expected hw ver: %s, got: %s", expectedHwVer, ver) 64 } 65 } 66 67 func TestDriverFirmareVersion(t *testing.T) { 68 expectedFwVer := "0.3.4" 69 d := initTestDriver() 70 ver, err := d.GetFirmwareVersion() 71 if err != nil { 72 t.Error(err) 73 } 74 if ver != expectedFwVer { 75 t.Errorf("Expected fw ver: %s, got: %s", expectedFwVer, ver) 76 } 77 } 78 79 func TestGetSerialNumber(t *testing.T) { 80 expectedSerialNumber := "E0180A54514E343732202020FF112137" 81 d := initTestDriver() 82 serial, err := d.GetSerialNumber() 83 if err != nil { 84 t.Error(err) 85 } 86 if serial != expectedSerialNumber { 87 t.Errorf("Expected serial number: %s, got: %s", expectedSerialNumber, serial) 88 } 89 } 90 91 func TestGetFiveVolts(t *testing.T) { 92 expectedVoltage := float32(5.047000) 93 d := initTestDriver() 94 voltage, err := d.Get5vVoltage() 95 if err != nil { 96 t.Error(err) 97 } 98 if voltage != expectedVoltage { 99 t.Errorf("Expected 5v voltage: %f, got: %f", expectedVoltage, voltage) 100 } 101 } 102 103 func TestGetBatVolts(t *testing.T) { 104 expectedBatVoltage := float32(15.411000) 105 d := initTestDriver() 106 voltage, err := d.GetBatteryVoltage() 107 if err != nil { 108 t.Error(err) 109 } 110 if voltage != expectedBatVoltage { 111 t.Errorf("Expected battery voltage: %f, got: %f", expectedBatVoltage, voltage) 112 } 113 } 114 115 func TestGetMotorStatus(t *testing.T) { 116 expectedPower := uint16(65408) 117 d := initTestDriver() 118 _, power, _, _, err := d.GetMotorStatus(MOTOR_LEFT) 119 if err != nil { 120 t.Error(err) 121 } 122 if power != expectedPower { 123 t.Errorf("Expected power: %d, got: %d", expectedPower, power) 124 } 125 } 126 127 func TestGetEncoderStatusPos(t *testing.T) { 128 negativeEncoder = false 129 expectedEncoderValue := int64(127) 130 d := initTestDriver() 131 encoderValue, err := d.GetMotorEncoder(MOTOR_LEFT) 132 if err != nil { 133 t.Error(err) 134 } 135 if encoderValue != expectedEncoderValue { 136 t.Errorf("Expected encoder value: %d, got: %d", expectedEncoderValue, encoderValue) 137 } 138 } 139 140 func TestGetEncoderStatusNeg(t *testing.T) { 141 negativeEncoder = true 142 expectedEncoderValue := int64(-128) 143 d := initTestDriver() 144 encoderValue, err := d.GetMotorEncoder(MOTOR_LEFT) 145 if err != nil { 146 t.Error(err) 147 } 148 if encoderValue != expectedEncoderValue { 149 t.Errorf("Expected encoder value: %d, got: %d", expectedEncoderValue, encoderValue) 150 } 151 } 152 153 func TestAnalogRead(t *testing.T) { 154 expectedVal := 160 155 d := initTestDriver() 156 val, err := d.AnalogRead("AD_1_1") 157 if err != nil { 158 t.Error(err) 159 } 160 if val != expectedVal { 161 t.Errorf("Expected value: %d, got: %d", expectedVal, val) 162 } 163 } 164 165 func TestDigitalRead(t *testing.T) { 166 expectedVal := 1 167 d := initTestDriver() 168 val, err := d.DigitalRead("AD_1_2") 169 if err != nil { 170 t.Error(err) 171 } 172 if val != expectedVal { 173 t.Errorf("Expected value: %d, got: %d", expectedVal, val) 174 } 175 } 176 177 func TestServoWrite(t *testing.T) { 178 d := initTestDriver() 179 err := d.ServoWrite(SERVO_1, 0x7F) 180 if err != nil { 181 t.Error(err) 182 } 183 } 184 185 func TestSetMotorPosition(t *testing.T) { 186 d := initTestDriver() 187 err := d.SetMotorPosition(MOTOR_LEFT, 12.0) 188 if err != nil { 189 t.Error(err) 190 } 191 } 192 193 func TestSetMotorPower(t *testing.T) { 194 d := initTestDriver() 195 err := d.SetMotorPower(MOTOR_LEFT, 127) 196 if err != nil { 197 t.Error(err) 198 } 199 } 200 201 func TestSetMotorDps(t *testing.T) { 202 d := initTestDriver() 203 err := d.SetMotorDps(MOTOR_LEFT, 12.0) 204 if err != nil { 205 t.Error(err) 206 } 207 } 208 209 func TestOffsetMotorEncoder(t *testing.T) { 210 d := initTestDriver() 211 err := d.OffsetMotorEncoder(MOTOR_LEFT, 12.0) 212 if err != nil { 213 t.Error(err) 214 } 215 } 216 217 func TestSetPWMDuty(t *testing.T) { 218 d := initTestDriver() 219 err := d.SetPWMDuty(AD_1_1_G, 80) 220 if err != nil { 221 t.Error(err) 222 } 223 } 224 225 func TestSetPWMfreq(t *testing.T) { 226 d := initTestDriver() 227 err := d.SetPWMFreq(AD_1_2_G, 100) 228 if err != nil { 229 t.Error(err) 230 } 231 } 232 233 func TestPwmWrite(t *testing.T) { 234 d := initTestDriver() 235 err := d.PwmWrite("AD_2_2", 80) 236 if err != nil { 237 t.Error(err) 238 } 239 } 240 241 func TestDigitalWrite(t *testing.T) { 242 d := initTestDriver() 243 err := d.DigitalWrite("AD_2_1", 1) 244 if err != nil { 245 t.Error(err) 246 } 247 } 248 249 type TestConnector struct{} 250 251 func (ctr *TestConnector) GetSpiConnection(busNum, chipNum, mode, bits int, maxSpeed int64) (device spi.Connection, err error) { 252 return TestSpiDevice{}, nil 253 } 254 255 func (ctr *TestConnector) GetSpiDefaultBus() int { 256 return 0 257 } 258 259 func (ctr *TestConnector) GetSpiDefaultChip() int { 260 return 0 261 } 262 263 func (ctr *TestConnector) GetSpiDefaultMode() int { 264 return 0 265 } 266 267 func (ctr *TestConnector) GetSpiDefaultBits() int { 268 return 8 269 } 270 271 func (ctr *TestConnector) GetSpiDefaultMaxSpeed() int64 { 272 return 0 273 } 274 275 type TestSpiDevice struct { 276 bus spi.Connection 277 } 278 279 func (c TestSpiDevice) Close() error { 280 return nil 281 } 282 283 func (c TestSpiDevice) Tx(w, r []byte) error { 284 manName, _ := hex.DecodeString("ff0000a544657874657220496e6475737472696573000000") 285 boardName, _ := hex.DecodeString("ff0000a5476f5069476f3300000000000000000000000000") 286 hwVersion, _ := hex.DecodeString("ff0000a5002dcaab") 287 fwVersion, _ := hex.DecodeString("ff0000a500000bbc") 288 serialNum, _ := hex.DecodeString("ff0000a5e0180a54514e343732202020ff112137") 289 fiveVoltVoltage, _ := hex.DecodeString("ff0000a513b7") 290 batteryVoltage, _ := hex.DecodeString("ff0000a53c33") 291 negMotorEncoder, _ := hex.DecodeString("ff0000a5ffffff00") 292 motorEncoder, _ := hex.DecodeString("ff0000a5000000ff") 293 motorStatus, _ := hex.DecodeString("ff0000a50080000000000000") 294 analogValue, _ := hex.DecodeString("ff0000a50000a0") 295 buttonPush, _ := hex.DecodeString("ff0000a50001") 296 switch w[1] { 297 case 1: 298 copy(r, manName) 299 return nil 300 case 2: 301 copy(r, boardName) 302 return nil 303 case 3: 304 copy(r, hwVersion) 305 return nil 306 case 4: 307 copy(r, fwVersion) 308 return nil 309 case 5: 310 copy(r, serialNum) 311 return nil 312 case 7: 313 copy(r, fiveVoltVoltage) 314 return nil 315 case 8: 316 copy(r, batteryVoltage) 317 return nil 318 case 17: 319 if negativeEncoder { 320 copy(r, negMotorEncoder) 321 return nil 322 } 323 copy(r, motorEncoder) 324 return nil 325 case 19: 326 copy(r, motorStatus) 327 return nil 328 case 29: 329 copy(r, buttonPush) 330 return nil 331 case 36: 332 copy(r, analogValue) 333 return nil 334 } 335 return nil 336 }