Stm32SpiPixelStrip.hxx

Go to the documentation of this file.

 
#ifndef _FREERTOS_DRIVERS_ST_STM32PIXELSTRIP_HXX_
#define _FREERTOS_DRIVERS_ST_STM32PIXELSTRIP_HXX_
 
#include <cstdint>
 
 
#include "stm32f_hal_conf.hxx"
 
#include "stm32g0xx_ll_spi.h"
 
class Stm32SpiPixelStrip
{
public:
    Stm32SpiPixelStrip(
        SPI_TypeDef *spi, unsigned num_pixels, uint8_t *backing_data)
        : spi_(spi)
        , numPixels_(num_pixels)
        , data_(backing_data)
    {
        memset(&spiHandle_, 0, sizeof(spiHandle_));
    }
 
    void hw_init(uint32_t spi_prescaler)
    {
        // Deinit if needed.
        if (spiHandle_.State != HAL_SPI_STATE_RESET)
        {
            HAL_SPI_DeInit(&spiHandle_);
        }
        spiHandle_.Instance = spi_;
        
        spiHandle_.Init.BaudRatePrescaler = spi_prescaler;
        spiHandle_.Init.Direction = SPI_DIRECTION_1LINE;
        spiHandle_.Init.CLKPolarity = SPI_POLARITY_LOW;
        spiHandle_.Init.CLKPhase = SPI_PHASE_2EDGE;
        spiHandle_.Init.DataSize = SPI_DATASIZE_15BIT;
        spiHandle_.Init.FirstBit = SPI_FIRSTBIT_LSB;
        spiHandle_.Init.NSS = SPI_NSS_SOFT;
        spiHandle_.Init.TIMode = SPI_TIMODE_DISABLE;
        spiHandle_.Init.NSSPMode = SPI_NSS_PULSE_DISABLE;
        spiHandle_.Init.CRCCalculation = SPI_CRCCALCULATION_DISABLE;
        spiHandle_.Init.CRCPolynomial = 7;
        spiHandle_.Init.CRCLength = SPI_CRC_LENGTH_8BIT;
        spiHandle_.Init.Mode = SPI_MODE_MASTER;
        HASSERT(HAL_SPI_Init(&spiHandle_) == HAL_OK);
        LL_SPI_SetTransferDirection(spi_, LL_SPI_HALF_DUPLEX_TX);
    }
 
    void update_sync()
    {
        LL_SPI_Enable(spi_);
        clear_iteration();
        portENTER_CRITICAL();
        while (!eof())
        {
            uint16_t next_word = 0;
            uint16_t ofs = 1u;
            // Computes 16 SPI bits with 5 pulses.
            while (!eof() && ofs < (1u << 13))
            {
                // Appends an 110 or 100 depending opn what the next bit should
                // be.
                next_word |= ofs;
                ofs <<= 1;
                if (next_bit())
                    next_word |= ofs;
                ofs <<= 2;
            }
            // We leave an extra bit as zero at the end of the word. We hope
            // that this will not confuse the pixel. They care mostly about the
            // length of the HIGH pulse.
 
            // Waits for space in tx buffer.
            while (!LL_SPI_IsActiveFlag_TXE(spi_)) { }
            LL_SPI_TransmitData16(spi_, next_word ^ 0xffff);
            // Note that there is no wait here for the transfer to complete.
            // This is super important, because we want to be computing the
            // next word while the previous word is emitted by SPI.
        }
        // The last bit output is a zero, and leaving the line there is
        // reasonable, because it matches the latch level.
        portEXIT_CRITICAL();
    }
 
private:
    void clear_iteration()
    {
        currentByte_ = 0;
        nextBit_ = 0x80;
    }
    bool next_bit()
    {
        bool ret = data_[currentByte_] & nextBit_;
        nextBit_ >>= 1;
        if (!nextBit_)
        {
            nextBit_ = 0x80;
            currentByte_++;
        }
        return ret;
    }
    bool eof()
    {
        return currentByte_ >= numPixels_ * 3;
    }
 
    SPI_TypeDef *spi_;
    SPI_HandleTypeDef spiHandle_;
    unsigned numPixels_;
    uint8_t *data_;
 
    unsigned currentByte_;
    uint8_t nextBit_;
};
 
#endif // _FREERTOS_DRIVERS_ST_STM32PIXELSTRIP_HXX_