Le langage Pascal

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.