spi

Documentation

Overview

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

Deprecated

This package is not maintained anymore. An actively supported cross-platform alternative is https://periph.io/.

Example

Example illustrates a program that drives an APA-102 LED strip.

package main

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

func main() {
	dev, err := spi.Open(&spi.Devfs{
		Dev:      "/dev/spidev0.1",
		Mode:     spi.Mode3,
		MaxSpeed: 500000,
	})
	if err != nil {
		panic(err)
	}
	defer dev.Close()

	if err := dev.Tx([]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

• Constants
• type Devfs
  • func (d *Devfs) Open() (driver.Conn, error)
• type Device
  • func Open(o driver.Opener) (*Device, error)
  • func (d *Device) Close() error
  • func (d *Device) SetBitOrder(o Order) error
  • func (d *Device) SetBitsPerWord(bits int) error
  • func (d *Device) SetCSChange(leaveEnabled bool) error
  • func (d *Device) SetDelay(t time.Duration) error
  • func (d *Device) SetMaxSpeed(speed int) error
  • func (d *Device) SetMode(mode Mode) error
  • func (d *Device) Tx(w, r []byte) error
• type Mode
• type Order

Examples

• Package

Constants

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

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

Types

type Devfs

type Devfs struct {
	// Dev is the device to be opened.
	// Device name is usually in the /dev/spidev<bus>.<chip> format.
	// Required.
	Dev string

	// 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 overridden by the device's driver.
	// Required.
	Mode Mode

	// MaxSpeed is the max clock speed (Hz) and can be overridden by the device's driver.
	// Required.
	MaxSpeed int64
}

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

func (*Devfs) Open

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

Open opens the provided device with the specified options and returns a connection.

type Device

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

func Open

func Open(o driver.Opener) (*Device, error)

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) SetCSChange

func (d *Device) SetCSChange(leaveEnabled bool) error

SetCSChange sets whether to leave the chipselect enabled after a Tx.

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 overridden 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) Tx

func (d *Device) Tx(w, r []byte) error

Tx performs a duplex transmission to write w to the SPI device and read len(r) bytes to r. User should not mutate the w and r 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 transferring words to the SPI device. MSB-first encoding is more popular than LSB-first.