writePixels()

template<uint8_t DATA_PIN, uint8_t CLOCK_PIN, uint32_t SPI_SPEED>

template<uint8_t FLAGS, class D, EOrder RGB_ORDER>

void AVRSoftwareSPIOutput< DATA_PIN, CLOCK_PIN, SPI_SPEED >::writePixels ( PixelController< RGB_ORDER > pixels, void * context = NULL )

inline

Write LED pixel data to the SPI interface.

Data is written in groups of three, re-ordered per the RGB_ORDER.

Template Parameters

FLAGS	Option flags, such as FLAG_START_BIT
D	Per-byte modifier class, e.g. DATA_NOP
RGB_ORDER	the rgb ordering for the LED data (e.g. what order red, green, and blue data is written out in)

Parameters

pixels

a PixelController with the LED data and modifier options

Definition at line 352 of file fastspi_bitbang.h.

                                                                                                                                                             {
        FASTLED_UNUSED(context);
        select();
        int len = pixels.mLen;
 
#ifdef FAST_SPI_INTERRUPTS_WRITE_PINS
        // If interrupts or other things may be generating output while we're working on things, then we need
        // to use this block
        while(pixels.has(1)) {
            if(FLAGS & FLAG_START_BIT) {
                writeBit<0>(1);
            }
            writeByte(D::adjust(pixels.loadAndScale0()));
            writeByte(D::adjust(pixels.loadAndScale1()));
            writeByte(D::adjust(pixels.loadAndScale2()));
            pixels.advanceData();
            pixels.stepDithering();
        }
#else
        // If we can guaruntee that no one else will be writing data while we are running (namely, changing the values of the PORT/PDOR pins)
        // then we can use a bunch of optimizations in here
        FASTLED_REGISTER data_ptr_t datapin = FastPin<DATA_PIN>::port();
 
        if(FastPin<DATA_PIN>::port() != FastPin<CLOCK_PIN>::port()) {
            FASTLED_REGISTER clock_ptr_t clockpin = FastPin<CLOCK_PIN>::port();
            // If data and clock are on different ports, then writing a bit will consist of writing the value foor
            // the bit (hi or low) to the data pin port, and then two writes to the clock port to strobe the clock line
            FASTLED_REGISTER data_t datahi = FastPin<DATA_PIN>::hival();
            FASTLED_REGISTER data_t datalo = FastPin<DATA_PIN>::loval();
            FASTLED_REGISTER clock_t clockhi = FastPin<CLOCK_PIN>::hival();
            FASTLED_REGISTER clock_t clocklo = FastPin<CLOCK_PIN>::loval();
 
            while(pixels.has(1)) {
                if(FLAGS & FLAG_START_BIT) {
                    writeBit<0>(1, clockpin, datapin, datahi, datalo, clockhi, clocklo);
                }
                writeByte(D::adjust(pixels.loadAndScale0()), clockpin, datapin, datahi, datalo, clockhi, clocklo);
                writeByte(D::adjust(pixels.loadAndScale1()), clockpin, datapin, datahi, datalo, clockhi, clocklo);
                writeByte(D::adjust(pixels.loadAndScale2()), clockpin, datapin, datahi, datalo, clockhi, clocklo);
                pixels.advanceData();
                pixels.stepDithering();
            }
 
        } else {
            // If data and clock are on the same port then we can combine setting the data and clock pins
            FASTLED_REGISTER data_t datahi_clockhi = FastPin<DATA_PIN>::hival() | FastPin<CLOCK_PIN>::mask();
            FASTLED_REGISTER data_t datalo_clockhi = FastPin<DATA_PIN>::loval() | FastPin<CLOCK_PIN>::mask();
            FASTLED_REGISTER data_t datahi_clocklo = FastPin<DATA_PIN>::hival() & ~FastPin<CLOCK_PIN>::mask();
            FASTLED_REGISTER data_t datalo_clocklo = FastPin<DATA_PIN>::loval() & ~FastPin<CLOCK_PIN>::mask();
 
            while(pixels.has(1)) {
                if(FLAGS & FLAG_START_BIT) {
                    writeBit<0>(1, datapin, datahi_clockhi, datalo_clockhi, datahi_clocklo, datalo_clocklo);
                }
                writeByte(D::adjust(pixels.loadAndScale0()), datapin, datahi_clockhi, datalo_clockhi, datahi_clocklo, datalo_clocklo);
                writeByte(D::adjust(pixels.loadAndScale1()), datapin, datahi_clockhi, datalo_clockhi, datahi_clocklo, datalo_clocklo);
                writeByte(D::adjust(pixels.loadAndScale2()), datapin, datahi_clockhi, datalo_clockhi, datahi_clocklo, datalo_clocklo);
                pixels.advanceData();
                pixels.stepDithering();
            }
        }
#endif
        D::postBlock(len);
        release();
    }

References PixelController< RGB_ORDER, LANES, MASK >::advanceData(), FASTLED_REGISTER, FASTLED_UNUSED, FLAG_START_BIT, PixelController< RGB_ORDER, LANES, MASK >::has(), FastPin< PIN >::hival(), PixelController< RGB_ORDER, LANES, MASK >::loadAndScale0(), PixelController< RGB_ORDER, LANES, MASK >::loadAndScale1(), PixelController< RGB_ORDER, LANES, MASK >::loadAndScale2(), FastPin< PIN >::loval(), FastPin< PIN >::mask(), PixelController< RGB_ORDER, LANES, MASK >::mLen, FastPin< PIN >::port(), release(), select(), PixelController< RGB_ORDER, LANES, MASK >::stepDithering(), writeBit(), and writeByte().

Here is the call graph for this function: