ROS Chess Robot Arm: Part 1
Authors: Vikram Singh, Dan Donato
Our goal with this project is to develop a modular robotic system to play chess and possibly other board games. We will be using Robotics Operating System (ROS) with Python.
Hardware
- UARM Swift
Software Libraries/Packages
We will be using a couple of libraries in our implementation.
- MoveIt: Manipulator API. API to manipulate the robot arm.
- Python Chess: Python Chess Engine. Maintains the match of chess and can determine moves to perform.
- Gazebo: World Simulation. We can simulate the chessboard and the robot arm interactions prior to testing it with a physical arm.
Nodes and Messages
Our design of this project will consist of a set of nodes and messages to facilitate a match of chess.
Nodes:
- Chess Node: Coordinates a match of chess with player nodes. Determines and manages the state of the board (Player Turn, Win Condition, etc).
- Player Node: Represents a player in the chess match. Determines which move to perform and publishes messages to the robot arms to move the chess pieces.
- Robot Arm Node: Node for the robot arm. Subscribes to move messages to determine where to move pieces on the board. This node is responsible for communicating with the robot arm.
Messages:
- Turn Message: Message indicating to the player nodes to take their turn. Both player nodes in the match will be subscribed to this message. The message should consist of a player indicator and the chessboard. The player indicator allows the player node to distinguish whether or not it is their turn. The chessboard allows the player node to decide on what move they want to make.
- Piece Move Message: Message indicating which piece should be move. The player nodes, upon receiving their turn message, will decide which piece to move and publish this message. This message should consist of the grid coordinates of the chess piece to move, the grid coordinates of the location it should be placed.
This set of messages and nodes should be sufficient to facilitate a match of chess.
Anticipated Issues
There are a couple of issues we have to address during our development.
Picking up chess pieces:
Chess pieces are very irregular. There is very little in common between each of the different pieces. In order to simplify our robot arm, we will consider each piece to be a cylinder of fixed radius. We will chose a cylinder whose radius corresponds to the piece with the “largest radius” and the height will correspond to the shortest piece.
We will also affix some padding to the arm gripper in order to provide a solid grip on the irregular surface.
Loss of height based off distance:
As a chess piece moves farther away from the base of the robot arm, the heights the arm can move the piece decreases. We have two methods to solve this issue.
- Place the robot arm at a much higher plane than the pieces. When we move pieces around the board, we lift the pieces up in height to prevent knocking down other pieces. By placing the arm above the chess pieces, the span the arm can move the pieces without knocking over all the other pieces is increased.
- Have two robot arms communicate with each other to move pieces around the board. A piece can be accessible by at least one arm. If a piece is at the span of one arm, it should not be at the span of the other arm. Having the two robot arms coordinate a piece movement will be required.
Project Roadmap:
Week 1:
- Model the Chessboard and robot arms with Gazebo
- Construct Robot arm nodes to move chess pieces from one square to another through simulation
- Construct a Chess node which communicates with player and robot arm nodes to coordinate simulated match of chess
Week 2:
- Use the robot arm nodes with the physical robot arms
- Test and debug the physical system
