-This paper illustrates an approach to the development of a shipboard power system reconfiguration as a Smart cyber-physical system (CPS). It is developed by representing it through a meta-model, providing a multi-paradigm approach that exploits the best features of three available frameworks, Jade, Jason and Akka. The resulting developing framework allows the creation of a new composite entity (labelled H-Entity) that exploits the advantages of Jade, Jason and Akka. Index Terms-CPS, smart, meta-model, multi-paradigm
The CPS application fields are nowadays several in all the domains of human activities. Here the paradigm of CPS is presented with the added quality of smartness, trying to find a flexible solution integrating heterogeneous technologies to easily communicate, although formerly not thought to cooperate at all. The specific case study is the Shipboard Power System (SPS) reconfiguration, where the use of a smart CPS is particularly compelling. The proposed solution to the problem adopts a multi-paradigm approach, where the selected requirements of adaptivity, proactivity, reactivity and smartness led to the consideration of different paradigm frameworks, especially referring to Agents and Actors entities. Among the available frameworks, three of the most representative, Jason, Jade and Akka, have been examined. Thus, this approach allowed to use each paradigm’s strength points for the most suitable task. The resulting developing framework is proposed in the form of a meta-model, representing the composition of the so-called HEntity, the core element of the meta-model. It constitutes the central reasoning of the proposal, gathering in itself different entities finally able to exchange information. In the end, an appendix with the definition of all meta-model elements is provided.
Before entering the proposal of a smart CPS development, it is better to briefly introduce what a CPS is, which are the principal domain applications, and what kind of frameworks can be taken into account. Thus, a short presentation of CPS, Ptolemy, Jade, Jason and Akka is following.
A Cyber-Physical System (CPS) is a new generation of
systems integrating the physical processes with those of the
digital systems [
Since their very start in early 2000, the research and
applications on this field increasingly evolved influencing several
human activities [
Current approaches to the development of smart CPSs encompass several alternative frameworks. Some selected are illustrated in the following.
Ptolemy II was born around 1996, successor to Ptolemy
Classic. It is a framework of Java-based components with
a graphical user interface called Vergil. As described from
the developer [
JADE (Java Agent DEvelopment framework), is an
Agentoriented middleware [
Jason is a framework implementing the AgentSpeak
language [
Akka is a Java-based framework, containing libraries
implemented by the Scala programming language [
Smart CPS may be applied in many different contexts: this section will discuss our specific domain of interest, the reconfiguration of shipboard power systems, and an analysis of the approach adopted for developing the proposed framework. A. The context: smart CPS for Shipboard Power Systems (SPS)
The here-described application context is specifically
referred to the use of a CPS for the reconfiguration of Shipboard
Power Systems (SPS). An SPS is responsible for vessels power
supply, and it governs all the aspects of the electrical system
onboard. About the state of the art of the reconfiguration
methods, a study has been led [
The general requirements a CPS should fulfill lie in a
wide domain, that in [
C. The proposed approach: a multi-paradigm strategy
A cyber-physical system is heterogeneous by definition,
even just for it couples digital elements with physical ones.
The purpose here exposed is to develop a smart cyber-physical
system respecting some requirements especially involving
the information exchange among heterogeneous systems, an
ability we can refer to as interoperability [
The term multi-paradigm refers to a domain dealing with
complex heterogeneity of models [
The more heterogeneous is the relationship the harder is the
issue to address. The problem here exposed couples different
paradigms with different underlying languages. Jade, Jason
and Akka have been taken into account [
• Jason’s reasoning
Basing on a BDI (belief-desire-intention) model, Jason’s
Agent shows a decision-making ability that can be called
reasoning [
In Jade the interaction between distributed Agents is
particularly stressed. As fully adhering to FIPA, the
Agent is proactive, so it can react to a state change
and decide to pursue a goal [
The peculiar structure of Akka lies in the father-sons
hierarchy of the entities. [
For the above-mentioned aim, it resulted that none of them can be substituted without losing something, so instead of settle with just one, the new objective was to choose all of them, basically using each strength points, i.e.: Jason’s reasoning, Akka’s hierarchy and scalability, Jade’s communication protocols.
Since it is a compact representation, the use of a
metamodel is useful to have an overall view of all the components
of the proposal: the more the parts are, the more useful
the construction of the meta-model is. Building it up means
to clear up the hierarchies and especially the relationships
keeping otherwise separated and, most of all, to finally see
possible links and how to develop them [
In the following section the H-Entity will be introduced. Right after we will have a look at the represented meta-model (Fig. 1). There, a top-down and a bottom-up perspective to deal with it are provided. This means that one could read the metamodel in terms of composition of elements (top-down) or by analyzing the single parts which it is made of (bottom-up).
The so-defined H-Entity, where ‘H’ stands for heterogeneous, holds the entire philosophy here proposed. It can be considered as a polyhedral organism composed of frameworks that cooperate by exploiting their best qualities and winning skills. The H-Entity allows them to share their knowledge among each other if they use different languages, and between them and the external world, making into communication other possible H-Entities. It is conceived as a flexible and versatile structure, defined by Roles played by the most suitable specific Entity (composing the H-Entity).
Let’s now observe the meta-model. The principle of all lies in the Cyber-Physical World, which is made up of a CPS Organization and of an Environment; they are the organizational side, corresponding to the Moise framework, and the environmental side, belonging to Cartago. The so-called HEntities also belong to the CPS world: they play the CPS roles, which are Moise roles and make a CPS organization. They constitute the link among the left and right areas. On their turn, the H-Entities are entities (Agents and/or Actors) playing both H-Roles, defined as Manager, Worker, Diplomat and Interface, and Entity Roles, which are Moise roles. This is the Moise Organization, that allows the Entity to pursue a goal by playing a role that determines the behavior of a Group of Entities. The same kind of organization is adopted inside a single H-Entity among its own Entities constituting it, or among different HEntities, that happen to interact in the Cyber-Physical World. Then, the H-Roles define the distribution of responsibilities in a single H-Entity; the CPS Roles describe the macrofunctionalities in the whole external system of CPS, among different H-Entities. The Roles define the structural definition of the organization and allow the Entities to pursue a goal by following a behavioral constraint; the Goal is collective and to be achieved by accomplishing Missions, that are the link between roles and Social Scheme, i.e. between the structural and the functional part of the organization. On the left side, the CPS world has an Environment, both physical and cybernetic. Here the artifacts compose the workspace: the artifacts are made by a Manual, that holds the information about their state, and by some Operations. The latter ones update Observable Properties, that are the states of the artifacts, and generate Observable Events (e. g., in the lower meta-model level, the messages).
Let’s put one aside the other the three frameworks we analyzed. Each of them has its own entity: Jade and Jason Agents and Akka Actor. a) Jade side: Jade’s Agent has an AgentState, performs a behavior through a Scheduler and it sends and receives an ACLMessage, which is FIPA compliant: thus, it contains a Content, a Content Language, an Ontology, a Protocol and a Performative, and it is expressed by an Agent-Communication Language (ACL).
b) Jason side: The Jason Agent lives following a BDI model. In pursuing some Goals, it reacts to the Events occurring in the context which trigger some Plans. The Plans have to satisfy these goals. In the meanwhile, Jason Agent communicates through messages, defined as Jason Messages, made by a content (Proposition) and a Performative.
c) Akka side: Finally, in Akka the actor shows a parental
hierarchy [
Something is immediately evident: at the bottom of the figure, the message level shows a gradual implementation from the Actor to Jade Agent framework: the Message, containing just a Content in Akka, acquires a Performative in Jason, and then also a Protocol, a Language and an Ontology in Jade (that, it is known, has its strength point in the communication side). Here it comes the key of the interaction among the three frameworks, originally not conceived to communicate at all. The other elements placed outside the known metamodels are those related to the concepts of entities: the upper entities, called H-Entities, are all of those elements who can interact among each other in the CPS world through an upper Moise Organization, that replicates in the lower metamodel level among the Roles of a single entity. Thus, the Goal can be a Social Goal, when pursued at the upper level, 15 while at the bottom it is the single Goal pursued by Agents. 16 There are still two elements to be analyzed, the so-defined 17 Jade-Jason Message Wrapper and the Jade-Akka Message 1198 Wrapper, highlighted in green in the picture. These constitute 20 the practical key for the realization of the inter-communication 2212 } among the three frameworks. What they do is establishing a translation using the Jade Communication Protocol as a channel: whenever an agent or an actor sends a message, Jade intercepts it to re-send it to its recipient, using a wrapper with Jason, by sharing the content and the performative, and a wrapper with Akka, sharing only the content.
The meta-model allowed to understand how and at what level to realize the merging among all frameworks. The following subsections will provide details about the wrappers developed to allow their interactions and the solution to the scenario introduced before.
As introduced in the previous section, the entities are linked together at the message level. This layer is implemented with the wrappers: in source code 1 and source code 2, the wrappers connect the Jason agent (Manager), with the Akka Actor (root). The communications from the Jason Agent to the Akka Actors are managed through a bridge. This is implemented with a Jade agent named JadeAkkaActorSystem (source code 1). 1 public class JadeAkkaActorSystem extends Agent { 2 ... 3 protected void setup() { 4 Akka2Jade bridge =new Akka2Jade(this); 5 root = system.actorOf(Root.props(bridge), "rootworker"); addBehaviour(new ForwardIncomingMessages()); ACLMessage msg = new ACLMessage(ACLMessage.INFORM); msg.addReceiver(new AID("manager",AID.ISLOCALNAME)) ; msg.setLanguage("h-language"); msg.setContent(content); myAgent.send(msg); } }
Source code 2. Akka to Jason wrapper def
The use of a Jade Agent as a bridge is very useful because, through the extension of the CyclicBehaviour class, a type of Behaviour that execute the action() method cyclically and never ends, the agent waits for messages from Jason agent, then the Jade Agent sends them to the root actor. With the source code 1, in the setup() method (line 5), a root actor is instantiated: this actor has the task of initializing all the possible sub-actors useful to the system, and it allows the subactors to connect with the Jason Agent. When the Manager (Jason Agent) would like to send a message to an actor, the JadeAkkaActorSystem intercepts the message (line 12) and sends it to the root actor (line 15), which has the task to send the message to the specified sub-actor. When an actor would send a message to a Jason Agent, uses the class Akka2Jade (source code 2). These bridges also exploit a native class named JadeAgArch that allows instantiating a Jason Agent into a Jade Agent, sending messages from Jason to Akka Actor through Jade Agent and vice versa. With the source code 2, the actor uses the sendJason(msg) method (line 3-21) to send a message to the Manager (Jason Agent).
In Fig. 2 it is explained the CPS solution for the SPS scenario, with the adoption of the proposed meta-model. The Captain sets the Mission by using the Interface which is made by a Cartago Artifact; so the Mission is changed and this is communicated to the SPSManager, whose role is played by a Jason Agent. It sets the load priorities with an exchange with the MissionManager, which after detecting the electric failure (by sensors communicating with Akka Actors, through the CircuitMonitor, finds a possible Reconfiguration with the SPS Plan Generator, which is an Actor. This is sent to the Manager which needs to validate the Solution by sending it to a Validator, an Akka Actor, exchanging information with a MatLab platform. So the available resources are negotiated with a “talk” between the Jason Agent Manager and the SPSRepresentative which is a Jade Agent. The solution is finally approved by the Captain who allows the Manager to apply it by enabling the Crew to interact with the Enactor, a Cartago Artifact, passing through a Reconfigurator Enactor, an Akka Actor. It physically switches off the non-vital loads to efficiently deal with the fault. Thanks to the proposed approach, the solution takes advantage of the most relevant features of the three composing frameworks: it shows the capability to adhere to standards, from Jade; it implements a strategy in high levels rules, through Jason, and it is very efficient, due to the Akka contribution.
Source code 1. Jason to Akka wrapper def 1 public class Akka2Jade { 2 ... 3 public void sendJason(String msg) { 4 if (myAgent != null) 5 myAgent.addBehaviour( new SendToJason(msg)); 6 } 7 8 9 10 11 12 } 13 @Override 14 public void action() { private class SendToJason extends OneShotBehaviour { ... public SendToJason (String content) { this.content = content; <<worker>> CircuitMonitor
[Akka] <<worker>> SensorMonitor [Akka]
<<worker>> SensorArrayMonitor [Akka]
2. Electric failure <<worker>> SensorMonitor [Akka]
9. Apply Solution <<worker>> Reconfiguration
Enactor [Akka]
<<worker>> SPSPlanGenerator [Akka]
8.
Approve Solution <<manager>> SPSManager [Jason] 3. Find Reconfiguration <<interface>> CrewInterface [Cartago]
MatLab Simulink 4. Validate Solution
<<worker>> SPSPlanValidator [Akka]
5. Feasible Solution
The need to work with smart CPS implies the necessity to make different frameworks and paradigms interact with each other. This issue by nature leads to a multi-paradigm approach, with the theme of communication among not-overlapping languages. The solution we developed is here presented by means of a meta-model including the considered agent and actor-based frameworks (here Jade, Jason and Akka), linked by the so-called H-Entity, a polyhedral structure that allows taking advantage of each framework winner skills to be exploited at best according to the needed roles to be played. The solution adopted for an SPS reconfiguration revealed a possible way to make the different entities interact at the message level, by the use of wrappers.
The SPS reconfiguration system prototype is now under test. The evaluation of the system will be performed by measuring the response time and the interactions among the different parts of the platform. The future advancement will be to extend the use of CPS to all the other ship’s facilities: the final purpose is to give form to a Smart Ship solution, as already provided by vendors such as Hyundai 1.
VII. APPENDIX: DEFINITION OF META-MODEL ELEMENTS
CARTAGO [
Manual: it contains the information about the functional description and the observable states of the artifact. Workspace: it is defined as an open set of artifacts and agents. The agent must exist in a workspace.
Operation: It determines the update of the artifact state or it generates observable events.
Observable Property: it determines the functional behavior of the artifact.
Observable Event: it is an event generated by an operation and sensed and registered by the agent sensors.
MOISE [
Social Scheme: it contains several missions.
Mission: contained in the Schemes, it is defined by a set of goals to achieve.
Role: it is a behavioral constraint for an Agent to play in a Group.
Norm: the collecting element between the Role and the Mission so the Group to Role.
Social Goal: the Goal the organization has to achieve.
H-Entity: it is the core element of the meta-model. It gathers all the possible heterogeneous entities.
Entity: one of the infinite possible members of the H-Entities. It can be an Agent or an Actor.
H-Role: H-Roles are internal roles played by the Entities. CPS Role: CPS Roles are played among different H-Entities interacting in the CPS World.
Entity Role: the external roles played by Entities following the Moise Organization.
JADE [
ACLMessage: it is based on an asynchronous communication paradigm. It makes the interaction among Agents. Protocol: as part of the structure of the ACLMessage, it is defined to the purpose of interaction among messages by the specification of sequences.
Content: it defines the information carried by a message. It follows FIPA indications about its expression generally using SL (semantic language).
Content language: it is expressed in SL and it is made up of expressions or propositions.
Ontology: it is a knowledge base the messages refer to. Performative: it is a type of communication expressed by a message, it is the communicative act.
JASON [
Plan: a set of actions to be performed to pursue and satisfy a goal.
Trigger Event: it is the circumstance that activates a plan rather than another.
Action: each task which a plan is made of. It is performed by the agent and can change the environment so becoming an Event.
Event: a change in agent’s initial knowledge or goal. Context: it is a set of conditions determining the execution of a Plan.
Belief : a predicate representing the starting knowledge of the environment the agent has.
Rule: a logic expression made by predicates.
Goal: the final state that the agent wants to achieve by performing a plan.
Jason Message: it has a performative and a content. It allows the Agents to communicate each other and it updates the believes.
Jason Performative: it is of the kind of request, information, etc Propositional Content: it is expressed by arguments and it could be true or false.
AKKA [
State: it is encapsulated by the Actor.
Behaviour: an encoding of reactions.
Supervision Strategy: the feature based on the hierarchical structure of Akka made of fathers and son. Each father is responsible for its sons.
Akka Message: the interaction key among Actors. It stimulates a reactive action of the Actor. Received messages are stored in a mailbox. It has just a content.