WS2812B LED support?

Chipsa82

Hi

im thinking of using the WS2812B individually addressable LEDs in my printer for both lighting the printbed as well as signalizing individual printer states by chaning color (running, error…)

Is there a way to address the data pin on these leds from Duet?

thanks!

Chipsa

dc42

Those LEDs don't use a standard protocol, and are currently not supported in firmware.

fma

It is possible to drive them from a SPI bus. Here is an example in micropython:

[[python]]
# -*- coding: utf-8 -*-

import gc
import pyb

class WS2812:
    """ Driver for WS2812 RGB LEDs. May be used for controlling single LED or chain  of LEDs.
    """
    buf_bytes = (0x11, 0x13, 0x31, 0x33)

    def __init__(self, spi_bus=1, led_count=1, intensity=1):
        """
        """
        self.led_count = led_count
        self.intensity = intensity
        self.disable_irq = True

        # prepare SPI data buffer (4 bytes for each color)
        self.buf_length = self.led_count * 3 * 4
        self.buf = bytearray(self.buf_length)

        # SPI init
        self.spi = pyb.SPI(spi_bus, pyb.SPI.MASTER, baudrate=3200000, polarity=0, phase=1)

        # turn LEDs off
        self.show([])

    def show(self, data):
        """ Show RGB data on LEDs.

        Expected data = [(R, G, B), ...] where R, G and B are intensities of colors in range from 0 to 255.
        One RGB tuple for each LED.
        Count of tuples may be less than count of connected LEDs.
        """
        self.fill_buf(data)
        self.send_buf()

    def send_buf(self):
        """ Send buffer over SPI.
        """
        if self.disable_irq:
            pyb.disable_irq()
            self.spi.send(self.buf)
            pyb.enable_irq()
        else:
            self.spi.send(self.buf)
        gc.collect()

    def fill_buf(self, data):
        """ Fill buffer with bytes.
        """
        i = 0
        for byte in self.data_to_bytes(data):
            self.buf[i] = byte
            i += 1

        # turn off the rest of the LEDs
        while i < self.buf_length:
            self.buf[i] = self.buf_bytes[0]
            i += 1

    def data_to_bytes(self, data):
        """ Convert data to bytes.

        Note: Order of colors is changed from RGB to GRB because WS2812 LED has GRB order of colors.
        """
        for red, green, blue in data:
            for byte in self.color_to_bytes(green):
                yield byte
            for byte in self.color_to_bytes(red):
                yield byte
            for byte in self.color_to_bytes(blue):
                yield byte

    def color_to_bytes(self, color):
        """ Yields 4 buffer bytes representing color value (1 byte for each 2 bits).
        """
        color = int(color * self.intensity)
        for i in range(4):
            yield self.buf_bytes[(color & 0xC0) >> 6]
            color <<= 2

def main():
    ring = WS2812(spi_bus=1, led_count=16)

    data = [
        (24, 0, 0),
        (0, 24, 0),
        (0, 0, 24),
        (12, 12, 0),
        (0, 12, 12),
        (12, 0, 12),
        (24, 0, 0),
        (21, 3, 0),
        (18, 6, 0),
        (15, 9, 0),
        (12, 12, 0),
        (9, 15, 0),
        (6, 18, 0),
        (3, 21, 0),
        (0, 24, 0),
        (8, 8, 8),
    ]

    ring.show(data)

if __name__ == "__main__":
    main()
[/i][/i]

T3P3Tony

As in the oled thread, the easiest approach would be to use a little Arduino or equivalent to switch between the display chip and the Duet.