El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia
HOME Mis cursos Finalizados
◄ Anterior
◄

Estudio de Caso 1: Aplicación en Tiempo Real

Siguiente ►
►

En este estudio de caso, desarrollaremos una aplicación en tiempo real utilizando Ada. Este ejercicio integrará varios conceptos aprendidos en los módulos anteriores, especialmente aquellos relacionados con la concurrencia, la programación en tiempo real y la sincronización.

Objetivos del Estudio de Caso

  1. Comprender los requisitos de una aplicación en tiempo real.
  2. Implementar tareas concurrentes en Ada.
  3. Utilizar objetos protegidos para la sincronización.
  4. Manejar la comunicación entre tareas.
  5. Asegurar el cumplimiento de los plazos en un sistema en tiempo real.

Descripción del Proyecto

Desarrollaremos un sistema de control de tráfico aéreo simplificado. Este sistema gestionará múltiples aviones que se aproximan a un aeropuerto, asegurando que no haya colisiones y que los aviones aterricen de manera segura y ordenada.

Requisitos del Sistema

  1. Gestión de Aviones:

    • Cada avión se representará como una tarea en Ada.
    • Los aviones deben comunicarse con la torre de control para recibir instrucciones de aterrizaje.

  2. Torre de Control:

    • La torre de control será responsable de coordinar los aterrizajes.
    • Utilizará objetos protegidos para gestionar la cola de aterrizaje y la pista.

  3. Sincronización y Comunicación:

    • Las tareas de los aviones deben sincronizarse con la torre de control.
    • La comunicación debe ser eficiente y garantizar que no haya conflictos en la pista.

Implementación

Paso 1: Definición de Tipos y Constantes

Primero, definimos los tipos y constantes necesarios para nuestro sistema.

package Traffic_Control is
   type Plane_ID is new Integer;
   Max_Planes : constant Integer := 10;
end Traffic_Control;

Paso 2: Definición de la Torre de Control

La torre de control se implementará como un objeto protegido que gestionará la cola de aterrizaje y la pista.

package body Traffic_Control is

   protected type Control_Tower is
      procedure Request_Landing (Plane : Plane_ID);
      procedure Land_Plane (Plane : Plane_ID);
      entry Get_Next_Plane (Plane : out Plane_ID);
   private
      Queue : array (1 .. Max_Planes) of Plane_ID;
      Queue_Length : Integer := 0;
      Runway_Free : Boolean := True;
   end Control_Tower;

   protected body Control_Tower is

      procedure Request_Landing (Plane : Plane_ID) is
      begin
         if Queue_Length < Max_Planes then
            Queue_Length := Queue_Length + 1;
            Queue(Queue_Length) := Plane;
         end if;
      end Request_Landing;

      procedure Land_Plane (Plane : Plane_ID) is
      begin
         Runway_Free := False;
         -- Simular el tiempo de aterrizaje
         delay 5.0;
         Runway_Free := True;
      end Land_Plane;

      entry Get_Next_Plane (Plane : out Plane_ID) when Runway_Free and then Queue_Length > 0 is
      begin
         Plane := Queue(1);
         for I in 1 .. Queue_Length - 1 loop
            Queue(I) := Queue(I + 1);
         end loop;
         Queue_Length := Queue_Length - 1;
      end Get_Next_Plane;

   end Control_Tower;

end Traffic_Control;

Paso 3: Definición de las Tareas de los Aviones

Cada avión se implementará como una tarea que solicitará permiso para aterrizar y esperará su turno.

with Ada.Text_IO; use Ada.Text_IO;
with Traffic_Control;

procedure Air_Traffic_Control is

   package TC renames Traffic_Control;

   task type Plane_Task (ID : TC.Plane_ID) is
      entry Start;
   end Plane_Task;

   task body Plane_Task is
   begin
      accept Start;
      Put_Line ("Plane " & Integer'Image(ID) & " requesting landing.");
      TC.Control_Tower.Request_Landing(ID);
      TC.Control_Tower.Get_Next_Plane(ID);
      Put_Line ("Plane " & Integer'Image(ID) & " landing.");
      TC.Control_Tower.Land_Plane(ID);
      Put_Line ("Plane " & Integer'Image(ID) & " has landed.");
   end Plane_Task;

   Planes : array (1 .. TC.Max_Planes) of Plane_Task;

begin
   for I in 1 .. TC.Max_Planes loop
      Planes(I).Start;
   end loop;
end Air_Traffic_Control;

Paso 4: Ejecución y Pruebas

Compilamos y ejecutamos el programa para observar cómo los aviones solicitan aterrizaje, esperan su turno y aterrizan de manera ordenada.

$ gnatmake air_traffic_control.adb
$ ./air_traffic_control

Salida Esperada

Plane  1 requesting landing.
Plane  2 requesting landing.
Plane  3 requesting landing.
Plane  4 requesting landing.
Plane  5 requesting landing.
Plane  6 requesting landing.
Plane  7 requesting landing.
Plane  8 requesting landing.
Plane  9 requesting landing.
Plane 10 requesting landing.
Plane  1 landing.
Plane  1 has landed.
Plane  2 landing.
Plane  2 has landed.
...

Conclusión

En este estudio de caso, hemos desarrollado una aplicación en tiempo real utilizando Ada. Hemos implementado tareas concurrentes para representar aviones y un objeto protegido para gestionar la torre de control. Este ejercicio ha demostrado cómo Ada facilita la programación en tiempo real y la sincronización entre tareas.

Resumen de Conceptos Clave

  • Tareas y Concurrencia: Utilizamos tareas para representar aviones que operan de manera concurrente.
  • Objetos Protegidos: Implementamos la torre de control como un objeto protegido para gestionar la sincronización y la comunicación.
  • Sincronización y Comunicación: Aseguramos que los aviones aterricen de manera ordenada utilizando entradas protegidas y procedimientos.

Este estudio de caso prepara al estudiante para abordar aplicaciones más complejas en tiempo real y sistemas concurrentes, consolidando los conocimientos adquiridos en los módulos anteriores.

◄ Anterior
◄
Siguiente ►
►
El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia
© Copyright 2024. Todos los derechos reservados