(* 
        
         ********************************************************** 
         ********************************************************** 
         **                                                      ** 
         **                     ls-Prozess 5                     ** 
         **                                                      ** 
         **                     Version 1.02                     ** 
         **                                                      ** 
         **                  (Stand : 26.01.90)                  ** 
         **                                                      ** 
         **                                                      ** 
         **                                                      ** 
         **         Autoren: Bruno Pollok, Bielefeld             ** 
         **                  Wolfgang Weber, Bielefeld           ** 
         **                                                      ** 
         **                                                      ** 
         **    Copyright (C) 1988  Eva Latta-Weber, Bielefeld    ** 
         **    Copyright (C) 1990  ERGOS GmbH, Siegburg          ** 
         ********************************************************** 
         ********************************************************** 
 
                                                                           *) 
PACKET ls prozess 5 DEFINES 
       pdv konfiguration zugelassen,
       pdv konfiguration evtl aktivieren,
       pdv konfiguration zeigen,
       pdv kanal konfigurieren,
       pdv interfaceausgabe testen,
       pdv interfaceeingabe testen:
LET max steckplaetze     =  4,
    max portanzahl       =  4,
    anzahl kartensorten  =  5,
    betriebsart          =  1,
    keine karte          =  1,
    ea karte             =  2,
    kombi                =  3,
    da karte             =  4,
    ad karte             =  5,

    compact              =  6,
    einzel               =  7,
    mehrfach             =  8;
LET testfenster x        = 11,
    testfenster y        =  5,
    testfenster xsize    = 59,
    testfenster ysize    = 15;
WINDOW VAR testfenster   :: window (testfenster x,     testfenster y,
                                    testfenster xsize, testfenster ysize);
INT    VAR steckplatzart :: 0;
BOOL   VAR mit konfigurationsmoeglichkeit :: TRUE;
TASK   VAR konfigurationsmanager          :: niltask;

ROW max steckplaetze INT VAR kartenart :: ROW max steckplaetze INT :
                                          (keine karte, keine karte,
                                           keine karte, keine karte);
LET SPANNUNG = ROW 2 REAL,
    PORT     = ROW 3 INT,
    KARTE    = ROW max portanzahl PORT;
ROW anzahl kartensorten KARTE CONST karte :: ROW anzahl kartensorten KARTE :
(* ---------------------------------------------------------------------- *)
(   KARTE : (
(* ---------------------------------------------------------------------- *)

(*         *)       PORT : (nicht belegt, 0, 0),        (*     Port 1     *)
(*  leere  *)       PORT : (nicht belegt, 0, 0),        (*     Port 2     *)
(*  Karte  *)       PORT : (nicht belegt, 0, 0),        (*     Port 3     *)
(*         *)       PORT : (nicht belegt, 0, 0)),       (*     Port 4     *)
(*----------------------------------------------------------------------- *)
    KARTE : (
(* ---------------------------------------------------------------------- *)
(*         *)       PORT : (digital ein,  1, 3),        (*     Port 1     *)

(*   E/A   *)       PORT : (digital aus,  1, 1),        (*     Port 2     *)
(*  Karte  *)       PORT : (digital ein,  1, 3),        (*     Port 3     *)
(*         *)       PORT : (digital aus,  1, 1)),       (*     Port 4     *)
(*----------------------------------------------------------------------- *)
    KARTE : (
(* ---------------------------------------------------------------------- *)
(*         *)       PORT : (analog  ein,  2, 2),        (*     Port 1     *)
(*  Kombi  *)       PORT : (analog  ein,  3, 2),        (*     Port 2     *)

(*  Karte  *)       PORT : (digital ein,  1, 3),        (*     Port 3     *)
(*         *)       PORT : (digital aus,  1, 1 )),      (*     Port 4     *)
(*----------------------------------------------------------------------- *)
    KARTE : (
(* ---------------------------------------------------------------------- *)
(*         *)       PORT : (analog  aus,  1, 1),        (*     Port 1     *)
(*   D/A   *)       PORT : (analog  aus,  1, 3),        (*     Port 2     *)
(* Wandler *)       PORT : (nicht belegt, 0, 0),        (*     Port 3     *)

(*         *)       PORT : (nicht belegt, 0, 0)),       (*     Port 4     *)
(*----------------------------------------------------------------------- *)
    KARTE : (
(* ---------------------------------------------------------------------- *)
(*         *)       PORT : (analog  ein,  1, 1),        (*     Port 1     *)
(*   A/D   *)       PORT : (analog  ein,  1, 3),        (*     Port 2     *)
(* Wandler *)       PORT : (nicht belegt, 0, 0),        (*     Port 3     *)
(*         *)       PORT : (nicht belegt, 0, 0))        (*     Port 4     *)

(*----------------------------------------------------------------------- *)
                                                                           );
PROC pdv konfiguration zugelassen (BOOL CONST wahrheitswert):
  teste berechtigung;
  mit konfigurationsmoeglichkeit := wahrheitswert;
  IF mit konfigurationsmoeglichkeit
     THEN konfigurationsmanager := niltask
     ELSE konfigurationsmanager := myself
  FI.
  teste berechtigung:
    enable stop;
    IF NOT (konfigurationsmanager = niltask  OR

            konfigurationsmanager = myself)
       THEN errorstop ("Befehl ist nur in Task '" +
                        name (konfigurationsmanager) + "' zugelassen!")
    FI.
END PROC pdv konfiguration zugelassen;
PROC pdv konfiguration evtl aktivieren:
  IF mit konfigurationsmoeglichkeit
     THEN activate (3)
     ELSE deactivate (3)
  FI
END PROC pdv konfiguration evtl aktivieren;
PROC pdv kanal konfigurieren:
  TEXT CONST info   ::  "  "15"Auswahl der Steckplatzart "14" "13""13""

                      + "     c  Compactbox             "13""
                      + "     e  Einzelsteckplatz       "13""
                      + "     m  Mehrfachsteckplatz     ",
             liste  :: "Compact"13"Einzel"13"Mehrfach",
             tasten :: "cemCEM";
   INT VAR auswahl := menualternative (info, liste, tasten, 5, FALSE);
   SELECT auswahl OF
     CASE 1, 101, 104 :  trage compactbox ein;
                         zeige kanalbelegung (0)
     CASE 2, 102, 105 :  trage einzelplatzbelegung ein;

                         zeige kanalbelegung (0)
     CASE 3, 103, 106 :  bearbeite die steckplaetze einzeln
   END SELECT;
   beende kanaldaten eintragen.
   trage compactbox ein:
     steckplatzart := compact;
     trage steckplatzbelegung ein (1, kombi);
     trage steckplatzbelegung ein (2, keine karte);
     trage steckplatzbelegung ein (3, keine karte);
     trage steckplatzbelegung ein (4, keine karte).
   trage einzelplatzbelegung ein:
     steckplatzart := einzel;
     trage steckplatzbelegung ein (1, ermittelte kartenart (0));

     trage steckplatzbelegung ein (2, keine karte);
     trage steckplatzbelegung ein (3, keine karte);
     trage steckplatzbelegung ein (4, keine karte).
   bearbeite die steckplaetze einzeln:
     INT VAR platz;
     steckplatzart := mehrfach;
     FOR platz FROM 1 UPTO max steckplaetze REP
       trage steckplatzbelegung ein (platz, ermittelte kartenart (platz));
       zeige kanalbelegung (platz * 10)
     PER.
END PROC pdv kanal konfigurieren;
PROC pdv konfiguration zeigen:
  SELECT steckplatzart OF

    CASE compact  : zeige kanalbelegung (0)
    CASE einzel   : zeige kanalbelegung (0)
    CASE mehrfach : zeige belegung einzelner steckplaetze
    OTHERWISE       noch nicht konfiguriert
  END SELECT.
  noch nicht konfiguriert:
    menuinfo ("                  "15"Warnung: "14"           "13""13""13""
            + " Das Interface wurde noch nicht konfiguriert! "13""13""
            + "  In diesem Zustand sind weder Eingaben noch  "13""
            + "     Ausgaben über das Interface möglich.     "13"").

  zeige belegung einzelner steckplaetze:
    TEXT CONST info   ::
                      "   "15"Eingestellt: Mehrfachsteckplatz "14" "13""13""
                    + "         1   Info Steckplatz 1         "13""
                    + "         2   Info Steckplatz 2         "13""
                    + "         3   Info Steckplatz 3         "13""
                    + "         4   Info Steckplatz 4         "13""13""
                    + "         z   Zurück ins Hauptmenü      ",
               liste  :: "1"13"2"13"3"13"4"13"z",

               tasten :: "1234zZ";
   INT VAR auswahl;
   REP auswahl := menualternative (info, liste, tasten, 5, FALSE);
     SELECT auswahl OF
       CASE 1, 101 :  zeige kanalbelegung (10)
       CASE 2, 102 :  zeige kanalbelegung (20)
       CASE 3, 103 :  zeige kanalbelegung (30)
       CASE 4, 104 :  zeige kanalbelegung (40)
     END SELECT
   UNTIL (auswahl = 5) OR (auswahl > 104) PER
END PROC pdv konfiguration zeigen;
PROC pdv interfaceausgabe testen:
  gestalte testfenster ("Ausgabetest");

  disable stop;
  teste interface;
  IF NOT is error
     THEN teste interface ausgabe
  FI;
  IF is error
     THEN fehlerbehandlung
     ELSE schliesse interface;
          enable stop;
          beseitige testfenster;
          refresh submenu
  FI.
  fehlerbehandlung:
    TEXT VAR meldung :: errormessage;
    clear error;
    schalte alles aus;
    schliesse interface;
    enable stop;
    cursor off;
    regenerate menuscreen;
    menuinfo (" " + invers (meldung)).
END PROC pdv interfaceausgabe testen;

PROC pdv interfaceeingabe testen:
  gestalte testfenster ("Eingabetest");
  disable stop;
  teste interface;
  IF NOT is error
     THEN teste interface eingabe
  FI;
  IF is error
     THEN fehlerbehandlung
     ELSE schliesse interface;
          enable stop;
          beseitige testfenster;
          refresh submenu
  FI.
  fehlerbehandlung:
    TEXT VAR meldung :: errormessage;
    clear error;
    schalte alles aus;
    schliesse interface;
    enable stop;
    cursor off;

    regenerate menuscreen;
    menuinfo (" " + invers (meldung)).
END PROC pdv interfaceeingabe testen;
PROC beseitige testfenster:
  INT VAR z;
  FOR z FROM testfenster y + testfenster ysize DOWNTO testfenster y - 1 REP
    cursor (testfenster x - 1, z);
    out (""5"")
  PER
END PROC beseitige testfenster;
PROC gestalte testfenster (TEXT CONST funktionsart):
  show (testfenster);
  cursor (testfenster x - 1, testfenster y + testfenster ysize - 2);
  out (balken links + (testfenster xsize * waagerecht) + balken rechts);

  cursor (testfenster, 1, 2);
  out (testfenster, center (testfenster, invers (funktionsart)))
END PROC gestalte testfenster;
PROC testfensterfussnote (TEXT CONST meldung):
  cursor (testfenster, 2, testfenster ysize);
  out (testfenster, meldung)
END PROC testfensterfussnote;
PROC teste interfaceausgabe:
  INT  VAR kanalnummer, steckplatz, port;
  TEXT VAR nummer :: "";
  enable stop;
  REP hole kanalnummer;
      teste ausgabe an kanal
  PER.
  hole kanalnummer:
    SELECT steckplatzart OF

      CASE compact  :  kanalnummer := 4; steckplatz := 1; port := 4
      CASE einzel   :  kanalnummer muss evtl erfragt werden
      CASE mehrfach :  kanalnummer muss erfragt werden
    OTHERWISE errorstop ("Interface ist noch nicht konfiguriert!")
    END SELECT;
    cursor (testfenster, 2, 5);
    out (testfenster, "Ausgabe an Kanal " + text (kanalnummer) + klammer +
                       kanalbeschreibung (steckplatz, port));
    IF steckplatzart = mehrfach
       THEN cursor (testfenster, 25, 6);

            out (testfenster, "in Steckplatz " + text (steckplatz))
    FI;
    out (testfenster, ")").
    klammer:
      IF kanalnummer < 10
         THEN "  (= "
         ELSE " (= "
      FI.
  kanalnummer muss evtl erfragt werden:
    SELECT kartenart [1] OF
      CASE kombi   :  kanalnummer := 4; steckplatz := 1; port := 4
      CASE eakarte :  kanalnummer := 2; steckplatz := 1; port := 2
      CASE dakarte :  frage nach kanalnummer auf da karte;
                      steckplatz  := 1; port := kanalnummer

    OTHERWISE errorstop ("Keine Ausgabe an " + kartenname + " möglich!")
    END SELECT.
  kartenname:
    IF kartenart [1] = ad karte
       THEN "A/D-Karte"
       ELSE "leeren Steckplatz"
    FI.
  frage nach kanalnummer auf da karte:
    menufootnote ("Zurück zum Hauptmenü: <ESC><q>");
    testfensterfussnote ("Bitte eine Kanalnummer eingeben!");
    cursor (testfenster, 2, 5);
    out (testfenster, "Ausgabe - Kanal (1 oder 2): ");
    cursor on;
    REP inchar (nummer)
    UNTIL (pos ("12", nummer) > 0) OR esc q gedrueckt PER;

    cursor off;
    IF nummer = ""27""
       THEN LEAVE teste interface ausgabe
       ELSE kanalnummer := int (nummer)
    FI.
    esc q gedrueckt:
      (nummer = ""27"") AND (incharety (20) = "q").
  kanalnummer muss erfragt werden:
    TEXT VAR exit char;
    menufootnote ("Zurück zum Hauptmenü: <ESC><q>");
    testfensterfussnote ("Bitte eine Kanalnummer eingeben!");
    cursor (testfenster, 2, 5);
    out (testfenster, "Ausgabe - Kanal:");
    cursor on;
    REP cursor (testfenster, 19, 5);

        editget (testfenster, nummer, 4, 4, "", "q", exit char)
    UNTIL (exit char = ""27"q") OR ausgabekanal eingegeben PER;
    cursor off;
    IF exit char = ""27"q"
       THEN LEAVE teste interface ausgabe
    FI.
  ausgabekanal eingegeben:
    kanalnummer := abs (int (nummer));
    steckplatz  := kanalnummer DIV 10;
    port        := kanalnummer MOD 10;
    IF steckplatz = 0 THEN steckplatz := 1 FI;
    cursor (testfenster, 2, 7);
    IF   (kanalnummer < 1) OR (kanalnummer > 49)

         THEN out (testfenster, "Unzulässige Kanalnummer!          "); FALSE
    ELIF (port = 0) OR (port > max portanzahl) OR kein ausgabeport
         THEN out (testfenster, "Dies ist kein Ausgabe-Kanal!      "); FALSE
         ELSE out (testfenster, "                                  "); TRUE
    FI.
    kein ausgabeport:
      (port betriebsart <> digital aus) AND (port betriebsart <> analog aus).
      port betriebsart: karte [sorte][port][betriebsart].
      sorte           : kartenart [steckplatz].

  teste ausgabe an kanal:
    TEXT VAR wert;
    cursor (testfenster, 1, 8);
    out (testfenster, testfenster xsize * "-");
    cursor (testfenster, 2, 11);
    out (testfenster, "Ausgabewert: ");
    testfenster fussnote ("Bitte einen Wert zwischen 0 und 255 eingeben!");
    menufootnote ("'Werte ausgeben' beenden: <ESC><q>");
    cursor on;
    REP cursor (testfenster, 15, 11);
        wert := "0";
        editget (testfenster, wert, 4, 4, "", "qh", exit char);
        IF exit char = return

           THEN ausgeben (kanalnummer, int (wert) MOD ganzzahlobergrenze)
        ELIF exit char = ""27"h"
           THEN errorstop ("Programm-Abbruch durch <ESC><h>!")
        FI
    UNTIL exitchar = ""27"q" PER;
    cursor off;
    IF (steckplatzart = mehrfach) OR (kartenart [1] = da karte)
       THEN cursor (testfenster, 1, 5);
            out (testfenster, (2 * testfenster xsize) * " ");
            cursor (testfenster, 2, 11);
            out (testfenster, "                       ");

            testfenster fussnote ((testfenster xsize - 2) * " ")
       ELSE LEAVE teste interfaceausgabe
    FI.
    return: ""13"".
END PROC teste interfaceausgabe;
PROC teste interfaceeingabe:
  INT  VAR kanalnummer, steckplatz, port;
  TEXT VAR nummer :: "";
  enable stop;
  REP hole kanalnummer;
      teste eingabe vom kanal
  PER.
  hole kanalnummer:
    IF   steckplatzart = 0
         THEN errorstop ("Interface ist noch nicht konfiguriert!")
         ELSE kanalnummer erfragen

    FI;
    cursor (testfenster, 2, 5);
    out (testfenster, "Eingabe von Kanal " + text (kanalnummer) + klammer +
                       kanalbeschreibung (steckplatz, port));
    IF steckplatzart = mehrfach
       THEN cursor (testfenster, 26, 6);
            out (testfenster, "in Steckplatz " + text (steckplatz))
    FI;
    out (testfenster, ")").
    klammer:
      IF kanalnummer < 10
         THEN "  (= "
         ELSE " (= "
      FI.
  kanalnummer erfragen:
    SELECT steckplatzart OF

      CASE compact  : drei kanaele anbieten;
                      steckplatz := 1; port := kanalnummer
      CASE einzel   : zwei oder drei kanaele anbieten;
                      steckplatz := 1; port := kanalnummer
      CASE mehrfach : alle kanaele moeglich
    END SELECT.
  drei kanaele anbieten:
    menufootnote ("Zurück zum Hauptmenü: <ESC><q>");
    testfensterfussnote ("Bitte eine Kanalnummer eingeben!");
    cursor (testfenster, 2, 5);
    out (testfenster, "Eingabe - Kanal (1, 2 oder 3): ");

    cursor on;
    REP inchar (nummer)
    UNTIL (pos ("123", nummer) > 0) OR esc q gedrueckt PER;
    cursor off;
    IF nummer = ""27""
       THEN LEAVE teste interface eingabe
       ELSE kanalnummer := int (nummer)
    FI.
    esc q gedrueckt:
      (nummer = ""27"") AND (incharety (20) = "q").
  zwei oder drei kanaele anbieten:
    SELECT kartenart [1] OF
      CASE kombi    : drei kanaele anbieten
      CASE ad karte : zwei kanaele anbieten
      CASE ea karte : kanalnummer := 1

    OTHERWISE errorstop ("Eingabe bei " + kartenname + " nicht möglich!")
    END SELECT.
    kartenname:
      IF kartenart [1] = da karte
         THEN "D/A-Karte"
         ELSE "leerem Steckplatz"
      FI.
  zwei kanaele anbieten:
    menufootnote ("Zurück zum Hauptmenü: <ESC><q>");
    testfensterfussnote ("Bitte eine Kanalnummer eingeben!");
    cursor (testfenster, 2, 5);
    out (testfenster, "Eingabe - Kanal (1 oder 2): ");
    cursor on;
    REP inchar (nummer)
    UNTIL (pos ("12", nummer) > 0) OR esc q gedrueckt PER;

    cursor off;
    IF nummer = ""27""
       THEN LEAVE teste interface eingabe
       ELSE kanalnummer := int (nummer)
    FI.
  alle kanaele moeglich:
    TEXT VAR exit char;
    menufootnote ("Zurück zum Hauptmenü: <ESC><q>");
    testfensterfussnote ("Bitte eine Kanalnummer eingeben!");
    cursor (testfenster, 2, 5);
    out (testfenster, "Eingabe - Kanal:");
    cursor on;
    REP cursor (testfenster, 19, 5);
        editget (testfenster, nummer, 4, 4, "", "q", exit char)
    UNTIL (exit char = ""27"q") OR eingabekanal eingegeben PER;

    cursor off;
    IF exit char = ""27"q"
       THEN LEAVE teste interface eingabe
    FI.
  eingabekanal eingegeben:
    kanalnummer := abs (int (nummer));
    steckplatz  := kanalnummer DIV 10;
    port        := kanalnummer MOD 10;
    IF steckplatz = 0 THEN steckplatz := 1 FI;
    cursor (testfenster, 2, 7);
    IF   (kanalnummer < 1) OR (kanalnummer > 49)
         THEN out (testfenster, "Unzulässige Kanalnummer!          "); FALSE
    ELIF (port = 0) OR (port > max portanzahl) OR kein eingabeport

         THEN out (testfenster, "Dies ist kein Eingabe-Kanal!      "); FALSE
         ELSE out (testfenster, "                                  "); TRUE
    FI.
    kein eingabeport:
      (port betriebsart <> digital ein) AND (port betriebsart <> analog ein).
      port betriebsart: karte [sorte][port][betriebsart].
      sorte           : kartenart [steckplatz].
  teste eingabe vom kanal:
    cursor (testfenster, 1, 8);
    out (testfenster, testfenster xsize * "-");
    cursor (testfenster, 2, 11);

    out (testfenster, "Eingelesener Wert: ");
    testfenster fussnote ("                                             ");
    menufootnote ("'Werte einlesen' beenden: <ESC><q>");
    REP cursor (testfenster, 21, 11);
        out (text (eingabe (kanalnummer), 3));
        warte (0.1)
    UNTIL abbruch gewuenscht PER;
    IF (steckplatzart = einzel) AND (kartenart [1] = ea karte)
       THEN LEAVE teste interfaceeingabe
       ELSE cursor (testfenster, 1, 5);
            out (testfenster, (2 * testfenster xsize) * " ");

            cursor (testfenster, 2, 11);
            out (testfenster, "                       ")
    FI.
END PROC teste interfaceeingabe;
TEXT PROC kanalbeschreibung (INT CONST steckplatz, port):
  IF steckplatzart = compact
     THEN port auf compactbox
     ELSE port auf steckkarte
  FI.
  port auf compactbox:
    portbeschreibung + " der Compact-Box".
  port auf steckkarte:
    SELECT kartenart [steckplatz] OF
      CASE kombi    : portbeschreibung + " der Kombi-Karte"
      CASE ea karte : portbeschreibung + " der E/A-Karte"

      CASE da karte : portbeschreibung + " der D/A-Karte"
      CASE ad karte : portbeschreibung + " der A/D-Karte"
    OTHERWISE ""
    END SELECT.
  portbeschreibung:
    SELECT 2 + karte [kartenart [steckplatz]][port][betriebsart] OF
      CASE 1 : "Digitalausgang"
      CASE 3 : "Digitaleingang"
      CASE 0 : "Analogausgang " + text (port)
      CASE 4 : "Analogeingang " + text (port)
    OTHERWISE ""
    END SELECT.
END PROC kanalbeschreibung;
PROC trage steckplatzbelegung ein (INT CONST steckplatz, art):

  INT VAR port;
  kartenart [steckplatz] := art;
  klaere spannungsbereiche;
  FOR port FROM 1 UPTO max portanzahl REP
    trage kanaldaten ein (kanalnummer, spannungsbereich, portdaten);
    IF steckplatz = 1
       THEN trage kanaldaten ein (port, spannungsbereich, portdaten)
    FI
  PER.
  kanalnummer:  port  +  10 * steckplatz.
  portdaten  :  karte [kartenart [steckplatz]][port].
  spannungsbereich:
    IF   port = 1
         THEN bereich von e1
    ELIF port = 2
         THEN bereich von e2

         ELSE SPANNUNG : (0.0, 0.0)
    FI.
  klaere spannungsbereiche:
    SPANNUNG VAR bereich von e1, bereich von e2;
    SELECT kartenart [steckplatz] OF
      CASE kombi    : spannungsbereich 0 bis 5 volt
      CASE da karte : setze spannungsbereiche
      CASE ad karte : erfrage adkarte schalterstellungen
    OTHERWISE alles auf 0 setzen
    END SELECT.
  spannungsbereich 0 bis 5 volt:
    bereich von e1 := SPANNUNG : (0.0, 5.0);
    bereich von e2 := SPANNUNG : (0.0, 5.0).
  setze spannungsbereiche:

    bereich von e1 := SPANNUNG : (-5.0, 5.0);
    bereich von e2 := SPANNUNG : ( 0.0, 5.0).
  alles auf 0 setzen:
    bereich von e1 := SPANNUNG : (0.0, 0.0);
    bereich von e2 := SPANNUNG : (0.0, 0.0).
erfrage adkarte schalterstellungen:
  REP
   hole schalterstellung
  UNTIL schalterstellung sinnvoll PER;
  bestimme spannungsbereiche (schalterzustand, bereich von e1, bereich von e2).
  hole schalterstellung:
    TEXT VAR schalterzustand := menuanswer (infotext, "00000000", 5).
  infotext:

    ueberschrift
    + "  Bitte die aktuelle Schalterstellung eintragen: "13""13""
    + "  Es bedeutet :  1  -  Schalterstellung 'on'     "13""
    + "                 0  -  Schalterstellung 'off'    "13""13""
    + " Nummer : 12345678 "13""
    + "          |||||||| ".
 ueberschrift:
   IF steckplatzart = mehrfach
      THEN " "15"Angabe der Schalterstellungen auf der A/D-Karte "14""13""
         + " "15"                in Steckplatz "
         + text (steckplatz) + ":                "14""13""13""

      ELSE " "15"Angabe der Schalterstellungen auf der A/D-Karte: "14""13""13""
   FI.
 schalterstellung sinnvoll:
   (length (schalterzustand) = 8) AND nur nullen und einsen.
 nur nullen und einsen:
   BOOL VAR ok := TRUE; INT VAR m;
   FOR m FROM 1 UPTO 8 REP
     IF NOT ((schalterzustand SUB m) = "1" OR (schalterzustand SUB m ) = "0")
        THEN ok := FALSE
     FI
   PER;
   ok.
END PROC trage steckplatzbelegung ein;
INT PROC ermittelte kartenart (INT CONST steckplatz):
  TEXT CONST info e ::  "     "15"Angabe der Interfacekarte: "14"    "13""13""

                      + "     k   Kombikarte              "13""
                      + "     e   E / A - Karte           "13""
                      + "     d   D / A - Wandler - Karte "13""
                      + "     a   A / D - Wandler - Karte "13""
                      + "     0   Keine Steckkarte        ",
             info m ::  "  "15"Angabe der Interfacekarte für Steckplatz "
                      + text (steckplatz) + ": "14" "13""13""
                      + "             k   Kombikarte              "13""

                      + "             e   E / A - Karte           "13""
                      + "             d   D / A - Wandler - Karte "13""
                      + "             a   A / D - Wandler - Karte "13""
                      + "             0   Keine Steckkarte        ",
             liste  :: "Kombi"13"E/A"13"D/A"13"A/D"13"Keine",
             tasten :: "keda0KEDA";
   INT VAR auswahl := menualternative (infotext, liste, tasten, 5, FALSE);
   SELECT auswahl OF
     CASE 1, 101, 106 :  kombi

     CASE 2, 102, 107 :  eakarte
     CASE 3, 103, 108 :  dakarte
     CASE 4, 104, 109 :  adkarte
     OTHERWISE           keine karte
   END SELECT.
   infotext:
     IF steckplatz = 0
        THEN info e
        ELSE info m
     FI.
END PROC ermittelte kartenart;
PROC zeige kanalbelegung (INT  CONST steckplatz):
   ROW 4 TEXT VAR kanalnummer;
   kanalnummer [1] := text (steckplatz + 1, 2);
   kanalnummer [2] := text (steckplatz + 2, 2);
   kanalnummer [3] := text (steckplatz + 3, 2);

   kanalnummer [4] := text (steckplatz + 4, 2);
   IF steckplatzart = compact
      THEN zeige compactboxbelegung
      ELSE zeige steckplatz mit karte
   FI.
  zeige steckplatz mit karte:
    SELECT kartenart [steckplatznummer] OF
      CASE kombi  : zeige steckplatz mit kombi
      CASE eakarte: zeige steckplatz mit eakarte
      CASE dakarte: zeige steckplatz mit dakarte
      CASE adkarte: zeige steckplatz mit adkarte
      OTHERWISE     zeige steckplatz ohne karte
    END SELECT.

  steckplatznummer:
    IF steckplatz = 0
       THEN 1
       ELSE steckplatz DIV 10
    FI.
  zeige compactboxbelegung:
    menuinfo (
      "              "15"Eingestellt: Compactbox "14"         "13""13""
    + "                 Belegung der Kanäle:               "13""13""13""
    + kanalnummeranzeige kombikarte).
  zeige steckplatz mit kombi:
    menuinfo (ueberschrift + " mit Kombikarte: "14"    "13""13""
    + "                Belegung der Kanäle:               "13""13""13""
    + kanalnummeranzeige kombikarte).

  zeige steckplatz mit eakarte:
    menuinfo (ueberschrift + " mit E / A - Karte: "14"    "13""13""
    + "                Belegung der Kanäle:               "13""13""13""
    + kanalnummeranzeige eakarte).
  zeige steckplatz mit dakarte:
    menuinfo (ueberschrift + " mit D / A - Karte: "14"    "13""13""
    + "                Belegung der Kanäle:               "13""13""
    + kanalnummeranzeige dakarte).
  zeige steckplatz mit adkarte:
    hole spannungsbereiche;
    menuinfo ("     " + ueberschrift + " mit A / D - Karte: "14""13""13""

    + "           Zwei analoge Eingänge stehen zur Verfügung:   "13""13""
    + kanalnummeranzeige adkarte).
  hole spannungsbereiche:
    SPANNUNG VAR e1 bereich, e2 bereich;
    hole spannungsbereich (steckplatz + 1, e1 bereich [1], e1 bereich [2]);
    hole spannungsbereich (steckplatz + 2, e2 bereich [1], e2 bereich [2]).
  zeige steckplatz ohne karte:
    IF steckplatz = 0
       THEN menuinfo (
            "    "15"Einzelsteckplatz ohne Steckkarte: "14"   "13""13""13""
          + " Es sind weder Ein- noch Ausgaben möglich! "13"")

       ELSE menuinfo (
            "        "15"Steckplatz "
          + text (steckplatz DIV 10) + " ohne Steckkarte: "14""13""13""13""
          + " Es sind hier weder Ein- noch Ausgaben möglich! "13"")
    FI.
  ueberschrift:
    IF steckplatz = 0
       THEN "         "15"Einzelsteckplatz"
       ELSE "           "15"Steckplatz " + text (steckplatz DIV 10)
    FI.
  kanalnummeranzeige kombikarte:
      "     "15"Kanal " + kanalnummer [1]
                             + ": "14"  Analogeingang 1 (E1) "13""13""

    + "     "15"Kanal " + kanalnummer [2]
                             + ": "14"  Analogeingang 2 (E2) "13""13""
    + "     "15"Kanal " + kanalnummer [3]
                             + ": "14"  Digitaleingang       "13""13""
    + "     "15"Kanal " + kanalnummer [4]
                             + ": "14"  Digitalausgang       "13"".
  kanalnummeranzeige eakarte:
    "     "15"Kanal " + kanalnummer [1]
    + ": "14"  Digitaleingang "13""13""
    + "     "15"Kanal " + kanalnummer [2]
    + ": "14"  Digitalausgang "13""13""

    + "   ( "15"Kanal " + kanalnummer [3]
    + ": "14"  Digitaleingang (= Kanal " + kanalnummer [1] + ") )"13""13""
    + "   ( "15"Kanal " + kanalnummer [4]
    + ": "14"  Digitalausgang (= Kanal " + kanalnummer [2] + ") )"13"".
  kanalnummeranzeige adkarte:
      "  "15"Kanal " + kanalnummer [1]
                     + ": "14" (E1)  Spannungsbereich  " + bereich1 + ""13""13""
    + "  "15"Kanal " + kanalnummer [2]
                     + ": "14" (E2)  Spannungsbereich  " + bereich2 + ""13"".

  bereich1:
    IF e1 bereich [1] = 0.0
       THEN "  0.000 V  -  +" + text (e1 bereich [2], 6, 3) + " V  "
       ELSE text (e1 bereich [1], 7, 3) + " V  -  +" + text (e1 bereich [2], 6, 3) + " V  "
    FI.
  bereich2:
    IF e2 bereich [1] = 0.0
       THEN "  0.000 V  -  +" + text (e2 bereich [2], 6, 3) + " V"
       ELSE text (e2 bereich [1], 7, 3) + " V  -  +" + text (e2 bereich [2], 6, 3) + " V"
    FI.
  kanalnummeranzeige dakarte:
      "  Die Karte stellt einen Analogausgang zur Verfügung, "13""

    + "  der auf zwei Arten angesprochen werden kann:        "13""13""13""
    + "     "15"Kanal " + kanalnummer [1]
                               + ": "14"  Spannungsbereich  -5 V  -  +5 V "13""13""
    + "     "15"Kanal " + kanalnummer [2]
                               + ": "14"  Spannungsbereich   0 V  -  +5 V "13"".
END PROC zeige kanalbelegung;
PROC bestimme spannungsbereiche (TEXT CONST schalterstellung,
                                 SPANNUNG VAR bereich von e1,
                                 SPANNUNG VAR bereich von e2):

  bestimme bereich von e1;
  bestimme bereich von e2.
  bestimme bereich von e1:
    IF   schalter 3 geschlossen
         THEN umax1 :=  0.25
    ELIF schalter 2 geschlossen
         THEN umax1 :=  2.5
    ELIF schalter 1 geschlossen
         THEN umax1 := 25.0
         ELSE umax1 :=  0.0
    FI;
    IF schalter 8 geschlossen
       THEN symmetrische spannungsmessung ueber e1
       ELSE asymmetrische spannungsmessung ueber e1
    FI.
    schalter 1 geschlossen:  (schalterstellung SUB 1) = on.

    schalter 2 geschlossen:  (schalterstellung SUB 2) = on.
    schalter 3 geschlossen:  (schalterstellung SUB 3) = on.
    schalter 8 geschlossen:  (schalterstellung SUB 8) = on.
    umin1:  bereich von e1 [1].
    umax1:  bereich von e1 [2].
  symmetrische spannungsmessung ueber e1:
    umax1 := umax1 / 2.0;
    umin1 := - umax1.
  asymmetrische spannungsmessung ueber e1:
    umin1 := 0.0.
  bestimme bereich von e2:
    IF   schalter 6 geschlossen
         THEN umax2 :=  0.25
    ELIF schalter 5 geschlossen

         THEN umax2 :=  2.5
    ELIF schalter 4 geschlossen
         THEN umax2 := 25.0
         ELSE umax2 :=  0.0
    FI;
    IF schalter 7 geschlossen
       THEN symmetrische spannungsmessung ueber e2
       ELSE asymmetrische spannungsmessung ueber e2
    FI.
    schalter 4 geschlossen:  (schalterstellung SUB 4) = on.
    schalter 5 geschlossen:  (schalterstellung SUB 5) = on.
    schalter 6 geschlossen:  (schalterstellung SUB 6) = on.
    schalter 7 geschlossen:  (schalterstellung SUB 7) = on.

    umin2:  bereich von e2 [1].
    umax2:  bereich von e2 [2].
  symmetrische spannungsmessung ueber e2:
    umax2 := umax2 / 2.0;
    umin2 := - umax2.
  asymmetrische spannungsmessung ueber e2:
    umin2 := 0.0.
  on:  "1".
END PROC bestimme spannungsbereiche
END PACKET ls prozess 5