Update edison package for new gpio interface

platforms/intel-iot/edison/edison_adaptor.go

@@ -1,7 +1,7 @@
 package edison
 
 import (
-	"fmt"
+	"errors"
 	"io"
 	"os"
 	"strconv"
@@ -56,7 +56,7 @@ type EdisonAdaptor struct {
 	digitalPins map[int]sysfs.DigitalPin
 	pwmPins     map[int]*pwmPin
 	i2cDevice   io.ReadWriteCloser
-	connect     func(e *EdisonAdaptor)
+	connect     func(e *EdisonAdaptor) (err error)
 }
 
 var sysfsPinMap = map[string]sysfsPin{
@@ -172,14 +172,12 @@ var sysfsPinMap = map[string]sysfsPin{
 }
 
 // changePinMode writes pin mode to current_pinmux file
-func changePinMode(pin, mode string) {
+func changePinMode(pin, mode string) (err error) {
-	_, err := writeFile(
+	_, err = writeFile(
 		"/sys/kernel/debug/gpio_debug/gpio"+pin+"/current_pinmux",
 		[]byte("mode"+mode),
 	)
-	if err != nil {
+	return
-		panic(err)
-	}
 }
 
 // NewEditionAdaptor creates a EdisonAdaptor with specified name and
@@ -190,37 +188,65 @@ func NewEdisonAdaptor(name string) *EdisonAdaptor {
 			name,
 			"EdisonAdaptor",
 		),
-		connect: func(e *EdisonAdaptor) {
+		connect: func(e *EdisonAdaptor) (err error) {
 			e.tristate = sysfs.NewDigitalPin(214)
-			e.tristate.Export()
+			if err = e.tristate.Export(); err != nil {
-			e.tristate.Direction(sysfs.OUT)
+				return err
-			e.tristate.Write(sysfs.LOW)
+			}
+			if err = e.tristate.Direction(sysfs.OUT); err != nil {
+				return err
+			}
+			if err = e.tristate.Write(sysfs.LOW); err != nil {
+				return err
+			}
 
 			for _, i := range []int{263, 262} {
 				io := sysfs.NewDigitalPin(i)
-				io.Export()
+				if err = io.Export(); err != nil {
-				io.Direction(sysfs.OUT)
+					return err
-				io.Write(sysfs.HIGH)
+				}
-				io.Unexport()
+				if err = io.Direction(sysfs.OUT); err != nil {
+					return err
+				}
+				if err = io.Write(sysfs.HIGH); err != nil {
+					return err
+				}
+				if err = io.Unexport(); err != nil {
+					return err
+				}
 			}
 
 			for _, i := range []int{240, 241, 242, 243} {
 				io := sysfs.NewDigitalPin(i)
-				io.Export()
+				if err = io.Export(); err != nil {
-				io.Direction(sysfs.OUT)
+					return err
-				io.Write(sysfs.LOW)
+				}
-				io.Unexport()
+				if err = io.Direction(sysfs.OUT); err != nil {
+					return err
+				}
+				if err = io.Write(sysfs.LOW); err != nil {
+					return err
+				}
+				if err = io.Unexport(); err != nil {
+					return err
+				}
+
 			}
 
 			for _, i := range []string{"111", "115", "114", "109"} {
-				changePinMode(i, "1")
+				if err = changePinMode(i, "1"); err != nil {
+					return err
+				}
 			}
 
 			for _, i := range []string{"131", "129", "40"} {
-				changePinMode(i, "0")
+				if err = changePinMode(i, "0"); err != nil {
+					return err
+				}
 			}
 
-			e.tristate.Write(sysfs.HIGH)
+			err = e.tristate.Write(sysfs.HIGH)
+			return
 		},
 	}
 }
@@ -230,8 +256,7 @@ func NewEdisonAdaptor(name string) *EdisonAdaptor {
 func (e *EdisonAdaptor) Connect() error {
 	e.digitalPins = make(map[int]sysfs.DigitalPin)
 	e.pwmPins = make(map[int]*pwmPin)
-	e.connect(e)
+	return e.connect(e)
-	return nil
 }
 
 // Finalize closes connection to board and pins
@@ -244,7 +269,8 @@ func (e *EdisonAdaptor) Finalize() error {
 	}
 	for _, pin := range e.pwmPins {
 		if pin != nil {
-			pin.close()
+			pin.enable("0")
+			pin.unexport()
 		}
 	}
 	if e.i2cDevice != nil {
@@ -254,93 +280,160 @@ func (e *EdisonAdaptor) Finalize() error {
 }
 
 // digitalPin returns matched digitalPin for specified values
-func (e *EdisonAdaptor) digitalPin(pin string, dir string) sysfs.DigitalPin {
+func (e *EdisonAdaptor) digitalPin(pin string, dir string) (sysfsPin sysfs.DigitalPin, err error) {
 	i := sysfsPinMap[pin]
 	if e.digitalPins[i.pin] == nil {
 		e.digitalPins[i.pin] = sysfs.NewDigitalPin(i.pin)
-		e.digitalPins[i.pin].Export()
+		if err = e.digitalPins[i.pin].Export(); err != nil {
+			return
+		}
+
 		e.digitalPins[i.resistor] = sysfs.NewDigitalPin(i.resistor)
-		e.digitalPins[i.resistor].Export()
+		if err = e.digitalPins[i.resistor].Export(); err != nil {
+			return
+		}
+
 		e.digitalPins[i.levelShifter] = sysfs.NewDigitalPin(i.levelShifter)
-		e.digitalPins[i.levelShifter].Export()
+		if err = e.digitalPins[i.levelShifter].Export(); err != nil {
+			return
+		}
+
 		if len(i.mux) > 0 {
 			for _, mux := range i.mux {
 				e.digitalPins[mux.pin] = sysfs.NewDigitalPin(mux.pin)
-				e.digitalPins[mux.pin].Export()
+				if err = e.digitalPins[mux.pin].Export(); err != nil {
-				e.digitalPins[mux.pin].Direction(sysfs.OUT)
+					return
-				e.digitalPins[mux.pin].Write(mux.value)
+				}
+
+				if err = e.digitalPins[mux.pin].Direction(sysfs.OUT); err != nil {
+					return
+				}
+
+				if err = e.digitalPins[mux.pin].Write(mux.value); err != nil {
+					return
+				}
+
 			}
 		}
 	}
 
 	if dir == "in" {
-		e.digitalPins[i.pin].Direction(sysfs.IN)
+		if err = e.digitalPins[i.pin].Direction(sysfs.IN); err != nil {
-		e.digitalPins[i.resistor].Direction(sysfs.OUT)
+			return
-		e.digitalPins[i.resistor].Write(sysfs.LOW)
+		}
-		e.digitalPins[i.levelShifter].Direction(sysfs.OUT)
+
-		e.digitalPins[i.levelShifter].Write(sysfs.LOW)
+		if err = e.digitalPins[i.resistor].Direction(sysfs.OUT); err != nil {
+			return
+		}
+
+		if err = e.digitalPins[i.resistor].Write(sysfs.LOW); err != nil {
+			return
+		}
+
+		if err = e.digitalPins[i.levelShifter].Direction(sysfs.OUT); err != nil {
+			return
+		}
+
+		if err = e.digitalPins[i.levelShifter].Write(sysfs.LOW); err != nil {
+			return
+		}
+
 	} else if dir == "out" {
-		e.digitalPins[i.pin].Direction(sysfs.OUT)
+		if err = e.digitalPins[i.pin].Direction(sysfs.OUT); err != nil {
-		e.digitalPins[i.resistor].Direction(sysfs.IN)
+			return
-		e.digitalPins[i.levelShifter].Direction(sysfs.OUT)
+		}
-		e.digitalPins[i.levelShifter].Write(sysfs.HIGH)
+
+		if err = e.digitalPins[i.resistor].Direction(sysfs.IN); err != nil {
+			return
+		}
+
+		if err = e.digitalPins[i.levelShifter].Direction(sysfs.OUT); err != nil {
+			return
+		}
+
+		if err = e.digitalPins[i.levelShifter].Write(sysfs.HIGH); err != nil {
+			return
+		}
+
 	}
-	return e.digitalPins[i.pin]
+	return e.digitalPins[i.pin], nil
 }
 
 // DigitalRead reads digital value from pin
-func (e *EdisonAdaptor) DigitalRead(pin string) (i int) {
+func (e *EdisonAdaptor) DigitalRead(pin string) (i int, err error) {
-	i, _ = e.digitalPin(pin, "in").Read()
+	sysfsPin, err := e.digitalPin(pin, "in")
-	return
+	if err != nil {
+		return
+	}
+	return sysfsPin.Read()
 }
 
 // DigitalWrite writes digital value to specified pin
-func (e *EdisonAdaptor) DigitalWrite(pin string, val byte) {
+func (e *EdisonAdaptor) DigitalWrite(pin string, val byte) (err error) {
-	e.digitalPin(pin, "out").Write(int(val))
+	sysfsPin, err := e.digitalPin(pin, "out")
+	if err != nil {
+		return
+	}
+	return sysfsPin.Write(int(val))
 }
 
 // PwmWrite writes scaled pwm value to specified pin
-func (e *EdisonAdaptor) PwmWrite(pin string, val byte) {
+func (e *EdisonAdaptor) PwmWrite(pin string, val byte) (err error) {
 	sysPin := sysfsPinMap[pin]
 	if sysPin.pwmPin != -1 {
 		if e.pwmPins[sysPin.pwmPin] == nil {
-			e.DigitalWrite(pin, 1)
+			if err = e.DigitalWrite(pin, 1); err != nil {
-			changePinMode(strconv.Itoa(int(sysPin.pin)), "1")
+				return
+			}
+			if err = changePinMode(strconv.Itoa(int(sysPin.pin)), "1"); err != nil {
+				return
+			}
 			e.pwmPins[sysPin.pwmPin] = newPwmPin(sysPin.pwmPin)
+			if err = e.pwmPins[sysPin.pwmPin].export(); err != nil {
+				return
+			}
+			if err = e.pwmPins[sysPin.pwmPin].enable("1"); err != nil {
+				return
+			}
 		}
-		period, err := strconv.Atoi(e.pwmPins[sysPin.pwmPin].period())
+		p, err := e.pwmPins[sysPin.pwmPin].period()
 		if err != nil {
-			panic(err)
+			return err
+		}
+		period, err := strconv.Atoi(p)
+		if err != nil {
+			return err
 		}
 		duty := gobot.FromScale(float64(val), 0, 255.0)
-		e.pwmPins[sysPin.pwmPin].writeDuty(strconv.Itoa(int(float64(period) * duty)))
+		return e.pwmPins[sysPin.pwmPin].writeDuty(strconv.Itoa(int(float64(period) * duty)))
-	} else {
-		fmt.Println("Not a PWM pin")
 	}
+	return errors.New("Not a PWM pin")
 }
 
 // AnalogWrite Not Implemented
-func (e *EdisonAdaptor) AnalogWrite(string, byte) {}
+func (e *EdisonAdaptor) AnalogWrite(string, byte) (err error) {
+	return errors.New("AnalogWrite is not yet implemented")
+}
 
 // InitServo Not Implemented
-func (e *EdisonAdaptor) InitServo() {}
+func (e *EdisonAdaptor) InitServo() (err error) {
+	return errors.New("InitServo is not yet implemented")
+}
 
 // ServoWrite Not Implemented
-func (e *EdisonAdaptor) ServoWrite(string, byte) {}
+func (e *EdisonAdaptor) ServoWrite(string, byte) (err error) {
+	return errors.New("ServoWrite is not yet implemented")
+}
 
 // AnalogRead returns value from analog reading of specified pin
-func (e *EdisonAdaptor) AnalogRead(pin string) int {
+func (e *EdisonAdaptor) AnalogRead(pin string) (val int, err error) {
 	buf, err := readFile(
 		"/sys/bus/iio/devices/iio:device1/in_voltage" + pin + "_raw",
 	)
 	if err != nil {
-		panic(err)
+		return
 	}
-	val, err := strconv.Atoi(string(buf[0 : len(buf)-1]))
+	return strconv.Atoi(string(buf[0 : len(buf)-1]))
-	if err != nil {
-		panic(err)
-	}
-	return val
 }
 
 // I2cStart initializes i2c device for addresss

platforms/intel-iot/edison/edison_adaptor_test.go

@@ -28,10 +28,21 @@ func initTestEdisonAdaptor() (*EdisonAdaptor, *sysfs.MockFilesystem) {
 		"/sys/class/pwm/pwmchip0/pwm1/enable",
 		"/sys/class/gpio/export",
 		"/sys/class/gpio/unexport",
+		"/sys/class/gpio/gpio13/value",
+		"/sys/class/gpio/gpio13/direction",
 		"/sys/class/gpio/gpio40/value",
 		"/sys/class/gpio/gpio40/direction",
 		"/sys/class/gpio/gpio128/value",
 		"/sys/class/gpio/gpio128/direction",
+		"/sys/class/gpio/gpio221/value",
+		"/sys/class/gpio/gpio221/direction",
+		"/sys/class/gpio/gpio243/value",
+		"/sys/class/gpio/gpio243/direction",
+		"/sys/class/gpio/gpio229/direction",
+		"/sys/class/gpio/gpio253/value",
+		"/sys/class/gpio/gpio253/direction",
+		"/sys/class/gpio/gpio261/value",
+		"/sys/class/gpio/gpio261/direction",
 		"/dev/i2c-6",
 	})
 	sysfs.SetFilesystem(fs)
@@ -55,7 +66,7 @@ func TestEdisonAdaptorDigitalIO(t *testing.T) {
 	gobot.Assert(t, fs.Files["/sys/class/gpio/gpio40/value"].Contents, "1")
 
 	a.DigitalWrite("2", 0)
-	i := a.DigitalRead("2")
+	i, _ := a.DigitalRead("2")
 	gobot.Assert(t, i, 0)
 }
 
@@ -80,6 +91,6 @@ func TestEdisonAdaptorAnalog(t *testing.T) {
 	a, fs := initTestEdisonAdaptor()
 
 	fs.Files["/sys/bus/iio/devices/iio:device1/in_voltage0_raw"].Contents = "1000\n"
-	i := a.AnalogRead("0")
+	i, _ := a.AnalogRead("0")
 	gobot.Assert(t, i, 1000)
 }

platforms/intel-iot/edison/pwm_pin.go

@@ -38,49 +38,38 @@ type pwmPin struct {
 
 // newPwmPin returns an exported and enabled pwmPin
 func newPwmPin(pin int) *pwmPin {
-	p := &pwmPin{pin: strconv.Itoa(pin)}
+	return &pwmPin{pin: strconv.Itoa(pin)}
-	p.export()
-	p.enable("1")
-	return p
 }
 
 // enable writes value to pwm enable path
-func (p *pwmPin) enable(val string) {
+func (p *pwmPin) enable(val string) (err error) {
-	_, err := writeFile(pwmEnablePath(p.pin), []byte(val))
+	_, err = writeFile(pwmEnablePath(p.pin), []byte(val))
-	if err != nil {
+	return
-		panic(err)
-	}
 }
 
 // period reads from pwm period path and returns value
-func (p *pwmPin) period() string {
+func (p *pwmPin) period() (period string, err error) {
 	buf, err := readFile(pwmPeriodPath(p.pin))
 	if err != nil {
-		panic(err)
+		return
 	}
-	return string(buf[0 : len(buf)-1])
+	return string(buf[0 : len(buf)-1]), nil
 }
 
 // writeDuty writes value to pwm duty cycle path
-func (p *pwmPin) writeDuty(duty string) {
+func (p *pwmPin) writeDuty(duty string) (err error) {
-	_, err := writeFile(pwmDutyCyclePath(p.pin), []byte(duty))
+	_, err = writeFile(pwmDutyCyclePath(p.pin), []byte(duty))
-	if err != nil {
+	return
-		panic(err)
-	}
 }
 
 // export writes pin to pwm export path
-func (p *pwmPin) export() {
+func (p *pwmPin) export() (err error) {
-	writeFile(pwmExportPath(), []byte(p.pin))
+	_, err = writeFile(pwmExportPath(), []byte(p.pin))
+	return
 }
 
 // export writes pin to pwm unexport path
-func (p *pwmPin) unexport() {
+func (p *pwmPin) unexport() (err error) {
-	writeFile(pwmUnExportPath(), []byte(p.pin))
+	_, err = writeFile(pwmUnExportPath(), []byte(p.pin))
-}
+	return
-
-// close disables and unexports pin
-func (p *pwmPin) close() {
-	p.enable("0")
-	p.unexport()
 }