undo epd2in66b Configure method deletion

* si5351: add support for si5351

Adds support for the si5351 I2C programmable clock generator using code
from @chiefMarlin which used code from @conotto which somehow never got merged.

Thank you everyone!

Signed-off-by: deadprogram <ron@hybridgroup.com>

* refactor: use regmap instead of legacy package to avoid heap allocations

Signed-off-by: deadprogram <ron@hybridgroup.com>

---------

Signed-off-by: deadprogram <ron@hybridgroup.com>

apa102/apa102.go

@@ -5,9 +5,10 @@ package apa102 // import "tinygo.org/x/drivers/apa102"
 
 import (
 	"image/color"
-	"machine"
 
 	"tinygo.org/x/drivers"
+	"tinygo.org/x/drivers/internal/legacy"
+	"tinygo.org/x/drivers/internal/pin"
 )
 
 const (
@@ -37,8 +38,11 @@ func New(b drivers.SPI) *Device {
 
 // NewSoftwareSPI returns a new APA102 driver that will use a software based
 // implementation of the SPI protocol.
-func NewSoftwareSPI(sckPin, sdoPin machine.Pin, delay uint32) *Device {
-	return New(&bbSPI{SCK: sckPin, SDO: sdoPin, Delay: delay})
+func NewSoftwareSPI(sckPin, sdoPin pin.Output, delay uint32) *Device {
+	return New(&bbSPI{SCK: sckPin.Set, SDO: sdoPin.Set, Delay: delay, configurePins: func() {
+		legacy.ConfigurePinOut(sckPin)
+		legacy.ConfigurePinOut(sdoPin)
+	}})
 }
 
 // WriteColors writes the given RGBA color slice out using the APA102 protocol.

apa102/softspi.go

@@ -1,6 +1,9 @@
 package apa102
 
-import "machine"
+import (
+	"tinygo.org/x/drivers/internal/legacy"
+	"tinygo.org/x/drivers/internal/pin"
+)
 
 // bbSPI is a dumb bit-bang implementation of SPI protocol that is hardcoded
 // to mode 0 and ignores trying to receive data. Just enough for the APA102.
@@ -8,15 +11,18 @@ import "machine"
 // most purposes other than the APA102 package. It might be desirable to make
 // this more generic and include it in the TinyGo "machine" package instead.
 type bbSPI struct {
-	SCK   machine.Pin
-	SDO   machine.Pin
-	Delay uint32
+	SCK           pin.OutputFunc
+	SDO           pin.OutputFunc
+	Delay         uint32
+	configurePins func()
 }
 
 // Configure sets up the SCK and SDO pins as outputs and sets them low
 func (s *bbSPI) Configure() {
-	s.SCK.Configure(machine.PinConfig{Mode: machine.PinOutput})
-	s.SDO.Configure(machine.PinConfig{Mode: machine.PinOutput})
+	if s.configurePins == nil {
+		panic(legacy.ErrConfigBeforeInstantiated)
+	}
+	s.configurePins()
 	s.SCK.Low()
 	s.SDO.Low()
 	if s.Delay == 0 {

bmi160/bmi160.go

@@ -1,31 +1,36 @@
 package bmi160
 
 import (
-	"machine"
 	"time"
 
 	"tinygo.org/x/drivers"
+	"tinygo.org/x/drivers/internal/legacy"
+	"tinygo.org/x/drivers/internal/pin"
 )
 
 // DeviceSPI is the SPI interface to a BMI160 accelerometer/gyroscope. There is
 // also an I2C interface, but it is not yet supported.
 type DeviceSPI struct {
 	// Chip select pin
-	CSB machine.Pin
+	csb pin.OutputFunc
 
 	buf [7]byte
 
 	// SPI bus (requires chip select to be usable).
-	Bus drivers.SPI
+	bus           drivers.SPI
+	configurePins func()
 }
 
 // NewSPI returns a new device driver. The pin and SPI interface are not
 // touched, provide a fully configured SPI object and call Configure to start
 // using this device.
-func NewSPI(csb machine.Pin, spi drivers.SPI) *DeviceSPI {
+func NewSPI(csb pin.Output, spi drivers.SPI) *DeviceSPI {
 	return &DeviceSPI{
-		CSB: csb, // chip select
-		Bus: spi,
+		csb: csb.Set, // chip select
+		bus: spi,
+		configurePins: func() {
+			legacy.ConfigurePinOut(csb)
+		},
 	}
 }
 
@@ -33,9 +38,11 @@ func NewSPI(csb machine.Pin, spi drivers.SPI) *DeviceSPI {
 // configures the BMI160, but it does not configure the SPI interface (it is
 // assumed to be up and running).
 func (d *DeviceSPI) Configure() error {
-	d.CSB.Configure(machine.PinConfig{Mode: machine.PinOutput})
-	d.CSB.High()
-
+	if d.configurePins == nil {
+		return legacy.ErrConfigBeforeInstantiated
+	}
+	d.configurePins()
+	d.csb.High()
 	// The datasheet recommends doing a register read from address 0x7F to get
 	// SPI communication going:
 	// > If CSB sees a rising edge after power-up, the BMI160 interface switches
@@ -86,9 +93,9 @@ func (d *DeviceSPI) ReadTemperature() (temperature int32, err error) {
 	data[0] = 0x80 | reg_TEMPERATURE_0
 	data[1] = 0
 	data[2] = 0
-	d.CSB.Low()
-	err = d.Bus.Tx(data, data)
-	d.CSB.High()
+	d.csb.Low()
+	err = d.bus.Tx(data, data)
+	d.csb.High()
 	if err != nil {
 		return
 	}
@@ -123,9 +130,9 @@ func (d *DeviceSPI) ReadAcceleration() (x int32, y int32, z int32, err error) {
 	for i := 1; i < len(data); i++ {
 		data[i] = 0
 	}
-	d.CSB.Low()
-	err = d.Bus.Tx(data, data)
-	d.CSB.High()
+	d.csb.Low()
+	err = d.bus.Tx(data, data)
+	d.csb.High()
 	if err != nil {
 		return
 	}
@@ -153,9 +160,9 @@ func (d *DeviceSPI) ReadRotation() (x int32, y int32, z int32, err error) {
 	for i := 1; i < len(data); i++ {
 		data[i] = 0
 	}
-	d.CSB.Low()
-	err = d.Bus.Tx(data, data)
-	d.CSB.High()
+	d.csb.Low()
+	err = d.bus.Tx(data, data)
+	d.csb.High()
 	if err != nil {
 		return
 	}
@@ -201,9 +208,9 @@ func (d *DeviceSPI) readRegister(address uint8) uint8 {
 	data := d.buf[:2]
 	data[0] = 0x80 | address
 	data[1] = 0
-	d.CSB.Low()
-	d.Bus.Tx(data, data)
-	d.CSB.High()
+	d.csb.Low()
+	d.bus.Tx(data, data)
+	d.csb.High()
 	return data[1]
 }
 
@@ -217,7 +224,7 @@ func (d *DeviceSPI) writeRegister(address, data uint8) {
 	buf[0] = address
 	buf[1] = data
 
-	d.CSB.Low()
-	d.Bus.Tx(buf, buf)
-	d.CSB.High()
+	d.csb.Low()
+	d.bus.Tx(buf, buf)
+	d.csb.High()
 }

buzzer/buzzer.go

@@ -2,22 +2,22 @@
 package buzzer // import "tinygo.org/x/drivers/buzzer"
 
 import (
-	"machine"
-
 	"time"
+
+	"tinygo.org/x/drivers/internal/pin"
 )
 
 // Device wraps a GPIO connection to a buzzer.
 type Device struct {
-	pin  machine.Pin
+	pin  pin.OutputFunc
 	High bool
 	BPM  float64
 }
 
 // New returns a new buzzer driver given which pin to use
-func New(pin machine.Pin) Device {
+func New(pin pin.Output) Device {
 	return Device{
-		pin:  pin,
+		pin:  pin.Set,
 		High: false,
 		BPM:  96.0,
 	}
@@ -25,14 +25,14 @@ func New(pin machine.Pin) Device {
 
 // On sets the buzzer to a high state.
 func (l *Device) On() (err error) {
-	l.pin.Set(true)
+	l.pin.High()
 	l.High = true
 	return
 }
 
 // Off sets the buzzer to a low state.
 func (l *Device) Off() (err error) {
-	l.pin.Set(false)
+	l.pin.Low()
 	l.High = false
 	return
 }

easystepper/easystepper.go

@@ -2,9 +2,9 @@
 package easystepper // import "tinygo.org/x/drivers/easystepper"
 
 import (
-	"errors"
-	"machine"
 	"time"
+
+	"tinygo.org/x/drivers/internal/pin"
 )
 
 // StepMode determines the coil sequence used to perform a single step
@@ -30,28 +30,10 @@ func (sm StepMode) stepCount() uint {
 	}
 }
 
-// DeviceConfig contains the configuration data for a single easystepper driver
-type DeviceConfig struct {
-	// Pin1 ... Pin4 determines the pins to configure and use for the device
-	Pin1, Pin2, Pin3, Pin4 machine.Pin
-	// StepCount is the number of steps required to perform a full revolution of the stepper motor
-	StepCount uint
-	// RPM determines the speed of the stepper motor in 'Revolutions per Minute'
-	RPM uint
-	// Mode determines the coil sequence used to perform a single step
-	Mode StepMode
-}
-
-// DualDeviceConfig contains the configuration data for a dual easystepper driver
-type DualDeviceConfig struct {
-	DeviceConfig
-	// Pin5 ... Pin8 determines the pins to configure and use for the second device
-	Pin5, Pin6, Pin7, Pin8 machine.Pin
-}
-
 // Device holds the pins and the delay between steps
 type Device struct {
-	pins       [4]machine.Pin
+	pins       [4]pin.OutputFunc
+	config     func()
 	stepDelay  time.Duration
 	stepNumber uint8
 	stepMode   StepMode
@@ -62,51 +44,6 @@ type DualDevice struct {
 	devices [2]*Device
 }
 
-// New returns a new single easystepper driver given a DeviceConfig
-func New(config DeviceConfig) (*Device, error) {
-	if config.StepCount == 0 || config.RPM == 0 {
-		return nil, errors.New("config.StepCount and config.RPM must be > 0")
-	}
-	return &Device{
-		pins:      [4]machine.Pin{config.Pin1, config.Pin2, config.Pin3, config.Pin4},
-		stepDelay: time.Second * 60 / time.Duration((config.StepCount * config.RPM)),
-		stepMode:  config.Mode,
-	}, nil
-}
-
-// Configure configures the pins of the Device
-func (d *Device) Configure() {
-	for _, pin := range d.pins {
-		pin.Configure(machine.PinConfig{Mode: machine.PinOutput})
-	}
-}
-
-// NewDual returns a new dual easystepper driver given 8 pins, number of steps and rpm
-func NewDual(config DualDeviceConfig) (*DualDevice, error) {
-	// Create the first device
-	dev1, err := New(config.DeviceConfig)
-	if err != nil {
-		return nil, err
-	}
-	// Create the second device
-	config.DeviceConfig.Pin1 = config.Pin5
-	config.DeviceConfig.Pin2 = config.Pin6
-	config.DeviceConfig.Pin3 = config.Pin7
-	config.DeviceConfig.Pin4 = config.Pin8
-	dev2, err := New(config.DeviceConfig)
-	if err != nil {
-		return nil, err
-	}
-	// Return composite dual device
-	return &DualDevice{devices: [2]*Device{dev1, dev2}}, nil
-}
-
-// Configure configures the pins of the DualDevice
-func (d *DualDevice) Configure() {
-	d.devices[0].Configure()
-	d.devices[1].Configure()
-}
-
 // Move rotates the motor the number of given steps
 // (negative steps will rotate it the opposite direction)
 func (d *Device) Move(steps int32) {

easystepper/easystepper_go.go

@@ -0,0 +1,26 @@
+package easystepper
+
+import (
+	"errors"
+	"time"
+
+	"tinygo.org/x/drivers/internal/pin"
+)
+
+func NewCrossPlatform(stepcount, rpm uint, mode StepMode, pins [4]pin.OutputFunc) (*Device, error) {
+	if stepcount == 0 || rpm == 0 {
+		return nil, errors.New("zero rpm and/or stepcount")
+	}
+	for i := range pins {
+		if pins[i] == nil {
+			return nil, errors.New("nil pin")
+		}
+	}
+	d := &Device{
+		pins:      pins,
+		stepDelay: time.Second * 60 / time.Duration((stepcount * rpm)),
+		stepMode:  mode,
+		config:    func() {},
+	}
+	return d, nil
+}

easystepper/easystepper_tinygo.go

@@ -0,0 +1,83 @@
+//go:build baremetal
+
+package easystepper
+
+import (
+	"errors"
+	"machine"
+	"time"
+
+	"tinygo.org/x/drivers/internal/legacy"
+	"tinygo.org/x/drivers/internal/pin"
+)
+
+// New returns a new single easystepper driver given a DeviceConfig
+func New(config DeviceConfig) (*Device, error) {
+	if config.StepCount == 0 || config.RPM == 0 {
+		return nil, errors.New("config.StepCount and config.RPM must be > 0")
+	}
+	return &Device{
+		pins:      [4]pin.OutputFunc{config.Pin1.Set, config.Pin2.Set, config.Pin3.Set, config.Pin4.Set},
+		stepDelay: time.Second * 60 / time.Duration((config.StepCount * config.RPM)),
+		stepMode:  config.Mode,
+		config: func() {
+			legacy.ConfigurePinOut(config.Pin1)
+			legacy.ConfigurePinOut(config.Pin2)
+			legacy.ConfigurePinOut(config.Pin3)
+			legacy.ConfigurePinOut(config.Pin4)
+		},
+	}, nil
+}
+
+// Configure configures the pins of the Device
+func (d *Device) Configure() {
+	if d.config == nil {
+		panic(legacy.ErrConfigBeforeInstantiated)
+	}
+	d.config()
+}
+
+// Configure configures the pins of the DualDevice
+func (d *DualDevice) Configure() {
+	d.devices[0].Configure()
+	d.devices[1].Configure()
+}
+
+// NewDual returns a new dual easystepper driver given 8 pins, number of steps and rpm
+func NewDual(config DualDeviceConfig) (*DualDevice, error) {
+	// Create the first device
+	dev1, err := New(config.DeviceConfig)
+	if err != nil {
+		return nil, err
+	}
+	// Create the second device
+	config.DeviceConfig.Pin1 = config.Pin5
+	config.DeviceConfig.Pin2 = config.Pin6
+	config.DeviceConfig.Pin3 = config.Pin7
+	config.DeviceConfig.Pin4 = config.Pin8
+	dev2, err := New(config.DeviceConfig)
+	if err != nil {
+		return nil, err
+	}
+	// Return composite dual device
+	return &DualDevice{devices: [2]*Device{dev1, dev2}}, nil
+}
+
+// DeviceConfig contains the configuration data for a single easystepper driver
+type DeviceConfig struct {
+	// Pin1 ... Pin4 determines the pins to configure and use for the device
+	Pin1, Pin2, Pin3, Pin4 machine.Pin
+	// StepCount is the number of steps required to perform a full revolution of the stepper motor
+	StepCount uint
+	// RPM determines the speed of the stepper motor in 'Revolutions per Minute'
+	RPM uint
+	// Mode determines the coil sequence used to perform a single step
+	Mode StepMode
+}
+
+// DualDeviceConfig contains the configuration data for a dual easystepper driver
+type DualDeviceConfig struct {
+	DeviceConfig
+	// Pin5 ... Pin8 determines the pins to configure and use for the second device
+	Pin5, Pin6, Pin7, Pin8 machine.Pin
+}

examples/si5351/main.go

@@ -0,0 +1,107 @@
+package main
+
+import (
+	"machine"
+	"time"
+
+	"tinygo.org/x/drivers/si5351"
+)
+
+// Simple demo of the SI5351 clock generator.
+// This is like the Arduino library example:
+//   https://github.com/adafruit/Adafruit_Si5351_Library/blob/master/examples/si5351/si5351.ino
+// Which will configure the chip with:
+//  - PLL A at 900mhz
+//  - PLL B at 616.66667mhz
+//  - Clock 0 at 112.5mhz, using PLL A as a source divided by 8
+//  - Clock 1 at 13.5531mhz, using PLL B as a source divided by 45.5
+//  - Clock 2 at 10.76khz, using PLL B as a source divided by 900 and further divided with an R divider of 64.
+
+func main() {
+	time.Sleep(5 * time.Second)
+
+	println("Si5351 Clockgen Test")
+	println()
+
+	// Configure I2C bus
+	machine.I2C0.Configure(machine.I2CConfig{})
+
+	// Create driver instance
+	clockgen := si5351.New(machine.I2C0)
+
+	// Verify device wired properly
+	connected, err := clockgen.Connected()
+	if err != nil {
+		println("Unable to read device status")
+		time.Sleep(time.Second)
+	}
+	if !connected {
+		for {
+			println("Unable to detect si5351 device")
+			time.Sleep(time.Second)
+		}
+	}
+
+	// Initialise device
+	clockgen.Configure()
+
+	// Now configue the PLLs and clock outputs.
+	// The PLLs can be configured with a multiplier and division of the on-board
+	// 25mhz reference crystal.  For example configure PLL A to 900mhz by multiplying
+	// by 36.  This uses an integer multiplier which is more accurate over time
+	// but allows less of a range of frequencies compared to a fractional
+	// multiplier shown next.
+	clockgen.ConfigurePLL(si5351.PLL_A, 36, 0, 1) // Multiply 25mhz by 36
+	println("PLL A frequency: 900mhz")
+
+	// And next configure PLL B to 616.6667mhz by multiplying 25mhz by 24.667 using
+	// the fractional multiplier configuration.  Notice you specify the integer
+	// multiplier and then a numerator and denominator as separate values, i.e.
+	// numerator 2 and denominator 3 means 2/3 or 0.667.  This fractional
+	// configuration is susceptible to some jitter over time but can set a larger
+	// range of frequencies.
+	clockgen.ConfigurePLL(si5351.PLL_B, 24, 2, 3) // Multiply 25mhz by 24.667 (24 2/3)
+	println("PLL B frequency: 616.6667mhz")
+
+	// Now configure the clock outputs.  Each is driven by a PLL frequency as input
+	// and then further divides that down to a specific frequency.
+	// Configure clock 0 output to be driven by PLL A divided by 8, so an output
+	// of 112.5mhz (900mhz / 8).  Again this uses the most precise integer division
+	// but can't set as wide a range of values.
+	clockgen.ConfigureMultisynth(0, si5351.PLL_A, 8, 0, 1) // Divide by 8 (8 0/1)
+	println("Clock 0: 112.5mhz")
+
+	// Next configure clock 1 to be driven by PLL B divided by 45.5 to get
+	// 13.5531mhz (616.6667mhz / 45.5).  This uses fractional division and again
+	// notice the numerator and denominator are explicitly specified.  This is less
+	// precise but allows a large range of frequencies.
+	clockgen.ConfigureMultisynth(1, si5351.PLL_B, 45, 1, 2) // Divide by 45.5 (45 1/2)
+	println("Clock 1: 13.5531mhz")
+
+	// Finally configure clock 2 to be driven by PLL B divided once by 900 to get
+	// down to 685.15 khz and then further divided by a special R divider that
+	// divides 685.15 khz by 64 to get a final output of 10.706khz.
+	clockgen.ConfigureMultisynth(2, si5351.PLL_B, 900, 0, 1) // Divide by 900 (900 0/1)
+	// Set the R divider, this can be a value of:
+	//  - R_DIV_1: divider of 1
+	//  - R_DIV_2: divider of 2
+	//  - R_DIV_4: divider of 4
+	//  - R_DIV_8: divider of 8
+	//  - R_DIV_16: divider of 16
+	//  - R_DIV_32: divider of 32
+	//  - R_DIV_64: divider of 64
+	//  - R_DIV_128: divider of 128
+	clockgen.ConfigureRdiv(2, si5351.R_DIV_64)
+	println("Clock 2: 10.706khz")
+
+	// After configuring PLLs and clocks, enable the outputs.
+	clockgen.EnableOutputs()
+
+	for {
+		time.Sleep(5 * time.Second)
+		println()
+		println("Clock 0: 112.5mhz")
+		println("Clock 1: 13.5531mhz")
+		println("Clock 2: 10.706khz")
+	}
+}

ft6336/ft6336.go

@@ -1,3 +1,6 @@
+// Guarded because still unsure of how to deal with interrupt drivers.
+//go:build tinygo
+
 // Package ft6336 provides a driver for the FT6336 I2C Self-Capacitive touch
 // panel controller.
 //

gc9a01/gc9a01.go

@@ -5,12 +5,13 @@ package gc9a01 // import "tinygo.org/x/drivers/gc9a01"
 
 import (
 	"image/color"
-	"machine"
 	"time"
 
 	"errors"
 
 	"tinygo.org/x/drivers"
+	"tinygo.org/x/drivers/internal/legacy"
+	"tinygo.org/x/drivers/internal/pin"
 )
 
 // Rotation controls the rotation used by the display.
@@ -22,10 +23,10 @@ type FrameRate uint8
 // Device wraps an SPI connection.
 type Device struct {
 	bus             drivers.SPI
-	dcPin           machine.Pin
-	resetPin        machine.Pin
-	csPin           machine.Pin
-	blPin           machine.Pin
+	dcPin           pin.OutputFunc
+	resetPin        pin.OutputFunc
+	csPin           pin.OutputFunc
+	blPin           pin.OutputFunc
 	width           int16
 	height          int16
 	columnOffsetCfg int16
@@ -52,17 +53,17 @@ type Config struct {
 }
 
 // New creates a new ST7789 connection. The SPI wire must already be configured.
-func New(bus drivers.SPI, resetPin, dcPin, csPin, blPin machine.Pin) Device {
-	resetPin.Configure(machine.PinConfig{Mode: machine.PinOutput})
-	dcPin.Configure(machine.PinConfig{Mode: machine.PinOutput})
-	csPin.Configure(machine.PinConfig{Mode: machine.PinOutput})
-	blPin.Configure(machine.PinConfig{Mode: machine.PinOutput})
+func New(bus drivers.SPI, resetPin, dcPin, csPin, blPin pin.Output) Device {
+	legacy.ConfigurePinOut(resetPin)
+	legacy.ConfigurePinOut(dcPin)
+	legacy.ConfigurePinOut(csPin)
+	legacy.ConfigurePinOut(blPin)
 	return Device{
 		bus:      bus,
-		resetPin: resetPin,
-		dcPin:    dcPin,
-		csPin:    csPin,
-		blPin:    blPin,
+		resetPin: resetPin.Set,
+		dcPin:    dcPin.Set,
+		csPin:    csPin.Set,
+		blPin:    blPin.Set,
 	}
 }
 
@@ -226,7 +227,7 @@ func (d *Device) Data(data uint8) {
 
 // Tx sends data to the display
 func (d *Device) Tx(data []byte, isCommand bool) {
-	d.dcPin.Set(!isCommand)
+	d.dcPin(!isCommand)
 	d.bus.Tx(data, nil)
 }
 

hcsr04/hcsr04.go

@@ -5,30 +5,39 @@
 package hcsr04
 
 import (
-	"machine"
 	"time"
+
+	"tinygo.org/x/drivers/internal/legacy"
+	"tinygo.org/x/drivers/internal/pin"
 )
 
 const TIMEOUT = 23324 // max sensing distance (4m)
 
 // Device holds the pins
 type Device struct {
-	trigger machine.Pin
-	echo    machine.Pin
+	trigger       pin.OutputFunc
+	echo          pin.InputFunc
+	configurePins func()
 }
 
 // New returns a new ultrasonic driver given 2 pins
-func New(trigger, echo machine.Pin) Device {
+func New(trigger pin.Output, echo pin.Input) Device {
 	return Device{
-		trigger: trigger,
-		echo:    echo,
+		trigger: trigger.Set,
+		echo:    echo.Get,
+		configurePins: func() {
+			legacy.ConfigurePinOut(trigger)
+			legacy.ConfigurePinInput(echo)
+		},
 	}
 }
 
 // Configure configures the pins of the Device
 func (d *Device) Configure() {
-	d.trigger.Configure(machine.PinConfig{Mode: machine.PinOutput})
-	d.echo.Configure(machine.PinConfig{Mode: machine.PinInput})
+	if d.configurePins == nil {
+		panic(legacy.ErrConfigBeforeInstantiated)
+	}
+	d.configurePins()
 }
 
 // ReadDistance returns the distance of the object in mm
@@ -52,7 +61,7 @@ func (d *Device) ReadPulse() int32 {
 	d.trigger.Low()
 	i := uint8(0)
 	for {
-		if d.echo.Get() {
+		if d.echo() {
 			t = time.Now()
 			break
 		}
@@ -66,7 +75,7 @@ func (d *Device) ReadPulse() int32 {
 	}
 	i = 0
 	for {
-		if !d.echo.Get() {
+		if !d.echo() {
 			return int32(time.Since(t).Microseconds())
 		}
 		i++

hd44780/hd44780.go

@@ -210,7 +210,7 @@ func (d *Device) SendCommand(command byte) {
 	d.bus.SetCommandMode(true)
 	d.bus.Write([]byte{command})
 
-	for d.busy(command == DISPLAY_CLEAR || command == CURSOR_HOME) {
+	for d.isBusy(command == DISPLAY_CLEAR || command == CURSOR_HOME) {
 	}
 }
 
@@ -219,7 +219,7 @@ func (d *Device) sendData(data byte) {
 	d.bus.SetCommandMode(false)
 	d.bus.Write([]byte{data})
 
-	for d.busy(false) {
+	for d.isBusy(false) {
 	}
 }
 
@@ -231,9 +231,9 @@ func (d *Device) CreateCharacter(cgramAddr uint8, data []byte) {
 	}
 }
 
-// busy returns true when hd447890 is busy
+// isBusy returns true when hd447890 is isBusy
 // or after the timeout specified
-func (d *Device) busy(longDelay bool) bool {
+func (d *Device) isBusy(longDelay bool) bool {
 	if d.bus.WriteOnly() {
 		// Can't read busy flag if write only, so sleep a bit then return
 		if longDelay {
@@ -261,7 +261,7 @@ func (d *Device) busy(longDelay bool) bool {
 
 // Busy returns true when hd447890 is busy
 func (d *Device) Busy() bool {
-	return d.busy(false)
+	return d.isBusy(false)
 }
 
 // Size returns the current size of the display.

max6675/max6675.go

@@ -3,9 +3,9 @@ package max6675
 
 import (
 	"errors"
-	"machine"
 
 	"tinygo.org/x/drivers"
+	"tinygo.org/x/drivers/internal/pin"
 )
 
 // ErrThermocoupleOpen is returned when the thermocouple input is open.
@@ -14,16 +14,16 @@ var ErrThermocoupleOpen = errors.New("thermocouple input open")
 
 type Device struct {
 	bus drivers.SPI
-	cs  machine.Pin
+	cs  pin.OutputFunc
 }
 
 // Create a new Device to read from a MAX6675 thermocouple.
 // Pins must be configured before use.  Frequency for SPI
 // should be 4.3MHz maximum.
-func NewDevice(bus drivers.SPI, cs machine.Pin) *Device {
+func NewDevice(bus drivers.SPI, cs pin.Output) *Device {
 	return &Device{
 		bus: bus,
-		cs:  cs,
+		cs:  cs.Set,
 	}
 }
 

max72xx/max72xx.go

@@ -3,31 +3,36 @@
 package max72xx
 
 import (
-	"machine"
-
 	"tinygo.org/x/drivers"
+	"tinygo.org/x/drivers/internal/legacy"
+	"tinygo.org/x/drivers/internal/pin"
 )
 
 type Device struct {
-	bus drivers.SPI
-	cs  machine.Pin
+	bus           drivers.SPI
+	cs            pin.OutputFunc
+	configurePins func()
 }
 
 // NewDriver creates a new max7219 connection. The SPI wire must already be configured
 // The SPI frequency must not be higher than 10MHz.
 // parameter cs: the datasheet also refers to this pin as "load" pin.
-func NewDevice(bus drivers.SPI, cs machine.Pin) *Device {
+func NewDevice(bus drivers.SPI, cs pin.Output) *Device {
 	return &Device{
 		bus: bus,
-		cs:  cs,
+		cs:  cs.Set,
+		configurePins: func() {
+			legacy.ConfigurePinOut(cs)
+		},
 	}
 }
 
 // Configure setups the pins.
 func (driver *Device) Configure() {
-	outPutConfig := machine.PinConfig{Mode: machine.PinOutput}
-
-	driver.cs.Configure(outPutConfig)
+	if driver.configurePins == nil {
+		panic(legacy.ErrConfigBeforeInstantiated)
+	}
+	driver.configurePins()
 }
 
 // SetScanLimit sets the scan limit. Maximum is 8.

mcp2515/mcp2515.go

@@ -8,18 +8,20 @@ package mcp2515 // import "tinygo.org/x/drivers/mcp2515"
 import (
 	"errors"
 	"fmt"
-	"machine"
 	"time"
 
 	"tinygo.org/x/drivers"
+	"tinygo.org/x/drivers/internal/legacy"
+	"tinygo.org/x/drivers/internal/pin"
 )
 
 // Device wraps MCP2515 SPI CAN Module.
 type Device struct {
-	spi     SPI
-	cs      machine.Pin
-	msg     *CANMsg
-	mcpMode byte
+	spi           SPI
+	cs            pin.OutputFunc
+	msg           *CANMsg
+	mcpMode       byte
+	configurePins func()
 }
 
 // CANMsg stores CAN message fields.
@@ -36,15 +38,18 @@ const (
 )
 
 // New returns a new MCP2515 driver. Pass in a fully configured SPI bus.
-func New(b drivers.SPI, csPin machine.Pin) *Device {
+func New(b drivers.SPI, csPin pin.Output) *Device {
 	d := &Device{
 		spi: SPI{
 			bus: b,
 			tx:  make([]byte, 0, bufferSize),
 			rx:  make([]byte, 0, bufferSize),
 		},
-		cs:  csPin,
+		cs:  csPin.Set,
 		msg: &CANMsg{},
+		configurePins: func() {
+			legacy.ConfigurePinOut(csPin)
+		},
 	}
 
 	return d
@@ -52,7 +57,10 @@ func New(b drivers.SPI, csPin machine.Pin) *Device {
 
 // Configure sets up the device for communication.
 func (d *Device) Configure() {
-	d.cs.Configure(machine.PinConfig{Mode: machine.PinOutput})
+	if d.configurePins == nil {
+		panic(legacy.ErrConfigBeforeInstantiated)
+	}
+	d.configurePins()
 }
 
 const beginTimeoutValue int = 10

onewire/onewire.go

@@ -5,8 +5,9 @@ package onewire // import "tinygo.org/x/drivers/onewire"
 
 import (
 	"errors"
-	"machine"
 	"time"
+
+	"tinygo.org/x/drivers/internal/pin"
 )
 
 // OneWire ROM commands
@@ -19,7 +20,8 @@ const (
 
 // Device wraps a connection to an 1-Wire devices.
 type Device struct {
-	p machine.Pin
+	set pin.OutputFunc
+	get pin.InputFunc
 }
 
 // Config wraps a configuration to an 1-Wire devices.
@@ -32,24 +34,30 @@ var (
 	errReadAddress    = errors.New("Error: OneWire. Read address error: CRC mismatch.")
 )
 
-// New creates a new GPIO 1-Wire connection.
-// The pin must be pulled up to the VCC via a resistor greater than 500 ohms (default 4.7k).
-func New(p machine.Pin) Device {
-	return Device{
-		p: p,
+// NewFromFuncs expects pin setter and getter for DQ line. Ideally this driver should receive
+// a one-wire bus HAL abstraction, but I was asked to show how this could be done using pin HAL so here goes.
+func NewFromFuncs(getPinLevel pin.InputFunc, setPinLevel pin.OutputFunc) *Device {
+	return &Device{
+		set: setPinLevel,
+		get: getPinLevel,
 	}
 }
 
 // Configure initializes the protocol.
 func (d *Device) Configure(config Config) {}
 
+// By setting the pin value one should configure as output and also expect a more
+// consistent behaviour across all tinygo hosts by pulling DQ line low consistently. Win-win.
+func (d *Device) cfgOut() { d.set.Low() }
+func (d *Device) cfgIn()  { d.get() }
+
 // Reset pull DQ line low, then up.
 func (d Device) Reset() error {
-	d.p.Configure(machine.PinConfig{Mode: machine.PinOutput})
+	d.cfgOut()
 	time.Sleep(480 * time.Microsecond)
-	d.p.Configure(machine.PinConfig{Mode: machine.PinInputPullup})
+	d.cfgIn()
 	time.Sleep(70 * time.Microsecond)
-	precence := d.p.Get()
+	precence := d.get()
 	time.Sleep(410 * time.Microsecond)
 	if precence {
 		return errNoPresence
@@ -59,14 +67,14 @@ func (d Device) Reset() error {
 
 // WriteBit transmits a bit to 1-Wire bus.
 func (d Device) WriteBit(data uint8) {
-	d.p.Configure(machine.PinConfig{Mode: machine.PinOutput})
+	d.cfgOut()
 	if data&1 == 1 { // Send '1'
 		time.Sleep(5 * time.Microsecond)
-		d.p.Configure(machine.PinConfig{Mode: machine.PinInputPullup})
+		d.cfgIn()
 		time.Sleep(60 * time.Microsecond)
 	} else { // Send '0'
 		time.Sleep(60 * time.Microsecond)
-		d.p.Configure(machine.PinConfig{Mode: machine.PinInputPullup})
+		d.cfgIn()
 		time.Sleep(5 * time.Microsecond)
 	}
 }
@@ -81,11 +89,11 @@ func (d Device) Write(data uint8) {
 
 // ReadBit receives a bit from 1-Wire bus.
 func (d Device) ReadBit() (data uint8) {
-	d.p.Configure(machine.PinConfig{Mode: machine.PinOutput})
+	d.cfgOut()
 	time.Sleep(3 * time.Microsecond)
-	d.p.Configure(machine.PinConfig{Mode: machine.PinInputPullup})
+	d.cfgIn()
 	time.Sleep(8 * time.Microsecond)
-	if d.p.Get() {
+	if d.get() {
 		data = 1
 	}
 	time.Sleep(60 * time.Microsecond)

onewire/onewire_tinygo.go

@@ -0,0 +1,31 @@
+//go:build tinygo
+
+package onewire
+
+import (
+	"machine"
+
+	"tinygo.org/x/drivers/internal/legacy"
+)
+
+// New creates a new GPIO 1-Wire connection.
+// The pin must be pulled up to the VCC via a resistor greater than 500 ohms (default 4.7k).
+func New(p machine.Pin) Device {
+	isOut := false
+	return Device{
+		set: func(level bool) {
+			if !isOut {
+				legacy.ConfigurePinOut(p)
+				isOut = true
+			}
+			p.Set(level)
+		},
+		get: func() (level bool) {
+			if isOut {
+				legacy.ConfigurePinInputPullup(p)
+				isOut = false
+			}
+			return p.Get()
+		},
+	}
+}

pcd8544/pcd8544.go

@@ -6,18 +6,18 @@ package pcd8544 // import "tinygo.org/x/drivers/pcd8544"
 import (
 	"errors"
 	"image/color"
-	"machine"
 	"time"
 
 	"tinygo.org/x/drivers"
+	"tinygo.org/x/drivers/internal/pin"
 )
 
 // Device wraps an SPI connection.
 type Device struct {
 	bus        drivers.SPI
-	dcPin      machine.Pin
-	rstPin     machine.Pin
-	scePin     machine.Pin
+	dcPin      pin.OutputFunc
+	rstPin     pin.OutputFunc
+	scePin     pin.OutputFunc
 	buffer     []byte
 	width      int16
 	height     int16
@@ -30,12 +30,12 @@ type Config struct {
 }
 
 // New creates a new PCD8544 connection. The SPI bus must already be configured.
-func New(bus drivers.SPI, dcPin, rstPin, scePin machine.Pin) *Device {
+func New(bus drivers.SPI, dcPin, rstPin, scePin pin.Output) *Device {
 	return &Device{
 		bus:    bus,
-		dcPin:  dcPin,
-		rstPin: rstPin,
-		scePin: scePin,
+		dcPin:  dcPin.Set,
+		rstPin: rstPin.Set,
+		scePin: scePin.Set,
 	}
 }
 

pixel/image_test.go

@@ -9,9 +9,30 @@ import (
 	"tinygo.org/x/drivers/pixel"
 )
 
+func TestImageRGB888(t *testing.T) {
+	image := pixel.NewImage[pixel.RGB888](5, 3)
+	if width, height := image.Size(); width != 5 || height != 3 {
+		t.Errorf("image.Size(): expected 5, 3 but got %d, %d", width, height)
+	}
+	for _, c := range []color.RGBA{
+		{R: 0xff, A: 0xff},
+		{G: 0xff, A: 0xff},
+		{B: 0xff, A: 0xff},
+		{R: 0x10, A: 0xff},
+		{G: 0x10, A: 0xff},
+		{B: 0x10, A: 0xff},
+	} {
+		image.Set(4, 2, pixel.NewColor[pixel.RGB888](c.R, c.G, c.B))
+		c2 := image.Get(4, 2).RGBA()
+		if c2 != c {
+			t.Errorf("failed to roundtrip color: expected %v but got %v", c, c2)
+		}
+	}
+}
+
 func TestImageRGB565BE(t *testing.T) {
 	image := pixel.NewImage[pixel.RGB565BE](5, 3)
-	if width, height := image.Size(); width != 5 && height != 3 {
+	if width, height := image.Size(); width != 5 || height != 3 {
 		t.Errorf("image.Size(): expected 5, 3 but got %d, %d", width, height)
 	}
 	for _, c := range []color.RGBA{
@@ -30,9 +51,30 @@ func TestImageRGB565BE(t *testing.T) {
 	}
 }
 
+func TestImageRGB555(t *testing.T) {
+	image := pixel.NewImage[pixel.RGB555](5, 3)
+	if width, height := image.Size(); width != 5 || height != 3 {
+		t.Errorf("image.Size(): expected 5, 3 but got %d, %d", width, height)
+	}
+	for _, c := range []color.RGBA{
+		{R: 0xff, A: 0xff},
+		{G: 0xff, A: 0xff},
+		{B: 0xff, A: 0xff},
+		{R: 0x10, A: 0xff},
+		{G: 0x10, A: 0xff},
+		{B: 0x10, A: 0xff},
+	} {
+		image.Set(4, 2, pixel.NewColor[pixel.RGB555](c.R, c.G, c.B))
+		c2 := image.Get(4, 2).RGBA()
+		if c2 != c {
+			t.Errorf("failed to roundtrip color: expected %v but got %v", c, c2)
+		}
+	}
+}
+
 func TestImageRGB444BE(t *testing.T) {
 	image := pixel.NewImage[pixel.RGB444BE](5, 3)
-	if width, height := image.Size(); width != 5 && height != 3 {
+	if width, height := image.Size(); width != 5 || height != 3 {
 		t.Errorf("image.Size(): expected 5, 3 but got %d, %d", width, height)
 	}
 	for _, c := range []color.RGBA{
@@ -67,7 +109,7 @@ func TestImageRGB444BE(t *testing.T) {
 
 func TestImageMonochrome(t *testing.T) {
 	image := pixel.NewImage[pixel.Monochrome](128, 64)
-	if width, height := image.Size(); width != 128 && height != 64 {
+	if width, height := image.Size(); width != 128 || height != 64 {
 		t.Errorf("image.Size(): expected 128, 64 but got %d, %d", width, height)
 	}
 	for _, expected := range []color.RGBA{

pixel/pixel.go

@@ -161,9 +161,9 @@ func (c RGB555) BitsPerPixel() int {
 
 func (c RGB555) RGBA() color.RGBA {
 	color := color.RGBA{
-		R: uint8(c>>10) << 3,
-		G: uint8(c>>5) << 3,
-		B: uint8(c) << 3,
+		R: (uint8(c) & 0x1F) << 3,
+		G: (uint8(c>>5) & 0x1F) << 3,
+		B: (uint8(c>>10) & 0x1F) << 3,
 		A: 255,
 	}
 	// Correct color rounding, so that 0xff roundtrips back to 0xff.

shiftregister/shiftregister.go

@@ -2,7 +2,8 @@
 package shiftregister
 
 import (
-	"machine"
+	"tinygo.org/x/drivers/internal/legacy"
+	"tinygo.org/x/drivers/internal/pin"
 )
 
 type NumberBit int8
@@ -16,9 +17,10 @@ const (
 
 // Device holds pin number
 type Device struct {
-	latch, clock, out machine.Pin // IC wiring
-	bits              NumberBit   // Pin number
-	mask              uint32      // keep all pins state
+	latch, clock, out pin.OutputFunc // IC wiring
+	config            func()
+	bits              NumberBit // Pin number
+	mask              uint32    // keep all pins state
 }
 
 // ShiftPin is the implementation of the ShiftPin interface.
@@ -29,20 +31,25 @@ type ShiftPin struct {
 }
 
 // New returns a new shift output register device
-func New(Bits NumberBit, Latch, Clock, Out machine.Pin) *Device {
+func New(Bits NumberBit, Latch, Clock, Out pin.Output) *Device {
 	return &Device{
-		latch: Latch,
-		clock: Clock,
-		out:   Out,
+		latch: Latch.Set,
+		clock: Clock.Set,
+		out:   Out.Set,
 		bits:  Bits,
+		config: func() {
+			legacy.ConfigurePinOut(Latch)
+			legacy.ConfigurePinOut(Clock)
+			legacy.ConfigurePinOut(Out)
+		},
 	}
 }
 
 // Configure set hardware configuration
 func (d *Device) Configure() {
-	d.latch.Configure(machine.PinConfig{Mode: machine.PinOutput})
-	d.clock.Configure(machine.PinConfig{Mode: machine.PinOutput})
-	d.out.Configure(machine.PinConfig{Mode: machine.PinOutput})
+	if d.config == nil {
+		panic(legacy.ErrConfigBeforeInstantiated)
+	}
 	d.latch.High()
 }
 
@@ -53,7 +60,7 @@ func (d *Device) WriteMask(mask uint32) {
 	d.latch.Low()
 	for i := 0; i < int(d.bits); i++ {
 		d.clock.Low()
-		d.out.Set(mask&1 != 0)
+		d.out(mask&1 != 0)
 		mask = mask >> 1
 		d.clock.High()
 	}

si5351/registers.go

@@ -0,0 +1,64 @@
+package si5351
+
+// The I2C address which this device listens to.
+const AddressDefault = 0x60     // Assumes ADDR pin is low
+const AddressAlternative = 0x61 // Assumes ADDR pin is high
+
+const (
+	OUTPUT_ENABLE_CONTROL = 3
+
+	CLK0_CONTROL = 16
+	CLK1_CONTROL = 17
+	CLK2_CONTROL = 18
+	CLK3_CONTROL = 19
+	CLK4_CONTROL = 20
+	CLK5_CONTROL = 21
+	CLK6_CONTROL = 22
+	CLK7_CONTROL = 23
+
+	MULTISYNTH0_PARAMETERS_1 = 42
+	MULTISYNTH0_PARAMETERS_3 = 44
+	MULTISYNTH1_PARAMETERS_1 = 50
+	MULTISYNTH1_PARAMETERS_3 = 52
+	MULTISYNTH2_PARAMETERS_1 = 58
+	MULTISYNTH2_PARAMETERS_3 = 60
+
+	SPREAD_SPECTRUM_PARAMETERS = 149
+
+	PLL_RESET = 177
+
+	CRYSTAL_INTERNAL_LOAD_CAPACITANCE = 183
+)
+
+const (
+	CRYSTAL_LOAD_6PF  = (1 << 6)
+	CRYSTAL_LOAD_8PF  = (2 << 6)
+	CRYSTAL_LOAD_10PF = (3 << 6)
+)
+
+const (
+	CRYSTAL_FREQ_25MHZ = 25000000
+	CRYSTAL_FREQ_27MHZ = 27000000
+)
+
+const (
+	PLL_A = iota
+	PLL_B
+)
+
+const (
+	R_DIV_1 = iota
+	R_DIV_2
+	R_DIV_4
+	R_DIV_8
+	R_DIV_16
+	R_DIV_32
+	R_DIV_64
+	R_DIV_128
+)
+
+const (
+	MULTISYNTH_DIV_4 = 4
+	MULTISYNTH_DIV_6 = 6
+	MULTISYNTH_DIV_8 = 8
+)

si5351/si5351.go

@@ -0,0 +1,448 @@
+package si5351
+
+import (
+	"encoding/binary"
+	"errors"
+	"fmt"
+	"math"
+
+	"tinygo.org/x/drivers"
+	"tinygo.org/x/drivers/internal/regmap"
+)
+
+// Device wraps an I2C connection to a SI5351 device.
+type Device struct {
+	bus     drivers.I2C
+	Address uint8
+
+	rw             regmap.Device8I2C
+	initialised    bool
+	crystalFreq    uint32
+	crystalLoad    uint8
+	pllaConfigured bool
+	pllaFreq       uint32
+	pllbConfigured bool
+	pllbFreq       uint32
+	lastRdivValue  [3]uint8
+}
+
+var ErrNotInitialised = errors.New("Si5351 not initialised")
+var ErrInvalidParameter = errors.New("Si5351 invalid parameter")
+
+// New creates a new SI5351 connection. The I2C bus must already be configured.
+//
+// This function only creates the Device object, it does not touch the device.
+func New(bus drivers.I2C) Device {
+	rw := regmap.Device8I2C{}
+	rw.SetBus(bus, AddressDefault, binary.BigEndian)
+
+	return Device{
+		bus:         bus,
+		rw:          rw,
+		Address:     AddressDefault,
+		crystalFreq: CRYSTAL_FREQ_25MHZ,
+		crystalLoad: CRYSTAL_LOAD_10PF,
+	}
+}
+
+// Configure sets up the device for communication
+// TODO error handling
+func (d *Device) Configure() error {
+	// // Disable all outputs setting CLKx_DIS high
+	d.rw.Write8(OUTPUT_ENABLE_CONTROL, 0xFF)
+
+	// Set the load capacitance for the XTAL
+	d.rw.Write8(CRYSTAL_INTERNAL_LOAD_CAPACITANCE, d.crystalLoad)
+
+	// Power down all output drivers
+	buf := []byte{CLK0_CONTROL, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80}
+	d.bus.Tx(uint16(d.Address), buf, nil)
+
+	// Disable spread spectrum output.
+	if err := d.DisableSpreadSpectrum(); err != nil {
+		return err
+	}
+
+	d.initialised = true
+
+	return nil
+}
+
+// Connected returns whether a device at SI5351 address has been found.
+func (d *Device) Connected() (bool, error) {
+	if err := d.bus.Tx(uint16(d.Address), []byte{}, []byte{0}); err != nil {
+		return false, err
+	}
+	return true, nil
+}
+
+// EnableSpreadSpectrum enables spread spectrum modulation to reduce EMI.
+func (d *Device) EnableSpreadSpectrum() error {
+	data, err := d.rw.Read8(SPREAD_SPECTRUM_PARAMETERS)
+	if err != nil {
+		return err
+	}
+
+	data |= 0x80
+	return d.rw.Write8(SPREAD_SPECTRUM_PARAMETERS, data)
+}
+
+func (d *Device) DisableSpreadSpectrum() error {
+	data, err := d.rw.Read8(SPREAD_SPECTRUM_PARAMETERS)
+	if err != nil {
+		return err
+	}
+
+	data &^= 0x80
+	return d.rw.Write8(SPREAD_SPECTRUM_PARAMETERS, data)
+}
+
+func (d *Device) OutputEnable(output uint8, enable bool) error {
+	if !d.initialised {
+		return ErrNotInitialised
+	}
+
+	// Read the current value of the OUTPUT_ENABLE_CONTROL register
+	regVal, err := d.rw.Read8(OUTPUT_ENABLE_CONTROL)
+	if err != nil {
+		return err
+	}
+
+	// Modify regVal based on clk and enable
+	if enable {
+		regVal &= ^(1 << output)
+	} else {
+		regVal |= (1 << output)
+	}
+
+	// Write the modified value back to the OUTPUT_ENABLE_CONTROL register
+	return d.rw.Write8(OUTPUT_ENABLE_CONTROL, regVal)
+}
+
+func (d *Device) EnableOutputs() error {
+	if !d.initialised {
+		return ErrNotInitialised
+	}
+
+	return d.rw.Write8(OUTPUT_ENABLE_CONTROL, 0x00)
+}
+
+func (d *Device) DisableOutputs() error {
+	if !d.initialised {
+		return ErrNotInitialised
+	}
+	return d.rw.Write8(OUTPUT_ENABLE_CONTROL, 0xFF)
+}
+
+// ConfigurePLL sets the multiplier for the specified PLL
+// pll   The PLL to configure, which must be one of the following:
+// - PLL_A
+// - PLL_B
+//
+// mult  The PLL integer multiplier (must be between 15 and 90)
+//
+// num   The 20-bit numerator for fractional output (0..1,048,575).
+// Set this to '0' for integer output.
+//
+// denom The 20-bit denominator for fractional output (1..1,048,575).
+// Set this to '1' or higher to avoid divider by zero errors.
+//
+// PLL Configuration
+// fVCO is the PLL output, and must be between 600..900MHz, where:
+//
+// fVCO = fXTAL * (a+(b/c))
+//
+// fXTAL = the crystal input frequency
+// a     = an integer between 15 and 90
+// b     = the fractional numerator (0..1,048,575)
+// c     = the fractional denominator (1..1,048,575)
+//
+// NOTE: Try to use integers whenever possible to avoid clock jitter
+// (only use the a part, setting b to '0' and c to '1').
+//
+// See: http://www.silabs.com/Support%20Documents/TechnicalDocs/AN619.pdf
+func (d *Device) ConfigurePLL(pll uint8, mult uint8, num uint32, denom uint32) error {
+	// Basic validation
+	if !d.initialised {
+		return ErrNotInitialised
+	}
+	// mult = 15..90
+	if !((mult > 14) && (mult < 91)) {
+		return ErrInvalidParameter
+	}
+	// Avoid divide by zero
+	if !(denom > 0) {
+		return ErrInvalidParameter
+	}
+	// 20-bit limit
+	if !(num <= 0xFFFFF) {
+		return ErrInvalidParameter
+	}
+	// 20-bit limit
+	if !(denom <= 0xFFFFF) {
+		return ErrInvalidParameter
+	}
+
+	// PLL Multiplier Equations
+	//
+	// P1 register is an 18-bit value using following formula:
+	//
+	// 	P1[17:0] = 128 * mult + floor(128*(num/denom)) - 512
+	//
+	// P2 register is a 20-bit value using the following formula:
+	//
+	// 	P2[19:0] = 128 * num - denom * floor(128*(num/denom))
+	//
+	// P3 register is a 20-bit value using the following formula:
+	//
+	// 	P3[19:0] = denom
+	//
+
+	// Set PLL config registers
+	var p1, p2, p3 uint32
+	if num == 0 {
+		// Integer mode
+		p1 = 128*uint32(mult) - 512
+		p2 = num
+		p3 = denom
+	} else {
+		// Fractional mode
+		p1 = uint32(128*float64(mult) + math.Floor(128*(float64(num)/float64(denom))) - 512)
+		p2 = uint32(128*float64(num) - float64(denom)*math.Floor(128*(float64(num)/float64(denom))))
+		p3 = denom
+	}
+
+	// Get the appropriate starting point for the PLL registers
+	baseaddr := uint8(26)
+	if pll == PLL_B {
+		baseaddr = 34
+	}
+
+	// The datasheet is a nightmare of typos and inconsistencies here!
+	data := [8]byte{}
+	data[0] = uint8((p3 & 0x0000FF00) >> 8)
+	data[1] = uint8(p3 & 0x000000FF)
+	data[2] = uint8((p1 & 0x00030000) >> 16)
+	data[3] = uint8((p1 & 0x0000FF00) >> 8)
+	data[4] = uint8(p1 & 0x000000FF)
+	data[5] = uint8(((p3 & 0x000F0000) >> 12) | ((p2 & 0x000F0000) >> 16))
+	data[6] = uint8((p2 & 0x0000FF00) >> 8)
+	data[7] = uint8(p2 & 0x000000FF)
+	if err := d.bus.Tx(uint16(baseaddr), data[:], nil); err != nil {
+		return err
+	}
+
+	// Reset both PLLs
+	if err := d.rw.Write8(PLL_RESET, (1<<7)|(1<<5)); err != nil {
+		return err
+	}
+
+	// Store the frequency settings for use with the Multisynth helper
+	fvco := float64(d.crystalFreq) * (float64(mult) + (float64(num) / float64(denom)))
+	if pll == PLL_A {
+		d.pllaConfigured = true
+		d.pllaFreq = uint32(math.Floor(fvco))
+	} else {
+		d.pllbConfigured = true
+		d.pllbFreq = uint32(math.Floor(fvco))
+	}
+	return nil
+}
+
+// ConfigureMultisynth divider, which determines the
+// output clock frequency based on the specified PLL input.
+//
+// output    The output channel to use (0..2)
+//
+// pll       The PLL input source to use, which must be one of:
+//   - PLL_A
+//   - PLL_B
+//
+// div       The integer divider for the Multisynth output.
+//
+//	If pure integer values are used, this value must be one of:
+//	- MULTISYNTH_DIV_4
+//	- MULTISYNTH_DIV_6
+//	- MULTISYNTH_DIV_8
+//	If fractional output is used, this value must be between 8 and 900.
+//
+// num       The 20-bit numerator for fractional output (0..1,048,575).
+//
+//	Set this to '0' for integer output.
+//
+// denom     The 20-bit denominator for fractional output (1..1,048,575).
+//
+//	Set this to '1' or higher to avoid divide by zero errors.
+//
+// # Output Clock Configuration
+//
+// The multisynth dividers are applied to the specified PLL output,
+// and are used to reduce the PLL output to a valid range (500kHz
+// to 160MHz). The relationship can be seen in this formula, where
+// fVCO is the PLL output frequency and MSx is the multisynth divider:
+//
+// fOUT = fVCO / MSx
+//
+// Valid multisynth dividers are 4, 6, or 8 when using integers,
+// or any fractional values between 8 + 1/1,048,575 and 900 + 0/1
+// The following formula is used for the fractional mode divider:
+//
+// a + b / c
+//
+// a = The integer value, which must be 4, 6 or 8 in integer mode (MSx_INT=1) or 8..900 in fractional mode (MSx_INT=0).
+// b = The fractional numerator (0..1,048,575)
+// c = The fractional denominator (1..1,048,575)
+//
+// NOTE: Try to use integers whenever possible to avoid clock jitter
+// NOTE: For output frequencies > 150MHz, you must set the divider
+//
+//	to 4 and adjust to PLL to generate the frequency (for example
+//	a PLL of 640 to generate a 160MHz output clock). This is not
+//	yet supported in the driver, which limits frequencies to 500kHz .. 150MHz.
+//
+// NOTE: For frequencies below 500kHz (down to 8kHz) Rx_DIV must be
+//
+//	used, but this isn't currently implemented in the driver.
+func (d *Device) ConfigureMultisynth(output uint8, pll uint8, div uint32, num uint32, denom uint32) error {
+	// Basic validation
+	if !d.initialised {
+		return ErrNotInitialised
+	}
+	// Channel range
+	if !(output < 3) {
+		return fmt.Errorf("output channel must be between 0 and 2")
+	}
+	// Divider integer value
+	if !((div > 3) && (div < 2049)) {
+		return ErrInvalidParameter
+	}
+	// Avoid divide by zero
+	if !(denom > 0) {
+		return ErrInvalidParameter
+	}
+	// 20-bit limit
+	if !(num <= 0xFFFFF) {
+		return ErrInvalidParameter
+	}
+	// 20-bit limit
+	if !(denom <= 0xFFFFF) {
+		return ErrInvalidParameter
+	}
+
+	// Make sure the requested PLL has been initialised
+	if pll == PLL_A && !d.pllaConfigured {
+		return ErrInvalidParameter
+	}
+	if pll == PLL_B && !d.pllbConfigured {
+		return ErrInvalidParameter
+	}
+
+	// Output Multisynth Divider Equations
+	//
+	// where: a = div, b = num and c = denom
+	//
+	// P1 register is an 18-bit value using following formula:
+	//
+	//  P1[17:0] = 128 * a + floor(128*(b/c)) - 512
+	//
+	// P2 register is a 20-bit value using the following formula:
+	//
+	//  P2[19:0] = 128 * b - c * floor(128*(b/c))
+	//
+	// P3 register is a 20-bit value using the following formula:
+	//
+	//  P3[19:0] = c
+	//
+
+	// Set PLL config registers
+	var p1, p2, p3 uint32
+	if num == 0 {
+		// Integer mode
+		p1 = 128*div - 512
+		p2 = 0
+		p3 = denom
+	} else if denom == 1 {
+		// Fractional mode, simplified calculations
+		p1 = 128*div + 128*num - 512
+		p2 = 128*num - 128
+		p3 = 1
+	} else {
+		// Fractional mode
+		p1 = uint32(128*float64(div) + math.Floor(128*(float64(num)/float64(denom))) - 512)
+		p2 = uint32(128*float64(num) - float64(denom)*math.Floor(128*(float64(num)/float64(denom))))
+		p3 = denom
+	}
+
+	// Get the appropriate starting point for the PLL registers
+	baseaddr := uint8(0)
+	switch output {
+	case 0:
+		baseaddr = MULTISYNTH0_PARAMETERS_1
+	case 1:
+		baseaddr = MULTISYNTH1_PARAMETERS_1
+	case 2:
+		baseaddr = MULTISYNTH2_PARAMETERS_1
+	}
+
+	// Set the MSx config registers
+	data := [8]byte{}
+	data[0] = uint8((p3 & 0xFF00) >> 8)
+	data[1] = uint8(p3 & 0xFF)
+	data[2] = uint8(((p1 & 0x30000) >> 16)) | d.lastRdivValue[output]
+	data[3] = uint8((p1 & 0xFF00) >> 8)
+	data[4] = uint8(p1 & 0xFF)
+	data[5] = uint8(((p3 & 0xF0000) >> 12) | ((p2 & 0xF0000) >> 16))
+	data[6] = uint8((p2 & 0xFF00) >> 8)
+	data[7] = uint8(p2 & 0xFF)
+	if err := d.bus.Tx(uint16(baseaddr), data[:], nil); err != nil {
+		return err
+	}
+
+	// Configure the clk control and enable the output
+	// TODO: Check if the clk control byte needs to be updated.
+	clkControlReg := uint8(0x0F) // 8mA drive strength, MS0 as CLK0 source, Clock not inverted, powered up
+	if pll == PLL_B {
+		clkControlReg |= (1 << 5) // Uses PLLB
+	}
+	if num == 0 {
+		clkControlReg |= (1 << 6) // Integer mode
+	}
+
+	var register uint8
+	switch output {
+	case 0:
+		register = CLK0_CONTROL
+	case 1:
+		register = CLK1_CONTROL
+	case 2:
+		register = CLK2_CONTROL
+	}
+
+	return d.rw.Write8(register, clkControlReg)
+}
+
+func (d *Device) ConfigureRdiv(output uint8, div uint8) error {
+	// Channel range
+	if !(output < 3) {
+		return ErrInvalidParameter
+	}
+
+	var register uint8
+	switch output {
+	case 0:
+		register = MULTISYNTH0_PARAMETERS_3
+	case 1:
+		register = MULTISYNTH1_PARAMETERS_3
+	case 2:
+		register = MULTISYNTH2_PARAMETERS_3
+	}
+
+	data, err := d.rw.Read8(register)
+	if err != nil {
+		return err
+	}
+
+	d.lastRdivValue[output] = (div & 0x07) << 4
+	data = (data & 0x0F) | d.lastRdivValue[output]
+	return d.rw.Write8(register, data)
+}

smoketest.sh

@@ -144,6 +144,7 @@ tinygo build -size short -o ./build/test.hex -target=pico ./examples/tmc5160/mai
 tinygo build -size short -o ./build/test.uf2 -target=nicenano ./examples/sharpmem/main.go
 tinygo build -size short -o ./build/test.hex -target=feather-nrf52840 ./examples/max6675/main.go
 tinygo build -size short -o ./build/test.hex -target=pico ./examples/ens160/main.go
+tinygo build -size short -o ./build/test.hex -target=pico ./examples/si5351/main.go
 # network examples (espat)
 tinygo build -size short -o ./build/test.hex -target=challenger-rp2040 ./examples/net/ntpclient/
 # network examples (wifinina)

ssd1289/pinbus.go

@@ -1,3 +1,5 @@
+//go:build tinygo
+
 package ssd1289
 
 import "machine"

ssd1289/ssd1289.go

@@ -7,6 +7,9 @@ import (
 	"image/color"
 	"machine"
 	"time"
+
+	"tinygo.org/x/drivers/internal/legacy"
+	"tinygo.org/x/drivers/internal/pin"
 )
 
 type Bus interface {
@@ -14,10 +17,10 @@ type Bus interface {
 }
 
 type Device struct {
-	rs  machine.Pin
-	wr  machine.Pin
-	cs  machine.Pin
-	rst machine.Pin
+	rs  pin.OutputFunc
+	wr  pin.OutputFunc
+	cs  pin.OutputFunc
+	rst pin.OutputFunc
 	bus Bus
 }
 
@@ -26,21 +29,20 @@ const height = int16(320)
 
 func New(rs machine.Pin, wr machine.Pin, cs machine.Pin, rst machine.Pin, bus Bus) Device {
 	d := Device{
-		rs:  rs,
-		wr:  wr,
-		cs:  cs,
-		rst: rst,
+		rs:  rs.Set,
+		wr:  wr.Set,
+		cs:  cs.Set,
+		rst: rst.Set,
 		bus: bus,
 	}
+	legacy.ConfigurePinOut(rs)
+	legacy.ConfigurePinOut(wr)
+	legacy.ConfigurePinOut(cs)
+	legacy.ConfigurePinOut(rst)
 
-	rs.Configure(machine.PinConfig{Mode: machine.PinOutput})
-	wr.Configure(machine.PinConfig{Mode: machine.PinOutput})
-	cs.Configure(machine.PinConfig{Mode: machine.PinOutput})
-	rst.Configure(machine.PinConfig{Mode: machine.PinOutput})
-
-	cs.High()
-	rst.High()
-	wr.High()
+	cs.Set(true)
+	rst.Set(true)
+	wr.Set(true)
 
 	return d
 }

ssd1331/ssd1331.go

@@ -5,12 +5,13 @@ package ssd1331 // import "tinygo.org/x/drivers/ssd1331"
 
 import (
 	"image/color"
-	"machine"
 
 	"errors"
 	"time"
 
 	"tinygo.org/x/drivers"
+	"tinygo.org/x/drivers/internal/legacy"
+	"tinygo.org/x/drivers/internal/pin"
 )
 
 type Model uint8
@@ -19,9 +20,9 @@ type Rotation uint8
 // Device wraps an SPI connection.
 type Device struct {
 	bus         drivers.SPI
-	dcPin       machine.Pin
-	resetPin    machine.Pin
-	csPin       machine.Pin
+	dcPin       pin.OutputFunc
+	resetPin    pin.OutputFunc
+	csPin       pin.OutputFunc
 	width       int16
 	height      int16
 	batchLength int16
@@ -36,15 +37,15 @@ type Config struct {
 }
 
 // New creates a new SSD1331 connection. The SPI wire must already be configured.
-func New(bus drivers.SPI, resetPin, dcPin, csPin machine.Pin) Device {
-	dcPin.Configure(machine.PinConfig{Mode: machine.PinOutput})
-	resetPin.Configure(machine.PinConfig{Mode: machine.PinOutput})
-	csPin.Configure(machine.PinConfig{Mode: machine.PinOutput})
+func New(bus drivers.SPI, resetPin, dcPin, csPin pin.Output) Device {
+	legacy.ConfigurePinOut(dcPin)
+	legacy.ConfigurePinOut(resetPin)
+	legacy.ConfigurePinOut(csPin)
 	return Device{
 		bus:      bus,
-		dcPin:    dcPin,
-		resetPin: resetPin,
-		csPin:    csPin,
+		dcPin:    dcPin.Set,
+		resetPin: resetPin.Set,
+		csPin:    csPin.Set,
 	}
 }
 
@@ -251,7 +252,7 @@ func (d *Device) Data(data uint8) {
 
 // Tx sends data to the display
 func (d *Device) Tx(data []byte, isCommand bool) {
-	d.dcPin.Set(!isCommand)
+	d.dcPin(!isCommand)
 	d.bus.Tx(data, nil)
 }
 

ssd1351/ssd1351.go

@@ -6,10 +6,11 @@ package ssd1351 // import "tinygo.org/x/drivers/ssd1351"
 import (
 	"errors"
 	"image/color"
-	"machine"
 	"time"
 
 	"tinygo.org/x/drivers"
+	"tinygo.org/x/drivers/internal/legacy"
+	"tinygo.org/x/drivers/internal/pin"
 )
 
 var (
@@ -19,17 +20,18 @@ var (
 
 // Device wraps an SPI connection.
 type Device struct {
-	bus          drivers.SPI
-	dcPin        machine.Pin
-	resetPin     machine.Pin
-	csPin        machine.Pin
-	enPin        machine.Pin
-	rwPin        machine.Pin
-	width        int16
-	height       int16
-	rowOffset    int16
-	columnOffset int16
-	bufferLength int16
+	bus           drivers.SPI
+	dcPin         pin.OutputFunc
+	resetPin      pin.OutputFunc
+	csPin         pin.OutputFunc
+	enPin         pin.OutputFunc
+	rwPin         pin.OutputFunc
+	configurePins func()
+	width         int16
+	height        int16
+	rowOffset     int16
+	columnOffset  int16
+	bufferLength  int16
 }
 
 // Config is the configuration for the display
@@ -41,19 +43,29 @@ type Config struct {
 }
 
 // New creates a new SSD1351 connection. The SPI wire must already be configured.
-func New(bus drivers.SPI, resetPin, dcPin, csPin, enPin, rwPin machine.Pin) Device {
+func New(bus drivers.SPI, resetPin, dcPin, csPin, enPin, rwPin pin.Output) Device {
 	return Device{
 		bus:      bus,
-		dcPin:    dcPin,
-		resetPin: resetPin,
-		csPin:    csPin,
-		enPin:    enPin,
-		rwPin:    rwPin,
+		dcPin:    dcPin.Set,
+		resetPin: resetPin.Set,
+		csPin:    csPin.Set,
+		enPin:    enPin.Set,
+		rwPin:    rwPin.Set,
+		configurePins: func() {
+			legacy.ConfigurePinOut(dcPin)
+			legacy.ConfigurePinOut(resetPin)
+			legacy.ConfigurePinOut(csPin)
+			legacy.ConfigurePinOut(enPin)
+			legacy.ConfigurePinOut(rwPin)
+		},
 	}
 }
 
 // Configure initializes the display with default configuration
 func (d *Device) Configure(cfg Config) {
+	if d.configurePins == nil {
+		panic(legacy.ErrConfigBeforeInstantiated)
+	}
 	if cfg.Width == 0 {
 		cfg.Width = 128
 	}
@@ -73,11 +85,7 @@ func (d *Device) Configure(cfg Config) {
 	}
 
 	// configure GPIO pins
-	d.dcPin.Configure(machine.PinConfig{Mode: machine.PinOutput})
-	d.resetPin.Configure(machine.PinConfig{Mode: machine.PinOutput})
-	d.csPin.Configure(machine.PinConfig{Mode: machine.PinOutput})
-	d.enPin.Configure(machine.PinConfig{Mode: machine.PinOutput})
-	d.rwPin.Configure(machine.PinConfig{Mode: machine.PinOutput})
+	d.configurePins()
 
 	// reset the device
 	d.resetPin.High()
@@ -278,7 +286,7 @@ func (d *Device) Data(data uint8) {
 
 // Tx sends data to the display
 func (d *Device) Tx(data []byte, isCommand bool) {
-	d.dcPin.Set(!isCommand)
+	d.dcPin(!isCommand)
 	d.csPin.Low()
 	d.bus.Tx(data, nil)
 	d.csPin.High()

st7735/st7735.go

@@ -5,12 +5,13 @@ package st7735 // import "tinygo.org/x/drivers/st7735"
 
 import (
 	"image/color"
-	"machine"
 	"time"
 
 	"errors"
 
 	"tinygo.org/x/drivers"
+	"tinygo.org/x/drivers/internal/legacy"
+	"tinygo.org/x/drivers/internal/pin"
 	"tinygo.org/x/drivers/pixel"
 )
 
@@ -39,10 +40,10 @@ type Device = DeviceOf[pixel.RGB565BE]
 // formats.
 type DeviceOf[T Color] struct {
 	bus          drivers.SPI
-	dcPin        machine.Pin
-	resetPin     machine.Pin
-	csPin        machine.Pin
-	blPin        machine.Pin
+	dcPin        pin.OutputFunc
+	resetPin     pin.OutputFunc
+	csPin        pin.OutputFunc
+	blPin        pin.OutputFunc
 	width        int16
 	height       int16
 	columnOffset int16
@@ -65,23 +66,23 @@ type Config struct {
 }
 
 // New creates a new ST7735 connection. The SPI wire must already be configured.
-func New(bus drivers.SPI, resetPin, dcPin, csPin, blPin machine.Pin) Device {
+func New(bus drivers.SPI, resetPin, dcPin, csPin, blPin pin.Output) Device {
 	return NewOf[pixel.RGB565BE](bus, resetPin, dcPin, csPin, blPin)
 }
 
 // NewOf creates a new ST7735 connection with a particular pixel format. The SPI
 // wire must already be configured.
-func NewOf[T Color](bus drivers.SPI, resetPin, dcPin, csPin, blPin machine.Pin) DeviceOf[T] {
-	dcPin.Configure(machine.PinConfig{Mode: machine.PinOutput})
-	resetPin.Configure(machine.PinConfig{Mode: machine.PinOutput})
-	csPin.Configure(machine.PinConfig{Mode: machine.PinOutput})
-	blPin.Configure(machine.PinConfig{Mode: machine.PinOutput})
+func NewOf[T Color](bus drivers.SPI, resetPin, dcPin, csPin, blPin pin.Output) DeviceOf[T] {
+	legacy.ConfigurePinOut(dcPin)
+	legacy.ConfigurePinOut(resetPin)
+	legacy.ConfigurePinOut(csPin)
+	legacy.ConfigurePinOut(blPin)
 	return DeviceOf[T]{
 		bus:      bus,
-		dcPin:    dcPin,
-		resetPin: resetPin,
-		csPin:    csPin,
-		blPin:    blPin,
+		dcPin:    dcPin.Set,
+		resetPin: resetPin.Set,
+		csPin:    csPin.Set,
+		blPin:    blPin.Set,
 	}
 }
 
@@ -423,7 +424,7 @@ func (d *DeviceOf[T]) Data(data uint8) {
 
 // Tx sends data to the display
 func (d *DeviceOf[T]) Tx(data []byte, isCommand bool) {
-	d.dcPin.Set(!isCommand)
+	d.dcPin(!isCommand)
 	d.bus.Tx(data, nil)
 }
 

st7789/st7789.go

@@ -7,13 +7,14 @@ package st7789 // import "tinygo.org/x/drivers/st7789"
 
 import (
 	"image/color"
-	"machine"
 	"math"
 	"time"
 
 	"errors"
 
 	"tinygo.org/x/drivers"
+	"tinygo.org/x/drivers/internal/legacy"
+	"tinygo.org/x/drivers/internal/pin"
 	"tinygo.org/x/drivers/pixel"
 )
 
@@ -46,10 +47,10 @@ type Device = DeviceOf[pixel.RGB565BE]
 // formats.
 type DeviceOf[T Color] struct {
 	bus             drivers.SPI
-	dcPin           machine.Pin
-	resetPin        machine.Pin
-	csPin           machine.Pin
-	blPin           machine.Pin
+	dcPin           pin.OutputFunc
+	resetPin        pin.OutputFunc
+	csPin           pin.OutputFunc
+	blPin           pin.OutputFunc
 	width           int16
 	height          int16
 	columnOffsetCfg int16
@@ -83,23 +84,27 @@ type Config struct {
 }
 
 // New creates a new ST7789 connection. The SPI wire must already be configured.
-func New(bus drivers.SPI, resetPin, dcPin, csPin, blPin machine.Pin) Device {
+func New(bus drivers.SPI, resetPin, dcPin, csPin, blPin pin.Output) Device {
 	return NewOf[pixel.RGB565BE](bus, resetPin, dcPin, csPin, blPin)
 }
 
 // NewOf creates a new ST7789 connection with a particular pixel format. The SPI
 // wire must already be configured.
-func NewOf[T Color](bus drivers.SPI, resetPin, dcPin, csPin, blPin machine.Pin) DeviceOf[T] {
-	dcPin.Configure(machine.PinConfig{Mode: machine.PinOutput})
-	resetPin.Configure(machine.PinConfig{Mode: machine.PinOutput})
-	csPin.Configure(machine.PinConfig{Mode: machine.PinOutput})
-	blPin.Configure(machine.PinConfig{Mode: machine.PinOutput})
+func NewOf[T Color](bus drivers.SPI, resetPin, dcPin, csPin, blPin pin.Output) DeviceOf[T] {
+	legacy.ConfigurePinOut(dcPin)
+	legacy.ConfigurePinOut(resetPin)
+	legacy.ConfigurePinOut(csPin)
+	legacy.ConfigurePinOut(blPin)
+	var cs pin.OutputFunc
+	if !legacy.PinIsNoPin(csPin) {
+		cs = csPin.Set
+	}
 	return DeviceOf[T]{
 		bus:      bus,
-		dcPin:    dcPin,
-		resetPin: resetPin,
-		csPin:    csPin,
-		blPin:    blPin,
+		dcPin:    dcPin.Set,
+		resetPin: resetPin.Set,
+		csPin:    cs,
+		blPin:    blPin.Set,
 	}
 }
 
@@ -229,7 +234,7 @@ func (d *DeviceOf[T]) sendCommand(command uint8, data []byte) error {
 // startWrite must be called at the beginning of all exported methods to set the
 // chip select pin low.
 func (d *DeviceOf[T]) startWrite() {
-	if d.csPin != machine.NoPin {
+	if d.csPin != nil {
 		d.csPin.Low()
 	}
 }
@@ -237,7 +242,7 @@ func (d *DeviceOf[T]) startWrite() {
 // endWrite must be called at the end of all exported methods to set the chip
 // select pin high.
 func (d *DeviceOf[T]) endWrite() {
-	if d.csPin != machine.NoPin {
+	if d.csPin != nil {
 		d.csPin.High()
 	}
 }

sx127x/radiocontrol_pins.go

@@ -1,3 +1,5 @@
+//go:build tinygo
+
 package sx127x
 
 import (

sx127x/sx127x.go

@@ -6,10 +6,10 @@ package sx127x
 
 import (
 	"errors"
-	"machine"
 	"time"
 
 	"tinygo.org/x/drivers"
+	"tinygo.org/x/drivers/internal/pin"
 	"tinygo.org/x/drivers/lora"
 )
 
@@ -22,7 +22,7 @@ const (
 // Device wraps an SPI connection to a SX127x device.
 type Device struct {
 	spi            drivers.SPI          // SPI bus for module communication
-	rstPin         machine.Pin          // GPIO for reset
+	rstPin         pin.OutputFunc       // GPIO for reset
 	radioEventChan chan lora.RadioEvent // Channel for Receiving events
 	loraConf       lora.Config          // Current Lora configuration
 	controller     RadioController      // to manage interactions with the radio
@@ -43,10 +43,10 @@ func (d *Device) GetRadioEventChan() chan lora.RadioEvent {
 }
 
 // New creates a new SX127x connection. The SPI bus must already be configured.
-func New(spi drivers.SPI, rstPin machine.Pin) *Device {
+func New(spi drivers.SPI, rstPin pin.Output) *Device {
 	k := Device{
 		spi:            spi,
-		rstPin:         rstPin,
+		rstPin:         rstPin.Set,
 		radioEventChan: make(chan lora.RadioEvent, RADIOEVENTCHAN_SIZE),
 		spiTxBuf:       make([]byte, SPI_BUFFER_SIZE),
 		spiRxBuf:       make([]byte, SPI_BUFFER_SIZE),

uc8151/uc8151.go

@@ -50,12 +50,7 @@ type Device struct {
 type Speed uint8
 
 // New returns a new uc8151 driver. Pass in a fully configured SPI bus.
-// Pins passed in must be configured beforehand.
 func New(bus drivers.SPI, csPin, dcPin, rstPin pin.Output, busyPin pin.Input) Device {
-	// For backwards compatibility.
-	// This driver used to configure pins,
-	// so leave in to not break users.
-	// May be removed in future so try not to depend on it!
 	legacy.ConfigurePinOut(csPin)
 	legacy.ConfigurePinOut(dcPin)
 	legacy.ConfigurePinOut(rstPin)

waveshare-epd/epd1in54/epd1in54.go

@@ -12,6 +12,9 @@ import (
 	"image/color"
 	"machine"
 	"time"
+
+	"tinygo.org/x/drivers/internal/legacy"
+	"tinygo.org/x/drivers/internal/pin"
 )
 
 type Config struct {
@@ -22,14 +25,14 @@ type Config struct {
 }
 
 type Device struct {
-	bus  *machine.SPI
-	cs   machine.Pin
-	dc   machine.Pin
-	rst  machine.Pin
-	busy machine.Pin
-
-	buffer   []uint8
-	rotation Rotation
+	bus           *machine.SPI
+	cs            pin.OutputFunc
+	dc            pin.OutputFunc
+	rst           pin.OutputFunc
+	isBusy        pin.InputFunc
+	configurePins func()
+	buffer        []uint8
+	rotation      Rotation
 }
 
 type Rotation uint8
@@ -79,22 +82,28 @@ var partialRefresh = [159]uint8{
 }
 
 // New returns a new epd1in54 driver. Pass in a fully configured SPI bus.
-func New(bus *machine.SPI, csPin, dcPin, rstPin, busyPin machine.Pin) Device {
+func New(bus *machine.SPI, csPin, dcPin, rstPin pin.Output, busyPin pin.Input) Device {
 	return Device{
 		buffer: make([]uint8, (uint32(Width)*uint32(Height))/8),
 		bus:    bus,
-		cs:     csPin,
-		dc:     dcPin,
-		rst:    rstPin,
-		busy:   busyPin,
+		cs:     csPin.Set,
+		dc:     dcPin.Set,
+		rst:    rstPin.Set,
+		isBusy: busyPin.Get,
+		configurePins: func() {
+			legacy.ConfigurePinOut(csPin)
+			legacy.ConfigurePinOut(dcPin)
+			legacy.ConfigurePinOut(rstPin)
+			legacy.ConfigurePinInput(busyPin)
+		},
 	}
 }
 
 func (d *Device) LDirInit(cfg Config) {
-	d.cs.Configure(machine.PinConfig{Mode: machine.PinOutput})
-	d.rst.Configure(machine.PinConfig{Mode: machine.PinOutput})
-	d.dc.Configure(machine.PinConfig{Mode: machine.PinOutput})
-	d.busy.Configure(machine.PinConfig{Mode: machine.PinInput})
+	if d.configurePins == nil {
+		panic(legacy.ErrConfigBeforeInstantiated)
+	}
+	d.configurePins()
 
 	d.bus.Configure(machine.SPIConfig{
 		Frequency: 2000000,
@@ -150,10 +159,10 @@ func (d *Device) LDirInit(cfg Config) {
 }
 
 func (d *Device) HDirInit(cfg Config) {
-	d.cs.Configure(machine.PinConfig{Mode: machine.PinOutput})
-	d.rst.Configure(machine.PinConfig{Mode: machine.PinOutput})
-	d.dc.Configure(machine.PinConfig{Mode: machine.PinOutput})
-	d.busy.Configure(machine.PinConfig{Mode: machine.PinInput})
+	if d.configurePins == nil {
+		panic(legacy.ErrConfigBeforeInstantiated)
+	}
+	d.configurePins()
 
 	d.bus.Configure(machine.SPIConfig{
 		Frequency: 2000000,
@@ -369,7 +378,7 @@ func (d *Device) Clear() {
 
 // WaitUntilIdle waits until the display is ready
 func (d *Device) WaitUntilIdle() {
-	for d.busy.Get() {
+	for d.isBusy() {
 		time.Sleep(100 * time.Millisecond)
 	}
 	time.Sleep(200 * time.Millisecond)
@@ -377,7 +386,7 @@ func (d *Device) WaitUntilIdle() {
 
 // IsBusy returns the busy status of the display
 func (d *Device) IsBusy() bool {
-	return d.busy.Get()
+	return d.isBusy()
 }
 
 // ClearBuffer sets the buffer to 0xFF (white)

waveshare-epd/epd2in13/epd2in13.go

@@ -6,10 +6,11 @@ package epd2in13 // import "tinygo.org/x/drivers/waveshare-epd/epd2in13"
 import (
 	"errors"
 	"image/color"
-	"machine"
 	"time"
 
 	"tinygo.org/x/drivers"
+	"tinygo.org/x/drivers/internal/legacy"
+	"tinygo.org/x/drivers/internal/pin"
 )
 
 type Config struct {
@@ -21,10 +22,10 @@ type Config struct {
 
 type Device struct {
 	bus          drivers.SPI
-	cs           machine.Pin
-	dc           machine.Pin
-	rst          machine.Pin
-	busy         machine.Pin
+	cs           pin.OutputFunc
+	dc           pin.OutputFunc
+	rst          pin.OutputFunc
+	isBusy       pin.InputFunc
 	logicalWidth int16
 	width        int16
 	height       int16
@@ -53,17 +54,17 @@ var lutPartialUpdate = [30]uint8{
 }
 
 // New returns a new epd2in13x driver. Pass in a fully configured SPI bus.
-func New(bus drivers.SPI, csPin, dcPin, rstPin, busyPin machine.Pin) Device {
-	csPin.Configure(machine.PinConfig{Mode: machine.PinOutput})
-	dcPin.Configure(machine.PinConfig{Mode: machine.PinOutput})
-	rstPin.Configure(machine.PinConfig{Mode: machine.PinOutput})
-	busyPin.Configure(machine.PinConfig{Mode: machine.PinInput})
+func New(bus drivers.SPI, csPin, dcPin, rstPin pin.Output, busyPin pin.Input) Device {
+	legacy.ConfigurePinOut(csPin)
+	legacy.ConfigurePinOut(dcPin)
+	legacy.ConfigurePinOut(rstPin)
+	legacy.ConfigurePinInput(busyPin)
 	return Device{
-		bus:  bus,
-		cs:   csPin,
-		dc:   dcPin,
-		rst:  rstPin,
-		busy: busyPin,
+		bus:    bus,
+		cs:     csPin.Set,
+		dc:     dcPin.Set,
+		rst:    rstPin.Set,
+		isBusy: busyPin.Get,
 	}
 }
 
@@ -298,14 +299,14 @@ func (d *Device) setMemoryPointer(x int16, y int16) {
 
 // WaitUntilIdle waits until the display is ready
 func (d *Device) WaitUntilIdle() {
-	for d.busy.Get() {
+	for d.isBusy() {
 		time.Sleep(100 * time.Millisecond)
 	}
 }
 
 // IsBusy returns the busy status of the display
 func (d *Device) IsBusy() bool {
-	return d.busy.Get()
+	return d.isBusy()
 }
 
 // ClearBuffer sets the buffer to 0xFF (white)

waveshare-epd/epd2in13x/epd2in13x.go

@@ -6,10 +6,11 @@ package epd2in13x // import "tinygo.org/x/drivers/waveshare-epd/epd2in13x"
 import (
 	"errors"
 	"image/color"
-	"machine"
 	"time"
 
 	"tinygo.org/x/drivers"
+	"tinygo.org/x/drivers/internal/legacy"
+	"tinygo.org/x/drivers/internal/pin"
 )
 
 type Config struct {
@@ -20,10 +21,10 @@ type Config struct {
 
 type Device struct {
 	bus          drivers.SPI
-	cs           machine.Pin
-	dc           machine.Pin
-	rst          machine.Pin
-	busy         machine.Pin
+	cs           pin.OutputFunc
+	dc           pin.OutputFunc
+	rst          pin.OutputFunc
+	isBusy       pin.InputFunc
 	width        int16
 	height       int16
 	buffer       [][]uint8
@@ -33,17 +34,17 @@ type Device struct {
 type Color uint8
 
 // New returns a new epd2in13x driver. Pass in a fully configured SPI bus.
-func New(bus drivers.SPI, csPin, dcPin, rstPin, busyPin machine.Pin) Device {
-	csPin.Configure(machine.PinConfig{Mode: machine.PinOutput})
-	dcPin.Configure(machine.PinConfig{Mode: machine.PinOutput})
-	rstPin.Configure(machine.PinConfig{Mode: machine.PinOutput})
-	busyPin.Configure(machine.PinConfig{Mode: machine.PinInput})
+func New(bus drivers.SPI, csPin, dcPin, rstPin pin.Output, busyPin pin.Input) Device {
+	legacy.ConfigurePinOut(csPin)
+	legacy.ConfigurePinOut(dcPin)
+	legacy.ConfigurePinOut(rstPin)
+	legacy.ConfigurePinInput(busyPin)
 	return Device{
-		bus:  bus,
-		cs:   csPin,
-		dc:   dcPin,
-		rst:  rstPin,
-		busy: busyPin,
+		bus:    bus,
+		cs:     csPin.Set,
+		dc:     dcPin.Set,
+		rst:    rstPin.Set,
+		isBusy: busyPin.Get,
 	}
 }
 
@@ -277,14 +278,14 @@ func (d *Device) ClearDisplay() {
 
 // WaitUntilIdle waits until the display is ready
 func (d *Device) WaitUntilIdle() {
-	for !d.busy.Get() {
+	for !d.isBusy() {
 		time.Sleep(100 * time.Millisecond)
 	}
 }
 
 // IsBusy returns the busy status of the display
 func (d *Device) IsBusy() bool {
-	return d.busy.Get()
+	return d.isBusy()
 }
 
 // ClearBuffer sets the buffer to 0xFF (white)

waveshare-epd/epd2in66b/dev.go

@@ -5,10 +5,11 @@ package epd2in66b
 
 import (
 	"image/color"
-	"machine"
 	"time"
 
 	"tinygo.org/x/drivers"
+	"tinygo.org/x/drivers/internal/legacy"
+	"tinygo.org/x/drivers/internal/pin"
 )
 
 const (
@@ -18,20 +19,12 @@ const (
 
 const Baudrate = 4_000_000 // 4 MHz
 
-type Config struct {
-	ResetPin      machine.Pin
-	DataPin       machine.Pin
-	ChipSelectPin machine.Pin
-	BusyPin       machine.Pin
-}
-
 type Device struct {
-	bus  drivers.SPI
-	cs   machine.Pin
-	dc   machine.Pin
-	rst  machine.Pin
-	busy machine.Pin
-
+	bus         drivers.SPI
+	cs          pin.OutputFunc
+	dc          pin.OutputFunc
+	rst         pin.OutputFunc
+	isBusy      pin.InputFunc
 	blackBuffer []byte
 	redBuffer   []byte
 }
@@ -50,18 +43,23 @@ func New(bus drivers.SPI) Device {
 	}
 }
 
+type Config struct {
+	ResetPin      pin.Output
+	DataPin       pin.Output
+	ChipSelectPin pin.Output
+	BusyPin       pin.Input
+}
+
 // Configure configures the device and its pins.
 func (d *Device) Configure(c Config) error {
-	d.cs = c.ChipSelectPin
-	d.dc = c.DataPin
-	d.rst = c.ResetPin
-	d.busy = c.BusyPin
-
-	d.cs.Configure(machine.PinConfig{Mode: machine.PinOutput})
-	d.dc.Configure(machine.PinConfig{Mode: machine.PinOutput})
-	d.rst.Configure(machine.PinConfig{Mode: machine.PinOutput})
-	d.busy.Configure(machine.PinConfig{Mode: machine.PinInput})
-
+	d.cs = c.ChipSelectPin.Set
+	d.dc = c.DataPin.Set
+	d.rst = c.ResetPin.Set
+	d.isBusy = c.BusyPin.Get
+	legacy.ConfigurePinOut(c.ChipSelectPin)
+	legacy.ConfigurePinOut(c.DataPin)
+	legacy.ConfigurePinOut(c.ResetPin)
+	legacy.ConfigurePinInput(c.BusyPin)
 	return nil
 }
 
@@ -229,7 +227,7 @@ func (d *Device) WaitUntilIdle() {
 	// give it some time to get busy
 	time.Sleep(50 * time.Millisecond)
 
-	for d.busy.Get() { // high = busy
+	for d.isBusy() { // high = busy
 		time.Sleep(10 * time.Millisecond)
 	}
 

waveshare-epd/epd2in9/epd2in9.go

@@ -13,10 +13,11 @@ package epd2in9 // import "tinygo.org/x/drivers/waveshare-epd/epd2in9"
 
 import (
 	"image/color"
-	"machine"
 	"time"
 
 	"tinygo.org/x/drivers"
+	"tinygo.org/x/drivers/internal/legacy"
+	"tinygo.org/x/drivers/internal/pin"
 )
 
 type Config struct {
@@ -28,10 +29,10 @@ type Config struct {
 
 type Device struct {
 	bus          drivers.SPI
-	cs           machine.Pin
-	dc           machine.Pin
-	rst          machine.Pin
-	busy         machine.Pin
+	cs           pin.OutputFunc
+	dc           pin.OutputFunc
+	rst          pin.OutputFunc
+	isBusy       pin.InputFunc
 	logicalWidth int16
 	width        int16
 	height       int16
@@ -61,17 +62,17 @@ var lutPartialUpdate = [30]uint8{
 }
 
 // New returns a new epd2in9 driver. Pass in a fully configured SPI bus.
-func New(bus drivers.SPI, csPin, dcPin, rstPin, busyPin machine.Pin) Device {
-	csPin.Configure(machine.PinConfig{Mode: machine.PinOutput})
-	dcPin.Configure(machine.PinConfig{Mode: machine.PinOutput})
-	rstPin.Configure(machine.PinConfig{Mode: machine.PinOutput})
-	busyPin.Configure(machine.PinConfig{Mode: machine.PinInput})
+func New(bus drivers.SPI, csPin, dcPin, rstPin pin.Output, busyPin pin.Input) Device {
+	legacy.ConfigurePinOut(csPin)
+	legacy.ConfigurePinOut(dcPin)
+	legacy.ConfigurePinOut(rstPin)
+	legacy.ConfigurePinInput(busyPin)
 	return Device{
-		bus:  bus,
-		cs:   csPin,
-		dc:   dcPin,
-		rst:  rstPin,
-		busy: busyPin,
+		bus:    bus,
+		cs:     csPin.Set,
+		dc:     dcPin.Set,
+		rst:    rstPin.Set,
+		isBusy: busyPin.Get,
 	}
 }
 
@@ -245,14 +246,14 @@ func (d *Device) setMemoryPointer(x int16, y int16) {
 
 // WaitUntilIdle waits until the display is ready
 func (d *Device) WaitUntilIdle() {
-	for d.busy.Get() {
+	for d.isBusy() {
 		time.Sleep(100 * time.Millisecond)
 	}
 }
 
 // IsBusy returns the busy status of the display
 func (d *Device) IsBusy() bool {
-	return d.busy.Get()
+	return d.isBusy()
 }
 
 // ClearBuffer sets the buffer to 0xFF (white)

waveshare-epd/epd4in2/epd4in2.go

@@ -10,10 +10,11 @@ package epd4in2
 
 import (
 	"image/color"
-	"machine"
 	"time"
 
 	"tinygo.org/x/drivers"
+	"tinygo.org/x/drivers/internal/legacy"
+	"tinygo.org/x/drivers/internal/pin"
 )
 
 type Config struct {
@@ -25,10 +26,10 @@ type Config struct {
 
 type Device struct {
 	bus          drivers.SPI
-	cs           machine.Pin
-	dc           machine.Pin
-	rst          machine.Pin
-	busy         machine.Pin
+	cs           pin.OutputFunc
+	dc           pin.OutputFunc
+	rst          pin.OutputFunc
+	isBusy       pin.InputFunc
 	logicalWidth int16
 	width        int16
 	height       int16
@@ -40,17 +41,17 @@ type Device struct {
 type Rotation uint8
 
 // New returns a new epd4in2 driver. Pass in a fully configured SPI bus.
-func New(bus drivers.SPI, csPin, dcPin, rstPin, busyPin machine.Pin) Device {
-	csPin.Configure(machine.PinConfig{Mode: machine.PinOutput})
-	dcPin.Configure(machine.PinConfig{Mode: machine.PinOutput})
-	rstPin.Configure(machine.PinConfig{Mode: machine.PinOutput})
-	busyPin.Configure(machine.PinConfig{Mode: machine.PinInput})
+func New(bus drivers.SPI, csPin, dcPin, rstPin pin.Output, busyPin pin.Input) Device {
+	legacy.ConfigurePinOut(csPin)
+	legacy.ConfigurePinOut(dcPin)
+	legacy.ConfigurePinOut(rstPin)
+	legacy.ConfigurePinInput(busyPin)
 	return Device{
-		bus:  bus,
-		cs:   csPin,
-		dc:   dcPin,
-		rst:  rstPin,
-		busy: busyPin,
+		bus:    bus,
+		cs:     csPin.Set,
+		dc:     dcPin.Set,
+		rst:    rstPin.Set,
+		isBusy: busyPin.Get,
 	}
 }
 
@@ -311,14 +312,14 @@ func (d *Device) ClearDisplay() {
 
 // WaitUntilIdle waits until the display is ready
 func (d *Device) WaitUntilIdle() {
-	for d.busy.Get() {
+	for d.isBusy() {
 		time.Sleep(100 * time.Millisecond)
 	}
 }
 
 // IsBusy returns the busy status of the display
 func (d *Device) IsBusy() bool {
-	return d.busy.Get()
+	return d.isBusy()
 }
 
 // ClearBuffer sets the buffer to 0xFF (white)