Details | Last modification | View Log | RSS feed
| Rev | Author | Line No. | Line |
|---|---|---|---|
| 1882 | - | 1 | //******************************************************************* |
| 2 | // Definition of color pattern and sequences |
||
| 3 | //******************************************************************* |
||
| 4 | |||
| 5 | |||
| 6 | // ------------------------------------------------------------------ |
||
| 7 | // Move a flashing circle from inner to outer |
||
| 8 | // ------------------------------------------------------------------ |
||
| 9 | void flashingCircle( uint8_t r, uint8_t g, uint8_t b, uint8_t wait) { |
||
| 10 | uint8_t ri1, ri2, ri3, ri4, ri5, ri6, ri7, ri8; |
||
| 11 | |||
| 12 | for (uint8_t j=0; j< riggerSize ; j++){ |
||
| 13 | strip.setPixelColor(j, r, g, b, 1, 1, 1, 1, 1, 1, 1, 1); |
||
| 14 | strip.show(); |
||
| 15 | delay ( wait ); |
||
| 16 | strip.setPixelColor(j, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1); |
||
| 17 | remoteControl(); |
||
| 18 | if (counter1 != counter2) { |
||
| 19 | return;} |
||
| 20 | strip.show(); |
||
| 21 | delay ( wait/2 ); |
||
| 22 | |||
| 23 | } |
||
| 24 | } |
||
| 25 | |||
| 26 | // ------------------------------------------------------------------ |
||
| 27 | // Move a flashing circle from outer to inner |
||
| 28 | // ------------------------------------------------------------------ |
||
| 29 | void flashingCircleRev( uint8_t r, uint8_t g, uint8_t b, uint8_t wait) { |
||
| 30 | uint8_t ri1, ri2, ri3, ri4, ri5, ri6, ri7, ri8; |
||
| 31 | |||
| 32 | for (uint8_t j = riggerSize; j > 0 ; j--){ |
||
| 33 | strip.setPixelColor(j-1, r, g, b, 1, 1, 1, 1, 1, 1, 1, 1); |
||
| 34 | strip.show(); |
||
| 35 | delay ( wait ); |
||
| 36 | strip.setPixelColor(j-1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1); |
||
| 37 | remoteControl(); |
||
| 38 | if (counter1 != counter2) { |
||
| 39 | return;} |
||
| 40 | strip.show(); |
||
| 41 | delay ( wait/2 ); |
||
| 42 | |||
| 43 | } |
||
| 44 | } |
||
| 45 | |||
| 46 | // ------------------------------------------------------------------ |
||
| 47 | // Move a single circling LED from inner to outer |
||
| 48 | // ------------------------------------------------------------------ |
||
| 49 | void spiral( uint8_t r, uint8_t g, uint8_t b, uint8_t wait) { |
||
| 50 | uint8_t ri1, ri2, ri3, ri4, ri5, ri6, ri7, ri8; |
||
| 51 | |||
| 52 | for (uint8_t j=0; j< riggerSize ; j++){ |
||
| 53 | for (uint8_t i=1; i<= rigger ; i++){ |
||
| 54 | if (i == 1){ |
||
| 55 | strip.setPixelColor(j, r, g, b, 1, 0, 0, 0, 0, 0, 0, 0); |
||
| 56 | strip.show(); |
||
| 57 | delay ( wait ); |
||
| 58 | strip.setPixelColor(j, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0); |
||
| 59 | remoteControl(); |
||
| 60 | if (counter1 != counter2) { |
||
| 61 | return;} |
||
| 62 | strip.show(); |
||
| 63 | delay ( wait ); |
||
| 64 | } |
||
| 65 | |||
| 66 | if (i == 2){ |
||
| 67 | strip.setPixelColor(j, r, g, b, 0, 1, 0, 0, 0, 0, 0, 0); |
||
| 68 | strip.show(); |
||
| 69 | delay ( wait ); |
||
| 70 | strip.setPixelColor(j, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0); |
||
| 71 | remoteControl(); |
||
| 72 | if (counter1 != counter2) { |
||
| 73 | return;} |
||
| 74 | strip.show(); |
||
| 75 | delay ( wait ); |
||
| 76 | } |
||
| 77 | |||
| 78 | if (i == 3){ |
||
| 79 | strip.setPixelColor(j, r, g, b, 0, 0, 1, 0, 0, 0, 0, 0); |
||
| 80 | strip.show(); |
||
| 81 | delay ( wait ); |
||
| 82 | strip.setPixelColor(j, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0); |
||
| 83 | remoteControl(); |
||
| 84 | if (counter1 != counter2) { |
||
| 85 | return;} |
||
| 86 | strip.show(); |
||
| 87 | delay ( wait ); |
||
| 88 | } |
||
| 89 | |||
| 90 | if (i == 4){ |
||
| 91 | strip.setPixelColor(j, r, g, b, 0, 0, 0, 1, 0, 0, 0, 0); |
||
| 92 | strip.show(); |
||
| 93 | delay ( wait ); |
||
| 94 | strip.setPixelColor(j, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0); |
||
| 95 | remoteControl(); |
||
| 96 | if (counter1 != counter2) { |
||
| 97 | return;} |
||
| 98 | strip.show(); |
||
| 99 | delay ( wait ); |
||
| 100 | } |
||
| 101 | |||
| 102 | if (i == 5){ |
||
| 103 | strip.setPixelColor(j, r, g, b, 0, 0, 0, 0, 1, 0, 0, 0); |
||
| 104 | strip.show(); |
||
| 105 | delay ( wait ); |
||
| 106 | strip.setPixelColor(j, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0); |
||
| 107 | remoteControl(); |
||
| 108 | if (counter1 != counter2) { |
||
| 109 | return;} |
||
| 110 | strip.show(); |
||
| 111 | delay ( wait ); |
||
| 112 | } |
||
| 113 | |||
| 114 | if (i == 6){ |
||
| 115 | strip.setPixelColor(j, r, g, b, 0, 0, 0, 0, 0, 1, 0, 0); |
||
| 116 | strip.show(); |
||
| 117 | delay ( wait ); |
||
| 118 | strip.setPixelColor(j, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0); |
||
| 119 | remoteControl(); |
||
| 120 | if (counter1 != counter2) { |
||
| 121 | return;} |
||
| 122 | strip.show(); |
||
| 123 | delay ( wait ); |
||
| 124 | } |
||
| 125 | |||
| 126 | if (i == 7){ |
||
| 127 | strip.setPixelColor(j, r, g, b, 0, 0, 0, 0, 0, 0, 1, 0); |
||
| 128 | strip.show(); |
||
| 129 | delay ( wait ); |
||
| 130 | strip.setPixelColor(j, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0); |
||
| 131 | remoteControl(); |
||
| 132 | if (counter1 != counter2) { |
||
| 133 | return;} |
||
| 134 | strip.show(); |
||
| 135 | delay ( wait ); |
||
| 136 | } |
||
| 137 | |||
| 138 | if (i == 8){ |
||
| 139 | strip.setPixelColor(j, r, g, b, 0, 0, 0, 0, 0, 0, 0, 1); |
||
| 140 | strip.show(); |
||
| 141 | delay ( wait ); |
||
| 142 | strip.setPixelColor(j, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1); |
||
| 143 | remoteControl(); |
||
| 144 | if (counter1 != counter2) { |
||
| 145 | return;} |
||
| 146 | strip.show(); |
||
| 147 | delay ( wait ); |
||
| 148 | } |
||
| 149 | } |
||
| 150 | } |
||
| 151 | } |
||
| 152 | |||
| 153 | // ------------------------------------------------------------------ |
||
| 154 | // Move a single circling LED from outer to inner |
||
| 155 | // ------------------------------------------------------------------ |
||
| 156 | void spiralRev( uint8_t r, uint8_t g, uint8_t b, uint8_t wait) { |
||
| 157 | uint8_t ri1, ri2, ri3, ri4, ri5, ri6, ri7, ri8; |
||
| 158 | |||
| 159 | for (uint8_t j = riggerSize; j > 0 ; j--){ |
||
| 160 | for (uint8_t i = 1 ; i <= rigger ; i++){ |
||
| 161 | if (i == 1){ |
||
| 162 | strip.setPixelColor(j-1, r, g, b, 1, 0, 0, 0, 0, 0, 0, 0); |
||
| 163 | strip.show(); |
||
| 164 | delay ( wait ); |
||
| 165 | strip.setPixelColor(j-1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0); |
||
| 166 | remoteControl(); |
||
| 167 | if (counter1 != counter2) { |
||
| 168 | return;} |
||
| 169 | strip.show(); |
||
| 170 | delay ( wait ); |
||
| 171 | } |
||
| 172 | |||
| 173 | if (i == 2){ |
||
| 174 | strip.setPixelColor(j-1, r, g, b, 0, 1, 0, 0, 0, 0, 0, 0); |
||
| 175 | strip.show(); |
||
| 176 | delay ( wait ); |
||
| 177 | strip.setPixelColor(j-1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0); |
||
| 178 | remoteControl(); |
||
| 179 | if (counter1 != counter2) { |
||
| 180 | return;} |
||
| 181 | strip.show(); |
||
| 182 | delay ( wait ); |
||
| 183 | } |
||
| 184 | |||
| 185 | if (i == 3){ |
||
| 186 | strip.setPixelColor(j-1, r, g, b, 0, 0, 1, 0, 0, 0, 0, 0); |
||
| 187 | strip.show(); |
||
| 188 | delay ( wait ); |
||
| 189 | strip.setPixelColor(j-1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0); |
||
| 190 | remoteControl(); |
||
| 191 | if (counter1 != counter2) { |
||
| 192 | return;} |
||
| 193 | strip.show(); |
||
| 194 | delay ( wait ); |
||
| 195 | } |
||
| 196 | |||
| 197 | if (i == 4){ |
||
| 198 | strip.setPixelColor(j-1, r, g, b, 0, 0, 0, 1, 0, 0, 0, 0); |
||
| 199 | strip.show(); |
||
| 200 | delay ( wait ); |
||
| 201 | strip.setPixelColor(j-1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0); |
||
| 202 | remoteControl(); |
||
| 203 | if (counter1 != counter2) { |
||
| 204 | return;} |
||
| 205 | strip.show(); |
||
| 206 | delay ( wait ); |
||
| 207 | } |
||
| 208 | |||
| 209 | if (i == 5){ |
||
| 210 | strip.setPixelColor(j-1, r, g, b, 0, 0, 0, 0, 1, 0, 0, 0); |
||
| 211 | strip.show(); |
||
| 212 | delay ( wait ); |
||
| 213 | strip.setPixelColor(j-1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0); |
||
| 214 | remoteControl(); |
||
| 215 | if (counter1 != counter2) { |
||
| 216 | return;} |
||
| 217 | strip.show(); |
||
| 218 | delay ( wait ); |
||
| 219 | } |
||
| 220 | |||
| 221 | if (i == 6){ |
||
| 222 | strip.setPixelColor(j-1, r, g, b, 0, 0, 0, 0, 0, 1, 0, 0); |
||
| 223 | strip.show(); |
||
| 224 | delay ( wait ); |
||
| 225 | strip.setPixelColor(j-1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0); |
||
| 226 | remoteControl(); |
||
| 227 | if (counter1 != counter2) { |
||
| 228 | return;} |
||
| 229 | strip.show(); |
||
| 230 | delay ( wait ); |
||
| 231 | } |
||
| 232 | |||
| 233 | if (i == 7){ |
||
| 234 | strip.setPixelColor(j-1, r, g, b, 0, 0, 0, 0, 0, 0, 1, 0); |
||
| 235 | strip.show(); |
||
| 236 | delay ( wait ); |
||
| 237 | strip.setPixelColor(j-1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0); |
||
| 238 | remoteControl(); |
||
| 239 | if (counter1 != counter2) { |
||
| 240 | return;} |
||
| 241 | strip.show(); |
||
| 242 | delay ( wait ); |
||
| 243 | } |
||
| 244 | |||
| 245 | if (i == 8){ |
||
| 246 | strip.setPixelColor(j-1, r, g, b, 0, 0, 0, 0, 0, 0, 0, 1); |
||
| 247 | strip.show(); |
||
| 248 | delay ( wait ); |
||
| 249 | strip.setPixelColor(j-1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1); |
||
| 250 | remoteControl(); |
||
| 251 | if (counter1 != counter2) { |
||
| 252 | return;} |
||
| 253 | strip.show(); |
||
| 254 | delay ( wait ); |
||
| 255 | } |
||
| 256 | } |
||
| 257 | } |
||
| 258 | } |
||
| 259 | |||
| 260 | |||
| 261 | // ------------------------------------------------------------------ |
||
| 262 | // Fade In: Fades selected color from dark to full bright |
||
| 263 | // ------------------------------------------------------------------ |
||
| 264 | void fadein( uint8_t r, uint8_t g, uint8_t b, uint8_t wait, uint8_t ri1, uint8_t ri2, uint8_t ri3, uint8_t ri4, uint8_t ri5, uint8_t ri6, uint8_t ri7, uint8_t ri8) { |
||
| 265 | |||
| 266 | uint8_t r2, g2, b2; |
||
| 267 | |||
| 268 | for (uint8_t j = 127; j > 10; j--){ |
||
| 269 | uint8_t rh = r-(j*r/127); |
||
| 270 | if((r || rh) && rh <= r) r2 = rh; |
||
| 271 | if(rh > r) r2 = r; |
||
| 272 | if(r == 0) r2 = 0; |
||
| 273 | uint8_t gh = g-(j*g/127); |
||
| 274 | if((g || gh) && gh <= g) g2 = gh; |
||
| 275 | if(gh > g) g2 = g; |
||
| 276 | if(g == 0) g2 = 0; |
||
| 277 | uint8_t bh = b-(j*b/127); |
||
| 278 | if((b || bh) && bh <= b) b2 = bh; |
||
| 279 | if(bh > b) b2 = b; |
||
| 280 | if(b == 0) b2 = 0; |
||
| 281 | for(uint8_t i=0; i<riggerSize; i++) { |
||
| 282 | strip.setPixelColor(i, r2, g2, b2, ri1, ri2, ri3, ri4, ri5, ri6, ri7, ri8); |
||
| 283 | } |
||
| 284 | remoteControl(); |
||
| 285 | if (counter1 != counter2) { |
||
| 286 | return;} |
||
| 287 | strip.show(); |
||
| 288 | delay(wait); |
||
| 289 | } |
||
| 290 | } |
||
| 291 | |||
| 292 | // ------------------------------------------------------------------ |
||
| 293 | // Fade Out: Fades selected color from full bright to dark |
||
| 294 | // ------------------------------------------------------------------ |
||
| 295 | void fadeout(uint8_t r, uint8_t g, uint8_t b, uint8_t wait, uint8_t ri1, uint8_t ri2, uint8_t ri3, uint8_t ri4, uint8_t ri5, uint8_t ri6, uint8_t ri7, uint8_t ri8) { |
||
| 296 | |||
| 297 | uint8_t r2, g2, b2; |
||
| 298 | |||
| 299 | for (uint8_t j = 10; j < 127; j++){ |
||
| 300 | uint8_t rh = r-(j*r/127); |
||
| 301 | if((r || 0) && rh < r) r2 = rh; |
||
| 302 | if(r == 0) r2 = 0; |
||
| 303 | uint8_t gh = g-(j*g/127); |
||
| 304 | if((g || 0) && gh < g) g2 = gh; |
||
| 305 | if(g == 0) g2 = 0; |
||
| 306 | uint8_t bh = b-(j*b/127); |
||
| 307 | if((b || 0) && bh < b) b2 = bh; |
||
| 308 | if(b == 0) b2 = 0; |
||
| 309 | for(int i=0; i<riggerSize; i++) { |
||
| 310 | strip.setPixelColor(i, r2, g2, b2,ri1, ri2, ri3, ri4, ri5, ri6, ri7, ri8); |
||
| 311 | } |
||
| 312 | remoteControl(); |
||
| 313 | if (counter1 != counter2) { |
||
| 314 | return;} |
||
| 315 | strip.show(); |
||
| 316 | delay(wait); |
||
| 317 | } |
||
| 318 | for(int i=0; i<riggerSize; i++) { |
||
| 319 | strip.setPixelColor(i, 0,ri1, ri2, ri3, ri4, ri5, ri6, ri7, ri8); |
||
| 320 | } |
||
| 321 | } |
||
| 322 | |||
| 323 | // ------------------------------------------------------------------ |
||
| 324 | // Flashing Light: Blink full rigger |
||
| 325 | // ------------------------------------------------------------------ |
||
| 326 | void flashLight(uint8_t wait, uint8_t cyl, uint8_t ri1, uint8_t ri2, uint8_t ri3, uint8_t ri4, uint8_t ri5, uint8_t ri6, uint8_t ri7, uint8_t ri8) { |
||
| 327 | |||
| 328 | for (int j=0; j < cyl; j++) { |
||
| 329 | for (int x = 0; x<2; x++){ |
||
| 330 | for (int i = 0; i < riggerSize; i++){ |
||
| 331 | strip.setPixelColor(i, 0, 127,0,ri1, ri2, ri3, ri4, ri5, ri6, ri7, ri8); |
||
| 332 | } |
||
| 333 | strip.show(); |
||
| 334 | delay(wait); |
||
| 335 | for (int i = 0; i < riggerSize; i++){ |
||
| 336 | strip.setPixelColor(i, 0,ri1, ri2, ri3, ri4, ri5, ri6, ri7, ri8); |
||
| 337 | } |
||
| 338 | remoteControl(); |
||
| 339 | if (counter1 != counter2) { |
||
| 340 | return;} |
||
| 341 | strip.show(); |
||
| 342 | delay(wait); |
||
| 343 | } |
||
| 344 | } |
||
| 345 | } |
||
| 346 | |||
| 347 | // ------------------------------------------------------------------ |
||
| 348 | // Police Light :Two colors flashing on left and right of selected rigger. |
||
| 349 | // ------------------------------------------------------------------ |
||
| 350 | void police(uint8_t wait, uint8_t cyl, uint8_t ri1, uint8_t ri2, uint8_t ri3, uint8_t ri4, uint8_t ri5, uint8_t ri6, uint8_t ri7, uint8_t ri8) { |
||
| 351 | |||
| 352 | for (int j=0; j < cyl; j++) { |
||
| 353 | for (int x = 0; x<2; x++){ |
||
| 354 | for (int i = 0; i < (riggerSize/2); i++){ |
||
| 355 | strip.setPixelColor(i, 127,0,0,ri1, ri2, ri3, ri4, ri5, ri6, ri7, ri8); |
||
| 356 | } |
||
| 357 | strip.show(); |
||
| 358 | delay(wait); |
||
| 359 | for (int i = 0; i < (riggerSize/2); i++){ |
||
| 360 | strip.setPixelColor(i, 0, 0,0,ri1, ri2, ri3, ri4, ri5, ri6, ri7, ri8); |
||
| 361 | } |
||
| 362 | remoteControl(); |
||
| 363 | if (counter1 != counter2) { |
||
| 364 | return;} |
||
| 365 | strip.show(); |
||
| 366 | delay(wait); |
||
| 367 | } |
||
| 368 | for (int x = 0; x<2; x++){ |
||
| 369 | for (int i = (riggerSize/2); i < riggerSize; i++){ |
||
| 370 | strip.setPixelColor(i, 0, 0,127,ri1, ri2, ri3, ri4, ri5, ri6, ri7, ri8); |
||
| 371 | } |
||
| 372 | strip.show(); |
||
| 373 | delay(wait); |
||
| 374 | for (int i = (riggerSize/2); i < riggerSize; i++){ |
||
| 375 | strip.setPixelColor(i, 0,ri1, ri2, ri3, ri4, ri5, ri6, ri7, ri8); |
||
| 376 | } |
||
| 377 | remoteControl(); |
||
| 378 | if (counter1 != counter2) { |
||
| 379 | return;} |
||
| 380 | strip.show(); |
||
| 381 | delay(wait); |
||
| 382 | } |
||
| 383 | } |
||
| 384 | } |
||
| 385 | |||
| 386 | // ------------------------------------------------------------------ |
||
| 387 | // Cycle through two colors, equally spaced around the Strip ( one left, on right ) |
||
| 388 | // Like Nightrider, but with two colors. |
||
| 389 | // ------------------------------------------------------------------ |
||
| 390 | void circlinglights(uint8_t wait, uint8_t cyl, uint8_t ri1, uint8_t ri2, uint8_t ri3, uint8_t ri4, uint8_t ri5, uint8_t ri6, uint8_t ri7, uint8_t ri8) { |
||
| 391 | uint16_t b=0; |
||
| 392 | uint16_t r=riggerSize-1; |
||
| 393 | |||
| 394 | for (int j=0; j < stripSize * cyl; j++) { |
||
| 395 | strip.setPixelColor(b%riggerSize,0,2,0,ri1, ri2, ri3, ri4, ri5, ri6, ri7, ri8); |
||
| 396 | strip.setPixelColor((b+1)%riggerSize,1,16,0,ri1, ri2, ri3, ri4, ri5, ri6, ri7, ri8); |
||
| 397 | strip.setPixelColor((b+2)%riggerSize,0,55,0,ri1, ri2, ri3, ri4, ri5, ri6, ri7, ri8); |
||
| 398 | strip.setPixelColor((b+3)%riggerSize,0,127,0,ri1, ri2, ri3, ri4, ri5, ri6, ri7, ri8); |
||
| 399 | strip.setPixelColor(r%riggerSize,2,1,0,ri1, ri2, ri3, ri4, ri5, ri6, ri7, ri8); |
||
| 400 | strip.setPixelColor((r+riggerSize-1)%riggerSize,16,3,0,ri1, ri2, ri3, ri4, ri5, ri6, ri7, ri8); |
||
| 401 | strip.setPixelColor((r+riggerSize-2)%riggerSize,55,15,0,ri1, ri2, ri3, ri4, ri5, ri6, ri7, ri8); |
||
| 402 | strip.setPixelColor((r+riggerSize-3)%riggerSize,127,20,0,ri1, ri2, ri3, ri4, ri5, ri6, ri7, ri8); |
||
| 403 | strip.show(); |
||
| 404 | delay(wait); |
||
| 405 | strip.setPixelColor(b%riggerSize,0,ri1, ri2, ri3, ri4, ri5, ri6, ri7, ri8); |
||
| 406 | strip.setPixelColor(r%riggerSize,0,ri1, ri2, ri3, ri4, ri5, ri6, ri7, ri8); |
||
| 407 | strip.show(); |
||
| 408 | if (b++==riggerSize) b=0; |
||
| 409 | if (r--==0) r=riggerSize; |
||
| 410 | remoteControl(); |
||
| 411 | if (counter1 != counter2) { |
||
| 412 | return;} |
||
| 413 | strip.show(); // write all the pixels out |
||
| 414 | } |
||
| 415 | } |
||
| 416 | |||
| 417 | |||
| 418 | // ------------------------------------------------------------------ |
||
| 419 | // Fill hole rigger dot by dot with selected color from inner to outer |
||
| 420 | // ------------------------------------------------------------------ |
||
| 421 | void colorWipe( uint8_t r, uint8_t g, uint8_t b, uint8_t wait, uint8_t ri1, uint8_t ri2, uint8_t ri3, uint8_t ri4, uint8_t ri5, uint8_t ri6, uint8_t ri7, uint8_t ri8) { |
||
| 422 | int i; |
||
| 423 | |||
| 424 | for (i=0; i < riggerSize; i++) { |
||
| 425 | strip.setPixelColor(i , r, g, b ,ri1, ri2, ri3, ri4, ri5, ri6, ri7, ri8); |
||
| 426 | remoteControl(); |
||
| 427 | if (counter1 != counter2) { |
||
| 428 | return;} |
||
| 429 | strip.show(); |
||
| 430 | delay(wait); |
||
| 431 | } |
||
| 432 | } |
||
| 433 | |||
| 434 | // ------------------------------------------------------------------ |
||
| 435 | // Fill hole rigger dot by dot with selected color from outer to inner |
||
| 436 | // ------------------------------------------------------------------ |
||
| 437 | void colorWipeREV( uint8_t r, uint8_t g, uint8_t b, uint8_t wait, uint8_t ri1, uint8_t ri2, uint8_t ri3, uint8_t ri4, uint8_t ri5, uint8_t ri6, uint8_t ri7, uint8_t ri8) { |
||
| 438 | int i; |
||
| 439 | |||
| 440 | for (i = riggerSize-1; i >= 0 ; i--) { |
||
| 441 | strip.setPixelColor(i , r, g, b ,ri1, ri2, ri3, ri4, ri5, ri6, ri7, ri8); |
||
| 442 | remoteControl(); |
||
| 443 | if (counter1 != counter2) { |
||
| 444 | return;} |
||
| 445 | strip.show(); |
||
| 446 | delay(wait); |
||
| 447 | } |
||
| 448 | } |
||
| 449 | |||
| 450 | // ------------------------------------------------------------------ |
||
| 451 | // Fill hole rigger with selected color in one step |
||
| 452 | // ------------------------------------------------------------------ |
||
| 453 | void colorFill( uint8_t r, uint8_t g, uint8_t b, uint8_t ri1, uint8_t ri2, uint8_t ri3, uint8_t ri4, uint8_t ri5, uint8_t ri6, uint8_t ri7, uint8_t ri8) { |
||
| 454 | int i; |
||
| 455 | |||
| 456 | for (i=0; i < riggerSize; i++) { |
||
| 457 | strip.setPixelColor(i , r, g, b ,ri1, ri2, ri3, ri4, ri5, ri6, ri7, ri8); |
||
| 458 | } |
||
| 459 | remoteControl(); |
||
| 460 | if (counter1 != counter2) { |
||
| 461 | return;} |
||
| 462 | strip.show(); |
||
| 463 | } |
||
| 464 | |||
| 465 | // ------------------------------------------------------------------ |
||
| 466 | // Chase a dot down the strip |
||
| 467 | // good for testing purposes |
||
| 468 | // ------------------------------------------------------------------ |
||
| 469 | void colorChase( uint8_t r, uint8_t g, uint8_t b, uint8_t wait, uint8_t ri1, uint8_t ri2, uint8_t ri3, uint8_t ri4, uint8_t ri5, uint8_t ri6, uint8_t ri7, uint8_t ri8) { |
||
| 470 | int pix; |
||
| 471 | |||
| 472 | for (pix=0; pix < riggerSize; pix++) { |
||
| 473 | strip.setPixelColor(pix , r, g, b ,ri1, ri2, ri3, ri4, ri5, ri6, ri7, ri8); // set one pixel |
||
| 474 | strip.show(); // refresh strip display |
||
| 475 | delay(wait); // hold image for a moment |
||
| 476 | strip.setPixelColor(pix,0,0, 0, ri1, ri2, ri3, ri4, ri5, ri6, ri7, ri8); // erase pixel (but don't refresh yet) |
||
| 477 | } |
||
| 478 | remoteControl(); |
||
| 479 | if (counter1 != counter2) { |
||
| 480 | return;} |
||
| 481 | strip.show(); // for last erased pixel |
||
| 482 | } |
||
| 483 | |||
| 484 | // ------------------------------------------------------------------ |
||
| 485 | // Chase a dot reverse up the strip |
||
| 486 | // good for testing purposes |
||
| 487 | // ------------------------------------------------------------------ |
||
| 488 | void colorChaseRev( uint8_t r, uint8_t g, uint8_t b, uint8_t wait, uint8_t ri1, uint8_t ri2, uint8_t ri3, uint8_t ri4, uint8_t ri5, uint8_t ri6, uint8_t ri7, uint8_t ri8) { |
||
| 489 | int i; |
||
| 490 | for (i=riggerSize-1; i >= 0; i--) { |
||
| 491 | strip.setPixelColor(i, r, g, b ,ri1, ri2, ri3, ri4, ri5, ri6, ri7, ri8); // set one pixel |
||
| 492 | strip.show(); // refresh strip display |
||
| 493 | delay(wait); // hold image for a moment |
||
| 494 | strip.setPixelColor(i,0,0, 0,ri1, ri2, ri3, ri4, ri5, ri6, ri7, ri8); // erase pixel (but don't refresh yet) |
||
| 495 | } |
||
| 496 | remoteControl(); |
||
| 497 | if (counter1 != counter2) { |
||
| 498 | return;} |
||
| 499 | strip.show(); // for last erased pixel |
||
| 500 | } |
||
| 501 | |||
| 502 | // ------------------------------------------------------------------ |
||
| 503 | // An "ordered dither" fills every pixel in a sequence that looks |
||
| 504 | // sparkly and almost random, but actually follows a specific order. |
||
| 505 | // ------------------------------------------------------------------ |
||
| 506 | void dither(uint8_t r, uint8_t g, uint8_t b, uint8_t wait, uint8_t ri1, uint8_t ri2, uint8_t ri3, uint8_t ri4, uint8_t ri5, uint8_t ri6, uint8_t ri7, uint8_t ri8) { |
||
| 507 | |||
| 508 | // Determine highest bit needed to represent pixel index |
||
| 509 | int hiBit = 0; |
||
| 510 | int n = (riggerSize/3)+1; |
||
| 511 | for(int bit=1; bit < 0x8000; bit <<= 1) { |
||
| 512 | if(n & bit) hiBit = bit; |
||
| 513 | } |
||
| 514 | |||
| 515 | int bit, reverse; |
||
| 516 | for(int i=0; i<(hiBit << 1); i++) { |
||
| 517 | // Reverse the bits in i to create ordered dither: |
||
| 518 | reverse = 0; |
||
| 519 | for(bit=1; bit <= hiBit; bit <<= 1) { |
||
| 520 | reverse <<= 1; |
||
| 521 | if(i & bit) reverse |= 1; |
||
| 522 | } |
||
| 523 | strip.setPixelColor(reverse, r,g,b,ri1, ri2, ri3, ri4, ri5, ri6, ri7, ri8); |
||
| 524 | remoteControl(); |
||
| 525 | if (counter1 != counter2) { |
||
| 526 | return;} |
||
| 527 | strip.show(); |
||
| 528 | delay(wait); |
||
| 529 | } |
||
| 530 | delay(250); // Hold image for 1/4 sec |
||
| 531 | } |
||
| 532 | |||
| 533 | // ------------------------------------------------------------------ |
||
| 534 | // "Larson scanner" = Cylon/KITT bouncing light effect |
||
| 535 | // ------------------------------------------------------------------ |
||
| 536 | void scanner(uint8_t r, uint8_t g, uint8_t b, uint8_t wait, uint8_t ri1, uint8_t ri2, uint8_t ri3, uint8_t ri4, uint8_t ri5, uint8_t ri6, uint8_t ri7, uint8_t ri8) { |
||
| 537 | int i, j, pos, dir; |
||
| 538 | |||
| 539 | pos = 1; |
||
| 540 | dir = 1; |
||
| 541 | |||
| 542 | for(i=1; i<(riggerSize)*8; i++) { |
||
| 543 | strip.setPixelColor(pos - 1, r/8, g/8, b/8,ri1, ri2, ri3, ri4, ri5, ri6, ri7, ri8); |
||
| 544 | strip.setPixelColor(pos, r, g, b,ri1, ri2, ri3, ri4, ri5, ri6, ri7, ri8); |
||
| 545 | strip.setPixelColor(pos + 1, r/8, g/8, b/8,ri1, ri2, ri3, ri4, ri5, ri6, ri7, ri8); |
||
| 546 | |||
| 547 | remoteControl(); |
||
| 548 | if (counter1 != counter2) { |
||
| 549 | return;} |
||
| 550 | strip.show(); |
||
| 551 | delay(wait); |
||
| 552 | // If we wanted to be sneaky we could erase just the tail end |
||
| 553 | // pixel, but it's much easier just to erase the whole thing |
||
| 554 | // and draw a new one next time. |
||
| 555 | for(j=-1; j<= 1; j++) strip.setPixelColor(pos+j,0,0,0,ri1, ri2, ri3, ri4, ri5, ri6, ri7, ri8); // Bounce off ends of strip |
||
| 556 | |||
| 557 | pos += dir; |
||
| 558 | if(pos < 1) { |
||
| 559 | pos = 1; |
||
| 560 | dir = -dir; |
||
| 561 | } else if(pos >= riggerSize-2) { |
||
| 562 | pos = riggerSize - 2; |
||
| 563 | dir = -dir; |
||
| 564 | } |
||
| 565 | } |
||
| 566 | } |
||
| 567 | |||
| 568 | // ------------------------------------------------------------------ |
||
| 569 | // Sine wave effect (Selcted color and white) |
||
| 570 | // ------------------------------------------------------------------ |
||
| 571 | #define PI 3.14159265 |
||
| 572 | void wave( uint8_t r, uint8_t g, uint8_t b, uint8_t wait, int stp, uint8_t ri1, uint8_t ri2, uint8_t ri3, uint8_t ri4, uint8_t ri5, uint8_t ri6, uint8_t ri7, uint8_t ri8) { |
||
| 573 | float y; |
||
| 574 | uint8_t r2, g2, b2; |
||
| 575 | |||
| 576 | for(int x=0; x<(riggerSize*5); x++) |
||
| 577 | { |
||
| 578 | for(int i=0; i<riggerSize; i++) { |
||
| 579 | y = sin(PI * (float)stp * (float)(x + i) / (float)riggerSize); |
||
| 580 | if(y >= 0.0) { |
||
| 581 | // Peaks of sine wave are white |
||
| 582 | y = 1.0 - y; // Translate Y to 0.0 (top) to 1.0 (center) |
||
| 583 | r2 = 127 - (byte)((float)(127 - r) * y); |
||
| 584 | g2 = 127 - (byte)((float)(127 - g) * y); |
||
| 585 | b2 = 127 - (byte)((float)(127 - b) * y); |
||
| 586 | } else { |
||
| 587 | // Troughs of sine wave are black |
||
| 588 | y += 1.0; // Translate Y to 0.0 (bottom) to 1.0 (center) |
||
| 589 | r2 = (byte)((float)r * y); |
||
| 590 | g2 = (byte)((float)g * y); |
||
| 591 | b2 = (byte)((float)b * y); |
||
| 592 | } |
||
| 593 | strip.setPixelColor(i, r2, g2, b2,ri1, ri2, ri3, ri4, ri5, ri6, ri7, ri8); |
||
| 594 | } |
||
| 595 | remoteControl(); |
||
| 596 | if (counter1 != counter2) { |
||
| 597 | return;} |
||
| 598 | strip.show(); |
||
| 599 | delay(wait); |
||
| 600 | } |
||
| 601 | } |
||
| 602 | |||
| 603 | // ------------------------------------------------------------------ |
||
| 604 | // Cycling thru the colors of RGB color the wheel (outer to inner) |
||
| 605 | // ------------------------------------------------------------------ |
||
| 606 | void rainbowCycle(uint8_t wait, uint8_t cyl, uint8_t ri1, uint8_t ri2, uint8_t ri3, uint8_t ri4, uint8_t ri5, uint8_t ri6, uint8_t ri7, uint8_t ri8) { |
||
| 607 | uint16_t i, j; |
||
| 608 | remoteControl(); |
||
| 609 | if (counter1 != counter2) { |
||
| 610 | return;} |
||
| 611 | for (j=0; j < 384 * cyl; j++) { // 5 cycles of all 384 colors in the wheel |
||
| 612 | for (i=0; i < riggerSize; i++) { |
||
| 613 | // tricky math! we use each pixel as a fraction of the full 384-color |
||
| 614 | // wheel (thats the i * 384 / riggerSize part) |
||
| 615 | // Then add in j which makes the colors go around per pixel |
||
| 616 | // the % 384 is to make the wheel cycle around |
||
| 617 | strip.setPixelColor(i, Wheel(((i * 384 / riggerSize) + j) % 384),ri1, ri2, ri3, ri4, ri5, ri6, ri7, ri8); |
||
| 618 | } |
||
| 619 | strip.show(); // write all the pixels out |
||
| 620 | delay(wait); |
||
| 621 | } |
||
| 622 | } |
||
| 623 | |||
| 624 | // ------------------------------------------------------------------ |
||
| 625 | // Cycling thru the colors of RGB color the wheel (all LEDs at same time) |
||
| 626 | // ------------------------------------------------------------------ |
||
| 627 | void rainbowCycleAll(uint8_t wait, uint8_t cyl, uint8_t ri1, uint8_t ri2, uint8_t ri3, uint8_t ri4, uint8_t ri5, uint8_t ri6, uint8_t ri7, uint8_t ri8) { |
||
| 628 | uint16_t i, j, w; |
||
| 629 | remoteControl(); |
||
| 630 | if (counter1 != counter2) { |
||
| 631 | return;} |
||
| 632 | for (j=0; j < 384*cyl; j++) { // cyl * cycles of all 384 colors in the wheel |
||
| 633 | for (i=0; i < riggerSize; i++) { |
||
| 634 | strip.setPixelColor(i, Wheel((j) % 384),ri1, ri2, ri3, ri4, ri5, ri6, ri7, ri8); |
||
| 635 | } |
||
| 636 | strip.show(); // write all the pixels out |
||
| 637 | for (w=0; w < wait; w++){ |
||
| 638 | delay(5); |
||
| 639 | } |
||
| 640 | } |
||
| 641 | } |
||
| 642 | |||
| 643 | |||
| 644 | // ------------------------------------------------------------------ |
||
| 645 | /* Helper function for Rainbow */ |
||
| 646 | // ------------------------------------------------------------------ |
||
| 647 | |||
| 648 | //Input a value 0 to 384 to get a color value. |
||
| 649 | //The colours are a transition r - g - b - back to r |
||
| 650 | uint32_t Wheel(uint16_t WheelPos) |
||
| 651 | { |
||
| 652 | byte r, g, b; |
||
| 653 | switch(WheelPos / 128) |
||
| 654 | { |
||
| 655 | case 0: |
||
| 656 | r = 127 - WheelPos % 128; // red down |
||
| 657 | g = WheelPos % 128; // green up |
||
| 658 | b = 0; // blue off |
||
| 659 | break; |
||
| 660 | case 1: |
||
| 661 | g = 127 - WheelPos % 128; // green down |
||
| 662 | b = WheelPos % 128; // blue up |
||
| 663 | r = 0; // red off |
||
| 664 | break; |
||
| 665 | case 2: |
||
| 666 | b = 127 - WheelPos % 128; // blue down |
||
| 667 | r = WheelPos % 128; // red up |
||
| 668 | g = 0; // green off |
||
| 669 | break; |
||
| 670 | } |
||
| 671 | return(strip.Color(r,g,b)); |
||
| 672 | } |
||
| 673 | |||
| 674 |