Arduino code for MAX6675

.from: https://github.com/codebendercc/arduino-files/blob/master/extra-libraries/max6675/max6675.cpp

X================================X max6675.h X================================X

// this library is public domain. enjoy!
// www.ladyada.net/learn/sensors/thermocouple

#if ARDUINO >= 100
 #include "Arduino.h"
#else
 #include "WProgram.h"
#endif

class MAX6675 {
 public:
  MAX6675(int8_t SCLK, int8_t CS, int8_t MISO);

  double readCelsius(void);
  double readFahrenheit(void);
  // For compatibility with older versions:
  double readFarenheit(void) { return readFahrenheit(); }
 private:
  int8_t sclk, miso, cs;
  uint8_t spiread(void);
};

X================================X max6675.cpp X================================X

// this library is public domain. enjoy!
// www.ladyada.net/learn/sensors/thermocouple

#include <avr pgmspace.h="pgmspace.h">
#include <util delay.h="delay.h">
#include <stdlib .h=".h">
#include "max6675.h"

MAX6675::MAX6675(int8_t SCLK, int8_t CS, int8_t MISO) {
  sclk = SCLK;
  cs = CS;
  miso = MISO;

  //define pin modes
  pinMode(cs, OUTPUT);
  pinMode(sclk, OUTPUT);
  pinMode(miso, INPUT);

  digitalWrite(cs, HIGH);
}
double MAX6675::readCelsius(void) {

  uint16_t v;

  digitalWrite(cs, LOW);
  _delay_ms(1);

  v = spiread();
  v &lt;&lt;= 8;
  v |= spiread();

  digitalWrite(cs, HIGH);

  if (v &amp; 0x4) {
    // uh oh, no thermocouple attached!
    return NAN;
    //return -100;
  }

  v &gt;&gt;= 3;

  return v*0.25;
}

double MAX6675::readFahrenheit(void) {
  return readCelsius() * 9.0/5.0 + 32;
}

byte MAX6675::spiread(void) {
  int i;
  byte d = 0;

  for (i=7; i&gt;=0; i--)
  {
    digitalWrite(sclk, LOW);
    _delay_ms(1);
    if (digitalRead(miso)) {
      //set the bit to 0 no matter what
      d |= (1 &lt;&lt; i);
    }

    digitalWrite(sclk, HIGH);
    _delay_ms(1);
  }

  return d;
}

X================================X X================================X


</stdlib></util></avr>

Exemple code I2C bmp085 pressure sensor

.from: https://github.com/codebendercc/arduino-files/blob/master/extra-libraries/ArduSat-I2Csensors/bmp085.cpp

X=========================X bmp085.h X=========================X

/*

bmp085.h

libary for using the I2C bmp085 pressure sensor

(c) Written by Jeroen Cappaert for NanoSatisfi, August 2012

*/

#ifndef bmp085_h

#define bmp085_h

#include <Arduino.h>

#define BAR_ADDR 0x77 // Barometric pressure sensor I2C address

class bmp085

{

 public:

   //constructor

    bmp085();

    //functions

    void configBaro();

    int bmp085ReadInt(int device, byte address);

    unsigned int baroReadUT();

    unsigned long baroReadUP();

    float getTempFromBaro(unsigned int ut);

    long getPressFromBaro(unsigned long up);

    void getBmpData(float bmp[]);

    //variables

    int ac1;

    int ac2;

    int ac3;

    unsigned int ac4;

    unsigned int ac5;

    unsigned int ac6;

    int b1;

    int b2;

    int mb;

    int mc;

    int md;

    int barOSS;

    long b5;

  private:

};

#endif

X=========================X bmp085.cpp X=========================X

/*

bmp085.cpp

libary for using the I2C bmp085 pressure sensor

(c) Written by Jeroen Cappaert for NanoSatisfi, August 2012

*/

#include <Arduino.h>

#include "bmp085.h"

#include <Wire.h>

//Constructor

bmp085::bmp085()

{

  barOSS = 2;

}

//configure barometer

void bmp085::configBaro()

{

  ac1 = bmp085ReadInt(BAR_ADDR, 0xAA);

  ac2 = bmp085ReadInt(BAR_ADDR, 0xAC);

  ac3 = bmp085ReadInt(BAR_ADDR, 0xAE);

  ac4 = bmp085ReadInt(BAR_ADDR, 0xB0);

  ac5 = bmp085ReadInt(BAR_ADDR, 0xB2);

  ac6 = bmp085ReadInt(BAR_ADDR, 0xB4);

  b1 = bmp085ReadInt(BAR_ADDR, 0xB6);

  b2 = bmp085ReadInt(BAR_ADDR, 0xB8);

  mb = bmp085ReadInt(BAR_ADDR, 0xBA);

  mc = bmp085ReadInt(BAR_ADDR, 0xBC);

  md = bmp085ReadInt(BAR_ADDR, 0xBE);

}

// user function: get pressure and temperature from sensor with one command

void bmp085::getBmpData(float bmp[])

{

 bmp[0] = getTempFromBaro(baroReadUT());

 bmp[1] = getPressFromBaro(baroReadUP());

}

// calculate temperature given ut

float bmp085::getTempFromBaro(unsigned int ut)

{

  long x1, x2;

  

  x1 = (((long)ut - (long)ac6)*(long)ac5) >> 15;

  x2 = ((long)mc << 11)/(x1 + md);

  b5 = x1 + x2;

  return (float) ((b5 + 8)>>4)/10.;

}

// Calculate pressure given up

// calibration values must be known

// b5 is also required so bmp085GetTemperature(...) must be called first.

// Value returned will be pressure in units of Pa.

long bmp085::getPressFromBaro(unsigned long up)

{

  long x1, x2, x3, b3, b6, p;

  unsigned long b4, b7;

  

  b6 = b5 - 4000;

  // Calculate B3

  x1 = (b2 * (b6 * b6)>>12)>>11;

  x2 = (ac2 * b6)>>11;

  x3 = x1 + x2;

  b3 = (((((long)ac1)*4 + x3)<<barOSS) + 2)>>2;

  

  // Calculate B4

  x1 = (ac3 * b6)>>13;

  x2 = (b1 * ((b6 * b6)>>12))>>16;

  x3 = ((x1 + x2) + 2)>>2;

  b4 = (ac4 * (unsigned long)(x3 + 32768))>>15;

  

  b7 = ((unsigned long)(up - b3) * (50000>>barOSS));

  if (b7 < 0x80000000)

    p = (b7<<1)/b4;

  else

    p = (b7/b4)<<1;

    

  x1 = (p>>8) * (p>>8);

  x1 = (x1 * 3038)>>16;

  x2 = (-7357 * p)>>16;

  p += (x1 + x2 + 3791)>>4;

  

  return p;

}

// read uncorrected temperature value from bmp085

unsigned int bmp085::baroReadUT()

{

  unsigned int ut;

  

  // Write 0x2E into Register 0xF4

  // This requests a temperature reading

  Wire.beginTransmission(BAR_ADDR);

  Wire.write(0xF4);

  Wire.write(0x2E);

  Wire.endTransmission();

  

  // Wait at least 4.5ms

  delay(5);

  

  // Read two bytes from registers 0xF6 and 0xF7

  ut = bmp085ReadInt(BAR_ADDR,0xF6);

  return ut;

}

// read uncorrected pressure value from bmp085

unsigned long bmp085::baroReadUP()

{

  unsigned char msb, lsb, xlsb;

  unsigned long up = 0;

  

  // Write 0x34+(OSS<<6) into register 0xF4

  // Request a pressure reading w/ oversampling setting

  Wire.beginTransmission(BAR_ADDR);

  Wire.write(0xF4);

  Wire.write(0x34 + (barOSS<<6));

  Wire.endTransmission();

  

  // Wait for conversion, delay time dependent on OSS

  delay(2 + (3<<barOSS));

  

  // Read register 0xF6 (MSB), 0xF7 (LSB), and 0xF8 (XLSB)

  Wire.beginTransmission(BAR_ADDR);

  Wire.write(0xF6);

  Wire.endTransmission();

  Wire.requestFrom(BAR_ADDR,3);

  

  // Wait for data to become available

  while(Wire.available() < 3)

    ;

  msb = Wire.read();

  lsb = Wire.read();

  xlsb = Wire.read();

  

  up = (((unsigned long) msb << 16) | ((unsigned long) lsb << 8) | (unsigned long) xlsb) >> (8-barOSS);

  

  return up;

}

// read integer on bmp085

int bmp085::bmp085ReadInt(int device, byte address)

{

  unsigned char msb, lsb;

  

  Wire.beginTransmission(device);

  Wire.write(address);

  Wire.endTransmission();

  

  Wire.requestFrom(device, 2);

  while(Wire.available()<2)

    ;

  msb = Wire.read();

  lsb = Wire.read();

  

  return (int) msb<<8 | lsb;

}

X=========================X X=========================X

Example Code for a TMP102 I2c Thermometer sensor

.from:  https://github.com/codebendercc/arduino-files/blob/master/extra-libraries/ArduSat-I2Csensors/tmp102.cpp

X------------------------X tmp102.h X-------------------------X

/*

mag3110.h

libary for using the I2C tmp102 temperature sensor

(c) Written by Jeroen Cappaert for NanoSatisfi, August 2012

*/

#ifndef tmp102_h

#define tmp102_h

#include <Arduino.h>

#define TEMP_ADDR 0x48 // Temp-sensor data register

class tmp102

{

  public:

    tmp102();

   float getTemperature();

  private:

};

#endif

X------------------------X tmp102.cpp X-------------------------X

/*

tmp102.cpp

libary for using the I2C tmp102 temperature sensor

(c) Written by Jeroen Cappaert for NanoSatisfi, August 2012

*/

#include <Arduino.h>

#include "tmp102.h"

#include <Wire.h>

//Constructor

tmp102::tmp102()

{

  

}

// get temperature value

float tmp102::getTemperature()

{

  Wire.requestFrom(TEMP_ADDR,2);

  byte MSB = Wire.read();

  byte LSB = Wire.read();

  //it's a 12bit int, using two's compliment for negative

  int TemperatureSum = ((MSB << 8) | LSB) >> 4;

  float celsius = TemperatureSum*0.0625;

  return celsius;

}

X-------------------------------------------------X

TextLCD library for controlling various LCD panels based on the HD44780 4-bit interface

TextLCD interface for driving 4-bit HD44780-based LCDs

.from: http://mbed.org/users/simon/libraries/TextLCD/livod0

XXXXXXXXXXXXXXXXXXXXXXXXX TextLCD.cpp XXXXXXXXXXXXXXXXXXXXXXXXXX

 /* mbed TextLCD Library, for a 4-bit LCD based on HD44780
 * Copyright (c) 2007-2010, sford, http://mbed.org
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 */

#include "TextLCD.h"
#include "mbed.h"

TextLCD::TextLCD(PinName rs, PinName e, PinName d4, PinName d5,
                 PinName d6, PinName d7, LCDType type) : _rs(rs),
        _e(e), _d(d4, d5, d6, d7),
        _type(type) {

    _e  = 1;
    _rs = 0;            // command mode

    wait(0.015);        // Wait 15ms to ensure powered up

    // send "Display Settings" 3 times (Only top nibble of 0x30 as we've got 4-bit bus)
    for (int i=0; i<3; i++) {
        writeByte(0x3);
        wait(0.00164);  // this command takes 1.64ms, so wait for it
    }
    writeByte(0x2);     // 4-bit mode
    wait(0.000040f);    // most instructions take 40us

    writeCommand(0x28); // Function set 001 BW N F - -
    writeCommand(0x0C);
    writeCommand(0x6);  // Cursor Direction and Display Shift : 0000 01 CD S (CD 0-left, 1-right S(hift) 0-no, 1-yes
    cls();
}

void TextLCD::character(int column, int row, int c) {
    int a = address(column, row);
    writeCommand(a);
    writeData(c);
}

void TextLCD::cls() {
    writeCommand(0x01); // cls, and set cursor to 0
    wait(0.00164f);     // This command takes 1.64 ms
    locate(0, 0);
}

void TextLCD::locate(int column, int row) {
    _column = column;
    _row = row;
}

int TextLCD::_putc(int value) {
    if (value == '\n') {
        _column = 0;
        _row++;
        if (_row >= rows()) {
            _row = 0;
        }
    } else {
        character(_column, _row, value);
        _column++;
        if (_column >= columns()) {
            _column = 0;
            _row++;
            if (_row >= rows()) {
                _row = 0;
            }
        }
    }
    return value;
}

int TextLCD::_getc() {
    return -1;
}

void TextLCD::writeByte(int value) {
    _d = value >> 4;
    wait(0.000040f); // most instructions take 40us
    _e = 0;
    wait(0.000040f);
    _e = 1;
    _d = value >> 0;
    wait(0.000040f);
    _e = 0;
    wait(0.000040f);  // most instructions take 40us
    _e = 1;
}

void TextLCD::writeCommand(int command) {
    _rs = 0;
    writeByte(command);
}

void TextLCD::writeData(int data) {
    _rs = 1;
    writeByte(data);
}

int TextLCD::address(int column, int row) {
    switch (_type) {
        case LCD20x4:
            switch (row) {
                case 0:
                    return 0x80 + column;
                case 1:
                    return 0xc0 + column;
                case 2:
                    return 0x94 + column;
                case 3:
                    return 0xd4 + column;
            }
        case LCD16x2B:
            return 0x80 + (row * 40) + column;
        case LCD16x2:
        case LCD20x2:
        default:
            return 0x80 + (row * 0x40) + column;
    }
}

int TextLCD::columns() {
    switch (_type) {
        case LCD20x4:
        case LCD20x2:
            return 20;
        case LCD16x2:
        case LCD16x2B:
        default:
            return 16;
    }
}

int TextLCD::rows() {
    switch (_type) {
        case LCD20x4:
            return 4;
        case LCD16x2:
        case LCD16x2B:
        case LCD20x2:
        default:
            return 2;
    }
}

XXXXXXXXXXXXXXXXXXXXXXXXX TextLCD.h XXXXXXXXXXXXXXXXXXXXXXXXXX

/* mbed TextLCD Library, for a 4-bit LCD based on HD44780
 * Copyright (c) 2007-2010, sford, http://mbed.org
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 */

#ifndef MBED_TEXTLCD_H
#define MBED_TEXTLCD_H

#include "mbed.h"

/** A TextLCD interface for driving 4-bit HD44780-based LCDs
 *
 * Currently supports 16x2, 20x2 and 20x4 panels
 *
 * @code
 * #include "mbed.h"
 * #include "TextLCD.h"
 *
 * TextLCD lcd(p10, p12, p15, p16, p29, p30); // rs, e, d4-d7
 *
 * int main() {
 *     lcd.printf("Hello World!\n");
 * }
 * @endcode
 */
class TextLCD : public Stream {
public:

    /** LCD panel format */
    enum LCDType {
        LCD16x2     /**< 16x2 LCD panel (default) */
        , LCD16x2B  /**< 16x2 LCD panel alternate addressing */
        , LCD20x2   /**< 20x2 LCD panel */
        , LCD20x4   /**< 20x4 LCD panel */
    };

    /** Create a TextLCD interface
     *
     * @param rs    Instruction/data control line
     * @param e     Enable line (clock)
     * @param d4-d7 Data lines for using as a 4-bit interface
     * @param type  Sets the panel size/addressing mode (default = LCD16x2)
     */
    TextLCD(PinName rs, PinName e, PinName d4, PinName d5, PinName d6, PinName d7, LCDType type = LCD16x2);

#if DOXYGEN_ONLY
    /** Write a character to the LCD
     *
     * @param c The character to write to the display
     */
    int putc(int c);

    /** Write a formated string to the LCD
     *
     * @param format A printf-style format string, followed by the
     *               variables to use in formating the string.
     */
    int printf(const char* format, ...);
#endif

    /** Locate to a screen column and row
     *
     * @param column  The horizontal position from the left, indexed from 0
     * @param row     The vertical position from the top, indexed from 0
     */
    void locate(int column, int row);

    /** Clear the screen and locate to 0,0 */
    void cls();

    int rows();
    int columns();

protected:

    // Stream implementation functions
    virtual int _putc(int value);
    virtual int _getc();

    int address(int column, int row);
    void character(int column, int row, int c);
    void writeByte(int value);
    void writeCommand(int command);
    void writeData(int data);

    DigitalOut _rs, _e;
    BusOut _d;
    LCDType _type;

    int _column;
    int _row;
};

#endif

XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

How to Use MBED as a mouse to Play AngryBirdz

How to Use MBED as a mouse

.from: http://mbed.org/cookbook/Slingshot

Check this in action!

So now you can kill pigs with a real USB Slingshot, by combining the two totally different worlds of carpentry and embedded systems!

XXXXXXXXXXXXXXXXXXXXXXXX main.cpp XXXXXXXXXXXXXXXXXXXXXXXXXXX

/* mbed USB Slingshot, 
 *
 * Copyright (c) 2010-2011 mbed.org, MIT License
 * 
 * smokrani, sford
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy of this software
 * and associated documentation files (the "Software"), to deal in the Software without
 * restriction, including without limitation the rights to use, copy, modify, merge, publish,
 * distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following conditions:
 * 
 *  The above copyright notice and this permission notice shall be included in all copies or
 * substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING
 * BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
 * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 */

#include "mbed.h"
#include "USBMouse.h"
#include "ADXL345.h"

// Physical interfaces
USBMouse mouse;
ADXL345 accelerometer(p5, p6, p7, p8);
AnalogIn stretch_sensor(p15);
BusOut leds(LED1, LED2, LED3, LED4);

// Return slingshot angle in radians, up > 0 > down
float get_angle() {
    int readings[3];
    accelerometer.getOutput(readings);
    float x = (int16_t)readings[0];
    float z = (int16_t)readings[2];
    return atan(z / x);    
}

// Return normalised stretch value based on bounds of all readings seen
float get_stretch() {
    static float min_strength = 0.7;
    static float max_strength = 0.7;
    float current_strength = stretch_sensor.read();
    if(current_strength > max_strength) { max_strength = current_strength; }
    if(current_strength < min_strength) { min_strength = current_strength; }
    float stretch = (current_strength - min_strength) / (max_strength - min_strength);
    return 1.0 - stretch;
}

// move mouse to a location relative to the start point, stepping as needed
void move_mouse(int x, int y) {
    const int STEP = 10;
    static int current_x = 0;
    static int current_y = 0;
    
    int move_x = x - current_x;
    int move_y = y - current_y; 

    // Move the mouse, in steps of max step size to ensure it is picked up by OS
    while(move_x > STEP) { mouse.move(STEP, 0); move_x -= STEP; }
    while(move_x < -STEP) { mouse.move(-STEP, 0); move_x += STEP; }
    while(move_y > STEP) { mouse.move(0, STEP); move_y -= STEP; }
    while(move_y < -STEP) { mouse.move(0, -STEP); move_y += STEP; }
    mouse.move(move_x, move_y);
    
    current_x = x;
    current_y = y;
}

template <class T>
T filter(T* array, int len, T value) {
    T mean = 0.0;
    for(int i = 0; i<len - 1; i++) {
        mean += array[i + 1];
        array[i] = array[i + 1];
    }
    mean += value;
    array[len - 1] = value;
    return mean / (T)len;
}

typedef enum {
    WAITING = 2,
    AIMING = 4,
    FIRING = 8
} state_t;

int main() {
    leds = 1;

    // setup accelerometer
    accelerometer.setPowerControl(0x00);
    accelerometer.setDataFormatControl(0x0B);
    accelerometer.setDataRate(ADXL345_3200HZ);
    accelerometer.setPowerControl(0x08);

    state_t state = WAITING;    
    Timer timer;

    float angles[8] = {0};
    float stretches[8] = {0};
    
    while(1) {        

        // get the slingshot parameters
        float this_stretch = get_stretch();
        float this_angle = get_angle();

        // apply some filtering
        float stretch = filter(stretches, 8, this_stretch);
        float angle = filter(angles, 8, this_angle);
            
        leds = state;
                
        // act based on the current state
        switch (state) {
            case WAITING:
                if(stretch > 0.5) {             // significant stretch, considered starting 
                    mouse.press(MOUSE_LEFT);
                    state = AIMING;
                }
                break;

            case AIMING:
                if(stretch - this_stretch > 0.1) { // rapid de-stretch, considered a fire
                    mouse.release(MOUSE_LEFT);
                    move_mouse(0, 0);
                    timer.start();
                    state = FIRING;
                } else {
                    int x = 0.0 - cos(angle) * stretch * 200;
                    int y = sin(angle) * stretch * 200;
                    move_mouse(x, y);
                }
                break;

            case FIRING:
                if(timer > 3.0) {
                    timer.stop();
                    timer.reset();
                    state = WAITING;
                }        
                break;
        };
        
        wait(0.01);
    }
}

XXXXXXXXXXXXXXXXXXXXXXXX test.cpp XXXXXXXXXXXXXXXXXXXXXXXXXXX

#include "mbed.h"
#include "USBMouse.h"
#include "ADXL345.h"
 
USBMouse mouse;
ADXL345 acc(p5, p6, p7, p8);
AnalogIn strength(p15);
 
int main() {
    //Initialize accelerometer
    acc.setPowerControl(0x00);
    acc.setDataFormatControl(0x0B);
    acc.setDataRate(ADXL345_3200HZ);
    acc.setPowerControl(0x08);
 
    while (1) {
        int readings[3];
        acc.getOutput(readings);        // test accelerometer
        printf("acc: %i, %i, %i\r\n", (int16_t)readings[0], (int16_t)readings[1], (int16_t)readings[2]);
 
        uint16_t str = strength.read_u16();        // test stretch sensor
        printf("strength: %d\r\n", str);
       
        mouse.move(10, 10);             // test USB relative mouse

        wait(0.1);
    }
}

XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX 

Here is the pinout table:

ADXL345 Signal Name	mbed pin
Vcc	Vout
Gnd	Gnd
SDA	p5
SDO	p6
SCL	p7
CS	p8
Stretch sensor	mbed pin
One extremity	Vout
The other	p15
USB connector	mbed pin
Vcc	Vin
Gnd	Gnd
D+	D+
D-	D-

3.3 to 5V and 5v to 3.3 Breakout: Sparkfun Logic Level Converter

The new Sparkfun Logic Level Converter

.from: http://www.sparkfun.com/products/8745

This one is very cool and work well between my XBee and my PIC18F.

Description: If you've ever tried to connect a 3.3V device to a 5V system, you know what a challenge it can be. The SparkFun logic level converter is a small device that safely steps down 5V signals to 3.3V and steps up 3.3V to 5V. This level converter also works with 2.8V and 1.8V devices. Each level converter has the capability of converting 4 pins on the high side to 4 pins on the low side. Two inputs and two outputs are provided for each side.

Bread board friendly! Can be used with normal serial, I2C, SPI, and any other digital signal. Does not work with an analog signal.

The level converter is very easy to use. The board needs to be powered from the two voltages sources, the high voltage and low voltage, that your system is using. High voltage (5V for example) to the 'HV' pin, low voltage (2.8V for example) to 'LV', and ground from the system to the 'GND' pin.

All the pins are labeled as INs and OUTs. These are relative to the board. A digital one going into the RXI pin on the 5V side will show up on the RXO pin on the 3.3V side as 3.3V. A digital one going into the TXI pin on the 3.3V side will show up on the TXO pin on the 5V side as 5V.

Dimensions: 0.5x0.6"

Documents: Schematic

Enjoy that.