Subversion Repositories Code-Repo

Rev

Rev 276 | Details | Compare with Previous | 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;
274 Kevin 236 
    for (x = 0; x < 6; x++) {
237 Kevin 237 
        Cube_Clear();
264 Kevin 238 
        if (x == 0)
239 
            Cube_Set_Shell(0, RED);
274 Kevin 240 
        else if (x == 1 || x == 5)
264 Kevin 241 
            Cube_Set_Shell(1, YELLOW);
274 Kevin 242 
        else if (x == 2 || x == 4)
264 Kevin 243 
            Cube_Set_Shell(2, GREEN);
244 
        else if (x == 3)
245 
            Cube_Set_Shell(3, BLUE);
237 Kevin 246 
        Delay_MS(delay_ms);
226 Kevin 247 
    }
248 
}
249 
 
242 Kevin 250 
void Animation_Cube_In_Out(uint16_t delay_ms, uint16_t r, uint16_t g, uint16_t b) {
251 
    uint8_t x,i,j,k;
252 
    for (x = 0; x < 7; x++) {
253 
        Cube_Clear();
274 Kevin 254 
        switch (x % 7) {
255 
            case 0:
256 
                Cube_Set_Shell(3, r, g, b);
257 
                break;
258 
            case 1:
259 
                Cube_Set_Shell(2, r, g, b);
260 
                break;
261 
            case 2:
262 
                Cube_Set_Shell(1, r, g, b);
263 
                break;
264 
            case 3:
265 
                Cube_Set_Shell(0, r, g, b);
266 
                break;
267 
            case 4:
268 
                Cube_Set_Shell(1, r, g, b);
269 
                break;
270 
            case 5:
271 
                Cube_Set_Shell(2, r, g, b);
272 
                break;
273 
            case 6:
274 
                Cube_Set_Shell(3, r, g, b);
275 
                break;
276 
        }
242 Kevin 277 
 
274 Kevin 278 
//        for (i = 0; i < CUBE_LAYER_COUNT; i++) {
279 
//            if ((x == 0 || x == 6)&&(i == 0 || i == 7)) {
280 
//                Cube_Set_Layer(i,r,g,b);
281 
//            } else if ((x == 1 || x == 5)&&(i == 1 || i == 6)) {
282 
//                for (j = 1; j < CUBE_ROW_COUNT-1; j++)
283 
//                    for (k = 1; k < CUBE_COLUMN_COUNT-1; k++)
284 
//                        Cube_Set_Pixel(i,j,k,r,g,b);
285 
//            } else if ((x == 2 || x == 4)&&(i == 2 || i == 5)) {
286 
//                for (j = 2; j < CUBE_ROW_COUNT-2; j++)
287 
//                    for (k = 2; k < CUBE_COLUMN_COUNT-2; k++)
288 
//                        Cube_Set_Pixel(i,j,k,r,g,b);
289 
//            } else if ((x == 3)&&(i == 3 || i == 4)) {
290 
//                for (j = 3; j < CUBE_ROW_COUNT-3; j++)
291 
//                    for (k = 3; k < CUBE_COLUMN_COUNT-3; k++)
292 
//                        Cube_Set_Pixel(i,j,k,r,g,b);
293 
//            }
294 
//
295 
//            if ((x == 0 || x == 6)&&(i > 0 && i < 8)) {
296 
//                for (j = 0; j < 8; j++) {
297 
//                    Cube_Set_Pixel(i,j,0,r,g,b);
298 
//                    Cube_Set_Pixel(i,j,7,r,g,b);
299 
//                    Cube_Set_Pixel(i,0,j,r,g,b);
300 
//                    Cube_Set_Pixel(i,7,j,r,g,b);
301 
//                }
302 
//            }
303 
//            if ((x == 1 || x == 5)&&(i > 1 && i < 7)) {
304 
//                for (j = 1; j < 7; j++) {
305 
//                    Cube_Set_Pixel(i,j,1,r,g,b);
306 
//                    Cube_Set_Pixel(i,j,6,r,g,b);
307 
//                    Cube_Set_Pixel(i,1,j,r,g,b);
308 
//                    Cube_Set_Pixel(i,6,j,r,g,b);
309 
//                }
310 
//            }
311 
//            if ((x == 2 || x == 4)&&(i > 2 && i < 6)) {
312 
//                for (j = 2; j < 6; j++) {
313 
//                    Cube_Set_Pixel(i,j,2,r,g,b);
314 
//                    Cube_Set_Pixel(i,j,5,r,g,b);
315 
//                    Cube_Set_Pixel(i,2,j,r,g,b);
316 
//                    Cube_Set_Pixel(i,5,j,r,g,b);
317 
//                }
318 
//            }
319 
//        }
242 Kevin 320 
        Delay_MS(delay_ms);
321 
    }
322 
}
323 
 
237 Kevin 324 
void Animation_Double_Rotation(uint16_t delay_ms) {
226 Kevin 325 
    Cube_Clear();
237 Kevin 326 
    uint8_t x,y,z;
226 Kevin 327 
 
274 Kevin 328 
    for (y = 0; y < CUBE_LAYER_COUNT; y++) {
329 
        Cube_Set_Pixel(y,0,0,RED);
330 
        Cube_Set_Pixel(y,1,1,ORANGE);
331 
        Cube_Set_Pixel(y,2,2,YELLOW);
332 
        Cube_Set_Pixel(y,3,3,GREEN);
333 
        Cube_Set_Pixel(y,4,4,TEAL);
334 
        Cube_Set_Pixel(y,5,5,BLUE);
335 
        Cube_Set_Pixel(y,6,6,PURPLE);
336 
        Cube_Set_Pixel(y,7,7,WHITE);
226 Kevin 337 
    }
274 Kevin 338 
 
339 
    for (x = 0; x < 28; x++) {
340 
        Delay_MS(delay_ms);
341 
        Cube_Rotate(0);
342 
    }
226 Kevin 343 
}
264 Kevin 344 
 
274 Kevin 345 
//    for (z = 0; z < 3; z++) {
346 
//        switch (z % 3) {
347 
//            case 0:
348 
//                for (y = 0; y < CUBE_LAYER_COUNT; y++) {
349 
//                    Cube_Set_Pixel(y,0,0,RED);
350 
//                    Cube_Set_Pixel(y,1,1,RED);
351 
//                    Cube_Set_Pixel(y,2,2,RED);
352 
//                    Cube_Set_Pixel(y,3,3,RED);
353 
//                    Cube_Set_Pixel(y,4,4,RED);
354 
//                    Cube_Set_Pixel(y,5,5,RED);
355 
//                    Cube_Set_Pixel(y,6,6,RED);
356 
//                    Cube_Set_Pixel(y,7,7,RED);
357 
//                }
358 
//                break;
359 
//            case 1:
360 
//                for (y = 0; y < CUBE_LAYER_COUNT; y++) {
361 
//                    Cube_Set_Pixel(y,0,0,GREEN);
362 
//                    Cube_Set_Pixel(y,1,1,GREEN);
363 
//                    Cube_Set_Pixel(y,2,2,GREEN);
364 
//                    Cube_Set_Pixel(y,3,3,GREEN);
365 
//                    Cube_Set_Pixel(y,4,4,GREEN);
366 
//                    Cube_Set_Pixel(y,5,5,GREEN);
367 
//                    Cube_Set_Pixel(y,6,6,GREEN);
368 
//                    Cube_Set_Pixel(y,7,7,GREEN);
369 
//                }
370 
//                break;
371 
//            case 2:
372 
//                for (y = 0; y < CUBE_LAYER_COUNT; y++) {
373 
//                    Cube_Set_Pixel(y,0,0,BLUE);
374 
//                    Cube_Set_Pixel(y,1,1,BLUE);
375 
//                    Cube_Set_Pixel(y,2,2,BLUE);
376 
//                    Cube_Set_Pixel(y,3,3,BLUE);
377 
//                    Cube_Set_Pixel(y,4,4,BLUE);
378 
//                    Cube_Set_Pixel(y,5,5,BLUE);
379 
//                    Cube_Set_Pixel(y,6,6,BLUE);
380 
//                    Cube_Set_Pixel(y,7,7,BLUE);
381 
//                }
382 
//                break;
383 
//        }
384 
//
385 
//        for (x = 0; x < 28; x++) {
386 
//            Delay_MS(delay_ms);
387 
//            Cube_Rotate(0);
388 
//        }
389 
//    }
390 
//}
391 
 
264 Kevin 392 
void Animation_Wave1(uint16_t delay_ms) {
393 
    uint8_t i, j;
274 Kevin 394 
    static uint8_t data[8];
395 
    uint32_t r;
264 Kevin 396 
 
397 
    for (i = 0; i < 16; i++) {
274 Kevin 398 
        for (j = 0; j < 8; j++) {
399 
            r = rand();
400 
            if (r % 3 == 0) {
401 
                // Increase
276 Kevin 402 
                data[j] = (data[j] == CUBE_LAYER_COUNT) ? data[j] : data[j] + 1;
274 Kevin 403 
            } else if (r % 3 == 1) {
404 
                // Decrease
405 
                data[j] = (data[j] == 0) ? data[j] : data[j] - 1;
406 
            } else {
407 
                // No change
408 
                data[j] = data[j];
409 
            }
410 
        }
264 Kevin 411 
        Cube_Shift_Waterfall(data);
412 
        Delay_MS(delay_ms);
413 
    }
414 
}
415 
 
416 
void Animation_Wave2(uint16_t delay_ms) {
417 
    uint8_t i, j;
274 Kevin 418 
    static uint8_t data[8];
419 
    uint32_t r;
420 
 
264 Kevin 421 
    for (i = 0; i < 16; i++) {
274 Kevin 422 
        for (j = 0; j < 8; j++) {
423 
            r = rand();
424 
            if (r % 3 == 0) {
425 
                // Increase
276 Kevin 426 
                data[j] = (data[j] == CUBE_LAYER_COUNT) ? data[j] : data[j] + 1;
274 Kevin 427 
            } else if (r % 3 == 1) {
428 
                // Decrease
429 
                data[j] = (data[j] == 0) ? data[j] : data[j] - 1;
430 
            } else {
431 
                // No change
432 
                data[j] = data[j];
433 
            }
434 
        }
264 Kevin 435 
        Cube_Shift_Waterfall2(data);
436 
        Delay_MS(delay_ms);
437 
    }
438 
}
439 
 
440 
void Animation_Sphere(uint16_t delay_ms) {
441 
    Cube_Clear();
442 
    Cube_Set_Sphere(0, RED);
443 
    Delay_MS(delay_ms);
444 
    Cube_Clear();
445 
    Cube_Set_Sphere(1, ORANGE);
446 
    Delay_MS(delay_ms);
447 
    Cube_Clear();
448 
    Cube_Set_Sphere(2, YELLOW);
449 
    Delay_MS(delay_ms);
450 
    Cube_Clear();
451 
    Cube_Set_Sphere(3, GREEN);
452 
    Delay_MS(delay_ms);
453 
    Cube_Clear();
454 
    Cube_Set_Sphere(4, BLUE);
455 
    Delay_MS(delay_ms);
456 
    Cube_Clear();
457 
    Cube_Set_Sphere(5, PURPLE);
458 
    Delay_MS(delay_ms);
459 
    Cube_Clear();
460 
    Cube_Set_Sphere(6, RED);
461 
    Delay_MS(delay_ms);
462 
    Cube_Clear();
463 
    Cube_Set_Sphere(7, ORANGE);
464 
    Delay_MS(delay_ms);
465 
    Cube_Clear();
466 
    Cube_Set_Sphere(8, YELLOW);
467 
    Delay_MS(delay_ms);
268 Kevin 468 
    Cube_Clear();
469 
    Cube_Set_Sphere(7, ORANGE);
470 
    Delay_MS(delay_ms);
471 
    Cube_Clear();
472 
    Cube_Set_Sphere(6, RED);
473 
    Delay_MS(delay_ms);
474 
    Cube_Clear();
475 
    Cube_Set_Sphere(5, PURPLE);
476 
    Delay_MS(delay_ms);
477 
    Cube_Clear();
478 
    Cube_Set_Sphere(4, BLUE);
479 
    Delay_MS(delay_ms);
480 
    Cube_Clear();
481 
    Cube_Set_Sphere(3, GREEN);
482 
    Delay_MS(delay_ms);
483 
    Cube_Clear();
484 
    Cube_Set_Sphere(2, YELLOW);
485 
    Delay_MS(delay_ms);
486 
    Cube_Clear();
487 
    Cube_Set_Sphere(1, ORANGE);
488 
    Delay_MS(delay_ms);
489 
    Cube_Clear();
264 Kevin 490 
}
491 
 
492 
void Animation_Sawtooth(uint16_t delay_ms) {
493 
    uint8_t i;
494 
    uint8_t dir = 1;
495 
    uint8_t layer_dir = 1;
496 
    uint8_t layer_min = 0;
497 
    uint8_t layer_max = CUBE_LAYER_COUNT;
498 
    uint8_t layer = layer_min;
499 
 
500 
    for (i = 0; i < 48; i++) {
501 
        Cube_Set_Row(7, 0x00, 0x00, 0x00);
502 
        Cube_Set_Pixel(layer, 7, 0, RED);
503 
        Cube_Set_Pixel(layer, 7, 1, ORANGE);
504 
        Cube_Set_Pixel(layer, 7, 2, YELLOW);
505 
        Cube_Set_Pixel(layer, 7, 3, GREEN);
506 
        Cube_Set_Pixel(layer, 7, 4, TEAL);
507 
        Cube_Set_Pixel(layer, 7, 5, BLUE);
508 
        Cube_Set_Pixel(layer, 7, 6, PURPLE);
509 
        Cube_Set_Pixel(layer, 7, 7, WHITE);
510 
 
511 
        if (dir)
512 
            layer++;
513 
        else
514 
            layer--;
515 
 
516 
        // Decrease the maximum layer
517 
        if (layer == layer_min) {
518 
            dir = 1;
519 
            if (layer_dir)
520 
                layer_max--;
521 
            else
522 
                layer_max++;
523 
        }
524 
 
525 
        // Increase the minimum layer
526 
        if (layer == layer_max - 1) {
527 
            dir = 0;
528 
            if (layer_dir)
529 
                layer_min++;
530 
            else
531 
                layer_min--;
532 
        }
533 
 
534 
        // Change the layer gap to expansion
535 
        if (layer_max - layer_min < 3) {
536 
            if (layer_dir)
537 
                layer_dir = 0;
538 
            else
539 
                layer_dir = 1;
540 
        }
541 
 
542 
        // Change the layer gap to reduction
543 
        if (layer == 0) {
544 
            if (layer_dir)
545 
                layer_dir = 0;
546 
            else
547 
                layer_dir = 1;
548 
        }
549 
 
550 
        Delay_MS(delay_ms);
551 
        Cube_Shift_Row(0);
552 
    }
553 
}