The project aims at designing and implementing a micro controller based system to control a robot while enabling the robot to learn about its environment on the fly i.e. without prior training and user intervention. The controller offers a set of commands for moving the robot in different directions and performing simple tasks like picking up and moving small things. The robot can learn about its environment either by randomly moving about on its own or by receiving commands from a user and executing them. Initially, when the robot is new to its environment, it tries to avoid any obstacles that it encounters during movement by a ‘Blind Man’ approach. If, the robot succeeds in getting around an obstacle in this way, it remembers the position at which it encountered the obstacle and the moves it had to carry out in order to overcome it and passes on this information to a backend program to train a neural network with that data. The robot then relies on the neural network in case of future difficulties and falls back on the ‘blind approach’ only when the network fails to provide an appropriate solution to its problem. In such cases, the robot causes the network to be trained again with the fresh data.
How the robot builds a model of its environment:
The backend program that helps the robot actually creates and trains a set of neural networks, each corresponding to a ’Zone’ in the robot’s environment. Each network is responsible to learn the positions of obstacles in that zone and the sequence of moves that would help the robot to get around that obstacle. Whenever the robot encounters an obstacle it contacts the program in the background that would evaluate the positions of the motors and determine the zone into which the obstacle falls. Then, it activates the corresponding network and gives the output of the network back to the robot. If no network exists yet for that zone, (which is the case when the robot starts anew), the program declares failure. In this case, or when the solution provided by the network fails to pull the robot out of its trouble, the robot proceeds to solve its problem on its own. When it finds a solution, it notifies the program that would then train the corresponding network by creating one if it doesn’t exist. In the event of the robot’s failure to find a solution to its problem, it gives up and waits for user intervention. As the robot gathers more and more data, it eventually builds a whole tree of neural networks storing the information about all the obstacles in its environment.
The system is going to be Intel 8051 based, capable of controlling six motors and an equal number of sensors. Each sensor is associated with one motor in such a way that the sensor would detect any obstacles in that motor’s path and inform the controller when the motor actually encounters one. The commands it offers will be to move the robot in the horizontal direction, vertical direction and to pick up or release some thing. The moves can be absolute, giving a position to go to, or relative, to move the robot by a fixed distance from the current position. When the controller receives a command, it attempts to finish the move while monitoring the sensors for an obstacle. In case it encounters one, it immediately enters the recovery mode, in which it attempts to overcome the obstacle and finish the unfinished move. In the recovery mode, it first contacts the backend program running on a pc, presenting to it, the positions of all of its motors at the time the obstacle was encountered. If the program comes up with a solution, the controller tries that. In case the program declares failure because a network for the zone in which the obstacle was encountered does not exist yet, or in case the solution given by the program fails, it attempts a recovery on its own using the blind man’s approach. The communication between the controller and its backend is going to take place over its serial port. The neural networks are created and trained using nql scripts. The back end itself is to be written in java. The back end offers an easy to use interface to the user for controlling the robot and also maintains the link between the neural networks and the controller.
The controller is ready with all its routines to control the robot and to recover from any obstacles that it encounters. The neural network part is also complete with all the necessary nql scripts ready. The whole thing is currently being tested to obtain some real results as to the ability of the robot to learn and maintain a picture of its environment. Visit this page again for the results.
The user interface and all related programs for communication between the controller and the host computer are to be written. And any bugs that surface in the ongoing tests are to be corrected and refinements made to the entire code to improve its functioning.
Soon to come: Some pictures of the robot that we are working on.
The entire area surrounding the robot is divided into a number of zones, each identifying a plane of motion of the robot, characterized by a range of positions of one or more motors that control the movement of the robot in that plane. For example, the area between position 0 and 200 of the motor governing the horizontal motion of the robot could be designated as the “leftmost” zone, that falling between position 200 to 500 the “left” zone and so on. A similar division is done in the vertical plane based on the positions of the motors governing the vertical motion of the robot. In fact, this division could be made in any number of dimensions in which the robot is capable of moving and the interpretation is purely logical. Such a classification enables the robot to place an obstacle in any of the possible combination of the zones such as “leftmosttopmost” or “lefttop” depending on the positions of all the motors. Some fuzziness may also be incorporated into the evaluation of the positions.