Subversion Repositories Code-Repo

Rev

Details | Last modification | View Log | RSS feed

Rev Author Line No. Line
226 Kevin 1 
#include "defines.h"
2 
#include "ANIMATIONS.h"
3 
#include "CUBE.h"
4 
 
237 Kevin 5 
void Animation_Solid_Colors(uint16_t delay_ms) {
6 
    Cube_Set_All(RED);
7 
    Delay_MS(delay_ms);
8 
    Cube_Set_All(GREEN);
9 
    Delay_MS(delay_ms);
10 
    Cube_Set_All(BLUE);
11 
    Delay_MS(delay_ms);
12 
}
13 
 
14 
void Animation_Layer_Alternate(uint16_t delay_ms) {
231 Kevin 15 
    uint8_t i;
237 Kevin 16 
    for (i = 0; i < CUBE_LAYER_COUNT; i++) {
17 
        if (i % 3 == 0)
18 
            Cube_Set_Layer(i,RED);
19 
        else if (i % 3 == 1)
20 
            Cube_Set_Layer(i,GREEN);
21 
        else
22 
            Cube_Set_Layer(i,BLUE);
226 Kevin 23 
    }
237 Kevin 24 
    Delay_MS(delay_ms);
25 
    for (i = 0; i < CUBE_LAYER_COUNT; i++) {
26 
        if (i % 3 == 0)
27 
            Cube_Set_Layer(i,GREEN);
28 
        else if (i % 3 == 1)
29 
            Cube_Set_Layer(i,BLUE);
30 
        else
31 
            Cube_Set_Layer(i,RED);
32 
    }
33 
    Delay_MS(delay_ms);
34 
    for (i = 0; i < CUBE_LAYER_COUNT; i++) {
35 
        if (i % 3 == 0)
36 
            Cube_Set_Layer(i,BLUE);
37 
        else if (i % 3 == 1)
38 
            Cube_Set_Layer(i,RED);
39 
        else
40 
            Cube_Set_Layer(i,GREEN);
41 
    }
42 
    Delay_MS(delay_ms);
226 Kevin 43 
}
44 
 
237 Kevin 45 
void Animation_Pixel_Alternate(uint16_t delay_ms) {
46 
    uint8_t i,j,k;
47 
    for (i = 0; i < CUBE_LAYER_COUNT; i++) {
48 
        Cube_Clear();
49 
        for (j = 0; j < CUBE_ROW_COUNT; j++) {
50 
            for (k = 0; k < CUBE_COLUMN_COUNT; k++) {
51 
                int32_t var = (j * 8) + k;
52 
                if (var % 3 == 0)
53 
                    Cube_Set_Pixel(i,j,k,RED);
54 
                else if (var % 3 == 1)
55 
                    Cube_Set_Pixel(i,j,k,GREEN);
56 
                else
57 
                    Cube_Set_Pixel(i,j,k,BLUE);
58 
            }
226 Kevin 59 
        }
60 
        Delay_MS(delay_ms);
237 Kevin 61 
        Cube_Clear();
62 
        for (j = 0; j < CUBE_ROW_COUNT; j++) {
63 
            for (k = 0; k < CUBE_COLUMN_COUNT; k++) {
64 
                int32_t var = (j * 8) + k;
65 
                if (var % 3 == 0)
66 
                    Cube_Set_Pixel(i,j,k,GREEN);
67 
                else if (var % 3 == 1)
68 
                    Cube_Set_Pixel(i,j,k,BLUE);
69 
                else
70 
                    Cube_Set_Pixel(i,j,k,RED);
71 
            }
226 Kevin 72 
        }
73 
        Delay_MS(delay_ms);
237 Kevin 74 
        Cube_Clear();
75 
        for (j = 0; j < CUBE_ROW_COUNT; j++) {
76 
            for (k = 0; k < CUBE_COLUMN_COUNT; k++) {
77 
                int32_t var = (j * 8) + k;
78 
                if (var % 3 == 0)
79 
                    Cube_Set_Pixel(i,j,k,BLUE);
80 
                else if (var % 3 == 1)
81 
                    Cube_Set_Pixel(i,j,k,RED);
82 
                else
83 
                    Cube_Set_Pixel(i,j,k,GREEN);
84 
            }
226 Kevin 85 
        }
86 
        Delay_MS(delay_ms);
87 
    }
88 
}
89 
 
237 Kevin 90 
void Animation_Full_Color_Sweep(uint16_t delay_us) {
91 
    int16_t i;
92 
    for (i = 0; i < 0x0FF; i+=2) {
93 
        Cube_Set_All(i,0,0);
94 
        Delay_US(delay_us);
95 
    }
96 
    for (i = 0; i < 0x0FF; i+=2) {
97 
        Cube_Set_All(0x0FF,i,0);
98 
        Delay_US(delay_us);
99 
    }
100 
    for (i = 0x0FF; i >= 0; i-=2) {
101 
        Cube_Set_All(i,0x0FF,0);
102 
        Delay_US(delay_us);
103 
    }
104 
    for (i = 0; i < 0x0FF; i+=2) {
105 
        Cube_Set_All(0,0x0FF,i);
106 
        Delay_US(delay_us);
107 
    }
108 
    for (i = 0; i < 0x0FF; i+=2) {
109 
        Cube_Set_All(i,0x0FF,0x0FF);
110 
        Delay_US(delay_us);
111 
    }
112 
    for (i = 0x0FF; i >= 0; i-=2) {
113 
        Cube_Set_All(0x0FF,i,0x0FF);
114 
        Delay_US(delay_us);
115 
    }
116 
    for (i = 0x0FF; i >= 0; i-=2) {
117 
        Cube_Set_All(i,0,0x0FF);
118 
        Delay_US(delay_us);
119 
    }
120 
    for (i = 0x0FF; i >= 0; i-=2) {
121 
        Cube_Set_All(0,0,i);
122 
        Delay_US(delay_us);
123 
    }
124 
}
125 
 
126 
void Animation_Row_Column_Sweep(uint16_t delay_ms) {
127 
    uint8_t i,j,k,a;
128 
    for (i = 0; i < 3; i++) {
129 
        for (j = 0; j < CUBE_ROW_COUNT; j++) {
226 Kevin 130 
            Cube_Clear();
237 Kevin 131 
            for (k = 0; k < CUBE_COLUMN_COUNT; k++)
132 
                if (i % 3 == 0)
133 
                    for (a = 0; a < CUBE_LAYER_COUNT; a++)
134 
                        Cube_Set_Pixel(a,j,k,RED);
135 
                else if (i % 3 == 1)
136 
                    for (a = 0; a < CUBE_LAYER_COUNT; a++)
137 
                        Cube_Set_Pixel(a,j,k,GREEN);
138 
                else
139 
                    for (a = 0; a < CUBE_LAYER_COUNT; a++)
140 
                        Cube_Set_Pixel(a,j,k,BLUE);
226 Kevin 141 
            Delay_MS(delay_ms);
237 Kevin 142 
        }
143 
        for (j = 0; j < CUBE_ROW_COUNT; j++) {
226 Kevin 144 
            Cube_Clear();
237 Kevin 145 
            for (k = 0; k < CUBE_COLUMN_COUNT; k++)
146 
                if (i % 3 == 0)
147 
                    for (a = 0; a < CUBE_LAYER_COUNT; a++)
148 
                        Cube_Set_Pixel(a,k,j,RED);
149 
                else if (i % 3 == 1)
150 
                    for (a = 0; a < CUBE_LAYER_COUNT; a++)
151 
                        Cube_Set_Pixel(a,k,j,GREEN);
152 
                else
153 
                    for (a = 0; a < CUBE_LAYER_COUNT; a++)
154 
                        Cube_Set_Pixel(a,k,j,BLUE);
155 
            Delay_MS(delay_ms);
156 
        }
157 
        for (j = CUBE_LAYER_COUNT; j != 0; j--) {
158 
            Cube_Clear();
159 
            if (i % 3 == 0) {
160 
                for (k = 0; k < CUBE_LAYER_COUNT; k++)
161 
                    if (k == j)
162 
                        Cube_Set_Layer(k,RED);
163 
            } else if (i % 3 == 1) {
164 
                for (k = 0; k < CUBE_LAYER_COUNT; k++)
165 
                    if (k == j)
166 
                        Cube_Set_Layer(k,GREEN);
167 
            } else {
168 
                for (k = 0; k < CUBE_LAYER_COUNT; k++)
169 
                    if (k == j)
170 
                        Cube_Set_Layer(k,BLUE);
226 Kevin 171 
            }
172 
            Delay_MS(delay_ms);
237 Kevin 173 
        }
174 
    }
175 
}
176 
 
177 
void Animation_Pixel_Sweep(uint16_t delay_ms) {
178 
    uint8_t i,j,k,a;
179 
    for (a = 0; a < 3; a++) {
180 
        for (i = 0; i < CUBE_LAYER_COUNT; i++) {
226 Kevin 181 
            for (j = 0; j < CUBE_ROW_COUNT; j++) {
182 
                for (k = 0; k < CUBE_COLUMN_COUNT; k++) {
237 Kevin 183 
                    Cube_Clear();
184 
                    if (a % 3 == 0) {
226 Kevin 185 
                        Cube_Set_Pixel(i,j,k,RED);
237 Kevin 186 
                    } else if (a % 3 == 1) {
226 Kevin 187 
                        Cube_Set_Pixel(i,j,k,GREEN);
237 Kevin 188 
                    } else {
189 
                        Cube_Set_Pixel(i,j,k,BLUE);
190 
                    }
191 
                    Delay_MS(delay_ms);
226 Kevin 192 
                }
193 
            }
194 
        }
195 
    }
196 
}
197 
 
237 Kevin 198 
void Animation_Pseudo_Random_Colors(uint16_t delay_ms) {
199 
    uint8_t i,j,k;
200 
    for (i = 0; i < CUBE_LAYER_COUNT; i++) {
201 
        for (j = 0; j < CUBE_ROW_COUNT; j++) {
202 
            for (k = 0; k < CUBE_COLUMN_COUNT; k++) {
203 
                uint32_t a = rand();
204 
                if (a % 5 == 0)
205 
                    Cube_Set_Pixel(i,j,k,RED);
206 
                else if (a % 5 == 1)
207 
                    Cube_Set_Pixel(i,j,k,GREEN);
208 
                else if (a % 5 == 2)
209 
                    Cube_Set_Pixel(i,j,k,BLUE);
210 
                else if (a % 5 == 3)
211 
                    Cube_Set_Pixel(i,j,k,PURPLE);
212 
                else if (a % 5 == 4)
213 
                    Cube_Set_Pixel(i,j,k,YELLOW);
214 
                else
215 
                    Cube_Set_Pixel(i,j,k,ORANGE);
226 Kevin 216 
            }
217 
        }
218 
    }
237 Kevin 219 
    Delay_MS(delay_ms);
226 Kevin 220 
}
221 
 
237 Kevin 222 
void Animation_Random_Colors(uint16_t delay_ms) {
223 
    uint8_t i,j,k;
224 
    for (i = 0; i < CUBE_LAYER_COUNT; i++) {
225 
        for (j = 0; j < CUBE_ROW_COUNT; j++) {
226 
            for (k = 0; k < CUBE_COLUMN_COUNT; k++) {
227 
                Cube_Set_Pixel(i,j,k,rand()&0x0FF,rand()&0x0FF,rand()&0x0FF);
226 Kevin 228 
            }
229 
        }
230 
    }
237 Kevin 231 
    Delay_MS(delay_ms);
226 Kevin 232 
}
233 
 
237 Kevin 234 
void Animation_Cube_In_Cube(uint16_t delay_ms) {
264 Kevin 235 
    uint8_t x;
237 Kevin 236 
    for (x = 0; x < 5; x++) {
237 
        Cube_Clear();
264 Kevin 238 
        if (x == 0)
239 
            Cube_Set_Shell(0, RED);
240 
        else if (x == 1)
241 
            Cube_Set_Shell(1, YELLOW);
242 
        else if (x == 2)
243 
            Cube_Set_Shell(2, GREEN);
244 
        else if (x == 3)
245 
            Cube_Set_Shell(3, BLUE);
246 
        else {
247 
            Cube_Set_Shell(0, RED);
248 
            Cube_Set_Shell(1, YELLOW);
249 
            Cube_Set_Shell(2, GREEN);
250 
            Cube_Set_Shell(3, BLUE);
226 Kevin 251 
        }
237 Kevin 252 
        Delay_MS(delay_ms);
226 Kevin 253 
    }
254 
}
255 
 
242 Kevin 256 
void Animation_Cube_In_Out(uint16_t delay_ms, uint16_t r, uint16_t g, uint16_t b) {
257 
    uint8_t x,i,j,k;
258 
    for (x = 0; x < 7; x++) {
259 
        Cube_Clear();
260 
        for (i = 0; i < CUBE_LAYER_COUNT; i++) {
261 
            if ((x == 0 || x == 6)&&(i == 0 || i == 7)) {
262 
                Cube_Set_Layer(i,r,g,b);
263 
            } else if ((x == 1 || x == 5)&&(i == 1 || i == 6)) {
264 
                for (j = 1; j < CUBE_ROW_COUNT-1; j++)
265 
                    for (k = 1; k < CUBE_COLUMN_COUNT-1; k++)
266 
                        Cube_Set_Pixel(i,j,k,r,g,b);
267 
            } else if ((x == 2 || x == 4)&&(i == 2 || i == 5)) {
268 
                for (j = 2; j < CUBE_ROW_COUNT-2; j++)
269 
                    for (k = 2; k < CUBE_COLUMN_COUNT-2; k++)
270 
                        Cube_Set_Pixel(i,j,k,r,g,b);
271 
            } else if ((x == 3)&&(i == 3 || i == 4)) {
272 
                for (j = 3; j < CUBE_ROW_COUNT-3; j++)
273 
                    for (k = 3; k < CUBE_COLUMN_COUNT-3; k++)
274 
                        Cube_Set_Pixel(i,j,k,r,g,b);
275 
            }
276 
 
277 
            if ((x == 0 || x == 6)&&(i > 0 && i < 8)) {
278 
                for (j = 0; j < 8; j++) {
279 
                    Cube_Set_Pixel(i,j,0,r,g,b);
280 
                    Cube_Set_Pixel(i,j,7,r,g,b);
281 
                    Cube_Set_Pixel(i,0,j,r,g,b);
282 
                    Cube_Set_Pixel(i,7,j,r,g,b);
283 
                }
284 
            }
285 
            if ((x == 1 || x == 5)&&(i > 1 && i < 7)) {
286 
                for (j = 1; j < 7; j++) {
287 
                    Cube_Set_Pixel(i,j,1,r,g,b);
288 
                    Cube_Set_Pixel(i,j,6,r,g,b);
289 
                    Cube_Set_Pixel(i,1,j,r,g,b);
290 
                    Cube_Set_Pixel(i,6,j,r,g,b);
291 
                }
292 
            }
293 
            if ((x == 2 || x == 4)&&(i > 2 && i < 6)) {
294 
                for (j = 2; j < 6; j++) {
295 
                    Cube_Set_Pixel(i,j,2,r,g,b);
296 
                    Cube_Set_Pixel(i,j,5,r,g,b);
297 
                    Cube_Set_Pixel(i,2,j,r,g,b);
298 
                    Cube_Set_Pixel(i,5,j,r,g,b);
299 
                }
300 
            }
301 
        }
302 
        Delay_MS(delay_ms);
303 
    }
304 
}
305 
 
237 Kevin 306 
void Animation_Double_Rotation(uint16_t delay_ms) {
226 Kevin 307 
    Cube_Clear();
237 Kevin 308 
    uint8_t x,y,z;
226 Kevin 309 
    for (z = 0; z < 3; z++) {
310 
        switch (z % 3) {
311 
            case 0:
312 
                for (y = 0; y < CUBE_LAYER_COUNT; y++) {
313 
                    Cube_Set_Pixel(y,0,0,RED);
314 
                    Cube_Set_Pixel(y,1,1,RED);
315 
                    Cube_Set_Pixel(y,2,2,RED);
316 
                    Cube_Set_Pixel(y,3,3,RED);
317 
                    Cube_Set_Pixel(y,4,4,RED);
318 
                    Cube_Set_Pixel(y,5,5,RED);
319 
                    Cube_Set_Pixel(y,6,6,RED);
320 
                    Cube_Set_Pixel(y,7,7,RED);
321 
                }
322 
                break;
323 
            case 1:
324 
                for (y = 0; y < CUBE_LAYER_COUNT; y++) {
325 
                    Cube_Set_Pixel(y,0,0,GREEN);
326 
                    Cube_Set_Pixel(y,1,1,GREEN);
327 
                    Cube_Set_Pixel(y,2,2,GREEN);
328 
                    Cube_Set_Pixel(y,3,3,GREEN);
329 
                    Cube_Set_Pixel(y,4,4,GREEN);
330 
                    Cube_Set_Pixel(y,5,5,GREEN);
331 
                    Cube_Set_Pixel(y,6,6,GREEN);
332 
                    Cube_Set_Pixel(y,7,7,GREEN);
333 
                }
334 
                break;
335 
            case 2:
336 
                for (y = 0; y < CUBE_LAYER_COUNT; y++) {
337 
                    Cube_Set_Pixel(y,0,0,BLUE);
338 
                    Cube_Set_Pixel(y,1,1,BLUE);
339 
                    Cube_Set_Pixel(y,2,2,BLUE);
340 
                    Cube_Set_Pixel(y,3,3,BLUE);
341 
                    Cube_Set_Pixel(y,4,4,BLUE);
342 
                    Cube_Set_Pixel(y,5,5,BLUE);
343 
                    Cube_Set_Pixel(y,6,6,BLUE);
344 
                    Cube_Set_Pixel(y,7,7,BLUE);
345 
                }
346 
                break;
347 
        }
348 
 
237 Kevin 349 
        for (x = 0; x < 28; x++) {
350 
            Delay_MS(delay_ms);
351 
            Cube_Rotate(0);
226 Kevin 352 
        }
353 
    }
354 
}
264 Kevin 355 
 
356 
void Animation_Wave1(uint16_t delay_ms) {
357 
    uint8_t i, j;
358 
    uint8_t data[8];
359 
 
360 
    for (i = 0; i < 16; i++) {
361 
        for (j = 0; j < 8; j++)
362 
            data[j] = rand() % 9;
363 
        Cube_Shift_Waterfall(data);
364 
        Delay_MS(delay_ms);
365 
    }
366 
}
367 
 
368 
void Animation_Wave2(uint16_t delay_ms) {
369 
    uint8_t i, j;
370 
    uint8_t data[8];
371 
 
372 
    for (i = 0; i < 16; i++) {
373 
        for (j = 0; j < 8; j++)
374 
            data[j] = rand() % 9;
375 
        Cube_Shift_Waterfall2(data);
376 
        Delay_MS(delay_ms);
377 
    }
378 
}
379 
 
380 
void Animation_Sphere(uint16_t delay_ms) {
381 
    Cube_Clear();
382 
    Cube_Set_Sphere(0, RED);
383 
    Delay_MS(delay_ms);
384 
    Cube_Clear();
385 
    Cube_Set_Sphere(1, ORANGE);
386 
    Delay_MS(delay_ms);
387 
    Cube_Clear();
388 
    Cube_Set_Sphere(2, YELLOW);
389 
    Delay_MS(delay_ms);
390 
    Cube_Clear();
391 
    Cube_Set_Sphere(3, GREEN);
392 
    Delay_MS(delay_ms);
393 
    Cube_Clear();
394 
    Cube_Set_Sphere(4, BLUE);
395 
    Delay_MS(delay_ms);
396 
    Cube_Clear();
397 
    Cube_Set_Sphere(5, PURPLE);
398 
    Delay_MS(delay_ms);
399 
    Cube_Clear();
400 
    Cube_Set_Sphere(6, RED);
401 
    Delay_MS(delay_ms);
402 
    Cube_Clear();
403 
    Cube_Set_Sphere(7, ORANGE);
404 
    Delay_MS(delay_ms);
405 
    Cube_Clear();
406 
    Cube_Set_Sphere(8, YELLOW);
407 
    Delay_MS(delay_ms);
268 Kevin 408 
    Cube_Clear();
409 
    Cube_Set_Sphere(7, ORANGE);
410 
    Delay_MS(delay_ms);
411 
    Cube_Clear();
412 
    Cube_Set_Sphere(6, RED);
413 
    Delay_MS(delay_ms);
414 
    Cube_Clear();
415 
    Cube_Set_Sphere(5, PURPLE);
416 
    Delay_MS(delay_ms);
417 
    Cube_Clear();
418 
    Cube_Set_Sphere(4, BLUE);
419 
    Delay_MS(delay_ms);
420 
    Cube_Clear();
421 
    Cube_Set_Sphere(3, GREEN);
422 
    Delay_MS(delay_ms);
423 
    Cube_Clear();
424 
    Cube_Set_Sphere(2, YELLOW);
425 
    Delay_MS(delay_ms);
426 
    Cube_Clear();
427 
    Cube_Set_Sphere(1, ORANGE);
428 
    Delay_MS(delay_ms);
429 
    Cube_Clear();
264 Kevin 430 
}
431 
 
432 
void Animation_Sawtooth(uint16_t delay_ms) {
433 
    uint8_t i;
434 
    uint8_t dir = 1;
435 
    uint8_t layer_dir = 1;
436 
    uint8_t layer_min = 0;
437 
    uint8_t layer_max = CUBE_LAYER_COUNT;
438 
    uint8_t layer = layer_min;
439 
 
440 
    for (i = 0; i < 48; i++) {
441 
        Cube_Set_Row(7, 0x00, 0x00, 0x00);
442 
        Cube_Set_Pixel(layer, 7, 0, RED);
443 
        Cube_Set_Pixel(layer, 7, 1, ORANGE);
444 
        Cube_Set_Pixel(layer, 7, 2, YELLOW);
445 
        Cube_Set_Pixel(layer, 7, 3, GREEN);
446 
        Cube_Set_Pixel(layer, 7, 4, TEAL);
447 
        Cube_Set_Pixel(layer, 7, 5, BLUE);
448 
        Cube_Set_Pixel(layer, 7, 6, PURPLE);
449 
        Cube_Set_Pixel(layer, 7, 7, WHITE);
450 
 
451 
        if (dir)
452 
            layer++;
453 
        else
454 
            layer--;
455 
 
456 
        // Decrease the maximum layer
457 
        if (layer == layer_min) {
458 
            dir = 1;
459 
            if (layer_dir)
460 
                layer_max--;
461 
            else
462 
                layer_max++;
463 
        }
464 
 
465 
        // Increase the minimum layer
466 
        if (layer == layer_max - 1) {
467 
            dir = 0;
468 
            if (layer_dir)
469 
                layer_min++;
470 
            else
471 
                layer_min--;
472 
        }
473 
 
474 
        // Change the layer gap to expansion
475 
        if (layer_max - layer_min < 3) {
476 
            if (layer_dir)
477 
                layer_dir = 0;
478 
            else
479 
                layer_dir = 1;
480 
        }
481 
 
482 
        // Change the layer gap to reduction
483 
        if (layer == 0) {
484 
            if (layer_dir)
485 
                layer_dir = 0;
486 
            else
487 
                layer_dir = 1;
488 
        }
489 
 
490 
        Delay_MS(delay_ms);
491 
        Cube_Shift_Row(0);
492 
    }
493 
}