feat(rp2350): add SST (Super Simple Tasker) scheduler for crea8

Adds an SST-style run-to-completion scheduler based on Quantum Leaps'
Super Simple Tasker concepts. Key features:

- Run-to-completion (RTC) task model - tasks cannot block
- Single shared stack - minimal memory footprint (~4KB total)
- Event-driven with lock-free event posting from ISRs
- Priority-based preemption (higher priority tasks preempt)
- Timer support for periodic events
- Deterministic timing for hard real-time applications

SST vs traditional threading:
- Tasks run to completion (no blocking/sleeping within handler)
- All tasks share one stack (vs per-task stacks)
- Events posted to task queues trigger execution
- Ideal for stepper motor control, 3D printing, PNP machines

New files:
- src/runtime/scheduler_sst.go - Core SST scheduler
- src/runtime/runtime_rp2_sst.go - RP2350 SST runtime
- src/runtime/gc_stack_sst.go - GC support for SST
- src/internal/task/task_sst.go - Task stubs for SST
- targets/crea8-sst.json - SST target configuration
- src/examples/crea8-sst/ - Example application

Build with: tinygo build -target=crea8-sst

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", "preemptive"}
+	validSchedulerOptions     = []string{"none", "tasks", "asyncify", "threads", "cores", "preemptive", "sst"}
 	validSerialOptions        = []string{"none", "uart", "usb", "rtt"}
 	validPrintSizeOptions     = []string{"none", "short", "full", "html"}
 	validPanicStrategyOptions = []string{"print", "trap"}

src/examples/crea8-sst/main.go

@@ -0,0 +1,293 @@
+// Example demonstrating SST (Super Simple Tasker) on RP2350 (Crea8 board).
+//
+// Build with:
+//   tinygo build -target=crea8-sst -o firmware.uf2 ./examples/crea8-sst
+//
+// This example shows:
+// - Run-to-completion task model
+// - Event-driven programming
+// - Priority-based preemption
+// - Timer-based periodic events
+// - Single shared stack (minimal memory)
+//
+// SST is ideal for hard real-time applications like stepper motor control.
+
+package main
+
+import (
+	"machine"
+	"runtime"
+)
+
+// Event signals (user signals start at SIG_USER)
+const (
+	SIG_STEP      = runtime.SIG_USER + iota // Stepper step event
+	SIG_TEMP_READ                            // Temperature read event
+	SIG_SERIAL_RX                            // Serial receive event
+	SIG_DISPLAY                              // Display update event
+	SIG_HEARTBEAT                            // LED heartbeat event
+)
+
+// Task priorities (0 = highest)
+const (
+	PRIO_STEPPER    = 0 // Highest - stepper timing critical
+	PRIO_SERIAL     = 1 // High - responsive serial handling
+	PRIO_TEMP       = 2 // Medium - temperature control
+	PRIO_DISPLAY    = 3 // Lower - display updates
+	PRIO_HEARTBEAT  = 4 // Lowest - LED blink
+)
+
+// Task state (shared - SST tasks can access directly since no preemption within task)
+var (
+	stepperX     int32
+	stepperY     int32
+	stepperZ     int32
+	stepperE     int32
+
+	targetX      int32 = 1000
+	targetY      int32 = 1000
+
+	hotendTemp   int16 = 25
+	bedTemp      int16 = 25
+	targetHotend int16 = 200
+	targetBed    int16 = 60
+
+	ledState     bool
+)
+
+// SST Tasks
+var (
+	stepperTask   *runtime.SSTTask
+	serialTask    *runtime.SSTTask
+	tempTask      *runtime.SSTTask
+	displayTask   *runtime.SSTTask
+	heartbeatTask *runtime.SSTTask
+)
+
+func main() {
+	// Configure pins
+	machine.LED.Configure(machine.PinConfig{Mode: machine.PinOutput})
+	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})
+	machine.HEATER_HOTEND.Configure(machine.PinConfig{Mode: machine.PinOutput})
+	machine.HEATER_BED.Configure(machine.PinConfig{Mode: machine.PinOutput})
+
+	// Set tick rate (10kHz for 100us resolution - good for steppers)
+	runtime.SSTSetTickRate(10000)
+
+	println("Crea8 SST Demo")
+	println("==============")
+	println("Tick rate:", runtime.SSTGetTickRate(), "Hz")
+
+	// Create tasks (priority, handler)
+	stepperTask = runtime.SSTTaskCreate(PRIO_STEPPER, stepperHandler)
+	serialTask = runtime.SSTTaskCreate(PRIO_SERIAL, serialHandler)
+	tempTask = runtime.SSTTaskCreate(PRIO_TEMP, tempHandler)
+	displayTask = runtime.SSTTaskCreate(PRIO_DISPLAY, displayHandler)
+	heartbeatTask = runtime.SSTTaskCreate(PRIO_HEARTBEAT, heartbeatHandler)
+
+	// Arm periodic timers
+	// Stepper: every 1 tick (100us) for 10kHz step rate
+	runtime.SSTTimerArm(stepperTask, SIG_STEP, 0, 1, 1)
+
+	// Temperature: every 1000 ticks (100ms)
+	runtime.SSTTimerArm(tempTask, SIG_TEMP_READ, 0, 1000, 1000)
+
+	// Display: every 10000 ticks (1s)
+	runtime.SSTTimerArm(displayTask, SIG_DISPLAY, 0, 10000, 10000)
+
+	// Heartbeat: every 5000 ticks (500ms)
+	runtime.SSTTimerArm(heartbeatTask, SIG_HEARTBEAT, 0, 5000, 5000)
+
+	// Set idle callback
+	runtime.SSTSetIdleCallback(idleCallback)
+
+	// The SST scheduler takes over from here
+	// (run() is called automatically by the runtime)
+	select {} // Never reached
+}
+
+// stepperHandler - highest priority, runs to completion
+// Generates step pulses for motion control
+func stepperHandler(e *runtime.Event) {
+	switch e.Signal {
+	case runtime.SIG_INIT:
+		println("Stepper task initialized")
+
+	case SIG_STEP:
+		// Generate step pulses if we need to move
+		stepped := false
+
+		if stepperX < targetX {
+			machine.STEPPER_X_DIR.High()
+			machine.STEPPER_X_STEP.High()
+			stepperX++
+			stepped = true
+		} else if stepperX > targetX {
+			machine.STEPPER_X_DIR.Low()
+			machine.STEPPER_X_STEP.High()
+			stepperX--
+			stepped = true
+		}
+
+		if stepperY < targetY {
+			machine.STEPPER_Y_DIR.High()
+			machine.STEPPER_Y_STEP.High()
+			stepperY++
+			stepped = true
+		} else if stepperY > targetY {
+			machine.STEPPER_Y_DIR.Low()
+			machine.STEPPER_Y_STEP.High()
+			stepperY--
+			stepped = true
+		}
+
+		// Small delay for pulse width, then lower step pins
+		if stepped {
+			// Inline delay (~1-2us)
+			for i := 0; i < 10; i++ {
+				// Busy loop for minimum pulse width
+			}
+			machine.STEPPER_X_STEP.Low()
+			machine.STEPPER_Y_STEP.Low()
+		}
+	}
+	// Task returns here (run-to-completion)
+}
+
+// serialHandler - handles serial communication
+func serialHandler(e *runtime.Event) {
+	switch e.Signal {
+	case runtime.SIG_INIT:
+		println("Serial task initialized")
+		// Setup serial RX interrupt to post events
+		// (simplified - real implementation would use UART IRQ)
+
+	case SIG_SERIAL_RX:
+		// Process received data
+		buf := make([]byte, 64)
+		n, _ := machine.Serial.Read(buf)
+		if n > 0 {
+			processGCode(buf[:n])
+		}
+	}
+}
+
+// tempHandler - temperature control
+func tempHandler(e *runtime.Event) {
+	switch e.Signal {
+	case runtime.SIG_INIT:
+		println("Temperature task initialized")
+
+	case SIG_TEMP_READ:
+		// Read temperatures (simplified - would use ADC)
+		hotendTemp = readADCTemp(machine.TEMP_HOTEND_ADC)
+		bedTemp = readADCTemp(machine.TEMP_BED_ADC)
+
+		// 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()
+		}
+	}
+}
+
+// displayHandler - display/status updates
+func displayHandler(e *runtime.Event) {
+	switch e.Signal {
+	case runtime.SIG_INIT:
+		println("Display task initialized")
+
+	case SIG_DISPLAY:
+		println("Position X:", stepperX, "Y:", stepperY)
+		println("Temp H:", hotendTemp, "/", targetHotend, "B:", bedTemp, "/", targetBed)
+		println("Tick:", runtime.SSTGetTickCount())
+		println("---")
+	}
+}
+
+// heartbeatHandler - LED blink to show system is alive
+func heartbeatHandler(e *runtime.Event) {
+	switch e.Signal {
+	case runtime.SIG_INIT:
+		println("Heartbeat task initialized")
+
+	case SIG_HEARTBEAT:
+		ledState = !ledState
+		if ledState {
+			machine.LED.High()
+		} else {
+			machine.LED.Low()
+		}
+	}
+}
+
+// idleCallback - called when no tasks have pending events
+func idleCallback() {
+	// Check for serial data and post event if available
+	if machine.Serial.Buffered() > 0 {
+		event := runtime.Event{Signal: SIG_SERIAL_RX}
+		serialTask.Post(&event)
+	}
+
+	// Could enter low-power mode here
+	// arm.Asm("wfe")
+}
+
+// processGCode processes G-code commands (simplified)
+func processGCode(data []byte) {
+	if len(data) == 0 {
+		return
+	}
+
+	switch data[0] {
+	case 'G':
+		// Movement commands
+		if len(data) > 1 {
+			switch data[1] {
+			case '0', '1': // G0/G1 - linear move
+				// Parse X, Y, Z, E parameters (simplified)
+				println("G-code move command")
+				targetX += 100
+				targetY += 100
+			case '2', '8': // G28 - home
+				println("G-code home command")
+				targetX = 0
+				targetY = 0
+			}
+		}
+
+	case 'M':
+		// Machine commands
+		if len(data) > 1 {
+			switch data[1] {
+			case '1': // M104/M109 - set hotend temp
+				println("M-code hotend temp")
+				targetHotend = 200
+			case '4': // M140 - set bed temp
+				println("M-code bed temp")
+				targetBed = 60
+			}
+		}
+	}
+}
+
+// readADCTemp reads temperature from ADC pin (simplified)
+func readADCTemp(pin machine.Pin) int16 {
+	// Simplified - real implementation would use ADC
+	return 25 // Room temperature
+}
+
+// PostStepEvent can be called from ISR to trigger step
+func PostStepEvent() {
+	stepperTask.PostFromISR(SIG_STEP, 0)
+}

src/internal/task/task_sst.go

@@ -0,0 +1,46 @@
+//go:build scheduler.sst
+
+// SST doesn't use the traditional task model.
+// This file provides stubs to satisfy the runtime interface.
+
+package task
+
+import "unsafe"
+
+// Task is unused in SST but needed for interface compatibility
+type Task struct {
+	Next     *Task
+	Ptr      unsafe.Pointer
+	Data     uint64
+	RunState uint8
+}
+
+// Stub constants
+const (
+	RunStatePaused   = 0
+	RunStateRunning  = 1
+	RunStateResuming = 2
+)
+
+// Current returns nil in SST (no traditional tasks)
+func Current() *Task {
+	return nil
+}
+
+// Pause is a no-op in SST
+func Pause() {
+}
+
+// PauseLocked is a no-op in SST
+func PauseLocked() {
+}
+
+// OnSystemStack returns true in SST (single stack)
+func OnSystemStack() bool {
+	return true
+}
+
+// SystemStack returns the system stack pointer
+func SystemStack() uintptr {
+	return 0
+}

src/runtime/gc_stack_sst.go

@@ -0,0 +1,29 @@
+//go:build scheduler.sst
+
+// GC stack scanning for SST scheduler.
+// SST uses a single shared stack, making GC simpler.
+
+package runtime
+
+// gcMarkReachable scans the single shared stack
+func gcMarkReachable() {
+	// Scan the current (only) stack
+	scanCurrentStack()
+
+	// Scan globals
+	findGlobals(markRoots)
+}
+
+//go:export tinygo_scanCurrentStack
+func scanCurrentStack()
+
+//go:export tinygo_scanstack
+func scanstack(sp uintptr) {
+	// Single stack - scan from sp to top
+	markRoots(sp, stackTop)
+}
+
+// gcResumeWorld is a no-op for SST (single core, single stack)
+func gcResumeWorld() {
+	// Nothing to do
+}