diff --git a/johnny-five/johnny-five-tests.ts b/johnny-five/johnny-five-tests.ts
new file mode 100644
index 0000000000..930a67ea88
--- /dev/null
+++ b/johnny-five/johnny-five-tests.ts
@@ -0,0 +1,255 @@
+///<reference path="./johnny-five.d.ts"/>
+
+import five = require('johnny-five');
+var board = new five.Board();
+
+board.on('connect', function(){
+});
+
+board.on('ready', function(){
+    var accelerometer = new five.Accelerometer({
+        controller: "MPU6050",
+        sensitivity: 16384 // optional
+    });
+
+    var servo = new five.Servo(9);
+    var animation = new five.Animation(servo);
+
+    // Create an animation segment object
+    animation.enqueue({
+        duration: 2000,
+        cuePoints: [0, 0.25, 0.5, 0.75, 1.0],
+        keyFrames: [ {degrees: 0}, {degrees: 135}, {degrees: 45}, {degrees: 180}, {degrees: 0}]
+    });
+
+    // Create a new `button` hardware instance.
+    var button = new five.Button(8);
+
+    button.on("hold", function() {
+        console.log( "Button held" );
+    });
+
+    button.on("press", function() {
+        console.log( "Button pressed" );
+    });
+
+    button.on("release", function() {
+        console.log( "Button released" );
+    });
+
+
+    var compass = new five.Compass({
+        controller: "HMC6352"
+    });
+
+    compass.on("headingchange", function() {
+        console.log("headingchange");
+        console.log("  heading : ", Math.floor(this.heading));
+        console.log("  bearing : ", this.bearing.name);
+        console.log("--------------------------------------");
+    });
+
+    compass.on("data", function() {
+        console.log("  heading : ", Math.floor(this.heading));
+        console.log("  bearing : ", this.bearing.name);
+        console.log("--------------------------------------");
+    });
+
+    var esc = new five.ESC(11);
+
+    // Set to top speed. (this can be physically dangerous, you've been warned.)
+    esc.max();
+
+
+    var gyro = new five.Gyro({
+        pins: ["A0", "A1"],
+        sensitivity: 0.67, // optional
+        resolution: 4.88   // optional
+    });
+
+    var accel = new five.IMU({
+        controller: "MPU6050",
+        address: 0x68, // optional
+        freq: 100      // optional
+    });
+
+    var motion = new five.IR.Motion(7);
+
+// Options object with pin property
+    var motion = new five.IR.Motion({
+        pin: 7
+    });
+
+    var proximity = new five.IR.Proximity({
+        controller: "GP2Y0A21YK",
+        pin: "A0"
+    });
+
+    var eyes = new five.IR.Reflect.Array({
+        emitter: 13,
+        pins: ["A0", "A1", "A2"], // any number of pins
+        freq: 25
+    });
+
+    eyes.on('data', function() {
+        console.log( "Raw Values: ", this.raw );
+    });
+
+    eyes.on('line', function() {
+        console.log( "Line Position: ", this.line);
+    });
+
+    eyes.enable();
+
+    var joystick = new five.Joystick({
+        pins: ["A0", "A1"]
+    });
+    joystick.on("data", (value)=>{
+        console.log(value);
+    });
+
+    joystick.on("axismove", (err, value)=>{
+        console.log("change");
+
+        console.log(joystick.axis);
+        console.log(joystick.raw);
+        console.log(err);
+        console.log(value);
+    });
+
+    var lcd = new five.LCD({
+        pins: [8, 9, 4, 5, 6, 7],
+        backlight: 13,
+        rows: 2,
+        cols: 16
+    });
+
+    var led = new five.Led(13);
+    led.blink();
+
+    var digits = new five.Led.Digits({
+        pins: {
+            data: 2,
+            clock: 3,
+            cs: 4
+        }
+    });
+
+    var matrix = new five.Led.Matrix({
+        controller: "HT16K33",
+        dims: "8x16", // or "16x8"
+        rotation: 2
+    });
+
+    // With Options object & pins array
+    var rgb = new five.Led.RGB({
+        pins: [9, 10, 11]
+    });
+
+    var motor = new five.Motor({
+        pins: {
+            pwm:9,
+            dir:8,
+            brake: 11
+        }
+    });
+
+    var piezo = new five.Piezo(3);
+
+    // Plays a song
+    piezo.play({
+        // song is composed by an array of pairs of notes and beats
+        // The first argument is the note (null means "no note")
+        // The second argument is the length of time (beat) of the note (or non-note)
+        song: [
+            ["C4", 1 / 4],
+            ["D4", 1 / 4],
+            ["F4", 1 / 4],
+            ["D4", 1 / 4],
+            ["A4", 1 / 4],
+            [null, 1 / 4],
+            ["A4", 1],
+            ["G4", 1],
+            [null, 1 / 2],
+            ["C4", 1 / 4],
+            ["D4", 1 / 4],
+            ["F4", 1 / 4],
+            ["D4", 1 / 4],
+            ["G4", 1 / 4],
+            [null, 1 / 4],
+            ["G4", 1],
+            ["F4", 1],
+            [null, 1 / 2]
+        ],
+        tempo: 100
+    });
+
+    var digital = new five.Pin({
+        pin: 13
+    });
+
+    var analog = new five.Pin({
+        pin: "A0"
+    });
+
+    var analogAsDigital = new five.Pin({
+        pin: 14,
+        type: "digital"
+    });
+
+    var ping = new five.Ping(7);
+
+    var ping = new five.Ping({
+        pin: 7
+    });
+
+    var relay = new five.Relay(10);
+
+// Options object with pin property
+    var relay = new five.Relay({
+        pin: 10
+    });
+
+    var sensor = new five.Sensor("A0");
+
+    sensor.scale([ 0, 10 ]).on("data", function() {
+        console.log( this.value );
+    });
+
+    var servo = new five.Servo({
+        pin: 10,
+        range: [45, 135]
+    });
+
+    var register = new five.ShiftRegister({
+        pins: {
+            data: 2,
+            clock: 3,
+            latch: 4
+        }
+    });
+
+    var sonar = new five.Sonar("A0");
+
+    sonar.on("data", function() {
+        console.log("inches     : " + this.in);
+        console.log("centimeters: " + this.cm);
+        console.log("-----------------------");
+    });
+
+    var stepper = new five.Stepper({
+        type: five.Stepper.TYPE.DRIVER,
+        stepsPerRev: 200,
+        pins: {
+            step: 11,
+            dir: 12
+        }
+    });
+
+    var temperature = new five.Temperature({
+        pin: "A0",
+        toCelsius: function(raw) { // optional
+            return (raw / 100) + 10;
+        }
+    });
+});
diff --git a/johnny-five/johnny-five.d.ts b/johnny-five/johnny-five.d.ts
new file mode 100644
index 0000000000..9dd1477eb4
--- /dev/null
+++ b/johnny-five/johnny-five.d.ts
@@ -0,0 +1,588 @@
+// Type definitions for johnny-five
+// Project: https://github.com/rwaldron/johnny-five
+// Definitions by: Toshiya Nakakura <https://github.com/nakakura>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+///<reference path="../node/node.d.ts"/>
+
+declare module "johnny-five" {
+    export interface AccelerometerOption{
+        controller: string;
+    }
+
+    export interface AccelerometerGeneralOption{
+        controller?: string;
+    }
+
+    export interface AccelerometerAnalogOption extends AccelerometerGeneralOption{
+        pins: Array<string>;
+        sensitivity?: number;
+        aref?: number;
+        zeroV?: number | Array<number>;
+        autoCalibrate?: boolean;
+    }
+
+    export interface AccelerometerMPU6050Option extends AccelerometerGeneralOption{
+        sensitivity?: number;
+    }
+
+    export interface AccelerometerMMA7361Option extends AccelerometerGeneralOption{
+        sleepPin?: number | string;
+    }
+
+    export class Accelerometer{
+        constructor(option: AccelerometerGeneralOption | AccelerometerAnalogOption | AccelerometerMPU6050Option | AccelerometerMMA7361Option);
+        on(event: string, cb: ()=>void): void;
+        on(event: "change", cb: ()=>void): void;
+        on(event: "data", cb: (freq: any)=>void): void;
+        hasAxis(name: string): void;
+        enable(): void;
+        disable(): void;
+    }
+
+    export class Animation{
+        constructor(option: Servo | Array<Servo>);
+        enqueue(segment: any): void;
+        play(): void;
+        pause(): void;
+        stop(): void;
+        next(): void;
+        speed(speed: Array<number>): void;
+
+        target: number;
+        duration: number;
+        cuePoints: Array<number>;
+        keyFrames: number;
+        easing: string;
+        loop: boolean;
+        loopback: number;
+        metronomic: boolean;
+        progress: number;
+        currentSpeed: number;
+        fps: number;
+    }
+
+    export interface ButtonOptions{
+        pin: number | string;
+        invert?: boolean;
+        isPullup?: boolean;
+        holdtime?: number;
+    }
+
+    export class Button{
+        constructor(pin: number | string | ButtonOptions);
+        on(event: string, cb: ()=>void): void;
+        on(event: "hold", cb: (holdTime: number)=>void): void;
+        on(event: "down", cb: ()=>void): void;
+        on(event: "press", cb: ()=>void): void;
+        on(event: "up", cb: ()=>void): void;
+        on(event: "release", cb: ()=>void): void;
+    }
+
+    export interface BoardOptions{
+        id?: number | string;
+        port?: string | any;
+        repl?: boolean;
+    }
+
+    export interface Repl{
+        inject(object: any): void;
+    }
+
+    export class Board{
+        constructor(option?: BoardOptions);
+        on(event: string, cb: ()=>void): void;
+        on(event: "ready", cb: ()=>void): void;
+        on(event: "connect", cb: ()=>void): void;
+        pinMode(pin: number, mode: number): void;
+        analogWrite(pin: number, value: number): void;
+        analogRead(pin: number, cb: (item: number)=>void): void;
+        digitalWrite(pin: number, value: number): void;
+        digitalRead(pin: number, cb: (item: number)=>void): void;
+        shiftOut(dataPin: Pin, clockPin: Pin, isBigEndian: boolean, value: number): void;
+        wait(ms: number, cb: ()=>void): void;
+        loop(ms: number, cb: ()=>void): void;
+
+        isReady: boolean;
+        io: any;
+        id: string;
+        pins: Array<Pin>;
+        port: string;
+        inject: Repl;
+    }
+
+    export interface CompassOptions{
+        controller: string;
+        gauss?: number;
+    }
+
+    export class Compass{
+        constructor(option: CompassOptions);
+        on(event: string, cb: ()=>void): void;
+        on(event: "change", cb: ()=>void): void;
+        on(event: "data", cb: (data: any)=>void): void;
+    }
+
+    export interface ESCOption{
+        pin: number | string;
+        range?: Array<number>;
+        startAt?: number;
+    }
+
+    export class ESC{
+        constructor(option: number | string | ESCOption);
+        speed(value: number): void;
+        min(): void;
+        max(): void;
+        stop(): void;
+    }
+
+    export interface GyroGeneralOption{
+        controller?: string;
+    }
+
+    export interface GyroAnalogOption extends GyroGeneralOption{
+        pins: Array<string>;
+        sensitivity: number;
+        resolution?: number;
+    }
+
+    export interface GyroMPU6050Option extends GyroGeneralOption{
+        sensitivity: number;
+    }
+
+    export class Gyro{
+        constructor(option: GyroGeneralOption | GyroAnalogOption | GyroMPU6050Option);
+        on(event: string, cb: ()=>void): void;
+        on(event: "change", cb: ()=>void): void;
+        on(event: "data", cb: (data: any)=>void): void;
+        recalibrate(): void;
+    }
+
+    export interface IMUGeneralOption{
+        controller?: string;
+        freq?: number;
+    }
+
+    export interface IMUMPU6050Option extends IMUGeneralOption{
+        address: number;
+    }
+
+    export class IMU{
+        constructor(option: IMUGeneralOption | IMUMPU6050Option);
+        on(event: string, cb: ()=>void): void;
+        on(event: "change", cb: ()=>void): void;
+        on(event: "data", cb: (data: any)=>void): void;
+    }
+
+    export module IR{
+        export interface MotionOption{
+            pin: number | string;
+        }
+
+        export class Motion{
+            constructor(option: number | MotionOption);
+            on(event: string, cb: ()=>void): void;
+            on(event: "data", cb: (data: any)=>void): void;
+            on(event: "motionstart", cb: ()=>void): void;
+            on(event: "motionend", cb: ()=>void): void;
+            on(event: "calibrated", cb: ()=>void): void;
+        }
+
+        export interface PloximityOption{
+            pin: number | string;
+            controller: string;
+        }
+
+        export class Proximity{
+            constructor(option: number | PloximityOption);
+            on(event: string, cb: ()=>void): void;
+            on(event: "data", cb: (data: any)=>void): void;
+            on(event: "change", cb: ()=>void): void;
+        }
+
+        export interface ArrayOption{
+            pins: Array<number> | Array<string>;
+            emitter: number | string;
+            freq?: number;
+        }
+
+        export interface LoadCalibrationOption{
+            min: Array<number>;
+            max: Array<number>;
+        }
+
+        export module Reflect{
+            export class Array{
+                constructor(option: ArrayOption);
+                enable(): void;
+                disable(): void;
+                calibrate(): void;
+                calibrateUntil(predicate: ()=>void): void;
+                loadCalibration(option: LoadCalibrationOption): void;
+                on(event: string, cb: ()=>void): void;
+                on(event: "data", cb: (data: any)=>void): void;
+                on(event: "calibratedData", cb: (data: any)=>void): void;
+                on(event: "line", cb: (data: any)=>void): void;
+            }
+        }
+    }
+
+    export interface JoystickOption{
+        pins: Array<string>;
+    }
+
+    export class Joystick{
+        constructor(option: JoystickOption);
+        on(event: string, cb: ()=>void): void;
+        on(event: "data", cb: (data: any)=>void): void;
+        on(event: "change", cb: ()=>void): void;
+        on(event: "axismove", cb: (error: Error, date: Date)=>void): void;
+
+        axis: Array<number>;
+        raw: Array<number>;
+    }
+
+
+    export interface LCDGeneralOption{
+        rows?: number;
+        cols?: number;
+    }
+
+    export interface LCDI2COption extends LCDGeneralOption{
+        controller: string;
+    }
+
+    export interface LCDParallelOption extends LCDGeneralOption{
+        pins: Array<any>;
+    }
+
+    export class LCD{
+        constructor(option: LCDGeneralOption | LCDI2COption | LCDParallelOption);
+        print(message: string): void;
+        useChar(char: string): void;
+        clear(): void;
+        cursor(row: number, col: number): void;
+        home(): void;
+        display(): void;
+        noDisplay(): void;
+        blink(): void;
+        noBlink(): void;
+        autoscroll(): void;
+        noAutoscroll(): void;
+    }
+
+    export interface LedOption{
+        pin: number;
+        type?: string;
+        controller?: string;
+        address?: number;
+        isAnode?: boolean;
+    }
+
+    export class Led{
+        constructor(option: number | LedOption);
+        on(): void;
+        off(): void;
+        toggle(): void;
+        strobe(ms: number): void;
+        blink(): void;
+        blink(ms: number): void;
+        brightness(val: number): void;
+        fade(brightness: number, ms: number): void;
+        fadeIn(ms: number): void;
+        fadeOut(ms: number): void;
+        pulse(ms: number): void;
+        stop(ms: number): void;
+    }
+
+    export module Led{
+        export interface DigitsOption{
+            pins: any;
+            devices?: number;
+        }
+
+        export class Digits{
+            constructor(option: DigitsOption);
+            on(): void;
+            on(index: number): void;
+            off(): void;
+            off(index: number): void;
+            clear(): void;
+            clear(index: number): void;
+            brightness(value: number): void;
+            brightness(index: number, value: number): void;
+            draw(position: number, character: number): void;
+            draw(index: number, position: number, character: number): void;
+        }
+
+        export interface MatrixOption{
+            pins: any;
+            devices?: number;
+        }
+
+        export interface MatrixIC2Option{
+            controller: string;
+            addresses?: Array<any>;
+            isBicolor?: boolean;
+            dims? :any;
+            rotation?: number;
+        }
+
+        export class Matrix{
+            constructor(option: MatrixOption | MatrixIC2Option);
+            on(): void;
+            on(index: number): void;
+            off(): void;
+            off(index: number): void;
+            clear(): void;
+            clear(index: number): void;
+            brightness(value: number): void;
+            brightness(index: number, value: number): void;
+            led(row: number, col: number, state: any): void;
+            led(index: number, row: number, col: number, state: any): void;
+            row(row: number, val: number): void;
+            row(index: number, row: number, val: number): void;
+            column(row: number, val: number): void;
+            column(index: number, row: number, val: number): void;
+            draw(position: number, character: number): void;
+            draw(index: number, position: number, character: number): void;
+        }
+
+        export interface RGBOption{
+            pins: Array<number>;
+            isAnode?: boolean;
+            controller?: string;
+        }
+
+        export class RGB{
+            constructor(option: RGBOption);
+            on(): void;
+            off(): void;
+            color(value: number): void;
+            toggle(): void;
+            strobe(ms: number): void;
+            brightness(value: number): void;
+            fadeIn(ms: number): void;
+            fadeOut(ms: number): void;
+            pulse(ms: number): void;
+            stop(ms: number): void;
+        }
+    }
+
+    export interface MotorOption{
+        pins: any;
+        current?: any;
+        invertPWM?: boolean;
+        address?: number;
+        controller?: string;
+        register?: any;
+        bits?: any;
+    }
+
+    export class Motor{
+        constructor(option: Array<number> | MotorOption);
+        forward(speed: number): void;
+        fwd(speed: number): void;
+        reverse(speed: number): void;
+        rev(speed: number): void;
+        start(): void;
+        start(speed: number): void;
+        stop(): void;
+        brake(): void;
+        release(): void;
+    }
+
+    export interface PiezoOption{
+        pin: number;
+    }
+
+    export class Piezo{
+        constructor(option: number | PiezoOption);
+        frequency(frequency: number, duration: number): void;
+        play(tune: any, cb?: ()=>void): void;
+        tone(frequency: number, duration: number): void;
+        noTone(): void;
+        off(): void;
+    }
+
+    export interface PinOption{
+        id?: number | string;
+        pin: number | string;
+        type?: string;
+    }
+
+    export interface PinState{
+        supportedModes: Array<number>;
+        mode: number;
+        value: number;
+        report: number;
+        analogChannel: number;
+    }
+
+    export class Pin{
+        constructor(option: number | string | PinOption);
+        query(cb: (pin: PinState)=>void): void;
+        high(): void;
+        low(): void;
+        write(value: number): void;
+        read(cb: (value: number)=>void): void;
+        static write(pin: number, value: number): void;
+        static read(pin: number, cb: (data: number)=>void): void;
+    }
+
+    export interface PingOption{
+        pin: number | string;
+        freq?: number;
+        pulse?: number;
+    }
+
+    export class Ping{
+        constructor(option: number | PingOption);
+    }
+
+    export interface RelayOption{
+        pin: number | string;
+        type?: string;
+    }
+
+    export class Relay{
+        constructor(option: number | RelayOption);
+        open(): void;
+        close(): void;
+        toggle(): void;
+    }
+
+    export interface SensorOption{
+        pin: number | string;
+        freq?: boolean;
+        threshold?: number;
+    }
+
+    export class Sensor{
+        constructor(option: number | string | SensorOption);
+        scale(low: number, high: number): Sensor;
+        scale(range: number[]): Sensor;
+        scale(): Sensor;
+        booleanAt(barrier: number): boolean;
+        within(range: Array<number>, cb: ()=>void): void;
+        on(event: string, cb: ()=>void): void;
+        on(event: "data", cb: (data: any)=>void): void;
+        on(event: "change", cb: ()=>void): void;
+    }
+
+    export interface ServoGeneralOption{
+        pin: number | string;
+        range?: Array<number>;
+        type?: string;
+        startAt?: number;
+        isInverted?: boolean;
+        center?: boolean;
+        controller?: string;
+    }
+
+    export interface ServoPCA9685Option extends ServoGeneralOption{
+        address?: number;
+    }
+
+    export interface ServoSweepOpts{
+        range: Array<number>;
+        interval?: number;
+        step?: number;
+    }
+
+    export class Servo{
+        constructor(option: number | string | ServoGeneralOption);
+        to(degrees: number, ms?: number, rage?: number): void;
+        min(): void;
+        max(): void;
+        center(): void;
+        sweep(): void;
+        sweep(range: Array<number>): void;
+        sweep(opt: ServoSweepOpts): void;
+        stop(): void;
+        cw(speed: number): void;
+        ccw(speed: number): void;
+        on(event: string, cb: ()=>void): void;
+        on(event: "move:complete", cb: ()=>void): void;
+    }
+
+    export interface ShiftRegisterOption{
+        pins: any;
+    }
+
+    export class ShiftRegister{
+        constructor(option: ShiftRegisterOption);
+        send(...value: number[]): void;
+    }
+
+    export interface SonarOption{
+        pin: number | string;
+        device: string;
+        freq?: number;
+        threshold?: number;
+    }
+
+    export class Sonar{
+        constructor(option: number | string | SonarOption);
+        within(range: Array<number>, cb: ()=>void): void;
+        within(range: Array<number>, unit: string, cb: ()=>void): void;
+        on(event: string, cb: ()=>void): void;
+        on(event: "data", cb: (data: any)=>void): void;
+        on(event: "change", cb: ()=>void): void;
+    }
+
+    export interface StepperOption{
+        pins: any;
+        stepsPerRev: number;
+        type: number;
+        rpm?: number;
+        direction?: number;
+    }
+
+    export module Stepper{
+        export class TYPE{
+            static DRIVER: number;
+            static TWO_WIRE: number;
+            static FOUR_WIRE: number;
+        }
+    }
+
+    export class Stepper{
+        constructor(option: number | string | StepperOption);
+        step(stepsOrOpts: any, cb: ()=>void): void;
+        rpm(): Stepper;
+        rpm(value: number): Stepper;
+        speed(): Stepper;
+        speed(value: number): Stepper;
+        direction(): Stepper;
+        direction(value: number): Stepper;
+        accel(): Stepper;
+        accel(value: number): Stepper;
+        decel(): Stepper;
+        decel(value: number): Stepper;
+        cw(): Stepper;
+        ccw(): Stepper;
+
+        within(range: Array<number>, cb: ()=>void): void;
+        within(range: Array<number>, unit: string, cb: ()=>void): void;
+        on(event: string, cb: ()=>void): void;
+        on(event: "data", cb: (data: any)=>void): void;
+        on(event: "change", cb: ()=>void): void;
+    }
+
+    export interface TemperatureOption{
+        controller?: string;
+        pin: string | number;
+        toCelsius?: (val: number)=>number;
+        freq?: number;
+    }
+
+    export class Temperature{
+        constructor(option: TemperatureOption);
+        on(event: string, cb: ()=>void): void;
+        on(event: "data", cb: (data: any)=>void): void;
+        on(event: "change", cb: ()=>void): void;
+    }
+}
+