Merge branch 'dev' into sdcard-refactor

examples/bno08x/i2c/main.go

@@ -0,0 +1,66 @@
+// Package main provides a basic example of using the BNO08x driver
+// to read rotation vector (quaternion) data from the sensor.
+package main
+
+import (
+	"machine"
+	"time"
+
+	"tinygo.org/x/drivers/bno08x"
+)
+
+func main() {
+	time.Sleep(2 * time.Second) // Wait for sensor to power up
+	// Initialize I2C bus
+	i2c := machine.I2C0
+	err := i2c.Configure(machine.I2CConfig{
+		Frequency: 400 * machine.KHz,
+	})
+	if err != nil {
+		println("Failed to configure I2C:", err.Error())
+		return
+	}
+
+	println("Initializing BNO08x sensor...")
+
+	// Create and configure sensor using I2C
+	sensor := bno08x.NewI2C(i2c)
+	err = sensor.Configure(bno08x.Config{})
+	if err != nil {
+		println("Failed to configure sensor:", err.Error())
+		return
+	}
+
+	println("Sensor initialized successfully")
+
+	// Enable Game Rotation Vector reports at 100Hz (10000 microseconds = 10ms interval)
+	// Using Game Rotation Vector (0x08) to match the working channel_debug test
+	err = sensor.EnableReport(bno08x.SensorGameRotationVector, 10000)
+	if err != nil {
+		println("Failed to enable game rotation vector:", err.Error())
+		return
+	}
+
+	println("Reading rotation vectors...")
+	println("Format: Real I J K Accuracy")
+
+	// Add a delay after enabling reports (Arduino does this)
+	time.Sleep(100 * time.Millisecond)
+
+	// Main loop - read and display quaternion data
+	for {
+		event, ok := sensor.GetSensorEvent()
+		if ok && (event.ID() == bno08x.SensorRotationVector || event.ID() == bno08x.SensorGameRotationVector) {
+			q := event.Quaternion()
+			if event.ID() == bno08x.SensorRotationVector {
+				println(q.Real, q.I, q.J, q.K, event.QuaternionAccuracy())
+			} else {
+				// GameRotationVector doesn't have accuracy
+				println(q.Real, q.I, q.J, q.K)
+			}
+		}
+
+		// Arduino uses 10ms delay in loop
+		time.Sleep(10 * time.Millisecond)
+	}
+}

examples/ds3231/alarms/main.go

@@ -0,0 +1,74 @@
+// Connects to an DS3231 I2C Real Time Clock (RTC) and sets both alarms. It then repeatedly checks
+// if the alarms are firing and prints out a message if that is the case.
+package main
+
+import (
+	"machine"
+	"time"
+
+	"tinygo.org/x/drivers/ds3231"
+)
+
+func main() {
+	machine.I2C0.Configure(machine.I2CConfig{})
+
+	rtc := ds3231.New(machine.I2C0)
+	rtc.Configure()
+
+	valid := rtc.IsTimeValid()
+	if !valid {
+		date := time.Date(2019, 12, 05, 20, 34, 12, 0, time.UTC)
+		rtc.SetTime(date)
+	}
+
+	// Set alarm1 so it triggers when the seconds match 59 => repeats every minute at dd:hh:mm:59
+	if err := rtc.SetAlarm1(time.Date(0, 0, 0, 0, 0, 59, 0, time.UTC), ds3231.A1_SECOND); err != nil {
+		println("Error while setting Alarm1")
+	}
+	if err := rtc.SetEnabledAlarm1(true); err != nil {
+		println("Error while enabling Alarm1")
+	}
+
+	// Set alarm2 so it triggers when the minutes match 35 => repeats every hour at dd:hh:35:ss
+	if err := rtc.SetAlarm2(time.Date(0, 0, 0, 0, 35, 0, 0, time.UTC), ds3231.A2_MINUTE); err != nil {
+		println("Error while setting Alarm2")
+	}
+	if err := rtc.SetEnabledAlarm2(true); err != nil {
+		println("Error while enabling Alarm2")
+	}
+
+	running := rtc.IsRunning()
+	if !running {
+		err := rtc.SetRunning(true)
+		if err != nil {
+			println("Error configuring RTC")
+		}
+	}
+
+	for {
+		dt, err := rtc.ReadTime()
+		if err != nil {
+			println("Error reading date:", err)
+			continue
+		}
+
+		a1 := rtc.IsAlarm1Fired()
+		a2 := rtc.IsAlarm2Fired()
+
+		println(dt.Format(time.DateTime), "A1:", a1, "A2:", a2)
+
+		if a1 {
+			if err := rtc.ClearAlarm1(); err != nil {
+				println("Error while clearing alarm1")
+			}
+		}
+		if a2 {
+			if err := rtc.ClearAlarm2(); err != nil {
+				println("Error while clearing alarm2")
+			}
+
+		}
+
+		time.Sleep(time.Second * 1)
+	}
+}

examples/ds3231/basic/main.go

@@ -3,10 +3,9 @@ package main
 
 import (
 	"machine"
+	"strconv"
 	"time"
 
-	"fmt"
-
 	"tinygo.org/x/drivers/ds3231"
 )
 
@@ -26,19 +25,19 @@ func main() {
 	if !running {
 		err := rtc.SetRunning(true)
 		if err != nil {
-			fmt.Println("Error configuring RTC")
+			println("Error configuring RTC")
 		}
 	}
 
 	for {
 		dt, err := rtc.ReadTime()
 		if err != nil {
-			fmt.Println("Error reading date:", err)
+			println("Error reading date:", err)
 		} else {
-			fmt.Printf("Date: %d/%s/%02d %02d:%02d:%02d \r\n", dt.Year(), dt.Month(), dt.Day(), dt.Hour(), dt.Minute(), dt.Second())
+			println(dt.Format(time.DateTime))
 		}
 		temp, _ := rtc.ReadTemperature()
-		fmt.Printf("Temperature: %.2f °C \r\n", float32(temp)/1000)
+		println("Temperature:", strconv.FormatFloat(float64(temp)/1000, 'f', -1, 32), "°C")
 
 		time.Sleep(time.Second * 1)
 	}

examples/encoders/quadrature-interrupt/main.go

@@ -0,0 +1,28 @@
+//go:build macropad_rp2040
+
+package main
+
+import (
+	"machine"
+
+	"tinygo.org/x/drivers/encoders"
+)
+
+var (
+	enc = encoders.NewQuadratureViaInterrupt(machine.ROT_A, machine.ROT_B)
+)
+
+func main() {
+
+	enc.Configure(encoders.QuadratureConfig{
+		Precision: 4,
+	})
+
+	for oldValue := 0; ; {
+		if newValue := enc.Position(); newValue != oldValue {
+			println("value: ", newValue)
+			oldValue = newValue
+		}
+	}
+
+}

examples/ens160/main.go

@@ -0,0 +1,56 @@
+// This example demonstrates ENS160 usage.
+//
+// Wiring:
+// - VCC to 3.3V, GND to ground
+// - SDA to board SDA, SCL to board SCL
+
+package main
+
+import (
+	"time"
+
+	"machine"
+
+	"tinygo.org/x/drivers"
+	"tinygo.org/x/drivers/ens160"
+)
+
+func main() {
+	err := machine.I2C0.Configure(machine.I2CConfig{
+		Frequency: 400 * machine.KHz,
+	})
+	if err != nil {
+		println("Failed to configure I2C:", err)
+	}
+
+	dev := ens160.New(machine.I2C0, ens160.DefaultAddress)
+
+	connected := dev.Connected()
+	if !connected {
+		println("ENS160 not detected")
+		return
+	}
+	println("ENS160 detected")
+
+	if err := dev.Configure(); err != nil {
+		println("Failed to configure ENS160:", err)
+	}
+
+	for {
+		err := dev.Update(drivers.Concentration)
+		if err != nil {
+			println("Error reading ENS160: %v\n", err)
+			time.Sleep(5 * time.Second)
+			continue
+		}
+
+		println(
+			"AQI:", dev.AQI(),
+			"TVOC:", dev.TVOC(),
+			"eCO2:", dev.ECO2(),
+			"Validity:", dev.ValidityString(),
+		)
+
+		time.Sleep(2 * time.Second)
+	}
+}

examples/flash/console/spi/main.go

@@ -10,7 +10,7 @@ import (
 func main() {
 	console_example.RunFor(
 		flash.NewSPI(
-			&machine.SPI1,
+			machine.SPI1,
 			machine.SPI1_SDO_PIN,
 			machine.SPI1_SDI_PIN,
 			machine.SPI1_SCK_PIN,

examples/gps/i2c/main.go

@@ -10,7 +10,7 @@ import (
 func main() {
 	println("GPS I2C Example")
 	machine.I2C0.Configure(machine.I2CConfig{})
-	ublox := gps.NewI2C(machine.I2C0)
+	ublox := gps.NewI2CWithAddress(machine.I2C0, gps.UBLOX_I2C_ADDRESS)
 	parser := gps.NewParser()
 	var fix gps.Fix
 	for {

examples/gps/uart/main.go

@@ -8,7 +8,6 @@ import (
 )
 
 func main() {
-	println("GPS UART Example")
 	machine.UART1.Configure(machine.UARTConfig{BaudRate: 9600})
 	ublox := gps.NewUART(machine.UART1)
 	parser := gps.NewParser()
@@ -16,14 +15,24 @@ func main() {
 	for {
 		s, err := ublox.NextSentence()
 		if err != nil {
-			println(err)
-			continue
+			switch err {
+			case gps.ErrUnknownNMEASentence, gps.ErrInvalidNMEASentence, gps.ErrInvalidNMEASentenceLength:
+				continue
+			default:
+				println("sentence error:", err)
+				continue
+			}
 		}
 
 		fix, err = parser.Parse(s)
 		if err != nil {
-			println(err)
-			continue
+			switch err {
+			case gps.ErrUnknownNMEASentence, gps.ErrInvalidNMEASentence, gps.ErrInvalidNMEASentenceLength:
+				continue
+			default:
+				println("parse error:", err)
+				continue
+			}
 		}
 		if fix.Valid {
 			print(fix.Time.Format("15:04:05"))
@@ -43,7 +52,10 @@ func main() {
 			}
 			println()
 		} else {
-			println("No fix")
+			if fix.Type == gps.GSV {
+				// GSV sentence provides satellite count even if no fix yet
+				println(fix.Satellites, "satellites visible")
+			}
 		}
 		time.Sleep(200 * time.Millisecond)
 	}

examples/honeyhsc/example.go

@@ -0,0 +1,49 @@
+package main
+
+import (
+	"machine"
+	"time"
+
+	"tinygo.org/x/drivers"
+	"tinygo.org/x/drivers/honeyhsc"
+)
+
+// Data taken from https://github.com/rodan/honeywell_hsc_ssc_i2c/blob/master/hsc_ssc_i2c.cpp
+// these defaults are valid for the HSCMRNN030PA2A3 chip
+const (
+	i2cAddress = 0x28
+	// 10%
+	outputMinimum = 0x666
+	// 90% of 2^14 - 1
+	outputMax = 0x399A
+	// min is 0 for sensors that give absolute values
+	pressureMin = 0
+	// 30psi (and we want results in millipascals)
+	// pressureMax = 206842.7
+	pressureMax = 206843 * 1000
+)
+
+func main() {
+	bus := machine.I2C0
+	err := bus.Configure(machine.I2CConfig{
+		Frequency: 400_000, // 100kHz minimum and 400kHz I2C maximum clock. 50 to 800 for SPI.
+		SDA:       machine.I2C0_SDA_PIN,
+		SCL:       machine.I2C0_SCL_PIN,
+	})
+	if err != nil {
+		panic(err.Error())
+	}
+	sensor := honeyhsc.NewDevI2C(bus, i2cAddress, outputMinimum, outputMax, pressureMin, pressureMax)
+	for {
+		time.Sleep(time.Second)
+		const measuremask = drivers.Pressure | drivers.Temperature
+		err := sensor.Update(measuremask)
+		if err != nil {
+			println("error updating measurements:", err.Error())
+			continue
+		}
+		P := sensor.Pressure()
+		T := sensor.Temperature()
+		println("pressure:", P, "temperature:", T)
+	}
+}

examples/ina219/main.go

@@ -0,0 +1,29 @@
+package main
+
+import (
+	"machine"
+	"time"
+
+	"tinygo.org/x/drivers/ina219"
+)
+
+func main() {
+	machine.I2C0.Configure(machine.I2CConfig{})
+
+	dev := ina219.New(machine.I2C0)
+	dev.Configure()
+
+	for {
+		busVoltage, shuntVoltage, current, power, err := dev.Measurements()
+		if err != nil {
+			println("Error reading measurements", err)
+		}
+
+		println("Bus Voltage:", busVoltage, "V")
+		println("Shunt Voltage:", shuntVoltage/100, "mV")
+		println("Current:", current, "mA")
+		println("Power:", power, "mW")
+
+		time.Sleep(10 * time.Millisecond)
+	}
+}

examples/lis3dh/main.go

@@ -14,9 +14,18 @@ func main() {
 	i2c.Configure(machine.I2CConfig{SCL: machine.SCL1_PIN, SDA: machine.SDA1_PIN})
 
 	accel := lis3dh.New(i2c)
-	accel.Address = lis3dh.Address1 // address on the Circuit Playground Express
-	accel.Configure()
-	accel.SetRange(lis3dh.RANGE_2_G)
+	err := accel.Configure(lis3dh.Config{
+		Address: lis3dh.Address1, // address on the Circuit Playground Express
+	})
+	for err != nil {
+		println("could not configure LIS3DH:", err)
+		time.Sleep(time.Second)
+	}
+	err = accel.SetRange(lis3dh.RANGE_2_G)
+	for err != nil {
+		println("could not set acceleration range:", err)
+		time.Sleep(time.Second)
+	}
 
 	println(accel.Connected())
 

examples/lsm303dlhc/main.go

@@ -0,0 +1,58 @@
+package main
+
+import (
+	"machine"
+	"time"
+
+	"tinygo.org/x/drivers/lsm303dlhc"
+)
+
+func main() {
+
+	// LSM303DLHC is connected to the I2C0 bus on Adafruit Feather M4 via pins: 20(SDA) and 21(SCL).
+	machine.I2C0.Configure(machine.I2CConfig{})
+
+	sensor := lsm303dlhc.New(machine.I2C0)
+	//default settings
+	err := sensor.Configure(lsm303dlhc.Configuration{
+		AccelPowerMode: lsm303dlhc.ACCEL_POWER_NORMAL,
+		AccelRange:     lsm303dlhc.ACCEL_RANGE_2G,
+		AccelDataRate:  lsm303dlhc.ACCEL_DATARATE_100HZ,
+		MagPowerMode:   lsm303dlhc.MAG_POWER_NORMAL,
+		MagSystemMode:  lsm303dlhc.MAG_SYSTEM_CONTINUOUS,
+		MagDataRate:    lsm303dlhc.MAG_DATARATE_10HZ,
+	})
+	if err != nil {
+		for {
+			println("Failed to configure", err.Error())
+			time.Sleep(time.Second)
+		}
+	}
+
+	for {
+		accel_x, accel_y, accel_z, err := sensor.ReadAcceleration()
+		if err != nil {
+			println("Failed to read accel", err.Error())
+		}
+		println("ACCEL_X:", accel_x, " ACCEL_Y:", accel_y, " ACCEL_Z:", accel_z)
+
+		mag_x, mag_y, mag_z, err := sensor.ReadMagneticField()
+		if err != nil {
+			println("Failed to read mag", err.Error())
+		}
+		println("MAG_X:", mag_x, " MAG_Y:", mag_y, " MAG_Z:", mag_z)
+
+		pitch, roll, _ := sensor.ReadPitchRoll()
+		println("Pitch:", float32(pitch), " Roll:", float32(roll))
+
+		heading, _ := sensor.ReadCompass()
+		println("Heading:", float32(heading), "degrees")
+
+		temp, _ := sensor.ReadTemperature()
+		println("Temperature:", float32(temp)/1000, "*C")
+
+		println("\n")
+		time.Sleep(time.Millisecond * 250)
+	}
+
+}

examples/max6675/main.go

@@ -0,0 +1,34 @@
+package main
+
+import (
+	"fmt"
+	"machine"
+	"time"
+
+	"tinygo.org/x/drivers/max6675"
+)
+
+// example for reading temperature from a thermocouple
+func main() {
+	// Pins are for an Adafruit Feather nRF52840 Express
+	machine.D5.Configure(machine.PinConfig{Mode: machine.PinOutput})
+	machine.D5.High()
+
+	machine.SPI0.Configure(machine.SPIConfig{
+		Frequency: 1_000_000,
+		SCK:       machine.SPI0_SCK_PIN,
+		SDI:       machine.SPI0_SDI_PIN,
+	})
+
+	thermocouple := max6675.NewDevice(machine.SPI0, machine.D5)
+
+	for {
+		temp, err := thermocouple.Read()
+		if err != nil {
+			println(err)
+			return
+		}
+		fmt.Printf("%0.02f C : %0.02f F\n", temp, (temp*9/5)+32)
+		time.Sleep(time.Second)
+	}
+}

examples/mcp2515/main.go

@@ -21,7 +21,7 @@ func main() {
 		SDI:       machine.SPI0_SDI_PIN,
 		Mode:      0})
 	can := mcp2515.New(spi, csPin)
-	can.Configure()
+	can.Configure(mcp2515.Configuration{})
 	err := can.Begin(mcp2515.CAN500kBps, mcp2515.Clock8MHz)
 	if err != nil {
 		failMessage(err.Error())

examples/mcp9808/main.go

@@ -0,0 +1,48 @@
+package main
+
+import (
+	"fmt"
+	"machine"
+	"time"
+
+	"tinygo.org/x/drivers/mcp9808"
+)
+
+func main() {
+
+	//tinygo monitor
+	time.Sleep(time.Millisecond * 5000)
+
+	//Configure I2C (in this case, I2C0 on RPI Pico), and wire the module accordingly
+	machine.I2C0.Configure(machine.I2CConfig{
+		SCL: machine.GP1,
+		SDA: machine.GP0,
+	})
+
+	//Create sensor
+	sensor := mcp9808.New(machine.I2C0)
+	if !sensor.Connected() {
+		println("MCP9808 not found")
+		return
+	} else {
+		println("MCP9808 found")
+	}
+
+	time.Sleep(time.Millisecond * 1000)
+
+	//Set resolution
+	sensor.SetResolution(mcp9808.Maximum)
+
+	time.Sleep(time.Millisecond * 1000)
+
+	//Read temp.
+	temp, err := sensor.ReadTemperature()
+	if err != nil {
+		println("MCP9808 error reading temperature")
+		println(err.Error())
+		return
+	} else {
+		fmt.Printf("Temperature: %.2f \n", temp)
+	}
+	return
+}

examples/net/http-get/main.go

@@ -9,7 +9,7 @@
 //     examples/net/webclient (for HTTP)
 //     examples/net/tlsclient (for HTTPS)
 
-//go:build pyportal || nano_rp2040 || metro_m4_airlift || arduino_mkrwifi1010 || matrixportal_m4 || wioterminal
+//go:build ninafw || wioterminal || comboat_fw
 
 package main
 

examples/net/http-head/main.go

@@ -9,7 +9,7 @@
 //     examples/net/webclient (for HTTP)
 //     examples/net/tlsclient (for HTTPS)
 
-//go:build pyportal || nano_rp2040 || metro_m4_airlift || arduino_mkrwifi1010 || matrixportal_m4 || wioterminal
+//go:build ninafw || wioterminal || comboat_fw
 
 package main
 

examples/net/http-post/main.go

@@ -9,7 +9,7 @@
 //     examples/net/webclient (for HTTP)
 //     examples/net/tlsclient (for HTTPS)
 
-//go:build pyportal || nano_rp2040 || metro_m4_airlift || arduino_mkrwifi1010 || matrixportal_m4 || wioterminal
+//go:build ninafw || wioterminal || comboat_fw
 
 package main
 

examples/net/http-postform/main.go

@@ -9,7 +9,7 @@
 //     examples/net/webclient (for HTTP)
 //     examples/net/tlsclient (for HTTPS)
 
-//go:build pyportal || nano_rp2040 || metro_m4_airlift || arduino_mkrwifi1010 || matrixportal_m4 || wioterminal
+//go:build ninafw || wioterminal || comboat_fw
 
 package main
 

examples/net/mqttclient/natiu/main.go

@@ -4,7 +4,7 @@
 // Note: It may be necessary to increase the stack size when using
 // paho.mqtt.golang.  Use the -stack-size=4KB command line option.
 
-//go:build pyportal || nano_rp2040 || metro_m4_airlift || arduino_mkrwifi1010 || matrixportal_m4 || wioterminal || challenger_rp2040
+//go:build ninafw || wioterminal || challenger_rp2040 || comboat_fw
 
 package main
 

examples/net/mqttclient/paho/main.go

@@ -4,7 +4,7 @@
 // Note: It may be necessary to increase the stack size when using
 // paho.mqtt.golang.  Use the -stack-size=4KB command line option.
 
-//go:build pyportal || nano_rp2040 || metro_m4_airlift || arduino_mkrwifi1010 || matrixportal_m4 || wioterminal || challenger_rp2040
+//go:build ninafw || wioterminal || challenger_rp2040 || comboat_fw
 
 package main
 

examples/net/ntpclient/main.go

@@ -3,7 +3,7 @@
 // It creates a UDP connection to request the current time and parse the
 // response from a NTP server.  The system time is set to NTP time.
 
-//go:build pyportal || arduino_nano33 || nano_rp2040 || metro_m4_airlift || arduino_mkrwifi1010 || matrixportal_m4 || wioterminal || challenger_rp2040
+//go:build ninafw || wioterminal || challenger_rp2040 || comboat_fw
 
 package main
 

examples/net/snake/init.go

@@ -0,0 +1,30 @@
+//go:build ninafw || wioterminal || comboat_fw
+
+package main
+
+import (
+	"log"
+	"time"
+
+	"tinygo.org/x/drivers/netlink"
+	"tinygo.org/x/drivers/netlink/probe"
+)
+
+var (
+	ssid string
+	pass string
+)
+
+func init() {
+	time.Sleep(2 * time.Second)
+
+	link, _ := probe.Probe()
+
+	err := link.NetConnect(&netlink.ConnectParams{
+		Ssid:       ssid,
+		Passphrase: pass,
+	})
+	if err != nil {
+		log.Fatal(err)
+	}
+}

examples/net/snake/main.go

@@ -0,0 +1,120 @@
+// This example is the classic snake network test.  The snake is feed a steady
+// diet of pkts and the pkts work themselves thru the snake segments and exit
+// the tail.  Each snake segment is a TCP socket connection to a server.  The
+// server echos pkts received back to the snake, and serves each segment on a
+// different port.  (See server/main.go for server).
+//
+//                snake     |    server
+//                          |
+//            head ----->---|-->--+
+//             seg a        |     |
+//                    +---<-|--<--+
+//                    |     |
+//                    +-->--|-->--+
+//             seg b        |     |
+//                    +---<-|--<--+
+//                    |     |
+//                    +-->--|-->--+
+//             seg c        |     |
+//                    +---<-|--<--+
+//                    |     |
+//                    +-->--|-->--+
+//              ...         |     |
+//                    +---<-|--<--+
+//                    |     |
+//                    +-->--|-->--+
+//             seg n        |     |
+//            tail -------<-|--<--+
+//                          |
+
+// The snake segments are linked by channels and each segment is run as a go
+// func.  This forces segments to connect and run concurrently, which is a good
+// test of the underlying driver's ability to handle concurrent connections.
+
+//go:build ninafw || wioterminal || comboat_fw
+
+package main
+
+import (
+	_ "embed"
+	"fmt"
+	"log"
+	"net"
+	"strings"
+	"time"
+)
+
+//go:embed main.go
+var code string
+
+var (
+	server string = "10.0.0.100:8080"
+)
+
+func segment(in chan []byte, out chan []byte) {
+	var buf [512]byte
+	for {
+		c, err := net.Dial("tcp", server)
+		for ; err != nil; c, err = net.Dial("tcp", server) {
+			println(err.Error())
+			time.Sleep(5 * time.Second)
+		}
+		for {
+			select {
+			case msg := <-in:
+				_, err := c.Write(msg)
+				if err != nil {
+					log.Fatal(err.Error())
+				}
+				time.Sleep(100 * time.Millisecond)
+				n, err := c.Read(buf[:])
+				if err != nil {
+					log.Fatal(err.Error())
+				}
+				out <- buf[:n]
+			}
+		}
+	}
+}
+
+func feedit(head chan []byte) {
+	for i := 0; i < 100; i++ {
+		head <- []byte(fmt.Sprintf("\n---%d---\n", i))
+		for _, line := range strings.Split(code, "\n") {
+			if len(line) == 0 {
+				line = " "
+			}
+			head <- []byte(line)
+		}
+	}
+}
+
+var head = make(chan []byte)
+var a = make(chan []byte)
+var b = make(chan []byte)
+var c = make(chan []byte)
+var d = make(chan []byte)
+var e = make(chan []byte)
+var f = make(chan []byte)
+var tail = make(chan []byte)
+
+func main() {
+
+	// The snake
+	go segment(head, a)
+	go segment(a, b)
+	go segment(b, c)
+	go segment(c, d)
+	go segment(d, e)
+	go segment(e, f)
+	go segment(f, tail)
+
+	go feedit(head)
+
+	for {
+		select {
+		case msg := <-tail:
+			println(string(msg))
+		}
+	}
+}

examples/net/snake/server/main.go

@@ -0,0 +1,34 @@
+package main
+
+import (
+	"io"
+	"log"
+	"net"
+)
+
+func main() {
+	// Listen for connections
+	l, err := net.Listen("tcp", ":8080")
+	if err != nil {
+		log.Fatal(err.Error())
+	}
+	defer l.Close()
+	println("Listening on port", ":8080")
+	for {
+		// Wait for a connection
+		conn, err := l.Accept()
+		if err != nil {
+			log.Fatal(err)
+		}
+		println("Accepted connection from", conn.RemoteAddr().String())
+		// Service the new connection in a goroutine.
+		// The loop then returns to accepting, so that
+		// multiple connections may be served concurrently
+		go func(c net.Conn) {
+			// Echo all incoming data
+			io.Copy(c, c)
+			// Shut down the connection
+			c.Close()
+		}(conn)
+	}
+}

examples/net/socket/main.go

@@ -4,7 +4,7 @@
 //
 // nc -lk 8080
 
-//go:build pyportal || arduino_nano33 || nano_rp2040 || metro_m4_airlift || arduino_mkrwifi1010 || matrixportal_m4 || wioterminal || challenger_rp2040
+//go:build ninafw || wioterminal || challenger_rp2040 || comboat_fw
 
 package main
 

examples/net/tcpclient/main.go

@@ -5,7 +5,7 @@
 //
 // nc -lk 8080
 
-//go:build pyportal || arduino_nano33 || nano_rp2040 || metro_m4_airlift || arduino_mkrwifi1010 || matrixportal_m4 || wioterminal || challenger_rp2040 || pico
+//go:build ninafw || wioterminal || challenger_rp2040 || comboat_fw
 
 package main
 

examples/net/tcpecho/main.go

@@ -7,7 +7,7 @@
 //
 // $ nc 10.0.0.2 8080 <file >copy ; cmp file copy
 
-//go:build pyportal || arduino_nano33 || nano_rp2040 || metro_m4_airlift || arduino_mkrwifi1010 || matrixportal_m4 || wioterminal
+//go:build ninafw || wioterminal
 
 package main
 

examples/net/tlsclient/main.go

@@ -5,7 +5,7 @@
 //
 // https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Strict-Transport-Security
 
-//go:build pyportal || nano_rp2040 || metro_m4_airlift || arduino_mkrwifi1010 || matrixportal_m4 || wioterminal
+//go:build ninafw || wioterminal || comboat_fw
 
 package main
 

examples/net/webclient/main.go

@@ -17,7 +17,7 @@
 // }
 // ---------------------------------------------------------------------------
 
-//go:build pyportal || arduino_nano33 || nano_rp2040 || metro_m4_airlift || arduino_mkrwifi1010 || matrixportal_m4 || wioterminal
+//go:build ninafw || wioterminal || comboat_fw
 
 package main
 

examples/net/webserver/main.go

@@ -6,7 +6,7 @@
 // Note: It may be necessary to increase the stack size when using "net/http".
 // Use the -stack-size=4KB command line option.
 
-//go:build pyportal || nano_rp2040 || metro_m4_airlift || arduino_mkrwifi1010 || matrixportal_m4 || wioterminal
+//go:build ninafw || wioterminal
 
 package main
 

examples/net/websocket/dial/main.go

@@ -6,7 +6,7 @@
 // Note: It may be necessary to increase the stack size when using
 // "golang.org/x/net/websocket".  Use the -stack-size=4KB command line option.
 
-//go:build pyportal || nano_rp2040 || metro_m4_airlift || arduino_mkrwifi1010 || matrixportal_m4 || wioterminal
+//go:build ninafw || wioterminal || comboat_fw
 
 package main
 

examples/net/websocket/handler/main.go

@@ -6,7 +6,7 @@
 // Note: It may be necessary to increase the stack size when using
 // "golang.org/x/net/websocket".  Use the -stack-size=4KB command line option.
 
-//go:build pyportal || nano_rp2040 || metro_m4_airlift || arduino_mkrwifi1010 || matrixportal_m4 || wioterminal
+//go:build ninafw || wioterminal
 
 package main
 

examples/net/webstatic/main.go

@@ -3,7 +3,7 @@
 // Note: It may be necessary to increase the stack size when using "net/http".
 // Use the -stack-size=4KB command line option.
 
-//go:build pyportal || nano_rp2040 || metro_m4_airlift || arduino_mkrwifi1010 || matrixportal_m4 || wioterminal
+//go:build ninafw || wioterminal
 
 package main
 

examples/pcf8591/main.go

@@ -0,0 +1,28 @@
+// Connects to a pcf8591 ADC via I2C.
+package main
+
+import (
+	"machine"
+	"time"
+
+	"tinygo.org/x/drivers/pcf8591"
+)
+
+var (
+	i2c = machine.I2C0
+)
+
+func main() {
+	i2c.Configure(machine.I2CConfig{})
+	adc := pcf8591.New(i2c)
+	adc.Configure()
+
+	// get "CH0" aka "machine.ADC" interface to channel 0 from ADC.
+	p := adc.CH0
+
+	for {
+		val := p.Get()
+		println(val)
+		time.Sleep(50 * time.Millisecond)
+	}
+}

examples/sdcard/console/feather-m4.go

@@ -7,7 +7,7 @@ import (
 )
 
 func init() {
-	spi = &machine.SPI0
+	spi = machine.SPI0
 	sckPin = machine.SPI0_SCK_PIN
 	sdoPin = machine.SPI0_SDO_PIN
 	sdiPin = machine.SPI0_SDI_PIN

examples/sdcard/console/grandcentral-m4.go

@@ -7,7 +7,7 @@ import (
 )
 
 func init() {
-	spi = &machine.SPI1
+	spi = machine.SPI1
 	sckPin = machine.SDCARD_SCK_PIN
 	sdoPin = machine.SDCARD_SDO_PIN
 	sdiPin = machine.SDCARD_SDI_PIN

examples/sdcard/console/m0.go

@@ -7,7 +7,7 @@ import (
 )
 
 func init() {
-	spi = &machine.SPI0
+	spi = machine.SPI0
 	sckPin = machine.SPI0_SCK_PIN
 	sdoPin = machine.SPI0_SDO_PIN
 	sdiPin = machine.SPI0_SDI_PIN

examples/sdcard/console/p1am-100.go

@@ -7,7 +7,7 @@ import (
 )
 
 func init() {
-	spi = &machine.SDCARD_SPI
+	spi = machine.SDCARD_SPI
 	sckPin = machine.SDCARD_SCK_PIN
 	sdoPin = machine.SDCARD_SDO_PIN
 	sdiPin = machine.SDCARD_SDI_PIN

examples/sdcard/console/pygamer.go

@@ -7,7 +7,7 @@ import (
 )
 
 func init() {
-	spi = &machine.SPI0
+	spi = machine.SPI0
 	sckPin = machine.SPI0_SCK_PIN
 	sdoPin = machine.SPI0_SDO_PIN
 	sdiPin = machine.SPI0_SDI_PIN

examples/sdcard/console/pyportal.go

@@ -7,7 +7,7 @@ import (
 )
 
 func init() {
-	spi = &machine.SPI0
+	spi = machine.SPI0
 	sckPin = machine.SPI0_SCK_PIN
 	sdoPin = machine.SPI0_SDO_PIN
 	sdiPin = machine.SPI0_SDI_PIN

examples/sdcard/console/wioterminal.go

@@ -7,7 +7,7 @@ import (
 )
 
 func init() {
-	spi = &machine.SPI2
+	spi = machine.SPI2
 	sckPin = machine.SCK2
 	sdoPin = machine.SDO2
 	sdiPin = machine.SDI2

examples/seesaw/rotary-encoder/main.go

@@ -0,0 +1,35 @@
+package main
+
+import (
+	"machine"
+	"time"
+
+	"tinygo.org/x/drivers/seesaw"
+)
+
+// example reading the position of a rotary encoder (4991) powered by a seesaw
+// https://learn.adafruit.com/adafruit-i2c-qt-rotary-encoder/arduino
+func main() {
+	// This assumes you are using an Adafruit QT Py RP2040 for its Stemma QT connector
+	// https://www.adafruit.com/product/4900
+	i2c := machine.I2C1
+	i2c.Configure(machine.I2CConfig{
+		SCL: machine.I2C1_QT_SCL_PIN,
+		SDA: machine.I2C1_QT_SDA_PIN,
+	})
+
+	dev := seesaw.New(i2c)
+	dev.Address = 0x36
+
+	for {
+		time.Sleep(time.Second)
+
+		pos, err := dev.GetEncoderPosition(0, false)
+		if err != nil {
+			println(err)
+			continue
+		}
+
+		println(pos)
+	}
+}

examples/servo/servo.go

@@ -25,19 +25,25 @@ func main() {
 		return
 	}
 
-	println("setting to 0°")
-	s.SetMicroseconds(1000)
-	time.Sleep(3 * time.Second)
-
-	println("setting to 45°")
-	s.SetMicroseconds(1500)
-	time.Sleep(3 * time.Second)
-
-	println("setting to 90°")
-	s.SetMicroseconds(2000)
-	time.Sleep(3 * time.Second)
-
 	for {
-		time.Sleep(time.Second)
+		println("setting to 0°")
+		s.SetAngle(0)
+		time.Sleep(3 * time.Second)
+
+		println("setting to 45°")
+		s.SetAngle(45)
+		time.Sleep(3 * time.Second)
+
+		println("setting to 90°")
+		s.SetAngle(90)
+		time.Sleep(3 * time.Second)
+
+		println("setting to 135°")
+		s.SetAngle(135)
+		time.Sleep(3 * time.Second)
+
+		println("setting to 180°")
+		s.SetAngle(180)
+		time.Sleep(3 * time.Second)
 	}
 }

examples/sharpmem/main.go

@@ -0,0 +1,90 @@
+package main
+
+import (
+	"image/color"
+	"machine"
+	"math/rand/v2"
+	"time"
+
+	"tinygo.org/x/drivers/sharpmem"
+)
+
+var (
+	// example wiring using a nice!view and nice!nano:
+	// (view)   (nano)
+	// MOSI --> P0.24
+	// SCK ---> P0.22
+	// GND ---> GND
+	// VCC ---> 3.3V
+	// CS ----> P0.06
+
+	spi = machine.SPI0
+
+	sckPin = machine.SPI0_SCK_PIN // SCK
+	sdoPin = machine.SPI0_SDO_PIN // MOSI
+	sdiPin = machine.SPI0_SDI_PIN // (any pin)
+
+	csPin = machine.P0_06 // CS
+)
+
+func main() {
+	time.Sleep(time.Second)
+
+	err := spi.Configure(machine.SPIConfig{
+		Frequency: 2000000,
+		SCK:       sckPin,
+		SDO:       sdoPin,
+		SDI:       sdiPin,
+		Mode:      0,
+		LSBFirst:  true,
+	})
+	if err != nil {
+		println("spi.Configure() failed, error:", err.Error())
+		return
+	}
+
+	csPin.Configure(machine.PinConfig{Mode: machine.PinOutput})
+
+	display := sharpmem.New(spi, csPin)
+
+	cfg := sharpmem.ConfigLS011B7DH03
+	display.Configure(cfg)
+
+	// clear the display before first use
+	err = display.Clear()
+	if err != nil {
+		println("display.Clear() failed, error:", err.Error())
+		return
+	}
+
+	// random boxes pop into and out of existence
+	for {
+		x0 := int16(rand.IntN(int(cfg.Width - 7)))
+		y0 := int16(rand.IntN(int(cfg.Height - 7)))
+
+		for x2 := int16(0); x2 < 16; x2++ {
+			x2 := x2
+			c := color.RGBA{R: 255, G: 255, B: 255, A: 255}
+
+			if x2 >= 8 {
+				// effectively erases the box after it showed up
+				x2 = x2 - 8
+				c = color.RGBA{R: 0, G: 0, B: 0, A: 255}
+			}
+
+			for x := int16(0); x < x2; x++ {
+				for y := int16(0); y < 8; y++ {
+					display.SetPixel(x0+x, y0+y, c)
+				}
+			}
+
+			err = display.Display()
+			if err != nil {
+				println("display.Display() failed, error:", err.Error())
+				continue
+			}
+
+			time.Sleep(33 * time.Millisecond)
+		}
+	}
+}

examples/si5351/main.go

@@ -0,0 +1,88 @@
+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)
+
+	// Initialize device
+	cnf := si5351.Config{
+		Capacitance: si5351.CrystalLoad10PF,
+	}
+
+	if err := clockgen.Configure(cnf); err != nil {
+		println("Failed to configure Si5351:", err.Error())
+		return
+	}
+	println("Si5351 configured")
+
+	// Now configure the clock outputs.
+	clockgen.SetFrequency(si5351.Clock0, 112_500_000)
+	println("Clock 0: 112.5mhz")
+
+	// Next configure clock 1 for 13.5531mhz (616.6667mhz / 45.5).
+	// This uses fractional division.
+	clockgen.SetFrequency(si5351.Clock1, 13_553_125)
+	println("Clock 1: 13.5531mhz")
+
+	// Finally configure clock 2 to output of 10.706khz.
+	clockgen.SetFrequency(si5351.Clock2, 10_706)
+	println("Clock 2: 10.706khz")
+
+	// After configuring the clocks enable the outputs.
+	clockgen.EnableOutput(si5351.Clock0, true)
+	clockgen.EnableOutput(si5351.Clock1, true)
+	clockgen.EnableOutput(si5351.Clock2, true)
+	println("All outputs enabled")
+
+	time.Sleep(time.Second)
+
+	clockgen.EnableOutput(si5351.Clock0, false)
+	clockgen.EnableOutput(si5351.Clock1, false)
+	clockgen.EnableOutput(si5351.Clock2, false)
+	println("All outputs disabled for 5 seconds")
+	time.Sleep(5 * time.Second)
+
+	// Now turn clock outputs on and off repeatedly
+	on := false
+	for {
+		if on {
+			println("Setting clock outputs off")
+			clockgen.EnableOutput(si5351.Clock0, false)
+			clockgen.EnableOutput(si5351.Clock1, false)
+			clockgen.EnableOutput(si5351.Clock2, false)
+			on = false
+		} else {
+			println("Setting clock outputs on")
+			clockgen.EnableOutput(si5351.Clock0, true)
+			clockgen.EnableOutput(si5351.Clock1, true)
+			clockgen.EnableOutput(si5351.Clock2, true)
+			on = true
+		}
+		time.Sleep(1 * time.Second)
+	}
+}

examples/ssd1289/main.go

@@ -5,6 +5,7 @@ import (
 	"machine"
 	"math/rand"
 
+	"tinygo.org/x/drivers/internal/pin"
 	"tinygo.org/x/drivers/ssd1289"
 )
 
@@ -16,7 +17,7 @@ func main() {
 	//consider creating a more efficient bus implementation that uses
 	//your microcontrollers built in "ports"
 	//see rp2040bus.go for an example for the rapsberry pi pico
-	bus := ssd1289.NewPinBus([16]machine.Pin{
+	bus := ssd1289.NewPinBus([16]pin.Output{
 		machine.GP4,  //DB0
 		machine.GP5,  //DB1
 		machine.GP6,  //DB2

examples/ssd1306/i2c_128x32/main.go

@@ -1,51 +0,0 @@
-package main
-
-import (
-	"machine"
-
-	"image/color"
-	"time"
-
-	"tinygo.org/x/drivers/ssd1306"
-)
-
-func main() {
-	machine.I2C0.Configure(machine.I2CConfig{
-		Frequency: machine.TWI_FREQ_400KHZ,
-	})
-
-	display := ssd1306.NewI2C(machine.I2C0)
-	display.Configure(ssd1306.Config{
-		Address: ssd1306.Address_128_32,
-		Width:   128,
-		Height:  32,
-	})
-
-	display.ClearDisplay()
-
-	x := int16(0)
-	y := int16(0)
-	deltaX := int16(1)
-	deltaY := int16(1)
-	for {
-		pixel := display.GetPixel(x, y)
-		c := color.RGBA{255, 255, 255, 255}
-		if pixel {
-			c = color.RGBA{0, 0, 0, 255}
-		}
-		display.SetPixel(x, y, c)
-		display.Display()
-
-		x += deltaX
-		y += deltaY
-
-		if x == 0 || x == 127 {
-			deltaX = -deltaX
-		}
-
-		if y == 0 || y == 31 {
-			deltaY = -deltaY
-		}
-		time.Sleep(1 * time.Millisecond)
-	}
-}

examples/ssd1306/i2c_128x64/main.go

@@ -1,60 +0,0 @@
-// This example shows how to use 128x64 display over I2C
-// Tested on Seeeduino XIAO Expansion Board https://wiki.seeedstudio.com/Seeeduino-XIAO-Expansion-Board/
-//
-// According to manual, I2C address of the display is 0x78, but that's 8-bit address.
-// TinyGo operates on 7-bit addresses and respective 7-bit address would be 0x3C, which we use below.
-//
-// To learn more about different types of I2C addresses, please see following page
-// https://www.totalphase.com/support/articles/200349176-7-bit-8-bit-and-10-bit-I2C-Slave-Addressing
-
-package main
-
-import (
-	"machine"
-
-	"image/color"
-	"time"
-
-	"tinygo.org/x/drivers/ssd1306"
-)
-
-func main() {
-	machine.I2C0.Configure(machine.I2CConfig{
-		Frequency: machine.TWI_FREQ_400KHZ,
-	})
-
-	display := ssd1306.NewI2C(machine.I2C0)
-	display.Configure(ssd1306.Config{
-		Address: 0x3C,
-		Width:   128,
-		Height:  64,
-	})
-
-	display.ClearDisplay()
-
-	x := int16(0)
-	y := int16(0)
-	deltaX := int16(1)
-	deltaY := int16(1)
-	for {
-		pixel := display.GetPixel(x, y)
-		c := color.RGBA{255, 255, 255, 255}
-		if pixel {
-			c = color.RGBA{0, 0, 0, 255}
-		}
-		display.SetPixel(x, y, c)
-		display.Display()
-
-		x += deltaX
-		y += deltaY
-
-		if x == 0 || x == 127 {
-			deltaX = -deltaX
-		}
-
-		if y == 0 || y == 63 {
-			deltaY = -deltaY
-		}
-		time.Sleep(1 * time.Millisecond)
-	}
-}

examples/ssd1306/main.go

@@ -0,0 +1,59 @@
+package main
+
+// This example shows how to use SSD1306 OLED display driver over I2C and SPI.
+//
+// Check the `newSSD1306Display()` functions for I2C and SPI initializations.
+
+import (
+	"runtime"
+
+	"image/color"
+	"time"
+)
+
+func main() {
+
+	display := newSSD1306Display()
+	display.ClearDisplay()
+
+	w, h := display.Size()
+	x := int16(0)
+	y := int16(0)
+	deltaX := int16(1)
+	deltaY := int16(1)
+
+	traceTime := time.Now().UnixMilli() + 1000
+	frames := 0
+	ms := runtime.MemStats{}
+
+	for {
+		pixel := display.GetPixel(x, y)
+		c := color.RGBA{255, 255, 255, 255}
+		if pixel {
+			c = color.RGBA{0, 0, 0, 255}
+		}
+		display.SetPixel(x, y, c)
+		display.Display()
+
+		x += deltaX
+		y += deltaY
+
+		if x == 0 || x == w-1 {
+			deltaX = -deltaX
+		}
+
+		if y == 0 || y == h-1 {
+			deltaY = -deltaY
+		}
+
+		frames++
+		now := time.Now().UnixMilli()
+		if now >= traceTime {
+			runtime.ReadMemStats(&ms)
+			println("TS", now, "| FPS", frames, "| HeapInuse", ms.HeapInuse)
+			traceTime = now + 1000
+			frames = 0
+		}
+	}
+
+}

examples/ssd1306/main_i2c_xiao-ble.go

@@ -0,0 +1,38 @@
+//go:build xiao_ble
+
+// This initializes SSD1306 OLED display driver over I2C.
+//
+// Seeed XIAO BLE board + SSD1306 128x32 I2C OLED display.
+//
+// Wiring:
+// - XIAO GND      -> OLED GND
+// - XIAO 3v3      -> OLED VCC
+// - XIAO D4 (SDA) -> OLED SDA
+// - XIAO D5 (SCL) -> OLED SCK
+//
+// For your case:
+// - Connect the display to I2C pins on your board.
+// - Adjust I2C address and display size as needed.
+
+package main
+
+import (
+	"machine"
+
+	"tinygo.org/x/drivers/ssd1306"
+)
+
+func newSSD1306Display() *ssd1306.Device {
+	machine.I2C0.Configure(machine.I2CConfig{
+		Frequency: 400 * machine.KHz,
+		SDA:       machine.SDA0_PIN,
+		SCL:       machine.SCL0_PIN,
+	})
+	display := ssd1306.NewI2C(machine.I2C0)
+	display.Configure(ssd1306.Config{
+		Address: ssd1306.Address_128_32, // or ssd1306.Address
+		Width:   128,
+		Height:  32, // or 64
+	})
+	return display
+}

examples/ssd1306/main_spi_thumby.go

@@ -0,0 +1,27 @@
+//go:build thumby
+
+// This initializes SSD1306 OLED display driver over SPI.
+//
+// Thumby board has a tiny built-in 72x40 display.
+//
+// As the display is built-in, no wiring is needed.
+
+package main
+
+import (
+	"machine"
+
+	"tinygo.org/x/drivers/ssd1306"
+)
+
+func newSSD1306Display() *ssd1306.Device {
+	machine.SPI0.Configure(machine.SPIConfig{})
+	display := ssd1306.NewSPI(machine.SPI0, machine.THUMBY_DC_PIN, machine.THUMBY_RESET_PIN, machine.THUMBY_CS_PIN)
+	display.Configure(ssd1306.Config{
+		Width:     72,
+		Height:    40,
+		ResetCol:  ssd1306.ResetValue{28, 99},
+		ResetPage: ssd1306.ResetValue{0, 5},
+	})
+	return display
+}

examples/ssd1306/main_spi_xiao-rp2040.go

@@ -0,0 +1,40 @@
+//go:build xiao_rp2040
+
+// This initializes SSD1306 OLED display driver over SPI.
+//
+// Seeed XIAO RP2040 board + SSD1306 128x64 SPI OLED display.
+//
+// Wiring:
+// - XIAO GND       -> OLED GND
+// - XIAO 3v3       -> OLED VCC
+// - XIAO D8 (SCK)  -> OLED D0
+// - XIAO D10 (SDO) -> OLED D1
+// - XIAO D4        -> OLED RES
+// - XIAO D5        -> OLED DC
+// - XIAO D6        -> OLED CS
+//
+// For your case:
+// - Connect the display to SPI pins on your board.
+// - Adjust RES, DC and CS pins as needed.
+// - Adjust SPI frequency as needed.
+// - Adjust display size as needed.
+
+package main
+
+import (
+	"machine"
+
+	"tinygo.org/x/drivers/ssd1306"
+)
+
+func newSSD1306Display() *ssd1306.Device {
+	machine.SPI0.Configure(machine.SPIConfig{
+		Frequency: 50 * machine.MHz,
+	})
+	display := ssd1306.NewSPI(machine.SPI0, machine.D5, machine.D4, machine.D6)
+	display.Configure(ssd1306.Config{
+		Width:  128,
+		Height: 64,
+	})
+	return display
+}

examples/ssd1306/spi_128x64/main.go

@@ -1,48 +0,0 @@
-package main
-
-import (
-	"image/color"
-	"machine"
-	"time"
-
-	"tinygo.org/x/drivers/ssd1306"
-)
-
-func main() {
-	machine.SPI0.Configure(machine.SPIConfig{
-		Frequency: 8000000,
-	})
-	display := ssd1306.NewSPI(machine.SPI0, machine.P8, machine.P7, machine.P9)
-	display.Configure(ssd1306.Config{
-		Width:  128,
-		Height: 64,
-	})
-
-	display.ClearDisplay()
-
-	x := int16(64)
-	y := int16(32)
-	deltaX := int16(1)
-	deltaY := int16(1)
-	for {
-		pixel := display.GetPixel(x, y)
-		c := color.RGBA{255, 255, 255, 255}
-		if pixel {
-			c = color.RGBA{0, 0, 0, 255}
-		}
-		display.SetPixel(x, y, c)
-		display.Display()
-
-		x += deltaX
-		y += deltaY
-
-		if x == 0 || x == 127 {
-			deltaX = -deltaX
-		}
-
-		if y == 0 || y == 63 {
-			deltaY = -deltaY
-		}
-		time.Sleep(1 * time.Millisecond)
-	}
-}

examples/sx128x/lora_rx/main.go

@@ -0,0 +1,106 @@
+package main
+
+import (
+	"errors"
+	"machine"
+	"runtime"
+	"time"
+
+	"tinygo.org/x/drivers/sx128x"
+)
+
+var (
+	// pin mapping specific to the lilygo t3s3, change as needed for your board
+	sdoPin   = machine.GPIO6
+	sdiPin   = machine.GPIO3
+	sckPin   = machine.GPIO5
+	nssPin   = machine.GPIO7
+	busyPin  = machine.GPIO36
+	resetPin = machine.GPIO8
+	dio1Pin  = machine.GPIO9
+)
+
+func setupPins() {
+	nssPin.Configure(machine.PinConfig{Mode: machine.PinOutput})
+	nssPin.Set(true)
+
+	resetPin.Configure(machine.PinConfig{Mode: machine.PinOutput})
+	resetPin.Set(true)
+
+	busyPin.Configure(machine.PinConfig{Mode: machine.PinInput})
+	dio1Pin.Configure(machine.PinConfig{Mode: machine.PinInput})
+}
+
+func main() {
+	setupPins()
+
+	spi := machine.SPI0
+	spi.Configure(machine.SPIConfig{
+		Mode:      0,
+		Frequency: 8 * 1e6,
+		SDO:       sdoPin,
+		SDI:       sdiPin,
+		SCK:       sckPin,
+	})
+
+	radio := sx128x.New(
+		spi,
+		nssPin,
+		resetPin,
+		busyPin,
+	)
+
+	radio.WaitWhileBusy(time.Second)
+	SetupLora(radio)
+
+	for {
+		data, err := Rx(radio)
+		if err != nil {
+			println("failed to receive:", err)
+		} else {
+			println("received:", string(data))
+		}
+	}
+}
+
+func SetupLora(radio *sx128x.Device) {
+	radio.SetStandby(sx128x.STANDBY_RC)
+	radio.SetPacketType(sx128x.PACKET_TYPE_LORA)
+	radio.SetRegulatorMode(sx128x.REGULATOR_DC_DC)
+
+	radio.SetRfFrequency(2400000000) // 2.4Ghz
+	radio.SetModulationParamsLoRa(sx128x.LORA_SF_9, sx128x.LORA_BW_1600, sx128x.LORA_CR_4_7)
+
+	// section 14.4.1 shows required register setting for setting up LoRa operations. These depend on the chosen spreading factor.
+	radio.WriteRegister(0x925, []byte{0x32})
+	radio.WriteRegister(0x93C, []byte{0x01})
+
+	radio.SetTxParams(13, sx128x.RADIO_RAMP_02_US)
+	radio.SetPacketParamsLoRa(12, sx128x.LORA_HEADER_EXPLICIT, 0xFF, sx128x.LORA_CRC_DISABLE, sx128x.LORA_IQ_STD)
+	radio.WriteRegister(sx128x.REG_LORA_SYNC_WORD_MSB, []byte{0x14, 0x24}) // full sync word is 0x1424
+
+}
+
+func Rx(radio *sx128x.Device) ([]byte, error) {
+	radio.SetStandby(sx128x.STANDBY_RC)
+	radio.SetDioIrqParams(sx128x.IRQ_RX_DONE_MASK|sx128x.IRQ_RX_TX_TIMEOUT_MASK, sx128x.IRQ_RX_DONE_MASK|sx128x.IRQ_RX_TX_TIMEOUT_MASK, 0x00, 0x00)
+	radio.SetBufferBaseAddress(0, 0)
+	radio.ClearIrqStatus(sx128x.IRQ_ALL_MASK)
+	radio.SetRx(sx128x.PERIOD_BASE_4_MS, 250) // 4ms * 250 = 1s
+	// busy wait for IRQ indication
+	for dio1Pin.Get() == false {
+		runtime.Gosched()
+	}
+	irqStatus, _ := radio.GetIrqStatus()
+	if irqStatus&sx128x.IRQ_RX_DONE_MASK != 0 {
+		payloadLength, bufferOffset, err := radio.GetRxBufferStatus()
+		if err != nil {
+			return nil, err
+		}
+		data, err := radio.ReadBuffer(bufferOffset, payloadLength)
+		return data, nil
+	} else if irqStatus&sx128x.IRQ_RX_TX_TIMEOUT_MASK != 0 {
+		return nil, errors.New("rx timeout")
+	}
+	return nil, errors.New("unexpected IRQ status")
+}

examples/sx128x/lora_tx/main.go

@@ -0,0 +1,96 @@
+package main
+
+import (
+	"errors"
+	"machine"
+	"runtime"
+	"time"
+
+	"tinygo.org/x/drivers/sx128x"
+)
+
+var (
+	// pin mapping specific to the lilygo t3s3, change as needed for your board
+	sdoPin   = machine.GPIO6
+	sdiPin   = machine.GPIO3
+	sckPin   = machine.GPIO5
+	nssPin   = machine.GPIO7
+	busyPin  = machine.GPIO36
+	resetPin = machine.GPIO8
+	dio1Pin  = machine.GPIO9
+)
+
+func setupPins() {
+	nssPin.Configure(machine.PinConfig{Mode: machine.PinOutput})
+	nssPin.Set(true)
+
+	resetPin.Configure(machine.PinConfig{Mode: machine.PinOutput})
+	resetPin.Set(true)
+
+	busyPin.Configure(machine.PinConfig{Mode: machine.PinInput})
+	dio1Pin.Configure(machine.PinConfig{Mode: machine.PinInput})
+}
+
+func main() {
+	setupPins()
+
+	spi := machine.SPI0
+	spi.Configure(machine.SPIConfig{
+		Mode:      0,
+		Frequency: 8 * 1e6,
+		SDO:       sdoPin,
+		SDI:       sdiPin,
+		SCK:       sckPin,
+	})
+
+	radio := sx128x.New(
+		spi,
+		nssPin,
+		resetPin,
+		busyPin,
+	)
+
+	radio.WaitWhileBusy(time.Second)
+	SetupLora(radio)
+
+	for {
+		Tx(radio, []byte("Hello, world!"))
+		time.Sleep(1 * time.Second)
+	}
+}
+
+func SetupLora(radio *sx128x.Device) {
+	radio.SetStandby(sx128x.STANDBY_RC)
+	radio.SetPacketType(sx128x.PACKET_TYPE_LORA)
+	radio.SetRegulatorMode(sx128x.REGULATOR_DC_DC)
+
+	radio.SetRfFrequency(2400000000) // 2.4Ghz
+	radio.SetModulationParamsLoRa(sx128x.LORA_SF_9, sx128x.LORA_BW_1600, sx128x.LORA_CR_4_7)
+
+	// section 14.4.1 shows required register setting for setting up LoRa operations. These depend on the chosen spreading factor.
+	radio.WriteRegister(0x925, []byte{0x32})
+	radio.WriteRegister(0x93C, []byte{0x01})
+
+	radio.SetTxParams(13, sx128x.RADIO_RAMP_02_US)
+	radio.SetPacketParamsLoRa(12, sx128x.LORA_HEADER_EXPLICIT, 0xFF, sx128x.LORA_CRC_DISABLE, sx128x.LORA_IQ_STD)
+	radio.WriteRegister(sx128x.REG_LORA_SYNC_WORD_MSB, []byte{0x14, 0x24}) // full sync word is 0x1424
+
+}
+
+func Tx(radio *sx128x.Device, data []byte) error {
+	if len(data) > 255 {
+		return errors.New("data length exceeds maximum of 255 bytes")
+	}
+	radio.SetStandby(sx128x.STANDBY_RC)
+	radio.SetPacketParamsLoRa(12, sx128x.LORA_HEADER_EXPLICIT, uint8(len(data)&0xFF), sx128x.LORA_CRC_DISABLE, sx128x.LORA_IQ_STD)
+	radio.SetBufferBaseAddress(0, 0)
+	radio.WriteBuffer(0, data)
+	radio.SetDioIrqParams(sx128x.IRQ_TX_DONE_MASK|sx128x.IRQ_RX_TX_TIMEOUT_MASK, sx128x.IRQ_TX_DONE_MASK|sx128x.IRQ_RX_TX_TIMEOUT_MASK, 0x00, 0x00)
+	radio.ClearIrqStatus(sx128x.IRQ_ALL_MASK)
+	radio.SetTx(sx128x.PERIOD_BASE_4_MS, 250) // 4ms * 250 = 1s
+	// busy wait for IRQ indication
+	for dio1Pin.Get() == false {
+		runtime.Gosched()
+	}
+	return nil
+}

examples/tmc2209/main.go

@@ -0,0 +1,35 @@
+package main
+
+import (
+	"machine"
+
+	"tinygo.org/x/drivers/tmc2209"
+)
+
+func main() {
+	uart := machine.UART0
+	comm := tmc2209.NewUARTComm(*uart, 0)
+	// Create an instance of the TMC2209 with UART communication
+	tmc := tmc2209.NewTMC2209(comm, 0x00) // Replace 0x00 with the appropriate address
+
+	// Set up the TMC2209 driver
+	err := tmc.Setup()
+	if err != nil {
+		println("Failed to set up TMC2209: ", err)
+	}
+
+	// Write to a register (example: setting a register value)
+	err = tmc.WriteRegister(0x10, 0x12345678) // Replace 0x10 with the register address and 0x12345678 with the value
+	if err != nil {
+		println("Failed to write register:", err)
+	}
+
+	// Read from a register (example: reading a register value)
+	value, err := tmc.ReadRegister(0x10)
+	if err != nil {
+		println("Failed to read register: ", err)
+	}
+
+	// Output the read value
+	println("Register value: ", value)
+}

examples/tmc5160/main.go

@@ -0,0 +1,61 @@
+// Connects to SPI1 on a RP2040 (Pico)
+package main
+
+import (
+	"machine"
+
+	"tinygo.org/x/drivers/tmc5160"
+)
+
+func main() {
+	// Step 1. Setup your protocol.  SPI setup shown below
+	spi := machine.SPI1
+	spi.Configure(machine.SPIConfig{
+		Frequency: 12000000, // Upto 12 MHZ is pretty stable. Reduce to 5 or 6 Mhz if you are experiencing issues
+		Mode:      3,
+		LSBFirst:  false,
+	})
+	// Step 2. Set up all associated Pins
+	csPin0 := machine.GPIO13
+	csPin0.Configure(machine.PinConfig{Mode: machine.PinOutput})
+	enn0 := machine.GPIO18
+	enn0.Configure(machine.PinConfig{Mode: machine.PinOutput})
+
+	// csPins is a map of all chip select pins in a multi driver setup.
+	//Only one pin csPin0 mapped to "0"is shown in this example, but add more mappings as required
+	csPins := map[uint8]machine.Pin{0: csPin0}
+	//bind csPin to driverAdddress
+	driverAddress := uint8(0) // Let's assume we are working with driver at address 0x01
+	// Step 3. Bind the communication interface to the protocol
+	comm := tmc5160.NewSPIComm(spi, csPins)
+	// Step 4. Define your stepper like this below
+	//stepper := tmc5160.NewStepper(angle , gearRatio  vSupply  rCoil , lCoil , iPeak , rSense , mSteps, fclk )
+	stepper := tmc5160.NewDefaultStepper() // Default Stepper should be used only for testing.
+	// Step 5. Instantiate your driver
+	driver := tmc5160.NewDriver(
+		comm,
+		driverAddress,
+		enn0,
+		stepper)
+
+	// Setting and getting mode
+	rampMode := tmc5160.NewRAMPMODE(comm, driverAddress)
+	err := rampMode.SetMode(tmc5160.PositioningMode)
+	if err != nil {
+		return
+	}
+	mode, err := rampMode.GetMode()
+	if err != nil {
+		println("Error getting mode:", err)
+	} else {
+		println("Current Mode:", mode)
+	}
+
+	// Read GCONF register
+	GCONF := tmc5160.NewGCONF()
+	gconfVal, err := driver.ReadRegister(tmc5160.GCONF)
+	// Uppack the register to get all the bits and bytes of the register
+	GCONF.Unpack(gconfVal)
+	//E.g. MultiStepFlit is retrieved from the GCONF register
+	println("GCONF:MultiStepFlit:", GCONF.MultistepFilt)
+}

examples/touch/capacitive/main.go

@@ -0,0 +1,69 @@
+// Capacitive touch sensing example.
+//
+// This capacitive touch sensor works by charging a normal GPIO pin, then slowly
+// discharging it through a 1MΩ resistor and seeing how long it takes to go from
+// high to low.
+//
+// Use as follows:
+//   - Change touchPin below as needed.
+//   - Connect this pin to some metal surface, like a piece of aluminimum foil.
+//     Make sure this surface is covered (using paper, Scotch tape, etc).
+//   - Also connect this same pin to ground through a 1MΩ resistor.
+//
+// This sensor is very sensitive to noise on the power source, so you should
+// probably try to limit it by running from a battery for example. Especially
+// phone chargers can produce a lot of noise.
+package main
+
+import (
+	"machine"
+	"time"
+
+	"tinygo.org/x/drivers/touch/capacitive"
+)
+
+const touchPin = machine.GP16 // Raspberry Pi Pico
+
+func main() {
+	time.Sleep(time.Second * 2)
+	println("start")
+
+	led := machine.LED
+	led.Configure(machine.PinConfig{Mode: machine.PinOutput})
+	led.Low()
+
+	// Configure the array of GPIO pins used for capacitive touch sensing.
+	// We're using only one pin.
+	array := capacitive.NewArray([]machine.Pin{touchPin})
+
+	// Use a dynamic threshold, meaning the GPIO pin is automatically calibrated
+	// and re-calibrated to adjust for varying environments (e.g. changing
+	// humidity).
+	array.SetDynamicThreshold(100)
+
+	wasTouching := false
+	for i := uint32(0); ; i++ {
+		// Update the GPIO pin. This must be called very often.
+		array.Update()
+		touching := array.Touching(0)
+
+		// Indicate whether the pin is touched via the LED.
+		led.Set(touching)
+
+		// Print something when the touch state changed.
+		if wasTouching != touching {
+			wasTouching = touching
+			if touching {
+				println("  touch!")
+			} else {
+				println("  release!")
+			}
+		}
+
+		// Print the current value, as a debugging aid. It's not really meant to
+		// be used directly.
+		if i%128 == 32 {
+			println("touch value:", array.RawValue(0))
+		}
+	}
+}

examples/uc8151/main.go

@@ -3,7 +3,9 @@ package main
 import (
 	"image/color"
 	"machine"
+	"time"
 
+	"tinygo.org/x/drivers"
 	"tinygo.org/x/drivers/uc8151"
 )
 
@@ -14,30 +16,56 @@ func main() {
 	led = machine.LED
 	led.Configure(machine.PinConfig{Mode: machine.PinOutput})
 	machine.SPI0.Configure(machine.SPIConfig{
-		Frequency: 12000000,
+		Frequency: 12 * machine.MHz,
 		SCK:       machine.EPD_SCK_PIN,
 		SDO:       machine.EPD_SDO_PIN,
 	})
 
 	display = uc8151.New(machine.SPI0, machine.EPD_CS_PIN, machine.EPD_DC_PIN, machine.EPD_RESET_PIN, machine.EPD_BUSY_PIN)
 	display.Configure(uc8151.Config{
-		Rotation: uc8151.ROTATION_270,
-		Speed:    uc8151.MEDIUM,
-		Blocking: true,
+		Rotation:    drivers.Rotation270,
+		Speed:       uc8151.TURBO,
+		FlickerFree: true,
+		Blocking:    false,
 	})
 	black := color.RGBA{1, 1, 1, 255}
 
-	display.ClearBuffer()
-	display.Display()
-	for i := int16(0); i < 37; i++ {
-		for j := int16(0); j < 16; j++ {
-			if (i+j)%2 == 0 {
-				showRect(i*8, j*8, 8, 8, black)
+	display.ClearDisplay()
+
+	mod := int16(1)
+	for {
+		// checkerboard
+		for i := int16(0); i < 11; i++ {
+			if mod == 1 {
+				mod = 0
+			} else {
+				mod = 1
+			}
+
+			display.ClearBuffer()
+			for i := int16(0); i < 37; i++ {
+				for j := int16(0); j < 16; j++ {
+					if (i+j)%2 == mod {
+						showRect(i*8, j*8, 8, 8, black)
+					}
+				}
+			}
+			display.Display()
+			time.Sleep(500 * time.Millisecond)
+		}
+
+		// moving line
+		for i := int16(16); i < 21; i++ {
+			display.ClearBuffer()
+			for j := int16(0); j < 16; j++ {
+				if (i+j)%2 == 0 {
+					showRect(i*8, j*8, 8, 8, black)
+				}
+				display.Display()
+				time.Sleep(250 * time.Millisecond)
 			}
 		}
 	}
-
-	display.Display()
 }
 
 func showRect(x int16, y int16, w int16, h int16, c color.RGBA) {

examples/unoqmatrix/main.go

@@ -0,0 +1,54 @@
+package main
+
+import (
+	"machine"
+
+	"image/color"
+	"math/rand"
+
+	"tinygo.org/x/drivers/unoqmatrix"
+)
+
+var on = color.RGBA{255, 255, 255, 255}
+
+func main() {
+	display := unoqmatrix.NewFromBasePin(machine.PF0)
+	display.ClearDisplay()
+
+	w, h := display.Size()
+	x := int16(0)
+	y := int16(0)
+	deltaX := int16(1)
+	deltaY := int16(1)
+
+	for {
+		pixel := display.GetPixel(x, y)
+		if pixel.R != 0 || pixel.G != 0 || pixel.B != 0 {
+			display.ClearDisplay()
+			x = 1 + int16(rand.Int31n(3))
+			y = 1 + int16(rand.Int31n(3))
+			deltaX = 1
+			deltaY = 1
+			if rand.Int31n(2) == 0 {
+				deltaX = -1
+			}
+			if rand.Int31n(2) == 0 {
+				deltaY = -1
+			}
+		}
+		display.SetPixel(x, y, on)
+
+		x += deltaX
+		y += deltaY
+
+		if x == 0 || x == w-1 {
+			deltaX = -deltaX
+		}
+
+		if y == 0 || y == h-1 {
+			deltaY = -deltaY
+		}
+
+		display.Display()
+	}
+}

examples/w5500/main.go

@@ -0,0 +1,37 @@
+package main
+
+import (
+	"machine"
+	"net"
+	"net/netip"
+	"time"
+
+	"tinygo.org/x/drivers/netdev"
+	"tinygo.org/x/drivers/w5500"
+)
+
+func main() {
+	machine.SPI0.Configure(machine.SPIConfig{
+		Frequency: 33 * machine.MHz,
+	})
+	machine.GPIO17.Configure(machine.PinConfig{Mode: machine.PinOutput})
+
+	eth := w5500.New(machine.SPI0, machine.GPIO17)
+	eth.Configure(w5500.Config{
+		MAC:        net.HardwareAddr{0xee, 0xbe, 0xe9, 0xa9, 0xb6, 0x4f},
+		IP:         netip.AddrFrom4([4]byte{192, 168, 1, 2}),
+		SubnetMask: netip.AddrFrom4([4]byte{255, 255, 255, 0}),
+		Gateway:    netip.AddrFrom4([4]byte{192, 168, 1, 1}),
+	})
+	netdev.UseNetdev(eth)
+
+	for {
+		if eth.LinkStatus() != w5500.LinkStatusUp {
+			println("Waiting for link to be up")
+
+			time.Sleep(1 * time.Second)
+			continue
+		}
+		break
+	}
+}

examples/waveshare-epd/epd1in54/main.go

@@ -0,0 +1,36 @@
+package main
+
+import (
+	"image/color"
+	"machine"
+
+	"tinygo.org/x/drivers/waveshare-epd/epd1in54"
+	"tinygo.org/x/tinyfont"
+	"tinygo.org/x/tinyfont/gophers"
+)
+
+var (
+	spi0 = machine.SPI0
+	cs   = machine.D10
+	dc   = machine.D9
+	rst  = machine.D6
+	busy = machine.D5
+
+	black = color.RGBA{R: 1, G: 1, B: 1, A: 255}
+)
+
+func main() {
+	display := epd1in54.New(spi0, cs, dc, rst, busy)
+
+	display.LDirInit(epd1in54.Config{})
+	display.Clear()
+	display.ClearBuffer()
+
+	tinyfont.WriteLineRotated(&display, &gophers.Regular58pt, 150, 0, "A B C", black, tinyfont.ROTATION_90)
+	tinyfont.WriteLineRotated(&display, &gophers.Regular58pt, 100, 0, "D E F", black, tinyfont.ROTATION_90)
+	tinyfont.WriteLineRotated(&display, &gophers.Regular58pt, 50, 0, "G H I", black, tinyfont.ROTATION_90)
+	tinyfont.WriteLineRotated(&display, &gophers.Regular58pt, 0, 0, "J K L", black, tinyfont.ROTATION_90)
+
+	display.Display()
+	display.Sleep()
+}

examples/waveshare-epd/epd2in66b/main.go

@@ -0,0 +1,84 @@
+package main
+
+import (
+	"image/color"
+	"machine"
+	"time"
+
+	"tinygo.org/x/drivers"
+	"tinygo.org/x/drivers/waveshare-epd/epd2in66b"
+	"tinygo.org/x/tinyfont"
+	"tinygo.org/x/tinyfont/freemono"
+)
+
+var (
+	black = color.RGBA{0, 0, 0, 0xff}
+	white = color.RGBA{0xff, 0xff, 0xff, 0xff}
+	red   = color.RGBA{0xff, 0, 0, 0xff}
+)
+
+func main() {
+	machine.Serial.Configure(machine.UARTConfig{})
+	time.Sleep(2 * time.Second)
+
+	machine.SPI1.Configure(machine.SPIConfig{
+		Frequency: epd2in66b.Baudrate,
+	})
+
+	println("started")
+
+	// in case you have a Pico module, you can directly use
+	// dev, err := epd2in66b.NewPicoModule()
+
+	display := epd2in66b.New(machine.SPI1)
+
+	cfg := epd2in66b.Config{
+		DataPin:       machine.GP8,
+		ChipSelectPin: machine.GP9,
+		ResetPin:      machine.GP12,
+		BusyPin:       machine.GP13,
+	}
+	err := display.Configure(cfg)
+	if err != nil {
+		panic(err)
+	}
+
+	err = display.Reset()
+	if err != nil {
+		panic(err)
+	}
+
+	println("draw checkerboard")
+	drawCheckerBoard(&display)
+
+	println("draw 'hello'")
+	tinyfont.WriteLineRotated(&display, &freemono.Bold24pt7b, 40, 10, "Hello!", white, tinyfont.ROTATION_90)
+	tinyfont.WriteLineRotated(&display, &freemono.Bold12pt7b, 10, 10, "tinygo rocks", white, tinyfont.ROTATION_90)
+	err = display.Display()
+	if err != nil {
+		panic(err)
+	}
+}
+
+func drawCheckerBoard(display drivers.Displayer) {
+	s := 8
+	width, height := display.Size()
+	for x := 0; x <= int(width)-s; x += s {
+		for y := 0; y <= int(height)-s; y += s {
+			c := red
+			if (x/s)%2 == (y/s)%2 {
+				c = black
+			}
+
+			showRect(display, x, y, s, s, c)
+		}
+	}
+}
+
+func showRect(display drivers.Displayer, x int, y int, w int, h int, c color.RGBA) {
+	for i := x; i < x+w; i++ {
+		for j := y; j < y+h; j++ {
+			display.SetPixel(int16(i), int16(j), c)
+		}
+	}
+}

examples/waveshare-epd/epd2in9v2/main.go

@@ -0,0 +1,137 @@
+package main
+
+import (
+	"image/color"
+	"machine"
+	"time"
+
+	"tinygo.org/x/drivers/waveshare-epd/epd2in9v2"
+)
+
+var display epd2in9v2.Device
+
+func main() {
+	machine.SPI0.Configure(machine.SPIConfig{
+		Frequency: 12000000,
+		SCK:       machine.EPD_SCK_PIN,
+		SDO:       machine.EPD_SDO_PIN,
+	})
+
+	display = epd2in9v2.New(
+		machine.SPI0,
+		machine.EPD_CS_PIN,
+		machine.EPD_DC_PIN,
+		machine.EPD_RESET_PIN,
+		machine.EPD_BUSY_PIN,
+	)
+	display.Configure(epd2in9v2.Config{
+		Rotation: epd2in9v2.ROTATION_270,
+		Speed:    epd2in9v2.SPEED_DEFAULT,
+		Blocking: true,
+	})
+
+	black := color.RGBA{0, 0, 0, 255}
+	white := color.RGBA{255, 255, 255, 255}
+
+	// --- Step 1: clear to white ---
+	println("epd2in9v2: clearing display")
+	display.ClearBuffer()
+	display.Display()
+	time.Sleep(2 * time.Second)
+
+	// --- Step 2: full refresh checkerboard ---
+	println("epd2in9v2: drawing checkerboard (full refresh)")
+	w, h := display.Size()
+	for i := int16(0); i < w/8; i++ {
+		for j := int16(0); j < h/8; j++ {
+			if (i+j)%2 == 0 {
+				fillRect(i*8, j*8, 8, 8, black)
+			}
+		}
+	}
+	display.Display()
+	time.Sleep(2 * time.Second)
+
+	// --- Step 3: fast refresh - draw border and diagonal cross ---
+	println("epd2in9v2: switching to fast refresh")
+	display.SetSpeed(epd2in9v2.SPEED_FAST)
+	display.ClearBuffer()
+
+	for x := int16(0); x < w; x++ {
+		display.SetPixel(x, 0, black)
+		display.SetPixel(x, h-1, black)
+	}
+	for y := int16(0); y < h; y++ {
+		display.SetPixel(0, y, black)
+		display.SetPixel(w-1, y, black)
+	}
+	for i := int16(0); i < w && i < h; i++ {
+		display.SetPixel(i, i*h/w, black)
+		display.SetPixel(w-1-i, i*h/w, black)
+	}
+
+	display.Display()
+	time.Sleep(2 * time.Second)
+
+	// --- Step 4: partial refresh counter ---
+	println("epd2in9v2: partial refresh demo")
+	display.SetSpeed(epd2in9v2.SPEED_DEFAULT)
+	display.ClearBuffer()
+
+	println("epd2in9v2: setting base image")
+	display.DisplayWithBase()
+
+	for count := 0; count < 10; count++ {
+		cx := int16(120)
+		cy := int16(50)
+		fillRect(cx, cy, 60, 20, white)
+
+		digit := int16(count % 10)
+		drawDigit(cx+22, cy+2, digit, black)
+
+		display.DisplayPartial()
+		time.Sleep(500 * time.Millisecond)
+	}
+	time.Sleep(2 * time.Second)
+
+	// --- Step 5: sleep ---
+	println("epd2in9v2: entering deep sleep")
+	display.ClearBuffer()
+	display.Display()
+	display.Sleep()
+	println("epd2in9v2: done, you can remove power")
+}
+
+func fillRect(x, y, w, h int16, c color.RGBA) {
+	for i := x; i < x+w; i++ {
+		for j := y; j < y+h; j++ {
+			display.SetPixel(i, j, c)
+		}
+	}
+}
+
+// drawDigit draws a simple 3x5-pixel-block digit (each block 4x3 px) at position (x,y).
+func drawDigit(x, y, digit int16, c color.RGBA) {
+	segments := [10][5]uint8{
+		{0x7, 0x5, 0x5, 0x5, 0x7}, // 0
+		{0x2, 0x2, 0x2, 0x2, 0x2}, // 1
+		{0x7, 0x1, 0x7, 0x4, 0x7}, // 2
+		{0x7, 0x1, 0x7, 0x1, 0x7}, // 3
+		{0x5, 0x5, 0x7, 0x1, 0x1}, // 4
+		{0x7, 0x4, 0x7, 0x1, 0x7}, // 5
+		{0x7, 0x4, 0x7, 0x5, 0x7}, // 6
+		{0x7, 0x1, 0x1, 0x1, 0x1}, // 7
+		{0x7, 0x5, 0x7, 0x5, 0x7}, // 8
+		{0x7, 0x5, 0x7, 0x1, 0x7}, // 9
+	}
+	if digit < 0 || digit > 9 {
+		return
+	}
+	for row := int16(0); row < 5; row++ {
+		for col := int16(0); col < 3; col++ {
+			if segments[digit][row]&(0x4>>uint(col)) != 0 {
+				fillRect(x+col*4, y+row*3, 4, 3, c)
+			}
+		}
+	}
+}

examples/ws2812/arduino.go

@@ -1,10 +1,11 @@
-//go:build arduino
+//go:build arduino || arduino_uno
 
 package main
 
 import "machine"
 
-// Replace neo and led in the code below to match the pin
-// that you are using if different.
-var neo = machine.D2
-var led = machine.LED
+func init() {
+	// Replace neo in the code below to match the pin
+	// that you are using if different.
+	neo = machine.D2
+}

examples/ws2812/digispark.go

@@ -4,8 +4,9 @@ package main
 
 import "machine"
 
-// This is the pin assignment for the Digispark only.
-// Replace neo and led in the code below to match the pin
-// that you are using if different.
-var neo machine.Pin = 0
-var led = machine.LED
+func init() {
+	// This is the pin assignment for the Digispark only.
+	// Replace neo and led in the code below to match the pin
+	// that you are using if different.
+	neo = machine.Pin(0)
+}

examples/ws2812/main.go

@@ -12,11 +12,12 @@ import (
 	"tinygo.org/x/drivers/ws2812"
 )
 
-var leds [10]color.RGBA
+var (
+	neo  machine.Pin
+	leds [10]color.RGBA
+)
 
 func main() {
-	led.Configure(machine.PinConfig{Mode: machine.PinOutput})
-
 	neo.Configure(machine.PinConfig{Mode: machine.PinOutput})
 
 	ws := ws2812.NewWS2812(neo)
@@ -35,7 +36,6 @@ func main() {
 		}
 
 		ws.WriteColors(leds[:])
-		led.Set(rg)
 		time.Sleep(100 * time.Millisecond)
 	}
 }

examples/ws2812/others.go

@@ -1,10 +1,11 @@
-//go:build !digispark && !arduino && !qtpy && !m5stamp_c3 && !thingplus_rp2040
+//go:build !digispark && !arduino && !arduino_uno && !xiao_esp32c3
 
 package main
 
 import "machine"
 
-// Replace neo and led in the code below to match the pin
-// that you are using if different.
-var neo machine.Pin = machine.WS2812
-var led = machine.LED
+func init() {
+	// Replace neo in the code below to match the pin
+	// that you are using if different.
+	neo = machine.WS2812
+}

examples/ws2812/others_wo_led.go

@@ -1,10 +0,0 @@
-//go:build qtpy || m5stamp_c3
-
-package main
-
-import "machine"
-
-// Replace neo and led in the code below to match the pin
-// that you are using if different.
-var neo machine.Pin = machine.WS2812
-var led = machine.NoPin

examples/ws2812/thingplus-rp2040.go

@@ -1,12 +0,0 @@
-//go:build thingplus_rp2040
-
-package main
-
-import "machine"
-
-// This is the pin assignment for the internal neopixel of the
-// Sparkfun thingplus rp2040.
-// Replace neo and led in the code below to match the pin
-// that you are using if different.
-var neo machine.Pin = machine.GPIO8
-var led = machine.LED

examples/ws2812/xiao-esp32c3.go

@@ -0,0 +1,11 @@
+//go:build xiao_esp32c3
+
+package main
+
+import "machine"
+
+func init() {
+	// Replace neo in the code below to match the pin
+	// that you are using if different.
+	neo = machine.D6
+}