8x8x8 LED KÜP KODU
#include <avr/interrupt.h>
#include <string.h>
#define AXIS_X 1
#define AXIS_Y 2
#define AXIS_Z 3
volatile unsigned char cube[8][8];
volatile int current_layer = 0;
void setup()
int i;
for (i = 0; i < 14; i++)
pinMode(i, OUTPUT);
DDRC = 0xff;
PORTC = 0x00;
TCCR2A = 0x00;
TCCR2B = 0x00;
TCCR2A |= (0x01 << WGM21); // CTC mode. clear counter on TCNT2 == OCR2A
OCR2A = 10; // Interrupt every 25600th cpu cycle (256*100)
TCNT2 = 0x00; // start counting at 0
TCCR2B |= (0x01 << CS22) | (0x01 << CS21); // Start the clock with a 256
prescaler
TIMSK2 |= (0x01 << OCIE2A);
ISR (TIMER2_COMPA_vect)
int i;
// all layer selects off
PORTC = 0x00;
PORTB &= 0x0f;
PORTB |= 0x08; // output enable off.
for (i = 0; i < 8; i++)
PORTD = cube[current_layer][i];
PORTB = (PORTB & 0xF8) | (0x07 & (i + 1));
PORTB &= 0b00110111; // Output enable on.
if (current_layer < 6)
PORTC = (0x01 << current_layer);
} else if (current_layer == 6)
digitalWrite(12, HIGH);
} else
digitalWrite(13, HIGH);
current_layer++;
if (current_layer == 8)
current_layer = 0;
}
void loop()
int i, x, y, z;
while (true)
int i;
for (i = 0; i < 8; i++)
fill(0x00);
setplane(AXIS_Z, i);
delay_ms(10000);
effect_text(800);
effect_planboing(AXIS_Z, 400);
effect_planboing(AXIS_Y, 400);
effect_planboing(AXIS_X, 400);
effect_blinky2();
effect_random_filler(75, 1);
effect_random_filler(75, 0);
effect_rain(100);
effect_boxside_randsend_parallel (AXIS_X, 0, 150, 1);
effect_boxside_randsend_parallel (AXIS_X, 1, 150, 1);
effect_boxside_randsend_parallel (AXIS_Y, 0, 150, 1);
effect_boxside_randsend_parallel (AXIS_Y, 1, 150, 1);
effect_boxside_randsend_parallel (AXIS_Z, 0, 150, 1);
effect_boxside_randsend_parallel (AXIS_Z, 1, 150, 1);
effect_box_wamp(1000);
//box_filled(0, 0, 0, 7, 7, 7);
//
==============================================================================
============
// TEXT Functions
//
==============================================================================
============
char font_data[128][8] = {
{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, // 0 :
{ 0x00, 0x3E, 0x41, 0x55, 0x41, 0x55, 0x49, 0x3E }, // 1 :
{ 0x00, 0x3E, 0x7F, 0x6B, 0x7F, 0x6B, 0x77, 0x3E }, // 2 :
{ 0x00, 0x22, 0x77, 0x7F, 0x7F, 0x3E, 0x1C, 0x08 }, // 3 :
{ 0x00, 0x08, 0x1C, 0x3E, 0x7F, 0x3E, 0x1C, 0x08 }, // 4 :
{ 0x00, 0x08, 0x1C, 0x2A, 0x7F, 0x2A, 0x08, 0x1C }, // 5 :
{ 0x00, 0x08, 0x1C, 0x3E, 0x7F, 0x3E, 0x08, 0x1C }, // 6 :
{ 0x00, 0x00, 0x1C, 0x3E, 0x3E, 0x3E, 0x1C, 0x00 }, // 7 :
{ 0xFF, 0xFF, 0xE3, 0xC1, 0xC1, 0xC1, 0xE3, 0xFF }, // 8 :
{ 0x00, 0x00, 0x1C, 0x22, 0x22, 0x22, 0x1C, 0x00 }, // 9 :
{ 0xFF, 0xFF, 0xE3, 0xDD, 0xDD, 0xDD, 0xE3, 0xFF }, // 10 :
{ 0x00, 0x0F, 0x03, 0x05, 0x39, 0x48, 0x48, 0x30 }, // 11 :
{ 0x00, 0x08, 0x3E, 0x08, 0x1C, 0x22, 0x22, 0x1C }, // 12 :
{ 0x00, 0x18, 0x14, 0x10, 0x10, 0x30, 0x70, 0x60 }, // 13 :
{ 0x00, 0x0F, 0x19, 0x11, 0x13, 0x37, 0x76, 0x60 }, // 14 :
{ 0x00, 0x08, 0x2A, 0x1C, 0x77, 0x1C, 0x2A, 0x08 }, // 15 :
{ 0x00, 0x60, 0x78, 0x7E, 0x7F, 0x7E, 0x78, 0x60 }, // 16 :
{ 0x00, 0x03, 0x0F, 0x3F, 0x7F, 0x3F, 0x0F, 0x03 }, // 17 :
{ 0x00, 0x08, 0x1C, 0x2A, 0x08, 0x2A, 0x1C, 0x08 }, // 18 :
{ 0x00, 0x66, 0x66, 0x66, 0x66, 0x00, 0x66, 0x66 }, // 19 :
{ 0x00, 0x3F, 0x65, 0x65, 0x3D, 0x05, 0x05, 0x05 }, // 20 :
{ 0x00, 0x0C, 0x32, 0x48, 0x24, 0x12, 0x4C, 0x30 }, // 21 :
{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x7F, 0x7F, 0x7F }, // 22 :
{ 0x00, 0x08, 0x1C, 0x2A, 0x08, 0x2A, 0x1C, 0x3E }, // 23 :
{ 0x00, 0x08, 0x1C, 0x3E, 0x7F, 0x1C, 0x1C, 0x1C }, // 24 :
{ 0x00, 0x1C, 0x1C, 0x1C, 0x7F, 0x3E, 0x1C, 0x08 }, // 25 :
{ 0x00, 0x08, 0x0C, 0x7E, 0x7F, 0x7E, 0x0C, 0x08 }, // 26 :
{ 0x00, 0x08, 0x18, 0x3F, 0x7F, 0x3F, 0x18, 0x08 }, // 27 :
{ 0x00, 0x00, 0x00, 0x70, 0x70, 0x70, 0x7F, 0x7F }, // 28 :
{ 0x00, 0x00, 0x14, 0x22, 0x7F, 0x22, 0x14, 0x00 }, // 29 :
{ 0x00, 0x08, 0x1C, 0x1C, 0x3E, 0x3E, 0x7F, 0x7F }, // 30 :
{ 0x00, 0x7F, 0x7F, 0x3E, 0x3E, 0x1C, 0x1C, 0x08 }, // 31 :
{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, // 32 :
{ 0x00, 0x18, 0x18, 0x18, 0x18, 0x18, 0x00, 0x18 }, // 33 : !
{ 0x00, 0x36, 0x36, 0x14, 0x00, 0x00, 0x00, 0x00 }, // 34 : "
{ 0x00, 0x36, 0x36, 0x7F, 0x36, 0x7F, 0x36, 0x36 }, // 35 : #
{ 0x00, 0x08, 0x1E, 0x20, 0x1C, 0x02, 0x3C, 0x08 }, // 36 : $
{ 0x00, 0x60, 0x66, 0x0C, 0x18, 0x30, 0x66, 0x06 }, // 37 : %
{ 0x00, 0x3C, 0x66, 0x3C, 0x28, 0x65, 0x66, 0x3F }, // 38 : &
{ 0x00, 0x18, 0x18, 0x18, 0x30, 0x00, 0x00, 0x00 }, // 39 : '
{ 0x00, 0x60, 0x30, 0x18, 0x18, 0x18, 0x30, 0x60 }, // 40 : (
{ 0x00, 0x06, 0x0C, 0x18, 0x18, 0x18, 0x0C, 0x06 }, // 41 : )
{ 0x00, 0x00, 0x36, 0x1C, 0x7F, 0x1C, 0x36, 0x00 }, // 42 : *
{ 0x00, 0x00, 0x08, 0x08, 0x3E, 0x08, 0x08, 0x00 }, // 43 : +
{ 0x00, 0x00, 0x00, 0x00, 0x30, 0x30, 0x30, 0x60 }, // 44 : ,
{ 0x00, 0x00, 0x00, 0x00, 0x3C, 0x00, 0x00, 0x00 }, // 45 : -
{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x60, 0x60 }, // 46 : .
{ 0x00, 0x00, 0x06, 0x0C, 0x18, 0x30, 0x60, 0x00 }, // 47 : /
{ 0x00, 0x3C, 0x66, 0x6E, 0x76, 0x66, 0x66, 0x3C }, // 48 : 0
{ 0x00, 0x18, 0x18, 0x38, 0x18, 0x18, 0x18, 0x7E }, // 49 : 1
{ 0x00, 0x3C, 0x66, 0x06, 0x0C, 0x30, 0x60, 0x7E }, // 50 : 2
{ 0x00, 0x3C, 0x66, 0x06, 0x1C, 0x06, 0x66, 0x3C }, // 51 : 3
{ 0x00, 0x0C, 0x1C, 0x2C, 0x4C, 0x7E, 0x0C, 0x0C }, // 52 : 4
{ 0x00, 0x7E, 0x60, 0x7C, 0x06, 0x06, 0x66, 0x3C }, // 53 : 5
{ 0x00, 0x3C, 0x66, 0x60, 0x7C, 0x66, 0x66, 0x3C }, // 54 : 6
{ 0x00, 0x7E, 0x66, 0x0C, 0x0C, 0x18, 0x18, 0x18 }, // 55 : 7
{ 0x00, 0x3C, 0x66, 0x66, 0x3C, 0x66, 0x66, 0x3C }, // 56 : 8
{ 0x00, 0x3C, 0x66, 0x66, 0x3E, 0x06, 0x66, 0x3C }, // 57 : 9
{ 0x00, 0x00, 0x18, 0x18, 0x00, 0x18, 0x18, 0x00 }, // 58 : :
{ 0x00, 0x00, 0x18, 0x18, 0x00, 0x18, 0x18, 0x30 }, // 59 : ;
{ 0x00, 0x06, 0x0C, 0x18, 0x30, 0x18, 0x0C, 0x06 }, // 60 : <
{ 0x00, 0x00, 0x00, 0x3C, 0x00, 0x3C, 0x00, 0x00 }, // 61 : =
//
{ 0x00, 0x60, 0x30, 0x18, 0x0C, 0x18, 0x30, 0x60 }, // 62 : >
{ 0x00, 0x3C, 0x66, 0x06, 0x1C, 0x18, 0x00, 0x18 }, // 63 : ?
{ 0x00, 0x38, 0x44, 0x5C, 0x58, 0x42, 0x3C, 0x00 }, // 64 : @
{ 0x00, 0x3C, 0x66, 0x66, 0x7E, 0x66, 0x66, 0x66 }, // 65 : A
{ 0x00, 0x7C, 0x66, 0x66, 0x7C, 0x66, 0x66, 0x7C }, // 66 : B
{ 0x00, 0x3C, 0x66, 0x60, 0x60, 0x60, 0x66, 0x3C }, // 67 : C
{ 0x00, 0x7C, 0x66, 0x66, 0x66, 0x66, 0x66, 0x7C }, // 68 : D
{ 0x00, 0x7E, 0x60, 0x60, 0x7C, 0x60, 0x60, 0x7E }, // 69 : E
{ 0x00, 0x7E, 0x60, 0x60, 0x7C, 0x60, 0x60, 0x60 }, // 70 : F
{ 0x00, 0x3C, 0x66, 0x60, 0x60, 0x6E, 0x66, 0x3C }, // 71 : G
{ 0x00, 0x66, 0x66, 0x66, 0x7E, 0x66, 0x66, 0x66 }, // 72 : H
{ 0x00, 0x3C, 0x18, 0x18, 0x18, 0x18, 0x18, 0x3C }, // 73 : I
{ 0x00, 0x1E, 0x0C, 0x0C, 0x0C, 0x6C, 0x6C, 0x38 }, // 74 : J
{ 0x00, 0x66, 0x6C, 0x78, 0x70, 0x78, 0x6C, 0x66 }, // 75 : K
{ 0x00, 0x60, 0x60, 0x60, 0x60, 0x60, 0x60, 0x7E }, // 76 : L
{ 0x00, 0x63, 0x77, 0x7F, 0x6B, 0x63, 0x63, 0x63 }, // 77 : M
{ 0x00, 0x63, 0x73, 0x7B, 0x6F, 0x67, 0x63, 0x63 }, // 78 : N
{ 0x00, 0x3C, 0x66, 0x66, 0x66, 0x66, 0x66, 0x3C }, // 79 : O
{ 0x00, 0x7C, 0x66, 0x66, 0x66, 0x7C, 0x60, 0x60 }, // 80 : P
{ 0x00, 0x3C, 0x66, 0x66, 0x66, 0x6E, 0x3C, 0x06 }, // 81 : Q
{ 0x00, 0x7C, 0x66, 0x66, 0x7C, 0x78, 0x6C, 0x66 }, // 82 : R
{ 0x00, 0x3C, 0x66, 0x60, 0x3C, 0x06, 0x66, 0x3C }, // 83 : S
{ 0x00, 0x7E, 0x5A, 0x18, 0x18, 0x18, 0x18, 0x18 }, // 84 : T
{ 0x00, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x3E }, // 85 : U
{ 0x00, 0x66, 0x66, 0x66, 0x66, 0x66, 0x3C, 0x18 }, // 86 : V
{ 0x00, 0x63, 0x63, 0x63, 0x6B, 0x7F, 0x77, 0x63 }, // 87 : W
{ 0x00, 0x63, 0x63, 0x36, 0x1C, 0x36, 0x63, 0x63 }, // 88 : X
{ 0x00, 0x66, 0x66, 0x66, 0x3C, 0x18, 0x18, 0x18 }, // 89 : Y
{ 0x00, 0x7E, 0x06, 0x0C, 0x18, 0x30, 0x60, 0x7E }, // 90 : Z
{ 0x00, 0x1E, 0x18, 0x18, 0x18, 0x18, 0x18, 0x1E }, // 91 : [
{ 0x00, 0x00, 0x60, 0x30, 0x18, 0x0C, 0x06, 0x00 }, // 92 : \
{ 0x00, 0x78, 0x18, 0x18, 0x18, 0x18, 0x18, 0x78 }, // 93 : ]
{ 0x00, 0x08, 0x14, 0x22, 0x41, 0x00, 0x00, 0x00 }, // 94 : ^
{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7F }, // 95 : _
{ 0x00, 0x0C, 0x0C, 0x06, 0x00, 0x00, 0x00, 0x00 }, // 96 : `
{ 0x00, 0x00, 0x00, 0x3C, 0x06, 0x3E, 0x66, 0x3E }, // 97 : a
{ 0x00, 0x60, 0x60, 0x60, 0x7C, 0x66, 0x66, 0x7C }, // 98 : b
{ 0x00, 0x00, 0x00, 0x3C, 0x66, 0x60, 0x66, 0x3C }, // 99 : c
{ 0x00, 0x06, 0x06, 0x06, 0x3E, 0x66, 0x66, 0x3E }, // 100 : d
{ 0x00, 0x00, 0x00, 0x3C, 0x66, 0x7E, 0x60, 0x3C }, // 101 : e
{ 0x00, 0x1C, 0x36, 0x30, 0x30, 0x7C, 0x30, 0x30 }, // 102 : f
{ 0x00, 0x00, 0x3E, 0x66, 0x66, 0x3E, 0x06, 0x3C }, // 103 : g
{ 0x00, 0x60, 0x60, 0x60, 0x7C, 0x66, 0x66, 0x66 }, // 104 : h
{ 0x00, 0x00, 0x18, 0x00, 0x18, 0x18, 0x18, 0x3C }, // 105 : i
{ 0x00, 0x0C, 0x00, 0x0C, 0x0C, 0x6C, 0x6C, 0x38 }, // 106 : j
{ 0x00, 0x60, 0x60, 0x66, 0x6C, 0x78, 0x6C, 0x66 }, // 107 : k
{ 0x00, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18 }, // 108 : l
{ 0x00, 0x00, 0x00, 0x63, 0x77, 0x7F, 0x6B, 0x6B }, // 109 : m
{ 0x00, 0x00, 0x00, 0x7C, 0x7E, 0x66, 0x66, 0x66 }, // 110 : n
{ 0x00, 0x00, 0x00, 0x3C, 0x66, 0x66, 0x66, 0x3C }, // 111 : o
{ 0x00, 0x00, 0x7C, 0x66, 0x66, 0x7C, 0x60, 0x60 }, // 112 : p
{ 0x00, 0x00, 0x3C, 0x6C, 0x6C, 0x3C, 0x0D, 0x0F }, // 113 : q
{ 0x00, 0x00, 0x00, 0x7C, 0x66, 0x66, 0x60, 0x60 }, // 114 : r
{ 0x00, 0x00, 0x00, 0x3E, 0x40, 0x3C, 0x02, 0x7C }, // 115 : s
{ 0x00, 0x00, 0x18, 0x18, 0x7E, 0x18, 0x18, 0x18 }, // 116 : t
{ 0x00, 0x00, 0x00, 0x66, 0x66, 0x66, 0x66, 0x3E }, // 117 : u
{ 0x00, 0x00, 0x00, 0x00, 0x66, 0x66, 0x3C, 0x18 }, // 118 : v
{ 0x00, 0x00, 0x00, 0x63, 0x6B, 0x6B, 0x6B, 0x3E }, // 119 : w
{ 0x00, 0x00, 0x00, 0x66, 0x3C, 0x18, 0x3C, 0x66 }, // 120 : x
{ 0x00, 0x00, 0x00, 0x66, 0x66, 0x3E, 0x06, 0x3C }, // 121 : y
{ 0x00, 0x00, 0x00, 0x3C, 0x0C, 0x18, 0x30, 0x3C }, // 122 : z
{ 0x00, 0x0E, 0x18, 0x18, 0x30, 0x18, 0x18, 0x0E }, // 123 : {
{ 0x00, 0x18, 0x18, 0x18, 0x00, 0x18, 0x18, 0x18 }, // 124 : |
{ 0x00, 0x70, 0x18, 0x18, 0x0C, 0x18, 0x18, 0x70 }, // 125 : }
{ 0x00, 0x00, 0x00, 0x3A, 0x6C, 0x00, 0x00, 0x00 }, // 126 : ~
{ 0x00, 0x08, 0x1C, 0x36, 0x63, 0x41, 0x41, 0x7F } // 127 :
};
// Define display string here
const int charNum = 15;
char string[charNum] = {'A', 'L', 'I', ' ', 'A', 'K', 'S', 'O', 'Y', ' '};
void effect_text(int delayt) {
fill(0x00);
for (int ltr = 0; ltr < charNum; ltr++) { // For each letter in string array
for (int dist = 0; dist < 8; dist++) { //bring letter forward
fill(0x00);//blank last row
int rev = 0;
for (int rw = 7; rw >= 0; rw--) {//copy rows
cube[rev][dist] = bitswap(font_data[string[ltr]][rw]);
rev++;
delay_ms(delayt);
unsigned char bitswap (unsigned char x)//Reverses a byte (so letters aren't
backwards);
{ byte result;
asm("mov __tmp_reg__, %[in] \n\t"
"lsl __tmp_reg__ \n\t" /* shift out high bit to carry */
"ror %[out] \n\t" /* rotate carry __tmp_reg__to low bit (eventually) */
"lsl __tmp_reg__ \n\t" /* 2 */
"ror %[out] \n\t"
"lsl __tmp_reg__ \n\t" /* 3 */
"ror %[out] \n\t"
"lsl __tmp_reg__ \n\t" /* 4 */
"ror %[out] \n\t"
"lsl __tmp_reg__ \n\t" /* 5 */
"ror %[out] \n\t"
"lsl __tmp_reg__ \n\t" /* 6 */
"ror %[out] \n\t"
"lsl __tmp_reg__ \n\t" /* 7 */
"ror %[out] \n\t"
"lsl __tmp_reg__ \n\t" /* 8 */
"ror %[out] \n\t"
: [out] "=r" (result) : [in] "r" (x));
return (result);
/*EKFUNKZ*//*EKFUNKZ*/
void effect_box_wamp(int delayt)
for (int k = 0; k < 3; k++) {
for (int i = 0; i < 4; i++) {
fill(0x00);
box_filled(3 - i, 3 - i, 3 - i, 4 + i, 4 + i, 4 + i);
delay_ms(delayt);
for (int i = 3; i >= 0; i--) {
fill(0x00);
box_filled(3 - i, 3 - i, 3 - i, 4 + i, 4 + i, 4 + i);
delay_ms(delayt);
}
for (int k = 0; k < 3; k++) {
for (int i = 0; i < 4; i++) {
fill(0x00);
box_walls(3 - i, 3 - i, 3 - i, 4 + i, 4 + i, 4 + i);
delay_ms(delayt);
for (int i = 3; i >= 0; i--) {
fill(0x00);
box_walls(3 - i, 3 - i, 3 - i, 4 + i, 4 + i, 4 + i);
delay_ms(delayt);
for (int k = 0; k < 3; k++) {
for (int i = 0; i < 4; i++) {
fill(0x00);
box_wireframe(3 - i, 3 - i, 3 - i, 4 + i, 4 + i, 4 + i);
delay_ms(delayt);
for (int i = 3; i >= 0; i--) {
fill(0x00);
box_wireframe(3 - i, 3 - i, 3 - i, 4 + i, 4 + i, 4 + i);
delay_ms(delayt);
void draw_positions_axis (char axis, unsigned char positions[64], int invert)
int x, y, p;
fill(0x00);
for (x = 0; x < 8; x++)
for (y = 0; y < 8; y++)
if (invert)
p = (7 - positions[(x * 8) + y]);
} else
p = positions[(x * 8) + y];
if (axis == AXIS_Z)
setvoxel(x, y, p);
if (axis == AXIS_Y)
setvoxel(x, p, y);
if (axis == AXIS_X)
setvoxel(p, y, x);
void effect_boxside_randsend_parallel (char axis, int origin, int delay, int
mode)
int i;
int done;
unsigned char cubepos[64];
unsigned char pos[64];
int notdone = 1;
int notdone2 = 1;
int sent = 0;
for (i = 0; i < 64; i++)
pos[i] = 0;
while (notdone)
if (mode == 1)
notdone2 = 1;
while (notdone2 && sent < 64)
i = rand() % 64;
if (pos[i] == 0)
sent++;
pos[i] += 1;
notdone2 = 0;
} else if (mode == 2)
if (sent < 64)
pos[sent] += 1;
sent++;
done = 0;
for (i = 0; i < 64; i++)
{
if (pos[i] > 0 && pos[i] < 7)
pos[i] += 1;
if (pos[i] == 7)
done++;
if (done == 64)
notdone = 0;
for (i = 0; i < 64; i++)
if (origin == 0)
cubepos[i] = pos[i];
} else
cubepos[i] = (7 - pos[i]);
delay_ms(delay);
draw_positions_axis(axis, cubepos, 0);
void effect_rain (int iterations)
int i, ii;
int rnd_x;
int rnd_y;
int rnd_num;
for (ii = 0; ii < iterations; ii++)
rnd_num = rand() % 4;
for (i = 0; i < rnd_num; i++)
rnd_x = rand() % 8;
rnd_y = rand() % 8;
setvoxel(rnd_x, rnd_y, 7);
delay_ms(1000);
shift(AXIS_Z, -1);
void effect_random_filler (int delay, int state)
int x, y, z;
int loop = 0;
if (state == 1)
fill(0x00);
} else
fill(0xff);
while (loop < 511)
x = rand() % 8;
y = rand() % 8;
z = rand() % 8;
if ((state == 0 && getvoxel(x, y, z) == 0x01) || (state == 1 &&
getvoxel(x, y, z) == 0x00))
{
altervoxel(x, y, z, state);
delay_ms(delay);
loop++;
void effect_blinky2()
int i, r;
fill(0x00);
for (r = 0; r < 2; r++)
i = 750;
while (i > 0)
{ fill(0x00);
delay_ms(i);
fill(0xff);
delay_ms(100);
i = i - (15 + (1000 / (i / 10)));
delay_ms(1000);
i = 750;
while (i > 0)
fill(0x00);
delay_ms(751 - i);
fill(0xff);
delay_ms(100);
i = i - (15 + (1000 / (i / 10)));
}
void effect_planboing (int plane, int speed)
int i;
for (i = 0; i < 8; i++)
fill(0x00);
setplane(plane, i);
delay_ms(speed);
for (i = 7; i >= 0; i--)
fill(0x00);
setplane(plane, i);
delay_ms(speed);
void setvoxel(int x, int y, int z)
if (inrange(x, y, z))
cube[z][y] |= (1 << x);
}void clrvoxel(int x, int y, int z)
if (inrange(x, y, z))
cube[z][y] &= ~(1 << x);
unsigned char inrange(int x, int y, int z)
if (x >= 0 && x < 8 && y >= 0 && y < 8 && z >= 0 && z < 8)
{
return 0x01;
} else
return 0x00;
unsigned char getvoxel(int x, int y, int z)
if (inrange(x, y, z))
if (cube[z][y] & (1 << x))
return 0x01;
} else
return 0x00;
} else
return 0x00;
void altervoxel(int x, int y, int z, int state)
if (state == 1)
setvoxel(x, y, z);
} else
clrvoxel(x, y, z);
}
void flpvoxel(int x, int y, int z)
if (inrange(x, y, z))
cube[z][y] ^= (1 << x);
void argorder(int ix1, int ix2, int *ox1, int *ox2)
if (ix1 > ix2)
int tmp;
tmp = ix1;
ix1 = ix2;
ix2 = tmp;
*ox1 = ix1;
*ox2 = ix2;
void setplane_z (int z)
int i;
if (z >= 0 && z < 8)
for (i = 0; i < 8; i++)
cube[z][i] = 0xff;
void clrplane_z (int z)
int i;
if (z >= 0 && z < 8)
for (i = 0; i < 8; i++)
cube[z][i] = 0x00;
void setplane_x (int x)
int z;
int y;
if (x >= 0 && x < 8)
for (z = 0; z < 8; z++)
for (y = 0; y < 8; y++)
cube[z][y] |= (1 << x);
void clrplane_x (int x)
int z;
int y;
if (x >= 0 && x < 8)
for (z = 0; z < 8; z++)
for (y = 0; y < 8; y++)
{
cube[z][y] &= ~(1 << x);
void setplane_y (int y)
int z;
if (y >= 0 && y < 8)
for (z = 0; z < 8; z++)
cube[z][y] = 0xff;
void clrplane_y (int y)
int z;
if (y >= 0 && y < 8)
for (z = 0; z < 8; z++)
cube[z][y] = 0x00;
void setplane (char axis, unsigned char i)
switch (axis)
case AXIS_X:
setplane_x(i);
break;
case AXIS_Y:
setplane_y(i);
break;
case AXIS_Z:
setplane_z(i);
break;
void clrplane (char axis, unsigned char i)
switch (axis)
case AXIS_X:
clrplane_x(i);
break;
case AXIS_Y:
clrplane_y(i);
break;
case AXIS_Z:
clrplane_z(i);
break;
void fill (unsigned char pattern)
int z;
int y;
for (z = 0; z < 8; z++)
for (y = 0; y < 8; y++)
cube[z][y] = pattern;
}
void box_filled(int x1, int y1, int z1, int x2, int y2, int z2)
int iy;
int iz;
argorder(x1, x2, &x1, &x2);
argorder(y1, y2, &y1, &y2);
argorder(z1, z2, &z1, &z2);
for (iz = z1; iz <= z2; iz++)
for (iy = y1; iy <= y2; iy++)
cube[iz][iy] |= byteline(x1, x2);
void box_walls(int x1, int y1, int z1, int x2, int y2, int z2)
int iy;
int iz;
argorder(x1, x2, &x1, &x2);
argorder(y1, y2, &y1, &y2);
argorder(z1, z2, &z1, &z2);
for (iz = z1; iz <= z2; iz++)
for (iy = y1; iy <= y2; iy++)
if (iy == y1 || iy == y2 || iz == z1 || iz == z2)
{
cube[iz][iy] = byteline(x1, x2);
} else
cube[iz][iy] |= ((0x01 << x1) | (0x01 << x2));
void box_wireframe(int x1, int y1, int z1, int x2, int y2, int z2)
int iy;
int iz;
argorder(x1, x2, &x1, &x2);
argorder(y1, y2, &y1, &y2);
argorder(z1, z2, &z1, &z2);
cube[z1][y1] = byteline(x1, x2);
cube[z1][y2] = byteline(x1, x2);
cube[z2][y1] = byteline(x1, x2);
cube[z2][y2] = byteline(x1, x2);
for (iy = y1; iy <= y2; iy++)
setvoxel(x1, iy, z1);
setvoxel(x1, iy, z2);
setvoxel(x2, iy, z1);
setvoxel(x2, iy, z2);
for (iz = z1; iz <= z2; iz++)
setvoxel(x1, y1, iz);
setvoxel(x1, y2, iz);
setvoxel(x2, y1, iz);
setvoxel(x2, y2, iz);
char byteline (int start, int end)
return ((0xff << start) & ~(0xff << (end + 1)));
char flipbyte (char byte)
char flop = 0x00;
flop = (flop & 0b11111110) | (0b00000001 & (byte >> 7));
flop = (flop & 0b11111101) | (0b00000010 & (byte >> 5));
flop = (flop & 0b11111011) | (0b00000100 & (byte >> 3));
flop = (flop & 0b11110111) | (0b00001000 & (byte >> 1));
flop = (flop & 0b11101111) | (0b00010000 & (byte << 1));
flop = (flop & 0b11011111) | (0b00100000 & (byte << 3));
flop = (flop & 0b10111111) | (0b01000000 & (byte << 5));
flop = (flop & 0b01111111) | (0b10000000 & (byte << 7));
return flop;
void line(int x1, int y1, int z1, int x2, int y2, int z2)
float xy;
float xz;
unsigned char x, y, z;
unsigned char lasty, lastz;
if (x1 > x2)
int tmp;
tmp = x2; x2 = x1; x1 = tmp;
tmp = y2; y2 = y1; y1 = tmp;
tmp = z2; z2 = z1; z1 = tmp;
if (y1 > y2)
xy = (float)(y1 - y2) / (float)(x2 - x1);
lasty = y2;
} else
xy = (float)(y2 - y1) / (float)(x2 - x1);
lasty = y1;
if (z1 > z2)
xz = (float)(z1 - z2) / (float)(x2 - x1);
lastz = z2;
} else
xz = (float)(z2 - z1) / (float)(x2 - x1);
lastz = z1;
for (x = x1; x <= x2; x++)
y = (xy * (x - x1)) + y1;
z = (xz * (x - x1)) + z1;
setvoxel(x, y, z);
void delay_ms(uint16_t x)
{
uint8_t y, z;
for ( ; x > 0 ; x--) {
for ( y = 0 ; y < 90 ; y++) {
for ( z = 0 ; z < 6 ; z++) {
asm volatile ("nop");
int i, x , y;
int ii, iii;
int state;
for (i = 0; i < 8; i++)
if (direction == -1)
ii = i;
} else
ii = (7 - i);
for (x = 0; x < 8; x++)
for (y = 0; y < 8; y++)
if (direction == -1)
iii = ii + 1;
} else
{
iii = ii - 1;
if (axis == AXIS_Z)
state = getvoxel(x, y, iii);
altervoxel(x, y, ii, state);
if (axis == AXIS_Y)
state = getvoxel(x, iii, y);
altervoxel(x, ii, y, state);
if (axis == AXIS_X)
state = getvoxel(iii, y, x);
altervoxel(ii, y, x, state);
if (direction == -1)
i = 7;
} else
i = 0;
}
for (x = 0; x < 8; x++)
for (y = 0; y < 8; y++)
if (axis == AXIS_Z)
clrvoxel(x, y, i);
if (axis == AXIS_Y)
clrvoxel(x, i, y);
if (axis == AXIS_X)
clrvoxel(i, y, x);
