src/main/drivers/light_ws2811strip.c

   1 /*
   2  * This file is part of Cleanflight and Betaflight.
   3  *
   4  * Cleanflight and Betaflight are free software. You can redistribute
   5  * this software and/or modify this software under the terms of the
   6  * GNU General Public License as published by the Free Software
   7  * Foundation, either version 3 of the License, or (at your option)
   8  * any later version.
   9  *
  10  * Cleanflight and Betaflight are distributed in the hope that they
  11  * will be useful, but WITHOUT ANY WARRANTY; without even the implied
  12  * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  13  * See the GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this software.
  17  *
  18  * If not, see <http://www.gnu.org/licenses/>.
  19  */
  20
  21 /*
  22  * "Note that the timing on the WS2812/WS2812B LEDs has changed as of batches from WorldSemi
  23  * manufactured made in October 2013, and timing tolerance for approx 10-30% of parts is very small.
  24  * Recommendation from WorldSemi is now: 0 = 400ns high/850ns low, and 1 = 850ns high, 400ns low"
  25  *
  26  * Currently the timings are 0 = 350ns high/800ns and 1 = 700ns high/650ns low.
  27  */
  28
  29 #include <stdbool.h>
  30 #include <stdint.h>
  31 #include <string.h>
  32
  33 #include "platform.h"
  34 #include "common/maths.h"
  35
  36 #ifdef USE_LED_STRIP
  37
  38 #include "build/build_config.h"
  39
  40 #include "common/color.h"
  41 #include "common/colorconversion.h"
  42
  43 #include "drivers/dma.h"
  44 #include "drivers/io.h"
  45
  46 #include "light_ws2811strip.h"
  47
  48 #include "scheduler/scheduler.h"
  49
  50 #ifdef USE_LEDSTRIP_CACHE_MGMT
  51 // WS2811_DMA_BUFFER_SIZE is multiples of uint32_t
  52 // Number of bytes required for buffer
  53 #define WS2811_DMA_BUF_BYTES              (WS2811_DMA_BUFFER_SIZE * sizeof(uint32_t))
  54 // Number of bytes required to cache align buffer
  55 #define WS2811_DMA_BUF_CACHE_ALIGN_BYTES  ((WS2811_DMA_BUF_BYTES + 0x20) & ~0x1f)
  56 // Size of array to create a cache aligned buffer
  57 #define WS2811_DMA_BUF_CACHE_ALIGN_LENGTH (WS2811_DMA_BUF_CACHE_ALIGN_BYTES / sizeof(uint32_t))
  58 DMA_RW_AXI __attribute__((aligned(32))) uint32_t ledStripDMABuffer[WS2811_DMA_BUF_CACHE_ALIGN_LENGTH];
  59 #else
  60 #if defined(STM32F7)
  61 FAST_DATA_ZERO_INIT uint32_t ledStripDMABuffer[WS2811_DMA_BUFFER_SIZE];
  62 #elif defined(STM32H7)
  63 DMA_RAM uint32_t ledStripDMABuffer[WS2811_DMA_BUFFER_SIZE];
  64 #else
  65 uint32_t ledStripDMABuffer[WS2811_DMA_BUFFER_SIZE];
  66 #endif
  67 #endif
  68
  69 static ioTag_t ledStripIoTag;
  70 static bool ws2811Initialised = false;
  71 volatile bool ws2811LedDataTransferInProgress = false;
  72 static unsigned usedLedCount = 0;
  73 static bool needsFullRefresh = true;
  74
  75 uint16_t BIT_COMPARE_1 = 0;
  76 uint16_t BIT_COMPARE_0 = 0;
  77
  78 static hsvColor_t ledColorBuffer[WS2811_DATA_BUFFER_SIZE];
  79
  80 #if !defined(USE_WS2811_SINGLE_COLOUR)
  81 void setLedHsv(uint16_t index, const hsvColor_t *color)
  82 {
  83     ledColorBuffer[index] = *color;
  84 }
  85
  86 void getLedHsv(uint16_t index, hsvColor_t *color)
  87 {
  88     *color = ledColorBuffer[index];
  89 }
  90
  91 void setLedValue(uint16_t index, const uint8_t value)
  92 {
  93     ledColorBuffer[index].v = value;
  94 }
  95
  96 void scaleLedValue(uint16_t index, const uint8_t scalePercent)
  97 {
  98     ledColorBuffer[index].v = ((uint16_t)ledColorBuffer[index].v * scalePercent / 100);
  99 }
 100 #endif
 101
 102 void setStripColor(const hsvColor_t *color)
 103 {
 104     for (unsigned index = 0; index < usedLedCount; index++) {
 105         ledColorBuffer[index] = *color;
 106     }
 107 }
 108
 109 void setStripColors(const hsvColor_t *colors)
 110 {
 111     for (unsigned index = 0; index < usedLedCount; index++) {
 112         setLedHsv(index, colors++);
 113     }
 114 }
 115
 116 void setUsedLedCount(unsigned ledCount)
 117 {
 118     usedLedCount = (ledCount < WS2811_DATA_BUFFER_SIZE) ? ledCount : WS2811_DATA_BUFFER_SIZE;
 119
 120      // Update all possible positions on the next update in case the count
 121      // decreased otherwise LEDs on the end could be left in their previous state
 122     needsFullRefresh = true;
 123 }
 124
 125 void ws2811LedStripInit(ioTag_t ioTag)
 126 {
 127     memset(ledStripDMABuffer, 0, sizeof(ledStripDMABuffer));
 128
 129     ledStripIoTag = ioTag;
 130 }
 131
 132 void ws2811LedStripEnable(void)
 133 {
 134     if (!ws2811Initialised) {
 135         if (!ws2811LedStripHardwareInit(ledStripIoTag)) {
 136             return;
 137         }
 138
 139         const hsvColor_t hsv_black = { 0, 0, 0 };
 140         setStripColor(&hsv_black);
 141         // RGB or GRB ordering doesn't matter for black, use 4-channel LED configuraton to make sure all channels are zero
 142         ws2811UpdateStrip(LED_GRBW, 100);
 143
 144         ws2811Initialised = true;
 145     }
 146 }
 147
 148 bool isWS2811LedStripReady(void)
 149 {
 150     return ws2811Initialised && !ws2811LedDataTransferInProgress;
 151 }
 152
 153 STATIC_UNIT_TESTED void updateLEDDMABuffer(ledStripFormatRGB_e ledFormat, rgbColor24bpp_t *color, unsigned ledIndex)
 154 {
 155     uint32_t bits_per_led;
 156     uint32_t packed_colour;
 157
 158     switch (ledFormat) {
 159         case LED_RGB: // WS2811 drivers use RGB format
 160             packed_colour = (color->rgb.r << 16) | (color->rgb.g << 8) | (color->rgb.b);
 161             bits_per_led = 24;
 162             break;
 163
 164         case LED_GRBW: // SK6812 drivers use this
 165         {
 166             /* reconstruct white channel from RGB, making the intensity a bit nonlinear, but thats fine for this use case */
 167             uint8_t white = MIN(MIN(color->rgb.r, color->rgb.g), color->rgb.b);
 168             packed_colour = (color->rgb.g << 24) | (color->rgb.r << 16) | (color->rgb.b << 8) | (white);
 169             bits_per_led = 32;
 170             break;
 171         }
 172
 173         case LED_GRB: // WS2812 drivers use GRB format
 174         default:
 175             packed_colour = (color->rgb.g << 16) | (color->rgb.r << 8) | (color->rgb.b);
 176             bits_per_led = 24;
 177         break;
 178     }
 179
 180     unsigned dmaBufferOffset = 0;
 181     for (int index = bits_per_led-1; index >= 0; index--) {
 182         ledStripDMABuffer[ledIndex * bits_per_led + dmaBufferOffset++] = (packed_colour & (1 << index)) ? BIT_COMPARE_1 : BIT_COMPARE_0;
 183     }
 184 }
 185
 186 /*
 187  * This method is non-blocking unless an existing LED update is in progress.
 188  * it does not wait until all the LEDs have been updated, that happens in the background.
 189  */
 190 void ws2811UpdateStrip(ledStripFormatRGB_e ledFormat, uint8_t brightness)
 191 {
 192     // don't wait - risk of infinite block, just get an update next time round
 193     if (!ws2811Initialised || ws2811LedDataTransferInProgress) {
 194         schedulerIgnoreTaskStateTime();
 195         return;
 196     }
 197
 198     unsigned ledIndex = 0;              // reset led index
 199
 200     // fill transmit buffer with correct compare values to achieve
 201     // correct pulse widths according to color values
 202     const unsigned ledUpdateCount = needsFullRefresh ? WS2811_DATA_BUFFER_SIZE : usedLedCount;
 203     const hsvColor_t hsvBlack = { 0, 0, 0 };
 204     while (ledIndex < ledUpdateCount) {
 205         hsvColor_t scaledLed = ledIndex < usedLedCount ? ledColorBuffer[ledIndex] : hsvBlack;
 206         // Scale the LED brightness
 207         scaledLed.v = scaledLed.v * brightness / 100;
 208
 209         rgbColor24bpp_t *rgb24 = hsvToRgb24(&scaledLed);
 210
 211         updateLEDDMABuffer(ledFormat, rgb24, ledIndex++);
 212     }
 213     needsFullRefresh = false;
 214
 215 #ifdef USE_LEDSTRIP_CACHE_MGMT
 216     SCB_CleanDCache_by_Addr(ledStripDMABuffer, WS2811_DMA_BUF_CACHE_ALIGN_BYTES);
 217 #endif
 218
 219     ws2811LedDataTransferInProgress = true;
 220     ws2811LedStripDMAEnable();
 221 }
 222
 223 #endif