embedded
/
devices
mirror of https://github.com/periph/devices
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

spi: rename variables 'bus' to 'port' where applicable (#143)

Browse Source 
As people like to copy paste code, make sure that the semantic of the variable
names is always relevant w.r.t. the object they refer to. In particular, do not
use 'bus' to refer to an spi.Port or spi.PortCloser, as this is blur the
distinction.

Also rename a few fooName to fooID.
pull/1/head
M-A 9 years ago committed by GitHub
parent 77af758e41
commit e1b4eec42a
10 changed files with 57 additions and 57 deletions
Show Stats Download Patch File Download Diff File

4
devices/apa102/apa102.go
Unescape Escape View File

@ -210,7 +210,7 @@ func ToRGB(p []color.NRGBA) []byte {
return b return b
} }
// Dev represents a strip of APA-102 LEDs as a strip connected over a SPI bus. // Dev represents a strip of APA-102 LEDs as a strip connected over a SPI port.
// It accepts a stream of raw RGB pixels and converts it to the full dynamic // It accepts a stream of raw RGB pixels and converts it to the full dynamic
// range as supported by APA102 protocol (nearly 8000:1 contrast ratio). // range as supported by APA102 protocol (nearly 8000:1 contrast ratio).
// //
@ -284,7 +284,7 @@ func (d *Dev) Halt() error {
// New returns a strip that communicates over SPI to APA102 LEDs. // New returns a strip that communicates over SPI to APA102 LEDs.
// //
// The SPI bus speed should be high, at least in the Mhz range, as // The SPI port speed should be high, at least in the Mhz range, as
// there's 32 bits sent per LED, creating a staggered effect. See // there's 32 bits sent per LED, creating a staggered effect. See
// https://cpldcpu.wordpress.com/2014/11/30/understanding-the-apa102-superled/ // https://cpldcpu.wordpress.com/2014/11/30/understanding-the-apa102-superled/
// //

12
devices/apa102/apa102_test.go
Unescape Escape View File

@ -552,18 +552,18 @@ func TestDrawRGBA(t *testing.T) {
} }
func TestHalt(t *testing.T) { func TestHalt(t *testing.T) {
bus := spitest.Playback{ s := spitest.Playback{
Playback: conntest.Playback{ Playback: conntest.Playback{
Ops: []conntest.IO{ Ops: []conntest.IO{
{W: []byte{0x0, 0x0, 0x0, 0x0, 0xe1, 0x0, 0x0, 0x0, 0xe1, 0x0, 0x0, 0x0, 0xe1, 0x0, 0x0, 0x0, 0xe1, 0x0, 0x0, 0x0, 0xff}}, {W: []byte{0x0, 0x0, 0x0, 0x0, 0xe1, 0x0, 0x0, 0x0, 0xe1, 0x0, 0x0, 0x0, 0xe1, 0x0, 0x0, 0x0, 0xe1, 0x0, 0x0, 0x0, 0xff}},
}, },
}, },
} }
d, _ := New(&bus, 4, 250, 5000) d, _ := New(&s, 4, 250, 5000)
if err := d.Halt(); err != nil { if err := d.Halt(); err != nil {
t.Fatal(err) t.Fatal(err)
} }
if err := bus.Close(); err != nil { if err := s.Close(); err != nil {
t.Fatal(err) t.Fatal(err)
} }
} }
@ -580,14 +580,14 @@ func TestInit(t *testing.T) {
// //
func Example() { func Example() {
bus, err := spireg.Open("") s, err := spireg.Open("")
if err != nil { if err != nil {
log.Fatalf("failed to open SPI: %v", err) log.Fatalf("failed to open SPI: %v", err)
} }
defer bus.Close() defer s.Close()
// Opens a strip of 150 lights are 50% intensity with color temperature at // Opens a strip of 150 lights are 50% intensity with color temperature at
// 5000 Kelvin. // 5000 Kelvin.
dev, err := New(bus, 150, 127, 5000) dev, err := New(s, 150, 127, 5000)
if err != nil { if err != nil {
log.Fatalf("failed to open apa102: %v", err) log.Fatalf("failed to open apa102: %v", err)
} }

2
devices/apa102/doc.go
Unescape Escape View File

@ -2,7 +2,7 @@
// Use of this source code is governed under the Apache License, Version 2.0 // Use of this source code is governed under the Apache License, Version 2.0
// that can be found in the LICENSE file. // that can be found in the LICENSE file.
// Package apa102 drives a strip of APA102 LEDs connected on a SPI bus. // Package apa102 drives a strip of APA102 LEDs connected on a SPI port.
// //
// These devices are interesting because they have 2 PWMs: one global of 5 bits // These devices are interesting because they have 2 PWMs: one global of 5 bits
// of resolution and one per channel of 8 bits of resolution. This means that // of resolution and one per channel of 8 bits of resolution. This means that

20
devices/bme280/bme280_test.go
Unescape Escape View File

@ -41,7 +41,7 @@ var calib = calibration{
} }
func TestSPISense_success(t *testing.T) { func TestSPISense_success(t *testing.T) {
bus := spitest.Playback{ s := spitest.Playback{
Playback: conntest.Playback{ Playback: conntest.Playback{
Ops: []conntest.IO{ Ops: []conntest.IO{
// Chipd ID detection. // Chipd ID detection.
@ -75,7 +75,7 @@ func TestSPISense_success(t *testing.T) {
Standby: S1s, Standby: S1s,
Filter: FOff, Filter: FOff,
} }
dev, err := NewSPI(&bus, &opts) dev, err := NewSPI(&s, &opts)
if err != nil { if err != nil {
t.Fatal(err) t.Fatal(err)
} }
@ -98,7 +98,7 @@ func TestSPISense_success(t *testing.T) {
if env.Humidity != 995 { if env.Humidity != 995 {
t.Fatalf("humidity %d", env.Humidity) t.Fatalf("humidity %d", env.Humidity)
} }
if err := bus.Close(); err != nil { if err := s.Close(); err != nil {
t.Fatal(err) t.Fatal(err)
} }
} }
@ -110,7 +110,7 @@ func TestNewSPI_fail(t *testing.T) {
} }
func TestNewSPI_fail_len(t *testing.T) { func TestNewSPI_fail_len(t *testing.T) {
bus := spitest.Playback{ s := spitest.Playback{
Playback: conntest.Playback{ Playback: conntest.Playback{
Ops: []conntest.IO{ Ops: []conntest.IO{
{ {
@ -122,18 +122,18 @@ func TestNewSPI_fail_len(t *testing.T) {
DontPanic: true, DontPanic: true,
}, },
} }
if dev, err := NewSPI(&bus, nil); dev != nil || err == nil { if dev, err := NewSPI(&s, nil); dev != nil || err == nil {
t.Fatal("read failed") t.Fatal("read failed")
} }
// The I/O didn't occur. // The I/O didn't occur.
bus.Count++ s.Count++
if err := bus.Close(); err != nil { if err := s.Close(); err != nil {
t.Fatal(err) t.Fatal(err)
} }
} }
func TestNewSPI_fail_chipid(t *testing.T) { func TestNewSPI_fail_chipid(t *testing.T) {
bus := spitest.Playback{ s := spitest.Playback{
Playback: conntest.Playback{ Playback: conntest.Playback{
Ops: []conntest.IO{ Ops: []conntest.IO{
{ {
@ -144,10 +144,10 @@ func TestNewSPI_fail_chipid(t *testing.T) {
}, },
}, },
} }
if dev, err := NewSPI(&bus, nil); dev != nil || err == nil { if dev, err := NewSPI(&s, nil); dev != nil || err == nil {
t.Fatal("read failed") t.Fatal("read failed")
} }
if err := bus.Close(); err != nil { if err := s.Close(); err != nil {
t.Fatal(err) t.Fatal(err)
} }
} }

18
devices/bme280/bme280smoketest/bme280smoketest.go
Unescape Escape View File

@ -38,12 +38,12 @@ func (s *SmokeTest) Description() string {
// Run implements the SmokeTest interface. // Run implements the SmokeTest interface.
func (s *SmokeTest) Run(args []string) (err error) { func (s *SmokeTest) Run(args []string) (err error) {
f := flag.NewFlagSet("buses", flag.ExitOnError) f := flag.NewFlagSet("buses", flag.ExitOnError)
i2cName := f.String("i2c", "", "I²C bus to use") i2cID := f.String("i2c", "", "I²C bus to use")
spiName := f.String("spi", "", "SPI bus to use") spiID := f.String("spi", "", "SPI port to use")
record := f.Bool("r", false, "record operation (for playback unit testing)") record := f.Bool("r", false, "record operation (for playback unit testing)")
f.Parse(args) f.Parse(args)
i2cBus, err2 := i2creg.Open(*i2cName) i2cBus, err2 := i2creg.Open(*i2cID)
if err2 != nil { if err2 != nil {
return err2 return err2
} }
@ -53,21 +53,21 @@ func (s *SmokeTest) Run(args []string) (err error) {
} }
}() }()
spiBus, err2 := spireg.Open(*spiName) spiPort, err2 := spireg.Open(*spiID)
if err2 != nil { if err2 != nil {
return err2 return err2
} }
defer func() { defer func() {
if err2 := spiBus.Close(); err == nil { if err2 := spiPort.Close(); err == nil {
err = err2 err = err2
} }
}() }()
if !*record { if !*record {
return run(i2cBus, spiBus) return run(i2cBus, spiPort)
} }
i2cRecorder := i2ctest.Record{Bus: i2cBus} i2cRecorder := i2ctest.Record{Bus: i2cBus}
spiRecorder := spitest.Record{Port: spiBus} spiRecorder := spitest.Record{Port: spiPort}
err = run(&i2cRecorder, &spiRecorder) err = run(&i2cRecorder, &spiRecorder)
if len(i2cRecorder.Ops) != 0 { if len(i2cRecorder.Ops) != 0 {
fmt.Printf("I²C recorder Addr: 0x%02X\n", i2cRecorder.Ops[0].Addr) fmt.Printf("I²C recorder Addr: 0x%02X\n", i2cRecorder.Ops[0].Addr)
@ -119,7 +119,7 @@ func (s *SmokeTest) Run(args []string) (err error) {
return err return err
} }
func run(i2cBus i2c.Bus, spiBus spi.PortCloser) (err error) { func run(i2cBus i2c.Bus, spiPort spi.PortCloser) (err error) {
opts := &bme280.Opts{ opts := &bme280.Opts{
Temperature: bme280.O16x, Temperature: bme280.O16x,
Pressure: bme280.O16x, Pressure: bme280.O16x,
@ -138,7 +138,7 @@ func run(i2cBus i2c.Bus, spiBus spi.PortCloser) (err error) {
} }
}() }()
spiDev, err2 := bme280.NewSPI(spiBus, opts) spiDev, err2 := bme280.NewSPI(spiPort, opts)
if err2 != nil { if err2 != nil {
return err2 return err2
} }

4
devices/lepton/lepton_test.go
Unescape Escape View File

@ -199,7 +199,7 @@ func TestReadImg_fail_Tx(t *testing.T) {
t.Fatal(err) t.Fatal(err)
} }
if _, err := d.ReadImg(); err == nil { if _, err := d.ReadImg(); err == nil {
t.Fatal("spi bus Tx failed") t.Fatal("spi port Tx failed")
} }
if err := i.Close(); err != nil { if err := i.Close(); err != nil {
t.Fatal(err) t.Fatal(err)
@ -214,7 +214,7 @@ func TestReadImg_fail_OUt(t *testing.T) {
t.Fatal(err) t.Fatal(err)
} }
if _, err := d.ReadImg(); err == nil { if _, err := d.ReadImg(); err == nil {
t.Fatal("spi bus Tx failed") t.Fatal("spi port Tx failed")
} }
if err := i.Close(); err != nil { if err := i.Close(); err != nil {
t.Fatal(err) t.Fatal(err)

4
devices/ssd1306/ssd1306.go
Unescape Escape View File

@ -149,8 +149,8 @@ func NewI2C(i i2c.Bus, w, h int, rotated bool) (*Dev, error) {
return newDev(&i2c.Dev{Bus: i, Addr: 0x3C}, w, h, rotated, false, nil) return newDev(&i2c.Dev{Bus: i, Addr: 0x3C}, w, h, rotated, false, nil)
} }
// newDev is the common initialization code that is independent of the bus // newDev is the common initialization code that is independent of the
// being used. // communication protocol (I²C or SPI) being used.
func newDev(c conn.Conn, w, h int, rotated, usingSPI bool, dc gpio.PinOut) (*Dev, error) { func newDev(c conn.Conn, w, h int, rotated, usingSPI bool, dc gpio.PinOut) (*Dev, error) {
if w < 8 || w > 128 || w&7 != 0 { if w < 8 || w > 128 || w&7 != 0 {
return nil, fmt.Errorf("ssd1306: invalid width %d", w) return nil, fmt.Errorf("ssd1306: invalid width %d", w)

24
devices/ssd1306/ssd1306_test.go
Unescape Escape View File

@ -420,12 +420,12 @@ func TestSPI_3wire(t *testing.T) {
} }
func TestSPI_4wire_String(t *testing.T) { func TestSPI_4wire_String(t *testing.T) {
bus := spitest.Playback{ port := spitest.Playback{
Playback: conntest.Playback{ Playback: conntest.Playback{
Ops: []conntest.IO{{W: getInitCmd(128, 64, false)}}, Ops: []conntest.IO{{W: getInitCmd(128, 64, false)}},
}, },
} }
dev, err := NewSPI(&bus, &gpiotest.Pin{N: "pin1", Num: 42}, 128, 64, false) dev, err := NewSPI(&port, &gpiotest.Pin{N: "pin1", Num: 42}, 128, 64, false)
if err != nil { if err != nil {
t.Fatal(err) t.Fatal(err)
} }
@ -433,7 +433,7 @@ func TestSPI_4wire_String(t *testing.T) {
if s := dev.String(); s != expected { if s := dev.String(); s != expected {
t.Fatalf("%q != %q", expected, s) t.Fatalf("%q != %q", expected, s)
} }
if err := bus.Close(); err != nil { if err := port.Close(); err != nil {
t.Fatal(err) t.Fatal(err)
} }
} }
@ -444,7 +444,7 @@ func TestSPI_4wire_Write_differential(t *testing.T) {
buf2 := make([]byte, 128) buf2 := make([]byte, 128)
buf2[130-128] = 1 buf2[130-128] = 1
buf2[131-128] = 2 buf2[131-128] = 2
bus := spitest.Playback{ port := spitest.Playback{
Playback: conntest.Playback{ Playback: conntest.Playback{
Ops: []conntest.IO{ Ops: []conntest.IO{
{W: getInitCmd(128, 64, false)}, {W: getInitCmd(128, 64, false)},
@ -455,7 +455,7 @@ func TestSPI_4wire_Write_differential(t *testing.T) {
}, },
}, },
} }
dev, err := NewSPI(&bus, &gpiotest.Pin{N: "pin1", Num: 42}, 128, 64, false) dev, err := NewSPI(&port, &gpiotest.Pin{N: "pin1", Num: 42}, 128, 64, false)
if err != nil { if err != nil {
t.Fatal(err) t.Fatal(err)
} }
@ -468,7 +468,7 @@ func TestSPI_4wire_Write_differential(t *testing.T) {
if n, err := dev.Write(pix); n != len(pix) || err != nil { if n, err := dev.Write(pix); n != len(pix) || err != nil {
t.Fatal(n, err) t.Fatal(n, err)
} }
if err := bus.Close(); err != nil { if err := port.Close(); err != nil {
t.Fatal(err) t.Fatal(err)
} }
} }
@ -476,7 +476,7 @@ func TestSPI_4wire_Write_differential(t *testing.T) {
func TestSPI_4wire_Write_differential_fail(t *testing.T) { func TestSPI_4wire_Write_differential_fail(t *testing.T) {
buf1 := make([]byte, 1024) buf1 := make([]byte, 1024)
buf1[130] = 1 buf1[130] = 1
bus := spitest.Playback{ port := spitest.Playback{
Playback: conntest.Playback{ Playback: conntest.Playback{
Ops: []conntest.IO{ Ops: []conntest.IO{
{W: getInitCmd(128, 64, false)}, {W: getInitCmd(128, 64, false)},
@ -485,7 +485,7 @@ func TestSPI_4wire_Write_differential_fail(t *testing.T) {
DontPanic: true, DontPanic: true,
}, },
} }
dev, err := NewSPI(&bus, &gpiotest.Pin{N: "pin1", Num: 42}, 128, 64, false) dev, err := NewSPI(&port, &gpiotest.Pin{N: "pin1", Num: 42}, 128, 64, false)
if err != nil { if err != nil {
t.Fatal(err) t.Fatal(err)
} }
@ -498,19 +498,19 @@ func TestSPI_4wire_Write_differential_fail(t *testing.T) {
if n, err := dev.Write(pix); n != 0 || !conntest.IsErr(err) { if n, err := dev.Write(pix); n != 0 || !conntest.IsErr(err) {
t.Fatalf("expected conntest error: %v", err) t.Fatalf("expected conntest error: %v", err)
} }
if err := bus.Close(); err != nil { if err := port.Close(); err != nil {
t.Fatal(err) t.Fatal(err)
} }
} }
func TestSPI_4wire_gpio_fail(t *testing.T) { func TestSPI_4wire_gpio_fail(t *testing.T) {
bus := spitest.Playback{ port := spitest.Playback{
Playback: conntest.Playback{ Playback: conntest.Playback{
Ops: []conntest.IO{{W: getInitCmd(128, 64, false)}}, Ops: []conntest.IO{{W: getInitCmd(128, 64, false)}},
}, },
} }
pin := &failPin{fail: false} pin := &failPin{fail: false}
dev, err := NewSPI(&bus, pin, 128, 64, false) dev, err := NewSPI(&port, pin, 128, 64, false)
if err != nil { if err != nil {
t.Fatal(err) t.Fatal(err)
} }
@ -522,7 +522,7 @@ func TestSPI_4wire_gpio_fail(t *testing.T) {
if err := dev.Halt(); err == nil || err.Error() != "injected error" { if err := dev.Halt(); err == nil || err.Error() != "injected error" {
t.Fatalf("expected gpio error: %v", err) t.Fatalf("expected gpio error: %v", err)
} }
if err := bus.Close(); err != nil { if err := port.Close(); err != nil {
t.Fatal(err) t.Fatal(err)
} }
} }

18
devices/ssd1306/ssd1306smoketest/ssd1306smoketest.go
Unescape Escape View File

@ -57,8 +57,8 @@ func (s *SmokeTest) Run(args []string) (err error) {
s.delay = 2 * time.Second s.delay = 2 * time.Second
f := flag.NewFlagSet("buses", flag.ExitOnError) f := flag.NewFlagSet("buses", flag.ExitOnError)
i2cName := f.String("i2c", "", "I²C bus to use") i2cID := f.String("i2c", "", "I²C bus to use")
spiName := f.String("spi", "", "SPI bus to use") spiID := f.String("spi", "", "SPI port to use")
dcName := f.String("dc", "", "DC pin to use in 4-wire SPI mode") dcName := f.String("dc", "", "DC pin to use in 4-wire SPI mode")
w := f.Int("w", 128, "Display width") w := f.Int("w", 128, "Display width")
@ -68,7 +68,7 @@ func (s *SmokeTest) Run(args []string) (err error) {
record := f.Bool("record", false, "record operation (for playback unit testing)") record := f.Bool("record", false, "record operation (for playback unit testing)")
f.Parse(args) f.Parse(args)
i2cBus, err2 := i2creg.Open(*i2cName) i2cBus, err2 := i2creg.Open(*i2cID)
if err2 != nil { if err2 != nil {
return err2 return err2
} }
@ -78,12 +78,12 @@ func (s *SmokeTest) Run(args []string) (err error) {
} }
}() }()
spiBus, err2 := spireg.Open(*spiName) spiPort, err2 := spireg.Open(*spiID)
if err2 != nil { if err2 != nil {
return err2 return err2
} }
defer func() { defer func() {
if err2 := spiBus.Close(); err == nil { if err2 := spiPort.Close(); err == nil {
err = err2 err = err2
} }
}() }()
@ -93,11 +93,11 @@ func (s *SmokeTest) Run(args []string) (err error) {
dc = gpioreg.ByName(*dcName) dc = gpioreg.ByName(*dcName)
} }
if !*record { if !*record {
return s.run(i2cBus, spiBus, dc, *w, *h, *rotated) return s.run(i2cBus, spiPort, dc, *w, *h, *rotated)
} }
i2cRecorder := i2ctest.Record{Bus: i2cBus} i2cRecorder := i2ctest.Record{Bus: i2cBus}
spiRecorder := spitest.Record{Port: spiBus} spiRecorder := spitest.Record{Port: spiPort}
err = s.run(&i2cRecorder, &spiRecorder, dc, *w, *h, *rotated) err = s.run(&i2cRecorder, &spiRecorder, dc, *w, *h, *rotated)
if len(i2cRecorder.Ops) != 0 { if len(i2cRecorder.Ops) != 0 {
fmt.Printf("I²C recorder Addr: 0x%02X\n", i2cRecorder.Ops[0].Addr) fmt.Printf("I²C recorder Addr: 0x%02X\n", i2cRecorder.Ops[0].Addr)
@ -149,7 +149,7 @@ func (s *SmokeTest) Run(args []string) (err error) {
return err return err
} }
func (s *SmokeTest) run(i2cBus i2c.Bus, spiBus spi.PortCloser, dc gpio.PinOut, w, h int, rotated bool) (err error) { func (s *SmokeTest) run(i2cBus i2c.Bus, spiPort spi.PortCloser, dc gpio.PinOut, w, h int, rotated bool) (err error) {
s.timings = make([]time.Duration, 2) s.timings = make([]time.Duration, 2)
start := time.Now() start := time.Now()
i2cDev, err2 := ssd1306.NewI2C(i2cBus, w, h, rotated) i2cDev, err2 := ssd1306.NewI2C(i2cBus, w, h, rotated)
@ -158,7 +158,7 @@ func (s *SmokeTest) run(i2cBus i2c.Bus, spiBus spi.PortCloser, dc gpio.PinOut, w
return err2 return err2
} }
start = time.Now() start = time.Now()
spiDev, err2 := ssd1306.NewSPI(spiBus, dc, w, h, rotated) spiDev, err2 := ssd1306.NewSPI(spiPort, dc, w, h, rotated)
s.timings[1] = time.Since(start) s.timings[1] = time.Since(start)
if err2 != nil { if err2 != nil {
return err2 return err2

8
experimental/devices/bitbang/spi.go
Unescape Escape View File

@ -31,7 +31,7 @@ type SPI struct {
csn gpio.PinOut // CS csn gpio.PinOut // CS
mu sync.Mutex mu sync.Mutex
maxHzBus int64 maxHzPort int64
maxHzDev int64 maxHzDev int64
mode spi.Mode mode spi.Mode
bits int bits int
@ -60,8 +60,8 @@ func (s *SPI) LimitSpeed(maxHz int64) error {
} }
s.mu.Lock() s.mu.Lock()
defer s.mu.Unlock() defer s.mu.Unlock()
s.maxHzBus = maxHz s.maxHzPort = maxHz
if s.maxHzDev == 0 || s.maxHzBus < s.maxHzDev { if s.maxHzDev == 0 || s.maxHzPort < s.maxHzDev {
s.halfCycle = time.Second / time.Duration(maxHz) / time.Duration(2) s.halfCycle = time.Second / time.Duration(maxHz) / time.Duration(2)
} }
return nil return nil
@ -78,7 +78,7 @@ func (s *SPI) DevParams(maxHz int64, mode spi.Mode, bits int) error {
s.mu.Lock() s.mu.Lock()
defer s.mu.Unlock() defer s.mu.Unlock()
s.maxHzDev = maxHz s.maxHzDev = maxHz
if s.maxHzDev != 0 && (s.maxHzBus == 0 || s.maxHzDev < s.maxHzBus) { if s.maxHzDev != 0 && (s.maxHzPort == 0 || s.maxHzDev < s.maxHzPort) {
s.halfCycle = time.Second / time.Duration(maxHz) / time.Duration(2) s.halfCycle = time.Second / time.Duration(maxHz) / time.Duration(2)
} }
s.mode = mode s.mode = mode

Write Preview
Loading…
Cancel
Save