Multiple robot programming using a concurrent logic language

Advances in robotics has led to the cooperation of multiple robots among themselves and with their industrial automation environment. Efficient interaction with industrial robots thus becomes one of the key factors in the successful utilization of this modern equipment. When multiple manipulators have to be coordinated, there is a need for a new programming approach that facilitates and encompasses the needs of concurrency, synchronization, timing, and communication. Most robot languages have been developed with little attention being given to the integration of the robot with its environment. Currently, there is a gap between the robot capabilities, the task definition environment, and language facilities supplied to use robots.This paper analyzes the needs and then establishes that a concurrent logic programming approach is a step towards achieving a multi-robot knowledgeable task programming. In particular, the FCP dialect of concurrent Prolog is demonstrated, and analyzed.This research is partially supported by the Paul Ivanier Center for research in robots and production management.     

Highly dependable concurrent programming using design for verification

There has been significant progress in automated verification techniques based on model checking. However, scalable software model checking remains a challenging problem. We believe that this problem can be addressed using a design for verification approach based on design patterns that facilitate scalable automated verification. In this paper, we present a design for verification approach for highly dependable concurrent programming using a design pattern for concurrency controllers. A concurrency controller class consists of a set of guarded commands defining a synchronization policy, and a stateful interface describing the correct usage of the synchronization policy. We present an assume-guarantee style modular verification strategy which separates the verification of the controller behavior from the verification of the conformance to its interface. This allows us to execute the interface and behavior verification tasks separately using specialized verification techniques. We present a case study demonstrating the effectiveness of the presented approach.     

Preserving abstraction in concurrent programming

Recent programming languages have attempted to provide support for concurrency and for modular programming based on abstract interfaces. Building on experience of adding monitors to CLU, a language oriented towards data abstraction, it is explained how these two goals conflict. In particular, the clash between conventional views on interface abstraction and the programming style required for avoiding monitor deadlock is discussed. It is argued that the best compromise between these goals is a combination of a fine-grain locking mechanism together with a method for explicitly defining concurrency properties for selected interfaces     

Higher-order communications for concurrent programming

In Pettorossi and Skowron (1983) a recursive-equations language is introduced. Its operational semantics is specified by means of computing agents which communicate and exchange messages. Those communications are, so to speak, zero-order, in the sense that the exchanged messages are values of a data structure, possibly defined by the programmer.

In this paper we extend that approach and we consider also ‘higher-order’ communications by allowing the exchange of agents behaviours, i.e. sets of computations, among computing agents. This extension leads to a new programming methodology which makes use of proofs of computing agents behaviours and their related strategies.     

Developing control logic using aspect-oriented programming and sequence planning

A fundamental functionality of a Programmable Logic Controller (PLC) is to control and execute a set of operations. But a large part of the program code is more involved in supporting the user with concerns like alarm, HMI, communication, safety and manual control. Code related to these supporting concerns is often tangled with operation execution code, the core concerns, which makes it hard to reuse.This paper describes a method to reuse code and functionality when developing PLC programs and code libraries. The method proposes that core concerns are planned with a software tool called Sequence Planner, and the supporting concerns are integrated into the core concerns with a tool based on aspect-oriented programming.     

Model-based space planning for temporary structures using simulation-based multi-objective programming

Construction trades need to share temporary structures to increase the output of direct work while controlling the labor input of indirect work. The purpose of this research is to develop a framework to determine the optimal location of temporary structures in a computerized practical manner for piping construction projects. Based on the spatial relationship between work envelope and scaffolding placement requirements, this paper presents the optimization model in two phases: the simulation-based optimization model and a multi-attribute utility (MAU) based alternative selection model. A multi-objective optimization model is established to improve scaffolding availability among multiple activities while maximizing piping crew productivity. The multi-attribute utility model is employed to handle the uncertainty of the assessment weights on the attributes to illustrate the preference of decision makers among different scaffolding placement alternatives obtained from the first phase. The approach was validated in a piping module, which provided superintendents and space planners with an effective decision-making tool among possible scaffolding alternatives in piping construction. The proposed optimization technique is an alternative methodology for solving the productivity-tasks-scaffolding trade-off problem, which further revolutionizes the spatial coordination process of workspace management and temporary structure planning.     

Distributed dynamic programming using concurrent object-orientedness with actors visualized by high-level Petri nets

This paper deals with application of concurrent object-oriented programming with Actors to solve dynamic programming problems in a distributed computing environment. This area of research is often called distributed artificial intelligence. Using a dynamic programming example of chained matrix multiplication, a method of managing dynamic programming searches in a distributed programming environment with Actors is presented. Distributed computations with Actors are visualized by means of Time-Varying Automata (for cases with no intra-actor concurrency) or using a class of high-level nets called Hierarchical Colored Petri Nets (for cases with intra-actor concurrency). Design and implementation features of the specific Actor-based programming environment, using a concurrent extension of C++, are also discussed.     

Mobile robot path planning using artificial bee colony and evolutionary programming

In this paper, an evolutionary approach to solve the mobile robot path planning problem is proposed. The proposed approach combines the artificial bee colony algorithm as a local search procedure and the evolutionary programming algorithm to refine the feasible path found by a set of local procedures. The proposed method is compared to a classical probabilistic roadmap method (PRM) with respect to their planning performances on a set of benchmark problems and it exhibits a better performance. Criteria used to measure planning effectiveness include the path length, the smoothness of planned paths, the computation time and the success rate in planning. Experiments to demonstrate the statistical significance of the improvements achieved by the proposed method are also shown.     

A long range production/resource planning system using linear programming

In January 1985, a project was initiated to optimize and update the entire Production Planning function, including long-range and short-range scheduling, Material Requirements Planning, and a Production/Resource Planning System for the Molding and Assembly area. This paper addresses the latter.

The Molding and Assembly area at Johnson Wax molds and assembles caps and their components for our products. We were looking for a long range strategic plan for the area. The natural solution was optimization in the form of linear programming.

The models were set up on Control Data's Cybernet Computer using PDS/Magen (for matrix generation) and APEX IV (for problem solving). This was accessed from an IBM-XT via a modem. (The models have since been moved to our inhouse IBM 3083 Mainframe and use Haverly Systems' OMNI and MPSX-370.) The project involved gathering information on the Molding and Assembly area, developing and testing a prototype, developing the data base and data tables for all caps concerned, expanding the prototype and developing the program to handle all caps, preparing output reports (using FOCUS Information Management System), and final implementation.     

Some aspects of concurrent programming in CCNPASCAL

CCNPASCAL is a language derived from Pascal and Concurrent Pascal which has been used in the development of an operating system for a multiprocessor. This paper introduces some of the important features of the language and illustrates them with examples. The language provides mechanisms for interfacing separately compiled modules, for building abstractions of collections of resources and for efficient asynchronous communication.     

A lingua franca for concurrent logic programming

Two of the more important concurrent logic programming languages with nonflat guards are GHC and Parlog. They balance the requirements of having clean semantics and providing good control facilities rather differently, and their respective merits are compared and contrasted. Since concurrent logic programming would benefit from both, but neither language is able to express all the programs expressible in the other language, a lingua franca of these languages is defined and justified. A method is given for translating GHC and Parlog to and from it. The method preserves the arities and execution conditions of each clause. It enables a lingua franca implementation to support both languages transparently, and to provide a simple concurrent logic programming language suitable for programming in its own right     

Local-global concurrent path planning and execution

Sensor-based discovery (i.e. dynamic) path planning is problematic because the path needs to be continually recomputed as new information is discovered. A process-based client-server approach is presented that permits concurrent sensor-based map and localization-correction updates as well as concurrent path computation and execution. A potential function is created by solving Laplace's equation (i.e. a harmonic function) using an iteration kernal convolved with an occupancy-grid representation of the current free space. The path produced (i.e. by steepest gradient descent on the harmonic function) is optimal in the sense of globally minimizing the distance to the goal as well as locally minimizing a hitting probability. This helps alleviate the influence of uncertainty on path planning. On a regular grid, the computation of the harmonic function is linear in the total number of grid elements, thus constraining this planner to be local. A global planner-provided that an a priori CAD map of the fixed objects exists-provides information to the local planner about the effects of a global goal. An algorithm for the three typical local scenarios found in indoor office-like environments is presented showing how a global goal is projected into the local context for each case. Since objects are sensed on-the-fly it is possible to discover that passage through a hallway or room may be blocked. A zero gradient vector in the local potential function is used to signal a blocked passage and subsequently initiate global replanning. The technique has been used to control a Nomadics 200 robot     

Models and emerging trends of concurrent constraint programming

Concurrent Constraint Programming (CCP) has been used over the last two decades as an elegant and expressive model for concurrent systems. It models systems of agents communicating by posting and querying partial information, represented as constraints over the variables of the system. This covers a vast variety of systems as those arising in biological phenomena, reactive systems, net-centric computing and the advent of social networks and cloud computing. In this paper we survey the main applications, developments and current trends of CCP.     

Fuzzy-set-based approach for concurrent constraint set-up planning

Material removal processes are integral parts of many manufacturing systems. They are either primary machining processes or an important part of preparing toolings for subsequent forming and moulding processes. Manufacturing process planning identifies the type of material removal processes and the machining parameters, cutting tools and fixtures needed to generate the features on a part. Previous research in manufacturing process planning has concentrated mainly on the role of features, in the derivation of the associated process and fixture plans. Many computer-aided process planning (CAPP) and computer-aided fixture planning (CAFP) systems derive process and fixture plans from the features on a part, on the basis that these features are context-free. However, manufacturing operations are interdependent processes. In the author's computer-aided set-up planning (CASP) system, a different perspective is adopted. Feature relations form the core of the conceptual structure. These features relations, which are often imprecise, are used in deriving set-up plans. The feature relations, which may be due to geometrical constraints, tolerance requirements, etc., are modelled using fuzzy sets and fuzzy relations. This paper presents the various feature relations considered in the present system and proposes a practical planning algorithm for set-up planning.     

Liquid-waste injection planning via goal programming

In this paper, applications of linear goal programming techniques to the analysis of design, management and operational problems in the deep-well injection industry are investigated. Deep-well injection is a method of hazardous waste disposal where liquid or liquefiable wastes are pumped under controlled rate and pressure into confined formations that have no other potential use. A typical liquid waste injection system is modeled as a linear goal program to study and resolve the effects of conflicting objectives such as cost, environmental regulations, equipment utilization and waste-water quality requirements before injection.

The model is validated using actual data obtained from a waste-water disposal complex in Odessa, Texas. The goal program is solved for the best disposal system design and operating policies that would not only enable the plant to meet the Environmental Protection Agency's standards, but best minimize capital investment, annual operating expense and deviations from the waste-water quality requirements before injection. Justification of the use of the model is presented by comparing the actual design and operating policies of the system with the optimal design obtained from the solution of the model. This comparison showed 40% savings in favor of the design predicted by the model.     

Robot path planning by genetic programming

This paper describes a method to determine the path of a robot that travels around between machine tools in a production line FA factory. This decision is made by the genetic algorithm with Lisp language programming. In the algorithm, the building block method to decide fitness is adopted. The method is applied to a flexible manufacturing system (FMS) that has four machine tools and a robot. This work was presented, in part, at the International Symposium on Artificial Life and Robotics, Oita, Japan, February 18–20, 1996     

Robot programming using augmented reality: An interactive method for planning collision-free paths

Current robot programming approaches lack the intuitiveness required for quick and simple applications. As new robotic applications are being identified, there is a greater need to be able to programme robots safely and quickly. This paper discusses the use of an augmented reality (AR) environment for facilitating intuitive robot programming, and presents a novel methodology for planning collision-free paths for an n-d.o.f. (degree-of-freedom) manipulator in a 3D AR environment. The methodology is interactive because the human is involved in defining the free space or collision-free volume (CFV), and selecting the start and goal configurations. The methodology uses a heuristic beam search algorithm to generate the paths. A number of possible scenarios are discussed.     

An implementation of the object-oriented concurrent programming language SINA

SINA is an object-oriented language for distributed and concurrent programming. The primary focus of this paper is on the object-oriented concurrent programming mechanisms of SINA and their implementation. This paper presents the SINA constructs for concurrent programming and inter-object communication, some illustrative examples and a message-based implementation model for SINA that we have used in our current implementation.