addMessage

Add message to interaction between lifelines

Since R2024b

Syntax

message = addMessage(operand,sourceLifeline,sourcePort,destLifeline,destPort,label)

message = addMessage(___,After=existingElement)

Description

message = addMessage(operand,sourceLifeline,sourcePort,destLifeline,destPort,label) adds a message between the lifelines specified by sourceLifeline and destinationLifeline within the operand specified by operand, where sourcePort and destPort are the ports on the corresponding components. The message message is also assigned the label message label.

message = addMessage(___,After=existingElement) specifies options using one or more name-value arguments in addition to the input arguments in previous syntaxes. For example, to add the fragment fragment after an existing fragment, set existingElement to a valid fragment object.

Examples

Create Sequence Diagrams Programmatically

Create a sequence diagram programmatically to describe the scenario of a pedestrian crossing the street at an intersection with traffic lights.

To learn more about sequence diagrams, see Author Sequence Diagrams Interactively.

Open Traffic Light Example

Load the TLExample architecture model.

model = systemcomposer.openModel('TLExample');

Create a new sequence diagram named 'InhibitCopy'.

diagram = model.addInteraction('InhibitCopy');

Add Lifelines

Add a lifeline for each component in the architecture.

sourceLifeline = diagram.addLifeline('TLExample/source');
pollerLifeline = diagram.addLifeline('TLExample/poller');
switchLifeline = diagram.addLifeline('TLExample/switch');
lampLifeline = diagram.addLifeline('TLExample/lampController');
controllerLifeline = diagram.addLifeline('TLExample/controller');

Get the root fragment and root operand of the interaction.

rootFragment = diagram.RootFragment;
rootOperand = rootFragment.Operands(1);

Add Messages and Fragments

Add two messages to the root operand.

sourceToPollerMsg = rootOperand.addMessage(sourceLifeline, "switchout", pollerLifeline, "sw", "rising(sw-1){sw==1}");
pollerToSwitchMsg = rootOperand.addMessage(pollerLifeline, "switchEvent", switchLifeline, "switchEvent", "switchEvent{switchEvent==1}");

Add an alternative fragment to the root operand.

altFrag = rootOperand.addFragment('Alt');

Specify the guard expressions for each operand of the alternative fragment.

op1 = altFrag.Operands(1);
op1.Guard = "switch/inhibit==0";
op2 = altFrag.addOperand("switch/inhibit==1");

Add two messages to the first operand of the alternative fragment.

switchToLampControllerMsg1 = op1.addMessage(switchLifeline, "lampColor", lampLifeline, "switchPed", "switchPed{switchPed==1}");
switchToControllerMsg = op1.addMessage(switchLifeline, "switchPush", controllerLifeline, "pedRequest", "pedRequest");

Add a message to the second operand of the alternative fragment.

switchToLampControllerMsg2 = op2.addMessage(switchLifeline, "lampColor", lampLifeline, "switchPed", "switchPed{switchPed==2}");

Add Duration Constraints

Add a duration constraint between the two messages in the first operand of the alternative fragment.

startEvent = switchToLampControllerMsg1.End;
endEvent = switchToControllerMsg.End;
expression = "t > 12msec";
durationConstraint = diagram.addDurationConstraint(startEvent, endEvent, expression);

Open Sequence Diagram

Open the newly created sequence diagram.

open(diagram);

Input Arguments

operand — Operand

operand object

Operand, specified as a systemcomposer.interaction.Operand object.

sourceLifeline — Source lifeline

lifeline object

Source lifeline, specified as a systemcomposer.interaction.Lifeline object.

Example: "source"

sourcePort — Source port

character vector | string

Source port, specified as a character vector or string.

Data Types: char | string

destLifeline — Destination lifeline

lifeline object

Destination lifeline, specified as a systemcomposer.interaction.Lifeline object.

Example: "dest"

destPort — Destination port

character vector | string

Destination port, specified as a character vector or string.

Data Types: char | string

label — Message label

character vector | string

Message label specified as a character vector or string.

A message label has a trigger, an optional guard, and an optional constraint in the form of trigger[guard]{constraint}. trigger represents the identifying event for this message. guard represents an additional condition to determine whether the message occurs. constraint is an expression that is expected to be true when this message occurs.

• In signal events, the trigger follows this format: direction(signal [+|-] value), which specifies a triggering edge with a direction and an expression. The direction can be:

  • Rising — The edge expression is rising from strictly below zero to a value equal to or greater than zero.

  • Falling — The edge expression is falling from strictly above zero.

  • Crossing — The edge expression either rising or falling past zero.

• In message events, the trigger is in the format port, which specifies the name of the input message port and represents the arrival of a message.

• A guard in square brackets on the message label is a MATLAB^® Boolean expression that is an additional condition to determine whether the message occurs. Evaluation of the guard only occurs once the software detects a valid trigger. During execution, the sequence diagram waits to proceed to the next message until the guard expression evaluates to true.

• A constraint in curly brackets on the message label is a MATLAB Boolean expression that specifies an expected value of inputs to the destination lifeline. During execution, the evaluation of the constraint determines whether the sequence diagram shows a pass or fail for that message.

Example: "rising(sw-1)"

Data Types: char | string

existingElement — Existing element in sequence diagram after which to place new fragment

fragment object | formal gate object | message object | message event object

Existing element in sequence diagram after which to place new fragment, specified as one of these objects:

• systemcomposer.interaction.Fragment

• systemcomposer.interaction.FormalGate

• systemcomposer.interaction.Message

• systemcomposer.interaction.MessageEvent

Output Arguments

message — Added message

message object

Added message, returned as a systemcomposer.interaction.Message object.

More About

Definitions

Term	Definition	Application	More Information
Interaction	An interaction specifies how each part of a system should interact as a sequence of message exchanges.	Use interactions to describe operational system behaviors.	Describe System Behavior Using Sequence Diagrams
Sequence diagram	A sequence diagram is a visual representation of an interaction.	Use sequence diagrams to visually specify how each part of a system should interact.	Describe System Behavior Using Sequence Diagrams
Lifeline	A lifeline represents an instance of a component as a participant of an interaction.	A lifeline corresponds to a component in an architecture.	Describe Interactions with Lifelines and Messages
Message	A message represents communication between two lifelines. Messages have labels to specify the expected condition for the message to occur.	A message label has a trigger, an optional guard, and an optional constraint where a trigger represents the identifying event for this message, a guard represents an additional condition to determine whether the message occurs, and a constraint is an expression that is expected to be true when this message occurs.	Describe Interactions with Lifelines and Messages
Gate	A gate represents the root of an architectural hierarchy.	A gate allows you to describe the exchange of messages between the architecture and its environment.	Describe Interactions with Lifelines and Messages
Annotation	An annotation describes the elements of a sequence diagram.	Use annotations to provide detailed explanations of elements or workflows captured by sequence diagrams.	Annotate Sequence Diagrams with Annotations
Fragment	A fragment encloses a group of lifelines and messages within an interaction to allow for the specification of more complex patterns of interaction.	A fragment defines the type of ordering logic such as looping and alternatives. Fragments can have one or more operands.	Model Complex Interactions with Fragments and Operands
Operand	An operand is a region in a fragment, or group of messages. The condition of an operand specifies whether the messages inside the operand execute.	The condition of an operand can specify constraints on the input signal of a lifeline as a MATLAB Boolean expression.	Model Complex Interactions with Fragments and Operands
Duration constraint	A duration constraint defines a constraint on elapsed time between a start and an end occurrence.	Use duration constraints to explicitly express a constraint on the duration between a start occurrence and an end occurrence.	Specify Timing Constraints Between Message Events with Duration Constraints

Version History

Introduced in R2024b