El Projecte | Sobre nosaltres | Contribuir | Donacions | Llicència
HOME Els meus cursos Finalitzats
◄ Anterior
◄

Sistemes en Temps Real

Següent ►
►

Els sistemes en temps real són aquells que requereixen una resposta dins d'un temps determinat. Aquests sistemes són crucials en aplicacions on el retard en la resposta pot tenir conseqüències greus, com en el control de processos industrials, sistemes de navegació aèria, aplicacions mèdiques, entre d'altres.

Objectius del Tema

  • Entendre els conceptes bàsics dels sistemes en temps real.
  • Aprendre a utilitzar les capacitats d'Ada per a la programació en temps real.
  • Implementar tasques en temps real utilitzant Ada.

Conceptes Bàsics

Definició de Sistemes en Temps Real

Un sistema en temps real és un sistema informàtic que ha de complir amb restriccions de temps estrictes. Aquests sistemes es classifiquen en dos tipus principals:

  • Sistemes en temps real durs: On el no compliment dels terminis pot resultar en una fallada catastròfica.
  • Sistemes en temps real tous: On el no compliment dels terminis pot degradar el rendiment però no resulta en una fallada catastròfica.

Característiques dels Sistemes en Temps Real

  • Determinisme: Capacitat de garantir que les operacions es compleixen dins dels terminis establerts.
  • Previsibilitat: Capacitat de predir el comportament del sistema sota diferents condicions de càrrega.
  • Fiabilitat: Capacitat de funcionar correctament durant períodes prolongats.

Programació en Temps Real amb Ada

Ada és un llenguatge de programació especialment dissenyat per a sistemes en temps real i sistemes empotrats. Proporciona diverses característiques que faciliten la programació en temps real, com ara tasques, objectes protegits i sincronització.

Tasques en Ada

Les tasques en Ada són unitats de concurrència que poden executar-se en paral·lel. Cada tasca té el seu propi fil d'execució.

Exemple de Tasca en Ada

with Ada.Text_IO; use Ada.Text_IO;

procedure Real_Time_Task is
   task type Simple_Task is
      entry Start;
   end Simple_Task;

   task body Simple_Task is
   begin
      accept Start do
         Put_Line("Task Started");
      end Start;
      -- Simulació de treball en temps real
      delay 1.0;
      Put_Line("Task Completed");
   end Simple_Task;

   T : Simple_Task;
begin
   T.Start;
end Real_Time_Task;

Explicació del Codi:

  • Es defineix una tasca Simple_Task amb una entrada Start.
  • El cos de la tasca accepta l'entrada Start, imprimeix un missatge, simula treball amb un retard (delay 1.0), i després imprimeix un altre missatge.
  • La tasca es crea i es crida l'entrada Start.

Objectes Protegits

Els objectes protegits en Ada s'utilitzen per a la sincronització i la comunicació segura entre tasques.

Exemple d'Objecte Protegit

with Ada.Text_IO; use Ada.Text_IO;

procedure Protected_Object_Example is
   protected type Shared_Data is
      procedure Write (Value : Integer);
      function Read return Integer;
   private
      Data : Integer := 0;
   end Shared_Data;

   protected body Shared_Data is
      procedure Write (Value : Integer) is
      begin
         Data := Value;
      end Write;

      function Read return Integer is
      begin
         return Data;
      end Read;
   end Shared_Data;

   Shared : Shared_Data;
begin
   Shared.Write(10);
   Put_Line("Shared Data: " & Integer'Image(Shared.Read));
end Protected_Object_Example;

Explicació del Codi:

  • Es defineix un tipus protegit Shared_Data amb una variable privada Data.
  • Es defineixen una funció Read i una procedura Write per accedir i modificar Data de manera segura.
  • Es crea una instància de Shared_Data i es demostra l'ús de les operacions Write i Read.

Exercicis Pràctics

Exercici 1: Crear una Tasca en Temps Real

Crea una tasca que simuli un sensor de temperatura que llegeix dades cada 2 segons i imprimeix la temperatura llegida.

Solució

with Ada.Text_IO; use Ada.Text_IO;

procedure Temperature_Sensor is
   task type Sensor_Task is
      entry Start;
   end Sensor_Task;

   task body Sensor_Task is
   begin
      accept Start;
      loop
         -- Simulació de lectura de temperatura
         Put_Line("Temperature: " & Integer'Image(25 + Integer'Random));
         delay 2.0;
      end loop;
   end Sensor_Task;

   Sensor : Sensor_Task;
begin
   Sensor.Start;
end Temperature_Sensor;

Exercici 2: Utilitzar un Objecte Protegit per Compartir Dades

Crea un objecte protegit que emmagatzemi un comptador. Implementa tasques que incrementin i llegeixin el valor del comptador.

Solució

with Ada.Text_IO; use Ada.Text_IO;

procedure Counter_Example is
   protected type Counter is
      procedure Increment;
      function Value return Integer;
   private
      Count : Integer := 0;
   end Counter;

   protected body Counter is
      procedure Increment is
      begin
         Count := Count + 1;
      end Increment;

      function Value return Integer is
      begin
         return Count;
      end Value;
   end Counter;

   Shared_Counter : Counter;

   task type Increment_Task is
   end Increment_Task;

   task body Increment_Task is
   begin
      loop
         Shared_Counter.Increment;
         delay 1.0;
      end loop;
   end Increment_Task;

   task type Read_Task is
   end Read_Task;

   task body Read_Task is
   begin
      loop
         Put_Line("Counter Value: " & Integer'Image(Shared_Counter.Value));
         delay 2.0;
      end loop;
   end Read_Task;

   Incrementer : Increment_Task;
   Reader : Read_Task;
begin
   null;
end Counter_Example;

Conclusió

En aquesta secció, hem explorat els conceptes bàsics dels sistemes en temps real i com Ada proporciona eines per implementar aquests sistemes. Hem après a crear tasques i objectes protegits per gestionar la concurrència i la sincronització. Els exercicis pràctics han reforçat aquests conceptes amb exemples concrets. En el següent tema, explorarem la sincronització i la comunicació en més detall.

◄ Anterior
◄
Següent ►
►
El Projecte | Sobre nosaltres | Contribuir | Donacions | Llicència
© Copyright 2024. Tots els drets reservats