fix ws2812 implementation

Author: soypat

go.sum

@@ -12,7 +12,7 @@ import (
 func main() {
 	const ws2812Pin = machine.GP16
 	sm, _ := pio.PIO0.ClaimStateMachine()
-	ws, err := piolib.NewWS2812(sm, ws2812Pin, 400_000)
+	ws, err := piolib.NewWS2812(sm, ws2812Pin)
 	if err != nil {
 		panic(err.Error())
 	}
@@ -26,19 +26,24 @@ func main() {
 		const longWait = 6 * time.Second
 		const shortWait = 2 * time.Second
 		// Start Stoplight in red (STOP).
+		println("red")
 		ws.SetColor(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)
 			time.Sleep(semiSleep)
 			ws.SetColor(red)
 			time.Sleep(semiSleep)
 		}
+		println("green")
 		ws.SetColor(green)
 		time.Sleep(longWait)
+
+		println("amber")
 		ws.SetColor(amber)
 		time.Sleep(shortWait)
 	}

rp2-pio/examples/ws2812/main.go

@@ -14,9 +14,51 @@ type WS2812 struct {
 	offset uint8
 }
 
-func NewWS2812(sm pio.StateMachine, pin machine.Pin, baud uint32) (*WS2812, error) {
+func NewWS2812(sm pio.StateMachine, pin machine.Pin) (*WS2812, error) {
+	// These timings are taken from the table "Updated simplified timing
+	// constraints for NeoPixel strings" at:
+	// https://wp.josh.com/2014/05/13/ws2812-neopixels-are-not-so-finicky-once-you-get-to-know-them/
+	// Here is a copy:
+	//   Symbol   Parameter                    Min   Typical    Max   Units
+	//   T0H      0 code, high voltage time    200       350    500   ns
+	//   T1H      1 code, high voltage time    550       700   5500   ns
+	//   TLD      data, low voltage time       450       600   5000   ns
+	//   TLL      latch, low voltage time     6000                    ns
+	// The equivalent table for WS2811 LEDs would be the following:
+	//   Symbol   Parameter                    Min   Typical    Max   Units
+	//   T0H      0 code, high voltage time    350       500    650   ns
+	//   T1H      1 code, high voltage time   1050      1200   5500   ns
+	//   TLD      data, low voltage time      1150      1300   5000   ns
+	//   TLL      latch, low voltage time     6000                    ns
+	// Combining the two (min and max) leads to the following table:
+	//   Symbol   Parameter                    Min   Typical    Max   Units
+	//   T0H      0 code, high voltage time    350         -    500   ns
+	//   T1H      1 code, high voltage time   1050         -   5500   ns
+	//   TLD      data, low voltage time      1150         -   5000   ns
+	//   TLL      latch, low voltage time     6000                    ns
+	// These comined timings are used so that the ws2812 package is compatible
+	// with both WS2812 and with WS2811 chips.
+	// T0H is the time the pin should be high to send a "0" bit.
+	// T1H is the time the pin should be high to send a "1" bit.
+	// TLD is the time the pin should be low between bits.
+	// TLL is the time the pin should be low to apply (latch) the new colors.
+	//
+	// These constants are for the most part not used but serve as
+	// a notebook of documentation. When in a IDE such as VSCode one
+	// can mouse over constants to observe their value.
+	const (
+		t0h        = 352 // augment it slightly to compensate for PIO clock instability.
+		t0h_cycles = 3   // Taken from PIO program by observing instructions used.
+		freq       = 1_000_000_000 * t0h_cycles / t0h
+		t1h_t0     = 1050. / t0h         // =3
+		tld_t0     = 1150. / t0h         // ~3.8
+		tll_t0     = 6000. / t0h         // ~18
+		t1h_cycles = t1h_t0 * t0h_cycles // =9
+		tld_cycles = tld_t0 * t0h_cycles // ~9.8
+		tll_cycles = tll_t0 * t0h_cycles // ~51.42
+	)
 	sm.TryClaim() // SM should be claimed beforehand, we just guarantee it's claimed.
-	whole, frac, err := pio.ClkDivFromFrequency(baud, machine.CPUFrequency())
+	whole, frac, err := pio.ClkDivFromFrequency(freq, machine.CPUFrequency())
 	if err != nil {
 		return nil, err
 	}
@@ -40,8 +82,9 @@ func NewWS2812(sm pio.StateMachine, pin machine.Pin, baud uint32) (*WS2812, erro
 }
 
 func (ws *WS2812) SetRGB(r, g, b uint8) {
-	color := uint32(r)<<16 | uint32(g)<<8 | uint32(b)
-	println("r", r, "g", g, "b", b)
+	// Has little endian encoding over wire, last bits are most significant.
+	// So green comes first, followed by red and lastly blue.
+	color := uint32(g) | uint32(r)<<8 | uint32(b)<<16
 	ws.sm.TxPut(color)
 }
 

rp2-pio/piolib/ws2812.go

@@ -4,17 +4,26 @@ public entry_point:
 	pull
 	set x, 23 ; Loop over 24 bits
 
+; In bitloop we have 3 unavoidable instructions during high cycle
+; This means 3 cycles == t0h, we then use t0h as a multiple 
+; to reach all other timings.
+; t1h is 3*t0h, so 9 PIO cycles.
 bitloop:
-	set pins, 1 ; Drive pin high
-	out y, 1 [5] ; Shift 1 bit out, and write it to y
-	jmp !y skip ; Skip the extra delay if the bit was 0
-	nop [5]
+	set pins, 1  ; Drive pin high
+	out y, 1 ; Shift 1 bit out, and write it to y
+	jmp !y skip  ; Skip the extra delay if the bit was 0
+	nop [5]      ; Here we finish t1h with 6 cycles reaching 9 total.
 
+; tld is 3.28571*t0h, so approximately 10 PIO cycles.
+; tll is 17.14*t0h, so approx 52 cycles.
 skip:
-	set pins, 0 [5]
+	set pins, 0 [9] 
 	jmp x-- bitloop ; Jump if x nonzero, and decrement x
+	nop [31] ; +32, need to still add 52-32
+	nop [19] ; +20, 52 cycles reached so color should be latched.
 	jmp entry_point
 
+
 % go {
 //go:build rp2040
 package piolib