Code used in RGB-123 Kickstarter. Conways Game of Life
Dependencies: WS2811_RY_A mbed
Fork of WS2811_RY_A by
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?
User | Revision | Line number | New 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 | } |