If robots are to be fully accepted in the homes and offices of the world, it is important that they are guaranteed

to be reliable and not to cause damage or harm. This requires testing robot systems and the software that comprises them. But testing robot software has always been a difficult process for developers. Issues of repeatability, safety, access to hardware and the general complexity of robot software are encountered. In industrial robotics, these difficulties are mitigated somewhat by the relatively simple, repeatable tasks and the controlled environment. Robotics for real-world environments, on the other hand, face the full challenges of testing. In this paper, we discuss regression testing at a low level of individual software components, particularly those components that are designed to interface with robot hardware. We present a software system for regression testing these components in a fully repeatable fashion as a case study of performing such testing in robotics. The presented system provides an efficient and quick method to monitor changes in the behaviour of software components as they are developed. Developers of robot software can quickly discover undesired changes and correct them. URC (ubiquitous robotic companion) is a new concept for a networkbased robotic system, in which a different kinds of robots are connected to a server system to provide various robotic services. In this paper, we introduce the client/server framework to provide context-aware services to network-based robots. We call the framework as CAMUS (context-aware middleware for URC systems). The CAMUS is mainly composed of three parts: service agent managers, CAMUS server and planet. The service agent manager is the robot-side framework to send robot's sensing data to the CAMUS server and receive control commands from the CAMUS server. The CAMUS server is the server-side framework to manage information from service agent managers, generate and disseminate appropriate events according to the context changes, and finally execute serverbased robot tasks. The planet is the communication framework between service agent managers and the CAMUS server. This paper also discusses the implementation of the URC field test applications. This paper presents a videophone service system based on the robot for young children. The proposed system for videophone service consists of a server, which mediates and manages client devices, and a robot, which acts as a client device. Robot in this paper is implemented to the embedded system, which has ARM11 hardware and embedded Linux for the OS. To make an easy phone call for young children, the robot video phone (RVP) module composed of the robot videophone main module and two kinds of libraries is proposed. To avoid the complicated usage of robot based videophone service for young children, the RFID technology is adopted. As young children

touch a RFID card to the robot, the robot can make a call to the specific number, which is contained in the RFID card.

We propose an integrated framework for testing and monitoring the model-based embedded systems. The framework incorporates three components: 1) model-based test generation for hybrid system, 2) run-time verification, and 3) modular code generation for hybrid systems. To analyze the behavior of a model-based system, the model of the system is augmented with a testing automaton that represents a given test case, and with a monitoring automaton that captures the formally specified properties of the system. The augmented model allows us to perform the model-level validation. In the next step, we use the modular code generator to convert the testing and monitoring automata into code that can be linked with the system code to perform the validation tasks on the implementation level. The paper illustrates our techniques by a case study on the Sony AIBO robot platform. We seek to make robot programming more efficient by developing a standard abstract interface for robot hardware, based on familiar techniques from operating systems and network engineering. This paper describes the application of three well known abstractions, the character device model, the interface/driver model, and the client/server model to this purpose. These abstractions underlie Player/Stage, our open source project for rapid development of robot control systems. One product of this project is the Player Abstract Device Interface (PADI) specification, which defines a set of interfaces that capture the functionality of logically similar sensors and actuators. This specification is the central abstraction that enables Player-based controllers to run unchanged on a variety of real and simulated devices. We propose that PADI could be a starting point for development of a standard platform for robot interfacing, independent of Player, to enable code portability and re-use, while still providing access to the unique capabilities of individual devices.