Generic Arduino Wireless Game Controller

()

Introduction

The Generic Arduino Wireless Game Controller consists two parts; a case for the controller made in a laser cutter and a simple code for controlling servos wireless using joypads and Arduino boards.
The conditions for building this project is that you should have some, if not little, knowledge to java programming – we use Arduino and Processing.

The project has been a two-man team. We tried to build an open source code for joypads. A simple code that could be modified by users to get a quick operating controller. We tested the code with servomotors, so that the test worked around a motorized remote vehicle (http://fabmaker.hobye.dk/bendablewood-tanktreads/). This was to see the controller in action and is not needed to build this product.
The down side of this code is that we did not write the code so you simply can remove our values and insert your own. Because we were focused on making it work before the deadline we did not manage to make any neat methods.
The upside of this code is very simple and easy to understand.

We have used two Ciseco SRF Shield for the wireless connection, but others can be just as well.

Step 1. Materials and Resources


A complete view of materials for the wireless controller

Materials

2 x JoyPads – Sainsmart – or something similar*
2 x Ciseco SRF shield – or similar
2 x Arduino Uno R3 boards
9V Battery or powerbank
24 x M3 Nuts
8 x M3 bolts, approximately 20mm long
16 x M3 washers
3 or more mounting pins for the Arduino Uno
1 x 400 x400 x 3 mm HDF* *
Assorted dual female protowires
2x 10 kOhm – pull-up resistors
Velcro tape - for the battery

*Note: The holes are spaced according to the Sainsmart and might need tweaking to accomodate other joypads.

* *Note: It is maybe possible to use polycarbonate sheets or plywood and increase the thickness of the materiel to 4 mm, but you will need to tweak the bendable pattern, otherwise it might break and/or not fit the dimensions of the case. None this has been fully tested.

Tools

Gloves (glue is hot) – safety first :)
Laser cutter
Glue gun
Soldering iron
Pliers
Screwdriver

Download

Processing – Download
Spirograph folder – Download
Arduino – Download

Step 2. Arduino Preparation


Install Arduino when finished.
Open “Spirograph” and extract the folder.
Inside Spirograph folder there is a folder called “install in libraries folder“ a file called “easytransfer” move the “easytransfer” to Arduino library. An example on where you can find the Arduino library (C:\Users\PCname\Documents\Arduino\libraries).


Step 3. Arduino/Shield Transmitter


On the Arduino board we used digital pins 7, 8 and 11. 8 is the "on" connection for the Ciseco Shield and 7 and 11 is used for the push buttons on the joypads. Analog pins A0, A1 is the X and Y axis for the right joypad and A2, A3 is the X and Y axis for the left joypad. Each axis goes from a value of 0 to 1023 which. We connected the vertical pins on the backside of the SRF Shield, so that it would take up as little space as possible.

Below, you can see the Ciseco SRF shield

Front side


Back side



Step 4. Joypads


This is our two identical joypads, which has a pull-up resistor soldered to each joypad between SW and 5V on the backside, so that the digital input has valid value when the switch is not pressed down.

In the background you can see the resistor on the joypad board


And this is the joypad in the foreground

The connection between the joypads and the SRF Shield/Arduino is as follows.

Colour - Left Joypad - Right Joypad - Shield board

Colour Left Joypad Right Joypad SRF Shield
RED +5V +5V 5V
BROWN GND GND GND
BLACK - VRx A0
WHITE - VRy A1
YELLOW VRy - A2
ORANGE VRx - A3
GREEN SW - 7
GRAY - SW 11




Step 5. Arduino Transmitter Code

The transmitter code is posted below.

  #include <EasyTransfer.h>

  //create object
  EasyTransfer ET;

  //put your variable definitions here for the data you want to send
  //THIS MUST BE EXACTLY THE SAME ON THE OTHER ARDUINO
  struct Data {
    int joyPinY0 = 0;                 // slider variable connecetd to analog pin 0
    int joyPinX0 = 1;                 // slider variable connecetd to analog pin 1
    int valueY0 = 0;                  // variable to read the value from the analog pin 0
    int valueX0 = 1;                  // variable to read the value from the analog pin 1
    int joyPinY1 = 2;                 // slider variable connecetd to analog pin 0
    int joyPinX1 = 3;                 // slider variable connecetd to analog pin 1
    int valueY1 = 2;                  // variable to read the value from the analog pin 0
    int valueX1 = 3;
    int pushButton0 = 11;
    int pushButton1 = 7;
    int state0;
    int state1;
  };

  // Initialize the object Data
  Data mydata;

  // Construct the program and load the following at start up
  void setup() {
    pinMode(11, INPUT);
    pinMode(7, INPUT);
    pinMode(8, OUTPUT);    // Initialisier Pin 8
    digitalWrite(8, HIGH);
    Serial.begin(115200);
    //start the library, pass in the data details and the name of the serial port. Can be Serial, Serial1, Serial2, etc.
    ET.begin(details(mydata), &Serial);

  }

  void loop() {
    mydata.state0 = digitalRead(mydata.pushButton0);
    delay(1);

    // reads the value of the variable resistor
    mydata.valueY0 = analogRead(mydata.joyPinY0);

    // this small pause is needed between reading
    // analog pins, otherwise we get the same value twice
    delay(1);
    mydata.valueX0 = analogRead(mydata.joyPinX0);
    delay(1);
    mydata.state1 = digitalRead(mydata.pushButton1);
    delay(1);
    mydata.valueY1 = analogRead(mydata.joyPinY1);
    delay(1);
    mydata.valueX1 = analogRead(mydata.joyPinX1);
    delay(1);
    // sendes data to the receiver


    ET.sendData();

    delay(20);
  }


Step. 6 Servo Control

The following describes how we connected the servo to the Arduino board.

The picture below shows the Arduino, Shield and the servos. The servos is mounted http://fabmaker.hobye.dk/bendablewood-tanktreads/ and is adjusted to control the tank.
Servo left and right is configured so that they are mirrored and will create drive in the tank.
The center servo tracks the position of the left joypad and is included only to verify that the controller transmits data.

A connection summery table overview from Arduino board to the servos.

Colour SRF Shield Left Servo Right Servo Center Servo
BLUE 6-LED1 - - -
GREEN 7-LED2 - - -
BROWN 9 WHITE - -
YELLOW 10 - WHITE -
ORANGE 11 - - YELLOW
RED 5V0 RED RED RED
BLACK GND GND GND GND
BLACK GND GND GND GND


Step 7. Arduino Receiver Code


This is the receiver code and inside it you will find notes for almost each line explaining what it does.

// Libraries we use
    #include <EasyTransfer.h>
    #include <Servo.h>
    #include <math.h>

    //Create object,
    EasyTransfer ET;
    Servo myservoX;
    Servo myservoY;
    Servo myservoZ;

    //put your variable definitions here for the data you want to receive
    //THIS MUST BE EXACTLY THE SAME ON THE OTHER ARDUINO
    struct Data {
      int joyPinY0 = 0;                 // slider variable connecetd to analog pin 0
      int joyPinX0 = 1;                 // slider variable connecetd to analog pin 1
      int valueY0 = 0;                  // variable to read the value from the analog pin 0
      int valueX0 = 1;                  // variable to read the value from the analog pin 1
      int joyPinY1 = 2;                 // slider variable connecetd to analog pin 0
      int joyPinX1 = 3;                 // slider variable connecetd to analog pin 1
      int valueY1 = 2;                  // variable to read the value from the analog pin 0
      int valueX1 = 3;
      int pushButton0 = 11;
      int pushButton1 = 7;
      int state0;
      int state1;
    };

    //Initialize the Data object and initialize variables
    Data mydata;
    int valX0;
    int valY0;
    int valX1;
    int valY1;
    int valXservo;
    int valYservo;
    int valZservo;
    float Angle = 0;

    // Construct the program. This is what the program will load, at the start op.
    void setup() {
      pinMode(8, OUTPUT);    // Initialisier Pin 8
      digitalWrite(8, HIGH); // Enable SRF Shield on pin 8
      Serial.begin(115200);  // 115200 BAUD communication rate
      ET.begin(details(mydata), &Serial); //start the library, pass in the data details and the name of the serial port. Can be Serial, Serial1, Serial2, etc.
      pinMode(6, OUTPUT);     // Blue lead, initialize pin 6 as OUTPUT
      pinMode(7, OUTPUT);     // Green lead, initialize pin 7 as OUTPUT
      myservoX.attach(9);     // Brown lead, connect the servo variable to pin 9
      myservoY.attach(10);    // Yellow lead, connect the servo variable to pin 10
      myservoZ.attach(11);    // Orange lead, connect the servo variable to pin 11
    }


    void loop() {
      // While the program is receiving the communication from the transmitter, then do as following
      if (ET.receiveData()) {

        // Maps a number from one range to another.
        // The parameters is as following. The number to map (the received data), and the current range of our value is from 0 to 1023. The target range is 50 to 130.
        // This is X and Y coordinates from one joypad.
        valX0 = map (mydata.valueX0, 0, 1023, 50, 130);
        valY0 = map (mydata.valueY0, 0, 1023, 50, 130);

        // The only thing this do, is rotating both sevo simultaneously the same direction, when you press up or down.
        valXservo = valX0 + valY0 - 90;
        myservoX.write(valXservo);
        valYservo = valX0 - valY0 + 90;
        myservoY.write(valYservo);

        // This is the second joypad.
        valX1 = map (mydata.valueX1, 0, 1023, 50, 130);
        valY1 = map (mydata.valueY1, 0, 1023, 50, 130);

        // This is used to get the value from joypad 2, and use trigonometry (https://www.arduino.cc/en/Math/H) tangent, to specify the angle
        // from the value we receive from mydata. We subtract 500 from mydata to reset the values and
        // multiply the substraction of 180/pi to convert the value from radiant to degree.
        // We then constrain the angle for safty reasons
        Angle = atan2( mydata.valueY1 - 500, mydata.valueX1 - 500) * - (180 / 3.14159265) + 90; // the + 90 might be useless in this situation
        delay(20);
        int conAngle = constrain(Angle, 0, 180); 

        // This is used so that the servo has a fixed angle of 90 degrees, so the start position is centered
        // as long Y1 and X1 is between the value 450 and 550
        if ( mydata.valueY1 >= 450 && mydata.valueY1 <= 550 && mydata.valueX1 >= 450 && mydata.valueX1 <= 550)
        {
          myservoZ.write(90);
          delay(20);
        }
        else // otherwise use the conAngle value
        {
          myservoZ.write(conAngle);
          delay(20);
        }
        Serial.println(mydata.state0);
        // This is used for the 5th button on the joypad
        // saying as long the state is LOW (being pressed), the button will enable otherwise its disabled
        if (mydata.state0 == LOW)
        {
          digitalWrite(6, HIGH); // enabled
        }
        else
        {
          digitalWrite(6, LOW); // disabled
        }
        // This is joypad 2 and used as mentioned above
        if (mydata.state1 == LOW)
        {
          digitalWrite(7, HIGH);
        }
        else
        {
          digitalWrite(7, LOW);
        }
        delay(10);
      }
    }


Step 8. Case Design

We used Processing to draw our case design by using the code and methods created by Mads Høbye. The folder is called "Spirograph" and is located under the section Downloads

This is our 7th prototype of the case shown below(the design has been revised a bit since then; namely the holes for the joypads has been made bigger, so that the joypads can be mounted higher and you can reach the extremes of the X/Y axis. Also the new version has a grid on the front to add buttons and LEDs easily.


The code for the case is shown below.

  import processing.pdf.*;
  // material thickness - the gridsystem is equal to the thickness of the material
  // the parant mfab class used as a neutral container or canvas. (materialthickness,inset,offset)
  mfab canvas = createCanvas(4.0f, 0.3f, 0.2f, 85, 80, "Generic Arduino Wireless Controller", "Joystick Gruppen");

  void setup() {
    size(800, 800, P2D );

    setupElements();
  }

  void setupElements()
  {
    setupMFab();

    //// SHELL
    float ShellHeight= 28;
    float X_Shell = 0;
    float Y_Shell = 45;
    float joypadDia =6.5;
    float joypadOffsetX = 7;
    float joypadOffsetY = 7;

    //// MOUNTING BOARD

    float X_MB = 50;
    float Y_MB = 5;
    float MBW = 29;

    //// STRUCTUREABLE PARTS
    float X_SP = 5;
    float Y_SP = 10;
    float SPHeight = 8;
    float SPoffset =12; //OFFSET
    float ArcDia = 2*SPHeight;

    //JOYPAD MOÙNTING HOLES
    float holeDia = .75;
    float X_holePitch= 5;
    float Y_holePitch= 6.5;
    float X_centerJoypadMountingHoles0 = X_MB + MBW/2 - X_holePitch/2 - holeDia - joypadOffsetX;
    float Y_centerJoypadMountingHoles0 = Y_MB - Y_holePitch/2 + holeDia + joypadOffsetY;

    float X_centerJoypadMountingHoles1=X_MB + MBW/2 - X_holePitch/2 - holeDia + joypadOffsetX;
    float Y_centerJoypadMountingHoles1=Y_MB - Y_holePitch/2 + holeDia + joypadOffsetY;

    float ArdMountHolesX = 13;
    float ArdMountHolesY = 14;

    //// STRUCTUREABLE PARTS
    // TOP
    canvas.addArc(X_SP, Y_SP+SPHeight/2, ArcDia/2, 90, 270);
    canvas.addArc(X_SP+MBW, Y_SP+SPHeight/2, ArcDia/2, -90, 90);
    canvas.addLine(X_SP, Y_SP, MBW, 0, LTTACKY);
    canvas.addLine(X_SP, Y_SP+SPHeight, MBW, 0, LTIREFLECT);

    canvas.addMountHoleRow(X_SP, Y_SP+SPHeight-2, MBW+1, 0);
    canvas.addMountHoleRow(X_SP+1, Y_SP+SPHeight-2, 4, -90);
    canvas.addMountHoleRow(X_SP+MBW-2, Y_SP+SPHeight-2, 4, -90);
    // BOTTOM
    canvas.addArc(X_SP, SPoffset+Y_SP+SPHeight/2, ArcDia/2, 90, 270);
    canvas.addArc(X_SP+MBW, SPoffset+Y_SP+SPHeight/2, ArcDia/2, -90, 90);
    canvas.addLine(X_SP, SPoffset+Y_SP, MBW, 0, LTTACKY);
    canvas.addLine(X_SP, SPoffset+Y_SP+SPHeight, MBW, 0, LTIREFLECT);
    canvas.addMountHoleRow(X_SP, SPoffset+Y_SP+SPHeight-2, MBW+1, 0);

    canvas.addMountHoleRow(X_SP+1, SPoffset+Y_SP+SPHeight-2, 4, -90);
    canvas.addMountHoleRow(X_SP+MBW-2, SPoffset+Y_SP+SPHeight-2, 4, -90);

    // TRIANGLES
    canvas.addLine(X_SP+39, SPoffset+Y_SP, SPHeight-3, 0, LTTACKY);
    canvas.addLine(X_SP+39, SPoffset+Y_SP, SPHeight-3, 90, LTTACKY);
    canvas.addLine(X_SP+39, SPoffset+Y_SP+5, 7.2, -45, LTSTRAIGHT);

    canvas.addLine(X_SP+39, SPoffset+Y_SP-10, SPHeight-3, 0, LTTACKY);
    canvas.addLine(X_SP+39, SPoffset+Y_SP-10, SPHeight-3, 90, LTTACKY);
    canvas.addLine(X_SP+39, SPoffset+Y_SP-5, 7.2, -45, LTSTRAIGHT);

    canvas.addLine(X_SP+34, SPoffset+Y_SP, SPHeight-3, 0, LTTACKY);
    canvas.addLine(X_SP+34, SPoffset+Y_SP, SPHeight-3, 90, LTTACKY);
    canvas.addLine(X_SP+34, SPoffset+Y_SP+5, 7.2, -45, LTSTRAIGHT);

    canvas.addLine(X_SP+34, SPoffset+Y_SP-10, SPHeight-3, 0, LTTACKY);
    canvas.addLine(X_SP+34, SPoffset+Y_SP-10, SPHeight-3, 90, LTTACKY);
    canvas.addLine(X_SP+34, SPoffset+Y_SP-5, 7.2, -45, LTSTRAIGHT);

    // OUTLINE
    //UPPER LINE
    canvas.addLine(X_Shell, Y_Shell, (MBW / 2)-1.5, 0, LTIREFLECT);
    canvas.addLine(X_Shell + (MBW / 2)-1.5, Y_Shell, (ArcDia*PI/4), 0, LTSTRAIGHT);
    canvas.addLine(X_Shell + (MBW / 2)-1.5 + (ArcDia*PI/4), Y_Shell, MBW, 0, LTIREFLECT);
    canvas.addLine(X_Shell + (MBW / 2)-1.5 + (ArcDia*PI/4) + MBW, Y_Shell, ArcDia*PI/4, 0, LTSTRAIGHT);
    canvas.addLine(X_Shell + (MBW / 2)-1.5 + 2 * (ArcDia*PI/4)+MBW, Y_Shell, (MBW / 2)+1.5, 0, LTIREFLECT);
    //LOWER LINE
    canvas.addLine(X_Shell, Y_Shell + ShellHeight, (MBW / 2)-1.5, 0, LTTACKY);
    canvas.addLine(X_Shell + (MBW / 2)-1.5, Y_Shell+ ShellHeight, (ArcDia*PI/4), 0, LTSTRAIGHT);
    canvas.addLine(X_Shell + (MBW / 2)-1.5 + (ArcDia*PI/4), Y_Shell+ ShellHeight, MBW, 0, LTTACKY);
    canvas.addLine(X_Shell + (MBW / 2)-1.5 + (ArcDia*PI/4) + MBW, Y_Shell+ ShellHeight, (ArcDia*PI/4), 0, LTSTRAIGHT);
    canvas.addLine(X_Shell + (MBW / 2)-1.5 + 2 * (ArcDia*PI/4)+MBW, Y_Shell+ ShellHeight, (MBW / 2)+1.5, 0, LTTACKY);
    // SIDES
    canvas.addLine(X_Shell, Y_Shell, ShellHeight, 90, LTSTRAIGHT);
    canvas.addLine(X_Shell + (MBW / 2)-1.5 + 2 * (ArcDia*PI/4)+MBW + (MBW / 2)+1.5, Y_Shell, ShellHeight, 90, LTSTRAIGHT);

    canvas.addRect(X_Shell, Y_Shell + (ShellHeight / 2)-2,2,4);
    canvas.addRect(X_Shell + (MBW / 2)-1.5 + 2 * (ArcDia*PI/4)+MBW + (MBW / 2)+1.5-2, Y_Shell + (ShellHeight / 2)-2,2,4);

    canvas.addMountHoleGrid(X_Shell + (MBW / 2)-1.5 + (ArcDia*PI/4)+1, Y_Shell+1.5, MBW-1, ShellHeight-2);

    // LOCKING MECHANISM
    canvas.addArc(22,3,4,0,360);
    canvas.addArc(22,3,.5,0,360);

    canvas.addRect(25,3,4,4);
    canvas.addArc(25+2,3+2,.5,0,360);

    canvas.addRect(30,3,5,5);
    canvas.addArc(30+2.5,3+2.5,.5,0,360);

    //BENDABLE
    float slitHeight = ShellHeight/4;
    float slitWidth = .4;
    float slitDistX = .8;
    float slitDistY = 1.1;

      for (float i=0; i<6; i=i+slitDistX)
    { // Start loop 1

       for (float y=-1; y<4; y=y+slitDistY)
      { // Start loop 2
        canvas.addRect(X_Shell + (MBW / 2)-1.5 + (2*i), Y_Shell+y*slitHeight, slitWidth, slitHeight);

        canvas.addRect(X_Shell + (MBW / 2)-1.5 + (2*i) + slitDistX, Y_Shell+y*slitHeight+slitHeight*(slitDistY/2), slitWidth, slitHeight);
      } // End loop 2 

      for (float y=-1; y<4; y=y+slitDistY)
      { // Start loop 3
        canvas.addRect(X_Shell + (MBW / 2)-1.5 + (ArcDia*PI/4) + MBW + (2*i), Y_Shell+y*slitHeight, slitWidth, slitHeight);

        canvas.addRect(X_Shell + (MBW / 2)-1.5 + (ArcDia*PI/4) + MBW + (2*i) + slitDistX, Y_Shell+y*slitHeight+slitHeight*(slitDistY/2), slitWidth, slitHeight);
      } // End loop 3

    } // End loop 1

  //HOLES

  canvas.addPopCircle(X_Shell + (MBW / 2)-1.5 + (ArcDia*PI/4) + MBW / 2 - joypadOffsetX, Y_Shell + joypadOffsetY, joypadDia);
  canvas.addPopCircle(X_Shell + (MBW / 2)-1.5 + (ArcDia*PI/4) + MBW / 2 + joypadOffsetX, Y_Shell + joypadOffsetY, joypadDia);

  // OUTLINE
  canvas.addLine(X_MB, Y_MB, MBW, 0, LTIREFLECT);
  canvas.addLine(X_MB, Y_MB + ShellHeight, MBW, 0, LTTACKY);
  canvas.addLine(X_MB, Y_MB, ShellHeight, 90, LTSTRAIGHT);
  canvas.addLine(MBW + X_MB, Y_MB, ShellHeight, 90, LTSTRAIGHT);

  canvas.addMountHoleRow(X_MB+2, Y_MB+1, 4, 90);
  canvas.addMountHoleRow(X_MB+MBW-1, Y_MB+1, 4, 90);

  canvas.addMountHoleRow(X_MB+1, ShellHeight+Y_MB-1, 4, -90);
  canvas.addMountHoleRow(X_MB+MBW-2, ShellHeight+Y_MB-1, 4, -90);

  // HOLES FOR JOYPADS

  canvas.addPopCircle(X_centerJoypadMountingHoles0, Y_centerJoypadMountingHoles0, holeDia);
  canvas.addPopCircle(X_centerJoypadMountingHoles0+Y_holePitch, Y_centerJoypadMountingHoles0, holeDia);
  canvas.addPopCircle(X_centerJoypadMountingHoles0, Y_centerJoypadMountingHoles0+X_holePitch, holeDia);
  canvas.addPopCircle(X_centerJoypadMountingHoles0+Y_holePitch, Y_centerJoypadMountingHoles0+X_holePitch, holeDia);

  canvas.addPopCircle(X_centerJoypadMountingHoles1, Y_centerJoypadMountingHoles1, holeDia);
  canvas.addPopCircle(X_centerJoypadMountingHoles1+Y_holePitch, Y_centerJoypadMountingHoles1, holeDia);
  canvas.addPopCircle(X_centerJoypadMountingHoles1, Y_centerJoypadMountingHoles1+X_holePitch, holeDia);
  canvas.addPopCircle(X_centerJoypadMountingHoles1+Y_holePitch, Y_centerJoypadMountingHoles1+X_holePitch, holeDia);

  // HOLES FOR ARDUINO UNO
  canvas.addPopCircle(ArdMountHolesX + X_MB, ArdMountHolesY + Y_MB, holeDia);
  canvas.addPopCircle(ArdMountHolesX + X_MB+(50.8/4), ArdMountHolesY + Y_MB + (15.2/4), holeDia);
  canvas.addPopCircle(ArdMountHolesX + X_MB+(50.8/4), ArdMountHolesY + Y_MB + (43.1/4), holeDia);
  canvas.addPopCircle(ArdMountHolesX + X_MB-(1.3/4), ArdMountHolesY + Y_MB + (48.2/4), holeDia);

  }

  void makeholes(mfab container, float _x, float _y, int _length)
  {
    for (int i = 0; i < _length; i++)
    {
      container.addCircle(_x, _y + i*2, canvas.toGrid(4));
    }
  }

  void draw() {
    drawMFab();
  }


Step 9. Case Assembly



Here you can see we used the glue gun on all 4 corners on the squared piece to attach the support.

Slightly attach the side, so there is a small space for the glue.

Assemble and apply glue on both sides

This is the lock. The small metal piece is only used for support

Use the glue gun on each inner layer you assemble

You can twist one of the squared piece to give it a neat look.

Now use a pliers to wiggle the metal piece loose, and pull it off. Be careful not to damage the lock.

Now you need a washer, 3 bolts and a screw. Also turn the assembled squared inner case upside down

Lay a washer on the hole and insert a screw through it, do this on all the holes that has a square shaped look (NOT the 4 asymmetric holes).

Turn the inner case. Put another washer and tighten the nut.

The second nut is to adjust the height of the joypad.

Repeat

When you mount the joypad make sure the connection pins is facing out.

This can be frustrating. If you raise the joypads too much it will hit the top cover case, and if you lower them too much you will not be able to move the joypads enough to give you an output. When you are done adjusting use the last 8 nuts to fasten the joypads

Connect the joypads if you like, or wait for later

There are 4 asymmetric holes, put your Arduino board on top of them and while holding the board in-place, turn the case

Insert the 4 mounting pins, and push them through the wood and Arduino board.

Turn the case once more and make sure the pins are fasten

Connect the wires on-to the SRF Shield board and plug it on the Arduino board.

It should look like this - depend on the wiring.

Put the frame in place.

While bending the sides, push them slightly inwards until they fall in-place - careful not to break it

Now you can add the lock, and give it a little twist.

Like so

And voilà

We tried to polish our design and I think we did a pretty good job.

And that is it. We might make a new design in transparent acrylic. We will make sure to post a picture if that happens.




This project has been created by Martin Hana & Jakob Thormod.



Keywords: Hackable, Arduino, Joypad, Wireless, Game Controller, Remote, Modifiable

Share on : Twitter, Facebook or Google+