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

Case Study 1: Real-Time Application

Next ►
►

In this case study, we will explore the development of a real-time application using Ada. Real-time systems are critical in various domains such as aerospace, automotive, and industrial automation, where timely and predictable responses are essential.

Objectives

  • Understand the requirements of a real-time system.
  • Learn how to design and implement a real-time application in Ada.
  • Explore the use of Ada's concurrency features to manage real-time tasks.
  • Implement synchronization and communication between tasks.

Requirements

For this case study, we will develop a simplified real-time monitoring system for an industrial plant. The system will:

  1. Monitor temperature and pressure sensors.
  2. Trigger alarms if the readings exceed predefined thresholds.
  3. Log sensor data to a file for later analysis.
  4. Ensure that sensor readings and alarm checks are performed at regular intervals.

System Design

Components

  1. Sensor Reading Task: Periodically reads temperature and pressure sensor data.
  2. Alarm Task: Checks sensor data against thresholds and triggers alarms if necessary.
  3. Logger Task: Logs sensor data to a file.

Task Synchronization

  • Protected Object: Used to store sensor data and ensure safe access by multiple tasks.
  • Task Priorities: Assign priorities to ensure timely execution of critical tasks.

Implementation

Step 1: Define Sensor Data and Thresholds

package Sensor_Data is
   type Sensor_Reading is record
      Temperature : Float;
      Pressure    : Float;
   end record;

   Temperature_Threshold : constant Float := 75.0;
   Pressure_Threshold    : constant Float := 150.0;
end Sensor_Data;

Step 2: Create a Protected Object for Sensor Data

package body Sensor_Data is
   protected Sensor_Store is
      procedure Update(Temp : Float; Press : Float);
      procedure Get(Temp : out Float; Press : out Float);
   private
      Current_Reading : Sensor_Reading := (Temperature => 0.0, Pressure => 0.0);
   end Sensor_Store;

   protected body Sensor_Store is
      procedure Update(Temp : Float; Press : Float) is
      begin
         Current_Reading.Temperature := Temp;
         Current_Reading.Pressure := Press;
      end Update;

      procedure Get(Temp : out Float; Press : out Float) is
      begin
         Temp := Current_Reading.Temperature;
         Press := Current_Reading.Pressure;
      end Get;
   end Sensor_Store;
end Sensor_Data;

Step 3: Implement the Sensor Reading Task

with Ada.Real_Time; use Ada.Real_Time;
with Sensor_Data;

task Sensor_Reader is
   period : constant Time_Span := Milliseconds(1000);
end Sensor_Reader;

task body Sensor_Reader is
   Next_Time : Time := Clock;
   Temp      : Float;
   Press     : Float;
begin
   loop
      -- Simulate sensor reading
      Temp := Float'Random * 100.0;
      Press := Float'Random * 200.0;

      -- Update sensor data
      Sensor_Data.Sensor_Store.Update(Temp, Press);

      -- Wait until the next period
      Next_Time := Next_Time + period;
      delay until Next_Time;
   end loop;
end Sensor_Reader;

Step 4: Implement the Alarm Task

with Ada.Text_IO; use Ada.Text_IO;
with Sensor_Data;

task Alarm_Checker is
   period : constant Time_Span := Milliseconds(500);
end Alarm_Checker;

task body Alarm_Checker is
   Next_Time : Time := Clock;
   Temp      : Float;
   Press     : Float;
begin
   loop
      -- Get the latest sensor data
      Sensor_Data.Sensor_Store.Get(Temp, Press);

      -- Check for alarms
      if Temp > Sensor_Data.Temperature_Threshold then
         Put_Line("Temperature Alarm: " & Float'Image(Temp));
      end if;

      if Press > Sensor_Data.Pressure_Threshold then
         Put_Line("Pressure Alarm: " & Float'Image(Press));
      end if;

      -- Wait until the next period
      Next_Time := Next_Time + period;
      delay until Next_Time;
   end loop;
end Alarm_Checker;

Step 5: Implement the Logger Task

with Ada.Text_IO; use Ada.Text_IO;
with Sensor_Data;

task Logger is
   period : constant Time_Span := Milliseconds(2000);
end Logger;

task body Logger is
   Next_Time : Time := Clock;
   Temp      : Float;
   Press     : Float;
   Log_File  : File_Type;
begin
   Create(Log_File, Out_File, "sensor_log.txt");

   loop
      -- Get the latest sensor data
      Sensor_Data.Sensor_Store.Get(Temp, Press);

      -- Log the data
      Put_Line(Log_File, "Temperature: " & Float'Image(Temp) & ", Pressure: " & Float'Image(Press));

      -- Wait until the next period
      Next_Time := Next_Time + period;
      delay until Next_Time;
   end loop;

   Close(Log_File);
end Logger;

Summary

In this case study, we developed a real-time monitoring system using Ada. We covered:

  • Defining sensor data and thresholds.
  • Creating a protected object for safe data access.
  • Implementing periodic tasks for sensor reading, alarm checking, and logging.
  • Using Ada's concurrency features to manage real-time tasks.

This example demonstrates how Ada's strong typing, concurrency, and real-time capabilities make it an excellent choice for developing reliable and predictable real-time systems.

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