Jack Berkhout / RGB_Matrix

Adafruit 64x32 RGB LED Matrix - 3mm pitch driver for Nucleo-F446RE

Dependents:   RGB_Matrix_Test

RGB_Matrix.cpp@0:04691de55153, 2015-10-02 (annotated)

Committer:
JackB
Date:
Fri Oct 02 22:27:28 2015 +0000
Revision:
0:04691de55153
Adafruit 64x32 RGB LED Matrix - 3mm pitch driver for Nucleo F446RE

Who changed what in which revision?

UserRevisionLine numberNew contents of line
JackB 0:04691de55153 1 /* mbed RGB Matrix Library
JackB 0:04691de55153 2 * Written for Nucleo-F446RE, v1.0, 03-10-2015
JackB 0:04691de55153 3 *
JackB 0:04691de55153 4 * Copyright (c) 2013-2015 JackB, cstyles
JackB 0:04691de55153 5 *
JackB 0:04691de55153 6 * Permission is hereby granted, free of charge, to any person obtaining a copy
JackB 0:04691de55153 7 * of this software and associated documentation files (the "Software"), to deal
JackB 0:04691de55153 8 * in the Software without restriction, including without limitation the rights
JackB 0:04691de55153 9 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
JackB 0:04691de55153 10 * copies of the Software, and to permit persons to whom the Software is
JackB 0:04691de55153 11 * furnished to do so, subject to the following conditions:
JackB 0:04691de55153 12 *
JackB 0:04691de55153 13 * The above copyright notice and this permission notice shall be included in
JackB 0:04691de55153 14 * all copies or substantial portions of the Software.
JackB 0:04691de55153 15 *
JackB 0:04691de55153 16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
JackB 0:04691de55153 17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
JackB 0:04691de55153 18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
JackB 0:04691de55153 19 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
JackB 0:04691de55153 20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
JackB 0:04691de55153 21 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
JackB 0:04691de55153 22 * THE SOFTWARE.
JackB 0:04691de55153 23 */
JackB 0:04691de55153 24
JackB 0:04691de55153 25 #include "RGB_Matrix.h"
JackB 0:04691de55153 26
JackB 0:04691de55153 27 RGB_Matrix::RGB_Matrix(PinName Pin_R1, PinName Pin_R2,
JackB 0:04691de55153 28 PinName Pin_G1, PinName Pin_G2,
JackB 0:04691de55153 29 PinName Pin_B1, PinName Pin_B2,
JackB 0:04691de55153 30 PinName Pin_CLK, PinName Pin_LAT, PinName Pin_OE,
JackB 0:04691de55153 31 PinName Pin_A, PinName Pin_B, PinName Pin_C, PinName Pin_D) :
JackB 0:04691de55153 32 _Pin_R1(Pin_R1), _Pin_R2(Pin_R2),
JackB 0:04691de55153 33 _Pin_G1(Pin_G1), _Pin_G2(Pin_G2),
JackB 0:04691de55153 34 _Pin_B1(Pin_B1), _Pin_B2(Pin_B2),
JackB 0:04691de55153 35 _Pin_CLK(Pin_CLK), _Pin_LAT(Pin_LAT), _Pin_OE(Pin_OE),
JackB 0:04691de55153 36 _Pin_A(Pin_A), _Pin_B(Pin_B), _Pin_C(Pin_C), _Pin_D(Pin_D) {
JackB 0:04691de55153 37 }
JackB 0:04691de55153 38
JackB 0:04691de55153 39 void RGB_Matrix::Init(void) {
JackB 0:04691de55153 40 // uint8_t *ptr;
JackB 0:04691de55153 41
JackB 0:04691de55153 42 _Pin_CLK = 0; // Clock low
JackB 0:04691de55153 43 _Pin_OE = 1; // Disable LED output during row/plane switchover
JackB 0:04691de55153 44 _Pin_LAT = 1; // Latch data loaded during *prior* interrupt
JackB 0:04691de55153 45
JackB 0:04691de55153 46 plane = PLANES - 1;
JackB 0:04691de55153 47 row = ROWS - 1;
JackB 0:04691de55153 48
JackB 0:04691de55153 49 // Allocate and initialize matrix buffer:
JackB 0:04691de55153 50
JackB 0:04691de55153 51 int buffsize = WIDTH * ROWS * PLANES,
JackB 0:04691de55153 52 allocsize = (DBUF == true) ? (buffsize * 2) : buffsize;
JackB 0:04691de55153 53
JackB 0:04691de55153 54 if(NULL == (matrixbuff[0] = (uint8_t *)malloc(allocsize)))
JackB 0:04691de55153 55 return;
JackB 0:04691de55153 56 memset(matrixbuff[0], 0, allocsize);
JackB 0:04691de55153 57
JackB 0:04691de55153 58 if(NULL == (matrixbuff[1] = (uint8_t *)malloc(allocsize)))
JackB 0:04691de55153 59 return;
JackB 0:04691de55153 60 memset(matrixbuff[1], 0, allocsize);
JackB 0:04691de55153 61
JackB 0:04691de55153 62 // If not double-buffered, both buffers then point to the same address:
JackB 0:04691de55153 63 // matrixbuff[1] = (DBUF == true) ? &matrixbuff[0][buffsize] : matrixbuff[0];
JackB 0:04691de55153 64
JackB 0:04691de55153 65 bufferDisplay = 0;
JackB 0:04691de55153 66 bufferWrite = 0;
JackB 0:04691de55153 67 // buffptr = matrixbuff[bufferDisplay]; // -> front buffer
JackB 0:04691de55153 68
JackB 0:04691de55153 69 /*
JackB 0:04691de55153 70 // Some data!
JackB 0:04691de55153 71 buffptr[0] = 0x11;
JackB 0:04691de55153 72 buffptr[1] = 0x22;
JackB 0:04691de55153 73 buffptr[2] = 0x44;
JackB 0:04691de55153 74 buffptr[0+PIXELS] = 0x11;
JackB 0:04691de55153 75 buffptr[1+PIXELS] = 0x22;
JackB 0:04691de55153 76 buffptr[2+PIXELS] = 0x44;
JackB 0:04691de55153 77 buffptr[0+PIXELS*2] = 0x11;
JackB 0:04691de55153 78 buffptr[1+PIXELS*2] = 0x22;
JackB 0:04691de55153 79 buffptr[2+PIXELS*2] = 0x44;
JackB 0:04691de55153 80 buffptr[0+PIXELS*3] = 0x11;
JackB 0:04691de55153 81 buffptr[1+PIXELS*3] = 0x22;
JackB 0:04691de55153 82 buffptr[2+PIXELS*3] = 0x44;
JackB 0:04691de55153 83 buffptr[0+PIXELS*4] = 0x11;
JackB 0:04691de55153 84 buffptr[1+PIXELS*4] = 0x22;
JackB 0:04691de55153 85 buffptr[2+PIXELS*4] = 0x44;
JackB 0:04691de55153 86 buffptr[0+PIXELS*5] = 0x11;
JackB 0:04691de55153 87 buffptr[1+PIXELS*5] = 0x22;
JackB 0:04691de55153 88 buffptr[2+PIXELS*5] = 0x44;
JackB 0:04691de55153 89 buffptr[0+PIXELS*6] = 0x11;
JackB 0:04691de55153 90 buffptr[1+PIXELS*6] = 0x22;
JackB 0:04691de55153 91 buffptr[2+PIXELS*6] = 0x44;
JackB 0:04691de55153 92
JackB 0:04691de55153 93 buffptr[0+WIDTH] = 0x00;
JackB 0:04691de55153 94 buffptr[1+WIDTH] = 0x00;
JackB 0:04691de55153 95 buffptr[2+WIDTH] = 0x00;
JackB 0:04691de55153 96 buffptr[0+WIDTH+PIXELS] = 0x11;
JackB 0:04691de55153 97 buffptr[1+WIDTH+PIXELS] = 0x22;
JackB 0:04691de55153 98 buffptr[2+WIDTH+PIXELS] = 0x44;
JackB 0:04691de55153 99 buffptr[0+WIDTH+PIXELS*2] = 0x11;
JackB 0:04691de55153 100 buffptr[1+WIDTH+PIXELS*2] = 0x22;
JackB 0:04691de55153 101 buffptr[2+WIDTH+PIXELS*2] = 0x44;
JackB 0:04691de55153 102 buffptr[0+WIDTH+PIXELS*3] = 0x11;
JackB 0:04691de55153 103 buffptr[1+WIDTH+PIXELS*3] = 0x22;
JackB 0:04691de55153 104 buffptr[2+WIDTH+PIXELS*3] = 0x44;
JackB 0:04691de55153 105 buffptr[0+WIDTH+PIXELS*4] = 0x11;
JackB 0:04691de55153 106 buffptr[1+WIDTH+PIXELS*4] = 0x22;
JackB 0:04691de55153 107 buffptr[2+WIDTH+PIXELS*4] = 0x44;
JackB 0:04691de55153 108 buffptr[0+WIDTH+PIXELS*5] = 0x11;
JackB 0:04691de55153 109 buffptr[1+WIDTH+PIXELS*5] = 0x22;
JackB 0:04691de55153 110 buffptr[2+WIDTH+PIXELS*5] = 0x44;
JackB 0:04691de55153 111 buffptr[0+WIDTH+PIXELS*6] = 0x11;
JackB 0:04691de55153 112 buffptr[1+WIDTH+PIXELS*6] = 0x22;
JackB 0:04691de55153 113 buffptr[2+WIDTH+PIXELS*6] = 0x44;
JackB 0:04691de55153 114
JackB 0:04691de55153 115 buffptr[0+WIDTH*2] = 0x00;
JackB 0:04691de55153 116 buffptr[1+WIDTH*2] = 0x00;
JackB 0:04691de55153 117 buffptr[2+WIDTH*2] = 0x00;
JackB 0:04691de55153 118 buffptr[0+WIDTH*2+PIXELS] = 0x00;
JackB 0:04691de55153 119 buffptr[1+WIDTH*2+PIXELS] = 0x00;
JackB 0:04691de55153 120 buffptr[2+WIDTH*2+PIXELS] = 0x00;
JackB 0:04691de55153 121 buffptr[0+WIDTH*2+PIXELS*2] = 0x11;
JackB 0:04691de55153 122 buffptr[1+WIDTH*2+PIXELS*2] = 0x22;
JackB 0:04691de55153 123 buffptr[2+WIDTH*2+PIXELS*2] = 0x44;
JackB 0:04691de55153 124 buffptr[0+WIDTH*2+PIXELS*3] = 0x11;
JackB 0:04691de55153 125 buffptr[1+WIDTH*2+PIXELS*3] = 0x22;
JackB 0:04691de55153 126 buffptr[2+WIDTH*2+PIXELS*3] = 0x44;
JackB 0:04691de55153 127 buffptr[0+WIDTH*2+PIXELS*4] = 0x11;
JackB 0:04691de55153 128 buffptr[1+WIDTH*2+PIXELS*4] = 0x22;
JackB 0:04691de55153 129 buffptr[2+WIDTH*2+PIXELS*4] = 0x44;
JackB 0:04691de55153 130 buffptr[0+WIDTH*2+PIXELS*5] = 0x11;
JackB 0:04691de55153 131 buffptr[1+WIDTH*2+PIXELS*5] = 0x22;
JackB 0:04691de55153 132 buffptr[2+WIDTH*2+PIXELS*5] = 0x44;
JackB 0:04691de55153 133 buffptr[0+WIDTH*2+PIXELS*6] = 0x11;
JackB 0:04691de55153 134 buffptr[1+WIDTH*2+PIXELS*6] = 0x22;
JackB 0:04691de55153 135 buffptr[2+WIDTH*2+PIXELS*6] = 0x44;
JackB 0:04691de55153 136
JackB 0:04691de55153 137 buffptr[0+WIDTH*3] = 0x00;
JackB 0:04691de55153 138 buffptr[1+WIDTH*3] = 0x00;
JackB 0:04691de55153 139 buffptr[2+WIDTH*3] = 0x00;
JackB 0:04691de55153 140 buffptr[0+WIDTH*3+PIXELS] = 0x00;
JackB 0:04691de55153 141 buffptr[1+WIDTH*3+PIXELS] = 0x00;
JackB 0:04691de55153 142 buffptr[2+WIDTH*3+PIXELS] = 0x00;
JackB 0:04691de55153 143 buffptr[0+WIDTH*3+PIXELS*2] = 0x00;
JackB 0:04691de55153 144 buffptr[1+WIDTH*3+PIXELS*2] = 0x00;
JackB 0:04691de55153 145 buffptr[2+WIDTH*3+PIXELS*2] = 0x00;
JackB 0:04691de55153 146 buffptr[0+WIDTH*3+PIXELS*3] = 0x11;
JackB 0:04691de55153 147 buffptr[1+WIDTH*3+PIXELS*3] = 0x22;
JackB 0:04691de55153 148 buffptr[2+WIDTH*3+PIXELS*3] = 0x44;
JackB 0:04691de55153 149 buffptr[0+WIDTH*3+PIXELS*4] = 0x11;
JackB 0:04691de55153 150 buffptr[1+WIDTH*3+PIXELS*4] = 0x22;
JackB 0:04691de55153 151 buffptr[2+WIDTH*3+PIXELS*4] = 0x44;
JackB 0:04691de55153 152 buffptr[0+WIDTH*3+PIXELS*5] = 0x11;
JackB 0:04691de55153 153 buffptr[1+WIDTH*3+PIXELS*5] = 0x22;
JackB 0:04691de55153 154 buffptr[2+WIDTH*3+PIXELS*5] = 0x44;
JackB 0:04691de55153 155 buffptr[0+WIDTH*3+PIXELS*6] = 0x11;
JackB 0:04691de55153 156 buffptr[1+WIDTH*3+PIXELS*6] = 0x22;
JackB 0:04691de55153 157 buffptr[2+WIDTH*3+PIXELS*6] = 0x44;
JackB 0:04691de55153 158
JackB 0:04691de55153 159 buffptr[0+WIDTH*4] = 0x00;
JackB 0:04691de55153 160 buffptr[1+WIDTH*4] = 0x00;
JackB 0:04691de55153 161 buffptr[2+WIDTH*4] = 0x00;
JackB 0:04691de55153 162 buffptr[0+WIDTH*4+PIXELS] = 0x00;
JackB 0:04691de55153 163 buffptr[1+WIDTH*4+PIXELS] = 0x00;
JackB 0:04691de55153 164 buffptr[2+WIDTH*4+PIXELS] = 0x00;
JackB 0:04691de55153 165 buffptr[0+WIDTH*4+PIXELS*2] = 0x00;
JackB 0:04691de55153 166 buffptr[1+WIDTH*4+PIXELS*2] = 0x00;
JackB 0:04691de55153 167 buffptr[2+WIDTH*4+PIXELS*2] = 0x00;
JackB 0:04691de55153 168 buffptr[0+WIDTH*4+PIXELS*3] = 0x00;
JackB 0:04691de55153 169 buffptr[1+WIDTH*4+PIXELS*3] = 0x00;
JackB 0:04691de55153 170 buffptr[2+WIDTH*4+PIXELS*3] = 0x00;
JackB 0:04691de55153 171 buffptr[0+WIDTH*4+PIXELS*4] = 0x11;
JackB 0:04691de55153 172 buffptr[1+WIDTH*4+PIXELS*4] = 0x22;
JackB 0:04691de55153 173 buffptr[2+WIDTH*4+PIXELS*4] = 0x44;
JackB 0:04691de55153 174 buffptr[0+WIDTH*4+PIXELS*5] = 0x11;
JackB 0:04691de55153 175 buffptr[1+WIDTH*4+PIXELS*5] = 0x22;
JackB 0:04691de55153 176 buffptr[2+WIDTH*4+PIXELS*5] = 0x44;
JackB 0:04691de55153 177 buffptr[0+WIDTH*4+PIXELS*6] = 0x11;
JackB 0:04691de55153 178 buffptr[1+WIDTH*4+PIXELS*6] = 0x22;
JackB 0:04691de55153 179 buffptr[2+WIDTH*4+PIXELS*6] = 0x44;
JackB 0:04691de55153 180
JackB 0:04691de55153 181 buffptr[0+WIDTH*5] = 0x00;
JackB 0:04691de55153 182 buffptr[1+WIDTH*5] = 0x00;
JackB 0:04691de55153 183 buffptr[2+WIDTH*5] = 0x00;
JackB 0:04691de55153 184 buffptr[0+WIDTH*5+PIXELS] = 0x00;
JackB 0:04691de55153 185 buffptr[1+WIDTH*5+PIXELS] = 0x00;
JackB 0:04691de55153 186 buffptr[2+WIDTH*5+PIXELS] = 0x00;
JackB 0:04691de55153 187 buffptr[0+WIDTH*5+PIXELS*2] = 0x00;
JackB 0:04691de55153 188 buffptr[1+WIDTH*5+PIXELS*2] = 0x00;
JackB 0:04691de55153 189 buffptr[2+WIDTH*5+PIXELS*2] = 0x00;
JackB 0:04691de55153 190 buffptr[0+WIDTH*5+PIXELS*3] = 0x00;
JackB 0:04691de55153 191 buffptr[1+WIDTH*5+PIXELS*3] = 0x00;
JackB 0:04691de55153 192 buffptr[2+WIDTH*5+PIXELS*3] = 0x00;
JackB 0:04691de55153 193 buffptr[0+WIDTH*5+PIXELS*4] = 0x00;
JackB 0:04691de55153 194 buffptr[1+WIDTH*5+PIXELS*4] = 0x00;
JackB 0:04691de55153 195 buffptr[2+WIDTH*5+PIXELS*4] = 0x00;
JackB 0:04691de55153 196 buffptr[0+WIDTH*5+PIXELS*5] = 0x11;
JackB 0:04691de55153 197 buffptr[1+WIDTH*5+PIXELS*5] = 0x22;
JackB 0:04691de55153 198 buffptr[2+WIDTH*5+PIXELS*5] = 0x44;
JackB 0:04691de55153 199 buffptr[0+WIDTH*5+PIXELS*6] = 0x11;
JackB 0:04691de55153 200 buffptr[1+WIDTH*5+PIXELS*6] = 0x22;
JackB 0:04691de55153 201 buffptr[2+WIDTH*5+PIXELS*6] = 0x44;
JackB 0:04691de55153 202
JackB 0:04691de55153 203 buffptr[0+WIDTH*6] = 0x00;
JackB 0:04691de55153 204 buffptr[1+WIDTH*6] = 0x00;
JackB 0:04691de55153 205 buffptr[2+WIDTH*6] = 0x00;
JackB 0:04691de55153 206 buffptr[0+WIDTH*6+PIXELS] = 0x00;
JackB 0:04691de55153 207 buffptr[1+WIDTH*6+PIXELS] = 0x00;
JackB 0:04691de55153 208 buffptr[2+WIDTH*6+PIXELS] = 0x00;
JackB 0:04691de55153 209 buffptr[0+WIDTH*6+PIXELS*2] = 0x00;
JackB 0:04691de55153 210 buffptr[1+WIDTH*6+PIXELS*2] = 0x00;
JackB 0:04691de55153 211 buffptr[2+WIDTH*6+PIXELS*2] = 0x00;
JackB 0:04691de55153 212 buffptr[0+WIDTH*6+PIXELS*3] = 0x00;
JackB 0:04691de55153 213 buffptr[1+WIDTH*6+PIXELS*3] = 0x00;
JackB 0:04691de55153 214 buffptr[2+WIDTH*6+PIXELS*3] = 0x00;
JackB 0:04691de55153 215 buffptr[0+WIDTH*6+PIXELS*4] = 0x00;
JackB 0:04691de55153 216 buffptr[1+WIDTH*6+PIXELS*4] = 0x00;
JackB 0:04691de55153 217 buffptr[2+WIDTH*6+PIXELS*4] = 0x00;
JackB 0:04691de55153 218 buffptr[0+WIDTH*6+PIXELS*5] = 0x00;
JackB 0:04691de55153 219 buffptr[1+WIDTH*6+PIXELS*5] = 0x00;
JackB 0:04691de55153 220 buffptr[2+WIDTH*6+PIXELS*5] = 0x00;
JackB 0:04691de55153 221 buffptr[0+WIDTH*6+PIXELS*6] = 0x11;
JackB 0:04691de55153 222 buffptr[1+WIDTH*6+PIXELS*6] = 0x22;
JackB 0:04691de55153 223 buffptr[2+WIDTH*6+PIXELS*6] = 0x44;
JackB 0:04691de55153 224 */
JackB 0:04691de55153 225 /*
JackB 0:04691de55153 226 buffptr[1] = 0x02;
JackB 0:04691de55153 227 buffptr[2] = 0x03;
JackB 0:04691de55153 228 buffptr[3] = 0x04;
JackB 0:04691de55153 229 buffptr[4] = 0x08;
JackB 0:04691de55153 230 buffptr[5] = 0x0c;
JackB 0:04691de55153 231 buffptr[6] = 0x10;
JackB 0:04691de55153 232 buffptr[7] = 0x20;
JackB 0:04691de55153 233 buffptr[8] = 0x30;
JackB 0:04691de55153 234 buffptr[WIDTH*ROWS+3] = 0x01;
JackB 0:04691de55153 235 buffptr[WIDTH*ROWS+4] = 0x04;
JackB 0:04691de55153 236 buffptr[WIDTH*ROWS+5] = 0x10;
JackB 0:04691de55153 237
JackB 0:04691de55153 238 drawPixel(2, 4, RGB(255, 128, 0)); // RRrrrGGg gggBBbbb
JackB 0:04691de55153 239 */
JackB 0:04691de55153 240
JackB 0:04691de55153 241 Update.attach(this, &RGB_Matrix::updateDisplay, INTTIME); // the address of the function to be attached (flip) and the interval (0.5 seconds)
JackB 0:04691de55153 242 char_x = 0;
JackB 0:04691de55153 243 char_y = 0;
JackB 0:04691de55153 244 foreground(RGB(0, 64, 0));
JackB 0:04691de55153 245 background(RGB(0, 0, 0));
JackB 0:04691de55153 246 SetOrientation(LANDSCAPE_B);
JackB 0:04691de55153 247 }
JackB 0:04691de55153 248
JackB 0:04691de55153 249 void RGB_Matrix::swap(int16_t &x, int16_t &y) {
JackB 0:04691de55153 250 int16_t temp = x;
JackB 0:04691de55153 251 x = y;
JackB 0:04691de55153 252 y = temp;
JackB 0:04691de55153 253 }
JackB 0:04691de55153 254
JackB 0:04691de55153 255 uint16_t RGB_Matrix::rgbToColor(uint8_t R, uint8_t G, uint8_t B) {
JackB 0:04691de55153 256 return ((R >> 6) << 14) + ((G >> 6) << 9) + ((B >> 6) << 3); // RRrrrGGg gggBBbbb
JackB 0:04691de55153 257 }
JackB 0:04691de55153 258
JackB 0:04691de55153 259 void RGB_Matrix::drawPixel2(int16_t x, int16_t y, uint16_t c) {
JackB 0:04691de55153 260 uint8_t r, g, b, bit, limit, *ptr;
JackB 0:04691de55153 261
JackB 0:04691de55153 262 if((x < 0) || (x >= WIDTH) || (y < 0) || (y >= HEIGHT))
JackB 0:04691de55153 263 return;
JackB 0:04691de55153 264
JackB 0:04691de55153 265 switch(_orientation) {
JackB 0:04691de55153 266 case 1:
JackB 0:04691de55153 267 swap(x, y);
JackB 0:04691de55153 268 x = WIDTH - 1 - x;
JackB 0:04691de55153 269 break;
JackB 0:04691de55153 270 case 2:
JackB 0:04691de55153 271 x = WIDTH - 1 - x;
JackB 0:04691de55153 272 y = HEIGHT - 1 - y;
JackB 0:04691de55153 273 break;
JackB 0:04691de55153 274 case 3:
JackB 0:04691de55153 275 swap(x, y);
JackB 0:04691de55153 276 y = HEIGHT - 1 - y;
JackB 0:04691de55153 277 break;
JackB 0:04691de55153 278 }
JackB 0:04691de55153 279
JackB 0:04691de55153 280 // Adafruit_GFX uses 16-bit color in 5/6/5 format, while matrix needs
JackB 0:04691de55153 281 // 2/2/2. Pluck out relevant bits while separating into R,G,B:
JackB 0:04691de55153 282 r = c >> 14; // RRrrrggggggbbbbb
JackB 0:04691de55153 283 g = (c >> 9) & 0x03; // rrrrrGGggggbbbbb
JackB 0:04691de55153 284 b = (c >> 3) & 0x03; // rrrrrggggggBBbbb
JackB 0:04691de55153 285
JackB 0:04691de55153 286 uint8_t color = r + (g << 2) + (b << 4);
JackB 0:04691de55153 287
JackB 0:04691de55153 288 buffptr = matrixbuff[bufferWrite]; // Set first buffer
JackB 0:04691de55153 289 buffptr[y * WIDTH + x] = color;
JackB 0:04691de55153 290 }
JackB 0:04691de55153 291
JackB 0:04691de55153 292 void RGB_Matrix::drawPixel(int16_t x, int16_t y, uint16_t c) {
JackB 0:04691de55153 293 uint8_t r, g, b, bit, limit, *ptr;
JackB 0:04691de55153 294
JackB 0:04691de55153 295 if((x < 0) || (x >= WIDTH) || (y < 0) || (y >= HEIGHT))
JackB 0:04691de55153 296 return;
JackB 0:04691de55153 297
JackB 0:04691de55153 298 switch(_orientation) {
JackB 0:04691de55153 299 case 1:
JackB 0:04691de55153 300 swap(x, y);
JackB 0:04691de55153 301 x = WIDTH - 1 - x;
JackB 0:04691de55153 302 break;
JackB 0:04691de55153 303 case 2:
JackB 0:04691de55153 304 x = WIDTH - 1 - x;
JackB 0:04691de55153 305 y = HEIGHT - 1 - y;
JackB 0:04691de55153 306 break;
JackB 0:04691de55153 307 case 3:
JackB 0:04691de55153 308 swap(x, y);
JackB 0:04691de55153 309 y = HEIGHT - 1 - y;
JackB 0:04691de55153 310 break;
JackB 0:04691de55153 311 }
JackB 0:04691de55153 312
JackB 0:04691de55153 313 // Adafruit_GFX uses 16-bit color in 5/6/5 format, while matrix needs
JackB 0:04691de55153 314 // 2/2/2. Pluck out relevant bits while separating into R,G,B:
JackB 0:04691de55153 315 r = c >> 13; // RRRrrggggggbbbbb
JackB 0:04691de55153 316 g = (c >> 8) & 0x07; // rrrrrGGGgggbbbbb
JackB 0:04691de55153 317 b = (c >> 2) & 0x07; // rrrrrggggggBBBbb
JackB 0:04691de55153 318
JackB 0:04691de55153 319 uint8_t color = r + (g << 2) + (b << 4);
JackB 0:04691de55153 320
JackB 0:04691de55153 321
JackB 0:04691de55153 322 uint8_t *buffptr;
JackB 0:04691de55153 323 buffptr = matrixbuff[bufferWrite]; // Set first buffer
JackB 0:04691de55153 324
JackB 0:04691de55153 325 const uint8_t PixelR1[] = {
JackB 0:04691de55153 326 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe,
JackB 0:04691de55153 327 0xfe, 0xfe, 0xfe, 0x01, 0xfe, 0xfe, 0xfe,
JackB 0:04691de55153 328 0xfe, 0x01, 0xfe, 0xfe, 0xfe, 0x01, 0xfe,
JackB 0:04691de55153 329 0xfe, 0x01, 0xfe, 0x01, 0xfe, 0x01, 0xfe,
JackB 0:04691de55153 330 0x01, 0x01, 0xfe, 0x01, 0xfe, 0x01, 0xfe,
JackB 0:04691de55153 331 0x01, 0x01, 0x01, 0xfe, 0x01, 0x01, 0xfe,
JackB 0:04691de55153 332 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0xfe,
JackB 0:04691de55153 333 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01
JackB 0:04691de55153 334 };
JackB 0:04691de55153 335
JackB 0:04691de55153 336 const uint8_t PixelR2[] = {
JackB 0:04691de55153 337 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef,
JackB 0:04691de55153 338 0xef, 0xef, 0xef, 0x10, 0xef, 0xef, 0xef,
JackB 0:04691de55153 339 0xef, 0x10, 0xef, 0xef, 0xef, 0x10, 0xef,
JackB 0:04691de55153 340 0xef, 0x10, 0xef, 0x10, 0xef, 0x10, 0xef,
JackB 0:04691de55153 341 0x10, 0x10, 0xef, 0x10, 0xef, 0x10, 0xef,
JackB 0:04691de55153 342 0x10, 0x10, 0x10, 0xef, 0x10, 0x10, 0xef,
JackB 0:04691de55153 343 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0xef,
JackB 0:04691de55153 344 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10
JackB 0:04691de55153 345 };
JackB 0:04691de55153 346
JackB 0:04691de55153 347 const uint8_t PixelG1[] = {
JackB 0:04691de55153 348 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd,
JackB 0:04691de55153 349 0xfd, 0xfd, 0xfd, 0x02, 0xfd, 0xfd, 0xfd,
JackB 0:04691de55153 350 0xfd, 0x02, 0xfd, 0xfd, 0xfd, 0x02, 0xfd,
JackB 0:04691de55153 351 0xfd, 0x02, 0xfd, 0x02, 0xfd, 0x02, 0xfd,
JackB 0:04691de55153 352 0x02, 0x02, 0xfd, 0x02, 0xfd, 0x02, 0xfd,
JackB 0:04691de55153 353 0x02, 0x02, 0x02, 0xfd, 0x02, 0x02, 0xfd,
JackB 0:04691de55153 354 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0xfd,
JackB 0:04691de55153 355 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02
JackB 0:04691de55153 356 };
JackB 0:04691de55153 357
JackB 0:04691de55153 358 const uint8_t PixelG2[] = {
JackB 0:04691de55153 359 0xdf, 0xdf, 0xdf, 0xdf, 0xdf, 0xdf, 0xdf,
JackB 0:04691de55153 360 0xdf, 0xdf, 0xdf, 0x20, 0xdf, 0xdf, 0xdf,
JackB 0:04691de55153 361 0xdf, 0x20, 0xdf, 0xdf, 0xdf, 0x20, 0xdf,
JackB 0:04691de55153 362 0xdf, 0x20, 0xdf, 0x20, 0xdf, 0x20, 0xdf,
JackB 0:04691de55153 363 0x20, 0x20, 0xdf, 0x20, 0xdf, 0x20, 0xdf,
JackB 0:04691de55153 364 0x20, 0x20, 0x20, 0xdf, 0x20, 0x20, 0xdf,
JackB 0:04691de55153 365 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0xdf,
JackB 0:04691de55153 366 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20
JackB 0:04691de55153 367 };
JackB 0:04691de55153 368
JackB 0:04691de55153 369 const uint8_t PixelB1[] = {
JackB 0:04691de55153 370 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb,
JackB 0:04691de55153 371 0xfb, 0xfb, 0xfb, 0x04, 0xfb, 0xfb, 0xfb,
JackB 0:04691de55153 372 0xfb, 0x04, 0xfb, 0xfb, 0xfb, 0x04, 0xfb,
JackB 0:04691de55153 373 0xfb, 0x04, 0xfb, 0x04, 0xfb, 0x04, 0xfb,
JackB 0:04691de55153 374 0x04, 0x04, 0xfb, 0x04, 0xfb, 0x04, 0xfb,
JackB 0:04691de55153 375 0x04, 0x04, 0x04, 0xfb, 0x04, 0x04, 0xfb,
JackB 0:04691de55153 376 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0xfb,
JackB 0:04691de55153 377 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04
JackB 0:04691de55153 378 };
JackB 0:04691de55153 379
JackB 0:04691de55153 380 const uint8_t PixelB2[] = {
JackB 0:04691de55153 381 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf,
JackB 0:04691de55153 382 0xbf, 0xbf, 0xbf, 0x40, 0xbf, 0xbf, 0xbf,
JackB 0:04691de55153 383 0xbf, 0x40, 0xbf, 0xbf, 0xbf, 0x40, 0xbf,
JackB 0:04691de55153 384 0xbf, 0x40, 0xbf, 0x40, 0xbf, 0x40, 0xbf,
JackB 0:04691de55153 385 0x40, 0x40, 0xbf, 0x40, 0xbf, 0x40, 0xbf,
JackB 0:04691de55153 386 0x40, 0x40, 0x40, 0xbf, 0x40, 0x40, 0xbf,
JackB 0:04691de55153 387 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0xbf,
JackB 0:04691de55153 388 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40
JackB 0:04691de55153 389 };
JackB 0:04691de55153 390
JackB 0:04691de55153 391 // PWM planes
JackB 0:04691de55153 392 // xBGRxBGR
JackB 0:04691de55153 393
JackB 0:04691de55153 394 for (uint8_t p = 0; p < PLANES; p++) {
JackB 0:04691de55153 395 if (y < ROWS) {
JackB 0:04691de55153 396 if ((PixelR1[p+r*7] & 0x80) == 0)
JackB 0:04691de55153 397 buffptr[x+WIDTH*y+PIXELS*p] |= PixelR1[p+r*7];
JackB 0:04691de55153 398 else
JackB 0:04691de55153 399 buffptr[x+WIDTH*y+PIXELS*p] &= PixelR1[p+r*7];
JackB 0:04691de55153 400 if ((PixelG1[p+g*7] & 0x80) == 0)
JackB 0:04691de55153 401 buffptr[x+WIDTH*y+PIXELS*p] |= PixelG1[p+g*7];
JackB 0:04691de55153 402 else
JackB 0:04691de55153 403 buffptr[x+WIDTH*y+PIXELS*p] &= PixelG1[p+g*7];
JackB 0:04691de55153 404 if ((PixelB1[p+b*7] & 0x80) == 0)
JackB 0:04691de55153 405 buffptr[x+WIDTH*y+PIXELS*p] |= PixelB1[p+b*7];
JackB 0:04691de55153 406 else
JackB 0:04691de55153 407 buffptr[x+WIDTH*y+PIXELS*p] &= PixelB1[p+b*7];
JackB 0:04691de55153 408 } else {
JackB 0:04691de55153 409 if ((PixelR2[p+r*7] & 0x80) == 0)
JackB 0:04691de55153 410 buffptr[x+WIDTH*(y-ROWS)+PIXELS*p] |= PixelR2[p+r*7];
JackB 0:04691de55153 411 else
JackB 0:04691de55153 412 buffptr[x+WIDTH*(y-ROWS)+PIXELS*p] &= PixelR2[p+r*7];
JackB 0:04691de55153 413 if ((PixelG2[p+g*7] & 0x80) == 0)
JackB 0:04691de55153 414 buffptr[x+WIDTH*(y-ROWS)+PIXELS*p] |= PixelG2[p+g*7];
JackB 0:04691de55153 415 else
JackB 0:04691de55153 416 buffptr[x+WIDTH*(y-ROWS)+PIXELS*p] &= PixelG2[p+g*7];
JackB 0:04691de55153 417 if ((PixelB2[p+b*7] & 0x80) == 0)
JackB 0:04691de55153 418 buffptr[x+WIDTH*(y-ROWS)+PIXELS*p] |= PixelB2[p+b*7];
JackB 0:04691de55153 419 else
JackB 0:04691de55153 420 buffptr[x+WIDTH*(y-ROWS)+PIXELS*p] &= PixelB2[p+b*7];
JackB 0:04691de55153 421 }
JackB 0:04691de55153 422 }
JackB 0:04691de55153 423 }
JackB 0:04691de55153 424
JackB 0:04691de55153 425 void RGB_Matrix::set_font(unsigned char* f) {
JackB 0:04691de55153 426 font = f;
JackB 0:04691de55153 427 }
JackB 0:04691de55153 428
JackB 0:04691de55153 429 void RGB_Matrix::character(int x, int y, int c) {
JackB 0:04691de55153 430 unsigned int hor,vert,offset,bpl,j,i,b;
JackB 0:04691de55153 431 unsigned char* char_offset;
JackB 0:04691de55153 432 unsigned char z,w;
JackB 0:04691de55153 433
JackB 0:04691de55153 434 if ((c < 31) || (c > 127)) return; // test char range
JackB 0:04691de55153 435
JackB 0:04691de55153 436 // read font parameter from start of array
JackB 0:04691de55153 437 offset = font[BYTESPERCHAR]; // bytes / char
JackB 0:04691de55153 438 hor = font[FONTWIDTH]; // get hor size of font
JackB 0:04691de55153 439 vert = font[FONTHEIGHT]; // get vert size of font
JackB 0:04691de55153 440 bpl = font[BYTESPERLINE]; // bytes per vertical line
JackB 0:04691de55153 441
JackB 0:04691de55153 442 if (char_x + hor > width()) {
JackB 0:04691de55153 443 // the next character doesn't fit on the same line
JackB 0:04691de55153 444 char_x = 0;
JackB 0:04691de55153 445 char_y = char_y + vert;
JackB 0:04691de55153 446 if (char_y > height() - font[FONTHEIGHT]) {
JackB 0:04691de55153 447 // the next line doesn't fit at the bottom of the screen
JackB 0:04691de55153 448 char_y = 0;
JackB 0:04691de55153 449 }
JackB 0:04691de55153 450 }
JackB 0:04691de55153 451
JackB 0:04691de55153 452 // window(char_x, char_y,hor,vert); // char box
JackB 0:04691de55153 453
JackB 0:04691de55153 454 char_offset = &font[((c -32) * offset) + 4]; // start of char bitmap
JackB 0:04691de55153 455 w = char_offset[0]; // width of actual char
JackB 0:04691de55153 456 for (j=0; j<vert; j++) { // vert line
JackB 0:04691de55153 457 for (i=0; i<hor; i++) { // horz line
JackB 0:04691de55153 458 z = char_offset[bpl * i + ((j & 0xF8) >> 3)+1];
JackB 0:04691de55153 459 b = 1 << (j & 0x07);
JackB 0:04691de55153 460 if (( z & b ) == 0x00) {
JackB 0:04691de55153 461 drawPixel(char_x + i, char_y + j, _background); // background
JackB 0:04691de55153 462 } else {
JackB 0:04691de55153 463 drawPixel(char_x + i, char_y + j, _foreground); // foreground
JackB 0:04691de55153 464 }
JackB 0:04691de55153 465 }
JackB 0:04691de55153 466 }
JackB 0:04691de55153 467 // WindowMax();
JackB 0:04691de55153 468 if ((w + 2) < hor) { // x offset to next char
JackB 0:04691de55153 469 char_x += w + 2;
JackB 0:04691de55153 470 } else char_x += hor;
JackB 0:04691de55153 471 }
JackB 0:04691de55153 472
JackB 0:04691de55153 473 int RGB_Matrix::putc(int value) {
JackB 0:04691de55153 474 if (value == '\n') { // new line
JackB 0:04691de55153 475 char_x = 0;
JackB 0:04691de55153 476 char_y = char_y + font[FONTHEIGHT];
JackB 0:04691de55153 477 if (char_y >= height() - font[FONTHEIGHT]) {
JackB 0:04691de55153 478 char_y = 0;
JackB 0:04691de55153 479 }
JackB 0:04691de55153 480 } else {
JackB 0:04691de55153 481 character(char_x, char_y, value);
JackB 0:04691de55153 482 }
JackB 0:04691de55153 483 return value;
JackB 0:04691de55153 484 }
JackB 0:04691de55153 485
JackB 0:04691de55153 486 void RGB_Matrix::printString(char *string) {
JackB 0:04691de55153 487 for (uint8_t i = 0; i < strlen(string); i++) {
JackB 0:04691de55153 488 putc(string[i]);
JackB 0:04691de55153 489 }
JackB 0:04691de55153 490 }
JackB 0:04691de55153 491
JackB 0:04691de55153 492 void RGB_Matrix::printStringCenter(char *string) {
JackB 0:04691de55153 493 uint8_t pwidth = strlen(string) * font[FONTWIDTH] - 1;
JackB 0:04691de55153 494 locatePixelX((width() - pwidth) / 2);
JackB 0:04691de55153 495 for (uint8_t i = 0; i < strlen(string); i++) {
JackB 0:04691de55153 496 putc(string[i]);
JackB 0:04691de55153 497 }
JackB 0:04691de55153 498 }
JackB 0:04691de55153 499
JackB 0:04691de55153 500 void RGB_Matrix::foreground(uint16_t colour) {
JackB 0:04691de55153 501 _foreground = colour;
JackB 0:04691de55153 502 }
JackB 0:04691de55153 503
JackB 0:04691de55153 504 void RGB_Matrix::background(uint16_t colour) {
JackB 0:04691de55153 505 _background = colour;
JackB 0:04691de55153 506 }
JackB 0:04691de55153 507
JackB 0:04691de55153 508 int RGB_Matrix::width() {
JackB 0:04691de55153 509 if (_orientation == 0 || _orientation == 2) return WIDTH;
JackB 0:04691de55153 510 else return HEIGHT;
JackB 0:04691de55153 511 }
JackB 0:04691de55153 512
JackB 0:04691de55153 513 int RGB_Matrix::height() {
JackB 0:04691de55153 514 if (_orientation == 0 || _orientation == 2) return HEIGHT;
JackB 0:04691de55153 515 else return WIDTH;
JackB 0:04691de55153 516 }
JackB 0:04691de55153 517
JackB 0:04691de55153 518 void RGB_Matrix::SetOrientation(uint8_t orientation) {
JackB 0:04691de55153 519 _orientation = orientation;
JackB 0:04691de55153 520 }
JackB 0:04691de55153 521
JackB 0:04691de55153 522 void RGB_Matrix::locate(uint8_t x, uint8_t y) {
JackB 0:04691de55153 523 char_x = x * font[FONTHEIGHT];
JackB 0:04691de55153 524 char_y = y * font[FONTHEIGHT];
JackB 0:04691de55153 525 }
JackB 0:04691de55153 526
JackB 0:04691de55153 527 void RGB_Matrix::locatePixelX(uint8_t x) {
JackB 0:04691de55153 528 char_x = x;
JackB 0:04691de55153 529 }
JackB 0:04691de55153 530
JackB 0:04691de55153 531 void RGB_Matrix::locatePixelY(uint8_t y) {
JackB 0:04691de55153 532 char_y = y;
JackB 0:04691de55153 533 }
JackB 0:04691de55153 534
JackB 0:04691de55153 535 int RGB_Matrix::columns() {
JackB 0:04691de55153 536 return width() / font[FONTHEIGHT];
JackB 0:04691de55153 537 }
JackB 0:04691de55153 538
JackB 0:04691de55153 539 int RGB_Matrix::rows() {
JackB 0:04691de55153 540 return height() / font[FONTHEIGHT];
JackB 0:04691de55153 541 }
JackB 0:04691de55153 542
JackB 0:04691de55153 543 void RGB_Matrix::setDisplayBuffer(uint8_t Buffer) {
JackB 0:04691de55153 544 bufferDisplay = Buffer;
JackB 0:04691de55153 545 }
JackB 0:04691de55153 546
JackB 0:04691de55153 547 void RGB_Matrix::setWriteBuffer(uint8_t Buffer) {
JackB 0:04691de55153 548 bufferWrite = Buffer;
JackB 0:04691de55153 549 }
JackB 0:04691de55153 550
JackB 0:04691de55153 551 void RGB_Matrix::updateDisplay2(void) {
JackB 0:04691de55153 552 _Pin_OE = 1; // Disable LED output during row/plane switchover
JackB 0:04691de55153 553 _Pin_LAT = 1; // Latch data loaded during *prior* interrupt
JackB 0:04691de55153 554 _Pin_A = (row & 0x01);
JackB 0:04691de55153 555 _Pin_B = (row & 0x02) >> 1;
JackB 0:04691de55153 556 _Pin_C = (row & 0x04) >> 2;
JackB 0:04691de55153 557 _Pin_D = (row & 0x08) >> 3;
JackB 0:04691de55153 558 _Pin_OE = 0; // Re-enable output
JackB 0:04691de55153 559 _Pin_LAT = 0; // Latch down
JackB 0:04691de55153 560
JackB 0:04691de55153 561 if(++plane >= PLANES) { // Advance plane counter. Maxed out?
JackB 0:04691de55153 562 plane = 0; // Yes, reset to plane 0, and
JackB 0:04691de55153 563 }
JackB 0:04691de55153 564 if(++row >= ROWS) { // advance row counter. Maxed out?
JackB 0:04691de55153 565 row = 0; // Yes, reset row counter, then...
JackB 0:04691de55153 566 }
JackB 0:04691de55153 567
JackB 0:04691de55153 568 buffptr = matrixbuff[bufferDisplay]; // Set first buffer
JackB 0:04691de55153 569
JackB 0:04691de55153 570 for(int x = 0; x < WIDTH; x++) {
JackB 0:04691de55153 571 int16_t BufferIndex1 = x + row * WIDTH;
JackB 0:04691de55153 572 int16_t BufferIndex2 = BufferIndex1 + ROWS * WIDTH;
JackB 0:04691de55153 573
JackB 0:04691de55153 574 uint8_t PixelValueR1 = buffptr[BufferIndex1] & 0x03;
JackB 0:04691de55153 575 uint8_t PixelValueG1 = (buffptr[BufferIndex1] >> 2) & 0x03;
JackB 0:04691de55153 576 uint8_t PixelValueB1 = (buffptr[BufferIndex1] >> 4) & 0x03;
JackB 0:04691de55153 577 uint8_t PixelValueR2 = buffptr[BufferIndex2] & 0x03;
JackB 0:04691de55153 578 uint8_t PixelValueG2 = (buffptr[BufferIndex2] >> 2) & 0x03;
JackB 0:04691de55153 579 uint8_t PixelValueB2 = (buffptr[BufferIndex2] >> 4) & 0x03;
JackB 0:04691de55153 580
JackB 0:04691de55153 581 if (PixelValueR1 >= plane+1) {
JackB 0:04691de55153 582 _Pin_R1 = 1;
JackB 0:04691de55153 583 } else {
JackB 0:04691de55153 584 _Pin_R1 = 0;
JackB 0:04691de55153 585 }
JackB 0:04691de55153 586 if (PixelValueG1 >= plane+1) {
JackB 0:04691de55153 587 _Pin_G1 = 1;
JackB 0:04691de55153 588 } else {
JackB 0:04691de55153 589 _Pin_G1 = 0;
JackB 0:04691de55153 590 }
JackB 0:04691de55153 591 if (PixelValueB1 >= plane+1) {
JackB 0:04691de55153 592 _Pin_B1 = 1;
JackB 0:04691de55153 593 } else {
JackB 0:04691de55153 594 _Pin_B1 = 0;
JackB 0:04691de55153 595 }
JackB 0:04691de55153 596
JackB 0:04691de55153 597 if (PixelValueR2 >= plane+1) {
JackB 0:04691de55153 598 _Pin_R2 = 1;
JackB 0:04691de55153 599 } else {
JackB 0:04691de55153 600 _Pin_R2 = 0;
JackB 0:04691de55153 601 }
JackB 0:04691de55153 602 if (PixelValueG2 >= plane+1) {
JackB 0:04691de55153 603 _Pin_G2 = 1;
JackB 0:04691de55153 604 } else {
JackB 0:04691de55153 605 _Pin_G2 = 0;
JackB 0:04691de55153 606 }
JackB 0:04691de55153 607 if (PixelValueB2 >= plane+1) {
JackB 0:04691de55153 608 _Pin_B2 = 1;
JackB 0:04691de55153 609 } else {
JackB 0:04691de55153 610 _Pin_B2 = 0;
JackB 0:04691de55153 611 }
JackB 0:04691de55153 612
JackB 0:04691de55153 613 _Pin_CLK = 0; // Clock low
JackB 0:04691de55153 614 _Pin_CLK = 1; // Clock high
JackB 0:04691de55153 615 }
JackB 0:04691de55153 616 }
JackB 0:04691de55153 617
JackB 0:04691de55153 618 void RGB_Matrix::updateDisplay(void) {
JackB 0:04691de55153 619 _Pin_OE = 1; // Disable LED output during row/plane switchover
JackB 0:04691de55153 620 _Pin_LAT = 1; // Latch data loaded during *prior* interrupt
JackB 0:04691de55153 621 _Pin_A = row & 0x01;
JackB 0:04691de55153 622 _Pin_B = (row >> 1) & 0x01;
JackB 0:04691de55153 623 _Pin_C = (row >> 2) & 0x01;
JackB 0:04691de55153 624 _Pin_D = (row >> 3) & 0x01;
JackB 0:04691de55153 625 _Pin_OE = 0; // Re-enable output
JackB 0:04691de55153 626 _Pin_LAT = 0; // Latch down
JackB 0:04691de55153 627
JackB 0:04691de55153 628 if(++plane >= PLANES) { // Advance plane counter. Maxed out?
JackB 0:04691de55153 629 plane = 0; // Yes, reset to plane 0, and
JackB 0:04691de55153 630 if(++row >= ROWS) { // advance row counter. Maxed out?
JackB 0:04691de55153 631 row = 0; // Yes, reset row counter, then...
JackB 0:04691de55153 632 }
JackB 0:04691de55153 633 }
JackB 0:04691de55153 634
JackB 0:04691de55153 635 buffptr = matrixbuff[bufferDisplay]; // Set display buffer
JackB 0:04691de55153 636 for(uint8_t x = 0; x < WIDTH; x++) {
JackB 0:04691de55153 637 uint16_t BufferIndex = x + row * WIDTH + plane * PIXELS;
JackB 0:04691de55153 638 _Pin_R1 = buffptr[BufferIndex] & 0x01;
JackB 0:04691de55153 639 _Pin_G1 = (buffptr[BufferIndex] >> 1) & 0x01;
JackB 0:04691de55153 640 _Pin_B1 = (buffptr[BufferIndex] >> 2) & 0x01;
JackB 0:04691de55153 641 _Pin_R2 = (buffptr[BufferIndex] >> 4) & 0x01;
JackB 0:04691de55153 642 _Pin_G2 = (buffptr[BufferIndex] >> 5) & 0x01;
JackB 0:04691de55153 643 _Pin_B2 = (buffptr[BufferIndex] >> 6) & 0x01;
JackB 0:04691de55153 644 _Pin_CLK = 0; // Clock low
JackB 0:04691de55153 645 _Pin_CLK = 1; // Clock high
JackB 0:04691de55153 646 }
JackB 0:04691de55153 647 }