A Standard for Software Reuse
in Embedded, Distributed
Author: James H. Christensen
from Alois Zoitl
All or part of the content of this document may be used under the
terms of the Creative Commons Attribution 3.0 License,
provided that attribution is made by including the URL http://www.holobloc.com/papers/iec61499/overview.htm
in the reused content.
What is IEC 61499?
IEC 61499-1 defines an open architecture
for distributed and embedded control and automation. In conjunction
with an appropriate compliance profile as defined in IEC 61499-4 and software tools meeting the
requirements of IEC 61499-2, reusable software modules (function
blocks) can be developed and deployed in distributed systems that
will meet the requirements of:
- portability: Software tools can accept and correctly
interpret software components and system configurations produced by
other software tools.
- interoperability: Embedded devices can operate
together to perform the functions needed for distributed
- configurability: Any device and its software
components can be configured by software tools from multiple vendors.
Function Block Types
IEC 61499 standard, the basic unit for
encapsulating and reusing Intellectual Property (IP="know-how") is the
function block type. In object-oriented terms, this is a
class defining the behavior of (possibly) multiple
instances. It includes
event inputs and outputs as well as the more traditional
data inputs and outputs, to provide for synchronization between
data transfer and program execution in distributed systems.
Basic Function Blocks
As its name implies, the
basic function block type is the "atom" out of which
higher-level "molecules" are constructed. With IEC 61499 compliant
software tools, software developers can
encapsulate IP in
the form of
algorithms written in
Java® or the
IEC 61131-3 programming languages. Execution of
these algorithms is triggered by
Execution Control Charts (ECCs), which are event-driven state
machines similar to the well-known
Service Interface Function Blocks
Another "atomic" function block type is the
service interface function block (SIFB) type. This represents
the interface to low-level services provided by the operating system or
hardware of the embedded device, such as:
software tools and and their associated runtime
packages provide a large selection of GUI and communications SIFBs.
hardware SIFBs (typically the
manufacturers of embedded devices) can use IEC 61499-compliant
software tools to document how they work in the form of
service sequence diagrams.
- Graphical User Interface (GUI) elements such as a
slider (illustrated below), knob or pilot light
- Communication services (the CLIENT_2 SIFB illustrated
below is a communication "client" for a remote "server")
- Interfaces to hardware such as a temperature sensor, a
motor speed controller, a control valve or a room light intensity
Software developers can use IEC 61499-compliant
software tools to build higher-level function
block "molecules" called
composite function block types out of lower-level function block
component function blocks). This is done by specifying the event
and data interfaces of the composite type, then filling it with a
diagram showing how its internal component function blocks are
connected. In this kind of function block, execution of the algorithms
in the component function blocks is controlled by the flow of events
from one component to another.
IEC 61499-1 architectural model, distributable
applications are built by interconnecting instances of reusable
function block types with appropriate event and data
connections,in the same manner as designing a circuit board with
integrated circuits. Using IEC 61499-compliant
software tools, these function blocks can then
distributed to physical
devices across a network, as long as these devices comply with
It is also possible to distribute an application across multiple
resources within a
device. Resources might be multiple processors plugged into a
backplane, or multiple tasks within a single processor with a
multitasking operating system. In the example shown below, pieces of
Application A run in Resources
x, y and
z, as well as other devices in the system; pieces of Application
B run in resource
z and in other devices; and Application C runs "locally" in
In the IEC 61499 architecture,
resources are the workhorses that provide the services needed to
integrate all the pieces of applications into a working distributed
system. IEC 61499-compliant
software tools can be used to:
- Map the messages that are passed back and forth between
devices into the input and output events and data of communication
service interface function blocks (SIFBs).
- Use event and data inputs and outputs to trigger the
performance of the algorithms of basic
and composite function blocks, and synchronize
their operation with other function blocks
- Map the data and event inputs and outputs of I/O SIFBs
to the inputs and outputs of the system, where it can sense what is
going on in the physical world and take appropriate physical actions
Example 1: Processing a Message
In the example shown below:
- A message arrives from another resource (possibly in a remote
device) via the communication interface.
- The resource maps the data in the message into a data output
of the communication SIFB, which is wired to the data input of a
basic function block; the resource then issues an event from the
SIFB, which is propagated to an event input of the basic FB.
- The arrival of this event causes the resource to execute the
basic FB's algorithm, which uses the value of the data input to
produce new values for the data outputs, which are wired to an I/O
- The resource then issues an event from the basic FB, which is
propagated to an event input of the I/O SIFB.
- The arrival of this event at the SIFB causes the resource to
perform an appropriate action (start or stop a motor, set a room
light level, etc.), based on the data input values of the SIFB.
Example 2: Processing an Input Event
In the example shown below:
- Something happens at an input interface (a user turns a knob,
a limit switch senses the presence of a package on a conveyor, etc).,
which causes the resource to map the input data to an output of the
- The resource maps the input data into a data output of the
I/O SIFB, which in this case is wired to the data input of a
communication SIFB. The resource then issues an event from the I/O
SIFB, which is propagated to an event input of the communication
- The arrival of this event at the communication SIFB causes a
message containing the input data to be sent to a resource somewhere
else in the system.
software tools can be used according to the
following procedure to
configure distributed control and automation systems from
libraries of reusable IEC 61499-compliant components:
- Configure the devices in the system: their names,
types, parameters, and network interconnections.
- Configure the name, type and parameters of each resource
in the devices.
- Build the required application functionality in each resource
by adding and interconnecting function blocks from a library
of function block types and setting their parameters as necessary.
- Add the communication service interface function blocks
(SIFBS) necessary for proper transmission of data and synchronization
of operations among resources, set their parameters and interconnect
them as needed with the application function blocks.
Following is a list of IEC 61499-related software tools known to the
author. Such tools should meet the requirements defined in
IEC 61499-2, and should also have their
characteristics defined in a
Compliance Profile as specified in
Last updated: 2014-10-19.
Java is a registered trademark of Oracle
Corporation and/or its affiliates.