View source for Model-based SW Engineering of Real time systems: a methodology

THIS SECTION IS WORK IN PROGRESS
= Introduction =

Model-based Software Engineering is based on the application of methods and tools to support the production of software systems.

In this chapter we outline a methodology to support the embedded software development lifecycle using formal description techniques based on modeling languages and automation.
In this approach, the constructs used are based on non-ambiguous definitions, meaning that the reading rules are the same for each reader.

At a glance the methodology relies on the following languages:

1. Message Sequence Charts ('''MSC''') and AADL for the system requirements analysis and architectural work, and test specifications ;

2. The Specification And Description Language ('''SDL''') for the system behavior

3. The Abstract Syntax Notation One ('''ASN.1''') for the data and ICD definitions


The TASTE framework is used to illustrate the methodology using concrete tools; the aim to provide a systematic and efficient approach to software development, ensuring the quality, reliability and maintainability of the software. The modeling-based methodology offers a visual representation of the software behavior and architecture, reducing the risk of errors and facilitating the communication between stakeholders.

The methodology can be outlined as follows:

1. '''Requirements Analysis''': Gather and analyze system requirements ; understand and reformulate operational scenarios.

2. '''Model Design''': use SDL to specify the system behavior with communicating state machines, and ASN.1 to define data structures and protocols.

3. '''Model Validation''': Validate the models using simulation and testing tools to ensure they accurately reflect the system requirements.

4. '''Code Generation''': Use the TASTE framework to generate code from the models, ensuring that the generated code adheres to the standards and specifications.

5. '''Integration and Testing''': Integrate the generated code with other system components and perform testing to verify that the system works as expected.

6. '''Deployment''': Deploy the system and perform any necessary post-deployment activities, such as maintenance and updates.

7. '''Maintenance''': Regularly monitor and maintain the system to ensure it continues to function correctly.

This methodology provides a structured approach to software development, using models as the basis for design, verification, and code generation, ensuring that the end result is a high-quality and reliable system.

== Requirement analysis ==

The first step in this methodology is Requirements Analysis. In this step, the main objective is to gather and analyze the system requirements and identify the communication patterns and protocols involved in the system. This step involves the following sub-steps:

1. '''Check the validity and applicability of the system requirements'''. This involves analyzing the functional and non-functional requirements of the system, including performance, reliability, and security requirements.

2. '''Identify communication patterns''': Analyze the system requirements and identify from the system architecture and operational modes the communication patterns between different system components. This will help to determine the protocols that need to be used for communication.

3. If needed, '''reformulate behavioural requirements''' with a more formal notation to remove any form of ambiguity: this will be the baseline for the creation of executable software technical specifications.

4. '''Validate requirements''': Validate the requirements and protocols with stakeholders and subject matter experts to ensure they are accurate and complete.

This step is critical as it sets the foundation for the rest of the development process. It ensures that the development team has a clear understanding of the system requirements and the communication patterns involved, allowing them to design the system models accordingly. This step helps to avoid misunderstandings and reduces the risk of errors and rework later in the development process.