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) {
235 
    uint8_t x,i,j,k;
236 
    for (x = 0; x < 5; x++) {
237 
        Cube_Clear();
226 Kevin 238 
        for (i = 0; i < CUBE_LAYER_COUNT; i++) {
237 Kevin 239 
            if ((x == 0 || x == 4)&&(i == 0 || i == 7)) {
240 
                Cube_Set_Layer(i,RED);
241 
            } else if ((x == 1 || x == 4)&&(i == 1 || i == 6)) {
242 
                for (j = 1; j < CUBE_ROW_COUNT-1; j++)
243 
                    for (k = 1; k < CUBE_COLUMN_COUNT-1; k++)
244 
                        Cube_Set_Pixel(i,j,k,YELLOW);
245 
            } else if ((x == 2 || x == 4)&&(i == 2 || i == 5)) {
246 
                for (j = 2; j < CUBE_ROW_COUNT-2; j++)
247 
                    for (k = 2; k < CUBE_COLUMN_COUNT-2; k++)
226 Kevin 248 
                        Cube_Set_Pixel(i,j,k,GREEN);
237 Kevin 249 
            } else if ((x == 3 || x == 4)&&(i == 3 || i == 4)) {
250 
                for (j = 3; j < CUBE_ROW_COUNT-3; j++)
251 
                    for (k = 3; k < CUBE_COLUMN_COUNT-3; k++)
226 Kevin 252 
                        Cube_Set_Pixel(i,j,k,BLUE);
253 
            }
254 
 
237 Kevin 255 
            if ((x == 0 || x == 4)&&(i > 0 && i < 8)) {
256 
                for (j = 0; j < 8; j++) {
257 
                    Cube_Set_Pixel(i,j,0,RED);
258 
                    Cube_Set_Pixel(i,j,7,RED);
259 
                    Cube_Set_Pixel(i,0,j,RED);
260 
                    Cube_Set_Pixel(i,7,j,RED);
226 Kevin 261 
                }
262 
            }
237 Kevin 263 
            if ((x == 1 || x == 4)&&(i > 1 && i < 7)) {
264 
                for (j = 1; j < 7; j++) {
265 
                    Cube_Set_Pixel(i,j,1,YELLOW);
266 
                    Cube_Set_Pixel(i,j,6,YELLOW);
267 
                    Cube_Set_Pixel(i,1,j,YELLOW);
268 
                    Cube_Set_Pixel(i,6,j,YELLOW);
226 Kevin 269 
                }
237 Kevin 270 
            }
271 
            if ((x == 2 || x == 4)&&(i > 2 && i < 6)) {
272 
                for (j = 2; j < 6; j++) {
273 
                    Cube_Set_Pixel(i,j,2,GREEN);
274 
                    Cube_Set_Pixel(i,j,5,GREEN);
275 
                    Cube_Set_Pixel(i,2,j,GREEN);
276 
                    Cube_Set_Pixel(i,5,j,GREEN);
226 Kevin 277 
                }
278 
            }
279 
        }
237 Kevin 280 
        Delay_MS(delay_ms);
226 Kevin 281 
    }
282 
}
283 
 
237 Kevin 284 
void Animation_Double_Rotation(uint16_t delay_ms) {
226 Kevin 285 
    Cube_Clear();
237 Kevin 286 
    uint8_t x,y,z;
226 Kevin 287 
    for (z = 0; z < 3; z++) {
288 
        switch (z % 3) {
289 
            case 0:
290 
                for (y = 0; y < CUBE_LAYER_COUNT; y++) {
291 
                    Cube_Set_Pixel(y,0,0,RED);
292 
                    Cube_Set_Pixel(y,1,1,RED);
293 
                    Cube_Set_Pixel(y,2,2,RED);
294 
                    Cube_Set_Pixel(y,3,3,RED);
295 
                    Cube_Set_Pixel(y,4,4,RED);
296 
                    Cube_Set_Pixel(y,5,5,RED);
297 
                    Cube_Set_Pixel(y,6,6,RED);
298 
                    Cube_Set_Pixel(y,7,7,RED);
299 
                }
300 
                break;
301 
            case 1:
302 
                for (y = 0; y < CUBE_LAYER_COUNT; y++) {
303 
                    Cube_Set_Pixel(y,0,0,GREEN);
304 
                    Cube_Set_Pixel(y,1,1,GREEN);
305 
                    Cube_Set_Pixel(y,2,2,GREEN);
306 
                    Cube_Set_Pixel(y,3,3,GREEN);
307 
                    Cube_Set_Pixel(y,4,4,GREEN);
308 
                    Cube_Set_Pixel(y,5,5,GREEN);
309 
                    Cube_Set_Pixel(y,6,6,GREEN);
310 
                    Cube_Set_Pixel(y,7,7,GREEN);
311 
                }
312 
                break;
313 
            case 2:
314 
                for (y = 0; y < CUBE_LAYER_COUNT; y++) {
315 
                    Cube_Set_Pixel(y,0,0,BLUE);
316 
                    Cube_Set_Pixel(y,1,1,BLUE);
317 
                    Cube_Set_Pixel(y,2,2,BLUE);
318 
                    Cube_Set_Pixel(y,3,3,BLUE);
319 
                    Cube_Set_Pixel(y,4,4,BLUE);
320 
                    Cube_Set_Pixel(y,5,5,BLUE);
321 
                    Cube_Set_Pixel(y,6,6,BLUE);
322 
                    Cube_Set_Pixel(y,7,7,BLUE);
323 
                }
324 
                break;
325 
        }
326 
 
237 Kevin 327 
        for (x = 0; x < 28; x++) {
328 
            Delay_MS(delay_ms);
329 
            Cube_Rotate(0);
226 Kevin 330 
        }
331 
    }
332 
}