Evaluating XMPP Communication in IEC 61499-based Distributed Energy Applications

The IEC 61499 reference model provides an international standard developed specifically for supporting the creation of distributed event-based automation systems. Functionality is abstracted into function blocks which can be coded graphically as well as via a text-based method. As one of the design goals was the ability to support distributed control applications, communication plays a central role in the IEC 61499 specification. In order to enable the deployment of functionality to distributed platforms, these platforms need to exchange data in a variety of protocols. IEC 61499 realizes the support of these protocols via "Service Interface Function Blocks" (SIFBs). In the context of smart grids and energy applications, IEC 61499 could play an important role, as these applications require coordinating several distributed control logics. Yet, the support of grid-related protocols is a pre-condition for a wide-spread utilization of IEC 61499. The eXtensible Messaging and Presence Protocol (XMPP) on the other hand is a well-established protocol for messaging, which has recently been adopted for smart grid communication. Thus, SIFBs for XMPP facilitate distributed control applications, which use XMPP for exchanging all control relevant data, being realized with the help of IEC 61499. This paper introduces the idea of integrating XMPP into SIFBs, demonstrates the prototypical implementation in an open source IEC 61499 platform and provides an evaluation of the feasibility of the result.Comment: 2016 IEEE 21st International Conference on Emerging Technologies and Factory Automation (ETFA

Design Criteria to Architect Continuous Experimentation for Self-Driving Vehicles

The software powering today's vehicles surpasses mechatronics as the dominating engineering challenge due to its fast evolving and innovative nature. In addition, the software and system architecture for upcoming vehicles with automated driving functionality is already processing ~750MB/s - corresponding to over 180 simultaneous 4K-video streams from popular video-on-demand services. Hence, self-driving cars will run so much software to resemble "small data centers on wheels" rather than just transportation vehicles. Continuous Integration, Deployment, and Experimentation have been successfully adopted for software-only products as enabling methodology for feedback-based software development. For example, a popular search engine conducts ~250 experiments each day to improve the software based on its users' behavior. This work investigates design criteria for the software architecture and the corresponding software development and deployment process for complex cyber-physical systems, with the goal of enabling Continuous Experimentation as a way to achieve continuous software evolution. Our research involved reviewing related literature on the topic to extract relevant design requirements. The study is concluded by describing the software development and deployment process and software architecture adopted by our self-driving vehicle laboratory, both based on the extracted criteria.Comment: Copyright 2017 IEEE. Paper submitted and accepted at the 2017 IEEE International Conference on Software Architecture. 8 pages, 2 figures. Published in IEEE Xplore Digital Library, URL: http://ieeexplore.ieee.org/abstract/document/7930218

Designing a product service system in a social framework: methodological and ethical considerations

Macroscopic social and economic changes in the last few years are forcing business companies and public institutions to redefine their approach to social intervention, focusing on local and highly individualised solutions. This change is also calling for a new design approach. The challenge for designers is not only to be able to provide local and highly individualised solutions, but also to propose strategies to transfer and reproduce the solutions, or part of them, into different local contexts, thus creating economy of scope. This would be possible by using forms of codification and modularisation of the most relevant components in local solutions. The code refers to the organisational knowledge included in local components and the way each component interacts with the others. Like software systems, local product-service systems can be built upon a source code. This paper will illustrate how this process was developed in a concrete case. Through this case the authors analyse the possibility to build something similar to a source code for initiatives based on social interaction and investigate the process of construction of such a code Furthermore, the author discuss differences and analogies between design intervention in a social context and in the normal business context. The question of codification suggests a methodological approach for supporting transferability both in the problem space (dealing with complexity) and in the solution space (dealing with contingency). The analysis of differences and similarities between business- and socially-oriented processes suggests a new role for designers and new opportunities for innovation. Keywords: Product Service Systems, Methodology, Design and Morality, Codification, Transferability</p

Implementation issues in product line scoping

Often product line engineering is treated similar to the waterfall model in traditional software engineering, i.e., the different phases (scoping, analysis, architecting, implementation) are treated as if they could be clearly separated and would follow each other in an ordered fashion. However, in practice strong interactions between the individual phases become apparent. In particular, how implementation is done has a strong impact on economic aspects of the project and thus how to adequately plan it. Hence, assessing these relationships adequately in the beginning has a strong impact on performing a product line project right. In this paper we present a framework that helps in exactly this task. It captures on an abstract level the relationships between scoping information and implementation aspects and thus allows to provide rough guidance on implementation aspects of the project. We will also discuss the application of our framework to a specific industrial project

Analysis and design of multiagent systems using MAS-CommonKADS

This article proposes an agent-oriented methodology called MAS-CommonKADS and develops a case study. This methodology extends the knowledge engineering methodology CommonKADSwith techniquesfrom objectoriented and protocol engineering methodologies. The methodology consists of the development of seven models: Agent Model, that describes the characteristics of each agent; Task Model, that describes the tasks that the agents carry out; Expertise Model, that describes the knowledge needed by the agents to achieve their goals; Organisation Model, that describes the structural relationships between agents (software agents and/or human agents); Coordination Model, that describes the dynamic relationships between software agents; Communication Model, that describes the dynamic relationships between human agents and their respective personal assistant software agents; and Design Model, that refines the previous models and determines the most suitable agent architecture for each agent, and the requirements of the agent network

Adressing context-awareness and standards interoperability in e-learning: a service-oriented framework based on IRS III

Current technologies aimed at supporting learning goals primarily follow a data and metadata-centric paradigm. They provide the learner with appropriate learning content packages containing the learning process description as well as the learning resources. Whereas process metadata is usually based on a certain standard specification – such as ADL SCORM or the IMS Learning Design – the used learning resources – data or services - are specific to pre-defined learning contexts, and they are allocated manually at design-time. Therefore, a content package cannot consider the actual learning context, since this is only known at runtime of a learning process. These facts limit the reusability of a content package across different standards and contexts. To overcome these issues, this paper proposes an innovative Semantic Web Service-based approach that changes this data- and metadata-based paradigm to a context-adaptive service-oriented approach. In this approach, the learning process is semantically described as a standard-independent process model decomposed into several learning goals. These goals are accomplished at runtime, based on the automatic allocation of the most appropriate service. As a result, we address the dynamic adaptation to specific context and - providing the appropriate mappings to established metadata standards - we enable the reuse of the defined semantic learning process model across different standards. To illustrate the application of our approach and to prove its feasibility, a prototypical application based on an initial use case scenario is proposed

Separating Agent-Functioning and Inter-Agent Coordination by Activated Modules: The DECOMAS Architecture

The embedding of self-organizing inter-agent processes in distributed software applications enables the decentralized coordination system elements, solely based on concerted, localized interactions. The separation and encapsulation of the activities that are conceptually related to the coordination, is a crucial concern for systematic development practices in order to prepare the reuse and systematic integration of coordination processes in software systems. Here, we discuss a programming model that is based on the externalization of processes prescriptions and their embedding in Multi-Agent Systems (MAS). One fundamental design concern for a corresponding execution middleware is the minimal-invasive augmentation of the activities that affect coordination. This design challenge is approached by the activation of agent modules. Modules are converted to software elements that reason about and modify their host agent. We discuss and formalize this extension within the context of a generic coordination architecture and exemplify the proposed programming model with the decentralized management of (web) service infrastructures