stm32f3 discovery + ws2812b: only 8 first leds light up

[snaumov]

hey! Thank you for the library! I"m having some troubles, and will appreciate some piece of advice:

SCU: STM32F3Discovery
Leds: BTF-lighting ws2812b leds strip Amazon

Code:

#![no_main]
#![no_std]

use panic_semihosting as _;

use cortex_m;
use cortex_m_rt::entry;
use hal::{
    gpio::gpioc,
    pac,
    prelude::*,
    spi::{config::Config, Spi},
};
use stm32f3xx_hal as hal;

use smart_leds::SmartLedsWrite;
use smart_leds_trait::{RGB8, RGBA};
use ws2812::Ws2812;
use ws2812_spi as ws2812;


#[entry]
fn main() -> ! {
    let dp = pac::Peripherals::take().unwrap();
    let cp = cortex_m::Peripherals::take().unwrap();
    let mut flash = dp.FLASH.constrain();
    let mut rcc = dp.RCC.constrain();
    let gpiob = dp.GPIOB.split(&mut rcc.ahb);
    let mut gpioc = dp.GPIOC.split(&mut rcc.ahb);

    // Set up the system clock. We want to run at 48MHz for this one.
    let clocks = rcc.cfgr.sysclk(48.MHz()).pclk1(24.MHz()).freeze(&mut flash.acr);

    // Configure pins for SPI
    let sck = gpioc
        .pc10
        .into_af6_push_pull(&mut gpioc.moder, &mut gpioc.otyper, &mut gpioc.afrh);
    let miso = gpioc
        .pc11
        .into_af6_push_pull(&mut gpioc.moder, &mut gpioc.otyper, &mut gpioc.afrh);
    let mosi = gpioc
        .pc12
        .into_af6_push_pull(&mut gpioc.moder, &mut gpioc.otyper, &mut gpioc.afrh);

    // let mut spi = Spi::new(dp.SPI3, (sck, miso, mosi), 3.MHz(), clocks, &mut rcc.apb1);
    let mut spi_config = Config::default().frequency(3.MHz()).mode(ws2812::MODE);
    let mut spi = Spi::new(
        dp.SPI3,
        (sck, miso, mosi),
        spi_config,
        clocks,
        &mut rcc.apb1,
    );
    // Create a delay abstraction based on SysTick
    let mut delay = hal::delay::Delay::new(cp.SYST, clocks);

    let mut data: [RGB8; 50] = [RGB8 {
        r: 0x23,
        g: 0x24,
        b: 0x09,
    }; 50];
    let empty: [RGB8; 50] = [RGB8::default(); 50];
    let mut ws = Ws2812::new(spi);
    ws.write(data.iter().cloned()).unwrap();
    loop {
        ws.write(data.iter().cloned()).unwrap();
        delay.delay_ms(1000 as u16);
        ws.write(empty.iter().cloned()).unwrap();
        delay.delay_ms(1000 as u16);
    }
}

WIth the code above I can get only 8 first leds to light up.

Things I tried so far:

• Builded with --release flag
• use prerendered
• use external 5v power adapter instead USB.
• Checked the data line with multimeter (I'm pretty new to embedded, so this is as far I can go with the hardware checks yet)

I would appreciate any suggestion or pointers on what could be wrong or how to troubleshoot this further.

[david-sawatzke]

That does sound weird. Do you have a logic analyzer like the fx2la to capture the output signal traces?

Does it work with other ws2812 drivers?

[snaumov]

Do you have a logic analyzer like the fx2la to capture the output signal traces?

Just ordered one today, will try to capture some data.

Does it work with other ws2812 drivers?

haven't tried any other yet. Do you know of any other drivers, brief googling shows me only this pretty much?

[david-sawatzke]

Hmm, I'd have thought there were others in C, but I also didn't have much success with my google searches.

You may want to try ws2812-timer-delay-rs.

[snaumov]

no luck with timer-based driver yet, the LEDs won't light up at all. I didn't invest too much time into this driver and moved onto a logic analyzer though

[snaumov]

here's a logic analyzer output. I'm going to dive into a ws2812b datasheet to make sense of it, but I'd appreciate it if you can have a quick peek as well

I also updated the code a bit, if it helps

fn main() -> ! {
    let dp = pac::Peripherals::take().unwrap();
    let cp = cortex_m::Peripherals::take().unwrap();
    let mut flash = dp.FLASH.constrain();
    let mut rcc = dp.RCC.constrain();
    let mut gpioc = dp.GPIOC.split(&mut rcc.ahb);

    // Set up the system clock. We want to run at 48MHz for this one.
    // let clocks = rcc.cfgr.sysclk(48.MHz()).pclk1(3.MHz()).freeze(&mut flash.acr);
    let clocks = rcc.cfgr.sysclk(48.MHz()).freeze(&mut flash.acr);

    // Configure pins for SPI
    let sck = gpioc
        .pc10
        .into_af6_push_pull(&mut gpioc.moder, &mut gpioc.otyper, &mut gpioc.afrh);
    let miso = gpioc
        .pc11
        .into_af6_push_pull(&mut gpioc.moder, &mut gpioc.otyper, &mut gpioc.afrh);
    let mosi = gpioc
        .pc12
        .into_af6_push_pull(&mut gpioc.moder, &mut gpioc.otyper, &mut gpioc.afrh);

    let mut spi_config = Config::default().frequency(3.MHz()).mode(ws2812::MODE);
    let mut spi = Spi::new(
        dp.SPI3,
        (sck, miso, mosi),
        spi_config,
        clocks,
        &mut rcc.apb1,
    );
    // Create a delay abstraction based on SysTick
    let mut delay = hal::delay::Delay::new(cp.SYST, clocks);

    let mut data_red: [RGB8; 20] = [RGB8 {
        r: 0xff,
        g: 0x00,
        b: 0x00,
    }; 20];
    let mut data_green: [RGB8; 20] = [RGB8 {
        r: 0x00,
        g: 0xff,
        b: 0x00,
    }; 20];
    let mut data_blue: [RGB8; 20] = [RGB8 {
        r: 0x00,
        g: 0x00,
        b: 0xff,
    }; 20];
    let empty: [RGB8; 20] = [RGB8::default(); 20];
    let mut ws = Ws2812::new(spi);
    loop {
        ws.write(data_red.iter().cloned()).unwrap();
        delay.delay_ms(200 as u16);
        ws.write(data_green.iter().cloned()).unwrap();
        delay.delay_ms(200 as u16);
        ws.write(data_blue.iter().cloned()).unwrap();
        delay.delay_ms(200 as u16);
    }
}

ws2812.zip

[david-sawatzke]

The code still seems reasonable. You captured the logic analyzer output at 1MHz afaict, the signal is much faster so I'd recommend 24MHz.

[snaumov]

thanks for taking a look! here's 24mhz capture:

24mhz.zip

[snaumov]

mosi line output makes very little sense to me, the timings seem way off from the expected 🤔 With the code above it should be (8 1's followed by 16 0's) x 20 times

[david-sawatzke]

Yeah, the whole think looks weird. The SCK should be a continuous 3 MHz, but it's ... not.

Maybe some interference in the signal?

I don't know what the default is, but increasing the slew rate may help.