package spi

import "golang.org/x/exp/io/spi"

Package spi allows users to read from and write to an SPI device.

dev, err := spi.Open(&spi.Devfs{}, 0, 1, spi.Mode3, 500000) // opens /dev/spidev0.1.
if err != nil {
    panic(err)
}
defer dev.Close()

if err := dev.Transfer([]byte{
    0, 0, 0, 0,
    0xff, 200, 0, 200,
    0xff, 200, 0, 200,
    0xe0, 200, 0, 200,
    0xff, 200, 0, 200,
    0xff, 8, 50, 0,
    0xff, 200, 0, 0,
    0xff, 0, 0, 0,
    0xff, 200, 0, 200,
    0xff, 0xff, 0xff, 0xff,
    0xff, 0xff, 0xff, 0xff,
    0xff, 0xff, 0xff, 0xff,
    0xff, 0xff, 0xff, 0xff,
}, nil); err != nil {
    panic(err)
}

Index ¶

Examples ¶

• package

Package Files ¶

devfs.go spi.go

Constants ¶

const (
    Mode0 = Mode(0)
    Mode1 = Mode(1)
    Mode2 = Mode(2)
    Mode3 = Mode(3)
)

const (
    MSBFirst = Order(0)
    LSBFirst = Order(1)
)

type Devfs ¶

type Devfs struct{}

Devfs is an SPI driver that works against the devfs. You need to load the "spidev" module to use this driver.

func (*Devfs) Open ¶

func (d *Devfs) Open(bus, chip int) (driver.Conn, error)

Open Devfs /dev/spidev<bus>.<chip> and returns a connection.

type Device ¶

type Device struct {
    // contains filtered or unexported fields
}

func Open ¶

func Open(o driver.Opener, bus, cs int, mode Mode, speed int) (*Device, error)

Open opens a device with the specified bus and chip select by using the given driver. If a nil driver is provided, the default driver (devfs) is used. Mode is the SPI mode. SPI mode is a combination of polarity and phases. CPOL is the high order bit, CPHA is the low order. Pre-computed mode values are Mode0, Mode1, Mode2 and Mode3. The value of the mode argument can be overriden by the device's driver. Speed is the max clock speed (Hz) and can be overriden by the device's driver.

func (*Device) Close ¶

func (d *Device) Close() error

Close closes the SPI device and releases the related resources.

func (*Device) SetBitOrder ¶

func (d *Device) SetBitOrder(o Order) error

SetBitOrder sets the bit justification used to transfer SPI words. Valid values are MSBFirst and LSBFirst.

func (*Device) SetBitsPerWord ¶

func (d *Device) SetBitsPerWord(bits int) error

SetBitsPerWord sets how many bits it takes to represent a word, e.g. 8 represents 8-bit words. The default is 8 bits per word.

func (*Device) SetDelay ¶

func (d *Device) SetDelay(t time.Duration) error

SetDelay sets the amount of pause will be added after each frame write.

func (*Device) SetMaxSpeed ¶

func (d *Device) SetMaxSpeed(speed int) error

SetMaxSpeed sets the maximum clock speed in Hz. The value can be overriden by SPI device's driver.

func (*Device) SetMode ¶

func (d *Device) SetMode(mode Mode) error

SetMode sets the SPI mode. SPI mode is a combination of polarity and phases. CPOL is the high order bit, CPHA is the low order. Pre-computed mode values are Mode0, Mode1, Mode2 and Mode3. The value can be changed by SPI device's driver.

func (*Device) Transfer ¶

func (d *Device) Transfer(tx, rx []byte) error

Transfer performs a duplex transmission to write to the SPI device and read len(rx) bytes to rx. User should not mutate the tx and rx until this call returns.

type Mode ¶

type Mode int

Mode represents the SPI mode number where clock parity (CPOL) is the high order and clock edge (CPHA) is the low order bit.

type Order ¶

type Order int

Order is the bit justification to be used while transfering words to the SPI device. MSB-first encoding is more popular than LSB-first.

Directories ¶