SCL 118
Gestion_circuits By jledun on 22nd October 2024 10:44:01 AM
  1. i := 0;
  2. j := 0;
  3. k := 0;
  4. l := 0;
  5. x := 0;
  6.  
  7. Synthese_Visu_invisible := FALSE;
  8.  
  9. (* SELECTION CIRCUIT *)
  10. FOR i:=1 TO bitDivers.Nombre_Circuit DO
  11.  
  12.         (* contrôle circuit isolé ou non *)
  13.         IF Circuits[i].Isoler THEN
  14.                 Synthese_Visu_invisible := TRUE;
  15.         END_IF;
  16.  
  17.         (* Contrôle circuits Aspiration *)
  18.         Aspi_ok := TRUE;
  19.         IF bitDivers.Circuit_Asp_General > 0 THEN
  20.                 IF Circuits[bitDivers.Circuit_Asp_General].Graphe <> 30 THEN
  21.                         Aspi_ok := FALSE;
  22.                 END_IF;
  23.         END_IF;
  24.         FOR j:=0 TO 9 DO
  25.                 IF Circuits[i].Circuit_Aspi[j] > 0 THEN
  26.                         IF Circuits[Circuits[i].Circuit_Aspi[j]].Graphe <> 30 THEN
  27.                                 Aspi_ok := FALSE;
  28.                                 EXIT;
  29.                         END_IF;
  30.                 END_IF;
  31.         END_FOR;
  32.  
  33.         (* Lancement des circuits aspiration si un Circuit le demande *)
  34.         IF i < bitDivers.Premier_Circuit_Asp THEN
  35.                 IF Circuits[i].Graphe >= 19 THEN
  36.                         IF bitDivers.Circuit_Asp_General > 0 THEN
  37.                                 Circuits[bitDivers.Circuit_Asp_General].Dde_Ext := 1;
  38.                         END_IF;
  39.                         FOR j:=0 TO 9 DO
  40.                                 IF Circuits[i].Circuit_Aspi[j] > 0 THEN
  41.                                         Circuits[Circuits[i].Circuit_Aspi[j]].Dde_Ext := 1;
  42.                                 END_IF;
  43.                         END_FOR;
  44.                 END_IF;
  45.         END_IF;
  46.  
  47.         (*Bouton Attente ou Arret sur NB*)
  48.         IF Circuits[i].Attente_Cycle_NB = 1 THEN
  49.                 Circuits[i].Arret_Cycle_NB := 0;
  50.         END_IF;
  51.         IF Circuits[i].Arret_Cycle_NB = 1 THEN
  52.                 Circuits[i].Attente_Cycle_NB := 0;
  53.         END_IF;
  54.  
  55.         (* ARRET SUR ARRET D'URGENCE *)
  56.         IF Circuits[i].Graphe <> 0 AND NOT SYNT_ATU THEN
  57.                 Circuits[i].Graphe := 200;
  58.         END_IF;
  59.  
  60.         (* GESTION DES DEMANDES EXTERIEURES *)
  61.         IF Circuits[i].Dde_Ext = 2 AND (Circuits[i].Graphe = 20 OR Circuits[i].Graphe = 30) THEN
  62.                 Circuits[i].Arret := 1;
  63.         END_IF;
  64.  
  65.         IF Circuits[i].Dde_Ext = 1 AND (Circuits[i].Graphe = 0 OR Circuits[i].Graphe = 100) THEN
  66.                 Circuits[i].Marche := 1;
  67.         END_IF;
  68.  
  69.         (* MARCHE *)
  70.         IF Circuits[i].Marche OR Circuits[i].Graphe = 0 AND (Circuits[i].Visualisation OR Circuits[i].Isoler) THEN
  71.                 Circuits[i].Marche := 0;
  72.  
  73.                 IF Circuits[i].Graphe = 18 OR Circuits[i].Graphe = 16 THEN
  74.                         Circuits[i].Graphe := 15;
  75.  
  76.                 ELSIF Circuits[i].Graphe = 100 THEN
  77.                         Circuits[i].Graphe := 20;
  78.  
  79.                 ELSE
  80.                         Circuits[i].Graphe := 5;
  81.                 END_IF;
  82.                 Circuits[i].Res6 := 0;
  83.                 Circuits[i].Res7 := 0;
  84.                 Circuits[i].NH := 0;
  85.                 Circuits[i].NB := 0;
  86.                 Circuits[i].Arret_SPV := 0;
  87.         END_IF;
  88.  
  89.         (* ARRET *)
  90.         IF Circuits[i].Arret THEN
  91.                 Circuits[i].Arret_SPV := 1;
  92.                 Circuits[i].Arret := 0;
  93.                 IF Circuits[i].Graphe < 20 THEN
  94.                         Circuits[i].Graphe := 0;
  95.  
  96.                 ELSIF   Circuits[i].Graphe = 100 THEN
  97.                         Circuits[i].Graphe := 200;
  98.  
  99.                 ELSE
  100.                         Circuits[i].Graphe := 100;
  101.                 END_IF;
  102.         END_IF;
  103.  
  104.         (* GRAFCET DE GESTION DU CIRCUIT *)
  105.         (* GRAFCET DE GESTION DU CIRCUIT *)
  106.         (* GRAFCET DE GESTION DU CIRCUIT *)
  107.         CASE Circuits[i].graphe OF
  108.                 0:      (* CIRCUIT A L'ARRET *)
  109.                         Circuits[i].Elem_Coupe := 99;
  110.  
  111.                 5:      (* CONTROLE DES ELEMENTS DU CIRCUIT *)
  112.                         (* On initialise les circuits aspirations *)
  113.                         FOR j:=0 TO 9 DO
  114.                                 Circuits[i].Circuit_Aspi[j] := 0;
  115.                         END_FOR;
  116.  
  117.                         use := FALSE;
  118.                         (* On vérifie qu'un élément du circuit n'est pas déjà utilisé 5 fois *)
  119.                         FOR j := 0 TO bitDivers.Nombre_Element DO
  120.                                 nombreUtilisation := 0;
  121.                                 IF Circuits[i].Elements[j] <> 0 THEN
  122.  
  123.                                         (* COMPTAGE D'UTILISATION DE L'ELEMENT D'ORIGINE DANS LE MEME CIRCUIT *)
  124.                                         IF Circuits[i].Elements[j] = Circuits[i].Elements[0] THEN
  125.                                                 nombreUtilisation := nombreUtilisation +1;
  126.                                         END_IF;
  127.  
  128.                                         (* RECHERCHE DE L'ELEMENT SELECTIONNE DANS LES AUTRES CIRCUITS ACTUELLEMENT EN COURS *)
  129.                                         FOR k := 1 TO bitDivers.Nombre_Circuit DO
  130.                                                 IF i <> k AND Circuits[k].Graphe > 0 AND Circuits[i].Graphe > 0 THEN
  131.                                                         FOR l := 0 TO bitDivers.Nombre_Element DO
  132.                                                                 IF Circuits[k].Elements[l] <> 0 AND Circuits[i].Elements[j] = Circuits[k].Elements[l] THEN
  133.                                                                         nombreUtilisation := nombreUtilisation +1;
  134.                                                                 END_IF;
  135.                                                         END_FOR;
  136.                                                 END_IF;
  137.                                         END_FOR;
  138.                                 END_IF;
  139.                                 IF nombreUtilisation > 5 THEN
  140.                                         use := TRUE;
  141.                                         EXIT;
  142.                                 END_IF;
  143.                         END_FOR;
  144.  
  145.                         IF NOT use THEN
  146.                                 (* i circuit sélectionné *)
  147.                                 (* j element sélectionné *)
  148.                                 FOR j:=0 TO bitDivers.Nombre_Element DO
  149.                                         (* SI ELEMENT NUL, ON PASSE A L'ELEMENT SUIVANT *)
  150.                                         IF Circuits[i].Elements[j] <> 0 THEN
  151.                                                 (* k circuit à observer *)
  152.                                                 FOR k:=1 TO bitDivers.Nombre_Circuit DO
  153.                                                         (* SI CIRCUIT OBSERVE = CIRCUIT SELECTIONNE OU LE CIRCUIT OBSERVE EST A L'ARRET, ON PASSE CIRCUIT AU SUIVANT *)
  154.                                                         IF k <> i AND Circuits[k].Graphe > 0 THEN
  155.                                                                 (* l element dans le circuit à observer *)
  156.                                                                 FOR l:=0 TO bitDivers.Nombre_Element DO
  157.                                                                         (* AU PREMIER ELEMENT COMMUN RENCONTRE *)
  158.                                                                         IF ((Circuits[k].Elements[l] MOD 1000) = (Circuits[i].Elements[j] MOD 1000)) THEN
  159.                                                                                 (* COMPTAGE DU NOMBRE D'ELEMENTS COMMUNS CONSECUTIFS JUSQU'A LA PREMIERE DESTINATION *)
  160.                                                                                 x := 0;
  161.                                                                                 WHILE Circuits[k].Elements[l + x] MOD 1000 = Circuits[i].Elements[j + x] MOD 1000 DO
  162.                                                                                         x := x + 1;
  163.                                                                                         IF Circuits[k].Elements[l + x] = 0 OR Circuits[i].Elements[j + x] = 0 THEN
  164.                                                                                                 EXIT;
  165.                                                                                         END_IF;
  166.                                                                                 END_WHILE;
  167.                                                                                 (* A DESTINATION EGALE, ON OBSERVE LES ELEMENTS SUIVANTS *)
  168.                                                                                 (* si la suite d'éléments consécutifs ne vont pas sur le même élement *)
  169.                                                                                 IF Circuits[k].Elements[l + x] MOD 1000 <> Circuits[i].Elements[j + x] MOD 1000 THEN
  170.  
  171.                                                                                         (* sauf si destination du circuit observé est l'origine du circuit sélectionné *)
  172.                                                                                         IF Circuits[k].Elements[l + 1] = 0 AND j = 0 THEN
  173.                                                                                                 EXIT;
  174.  
  175.                                                                                         (* ou si l'origine du circuit observé est la destination du circuit sélectionné *)
  176.                                                                                         ELSIF l = 0 AND Circuits[i].Elements[j + 1] = 0  THEN
  177.                                                                                                 EXIT;
  178.  
  179.                                                                                         (* alors on déclare l'élément utilisé *)
  180.                                                                                         ELSE
  181.                                                                                                 use := TRUE;
  182.                                                                                                 Circuits[i].Def_elem := Circuits[k].Elements[l] MOD 1000;
  183.                                                                                                 Circuits[i].Def_Circuit := k;
  184.                                                                                                 EXIT;
  185.                                                                                         END_IF;
  186.                                                                                 END_IF;
  187.                                                                                 (* pour la suite, on saute à la suite de la série d'éléments consécutifs *)
  188.                                                                                 l := l + x;
  189.                                                                                 j := j + x;
  190.                                                                                        
  191.                                                                         END_IF;
  192.                                                                 END_FOR;
  193.                                                         END_IF;
  194.                                                         IF use THEN EXIT; END_IF;
  195.                                                 END_FOR;
  196.                                         END_IF;
  197.                                         IF use THEN EXIT; END_IF;
  198.                                 END_FOR;
  199.                         END_IF;
  200.  
  201.                         IF (use) THEN
  202.                                 Circuits[i].Graphe := 6;
  203.                                 Circuits[i].Isoler := 0;
  204.                                 Circuits[i].Visualisation := 0;
  205.                         ELSE
  206.                                 Circuits[i].Graphe := 10;
  207.                         END_IF;
  208.  
  209.                 6:      (* !!! ELEMENT UTILISE !!! *)
  210.                         ;
  211.  
  212.                 10:     (* ELEMENTS CONTROLES - CHOIX DU MODE DE FONCTIONNEMENT DU CIRCUIT *)
  213.                         IF (Circuits[i].Visualisation = 1) THEN
  214.                                 Circuits[i].Graphe := 16;
  215.                
  216.                         ELSIF (Circuits[i].Isoler = 1) THEN
  217.                                 Circuits[i].Graphe := 18;
  218.                
  219.                         ELSE
  220.                                 Circuits[i].Graphe := 15;
  221.                                 (*Lancement_Cycle_Klaxon:=1;*)
  222.                         END_IF;
  223.  
  224.                 15:     (* CONTROLE PREMIER ELEMENT DU CIRCUIT *)
  225.                         IF Circuits[i].Elements[0] <> 0 THEN
  226.                                 (* SI CIRCUIT ASPIRATION ALORS ON LANCE, SINON, ON ATTEND ASPI OK *)
  227.                                 IF i < bitDivers.Premier_Circuit_Asp THEN
  228.                                         Circuits[i].Graphe := 19;
  229.                                 ELSE
  230.                                         Circuits[i].Graphe := 20;
  231.                                 END_IF;                
  232.                         ELSE
  233.                                 Circuits[i].Graphe := 0;
  234.                         END_IF;
  235.  
  236.                 16:     (* VISUALISATION CIRCUIT *)
  237.                         IF NOT Circuits[i].Visualisation THEN
  238.                                 IF Circuits[i].Elements[0] <> 0 THEN
  239.                                         Circuits[i].Graphe := 200;
  240.                                 ELSE
  241.                                         Circuits[i].Graphe := 0;
  242.                                 END_IF;
  243.                         END_IF;
  244.  
  245.                 17:     (* PAUSE CIRCUIT SUR NIVEAU HAUT *)
  246.                         (* GERE PAR LES ELEMENTS D'ORIGINE ET DE DESTINATION *)
  247.                         ;
  248.  
  249.                 18:     (* ISOLATION CIRCUIT *)
  250.                         IF NOT Circuits[i].Isoler THEN
  251.                                 IF Circuits[i].Elements[0] <> 0 THEN
  252.                                         Circuits[i].Graphe := 200;
  253.                                 ELSE
  254.                                         Circuits[i].Graphe := 0;
  255.                                 END_IF;
  256.                         END_IF;
  257.  
  258.                 19:     (* ATTENTE ASPIRATION *)
  259.                         IF Aspi_ok THEN
  260.                                 Circuits[i].Graphe := 20;
  261.                         END_IF;
  262.  
  263.                 20:     (* DEMARRAGE DU CIRCUIT EN COURS *)
  264.                         (* L'ELEMENT D'ORIGINE DU CIRCUIT DECIDE DE BASCULER LE CIRCUIT A L'ETAT EN COURS OU NON *)
  265.                        
  266.                         (* Si défaut d'aspiration, Arrêt brutal *)
  267.                         IF NOT Aspi_ok AND i < bitDivers.Premier_Circuit_Asp THEN
  268.                                 Circuits[i].Graphe := 200;
  269.        
  270.                         (* Si NH Aspiration, Arrêt cascade *)
  271.                         ELSIF spv_Bennes.DEF_NH AND NOT spv_bennes.INH_DEF_NH THEN
  272.                                 IF bitDivers.Circuit_Asp_General > 0 THEN
  273.                                         Circuits[i].Graphe := 100;
  274.                                 END_IF;
  275.                                 FOR j:=0 TO 9 DO
  276.                                         IF Circuits[i].Circuit_Aspi[j] > 0 THEN
  277.                                                 Circuits[i].Graphe := 100;
  278.                                         END_IF;
  279.                                 END_FOR;
  280.                         END_IF;
  281.                
  282.                 30:     (* CIRCUIT EN COURS *)
  283.                         (* L'ELEMENT D'ORIGINE DU CIRCUIT DECIDE DE BASCULER LE CIRCUIT A L'ETAT EN COURS OU NON *)
  284.                        
  285.                         (* Si défaut d'aspiration, Arrêt brutal *)
  286.                         IF NOT Aspi_ok AND i < bitDivers.Premier_Circuit_Asp THEN
  287.                                 Circuits[i].Graphe := 200;
  288.        
  289.                         (* Si NH Aspiration, Arrêt cascade *)
  290.                         ELSIF spv_Bennes.DEF_NH AND NOT spv_bennes.INH_DEF_NH THEN
  291.                                 IF bitDivers.Circuit_Asp_General > 0 THEN
  292.                                         Circuits[i].Graphe := 100;
  293.                                 END_IF;
  294.                                 FOR j:=0 TO 9 DO
  295.                                         IF Circuits[i].Circuit_Aspi[j] > 0 THEN
  296.                                                 Circuits[i].Graphe := 100;
  297.                                         END_IF;
  298.                                 END_FOR;
  299.                         END_IF;
  300.  
  301.                 100:    (* ARRET EN CASCADE DU CIRCUIT *)
  302.                         (* L'ELEMENT DE DESTINATION DU CIRCUIT DECIDE BASCULER LE CIRCUIT A L'ETAT ARRET COMPLET OU NON *)
  303.                        
  304.                         (* Si défaut d'aspiration, Arrêt brutal *)
  305.                         IF NOT Aspi_ok AND i < bitDivers.Premier_Circuit_Asp THEN
  306.                                 Circuits[i].Graphe := 200;
  307.                         END_IF;
  308.  
  309.                 200:    (* ARRET IMMEDIAT *)
  310.                         Circuits[i].Graphe := 0;
  311.                         Circuits[i].Def_elem := 0;
  312.                         Circuits[i].Def_Circuit := 0;
  313.                         Circuits[i].Isoler := 0;
  314.                         Circuits[i].Visualisation := 0;
  315.                         Circuits[i].Arret_SPV := 0;
  316.  
  317.                 ELSE
  318.                         Circuits[i].graphe := 200;
  319.         END_CASE;
  320.        
  321. END_FOR;

Paste is for source code and general debugging text.

Login or Register to edit, delete and keep track of your pastes and more.

Raw Paste

Login or Register to edit or fork this paste. It's free.

Copyright © 2026 Paste. All rights reserved.
Powered by Paste