WebSVN – Code-Repo – Diff – /PIC Stuff/Cerebot_32MX7_LED_Cube/ANIMATIONS.c



#include "defines.h"
#include "ANIMATIONS.h"
#include "CUBE.h"
 
void Animation_Solid_Colors(uint8_t iterations, uint16_t delay_ms) {
    uint8_t i;
    for (i = 0; i < iterations; i++) {
        Cube_Set_All(RED);
        Delay_MS(delay_ms);
        Cube_Set_All(GREEN);
        Delay_MS(delay_ms);
        Cube_Set_All(BLUE);
        Delay_MS(delay_ms);
    }
}
 
void Animation_Layer_Alternate(uint8_t iterations, uint16_t delay_ms) {
    uint8_t i,z;
    for (z = 0; z < iterations; z++) {
        for (i = 0; i < CUBE_LAYER_COUNT; i++) {
            if (i % 3 == 0)
                Cube_Set_Layer(i,RED);
            else if (i % 3 == 1)

        }
        Delay_MS(delay_ms);
    }
}
 
void Animation_Pixel_Alternate(uint8_t iterations, uint16_t delay_ms) {
    uint8_t i,j,k,z;
    for (z = 0; z < iterations; z++) {
        for (i = 0; i < CUBE_LAYER_COUNT; i++) {
            Cube_Clear();
            for (j = 0; j < CUBE_ROW_COUNT; j++) {
                for (k = 0; k < CUBE_COLUMN_COUNT; k++) {
                    int32_t var = (j * 8) + k;
                    if (var % 3 == 0)
                        Cube_Set_Pixel(i,j,k,RED);
                    else if (var % 3 == 1)
                        Cube_Set_Pixel(i,j,k,GREEN);
                    else

            }
            Delay_MS(delay_ms);
            Cube_Clear();
            for (j = 0; j < CUBE_ROW_COUNT; j++) {
                for (k = 0; k < CUBE_COLUMN_COUNT; k++) {
                    int32_t var = (j * 8) + k;
                    if (var % 3 == 0)
                        Cube_Set_Pixel(i,j,k,GREEN);
                    else if (var % 3 == 1)
                        Cube_Set_Pixel(i,j,k,BLUE);
                    else

            }
            Delay_MS(delay_ms);
            Cube_Clear();
            for (j = 0; j < CUBE_ROW_COUNT; j++) {
                for (k = 0; k < CUBE_COLUMN_COUNT; k++) {
                    int32_t var = (j * 8) + k;
                    if (var % 3 == 0)
                        Cube_Set_Pixel(i,j,k,BLUE);
                    else if (var % 3 == 1)
                        Cube_Set_Pixel(i,j,k,RED);
                    else

            Delay_MS(delay_ms);
        }
    }
}
 
void Animation_Full_Color_Sweep(uint8_t iterations, uint16_t delay_us) {
    int16_t i,z;
    for (z = 0; z < iterations; z++) {
        for (i = 0; i < 0x0FF; i+=2) {
            Cube_Set_All(i,0,0);
            Delay_US(delay_us);
        }

        }
        for (i = 0x0FF; i >= 0; i-=2) {
            Cube_Set_All(i,0,0x0FF);
            Delay_US(delay_us);
        }
        for (i = 0x0FF; i >= 0; i-=2) {
            Cube_Set_All(0,0,i);
            Delay_US(delay_us);
        }
    }
}
 
void Animation_Row_Column_Sweep(uint8_t iterations, uint16_t delay_ms) {
    uint8_t i,j,k,a,z;
    for (z = 0; z < iterations; z++) {
        for (i = 0; i < 3; i++) {
            for (j = 0; j < CUBE_ROW_COUNT; j++) {
                Cube_Clear();
                for (k = 0; k < CUBE_COLUMN_COUNT; k++)

                    else
                        for (a = 0; a < CUBE_LAYER_COUNT; a++)
                            Cube_Set_Pixel(a,k,j,BLUE);
                Delay_MS(delay_ms);
            }
            for (j = CUBE_LAYER_COUNT; j != 0; j--) {
                Cube_Clear();
                if (i % 3 == 0) {
                    for (k = 0; k < CUBE_LAYER_COUNT; k++)
                        if (k == j)
                            Cube_Set_Layer(k,RED);

            }
        }
    }
}
 
void Animation_Pixel_Sweep(uint8_t iterations, uint16_t delay_ms) {
    uint8_t i,j,k,z,a;
    for (z = 0; z < iterations; z++) {
        for (a = 0; a < 3; a++) {
            for (i = 0; i < CUBE_LAYER_COUNT; i++) {
                for (j = 0; j < CUBE_ROW_COUNT; j++) {
                    for (k = 0; k < CUBE_COLUMN_COUNT; k++) {

            }
        }
    }
}
 
void Animation_Pseudo_Random_Colors(uint8_t iterations, uint16_t delay_ms) {
    uint8_t i,j,k,z;
    for (z = 0; z < iterations; z++) {
        for (i = 0; i < CUBE_LAYER_COUNT; i++) {
            for (j = 0; j < CUBE_ROW_COUNT; j++) {
                for (k = 0; k < CUBE_COLUMN_COUNT; k++) {
                    uint32_t a = rand();
                    if (a % 5 == 0)
                        Cube_Set_Pixel(i,j,k,RED);
                    else if (a % 5 == 1)
                        Cube_Set_Pixel(i,j,k,GREEN);
                    else if (a % 5 == 2)

        }
        Delay_MS(delay_ms);
    }
}
 
void Animation_Random_Colors(uint8_t iterations, uint16_t delay_ms) {
    uint8_t i,j,k,z;
    for (z = 0; z < iterations; z++) {
        for (i = 0; i < CUBE_LAYER_COUNT; i++) {
            for (j = 0; j < CUBE_ROW_COUNT; j++) {
                for (k = 0; k < CUBE_COLUMN_COUNT; k++) {
                    Cube_Set_Pixel(i,j,k,rand()&0x0FF,rand()&0x0FF,rand()&0x0FF);

        }
        Delay_MS(delay_ms);
    }
}
 
void Animation_Cube_In_Cube(uint8_t iterations, uint16_t delay_ms) {
    uint8_t z,x,i,j,k;
    for (z = 0; z < iterations; z++) {
        for (x = 0; x < 5; x++) {
            Cube_Clear();
            for (i = 0; i < CUBE_LAYER_COUNT; i++) {
                if ((x == 0 || x == 4)&&(i == 0 || i == 7)) {

            Delay_MS(delay_ms);
        }
    }
}
 
void Animation_Double_Rotation(uint8_t iterations, uint16_t delay_ms) {
    Cube_Clear();
    uint8_t i,x,y,z;
    for (z = 0; z < 3; z++) {
        switch (z % 3) {
            case 0:
                for (y = 0; y < CUBE_LAYER_COUNT; y++) {
                    Cube_Set_Pixel(y,0,0,RED);

Rev 226	Rev 231
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(int iterations, int delay_ms) {`	5	`void Animation_Solid_Colors(uint8_t iterations, uint16_t delay_ms) {`
6	`int i;`	6	`uint8_t i;`
7	`for (i = 0; i < iterations; i++) {`	7	`for (i = 0; i < iterations; i++) {`
8	`Cube_Set_All(RED);`	8	`Cube_Set_All(RED);`
9	`Delay_MS(delay_ms);`	9	`Delay_MS(delay_ms);`
10	`Cube_Set_All(GREEN);`	10	`Cube_Set_All(GREEN);`
11	`Delay_MS(delay_ms);`	11	`Delay_MS(delay_ms);`
12	`Cube_Set_All(BLUE);`	12	`Cube_Set_All(BLUE);`
13	`Delay_MS(delay_ms);`	13	`Delay_MS(delay_ms);`
14	`}`	14	`}`
15	`}`	15	`}`
16		16
17	`void Animation_Layer_Alternate(int iterations, int delay_ms) {`	17	`void Animation_Layer_Alternate(uint8_t iterations, uint16_t delay_ms) {`
18	`int i,z;`	18	`uint8_t i,z;`
19	`for (z = 0; z < iterations; z++) {`	19	`for (z = 0; z < iterations; z++) {`
20	`for (i = 0; i < CUBE_LAYER_COUNT; i++) {`	20	`for (i = 0; i < CUBE_LAYER_COUNT; i++) {`
21	`if (i % 3 == 0)`	21	`if (i % 3 == 0)`
22	`Cube_Set_Layer(i,RED);`	22	`Cube_Set_Layer(i,RED);`
23	`else if (i % 3 == 1)`	23	`else if (i % 3 == 1)`
Line 45...	Line 45...
45	`}`	45	`}`
46	`Delay_MS(delay_ms);`	46	`Delay_MS(delay_ms);`
47	`}`	47	`}`
48	`}`	48	`}`
49		49
50	`void Animation_Pixel_Alternate(int iterations, int delay_ms) {`	50	`void Animation_Pixel_Alternate(uint8_t iterations, uint16_t delay_ms) {`
51	`int i,j,k,z;`	51	`uint8_t i,j,k,z;`
52	`for (z = 0; z < iterations; z++) {`	52	`for (z = 0; z < iterations; z++) {`
53	`for (i = 0; i < CUBE_LAYER_COUNT; i++) {`	53	`for (i = 0; i < CUBE_LAYER_COUNT; i++) {`
54	`Cube_Clear();`	54	`Cube_Clear();`
55	`for (j = 0; j < CUBE_ROW_COUNT; j++) {`	55	`for (j = 0; j < CUBE_ROW_COUNT; j++) {`
56	`for (k = 0; k < CUBE_COLUMN_COUNT; k++) {`	56	`for (k = 0; k < CUBE_COLUMN_COUNT; k++) {`
57	`int var = (j * 8) + k;`	57	`int32_t var = (j * 8) + k;`
58	`if (var % 3 == 0)`	58	`if (var % 3 == 0)`
59	`Cube_Set_Pixel(i,j,k,RED);`	59	`Cube_Set_Pixel(i,j,k,RED);`
60	`else if (var % 3 == 1)`	60	`else if (var % 3 == 1)`
61	`Cube_Set_Pixel(i,j,k,GREEN);`	61	`Cube_Set_Pixel(i,j,k,GREEN);`
62	`else`	62	`else`
Line 65...	Line 65...
65	`}`	65	`}`
66	`Delay_MS(delay_ms);`	66	`Delay_MS(delay_ms);`
67	`Cube_Clear();`	67	`Cube_Clear();`
68	`for (j = 0; j < CUBE_ROW_COUNT; j++) {`	68	`for (j = 0; j < CUBE_ROW_COUNT; j++) {`
69	`for (k = 0; k < CUBE_COLUMN_COUNT; k++) {`	69	`for (k = 0; k < CUBE_COLUMN_COUNT; k++) {`
70	`int var = (j * 8) + k;`	70	`int32_t var = (j * 8) + k;`
71	`if (var % 3 == 0)`	71	`if (var % 3 == 0)`
72	`Cube_Set_Pixel(i,j,k,GREEN);`	72	`Cube_Set_Pixel(i,j,k,GREEN);`
73	`else if (var % 3 == 1)`	73	`else if (var % 3 == 1)`
74	`Cube_Set_Pixel(i,j,k,BLUE);`	74	`Cube_Set_Pixel(i,j,k,BLUE);`
75	`else`	75	`else`
Line 78...	Line 78...
78	`}`	78	`}`
79	`Delay_MS(delay_ms);`	79	`Delay_MS(delay_ms);`
80	`Cube_Clear();`	80	`Cube_Clear();`
81	`for (j = 0; j < CUBE_ROW_COUNT; j++) {`	81	`for (j = 0; j < CUBE_ROW_COUNT; j++) {`
82	`for (k = 0; k < CUBE_COLUMN_COUNT; k++) {`	82	`for (k = 0; k < CUBE_COLUMN_COUNT; k++) {`
83	`int var = (j * 8) + k;`	83	`int32_t var = (j * 8) + k;`
84	`if (var % 3 == 0)`	84	`if (var % 3 == 0)`
85	`Cube_Set_Pixel(i,j,k,BLUE);`	85	`Cube_Set_Pixel(i,j,k,BLUE);`
86	`else if (var % 3 == 1)`	86	`else if (var % 3 == 1)`
87	`Cube_Set_Pixel(i,j,k,RED);`	87	`Cube_Set_Pixel(i,j,k,RED);`
88	`else`	88	`else`
Line 92...	Line 92...
92	`Delay_MS(delay_ms);`	92	`Delay_MS(delay_ms);`
93	`}`	93	`}`
94	`}`	94	`}`
95	`}`	95	`}`
96		96
97	`void Animation_Full_Color_Sweep(int iterations, int delay_us) {`	97	`void Animation_Full_Color_Sweep(uint8_t iterations, uint16_t delay_us) {`
98	`int i,z;`	98	`int16_t i,z;`
99	`for (z = 0; z < iterations; z++) {`	99	`for (z = 0; z < iterations; z++) {`
100	`for (i = 0; i < 0x0FF; i+=2) {`	100	`for (i = 0; i < 0x0FF; i+=2) {`
101	`Cube_Set_All(i,0,0);`	101	`Cube_Set_All(i,0,0);`
102	`Delay_US(delay_us);`	102	`Delay_US(delay_us);`
103	`}`	103	`}`
Line 123...	Line 123...
123	`}`	123	`}`
124	`for (i = 0x0FF; i >= 0; i-=2) {`	124	`for (i = 0x0FF; i >= 0; i-=2) {`
125	`Cube_Set_All(i,0,0x0FF);`	125	`Cube_Set_All(i,0,0x0FF);`
126	`Delay_US(delay_us);`	126	`Delay_US(delay_us);`
127	`}`	127	`}`
128	`for (i = 0x100; i >= 0; i-=2) {`	128	`for (i = 0x0FF; i >= 0; i-=2) {`
129	`Cube_Set_All(0,0,i);`	129	`Cube_Set_All(0,0,i);`
130	`Delay_US(delay_us);`	130	`Delay_US(delay_us);`
131	`}`	131	`}`
132	`}`	132	`}`
133	`}`	133	`}`
134		134
135	`void Animation_Row_Column_Sweep(int iterations, int delay_ms) {`	135	`void Animation_Row_Column_Sweep(uint8_t iterations, uint16_t delay_ms) {`
136	`int i,j,k,a,z;`	136	`uint8_t i,j,k,a,z;`
137	`for (z = 0; z < iterations; z++) {`	137	`for (z = 0; z < iterations; z++) {`
138	`for (i = 0; i < 3; i++) {`	138	`for (i = 0; i < 3; i++) {`
139	`for (j = 0; j < CUBE_ROW_COUNT; j++) {`	139	`for (j = 0; j < CUBE_ROW_COUNT; j++) {`
140	`Cube_Clear();`	140	`Cube_Clear();`
141	`for (k = 0; k < CUBE_COLUMN_COUNT; k++)`	141	`for (k = 0; k < CUBE_COLUMN_COUNT; k++)`
Line 162...	Line 162...
162	`else`	162	`else`
163	`for (a = 0; a < CUBE_LAYER_COUNT; a++)`	163	`for (a = 0; a < CUBE_LAYER_COUNT; a++)`
164	`Cube_Set_Pixel(a,k,j,BLUE);`	164	`Cube_Set_Pixel(a,k,j,BLUE);`
165	`Delay_MS(delay_ms);`	165	`Delay_MS(delay_ms);`
166	`}`	166	`}`
167	`for (j = CUBE_LAYER_COUNT-1; j >= 0; j--) {`	167	`for (j = CUBE_LAYER_COUNT; j != 0; j--) {`
168	`Cube_Clear();`	168	`Cube_Clear();`
169	`if (i % 3 == 0) {`	169	`if (i % 3 == 0) {`
170	`for (k = 0; k < CUBE_LAYER_COUNT; k++)`	170	`for (k = 0; k < CUBE_LAYER_COUNT; k++)`
171	`if (k == j)`	171	`if (k == j)`
172	`Cube_Set_Layer(k,RED);`	172	`Cube_Set_Layer(k,RED);`
Line 183...	Line 183...
183	`}`	183	`}`
184	`}`	184	`}`
185	`}`	185	`}`
186	`}`	186	`}`
187		187
188	`void Animation_Pixel_Sweep(int iterations, int delay_ms) {`	188	`void Animation_Pixel_Sweep(uint8_t iterations, uint16_t delay_ms) {`
189	`int i,j,k,z,a;`	189	`uint8_t i,j,k,z,a;`
190	`for (z = 0; z < iterations; z++) {`	190	`for (z = 0; z < iterations; z++) {`
191	`for (a = 0; a < 3; a++) {`	191	`for (a = 0; a < 3; a++) {`
192	`for (i = 0; i < CUBE_LAYER_COUNT; i++) {`	192	`for (i = 0; i < CUBE_LAYER_COUNT; i++) {`
193	`for (j = 0; j < CUBE_ROW_COUNT; j++) {`	193	`for (j = 0; j < CUBE_ROW_COUNT; j++) {`
194	`for (k = 0; k < CUBE_COLUMN_COUNT; k++) {`	194	`for (k = 0; k < CUBE_COLUMN_COUNT; k++) {`
Line 206...	Line 206...
206	`}`	206	`}`
207	`}`	207	`}`
208	`}`	208	`}`
209	`}`	209	`}`
210		210
211	`void Animation_Pseudo_Random_Colors(int iterations, int delay_ms) {`	211	`void Animation_Pseudo_Random_Colors(uint8_t iterations, uint16_t delay_ms) {`
212	`int i,j,k,z;`	212	`uint8_t i,j,k,z;`
213	`for (z = 0; z < iterations; z++) {`	213	`for (z = 0; z < iterations; z++) {`
214	`for (i = 0; i < CUBE_LAYER_COUNT; i++) {`	214	`for (i = 0; i < CUBE_LAYER_COUNT; i++) {`
215	`for (j = 0; j < CUBE_ROW_COUNT; j++) {`	215	`for (j = 0; j < CUBE_ROW_COUNT; j++) {`
216	`for (k = 0; k < CUBE_COLUMN_COUNT; k++) {`	216	`for (k = 0; k < CUBE_COLUMN_COUNT; k++) {`
217	`unsigned int a = rand();`	217	`uint32_t a = rand();`
218	`if (a % 5 == 0)`	218	`if (a % 5 == 0)`
219	`Cube_Set_Pixel(i,j,k,RED);`	219	`Cube_Set_Pixel(i,j,k,RED);`
220	`else if (a % 5 == 1)`	220	`else if (a % 5 == 1)`
221	`Cube_Set_Pixel(i,j,k,GREEN);`	221	`Cube_Set_Pixel(i,j,k,GREEN);`
222	`else if (a % 5 == 2)`	222	`else if (a % 5 == 2)`
Line 232...	Line 232...
232	`}`	232	`}`
233	`Delay_MS(delay_ms);`	233	`Delay_MS(delay_ms);`
234	`}`	234	`}`
235	`}`	235	`}`
236		236
237	`void Animation_Random_Colors(int iterations, int delay_ms) {`	237	`void Animation_Random_Colors(uint8_t iterations, uint16_t delay_ms) {`
238	`int i,j,k,z;`	238	`uint8_t i,j,k,z;`
239	`for (z = 0; z < iterations; z++) {`	239	`for (z = 0; z < iterations; z++) {`
240	`for (i = 0; i < CUBE_LAYER_COUNT; i++) {`	240	`for (i = 0; i < CUBE_LAYER_COUNT; i++) {`
241	`for (j = 0; j < CUBE_ROW_COUNT; j++) {`	241	`for (j = 0; j < CUBE_ROW_COUNT; j++) {`
242	`for (k = 0; k < CUBE_COLUMN_COUNT; k++) {`	242	`for (k = 0; k < CUBE_COLUMN_COUNT; k++) {`
243	`Cube_Set_Pixel(i,j,k,rand()&0x0FF,rand()&0x0FF,rand()&0x0FF);`	243	`Cube_Set_Pixel(i,j,k,rand()&0x0FF,rand()&0x0FF,rand()&0x0FF);`
Line 246...	Line 246...
246	`}`	246	`}`
247	`Delay_MS(delay_ms);`	247	`Delay_MS(delay_ms);`
248	`}`	248	`}`
249	`}`	249	`}`
250		250
251	`void Animation_Cube_In_Cube(int iterations, int delay_ms) {`	251	`void Animation_Cube_In_Cube(uint8_t iterations, uint16_t delay_ms) {`
252	`int z,x,i,j,k;`	252	`uint8_t z,x,i,j,k;`
253	`for (z = 0; z < iterations; z++) {`	253	`for (z = 0; z < iterations; z++) {`
254	`for (x = 0; x < 5; x++) {`	254	`for (x = 0; x < 5; x++) {`
255	`Cube_Clear();`	255	`Cube_Clear();`
256	`for (i = 0; i < CUBE_LAYER_COUNT; i++) {`	256	`for (i = 0; i < CUBE_LAYER_COUNT; i++) {`
257	`if ((x == 0 \|\| x == 4)&&(i == 0 \|\| i == 7)) {`	257	`if ((x == 0 \|\| x == 4)&&(i == 0 \|\| i == 7)) {`
Line 298...	Line 298...
298	`Delay_MS(delay_ms);`	298	`Delay_MS(delay_ms);`
299	`}`	299	`}`
300	`}`	300	`}`
301	`}`	301	`}`
302		302
303	`void Animation_Double_Rotation(int iterations, int delay_ms) {`	303	`void Animation_Double_Rotation(uint8_t iterations, uint16_t delay_ms) {`
304	`Cube_Clear();`	304	`Cube_Clear();`
305	`int i,x,y,z;`	305	`uint8_t i,x,y,z;`
306	`for (z = 0; z < 3; z++) {`	306	`for (z = 0; z < 3; z++) {`
307	`switch (z % 3) {`	307	`switch (z % 3) {`
308	`case 0:`	308	`case 0:`
309	`for (y = 0; y < CUBE_LAYER_COUNT; y++) {`	309	`for (y = 0; y < CUBE_LAYER_COUNT; y++) {`
310	`Cube_Set_Pixel(y,0,0,RED);`	310	`Cube_Set_Pixel(y,0,0,RED);`

Subversion Repositories Code-Repo

(root)/PIC Stuff/Cerebot_32MX7_LED_Cube/ANIMATIONS.c @ 234 – Rev 226 → 231