go-embedded
/
embd
mirror of https://github.com/kidoman/embd
1
0
Fork 0
Code Issues Releases Wiki Activity

host specific drivers can now be loaded separately

Browse Source 
this ensures cleaner abstractions/code and will ensure that the produced
binary is as small as possible. a convenience package is provided to
easily load all hosts easily: "github.com/kidoman/embd/host/all"
pull/4/head
Karan Misra 9 years ago
parent 57328c979d
commit c35deeb17c
44 changed files with 1184 additions and 1018 deletions
Show Stats Download Patch File Download Diff File

507
bbb.go
Unescape Escape View File

@ -1,507 +0,0 @@
// BeagleBone Black support.
// The following features are supported on Linux kernel 3.8+
//
// GPIO (digital (rw), analog (ro), pwm)
// I2C
// LED
package embd
import (
"bufio"
"errors"
"fmt"
"io/ioutil"
"os"
"path"
"strconv"
"strings"
"time"
"github.com/golang/glog"
"github.com/kidoman/embd/util"
)
var bbbPins = PinMap{
&PinDesc{ID: "P8_07", Aliases: []string{"66", "GPIO_66", "Caps: TIMER4"}, Caps: CapDigital | CapGPMC, DigitalLogical: 66},
&PinDesc{ID: "P8_08", Aliases: []string{"67", "GPIO_67", "TIMER7"}, Caps: CapDigital | CapGPMC, DigitalLogical: 67},
&PinDesc{ID: "P8_09", Aliases: []string{"69", "GPIO_69", "TIMER5"}, Caps: CapDigital | CapGPMC, DigitalLogical: 69},
&PinDesc{ID: "P8_10", Aliases: []string{"68", "GPIO_68", "TIMER6"}, Caps: CapDigital | CapGPMC, DigitalLogical: 68},
&PinDesc{ID: "P8_11", Aliases: []string{"45", "GPIO_45"}, Caps: CapDigital | CapGPMC, DigitalLogical: 45},
&PinDesc{ID: "P8_12", Aliases: []string{"44", "GPIO_44"}, Caps: CapDigital | CapGPMC, DigitalLogical: 44},
&PinDesc{ID: "P8_13", Aliases: []string{"23", "GPIO_23", "EHRPWM2B"}, Caps: CapDigital | CapGPMC, DigitalLogical: 23},
&PinDesc{ID: "P8_14", Aliases: []string{"26", "GPIO_26"}, Caps: CapDigital | CapGPMC, DigitalLogical: 26},
&PinDesc{ID: "P8_15", Aliases: []string{"47", "GPIO_47"}, Caps: CapDigital | CapGPMC, DigitalLogical: 47},
&PinDesc{ID: "P8_16", Aliases: []string{"46", "GPIO_46"}, Caps: CapDigital | CapGPMC, DigitalLogical: 46},
&PinDesc{ID: "P8_17", Aliases: []string{"27", "GPIO_27"}, Caps: CapDigital | CapGPMC, DigitalLogical: 27},
&PinDesc{ID: "P8_18", Aliases: []string{"65", "GPIO_65"}, Caps: CapDigital | CapGPMC, DigitalLogical: 65},
&PinDesc{ID: "P8_19", Aliases: []string{"22", "GPIO_22", "EHRPWM2A"}, Caps: CapDigital | CapGPMC, DigitalLogical: 22},
&PinDesc{ID: "P8_26", Aliases: []string{"61", "GPIO_61"}, Caps: CapDigital | CapGPMC, DigitalLogical: 61},
&PinDesc{ID: "P8_27", Aliases: []string{"86", "GPIO_86"}, Caps: CapDigital | CapLCD, DigitalLogical: 86},
&PinDesc{ID: "P8_28", Aliases: []string{"88", "GPIO_88"}, Caps: CapDigital | CapLCD, DigitalLogical: 88},
&PinDesc{ID: "P8_29", Aliases: []string{"87", "GPIO_87"}, Caps: CapDigital | CapLCD, DigitalLogical: 87},
&PinDesc{ID: "P8_30", Aliases: []string{"89", "GPIO_89"}, Caps: CapDigital | CapLCD, DigitalLogical: 89},
&PinDesc{ID: "P8_31", Aliases: []string{"10", "GPIO_10", "UART5_CTSN"}, Caps: CapDigital | CapLCD, DigitalLogical: 10},
&PinDesc{ID: "P8_32", Aliases: []string{"11", "GPIO_11", "UART5_RTSN"}, Caps: CapDigital | CapLCD, DigitalLogical: 11},
&PinDesc{ID: "P8_33", Aliases: []string{"9", "GPIO_9 ", "UART4_RTSN"}, Caps: CapDigital | CapLCD, DigitalLogical: 9},
&PinDesc{ID: "P8_34", Aliases: []string{"81", "GPIO_81", "UART3_RTSN"}, Caps: CapDigital | CapLCD, DigitalLogical: 81},
&PinDesc{ID: "P8_35", Aliases: []string{"8", "GPIO_8 ", "UART4_CTSN"}, Caps: CapDigital | CapLCD, DigitalLogical: 8},
&PinDesc{ID: "P8_36", Aliases: []string{"80", "GPIO_80", "UART3_CTSN"}, Caps: CapDigital | CapLCD, DigitalLogical: 80},
&PinDesc{ID: "P8_37", Aliases: []string{"78", "GPIO_78", "UART5_TXD"}, Caps: CapDigital | CapLCD, DigitalLogical: 78},
&PinDesc{ID: "P8_38", Aliases: []string{"79", "GPIO_79", "UART5_RXD"}, Caps: CapDigital | CapLCD, DigitalLogical: 79},
&PinDesc{ID: "P8_39", Aliases: []string{"76", "GPIO_76"}, Caps: CapDigital | CapLCD, DigitalLogical: 76},
&PinDesc{ID: "P8_40", Aliases: []string{"77", "GPIO_77"}, Caps: CapDigital | CapLCD, DigitalLogical: 77},
&PinDesc{ID: "P8_41", Aliases: []string{"74", "GPIO_74"}, Caps: CapDigital | CapLCD, DigitalLogical: 74},
&PinDesc{ID: "P8_42", Aliases: []string{"75", "GPIO_75"}, Caps: CapDigital | CapLCD, DigitalLogical: 75},
&PinDesc{ID: "P8_43", Aliases: []string{"72", "GPIO_72"}, Caps: CapDigital | CapLCD, DigitalLogical: 72},
&PinDesc{ID: "P8_44", Aliases: []string{"73", "GPIO_73"}, Caps: CapDigital | CapLCD, DigitalLogical: 73},
&PinDesc{ID: "P8_45", Aliases: []string{"70", "GPIO_70"}, Caps: CapDigital | CapLCD, DigitalLogical: 70},
&PinDesc{ID: "P8_46", Aliases: []string{"71", "GPIO_71"}, Caps: CapDigital | CapLCD, DigitalLogical: 71},
&PinDesc{ID: "P9_11", Aliases: []string{"30", "GPIO_30", "UART4_RXD"}, Caps: CapDigital | CapUART, DigitalLogical: 30},
&PinDesc{ID: "P9_12", Aliases: []string{"60", "GPIO_60", "GPIO1_28"}, Caps: CapDigital, DigitalLogical: 60},
&PinDesc{ID: "P9_13", Aliases: []string{"31", "GPIO_31", "UART4_TXD"}, Caps: CapDigital | CapUART, DigitalLogical: 31},
&PinDesc{ID: "P9_14", Aliases: []string{"50", "GPIO_50", "EHRPWM1A"}, Caps: CapDigital | CapPWM, DigitalLogical: 50},
&PinDesc{ID: "P9_15", Aliases: []string{"48", "GPIO_48", "GPIO1_16"}, Caps: CapDigital, DigitalLogical: 48},
&PinDesc{ID: "P9_16", Aliases: []string{"51", "GPIO_51", "EHRPWM1B"}, Caps: CapDigital | CapPWM, DigitalLogical: 51},
&PinDesc{ID: "P9_17", Aliases: []string{"5", "GPIO_5", "I2C1_SCL"}, Caps: CapDigital | CapI2C, DigitalLogical: 5},
&PinDesc{ID: "P9_18", Aliases: []string{"4", "GPIO_4", "I2C1_SDA"}, Caps: CapDigital | CapI2C, DigitalLogical: 4},
&PinDesc{ID: "P9_19", Aliases: []string{"13", "GPIO_13", "I2C2_SCL"}, Caps: CapDigital | CapI2C, DigitalLogical: 13},
&PinDesc{ID: "P9_20", Aliases: []string{"12", "GPIO_12", "I2C2_SDA"}, Caps: CapDigital | CapI2C, DigitalLogical: 12},
&PinDesc{ID: "P9_21", Aliases: []string{"3", "GPIO_3", "UART2_TXD"}, Caps: CapDigital | CapUART, DigitalLogical: 3},
&PinDesc{ID: "P9_22", Aliases: []string{"2", "GPIO_2", "UART2_RXD"}, Caps: CapDigital | CapUART, DigitalLogical: 2},
&PinDesc{ID: "P9_23", Aliases: []string{"49", "GPIO_49", "GPIO1_17"}, Caps: CapDigital, DigitalLogical: 49},
&PinDesc{ID: "P9_24", Aliases: []string{"15", "GPIO_15", "UART1_TXD"}, Caps: CapDigital | CapUART, DigitalLogical: 15},
&PinDesc{ID: "P9_25", Aliases: []string{"117", "GPIO_117", "GPIO3_21"}, Caps: CapDigital, DigitalLogical: 117},
&PinDesc{ID: "P9_26", Aliases: []string{"14", "GPIO_14", "UART1_RXD"}, Caps: CapDigital | CapUART, DigitalLogical: 14},
&PinDesc{ID: "P9_27", Aliases: []string{"115", "GPIO_115", "GPIO3_19"}, Caps: CapDigital, DigitalLogical: 115},
&PinDesc{ID: "P9_28", Aliases: []string{"113", "GPIO_113", "SPI1_CS0"}, Caps: CapDigital | CapSPI, DigitalLogical: 113},
&PinDesc{ID: "P9_29", Aliases: []string{"111", "GPIO_111", "SPI1_D0"}, Caps: CapDigital | CapSPI, DigitalLogical: 111},
&PinDesc{ID: "P9_30", Aliases: []string{"112", "GPIO_112", "SPI1_D1"}, Caps: CapDigital | CapSPI, DigitalLogical: 112},
&PinDesc{ID: "P9_31", Aliases: []string{"110", "GPIO_110", "SPI1_SCLK"}, Caps: CapDigital | CapSPI, DigitalLogical: 110},
&PinDesc{ID: "P9_32", Aliases: []string{"VADC"}},
&PinDesc{ID: "P9_33", Aliases: []string{"4", "AIN4"}, Caps: CapAnalog, AnalogLogical: 4},
&PinDesc{ID: "P9_34", Aliases: []string{"AGND"}},
&PinDesc{ID: "P9_35", Aliases: []string{"6", "AIN6"}, Caps: CapAnalog, AnalogLogical: 6},
&PinDesc{ID: "P9_36", Aliases: []string{"5", "AIN5"}, Caps: CapAnalog, AnalogLogical: 5},
&PinDesc{ID: "P9_37", Aliases: []string{"2", "AIN2"}, Caps: CapAnalog, AnalogLogical: 2},
&PinDesc{ID: "P9_38", Aliases: []string{"3", "AIN3"}, Caps: CapAnalog, AnalogLogical: 3},
&PinDesc{ID: "P9_39", Aliases: []string{"0", "AIN0"}, Caps: CapAnalog, AnalogLogical: 0},
&PinDesc{ID: "P9_40", Aliases: []string{"1", "AIN1"}, Caps: CapAnalog, AnalogLogical: 1},
}
var bbbLEDMap = LEDMap{
"beaglebone:green:usr0": []string{"0", "USR0", "usr0"},
"beaglebone:green:usr1": []string{"1", "USR1", "usr1"},
"beaglebone:green:usr2": []string{"2", "USR2", "usr2"},
"beaglebone:green:usr3": []string{"3", "USR3", "usr3"},
}
func bbbEnsureFeatureEnabled(id string) error {
pattern := "/sys/devices/bone_capemgr.*/slots"
file, err := findFirstMatchingFile(pattern)
if err != nil {
return err
}
bytes, err := ioutil.ReadFile(file)
if err != nil {
return err
}
str := string(bytes)
if strings.Contains(str, id) {
return nil
}
slots, err := os.OpenFile(file, os.O_WRONLY, os.ModeExclusive)
if err != nil {
return err
}
defer slots.Close()
_, err = slots.WriteString(id)
return err
}
// This cannot be currently used to disable things like the
// analog and pwm modules. Removing them from slots file can
// potentially cause a kernel panic and unsettle things. So the
// recommended thing to do is to simply reboot.
func bbbEnsureFeatureDisabled(id string) error {
pattern := "/sys/devices/bone_capemgr.*/slots"
file, err := findFirstMatchingFile(pattern)
if err != nil {
return err
}
slots, err := os.OpenFile(file, os.O_RDWR, os.ModeExclusive)
if err != nil {
return err
}
defer slots.Close()
scanner := bufio.NewScanner(slots)
for scanner.Scan() {
text := scanner.Text()
if !strings.Contains(text, id) {
continue
}
// Extract the id from the line
idx := strings.Index(text, ":")
if idx < 0 {
// Something is off, bail
continue
}
dis := strings.TrimSpace(text[:idx])
slots.Seek(0, 0)
_, err = slots.WriteString("-" + dis)
return err
}
// Could not disable the feature
return fmt.Errorf("embd: could not disable feature %q", id)
}
type bbbAnalogPin struct {
id string
n int
drv GPIODriver
val *os.File
initialized bool
}
func newBBBAnalogPin(pd *PinDesc, drv GPIODriver) AnalogPin {
return &bbbAnalogPin{id: pd.ID, n: pd.AnalogLogical, drv: drv}
}
func (p *bbbAnalogPin) N() int {
return p.n
}
func (p *bbbAnalogPin) init() error {
if p.initialized {
return nil
}
var err error
if err = p.ensureEnabled(); err != nil {
return err
}
if p.val, err = p.valueFile(); err != nil {
return err
}
p.initialized = true
return nil
}
func (p *bbbAnalogPin) ensureEnabled() error {
return bbbEnsureFeatureEnabled("cape-bone-iio")
}
func (p *bbbAnalogPin) valueFilePath() (string, error) {
pattern := fmt.Sprintf("/sys/devices/ocp.*/helper.*/AIN%v", p.n)
return findFirstMatchingFile(pattern)
}
func (p *bbbAnalogPin) openFile(path string) (*os.File, error) {
return os.OpenFile(path, os.O_RDONLY, os.ModeExclusive)
}
func (p *bbbAnalogPin) valueFile() (*os.File, error) {
path, err := p.valueFilePath()
if err != nil {
return nil, err
}
return p.openFile(path)
}
func (p *bbbAnalogPin) Read() (int, error) {
if err := p.init(); err != nil {
return 0, err
}
p.val.Seek(0, 0)
bytes, err := ioutil.ReadAll(p.val)
if err != nil {
return 0, err
}
str := string(bytes)
str = strings.TrimSpace(str)
return strconv.Atoi(str)
}
func (p *bbbAnalogPin) Close() error {
if err := p.drv.Unregister(p.id); err != nil {
return err
}
if !p.initialized {
return nil
}
if err := p.val.Close(); err != nil {
return err
}
p.initialized = false
return nil
}
const (
// BBBPWMDefaultPolarity represents the default polarity (Positve or 1) for pwm.
BBBPWMDefaultPolarity = Positive
// BBBPWMDefaultDuty represents the default duty (0ns) for pwm.
BBBPWMDefaultDuty = 0
// BBBPWMDefaultPeriod represents the default period (500000ns) for pwm. Equals 2000 Hz.
BBBPWMDefaultPeriod = 500000
// BBBPWMMaxPulseWidth represents the max period (1000000000ns) supported by pwm. Equals 1 Hz.
BBBPWMMaxPulseWidth = 1000000000
)
type bbbPWMPin struct {
n string
drv GPIODriver
period int
polarity Polarity
dutyf *os.File
periodf *os.File
polarityf *os.File
initialized bool
}
func newBBBPWMPin(pd *PinDesc, drv GPIODriver) PWMPin {
return &bbbPWMPin{n: pd.ID, drv: drv}
}
func (p *bbbPWMPin) N() string {
return p.n
}
func (p *bbbPWMPin) id() string {
return "bone_pwm_" + p.n
}
func (p *bbbPWMPin) init() error {
if p.initialized {
return nil
}
if err := p.ensurePWMEnabled(); err != nil {
return err
}
if err := p.ensurePinEnabled(); err != nil {
return err
}
basePath, err := p.basePath()
if err != nil {
return err
}
if err := p.ensurePeriodFileExists(basePath, 500*time.Millisecond); err != nil {
return err
}
if p.periodf, err = p.periodFile(basePath); err != nil {
return err
}
if p.dutyf, err = p.dutyFile(basePath); err != nil {
return err
}
if p.polarityf, err = p.polarityFile(basePath); err != nil {
return err
}
p.initialized = true
if err := p.reset(); err != nil {
return err
}
return nil
}
func (p *bbbPWMPin) ensurePWMEnabled() error {
return bbbEnsureFeatureEnabled("am33xx_pwm")
}
func (p *bbbPWMPin) ensurePinEnabled() error {
return bbbEnsureFeatureEnabled(p.id())
}
func (p *bbbPWMPin) ensurePinDisabled() error {
return bbbEnsureFeatureDisabled(p.id())
}
func (p *bbbPWMPin) basePath() (string, error) {
pattern := "/sys/devices/ocp.*/pwm_test_" + p.n + ".*"
return findFirstMatchingFile(pattern)
}
func (p *bbbPWMPin) openFile(path string) (*os.File, error) {
return os.OpenFile(path, os.O_WRONLY, os.ModeExclusive)
}
func (p *bbbPWMPin) ensurePeriodFileExists(basePath string, d time.Duration) error {
path := p.periodFilePath(basePath)
timeout := time.After(d)
for {
select {
case <-timeout:
return errors.New("embd: period file not found before timeout")
default:
if _, err := os.Stat(path); err == nil {
return nil
}
}
// We are looping, wait a bit.
time.Sleep(10 * time.Millisecond)
}
}
func (p *bbbPWMPin) periodFilePath(basePath string) string {
return path.Join(basePath, "period")
}
func (p *bbbPWMPin) periodFile(basePath string) (*os.File, error) {
return p.openFile(p.periodFilePath(basePath))
}
func (p *bbbPWMPin) dutyFile(basePath string) (*os.File, error) {
return p.openFile(path.Join(basePath, "duty"))
}
func (p *bbbPWMPin) polarityFile(basePath string) (*os.File, error) {
return p.openFile(path.Join(basePath, "polarity"))
}
func (p *bbbPWMPin) SetPeriod(ns int) error {
if err := p.init(); err != nil {
return err
}
if ns > BBBPWMMaxPulseWidth {
return fmt.Errorf("embd: pwm period for %v is out of bounds (must be =< %vns)", p.n, BBBPWMMaxPulseWidth)
}
_, err := p.periodf.WriteString(strconv.Itoa(ns))
if err != nil {
return err
}
p.period = ns
return nil
}
func (p *bbbPWMPin) SetDuty(ns int) error {
if err := p.init(); err != nil {
return err
}
if ns > BBBPWMMaxPulseWidth {
return fmt.Errorf("embd: pwm duty %v for pin %v is out of bounds (must be =< %vns)", p.n, BBBPWMMaxPulseWidth)
}
if ns > p.period {
return fmt.Errorf("embd: pwm duty %v for pin %v is greater than the period %v", ns, p.n, p.period)
}
_, err := p.dutyf.WriteString(strconv.Itoa(ns))
if err != nil {
return err
}
return nil
}
func (p *bbbPWMPin) SetMicroseconds(us int) error {
if err := p.init(); err != nil {
return err
}
if p.period != 20000000 {
glog.Warningf("embd: pwm pin %v has freq %v hz. recommended 50 hz for servo mode", 1000000000/p.period)
}
duty := us * 1000 // in nanoseconds
if duty > p.period {
return fmt.Errorf("embd: calculated pwm duty %vns for pin %v (servo mode) is greater than the period %vns", duty, p.n, p.period)
}
return p.SetDuty(duty)
}
func (p *bbbPWMPin) SetAnalog(value byte) error {
duty := util.Map(int64(value), 0, 255, 0, int64(p.period))
return p.SetDuty(int(duty))
}
func (p *bbbPWMPin) SetPolarity(pol Polarity) error {
if err := p.init(); err != nil {
return err
}
_, err := p.polarityf.WriteString(strconv.Itoa(int(pol)))
if err != nil {
return err
}
p.polarity = pol
return nil
}
func (p *bbbPWMPin) reset() error {
if err := p.SetPolarity(Positive); err != nil {
return err
}
if err := p.SetDuty(BBBPWMDefaultDuty); err != nil {
return err
}
if err := p.SetPeriod(BBBPWMDefaultPeriod); err != nil {
return err
}
return nil
}
func (p *bbbPWMPin) Close() error {
if err := p.drv.Unregister(p.n); err != nil {
return err
}
if !p.initialized {
return nil
}
if err := p.reset(); err != nil {
return err
}
if err := p.ensurePinDisabled(); err != nil {
return err
}
p.initialized = false
return nil
}
func init() {
Register(HostBBB, func(rev int) *Descriptor {
return &Descriptor{
GPIODriver: func() GPIODriver {
return newGPIODriver(bbbPins, newDigitalPin, newBBBAnalogPin, newBBBPWMPin)
},
I2CDriver: newI2CDriver,
LEDDriver: func() LEDDriver {
return newLEDDriver(bbbLEDMap)
},
}
})
}

41
bbb_test.go
Unescape Escape View File

@ -1,41 +0,0 @@
package embd
import "testing"
func TestBBBAnalogPinClose(t *testing.T) {
pinMap := PinMap{
&PinDesc{ID: "P1_1", Aliases: []string{"1"}, Caps: CapAnalog},
}
driver := newGPIODriver(pinMap, nil, newBBBAnalogPin, nil)
pin, err := driver.AnalogPin(1)
if err != nil {
t.Fatalf("Looking up analog pin 1: got %v", err)
}
pin.Close()
pin2, err := driver.AnalogPin(1)
if err != nil {
t.Fatalf("Looking up analog pin 1: got %v", err)
}
if pin == pin2 {
t.Fatal("Looking up closed analog pin 1: but got the old instance")
}
}
func TestBBBPWMPinClose(t *testing.T) {
pinMap := PinMap{
&PinDesc{ID: "P1_1", Aliases: []string{"1"}, Caps: CapPWM},
}
driver := newGPIODriver(pinMap, nil, nil, newBBBPWMPin)
pin, err := driver.PWMPin(1)
if err != nil {
t.Fatalf("Looking up pwm pin 1: got %v", err)
}
pin.Close()
pin2, err := driver.PWMPin(1)
if err != nil {
t.Fatalf("Looking up pwm pin 1: got %v", err)
}
if pin == pin2 {
t.Fatal("Looking up closed pwm pin 1: but got the old instance")
}
}

4
gpiodriver.go
Unescape Escape View File

@ -25,7 +25,9 @@ type gpioDriver struct {
initializedPins map[string]pin
}
func newGPIODriver(pinMap PinMap, dpf digitalPinFactory, apf analogPinFactory, ppf pwmPinFactory) GPIODriver {
// NewGPIODriver returns a GPIODriver interface which allows control
// over the GPIO subsystem.
func NewGPIODriver(pinMap PinMap, dpf digitalPinFactory, apf analogPinFactory, ppf pwmPinFactory) GPIODriver {
return &gpioDriver{
pinMap: pinMap,
dpf: dpf,

8
gpiodriver_test.go
Unescape Escape View File

@ -62,7 +62,7 @@ func TestGpioDriverDigitalPin(t *testing.T) {
pinMap := PinMap{
&PinDesc{ID: "P1_1", Aliases: []string{"1"}, Caps: CapDigital, DigitalLogical: 1},
}
driver := newGPIODriver(pinMap, newFakeDigitalPin, nil, nil)
driver := NewGPIODriver(pinMap, newFakeDigitalPin, nil, nil)
for _, test := range tests {
pin, err := driver.DigitalPin(test.key)
if err != nil {
@ -112,7 +112,7 @@ func TestGpioDriverAnalogPin(t *testing.T) {
pinMap := PinMap{
&PinDesc{ID: "P1_1", Aliases: []string{"1"}, Caps: CapAnalog, AnalogLogical: 1},
}
driver := newGPIODriver(pinMap, nil, newFakeAnalogPin, nil)
driver := NewGPIODriver(pinMap, nil, newFakeAnalogPin, nil)
for _, test := range tests {
pin, err := driver.AnalogPin(test.key)
if err != nil {
@ -130,7 +130,7 @@ func TestGpioDriverUnavailablePinType(t *testing.T) {
&PinDesc{ID: "P1_1", Aliases: []string{"1"}, Caps: CapDigital, DigitalLogical: 1},
&PinDesc{ID: "P1_2", Aliases: []string{"1"}, Caps: CapAnalog, AnalogLogical: 1},
}
driver := newGPIODriver(pinMap, nil, nil, nil)
driver := NewGPIODriver(pinMap, nil, nil, nil)
_, err := driver.DigitalPin(1)
if err == nil {
t.Fatal("Looking up digital pin 1: did not get error")
@ -153,7 +153,7 @@ func TestGpioPinCaching(t *testing.T) {
pinMap := PinMap{
&PinDesc{ID: "P1_1", Aliases: []string{"1"}, Caps: CapDigital},
}
driver := newGPIODriver(pinMap, newFakeDigitalPin, nil, nil)
driver := NewGPIODriver(pinMap, newFakeDigitalPin, nil, nil)
pin, err := driver.DigitalPin(1)
if err != nil {
t.Fatalf("Looking up digital pin 1: got %v", err)

7
host/all/all.go
Unescape Escape View File

@ -0,0 +1,7 @@
// Package all conviniently loads all the inbuilt/supported host drivers.
package all
import (
_ "github.com/kidoman/embd/host/bbb"
_ "github.com/kidoman/embd/host/rpi"
)

104
host/bbb/analogpin.go
Unescape Escape View File

@ -0,0 +1,104 @@
// Analog I/O support on the BBB.
package bbb
import (
"fmt"
"io/ioutil"
"os"
"strconv"
"strings"
"github.com/kidoman/embd"
)
type analogPin struct {
id string
n int
drv embd.GPIODriver
val *os.File
initialized bool
}
func newAnalogPin(pd *embd.PinDesc, drv embd.GPIODriver) embd.AnalogPin {
return &analogPin{id: pd.ID, n: pd.AnalogLogical, drv: drv}
}
func (p *analogPin) N() int {
return p.n
}
func (p *analogPin) init() error {
if p.initialized {
return nil
}
var err error
if err = p.ensureEnabled(); err != nil {
return err
}
if p.val, err = p.valueFile(); err != nil {
return err
}
p.initialized = true
return nil
}
func (p *analogPin) ensureEnabled() error {
return ensureFeatureEnabled("cape-bone-iio")
}
func (p *analogPin) valueFilePath() (string, error) {
pattern := fmt.Sprintf("/sys/devices/ocp.*/helper.*/AIN%v", p.n)
return embd.FindFirstMatchingFile(pattern)
}
func (p *analogPin) openFile(path string) (*os.File, error) {
return os.OpenFile(path, os.O_RDONLY, os.ModeExclusive)
}
func (p *analogPin) valueFile() (*os.File, error) {
path, err := p.valueFilePath()
if err != nil {
return nil, err
}
return p.openFile(path)
}
func (p *analogPin) Read() (int, error) {
if err := p.init(); err != nil {
return 0, err
}
p.val.Seek(0, 0)
bytes, err := ioutil.ReadAll(p.val)
if err != nil {
return 0, err
}
str := string(bytes)
str = strings.TrimSpace(str)
return strconv.Atoi(str)
}
func (p *analogPin) Close() error {
if err := p.drv.Unregister(p.id); err != nil {
return err
}
if !p.initialized {
return nil
}
if err := p.val.Close(); err != nil {
return err
}
p.initialized = false
return nil
}

26
host/bbb/analogpin_test.go
Unescape Escape View File

@ -0,0 +1,26 @@
package bbb
import (
"testing"
"github.com/kidoman/embd"
)
func TestAnalogPinClose(t *testing.T) {
pinMap := embd.PinMap{
&embd.PinDesc{ID: "P1_1", Aliases: []string{"1"}, Caps: embd.CapAnalog},
}
driver := embd.NewGPIODriver(pinMap, nil, newAnalogPin, nil)
pin, err := driver.AnalogPin(1)
if err != nil {
t.Fatalf("Looking up analog pin 1: got %v", err)
}
pin.Close()
pin2, err := driver.AnalogPin(1)
if err != nil {
t.Fatalf("Looking up analog pin 1: got %v", err)
}
if pin == pin2 {
t.Fatal("Looking up closed analog pin 1: but got the old instance")
}
}

170
host/bbb/bbb.go
Unescape Escape View File

@ -0,0 +1,170 @@
/*
Package bbb provides BeagleBone Black support.
The following features are supported on Linux kernel 3.8+
GPIO (digital (rw), analog (ro), pwm)
I²C
LED
*/
package bbb
import (
"bufio"
"fmt"
"io/ioutil"
"os"
"strings"
"github.com/kidoman/embd"
"github.com/kidoman/embd/host/generic"
)
var pins = embd.PinMap{
&embd.PinDesc{ID: "P8_07", Aliases: []string{"66", "GPIO_66", "Caps: TIMER4"}, Caps: embd.CapDigital | embd.CapGPMC, DigitalLogical: 66},
&embd.PinDesc{ID: "P8_08", Aliases: []string{"67", "GPIO_67", "TIMER7"}, Caps: embd.CapDigital | embd.CapGPMC, DigitalLogical: 67},
&embd.PinDesc{ID: "P8_09", Aliases: []string{"69", "GPIO_69", "TIMER5"}, Caps: embd.CapDigital | embd.CapGPMC, DigitalLogical: 69},
&embd.PinDesc{ID: "P8_10", Aliases: []string{"68", "GPIO_68", "TIMER6"}, Caps: embd.CapDigital | embd.CapGPMC, DigitalLogical: 68},
&embd.PinDesc{ID: "P8_11", Aliases: []string{"45", "GPIO_45"}, Caps: embd.CapDigital | embd.CapGPMC, DigitalLogical: 45},
&embd.PinDesc{ID: "P8_12", Aliases: []string{"44", "GPIO_44"}, Caps: embd.CapDigital | embd.CapGPMC, DigitalLogical: 44},
&embd.PinDesc{ID: "P8_13", Aliases: []string{"23", "GPIO_23", "EHRPWM2B"}, Caps: embd.CapDigital | embd.CapGPMC, DigitalLogical: 23},
&embd.PinDesc{ID: "P8_14", Aliases: []string{"26", "GPIO_26"}, Caps: embd.CapDigital | embd.CapGPMC, DigitalLogical: 26},
&embd.PinDesc{ID: "P8_15", Aliases: []string{"47", "GPIO_47"}, Caps: embd.CapDigital | embd.CapGPMC, DigitalLogical: 47},
&embd.PinDesc{ID: "P8_16", Aliases: []string{"46", "GPIO_46"}, Caps: embd.CapDigital | embd.CapGPMC, DigitalLogical: 46},
&embd.PinDesc{ID: "P8_17", Aliases: []string{"27", "GPIO_27"}, Caps: embd.CapDigital | embd.CapGPMC, DigitalLogical: 27},
&embd.PinDesc{ID: "P8_18", Aliases: []string{"65", "GPIO_65"}, Caps: embd.CapDigital | embd.CapGPMC, DigitalLogical: 65},
&embd.PinDesc{ID: "P8_19", Aliases: []string{"22", "GPIO_22", "EHRPWM2A"}, Caps: embd.CapDigital | embd.CapGPMC, DigitalLogical: 22},
&embd.PinDesc{ID: "P8_26", Aliases: []string{"61", "GPIO_61"}, Caps: embd.CapDigital | embd.CapGPMC, DigitalLogical: 61},
&embd.PinDesc{ID: "P8_27", Aliases: []string{"86", "GPIO_86"}, Caps: embd.CapDigital | embd.CapLCD, DigitalLogical: 86},
&embd.PinDesc{ID: "P8_28", Aliases: []string{"88", "GPIO_88"}, Caps: embd.CapDigital | embd.CapLCD, DigitalLogical: 88},
&embd.PinDesc{ID: "P8_29", Aliases: []string{"87", "GPIO_87"}, Caps: embd.CapDigital | embd.CapLCD, DigitalLogical: 87},
&embd.PinDesc{ID: "P8_30", Aliases: []string{"89", "GPIO_89"}, Caps: embd.CapDigital | embd.CapLCD, DigitalLogical: 89},
&embd.PinDesc{ID: "P8_31", Aliases: []string{"10", "GPIO_10", "UART5_CTSN"}, Caps: embd.CapDigital | embd.CapLCD, DigitalLogical: 10},
&embd.PinDesc{ID: "P8_32", Aliases: []string{"11", "GPIO_11", "UART5_RTSN"}, Caps: embd.CapDigital | embd.CapLCD, DigitalLogical: 11},
&embd.PinDesc{ID: "P8_33", Aliases: []string{"9", "GPIO_9 ", "UART4_RTSN"}, Caps: embd.CapDigital | embd.CapLCD, DigitalLogical: 9},
&embd.PinDesc{ID: "P8_34", Aliases: []string{"81", "GPIO_81", "UART3_RTSN"}, Caps: embd.CapDigital | embd.CapLCD, DigitalLogical: 81},
&embd.PinDesc{ID: "P8_35", Aliases: []string{"8", "GPIO_8 ", "UART4_CTSN"}, Caps: embd.CapDigital | embd.CapLCD, DigitalLogical: 8},
&embd.PinDesc{ID: "P8_36", Aliases: []string{"80", "GPIO_80", "UART3_CTSN"}, Caps: embd.CapDigital | embd.CapLCD, DigitalLogical: 80},
&embd.PinDesc{ID: "P8_37", Aliases: []string{"78", "GPIO_78", "UART5_TXD"}, Caps: embd.CapDigital | embd.CapLCD, DigitalLogical: 78},
&embd.PinDesc{ID: "P8_38", Aliases: []string{"79", "GPIO_79", "UART5_RXD"}, Caps: embd.CapDigital | embd.CapLCD, DigitalLogical: 79},
&embd.PinDesc{ID: "P8_39", Aliases: []string{"76", "GPIO_76"}, Caps: embd.CapDigital | embd.CapLCD, DigitalLogical: 76},
&embd.PinDesc{ID: "P8_40", Aliases: []string{"77", "GPIO_77"}, Caps: embd.CapDigital | embd.CapLCD, DigitalLogical: 77},
&embd.PinDesc{ID: "P8_41", Aliases: []string{"74", "GPIO_74"}, Caps: embd.CapDigital | embd.CapLCD, DigitalLogical: 74},
&embd.PinDesc{ID: "P8_42", Aliases: []string{"75", "GPIO_75"}, Caps: embd.CapDigital | embd.CapLCD, DigitalLogical: 75},
&embd.PinDesc{ID: "P8_43", Aliases: []string{"72", "GPIO_72"}, Caps: embd.CapDigital | embd.CapLCD, DigitalLogical: 72},
&embd.PinDesc{ID: "P8_44", Aliases: []string{"73", "GPIO_73"}, Caps: embd.CapDigital | embd.CapLCD, DigitalLogical: 73},
&embd.PinDesc{ID: "P8_45", Aliases: []string{"70", "GPIO_70"}, Caps: embd.CapDigital | embd.CapLCD, DigitalLogical: 70},
&embd.PinDesc{ID: "P8_46", Aliases: []string{"71", "GPIO_71"}, Caps: embd.CapDigital | embd.CapLCD, DigitalLogical: 71},
&embd.PinDesc{ID: "P9_11", Aliases: []string{"30", "GPIO_30", "UART4_RXD"}, Caps: embd.CapDigital | embd.CapUART, DigitalLogical: 30},
&embd.PinDesc{ID: "P9_12", Aliases: []string{"60", "GPIO_60", "GPIO1_28"}, Caps: embd.CapDigital, DigitalLogical: 60},
&embd.PinDesc{ID: "P9_13", Aliases: []string{"31", "GPIO_31", "UART4_TXD"}, Caps: embd.CapDigital | embd.CapUART, DigitalLogical: 31},
&embd.PinDesc{ID: "P9_14", Aliases: []string{"50", "GPIO_50", "EHRPWM1A"}, Caps: embd.CapDigital | embd.CapPWM, DigitalLogical: 50},
&embd.PinDesc{ID: "P9_15", Aliases: []string{"48", "GPIO_48", "GPIO1_16"}, Caps: embd.CapDigital, DigitalLogical: 48},
&embd.PinDesc{ID: "P9_16", Aliases: []string{"51", "GPIO_51", "EHRPWM1B"}, Caps: embd.CapDigital | embd.CapPWM, DigitalLogical: 51},
&embd.PinDesc{ID: "P9_17", Aliases: []string{"5", "GPIO_5", "I2C1_SCL"}, Caps: embd.CapDigital | embd.CapI2C, DigitalLogical: 5},
&embd.PinDesc{ID: "P9_18", Aliases: []string{"4", "GPIO_4", "I2C1_SDA"}, Caps: embd.CapDigital | embd.CapI2C, DigitalLogical: 4},
&embd.PinDesc{ID: "P9_19", Aliases: []string{"13", "GPIO_13", "I2C2_SCL"}, Caps: embd.CapDigital | embd.CapI2C, DigitalLogical: 13},
&embd.PinDesc{ID: "P9_20", Aliases: []string{"12", "GPIO_12", "I2C2_SDA"}, Caps: embd.CapDigital | embd.CapI2C, DigitalLogical: 12},
&embd.PinDesc{ID: "P9_21", Aliases: []string{"3", "GPIO_3", "UART2_TXD"}, Caps: embd.CapDigital | embd.CapUART, DigitalLogical: 3},
&embd.PinDesc{ID: "P9_22", Aliases: []string{"2", "GPIO_2", "UART2_RXD"}, Caps: embd.CapDigital | embd.CapUART, DigitalLogical: 2},
&embd.PinDesc{ID: "P9_23", Aliases: []string{"49", "GPIO_49", "GPIO1_17"}, Caps: embd.CapDigital, DigitalLogical: 49},
&embd.PinDesc{ID: "P9_24", Aliases: []string{"15", "GPIO_15", "UART1_TXD"}, Caps: embd.CapDigital | embd.CapUART, DigitalLogical: 15},
&embd.PinDesc{ID: "P9_25", Aliases: []string{"117", "GPIO_117", "GPIO3_21"}, Caps: embd.CapDigital, DigitalLogical: 117},
&embd.PinDesc{ID: "P9_26", Aliases: []string{"14", "GPIO_14", "UART1_RXD"}, Caps: embd.CapDigital | embd.CapUART, DigitalLogical: 14},
&embd.PinDesc{ID: "P9_27", Aliases: []string{"115", "GPIO_115", "GPIO3_19"}, Caps: embd.CapDigital, DigitalLogical: 115},
&embd.PinDesc{ID: "P9_28", Aliases: []string{"113", "GPIO_113", "SPI1_CS0"}, Caps: embd.CapDigital | embd.CapSPI, DigitalLogical: 113},
&embd.PinDesc{ID: "P9_29", Aliases: []string{"111", "GPIO_111", "SPI1_D0"}, Caps: embd.CapDigital | embd.CapSPI, DigitalLogical: 111},
&embd.PinDesc{ID: "P9_30", Aliases: []string{"112", "GPIO_112", "SPI1_D1"}, Caps: embd.CapDigital | embd.CapSPI, DigitalLogical: 112},
&embd.PinDesc{ID: "P9_31", Aliases: []string{"110", "GPIO_110", "SPI1_SCLK"}, Caps: embd.CapDigital | embd.CapSPI, DigitalLogical: 110},
&embd.PinDesc{ID: "P9_32", Aliases: []string{"VADC"}},
&embd.PinDesc{ID: "P9_33", Aliases: []string{"4", "AIN4"}, Caps: embd.CapAnalog, AnalogLogical: 4},
&embd.PinDesc{ID: "P9_34", Aliases: []string{"AGND"}},
&embd.PinDesc{ID: "P9_35", Aliases: []string{"6", "AIN6"}, Caps: embd.CapAnalog, AnalogLogical: 6},
&embd.PinDesc{ID: "P9_36", Aliases: []string{"5", "AIN5"}, Caps: embd.CapAnalog, AnalogLogical: 5},
&embd.PinDesc{ID: "P9_37", Aliases: []string{"2", "AIN2"}, Caps: embd.CapAnalog, AnalogLogical: 2},
&embd.PinDesc{ID: "P9_38", Aliases: []string{"3", "AIN3"}, Caps: embd.CapAnalog, AnalogLogical: 3},
&embd.PinDesc{ID: "P9_39", Aliases: []string{"0", "AIN0"}, Caps: embd.CapAnalog, AnalogLogical: 0},
&embd.PinDesc{ID: "P9_40", Aliases: []string{"1", "AIN1"}, Caps: embd.CapAnalog, AnalogLogical: 1},
}
var ledMap = embd.LEDMap{
"beaglebone:green:usr0": []string{"0", "USR0", "usr0"},
"beaglebone:green:usr1": []string{"1", "USR1", "usr1"},
"beaglebone:green:usr2": []string{"2", "USR2", "usr2"},
"beaglebone:green:usr3": []string{"3", "USR3", "usr3"},
}
func ensureFeatureEnabled(id string) error {
pattern := "/sys/devices/bone_capemgr.*/slots"
file, err := embd.FindFirstMatchingFile(pattern)
if err != nil {
return err
}
bytes, err := ioutil.ReadFile(file)
if err != nil {
return err
}
str := string(bytes)
if strings.Contains(str, id) {
return nil
}
slots, err := os.OpenFile(file, os.O_WRONLY, os.ModeExclusive)
if err != nil {
return err
}
defer slots.Close()
_, err = slots.WriteString(id)
return err
}
// This cannot be currently used to disable things like the
// analog and pwm modules. Removing them from slots file can
// potentially cause a kernel panic and unsettle things. So the
// recommended thing to do is to simply reboot.
func ensureFeatureDisabled(id string) error {
pattern := "/sys/devices/bone_capemgr.*/slots"
file, err := embd.FindFirstMatchingFile(pattern)
if err != nil {
return err
}
slots, err := os.OpenFile(file, os.O_RDWR, os.ModeExclusive)
if err != nil {
return err
}
defer slots.Close()
scanner := bufio.NewScanner(slots)
for scanner.Scan() {
text := scanner.Text()
if !strings.Contains(text, id) {
continue
}
// Extract the id from the line
idx := strings.Index(text, ":")
if idx < 0 {
// Something is off, bail
continue
}
dis := strings.TrimSpace(text[:idx])
slots.Seek(0, 0)
_, err = slots.WriteString("-" + dis)
return err
}
// Could not disable the feature
return fmt.Errorf("embd: could not disable feature %q", id)
}
func init() {
embd.Register(embd.HostBBB, func(rev int) *embd.Descriptor {
return &embd.Descriptor{
GPIODriver: func() embd.GPIODriver {
return embd.NewGPIODriver(pins, generic.NewDigitalPin, newAnalogPin, newPWMPin)
},
I2CDriver: func() embd.I2CDriver {
return embd.NewI2CDriver(generic.NewI2CBus)
},
LEDDriver: func() embd.LEDDriver {
return embd.NewLEDDriver(ledMap, generic.NewLED)
},
}
})
}

261
host/bbb/pwmpin.go
Unescape Escape View File

@ -0,0 +1,261 @@
// PWM support on the BBB.
package bbb
import (
"errors"
"fmt"
"os"
"path"
"strconv"
"time"
"github.com/golang/glog"
"github.com/kidoman/embd"
"github.com/kidoman/embd/util"
)
const (
// PWMDefaultPolarity represents the default polarity (Positve or 1) for pwm.
PWMDefaultPolarity = embd.Positive
// PWMDefaultDuty represents the default duty (0ns) for pwm.
PWMDefaultDuty = 0
// PWMDefaultPeriod represents the default period (500000ns) for pwm. Equals 2000 Hz.
PWMDefaultPeriod = 500000
// PWMMaxPulseWidth represents the max period (1000000000ns) supported by pwm. Equals 1 Hz.
PWMMaxPulseWidth = 1000000000
)
type pwmPin struct {
n string
drv embd.GPIODriver
period int
polarity embd.Polarity
dutyf *os.File
periodf *os.File
polarityf *os.File
initialized bool
}
func newPWMPin(pd *embd.PinDesc, drv embd.GPIODriver) embd.PWMPin {
return &pwmPin{n: pd.ID, drv: drv}
}
func (p *pwmPin) N() string {
return p.n
}
func (p *pwmPin) id() string {
return "bone_pwm_" + p.n
}
func (p *pwmPin) init() error {
if p.initialized {
return nil
}
if err := p.ensurePWMEnabled(); err != nil {
return err
}
if err := p.ensurePinEnabled(); err != nil {
return err
}
basePath, err := p.basePath()
if err != nil {
return err
}
if err := p.ensurePeriodFileExists(basePath, 500*time.Millisecond); err != nil {
return err
}
if p.periodf, err = p.periodFile(basePath); err != nil {
return err
}
if p.dutyf, err = p.dutyFile(basePath); err != nil {
return err
}
if p.polarityf, err = p.polarityFile(basePath); err != nil {
return err
}
p.initialized = true
if err := p.reset(); err != nil {
return err
}
return nil
}
func (p *pwmPin) ensurePWMEnabled() error {
return ensureFeatureEnabled("am33xx_pwm")
}
func (p *pwmPin) ensurePinEnabled() error {
return ensureFeatureEnabled(p.id())
}
func (p *pwmPin) ensurePinDisabled() error {
return ensureFeatureDisabled(p.id())
}
func (p *pwmPin) basePath() (string, error) {
pattern := "/sys/devices/ocp.*/pwm_test_" + p.n + ".*"
return embd.FindFirstMatchingFile(pattern)
}
func (p *pwmPin) openFile(path string) (*os.File, error) {
return os.OpenFile(path, os.O_WRONLY, os.ModeExclusive)
}
func (p *pwmPin) ensurePeriodFileExists(basePath string, d time.Duration) error {
path := p.periodFilePath(basePath)
timeout := time.After(d)
for {
select {
case <-timeout:
return errors.New("embd: period file not found before timeout")
default:
if _, err := os.Stat(path); err == nil {
return nil
}
}
// We are looping, wait a bit.
time.Sleep(10 * time.Millisecond)
}
}
func (p *pwmPin) periodFilePath(basePath string) string {
return path.Join(basePath, "period")
}
func (p *pwmPin) periodFile(basePath string) (*os.File, error) {
return p.openFile(p.periodFilePath(basePath))
}
func (p *pwmPin) dutyFile(basePath string) (*os.File, error) {
return p.openFile(path.Join(basePath, "duty"))
}
func (p *pwmPin) polarityFile(basePath string) (*os.File, error) {
return p.openFile(path.Join(basePath, "polarity"))
}
func (p *pwmPin) SetPeriod(ns int) error {
if err := p.init(); err != nil {
return err
}
if ns > PWMMaxPulseWidth {
return fmt.Errorf("embd: pwm period for %v is out of bounds (must be =< %vns)", p.n, PWMMaxPulseWidth)
}
_, err := p.periodf.WriteString(strconv.Itoa(ns))
if err != nil {
return err
}
p.period = ns
return nil
}
func (p *pwmPin) SetDuty(ns int) error {
if err := p.init(); err != nil {
return err
}
if ns > PWMMaxPulseWidth {
return fmt.Errorf("embd: pwm duty %v for pin %v is out of bounds (must be =< %vns)", p.n, PWMMaxPulseWidth)
}
if ns > p.period {
return fmt.Errorf("embd: pwm duty %v for pin %v is greater than the period %v", ns, p.n, p.period)
}
_, err := p.dutyf.WriteString(strconv.Itoa(ns))
if err != nil {
return err
}
return nil
}
func (p *pwmPin) SetMicroseconds(us int) error {
if err := p.init(); err != nil {
return err
}
if p.period != 20000000 {
glog.Warningf("embd: pwm pin %v has freq %v hz. recommended 50 hz for servo mode", 1000000000/p.period)
}
duty := us * 1000 // in nanoseconds
if duty > p.period {
return fmt.Errorf("embd: calculated pwm duty %vns for pin %v (servo mode) is greater than the period %vns", duty, p.n, p.period)
}
return p.SetDuty(duty)
}
func (p *pwmPin) SetAnalog(value byte) error {
duty := util.Map(int64(value), 0, 255, 0, int64(p.period))
return p.SetDuty(int(duty))
}
func (p *pwmPin) SetPolarity(pol embd.Polarity) error {
if err := p.init(); err != nil {
return err
}
_, err := p.polarityf.WriteString(strconv.Itoa(int(pol)))
if err != nil {
return err
}
p.polarity = pol
return nil
}
func (p *pwmPin) reset() error {
if err := p.SetPolarity(embd.Positive); err != nil {
return err
}
if err := p.SetDuty(PWMDefaultDuty); err != nil {
return err
}
if err := p.SetPeriod(PWMDefaultPeriod); err != nil {
return err
}
return nil
}
func (p *pwmPin) Close() error {
if err := p.drv.Unregister(p.n); err != nil {
return err
}
if !p.initialized {
return nil
}
if err := p.reset(); err != nil {
return err
}
if err := p.ensurePinDisabled(); err != nil {
return err
}
p.initialized = false
return nil
}

26
host/bbb/pwmpin_test.go
Unescape Escape View File

@ -0,0 +1,26 @@
package bbb
import (
"testing"
"github.com/kidoman/embd"
)
func TestPWMPinClose(t *testing.T) {
pinMap := embd.PinMap{
&embd.PinDesc{ID: "P1_1", Aliases: []string{"1"}, Caps: embd.CapPWM},
}
driver := embd.NewGPIODriver(pinMap, nil, nil, newPWMPin)
pin, err := driver.PWMPin(1)
if err != nil {
t.Fatalf("Looking up pwm pin 1: got %v", err)
}
pin.Close()
pin2, err := driver.PWMPin(1)
if err != nil {
t.Fatalf("Looking up pwm pin 1: got %v", err)
}
if pin == pin2 {
t.Fatal("Looking up closed pwm pin 1: but got the old instance")
}
}

2
host/doc.go
Unescape Escape View File

@ -0,0 +1,2 @@
// Package host is a container for the various hosts supported by EMBD.
package host

20
digitalpin.go → host/generic/digitalpin.go
Unescape Escape View File

@ -2,7 +2,7 @@
// This driver requires kernel version 3.8+ and should work uniformly
// across all supported devices.
package embd
package generic
import (
"errors"
@ -11,13 +11,15 @@ import (
"path"
"strconv"
"time"
"github.com/kidoman/embd"
)
type digitalPin struct {
id string
n int
drv GPIODriver
drv embd.GPIODriver
dir *os.File
val *os.File
@ -28,7 +30,7 @@ type digitalPin struct {
initialized bool
}
func newDigitalPin(pd *PinDesc, drv GPIODriver) DigitalPin {
func NewDigitalPin(pd *embd.PinDesc, drv embd.GPIODriver) embd.DigitalPin {
return &digitalPin{id: pd.ID, n: pd.DigitalLogical, drv: drv, readBuf: make([]byte, 1)}
}
@ -100,13 +102,13 @@ func (p *digitalPin) activeLowFile() (*os.File, error) {
return p.openFile(path.Join(p.basePath(), "active_low"))
}
func (p *digitalPin) SetDirection(dir Direction) error {
func (p *digitalPin) SetDirection(dir embd.Direction) error {
if err := p.init(); err != nil {
return err
}
str := "in"
if dir == Out {
if dir == embd.Out {
str = "out"
}
_, err := p.dir.WriteString(str)
@ -138,7 +140,7 @@ var (
func (p *digitalPin) write(val int) error {
bytes := lowBytes
if val == High {
if val == embd.High {
bytes = highBytes
}
_, err := p.val.Write(bytes)
@ -158,9 +160,9 @@ func (p *digitalPin) TimePulse(state int) (time.Duration, error) {
return 0, err
}
aroundState := Low
if state == Low {
aroundState = High
aroundState := embd.Low
if state == embd.Low {
aroundState = embd.High
}
// Wait for any previous pulse to end

14
digitalpin_test.go → host/generic/digitalpin_test.go
Unescape Escape View File

@ -1,12 +1,16 @@
package embd
package generic
import "testing"
import (
"testing"
"github.com/kidoman/embd"
)
func TestDigitalPinClose(t *testing.T) {
pinMap := PinMap{
&PinDesc{ID: "P1_1", Aliases: []string{"1"}, Caps: CapDigital},
pinMap := embd.PinMap{
&embd.PinDesc{ID: "P1_1", Aliases: []string{"1"}, Caps: embd.CapDigital},
}
driver := newGPIODriver(pinMap, newDigitalPin, nil, nil)
driver := embd.NewGPIODriver(pinMap, NewDigitalPin, nil, nil)
pin, err := driver.DigitalPin(1)
if err != nil {
t.Fatalf("Looking up digital pin 1: got %v", err)

10
host/generic/doc.go
Unescape Escape View File

@ -0,0 +1,10 @@
/*
Package generic provides generic (to Linux) drivers for functionalities like
Digital I/O
I²C
LED control
They are used by the hosts to satiate the HAL.
*/
package generic

288
host/generic/i2cbus.go
Unescape Escape View File

@ -0,0 +1,288 @@
// I²C support.
package generic
import (
"fmt"
"os"
"reflect"
"sync"
"syscall"
"time"
"unsafe"
"github.com/kidoman/embd"
)
const (
delay = 20
slaveCmd = 0x0703 // Cmd to set slave address
rdrwCmd = 0x0707 // Cmd to read/write data together
rd = 0x0001
)
type i2c_msg struct {
addr uint16
flags uint16
len uint16
buf uintptr
}
type i2c_rdwr_ioctl_data struct {
msgs uintptr
nmsg uint32
}
type i2cBus struct {
l byte
file *os.File
addr byte
mu sync.Mutex
initialized bool
}
func NewI2CBus(l byte) embd.I2CBus {
return &i2cBus{l: l}
}
func (b *i2cBus) init() error {
if b.initialized {
return nil
}
var err error
if b.file, err = os.OpenFile(fmt.Sprintf("/dev/i2c-%v", b.l), os.O_RDWR, os.ModeExclusive); err != nil {
return err
}