Zum Einsatz kommt hier ein ADXL330. Der ADXL330 ist ein 3-Achsenbeschleunigungssensor bis maximal 3g.

Die Ausgabe erfolgt mit einer variablen Spannung in abhängigkeit zur Beschleunigung.
Anbei ein Video wo ein ADXL330 mit einem Arduino ausgelesen/verabeitet wird und die Daten zu einem mit Proccessing erstellten 3D-Modell gesendet und dargestellt wird:

Datenblatt: http://www.analog.com/static/imported-files/data_sheets/ADXL330.pdf

Arduino Sketch:

#include <LiquidCrystal.h>

int adxlX=2;
int adxlY=1;
int adxlZ=0;

int KalibTast=2;
volatile int Prellen     = 250;
volatile unsigned long letzter_irq=millis();

int adxlXK=0;
int adxlYK=0;
int adxlZK=0;
int adxlRauschen=2;
int Kalibrieren=0;

//LiquidCrystal lcd(12, 11, 5, 4, 3, 2);
LiquidCrystal lcd(12, 11, 7, 6, 5, 4);

void setup(void)
{
     pinMode(KalibTast,INPUT);
     attachInterrupt(0,Kalib,FALLING);
     Serial.begin(9600);

     lcd.begin(16,2);
     Kalibrieren=1;
     Kalib();
     delay(1000);
}

void loop ()
{
     int i=0;

     int x=0;
     int y=0;
     int z=0;

     int x1=0;
     int y1=0;
     int z1=0;

     x=analogRead(adxlX)-adxlXK;
     y=analogRead(adxlY)-adxlYK;
     z=analogRead(adxlZ)-adxlZK;

     if(x <= -adxlRauschen or x >= adxlRauschen)
               x1=x;

     if(y <= -adxlRauschen or y >= adxlRauschen)
               y1=y;

     if(z <= -adxlRauschen or z >= adxlRauschen)
               z1=z;

     lcd.clear();
     lcd.setCursor(0,0);
     lcd.print("X=");
     lcd.print(x1);
     lcd.print("     Y=");
     lcd.print(y1);
     lcd.setCursor(0,1);
     lcd.print("Z=");
     lcd.print(z1);

     Serial.print(x1,DEC);
     Serial.print(" ");
     Serial.print(y1,DEC);
     Serial.print(" ");
     Serial.print(z1,DEC);
     Serial.println();

     delay(50);
}

void Kalib (void)
{
     unsigned long akt_irq;
     akt_irq=millis();
     if(akt_irq - letzter_irq > Prellen or Kalibrieren == 1)
     {
               lcd.clear();
               lcd.setCursor(0,0);
               lcd.print("Kalibriere...");

               adxlXK=analogRead(adxlX);
               adxlYK=analogRead(adxlY);
               adxlZK=analogRead(adxlZ);

               letzter_irq=akt_irq;
               if(Kalibrieren == 1) { Kalibrieren=0; }
     }
}

Proccessing Sketch:

import processing.serial.*;

Serial port;
String message = null;
String elements[] = null;
int[] sensorValues = new int[3];

float boxSize = 50;
float margin = boxSize*2;
float depth = 400;
color boxFill;

void setup()
{
     size(800,400,P3D);
     noStroke();
     println(Serial.list());
     port = new Serial(this, Serial.list()[6], 9600);
     frameRate(25);
}

void draw() {
     background(255);

     translate(width/2, height/2, -depth);
     rotateZ(radians(360-(sensorValues[0]*1.5)));
     rotateX(radians(360-((sensorValues[1]*1.5)-90)));

     for (float i =- depth/2+margin; i <= depth/2-margin; i += boxSize){
               pushMatrix();
               for (float j =- height+margin; j <= height-margin; j += boxSize){
                         pushMatrix();
                         for (float k =- width+margin; k <= width-margin; k += boxSize){
                                   boxFill = color(abs(i), abs(j), abs(k), 50);
                                   pushMatrix();
                                   translate(k/1.5, j/1.5, i/1.5);
                                   fill(boxFill);
                                   box(boxSize, boxSize, boxSize);
                                   popMatrix();
                         }
                         popMatrix();
               }
               popMatrix();
     }
}

void serialEvent(Serial p){
     message = port.readStringUntil(13);
     if (message != null) {
               try {
                         elements = splitTokens(message);
                         for (int i =0; i < elements.length && i < 3; i++ ) {
                                   sensorValues[i] = int(elements[i]);
                         }
               }
               catch (Exception e){
               }
     }

}