diff options
author | Sam Guyer <sam.guyer@gmail.com> | 2021-07-18 19:51:52 +0300 |
---|---|---|
committer | Sam Guyer <sam.guyer@gmail.com> | 2021-07-18 19:51:52 +0300 |
commit | ab74c7a5b6d0006f09f9b290bc37fb44d1958754 (patch) | |
tree | 684291df13af6aa9bd5eb9234bc8c61df2b03d01 | |
parent | e5921775c64c2eb3428e70f9f39ebd7d76f51b5e (diff) | |
parent | b45cc8cf654402fbef342922919636ae62432cd4 (diff) |
Merge branch 'ntwallace-master'
Merging code from ntwallace to support hardware SPI on ESP32
-rw-r--r-- | src/fastspi.h | 7 | ||||
-rwxr-xr-x[-rw-r--r--] | src/platforms/esp/32/fastled_esp32.h | 4 | ||||
-rw-r--r-- | src/platforms/esp/32/fastspi_esp32.h | 168 |
3 files changed, 178 insertions, 1 deletions
diff --git a/src/fastspi.h b/src/fastspi.h index aeb2ad01..ae084f84 100644 --- a/src/fastspi.h +++ b/src/fastspi.h @@ -13,7 +13,7 @@ FASTLED_NAMESPACE_BEGIN #if defined(FASTLED_TEENSY3) && (F_CPU > 48000000) #define DATA_RATE_MHZ(X) (((48000000L / 1000000L) / X)) #define DATA_RATE_KHZ(X) (((48000000L / 1000L) / X)) -#elif defined(FASTLED_TEENSY4) // && (ARM_HARDWARE_SPI) +#elif defined(FASTLED_TEENSY4) || (defined(ESP32) && defined(FASTLED_ALL_PINS_HARDWARE_SPI)) // just use clocks #define DATA_RATE_MHZ(X) (1000000 * (X)) #define DATA_RATE_KHZ(X) (1000 * (X)) @@ -54,6 +54,11 @@ template<uint8_t _DATA_PIN, uint8_t _CLOCK_PIN, uint32_t _SPI_CLOCK_DIVIDER> class SPIOutput : public APOLLO3HardwareSPIOutput<_DATA_PIN, _CLOCK_PIN, _SPI_CLOCK_DIVIDER> {}; #endif +#if defined(ESP32) && defined(FASTLED_ALL_PINS_HARDWARE_SPI) +template<uint8_t _DATA_PIN, uint8_t _CLOCK_PIN, uint32_t _SPI_CLOCK_DIVIDER> +class SPIOutput : public ESP32SPIOutput<_DATA_PIN, _CLOCK_PIN, _SPI_CLOCK_DIVIDER> {}; +#endif + #if defined(SPI_DATA) && defined(SPI_CLOCK) #if defined(FASTLED_TEENSY3) && defined(ARM_HARDWARE_SPI) diff --git a/src/platforms/esp/32/fastled_esp32.h b/src/platforms/esp/32/fastled_esp32.h index edf27e7d..6e9a1c59 100644..100755 --- a/src/platforms/esp/32/fastled_esp32.h +++ b/src/platforms/esp/32/fastled_esp32.h @@ -2,6 +2,10 @@ #include "fastpin_esp32.h" +#ifdef FASTLED_ALL_PINS_HARDWARE_SPI +#include "fastspi_esp32.h" +#endif + #ifdef FASTLED_ESP32_I2S #include "clockless_i2s_esp32.h" #else diff --git a/src/platforms/esp/32/fastspi_esp32.h b/src/platforms/esp/32/fastspi_esp32.h new file mode 100644 index 00000000..33d620fd --- /dev/null +++ b/src/platforms/esp/32/fastspi_esp32.h @@ -0,0 +1,168 @@ +#pragma once +#pragma message "ESP32 Hardware SPI support added" + +FASTLED_NAMESPACE_BEGIN + +/* + * ESP32 Hardware SPI Driver + * + * Copyright (c) 2020 Nick Wallace + * Derived from code for ESP8266 hardware SPI by Benoit Anastay. + * + * This hardware SPI implementation can drive clocked LEDs from either the + * VSPI or HSPI bus (aka SPI2 & SPI3). No support is provided for SPI1, because it is + * shared among devices and the cache for data (code) in the Flash as well as the PSRAM. + * + * To enable the hardware SPI driver, add the following line *before* including + * FastLED.h: + * + * #define FASTLED_ALL_PINS_HARDWARE_SPI + * + * This driver uses the VSPI bus by default (GPIO 18, 19, 23, & 5). To use the + * HSPI bus (GPIO 14, 12, 13, & 15) add the following line *before* including + * FastLED.h: + * + * #define FASTLED_ESP32_SPI_BUS HSPI + * + */ +/* + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + */ + +#ifndef FASTLED_ESP32_SPI_BUS + #define FASTLED_ESP32_SPI_BUS VSPI +#endif + +SPIClass ledSPI(FASTLED_ESP32_SPI_BUS); + +#if FASTLED_ESP32_SPI_BUS == VSPI + static uint8_t spiClk = 18; + static uint8_t spiMiso = 19; + static uint8_t spiMosi = 23; + static uint8_t spiCs = 5; +#elif FASTLED_ESP32_SPI_BUS == HSPI + static uint8_t spiClk = 14; + static uint8_t spiMiso = 12; + static uint8_t spiMosi = 13; + static uint8_t spiCs = 15; +#endif + +template <uint8_t DATA_PIN, uint8_t CLOCK_PIN, uint32_t SPI_SPEED> +class ESP32SPIOutput { + Selectable *m_pSelect; + +public: + ESP32SPIOutput() { m_pSelect = NULL; } + ESP32SPIOutput(Selectable *pSelect) { m_pSelect = pSelect; } + void setSelect(Selectable *pSelect) { m_pSelect = pSelect; } + + void init() { + // set the pins to output and make sure the select is released (which apparently means hi? This is a bit + // confusing to me) + ledSPI.begin(spiClk, spiMiso, spiMosi, spiCs); + release(); + } + + // stop the SPI output. Pretty much a NOP with software, as there's no registers to kick + static void stop() { } + + // wait until the SPI subsystem is ready for more data to write. A NOP when bitbanging + static void wait() __attribute__((always_inline)) { } + static void waitFully() __attribute__((always_inline)) { wait(); } + + static void writeByteNoWait(uint8_t b) __attribute__((always_inline)) { writeByte(b); } + static void writeBytePostWait(uint8_t b) __attribute__((always_inline)) { writeByte(b); wait(); } + + static void writeWord(uint16_t w) __attribute__((always_inline)) { writeByte(w>>8); writeByte(w&0xFF); } + + // naive writeByte implelentation, simply calls writeBit on the 8 bits in the byte. + static void writeByte(uint8_t b) { + ledSPI.transfer(b); + } + +public: + + // select the SPI output (TODO: research whether this really means hi or lo. Alt TODO: move select responsibility out of the SPI classes + // entirely, make it up to the caller to remember to lock/select the line?) + void select() { + ledSPI.beginTransaction(SPISettings(SPI_SPEED, MSBFIRST, SPI_MODE0)); + if(m_pSelect != NULL) { m_pSelect->select(); } + } + + // release the SPI line + void release() { + if(m_pSelect != NULL) { m_pSelect->release(); } + ledSPI.endTransaction(); + } + + // Write out len bytes of the given value out over ledSPI. Useful for quickly flushing, say, a line of 0's down the line. + void writeBytesValue(uint8_t value, int len) { + select(); + writeBytesValueRaw(value, len); + release(); + } + + static void writeBytesValueRaw(uint8_t value, int len) { + while(len--) { + ledSPI.transfer(value); + } + } + + // write a block of len uint8_ts out. Need to type this better so that explicit casts into the call aren't required. + // note that this template version takes a class parameter for a per-byte modifier to the data. + template <class D> void writeBytes(register uint8_t *data, int len) { + select(); + uint8_t *end = data + len; + while(data != end) { + writeByte(D::adjust(*data++)); + } + D::postBlock(len); + release(); + } + + // default version of writing a block of data out to the SPI port, with no data modifications being made + void writeBytes(register uint8_t *data, int len) { writeBytes<DATA_NOP>(data, len); } + + // write a single bit out, which bit from the passed in byte is determined by template parameter + template <uint8_t BIT> inline void writeBit(uint8_t b) { + ledSPI.transfer(b); + } + + // write a block of uint8_ts out in groups of three. len is the total number of uint8_ts to write out. The template + // parameters indicate how many uint8_ts to skip at the beginning of each grouping, as well as a class specifying a per + // byte of data modification to be made. (See DATA_NOP above) + template <uint8_t FLAGS, class D, EOrder RGB_ORDER> __attribute__((noinline)) void writePixels(PixelController<RGB_ORDER> pixels) { + select(); + int len = pixels.mLen; + 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(); + } + D::postBlock(len); + release(); + } +}; + +FASTLED_NAMESPACE_END
\ No newline at end of file |