gpioutil

Documentation

Overview

Package gpioutil includes utilities to filter or augment GPIOs.

Example

package main

import (
	"fmt"
	"log"
	"time"

	"periph.io/x/conn/v3/driver/driverreg"
	"periph.io/x/conn/v3/gpio"
	"periph.io/x/conn/v3/gpio/gpioreg"
	"periph.io/x/conn/v3/gpio/gpioutil"
	"periph.io/x/conn/v3/physic"
)

func main() {
	// Make sure periph is initialized.
	// TODO: Use host.Init(). It is not used in this example to prevent circular
	// go package import.
	if _, err := driverreg.Init(); err != nil {
		log.Fatal(err)
	}

	// Complete solution:
	// - Fallback to software polling if the GPIO doesn't support hardware edge
	//   detection.
	// - Denoise and debounce the reading.
	//
	// Order is important, as Debounce() requires working edge detection.
	p := gpioreg.ByName("XOI-P1")
	if p != nil {
		log.Fatal("please open another GPIO")
	}
	if err := p.In(gpio.PullDown, gpio.BothEdges); err == nil {
		// Try to fallback into software polling, then reinitialize.
		p = gpioutil.PollEdge(p, 50*physic.Hertz)
		if err = p.In(gpio.PullDown, gpio.BothEdges); err != nil {
			log.Fatal(err)
		}
	}

	// Ignore glitches lasting less than 10ms, and ignore repeated edges within
	// 30ms. Make sure to not use denoiser period lower than the software poller
	// frequency.
	d, err := gpioutil.Debounce(p, 10*time.Millisecond, 30*time.Millisecond, gpio.BothEdges)
	if err != nil {
		log.Fatal(err)
	}

	defer d.Halt()
	for {
		if d.WaitForEdge(-1) {
			fmt.Println(d.Read())
		}
	}
}

Index

• func Debounce(p gpio.PinIO, denoise, debounce time.Duration, edge gpio.Edge) (gpio.PinIO, error)
• func PollEdge(p gpio.PinIO, freq physic.Frequency) gpio.PinIO

Examples

• Package
• Debounce
• PollEdge

Functions

func Debounce

func Debounce(p gpio.PinIO, denoise, debounce time.Duration, edge gpio.Edge) (gpio.PinIO, error)

Debounce returns a debounced gpio.PinIO from a gpio.PinIO source. Only the PinIn behavior is mutated.

denoise is a noise filter, which waits a pin to be steady for this amount of time BEFORE reporting the new level.

debounce will lock on a level for this amount of time AFTER the pin changed state, ignoring following state changes.

Either value can be 0.

Example

package main

import (
	"fmt"
	"log"
	"time"

	"periph.io/x/conn/v3/driver/driverreg"
	"periph.io/x/conn/v3/gpio"
	"periph.io/x/conn/v3/gpio/gpioreg"
	"periph.io/x/conn/v3/gpio/gpioutil"
)

func main() {
	// Make sure periph is initialized.
	// TODO: Use host.Init(). It is not used in this example to prevent circular
	// go package import.
	if _, err := driverreg.Init(); err != nil {
		log.Fatal(err)
	}

	p := gpioreg.ByName("GPIO16")
	if p != nil {
		log.Fatal("please open another GPIO")
	}

	// Ignore glitches lasting less than 3ms, and ignore repeated edges within
	// 30ms.
	d, err := gpioutil.Debounce(p, 3*time.Millisecond, 30*time.Millisecond, gpio.BothEdges)
	if err != nil {
		log.Fatal(err)
	}

	defer d.Halt()
	for {
		if d.WaitForEdge(-1) {
			fmt.Println(d.Read())
		}
	}
}

func PollEdge

func PollEdge(p gpio.PinIO, freq physic.Frequency) gpio.PinIO

PollEdge returns a gpio.PinIO which implements edge detection via polling.

Example of GPIOs without edge detection are GPIOs accessible over an I²C chip or over USB.

freq must be above 0. A reasonable value is 20Hz reading. High rate essentially means a busy loop.

Example

package main

import (
	"fmt"
	"log"

	"periph.io/x/conn/v3/driver/driverreg"
	"periph.io/x/conn/v3/gpio"
	"periph.io/x/conn/v3/gpio/gpioreg"
	"periph.io/x/conn/v3/gpio/gpioutil"
	"periph.io/x/conn/v3/physic"
)

func main() {
	// Make sure periph is initialized.
	// TODO: Use host.Init(). It is not used in this example to prevent circular
	// go package import.
	if _, err := driverreg.Init(); err != nil {
		log.Fatal(err)
	}

	// Flow when it is known that the GPIO does not support edge detection.
	p := gpioreg.ByName("XOI-P1")
	if p != nil {
		log.Fatal("please open another GPIO")
	}
	p = gpioutil.PollEdge(p, 20*physic.Hertz)
	if err := p.In(gpio.PullDown, gpio.RisingEdge); err != nil {
		log.Fatal(err)
	}

	defer p.Halt()
	for {
		if p.WaitForEdge(-1) {
			fmt.Println(p.Read())
		}
	}
}