Advanced Algorithms for Micro Mouse Maze Solving

Swati Mishra1, Pankaj Bande2

1
Inderprastha Engineering College, Ghaziabad, Uttar Pradesh, India
2
LARE, Mumbai, Maharashtra, India

Abstract: The problem of micro-mouse is 30 years old theoretical study into practice. Furthermore, they learn
but its importance in the field of robotics is unparalleled, as teamwork.
it requires a complete analysis & proper planning to be To stimulate this learning process in upcoming engineering,
solved. This paper covers one of the most important areas of a wide range of robotic competitions is held worldwide, and
robot, “Decision making Algorithm” or in lay-man’s the most sought after among them is MICROMOUSE. It is
language, “Robot Intelligence”. For starting in the field of one of the most efficient ways to inculcate the true
micro-mouse it is very difficult to decide the appropriate "engineering values" in students. As mentioned above, the
logic for maze solving to give optimized results. This paper change in the mode of education is under revolution, as a
begins with the A* algorithm to solve the maze, and result of which not much students are exposed to the field of
gradually improves the algorithm to accurately solve the robotics.
maze in shortest time with some more intelligence. The Traditional maze solving algorithms, while appropriate for
Algorithm is developed up to some sophisticated level as purely software solutions, break down when faced with real
Flood-Fill algorithm. The paper would help all the world constraints. When designing software for a maze-
beginners in this fascinating field, as they proceed towards solving robot, it is important to consider many factors not
development of the “brain of the system”, particularly for traditionally addressed in maze solving algorithms. Our
robots concerned with path planning and navigation. information about the maze changes as we explore, so we
must make certain assumptions about unseen portions of the
Keywords: Mobile Robot Navigation, Algorithms, maze at certain steps in most algorithms.
Micromouse, Flood fill, Djikstra, A*.
2. A* algorithm
1. Introduction
A* is a type of search algorithm. Some problems can be
Autonomous agents are mobile versatile machines capable solved by representing the world in the initial state, and then
of interacting with an environment and executing a variety for each action we can perform on the world we generate
of tasks in unpredictable conditions. Autonomy means states for what the world would be like if we did so. If you
capability of navigating the environment; navigation, in do this until the world is in the state that we specified as a
turn, necessarily relies on a topological and metric solution, then the route from the start to this goal state is the
description of the environment [6]. solution to your problem.
One of the major components for the creation of A node is a state that the problem's world can be in. In this
autonomous robot is the ability of the robot to “plan its case, a node represents a cell of the maze. All the nodes are
path” and in general the ability to “plan its motion”. In a arranged in a graph where links between nodes represent
limited or carefully engineered environment it is possible to valid steps in solving the problem. These links are known as
program the robot for all possible combinations of motions edges. So the edges here are paths that lead from one cell to
in order to accomplish specific task [2]. The problem of path another. A* (pronounced "A star") is a best-first, graph
planning is not confined to the field of robotics but its search algorithm that finds the least-cost path from a given
applications exist in various genres. For example, molecule initial node to one goal node. The goal node here is the
folding, assembly/disassembly problems and computer centre of the cell.
animations are areas where comparable problems arise [7]. It searches first the routes that appear to be most likely to
A robot is a mechanical device, which performs automated lead towards the center, and it also takes the distance
physical tasks, either according to direct human supervision, already traveled into account. The algorithm traverses
a pre-defined program, or a set of General guidelines using various paths from start to centre. For each node x traversed,
artificial intelligence techniques. There is a paradigm shift in it maintains 3 values; g(x) which is the actual shortest
engineering education from conventional classroom teaching distance traveled from initial cell to current cell, h(x) which
to hands on projects, robotic projects are very useful for is the estimated (or "heuristic") distance from current cell to
students who have to deal with an open ended problem and center, f(x)which is the sum of g(x) and h(x).
this way their creativity is stimulated. As project incorporates The heuristic is like an algorithm, but with a key difference.
wide range of engineering fields, they can convert variety of An algorithm is a set of steps which you can follow to solve
a problem, which always works for valid input. A heuristic STEP 4: x = the cell in cell_remaining set having the lowest
is not guaranteed to work but is useful in that it may solve a value_f[] value
problem for which there is no algorithm. What we need is to STEP 5: check if x = centre
use our heuristic at each cell to make an estimate of how far STEP 6: if yes then call function reproduce path
we are from the center. STEP 7: delete x from cell_remaining
STEP 8: add x to cell_traversed
2.1 The Algorithm STEP 9: check if wall is present in each of 4 directions.
STEP 10: if no then each cell is added as y to
Starting with the initial cell, we maintain a priority queue of Cell_neighbor(x)
cells to be traversed. The lower the f(x) for a given cell x, STEP 11: check if y is in cell_traversed
the higher is its priority. STEP 12: if no then goto step 13 else check for the next
At each step of the algorithm, the cell with the lowest f(x) value of y in set cell_neighbor(x)
value is removed from the queue, the f and h values of its STEP 13: temp_value_g = value_g[x]+ dist_btw(x,y)
neighboring cells are updated accordingly, and these STEP 14: better_temp_value_g = 0 (false)
neighbors are added to the queue. The algorithm continues STEP 15: check if y is in cell_remaining if no then add y to
until a goal cell has a lower f value than any cell in the cell_traversed
queue (or until the queue is empty). Goal cell may be passed STEP 16:value_h[y] = heuristic_function(y, center)
over multiple times if there remain other cells with lower f STEP 17:better_temp_value_g=1
values, as they may lead to a shorter path to a goal. After the (true)
algorithm finishes its execution the f value of the goal is STEP 18: temp_value_g<value_g[y]
then the length of the shortest path. The algorithm may also STEP 19:better_temp_value_g = 1 (true)
update each neighbor with its immediate predecessor in the STEP 20: check if better_temp_value_g = 1
best path found so far; this information can then be used to came_from[y] =x
reconstruct the path by working backwards from the goal value_g[y] = temp_value_g
cell. value_f[y]=value_g[y]+value_h[y]
The nomenclature used in this algorithm is as follows. STEP 21: check for next value in cell_neighbor got step 12
Cell_traversed is the set of the cells already visited and until Cell_neighbor(x) is empty.
evaluated
Cell_remaining is the set of the cells not evaluated so far. 2.2 Drawbacks of the A* Algorithm
Value_g represents the value of g(x) function
Value_h represents the value of h(x) function This algorithm may though be capable of solving many of
Value_f represents the value of f(x) function the complex mazes or almost all of the mazes because it
Cell_neighbor is the set of the adjacent cells to the cell works on cell by cell basis and keeps a track of all the
under evaluation. visited and non-visited cells so as to save time in revisiting
temp_value_g is the temporary value of g(x) the same cells over and over again. But the drawback of the
dist_btw(x, y) is a function that gives the distance between algorithm lies in its dependence on the heuristic function to
two adjacent cells. For uniform maze, this distance is determine the distance of the current position from the
constant. destination cell i.e. the center. For simple mazes the
better_temp_value_g is a variable that determines if the heuristic function may be simpler but as the mazes get
value of g(x) is better than the rest of the values of g(x). complex it becomes more and more complicated and the
came_from is the cell that the micromouse has come from determination of the heuristic function becomes difficult.
after traversing. Therefore, the algorithm fails when it comes to complex
reproduce_path(came_from, current_cell) is the function to heuristic functions. Also, determining heuristic functions is
reproduce the path traversed to reach the current cell from a time taking task and for different mazes it may be
the cell desired. different.
The algorithm proceeds as follows; Hence, we can modify this algorithm and then use it to
reduce the drawbacks and get better results.
STEP 1: Initialize
cell_traversed = null The time taken by the robot can be calculated. For the robot
Cell_remaining= initial cell used here, the cell to cell movement time is 5 sec. and the
Value_g[start_cell]=0 turning time is 1 sec. so the total time taken by the robot to
Value_h[start_cell]=heuristic_function(start_cell, center) reach the center is (50*5) +(16*1)= 266 sec+ (extra time
Value_f[start_cell]=value_h[start_cell] for traversing the other paths that lead to the center).
STEP 2: check if cell_remaining is empty
STEP 3: if yes then goto step else goto step4
 The input of the algorithm consists of a weighted directed
graph G and a source vertex s in G. We will denote V the set
of all vertices in the graph G. Each edge of the graph is an
ordered pair of vertices (u, v) representing a connection
from vertex u to vertex v. The set of all edges is denoted E.
Weights of edges are given by a weight function w: E → [0,
∞); therefore w(u,v) is the cost of moving directly from
vertex u to vertex v. The cost of an edge can be thought of
as (a generalization of) the distance between those two
vertices. The cost of a path between two vertices is the sum
of costs of the edges in that path. For a given pair of vertices
s and t in V, the algorithm finds the path from s to t with
lowest cost (i.e. the shortest path).So now this fundamental
Figure 1: Maze solved by A*.(red dashes show the other
nature of the algorithm can be used to find the graph. The
paths found by the algorithm).
stepwise functioning of the algorithm has been described as
below.

STEP 1: Start “ready set” with start node

Set start distance to 0, dist[s] =0;
others to infinite: dist[i]= (for i s);
Set Ready = { }.
STEP 2: Select node with shortest distance from the starting
point that is not in Ready set
Ready = Ready + {n}.
STEP 3: Compute distances to all of its neighbors
For each neighbor node m of n
Check if dist[n] +edge (n, m) < dist[m]
If yes then dist[m] = dist[n] +edge (n, m);
STEP 4: Store path predecessors.
Image 1: Maze solved by A*( plane line shows the other pre[m] = n;
path found by the robot) STEP 5: Add current node to “ready set”.
STEP 6: Check if any node is left, if yes goto step 2
3. Djikstra’s algorithm STEP 7: end.

So we observe that the design of an autonomous navigation Now the problem arises of how to generate the directed
system with multiple tasks to be accomplished in unknown graph G of the nodes we have talked about so far. So for this
environments represents a complex undertaking. Concepts we need to get the Micromouse traverse the whole maze and
from immune network theory are employed these days to generate the nodes! So the traversal function is defined as
convert an earlier reactive robot controller, based on follows.
learning classifier systems, into a connectionist device. Traverse ( ):
Starting from no a priori knowledge, both the classifiers and STEP 1: Move straight
their connections are evolved during the robot navigation. STEP 2: Check if any wall is present in front. If yes, then
[1] goto step 3 else goto step 1.
As a conclusion from the above fact we now move a step STEP 3: check if the current location is present in V, if no
ahead and implement the Djikstra’s Shortest Path algorithm then add the location in the set V, Calculate the distance
for solving our problem. The algorithm deals with finding between the previous and the present location. Store the
the shortest path from a directed graph of a given set of value in the set E, else take 180 degree turn and traverse to
nodes. This algorithm is basically a special case of A* the previous entry of V.
algorithm where h(x)=0. STEP 4: Check if wall is present on right. If present, take a
The approach adopts a strategy of multi-behavior 90 degree turn left if not then take a 90 degree turn right.
coordination, in which a novel path-searching behavior is STEP 5: Goto step 1
developed for determining the shortest path [11]. Repeat steps 1 to 5 till the entire maze is traversed.
Calculation of distance between two consecutive nodes is
done by adding a counter circuit at the base of the chasis
3.1. Maze Solving near the wheels so as to count the number of cells between
the destination and the source location. This number would 3.2 Drawbacks of the algorithm
denote the weight of the edge E.
Each location is represented by a cell of a 16x16 two There are, however, problems in using this algorithm, the
dimensional array, cell being represented by [R, C], R major one being that the whole maze has to be traversed.
represents row, and C represents column. So the vertex set For identifying the nodes, it is important to travel all the
V consists of a pair of variables [R, C] representing a single parts of the maze, irrespective of whether that portion of the
node. maze contains the shortest path or not. Now, this is time
consuming and also a lot of energy is wasted in the
traversal. This problem would be solved if we can design a
way where both the maze interpretation and path finding are
done simultaneously.
The other problem is that for counting the number of cells to
generate the edge set E, an additional hardware is involved
which includes a counter circuit that counts the rotation of
the wheels and hence the distance between two consecutive
locations. This adds to the complexity of the design and
increases the probability of error in input data from the
external environment.
To avoid such complexities, we use yet another solution to
solve our problem which has been described below.
Figure 2. Maze as solved by Djikstra’s algorithm.(red
dashes show the maze travelled for map generation) 4. Flood Fill algorithm
After generating the graph the final algorithm is applied on
the graph and the shortest path reachable to the destination The speed of robot to find its path, affected by the applied
node which is the centre is obtained. algorithm, acts the main part in the present project. 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 [3].
The maze is represented as a 16x16 array in the memory.
The centre is given the value (0, 0).all cells in its immediate
vicinity are assigned 1, the cells next to it as 2, and so on.
The array is divided into 4 symmetrical regions and then the
assignment is done.
Upper left quarter, loop decrements the column, increments
the row: R= R+j, C=C-i, i, j vary from 0 to 8.
Image 2. Maze being solved by Djikstra’s algorithm. Upper right quarter, loop increments the column, increments
White line shows the path traversed by the device and the the row: R=R+j, C=C+i, i, j vary from 0 to 8.
white points show the nodes as perceived by the algorithm. Lower left quarter, loop decrements the column, decrements
the row: R=R-j, C=C-i, i, j vary from 0 to 8.
The time taken by the robot can be calculated. For the robot Lower right quarter, loop increments the column,
used here, the cell to cell movement time is 5 sec. and the decrements the row: R=R-j, C=C+i, i, j vary from 0 to 8.
turning time is 1 sec. so the total time taken by the robot is
(50*5) +(16*1)= 266 sec+ (extra time for maze mapping) decr= 0, incr= 1 decr=0, incr= 1
for reaching the center of this maze. decc= 1, incc=0 decc= 0, incc= 1
Now we see that it effectively calculates the shortest path
but to find that path it has to travel the entire maze. This decr= 1, incr= 0 decr= 1, incr= 0
traversal is to generate the directed graph G. Though the decc= 1, incc=0 decc= 0, incc=1
time taken to reach the centre is less but it takes more time
to traverse the maze. So if we calculate the total time taken, Figure 3. Values of the 4 variables in the 4 quadrants
then it would be more in this case.
So it is combined into a MATHEMATICAL EQUATION stored in the array, they are sorted using any kind of sorting.
as follows: We have used here selection sort.
After this, the array is ready for further processing, which
Row increment and decrement: R-(i*decr) + (i*incr) includes the deciding of which path to be taken and which
Column increment and decrement: C-(j*decc) + (j*incc) values in the map to be changed.
Now when the assignment is done, the entire equation is as The maze after being flooded is then traversed and the map
follows: (where the variables i, j vary in the loop from 0 to of the maze is updated after every traversal. Every time a
8) new cell is traversed, it creates the array described above
and decides the lowest value nearby that can be traversed.
MAZE[R-(i*decr) + (i*incr)][C-(j*decc)+j*incc)] The path followed is always from a higher value to a lower
= i+j; value.

Main():
START: form array temp[4] for Maze[R][C].
STEP 1: From the array, select the ith element, (i=1
initially)
STEP 2: If the value temp [i]<= Maze [R][C] , then go to
step 4. If temp [i]>=Maze[R][C], call check(R,C).
Step 3: if the value temp [1]=256, turn 180 deg, i=i+1,goto
step 1
STEP 4: locate the cell of the value temp [i].
STEP 5: check if the wall is present in the way, if yes then,
i++, go to step1
STEP 6: check if Maze[R1][C1]=temp[i+1], if yes, then
use call Locate( R, C, temp(i+1)) algorithm defined below,
to locate its cell.
STEP 7: store the result in (R2, C2)
Image 3. An actual maze as depicted in the memory of STEP 8: call the function direction of move (R1, R2, C1,
the micro mouse. C2)
Formation of array temp [4] for each cell: STEP 9: move to Maze (R’, C’)
STEP 10: update value, R=R’, C=C’
(R+1, C) STEP 11: check if Maze[R][C]=0, if yes, call return to start
( ), else go to START.
(R, C-1) (R, C) (R, C+1) STEP 12: call follow ( ).

Decide which cell is preferable to move by using the

(R-1, C) following algorithm: (direction of move (R1, R2,C1,C2))
STEP 1: check which cell is obstructed by a wall
STEP 2: move in direction of no wall, if wall is present
before all selected cells, then i=i+2, go to STEP
3: give the priority to forward straight movement.
STEP 4: if the wall is in front, move towards right or left,
priority can be given to any direction.
STEP 5: if it is dead end, then move in backward direction
Figure 4. Storing elements in array; temp [4] turn 180deg.
STEP 6: return the decided value in (R’, C’).
Each cell is interpreted as an array cell of a 2-d array and is
represented with a value, R and C, which represents a row Location of the value in array, which is first dealt with, is
and column, respectively. The values, therefore, of the found by following routine:
neighboring cells are as shown in the diagram. The values of STEP 1: Initialize: flag1=0, flag2=0, flag3=0, flag4=0
the cell arrays are as according to the index values assigned STEP 2: Locate(R, C, temp [i])
to a 16x16 array in the computer memory. Initially the value {check if temp [i]==Maze [R+1][C], if yes flag1=1;
of the first cell is assigned as, R=1, C=1.The values of the R1=R+1, C1=C;
neighbors are stored in the above array. After the values are check if temp[i]==Maze[R-1][C], if yes
flag2=1; R1=R-1, C1=C;
check if temp[i]==Maze[R][C+1], if yes
flag3=1; R1=R, C1=C+1
check if temp[i]==Maze[R][C-1], if yes
flag4=1; R1=R, C1=C-1 }
STEP 3: Return (R1, C1)
The assignment of flags deals with the problem that arises
when more than one cell has the same value.
Check (R, C, i)
{Step 1: Maze[R][C]=temp[i] + 1
Step 2: update()
Step 3: return to step 2 of main( )}

There is an updating based on the fact that the value of the

cell near the center is always less than the value of the cell
away from the center. So, Figure 5. Maze solved through flood fill algorithm:

For 1<R<8, and 1<C<8, Maze[R+1][C]<Maze[R][C]

Maze[R][C+1]<Maze[R][C]

For 9<R<16, and 1<C<8, Maze[R+1][C]>Maze[R][C]

Maze[R][C+1]<Maze[R][C]

For 1<R<8, and 9<C<16,

Maze[R+1][C]<Maze[R][C]
Maze[R][C+1]>Maze[R][C]

For 9<R<16, and 9<C<16,

Maze[R+1][C]>Maze[R][C] Maze[R][C+1]>Maze[R][C]
So the equation which determines the update ( ) function is
as follows: Image 4: Sample maze solved through flood fill
If Maze [R-(i*decr) + (i*incr)][C-(j*decc)+j*incc)] >= algorithm:
Maze [R-(i*decr) + (i*incr)][C-((j+1)* decc)+((j+1)*incc)],
then White line shows the path followed by robot.
Maze [R-(i*decr) + (i*incr)][C-(j*decc)+j*incc)]+1 = Maze
[R-(i*decr) + (i*incr)][C-((j+1)* decc)+((j+1)*incc)], and 5. Result:
If Maze [R-(i*decr) + (i*incr)][C-(j*decc)+j*incc)] >= Motion planning is a key requirement demanded of
Maze [R-((i+1)*decr) + ((i+1)*incr)][C-(j* autonomous robots. Given a task to fulfill, the robot has to
decc)+((j)*incc)], then plan its actions including collision-free movement of
actuators or the whole robotic platform.[1]
Maze [R-(i*decr) + (i*incr)][C-(j*decc)+j*incc)]+1 = Maze A comparative study on the path length & time taken
[R-((i+1)*decr) + ((i+1)*incr)][C-(j* decc)+(j*incc)] performance of our robot with regards to different
Where i, j are variables varying from 0 to 8, in loop. algorithms is also done. Both simulation and real tests are
performed.
The given maze is solved using the flood fill logic. The time The problem encountered in A* algorithm is solved by
taken by the robot can be calculated. For the robot used Djikstra’s algorithm. And this algorithm is once again
here, the cell to cell movement time is 5 sec. and the turning refined to Flood fill. The A* logic is restricted to a limited
time is 1 sec. then the total time taken by the robot is kind of the mazes only with simpler heuristic functions,
(50*5) +(16*1)= 266 sec. for reaching the center while the Djikstra’s algorithm can solve practically any kind
of maze. But it requires a lot of time for maze interpretation
and mapping which reduces its efficiency. So for situations
in which the time is not the priority, this algorithm could
serve the best. In case of A* algorithms, as well as the Flood
fill algorithm, the maze interpretation or we can say map
generation is done along with the maze solving. Both the [6] Horst-michael gross, Alexander Koenig; “Robust Omniview-
tasks performed together improve the efficiency of the basad Probilistic Self-loalization for Mobile Robots in Large
micromouse robot. An elaborate analysis of the above Maze-like Environments”, proceedings of the 17th International
algorithms gives us a basis of how to proceed in path Conference on Pattern Recognition, ICPR-2004.
planning, of intelligent devices capable of navigation. In [7] Shinichiro Yano, Manabu Noda, Hisahiro Itani, Masayuki
contrast, to this in case of the Djikstra’s algorithm, the maze Natsume, Haruhiko Itoh and Hajime Hattori, Tadashi Odashima,
interpretation is prior to maze solving. Kazuo Kaya, Shinya Kataoka and Hideo Yuasa, Xiangjun Li,
For comparison, we have used a single virtual maze but for Mitsuhiro Ando, Wateru Nogimori and Takahiro Yamada; “A
effective elaboration, the logics were verified on various Study of Maze Searching With Multiple Robots System”, 7th
mazes. Also we have used a standard IEEE maze for International Symposium on MicroMachine and Human Science,
experimentation. For non uniform mazes, the same 1996.
algorithms can be used with an external hardware attached
that would keep a track of the distance travelled by the [8] Frank Lingelbach; “Path Planning using Probabilistic Cell
Decomposition”, International Conference on Robotics &
robot. The future work of this paper gives an emphasis on Automation, 2004.
this problem.
[9] Javier Antich and Alberto Ortiz; “Extending the potential
6. Conclusion: Fields Approach to Avoid Trapping Situations”, CICYT-DPI-
2001.
Hence we conclude that, if we don’t have any time and [109] Gorden Mc Comb, Myke Predko,“Robot Builder’s
hardware constraints we can effectively use the Djikstra’s Bonanza”, Mc-Graw Hill, 2006.
algorithm, but if both are the constraints then Flood fill
would be superior to others. Further, if we do not wish to [11] Thomas Braunl; “Embedded Robotics mobile robot design
have any complex calculation to embed in the system, that and applications with Embedded systems”, Springer 2006.
means, if we have a memory constraint as well as heuristic
function for the maze to be solved can be easily determined, [12]Meng Wang, James N.K. Liu, “Fuzzy Logic Based Robot Path
then the A* algorithm would be best to use. The kind of Planning in unknown Environment, the Fourth International
logic implemented for robot path finding, depends upon the Conference on Machine Learning and Cybernetics, Guangzhou,
2005
functional priority of the system.
The speed of robot to find its path, affected by the applied [13] Roland Buchi, Gilles Caprari, Vladimir Vuscovic, Roland
algorithm, acts the main part in the present projects that are Siegwart; “A Remote Controlled Mobile Mini Robot”, 7th
concerned with robot navigation. While there is no International Symposium on MicroMachine and Human Science,
limitation to improve the algorithms, there are some 1996.
restrictions on developing robot’s mechanic or electronic.
Developing algorithm is usually cheaper than other parts.

7. References:
[1] Swati Mishra, Pankaj Bande;”Maze Solving Algorithms for
Micromouse” IEEE conference, SITIS Bali, Indonesia, 2008.

[2] Renato Reder Cazangi, Associate,

Member, IEEE, and Fernando J. Von Zuben, Member, IEEE
“Immune Learning Classifier Networks: Evolving Nodes and
Connections” , IEEE Congress on Evolutionary Computation
,Canada, 2006

[3] Dimitris C. Dracopoulos;”Robot Path Planning for Maze

Navigation”, 1998.

[4] Babak Hosseini Kazerouni, Mona Behnam Moradi and Pooya

Hosseini Kazerouni;”Variable Priorities in Maze-Sloving
Algorithms for Robot’s Movement”, 2003.

[5] Sung-Hee Lee, Junggon Kim, F.C.Park, Munsang Km, and

James E.Bobrow;”Newton-Type Algorithms for Dynamics-Based
Robot Movement Optimization”, Digital Object Identifier, 2004.