J Sign Process Syst (2013) 73:315323

DOI 10.1007/s11265-013-0767-x

A Methodology for Design of Scalable Architectures

in Software Radio Networks: a Unified Device
and Network Perspective
Maurizio Colizza Marco Faccio Claudia Rinaldi
Fortunato Santucci

Received: 18 October 2012 / Revised: 1 February 2013 / Accepted: 24 April 2013 / Published online: 18 May 2013
Springer Science+Business Media New York 2013

Abstract This paper proposes the Tissue methodology as

a novel methodology for analysis, design and synthesis
of networked embedded systems and subsequent development of distributed architectural frameworks. The proposed
method aims at reducing the development time through the
use of reconfigurable HW/SW components and the
applica- tion of automatic code generation techniques. We
devise the usefulness of the proposed methodology in
the context of mobile ad-hoc networks (MANET) which
exploit Soft- ware Radio (SR) technology for
reconfigurability issues. Drawbacks of current design and
simulation tools and advantages coming from the
application of the TM are discussed in the paper.
Keywords Software architecture Simulation Automatic
code generation Tissue methodology MANETs
Software Defined Radio

1 Introduction
The recent development of advanced applications running
on interconnected systems has pushed increasing demands
for evolution of communication systems, with the wireless
M. Colizza M. Faccio C. Rinaldi ( ) F. Santucci
Center of Excellence DEWS, University of
LAquila, LAquila, Italy
e-mail: claudia.rinaldi@univaq.it

domain being interested by an unprecedented pressure for

supporting several services through different protocol
stacks and in different bands. This has motivated the
research and industrial communities to undertake the
investigation of algorithms even for dynamical resource
access [1] as the basis for dynamical configuration of
communication systems. The consequent trend of moving
processing from the hardware, to the software, has lead to
the Software Defined Radio (SDR) paradigm [2]. To
satisfy the chal- lenges introduced by this communication
technology, one of the possible solutions proposed in
literature is given by the Software Communications
Architecture (SCA) [3]. SCA is a non-proprietary, open
architecture framework that tells designers how elements
of hardware and software have to operate in harmony
within a software defined radio. It is a set of design
constraints. If a developer designs a system according to
these design rules, the system will be portable to other SCA
implementations regardless of what operating system or
hardware that implementation utilizes.
The main features of SCA are summarized as follows:

M. Colizza
e-mail: colizza@westaquila.com
M. Faccio
e-mail: marco.faccio@univaq.it
F. Santucci
e-mail: fortunato.santucci@univaq.it

it is an architecture with a layered structure;

at the top level, an Operative Environment (OE) is
avail- able which provides support for a component
based design; the Operative environment is accessible
by means
of a middleware;
each
component
may be developed by using any language, such as Java, C++;
a system results in a set of components which
exchanges data and remote procedures call, by means
of a communication service of type client-server, that
is
provided
by CORBA (Common Object Request Broker
Architecture) within the Operative Environment;
the client-server communications are managed by
means of the ORB (Object Request Broker) bus;

J Sign Process Syst (2013) 73:315323

SCA describes only the behavior expected from components, waveforms, and operational environments; it
does not provide implementation details;
in the SCA platform any aspect of a target platform,
such as processors, FPGA or DSP resources, Real Time
Operative Systems (RTOS), is hidden by the OE to the
top level.

Furthermore, the reconfiguration ability covers all layers

of a protocol stack. This high degree of reconfigurability
opens new possibilities in terms of dynamical access to services, while bringing new problems due to the dynamicity
introduced in the protocol stack.
Indeed the design and even the simulation of wireless
systems is non trivial, because the number of nodes is usually large, different radio technologies are involved, different traffic types (i.e. voice, data, multimedia) are involved,
various mobilities, channel and propagation models are
assumed, and there are various available bandwidths. In
par- ticular MANETs, with high degree of adaptivity and
ability to (re)configure in application scenarios, motivate
research efforts in developing methods and tools for
supporting a complete and sound design flow that
encompasses:
1. waveform/protocol specification;
2. validation through accurate simulations and early stage
testing;
3. rapid code development on selected target platform.
Despite those needs of high degree of complexity,
it can be observed that state-of-the-art software design
methodologies, e.g. RUP [4], are too complex and computationally intensive to be used in the field of networks
protocol stacks.
Therefore, we aim at defining a methodology that:

allows the implementation of distributed architectures

through the use of design patterns;
is based on design pattern using a reduced set of components, each of which may be hardware (HW) or
software (SW);
allows to put together the design patterns using a technique to exchange messages;
enables easy traceability among system requirements,
architectures and code.

Moving from inspections of simulation environment, a

(non exhaustive) list of current weaknesses in the
avail- able tools (e.g. NSx, OPNET, OMNET) can be
provided as follows:
1.

simulators are not typically conceived to offer the

opportunity to reuse the developed code for subsequent
implementation on the target device;
2. the problem of inserting and removing measurement
code inside business code is not typically addressed;

3.

tools for sound and easy support of tracking projects

requirements into the developed code are not available;
4. tools for supporting automatic generation of reports
that rely on qualitative and quantitative performance
assessment are not satisfactory;
5. high level cross verification for performance analysis
(e.g. logic trigger) is not addressed.
With the motivation of bringing improvements in
the depicted technical framework, we are involved in
several projects, e.g. ARTEMIS PRESTO http://www.
presto- embedded.eu/ and FP7 NoE HYCON2 http://www.
hycon2.eu/ both co-funded by the European community.
Although the main research problems are different, both
projects are conceived with the aim of riding over limitations due to the currently used technologies. Specifically,
the PRESTO project is mainly focused on:
1.

the improvement of test-based embedded software

development and validation procedure, while considering the constraints of industrial development
processes;
2. the definition of functional and performance analysis
with platform optimization at an early stage of the
development process.
The project also intends to explicitly consider some industrial development constraints: simplified use of tools,
smooth integration in current design processes, framework
of tools that is flexible enough to adapt to different process
methodologies, design languages and integration test, platform modeling for early comparison of results with real
sce- narios and fast prototyping. Through the WP6,
HYCON2 also pursues research advances in developing
methods and tools for analysis and design in the broad
range of complex and networked embedded systems.
In this paper we focus on the definition and development
of a set of tools (suite) to support sound design, appropriate verification/test and development of embedded software
for SDR systems. Specifically, we are defining a workflow
whose qualifying features are as follows:
1.

the design of a system or subsystem in a network

protocol stack is model-based;
2.
the amount of manually written code (firstly for
simula- tion) is minimized, while the code can be
obtained from the model through a set of procedures
for automatic code generation;
3. the probes for measurement may be placed in the
model; they can be automatically switched off when
the model is used to produce code for target devices;
4.
the model holds true independently of the target
device;
5. when a probe for measurement is selected, the generated track can be automatically added to a technical
report.

The suite is intended to provide the designer with the

capabilities of:
1. developing a protocol model through the composition
of library components;
2. generating code for simulation and test in a network
simulator starting from the model;
3. generating code for a target device, starting from the
model;
4. integrating protocol models with application related
models, e.g. those encountered in the context of networked control systems.
The paper will report on already achieved results in terms
of developed models and simulation environments.
The paper is structured as follows: in Section 2 we
describe the proposed architecture, with Subsections related
to the illustration of TM, the requirements of an environment supporting TM, the basic Tissue Patterns (TPs) and a
case study; in Section 3 TM is used to define a simulator
architecture and finally Section 4 concludes the paper and
outlines future works.

2 Architecture for Design

2.1 Methodology and Architecture Definition
Data structures are critical factors when dealing with the
re- usability of simulation code on target devices. This is
due to the fact that the target device hardware has limited
resources with respect to the host platform. Code
traceability, with respect to requirements, reporting on
design, development and test are other critical factors for
treatment of protocol stacks such as those in MANETs.
This section proposes an implementation of a new
methodological approach, namely Tissue Methodology
(TM), [5] whose aim is to define an architecture taking
into account the previous critical factors. The methodology proposed in [5] emphasizes the following modeling
paradigms:
1.
2.
3.
4.

modular programming [68];

patterns programming [9];
events oriented programming [10];
fractal programming [11].

The design pattern used in this methodology is called

TP. The TP has the aim of enabling the design by using a
basic module which is able to:
1. receive and generate events (H);
2. process events (P);

3. store a state space or other information (S);

4. increase their skills through interaction with other
units or reconfiguration.
The growth of tissues is achieved through the repetition
of basic units, as well as the fractal structures; the link
between H, S and P is represented by functional calls, an
access to remote resources, or any communication protocol. The basic units can be used to build macro structures
that can be in turn used for growing a tissue. Following this
approach, a protocol stack can be rethought as shown in
Fig. 1 where a model made up of a basic TP is presented;
each of the H modules receives events from other layers
and, at the same time, it generates events towards other
layers.
In every layer each event is processed by the P module.
The data exchanged between two layers, or the data needed
by a P module, are stored in the S module.
It is worthwhile mentioning that each S module represents a system to store data (e.g. a bank of memories, a
remote data source). Both the P module and the H module may retrieve a specific data set through an identification
code. Through this code, the module, which needs to use
the data set, receives a handle; this handle enables the use
of the data set in read/write mode (Fig. 2).
The data set could be composed by basic types (e.g.
boolean, int, double) or structured data type. If the designer
defines all data types required by the project, the S module
may be implemented through automatic code generation.
Moreover, using standardized data structures, or rather data
structures gathered from predefined ones, the measure code
may be generated in automatic mode too and it may be
automatically switched off when the model is used to produce code for the target device. Along with this vision, it is
important to define techniques in order to:
1. exchange information between different layers, or
rather, between different modules of type H;
2. index each data set;
3. manage events generation and subsequent processing.
In next sections we suggest a SW implementation for
these techniques.
2.2 Requirements of the Tissue Integrated Development
Environment
This section deals with the definition of requirements that
relate to the Tissue Methodology. The first step consists in
isolating the main characteristics of each paradigm that is
at the basis of the Tissue Methodology. The modular programming is the first concept to be taken into account. In
order to be able to build a system through input/output
func- tionalities and memory partitioning, the
environment has

Figure 1 Use of the basic TP to

model a protocol stack.

SAP6

M
E
A
S
U
R
E
S

SAP5

to guarantee a support for the creation of the module. The

latter one has to be supplied with input/output ports for
receiving and generating events (Req.1). Moreover, a handle has to be provided by each module to allow interaction
with other modules (Req.2). In order to exchange events,
a communication protocol (Req.3) is also required. One of
the possible protocols to be used is the Message Passing
Interface (MPI) [12]; this protocol is particularly
interesting because of the existence of a version for real
time systems, named Real Time MPI. This is appealing for
our purposes, because the environment we want to
propose is intended to enable the designer to simulate the
architecture that is going to be implemented on the target
device (Req.4). With this design choice, starting from
architectural models, it is possible to automate, through
automatic code generation, the implementation of the
model either for simulation or for prototyping activities,
without any need for porting, any redesign and new testing
activity (Req.5). Basing on pre- viously described
requirements, the event based simulator OMNET++ has
been chosen. The next section is devoted to describe the
Sequence diagram of the design pattern which is depicted
in Fig. 1.
handle

ID1

handle1

SAP3

SAP1

SAP2

PHY

ID

SAP4

S
U
R
E
S

MAC

S
U
R
E
S

LLC

S
U
R
E
S

IP

S
U
R
E
S

UDP/TCP

M
E
A
P

Application

The issue of designing a protocol layer using TM can be

approached by the use of the TP shown in Fig. 3.
This pattern represents the basic configuration to build a
system, where the tasks to deal with are shared among different entities, that can be classified in logical layers. However, if a cross layer interaction is required, the architecture
depicted in Fig. 1 inherently supports this interaction. This
concept can be explained with the help of Fig. 4, where
other elements are used in addition to the Data Set, i.e. the
opera- tion set, containing the handles for cache
functionality, and the event set, containing the handles to
the events. Each data set is characterized by two
coordinates, the handle of the ref- erence storage sHandle
and the handle of the specific data
handleDk with k referring to indexes of data types in the
following ranges:

[1, N ] for the data set;

[1, M ] for the operation set;

[1, L] for the event set.

Figure 2 Data set.

2.3 TP for Protocol Design

IDN

M
E
A
S
U
R
E
S

handleN
Figure 3 Basic TP.

sHandle

pHandle

hHandle

Table 2 802.15.4 modulations.

EventN

Initialize
Data
set
Exchange
data

Call
event
operation
execute
operations

Exchange
data
Operation Set
DatahandleD
Set
ID-Data
handle
ID
handle
ID-Process
handleP
ID
IDD1
handleD1
IDP1
handleP1

IDDN

handleDN

IDPN

handlePM

Identify
events
Answer
To
EventN

Event Set
ID
handle
ID-Event
Operation
IDE1 handleP1

IDEN

handlePL

Figure 4 Sequence Diagram for a Basic TP.

It has also to be noticed that:

1.

all data set can be moved from one storage module to

another;
2. any data set can be handled from any P module or
H module; indeed, it is possible to use the pair
(sHandle,handleDk) from any module.
Moreover, the exploitation of previous advantages
facili- tates measurement operations. Before going into the
devel- opment of techniques to automate code generation
for TP implementation, and hence the protocol stack, the
feasibil- ity of these methods needs to be assessed. The
next section proposes an application of TP to a 802.15.4
physical layer.

Binary PSK at 868 MHz

P1

S1

Offset Quadrature PSK at 2400 MHz

P2

S2

2.4 TP for 802.15.4 PHY Layer

to spotlight the differences with a traditional design, like
OOP (Object Oriented Programming), we started from an
existing project and we redesigned this project through the
reuse of existing code in order to produce a TM compliant
implementation. The project is part of a framework developed to simulate MANET networks through OMNET++.
The framework is called INETMANET, and we focused on
the physical layer 802.15.4 implementation. The
conversion
has been achieved through the following steps:
1. definition of data types to cover all data managed into
the PHY layer;
2. association of a unique identification code to each data
type;
3. association of a unique handle to each data type.
In Table 1 we show the implementation of the handles
for each data type, based on the map data structure of C+
+ STL (Standard Library) and their informal description.
All these methods are located in the P module. This
closes the implementation of the basic TP of Fig. 4.
Now, by resorting to Software Defined Radio
paradigms, the reprogramming of a device has to be taken
into account. According to the Tissue architecture, an
example of recon- figurability is shown. Let us consider
Table 2, wherein we

Table 1 Implemented methods and abstract references.

Function

Abstract
reference

Description

select802154Data
set802154Dat
hs802154PHY
hS802154PH
fCSend fCSelfMsg
fCancEvent
deleteSelfMsg

F1
F2
F3
F4
F5
F6
F7
F8
F9
F10
F11
F12
F13
F14

it returns the handle specified by the typeData ID

it adds a new data structure
In order to retrieve the handle of the storage
module In order to retrieve the handle of the
storage module to control the generation of events
in the H module to set internal events (e.g. Timer)
to cancel an event that is expired or has been processed
to cancel an internal event that is expired or has been
processed to display information at run time
to manage the primitives exchange between 802.15.4 PHY and MAC
layers to manage messages originated from the mac layer
to manage internal messages
to manage messages coming from lower layers
to manage the queue of the air frames Protocol Data Units

updateDisplayString
handlePrimitive
handleUpperMs
handleSelfMsg
handleLowerMsgStart
bufferMsg

Java storage

tuple
type

e.g.
routing
table

position

time

node

Figure 7 Java storage class.

Figure 5 Example of dynamic TP reconfiguration.

assume that two modules of type P are defined for implementation of two modulation formats at the physical layer:
specifically, P1 for the BPSK format, and P2 for O-QPSK,
[13]. Let us assume that the early (default) implementation includes the module P1; when the H module of the
PHY layer identifies an event which encodes a command
for switching the modulation format, it starts a
reconfiguration procedure which includes the following
steps:

The H module of PHY layer forwards the detected

event to a H module devoted to the management of
reconfigurations;

The latter H module performs the following

operations:

Figure 6 Network Storage concept.

3 Architecture for Simulation

Once the code of a protocol stack is produced, network
simulations for a set of nodes is carried out to evaluate
its performances (e.g. end-to-end delay, throughput, power
consumption, reliability etc.).
We assume that the code to be simulated is the same code
used for the target device; this implies that the accuracy of
the protocol stack code is particularly complex and so is the
simulation, both for the execution time and the amount of
generated data. Indeed, a network data acquisition system
has to guarantee:

complete traceability of algorithm behaviours running

on the single device and network wide behaviours;
scalability both in time (e.g. increasing of the number
of nodes) and high data streaming;
reconfigurability of check points.

Figure 8 Tuple-time plane for node i.

P
P

PHY

DT

PHY

H
H

DT

Node i

P
S
S

DT

tuple
type 1

S
S

According to TM, a simulation of an N-nodes network

can be represented with the architecture shown in Fig. 6.
The Simulation Architecture consists of N instances of
the Node Architecture (Fig. 1), which is in turn composed
by basic TPs. It is worth noting that each Node Architecture may be characterized by one or more storages. On a
higher level of abstraction the set of all storages of each
node can be viewed as a network storage exchanging data
with a Distributed file System (DFS), as in Fig. 6.
All storages can be viewed as sources of data streams
contributing to a single data flow. The latter one has to be

It receives the message and identifies the modules,

P2 and S2, devoted to process the message;
It produces an instance of S2 and P2;
It updates the Tissue Pattern of the physical layer as
shown in Fig. 5.

TM
DFS

tuple
type k
tuple
type

Data
node

chunk

Node

Table 4 Storage cloud management.

file

data node
process ID

Node i
tuple
type x tuple type

DTx
time

Figure 9 Storage space.

stored and, due to its dimensions, a distributed file system

may be helpful. This implies that the basic storage unit is
given by a file. There are two main possibilities of extracting data streams that represent the file content. The first
one is given by the introduction of a measure module, i.e.
the observer, inside each node. The observer needs two
types of data: the type of the tuple to be observed and the
sampling time. These data are placed in an XML file. The
second solution envisages the exploitation of a listener, that
belongs to the simulation environment. The listener senses
the events occurring during the simulation and gathers
information coming from each event.
In both cases the content of the file is achieved through
the following steps:
1.

the gathered information is placed inside objects which

are instances of C++ classes; the use of C++ language
is motivated by the fact that we are simulating in the
OMNET++ environment;
2. a Java application is called whose inputs are given
by
clones of the previously described C++ objects; clones
are necessary in order to avoid memory access conflicts and, since the Java application is managing C++
objects, Java Native Interface (JNI) are here used;
3. clones of C++ objects are copied inside Java objects by
the Java application, as sketched in Fig. 7;
4. Java objects are serialized within the file; with this
approach the data stream is projected into a plane
time-tuple as shown in Fig. 8;
5. the file is closed when its dimension exceeds a specific
threshold; the minimum value for the threshold is
given by 64 MByte as established in [15].
The analysis of simulation results is equivalent to a
research in a 3-dimensional space where dimensions are:
time, tuple type and node ID (see Fig. 9). In this way the
problem of information searching is orthogonalized, [14]
with the following search rules:

tuple-type based search;

Table 3
table.

Index simulation

tuple ID

tuple type

start

stop

filename

node ID

node ID based search;

T based search;
a combination of two or more previous criteria.

These criteria can be supported by an SQL database

providing Tables 3 and 4.
The use of those tables allows to support many queries.
As an example, let us consider the problem of finding all
tuples of a certain type (e.g. position, routing table, etc.)
within a specific time interval for a specific node:
1. find all the tuples of the specific type for the specific
node;
2. within the result of the previous query, find the tuples
belonging to a certain time interval;
3. read the corresponding filenames;
4.
retrieve the files associated with the previous
filenames.
An inverse operation is even possible. Indeed another Java
application may receive the extracted files as inputs. For
each file, the Java application has to provide for:

file reading (Java streaming acquisition);

de-serialization of Java storages inside each file;
extraction of data required from each Java storage;
data forwarding to a viewer.

4 Conclusions and Future Works

In this paper we faced the issue of the design and development of reconfigurable wireless networks.
In order to meet advanced requirements in challenging
contexts, in this paper we proposed a methodology, called
Tissue Methodology, that is a combination of four modelling paradigms: modular programming, patterns programming, events oriented programming, fractal programming.
Design patterns developed by the proposed methodology
are called Tissue Patterns. They are built through the use of
only three basic components (i.e. S, H, P) that can be connected using exchange messages techniques. Basing on this
framework, distributed architectures can be developed.
An example has been devised to validate the methodology, with particular emphasis on exploitation of modular
design and the support of reconfigurability. Indeed the
legacy code of the IEEE 802.15.4 PHY layer, belonging to
the INETMANET framework, has been modelled using the
Basic Tissue Pattern. The MPI has been used as exchange
message technique.

In addition, we extended the use of TM to the simulation

level by proposing a method for simulation data storage on
a distributed storage system.
Ongoing work is focused on development of tools and
validation of the TM methodologies in case studies proposed in out research projects (MANETs are a major concerns, as stated), with close links to industrial partners.
Future works will expand toward the broader and emerging
context of Software Defined Networks.

References
1. Mitola, J., & Maguire Jr., G.Q. (1999). Cognitive radio: making
software radios more personal. In IEEE Personal Communications, 6(4), 1318.
2. Nesimoglu, T. (2010). A review of Software Defined Radio
enabling technologies. Microwave Symposium (MMS),
2010
Mediterranean,
pp.
8790.
doi:10.1109/MMW.2010.5605145.
3. Bard, J., & Koverik Jr, V.J. (2007). Software Desined Radio: the
software communication architecture (p. 462). Wiley: ISBN
9780470865187.
4. Shuja, A., & Krebs, J. (2007). Ibm Rational Unified Process Reference and Certification Guide: Solution Designer (First ed.).
IBM Press.
5. Colizza, M., Faccio, M., Rinaldi, C., Santucci, F. (2012). A
methodology to design an advanced framework for efficient
modelling and testing of manets. Wireless Telecommunications
Symposium (WTS), 16. doi:10.1109/WTS.2012.6266119.
6. Lau, K.-K., & Wang, Z. (2007). Software component mo
dels. IEEE Transaction Software Engineering, 33(10), 709724.
doi:10.1109/TSE.2007.7072633.
7. Sicard, S., Boyer, F., De Palma, N. (2008). Using
components
for architecture-based management: the self-repair case. In Proceedings of 30th international conference on software
engineering (ICSE 2008), ACM, ISBN: 978-1-60558-079-1.
8. David, P.C., Leger, M., Grall, H., Ledoux, T., Coupaye, T.
(2008).
A multi-stage approach for reliable dynamic reconfigurations of
component-based systems. In 8th IFIP international conference
distributed applications and interoperable systems, DAIS 2008,
volume 5053 of LNCS.
9. Gamma, E., Helm, R., Johnson, R., Vlissides, J.M. (1994).
Design
patterns: elements of reusable object-oriented software. AddisonWesley Professional, ISBN: 0201633612.
10. Mani Chandy, K., Charpentier, M., Capponi, A. (2007).
Towards
a theory of events DEBS 07, June 2022. Toronto, Ontario,
Canada.
11. Fractal programming. http://fractal.ow2.org/documentation.html.
12. Gropp, W., Lusk, E., Skjellum, A. (1999). Using MPI, 2nd edition: portable parallel programming with the message passing
interface. Cambridge, MA, USA: MIT Press Scientific And Engineering Computation Series. ISBN 978-0-262-57132-6.
13. Haykin, S. (2001). Communication systems, Fourth Edition,
Wiley.

14. Keutzer, K., Newton, A.R., Rabaey, J.M., SangiovanniVincentelli, A. (2000). System-level design: orthogonalization
of concerns and platform-based design. IEEE Transactions on
Computer-Aided Design of Integrated Circuits and Systems,
19(12), 15231543.
15. Apache Hadoop. http://hadoop.apache.org/.
Maurizio Colizza was born
in LAquila, Italy, in 1977.He
received the laurea degree in
Electronic Engineering from
the University of LAquila,
Italy, in 2005, discussing a
thesis entitled Study and
Application of an Environment Codesign for Embedded
System Design. In 2008 he
followed the second level
Master in Technologies,
Applications and Service
in etherogeneous radio networks at the University of LAquila. He is current a third year of
PhD
student at University of LAquila. Since 2006 he has collaborated
with the University of LAquila as Research Engineer in European
projects, such as ESSOR, HYCON2, PRESTO and CRAFTERS. In
2008 he received the Best IP Awards for a SDR IP during IP
Conference in Grenoble, France. His current research activities regard
the definition of a methodology to design, to simulate, and to test
embedded system networks: the development of an enterprise
application to support this methodology is one of the main goal.

Marco Faccio is currently

Associate Professor of Digital Electronics Systems at
University of LAquila. His
present research interests
include the hardware design
of algorithms and design
methodologies but also CMOS
image sensor technology, its
interfaces and communications, the AtoD conversion
for smart sensor and low
voltage digital systems. He is
co-author and author of ninety
international papers in this research fields. He was born in
Tortoreto,
Italy in 1954 and he received the degree in Electrical Engineering
from LAquila University, Italy in 1979. He was worked in industrial
environment about microprocessor, data acquisition systems and IC
design. Since 1989 he has been a Researcher of applied electronics at
Department of Electrical Engineering of LAquila University and he
was also visiting professor to ETH of Zurich in 1995.

Claudia Rinaldi was born

in Rieti, Italy, in 1981. She
got her University Degree in
Electronic Engineering (cum
laude) from the University of
LAquila, at the Faculty Engineering, within the Course
of Telecommunications. The
Master Thesis (available both
in Italian and in English) was
developed at the Royal Institute of Technology (KTH) of
Stockholm under the supervision of professor Karl Herik
Johansson and professor Niels Moller. In 2006 she graduated
in
Trumpet at the Conservatory of Music A. Casella of LAquila
and in 2013 she got a degree in Music and New Technologies
at the same institute. In 2005 she participated to the exam for PhD
appli- cation and obtained the best placement. She thus was PhD
student from 2005 to 2009 at the Center of Excellence DEWS of
The Fac- ulty of Engineering of the University of LAquila
where she got the PhD in 2009 with a thesis with the following title:
Advanced Modeling for Wireless Communications and Distributed
Control over Wireless Networks. In 2005 she had a contract by
the Center of Excellence DEWS for research on modelling and
optimization of transport techniques for adaptive wireless
systems.Since 2005 she was a tutor for students thesis of both
Bachelor and Master Degree. She also made seminars, exercises
and exams for the courses of Signal Analysis and Elaboration,
Wireless Communications, Electri- cal Communications. She made
some lessons for a refresher course in Technolabs, LAquila, about
the MAC level of WiMax Standard. She is the authors of papers
published in various conference pro- ceedings and international
journals and she has been a reviewer for various international
journals.Her main research activities are focused on design,
modelling and optimization of communication algorithms with
particular interest on the physical layer of the pro- tocol stack, in the
use of technology in artistic fields with partic- ular emphasis on
application of wireless sensor networks in elec- tronic music and in
the topics of the software defined radio for the development of
transmission systems responding to cognitive radios paradigms.

Fortunato Santucci (S9

3- M9 5-SM0 0 of the
IEEE) was born
at
LA
quila, Italy, in
1964. He received the laurea
degree and the Ph.D. degree in
Electronic Engineering from
the University of
LA
quila,
Italy, in 1989 and 1994,
respectively. In 1989 he was
with Selenia Spazio S.p.a.,
Rome, working on VSAT networks design. In 1991-1992
he was at the Solid State Electronics Institute (I.E.S.S.) of
the National Research Council (C.N.R.), Rome, doing research on
superconductor receivers for millimeter wave satellite systems. Since
1994 he has been with the Department of Electrical Engineering, University of LA quila, where he currently holds the position of
Associate Professor and is chairing the Telecommunications
Engineering program. He was a visiting researcher at the Department of Electrical and
Computer Engineering of the University of Victoria, BC. His current
research activity is focused on communication theory, access control and radio resource management in future mobile radio systems,
technologies and architectures for wireless embedded networks. He
has participated in major national and european research programs in
wireless mobile communications and coordinates research programs
funded by industrial partners. Since 2000 he has served as an Editor
for the IEEE Transactions on Communications and, more recently,
also for Kluwer Telecommunications Systems and Hindawi. He is in
the TPC of major international conferences and has been author and
speaker of invited/plenary talks in several conferences. Dr. Santucci
has organized national conferences and international workshops. He
has been a guest editor for special issues in international journals. He
is a Senior Member of the IEEE and is in the IEEE Communications
Theory Committee. He is in the Board of Directors of the Center of
Excellence DEWS at the University of LAquila, of the Radiolabs
consortium, and also in the Technical Committee of CNIT. He is in
the Executive Committee of the Network of Excellence HYCON. He
has been a reviewer of research proposals for national and
international funding agencies and is a co-founder and a member of
the board of governors of the spin-off company WEST Aquila srl.