Page 283 - Mechatronics for Safety, Security and Dependability in a New Era

Ch54-I044963.fm Page 267 Thursday, July 27, 2006 8:16 AM
8:16 AM
Thursday, July 27, 2006
Page 267
Ch54-I044963.fm
267
267
(MCU). In other words, the physical architecture is a regular field bus device network, where the
Atomis are the nodes of the bus, but which is extended towards object-oriented thinking as combined
software and hardware objects, and implemented in a small physical scale.
Field bus
Field bus Simple device
Simple device
7V— Device main control object
Device main control object
A-Servo control object
Servo control object
Servo •'
Servo
AD-conversions object
connectors I- AD-conversions object
connectors
Sensor
connectors
Figure 1 Device built with embedded objects i.e. Atomis
Object-oriented thinking
The advantages of object-oriented techniques (OOT) for software are well known (Booch, 1991,
Yourdon, 1994, Martin and Odell, 1992). Many of them apply directly to hardware or an embedded
system, such as maintainability, reusability, stability, reliability, faster designing, and extensibility. In
our case, one of the main reasons for using object-oriented technology is the goal of making an easy,
high-level method to create embedded systems. We consider Atomi as combined software and
hardware object: each Atomi contains its own properties, events, and methods, which are related to
each Atomi's hardware functionalities. As the benefits of the OOT are achieved via some fundamental
elements, such as modularity, encapsulation, abstraction, hierarchy, inheritance, and concurrency, it is
relevant to study how they can be realized in Atomis.

Atomis realize modularity, encapsulation and concurrency naturally via their modular architecture.
Modularity is important element for the high-level development goal, since it enables the use of library
objects i.e. Atomis with ready-made low-level code and hardware. The idea of encapsulation is that the
internal data is hidden from the other objects, and only accessible via specific methods. Since the
software of an Atomi corresponds directly to the hardware, and Atomis are accessible only through the
field bus interface, this realizes naturally. Concurrency means the handling of different events
simultaneously. In the Atomi context it is realized through the multiprocessor architecture.

Abstraction and hierarchy are combined through inheritance. Abstraction means presenting the
essential characteristics of an object that distinguishes it from other types of objects, and hierarchy
means ranking or ordering these abstractions. Inheritance represents a hierarchy of abstractions, in
which a subclass (child) inherits from one or more superclasses (parents) (Booch, 1991). In the Atomi
architecture, inheritance is realized at two levels. A new object inheriting another object or objects can
be realized by just stacking the objects, i.e. Atomis, together and writing new software for the new
child object. This we call high-level inheritance (see Figure 2). Here, the child object controls the
parent objects, while the interfacing to others takes place via the interface of the new child object. This
procedure implements the inheritance of the parents as public class members, since others can access
them directly because they are all on the same bus. However, the new child object can also have two
interfaces (field bus interfaces and software protocol stacks) and thus implement the inheritance as
private class members by attaching objects into the second bus, which is separated from the common
bus.