Abstract

This paper describes the architectural principles of a distributed agent-based platform for the remote supervision of robotic manipulation tasks. The main contributions of this paper are that the real-time constraints can be encapsulated within the local robotic controller through the methods of compliant control, and that such low-level API is the foundation for distributed applications that are evolvable, survivable, and that can guarantee stability and compliance even in the face of failures and lack of QoS provisioning. We discuss our experience with a prototype implementation and outline future research directions.

1. Introduction

In this paper, we discuss an approach for the implementation of complex software to control networked robots. The key point of this paper is that for a broad category of applications (manipulation tasks), the real-time constraints can be circumscribed and encapsulated within a local controller. Such local controller enables a remote agent to reason about robot behavior and to predictably direct robot operations even in the absence of QoS provisioning. As a result, such interface can be the foundation for a hierarchical and distributed multi-agent control platform. The benefits of this approach include:

1. The ability to interface with remote control components or human supervisors in the presence of time delays, both with and without QoS provisioning in the network infrastructure,
2. The ability to coordinate multiple robots and to aggregate robot teams into controllable units,
3. Control evolvability in terms of rapid re-programmability (addition of new functionality after hardware deployment), dynamic reconfiguration (creation of new collections of sensors, actuators, computers, robots, vehicles, and instruments into coordinated, task-oriented teams), and extensibility (growth through modular incorporation of additional assets),
4. Survivability and fault-tolerance (automatic reallocation of communications software in response to component failures).

We will describe the underlying principles of our approach, a prototype implementation, and report on our initial experience.

The paper is organized as follows. Section 2 outlines our goals. Section 3 discusses our technical approach both in terms of local controllers and of multi-agent systems. Section 4 reports on our prototype and on the experience we gained through it. Section 5 summarizes the mostly directly related work, and Section 6 concludes the paper.

2. Vision

Our vision is for an end-user to affect a remote physical environment through network interaction and action units. Ideally, a user needs an Internet connection, a robot unit, and the appropriate control software in order to accomplish remote manipulation tasks such as conducting an experiment in a remote facility. In order to achieve such objectives, we describe core technologies in networked robotics. Specifically, we investigate, implement, and evaluate agent-based software systems for the remote supervision of robotic manipulation tasks. Agents are software components that are autonomous, adaptable, reactive, knowledgeable, goal-oriented, flexible, learning, mobile, collaborative, and persistent [1,2]. Robot supervision achieves robot control through coarse-grained high-level directions, troubleshooting, and reprogramming. Manipulation tasks involve contact operations in which energy is exchanged between the robot and environment, resulting in a physical change in state of the environment, typically subject to force or kinematics constraints to prevent damage.

3. Technical Approach.

Our technical approach involves the following core technical elements:

1. The local robot controller provides an API that is based on compliant control; such local functionality supports remote communication in that it allows the robot control to remain gentle and safe for its environment even in the presence of delays, jitter, and communication failures. The compliant control API encapsulates the intelligence needed to cope with long delays and with an imprecise modeling of unstructured physical environments. As a result, compliant control establishes predictable and safe robot behavior and allows higher-level distributed software components to reason about the robot even in the presence of poor communication properties. Presumption of such a controller defines the interface and the appropriate communications context and level of abstraction.
2. The local API is wrapped into layers of increased abstraction (agents) that enable distributed and flexible operations. The agents implement supervisory control whereby the robot is directed through high-level, coarse-grained commands. Agents form a distributed system that operates over an underlying IP network. The platform supports agent mobility for evolvability, added fault-tolerance, and high end-to-end performance.

The rest of this section expands on the two complementary themes of compliant control and agent-based platforms.

Distributed Multi-Agent Supervision. This paper proposes an architecture for remote robotic control that utilizes sophisticated agents acting as intermediaries between the robot and the supervisor. These agents are capable of moving from one computer to another autonomously as resource needs change or as degraded service is detected. Additionally, this abstraction permits a programmer to add new functionality that wraps up existent robotic functionality. This allows a supervisor to create and inject new methods that will control the robot without actually reprogramming the robot itself.

An outline of the architecture is presented in figure 1. In a nutshell, the building blocks have the following functionality. The Remote Procedure Call Stub’s (RPCS) are simple middleware stubs that run at the robot sites, interface with the local on-board robot controller and with network communication, and are usually provided by the manufacturer or easily built from the manufacturer’s specifications. The Robot Proxies (RP) provide a thin legacy layer between the manufacturer’s RPCS and the agent-based control system. The Virtual Robots (VR) are autonomous and interacting agents that control the robot units. The Virtual Supervisors (VS) are agents with which human experts or intelligent systems interact and that convey supervisory commands to the virtual robots. The Virtual Emergency Contacts (VEC) are agents that seek human experts in case of an emergency by messaging, paging, and the like. The look-up service keeps track of the services that are currently registered within the system. We next describe in more details the salient features of VR’s and VS’s.

Virtual Robots (VR’s). Virtual robots (VR’s) are agents that compose the core of our architecture. VR’s can act autonomously or semi-autonomously, in which case a supervisor typically supplies only high-level directions. VR’s are collaborative, since they must transmit information between themselves and also the supervisor and the robots. The communication flow is induced by the notion of virtual containment and, in a graphical representation (Figure 1), the higher-level VR’s virtually contain the VR’s and RP’s below it. Formally, let T be a tree on the set of agents such that the root of T is the VS, the leaves are the RP’s, and the internal nodes are VR’s. An agent x is said to virtually contain an agent y in the communication pattern induced by T if y is a child of x. Similarly, an agent y is said to be virtually contained by x in the communication pattern induced by T if x virtually contains y. (Further references to a specific tree T will be omitted when the ordering is clear from the context.) An agent x can invoke methods only on the agents that contain x or that are contained by x. Thus, the virtual containment relationship enforces as a hierarchical organization of the robot communication pattern where the higher agent in the chain of command gives orders to its subordinates, which in turn can report sensory data, warnings, or computational results back to their direct leader. Meanwhile, virtual containment also describes properties of cooperating robotic teams in the physical world. For example, if a robot platoon contains two physical robots, there could be a VR for the entire team that contains the VR for each one of the two composing robots. The top level VR represents the team and executes coordinated operations by invoking functionality of the two lower-level VR’s. Thus, virtual containment represents properties of a robotic system that are intuitive in terms of the robot behavior and coordination in their physical environment. However, virtual containment is not expressive of the containment relationship in the corresponding ontology in that the definition of the top-level VR class does not contain lower-level VR classes.

A special case of the virtual containment relationship is when VR’s are organized in a chain. In this case, there is no cooperation among multiple units, however the VR chain allows a designer to implement layers of increasingly complex functionality. For example, a VR in our current prototype (Section 4) implements functions to toggle each one of a set of switches. Another VR could implement a higher-level function like EverythingOn() that moves all switches and buttons to the “on” position by invoking the existing individual functions on the switches. Using just the one EverythingOn() command abstracts existing methods into a more complex functionality, makes it easier to aggregate robot operations into longer and more meaningful sequences, and saves a human supervisor the trouble of having to invoke each method individually from the VS GUI.

The VR’s are sophisticated mobile agents that can move from one computer to another as the task they are charged with executing changes and give different priorities to various resources. VR’s can decide without input when it is beneficial to move from one computer to another. Since the decision about whether or not the VR should move itself to another computer is based upon the resources available at its current location and others, the VR is knowledgeable about itself and surroundings and is highly adaptable and resilient. However, at this stage of the project, the development of intelligent mobility strategies is at its preliminary stages. Finally, the ability of creating new VR’s, interconnecting them into a virtual containment network, and letting them find dynamically an execution environment, allows the loading of code at run-time without recompilation of existing software components or changes in the robotic firmware.

Virtual Supervisors (VS’s). The Virtual Supervisors (VS’s) are, in some sense, top-level VR’s, but can also be responsible for the GUI with a human expert. In particular, the VS displays to the human supervisor the result of callback functions from the robot or sensor streams that depict the most current state of the robot workspace. Furthermore, the VS represents in a GUI the function that can be invoked on a VR and allows the operator to issue the appropriate function calls. We have also investigated whether it is possible to generate GUI’s for VR function calls dynamically. When a VR reports a method with some number of parameters and the supervisor indicates to the VS that he or she has an interest in executing that method, the virtual supervisor dynamically creates controls that are good representations of each parameter’s type. For example, a range parameter can be represented by a sliding bar (see Section 4). The human supervisor can then manipulate these newly created controls to reflect the parameter values he wishes to send to the method. At present, only the basic data types are associated with a class of controls that may be displayed on the VS. In general, this limited set of widgets could severely restrict the type of GUI that can be created dynamically, but in our experience such widgets were more than sufficient to dynamically generate GUI’s for a surprisingly large number of interfaces.

Compliant Control. Networked communication is subject to long delays, packet losses, communication failures, and jitter and all of these factors impact the stability and performance of a robotic system. For example, a space robot controlled in real-time directly from Earth can become unstable or tremendously inefficient even when delays are of the order of 100ms or less. As a result, the robot cannot be guaranteed to be resilient and safe for its environment. Compliant control is a set of techniques to guarantee robot stability even in the presence of arbitrary delays, packet losses, or jitter as long as the environment dynamics can be roughly characterized. Compliant control is based on the two techniques of natural admittance control and virtual attractors, which are described next.

The first component for compliant control is natural admittance control (NAC). NAC is based on a set of parameters that prescribe desirable admittance dynamics that the robot should emulate. For example, a NAC robot can be instructed to wash a window if the NAC parameters are set so that the robot behaves relatively stiffly in directions tangent to the glass and compliant normal to the glass. As another example, a NAC robot can be instructed to open a door if the NAC parameters are set so that the robot behaves relatively stiffly in the expected direction of motion and complies gently in directions corresponding with the hinge constraints (incidentally, it is not necessary to know these direction axes at all precisely).

NAC was introduced by one of the authors and has been advanced over the last 14 years. NAC has demonstrated pioneering compliant motion control on a variety of robotic manipulators and control platforms [4-16]. The NAC method has been shown to be responsive, stable, and portable across robots and controllers. While NAC controller performance is a continuing objective of on-going research, this technology is sufficiently developed that it can be used now as a foundation for remote controls.

A second component of compliant control is the notion of virtual attractors. A virtual attractor is a point in the three-dimensional space to which the robot end-effector is virtually connected by means of a set of fictitious springs and dampers of specified stiffness and damping. The use of virtual attractors, springs, and dampers is illustrated schematically in Figure 2. Virtual attractor behaviors enable a designer to visualize and produce desirable interaction dynamics. Furthermore, the virtual attractor can be moved over time, thereby forcing the robot end-effector to follow it according to the dynamics specified by the virtual springs and dampers. For the example of washing glass, the virtual attractor would move along coordinates projected onto the tangent plane of the glass, but would be displaced slightly into or through the plane of the glass. As a result, the virtual attractor will be followed closely by the end-effector on the glass plane while the attractor displacement normal to the glass causes a stretch of a soft virtual spring, thus producing a desired pre-load (normal force). With this combination of virtual attractor trajectories and virtual springs, the robot can perform surface following, can fit parts together, can turn a crank, and can cooperatively manipulate large objects in collaboration with other robots.

We have found that the definition of virtual impedance and a virtual attractor conveniently constitutes a simple and effective interface between the dynamic interaction control layer and higher-level intelligence [12-15]. In particular, this paradigm served as the interface between a local controller and a networked control system. This core technology helps us to define the appropriate communications approach for future intelligent robots, including level of abstraction, a relevant communications protocol, and the associated demands on and implications of network behavior.

One area where compliant control helps remote supervision is that the harder real-time constraints are encapsulated within the RPCS. As a result, the agent infrastructure is freed from hard or soft real-time constraints. It is however desirable if certain real-time considerations were incorporated in the VR hierarchy. For example, compliant control guarantees that the unit remains safe to its environment even when supervisory commands are late or desultory. However, it is still desirable to submit supervisory instruction in a timely fashion to avoid abrupt movements of the robot end-effector. By the same token, the notion of compliant control removes the absolute requirement of isolating the operations of different VRs, but it is again desirable if some level of separation were achieved.

4. Experience

Prototype. The prototype was written in the .net framework in the C# language and uses the .net runtime environment and the SOAP remote procedure call protocol. The prototype allows a VS to create agents, move them from one host to another, interconnect agents, locate robot controllers, and instruct the robot to execute tasks on the robot workspace.

Demonstration. As an application of our prototype, we have demonstrated that a robot can conduct an experiment in the physical sciences in an emulated environment with the assistance of a remote investigator. Figure 3 demonstrates the VS GUI of the current prototype. The window on the right is a live WebCam feed from the robot workspace and shows a set of switches, levers, and toggles that the remote robot can open and close. This environment is a mock-up that models the controls that could be manipulated during an experiment in fluid dynamics. The left window shows the VS panel. The forefront tabs gives the functions that a human supervisor can invoke on the VR, including moving the large metal switch, rotating the level valve, and the like. The highlighted function is “Large Metal Switch” and it will be invoked if the operator clicks on the “Go” button. The parameter required to execute the “Large Metal Switch” method has been graphically displayed in the upper right. It is an input of type “range”. Range types describe data that must fall within a certain range of values, in this case one of three values (corresponding to three states of the large metal switch, either neutral or switched to the left or right). The virtual supervisor selected its default control to represent a range input, a horizontal slider. Each of the three stops along the slider indicates a possible input. Upon holding the mouse cursor over the method name, a tool tip has appeared, informing the supervisor of the name and return value of the method (in this case there is no return value). In general, the VS renders controls to represent the basic data types and thus molds itself into the form of the VR to which it connects. The other tabs in this window allow a human engineer to create new VR’s and to interconnect them on the basis of virtual inclusion relationships.

At the other extreme of the system, the robot on-board controller is essentially a procedure that takes as an argument the succinct description of a virtual attractor trajectory [2-18] that the robot end-effector will attempt to follow in the three dimensional space. The corresponding RPCS is a simple middleware stub that runs at the robot site and allows a remote client to call such a procedure, thereby setting the parameters for the robot dynamics. Analogously, the RPCS supports callback functions from the robot controller to a remote client. In our investigation, we were able to manipulate these controls gently, safely and effectively using NAC and virtual attractors, as commanded from the remote VS. We are thus confirmed that this approach is a key element in interfacing to intelligent systems performing contact operations. The RPCS interface is exposed by the RP, to a controlling VR, which directs the robot to move the various levers, valves, and switches.

Tele-operation. The GUI shown in the figure demonstrates the more typical operations of the platform (supervision), whereby methods are invoked on VR’s, which in turn sets the trajectory of a virtual attractor. We also experimented with classical tele-operation, whereby the remote supervisor can set the position of the end-effector by dragging a mouse or handling a haptic input device whose input the robot attempts to follow. Tele-operation differs from supervisory control in that tele-operation demands the human expert to specify exactly the position of the end-effector at all instants in time, whereas supervisory control (such as that shown in Figure 3) only requires the human expert to select a discrete task execution like “Close the large metal switch”. Incidentally, tele-operation was easily implemented within our framework: a VR sets impedance parameters to infinite stiffness and the VS GUI shows graphically the robot workspace, the current mouse position, and the current end-effector position. The operator can then move the end-effector by dragging the mouse. Tele-operation was conducted on the same LAN as the robot, in which case tasks were indeed achieved but the low resolution of the WebCam image and the lack of a sense of depth made manipulation somewhat difficult. Subsequently, a wide-area emulator (dummynet) was inserted between the supervisor and the robot and caused artificial one-way delays of 200ms. The presence of these delays made tele-operation extremely slow and ineffective, but had only a minor impact on supervisory control. We are thus confirmed that supervisory control is practically necessary over long-haul links, but we also discovered that supervisory control could be more efficient than tele-operation even over low-delay links if the robot workspace cannot be rendered accurately.

5. Related Work

The goal of refining remote robotic supervision is not new, with attempts increasingly focused on Internet control [19-27]. Internet control has proven itself to be an excellent medium for remote control because there exist standard Internet protocols, which have been utilized by many robots and robotic controllers [28]. Previous work in Internet robotics demonstrates that the technology for controlling robots over the Internet is not yet mature due to the potentially long and unpredictable delays in current IP networks [25]. However, there is evidence that it should be possible to implement non-real-time robot control [26].

Previous related projects include network-based tele-operation with reflexive collision avoidance [29], a prototype robot that sorts laundry under the supervision of a remote homeowner [30], and the support for the reprogramming of advanced production line robots from a remote laptop or PDA [31]. Early demonstrations of networked robotics are surveyed in [26, 27, 30] and highlight the impact of poor levels of network service on tele-operation and the consequent reliance on non-real-time control.

Traditional robotic control involves a myriad of varying components. Some industrial robots are programmed directly while some are controlled through a separate computer to which they must always remain attached. The operating system that controls the robot or its computer controller differs from one manufacturer to the next. Sometimes they are standard and often they are completely proprietary. The languages in which robotic controller code is developed also vary greatly, typically being proprietary to the robot manufacturer. With all of these differing factors, it quickly becomes quite difficult to program or control multiple robots from differing manufacturers. This is especially so when multiple robots must be coordinated to cooperate in achieving a single objective [31]. Furthermore, each robot typically has a static, centralized controller that exposes its own interface with which interaction may take place. Using those interfaces, the remote controller may send messages in the language defined by the robot. Various attempts have been made to make a standard language that all robots could recognize and thus simplify the communication process [32-34]. Even with such attempts, a fully accepted universal language for use in passing messages to robots far from a reality. Part of this problem is the wide range of activities that robots can perform makes the creation of a language that can adequately describe all of them difficult. Trying to remotely control two different robots, then, nearly always implies the need to work with vastly different interfaces that accept messages formed in vastly different languages. However, a better programming practice should stem from more standard protocols and communication middleware [36, 37].

6. Conclusions

Summary. In this paper, we have described the architectural principles for the remote supervision of robotic manipulation tasks and reported our experience with a prototype of this system. The main idea of the paper is that the harder real-time requirements can be encapsulated within the robot local controller through the intuitively appealing paradigms of natural admittance control and virtual attractors. Such local controller guarantees that the robot remains stable, gentle, and compliant even in the presence of packet losses, delays, and jitter. Furthermore, such interface allows the implementation of a hierarchical application that is distributed, agent-based, and evolvable.

Future Work. A clear issue for future work is the need for authentication and authorization of supervisors, and more generally for security. Another fundamental issue pertains the performance of the robotic units. The main conclusion of this paper is that stability, compliance, and sophisticated software controls are possible if appropriate real-time requirements are encapsulated locally. As a result, this approach removes real-time requirements from the distributed control software. However, while the resulting system is indeed stable and compliant, it could still be slow and ineffective if the network level of service is poor. In other words, while our approach does not require a good level of service for stability and physical safety, our methods nevertheless make good network behavior desirable to ensure adequate robot performance. One way to ameliorate the network behavior is to provide for Quality-of-Service in the network. However, higher levels solutions are also possible and can be expressed in terms of agent placement and mobility. For example, if a VR is placed closer to the robotic unit, it will probably be able to communicate with the robot with lower delays, losses, and jitter. Analogously, certain failures can be viewed as cases when certain metrics of system performance have dropped to zero, in which case a mobile VR can attempt to find a more appropriate host. Thus, agent placement and mobility is also critical for continued operations in the face of network failures [38]. A main issue for future work is to investigate strategies and performance of agent placement and mobility algorithms in terms of robotic behavior in the physical world.

Acknowledgments

This work was supported in part by NASA under grants NAG3-2578 and NAG3-2799.

References

[1] S. Graham, S. Simeonov, T. Boubez, D. Davis, G. Daniels, Y. Nakamura, and R. Neyama. Building Web Services with Java. SAMS, 2002.

[2] M. L. Griss and G. Pour. “Accelerating Development with Agent Components”. Computer, 34 (5), 37-43, May 2001.

[3] Nipi, Giri; Ghosh, Amitabha; Sriram, K. “Design and Developement of a master slave teleoperated robot.” (October, 1999).

[4] Mathewson, B.B. and W.S. Newman. "Integration of Force Strategies and Natural Admittance Control". in Proceedings of the ASME Mechanical Engineering Congress and Exposition, DSC-Vol 55-1. 1994. Chicago, IL: ASME.

[5] Newman, W. S., and Zhang, Y., “Stable Interaction Control and Coulomb Friction Compensation Using Natural Admittance Control,” Journal of Robotic Systems, Vol. 11, No. 1, pp. 3 - 11, 1994.

[6] Glosser, G. D., and Newman, W. S., “Implementation of a Natural Admittance Controller on an Industrial Manipulator,” Proceedings of IEEE Int. Conf. on Robotics and Automation, May, 1994.

[7] Newman, W. S., “Stability and Performance Limits of Interaction Controllers,” Transactions of the ASME Journal of Dynamic Systems, Measurement, and Control, Vol. 114, No. 4, pp. 563-570, 1992.

[8] Newman, W. S., Branicky, M. S., Chhatpar, S., Huang, L., and Zhang, H., “Impedance Based Assembly,” Video Proc. of IEEE Int. Conf. On Robotics and Automation, Detroit, MI, 1999.

[9] Newman, W.S., et al. "Force-Responsive Robotic Assembly of Transmission Components". In Proc. IEEE Int. Conf. on Robotics and Automation. 1999. Detroit, MI: IEEE.

[10] Dohring, M.E. and W.S. Newman. "The Effect of Robot Design on Force Control Performance with Implications for Micro-Gravity Applications". in AIAA. 1994. Huntsville, AL: AIAA.

[11] Newman, W.S. and M.E. Dohring. "Augmented Impedance Control: An Approach to Compliant Control of Kinematically Redundant Manipulators". in Proc. IEEE Int. Conf. on Robotics and Automation. 1991. Sacramento, CA

[12] Morris, D., Hebbar, R., Newman, W., "Force-Responsive Robotic Assembly of Powertrain Components", IEEE Int. Conf. on Robotics and Automation, 2001.

[13] Hebbar, R., Morris, D., Chhatpar, S., Branicky, M., and Newman, W., "Force-Guided Assemblies Using a Novel Parallel Manipulator", IEEE Int. Conf. on Robotics and Automation, video proceedings, 2001.

[14] R. Hebbar, S. Chhatpar, C. Birkhimer, R. Stoughton, D. Kozlowski, M.Branicky, and W. Newman, “Flexible Robotic Assembly for Power-train Applications (FRAPA)”, IEEE Int. Conf. on Rob. and Auto., video proceedings, 2002.

[15] Wei, J. and Newman, W. S., “Improving Robotic Assembly Performance through Autonomous Exploration”, IEEE Int. Conf. on Robotics and Automation, 2002.

[16] Dohring, M. E. and Newman, W. S., “Admittance Enhancement in Force Feedback of Dynamic Systems”, IEEE Int. Conf. on Robotics and Automation, 2002.

[17] Bellavista, P, Corradi, A., and Stefanelli, C. “Mobile Agent Middleware for Mobile Computing”. Computer, 34(3):73-81, 2001.

[18] Wong, D., Paciorek, N., and Moore, D., Java-Based Mobile Agents. CACM, 42(3):92-102, 1999.

[19] Sayers Craig, Richard Paul, Dana Yoerger, Louis Whitcomb, and Josko Catipovic (WHOI). “Subsea Teleprogramming”, http://www.cis.upenn.edu/~sayers/tele/subsea.html May 1995

[20] Sayers Craig, Augela Lai and Richard Paul. “Visual Imagery for Subsea Teleprogramming”, IEEE Robotics and Automation Conference, May, 1995.

[21] Sayers Craig and Richard Paul. “An operator interface for teleprogramming employing synthetic fixtures”, Presence, Vol. 3, No. 4, 1994

[22] Scalable Coordination of Wireless Robots ftp://deckard.usc.edu/pub/arena

[23] Card S. K., Moran T. P., Newell A. “The psychology of human-computer interaction”. Hillsdale, NJ, Lawrence Erlbaum Associates. (1983).

[24] Taylor K. and Dalton B., “Internet Robots: A New Robotics Niche”, IEEE Robotics and Automation Magazine, 2000, pages 27-34

[25] Tarn T. J. “Live Remote Control of a Robot via the Internet”, IEEE Robotics & Automation Magazine, pages 7-8, September 1999

[26] Goldberg Ken, et. al., “Desktop Teleoperation via the World Wide web”. IEEE Int. Conf. On Robotics and Automation, 1995, pages 654-659.

[27] Goldberg Ken and Joseph Santarromana (UC Irvine). “The Telegarden” http://www.usc.edu/dept/garden/ , 1995

[28] Ghiasi, Soraya; Zorn, Benjamin. University of Colorado. “A Reusable Framework for Web-based Teleoperation of Robotic Devices” (June 2000).

[29] Chuckpaiwong, Ittichote. Case Western Reserve University. “Reflexive Collision Avoidance for a Novel Parallel Manipulator” (2001).

[30] Lung Ngai; Newman, W.S.; Liberatore, V. An experiment in internet-based, human-assisted robotics. Robotics and Automation, 2002. Proceedings. ICRA '02. IEEE International Conference on , Volume: 2 , 2002. Page(s): 2190 –2195.

[31] D. Anzola. A Remote Teach Pendant Interface for an Novel Parallel Manipulator. M.S. Project, CWRU (W. S. Newman, advisor).

[31] Fong, Terrance; Baur, Charles. “Multi-robot driving with collaborative control.” (July 2002).

[32] Munson, Michelle; Hodes, Todd; Fischer, Thomas; Lee, Keung Hae; Lehman, Tobin; Zhao, Ben. IBM/Berkley. "Flexible Internetworking of Devices and Controls". (1999).

[33] Bates, J.; Bacon, J; Moody, K; Spiteri, M. “Using Events for the Scalable Federation of Heterogeneous Components.” (September 1998).

[34] Gelernter, D. “Generative Communication in Linda”. (January 1985).

[35] D. Rosas. Multi-agent supervision of generic robots. M.S. Thesis, Case Western Reserve University, 2002. (Advisors: V. Liberatore and W. S. Newman).

[36] D. C. Schmidt. Middleware for Real-Time and Embedded Systems. Communications of the ACM, 45 (6), 43-48, June 2002.

[37] http://www.realtime-corba.com

[38] D. B. Lange and M. Oshima. Programming and Developing Java Mobile Agents with Aglets. Addison-Wesley, 1998.