Decompress source files

EUMEL’s TEXT dataspaces wastes a lot of storage space. Some files were
therefore “compressed” by storing them as a single line, reducing
overhead significantly.

7 files changed, 3133 insertions, 204 deletions

diff --git a/prozess/ls-Prozess 1 für AKTRONIC-Adapter b/prozess/ls-Prozess 1 für AKTRONIC-Adapter
index c42cfa5..d49d9d2 100644
--- a/prozess/ls-Prozess 1 für AKTRONIC-Adapter
+++ b/prozess/ls-Prozess 1 für AKTRONIC-Adapter
@@ -22,36 +22,536 @@
  
                                                                            *) 
 PACKET ls prozess 1 DEFINES                   
-       run pdv,{}       run pdv again,{}       initialisiere interface,{}       schalte alles aus,{}       ausgeben,{}       eingabe,{}       warte,{}       abbruch gewuenscht,{}       tue nichts,{}       trage kanaldaten ein,{}       beende kanaldaten eintragen,{}       hole spannungsbereich,{}       letzte ausgabe,{}       pruefe kanal,{}       pruefe abbruch,{}       teste interface,{}       oeffne interface,{}       schliesse interface,{}       nicht belegt,{}       digital aus,{}       analog aus,{}
-       digital ein,{}       analog ein,{}       kanalbreite,{}       ganzzahl obergrenze,{}       adapterart,{}    (* ------------------------- *){}       kanalkoppler,{}       interface kanal,{}       oeffne interface direkt,{}       schliesse interface direkt,{}       initialisiere interface direkt,{}       direkt ausgeben,{}       direkt eingabe:{}(******** A N P A S S U N G  A N  A K T R O N I C - A D A P T E R ********){}LET interface test  code = ""240"",{}    interface open  code = ""176"",{}
-    interface close code = ""176"",{}    adresse 0 code       = ""176"",{}    interface write code =    64  ,{}    interface read  code =   192  ;{}TEXT CONST adapterart :: "AKTRONIC-Adapter";{}TEXT PROC interface anpassung (INT CONST kanalnummer, steuerungscode):{}  IF   es ist ein ausgabekanal{}       THEN code (interface write code + device + faktor * steuerungscode){}  ELIF es ist ein eingabekanal{}       THEN lesecode in abhaengigkeit von der taktzahl{}       ELSE ""{}  FI.{}  es ist ein ausgabekanal:{}
-    kanal [kanalnummer].betriebsart < 0.{}  es ist ein eingabekanal:{}    kanal [kanalnummer].betriebsart > 0.{}  device:{}    IF steckplatznummer < 3{}       THEN 16{}       ELSE 32{}    FI.{}  faktor:{}    IF steckplatznummer MOD 2 = 0{}       THEN 4{}       ELSE 1{}    FI.{}  steckplatznummer:{}    IF kanalnummer < 10{}       THEN 1{}       ELSE kanalnummer DIV 10{}    FI.{}  lesecode in abhaengigkeit von der taktzahl:{}    SELECT kanal [kanalnummer].taktzahl OF{}      CASE 1: code fuer digital oder analog eingang{}
-      CASE 2: code fuer kombi e1{}      CASE 3: code fuer kombi e2{}    OTHERWISE "" END SELECT.{}  code fuer digital oder analog eingang:{}    IF kanal [kanalnummer].betriebsart = analog ein{}       THEN kanal [kanalnummer].taktzahl := 2;  (* ad wandler muss hier *){}            lesecode + lesecode                 (* 2x gelesen werden!   *){}       ELSE lesecode{}    FI.{}  lesecode  :  code (interface read code + device + faktor * steuerungscode).{}  code fuer kombi e1:{}    kanal [kanalnummer].taktzahl INCR 1; (* bei Analogport1 der Kombikarte *){}
-    adresse 0 code + (3 * lesecode).     (* sind hier 3 Takte     noetig ! *){}  code fuer kombi e2:{}    kanal [kanalnummer].taktzahl DECR 1;     (* hier nur 2 Takte noetig ! *){}    adresse 0 code + lesecode + lesecode.{}END PROC interface anpassung;{}(************ H A R D W A R E U N A B H Ä N G I G E R  T E I L ************){}LET       max kanalanzahl          =   49,{}          initcode                 =   50,{}          endcode                  =   51,{}          alles aus code           =   52,{}
-          endezeichen              =  "q",{}          abbruchzeichen           =  "h",{}          esc                      =  ""27"";{}INT CONST analog aus               ::  -2,            (* Betriebsarten *){}          digital aus              ::  -1,{}          nicht belegt             ::   0,{}          digital ein              ::   1,{}          analog  ein              ::   2,{}          kanalbreite              ::   8,{}          ganzzahl obergrenze      ::   2 ** kanalbreite,{}          configuration error code ::  -1,{}
-          kanal besetzt code       ::  -3,{}          interface error code     ::  -4,{}          not init code            ::  -5;{}INT VAR   interfacechannel         ::   2,{}          dummy;{}TEXT VAR  meldung                  ::  "";{}BOOL VAR  kanaldaten sind eingetragen :: FALSE,{}          endezeichen gegeben         :: FALSE,{}          programm mit pdv gestartet  :: FALSE,{}          fehler zu melden            :: FALSE;{}TASK VAR  interface task              :: niltask;{}DATASPACE VAR  ds :: nilspace;{}
-TYPE KANAL     = STRUCT (INT  betriebsart, taktzahl, TEXT steuercode),{}     SPANNUNG  = STRUCT (REAL minimalwert, maximalwert);{}ROW max kanalanzahl INT      VAR vorherige ausgabe;{}ROW max kanalanzahl KANAL    VAR kanal;{}ROW max kanalanzahl SPANNUNG VAR spannung;{}ROW 5 TEXT CONST fehlermeldung :: ROW 5 TEXT :{}  ("Interface ist noch nicht konfiguriert!",{}   "Interface-Task ist besetzt!",{}   "Interface-Kanal ist belegt!",{}   "Interface meldet sich nicht!",{}   "Interface kann nicht geöffnet werden!");{}
-PROC run pdv:{}  run pdv (last param){}END PROC run pdv;{}PROC run pdv (TEXT CONST programmname):{}  enable stop;{}  last param (programmname);{}  programm mit pdv gestartet := TRUE;{}  teste interface;{}  disable stop;{}  run (programmname);{}  IF is error{}     THEN fehlerbehandlung{}     ELSE melde programmende{}  FI;{}  schliesse interface;{}  programm mit pdv gestartet := FALSE;{}  enable stop;{}  IF fehler zu melden{}     THEN errorstop (meldung){}  FI{}END PROC run pdv;{}PROC run pdv again:{}
-  enable stop;{}  programm mit pdv gestartet := TRUE;{}  teste interface;{}  disable stop;{}  run again;{}  IF is error{}     THEN fehlerbehandlung{}     ELSE melde programmende{}  FI;{}  schliesse interface;{}  programm mit pdv gestartet := FALSE;{}  enable stop;{}  IF fehler zu melden{}     THEN errorstop (meldung){}  FI{}END PROC run pdv again;{}PROC melde programmende:{}  page;{}  menufootnote ("Programmende! Zum Weitermachen bitte irgendeine Taste tippen.");{}  pause;{}  schalte alles aus{}END PROC melde programmende;{}
-PROC initialisiere interface:{}  enable stop;{}  pruefe abbruch;{}  IF programm mit pdv gestartet{}     THEN schalte alles aus{}     ELSE errorstop ("PDV-Programme müssen mit 'run pdv' gestartet werden!"){}  FI{}END PROC initialisiere interface;{}PROC schalte alles aus:{}  INT VAR k;{}  FOR k FROM 1 UPTO max kanalanzahl REP{}    vorherige ausgabe [k] := 0{}  PER;{}  forget (ds); ds := nilspace;{}  call (interface task, alles aus code, ds, dummy){}END PROC schalte alles aus;{}PROC ausgeben (INT CONST kanalnummer, wert):{}
-  merke wert;{}  gib wert aus.{}  merke wert:{}    vorherige ausgabe [kanalnummer] := wert.{}  gib wert aus:{}    call (interface task, 256 * kanalnummer + wert, ds, dummy).{}END PROC ausgeben;{}INT PROC eingabe (INT CONST kanalnummer):{}  INT VAR eingabewert;{}  call (interface task, kanalnummer, ds, eingabewert);{}  eingabewert{}END PROC eingabe;{}PROC warte (REAL CONST sekunden):{}  TEXT VAR eingabe;{}  pruefe abbruch;{}  eingabe := incharety (int (sekunden * 10.0 + 0.5));{}  IF eingabe = esc{}
-     THEN untersuche naechstes zeichen{}  FI.{}  untersuche naechstes zeichen:{}    eingabe := incharety (30);{}    IF   eingabe = endezeichen{}         THEN endezeichen gegeben := TRUE{}    ELIF eingabe = abbruchzeichen{}         THEN errorstop ("Programm-Abbruch durch <ESC><"{}                             + abbruchzeichen + ">!"){}    FI.{}END PROC warte;{}PROC warte (INT CONST sekunden):{}  TEXT VAR eingabe;{}  pruefe abbruch;{}  eingabe := incharety (sekunden * 10);{}  IF eingabe = esc{}     THEN untersuche naechstes zeichen{}
-  FI.{}  untersuche naechstes zeichen:{}    eingabe := incharety (30);{}    IF   eingabe = endezeichen{}         THEN endezeichen gegeben := TRUE{}    ELIF eingabe = abbruchzeichen{}         THEN errorstop ("Programm-Abbruch durch <ESC><"{}                             + abbruchzeichen + ">!"){}    FI.{}END PROC warte;{}BOOL PROC abbruch gewuenscht:{}  pruefe abbruch;{}  BOOL VAR entscheidung :: endezeichen gegeben;{}  endezeichen gegeben := FALSE;{}  entscheidung{}END PROC abbruch gewuenscht;{}PROC tue nichts:{}
-  pruefe abbruch{}END PROC tue nichts;{}PROC trage kanaldaten ein (INT CONST  kanalnummer,{}                           ROW 2 REAL CONST spannungsbereich,{}                           ROW 3 INT  CONST kanalparameter):{}   spannung [kanalnummer].minimalwert := spannungsbereich [1];{}   spannung [kanalnummer].maximalwert := spannungsbereich [2];{}   kanal [kanalnummer].betriebsart    := kanalparameter   [1];{}   kanal [kanalnummer].taktzahl       := kanalparameter   [2];{}   kanal [kanalnummer].steuercode     := interface anpassung{}
-                                         (kanalnummer, kanalparameter [3]){}END PROC trage kanaldaten ein;{}PROC beende kanaldaten eintragen:{}  loesche interface task;{}  begin (PROC kanal koppler, interface task);{}  kanaldaten sind eingetragen := TRUE.{}  loesche interface task:{}    disable stop;{}    end (interface task);{}    IF is error{}       THEN clear error{}    FI;{}    enable stop.{}END PROC beende kanaldaten eintragen;{}PROC hole spannungsbereich (INT CONST kanalnummer, REAL VAR  u min, u max):{}
-  u min := spannung [kanalnummer].minimalwert;{}  u max := spannung [kanalnummer].maximalwert{}END PROC hole spannungsbereich;{}INT PROC letzte ausgabe (INT CONST kanalnummer):{}  vorherige ausgabe [kanalnummer]{}END PROC letzte ausgabe;{}PROC pruefe kanal (INT CONST kanalnummer, gewuenschte betriebsart):{}  pruefe abbruch;{}  pruefe kanalnummer;{}  pruefe betriebsart.{}  pruefe kanalnummer:{}    IF kanalnummer < 1 OR kanalnummer > max kanalanzahl{}       THEN errorstop ("Kanalnummer " + text (kanalnummer) +{}
-                        " ist unzulaessig !"){}    FI.{}  pruefe betriebsart:{}    IF gewuenschte betriebsart <> kanal [kanalnummer].betriebsart{}       THEN errorstop ("An Kanal " + text (kanalnummer) +{}                          " keine " +  wunsch + " moeglich!"){}    FI.{}  wunsch:{}    IF   gewuenschte betriebsart = analog aus{}         THEN "Analog-Ausgabe"{}    ELIF gewuenschte betriebsart = digital aus{}         THEN "Digital-Ausgabe"{}    ELIF gewuenschte betriebsart = digital ein{}         THEN "Digital-Eingabe"{}
-    ELIF gewuenschte betriebsart = analog ein{}         THEN "Analog-Eingabe"{}         ELSE "Ein- oder Ausgabe"{}    FI.{}END PROC pruefe kanal;{}PROC pruefe abbruch:{}  IF incharety = esc{}     THEN pruefe weiter{}  FI.{}  pruefe weiter:{}    TEXT CONST zeichen :: incharety (30);{}    IF   zeichen = endezeichen{}         THEN endezeichen gegeben := TRUE{}    ELIF zeichen = abbruchzeichen{}         THEN errorstop ("Programm-Abbruch durch <ESC><"{}                             + abbruchzeichen + ">!"){}
-    FI.{}END PROC pruefe abbruch;{}PROC oeffne interface (INT VAR status):{}  enable stop;{}  forget (ds); ds := nilspace;{}  IF kanaldaten sind eingetragen{}     THEN pingpong (interfacetask, initcode, ds, status){}     ELSE status := configuration error code{}  FI;{}  IF status > 0 THEN status DECR maxint FI;{}  forget (ds); ds := nilspace{}END PROC oeffne interface;{}PROC schliesse interface:{}  enable stop;{}  forget (ds); ds := nilspace;{}  pingpong (interface task, end code, ds, dummy);{}  forget (ds); ds := nilspace{}
-END PROC schliesse interface;{}PROC teste interface:{}  INT VAR test;{}  oeffne interface (test);{}  IF test < 0{}     THEN errorstop (fehlermeldung [min (5, abs (test))]){}     ELSE fehler zu melden           := FALSE;{}          endezeichen gegeben        := FALSE{}  FI{}END PROC teste interface;{}PROC fehlerbehandlung:{}  meldung := errormessage;{}  IF meldung <> ""{}     THEN meldung CAT fehlerzeile;{}          fehler zu melden := TRUE{}  FI;{}  clear error;{}  initialisiere interface.{}  fehlerzeile:{}
-    IF errorline = 0{}       THEN ""{}       ELSE " (bei Zeile " + text (errorline) + ")"{}    FI.{}END PROC fehlerbehandlung;{}(********************  EIN-/AUSGABE AM INTERFACE-KANAL ********************){}PROC kanalkoppler:{}  IF name (myself) <> "-"{}     THEN errorstop ("Unzulässiges Kommando!"){}     ELSE warte auf anrufe{}  FI.{}  warte auf anrufe:{}    TASK      VAR absender;{}    TEXT      VAR dummy;{}    INT       VAR codenummer, antwort;{}    disable stop;{}    REP forget (ds);{}        wait (ds, codenummer, absender);{}
-        IF codenummer = initcode{}           THEN kopple an interface kanal;{}                IF interface ist betriebsbereit{}                   THEN bearbeite weitere auftraege{}                   ELSE gib negative rueckmeldung{}                FI;{}                gib kanal frei{}           ELSE antwort := not init code;{}                gib negative rueckmeldung{}        FI{}    PER.{} kopple an interface kanal:{}  continue (interface channel);{}  IF is error{}     THEN clear error;{}          antwort := kanal besetzt code{}
-     ELSE oeffne interface direkt (antwort){}  FI.{} interface ist betriebsbereit:  antwort = 0.{} gib negative rueckmeldung:     send (absender, antwort, ds).{} gib kanal frei:{}   break (quiet);{}   send  (absender, 0, ds, antwort);{}   collect heap garbage.{} bearbeite weitere auftraege:{}   REP   call (absender, antwort, ds, codenummer);{}         IF   codenummer > 255{}              THEN sende wert an interface{}         ELIF codenummer <  50{}              THEN hole wert von interface{}         ELIF codenummer = alles aus code{}
-              THEN initialisiere interface direkt{}         FI{}   UNTIL codenummer = endcode PER;{}   IF is error THEN clear error FI;{}   schliesse interface direkt.{}  sende wert an interface:{}    out (kanal [codenummer DIV 256].steuercode);{}    out (code (codenummer)).{}  hole wert von interface:{}    out (kanal [codenummer].steuercode);{}    SELECT kanal [codenummer].taktzahl OF{}      CASE 1 :  antwort := erstes  zeichen{}      CASE 2 :  antwort := zweites zeichen{}      CASE 3 :  antwort := drittes zeichen{}
-      OTHERWISE antwort := -1{}    END SELECT.{}    erstes zeichen:{}      code (incharety (1)).{}    zweites zeichen:{}      dummy := incharety (1);{}      code (incharety (1)).{}    drittes zeichen:{}      dummy := incharety (1);{}      dummy := incharety (1);{}      code (incharety (1)).{}END PROC kanalkoppler;{}PROC interface kanal (INT CONST kanalnummer):{}  enable stop;{}  IF kanalnummer < 1 OR kanalnummer > 24{}     THEN errorstop ("Unzulaessige Kanalnummer"){}     ELSE interface channel := kanalnummer{}
-  FI{}END PROC interface kanal;{}INT PROC interface kanal:{}  interface channel{}END PROC interface kanal;{}PROC oeffne interface direkt (INT VAR status):{}  leere puffer;{}  out (interface test code);{}  IF antwort <> ""{}     THEN status := 0;{}          out (interface open code){}     ELSE status := interface error code{}  FI.{}  leere puffer:{}    REP  UNTIL incharety = "" PER.{}  antwort: incharety (1).{}END PROC oeffne interface direkt;{}PROC schliesse interface direkt:{}  out (interface close code){}
-END PROC schliesse interface direkt;{}PROC initialisiere interface direkt:{}  schalte alles aus.{}  schalte alles aus:{}    INT VAR kanalnummer, kanalbetriebsart;{}    FOR kanalnummer FROM 1 UPTO max kanalanzahl REP{}        kanalbetriebsart := kanal [kanalnummer].betriebsart;{}        IF   kanalbetriebsart = digital aus{}             THEN direkt ausgeben (kanalnummer, 0){}        ELIF kanalbetriebsart = analog aus{}             THEN direkt ausgeben (kanalnummer, gewandelte nullspannung){}        FI{}
-    PER.{}  gewandelte nullspannung:{}    int(- real (ganzzahl obergrenze) * u min / (u max - u min) + 0.5).{}    u max :  spannung [kanalnummer].maximalwert.{}    u min :  spannung [kanalnummer].minimalwert.{}END PROC initialisiere interface direkt;{}PROC direkt ausgeben (INT CONST kanalnummer, wert):{} out (kanal [kanalnummer].steuercode);{} out (code (wert)){}END PROC direkt ausgeben;{}INT PROC direkt eingabe (INT CONST kanalnummer):{}  gib lesecode aus;{}  erhaltene antwort.{}  gib lesecode aus:{}
-    out (kanal [kanalnummer].steuercode).{}  erhaltene antwort:{}    TEXT VAR dummy;{}    SELECT kanal [kanalnummer].taktzahl OF{}      CASE 1 :  erstes  zeichen{}      CASE 2 :  zweites zeichen{}      CASE 3 :  drittes zeichen{}      OTHERWISE -1{}    END SELECT.{}    erstes zeichen:{}      code (incharety (1)).{}    zweites zeichen:{}      dummy := incharety (1);{}      code (incharety (1)).{}    drittes zeichen:{}      dummy := incharety (1);{}      dummy := incharety (1);{}      code (incharety (1)).{}
-END PROC direkt eingabe;{}PROC initialisiere die kanaele:{}  INT VAR kanalnummer;{}  FOR kanalnummer FROM 1 UPTO max kanalanzahl REP{}      trage kanaldaten ein (kanalnummer, keine spannung, leere karte);{}      vorherige ausgabe [kanalnummer] := 0{}  PER.{}  keine spannung:{}    ROW 2 REAL : (0.0, 0.0).{}  leere karte:{}    ROW 3 INT : (nicht belegt, 0, 0).{}END PROC initialisiere die kanaele;{}initialisiere die kanaele;{}END PACKET ls prozess 1{}
+       run pdv,
+       run pdv again,
+       initialisiere interface,
+       schalte alles aus,
+       ausgeben,
+       eingabe,
+       warte,
+       abbruch gewuenscht,
+       tue nichts,
+       trage kanaldaten ein,
+       beende kanaldaten eintragen,
+       hole spannungsbereich,
+       letzte ausgabe,
+       pruefe kanal,
+       pruefe abbruch,
+       teste interface,
+       oeffne interface,
+       schliesse interface,
+       nicht belegt,
+       digital aus,
+       analog aus,
+
+       digital ein,
+       analog ein,
+       kanalbreite,
+       ganzzahl obergrenze,
+       adapterart,
+    (* ------------------------- *)
+       kanalkoppler,
+       interface kanal,
+       oeffne interface direkt,
+       schliesse interface direkt,
+       initialisiere interface direkt,
+       direkt ausgeben,
+       direkt eingabe:
+(******** A N P A S S U N G  A N  A K T R O N I C - A D A P T E R ********)
+LET interface test  code = ""240"",
+    interface open  code = ""176"",
+
+    interface close code = ""176"",
+    adresse 0 code       = ""176"",
+    interface write code =    64  ,
+    interface read  code =   192  ;
+TEXT CONST adapterart :: "AKTRONIC-Adapter";
+TEXT PROC interface anpassung (INT CONST kanalnummer, steuerungscode):
+  IF   es ist ein ausgabekanal
+       THEN code (interface write code + device + faktor * steuerungscode)
+  ELIF es ist ein eingabekanal
+       THEN lesecode in abhaengigkeit von der taktzahl
+       ELSE ""
+  FI.
+  es ist ein ausgabekanal:
+
+    kanal [kanalnummer].betriebsart < 0.
+  es ist ein eingabekanal:
+    kanal [kanalnummer].betriebsart > 0.
+  device:
+    IF steckplatznummer < 3
+       THEN 16
+       ELSE 32
+    FI.
+  faktor:
+    IF steckplatznummer MOD 2 = 0
+       THEN 4
+       ELSE 1
+    FI.
+  steckplatznummer:
+    IF kanalnummer < 10
+       THEN 1
+       ELSE kanalnummer DIV 10
+    FI.
+  lesecode in abhaengigkeit von der taktzahl:
+    SELECT kanal [kanalnummer].taktzahl OF
+      CASE 1: code fuer digital oder analog eingang
+
+      CASE 2: code fuer kombi e1
+      CASE 3: code fuer kombi e2
+    OTHERWISE "" END SELECT.
+  code fuer digital oder analog eingang:
+    IF kanal [kanalnummer].betriebsart = analog ein
+       THEN kanal [kanalnummer].taktzahl := 2;  (* ad wandler muss hier *)
+            lesecode + lesecode                 (* 2x gelesen werden!   *)
+       ELSE lesecode
+    FI.
+  lesecode  :  code (interface read code + device + faktor * steuerungscode).
+  code fuer kombi e1:
+    kanal [kanalnummer].taktzahl INCR 1; (* bei Analogport1 der Kombikarte *)
+
+    adresse 0 code + (3 * lesecode).     (* sind hier 3 Takte     noetig ! *)
+  code fuer kombi e2:
+    kanal [kanalnummer].taktzahl DECR 1;     (* hier nur 2 Takte noetig ! *)
+    adresse 0 code + lesecode + lesecode.
+END PROC interface anpassung;
+(************ H A R D W A R E U N A B H Ä N G I G E R  T E I L ************)
+LET       max kanalanzahl          =   49,
+          initcode                 =   50,
+          endcode                  =   51,
+          alles aus code           =   52,
+
+          endezeichen              =  "q",
+          abbruchzeichen           =  "h",
+          esc                      =  ""27"";
+INT CONST analog aus               ::  -2,            (* Betriebsarten *)
+          digital aus              ::  -1,
+          nicht belegt             ::   0,
+          digital ein              ::   1,
+          analog  ein              ::   2,
+          kanalbreite              ::   8,
+          ganzzahl obergrenze      ::   2 ** kanalbreite,
+          configuration error code ::  -1,
+
+          kanal besetzt code       ::  -3,
+          interface error code     ::  -4,
+          not init code            ::  -5;
+INT VAR   interfacechannel         ::   2,
+          dummy;
+TEXT VAR  meldung                  ::  "";
+BOOL VAR  kanaldaten sind eingetragen :: FALSE,
+          endezeichen gegeben         :: FALSE,
+          programm mit pdv gestartet  :: FALSE,
+          fehler zu melden            :: FALSE;
+TASK VAR  interface task              :: niltask;
+DATASPACE VAR  ds :: nilspace;
+
+TYPE KANAL     = STRUCT (INT  betriebsart, taktzahl, TEXT steuercode),
+     SPANNUNG  = STRUCT (REAL minimalwert, maximalwert);
+ROW max kanalanzahl INT      VAR vorherige ausgabe;
+ROW max kanalanzahl KANAL    VAR kanal;
+ROW max kanalanzahl SPANNUNG VAR spannung;
+ROW 5 TEXT CONST fehlermeldung :: ROW 5 TEXT :
+  ("Interface ist noch nicht konfiguriert!",
+   "Interface-Task ist besetzt!",
+   "Interface-Kanal ist belegt!",
+   "Interface meldet sich nicht!",
+   "Interface kann nicht geöffnet werden!");
+
+PROC run pdv:
+  run pdv (last param)
+END PROC run pdv;
+PROC run pdv (TEXT CONST programmname):
+  enable stop;
+  last param (programmname);
+  programm mit pdv gestartet := TRUE;
+  teste interface;
+  disable stop;
+  run (programmname);
+  IF is error
+     THEN fehlerbehandlung
+     ELSE melde programmende
+  FI;
+  schliesse interface;
+  programm mit pdv gestartet := FALSE;
+  enable stop;
+  IF fehler zu melden
+     THEN errorstop (meldung)
+  FI
+END PROC run pdv;
+PROC run pdv again:
+
+  enable stop;
+  programm mit pdv gestartet := TRUE;
+  teste interface;
+  disable stop;
+  run again;
+  IF is error
+     THEN fehlerbehandlung
+     ELSE melde programmende
+  FI;
+  schliesse interface;
+  programm mit pdv gestartet := FALSE;
+  enable stop;
+  IF fehler zu melden
+     THEN errorstop (meldung)
+  FI
+END PROC run pdv again;
+PROC melde programmende:
+  page;
+  menufootnote ("Programmende! Zum Weitermachen bitte irgendeine Taste tippen.");
+  pause;
+  schalte alles aus
+END PROC melde programmende;
+
+PROC initialisiere interface:
+  enable stop;
+  pruefe abbruch;
+  IF programm mit pdv gestartet
+     THEN schalte alles aus
+     ELSE errorstop ("PDV-Programme müssen mit 'run pdv' gestartet werden!")
+  FI
+END PROC initialisiere interface;
+PROC schalte alles aus:
+  INT VAR k;
+  FOR k FROM 1 UPTO max kanalanzahl REP
+    vorherige ausgabe [k] := 0
+  PER;
+  forget (ds); ds := nilspace;
+  call (interface task, alles aus code, ds, dummy)
+END PROC schalte alles aus;
+PROC ausgeben (INT CONST kanalnummer, wert):
+
+  merke wert;
+  gib wert aus.
+  merke wert:
+    vorherige ausgabe [kanalnummer] := wert.
+  gib wert aus:
+    call (interface task, 256 * kanalnummer + wert, ds, dummy).
+END PROC ausgeben;
+INT PROC eingabe (INT CONST kanalnummer):
+  INT VAR eingabewert;
+  call (interface task, kanalnummer, ds, eingabewert);
+  eingabewert
+END PROC eingabe;
+PROC warte (REAL CONST sekunden):
+  TEXT VAR eingabe;
+  pruefe abbruch;
+  eingabe := incharety (int (sekunden * 10.0 + 0.5));
+  IF eingabe = esc
+
+     THEN untersuche naechstes zeichen
+  FI.
+  untersuche naechstes zeichen:
+    eingabe := incharety (30);
+    IF   eingabe = endezeichen
+         THEN endezeichen gegeben := TRUE
+    ELIF eingabe = abbruchzeichen
+         THEN errorstop ("Programm-Abbruch durch <ESC><"
+                             + abbruchzeichen + ">!")
+    FI.
+END PROC warte;
+PROC warte (INT CONST sekunden):
+  TEXT VAR eingabe;
+  pruefe abbruch;
+  eingabe := incharety (sekunden * 10);
+  IF eingabe = esc
+     THEN untersuche naechstes zeichen
+
+  FI.
+  untersuche naechstes zeichen:
+    eingabe := incharety (30);
+    IF   eingabe = endezeichen
+         THEN endezeichen gegeben := TRUE
+    ELIF eingabe = abbruchzeichen
+         THEN errorstop ("Programm-Abbruch durch <ESC><"
+                             + abbruchzeichen + ">!")
+    FI.
+END PROC warte;
+BOOL PROC abbruch gewuenscht:
+  pruefe abbruch;
+  BOOL VAR entscheidung :: endezeichen gegeben;
+  endezeichen gegeben := FALSE;
+  entscheidung
+END PROC abbruch gewuenscht;
+PROC tue nichts:
+
+  pruefe abbruch
+END PROC tue nichts;
+PROC trage kanaldaten ein (INT CONST  kanalnummer,
+                           ROW 2 REAL CONST spannungsbereich,
+                           ROW 3 INT  CONST kanalparameter):
+   spannung [kanalnummer].minimalwert := spannungsbereich [1];
+   spannung [kanalnummer].maximalwert := spannungsbereich [2];
+   kanal [kanalnummer].betriebsart    := kanalparameter   [1];
+   kanal [kanalnummer].taktzahl       := kanalparameter   [2];
+   kanal [kanalnummer].steuercode     := interface anpassung
+
+                                         (kanalnummer, kanalparameter [3])
+END PROC trage kanaldaten ein;
+PROC beende kanaldaten eintragen:
+  loesche interface task;
+  begin (PROC kanal koppler, interface task);
+  kanaldaten sind eingetragen := TRUE.
+  loesche interface task:
+    disable stop;
+    end (interface task);
+    IF is error
+       THEN clear error
+    FI;
+    enable stop.
+END PROC beende kanaldaten eintragen;
+PROC hole spannungsbereich (INT CONST kanalnummer, REAL VAR  u min, u max):
+
+  u min := spannung [kanalnummer].minimalwert;
+  u max := spannung [kanalnummer].maximalwert
+END PROC hole spannungsbereich;
+INT PROC letzte ausgabe (INT CONST kanalnummer):
+  vorherige ausgabe [kanalnummer]
+END PROC letzte ausgabe;
+PROC pruefe kanal (INT CONST kanalnummer, gewuenschte betriebsart):
+  pruefe abbruch;
+  pruefe kanalnummer;
+  pruefe betriebsart.
+  pruefe kanalnummer:
+    IF kanalnummer < 1 OR kanalnummer > max kanalanzahl
+       THEN errorstop ("Kanalnummer " + text (kanalnummer) +
+
+                        " ist unzulaessig !")
+    FI.
+  pruefe betriebsart:
+    IF gewuenschte betriebsart <> kanal [kanalnummer].betriebsart
+       THEN errorstop ("An Kanal " + text (kanalnummer) +
+                          " keine " +  wunsch + " moeglich!")
+    FI.
+  wunsch:
+    IF   gewuenschte betriebsart = analog aus
+         THEN "Analog-Ausgabe"
+    ELIF gewuenschte betriebsart = digital aus
+         THEN "Digital-Ausgabe"
+    ELIF gewuenschte betriebsart = digital ein
+         THEN "Digital-Eingabe"
+
+    ELIF gewuenschte betriebsart = analog ein
+         THEN "Analog-Eingabe"
+         ELSE "Ein- oder Ausgabe"
+    FI.
+END PROC pruefe kanal;
+PROC pruefe abbruch:
+  IF incharety = esc
+     THEN pruefe weiter
+  FI.
+  pruefe weiter:
+    TEXT CONST zeichen :: incharety (30);
+    IF   zeichen = endezeichen
+         THEN endezeichen gegeben := TRUE
+    ELIF zeichen = abbruchzeichen
+         THEN errorstop ("Programm-Abbruch durch <ESC><"
+                             + abbruchzeichen + ">!")
+
+    FI.
+END PROC pruefe abbruch;
+PROC oeffne interface (INT VAR status):
+  enable stop;
+  forget (ds); ds := nilspace;
+  IF kanaldaten sind eingetragen
+     THEN pingpong (interfacetask, initcode, ds, status)
+     ELSE status := configuration error code
+  FI;
+  IF status > 0 THEN status DECR maxint FI;
+  forget (ds); ds := nilspace
+END PROC oeffne interface;
+PROC schliesse interface:
+  enable stop;
+  forget (ds); ds := nilspace;
+  pingpong (interface task, end code, ds, dummy);
+  forget (ds); ds := nilspace
+
+END PROC schliesse interface;
+PROC teste interface:
+  INT VAR test;
+  oeffne interface (test);
+  IF test < 0
+     THEN errorstop (fehlermeldung [min (5, abs (test))])
+     ELSE fehler zu melden           := FALSE;
+          endezeichen gegeben        := FALSE
+  FI
+END PROC teste interface;
+PROC fehlerbehandlung:
+  meldung := errormessage;
+  IF meldung <> ""
+     THEN meldung CAT fehlerzeile;
+          fehler zu melden := TRUE
+  FI;
+  clear error;
+  initialisiere interface.
+  fehlerzeile:
+
+    IF errorline = 0
+       THEN ""
+       ELSE " (bei Zeile " + text (errorline) + ")"
+    FI.
+END PROC fehlerbehandlung;
+(********************  EIN-/AUSGABE AM INTERFACE-KANAL ********************)
+PROC kanalkoppler:
+  IF name (myself) <> "-"
+     THEN errorstop ("Unzulässiges Kommando!")
+     ELSE warte auf anrufe
+  FI.
+  warte auf anrufe:
+    TASK      VAR absender;
+    TEXT      VAR dummy;
+    INT       VAR codenummer, antwort;
+    disable stop;
+    REP forget (ds);
+        wait (ds, codenummer, absender);
+
+        IF codenummer = initcode
+           THEN kopple an interface kanal;
+                IF interface ist betriebsbereit
+                   THEN bearbeite weitere auftraege
+                   ELSE gib negative rueckmeldung
+                FI;
+                gib kanal frei
+           ELSE antwort := not init code;
+                gib negative rueckmeldung
+        FI
+    PER.
+ kopple an interface kanal:
+  continue (interface channel);
+  IF is error
+     THEN clear error;
+          antwort := kanal besetzt code
+
+     ELSE oeffne interface direkt (antwort)
+  FI.
+ interface ist betriebsbereit:  antwort = 0.
+ gib negative rueckmeldung:     send (absender, antwort, ds).
+ gib kanal frei:
+   break (quiet);
+   send  (absender, 0, ds, antwort);
+   collect heap garbage.
+ bearbeite weitere auftraege:
+   REP   call (absender, antwort, ds, codenummer);
+         IF   codenummer > 255
+              THEN sende wert an interface
+         ELIF codenummer <  50
+              THEN hole wert von interface
+         ELIF codenummer = alles aus code
+
+              THEN initialisiere interface direkt
+         FI
+   UNTIL codenummer = endcode PER;
+   IF is error THEN clear error FI;
+   schliesse interface direkt.
+  sende wert an interface:
+    out (kanal [codenummer DIV 256].steuercode);
+    out (code (codenummer)).
+  hole wert von interface:
+    out (kanal [codenummer].steuercode);
+    SELECT kanal [codenummer].taktzahl OF
+      CASE 1 :  antwort := erstes  zeichen
+      CASE 2 :  antwort := zweites zeichen
+      CASE 3 :  antwort := drittes zeichen
+
+      OTHERWISE antwort := -1
+    END SELECT.
+    erstes zeichen:
+      code (incharety (1)).
+    zweites zeichen:
+      dummy := incharety (1);
+      code (incharety (1)).
+    drittes zeichen:
+      dummy := incharety (1);
+      dummy := incharety (1);
+      code (incharety (1)).
+END PROC kanalkoppler;
+PROC interface kanal (INT CONST kanalnummer):
+  enable stop;
+  IF kanalnummer < 1 OR kanalnummer > 24
+     THEN errorstop ("Unzulaessige Kanalnummer")
+     ELSE interface channel := kanalnummer
+
+  FI
+END PROC interface kanal;
+INT PROC interface kanal:
+  interface channel
+END PROC interface kanal;
+PROC oeffne interface direkt (INT VAR status):
+  leere puffer;
+  out (interface test code);
+  IF antwort <> ""
+     THEN status := 0;
+          out (interface open code)
+     ELSE status := interface error code
+  FI.
+  leere puffer:
+    REP  UNTIL incharety = "" PER.
+  antwort: incharety (1).
+END PROC oeffne interface direkt;
+PROC schliesse interface direkt:
+  out (interface close code)
+
+END PROC schliesse interface direkt;
+PROC initialisiere interface direkt:
+  schalte alles aus.
+  schalte alles aus:
+    INT VAR kanalnummer, kanalbetriebsart;
+    FOR kanalnummer FROM 1 UPTO max kanalanzahl REP
+        kanalbetriebsart := kanal [kanalnummer].betriebsart;
+        IF   kanalbetriebsart = digital aus
+             THEN direkt ausgeben (kanalnummer, 0)
+        ELIF kanalbetriebsart = analog aus
+             THEN direkt ausgeben (kanalnummer, gewandelte nullspannung)
+        FI
+
+    PER.
+  gewandelte nullspannung:
+    int(- real (ganzzahl obergrenze) * u min / (u max - u min) + 0.5).
+    u max :  spannung [kanalnummer].maximalwert.
+    u min :  spannung [kanalnummer].minimalwert.
+END PROC initialisiere interface direkt;
+PROC direkt ausgeben (INT CONST kanalnummer, wert):
+ out (kanal [kanalnummer].steuercode);
+ out (code (wert))
+END PROC direkt ausgeben;
+INT PROC direkt eingabe (INT CONST kanalnummer):
+  gib lesecode aus;
+  erhaltene antwort.
+  gib lesecode aus:
+
+    out (kanal [kanalnummer].steuercode).
+  erhaltene antwort:
+    TEXT VAR dummy;
+    SELECT kanal [kanalnummer].taktzahl OF
+      CASE 1 :  erstes  zeichen
+      CASE 2 :  zweites zeichen
+      CASE 3 :  drittes zeichen
+      OTHERWISE -1
+    END SELECT.
+    erstes zeichen:
+      code (incharety (1)).
+    zweites zeichen:
+      dummy := incharety (1);
+      code (incharety (1)).
+    drittes zeichen:
+      dummy := incharety (1);
+      dummy := incharety (1);
+      code (incharety (1)).
+
+END PROC direkt eingabe;
+PROC initialisiere die kanaele:
+  INT VAR kanalnummer;
+  FOR kanalnummer FROM 1 UPTO max kanalanzahl REP
+      trage kanaldaten ein (kanalnummer, keine spannung, leere karte);
+      vorherige ausgabe [kanalnummer] := 0
+  PER.
+  keine spannung:
+    ROW 2 REAL : (0.0, 0.0).
+  leere karte:
+    ROW 3 INT : (nicht belegt, 0, 0).
+END PROC initialisiere die kanaele;
+initialisiere die kanaele;
+END PACKET ls prozess 1
+
 
diff --git a/prozess/ls-Prozess 1 für MUFI als Endgerät b/prozess/ls-Prozess 1 für MUFI als Endgerät
index 4d2a5f4..3408230 100644
--- a/prozess/ls-Prozess 1 für MUFI als Endgerät
+++ b/prozess/ls-Prozess 1 für MUFI als Endgerät
@@ -22,36 +22,529 @@
  
                                                                            *) 
 PACKET ls prozess 1 DEFINES 
-       run pdv,{}       run pdv again,{}       initialisiere interface,{}       schalte alles aus,{}       ausgeben,{}       eingabe,{}       warte,{}       abbruch gewuenscht,{}       tue nichts,{}       trage kanaldaten ein,{}       beende kanaldaten eintragen,{}       hole spannungsbereich,{}       letzte ausgabe,{}       pruefe kanal,{}       pruefe abbruch,{}       teste interface,{}       oeffne interface,{}       schliesse interface,{}       nicht belegt,{}       digital aus,{}       analog aus,{}
-       digital ein,{}       analog ein,{}       kanalbreite,{}       ganzzahl obergrenze,{}       adapterart,{}    (* ------------------------- *){}       kanalkoppler,{}       interface kanal,{}       oeffne interface direkt,{}       schliesse interface direkt,{}       initialisiere interface direkt,{}       direkt ausgeben,{}       direkt eingabe:{}(******************** A N P A S S U N G  A N  M U F I ********************){}LET interface test  code = ""27""27"10",{}    interface okay  code = ""27""27"00",{}
-    interface open  code = ""27""27"1A18",{}    interface close code = ""25""27""27"13",{}    adresse 0 code       = ""61"",{}    leertakt  code       = ""62"",{}    interface write code =   80  ,{}    interface read  code =   64  ,{}    erwartete zeichen    =    4  ;{}TEXT CONST adapterart   :: "MUFI als Endgerät";{}TEXT PROC interface anpassung (INT CONST kanalnummer, steuerungscode):{}  IF   es ist ein ausgabekanal{}       THEN code (interface write code + device + 4 * steuerungscode){}  ELIF es ist ein eingabekanal{}
-       THEN lesecode in abhaengigkeit von der taktzahl{}       ELSE ""{}  FI.{}  es ist ein ausgabekanal:{}    kanal [kanalnummer].betriebsart < 0.{}  es ist ein eingabekanal:{}    kanal [kanalnummer].betriebsart > 0.{}  device:{}    IF kanalnummer < 10{}       THEN 0{}       ELSE kanalnummer DIV 10  -  1{}    FI.{}  lesecode in abhaengigkeit von der taktzahl:{}    SELECT kanal [kanalnummer].taktzahl OF{}      CASE 1: lesecode{}      CASE 2: adresse 0 code + lesecode + lesecode{}      CASE 3: adresse 0 code + lesecode + zwei weitere takte{}
-    OTHERWISE "" END SELECT.{}  lesecode  :  code (interface read code + device + 4 * steuerungscode).{}  zwei weitere takte:{}    IF leertakt code = ""{}       THEN lesecode + lesecode{}       ELSE kanal [kanalnummer].taktzahl DECR 1;{}            leertakt code + lesecode{}    FI.{}END PROC interface anpassung;{}(************ H A R D W A R E U N A B H Ä N G I G E R  T E I L ************){}LET       max kanalanzahl          =   49,{}          initcode                 =   50,{}          endcode                  =   51,{}
-          alles aus code           =   52,{}          endezeichen              =  "q",{}          abbruchzeichen           =  "h",{}          esc                      =  ""27"";{}INT CONST analog aus               ::  -2,            (* Betriebsarten *){}          digital aus              ::  -1,{}          nicht belegt             ::   0,{}          digital ein              ::   1,{}          analog  ein              ::   2,{}          kanalbreite              ::   8,{}          ganzzahl obergrenze      ::   2 ** kanalbreite,{}
-          configuration error code ::  -1,{}          kanal besetzt code       ::  -3,{}          interface error code     ::  -4,{}          not init code            ::  -5;{}INT VAR   interfacechannel         ::   2,{}          dummy;{}TEXT VAR  meldung                  ::  "";{}BOOL VAR  kanaldaten sind eingetragen :: FALSE,{}          endezeichen gegeben         :: FALSE,{}          programm mit pdv gestartet  :: FALSE,{}          fehler zu melden            :: FALSE;{}TASK VAR  interface task              :: niltask;{}
-DATASPACE VAR  ds :: nilspace;{}TYPE KANAL     = STRUCT (INT  betriebsart, taktzahl, TEXT steuercode),{}     SPANNUNG  = STRUCT (REAL minimalwert, maximalwert);{}ROW max kanalanzahl INT      VAR vorherige ausgabe;{}ROW max kanalanzahl KANAL    VAR kanal;{}ROW max kanalanzahl SPANNUNG VAR spannung;{}ROW 5 TEXT CONST fehlermeldung :: ROW 5 TEXT :{}  ("Interface ist noch nicht konfiguriert!",{}   "Interface-Task ist besetzt!",{}   "Interface-Kanal ist belegt!",{}   "Interface meldet sich nicht!",{}   "Interface kann nicht geöffnet werden!");{}
-PROC run pdv:{}  run pdv (last param){}END PROC run pdv;{}PROC run pdv (TEXT CONST programmname):{}  enable stop;{}  last param (programmname);{}  programm mit pdv gestartet := TRUE;{}  teste interface;{}  disable stop;{}  run (programmname);{}  IF is error{}     THEN fehlerbehandlung{}     ELSE melde programmende{}  FI;{}  schliesse interface;{}  programm mit pdv gestartet := FALSE;{}  enable stop;{}  IF fehler zu melden{}     THEN errorstop (meldung){}  FI{}END PROC run pdv;{}PROC run pdv again:{}
-  enable stop;{}  programm mit pdv gestartet := TRUE;{}  teste interface;{}  disable stop;{}  run again;{}  IF is error{}     THEN fehlerbehandlung{}     ELSE melde programmende{}  FI;{}  schliesse interface;{}  programm mit pdv gestartet := FALSE;{}  enable stop;{}  IF fehler zu melden{}     THEN errorstop (meldung){}  FI{}END PROC run pdv again;{}PROC melde programmende:{}  page;{}  menufootnote ("Programmende! Zum Weitermachen bitte irgendeine Taste tippen.");{}  pause;{}  schalte alles aus{}END PROC melde programmende;{}
-PROC initialisiere interface:{}  enable stop;{}  pruefe abbruch;{}  IF programm mit pdv gestartet{}     THEN schalte alles aus{}     ELSE errorstop ("PDV-Programme müssen mit 'run pdv' gestartet werden!"){}  FI{}END PROC initialisiere interface;{}PROC schalte alles aus:{}  INT VAR k;{}  FOR k FROM 1 UPTO max kanalanzahl REP{}    vorherige ausgabe [k] := 0{}  PER;{}  forget (ds); ds := nilspace;{}  call (interface task, alles aus code, ds, dummy){}END PROC schalte alles aus;{}PROC ausgeben (INT CONST kanalnummer, wert):{}
-  merke wert;{}  gib wert aus.{}  merke wert:{}    vorherige ausgabe [kanalnummer] := wert.{}  gib wert aus:{}    call (interface task, 256 * kanalnummer + wert, ds, dummy).{}END PROC ausgeben;{}INT PROC eingabe (INT CONST kanalnummer):{}  INT VAR eingabewert;{}  call (interface task, kanalnummer, ds, eingabewert);{}  eingabewert{}END PROC eingabe;{}PROC warte (REAL CONST sekunden):{}  TEXT VAR eingabe;{}  pruefe abbruch;{}  eingabe := incharety (int (sekunden * 10.0 + 0.5));{}  IF eingabe = esc{}
-     THEN untersuche naechstes zeichen{}  FI.{}  untersuche naechstes zeichen:{}    eingabe := incharety (30);{}    IF   eingabe = endezeichen{}         THEN endezeichen gegeben := TRUE{}    ELIF eingabe = abbruchzeichen{}         THEN errorstop ("Programm-Abbruch durch <ESC><"{}                             + abbruchzeichen + ">!"){}    FI.{}END PROC warte;{}PROC warte (INT CONST sekunden):{}  TEXT VAR eingabe;{}  pruefe abbruch;{}  eingabe := incharety (sekunden * 10);{}  IF eingabe = esc{}     THEN untersuche naechstes zeichen{}
-  FI.{}  untersuche naechstes zeichen:{}    eingabe := incharety (30);{}    IF   eingabe = endezeichen{}         THEN endezeichen gegeben := TRUE{}    ELIF eingabe = abbruchzeichen{}         THEN errorstop ("Programm-Abbruch durch <ESC><"{}                             + abbruchzeichen + ">!"){}    FI.{}END PROC warte;{}BOOL PROC abbruch gewuenscht:{}  pruefe abbruch;{}  BOOL VAR entscheidung :: endezeichen gegeben;{}  endezeichen gegeben := FALSE;{}  entscheidung{}END PROC abbruch gewuenscht;{}PROC tue nichts:{}
-  pruefe abbruch{}END PROC tue nichts;{}PROC trage kanaldaten ein (INT CONST  kanalnummer,{}                           ROW 2 REAL CONST spannungsbereich,{}                           ROW 3 INT  CONST kanalparameter):{}   spannung [kanalnummer].minimalwert := spannungsbereich [1];{}   spannung [kanalnummer].maximalwert := spannungsbereich [2];{}   kanal [kanalnummer].betriebsart    := kanalparameter   [1];{}   kanal [kanalnummer].taktzahl       := kanalparameter   [2];{}   kanal [kanalnummer].steuercode     := interface anpassung{}
-                                         (kanalnummer, kanalparameter [3]){}END PROC trage kanaldaten ein;{}PROC beende kanaldaten eintragen:{}  loesche interface task;{}  begin (PROC kanal koppler, interface task);{}  kanaldaten sind eingetragen := TRUE.{}  loesche interface task:{}    disable stop;{}    end (interface task);{}    IF is error{}       THEN clear error{}    FI;{}    enable stop.{}END PROC beende kanaldaten eintragen;{}PROC hole spannungsbereich (INT CONST kanalnummer, REAL VAR  u min, u max):{}
-  u min := spannung [kanalnummer].minimalwert;{}  u max := spannung [kanalnummer].maximalwert{}END PROC hole spannungsbereich;{}INT PROC letzte ausgabe (INT CONST kanalnummer):{}  vorherige ausgabe [kanalnummer]{}END PROC letzte ausgabe;{}PROC pruefe kanal (INT CONST kanalnummer, gewuenschte betriebsart):{}  pruefe abbruch;{}  pruefe kanalnummer;{}  pruefe betriebsart.{}  pruefe kanalnummer:{}    IF kanalnummer < 1 OR kanalnummer > max kanalanzahl{}       THEN errorstop ("Kanalnummer " + text (kanalnummer) +{}
-                        " ist unzulaessig !"){}    FI.{}  pruefe betriebsart:{}    IF gewuenschte betriebsart <> kanal [kanalnummer].betriebsart{}       THEN errorstop ("An Kanal " + text (kanalnummer) +{}                          " keine " +  wunsch + " moeglich!"){}    FI.{}  wunsch:{}    IF   gewuenschte betriebsart = analog aus{}         THEN "Analog-Ausgabe"{}    ELIF gewuenschte betriebsart = digital aus{}         THEN "Digital-Ausgabe"{}    ELIF gewuenschte betriebsart = digital ein{}         THEN "Digital-Eingabe"{}
-    ELIF gewuenschte betriebsart = analog ein{}         THEN "Analog-Eingabe"{}         ELSE "Ein- oder Ausgabe"{}    FI.{}END PROC pruefe kanal;{}PROC pruefe abbruch:{}  IF incharety = esc{}     THEN pruefe weiter{}  FI.{}  pruefe weiter:{}    TEXT CONST zeichen :: incharety (30);{}    IF   zeichen = endezeichen{}         THEN endezeichen gegeben := TRUE{}    ELIF zeichen = abbruchzeichen{}         THEN errorstop ("Programm-Abbruch durch <ESC><"{}                             + abbruchzeichen + ">!"){}
-    FI.{}END PROC pruefe abbruch;{}PROC oeffne interface (INT VAR status):{}  enable stop;{}  forget (ds); ds := nilspace;{}  IF kanaldaten sind eingetragen{}     THEN pingpong (interfacetask, initcode, ds, status){}     ELSE status := configuration error code{}  FI;{}  IF status > 0 THEN status DECR maxint FI;{}  forget (ds); ds := nilspace{}END PROC oeffne interface;{}PROC schliesse interface:{}  enable stop;{}  forget (ds); ds := nilspace;{}  pingpong (interface task, end code, ds, dummy);{}  forget (ds); ds := nilspace{}
-END PROC schliesse interface;{}PROC teste interface:{}  INT VAR test;{}  oeffne interface (test);{}  IF test < 0{}     THEN errorstop (fehlermeldung [min (5, abs (test))]){}     ELSE fehler zu melden           := FALSE;{}          endezeichen gegeben        := FALSE{}  FI{}END PROC teste interface;{}PROC fehlerbehandlung:{}  meldung := errormessage;{}  IF meldung <> ""{}     THEN meldung CAT fehlerzeile;{}          fehler zu melden := TRUE{}  FI;{}  clear error;{}  initialisiere interface.{}  fehlerzeile:{}
-    IF errorline = 0{}       THEN ""{}       ELSE " (bei Zeile " + text (errorline) + ")"{}    FI.{}END PROC fehlerbehandlung;{}(********************  EIN-/AUSGABE AM INTERFACE-KANAL ********************){}PROC kanalkoppler:{}  IF name (myself) <> "-"{}     THEN errorstop ("Unzulässiges Kommando!"){}     ELSE warte auf anrufe{}  FI.{}  warte auf anrufe:{}    TASK      VAR absender;{}    TEXT      VAR dummy;{}    INT       VAR codenummer, antwort;{}    disable stop;{}    REP forget (ds);{}        wait (ds, codenummer, absender);{}
-        IF codenummer = initcode{}           THEN kopple an interface kanal;{}                IF interface ist betriebsbereit{}                   THEN bearbeite weitere auftraege{}                   ELSE gib negative rueckmeldung{}                FI;{}                gib kanal frei{}           ELSE antwort := not init code;{}                gib negative rueckmeldung{}        FI{}    PER.{} kopple an interface kanal:{}  continue (interface channel);{}  IF is error{}     THEN clear error;{}          antwort := kanal besetzt code{}
-     ELSE oeffne interface direkt (antwort){}  FI.{} interface ist betriebsbereit:  antwort = 0.{} gib negative rueckmeldung:     send (absender, antwort, ds).{} gib kanal frei:{}   break (quiet);{}   send  (absender, 0, ds, antwort);{}   collect heap garbage.{} bearbeite weitere auftraege:{}   REP   call (absender, antwort, ds, codenummer);{}         IF   codenummer > 255{}              THEN sende wert an interface{}         ELIF codenummer <  50{}              THEN hole wert von interface{}         ELIF codenummer = alles aus code{}
-              THEN initialisiere interface direkt{}         FI{}   UNTIL codenummer = endcode PER;{}   IF is error THEN clear error FI;{}   schliesse interface direkt.{}  sende wert an interface:{}    out (kanal [codenummer DIV 256].steuercode);{}    out (code (codenummer)).{}  hole wert von interface:{}    out (kanal [codenummer].steuercode);{}    SELECT kanal [codenummer].taktzahl OF{}      CASE 1 :  antwort := erstes  zeichen{}      CASE 2 :  antwort := zweites zeichen{}      CASE 3 :  antwort := drittes zeichen{}
-      OTHERWISE antwort := -1{}    END SELECT.{}    erstes zeichen:{}      code (incharety (1)).{}    zweites zeichen:{}      dummy := incharety (1);{}      code (incharety (1)).{}    drittes zeichen:{}      dummy := incharety (1);{}      dummy := incharety (1);{}      code (incharety (1)).{}END PROC kanalkoppler;{}PROC interface kanal (INT CONST kanalnummer):{}  enable stop;{}  IF kanalnummer < 1 OR kanalnummer > 24{}     THEN errorstop ("Unzulaessige Kanalnummer"){}     ELSE interface channel := kanalnummer{}
-  FI{}END PROC interface kanal;{}INT PROC interface kanal:{}  interface channel{}END PROC interface kanal;{}PROC oeffne interface direkt (INT VAR status):{}  leere puffer;{}  out (interface test code);{}  fange antwort;{}  IF antwort = interface okay code{}     THEN status := 0;{}          out (interface open code){}     ELSE status := interface error code{}  FI.{}  leere puffer:{}    REP  UNTIL incharety = "" PER.{}  fange antwort:{}    INT  VAR zaehler;{}    TEXT VAR antwort :: "";{}    FOR zaehler FROM 1 UPTO erwartete zeichen REP{}
-      antwort CAT incharety (1){}    PER.{}END PROC oeffne interface direkt;{}PROC schliesse interface direkt:{}  out (interface close code){}END PROC schliesse interface direkt;{}PROC initialisiere interface direkt:{}  schalte alles aus.{}  schalte alles aus:{}    INT VAR kanalnummer, kanalbetriebsart;{}    FOR kanalnummer FROM 1 UPTO max kanalanzahl REP{}        kanalbetriebsart := kanal [kanalnummer].betriebsart;{}        IF   kanalbetriebsart = digital aus{}             THEN direkt ausgeben (kanalnummer, 0){}
-        ELIF kanalbetriebsart = analog aus{}             THEN direkt ausgeben (kanalnummer, gewandelte nullspannung){}        FI{}    PER.{}  gewandelte nullspannung:{}    int(- real (ganzzahl obergrenze) * u min / (u max - u min) + 0.5).{}    u max :  spannung [kanalnummer].maximalwert.{}    u min :  spannung [kanalnummer].minimalwert.{}END PROC initialisiere interface direkt;{}PROC direkt ausgeben (INT CONST kanalnummer, wert):{} out (kanal [kanalnummer].steuercode);{} out (code (wert)){}END PROC direkt ausgeben;{}
-INT PROC direkt eingabe (INT CONST kanalnummer):{}  gib lesecode aus;{}  erhaltene antwort.{}  gib lesecode aus:{}    out (kanal [kanalnummer].steuercode).{}  erhaltene antwort:{}    TEXT VAR dummy;{}    SELECT kanal [kanalnummer].taktzahl OF{}      CASE 1 :  erstes  zeichen{}      CASE 2 :  zweites zeichen{}      CASE 3 :  drittes zeichen{}      OTHERWISE -1{}    END SELECT.{}    erstes zeichen:{}      code (incharety (1)).{}    zweites zeichen:{}      dummy := incharety (1);{}      code (incharety (1)).{}
-    drittes zeichen:{}      dummy := incharety (1);{}      dummy := incharety (1);{}      code (incharety (1)).{}END PROC direkt eingabe;{}PROC initialisiere die kanaele:{}  INT VAR kanalnummer;{}  FOR kanalnummer FROM 1 UPTO max kanalanzahl REP{}      trage kanaldaten ein (kanalnummer, keine spannung, leere karte);{}      vorherige ausgabe [kanalnummer] := 0{}  PER.{}  keine spannung:{}    ROW 2 REAL : (0.0, 0.0).{}  leere karte:{}    ROW 3 INT : (nicht belegt, 0, 0).{}END PROC initialisiere die kanaele;{}
-initialisiere die kanaele;{}END PACKET ls prozess 1{}
+       run pdv,
+       run pdv again,
+       initialisiere interface,
+       schalte alles aus,
+       ausgeben,
+       eingabe,
+       warte,
+       abbruch gewuenscht,
+       tue nichts,
+       trage kanaldaten ein,
+       beende kanaldaten eintragen,
+       hole spannungsbereich,
+       letzte ausgabe,
+       pruefe kanal,
+       pruefe abbruch,
+       teste interface,
+       oeffne interface,
+       schliesse interface,
+       nicht belegt,
+       digital aus,
+       analog aus,
+
+       digital ein,
+       analog ein,
+       kanalbreite,
+       ganzzahl obergrenze,
+       adapterart,
+    (* ------------------------- *)
+       kanalkoppler,
+       interface kanal,
+       oeffne interface direkt,
+       schliesse interface direkt,
+       initialisiere interface direkt,
+       direkt ausgeben,
+       direkt eingabe:
+(******************** A N P A S S U N G  A N  M U F I ********************)
+LET interface test  code = ""27""27"10",
+    interface okay  code = ""27""27"00",
+
+    interface open  code = ""27""27"1A18",
+    interface close code = ""25""27""27"13",
+    adresse 0 code       = ""61"",
+    leertakt  code       = ""62"",
+    interface write code =   80  ,
+    interface read  code =   64  ,
+    erwartete zeichen    =    4  ;
+TEXT CONST adapterart   :: "MUFI als Endgerät";
+TEXT PROC interface anpassung (INT CONST kanalnummer, steuerungscode):
+  IF   es ist ein ausgabekanal
+       THEN code (interface write code + device + 4 * steuerungscode)
+  ELIF es ist ein eingabekanal
+
+       THEN lesecode in abhaengigkeit von der taktzahl
+       ELSE ""
+  FI.
+  es ist ein ausgabekanal:
+    kanal [kanalnummer].betriebsart < 0.
+  es ist ein eingabekanal:
+    kanal [kanalnummer].betriebsart > 0.
+  device:
+    IF kanalnummer < 10
+       THEN 0
+       ELSE kanalnummer DIV 10  -  1
+    FI.
+  lesecode in abhaengigkeit von der taktzahl:
+    SELECT kanal [kanalnummer].taktzahl OF
+      CASE 1: lesecode
+      CASE 2: adresse 0 code + lesecode + lesecode
+      CASE 3: adresse 0 code + lesecode + zwei weitere takte
+
+    OTHERWISE "" END SELECT.
+  lesecode  :  code (interface read code + device + 4 * steuerungscode).
+  zwei weitere takte:
+    IF leertakt code = ""
+       THEN lesecode + lesecode
+       ELSE kanal [kanalnummer].taktzahl DECR 1;
+            leertakt code + lesecode
+    FI.
+END PROC interface anpassung;
+(************ H A R D W A R E U N A B H Ä N G I G E R  T E I L ************)
+LET       max kanalanzahl          =   49,
+          initcode                 =   50,
+          endcode                  =   51,
+
+          alles aus code           =   52,
+          endezeichen              =  "q",
+          abbruchzeichen           =  "h",
+          esc                      =  ""27"";
+INT CONST analog aus               ::  -2,            (* Betriebsarten *)
+          digital aus              ::  -1,
+          nicht belegt             ::   0,
+          digital ein              ::   1,
+          analog  ein              ::   2,
+          kanalbreite              ::   8,
+          ganzzahl obergrenze      ::   2 ** kanalbreite,
+
+          configuration error code ::  -1,
+          kanal besetzt code       ::  -3,
+          interface error code     ::  -4,
+          not init code            ::  -5;
+INT VAR   interfacechannel         ::   2,
+          dummy;
+TEXT VAR  meldung                  ::  "";
+BOOL VAR  kanaldaten sind eingetragen :: FALSE,
+          endezeichen gegeben         :: FALSE,
+          programm mit pdv gestartet  :: FALSE,
+          fehler zu melden            :: FALSE;
+TASK VAR  interface task              :: niltask;
+
+DATASPACE VAR  ds :: nilspace;
+TYPE KANAL     = STRUCT (INT  betriebsart, taktzahl, TEXT steuercode),
+     SPANNUNG  = STRUCT (REAL minimalwert, maximalwert);
+ROW max kanalanzahl INT      VAR vorherige ausgabe;
+ROW max kanalanzahl KANAL    VAR kanal;
+ROW max kanalanzahl SPANNUNG VAR spannung;
+ROW 5 TEXT CONST fehlermeldung :: ROW 5 TEXT :
+  ("Interface ist noch nicht konfiguriert!",
+   "Interface-Task ist besetzt!",
+   "Interface-Kanal ist belegt!",
+   "Interface meldet sich nicht!",
+   "Interface kann nicht geöffnet werden!");
+
+PROC run pdv:
+  run pdv (last param)
+END PROC run pdv;
+PROC run pdv (TEXT CONST programmname):
+  enable stop;
+  last param (programmname);
+  programm mit pdv gestartet := TRUE;
+  teste interface;
+  disable stop;
+  run (programmname);
+  IF is error
+     THEN fehlerbehandlung
+     ELSE melde programmende
+  FI;
+  schliesse interface;
+  programm mit pdv gestartet := FALSE;
+  enable stop;
+  IF fehler zu melden
+     THEN errorstop (meldung)
+  FI
+END PROC run pdv;
+PROC run pdv again:
+
+  enable stop;
+  programm mit pdv gestartet := TRUE;
+  teste interface;
+  disable stop;
+  run again;
+  IF is error
+     THEN fehlerbehandlung
+     ELSE melde programmende
+  FI;
+  schliesse interface;
+  programm mit pdv gestartet := FALSE;
+  enable stop;
+  IF fehler zu melden
+     THEN errorstop (meldung)
+  FI
+END PROC run pdv again;
+PROC melde programmende:
+  page;
+  menufootnote ("Programmende! Zum Weitermachen bitte irgendeine Taste tippen.");
+  pause;
+  schalte alles aus
+END PROC melde programmende;
+
+PROC initialisiere interface:
+  enable stop;
+  pruefe abbruch;
+  IF programm mit pdv gestartet
+     THEN schalte alles aus
+     ELSE errorstop ("PDV-Programme müssen mit 'run pdv' gestartet werden!")
+  FI
+END PROC initialisiere interface;
+PROC schalte alles aus:
+  INT VAR k;
+  FOR k FROM 1 UPTO max kanalanzahl REP
+    vorherige ausgabe [k] := 0
+  PER;
+  forget (ds); ds := nilspace;
+  call (interface task, alles aus code, ds, dummy)
+END PROC schalte alles aus;
+PROC ausgeben (INT CONST kanalnummer, wert):
+
+  merke wert;
+  gib wert aus.
+  merke wert:
+    vorherige ausgabe [kanalnummer] := wert.
+  gib wert aus:
+    call (interface task, 256 * kanalnummer + wert, ds, dummy).
+END PROC ausgeben;
+INT PROC eingabe (INT CONST kanalnummer):
+  INT VAR eingabewert;
+  call (interface task, kanalnummer, ds, eingabewert);
+  eingabewert
+END PROC eingabe;
+PROC warte (REAL CONST sekunden):
+  TEXT VAR eingabe;
+  pruefe abbruch;
+  eingabe := incharety (int (sekunden * 10.0 + 0.5));
+  IF eingabe = esc
+
+     THEN untersuche naechstes zeichen
+  FI.
+  untersuche naechstes zeichen:
+    eingabe := incharety (30);
+    IF   eingabe = endezeichen
+         THEN endezeichen gegeben := TRUE
+    ELIF eingabe = abbruchzeichen
+         THEN errorstop ("Programm-Abbruch durch <ESC><"
+                             + abbruchzeichen + ">!")
+    FI.
+END PROC warte;
+PROC warte (INT CONST sekunden):
+  TEXT VAR eingabe;
+  pruefe abbruch;
+  eingabe := incharety (sekunden * 10);
+  IF eingabe = esc
+     THEN untersuche naechstes zeichen
+
+  FI.
+  untersuche naechstes zeichen:
+    eingabe := incharety (30);
+    IF   eingabe = endezeichen
+         THEN endezeichen gegeben := TRUE
+    ELIF eingabe = abbruchzeichen
+         THEN errorstop ("Programm-Abbruch durch <ESC><"
+                             + abbruchzeichen + ">!")
+    FI.
+END PROC warte;
+BOOL PROC abbruch gewuenscht:
+  pruefe abbruch;
+  BOOL VAR entscheidung :: endezeichen gegeben;
+  endezeichen gegeben := FALSE;
+  entscheidung
+END PROC abbruch gewuenscht;
+PROC tue nichts:
+
+  pruefe abbruch
+END PROC tue nichts;
+PROC trage kanaldaten ein (INT CONST  kanalnummer,
+                           ROW 2 REAL CONST spannungsbereich,
+                           ROW 3 INT  CONST kanalparameter):
+   spannung [kanalnummer].minimalwert := spannungsbereich [1];
+   spannung [kanalnummer].maximalwert := spannungsbereich [2];
+   kanal [kanalnummer].betriebsart    := kanalparameter   [1];
+   kanal [kanalnummer].taktzahl       := kanalparameter   [2];
+   kanal [kanalnummer].steuercode     := interface anpassung
+
+                                         (kanalnummer, kanalparameter [3])
+END PROC trage kanaldaten ein;
+PROC beende kanaldaten eintragen:
+  loesche interface task;
+  begin (PROC kanal koppler, interface task);
+  kanaldaten sind eingetragen := TRUE.
+  loesche interface task:
+    disable stop;
+    end (interface task);
+    IF is error
+       THEN clear error
+    FI;
+    enable stop.
+END PROC beende kanaldaten eintragen;
+PROC hole spannungsbereich (INT CONST kanalnummer, REAL VAR  u min, u max):
+
+  u min := spannung [kanalnummer].minimalwert;
+  u max := spannung [kanalnummer].maximalwert
+END PROC hole spannungsbereich;
+INT PROC letzte ausgabe (INT CONST kanalnummer):
+  vorherige ausgabe [kanalnummer]
+END PROC letzte ausgabe;
+PROC pruefe kanal (INT CONST kanalnummer, gewuenschte betriebsart):
+  pruefe abbruch;
+  pruefe kanalnummer;
+  pruefe betriebsart.
+  pruefe kanalnummer:
+    IF kanalnummer < 1 OR kanalnummer > max kanalanzahl
+       THEN errorstop ("Kanalnummer " + text (kanalnummer) +
+
+                        " ist unzulaessig !")
+    FI.
+  pruefe betriebsart:
+    IF gewuenschte betriebsart <> kanal [kanalnummer].betriebsart
+       THEN errorstop ("An Kanal " + text (kanalnummer) +
+                          " keine " +  wunsch + " moeglich!")
+    FI.
+  wunsch:
+    IF   gewuenschte betriebsart = analog aus
+         THEN "Analog-Ausgabe"
+    ELIF gewuenschte betriebsart = digital aus
+         THEN "Digital-Ausgabe"
+    ELIF gewuenschte betriebsart = digital ein
+         THEN "Digital-Eingabe"
+
+    ELIF gewuenschte betriebsart = analog ein
+         THEN "Analog-Eingabe"
+         ELSE "Ein- oder Ausgabe"
+    FI.
+END PROC pruefe kanal;
+PROC pruefe abbruch:
+  IF incharety = esc
+     THEN pruefe weiter
+  FI.
+  pruefe weiter:
+    TEXT CONST zeichen :: incharety (30);
+    IF   zeichen = endezeichen
+         THEN endezeichen gegeben := TRUE
+    ELIF zeichen = abbruchzeichen
+         THEN errorstop ("Programm-Abbruch durch <ESC><"
+                             + abbruchzeichen + ">!")
+
+    FI.
+END PROC pruefe abbruch;
+PROC oeffne interface (INT VAR status):
+  enable stop;
+  forget (ds); ds := nilspace;
+  IF kanaldaten sind eingetragen
+     THEN pingpong (interfacetask, initcode, ds, status)
+     ELSE status := configuration error code
+  FI;
+  IF status > 0 THEN status DECR maxint FI;
+  forget (ds); ds := nilspace
+END PROC oeffne interface;
+PROC schliesse interface:
+  enable stop;
+  forget (ds); ds := nilspace;
+  pingpong (interface task, end code, ds, dummy);
+  forget (ds); ds := nilspace
+
+END PROC schliesse interface;
+PROC teste interface:
+  INT VAR test;
+  oeffne interface (test);
+  IF test < 0
+     THEN errorstop (fehlermeldung [min (5, abs (test))])
+     ELSE fehler zu melden           := FALSE;
+          endezeichen gegeben        := FALSE
+  FI
+END PROC teste interface;
+PROC fehlerbehandlung:
+  meldung := errormessage;
+  IF meldung <> ""
+     THEN meldung CAT fehlerzeile;
+          fehler zu melden := TRUE
+  FI;
+  clear error;
+  initialisiere interface.
+  fehlerzeile:
+
+    IF errorline = 0
+       THEN ""
+       ELSE " (bei Zeile " + text (errorline) + ")"
+    FI.
+END PROC fehlerbehandlung;
+(********************  EIN-/AUSGABE AM INTERFACE-KANAL ********************)
+PROC kanalkoppler:
+  IF name (myself) <> "-"
+     THEN errorstop ("Unzulässiges Kommando!")
+     ELSE warte auf anrufe
+  FI.
+  warte auf anrufe:
+    TASK      VAR absender;
+    TEXT      VAR dummy;
+    INT       VAR codenummer, antwort;
+    disable stop;
+    REP forget (ds);
+        wait (ds, codenummer, absender);
+
+        IF codenummer = initcode
+           THEN kopple an interface kanal;
+                IF interface ist betriebsbereit
+                   THEN bearbeite weitere auftraege
+                   ELSE gib negative rueckmeldung
+                FI;
+                gib kanal frei
+           ELSE antwort := not init code;
+                gib negative rueckmeldung
+        FI
+    PER.
+ kopple an interface kanal:
+  continue (interface channel);
+  IF is error
+     THEN clear error;
+          antwort := kanal besetzt code
+
+     ELSE oeffne interface direkt (antwort)
+  FI.
+ interface ist betriebsbereit:  antwort = 0.
+ gib negative rueckmeldung:     send (absender, antwort, ds).
+ gib kanal frei:
+   break (quiet);
+   send  (absender, 0, ds, antwort);
+   collect heap garbage.
+ bearbeite weitere auftraege:
+   REP   call (absender, antwort, ds, codenummer);
+         IF   codenummer > 255
+              THEN sende wert an interface
+         ELIF codenummer <  50
+              THEN hole wert von interface
+         ELIF codenummer = alles aus code
+
+              THEN initialisiere interface direkt
+         FI
+   UNTIL codenummer = endcode PER;
+   IF is error THEN clear error FI;
+   schliesse interface direkt.
+  sende wert an interface:
+    out (kanal [codenummer DIV 256].steuercode);
+    out (code (codenummer)).
+  hole wert von interface:
+    out (kanal [codenummer].steuercode);
+    SELECT kanal [codenummer].taktzahl OF
+      CASE 1 :  antwort := erstes  zeichen
+      CASE 2 :  antwort := zweites zeichen
+      CASE 3 :  antwort := drittes zeichen
+
+      OTHERWISE antwort := -1
+    END SELECT.
+    erstes zeichen:
+      code (incharety (1)).
+    zweites zeichen:
+      dummy := incharety (1);
+      code (incharety (1)).
+    drittes zeichen:
+      dummy := incharety (1);
+      dummy := incharety (1);
+      code (incharety (1)).
+END PROC kanalkoppler;
+PROC interface kanal (INT CONST kanalnummer):
+  enable stop;
+  IF kanalnummer < 1 OR kanalnummer > 24
+     THEN errorstop ("Unzulaessige Kanalnummer")
+     ELSE interface channel := kanalnummer
+
+  FI
+END PROC interface kanal;
+INT PROC interface kanal:
+  interface channel
+END PROC interface kanal;
+PROC oeffne interface direkt (INT VAR status):
+  leere puffer;
+  out (interface test code);
+  fange antwort;
+  IF antwort = interface okay code
+     THEN status := 0;
+          out (interface open code)
+     ELSE status := interface error code
+  FI.
+  leere puffer:
+    REP  UNTIL incharety = "" PER.
+  fange antwort:
+    INT  VAR zaehler;
+    TEXT VAR antwort :: "";
+    FOR zaehler FROM 1 UPTO erwartete zeichen REP
+
+      antwort CAT incharety (1)
+    PER.
+END PROC oeffne interface direkt;
+PROC schliesse interface direkt:
+  out (interface close code)
+END PROC schliesse interface direkt;
+PROC initialisiere interface direkt:
+  schalte alles aus.
+  schalte alles aus:
+    INT VAR kanalnummer, kanalbetriebsart;
+    FOR kanalnummer FROM 1 UPTO max kanalanzahl REP
+        kanalbetriebsart := kanal [kanalnummer].betriebsart;
+        IF   kanalbetriebsart = digital aus
+             THEN direkt ausgeben (kanalnummer, 0)
+
+        ELIF kanalbetriebsart = analog aus
+             THEN direkt ausgeben (kanalnummer, gewandelte nullspannung)
+        FI
+    PER.
+  gewandelte nullspannung:
+    int(- real (ganzzahl obergrenze) * u min / (u max - u min) + 0.5).
+    u max :  spannung [kanalnummer].maximalwert.
+    u min :  spannung [kanalnummer].minimalwert.
+END PROC initialisiere interface direkt;
+PROC direkt ausgeben (INT CONST kanalnummer, wert):
+ out (kanal [kanalnummer].steuercode);
+ out (code (wert))
+END PROC direkt ausgeben;
+
+INT PROC direkt eingabe (INT CONST kanalnummer):
+  gib lesecode aus;
+  erhaltene antwort.
+  gib lesecode aus:
+    out (kanal [kanalnummer].steuercode).
+  erhaltene antwort:
+    TEXT VAR dummy;
+    SELECT kanal [kanalnummer].taktzahl OF
+      CASE 1 :  erstes  zeichen
+      CASE 2 :  zweites zeichen
+      CASE 3 :  drittes zeichen
+      OTHERWISE -1
+    END SELECT.
+    erstes zeichen:
+      code (incharety (1)).
+    zweites zeichen:
+      dummy := incharety (1);
+      code (incharety (1)).
+
+    drittes zeichen:
+      dummy := incharety (1);
+      dummy := incharety (1);
+      code (incharety (1)).
+END PROC direkt eingabe;
+PROC initialisiere die kanaele:
+  INT VAR kanalnummer;
+  FOR kanalnummer FROM 1 UPTO max kanalanzahl REP
+      trage kanaldaten ein (kanalnummer, keine spannung, leere karte);
+      vorherige ausgabe [kanalnummer] := 0
+  PER.
+  keine spannung:
+    ROW 2 REAL : (0.0, 0.0).
+  leere karte:
+    ROW 3 INT : (nicht belegt, 0, 0).
+END PROC initialisiere die kanaele;
+
+initialisiere die kanaele;
+END PACKET ls prozess 1
+
 
diff --git a/prozess/ls-Prozess 1 für MUFI im Terminalkanal b/prozess/ls-Prozess 1 für MUFI im Terminalkanal
index d1edbc1..712b8a2 100644
--- a/prozess/ls-Prozess 1 für MUFI im Terminalkanal
+++ b/prozess/ls-Prozess 1 für MUFI im Terminalkanal
@@ -22,34 +22,485 @@
  
                                                                            *) 
 PACKET altes incharety DEFINES old incharety: 
-TEXT PROC old incharety:{}  incharety{}END PROC old incharety;{}TEXT PROC old incharety (INT CONST timelimit):{}  incharety (timelimit){}END PROC old incharety;{}END PACKET altes incharety;{}PACKET ls prozess 1 DEFINES{}       run pdv,{}       run pdv again,{}       initialisiere interface,{}       ausgeben,{}       eingabe,{}       warte,{}       abbruch gewuenscht,{}       tue nichts,{}       trage kanaldaten ein,{}       beende kanaldaten eintragen,{}       hole spannungsbereich,{}       letzte ausgabe,{}
-       pruefe kanal,{}       pruefe abbruch,{}       teste interface,{}      schalte alles aus,{}       oeffne interface,{}       schliesse interface,{}       nicht belegt,{}       digital aus,{}       analog aus,{}       digital ein,{}       analog ein,{}       kanalbreite,{}       ganzzahl obergrenze,{}       adapterart,{}       incharety,{}       inchar,{}       pause:{}(******************** A N P A S S U N G  A N  M U F I ********************){}LET mufikennung       = ""31""31"",{}    erwartete zeichen =        4  ;{}
-TEXT CONST adapterart           :: "MUFI im Terminalkanal",{}           interface test  code :: ""27""27"10",{}           interface okay  code :: ""27""27"00",{}           interface open  code :: ""27""27"1C" + hex (mufikennung),{}           interface close code :: mufikennung  + "1C" + hex (""27""27""),{}           adresse 0 code       :: mufikennung + "3D",{}           leertakt  code       :: mufikennung + "3E",{}           interface write code :: mufikennung + "5" ,{}           interface read  code :: mufikennung + "4" ;{}
-TEXT VAR   puffer :: "";{}ROW 256 TEXT CONST hexcode :: ROW 256 TEXT : ({}"00","01","02","03","04","05","06","07","08","09","0A","0B","0C","0D","0E","0F",{}"10","11","12","13","14","15","16","17","18","19","1A","1B","1C","1D","1E","1F",{}"20","21","22","23","24","25","26","27","28","29","2A","2B","2C","2D","2E","2F",{}"30","31","32","33","34","35","36","37","38","39","3A","3B","3C","3D","3E","3F",{}"40","41","42","43","44","45","46","47","48","49","4A","4B","4C","4D","4E","4F",{}"50","51","52","53","54","55","56","57","58","59","5A","5B","5C","5D","5E","5F",{}
-"60","61","62","63","64","65","66","67","68","69","6A","6B","6C","6D","6E","6F",{}"70","71","72","73","74","75","76","77","78","79","7A","7B","7C","7D","7E","7F",{}"80","81","82","83","84","85","86","87","88","89","8A","8B","8C","8D","8E","8F",{}"90","91","92","93","94","95","96","97","98","99","9A","9B","9C","9D","9E","9F",{}"A0","A1","A2","A3","A4","A5","A6","A7","A8","A9","AA","AB","AC","AD","AE","AF",{}"B0","B1","B2","B3","B4","B5","B6","B7","B8","B9","BA","BB","BC","BD","BE","BF",{}"C0","C1","C2","C3","C4","C5","C6","C7","C8","C9","CA","CB","CC","CD","CE","CF",{}
-"D0","D1","D2","D3","D4","D5","D6","D7","D8","D9","DA","DB","DC","DD","DE","DF",{}"E0","E1","E2","E3","E4","E5","E6","E7","E8","E9","EA","EB","EC","ED","EE","EF",{}"F0","F1","F2","F3","F4","F5","F6","F7","F8","F9","FA","FB","FC","FD","FE","FF");{}TEXT PROC interface anpassung (INT CONST kanalnummer, steuerungscode):{}  LET  hexzeichen = "0123456789ABCDEF";{}  IF   es ist ein ausgabekanal{}       THEN interface write code{}            + (hexzeichen SUB (device + 4 * steuerungscode)){}  ELIF es ist ein eingabekanal{}
-       THEN lesecode in abhaengigkeit von der taktzahl{}       ELSE ""{}  FI.{}  es ist ein ausgabekanal:{}    kanal [kanalnummer].betriebsart < 0.{}  es ist ein eingabekanal:{}    kanal [kanalnummer].betriebsart > 0.{}  device:{}    IF kanalnummer < 10{}       THEN 1{}       ELSE kanalnummer DIV 10{}    FI.{}  lesecode in abhaengigkeit von der taktzahl:{}    SELECT kanal [kanalnummer].taktzahl OF{}      CASE 1: lesecode{}      CASE 2: adresse 0 code + lesecode + lesecode{}      CASE 3: adresse 0 code + lesecode + zwei weitere takte{}
-    OTHERWISE "" END SELECT.{}  lesecode:{}    interface read code + (hexzeichen SUB (device + 4 * steuerungscode)).{}  zwei weitere takte:{}    IF leertakt code = ""{}       THEN lesecode + lesecode{}       ELSE kanal [kanalnummer].taktzahl DECR 1;{}            leertakt code + lesecode{}    FI.{}END PROC interface anpassung;{}PROC ausgeben (INT CONST kanalnummer, wert):{}  merke wert;{}  gib wert aus.{}  merke wert:{}   vorherige ausgabe [kanalnummer] := wert.{}  gib wert aus:{}    out (kanal [kanalnummer].steuercode);{}
-    out (hexcode [wert + 1]).{}END PROC ausgeben;{}INT PROC eingabe (INT CONST kanalnummer):{}  gib lesecode aus;{}  erhaltene antwort.{}  gib lesecode aus:{}    out (kanal [kanalnummer].steuercode).{}  erhaltene antwort:{}    TEXT VAR dummy;{}    SELECT kanal [kanalnummer].taktzahl OF{}      CASE 1 :  erste  sendung{}      CASE 2 :  zweite sendung{}      CASE 3 :  dritte sendung{}      OTHERWISE -1{}    END SELECT.{}    erste sendung:{}      fange mufikennung;{}      dezimalwert (old incharety (1), old incharety (1)).{}
-    zweite sendung:{}      fange mufikennung;{}      dummy := old incharety (1);{}      dummy := old incharety (1);{}      erste sendung.{}    dritte sendung:{}      fange mufikennung;{}      dummy := old incharety (1);{}      dummy := old incharety (1);{}      zweite sendung.{}    fange mufikennung:{}      puffer CAT old incharety;{}      REP puffer CAT old incharety{}      UNTIL pos (puffer, mufikennung) > 0 PER;{}      puffer := subtext (puffer, 1, length (puffer) - 2).{}END PROC eingabe;{}(************ H A R D W A R E U N A B H Ä N G I G E R  T E I L ************){}
-LET       max kanalanzahl          =   49,{}          endezeichen              =  "q",{}          abbruchzeichen           =  "h",{}          esc                      =  ""27"";{}INT CONST analog aus               ::  -2,            (* Betriebsarten *){}          digital aus              ::  -1,{}          nicht belegt             ::   0,{}          digital ein              ::   1,{}          analog  ein              ::   2,{}          kanalbreite              ::   8,{}          ganzzahl obergrenze      ::   2 ** kanalbreite,{}
-          configuration error code ::  -1,{}          interface error code     ::  -4;{}TEXT VAR  meldung                  ::  "";{}BOOL VAR  kanaldaten sind eingetragen :: FALSE,{}          endezeichen gegeben         :: FALSE,{}          programm mit pdv gestartet  :: FALSE,{}          fehler zu melden            :: FALSE;{}TYPE KANAL     = STRUCT (INT  betriebsart, taktzahl, TEXT steuercode),{}     SPANNUNG  = STRUCT (REAL minimalwert, maximalwert);{}ROW max kanalanzahl INT      VAR vorherige ausgabe;{}
-ROW max kanalanzahl KANAL    VAR kanal;{}ROW max kanalanzahl SPANNUNG VAR spannung;{}PROC run pdv:{}  run pdv (last param){}END PROC run pdv;{}PROC run pdv (TEXT CONST programmname):{}  enable stop;{}  last param (programmname);{}  programm mit pdv gestartet := TRUE;{}  teste interface;{}  disable stop;{}  run (programmname);{}  IF is error{}     THEN fehlerbehandlung{}     ELSE melde programmende{}  FI;{}  schliesse interface;{}  programm mit pdv gestartet := FALSE;{}  enable stop;{}  IF fehler zu melden{}
-     THEN errorstop (meldung){}  FI{}END PROC run pdv;{}PROC run pdv again:{}  enable stop;{}  programm mit pdv gestartet := TRUE;{}  teste interface;{}  disable stop;{}  run again;{}  IF is error{}     THEN fehlerbehandlung{}     ELSE melde programmende{}  FI;{}  schliesse interface;{}  programm mit pdv gestartet := FALSE;{}  enable stop;{}  IF fehler zu melden{}     THEN errorstop (meldung){}  FI{}END PROC run pdv again;{}PROC melde programmende:{}  page;{}  menufootnote ("Programmende! Zum Weitermachen bitte irgendeine Taste tippen.");{}
-  pause;{}  schalte alles aus{}END PROC melde programmende;{}PROC initialisiere interface:{}  enable stop;{}  pruefe abbruch;{}  IF programm mit pdv gestartet{}     THEN schalte alles aus{}     ELSE errorstop ("PDV-Programme müssen mit 'run pdv' gestartet werden!"){}  FI{}END PROC initialisiere interface;{}PROC schalte alles aus:{}  INT VAR kanalnummer, kanalbetriebsart;{}  FOR kanalnummer FROM 1 UPTO max kanalanzahl REP{}      kanalbetriebsart := kanal [kanalnummer].betriebsart;{}      IF   kanalbetriebsart = digital aus{}
-           THEN ausgeben (kanalnummer, 0){}      ELIF kanalbetriebsart = analog aus{}           THEN ausgeben (kanalnummer, gewandelte nullspannung){}      FI{}  PER.{}  gewandelte nullspannung:{}    int(- real (ganzzahl obergrenze) * u min / (u max - u min) + 0.5).{}    u max :  spannung [kanalnummer].maximalwert.{}    u min :  spannung [kanalnummer].minimalwert.{}END PROC schalte alles aus;{}PROC warte (REAL CONST sekunden):{}  TEXT VAR eingabe;{}  pruefe abbruch;{}  eingabe := incharety (int (sekunden * 10.0 + 0.5));{}
-  IF eingabe = esc{}     THEN untersuche naechstes zeichen{}  FI.{}  untersuche naechstes zeichen:{}    eingabe := incharety (30);{}    IF   eingabe = endezeichen{}         THEN endezeichen gegeben := TRUE{}    ELIF eingabe = abbruchzeichen{}         THEN errorstop ("Programm-Abbruch durch <ESC><"{}                             + abbruchzeichen + ">!"){}    FI.{}END PROC warte;{}PROC warte (INT CONST sekunden):{}  TEXT VAR eingabe;{}  pruefe abbruch;{}  eingabe := incharety (sekunden * 10);{}  IF eingabe = esc{}
-     THEN untersuche naechstes zeichen{}  FI.{}  untersuche naechstes zeichen:{}    eingabe := incharety (30);{}    IF   eingabe = endezeichen{}         THEN endezeichen gegeben := TRUE{}    ELIF eingabe = abbruchzeichen{}         THEN errorstop ("Programm-Abbruch durch <ESC><"{}                             + abbruchzeichen + ">!"){}    FI.{}END PROC warte;{}TEXT PROC incharety:{}  IF puffer = ""{}     THEN old incharety{}     ELSE erstes zeichen von puffer{}  FI.{}  erstes zeichen von puffer:{}    TEXT CONST zeichen :: puffer SUB 1;{}
-    puffer := subtext (puffer, 2);{}    zeichen.{}END PROC incharety;{}TEXT PROC incharety (INT CONST timelimit):{}  IF puffer = ""{}     THEN old incharety (timelimit){}     ELSE erstes zeichen von puffer{}  FI.{}  erstes zeichen von puffer:{}    TEXT CONST zeichen :: puffer SUB 1;{}    puffer := subtext (puffer, 2);{}    zeichen.{}END PROC incharety;{}PROC inchar (TEXT VAR character):{}  REP character := incharety{}  UNTIL character <> "" PER{}END PROC inchar;{}PROC pause:{}  TEXT VAR dummy;{}  inchar (dummy){}
-END PROC pause;{}PROC pause (INT CONST timelimit):{}  TEXT VAR dummy := incharety (timelimit){}END PROC pause;{}BOOL PROC abbruch gewuenscht:{}  pruefe abbruch;{}  BOOL VAR entscheidung :: endezeichen gegeben;{}  endezeichen gegeben := FALSE;{}  entscheidung{}END PROC abbruch gewuenscht;{}PROC tue nichts:{}  pruefe abbruch{}END PROC tue nichts;{}PROC trage kanaldaten ein (INT CONST  kanalnummer,{}                           ROW 2 REAL CONST spannungsbereich,{}                           ROW 3 INT  CONST kanalparameter):{}
-   spannung [kanalnummer].minimalwert := spannungsbereich [1];{}   spannung [kanalnummer].maximalwert := spannungsbereich [2];{}   kanal [kanalnummer].betriebsart    := kanalparameter   [1];{}   kanal [kanalnummer].taktzahl       := kanalparameter   [2];{}   kanal [kanalnummer].steuercode     := interface anpassung{}                                         (kanalnummer, kanalparameter [3]){}END PROC trage kanaldaten ein;{}PROC beende kanaldaten eintragen:{}  kanaldaten sind eingetragen := TRUE{}END PROC beende kanaldaten eintragen;{}
-PROC hole spannungsbereich (INT CONST kanalnummer, REAL VAR  u min, u max):{}  u min := spannung [kanalnummer].minimalwert;{}  u max := spannung [kanalnummer].maximalwert{}END PROC hole spannungsbereich;{}INT PROC letzte ausgabe (INT CONST kanalnummer):{}  vorherige ausgabe [kanalnummer]{}END PROC letzte ausgabe;{}PROC pruefe kanal (INT CONST kanalnummer, gewuenschte betriebsart):{}  pruefe abbruch;{}  pruefe kanalnummer;{}  pruefe betriebsart.{}  pruefe kanalnummer:{}    IF kanalnummer < 1 OR kanalnummer > max kanalanzahl{}
-       THEN errorstop ("Kanalnummer " + text (kanalnummer) +{}                        " ist unzulaessig !"){}    FI.{}  pruefe betriebsart:{}    IF gewuenschte betriebsart <> kanal [kanalnummer].betriebsart{}       THEN errorstop ("An Kanal " + text (kanalnummer) +{}                          " keine " +  wunsch + " moeglich!"){}    FI.{}  wunsch:{}    IF   gewuenschte betriebsart = analog aus{}         THEN "Analog-Ausgabe"{}    ELIF gewuenschte betriebsart = digital aus{}         THEN "Digital-Ausgabe"{}
-    ELIF gewuenschte betriebsart = digital ein{}         THEN "Digital-Eingabe"{}    ELIF gewuenschte betriebsart = analog ein{}         THEN "Analog-Eingabe"{}         ELSE "Ein- oder Ausgabe"{}    FI.{}END PROC pruefe kanal;{}PROC pruefe abbruch:{}  TEXT VAR zeichen :: incharety;{}  IF zeichen = esc{}     THEN pruefe weiter{}  FI.{}  pruefe weiter:{}    zeichen := incharety (30);{}    IF   zeichen = endezeichen{}         THEN endezeichen gegeben := TRUE{}    ELIF zeichen = abbruchzeichen{}         THEN errorstop ("Programm-Abbruch durch <ESC><"{}
-                             + abbruchzeichen + ">!"){}    FI.{}END PROC pruefe abbruch;{}PROC oeffne interface (INT VAR status):{}  enable stop;{}  IF kanaldaten sind eingetragen{}     THEN teste interface funktion{}     ELSE status := configuration error code{}  FI.{}  teste interface funktion:{}    leere puffer;{}    out (interface test code);{}    fange antwort;{}    IF antwort = interface okay code{}       THEN status := 0;{}            out (interface open code){}       ELSE status := interface error code{}
-    FI.{}  leere puffer:{}    puffer := "";{}    REP  UNTIL old incharety = "" PER.{}  fange antwort:{}    INT  VAR zaehler;{}    TEXT VAR antwort :: "";{}    FOR zaehler FROM 1 UPTO erwartete zeichen REP{}      antwort CAT old incharety (1){}    PER.{}END PROC oeffne interface;{}PROC schliesse interface:{}  enable stop;{}  out (interface close code){}END PROC schliesse interface;{}(*********************  H I L F S P R O Z E D U R E N *********************){}PROC teste interface:{}  INT VAR test;{}
-  warte etwas;{}  oeffne interface (test);{}  IF test < 0{}     THEN errorstop (fehlermeldung){}     ELSE endezeichen gegeben        := FALSE;{}          fehler zu melden           := FALSE{}  FI.{}  warte etwas:{}    pause (1); pause (1); pause (1); pause (1); pause (1).{}  fehlermeldung:{}    IF   test = configuration error code{}         THEN "Interface ist noch nicht konfiguriert!"{}    ELIF test = interface error code{}         THEN "Interface meldet sich nicht!"{}         ELSE "Interface kann nicht geöffnet werden!"{}
-    FI.{}END PROC teste interface;{}PROC fehlerbehandlung:{}  meldung := errormessage;{}  IF meldung <> ""{}     THEN meldung CAT fehlerzeile;{}          fehler zu melden := TRUE{}  FI;{}  clear error;{}  initialisiere interface.{}  fehlerzeile:{}    IF errorline = 0{}       THEN ""{}       ELSE " (bei Zeile " + text (errorline) + ")"{}    FI.{}END PROC fehlerbehandlung;{}INT PROC dezimalwert (TEXT CONST zeichen 1, zeichen 2):{}  16 * pos (hexzeichen, zeichen 1) + pos (hexzeichen, zeichen 2).{}  hexzeichen: "123456789ABCDEF".{}
-END PROC dezimalwert;{}TEXT PROC hex (TEXT CONST zwei zeichen):{}  hex (code (zwei zeichen SUB 1)) + hex (code (zwei zeichen SUB 2)){}END PROC hex;{}TEXT PROC hex (INT CONST wert):{}  (hexzeichen SUB (wert DIV 16 + 1)) + (hexzeichen SUB (wert MOD 16 + 1)).{}  hexzeichen: "0123456789ABCDEF".{}END PROC hex;{}PROC initialisiere die kanaele:{}  INT VAR kanalnummer;{}  FOR kanalnummer FROM 1 UPTO max kanalanzahl REP{}      trage kanaldaten ein (kanalnummer, keine spannung, leere karte);{}      vorherige ausgabe [kanalnummer] := 0{}
-  PER.{}  keine spannung:{}    ROW 2 REAL : (0.0, 0.0).{}  leere karte:{}    ROW 3 INT : (nicht belegt, 0, 0).{}END PROC initialisiere die kanaele;{}initialisiere die kanaele{}END PACKET ls prozess 1{}
+TEXT PROC old incharety:
+  incharety
+END PROC old incharety;
+TEXT PROC old incharety (INT CONST timelimit):
+  incharety (timelimit)
+END PROC old incharety;
+END PACKET altes incharety;
+PACKET ls prozess 1 DEFINES
+       run pdv,
+       run pdv again,
+       initialisiere interface,
+       ausgeben,
+       eingabe,
+       warte,
+       abbruch gewuenscht,
+       tue nichts,
+       trage kanaldaten ein,
+       beende kanaldaten eintragen,
+       hole spannungsbereich,
+       letzte ausgabe,
+
+       pruefe kanal,
+       pruefe abbruch,
+       teste interface,
+      schalte alles aus,
+       oeffne interface,
+       schliesse interface,
+       nicht belegt,
+       digital aus,
+       analog aus,
+       digital ein,
+       analog ein,
+       kanalbreite,
+       ganzzahl obergrenze,
+       adapterart,
+       incharety,
+       inchar,
+       pause:
+(******************** A N P A S S U N G  A N  M U F I ********************)
+LET mufikennung       = ""31""31"",
+    erwartete zeichen =        4  ;
+
+TEXT CONST adapterart           :: "MUFI im Terminalkanal",
+           interface test  code :: ""27""27"10",
+           interface okay  code :: ""27""27"00",
+           interface open  code :: ""27""27"1C" + hex (mufikennung),
+           interface close code :: mufikennung  + "1C" + hex (""27""27""),
+           adresse 0 code       :: mufikennung + "3D",
+           leertakt  code       :: mufikennung + "3E",
+           interface write code :: mufikennung + "5" ,
+           interface read  code :: mufikennung + "4" ;
+
+TEXT VAR   puffer :: "";
+ROW 256 TEXT CONST hexcode :: ROW 256 TEXT : (
+"00","01","02","03","04","05","06","07","08","09","0A","0B","0C","0D","0E","0F",
+"10","11","12","13","14","15","16","17","18","19","1A","1B","1C","1D","1E","1F",
+"20","21","22","23","24","25","26","27","28","29","2A","2B","2C","2D","2E","2F",
+"30","31","32","33","34","35","36","37","38","39","3A","3B","3C","3D","3E","3F",
+"40","41","42","43","44","45","46","47","48","49","4A","4B","4C","4D","4E","4F",
+"50","51","52","53","54","55","56","57","58","59","5A","5B","5C","5D","5E","5F",
+
+"60","61","62","63","64","65","66","67","68","69","6A","6B","6C","6D","6E","6F",
+"70","71","72","73","74","75","76","77","78","79","7A","7B","7C","7D","7E","7F",
+"80","81","82","83","84","85","86","87","88","89","8A","8B","8C","8D","8E","8F",
+"90","91","92","93","94","95","96","97","98","99","9A","9B","9C","9D","9E","9F",
+"A0","A1","A2","A3","A4","A5","A6","A7","A8","A9","AA","AB","AC","AD","AE","AF",
+"B0","B1","B2","B3","B4","B5","B6","B7","B8","B9","BA","BB","BC","BD","BE","BF",
+"C0","C1","C2","C3","C4","C5","C6","C7","C8","C9","CA","CB","CC","CD","CE","CF",
+
+"D0","D1","D2","D3","D4","D5","D6","D7","D8","D9","DA","DB","DC","DD","DE","DF",
+"E0","E1","E2","E3","E4","E5","E6","E7","E8","E9","EA","EB","EC","ED","EE","EF",
+"F0","F1","F2","F3","F4","F5","F6","F7","F8","F9","FA","FB","FC","FD","FE","FF");
+TEXT PROC interface anpassung (INT CONST kanalnummer, steuerungscode):
+  LET  hexzeichen = "0123456789ABCDEF";
+  IF   es ist ein ausgabekanal
+       THEN interface write code
+            + (hexzeichen SUB (device + 4 * steuerungscode))
+  ELIF es ist ein eingabekanal
+
+       THEN lesecode in abhaengigkeit von der taktzahl
+       ELSE ""
+  FI.
+  es ist ein ausgabekanal:
+    kanal [kanalnummer].betriebsart < 0.
+  es ist ein eingabekanal:
+    kanal [kanalnummer].betriebsart > 0.
+  device:
+    IF kanalnummer < 10
+       THEN 1
+       ELSE kanalnummer DIV 10
+    FI.
+  lesecode in abhaengigkeit von der taktzahl:
+    SELECT kanal [kanalnummer].taktzahl OF
+      CASE 1: lesecode
+      CASE 2: adresse 0 code + lesecode + lesecode
+      CASE 3: adresse 0 code + lesecode + zwei weitere takte
+
+    OTHERWISE "" END SELECT.
+  lesecode:
+    interface read code + (hexzeichen SUB (device + 4 * steuerungscode)).
+  zwei weitere takte:
+    IF leertakt code = ""
+       THEN lesecode + lesecode
+       ELSE kanal [kanalnummer].taktzahl DECR 1;
+            leertakt code + lesecode
+    FI.
+END PROC interface anpassung;
+PROC ausgeben (INT CONST kanalnummer, wert):
+  merke wert;
+  gib wert aus.
+  merke wert:
+   vorherige ausgabe [kanalnummer] := wert.
+  gib wert aus:
+    out (kanal [kanalnummer].steuercode);
+
+    out (hexcode [wert + 1]).
+END PROC ausgeben;
+INT PROC eingabe (INT CONST kanalnummer):
+  gib lesecode aus;
+  erhaltene antwort.
+  gib lesecode aus:
+    out (kanal [kanalnummer].steuercode).
+  erhaltene antwort:
+    TEXT VAR dummy;
+    SELECT kanal [kanalnummer].taktzahl OF
+      CASE 1 :  erste  sendung
+      CASE 2 :  zweite sendung
+      CASE 3 :  dritte sendung
+      OTHERWISE -1
+    END SELECT.
+    erste sendung:
+      fange mufikennung;
+      dezimalwert (old incharety (1), old incharety (1)).
+
+    zweite sendung:
+      fange mufikennung;
+      dummy := old incharety (1);
+      dummy := old incharety (1);
+      erste sendung.
+    dritte sendung:
+      fange mufikennung;
+      dummy := old incharety (1);
+      dummy := old incharety (1);
+      zweite sendung.
+    fange mufikennung:
+      puffer CAT old incharety;
+      REP puffer CAT old incharety
+      UNTIL pos (puffer, mufikennung) > 0 PER;
+      puffer := subtext (puffer, 1, length (puffer) - 2).
+END PROC eingabe;
+(************ H A R D W A R E U N A B H Ä N G I G E R  T E I L ************)
+
+LET       max kanalanzahl          =   49,
+          endezeichen              =  "q",
+          abbruchzeichen           =  "h",
+          esc                      =  ""27"";
+INT CONST analog aus               ::  -2,            (* Betriebsarten *)
+          digital aus              ::  -1,
+          nicht belegt             ::   0,
+          digital ein              ::   1,
+          analog  ein              ::   2,
+          kanalbreite              ::   8,
+          ganzzahl obergrenze      ::   2 ** kanalbreite,
+
+          configuration error code ::  -1,
+          interface error code     ::  -4;
+TEXT VAR  meldung                  ::  "";
+BOOL VAR  kanaldaten sind eingetragen :: FALSE,
+          endezeichen gegeben         :: FALSE,
+          programm mit pdv gestartet  :: FALSE,
+          fehler zu melden            :: FALSE;
+TYPE KANAL     = STRUCT (INT  betriebsart, taktzahl, TEXT steuercode),
+     SPANNUNG  = STRUCT (REAL minimalwert, maximalwert);
+ROW max kanalanzahl INT      VAR vorherige ausgabe;
+
+ROW max kanalanzahl KANAL    VAR kanal;
+ROW max kanalanzahl SPANNUNG VAR spannung;
+PROC run pdv:
+  run pdv (last param)
+END PROC run pdv;
+PROC run pdv (TEXT CONST programmname):
+  enable stop;
+  last param (programmname);
+  programm mit pdv gestartet := TRUE;
+  teste interface;
+  disable stop;
+  run (programmname);
+  IF is error
+     THEN fehlerbehandlung
+     ELSE melde programmende
+  FI;
+  schliesse interface;
+  programm mit pdv gestartet := FALSE;
+  enable stop;
+  IF fehler zu melden
+
+     THEN errorstop (meldung)
+  FI
+END PROC run pdv;
+PROC run pdv again:
+  enable stop;
+  programm mit pdv gestartet := TRUE;
+  teste interface;
+  disable stop;
+  run again;
+  IF is error
+     THEN fehlerbehandlung
+     ELSE melde programmende
+  FI;
+  schliesse interface;
+  programm mit pdv gestartet := FALSE;
+  enable stop;
+  IF fehler zu melden
+     THEN errorstop (meldung)
+  FI
+END PROC run pdv again;
+PROC melde programmende:
+  page;
+  menufootnote ("Programmende! Zum Weitermachen bitte irgendeine Taste tippen.");
+
+  pause;
+  schalte alles aus
+END PROC melde programmende;
+PROC initialisiere interface:
+  enable stop;
+  pruefe abbruch;
+  IF programm mit pdv gestartet
+     THEN schalte alles aus
+     ELSE errorstop ("PDV-Programme müssen mit 'run pdv' gestartet werden!")
+  FI
+END PROC initialisiere interface;
+PROC schalte alles aus:
+  INT VAR kanalnummer, kanalbetriebsart;
+  FOR kanalnummer FROM 1 UPTO max kanalanzahl REP
+      kanalbetriebsart := kanal [kanalnummer].betriebsart;
+      IF   kanalbetriebsart = digital aus
+
+           THEN ausgeben (kanalnummer, 0)
+      ELIF kanalbetriebsart = analog aus
+           THEN ausgeben (kanalnummer, gewandelte nullspannung)
+      FI
+  PER.
+  gewandelte nullspannung:
+    int(- real (ganzzahl obergrenze) * u min / (u max - u min) + 0.5).
+    u max :  spannung [kanalnummer].maximalwert.
+    u min :  spannung [kanalnummer].minimalwert.
+END PROC schalte alles aus;
+PROC warte (REAL CONST sekunden):
+  TEXT VAR eingabe;
+  pruefe abbruch;
+  eingabe := incharety (int (sekunden * 10.0 + 0.5));
+
+  IF eingabe = esc
+     THEN untersuche naechstes zeichen
+  FI.
+  untersuche naechstes zeichen:
+    eingabe := incharety (30);
+    IF   eingabe = endezeichen
+         THEN endezeichen gegeben := TRUE
+    ELIF eingabe = abbruchzeichen
+         THEN errorstop ("Programm-Abbruch durch <ESC><"
+                             + abbruchzeichen + ">!")
+    FI.
+END PROC warte;
+PROC warte (INT CONST sekunden):
+  TEXT VAR eingabe;
+  pruefe abbruch;
+  eingabe := incharety (sekunden * 10);
+  IF eingabe = esc
+
+     THEN untersuche naechstes zeichen
+  FI.
+  untersuche naechstes zeichen:
+    eingabe := incharety (30);
+    IF   eingabe = endezeichen
+         THEN endezeichen gegeben := TRUE
+    ELIF eingabe = abbruchzeichen
+         THEN errorstop ("Programm-Abbruch durch <ESC><"
+                             + abbruchzeichen + ">!")
+    FI.
+END PROC warte;
+TEXT PROC incharety:
+  IF puffer = ""
+     THEN old incharety
+     ELSE erstes zeichen von puffer
+  FI.
+  erstes zeichen von puffer:
+    TEXT CONST zeichen :: puffer SUB 1;
+
+    puffer := subtext (puffer, 2);
+    zeichen.
+END PROC incharety;
+TEXT PROC incharety (INT CONST timelimit):
+  IF puffer = ""
+     THEN old incharety (timelimit)
+     ELSE erstes zeichen von puffer
+  FI.
+  erstes zeichen von puffer:
+    TEXT CONST zeichen :: puffer SUB 1;
+    puffer := subtext (puffer, 2);
+    zeichen.
+END PROC incharety;
+PROC inchar (TEXT VAR character):
+  REP character := incharety
+  UNTIL character <> "" PER
+END PROC inchar;
+PROC pause:
+  TEXT VAR dummy;
+  inchar (dummy)
+
+END PROC pause;
+PROC pause (INT CONST timelimit):
+  TEXT VAR dummy := incharety (timelimit)
+END PROC pause;
+BOOL PROC abbruch gewuenscht:
+  pruefe abbruch;
+  BOOL VAR entscheidung :: endezeichen gegeben;
+  endezeichen gegeben := FALSE;
+  entscheidung
+END PROC abbruch gewuenscht;
+PROC tue nichts:
+  pruefe abbruch
+END PROC tue nichts;
+PROC trage kanaldaten ein (INT CONST  kanalnummer,
+                           ROW 2 REAL CONST spannungsbereich,
+                           ROW 3 INT  CONST kanalparameter):
+
+   spannung [kanalnummer].minimalwert := spannungsbereich [1];
+   spannung [kanalnummer].maximalwert := spannungsbereich [2];
+   kanal [kanalnummer].betriebsart    := kanalparameter   [1];
+   kanal [kanalnummer].taktzahl       := kanalparameter   [2];
+   kanal [kanalnummer].steuercode     := interface anpassung
+                                         (kanalnummer, kanalparameter [3])
+END PROC trage kanaldaten ein;
+PROC beende kanaldaten eintragen:
+  kanaldaten sind eingetragen := TRUE
+END PROC beende kanaldaten eintragen;
+
+PROC hole spannungsbereich (INT CONST kanalnummer, REAL VAR  u min, u max):
+  u min := spannung [kanalnummer].minimalwert;
+  u max := spannung [kanalnummer].maximalwert
+END PROC hole spannungsbereich;
+INT PROC letzte ausgabe (INT CONST kanalnummer):
+  vorherige ausgabe [kanalnummer]
+END PROC letzte ausgabe;
+PROC pruefe kanal (INT CONST kanalnummer, gewuenschte betriebsart):
+  pruefe abbruch;
+  pruefe kanalnummer;
+  pruefe betriebsart.
+  pruefe kanalnummer:
+    IF kanalnummer < 1 OR kanalnummer > max kanalanzahl
+
+       THEN errorstop ("Kanalnummer " + text (kanalnummer) +
+                        " ist unzulaessig !")
+    FI.
+  pruefe betriebsart:
+    IF gewuenschte betriebsart <> kanal [kanalnummer].betriebsart
+       THEN errorstop ("An Kanal " + text (kanalnummer) +
+                          " keine " +  wunsch + " moeglich!")
+    FI.
+  wunsch:
+    IF   gewuenschte betriebsart = analog aus
+         THEN "Analog-Ausgabe"
+    ELIF gewuenschte betriebsart = digital aus
+         THEN "Digital-Ausgabe"
+
+    ELIF gewuenschte betriebsart = digital ein
+         THEN "Digital-Eingabe"
+    ELIF gewuenschte betriebsart = analog ein
+         THEN "Analog-Eingabe"
+         ELSE "Ein- oder Ausgabe"
+    FI.
+END PROC pruefe kanal;
+PROC pruefe abbruch:
+  TEXT VAR zeichen :: incharety;
+  IF zeichen = esc
+     THEN pruefe weiter
+  FI.
+  pruefe weiter:
+    zeichen := incharety (30);
+    IF   zeichen = endezeichen
+         THEN endezeichen gegeben := TRUE
+    ELIF zeichen = abbruchzeichen
+         THEN errorstop ("Programm-Abbruch durch <ESC><"
+
+                             + abbruchzeichen + ">!")
+    FI.
+END PROC pruefe abbruch;
+PROC oeffne interface (INT VAR status):
+  enable stop;
+  IF kanaldaten sind eingetragen
+     THEN teste interface funktion
+     ELSE status := configuration error code
+  FI.
+  teste interface funktion:
+    leere puffer;
+    out (interface test code);
+    fange antwort;
+    IF antwort = interface okay code
+       THEN status := 0;
+            out (interface open code)
+       ELSE status := interface error code
+
+    FI.
+  leere puffer:
+    puffer := "";
+    REP  UNTIL old incharety = "" PER.
+  fange antwort:
+    INT  VAR zaehler;
+    TEXT VAR antwort :: "";
+    FOR zaehler FROM 1 UPTO erwartete zeichen REP
+      antwort CAT old incharety (1)
+    PER.
+END PROC oeffne interface;
+PROC schliesse interface:
+  enable stop;
+  out (interface close code)
+END PROC schliesse interface;
+(*********************  H I L F S P R O Z E D U R E N *********************)
+PROC teste interface:
+  INT VAR test;
+
+  warte etwas;
+  oeffne interface (test);
+  IF test < 0
+     THEN errorstop (fehlermeldung)
+     ELSE endezeichen gegeben        := FALSE;
+          fehler zu melden           := FALSE
+  FI.
+  warte etwas:
+    pause (1); pause (1); pause (1); pause (1); pause (1).
+  fehlermeldung:
+    IF   test = configuration error code
+         THEN "Interface ist noch nicht konfiguriert!"
+    ELIF test = interface error code
+         THEN "Interface meldet sich nicht!"
+         ELSE "Interface kann nicht geöffnet werden!"
+
+    FI.
+END PROC teste interface;
+PROC fehlerbehandlung:
+  meldung := errormessage;
+  IF meldung <> ""
+     THEN meldung CAT fehlerzeile;
+          fehler zu melden := TRUE
+  FI;
+  clear error;
+  initialisiere interface.
+  fehlerzeile:
+    IF errorline = 0
+       THEN ""
+       ELSE " (bei Zeile " + text (errorline) + ")"
+    FI.
+END PROC fehlerbehandlung;
+INT PROC dezimalwert (TEXT CONST zeichen 1, zeichen 2):
+  16 * pos (hexzeichen, zeichen 1) + pos (hexzeichen, zeichen 2).
+  hexzeichen: "123456789ABCDEF".
+
+END PROC dezimalwert;
+TEXT PROC hex (TEXT CONST zwei zeichen):
+  hex (code (zwei zeichen SUB 1)) + hex (code (zwei zeichen SUB 2))
+END PROC hex;
+TEXT PROC hex (INT CONST wert):
+  (hexzeichen SUB (wert DIV 16 + 1)) + (hexzeichen SUB (wert MOD 16 + 1)).
+  hexzeichen: "0123456789ABCDEF".
+END PROC hex;
+PROC initialisiere die kanaele:
+  INT VAR kanalnummer;
+  FOR kanalnummer FROM 1 UPTO max kanalanzahl REP
+      trage kanaldaten ein (kanalnummer, keine spannung, leere karte);
+      vorherige ausgabe [kanalnummer] := 0
+
+  PER.
+  keine spannung:
+    ROW 2 REAL : (0.0, 0.0).
+  leere karte:
+    ROW 3 INT : (nicht belegt, 0, 0).
+END PROC initialisiere die kanaele;
+initialisiere die kanaele
+END PACKET ls prozess 1
+
 
diff --git a/prozess/ls-Prozess 2 b/prozess/ls-Prozess 2
index 11cb4e7..3b8d407 100644
--- a/prozess/ls-Prozess 2
+++ b/prozess/ls-Prozess 2
@@ -22,18 +22,217 @@
  
                                                                            *) 
 PACKET ls prozess 2 DEFINES                   
-       wert an analogausgang ausgeben,{}       spannungswert ausgeben,{}       bitsymbol ausgeben,{}       bitmuster ausgeben,{}       dezimalwert ausgeben,{}       bitmuster gleich,{}       bit ist gesetzt,{}       wert von analogeingang,{}       spannungswert,{}       bitsymbol,{}       bitmuster,{}       dezimalwert:{}LET    eins   = "I",{}       null   = "O",{}       invers = "T",{}       egal   = "X";{}REAL CONST maximalwert :: real (ganzzahl obergrenze - 1);{}(********************* A U S G A B E - B E F E H L E *********************){}
-PROC wert an analogausgang ausgeben (INT CONST kanal, wert):{}  pruefe kanal (kanal, analog aus);{}  ausgeben (kanal, wert MOD ganzzahlobergrenze){}END PROC wert an analogausgang ausgeben;{}PROC spannungswert ausgeben (INT  CONST kanal, REAL CONST wert):{}  pruefe kanal (kanal, analog aus);{}  pruefe spannungswert;{}  ausgeben (kanal, gewandelte spannung).{}  pruefe spannungswert:{}    REAL VAR u min, u max;{}    hole spannungsbereich (kanal, u min, u max);{}    IF wert < u min OR wert > u max{}       THEN errorstop ("Der Spannungswert " + text (wert) +{}
-                       " ist nicht zulaessig!"){}    FI.{}  gewandelte spannung:{}    int (((wert - u min) * maximalwert) / (u max - u min) + 0.5).{}END PROC spannungswert ausgeben;{}PROC bitsymbol ausgeben (INT  CONST kanal, bitnummer, TEXT CONST zeichen):{}  pruefe kanal (kanal, digital aus);{}  pruefe bitnummer (bitnummer);{}  ausgeben (kanal, relativer dezimalwert (zeichen, bitnummer, kanal)){}END PROC bitsymbol ausgeben;{}PROC bitmuster ausgeben (INT  CONST kanal, TEXT CONST zeichenkette):{}
-  pruefe kanal (kanal, digital aus);{}  ausgeben (kanal, relativer dezimalwert (zeichenkette, kanal)){}END PROC bitmuster ausgeben;{}PROC dezimalwert ausgeben (INT CONST kanal, wert):{}  pruefe kanal (kanal, digital aus);{}  ausgeben (kanal, wert MOD ganzzahl obergrenze){}END PROC dezimalwert ausgeben;{}(********************* E I N G A B E - B E F E H L E *********************){}BOOL PROC bitmuster gleich (INT CONST kanal, TEXT CONST zeichenkette):{}  INT CONST eingabewert :: dezimalwert (kanal);{}
-  pruefe zeichenkette;{}  eingabe passt zur zeichenkette.{}  pruefe zeichenkette:{}    IF length (zeichenkette) <> kanalbreite{}       THEN errorstop ("Das Bitmuster '" + zeichenkette +{}                       "' hat eine unzulaessige Laenge!"){}    FI.{}  eingabe passt zur zeichenkette:{}   INT VAR stelle;{}   BOOL VAR abweichung gefunden :: FALSE;{}   FOR stelle FROM 1 UPTO kanalbreite REP{}     teste bit an dieser stelle{}   UNTIL abweichung gefunden PER;{}   NOT abweichung gefunden.{} teste bit an dieser stelle:{}
-   TEXT CONST einzelbit :: zeichenkette SUB stelle;{}   IF   einzelbit = eins{}        THEN teste eingabebit auf eins{}   ELIF einzelbit = null{}        THEN teste eingabebit auf null{}   ELIF einzelbit = egal{}        THEN eingabebit ist beliebig{}   ELSE errorstop ("'" + einzelbit + "' ist unzulaessiges " +{}                   "Bitsymbol in '" + zeichenkette + "'!"){}   FI.{} teste eingabebit auf eins:{}   IF NOT bit (eingabewert, kanalbreite - stelle){}      THEN abweichung gefunden := TRUE{}   FI.{}
- teste eingabebit auf null:{}   IF bit (eingabewert, kanalbreite - stelle){}      THEN abweichung gefunden := TRUE{}   FI.{} eingabebit ist beliebig:{}   .{}END PROC bitmuster gleich;{}BOOL PROC bit ist gesetzt (INT CONST kanal, bitnummer):{}  pruefe kanal (kanal, digital ein);{}  pruefe bitnummer (bitnummer);{}  IF bit (eingabe (kanal), bitnummer){}     THEN TRUE{}     ELSE FALSE{}  FI{}END PROC bit ist gesetzt;{}INT PROC wert von analogeingang (INT CONST kanal):{}  pruefe kanal (kanal, analog ein);{}
-  eingabe (kanal){}END PROC wert von analogeingang;{}REAL PROC spannungswert (INT CONST kanal):{}  INT CONST dezimalwert :: wert von analogeingang (kanal);{}  REAL  VAR u min, u max;{}  hole spannungsbereich (kanal, u min, u max);{}  round (real (dezimalwert) * (u max - u min) / maximalwert + u min, 3){}END PROC spannungswert;{}TEXT PROC bitsymbol (INT CONST kanal, bitnummer):{}  pruefe kanal (kanal, digital ein);{}  pruefe bitnummer (bitnummer);{}  IF bit (eingabe (kanal), bitnummer){}     THEN eins{}
-     ELSE null{}  FI{}END PROC bitsymbol;{}TEXT PROC bitmuster (INT CONST kanal):{}  TEXT VAR   zeichenkette :: "";{}  INT  CONST wert         :: dezimalwert (kanal);{}  wandle wert;{}  zeichenkette.{}  wandle wert:{}    INT VAR zeiger;{}    FOR zeiger FROM kanalbreite - 1 DOWNTO 0 REP{}      IF bit (wert, zeiger){}         THEN zeichenkette CAT eins{}         ELSE zeichenkette CAT null{}      FI{}    PER.{}END PROC bitmuster;{}INT PROC dezimalwert (INT CONST kanal):{}  pruefe kanal (kanal, digital ein);{}
-  eingabe (kanal){}END PROC dezimalwert;{}(******************** H I L F S - P R O Z E D U R E N ********************){}INT PROC relativer dezimalwert (TEXT CONST zeichenkette, INT CONST kanal):{}   INT VAR wert := letzte ausgabe (kanal);{}   pruefe zeichenkette auf korrekte laenge;{}   veraendere alten wert;{}   wert.{}   pruefe zeichenkette auf korrekte laenge:{}     IF length (zeichenkette) <> kanalbreite{}        THEN errorstop ("Bitmuster '" + zeichenkette + "' hat "{}                                      + "unzulaessige Laenge!"){}
-     FI.{}   veraendere alten wert:{}     INT VAR zeiger;{}     FOR zeiger FROM 1 UPTO kanalbreite REP{}       veraendere dieses bit{}     PER.{}   veraendere dieses bit:{}     TEXT CONST einzelbit :: zeichenkette SUB zeiger;{}     IF   einzelbit = eins   THEN setze bit{}     ELIF einzelbit = null   THEN loesche bit{}     ELIF einzelbit = invers THEN invertiere bit{}     ELIF einzelbit = egal   THEN lasse bit{}     ELSE errorstop ("'" + einzelbit + "' ist unzulaessiges " +{}                     "Bitsymbol in '" + zeichenkette + "'!"){}
-     FI.{}   setze bit:{}     set bit (wert, kanalbreite - zeiger).{}   loesche bit:{}     reset bit (wert, kanalbreite - zeiger).{}   invertiere bit:{}     IF bit (wert, kanalbreite - zeiger){}        THEN loesche bit{}        ELSE setze bit{}     FI.{}   lasse bit:{}     .{}  END PROC relativer dezimalwert;{}INT PROC relativer dezimalwert (TEXT CONST bitzeichen,{}                                INT  CONST bitnummer, kanal):{}    INT VAR wert :: letzte ausgabe (kanal);{}    IF   bitzeichen = eins   THEN setze bit{}
-    ELIF bitzeichen = null   THEN loesche bit{}    ELIF bitzeichen = invers THEN invertiere bit{}    ELIF bitzeichen = egal   THEN lasse bit{}    ELSE errorstop ("'" + bitzeichen + "' ist ein unzulaessiges " +{}                                       "Bitsymbol!"){}    FI;{}    wert.{}   setze bit:{}     set bit (wert, bitnummer).{}   loesche bit:{}     reset bit (wert, bitnummer).{}   invertiere bit:{}     IF bit (wert, bitnummer){}        THEN loesche bit{}        ELSE setze bit{}     FI.{}   lasse bit:{}
-     .{}END PROC relativer dezimalwert;{}PROC pruefe bitnummer (INT CONST bitnummer):{}  IF bitnummer < 0  OR  bitnummer > kanalbreite - 1{}     THEN errorstop ("Bitnummer " + text (bitnummer) +{}                     " ist nicht zulaessig!"){}  FI{}END PROC pruefe bitnummer{}END PACKET ls prozess 2{}
+       wert an analogausgang ausgeben,
+       spannungswert ausgeben,
+       bitsymbol ausgeben,
+       bitmuster ausgeben,
+       dezimalwert ausgeben,
+       bitmuster gleich,
+       bit ist gesetzt,
+       wert von analogeingang,
+       spannungswert,
+       bitsymbol,
+       bitmuster,
+       dezimalwert:
+LET    eins   = "I",
+       null   = "O",
+       invers = "T",
+       egal   = "X";
+REAL CONST maximalwert :: real (ganzzahl obergrenze - 1);
+(********************* A U S G A B E - B E F E H L E *********************)
+
+PROC wert an analogausgang ausgeben (INT CONST kanal, wert):
+  pruefe kanal (kanal, analog aus);
+  ausgeben (kanal, wert MOD ganzzahlobergrenze)
+END PROC wert an analogausgang ausgeben;
+PROC spannungswert ausgeben (INT  CONST kanal, REAL CONST wert):
+  pruefe kanal (kanal, analog aus);
+  pruefe spannungswert;
+  ausgeben (kanal, gewandelte spannung).
+  pruefe spannungswert:
+    REAL VAR u min, u max;
+    hole spannungsbereich (kanal, u min, u max);
+    IF wert < u min OR wert > u max
+       THEN errorstop ("Der Spannungswert " + text (wert) +
+
+                       " ist nicht zulaessig!")
+    FI.
+  gewandelte spannung:
+    int (((wert - u min) * maximalwert) / (u max - u min) + 0.5).
+END PROC spannungswert ausgeben;
+PROC bitsymbol ausgeben (INT  CONST kanal, bitnummer, TEXT CONST zeichen):
+  pruefe kanal (kanal, digital aus);
+  pruefe bitnummer (bitnummer);
+  ausgeben (kanal, relativer dezimalwert (zeichen, bitnummer, kanal))
+END PROC bitsymbol ausgeben;
+PROC bitmuster ausgeben (INT  CONST kanal, TEXT CONST zeichenkette):
+
+  pruefe kanal (kanal, digital aus);
+  ausgeben (kanal, relativer dezimalwert (zeichenkette, kanal))
+END PROC bitmuster ausgeben;
+PROC dezimalwert ausgeben (INT CONST kanal, wert):
+  pruefe kanal (kanal, digital aus);
+  ausgeben (kanal, wert MOD ganzzahl obergrenze)
+END PROC dezimalwert ausgeben;
+(********************* E I N G A B E - B E F E H L E *********************)
+BOOL PROC bitmuster gleich (INT CONST kanal, TEXT CONST zeichenkette):
+  INT CONST eingabewert :: dezimalwert (kanal);
+
+  pruefe zeichenkette;
+  eingabe passt zur zeichenkette.
+  pruefe zeichenkette:
+    IF length (zeichenkette) <> kanalbreite
+       THEN errorstop ("Das Bitmuster '" + zeichenkette +
+                       "' hat eine unzulaessige Laenge!")
+    FI.
+  eingabe passt zur zeichenkette:
+   INT VAR stelle;
+   BOOL VAR abweichung gefunden :: FALSE;
+   FOR stelle FROM 1 UPTO kanalbreite REP
+     teste bit an dieser stelle
+   UNTIL abweichung gefunden PER;
+   NOT abweichung gefunden.
+ teste bit an dieser stelle:
+
+   TEXT CONST einzelbit :: zeichenkette SUB stelle;
+   IF   einzelbit = eins
+        THEN teste eingabebit auf eins
+   ELIF einzelbit = null
+        THEN teste eingabebit auf null
+   ELIF einzelbit = egal
+        THEN eingabebit ist beliebig
+   ELSE errorstop ("'" + einzelbit + "' ist unzulaessiges " +
+                   "Bitsymbol in '" + zeichenkette + "'!")
+   FI.
+ teste eingabebit auf eins:
+   IF NOT bit (eingabewert, kanalbreite - stelle)
+      THEN abweichung gefunden := TRUE
+   FI.
+
+ teste eingabebit auf null:
+   IF bit (eingabewert, kanalbreite - stelle)
+      THEN abweichung gefunden := TRUE
+   FI.
+ eingabebit ist beliebig:
+   .
+END PROC bitmuster gleich;
+BOOL PROC bit ist gesetzt (INT CONST kanal, bitnummer):
+  pruefe kanal (kanal, digital ein);
+  pruefe bitnummer (bitnummer);
+  IF bit (eingabe (kanal), bitnummer)
+     THEN TRUE
+     ELSE FALSE
+  FI
+END PROC bit ist gesetzt;
+INT PROC wert von analogeingang (INT CONST kanal):
+  pruefe kanal (kanal, analog ein);
+
+  eingabe (kanal)
+END PROC wert von analogeingang;
+REAL PROC spannungswert (INT CONST kanal):
+  INT CONST dezimalwert :: wert von analogeingang (kanal);
+  REAL  VAR u min, u max;
+  hole spannungsbereich (kanal, u min, u max);
+  round (real (dezimalwert) * (u max - u min) / maximalwert + u min, 3)
+END PROC spannungswert;
+TEXT PROC bitsymbol (INT CONST kanal, bitnummer):
+  pruefe kanal (kanal, digital ein);
+  pruefe bitnummer (bitnummer);
+  IF bit (eingabe (kanal), bitnummer)
+     THEN eins
+
+     ELSE null
+  FI
+END PROC bitsymbol;
+TEXT PROC bitmuster (INT CONST kanal):
+  TEXT VAR   zeichenkette :: "";
+  INT  CONST wert         :: dezimalwert (kanal);
+  wandle wert;
+  zeichenkette.
+  wandle wert:
+    INT VAR zeiger;
+    FOR zeiger FROM kanalbreite - 1 DOWNTO 0 REP
+      IF bit (wert, zeiger)
+         THEN zeichenkette CAT eins
+         ELSE zeichenkette CAT null
+      FI
+    PER.
+END PROC bitmuster;
+INT PROC dezimalwert (INT CONST kanal):
+  pruefe kanal (kanal, digital ein);
+
+  eingabe (kanal)
+END PROC dezimalwert;
+(******************** H I L F S - P R O Z E D U R E N ********************)
+INT PROC relativer dezimalwert (TEXT CONST zeichenkette, INT CONST kanal):
+   INT VAR wert := letzte ausgabe (kanal);
+   pruefe zeichenkette auf korrekte laenge;
+   veraendere alten wert;
+   wert.
+   pruefe zeichenkette auf korrekte laenge:
+     IF length (zeichenkette) <> kanalbreite
+        THEN errorstop ("Bitmuster '" + zeichenkette + "' hat "
+                                      + "unzulaessige Laenge!")
+
+     FI.
+   veraendere alten wert:
+     INT VAR zeiger;
+     FOR zeiger FROM 1 UPTO kanalbreite REP
+       veraendere dieses bit
+     PER.
+   veraendere dieses bit:
+     TEXT CONST einzelbit :: zeichenkette SUB zeiger;
+     IF   einzelbit = eins   THEN setze bit
+     ELIF einzelbit = null   THEN loesche bit
+     ELIF einzelbit = invers THEN invertiere bit
+     ELIF einzelbit = egal   THEN lasse bit
+     ELSE errorstop ("'" + einzelbit + "' ist unzulaessiges " +
+                     "Bitsymbol in '" + zeichenkette + "'!")
+
+     FI.
+   setze bit:
+     set bit (wert, kanalbreite - zeiger).
+   loesche bit:
+     reset bit (wert, kanalbreite - zeiger).
+   invertiere bit:
+     IF bit (wert, kanalbreite - zeiger)
+        THEN loesche bit
+        ELSE setze bit
+     FI.
+   lasse bit:
+     .
+  END PROC relativer dezimalwert;
+INT PROC relativer dezimalwert (TEXT CONST bitzeichen,
+                                INT  CONST bitnummer, kanal):
+    INT VAR wert :: letzte ausgabe (kanal);
+    IF   bitzeichen = eins   THEN setze bit
+
+    ELIF bitzeichen = null   THEN loesche bit
+    ELIF bitzeichen = invers THEN invertiere bit
+    ELIF bitzeichen = egal   THEN lasse bit
+    ELSE errorstop ("'" + bitzeichen + "' ist ein unzulaessiges " +
+                                       "Bitsymbol!")
+    FI;
+    wert.
+   setze bit:
+     set bit (wert, bitnummer).
+   loesche bit:
+     reset bit (wert, bitnummer).
+   invertiere bit:
+     IF bit (wert, bitnummer)
+        THEN loesche bit
+        ELSE setze bit
+     FI.
+   lasse bit:
+
+     .
+END PROC relativer dezimalwert;
+PROC pruefe bitnummer (INT CONST bitnummer):
+  IF bitnummer < 0  OR  bitnummer > kanalbreite - 1
+     THEN errorstop ("Bitnummer " + text (bitnummer) +
+                     " ist nicht zulaessig!")
+  FI
+END PROC pruefe bitnummer
+END PACKET ls prozess 2
+
 
diff --git a/prozess/ls-Prozess 3 b/prozess/ls-Prozess 3
index 28ef825..b66cbe6 100644
--- a/prozess/ls-Prozess 3
+++ b/prozess/ls-Prozess 3
@@ -22,5 +22,12 @@
  
                                                                            *) 
 PACKET ls prozess 3 DEFINES                    
-       temperatur:{}LET thermometerkonstante = 50.0,{}    minimaltemperatur    = 10.0;{}REAL PROC temperatur (REAL CONST spannungswert):{}  spannungswert * thermometerkonstante - minimaltemperatur{}END PROC temperatur{}END PACKET ls prozess 3{}
+       temperatur:
+LET thermometerkonstante = 50.0,
+    minimaltemperatur    = 10.0;
+REAL PROC temperatur (REAL CONST spannungswert):
+  spannungswert * thermometerkonstante - minimaltemperatur
+END PROC temperatur
+END PACKET ls prozess 3
+
 
diff --git a/prozess/ls-Prozess 4 b/prozess/ls-Prozess 4
index 158b548..59a1493 100644
--- a/prozess/ls-Prozess 4
+++ b/prozess/ls-Prozess 4
@@ -22,40 +22,574 @@
  
                                                                            *) 
 PACKET ls prozess 4 DEFINES 
-           pdv befehlsuebersicht anzeigen,{}           pdv ausgabebefehle anzeigen,{}           pdv eingabebefehle anzeigen,{}           pdv testbefehle anzeigen,{}           pdv weitere befehle anzeigen,{}           pdv bitmuster erlaeutern,{}           pdv symbole erlaeutern,{}           pdv digital analog werte,{}           pdv programm neu erstellen,{}           pdv programm ansehen,{}           pdv programm starten,{}           pdv programm wiederholen,{}           pdv dateien verzeichnis,{}
-           pdv datei kopieren,{}           pdv datei umbenennen,{}           pdv dateien loeschen,{}           pdv dateien drucken,{}           init pdv,{}           pdv:{}LET  menukarte       = "ls-MENUKARTE:Prozess",{}     niltext         =         "",{}     maxlaenge       =         45,{}     maxnamenslaenge =         35;{}WINDOW VAR w :: window (1, 3, 79, 19);{}TEXT   VAR programmname :: "";{}BOOL   VAR noch kein programm gelaufen :: TRUE;{}PROC pdv:{}  init pdv;{}  install menu (menukarte, FALSE);{}
-  handle menu  ("PDV"){}END PROC pdv;{}PROC init pdv:{}  programmname := "";{}  noch kein programm gelaufen := TRUE;{}  cursor off;{}END PROC init pdv;{}PROC pdv befehlsuebersicht anzeigen:{}  menuinfo (anwendungstext (20)){}END PROC pdv befehlsuebersicht anzeigen;{}PROC pdv ausgabebefehle anzeigen:{}  INT VAR i;{}  REP{}    i := menualternative (anwendungstext (1), anwendungstext (3),{}                          anwendungstext (4), 5, TRUE);{}    SELECT i OF{}      CASE 1, 101: menuinfo (anwendungstext (21)){}
-      CASE 2, 102: menuinfo (anwendungstext (22)){}      CASE 3, 103: menuinfo (anwendungstext (23)){}      CASE 4, 104: menuinfo (anwendungstext (24)){}      CASE 5, 105: menuinfo (anwendungstext (25)){}    END SELECT{}  UNTIL i = 6 OR i = 106 PER;{}END PROC pdv ausgabebefehle anzeigen;{}PROC pdv eingabebefehle anzeigen:{}  INT VAR i;{}  REP{}    i := menualternative (anwendungstext (2), anwendungstext (3),{}                          anwendungstext (4), 5, TRUE);{}    SELECT i OF{}      CASE 1, 101: menuinfo (anwendungstext (31)){}
-      CASE 2, 102: menuinfo (anwendungstext (32)){}      CASE 3, 103: menuinfo (anwendungstext (33)){}      CASE 4, 104: menuinfo (anwendungstext (34)){}      CASE 5, 105: menuinfo (anwendungstext (35)){}    END SELECT{}  UNTIL i = 6 OR i = 106 PER;{}END PROC pdv eingabebefehle anzeigen;{}PROC pdv testbefehle anzeigen:{}  INT VAR i;{}  REP{}    i := menualternative (anwendungstext (5), anwendungstext (7),{}                          anwendungstext (8), 5, TRUE);{}    SELECT i OF{}      CASE 1, 101: menuinfo (anwendungstext (41)){}
-      CASE 2, 102: menuinfo (anwendungstext (42)){}    END SELECT{}  UNTIL i = 3 OR i = 103 PER;{}END PROC pdv testbefehle anzeigen;{}PROC pdv weitere befehle anzeigen:{}  INT VAR i;{}  REP{}    i := menualternative (anwendungstext (6), anwendungstext (7),{}                          anwendungstext (8), 5, TRUE);{}    SELECT i OF{}      CASE 1, 101: menuinfo (anwendungstext (43)){}      CASE 2, 102: menuinfo (anwendungstext (44)){}    END SELECT{}  UNTIL i = 3 OR i = 103 PER;{}END PROC pdv weitere befehle anzeigen;{}
-PROC pdv bitmuster erlaeutern:{}  menuinfo (anwendungstext (46)){}END PROC pdv bitmuster erlaeutern;{}PROC pdv symbole erlaeutern:{}  menuinfo (anwendungstext (47)){}END PROC pdv symbole erlaeutern;{}PROC pdv digital analog werte:{}  menuinfo (anwendungstext (48)){}END PROC pdv digital analog werte;{}PROC pdvdateien verzeichnis:{}  disable stop;{}  forget ("Verzeichnis der Dateien", quiet);{}  THESAURUS VAR programme :: ALL myself;{}  FILE VAR f ::{}  sequential file (output, "Verzeichnis der Dateien");{}
-  f FILLBY programme;{}  modify (f);{}  to line (f, 1); insert record (f);{}  menufootnote ("Verlassen: <ESC> <q>");{}  cursor on;{}  show (w, f);{}  cursor off;{}  forget ("Verzeichnis der Dateien", quiet);{}  IF is error{}     THEN regenerate menuscreen;{}          out (""7"");{}          menuinfo  (" " + invers ("FEHLER: " + errormessage));{}          clear error{}     ELSE menu bildschirm{}  FI;{}  enable stop{}END PROC pdvdateien verzeichnis;{}PROC pdvprogramm neu erstellen:{}  hole programmname;{}
-  kontrolliere den programmnamen;{}  command dialogue (FALSE);{}  cursor on;{}  disable stop;{}  stdinfoedit (programmname, 3);{}  cursor off;{}  command dialogue (TRUE);{}  IF is error{}     THEN regenerate menuscreen;{}          out (""7"");{}          menuinfo  (" " + invers (errormessage));{}          clear error{}     ELSE menu bildschirm{}  FI;{}  enable stop.{}  hole programmname:{}    programmname := "";{}    programmname := menuanswer (ausgabe, programmname, 5).{}  ausgabe:{}    center (maxlaenge, invers ("Programm neu erstellen")) + ""13""13""{}
-                 + " Bitte den Namen für das Programm "13""13"".{}  kontrolliere den programmnamen:{}    IF   programmname = niltext{}         THEN LEAVE pdvprogramm neu erstellen{}    ELIF length (programmname) > maxnamenslaenge{}         THEN meckere zu langen namen an;{}              programmname := niltext;{}              LEAVE pdvprogramm neu erstellen{}    ELIF exists (programmname){}         THEN meckere existierendes programm an;{}              LEAVE pdvprogramm neu erstellen{}    FI.{}END PROC pdvprogramm neu erstellen;{}
-PROC pdvprogramm ansehen:{}  IF programmname <> niltext CAND exists (programmname){}     THEN frage nach diesem programm{}     ELSE lasse programm auswaehlen{}  FI;{}  cursor on;{}  disable stop;{}  stdinfoedit (programmname, 3);{}  cursor off;{}  IF is error{}     THEN regenerate menuscreen;{}          out (""7"");{}          menuinfo  (" " + invers ("FEHLER: " + errormessage));{}          clear error{}     ELSE menu bildschirm{}  FI;{}  enable stop.{}  frage nach diesem programm:{}    IF menuno (ueberschrift + " Zuletzt bearbeitetes Programm: " + name{}
-              + " Soll mit diesem Programm gearbeitet werden", 5){}       THEN lasse programm auswaehlen{}    FI.{}  ueberschrift:{}    center (maxlaenge, invers ("Programm ansehen/ändern")) + ""13""13"".{}  name:{}    ""13""13" " + invers (programmname) + ""13""13"".{}  lasse programm auswaehlen:{}    THESAURUS VAR verfuegbare :: ALL myself;{}    IF NOT not empty (verfuegbare){}       THEN noch kein programm;{}            LEAVE pdvprogramm ansehen{}       ELSE biete auswahl an{}    FI.{}  biete auswahl an:{}
-    programmname := menuone (verfuegbare, "Programm ansehen/ändern",{}                             "Bitte das gewünschte Programm ankreuzen!",{}                              FALSE);{}    IF programmname = niltext{}       THEN menu bildschirm;{}            LEAVE pdvprogramm ansehen{}    FI.{}END PROC pdvprogramm ansehen;{}PROC pdvdateien drucken:{}  lasse programme auswaehlen;{}  drucke programme;{}  menu bildschirm.{}  lasse programme auswaehlen:{}    THESAURUS VAR verfuegbare :: ALL myself;{}    IF NOT not empty (verfuegbare){}
-       THEN noch kein programm;{}            LEAVE pdvdateien drucken{}       ELSE biete auswahl an{}    FI.{}  biete auswahl an:{}    verfuegbare := menusome (verfuegbare, "Dateien drucken",{}                   "Bitte die Dateien ankreuzen, die gedruckt werden sollen!",{}                    FALSE).{}  drucke programme:{}    show menuwindow;{}    steige ggf bei leerem thesaurus aus;{}    menuwindowout (menuwindowcenter (invers ("Dateien drucken")));{}    menuwindowline (2);{}    command dialogue (FALSE);{}
-    fuehre einzelne operationen aus;{}    command dialogue (TRUE);{}    schlage ggf neue seite auf;{}    menuwindowout (" Alle ausgewählten Dateien wurden gedruckt!");{}    menuwindowstop.{}  fuehre einzelne operationen aus:{}    INT VAR k;{}    FOR k FROM 1 UPTO highest entry (verfuegbare) REP{}      IF name (verfuegbare, k) <> ""{}         THEN disable stop;{}              menuwindowout ( " """ + name (verfuegbare, k) +{}                              """ wird gedruckt!");{}              menuwindowline;{}
-              print (name (verfuegbare, k));{}              fehlerbehandlung{}      FI{}    PER.{}  steige ggf bei leerem thesaurus aus:{}    IF NOT not empty (verfuegbare){}       THEN menuwindowline (2);{}            menuwindowout (" Es wurde keine Datei ausgewählt!");{}            menuwindowstop;{}            menu bildschirm;{}            LEAVE pdvdateien drucken{}    FI.{}  schlage ggf neue seite auf:{}    IF remaining menuwindowlines < 7{}       THEN menuwindowpage; menuwindowline{}       ELSE menuwindowline (2){}
-    FI.{}  fehlerbehandlung:{}    IF is error{}       THEN regenerate menuscreen; out (""7"");{}            menuinfo  (" " + invers (errormessage));{}            clear error; enable stop;{}            LEAVE pdvdateien drucken{}       ELSE enable stop{}    FI.{}END PROC pdvdateien drucken;{}PROC pdvdatei kopieren:{}  ermittle alten programmnamen;{}  erfrage neuen programmnamen;{}  kopiere ggf das programm.{}  ermittle alten programmnamen:{}    IF NOT not empty (ALL myself){}       THEN noch kein programm;{}
-            LEAVE pdvdatei kopieren{}       ELSE biete auswahl an{}    FI.{}  biete auswahl an:{}    TEXT VAR alter name := menuone (ALL myself, "Datei kopieren",{}            "Bitte die Datei ankreuzen, das kopiert werden soll!",FALSE);{}    menu bildschirm;{}    IF alter name = niltext{}       THEN LEAVE pdvdatei kopieren{}    FI.{}  erfrage neuen programmnamen:{}    TEXT VAR neuer name :: menuanswer (ausgabe, alter name, 5).{}  ausgabe:{}     ueberschrift + " Name der 'alten' Datei: " + bisheriger name{}
-                  + " Bitte den Namen für die Kopie: ".{}  ueberschrift:{}    center (maxlaenge, invers ("Datei kopieren")) + ""13""13"".{}  bisheriger name:{}    ""13""13" " + invers (alter name) + ""13""13"".{}  kopiere ggf das programm:{}    IF   neuer name = niltext{}         THEN menuinfo (" " + invers ("Der gewünschte Name ist unzulässig!"));{}              LEAVE pdvdatei kopieren{}    ELIF exists (neuer name){}         THEN mache vorwurf;{}              LEAVE pdvdatei kopieren{}       ELSE copy (alter name, neuer name){}
-    FI.{}  mache vorwurf:{}    menuinfo (" " + invers ("Eine Datei mit diesem Namen gibt es bereits!")).{}END PROC pdvdatei kopieren;{}PROC pdvdatei umbenennen:{}  ermittle alten programmnamen;{}  erfrage neuen programmnamen;{}  benenne ggf das programm um.{}  ermittle alten programmnamen:{}    IF NOT not empty (ALL myself){}       THEN noch kein programm;{}            LEAVE pdvdatei umbenennen{}       ELSE biete auswahl an{}    FI.{}  biete auswahl an:{}    TEXT VAR alter name := menuone ( ALL myself, "Datei umbenennen",{}
-        "Bitte die Datei ankreuzen, die umbenannt werden soll!", FALSE);{}    menu bildschirm;{}    IF alter name = niltext{}       THEN LEAVE pdvdatei umbenennen{}    FI.{}  erfrage neuen programmnamen:{}    TEXT VAR neuer name :: menuanswer (ausgabe, alter name, 5).{}  ausgabe:{}     ueberschrift + " Bisheriger  Dateiname: " + bisheriger name{}                  + " Zukünftiger Dateiname: ".{}  ueberschrift:{}    center (maxlaenge, invers ("Datei umbenennen")) + ""13""13"".{}  bisheriger name:{}
-    ""13""13" " + invers (alter name) + ""13""13"".{}  benenne ggf das programm um:{}    IF   neuer name = niltext{}         THEN menuinfo (" " + invers ("Der gewünschte Name ist unzulässig!"));{}              LEAVE pdvdatei umbenennen{}    ELIF exists (neuer name){}         THEN mache vorwurf;{}              LEAVE pdvdatei umbenennen{}       ELSE rename (alter name, neuer name);{}            programmname := neuer name{}    FI.{}  mache vorwurf:{}    menuinfo (" " + invers ("Eine Datei mit diesem Namen gibt es bereits!")).{}
-END PROC pdvdatei umbenennen;{}PROC pdvdateien loeschen:{}  lasse programme auswaehlen;{}  loesche programme;{}  menu bildschirm.{}  lasse programme auswaehlen:{}    THESAURUS VAR verfuegbare :: ALL myself;{}    IF NOT not empty (verfuegbare){}       THEN noch kein programm;{}            LEAVE pdvdateien loeschen{}       ELSE biete auswahl an{}    FI.{}  biete auswahl an:{}    verfuegbare := menusome (verfuegbare, "Dateien löschen",{}    "Bitte alle Dateien ankreuzen, die gelöscht werden sollen!", FALSE).{}
-  loesche programme:{}    show menuwindow;{}    steige ggf bei leerem thesaurus aus;{}    menuwindowout (menuwindowcenter (invers ("Dateien löschen")));{}    menuwindowline (2);{}    command dialogue (FALSE);{}    fuehre einzelne operationen aus;{}    command dialogue (TRUE);{}    schlage ggf neue seite auf;{}    menuwindowout (" Alle ausgewählten Dateien wurden gelöscht!");{}    menuwindowstop.{}  fuehre einzelne operationen aus:{}    INT VAR k;{}    FOR k FROM 1 UPTO highest entry (verfuegbare) REP{}
-      IF name (verfuegbare, k) <> ""{}         THEN disable stop;{}              IF menuwindowyes (" """ + name (verfuegbare, k) + """ löschen"){}                 THEN forget (name (verfuegbare, k), quiet){}              FI;{}              fehlerbehandlung{}      FI{}    PER;{}    programmname := "".{}  steige ggf bei leerem thesaurus aus:{}    IF NOT not empty (verfuegbare){}       THEN menuwindowline (2);{}            menuwindowout (" Es wurde keine Datei ausgewählt!");{}            menuwindowstop;{}
-            menu bildschirm;{}            LEAVE pdvdateien loeschen{}    FI.{}  schlage ggf neue seite auf:{}    IF remaining menuwindowlines < 7{}       THEN menuwindowpage; menuwindowline{}       ELSE menuwindowline (2){}    FI.{}  fehlerbehandlung:{}    IF is error{}       THEN regenerate menuscreen; out (""7"");{}            menuinfo  (" " + invers (errormessage));{}            clear error; enable stop;{}            LEAVE pdvdateien loeschen{}       ELSE enable stop{}    FI.{}END PROC pdvdateien loeschen;{}
-PROC pdvprogramm starten:{}  programmname ermitteln;{}  bildschirm vorbereiten;{}  cursor on;{}  disable stop;{}  warnings off;{}  check on;{}  run pdv (programmname);{}  noch kein programm gelaufen := FALSE;{}  cursor off;{}  IF is error{}     THEN fehler ggf melden;{}          clear error{}     ELSE regenerate menuscreen{}  FI;{}  enable stop.{}  bildschirm vorbereiten:{}    cursor (17, 2); out (waagerecht);{}    cursor (38, 2); out (waagerecht);{}    cursor ( 1, 3); out (""4"");{}    menufootnote ("Programmabbruch: <ESC><h>");{}
-    cursor (1, 5);{}    out ("Das Programm wird übersetzt.  Zeilen-Nr.: ").{}  fehler ggf melden:{}    IF errormessage <> ""{}       THEN fehler melden{}    FI.{}  fehler melden:{}    IF   pos (errormessage, "'halt' vom Terminal") > 0{}       THEN regenerate menuscreen;{}            out (""7""); menuinfo (" "15"'halt' vom Terminal "14""){}    ELIF pos (errormessage, "Programm-Abbruch durch <ESC><h>") > 0{}       THEN regenerate menuscreen;{}            out (""7""); menuinfo (" "15"Programm-Abbruch durch <ESC><h> "14""){}
-    ELIF pos (errormessage, "(bei Zeile") > 0 AND exists (programmname){}       THEN programm mit fehler im notebook zeigen;{}            regenerate menuscreen{}       ELSE regenerate menuscreen;{}            out (""7""); menuinfo  (" " + invers ("FEHLER: "{}                                        + subtext (errormessage, 1, 61))){}    FI.{}  programm mit fehler im notebook zeigen:{}    noteline;{}    note ("FEHLER: " + errormessage);{}    INT VAR n; FOR n FROM 1 UPTO 9 REP noteline PER;{}    note (""15"Verlassen: <ESC><q> "14"");{}
-    FILE VAR p :: sequential file (modify, programmname);{}    to line (p, max (1, fehlerzeile));{}    col (1);{}    clear error;{}    out (""7"");{}    cursor on;{}    noteedit (p);{}    cursor off.{}  fehlerzeile:{}    int (subtext (errormessage, zahlposition)).{}    zahlposition: pos (errormessage, "(bei Zeile") + 10.{}  programmname ermitteln:{}    IF programmname <> niltext CAND exists (programmname){}       THEN frage nach diesem programm{}       ELSE lasse programm auswaehlen{}    FI.{}  frage nach diesem programm:{}
-    IF menuno (ueberschrift + " Zuletzt bearbeitetes Programm: " +{}               name + " Soll mit diesem Programm gearbeitet werden", 5){}       THEN lasse programm auswaehlen{}    FI.{}  ueberschrift:{}    center (maxlaenge, invers ("Programm starten")) + ""13""13"".{}  name:{}    ""13""13" " + invers (programmname) + ""13""13"".{}  lasse programm auswaehlen:{}    THESAURUS VAR verfuegbare :: ALL myself;{}    IF NOT not empty (verfuegbare){}       THEN noch kein programm;{}            LEAVE pdvprogramm starten{}
-       ELSE biete auswahl an{}    FI.{}  biete auswahl an:{}    programmname := menuone (verfuegbare, "Programm starten",{}                    "Bitte das gewünschte Programm ankreuzen!", FALSE);{}    IF programmname = niltext{}       THEN menubildschirm;{}            LEAVE pdv programm starten{}    FI.{}END PROC pdvprogramm starten;{}PROC pdv programm wiederholen:{}  bildschirm vorbereiten;{}  cursor on;{}  disable stop;{}  IF noch kein programm gelaufen{}     THEN errorstop ("Eine Wiederholung ist nicht moeglich!"){}
-     ELSE run pdv again{}  FI;{}  cursor off;{}  regenerate menuscreen;{}  IF is error{}     THEN zeige fehler;{}          clear error{}  FI;{}  enable stop.{}  bildschirm vorbereiten:{}    cursor (17, 2); out (waagerecht);{}    cursor (38, 2); out (waagerecht);{}    cursor ( 1, 3); out (""4"");{}    menufootnote ("Programmabbruch: <ESC><h>");{}    cursor (1,3).{}  zeige fehler:{}    out (""7"");{}    IF errormessage = "'run again' nicht moeglich"{}       THEN menuinfo (" "15"Eine Wiederholung ist nicht moeglich! "14""){}
-    ELIF pos (errormessage, "'halt' vom Terminal") > 0{}       THEN menuinfo (" "15"'halt' vom Terminal "14""){}    ELIF pos (errormessage, "Programm-Abbruch durch <ESC><h>") > 0{}       THEN menuinfo (" "15"Programm-Abbruch durch <ESC><h> "14""){}       ELSE menuinfo (" " + invers ("FEHLER: "{}                          + subtext (errormessage, 1, 61))){}    FI.{}END PROC pdv programm wiederholen;{}PROC meckere zu langen namen an:{}  menuinfo (" " + invers ("Hier dürfen Namen höchstens "{}                + text (max namenslaenge){}
-                + " Zeichen lang sein!")){}END PROC meckere zu langen namen an;{}PROC meckere existierendes programm an:{}  menuinfo (" " + invers ("Ein Programm mit diesem Namen gibt es bereits!")){}END PROC meckere existierendes programm an;{}PROC noch kein programm:{}  menuinfo (" " + invers ("Es existiert noch kein Programm!")){}END PROC noch kein programm;{}PROC menu bildschirm:{}  cursor (1, 2);{}  out (5 * waagerecht);{}  cursor (1, 3);{}  out (""4"");{}  cursor (1,23);{}  out (79 * waagerecht);{}
-  refresh submenu{}END PROC menu bildschirm{}END PACKET ls prozess 4{}
+           pdv befehlsuebersicht anzeigen,
+           pdv ausgabebefehle anzeigen,
+           pdv eingabebefehle anzeigen,
+           pdv testbefehle anzeigen,
+           pdv weitere befehle anzeigen,
+           pdv bitmuster erlaeutern,
+           pdv symbole erlaeutern,
+           pdv digital analog werte,
+           pdv programm neu erstellen,
+           pdv programm ansehen,
+           pdv programm starten,
+           pdv programm wiederholen,
+           pdv dateien verzeichnis,
+
+           pdv datei kopieren,
+           pdv datei umbenennen,
+           pdv dateien loeschen,
+           pdv dateien drucken,
+           init pdv,
+           pdv:
+LET  menukarte       = "ls-MENUKARTE:Prozess",
+     niltext         =         "",
+     maxlaenge       =         45,
+     maxnamenslaenge =         35;
+WINDOW VAR w :: window (1, 3, 79, 19);
+TEXT   VAR programmname :: "";
+BOOL   VAR noch kein programm gelaufen :: TRUE;
+PROC pdv:
+  init pdv;
+  install menu (menukarte, FALSE);
+
+  handle menu  ("PDV")
+END PROC pdv;
+PROC init pdv:
+  programmname := "";
+  noch kein programm gelaufen := TRUE;
+  cursor off;
+END PROC init pdv;
+PROC pdv befehlsuebersicht anzeigen:
+  menuinfo (anwendungstext (20))
+END PROC pdv befehlsuebersicht anzeigen;
+PROC pdv ausgabebefehle anzeigen:
+  INT VAR i;
+  REP
+    i := menualternative (anwendungstext (1), anwendungstext (3),
+                          anwendungstext (4), 5, TRUE);
+    SELECT i OF
+      CASE 1, 101: menuinfo (anwendungstext (21))
+
+      CASE 2, 102: menuinfo (anwendungstext (22))
+      CASE 3, 103: menuinfo (anwendungstext (23))
+      CASE 4, 104: menuinfo (anwendungstext (24))
+      CASE 5, 105: menuinfo (anwendungstext (25))
+    END SELECT
+  UNTIL i = 6 OR i = 106 PER;
+END PROC pdv ausgabebefehle anzeigen;
+PROC pdv eingabebefehle anzeigen:
+  INT VAR i;
+  REP
+    i := menualternative (anwendungstext (2), anwendungstext (3),
+                          anwendungstext (4), 5, TRUE);
+    SELECT i OF
+      CASE 1, 101: menuinfo (anwendungstext (31))
+
+      CASE 2, 102: menuinfo (anwendungstext (32))
+      CASE 3, 103: menuinfo (anwendungstext (33))
+      CASE 4, 104: menuinfo (anwendungstext (34))
+      CASE 5, 105: menuinfo (anwendungstext (35))
+    END SELECT
+  UNTIL i = 6 OR i = 106 PER;
+END PROC pdv eingabebefehle anzeigen;
+PROC pdv testbefehle anzeigen:
+  INT VAR i;
+  REP
+    i := menualternative (anwendungstext (5), anwendungstext (7),
+                          anwendungstext (8), 5, TRUE);
+    SELECT i OF
+      CASE 1, 101: menuinfo (anwendungstext (41))
+
+      CASE 2, 102: menuinfo (anwendungstext (42))
+    END SELECT
+  UNTIL i = 3 OR i = 103 PER;
+END PROC pdv testbefehle anzeigen;
+PROC pdv weitere befehle anzeigen:
+  INT VAR i;
+  REP
+    i := menualternative (anwendungstext (6), anwendungstext (7),
+                          anwendungstext (8), 5, TRUE);
+    SELECT i OF
+      CASE 1, 101: menuinfo (anwendungstext (43))
+      CASE 2, 102: menuinfo (anwendungstext (44))
+    END SELECT
+  UNTIL i = 3 OR i = 103 PER;
+END PROC pdv weitere befehle anzeigen;
+
+PROC pdv bitmuster erlaeutern:
+  menuinfo (anwendungstext (46))
+END PROC pdv bitmuster erlaeutern;
+PROC pdv symbole erlaeutern:
+  menuinfo (anwendungstext (47))
+END PROC pdv symbole erlaeutern;
+PROC pdv digital analog werte:
+  menuinfo (anwendungstext (48))
+END PROC pdv digital analog werte;
+PROC pdvdateien verzeichnis:
+  disable stop;
+  forget ("Verzeichnis der Dateien", quiet);
+  THESAURUS VAR programme :: ALL myself;
+  FILE VAR f ::
+  sequential file (output, "Verzeichnis der Dateien");
+
+  f FILLBY programme;
+  modify (f);
+  to line (f, 1); insert record (f);
+  menufootnote ("Verlassen: <ESC> <q>");
+  cursor on;
+  show (w, f);
+  cursor off;
+  forget ("Verzeichnis der Dateien", quiet);
+  IF is error
+     THEN regenerate menuscreen;
+          out (""7"");
+          menuinfo  (" " + invers ("FEHLER: " + errormessage));
+          clear error
+     ELSE menu bildschirm
+  FI;
+  enable stop
+END PROC pdvdateien verzeichnis;
+PROC pdvprogramm neu erstellen:
+  hole programmname;
+
+  kontrolliere den programmnamen;
+  command dialogue (FALSE);
+  cursor on;
+  disable stop;
+  stdinfoedit (programmname, 3);
+  cursor off;
+  command dialogue (TRUE);
+  IF is error
+     THEN regenerate menuscreen;
+          out (""7"");
+          menuinfo  (" " + invers (errormessage));
+          clear error
+     ELSE menu bildschirm
+  FI;
+  enable stop.
+  hole programmname:
+    programmname := "";
+    programmname := menuanswer (ausgabe, programmname, 5).
+  ausgabe:
+    center (maxlaenge, invers ("Programm neu erstellen")) + ""13""13""
+
+                 + " Bitte den Namen für das Programm "13""13"".
+  kontrolliere den programmnamen:
+    IF   programmname = niltext
+         THEN LEAVE pdvprogramm neu erstellen
+    ELIF length (programmname) > maxnamenslaenge
+         THEN meckere zu langen namen an;
+              programmname := niltext;
+              LEAVE pdvprogramm neu erstellen
+    ELIF exists (programmname)
+         THEN meckere existierendes programm an;
+              LEAVE pdvprogramm neu erstellen
+    FI.
+END PROC pdvprogramm neu erstellen;
+
+PROC pdvprogramm ansehen:
+  IF programmname <> niltext CAND exists (programmname)
+     THEN frage nach diesem programm
+     ELSE lasse programm auswaehlen
+  FI;
+  cursor on;
+  disable stop;
+  stdinfoedit (programmname, 3);
+  cursor off;
+  IF is error
+     THEN regenerate menuscreen;
+          out (""7"");
+          menuinfo  (" " + invers ("FEHLER: " + errormessage));
+          clear error
+     ELSE menu bildschirm
+  FI;
+  enable stop.
+  frage nach diesem programm:
+    IF menuno (ueberschrift + " Zuletzt bearbeitetes Programm: " + name
+
+              + " Soll mit diesem Programm gearbeitet werden", 5)
+       THEN lasse programm auswaehlen
+    FI.
+  ueberschrift:
+    center (maxlaenge, invers ("Programm ansehen/ändern")) + ""13""13"".
+  name:
+    ""13""13" " + invers (programmname) + ""13""13"".
+  lasse programm auswaehlen:
+    THESAURUS VAR verfuegbare :: ALL myself;
+    IF NOT not empty (verfuegbare)
+       THEN noch kein programm;
+            LEAVE pdvprogramm ansehen
+       ELSE biete auswahl an
+    FI.
+  biete auswahl an:
+
+    programmname := menuone (verfuegbare, "Programm ansehen/ändern",
+                             "Bitte das gewünschte Programm ankreuzen!",
+                              FALSE);
+    IF programmname = niltext
+       THEN menu bildschirm;
+            LEAVE pdvprogramm ansehen
+    FI.
+END PROC pdvprogramm ansehen;
+PROC pdvdateien drucken:
+  lasse programme auswaehlen;
+  drucke programme;
+  menu bildschirm.
+  lasse programme auswaehlen:
+    THESAURUS VAR verfuegbare :: ALL myself;
+    IF NOT not empty (verfuegbare)
+
+       THEN noch kein programm;
+            LEAVE pdvdateien drucken
+       ELSE biete auswahl an
+    FI.
+  biete auswahl an:
+    verfuegbare := menusome (verfuegbare, "Dateien drucken",
+                   "Bitte die Dateien ankreuzen, die gedruckt werden sollen!",
+                    FALSE).
+  drucke programme:
+    show menuwindow;
+    steige ggf bei leerem thesaurus aus;
+    menuwindowout (menuwindowcenter (invers ("Dateien drucken")));
+    menuwindowline (2);
+    command dialogue (FALSE);
+
+    fuehre einzelne operationen aus;
+    command dialogue (TRUE);
+    schlage ggf neue seite auf;
+    menuwindowout (" Alle ausgewählten Dateien wurden gedruckt!");
+    menuwindowstop.
+  fuehre einzelne operationen aus:
+    INT VAR k;
+    FOR k FROM 1 UPTO highest entry (verfuegbare) REP
+      IF name (verfuegbare, k) <> ""
+         THEN disable stop;
+              menuwindowout ( " """ + name (verfuegbare, k) +
+                              """ wird gedruckt!");
+              menuwindowline;
+
+              print (name (verfuegbare, k));
+              fehlerbehandlung
+      FI
+    PER.
+  steige ggf bei leerem thesaurus aus:
+    IF NOT not empty (verfuegbare)
+       THEN menuwindowline (2);
+            menuwindowout (" Es wurde keine Datei ausgewählt!");
+            menuwindowstop;
+            menu bildschirm;
+            LEAVE pdvdateien drucken
+    FI.
+  schlage ggf neue seite auf:
+    IF remaining menuwindowlines < 7
+       THEN menuwindowpage; menuwindowline
+       ELSE menuwindowline (2)
+
+    FI.
+  fehlerbehandlung:
+    IF is error
+       THEN regenerate menuscreen; out (""7"");
+            menuinfo  (" " + invers (errormessage));
+            clear error; enable stop;
+            LEAVE pdvdateien drucken
+       ELSE enable stop
+    FI.
+END PROC pdvdateien drucken;
+PROC pdvdatei kopieren:
+  ermittle alten programmnamen;
+  erfrage neuen programmnamen;
+  kopiere ggf das programm.
+  ermittle alten programmnamen:
+    IF NOT not empty (ALL myself)
+       THEN noch kein programm;
+
+            LEAVE pdvdatei kopieren
+       ELSE biete auswahl an
+    FI.
+  biete auswahl an:
+    TEXT VAR alter name := menuone (ALL myself, "Datei kopieren",
+            "Bitte die Datei ankreuzen, das kopiert werden soll!",FALSE);
+    menu bildschirm;
+    IF alter name = niltext
+       THEN LEAVE pdvdatei kopieren
+    FI.
+  erfrage neuen programmnamen:
+    TEXT VAR neuer name :: menuanswer (ausgabe, alter name, 5).
+  ausgabe:
+     ueberschrift + " Name der 'alten' Datei: " + bisheriger name
+
+                  + " Bitte den Namen für die Kopie: ".
+  ueberschrift:
+    center (maxlaenge, invers ("Datei kopieren")) + ""13""13"".
+  bisheriger name:
+    ""13""13" " + invers (alter name) + ""13""13"".
+  kopiere ggf das programm:
+    IF   neuer name = niltext
+         THEN menuinfo (" " + invers ("Der gewünschte Name ist unzulässig!"));
+              LEAVE pdvdatei kopieren
+    ELIF exists (neuer name)
+         THEN mache vorwurf;
+              LEAVE pdvdatei kopieren
+       ELSE copy (alter name, neuer name)
+
+    FI.
+  mache vorwurf:
+    menuinfo (" " + invers ("Eine Datei mit diesem Namen gibt es bereits!")).
+END PROC pdvdatei kopieren;
+PROC pdvdatei umbenennen:
+  ermittle alten programmnamen;
+  erfrage neuen programmnamen;
+  benenne ggf das programm um.
+  ermittle alten programmnamen:
+    IF NOT not empty (ALL myself)
+       THEN noch kein programm;
+            LEAVE pdvdatei umbenennen
+       ELSE biete auswahl an
+    FI.
+  biete auswahl an:
+    TEXT VAR alter name := menuone ( ALL myself, "Datei umbenennen",
+
+        "Bitte die Datei ankreuzen, die umbenannt werden soll!", FALSE);
+    menu bildschirm;
+    IF alter name = niltext
+       THEN LEAVE pdvdatei umbenennen
+    FI.
+  erfrage neuen programmnamen:
+    TEXT VAR neuer name :: menuanswer (ausgabe, alter name, 5).
+  ausgabe:
+     ueberschrift + " Bisheriger  Dateiname: " + bisheriger name
+                  + " Zukünftiger Dateiname: ".
+  ueberschrift:
+    center (maxlaenge, invers ("Datei umbenennen")) + ""13""13"".
+  bisheriger name:
+
+    ""13""13" " + invers (alter name) + ""13""13"".
+  benenne ggf das programm um:
+    IF   neuer name = niltext
+         THEN menuinfo (" " + invers ("Der gewünschte Name ist unzulässig!"));
+              LEAVE pdvdatei umbenennen
+    ELIF exists (neuer name)
+         THEN mache vorwurf;
+              LEAVE pdvdatei umbenennen
+       ELSE rename (alter name, neuer name);
+            programmname := neuer name
+    FI.
+  mache vorwurf:
+    menuinfo (" " + invers ("Eine Datei mit diesem Namen gibt es bereits!")).
+
+END PROC pdvdatei umbenennen;
+PROC pdvdateien loeschen:
+  lasse programme auswaehlen;
+  loesche programme;
+  menu bildschirm.
+  lasse programme auswaehlen:
+    THESAURUS VAR verfuegbare :: ALL myself;
+    IF NOT not empty (verfuegbare)
+       THEN noch kein programm;
+            LEAVE pdvdateien loeschen
+       ELSE biete auswahl an
+    FI.
+  biete auswahl an:
+    verfuegbare := menusome (verfuegbare, "Dateien löschen",
+    "Bitte alle Dateien ankreuzen, die gelöscht werden sollen!", FALSE).
+
+  loesche programme:
+    show menuwindow;
+    steige ggf bei leerem thesaurus aus;
+    menuwindowout (menuwindowcenter (invers ("Dateien löschen")));
+    menuwindowline (2);
+    command dialogue (FALSE);
+    fuehre einzelne operationen aus;
+    command dialogue (TRUE);
+    schlage ggf neue seite auf;
+    menuwindowout (" Alle ausgewählten Dateien wurden gelöscht!");
+    menuwindowstop.
+  fuehre einzelne operationen aus:
+    INT VAR k;
+    FOR k FROM 1 UPTO highest entry (verfuegbare) REP
+
+      IF name (verfuegbare, k) <> ""
+         THEN disable stop;
+              IF menuwindowyes (" """ + name (verfuegbare, k) + """ löschen")
+                 THEN forget (name (verfuegbare, k), quiet)
+              FI;
+              fehlerbehandlung
+      FI
+    PER;
+    programmname := "".
+  steige ggf bei leerem thesaurus aus:
+    IF NOT not empty (verfuegbare)
+       THEN menuwindowline (2);
+            menuwindowout (" Es wurde keine Datei ausgewählt!");
+            menuwindowstop;
+
+            menu bildschirm;
+            LEAVE pdvdateien loeschen
+    FI.
+  schlage ggf neue seite auf:
+    IF remaining menuwindowlines < 7
+       THEN menuwindowpage; menuwindowline
+       ELSE menuwindowline (2)
+    FI.
+  fehlerbehandlung:
+    IF is error
+       THEN regenerate menuscreen; out (""7"");
+            menuinfo  (" " + invers (errormessage));
+            clear error; enable stop;
+            LEAVE pdvdateien loeschen
+       ELSE enable stop
+    FI.
+END PROC pdvdateien loeschen;
+
+PROC pdvprogramm starten:
+  programmname ermitteln;
+  bildschirm vorbereiten;
+  cursor on;
+  disable stop;
+  warnings off;
+  check on;
+  run pdv (programmname);
+  noch kein programm gelaufen := FALSE;
+  cursor off;
+  IF is error
+     THEN fehler ggf melden;
+          clear error
+     ELSE regenerate menuscreen
+  FI;
+  enable stop.
+  bildschirm vorbereiten:
+    cursor (17, 2); out (waagerecht);
+    cursor (38, 2); out (waagerecht);
+    cursor ( 1, 3); out (""4"");
+    menufootnote ("Programmabbruch: <ESC><h>");
+
+    cursor (1, 5);
+    out ("Das Programm wird übersetzt.  Zeilen-Nr.: ").
+  fehler ggf melden:
+    IF errormessage <> ""
+       THEN fehler melden
+    FI.
+  fehler melden:
+    IF   pos (errormessage, "'halt' vom Terminal") > 0
+       THEN regenerate menuscreen;
+            out (""7""); menuinfo (" "15"'halt' vom Terminal "14"")
+    ELIF pos (errormessage, "Programm-Abbruch durch <ESC><h>") > 0
+       THEN regenerate menuscreen;
+            out (""7""); menuinfo (" "15"Programm-Abbruch durch <ESC><h> "14"")
+
+    ELIF pos (errormessage, "(bei Zeile") > 0 AND exists (programmname)
+       THEN programm mit fehler im notebook zeigen;
+            regenerate menuscreen
+       ELSE regenerate menuscreen;
+            out (""7""); menuinfo  (" " + invers ("FEHLER: "
+                                        + subtext (errormessage, 1, 61)))
+    FI.
+  programm mit fehler im notebook zeigen:
+    noteline;
+    note ("FEHLER: " + errormessage);
+    INT VAR n; FOR n FROM 1 UPTO 9 REP noteline PER;
+    note (""15"Verlassen: <ESC><q> "14"");
+
+    FILE VAR p :: sequential file (modify, programmname);
+    to line (p, max (1, fehlerzeile));
+    col (1);
+    clear error;
+    out (""7"");
+    cursor on;
+    noteedit (p);
+    cursor off.
+  fehlerzeile:
+    int (subtext (errormessage, zahlposition)).
+    zahlposition: pos (errormessage, "(bei Zeile") + 10.
+  programmname ermitteln:
+    IF programmname <> niltext CAND exists (programmname)
+       THEN frage nach diesem programm
+       ELSE lasse programm auswaehlen
+    FI.
+  frage nach diesem programm:
+
+    IF menuno (ueberschrift + " Zuletzt bearbeitetes Programm: " +
+               name + " Soll mit diesem Programm gearbeitet werden", 5)
+       THEN lasse programm auswaehlen
+    FI.
+  ueberschrift:
+    center (maxlaenge, invers ("Programm starten")) + ""13""13"".
+  name:
+    ""13""13" " + invers (programmname) + ""13""13"".
+  lasse programm auswaehlen:
+    THESAURUS VAR verfuegbare :: ALL myself;
+    IF NOT not empty (verfuegbare)
+       THEN noch kein programm;
+            LEAVE pdvprogramm starten
+
+       ELSE biete auswahl an
+    FI.
+  biete auswahl an:
+    programmname := menuone (verfuegbare, "Programm starten",
+                    "Bitte das gewünschte Programm ankreuzen!", FALSE);
+    IF programmname = niltext
+       THEN menubildschirm;
+            LEAVE pdv programm starten
+    FI.
+END PROC pdvprogramm starten;
+PROC pdv programm wiederholen:
+  bildschirm vorbereiten;
+  cursor on;
+  disable stop;
+  IF noch kein programm gelaufen
+     THEN errorstop ("Eine Wiederholung ist nicht moeglich!")
+
+     ELSE run pdv again
+  FI;
+  cursor off;
+  regenerate menuscreen;
+  IF is error
+     THEN zeige fehler;
+          clear error
+  FI;
+  enable stop.
+  bildschirm vorbereiten:
+    cursor (17, 2); out (waagerecht);
+    cursor (38, 2); out (waagerecht);
+    cursor ( 1, 3); out (""4"");
+    menufootnote ("Programmabbruch: <ESC><h>");
+    cursor (1,3).
+  zeige fehler:
+    out (""7"");
+    IF errormessage = "'run again' nicht moeglich"
+       THEN menuinfo (" "15"Eine Wiederholung ist nicht moeglich! "14"")
+
+    ELIF pos (errormessage, "'halt' vom Terminal") > 0
+       THEN menuinfo (" "15"'halt' vom Terminal "14"")
+    ELIF pos (errormessage, "Programm-Abbruch durch <ESC><h>") > 0
+       THEN menuinfo (" "15"Programm-Abbruch durch <ESC><h> "14"")
+       ELSE menuinfo (" " + invers ("FEHLER: "
+                          + subtext (errormessage, 1, 61)))
+    FI.
+END PROC pdv programm wiederholen;
+PROC meckere zu langen namen an:
+  menuinfo (" " + invers ("Hier dürfen Namen höchstens "
+                + text (max namenslaenge)
+
+                + " Zeichen lang sein!"))
+END PROC meckere zu langen namen an;
+PROC meckere existierendes programm an:
+  menuinfo (" " + invers ("Ein Programm mit diesem Namen gibt es bereits!"))
+END PROC meckere existierendes programm an;
+PROC noch kein programm:
+  menuinfo (" " + invers ("Es existiert noch kein Programm!"))
+END PROC noch kein programm;
+PROC menu bildschirm:
+  cursor (1, 2);
+  out (5 * waagerecht);
+  cursor (1, 3);
+  out (""4"");
+  cursor (1,23);
+  out (79 * waagerecht);
+
+  refresh submenu
+END PROC menu bildschirm
+END PACKET ls prozess 4
+
 
diff --git a/prozess/ls-Prozess 5 b/prozess/ls-Prozess 5
index 66bdf94..a9b5028 100644
--- a/prozess/ls-Prozess 5
+++ b/prozess/ls-Prozess 5
@@ -22,63 +22,808 @@
  
                                                                            *) 
 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{}
+       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
+