There is an Instructable that documents how to control an OWI Arm with an Arduino and a motor shield. I think this is far too complicated. I recently ordered some jumper wires and will attempt to control the arm with the Arduino by wiring it in as the controller and not by connecting the motors to some sort of motor shield or transistor network. I think this will give me the same controls as in the Instructable but will use the electronics board in the arm instead of the Arduino. Perhaps this will also use fewer pins on the Arduino.
One of the drawbacks of using a OWI arm is that is uses DC motors and not servos or stepper motors. This means that I need to figure out some way to determine how far the arms have moved. I could calibrate the time it takes to move each motor to various distances, but this will not account for drift in the motors or variations in the power given to the motors from the ever-draining D batteries. An ingenious solution to the distance measurement problem is found by using infrared sensors to measure to rotation of a gear in each gearbox. I have obtained sensors, but I still need to modify the gears and gear boxes so the sensors fit. I'm not sure if this will be less work than making a robotic arm with servos, but I think it will be less expensive in the long run. I have attached some photos of the gear box and the position of the opto coupler. I need to cut some of the plastic in the gearbox so the slit in the optical sensor is in the same plane as the gear. I will detail the process of installing and wiring the opto coupling system as I complete it. I want to demonstrate the Arduino control first after the jumper wires arrive this week.
The other day, I ordered an OWI Robotic Arm from Amazon. It is by far the least expensive robotic arm I have seen. I also purchased a standard double-weight tournament-style travel chess board from my local gaming store. It's pretty much this. The OWI arm has a large range of motion and the motors provide enough torque to lift the heaviest even at full extension. I took a little video of my using the arm with the remote control to move a queen around. As you can see, I am still having trouble figuring out the controls. Also, you can hear my kids making some craft ghosts for Halloween in the background.
I have completed a Python program that uses the Stockfish chess engine with rules governed by the ChessBoard Python module. The code allows the user to choose whether to play black or white, has an adjustable skill level, and lets the chess engine look 15 moves deep. The program will also check the legality of each move made and accounts for special moves such as en passant, castling, and pawn promotion. It also checks for stalemates, the 50 move rule, and the three move repetition rule. In its current iteration, the program prints out the board after each move to make sure it is working correctly. Here is a copy of the program for Python 2.7. You must have the Stockfish engine installed as well as the ChessBoard module with the code pointed to the appropriate places. Moves must be entered in algebraic notation with quotes. For example, a typical opening move may be 'e2e4', castling may be 'e1g1', a pawn promotion may be 'e7e8q', and en passant may look like 'e5d6'.
I have had it in my head for a while to build a robotic chess board, a chess board where I play against a computer that controls a robotic arm of some sort that moves real pieces on a real board. The "thinking" will be done on a Raspberry Pi computer, which I bought this week as a graduate gift to myself for having finished my PhD program. The arm will be controlled by an Arduino microcontroller. I have already learned how to get Arduino and Raspberry Pi to communicate with each other by reading Simon Monk's nice book Programming the Raspberry Pi: Getting Started with Python. The Arduino and Raspberry Pi communicate nicely though the serial port using the PySerial package. I have tested this out and it works wonderfully. I must write the Arduino code on my Mac though because the Arduino software released for the Linux Debian operating system is a very old version.
For the chess engine, I have decided to use Stockfish, which uses the Universal Chess Interface. It is consistently rate one of the strongest chess engines. The creators of Stockfish have not provided any documentation for their engine, and the Universal Chess Interface was nontrivial to decipher. Therefore, it took me some time to figure out how to communicate with Stockfish through the terminal.
Tonight, I was able to write a proof-of-concept Python program which let me play chess with Stockfish through the Python shell. This is the first step in writing the software for a USB chessboard. I have included the Python code below. Of course, the Stockfish engine must be installed first.
#This code talks to the Stockfish Chess Engine. Entries are to be made in algebraic
#chess notation (eg. e2e4). Stockfish is set to think for a maximum of 1 sec.
chess = r'/Applications/stockfish-4-mac/Mac/stockfish-4-64'.split()['linux' in sys.platform]
import subprocess as S
getprompt = 'isready'
proc= S.Popen(chess, stdin=S.PIPE, stdout=S.PIPE, bufsize=1, universal_newlines=True)
while True :
text = proc.stdout.readline().strip()
if text == "uciok":
print('Choose skill level (0-20):')
proc.stdin.write('setoption name Skill Level value '+skillLevel+'\n')
moveList='position startpos moves '
proc.stdin.write('go movetime 1000\n')
while True :
text = proc.stdout.readline().strip()
if text[0:8] == 'bestmove':