Introduction Structure of general assembly using function requirements and modular concepts

Download 33.92 Kb.
Size33.92 Kb.
Development of "LEGO Mindstorms" system

using JACK 5.0 Intelligent Agents

Structure of general assembly using function requirements and modular concepts.

The structure of a general assembly is presented in figure 1. The assembly consists of several steps each following specific rules. The assembly process consists of four parts: requirements analyzer, library searcher, combination optimizer and assembly order generator as shown in Figure 1.

The first step is given by the presentation of the requirements to the system. Following these requirements the system has to generate an assembly tree that has to coincide with the desires of the designers. A product designer analyzes those requirements to some functional requirements. The function requirements are actualized by one module or a combination of several modules which correspond to a primitive function. Functional requirements are input to the system.

Step two. These functional requirements are analyzed with respect to primitive functions by the requirements analyzer by reference to the module library. In the module library, relationships among functional requirements, primitive functions and modules are represented in a hierarchical description. Component parts of the module and constraints for the module are also described as attributes of each module in the module library. Primitive functions for the establishment of each functional requirement are obtained by referring the functional requirement class to the primitive function class.

Step three. In the module searcher, a module corresponding to primitive function is chosen by referring a primitive function class to a module class. Then, modules corresponding to each primitive function are selected.

Step four. In the combination optimizer, combination arrangement optimization is performed for selected modules. Several design drafts are provided as variation of module combinations.

Step five. In the assembly order generator, assembly order for each generated design drafts are generated. Finally, several design drafts with assembly order are presented.

Figure 1. Structure of a general assembly

Extending the general assembly to the "Lego Mindstorms" system

The above procedure is applied to the robotics invention system “Lego Mindstorms”: a building block kit for toy robots. The structure for the trial implementation system is shown in Figure 2. The system mainly consists of a block library searcher, a combination optimizer for function blocks, a combination optimizer for connection blocks and an assembly order generator.

Figure 2. Structure of the implementation system

In this structure a "block" represents a module. These blocks are divided into function blocks and connection blocks. A function block satisfies one basic functionality and has some constrains when part of the robot.

Figure 3. Examples of blocks

A function block class has block type, basic function type, position, size and some other constraints as attributes. A single or combinations of connection blocks are used for connecting function blocks.

The designer inputs functional requirements to the system. These requirements are analyzed for primitive functions by reference to the block library in the block library searcher. Each primitive function is replaced by a corresponding function block by a looking-up block in the library. Generated arrangements of possible combinations of function blocks, are applied in combination at the optimizer for function blocks. To make connections among function blocks in each generated arrangement using connection blocks and to complete this arrangement as a robot body, a simple genetic algorithm is applied at the optimizer for connection blocks. Finally, assembly orders are generated for each arrangement.
Introduction to JACK Intelligent Agents
JACK™ Intelligent Agents (JACK) is an Agent Oriented development environment built on top of and integrated with the Java programming language. It includes all components of the Java development environment as well as offering specific extensions to implement agent behaviour. JACK's relationship to Java is analogous to the relationship between the C++ and C languages. C was developed as a procedural language and subsequently C++ was developed to provide programmers with object-oriented extensions to the existing language. Similarly, JACK has been developed to provide agent-oriented extensions to the Java programming language. JACK source code is first compiled into regular Java code before being executed.

In the same way that object-oriented programming introduces a number of key concepts that influence the entire logical and physical structure of the resulting software system, so too does agent-oriented programming. In agent-oriented programming, a system is modelled in terms of agents. These agents are autonomous reasoning entities capable of making pro-active decisions while reacting to events in their environment.

Agent oriented programming is an advanced software modelling paradigm that arose from research in distributed artificial intelligence. It addresses the need for software systems to exhibit rational, human-like behaviour in their respective problem domains. Traditional software systems make it difficult to model rational behaviour, and often programs written in these systems experience limitations, especially when attempting to operate in real-time environments.

Agent oriented programming is highly suited to many application areas, including distributed business systems, command and control, intelligent appliances and simulation. Although still young and under development, it has already shown particular promise in a variety of distributed problem solving tasks such as fleet organisation, air traffic management and air combat simulation. Because it offers such a modular and elegant solution to many of the problems faced in reactive processing, agent-oriented programming is ideally suited to these environments.

The Agent Oriented model follows the same underlying principle as Object Oriented programming – that reliable and scalable development can be enhanced by encapsulating the desired behavior in modular units which contain all the definitions and structures required for them to operate independently. Agents extend the concept of encapsulation to include a representation of behavior at a higher level than object-oriented approaches.

The term agent is widely used to describe a range of software components, varying in capability from procedural wizards, found in popular desktop applications, to information agents that are used to automate information search and retrieval, and, finally, to intelligent agents capable of reasoning in a well-defined way. The agents used in JACK are intelligent agents. They model reasoning behaviour according to the theoretical Belief Desire Intention (BDI) model of artificial intelligence.

Following the BDI model, JACK intelligent agents are autonomous software components that have explicit goals to achieve or events to handle (desires). To describe how they should achieve these desires, BDI agents are programmed with a set of plans. Each plan describes how to achieve a goal under varying circumstances. Set to work, the agent pursues its given goals (desires), adopting the appropriate plans (intentions) according to its current set of data (beliefs) about the state of the world. This combination of desires and beliefs initiating context-sensitive intended behaviour is part of what characterises a BDI agent.

A JACK agent is a software component that can exhibit reasoning behaviour under both proactive (goal directed) and reactive (event driven) stimuli. Each agent has:

• a set of beliefs about the world (its data set),

• a set of events that it will respond to,

• a set of goals that it may desire to achieve (either at the request of an external agent, as a consequence of an event, or when one or more of its beliefs change), and

• a set of plans that describe how it can handle the goals or events that may arise.

When an agent is instantiated in a system, it will wait until it is given a goal to achieve or experiences an event that it must respond to. When such a goal or event arises, it determines what course of action it will take. If the agent already believes that the goal or event has been handled (as may happen when it is asked to do something that it believes has already been achieved), it does nothing. Otherwise, it looks through its plans to find those that are relevant to the request and applicable to the situation. If it has any problems executing this plan, it looks for others that might apply and keeps cycling through its alternatives until it succeeds or all alternatives are exhausted.

Thus, an agent can be thought of as analogous to a person with access to a Procedures Manual. The Procedures Manual (set of plans) describes the steps that the agent should take when a certain event arises or when it wants to achieve a certain outcome. At first glance, this may seem like ordinary Expert System behavior – with all the limitations that this implies.

However, the crucial difference in agent-oriented systems is that the agent is able to be programmed to execute these plans just as a rational person would. In particular, it is able to exhibit properties associated with rational behavior.

The JACK Agent Language

The JACK Agent Language is built on top of Java. Like C++, the JACK Agent Language does more than extend the functionality of Java – it also provides a framework to support an entirely new programming paradigm. The JACK Agent Language is an Agent Oriented programming language and is used for implementing Agent Oriented software systems.

The JACK Agent Language extends Java to support Agent Oriented programming:

• It defines new base classes, interfaces and methods.

• It provides extensions to the Java syntax to support new agent-oriented classes, definitions and statements.

• It provides semantic extensions (runtime differences) to support the execution model required by an agent-oriented software system.

All the language extensions are implemented as Java plug-ins. This makes the language as extensible and flexible as possible. Flexibility is important in the JACK Agent Language because it facilitates ongoing research into agent-oriented programming. Developers may, for example, want to investigate how different beliefset implementations affect agent performance. Because the beliefset component is supplied as a plug-in, this can be altered with minimal changes to the JACK development environment. All that is required is to replace the beliefset implementation in the kernel package.

Each of the JACK Agent Language extensions is strictly typed. This minimises implicit type casting and the opportunity for programmer error. Strict typing also allows for more efficient program compilation by the JACK Agent Compiler.

Implementing the Lego Mindstorms system into Jack
Given the system structure that was discussed above we can implement it into Jack by defining the following agents:

  • an designer agent of the type Designer;

  • an agent that will search the block library, his type LibrarySearcher;

  • an agent that will optimize the combination for function blocks, his type FunctionOptimizer;

  • an agent that will optimize the combination for connection blocks, his type ConectionOptimizer;

  • an agent that will generate the assembly order, his type OrderGenerater.

The desigen agent
His definition is :

agent Designer extends Agent



This agent has the requirements that the assembly needs in order to build the desired robot.

He is capable of analizing requirements and send them to the library searcher agent and receiving the design drafts from the assembly order generator agent.

His events are the sending of the requirements and the receiving of the designs.

His plans are the rules that according to he is sending the requirements so that the assembly will evolve from the easiest steps to the hardest steps. In many cases there are some crucial conditions to the assembly so then they will be executed first.

The structure of the designer agent's actions, capabilities etc are presented below:

Where the geometrical objects represent :

  • this represents a capability;

- this represents a plan

- this represents a note

- this represents data

- this represents an event

- this represents an agent

This means that the agent has the requirements and uses the Sending rules to send the requirements to the library searching agent.

The Block Library Searching Agent

His definition is :

agent LibrarySearcher extends Agent



This agent has the requirements that the designer agent had sent and searches the library for the blocks needed to fulfill the given requirements.

He is capable of searching the library for the blocks (function or connection blocks) and he sends the selection to the optimizing agents.

His events are the sending of the selected blocks and the receiving of the requirements.

His plans are the rules that according to he selects the blocks from the library based on the searching criteria he has implemented in his code.

His belief set is the Library that contains the codes of the function blocks and the connection blocks, separated into categories and classes of characteristics.

The implementation of the Library searching agent is presented below:

The Block Library Searching Agent

The Function Block Optimizer Agent

His definition is :

agent FuntionBlockOptimizer extends Agent



This agent has the selected blocks given by the library-searching agent and according to the requirements he must optimize the combination of the function blocks.

He is capable of combining function blocks from the selected function blocks sent by the library searcher.

His events are the sending of the optimized arrangements of function blocks and the receiving of the selected function blocks.

His plans are the rules that according to he arranges the blocks so that the combination will correspond to the requirements and will be optimum.

The implementation of the Function Block Combination Optimizer agent is:

The Connection Block Optimizer Agent

His definition is :

agent ConnectionBlockOptimizer extends Agent



This agent has the selected blocks given by the library-searching agent and the arrangements generated by the function block connection optimizer agent and according to the requirements he must optimize the combination of the connection blocks.

He is capable of combining connection blocks from the selected connection blocks sent by the library searcher or combining connection blocks with the function blocks.

His events are the sending of the optimized arrangements of connection blocks and the receiving of the selected connection blocks and the function block arrangements.

His plans are the rules that according to he arranges the blocks so that the combination will correspond to the requirements and will be optimum.

The implementation of the Connection Block Combination Optimizer agent is:

The Assembly Order Generator Agent
His definition is :

agent AssemblyOrderGanerator extends Agent



This agent has the whole block arrangements sent by the connection block combination optimizer and generates the assembly tree and the sends the design drafts to the Designer agent.

He is capable of generating the assembly tree from the arrangements received from the previous agent.

His events are the sending of the design drafts and the receiving of the block arrangements.

His plans are the rules that according to he generates the assembly tree, starting from the complex block connections until the superficial level of parts connections.

The implementation of the Assembly Order Generator agent is:

Download 33.92 Kb.

Share with your friends:

The database is protected by copyright © 2024
send message

    Main page