first commitHEADmaster

10 files changed, 2586 insertions, 0 deletions

diff --git a/avr-test/src/cube.h b/avr-test/src/cube.h
new file mode 100644
index 0000000..01f19da
--- /dev/null
+++ b/avr-test/src/cube.h
@@ -0,0 +1,32 @@
+#ifndef CUBE_H
+#define CUBE_H
+
+// Some of the functions are created to be portable
+// These functions will work on cubes of different sizes by
+// changing this constant
+#define CUBE_SIZE 8
+#define CUBE_BYTES 64
+
+// If you change this to anything greather than 8, you also have
+// change how the cube buffer works and probably all the functions
+// in draw.c
+
+// Cube buffer
+// Data from this array is loaded onto the cube for each duty cycle
+extern volatile unsigned char cube[CUBE_SIZE][CUBE_SIZE];
+
+// Framebuffer
+// Animations that take a lot of time to compute are temporarily
+// stored to this array, then loaded into cube[8][8] when the image
+// is ready to be displayed
+extern volatile unsigned char fb[CUBE_SIZE][CUBE_SIZE];
+
+// Some effects can render on different axis
+// for example send pixels along an axis
+// for better readability, we use the following predefined constants
+#define AXIS_X 0x78
+#define AXIS_Y 0x79
+#define AXIS_Z 0x7a
+
+#endif
+
diff --git a/avr-test/src/draw.cpp b/avr-test/src/draw.cpp
new file mode 100644
index 0000000..faaa346
--- /dev/null
+++ b/avr-test/src/draw.cpp
@@ -0,0 +1,559 @@
+#include "draw.h"
+#include "string.h"
+
+// Set a single voxel to ON
+void setvoxel(int x, int y, int z)
+{
+	if (inrange(x,y,z))
+		cube[z][y] |= (1 << x);
+}
+
+// Set a single voxel in the temporary cube buffer to ON
+void tmpsetvoxel(int x, int y, int z)
+{
+	if (inrange(x,y,z))
+		fb[z][y] |= (1 << x);
+}
+
+// Set a single voxel to OFF
+void clrvoxel(int x, int y, int z)
+{
+	if (inrange(x,y,z))
+		cube[z][y] &= ~(1 << x);
+}
+
+// Set a single voxel to OFF
+void tmpclrvoxel(int x, int y, int z)
+{
+	if (inrange(x,y,z))
+		fb[z][y] &= ~(1 << x);
+}
+
+// This function validates that we are drawing inside the cube.
+unsigned char inrange(int x, int y, int z)
+{
+	if (x >= 0 && x < CUBE_SIZE && y >= 0 && y < CUBE_SIZE && z >= 0 && z < CUBE_SIZE)
+	{
+		return 1;
+	} else
+	{
+		// One of the coordinates was outside the cube.
+		return 0;
+	}
+}
+
+// Get the current status of a voxel
+unsigned char getvoxel(int x, int y, int z)
+{
+	if (inrange(x,y,z))
+	{
+		if (cube[z][y] & (1 << x))
+		{
+			return 1;
+		} else
+		{
+			return 0;
+		}
+	} else
+	{
+		return 0;
+	}
+}
+
+// In some effect we want to just take bool and write it to a voxel
+// this function calls the apropriate voxel manipulation function.
+void altervoxel(int x, int y, int z, int state)
+{
+	if (state == 1)
+	{
+		setvoxel(x,y,z);
+	} else
+	{
+		clrvoxel(x,y,z);
+	}
+}
+
+// Flip the state of a voxel.
+// If the voxel is 1, its turned into a 0, and vice versa.
+void flpvoxel(int x, int y, int z)
+{
+	if (inrange(x, y, z))
+		cube[z][y] ^= (1 << x);
+}
+
+// Makes sure x1 is alwas smaller than x2
+// This is usefull for functions that uses for loops,
+// to avoid infinite loops
+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;
+}
+
+// Sets all voxels along a X/Y plane at a given point
+// on axis Z
+void setplane_z (int z)
+{
+	int i;
+	if (z>=0 && z<CUBE_SIZE)
+	{
+		for (i=0;i<CUBE_SIZE;i++)
+			cube[z][i] = 0xff;
+	}
+}
+
+// Clears voxels in the same manner as above
+void clrplane_z (int z)
+{
+	int i;
+	if (z>=0 && z<CUBE_SIZE)
+	{
+		for (i=0;i<CUBE_SIZE;i++)
+			cube[z][i] = 0x00;
+	}
+}
+
+void setplane_x (int x)
+{
+	int z;
+	int y;
+	if (x>=0 && x<CUBE_SIZE)
+	{
+		for (z=0;z<CUBE_SIZE;z++)
+		{
+			for (y=0;y<CUBE_SIZE;y++)
+			{
+				cube[z][y] |= (1 << x);
+			}
+		}
+	}
+}
+
+void clrplane_x (int x)
+{
+	int z;
+	int y;
+	if (x>=0 && x<CUBE_SIZE)
+	{
+		for (z=0;z<CUBE_SIZE;z++)
+		{
+			for (y=0;y<CUBE_SIZE;y++)
+			{
+				cube[z][y] &= ~(1 << x);
+			}
+		}
+	}
+}
+
+void setplane_y (int y)
+{
+	int z;
+	if (y>=0 && y<CUBE_SIZE)
+	{
+		for (z=0;z<CUBE_SIZE;z++)
+			cube[z][y] = 0xff;
+	}
+}
+
+void clrplane_y (int y)
+{
+	int z;
+	if (y>=0 && y<CUBE_SIZE)
+	{
+		for (z=0;z<CUBE_SIZE;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;
+    }
+}
+
+// Fill a value into all 64 byts of the cube buffer
+// Mostly used for clearing. fill(0x00)
+// or setting all on. fill(0xff)
+void fill (unsigned char pattern)
+{
+	int z;
+	int y;
+	for (z=0;z<CUBE_SIZE;z++)
+	{
+		for (y=0;y<CUBE_SIZE;y++)
+		{
+			cube[z][y] = pattern;
+		}
+	}
+}
+
+void tmpfill (unsigned char pattern)
+{
+	int z;
+	int y;
+	for (z=0;z<CUBE_SIZE;z++)
+	{
+		for (y=0;y<CUBE_SIZE;y++)
+		{
+			fb[z][y] = pattern;
+		}
+	}
+}
+
+// Draw a box with all walls drawn and all voxels inside set
+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);
+		}
+	}
+
+}
+
+// Darw a hollow box with side walls.
+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));
+			}
+		}
+	}
+
+}
+
+// Draw a wireframe box. This only draws the corners and edges,
+// no walls.
+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);
+
+	// Lines along X axis
+	cube[z1][y1] = byteline(x1,x2);
+	cube[z1][y2] = byteline(x1,x2);
+	cube[z2][y1] = byteline(x1,x2);
+	cube[z2][y2] = byteline(x1,x2);
+
+	// Lines along Y axis
+	for (iy=y1;iy<=y2;iy++)
+	{
+		setvoxel(x1,iy,z1);
+		setvoxel(x1,iy,z2);
+		setvoxel(x2,iy,z1);
+		setvoxel(x2,iy,z2);
+	}
+
+	// Lines along Z axis
+	for (iz=z1;iz<=z2;iz++)
+	{
+		setvoxel(x1,y1,iz);
+		setvoxel(x1,y2,iz);
+		setvoxel(x2,y1,iz);
+		setvoxel(x2,y2,iz);
+	}
+
+}
+
+// Returns a byte with a row of 1's drawn in it.
+// byteline(2,5) gives 0b00111100
+char byteline (int start, int end)
+{
+	return ((0xff<<start) & ~(0xff<<(end+1)));
+}
+
+// Flips a byte 180 degrees.
+// MSB becomes LSB, LSB becomes MSB.
+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;
+}
+
+// Draw a line between any coordinates in 3d space.
+// Uses integer values for input, so dont expect smooth animations.
+void line(int x1, int y1, int z1, int x2, int y2, int z2)
+{
+	float xy;	// how many voxels do we move on the y axis for each step on the x axis
+	float xz;	// how many voxels do we move on the y axis for each step on the x axis
+	unsigned char x,y,z;
+	unsigned char lasty,lastz;
+
+	// We always want to draw the line from x=0 to x=7.
+	// If x1 is bigget than x2, we need to flip all the values.
+	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 each step of x, y increments by:
+	for (x = x1; x<=x2;x++)
+	{
+		y = (xy*(x-x1))+y1;
+		z = (xz*(x-x1))+z1;
+		setvoxel(x,y,z);
+	}
+
+}
+
+// Delay loop.
+// This is not calibrated to milliseconds,
+// but we had allready made to many effects using this
+// calibration when we figured it might be a good idea
+// to calibrate it.
+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");
+      }
+    }
+  }
+}
+
+// Copies the contents of fb (temp cube buffer) into the rendering buffer
+void tmp2cube (void)
+{
+    memcpy((void*)cube, (const void*)fb, 64); // copy the current cube into a buffer.
+}
+
+// Shift the entire contents of the cube along an axis
+// This is great for effects where you want to draw something
+// on one side of the cube and have it flow towards the other
+// side. Like rain flowing down the Z axiz.
+void shift (char axis, int direction)
+{
+	int i, x ,y;
+	int ii, iii;
+	int state;
+
+	for (i = 0; i < CUBE_SIZE; i++)
+	{
+		if (direction == -1)
+		{
+			ii = i;
+		} else
+		{
+			ii = (7-i);
+		}
+
+
+		for (x = 0; x < CUBE_SIZE; x++)
+		{
+			for (y = 0; y < CUBE_SIZE; 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 < CUBE_SIZE; x++)
+	{
+		for (y = 0; y < CUBE_SIZE; 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);
+		}
+	}
+}
+
+// Flip the cube 180 degrees along the y axis.
+void mirror_y (void)
+{
+    unsigned char buffer[CUBE_SIZE][CUBE_SIZE];
+    unsigned char x,y,z;
+
+    memcpy(buffer, (const void*)cube, CUBE_BYTES); // copy the current cube into a buffer.
+
+    fill(0x00);
+    for (z=0; z<CUBE_SIZE; z++)
+    {
+        for (y=0; y<CUBE_SIZE; y++)
+        {
+            for (x=0; x<CUBE_SIZE; x++)
+            {
+                if (buffer[z][y] & (0x01 << x))
+                    setvoxel(x,CUBE_SIZE-1-y,z);
+            }
+        }
+    }
+
+}
+
+// Flip the cube 180 degrees along the x axis
+void mirror_x (void)
+{
+    unsigned char buffer[CUBE_SIZE][CUBE_SIZE];
+    unsigned char y,z;
+
+    memcpy(buffer, (const void*)cube, CUBE_BYTES); // copy the current cube into a buffer.
+
+    fill(0x00);
+
+    for (z=0; z<CUBE_SIZE; z++)
+    {
+        for (y=0; y<CUBE_SIZE; y++)
+        {
+            // This will break with different buffer sizes..
+            cube[z][y] = flipbyte(buffer[z][y]);
+        }
+    }
+}
+
+// flip the cube 180 degrees along the z axis
+void mirror_z (void)
+{
+    unsigned char buffer[CUBE_SIZE][CUBE_SIZE];
+    unsigned char z, y;
+
+    memcpy(buffer, (const void*)cube, CUBE_BYTES); // copy the current cube into a buffer.
+
+    for (y=0; y<CUBE_SIZE; y++)
+    {
+        for (z=0; z<CUBE_SIZE; z++)
+        {
+            cube[CUBE_SIZE-1-z][y] = buffer[z][y];
+        }
+    }
+}
+
diff --git a/avr-test/src/draw.h b/avr-test/src/draw.h
new file mode 100644
index 0000000..abe93d2
--- /dev/null
+++ b/avr-test/src/draw.h
@@ -0,0 +1,71 @@
+#ifndef DRAW_H
+#define DRAW_H
+
+#include <avr/io.h>
+#include <avr/pgmspace.h>
+
+#include "cube.h"
+
+extern const unsigned char font[480];
+
+// Red led on D2
+#define LED_RED 0x04
+// Green led D3
+#define LED_GREEN 0x08
+// Program led on D4
+#define LED_PGM 0x10;
+// Leds connected to port D
+#define LED_PORT PORTD
+// Programming button on D5
+#define PGM_BTN 0x20
+
+void delay_ms (uint16_t x);
+
+
+void setvoxel(int x, int y, int z);
+void clrvoxel(int x, int y, int z);
+void tmpsetvoxel(int x, int y, int z);
+void tmpclrvoxel(int x, int y, int z);
+
+unsigned char inrange(int x, int y, int z);
+unsigned char getvoxel(int x, int y, int z);
+void flpvoxel(int x, int y, int z);
+
+void altervoxel(int x, int y, int z, int state);
+void setplane_z(int z);
+void clrplane_z(int z);
+void setplane_x(int x);
+void clrplane_x(int x);
+void setplane_y(int y);
+void clrplane_y(int y);
+
+void setplane (char axis, unsigned char i);
+void clrplane (char axis, unsigned char i);
+
+void setline_z(int x, int y, int z1, int z2);
+void setline_x(int z, int y, int x1, int x2);
+void setline_y(int z, int x, int y1, int y2);
+void clrline_z(int x, int y, int z1, int z2);
+void clrline_x(int z, int y, int x1, int x2);
+void clrline_y(int z, int x, int y1, int y2);
+void fill(unsigned char pattern);
+void tmpfill(unsigned char pattern);
+void line(int x1, int y1, int z1, int x2, int y2, int z2);
+void drawchar(char chr, int offset, int layer);
+char flipbyte(char byte);
+void charfly (char chr, int direction, char axis, int mode, uint16_t delay);
+void strfly (char * str, int direction, char axis, int mode, uint16_t delay, uint16_t pause);
+void box_filled(int x1, int y1, int z1, int x2, int y2, int z2);
+void box_walls(int x1, int y1, int z1, int x2, int y2, int z2);
+void box_wireframe(int x1, int y1, int z1, int x2, int y2, int z2);
+char byteline (int start, int end);
+
+void tmp2cube (void);
+void shift (char axis, int direction);
+
+void mirror_x(void);
+void mirror_y(void);
+void mirror_z(void);
+
+#endif
+
diff --git a/avr-test/src/effect.cpp b/avr-test/src/effect.cpp
new file mode 100644
index 0000000..1f47155
--- /dev/null
+++ b/avr-test/src/effect.cpp
@@ -0,0 +1,1021 @@
+#include "effect.h"
+#include "draw.h"
+#include <math.h>
+#include <avr/interrupt.h>
+
+//char myrand();
+int myrand();
+
+void effect_test (void)
+{
+
+	int x,y,i;
+
+	for (i=0;i<1000;i++)
+	{
+		x = sin(i/8)*2+3.5;
+		y = cos(i/8)*2+3.5;
+
+		setvoxel(x,y,1);
+		setvoxel(x,y,1);
+		delay_ms(1000);
+		fill(0x00);
+	}
+
+}
+
+
+// Draw a plane on one axis and send it back and forth once.
+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 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_box_shrink_grow (int iterations, int rot, int flip, uint16_t delay)
+{
+	int x, i, xyz;
+	for (x=0;x<iterations;x++)
+	{
+		for (i=0;i<16;i++)
+		{
+            xyz = 7-i; // This reverses counter i between 0 and 7.
+            if (i > 7)
+                xyz = i-8; // at i > 7, i 8-15 becomes xyz 0-7.
+
+            fill(0x00); delay_ms(1);
+            cli(); // disable interrupts while the cube is being rotated
+			box_wireframe(0,0,0,xyz,xyz,xyz);
+
+            if (flip > 0) // upside-down
+                mirror_z();
+
+            if (rot == 1 || rot == 3)
+                mirror_y();
+
+            if (rot == 2 || rot == 3)
+                mirror_x();
+
+            sei(); // enable interrupts
+			delay_ms(delay);
+	        fill(0x00);
+        }
+    }
+}
+
+// Creates a wireframe box that shrinks or grows out from the center of the cube.
+void effect_box_woopwoop (int delay, int grow)
+{
+	int i,ii;
+
+	fill(0x00);
+	for (i=0;i<4;i++)
+	{
+        ii = i;
+        if (grow > 0)
+            ii = 3-i;
+
+		box_wireframe(4+ii,4+ii,4+ii,3-ii,3-ii,3-ii);
+		delay_ms(delay);
+		fill(0x00);
+	}
+}
+
+
+// Send a voxel flying from one side of the cube to the other
+// If its at the bottom, send it to the top..
+void sendvoxel_z (unsigned char x, unsigned char y, unsigned char z, int delay)
+{
+	int i, ii;
+	for (i=0; i<8; i++)
+	{
+		if (z == 7)
+		{
+			ii = 7-i;
+			clrvoxel(x,y,ii+1);
+		} else
+		{
+			ii = i;
+			clrvoxel(x,y,ii-1);
+		}
+		setvoxel(x,y,ii);
+		delay_ms(delay);
+	}
+}
+
+// Send all the voxels from one side of the cube to the other
+// Start at z and send to the opposite side.
+// Sends in random order.
+void sendplane_rand_z (unsigned char z, int delay, int wait)
+{
+	unsigned char loop = 16;
+	unsigned char x, y;
+
+	fill(0x00);
+
+	setplane_z(z);
+
+	// Send voxels at random untill all 16 have crossed the cube.
+	while(loop)
+	{
+		x = myrand()%4;
+		y = myrand()%4;
+		if (getvoxel(x,y,z))
+		{
+			// Send the voxel flying
+			sendvoxel_z(x,y,z,delay);
+			delay_ms(wait);
+			loop--; // one down, loop-- to go. when this hits 0, the loop exits.
+		}
+	}
+}
+
+// For each coordinate along X and Y, a voxel is set either at level 0 or at level 7
+// for n iterations, a random voxel is sent to the opposite side of where it was.
+void sendvoxels_rand_z (int iterations, int delay, int wait)
+{
+	unsigned char x, y, last_x = 0, last_y = 0, i;
+
+	fill(0x00);
+
+	// Loop through all the X and Y coordinates
+	for (x=0;x<8;x++)
+	{
+		for (y=0;y<8;y++)
+		{
+			// Then set a voxel either at the top or at the bottom
+            // myrand()%2 returns either 0 or 1. multiplying by 7 gives either 0 or 7.
+            setvoxel(x,y,((myrand()%2)*7));
+		}
+	}
+
+	for (i=0;i<iterations;i++)
+	{
+		// Pick a random x,y position
+		x = myrand()%8;
+		y = myrand()%8;
+		// but not the sameone twice in a row
+		if (y != last_y && x != last_x)
+		{
+			// If the voxel at this x,y is at the bottom
+			if (getvoxel(x,y,0))
+			{
+				// send it to the top
+				sendvoxel_z(x,y,0,delay);
+			} else
+			{
+				// if its at the top, send it to the bottom
+				sendvoxel_z(x,y,7,delay);
+			}
+			delay_ms(wait);
+
+			// Remember the last move
+			last_y = y;
+			last_x = x;
+		}
+	}
+
+}
+
+
+// Big ugly function :p but it looks pretty
+void boingboing(uint16_t iterations, int delay, unsigned char mode, unsigned char drawmode)
+{
+	fill(0x00);		// Blank the cube
+
+	int x, y, z;		// Current coordinates for the point
+	int dx, dy, dz;	// Direction of movement
+	int lol, i;		// lol?
+	unsigned char crash_x, crash_y, crash_z;
+
+	y = myrand()%8;
+	x = myrand()%8;
+	z = myrand()%8;
+
+	// Coordinate array for the snake.
+	int snake[8][3];
+	for (i=0;i<8;i++)
+	{
+		snake[i][0] = x;
+		snake[i][1] = y;
+		snake[i][2] = z;
+	}
+
+
+	dx = 1;
+	dy = 1;
+	dz = 1;
+
+	while(iterations)
+	{
+		crash_x = 0;
+		crash_y = 0;
+		crash_z = 0;
+
+
+		// Let's mix things up a little:
+		if (myrand()%3 == 0)
+		{
+			// Pick a random axis, and set the speed to a random number.
+			lol = myrand()%3;
+			if (lol == 0)
+				dx = myrand()%3 - 1;
+
+			if (lol == 1)
+				dy = myrand()%3 - 1;
+
+			if (lol == 2)
+				dz = myrand()%3 - 1;
+		}
+
+	    // The point has reached 0 on the x-axis and is trying to go to -1
+        // aka a crash
+		if (dx == -1 && x == 0)
+		{
+			crash_x = 0x01;
+			if (myrand()%3 == 1)
+			{
+				dx = 1;
+			} else
+			{
+				dx = 0;
+			}
+		}
+
+        // y axis 0 crash
+		if (dy == -1 && y == 0)
+		{
+			crash_y = 0x01;
+			if (myrand()%3 == 1)
+			{
+				dy = 1;
+			} else
+			{
+				dy = 0;
+			}
+		}
+
+        // z axis 0 crash
+		if (dz == -1 && z == 0)
+		{
+			crash_z = 0x01;
+			if (myrand()%3 == 1)
+			{
+				dz = 1;
+			} else
+			{
+				dz = 0;
+			}
+		}
+
+        // x axis 7 crash
+		if (dx == 1 && x == 7)
+		{
+			crash_x = 0x01;
+			if (myrand()%3 == 1)
+			{
+				dx = -1;
+			} else
+			{
+				dx = 0;
+			}
+		}
+
+        // y axis 7 crash
+		if (dy == 1 && y == 7)
+		{
+			crash_y = 0x01;
+			if (myrand()%3 == 1)
+			{
+				dy = -1;
+			} else
+			{
+				dy = 0;
+			}
+		}
+
+        // z azis 7 crash
+		if (dz == 1 && z == 7)
+		{
+			crash_z = 0x01;
+			if (myrand()%3 == 1)
+			{
+				dz = -1;
+			} else
+			{
+				dz = 0;
+			}
+		}
+
+		// mode bit 0 sets crash action enable
+		if (mode | 0x01)
+		{
+			if (crash_x)
+			{
+				if (dy == 0)
+				{
+					if (y == 7)
+					{
+						dy = -1;
+					} else if (y == 0)
+					{
+						dy = +1;
+					} else
+					{
+						if (myrand()%2 == 0)
+						{
+							dy = -1;
+						} else
+						{
+							dy = 1;
+						}
+					}
+				}
+				if (dz == 0)
+				{
+					if (z == 7)
+					{
+						dz = -1;
+					} else if (z == 0)
+					{
+						dz = 1;
+					} else
+					{
+						if (myrand()%2 == 0)
+						{
+							dz = -1;
+						} else
+						{
+							dz = 1;
+						}
+					}
+				}
+			}
+
+			if (crash_y)
+			{
+				if (dx == 0)
+				{
+					if (x == 7)
+					{
+						dx = -1;
+					} else if (x == 0)
+					{
+						dx = 1;
+					} else
+					{
+						if (myrand()%2 == 0)
+						{
+							dx = -1;
+						} else
+						{
+							dx = 1;
+						}
+					}
+				}
+				if (dz == 0)
+				{
+					if (z == 3)
+					{
+						dz = -1;
+					} else if (z == 0)
+					{
+						dz = 1;
+					} else
+					{
+						if (myrand()%2 == 0)
+						{
+							dz = -1;
+						} else
+						{
+							dz = 1;
+						}
+					}
+				}
+			}
+
+			if (crash_z)
+			{
+				if (dy == 0)
+				{
+					if (y == 7)
+					{
+						dy = -1;
+					} else if (y == 0)
+					{
+						dy = 1;
+					} else
+					{
+						if (myrand()%2 == 0)
+						{
+							dy = -1;
+						} else
+						{
+							dy = 1;
+						}
+					}
+				}
+				if (dx == 0)
+				{
+					if (x == 7)
+					{
+						dx = -1;
+					} else if (x == 0)
+					{
+						dx = 1;
+					} else
+					{
+						if (myrand()%2 == 0)
+						{
+							dx = -1;
+						} else
+						{
+							dx = 1;
+						}
+					}
+				}
+			}
+		}
+
+		// mode bit 1 sets corner avoid enable
+		if (mode | 0x02)
+		{
+			if (	// We are in one of 8 corner positions
+				(x == 0 && y == 0 && z == 0) ||
+				(x == 0 && y == 0 && z == 7) ||
+				(x == 0 && y == 7 && z == 0) ||
+				(x == 0 && y == 7 && z == 7) ||
+				(x == 7 && y == 0 && z == 0) ||
+				(x == 7 && y == 0 && z == 7) ||
+				(x == 7 && y == 7 && z == 0) ||
+				(x == 7 && y == 7 && z == 7)
+			)
+			{
+				// At this point, the voxel would bounce
+				// back and forth between this corner,
+				// and the exact opposite corner
+				// We don't want that!
+
+				// So we alter the trajectory a bit,
+				// to avoid corner stickyness
+				lol = myrand()%3;
+				if (lol == 0)
+					dx = 0;
+
+				if (lol == 1)
+					dy = 0;
+
+				if (lol == 2)
+					dz = 0;
+			}
+		}
+
+        // one last sanity check
+        if (x == 0 && dx == -1)
+            dx = 1;
+
+        if (y == 0 && dy == -1)
+            dy = 1;
+
+        if (z == 0 && dz == -1)
+            dz = 1;
+
+        if (x == 7 && dx == 1)
+            dx = -1;
+
+        if (y == 7 && dy == 1)
+            dy = -1;
+
+        if (z == 7 && dz == 1)
+            dz = -1;
+
+
+		// Finally, move the voxel.
+		x = x + dx;
+		y = y + dy;
+		z = z + dz;
+
+		if (drawmode == 0x01) // show one voxel at time
+		{
+			setvoxel(x,y,z);
+			delay_ms(delay);
+			clrvoxel(x,y,z);
+		} else if (drawmode == 0x02) // flip the voxel in question
+		{
+			flpvoxel(x,y,z);
+			delay_ms(delay);
+		} if (drawmode == 0x03) // draw a snake
+		{
+			for (i=7;i>=0;i--)
+			{
+				snake[i][0] = snake[i-1][0];
+				snake[i][1] = snake[i-1][1];
+				snake[i][2] = snake[i-1][2];
+			}
+			snake[0][0] = x;
+			snake[0][1] = y;
+			snake[0][2] = z;
+
+			for (i=0;i<8;i++)
+			{
+				setvoxel(snake[i][0],snake[i][1],snake[i][2]);
+			}
+			delay_ms(delay);
+			for (i=0;i<8;i++)
+			{
+				clrvoxel(snake[i][0],snake[i][1],snake[i][2]);
+			}
+		}
+
+
+		iterations--;
+	}
+}
+
+// Set or clear exactly 512 voxels in a random order.
+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 = myrand()%8;
+		y = myrand()%8;
+		z = myrand()%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_rain (int iterations)
+{
+	int i, ii;
+	int rnd_x;
+	int rnd_y;
+	int rnd_num;
+
+	for (ii=0;ii<iterations;ii++)
+	{
+		rnd_num = myrand()%4;
+
+		for (i=0; i < rnd_num;i++)
+		{
+			rnd_x = myrand()%8;
+			rnd_y = myrand()%8;
+			setvoxel(rnd_x,rnd_y,7);
+		}
+
+		delay_ms(1000);
+		shift(AXIS_Z,-1);
+	}
+}
+
+void effect_z_updown (int iterations, int delay)
+{
+	unsigned char positions[64];
+	unsigned char destinations[64];
+
+	int i,y,move;
+
+	for (i=0; i<64; i++)
+	{
+		positions[i] = 4;
+		destinations[i] = myrand()%8;
+	}
+
+	for (i=0; i<8; i++)
+	{
+		effect_z_updown_move(positions, destinations, AXIS_Z);
+		delay_ms(delay);
+	}
+
+	for (i=0;i<iterations;i++)
+	{
+		for (move=0;move<8;move++)
+		{
+			effect_z_updown_move(positions, destinations, AXIS_Z);
+			delay_ms(delay);
+		}
+
+		delay_ms(delay*4);
+
+
+		for (y=0;y<32;y++)
+		{
+				destinations[myrand()%64] = myrand()%8;
+		}
+
+	}
+
+}
+
+void effect_z_updown_move (unsigned char positions[64], unsigned char destinations[64], char axis)
+{
+	int px;
+	for (px=0; px<64; px++)
+	{
+		if (positions[px]<destinations[px])
+		{
+			positions[px]++;
+		}
+		if (positions[px]>destinations[px])
+		{
+			positions[px]--;
+		}
+	}
+
+	draw_positions_axis (AXIS_Z, positions,0);
+}
+
+void effect_axis_updown_randsuspend (char axis, int delay, int sleep, int invert)
+{
+	unsigned char positions[64];
+	unsigned char destinations[64];
+
+	int i,px;
+
+    // Set 64 random positions
+	for (i=0; i<64; i++)
+	{
+		positions[i] = 0; // Set all starting positions to 0
+		destinations[i] = myrand()%8;
+	}
+
+    // Loop 8 times to allow destination 7 to reach all the way
+	for (i=0; i<8; i++)
+	{
+        // For every iteration, move all position one step closer to their destination
+		for (px=0; px<64; px++)
+		{
+			if (positions[px]<destinations[px])
+			{
+				positions[px]++;
+			}
+		}
+        // Draw the positions and take a nap
+		draw_positions_axis (axis, positions,invert);
+		delay_ms(delay);
+	}
+
+    // Set all destinations to 7 (opposite from the side they started out)
+	for (i=0; i<64; i++)
+	{
+		destinations[i] = 7;
+	}
+
+    // Suspend the positions in mid-air for a while
+	delay_ms(sleep);
+
+    // Then do the same thing one more time
+	for (i=0; i<8; i++)
+	{
+		for (px=0; px<64; px++)
+		{
+			if (positions[px]<destinations[px])
+			{
+				positions[px]++;
+			}
+			if (positions[px]>destinations[px])
+			{
+				positions[px]--;
+			}
+		}
+		draw_positions_axis (axis, positions,invert);
+		delay_ms(delay);
+	}
+}
+
+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 = myrand()%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);
+		LED_PORT ^= LED_RED;
+	}
+
+}
+
+
+
+
+// Light all leds layer by layer,
+// then unset layer by layer
+void effect_loadbar(int delay)
+{
+	fill(0x00);
+
+	int z,y;
+
+	for (z=0;z<8;z++)
+	{
+		for (y=0;y<8;y++)
+			cube[z][y] = 0xff;
+
+		delay_ms(delay);
+	}
+
+	delay_ms(delay*3);
+
+	for (z=0;z<8;z++)
+	{
+		for (y=0;y<8;y++)
+			cube[z][y] = 0x00;
+
+		delay_ms(delay);
+	}
+}
+
+
+// Set n number of voxels at random positions
+void effect_random_sparkle_flash (int iterations, int voxels, int delay)
+{
+	int i;
+	int v;
+	for (i = 0; i < iterations; i++)
+	{
+		for (v=0;v<=voxels;v++)
+			setvoxel(myrand()%8,myrand()%8,myrand()%8);
+
+		delay_ms(delay);
+		fill(0x00);
+	}
+}
+
+// blink 1 random voxel, blink 2 random voxels..... blink 20 random voxels
+// and back to 1 again.
+void effect_random_sparkle (void)
+{
+	int i;
+
+	for (i=1;i<20;i++)
+	{
+		effect_random_sparkle_flash(5,i,200);
+	}
+
+	for (i=20;i>=1;i--)
+	{
+		effect_random_sparkle_flash(5,i,200);
+	}
+
+}
+
+int effect_telcstairs_do(int x, int val, int delay)
+{
+	int y,z;
+
+	for(y = 0, z = x; y <= z; y++, x--)
+	{
+		if(x < CUBE_SIZE && y < CUBE_SIZE)
+		{
+			cube[x][y] = val;
+		}
+	}
+	delay_ms(delay);
+	return z;
+}
+
+void effect_telcstairs (int invert, int delay, int val)
+{
+	int x;
+
+	if(invert)
+	{
+		for(x = CUBE_SIZE*2; x >= 0; x--)
+		{
+			x = effect_telcstairs_do(x,val,delay);
+		}
+	}
+	else
+	{
+		for(x = 0; x < CUBE_SIZE*2; x++)
+		{
+			x = effect_telcstairs_do(x,val,delay);
+		}
+	}
+}
+
+void effect_wormsqueeze (int size, int axis, int direction, int iterations, int delay)
+{
+	int x, y, i,j,k, dx, dy;
+	int cube_size;
+	int origin = 0;
+
+	if (direction == -1)
+		origin = 7;
+
+	cube_size = 8-(size-1);
+
+	x = myrand()%cube_size;
+	y = myrand()%cube_size;
+
+	for (i=0; i<iterations; i++)
+	{
+		dx = ((myrand()%3)-1);
+		dy = ((myrand()%3)-1);
+
+		if ((x+dx) > 0 && (x+dx) < cube_size)
+			x += dx;
+
+		if ((y+dy) > 0 && (y+dy) < cube_size)
+			y += dy;
+
+		shift(axis, direction);
+
+
+		for (j=0; j<size;j++)
+		{
+			for (k=0; k<size;k++)
+			{
+				if (axis == AXIS_Z)
+					setvoxel(x+j,y+k,origin);
+
+				if (axis == AXIS_Y)
+					setvoxel(x+j,origin,y+k);
+
+				if (axis == AXIS_X)
+					setvoxel(origin,y+j,x+k);
+			}
+		}
+
+		delay_ms(delay);
+	}
+}
+
+void effect_pathmove (unsigned char *path, int length)
+{
+	int i,z;
+	unsigned char state;
+
+	for (i=(length-1);i>=1;i--)
+	{
+		for (z=0;z<8;z++)
+		{
+
+			state = getvoxel(((path[(i-1)]>>4) & 0x0f), (path[(i-1)] & 0x0f), z);
+			altervoxel(((path[i]>>4) & 0x0f), (path[i] & 0x0f), z, state);
+		}
+	}
+	for (i=0;i<8;i++)
+		clrvoxel(((path[0]>>4) & 0x0f), (path[0] & 0x0f),i);
+}
+
+
diff --git a/avr-test/src/effect.h b/avr-test/src/effect.h
new file mode 100644
index 0000000..3398082
--- /dev/null
+++ b/avr-test/src/effect.h
@@ -0,0 +1,54 @@
+#ifndef EFFECT_H
+#define EFFECT_H
+
+#include <avr/io.h>
+#include <avr/pgmspace.h>
+#include <stdlib.h>
+
+#include "cube.h"
+
+void effect_box_shrink_grow (int iterations, int rot, int flip, uint16_t delay);
+
+void effect_hollow_1 (int iterations, uint16_t delay);
+void effect_hollow_2 (int iterations, int corner, uint16_t delay);
+
+void sendvoxel_z (unsigned char x, unsigned char y, unsigned char z, int delay);
+void sendplane_rand_z (unsigned char z, int delay, int wait);
+void sendvoxels_rand_z (int iterations, int delay, int wait);
+void boingboing(uint16_t iterations, int delay, unsigned char mode, unsigned char drawmode);
+
+void effect_planboing (int plane, int speed);
+
+void effect_random_filler (int delay, int state);
+
+void effect_z_updown (int iterations, int delay);
+void effect_rain(int iterations);
+void effect_stringfly2(char * str);
+void effect_blinky2(void);
+void draw_positions_axis (char axis, unsigned char positions[64], int invert);
+void effect_axis_updown_randsuspend (char axis, int delay, int sleep, int invert);
+
+void effect_random_sparkle_flash (int iterations, int voxels, int delay);
+void effect_random_sparkle (void);
+
+void effect_box_woopwoop (int delay, int grow);
+void effect_telcstairs (int invert, int delay, int val);
+void effect_loadbar(int delay);
+
+void effect_boxside_randsend_parallel (char axis, int origin, int delay, int mode);
+void effect_smileyspin (int count, int delay, char bitmap);
+void effect_pathmove (unsigned char *path, int length);
+void effect_rand_patharound (int iterations, int delay);
+void effect_pathspiral (int iterations, int delay);
+void effect_path_text (int delay, char *str);
+void effect_path_bitmap (int delay, char bitmap, int iterations);
+void effect_wormsqueeze (int size, int axis, int direction, int iterations, int delay);
+
+void effect_z_updown (int iterations, int delay);
+void effect_z_updown_move (unsigned char positions[64], unsigned char destinations[64], char axis);
+
+
+
+
+#endif
+
diff --git a/avr-test/src/fuses.txt b/avr-test/src/fuses.txt
new file mode 100644
index 0000000..f24e5f5
--- /dev/null
+++ b/avr-test/src/fuses.txt
@@ -0,0 +1,6 @@
+
+lfuse: 0b11101111
+hfuse: 0b11001001
+
+
+
diff --git a/avr-test/src/lisence.txt b/avr-test/src/lisence.txt
new file mode 100644
index 0000000..812dab5
--- /dev/null
+++ b/avr-test/src/lisence.txt
@@ -0,0 +1,5 @@
+Created by Christian Moen (christian@lynet.no) and Ståle Kristoffersen (staalekb@ifi.uio.no) 2011.
+
+Lisence:  http://creativecommons.org/licenses/by-nc-sa/3.0/
+
+Happy hacking!! :D
diff --git a/avr-test/src/main.c.old b/avr-test/src/main.c.old
new file mode 100644
index 0000000..be31861
--- /dev/null
+++ b/avr-test/src/main.c.old
@@ -0,0 +1,285 @@
+/*
+ * Code to controll an 8x8x8 ledcube using avr
+ * http://www.instructables.com/id/Led-Cube-8x8x8/
+ * See lisence.txt for lisence.
+ */
+#include "main.h"
+#include "effect.h"
+#include "launch_effect.h"
+#include "draw.h"
+
+// Main loop
+// the AVR enters this function at boot time
+int main (void)
+{
+
+	// This function initiates IO ports, timers, interrupts and
+    // serial communications
+	ioinit();
+	
+    // This variable specifies which layer is currently being drawn by the
+	// cube interrupt routine. We assign a value to it to make sure it's not >7.
+	current_layer = 1;	
+
+	int i;
+	
+	// Boot wait
+	// This function serves 3 purposes
+	// 1) We delay starting up any interrupts, as drawing the cube causes a lot
+	//    noise that can confuse the ISP programmer.
+	// 2) Listen for button press. One button means go into rs232 mode,
+	//    The other means go into autonomous mode and start doing stuff.
+	// 3) Random seed. The bootwait function counts forever from 0 to 255.
+	//    Whenever you press the button, this counter stops, and the number it
+	//    stopped at is used as a random seed. This ensures true randomness at
+	//    every boot. Without this (or some similar process) the cube would
+	//    produce the same "random" sequence every time
+	i = bootwait();
+
+	// Enable interrupts
+	// This starts the routine that draws the cube content
+	sei();
+
+	// Result for bootwait() is 2:
+	// Go to rs232 mode. this function loops forever.
+	if (i == 2)
+	{
+		rs232();
+	}
+
+	// Result of bootwait() is something other than 2:
+	// Do awesome effects. Loop forever.
+	while (1)
+	{
+		// Show the effects in a predefined order
+		for (i=0; i<EFFECTS_TOTAL; i++)
+			launch_effect(i);
+		
+		// Show the effects in a random order.
+		// Comment the two lines above and uncomment this
+		// if you want the effects in a random order.
+		//launch_effect(rand()%EFFECTS_TOTAL);
+	}
+
+}
+
+/*
+ * Multiplexer/framebuffer routine
+ * This function is called by an interrupt generated by timer 2.
+ * Every time it runs, it does the following:
+ * 1) Disable the output for the multiplexer array.
+ * 2) Turn of all layers.
+ * 3) Load the current layer from the cube buffer onto the
+ *    multiplexer array.
+ * 4) Enable output from the multiplexer array.
+ * 5) Turn on the current layer.
+ * 6) Increment the current_layer variable, so the next layer is
+ *    drawn the next time this function runs.
+*/
+
+ISR(TIMER2_COMP_vect)
+{
+	int i;
+
+	LAYER_SELECT = 0x00; // Turn all cathode layers off. (all transistors off)
+	OE_PORT |= OE_MASK; // Set OE high, disabling all outputs on latch array
+
+	// Loop through all 8 bytes of data in the current layer
+	// and latch it onto the cube.
+	for (i = 0; i < 8; i++)
+	{
+		// Set the data on the data-bus of the latch array.
+		PORTA = cube[current_layer][i];
+		// Increment the latch address chip, 74HC138, to create
+		// a rising edge (LOW to HIGH) on the current latch.
+		LATCH_ADDR = (LATCH_ADDR & LATCH_MASK_INV) | (LATCH_MASK & (i+1));
+	}
+
+	OE_PORT &= ~OE_MASK; // Set OE low, enabling outputs on the latch array
+	LAYER_SELECT = (0x01 << current_layer); // Transistor ON for current layer
+
+	// Increment the curren_layer counter so that the next layer is
+	// drawn the next time this function runs.
+	current_layer++;
+	// We want to count from 0-7, so set it to 0 when it reaches 8.
+	if (current_layer == 8)
+		current_layer = 0;
+}
+
+
+void ioinit (void)
+{
+	DDRA = 0xff;	// DATA bus output
+	DDRB = 0xef;	// Button on B4
+	DDRC = 0xff;	// Layer select output
+	DDRD = 0xdf;	// Button on D5
+	
+	
+	PORTA = 0x00; // Set data bus off
+	PORTC = 0x00; // Set layer select off
+	PORTB = 0x10; // Enable pull up on button.
+	PORTD = 0x20; // Enable pull up on button.
+
+
+	// Timer 2
+	// Frame buffer interrupt
+	// 14745600/128/11 = 10472.72 interrupts per second
+	// 10472.72/8 = 1309 frames per second
+	OCR2 = 10; 	// interrupt at counter = 10
+    TCCR2 |= (1 << CS20) | (1 << CS22); // Prescaler = 128.
+	TCCR2 |= (1 << WGM21); // CTC mode. Reset counter when OCR2 is reached.
+	TCNT2 = 0x00;	// initial counter value = 0;
+	TIMSK |= (1 << OCIE2); // Enable CTC interrupt
+
+
+
+    // Initiate RS232
+    // USART Baud rate is defined in MYUBRR
+    UBRRH = MYUBRR >> 8;
+    UBRRL = MYUBRR;
+    // UCSRC - USART control register
+    // bit 7-6      sync/ascyn 00 = async,  01 = sync
+    // bit 5-4      parity 00 = disabled
+    // bit 3        stop bits 0 = 1 bit  1 = 2 bits
+    // bit 2-1      frame length 11 = 8
+    // bit 0        clock polarity = 0
+    UCSRC  = 0b10000110;
+    // Enable RS232, tx and rx
+    UCSRB = (1<<RXEN)|(1<<TXEN);
+    UDR = 0x00; // send an empty byte to indicate powerup.
+
+
+}
+
+// Boot wait function
+// This function does 3 things:
+// 1) Delay startup of interrupt. I've had some problems with in circuit
+//    serial programming when the cube was running. I guess switching all
+//    those LEDs on and off generates some noise.
+// 2) Set a random random seed based on the delay between boot time and
+//    the time you press a button.
+// 3) Select mode of operation, autonomous or rs232 controlled.
+unsigned int bootwait (void)
+{
+	// All the LED_PORT... code blinks the red and green status LEDs.
+
+	unsigned int x = 0;
+	LED_PORT |= LED_GREEN;
+	while (1)
+	{
+        x++; // increment x by one.
+		srand(x); // use counter x as random seed
+		
+		delay_ms(1000);
+		LED_PORT &= ~LED_GREEN; // green off, red on
+		LED_PORT |= LED_RED;
+		
+		// Listen for button presses and return with the
+		// apropriate number.
+		if (!(PIND & RS232_BTN))
+			return 2;
+
+		if (!(PINB & MAIN_BTN))
+			return 1;
+		
+		delay_ms(1000);
+		LED_PORT &= ~LED_RED; // red off, green on
+		LED_PORT |= LED_GREEN;
+		
+		// Same as above. I do it twise because there are two delays
+		// in this loop, used for the red and green led blinking..
+		if (!(PIND & RS232_BTN))
+			return 2;
+
+		if (!(PINB & MAIN_BTN))
+			return 1;
+	}
+}
+
+// Take input from a computer and load it onto the cube buffer
+void rs232(void)
+{
+	int tempval;
+	int x = 0;
+	int y = 0;
+    int escape = 0;
+	
+	while (1)
+	{
+		// Switch state on red LED for debugging
+		// Should switch state every time the code
+		// is waiting for a byte to be received.
+		LED_PORT ^= LED_RED;
+
+		// Wait until a byte has been received
+		while ( !(UCSRA & (1<<RXC)) );
+
+		// Load the received byte from rs232 into a buffer.
+		tempval = UDR;
+
+		// Uncommet this to echo data back to the computer
+		// for debugging purposes.
+		//UDR = tempval;
+
+		// Every time the cube receives a 0xff byte,
+		// it goes into sync escape mode.
+		// if a 0x00 byte is then received, the x and y counters
+		// are reset to 0. This way the x and y counters are
+		// always the same on the computer and in the cube.
+		// To send an 0xff byte, you have to send it twice!
+
+		// Go into sync escape mode
+		if (tempval == 0xff)
+		{
+			// Wait for the next byte
+			 while ( !(UCSRA & (1<<RXC)) );
+			 // Get the next byte
+			 tempval = UDR;
+
+			 // Sync signal is received.
+			 // Reset x and y counters to 0.
+			 if (tempval == 0x00)
+			 {
+				x = 0;
+				y = 0;
+                escape = 1;
+			 }
+			 // if no 0x00 byte is received, proceed with
+			 // the byte we just received.
+		}
+
+        if (escape == 0)
+        {
+		// Load data into the current position in the buffer
+		fb[x][y] = tempval;
+
+    		// Check if we have reached the limits of the buffer array.
+    		if (y == 7)
+    		{
+    			if (x == 7)
+    			{
+    				// All data is loaded. Reset both counters
+    				y = 0;
+    				x = 0;
+                    // Copy the data onto the cube.
+    				tmp2cube();
+    			} else
+    			{
+    				// A layer is loaded, reset y and increment x.
+    				x++;
+    				y = 0;
+    			}
+    		} else
+    		{
+    			// We are in the middle of loading a layer. increment y.
+    			y++;
+    		}
+	
+	    } else
+        {
+            escape = 0;
+        }
+    }
+}
+
+
diff --git a/avr-test/src/main.cpp b/avr-test/src/main.cpp
new file mode 100644
index 0000000..6f3d6ba
--- /dev/null
+++ b/avr-test/src/main.cpp
@@ -0,0 +1,508 @@
+/* (c) copyright N.C. 2011 */
+
+// ATMEL ATMEGA8
+//
+//                        +-\/-+
+//          (RESET) PC6  1|    |28  PC5 (ADC5/SCL)
+//            (RXD) PD0  2|    |27  PC4 (ADC4/SDA)
+//            (TXD) PD1  3|    |26  PC3 (ADC3)
+//           (INT0) PD2  4|    |25  PC2 (ADC2)
+//           (INT1) PD3  5|    |24  PC1 (ADC1)
+//         (XCK/T0) PD4  6|    |23  PC0 (ADC0)
+//                  VCC  7|    |22  GND
+//                  GND  8|    |21  AREF
+//    (XTAL1/TOSC1) PB6  9|    |20  AVCC
+//    (XTAL2/TOSC2) PB7 10|    |19  PB5 (SCK)
+//             (T1) PD5 11|    |18  PB4 (MISO)
+//           (AIN0) PD6 12|    |17  PB3 (MOSI/OC2)
+//           (AIN1) PD7 13|    |16  PB2 (SS/OC1B)
+//           (ICP1) PB0 14|    |15  PB1 (OC1A)
+//                        +----+
+
+extern "C" {
+#include <avr/io.h>
+#include <avr/interrupt.h>
+
+#include <stdlib.h> // rand
+}
+
+//char myrand()
+//{
+//    static short rand = 0;
+//    rand=(rand*109+89)%251;
+//    return rand;
+//}
+
+int myrand() { return rand(); }
+
+#define CUBE_SIZE 8
+
+//#define AXIS_X 1
+//#define AXIS_Y 2
+//#define AXIS_Z 3
+
+volatile unsigned char cube[8][8];
+//volatile unsigned char current_layer = 0;
+extern volatile unsigned char current_layer;
+volatile bool in_wait = false;
+
+volatile unsigned char fb[CUBE_SIZE][CUBE_SIZE];
+/*****************************************************************************
+ * TIME MANAGEMENT
+ *****************************************************************************/
+
+#define F_CPU 8000000UL
+
+#define clockCyclesPerMicrosecond() ( F_CPU / 1000000L )
+#define clockCyclesToMicroseconds(a) ( (a) / clockCyclesPerMicrosecond() )
+#define microsecondsToClockCycles(a) ( (a) * clockCyclesPerMicrosecond() )
+
+// the prescaler is set so that timer0 ticks every 64 clock cycles, and the
+// the overflow handler is called every 256 ticks.
+#define MICROSECONDS_PER_TIMER0_OVERFLOW (clockCyclesToMicroseconds(64 * 256))
+
+// the whole number of milliseconds per timer0 overflow
+#define MILLIS_INC (MICROSECONDS_PER_TIMER0_OVERFLOW / 1000)
+
+// the fractional number of milliseconds per timer0 overflow. we shift right
+// by three to fit these numbers into a byte. (for the clock speeds we care
+// about - 8 and 16 MHz - this doesn't lose precision.)
+#define FRACT_INC ((MICROSECONDS_PER_TIMER0_OVERFLOW % 1000) >> 3)
+#define FRACT_MAX (1000 >> 3)
+
+//volatile uint32_t timer0_overflow_count = 0;
+volatile uint32_t timer0_millis = 0;
+//static uint8_t timer0_fract = 0;
+
+
+ISR(TIMER0_OVF_vect)
+{
+        // copy these to local variables so they can be stored in registers
+        // (volatile variables must be read from memory on every access)
+        uint32_t m = timer0_millis;
+        //uint8_t f = timer0_fract;
+        static uint8_t timer0_fract = 0;
+
+        m += MILLIS_INC;
+        //f += FRACT_INC;
+        timer0_fract += FRACT_INC;
+        //if (f >= FRACT_MAX) {
+        if (timer0_fract >= FRACT_MAX) {
+                //f -= FRACT_MAX;
+                timer0_fract -= FRACT_MAX;
+                ++m;
+        }
+
+        //timer0_fract = f;
+        timer0_millis = m;
+        //timer0_overflow_count++;
+
+//static uint32_t last_time = 0;
+        //if (timer0_overflow_count & 0x1)
+        //if (m - last_time >= 5) {
+        //debounce_keys(); // called nearly each 2ms (0,002048s)
+            //last_time = m;
+        //}
+}
+
+/*
+inline uint32_t millis()
+{
+        uint32_t m;
+        uint8_t oldSREG = SREG;
+
+        // disable interrupts while we read timer0_millis or we might get an
+        // inconsistent value (e.g. in the middle of a write to timer0_millis)
+        cli();
+        m = timer0_millis;
+        SREG = oldSREG;
+
+        return m;
+}
+*/
+
+inline uint32_t millis()
+{
+    return timer0_millis;
+}
+
+void delay(uint32_t ms)
+{
+    in_wait = true;
+    uint32_t time1 = millis();
+    while ((millis()) - time1 < ms);
+    in_wait = false;
+}
+//void delay_ms(uint16_t x)
+//{
+//    in_wait = true;
+//  uint8_t y, z;
+//  for ( ; x > 0 ; x--){
+//    for ( y = 0 ; y < 90 ; y++){
+//      for ( z = 0 ; z < 6 ; z++){
+//        asm volatile ("nop");
+//      }
+//    }
+//  }
+//    in_wait = false;
+//}
+
+
+/*****************************************************************************
+ * ACCESSORS
+ *****************************************************************************/
+
+//unsigned char inrange(int x, int y, int z)
+//{
+//    if (x >= 0 && x < CUBE_SIZE && y >= 0 && y < CUBE_SIZE && z >= 0 && z < CUBE_SIZE)
+//    {
+//        return 1;
+//    } else
+//    {
+//        // One of the coordinates was outside the cube.
+//        return 0;
+//    }
+//}
+
+//bool get_led(unsigned char x, unsigned char y, unsigned char z)
+//{
+//    /*
+//    assert(x >= 0 && x <= 7);
+//    assert(y >= 0 && y <= 7);
+//    assert(z >= 0 && z <= 7);
+//    */
+//
+//    if (inrange(x, y, z)) {
+//        return cube[y][z] & (1 << x);
+//    }
+//
+//    return false;
+//}
+
+//void set_led(unsigned char x, unsigned char y, unsigned char z, bool on)
+//{
+//
+//    if (!inrange(x, y, z)) {
+//        return;
+//    }
+//
+//    /*
+//    assert(x >= 0 && x <= 7);
+//    assert(y >= 0 && y <= 7);
+//    assert(z >= 0 && z <= 7);
+//    */
+//
+//    if (on) {
+//        cube[y][z] |= ((unsigned char)1) << x;
+//    }
+//    else {
+//        cube[y][z] &= ~(((unsigned char)1) << x);
+//    }
+//}
+
+void clear_led()
+{
+    for (unsigned char z = 0; z < 8; ++z) {
+        for (unsigned char y = 0; y < 8; ++y) {
+            cube[y][z] = 0;
+        }
+    }
+}
+
+/*****************************************************************************
+ * RENDER
+ *****************************************************************************/
+
+//ISR(TIMER2_COMP_vect)
+//{
+//    //if (!in_wait) return;
+//    PORTC &= ~0x28; // layer and latch low
+//    unsigned char current_layer_ = current_layer;
+//
+//    for (char j = 0; j < 8; ++j) {
+//    //for (char j = 0; j < 4; ++j) {
+//        unsigned char val = cube[7-j][current_layer_];
+//        //unsigned char val2 = cube[3-j][current_layer_];
+//        for (char i = 0; i < 8; ++i/*, val >>= 1*/) {
+//            PORTC &= ~0x10;
+//            //PORTD = (PORTD & ~0x80) | ((val2 << (7-i)) & 0x80);
+//            PORTB = (PORTB & ~0x01) | ((val >> i) & 0x01);
+//            //PORTB |= 0x01;
+//
+//            //PORTD |= 0x80;
+//            //PORTD = (PORTD & ~0x40) | (((val << (7-i)) & 0x80) >> 1);
+//            PORTC |= 0x10;
+//        }
+//    }
+//
+//    PORTC = (PORTC & ~0x07) | current_layer_;
+//    ++current_layer_;
+//    current_layer = current_layer_ & 0x07;
+//
+//    PORTC |= 0x28; // layer and latch high
+//}
+
+ISR(TIMER2_COMP_vect)
+{
+    //if (!in_wait) return;
+    PORTC &= ~0x28; // layer and latch low
+    unsigned char current_layer_ = current_layer;
+
+    for (unsigned char j = 7; j < 255; --j) {
+    //for (char j = 0; j < 4; ++j) {
+        unsigned char val = cube[j][current_layer_];
+        PORTC &= ~0x10;
+        PORTB = (PORTB & ~0x01) | ((val     ) & 0x01);
+        PORTC |= 0x10;
+        PORTC &= ~0x10;
+        PORTB = (PORTB & ~0x01) | ((val >> 1) & 0x01);
+        PORTC |= 0x10;
+        PORTC &= ~0x10;
+        PORTB = (PORTB & ~0x01) | ((val >> 2) & 0x01);
+        PORTC |= 0x10;
+        PORTC &= ~0x10;
+        PORTB = (PORTB & ~0x01) | ((val >> 3) & 0x01);
+        PORTC |= 0x10;
+        PORTC &= ~0x10;
+        PORTB = (PORTB & ~0x01) | ((val >> 4) & 0x01);
+        PORTC |= 0x10;
+        PORTC &= ~0x10;
+        PORTB = (PORTB & ~0x01) | ((val >> 5) & 0x01);
+        PORTC |= 0x10;
+        PORTC &= ~0x10;
+        PORTB = (PORTB & ~0x01) | ((val >> 6) & 0x01);
+        PORTC |= 0x10;
+        PORTC &= ~0x10;
+        PORTB = (PORTB & ~0x01) | ((val >> 7) & 0x01);
+        //PORTD = val;
+        PORTC |= 0x10;
+    }
+
+    PORTC = (PORTC & ~0x07) | current_layer_ | 0x28;
+    ++current_layer_;
+    if (current_layer_ > 7) current_layer_ = 0;
+    //current_layer = current_layer_ & 0x07;
+    current_layer = current_layer_;
+
+    //PORTC |= 0x28; // layer and latch high
+}
+
+
+
+//void draw_positions_axis (char axis, unsigned char positions[64], int invert)
+//{
+//	int x, y, p;
+//
+//	//fill(0x00);
+//    clear_led();
+//
+//	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);
+//                set_led(x, y, p, true);
+//
+//			if (axis == AXIS_Y)
+//				//setvoxel(x,p,y);
+//				set_led(x,p,y, true);
+//
+//			if (axis == AXIS_X)
+//				set_led(p,y,x, true);
+//		}
+//	}
+//
+//}
+
+
+
+
+//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 = myrand()%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);
+//
+//	}
+//
+//}
+
+
+
+/*****************************************************************************
+ * MAIN
+ *****************************************************************************/
+#include "main.h"
+#include "effect.h"
+#include "draw.h"
+
+int main()
+{
+    /*
+     * =======================================================================
+     * Initialisation
+     * =======================================================================
+     */
+
+    //*** init time management
+    TCNT0 = 0; // init timer count to 0
+    TCCR0 |= 0x03; // prescaler: 64
+    TIMSK |= 0x01; // enable timer 0 overflow interrupt
+
+    // Timer 2
+    // Frame buffer interrupt
+    // 14745600/128/11 = 10472.72 interrupts per second
+    // 10472.72/8 = 1309 frames per second
+    OCR2 = 11;  // interrupt at counter = 10
+    TCCR2 |= (1 << CS20) | (0 << CS21) | (1 << CS22); // Prescaler = 128.
+    TCCR2 |= (1 << WGM21); // CTC mode. Reset counter when OCR2 is reached.
+    TCNT2 = 0x00;   // initial counter value = 0;
+    TIMSK |= (1 << OCIE2); // Enable CTC interrupt
+
+    PORTD = 0;
+    PORTB = 0;
+    PORTC = 0;
+    DDRD = 0xff;
+    DDRB = 0xff;
+    DDRC = 0xff;
+
+    //*** set interupts
+    sei();
+
+    /*
+     * =======================================================================
+     * MAIN LOOP
+     * =======================================================================
+     */
+
+    for (;;) {
+
+        //clear_led();
+        //delay_ms(1000);
+        for (unsigned char z = 0; z < 8; ++z) {
+            for (unsigned char y = 0; y < 8; ++y) {
+                cube[y][z] = 0xFF;
+            }
+        }
+        //continue;
+        delay(1000);
+
+		// Show the effects in a predefined order
+		//for (char i=0; i<EFFECTS_TOTAL; i++)
+			//launch_effect(i);
+			sendvoxels_rand_z(20,220,2000);
+			effect_rain(100);
+			effect_random_filler(5,1);
+			effect_z_updown(20,1000);
+			effect_wormsqueeze (2, AXIS_Z, -1, 100, 1000);
+			effect_blinky2();
+
+
+		// Show the effects in a random order.
+		// Comment the two lines above and uncomment this
+		// if you want the effects in a random order.
+		//launch_effect(rand()%EFFECTS_TOTAL);
+
+        for (char i = 0; i < 10; ++i) {
+            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);
+        }
+
+        continue;
+
+        //return;
+        for (char z = 0; z < 8; ++z) {
+            for (char y = 0; y < 8; ++y) {
+                for (char x = 0; x < 8; ++x) {
+                    //set_led(x, y, z, true);
+                    delay(5);
+                    delay(100);
+                    //delay(500);
+                    //delay(1000);
+                    //delay_ms(1000);
+                }
+            }
+        }
+
+        //delay(1000);
+        //PORTB ^= 0x01;
+    }
+
+    return 0; // normally never return, just to be complient with c99 standard
+}
diff --git a/avr-test/src/main.h b/avr-test/src/main.h
new file mode 100644
index 0000000..0a755f7
--- /dev/null
+++ b/avr-test/src/main.h
@@ -0,0 +1,45 @@
+#ifndef MAIN_H
+#define MAIN_H
+
+#include <avr/io.h>
+#include <avr/pgmspace.h>
+#include <avr/interrupt.h>
+#include <stdlib.h>
+
+#include "cube.h"
+
+// Define USART stuff
+#define FOSC 14745600
+#define BAUD 38400
+#define MYUBRR (((((FOSC * 10) / (16L * BAUD)) + 5) / 10) - 1)
+
+#define DATA_BUS PORTA
+#define LAYER_SELECT PORTC
+#define LATCH_ADDR PORTB
+#define LATCH_MASK 0x07
+#define LATCH_MASK_INV 0xf8
+#define OE_PORT PORTB
+#define OE_MASK 0x08
+
+// Red led on D2
+#define LED_RED 0x04
+// Green led D3
+#define LED_GREEN 0x08
+// Program led on D4
+#define LED_PGM 0x10;
+// Leds connected to port D
+#define LED_PORT PORTD
+// Rs232 button on D5
+#define RS232_BTN 0x20
+// Main button on B4
+#define MAIN_BTN 0x10 
+
+void ioinit (void);
+void bootmsg (void);
+
+volatile unsigned char current_layer;
+volatile unsigned char pgm_mode;
+void rs232(void);
+unsigned int bootwait (void);
+#endif
+