Subversion Repositories Code-Repo

Rev

Rev 231 | Show entire file | Ignore whitespace | Details | Blame | Last modification | View Log | RSS feed

Rev 231 Rev 237
Line 1... Line 1...
1 
#include "defines.h"
 1 
#include "defines.h"
2 
#include "ANIMATIONS.h"
 2 
#include "ANIMATIONS.h"
3 
#include "CUBE.h"
 3 
#include "CUBE.h"
4 
 
 4 
 
5 
void Animation_Solid_Colors(uint8_t iterations, uint16_t delay_ms) {
 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) {
6 
    uint8_t i;
 15 
    uint8_t i;
7 
    for (i = 0; i < iterations; i++) {
 16 
    for (i = 0; i < CUBE_LAYER_COUNT; i++) {
- 
 
 17 
        if (i % 3 == 0)
8 
        Cube_Set_All(RED);
 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);
- 
 
 23 
    }
9 
        Delay_MS(delay_ms);
 24 
    Delay_MS(delay_ms);
- 
 
 25 
    for (i = 0; i < CUBE_LAYER_COUNT; i++) {
- 
 
 26 
        if (i % 3 == 0)
10 
        Cube_Set_All(GREEN);
 27 
            Cube_Set_Layer(i,GREEN);
11 
        Delay_MS(delay_ms);
 28 
        else if (i % 3 == 1)
12 
        Cube_Set_All(BLUE);
 29 
            Cube_Set_Layer(i,BLUE);
- 
 
 30 
        else
13 
        Delay_MS(delay_ms);
 31 
            Cube_Set_Layer(i,RED);
14 
    }
 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);
15 
}
 43 
}
16 
 
 44 
 
17 
void Animation_Layer_Alternate(uint8_t iterations, uint16_t delay_ms) {
 45 
void Animation_Pixel_Alternate(uint16_t delay_ms) {
18 
    uint8_t i,z;
 46 
    uint8_t i,j,k;
19 
    for (z = 0; z < iterations; z++) {
 47 
    for (i = 0; i < CUBE_LAYER_COUNT; i++) {
- 
 
 48 
        Cube_Clear();
20 
        for (i = 0; i < CUBE_LAYER_COUNT; i++) {
 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;
21 
            if (i % 3 == 0)
 52 
                if (var % 3 == 0)
22 
                Cube_Set_Layer(i,RED);
 53 
                    Cube_Set_Pixel(i,j,k,RED);
23 
            else if (i % 3 == 1)
 54 
                else if (var % 3 == 1)
24 
                Cube_Set_Layer(i,GREEN);
 55 
                    Cube_Set_Pixel(i,j,k,GREEN);
25 
            else
 56 
                else
26 
                Cube_Set_Layer(i,BLUE);
 57 
                    Cube_Set_Pixel(i,j,k,BLUE);
- 
 
 58 
            }
27 
        }
 59 
        }
28 
        Delay_MS(delay_ms);
 60 
        Delay_MS(delay_ms);
- 
 
 61 
        Cube_Clear();
29 
        for (i = 0; i < CUBE_LAYER_COUNT; i++) {
 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;
30 
            if (i % 3 == 0)
 65 
                if (var % 3 == 0)
31 
                Cube_Set_Layer(i,GREEN);
 66 
                    Cube_Set_Pixel(i,j,k,GREEN);
32 
            else if (i % 3 == 1)
 67 
                else if (var % 3 == 1)
33 
                Cube_Set_Layer(i,BLUE);
 68 
                    Cube_Set_Pixel(i,j,k,BLUE);
34 
            else
 69 
                else
35 
                Cube_Set_Layer(i,RED);
 70 
                    Cube_Set_Pixel(i,j,k,RED);
- 
 
 71 
            }
36 
        }
 72 
        }
37 
        Delay_MS(delay_ms);
 73 
        Delay_MS(delay_ms);
- 
 
 74 
        Cube_Clear();
38 
        for (i = 0; i < CUBE_LAYER_COUNT; i++) {
 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;
39 
            if (i % 3 == 0)
 78 
                if (var % 3 == 0)
40 
                Cube_Set_Layer(i,BLUE);
 79 
                    Cube_Set_Pixel(i,j,k,BLUE);
41 
            else if (i % 3 == 1)
 80 
                else if (var % 3 == 1)
42 
                Cube_Set_Layer(i,RED);
 81 
                    Cube_Set_Pixel(i,j,k,RED);
43 
            else
 82 
                else
44 
                Cube_Set_Layer(i,GREEN);
 83 
                    Cube_Set_Pixel(i,j,k,GREEN);
- 
 
 84 
            }
45 
        }
 85 
        }
46 
        Delay_MS(delay_ms);
 86 
        Delay_MS(delay_ms);
47 
    }
 87 
    }
48 
}
 88 
}
49 
 
 89 
 
- 
 
 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 
 
50 
void Animation_Pixel_Alternate(uint8_t iterations, uint16_t delay_ms) {
 126 
void Animation_Row_Column_Sweep(uint16_t delay_ms) {
51 
    uint8_t i,j,k,z;
 127 
    uint8_t i,j,k,a;
52 
    for (z = 0; z < iterations; z++) {
 128 
    for (i = 0; i < 3; i++) {
53 
        for (i = 0; i < CUBE_LAYER_COUNT; i++) {
 129 
        for (j = 0; j < CUBE_ROW_COUNT; j++) {
54 
            Cube_Clear();
 130 
            Cube_Clear();
55 
            for (j = 0; j < CUBE_ROW_COUNT; j++) {
 - 
 
56 
                for (k = 0; k < CUBE_COLUMN_COUNT; k++) {
 131 
            for (k = 0; k < CUBE_COLUMN_COUNT; k++)
57 
                    int32_t var = (j * 8) + k;
 132 
                if (i % 3 == 0)
58 
                    if (var % 3 == 0)
 133 
                    for (a = 0; a < CUBE_LAYER_COUNT; a++)
59 
                        Cube_Set_Pixel(i,j,k,RED);
 134 
                        Cube_Set_Pixel(a,j,k,RED);
60 
                    else if (var % 3 == 1)
 135 
                else if (i % 3 == 1)
- 
 
 136 
                    for (a = 0; a < CUBE_LAYER_COUNT; a++)
61 
                        Cube_Set_Pixel(i,j,k,GREEN);
 137 
                        Cube_Set_Pixel(a,j,k,GREEN);
62 
                    else
 138 
                else
63 
                        Cube_Set_Pixel(i,j,k,BLUE);
 139 
                    for (a = 0; a < CUBE_LAYER_COUNT; a++)
64 
                }
 140 
                        Cube_Set_Pixel(a,j,k,BLUE);
65 
            }
 - 
 
66 
            Delay_MS(delay_ms);
 141 
            Delay_MS(delay_ms);
- 
 
 142 
        }
- 
 
 143 
        for (j = 0; j < CUBE_ROW_COUNT; j++) {
67 
            Cube_Clear();
 144 
            Cube_Clear();
68 
            for (j = 0; j < CUBE_ROW_COUNT; j++) {
 - 
 
69 
                for (k = 0; k < CUBE_COLUMN_COUNT; k++) {
 145 
            for (k = 0; k < CUBE_COLUMN_COUNT; k++)
70 
                    int32_t var = (j * 8) + k;
 146 
                if (i % 3 == 0)
71 
                    if (var % 3 == 0)
 147 
                    for (a = 0; a < CUBE_LAYER_COUNT; a++)
72 
                        Cube_Set_Pixel(i,j,k,GREEN);
 148 
                        Cube_Set_Pixel(a,k,j,RED);
73 
                    else if (var % 3 == 1)
 149 
                else if (i % 3 == 1)
- 
 
 150 
                    for (a = 0; a < CUBE_LAYER_COUNT; a++)
74 
                        Cube_Set_Pixel(i,j,k,BLUE);
 151 
                        Cube_Set_Pixel(a,k,j,GREEN);
75 
                    else
 152 
                else
76 
                        Cube_Set_Pixel(i,j,k,RED);
 153 
                    for (a = 0; a < CUBE_LAYER_COUNT; a++)
77 
                }
 154 
                        Cube_Set_Pixel(a,k,j,BLUE);
78 
            }
 - 
 
79 
            Delay_MS(delay_ms);
 155 
            Delay_MS(delay_ms);
- 
 
 156 
        }
- 
 
 157 
        for (j = CUBE_LAYER_COUNT; j != 0; j--) {
80 
            Cube_Clear();
 158 
            Cube_Clear();
81 
            for (j = 0; j < CUBE_ROW_COUNT; j++) {
 159 
            if (i % 3 == 0) {
82 
                for (k = 0; k < CUBE_COLUMN_COUNT; k++) {
 160 
                for (k = 0; k < CUBE_LAYER_COUNT; k++)
83 
                    int32_t var = (j * 8) + k;
 161 
                    if (k == j)
- 
 
 162 
                        Cube_Set_Layer(k,RED);
84 
                    if (var % 3 == 0)
 163 
            } else if (i % 3 == 1) {
85 
                        Cube_Set_Pixel(i,j,k,BLUE);
 164 
                for (k = 0; k < CUBE_LAYER_COUNT; k++)
86 
                    else if (var % 3 == 1)
 165 
                    if (k == j)
87 
                        Cube_Set_Pixel(i,j,k,RED);
 166 
                        Cube_Set_Layer(k,GREEN);
88 
                    else
 167 
            } else {
89 
                        Cube_Set_Pixel(i,j,k,GREEN);
 168 
                for (k = 0; k < CUBE_LAYER_COUNT; k++)
90 
                }
 169 
                    if (k == j)
- 
 
 170 
                        Cube_Set_Layer(k,BLUE);
91 
            }
 171 
            }
92 
            Delay_MS(delay_ms);
 172 
            Delay_MS(delay_ms);
93 
        }
 173 
        }
94 
    }
 174 
    }
95 
}
 175 
}
96 
 
 176 
 
97 
void Animation_Full_Color_Sweep(uint8_t iterations, uint16_t delay_us) {
 - 
 
98 
    int16_t i,z;
 - 
 
99 
    for (z = 0; z < iterations; z++) {
 - 
 
100 
        for (i = 0; i < 0x0FF; i+=2) {
 - 
 
101 
            Cube_Set_All(i,0,0);
 - 
 
102 
            Delay_US(delay_us);
 - 
 
103 
        }
 - 
 
104 
        for (i = 0; i < 0x0FF; i+=2) {
 - 
 
105 
            Cube_Set_All(0x0FF,i,0);
 - 
 
106 
            Delay_US(delay_us);
 - 
 
107 
        }
 - 
 
108 
        for (i = 0x0FF; i >= 0; i-=2) {
 - 
 
109 
            Cube_Set_All(i,0x0FF,0);
 - 
 
110 
            Delay_US(delay_us);
 - 
 
111 
        }
 - 
 
112 
        for (i = 0; i < 0x0FF; i+=2) {
 - 
 
113 
            Cube_Set_All(0,0x0FF,i);
 - 
 
114 
            Delay_US(delay_us);
 - 
 
115 
        }
 - 
 
116 
        for (i = 0; i < 0x0FF; i+=2) {
 - 
 
117 
            Cube_Set_All(i,0x0FF,0x0FF);
 - 
 
118 
            Delay_US(delay_us);
 - 
 
119 
        }
 - 
 
120 
        for (i = 0x0FF; i >= 0; i-=2) {
 - 
 
121 
            Cube_Set_All(0x0FF,i,0x0FF);
 - 
 
122 
            Delay_US(delay_us);
 - 
 
123 
        }
 - 
 
124 
        for (i = 0x0FF; i >= 0; i-=2) {
 - 
 
125 
            Cube_Set_All(i,0,0x0FF);
 - 
 
126 
            Delay_US(delay_us);
 - 
 
127 
        }
 - 
 
128 
        for (i = 0x0FF; i >= 0; i-=2) {
 - 
 
129 
            Cube_Set_All(0,0,i);
 - 
 
130 
            Delay_US(delay_us);
 - 
 
131 
        }
 - 
 
132 
    }
 - 
 
133 
}
 - 
 
134 
 
 - 
 
135 
void Animation_Row_Column_Sweep(uint8_t iterations, uint16_t delay_ms) {
 177 
void Animation_Pixel_Sweep(uint16_t delay_ms) {
136 
    uint8_t i,j,k,a,z;
 178 
    uint8_t i,j,k,a;
137 
    for (z = 0; z < iterations; z++) {
 - 
 
138 
        for (i = 0; i < 3; i++) {
 179 
    for (a = 0; a < 3; a++) {
139 
            for (j = 0; j < CUBE_ROW_COUNT; j++) {
 180 
        for (i = 0; i < CUBE_LAYER_COUNT; i++) {
140 
                Cube_Clear();
 - 
 
141 
                for (k = 0; k < CUBE_COLUMN_COUNT; k++)
 - 
 
142 
                    if (i % 3 == 0)
 - 
 
143 
                        for (a = 0; a < CUBE_LAYER_COUNT; a++)
 - 
 
144 
                            Cube_Set_Pixel(a,j,k,RED);
 - 
 
145 
                    else if (i % 3 == 1)
 - 
 
146 
                        for (a = 0; a < CUBE_LAYER_COUNT; a++)
 - 
 
147 
                            Cube_Set_Pixel(a,j,k,GREEN);
 - 
 
148 
                    else
 - 
 
149 
                        for (a = 0; a < CUBE_LAYER_COUNT; a++)
 - 
 
150 
                            Cube_Set_Pixel(a,j,k,BLUE);
 - 
 
151 
                Delay_MS(delay_ms);
 - 
 
152 
            }
 - 
 
153 
            for (j = 0; j < CUBE_ROW_COUNT; j++) {
 181 
            for (j = 0; j < CUBE_ROW_COUNT; j++) {
154 
                Cube_Clear();
 - 
 
155 
                for (k = 0; k < CUBE_COLUMN_COUNT; k++)
 182 
                for (k = 0; k < CUBE_COLUMN_COUNT; k++) {
156 
                    if (i % 3 == 0)
 183 
                    Cube_Clear();
157 
                        for (a = 0; a < CUBE_LAYER_COUNT; a++)
 184 
                    if (a % 3 == 0) {
158 
                            Cube_Set_Pixel(a,k,j,RED);
 185 
                        Cube_Set_Pixel(i,j,k,RED);
159 
                    else if (i % 3 == 1)
 186 
                    } else if (a % 3 == 1) {
160 
                        for (a = 0; a < CUBE_LAYER_COUNT; a++)
 - 
 
161 
                            Cube_Set_Pixel(a,k,j,GREEN);
 187 
                        Cube_Set_Pixel(i,j,k,GREEN);
162 
                    else
 188 
                    } else {
163 
                        for (a = 0; a < CUBE_LAYER_COUNT; a++)
 - 
 
164 
                            Cube_Set_Pixel(a,k,j,BLUE);
 189 
                        Cube_Set_Pixel(i,j,k,BLUE);
165 
                Delay_MS(delay_ms);
 - 
 
166 
            }
 - 
 
167 
            for (j = CUBE_LAYER_COUNT; j != 0; j--) {
 - 
 
168 
                Cube_Clear();
 - 
 
169 
                if (i % 3 == 0) {
 - 
 
170 
                    for (k = 0; k < CUBE_LAYER_COUNT; k++)
 - 
 
171 
                        if (k == j)
 - 
 
172 
                            Cube_Set_Layer(k,RED);
 - 
 
173 
                } else if (i % 3 == 1) {
 - 
 
174 
                    for (k = 0; k < CUBE_LAYER_COUNT; k++)
 - 
 
175 
                        if (k == j)
 - 
 
176 
                            Cube_Set_Layer(k,GREEN);
 - 
 
177 
                } else {
 190 
                    }
178 
                    for (k = 0; k < CUBE_LAYER_COUNT; k++)
 - 
 
179 
                        if (k == j)
 191 
                    Delay_MS(delay_ms);
180 
                            Cube_Set_Layer(k,BLUE);
 - 
 
181 
                }
 192 
                }
182 
                Delay_MS(delay_ms);
 - 
 
183 
            }
 193 
            }
184 
        }
 194 
        }
185 
    }
 195 
    }
186 
}
 196 
}
187 
 
 197 
 
188 
void Animation_Pixel_Sweep(uint8_t iterations, uint16_t delay_ms) {
 198 
void Animation_Pseudo_Random_Colors(uint16_t delay_ms) {
189 
    uint8_t i,j,k,z,a;
 199 
    uint8_t i,j,k;
190 
    for (z = 0; z < iterations; z++) {
 200 
    for (i = 0; i < CUBE_LAYER_COUNT; i++) {
191 
        for (a = 0; a < 3; a++) {
 201 
        for (j = 0; j < CUBE_ROW_COUNT; j++) {
192 
            for (i = 0; i < CUBE_LAYER_COUNT; i++) {
 202 
            for (k = 0; k < CUBE_COLUMN_COUNT; k++) {
193 
                for (j = 0; j < CUBE_ROW_COUNT; j++) {
 203 
                uint32_t a = rand();
194 
                    for (k = 0; k < CUBE_COLUMN_COUNT; k++) {
 204 
                if (a % 5 == 0)
195 
                        Cube_Clear();
 205 
                    Cube_Set_Pixel(i,j,k,RED);
196 
                        if (a % 3 == 0) {
 206 
                else if (a % 5 == 1)
197 
                            Cube_Set_Pixel(i,j,k,RED);
 207 
                    Cube_Set_Pixel(i,j,k,GREEN);
198 
                        } else if (a % 3 == 1) {
 208 
                else if (a % 5 == 2)
199 
                            Cube_Set_Pixel(i,j,k,GREEN);
 209 
                    Cube_Set_Pixel(i,j,k,BLUE);
200 
                        } else {
 210 
                else if (a % 5 == 3)
201 
                            Cube_Set_Pixel(i,j,k,BLUE);
 211 
                    Cube_Set_Pixel(i,j,k,PURPLE);
202 
                        }
 212 
                else if (a % 5 == 4)
203 
                        Delay_MS(delay_ms);
 213 
                    Cube_Set_Pixel(i,j,k,YELLOW);
204 
                    }
 214 
                else
205 
                }
 215 
                    Cube_Set_Pixel(i,j,k,ORANGE);
206 
            }
 216 
            }
207 
        }
 217 
        }
208 
    }
 218 
    }
- 
 
 219 
    Delay_MS(delay_ms);
209 
}
 220 
}
210 
 
 221 
 
211 
void Animation_Pseudo_Random_Colors(uint8_t iterations, uint16_t delay_ms) {
 222 
void Animation_Random_Colors(uint16_t delay_ms) {
212 
    uint8_t i,j,k,z;
 223 
    uint8_t i,j,k;
213 
    for (z = 0; z < iterations; z++) {
 - 
 
214 
        for (i = 0; i < CUBE_LAYER_COUNT; i++) {
 224 
    for (i = 0; i < CUBE_LAYER_COUNT; i++) {
215 
            for (j = 0; j < CUBE_ROW_COUNT; j++) {
 225 
        for (j = 0; j < CUBE_ROW_COUNT; j++) {
216 
                for (k = 0; k < CUBE_COLUMN_COUNT; k++) {
 226 
            for (k = 0; k < CUBE_COLUMN_COUNT; k++) {
217 
                    uint32_t a = rand();
 - 
 
218 
                    if (a % 5 == 0)
 - 
 
219 
                        Cube_Set_Pixel(i,j,k,RED);
 - 
 
220 
                    else if (a % 5 == 1)
 - 
 
221 
                        Cube_Set_Pixel(i,j,k,GREEN);
 - 
 
222 
                    else if (a % 5 == 2)
 - 
 
223 
                        Cube_Set_Pixel(i,j,k,BLUE);
 - 
 
224 
                    else if (a % 5 == 3)
 - 
 
225 
                        Cube_Set_Pixel(i,j,k,PURPLE);
 - 
 
226 
                    else if (a % 5 == 4)
 - 
 
227 
                        Cube_Set_Pixel(i,j,k,YELLOW);
 - 
 
228 
                    else
 - 
 
229 
                        Cube_Set_Pixel(i,j,k,ORANGE);
 227 
                Cube_Set_Pixel(i,j,k,rand()&0x0FF,rand()&0x0FF,rand()&0x0FF);
230 
                }
 - 
 
231 
            }
 228 
            }
232 
        }
 229 
        }
233 
        Delay_MS(delay_ms);
 - 
 
234 
    }
 230 
    }
- 
 
 231 
    Delay_MS(delay_ms);
235 
}
 232 
}
236 
 
 233 
 
237 
void Animation_Random_Colors(uint8_t iterations, uint16_t delay_ms) {
 234 
void Animation_Cube_In_Cube(uint16_t delay_ms) {
238 
    uint8_t i,j,k,z;
 235 
    uint8_t x,i,j,k;
239 
    for (z = 0; z < iterations; z++) {
 236 
    for (x = 0; x < 5; x++) {
- 
 
 237 
        Cube_Clear();
240 
        for (i = 0; i < CUBE_LAYER_COUNT; i++) {
 238 
        for (i = 0; i < CUBE_LAYER_COUNT; i++) {
- 
 
 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)) {
241 
            for (j = 0; j < CUBE_ROW_COUNT; j++) {
 242 
                for (j = 1; j < CUBE_ROW_COUNT-1; j++)
242 
                for (k = 0; k < CUBE_COLUMN_COUNT; k++) {
 243 
                    for (k = 1; k < CUBE_COLUMN_COUNT-1; k++)
243 
                    Cube_Set_Pixel(i,j,k,rand()&0x0FF,rand()&0x0FF,rand()&0x0FF);
 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++)
- 
 
 248 
                        Cube_Set_Pixel(i,j,k,GREEN);
- 
 
 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++)
244 
                }
 252 
                        Cube_Set_Pixel(i,j,k,BLUE);
245 
            }
 253 
            }
246 
        }
 - 
 
247 
        Delay_MS(delay_ms);
 - 
 
248 
    }
 - 
 
249 
}
 - 
 
250 
 
 254 
 
251 
void Animation_Cube_In_Cube(uint8_t iterations, uint16_t delay_ms) {
 - 
 
252 
    uint8_t z,x,i,j,k;
 - 
 
253 
    for (z = 0; z < iterations; z++) {
 - 
 
254 
        for (x = 0; x < 5; x++) {
 - 
 
255 
            Cube_Clear();
 - 
 
256 
            for (i = 0; i < CUBE_LAYER_COUNT; i++) {
 - 
 
257 
                if ((x == 0 || x == 4)&&(i == 0 || i == 7)) {
 - 
 
258 
                    Cube_Set_Layer(i,RED);
 - 
 
259 
                } else if ((x == 1 || x == 4)&&(i == 1 || i == 6)) {
 - 
 
260 
                    for (j = 1; j < CUBE_ROW_COUNT-1; j++)
 - 
 
261 
                        for (k = 1; k < CUBE_COLUMN_COUNT-1; k++)
 - 
 
262 
                            Cube_Set_Pixel(i,j,k,YELLOW);
 - 
 
263 
                } else if ((x == 2 || x == 4)&&(i == 2 || i == 5)) {
 - 
 
264 
                    for (j = 2; j < CUBE_ROW_COUNT-2; j++)
 - 
 
265 
                        for (k = 2; k < CUBE_COLUMN_COUNT-2; k++)
 - 
 
266 
                            Cube_Set_Pixel(i,j,k,GREEN);
 - 
 
267 
                } else if ((x == 3 || x == 4)&&(i == 3 || i == 4)) {
 - 
 
268 
                    for (j = 3; j < CUBE_ROW_COUNT-3; j++)
 - 
 
269 
                        for (k = 3; k < CUBE_COLUMN_COUNT-3; k++)
 - 
 
270 
                            Cube_Set_Pixel(i,j,k,BLUE);
 - 
 
271 
                }
 - 
 
272 
 
 - 
 
273 
                if ((x == 0 || x == 4)&&(i > 0 && i < 8)) {
 255 
            if ((x == 0 || x == 4)&&(i > 0 && i < 8)) {
274 
                    for (j = 0; j < 8; j++) {
 256 
                for (j = 0; j < 8; j++) {
275 
                        Cube_Set_Pixel(i,j,0,RED);
 257 
                    Cube_Set_Pixel(i,j,0,RED);
276 
                        Cube_Set_Pixel(i,j,7,RED);
 258 
                    Cube_Set_Pixel(i,j,7,RED);
277 
                        Cube_Set_Pixel(i,0,j,RED);
 259 
                    Cube_Set_Pixel(i,0,j,RED);
278 
                        Cube_Set_Pixel(i,7,j,RED);
 260 
                    Cube_Set_Pixel(i,7,j,RED);
279 
                    }
 261 
                }
280 
                }
 262 
            }
281 
                if ((x == 1 || x == 4)&&(i > 1 && i < 7)) {
 263 
            if ((x == 1 || x == 4)&&(i > 1 && i < 7)) {
282 
                    for (j = 1; j < 7; j++) {
 264 
                for (j = 1; j < 7; j++) {
283 
                        Cube_Set_Pixel(i,j,1,YELLOW);
 265 
                    Cube_Set_Pixel(i,j,1,YELLOW);
284 
                        Cube_Set_Pixel(i,j,6,YELLOW);
 266 
                    Cube_Set_Pixel(i,j,6,YELLOW);
285 
                        Cube_Set_Pixel(i,1,j,YELLOW);
 267 
                    Cube_Set_Pixel(i,1,j,YELLOW);
286 
                        Cube_Set_Pixel(i,6,j,YELLOW);
 268 
                    Cube_Set_Pixel(i,6,j,YELLOW);
287 
                    }
 269 
                }
288 
                }
 270 
            }
289 
                if ((x == 2 || x == 4)&&(i > 2 && i < 6)) {
 271 
            if ((x == 2 || x == 4)&&(i > 2 && i < 6)) {
290 
                    for (j = 2; j < 6; j++) {
 272 
                for (j = 2; j < 6; j++) {
291 
                        Cube_Set_Pixel(i,j,2,GREEN);
 273 
                    Cube_Set_Pixel(i,j,2,GREEN);
292 
                        Cube_Set_Pixel(i,j,5,GREEN);
 274 
                    Cube_Set_Pixel(i,j,5,GREEN);
293 
                        Cube_Set_Pixel(i,2,j,GREEN);
 275 
                    Cube_Set_Pixel(i,2,j,GREEN);
294 
                        Cube_Set_Pixel(i,5,j,GREEN);
 276 
                    Cube_Set_Pixel(i,5,j,GREEN);
295 
                    }
 - 
 
296 
                }
 277 
                }
297 
            }
 278 
            }
298 
            Delay_MS(delay_ms);
 - 
 
299 
        }
 279 
        }
- 
 
 280 
        Delay_MS(delay_ms);
300 
    }
 281 
    }
301 
}
 282 
}
302 
 
 283 
 
303 
void Animation_Double_Rotation(uint8_t iterations, uint16_t delay_ms) {
 284 
void Animation_Double_Rotation(uint16_t delay_ms) {
304 
    Cube_Clear();
 285 
    Cube_Clear();
305 
    uint8_t i,x,y,z;
 286 
    uint8_t x,y,z;
306 
    for (z = 0; z < 3; z++) {
 287 
    for (z = 0; z < 3; z++) {
307 
        switch (z % 3) {
 288 
        switch (z % 3) {
308 
            case 0:
 289 
            case 0:
309 
                for (y = 0; y < CUBE_LAYER_COUNT; y++) {
 290 
                for (y = 0; y < CUBE_LAYER_COUNT; y++) {
310 
                    Cube_Set_Pixel(y,0,0,RED);
 291 
                    Cube_Set_Pixel(y,0,0,RED);
Line 341... Line 322...
341 
                    Cube_Set_Pixel(y,7,7,BLUE);
 322 
                    Cube_Set_Pixel(y,7,7,BLUE);
342 
                }
 323 
                }
343 
                break;
 324 
                break;
344 
        }
 325 
        }
345 
 
 326 
 
346 
        for (i = 0; i < iterations; i++) {
 - 
 
347 
            for (x = 0; x < 28; x++) {
 327 
        for (x = 0; x < 28; x++) {
348 
                Delay_MS(delay_ms);
 328 
            Delay_MS(delay_ms);
349 
                Cube_Rotate(0);
 329 
            Cube_Rotate(0);
350 
            }
 - 
 
351 
        }
 330 
        }
352 
    }
 331 
    }
353 
}
 332 
}