I've fixed a couple of running bugs with the data packet, and I've modified the NXTI2CDevice library to be compatible with Arduino 1.0.
The attached zip file has
1. a new Arduino sketch
2. a new Processing sketch
3. the modified NXTI2CDevice library
You'll still need the Procontroll library in Processing, though.
Greetings, everyone, and welcome to my first instructable!
Today we'll be covering a few major bases to get to the final goal: controlling an Arduino-based robot via a PS3 remote! By the end of this instructable, you'll be able to control the speeds of both NXT motors with the two analog sticks of a PS3 controller.
Here's the idea:
A PS3 communicates via bluetooth to the computer sending the value of its analog sticks to the Processing program. Processing then sends this information as a packet of data to the Arduino bot through the Xbee wireless modules. Lastly, the Arduino board "unpacks" this data packet and interprets it as the speed and direction to drive each motor.
Here are the three basic milestones that we'll cover:
-- using Arduino to control NXT Motors
-- interfacing the Programming Language Processing with a PS3 controller
-- Wireless communication between your computer and Arduino via Xbee modules
If you aren't quite comfortable with either Processing or Arduino's Programming languages--fear not! I've accompanied the project with my source code .
Here's what I'll assume:
-- you're mildly familiar with Arduino, and you can a user-created library to the IDE.
-- your computer has bluetooth-pairing capabilities
-- you can strip a few small wires and you have basic soldering skills.
Here's a few concepts that you'll learn about on the side:
(You don't need to know about these beforehand to get started on this project)
-- Xbee wireless communication
-- i2c communication (between the NXT motors and Arduino)
All right, Let's get started!
Lastly, feel free to check out the video for the final results of this project in action!
Step 1: Materials
I got the hard-to-find (nonLego) pieces from both Sparkfun.com and Mindsensors.com
-- two Mindstorms NXT Motors and two cables
-- Lego Technic Pieces to build your robot Chassis
-- Standard Arduino (I used the UNO. This actually allows me to skip adding pull-up resistors to the analog inputs)
-- 9V batter and 9V battery Clip to power the Arduino. ( We could power it off the motor battery, but I'll hold off on that to keep it simple.)
-- Battery Pack (or other power supply. I'm using a 7.2V NiMH pack)
-- I2C Host Cable with NXT Connector
-- Tape (Gaffer's Tape is probably the least messy, but any tape will do the job)
-- Multiplexer for NXT Motors (this piece gives us the ability to speak to the NXT motors lots of ugly wire snipping)
-- 2 XBee 1mW Wire Antennas (Xbee radios)
-- XBee Explorer USB connector
-- XBee Wireless Shield
-- header pins (longer header pins are a bit more user-friendly)
-- PS3 controller
-- mini USB cable for connecting the Xbee to your computer
-- USB cable to program the Arduino
A bundle of OpenSource Software:
-- The Arduino IDE
-- The NXT Library for speaking to the NXT i2c Motors
(Side note: This NXT Library is a great project all to itself! Check out the man Clinton Blackmore behind the accomplishment at http://robotclub.ab.ca/ )
-- The Processing Language Library called Pro Controll which will allow us to communicate with the PS3 controller.
Final Tools to get the job done:
-- Soldering Iron
-- Exacto knife (or any small-and-precise knife)
-- wire strippers for stripping very thin wire.
Step 2: Connect the PS3 Controller to Your Computer
I'm using a Mac Laptop, but there are many guides to do this. Here's where I found my help:
I first downloaded and installed the driver available here:
Here's the guide that I followed (Many thanks, RandomTechKid!) :
Step 3: Connect the PS3 Controller to Processing
First We'll need to download both Processing and the ProControll Library:
Next, we'll need to connect our PS3 Controller to the computer. On macs, you'll know you're paired when you see the bluetooth symbol change. Check out the image below.
Now that we have both packages, install Processing and unzip the ProControll library.
Processing creates a folder called Processing somewhere in your computer when you install it. (Mine was in Documents.) This is where all of your Processing projects are saved.
In our case, we need to add the ProControll Library to our libraries available to us in Processing.
Create a folder in the Processing Folder called libraries and simply drag the unzipped ProControll library into this folder.
If you have Processing open right now, you'll want to restart it before you can begin using the library that we just added.
Next up: Let's connect that PS3 Controller!
(Ok, this is probably the most intimidating step, but I'll guide you through it.)
The ProControll library has a great set of example code to get us started.
By dragging and dropping the example code from the printDevices() documentation on ProControll's web page, we can see that the PS3 is recognized by Processing.
Here's what you'll need to do:
after running the pringDevices() example code, check to make sure that the name of the PS3 controller is the same as in the Test code that I included. If it is, Great! Move on to the next step!
If not, you'll need to replace the name of the controller with the name that you'll receive after running the printDevices() example code. You'll place this name in the code that I'll give you in the later steps. You'll also need to do the same for the names of the two analog sticks.
(You may want to run the Test code that I included that moves around a square in response to the left PS3 analog stick to see if you've got everything down so far.)
Step 4: Assemble Your Robot Chassis
In this case, I decided not to include instructions on how to build my LegoNXT chassis.
All you'll need to do is create a chassis that runs off of two motors. Each motor drives a wheel on that corresponding side (in my case, a tread).
If you're not too LEGO savvy, no sweat! Check out the gracious providers of many instructions at www.nxtprograms.com for a guide to building a simple chassis:
Here's a really simple one to get you started:
Once you've built that chassis, we'll be mounting a few Arduino components to it in the next step.
Step 5: Assemble the Arduino Hardware
First cut the cable in half! You only need one half in this case.
With an exacto knife, separate the individual strands of the wire.
(Be Gentle! separate them just over an inch apart from each other.)
Next, (Gently) strip the insulation off of each wire except the red one.
From your stack of header pins, give yourself 4 separate individual header pins. Solder the following:
One header pin to the 5V wire
One header pin to the two Ground wires (just twist those two ground wires together)
One header pin to the SCL wire
One header pin to the SDA wire
Insulate all of your solder joints with some tape!
Next: the Arduino assembly
Attach an Xbee radio to the Xbee shield from Sparkfun.
Mount this shield onto the Arduino.
Attach the modded NXT wire to Arduino as follows.
5V goes to the Arduino 5V
Grounds go to the Arduino Gnd
SCL goes to Arduino's analog pin 5
SDA goes to Arduino's analog pin 4
(For the last two connections, you'll have to twist the NXT wire because the wire connections are reversed.)
Next: connect the mindsensors multiplexor to the Arduino. Insert it into the NXT socket because our Arduino is "mimicking" the NXT by speaking in the i2c protocol that the NXT uses to communicate to the motors.
connect the motor chassis motor cables in the corresponding M1 and M2 connections. If you find that you're controlling the motor that doesn't correlate to the correct analog stick, simply switch the connections here in the future.
From here on out: Simply mount everything onto the chassis! (I used Gaffers Tape here.)
Step 6: Add the NXT Library to the Arduino IDE
From here, you'll want to install the Arduino IDE first, if you haven't already.
Next, create a folder called libraries in the Arduino Directory. (This is just like what we did for Processing and the ProControll library, so I wont cover it as "in-depth" with all of the detailed pictures.)
Simply drag'n'drop the NXTI2CDevice folder into this libraries folder in the Arduino IDE.
Step 7: Connect the Xbees
here's another tutorial for the same idea:
Ok, when we have two paired Xbees, we can now mimick a hard wire serial communication from the computer to your Arduino.
Step 8: Download, Run, and Our Summary
Upload that Arduino sketch onto your Arduino bot!
NOTE: when you upload this code, make sure that you switch the little switch on the Sparkfun shield to the DLINE setting. When you want to run the code, though, switch the little switch back to the UART setting.
Download the Processing Sketch that I also included.
Here we go!
First mount the other Xbee radio onto the explorer and connect it to the computer.
Then Pair the PS3 controller.
Then run the Processing Sketch.
Then connect the NXT motors to their battery and connect the Arduino to it's 9v battery.
(Make sure you're switch is set to UART)
Enjoy the analog control of your NXT project!
Here's what we've done:
We've interfaced the NXT motors with the Arduino using ONLY Two pins!
We've interfaced a PS3 controller with Processing!
We've succeeded in wireless communication between the computer and Arduino.
We've successfully achieved analog control of two NXT motors via remote control!
Thanks for coming this far! You've done many things to get here! I'd appreciate any feedback you can give, whether they be questions... comments... (ok, ok, snide remarks too, as long as I can improve myself from here).