Stefan Bosse - A hybrid approach for Structural Monitoring with self-organizing multi-agent systems and inverse numerical methods in material-embedded sensor networks

A hybrid approach for Structural Monitoring with self-organizing

multi-agent systems and inverse numerical methods in

material-embedded sensor networks

Stefan Bosse

⇑

, Armin Lechleiter

University of Bremen, Dept. of Mathematics & Computer Science, Robert Hooke Str. 5, 28359 Bremen, Germany

article info

Article history:

Received 17 November 2014

Revised 24 July 2015

Accepted 23 August 2015

Available online 28 October 2015

Keywords:

Structural health monitoring

Sensor network

Mobile agent

Heterogeneous networks

Embedded systems

Inverse numerical computation

abstract

One of the major challenges in Structural Monitoring of mechanical structures is the derivation of mean-

ingful information from sensor data. This work investigates a hybrid data processing approach for

material-integrated structural health and load monitoring systems by using self-organizing mobile

multi-agent systems (MAS), and inverse numerical methods providing the spatial resolved load informa-

tion from a set of sensors embedded in the technical structure with low-resource agent processing plat-

forms scalable to microchip level, enabling material-integrated real-time sensor systems. The MAS is

deployed in a heterogeneous environment and offers event-based sensor preprocessing, distribution,

and pre-computation. Inverse numerical approaches usually require a large amount of computational

power and storage resources, not suitable for resource constrained sensor node implementations.

Instead, the computation is partitioned into spatial off-line (outside the network) and on-line parts, with

on-line sensor processing performed by the agent system. A uniﬁed multi-domain simulation framework

is used to proﬁle and validate the proposed approach.

1. Introduction

Structural Monitoring of mechanical structures allows to derive

not just loads by using Load Monitoring (LM), but also their effects

to the structure, its safety, and its functioning from sensor data,

offering some kind of Structural Health Monitoring (SHM). A load

monitoring system is a basic component of a SHM system, which

provides spatial resolved information about loads (forces,

moments, etc.) applied to a technical structure, with applications

ranging from robotics to building monitoring.

One of the major challenges in SHM and LM is the derivation of

meaningful information from sensor input. The sensor output of a

SHM or LM system reﬂects the lowest level of information. Beside

technical aspects of sensor integration the main issue in those

applications is the derivation of a information mapping function

Map(s, E): s  E ? i that basically maps the raw sensor data input

s,an-dimensional vector consisting of n sensor values, on the

desired information i,am-dimensional result vector. The result

of the computed information commonly depends on some abstract

environmental setting E (see Fig. 1) arising in all technical systems,

i.e., the disturbance of data caused by communication, data

processing, energy supply, or temporal and spatial data

distribution. The goal of the mapping function it to reduce the data

dimension signiﬁcantly, i.e., m  n.

This work investigates a hybrid data processing approach for

material-integrated LM systems by using self-organizing and

event-driven mobile multi-agent system (MAS), with agent

processing platforms scaled to microchip level which offer

material-integrated real-time sensor systems, and inverse numer-

ical methods providing the spatially resolved load information

from a set of sensors embedded in the technical structure. Such

inverse approaches usually require a considerable amount of com-

putational power and storage resources, not very well matching

resource constrained sensor node implementations. Instead, off-

line computation is performed, with on-line sensor processing by

the agent system. Commonly off-line computation operates on a

continuous data stream requested by the off-line processing sys-

tem delivering sensor data continuously in ﬁxed acquisition inter-

vals, resulting in high communication and computational costs. In

this work, the sensor preprocessing MAS delivers sensor data

event-based if a change of the load was detected (feature extrac-

tion), reducing network activity and energy consumption signiﬁ-

cantly. Inverse numerical algorithms use matrix computations

extensively, so it is in principle possible to distribute and perform

http://dx.doi.org/10.1016/j.mechatronics.2015.08.005

⇑

Corresponding author.

Mechatronics 34 (2016) 12–37

Contents lists available at ScienceDirect

Mechatronics

journal homepage: www.elsevier.com/locate/mechatronics

some of the matrix computations in the sensor network offering an

on-line pre-computation by the MAS. This is a main advantage over

Machine Learning methods used in LM and SHM systems [1–3],

which are more difﬁcult to distribute efﬁciently due to long dis-

tance data dependencies.

Basically there are two different information extraction

approaches for material-integrated LM systems and a possible

optimization of sensor positions: (I) Those methods based on a

mechanical and numerical model of the technical structure, the

Device under Test (DUT), and the sensor; (II) Those without any

or with a partial physical model. The latter class can proﬁt from

artiﬁcial intelligence, which is usually based on classiﬁcation algo-

rithms derived from supervised machine learning or pattern recog-

nition using, for example, self-organizing systems like multi-agent

systems with less or no a priori knowledge of the environment.

One common approach in SHM is the correlation of measured

data resulting from an induced stimuli at run-time (system

response) with data sets retrieved from an initial (ﬁrst-hand)

observation, which makes it difﬁcult to select damage relevant

features from the measurement results. Other variants are based

on statistical methods, data analysis using Fourier- or wavelet-

techniques, or neural network approaches. We refer to [4–8]

(Chapter 12) posing examples illustrating the variety of possible

approaches.

Inverse methods generally belong to the ﬁrst class of

approaches since they are based on a mechanical model T of the

technical structure mapping loads to sensor signals. In this study,

we consider measurements of surface strains and aim to compute

the associated spatially varying (discretized) loads l on the struc-

ture. The mechanical model T is gained from linear elasticity and

can, in a discretized setting, be represented by a matrix. Given a

sensor signal vector s (serialization of a two-dimensional sensor

matrix S, which is a approximately linear depending on the mea-

sured strain), inverse methods try to stably ‘‘invert”; the mapping

T, that is, to ﬁnd a stable solution l to the problem Tl = s. Since mea-

sured signals and the underlying physical model always contain

numerical and modelling errors, inverse methods do not attempt

to ﬁnd an exact solution to the latter equation. Indeed, inversion

problems, in particular those with incomplete data, are usually

extremely ill-conditioned, meaning that small errors in the signals

or the model lead to huge errors in any ‘‘solution”; gained by such a

naive approach. Instead, inverse methods try to stabilize the inver-

sion process, using, e.g., one of the following techniques:

 A classical and well-known inversion method is Tikhonov regu-

larization. Pick amongst all approximated solutions to Tl = s the

one that minimizes a certain functional – the simplest func-

tional to minimize would be the Tikhonov functional

l # Tl  s

; ð1Þ

where a > 0 and kk

is the 2-norm of a vector deﬁned by Eq.

(2), but different and more complicated variants exist and might

also be convenient choices. The latter vector norm is deﬁned for

any dimension n 2 N and any vector

v ¼ðv

; ...; v

2 R

j¼1

1=2

: ð2Þ

 Alternatively, consider any iterative method that minimizes the

residual Tl  s and stabilize the inversion by stopping the itera-

tion when the norm of the residual is about the magnitude of

the expected signal and modelling error. Examples for such iter-

ative techniques include the Landweber iteration, the conjugate

gradient iteration, but also recent soft shrinkage techniques, see

[9,10].

If the mechanical model T is linear, then the best known inver-

sion method in the ﬁrst class is the Tikhonov regularization mini-

mizing the quadratic functional (Eq. (1)) by solving the equivalent

linear system (T

⁄

T +

)l = T

⁄

s, where T

⁄

denotes the transpose

matrix of T. The most powerful algorithm in the second class is,

arguably, the conjugate gradient iteration. The disadvantage of

inverse methods with regard to applications based on sensor net-

works usually is their cost in terms of computing time and memory

requirements which deﬁnitely is a drawback for material-

integrated SHM and LM systems. The possibly high computing

Fig. 1. Initially unknown external forces acting on a mechanical structure lead to an deformation of the material based on the internal forces. A material-integrated active

sensor network [22] composed of sensors, electronics, data processing, and communication, together with mobile agents can be used to monitor relevant sensor changes with

an advanced event-based information delivery behaviour. Inverse numerical methods can compute ﬁnally the material response. The unknown system response for

externally applied load l is measured by the strain sensor stimuli response s’ (a function of s), and ﬁnally inverse numerical methods compute an approximation l’ to the

applied load.

S. Bosse, A. Lechleiter / Mechatronics 34 (2016) 12–37

time and memory requirements for pre-computations before actu-

ally launching the monitoring device due to the physical and

numerical model are nowadays becoming less important due to

advanced numerical simulation methods and increasing computa-

tional power.

Reliable distributed data processing in sensor networks using

multi-agent systems (MAS) were recently reported in [11] and

employed for SHM applications in [12]. An adaptive and learning

behaviour of MAS, which is a fundamental principle in the agent

model, can aid to overcome technical unreliability and limitations

[13]. Artiﬁcial intelligence and machine learning can be used in

sensorial materials without a predictive mechanical model at hand

[1], which is a deﬁnite advantage for complex materials.

Multi-agent systems can be used for a decentralized and self-

organizing approach of data processing in a distributed system like

a sensor network (that is already applied in macro-scale applica-

tions, e.g., in [14]), enabling information extraction, for example,

based on pattern recognition [15], by decomposing complex tasks

in simpler cooperative agents.

In this work the behaviour of mobile agents is related to a state

and is modelled with an activity-transition graph (ATG) which is

implemented with the Activity-based Agent Programming Lan-

guage AAPL [16]. An activity is related with a state and actions per-

formed by activating an activity by a transition.

AAPL models can be compiled to various agent processing plat-

form architectures including programmable code-based stack

machines [17] and non-programmable, part of each sensor node.

The non-programmable agent processing platform implements

the ATG behaviour directly [16], enabling very low-resource single

microsystem platforms. In the case of the programmable agent

platform the program code implements the agent behaviour

entirely. The ATG can be modiﬁed at run-time by the agent itself

using dedicated AAPL transformation statements [18]. By using

program code that is executed on a Virtual Machine (VM) this is

performed by code morphing techniques provided by the VM.

Agents carrying the code, data, and already applied modiﬁcations,

are capable to migrate in the network between nodes [18]. Both

processing platform architectures use token-based and pipelined

agent processing for optimized resource sharing and parallel

execution.

The programmable agent processing platform used for the exe-

cution of agents is a pipelined stack-based virtual machine, with

support for code morphing and code migration. This VM approach

offers small sized agent program code, low system complexity,

high data processing performance, and enables the support of

heterogeneous network ranging from microchips to the internet.

The agent platform VM can be implemented directly in hardware

with a System-on-Chip design. Agents processed on one particular

node can interact by using a tuple-space server provided by each

sensor node. Remote interaction is provided by signals carrying

data which can cross sensor node boundaries.

This approach provides a high degree of computational inde-

pendency from the underlying platform and other agents, and

enhanced robustness of the entire heterogeneous environment in

the presence of node, sensor, link, data processing, and communi-

cation failures. Support for heterogeneous networks considering

hardware (System-on-Chip designs) and software (microproces-

sor) platforms is covered by one design and synthesis ﬂow includ-

ing functional behavioural simulation. For material-integration,

there is an application speciﬁc agent processing platform that

implements the agent behaviour on-chip, offering the lowest

resource and chip area requirements.

The mechanical model of the structure under investigation

allows in particular the pre-computation of a sufﬁciently accurate

discretization of the forward mapping T linking loads with mea-

sured signals. Moreover, this pre-computation allows to associate

to each sensor an individual signal level that might potentially

be critical for the entire structure.

Hence, when a load change that is potentially critical is detected

by one the material-integrated sensors, the signals measured by all

sensors are propagated to an exterior CPU. An alternative way is

that merely those sensors noting a critical load change start to

propagate their signals to the exterior CPU. The propagated signals

are then fed into a regularization scheme that is able to stably

invert signals into loads.

As discussed above, Tikhonov regularization is a feasible regu-

larization scheme, computing an approximation to the true load

as solution to the linear system

ðT



T þ

Þl ¼ T



s þ

; ð3Þ

where T

⁄

denotes the transpose of T. The solution to this system is

hence computed rapidly with low cost if one is able to pre-compute

a singular value decomposition of the matrix T. The disadvantage of

this inversion scheme is that reconstructions of discontinuous

loads, in particular with small support, are smoothed out which

makes the precise location of the support of a load difﬁcult. Several

iterative inversion techniques such as the steepest descent method

or the conjugate gradient method applied to T

⁄

Tl = T

⁄

g avoid this

disadvantage. Further, they merely require the ability to compute

matrix–vector products and a (cheap stopping) rule to stabilize

the inversion. The class of iterative inversion methods also includes

the so-called Landweber iteration and its variant, the so-called iter-

ative soft shrinkage. The disadvantage of the latter two techniques

is their slow convergence, and the huge number of iterations are

necessary to compute accurate inversions [9,19].

Combining Self-organizing Multi-Agent Systems (SoMAS) and

event-based sensor data distribution with inverse numerical meth-

ods into a hybrid data processing approach has several advantages:

First, the (possibly distinct) critical level for an individual sensor

signal can be pre-computed for each sensor position individually.

Second, depending on the a priori knowledge on the expected loads

on the structure, a suitable regularization technique can be chosen

as inversion method, promoting speciﬁc features of the expected

loads. Third, the sensor positions themselves might well be opti-

mized with respect to the last two points, aiming for sensor posi-

tions that maximize the detectability of critical loads and/or

sensor positions that maximize the quality of load reconstructions

from sensor signals.

This work introduces some novelties compared to other data

processing and agent platform approaches and previously pub-

lished work [16,18,17,20]:

 Complete multi-domain simulation of large-scale multi-agent

systems, sensor networks, and numerical computation with a

uniﬁed database centric simulation environment.

 Sensor signal preprocessing at run-time inside the sensor net-

work by using multi-agent systems. Event-based sensor data

distribution and pre-computation with agents reduces commu-

nication and overall network activity resulting in reduced

energy consumption.

 Agent mobility crossing different execution platforms in mesh-

like networks and agent interaction by using tuple-space data-

bases and global signal propagation aid solving data distribu-

tion and synchronization issues in the design of distributed

sensor networks connected to generic computer networks and

the Internet.

 Enhanced inverse numeric improving stability and accuracy is

used to compute the load for a structure from noisy and incom-

plete sensor data.

 An advanced on- and off-line processing with off-line inverse

numerical computation of mechanical loads form on-line pre-

processed sensor data allows the determination of the system

14 S. Bosse, A. Lechleiter / Mechatronics 34 (2016) 12–37

response. FEM simulation is used to 1. Retrieve the inverse

numeric for real-world sensing system; and 2. For the creation

of synthetic sensor data of the technical structure in simulation.

 Rigorous analysis and evaluation of the load computation for a

structure with temporal and spatial disturbed or incomplete

sensor input data. Temporal disturbance is caused by data dis-

tribution latencies, and spatial disturbance is caused by techni-

cal failures in the sensor network (e.g., communication failures).

The next sections summarize the activity-based agent process-

ing model, available mobility and interaction, and the used agent

processing platform architecture related to the programming

model. A summarized description of the sensor signal processing

algorithms and a rigorous description of the proposed inverse

numerical methods for load computations are following, which

are proﬁled and validated with an extensive simulation framework.

2. Agent behaviour model

The agent behaviour is composed and modelled with an activity

graph, with activities representing the control state of the agent rea-

soning engine, and conditional transitions connecting and enabling

activities, shown in Fig. 2 (detailed description in [16,20]). Activities

provide a procedural agent processing by sequential execution of

imperative data processing and control statements.

The activity-graph based agent model is attractive due to the

proximity to the ﬁnite-state machine model, which simpliﬁes the

hardware implementation, but still enabling efﬁcient software

implementations.

An activity is activated by a transition which can depend on a

predicate as a result of the evaluation of (private) agent data

related to a part of the agents belief in terms of Belief-

Desire-Intention (BDI) architecture. An agent belongs to a speciﬁc

parameterizable agent class AC, specifying the behaviour, local

agent data (only visible for the agent itself), types, signals, activi-

ties, signal handlers, and transitions.

The class AC can be composed of sub-classes, which can be inde-

pendently selected. Plans are related to AAPL activities and transi-

tions close to conditional triggering of plans.

This reactive behaviour can be summarized to the following

operational semantic:

 Procedural data processing takes place in activities computing

and changing private and global data.

 Transitions between activities represent the progress and the

external visible change of the control state of an agent. Transi-

tions can be conditional depending on the evaluation of agent

data.

 Body variables of an agent are private data only visible to the

speciﬁc agent. The data content of body variables are mobile

and can be inherited by forked child agents.

 Each agent owns a public set of agent parameters initialized on

agent creation.

 Global data is exchanged by using a tuple database and syn-

chronized and atomic read, test, remove, and write operations.

 Agents can migrate between different physical and spatially dis-

tinguished execution platforms by preserving and transferring

the control and data state of the agent.

 The agent behaviour can be either implemented directly by the

processing platform (application speciﬁc and static platform

class) or can be implemented with program code executed by

a generic agent processing platform (dynamic platform class).

 Agents can be created at run-time, regardless of the platform

class. Agents can inherit the control and data state from parent

agents (forking behaviour).

 Agents can communicate and synchronize peer-to-peer by using

signals, which can be delivered to remote execution nodes, too.

Fig. 2. Agent behaviour programming level with activities and transitions (AAPL, left); agent class model and activity-transition graphs (top); agent instantiation, processing,

and agent interaction on the network node level (right) [17].

S. Bosse, A. Lechleiter / Mechatronics 34 (2016) 12–37

A short notation of AAPL used to specify the agent behaviour in

this work is presented in Appendix A.

3. Agent processing platform

There are two different agent processing platforms capable of

processing of the mobile agents used in this work: a non-

programmable and a programmable platform architecture. The

non-programmable platform implements the agent behaviour for

different agent classes directly, whereas the programmable plat-

form provides generic agent processing of program code supplied

externally which implements the agent behaviour of a particular

agent class. Both platforms can be implemented entirely on hard-

ware (SoC), or software, or simulation model level. All implemen-

tations of each platform class can be deployed and connected in

a heterogeneous network environment, shown in Fig. 3. They are

compatible on operational and interface level. That means agents

can migrate between different platform implementations and dif-

ferent host environments. The simulation of MAS can be based

on a pure behavioural model (BSIM) by simulating the agents itself

or based on an architectural model by simulating the agent pro-

cessing platform (PSIM) using agents.

Table 1 compares the characteristics and the advantages/disad-

vantages of both platform architectures. Fig. 3 shows the modelling

and synthesis of agent platforms from a common model and pro-

gramming sources.

4. Sensing with multi-agent systems

Large scale sensor networks with hundreds and thousands of

sensor nodes require smart data processing concepts far beyond

the traditional centralized approaches. Multi-Agent systems can

be used to implement smart and optimized sensor data processing

in these distributed sensor networks.

In this work, three different data processing and distribution

approaches are used and implemented with agents, leading to a sig-

niﬁcant decrease of network processing and communication activity

and a signiﬁcant increase of reliability and the Quality-of-Service:

1. An event-based sensor distribution behaviour is used to deliver

sensor information from source sensor to computation nodes.

2. Adaptive path ﬁnding (routing) supports agent migration in

unreliable networks with missing links or nodes by using a

hybrid approach of random and attractive walk behaviour.

3. Self-organizing agent systems with exploration, distribution,

replication, and interval voting behaviours based on feature

marking are used to identify a region of interest (ROI, a collec-

tion of stimulated sensors) and to distinguish sensor failures

(noise) from correlated sensor activity within this ROI.

It is assumed that sensor nodes arranged in a two-dimensional

grid network (as shown in Fig. 4) providing spatially resolved and

distributed sensing information of the surrounding technical struc-

ture, for example, a metal plate. Each sensor node shall sense

mechanical properties of the technical structure nearby the node

location, for example, by using strain gauge sensors. Usually a sin-

gle sensor cannot provide any meaningful information of the

mechanical structures. A connected area of sensors (complete sen-

sor matrix or a part of it) is required to calculate the response of the

material due to applied forces. The computation of the material

response requires high computational power of the processing

unit, which cannot offered by down-scaled single micro-chip plat-

forms. For these reasons, sensor nodes use mobile agents to deliver

their sensor data to dedicated computational nodes located at the

edges of the sensor network, shown in Fig. 4, discussed in detail in

the following sub-sections. The computational nodes arranged at

the outside of the network are further divided in pre-

computation and the ﬁnal computation nodes (the four nodes

located at the corners of the network). The pre-computational

nodes can be embedded PCs or single micro-chips, and the compu-

tational nodes can be workstations or servers physically displaced

from the material-embedded sensor network. Only the inner sen-

sor nodes are micro-chip platforms embedded in the technical

structure material, for example, using thinned silicon technologies.

4.1. Event-based sensor data processing with agents

The computation of the system response information requires

basically the complete sensor signal matrix S. In traditional sensor

signal processing networks this sensor matrix is updated in regular

time intervals, resulting in a high network communication and

sensor node activities. In this approach presented here the ele-

ments of the sensor matrix are only updated if a signiﬁcant change

of speciﬁc sensors occurred. Only the four corner computational

nodes store the complete sensor matrix and perform the inverse

numerical computations, explained in Section 6.

The sensor processing uses both stationary (non-mobile) and

mobile agents carrying data, illustrated in Fig. 5 on the left side.

Fig. 3. Different agent processing platform architectures and implementations, but a common agent behaviour model and programming sources. (PCSP: Pipelined

Communicating Sequential Processes, PAVM: Pipelined Agent Forth Virtual Machine, ATG: Activity-Transition Graph, AAPL: Agent Programming Language, HWS: Hardware

Synthesis, SWS: Software Synthesis, PSIM: Platform Simulation, BSIM: Behavioural Agent Simulation).

16 S. Bosse, A. Lechleiter / Mechatronics 34 (2016) 12–37

There are two different stationary (non-mobile) agents operating

on each sensor node: the sampling agent which collects sensor

data, and the sensing agent, which pre-processes and interprets

the acquired sensor data. If the sensing agent detects a relevant

change in the sensor data, it sent out four mobile event agents,

each in another direction. The event agent carries the sensor data

and delivers it to the pre-computation nodes at the boundary of

the sensor network. The agent behaviour is speciﬁed in Algorithm

2 in Appendix A, and an overview of the agent behaviour and the

ATG can be found in Fig. 5 on the right side.

An event agent has a pre-deﬁned path in the direction dir which

is followed by the move activity as long as there is connectivity to

the next neighbour node in this direction. Normally the agent trav-

els to the outside of the network on the given direction by applying

the route_normal routing strategy successfully. If it is not possi-

ble to migrate in the pre-deﬁned direction, an alternative path is

chosen by using the route_opposite routing strategy, which

chooses a path away from the original destination to bypass not

connected nodes and missing communication links. Using the

route_relax routing strategy the agent is directed again to the

original planned path. Making routing decisions and migration

are performed in the move activity of the agent, followed by the

check activity which collects sensor data from the current node

and checks the destination node goal, and if reached delivering

the sensor values in the deliver activity.

Each pre-computation node stores a row or a columns of the

sensor matrix S. If their data changes, the pre-computation nodes

will sent out two mobile distribution agents in opposite directions,

delivering a row or column of S to the ﬁnal computation nodes,

located at the edges of the sensor network.

4.2. Self-organizing MAS and feature recognition

The event-based sensor data distribution relies on well operating

sensors and trustful sensor values. Faulty or noisy sensors can

disturb the further data processing algorithms (inverse numeric)

signiﬁcantly and should not delivered to the computational nodes.

Usually sensor values are correlated within a spatially bounded

region. The goal of the following MAS is to ﬁnd the outline of

extended correlated regions of increased sensor stimuli which can

be distinguished from the neighbourhood. For example, strain

gauge sensors which deliver information about mechanical distor-

tion of a material resulting from externally applied load forces. A

single stimulated sensor cannot be a result from a mechanical load.

To ﬁnd such a correlated stimulated sensor region, a distributed

directed diffusion behaviour and self-organization (see Fig. 6) are

used, derived from the image feature extraction approach

(proposed by [15]). A single sporadic sensor activity not correlated

with the surrounding neighbourhood should be distinguished from

an extended correlated region by marking nodes nearby the bound-

ary of the region, which is the feature to be detected (edge detector).

Sensor nodes detecting a signiﬁcant change of their sensor val-

ues send out explorer agents which perform the feature detection

and marking. Sensors nodes sending out the feature recognition

agents but get no markings can decrease a trust probability for

their sensor values for further assessment and activity planning.

The feature detection is performed by the mobile exploration

agent, which supports three main different behaviours: explo-

ration, diffusion, and reproduction. The diffusion behaviour is used

to move into a region, mainly limited by the lifetime of the agent,

and to detect the feature, here the region with increased

mechanical distortion (more precisely the edge of such an area).

The detection of the feature enables the reproduction behaviour,

which induces the agent to stay at the current node, setting a

feature marking and sending out more exploration agents in the

neighbourhood. The local stimuli H(i

, j) for an exploration agent

to mark a speciﬁc node with the coordinate (i, j) is given by Eq. (4).

Hði; jÞ¼

u¼R

v ¼R

f sði þ u; j þ

Þsði; jÞ

6 dg

s : SensorSignalStrength

R : SquareRegionaroundði; jÞ

ð4Þ

Table 1

Comparison of both agent processing platform architectures and their implementations (PCSP: Pipelined Communicating Sequential Processes, PAVM: Pipelined Agent Forth

Virtual Machine).

Programmable PAVM Non-programmable PCSP

Approach  Program code based approach

 Data is embedded in code

 Zero-operand instruction format

 Stack memory centric data processing model

 Platform is generic

 Code embeds instructions, conﬁguration (control state), and data

 Migration: code transfer

 Application-speciﬁc approach

 Platform is application-speciﬁc

 Activities of the ATG are mapped to processes

 Token-based agent processing

 ATG reconﬁguration by switching token channel paths

 Migration: data and control state transfer (including conﬁguration

table)

Hardware  Optimized Multi Stack Machine

 Each stack processor is attached to a local code segment and two stacks

shared by all agents. There is no data segment!

 Single SoC Design

 Multiprocessor architecture with distributed and global shared code

memory

 Multi-FSM RTL hardware architecture

 Automatic Token-based agent process scheduling and processing

 Code morphing capability to modify agent behaviour and program code

(ATG modiﬁcation)

 Data- and code word sizes can be parameterized

 Pipelined Communicating Processes Architecture composition imple-

menting ATG and token-based agent processing

 Single SoC Design

 Optimized resource sharing – only one PCSP for each agent class

implementation required

 Activity process replication for enhanced parallel agent processing

 For each agent class there is one PCSP with attached data memory

(agent data)

 Single SoC Design

 LUT conﬁguration matrix approach for ATG reconﬁguration

Software  Multi-Threading or Multi-Process software architecture

 Inter-process communication: queues

 Software model independent from programming language

 VM sources for various programming languages: C, ML, Javascript, ...

 Can be embedded in existing software

 Multi-Threading software architecture

 Optimization: Functional composition and implementation of ATG

behaviour instead PCSP

 Interprocess-communication: queues

 Software model independent from programming language

 Source code for various programming languages: C

, ML, ...

 Can be embedded in existing software

Simulation  Agent-based Platform simulation

 Generic simulation model – can execute machine code directly

 Processor components and managers are simulated with agents

 Agent-based platform simulation

 Application-speciﬁc simulation model

 ATG activity processes are simulated with agents

S. Bosse, A. Lechleiter / Mechatronics 34 (2016) 12–37