UML for Embedded Systems III. Detailed Design - Eurecom

slide 2 

Memo on Methodology 

III. Detailed design 

Behavior of the system 

II. Design 

Classes of the system 

Architecture of the system 

UML for Embedded Systems 

III. Detailed Design 

Ludovic Apvrille 

ludovic.apvrille@telecom-paristech.fr 

Eurecom, Office 470 

Page 1 

IV. Validation of the 

system 

Simulation 

Code generation 

I. Analysis 

Use case 

First class diagram 

Relevant scenarios 

(C) Ludovic Apvrille UML for Embedded Systems - Fall 2012

slide 3 

slide 4 

Detailed Design Stage 

� Purpose 

• Design the behavior of classes 

� State machine diagrams 

• Signal sending 

• Signal receiving 

• Composite states 

• Loop, tests 

• Setting and use of variables 

• Etc. 

(C) Ludovic Apvrille UML for Embedded Systems - Fall 2012 

Detailed Design 

� Basics of automata 

� Modeling objects with states machines 

� UML state machine diagram 

� TAU G2 state machines 

� Examples 


Page 2

slide 5 

slide 6 

Basics of Automata 

� Definition 

• Machines whose input behavior is not only a direct 

consequence of the current input, but of some past 

history of its input 

� Characterized by an internal state 

• Current state = past experience 


Example of State Machine Diagrams 

LampOff 

on() off() 

lampOn 

Page 3 

Start state 

States 


Trigger

Output and Actions 

� Actions can be generated 

either at state entrance, 

exit or at trigger level 

slide 8 

Use of Variables 

LampOff 

on()/ctr = ctr+1; off() 

lampOn 

Page 4 

LampOff 

on()/print("on"); off() 

lampOn 

Mealy automaton 

Integer ctr; 


slide 9 

slide 10 

Mealy Machines 

� Mealy machines 

• Hopcroft and Ullman (1979, 42), Salomaa (1973, 31) 

• Finite-state machines 

- Take a string on an input alphabet 

- Producing a string of equal length on an output alphabet. 

� Formally, a Mealy machine is a six-tuple 

M = (Q, Σ, Γ, δ, λ, q 1) 

• where 

- Q = (q 1, q 2, …, q |Q|) is a finite set of states; 

- Σ = (σ 1, σ 2, …, σ |Σ|) is a finite input alphabet; 

- Γ = (γ 1, γ 2, …, γ |Γ|) is a finite output alphabet; 

- δ : Q x Σ → Q is the next-state function, such that a machine in state q j, after reading symbol σ k, 

moves to state δ(q j, σ k) ∈ Q 

- λ : Q x Σ → Γ is the output function, such that a machine in state q j, after reading symbol σ k, 

writes symbol λ(q j, σ k) ∈ Γ ; and 

- q 1 ∈ Q is the initial state in which the machine is found before the first symbol of a string is 

processed 


Example 

� Let M = (Q, Σ, Γ, δ, λ, q1) with 

• Q = {q1, q2} • Σ = {sig1, sig2} 

• Γ = {out1, out2} 

• δ(q1, sig1) = q1; δ(q1, sig2) = q2; 

• δ(q2, sig1) = q2; δ(q2, sig2) = q1; 

• λ(q1, sig1) = out1; λ(q1, sig2) = out2; 

• λ(q2, sig1) = out2; λ(q2, sig2) = out1; 

� Propose a graphical representation of this machine 


Page 5

slide 11 

slide 12 






� Examples 


What Can be Modeled with State 

Machines? 

� State machines are well-suited for the modeling of eventdriven 

and discrete behavior 

� Inappropriate for modeling continuous behavior 

threshold 

� Are State Machines well-suited for modeling real-time and 

embedded systems? 

• What is an event-driven systems? 

• What are real-time and embedded systems? 


Page 6 

time

slide 13 

slide 14 

Event-Driven Behavior 

� Event = a type of observable occurrence 

• Interactions 

- Invocation of object operations is synchronous (call event) 

- Receiving of asynchronous signal (signal event) 

• Occurrence of time instants (time event) 

- Interval expiry 

- Calendar/clock time 

• Change in value of some entity (change event) 

� Event Instance = an instance of an event (type) 

• Occurs at a particular time instant and has no duration 


Embedded Systems’ Architecture 

� Embedded system = controlling system + controlled 

system + environment 

Sensors Sensors 

Controlling 

System 

Controlled 

System 

Page 7 

Sensors Sensors Actuators 


Interface

Synchronous 

Asynchronous 

slide 15 

Single event 

Multiple event 

slide 16 

Response to External Events 

Event 

(Input) 

External Hostile 

Environment 

Embedded 

System 

Page 8 

Response 

(Output) 


What is a Real-Time System? 

Synchronous 

Asynchronous 

Single event 


� Real-Time Systems have been defined as: 

“Those systems in which the correctness of the 

system depends not only on the logical results of the 

computation, but also on the time at which the results 

are produced” 

(J. Stankovic, “Misconceptions About Real-Time 

Computing”, IEEE Computer, 21(10), October 1988) 


slide 17 

slide 18 

Jobs and Tasks 

� Task 

• A task is a set of related jobs joined to provide functions 

� Job 

• A job is a unit of work, scheduled and executed by the 

system 

� Parameters 

• Temporal behavior 

- Last less than 20ms, periodic task i.e. executes every 30 ms 

• Functional: intrinsic properties of the job 

- Taps of filter 

• Resource requirements 

- 10kb of memory 

• Interconnection: its communication with other jobs 

- The decoding job must send its result to the displaying job 

- May use shared memory, message queues, etc. 

Synchronous 

Asynchronous 

Single event 



Response to External Events 

Event 

(Input) 

Timing 

Constraints 

Real Real-Time Time 

System 

Page 9 

Response 

(Output) 


Synchronous 

Asynchronous 

Single event 

Multiple event

slide 19 

slide 20 

Are State Machines Well-Suited for Modeling 

Real-Time and embedded Systems? 

� What do you think? 

� What should be modeled with state machines? 

• In principle, anything that manifests event-driven behavior 

• In practice: 

- The behavior of individual objects 

- Object interactions 

� The dynamic semantics of UML state machines are 

currently mainly specified for the case of active 

objects 

� Note: currently, there is no support in UML for 

modeling continuous behavior 


Object Behavior: General Model 

Initialization 

Waiting for input 

Computing input 

Sending output 

Termination 


Page 10 

Note: this is not a 

UML state 

machine but 

rather a flowchart 

to explain how an 

object generally 

behaves

slide 21 

slide 22 

Example 





Termination 

Page 11 

LampOff 

on()/print(on); off() 

lampOn 

stopLamp() 


Active and Passive Objects 

� An active object is a thread of control of the 

application 

• Autonomous 

• No internal concurrency 

• Mechanisms for storing input data 

� A passive object is an object which is not active 

• It is activated by external power 


slide 23 

slide 24 

Object Behavior: Active Objects 





Termination 


Object Behavior: Passive Objects 





Termination 


Page 12

slide 25 

slide 26 

Passive Objects: Synchronization Issues 

Synchronization 

may be 

required! 





Termination 


V. Detailed Design 





� Examples 


Page 13

� States 

� Transitions 

slide 27 

Basics of UML State Machine Diagrams 

Message [condition] / action 

s1 s2 

� Transition with temporal 

information 

when (date = 10) 

E1 E2 

slide 28 


States, Transitions and Actions 

LampOn 

entry/lamp.on(); 

exit/printf(“exiting”); 

off/printf(“to off”); 

LampOff 

entry/lamp.off(); 


off/null 

Page 14 

after(100) 

E1 E2 

LampOff 



off/printf(“needless”); 

Self transition 

entry and exit 

actions are 

ignored 


slide 29 

UML 2.x State Machines: Towards SDL 

state1 

signal1() 

signal2() 

state2 

Page 15 

Waiting for 

the 

receiving 

of signal 

signal1 

Sending of 

signal 

signal2 


Guards 

LampOff 



on[LampIsPlugged]/printf(“to on”); 

LampOn 

entry/lamp.on(); 


x = 5 

state2 

state1 

signal1() 

x = x +1; 

signal2() 

x

slide 31 

slide 32 

Composite States: Hierarchical State 

Machines 

State1 

State2.1 

State2.1 

State2.2 

H 

Page 16 

State3 


Order of Actions 

S1 

exit/exS1 

S11 

exit/exS11 

E/actE 

Execution sequence when E: 

H 

H* 

S2 

entry/enS2 

initS2 

S21 

entry/enS21 

exS11 � exS1 � actE � enS2 � initS2 � enS21 


Swallow history 

Deep history

slide 33 

slide 34 

Orthogonal Regions 

oven on 

oven off 

Page 17 

oven light 

on 

oven light 

off 


Deferred Events 

� Events can be deferred if they cannot be computed 

• Saved for future use 

off/ 

LampOff 

entry/lamp.off() 

off/defer 

LampOn 

on/ 

entry/lamp.on() 

Event is 

deferred 


slide 35 

slide 36 

Fork and Join Transitions 

Child Adult Retiree 

Staff 

Member 

Page 18 

Manager 

age 

employee 






� With TAU G2 

� Examples 


slide 37 

slide 38 

States Machines under TAU G2 

Deferred 

signal 

Termination of 

the object 

signal3 

x = 5 

state2 

signal3() 

state1 

signal1() 

x = x + 1; 

signal2() 

x

fromCounter 

slide 39 

slide 40 

Counter 

port1 

Counter 

 

Loop 

Integer 

 

fromCounter 

Loop (Integer) 

Statechart Diagram statemachine initialize {1/1} 

All transition should have a condition 

for being triggered 


Page 20 

Set Bell 

'port' 

Alarm 

slide 41 

slide 42 

Alarm Clock 

 

Bell 

 

Set 


Page 21 

waitForSet 

Set() 

set(myTimer(), now+10); 

waitForTimer 

myTimer() 

Bell() 

waitForSet 

Simulation of Alarm Clock 

sd Trace (7) Sequence diagram trace 

generated by Tau 

for Alarm 

interaction UseCase3 {1/1} 

env[1] 

'@Set' () 

Alarm[1] 

waitForSet 

waitForTimer 

Bell () 

waitForSet 

myTimer () /* 10.0000 */ 

myTimer () 


statemachine initialize {1/1} 

timer myTimer;

slide 43 

slide 44 

Exercises: Ping-Pong Game 

� Two players P1 and P2 

� P1 

• Sends value k to P2 

• Waits for value k 

• Increment k 

• And so on.. 

� P2 

• Waits for a value x 

• Returns x to the sender 


Microwave Oven 

� We wish to model a basic oven with a door and a 

« start » button 

� Once a meal has been put in the oven, the user 

pushes the « start » button. Once pushed, the meal 

is heated for 30 seconds. Then, the oven stops and 

plays a bell sound 

� Alternatively, the user may open the door while the 

oven is heating. In that case, the heating process 

stops and the 30s delay is set to 0 


Page 22 

« Start » button

UML for Embedded Systems III. Detailed Design - Eurecom

Create successful ePaper yourself

Delete template?

Save as template?