Arduino Game Controller

This Arduino Game Controller Project is an extension of my Mechatronics Final Year Project. It’s my Arduino Glove that I am using to control the video game. So before you continue it’s good too check my Mechatronics Final Year Project in order to see how the device works and how it’s made.

Here I will explain in details how I programmed the Arduino board using the Processing IDE to enable the control of the video game. Watch the video below to see the Arduino Game Controller in Action playing Need For Speed.

https://www.youtube.com/watch?v=6HfvNa7VteY

How It Works

This is how Arduino Game Controller works:

• The sensors of the glove capture the movements of the arm.
• The captured values are sent into the Arduino board Analog Inputs.
• From the Arduino they are sent to the Processing IDE via Serial Communication.
• From the Processing IDE they are sent to the video game.

Arduino IDE

First I programmed the Arduino board using the Arduino IDE to work as a server that would continuously run on the Arduino board. That code enables the Serial Communication between the Arduino board and the Processing IDE.

Here is the Source Code:

/*  
 *  Arduino Game Controller
 *  
 *  Crated by Dejan Nedelkovski,
 *   www.HowToMechatronics.com 
 *   
 */

// Defining variables

int pinX=A8;
int pinY=A7;
int pinZ=A6;
int pinA0=A0;
int pinA4=A4;
int pinA3=A3;
int pinA1=A1;
int pinA2=A2;

void setup() 
{
  Serial.begin(115200);     // starts the serial communication
}

void loop()
{
  int valX=analogRead(pinX);     // reads the Analog Input, t.e the value from the X - axis from the accelerometer
  Serial.print(valX);     // sends that value into the Serial Port
  Serial.print(",");     // sends addition character right next to the read value needed  later in the Processing IDE for indexing
   
  int valY=analogRead(pinY);
  Serial.print(valY);
  Serial.print("/");
  
  int valZ=analogRead(pinZ);
  Serial.print(valZ);
  Serial.print(";");
  
  int valA0=analogRead(pinA0);
  Serial.print(valA0);
  Serial.print(":");
  
  int valA4=analogRead(pinA4);
  Serial.print(valA4);
  Serial.print("<");
  
  int valA3=analogRead(pinA3);
  Serial.print(valA3);
  Serial.print("!");
  
  int valA2=analogRead(pinA2);
  Serial.print(valA2);
  Serial.print("?");
  
  int valA1=analogRead(pinA1);
  Serial.print(valA1);
  Serial.print(".");
  
  delay(30);
  
}Code language: Arduino (arduino)

From the code above you can see that I am using the AnalogRead() function to read the values from the Accelerometer for the orientation of the arm (3 variables) and the Potentiometers for the position of the fingers (5 variables). Now these values are being sent via the Serial Port to the Processing IDE. Also right after each variable I send a specific character to the Processing IDE using the Serial,print() function which will work as an Index.

So when I have the glove connected to the computer I will continuously send the above (picture above) line of data through the Serial Port. The numbers are values from the sensors and the characters are for indexing them which will help when receiving them in the Processing IDE. Note: The numbers are just for example, they can varies according to your sensors readings.

Processing IDE

Now I had to receive the data coming from the Serial Port into Processing IDE and according to them send commands to the video game. For that, I developed the code below and this is how it works:

• First it read the data from the Serial Port.
• It separates that data into variables from each sensor.
• According to the values from each sensors it simulates keyboard key press or release which actually are controlling the video game.

Go trough the code and find detailed explanations for a specific functions and lines of codes in the comments of the code.

Note: The values in the code are set according to my readings from my sensors. You should adjust them according to your readings. Also for explanation in the comments of the code I am using the values from the picture above, which are just example numbers.

/* 
* Arduino Game Controller Project
* 
* Crated by Dejan Nedelkovski,
* www.HowToMechatronics.com 
* 
*/

import processing.serial.*; // imports library for serial communication
import java.awt.Robot; // imports library for key press or release simulation
import java.awt.event.KeyEvent; // imports library for reading the data from the serial port
import java.io.IOException;

Serial port; // defines Object Serial
Robot robot; // defines Object Robot

//defining variables

String X= "";
String Y= "";
String Z= "";
String A0= "";
String A1= "";
String A2= "";
String A3= "";
String A4= "";
String data= "";
int index=0;
int index2=0;
int index3=0;
int index4=0;
int index5=0;
int index6=0;
int index7=0;
int iX=0;
int iY=0;
int iZ=0;
int iA0=0;
int iA1=0;
int iA2=0;
int iA3=0;
int iA4=0;

// creates new robot object

void setup()
{

try 
{
robot = new Robot();
}
catch (Exception e) {
e.printStackTrace();
exit();
}

delay(2000);
size (800, 800);
port = new Serial(this,"COM3", 115200); // starts the serial communication
port.bufferUntil('.'); // reads the data from the serial port up to the character '.'. So actually it reads this: 215,214/141;315:314<316!314?315.
}

void draw()
{

background(0,0,0);
fill(255, 255, 255);

//Simulating key press or release

// turn left

if(iX>320)
{ 
delay(40);
robot.keyPress(KeyEvent.VK_J); // Simulates "I" key press if the value from the accelerometer for the X axis is greater than 320 
}

if(iX<=320){
delay(40);
robot.keyRelease(KeyEvent.VK_J); // Simulates "I" key release if the value from the accelerometer for the X axis is less than 320 
}

// turn right

if( iX<280 ) 
{
delay(40);
robot.keyPress(KeyEvent.VK_L); 
}

if(iX>=280){
delay(40);
robot.keyRelease(KeyEvent.VK_L);
}

// turn up

if(iY>320)
{
delay(40);
robot.keyPress(KeyEvent.VK_I); 
}

if(iY<=320){
delay(40);
robot.keyRelease(KeyEvent.VK_I);
}

// turn down

if( iY<280 ) 
{
delay(40);
robot.keyPress(KeyEvent.VK_K);
}
if(iY>=280){
delay(40);
robot.keyRelease(KeyEvent.VK_K);
}

// accelerate - indexFinger

if( iA4<510 ) 
{
delay(40);
robot.keyPress(KeyEvent.VK_W); 
}

if(iA4>=510){
robot.keyRelease(KeyEvent.VK_W);
}

// handbrake - thumbFinger

if( iA0<500 ) 
{
robot.keyPress(KeyEvent.VK_SPACE);
}

if(iA0>=500){
robot.keyRelease(KeyEvent.VK_SPACE);
}

// reverse - middleFinger

if( iA3<560 ) 
{
robot.keyPress(KeyEvent.VK_S); 
}
if(iA3>=560){
robot.keyRelease(KeyEvent.VK_S);
}

// shift up - ringFinger

if( iA2<400 ) 
{
robot.keyPress(KeyEvent.VK_R); 
}

if(iA2>=400){
robot.keyRelease(KeyEvent.VK_R);
}

// shift down - littleFinger

if( iA1<250 ) 
{
robot.keyPress(KeyEvent.VK_F);
}

if(iA1>=250){
robot.keyRelease(KeyEvent.VK_F);
}

}

// Reading data from the Serial Port

void serialEvent (Serial port) // starts reading data from the Serial Port
{

data = port.readStringUntil('.'); // reads the data from the serial port up to the character '.' and it sets that into the String variable "data". So actually it reads this: 215,214/141;315:314<316!314?315.
data = data.substring(0,data.length()-1); // it removes the '.' from the previous read. So this will be the String "data" variable: 215,214/141;315:314<316!314?315

// Finding the indexes in the data and setting the variables from the sensors by taking from the String "data" the appropriate values that are between the characters in the "data" String

index = data.indexOf(","); // finds the index of the character "," from the String "data" variable
X= data.substring(0, index); // sets into the variable X the string from position 0 of the hole string to where the index was. That would mean that read will be : 215

index2 = data.indexOf("/"); // finds the index of the character "/" from the String "data" variable 
Y= data.substring(index+1, index2); // sets into the variable Y data the string from position where the character "," was +1, to where the index2 was. That would mean that the read will be: 214

// We keep reading this way and that's how we get only the numbers, the values from the sensors coming from the serial port.

index3 = data.indexOf(";");
Z= data.substring(index2+1, index3);

index4 = data.indexOf(":");
A0= data.substring(index3+1, index4);

index5 = data.indexOf("<");
A4= data.substring(index4+1, index5);

index6 = data.indexOf("!");
A3= data.substring(index5+1, index6);

index7 = data.indexOf("?");
A2= data.substring(index6+1, index7);

A1= data.substring(index7+1, data.length());

// Converting the String variables values into Integer values needed for the if statements above

iX= int(X);
iY= int(Y);
iZ= int(Z);
iA0= int(A0);
iA4= int(A4);
iA1= int(A1);
iA2= int(A2);
iA3= int(A3);
}
Code language: Arduino (arduino)

Feel free to ask any question in the comments section below.