From afd4c3c448381f6eb706090911a15c162fdaf8af Mon Sep 17 00:00:00 2001 From: Lars-Dominik Braun Date: Sun, 9 Oct 2016 11:28:19 +0200 Subject: Decompress source files MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 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. --- "prozess/ls-Prozess 1 f\303\274r AKTRONIC-Adapter" | 564 +++++++++++++- ...-Prozess 1 f\303\274r MUFI als Endger\303\244t" | 557 ++++++++++++- .../ls-Prozess 1 f\303\274r MUFI im Terminalkanal" | 511 +++++++++++- prozess/ls-Prozess 2 | 227 +++++- prozess/ls-Prozess 3 | 9 +- prozess/ls-Prozess 4 | 606 ++++++++++++++- prozess/ls-Prozess 5 | 863 +++++++++++++++++++-- 7 files changed, 3133 insertions(+), 204 deletions(-) (limited to 'prozess') diff --git "a/prozess/ls-Prozess 1 f\303\274r AKTRONIC-Adapter" "b/prozess/ls-Prozess 1 f\303\274r AKTRONIC-Adapter" index c42cfa5..d49d9d2 100644 --- "a/prozess/ls-Prozess 1 f\303\274r AKTRONIC-Adapter" +++ "b/prozess/ls-Prozess 1 f\303\274r 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 <"{} + 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 <"{} + 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 <"{} + 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 <" + + 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 <" + + 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 <" + + 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\303\274r MUFI als Endger\303\244t" "b/prozess/ls-Prozess 1 f\303\274r MUFI als Endger\303\244t" index 4d2a5f4..3408230 100644 --- "a/prozess/ls-Prozess 1 f\303\274r MUFI als Endger\303\244t" +++ "b/prozess/ls-Prozess 1 f\303\274r MUFI als Endger\303\244t" @@ -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 <"{} + 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 <"{} + 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 <"{} + 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 <" + + 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 <" + + 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 <" + + 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\303\274r MUFI im Terminalkanal" "b/prozess/ls-Prozess 1 f\303\274r MUFI im Terminalkanal" index d1edbc1..712b8a2 100644 --- "a/prozess/ls-Prozess 1 f\303\274r MUFI im Terminalkanal" +++ "b/prozess/ls-Prozess 1 f\303\274r 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 <"{} + 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 <"{} + 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 <"{} - + 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 <" + + 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 <" + + 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 <" + + + 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: ");{} 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: ");{} - 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 ") > 0{} THEN regenerate menuscreen;{} out (""7""); menuinfo (" "15"Programm-Abbruch durch "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: "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: ");{} 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 ") > 0{} THEN menuinfo (" "15"Programm-Abbruch durch "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: "); + 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: "); + + 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 ") > 0 + THEN regenerate menuscreen; + out (""7""); menuinfo (" "15"Programm-Abbruch durch "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: "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: "); + 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 ") > 0 + THEN menuinfo (" "15"Programm-Abbruch durch "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ü: ");{} 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ü: ");{} 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: ");{} 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 !"){} 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ü: ");{} 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ü: ");{} 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ü: ");{} 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: ");{} 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ü: "); + 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ü: "); + 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: "); + 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 !") + 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ü: "); + 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ü: "); + 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ü: "); + 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: "); + 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 + -- cgit v1.2.3