A conversion of the excellent Adafruit WS2801 library for Arduino to work on mbed
Adafruit_WS2801.cpp@2:2fdaa13896a4, 2014-02-12 (annotated)
- Committer:
- SomeRandomBloke
- Date:
- Wed Feb 12 22:05:44 2014 +0000
- Revision:
- 2:2fdaa13896a4
- Parent:
- 1:6ff477690983
- Child:
- 3:dfffbd9f8ac6
Updated to use hardware SPI on SPI0, only tested on WiFiDIPCortex, LPC1347 based board.
Who changed what in which revision?
User | Revision | Line number | New contents of line |
---|---|---|---|
SomeRandomBloke | 0:582e1b9c1cc1 | 1 | #include "mbed.h" |
SomeRandomBloke | 0:582e1b9c1cc1 | 2 | #include "Adafruit_WS2801.h" |
SomeRandomBloke | 0:582e1b9c1cc1 | 3 | |
SomeRandomBloke | 0:582e1b9c1cc1 | 4 | // Example to control WS2801-based RGB LED Modules in a strand or strip |
SomeRandomBloke | 0:582e1b9c1cc1 | 5 | // Written by Adafruit - MIT license |
SomeRandomBloke | 0:582e1b9c1cc1 | 6 | /*****************************************************************************/ |
SomeRandomBloke | 0:582e1b9c1cc1 | 7 | |
SomeRandomBloke | 2:2fdaa13896a4 | 8 | SPI spi(p16, p15, p13); // mosi, miso, sclk |
SomeRandomBloke | 2:2fdaa13896a4 | 9 | |
SomeRandomBloke | 0:582e1b9c1cc1 | 10 | // Constructor for use with hardware SPI (specific clock/data pins): |
SomeRandomBloke | 1:6ff477690983 | 11 | //Adafruit_WS2801::Adafruit_WS2801(uint16_t n, uint8_t order): clkpin(PTD4), datapin(PTA12) |
SomeRandomBloke | 1:6ff477690983 | 12 | //{ |
SomeRandomBloke | 1:6ff477690983 | 13 | // rgb_order = order; |
SomeRandomBloke | 1:6ff477690983 | 14 | // alloc(n); |
SomeRandomBloke | 1:6ff477690983 | 15 | // updatePins(); |
SomeRandomBloke | 1:6ff477690983 | 16 | //} |
SomeRandomBloke | 0:582e1b9c1cc1 | 17 | |
SomeRandomBloke | 0:582e1b9c1cc1 | 18 | // Constructor for use with arbitrary clock/data pins: |
SomeRandomBloke | 0:582e1b9c1cc1 | 19 | Adafruit_WS2801::Adafruit_WS2801(uint16_t n, PinName dpin, PinName cpin, uint8_t order) : clkpin(cpin), datapin(dpin) |
SomeRandomBloke | 0:582e1b9c1cc1 | 20 | { |
SomeRandomBloke | 0:582e1b9c1cc1 | 21 | rgb_order = order; |
SomeRandomBloke | 0:582e1b9c1cc1 | 22 | alloc(n); |
SomeRandomBloke | 2:2fdaa13896a4 | 23 | |
SomeRandomBloke | 0:582e1b9c1cc1 | 24 | // updatePins(dpin, cpin); |
SomeRandomBloke | 0:582e1b9c1cc1 | 25 | } |
SomeRandomBloke | 0:582e1b9c1cc1 | 26 | |
SomeRandomBloke | 0:582e1b9c1cc1 | 27 | // Constructor for use with a matrix configuration, specify w, h for size of matrix |
SomeRandomBloke | 0:582e1b9c1cc1 | 28 | // assumes configuration where string starts at coordinate 0,0 and continues to w-1,0, w-1,1 |
SomeRandomBloke | 0:582e1b9c1cc1 | 29 | // and on to 0,1, 0,2 and on to w-1,2 and so on. Snaking back and forth till the end. |
SomeRandomBloke | 0:582e1b9c1cc1 | 30 | // other function calls with provide access to pixels via an x,y coordinate system |
SomeRandomBloke | 0:582e1b9c1cc1 | 31 | Adafruit_WS2801::Adafruit_WS2801(uint16_t w, uint16_t h, PinName dpin, PinName cpin, uint8_t order) : clkpin(cpin), datapin(dpin) |
SomeRandomBloke | 0:582e1b9c1cc1 | 32 | { |
SomeRandomBloke | 0:582e1b9c1cc1 | 33 | rgb_order = order; |
SomeRandomBloke | 0:582e1b9c1cc1 | 34 | alloc(w * h); |
SomeRandomBloke | 0:582e1b9c1cc1 | 35 | width = w; |
SomeRandomBloke | 0:582e1b9c1cc1 | 36 | height = h; |
SomeRandomBloke | 0:582e1b9c1cc1 | 37 | // updatePins(dpin, cpin); |
SomeRandomBloke | 0:582e1b9c1cc1 | 38 | } |
SomeRandomBloke | 0:582e1b9c1cc1 | 39 | |
SomeRandomBloke | 0:582e1b9c1cc1 | 40 | // Allocate 3 bytes per pixel, init to RGB 'off' state: |
SomeRandomBloke | 0:582e1b9c1cc1 | 41 | void Adafruit_WS2801::alloc(uint16_t n) |
SomeRandomBloke | 0:582e1b9c1cc1 | 42 | { |
SomeRandomBloke | 0:582e1b9c1cc1 | 43 | begun = false; |
SomeRandomBloke | 0:582e1b9c1cc1 | 44 | numLEDs = ((pixels = (uint8_t *)calloc(n, 3)) != NULL) ? n : 0; |
SomeRandomBloke | 0:582e1b9c1cc1 | 45 | |
SomeRandomBloke | 2:2fdaa13896a4 | 46 | |
SomeRandomBloke | 2:2fdaa13896a4 | 47 | // for(int bits = 0; bits <= numLEDs*24; bits++) { |
SomeRandomBloke | 2:2fdaa13896a4 | 48 | // spi.write(0x00); |
SomeRandomBloke | 2:2fdaa13896a4 | 49 | // clkpin = 0; |
SomeRandomBloke | 2:2fdaa13896a4 | 50 | // datapin = 0; |
SomeRandomBloke | 2:2fdaa13896a4 | 51 | // clkpin = 1; |
SomeRandomBloke | 2:2fdaa13896a4 | 52 | // } |
SomeRandomBloke | 2:2fdaa13896a4 | 53 | // clkpin = 0; |
SomeRandomBloke | 0:582e1b9c1cc1 | 54 | } |
SomeRandomBloke | 0:582e1b9c1cc1 | 55 | |
SomeRandomBloke | 0:582e1b9c1cc1 | 56 | // via Michael Vogt/neophob: empty constructor is used when strand length |
SomeRandomBloke | 0:582e1b9c1cc1 | 57 | // isn't known at compile-time; situations where program config might be |
SomeRandomBloke | 0:582e1b9c1cc1 | 58 | // read from internal flash memory or an SD card, or arrive via serial |
SomeRandomBloke | 0:582e1b9c1cc1 | 59 | // command. If using this constructor, MUST follow up with updateLength() |
SomeRandomBloke | 0:582e1b9c1cc1 | 60 | // and updatePins() to establish the strand length and output pins! |
SomeRandomBloke | 0:582e1b9c1cc1 | 61 | // Also, updateOrder() to change RGB vs GRB order (RGB is default). |
SomeRandomBloke | 1:6ff477690983 | 62 | //Adafruit_WS2801::Adafruit_WS2801(void) : clkpin(PTD4), datapin(PTA12) |
SomeRandomBloke | 1:6ff477690983 | 63 | //{ |
SomeRandomBloke | 1:6ff477690983 | 64 | // begun = false; |
SomeRandomBloke | 1:6ff477690983 | 65 | // numLEDs = 0; |
SomeRandomBloke | 1:6ff477690983 | 66 | // pixels = NULL; |
SomeRandomBloke | 1:6ff477690983 | 67 | // rgb_order = WS2801_RGB; |
SomeRandomBloke | 1:6ff477690983 | 68 | // updatePins(); // Must assume hardware SPI until pins are set |
SomeRandomBloke | 1:6ff477690983 | 69 | //} |
SomeRandomBloke | 0:582e1b9c1cc1 | 70 | |
SomeRandomBloke | 0:582e1b9c1cc1 | 71 | // Release memory (as needed): |
SomeRandomBloke | 0:582e1b9c1cc1 | 72 | Adafruit_WS2801::~Adafruit_WS2801(void) |
SomeRandomBloke | 0:582e1b9c1cc1 | 73 | { |
SomeRandomBloke | 0:582e1b9c1cc1 | 74 | if (pixels != NULL) { |
SomeRandomBloke | 0:582e1b9c1cc1 | 75 | free(pixels); |
SomeRandomBloke | 0:582e1b9c1cc1 | 76 | } |
SomeRandomBloke | 0:582e1b9c1cc1 | 77 | } |
SomeRandomBloke | 0:582e1b9c1cc1 | 78 | |
SomeRandomBloke | 0:582e1b9c1cc1 | 79 | // Activate hard/soft SPI as appropriate: |
SomeRandomBloke | 0:582e1b9c1cc1 | 80 | void Adafruit_WS2801::begin(void) |
SomeRandomBloke | 0:582e1b9c1cc1 | 81 | { |
SomeRandomBloke | 2:2fdaa13896a4 | 82 | if( hardwareSPI ) { |
SomeRandomBloke | 2:2fdaa13896a4 | 83 | // Setup the spi for 8 bit data, high steady state clock, |
SomeRandomBloke | 2:2fdaa13896a4 | 84 | // second edge capture, with a 1MHz clock rate |
SomeRandomBloke | 2:2fdaa13896a4 | 85 | spi.format(8,0); |
SomeRandomBloke | 2:2fdaa13896a4 | 86 | spi.frequency(1000000); |
SomeRandomBloke | 2:2fdaa13896a4 | 87 | } else { |
SomeRandomBloke | 2:2fdaa13896a4 | 88 | datapin = 0; |
SomeRandomBloke | 2:2fdaa13896a4 | 89 | clkpin = 0; |
SomeRandomBloke | 2:2fdaa13896a4 | 90 | } |
SomeRandomBloke | 0:582e1b9c1cc1 | 91 | begun = true; |
SomeRandomBloke | 0:582e1b9c1cc1 | 92 | } |
SomeRandomBloke | 0:582e1b9c1cc1 | 93 | |
SomeRandomBloke | 0:582e1b9c1cc1 | 94 | // Change pin assignments post-constructor, switching to hardware SPI: |
SomeRandomBloke | 0:582e1b9c1cc1 | 95 | void Adafruit_WS2801::updatePins(void) |
SomeRandomBloke | 0:582e1b9c1cc1 | 96 | { |
SomeRandomBloke | 0:582e1b9c1cc1 | 97 | hardwareSPI = true; |
SomeRandomBloke | 0:582e1b9c1cc1 | 98 | datapin = 0; |
SomeRandomBloke | 0:582e1b9c1cc1 | 99 | clkpin = 0; |
SomeRandomBloke | 0:582e1b9c1cc1 | 100 | } |
SomeRandomBloke | 2:2fdaa13896a4 | 101 | |
SomeRandomBloke | 0:582e1b9c1cc1 | 102 | |
SomeRandomBloke | 0:582e1b9c1cc1 | 103 | // Change pin assignments post-constructor, using arbitrary pins: |
SomeRandomBloke | 1:6ff477690983 | 104 | //void Adafruit_WS2801::updatePins(PinName dpin, PinName cpin) |
SomeRandomBloke | 1:6ff477690983 | 105 | //{ |
SomeRandomBloke | 0:582e1b9c1cc1 | 106 | // Note: any prior clock/data pin directions are left as-is and are |
SomeRandomBloke | 0:582e1b9c1cc1 | 107 | // NOT restored as inputs! |
SomeRandomBloke | 0:582e1b9c1cc1 | 108 | |
SomeRandomBloke | 1:6ff477690983 | 109 | // datapin = DigitalOut(dpin); |
SomeRandomBloke | 1:6ff477690983 | 110 | // clkpin = DigitalOut(cpin); |
SomeRandomBloke | 1:6ff477690983 | 111 | //} |
SomeRandomBloke | 0:582e1b9c1cc1 | 112 | |
SomeRandomBloke | 0:582e1b9c1cc1 | 113 | uint16_t Adafruit_WS2801::numPixels(void) |
SomeRandomBloke | 0:582e1b9c1cc1 | 114 | { |
SomeRandomBloke | 0:582e1b9c1cc1 | 115 | return numLEDs; |
SomeRandomBloke | 0:582e1b9c1cc1 | 116 | } |
SomeRandomBloke | 0:582e1b9c1cc1 | 117 | |
SomeRandomBloke | 0:582e1b9c1cc1 | 118 | // Change strand length (see notes with empty constructor, above): |
SomeRandomBloke | 0:582e1b9c1cc1 | 119 | void Adafruit_WS2801::updateLength(uint16_t n) |
SomeRandomBloke | 0:582e1b9c1cc1 | 120 | { |
SomeRandomBloke | 0:582e1b9c1cc1 | 121 | if(pixels != NULL) free(pixels); // Free existing data (if any) |
SomeRandomBloke | 0:582e1b9c1cc1 | 122 | // Allocate new data -- note: ALL PIXELS ARE CLEARED |
SomeRandomBloke | 0:582e1b9c1cc1 | 123 | numLEDs = ((pixels = (uint8_t *)calloc(n, 3)) != NULL) ? n : 0; |
SomeRandomBloke | 0:582e1b9c1cc1 | 124 | // 'begun' state does not change -- pins retain prior modes |
SomeRandomBloke | 0:582e1b9c1cc1 | 125 | } |
SomeRandomBloke | 0:582e1b9c1cc1 | 126 | |
SomeRandomBloke | 0:582e1b9c1cc1 | 127 | // Change RGB data order (see notes with empty constructor, above): |
SomeRandomBloke | 0:582e1b9c1cc1 | 128 | void Adafruit_WS2801::updateOrder(uint8_t order) |
SomeRandomBloke | 0:582e1b9c1cc1 | 129 | { |
SomeRandomBloke | 0:582e1b9c1cc1 | 130 | rgb_order = order; |
SomeRandomBloke | 0:582e1b9c1cc1 | 131 | // Existing LED data, if any, is NOT reformatted to new data order. |
SomeRandomBloke | 0:582e1b9c1cc1 | 132 | // Calling function should clear or fill pixel data anew. |
SomeRandomBloke | 0:582e1b9c1cc1 | 133 | } |
SomeRandomBloke | 0:582e1b9c1cc1 | 134 | |
SomeRandomBloke | 0:582e1b9c1cc1 | 135 | void Adafruit_WS2801::show(void) |
SomeRandomBloke | 0:582e1b9c1cc1 | 136 | { |
SomeRandomBloke | 0:582e1b9c1cc1 | 137 | uint16_t i, nl3 = numLEDs * 3; // 3 bytes per LED |
SomeRandomBloke | 2:2fdaa13896a4 | 138 | |
SomeRandomBloke | 2:2fdaa13896a4 | 139 | if( hardwareSPI ) { |
SomeRandomBloke | 2:2fdaa13896a4 | 140 | for(i=0; i<nl3; i++ ) { |
SomeRandomBloke | 2:2fdaa13896a4 | 141 | spi.write( pixels[i]); |
SomeRandomBloke | 2:2fdaa13896a4 | 142 | } |
SomeRandomBloke | 2:2fdaa13896a4 | 143 | wait_ms(1); // Data is latched by holding clock pin low for 1 millisecond |
SomeRandomBloke | 2:2fdaa13896a4 | 144 | } else { |
SomeRandomBloke | 2:2fdaa13896a4 | 145 | uint8_t bit; |
SomeRandomBloke | 0:582e1b9c1cc1 | 146 | |
SomeRandomBloke | 2:2fdaa13896a4 | 147 | // Write 24 bits per pixel: |
SomeRandomBloke | 2:2fdaa13896a4 | 148 | for(i=0; i<nl3; i++ ) { |
SomeRandomBloke | 2:2fdaa13896a4 | 149 | for(bit=0x80; bit; bit >>= 1) { |
SomeRandomBloke | 2:2fdaa13896a4 | 150 | clkpin = 0; |
SomeRandomBloke | 2:2fdaa13896a4 | 151 | datapin = (pixels[i] & bit) ? 1 : 0; |
SomeRandomBloke | 2:2fdaa13896a4 | 152 | clkpin = 1; |
SomeRandomBloke | 2:2fdaa13896a4 | 153 | wait_us(100); |
SomeRandomBloke | 2:2fdaa13896a4 | 154 | } |
SomeRandomBloke | 0:582e1b9c1cc1 | 155 | } |
SomeRandomBloke | 2:2fdaa13896a4 | 156 | datapin = 0; |
SomeRandomBloke | 0:582e1b9c1cc1 | 157 | |
SomeRandomBloke | 2:2fdaa13896a4 | 158 | clkpin = 0; |
SomeRandomBloke | 2:2fdaa13896a4 | 159 | wait_ms(1); // Data is latched by holding clock pin low for 1 millisecond |
SomeRandomBloke | 2:2fdaa13896a4 | 160 | clkpin = 1; |
SomeRandomBloke | 2:2fdaa13896a4 | 161 | } |
SomeRandomBloke | 0:582e1b9c1cc1 | 162 | } |
SomeRandomBloke | 0:582e1b9c1cc1 | 163 | |
SomeRandomBloke | 0:582e1b9c1cc1 | 164 | // Set pixel color from separate 8-bit R, G, B components: |
SomeRandomBloke | 0:582e1b9c1cc1 | 165 | void Adafruit_WS2801::setPixelColor(uint16_t n, uint8_t r, uint8_t g, uint8_t b) |
SomeRandomBloke | 0:582e1b9c1cc1 | 166 | { |
SomeRandomBloke | 0:582e1b9c1cc1 | 167 | if(n < numLEDs) { // Arrays are 0-indexed, thus NOT '<=' |
SomeRandomBloke | 0:582e1b9c1cc1 | 168 | uint8_t *p = &pixels[n * 3]; |
SomeRandomBloke | 0:582e1b9c1cc1 | 169 | // See notes later regarding color order |
SomeRandomBloke | 0:582e1b9c1cc1 | 170 | if(rgb_order == WS2801_RGB) { |
SomeRandomBloke | 0:582e1b9c1cc1 | 171 | *p++ = r; |
SomeRandomBloke | 0:582e1b9c1cc1 | 172 | *p++ = g; |
SomeRandomBloke | 0:582e1b9c1cc1 | 173 | } else { |
SomeRandomBloke | 0:582e1b9c1cc1 | 174 | *p++ = g; |
SomeRandomBloke | 0:582e1b9c1cc1 | 175 | *p++ = r; |
SomeRandomBloke | 0:582e1b9c1cc1 | 176 | } |
SomeRandomBloke | 0:582e1b9c1cc1 | 177 | *p++ = b; |
SomeRandomBloke | 0:582e1b9c1cc1 | 178 | } |
SomeRandomBloke | 0:582e1b9c1cc1 | 179 | } |
SomeRandomBloke | 0:582e1b9c1cc1 | 180 | |
SomeRandomBloke | 0:582e1b9c1cc1 | 181 | // Set pixel color from separate 8-bit R, G, B components using x,y coordinate system: |
SomeRandomBloke | 0:582e1b9c1cc1 | 182 | void Adafruit_WS2801::setPixelColor(uint16_t x, uint16_t y, uint8_t r, uint8_t g, uint8_t b) |
SomeRandomBloke | 0:582e1b9c1cc1 | 183 | { |
SomeRandomBloke | 0:582e1b9c1cc1 | 184 | bool evenRow = ((y % 2) == 0); |
SomeRandomBloke | 0:582e1b9c1cc1 | 185 | // calculate x offset first |
SomeRandomBloke | 0:582e1b9c1cc1 | 186 | uint16_t offset = x % width; |
SomeRandomBloke | 0:582e1b9c1cc1 | 187 | if (!evenRow) { |
SomeRandomBloke | 0:582e1b9c1cc1 | 188 | offset = (width-1) - offset; |
SomeRandomBloke | 0:582e1b9c1cc1 | 189 | } |
SomeRandomBloke | 0:582e1b9c1cc1 | 190 | // add y offset |
SomeRandomBloke | 0:582e1b9c1cc1 | 191 | offset += y * width; |
SomeRandomBloke | 0:582e1b9c1cc1 | 192 | setPixelColor(offset, r, g, b); |
SomeRandomBloke | 0:582e1b9c1cc1 | 193 | } |
SomeRandomBloke | 0:582e1b9c1cc1 | 194 | |
SomeRandomBloke | 0:582e1b9c1cc1 | 195 | // Set pixel color from 'packed' 32-bit RGB value: |
SomeRandomBloke | 0:582e1b9c1cc1 | 196 | void Adafruit_WS2801::setPixelColor(uint16_t n, uint32_t c) |
SomeRandomBloke | 0:582e1b9c1cc1 | 197 | { |
SomeRandomBloke | 0:582e1b9c1cc1 | 198 | if(n < numLEDs) { // Arrays are 0-indexed, thus NOT '<=' |
SomeRandomBloke | 0:582e1b9c1cc1 | 199 | uint8_t *p = &pixels[n * 3]; |
SomeRandomBloke | 0:582e1b9c1cc1 | 200 | // To keep the show() loop as simple & fast as possible, the |
SomeRandomBloke | 0:582e1b9c1cc1 | 201 | // internal color representation is native to different pixel |
SomeRandomBloke | 0:582e1b9c1cc1 | 202 | // types. For compatibility with existing code, 'packed' RGB |
SomeRandomBloke | 0:582e1b9c1cc1 | 203 | // values passed in or out are always 0xRRGGBB order. |
SomeRandomBloke | 0:582e1b9c1cc1 | 204 | if(rgb_order == WS2801_RGB) { |
SomeRandomBloke | 0:582e1b9c1cc1 | 205 | *p++ = c >> 16; // Red |
SomeRandomBloke | 0:582e1b9c1cc1 | 206 | *p++ = c >> 8; // Green |
SomeRandomBloke | 0:582e1b9c1cc1 | 207 | } else { |
SomeRandomBloke | 0:582e1b9c1cc1 | 208 | *p++ = c >> 8; // Green |
SomeRandomBloke | 0:582e1b9c1cc1 | 209 | *p++ = c >> 16; // Red |
SomeRandomBloke | 0:582e1b9c1cc1 | 210 | } |
SomeRandomBloke | 0:582e1b9c1cc1 | 211 | *p++ = c; // Blue |
SomeRandomBloke | 0:582e1b9c1cc1 | 212 | } |
SomeRandomBloke | 0:582e1b9c1cc1 | 213 | } |
SomeRandomBloke | 0:582e1b9c1cc1 | 214 | |
SomeRandomBloke | 0:582e1b9c1cc1 | 215 | // Set pixel color from 'packed' 32-bit RGB value using x,y coordinate system: |
SomeRandomBloke | 0:582e1b9c1cc1 | 216 | void Adafruit_WS2801::setPixelColor(uint16_t x, uint16_t y, uint32_t c) |
SomeRandomBloke | 0:582e1b9c1cc1 | 217 | { |
SomeRandomBloke | 0:582e1b9c1cc1 | 218 | bool evenRow = ((y % 2) == 0); |
SomeRandomBloke | 0:582e1b9c1cc1 | 219 | // calculate x offset first |
SomeRandomBloke | 0:582e1b9c1cc1 | 220 | uint16_t offset = x % width; |
SomeRandomBloke | 0:582e1b9c1cc1 | 221 | if (!evenRow) { |
SomeRandomBloke | 0:582e1b9c1cc1 | 222 | offset = (width-1) - offset; |
SomeRandomBloke | 0:582e1b9c1cc1 | 223 | } |
SomeRandomBloke | 0:582e1b9c1cc1 | 224 | // add y offset |
SomeRandomBloke | 0:582e1b9c1cc1 | 225 | offset += y * width; |
SomeRandomBloke | 0:582e1b9c1cc1 | 226 | setPixelColor(offset, c); |
SomeRandomBloke | 0:582e1b9c1cc1 | 227 | } |
SomeRandomBloke | 0:582e1b9c1cc1 | 228 | |
SomeRandomBloke | 0:582e1b9c1cc1 | 229 | // Query color from previously-set pixel (returns packed 32-bit RGB value) |
SomeRandomBloke | 0:582e1b9c1cc1 | 230 | uint32_t Adafruit_WS2801::getPixelColor(uint16_t n) |
SomeRandomBloke | 0:582e1b9c1cc1 | 231 | { |
SomeRandomBloke | 0:582e1b9c1cc1 | 232 | if(n < numLEDs) { |
SomeRandomBloke | 0:582e1b9c1cc1 | 233 | uint16_t ofs = n * 3; |
SomeRandomBloke | 0:582e1b9c1cc1 | 234 | // To keep the show() loop as simple & fast as possible, the |
SomeRandomBloke | 0:582e1b9c1cc1 | 235 | // internal color representation is native to different pixel |
SomeRandomBloke | 0:582e1b9c1cc1 | 236 | // types. For compatibility with existing code, 'packed' RGB |
SomeRandomBloke | 0:582e1b9c1cc1 | 237 | // values passed in or out are always 0xRRGGBB order. |
SomeRandomBloke | 0:582e1b9c1cc1 | 238 | return (rgb_order == WS2801_RGB) ? |
SomeRandomBloke | 0:582e1b9c1cc1 | 239 | ((uint32_t)pixels[ofs] << 16) | ((uint16_t) pixels[ofs + 1] << 8) | pixels[ofs + 2] : |
SomeRandomBloke | 0:582e1b9c1cc1 | 240 | (pixels[ofs] << 8) | ((uint32_t)pixels[ofs + 1] << 16) | pixels[ofs + 2]; |
SomeRandomBloke | 0:582e1b9c1cc1 | 241 | } |
SomeRandomBloke | 0:582e1b9c1cc1 | 242 | |
SomeRandomBloke | 0:582e1b9c1cc1 | 243 | return 0; // Pixel # is out of bounds |
SomeRandomBloke | 0:582e1b9c1cc1 | 244 | } |