Controlling Logistics Robots with the Action-Based Language YAGI

Proceedings of the 12th International Conference on Agents and Artificial Intelligence, 2020

The field of Cognitive Robotics aims at intelligent decision making of autonomous robots. It has matured over the last 25 or so years quite a bit. That is, a number of high-level control languages and architectures have emerged from the field. One concern in this regard is the action language GOLOG. GOLOG has been used in a rather large number of applications as a high-level control language ranging from intelligent service robots to soccer robots. For the lower level robot software, the Robot Operating System (ROS) has been around for more than a decade now and it has developed into the standard middleware for robot applications. ROS provides a large number of packages for standard tasks in robotics like localisation, navigation, and object recognition. Interestingly enough, only little work within ROS has gone into the high-level control of robots. In this paper, we describe our approach to marry the GOLOG action language with ROS. In particular, we present our architecture on integrating golog++, which is based on the GOLOG dialect Readylog, with the Robot Operating System. With an example application on the Pepper service robot, we show how primitive actions can be easily mapped to the ROS ActionLib framework and present our control architecture in detail.

The Journal of Logic Programming, 1997

This paper proposes a new logic programming language called GOLOG whose interpreter automatically maintains an explicit representation of the dynamic world being modeled, on the basis of user supplied axioms about the preconditions and e ects of actions and the initial state of the world. This allows programs to reason about the state of the world and consider the e ects of various possible courses of action before committing to a particular behavior. The net e ect is that programs may be written at a much higher level of abstraction than is usually possible. The language appears well suited for applications in high level control of robots and industrial processes, intelligent software agents, discrete event simulation, etc. It is based on a formal theory of action speci ed in an extended version of the situation calculus. A prototype implementation in Prolog has been developed. / This research received nancial support from the Information Technology Research Center (Ontario, Canada), the Institute for Robotics and Intelligent Systems (Canada), and the Natural Science and Engineering Research Council (Canada). Levesque and Reiter are fellows of the Canadian Institute for Advanced Research.

1999

In this paper, we present a multi-layered architecture for spatial and temporal agents. Agent scripts can be realized as (constraint) logic programs. The logical description language is able to express actions or plans for one and more autonomous and cooperating agents for the RoboCup (Simulator League). We focus on the presentation of the script language for basic and complex skills. £ A revised and extended version of this paper will appear in RoboCup-99: Robot Soccer World-Cup III, Springer-Verlag, LNAI series.

Practical Aspects of Declarative Languages, 2003

ACTILOG is a language to write generalized condition → action activation rules. We propose it as an alternative and a complement to OPENLOG [6], another agent logic programming language for an abductive reasoner. We want to show how implications (conditional goals) can be used to state integrity contraints for an agent. These integrity contraints describe conditions under which the agent's goals must be reduced to plans that can be executed. For instance, a rule such as if A then B, will indicate to the agent that whenever it can prove that A is the case, it then should pursue goal B. B is normally the description of a task that must be reduced to a set of low-level, primitive actions that the agent can execute.

2008 International Multiconference on Computer Science and Information Technology, 2008

Effective study of autonomous agents is a challenging activity, for researchers and programmers alike. In this paper we introduce a new agent environment built on top of the tank-simulation game Robocode. We consider this game a good choice for testing agent programming strategies and an excellent learning opportunity. We integrated SWI-Prolog into Robocode and built an architecture for writing agents with Prolog. Game generated events are translated by our framework into predicate invocations, allowing the agent to perceive the environment. An API to issue commands to the tank from Prolog acts as agent's effectors. We tested our architecture by implementing a simple autonomous agent that uses a static strategy.

2009

IndiGolog isaprogramming languagefor autonomousagentsthat sense their environment anddo planning astheyoperate. Insteadof classical planning, it supports high-level program execution. The programmer provides a high-level nondeterministicprograminvolving domain-speci? c actions andteststo perform the agent’s tasks. The IndiGolog interpreterthenreasons aboutthepreconditions andeffectsofthe actionsintheprogramtonda legalterminatingexecution.To support this, the programmer provides a declarative specication of the domain (i.e.,primitive actions,preconditions andeffects, whatis known aboutthe initial state)inthe situation calculus. Theprogrammer can controlthe amountof non-determinism in the program and how muchof it is searched over. The language isrichand supports concurrentprogramming.Programsareexecuted onlinetogether withsensingthe environment and monitoringforevents,thus supporting thedevelopmentofreactiveagents.We discussthe language, itsimplementation, and applicationsthathave beenrealized withit.

2005

Intelligent agent development has imposed new challenges on the necessary language support. Object-oriented languages have been proposed as an appropriate tool, although logic-oriented languages are more adequate for managing mental attitudes. Multi-paradigm languages supporting encapsulation of actions, hiding of private knowledge and exible manipulation of knowledge are, certainly, a good alternative for programming agents. However, a unique language to support exible and e cient development of multi-agent systems confronts with the tradeo s imposed by expressive power, e ciency and support technology. An alternative to conciliate these tradeo s is not to think about a single language but an incrementally compatible family of agent-oriented multi-paradigm languages. In this work we present an approach based on object-oriented framework technology for integrating object and logic paradigms in such a way that new language features can be incrementally added to the core language. This core language is based on logic modules integrated as object abstractions in the object paradigm. JavaLog is a materialization of this framework integrating Java and Prolog. This core was extended to provide multi-threading support, mobility and temporal-logic operators to Prolog. MoviLog, the mobile part of the family provides a novel mobility mechanism, reactive mobility by failure, which enables virtual Prolog databases distributed across Web sites.

shift from robots big and expensive-like the mainframes-to small and pervasives ones-personal computers. This shift can be interpreted as the transition from robots who compose assembly lines of automobile manufacturing or in military missions (e.g drones for US Army), to robots who perform companionship activities, physical assistance or cleaning tasks. In this perspective, robot programming becomes a very important aspect, like programming stardard applications. That is, robots are considered as computer systems, not just electronic and mechanic devices. Considering that, this thesis will mainly focus on programming robotic control systems, that is a challenging tasks for today's programmers with even a basic under-This thesis aims at tackling this issue, taking into account an agent-based approach for programming robots. In particular, we are going to use the BDI (Belief, Desire, Intention) model, which directly encompasses all the necessary features to program a robot and help to cope with typical robotics issues. With regard to the above considerations, this thesis will explore a method to design robot controllers by means of high level languages and architectures like Jason and CArtagO. In order to do the experiments and tests, the Webots robot simulator platform is used. The platform allows to create simulated worlds and robots, and provides proper API to develop the required bridge to integrate heterogeneous programming language and systems for controlling the robot. A set of small but relevant programming examples is used to compare the different approaches just mentioned. The different investigations will deal both with standard and high level programming languages in order to fulfill the aimed goals. Of course programming robots is a non-trivial task, but in this work we show how agent programming languages and technologies could be a promising approach for easing the development of articulated robot programs, im

INTELIGENCIA ARTIFICIAL, 2006

A rational agent exploring a complex and dynamic environment with incomplete information needs cognitive capabilities, e.g. planning, in addition to its perception and reaction for basic functionalities. However, mere planning, i.e., reasoning about sequences of actions, is not sufficient to solve problems in such complex environment. This is because (i) agents need to execute actions while they plan, (ii) they must gather and interpret sensor information, (iii) revise their world model, and (iv) adapt their own goals during a task. The knowledge representation and non monotonic reasoning area has shown the advantage of using logical formalisms to specify rational agents for complex robot applications, also called cognitive robotics applications. An example of such formalism is the Golog language and its different dialects. What those areas are still missing is implementational testbeds to evaluate existing theories. Since practical experimentation highlights the need for the improvement of existing formal theories at the ontological level. This work presents a logic-based implementation of an agent for the Wumpus World domain, which can be envisaged as a simplified model of an agent that reasons logically about its actions and sensor information in the presence of incomplete knowledge. Through a complete implementation of an agent in a real robot, the Lego R MindStorms TM robot, we show some experiments to verify that the Wumpus World can be an implementational testbed used to identify difficulties in transforming theory into operational solutions.

Autonomous Agents and Multi-Agent Systems, 2008