Le langage Pascal


précédentsommairesuivant

Ensembles

Un ensemble est une "collection" d'éléments de même type (cf cours maths 6ème). Supposons vouloir représenter des vendeurs et leurs domaines d'action.

Le type ensemble est défini par SET OF :

 
Sélectionnez
TYPE produits = (velos,motos,autos,accessoires);
VAR vendeur1, vendeur2 : SET OF produits;

On "remplit" un ensemble en donnant ses éléments entre crochets :

 
Sélectionnez
vendeur1 := [velos,motos];
vendeur2 := [motos,accessoires];

L'ensemble vide est : [].

On peut faire les opérations suivantes :

  • Union : vendeur1 + vendeur2 = [velos,motos,accessoires]
  • Intersection : vendeur1 * vendeur2 = [motos]
  • Complément : vendeur1 - vendeur2 = [velos] vendeur2 - vendeur1 = [accessoires]

Les tests booléens possibles sont : = , <> , <= (inclus) , >= (contenant).

On teste l'appartenance d'un élément par IN : si X vaut motos, alors X IN VENDEUR1 et [motos] <= VENDEUR1 sont équivalents (IN compare un élément et un ensemble, alors que <= compare deux ensembles.

Remarque : En général, on ne pense pas à utiliser lesensembles (le prof de maths aurait-il oublié de nous dire à quoi ça sert ?), et l'on s'embrouille dans des programmes complexes. Voici par exemple, des idées pour programmer facilement un automatisme défini par plusieurs Grafcet complexes ([xx] se lisant "ensemble des xx") :

 
Sélectionnez
[étapes actives] := [étapes initiales]

Pour chaque transition :

 
Sélectionnez
si [étapes immédiatement précédentes] <= [étapes actives]
et [capteurs nécessaires] <= [capteurs]
alors [étapes actives] := [étapes actives] - [précédentes] + [suivantes]
activer [sorties] en fonction [étapes actives] et boucler

On peut trouver un exemple détaillé dans mon document sur la mise en oeuvre du Grafcet.

 
Sélectionnez
{ Ce programme correspond au GRAFCET 2 "mise en oeuvre du grafcet sur automate" }

PROGRAM grafcet_2 (input,output);

CONST
  adresse_port = $330;

TYPE 
  liste_capteurs = (e1,e2,e3);
  ensemble_capteurs = SET OF liste_capteurs;
  liste_actions = (sortie1,sortie2,sortie3);
  ensemble_actions = SET OF liste_actions;

VAR { pour le programme principal }
  etape : array [1..4] of boolean;
  transition : array [1..4] of boolean;
  capteurs : ensemble_capteurs;
  sorties : ensemble_actions;
  i : integer;

PROCEDURE lire_capteurs (VAR etat_actuel_capteurs : ensemble_capteurs);
{ cette procédure lit les capteurs et rend un ensemble contenant les
  capteurs à 1. Cette procédure dépend du type de machine }
var { locale } etat : record 
                        case integer of
                          1 : (compatible_port : byte);
                          2 : (compatible_ensemble : ensemble_capteurs)
                      end;
begin
  etat.compatible_port := port[adresse_port];
  etat_actuel_capteurs := etat.compatible_ensemble
end;

PROCEDURE affecte_sorties (etat_sorties : ensemble_actions);
{ affecte les sorties }
var etat : record 
             case integer of
               1 : (compatible_port:byte);
               2 : (compatible_ensemble:ensemble_actions)
             end;
begin
  etat.compatible_ensemble := etat_sorties;
  port[adresse_port] := etat.compatible_port
end;

BEGIN { programme principal }
  {initialisation}
  sorties := []; { ensemble vide }
  affecte_sorties(sorties);
  etape[1] := true;
  for i := 2 to 4 do etape[i] := false;
  repeat
    lecture des entrées}
    lire_capteurs(capteurs);
    {-----------------------------------------------
    write('capteurs : ');
    if e1 in capteurs then write('E1);
    if e2 in capteurs then write('E2 ');
    if e3 in capteurs then write('E3 ');
    writeln;
    ------------------------------------------------}
    { conditions d'évolution }
    transition[1] := etape[1] and (e1 in capteurs);
    transition[2] := etape[2] and etape[3] and ([e2,e3] * capteurs = []); { intersection vide }
    transition[3] := etape[3] and (e2 in capteurs) and not (e3 in capteurs);
    transition[4] := etape[4] and not (c2 in capteurs);
    { désativation }
    if transition[1] then etape[1] := false;
    if transition[2] then begin
      etape[2] := false;
      etape[3] := false
    end;
    if transition[3] then etape[3] := false;
    if transition[4] then etape[4] := false;
    { activation }
    if transition[1] then begin
      etape[2] := true;
      etape[3] := true
    end;
    if transition[2] then etape[1] := true;
    if transition[3] then etape[4] := true;
    if transition[4] then etape[3] := true;
    { affectation sorties }
    {-----------------------------------------------
    write('Etapes : ');
    for i := 1 to 4 do if etape[i] then write(i,' ');
    writeln;
    ------------------------------------------------}
    sorties := [];
    if etape[2] then sorties := sorties + [sortie1];
    if etape[3] then sorties := sorties + [sortie2];
    if etape[4] then sorties := sorties + [sortie3];
    affecte_sorties(sorties);
  UNTIL false; { boucler jusqu'à extinction }
END.

précédentsommairesuivant

Vous avez aimé ce tutoriel ? Alors partagez-le en cliquant sur les boutons suivants : Viadeo Twitter Facebook Share on Google+   

Utilisation de ce document libre pour tout usage personnel. Utilisation autorisée pour tout usage public non commercial, à condition de citer son auteur (Patrick Trau, IPST, Université Louis Pasteur Strasbourg) et de me signaler tout usage intensif. Utilisation commerciale interdite sans accord écrit de ma part.