add ws2812b alternative to ws2812 driver (#10)

* add ws2812b alternative to ws2812 driver

* fix timings a bit

* add working WS2812B implementation!

Author: soypat

rp2-pio/examples/ws2812/main.go

@@ -12,39 +12,56 @@ import (
 func main() {
 	const ws2812Pin = machine.GP16
 	sm, _ := pio.PIO0.ClaimStateMachine()
-	ws, err := piolib.NewWS2812(sm, ws2812Pin)
+	ws, err := piolib.NewWS2812B(sm, ws2812Pin)
 	if err != nil {
 		panic(err.Error())
 	}
-	const maxVal = 255
+	const maxVal = 4
 	red := color.RGBA{R: maxVal}
 	amber := color.RGBA{R: maxVal, G: maxVal / 4 * 3}
 	green := color.RGBA{G: maxVal}
+	for {
+		for g := uint8(0); g < 255; g |= 1 {
+			for r := uint8(0); r < 255; r |= 1 {
+				for b := uint8(0); b < 255; b |= 1 {
+					time.Sleep(time.Second / 8)
+					ws.PutRGB(r, g, b)
+					b <<= 1
+					println(r, g, b)
+				}
+				println("max blue")
+				r <<= 1
+			}
+			println("max red")
+			g <<= 1
+		}
+		println("max greenb")
+	}
 
 	// Stoplight sequence.
 	for {
 		const longWait = 6 * time.Second
 		const shortWait = 2 * time.Second
 		// Start Stoplight in red (STOP).
 		println("red")
-		ws.SetColor(red)
+		ws.PutColor(red)
 		time.Sleep(4 * time.Second)
 
 		// Before green we go through a red+yellow stage (PREP. PULL AWAY)
 		println("green/amber switching")
 		for i := 0; i < 2; i++ {
 			const semiSleep = time.Second / 2
-			ws.SetColor(amber)
+			ws.PutColor(amber)
 			time.Sleep(semiSleep)
-			ws.SetColor(red)
+			ws.PutColor(red)
 			time.Sleep(semiSleep)
 		}
 		println("green")
-		ws.SetColor(green)
+		ws.PutColor(green)
 		time.Sleep(longWait)
 
 		println("amber")
-		ws.SetColor(amber)
+		ws.PutColor(amber)
 		time.Sleep(shortWait)
 	}
 }

rp2-pio/examples/ws2812b/main.go

@@ -0,0 +1,68 @@
+package main
+
+import (
+	"machine"
+	"time"
+
+	pio "github.com/tinygo-org/pio/rp2-pio"
+	"github.com/tinygo-org/pio/rp2-pio/piolib"
+)
+
+func main() {
+	const ws2812Pin = machine.GP16
+	sm, _ := pio.PIO0.ClaimStateMachine()
+	ws, err := piolib.NewWS2812B(sm, ws2812Pin)
+	if err != nil {
+		panic(err.Error())
+	}
+	const lightIntensity = 64
+	rawred := rawcolor(lightIntensity, 0, 0)
+	rawgreen := rawcolor(0, lightIntensity, 0)
+	// Make Christmas lights of first part of strip.
+	ws.EnableDMA(true)
+	ws.WriteRaw([]uint32{
+		0,
+		rawred,
+		rawgreen,
+		rawred,
+		rawgreen,
+		rawred,
+		rawgreen,
+		rawred,
+		rawgreen,
+		rawred,
+		rawgreen,
+		rawred,
+		rawgreen,
+		rawred,
+		rawgreen,
+	})
+
+	// And sweep first LED.
+	const sweepIncrement = 1
+	const sweepPeriod = time.Second / 4
+	for {
+		println("red sweep")
+		for r := uint8(0); r < 255; r += sweepIncrement {
+			ws.PutRGB(r, 0, 0)
+			time.Sleep(sweepPeriod)
+		}
+		time.Sleep(time.Second)
+		println("green sweep")
+		for g := uint8(0); g < 255; g += sweepIncrement {
+			ws.PutRGB(0, g, 0)
+			time.Sleep(sweepPeriod)
+		}
+		time.Sleep(time.Second)
+		println("blue sweep")
+		for b := uint8(0); b < 255; b += sweepIncrement {
+			ws.PutRGB(0, 0, b)
+			time.Sleep(sweepPeriod)
+		}
+		time.Sleep(time.Second)
+	}
+}
+
+func rawcolor(r, g, b uint8) uint32 {
+	return uint32(g)<<24 | uint32(r)<<16 | uint32(b)<<8
+}

rp2-pio/piolib/all_generate.go

@@ -21,6 +21,7 @@ var (
 //go:generate pioasm -o go pulsar.pio     pulsar_pio.go
 //go:generate pioasm -o go spi.pio        spi_pio.go
 //go:generate pioasm -o go ws2812.pio     ws2812_pio.go
+//go:generate pioasm -o go ws2812b.pio     ws2812b_pio.go
 //go:generate pioasm -o go i2s.pio        i2s_pio.go
 //go:generate pioasm -o go spi3w.pio       spi3w_pio.go
 func gosched() {

rp2-pio/piolib/ws2812b.go

@@ -0,0 +1,135 @@
+//go:build rp2040
+
+package piolib
+
+import (
+	"image/color"
+	"machine"
+
+	pio "github.com/tinygo-org/pio/rp2-pio"
+)
+
+// WS2812B is an RGB LED strip controller implementation, also known as NeoPixel.
+type WS2812B struct {
+	sm     pio.StateMachine
+	dma    dmaChannel
+	offset uint8
+}
+
+func NewWS2812B(sm pio.StateMachine, pin machine.Pin) (*WS2812B, error) {
+	// https://cdn-shop.adafruit.com/datasheets/WS2812B.pdf
+	const (
+		baseline      = 1250.
+		baselinesplit = baseline / 3
+		cycle         = baselinesplit / 3
+		freq          = uint32(1e9 / cycle)
+	)
+	sm.TryClaim() // SM should be claimed beforehand, we just guarantee it's claimed.
+	cpufreq := machine.CPUFrequency()
+	// whole, frac, err := pio.ClkDivFromPeriod(period, cpufreq)
+	whole, frac, err := pio.ClkDivFromFrequency(freq, cpufreq)
+	if err != nil {
+		return nil, err
+	}
+	// We add the program to PIO memory and store it's offset.
+	Pio := sm.PIO()
+	offset, err := Pio.AddProgram(ws2812b_ledInstructions, ws2812b_ledOrigin)
+	if err != nil {
+		return nil, err
+	}
+	pin.Configure(machine.PinConfig{Mode: Pio.PinMode()})
+	sm.SetPindirsConsecutive(pin, 1, true)
+	cfg := ws2812b_ledProgramDefaultConfig(offset)
+	cfg.SetSetPins(pin, 1)
+	// We only use Tx FIFO, so we set the join to Tx.
+	cfg.SetFIFOJoin(pio.FifoJoinTx)
+	cfg.SetClkDivIntFrac(whole, frac)
+	cfg.SetOutShift(false, true, 24)
+	sm.Init(offset, cfg)
+	sm.SetEnabled(true)
+	dev := &WS2812B{sm: sm, offset: offset}
+	return dev, nil
+}
+
+// PutRGB puts a RGB color in the transmit queue. If Queue if full will be discarded.
+func (ws *WS2812B) PutRGB(r, g, b uint8) {
+	// Shift occurs to left for WS2812B to interpret correctly.
+	color := uint32(g)<<24 | uint32(r)<<16 | uint32(b)<<8
+	ws.PutRaw(color)
+}
+
+// PutRaw puts a raw color value in the PIO state machine queue. The grb uint32 is a WS2812B color
+// which can be created with 3 uint8 color values:
+//
+//	color := uint32(green)<<24 | uint32(red)<<16 | uint32(blue)<<8
+func (ws *WS2812B) PutRaw(grb uint32) {
+	ws.sm.TxPut(grb)
+}
+
+// IsQueueFull returns true if the PIO Tx FIFO has 8 elements and will discard next call to PutRaw, PutRGB or PutColor.
+func (ws *WS2812B) IsQueueFull() bool {
+	return ws.sm.IsTxFIFOFull()
+}
+
+// PutColor wraps PutRGB for a [color.Color] type.
+func (ws *WS2812B) PutColor(c color.Color) {
+	r16, g16, b16, _ := c.RGBA()
+	ws.PutRGB(uint8(r16>>8), uint8(g16>>8), uint8(b16>>8))
+}
+
+// WriteRaw writes raw GRB values to a strip of WS2812B LEDs. Each uint32 is a WS2812B color
+// which can be created with 3 uint8 color values::
+//
+//	color := uint32(g)<<24 | uint32(r)<<16 | uint32(b)<<8
+func (ws *WS2812B) WriteRaw(rawGRB []uint32) error {
+	if ws.IsDMAEnabled() {
+		return ws.writeDMA(rawGRB)
+	}
+	dl := ws.dma.dl.newDeadline()
+	i := 0
+	for i < len(rawGRB) {
+		if ws.IsQueueFull() {
+			if dl.expired() {
+				return errTimeout
+			}
+			gosched()
+			continue
+		}
+		ws.sm.TxPut(rawGRB[i])
+		i++
+	}
+	return nil
+}
+
+// EnableDMA enables DMA for vectorized writes.
+func (ws *WS2812B) EnableDMA(enabled bool) error {
+	dmaAlreadyEnabled := ws.IsDMAEnabled()
+	if !enabled || dmaAlreadyEnabled {
+		if !enabled && dmaAlreadyEnabled {
+			ws.dma.Unclaim()
+			ws.dma = dmaChannel{} // Invalidate DMA channel.
+		}
+		return nil
+	}
+	channel, ok := _DMA.ClaimChannel()
+	if !ok {
+		return errDMAUnavail
+	}
+	channel.dl = ws.dma.dl // Copy deadline.
+	ws.dma = channel
+	return nil
+}
+
+func (ws *WS2812B) writeDMA(w []uint32) error {
+	dreq := dmaPIO_TxDREQ(ws.sm)
+	err := ws.dma.Push32(&ws.sm.TxReg().Reg, w, dreq)
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+// IsDMAEnabled returns true if DMA is enabled.
+func (ws *WS2812B) IsDMAEnabled() bool {
+	return ws.dma.IsValid()
+}

rp2-pio/piolib/ws2812b.pio

@@ -0,0 +1,44 @@
+; Timings according to Datasheet
+; 	T0H = 400ns
+; 	T0L = 850ns
+; 	T1H = 800ns
+; 	T1L = 450ns
+; Thus, a whole cycle is 1250ns. This will be our base unit of transmission.
+; Next unit of time is one that is closest to T0H and T1L. 
+; If we divide baseline by 3 we get 1250/3 = 416.67, falling between 400 and 450.
+; Since we need more than 1 instruction per high/low time, we examine cases where
+; we split the split baseline in 3 and then calculate result PIO clockdiv since 3 is minimum
+; number of instructions to do first part of high time.
+;
+; From the equations:
+;  piofreq = 256*clockfreq / (256*whole + frac)
+; where period = 1e9/freq => freq = 1e9/period, so:
+;  1e9/period = 256*clockfreq / (256*whole + frac) =>
+;  256*whole + frac = 256*clockfreq*period/1e9
+; So, the previous equations yield:
+;	416.67/3=138.89 -> ???
+
+.program ws2812b_led
+public entry_point:
+	pull ifempty block ; Do autopull, blocks if Tx empty.
+bitloop:
+	; 3 instructions high logic level
+	set pins, 1    ; Drive pin high at start of pulse.
+	out y, 1       ; Shift 1 bit out, and write it to y.
+	jmp !y lolo    ; Jump to LOW bit part.
+	jmp hilo [2]   ; Jump to 
+
+lolo:
+	set pins, 0 [2]; To create T0L we need 6 cycles, 3 of them are part of hi branch.
+hilo:
+	set pins, 0 
+	jmp !osre bitloop [1]
+
+% go {
+//go:build rp2040
+package piolib
+
+import (
+    pio "github.com/tinygo-org/pio/rp2-pio"
+)
+%}