An Algorithm for Dispersion of Search and Rescue Robots

Transcription

1 An Algorithm for Dispersion of Search and Rescue Robots Lava K.C. Augsburg College Minneapolis, MN Abstract When a disaster strikes, people can be trapped in areas which human rescue teams cannot reach. Small robots are being built to reach these areas. Power becomes a huge issue for these tiny robots. To minimize the power consumption, we can reduce the number of sensors the each robot uses. In addition, dispersion algorithms requiring little power consumption are needed. We have developed a search and rescue dispersion algorithm that allows the robots to search an area with minimal sensing while maximizing the area covered in limited time. The algorithm is a modification of classic tree search algorithms either breadth first or depth first determined by the structure of the disaster area.

2 1 Introduction When a disaster strikes, people can be trapped in areas which human rescue teams cannot reach. The safety of human rescuers is also a concern when dealing with destroyed environments. To reduce the loss of lives that occurs when entering these disaster areas, small robots are being built to search for survivors. We can either send one single robot or multiple robots into the area. Sending one robot may not be efficient as it has to cover a lot of area in limited time. Sending a large robot is also not a good idea because it may not be able to go through narrow passages in the destroyed environment. Sending many tiny robots is an option. This paper describes a dispersion algorithm for a group of small robots with few sensors and using little power. 2 What is a Dispersion Algorithm? A dispersion algorithm is an algorithm that causes many robots to disperse in an area either systematically or randomly, trying to cover the maximum area and gather information collectively. A number of researchers have developed dispersion algorithms for small robots. Das et. al. [2] used a team of heterogeneous agents, including both humans and robots, in rescue operations. They concentrated on forming strong networks between all participants. Their environment was dangerous in terms of fire or toxins, but was well structured. McLurkin and Smith [3] used ad-hoc communications network topologies formed by gradient floods. Although they paid attention to doors and hallways, the underlying assumption was that the environment was structured with no unexpected obstacles or narrow passages. Reich and Sklar [4] are developing algorithms for automatically reconfiguring robot sensor networks in urban search and rescue. They are using a large number of robots with limited mobility and sensing capabilities combined with a small number of more powerful robots. Their focus is on network configurations rather than dispersion. Damer et. al. [1] developed two distributed dispersion algorithms based on wireless signal intensities. The main difference between their work and what is being presented here is that they used cliques in a graph structure as their data structure as opposed to a tree structure which requires less overhead. Their intended robot of implementation was the University of Minnesota s Scout [5]. Our intention when we started to develop a dispersion algorithm was to extend the algorithm developed at the University of Minnesota for the Scout. After our initial simulations led to the same issues that the Minnesota group discovered when trying to realistically simulate the Scout (a small rolling cylinder), we decided to simulate the small wheeled robots which we are using in the laboratory. Although not sturdy enough to be used in real life search and rescue, they use little power, have few sensors and are an appropriate size. We chose to develop a tree structure in an attempt to improve on the execution time of the graph-based algorithm used by the Minnesota group. 1

3 3 Our Original Algorithm Our dispersion algorithm is a tree based algorithm. The first robot which enters the destroyed environment becomes the root of the tree. When other robots enter the area, they become the branches of the tree. We have currently limited each node (which is the robot itself) in the tree to have up to a maximum of three children. Each robot has three IR sensors, one in each of three different directions, as shown below (Figure 1). The angle between the sensors can be adjusted. Figure 1: The tree structure created by the robots, showing the three IR sensor directions where the branches can occur. Like any other tree based algorithm, our algorithm can build the tree either in a breadth first or depth first manner. Depending upon the type of destroyed environment and what the main objective is, the algorithm switches either to breadth first or depth first. For example, a destroyed environment may have a long hallway where trying to find something to the side using a breadth first algorithm may be useless. So it may switch to a depth first algorithm in order to be more efficient (Figure 2). Figure 2: The robots at positions marked A are useless. Unless we use a depth first approach, our algorithm is going to be inefficient. 2

4 3.1 Depth First Algorithm In this algorithm, the assignment of the children is done from the middle node and then the side nodes. The priority is given to the center of the tree which results in creating a long narrow structure. This may be useful in covering areas mainly consisting of narrow hallways as shown in Figure Breadth First Algorithm In this algorithm, the assignment of the children is done from left to right node or vice versa. The priority is given to the side of the tree hence filling in each level (height) before advancing to the next level (height). This creates a broader tree instead of a taller tree which might be useful to cover a very large open area such as a room with no narrow passage as illustrated in Figure 3. If we have enough robots and let both algorithms run, the approaches will eventually fill in a space like in Figure 3 in the same way. We are moving these robots into the environment so that effective coverage is attained as quickly as possible. Figure 3: The breadth first tree structure showing robots covering more area in a large open space. First the green nodes are filled out and finally the blue nodes are filled out. 4 Optimized Dispersion Algorithm After running the above algorithm in simulation, we decided to modify it in the following way: In a destroyed environment, it is likely that the passage through which the robot must travel will be so narrow that only one robot can pass through. Robots trying to move into the area and become part of the tree would be blocked by their parent. In our modified algorithm, the root is created at first and is located at the entrance. A second robot is positioned in the search area at maximum sensory-distance of the root. This child node of the root can 3

5 then add more children. Each robot can only communicate with its parent or its children. A branching factor is determined at each node based on the estimated breadth of the area to explore at that point. When a robot sends information that more robots can be added to its branches, the information is sent back all the way to the root. A new robot then can be sent out to the desired branch. This is done by what we call the Push Concept. The new robot becomes the root and the previous root moves down the path, becoming the child of the root (sub-root) in the desired path. This process continues until the robot that asked for a child becomes that child itself and moves into the new unexplored area. 4.1 The Process of Broadcasting A robot can broadcast when it is near the entrance trying to enter the destroyed area, when it has found something useful in the area or when it needs a child. Before entering the destroyed area, a robot broadcasts information that it is ready to become a child. If no one processes the information, it declares itself to be the root (because no one is at the entrance) and stays at the entrance. It then broadcasts that it needs a child. If the broadcast information is processed by the root, the robot then waits for further instruction from the root. When a child is created, the parent gives it a defining characteristic which states whether it is a middle, left, or right child represented by m or l or r respectively. This means that every robot has one of these variables set by its parent except for the root and the root starts by setting itself to m for middle. If the node has to broadcast that it needs a child or has found something, it sends back its information to the parent. The parent then adds the information from the child to its information and sends it to its parent. This is done until the accumulated information is finally passed to the root of the tree. The root then takes necessary actions and the appended message allows it to find where the information originated. For example in Figure 4 when A has to send back information stating it needs a child, it sends l to B, then B sends lm to the root. Similarly, when C has to send the information back, it will send r to B and B will send rm to the root. 4.2 The Process of Pushing When a broadcast signal which states that a node needs more children is processed by the root, it checks if any robots are waiting at the entrance. If there are none, the broadcast is denied until a new robot is ready at the entrance. If there is a robot ready at the entrance, it passes information about its location and properties to the ready robot. The ready robot moves to the root s place and takes the place of the root. The root then follows the path from the broadcast information which is either left, right or middle represented by l, r 4

6 Figure 4: The process of broadcasting. or m. Since it knows where its children are, it proceeds in the direction of the child which broadcast the message and becomes that child, causing the child node to move forward. This happens continuously until the final destination is reached and the node which first broadcast for a needed child goes to the place where it needed the child. 4.3 Data Structure of the Tree A desire for simple arithmetic calculations to access left child, right child, middle child, and the parent tempted us to use an array to maintain the tree structure in our simulation. But soon, we realized that an array would use up a lot of memory, even if each node on the tree contained very few children. For example, let us take 100 robots. If we place each robot as the left child of another, we will have a tree of height 100 (This could very well happen in our depth first dispersion algorithm). Even though we have only 100 robots, the array will have to be of size 300 because each node would have to have space for left, right and the middle child. In addition, it was impractical for each of our tiny robots with very little memory capacity to carry this whole array even though it would only communicate with 4 other robots. Hence, for our simulation, we use a linked list to maintain the tree structure. Each robot is a node and can have four links to other nodes called left, right, middle, and parent (3 children and a parent). Thus, each robot has only 4 nodes to store and does not care where the other robots are, saving us memory and processing time. 5 Writing the code The simulation was written in Java using a open source Javaclient developed for the Player/Stage environment by Esben H. Ostergaard ( The Javaclient is a client for the Player/Stage server. One creates a new object of the Playerclient from the javaclient package specifying the host and the port name. A simple request is done by the Playerclient object to get different interfaces such as sonar, position, and 5

7 laser range finder the from the Player/Stage server. 5.1 The Player/Stage Environment Player is a simulator for robots in which almost all of the modern sensors are available for simulation. One can define the dimension of the robot, the sensors it will be using, the position of each sensor and the properties of a sensor in a configuration file for the robot. The Player takes in a configuration file of the simulation, which includes how many robots are going to be used, the model of each robot, the sensors on each robot, the port number the sensors will be broadcast in and the world file it is going to use. Stage is the 2D environment for the player. It is represented by a world file, which contains an image to use for the map, and places each defined robot in the Player configuration. Creating a stage map is easy. The map has to be in a standard picture format either a jpeg or a png. Anything other than white is considered to be a object on the map. The map is usually black and white, where black represents objects like walls, and white represents a free space. To avoid confusion in writing code for the Player/Stage environment, we developed a GUI version to generate configuration files. This environment allowed us to load a map, load a robot configuration file, and visually place the robots where we want them to be on the map. The program then automatically generates the Player/Stage configuration file. 6 Results We simulated 5 robots with our dispersion algorithm. The robots dispersed according to the algorithm proposed. The result is demonstrated in Figures 5, 6, and 7. After the robots have reached the entrance, a root is created. In this example, since robot B reached the entrance first, it is assigned as the root of the tree. After, one other robot comes to the entrance and broadcasts that it is ready, it pushes the root into the open space as shown in Figure 6 (left). Robot C was the second one to reach the entrance, hence it pushed robot B into the free space and became the root of the tree. Robot B which was pushed into the environment, moves forward until it finds a suitable place to have branches or children. The message is sent back to robot C (B s parent). Since, C is the current root of the tree, it checks if any other robot at the entrance are ready. In this example, robots A and D are ready at the moment. Our algorithm picks the last one to be ready and since it was A, A becomes the new root pushing C into B s position and C pushes B into the free position. Since, we were using breadth first algorithm in this map, robot B goes to the left as shown in Figure 6 (right). Robots are further distributed using the breadth first technique as shown in Figure 7(left). Even though robot A needs a child, nothing happens because there are no robots free at the 6

8 Figure 5: Position of robots at the start time(left) and when they head toward the entrance(right). Figure 6: Robots waiting at entrance(left) and robots using the push method to move on, creating a tree structure (right). entrance. Ultimately, it results in a small tree as shown in Figure 7(right). After many simulations, we noticed some places where we could improve. In Figure 7, we see that robot C is in a narrow area and it broadcasts that it does not need any child. If it had rotated a little to the left, we could have discovered a whole new place to explore. When 7

9 Figure 7: Distribution of robots (left) and final positions of robots (right) after breadth first algorithm is used. a child is pushed forward to explore a new area, it automatically does not look for its best position, which may result in never finding a narrow passage. We also figured out that just using one type of algorithm (depth first or breadth first) was not efficient. An environment may have long hallways as well as large open areas. Hence if our algorithm could switch between the two types in different branches of the tree, it would be able to cover that type of environment. 7 Future work We would like to make the stationary robots which are the leaves adjust themselves either by narrowing their sensor views or by rotating about their axes to find the maximum area to explore. We would like to make our algorithm be dynamic, so that it can include both depth first and breadth first algorithms in a single simulation/real time run. Depending upon the area being explored, the algorithm should be able to choose which technique to apply hence increasing the overall efficiency of the algorithm in an environment where there are large open areas and long hallways. We would like to extend our work to a 3D platform. The 3D environment will be provided by Gazebo which will replace the 2D environment provided by Stage. Ultimately, we are applying this algorithm to small robots built on the Handy Cricket robot platform using 3 IR sensors as we have used in the simulation. (See 8

10 8 Acknowledgement This project was supported by National Science Foundation grant EEC I would like to thank Professor Karen Sutherland, Paul Bjorkstrand, Jesse Docken, and Cory Nathe for help throughout this project. References [1] Stephen Damer, Luke Ludwig, Monica Anderson Lapoint, Maria Gini, Nikoloas Papanikolopoulos, and John Budenske, Dispersion and exploration algorithms for robots in unknown environments, Proceedings of the 2006 SPIE Meeting, SPIE, April [2] A. Das, G. Kantor, V. Kumar, G. Pereira, R. Peterson, D.Rus, S. Singh, and J. Spletzer, Distributed search and rescue with robot and sensor teams, Proceedings of Field and Service Robotics, Japan, July [3] James McLurkin and Jennifer Smith, Distributed algorithms for dispersion in indoor environments using a swarm of autonomous mobile robots, Proceedings of DARS2004, [4] Joshua Reich and Elizabeth Sklar, Toward automatic reconfiguration of robot-sensor networks for urban search and rescue, First International Workshop on Agent Technology for Disaster Management (ATDM): Fifth International Joint Conference on Autonomous Agents and Multiagent Systems (Hakodate, Japan), ACM, May [5] Paul E. Rybski, Ian Burt, Andrew Drenner, Bradley Kratochvil, Colin McMillen, Sascha Stoeter, Kristen Stubbs, Maria Gini, and Nikolaos Papanikolopoulos, Evaluation of the scout robot for urban search and rescue, Proceedings of the AAAI 2001 Mobile Robot Competition and Exhibition Workshop (Seattle, WA, USA), August