Stefan Bosse - Distributed Agent-Based Computing in Material-Embedded Sensor Network Systems With the Agent-on-Chip Architecture

IEEE SENSORS JOURNAL, VOL. 14, NO. 7, JULY 2014 2159

Distributed Agent-Based Computing in

Material-Embedded Sensor Network Systems

With the Agent-on-Chip Architecture

Stefan Bosse

Abstract—Distributed material-embedded systems like sensor

networks integrated in sensorial materials require new data

processing and communication architectures. Reliability and

robustness of the entire heterogeneous environment in the pres-

ence of node, sensor, link, data processing, and communication

failures must be offered, especially concerning limited service of

material-embedded systems after manufacturing. In this paper,

multiagent systems with state-based mobile agents are used for

computing in unreliable mesh-like networks of nodes, usually

consisting of a single microchip, introducing a novel design

approach for reliable distributed and parallel data processing

on embedded systems with static resources. An advanced high-

level synthesis approach is used to map the agent behavior to

multiagent systems implementable entirely on microchip-level

supporting agent-on-chip (AoC) processing architectures. The

agent behavior, interaction, and mobility are fully integrated

on the microchip using a reconﬁgurable pipelined communicat-

ing process architecture implemented with ﬁnite-state machines

and register-transfer logic. The agent processing architecture is

related to Petri Net token processing. A reconﬁguration mech-

anism of the agent processing system achieves some degree of

agent adaptation and algorithmic selection. The agent behavior,

interaction, and mobility features are modeled and speciﬁed with

an activity-based agent behavior programming language. Agent

interaction and communication is provided by a simple tuple-

space database implemented on node level and signals providing

remote inter-node level communication and interaction.

Index Terms— Mobile agents, intelligent agents, parallel

processing, distributed information systems.

I. INTRODUCTION AND OVERVIEW

MBEDDED systems required for sensorial perception

and structural monitoring (perceptive networks), used,

for example in Cyber-Physical-Systems (CPS) and Structural

Health Monitoring (SHM) [6], perform the monitoring and

control of complex physical processes using applications

running on dedicated execution platforms in a resource-

constrained manner and with real-time processing constraints.

Trends emerging recently in engineering and micro-system

applications such as the development of sensorial materials

[15] show a growing demand for autonomous networks of

Manuscript received September 2, 2013; revised December 31, 2013;

accepted January 6, 2014. Date of publication January 22, 2014; date of

current version May 22, 2014. The associate editor coordinating the review

of this paper and approving it for publication was Dr. Dirk Lehmhus.

The author is with the Department of Computer Science, Working Group

Robotics, ISIS Sensorial Materials Scientiﬁc Centre, University of Bremen,

Bremen 28359, Germany (e-mail: sbosse@uni-bremen.de).

Color versions of one or more of the ﬁgures in this paper are available

online at http://ieeexplore.ieee.org.

Digital Object Identiﬁer 10.1109/JSEN.2014.2301938

miniaturized smart sensors and actuators embedded in tech-

nical structures [6] (see Fig. 1). To reduce the impact of

such embedded sensorial systems on mechanical structure

properties, single microchip sensor nodes (in mm

range) are

preferred. Real-time constraints require parallel data process-

ing usually not provided by microcontrollers. Hence with

increasing miniaturization and node density, new decentralized

network and data processing architectures are required. Multi-

agent systems (MAS) can be used for a decentralized and

self-organizing approach of data processing in a distributed

system like a sensor network [2], enabling the mapping

of distributed raw sensor data to condensed information,

for example based on pattern recognition [5]. In [2], the

agent-based architecture considers sensors as devices used

by an upper layer of controller agents. Agents are organized

according to roles related to the different aspects to integrate,

mainly sensor management, communication and data process-

ing. This organization isolates largely and decouples the data

management from the changing network, while encouraging

reuse of solutions. Multi-agent system-based structural health

monitoring technologies are used to deal with high-density

and different kinds of sensors in reliable monitoring of large

scale engineering structures [5]. In [18] and [19], agents are

deployed for distributed sensing and power management in

wireless sensor networks, but still using embedded system

nodes not suitable for material integration.

Material-embedded data processing systems usually consist

of single microchip nodes connected either wired in mesh-

like networks [6] or wireless using ad-hoc networks [8] with

limited energy supply and processing resources. But tradi-

tionally, mobile agents are processed on generic program-

controlled computer architectures using virtual machines

[7], [8], [18], [19], which usually cannot easily be reduced

to single microchip level like they are required in sensor-

ial materials. Furthermore, agents are treated with abstract

heavy-weighted knowledge-based models, not entirely match-

ing distributed data processing in sensor networks. In [3], a

multi-agent system is used for advanced image processing

making proﬁt from the inherent parallel execution model of

agents.

Application speciﬁc digital logic hardware design has

advantages compared to program controlled microcontroller

approaches concerning power consumption, performance,

and chip resources by exploiting parallel data processing

(covered by the agent model) with lower clock frequencies

and enhanced performance [10].

See http://www.ieee.org/publications_standards/publications/rights/index.html for more information.

2160 IEEE SENSORS JOURNAL, VOL. 14, NO. 7, JULY 2014

Fig. 1. Sensorial materials embedded in robots providing perception information of external applied load forces or internal structure load.

There are actually four major issues related to the scaling of

traditional software-based multi-agents systems to microchip

level and their design:

1) limited static processing, storage,and communication

resources, real-time processing,

2) unreliable communication,

3) suitable simpliﬁed programming models and processing

architectures offering hardware designs with ﬁnite state

machines (FSM) and resource sharing for parallel agent

execution, and

4) a generic high-level synthesis design approach.

Microchip level implementations of multi-agent systems were

originally proposed for low level tasks, for example in

[12] using agents to negotiate network resources and for high-

level tasks using agents to support human beings in ambient-

intelligence environments [14]. The ﬁrst work implements the

agent behavior directly in hardware, the second uses still a

(conﬁgurable) microcontroller approach with optimized paral-

lel computational blocks providing instruction set extension.

A more general and reconﬁgurable implementation of agents

on microchip level is reported in [1], providing a closed-

loop design ﬂow especially focussing on communication and

interaction, though still assuming and applying to program

controlled data processing machines and architectures. Hard-

ware implementations of multi-agent systems are still limited

to single or a few and non-mobile agents ([1], [20]).

In this work, an advanced high-level synthesis approach is

introduced to map the agent behavior of multi-agent systems

on microchip-level with an Agent-On-Chip processing archi-

tecture (AoC). The agent behavior, interaction, and mobility

are fully integrated on the microchip using a reconﬁgurable

pipelined communicating process architecture implemented

with ﬁnite-state machines and register-transfer logic. This

architecture supports parallel agent execution with a resource

shared pipeline approach. In this approach, the agent process-

ing is comparable to Petri Net token processing. A reconﬁgura-

tion mechanism of the agent processing system achieves some

kind of agent adaptation and algorithmic section based on

environmental changes like partial hardware or inter-connect

failures or based on learning and improved knowledge base.

The agent behavior, interaction, and mobility features

are modelled and speciﬁed with an activity-based agent

behavior programming language (AAPL). The activity-

graph based agent model is attractive due to the

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

the hardware implementation. With this AAPL a high-level

agent compiler is able to synthesize a hardware model on

model (C, ML), or a simulation model (XML) suitable to

simulate a multi-agent system using the SeSAm simulator

framework [9]. Agent interaction and communication are

provided ﬁrstly by a simple tuple-space database implemented

on each node providing access and sharing of local data,

and secondly by signals able to propagate in the network

(like messages) preferred for fast and light-weighted remote

inter-node level communication and interaction. To enable

dynamic adaptation of the agent behavior at run-time, the

agent processing architecture implementing the agent behavior

can be (re)conﬁgured by agents by modifying the transitional

network.

Traditionally agent programs are interpreted, leading to a

signiﬁcant decrease in performance. In the approach presented

here the agent processing platform can directly be imple-

mented in standalone hardware nodes without intermediate

processing levels and without the necessity of an operating

system, but still enabling software implementations that can

be embedded in applications.

There is related work concerning agent programming lan-

guages and processing architectures, like APRIL[13] providing

tuple-space like agent communication, and widely used FIPA,

ACL,andKQGML[11] focusing on high-level knowledge

representation and exchange. All those approaches represent

communication and information on complex and abstract

level not fully suited for the synthesis of low-resource data

processing systems in distributed loosely coupled networks,

especially in sensor networks, in contrast to the proposed

AAPL approach, simple enough to enable hardware design

synthesis, but powerful enough to model the agent behavior

of complex distributed systems, which is demonstrated in the

following case study. Though the imperative programming

model is quite simple and closer to a traditional PL it can be

used as a common source and intermediate representation for

different agent processing platform implementations: hardware

(HW), software (SW), and simulation (SIM).

BOSSE: DISTRIBUTED AGENT-BASED COMPUTING 2161

Fig. 2. Prototype of a Sensorial Material using intelligent sensor networks.

What is novel compared to other approaches?

• Reliability and reactivity provided by the autonomy of

mobile state-based agents and reconﬁguration.

• Agent mobility and interaction by using tuple-space

databases and global signal propagation aid solving data

distribution and synchronization issues in distributed sys-

tems design, and tuple spaces represent agent belief.

• One common agent programming language and process-

ing architecture enables the synthesis of standalone

parallel hardware implementations, alternatively stand-

alone software implementations, and behavioral simula-

tion models, enabling the design and test of large-scale

heterogeneous systems.

• AAPL provides powerful statements for computation and

agent control with static resources.

• A token-based pipelined multi-process agent process-

ing architecture suitable for hardware platforms with

putational resources and speed.

• Improved scaling in large network applications compared

with full or semi centralized and pure message based

processing architectures.

II. F

IELDS OF APPLICATION:SENSORIAL MATERIALS

Sensorial Materials are equipped with material-embedded

high miniaturized distributed sensor networks performing load

monitoring or environmental perception [15], shown in prin-

ciple in Fig. 1. These embedded sensor networks consist

of nodes equipped with sensor signal electronics and digital

logic performing computation and communication. Optionally

there are material-embedded energy sources (energy harvester)

supplying the nodes locally.

Fig. 2 shows a prototype of a Sensorial Material using

intelligent sensor networks. Each autonomous network node is

connected with up to four neighbors and strain-gauge sensors

mounted on a rubber sheet, altogether equipped with nine

bi- axial strain-gauge sensors placed at a distance of 70 mm.

The Sensorial Material was used to retrieve load information

about the sheet (applied by external forces) by using advanced

machine learning methods from a small set of uncalibrated

sensors with unknown electro-mechanical model still provid-

ing high spatial resolution compared with the distance of the

sensors to each other.

Fig. 3 shows the usage of such material in an intersection

element of a robot arm manipulator providing external envi-

ronmental perception required for robot control. The proposed

robot manipulator [16] consists of actors (joint drives) and

intersection elements with integrated smart sensor networks.

Distributed data processing is provided by mobile agents.

The agent behavior is implemented with SoC designs on

hardware-level. The intersection element connects two joint

actors with a rigid double-pipe construction, which is sur-

rounded by two opposite placed load sensitive skins (bent

rubber plate), equipped each with four strain-gauge sensor

pairs (bi-axially aligned). Each sensor pair is connected to a

sensor node providing parallel data processing, agent behavior

implementation, and communication/networking. All sensor

nodes are arranged in a mesh-like network connected with

serial point-to-point links. Communication is established by a

smart and robust routing protocol.

III. S

TATE-BASED AGENTS AND THE AGENT

PROGRAMMING LANGUAGE APL

Initially, a sensor network is a collection of independent

computing nodes. Interaction between nodes is required to

manage and distribute data and to compute information.

One common interaction model is the state-based mobile

agent.

The behavior of a state-based agent can be easily mod-

elled with a ﬁnite-state machine completely implementable

with register-transfer logic (RTL) on microchip level eas-

ing high-level synthesis and the exploitation of concurrency