diff options
| author | Lars-Dominik Braun <lars@6xq.net> | 2019-02-04 13:09:03 +0100 |
|---|---|---|
| committer | Lars-Dominik Braun <lars@6xq.net> | 2019-02-04 13:09:03 +0100 |
| commit | 04e68443040c7abad84d66477e98f93bed701760 (patch) | |
| tree | 2b6202afae659e773bf6916157d23e83edfa44e3 /app/gs.process | |
| download | eumel-src-04e68443040c7abad84d66477e98f93bed701760.tar.gz eumel-src-04e68443040c7abad84d66477e98f93bed701760.tar.bz2 eumel-src-04e68443040c7abad84d66477e98f93bed701760.zip | |
Initial import
Diffstat (limited to 'app/gs.process')
22 files changed, 5114 insertions, 0 deletions
diff --git a/app/gs.process/1.02/doc/Anhang Prozess b/app/gs.process/1.02/doc/Anhang Prozess new file mode 100644 index 0000000..8415268 --- /dev/null +++ b/app/gs.process/1.02/doc/Anhang Prozess @@ -0,0 +1,92 @@ +limit (11.0)##pagelength (16.5)##block# +#start (2.0,0.0)# +#page (1)# +#headodd# +#center#gs-Prozess#right#% + +#end# +#headeven# +%#center#gs-Prozess + +#end# +#center#1 + +#center##on("b")#Anhang#off("b")# + +#center##on("b")#Bezugsquellenverzeichnis#off("b")# + + + - AKTRONIK + Elektronik-Großhandel + A. Kaup + Teichstraße 9 + 4401 Saerbeck + Tel.: 02574/8008 - 8009 + + + + - BICOS Computer GmbH + Werkering 6 + Postfach 1229 + 4800 Bielefeld 1 + Tel.: 0521/34011 + + + + - lattasoft + Eva Latta-Weber + Software- und + Hardware-Systeme + Brehmstraße 7 + 4800 Bielefeld 1 + Tel.: 0521/38919 + + + + - Landesinstitut für Schule + und Weiterbildung + Paradieser Weg 64 + 4770 Soest + Tel.: 02921/683-1 + +#page# +#on("b")#Anhang#off("b")# + +#on("b")#Verzeichnis der Abbildungen#off("b")# + +Abb. 1: MUFI geöffnet +Abb. 2: Mögliche DIP-Schalter-Stellung beim MUFI +Abb. 3: Einbau des MUFIs in den Terminalkanal +Abb. 4: RS232-Adapter geöffnet +Abb. 5: Mögliche Jumperposition beim RS232-Adapter +Abb. 6: Auswahl der Interface-Anpassung +Abb. 7: Anschluß Leuchtdiodenanzeige -Kombikarte +Abb. 8: Pinbelegung auf der E/A-Karte +Abb. 9: Eingangsbildschirm ls-Prozess +Abb.10: Menubildschirm zum Oberbegriff 'Interface' +Abb.11: Information bei unkonfiguriertem System +Abb.12: Auswahl der Steckplatzart +Abb.13: Compact-Box: Belegung der Kanäle +Abb.14: Auswahl einer Interfacekarte +Abb.15: Kanalbelegung D/A-Karte (Einzelsteckplatz) +Abb.16: A/D-Karte: Angabe der Schalterstellung +Abb.17: A/D-Karte: Kanalbel./Spannungsber.(Bspl.) +Abb.18: Ausgabetest - Einblendung +Abb.19: Eingabetest - Einblendung +Abb.20: Beispiellochkarte +Abb.21: Aufbau eines Drehpotentiometers +Abb.22: Eingangsbildschirm ls-Prozess +Abb.23: Befehlsübersicht +Abb.24: Auswahl Ausgabebefehle +Abb.25: Auswahl Eingabebefehle +Abb.26: Auswahl Testbefehle +Abb.27: Auswahl 'Weitere Befehle' +Abb.28: Menubildschirm zum Oberbegriff 'Interface' +Abb.29: Menubildschirm zum Oberbegriff 'Programm' +Abb.30: Informationsauswahl zum EUMEL-Editor +Abb.31: Menubildschirm zum Oberbegriff 'Archiv' +Abb.32: Auswahl der Archiv-Formate +Abb.33: Auswahl der Zieltask + + + diff --git a/app/gs.process/1.02/doc/Inhalt Prozess b/app/gs.process/1.02/doc/Inhalt Prozess new file mode 100644 index 0000000..ab9616a --- /dev/null +++ b/app/gs.process/1.02/doc/Inhalt Prozess @@ -0,0 +1,84 @@ +limit (11.0)##pagelength (16.5)##block# +#start (2.0,0.0)# +#page (1)# +#headodd# +#center#gs-Prozess#right#% + +#end# +#headeven# +%#center#gs-Prozess + +#end# +#center#1 + +#center##on("b")#Inhaltsverzeichnis#off("b")# + +1 Was kann gs-Prozess + +2 Allgemeines zur Prozeßdatenverarbeitung +2.1 Welche Hardware-Lösungen gibt es zur Zeit ? +2.2 Die besonderen Probleme unter EUMEL +2.3 Die Wahl des Interface-Systems + +3 Installation des Interface-Systems +3.1 Das MUFI der Firma BICOS als Adapter +3.1.1 Einstellung der DIP-Schalter am MUFI +3.1.2 Einbau des MUFIs in den Terminalkanal +3.1.3 Das MUFI an separater serieller Schnittstelle +3.2 Der RS232-Adapter der Firma AKTRONIK +3.3 Verbindung Adapter - Interface-System +3.4 Bereitstellung des Interface-Systems + +4 Installation von gs-Prozess +4.1 Voraussetzungen +4.2 Lieferumfang +4.3 Installation +4.4 Anmerkungen zur Erstinstallation + +5 Konfiguration von gs-Prozess +5.1 Kontrolle der Konfigurationen/Anschlüsse +5.2 Vorbereitungen für den Ein-/Ausgabetest +5.2.1 Anschluß einer Leuchtdiodenanzeige an die Kombikarte +5.2.2 Anschluß des Codekartenlesers (Drahtstück) +5.3 Konfiguration von gs-Prozess +5.3.1 Auswahl der Steckplatzart/Interfacekarte +5.3.2 Bedeutung der Kanalnummern +5.4 Aus- und Eingabetest +5.5 Mögliche Fehlerfälle + +6 Arbeiten mit gs-Prozess +6.1 Kleine Beispiele zur digitalen Ausgabe +6.1.1 Möglichkeit eines Programmabbruchs +6.1.2 Die "sonstigen" Befehle +6.1.3 Schreibweise für Bitmuster/Bitsymbole +6.1.4 Befehle für die digitale Ausgabe +6.1.5 Befehle für die analoge Ausgabe +6.2 Kleine Beispiele zur digitalen Eingabe +6.2.1 Befehle für die digitale Eingabe +6.2.2 Eingabetests +6.2.3 Befehle für die analoge Eingabe +6.3 Hinweise auf Aufgabenmaterial + +7 Beschreibung der Menufunktionen +7.1 Kurzhinweise zur Bedienung der Menus +7.2 Menufunktionen zum Oberbegriff 'Info' +7.3 Menufunktionen zum Oberbegriff 'Interface' +7.4 Menufunktionen zum Oberbegriff 'Programm' +7.5 Menufunktionen zum Oberbegriff 'Archiv' + +8 Detailbeschreibung der Basisbefehle und Tests + +9 Hinweise für den Systembetreuer/ Programmierer +9.1 Vergabe der Kanäle/Organisation des Tasksystems +9.2 Informationsprozeduren +9.3 Neufestlegung des Interfacekanals +9.4 Fixieren der Konfiguration +9.5 Mögliche Fehlerfälle +9.6 Weitere Möglichkeiten + +Anhang: Bezugsquellenverzeichnis + Verzeichnis der Abbildungen + + + + diff --git a/app/gs.process/1.02/doc/gs-Prozess handbuch.impressum b/app/gs.process/1.02/doc/gs-Prozess handbuch.impressum new file mode 100644 index 0000000..ca22b10 --- /dev/null +++ b/app/gs.process/1.02/doc/gs-Prozess handbuch.impressum @@ -0,0 +1,104 @@ +____________________________________________________________________________ + + +#on("b")##on ("u")# +#center#Betriebssystem E U M E L +#off ("u")# + + +#center#gs-Prozess + + + + +#off("b")# +#center#Lizenzfreie Software der +#on ("b")# + +#center#Gesellschaft für Mathematik und Datenverarbeitung mbH, +#center#5205 Sankt Augustin + + +#off("b")# +#center#Die Nutzung der Software ist nur im Schul- und Hochschulbereich für +#center#nichtkommerzielle Zwecke gestattet. + +#center#Gewährleistung und Haftung werden ausgeschlossen + + +____________________________________________________________________________ +#page# + +#free (4.0)##on("b")# +#center#gs-Prozess + + +#center#Benutzerhandbuch + + +#center#Version 1.0 + + +#off("b")##center#copyright +#center#Eva Latta-Weber +#center#Software- und Hardware-Systeme, 1988 +#center#ERGOS GmbH, 1990 +#page# +#block# +#center#____________________________________________________________________________ + + +Copyright: ERGOS GmbH März 1990 + + Alle Rechte vorbehalten. Insbesondere ist die Überführung in + maschinenlesbare Form sowie das Speichern in Informations + systemen, auch auszugsweise, nur mit schriftlicher Einwilligung + der ERGOS GmbH gestattet. + + +#center#____________________________________________________________________________ + +Es kann keine Gewähr übernommen werden, daß das Programm für eine +bestimmte Anwendung geeignet ist. Die Verantwortung dafür liegt beim +Anwender. + +Das Handbuch wurde mit größter Sorgfalt erstellt. Für die Korrektheit und +Vollständigkeit der Angaben kann keine Gewähr übernommen werden. Das +Handbuch kann jederzeit ohne Ankündigung geändert werden. + +Texterstellung : Dieser Text wurde mit der ERGOS-L3 Textverarbeitung + erstellt und aufbereitet und auf einem Kyocera Laser + drucker gedruckt. + + + + +#center#___________________________________________________________________________ + + + +Ergonomic Office Software GmbH + +Bergstr. 7 Telefon: (02241) 63075 +5200 Siegburg Teletex: 2627-2241413=ERGOS + Telefax: (02241) 63078 + + +#center#____________________________________________________________________________ + + + + + + + + + + + + + + + + + diff --git a/app/gs.process/1.02/doc/gs-Prozess-2 b/app/gs.process/1.02/doc/gs-Prozess-2 new file mode 100644 index 0000000..376143e --- /dev/null +++ b/app/gs.process/1.02/doc/gs-Prozess-2 @@ -0,0 +1,255 @@ +limit (11.0)##pagelength (16.5)##block# +#start (2.0,0.0)# +#page (1)# +#headodd# +#center#gs-Prozess#right#% + +#end# +#headeven# +%#center#gs-Prozess + +#end# +#center#1 + +#on("b")#2 Allgemeines zur Prozeßdatenverarbeitung#off("b")# + +In diesem Kapitel erfahren Sie, warum unter EUMEL/ELAN die Prozeßdatenver +arbeitung bisher kaum Berücksichtigung gefunden hat und welche Probleme zu +überwinden waren. Es wird aufgezeigt, warum unter EUMEL/ELAN nicht jedes Inter +facesystem verwendet werden kann; außerdem werden die Gründe für die Wahl eines +bestimmten Interfacesystems genannt. + + +#on("b")#2.1 Welche Hardware-Lösungen gibt es zur Zeit ?#off("b")# + +Wie schon in Kapitel 1 erwähnt, ist zum Messen, Steuern und Regeln mit dem +Computer ein Hardware-Interface notwendig, über das der "Kontakt zur Außenwelt" +hergestellt wird. + + +#on("b")# + Computer <--------> Interface <--------> Modell +#off("b")# + + +Interfaces (zu deutsch etwas mißverständlich: Schnittstellen) verbinden innerhalb +eines Systems Teilsysteme und einzelne Funktionseinheiten miteinander. Dabei +werden z.B. #on("b")#Hardware-Schnittstellen#off("b")# (Um diese geht es vornehmlich in diesem +Kapitel), #on("b")#Hardware-Software-Schnittstellen#off("b")# (Nach Festlegung, welche Funktionen +eines Rechnersystems von der Hardware und welche von der Software übernommen +werden, erfolgt hierüber die Verknüpfung der beiden Komponenten), #on("b")#Software- +Schnittstellen#off("b")# (zwischen Programmoduln), #on("b")#Mensch-Maschine-Schnittstellen#off("b")# +(Benutzerschnittstellen - wie z.B. #on("b")#gs-DIALOG#off("b")#) unterschieden. + +Wenn wir im folgenden von 'Interface' reden, ist damit immer eine 'Hardware- +Schnittstelle' gemeint. + +Über ein solches Interface (eine Hardware-Schnittstelle) können an den Computer +externe Geräte/Modelle angeschlossen werden, die vom Computer aus gesteuert +werden. Dabei setzt das Interface die vergleichsweise schwachen Signale des +Computers in Ströme und Spannungen um, mit denen z.B. eine Lampe oder ein +Motor betrieben werden kann. Umgekehrt senden externe Geräte/Modelle über das +Interface Signale an den Computer, die von ihm ausgewertet werden. So müssen z.B. +Widerstandsveränderungen eines Temperaturfühlers oder die Stellung eines Schalters +in eine vom Computer erfaßbare Form umgewandelt werden. + +Inzwischen bieten verschiedene Hersteller (FISCHER, LEGO, AKTRONIK, PHYWE, +etc.) und Lehrmittelverlage (METZLER, CVK, etc.) eine Reihe von Lösungen an. +Leider sind die meisten Lösungen auf ganz spezielle Computertypen zugeschnitten +und somit nicht an anderen Computertypen verwendbar - außerdem unterscheiden +sich die verschiedenen Lösungen z.T. ganz erheblich im Leistungsumfang. + +Einzellösungen, insbesondere an den gängigen Homecomputern, gibt es schon seit +langem. Voraussetzung ist zumeist, daß der Computer über einen speziellen +Anschluß ('Userport' oder 'Joystick-Eingang') verfügt. Oder es werden Platinen +geliefert, die in spezielle Steckplätze (Slots) einzustecken sind, wo sie vom Computer +aus angesprochen werden können. + +Bei all diesen Lösungen konnten wir 'EUMELaner' nur neidvoll zuschauen. Der +Vorteil, den wir sonst so zu schätzen wissen, ein einheitliches Betriebssystem auf ganz +unterschiedlicher Hardware zur Verfügung zu haben, wird hier zum Nachteil. Eine +einheitliche Lösung schien zu Anfang völlig aussichtslos zu sein. + + +#on("b")#2.2 Die besonderen Probleme unter EUMEL#off("b")# + +Das Betriebssystem EUMEL gestattet es nicht, beliebig auf Hardwarekomponenten des +Rechners zuzugreifen - und das aus gutem Grund, denn sonst wäre ein reibungsloser +Multi-User-Betrieb nicht gewährleistet. Man kann aber den Zugriff auf neue Hard +warekomponenten im EUMEL-System etablieren. Allerdings ist das etwas aufwendiger +als in anderen Systemen, denn das sogenannte 'Shard', die 'Software-Hardware- +Schnittstelle', muß angepaßt werden. + +Unsere ersten "Gehversuche" mit der Prozeßdatenverarbeitung unter EUMEL haben +so angefangen. Es ist aber leicht einzusehen, daß dieser Weg nicht sinnvoll ist. Denn +dann müßten alle EUMEL-Shards (es gibt ja für jeden Rechnertyp mindestens eines) +entsprechend geändert werden, ggf. müßten für verschiedene Lösungen verschiedene +Versionen entwickelt werden - eine Aufgabe, die niemand bereit wäre zu überneh +men. + + +#on("b")#2.3 Die Wahl des Interface-Systems#off("b")# + +Unser Ziel war klar: Wir wollten ein gängiges, käuflich zu erwerbendes Hardware- +Interface möglichst universell an Computern verschiedener Hersteller unter dem +Betriebssystem EUMEL ansprechen können. + +Nach Sichtung der angebotenen Systeme kamen nur drei in die engere Wahl: das +LEGO-Interface, das FISCHER-Technik-Interface und das AKTRONIK-Interface (Soft +ware-kompatibel dazu ist das PHYWE-Interface). + +Bei der Auswahl hielten wir es für sinnvoll, die Empfehlung des Landesinstituts für +Schule und Weiterbildung in Soest zu berücksichtigen, in der folgende Anforderungen +an Interfaces formuliert sind: + + - 8 digitale Eingänge + - 8 digitale Ausgänge + - optional: analoge Ein- und Ausgabe. + +Allen gestellten Anforderungen wird nur das AKTRONIK-Interface gerecht. Das System +ist modular aufgebaut, je nach Anforderungen kann mit verschiedenen Steckkarten +gearbeitet werden. Es gibt eine "Kompaktlösung", bei der die wichtigsten Funktionen +bereitgestellt werden (8 digitale Eingänge, 8 digitale Ausgänge, 2 analoge Eingänge). +Darüber hinaus kann auch noch mit dem sog. 'Modul-Bus' gearbeitet werden, bei +dem gleichzeitig mehrere Steckkarten angesprochen werden können. Mit ent +sprechender Steckkarte ist auch die analoge Ausgabe möglich. + +Die beiden anderen Interfaces erfüllen die oben genannten Anforderungen nicht: Das +LEGO-Interface verfügt über nur 6 digitale Ausgänge und 2 digitale Eingänge; analoge +Ein- und Ausgabe ist gar nicht möglich. + +Das FISCHER-Technik-Inteface verfügt über 8 digitale Ausgänge und 8 digitale Ein +gänge. Das Interface verfügt auch über einen analogen Eingang - allerdings nicht +über einen Analog-Digital-Wandler-Baustein! Das bedeutet, daß der angeschlossene +Rechner die Auswertung der eingehenden Daten übernehmen muß - ein zeit +kritischer Prozeß, der in einem Multi-User-System nicht garantiert werden kann. Die +analoge Ausgabe ist grundsätzlich nicht möglich, das System ist in sich abgeschlossen +und kann sich ändernden Anforderungen ebensowenig angepaßt werden wie das +LEGO-Interface. + + +Wir entschieden uns also dafür, die weitere Entwicklung auf der Basis des +AKTRONIK-Interfaces zu betreiben. Es galt jedoch noch, dieses Interface mit dem +Computer zu verbinden - und das möglichst universell: möglichst unabhängig von der +verwendeten Computerhardware. + +Dieses Ziel ist nur dann zu erreichen, wenn man die 'Standardschittstellen' des +Computers berücksichtigt, die unter EUMEL problemlos ansprechbar sind: die +parallelen (Centronics) und seriellen (V24) Schnittstellen. Diese 'Standardschnitt +stellen' sind zwar nicht für den direkten Anschluß der Modelle/Interfaces geeignet, +über einen "Adapter" aber ist ein Anschluß möglich. + +Die Entscheidung fiel schnell gegen eine Verwendung der parallelen (Centronics) +Schnittstelle. Die meisten Computer verfügen nur über eine dieser Schnittstellen, die +zumeist auch schon durch den Drucker belegt ist. Außerdem handelt es sich dabei in +der Regel um eine unidirektionale Schnittstelle - d.h. die Daten können vom +Computer zum Endgerät (z.B. Drucker) gelangen, nicht aber vom Endgerät zum +Computer. Somit wären zwar Steuerungsvorgänge, nicht aber Meß- und Regelungs +vorgänge über die Schnittstelle möglich. + +Einige Hersteller nutzen die Datenleitungen, über die z.B. der Drucker dem Rechner +mitteilt, daß der interne Speicher voll bzw. das Papier zuende ist. Über diese Leitung +werden Daten seriell übertragen und vom Rechner ausgewertet. Unter EUMEL +scheidet diese Lösung aber aus, denn um hier eine sichere Auswertung zu gewähr +leisten, müßten Maschinenspracheprogramme eingebunden werden; das ist aber +unter EUMEL nicht möglich. + +Damit war festgelegt, daß die weitere Entwicklung auf der Basis des AKTRONIK-Inter +faces über die serielle Schnittstelle erfolgen sollte. Wie schon erwähnt, ist das Inter +face auf keinen Fall direkt an die serielle Schnittstelle anschließbar. Wie der Name +schon sagt, werden die Daten bei einer seriellen Schnittstelle seriell übertragen - um +Prozeßdatenverarbeitung zu betreiben, müssen die Daten aber parallel vorliegen. + +Notwendig ist also ein "Adapter", der einen Seriell-Parallel-/Parallel-Seriell-Wandler +beinhaltet, so daß die Verbindung zwischen Computer und Interface hergestellt +werden kann. + +Inzwischen sind uns hier zwei (käuflich zu erwerbende) Lösungen bekannt - der +"RS232-Adapter" der Firma AKTRONIK und das "MUFI" (Multifunktionales Interface) +der Firma BICOS: + +Das MUFI ist sicherlich der universeller verwendbare "Adapter" (leider aber auch die +kostspieligere Lösung). Einerseits kann es ebenso wie der "RS232-Adapter" an eine +separate serielle Schnittstelle angeschlossen werden, andererseits verfügt es über +einen zweiten - den eigentlich interessanten Betriebsmodus: Es kann nämlich auch +in den Terminalkanal eingebaut werden. + +Die Idee, die dahintersteckt, ist folgende: Das MUFI verfügt (neben der eigentlich +wichtigen bidirektionalen parallelen Schnittstelle) über einen (seriellen) Eingang und +einen (seriellen) Ausgang. So kann das MUFI einfach in eine Leitung zwischen +Computer und Terminal eingebaut werden. In ausgeschaltetem Zustand hat es +keinen Einfluß auf den Datenaustausch zwischen Rechner und Terminal - als ob es +gar nicht vorhanden wäre. In eingeschaltetem Zustand dagegen "horcht es den +Datenfluß zwischen Rechner und Terminal ab". Auf eine vereinbarte Parole +(Zeichenkombination) hin, "weiß es", daß die folgenden Daten nicht für das +Terminal, sondern eben für sich bestimmt sind. Diese, und nur diese Daten werden +aus dem Datenstrom vom MUFI "herausgefischt" und intern sachgerecht weiterver +arbeitet. Alle anderen Daten werden unbeeinflußt an das Terminal weitergeleitet, +damit ja nicht der reibungslose Betrieb gestört wird. Natürlich ist das MUFI ebenso in +der Lage, die gerade extern anliegenden Daten zu ermitteln und in den Datenstrom +zum Computer "einzuschleusen". + +Um diese Aufgaben bewältigen zu können, wurde das MUFI mit einem eigenen, +schnellen Mikroprozessor ausgestattet, der in der Lage ist, den Datenfluß zu +bewältigen. Zudem wurde versucht, das MUFI mit soviel Intelligenz (Firmware) +auszustatten, daß alle zeitkritischen Prozesse bei der Ansteuerung des Interface- +Systems vom MUFI selbst erledigt und die Daten vom MUFI so aufbereitet werden, +daß sie möglichst einfach weitergegeben und verarbeitet werden können. + +Durch die Beschränkung der Baud-Rate auf maximal 19200 ist die Verarbeitungs +geschwindigkeit allerdings auch beschränkt. Die rechnerisch maximale Ausgabetakt +rate von 320 Hz bei 19200 Baud und 160 Hz bei 9600 Baud wird von #on("b")#gs-Prozess#off("b")# auf +einem 80386-Rechner im Alleinbetrieb tatsächlich erreicht. Natürlich bedeuten +mehrere gleichzeitig betriebene MUFIs an einem Rechner Geschwindigkeitseinbußen. +Ebenso sinkt die Ausgabetaktrate bei Prozessoren mit geringerem Durchsatz (8088: +maximal 120 Hz). Für die Anwendungen in der Schule sind diese Geschwindigkeiten +aber hinreichend. + +Die Vorteile des MUFI für diejenigen, die EUMEL im Multi-User-Betrieb nutzen, liegen +dennoch klar auf der Hand: + + - Es werden keine weiteren seriellen Schnittstellen benötigt. (Die vorhandenen + sind sowieso schon weitgehend belegt. Gegebenenfalls würden zusätzliche + Kosten verursacht.) + + - Es sind keine weiteren Kabelverlegungen zwischen Rechner und Arbeitsplatz + notwendig, trotzdem befindet sich das MUFI direkt am Bildschirmarbeits + platz. + + - Das beim Anschluß an eine separate Schnittstelle notwendige, zeitauf + wendige Ansteuern des Interface-Kanals entfällt. + + +Arbeiten Sie an einem Einzelplatz-System (z.B. IBM-kompatibler Rechner nur mit +Monitor) so ist ein Betrieb des MUFIs im Terminal-Kanal nicht möglich. Hier bleibt +nur der Betrieb des Interface-Systems an einer separaten seriellen Schnittstelle. +Sinnvoll ist aber auch ein solcher Betrieb, wenn (zunächst) nur die Hardware für +einen Arbeitsplatz zur Verfügung steht. Das Interface kann dann nämlich von meh +reren Tasks abwechselnd angesprochen werden. + +Beim Anschluß an eine separate serielle Schnittstelle sind die Leistungen des MUFIs +und des RS232-Adapters gleichwertig. Da das abwechselnde Ansprechen einer +seriellen Schnittstelle und der Tastatur/des Monitors unter EUMEL relativ zeitauf +wendig ist, sind hier keine hohe Ausgabegeschwindigkeiten zu erwarten: bei einem +8088-Rechner ca. 40 Hz, bei Prozessoren mit höherem Durchsatz eben entsprechend +mehr. Dennoch ist das für die meisten Anwendungen in der Schule schnell genug. + +Für Spezialanwendungen ist auch die direkte Ansprache der Schnittstelle möglich. +Hierbei sind Ausgabetaktraten von 960 Hz bei 19200 Baud bzw. 480 Hz bei 9600 +Baud möglich. Für die schulische Praxis (in der Sekundarstufe I) ist diese "direkte +Ansprache" aber ungeeignet, da weitergehende Programmierkenntnisse erforderlich +sind. Zudem kann bei Programmierfehlern "die Task am Kanal hängenbleiben". +Genaueres dazu sehen Sie bitte im Kapitel 'Hinweise für den Systembetreuer/ +Programmierer'. + +Die Hardware-Konstellation stellt sich im Überblick also folgendermaßen dar: +#on("b")# + + Computer <---> Adapter <---> Interface <---> Modell + + (mit se- ('MUFI' (AKTRONIK) + rieller oder + Schnitt- 'RS232- + stelle) Adapter') +#off("b")# + diff --git a/app/gs.process/1.02/doc/gs-Prozess-3 b/app/gs.process/1.02/doc/gs-Prozess-3 new file mode 100644 index 0000000..3fae1bd --- /dev/null +++ b/app/gs.process/1.02/doc/gs-Prozess-3 @@ -0,0 +1,346 @@ +limit (11.0)##pagelength (16.5)##block# +#start (2.0,0.0)# +#page (1)# +#headodd# +#center#gs-Prozess#right#% + +#end# +#headeven# +%#center#gs-Prozess + +#end# +#center#1 + +#on("b")#3 Installation des Interface-Systems#off("b")# + +In diesem Kapitel erfahren Sie, wie Sie Ihr Interface-System an den Rechner an +schließen und welche Einstellungen noch vorzunehmen sind. Für Details und weiter +gehende Informationen sehen Sie bitte in den Handbüchern / Begleitmaterialien der +Firmen BICOS bzw. AKTRONIK nach. + +Am Ende des Kapitels 2 haben wir festgestellt, daß das Interface-System über einen +Adapter mit dem Computer verbunden werden muß. An das Interface-System lassen +sich dann entsprechende Modelle anschließen: + +#on("b")# Computer <----> Adapter <----> Interface <----> Modell + + (mit se- ('MUFI' (AKTRONIK) + rieller oder + Schnitt- 'RS232- + stelle) Adapter') #off("b")# + +Wir möchten Ihnen zuerst erklären, wie Sie den jeweiligen Adapter mit dem +Computer verbinden und welche Einstellungen am Adapter vorzunehmen sind. An +schließend beschreiben wir, wie Sie das Interface-System an den Adapter anschlie +ßen. + +Wie schon in Kapitel 2 erwähnt, können Sie zwischen zwei Adaptern wählen - dem +MUFI der Firma BICOS und dem RS232-Adapter der Firma AKTRONIK. Letztge +nannter kann nur an einer separaten seriellen Schnittstelle betrieben werden, +während das MUFI zusätzlich auch in den Terminalkanal eingebaut werden kann. + + +#on("b")#3.1 Das MUFI der Firma BICOS als Adapter#off("b")# + +Für den Betrieb in einem Terminalkanal sollte das MUFI über eine sog. "Schnitt +stellen-Automatik" verfügen, die verhindert, daß das MUFI in ausgeschaltetem +Zustand oder mit abgezogenem Netzstecker den Datenfluß zwischen Rechner und +Terminal unterbricht. Diese sehr sinnvolle Automatik wird von BICOS #on("b")#nicht +standardmäßig#off("b")# eingebaut. Sie sollten bei eventuellen Bestellungen darauf achten. +Bevor Sie das MUFI in den Terminalkanal einbauen oder an eine separate serielle +Schnittstelle anschließen, ist noch die Einstellung der DIP-Schalter zu kontrollieren +bzw. eine Neueinstellung vorzunehmen. + + +#on("b")#3.1.1 Einstellung der DIP-Schalter am MUFI#off("b")# + +Versichern Sie sich, daß das MUFI noch nicht an das Netz angeschlossen ist. Öffnen +Sie dann das Gehäuse, indem Sie die vier Schrauben an der Unterseite des MUFIs +(direkt neben den Füßen) lösen. Heben Sie nun #on("b")##on("b")#vorsichtig#off("b")##off("b")# den hellen Deckel des +Gehäuses ab. Aber Achtung! Der Deckel bleibt über Kabel mit dem Fußteil ver +bunden! Legen Sie vorsichtig den Deckel neben das MUFI, so daß die Kabelver +bindungen nicht belastet werden. + + +---------------------------------------------------+ + | +-------+ +------------+ | + | | | | | +---------+ | + | +-------+ | | | DIP- | | + | +-------+ | | | Schalter| | +Rück- | | | | | +---------+ | Vorder- +seite | +-------+ | | +--------------+ | seite + | +-------+ | SCN68000 | | | | + | | | | | +--------------+ | + | +-------+ | | | + | +-------+ | | | + | | | | | | + | +-------+ +------------+ | + +---------------------------------------------------+ + + + +#center#Abb.1: MUFI geöffnet + + +Im Inneren des Fußteiles fällt Ihnen sofort der größte CHIP auf, der u.a. die +Bezeichnung 'SCN68000' trägt. Drehen Sie das MUFI so vor sich, daß an der linken +Seite dieses Chips die vier gleichen, mittelgroßen Chips zu liegen kommen. Dann +sehen Sie rechts vom großen Chip, ganz hinten im Gehäuse eine kleine Plastikbox +mit DIP-Schaltern, die die folgende Aufschrift trägt: + +#on("b")# + O N + 1 2 3 4 +#off("b")# + +Den durchsichtigen Deckel dieser kleinen Plastikbox müssen Sie nun öffnen, um die +Stellung der DIP-Schalter einsehen zu können. Dazu verwenden Sie am besten einen +Kugelschreiber oder einen kleinen Schraubendreher. Heben Sie damit den Deckel an +der rechten Seite leicht an, dann läßt sich der Deckel nach links herüberlegen. Weist +ein Schalter nach hinten (in dieser Lage des MUFIs von Ihrem Körper weg), so hat er +die Stellung 'ON', weist er nach vorn (zu Ihrem Körper hin), so hat er die Stellung +'OFF'. + + +Beispiel: + + +---------------------------------------+ + | +-----+ +-----+ +-----+ +-----+ | + | |+++++| | | | | | | | + | |+++++| | | | | | | | ON + | |+++++| | | | | | | | + | |+++++| | | | | | | | + | | | | | | | | | | + | | | | | | | | | | + | | | | | | | | | | + | | | |+++++| |+++++| |+++++| | + | | | |+++++| |+++++| |+++++| | + | | | |+++++| |+++++| |+++++| | OFF + | | | |+++++| |+++++| |+++++| | + | +-----+ +-----+ +-----+ +-----+ | + +---------------------------------------+ + + 1 2 3 4 + +#center#Abb.2: Mögliche DIP-Schalter-Stellung beim MUFI + + +Dabei haben die DIP-Schalter folgende Bedeutung: + +#on("b")# + 1 ON : Modulbusbetrieb + OFF : Parallelportbetrieb + + 2 ON : RTS/CTS Hardware Handshake + OFF : XON-/XOFF-Protokoll + + 3 ON : 9600 Baud + OFF : 19200 Baud + + 4 ON : Even Parity + OFF : No Parity + +#off("b")# +Wenn Sie das MUFI im Terminalkanal betreiben wollen, müssen Sie je nachdem, wie +Sie Ihr Terminal konfiguriert haben, die entsprechende Einstellung vornehmen. + +Betreiben Sie das Terminal mit einer Übertragungsrate von 19200 Baud, so sollten +Sie unbedingt mit XON/XOFF-Protokoll arbeiten - es sei denn, das Terminal unter +stützt RTS/CTS! In jedem Falle muß der DIP-Schalter 1 in die Stellung ON gebracht +werden (der Betrieb des Interface-Systems der Firma AKTRONIK wird hier "Modul +busbetrieb" genannt). + +Wenn Sie das MUFI an einer separaten seriellen Schnittstelle betreiben wollen, #on("b")#muß#off("b")# +der Datenaustausch mit dem RTS/CTS-Protokoll abgewickelt werden. Versichern Sie +sich, daß Ihr Kabel darauf ausgelegt ist! + +Nach dieser Einstellung der DIP-Schalter ist das MUFI betriebsbereit. Schrauben Sie +bitte den Gehäusedeckel mit den vier Schrauben wieder fest. + + +#on("b")#3.1.2 Einbau des MUFIs in den Terminalkanal#off("b")# + +Um das MUFI in den Terminalkanal einbauen zu können, müssen Sie zunächst die +Zuleitung vom Rechner zum Terminal am Terminal lösen. Auf der Rückseite des +MUFIs befinden sich zwei Stecker, die mit V24/1 und V24/2 bezeichnet sind. Ver +inden Sie nun das Kabel, was ursprünglich vom Computer zum Terminal führte, mit +dem MUFI, indem Sie es an den mit V24/2 gekennzeichneten Stecker anstecken. Sie +benötigen jetzt noch ein weiteres (kurzes) V24-Kabel, um das MUFI mit dem +Terminal zu verbinden. Es wird einerseits auf den mit V24/1 gekennzeichneten +Stecker am MUFI aufgesteckt; das andere Ende wird mit dem Terminal in gleicher +Weise verbunden, wie das ursprüngliche Kabel zwischen Rechner und Terminal. + + + +--------------------------+ + | +----------------------+ | + | | V24/1 V24/2 | | + | | | | | | + | +----|-----------|-----+ | + +------|-----------|-------+ + | | + | | + ZUM <-----+ +-----> ZUM + TERMINAL COMPUTER + + +#center#Abb.3: Einbau des MUFIs in den Terminalkanal + + +Beachten Sie bitte, daß die V24-Schnittstellen des MUFIs auf 8 Datenbits und 1 Stop +bit fest eingestellt sind - ggf. müssen Sie Ihre Terminalkonfiguration hieran anpassen. +Kontrollieren Sie aber in jedem Falle, ob die Konfiguration mit diesen Daten überein +stimmt! + +Koppeln Sie dazu die Task 'configurator' an Ihr Terminal (mit 'continue +("configurator") <RETURN>') und geben Sie dann das Kommando 'configurate +<RETURN>'. Für alle vorhandenen Kanäle werden Sie nun nacheinander gefragt, +ob Sie eine Konfiguration vornehmen wollen. Bei den "interessanten Kanälen" ant +worten Sie mit 'ja' (<j>). + +Wollen Sie sich nur die aktuelle Konfiguration ansehen, so beantworten Sie alle dann +gestellten Fragen zum Kanal mit 'ja' (<j>), dann bleibt die aktuelle Einstellung +erhalten. Der Konfigurationsdialog ist im EUMEL-Systemhandbuch auf den Seiten 6 - +8 detailliert beschrieben. + +Die Verschaltung der V24-Kabel ist in der Bedienungsanweisung zum MUFI erläutert, +ggf. können Sie entsprechende Kabel von der Firma BICOS beziehen. + +Wenn alle Kabelverbindungen gesteckt sind, sollten Sie auf alle Fälle erst einmal #on("b")#bei +ausgeschaltetem MUFI#off("b")# prüfen, ob das Terminal sich noch bedienen läßt. Wenn das +Terminal keine Reaktion mehr zeigt, obwohl es vorher (ohne MUFI) reibungslos +funktioniert hat, dann haben Sie entweder ein MUFI ohne "Schnittstellen-Automatik" +vor sich (vergl. Sie dazu Kap. 3.1), oder an den Kabelverbindungen stimmt irgend +etwas nicht. In diesem Falle sollten Sie noch einmal alle Anschlüsse und eventuell +auch die interne Verschaltung der Kabel überprüfen. + + +#on("b")#3.1.3 Das MUFI an separater serieller Schnittstelle#off("b")# + +Wenn Sie das MUFI als Endgerät an einer separaten seriellen Schnittstelle betreiben, +dann stecken Sie das vom Computer kommende Kabel auf den mit V24/2 +bezeichneten Stecker an der Rückseite des MUFIs. Damit ein einwandfreier Betrieb +gewährleistet ist, sollten Sie einen sog. "Kurzschlußstecker" auf die dann freie +25polige D-Subminiatur-Buchse (V24/1) am MUFI aufstecken. Haben Sie eine solche +nicht zur Hand, können Sie zwei kleine Brücken einsetzen: Nehmen Sie dazu zwei +kleine Drahtstücke und verbinden Sie einmal Pin (Öffnung) 2 mit Pin 3 und außer +dem Pin 4 mit Pin 5. + +In der Task 'configurator' muß der Kanal, an dem das MUFI angeschlossen ist, auf +'transparent, 8 Bit, 1 Stopbit, RTS/CTS-Protokoll' eingestellt werden, weiterhin je nach +MUFI-DIP-Schalter-Stellung auf '9600' bzw. '19200 Baud' und 'no parity' bzw. 'even +parity'. + + +#on("b")#3.2 Der RS232-Adapter der Firma AKTRONIK#off("b")# + +Bevor Sie den Adapter an die serielle Schnittstelle anschließen, ist noch die einge +stellte Baudrate zu überprüfen bzw. eine Neueinstellung vorzunehmen. + +Öffnen Sie das Gehäuse des Adapters, indem Sie die vier Schrauben an der Unterseite +lösen. Drehen Sie den Adapter so vor sich, daß die 25polige D-Subminiatur-Buchse +von Ihrem Körper wegzeigt. Vorn rechts sind dann zwei parallele 8polige Pfosten +steckerleisten sichtbar. + +#center#25-pol. D-Subminiatur-Stecker + + +---------------+ + | | + +---+ +---+ + | +------+ | + | | | | + | | | | + | | | | + | | | | + | +------+ | + | +------+ | + | | | +-------+ | + | +------+ | | | + | +------+ +-------+ | + | | | +-------+ | + | +------+ | <-|---------Jumper-Leiste + | +-------+ | + +---+ +---+ + | Baudrate | + +---------------+ + + +#center#Abb.4: RS232-Adapter geöffnet + + +Auf einem Paar steckt ein 'Jumper', mit dem die Baudrate eingestellt wird. +Gegebenenfalls ist dieser Jumper umzustecken. Anschließend schrauben Sie das +Gehäuse mit den vier entfernten Schrauben wieder zu. + + +---------+ + | o o | 300 + | o o | 600 + | o o | 1200 + | o o | 2400 + | o o | 4800 + | o o | 9600 + Jumper ---> | o o | 19200 + | o o | 38400 + +---------+ + Baudrate + + +#center#Abb.5: Mögliche Jumperposition beim RS232-Adapter + + +Nun muß noch in der Task 'configurator' der entsprechende Kanal konfiguriert +werden. Koppeln Sie dazu die Task 'configurator' an Ihr Terminal (mit 'continue +("configurator") <RETURN>') und geben Sie dann das Kommando 'configurate +<RETURN>'. Für alle vorhandenen Kanäle werden Sie nun nacheinander gefragt, +ob Sie eine Konfiguration vornehmen wollen. Beim vorgesehenen Kanal antworten Sie +mit 'ja' (<j>). + +Wollen Sie sich nur die aktuelle Konfiguration ansehen, so beantworten Sie alle dann +gestellten Fragen zum Kanal mit 'ja' (<j>), dann bleibt die aktuelle Einstellung +erhalten. Der Konfigurationsdialog ist im EUMEL-Systemhandbuch auf den Seiten 6 - +8 detailliert beschrieben. + +Folgende Konfigurationsmerkmale müssen eingestellt werden: + + transparent, 8 Bit, 2 Stopbit, no Parity, #on("b")#kein#off("b")# Protokoll + +Die Baudrate ist entsprechend der Jumper-Stellung einzustellen. + +Am Adapter ist ein Kabel mit 25poligem D-Subminiatur-Stecker bereits fest montiert. +Sollte der Stecker nicht an Ihren Rechner passen, so müßten Sie ein entsprechendes +Adapterkabel basteln oder kaufen. + + + +#on("b")#3.3 Verbindung Adapter - Interface-System#off("b")# + +Nachdem Sie nun den Adapter (MUFI oder RS232-Adapter) an den Rechner ange +schlossen haben, müssen Sie noch die Verbindung zum Interface-System herstellen. +Dabei ist es gleichgültig, ob Sie eine Compact-Box, einen Einzelsteckplatz oder einen +Mehrfachsteckplatz benutzen, denn alle diese Geräte verfügen über den gleichen +Anschlußstecker. Den RS232-Adapter können Sie direkt an das Interface-System +anschließen, denn er verfügt bereits über einen entsprechenden Stecker. + +Für das MUFI benötigen Sie ein Anschlußkabel, das auf der einen Seite einen +36poligen Centronics-Stecker und auf der anderen Seite einen 25poligen D-Sub +miniatur-Stecker besitzt (von der Firma BICOS zu beziehen). + + +#on("b")#3.4 Bereitstellung des Interface-Systems#off("b")# + +Sofern Sie eine Compact-Box angeschlossen haben, brauchen Sie nur noch das mitge +lieferte Netzteil mit der Compact-Box und dem Netz zu verbinden und die ent +sprechende Spannung laut beiliegender Bedienungsanweisung der Fa. AKTRONIK +einzustellen. + +Wenn Sie mit einem Einzelsteckplatz oder einem Mehrfachsteckplatz arbeiten, +müssen Sie zunächst noch eine Interface-Karte einstecken. Für einen anschließenden +Test des Systems (sehen Sie dazu Kapitel 5) empfiehlt es sich, eine Kombikarte oder +eine E/A-Karte zu verwenden. Nach dem Einstecken der Interface-Karte ist der Steck +platz noch mit dem Netzstecker an das Stromnetz anzuschließen, um eine +Spannungsversorgung zu gewährleisten. + + + + + + + diff --git a/app/gs.process/1.02/doc/gs-Prozess-4 b/app/gs.process/1.02/doc/gs-Prozess-4 new file mode 100644 index 0000000..e106df1 --- /dev/null +++ b/app/gs.process/1.02/doc/gs-Prozess-4 @@ -0,0 +1,173 @@ +limit (11.0)##pagelength (16.5)##block# +#start (2.0,0.0)# +#page (1)# +#headodd# +#center#gs-Prozess#right#% + +#end# +#headeven# +%#center#gs-Prozess + +#end# +#center#1 + +#on("b")#4 Installation von gs-Prozess#off("b")# + + +Bevor Sie #on("b")#gs-Prozess#off("b")# auf Ihrem Computer benutzen können, müssen Sie das +Programm zunächst installieren. Wenn #on("b")#gs-Prozess#off("b")# auf Ihrem System schon zur +Verfügung steht, können Sie dieses Kapitel ruhig überspringen. + + + +#on("b")#4.1 Voraussetzungen#off("b")# + + +Um #on("b")#gs-Prozess#off("b")# auf Ihrem Computer betreiben zu können, muß das EUMEL- +Betriebssystem installiert sein. #on("b")#gs-Prozess#off("b")# setzt die Multi-User-Version voraus und ist +lauffähig ab Version 1.8.x. #on("b")#gs-Prozess#off("b")# setzt weiterhin voraus, daß auf Ihrem +Computer bereits das Programm #on("b")#gs-DIALOG#off("b")# (Version 1.1) installiert ist. + + + +#on("b")#4.2 Lieferumfang#off("b")# + + +#on("b")#gs-Prozess#off("b")# wird auf einer Diskette geliefert, die alle notwendigen Programme ent +hält (die Installation von #on("b")#gs-DIALOG#off("b")# wird dabei vorausgesetzt!). Um den Inhalt der +Diskette feststellen zu können, starten Sie Ihr System und bringen es dazu, daß 'gib +kommando:' erscheint. Dann legen Sie die Diskette ein und geben das Kommando: + + +#on("b")##center#archive("gs-Prozess");list(archive);release(archive) <RETURN>#off("b")# +#page# +Anschließend erscheint eine Übersicht der auf dem Archiv vorhandenen Programme. +Folgende Programme sollten sich in der Übersicht befinden: + + + "gs-Prozess 1 für MUFI im Terminalkanal" + "gs-Prozess 1 für MUFI als Endgerät" + "gs-Prozess 1 für AKTRONIK Adapter" + "gs-Prozess 2" + "gs-Prozess 3" + "gs-Prozess 4" + "gs-Prozess 5" + "gs-MENUKARTE:Prozess" + "gs-Prozess/gen" + + +Eventuell können noch weitere Namen auf der Diskette vorhanden sein. Wenn Sie den +Inhalt der Diskette kontrolliert haben und diese Programme auf der Diskette vor +handen sind, können Sie #on("b")#gs-Prozess#off("b")# installieren. + +Sollten Sie statt der Übersicht eine Fehlermeldung erhalten, überprüfen Sie bitte, ob +die Diskette das richtige Format besitzt oder ob Ihr Diskettenlaufwerk Probleme +macht. Sollten dagegen Programme fehlen, so reklamieren Sie die Diskette. + + +#on("b")#4.3 Installation#off("b")# + +#on("b")#gs-Prozess#off("b")# muß in einer Task installiert werden, in der bereits das Programm +#on("b")#gs-DIALOG#off("b")# zur Verfügung steht. Alle Söhne und Enkel der neuen Task können +anschließend mit #on("b")#gs-Prozess#off("b")# arbeiten. Richten Sie also eine Task als Sohn der Task +ein, in der auf Ihrem Computer bereits #on("b")#gs-DIALOG#off("b")# installiert ist. Wir nehmen hier +an, daß #on("b")#gs-DIALOG#off("b")# in der Task 'MENU' installiert ist und die neue Task den Namen +'PDV' erhalten soll. (Sie können für die Task auch einen beliebigen anderen Namen +wählen): + +#on("b")# + <SV> (Supervisor - Taste) + + --> gib supervisor kommando: + + begin ("PDV","MENU") <RETURN> + + --> gib kommando: + + +#off("b")# +(Arbeiten mehrere Personen mit dem Computer, dann ist es sinnvoll, diese Task vor +unbefugtem Zugriff durch ein Passwort zu schützen. Wie das gemacht wird, können +Sie in Ihrem EUMEL-Benutzerhandbuch erfahren.) + + +Legen Sie dann die Archivdiskette ein, auf der sich #on("b")#gs-Prozess#off("b")# befindet, und geben +Sie das folgende Kommando: + + +#on("b")# + archive("gs-Prozess") <RETURN> + + fetch("gs-Prozess/gen",archive) <RETURN> + + run <RETURN> + +#off("b")# + +Sie haben damit das Generatorprogramm gestartet. Bevor die Generierung allerdings +ausgeführt werden kann, müssen Sie dem System noch Angaben über den ver +wendeten Adapter machen. Die zur Verfügung stehenden Anpassungen werden Ihnen +zur Auswahl angeboten: + +--------------------------------------------------------+ + | Auswahl der Interface-Anpassung | + | Bitte gewünschte Anpassung ankreuzen! | + |--------------------------------------------------------| + | Auswahl e i n e r Datei durch Ankreuzen | + |--------------------------------------------------------| + |==> > gs-Prozess 1 für MUFI im Terminalkanal | + | > gs-Prozess 1 für MUFI als Endgerät | + | > gs-Prozess 1 für AKTRONIC-Adapter | + | | + +--------------------------------------------------------| + | Info: <?> Fertig: <ESC><q> Abbrechen: <ESC><h> | + +--------------------------------------------------------+ +#center#Abb.6: Auswahl der Interface-Anpassung + + +Bringen Sie den Pfeil mit den Pfeiltasten vor die gewünschte Anpassung und drücken +Sie die <RETURN>-Taste. + +Haben Sie als Anpassung "gs-Prozess für AKTRONIK Adapter" oder "gs-Prozess für +MUFI als Endgerät" gewählt, so erscheint als nächstes die Aufforderung: + +#center##on("b")#'Gib Interface-Kanal:'#off("b")# + +Geben Sie hier die Kanalnummer der seriellen Schnittstelle ein, an der der Adapter +betrieben werden soll. + +Die Installation wird automatisch durchgeführt. Lassen Sie während des gesamten +Vorgangs die Archivdiskette eingelegt. Die Generierung ist beendet, wenn der +EUMEL-Eingangsbildschirm erscheint. Die Task, in der die Generierung stattfin +det, wird automatisch zur Managertask, das heißt, daß Söhne von ihr eingerichtet +werden können. + + +#on("b")#4.4 Anmerkungen zur Erstinstallation#off("b")# + +Mit der Installation der Software ist das Gesamtsystem allerdings noch nicht betriebs +bereit. Dazu fehlen #on("b")#gs-Prozess#off("b")# noch einige Informationen. Bisher ist #on("b")#gs-Prozess#off("b")# +nämlich nur bekannt, welchen Adapter Sie verwenden und ob Sie ihn im Terminal +kanal oder an einer separaten Schnittstelle betreiben wollen. + +Um das angeschlossene Interface-System sachgerecht ansteuern zu können, benötigt +#on("b")#gs-Prozess#off("b")# aber noch Informationen über die Hardware-Konstellation. Diese Mit +teilungen, die noch gemacht werden müssen, nennen wir "Konfiguration von +#on("b")#gs-Prozess#off("b")#". Wie diese Konfiguration vorgenommen wird und wie Sie anschließend +Ihr Interface-System testen, ist im Kapitel 5 detailliert beschrieben. + +#on("b")#gs-Prozess#off("b")# bietet Ihnen eine Reihe von Möglichkeiten, die vorhandene Hardware +möglichst effektiv zu nutzen. So ist es möglich, wenn Sie Ihre(n) Adapter an +separater/separaten Schnittstelle(n) betreiben, von verschiedenen Tasks aus auf +einen Adapter zuzugreifen. Gerade in der Anschaffungsphase, wenn noch nicht +genügend Hardware zur Verfügung steht, ist das eine sinnvolle/preiswerte Möglich +keit, von verschiedenen Arbeitsplätzen aus Prozeßdatenverarbeitung zu betreiben. + +Zu diesem Zeitpunkt würde es aber zu weit führen, hierzu Details zu erläutern. +Beschreibungen dieser Möglichkeiten finden Sie im Kapitel "Hinweise für den +Systembetreuer/ Programmierer". + +#on("b")# +Sie sollten sich zunächst darauf beschränken, ein Interface-System "zum +Laufen zu bringen". Verfahren Sie dazu bitte genau, wie im Kapitel 5 +beschrieben.#off("b")# + diff --git a/app/gs.process/1.02/doc/gs-prozess-1 b/app/gs.process/1.02/doc/gs-prozess-1 new file mode 100644 index 0000000..f6a3696 --- /dev/null +++ b/app/gs.process/1.02/doc/gs-prozess-1 @@ -0,0 +1,99 @@ +limit (11.0)##pagelength (16.5)##block# +#start (2.0,0.0)# +#page (1)# +#headodd# +#center#gs-Prozess#right#% + +#end# +#headeven# +%#center#gs-Prozess + +#end# +#center#1 + +#on("b")#1 Was kann gs-Prozess#off("b")# + +#on("b")#gs-Prozess#off("b")# ist ein Programmsystem unter dem Betriebssystem EUMEL, mit dem ein +Anwendungsbereich erschlossen werden kann, der bisher in der Schule zumeist sehr +stiefmütterlich behandelt wurde: die Prozeßdatenverarbeitung - das Messen, Steuern +und Regeln mit dem Computer. + +Es wird dadurch möglich, externe Modelle/Geräte (z.B. eine Ampelanlage) zu steuern +oder von externen Meßfühlern (z.B. einem Temperaturfühler) oder Eingabeeinheiten +(z.B. einem Lochkartenleser) Daten aufzunehmen. Durch die Kombination der +beiden Vorgänge können sogar komplexe geregelte Systeme in Modellen nachgebildet +werden. + +Eigentlich ist eine solch stiefmütterliche Behandlung dieses Anwendungsbereiches +von Computern in der Schule gar nicht einzusehen, denn in der Forschung, im +Dienstleistungsbereich, im privaten Bereich und vor allem in der Produktion gibt es +eine Vielzahl von Anwendungen, z.B.: + + Meßdatenerfassung und -auswertung bei Experimenten, Wetterbeobachtung, + seismologische Untersuchungen, ..., Ampelsteuerungen, Verkehrsleitsysteme, ..., + Scannerkassen, Scheckkartenleser, Geldautomaten, ..., Waschmaschinen, + Heizungsanlagen, Modelleisenbahnen, ..., CNC-Maschinen, Universalhand + habungsautomaten (Roboter),... + +In den meisten Fällen werden Computer eingesetzt, die speziell für diesen +Anwendungsbereich entwickelt wurden. Insbesondere an die Verarbeitungsge +schwindigkeit solcher Systeme werden sehr hohe Anforderungen gestellt. Solche +Systeme sind für die schulische Verwendung viel zu teuer. Zumeist sind auch die in +der Realität ablaufenden Vorgänge so komplex, daß sie als Ganzes gar nicht im +Unterricht nachgebildet werden können. + +Das aber kann auch nicht Ziel einer Auseinandersetzung mit diesem Anwendungs +bereich in der Schule sein. Hier gilt es, unter didaktisch-methodischen Gesichts +punkten, Grundprinzipen der Prozeßdatenverarbeitung zu vermitteln und beispiel +hafte Anwendungen an Modellen zu erarbeiten und zu erproben. In einem zeitge +mäßen Informatikunterricht darf dieser wichtige Anwendungsbereich von Computern +nicht ausgespart bleiben. + +Bisher scheiterte das Messen, Steuern und Regeln mit dem Computer in der Schule +meistens daran, daß es keine standardisierten Software- und Hardware-Systeme und +auch keine geeigneten Modelle gab. Das aber hat sich inzwischen geändert. +Verschiedene Hersteller bieten Interface-Systeme und Modelle an, die gut verwendet +werden können. + +Auch #on("b")#gs-Prozess#off("b")# greift auf ein solches Interface-System zu, das aus mehreren +Einzelkomponenten besteht (mehr dazu in den folgenden Kapiteln). Das sind Geräte, +über die der Computer "Kontakt" mit den 'Endgeräten' (z.B. Modellen) aufnimmt: +Hier werden Ausgaben des Computers in "elektrische Impulse" umgesetzt, mit denen +Modelle angesprochen werden können (z.B. Lämpchen ein- und ausgeschaltet, +Motoren zu Drehungen nach links oder rechts veranlaßt werden können). Ein +gehende "Impulse" werden in "computerangemessene Form" umgewandelt und an +den Computer weitergegeben. + +Der Aufwand, der betrieben werden muß, um ein Interfacesystem sachgerecht anzu +steuern, ist erheblich. Es kostet einige Mühe und vor allem viel Zeit, um alle Details +des Interfacesystems und seiner Programmierung kennenzulernen, und es gehört +eine gehörige Portion Erfahrung und vor allem viel Geduld dazu, um Fehlfunktionen +zu analysieren und letztlich zu beheben. Das alles ist einem Anwender, dem es z.B. +darum geht, ein bestimmtes Modell anzusteuern, nicht zumutbar. + +Hier schafft nun #on("b")#gs-Prozess#off("b")# Abhilfe! #on("b")#gs-Prozess#off("b")# ist eingebettet in die komfortable +Benutzerschnittstelle #on("b")#gs-DIALOG#off("b")#, so daß der Einarbeitungsaufwand in das +Programmsystem gering und eine einfache Bedienung des Systems gewährleistet ist. + +Ähnlich wie bei #on("b")#gs-Herbert und Robbi#off("b")# wird eine komplette Programmier +umgebung zur Verfügung gestellt, die alle Funtionen enthält (Informationen, +Konfiguration des Systems, Erstellung und Ausführung von Programmen, Archiv +handling), die bei der Arbeit von Bedeutung sein können - natürlich jetzt auf das +Messen, Steuern und Regeln bezogen. Durch diese Programmierumgebung wird +selbst dem Computerneuling ermöglicht, einen einfachen, eingängigen Zugang zu +diesem Anwendungsbereich zu finden. + +#on("b")#gs-Prozess#off("b")# stellt einen Basisbefehlssatz (Eingabe-, Ausgabebefehle und Tests) zur +Verfügung, mit dessen Hilfe Lösungsalgorithmen aus diesem Anwendungsbereich +angemessen formuliert werden können. Dabei kann sich der Anwender ganz auf sein +Problem konzentrieren, da er sich um die spezifische Ansteuerung des Interfaces +nicht zu kümmern braucht - das erledigt #on("b")#gs-Prozess#off("b")#. + +Der Basisbefehlssatz besteht aus nur wenigen Befehlen, um das Erlernen und den +Umgang damit möglichst einfach zu gestalten. Andererseits ist der Befehlssatz so +umfangreich und universell, daß alle schulisch relevanten Problemstellungen aus +diesem Anwendungsbereich angemessen bearbeitet werden können. + + + + diff --git a/app/gs.process/1.02/doc/gs-prozess-5 b/app/gs.process/1.02/doc/gs-prozess-5 new file mode 100644 index 0000000..5c44f29 --- /dev/null +++ b/app/gs.process/1.02/doc/gs-prozess-5 @@ -0,0 +1,819 @@ +limit (11.0)##pagelength (16.5)##block# +#start (2.0,0.0)# +#page (1)# +#headodd# +#center#gs-Prozess#right#% + +#end# +#headeven# +%#center#gs-Prozess + +#end# +#center#1 + +#on("b")#5 Konfiguration von gs-Prozess#off("b")# +#on("b")# Test des Interface-Systems#off("b")# + +In diesem Kapitel erfahren Sie, wie Sie #on("b")#gs-Prozess#off("b")# entsprechend der angeschlossenen +Hardware konfigurieren müssen. Anschließend zeigen wir Ihnen, wie Sie Ihr Inter +face-System testen können. + +Wir gehen hier davon aus, daß die Hardware-Voraussetzungen erfüllt, das Interface- +System über einen Adapter (MUFI / RS232-Adapter) angeschlossen und #on("b")#gs-Prozess#off("b")# +auf dem Rechner installiert sind. + + +#on("b")#5.1 Kontrolle der Konfigurationen/Anschlüsse#off("b")# + +Bevor Sie mit der Arbeit beginnen, überzeugen Sie sich unbedingt (noch einmal) +davon, daß die Konfigurationen und die Steckverbindungen den Vorgaben ent +sprechen: + +- #on("b")#MUFI im Terminalkanal:#off("b")# + + Sind die beiden Kabel zum Rechner und zum Terminal an der Rückseite des + MUFIs korrekt aufgesteckt (sehen Sie Abb.3)? Haben Sie die notwendigen + Konfigurationen vorgenommen (Task 'configurator', MUFI-DIP-Schalter, Ter + minal)? Ist das Netzkabel des MUFIs mit dem Stromnetz verbunden? Ist das + Verbindungskabel zwischen MUFI und Interface-System an der Vorderseite des + MUFIs und am Interface-System (Compact-Box, Einzel- oder Mehrfachsteck + platz) aufgesteckt? +#page# +- #on("b")#MUFI als Endgerät:#off("b")# + + Ist das vom Computer kommende Kabel auf den mit V24/2 gekennzeichneten + Stecker aufgesteckt? Haben Sie auf den freien Stecker (V24/1) einen "Kurz + schlußstecker" aufgesteckt? Haben Sie ein Kabel verwendet, über welches das + RTS/CTS-Protokoll abgewickelt werden kann? Haben Sie den Kanal, an dem das + MUFI betrieben wird, den Anweisungen in Kapitel 3.1.3 entsprechend kon + figuriert? Sind die DIP-Schalter im MUFI entsprechend eingestellt? Ist das + Netzkabel des MUFIs mit dem Stromnetz verbunden? Ist das Verbindungskabel + zwischen MUFI und Interface-System an der Vorderseite des MUFIs und am + Interface-System (Compact-Box, Einzel- oder Mehrfachsteckplatz) aufgesteckt? + + +- #on("b")#RS232-Adapter:#off("b")# + + Ist das Schnittstellen-Kabel korrekt am Computer angeschlossen? Haben Sie den + Kanal, an dem der RS232-Adapter betrieben wird, den Anweisungen in Kapitel + 3.2 entsprechend konfiguriert? Ist der Jumper im RS232-Adapter korrekt aufge + steckt? Ist der RS232-Adapter an das Interface-System (Compact-Box, Einzel- + oder Mehrfachsteckplatz) angesteckt? Ist der 3polige Platinenstecker des + Adapters in die 12V-Spannungsversorgungs-Buchse des Interface-Systems + eingesteckt? + + +- #on("b")#Compact-Box#off("b")# + + Ist die Compact-Box an das zugehörige Netzgerät angeschlossen? Ist der Stecker + wirklich richtig herum eingesteckt? Ist das Netzteil mit dem Stromnetz ver + bunden? + +- #on("b")#Einzelsteckplatz#off("b")# + + Ist eine Kombi-Karte oder eine E/A-Karte eingesteckt? Ist das Netzkabel des + Steckplatz-Netzgerätes mit dem Stromnetz verbunden? +#page# +- #on("b")#Mehrfachsteckplatz#off("b")# + + Ist ein passendes Netzteil an den Mehrfachsteckplatz angeschlossen? Ist das + zugehörige Netzkabel mit dem Stromnetz verbunden? Ist eine Kombi- oder + E/A-Karte in einen Steckplatz eingesteckt? + + +#on("b")#5.2 Vorbereitungen für den Ein-/Ausgabetest#off("b")# + +Für den Ausgabetest sollte eine 8elementige Leuchtdiodenanzeige zur Verfügung +stehen, um am Interface-System die Ausgaben kontrollieren zu können. Sofern Sie +mit der Compact-Box arbeiten oder eine E/A-Karte verwenden, brauchen Sie sich +darum nicht weiter zu kümmern, denn in diese Systeme ist eine Leuchtdioden +anzeige integriert. Wenn Sie dagegen mit einer Kombikarte arbeiten, muß eine +gesonderte Anzeige (kann leicht selbst gebaut werden oder ist fertig zu kaufen bei der +Fa. AKTRONIK) angeschlossen werden. + +Für den Eingabetest reicht ein kleines Drahtstück, an dem zwei kleine Lötschuhe +angelötet sind - schön wäre es, wenn ein Codekarten-Leser zur Verfügung stünde. + + +#on("b")#5.2.1 Anschluß einer Leuchtdiodenanzeige an die Kombikarte#off("b")# + +Stecken Sie den 8poligen Platinenstecker, der an der Leuchtdiodenanzeige befestigt +ist, auf die mit "AUSG." gekennzeichnte Buchse der Kombikarte. Den Lötschuh des +einzelnen Drahtes an der Leuchtdiodenanzeige stecken Sie auf den Masse-Lötstift +direkt neben der "Ausgangs-Buchse" der Kombikarte (sehen Sie Abb. 7). Da die +Leuchtdiodenanzeige mit Spannung versorgt werden muß, müssen jetzt noch zwei +Kabel - wie in der Abb. 7 dargestellt (Kabel 1 und Kabel 2) - aufgesteckt werden. +#page# + + + + +---------------------------------------------------------------+ + | 4-7 o----------+ | + | +-+-----------+-+ | | + | | | O | | GMD o | | + | | | | | | Kabel 1 | + | | | | | | | + | v | | O | | | | + | | | | | | | + | E| | | | | | + | | | O | | | | + | +-+-------------+ ___________| | + | o -----------| | + | Ausg. | | + | +---------------+ O 0 | | + | | +-----------+ | 1 O | | + ---+---|-|---| | | O 2 | | + ---+---|-|---| | | 3 O | | + ---+---|-|---| | | O 4 | | + ---|---|-|---| | | 5 O | | + ---|---|-|---| | | O 6 | | + ---|---|-|---| | | 7 O | | + | | +-----------+ | | | + | +---------------+ | | +<-----------------o | Kabel 2 | + Zur Leuchtdiodenanzeige | | + | +---------------+ | | + | | O | O 0 | | + | | O | 1 O | | + | | O | O 2 | | + | | O | 3 O | | + | | O | O 4 | | + | | O | 5 O | | + | | O | O 6 | | + | | O | 7 O | | + | +---------------+ | | + | GMD o o +5V | | + | | | | + | +----------------------------+ | + | | + | +---------------+ | + | | O | + O | + | | O | O E2 | + | | O | GMD O | + | +---------------+ | + | | + | +---------------+ | + | | O | + O | + | | O | O E2 | + | | O | GMD O | + | +---------------+ | + | o o o o o o o o o o | + | | | | | | | | | | | | + | +-o-+-o-+-o-+-o-+-o-+-o-+-o-+-o-+-o-+-o-+-o-+ | + | | | | + +----------+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+----------+ + | | | | | | | | | | | | | | | | | | | | | + | | | | | | | | | | | | | | | | | | | | | + +#center#Abb.7: Anschluß Leuchtdiodenanzeige - Kombikarte + +#on("b")#ACHTUNG!#off("b")# Bei dieser Spannungversorgung auf der Kombikarte (+5V) darf #on("b")#auf +keinen Fall#off("b")# eine größere Last (z.B. Motor oder auch nur eine Glühbirne) ange +schlossen werden, da dadurch die Interfacekarte bzw. das Netzteil im Einzelsteck +platz beschädigt werden könnte. +#page# +Möchten Sie eine größere Last anschließen, so benötigen Sie ein stabilisiertes Netzteil +mit "ordentlich geglättetem" Gleichstrom. Die Masse (Minuspol) des Netztteils be +festigen Sie an dem Lötschuh (oder der davorliegenden Klemme), der zwischen den +beiden Lötstiften liegt, an denen in der Abb.7 das Kabel 1 befestigt ist. Den Pluspol +des Netzteiles verbinden Sie mit mit einem der Lötstifte (bzw. an der davorliegenden +Klemme), auf dem jetzt das Kabel 1 befestigt ist. Damit alle 8 Ausgänge mit Span +nung versorgt werden, müssen Sie auch hier ebenfalls eine Brücke zum zweiten +Lötschuh (oder der Klemme davor), an dem in der Zeichnung Kabel 1 befestigt ist, +anbringen. + +Da die Compact-Box ohnehin durch das Netzteil versorgt wird, kann es hier nicht zu +Komplikationen kommen. Wollen Sie eine größere Last an die E/A-Karte anschließen, +so benötigen Sie z.B. eine Relais-Box. + + + +#on("b")#5.2.2 Anschluß des Codekartenlesers (Drahtstück)#off("b")# + +Stecken Sie den 8poligen Platinenstecker, der am Codekartenleser befestigt ist, auf +die Eingangsbuchse an Ihrem Interface-System. Dann muß noch der 3polige +Platinenstecker, der ebenfalls am Codekartenleser befestigt ist, an die 12V-Span +nungsversorgungs-Buchse an Ihrem Interface-System aufgesteckt werden. + +haben Sie keinen Codekartenleser zur Hand, so reicht für den Eingabetest auch ein +kleines Kabelstück aus, an dessen Enden jeweils ein Lötschuh angelötet sein sollte. +Stecken Sie den einen Lötschuh auf einen +5V-Lötstift Ihres Interface-Systems. Das +andere Ende des Kabels wird zunächst noch nicht befestigt. + +Auf der Kombikarte sind die +5V-Lötstifte beschriftet und damit leicht zu finden. Wo +Sie einen +5V-Lötstift auf der E/A-Karte finden, können Sie der folgenden Abbildung +entnehmen: +#page# + Leuchtdiodenanzeige + | + +---------------------------------------+------------+ + | +---------------+ | | + | | O | O 0 V | +Digital- | | O | 1 O o o o o o o o o | +Ausgang | | O | O 2 | + | | O | 3 O | + | | O | O 4 | + | | O | 5 O | + | | O | O 6 | + | | O | 7 O | + | +---------------+ | + | +---------------+ | + | | O | O 0 | +Digital- | | O | 1 O | +Eingang | | O | O 2 | + | | O | 3 O | + | | O | O 4 | + | | O | 5 O | + | | O | O 6 | + | | O | 7 O | + | +---------------+ | + | +---------------+ | + | | O | O 0 | +Versorgungs- | | O | 1 O | +und | | O | O 2 | +Steuer- | | O | 3 O | +leitung | | O | O 4 | + | | O | 5 O | + | | O---5V------O 6 | + | | O | 7 O | + | +-------|-------+ | | + | | | | + | +---------------+ | + | | | + | GMD | + | | + | o o o o o o o o o o | + | | | | | | | | | | | | + | +-o-+-o-+-o-+-o-+-o-+-o-+-o-+-o-+-o-+-o-+-o-+ | + | | | | + +----+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+---+ + | | | | | | | | | | | | | | | | | | | | | + | | | | | | | | | | | | | | | | | | | | | + + +#center#Abb.8: Pinbelegung auf der E/A-Karte + + +#on("b")#5.3 Konfiguration von gs-Prozess#off("b")# + +Normalerweise kann in jeder Task, in der #on("b")#gs-Prozess#off("b")# zur Verfügung steht, die +Konfiguration vorgenommen werden (beachten Sie aber bitte die Bemerkungen im +Kapitel "Hinweise für den Systembetreuer/Programmierer"). + +Richten Sie eine Sohntask der Task ein, in der #on("b")#gs-Prozess#off("b")# installiert ist - in unserem +Fall soll das die Task 'PDV' sein. Die Sohntask soll den Namen 'pdvtest' erhalten: +#page# +#on("b")# + <SV> (Supervisor - Taste) +#off("b")# + --> gib supervisor kommando: +#on("b")# + begin ("pdvtest","PDV") <RETURN> +#off("b")# + --> gib kommando: +#on("b")# + pdv <RETURN> +#off("b")# + +Daraufhin erscheint der in Abb.9 dargestellte Menubildschirm. Über die Menupunkte +im dann sichtbaren Pull-Down-Menu können Sie diverse Informationen zu +#on("b")#gs-Prozess#off("b")# abrufen, auf die wir hier allerdings nicht weiter eingehen wollen. Statt +dessen drücken Sie bitte die 'Pfeiltaste rechts'. Sie gelangen so zum Menu unter dem +Oberbegriff "Interface" (Abb. 10). + + ++---------------------------------------------------------------------+ +| PDV: Info Interface Programm Archiv | +|-------+------------------------+------------------------------------+ +| | u Übersicht Befehle | | +| | --------------------- | | +| | a Ausgabebefehle | | +| | e Eingabebefehle | | +| | t Testbefehle | | +| | w Weitere Befehle | | +| | --------------------- | | +| | b Bitmuster | | +| | s Symbole/Zeichen | | +| | d Digital-/Analogwerte| | +| +------------------------+ | +| | +| +----------------------------------------+ | +| | gs-Prozess | | +| | Version 1.0 | | +| | | | +| | Copyright Ρ 1988 bei Eva Latta-Weber, | | +| | Bielefeld | | +| +----------------------------------------+ | ++---------------------------------------------------------------------+ +|Info:<ESC><?>/<?> Wahl:<Pfeile> Ausführen:<RETURN> Verlassen:<ESC><q>| ++---------------------------------------------------------------------+ + + + Abb.9: Eingangsbildschirm #on("b")#gs-Prozess#off("b")# +#page# + ++-----------------------------------------------------------------------+ +| PDV: Info Interface Programm Archiv | ++-------+-------------------+-------------------------------------------+ +| | i Informationen | | +| | ---------------- | | +| | k Konfigurieren | | +| | ---------------- | | +| | a Ausgabetest | | +| | e Eingabetest | | +| +-------------------+ | +| | +| | +| | ++---------------------------------------------------------------------- + +| Info:<ESC><?>/<?> Wahl:<Pfeile> Ausführen:<RETURN> Verlassen:<ESC><q> | ++-----------------------------------------------------------------------+ + + #center#Abb.10: Menubildschirm zum Oberbegriff 'Interface' + + +Über den ersten Menupunkt ("Informationen") kann die aktuelle Konfiguration des +Interfaces erfragt werden. Wenn Sie diesen Menupunkt aktivieren und es ist weder in +dieser Task noch in einer übergeordneten Task eine Konfiguration vorgenommen +worden, erhalten Sie die folgende Warnung: + + +----------------------------------------+ + | Interface ist noch nicht konfiguriert! | + +----------------------------------------+ +#center#Abb.11: Information bei unkonfiguriertem System + + +Ist schon eine Konfiguration, z.B. in der Vatertask vorgenommen worden, so wird +Ihnen die aktuellen Einstellung angezeigt (s.u.). +#page# +#on("b")#5.3.1 Auswahl der Steckplatzart/Interfacekarte#off("b")# + +Da Sie in jedem Falle eine Konfiguration von #on("b")#gs-Prozess#off("b")# vornehmen sollen, +aktivieren Sie jetzt bitte den Menupunkt "Konfigurieren". Daraufhin erscheint die +folgende Auswahl: + +-----------------------------+ + | Auswahl der Steckplatzart | + | | + | c Compactbox | + | e Einzelsteckplatz | + | m Mehrfachsteckplatz | + | | + | Compact Einzel Mehrfach | + +-----------------------------+ + +#center#Abb.12: Auswahl der Steckplatzart + + +Haben Sie eine Compact-Box angeschlossen, so ist die Konfiguration schnell erledigt: +Sie tippen die Taste <c>. Daraufhin wird die komplette Konfiguration ausgeführt +und die Einstellung eingeblendet. + +------------------------------------+ + | Eingestellt: Compactbox | + | | + | Belegung der Kanäle: | + | | + | Kanal 1: Analogeingang 1 (E1) | + | | + | Kanal 2: Analogeingang 2 (E2) | + | | + | Kanal 3: Digitaleingang | + | | + | Kanal 4: Digitalausgang | + +------------------------------------+ + +#center#Abb.13: Compact-Box: Belegung der Kanäle +#page# +Die Anzeige verschwindet, wenn Sie eine beliebige Taste tippen. + +Anders dagegen, wenn Sie zuvor dem System mitgeteilt haben, daß ein Einzelsteck +platz bzw. ein Mehrfachsteckplatz angeschlossen ist. In diesem Fall müssen Sie +#on("b")#gs-Prozess#off("b")# noch mitteilen, welche Steckkarten Sie verwenden. Dazu wird Ihnen die +folgende Auswahl angeboten: + + +----------------------------------+ + | Angabe der Interfacekarte: | + | | + | k Kombikarte | + | e E/A - Karte | + | d D/A - Wandler - Karte | + | a A/D - Wandler - Karte | + | 0 Keine Steckkarte | + | | + | Kombi E/A D/A A/D Keine | + +----------------------------------+ + + +#center#Abb.14: Auswahl einer Interfacekarte + + +Wenn Sie eine Kombikarte, eine E/A-Karte oder eine D/A-Wandler-Karte verwenden, +ist durch die jeweilige Angabe der Einstellvorgang abgeschlossen. #on("b")#gs-Prozess#off("b")# teilt +Ihnen daraufhin - ähnlich wie bei der Compact-Box - jeweils die Belegung der Kanäle +mit. Bei Nutzung der D/A-Wandler-Karte wird zusätzlich der gültige Spannungs +bereich angezeigt. +#page# + + +------------------------------------------------------+ + | Einzelsteckplatz mit D/A - Karte: | + | | + | Belegung der Kanäle: | + | | + | Die Karte stellt einen Analogausgang zur Verfügung, | + | der auf zwei Arten angesprochen werden kann: | + | | + | Kanal 1: Spannungsbereich -5 V - +5 V | + | | + | Kanal 2: Spannungsbereich 0 V - +5 V | + | | + +------------------------------------------------------+ + +#center#Abb.15: Kanalbelegung D/A-Karte (Einzelsteckplatz) + + +Haben Sie dagegen eine A/D-Wandler-Karte angegeben, so erfragt #on("b")#gs-Prozess#off("b")# noch +die Schalterstellung der DIP-Schalter auf der A/D-Wandler-Karte. Über diese Schalter +stellung kann der Spannungsbereich der Analogeingänge festgelegt werden. Das +erfolgt nach folgendem Prinzip: + +Das Spannungsintervall wird jeweils über 3 Schalter festgelegt. Für den Eingang 1 +stehen die Schalter 1, 2 und 3 zur Verfügung, für denn Eingang 2 die Schalter 4, 5 +und 6. Im folgenden werden wir die Einstellung für den Eingang 1 aufzeigen - für den +Eingang 2 ist mit den drei genannten Schaltern synonym zu verfahren. + +Steht Schalter 1 in der Position 'ON', so ist ein Spannungsintervall von 0V - 25V einge +stellt (Fall 1) - unabhängig von der Stellung der anderen beiden Schalter. Innerhalb +eines Schaltertripletts "dominiert" nämlich ein Schalter mit kleinerer Nummer über +den/die mit größerer Nummer. Ist Schalter 1 in Stellung 'OFF' und Schalter 2 in +Stellung 'ON', so ist ein Spannungsbereich von 0V - 2,5V eingestellt (Fall 2). Sind die +beiden ersten Schalter in der Position 'OFF' und nur der Schalter 3 in der Position +'ON', so ist ein Spannungsintervall von 0V - 0,25V eingestellt (Fall 3). +#page# +Eine besondere Bedeutung kommt noch den Schaltern 7 und 8 zu, denn sie beein +flussen noch die eben genannten Intervalle. Dabei ist überraschenderweise der +Schalter 7 für den Eingang 2 und der Schalter 8 für den Eingang 1 zuständig. Die drei +oben genannten Fälle gelten nämlich nur, wenn Schalter 8 in der Position 'OFF' steht. +In der Position 'ON' werden die durch das Schaltertriplett eingestellten Spannungs +intervalle dagegen symmmetrisch um 0V angelegt: im Fall 1 also der Bereich von +-12,5V - +12,5V, im Fall 2 von -1,25V - +1,25V und im Fall 3 von -0,125V - ++0,125V. + +----------------------------------------------------+ + | Angabe der Schalterstellungen auf der A/D - Karte: | + | | + | Bitte die aktuelle Schalterstellung eintragen: | + | | + | Es bedeutet: 1 - Schalterstellung "on" | + | 0 - Schalterstellung "off" | + | | + | Nummer: 12345678 | + | | + | Eingabe: 10010010 | + +----------------------------------------------------+ +#center#Abb.16: A/D-Karte: Angabe der Schalterstellung + + +Der Spannungsbereich wird von #on("b")#gs-Prozess#off("b")# aus der Schalterstellung automatisch +ermittelt und neben den festgelegten Kanalnummer angezeigt. Die obige Schalter +stellung führt somit zu folgender Meldung: + + +----------------------------------------------------------------+ + | Einzelsteckplatz mit A/D - Karte: | + | | + | Zwei analoge Einträge stehen zur Vefügung: | + | | + | Kanal 1: (E1) Spannungsbereich 0.000 V - +25.000 V | + | | + | Kanal 2: (E2) Spannungsbereich -12.500 V - +12.500 V | + | | + +----------------------------------------------------------------+ +#center#Abb.17: A/D-Karte: Kanalbel./Spannungsber.(Bspl.) +#page# +Während Sie bei Verwendung eines Einzelsteckplatzes nur einmal nach all diesen +Angaben gefragt werden, erfolgt die Abfrage bei einem Mehrfachsteckplatz viermal +hintereinander. Haben Sie einen Steckplatz nicht belegt, so tippen Sie bei der Angabe +der Interfacekarte die Taste <0> (keine Steckkarte). + + +#on("b")#5.3.2 Bedeutung der Kanalnummern#off("b")# + +Nachdem Sie #on("b")#gs-Prozess#off("b")# die Angaben zur Konfiguration (Steckplatzart/Interface +kartenart) mitgeteilt haben, teilt Ihnen das System jeweils die Kanalnummern mit. +Diese Nummern sollten Sie sich merken, denn wenn Sie mit dem von #on("b")#gs-Prozess#off("b")# zur +Verfügung gestellten Befehlen programmieren wollen, müssen Sie jeweils diese +Kanalnummern angeben. Fordern Sie von einem Kanal eine Aktion, die nicht ausge +führt werden kann/nicht sinnvoll ist, so kann Ihnen dadurch eine Fehlermeldung +zugestellt werden. + +Auf der Compact-Box bzw. der Kombikarte an einem Einzelsteckplatz ist die +Numerierung identisch: die beiden Analogeingänge haben die Kanalnummern 1 und +2, der Digitaleingang hat die Nummer 3 und der Digitalausgang die Nummer 4. + +Die E/A-Karte verfügt nur über je einen digitalen Eingang und digitalen Ausgang, die +über die Kanäle 1 und 2 angesprochen werden können. Damit nun aber auch +Programme, die für die Compact-Box bzw. eine Kombikarte geschrieben sind, auch +auf der E/A-Karte laufen, können diese beiden Kanäle auch unter der Kanalnummer +3 (Eingang) bzw. 4 (Ausgang) angesprochen werden. Natürlich ist ein solches +Programm nur dann auf der E/A-Karte lauffähig, wenn keine Analogeingänge ange +sprochen werden, denn die sind ja auf der E/A-Karte gar nicht vorhanden! + +Die Kanalnummern auf einem Mehrfachsteckplatz werden nach folgendem System +vergeben: Die Kanalnummern sind immer zweistellig. Über die erste Ziffer wird der +Steckplatz (1 - 4) identifiziert, über die zweite Ziffer der eigentliche Kanal auf der +Steckkarte. Steckt also z.B. in Steckplatz 3 eine Kombikarte (4 mögliche Kanäle) und +möchten Sie hier den Digitalausgang (Kanal 4) ansprechen, so muß als Kanal die +Nummer 34 angegeben werden. +#page# +Aber auch hier gibt es eine zusätzliche Vereinbarung: Der erste Steckplatz eines +Mehrfachsteckplatzes kann (zusätzlich) wie ein Einzelsteckplatz angesprochen +werden. Bei Belegung des ersten Steckplatzes mit einer Kombikarte, können Sie die +Karte also über die Kanalnummern 11, 12, 13 und 14 ansprechen und zusätzlich +über die Nummern 1, 2, 3 und 4. Der Sinn der dahintersteckt ist Ihnen sicher sofort +klar geworden: Dadurch kann ein Programm, das z.B. für die Compact-Box ge +schrieben wurde, ohne Änderung übernommen werden, wenn eine Kombikarte auf +Steckplatz 1 des Mehrfachsteckplatzes steckt etc.. + + +#on("b")#5.4 Aus- und Eingabetest#off("b")# + +Nun wird es spannend, denn Sie sollen jetzt testen, ob Sie mit Ihrem Interface-System +arbeiten können. Sofern Sie mit dem MUFI als Adapter arbeiten, schalten Sie das +MUFI mit dem Schalter an der Vorderseite ein. + +Wenn Sie das MUFI im Terminalkanal betreiben, kann das Einschalten dazu führen, +daß eine unsinnige Zeichenkette auf dem Bildschirm erscheint. Diese Zeichen +werden durch den "Einschaltknack" verursacht und haben eigentlich nichts zu +bedeuten. Allerdings läßt sich die Ausgabe auch nicht verhindern. Die Zeichen ver +schwinden bei der nächsten Menubedienung. + +Wenn Sie alle Hinweise in Kapitel 5.1 beachtet haben, müßte spätestens jetzt das +Interface-System betriebsbereit sein - gleichgültig, welchen Adapter und welche +Interface-Komponenten Sie verwenden. + +Aktivieren Sie nun den Menupunkt 'Ausgabetest', indem Sie z.B. die Taste <a> +tippen. Wenn Sie eine Compact-Box angeschlossen haben, müßte die folgende Ein +blendung in Ihrem Menubildschirm erscheinen: +#page# + +-------------------------------------------------------------+ + | Ausgabetest | + | | + | Ausgabe an Kanal 4 (= Digitalausgang der Compact-Box) | + |-------------------------------------------------------------| + | | + | | + | | + | Ausgabewert: 129 | + | | + |-------------------------------------------------------------| + | Bitte einen Wert zwischen 0 und 255 eingeben! | + | | + +-------------------------------------------------------------+ +#center#Abb.18: Ausgabetest - Einblendung + + +Eine nahezu identische Einblendung erhalten Sie, wenn Sie einen Einzelsteckplatz +mit Kombi- oder E/A-Karte angeschlossen haben. + +Da beim Ausgabetest nur die Ausgänge einer Karte angesprochen werden, ist ein +Ausgabetest an einer A/D-Wandler-Karte nicht möglich! An einer D/A-Wandler-Karte +kann zwar prinzipiell ein Ausgabetest erfolgen - ist aber nicht sinnvoll, da die zur +Kontrolle notwendige Leuchtdiodenanzeige hier nicht angeschlossen werden kann. + +Wenn Sie einen Mehrfachsteckplatz angeschlossen haben, werden Sie zuvor noch +gefragt, welchen Steckplatz Sie testen wollen. Bitte beachten Sie hier das im vorigen +Abschnitt Gesagte. Ansonsten ist auch hier die anschließende Einblendung nahezu +identisch. + +Zum Testen geben Sie jetzt einige Werte zwischen 0 und 255 ein. Nach jeder Eingabe +tippen Sie bitte die <RETURN>-Taste. Bei Eingabe der '0' müßten alle Leucht +dioden dunkel sein. Bei '1' dürfte nur die letzte Leuchtdiode (rechts) aufleuchten, +bei 128 nur die erste (links); bei 255 müßten alle 8 Leuchtdioden der Anzeige auf +leuchten. +#page# +Sollten wider Erwarten Fehler aufgetreten sein, lesen Sie bitte im Kapitel 5.5 nach. +Wenn alles wie beschrieben funktioniert hat, gehen Sie gleich zum Eingabetest über. +Verlassen Sie dazu den Ausgabetest durch die Tastenfolge <ESC><q> und +aktivieren Sie anschließend den Menupunkt 'Eingabetest' indem Sie z.B. die Taste +<e> tippen. + +Außer bei der E/A-Karte im Einzelsteckplatz werden Sie hier zusätzlich nach der +Nummer des Kanals gefragt, über den der Einlesetest erfolgen soll. Das liegt daran, +daß sich auf den meisten Interfacesystemen mehrere Eingänge befinden. Beim +Einzelsteckplatz werden die Auswahlmöglichkeiten vorgegeben; beim Mehrfachsteck +platz erfolgt eine freie Eingabe der Kanalnummern. + +Wenn Sie eine Compact-Box angeschlossen haben, müßte die folgende Einblendung +in Ihrem Menubildschirm erscheinen: + + +-------------------------------------------------------------+ + | Eingabetest | + | | + | Eingabe von Kanal 3 (= Digitaleingang der Compact-Box) | + | | + |-------------------------------------------------------------| + | | + | | + | Eingelesener Wert: 129 | + |-------------------------------------------------------------| + | | + +-------------------------------------------------------------+ + +#center#Abb.19: Eingabetest - Einblendung + + +Wenn Sie den Codekartenleser am Digitaleingang angeschlossen haben und alles +korrekt funktioniert, müßte als eingelesener Wert die Zahl 255 erscheinen. Legen Sie +eine Lochkarte ein oder legen Sie einen Finger zwischen Beleuchtung und Licht +sensoren. Daraufhin müßte sich die Anzeige auf dem Bildschirm ändern. Nun +können Sie versuchen, durch Abdecken der Sensoren die bei der Ausgabe schon +angesprochenen Testwerte zu erhalten. +#page# +Wenn Sie über keinen Codekartenleser verfügen, so benutzen Sie jetzt bitte das kleine +Kabelstück, das Sie auf den +5V-Lötschuh aufgesteckt haben und dessen anderes +Ende bisher noch nirgendwo aufgesteckt ist. Berühren Sie nun mit diesem freien +Ende die Stifte, die im 8poligen Eingangs-Platinenstecker sichbar sind. Wird kein Pin +berührt, müßte auf dem Bildschirm der Wert '0' erscheinen. Berühren Sie einen der +Pins an der Seite, müßte der Wert '1', berühren Sie den an der anderen Seite, müßte +der Wert '128' erscheinen. Wenn Sie also nacheinander die Pins berühren, müßten +die Zahlenwerte 1, 2, 4, 8, 16, 32, 64, 128 erscheinen. + +Wenn sowohl Ausgabe- als auch Eingabetest korrekt abgewickelt werden konnten, +brauchen Sie das Kapitel 5.5 nicht zu lesen, denn das beschäftigt sich nur mit +Fehlern, die bisher aufgetreten sein könnten. Den Eingabetest verlassen Sie bitte +durch die Tastenfolge <ESC><q>. + + +#on("b")#5.5 Mögliche Fehlerfälle#off("b")# + +#on("b")# +- Das MUFI wurde in den Terminalkanal eingebaut. Selbst beim vom Netz + getrennten MUFI ist kein Terminalbetrieb möglich: +#off("b")# + + --> Das neu eingefügte Kabel ist unzureichend oder falsch verdrahtet. Bitte + Hinweise im MUFI-Handbuch lesen bzw. Informationen von BICOS ein + holen. + + +#on("b")# +- Das MUFI wurde in den Terminalkanal eingebaut. Beim Einschalten des + MUFIs erscheinen unsinnige Zeichenketten auf dem Bildschirm bzw. das + Einschalten hat noch schwerwiegendere Folgen: #off("b")# + + --> Der "Einschaltknack" des MUFI "schlägt auf andere Systemkomponenten + durch". Sofern nur Zeichen auf dem Bildscchirm erscheinen, ist das weit + gehend unproblematisch - kann auch nicht beseitigt werden. Ansonsten + erst das MUFI, dann das Terminal bzw. den Rechner einschalten. Ggf. + Rücksprache mit BICOS. +#page# +#on("b")# +- Das MUFI wurde in den Terminalkanal eingebaut. Bei ausgeschaltetem + MUFI ist ein einwandfreier Terminalbetrieb möglich, bei einge + schaltetem MUFI reagiert das Terminal nicht mehr: +#off("b")# + + --> MUFI- und Terminalkonfiguration passen nicht zueinander (Baudrate, + Protokoll, Anzahl der Stopbits). Einstellungen am Terminal, in der Task + 'configurator' und die DIP-Schalter-Stellung im MUFI kontrollieren; ggf. + Neueinstellung. + + --> MUFI defekt - Rücksprache mit BICOS. + + +#on("b")# +- Beim Austest erscheint die Einblendung "Interface ist noch nicht + konfiguriert!": +#off("b")# + + --> #on("b")#gs-Prozess#off("b")# wurde noch nicht konfiguriert. Unter dem Oberbegriff 'Inter + face' den Menupunkt 'Konfigurieren' aktivieren und den Ausführungen in + Kapitel 5.3 folgend die Konfiguration vornehmen. + + --> Bei Betrieb des Interface Systems an separater serieller Schnittstelle werden + unbenannte Sohntasks eingerichtet (unter der eigenen Task bzw. unter + einer "zentralen Abwicklungstask"). Diese unbenannte Sohntask wurde + irrtümlich gelöscht. Abhilfe: Neukonfiguration vornehmen. #on("b")#*)#off("b")# + + --> Bei Betrieb des Interface-Systems an separater serieller Schnittstelle und + "zentraler Abwicklungstask" wurde in der "zentralen Abwicklungs-Task" + eine Neukonfiguration von #on("b")#gs-Prozess#off("b")# vorgenommen. Die dabei ent + standene unbenannte Sohntask wird von den "alten" Sohntasks nicht mehr + erkannt. Abhilfe: Alle Sohntasks, die auf die "zentrale Abwicklungstask" + zugreifen, löschen und neu einrichten. #on("b")#*)#off("b")# +#page# +#on("b")# +- Es erscheint die Fehlermeldung "Interface meldet sich nicht!": +#off("b")# + + --> Der angeschlossene Adapter ist ohne Spannungsversorgung. Netzstecker + des Adapters überprüfen. Beim MUFI den Schalter an der Vorderseite in + Stellung 'Ein' bringen. Beim RS232-Adapter den 3poligen Platinenstecker + in die 12V-Spannungsversorgungsbuchse am Interface-System einstecken. + + --> Es wurde bei der Installation von #on("b")#gs-Prozess#off("b")# eine falsche Interface- + Kanal-Nummer angegeben. Die Kanalnummer kann mit 'put(interface + kanal) <RETURN>' erfragt werden. Kanalnummer überprüfen. Ggf. neue + Kanalnummer angeben. Dafür steht die Prozedur 'PROC interfacekanal + (INT CONST nummer)' zur Verfügung. + + --> Speziell beim MUFI: Das MUFI wurde zwischenzeitlich (versehentlich) + ausgeschaltet oder es kam zu einem "ungeregeltem Bedienungsabbruch" + z.B. durch Drücken der SV-Taste im laufenden Betrieb. Die interne Ein + stellung des MUFIs ist verändert. Abhilfe: Menupunkt verlassen, MUFI + ausschalten, einige Sekunden warten, MUFI anschalten, Menupunkt neu + anwählen. + + +#on("b")# +- Es erscheint die Fehlermeldung "Interface-Kanal ist belegt!: +#off("b")# + + --> Das Interface-System ist an einer separaten seriellen Schnittstelle ange + schlossen. Am Kanal wurden schon andere Geräte betrieben, die nicht + ordentlich abgemeldet wurden. Mit 'taskinfo (2) <RETURN>' kann die + Belegung der Kanäle eingesehen werden. Ggf. erst ein Terminal an den + Kanal anschließen (Kanal umkonfigurieren!) und dort 'break + <RETURN>' geben. Oder von einer privilegierten Task aus die ange + koppelte Task "abschießen". + + --> Das Interface-System ist an einer separaten seriellen Schnittstelle ange + schlossen. Eine andere Task greift bereits auf das Interface-System am + eingestellten Kanal zu. Benutzer bitten, den Kanal freizugeben. #on("b")#*)#off("b")# +#page# +#on("b")# +- Es erscheint die Fehlermeldung "Interface-Task ist besetzt!": +#off("b")# + + --> Das Interface-System ist an einer separaten seriellen Schnittstelle ange + schlossen. Die Kommunikation erfolgt über eine "zentrale Abwicklungs + task". Auf diese Task greift zur Zeit ein anderer Benutzer zu. Mit dem + anderen Benutzer verständigen und warten, bis die Task freigegeben wird. + #on("b")#*)#off("b")# + + +#on("b")# +- Es erschient die Fehlermeldung "An Kanal ... ist keine Digitaleingabe + (Digiatalausgabe, Analogeingabe, Analogausgabe) möglich!": +#off("b")# + + --> Laut Konfiguration ist die gewünschte Leistung am angegebenen Kanal auf + der angeschlossenen Interfacekarte nicht möglich. Kanal neu konfigurieren + oder anderen Kanal ansprechen bzw. Interface-Karte wechseln und neu + konfigurieren. + + +#on("b")# +- Es erschient die Fehlermeldung "Kanalnummer ... ist unzulässig!": +#off("b")# + + --> Es wurde eine - bezogen auf das angeschlossene Interface-System - un + sinnige Kanalnummer angegeben. Diese Fehlermeldung erscheint in jedem + Falle, wenn die Kanalnummer kleiner als 1 oder größer als 49 ist! Abhilfe: + korrekte Kanalnummer angeben. + + +#on("b")# +- Es erschient die Fehlermeldung "Interface kann nicht geöffnet werden!": +#off("b")# + + --> Interessanter Fehler! Bitte alle Details der Fehlersituation notieren und an + ERGOS einsenden! +#page# +#on("b")# +- Beim Austest erscheint zwar keine Fehlermeldung, aber die Leucht + diodenanzeige zeigt auf verschiedene Ausgabewerte keine Reaktion + (bleibt dunkel oder unsinnige fixe Anzeige): +#off("b")# + + --> Die angeschlossene Leuchtdiodenanzeige ist nicht korrekt angeschlossen. + Platinenstecker (Digitalausgang) überprüfen; Massekabel überprüfen; die + beiden Überbrückungskabel (Abb.7) überprüfen. + + --> Steckplatz/Compact-Box wird nicht mit Spannung versorgt. Netzkabel/An + schluß zum Netzteil überprüfen. + + --> Verbindungskabel Adapter - Interface-System nicht richtig aufgesteckt oder + intern falsch verdrahtet. + + +#on("b")# +- Beim Austest erscheinen verschiedene Ausgabemuster an den Leucht + dioden, die Muster sind aber nicht korrekt: +#off("b")# + + --> Kabel vom Adapter zum Interface ist falsch verdrahtet. + + --> Kabel in der Leuchtdiodenanzeige (Selbstbau ?) sind falsch verdrahtet. + + +#on("b")#*)#off("b")# Die hier genannten Fehlermeldungen sind bei der oben beschriebenen Erst + installation (noch) nicht möglich. Sie können erst auftreten, wenn weiter + gehende Installationen erfolgt sind (z.B. Installation einer "zentralen Abwick + lungs-Task" etc.). Zum Verständnis lesen Sie bitte das Kapitel "Hinweise für den + Systembetreuer/Programmierer". + + + + + + + + diff --git a/app/gs.process/1.02/doc/gs-prozess-6 b/app/gs.process/1.02/doc/gs-prozess-6 new file mode 100644 index 0000000..a3835cd --- /dev/null +++ b/app/gs.process/1.02/doc/gs-prozess-6 @@ -0,0 +1,641 @@ +limit (11.0)##pagelength (16.5)##block# +#start (2.0,0.0)# +#page (1)# +#headodd# +#center#gs-Prozess#right#% + +#end# +#headeven# +%#center#gs-Prozess + +#end# +#center#1 + +#on("b")#6 Arbeiten mit gs-Prozess#off("b")# + +In diesem Kapitel werden wir Ihnen die Basisbefehle von #on("b")#gs-Prozess#off("b")# vorstellen und +erläutern, was die einzelnen Befehle bewirken. Dabei werden wir an einfachen +Beispielen aufzeigen, wie Sie mit #on("b")#gs-Prozess#off("b")# arbeiten können. + +Wir gehen hier davon aus, daß die Hardware-Voraussetzungen erfüllt, das Interface- +System angeschlossen und die Software (#on("b")#gs-Prozess#off("b")#) auf dem Rechner installiert +sind. Sie sollten #on("b")#gs-Prozess#off("b")# bereits konfiguriert und einen Ein- und Ausgabetest +durchgeführt haben. + +In unserer Beschreibung gehen wir weiterhin davon aus, daß als Interface-System +eine Compact-Box verwendet wird. Alle hier beschriebenen Beispiele gelten ganz +genauso für einen Einzelsteckplatz mit Kombikarte (hier müssen Sie nur zusätzlich +eine Leuchtdiodenanzeige anschließen - aber Sie wissen ja schon, wie das gemacht +wird.) Bei anderen Hardware-Konfigurationen ist darauf zu achten, daß ggf. andere +Kanalnummern anzugeben sind. + +Die Compact-Box verfügt - genau wie die Kombikarte - über zwei analoge Eingänge +(Kanal 1 und Kanal 2), über einen digitalen Eingang (Kanal 3) sowie über einen +digitalen Ausgang (Kanal 4). Wie Sie schon bei der Konfiguration von #on("b")#gs-Prozess#off("b")# +gesehen haben, haben Sie keinen Einfluß auf die Numerierung der Kanäle - die wird +vom #on("b")#gs-Prozess#off("b")# vorgegeben. Diese Kanalnummer müssen Sie kennen, wenn Sie das +System ansprechen (programmieren) wollen (ggf. können Sie die Kanalnummern +durch Aktivieren des Menupunktes 'Information' unter dem Oberbegriff 'Interface' +erfragen). + + +#on("b")#6.1 Kleine Beispiele zur digitalen Ausgabe#off("b")# + +Bei diesem Einführungsbeispiel wollen wir uns zunächst ausschließlich auf die +digitale Ausgabe beschränken. Wenn Sie die Compact-Box (oder eine E/A-Karte) +angeschlossen haben, benötigen Sie hierzu keine zusätzliche Hardware, ansonsten +schließen Sie bitte an Ihren digitalen Ausgang eine 8-elementige Leuchtdiodenanzeige +an. +#page# +Sie haben sicher schon an einer Autobahnbaustelle ein sogenanntes "Lauflicht" +gesehen. Es erscheint, als ob ein Licht über die aufgestellten Barken hinwegläuft. +Dadurch soll auf die Baustellenein- bzw. -ausfahrt hingewiesen werden. Dieser Effekt +wird dadurch erreicht, daß die Lampen, die an den Barken angebracht sind, nach +einander ein- und auch wieder ausgeschaltet werden. + +Wir wollen jetzt auf unserer 8-elementigen Leuchtdiodenanzeige ein solches Lauflicht +nachbilden. Dabei soll das "Licht von rechts nach links über die Anzeige wandern". + +Um das Programm zu schreiben, aktivieren Sie im #on("b")#gs-Prozess#off("b")#-Menu unter dem +Oberbegriff "Programm" den Menupunkt "Neu erstellen". Sie werden dann nach +einem Namen gefragt, den Sie der Programmdatei geben wollen. Tragen Sie hier +einen beliebigen Namen ein, und tippen Sie anschließend die <RETURN>-Taste. +Notieren Sie dann das folgende ELAN-Programm: + +#on("b")# + initialisiere interface; + REP + lauflichtdurchgang; + warte (2.0) + UNTIL abbruch gewuenscht PER. + + lauflichtdurchgang: + bitmuster ausgeben (4, "OOOOOOOI"); + bitmuster ausgeben (4, "OOOOOOIO"); + bitmuster ausgeben (4, "OOOOOIOO"); + bitmuster ausgeben (4, "OOOOIOOO"); + bitmuster ausgeben (4, "OOOIOOOO"); + bitmuster ausgeben (4, "OOIOOOOO"); + bitmuster ausgeben (4, "OIOOOOOO"); + bitmuster ausgeben (4, "IOOOOOOO") +#off("b")# + + +Wenn Sie das Programm fertiggeschrieben haben, verlassen Sie die Datei durch die +Tastenfolge <ESC><q>. Sie gelangen wieder zum Menu und aktivieren jetzt den +Menupunkt "Starten". Daraufhin wird das Programm übersetzt und ausgeführt. +#page# +#on("b")#6.1.1 Möglichkeit eines Programmabbruchs#off("b")# + +Wir hoffen natürlich, daß das Programm genau die Ausgabe an der Leuchtdioden +anzeige erzeugt, die Sie erwartet haben. + +Als Ausgangsbedingung der Schleife haben wir den Testbefehl 'abbruch gewuenscht' +verwendet. Dieser Befehl wird von #on("b")#gs-Prozess#off("b")# zur Verfügung gestellt. Durch den +Testbefehl wird überprüft, ab zwischenzeitlich die Tastenkombination <ESC><q> +eingegeben wurde. Ist das bei unserem Programm der Fall, so wird die Schleife +('regulär') beendet. + +Aber bitte etwas Geduld: Das Programm wird nicht sofort nach Eingabe der Tasten +folge "abgebrochen". Hat nämlich gerade ein neuer 'lauflichtdurchgang' begonnen, +so wird das Refinement natürlich erst vollständig abgearbeitet. Erst dann wird +geprüft, ob die Tastenfolge zwischenzeitlich eingegeben wurde. + +Sollten Sie einmal in einer Situation sein, in der Sie ein Programm tatsächlich +abbrechen müssen, so ist das (in den meisten Fällen) über die Tastenfolge +<ESC><h> möglich. Diese Tastenkombination sollten Sie sich für "Notfälle" +merken. Vielleicht probieren Sie sie gleich an unserem Beispiel aus. + + +#on("b")#6.1.2 Die "sonstigen" Befehle#off("b")# + +Gehen wir zunächst auf die beiden Befehle 'initialisiere interface' und 'warte' sowie +auf den Testbefehl 'abbruch gewuenscht ein: + +#on("b")# +PROC initialisiere interface +#off("b")# + + Jedes Programm zur Prozeßdatenverarbeitung, das auf das Interface-System + zugreift, sollte mit diesem Befehl beginnen. Durch diesen Befehl wird das System + in einen definierten Anfangszustand versetzt; systeminterne Variablen werden + initialisiert, so daß vom Programm aus darauf zugegriffen werden kann. +#page# +#on("b")# +PROC warte (REAL CONST wert) +PROC warte (INT CONST wert) +#off("b")# + + Der Befehl 'warte' ähnelt dem Ihnen sicher bekannten Befehl 'pause'. Allerdings + wird hier als Parameter (INT oder REAL) die Wartezeit in Sekunden angegeben - + bei 'pause' dagegen die Anzahl der Zehntelsekunden. Der eigentliche Unterschied + besteht aber darin, daß 'warte' im Gegensatz zu 'pause' ein "Nothalt" - d.h. die + Tastenkombination <ESC><h>, die wir im vorigen Kapitel beschrieben haben + - registriert. Aus diesem Grunde sollte in Prozeßdatenverarbeitungsprogrammen + mit 'warte' statt mit 'pause' gearbeitet werden. + + +#on("b")# +BOOL PROC abbruch gewuenscht +#off("b")# + + Die Prozedur liefert den Wert 'TRUE', wenn zwischenzeitlich die Tasten + kombination <ESC><q> eingegeben wurde, sonst den Wert 'FALSE'. + + +#on("b")#6.1.3 Schreibweise für Bitmuster/Bitsymbole#off("b")# + +Beim Befehl 'bitmuster ausgeben', wird eine Zeichenkette, die aus 8 Zeichen besteht, +übergeben - das sog. Bitmsuster. In unserem Falle kommen hier nur die Zeichen 'I' +und 'O' vor. Ihnen ist sicher die Bedeutung sofort klar gewesen: + + 'I' bedeutet, daß an der entsprechenden Position ein High-Pegel (5V) angelegt + werden soll; 'O' bedeutet, daß an der entsprechenden Position ein Low- + Pegel (0V) angelegt werden soll. + +So werden über den ersten Befehl im Refinement 'lauflichtdurchgang' alle Leucht +dioden ausgeschaltet, nur die Leuchtdiode ganz rechts wird angeschaltet. Über den +zweiten Befehl wird diese wieder ausgeschaltet und dafür aber die zweite von rechts +eingeschaltet usw. +#page# +Neben den Zeichen 'I' und 'O' dürfen auch die Zeichen 'X' und 'T' in der über +gebenen Zeichenkette auftauchen. Um die Bedeutung zu verstehen, muß man +wissen, daß #on("b")#gs-Prozess#off("b")# den jeweils letzten Zustand des digitalen Ausgangs speichert +(durch 'initialisiere interface' werden alle Ausgänge auf 'O' gesetzt). + + 'X' bedeutet, daß an der entsprechenden Position der zuletzt dagewesene + Zustand erhalten bleibt, d.h. durch diese Ausgabe nicht beeinflußt wird. + + 'T' bedeutet, daß an der entsprechenden Position der zuletzt dagewesene + Zustand "umgekehrt" wird. Lag zuletzt ein Low-Pegel (O) an, so wird + daraus ein High-Pegel (I) und umgekehrt. + +Sie können sich nun sicher sofort erklären, was das folgende Programm bewirkt: + + +#on("b")# + initialisiere interface; + bitmuster ausgeben (4, "OIOIOIOI"); + REP + bitmuster ausgeben (4, "TTTTTTTT"); + warte (1) + UNTIL abbruch gewuenscht PER +#off("b")# + + +Durch den ersten Befehl 'bitmuster ausgeben' wird jede zweite Leuchtdiode ange +schaltet, die anderen werden ausgeschaltet. Durch den zweiten Befehl in der Schleife +wird nun jeweils jeder Zustand in "das Gegenteil umgekehrt", so daß ein Blinklicht +entsteht, bei dem abwechselnd einmal die einen vier, dann die anderen vier Leucht +dioden aufleuchten - und das jeweils für eine Sekunde. + + +#on("b")#6.1.4 Befehle für die digitale Ausgabe#off("b")# + +Einen Befehl, mit dem der digitale Ausgang des Interfaces angesprochen werden +kann, haben Sie schon in Kapitel 6.1 kennengelernt: +#page# +#on("b")# +PROC bitmuster ausgeben (INT CONST kanal, + TEXT CONST zeichenkette) +#off("b")# + +Über den ersten Parameter wird der Kanal angegeben, über den der digitale Ausgang +angesprochen werden kann; bei uns ist das der Kanal 4 auf der Compact-Box. Über +den zweiten Parameter wird das sogenannte Bitmuster übergeben; ein Text, der aus +genau 8 Zeichen besteht. Dabei dürfen die Zeichen "I, O, X und T verwendet werden +(sehen Sie dazu auch Kapitel 6.1.3). + +#on("b")#gs-Prozess#off("b")# stellt noch zwei weitere Befehle für die digitale Ausgabe zur Verfügung. +Um die Wirkungsweise der Befehle zu verdeutlichen, hier das erste Beispiel (das +Lauflicht) in einer zweiten Version: + +#on("b")# + initialisiere interface; + REP + lauflichtdurchgang; + warte (2.0) + UNTIL abbruch gewuenscht PER. + + lauflichtdurchgang: + INT VAR zeiger; + FOR zeiger FROM 0 UPTO 7 REP + schalte aktuelle leichtdiode an; + schalte vorgaenger aus + PER. + + schalte aktuelle leuchtdiode an: + bitsymbol ausgeben (4, zeiger, "I"). + + schalte vorgaenger aus: + IF zeiger = 0 + THEN bitsymbol ausgeben (4, 7, "O") + ELSE bitsymbol ausgeben (4, zeiger - 1, "O") + FI. +#off("b")# + +#on("b")# +PROC bitsymbol ausgeben (INT CONST kanal, bitnummer, + TEXT CONST zeichen) +#off("b")# +#page# +Während durch den Befehl 'bitmuster ausgeben' auf alle 8 Ausgänge gleichzeitig +Einfluß genommen werden kann, wird mit dem Befehl 'bitsymbol ausgeben' gezielt +nur genau einer der 8 Ausgänge, d.h. eines der 8 Bits manipuliert. Welcher Ausgang / +welches Bit manipuliert werden soll, wird über den zweiten Parameter festgelegt: hier +kann einer der Werte 0...7 angegeben werden (Beachten Sie die Numerierung der +Ausgänge (!)). + +Als dritter Parameter wird ein Text übergeben, der aus genau einem Zeichen +bestehen muß. Ebenso wie beim Befehl 'bitmuster ausgeben' sind hier die Zeichen I, +O, X und T zulässig. Sie haben hier auch die gleiche Bedeutung. + +Mit dem dritten Ausgabebefehl für den digitalen Ausgang können wir das Beispiel +noch in einer dritten Version notieren: + +#on("b")# + initialisiere interface; + REP + lauflichtdurchgang; + warte (2.0) + UNTIL abbruch gewuenscht PER. + + lauflichtdurchgang: + INT VAR wert :: 1; + REP + dezimalwert ausgeben (4, wert); + wert := 2 * wert + UNTIL wert > 128 PER. +#off("b")# + +#on("b")# +PROC dezimalwert ausgeben (INT CONST kanal, wert) +#off("b")# + +'wert' kann Werte zwischen 0 und 255 annehmen. Das zugehörige Bitmuster wird +dann am angegebenen Kanal ausgegeben. Anhand dieses Befehls wird Ihnen sicher +auch klar, warum gerade die oben beschriebene Numerierung der Bits gewählt +wurde. +#page# +#on("b")#6.1.5 Befehle für die analoge Ausgabe#off("b")# + +Neben der 'digitalen' Ausgabe ist auch eine 'analoge' Ausgabe möglich. Allerdings +wollen wir die Beschreibung der Befehle an dieser Stelle sehr kurz halten, denn eine +"analoge" Ausgabe ist nur möglich, wenn Sie eine D/A-Karte besitzen. + +Auf der D/A-Karte steht nur ein physikalischer Ausgabekanal zur Verfügung, der von +#on("b")#gs-Prozess#off("b")# jedoch über zwei Kanalnummern angesprochen werden kann. + +Über den Ausgabekanal 1 können Spannungswerte zwischen -5V und +5V aus +gegeben werden, über den Ausgabekanal 2 Spannungswerte zwischen 0V und +5V. + +Dafür stellt #on("b")#gs-Prozess#off("b")# zwei Befehle bereit: + +#on("b")# +PROC spannungswert ausgeben (INT CONST kanal, + REAL CONST wert) +#off("b")# + +'wert' kann, in Abhängigkeit vom angegebenen Kanal, Werte zwischen -5.0 und +5.0 +(bei Kanal 1) bzw. 0.0 und +5.0 (bei Kanal 2) annehmen. Bei dem Versuch, Werte +außerhalb dieser Grenzen anzugeben, erhalten Sie die Fehlermeldung "Der +Spannungswert ... ist nicht zulässig!". + + +#on("b")# +PROC wert an analogausgang ausgeben (INT CONST kanal, wert) +#off("b")# + +Für 'wert' kann eine Zahl zwischen 0 und 255 angegeben werden. Dabei wird 0 auf +den kleinstmöglichen Spannungswert am jeweilgen Kanal (bei Kanal 1 also auf -5V, +bei Kanal 2 auf 0V) und 255 auf den größtmöglichen Spannungswert am jeweilgen +Kanal (bei beiden Kanälen auf +5V) abgebildet. Das Intervall zwischen kleinst- und +größtmöglichem Spannungswert wird in 255 gleichgroße Teilintervalle eingeteilt. Es +wird nun die Spannung ausgegeben, die der Intervallnummer entspricht. +Anmerkung: Dieser Befehl hat nur einen "geringen praktischen Nutzwert"; er dient + vornehmlich dazu, den Wandlungsprozeß zu verdeutlichen. +#page# +#on("b")#6.2 Kleine Beispiele zur digitalen Eingabe#off("b")# + +Für die im folgenden beschriebenen kleinen Beispiele benötigen Sie einen Code +kartenleser und einige Codekarten (können auch von der Fa. AKTRONIK bezogen +werden). Der Anschluß des Codekartenlesers an Ihr Interface-System ist denkbar +einfach. Stecken Sie den 8poligen Platinenstecker des Codekartenlesers in die Buchse +des Digitaleinganges der Steckkarte bzw. der Compact-Box und den 3poligen +Platinenstecker in die passende Spannungsversorgungsbuchse (12V) am Steckplatz +bzw. auf der Compact-Box - fertig! Bei eingeschalteter Betriebsspannung müßte nun +der Codekartenleser beleuchtet sein. + +Auf den Lochkarten sind bis zu 8 Löcher eingestanzt. Dabei können bestimmte +Löcher (Bits) für die Erfassung definierter Merkmale verwendet werden. Dazu kann +eine Karte in bestimmte Bereiche aufgeteilt werden. + +In unserem kleinen Beispiel stellen wir uns vor, daß eine (Modell-)Sparkasse zwei +Filialen hat. Sie hat an Ihre "Kunden" Codekarten verteilt. Die Filialen sind durch +Farben gekennzeichnet. Die oberen (höchstwertigen) zwei Bits der Karte sollen diese +Farbe kodiert enthalten, damit auch der "Sparkassen-Computer" die Farbe schnell +ermitteln kann. Die Karte soll folgenden Aufbau haben: + + +---------------------------------+ + | O o o O o o O | + | | | + | Farbbits| Kundennummer | + | | | + | | | + | | | + | | + +---------------------------------+ + + +#center#Abb.20 Beispiellochkarte +#page# +Bit 7 sei für rote, Bit 6 für grüne Farbe gesetzt, d.h. gelocht. Wie wollen jetzt ein +Programm erstellen, das auf Eingabe einer Karte deren Farbe und den durch die +ersten 6 Bits bestimmten Wert (Kundennummer) ausgibt: + +#on("b")# + initialisiere interface; + REP + erfasse lochkarte + UNTIL abbruch gewuenscht PER. + + erfasse lochkarte: + warte bis karte im leser; + gib farbe aus; + gib kundennummer aus; + warte bis keine karte im leser. + + warte bis karte im leser: + put ("Bitte eine Codekarte einlegen!"); line; + WHILE NOT alles abgedunkelt REP + tue nichts + END REP; + WHILE alles abgedunkelt REP + tue nichts + END REP; + warte (1). + + warte bis keine karte im leser: + put ("Bitte die Karte entnehmen!"); + REP + tue nichts + UNTIL alles beleuchtet PER. + + alles abgedunkelt: + bitmuster (3) = "OOOOOOOO". + + alles beleuchtet: + bitmuster (3) = "IIIIIIII". + + gib farbe aus: + IF bitsymbol (3, 7) = "I" + THEN put ("rote Karte"); line + ELSE put ("grüne Karte");line + FI; +#page# + gib kundennummer aus: + INT VAR kundennummer :: 0, bitnummer; + FOR bitnummer FROM 0 UPTO 5 REP + registriere gesetztes bit + PER; + put ("Kundennummer:"); put (kundennummer): line. + + registriere gesetztes bit: + IF bit ist gesetzt (3, bitnummer) + THEN kundennummer INCR (2 ** bitnummer) + FI. + + +#off("b")# + (Hinweis: Es handelt sich hier um ein Beispielprogramm, an dem diverse + Befehle erläutert werden sollen - die Programmierung ist nicht + optimal! Im Refinement 'warte bis karte im leser' ist es z.B. + günstiger, solange einzulesen, bis der eingelesene Wert "stabil" ist. + Auch das Refinement 'registriere gesetztes bit' würde man so nicht + programmieren, sondern nach einem Einlesevorgang (Bitmuster) + über Textoperationen aus dem Bitmuster die 'kundennummer' + ermitteln...). + +Bevor wir Ihnen die Funktionsweise der von #on("b")#gs-Prozess#off("b")# bereitgestellten Prozeduren +im Detail erläutern, möchten wir Ihnen noch ein paar kurze Erläuterungen zum +obigen Programm geben. + +Besondere Aufmerksamkeit sollten Sie den Refinements 'warte bis karte im leser' und +'warte bis keine karte im leser' schenken. Im erstgenannten Refinement ist sicherzu +stellen, daß das Einschieben der Karte (erst muß alles abgedunkelt werden - dann +müssen einige Positionen beleuchtet sein) registriert wird. Um Fehlauswertungen der +Karte zu vermeiden (z.B. beim Verkanten einer Karte) wird zur Sicherheit vor der +Auswertung eine Sekunde gewartet. Am Ende des Lesevorgangs soll sichergestellt +werden, daß die Karte auch entnommen worden ist (alle Positionen wieder beleuchtet +sind). +#page# +Wir prüfen im Refinement 'gib farbe aus' nur das 7. Bit (sehen Sie die Erklärung zu +'bitsymbol'). Ist das Bit gesetzt (die Karte hier gelocht), so identifizieren wir die Farbe +Rot, sonst Grün. Natürlich ist es möglich, mit 2 "Farbbits" vier Farben zu ver +schlüsseln: z.B. Rot, wenn nur Bit 7 gesetzt ist; Grün, wenn nur Bit 6 gesetzt ist; Blau, +wenn Bit 7 und Bit 6 gesetzt sind; Gelb, wenn weder Bit 7 noch Bit 6 gesetzt sind. +Dadurch wird der Auswertalgorithmus aber etwas aufwendiger. Vielleicht probieren +Sie es nacher einmal. + +Die Prozedur 'tue nichts' wird schon von #on("b")#gs-Prozess#off("b")# bereitgestellt. Es wird keine +Aktion ausgeführt - jedoch überprüft, ob zwischenzeitlich die Tastenfolge +<ESC><h> ("Notbremse") eingegeben wurde. Es empfiehlt sich, diese Prozedur +gerade in Schleifenrümpfen einzusetzten, damit die Möglichkeit besteht, bei einer +"Endlosschleife" einen Abbruch herbeizuführen (sonst "hängt" die Task ggf. am +Interfacekanal)! + + +#on("b")#6.2.1 Befehle für die digitale Eingabe#off("b")# + +In Kapitel 6.1.4 haben Sie die Befehle für die digitale Ausgabe kennengelernt, die +Ihnen #on("b")#gs-Prozess#off("b")# zur Verfügung stellt. Zu jedem dieser drei Befehle gibt es das +"Gegenstück" auch als Eingabebefehl. Alle Eingabebefehle sind als werteliefernde +Prozeduren (Funktionen) ausgelegt. + +In den Refinements 'alles abgedunkelt' und 'alles beleuchtet' benutzen wir den +Befehl: + +#on("b")# +TEXT PROC bitmuster (INT CONST kanal) +#off("b")# + +Über den Parameter wird der Kanal angegeben, über den der digitale Eingang ange +sprochen werden kann; bei uns ist das der Kanal 3 auf der Compact-Box. Die +Prozedur liefert einen Text, der aus acht Zeichen besteht. Dabei können nur die +Zeichen "I und "O" auftreten (sehen Sie dazu auch Kapitel 6.1.3). +#page# +Die beiden gerade genannten Refinements hätten aber auch so notiert werden +können: + +#on("b")# + alles abgedunkelt: + dezimalwert (3) = 0. + + alles beleuchtet: + dezimalwert (3) = 255. +#off("b")# + +#on("b")# +INT PROC dezimalwert (INT CONST kanal) +#off("b")# + +Über den Parameter wird der Kanal angegeben, über den der digitale Eingang ange +sprochen werden kann; bei uns ist das wieder der Kanal 3 auf der Compact-Box. Die +Prozedur liefert einen Integer-Wert zwischen 0 und 255 (sehen Sie dazu auch unter +'dezimalwert ausgeben' im Kapitel 6.1.4). + +Den dritten Eingabebefehl für den Digitaleingang, den #on("b")#gs-Prozess#off("b")# bereitstellt, finden +Sie im Refinement 'gib farbe aus': + +#on("b")# +TEXT PROC bitsymbol (INT CONST kanal, bitnummer) +#off("b")# + +Wie schon bei den anderen beiden Eingabebefehlen wird hier über den ersten +Parameter der Eingabekanal festgelegt; bei uns auf der Compact-Box ist das wieder +der Kanal 3. Über den zweiten Parameter wird die Nummer des Bits angegeben, +dessen Wert ermittelt werden soll. Ist das betreffende Bit gesetzt, so liefert die +Prozedur das Zeichen "I", sonst das Zeichen "O" (sehen Sie dazu auch das Kapitel +6.1.3 'Schreibweise für Bitmuster/Bitsymbole'). + + +#on("b")#6.2.2 Eingabetests#off("b")# + +Neben diesen drei Eingabebefehlen stellt #on("b")#gs-Prozess#off("b")# noch zwei Testbefehle zur +Verfügung, die man häufig gut verwenden kann. Auf einen greifen wir schon im +Refinement 'registriere gesetztes bit' zurück: +#page# +#on("b")# +BOOL PROC bit ist gesetzt (INT CONST kanal, bitnummer) +#off("b")# + +Die Parameter sind die gleichen wie beim Befehl 'bitsymbol'. Zunächst liest die +Prozedur die aktuelle Einstellung am angegebenen Digitaleingang ('kanal') ein und +untersucht dann das Bit mit der angegebenen Bitnummer (0, ..., 7). Die Prozedur +liefert den Wert 'TRUE', wenn das Bit mit der entsprechenden Bitnummer gesetzt ist +(die Prozedur bitsymbol' mit gleichen Parametern also den Wert "I" liefern würde), +sonst 'FALSE' (die Prozedur bitsymbol' mit gleichen Parametern also den Wert "O" +liefern würde). + +Den zweiten Testbefehl haben wir im obigen Programm noch nicht verwendet. Wir +könnten damit aber auch die Refinements 'alles abgedunkelt' und 'alles beleuchtet' +folgendermaßen notieren: + +#on("b")# + alles abgedunkelt: + bitmuster gleich (3, "OOOOOOOO"). + + alles beleuchtet: + bitmuster gleich (3, "IIIIIIII"). +#off("b")# + + +#on("b")# +BOOL PROC bitmuster gleich (INT CONST kanal, + TEXT CONST vorgabe) +#off("b")# + +Wie bereits zuvor wird über den ersten Parameter der Kanal angegeben, über den der +Digitaleingang angesprochen werden kann. Zunächst liest die Prozedur am ange +gebenen Kanal die aktuelle Einstellung ein und vergleicht es mit der 'vorgabe'. Der +eigentliche Vorteil der Prozedur liegt darin, daß bei der Beschreibung der 'vorgabe' +neben den Zeichen "I" und "O" auch das Zeichen "X" verwendet werden darf. z.B. +"IOXXXXX". Entspricht das eingelesene Bitmuster der 'vorgabe', so liefert die Prozedur +den Wert 'TRUE', sonst den Wert 'FALSE'. In gerade genannten Beispiel liefert die +Prozedur also immer dann 'TRUE', wenn eine Karte mit der Markierung für Rot +eingeschoben wurde - gleichgültig, welche Kundennummer eingestanzt ist. +#page# +#on("b")#6.2.3 Befehle für die analoge Eingabe#off("b")# + +Die analoge Eingabe möchten wir Ihnen an einem ganz einfachen Beispiel vor Augen +führen. Sie brauchen dazu nur ein ganz normales Drehpotentiometer (ca. 5kOhm), +das Sie in jedem Elektronik-Fachgeschäft für wenig Geld erhalten können. Ein +solches Drehpotentiometer verfügt über drei Anschlüsse. Wenn man sich den inneren +Aufbau vor Augen führt, ist die Belegung der drei Anschlüsse auch recht einsichtig. + + + siehe Physikbuch!! + + + +#on("b")##center#Abb.21 Aufbau eines Drehpotentiometers#off("b")# + +Löten Sie ggf. auf die drei Anschlüsse je einen Lötschuh, um eine einfache Steckver +bindung zur Kombikarte/Compact-Box herstellen zu können. Wichtig ist vor allem, +daß der mittlere Anschluß am Drehpotentiometer auf den mittleren Stecksockel am +Analogeingang auf der Kombikarte/Compact-Box aufgesteckt wird. Die beiden +anderen Anschlüsse können können Sie beliebig auf die beiden dann noch freien +Lötstifte (+ und �) des gleichen Analogeingangs aufstecken. + +Starten Sie dann das folgende Programm: + +#on("b")# + initialisiere interface; + page; + REP + notiere potentiometerwert + UNTIL abbruch gewuenscht PER. + + notiere potentiometerwert: + put (wert von analogeingang (1)); + line. +#off("b")# +#page# +Nach dem Start des Programms müßten auf dem Bildschirm untereinander immer +wieder die gleiche Zahl (ein Wert zwischen 0 und 255) auftauchen. Wenn Sie dann +am Potentiometer drehen, müßten sich auch die Werte auf dem Bildschirm ändern. + +Sie hätten das Refinement 'notiere potentiometerwert' auch folgendermaßen notieren +können: + +#on("b")# + notiere potentiometerwert: + put (spannungswert (1)); + line. +#off("b")# + +Statt Wert zwischen 0 und 255 zu erhalten, müßten Sie jetzt Werte zwischen 0.0 und +5.0 erhalten. + + +#on("b")# +REAL PROC spannungswert (INT CONST kanal) +#off("b")# + +Über den Parameter wird der Kanal angegeben, über den der analoge Eingang ange +sprochen werden kann; bei uns ist das der Kanal 1 (oder 2) auf der Kombikarte/ +Compact-Box. Auf der Kombikarte/Compact-Box können nur Spannungswerte +zwischen 0.0V und 5.0V eingelesen werden. Auf der A/D-Karte kann der Bereich für +die einzulesenden Sapnnungwerte durch die Schalterstellung auf der Karte eingestellt +werden (Sehen Sie dazu auch Kapitel 5.3.1). + + +#on("b")# +REAL PROC wert von analogeingang (INT CONST kanal) +#off("b")# + +Über den Parameter wird der Kanal angegeben, über den der analoge Eingang ange +sprochen werden kann; bei uns ist das der Kanal 1 (oder 2) auf der Kombikarte/ +Compact-Box. Geliefert werden Werte zwischen 0 und 255. + +Tatsächlich wird aber ein Spannungswert vom Analogeingang eingelesen. Dieser +Spannungswert wird vom Analog-Digital-Wandler auf der Karte nach folgendem +Verfahren gewandelt: +#page# +Dem größtmöglichen Spannungswert an diesem Eingang wird der Wert 255, dem +kleinstmöglichen der Wert 0 zugeordnet. Das Intervall zwischen dem kleinst- und +größtmöglichen Spannungswert wird in 255 gleichgroße Teilintervalle eingeteilt. Es +wird nun die Nummer des Intervalls geliefert, in das die eingelesene Spannung fällt. +Kleinst- und größtmögliche Spannungswerte sind abhängig von der aktuellen Steck +karte, Interface-Konfiguration). + + +#on("b")#6.3 Hinweise auf Aufgabenmaterial#off("b")# + +Eine Fülle von Beispielanwendungen sind beschrieben in: + + Landesinstitut für Schule und Weiterbildung (Hrsg.), Materialien zur Lehrerfort + bildung in Nordrhein-Westfalen, Heft 2, Neue Technologien - Informations + technologische Inhalte im Wahlpflichtunterricht der Klassen 9/10, 2. über + arbeitete Auflage 1987 + diff --git a/app/gs.process/1.02/doc/gs-prozess-7 b/app/gs.process/1.02/doc/gs-prozess-7 new file mode 100644 index 0000000..db3b9d1 --- /dev/null +++ b/app/gs.process/1.02/doc/gs-prozess-7 @@ -0,0 +1,1121 @@ +limit (11.0)##pagelength (16.5)##block# +#start (2.0,0.0)# +#page (1)# +#headodd# +#center#gs-Prozess#right#% + +#end# +#headeven# +%#center#gs-Prozess + +#end# +#center#1 + +#on("b")#7 Beschreibung der Menufunktionen#off("b")# + +Nach Aufruf meldet sich #on("b")#gs-Prozess#off("b")# zunächst mit dem #on("b")#gs-DIALOG#off("b")#-Emblem. Kurze +Zeit später erscheint das folgende Menu auf dem Bildschirm: + ++---------------------------------------------------------------------+ +| PDV: Info Interface Programm Archiv | +|-------+------------------------+------------------------------------+ +| | u Übersicht Befehle | | +| | --------------------- | | +| | a Ausgabebefehle | | +| | e Eingabebefehle | | +| | t Testbefehle | | +| | w Weitere Befehle | | +| | --------------------- | | +| | b Bitmuster | | +| | s Symbole/Zeichen | | +| | d Digital-/Analogwerte| | +| +------------------------+ | +| | +| +----------------------------------------+ | +| | gs-Prozess | | +| | Version 1.0 | | +| | | | +| | Copyright Ρ 1988 bei Eva Latta-Weber, | | +| | Bielefeld | | +| +----------------------------------------+ | ++---------------------------------------------------------------------+ +|Info:<ESC><?>/<?> Wahl:<Pfeile> Ausführen:<RETURN> Verlassen:<ESC><q>| ++---------------------------------------------------------------------+ + +#center#Abb.22: Eingangsbildschirm #on("b")#gs-Prozess#off("b")# + + +Bevor wir Ihnen die Bedeutung der einzelnen Menupunkte erklären, geben wir erst +noch einige grundsätzliche Hinweise zur Bedienung des Menusystems für diejenigen +Leser, die im Umgang mit Menus unter #on("b")#gs-DIALOG#off("b")# nicht geübt sind. +#page# +#on("b")#7.1 Kurzhinweise zur Bedienung der Menus#off("b")# + +Die Bedienung des Menus ist sehr einfach. Eine ausführliche Beschreibung dazu +finden Sie in den Unterlagen zum Programmsystem #on("b")#gs-DIALOG#off("b")#. An dieser Stelle +sollen nur die wesentlichen Bedienungsvorgänge beschrieben werden. + +- Mit der Tastenfolge <ESC><?> können Sie sich Informationen zur Bedienung + des Menusystems in das Menu einblenden lassen. + +- Mit den Pfeiltasten <rechts> und <links> können Sie zwischen den "Ober + begriffen" in der Kopfzeile wählen. Der aktuelle Oberbegriff ist jeweils invers + dargestellt. Das ausgeklappte 'Pull-Down-Menu' bezieht sich auf diesen invers + dargestellten Oberbegriff. + +- Mit den Pfeiltasten <hoch> und <runter> können Sie zwischen den Menu + funktionen wählen, die Ihnen im aktuellen Pull-Down-Menu zur Auswahl ange + boten werden. Die aktuell angewählte Menufunktion wird jeweils invers darge + stellt. Die Trennlinien, die in einigen Pull-Down-Menus sichtbar sind, dienen nur + der optischen Untergliederung; sie können nicht angewählt werden und werden + deshalb automatisch übersprungen. Die einzelnen Menupunkte sind "zyklisch + miteinander verknüpft", das heißt, man gelangt vom untersten Menupunkt + wieder zum obersten und umgekehrt. Menupunkte, vor denen ein Minuszeichen + steht ('-'), sind (zur Zeit) nicht aktivierbar; auch sie können nicht angewählt + werden und werden einfach übersprungen. + +- Durch Tippen der Fragezeichentaste (<?>) können Sie sich jeweils zur + aktuellen Menufunktion (invers im Pull-Down-Menu) Informationen in das + Menu einblenden lassen. + +- Um eine Menufunktion ausführen zu lassen, bewegen Sie sich mit den Pfeiltasten + auf die gewünschte Menufunktion im aktuellen Pull-Down-Menu und tippen + dann die <RETURN>-Taste. Steht vor dem gewünschten Menupunkt ein +#page# + einzelner Buchstabe oder eine Ziffer, so kann durch Tippen der entsprechenden + Taste diese Menufunktion dadurch direkt aufgerufen werden. Sobald eine Menu + funktion aufgerufen worden ist, erscheint davor ein Stern ('*'). Daraus können + Sie entnehmen, daß das System bereits den Auftrag ausführt. + +- An verschiedenen Stellen werden Fragen an Sie gerichtet, die Sie mit 'ja' oder + 'nein' beantworten müssen. Tippen Sie dazu entsprechend der Entscheidung die + Taste <j> (für 'ja') bzw. <n> (für 'nein'). + +- Werden Ihnen vom Menu aus Dateinamen zur Auswahl angeboten, so können Sie + den auf dem Bildschirm sichtbaren Pfeil vor den gewünschten Namen + positionieren. Mit den Tasten <x> oder <RETURN> können Sie den Namen + ankreuzen. Ist die Auswahl mehrerer Dateinamen möglich, so können Sie den + Vorgang wiederholen. Mit den Tasten <o> oder <RUBOUT> können Sie auch + ein Kreuz vor einem Namen wieder löschen. Daneben gibt es noch einige Ta + stenfunktionen, die für die Bedienung recht hilfreich sein können. Tippen Sie + während der Auswahl die Fragezeichentaste (<?>), so werden Ihnen alle + Bedienungsmöglichkeiten auf dem Bildschirm angezeigt. Eine Auswahl, in der + mehrere Dateien angekreuzt werden dürfen, wird durch die Tastenfolge + <ESC><q> verlassen. Anschließend wird die eingestellte Operation mit den + angekreuzten Dateien ausgeführt. Sind Sie versehentlich in eine solche Auswahl + gelangt, so können Sie den Vorgang durch die Tastenkombination <ESC><h> + abbrechen. + +- An einigen Stellen werden Sie aufgefordert, eine Eingabe zu machen (z.B. einen + Dateinamen einzugeben). Wird Ihnen hier ein Vorschlag gemacht, den Sie + akzeptieren, so brauchen Sie zur Bestätigung nur die <RETURN>-Taste zu + tippen. Gefällt Ihnen der Vorschlag nicht oder wird Ihnen kein Vorschlag ge + macht, so machen Sie bitte die gewünschte Eingabe. Zum Schreiben stehen + Ihnen alle aus dem Editor bekannten Funktionen zur Verfügung. Mit der Taste + <RUBOUT> können Sie Buchstaben löschen, mit <RUBIN> einfügen. Die +#page# + Eingabe wird durch Tippen der <RETURN>-Taste abgeschlossen. Ist der von + Ihnen gewünschte Name schon in Ihrer Task vorhanden und steht in der Fußzeile + der Hinweis 'Zeigen: <ESC><z>', dann können Sie sich auch alle vor + handenen Namen zur Auswahl anbieten lassen und durch Ankreuzen den beab + sichtigten Namen auswählen. + +- Ihnen können auch mehrere Alternativen angeboten werden, zwischen denen Sie + wählen müssen. In der untersten Zeile eines solchen Kastens, in denen Ihnen die + Alternativen auf dem Bildschirm eingeblendet werden, sind die Möglichkeiten + aufgeführt, die darüber beschrieben sind. Mit den Pfeiltasten können sie die + Markierung auf die gewünschte Alternative positionieren und dann durch die + <RETURN>-Taste zur Ausführung bringen. (Manchmal ist das auch durch + Tippen der den Alternativen vorangestellten Buchstaben oder Ziffern möglich). + +- Durch die Tastenfolge <ESC><q> kann das Menu insgesamt verlassen + werden. Damit das nicht versehentlich geschieht, wird jeweils die Frage gestellt, + ob Sie das Menu tatsächlich verlassen wollen. Diese Frage beantworten Sie bitte je + nach Wunsch mit 'ja' oder 'nein' durch Tippen der Tasten <j> bzw. <n>. + + +#on("b")#7.2 Menufunktionen zum Oberbegriff 'Info'#off("b")# + +Das auf dem Bildschirm sichtbare Pull-Down-Menu ist oben abgebildet. + +#on("b")#u Übersicht Befehle#off("b")# + +Mit dieser Funktion können Sie sich eine Übersicht der Befehle, die Ihnen +#on("b")#gs-Prozess#off("b")# zur Verfügung stellt, in den aktuellen Bildschirm einblenden lassen: +#page# +#free(2.0)# + +------------------------------------------------------------+ + | Ausgabebefehle: Eingabebefehle: | + | | + | dezimalwert ausgeben dezimalwert | + | bitmuster ausgeben bitmuster | + | bitsymbol ausgeben bitsymbol | + | spannungswert ausgeben spannungswert | + | wert an analogausgang ausgeben wert von analogeingang | + | | + | | + | Testbefehle: Weitere Befehle: | + | | + | bitmuster gleich initialisiere interface | + | bit ist gesetzt warte | + | | + +------------------------------------------------------------+ +#center#Abb.23: Befehlsübersicht + + Es werden 'Eingabebefehle', 'Ausgabebefehle' und 'Testbefehle' unterschieden. + Darüberhinaus werden 'Weitere Befehle' angegeben. Eine ausführliche + Beschreibung der einzelnen Befehle ist unter den gleichnamigen Menupunkten + abrufbar. + + +#on("b")#a Ausgabebefehle#off("b")# + + Mit dieser Funktion können Sie sich die zur Verfügung stehenden Ausgabe + befehle detailliert erläutern lassen. Zuerst gelangen Sie in eine Auswahl, von + der aus zu jedem einzelnen Ausgabebefehl eine Informationstafel abgerufen + werden kann: +#page# +#free(2.0)# + +-------------------------------------+ + | Ausgabebefehle: | + | | + | 1 dezimalwert ausgeben | + | | + | 2 bitmuster ausgeben | + | 3 bitsymbol ausgeben | + | | + | 4 spannungswert ausgeben | + | 5 wert an analogausgang ausgeben | + | | + | z Zurück in das Menu | + | | + | 1 2 3 4 5 z | + +-------------------------------------+ + +#center#Abb.24: Auswahl Ausgabebefehle + + Auf jeder Informationstafel ist ein kleines Beispiel zur Verwendung des Befehls + angegeben, das auch erläutert wird. Anschließend wird ausführlich auf die + Parameter der Befehle eingegangen (Datentyp, Wertebereich, etc.). Aus den + einzelnen Informationstafeln gelangen Sie immer wieder zur Auswahl zurück. + Wird die Auswahl selbst verlassen, gelangen Sie zurück ins Ausgangsmenu. + + +#on("b")#e Eingabebefehle#off("b")# + + Mit dieser Funktion können Sie sich die zur Verfügung stehenden Eingabe + befehle detailliert erläutern lassen. Zuerst gelangen Sie in eine Auswahl, von + der aus zu jedem einzelnen Eingabebefehl eine Informationstafel abgerufen + werden kann: +#page# +#free(1.0)# + +------------------------------+ + | Eingabebefehle: | + | | + | 1 dezimalwert | + | | + | 2 bitmuster | + | 3 bitsymbol | + | | + | 4 spannungswert | + | 5 wert von analogeingang | + | | + | z Zurück in das Menu | + | | + | 1 2 3 4 5 z | + +------------------------------+ + + +#center#Abb.25: Auswahl Eingabebefehle + + Auf jeder Informationstafel ist ein kleines Beispiel zur Verwendung des Befehls + angegeben, das auch erläutert wird. Anschließend wird ausführlich auf die + Parameter der Befehle (Datentyp, Wertebereich, etc.) und die Werte, die + geliefert werden, eingegangen. + + Aus den einzelnen Informationstafeln gelangen Sie immer wieder zur Auswahl + zurück. Wird die Auswahl selbst verlassen, gelangen Sie zurück ins Ausgangs + menu. + + +#on("b")#t Testbefehle#off("b")# + + Mit dieser Funktion können Sie sich die zur Verfügung stehenden Testbefehle + detailliert erläutern lassen. Zuerst gelangen Sie in eine Auswahl, von der aus zu + jedem einzelnen Testbefehl eine Informationstafel abgerufen werden kann: +#page# + +------------------------+ + | Testbefehle: | + | | + | 1 bitmuster gleich | + | 2 bit ist gesetzt | + | | + | z Zurück in das Menu | + | | + | 1 2 z | + +------------------------+ + +#center#Abb.26: Auswahl Testbefehle + + Auf jeder Informationstafel ist ein kleines Beispiel zur Verwendung des Befehls + angegeben, das auch erläutert wird. Anschließend wird ausführlich auf die + Parameter der Befehle (Datentyp, Wertebereich, etc.) und die Werte, die ge + liefert werden, eingegangen. + Aus den einzelnen Informationstafeln gelangen Sie immer wieder zur Auswahl + zurück. Wird die Auswahl selbst verlassen, gelangen Sie zurück ins Ausgangs + menu. + + +#on("b")#w Weitere Befehle#off("b")# + + Hier werden noch weitere zur Verfügung stehende Befehle erläutert, die für die + Programmierung ganz hilfreich sind. Zuerst gelangen Sie in eine Auswahl, von + der aus zu jedem Befehl eine Informationstafel abgerufen werden kann: + + + +----------------------------+ + | Weitere Befehle: | + | | + | 1 initialisiere interface | + | 2 warte | + | | + | z Zurück in das Menu | + | | + | 1 2 z | + +----------------------------+ + +#center#Abb.27: Auswahl 'Weitere Befehle' +#page# + Aus den einzelnen Informationstafeln gelangen Sie immer wieder zur Auswahl + zurück. Wird die Auswahl selbst verlassen, gelangen Sie zurück ins Ausgangs + menu. + + +#on("b")#b Bitmuster#off("b")# + + Nach Aufruf dieser Funktion wird der Aufbau der Bitmuster erläutert, die als + Parameter übergeben oder auch von Prozeduren geliefert werden. + + Insbesondere wird auf die Numerierung der einzelnen Bits eingegangen. + + +#on("b")#s Symbole/Zeichen#off("b")# + + Nach Aufruf der Funktion werden die Zeichen erläutert, die bei der Be + schreibung von Bitmustern und Bitsymbolen Verwendung finden. + + +#on("b")#d Digital-/Analogwerte#off("b")# + + Bei den beiden Befehlen 'wert an analogausgang ausgeben' und 'wert von + analogeingang', wird ein Wert zwischen 0 und 255 als Parameter übergeben + bzw. von der Prozedur geliefert. Am Analogausgang wird aber eine Spannung + ausgegeben bzw. eingelesen. Hier wird erläutert, wie die Spannungswerte + innerhalb der Prozeduren gewandelt werden. + + +#on("b")#7.3 Menufunktionen zum Oberbegriff 'Interface'#off("b")# + +Über die Menufunktionen unter diesem Oberbegriff nehmen Sie die Konfiguration +von #on("b")#gs-Prozess#off("b")# vor. Ebenso ist von hier aus ein Test des Interface-Systems möglich. +#page# + ++-----------------------------------------------------------------------+ +| PDV: Info Interface Programm Archiv | ++-------+-------------------+-------------------------------------------+ +| | i Informationen | | +| | ---------------- | | +| | k Konfigurieren | | +| | ---------------- | | +| | a Ausgabetest | | +| | e Eingabetest | | +| +-------------------+ | +| | +| | +| | ++---------------------------------------------------------------------- + +| Info:<ESC><?>/<?> Wahl:<Pfeile> Ausführen:<RETURN> Verlassen:<ESC><q> | ++-----------------------------------------------------------------------+ + +#center#Abb.28: Menubildschirm zum Oberbegriff 'Interface' + + +#on("b")#i Informationen#off("b")# + + Mit dieser Menufunktion können Sie sich zu jedem Zeitpunkt die aktuell + eingestellte Konfiguration von #on("b")#gs-Prozess#off("b")# anzeigen lassen. Sie können er + sehen, welches Interface-System eingestellt ist, wie die Kanäle belegt und + numeriert sind (sehen Sie das Beispiel in Abb.13). + + Ist eine Compact-Box oder ein Einzelsteckplatz eingestellt, erhalten Sie die + Informationen direkt eingeblendet. Ist dagegen ein Mehrfachsteckplatz einge + stellt, gelangen Sie in eine Auswahl. Von hier aus können Sie Informationen zu + jedem einzelnen Steckplatz getrennt abrufen. + + Fehlerfälle: + - Wurde #on("b")#gs-Prozess#off("b")# bisher noch nicht konfiguriert, so erhalten Sie eine + Warnung (sehen Sie Abb.11). In diesem Falle ist zunächst eine Konfigura + tion von #on("b")#gs-Prozess#off("b")# vorzunehmen (sehen Sie die Beschreibung zur + nächsten Menufunktion). +#page# +#on("b")#k Konfigurieren#off("b")# + + Mit dieser Menufunktion können Sie #on("b")#gs-Prozess#off("b")# auf das aktuell angeschlos + sene Interface-System einstellen. Dazu haben Sie verschiedene Angaben zu + machen. + + Zunächst wird Ihnen eine Auswahl der Steckplatzart angeboten (sehen Sie + dazu Abb.12). Hier können Sie zur Zeit zwischen Compact-Box, Einzelsteck + platz und Mehrfachsteckplatz wählen. + + Ist eine Compact-Box angeschlossen, ist mit der hier gemachten Angabe die + Konfiguration abgeschlossen; die aktuelle Kanalbelegung wird Ihnen dann nur + noch zur Information eingeblendet. + + Bei Einzel- und Mehrfachsteckplatz haben Sie noch anzugeben, welche Inter + facekarte eingesteckt ist. Beim Einzelsteckplatz ist diese Angabe nur einmal zu + machen, beim Mehrfachsteckplatz halt mehrfach. Hierzu wird Ihnen aber + ebenfalls eine Auswahl angeboten (sehen Sie Abb.14). Nach jeder vorge + nommenen Einstellung wird Ihnen zur Information die Kanalbelegung mitge + teilt. Sofern Sie eine A/D-Karte verwenden, wird noch die Schalterstellung auf + der Karte erfragt, denn daraus kann #on("b")#gs-Prozess#off("b")# die eingestellte Eingangsem + pfindlichkeit ermitteln. + + +#on("b")#a Ausgabetest#off("b")# + + Mit dieser Menufunktion können Sie auf einfache Weise testen, ob Ihr Inter + face-System korrekte Ausgaben erzeugt. Nach Aktivieren der Menufunktion + erhalten Sie die Möglichkeit, Ausgabewerte einzutragen (sehen Sie Abb.18). + Jede Eintragung ist durch <RETURN> abzuschließen. + + Für den Ausgabetest sollte eine Leuchtdiodenanzeige zur Verfügung stehen, um + die Ausgaben am Interface kontrollieren zu können. Für detailliertere Informa + tionen lesen Sie bitte unbedingt Kapitel 5. +#page# + Fehlerfälle: + - Interface meldet sich nicht! + Abhilfe: Überprüfen, ob der Adapter ordnungsgemäß angeschlossen + und eingeschlatet ist (sehen Sie Kapitel 5). Wenn ein MUFI + verwendet wird, MUFI aus- und nach kurzer Pause wieder + einschalten. Noch einmal den Ausgabetest versuchen. + - Interface-Kanal belegt! + (Kann nur beim Betrieb von MUFI als Endgerät oder bei RS232-Adapter + auftreten!) + Abhilfe: Feststellen, welche Task an den Interface-Kanal gekoppelt ist + ('taskinfo (2) <RETURN>') und diese dann abmelden + ('break' oder 'end'). Die Nummer des Interfacekanals kann + mit dem Kommando 'put (interfacekanal) <RETURN>' + erfragt werden. + - Sehen Sie bitte die detaillierte Fehlerliste in Kapitel 5.5. + + +#on("b")#e Eingabetest#off("b")# + + Mit dieser Menufunktion können Sie auf einfache Weise testen, ob über Ihr + Interface-System korrekte Eingaben möglich sind. Nach Aktivieren der Menu + funktion erhalten Sie die Möglichkeit, am Interface angelegte Eingabewerte + abzulesen (sehen Sie Abb.19). + + Für den Eingabetest sollte ein Codekartenleser oder zumindest ein kurzer + Draht zur Verfügung stehen. Für detailliertere Informationen lesen Sie bitte + unbedingt Kapitel 5. + + Fehlerfälle: + - Interface meldet sich nicht! + Abhilfe: Überprüfen, ob der Adapter ordnungsgemäß angeschlossen + und eingeschlatet ist (sehen Sie Kapitel 5). Wenn ein MUFI + verwendet wird, MUFI aus- und nach kurzer Pause wieder + einschalten. Noch einmal den Ausgabetest versuchen. +#page# + - Interface-Kanal belegt! + (Kann nur beim Betrieb von MUFI als Endgerät oder bei RS232-Adapter + auftreten!) + Abhilfe: Feststellen, welche Task an den Interface-Kanal gekoppelt ist + ('taskinfo (2) <RETURN>') und diese dann abmelden + ('break' oder 'end'). Die Nummer des Interfacekanals kann + mit dem Kommando 'put (interfacekanal) <RETURN>' + erfragt werden. + - Sehen Sie bitte die detaillierte Fehlerliste in Kapitel 5.5. + + +#on("b")#7.4 Menufunktionen zum Oberbegriff 'Programm'#off("b")# + + ++-------------------------------------------------------------------------+ +| PDV: Info Interface Programm Archiv | +|---------------------+---------------------+-----------------------------| +| | n Neu erstellen | | +| | a Ansehen/Ändern | | +| | | | +| | s Starten | | +| | w Wiederholen | | +| | | | +| | v Verzeichnis | | +| | | | +| | l Löschen | | +| | d Drucken | | +| | | | +| | k Kopieren | | +| | u Umbenennen | | +| +---------------------+ | +|-------------------------------------------------------------------------| +| Info:<ESC><?>/<?> Wahl:<Pfeile> Ausführen:<RETURN> Verlassen:<ESC><q> | ++-------------------------------------------------------------------------+ + +#center#Abb.29: Menubildschirm zum Oberbegriff 'Programm' +#page# +#on("b")#n Neu erstellen#off("b")# + + Mit dieser Funktion können Sie eine neue Programmdatei anlegen und be + schreiben. + + Sie werden zunächst nach einem Namen für die #on("b")#neue#off("b")# Programmdatei gefragt. + Geben Sie einen beliebigen Namen (#on("b")#ohne Anführungszeichen (!)#off("b")#) ein und + schließen Sie die Eingabe durch <RETURN> ab. Daraufhin wird Ihnen auf + dem Bildschirm eine neue Datei zum beschreiben angeboten. + + Sollte schon eine Programmdatei mit diesem Namen in der Task vorhanden + sein, so werden Sie darauf aufmerksam gemacht. + + Sie können sich während des Schreibens die wichtigsten Tastenfunktionen des + Editors einblenden lassen. Tippen Sie dazu die Tastenfolge <ESC><?>. Es + erscheint dann das folgende Angebot aus dem Sie auswählen können: + + + +------------------------------------------------+ + | Der EUMEL - Editor | + | | + | b ... Beschreibung desEditors | + | w ... Wichtige Tasten | + | p ... Positionieren der Schreibmarke | + | k ... Korrigieren im Text (Einfügen/Löschen) | + | m ... Markierte Textpassagen bearbeiten | + | l ... Lernen im Editor | + | a ... Anweisungen im Editor (Kommandodialog) | + | | + | z ... Zurück in den Schreibmodus | + | | + | b w p k m l a z | + | | + +------------------------------------------------+ + +#center#Abb.30: Informationsauswahl zum EUMEL-Editor +#page# + Fehlerfälle: + - Eine Datei mit dem vorgeschlagenen Namen existiert schon. + + +#on("b")#a Ansehen/Ändern#off("b")# + + Mit dieser Funktion können Sie sich Dateien, die schon in Ihrer Task + existieren, ansehen oder auch verändern. + + Sie werden zunächst gefragt, ob Sie #on("b")#die zuletzt bearbeitete Programmdatei#off("b")# + ansehen bzw. verändern möchten (sofern Sie schon vorher mit #on("b")#gs-Prozess#off("b")# in + der Task gearbeitet haben). + + Bejahen Sie diese Frage, dann wird Ihnen diese Programmdatei zur Be + arbeitung angeboten. Verneinen Sie die Frage dagegen, so gelangen Sie in die + 'Auswahl' (d.h es werden Ihnen alle Programmdateien in der Task zur Auswahl + angeboten). Nachdem Sie einen der Namen angekreuzt haben, wird Ihnen die + ausgewählte Programmdatei zur Bearbeitung auf dem Bildschirm angebo + ten. + + Fehlerfälle: + - In der Task existiert noch keine Programmdatei. + + +#on("b")#s Starten#off("b")# + + Mit dieser Menufunktion können Sie eine Programmdatei übersetzen und + ausführen lassen. + + Sie werden zunächst gefragt, ob #on("b")#das zuletzt bearbeitete Programm#off("b")# ausgeführt + werden soll. Bejahen Sie die Frage, so wird dieses Programm gestartet; ver + neinen Sie die Frage dagegen, so gelangen Sie in die 'Auswahl'. Nach An + kreuzen des gewünschten Programmnamens wird das ausgewählte Programm + ausgeführt. +#page# + Sind im Programm noch Fehler enthalten, so werden das Programm und die + Fehlermeldungen gleichzeitig auf dem Bildschirm dargestellt (Paralleleditor) + und zur Korrektur angeboten. Für die Programmkorrektur stehen ebenfalls alle + Editorfunktionen zur Verfügung. + + Sollte Ihnen beim Programmieren ein Fehler unterlaufen sein (z.B. eine + Endlosschleife), so kann mit der Tastenfolge <ESC><h> der Programmlauf + abgebrochen werden ("Notbremse"). + + +#on("b")##on("b")#w Wiederholen#off("b")# + + Mit dieser Funktion können Sie den Ablauf des zuletzt ausgeführten + Programms wiederholen, ohne daß das Programm neu übersetzt wird. + + Beachten Sie aber bitte, daß Veränderungen am Programmtext, die seit dem + letzten Prtogrammlauf vorgenommen wurden, #on("b")#nicht#off("b")# berücksichtigt werden; + dazu muß das Programm erneut mit der Menufunktion 's Starten' übersetzt + werden. + + Ist die Wiederholung eines Programmlaufs nicht möglich, so erfolgt ein Hin + weis darauf. + + +#on("b")#v Verzeichnis#off("b")# + + Mit dieser Funktion können Sie sich einen Überblick über die in Ihrer Task + vorhandenen Programmdateien verschaffen. + + Nach Aufruf dieser Funktion wird eine Liste der Programmdateien auf dem + Bildschirm ausgegeben, die sich in Ihrer Task befinden. Da die Liste selbst + eine Datei ist, kann Sie mit der Tastenkombination <ESC><q> verlassen + werden - hierauf wird auch in der Kopfzeile der Datei hingewiesen. Falls nicht + alle Namen auf den Bildschirm passen, können Sie das Fenster mit + <HOP><runter> und <HOP><hoch> verschieben. +#page# +#on("b")#l Löschen#off("b")# + + Mit dieser Funktion können Sie Programmdateien, die Sie nicht mehr + benötigen, die unnötig Platz belegen, löschen. Aber Vorsicht! Die Programm + dateien verschwinden durch diese Funktion unwiederbringlich! + + Nach Aufruf dieser Funktion werden Ihnen alle Programmdateien, die sich in + Ihrer Task befinden, zur Auswahl angeboten. Hier können Sie die gewünschten + Namen ankreuzen. Die Auswahl wird dann durch die Tastenfolge + <ESC><q> verlassen. + + Für jede einzelne Programmdatei wird noch einmal zur Sicherheit gefragt, ob + sie auch tatsächlich gelöscht werden soll. Zur Bestätigung tippen Sie bitte die + Taste <j> ('ja') - zur Verhinderung <n> ('nein'). + + Fehlerfälle: + - In der Task exsitiert noch keine Programmdatei. + + +#on("b")#d Drucken#off("b")# + + Mit dieser Funktion können Sie Programmdateien über einen angeschlossenen + Drucker ausgeben lassen. + + Nach Aufruf dieser Funktion werden Ihnen alle Programmdateien, die sich in + Ihrer Task befinden, zur Auswahl angeboten. Hier können Sie die gewünschten + Namen ankreuzen. Die Auswahl wird dann durch die Tastenfolge + <ESC><q> verlassen. + + Die angekreuzten Programmdateien werden anschließend zum Drucker ge + schickt. Der Vorgang wird auf dem Bildschirm protokolliert. +#page# + Fehlerfälle: + - In der Task existiert noch keine Programmdatei. + - Der Drucker ist nicht funktionsbereit. + - Der Drucker wird nicht über die Task 'PRINTER' betrieben. + - Auf Ihrem System werden die Druckkosten abgerechnet. Sie müssen sich + mit einer Codenummer identifizieren. + + +#on("b")#k Kopieren#off("b")# + + Mit dieser Funktion können Sie sich eine Kopie einer bereits in der Task + vorhandenen Programmdatei anlegen. Das ist z.B. dann sinnvoll, wenn Sie sich + einen bestimmten 'Stand' aufbewahren wollen oder wenn Sie ein Programm + schreiben wollen, das einem bereits vorhandenen ähnelt. + + Nach Aufruf dieser Funktion werden Ihnen alle Programmdateien, die sich in + Ihrer Task befinden, zur Auswahl angeboten. Nach Ankreuzen eines Namens + wird die Auswahl automatisch verlassen. + + Anschließend wird der angekreuzte Name angezeigt und der Name für die + Kopie erfragt. Es muß ein Name eingetragen werden, der in dieser Task noch + nicht für eine Programmdatei vergeben wurde; ansonsten erfolgt ein Hinweis + darauf und es wird nicht kopiert! + + Da man aber oft für die Kopie einen ähnlichen Namen wie für das Original + wählt, wird der 'alte' Name vorgeschlagen. Aus genannten Gründen muß er + aber verändert werden. Sie können diesen Namen mit den üblichen Editier + funktionen verändern oder mit <HOP><RUBOUT> löschen und ganz neu + eingeben. Sie sparen aber eine Menge Tipparbeit, wenn Sie einen langen + Namen nur an einer Stelle ändern wollen. + + Fehlerfälle: + - Eine Programmdatei mit dem gewünschten Namen existiert bereits in der + Task. +#page# +#on("b")#u Umbenennen#off("b")# + + Mit dieser Funktion können Sie einer bereits vorhandenen Programmdatei + einen neuen Namen geben. + + Nach Aufruf dieser Funktion werden Ihnen alle Programmdateien, die sich in + Ihrer Task befinden, zur Auswahl angeboten. Nach Ankreuzen eines Namens + wird die Auswahl automatisch verlassen. + + Anschließend wird dieser Name angezeigt und der zukünftige Name für die + Programmdatei erfragt. Es muß ein Name eingetragen werden, der in dieser + Task noch nicht für eine Programmdatei vergeben wurde - ansonsten erfolgt + ein Hinweis darauf und die Programmdatei wird nicht umbenannt! + + Da man aber oft den 'neuen' Namen in Anlehnung an den 'alten' Namen + wählt, wird der 'alte' Name vorgeschlagen. Aus genannten Gründen muß er + aber verändert werden. Sie können diesen Namen mit den üblichen Editier + funktionen verändern oder mit <HOP><RUBOUT> löschen und ganz neu + eingeben. Sie sparen aber eine Menge Tipparbeit, wenn Sie einen langen + Namen nur an einer Stelle ändern wollen. + + Fehlerfälle: + - Eine Programmdatei mit dem gewünschten Namen existiert bereits in der + Task. +#page# +#on("b")#7.5 Menufunktionen zum Oberbegriff 'Archiv'#off("b")# + + ++-----------------------------------------------------------------------+ +| PDV: Info Interface Programm Archiv | +|------------------+------------------------+---------------------------| +| | r Reservieren | | +| | - Neue Diskette | | +| | | | +| | - Schreiben | | +| | - Checken | | +| | - Kombination | | +| | - Holen/Lesen | | +| | - Löschen | | +| | | | +| | - Verzeichnis | | +| | - Drucken | | +| | | +---------------------+ | +| | i Initialisieren | | Dateiaustausch mit:| | +| | z Zieltask einstellen | | Archiv | | +| +------------------------+ | Archivname: | | +| | __________ | | +| +---------------------+ | +|-----------------------------------------------------------------------| +| Info:<ESC><?>/<?> Wahl:<Pfeile> Ausführen:<RETURN> Verlassen:<ESC><q> | ++-----------------------------------------------------------------------+ + +#center#Abb.31: Menubildschirm zum Oberbegriff 'Archiv' + + +In diesem Kapitel werden alle die Menufunktionen beschrieben, die Ihnen unter dem +Oberbegriff 'Archiv' im Menu angeboten werden. Mit den Funktionen in diesem Menu +können Sie aber nicht nur Dateien auf dem Archiv behandeln, sondern auch in +anderen Tasks im Multi-User-System oder über das EUMEL-Netz sogar auf anderen +Rechnern! + +Wenn Sie dieses Pull-Down-Menu gerade aufgeschlagen haben, sind nicht alle Funk +tionen aktivierbar! Um weitere Funktionen zu aktivieren, muß erst einer der aktivier +baren Menupunkte gewählt werden. +#page# +#on("b")#r Reservieren#off("b")# (des Archivlaufwerks) + + Im EUMEL-Multi-User-System haben normalerweise mehrere Personen das + Zugriffsrecht auf das Archivlaufwerk. Allerdings muß der Zugriff so geregelt + werden, daß sich die Beteiligten dabei nicht gegenseitig "in die Quere + kommen". Ein Zugriff auf das Archivlaufwerk erfordert zunächst eine An + meldung. Ist diese Anmeldung erfolgt, kann von den anderen Beteiligten so + lange nicht mehr auf das Laufwerk zugegriffen werden, bis es wieder freige + geben worden ist. + + Diese Anmeldung des Archivlaufwerkes erfolgt über die Menufunktion 'r Reser + vieren'. Greift bereits eine andere Task auf das Laufwerk zu, so erhalten Sie + darüber einen Hinweis auf dem Bildschirm. Ansonsten wird an Sie die Frage + gestellt, ob die Diskette eingelegt und das Laufwerk geschlossen ist. + + Erst zu diesem Zeitpunkt ist sichergestellt, daß Sie den alleinigen Zugriff auf + das Laufwerk haben. Deshalb sollten Sie, wenn Sie mit mehreren Personen am + Computer arbeiten, erst zum Zeitpunkt der Fragestellung die Diskette ins + Laufwerk einlegen. + + Nachdem Sie die Diskette eingelegt und die Frage bejaht haben, ermittelt das + System selbständig den Namen der eingelegten Diskette, zeigt den Namen auf + dem Bildschirm (im kleinen Kasten unten) an und aktiviert die anderen + Menupunkte des Pull-Down-Menus. + + Beim Verlassen des Pull-Down-Menus, wenn eine andere Zieltask eingestellt + wird oder wenn das Menu gänzlich verlassen wird, wird die Reservierung + automatisch aufgehoben! +#page# + Fehlerfälle: + - Das Laufwerk ist von einer anderen Task belegt. + - Die Diskette ist falsch eingelegt oder das Laufwerk ist nicht richtig ge + schlossen. + - Die Diskette ist nicht formatiert bzw. initialisiert. + - Die Diskette kann nicht gelesen werden (keine EUMEL-Diskette, Diskette + hat ein falsches Format, Diskette ist verschmutzt...). + + +#on("b")#n Neue Diskette#off("b")# (anmelden) + + Der Dateiaustausch mit einer Diskette ist nur dann möglich, wenn der im + System eingestellte Diskettenname (auf dem Bildschirm im kleinen Kasten + unten sichtbar) mit dem tatsächlichen Namen der Diskette übereinstimmt. + Nach einem Diskettenwechsel ist das aber in der Regel nicht mehr der Fall. + Greift man dann auf die neu eingelegte Diskette zu, so erscheint die Fehlermel + dung: 'Falscher Archivname! Bitte neue Diskette anmelden!'. + + Das Anmelden einer neuen Diskette - ohne einen neuen Reservierungsvorgang + - wird durch diese Menufunktion ermöglicht. Nach Aktivieren dieses Menu + punktes wird der Name der eingelegten Diskette ermittelt, im System eingestellt + und auf dem Bildschirm angezeigt. + + Im Gegensatz zur Menufunktion 'r Reservieren' greift das System ohne Anfrage + an den Benutzer auf das Archivlaufwerk zu (die Reservierung bleibt ja + bestehen). Ist das Archivlaufwerk reserviert, so ist die Neuanmeldung einer + Diskette über diese Menufunktion weniger zeitaufwendig. + + Fehlerfälle: + - wie unter 'r Reservieren'. +#page# +#on("b")#s Schreiben#off("b")# (Kopieren) + + Alle Dateien der eigenen Task werden zur Auswahl angeboten. Wenn Sie die + Auswahl durch die Tastenfolge <ESC><q> verlassen, überprüft das System + zunächst, ob die Dateien in der eingestellten Zieltask schon vorhanden sind. Ist + das der Fall, wird erfragt, ob die dort vorhandenen Dateien überschrieben, d.h. + gelöscht werden dürfen (s.u.). Anschließend werden alle angekreuzten Dateien + in der Reihenfolge, in der Sie sie angekreuzt haben, in die eingestellte Zieltask + kopiert. Der Vorgang wird auf dem Bildschirm protokolliert. Die Original + dateien in der eigenen Task bleiben dabei erhalten. + + Wenn in der Zieltask schon eine Datei existiert, die den gleichen Namen hat + wie eine Datei, die Sie dorthin kopieren möchten, so wird angefragt, ob die + vorher schon existierende Datei überschrieben (gelöscht!) werden soll. Bejahen + Sie diese Frage, so wird die bereits in der Zieltask existierende Datei (un + wiederbringlich) gelöscht und die gewünschte Datei dorthin transportiert. Ein + Überschreiben aus Versehen ist nicht möglich, wenn Sie die an Sie gestellte + Frage sorgfältig beantworten. + + Verneinen Sie die Frage, so wird die Datei auch nicht hinübertransportiert! Sie + können die Datei aber umbenennen (Menufunktion 'u Umbenennen' unter + den Oberbegriffen 'Landschaft'/Arbeitsfeld' bzw. 'Programm') und an + schließend mit anderem Namen hinüberschreiben. + + Beachten Sie, daß beim Überschreiben einer Datei auf einer Archivdiskette der + Speicherplatz der alten (überschriebenen) Version im allgemeinen nicht + wiederverwendet werden kann. In einem solchen Fall könnte die Diskette voll + geschrieben werden, obwohl eigentlich genügend Platz vorhanden wäre. Zur + Optimierung wird deshalb zuerst überprüft, ob die angekreuzten Dateien + schon in der Zieltask vorhanden sind und löscht diese, wenn Sie Ihr Einver + ständnis geben. Erst anschließend werden die Dateien insgesamt kopiert. +#page# + Normalerweise ist als Zieltask das Archivlaufwerk der eigenen Station einge + stellt. Mit der Menufunktion 'z Zieltask einstellen' kann diese Einstellung aber + verändert werden. + + Fehlerfälle: + - Die Diskette ist falsch eingelegt oder beschädigt. + - Die Diskette kann nicht beschrieben werden (Schreibfehler). + - Die Diskette ist voll. + - Sehen Sie auch unter 'r Reservieren' + 'z Zieltask einstellen'. + + +#on("b")#c Checken#off("b")# + + Diese Menufunktion kann nur ausgeführt werden, wenn der Dateiaustausch + mit einem Archiv(manager) erfolgt - ansonsten ist diese Menufunktion auch + nicht aktivierbar. Die Menufunktion dient dazu, auf Diskette geschriebene + Dateien auf Lesefehler hin zu prüfen. Es empfiehlt sich, diese Prüfroutine auf + neu auf die Diskette geschriebene Dateien anzuwenden. Sehen Sie dazu auch + 'k Kombination'. + + Alle Dateien der eingestellten Zieltask (Archiv) werden zur Auswahl angeboten. + Wenn Sie die Auswahl durch die Tastenfolge <ESC><q> verlassen, werden + alle angekreuzten Dateien in der Reihenfolge, in der Sie sie angekreuzt haben, + "gecheckt", d.h. auf Lesefehler hin überprüft. Der Vorgang wird auf dem Bild + schirm protokolliert. + + Fehlerfälle: + - Lesefehler auf dem Archiv. + - Sehen Sie auch unter 'r Reservieren'. + +#page# +#on("b")#k Kombination#off("b")# + + Diese Menufunktion ist eine Kombination aus den beiden Menufunktionen 's + Schreiben' und 'c Checken' (Sehen Sie weitere Informationen auch dort!). + + Alle Dateien der eigenen Task werden zur Auswahl angeboten. Wenn Sie die + Auswahl durch die Tastenfolge <ESC><q> verlassen, werden alle ange + kreuzten Dateien in der Reihenfolge, in der Sie sie angekreuzt haben, in die + eingestellte Zieltask kopiert (gegebenenfalls müssen bereits vorhandene + Dateien gleichen Namens in der Zieltask gelöscht werden). Anschließend + werden alle Dateien, die gerade geschrieben wurden, gecheckt, d.h. auf Lese + fehler hin untersucht. Beide Vorgänge werden auf dem Bildschirm + protokolliert. + + Da die 'Check' - Operation nur bei Archivmanagern zulässig ist, ist diese Menu + funktionen ebenfalls nur bei Archivmanagern aktivierbar. Zur Erläuterung + sehen Sie bitte auch unter 'z Zieltask einstellen'. + + +#on("b")#h Holen/Lesen#off("b")# + + Die Menufunktion dient dazu, Dateien, die bereits auf einer Archivdiskette oder + in einer anderen Task existieren, in die eigene Task zu kopieren. + + Alle Dateien der eingestellten Zieltask werden zur Auswahl angeboten. An + schließend werden Kopien der angekreuzten Dateien in der Reihenfolge des + Ankreuzens in die eigene Task geholt. Das Original in der Zieltask bleibt dabei + unverändert! Der Vorgang wird auf dem Bildschirm protokolliert. + + Sind in der eigenen Task schon Dateien mit gleichem Namen vorhanden, so + wird gefragt, ob die 'alten' Dateien überschrieben (gelöscht) werden dürfen. + Nur wenn Sie zustimmen, werden die in Ihrer Task existierenden Dateien + (unwiederbringlich!) gelöscht und Kopien der gleichnamigen Dateien aus der + Zieltask angefertigt. +#page# + Stimmen Sie dem Löschvorgang nicht zu, dann bleiben die bisherigen Dateien + in Ihrer Task erhalten - die Dateien aus der Zieltask werden dann aber auch + nicht in Ihre Task kopiert! Um dennoch die Kopien zu erhalten, können Sie die + namensgleichen Dateien in Ihrer Task umbenennen und dann erst die Dateien + aus der anderen Task anfordern. + + Normalerweise werden die Dateien vom Archiv der eigenen Station geholt. Mit + dem Menupunkt 'z Zieltask einstellen' kann diese Einstellung verändert + werden. + + Fehlerfälle: + - Lesefehler auf dem Archiv. + - Sehen Sie auch unter 'r Reservieren' + 's Schreiben' + 'z Zieltask einstellen'. + + +#on("b")#l Löschen#off("b")# + + Die Menufunktion dient dazu, Dateien in der Zieltask (unwiederbringlich!) zu + löschen. Dazu werden alle Dateien der eingestellten Zieltask zur Auswahl ange + boten. Anschließend werden die angekreuzten Dateien in der Reihenfolge ihres + Ankreuzens gelöscht. Zur Sicherheit muß noch einmal für jede einzelne Datei + bestätigt werden, daß sie auch tatsächlich gelöscht werden soll. + + Beachten Sie, daß beim Löschen einer Datei auf einer Archivdiskette der + Speicherplatz im allgemeinen nicht wieder verwendet werden kann. In einem + solchen Fall könnte die Diskette voll geschrieben werden, obwohl eigentlich + genügend Platz vorhanden wäre. Diese Probleme treten bei anderen Tasks, die + keine Archivmanager sind, nicht auf, da deren Speicherplatz intelligenter + verwaltet wird. +#page# + Normalerweise ist als Zieltask das Archiv der eigenen Station eingestellt. Mit + dem Menupunkt 'z Zieltask einstellen' kann diese Einstellung verändert + werden. + + Fehlerfälle: + - Sehen Sie auch unter 'r Reservieren' + 's Schreiben' + 'z Zieltask einstellen'. + + +#on("b")#v Verzeichnis#off("b")# + + Mit dieser Menufunktion können Sie sich einen Überblick über die in der + Zieltask (z.B. auf dem Archiv) vorhandenen Dateien verschaffen. + + Nach Aufruf der Funktion wird eine Liste der Dateien auf dem Bildschirm + ausgegeben, die sich in der Zieltask (z.B. auf dem Archiv) befinden. Ist die + Zieltask ein Archiv(manager), so wird auch angezeigt, wieviel Platz auf der + Diskette belegt ist. Da die Liste selbst eine Datei ist, kann sie mit der Tasten + kombination <ESC><q> verlassen werden. Falls nicht alle Dateinamen auf + den Bildschirm passen, können Sie das Fenster mit <HOP><hoch> und + <HOP><runter> verschieben. + + Fehlerfälle: + - Sehen Sie unter 'z Zieltask einstellen'. + + +#on("b")#d Drucken#off("b")# + + Das Verzeichnis der Dateien in der Zieltask, das man mit der Menufunktion 'v + Verzeichnis' auf dem Bildschirm angezeigt bekommt, kann mit dieser Menu + funktion ausgedruckt werden. +#page# + Zur Sicherheit wird angefragt, ob wirklich ein solches Dateiverzeichnis der + Zieltask gedruckt werden soll. Bejaht man die Frage, so wird ein Dateiver + zeichnis erstellt und zum Drucker geschickt. + + Fehlerfälle: + - Der Drucker ist nicht funktionsbereit. + - Der Drucker wird nicht über die Task 'PRINTER' betrieben. + - Auf Ihrem System werden die Druckkosten abgerechnet. Sie müssen sich + mit einer Codenummer identifizieren. + + +#on("b")#i Initialisieren#off("b")# + + Diese Menufunktion gestattet es, frische Disketten zu formatieren, zu + initialisieren bzw. beschriebene Disketten vollständig zu löschen und ggf. dabei + umzubenennen. Bei Aufruf dieser Menufunktion wird - sofern noch nicht + geschehen - das Archivlaufwerk automatisch reserviert. + + Wenn Sie eine fabrikneue Diskette aus der Verpackung nehmen, müssen Sie + diese zunächst #on("b")#formatieren#off("b")#. Dabei wird die Diskette auf ein festgelegtes + physikalisches Format eingestellt. Ohne daß diese Operation vorausgegangen + ist, kann eine Diskette weder beschrieben noch gelesen werden. + + Prinzipiell braucht eine Diskette nur ein einziges Mal formatiert zu werden. Sie + können Sie jedoch jederzeit wieder formatieren - z.B. wenn Sie Disketten ha + ben, von denen Sie nicht genau wissen, für welche Zwecke sie zuvor verwendet + wurden. + + Wenn Sie diese Menufunktion aktivieren, werden Sie so zunächst gefragt, ob Sie + die Diskette auch formatieren wollen. Bejahen Sie die Frage, so werden Ihnen + mehrere Formate zur Auswahl angeboten: +#page# + +----------------------------------+ + | Formatieren einer Diskette | + | | + | Dies sind die möglichen Formate: | + | | + | 1 .... 40 Spur - 360 KB | + | 2 .... 80 Spur - 720 KB | + | 3 .... 5 1/4" - 1,2 MB | + | 4 .... 3 1/2" - 1,4 MB | + | s .... Standard - Format | + | | + | | + | 1 2 3 4 s | + +----------------------------------+ + +#center#Abb.32: Auswahl der Archiv-Formate + + Erkundigen Sie sich bei Ihrem Händler, welches Format Sie bei Ihrem Rechner + und den von Ihnen verwendeten Disketten einstellen müssen. Manche Rechner + unterstützen diese Operation innerhalb des EUMEL-Systems auch gar nicht, + das Formatieren muß dann irgendwie anders außerhalb des EUMEL-Systems + geschehen. + + Wenn Sie die Formatierung abgeschlossen oder auch übersprungen haben, + beginnt die eigentliche Initialisierung der Diskette. Dabei wird als erstes der + Archivname auf die Diskette geschrieben. Alle alten Daten, die sich ggf. auf der + Diskette befinden, werden bei diesem Vorgang unwiederbringlich (!) gelöscht. + + Zur Sicherheit überprüft das System in jedem Falle, ob es sich um eine EUMEL + - Diskette handelt, und erfragt Ihr Einverständnis, ob die Diskette wirklich + initialisiert werden soll. Geben Sie hierzu Ihr Einverständnis, dann wird noch + der (neue) Archivname erfragt. Hatte die Diskette schon einen Namen, dann + wird dieser zum Überschreiben angeboten. Wollen Sie den alten Archivnamen + beibehalten, so brauchen Sie nur die <RETURN>-Taste zu tippen, ansonsten + können Sie den Namen auch zuvor verändern oder einen ganz neuen Namen + hinschreiben. Anhand des ausgegebenen Namens können Sie auch über + prüfen, ob Sie die richtige Diskette eingelegt haben. +#page# + Das Initialisieren funktioniert natürlich nur, wenn Sie als Zieltask einen + Archivmanager eingestellt haben - ansonsten ist diese Menufunktion gesperrt + (nicht aktivierbar!). + + Fehlerfälle: + - Formatieren ist nicht auf dem System möglich. + - Sehen Sie auch unter 'r Reservieren' + 'z Zieltask einstellen'. + + +#on("b")#z Zieltask einstellen#off("b")# + + Mit dieser Menufunktion können Sie festlegen, mit welcher Zieltask Sie + kommunizieren, d.h. z.B. Dateien austauschen möchten. Normalerweise ist hier + das Archiv am eigenen Rechner eingestellt. Das wird auch nach Aufklappen des + Pull-Down-Menus im Kasten unten angezeigt. + + Diese Menufunktion kann im Unterricht z.B. dazu genutzt werden, um fertig + gestellte Hausaufgaben in eine bestimmte Task zu schicken (Vatertask) oder um + von dort z.B. vorgefertigte Landschaften oder/und Programme abzuholen. + + Sie können aber auch eine andere Task einstellen (z.B. die Vatertask oder die + Task 'PUBLIC'), um mit diesen Dateien auszutauschen oder um sich auch nur + einen Überblick über die dort vorhandenen Dateien zu verschaffen. Wenn Sie + mit Ihrem Rechner in ein EUMEL-Netz integriert sind, können Sie auch auf + Tasks anderer Rechner zugreifen oder auch Disketten von Laufwerken anderer + Rechner einlesen (z.B. wenn Sie Disketten anderer Formate haben, die von + Ihrem Rechner nicht gelesen werden können). + + Dabei werden zwei Anforderungen an die Zieltask gestellt: Sie muß existieren + und bereit für den Dateiaustausch sein, d.h es muß eine Managertask sein, auf + die Sie Zugriff haben. Versuchen Sie auf andere Tasks zuzugreifen, so erhalten + Sie entsprechende (Fehler-)Meldungen. +#page# + Zu beachten ist noch, daß es im EUMEL-System verschiedene Arten von + Managertasks gibt - Archivmanager und normale Dateimanager. Der Unter + schied besteht darin, daß ein Archivmanager vom Benutzer vor dem Zugriff + reserviert werden muß - anschließend hat nur dieser Benutzer (bis zur Aufgabe + der Reservierung) ein Zugriffsrecht auf den Manager. Normale Dateimanager + können dagegen von mehreren Benutzern in beliebiger Reihenfolge ange + sprochen werden. + + Ein Archivmanager kann auch auf bestimmte Diskettenformate spezialisert sein + (z.B. auf das Lesen von DOS-Disketten). Manche Rechner haben auch mehrere + Archivmanager für verschiedene Laufwerke etc. Durch Einstellen unterschied + licher Archivmanager können Sie dann auf verschiedenen Laufwerken + archivieren. + + Nach Aktivieren dieses Menupunktes werden Ihnen die folgenden Alternativen + angeboten: + + + +-----------------------------------------+ + | Dateiaustausch gewünscht mit: | + | | + | a ... Archiv (Eigene Station) | + | | + | v ... Vatertask | + | | + | p ... 'PUBLIC' (Eigene Station) | + | | + | s ... Sonstige Task | + | | + | Archiv Vatertask PUBLIC Sonstige | + +-----------------------------------------+ + +#center#Abb.33: Auswahl der Zieltask + + Da der Dateiaustausch mit dem Standardarchiv der eigenen Station (Task: + 'ARCHIVE'), mit der Vatertask und der Task 'PUBLIC' recht häufig in Anspruch + genommen wird, sind diese drei Optionen unter den Alternativen direkt ange +#page# + geben. Entscheiden Sie sich für eine dieser drei Tasks, so nimmt das System + alle notwendigen Einstellungen vor. Möchten Sie dagegen in Kontakt mit einer + anderen Task treten, so wählen Sie die Alternative 's ... Sonstige Task'. In + diesem Falle haben Sie noch 3 Angaben zu machen: + + - Zunächst werden Sie nach dem Namen der Zieltask gefragt. Geben Sie den + Namen der Zieltask - ohne Anführungsstriche (!) - ein und schließen Sie + die Eingabe mit der <RETURN>-Taste ab. (Den ausgegebenen Namen der + z.Z. eingestellten Task können Sie dabei verändern bzw. überschreiben.) + + - Dann wird die Nummer der Station im EUMEL-Netz erfragt, auf der sich + die Zieltask befindet. Die Nummer Ihrer Station wird als Vorschlag ausge + geben. Wollen Sie mit einer Task auf Ihrem Rechner kommunizieren, so + brauchen Sie diesen Vorschlag nur durch Drücken der <RETURN>-Taste + bestätigen - ansonsten tragen Sie zuvor die entsprechende Stationsnummer + ein. Ist Ihr Rechner nicht in ein EUMEL-Netz integriert, so wird die + Stationsnummer 0 (Null) ausgegeben. Bitte bestätigen Sie diese Stations + nummer durch Tippen der <RETURN>-Taste. + + - Zum Abschluß müssen Sie noch angeben, ob die eingestellte Zieltask ein + Archivmanager ist oder nicht. + + Das System versucht dann den Kontakt herzustellen. Je nachdem, welche + Einstellung Sie vorgenommen haben, sind bestimmte Funktionen innerhalb + des Menus nicht aktivierbar. Das System läßt nur die Funktionen zu, die + aufgrund Ihrer Einstellungen zulässig sind. + + Im Kasten unten auf dem Bildschirm wird jeweils angezeigt, welche Zieltask + eingestellt ist. Erscheint in diesem Kasten auch ein Hinweis auf den Archiv + namen, so haben Sie einen Archivmanager eingestellt. Ist dagegen vor dem + Namen der Zieltask noch eine Zahl und ein Schrägstrich angegeben, so haben + Sie eine Zieltask auf einem anderen Rechner eingestellt. +#page# + Bedenken Sie, daß Operationen mit Tasks auf anderen Stationen länger an + dauern können - werden Sie nicht ungeduldig! + + Sie können die Einstellung der Zieltask jederzeit wieder verändern! + + Fehlerfälle: + - Die eingestellte Zieltask existiert nicht. + - Die eingestellte Zieltask existiert zwar, ist aber nicht empfangsbereit, d.h. + ein Zugriff von Ihrer Task aus ist nicht möglich! + - Das Netz ist nicht funktionsbereit (Collector-Task fehlt). + - Die Kommunikation war nicht erfolgreich. + - Die gewünschte Operation kann mit der eingestellten Zieltask nicht ausge + führt werden (Zieltask ist z.B. gar kein Archivmanager - Sie aber ver + suchen, das Laufwerk zu reservieren). + diff --git a/app/gs.process/1.02/doc/gs-prozess-8 b/app/gs.process/1.02/doc/gs-prozess-8 new file mode 100644 index 0000000..c36ccc9 --- /dev/null +++ b/app/gs.process/1.02/doc/gs-prozess-8 @@ -0,0 +1,377 @@ +limit (11.0)##pagelength (16.5)##block# +#start (2.0,0.0)# +#page (1)# +#headodd# +#center#gs-Prozess#right#% + +#end# +#headeven# +%#center#gs-Prozess + +#end# +#center#1 + +#on("b")#8 Detailbeschreibung der Basisbefehle und Tests#off("b")# + + +#on("b")# +BOOL PROC abbruch gewuenscht +#off("b")# + + - erfragt, ob inzwischen durch einen Basisbefehl die Tastenfolge <ESC><q> + im Eingabestrom registriert worden ist. Ist das der Fall, liefert die Prozedur + den Wert 'TRUE', sonst 'FALSE'. + + +#on("b")# +BOOL PROC bit ist gesetzt (INT CONST kanal, bitnummer) +#off("b")# + + - untersucht, ob inzwischen die Tastenfolge <ESC><h> eingegeben wurde. + Ist das der Fall, dann erfolgt ein Abbruch mit der Fehlermeldung + "Programm-Abbruch durch <ESC><h>!". + - registriert, ob inzwischen die Tastenfolge <ESC><q> eingegeben wurde. + - untersucht, ob die angegebene Kanalnummer grundsätzlich zulässig ist (1 #on("b")#<#off("b")# + 'kanal' #on("b")#<#off("b")# 49). Ist das nicht der Fall, erfolgt ein Abbruch mit der Fehler + meldung "Kanalnummer ... ist unzulässig!". + - untersucht, ob am angegebenen Kanal laut Konfiguration eine digitale Ein + gabe möglich ist. Ist das nicht der Fall, erfolgt ein Abbruch mit der Fehler + meldung "An Kanal ... ist keine Digital-Eingabe möglich!". + - untersucht, ob die angegebene Bitnummer zulässig ist (0 #on("b")#<#off("b")# 'bitnummer' #on("b")#<#off("b")# + 7). Ist das nicht der Fall, erfolgt ein Abbruch mit der Fehlermeldung "Bit + nummer ... ist nicht zulässig!". + - liest den aktuell anliegenden Wert am angegebenen Kanal. + - liefert den Wert 'TRUE', wenn in der binären Darstellung das Bit mit der + angegebenen Bitnummer gesetzt ist ("I"), sonst den Wert 'FALSE'. + +#on("b")# +TEXT PROC bitmuster (INT CONST kanal) +#off("b")# + + - untersucht, ob inzwischen die Tastenfolge <ESC><h> eingegeben wurde. + Ist das der Fall, dann erfolgt ein Abbruch mit der Fehlermeldung + "Programm-Abbruch durch <ESC><h>!". +#page# + - registriert, ob inzwischen die Tastenfolge <ESC><q> eingegeben wurde. + - untersucht, ob die angegebene Kanalnummer grundsätzlich zulässig ist (1 #on("b")#<#off("b")# + 'kanal' #on("b")#<#off("b")# 49). Ist das nicht der Fall, erfolgt ein Abbruch mit der Fehler + meldung "Kanalnummer ... ist unzulässig!". + - untersucht, ob am angegebenen Kanal laut Konfiguration eine digitale Ein + gabe möglich ist. Ist das nicht der Fall, erfolgt ein Abbruch mit der Fehler + meldung "An Kanal ... ist keine Digital-Eingabe möglich!". + - liest den aktuell anliegenden Wert am angegebenen Kanal ein und wandelt + ihn in die binäre Darstellung. + - liefert einen Text der Länge 8, bestehend aus den Zeichen "I" und/oder "O". + + +#on("b")# +PROC bitmuster ausgeben (INT CONST kanal, + TEXT CONST bitmuster) +#off("b")# + + - untersucht, ob inzwischen die Tastenfolge <ESC><h> eingegeben wurde. + Ist das der Fall, dann erfolgt ein Abbruch mit der Fehlermeldung + "Programm-Abbruch durch <ESC><h>!". + - registriert, ob inzwischen die Tastenfolge <ESC><q> eingegeben wurde. + - untersucht, ob die angegebene Kanalnummer grundsätzlich zulässig ist (1 #on("b")#<#off("b")# + 'kanal' #on("b")#<#off("b")# 49). Ist das nicht der Fall, erfolgt ein Abbruch mit der Fehler + meldung "Kanalnummer ... ist unzulässig!". + - untersucht, ob am angegebenen Kanal laut Konfiguration eine digitale Aus + gabe möglich ist. Ist das nicht der Fall, erfolgt ein Abbruch mit der Fehler + meldung "An Kanal ... ist keine Digital-Ausgabe möglich!". + - untersucht die übergebene Zeichenkette (bitmuster) auf korrekte Länge (8 + Zeichen). Ist das nicht der Fall, erfolgt ein Abbruch mit der Fehlermeldung + "Das Bitmuster ... hat eine unzulässige Länge!". + - überprüft die in der übergebenen Zeichenkette (bitmuster) vorkommenden + Symbole auf ihre Zulässigkeit ("I", "O", "X", "T"). Taucht ein unzulässiges + Symbol auf, erfolgt ein Abbruch mit der Fehlermeldung "... ist ein unzu + lässiges Bitsymbol in ...!". +#page# + - aus dem am angegebenen Kanal zuletzt ausgegeben Wert und der über + gebenen Zeichenkette (bitmuster) wird der auszugebende Dezimalwert er + mittelt. Dieser Dezimalwert wird am angegebenen Kanal ausgegeben. Dabei + bedeuten "I", daß das betreffende Bit gesetzt wird, "O", daß das betreffende + Bit nicht gesetzt wird, "X", daß das betreffende Bit gegenüber der zuvor + erfolgten Ausgabe am gleichen Kanal nicht verändert wird und "T", daß das + betreffende Bit gegenüber der zuvor erfolgten Ausgabe am gleichen Kanal + invertiert wird. + + +#on("b")# +BOOL PROC bitmuster gleich (INT CONST kanal, + TEXT CONST vergleichsmuster) +#off("b")# + + - untersucht, ob inzwischen die Tastenfolge <ESC><h> eingegeben wurde. + Ist das der Fall, dann erfolgt ein Abbruch mit der Fehlermeldung + "Programm-Abbruch durch <ESC><h>!". + - registriert, ob inzwischen die Tastenfolge <ESC><q> eingegeben wurde. + - untersucht, ob die angegebene Kanalnummer grundsätzlich zulässig ist (1 #on("b")#<#off("b")# + 'kanal' #on("b")#<#off("b")# 49). Ist das nicht der Fall, erfolgt ein Abbruch mit der Fehler + meldung "Kanalnummer ... ist unzulässig!". + - untersucht, ob am angegebenen Kanal laut Konfiguration eine digitale Ein + gabe möglich ist. Ist das nicht der Fall, erfolgt ein Abbruch mit der Fehler + meldung "An Kanal ... ist keine Digital-Eingabe möglich!". + - untersucht die übergebene Zeichenkette (bitmuster) auf korrekte Länge (8 + Zeichen). Ist das nicht der Fall, erfolgt ein Abbruch mit der Fehlermeldung + "Das Bitmuster ... hat eine unzulässige Länge!". + - überprüft die im 'vergleichsmuster' vorkommenden Symbole auf ihre Zu + lässigkeit ("I", "O", "X"). Taucht ein unzulässiges Symbol auf, erfolgt ein + Abbruch mit der Fehlermeldung "... ist ein unzulässiges Bitsymbol in ...!". + - liest den aktuell anliegenden Wert am angegebenen Kanal ein und wandelt + ihn in die binäre Darstellung. + - überprüft, ob das eingelesene Bitmuster zum 'vergleichsmuster' "paßt". Ist + das der Fall, wird der Wert 'TRUE' geliefert, sonst der Wert 'FALSE'. +#page# +#on("b")# +TEXT PROC bitsymbol (INT CONST kanal, bitnummer) +#off("b")# + + - untersucht, ob inzwischen die Tastenfolge <ESC><h> eingegeben wurde. + Ist das der Fall, dann erfolgt ein Abbruch mit der Fehlermeldung + "Programm-Abbruch durch <ESC><h>!". + - registriert, ob inzwischen die Tastenfolge <ESC><q> eingegeben wurde. + - untersucht, ob die angegebene Kanalnummer grundsätzlich zulässig ist (1 #on("b")#<#off("b")# + 'kanal' #on("b")#<#off("b")# 49). Ist das nicht der Fall, erfolgt ein Abbruch mit der Fehler + meldung "Kanalnummer ... ist unzulässig!". + - untersucht, ob am angegebenen Kanal laut Konfiguration eine digitale Ein + gabe möglich ist. Ist das nicht der Fall, erfolgt ein Abbruch mit der Fehler + meldung "An Kanal ... ist keine Digital-Eingabe möglich!". + - untersucht, ob die angegebene Bitnummer zulässig ist (0 #on("b")#<#off("b")# 'bitnummer' #on("b")#<#off("b")# + 7). Ist das nicht der Fall, erfolgt ein Abbruch mit der Fehlermeldung "Bit + nummer ... ist nicht zulässig!". + - liest den aktuell anliegenden Wert am angegebenen Kanal ein und wandelt + ihn in die binäre Darstellung. + - liefert einen Text der Länge 1, nämlich "I" oder "O". + + +#on("b")# +PROC bitsymbol ausgeben (INT CONST kanalnummer, bitnummer, + TEXT CONST bitsymbol) +#off("b")# + + - untersucht, ob inzwischen die Tastenfolge <ESC><h> eingegeben wurde. + Ist das der Fall, dann erfolgt ein Abbruch mit der Fehlermeldung + "Programm-Abbruch durch <ESC><h>!". + - registriert, ob inzwischen die Tastenfolge <ESC><q> eingegeben wurde. + - untersucht, ob die angegebene Kanalnummer grundsätzlich zulässig ist (1 #on("b")#<#off("b")# + 'kanal' #on("b")#<#off("b")# 49). Ist das nicht der Fall, erfolgt ein Abbruch mit der Fehler + meldung "Kanalnummer ... ist unzulässig!". + - untersucht, ob am angegebenen Kanal laut Konfiguration eine digitale Aus + gabe möglich ist. Ist das nicht der Fall, erfolgt ein Abbruch mit der Fehler + meldung "An Kanal ... ist keine Digital-Ausgabe möglich!". +#page# + - untersucht, ob die angegebene Bitnummer zulässig ist (0 #on("b")#<#off("b")# 'bitnummer' #on("b")#<#off("b")# + 7). Ist das nicht der Fall, erfolgt ein Abbruch mit der Fehlermeldung "Bit + nummer ... ist nicht zulässig!". + - überprüft das übergebene Bitsymbol auf Zulässigkeit ("I", "O", "X", "T"). + Taucht ein unzulässiges Symbol auf oder besteht das Bitsymbol aus mehr als + einem Zeichen, erfolgt ein Abbruch mit der Fehlermeldung "... ist ein unzu + lässiges Bitsymbol!". + - ermittelt aus dem am angegebenen Kanal zuletzt ausgegeben Wert und der + übergebenen Bitnummer/dem übergebenen Bitsymbol den auszugebende + Dezimalwert. Dieser Dezimalwert wird am angegebenen Kanal ausgegeben. + Dabei bedeuten "I", daß das betreffende Bit gesetzt wird, "O", daß das be + treffende Bit nicht gesetzt wird, "X", daß das betreffende Bit gegenüber der + zuvor erfolgten Ausgabe am gleichen Kanal nicht verändert wird und "T", daß + das betreffende Bit gegenüber der zuvor erfolgten Ausgabe am gleichen Kanal + invertiert wird. + + +#on("b")# +INT PROC dezimalwert (INT CONST kanal) +#off("b")# + + - untersucht, ob inzwischen die Tastenfolge <ESC><h> eingegeben wurde. + Ist das der Fall, dann erfolgt ein Abbruch mit der Fehlermeldung + "Programm-Abbruch durch <ESC><h>!". + - registriert, ob inzwischen die Tastenfolge <ESC><q> eingegeben wurde. + - untersucht, ob die angegebene Kanalnummer grundsätzlich zulässig ist (1 #on("b")#<#off("b")# + 'kanal' #on("b")#<#off("b")# 49). Ist das nicht der Fall, erfolgt ein Abbruch mit der Fehler + meldung "Kanalnummer ... ist unzulässig!". + - untersucht, ob am angegebenen Kanal laut Konfiguration eine digitale Ein + gabe möglich ist. Ist das nicht der Fall, erfolgt ein Abbruch mit der Fehler + meldung "An Kanal ... ist keine Digital-Eingabe möglich!". + - liest den aktuell anliegenden Wert am angegebenen Kanal ein. + - liefert einen INT-Wert mit 0 #on("b")#<#off("b")# 'wert' #on("b")#<#off("b")# 255. +#page# +#on("b")# +PROC dezimalwert ausgeben (INT CONST kanal, wert) +#off("b")# + + - untersucht, ob inzwischen die Tastenfolge <ESC><h> eingegeben wurde. + Ist das der Fall, dann erfolgt ein Abbruch mit der Fehlermeldung + "Programm-Abbruch durch <ESC><h>!". + - registriert, ob inzwischen die Tastenfolge <ESC><q> eingegeben wurde. + - untersucht, ob die angegebene Kanalnummer grundsätzlich zulässig ist (1 #on("b")#<#off("b")# + 'kanal' #on("b")#<#off("b")# 49). Ist das nicht der Fall, erfolgt ein Abbruch mit der Fehler + meldung "Kanalnummer ... ist unzulässig!". + - untersucht, ob am angegebenen Kanal laut Konfiguration eine digitale Aus + gabe möglich ist. Ist das nicht der Fall, erfolgt ein Abbruch mit der Fehler + meldung "An Kanal ... ist keine Digital-Ausgabe möglich!". + - ermittelt den auszugebenden Wert durch die Rechnung +#on("b")# +#center#ausgabe = wert MOD 256, +#off("b")# + und gibt diesen am angegebenen Kanal aus. + + +#on("b")# +PROC initialisiere interface +#off("b")# + + - untersucht, ob inzwischen die Tastenfolge <ESC><h> eingegeben wurde. + Ist das der Fall, dann erfolgt ein Abbruch mit der Fehlermeldung + "Programm-Abbruch durch <ESC><h>!". + - registriert, ob inzwischen die Tastenfolge <ESC><q> eingegeben wurde. + - untersucht, ob das Programm korrekt (mit 'run pdv') gestartet wurde. Ist das + nicht der Fall, erfolgt ein Abbruch mit der Fehlermeldung "PDV-Programme + müssen mit 'run pdv' gestartet werden!". Dieser Fehler kann nicht auftreten, + wenn die Programme vom #on("b")#gs-Prozess#off("b")#-Menu gestartet werden! + - An jeden Digitalausgang des angeschlossenen Interface-Systems wird der Wert + '0', an jeden Analogausgang eine "Nullspannung" angelegt (d.h. alles wird + "ausgeschaltet"). Die internen Variablen werden dabei initialisiert. +#page# +#on("b")# +PROC spannungswert (INT CONST kanal) +#off("b")# + + - untersucht, ob inzwischen die Tastenfolge <ESC><h> eingegeben wurde. + Ist das der Fall, dann erfolgt ein Abbruch mit der Fehlermeldung + "Programm-Abbruch durch <ESC><h>!". + - registriert, ob inzwischen die Tastenfolge <ESC><q> eingegeben wurde. + - untersucht, ob die angegebene Kanalnummer grundsätzlich zulässig ist (1 #on("b")#<#off("b")# + 'kanal' #on("b")#<#off("b")# 49). Ist das nicht der Fall, erfolgt ein Abbruch mit der Fehler + meldung "Kanalnummer ... ist unzulässig!". + - untersucht, ob am angegebenen Kanal laut Konfiguration eine analoge Ein + gabe möglich ist. Ist das nicht der Fall, erfolgt ein Abbruch mit der Fehler + meldung "An Kanal ... ist keine Analog-Eingabe möglich!". + - ermittelt die laut Konfiguration aktuelle Obergrenze (u max) und Untergrenze + (u min) des Spannungsbereiches am angegebenen Analogeingang. + - liest den aktuell anliegenden Wert (0 #on("b")#<#off("b")# 'wert' #on("b")#<#off("b")# 255) am angegebenen + Kanal ein und wandelt ihn nach folgender Rechnung: + +#on("b")# + real(wert) * (u max - u min) + lieferwert = ---------------------------- + u min + 255.0 + +#off("b")# + - liefert einen REAL-Wert mit u min #on("b")#<#off("b")# 'lieferwert' #on("b")#<#off("b")# u max, gerundet auf drei + Nachkommastellen. + + +#on("b")# +PROC spannungswert ausgeben (INT CONST kanal, + REAL CONST spannung) +#off("b")# + + - untersucht, ob inzwischen die Tastenfolge <ESC><h> eingegeben wurde. + Ist das der Fall, dann erfolgt ein Abbruch mit der Fehlermeldung + "Programm-Abbruch durch <ESC><h>!". + - registriert, ob inzwischen die Tastenfolge <ESC><q> eingegeben wurde. + - untersucht, ob die angegebene Kanalnummer grundsätzlich zulässig ist (1 #on("b")#<#off("b")# + 'kanal' #on("b")#<#off("b")# 49). Ist das nicht der Fall, erfolgt ein Abbruch mit der Fehler + meldung "Kanalnummer ... ist unzulässig!". +#page# + - untersucht, ob am angegebenen Kanal laut Konfiguration eine analoge Aus + gabe möglich ist. Ist das nicht der Fall, erfolgt ein Abbruch mit der Fehler + meldung "An Kanal ... ist keine Analog-Ausgabe möglich!". + - ermittelt die laut Konfiguration aktuelle Obergrenze (u max) und Untergrenze + (u min) des Spannungsbereiches am angegebenen Analogausgang und prüft, + ob u min #on("b")#<#off("b")# 'spannung' #on("b")#<#off("b")# u max. Ist das nicht der Fall, erfolgt ein Abbruch + mit der Fehlermeldung 'Der Spannungswert ... ist nicht zulässig!". + - wandelt die angegebene 'spannung' nach der Rechnung: + +#on("b")# + (wert - u min) * 255.0 + ausgabewert = int ( ---------------------- + 0.5 ) + u max - u min + +#off("b")# + - gibt den ermittelten 'ausgabewert' am angegebenen Kanal aus. + + +#on("b")# +REAL PROC temperatur (REAL CONST spannungswert) +#off("b")# + + - errechnet aus dem Spannungswert, der vom Temperaturfühler eingelesen + wurde, der Thermometerkonstanten und der Minimaltemperatur die + Temperatur in �C. + - liefert einen REAL-Wert (die Temperatur in �C). + So nur anwendbar auf den Temperaturfühler der Fa. AKTRONIK! + + +#on("b")# +PROC tue nichts +#off("b")# + + - untersucht, ob inzwischen die Tastenfolge <ESC><h> eingegeben wurde. + Ist das der Fall, dann erfolgt ein Abbruch mit der Fehlermeldung + "Programm-Abbruch durch <ESC><h>!". + - registriert, ob inzwischen die Tastenfolge <ESC><q> eingegeben wurde. +#page# +#on("b")# +PROC warte (INT CONST sekunden) +#off("b")# + + - untersucht, ob inzwischen die Tastenfolge <ESC><h> eingegeben wurde. + Ist das der Fall, dann erfolgt ein Abbruch mit der Fehlermeldung + "Programm-Abbruch durch <ESC><h>!". + - registriert, ob inzwischen die Tastenfolge <ESC><q> eingegeben wurde. + - wirkt sonst wie 'pause (sekunden * 10)'. + + +#on("b")# +PROC warte (REAL CONST sekunden) +#off("b")# + + - untersucht, ob inzwischen die Tastenfolge <ESC><h> eingegeben wurde. + Ist das der Fall, dann erfolgt ein Abbruch mit der Fehlermeldung + "Programm-Abbruch durch <ESC><h>!". + - registriert, ob inzwischen die Tastenfolge <ESC><q> eingegeben wurde. + - wirkt sonst wie 'pause (int (sekunden * 10.0 + 0.5))'. + + +#on("b")# +PROC wert an analogausgang ausgeben (INT CONST kanal, wert) +#off("b")# + + - untersucht, ob inzwischen die Tastenfolge <ESC><h> eingegeben wurde. + Ist das der Fall, dann erfolgt ein Abbruch mit der Fehlermeldung + "Programm-Abbruch durch <ESC><h>!". + - registriert, ob inzwischen die Tastenfolge <ESC><q> eingegeben wurde. + - untersucht, ob die angegebene Kanalnummer grundsätzlich zulässig ist (1 #on("b")#<#off("b")# + 'kanal' #on("b")#<#off("b")# 49). Ist das nicht der Fall, erfolgt ein Abbruch mit der Fehler + meldung "Kanalnummer ... ist unzulässig!". + - untersucht, ob am angegebenen Kanal laut Konfiguration eine analoge Aus + gabe möglich ist. Ist das nicht der Fall, erfolgt ein Abbruch mit der Fehler + meldung "An Kanal ... ist keine Analog-Ausgabe möglich!". + - ermittelt den auszugebenden Wert durch die Rechnung + +#on("b")# +#center#ausgabe = wert MOD 256, + +#off("b")# + und gibt diesen Wert am angegebenen Kanal aus. Die am Analogausgang + auszugebende Spannung wird vom D/A-Wandler des Interface-Systems er + mittelt. +#page# +#on("b")# +INT PROC wert von analogeingang (INT CONST kanal) +#off("b")# + + - untersucht, ob inzwischen die Tastenfolge <ESC><h> eingegeben wurde. + Ist das der Fall, dann erfolgt ein Abbruch mit der Fehlermeldung + "Programm-Abbruch durch <ESC><h>!". + - registriert, ob inzwischen die Tastenfolge <ESC><q> eingegeben wurde. + - untersucht, ob die angegebene Kanalnummer grundsätzlich zulässig ist (1 #on("b")#<#off("b")# + 'kanal' #on("b")#<#off("b")# 49). Ist das nicht der Fall, erfolgt ein Abbruch mit der Fehler + meldung "Kanalnummer ... ist unzulässig!". + - untersucht, ob am angegebenen Kanal laut Konfiguration eine analoge Ein + gabe möglich ist. Ist das nicht der Fall, erfolgt ein Abbruch mit der Fehler + meldung "An Kanal ... ist keine Analog-Eingabe möglich!". + - liefert den vom A/D-Wandler des Interface-Systems gelieferten Wert mit 0 #on("b")#<#off("b")# + 'lieferwert' #on("b")#<#off("b")# 255. + diff --git a/app/gs.process/1.02/doc/gs-prozess-9 b/app/gs.process/1.02/doc/gs-prozess-9 new file mode 100644 index 0000000..6551b01 --- /dev/null +++ b/app/gs.process/1.02/doc/gs-prozess-9 @@ -0,0 +1,477 @@ +limit (11.0)##pagelength (16.5)##block# +#start (2.0,0.0)# +#page (1)# +#headodd# +#center#gs-Prozess#right#% + +#end# +#headeven# +%#center#gs-Prozess + +#end# +#center#1 + +#on("b")#9 Hinweise für den Systembetreuer/ Programmierer#off("b")# + +Sie haben wahrscheinlich bisher - ausschließlich zu Testzwecken - mit nur einem +Interface-System gearbeitet. In diesem Kapitel möchten wir Ihnen Vorschläge +machen, wie Sie Ihr Tasksystem organisieren können, um möglichst effektiv und +störungsfrei mit der vorhandenen Hardware zu arbeiten. + +Neben den Möglichkeiten der Organisation des Systems werden wir Ihnen zeigen, wie +Sie eine einmal vorgenommene Konfiguration/Organisation "fixieren", d.h. schützen +können. + +Im letzten Teil dieses Kapitels werden wir für den #on("b")#routinierten(!) Programmierer#off("b")#, +Möglichkeiten aufzeigen, wie man, unter weitgehender Umgehung von #on("b")#gs-Prozess#off("b")#, +Programme für spezielle Anwendungen entwickeln kann. Schon an dieser Stelle sei +ausdrücklich gesagt, daß dabei alle "Sicherheiten", die #on("b")#gs-Prozess#off("b")# normalerweise +bietet, nicht (mehr) vorhanden sind. + + +#on("b")#9.1 Vergabe der Kanäle/Organisation des Tasksystems#off("b")# + +Zur optimalen Organisation Ihres Systems sollten Sie wissen, in welcher Task die +Konfiguration sinnvollerweise vorzunehmen ist. Da die Aspekte sehr vielfältig sind, +werden wir verschiedene Situationen beschreiben. Lesen Sie die Ausführungen zu der +Situation, die der Ihren am ehesten entspricht. + + +#on("b")# +1) Es stehen mehrere MUFIs als Adapter zur Verfügung. Alle MUFIs sollen + im Terminalkanal betrieben werden. Die Arbeitsplätze sind alle mit + dem gleichen Interfacesystem ausgestattet. +#off("b")# +#page# + Sie sind hervorragend ausgestattet. Die Organisation und Konfiguration des + Systems ist sehr einfach: + + Es ist sinnvoll, die Konfiguration von #on("b")#gs-Prozess#off("b")# in der Task vorzunehmen, in + der Sie #on("b")#gs-Prozess#off("b")# installiert haben. Das hat den Vorteil, daß alle Sohntasks, + die sich anschließend anmelden, diese Konfiguration "erben". + + Bei dieser Ausstattung ist es sinnvoll die Konfiguration zu "fixieren", um irrtüm + lichen oder "böswilligen" Umkonfigurationen vorzubeugen. Sehen Sie dazu + Kapitel 9.4. + + +#on("b")# +2) Es stehen mehrere MUFIs als Adapter zur Verfügung. Alle MUFIs sollen + im Terminalkanal betrieben werden. Die Arbeitsplätze sind aber mit + verschiedenen Interface-Systemen ausgestattet. +#off("b")# + + Wenn die Bestückung der einzelnen Arbeitsplätze ständig wechselt, ist es nicht + sinnvoll, eine generelle Konfiguration vorzugeben. Teilen Sie jedem Anwender + mit, daß er selbst für die Konfiguration seines Systems zuständig ist. Er sollte bei + jedem Neuankoppeln seiner Task zumindest die Konfiguration überprüfen und + ggf. den Vorgaben entsprechend eine Anpassung vornehmen. Es ist nicht sinn + voll, die jeweilige Konfiguration zu fixieren. + + Wenn Sie zwar unterschiedliche Interface-Systeme verwenden, aber die Inter + face-Systeme einzelnen MUFIs eindeutig zuordnen können, lohnt es sich schon, + eine Konfiguration des Systems vorzugeben. + + Richten Sie zu diesem Zwecke so viele Tasks ein, wie Sie unterschiedliche + Interface-Systeme zur Verfügung haben, und ordnen Sie jedem Interface-System + eindeutig je eine Task zu. Die Namen der Tasks sollten Sie so wählen, daß sofort + ersichtlich ist, welchem Interface-System sie zugeordnet ist. + + Nehmen Sie in jeder Task eine Konfiguration von #on("b")#gs-Prozess#off("b")# entsprechend + dem zugeordneten Interface-System vor. +#page# + Auch hier ist es sinnvoll, die vorgenommenen Konfigurationen zu "fixieren", um + irrtümlichen oder "böswilligen" Umkonfigurationen vorzubeugen. Sehen Sie + dazu Kapitel 9.4. + + Die Anwender sollten sich später jeweils als Sohntask der Task anmelden, die + sich dem an ihrem Arbeitsplatz vorhandenen Interface-System eindeutig zu + ordnen läßt. + + +#on("b")# +3) Es steht nur ein MUFI als Adapter zur Verfügung. Das MUFI soll im + Terminalkanal betrieben werden. +#off("b")# + + Je nachdem, ob Sie eine feste Hardware am MUFI betreiben oder nicht, sollten + Sie sich an den beiden zuvor beschriebenen Fällen orientieren. + + +#on("b")# +4) Es steht nur ein RS232-Adapter oder ein MUFI, das als Endgerät an + einer separaten Schnittstelle betrieben werden soll, zur Verfügung. Es + soll nur von einem Arbeitsplatz/einer Task aus mit dem angeschlos + senen Interface-System gearbeitet werden. +#off("b")# + + Nehmen Sie die Installation/Konfiguration wie unter 5) beschrieben vor. + Arbeiten Sie nur in der Task, in der Sie die Konfiguration vorgenommen haben. + + +#on("b")# +5) Es steht nur ein Adapter zur Verfügung. Sie wollen aber die Möglichkeit + schaffen, daß von verschiedenen Tasks abwechselnd darauf zugegriffen + werden kann. +#off("b")# + + Es ist gleichgültig, ob Sie ein MUFI oder einen RS232-Adapter verwenden - sie + sollten den Adapter an einer separaten seriellen Schnittstelle betreiben. +#page# + Auch wenn Sie ein MUFI besitzen, kann es vorteilhaft sein, das MUFI nicht im + Terminalkanal, sondern an einer separaten Schnittstelle zu betreiben: + + Beim Betrieb im Terminalkanal kann nämlich nur die Task mit dem MUFI + kommunizieren, die an das Terminal gekoppelt ist, in dessen Zuleitung das + MUFI eingebaut ist. Das wird hier zum Nachteil, denn wenn eine andere Task + auf das Interface-System zugreifen möchte, muß erst die alte Task abgekoppelt + und die neue an das Terminal mit dem MUFI angekoppelt werden. + + Der Betrieb an einer separaten Schnittstelle bietet hier wahrscheinlich viel + fältigere Möglichkeiten, wenngleich Sie dadurch auch Geschwindigkeitsein + bußen hinnehmen müssen. + + #on("b")#gs-Prozess#off("b")# bietet Ihnen bei Betrieb eines Adapters an einer separaten seriellen + Schnittstelle nämlich die Möglichkeit, abwechselnd von verschiedenen Tasks auf + den Adapter und das angeschlossene Interface-System zugreifen zu können. + + Teilen Sie bei der Installation (automatischen Generierung) von #on("b")#gs-Prozess#off("b")# + dem System gleich mit, daß Sie Ihren Adapter (ob nun MUFI oder + RS232-Adapter) an einer separaten seriellen Schnittstelle betreiben wollen. + Schon bei dieser Installation werden Sie nach der Kanalnummer gefragt. + + Wir gehen hier davon aus, daß Sie immer mit dem gleichen Interface-System an + diesem Adapter arbeiten werden. In diesem Falle empfiehlt es sich, gleich in der + Task, in der Sie die Installation vorgenommen haben, auch die Konfiguration + von #on("b")#gs-Prozess#off("b")# vorzunehmen und die Konfiguration zu "fixieren". Durch die + Konfiguration in dieser Task, "erben" alle Sohntasks, die anschließend ange + meldet werden, diese Konfiguration. + + Wenn Sie sich mit 'taskinfo <RETURN>' einen Katalog ausgeben lassen, + werden Sie feststellen, daß eine weitere Task als unbenannter Sohn ("-") Ihrer + Task eingerichtet worden ist. Sie haben nämlich Ihre Task zu einer "zentralen + Abwicklungstask" gemacht - genauer gesagt die unbenannte Sohntask. +#page# + Wenn Sie aus Ihrer Task, in der Sie die Konfiguration vorgenommen haben, mit + dem Interface-System kommunizieren, erfolgt der Zugriff über diese unbe + nannte Sohntask! + + Sie schaffen dadurch aber zusätzlich die Möglichkeit, daß mehrere Sohntasks - + natürlich abwechselnd - über diese "zentrale Abwicklungstask" mit dem Inter + face-System kommunizieren. Selbstverständlich setzt der Zugriff auf das Inter + face-System eine Absprache zwischen den Beteiligten voraus! + + + Gerade in der Aufbauphase, wenn erst wenige Geräte zur Verfügung stehen, ist + das eine Möglichkeit, von verschiedenen Arbeitsplätzen aus mit nur einem Adap + ter/Interface-System Prozeßdatenverarbeitung zu betreiben. + + +#on("b")# +6) Sie wollen mehrere Adapter an separaten seriellen Schnittstellen + betreiben. +#off("b")# + + In diesem Falle ist es sinnvoll - bevor Sie eine Konfiguration vornehmen - gleich + nach der Installation von #on("b")#gs-Prozess#off("b")# für jeden einzelnen Adapter eine Sohntask + unter der Task einzurichten, in der #on("b")#gs-Prozess#off("b")# installiert ist. Jede dieser Sohn + tasks koppeln Sie mit einem festen Kanal, an dem ein Adapter/Interface-System + angeschlossen ist. + + Sie brauchen dazu #on("b")#gs-Prozess#off("b")# nicht mehrfach zu installieren; wir haben für + diesen Fall vorgesorgt. Für die Kopplung der Tasks an die einzelnen Kanäle steht + die Prozedur 'PROC interfacekanal (INT CONST kanalnummer)' zur Verfügung. + Geben Sie also in einer Task z.B. das Kommando 'interfacekanal (5) + <RETURN>', so wird von dieser Task aus das Interface-System am Kanal 5 + angesprochen. + + Über die Prozedur 'INT PROC interfacekanal' können Sie sich in jeder Task + informieren, über welchen Kanal die Kommunikation mit dem Interface-System + abgewickelt wird: z.B. mit 'put (interfacekanal) <RETURN>'. +#page# + Ihnen ist sicher klar, daß es auch hier sinnvoll ist, den Namen der jeweiligen + Task so zu wählen, daß daraus sofort der betreffende Interfacekanal ablesbar + ist. + + In jeder so an einen Kanal gekoppelten Task sollten Sie die Konfiguration von + #on("b")#gs-Prozess#off("b")# vornehmen und ggf. "fixieren". Jede solche Task richtet auto + matisch eine unbenannte Sohntask ("-") ein, die sich wie eine "zentrale Ab + wicklungstask" verhält. Wenn Sie also aus Ihrer Task oder aus neu einge + richteten Sohntasks mit dem Interface-System kommunizieren, so erfolgt das + über die "zentrale Abwicklungstask". + + +#on("b")#9.2 Informationsprozeduren#off("b")# + +Zur Information stehen dem Systembetreuer drei wichtige Prozeduren zur Verfügung: + +#on("b")# +TEXT PROC adapterart +#off("b")# + +Hiermit können Sie in Erfahrung bringen, welche Interfaceanpassung z.Z. in der +aktuellen Task insertiert ist: MUFI im Terminalkanal, MUFI als Endgerät oder +AKTRONIK-Adapter (RS232-Adapter). + + +#on("b")# +INT PROC interfacekanal +#off("b")# + +Hiermit können Sie in Erfahrung bringen, über welchen Kanal z.Z. mit dem Inter +face-System aus der Task kommuniziert wird. Die Prozedur steht allerdings nur dann +zur Verfügung, wenn das Interface-System an einer separaten Schnittstelle betrieben +wird - sonst erscheint der Hinweis 'FEHLER: unbekanntes Kommando'. + +Es gibt noch einen Befehl, mit dem Sie sich über den Zustand des Interface-Systems +informieren können: +#page# +#on("b")# +PROC oeffne interface (INT VAR testwert) +#off("b")# + +Die Prozedur versucht, die aktuelle Betriebsart einzustellen. Anschließend erhalten +Sie eine 'Erfolgsauskunft'. Dabei bedeuten: + + 0 - alles okay + -1 - Interface ist noch nicht konfiguriert + -2 - Interface-Task ist besetzt + -3 - Interfacekanal ist belegt + -4 - Interface meldet sich nicht + -5 - Interface kann nicht geöffnet werden + +Ist der Adapter an einer separaten Schnittstelle angeschlossen, so arbeitet der Befehl +über die "zentrale Abwicklungstask". Als Antwort können alle genannten Codes auftre +ten; beim MUFI im Terminalkanal allerdings nur die Codes 0, -1 und -4. Die oben +genannten Fehlermeldungen sind detailliert in Kapitel 5.5 erläutert. + +Sie sollten anschließend #on("b")#unbedingt#off("b")# das Kommando 'schliesse interface' geben: Eine +eventuell durch 'oeffne interface' vollzogene Betriebsartumstellung wird dadurch +rückgängig gemacht. + + + +#on("b")#9.3 Neufestlegung des Interfacekanals#off("b")# + +Wenn Sie mit MUFI(s) im Terminalkanal arbeiten, spielen Kanalnummern für das +Ansprechen des/der MUFIs keine Rolle. Das jeweilige MUFI kann in diesem Falle +nämlich immer nur von der Task aus angesprochen werden, die an das Terminal +gekoppelt ist, in dessen Zuleitung das MUFI eingebaut wurde. + +Wenn Sie Adapter (MUFI oder RS232-Adapter) an separaten seriellen Schnittstellen +betreiben, so legen Sie schon bei der Installation von #on("b")#gs-Prozess#off("b")# den Kanal fest, +über den die Task mit dem Interface-System kommuniziert. Wie wir schon oben be +schrieben haben, können Sie den Interface-Kanal mit der Prozedur 'PROC interface +kanal (INT CONST kanalnummer)' neu festlegen. Beachten Sie dabei aber bitte +folgendes: +#page# +Wenn Sie in einer Task #on("b")#gs-Prozess#off("b")# konfigurieren und zuvor entschieden haben, daß +der Adapter an einer separaten Schnittstelle betrieben wird, so wird automatisch eine +unbenannte Sohntask ("-") eingerichtet. Diese Sohntask wird zur "zentralen Abwick +lungstask". Wenn Sie nun aus der Task, in der Sie die Konfiguration vorgenommen +haben, oder aus einer Sohntask dieser Task, die anschließend eingerichtet wird, mit +dem Interface-System kommunizieren, so erfolgt diese Kommunikation über diese +unbenannte Sohntask. Daher wählten wir die Bezeichnung "zentrale Abwicklungs +task". + +Da die "zentrale Abwicklungstask" den "Zustand der Vatertask" in dem Augenblick +erbt, in dem Sie eingerichtet wird, würde eine später erfolgende Neufestlegung des +Interfacekanals nicht von Ihr registriert und damit auch nicht wirksam. + +#on("b")#Es ist unbedingt notwendig#off("b")#, in der Task, in der Sie eine Neufestlegung des Interface- +Kanals vornehmen, #on("b")#gs-Prozess#off("b")# auch neu zu konfigurieren! Bei der Neukonfiguration +wird nämlich die unbenannte Sohntask gelöscht und neu eingerichtet. + +(Das hier beschriebene Phänomen ist Ihnen wahrscheinlich schon aus der +PRINTER-Task bekannt). + +Hinsichtlich der Sicherheit des Systems hat dieses Vorgehen aber einen Vorteil: wenn +in den "zugänglichen Sohntask", die über eine "zentrale Abwicklungstask" mit dem +Interface-System kommunizieren eine Neueinstellung des Interface-Kanals vorge +nommen wird, so bleibt diese unwirksam (solange in der Sohntask nicht umkonfigu +riert wird - was sich aber verhindern läßt! Sehen Sie dazu das folgende Kapitel!). + + +#on("b")#9.4 Fixieren der Konfiguration#off("b")# + +Prinzipiell kann in jeder Task, in der #on("b")#gs-Prozess#off("b")# zur Verfügung steht, die Konfigura +tion (von #on("b")#gs-Prozess#off("b")#) vorgenommen werden. Gerade von unerfahrenen Anwendern +könnte aber irrtümlich eine Umkonfiguration vorgenommen werden. Aber nicht nur +das: auch erfahrene Anwender könnten "böswillig" die Konfiguration verändern. Aus +diesem Grunde ist es ggf. sinnvoll, eine vorgenommene Konfiguration zu fixieren +(schützen). +#page# +Dazu steht die Prozedur 'PROC pdv konfiguration zugelassen (BOOL CONST ent +scheidung)' zur Verfügung. Mit dem Kommando 'pdv konfiguration zugelassen +(FALSE) <RETURN>' sperren Sie in der aktuellen Task und in allen Sohntasks, die +sich #on("b")#anschließend#off("b")# unter dieser Task anmelden, den Menupunkt 'k Konfigurieren' +unter dem Oberbegriff 'Interface'. + +Sofern nötig, können Sie diese Sperre mit dem Kommando 'pdv konfiguration zuge +lassen (TRUE) <RETURN>' wieder aufheben, #on("b")#allerdings nur in der Task, in der Sie +auch die Sperre gesetzt haben#off("b")#, denn #on("b")#gs-Prozess#off("b")# merkt sich diesen Tasknamen! +Wenn Sie also ein Password auf diese Task legen, und damit anderen den Zugang +verwehren, kann auch eine "böswilligie Umkonfiguration" verhindert werden. + + +#on("b")#9.5 Mögliche Fehlerfälle#off("b")# + +Wenn Fehlermeldungen auftreten, so finden Sie Fehlerbeschreibungen und Möglich +keiten zur Abhilfe im Kapitel 5.5 beschrieben. Auf einen Fehlerzustand möchten wir +Sie hier noch besonders hinweisen: + +#on("b")#Interfacekanal ist belegt!#off("b")# + + Über den angegebenen Kanal greift schon eine andere Task auf das angeschlos + sene Interface-System zu. Vielleicht wurde der betreffende Kanal auch zuvor für + andere Zwecke verwendet - anschließend hat der Benutzer den Kanal nicht + ordentlich freigegeben. Geben Sie in der 'gib kommmando'-Ebene den Befehl + 'taskinfo (2) <RETURN>'. In der Spalte mit der Überschrift 'CHAN' müßte jetzt + irgendwo die Kanalnummer auftauchen. Steht die Kanalnummer bei einem Sohn + der Task 'SUPERVISOR', so liegt der letztgenannte Fall vor, sonst der erstge + nannte. + + Abhilfe: Schließen Sie Ihr Interface-System an einen anderen Kanal an oder + bitten Sie den betreffenden Anwender, den Kanal freizugeben. + Ist das nicht möglich, so kann aus einer Systemtask das Kommando + 'end (canal (kanalnummer))' <RETURN>' gegeben werden. Statt + 'kanalnummer' ist natürlich die tatsächliche Nummer (z.B. '4') + anzugeben. +#page# +#on("b")#9.6 Weitere Möglichkeiten#off("b")# + +Ihnen ist sicher aufgefallen, daß wir uns bemüht haben, einen sinnvollen Kompro +miß zwischen Sicherheit in der Handhabung und Geschwindigkeit des Systems zu +finden. In Zweifelsfällen haben wir uns eher zugunsten der Sicherheit entschieden. + +Sicher werden Sie inzwischen bemerkt haben, daß die Kommunikation mit einem +Adapter (MUFI oder RS232-Adapter) an einer separaten seriellen Schnittstelle recht +zeitaufwendig ist. + +Prinzipiell standen uns bei der Konzeption zwei Möglichkeiten zur Verfügung: Ent +weder wir gestalten jeden Basisbefehl so, daß wir uns zu Beginn der Ausführung +jeweils direkt an den betreffenden Kanal ankoppeln und am Ende der Ausführung +des Befehls wieder abkoppeln - oder wir richten eine "zentrale Abwicklungstask" ein +und nutzen die Intertaskkommunikation des EUMELs. Wir haben uns nach diversen +Tests für die zweite Variante entschieden: Einmal zeigte sich, daß dieses Verfahren +weit weniger zeitaufwendig ist als das ständige An- und Abkoppeln an den Interface- +Kanal. Zum anderen konnten wir so die Möglichkeit schaffen, über diese "zentrale +Abwicklungstask" den abwechselnden, koordinierten Zugriff mehrerer Tasks auf ein +Interface-System zu realiseren. + +Wenn Sie nun aber spezielle Anwendungen schreiben wollen, für die die Geschwin +digkeit beim Ansprechen des Interface-Systems an einer separaten Schnittstelle nicht +ausreicht, so möchten wir Ihnen hier noch eine Möglichkeit aufzeigen, dieses +Problem zu bewältigen. + +Auch an dieser Stelle sei noch einmal ausdrücklich darauf hingewiesen, daß Sie bei +dieser Programmiermöglichkeit auf alle Sicherheiten, die Ihnen #on("b")#gs-Prozess#off("b")# bietet, +verzichten müssen. Deshalb sollten Sie diesen Weg nur beschreiten, wenn Sie ein +hinlängliches Maß an Programmierroutine besitzen! Die zur Verfügung stehenden +Befehle und die Besonderheiten möchten wir Ihnen an einem kleinen Beispiel +programm aufzeigen: +#page# +#on("b")# + LET ausgabekanal = 4, + eingabekanal = 3; + + INT VAR test, eingabewert; + INT VAR terminalkanal :: channel (myself); + schliesse interface; + continue (interfacekanal); + oeffne interface direkt (test); + IF test < 0 + THEN continue (terminalkanal); + errorstop ("Funktionsfehler Interface-System") + FI; + initialisiere interface direkt; + eigentliches programm; + schliesse interface direkt; + continue (terminalkanal). + + eigentliches programm: + direkt ausgeben (ausgabekanal, 3); + eingabewert := direkteingabe (eingabekanal). +#off("b")# + +Wenn Sie ein solches Programm geschrieben haben, starten Sie es bitte mit dem +Befehl 'run pdv' oder aus dem Menusystem heraus mit der Menufunktion 's Starten'. +(Bei 'run' kann der Befehl 'schliesse interface' gestrichen werden!). + +Für die eigentliche Programmierung des Interface-Systems stehen Ihnen nur zwei +Befehle zur Verfügung: + +#on("b")# +PROC direkt ausgeben (INT CONST kanal, wert) +#off("b")# + + - ermittelt den auszugebenden Wert durch die Rechnung + +#on("b")##center#ausgabe = wert MOD 256#off("b")# + + und gibt diesen am Ausgabekanal aus. + + Der Befehl ähnelt dem Befehl 'dezimalwert ausgeben' - hat aber im Gegensatz + dazu keinerlei "Fehlerfänger": so werden Sie z.B. nicht darauf aufmerksam + gemacht, wenn der angegebene Kanal gar kein Ausgang ist, etc.) +#page# +#on("b")# +INT PROC direkteingabe (INT CONST kanal) +#off("b")# + + - liest den aktuell anliegenden Wert am angegebenen Kanal ein. + - liefert einen INT-Wert mit 0 � 'wert' � 255. + + Der Befehl ähnelt dem Befehl 'dezimalwert' - hat aber im Gegensatz dazu + ebenfalls keinerlei "Fehlerfänger"! + + +Das obige Programm beginnt mit dem Befehl 'schliesse interface'. Sicher kommt es +Ihnen sonderbar vor, daß zu Beginn des Programms das Interface geschlossen wird, +wo wir es doch eigentlich "öffnen" müßten. Ihnen wird die Funktion aber sofort klar, +wenn Sie sich die Situation vor Augen führen: + +Als Sie #on("b")#gs-Prozess#off("b")# in Ihrer Task konfiguriert haben, und festlegten, daß der Adapter +an einer separaten Schnittstelle "hängt", richtete #on("b")#gs-Prozess#off("b")# automatisch eine +unbenannte Sohntask ("-") als "zentrale Abwicklungstask" ein, die durch das +Kommando 'run pdv' bzw. durch die Menufunktion 's Starten' an den Interfacekanal +gekoppelt wird. Der Befehl 'schliesse interface' koppelt die Task "-" wieder vom Inter +face-Kanal ab, so daß Sie direkt darauf zugreifen können. Außerdem werden die +internen Einstellungen im Adapter wieder in Ausgangsstellung gebracht. + +Mit der Prozedur 'PROC oeffne interface direkt (INT VAR testwert)' sprechen Sie das +Interface neu an. Dabei wird ein angeschlossener Adapter automatisch auf Betriebs +bereitschaft getestet und dann auf den Betrieb an einer separaten seriellen Schnitt +stelle umgestellt (nur beim MUFI). + +Über 'testwert' erhalten Sie eine Rückmeldung. Dabei haben die gelieferten 'test +werte' folgende Bedeutung: + + 0 - Interface betriebsbereit + -4 - Interface #on("b")#nicht#off("b")# betriebsbereit + (Interface meldet sich nicht) +#page# +Der Befehl 'initialisiere interface direkt' wirkt ähnlich wie der schon oben be +schriebene Befehl 'initialisiere interface', jedoch #on("b")#nicht#off("b")# über den "Umweg zentrale +Abwicklungstask" - sondern halt 'direkt' am Interface-Kanal. Einzige Aufgabe hier: +Alle Ausgabe-Kanäle auf Wert '0' bzw. Nullspannung setzen. + +Durch das abschließende 'schliesse interface direkt' bringen Sie ein angeschlossenes +MUFI wieder in die "Ausgangsstellung". + +Beachten Sie bei der Programmierung bitte unbedingt, daß Sie ständig zwischen dem +Kanal, an dem Sie arbeiten (Terminal) und dem Interfacekanal hin- und herschalten +(müssen), wenn Ein- oder Ausgaben auf dem Terminal erfolgen sollen. Die direkte +Programmierung lohnt sich demnach nur, wenn aufeinanderfolgende Aktionen am +Interfacekanal durchgeführt werden (z.B. Schrittmotorsteuerungen etc.). + +Treten Programmfehler auf, während Sie an den Interfacekanal gekoppelt sind, +haben Sie keine Chance, von Ihrem Terminalkanal aus auf das Interface zuzugreifen +- denn das "hängt am Interfacekanal" (z.B. bei "Programmabsturz" oder Endlos +schleife). + +Bei Ihrer Programmierung sollten Sie diesem Fall vorbeugen (disable stop - enable +stop). Ansonsten müßten Sie aus einer Systemtask den Kanal "abschießen". Geben +Sie dazu in einer Systemtask z.B. das Kommando 'end (canal (5)) <RETURN>', +wenn das Interface-System über den Kanal 5 angesprochen wird. + diff --git a/app/gs.process/1.02/source-disk b/app/gs.process/1.02/source-disk new file mode 100644 index 0000000..df52516 --- /dev/null +++ b/app/gs.process/1.02/source-disk @@ -0,0 +1 @@ +informatikpaket/04_gs.propess.img diff --git a/app/gs.process/1.02/src/ls-MENUKARTE:Prozess b/app/gs.process/1.02/src/ls-MENUKARTE:Prozess Binary files differnew file mode 100644 index 0000000..9a2e009 --- /dev/null +++ b/app/gs.process/1.02/src/ls-MENUKARTE:Prozess diff --git a/app/gs.process/1.02/src/ls-Prozess 1 für AKTRONIC-Adapter b/app/gs.process/1.02/src/ls-Prozess 1 für AKTRONIC-Adapter new file mode 100644 index 0000000..c42cfa5 --- /dev/null +++ b/app/gs.process/1.02/src/ls-Prozess 1 für AKTRONIC-Adapter @@ -0,0 +1,57 @@ +(* + + ********************************************************** + ********************************************************** + ** ** + ** ls-Prozess 1 ** + ** ** + ** Anpassung für AKTRONIC-Adapter ** + ** ** + ** Version 1.02 ** + ** ** + ** (Stand : 26.01.90) ** + ** ** + ** ** + ** Autoren: Bruno Pollok, Bielefeld ** + ** Wolfgang Weber, Bielefeld ** + ** ** + ** Copyright (C) 1988 Eva Latta-Weber, Bielefeld ** + ** Copyright (C) 1990 ERGOS GmbH, Siegburg ** + ********************************************************** + ********************************************************** + + *) +PACKET ls prozess 1 DEFINES + run pdv,{} run pdv again,{} initialisiere interface,{} schalte alles aus,{} ausgeben,{} eingabe,{} warte,{} abbruch gewuenscht,{} tue nichts,{} trage kanaldaten ein,{} beende kanaldaten eintragen,{} hole spannungsbereich,{} letzte ausgabe,{} pruefe kanal,{} pruefe abbruch,{} teste interface,{} oeffne interface,{} schliesse interface,{} nicht belegt,{} digital aus,{} analog aus,{} + digital ein,{} analog ein,{} kanalbreite,{} ganzzahl obergrenze,{} adapterart,{} (* ------------------------- *){} kanalkoppler,{} interface kanal,{} oeffne interface direkt,{} schliesse interface direkt,{} initialisiere interface direkt,{} direkt ausgeben,{} direkt eingabe:{}(******** A N P A S S U N G A N A K T R O N I C - A D A P T E R ********){}LET interface test code = ""240"",{} interface open code = ""176"",{} + interface close code = ""176"",{} adresse 0 code = ""176"",{} interface write code = 64 ,{} interface read code = 192 ;{}TEXT CONST adapterart :: "AKTRONIC-Adapter";{}TEXT PROC interface anpassung (INT CONST kanalnummer, steuerungscode):{} IF es ist ein ausgabekanal{} THEN code (interface write code + device + faktor * steuerungscode){} ELIF es ist ein eingabekanal{} THEN lesecode in abhaengigkeit von der taktzahl{} ELSE ""{} FI.{} es ist ein ausgabekanal:{} + kanal [kanalnummer].betriebsart < 0.{} es ist ein eingabekanal:{} kanal [kanalnummer].betriebsart > 0.{} device:{} IF steckplatznummer < 3{} THEN 16{} ELSE 32{} FI.{} faktor:{} IF steckplatznummer MOD 2 = 0{} THEN 4{} ELSE 1{} FI.{} steckplatznummer:{} IF kanalnummer < 10{} THEN 1{} ELSE kanalnummer DIV 10{} FI.{} lesecode in abhaengigkeit von der taktzahl:{} SELECT kanal [kanalnummer].taktzahl OF{} CASE 1: code fuer digital oder analog eingang{} + CASE 2: code fuer kombi e1{} CASE 3: code fuer kombi e2{} OTHERWISE "" END SELECT.{} code fuer digital oder analog eingang:{} IF kanal [kanalnummer].betriebsart = analog ein{} THEN kanal [kanalnummer].taktzahl := 2; (* ad wandler muss hier *){} lesecode + lesecode (* 2x gelesen werden! *){} ELSE lesecode{} FI.{} lesecode : code (interface read code + device + faktor * steuerungscode).{} code fuer kombi e1:{} kanal [kanalnummer].taktzahl INCR 1; (* bei Analogport1 der Kombikarte *){} + adresse 0 code + (3 * lesecode). (* sind hier 3 Takte noetig ! *){} code fuer kombi e2:{} kanal [kanalnummer].taktzahl DECR 1; (* hier nur 2 Takte noetig ! *){} adresse 0 code + lesecode + lesecode.{}END PROC interface anpassung;{}(************ H A R D W A R E U N A B H Ä N G I G E R T E I L ************){}LET max kanalanzahl = 49,{} initcode = 50,{} endcode = 51,{} alles aus code = 52,{} + endezeichen = "q",{} abbruchzeichen = "h",{} esc = ""27"";{}INT CONST analog aus :: -2, (* Betriebsarten *){} digital aus :: -1,{} nicht belegt :: 0,{} digital ein :: 1,{} analog ein :: 2,{} kanalbreite :: 8,{} ganzzahl obergrenze :: 2 ** kanalbreite,{} configuration error code :: -1,{} + kanal besetzt code :: -3,{} interface error code :: -4,{} not init code :: -5;{}INT VAR interfacechannel :: 2,{} dummy;{}TEXT VAR meldung :: "";{}BOOL VAR kanaldaten sind eingetragen :: FALSE,{} endezeichen gegeben :: FALSE,{} programm mit pdv gestartet :: FALSE,{} fehler zu melden :: FALSE;{}TASK VAR interface task :: niltask;{}DATASPACE VAR ds :: nilspace;{} +TYPE KANAL = STRUCT (INT betriebsart, taktzahl, TEXT steuercode),{} SPANNUNG = STRUCT (REAL minimalwert, maximalwert);{}ROW max kanalanzahl INT VAR vorherige ausgabe;{}ROW max kanalanzahl KANAL VAR kanal;{}ROW max kanalanzahl SPANNUNG VAR spannung;{}ROW 5 TEXT CONST fehlermeldung :: ROW 5 TEXT :{} ("Interface ist noch nicht konfiguriert!",{} "Interface-Task ist besetzt!",{} "Interface-Kanal ist belegt!",{} "Interface meldet sich nicht!",{} "Interface kann nicht geöffnet werden!");{} +PROC run pdv:{} run pdv (last param){}END PROC run pdv;{}PROC run pdv (TEXT CONST programmname):{} enable stop;{} last param (programmname);{} programm mit pdv gestartet := TRUE;{} teste interface;{} disable stop;{} run (programmname);{} IF is error{} THEN fehlerbehandlung{} ELSE melde programmende{} FI;{} schliesse interface;{} programm mit pdv gestartet := FALSE;{} enable stop;{} IF fehler zu melden{} THEN errorstop (meldung){} FI{}END PROC run pdv;{}PROC run pdv again:{} + enable stop;{} programm mit pdv gestartet := TRUE;{} teste interface;{} disable stop;{} run again;{} IF is error{} THEN fehlerbehandlung{} ELSE melde programmende{} FI;{} schliesse interface;{} programm mit pdv gestartet := FALSE;{} enable stop;{} IF fehler zu melden{} THEN errorstop (meldung){} FI{}END PROC run pdv again;{}PROC melde programmende:{} page;{} menufootnote ("Programmende! Zum Weitermachen bitte irgendeine Taste tippen.");{} pause;{} schalte alles aus{}END PROC melde programmende;{} +PROC initialisiere interface:{} enable stop;{} pruefe abbruch;{} IF programm mit pdv gestartet{} THEN schalte alles aus{} ELSE errorstop ("PDV-Programme müssen mit 'run pdv' gestartet werden!"){} FI{}END PROC initialisiere interface;{}PROC schalte alles aus:{} INT VAR k;{} FOR k FROM 1 UPTO max kanalanzahl REP{} vorherige ausgabe [k] := 0{} PER;{} forget (ds); ds := nilspace;{} call (interface task, alles aus code, ds, dummy){}END PROC schalte alles aus;{}PROC ausgeben (INT CONST kanalnummer, wert):{} + merke wert;{} gib wert aus.{} merke wert:{} vorherige ausgabe [kanalnummer] := wert.{} gib wert aus:{} call (interface task, 256 * kanalnummer + wert, ds, dummy).{}END PROC ausgeben;{}INT PROC eingabe (INT CONST kanalnummer):{} INT VAR eingabewert;{} call (interface task, kanalnummer, ds, eingabewert);{} eingabewert{}END PROC eingabe;{}PROC warte (REAL CONST sekunden):{} TEXT VAR eingabe;{} pruefe abbruch;{} eingabe := incharety (int (sekunden * 10.0 + 0.5));{} IF eingabe = esc{} + THEN untersuche naechstes zeichen{} FI.{} untersuche naechstes zeichen:{} eingabe := incharety (30);{} IF eingabe = endezeichen{} THEN endezeichen gegeben := TRUE{} ELIF eingabe = abbruchzeichen{} THEN errorstop ("Programm-Abbruch durch <ESC><"{} + abbruchzeichen + ">!"){} FI.{}END PROC warte;{}PROC warte (INT CONST sekunden):{} TEXT VAR eingabe;{} pruefe abbruch;{} eingabe := incharety (sekunden * 10);{} IF eingabe = esc{} THEN untersuche naechstes zeichen{} + FI.{} untersuche naechstes zeichen:{} eingabe := incharety (30);{} IF eingabe = endezeichen{} THEN endezeichen gegeben := TRUE{} ELIF eingabe = abbruchzeichen{} THEN errorstop ("Programm-Abbruch durch <ESC><"{} + abbruchzeichen + ">!"){} FI.{}END PROC warte;{}BOOL PROC abbruch gewuenscht:{} pruefe abbruch;{} BOOL VAR entscheidung :: endezeichen gegeben;{} endezeichen gegeben := FALSE;{} entscheidung{}END PROC abbruch gewuenscht;{}PROC tue nichts:{} + pruefe abbruch{}END PROC tue nichts;{}PROC trage kanaldaten ein (INT CONST kanalnummer,{} ROW 2 REAL CONST spannungsbereich,{} ROW 3 INT CONST kanalparameter):{} spannung [kanalnummer].minimalwert := spannungsbereich [1];{} spannung [kanalnummer].maximalwert := spannungsbereich [2];{} kanal [kanalnummer].betriebsart := kanalparameter [1];{} kanal [kanalnummer].taktzahl := kanalparameter [2];{} kanal [kanalnummer].steuercode := interface anpassung{} + (kanalnummer, kanalparameter [3]){}END PROC trage kanaldaten ein;{}PROC beende kanaldaten eintragen:{} loesche interface task;{} begin (PROC kanal koppler, interface task);{} kanaldaten sind eingetragen := TRUE.{} loesche interface task:{} disable stop;{} end (interface task);{} IF is error{} THEN clear error{} FI;{} enable stop.{}END PROC beende kanaldaten eintragen;{}PROC hole spannungsbereich (INT CONST kanalnummer, REAL VAR u min, u max):{} + u min := spannung [kanalnummer].minimalwert;{} u max := spannung [kanalnummer].maximalwert{}END PROC hole spannungsbereich;{}INT PROC letzte ausgabe (INT CONST kanalnummer):{} vorherige ausgabe [kanalnummer]{}END PROC letzte ausgabe;{}PROC pruefe kanal (INT CONST kanalnummer, gewuenschte betriebsart):{} pruefe abbruch;{} pruefe kanalnummer;{} pruefe betriebsart.{} pruefe kanalnummer:{} IF kanalnummer < 1 OR kanalnummer > max kanalanzahl{} THEN errorstop ("Kanalnummer " + text (kanalnummer) +{} + " ist unzulaessig !"){} FI.{} pruefe betriebsart:{} IF gewuenschte betriebsart <> kanal [kanalnummer].betriebsart{} THEN errorstop ("An Kanal " + text (kanalnummer) +{} " keine " + wunsch + " moeglich!"){} FI.{} wunsch:{} IF gewuenschte betriebsart = analog aus{} THEN "Analog-Ausgabe"{} ELIF gewuenschte betriebsart = digital aus{} THEN "Digital-Ausgabe"{} ELIF gewuenschte betriebsart = digital ein{} THEN "Digital-Eingabe"{} + ELIF gewuenschte betriebsart = analog ein{} THEN "Analog-Eingabe"{} ELSE "Ein- oder Ausgabe"{} FI.{}END PROC pruefe kanal;{}PROC pruefe abbruch:{} IF incharety = esc{} THEN pruefe weiter{} FI.{} pruefe weiter:{} TEXT CONST zeichen :: incharety (30);{} IF zeichen = endezeichen{} THEN endezeichen gegeben := TRUE{} ELIF zeichen = abbruchzeichen{} THEN errorstop ("Programm-Abbruch durch <ESC><"{} + abbruchzeichen + ">!"){} + FI.{}END PROC pruefe abbruch;{}PROC oeffne interface (INT VAR status):{} enable stop;{} forget (ds); ds := nilspace;{} IF kanaldaten sind eingetragen{} THEN pingpong (interfacetask, initcode, ds, status){} ELSE status := configuration error code{} FI;{} IF status > 0 THEN status DECR maxint FI;{} forget (ds); ds := nilspace{}END PROC oeffne interface;{}PROC schliesse interface:{} enable stop;{} forget (ds); ds := nilspace;{} pingpong (interface task, end code, ds, dummy);{} forget (ds); ds := nilspace{} +END PROC schliesse interface;{}PROC teste interface:{} INT VAR test;{} oeffne interface (test);{} IF test < 0{} THEN errorstop (fehlermeldung [min (5, abs (test))]){} ELSE fehler zu melden := FALSE;{} endezeichen gegeben := FALSE{} FI{}END PROC teste interface;{}PROC fehlerbehandlung:{} meldung := errormessage;{} IF meldung <> ""{} THEN meldung CAT fehlerzeile;{} fehler zu melden := TRUE{} FI;{} clear error;{} initialisiere interface.{} fehlerzeile:{} + IF errorline = 0{} THEN ""{} ELSE " (bei Zeile " + text (errorline) + ")"{} FI.{}END PROC fehlerbehandlung;{}(******************** EIN-/AUSGABE AM INTERFACE-KANAL ********************){}PROC kanalkoppler:{} IF name (myself) <> "-"{} THEN errorstop ("Unzulässiges Kommando!"){} ELSE warte auf anrufe{} FI.{} warte auf anrufe:{} TASK VAR absender;{} TEXT VAR dummy;{} INT VAR codenummer, antwort;{} disable stop;{} REP forget (ds);{} wait (ds, codenummer, absender);{} + IF codenummer = initcode{} THEN kopple an interface kanal;{} IF interface ist betriebsbereit{} THEN bearbeite weitere auftraege{} ELSE gib negative rueckmeldung{} FI;{} gib kanal frei{} ELSE antwort := not init code;{} gib negative rueckmeldung{} FI{} PER.{} kopple an interface kanal:{} continue (interface channel);{} IF is error{} THEN clear error;{} antwort := kanal besetzt code{} + ELSE oeffne interface direkt (antwort){} FI.{} interface ist betriebsbereit: antwort = 0.{} gib negative rueckmeldung: send (absender, antwort, ds).{} gib kanal frei:{} break (quiet);{} send (absender, 0, ds, antwort);{} collect heap garbage.{} bearbeite weitere auftraege:{} REP call (absender, antwort, ds, codenummer);{} IF codenummer > 255{} THEN sende wert an interface{} ELIF codenummer < 50{} THEN hole wert von interface{} ELIF codenummer = alles aus code{} + THEN initialisiere interface direkt{} FI{} UNTIL codenummer = endcode PER;{} IF is error THEN clear error FI;{} schliesse interface direkt.{} sende wert an interface:{} out (kanal [codenummer DIV 256].steuercode);{} out (code (codenummer)).{} hole wert von interface:{} out (kanal [codenummer].steuercode);{} SELECT kanal [codenummer].taktzahl OF{} CASE 1 : antwort := erstes zeichen{} CASE 2 : antwort := zweites zeichen{} CASE 3 : antwort := drittes zeichen{} + OTHERWISE antwort := -1{} END SELECT.{} erstes zeichen:{} code (incharety (1)).{} zweites zeichen:{} dummy := incharety (1);{} code (incharety (1)).{} drittes zeichen:{} dummy := incharety (1);{} dummy := incharety (1);{} code (incharety (1)).{}END PROC kanalkoppler;{}PROC interface kanal (INT CONST kanalnummer):{} enable stop;{} IF kanalnummer < 1 OR kanalnummer > 24{} THEN errorstop ("Unzulaessige Kanalnummer"){} ELSE interface channel := kanalnummer{} + FI{}END PROC interface kanal;{}INT PROC interface kanal:{} interface channel{}END PROC interface kanal;{}PROC oeffne interface direkt (INT VAR status):{} leere puffer;{} out (interface test code);{} IF antwort <> ""{} THEN status := 0;{} out (interface open code){} ELSE status := interface error code{} FI.{} leere puffer:{} REP UNTIL incharety = "" PER.{} antwort: incharety (1).{}END PROC oeffne interface direkt;{}PROC schliesse interface direkt:{} out (interface close code){} +END PROC schliesse interface direkt;{}PROC initialisiere interface direkt:{} schalte alles aus.{} schalte alles aus:{} INT VAR kanalnummer, kanalbetriebsart;{} FOR kanalnummer FROM 1 UPTO max kanalanzahl REP{} kanalbetriebsart := kanal [kanalnummer].betriebsart;{} IF kanalbetriebsart = digital aus{} THEN direkt ausgeben (kanalnummer, 0){} ELIF kanalbetriebsart = analog aus{} THEN direkt ausgeben (kanalnummer, gewandelte nullspannung){} FI{} + PER.{} gewandelte nullspannung:{} int(- real (ganzzahl obergrenze) * u min / (u max - u min) + 0.5).{} u max : spannung [kanalnummer].maximalwert.{} u min : spannung [kanalnummer].minimalwert.{}END PROC initialisiere interface direkt;{}PROC direkt ausgeben (INT CONST kanalnummer, wert):{} out (kanal [kanalnummer].steuercode);{} out (code (wert)){}END PROC direkt ausgeben;{}INT PROC direkt eingabe (INT CONST kanalnummer):{} gib lesecode aus;{} erhaltene antwort.{} gib lesecode aus:{} + out (kanal [kanalnummer].steuercode).{} erhaltene antwort:{} TEXT VAR dummy;{} SELECT kanal [kanalnummer].taktzahl OF{} CASE 1 : erstes zeichen{} CASE 2 : zweites zeichen{} CASE 3 : drittes zeichen{} OTHERWISE -1{} END SELECT.{} erstes zeichen:{} code (incharety (1)).{} zweites zeichen:{} dummy := incharety (1);{} code (incharety (1)).{} drittes zeichen:{} dummy := incharety (1);{} dummy := incharety (1);{} code (incharety (1)).{} +END PROC direkt eingabe;{}PROC initialisiere die kanaele:{} INT VAR kanalnummer;{} FOR kanalnummer FROM 1 UPTO max kanalanzahl REP{} trage kanaldaten ein (kanalnummer, keine spannung, leere karte);{} vorherige ausgabe [kanalnummer] := 0{} PER.{} keine spannung:{} ROW 2 REAL : (0.0, 0.0).{} leere karte:{} ROW 3 INT : (nicht belegt, 0, 0).{}END PROC initialisiere die kanaele;{}initialisiere die kanaele;{}END PACKET ls prozess 1{} + diff --git a/app/gs.process/1.02/src/ls-Prozess 1 für MUFI als Endgerät b/app/gs.process/1.02/src/ls-Prozess 1 für MUFI als Endgerät new file mode 100644 index 0000000..4d2a5f4 --- /dev/null +++ b/app/gs.process/1.02/src/ls-Prozess 1 für MUFI als Endgerät @@ -0,0 +1,57 @@ +(* + + ********************************************************** + ********************************************************** + ** ** + ** ls-Prozess 1 ** + ** ** + ** Anpassung für MUFI als Endgerät ** + ** ** + ** Version 1.02 ** + ** ** + ** (Stand : 26.01.90) ** + ** ** + ** ** + ** Autoren: Bruno Pollok, Bielefeld ** + ** Wolfgang Weber, Bielefeld ** + ** ** + ** Copyright (C) 1988 Eva Latta-Weber, Bielefeld ** + ** Copyright (C) 1990 ERGOS GmbH, Siegburg ** + ********************************************************** + ********************************************************** + + *) +PACKET ls prozess 1 DEFINES + run pdv,{} run pdv again,{} initialisiere interface,{} schalte alles aus,{} ausgeben,{} eingabe,{} warte,{} abbruch gewuenscht,{} tue nichts,{} trage kanaldaten ein,{} beende kanaldaten eintragen,{} hole spannungsbereich,{} letzte ausgabe,{} pruefe kanal,{} pruefe abbruch,{} teste interface,{} oeffne interface,{} schliesse interface,{} nicht belegt,{} digital aus,{} analog aus,{} + digital ein,{} analog ein,{} kanalbreite,{} ganzzahl obergrenze,{} adapterart,{} (* ------------------------- *){} kanalkoppler,{} interface kanal,{} oeffne interface direkt,{} schliesse interface direkt,{} initialisiere interface direkt,{} direkt ausgeben,{} direkt eingabe:{}(******************** A N P A S S U N G A N M U F I ********************){}LET interface test code = ""27""27"10",{} interface okay code = ""27""27"00",{} + interface open code = ""27""27"1A18",{} interface close code = ""25""27""27"13",{} adresse 0 code = ""61"",{} leertakt code = ""62"",{} interface write code = 80 ,{} interface read code = 64 ,{} erwartete zeichen = 4 ;{}TEXT CONST adapterart :: "MUFI als Endgerät";{}TEXT PROC interface anpassung (INT CONST kanalnummer, steuerungscode):{} IF es ist ein ausgabekanal{} THEN code (interface write code + device + 4 * steuerungscode){} ELIF es ist ein eingabekanal{} + THEN lesecode in abhaengigkeit von der taktzahl{} ELSE ""{} FI.{} es ist ein ausgabekanal:{} kanal [kanalnummer].betriebsart < 0.{} es ist ein eingabekanal:{} kanal [kanalnummer].betriebsart > 0.{} device:{} IF kanalnummer < 10{} THEN 0{} ELSE kanalnummer DIV 10 - 1{} FI.{} lesecode in abhaengigkeit von der taktzahl:{} SELECT kanal [kanalnummer].taktzahl OF{} CASE 1: lesecode{} CASE 2: adresse 0 code + lesecode + lesecode{} CASE 3: adresse 0 code + lesecode + zwei weitere takte{} + OTHERWISE "" END SELECT.{} lesecode : code (interface read code + device + 4 * steuerungscode).{} zwei weitere takte:{} IF leertakt code = ""{} THEN lesecode + lesecode{} ELSE kanal [kanalnummer].taktzahl DECR 1;{} leertakt code + lesecode{} FI.{}END PROC interface anpassung;{}(************ H A R D W A R E U N A B H Ä N G I G E R T E I L ************){}LET max kanalanzahl = 49,{} initcode = 50,{} endcode = 51,{} + alles aus code = 52,{} endezeichen = "q",{} abbruchzeichen = "h",{} esc = ""27"";{}INT CONST analog aus :: -2, (* Betriebsarten *){} digital aus :: -1,{} nicht belegt :: 0,{} digital ein :: 1,{} analog ein :: 2,{} kanalbreite :: 8,{} ganzzahl obergrenze :: 2 ** kanalbreite,{} + configuration error code :: -1,{} kanal besetzt code :: -3,{} interface error code :: -4,{} not init code :: -5;{}INT VAR interfacechannel :: 2,{} dummy;{}TEXT VAR meldung :: "";{}BOOL VAR kanaldaten sind eingetragen :: FALSE,{} endezeichen gegeben :: FALSE,{} programm mit pdv gestartet :: FALSE,{} fehler zu melden :: FALSE;{}TASK VAR interface task :: niltask;{} +DATASPACE VAR ds :: nilspace;{}TYPE KANAL = STRUCT (INT betriebsart, taktzahl, TEXT steuercode),{} SPANNUNG = STRUCT (REAL minimalwert, maximalwert);{}ROW max kanalanzahl INT VAR vorherige ausgabe;{}ROW max kanalanzahl KANAL VAR kanal;{}ROW max kanalanzahl SPANNUNG VAR spannung;{}ROW 5 TEXT CONST fehlermeldung :: ROW 5 TEXT :{} ("Interface ist noch nicht konfiguriert!",{} "Interface-Task ist besetzt!",{} "Interface-Kanal ist belegt!",{} "Interface meldet sich nicht!",{} "Interface kann nicht geöffnet werden!");{} +PROC run pdv:{} run pdv (last param){}END PROC run pdv;{}PROC run pdv (TEXT CONST programmname):{} enable stop;{} last param (programmname);{} programm mit pdv gestartet := TRUE;{} teste interface;{} disable stop;{} run (programmname);{} IF is error{} THEN fehlerbehandlung{} ELSE melde programmende{} FI;{} schliesse interface;{} programm mit pdv gestartet := FALSE;{} enable stop;{} IF fehler zu melden{} THEN errorstop (meldung){} FI{}END PROC run pdv;{}PROC run pdv again:{} + enable stop;{} programm mit pdv gestartet := TRUE;{} teste interface;{} disable stop;{} run again;{} IF is error{} THEN fehlerbehandlung{} ELSE melde programmende{} FI;{} schliesse interface;{} programm mit pdv gestartet := FALSE;{} enable stop;{} IF fehler zu melden{} THEN errorstop (meldung){} FI{}END PROC run pdv again;{}PROC melde programmende:{} page;{} menufootnote ("Programmende! Zum Weitermachen bitte irgendeine Taste tippen.");{} pause;{} schalte alles aus{}END PROC melde programmende;{} +PROC initialisiere interface:{} enable stop;{} pruefe abbruch;{} IF programm mit pdv gestartet{} THEN schalte alles aus{} ELSE errorstop ("PDV-Programme müssen mit 'run pdv' gestartet werden!"){} FI{}END PROC initialisiere interface;{}PROC schalte alles aus:{} INT VAR k;{} FOR k FROM 1 UPTO max kanalanzahl REP{} vorherige ausgabe [k] := 0{} PER;{} forget (ds); ds := nilspace;{} call (interface task, alles aus code, ds, dummy){}END PROC schalte alles aus;{}PROC ausgeben (INT CONST kanalnummer, wert):{} + merke wert;{} gib wert aus.{} merke wert:{} vorherige ausgabe [kanalnummer] := wert.{} gib wert aus:{} call (interface task, 256 * kanalnummer + wert, ds, dummy).{}END PROC ausgeben;{}INT PROC eingabe (INT CONST kanalnummer):{} INT VAR eingabewert;{} call (interface task, kanalnummer, ds, eingabewert);{} eingabewert{}END PROC eingabe;{}PROC warte (REAL CONST sekunden):{} TEXT VAR eingabe;{} pruefe abbruch;{} eingabe := incharety (int (sekunden * 10.0 + 0.5));{} IF eingabe = esc{} + THEN untersuche naechstes zeichen{} FI.{} untersuche naechstes zeichen:{} eingabe := incharety (30);{} IF eingabe = endezeichen{} THEN endezeichen gegeben := TRUE{} ELIF eingabe = abbruchzeichen{} THEN errorstop ("Programm-Abbruch durch <ESC><"{} + abbruchzeichen + ">!"){} FI.{}END PROC warte;{}PROC warte (INT CONST sekunden):{} TEXT VAR eingabe;{} pruefe abbruch;{} eingabe := incharety (sekunden * 10);{} IF eingabe = esc{} THEN untersuche naechstes zeichen{} + FI.{} untersuche naechstes zeichen:{} eingabe := incharety (30);{} IF eingabe = endezeichen{} THEN endezeichen gegeben := TRUE{} ELIF eingabe = abbruchzeichen{} THEN errorstop ("Programm-Abbruch durch <ESC><"{} + abbruchzeichen + ">!"){} FI.{}END PROC warte;{}BOOL PROC abbruch gewuenscht:{} pruefe abbruch;{} BOOL VAR entscheidung :: endezeichen gegeben;{} endezeichen gegeben := FALSE;{} entscheidung{}END PROC abbruch gewuenscht;{}PROC tue nichts:{} + pruefe abbruch{}END PROC tue nichts;{}PROC trage kanaldaten ein (INT CONST kanalnummer,{} ROW 2 REAL CONST spannungsbereich,{} ROW 3 INT CONST kanalparameter):{} spannung [kanalnummer].minimalwert := spannungsbereich [1];{} spannung [kanalnummer].maximalwert := spannungsbereich [2];{} kanal [kanalnummer].betriebsart := kanalparameter [1];{} kanal [kanalnummer].taktzahl := kanalparameter [2];{} kanal [kanalnummer].steuercode := interface anpassung{} + (kanalnummer, kanalparameter [3]){}END PROC trage kanaldaten ein;{}PROC beende kanaldaten eintragen:{} loesche interface task;{} begin (PROC kanal koppler, interface task);{} kanaldaten sind eingetragen := TRUE.{} loesche interface task:{} disable stop;{} end (interface task);{} IF is error{} THEN clear error{} FI;{} enable stop.{}END PROC beende kanaldaten eintragen;{}PROC hole spannungsbereich (INT CONST kanalnummer, REAL VAR u min, u max):{} + u min := spannung [kanalnummer].minimalwert;{} u max := spannung [kanalnummer].maximalwert{}END PROC hole spannungsbereich;{}INT PROC letzte ausgabe (INT CONST kanalnummer):{} vorherige ausgabe [kanalnummer]{}END PROC letzte ausgabe;{}PROC pruefe kanal (INT CONST kanalnummer, gewuenschte betriebsart):{} pruefe abbruch;{} pruefe kanalnummer;{} pruefe betriebsart.{} pruefe kanalnummer:{} IF kanalnummer < 1 OR kanalnummer > max kanalanzahl{} THEN errorstop ("Kanalnummer " + text (kanalnummer) +{} + " ist unzulaessig !"){} FI.{} pruefe betriebsart:{} IF gewuenschte betriebsart <> kanal [kanalnummer].betriebsart{} THEN errorstop ("An Kanal " + text (kanalnummer) +{} " keine " + wunsch + " moeglich!"){} FI.{} wunsch:{} IF gewuenschte betriebsart = analog aus{} THEN "Analog-Ausgabe"{} ELIF gewuenschte betriebsart = digital aus{} THEN "Digital-Ausgabe"{} ELIF gewuenschte betriebsart = digital ein{} THEN "Digital-Eingabe"{} + ELIF gewuenschte betriebsart = analog ein{} THEN "Analog-Eingabe"{} ELSE "Ein- oder Ausgabe"{} FI.{}END PROC pruefe kanal;{}PROC pruefe abbruch:{} IF incharety = esc{} THEN pruefe weiter{} FI.{} pruefe weiter:{} TEXT CONST zeichen :: incharety (30);{} IF zeichen = endezeichen{} THEN endezeichen gegeben := TRUE{} ELIF zeichen = abbruchzeichen{} THEN errorstop ("Programm-Abbruch durch <ESC><"{} + abbruchzeichen + ">!"){} + FI.{}END PROC pruefe abbruch;{}PROC oeffne interface (INT VAR status):{} enable stop;{} forget (ds); ds := nilspace;{} IF kanaldaten sind eingetragen{} THEN pingpong (interfacetask, initcode, ds, status){} ELSE status := configuration error code{} FI;{} IF status > 0 THEN status DECR maxint FI;{} forget (ds); ds := nilspace{}END PROC oeffne interface;{}PROC schliesse interface:{} enable stop;{} forget (ds); ds := nilspace;{} pingpong (interface task, end code, ds, dummy);{} forget (ds); ds := nilspace{} +END PROC schliesse interface;{}PROC teste interface:{} INT VAR test;{} oeffne interface (test);{} IF test < 0{} THEN errorstop (fehlermeldung [min (5, abs (test))]){} ELSE fehler zu melden := FALSE;{} endezeichen gegeben := FALSE{} FI{}END PROC teste interface;{}PROC fehlerbehandlung:{} meldung := errormessage;{} IF meldung <> ""{} THEN meldung CAT fehlerzeile;{} fehler zu melden := TRUE{} FI;{} clear error;{} initialisiere interface.{} fehlerzeile:{} + IF errorline = 0{} THEN ""{} ELSE " (bei Zeile " + text (errorline) + ")"{} FI.{}END PROC fehlerbehandlung;{}(******************** EIN-/AUSGABE AM INTERFACE-KANAL ********************){}PROC kanalkoppler:{} IF name (myself) <> "-"{} THEN errorstop ("Unzulässiges Kommando!"){} ELSE warte auf anrufe{} FI.{} warte auf anrufe:{} TASK VAR absender;{} TEXT VAR dummy;{} INT VAR codenummer, antwort;{} disable stop;{} REP forget (ds);{} wait (ds, codenummer, absender);{} + IF codenummer = initcode{} THEN kopple an interface kanal;{} IF interface ist betriebsbereit{} THEN bearbeite weitere auftraege{} ELSE gib negative rueckmeldung{} FI;{} gib kanal frei{} ELSE antwort := not init code;{} gib negative rueckmeldung{} FI{} PER.{} kopple an interface kanal:{} continue (interface channel);{} IF is error{} THEN clear error;{} antwort := kanal besetzt code{} + ELSE oeffne interface direkt (antwort){} FI.{} interface ist betriebsbereit: antwort = 0.{} gib negative rueckmeldung: send (absender, antwort, ds).{} gib kanal frei:{} break (quiet);{} send (absender, 0, ds, antwort);{} collect heap garbage.{} bearbeite weitere auftraege:{} REP call (absender, antwort, ds, codenummer);{} IF codenummer > 255{} THEN sende wert an interface{} ELIF codenummer < 50{} THEN hole wert von interface{} ELIF codenummer = alles aus code{} + THEN initialisiere interface direkt{} FI{} UNTIL codenummer = endcode PER;{} IF is error THEN clear error FI;{} schliesse interface direkt.{} sende wert an interface:{} out (kanal [codenummer DIV 256].steuercode);{} out (code (codenummer)).{} hole wert von interface:{} out (kanal [codenummer].steuercode);{} SELECT kanal [codenummer].taktzahl OF{} CASE 1 : antwort := erstes zeichen{} CASE 2 : antwort := zweites zeichen{} CASE 3 : antwort := drittes zeichen{} + OTHERWISE antwort := -1{} END SELECT.{} erstes zeichen:{} code (incharety (1)).{} zweites zeichen:{} dummy := incharety (1);{} code (incharety (1)).{} drittes zeichen:{} dummy := incharety (1);{} dummy := incharety (1);{} code (incharety (1)).{}END PROC kanalkoppler;{}PROC interface kanal (INT CONST kanalnummer):{} enable stop;{} IF kanalnummer < 1 OR kanalnummer > 24{} THEN errorstop ("Unzulaessige Kanalnummer"){} ELSE interface channel := kanalnummer{} + FI{}END PROC interface kanal;{}INT PROC interface kanal:{} interface channel{}END PROC interface kanal;{}PROC oeffne interface direkt (INT VAR status):{} leere puffer;{} out (interface test code);{} fange antwort;{} IF antwort = interface okay code{} THEN status := 0;{} out (interface open code){} ELSE status := interface error code{} FI.{} leere puffer:{} REP UNTIL incharety = "" PER.{} fange antwort:{} INT VAR zaehler;{} TEXT VAR antwort :: "";{} FOR zaehler FROM 1 UPTO erwartete zeichen REP{} + antwort CAT incharety (1){} PER.{}END PROC oeffne interface direkt;{}PROC schliesse interface direkt:{} out (interface close code){}END PROC schliesse interface direkt;{}PROC initialisiere interface direkt:{} schalte alles aus.{} schalte alles aus:{} INT VAR kanalnummer, kanalbetriebsart;{} FOR kanalnummer FROM 1 UPTO max kanalanzahl REP{} kanalbetriebsart := kanal [kanalnummer].betriebsart;{} IF kanalbetriebsart = digital aus{} THEN direkt ausgeben (kanalnummer, 0){} + ELIF kanalbetriebsart = analog aus{} THEN direkt ausgeben (kanalnummer, gewandelte nullspannung){} FI{} PER.{} gewandelte nullspannung:{} int(- real (ganzzahl obergrenze) * u min / (u max - u min) + 0.5).{} u max : spannung [kanalnummer].maximalwert.{} u min : spannung [kanalnummer].minimalwert.{}END PROC initialisiere interface direkt;{}PROC direkt ausgeben (INT CONST kanalnummer, wert):{} out (kanal [kanalnummer].steuercode);{} out (code (wert)){}END PROC direkt ausgeben;{} +INT PROC direkt eingabe (INT CONST kanalnummer):{} gib lesecode aus;{} erhaltene antwort.{} gib lesecode aus:{} out (kanal [kanalnummer].steuercode).{} erhaltene antwort:{} TEXT VAR dummy;{} SELECT kanal [kanalnummer].taktzahl OF{} CASE 1 : erstes zeichen{} CASE 2 : zweites zeichen{} CASE 3 : drittes zeichen{} OTHERWISE -1{} END SELECT.{} erstes zeichen:{} code (incharety (1)).{} zweites zeichen:{} dummy := incharety (1);{} code (incharety (1)).{} + drittes zeichen:{} dummy := incharety (1);{} dummy := incharety (1);{} code (incharety (1)).{}END PROC direkt eingabe;{}PROC initialisiere die kanaele:{} INT VAR kanalnummer;{} FOR kanalnummer FROM 1 UPTO max kanalanzahl REP{} trage kanaldaten ein (kanalnummer, keine spannung, leere karte);{} vorherige ausgabe [kanalnummer] := 0{} PER.{} keine spannung:{} ROW 2 REAL : (0.0, 0.0).{} leere karte:{} ROW 3 INT : (nicht belegt, 0, 0).{}END PROC initialisiere die kanaele;{} +initialisiere die kanaele;{}END PACKET ls prozess 1{} + diff --git a/app/gs.process/1.02/src/ls-Prozess 1 für MUFI im Terminalkanal b/app/gs.process/1.02/src/ls-Prozess 1 für MUFI im Terminalkanal new file mode 100644 index 0000000..d1edbc1 --- /dev/null +++ b/app/gs.process/1.02/src/ls-Prozess 1 für MUFI im Terminalkanal @@ -0,0 +1,55 @@ +(* + + ********************************************************** + ********************************************************** + ** ** + ** ls-Prozess 1 ** + ** ** + ** Anpassung für MUFI im Terminalkanal ** + ** ** + ** Version 1.02 ** + ** ** + ** (Stand : 26.01.90) ** + ** ** + ** ** + ** Autoren: Bruno Pollok, Bielefeld ** + ** Wolfgang Weber, Bielefeld ** + ** ** + ** Copyright (C) 1988 Eva Latta-Weber, Bielefeld ** + ** Copyright (C) 1990 ERGOS GmbH, Siegburg ** + ********************************************************** + ********************************************************** + + *) +PACKET altes incharety DEFINES old incharety: +TEXT PROC old incharety:{} incharety{}END PROC old incharety;{}TEXT PROC old incharety (INT CONST timelimit):{} incharety (timelimit){}END PROC old incharety;{}END PACKET altes incharety;{}PACKET ls prozess 1 DEFINES{} run pdv,{} run pdv again,{} initialisiere interface,{} ausgeben,{} eingabe,{} warte,{} abbruch gewuenscht,{} tue nichts,{} trage kanaldaten ein,{} beende kanaldaten eintragen,{} hole spannungsbereich,{} letzte ausgabe,{} + pruefe kanal,{} pruefe abbruch,{} teste interface,{} schalte alles aus,{} oeffne interface,{} schliesse interface,{} nicht belegt,{} digital aus,{} analog aus,{} digital ein,{} analog ein,{} kanalbreite,{} ganzzahl obergrenze,{} adapterart,{} incharety,{} inchar,{} pause:{}(******************** A N P A S S U N G A N M U F I ********************){}LET mufikennung = ""31""31"",{} erwartete zeichen = 4 ;{} +TEXT CONST adapterart :: "MUFI im Terminalkanal",{} interface test code :: ""27""27"10",{} interface okay code :: ""27""27"00",{} interface open code :: ""27""27"1C" + hex (mufikennung),{} interface close code :: mufikennung + "1C" + hex (""27""27""),{} adresse 0 code :: mufikennung + "3D",{} leertakt code :: mufikennung + "3E",{} interface write code :: mufikennung + "5" ,{} interface read code :: mufikennung + "4" ;{} +TEXT VAR puffer :: "";{}ROW 256 TEXT CONST hexcode :: ROW 256 TEXT : ({}"00","01","02","03","04","05","06","07","08","09","0A","0B","0C","0D","0E","0F",{}"10","11","12","13","14","15","16","17","18","19","1A","1B","1C","1D","1E","1F",{}"20","21","22","23","24","25","26","27","28","29","2A","2B","2C","2D","2E","2F",{}"30","31","32","33","34","35","36","37","38","39","3A","3B","3C","3D","3E","3F",{}"40","41","42","43","44","45","46","47","48","49","4A","4B","4C","4D","4E","4F",{}"50","51","52","53","54","55","56","57","58","59","5A","5B","5C","5D","5E","5F",{} +"60","61","62","63","64","65","66","67","68","69","6A","6B","6C","6D","6E","6F",{}"70","71","72","73","74","75","76","77","78","79","7A","7B","7C","7D","7E","7F",{}"80","81","82","83","84","85","86","87","88","89","8A","8B","8C","8D","8E","8F",{}"90","91","92","93","94","95","96","97","98","99","9A","9B","9C","9D","9E","9F",{}"A0","A1","A2","A3","A4","A5","A6","A7","A8","A9","AA","AB","AC","AD","AE","AF",{}"B0","B1","B2","B3","B4","B5","B6","B7","B8","B9","BA","BB","BC","BD","BE","BF",{}"C0","C1","C2","C3","C4","C5","C6","C7","C8","C9","CA","CB","CC","CD","CE","CF",{} +"D0","D1","D2","D3","D4","D5","D6","D7","D8","D9","DA","DB","DC","DD","DE","DF",{}"E0","E1","E2","E3","E4","E5","E6","E7","E8","E9","EA","EB","EC","ED","EE","EF",{}"F0","F1","F2","F3","F4","F5","F6","F7","F8","F9","FA","FB","FC","FD","FE","FF");{}TEXT PROC interface anpassung (INT CONST kanalnummer, steuerungscode):{} LET hexzeichen = "0123456789ABCDEF";{} IF es ist ein ausgabekanal{} THEN interface write code{} + (hexzeichen SUB (device + 4 * steuerungscode)){} ELIF es ist ein eingabekanal{} + THEN lesecode in abhaengigkeit von der taktzahl{} ELSE ""{} FI.{} es ist ein ausgabekanal:{} kanal [kanalnummer].betriebsart < 0.{} es ist ein eingabekanal:{} kanal [kanalnummer].betriebsart > 0.{} device:{} IF kanalnummer < 10{} THEN 1{} ELSE kanalnummer DIV 10{} FI.{} lesecode in abhaengigkeit von der taktzahl:{} SELECT kanal [kanalnummer].taktzahl OF{} CASE 1: lesecode{} CASE 2: adresse 0 code + lesecode + lesecode{} CASE 3: adresse 0 code + lesecode + zwei weitere takte{} + OTHERWISE "" END SELECT.{} lesecode:{} interface read code + (hexzeichen SUB (device + 4 * steuerungscode)).{} zwei weitere takte:{} IF leertakt code = ""{} THEN lesecode + lesecode{} ELSE kanal [kanalnummer].taktzahl DECR 1;{} leertakt code + lesecode{} FI.{}END PROC interface anpassung;{}PROC ausgeben (INT CONST kanalnummer, wert):{} merke wert;{} gib wert aus.{} merke wert:{} vorherige ausgabe [kanalnummer] := wert.{} gib wert aus:{} out (kanal [kanalnummer].steuercode);{} + out (hexcode [wert + 1]).{}END PROC ausgeben;{}INT PROC eingabe (INT CONST kanalnummer):{} gib lesecode aus;{} erhaltene antwort.{} gib lesecode aus:{} out (kanal [kanalnummer].steuercode).{} erhaltene antwort:{} TEXT VAR dummy;{} SELECT kanal [kanalnummer].taktzahl OF{} CASE 1 : erste sendung{} CASE 2 : zweite sendung{} CASE 3 : dritte sendung{} OTHERWISE -1{} END SELECT.{} erste sendung:{} fange mufikennung;{} dezimalwert (old incharety (1), old incharety (1)).{} + zweite sendung:{} fange mufikennung;{} dummy := old incharety (1);{} dummy := old incharety (1);{} erste sendung.{} dritte sendung:{} fange mufikennung;{} dummy := old incharety (1);{} dummy := old incharety (1);{} zweite sendung.{} fange mufikennung:{} puffer CAT old incharety;{} REP puffer CAT old incharety{} UNTIL pos (puffer, mufikennung) > 0 PER;{} puffer := subtext (puffer, 1, length (puffer) - 2).{}END PROC eingabe;{}(************ H A R D W A R E U N A B H Ä N G I G E R T E I L ************){} +LET max kanalanzahl = 49,{} endezeichen = "q",{} abbruchzeichen = "h",{} esc = ""27"";{}INT CONST analog aus :: -2, (* Betriebsarten *){} digital aus :: -1,{} nicht belegt :: 0,{} digital ein :: 1,{} analog ein :: 2,{} kanalbreite :: 8,{} ganzzahl obergrenze :: 2 ** kanalbreite,{} + configuration error code :: -1,{} interface error code :: -4;{}TEXT VAR meldung :: "";{}BOOL VAR kanaldaten sind eingetragen :: FALSE,{} endezeichen gegeben :: FALSE,{} programm mit pdv gestartet :: FALSE,{} fehler zu melden :: FALSE;{}TYPE KANAL = STRUCT (INT betriebsart, taktzahl, TEXT steuercode),{} SPANNUNG = STRUCT (REAL minimalwert, maximalwert);{}ROW max kanalanzahl INT VAR vorherige ausgabe;{} +ROW max kanalanzahl KANAL VAR kanal;{}ROW max kanalanzahl SPANNUNG VAR spannung;{}PROC run pdv:{} run pdv (last param){}END PROC run pdv;{}PROC run pdv (TEXT CONST programmname):{} enable stop;{} last param (programmname);{} programm mit pdv gestartet := TRUE;{} teste interface;{} disable stop;{} run (programmname);{} IF is error{} THEN fehlerbehandlung{} ELSE melde programmende{} FI;{} schliesse interface;{} programm mit pdv gestartet := FALSE;{} enable stop;{} IF fehler zu melden{} + THEN errorstop (meldung){} FI{}END PROC run pdv;{}PROC run pdv again:{} enable stop;{} programm mit pdv gestartet := TRUE;{} teste interface;{} disable stop;{} run again;{} IF is error{} THEN fehlerbehandlung{} ELSE melde programmende{} FI;{} schliesse interface;{} programm mit pdv gestartet := FALSE;{} enable stop;{} IF fehler zu melden{} THEN errorstop (meldung){} FI{}END PROC run pdv again;{}PROC melde programmende:{} page;{} menufootnote ("Programmende! Zum Weitermachen bitte irgendeine Taste tippen.");{} + pause;{} schalte alles aus{}END PROC melde programmende;{}PROC initialisiere interface:{} enable stop;{} pruefe abbruch;{} IF programm mit pdv gestartet{} THEN schalte alles aus{} ELSE errorstop ("PDV-Programme müssen mit 'run pdv' gestartet werden!"){} FI{}END PROC initialisiere interface;{}PROC schalte alles aus:{} INT VAR kanalnummer, kanalbetriebsart;{} FOR kanalnummer FROM 1 UPTO max kanalanzahl REP{} kanalbetriebsart := kanal [kanalnummer].betriebsart;{} IF kanalbetriebsart = digital aus{} + THEN ausgeben (kanalnummer, 0){} ELIF kanalbetriebsart = analog aus{} THEN ausgeben (kanalnummer, gewandelte nullspannung){} FI{} PER.{} gewandelte nullspannung:{} int(- real (ganzzahl obergrenze) * u min / (u max - u min) + 0.5).{} u max : spannung [kanalnummer].maximalwert.{} u min : spannung [kanalnummer].minimalwert.{}END PROC schalte alles aus;{}PROC warte (REAL CONST sekunden):{} TEXT VAR eingabe;{} pruefe abbruch;{} eingabe := incharety (int (sekunden * 10.0 + 0.5));{} + IF eingabe = esc{} THEN untersuche naechstes zeichen{} FI.{} untersuche naechstes zeichen:{} eingabe := incharety (30);{} IF eingabe = endezeichen{} THEN endezeichen gegeben := TRUE{} ELIF eingabe = abbruchzeichen{} THEN errorstop ("Programm-Abbruch durch <ESC><"{} + abbruchzeichen + ">!"){} FI.{}END PROC warte;{}PROC warte (INT CONST sekunden):{} TEXT VAR eingabe;{} pruefe abbruch;{} eingabe := incharety (sekunden * 10);{} IF eingabe = esc{} + THEN untersuche naechstes zeichen{} FI.{} untersuche naechstes zeichen:{} eingabe := incharety (30);{} IF eingabe = endezeichen{} THEN endezeichen gegeben := TRUE{} ELIF eingabe = abbruchzeichen{} THEN errorstop ("Programm-Abbruch durch <ESC><"{} + abbruchzeichen + ">!"){} FI.{}END PROC warte;{}TEXT PROC incharety:{} IF puffer = ""{} THEN old incharety{} ELSE erstes zeichen von puffer{} FI.{} erstes zeichen von puffer:{} TEXT CONST zeichen :: puffer SUB 1;{} + puffer := subtext (puffer, 2);{} zeichen.{}END PROC incharety;{}TEXT PROC incharety (INT CONST timelimit):{} IF puffer = ""{} THEN old incharety (timelimit){} ELSE erstes zeichen von puffer{} FI.{} erstes zeichen von puffer:{} TEXT CONST zeichen :: puffer SUB 1;{} puffer := subtext (puffer, 2);{} zeichen.{}END PROC incharety;{}PROC inchar (TEXT VAR character):{} REP character := incharety{} UNTIL character <> "" PER{}END PROC inchar;{}PROC pause:{} TEXT VAR dummy;{} inchar (dummy){} +END PROC pause;{}PROC pause (INT CONST timelimit):{} TEXT VAR dummy := incharety (timelimit){}END PROC pause;{}BOOL PROC abbruch gewuenscht:{} pruefe abbruch;{} BOOL VAR entscheidung :: endezeichen gegeben;{} endezeichen gegeben := FALSE;{} entscheidung{}END PROC abbruch gewuenscht;{}PROC tue nichts:{} pruefe abbruch{}END PROC tue nichts;{}PROC trage kanaldaten ein (INT CONST kanalnummer,{} ROW 2 REAL CONST spannungsbereich,{} ROW 3 INT CONST kanalparameter):{} + spannung [kanalnummer].minimalwert := spannungsbereich [1];{} spannung [kanalnummer].maximalwert := spannungsbereich [2];{} kanal [kanalnummer].betriebsart := kanalparameter [1];{} kanal [kanalnummer].taktzahl := kanalparameter [2];{} kanal [kanalnummer].steuercode := interface anpassung{} (kanalnummer, kanalparameter [3]){}END PROC trage kanaldaten ein;{}PROC beende kanaldaten eintragen:{} kanaldaten sind eingetragen := TRUE{}END PROC beende kanaldaten eintragen;{} +PROC hole spannungsbereich (INT CONST kanalnummer, REAL VAR u min, u max):{} u min := spannung [kanalnummer].minimalwert;{} u max := spannung [kanalnummer].maximalwert{}END PROC hole spannungsbereich;{}INT PROC letzte ausgabe (INT CONST kanalnummer):{} vorherige ausgabe [kanalnummer]{}END PROC letzte ausgabe;{}PROC pruefe kanal (INT CONST kanalnummer, gewuenschte betriebsart):{} pruefe abbruch;{} pruefe kanalnummer;{} pruefe betriebsart.{} pruefe kanalnummer:{} IF kanalnummer < 1 OR kanalnummer > max kanalanzahl{} + THEN errorstop ("Kanalnummer " + text (kanalnummer) +{} " ist unzulaessig !"){} FI.{} pruefe betriebsart:{} IF gewuenschte betriebsart <> kanal [kanalnummer].betriebsart{} THEN errorstop ("An Kanal " + text (kanalnummer) +{} " keine " + wunsch + " moeglich!"){} FI.{} wunsch:{} IF gewuenschte betriebsart = analog aus{} THEN "Analog-Ausgabe"{} ELIF gewuenschte betriebsart = digital aus{} THEN "Digital-Ausgabe"{} + ELIF gewuenschte betriebsart = digital ein{} THEN "Digital-Eingabe"{} ELIF gewuenschte betriebsart = analog ein{} THEN "Analog-Eingabe"{} ELSE "Ein- oder Ausgabe"{} FI.{}END PROC pruefe kanal;{}PROC pruefe abbruch:{} TEXT VAR zeichen :: incharety;{} IF zeichen = esc{} THEN pruefe weiter{} FI.{} pruefe weiter:{} zeichen := incharety (30);{} IF zeichen = endezeichen{} THEN endezeichen gegeben := TRUE{} ELIF zeichen = abbruchzeichen{} THEN errorstop ("Programm-Abbruch durch <ESC><"{} + + abbruchzeichen + ">!"){} FI.{}END PROC pruefe abbruch;{}PROC oeffne interface (INT VAR status):{} enable stop;{} IF kanaldaten sind eingetragen{} THEN teste interface funktion{} ELSE status := configuration error code{} FI.{} teste interface funktion:{} leere puffer;{} out (interface test code);{} fange antwort;{} IF antwort = interface okay code{} THEN status := 0;{} out (interface open code){} ELSE status := interface error code{} + FI.{} leere puffer:{} puffer := "";{} REP UNTIL old incharety = "" PER.{} fange antwort:{} INT VAR zaehler;{} TEXT VAR antwort :: "";{} FOR zaehler FROM 1 UPTO erwartete zeichen REP{} antwort CAT old incharety (1){} PER.{}END PROC oeffne interface;{}PROC schliesse interface:{} enable stop;{} out (interface close code){}END PROC schliesse interface;{}(********************* H I L F S P R O Z E D U R E N *********************){}PROC teste interface:{} INT VAR test;{} + warte etwas;{} oeffne interface (test);{} IF test < 0{} THEN errorstop (fehlermeldung){} ELSE endezeichen gegeben := FALSE;{} fehler zu melden := FALSE{} FI.{} warte etwas:{} pause (1); pause (1); pause (1); pause (1); pause (1).{} fehlermeldung:{} IF test = configuration error code{} THEN "Interface ist noch nicht konfiguriert!"{} ELIF test = interface error code{} THEN "Interface meldet sich nicht!"{} ELSE "Interface kann nicht geöffnet werden!"{} + FI.{}END PROC teste interface;{}PROC fehlerbehandlung:{} meldung := errormessage;{} IF meldung <> ""{} THEN meldung CAT fehlerzeile;{} fehler zu melden := TRUE{} FI;{} clear error;{} initialisiere interface.{} fehlerzeile:{} IF errorline = 0{} THEN ""{} ELSE " (bei Zeile " + text (errorline) + ")"{} FI.{}END PROC fehlerbehandlung;{}INT PROC dezimalwert (TEXT CONST zeichen 1, zeichen 2):{} 16 * pos (hexzeichen, zeichen 1) + pos (hexzeichen, zeichen 2).{} hexzeichen: "123456789ABCDEF".{} +END PROC dezimalwert;{}TEXT PROC hex (TEXT CONST zwei zeichen):{} hex (code (zwei zeichen SUB 1)) + hex (code (zwei zeichen SUB 2)){}END PROC hex;{}TEXT PROC hex (INT CONST wert):{} (hexzeichen SUB (wert DIV 16 + 1)) + (hexzeichen SUB (wert MOD 16 + 1)).{} hexzeichen: "0123456789ABCDEF".{}END PROC hex;{}PROC initialisiere die kanaele:{} INT VAR kanalnummer;{} FOR kanalnummer FROM 1 UPTO max kanalanzahl REP{} trage kanaldaten ein (kanalnummer, keine spannung, leere karte);{} vorherige ausgabe [kanalnummer] := 0{} + PER.{} keine spannung:{} ROW 2 REAL : (0.0, 0.0).{} leere karte:{} ROW 3 INT : (nicht belegt, 0, 0).{}END PROC initialisiere die kanaele;{}initialisiere die kanaele{}END PACKET ls prozess 1{} + diff --git a/app/gs.process/1.02/src/ls-Prozess 2 b/app/gs.process/1.02/src/ls-Prozess 2 new file mode 100644 index 0000000..11cb4e7 --- /dev/null +++ b/app/gs.process/1.02/src/ls-Prozess 2 @@ -0,0 +1,39 @@ +(* + + ********************************************************** + ********************************************************** + ** ** + ** ls-Prozess 2 ** + ** ** + ** Version 1.02 ** + ** ** + ** (Stand : 06.06.89) ** + ** ** + ** ** + ** ** + ** Autoren: Bruno Pollok, Bielefeld ** + ** Wolfgang Weber, Bielefeld ** + ** ** + ** ** + ** Copyright (C) 1988 Eva Latta-Weber, Bielefeld ** + ** Copyright (C) 1990 ERGOS GmbH, Siegburg ** + ********************************************************** + ********************************************************** + + *) +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{} + diff --git a/app/gs.process/1.02/src/ls-Prozess 3 b/app/gs.process/1.02/src/ls-Prozess 3 new file mode 100644 index 0000000..28ef825 --- /dev/null +++ b/app/gs.process/1.02/src/ls-Prozess 3 @@ -0,0 +1,26 @@ +(* + + ********************************************************** + ********************************************************** + ** ** + ** ls-Prozess 3 ** + ** ** + ** Version 1.02 ** + ** ** + ** (Stand : 06.06.89) ** + ** ** + ** ** + ** ** + ** Autoren: Bruno Pollok, Bielefeld ** + ** Wolfgang Weber, Bielefeld ** + ** ** + ** ** + ** Copyright (C) 1988 Eva Latta-Weber, Bielefeld ** + ** Copyright (C) 1990 ERGOS GmbH, Siegburg ** + ********************************************************** + ********************************************************** + + *) +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{} + diff --git a/app/gs.process/1.02/src/ls-Prozess 4 b/app/gs.process/1.02/src/ls-Prozess 4 new file mode 100644 index 0000000..158b548 --- /dev/null +++ b/app/gs.process/1.02/src/ls-Prozess 4 @@ -0,0 +1,61 @@ +(* + + ********************************************************** + ********************************************************** + ** ** + ** ls-Prozess 4 ** + ** ** + ** Version 1.02 ** + ** ** + ** (Stand : 26.01.90) ** + ** ** + ** ** + ** ** + ** Autoren: Bruno Pollok, Bielefeld ** + ** Wolfgang Weber, Bielefeld ** + ** ** + ** ** + ** Copyright (C) 1988 Eva Latta-Weber, Bielefeld ** + ** Copyright (C) 1990 ERGOS GmbH, Siegburg ** + ********************************************************** + ********************************************************** + + *) +PACKET ls prozess 4 DEFINES + pdv befehlsuebersicht anzeigen,{} pdv ausgabebefehle anzeigen,{} pdv eingabebefehle anzeigen,{} pdv testbefehle anzeigen,{} pdv weitere befehle anzeigen,{} pdv bitmuster erlaeutern,{} pdv symbole erlaeutern,{} pdv digital analog werte,{} pdv programm neu erstellen,{} pdv programm ansehen,{} pdv programm starten,{} pdv programm wiederholen,{} pdv dateien verzeichnis,{} + pdv datei kopieren,{} pdv datei umbenennen,{} pdv dateien loeschen,{} pdv dateien drucken,{} init pdv,{} pdv:{}LET menukarte = "ls-MENUKARTE:Prozess",{} niltext = "",{} maxlaenge = 45,{} maxnamenslaenge = 35;{}WINDOW VAR w :: window (1, 3, 79, 19);{}TEXT VAR programmname :: "";{}BOOL VAR noch kein programm gelaufen :: TRUE;{}PROC pdv:{} init pdv;{} install menu (menukarte, FALSE);{} + handle menu ("PDV"){}END PROC pdv;{}PROC init pdv:{} programmname := "";{} noch kein programm gelaufen := TRUE;{} cursor off;{}END PROC init pdv;{}PROC pdv befehlsuebersicht anzeigen:{} menuinfo (anwendungstext (20)){}END PROC pdv befehlsuebersicht anzeigen;{}PROC pdv ausgabebefehle anzeigen:{} INT VAR i;{} REP{} i := menualternative (anwendungstext (1), anwendungstext (3),{} anwendungstext (4), 5, TRUE);{} SELECT i OF{} CASE 1, 101: menuinfo (anwendungstext (21)){} + CASE 2, 102: menuinfo (anwendungstext (22)){} CASE 3, 103: menuinfo (anwendungstext (23)){} CASE 4, 104: menuinfo (anwendungstext (24)){} CASE 5, 105: menuinfo (anwendungstext (25)){} END SELECT{} UNTIL i = 6 OR i = 106 PER;{}END PROC pdv ausgabebefehle anzeigen;{}PROC pdv eingabebefehle anzeigen:{} INT VAR i;{} REP{} i := menualternative (anwendungstext (2), anwendungstext (3),{} anwendungstext (4), 5, TRUE);{} SELECT i OF{} CASE 1, 101: menuinfo (anwendungstext (31)){} + CASE 2, 102: menuinfo (anwendungstext (32)){} CASE 3, 103: menuinfo (anwendungstext (33)){} CASE 4, 104: menuinfo (anwendungstext (34)){} CASE 5, 105: menuinfo (anwendungstext (35)){} END SELECT{} UNTIL i = 6 OR i = 106 PER;{}END PROC pdv eingabebefehle anzeigen;{}PROC pdv testbefehle anzeigen:{} INT VAR i;{} REP{} i := menualternative (anwendungstext (5), anwendungstext (7),{} anwendungstext (8), 5, TRUE);{} SELECT i OF{} CASE 1, 101: menuinfo (anwendungstext (41)){} + CASE 2, 102: menuinfo (anwendungstext (42)){} END SELECT{} UNTIL i = 3 OR i = 103 PER;{}END PROC pdv testbefehle anzeigen;{}PROC pdv weitere befehle anzeigen:{} INT VAR i;{} REP{} i := menualternative (anwendungstext (6), anwendungstext (7),{} anwendungstext (8), 5, TRUE);{} SELECT i OF{} CASE 1, 101: menuinfo (anwendungstext (43)){} CASE 2, 102: menuinfo (anwendungstext (44)){} END SELECT{} UNTIL i = 3 OR i = 103 PER;{}END PROC pdv weitere befehle anzeigen;{} +PROC pdv bitmuster erlaeutern:{} menuinfo (anwendungstext (46)){}END PROC pdv bitmuster erlaeutern;{}PROC pdv symbole erlaeutern:{} menuinfo (anwendungstext (47)){}END PROC pdv symbole erlaeutern;{}PROC pdv digital analog werte:{} menuinfo (anwendungstext (48)){}END PROC pdv digital analog werte;{}PROC pdvdateien verzeichnis:{} disable stop;{} forget ("Verzeichnis der Dateien", quiet);{} THESAURUS VAR programme :: ALL myself;{} FILE VAR f ::{} sequential file (output, "Verzeichnis der Dateien");{} + f FILLBY programme;{} modify (f);{} to line (f, 1); insert record (f);{} menufootnote ("Verlassen: <ESC> <q>");{} cursor on;{} show (w, f);{} cursor off;{} forget ("Verzeichnis der Dateien", quiet);{} IF is error{} THEN regenerate menuscreen;{} out (""7"");{} menuinfo (" " + invers ("FEHLER: " + errormessage));{} clear error{} ELSE menu bildschirm{} FI;{} enable stop{}END PROC pdvdateien verzeichnis;{}PROC pdvprogramm neu erstellen:{} hole programmname;{} + kontrolliere den programmnamen;{} command dialogue (FALSE);{} cursor on;{} disable stop;{} stdinfoedit (programmname, 3);{} cursor off;{} command dialogue (TRUE);{} IF is error{} THEN regenerate menuscreen;{} out (""7"");{} menuinfo (" " + invers (errormessage));{} clear error{} ELSE menu bildschirm{} FI;{} enable stop.{} hole programmname:{} programmname := "";{} programmname := menuanswer (ausgabe, programmname, 5).{} ausgabe:{} center (maxlaenge, invers ("Programm neu erstellen")) + ""13""13""{} + + " Bitte den Namen für das Programm "13""13"".{} kontrolliere den programmnamen:{} IF programmname = niltext{} THEN LEAVE pdvprogramm neu erstellen{} ELIF length (programmname) > maxnamenslaenge{} THEN meckere zu langen namen an;{} programmname := niltext;{} LEAVE pdvprogramm neu erstellen{} ELIF exists (programmname){} THEN meckere existierendes programm an;{} LEAVE pdvprogramm neu erstellen{} FI.{}END PROC pdvprogramm neu erstellen;{} +PROC pdvprogramm ansehen:{} IF programmname <> niltext CAND exists (programmname){} THEN frage nach diesem programm{} ELSE lasse programm auswaehlen{} FI;{} cursor on;{} disable stop;{} stdinfoedit (programmname, 3);{} cursor off;{} IF is error{} THEN regenerate menuscreen;{} out (""7"");{} menuinfo (" " + invers ("FEHLER: " + errormessage));{} clear error{} ELSE menu bildschirm{} FI;{} enable stop.{} frage nach diesem programm:{} IF menuno (ueberschrift + " Zuletzt bearbeitetes Programm: " + name{} + + " Soll mit diesem Programm gearbeitet werden", 5){} THEN lasse programm auswaehlen{} FI.{} ueberschrift:{} center (maxlaenge, invers ("Programm ansehen/ändern")) + ""13""13"".{} name:{} ""13""13" " + invers (programmname) + ""13""13"".{} lasse programm auswaehlen:{} THESAURUS VAR verfuegbare :: ALL myself;{} IF NOT not empty (verfuegbare){} THEN noch kein programm;{} LEAVE pdvprogramm ansehen{} ELSE biete auswahl an{} FI.{} biete auswahl an:{} + programmname := menuone (verfuegbare, "Programm ansehen/ändern",{} "Bitte das gewünschte Programm ankreuzen!",{} FALSE);{} IF programmname = niltext{} THEN menu bildschirm;{} LEAVE pdvprogramm ansehen{} FI.{}END PROC pdvprogramm ansehen;{}PROC pdvdateien drucken:{} lasse programme auswaehlen;{} drucke programme;{} menu bildschirm.{} lasse programme auswaehlen:{} THESAURUS VAR verfuegbare :: ALL myself;{} IF NOT not empty (verfuegbare){} + THEN noch kein programm;{} LEAVE pdvdateien drucken{} ELSE biete auswahl an{} FI.{} biete auswahl an:{} verfuegbare := menusome (verfuegbare, "Dateien drucken",{} "Bitte die Dateien ankreuzen, die gedruckt werden sollen!",{} FALSE).{} drucke programme:{} show menuwindow;{} steige ggf bei leerem thesaurus aus;{} menuwindowout (menuwindowcenter (invers ("Dateien drucken")));{} menuwindowline (2);{} command dialogue (FALSE);{} + fuehre einzelne operationen aus;{} command dialogue (TRUE);{} schlage ggf neue seite auf;{} menuwindowout (" Alle ausgewählten Dateien wurden gedruckt!");{} menuwindowstop.{} fuehre einzelne operationen aus:{} INT VAR k;{} FOR k FROM 1 UPTO highest entry (verfuegbare) REP{} IF name (verfuegbare, k) <> ""{} THEN disable stop;{} menuwindowout ( " """ + name (verfuegbare, k) +{} """ wird gedruckt!");{} menuwindowline;{} + print (name (verfuegbare, k));{} fehlerbehandlung{} FI{} PER.{} steige ggf bei leerem thesaurus aus:{} IF NOT not empty (verfuegbare){} THEN menuwindowline (2);{} menuwindowout (" Es wurde keine Datei ausgewählt!");{} menuwindowstop;{} menu bildschirm;{} LEAVE pdvdateien drucken{} FI.{} schlage ggf neue seite auf:{} IF remaining menuwindowlines < 7{} THEN menuwindowpage; menuwindowline{} ELSE menuwindowline (2){} + FI.{} fehlerbehandlung:{} IF is error{} THEN regenerate menuscreen; out (""7"");{} menuinfo (" " + invers (errormessage));{} clear error; enable stop;{} LEAVE pdvdateien drucken{} ELSE enable stop{} FI.{}END PROC pdvdateien drucken;{}PROC pdvdatei kopieren:{} ermittle alten programmnamen;{} erfrage neuen programmnamen;{} kopiere ggf das programm.{} ermittle alten programmnamen:{} IF NOT not empty (ALL myself){} THEN noch kein programm;{} + LEAVE pdvdatei kopieren{} ELSE biete auswahl an{} FI.{} biete auswahl an:{} TEXT VAR alter name := menuone (ALL myself, "Datei kopieren",{} "Bitte die Datei ankreuzen, das kopiert werden soll!",FALSE);{} menu bildschirm;{} IF alter name = niltext{} THEN LEAVE pdvdatei kopieren{} FI.{} erfrage neuen programmnamen:{} TEXT VAR neuer name :: menuanswer (ausgabe, alter name, 5).{} ausgabe:{} ueberschrift + " Name der 'alten' Datei: " + bisheriger name{} + + " Bitte den Namen für die Kopie: ".{} ueberschrift:{} center (maxlaenge, invers ("Datei kopieren")) + ""13""13"".{} bisheriger name:{} ""13""13" " + invers (alter name) + ""13""13"".{} kopiere ggf das programm:{} IF neuer name = niltext{} THEN menuinfo (" " + invers ("Der gewünschte Name ist unzulässig!"));{} LEAVE pdvdatei kopieren{} ELIF exists (neuer name){} THEN mache vorwurf;{} LEAVE pdvdatei kopieren{} ELSE copy (alter name, neuer name){} + FI.{} mache vorwurf:{} menuinfo (" " + invers ("Eine Datei mit diesem Namen gibt es bereits!")).{}END PROC pdvdatei kopieren;{}PROC pdvdatei umbenennen:{} ermittle alten programmnamen;{} erfrage neuen programmnamen;{} benenne ggf das programm um.{} ermittle alten programmnamen:{} IF NOT not empty (ALL myself){} THEN noch kein programm;{} LEAVE pdvdatei umbenennen{} ELSE biete auswahl an{} FI.{} biete auswahl an:{} TEXT VAR alter name := menuone ( ALL myself, "Datei umbenennen",{} + "Bitte die Datei ankreuzen, die umbenannt werden soll!", FALSE);{} menu bildschirm;{} IF alter name = niltext{} THEN LEAVE pdvdatei umbenennen{} FI.{} erfrage neuen programmnamen:{} TEXT VAR neuer name :: menuanswer (ausgabe, alter name, 5).{} ausgabe:{} ueberschrift + " Bisheriger Dateiname: " + bisheriger name{} + " Zukünftiger Dateiname: ".{} ueberschrift:{} center (maxlaenge, invers ("Datei umbenennen")) + ""13""13"".{} bisheriger name:{} + ""13""13" " + invers (alter name) + ""13""13"".{} benenne ggf das programm um:{} IF neuer name = niltext{} THEN menuinfo (" " + invers ("Der gewünschte Name ist unzulässig!"));{} LEAVE pdvdatei umbenennen{} ELIF exists (neuer name){} THEN mache vorwurf;{} LEAVE pdvdatei umbenennen{} ELSE rename (alter name, neuer name);{} programmname := neuer name{} FI.{} mache vorwurf:{} menuinfo (" " + invers ("Eine Datei mit diesem Namen gibt es bereits!")).{} +END PROC pdvdatei umbenennen;{}PROC pdvdateien loeschen:{} lasse programme auswaehlen;{} loesche programme;{} menu bildschirm.{} lasse programme auswaehlen:{} THESAURUS VAR verfuegbare :: ALL myself;{} IF NOT not empty (verfuegbare){} THEN noch kein programm;{} LEAVE pdvdateien loeschen{} ELSE biete auswahl an{} FI.{} biete auswahl an:{} verfuegbare := menusome (verfuegbare, "Dateien löschen",{} "Bitte alle Dateien ankreuzen, die gelöscht werden sollen!", FALSE).{} + loesche programme:{} show menuwindow;{} steige ggf bei leerem thesaurus aus;{} menuwindowout (menuwindowcenter (invers ("Dateien löschen")));{} menuwindowline (2);{} command dialogue (FALSE);{} fuehre einzelne operationen aus;{} command dialogue (TRUE);{} schlage ggf neue seite auf;{} menuwindowout (" Alle ausgewählten Dateien wurden gelöscht!");{} menuwindowstop.{} fuehre einzelne operationen aus:{} INT VAR k;{} FOR k FROM 1 UPTO highest entry (verfuegbare) REP{} + IF name (verfuegbare, k) <> ""{} THEN disable stop;{} IF menuwindowyes (" """ + name (verfuegbare, k) + """ löschen"){} THEN forget (name (verfuegbare, k), quiet){} FI;{} fehlerbehandlung{} FI{} PER;{} programmname := "".{} steige ggf bei leerem thesaurus aus:{} IF NOT not empty (verfuegbare){} THEN menuwindowline (2);{} menuwindowout (" Es wurde keine Datei ausgewählt!");{} menuwindowstop;{} + menu bildschirm;{} LEAVE pdvdateien loeschen{} FI.{} schlage ggf neue seite auf:{} IF remaining menuwindowlines < 7{} THEN menuwindowpage; menuwindowline{} ELSE menuwindowline (2){} FI.{} fehlerbehandlung:{} IF is error{} THEN regenerate menuscreen; out (""7"");{} menuinfo (" " + invers (errormessage));{} clear error; enable stop;{} LEAVE pdvdateien loeschen{} ELSE enable stop{} FI.{}END PROC pdvdateien loeschen;{} +PROC pdvprogramm starten:{} programmname ermitteln;{} bildschirm vorbereiten;{} cursor on;{} disable stop;{} warnings off;{} check on;{} run pdv (programmname);{} noch kein programm gelaufen := FALSE;{} cursor off;{} IF is error{} THEN fehler ggf melden;{} clear error{} ELSE regenerate menuscreen{} FI;{} enable stop.{} bildschirm vorbereiten:{} cursor (17, 2); out (waagerecht);{} cursor (38, 2); out (waagerecht);{} cursor ( 1, 3); out (""4"");{} menufootnote ("Programmabbruch: <ESC><h>");{} + cursor (1, 5);{} out ("Das Programm wird übersetzt. Zeilen-Nr.: ").{} fehler ggf melden:{} IF errormessage <> ""{} THEN fehler melden{} FI.{} fehler melden:{} IF pos (errormessage, "'halt' vom Terminal") > 0{} THEN regenerate menuscreen;{} out (""7""); menuinfo (" "15"'halt' vom Terminal "14""){} ELIF pos (errormessage, "Programm-Abbruch durch <ESC><h>") > 0{} THEN regenerate menuscreen;{} out (""7""); menuinfo (" "15"Programm-Abbruch durch <ESC><h> "14""){} + ELIF pos (errormessage, "(bei Zeile") > 0 AND exists (programmname){} THEN programm mit fehler im notebook zeigen;{} regenerate menuscreen{} ELSE regenerate menuscreen;{} out (""7""); menuinfo (" " + invers ("FEHLER: "{} + subtext (errormessage, 1, 61))){} FI.{} programm mit fehler im notebook zeigen:{} noteline;{} note ("FEHLER: " + errormessage);{} INT VAR n; FOR n FROM 1 UPTO 9 REP noteline PER;{} note (""15"Verlassen: <ESC><q> "14"");{} + FILE VAR p :: sequential file (modify, programmname);{} to line (p, max (1, fehlerzeile));{} col (1);{} clear error;{} out (""7"");{} cursor on;{} noteedit (p);{} cursor off.{} fehlerzeile:{} int (subtext (errormessage, zahlposition)).{} zahlposition: pos (errormessage, "(bei Zeile") + 10.{} programmname ermitteln:{} IF programmname <> niltext CAND exists (programmname){} THEN frage nach diesem programm{} ELSE lasse programm auswaehlen{} FI.{} frage nach diesem programm:{} + IF menuno (ueberschrift + " Zuletzt bearbeitetes Programm: " +{} name + " Soll mit diesem Programm gearbeitet werden", 5){} THEN lasse programm auswaehlen{} FI.{} ueberschrift:{} center (maxlaenge, invers ("Programm starten")) + ""13""13"".{} name:{} ""13""13" " + invers (programmname) + ""13""13"".{} lasse programm auswaehlen:{} THESAURUS VAR verfuegbare :: ALL myself;{} IF NOT not empty (verfuegbare){} THEN noch kein programm;{} LEAVE pdvprogramm starten{} + ELSE biete auswahl an{} FI.{} biete auswahl an:{} programmname := menuone (verfuegbare, "Programm starten",{} "Bitte das gewünschte Programm ankreuzen!", FALSE);{} IF programmname = niltext{} THEN menubildschirm;{} LEAVE pdv programm starten{} FI.{}END PROC pdvprogramm starten;{}PROC pdv programm wiederholen:{} bildschirm vorbereiten;{} cursor on;{} disable stop;{} IF noch kein programm gelaufen{} THEN errorstop ("Eine Wiederholung ist nicht moeglich!"){} + ELSE run pdv again{} FI;{} cursor off;{} regenerate menuscreen;{} IF is error{} THEN zeige fehler;{} clear error{} FI;{} enable stop.{} bildschirm vorbereiten:{} cursor (17, 2); out (waagerecht);{} cursor (38, 2); out (waagerecht);{} cursor ( 1, 3); out (""4"");{} menufootnote ("Programmabbruch: <ESC><h>");{} cursor (1,3).{} zeige fehler:{} out (""7"");{} IF errormessage = "'run again' nicht moeglich"{} THEN menuinfo (" "15"Eine Wiederholung ist nicht moeglich! "14""){} + ELIF pos (errormessage, "'halt' vom Terminal") > 0{} THEN menuinfo (" "15"'halt' vom Terminal "14""){} ELIF pos (errormessage, "Programm-Abbruch durch <ESC><h>") > 0{} THEN menuinfo (" "15"Programm-Abbruch durch <ESC><h> "14""){} ELSE menuinfo (" " + invers ("FEHLER: "{} + subtext (errormessage, 1, 61))){} FI.{}END PROC pdv programm wiederholen;{}PROC meckere zu langen namen an:{} menuinfo (" " + invers ("Hier dürfen Namen höchstens "{} + text (max namenslaenge){} + + " Zeichen lang sein!")){}END PROC meckere zu langen namen an;{}PROC meckere existierendes programm an:{} menuinfo (" " + invers ("Ein Programm mit diesem Namen gibt es bereits!")){}END PROC meckere existierendes programm an;{}PROC noch kein programm:{} menuinfo (" " + invers ("Es existiert noch kein Programm!")){}END PROC noch kein programm;{}PROC menu bildschirm:{} cursor (1, 2);{} out (5 * waagerecht);{} cursor (1, 3);{} out (""4"");{} cursor (1,23);{} out (79 * waagerecht);{} + refresh submenu{}END PROC menu bildschirm{}END PACKET ls prozess 4{} + diff --git a/app/gs.process/1.02/src/ls-Prozess 5 b/app/gs.process/1.02/src/ls-Prozess 5 new file mode 100644 index 0000000..66bdf94 --- /dev/null +++ b/app/gs.process/1.02/src/ls-Prozess 5 @@ -0,0 +1,84 @@ +(* + + ********************************************************** + ********************************************************** + ** ** + ** ls-Prozess 5 ** + ** ** + ** Version 1.02 ** + ** ** + ** (Stand : 26.01.90) ** + ** ** + ** ** + ** ** + ** Autoren: Bruno Pollok, Bielefeld ** + ** Wolfgang Weber, Bielefeld ** + ** ** + ** ** + ** Copyright (C) 1988 Eva Latta-Weber, Bielefeld ** + ** Copyright (C) 1990 ERGOS GmbH, Siegburg ** + ********************************************************** + ********************************************************** + + *) +PACKET ls prozess 5 DEFINES + pdv konfiguration zugelassen,{} pdv konfiguration evtl aktivieren,{} pdv konfiguration zeigen,{} pdv kanal konfigurieren,{} pdv interfaceausgabe testen,{} pdv interfaceeingabe testen:{}LET max steckplaetze = 4,{} max portanzahl = 4,{} anzahl kartensorten = 5,{} betriebsart = 1,{} keine karte = 1,{} ea karte = 2,{} kombi = 3,{} da karte = 4,{} ad karte = 5,{} + compact = 6,{} einzel = 7,{} mehrfach = 8;{}LET testfenster x = 11,{} testfenster y = 5,{} testfenster xsize = 59,{} testfenster ysize = 15;{}WINDOW VAR testfenster :: window (testfenster x, testfenster y,{} testfenster xsize, testfenster ysize);{}INT VAR steckplatzart :: 0;{}BOOL VAR mit konfigurationsmoeglichkeit :: TRUE;{}TASK VAR konfigurationsmanager :: niltask;{} +ROW max steckplaetze INT VAR kartenart :: ROW max steckplaetze INT :{} (keine karte, keine karte,{} keine karte, keine karte);{}LET SPANNUNG = ROW 2 REAL,{} PORT = ROW 3 INT,{} KARTE = ROW max portanzahl PORT;{}ROW anzahl kartensorten KARTE CONST karte :: ROW anzahl kartensorten KARTE :{}(* ---------------------------------------------------------------------- *){}( KARTE : ({}(* ---------------------------------------------------------------------- *){} +(* *) PORT : (nicht belegt, 0, 0), (* Port 1 *){}(* leere *) PORT : (nicht belegt, 0, 0), (* Port 2 *){}(* Karte *) PORT : (nicht belegt, 0, 0), (* Port 3 *){}(* *) PORT : (nicht belegt, 0, 0)), (* Port 4 *){}(*----------------------------------------------------------------------- *){} KARTE : ({}(* ---------------------------------------------------------------------- *){}(* *) PORT : (digital ein, 1, 3), (* Port 1 *){} +(* E/A *) PORT : (digital aus, 1, 1), (* Port 2 *){}(* Karte *) PORT : (digital ein, 1, 3), (* Port 3 *){}(* *) PORT : (digital aus, 1, 1)), (* Port 4 *){}(*----------------------------------------------------------------------- *){} KARTE : ({}(* ---------------------------------------------------------------------- *){}(* *) PORT : (analog ein, 2, 2), (* Port 1 *){}(* Kombi *) PORT : (analog ein, 3, 2), (* Port 2 *){} +(* Karte *) PORT : (digital ein, 1, 3), (* Port 3 *){}(* *) PORT : (digital aus, 1, 1 )), (* Port 4 *){}(*----------------------------------------------------------------------- *){} KARTE : ({}(* ---------------------------------------------------------------------- *){}(* *) PORT : (analog aus, 1, 1), (* Port 1 *){}(* D/A *) PORT : (analog aus, 1, 3), (* Port 2 *){}(* Wandler *) PORT : (nicht belegt, 0, 0), (* Port 3 *){} +(* *) PORT : (nicht belegt, 0, 0)), (* Port 4 *){}(*----------------------------------------------------------------------- *){} KARTE : ({}(* ---------------------------------------------------------------------- *){}(* *) PORT : (analog ein, 1, 1), (* Port 1 *){}(* A/D *) PORT : (analog ein, 1, 3), (* Port 2 *){}(* Wandler *) PORT : (nicht belegt, 0, 0), (* Port 3 *){}(* *) PORT : (nicht belegt, 0, 0)) (* Port 4 *){} +(*----------------------------------------------------------------------- *){} );{}PROC pdv konfiguration zugelassen (BOOL CONST wahrheitswert):{} teste berechtigung;{} mit konfigurationsmoeglichkeit := wahrheitswert;{} IF mit konfigurationsmoeglichkeit{} THEN konfigurationsmanager := niltask{} ELSE konfigurationsmanager := myself{} FI.{} teste berechtigung:{} enable stop;{} IF NOT (konfigurationsmanager = niltask OR{} + konfigurationsmanager = myself){} THEN errorstop ("Befehl ist nur in Task '" +{} name (konfigurationsmanager) + "' zugelassen!"){} FI.{}END PROC pdv konfiguration zugelassen;{}PROC pdv konfiguration evtl aktivieren:{} IF mit konfigurationsmoeglichkeit{} THEN activate (3){} ELSE deactivate (3){} FI{}END PROC pdv konfiguration evtl aktivieren;{}PROC pdv kanal konfigurieren:{} TEXT CONST info :: " "15"Auswahl der Steckplatzart "14" "13""13""{} + + " c Compactbox "13""{} + " e Einzelsteckplatz "13""{} + " m Mehrfachsteckplatz ",{} liste :: "Compact"13"Einzel"13"Mehrfach",{} tasten :: "cemCEM";{} INT VAR auswahl := menualternative (info, liste, tasten, 5, FALSE);{} SELECT auswahl OF{} CASE 1, 101, 104 : trage compactbox ein;{} zeige kanalbelegung (0){} CASE 2, 102, 105 : trage einzelplatzbelegung ein;{} + zeige kanalbelegung (0){} CASE 3, 103, 106 : bearbeite die steckplaetze einzeln{} END SELECT;{} beende kanaldaten eintragen.{} trage compactbox ein:{} steckplatzart := compact;{} trage steckplatzbelegung ein (1, kombi);{} trage steckplatzbelegung ein (2, keine karte);{} trage steckplatzbelegung ein (3, keine karte);{} trage steckplatzbelegung ein (4, keine karte).{} trage einzelplatzbelegung ein:{} steckplatzart := einzel;{} trage steckplatzbelegung ein (1, ermittelte kartenart (0));{} + trage steckplatzbelegung ein (2, keine karte);{} trage steckplatzbelegung ein (3, keine karte);{} trage steckplatzbelegung ein (4, keine karte).{} bearbeite die steckplaetze einzeln:{} INT VAR platz;{} steckplatzart := mehrfach;{} FOR platz FROM 1 UPTO max steckplaetze REP{} trage steckplatzbelegung ein (platz, ermittelte kartenart (platz));{} zeige kanalbelegung (platz * 10){} PER.{}END PROC pdv kanal konfigurieren;{}PROC pdv konfiguration zeigen:{} SELECT steckplatzart OF{} + CASE compact : zeige kanalbelegung (0){} CASE einzel : zeige kanalbelegung (0){} CASE mehrfach : zeige belegung einzelner steckplaetze{} OTHERWISE noch nicht konfiguriert{} END SELECT.{} noch nicht konfiguriert:{} menuinfo (" "15"Warnung: "14" "13""13""13""{} + " Das Interface wurde noch nicht konfiguriert! "13""13""{} + " In diesem Zustand sind weder Eingaben noch "13""{} + " Ausgaben über das Interface möglich. "13"").{} + zeige belegung einzelner steckplaetze:{} TEXT CONST info ::{} " "15"Eingestellt: Mehrfachsteckplatz "14" "13""13""{} + " 1 Info Steckplatz 1 "13""{} + " 2 Info Steckplatz 2 "13""{} + " 3 Info Steckplatz 3 "13""{} + " 4 Info Steckplatz 4 "13""13""{} + " z Zurück ins Hauptmenü ",{} liste :: "1"13"2"13"3"13"4"13"z",{} + tasten :: "1234zZ";{} INT VAR auswahl;{} REP auswahl := menualternative (info, liste, tasten, 5, FALSE);{} SELECT auswahl OF{} CASE 1, 101 : zeige kanalbelegung (10){} CASE 2, 102 : zeige kanalbelegung (20){} CASE 3, 103 : zeige kanalbelegung (30){} CASE 4, 104 : zeige kanalbelegung (40){} END SELECT{} UNTIL (auswahl = 5) OR (auswahl > 104) PER{}END PROC pdv konfiguration zeigen;{}PROC pdv interfaceausgabe testen:{} gestalte testfenster ("Ausgabetest");{} + disable stop;{} teste interface;{} IF NOT is error{} THEN teste interface ausgabe{} FI;{} IF is error{} THEN fehlerbehandlung{} ELSE schliesse interface;{} enable stop;{} beseitige testfenster;{} refresh submenu{} FI.{} fehlerbehandlung:{} TEXT VAR meldung :: errormessage;{} clear error;{} schalte alles aus;{} schliesse interface;{} enable stop;{} cursor off;{} regenerate menuscreen;{} menuinfo (" " + invers (meldung)).{}END PROC pdv interfaceausgabe testen;{} +PROC pdv interfaceeingabe testen:{} gestalte testfenster ("Eingabetest");{} disable stop;{} teste interface;{} IF NOT is error{} THEN teste interface eingabe{} FI;{} IF is error{} THEN fehlerbehandlung{} ELSE schliesse interface;{} enable stop;{} beseitige testfenster;{} refresh submenu{} FI.{} fehlerbehandlung:{} TEXT VAR meldung :: errormessage;{} clear error;{} schalte alles aus;{} schliesse interface;{} enable stop;{} cursor off;{} + regenerate menuscreen;{} menuinfo (" " + invers (meldung)).{}END PROC pdv interfaceeingabe testen;{}PROC beseitige testfenster:{} INT VAR z;{} FOR z FROM testfenster y + testfenster ysize DOWNTO testfenster y - 1 REP{} cursor (testfenster x - 1, z);{} out (""5""){} PER{}END PROC beseitige testfenster;{}PROC gestalte testfenster (TEXT CONST funktionsart):{} show (testfenster);{} cursor (testfenster x - 1, testfenster y + testfenster ysize - 2);{} out (balken links + (testfenster xsize * waagerecht) + balken rechts);{} + cursor (testfenster, 1, 2);{} out (testfenster, center (testfenster, invers (funktionsart))){}END PROC gestalte testfenster;{}PROC testfensterfussnote (TEXT CONST meldung):{} cursor (testfenster, 2, testfenster ysize);{} out (testfenster, meldung){}END PROC testfensterfussnote;{}PROC teste interfaceausgabe:{} INT VAR kanalnummer, steckplatz, port;{} TEXT VAR nummer :: "";{} enable stop;{} REP hole kanalnummer;{} teste ausgabe an kanal{} PER.{} hole kanalnummer:{} SELECT steckplatzart OF{} + CASE compact : kanalnummer := 4; steckplatz := 1; port := 4{} CASE einzel : kanalnummer muss evtl erfragt werden{} CASE mehrfach : kanalnummer muss erfragt werden{} OTHERWISE errorstop ("Interface ist noch nicht konfiguriert!"){} END SELECT;{} cursor (testfenster, 2, 5);{} out (testfenster, "Ausgabe an Kanal " + text (kanalnummer) + klammer +{} kanalbeschreibung (steckplatz, port));{} IF steckplatzart = mehrfach{} THEN cursor (testfenster, 25, 6);{} + out (testfenster, "in Steckplatz " + text (steckplatz)){} FI;{} out (testfenster, ")").{} klammer:{} IF kanalnummer < 10{} THEN " (= "{} ELSE " (= "{} FI.{} kanalnummer muss evtl erfragt werden:{} SELECT kartenart [1] OF{} CASE kombi : kanalnummer := 4; steckplatz := 1; port := 4{} CASE eakarte : kanalnummer := 2; steckplatz := 1; port := 2{} CASE dakarte : frage nach kanalnummer auf da karte;{} steckplatz := 1; port := kanalnummer{} + OTHERWISE errorstop ("Keine Ausgabe an " + kartenname + " möglich!"){} END SELECT.{} kartenname:{} IF kartenart [1] = ad karte{} THEN "A/D-Karte"{} ELSE "leeren Steckplatz"{} FI.{} frage nach kanalnummer auf da karte:{} menufootnote ("Zurück zum Hauptmenü: <ESC><q>");{} testfensterfussnote ("Bitte eine Kanalnummer eingeben!");{} cursor (testfenster, 2, 5);{} out (testfenster, "Ausgabe - Kanal (1 oder 2): ");{} cursor on;{} REP inchar (nummer){} UNTIL (pos ("12", nummer) > 0) OR esc q gedrueckt PER;{} + cursor off;{} IF nummer = ""27""{} THEN LEAVE teste interface ausgabe{} ELSE kanalnummer := int (nummer){} FI.{} esc q gedrueckt:{} (nummer = ""27"") AND (incharety (20) = "q").{} kanalnummer muss erfragt werden:{} TEXT VAR exit char;{} menufootnote ("Zurück zum Hauptmenü: <ESC><q>");{} testfensterfussnote ("Bitte eine Kanalnummer eingeben!");{} cursor (testfenster, 2, 5);{} out (testfenster, "Ausgabe - Kanal:");{} cursor on;{} REP cursor (testfenster, 19, 5);{} + editget (testfenster, nummer, 4, 4, "", "q", exit char){} UNTIL (exit char = ""27"q") OR ausgabekanal eingegeben PER;{} cursor off;{} IF exit char = ""27"q"{} THEN LEAVE teste interface ausgabe{} FI.{} ausgabekanal eingegeben:{} kanalnummer := abs (int (nummer));{} steckplatz := kanalnummer DIV 10;{} port := kanalnummer MOD 10;{} IF steckplatz = 0 THEN steckplatz := 1 FI;{} cursor (testfenster, 2, 7);{} IF (kanalnummer < 1) OR (kanalnummer > 49){} + THEN out (testfenster, "Unzulässige Kanalnummer! "); FALSE{} ELIF (port = 0) OR (port > max portanzahl) OR kein ausgabeport{} THEN out (testfenster, "Dies ist kein Ausgabe-Kanal! "); FALSE{} ELSE out (testfenster, " "); TRUE{} FI.{} kein ausgabeport:{} (port betriebsart <> digital aus) AND (port betriebsart <> analog aus).{} port betriebsart: karte [sorte][port][betriebsart].{} sorte : kartenart [steckplatz].{} + teste ausgabe an kanal:{} TEXT VAR wert;{} cursor (testfenster, 1, 8);{} out (testfenster, testfenster xsize * "-");{} cursor (testfenster, 2, 11);{} out (testfenster, "Ausgabewert: ");{} testfenster fussnote ("Bitte einen Wert zwischen 0 und 255 eingeben!");{} menufootnote ("'Werte ausgeben' beenden: <ESC><q>");{} cursor on;{} REP cursor (testfenster, 15, 11);{} wert := "0";{} editget (testfenster, wert, 4, 4, "", "qh", exit char);{} IF exit char = return{} + THEN ausgeben (kanalnummer, int (wert) MOD ganzzahlobergrenze){} ELIF exit char = ""27"h"{} THEN errorstop ("Programm-Abbruch durch <ESC><h>!"){} FI{} UNTIL exitchar = ""27"q" PER;{} cursor off;{} IF (steckplatzart = mehrfach) OR (kartenart [1] = da karte){} THEN cursor (testfenster, 1, 5);{} out (testfenster, (2 * testfenster xsize) * " ");{} cursor (testfenster, 2, 11);{} out (testfenster, " ");{} + testfenster fussnote ((testfenster xsize - 2) * " "){} ELSE LEAVE teste interfaceausgabe{} FI.{} return: ""13"".{}END PROC teste interfaceausgabe;{}PROC teste interfaceeingabe:{} INT VAR kanalnummer, steckplatz, port;{} TEXT VAR nummer :: "";{} enable stop;{} REP hole kanalnummer;{} teste eingabe vom kanal{} PER.{} hole kanalnummer:{} IF steckplatzart = 0{} THEN errorstop ("Interface ist noch nicht konfiguriert!"){} ELSE kanalnummer erfragen{} + FI;{} cursor (testfenster, 2, 5);{} out (testfenster, "Eingabe von Kanal " + text (kanalnummer) + klammer +{} kanalbeschreibung (steckplatz, port));{} IF steckplatzart = mehrfach{} THEN cursor (testfenster, 26, 6);{} out (testfenster, "in Steckplatz " + text (steckplatz)){} FI;{} out (testfenster, ")").{} klammer:{} IF kanalnummer < 10{} THEN " (= "{} ELSE " (= "{} FI.{} kanalnummer erfragen:{} SELECT steckplatzart OF{} + CASE compact : drei kanaele anbieten;{} steckplatz := 1; port := kanalnummer{} CASE einzel : zwei oder drei kanaele anbieten;{} steckplatz := 1; port := kanalnummer{} CASE mehrfach : alle kanaele moeglich{} END SELECT.{} drei kanaele anbieten:{} menufootnote ("Zurück zum Hauptmenü: <ESC><q>");{} testfensterfussnote ("Bitte eine Kanalnummer eingeben!");{} cursor (testfenster, 2, 5);{} out (testfenster, "Eingabe - Kanal (1, 2 oder 3): ");{} + cursor on;{} REP inchar (nummer){} UNTIL (pos ("123", nummer) > 0) OR esc q gedrueckt PER;{} cursor off;{} IF nummer = ""27""{} THEN LEAVE teste interface eingabe{} ELSE kanalnummer := int (nummer){} FI.{} esc q gedrueckt:{} (nummer = ""27"") AND (incharety (20) = "q").{} zwei oder drei kanaele anbieten:{} SELECT kartenart [1] OF{} CASE kombi : drei kanaele anbieten{} CASE ad karte : zwei kanaele anbieten{} CASE ea karte : kanalnummer := 1{} + OTHERWISE errorstop ("Eingabe bei " + kartenname + " nicht möglich!"){} END SELECT.{} kartenname:{} IF kartenart [1] = da karte{} THEN "D/A-Karte"{} ELSE "leerem Steckplatz"{} FI.{} zwei kanaele anbieten:{} menufootnote ("Zurück zum Hauptmenü: <ESC><q>");{} testfensterfussnote ("Bitte eine Kanalnummer eingeben!");{} cursor (testfenster, 2, 5);{} out (testfenster, "Eingabe - Kanal (1 oder 2): ");{} cursor on;{} REP inchar (nummer){} UNTIL (pos ("12", nummer) > 0) OR esc q gedrueckt PER;{} + cursor off;{} IF nummer = ""27""{} THEN LEAVE teste interface eingabe{} ELSE kanalnummer := int (nummer){} FI.{} alle kanaele moeglich:{} TEXT VAR exit char;{} menufootnote ("Zurück zum Hauptmenü: <ESC><q>");{} testfensterfussnote ("Bitte eine Kanalnummer eingeben!");{} cursor (testfenster, 2, 5);{} out (testfenster, "Eingabe - Kanal:");{} cursor on;{} REP cursor (testfenster, 19, 5);{} editget (testfenster, nummer, 4, 4, "", "q", exit char){} UNTIL (exit char = ""27"q") OR eingabekanal eingegeben PER;{} + cursor off;{} IF exit char = ""27"q"{} THEN LEAVE teste interface eingabe{} FI.{} eingabekanal eingegeben:{} kanalnummer := abs (int (nummer));{} steckplatz := kanalnummer DIV 10;{} port := kanalnummer MOD 10;{} IF steckplatz = 0 THEN steckplatz := 1 FI;{} cursor (testfenster, 2, 7);{} IF (kanalnummer < 1) OR (kanalnummer > 49){} THEN out (testfenster, "Unzulässige Kanalnummer! "); FALSE{} ELIF (port = 0) OR (port > max portanzahl) OR kein eingabeport{} + THEN out (testfenster, "Dies ist kein Eingabe-Kanal! "); FALSE{} ELSE out (testfenster, " "); TRUE{} FI.{} kein eingabeport:{} (port betriebsart <> digital ein) AND (port betriebsart <> analog ein).{} port betriebsart: karte [sorte][port][betriebsart].{} sorte : kartenart [steckplatz].{} teste eingabe vom kanal:{} cursor (testfenster, 1, 8);{} out (testfenster, testfenster xsize * "-");{} cursor (testfenster, 2, 11);{} + out (testfenster, "Eingelesener Wert: ");{} testfenster fussnote (" ");{} menufootnote ("'Werte einlesen' beenden: <ESC><q>");{} REP cursor (testfenster, 21, 11);{} out (text (eingabe (kanalnummer), 3));{} warte (0.1){} UNTIL abbruch gewuenscht PER;{} IF (steckplatzart = einzel) AND (kartenart [1] = ea karte){} THEN LEAVE teste interfaceeingabe{} ELSE cursor (testfenster, 1, 5);{} out (testfenster, (2 * testfenster xsize) * " ");{} + cursor (testfenster, 2, 11);{} out (testfenster, " "){} FI.{}END PROC teste interfaceeingabe;{}TEXT PROC kanalbeschreibung (INT CONST steckplatz, port):{} IF steckplatzart = compact{} THEN port auf compactbox{} ELSE port auf steckkarte{} FI.{} port auf compactbox:{} portbeschreibung + " der Compact-Box".{} port auf steckkarte:{} SELECT kartenart [steckplatz] OF{} CASE kombi : portbeschreibung + " der Kombi-Karte"{} CASE ea karte : portbeschreibung + " der E/A-Karte"{} + CASE da karte : portbeschreibung + " der D/A-Karte"{} CASE ad karte : portbeschreibung + " der A/D-Karte"{} OTHERWISE ""{} END SELECT.{} portbeschreibung:{} SELECT 2 + karte [kartenart [steckplatz]][port][betriebsart] OF{} CASE 1 : "Digitalausgang"{} CASE 3 : "Digitaleingang"{} CASE 0 : "Analogausgang " + text (port){} CASE 4 : "Analogeingang " + text (port){} OTHERWISE ""{} END SELECT.{}END PROC kanalbeschreibung;{}PROC trage steckplatzbelegung ein (INT CONST steckplatz, art):{} + INT VAR port;{} kartenart [steckplatz] := art;{} klaere spannungsbereiche;{} FOR port FROM 1 UPTO max portanzahl REP{} trage kanaldaten ein (kanalnummer, spannungsbereich, portdaten);{} IF steckplatz = 1{} THEN trage kanaldaten ein (port, spannungsbereich, portdaten){} FI{} PER.{} kanalnummer: port + 10 * steckplatz.{} portdaten : karte [kartenart [steckplatz]][port].{} spannungsbereich:{} IF port = 1{} THEN bereich von e1{} ELIF port = 2{} THEN bereich von e2{} + ELSE SPANNUNG : (0.0, 0.0){} FI.{} klaere spannungsbereiche:{} SPANNUNG VAR bereich von e1, bereich von e2;{} SELECT kartenart [steckplatz] OF{} CASE kombi : spannungsbereich 0 bis 5 volt{} CASE da karte : setze spannungsbereiche{} CASE ad karte : erfrage adkarte schalterstellungen{} OTHERWISE alles auf 0 setzen{} END SELECT.{} spannungsbereich 0 bis 5 volt:{} bereich von e1 := SPANNUNG : (0.0, 5.0);{} bereich von e2 := SPANNUNG : (0.0, 5.0).{} setze spannungsbereiche:{} + bereich von e1 := SPANNUNG : (-5.0, 5.0);{} bereich von e2 := SPANNUNG : ( 0.0, 5.0).{} alles auf 0 setzen:{} bereich von e1 := SPANNUNG : (0.0, 0.0);{} bereich von e2 := SPANNUNG : (0.0, 0.0).{}erfrage adkarte schalterstellungen:{} REP{} hole schalterstellung{} UNTIL schalterstellung sinnvoll PER;{} bestimme spannungsbereiche (schalterzustand, bereich von e1, bereich von e2).{} hole schalterstellung:{} TEXT VAR schalterzustand := menuanswer (infotext, "00000000", 5).{} infotext:{} + ueberschrift{} + " Bitte die aktuelle Schalterstellung eintragen: "13""13""{} + " Es bedeutet : 1 - Schalterstellung 'on' "13""{} + " 0 - Schalterstellung 'off' "13""13""{} + " Nummer : 12345678 "13""{} + " |||||||| ".{} ueberschrift:{} IF steckplatzart = mehrfach{} THEN " "15"Angabe der Schalterstellungen auf der A/D-Karte "14""13""{} + " "15" in Steckplatz "{} + text (steckplatz) + ": "14""13""13""{} + ELSE " "15"Angabe der Schalterstellungen auf der A/D-Karte: "14""13""13""{} FI.{} schalterstellung sinnvoll:{} (length (schalterzustand) = 8) AND nur nullen und einsen.{} nur nullen und einsen:{} BOOL VAR ok := TRUE; INT VAR m;{} FOR m FROM 1 UPTO 8 REP{} IF NOT ((schalterzustand SUB m) = "1" OR (schalterzustand SUB m ) = "0"){} THEN ok := FALSE{} FI{} PER;{} ok.{}END PROC trage steckplatzbelegung ein;{}INT PROC ermittelte kartenart (INT CONST steckplatz):{} TEXT CONST info e :: " "15"Angabe der Interfacekarte: "14" "13""13""{} + + " k Kombikarte "13""{} + " e E / A - Karte "13""{} + " d D / A - Wandler - Karte "13""{} + " a A / D - Wandler - Karte "13""{} + " 0 Keine Steckkarte ",{} info m :: " "15"Angabe der Interfacekarte für Steckplatz "{} + text (steckplatz) + ": "14" "13""13""{} + " k Kombikarte "13""{} + + " e E / A - Karte "13""{} + " d D / A - Wandler - Karte "13""{} + " a A / D - Wandler - Karte "13""{} + " 0 Keine Steckkarte ",{} liste :: "Kombi"13"E/A"13"D/A"13"A/D"13"Keine",{} tasten :: "keda0KEDA";{} INT VAR auswahl := menualternative (infotext, liste, tasten, 5, FALSE);{} SELECT auswahl OF{} CASE 1, 101, 106 : kombi{} + CASE 2, 102, 107 : eakarte{} CASE 3, 103, 108 : dakarte{} CASE 4, 104, 109 : adkarte{} OTHERWISE keine karte{} END SELECT.{} infotext:{} IF steckplatz = 0{} THEN info e{} ELSE info m{} FI.{}END PROC ermittelte kartenart;{}PROC zeige kanalbelegung (INT CONST steckplatz):{} ROW 4 TEXT VAR kanalnummer;{} kanalnummer [1] := text (steckplatz + 1, 2);{} kanalnummer [2] := text (steckplatz + 2, 2);{} kanalnummer [3] := text (steckplatz + 3, 2);{} + kanalnummer [4] := text (steckplatz + 4, 2);{} IF steckplatzart = compact{} THEN zeige compactboxbelegung{} ELSE zeige steckplatz mit karte{} FI.{} zeige steckplatz mit karte:{} SELECT kartenart [steckplatznummer] OF{} CASE kombi : zeige steckplatz mit kombi{} CASE eakarte: zeige steckplatz mit eakarte{} CASE dakarte: zeige steckplatz mit dakarte{} CASE adkarte: zeige steckplatz mit adkarte{} OTHERWISE zeige steckplatz ohne karte{} END SELECT.{} + steckplatznummer:{} IF steckplatz = 0{} THEN 1{} ELSE steckplatz DIV 10{} FI.{} zeige compactboxbelegung:{} menuinfo ({} " "15"Eingestellt: Compactbox "14" "13""13""{} + " Belegung der Kanäle: "13""13""13""{} + kanalnummeranzeige kombikarte).{} zeige steckplatz mit kombi:{} menuinfo (ueberschrift + " mit Kombikarte: "14" "13""13""{} + " Belegung der Kanäle: "13""13""13""{} + kanalnummeranzeige kombikarte).{} + zeige steckplatz mit eakarte:{} menuinfo (ueberschrift + " mit E / A - Karte: "14" "13""13""{} + " Belegung der Kanäle: "13""13""13""{} + kanalnummeranzeige eakarte).{} zeige steckplatz mit dakarte:{} menuinfo (ueberschrift + " mit D / A - Karte: "14" "13""13""{} + " Belegung der Kanäle: "13""13""{} + kanalnummeranzeige dakarte).{} zeige steckplatz mit adkarte:{} hole spannungsbereiche;{} menuinfo (" " + ueberschrift + " mit A / D - Karte: "14""13""13""{} + + " Zwei analoge Eingänge stehen zur Verfügung: "13""13""{} + kanalnummeranzeige adkarte).{} hole spannungsbereiche:{} SPANNUNG VAR e1 bereich, e2 bereich;{} hole spannungsbereich (steckplatz + 1, e1 bereich [1], e1 bereich [2]);{} hole spannungsbereich (steckplatz + 2, e2 bereich [1], e2 bereich [2]).{} zeige steckplatz ohne karte:{} IF steckplatz = 0{} THEN menuinfo ({} " "15"Einzelsteckplatz ohne Steckkarte: "14" "13""13""13""{} + " Es sind weder Ein- noch Ausgaben möglich! "13""){} + ELSE menuinfo ({} " "15"Steckplatz "{} + text (steckplatz DIV 10) + " ohne Steckkarte: "14""13""13""13""{} + " Es sind hier weder Ein- noch Ausgaben möglich! "13""){} FI.{} ueberschrift:{} IF steckplatz = 0{} THEN " "15"Einzelsteckplatz"{} ELSE " "15"Steckplatz " + text (steckplatz DIV 10){} FI.{} kanalnummeranzeige kombikarte:{} " "15"Kanal " + kanalnummer [1]{} + ": "14" Analogeingang 1 (E1) "13""13""{} + + " "15"Kanal " + kanalnummer [2]{} + ": "14" Analogeingang 2 (E2) "13""13""{} + " "15"Kanal " + kanalnummer [3]{} + ": "14" Digitaleingang "13""13""{} + " "15"Kanal " + kanalnummer [4]{} + ": "14" Digitalausgang "13"".{} kanalnummeranzeige eakarte:{} " "15"Kanal " + kanalnummer [1]{} + ": "14" Digitaleingang "13""13""{} + " "15"Kanal " + kanalnummer [2]{} + ": "14" Digitalausgang "13""13""{} + + " ( "15"Kanal " + kanalnummer [3]{} + ": "14" Digitaleingang (= Kanal " + kanalnummer [1] + ") )"13""13""{} + " ( "15"Kanal " + kanalnummer [4]{} + ": "14" Digitalausgang (= Kanal " + kanalnummer [2] + ") )"13"".{} kanalnummeranzeige adkarte:{} " "15"Kanal " + kanalnummer [1]{} + ": "14" (E1) Spannungsbereich " + bereich1 + ""13""13""{} + " "15"Kanal " + kanalnummer [2]{} + ": "14" (E2) Spannungsbereich " + bereich2 + ""13"".{} + bereich1:{} IF e1 bereich [1] = 0.0{} THEN " 0.000 V - +" + text (e1 bereich [2], 6, 3) + " V "{} ELSE text (e1 bereich [1], 7, 3) + " V - +" + text (e1 bereich [2], 6, 3) + " V "{} FI.{} bereich2:{} IF e2 bereich [1] = 0.0{} THEN " 0.000 V - +" + text (e2 bereich [2], 6, 3) + " V"{} ELSE text (e2 bereich [1], 7, 3) + " V - +" + text (e2 bereich [2], 6, 3) + " V"{} FI.{} kanalnummeranzeige dakarte:{} " Die Karte stellt einen Analogausgang zur Verfügung, "13""{} + + " der auf zwei Arten angesprochen werden kann: "13""13""13""{} + " "15"Kanal " + kanalnummer [1]{} + ": "14" Spannungsbereich -5 V - +5 V "13""13""{} + " "15"Kanal " + kanalnummer [2]{} + ": "14" Spannungsbereich 0 V - +5 V "13"".{}END PROC zeige kanalbelegung;{}PROC bestimme spannungsbereiche (TEXT CONST schalterstellung,{} SPANNUNG VAR bereich von e1,{} SPANNUNG VAR bereich von e2):{} + bestimme bereich von e1;{} bestimme bereich von e2.{} bestimme bereich von e1:{} IF schalter 3 geschlossen{} THEN umax1 := 0.25{} ELIF schalter 2 geschlossen{} THEN umax1 := 2.5{} ELIF schalter 1 geschlossen{} THEN umax1 := 25.0{} ELSE umax1 := 0.0{} FI;{} IF schalter 8 geschlossen{} THEN symmetrische spannungsmessung ueber e1{} ELSE asymmetrische spannungsmessung ueber e1{} FI.{} schalter 1 geschlossen: (schalterstellung SUB 1) = on.{} + schalter 2 geschlossen: (schalterstellung SUB 2) = on.{} schalter 3 geschlossen: (schalterstellung SUB 3) = on.{} schalter 8 geschlossen: (schalterstellung SUB 8) = on.{} umin1: bereich von e1 [1].{} umax1: bereich von e1 [2].{} symmetrische spannungsmessung ueber e1:{} umax1 := umax1 / 2.0;{} umin1 := - umax1.{} asymmetrische spannungsmessung ueber e1:{} umin1 := 0.0.{} bestimme bereich von e2:{} IF schalter 6 geschlossen{} THEN umax2 := 0.25{} ELIF schalter 5 geschlossen{} + THEN umax2 := 2.5{} ELIF schalter 4 geschlossen{} THEN umax2 := 25.0{} ELSE umax2 := 0.0{} FI;{} IF schalter 7 geschlossen{} THEN symmetrische spannungsmessung ueber e2{} ELSE asymmetrische spannungsmessung ueber e2{} FI.{} schalter 4 geschlossen: (schalterstellung SUB 4) = on.{} schalter 5 geschlossen: (schalterstellung SUB 5) = on.{} schalter 6 geschlossen: (schalterstellung SUB 6) = on.{} schalter 7 geschlossen: (schalterstellung SUB 7) = on.{} + umin2: bereich von e2 [1].{} umax2: bereich von e2 [2].{} symmetrische spannungsmessung ueber e2:{} umax2 := umax2 / 2.0;{} umin2 := - umax2.{} asymmetrische spannungsmessung ueber e2:{} umin2 := 0.0.{} on: "1".{}END PROC bestimme spannungsbereiche{}END PACKET ls prozess 5{} + diff --git a/app/gs.process/1.02/src/ls-Prozess-gen b/app/gs.process/1.02/src/ls-Prozess-gen new file mode 100644 index 0000000..b93e4b9 --- /dev/null +++ b/app/gs.process/1.02/src/ls-Prozess-gen @@ -0,0 +1,146 @@ +(* + + ********************************************************** + ********************************************************** + ** ** + ** ls-Prozess/gen ** + ** ** + ** Version 1.02 ** + ** ** + ** (Stand : 26.01.90) ** + ** ** + ** ** + ** ** + ** Autoren: Bruno Pollok, Bielefeld ** + ** Wolfgang Weber, Bielefeld ** + ** ** + ** ** + ** Copyright (C) 1988 Eva Latta-Weber, Bielefeld ** + ** Copyright (C) 1990 ERGOS GmbH, Siegburg ** + ********************************************************** + ********************************************************** + + *) +WINDOW VAR fenster := window (1, 1, 79, 24); +TEXT CONST titel :: ""15"ls-Prozess : Automatische Generierung "14"", + ueberschrift :: "Auswahl der Interface-Anpassung", + hinweis :: "Bitte gewünschte Anpassung ankreuzen!"; +TEXT VAR anpassung; +BOOL VAR alles okay; +frage nach diskette; +IF alles okay + THEN installation +FI; +PROC installation: + THESAURUS VAR thes :: infix namen (ALL archive, "ls-Prozess 1"); + anpassung := boxone (fenster, thes, ueberschrift, hinweis, FALSE); + cursor (1, 3); + out (""4""); + IF anpassung <> "" + THEN installiere ls prozess + ELSE warnung + FI. + warnung: + out (""7""); + line (2); + out (" FEHLER: Es muß unbedingt eine Anpassung ausgewaehlt werden!"); + cursor (5, 7); + IF no ("Generierung abbrechen") + THEN installation + FI. +END PROC installation; +PROC installiere ls prozess: + forget ("ls-Prozess/gen", quiet); + frage evtl nach interfacekanal; + check off; + warnings off; + installiere (anpassung); + installiere ("ls-Prozess 2"); + installiere ("ls-Prozess 3"); + installiere ("ls-Prozess 4"); + installiere ("ls-Prozess 5"); + + installiere ("ls-MENUKARTE:Prozess"); + check on; + release (archive); + setze ggf interface kanal; + global manager. + frage evtl nach interfacekanal: + IF adapter fuer separate schnittstelle + THEN erfrage kanalnummer + FI. + erfrage kanalnummer: + INT VAR kanalnummer; + line (2); + REP put (" Gib Interfacekanal:"); + get (kanalnummer); + IF kanalnummer < 1 OR kanalnummer > 24 + THEN out (""7" Unzulaessige Kanalnummer!"); + line (2) + + FI + UNTIL kanalnummer > 0 AND kanalnummer < 25 PER; + cursor (1, 3); + out (""4""). + setze ggf interfacekanal: + IF adapter fuer separate schnittstelle + THEN do ("interface kanal (" + text (kanalnummer) + ")") + FI. + adapter fuer separate schnittstelle: + (anpassung = "ls-Prozess 1 für AKTRONIC-Adapter") OR + (anpassung = "ls-Prozess 1 für MUFI als Endgerät"). +END PROC installiere ls prozess; +PROC installiere (TEXT CONST datei): + INT VAR zeile, spalte; + + hole datei vom archiv; + IF datei = "ls-MENUKARTE:Prozess" + THEN schicke zu menukarten task + ELSE insertiere + FI. + hole datei vom archiv: + line (2); + out ("'" + datei + "' "); + get cursor (spalte, zeile); + IF NOT exists (datei) + THEN out ("wird von der Archivdiskette geholt."); + fetch (datei, archive) + FI. + insertiere: + cursor (spalte, zeile); + out (""5""); + out ("wird insertiert."); + insert (datei); + cursor (spalte, zeile); + + out (""4""); + forget (datei, quiet). + schicke zu menukarten task: + cursor (spalte, zeile); + out (""5""); + command dialogue (FALSE); + save (datei, /"ls-MENUKARTEN"); + command dialogue (TRUE); + forget (datei, quiet). +END PROC installiere; +PROC frage nach diskette: + page; + out (center (fenster, titel)); + line (4); + putline (" Ist das Archiv angemeldet,"); + putline (" die Diskette mit 'ls-Prozess' eingelegt"); + IF yes (" und das Laufwerk geschlossen") + + THEN alles okay := TRUE + ELSE alles okay := FALSE; + warnung + FI. + warnung: + line (3); + out (" FEHLER : Diskettenzugriff nicht gesichert!"7""); + line (2); + out (" Bitte Fehler beseitigen und Programm neu starten!"); + line (5) +END PROC frage nach diskette; + + |