ohararp / Mbed 2 deprecated WS2811_RY_32x48_ConwayA

Code used in RGB-123 Kickstarter. Conways Game of Life

Dependencies:   WS2811_RY_A mbed

Fork of WS2811_RY_A by ohararp@...

main.cpp@1:1b91ef74cc9c, 2013-08-15 (annotated)

Committer:
ohararp
Date:
Thu Aug 15 20:22:48 2013 +0000
Revision:
1:1b91ef74cc9c
Parent:
0:f19c80146d55 
Code used in RGB-123 Kickstarter Video

Who changed what in which revision?

UserRevisionLine numberNew contents of line
ohararp 0:f19c80146d55 1 #include "mbed.h"
ohararp 1:1b91ef74cc9c 2 #include "matrix.h"
ohararp 0:f19c80146d55 3 Serial pc(USBTX, USBRX);
ohararp 0:f19c80146d55 4 DigitalOut dat(p5);
ohararp 1:1b91ef74cc9c 5 DigitalOut bLed(LED1);
ohararp 0:f19c80146d55 6
ohararp 0:f19c80146d55 7 //*******************************************************************************
ohararp 0:f19c80146d55 8 // DEFINE WS2811 Strip Parameters
ohararp 1:1b91ef74cc9c 9 #define numLEDs 1536
ohararp 1:1b91ef74cc9c 10 #define BrightMax 64
ohararp 1:1b91ef74cc9c 11 #define BrightMin 0
ohararp 1:1b91ef74cc9c 12
ohararp 1:1b91ef74cc9c 13 #define ROWS_LEDs 32 // LED_LAYOUT assumed 0 if ROWS_LEDs > 8
ohararp 1:1b91ef74cc9c 14 #define COLS_LEDs 48 // all of the following params need to be adjusted for screen size
ohararp 1:1b91ef74cc9c 15
ohararp 1:1b91ef74cc9c 16
ohararp 1:1b91ef74cc9c 17 uint8_t RandRed;
ohararp 1:1b91ef74cc9c 18 uint8_t RandGrn;
ohararp 1:1b91ef74cc9c 19 uint8_t RandBlu;
ohararp 1:1b91ef74cc9c 20
ohararp 1:1b91ef74cc9c 21 uint8_t pixels[numLEDs*3];
ohararp 0:f19c80146d55 22 Timer guardtime;
ohararp 0:f19c80146d55 23 uint32_t bogocal;
ohararp 1:1b91ef74cc9c 24 //*******************************************************************************
ohararp 1:1b91ef74cc9c 25 //Byte val 2PI Cosine Wave, offset by 1 PI
ohararp 1:1b91ef74cc9c 26 //supports fast trig calcs and smooth LED fading/pulsing.
ohararp 1:1b91ef74cc9c 27 uint8_t cos_wave[256] =
ohararp 1:1b91ef74cc9c 28 {0,0,0,0,1,1,1,2,2,3,4,5,6,6,8,9,10,11,12,14,15,17,18,20,22,23,25,27,29,31,33,35,38,40,42,
ohararp 1:1b91ef74cc9c 29 45,47,49,52,54,57,60,62,65,68,71,73,76,79,82,85,88,91,94,97,100,103,106,109,113,116,119,
ohararp 1:1b91ef74cc9c 30 122,125,128,131,135,138,141,144,147,150,153,156,159,162,165,168,171,174,177,180,183,186,
ohararp 1:1b91ef74cc9c 31 189,191,194,197,199,202,204,207,209,212,214,216,218,221,223,225,227,229,231,232,234,236,
ohararp 1:1b91ef74cc9c 32 238,239,241,242,243,245,246,247,248,249,250,251,252,252,253,253,254,254,255,255,255,255,
ohararp 1:1b91ef74cc9c 33 255,255,255,255,254,254,253,253,252,252,251,250,249,248,247,246,245,243,242,241,239,238,
ohararp 1:1b91ef74cc9c 34 236,234,232,231,229,227,225,223,221,218,216,214,212,209,207,204,202,199,197,194,191,189,
ohararp 1:1b91ef74cc9c 35 186,183,180,177,174,171,168,165,162,159,156,153,150,147,144,141,138,135,131,128,125,122,
ohararp 1:1b91ef74cc9c 36 119,116,113,109,106,103,100,97,94,91,88,85,82,79,76,73,71,68,65,62,60,57,54,52,49,47,45,
ohararp 1:1b91ef74cc9c 37 42,40,38,35,33,31,29,27,25,23,22,20,18,17,15,14,12,11,10,9,8,6,6,5,4,3,2,2,1,1,1,0,0,0,0
ohararp 1:1b91ef74cc9c 38 };
ohararp 0:f19c80146d55 39
ohararp 1:1b91ef74cc9c 40
ohararp 1:1b91ef74cc9c 41 //Gamma Correction Curve
ohararp 1:1b91ef74cc9c 42 uint8_t exp_gamma[256] =
ohararp 1:1b91ef74cc9c 43 {0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2,2,2,2,2,2,2,2,2,3,3,3,3,3,
ohararp 1:1b91ef74cc9c 44 4,4,4,4,4,5,5,5,5,5,6,6,6,7,7,7,7,8,8,8,9,9,9,10,10,10,11,11,12,12,12,13,13,14,14,14,15,15,
ohararp 1:1b91ef74cc9c 45 16,16,17,17,18,18,19,19,20,20,21,21,22,23,23,24,24,25,26,26,27,28,28,29,30,30,31,32,32,33,
ohararp 1:1b91ef74cc9c 46 34,35,35,36,37,38,39,39,40,41,42,43,44,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,
ohararp 1:1b91ef74cc9c 47 61,62,63,64,65,66,67,68,70,71,72,73,74,75,77,78,79,80,82,83,84,85,87,89,91,92,93,95,96,98,
ohararp 1:1b91ef74cc9c 48 99,100,101,102,105,106,108,109,111,112,114,115,117,118,120,121,123,125,126,128,130,131,133,
ohararp 1:1b91ef74cc9c 49 135,136,138,140,142,143,145,147,149,151,152,154,156,158,160,162,164,165,167,169,171,173,175,
ohararp 1:1b91ef74cc9c 50 177,179,181,183,185,187,190,192,194,196,198,200,202,204,207,209,211,213,216,218,220,222,225,
ohararp 1:1b91ef74cc9c 51 227,229,232,234,236,239,241,244,246,249,251,253,254,255
ohararp 1:1b91ef74cc9c 52 };
ohararp 0:f19c80146d55 53 //*******************************************************************************
ohararp 0:f19c80146d55 54 void setup () {
ohararp 1:1b91ef74cc9c 55 /*if ((pixels = (uint8_t *)malloc(numLEDs * 3))) {
ohararp 0:f19c80146d55 56 memset(pixels, 0x00, numLEDs * 3); // Init to RGB 'off' state
ohararp 1:1b91ef74cc9c 57 }*/
ohararp 1:1b91ef74cc9c 58
ohararp 1:1b91ef74cc9c 59 for (int j=0; j<numLEDs*3; j++) {
ohararp 1:1b91ef74cc9c 60 pixels[j]=0x00;
ohararp 0:f19c80146d55 61 }
ohararp 1:1b91ef74cc9c 62
ohararp 0:f19c80146d55 63 // calibrate delay loops for NRZ
ohararp 0:f19c80146d55 64 int i;
ohararp 0:f19c80146d55 65 guardtime.start();
ohararp 0:f19c80146d55 66 for (i=0; i<1000; i++)
ohararp 0:f19c80146d55 67 /* do nothing */;
ohararp 0:f19c80146d55 68 i=guardtime.read_us();
ohararp 0:f19c80146d55 69 printf("ws2811: 1000 iters took %d usec.\n", i);
ohararp 1:1b91ef74cc9c 70 bogocal = (1000 / (i*10)); // iterations per bitcell (417 nsec)
ohararp 1:1b91ef74cc9c 71 bogocal = 1;
ohararp 0:f19c80146d55 72 printf("ws2811: calibrating to %d bogojiffies.\n", bogocal);
ohararp 0:f19c80146d55 73 }
ohararp 0:f19c80146d55 74 //*******************************************************************************
ohararp 0:f19c80146d55 75 inline void celldelay(void) {
ohararp 0:f19c80146d55 76 for (int i = 0; i<bogocal; i++)
ohararp 0:f19c80146d55 77 /* do nothing */ ;
ohararp 0:f19c80146d55 78 }
ohararp 0:f19c80146d55 79 //*******************************************************************************
ohararp 0:f19c80146d55 80 void writebit(bool bit) {
ohararp 0:f19c80146d55 81 // first cell is always 1
ohararp 0:f19c80146d55 82 dat = 1;
ohararp 0:f19c80146d55 83 celldelay();
ohararp 0:f19c80146d55 84 if (bit) {
ohararp 0:f19c80146d55 85 celldelay();
ohararp 0:f19c80146d55 86 } else {
ohararp 0:f19c80146d55 87 dat=0;
ohararp 0:f19c80146d55 88 celldelay();
ohararp 0:f19c80146d55 89 }
ohararp 0:f19c80146d55 90 // last cell is always 0
ohararp 0:f19c80146d55 91 dat=0;
ohararp 0:f19c80146d55 92 celldelay();
ohararp 0:f19c80146d55 93 }
ohararp 0:f19c80146d55 94 //*******************************************************************************
ohararp 0:f19c80146d55 95 void write(uint8_t byte) {
ohararp 0:f19c80146d55 96 __disable_irq();
ohararp 0:f19c80146d55 97 for (int i=0; i<8; i++) {
ohararp 0:f19c80146d55 98 if (byte & 0x80)
ohararp 0:f19c80146d55 99 writebit(1);
ohararp 0:f19c80146d55 100 else
ohararp 0:f19c80146d55 101 writebit(0);
ohararp 0:f19c80146d55 102 byte <<= 1;
ohararp 0:f19c80146d55 103 }
ohararp 0:f19c80146d55 104 __enable_irq();
ohararp 0:f19c80146d55 105 }
ohararp 0:f19c80146d55 106
ohararp 0:f19c80146d55 107 uint16_t numPixels(void) {
ohararp 0:f19c80146d55 108 return numLEDs;
ohararp 0:f19c80146d55 109 }
ohararp 0:f19c80146d55 110
ohararp 0:f19c80146d55 111 //*******************************************************************************
ohararp 0:f19c80146d55 112 void show(void) {
ohararp 0:f19c80146d55 113 uint16_t i, nl3 = numLEDs * 3; // 3 bytes per LED
ohararp 0:f19c80146d55 114 while (guardtime.read_us() < 50)
ohararp 0:f19c80146d55 115 /* spin */;
ohararp 0:f19c80146d55 116 for (i=0; i<nl3; i++ ) {
ohararp 0:f19c80146d55 117 write(pixels[i]);
ohararp 0:f19c80146d55 118 }
ohararp 0:f19c80146d55 119 guardtime.reset();
ohararp 0:f19c80146d55 120 }
ohararp 0:f19c80146d55 121 //*******************************************************************************
ohararp 0:f19c80146d55 122 void blank(void) {
ohararp 1:1b91ef74cc9c 123 for (int i=0; i<numLEDs*3; i++) {
ohararp 1:1b91ef74cc9c 124 pixels[i]=0x00;
ohararp 1:1b91ef74cc9c 125 }
ohararp 0:f19c80146d55 126 show();
ohararp 0:f19c80146d55 127 }
ohararp 0:f19c80146d55 128 //*******************************************************************************
ohararp 0:f19c80146d55 129 void blankDelay(int n) {
ohararp 1:1b91ef74cc9c 130 for (int i=0; i<numLEDs*3; i++) {
ohararp 1:1b91ef74cc9c 131 pixels[i]=0x00;
ohararp 1:1b91ef74cc9c 132 }
ohararp 0:f19c80146d55 133 show();
ohararp 0:f19c80146d55 134 wait_ms(n);
ohararp 0:f19c80146d55 135 }
ohararp 0:f19c80146d55 136 //*******************************************************************************
ohararp 0:f19c80146d55 137 uint32_t total_luminance(void) {
ohararp 0:f19c80146d55 138 uint32_t running_total;
ohararp 0:f19c80146d55 139 running_total = 0;
ohararp 0:f19c80146d55 140 for (int i=0; i<numLEDs*3; i++)
ohararp 0:f19c80146d55 141 running_total += pixels[i];
ohararp 0:f19c80146d55 142 return running_total;
ohararp 0:f19c80146d55 143 }
ohararp 0:f19c80146d55 144 //*******************************************************************************
ohararp 0:f19c80146d55 145 // Convert R,G,B to combined 32-bit color
ohararp 0:f19c80146d55 146 uint32_t Color(uint8_t r, uint8_t g, uint8_t b) {
ohararp 0:f19c80146d55 147 // Take the lowest 7 bits of each value and append them end to end
ohararp 0:f19c80146d55 148 // We have the top bit set high (its a 'parity-like' bit in the protocol
ohararp 0:f19c80146d55 149 // and must be set!)
ohararp 0:f19c80146d55 150 return ((uint32_t)g << 16) | ((uint32_t)r << 8) | (uint32_t)b;
ohararp 0:f19c80146d55 151 }
ohararp 0:f19c80146d55 152 //*******************************************************************************
ohararp 0:f19c80146d55 153 // store the rgb component in our array
ohararp 0:f19c80146d55 154 void setPixelColor(uint16_t n, uint8_t r, uint8_t g, uint8_t b) {
ohararp 0:f19c80146d55 155 if (n >= numLEDs) return; // '>=' because arrays are 0-indexed
ohararp 0:f19c80146d55 156 pixels[n*3 ] = g;
ohararp 0:f19c80146d55 157 pixels[n*3+1] = r;
ohararp 0:f19c80146d55 158 pixels[n*3+2] = b;
ohararp 0:f19c80146d55 159 //pc.printf("setPixelColor-4 inputs\n");
ohararp 0:f19c80146d55 160 }
ohararp 0:f19c80146d55 161 //*******************************************************************************
ohararp 0:f19c80146d55 162 void setPixelR(uint16_t n, uint8_t r) {
ohararp 0:f19c80146d55 163 if (n >= numLEDs) return; // '>=' because arrays are 0-indexed
ohararp 0:f19c80146d55 164 pixels[n*3+1] = r;
ohararp 0:f19c80146d55 165 }
ohararp 0:f19c80146d55 166 //*******************************************************************************
ohararp 0:f19c80146d55 167 void setPixelG(uint16_t n, uint8_t g) {
ohararp 0:f19c80146d55 168 if (n >= numLEDs) return; // '>=' because arrays are 0-indexed
ohararp 0:f19c80146d55 169 pixels[n*3] = g;
ohararp 0:f19c80146d55 170 }
ohararp 0:f19c80146d55 171 //*******************************************************************************
ohararp 0:f19c80146d55 172 void setPixelB(uint16_t n, uint8_t b) {
ohararp 0:f19c80146d55 173 if (n >= numLEDs) return; // '>=' because arrays are 0-indexed
ohararp 0:f19c80146d55 174 pixels[n*3+2] = b;
ohararp 0:f19c80146d55 175 }
ohararp 0:f19c80146d55 176 //*******************************************************************************
ohararp 0:f19c80146d55 177 void setPixelColor(uint16_t n, uint32_t c) {
ohararp 0:f19c80146d55 178 if (n >= numLEDs) return; // '>=' because arrays are 0-indexed
ohararp 0:f19c80146d55 179 pixels[n*3 ] = (c >> 16);
ohararp 0:f19c80146d55 180 pixels[n*3+1] = (c >> 8);
ohararp 0:f19c80146d55 181 pixels[n*3+2] = c;
ohararp 0:f19c80146d55 182 //pc.printf("setPixelColor-2 inputs\n");
ohararp 0:f19c80146d55 183 }
ohararp 0:f19c80146d55 184 //*******************************************************************************
ohararp 0:f19c80146d55 185 // Fill the dots one after the other with a color
ohararp 0:f19c80146d55 186 void colorWipe(uint32_t c, uint8_t wait) {
ohararp 0:f19c80146d55 187 for(uint16_t i=0; i<numPixels(); i++) {
ohararp 1:1b91ef74cc9c 188 setPixelColor(Matrix[i], c);
ohararp 0:f19c80146d55 189 show();
ohararp 0:f19c80146d55 190 wait_ms(wait);
ohararp 0:f19c80146d55 191 }
ohararp 0:f19c80146d55 192 }
ohararp 0:f19c80146d55 193 //*******************************************************************************
ohararp 1:1b91ef74cc9c 194 // Fill the dots one after the other with a color
ohararp 1:1b91ef74cc9c 195 void colorAll(uint32_t c, uint16_t wait) {
ohararp 1:1b91ef74cc9c 196 for(uint16_t i=0; i<numPixels(); i++) {
ohararp 1:1b91ef74cc9c 197 setPixelColor(Matrix[i], c);
ohararp 1:1b91ef74cc9c 198 }
ohararp 1:1b91ef74cc9c 199 show();
ohararp 1:1b91ef74cc9c 200 wait_ms(wait);
ohararp 1:1b91ef74cc9c 201 }
ohararp 1:1b91ef74cc9c 202
ohararp 1:1b91ef74cc9c 203 //*******************************************************************************
ohararp 1:1b91ef74cc9c 204 // Fill the dots one after the other with a color
ohararp 1:1b91ef74cc9c 205 void RandOne(uint8_t MaxRand, uint16_t wait) {
ohararp 1:1b91ef74cc9c 206 for(uint16_t i=0; i<numPixels(); i++) {
ohararp 1:1b91ef74cc9c 207 setPixelColor(Matrix[rand() % numLEDs-1], rand() % MaxRand,rand() % MaxRand,rand() % MaxRand);
ohararp 1:1b91ef74cc9c 208 show();
ohararp 1:1b91ef74cc9c 209 wait_ms(wait);
ohararp 1:1b91ef74cc9c 210 }
ohararp 1:1b91ef74cc9c 211
ohararp 1:1b91ef74cc9c 212 }
ohararp 1:1b91ef74cc9c 213 //*******************************************************************************
ohararp 1:1b91ef74cc9c 214 // Fill the dots one after the other with a color
ohararp 1:1b91ef74cc9c 215 void RandAll(uint8_t MaxRand, uint16_t wait) {
ohararp 1:1b91ef74cc9c 216 for(uint16_t i=0; i<numPixels(); i++) {
ohararp 1:1b91ef74cc9c 217 setPixelColor(Matrix[i], rand() % MaxRand,rand() % MaxRand,rand() % MaxRand);
ohararp 1:1b91ef74cc9c 218 }
ohararp 1:1b91ef74cc9c 219 show();
ohararp 1:1b91ef74cc9c 220 wait_ms(wait);
ohararp 1:1b91ef74cc9c 221 }
ohararp 1:1b91ef74cc9c 222 //*******************************************************************************
ohararp 0:f19c80146d55 223 // Input a value 0 to 255 to get a color value.
ohararp 0:f19c80146d55 224 // The colours are a transition r - g - b - back to r.
ohararp 0:f19c80146d55 225 uint32_t Wheel(int WheelPos) {
ohararp 0:f19c80146d55 226 if(WheelPos < 85) {
ohararp 0:f19c80146d55 227 return Color(WheelPos * 3, 255 - WheelPos * 3, 0);
ohararp 0:f19c80146d55 228 } else if(WheelPos < 170) {
ohararp 0:f19c80146d55 229 WheelPos -= 85;
ohararp 0:f19c80146d55 230 return Color(255 - WheelPos * 3, 0, WheelPos * 3);
ohararp 0:f19c80146d55 231 } else {
ohararp 0:f19c80146d55 232 WheelPos -= 170;
ohararp 0:f19c80146d55 233 return Color(0, WheelPos * 3, 255 - WheelPos * 3);
ohararp 0:f19c80146d55 234 }
ohararp 0:f19c80146d55 235 }
ohararp 0:f19c80146d55 236 //*******************************************************************************
ohararp 0:f19c80146d55 237 void rainbow(uint8_t rwait) {
ohararp 0:f19c80146d55 238 uint16_t i, j;
ohararp 0:f19c80146d55 239
ohararp 0:f19c80146d55 240 for(j=0; j<256; j++) {
ohararp 0:f19c80146d55 241 for(i=0; i<numPixels(); i++) {
ohararp 0:f19c80146d55 242 setPixelColor(i, Wheel((i+j) & 255));
ohararp 0:f19c80146d55 243 }
ohararp 0:f19c80146d55 244 show();
ohararp 0:f19c80146d55 245 wait_ms(rwait);
ohararp 0:f19c80146d55 246 }
ohararp 0:f19c80146d55 247 }
ohararp 0:f19c80146d55 248 //*******************************************************************************
ohararp 0:f19c80146d55 249 // Slightly different, this makes the rainbow equally distributed throughout
ohararp 0:f19c80146d55 250 void rainbowCycle(uint8_t rwait) {
ohararp 0:f19c80146d55 251 uint16_t i, j;
ohararp 0:f19c80146d55 252
ohararp 0:f19c80146d55 253 for(j=0; j<256*5; j++) { // 5 cycles of all colors on wheel
ohararp 0:f19c80146d55 254 for(i=0; i< numPixels(); i++) {
ohararp 0:f19c80146d55 255 setPixelColor(i, Wheel(((i * 256 / numPixels()) + j) & 255));
ohararp 0:f19c80146d55 256 }
ohararp 0:f19c80146d55 257 show();
ohararp 0:f19c80146d55 258 wait_ms(rwait);
ohararp 0:f19c80146d55 259 }
ohararp 0:f19c80146d55 260 }
ohararp 0:f19c80146d55 261 //*******************************************************************************
ohararp 1:1b91ef74cc9c 262 void Ring(int RingArray[], uint8_t r, uint8_t g, uint8_t b, uint8_t RingWait) {
ohararp 1:1b91ef74cc9c 263
ohararp 1:1b91ef74cc9c 264 for (int i=1;i<RingArray[0];++i) {
ohararp 1:1b91ef74cc9c 265 setPixelColor(RingArray[i], r, g, b);
ohararp 1:1b91ef74cc9c 266 //pc.printf("RingArray[%d,%d]\n",RingArray[i],RingArray[0]);
ohararp 1:1b91ef74cc9c 267 }
ohararp 1:1b91ef74cc9c 268 show();
ohararp 1:1b91ef74cc9c 269 wait_ms(RingWait);
ohararp 1:1b91ef74cc9c 270 }
ohararp 1:1b91ef74cc9c 271 //*******************************************************************************
ohararp 1:1b91ef74cc9c 272 void RingFadeUp(int RingArray[], uint8_t r, uint8_t g, uint8_t b, uint8_t FadeSteps, uint8_t FadeTime, uint16_t RingWait) {
ohararp 1:1b91ef74cc9c 273 uint8_t rBump, gBump, bBump;
ohararp 1:1b91ef74cc9c 274 uint8_t rStep, gStep, bStep;
ohararp 1:1b91ef74cc9c 275
ohararp 1:1b91ef74cc9c 276 rStep = r/FadeSteps; if(rStep == 0) {rStep = 1;}
ohararp 1:1b91ef74cc9c 277 gStep = g/FadeSteps; if(gStep == 0) {gStep = 1;}
ohararp 1:1b91ef74cc9c 278 bStep = b/FadeSteps; if(bStep == 0) {bStep = 1;}
ohararp 1:1b91ef74cc9c 279
ohararp 1:1b91ef74cc9c 280 rBump = 0;
ohararp 1:1b91ef74cc9c 281 gBump = 0;
ohararp 1:1b91ef74cc9c 282 bBump = 0;
ohararp 1:1b91ef74cc9c 283
ohararp 1:1b91ef74cc9c 284 for (int j=0;j<FadeSteps;++j) {
ohararp 1:1b91ef74cc9c 285 rBump += rStep; if(rBump > BrightMax) {rBump = 0;} //Account for Int rollover
ohararp 1:1b91ef74cc9c 286 gBump += gStep; if(gBump > BrightMax) {gBump = 0;} //Account for Int rollover
ohararp 1:1b91ef74cc9c 287 bBump += bStep; if(bBump > BrightMax) {bBump = 0;} //Account for Int rollover
ohararp 1:1b91ef74cc9c 288 for (int i=1;i<RingArray[0];++i) {
ohararp 1:1b91ef74cc9c 289 setPixelColor(RingArray[i], rBump, gBump, bBump);
ohararp 1:1b91ef74cc9c 290 pc.printf("UP [%d,%d %d]\n",rBump, gBump, bBump);
ohararp 1:1b91ef74cc9c 291 }
ohararp 1:1b91ef74cc9c 292 show();
ohararp 1:1b91ef74cc9c 293 wait_ms(FadeTime);
ohararp 1:1b91ef74cc9c 294 };
ohararp 1:1b91ef74cc9c 295 wait_ms(RingWait);
ohararp 1:1b91ef74cc9c 296 }
ohararp 1:1b91ef74cc9c 297 //*******************************************************************************
ohararp 1:1b91ef74cc9c 298 void RingFadeDn(int RingArray[], uint8_t r, uint8_t g, uint8_t b, uint8_t FadeSteps, uint8_t FadeTime, uint16_t RingWait) {
ohararp 1:1b91ef74cc9c 299 uint8_t rBump, gBump, bBump;
ohararp 1:1b91ef74cc9c 300 uint8_t rStep, gStep, bStep;
ohararp 1:1b91ef74cc9c 301
ohararp 1:1b91ef74cc9c 302 rStep = r/FadeSteps; if(rStep == 0) {rStep = 1;}
ohararp 1:1b91ef74cc9c 303 gStep = g/FadeSteps; if(gStep == 0) {gStep = 1;}
ohararp 1:1b91ef74cc9c 304 bStep = b/FadeSteps; if(bStep == 0) {bStep = 1;}
ohararp 1:1b91ef74cc9c 305
ohararp 1:1b91ef74cc9c 306 rBump = r;
ohararp 1:1b91ef74cc9c 307 gBump = g;
ohararp 1:1b91ef74cc9c 308 bBump = b;
ohararp 1:1b91ef74cc9c 309
ohararp 1:1b91ef74cc9c 310 for (int j=0;j<FadeSteps;++j) {
ohararp 1:1b91ef74cc9c 311 rBump -= rStep; if(rBump > BrightMax) {rBump = 0;} //Account for Int rollover
ohararp 1:1b91ef74cc9c 312 gBump -= gStep; if(gBump > BrightMax) {gBump = 0;} //Account for Int rollover
ohararp 1:1b91ef74cc9c 313 bBump -= bStep; if(bBump > BrightMax) {bBump = 0;} //Account for Int rollover
ohararp 1:1b91ef74cc9c 314 for (int i=1;i<RingArray[0];++i) {
ohararp 1:1b91ef74cc9c 315 setPixelColor(RingArray[i], rBump, gBump, bBump);
ohararp 1:1b91ef74cc9c 316 pc.printf("DN [%d,%d %d]\n",rBump, gBump, bBump);
ohararp 1:1b91ef74cc9c 317 }
ohararp 1:1b91ef74cc9c 318 show();
ohararp 1:1b91ef74cc9c 319 wait_ms(FadeTime);
ohararp 1:1b91ef74cc9c 320 };
ohararp 1:1b91ef74cc9c 321 wait_ms(RingWait);
ohararp 1:1b91ef74cc9c 322 }
ohararp 1:1b91ef74cc9c 323 //*******************************************************************************
ohararp 1:1b91ef74cc9c 324 uint8_t ColorRand(void) {
ohararp 1:1b91ef74cc9c 325 return (rand()%(BrightMax-BrightMin)+BrightMin);
ohararp 1:1b91ef74cc9c 326 }
ohararp 1:1b91ef74cc9c 327 //*******************************************************************************
ohararp 1:1b91ef74cc9c 328 inline uint8_t fastCosineCalc( uint16_t preWrapVal)
ohararp 1:1b91ef74cc9c 329 {
ohararp 1:1b91ef74cc9c 330 uint8_t wrapVal = (preWrapVal % 255);
ohararp 1:1b91ef74cc9c 331 if (wrapVal<=0){
ohararp 1:1b91ef74cc9c 332 wrapVal=255+wrapVal;
ohararp 1:1b91ef74cc9c 333 }
ohararp 1:1b91ef74cc9c 334 return cos_wave[wrapVal];
ohararp 1:1b91ef74cc9c 335 }
ohararp 1:1b91ef74cc9c 336 //*******************************************************************************
ohararp 1:1b91ef74cc9c 337 void Plasma()
ohararp 1:1b91ef74cc9c 338 {
ohararp 1:1b91ef74cc9c 339 unsigned long frameCount=25500; // arbitrary seed to calculate the three time displacement variables t,t2,t3
ohararp 1:1b91ef74cc9c 340 while(1) {
ohararp 1:1b91ef74cc9c 341 frameCount++ ; //42 35 38
ohararp 1:1b91ef74cc9c 342 uint16_t t = fastCosineCalc((128 * frameCount)/100); //time displacement - fiddle with these til it looks good...
ohararp 1:1b91ef74cc9c 343 uint16_t t2 = fastCosineCalc((128 * frameCount)/100);
ohararp 1:1b91ef74cc9c 344 uint16_t t3 = fastCosineCalc((128 * frameCount)/100);
ohararp 1:1b91ef74cc9c 345
ohararp 1:1b91ef74cc9c 346 for (uint8_t y = 0; y < ROWS_LEDs; y++) {
ohararp 1:1b91ef74cc9c 347 int left2Right, pixelIndex;
ohararp 1:1b91ef74cc9c 348 if (((y % (ROWS_LEDs/8)) & 1) == 0) {
ohararp 1:1b91ef74cc9c 349 left2Right = 1;
ohararp 1:1b91ef74cc9c 350 pixelIndex = y * COLS_LEDs;
ohararp 1:1b91ef74cc9c 351 } else {
ohararp 1:1b91ef74cc9c 352 left2Right = -1;
ohararp 1:1b91ef74cc9c 353 pixelIndex = (y + 1) * COLS_LEDs - 1;
ohararp 1:1b91ef74cc9c 354 }
ohararp 1:1b91ef74cc9c 355 for (uint8_t x = 0; x < COLS_LEDs ; x++) {
ohararp 1:1b91ef74cc9c 356 //Calculate 3 seperate plasma waves, one for each color channel
ohararp 1:1b91ef74cc9c 357 uint8_t r = fastCosineCalc(((x << 3) + (t >> 1) + fastCosineCalc((t2 + (y << 3)))));
ohararp 1:1b91ef74cc9c 358 uint8_t g = fastCosineCalc(((y << 3) + t + fastCosineCalc(((t3 >> 2) + (x << 3)))));
ohararp 1:1b91ef74cc9c 359 uint8_t b = fastCosineCalc(((y << 3) + t2 + fastCosineCalc((t + x + (g >> 2)))));
ohararp 1:1b91ef74cc9c 360 //uncomment the following to enable gamma correction
ohararp 1:1b91ef74cc9c 361 r=exp_gamma[r];
ohararp 1:1b91ef74cc9c 362 g=exp_gamma[g];
ohararp 1:1b91ef74cc9c 363 b=exp_gamma[b];
ohararp 1:1b91ef74cc9c 364 setPixelColor(Matrix[pixelIndex],r,g,b);
ohararp 1:1b91ef74cc9c 365 //pc.printf("Plasma [%d,%d,%d %d]\n",pixelIndex,r,g,b);
ohararp 1:1b91ef74cc9c 366 pixelIndex += left2Right;
ohararp 1:1b91ef74cc9c 367 }
ohararp 1:1b91ef74cc9c 368 }
ohararp 1:1b91ef74cc9c 369 show();
ohararp 1:1b91ef74cc9c 370 }
ohararp 1:1b91ef74cc9c 371 }
ohararp 1:1b91ef74cc9c 372
ohararp 1:1b91ef74cc9c 373 //*******************************************************************************
ohararp 1:1b91ef74cc9c 374 //http://onehourhacks.blogspot.com/2012/03/conways-game-of-life-on-arduino.html
ohararp 1:1b91ef74cc9c 375 const int ROWS = 48;
ohararp 1:1b91ef74cc9c 376 const int COLS = 32;
ohararp 1:1b91ef74cc9c 377 int boardnum = 0; // number of boards run by the game
ohararp 1:1b91ef74cc9c 378 int iteration = 0; // current round in the current board
ohararp 1:1b91ef74cc9c 379 int numberAround(int row, int col);
ohararp 1:1b91ef74cc9c 380
ohararp 1:1b91ef74cc9c 381 // The "Alive" cells on the board.
ohararp 1:1b91ef74cc9c 382 uint32_t alive[ROWS] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
ohararp 1:1b91ef74cc9c 383
ohararp 1:1b91ef74cc9c 384 //*******************************************************************************
ohararp 1:1b91ef74cc9c 385 bool isAlive(int row, int col)
ohararp 1:1b91ef74cc9c 386 {
ohararp 1:1b91ef74cc9c 387 return alive[row] & (1<<(col));
ohararp 1:1b91ef74cc9c 388 }
ohararp 1:1b91ef74cc9c 389 //*******************************************************************************
ohararp 1:1b91ef74cc9c 390 void setAlive(int row, int col)
ohararp 1:1b91ef74cc9c 391 {
ohararp 1:1b91ef74cc9c 392 alive[row] |= 1 << col;
ohararp 1:1b91ef74cc9c 393 }
ohararp 1:1b91ef74cc9c 394 //*******************************************************************************
ohararp 1:1b91ef74cc9c 395 /*
ohararp 1:1b91ef74cc9c 396 * Sets the alive array to all falses.
ohararp 1:1b91ef74cc9c 397 */
ohararp 1:1b91ef74cc9c 398 void blank_alive()
ohararp 1:1b91ef74cc9c 399 {
ohararp 1:1b91ef74cc9c 400 for(int i = 0; i < ROWS; ++i)
ohararp 1:1b91ef74cc9c 401 alive[i] = 0;
ohararp 1:1b91ef74cc9c 402 }
ohararp 1:1b91ef74cc9c 403 //*******************************************************************************
ohararp 1:1b91ef74cc9c 404 /**
ohararp 1:1b91ef74cc9c 405 * Writes output to the console.
ohararp 1:1b91ef74cc9c 406 */
ohararp 1:1b91ef74cc9c 407
ohararp 1:1b91ef74cc9c 408 void do_output()
ohararp 1:1b91ef74cc9c 409 {
ohararp 1:1b91ef74cc9c 410 //blank();
ohararp 1:1b91ef74cc9c 411 //pc.printf("Board: %d",boardnum);
ohararp 1:1b91ef74cc9c 412 //pc.printf(" Iteration: %d\n",iteration);
ohararp 1:1b91ef74cc9c 413 for(int i = 0; i < ROWS; i++)
ohararp 1:1b91ef74cc9c 414 {
ohararp 1:1b91ef74cc9c 415 for(int j = 0; j < COLS; j++)
ohararp 1:1b91ef74cc9c 416 {
ohararp 1:1b91ef74cc9c 417 // WIDTH, HEIGHT
ohararp 1:1b91ef74cc9c 418 if(isAlive(i,j))
ohararp 1:1b91ef74cc9c 419 {
ohararp 1:1b91ef74cc9c 420 setPixelColor(Matrix[i+RowIdx[j]],rand() % BrightMax,rand() % BrightMax,rand() % BrightMax);
ohararp 1:1b91ef74cc9c 421 //pc.printf("Alive: %d %d\n",i,j);
ohararp 1:1b91ef74cc9c 422 }
ohararp 1:1b91ef74cc9c 423 else
ohararp 1:1b91ef74cc9c 424 setPixelColor(Matrix[i+RowIdx[j]],0,0,0);
ohararp 1:1b91ef74cc9c 425 }
ohararp 1:1b91ef74cc9c 426 }
ohararp 1:1b91ef74cc9c 427 }
ohararp 1:1b91ef74cc9c 428
ohararp 1:1b91ef74cc9c 429 /**
ohararp 1:1b91ef74cc9c 430 * Randomly fills the grid with alive cells after blanking.
ohararp 1:1b91ef74cc9c 431 */
ohararp 1:1b91ef74cc9c 432 void random_fill()
ohararp 1:1b91ef74cc9c 433 {
ohararp 1:1b91ef74cc9c 434 blank_alive();
ohararp 1:1b91ef74cc9c 435
ohararp 1:1b91ef74cc9c 436 // Fill up 10-30% of the cells
ohararp 1:1b91ef74cc9c 437 int numToFill = (ROWS * COLS) * (rand() % 30+10) / 100 ;
ohararp 1:1b91ef74cc9c 438
ohararp 1:1b91ef74cc9c 439 for(int r = 0; r < numToFill; r ++)
ohararp 1:1b91ef74cc9c 440 {
ohararp 1:1b91ef74cc9c 441 int row = rand() % ROWS;
ohararp 1:1b91ef74cc9c 442 int col = rand() % COLS;
ohararp 1:1b91ef74cc9c 443
ohararp 1:1b91ef74cc9c 444 setAlive(row,col);
ohararp 1:1b91ef74cc9c 445 }
ohararp 1:1b91ef74cc9c 446 }
ohararp 1:1b91ef74cc9c 447
ohararp 1:1b91ef74cc9c 448 /**
ohararp 1:1b91ef74cc9c 449 * Returns the index of the row below the current one.
ohararp 1:1b91ef74cc9c 450 */
ohararp 1:1b91ef74cc9c 451 int rowBelow(int row)
ohararp 1:1b91ef74cc9c 452 {
ohararp 1:1b91ef74cc9c 453 return (row + 1 < ROWS) ? row + 1 : 0;
ohararp 1:1b91ef74cc9c 454 }
ohararp 1:1b91ef74cc9c 455
ohararp 1:1b91ef74cc9c 456 /**
ohararp 1:1b91ef74cc9c 457 * Returns the index of the row above the given one
ohararp 1:1b91ef74cc9c 458 */
ohararp 1:1b91ef74cc9c 459 int rowAbove(int row)
ohararp 1:1b91ef74cc9c 460 {
ohararp 1:1b91ef74cc9c 461 return (row > 0) ? row - 1 : ROWS - 1;
ohararp 1:1b91ef74cc9c 462 }
ohararp 1:1b91ef74cc9c 463
ohararp 1:1b91ef74cc9c 464 /** Returns the index of the col to the right of this one */
ohararp 1:1b91ef74cc9c 465 int colRight(int col)
ohararp 1:1b91ef74cc9c 466 {
ohararp 1:1b91ef74cc9c 467 return (col + 1 < COLS) ? col + 1 : 0;
ohararp 1:1b91ef74cc9c 468 }
ohararp 1:1b91ef74cc9c 469
ohararp 1:1b91ef74cc9c 470 /** Returns the index of the col to the left of this one */
ohararp 1:1b91ef74cc9c 471 int colLeft(int col)
ohararp 1:1b91ef74cc9c 472 {
ohararp 1:1b91ef74cc9c 473 return (col > 0) ? col - 1 : COLS -1;
ohararp 1:1b91ef74cc9c 474 }
ohararp 1:1b91ef74cc9c 475
ohararp 1:1b91ef74cc9c 476 /** true if the cell to the left is alive*/
ohararp 1:1b91ef74cc9c 477 bool left(int row, int col)
ohararp 1:1b91ef74cc9c 478 {
ohararp 1:1b91ef74cc9c 479 col = colLeft(col);
ohararp 1:1b91ef74cc9c 480 return isAlive(row,col);
ohararp 1:1b91ef74cc9c 481 }
ohararp 1:1b91ef74cc9c 482
ohararp 1:1b91ef74cc9c 483 /** true if the cell to the right is alive*/
ohararp 1:1b91ef74cc9c 484 bool right(int row, int col)
ohararp 1:1b91ef74cc9c 485 {
ohararp 1:1b91ef74cc9c 486 col = colRight(col);
ohararp 1:1b91ef74cc9c 487 return isAlive(row,col);
ohararp 1:1b91ef74cc9c 488 }
ohararp 1:1b91ef74cc9c 489
ohararp 1:1b91ef74cc9c 490 /** true if the cell above is alive*/
ohararp 1:1b91ef74cc9c 491 bool above(int row, int col)
ohararp 1:1b91ef74cc9c 492 {
ohararp 1:1b91ef74cc9c 493 row = rowAbove(row);
ohararp 1:1b91ef74cc9c 494 return isAlive(row,col);
ohararp 1:1b91ef74cc9c 495 }
ohararp 1:1b91ef74cc9c 496
ohararp 1:1b91ef74cc9c 497 /** true if the cell below is alive*/
ohararp 1:1b91ef74cc9c 498 bool below(int row, int col)
ohararp 1:1b91ef74cc9c 499 {
ohararp 1:1b91ef74cc9c 500 row = rowBelow(row);
ohararp 1:1b91ef74cc9c 501 return isAlive(row,col);
ohararp 1:1b91ef74cc9c 502 }
ohararp 1:1b91ef74cc9c 503
ohararp 1:1b91ef74cc9c 504 /** true if the cell NE is alive*/
ohararp 1:1b91ef74cc9c 505 bool aboveright(int row, int col)
ohararp 1:1b91ef74cc9c 506 {
ohararp 1:1b91ef74cc9c 507 row = rowAbove(row);
ohararp 1:1b91ef74cc9c 508 col = colRight(col);
ohararp 1:1b91ef74cc9c 509 return isAlive(row,col);
ohararp 1:1b91ef74cc9c 510 }
ohararp 1:1b91ef74cc9c 511
ohararp 1:1b91ef74cc9c 512 /** true if the cell SE is alive*/
ohararp 1:1b91ef74cc9c 513 bool belowright(int row, int col)
ohararp 1:1b91ef74cc9c 514 {
ohararp 1:1b91ef74cc9c 515 row = rowBelow(row);
ohararp 1:1b91ef74cc9c 516 col = colRight(col);
ohararp 1:1b91ef74cc9c 517 return isAlive(row,col);
ohararp 1:1b91ef74cc9c 518 }
ohararp 1:1b91ef74cc9c 519
ohararp 1:1b91ef74cc9c 520 /** true if the cell NW is alive*/
ohararp 1:1b91ef74cc9c 521 bool aboveleft(int row, int col)
ohararp 1:1b91ef74cc9c 522 {
ohararp 1:1b91ef74cc9c 523 row = rowAbove(row);
ohararp 1:1b91ef74cc9c 524 col = colLeft(col);
ohararp 1:1b91ef74cc9c 525 return isAlive(row,col);
ohararp 1:1b91ef74cc9c 526 }
ohararp 1:1b91ef74cc9c 527
ohararp 1:1b91ef74cc9c 528 /** true if the cell SW is alive*/
ohararp 1:1b91ef74cc9c 529 bool belowleft(int row, int col)
ohararp 1:1b91ef74cc9c 530 {
ohararp 1:1b91ef74cc9c 531 row = rowBelow(row);
ohararp 1:1b91ef74cc9c 532 col = colLeft(col);
ohararp 1:1b91ef74cc9c 533 return isAlive(row,col);
ohararp 1:1b91ef74cc9c 534 }
ohararp 1:1b91ef74cc9c 535
ohararp 1:1b91ef74cc9c 536 /**Returns the number of living cells sorrounding this one.*/
ohararp 1:1b91ef74cc9c 537 int numberAround(int row, int col)
ohararp 1:1b91ef74cc9c 538 {
ohararp 1:1b91ef74cc9c 539 int around = 0;
ohararp 1:1b91ef74cc9c 540 if(left(row,col))
ohararp 1:1b91ef74cc9c 541 around++;
ohararp 1:1b91ef74cc9c 542
ohararp 1:1b91ef74cc9c 543 if(right(row,col))
ohararp 1:1b91ef74cc9c 544 around++;
ohararp 1:1b91ef74cc9c 545
ohararp 1:1b91ef74cc9c 546 if(above(row,col))
ohararp 1:1b91ef74cc9c 547 around++;
ohararp 1:1b91ef74cc9c 548
ohararp 1:1b91ef74cc9c 549 if(below(row,col))
ohararp 1:1b91ef74cc9c 550 around++;
ohararp 1:1b91ef74cc9c 551
ohararp 1:1b91ef74cc9c 552 if(aboveright(row,col))
ohararp 1:1b91ef74cc9c 553 around++;
ohararp 1:1b91ef74cc9c 554
ohararp 1:1b91ef74cc9c 555 if(aboveleft(row,col))
ohararp 1:1b91ef74cc9c 556 around++;
ohararp 1:1b91ef74cc9c 557
ohararp 1:1b91ef74cc9c 558 if(belowright(row,col))
ohararp 1:1b91ef74cc9c 559 around++;
ohararp 1:1b91ef74cc9c 560
ohararp 1:1b91ef74cc9c 561 if(belowleft(row,col))
ohararp 1:1b91ef74cc9c 562 around++;
ohararp 1:1b91ef74cc9c 563
ohararp 1:1b91ef74cc9c 564 return around;
ohararp 1:1b91ef74cc9c 565 }
ohararp 1:1b91ef74cc9c 566
ohararp 1:1b91ef74cc9c 567 /**
ohararp 1:1b91ef74cc9c 568 * Moves all of the cells
ohararp 1:1b91ef74cc9c 569 */
ohararp 1:1b91ef74cc9c 570 void move()
ohararp 1:1b91ef74cc9c 571 {
ohararp 1:1b91ef74cc9c 572 uint32_t nextRows[ROWS] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0};
ohararp 1:1b91ef74cc9c 573
ohararp 1:1b91ef74cc9c 574 for(int i = 0; i < ROWS; i++)
ohararp 1:1b91ef74cc9c 575 {
ohararp 1:1b91ef74cc9c 576 for(int j = 0; j < COLS; j++)
ohararp 1:1b91ef74cc9c 577 {
ohararp 1:1b91ef74cc9c 578 int na = numberAround(i,j);
ohararp 1:1b91ef74cc9c 579 if((na == 2 && isAlive(i,j)) || na == 3)
ohararp 1:1b91ef74cc9c 580 nextRows[i] |= 1 << j;
ohararp 1:1b91ef74cc9c 581 }
ohararp 1:1b91ef74cc9c 582 }
ohararp 1:1b91ef74cc9c 583 for(int i = 0; i < ROWS; i++)
ohararp 1:1b91ef74cc9c 584 alive[i] = nextRows[i];
ohararp 1:1b91ef74cc9c 585 }
ohararp 1:1b91ef74cc9c 586
ohararp 1:1b91ef74cc9c 587 //*******************************************************************************
ohararp 0:f19c80146d55 588 int main() {
ohararp 0:f19c80146d55 589 pc.baud(38400);
ohararp 0:f19c80146d55 590 setup();
ohararp 0:f19c80146d55 591 while (1) {
ohararp 0:f19c80146d55 592 pc.printf("Top of the Loop\n");
ohararp 1:1b91ef74cc9c 593 bLed = !bLed;
ohararp 1:1b91ef74cc9c 594 blankDelay(0);
ohararp 1:1b91ef74cc9c 595
ohararp 1:1b91ef74cc9c 596 boardnum++;
ohararp 1:1b91ef74cc9c 597 random_fill();
ohararp 0:f19c80146d55 598
ohararp 1:1b91ef74cc9c 599 for(iteration = 0;iteration < 500; iteration++)
ohararp 1:1b91ef74cc9c 600 {
ohararp 1:1b91ef74cc9c 601 do_output();
ohararp 1:1b91ef74cc9c 602 show();
ohararp 1:1b91ef74cc9c 603 move();
ohararp 1:1b91ef74cc9c 604 wait_ms(0);
ohararp 1:1b91ef74cc9c 605 }
ohararp 0:f19c80146d55 606 }
ohararp 1:1b91ef74cc9c 607 }