Real-time Embedded Systems Ada Program Example

Learn about real-time embedded systems and see an example program written in Ada. This program demonstrates how to use the Ada.Real_Time .

This program creates two tasks: a timer task and a main task. The timer task is responsible for performing some time-critical tasks every 10 milliseconds, while the main task performs the core tasks of the program and has a deadline of 50 milliseconds.

The program uses the Ada. Real_Time package to work with time and schedules the tasks to run at specific times using the delay until statement.

The output of this program is a message that will be printed to the console if the main task misses its deadline. This is important in a real-time system, as missing deadlines can lead to system failure or other serious consequences.

Program:-

with System;
with Ada.Real_Time; use Ada.Real_Time;

procedure Real_Time_Embedded is
   Task_Deadline : constant Time_Span := Milliseconds (50);
   Next_Deadline : Time;
   Last_Time : Time := Clock;
   
   task Timer is
      pragma Priority (10);
      period : constant Time_Span := Milliseconds (10);
      Next_Call : Time := Clock + period;
   begin
      loop
         delay until Next_Call;
         Next_Call := Next_Call + period;
         -- perform timer-related tasks here
      end loop;
   end Timer;
   
   task Main is
      pragma Priority (5);
   begin
      loop
         Next_Deadline := Next_Deadline + Task_Deadline;
         -- perform main program tasks here
         
         -- Check if the task met the deadline
         if Next_Deadline < Clock then
            Put_Line("Deadline missed!");
         end if;
         
         Last_Time := Clock;
         delay until Next_Deadline;
      end loop;
   end Main;
   
begin
   Next_Deadline := Last_Time + Task_Deadline;
   null;
end Real_Time_Embedded;


output


Deadline missed!
Deadline missed!
Deadline missed!


This program is an example of a real-time embedded system written in Ada. It consists of two tasks: a timer task and a main task. The timer task is responsible for performing some time-critical tasks every 10 milliseconds, while the main task performs the core tasks of the program and has a deadline of 50 milliseconds.

The program uses the Ada.Real_Time package to work with time and schedules the tasks to run at specific times using the delay until statement.

The output of this program is a message that will be printed to the console if the main task misses its deadline. This is important in a real-time system, as missing deadlines can lead to system failure or other serious consequences.

Here is an example of what the output might look like if the main task misses its deadline:

This output indicates that the main task was not able to complete its work within the allotted time and missed its deadline three times in a row. Depending on the specific application, this could be a serious problem and may require further investigation to determine the root cause of the issue.

Share on Facebook

Tweet

Follow us

Save