Add INPUT_PULLUP support on firmdata platform

drivers/gpio/aip1640_driver.go

@@ -21,7 +21,7 @@ const (
 //
 // Library ported from: https://github.com/wemos/WEMOS_Matrix_LED_Shield_Arduino_Library
 type AIP1640Driver struct {
-	pinClock  *DirectPinDriver
+	pinClock   *DirectPinDriver
 	pinData    *DirectPinDriver
 	name       string
 	intensity  byte
@@ -34,7 +34,7 @@ type AIP1640Driver struct {
 func NewAIP1640Driver(a gobot.Connection, clockPin string, dataPin string) *AIP1640Driver {
 	t := &AIP1640Driver{
 		name:       gobot.DefaultName("AIP1640Driver"),
-		pinClock:  NewDirectPinDriver(a, clockPin),
+		pinClock:   NewDirectPinDriver(a, clockPin),
 		pinData:    NewDirectPinDriver(a, dataPin),
 		intensity:  7,
 		connection: a,

drivers/gpio/button_driver.go

@@ -8,13 +8,15 @@ import (
 
 // ButtonDriver Represents a digital Button
 type ButtonDriver struct {
-	Active       bool
-	DefaultState int
-	pin          string
-	name         string
-	halt         chan bool
-	interval     time.Duration
-	connection   DigitalReader
+	Active                bool
+	DefaultState          int
+	pin                   string
+	name                  string
+	halt                  chan bool
+	interval              time.Duration
+	connection            DigitalReader
+	connectionInputPullup DigitalReaderInputPullup
+	inputPullup           bool
 	gobot.Eventer
 }
 
@@ -33,6 +35,7 @@ func NewButtonDriver(a DigitalReader, pin string, v ...time.Duration) *ButtonDri
 		Eventer:      gobot.NewEventer(),
 		interval:     10 * time.Millisecond,
 		halt:         make(chan bool),
+		inputPullup:  false,
 	}
 
 	if len(v) > 0 {
@@ -56,7 +59,14 @@ func (b *ButtonDriver) Start() (err error) {
 	state := b.DefaultState
 	go func() {
 		for {
-			newValue, err := b.connection.DigitalRead(b.Pin())
+			var newValue int
+			var err error
+			if b.IsInputPullup() {
+				newValue, err = b.connectionInputPullup.DigitalReadInputPullup(b.Pin())
+			} else {
+				newValue, err = b.connection.DigitalRead(b.Pin())
+			}
+
 			if err != nil {
 				b.Publish(Error, err)
 			} else if newValue != state && newValue != -1 {
@@ -73,6 +83,24 @@ func (b *ButtonDriver) Start() (err error) {
 	return
 }
 
+// SetInputPullup permit to put pin mode as INPUT_PULLUP
+// Your pletaform must be support it
+func (b *ButtonDriver) SetInputPullup() (err error) {
+	if reader, ok := b.Connection().(DigitalReaderInputPullup); ok {
+		b.connectionInputPullup = reader
+		b.inputPullup = true
+
+		return
+	}
+
+	err = ErrDigitalReadInputPullupUnsupported
+
+	return
+}
+
+// IsInputPullup return if pin is setting as INPUT_PULLUP
+func (b *ButtonDriver) IsInputPullup() bool { return b.inputPullup }
+
 // Halt stops polling the button for new information
 func (b *ButtonDriver) Halt() (err error) {
 	b.halt <- true

drivers/gpio/button_driver_test.go

@@ -18,6 +18,10 @@ func initTestButtonDriver() *ButtonDriver {
 	return NewButtonDriver(newGpioTestAdaptor(), "1")
 }
 
+func initTestButtonInputPullupDriver() *ButtonDriver {
+	return NewButtonDriver(newGpioInputPullupTestAdaptor(), "1")
+}
+
 func TestButtonDriverHalt(t *testing.T) {
 	d := initTestButtonDriver()
 	go func() {
@@ -157,3 +161,88 @@ func TestButtonDriverSetName(t *testing.T) {
 	g.SetName("mybot")
 	gobottest.Assert(t, g.Name(), "mybot")
 }
+
+func TestButtonDriverSetInputPullup(t *testing.T) {
+	g := initTestButtonInputPullupDriver()
+	err := g.SetInputPullup()
+	gobottest.Assert(t, err, nil)
+	gobottest.Assert(t, g.IsInputPullup(), true)
+
+	g = initTestButtonDriver()
+	err = g.SetInputPullup()
+	gobottest.Assert(t, err, ErrDigitalReadInputPullupUnsupported)
+}
+
+func TestButtonInputPullupDriverStart(t *testing.T) {
+	sem := make(chan bool, 0)
+	a := newGpioInputPullupTestAdaptor()
+	d := NewButtonDriver(a, "1")
+	err := d.SetInputPullup()
+	gobottest.Assert(t, err, nil)
+
+	d.Once(ButtonPush, func(data interface{}) {
+		gobottest.Assert(t, d.Active, true)
+		sem <- true
+	})
+
+	a.TestAdaptorDigitalRead(func() (val int, err error) {
+		val = 1
+		return
+	})
+
+	gobottest.Assert(t, d.Start(), nil)
+
+	select {
+	case <-sem:
+	case <-time.After(buttonTestDelay * time.Millisecond):
+		t.Errorf("Button Event \"Push\" was not published")
+	}
+
+	d.Once(ButtonRelease, func(data interface{}) {
+		gobottest.Assert(t, d.Active, false)
+		sem <- true
+	})
+
+	a.TestAdaptorDigitalRead(func() (val int, err error) {
+		val = 0
+		return
+	})
+
+	select {
+	case <-sem:
+	case <-time.After(buttonTestDelay * time.Millisecond):
+		t.Errorf("Button Event \"Release\" was not published")
+	}
+
+	d.Once(Error, func(data interface{}) {
+		sem <- true
+	})
+
+	a.TestAdaptorDigitalRead(func() (val int, err error) {
+		err = errors.New("digital read error")
+		return
+	})
+
+	select {
+	case <-sem:
+	case <-time.After(buttonTestDelay * time.Millisecond):
+		t.Errorf("Button Event \"Error\" was not published")
+	}
+
+	d.Once(ButtonPush, func(data interface{}) {
+		sem <- true
+	})
+
+	d.halt <- true
+
+	a.TestAdaptorDigitalRead(func() (val int, err error) {
+		val = 1
+		return
+	})
+
+	select {
+	case <-sem:
+		t.Errorf("Button Event \"Press\" should not published")
+	case <-time.After(buttonTestDelay * time.Millisecond):
+	}
+}

drivers/gpio/direct_pin_driver.go

@@ -8,9 +8,11 @@ import (
 
 // DirectPinDriver represents a GPIO pin
 type DirectPinDriver struct {
-	name       string
-	pin        string
-	connection gobot.Connection
+	name                  string
+	pin                   string
+	inputPullup           bool
+	connection            gobot.Connection
+	connectionInputPullup DigitalReaderInputPullup
 	gobot.Commander
 }
 
@@ -24,10 +26,11 @@ type DirectPinDriver struct {
 // 	"ServoWrite" - See DirectPinDriver.ServoWrite
 func NewDirectPinDriver(a gobot.Connection, pin string) *DirectPinDriver {
 	d := &DirectPinDriver{
-		name:       gobot.DefaultName("DirectPin"),
-		connection: a,
-		pin:        pin,
-		Commander:  gobot.NewCommander(),
+		name:        gobot.DefaultName("DirectPin"),
+		connection:  a,
+		pin:         pin,
+		Commander:   gobot.NewCommander(),
+		inputPullup: false,
 	}
 
 	d.AddCommand("DigitalRead", func(params map[string]interface{}) interface{} {
@@ -50,6 +53,25 @@ func NewDirectPinDriver(a gobot.Connection, pin string) *DirectPinDriver {
 	return d
 }
 
+// SetInputPullup permit to put pin mode as INPUT_PULLUP
+// Your pletaform must be support it
+func (d *DirectPinDriver) SetInputPullup() (err error) {
+
+	if reader, ok := d.Connection().(DigitalReaderInputPullup); ok {
+		d.connectionInputPullup = reader
+		d.inputPullup = true
+
+		return
+	}
+
+	err = ErrDigitalReadInputPullupUnsupported
+
+	return
+}
+
+// IsInputPullup return if pin is setting as INPUT_PULLUP
+func (d *DirectPinDriver) IsInputPullup() bool { return d.inputPullup }
+
 // Name returns the DirectPinDrivers name
 func (d *DirectPinDriver) Name() string { return d.name }
 
@@ -88,10 +110,17 @@ func (d *DirectPinDriver) On() (err error) {
 
 // DigitalRead returns the current digital state of the pin
 func (d *DirectPinDriver) DigitalRead() (val int, err error) {
+
+	if d.IsInputPullup() {
+		return d.connectionInputPullup.DigitalReadInputPullup(d.Pin())
+	}
+
 	if reader, ok := d.Connection().(DigitalReader); ok {
 		return reader.DigitalRead(d.Pin())
+
 	}
 	err = ErrDigitalReadUnsupported
+
 	return
 }
 

drivers/gpio/direct_pin_driver_test.go

@@ -29,6 +29,28 @@ func initTestDirectPinDriver() *DirectPinDriver {
 	return NewDirectPinDriver(a, "1")
 }
 
+func initTestDirectPinInputPullupDriver() *DirectPinDriver {
+	a := newGpioInputPullupTestAdaptor()
+	a.testAdaptorDigitalRead = func() (val int, err error) {
+		val = 1
+		return
+	}
+	a.testAdaptorDigitalReadInputPullup = func() (val int, err error) {
+		val = 1
+		return
+	}
+	a.testAdaptorDigitalWrite = func() (err error) {
+		return errors.New("write error")
+	}
+	a.testAdaptorPwmWrite = func() (err error) {
+		return errors.New("write error")
+	}
+	a.testAdaptorServoWrite = func() (err error) {
+		return errors.New("write error")
+	}
+	return NewDirectPinDriver(a, "1")
+}
+
 func TestDirectPinDriver(t *testing.T) {
 	var ret map[string]interface{}
 	var err interface{}
@@ -169,3 +191,23 @@ func TestDirectPinDriverSetName(t *testing.T) {
 	d.SetName("mybot")
 	gobottest.Assert(t, d.Name(), "mybot")
 }
+
+func TestDirectPinDriverSetInputPullup(t *testing.T) {
+	d := initTestDirectPinInputPullupDriver()
+	err := d.SetInputPullup()
+	gobottest.Assert(t, err, nil)
+	gobottest.Assert(t, d.IsInputPullup(), true)
+
+	d = initTestDirectPinDriver()
+	err = d.SetInputPullup()
+	gobottest.Assert(t, err, ErrDigitalReadInputPullupUnsupported)
+}
+
+func TestDirectPinDriverDigitalReadInputPullup(t *testing.T) {
+	d := initTestDirectPinInputPullupDriver()
+	err := d.SetInputPullup()
+	gobottest.Assert(t, err, nil)
+	ret, err := d.DigitalRead()
+	gobottest.Assert(t, ret, 1)
+	gobottest.Assert(t, err, nil)
+}

drivers/gpio/easy_driver_test.go

@@ -183,4 +183,3 @@ func TestEasyDriverDisable(t *testing.T) {
 	gobottest.Assert(t, d.IsEnabled(), false)
 	gobottest.Assert(t, d.IsMoving(), false)
 }
-

drivers/gpio/gpio.go

@@ -20,6 +20,9 @@ var (
 	// ErrDigitalReadUnsupported is the error resulting when a driver attempts to use
 	// hardware capabilities which a connection does not support
 	ErrDigitalReadUnsupported = errors.New("DigitalRead is not supported by this platform")
+	// ErrDigitalReadInputPullupUnsupported is the error resulting when a driver attempts to use
+	// hardware capabilities which a connection does not support
+	ErrDigitalReadInputPullupUnsupported = errors.New("DigitalRead with INPUT_PULLUP is not supported by this platform")
 	// ErrServoOutOfRange is the error resulting when a driver attempts to use
 	// hardware capabilities which a connection does not support
 	ErrServoOutOfRange = errors.New("servo angle must be between 0-180")
@@ -61,3 +64,8 @@ type DigitalWriter interface {
 type DigitalReader interface {
 	DigitalRead(string) (val int, err error)
 }
+
+// DigitalReaderInputPullup interface represents an Adaptor which has DigitalRead capabilities with INPUT_PULLUP
+type DigitalReaderInputPullup interface {
+	DigitalReadInputPullup(string) (val int, err error)
+}

drivers/gpio/helpers_test.go

@@ -26,6 +26,11 @@ type gpioTestAdaptor struct {
 	testAdaptorDigitalRead  func() (val int, err error)
 }
 
+type gpioInputPullupTestAdaptor struct {
+	testAdaptorDigitalReadInputPullup func() (val int, err error)
+	gpioTestAdaptor
+}
+
 func (t *gpioTestAdaptor) TestAdaptorDigitalWrite(f func() (err error)) {
 	t.mtx.Lock()
 	defer t.mtx.Unlock()
@@ -103,3 +108,39 @@ func newGpioTestAdaptor() *gpioTestAdaptor {
 		},
 	}
 }
+
+func (t *gpioInputPullupTestAdaptor) TestAdaptorDigitalReadInputPullup(f func() (val int, err error)) {
+	t.mtx.Lock()
+	defer t.mtx.Unlock()
+	t.testAdaptorDigitalReadInputPullup = f
+}
+func (t *gpioInputPullupTestAdaptor) DigitalReadInputPullup(string) (val int, err error) {
+	t.mtx.Lock()
+	defer t.mtx.Unlock()
+	return t.testAdaptorDigitalRead()
+}
+func newGpioInputPullupTestAdaptor() *gpioInputPullupTestAdaptor {
+	return &gpioInputPullupTestAdaptor{
+		gpioTestAdaptor: gpioTestAdaptor{
+			port: "/dev/null",
+			testAdaptorDigitalWrite: func() (err error) {
+				return nil
+			},
+			testAdaptorServoWrite: func() (err error) {
+				return nil
+			},
+			testAdaptorPwmWrite: func() (err error) {
+				return nil
+			},
+			testAdaptorAnalogRead: func() (val int, err error) {
+				return 99, nil
+			},
+			testAdaptorDigitalRead: func() (val int, err error) {
+				return 1, nil
+			},
+		},
+		testAdaptorDigitalReadInputPullup: func() (val int, err error) {
+			return 1, nil
+		},
+	}
+}