rpio

func Close ¶

func Close() error

Close unmaps GPIO memory

func DetectEdge ¶

func DetectEdge(pin Pin, edge Edge)

DetectEdge: Enable edge event detection on pin.

Combine with pin.EdgeDetected() to check whether event occured.

Note that using this function might conflict with the same functionality of other gpio library.

It also clears previously detected event of this pin if there was any.

Note that call with RiseEdge will disable previously set FallEdge detection and vice versa. You have to call with AnyEdge, to enable detection for both edges. To disable previously enabled detection call it with NoEdge.

WARNING: this might make your Pi unresponsive, if this happens, you should either run the code as root, or add `dtoverlay=gpio-no-irq` to `/boot/config.txt` and restart your pi,

func DisableIRQs ¶

func DisableIRQs(irqs uint64)

DisableIRQs: Disables given IRQs (by setting bit to 1 at intended position). See 'ARM peripherals interrupts table' in pheripherals datasheet. WARNING: you can corrupt your system, only use this if you know what you are doing.

func EdgeDetected ¶

func EdgeDetected(pin Pin) bool

EdgeDetected checks whether edge event occured since last call or since detection was enabled

There is no way (yet) to handle interruption caused by edge event, you have to use polling.

Event detection has to be enabled first, by pin.Detect(edge)

func EnableIRQs ¶

func EnableIRQs(irqs uint64)

EnableIRQs: Enables given IRQs (by setting bit to 1 at intended position). See 'ARM peripherals interrupts table' in pheripherals datasheet. WARNING: you can corrupt your system, only use this if you know what you are doing.

func Open ¶

func Open() (err error)

Open and memory map GPIO memory range from /dev/mem . Some reflection magic is used to convert it to a unsafe []uint32 pointer

func PinMode ¶

func PinMode(pin Pin, mode Mode)

PinMode sets the mode of a given pin (Input, Output, Clock, Pwm or Spi)

Clock is possible only for pins 4, 5, 6, 20, 21. Pwm is possible only for pins 12, 13, 18, 19.

Spi mode should not be set by this directly, use SpiBegin instead.

func PullMode ¶

func PullMode(pin Pin, pull Pull)

func SetDutyCycle ¶

func SetDutyCycle(pin Pin, dutyLen, cycleLen uint32)

SetDutyCycle: Set cycle length (range) and duty length (data) for Pwm pin in M/S mode

 |<- duty ->|
  __________
_/          \_____________/
 |<------- cycle -------->|

Output frequency is computed as pwm clock frequency divided by cycle length. So, to set Pwm pin to freqency 38kHz with duty cycle 1/4, use this combination:

pin.Pwm()
pin.DutyCycle(1, 4)
pin.Freq(38000*4)

Note that some pins share common pwm channel, so calling this function will set same duty cycle for all pins belonging to channel. The channels are:

channel 1 (pwm0) for pins 12, 18, 40
channel 2 (pwm1) for pins 13, 19, 41, 45.

func SetFreq ¶

func SetFreq(pin Pin, freq int)

SetFreq: Set clock speed for given pin in Clock or Pwm mode

Param freq should be in range 4688Hz - 19.2MHz to prevent unexpected behavior, however output frequency of Pwm pins can be further adjusted with SetDutyCycle. So for smaller frequencies use Pwm pin with large cycle range. (Or implement custom software clock using output pin and sleep.)

Note that some pins share the same clock source, it means that changing frequency for one pin will change it also for all pins within a group. The groups are:

gp_clk0: pins 4, 20, 32, 34
gp_clk1: pins 5, 21, 42, 44
gp_clk2: pins 6 and 43
pwm_clk: pins 12, 13, 18, 19, 40, 41, 45

func SpiBegin ¶

func SpiBegin(dev SpiDev) error

SpiBegin: Sets all pins of given SPI device to SPI mode

dev\pin | CE0 | CE1 | CE2 | SCLK | MOSI | MISO |
Spi0    |   7 |   8 |   - |    9 |   10 |   11 |
Spi1    |  16 |  17 |  18 |   19 |   20 |   21 |
Spi2    |  40 |  41 |  42 |   43 |   44 |   45 |

It also resets SPI control register.

Note that you should disable SPI interface in raspi-config first!

err := SpiBegin(Spi0) // pins 7 to 11
if err != nil {
	panic(err)
}

// any Spi functions must go there...
SpiTransmit(42)

SpiEnd(Spi0)

Output:

func SpiChipSelect ¶

func SpiChipSelect(chip uint8)

SpiChipSelect: Select chip, one of 0, 1, 2 for selecting slave on CE0, CE1, or CE2 pin

func SpiChipSelectPolarity ¶

func SpiChipSelectPolarity(chip uint8, polarity uint8)

SpiChipSelectPolarity: Sets polarity (0/1) of active chip select default active=0

func SpiEnd ¶

func SpiEnd(dev SpiDev)

SpiEnd: Sets SPI pins of given device to default (Input) mode. See SpiBegin.

func SpiExchange ¶

func SpiExchange(data []byte)

SpiExchange: Transmit all bytes in data to slave and simultaneously receives bytes from slave to data.

If you want to only send or only receive, use SpiTransmit/SpiReceive

func SpiMode ¶

func SpiMode(polarity uint8, phase uint8)

SpiMode: Set polarity (0/1) and phase (0/1) of spi clock default polarity=0; phase=0

func SpiReceive ¶

func SpiReceive(n int) []byte

SpiReceive receives n bytes from slave.

Note that n zeroed bytes are send to slave as side effect.

func SpiSpeed ¶

func SpiSpeed(speed int)

SpiSpeed: Set (maximal) speed [Hz] of SPI clock. Param speed may be as big as 125MHz in theory, but only values up to 31.25MHz are considered relayable.

func SpiTransmit ¶

func SpiTransmit(data ...byte)

SpiTransmit takes one or more bytes and send them to slave.

Data received from slave are ignored. Use spread operator to send slice of bytes.

SpiTransmit(0xFF)             // send single byte
SpiTransmit(0xDE, 0xAD, 0xBE) // send several bytes

data := []byte{'H', 'e', 'l', 'l', 'o', 0}
SpiTransmit(data...) // send slice of bytes

Output:

func StartPwm ¶

func StartPwm()

StartPwm starts pwm for both channels

func StopPwm ¶

func StopPwm()

StopPwm: Stop pwm for both channels

func TogglePin ¶

func TogglePin(pin Pin)

TogglePin: Toggle a pin state (high -> low -> high)

func WritePin ¶

func WritePin(pin Pin, state State)

WritePin sets a given pin High or Low by setting the clear or set registers respectively