Code:
#include <SoftwareSerial.h>
#include <MeetAndroid.h>
#include <Servo.h>

void stringValue(byte flag, byte numOfValues){}

Want to build this project? View my step-by-step Instructable at http://www.instructables.com/id/Control-Keyboard-Mouse-w-Android-app-via-Arduin/.

1. First steps :’)

2. Programmed (pre-determined) turns

3. Simple turns with custom Android app over Bluetooth

4. Avoiding object with a PING))) ultrasonic sensor

5. Robot’s perspective while avoiding objects

6. Choosing which way to turn (based on distance)

Wiring

There’s only one +5V pin on the Arduino (UNO). You’ll need to use the power rail(s) on a breadboard and some extra jumper wires in order to provide power from the Arduino to the 2 servos and the NES controller. Other than that, you’ll hook up the parts normally.

2 Servos and NES controller wired to an Arduino (a mess)

Code

#include <NESpad.h>
#include <Servo.h>

}

Video

Parts

• Hobby/Micro Servo (HiTec HS-322HD is used in this post)
• 3 Jumper Wires (red, black, & yellow)
• Arduino
• USB cable (A to B)

Steps

1. Typical (hobby) servos have 3 wires with a female header at the end. Insert a jumper wire into each of the header pins.
2. Hook the RED wire up to +5V on the Arduino and hook up the BLACK wire to GROUND on the Arduino.
3. The YELLOW wire is for data. Hook it up to a Digital Pin (8) on the Arduino.


A servo wired to an Arduino

4. The servo library included in the Arduino IDE makes controlling servos very simple. Just include the servo library header file, declare a Servo object, attach your servo to a pin in the setup, then call the ‘write’ method on your servo object in order to change the servo’s position (rotation) Note: Remember to delay for at least 15ms after calling the ‘write’ method to give the servo time to move.
5. Connect the Arduino to your computer with a USB cable (A to B) and upload the code below. Or, just simply go to File > Examples > Servo > Sweep in the Arduino IDE (same as below).

Code

#include <Servo.h>

void loop()
{
for(pos = 0; pos < 180; pos += 1) // goes from 0 degrees to 180 degrees
{ // in steps of 1 degree
myservo.write(pos); // tell servo to go to position in variable 'pos'
delay(15); // waits 15ms for the servo to reach the position
}
for(pos = 180; pos>=1; pos-=1) // goes from 180 degrees to 0 degrees
{
myservo.write(pos); // tell servo to go to position in variable 'pos'
delay(15); // waits 15ms for the servo to reach the position
}
}

A Step Further

If you’ve read my previous post, Hack a Nintendo (NES) Controller, you can now combine your knowledge to control servos with a NES controller. See the video below from my YouTube channel.

Code From Video

#include <NESpad.h>
#include <Servo.h>

}

Parts

• Nintendo (NES) Controller
• 5 Jumper Wires (red, black, white, orange, & yellow)
• Arduino
• USB cable (A to B)

Steps

1. Before you begin, see the diagram showing the Nintendo pin-out below. (Pinouts.ru is also a great source)


Pin-out for an NES Controller

2. Now that you understand the pins on the Nintendo controller, hook up your jumper wires by using arrow’s colors from the photo above. (Note: The pins are fairly deep, be sure that your wires are deep enough and snug to insure a strong connection)
3. As for the other ends of the wires, place the RED wire from +5V on the Nintendo controller to 5V on the Arduino. Place the BLACK wire from GROUND on the NES controller to GROUND on the Arduino. Pretty straight forward.
4. Place the ORANGE wire from STROBE on the NES controller to Digital Pin 2 on the Arduino.
5. Place the WHITE wire from CLOCK on the NES controller to Digital Pin 3 on the Arduino.
6. Place the YELLOW wire from DATA on the NES controller to Digital Pin 4 on the Arduino.


NES controller wired to Arduino

7. Download the NESpad_1.3 library by rahjix. Unzip the folder into your “libraries” folder within your Arduino projects folder (ie. …/Documents/Arduino/libraries). If this is your first library, you may need to create a “libraries” folder, as I did. This handy library will do all the hard work dealing with the pulses, enabling you to simply check for Boolean values such as “NES_A” rather than dealing with binary. Besides, why reinvent the wheel?
8. To be sure you installed the library correctly, restart your Arduino software and go to “Sketch > Import Library” and make sure NESpad is on the list.


Import the NES Library after installation

9. Copy & paste the following code into the Arduino software:

#include <NESpad.h>

// put your own strobe/clock/data pin numbers here -- see the pinout in readme.txt
NESpad nintendo = NESpad(2,3,4);

byte state = 0;

/* A button gets marked as true as soon as it is pressed. That way
we know to not "press" it again */
boolean a = false; //A Button
boolean b = false; //B Button
boolean u = false; //Up Button
boolean d = false; //Down Button
boolean l = false; //Left Button
boolean r = false; //Right Button
boolean s = false; //Start Button
boolean e = false; //Select Button

/* We will pass on this array whenever a key is released. Once the
key is released we will turn that 0 into a 1. That way in our java program
we will know exactly which keys we just released. The keys will always go
in this order: a,b,u,d, l,r,s,e */
int keysReleased[] = {
0,0,0,0, 0,0,0,0};

/* We will set this to true only when a button has been released. This will
stop us from sending the keysReleased array every loop to our java robot */
boolean isReleased = false;

void setup() {
Serial.begin(9600);
}

void loop() {

delay(5);

state = nintendo.buttons();

// A
if (state & NES_A){
if(!a){
a = true; //Make sure the button is only pressed once
Serial.println('A'); //Print the button to be picked up by our robot
}
}
//Key might have been released so we check and if so change the
//value in our released array
else if (a == true){
a = false;
keysReleased[0] = 1;
isReleased = true;
}

// B
if (state & NES_B){
if(!b){
b = true; //Make sure the button is only pressed once
Serial.println('B'); //Print the button to be picked up by our robot
}
}
//Key might have been released so we check and if so change the
//value in our released array
else if (b == true){
b = false;
keysReleased[1] = 1;
isReleased = true;
}

// Up
if (state & NES_UP){
if(!u){
u = true; //Make sure the button is only pressed once
Serial.println('U'); //Print the button to be picked up by our robot
}
}
//Key might have been released so we check and if so change the
//value in our released array
else if (u == true){
u = false;
keysReleased[2] = 1;
isReleased = true;
}

// Down
if (state & NES_DOWN){
if(!d){
d = true; //Make sure the button is only pressed once
Serial.println('D'); //Print the button to be picked up by our robot
}
}
//Key might have been released so we check and if so change the
//value in our released array
else if (d == true){
d = false;
keysReleased[3] = 1;
isReleased = true;
}

// Left
if (state & NES_LEFT){
if(!l){
l = true; //Make sure the button is only pressed once
Serial.println('L'); //Print the button to be picked up by our robot
}
}
//Key might have been released so we check and if so change the
//value in our released array
else if (l == true){
l = false;
keysReleased[4] = 1;
isReleased = true;
}

//Right
if (state & NES_RIGHT){
if(!r){
r = true; //Make sure the button is only pressed once
Serial.println('R'); //Print the button to be picked up by our robot
}
}
//Key might have been released so we check and if so change the
//value in our released array
else if (r == true){
r = false;
keysReleased[5] = 1;
isReleased = true;
}

//Start
if (state & NES_START){
if(!s){
s = true; //Make sure the button is only pressed once
Serial.println('S'); //Print the button to be picked up by our robot
}
}
//Key might have been released so we check and if so change the
//value in our released array
else if (s == true){
s = false;
keysReleased[6] = 1;
isReleased = true;
}

//Select
if (state & NES_SELECT){
if(!e){
e = true; //Make sure the button is only pressed once
Serial.println('E'); //Print the button to be picked up by our robot
}
}
//Key might have been released so we check and if so change the
//value in our released array
else if (e == true){
e = false;
keysReleased[7] = 1;
isReleased = true;
}

/* If a key has been released then our java robot needs to know about it. So what we
are going to do is to iterate over our array if a key has been released and print out the
position in the array of that key. So for example if "Up" has been released we will
see that our array looks like this [0,0,1,0, 0,0,0,0]. So then we will print 2 to the java robot
so it knows that "Up" has been released. Likewise we would print 7 for the start button on release. */
if(isReleased){
isReleased = false; //Reset the boolean
for(int i=0; i < 8; i++){
if(keysReleased[i] == 1){
keysReleased[i] = 0; //Reset the button listener
Serial.println(i);
}
}
}
}

10. Connect the Arduino to your computer via the USB cable (A to B) and upload the code to your board.
11. Once uploaded, open up the Serial Monitor within the Arduino Software. Notice when a button on the NES controller is PRESSED, the corresponding letter is printed to the monitor. (Note: If you’re getting very sporadic results, such as a bunch of letters and numbers rapdily filling the Serial Monitor, you most likely have a lose connection between your wire(s) and the NES controller’s pins. Be sure they are tight enough.)

Explanation

When a button is RELEASED, a unique number is displayed for each button. This number corresponds to the buttons position in the array that holds the binary number received from the NES controller. In other words, the Arduino is receiving 8-bit binary numbers from the the NES controller, ie. 10000100. The order is as follows: A, B, Up, Down, Left, Right, Start, Select. 1 stands for an “on” bit (button pressed), and 0 stands for an “off” bit (button NOT pressed); therefore, in the example 10000100, the ‘A’ and ‘Right’ buttons are pressed. Now the numbers that display after a button is released should make sense. When the ‘A’ button is PRESSED, ‘A’ is printed to the Serial Monitor. Once ‘A’ is RELEASED, ’0′ is printed to the Serial Monitor (since arrays start at 0 and ‘A’ is the first bit). Feel free to modify the code to something possibly more useful, such as an uppercase letter (A) when pressed and a lowercase letter (a) when released for example.

Video

A Step Further

More posts coming soon detailing possible uses for this knowledge. Until then, you can view my NES/Arduino projects on my YouTube channel.

Parts

• Memsic 2125 dual-axis accelerometer ($30)
• 4 Jumper Wires (yellow, orange, red & black)
• Breadboard
• Arduino
• USB cable (A to B)

Steps

1. The Memsic 2125 accelerometer has 6 leads. Place it into your breadboard, over the gap to prevent a short. I will referring to the leads assuming that the accelerometer is rotated so that you can read “Mx2125″ normally on the mini pcb. Make sure you don’t have it upside-down. You can find specs here.
2. The UPPER-RIGHT lead is positive and should be wired (red) to 5V on the Arduino.
3. The LOWER-LEFT lead is negative and should be wired (black) to Ground on the Arduino.
4. The MIDDLE pin on the RIGHT will provide the X values and should be wired (yellow) to a Digital Pin (8) on the Arduino.
5. The MIDDLE pin on the LEFT will provide the Y values and should be wired (orange) to a Digital Pin (9) on the Arduino.


Memsic 2125 Dual Axis Accelerometer wired up.

6. Connect the Arduino to your computer with the USB cable (A to B).
7. The code below simply reads in the X and Y of the accelerometer and outputs those values to the Serial Monitor within the Arduino software. Once uploaded to your board, open the Serial Monitor. You should be able to tilt the accelerometer and see the respective X and Y values change.

Code

const int xPin = 8; // X input from accelerometer
const int yPin = 9; // Y input accelerometer

int xPulse, yPulse; // read from accelerometer
int xVal, yVal; // converted value

void setup() {
Serial.begin(9600);
pinMode(xPin, INPUT);
pinMode(yPin, INPUT);
}

Serial.print(xVal);
Serial.print("\t");
Serial.print(yVal);
Serial.println()


delay(100);
}

Conclusion

Now that the values are being read in properly, it becomes easy to integrate for your own purpose by using basic if-else statements and comparison operators.

• Photo Resistor
• Resistor (10k)
• 3 Jumper wires (yellow, red & black)
• Breadboard
• Arduino
• USB cable (A to B)

Steps

1. A typical photo resistor has 2 leads. Choose one lead to be positive and one lead to be negative. Place it on the breadboard.
2. Place a (yellow) wire in the same row as the positive lead and wire it to an Analog pin (0) on the Arduino. Leave room for 1 lead of a resistor.
3. Place a one lead of a (10k) resistor in between the (yellow) wire to the analog pin and the positive lead of the photo resistor.
4. Place the other lead of the (10k) resistor a few rows up/down and wire (red) it to 5V on the Arduino.
5. Place a (black) wire in the same row as the negative lead of the photo resistor and wire it to Ground on the Arduino.


A photo resistor wired up.

6. Connect the Arduino to your computer with the USB cable (A to B).
7. The code below simply reads in the value of the photo resistor and outputs that value to the Serial Monitor within the Arduino software. Note: With the lights on, mine reads a value around 250. With the lights off, mine reads a value around 900.

Code

int lightPin = 0;

void loop()
{
Serial.println(analogRead(lightPin));
delay(100);
}

Parts

• Buzzer
• 2 Jumper Wires (yellow & black)
• Breadboard
• Arduino
• USB cable (A to B)

Steps

1. A typical (piezo) buzzer has 2 leads. To no surprise, 1 is positive and 1 is negative. These should be labeled on and/or under the buzzer.
2. Place it on you breadboard and place a (yellow) wire from the positive lead to a digital pin (4).
3. Place a (black) wire from the negative lead to a ground pin.


A buzzer wired up.

4. Connect the Arduino to your computer using the USB cable (A to B).
5. The code below will repeatedly turn the buzzer on HIGH and LOW (on and off) with 2000 microseconds intervals, which is 2 milliseconds or 0.002 seconds. Upload it to your board and enjoy the constant low tone.

Code

int buzzPin = 2;

void setup()
{
pinMode(buzzPin, OUTPUT);
}


void loop()
{
digitalWrite(buzzPin, HIGH);
delayMicroseconds(2000);
digitalWrite(buzzPin, LOW);
delayMicroseconds(2000);
}

Explanation

Turning the buzzer on and off rapidly causes the buzzer to vibrate and make sound. While the above code is looping infinitely, using a for loop will give you more control over the duration. You’ll want to loop it at least a couple dozen times for a brief (1-2 second) sound.

• Soft Pot
• 3 Jumper wires (yellow, red & black)
• Breadboard
• Arduino
• USB cable (A to B)

If you’ve already read my post on How to Hook Up A Potentiometer, then all you need to know is which lead is which (You can even use the same code). See step 1 below.

Steps

1. A typical soft pot has 3 leads. Like a regular potentiometer, the outer leads are for power and the middle lead is for the value. However, unlike a regular potentiometer, the outer leads are predetermined as positive and negative. On my soft pot (by Spectra Symbol), the film is clear and you can see the traces from the leads. The one that traces all the way to the opposite end of the leads is positive. Obviously, the other one is negative.
2. With each lead in separate rows on the breadboard, place (red) wire from the positive lead of the soft pot to a 5V pin on the Arduino.
3. Place (black) wire from the negative lead of the soft pot to a Ground pin on the Arduino.
4. Place (yellow) wire from the middle lead of the soft pot to an Analog pin (0) on the Arduino.


A soft pot wired up.

5. Connect the Arduino to your computer using the USB cable (A to B).
6. The code below reads in the value of the soft pot’s pin and prints it to the Serial Monitor (within the Arduino software). Upload it to your board. Lay the soft pot on a firm, flat surface and slowly slide your finger up and down while watching the values change in the Serial Monitor.

Code

int softPot = 0;

void loop()
{
Serial.println(analogRead(softPot));
delay(100);
}

Explanation

The soft pot works by changing the resistance depending on where pressure is positioned along the strip. For more information: http://www.spectrasymbol.com/how-it-works-softpot