feat(rp2350): add preemptive scheduler and DMA UART for crea8 board

This commit introduces an alternate runtime for RP2350 (crea8 board)
optimized for real-time applications like 3D printing and PNP machines.

Key features:
- Preemptive scheduler using SysTick timer for time slicing
- PendSV-based context switching (matches Pico SDK pattern)
- DMA-based UART for non-blocking serial I/O
- Priority-based task scheduling with 8 priority levels
- Multi-core support with both RP2350 cores
- Improved IRQ priority management

New files:
- targets/crea8.json, crea8-preemptive.json - Board targets
- src/machine/board_crea8.go - Pin definitions for 3D printing/PNP
- src/runtime/scheduler_preemptive.go - Preemptive scheduler
- src/runtime/runtime_rp2_preemptive.go - RP2350 preemptive runtime
- src/machine/machine_rp2_uart_dma.go - DMA-based UART driver
- src/internal/task/*_preemptive*.go - Task/context support
- src/examples/crea8-preemptive/ - Example application

Build with: tinygo build -target=crea8-preemptive

Author: claude

compileopts/options.go

@@ -10,7 +10,7 @@ import (
 var (
 	validBuildModeOptions     = []string{"default", "c-shared", "wasi-legacy"}
 	validGCOptions            = []string{"none", "leaking", "conservative", "custom", "precise", "boehm"}
-	validSchedulerOptions     = []string{"none", "tasks", "asyncify", "threads", "cores"}
+	validSchedulerOptions     = []string{"none", "tasks", "asyncify", "threads", "cores", "preemptive"}
 	validSerialOptions        = []string{"none", "uart", "usb", "rtt"}
 	validPrintSizeOptions     = []string{"none", "short", "full", "html"}
 	validPanicStrategyOptions = []string{"print", "trap"}

src/examples/crea8-preemptive/main.go

@@ -0,0 +1,188 @@
+// Example demonstrating preemptive scheduler and DMA UART on RP2350 (Crea8 board).
+//
+// Build with:
+//   tinygo build -target=crea8-preemptive -o firmware.uf2 ./examples/crea8-preemptive
+//
+// This example shows:
+// - Preemptive multitasking with time slicing
+// - DMA-based UART for non-blocking serial I/O
+// - Priority-based task scheduling
+// - Real-time task patterns for 3D printing / PNP applications
+
+package main
+
+import (
+	"machine"
+	"runtime"
+	"time"
+)
+
+// Task priorities (0 = highest, 7 = lowest)
+const (
+	PriorityMotion    = 0 // Highest - stepper motor control
+	PrioritySerial    = 2 // High - serial communication
+	PriorityTemperature = 4 // Medium - temperature control
+	PriorityDisplay   = 6 // Low - display updates
+	PriorityIdle      = 7 // Lowest - idle task
+)
+
+// Shared state (protected by mutex in real applications)
+var (
+	stepperX int32
+	stepperY int32
+	stepperZ int32
+
+	hotendTemp  float32
+	bedTemp     float32
+	targetHotend float32 = 200.0
+	targetBed   float32 = 60.0
+)
+
+func main() {
+	// Configure LED for status indication
+	machine.LED.Configure(machine.PinConfig{Mode: machine.PinOutput})
+
+	// Configure stepper pins (example)
+	machine.STEPPER_X_STEP.Configure(machine.PinConfig{Mode: machine.PinOutput})
+	machine.STEPPER_X_DIR.Configure(machine.PinConfig{Mode: machine.PinOutput})
+	machine.STEPPER_Y_STEP.Configure(machine.PinConfig{Mode: machine.PinOutput})
+	machine.STEPPER_Y_DIR.Configure(machine.PinConfig{Mode: machine.PinOutput})
+
+	// Configure heater pins
+	machine.HEATER_HOTEND.Configure(machine.PinConfig{Mode: machine.PinOutput})
+	machine.HEATER_BED.Configure(machine.PinConfig{Mode: machine.PinOutput})
+
+	println("Crea8 Preemptive Scheduler Demo")
+	println("================================")
+	println("Number of CPUs:", runtime.NumCPU())
+
+	// Start high-priority motion control task
+	go motionControlTask()
+
+	// Start serial communication task
+	go serialTask()
+
+	// Start temperature control task
+	go temperatureControlTask()
+
+	// Start display update task
+	go displayTask()
+
+	// Main loop - blink LED to show system is running
+	for {
+		machine.LED.High()
+		time.Sleep(500 * time.Millisecond)
+		machine.LED.Low()
+		time.Sleep(500 * time.Millisecond)
+	}
+}
+
+// motionControlTask handles stepper motor control with highest priority
+// This task should not be preempted during critical step pulse generation
+func motionControlTask() {
+	stepInterval := 100 * time.Microsecond // 10kHz step rate
+
+	for {
+		// Generate step pulses (simplified example)
+		// In a real implementation, you would use interrupt.Disable()/Restore()
+		// for critical timing sections
+		machine.STEPPER_X_STEP.High()
+		machine.STEPPER_Y_STEP.High()
+
+		// Small delay for step pulse width (~1-2us)
+		for i := 0; i < 10; i++ {
+			// Busy wait
+		}
+
+		machine.STEPPER_X_STEP.Low()
+		machine.STEPPER_Y_STEP.Low()
+
+		// Update position counters
+		stepperX++
+		stepperY++
+
+		// Wait for next step
+		time.Sleep(stepInterval)
+	}
+}
+
+// serialTask handles serial communication
+func serialTask() {
+	// Buffer for incoming data
+	buf := make([]byte, 256)
+
+	for {
+		// Check for incoming data
+		if machine.Serial.Buffered() > 0 {
+			n, _ := machine.Serial.Read(buf)
+			if n > 0 {
+				// Echo back received data
+				machine.Serial.Write(buf[:n])
+
+				// Process G-code commands (simplified)
+				processCommand(buf[:n])
+			}
+		}
+
+		// Yield to other tasks
+		runtime.Gosched()
+	}
+}
+
+// temperatureControlTask handles heater PID control
+func temperatureControlTask() {
+	for {
+		// Read temperature sensors (simplified - would use ADC)
+		hotendTemp = readTemperature(machine.TEMP_HOTEND_ADC)
+		bedTemp = readTemperature(machine.TEMP_BED_ADC)
+
+		// Simple bang-bang control (real implementation would use PID)
+		if hotendTemp < targetHotend-2 {
+			machine.HEATER_HOTEND.High()
+		} else if hotendTemp > targetHotend+2 {
+			machine.HEATER_HOTEND.Low()
+		}
+
+		if bedTemp < targetBed-2 {
+			machine.HEATER_BED.High()
+		} else if bedTemp > targetBed+2 {
+			machine.HEATER_BED.Low()
+		}
+
+		// Temperature control runs at 10Hz
+		time.Sleep(100 * time.Millisecond)
+	}
+}
+
+// displayTask updates the display (lowest priority)
+func displayTask() {
+	for {
+		// Print status (would update LCD in real application)
+		println("X:", stepperX, "Y:", stepperY, "Z:", stepperZ)
+		println("Hotend:", hotendTemp, "/", targetHotend)
+		println("Bed:", bedTemp, "/", targetBed)
+		println("---")
+
+		// Display updates at 1Hz
+		time.Sleep(1 * time.Second)
+	}
+}
+
+// readTemperature reads temperature from ADC (simplified)
+func readTemperature(pin machine.Pin) float32 {
+	// Simplified - real implementation would read ADC and convert
+	return 25.0 // Room temperature placeholder
+}
+
+// processCommand processes incoming G-code commands
+func processCommand(data []byte) {
+	// Simplified G-code parsing
+	if len(data) > 0 {
+		switch data[0] {
+		case 'G':
+			println("G-code command received")
+		case 'M':
+			println("M-code command received")
+		}
+	}
+}

src/internal/task/atomic-preemptive-rp2.go

@@ -0,0 +1,64 @@
+//go:build scheduler.preemptive && (rp2040 || rp2350)
+
+// Atomic operations for preemptive scheduler on RP2040/RP2350.
+// Uses hardware spinlocks for atomicity.
+
+package task
+
+import "runtime/interrupt"
+
+// Uint32 provides atomic uint32 operations
+type Uint32 struct {
+	v uint32
+}
+
+// Load atomically loads the value
+func (u *Uint32) Load() uint32 {
+	mask := lockAtomics()
+	v := u.v
+	unlockAtomics(mask)
+	return v
+}
+
+// Store atomically stores a value
+func (u *Uint32) Store(v uint32) {
+	mask := lockAtomics()
+	u.v = v
+	unlockAtomics(mask)
+}
+
+// Swap atomically swaps and returns the old value
+func (u *Uint32) Swap(new uint32) uint32 {
+	mask := lockAtomics()
+	old := u.v
+	u.v = new
+	unlockAtomics(mask)
+	return old
+}
+
+// CompareAndSwap performs atomic compare-and-swap
+func (u *Uint32) CompareAndSwap(old, new uint32) bool {
+	mask := lockAtomics()
+	if u.v == old {
+		u.v = new
+		unlockAtomics(mask)
+		return true
+	}
+	unlockAtomics(mask)
+	return false
+}
+
+// Add atomically adds delta and returns new value
+func (u *Uint32) Add(delta uint32) uint32 {
+	mask := lockAtomics()
+	u.v += delta
+	v := u.v
+	unlockAtomics(mask)
+	return v
+}
+
+//go:linkname lockAtomics runtime.lockAtomics
+func lockAtomics() interrupt.State
+
+//go:linkname unlockAtomics runtime.unlockAtomics
+func unlockAtomics(interrupt.State)

src/internal/task/futex-preemptive.go

@@ -0,0 +1,53 @@
+//go:build scheduler.preemptive
+
+// Futex implementation for preemptive scheduler.
+
+package task
+
+import "runtime/interrupt"
+
+// Futex provides wait/wake functionality using a pointer as key
+type Futex struct {
+	Uint32
+	waiters Stack
+}
+
+// Wait atomically checks if value equals cmp and if so, sleeps
+func (f *Futex) Wait(cmp uint32) (awoken bool) {
+	mask := lockFutex()
+
+	if f.Uint32.Load() != cmp {
+		unlockFutex(mask)
+		return false
+	}
+
+	f.waiters.Push(Current())
+	unlockFutex(mask)
+
+	Pause()
+	return true
+}
+
+// Wake wakes a single waiter
+func (f *Futex) Wake() {
+	mask := lockFutex()
+	if t := f.waiters.Pop(); t != nil {
+		scheduleTask(t)
+	}
+	unlockFutex(mask)
+}
+
+// WakeAll wakes all waiters
+func (f *Futex) WakeAll() {
+	mask := lockFutex()
+	for t := f.waiters.Pop(); t != nil; t = f.waiters.Pop() {
+		scheduleTask(t)
+	}
+	unlockFutex(mask)
+}
+
+//go:linkname lockFutex runtime.lockFutex
+func lockFutex() interrupt.State
+
+//go:linkname unlockFutex runtime.unlockFutex
+func unlockFutex(interrupt.State)