ABSTRACT

The objective of the project is to solve the classic problem of maze solving by using distributed robotics. Two micro mice need to be designed to negotiate a path to the center of a maze in the optimal amount of time. For this purpose an algorithm needs to be developed which allows the two of them to work in parallel and reduce redundant mapping by communicating and sharing information with each other and aiding each other to reach the centre. The design must integrate a microcontroller, sensors, motors and communication modules. This thesis presents the current design and interface of the different modules as well as preliminary data related to the performance of the micro mouse. Currently, one Micro Mouse has been designed and made fully functional, ie capable of solving the maze on its own. Future challenges lie in implementing the communication modules and improvising the algorithm to allow efficient parallel coordinated operation of both mice for maze navigation and solving with increased efficiency.

OBJECTIVE:
The project objectives can be summarized as follows: To solve the maze using multiple mice. Helpful in solving bigger Mazes. Does so by communicating with each other. Thus individual intelligence of the Bots combines to form a single intelligence. Each Robot can take decisions based on the success or failure of the other.

INTRODUCTION
The micromouse is an autonomous vehicle whose goal is to find the center of a maze. The official IEEE Micromouse Competitions began in 1987 at the World Micromouse Competition, where David Otten of MIT captured first and second place with his MITEE Mouse. This competition used a new scoring system design to reward intelligence, efficiency, and self reliance. Micromouse competitions have become a popular event among engineering students and engineers. The mouse must recognize walls and openings in order to navigate the maze and prevent crashes. The navigation sensor array provides the mouse with this information. The navigation sensor array consists of a combination of four short-range and two longrange infrared sensors. The mouse must stay centered within the maze to prevent compounding errors in distance and position calculations. A digital compass determines if the deviates from its desired bearing. This information is sent to the motor control system to make proper corrections, either speeding up or slowing down one wheel. The motor control portion of the project is responsible for safely moving the micromouse through the maze. There are two maximum speeds, one for the mapping portion of the competition and one for the racing portion of the competition. The motor control code is given a distance to travel as input. It is then the responsibility of the motor control to accelerate and decelerate the mouse during travel. The rate of acceleration is fixed based upon the traction of the wheels on the maze surface.

The micromouse can also be defined as it is a small battery operated mobile robot that moves randomly through a maze and is able to find its way through it without exterior help. The micromouse functionalities can be divided in to three systems. The first one is the drive control system. This first system consists of two stepper motor drivers and their respective motors. This system will be the wheels of the micro-mouse. The second system is the sensory array. This second system will be the eyes of the micro-mouse, guiding it through various obstacles which include walls in every direction. The third and final system is the control system. This system is the brain of the micro-mouse and it will consist of a microcontroller that will communicate with the first two systems through input and output signals and special instructions will be followed

according to these signals. The micro-mouse will be planned and constructed in approximately fourteen weeks.

LITERATURE REVIEW
The Bellman Ford algorithm was studied in details from On a Routing Problem, in Quarterly of Applied Mathematics published by Richard Bellman in 1958. Other references for the algorithms are An algorithm for Finding Shortest Routes from all Source Nodes to a Given Destination in General Network, in Quarterly of Applied Mathematics, 1970 by Jin Y. Yen and A Simple and Fast Label Correcting Algorithm for Shortest Paths in Networks magazine, 1993 There have been many IEEE publications in the recent years regarding the micromouse and its modern approaches. Some of the papers worth mentioning are:

An updated micromouse competition by Ning Chen of California State University in IEEE Frontiers in Education Conference, 1996. Maze Solving Algorithms for Micrjo Mouse by Swati Mishra and Panka Bande in Signal Image Technology and Internet Based Systems, 2008. Research relevance of mobile robot competitions by Braunl, T in Robotics & Automation Magazine, IEEE, Dec 1999.

BACKGROUND
The software implementation of the micromouse is important for the proper and efficient working of the micromouse, as much as its hardware. As the rules of the competition suggests it is not just solving the maze that counts. The micromice should solve the maze in the shortest time possible giving it the edge over the other competitors participating in the competition. So a proper selection and implementation and even improvisation of algorithm is important for obtaining expected results. Most of the algorithms used nowadays in maze solving competitions are based on logical synthesis design rules. The algorithms which were used in the beginning years of this competition were simple logical algorithms which became inefficient as the maze itself became complex. The Algorithms used for maze solving competition are:
Wall follower Algorithm Depth first search Algorithm Flood fill Algorithm Modified Flood fill Algorithm

Wall follower Algorithm:

The wall following algorithm is the simplest of the maze solving techniques. Basically, the mouse follows either the left or the right wall as a guide around the maze. And if the mouse encounters an opening in any of the walls picked up by its sensors, the mouse will stop and take a turn in that direction and then move forward sensing the walls gain. Thus keeping the walls as a guide the micromouse hopes to solve maze rather than actually solving it. The steps involved in following the right wall is given below
The right wall following routine: Upon arriving in a cell: If there is an opening to the right Rotate right Else if there is an opening ahead Do nothing

Else if there is an opening to the left Rotate left Else Turn around End If Move forward one cell Although this Algorithm was efficient in solving the maze of the beginning years it is not used nowadays. This is because the maze used in competitions nowadays are constructed in such a way that the wall follower algorithm will never solve it. Such mazes have bottleneck regions which will cause the algorithm to fail.

Depth First Search Algorithm:

The depth first search is an intuitive method of searching a maze. Basically, the mouse simply starts moving. When it comes to an intersection in the maze, it randomly chooses one of the paths. If that path leads to a dead end, the mouse backtracks to the intersection and chooses another path. This forces the robot to explore every possible path within the maze. By exploring every cell within the maze the mouse will eventually find the center. Even though this algorithm succeeds in solving the maze completely it need not necessarily be the shortest path. In addition to that the mice explores the entire maze for solving the maze leading to long latency. Cases have occurred in competitions where the competitors using this algorithm had to change their batteries in the middle as the mice took too much time in solving the maze. Hence algorithm is also not used in modern competitions.

Flood Fill Algorithm:

The introduction of flood fill algorithm in maze solving methods paved new ways by which modern complex mazes can be solved without any bottlenecks. This algorithm is derived from the Bellman Ford Algorithm coming under the field of logic synthesis techniques. Other algorithms in this field are Djikstras Algorithm, Johnsons Algorithm etc. These algorithms find applications in various fields like Communication, design softwares etc.

The flood-fill algorithm involves assigning values to each of the cells in the maze where these values represent the distance from any cell on the maze to the destination cell. The destination cell, therefore, is assigned a value of 0. If the mouse is standing in a cell with a value of 1, it is 1 cell away from the goal. If the mouse is standing in a cell with a value of 3, it is 3 cells away from the goal. Assuming the robot cannot move diagonally, the values for a 5X5 maze without walls would look like this:

Of course for a full sized maze, you would have 16 rows by 16 columns = 256 cell values. Therefore you would need 256 bytes to store the distance values for a complete maze. When it comes time to make a move, the robot must examine all adjacent cells which are not separated by walls and choose the one with the lowest distance value. In our example above, the mouse would ignore any cell to the West because there is a wall, and it would look at the distance values of the cells to the North, East and South since those are not separated by walls. The cell to the North has a value of 2, the cell to the East has a value of 2 and the cell to the South has a value of 4. The routine sorts the values to determine which cell has the lowest distance value. It turns out that both the North and East cells have a distance value of 2. That means that the mouse can go North or East and traverse the same number of cells on its way to the destination cell. Since turning would take time, the mouse will choose to go forward to the North cell. So the decision process would be something like this:

Decide which neighboring cell has the lowest distance value: Is the cell to the North separated by a wall? Yes -> Ignore the North cell No -> Push the North cell onto the stack to be examined Is the cell to the East separated by a wall? Yes -> Ignore the East cell No -> Push the East cell onto the stack to be examined Is the cell to the South separated by a wall? Yes -> Ignore the South cell No -> Push the South cell onto the stack to be examined Is the cell to the West separated by a wall? Yes -> Ignore the West cell No -> Push the West cell onto the stack to be examined Pull all of the cells from the stack (The stack is now empty) Sort the cells to determine which has the lowest distance value Move to the neighboring cell with the lowest distance value. Now the mouse has a way of getting to center in a maze with no walls. But real mazes have walls and these walls will affect the distance values in the maze so we need to keep track of them. Again, there are 256 cells in a real maze so another 256 bytes will be more than sufficient to keep track of the walls. There are 8 bits in the byte for a cell. The first 4 bits can represent the walls leaving you with another 4 bits for your own use. A typical cell byte can look like this: Bit no. Wall 7 6 5 4 3 W 2 S 1 E 0 N

Remember that every interior wall is shared by two cells so when you update the wall value for one cell you can update the wall value for its neighbor as well. The instructions for updating the wall map can look something like this: Is the cell to the North separated by a wall? Yes -> Turn on the "North" bit for the cell we are standing on and Turn on the "South" bit for the cell to the North No -> Do nothing Is the cell to the East separated by a wall? Yes -> Turn on the "East" bit for the cell we are standing on and Turn on the "West" bit for the cell to the East No -> Do nothing Is the cell to the South separated by a wall? Yes -> Turn on the "South" bit for the cell we are standing on and Turn on the "North" bit for the cell to the South No -> Do nothing Is the cell to the West separated by a wall? Yes -> Turn on the "West" bit for the cell we are standing on and Turn on the "East" bit for the cell to the West No -> Do nothing So now we have a way of keeping track of the walls the mouse finds as it moves about the maze. But as new walls are found, the distance values of the cells are affected so we need a way of updating those. Returning to our example, suppose the mouse has found a wall.

We cannot go West and we cannot go East, we can only travel North or South. But going North or South means going up in distance values which we do not want to do. So we need to update the cell values as a result of finding this new wall. To do this we "flood" the maze with new values. As an example of flooding the maze, let's say that our mouse has wandered around and found a few more walls. The routine would start by initializing the array holding the distance values and assigning a value of 0 to the destination cell. This means that the objective of the mice is to get to the cell which has the cost value with value 0. During the process of solving the maze the cost values of all the cell may change except for the centre cell. It will always be assigned the value 0.

The routine then takes any open neighbors (that is, neighbors which are not seperated by a wall) and assigns the next highest value, 1:

The routine again finds the open neighbors and assigns the next highest value, 2:

This is repeated as many times as necessary until all of the cells have a value:

It can be seen how the values lead the mouse from the start cell to the destination cell through the shortest path. The instructions for flooding the maze with distance values could be: Flood the maze with new distance values: Let variable Level = 0 Initialize the array DistanceValue so that all values = 255 Place the destination cell in an array called CurrentLevel Initialize a second array called NextLevel Begin: Repeat the following instructions until CurrentLevel is empty: { Remove a cell from CurrentLevel If DistanceValue(cell) = 255 then let DistanceValue(cell) = Level and place all open neighbors of cell into NextLevel End If } The array CurrentLevel is now empty. Is the array NextLevel empty? No ->

{ Level = Level +1, Let CurrentLevel = NextLevel, Initialize NextLevel, Go back to "Begin:" } Yes -> You're done flooding the maze The flood-fill algorithm is a good way of finding the shortest (if not the fastest) path from the start cell to the destination cells. You will need 512 bytes of RAM to implement the routine: one 256 byte array for the distance values and one 256 array to store the map of walls. Every time the mouse arrives in a cell it will perform the following steps:

Update the wall map Flood the maze with new distance values Decide which neighboring cell has the lowest distance value Move to the neighboring cell with the lowest distance value

Modified Flood Fill Algorithm:

The modified flood-fill algorithm is similar to the regular flood-fill algorithm in that the mouse uses distance values to move about the maze. The distance values, which represent how far the mouse is from the destination cell, are followed in descending order until the mouse reaches its goal. The basic structure of the algorithm remains the same with some modifications to optimise the working of the flood fill algorithm. This modification helps the mice to solve the maze in lesser time than if it were using a simple flood fill algorithm. As the Micromouse finds new walls during its exploration, the distance values need to be updated. Instead of flooding the entire maze with values, as is the case with the regular flood-fill, the modified flood-fill only changes those values which need to be changed. Let's say our mouse moves forward one cell and discovers a wall:

The robot cannot go West and it cannot go East, it can only travel North or South. But going North or South means going up in distance values which we do not want to do. So the cell values need to be updated. When we encounter this, we follow this rule: If a cell is not the destination cell, its value should be one plus the minimum value of its open neighbors . In the example above, the minimum value of its open neighbors is 3. Adding 1 to this value results in 3 + 1 = 4. The maze now looks like this:

There are times when updating a cell's value will cause its neighbors to violate the "1 + minimum value" rule and so they must be checked as well. We can see in our example above that the cells to the North and to the South have neighbors whose minimum value is 2. Adding a 1 to this value results in 2 + 1 = 3 therefore the cells to the North and to the South do not violate the rule and the updating routine is done. Now that the cell values have been updated, the mouse can once again follow the distance values in descending order. So our modified flood-fill procedure for updating the distance values is: Update the distance values (if necessary) Make sure the stack is empty Push the current cell (the one the robot is standing on) onto the stack Repeat the following set of instructions until the stack is empty: { Pull a cell from the stack Is the distance value of this cell = 1 + the minimum value of its open neighbors? No -> Change the cell to 1 + the minimum value of its open neighbors and push all of the cell's open neighbors onto the stack to be checked Yes -> Do nothing } Most of the time, the modified flood-fill is faster than the regular flood-fill. By updating only those values which need to be updated, the mouse can make its next move much quicker.