The Project | About Us | Contribute | Donations | License
HOME My courses Completed
◄ Previous
◄

Real-Time Systems

Next ►
►

In this section, we will explore the concepts and practical aspects of real-time systems in Ada. Real-time systems are critical in applications where timely and predictable responses are essential, such as in embedded systems, aerospace, and industrial automation.

Key Concepts

  1. Real-Time Systems: Systems that must respond to inputs or events within a strict time constraint.
  2. Hard Real-Time Systems: Systems where missing a deadline can lead to catastrophic consequences.
  3. Soft Real-Time Systems: Systems where deadlines are important but not critical, and occasional deadline misses are tolerable.
  4. Determinism: The ability of a system to produce predictable and repeatable behavior.
  5. Latency: The time taken to respond to an event.
  6. Jitter: The variability in response time.

Real-Time Features in Ada

Ada provides several features to support real-time programming:

  1. Tasking: Ada's concurrency model allows the creation of tasks that can run in parallel.
  2. Protected Objects: Mechanisms to ensure safe access to shared resources.
  3. Real-Time Scheduling: Ada supports various scheduling policies to manage task execution.
  4. Timing Events: Ada provides facilities to handle timing events and delays.

Practical Example: Real-Time Task Scheduling

Let's create a simple real-time system in Ada that demonstrates task scheduling and timing control.

Step 1: Define the Tasks

We will define two tasks: Sensor_Task and Control_Task. The Sensor_Task will simulate reading sensor data at regular intervals, and the Control_Task will process this data.

with Ada.Text_IO; use Ada.Text_IO;
with Ada.Real_Time; use Ada.Real_Time;

procedure Real_Time_System is

   -- Define a task type for the sensor
   task type Sensor_Task is
      entry Start;
   end Sensor_Task;

   -- Define a task type for the control
   task type Control_Task is
      entry Start;
   end Control_Task;

   -- Declare task objects
   Sensor : Sensor_Task;
   Control : Control_Task;

   -- Implementation of the Sensor_Task
   task body Sensor_Task is
      Next_Time : Time := Clock;
      Period : constant Time_Span := Milliseconds(100);
   begin
      accept Start;
      loop
         -- Simulate sensor data reading
         Put_Line("Sensor Task: Reading sensor data...");
         -- Wait for the next period
         Next_Time := Next_Time + Period;
         delay until Next_Time;
      end loop;
   end Sensor_Task;

   -- Implementation of the Control_Task
   task body Control_Task is
      Next_Time : Time := Clock;
      Period : constant Time_Span := Milliseconds(200);
   begin
      accept Start;
      loop
         -- Simulate control processing
         Put_Line("Control Task: Processing data...");
         -- Wait for the next period
         Next_Time := Next_Time + Period;
         delay until Next_Time;
      end loop;
   end Control_Task;

begin
   -- Start the tasks
   Sensor.Start;
   Control.Start;
   -- Main program loop
   loop
      delay 1.0; -- Main program does nothing, just waits
   end loop;

end Real_Time_System;

Explanation

  • Task Types: We define two task types, Sensor_Task and Control_Task, each with an entry point Start.
  • Task Bodies: Each task has a loop that simulates its respective operations and uses delay until to wait for the next period.
  • Timing Control: We use Ada.Real_Time.Clock to get the current time and Milliseconds to define the period for each task.
  • Task Start: The tasks are started by calling their Start entry.

Step 2: Compile and Run

To compile and run the program, follow these steps:

  1. Save the code in a file named real_time_system.adb.
  2. Compile the program using the GNAT compiler: 
    gnatmake real_time_system.adb
  3. Run the executable: 
    ./real_time_system

Expected Output

Sensor Task: Reading sensor data...
Control Task: Processing data...
Sensor Task: Reading sensor data...
Sensor Task: Reading sensor data...
Control Task: Processing data...
...

Practical Exercise

Exercise: Implement a Real-Time Logger

Create a real-time system with three tasks: Sensor_Task, Control_Task, and Logger_Task. The Logger_Task should log messages from the other two tasks at regular intervals.

Solution

with Ada.Text_IO; use Ada.Text_IO;
with Ada.Real_Time; use Ada.Real_Time;

procedure Real_Time_Logger is

   -- Define a task type for the sensor
   task type Sensor_Task is
      entry Start;
   end Sensor_Task;

   -- Define a task type for the control
   task type Control_Task is
      entry Start;
   end Control_Task;

   -- Define a task type for the logger
   task type Logger_Task is
      entry Start;
   end Logger_Task;

   -- Declare task objects
   Sensor : Sensor_Task;
   Control : Control_Task;
   Logger : Logger_Task;

   -- Shared log message
   Log_Message : String := (1 .. 100 => ' ');

   -- Implementation of the Sensor_Task
   task body Sensor_Task is
      Next_Time : Time := Clock;
      Period : constant Time_Span := Milliseconds(100);
   begin
      accept Start;
      loop
         -- Simulate sensor data reading
         Log_Message := "Sensor Task: Reading sensor data...";
         -- Wait for the next period
         Next_Time := Next_Time + Period;
         delay until Next_Time;
      end loop;
   end Sensor_Task;

   -- Implementation of the Control_Task
   task body Control_Task is
      Next_Time : Time := Clock;
      Period : constant Time_Span := Milliseconds(200);
   begin
      accept Start;
      loop
         -- Simulate control processing
         Log_Message := "Control Task: Processing data...";
         -- Wait for the next period
         Next_Time := Next_Time + Period;
         delay until Next_Time;
      end loop;
   end Control_Task;

   -- Implementation of the Logger_Task
   task body Logger_Task is
      Next_Time : Time := Clock;
      Period : constant Time_Span := Milliseconds(150);
   begin
      accept Start;
      loop
         -- Log the message
         Put_Line(Log_Message);
         -- Wait for the next period
         Next_Time := Next_Time + Period;
         delay until Next_Time;
      end loop;
   end Logger_Task;

begin
   -- Start the tasks
   Sensor.Start;
   Control.Start;
   Logger.Start;
   -- Main program loop
   loop
      delay 1.0; -- Main program does nothing, just waits
   end loop;

end Real_Time_Logger;

Explanation

  • Logger_Task: This task logs the shared Log_Message at regular intervals.
  • Shared Log Message: The Log_Message variable is shared among tasks to store the latest message.
  • Task Coordination: Each task updates the Log_Message before waiting for the next period.

Summary

In this section, we covered the basics of real-time systems in Ada, including key concepts and practical examples. We demonstrated how to create tasks, control their timing, and implement a simple real-time system. Understanding these concepts is crucial for developing reliable and predictable real-time applications in Ada.

Next, we will explore synchronization and communication mechanisms in real-time systems.

◄ Previous
◄
Next ►
►
The Project | About Us | Contribute | Donations | License
© Copyright 2024. All rights reserved