watersensor: upgrade to embd/gpio

samples/watersensor.go

@@ -1,25 +1,38 @@
 package main
 
 import (
-	"log"
 	"time"
 
+	"github.com/golang/glog"
+	"github.com/kidoman/embd/gpio"
 	"github.com/kidoman/embd/sensor/watersensor"
 )
 
 func main() {
-	fluidSensor := watersensor.New(7)
+	if err := gpio.Open(); err != nil {
+		panic(err)
+	}
+	defer gpio.Close()
+
+	pin, err := gpio.NewDigitalPin(7)
+	if err != nil {
+		panic(err)
+	}
+	defer pin.Close()
+
+	fluidSensor := watersensor.New(pin)
 
 	for {
-		isWater, err := fluidSensor.IsWet()
+		wet, err := fluidSensor.IsWet()
 		if err != nil {
-			log.Panic(err)
+			panic(err)
 		}
-		if isWater {
+		if wet {
-			log.Printf("Bot is dry")
+			glog.Info("bot is dry")
 		} else {
-			log.Printf("Bot is Wet")
+			glog.Info("bot is Wet")
 		}
+
 		time.Sleep(500 * time.Millisecond)
 	}
 }

sensor/watersensor/watersensor.go

@@ -2,70 +2,62 @@
 package watersensor
 
 import (
-        "log"
+	"sync"
-        "sync"
-        "github.com/stianeikeland/go-rpio"
-       )
 
-type watersensor struct {
+	"github.com/golang/glog"
-    waterPinNumber int
+	"github.com/kidoman/embd/gpio"
-    waterPin rpio.Pin
+)
 
-    initialized bool
+type WaterSensor struct {
-    mu *sync.RWMutex
+	Pin gpio.DigitalPin
 
-    debug bool
+	initialized bool
+	mu          sync.RWMutex
+
+	Debug bool
 }
 
-// WaterSensor implements access to a water sensor
+// New creates a new WaterSensor struct
-type WaterSensor interface {
+func New(pin gpio.DigitalPin) *WaterSensor {
-    // IsWet determines if there is water present on the sensor
+	return &WaterSensor{Pin: pin}
-    IsWet() (b bool,err error)
 }
 
-// New creates a new WaterSensor interface
+func (d *WaterSensor) setup() error {
-func New(pinNumber int) WaterSensor {
+	d.mu.RLock()
-    return &watersensor{waterPinNumber: pinNumber, mu: new(sync.RWMutex)}
+	if d.initialized {
-}
+		d.mu.RUnlock()
+		return nil
+	}
+	d.mu.RUnlock()
 
-func (d *watersensor) Setup() (err error) {
+	d.mu.Lock()
-    d.mu.RLock()
+	defer d.mu.Unlock()
-    if d.initialized {
-        d.mu.RUnlock()
-        return
-    }
-    d.mu.RUnlock()
 
-    d.mu.Lock()
+	if err := d.Pin.SetDirection(gpio.In); err != nil {
-    defer d.mu.Unlock()
+		return err
+	}
+	d.initialized = true
 
-    if err = rpio.Open(); err != nil {
+	return nil
-        return
-    }
-
-    d.waterPin = rpio.Pin(d.waterPinNumber)
-    d.waterPin.Input()
-    d.initialized = true
-
-    return nil
 }
 
 // IsWet determines if there is water present on the sensor
-func (d *watersensor) IsWet() (b bool, err error) {
+func (d *WaterSensor) IsWet() (bool, error) {
-    if err = d.Setup(); err != nil {
+	if err := d.setup(); err != nil {
-        return
+		return false, err
-    }
+	}
 
-    if d.debug {
+	if d.Debug {
-        log.Print("Getting reading")
+		glog.Infof("watersensor: reading")
-    }
+	}
 
-    // Read the pin value of the sensor
+	value, err := d.Pin.Read()
-    if d.waterPin.Read() == rpio.High {
+	if err != nil {
-        b=true
+		return false, err
-    } else {
+	}
-        b=false
+	if value == gpio.High {
-    }
+		return true, nil
-
+	} else {
-    return
+		return false, nil
+	}
 }