Einführung und erste Hilfe zur Programmiersprache Turbo ...m-frost/zip/Pascal-Reader.pdf · Hierunter fallen OBJEKTORIENTIERTE PROGRAMMIERSPRACHEN wie z.B. Java, Delphi, C++ oder

13.07.02

0-Inhalt

Programmiertechnik Klasse : Informationsblatt Name : PASCAL-READER VERSION 2.3

Hans- Böckler- Schule

Münster 25 Seiten Datum :

Einführung und erste Hilfe zur Programmiersprache

Turbo - Pascal Inhaltsverzeichnis : 1 ) Entstehung von Pascal 2 ) Übersicht Programmiersprachen 3 ) Bedienungshinweise zu Turbo-Pascal 6.0 / 7.0 4 ) Stufen der Programmentwicklung 5 ) Sinnbilder für Struktogramme und PAP 6 ) Aufbau eines Pascal-Programms und Datentypen 7 ) wichtige Pascal-Befehle und Kontrollstrukturen 8 ) Standard- Ein- Ausgabe- Funktionen 9 ) Beispielentwurf für ein lineares Programm 10 ) Regeln für die Dokumentation von Programmen 11 ) Übungsaufgaben für lineare Programme 12 ) Unterprogramme / Prozeduren 13 ) Unterprogramme / Funktionen 14 ) Unterprogrammsammlungen / Units 15 ) Wiederholungsstrukturen 16 ) Übungsaufgaben zur Schleifenprogrammierung 17 ) Programmierung über die parallele Schnittstelle 18 ) Verzweigungen 19 ) Übungsaufgaben zu Verzweigungen 20 ) Programm mit Loops und Verzweigungen Beispiellösung / Teil 1 21 ) Programm mit Loops und Verzweigungen Beispiellösung / Teil 2 22 ) Zusammengesetzte Datentypen : Array / Felder 23 ) Records / Verbund 24 ) Mengen ( SET ) 25 ) Eigene Datentypen ( TYPE ) Literatur zum Einstieg : 1] Gregor Kuhlmann :

Programmiersprache Turbo-Pascal; Eine strukturierte Einführung, rororo Computer Nr. 8148 ; Preis ca. 13.- €

2] Peter Niehoff : Informatik - Datenverarbeitung . mit Pascal, Verlag Handwerk und Technik, Hamburg; Preis ca. 13.- €

3] Reinhard Schuberth : Technologie , Eine Einführung für technische Ausbildungsrichtungen – mit Pascal Verlag Handwerk & Technik 2711 , Hamburg 1993, Preis ca. 13.- €

4] D. Häberle : Pascal für gewerbliche Schulen; 2. Auflage 1994, Verlag : Europa-Lehrmittel, Düsseldorf, Preis ca. 16.- €

5] Das erweiterte Online-Exemplar des Readers finden Sie unter : http://www.muenster.de/~m_frost

11.07.02

1-geschichte

Programmiertechnik Klasse : Informationsblatt Name : GESCHICHTE


Münster 1/25 Datum :

Programmiersprache Turbo-Pascal 1) Blaise Pascal, der französische Religionsphilosoph, Mathematiker und Physiker wurde am 19. Juni 1623 in Clermont-Ferrand als Sohn eines Steuerfachmanns geboren. Er starb 1662. Um seinem Va-ter bei Steuerberechnungen zu helfen, konstruierte er die erste Rechenmaschine , die Pascaline, nach deren Prinzip in Zukunft alle weiteren gebaut wurden.

Die Programmiersprache hat ihren Ursprung in der Sprache Pascal, die 1972 von Niclas Wirth als "Universitätssprache" entworfen wurde, also als eine Pro-grammiersprache, die den Studenten das Erlernen des Programmierens er-leichtern sollte. Niklaus Wirth wurde im Februar 1934 in Winterthur, Schweiz geboren. Nach seiner Prüfung als Elektronik-Ingenieur am Federal Institute of Technology (ETH) in Zürich ( 1959 ) arbeitete er zunächst an der Laval University in Cana-da ( 1960 ) und an der University of California in Berkeley ( 1963 ). Bevor er wieder zurück an die Universität von Zürich zurückkehrte war er Assistenz-Professor für Computerwissenschaften an der Stanford University (1963 - 1967) wo er Pascal entwickelte.

Der Name ist akademisch nach Blaise Pascal ausgewählt worden, dem bekannten Mathematiker und Philosophen. Zu Ehren dieses bedeutenden Genies und einem der Vorväter des Computers hat Nikolaus Wirth, Professor für Informatik an der ETH Zürich, seine zu Beginn der 70er Jahre aus "Algol 60" entwickelte Programmiersprache zur Unterstützung der strukturierten Programmierung "Pascal" genannt. Diese Bezeichnung wurde dann von Borland später übernommen.

1 ] Made in Borland® Copyright© 1994-2002 Borland Software Corporation

11.07.02

2-sprachen

Programmiertechnik Klasse : Informationsblatt Name : PROGRAMMIERSPRACHEN



Übersicht Programmiersprachen Um einen Computer zu programmieren, muss ein gemeinsamer Kode gefunden werden, auf dessen Basis man mit der Maschine kommuniziert Je mehr man sich der Sprache des Rechners nähert, um so schwieriger und umständlicher wird die Kommunikation. Man unterscheidet heute 5 verschiedene Generationen:

1) Programme in MASCHINENSPRACHE bestehen aus Maschinenbefehlen, die als Folge von Nullen und Einsen im Computer dargestellt werden. Die umständliche Eingabe Tausender von einzelnen Bits wird häu-fig abgekürzt durch die Eingabe der äquivalenten Hexadezimalzahlen z.B. 63 B1 0C statt 0110 0011 1011 0001 0000 1100 usw. Bei Fehleingaben wird die Fehlersuche sehr zeitaufwendig und schwierig. Maschinen-sprachen gelten immer nur für Mikroprozessoren des gleichen Typs.

2) Programmiersprachen, bei denen die Bitkombinationen der Maschinenbefehle durch ein leicht zu merken-des Symbolwort ( Mnemonics ) ausgedrückt werden, nennt man ASSEMBLER. Auch solche Assembler-sprachen gelten immer nur für einen einzigen Mikroprozessortyp.

3) Höhere oder PROBLEMORIENTIERTE PROGRAMMIERSPRACHEN erlauben es die Anweisungen für den Computer so zu beschreiben, dass man keine Maschinenbefehle verwenden muss. Man ist dadurch unab-hängig vom Mikroprozessortyp und die Programme können auf jedem Rechner ablaufen.

4) Sprachen der 4. Generation nennt man DESKRIPTIVE PROGRAMMIERSPRACHEN. Hier gibt der Anwen-der nur noch den Verarbeitungsbefehl ein, ohne dass er den Lösungsweg in Form eines Algorithmus be-schreiben muss. Diese Sprachen sind immer auf ein bestimmtes Anwendungsgebiet zugeschnitten; z.B. SQL für relationale Datenbanken oder ADF, CSP, DMS (IBM) , Natural ,Oracle usw.

5) Im Bereich der Künstlichen Intelligenz findet man Programmiersprachen zur Erstellung von Experten-systemen. Hierunter fallen OBJEKTORIENTIERTE PROGRAMMIERSPRACHEN wie z.B. Java, Delphi, C++ oder Visual Basic. Auch funktionale Sprachen wie LISP, logische Sprachen wie Prolog und alle neuen Mak-ro-Sprachen zählt man zur 5. Generation. Hier programmiert man keine Befehle, sondern man gibt an, was mit Objekten passieren soll, wenn bestimmte Ereignisse ( events ) im Programmablauf aktiviert werden. Die Objekte können Dialogelemente sein, Befehlsschaltflächen, Kontrollkästen, Bildlaufleisten usw.

ObjektkodeInterpreter

Compiler

Assembler

( Übersetzungsprogramme )

Quellkode

Maschinensprache Assembler Problemorientierte SprachenDualkode Hexadezimalkode Mnemonics z.B. BASIC z.B. PASCAL 0011 11100000 0011

3E03

MVI A, 03hoder LD A, 03h

A := 3;10 LET A = 3

Einzelne Programmieranweisungen in einer höheren Programmiersprache können eine Menge von Maschi-nenbefehlen auslösen, die der Programmierer im einzelnen gar nicht kennt. Welche Befehle jeweils ausgelöst werden, teilt ein Übersetzungsprogramm dem Computer mit. Vor dem Programmieren ist daher unbedingt ein Übersetzungsprogramm in den RAM zu laden! Dabei unterscheidet man drei Grundversionen :

1) ASSEMBLER Leider hat sich für das Übersetzungsprogramm von Assemblersprache in Maschinenspra-che ebenfalls das Fachwort Assembler eingebürgert.

2) INTERPRETER Dies sind Übersetzer, die nach dem Start eines Quellprogramms jeweils eine einzige An-weisung in Maschinenbefehle übersetzen und sofort ausführen. Erst dann wird die nächste Anweisung bearbeitet. Vorteil : Man kann ein Programm bis zu Fehlerstelle im Quelltext testen. Nachteil: Da immer nur eine Zeile übersetzt wird, liegt das Programm nie komplett übersetzt vor. Man muss bei jedem Start den Quelltext neu übersetzen, was sehr lange dauert. Der Interpreter muss ständig im Speicher verbleiben.

3) COMPILER Sie übersetzen ein komplettes Quelltextprogramm auf einmal in Maschinensprache und legen das Ergebnis entweder auf Diskette oder im RAM als Maschinenspracheprogramm ab. Vorteil : Sie brauchen das Programm nur ein einziges mal zu übersetzen; anschließend läuft es in Maschinensprache sehr schnell ab. Nachteil : Ein Maschinenspracheprogramm ist nicht mehr ohne weiteres zu verändern. Außerdem - und das ist das Problem - über-setzt ein Compiler Ihr Programm nur dann, wenn es fertig durchdacht ist und fehlerfrei vorliegt. Testen von Programmteilen ist nur bedingt möglich.

11.07.02

3-bedienung

Programmiertechnik Klasse : Informationsblatt Name : BEDIENUNGSHINWEISE



Turbo-Pascal starten und beenden Sie können den Compiler ganz einfach starten, indem Sie von der Betriebssystemebene aus im entsprechenden Pfad die Startdatei TURBO.EXE aufrufen. Nach kurzer Zeit meldet sich Turbo-Pascal mit dem Einschaltbild und wartet auf Ihre weiteren Eingaben. Wird während des Ladevorgangs der Fehler gemeldet: „cannot create swap file“, so kann Pascal seine Auslagerungsdatei ( swap file ) nicht öffnen. Das liegt daran, dass Sie den Schreib-schutz an Ihrer Diskette aktiviert haben oder im aktuellen Pfad keine Schreibrechte im Netzwerk besitzen. Beenden Sie Turbo-Pascal nie (!) , indem Sie einfach den Rechner ausschalten oder einen Reset auslösen, denn Pascal schließt dann die temporären Dateien nicht ordnungsgemäß. Auf Ihrer Diskette häufen sich dann Dateien, die etwa folgendermaßen aussehen : tp0dde7f.$$$ oder td2ed929.$$$. Verlassen Sie den Compiler immer nur über das Menue FILE mit dem Menuepunkt EXIT.

Programme laden und speichern Über das Pull Down Menue FILE können Sie entweder alte Programme bearbeiten ( OPEN ) oder völlig neue Programme entwerfen ( NEW ). Dazu müssen Sie aber angeben, in welchem Pfad auf Ihrer Diskette oder der Festplatte das Programm gesucht werden soll. Stellen Sie dies im Menuepunkt CHANGE DIR vorher ein. Zum Speichern Ihres Quelltextes bietet das Pull Down Menue zwei Varianten. Mit SAVE wird der Quelltext unter dem Namen gespeichert, der im Rahmen des blauen Bildschirms oben aktuell eingeblendet ist; das ist meist noname00.pas. Mit dem anderen Menuepunkt SAVE AS .. können Sie vor dem Speichern den Programmnamen ändern. Der Pfad in dem der Quellkode abgelegt wird entspricht dem, unter welchem auch gelesen wurde.

Programme compilieren und starten Ihre fertigen Programme übersetzen Sie in Maschinensprache mit dem Kommando COMPILE im Menue COMPILE. In Abhängigkeit von dem Schalter DESTINATION ( Zielort ) wird der Objektkode entweder im RAM abgelegt ( memory ) oder auf dem Datenträger ( disk ) gespeichert. Wo auf der Diskette oder der Festplatte Ihr Programm landet, hängt davon ab, welche Zielpfade Sie vorher eingestellt haben. Ihrer Wahl treffen Sie unter dem Menuepunkt OPTIONS und DIRECTORIES. Dort werden die Pfade für die EXE-Dateien vorgegeben. Sie können natürlich Ihr Programm nur dann erfolgreich compilieren lassen, wenn der Quelltext völlig fehlerfrei vor-liegt. Treten Fehler auf, so stellt Pascal den Cursor an die Stelle des Quelltextes, wo die Übersetzung aufgrund eines Syntaxfehlers abgebrochen hat. Das Kommando RUN startet das Programm für den Normalbetrieb, wobei das Startkommando bereits den Com-pileraufruf enthält. Sie sollten ein Programm aber nie starten, bevor Sie es nicht abgesichert haben. Hängt sich Ihr Programm aufgrund eines Logikfehlers auf, so bleibt nur der Neustart des Rechners und Ihr Programm im RAM des PC ist unwiderruflich verloren. Sie müssen dann alles noch einmal neu schreiben. Programme eingeben und bearbeiten Diesen Vorgang nennt man Editieren. Demzufolge erreichen Sie die wichtigsten Bearbeitungsfunktionen auch über den Menuepunkt EDIT. Sie können zuvor markierte Textteile in eine Ablage ( CLIPBOARD ) legen ( CUT ), sie hinein kopieren ( COPY ), sie wieder aus der Ablage entnehmen ( PASTE ) oder sie in der Ablage löschen ( DELETE ). Solche Blockoperationen erleichtern die tägliche Arbeit beim Eintippen von Quelltexten ungemein. Wollen Sie einen Buchstaben oder mehrere überschreiben und nicht einfügen, so müssen Sie mit der Taste INS ( Einfügen ) zwischen dem Überschreibmodus und dem Einfügemodus wechseln. Den eingestellten Modus ( die Betriebsart ) erkennen Sie an der Form des Cursors. Können Sie keine Leerzeilen mit RETURN mehr einfügen, so sind Sie mit Sicherheit im Überschreibmodus und müssen zum Einfügemodus wechseln. ----------------------------------------------------------------------------------------- Beachten Sie bitte : 1) Stellen Sie zunächst alle Quell- und Zielpfade exakt ein; Sie finden sonst Ihre Programme schlecht wieder ! 2) Speichern Sie Ihr Programm ca. alle 10 min als Sicherungskopie ab; es könnte der Strom ausfallen ! 3) Sichern Sie Ihre Programme auch auf Ihrer Diskette. Auf der Festplatte C: oder D: sind die Daten nicht sicher. 4) Speichern Sie Ihr Programm vor dem ersten Probelauf ab. Es könnte sich unwiderruflich „aufhängen“.

11.07.02

4-prgentwurf

Programmiertechnik Klasse : Informationsblatt Name : PROGRAMMENTWURF



Stufen der Programmentwicklung Der Weg von der Problemerkennung bis zur Lösung mittels Computer ist unter Umständen sehr lang und beschwerlich. Dabei liegen die Hauptprobleme weniger in der Programmierung als vielmehr dar-in, dass der Anwender das Problem und die Problemlösung nicht genau genug beschreiben kann. Ungefähre Vorstellungen führen grundsätzlich dazu, dass man sich verzettelt. Es hilft also nichts, wenn man sofort beginnt, mit seinen „Wurstfingern“ wild auf der Tastatur zu klappern bevor man nicht nachgedacht hat. Da der Pascal-Compiler unerbittlich ist, wenn Sie nicht planen, bin ich es auch und helfe nur, wenn die Vorarbeiten zum Programm sauber und eindeutig sind. PROGRAMMENTWICKLUNG 1) Lastenheft / Pflichtenheft - die Aufgabenstellung wird in einem ganzen Satz schriftlich u. grammatisch exakt beschrieben. - einzuhaltende Bedingungen werden geklärt, gewünschte Ergebnisse werden konkret definiert. 2) Problemanalyse - welche Daten werden eingegeben, welche werden ausgegeben ? - welche Variablen und welche Konstanten liegen vor ? Wie sollen sie heißen ? - welcher Art sind diese Variablen und in welcher Form sollen sie verwendet werden ? - welcher Algorithmus kann das Problem lösen ? ( Oft hilft eine Skizze weiter ! ) 3) Programmstrukturierung ( d.h. graphische Darstellung der Vorgehensweise ) - mit Hilfe eines Programmablaufplans PAP ( DIN 66001 ) - mit Hilfe eines Struktogramms nach den Herren Nassi und Shneiderman ( DIN 66261 ) 4) Codierung - Umsetzen der Algorithmen in eine Folge von Anweisungen ( Quelltext schreiben ) - Einstellen der Pfade zur definierten Abspeicherung - Abspeichern des Programmentwurfs als Sicherungskopie 5) Programmtest - Übersetzen des Quelltextes in den Maschinenkode ( Objektkode ) - Prüfung auf Codierfehler / Syntaxfehler - Prüfung auf logische Fehler durch Testläufe - Testläufe, um die Grenzen des Programms zu erkennen - Abspeichern des getesteten, fertigen Programms 6) Programmdokumentation - graphisches Einrücken der Anweisungen mit richtiger Schreibweise - Angaben zu Ort, Zeit, Version, Autor usw. im Quelltext - kurzer Kommentar mit Programmbeschreibung und Leistungsgrenzen - Kommentare zur Erläuterung von Variablen und Konstanten - Abspeichern des fertigen, kommentierten Programms Bei umfangreichen und komplexen Problemen zerlegt man die Gesamtaufgabe stufenweise in immer kleinere Teilprobleme, die dann einzeln nach der genannten Vorgehensweise bearbeitet werden ( Top Down Entwurf ). Solche in sich abgeschlossene und fertige Programmteile nennt man Module und fügt sie später durch Unterprogrammtechnik zusammen. Größere Unterprogrammsammlungen nennt man bei Turbo-Pascal UNITS.

11.07.02

5-strukto

Programmiertechnik Klasse : Informationsblatt Name : SINNBILDER FÜR STRUKTOGRAMME UND PAP’S



Sinnbilder für Programmablaufpläne und Struktogramme :

Die Programmdokumentation ist eine notwendige Voraussetzung zur Entwicklung und Wartung eines Programmes. Vor allem müssen die Programme grafisch dargestellt werden, weil nur so ein Überblick möglich ist. Speziell dafür verwendet man genormte Sinnbilder nach DIN 66261( Struktogramme nach Nassi und Shneiderman ) oder auch DIN 66001 ( Programmablaufplan ) .

Sinnbilder für Programmablaufpläne

Sinnbild Benennung

Operation allgemein

Unterprogrammaufruf

Ein- bzw Ausgabe

Verzweigung

Übergangsstelle

Grenzstelle

Ablauflinien

Schleifenbegrenzungfür zählergesteuerteWiederholungen

Elem ente von S truktogram m en

S innbild B enennung

A nw eisung 1

A nw eisung 2

A nw eisung 3

Folgeblockfür W ertzuw eisungen,R echenoperationenund B ildschirm befehle

A nw eisung 1

A nw eisung 1

( nicht geno rm t )

( nicht geno rm t )

A nw eisung 1

A nw eisung 2W iederholungsstrukturm it End ebed ingung

A nw eisung 1

A nw eisung 2

W iederholungsstrukturm it A nfangsbedingung

w iederhole bis ..

w iederhole solange

A nw eisung

B edingungnein ja a) einseitig

b) zw eiseitig

B edingungFall

1 2 3 4 ..m ehrfach

A ufruf U -Prg a) Funktionb) P rozedur

Bei umfangreichen Programmen mit vielen Programmverzweigungen erweist sich das Struktogramm als vorteilhaft. Es ist übersichtlicher. Das liegt auch daran, dass für Programmablaufpläne keine Sym-bolik genormt ist, mit der man eine Mehrfachverzweigung skizzieren kann.

Nicht nur für das Hauptprogramm müssen Ablaufpläne gezeichnet werden, sondern für jedes Unterprogramm zusätzlich. Das heißt, ein Programm mit z.B. 5 Unterprogrammen basiert auf der Grundlage von 6 Ablaufplänen.

11.07.02

6-prgaufbau

Programmiertechnik Klasse : Informationsblatt Name : AUFBAU EINES PROGRAMMS



Aufbau eines Programms Jedes Pascal-Programm muss nach bestimmten Regeln ( Syntax ) aufgebaut werden. Es besteht immer aus drei Teilen : 1) - dem Programmkopf 2) - dem Vereinbarungsteil ( Deklarationsteil ) 3) - dem Anweisungsteil ( Hauptprogramm ) Programmkopf : Er wird immer eingeleitet mit dem Schlüsselwort PROGRAM. Dahinter folgt nach einem Leerzeichen ( blank ) der Name des Programms. Er darf aus bis zu 127 Zeichen bestehen, mit Ausnahme von Leerzeichen. In manchen Pascal - Dialekten folgt nun die Angabe der benötigten Standard-Ein- und Ausgabeperipherie ( Tastatur und Bildschirm ). Allgemein gilt also : PROGRAM Name (input , output) ; Vereinbarungsteil : Damit alle benötigten Speicherplätze vom Programm richtig adressiert und wiedergefunden werden, müssen sie eingerichtet ( deklariert ) werden. In Turbo-Pascal vereinbart man : - Programmbibliotheken USES - Variable VAR - Konstanten CONST - Funktionen FUNCTION - Unterprogramme PROCEDURE - eigene Datentypen TYPE - Sprungadressen LABEL

Damit der Rechner auch weiß, wie groß der vorzusehende Speicherplatz sein muss, wird hinter den deklarierten Speicherplätzen und einem Doppelpunkt der sogenannte Datentyp angegeben. Hier zu-nächst die einfachen Datentypen von Turbo - Pascal :

1) numerische Datentypen BYTE kleine positive ganze Zahl 0 .. 255 ( 1 Byte ) SHORTINT kurze ganze Zahl -128 .. +127 ( 1 Byte ) WORD positive ganze Zahl 0 .. 65535 ( 2 Byte ) INTEGER ganze Zahl -32768 .. +32767 ( 2 Byte ) LONGINT große ganze Zahl -2147483648 .. +2147486647 ( 4 Byte ) REAL reelwertige Zahl -2,9 • 1039 .. +1,7 • 1038 ( 6 Byte )

Die reellen Zahlentypen SINGLE, DOUBLE, EXTENDED und COMP können mit dem Compi-lerbefehl $N+ eingeschaltet werden, wenn ein mathematischer Coprozessor vorhanden ist. Diese Compilerdirektive $N+ steht dann unmittelbar vor dem einleitenden Schlüsselwort PROGRAM.

2) ein einzelnes Zeichen CHAR alle 256 Zeichen des ASCII - Zeichensatzes ( 1 Byte ) 3) Wahrheitswert BOOLEAN für zwei Wahrheitswerte : true / false ( 1 Byte )

Aus diesen einfachen Datentypen lassen sich dann, zum Abspeichern von Namen beispielsweise, auch größere Datentypen ( strukturierte Datentypen ) zusammensetzen. a) STRING[n] Zeichenkette mit n Daten vom Datentyp CHAR ARRAY[n.. m] Folge von n bis m Elementen mit jeweils gleichem Datentyp einfacher Art RECORD Verbund von Datenfeldern verschiedener Datentypen FILE nichttypisierte Datei, die unstrukturiert ist b) SET of Untermenge eines Grundmengentyps der einfachen Datentypen

Anweisungsteil : Hier folgen nun die eigentlichen Pascal-Anweisungen zur Eingabe, Verarbeitung und Ausgabe. Die Anweisungen werden mit BEGIN und END. ( mit Punkt ! ) umklammert.

11.07.02

7-befehle

Programmiertechnik Klasse : Informationsblatt Name : STANDARD-PASCAL-BEFEHLE



Pascal - Schlüsselwörter Programmkopf PROGRAM < .. >; Kopfzeile mit Namen des Programms USES < .. >; Einbinden von externen Programmunits z.B. CRT, DOS; [ CRT = cathode ray tube ( Elektronenstrahlröhre ) ] Vereinbarungsteil CONST ... Konstantenvereinbarung ( Deklarationsteil ) VAR ... Variablenvereinbarung LABEL ... Sprungadressen ( möglichst nie verwenden !!! ) PROCEDURE ... Unterprogramme mit Namen und evtl. Parameterliste FUNCTION ... Subroutinen mit Ergebnislieferung an eine Variable TYPE ... Vereinbarung eigener Datentypen z.B. vom Typ Monat Anweisungsteil

Kontrollstrukturen BEGIN ... END; Anweisungsklammern. Das letzte END schließt mit einem "•" das Hauptprogramm ab.

IF .. THEN einseitige bedingte Anweisung IF .. THEN .. ELSE zweiseitige bedingte Anweisung CASE .. OF .. ELSE mehrseitige bedingte Anweisung REPEAT .. UNTIL .. Schleife mit Austrittsbedingung ( post check loop ) WHILE .. DO .. Schleife mit Eintrittsbedingung ( pre check loop ) FOR .. TO .. DO .. zählergesteuerte Schleife aufwärts FOR..DOWNTO.. DO zählergesteuerte Schleife abwärts

INLINE(Maschinencode) Einbinden einzelner Maschinensprachebefehle

Standardprozeduren Write ( .. ); Ausgabeanweisung ohne Zeilenvorschub WriteLn ( .. ); Ausgabeanweisung mit Zeilenvorschub und "Wagenrücklauf" Read( n ); Eingabe mit Return ReadLn( n ); Eingabe mit Return und anschließendem Zeilenvorschub

Nur in Verbindung n := ReadKey; Eingabe nur eines einzigen ASCII-Zeichens ohne Return mit der Unit CRT ! ClrScr; Bildschirm löschen

GotoXY(x,y); Cursor an die Bildschirmposition x,y positionieren TextColor( n ); Textfarbe verändern ClrEol; löscht den Rest der Zeile ab der Cursorposition

Standardfunktionen y := Sqr ( n ); Quadratfunktion y := Sqrt ( n ); Wurzelfunktion ( square root ) y := Exp( n ); Exponentialfunktion zur Basis e ( e = 2,718281.. ) y := Sin( n ); Sinusfunktion ( Ergebnisse liegen im Bogenmaß vor ! ) y := Cos( n ); Cosinusfunktion .. ebenfalls im Bogenmaß y := ArcTan( n ); Umkehrfunktion des Tangens ( n in rad ! ) y := Trunc( n ); Nachkommastellen abschneiden y := Round( n ); Wert runden y := Abs( n ); Absolutbetrag ( Vorzeichen spielen keine Rolle mehr ) y := Ln ( n ); Logarithmus naturalis ( Basis = e ) y := Succ ( n ); logischer Nachfolger wird ermittelt ( nur für Ordinalzahlen ) y := Pred ( n ); logischer Vorgänger y := UpCase ( n ); Buchstaben in Großbuchstaben umwandeln y := Random( n ); ergibt eine Zufallszahl zwischen 0 und der genannten Grenze n

Operatoren DIV ( n ); Division ohne Rest MOD ( n ); Modulodivision ( Rest bei ganzzahliger Division ) SHL; SHR Binärzahlen im Register links/rechts schieben ( shift left/right ) AND, OR, NOT logische Grundoperatoren XOR logische Exclusiv-Oder Verknüpfung

Standardvariable Port [ Adresse ] := n; Ein Byte n über einen Schnittstellenport ausgeben X := Port [ Adresse ]; Ein Byte über eine Schnittstelle in eine Variable X einlesen

11.07.02

8-StEin- Ausgabe

Programmiertechnik Klasse : Informationsblatt Name : STANDARD-EIN-, AUSGABE- FUNKTIONEN



Turbo-Pascal hat bereits eine Reihe von Prozeduren ( und Funktionen ) vordefiniert. Sie sind in der Unit SYSTEM abgelegt und gehören zum Standard-Sprachumfang. Mit anderen Worten : Diese Unterprogramme stehen Ihnen in jedem Programm standardmäßig zur Verfügung und können sofort eingesetzt werden. Die wich-tigsten sind die Ein- und Ausgabebefehle :

Eingabe Ausgabe Read ReadLn Write WriteLn Daten werden über die Tastatur eingelesen und in eine oder mehre-re Variablen ge-schrieben.

Daten werden über die Tastatur eingelesen und in eine oder meh-rere Variablen geschrieben. An-schließend erfolgt ein "Wagen-rücklauf" und ein "Zeilenvorschub"

Daten werden an der aktuellen Cur-sorposition unmit-telbar auf den Bild-schirm geschrieben.

Daten werden an der Cursorposi-tion unmittelbar auf den Bild-schirm geschrieben. Anschlie-ßend erfolgt ein "Wagenrücklauf" und ein "Zeilenvorschub"

Die Ausgabeanweisung Das Schlüsselwort zur Ausgabe von Daten auf den Bildschirm lautet zunächst Write oder WriteLn. Dahinter wird in runden Klammern angegeben, was ausgegeben werden soll. Und hier unterscheidet man grundsätzlich drei Möglichkeiten :

Ausgabe von Textkonstanten Ausgabe des Inhalts von Variablen oder Konstanten Ausgabe zum Drucker

WriteLn ( ' Text ' ); WriteLn ( Variable ); WriteLn ( Lst, ' Text ' );

Achten Sie darauf, dass Sie Texte zwischen Hochkommata setzen müssen, um sie von den Namen der dekla-rierten Variablen und Konstanten abzugrenzen. Jeder Befehl schließt übrigens am Ende der Zeile mit einem Semikolon ab. Wenn Sie in einer Anweisung mehrere Elemente gleichzeitig ausgeben wollen, so müssen Sie die einzelnen Komponenten in der Ausgabeanweisung durch Kommata trennen. Im folgenden Beispiel wird der Text "Die Entfernung beträgt :", der Inhalt der Variablen Länge und der Text "km" zusammen hintereinander ausgegeben. Beispiel : WriteLn ( ' Die Entfernung beträgt : ' , Laenge , ' km ' );

Ausgabeformatierung Damit Gleitkommazahlen ( Realzahlen ) am Bildschirm nicht mit 10 Stellen hinter dem Komma und mit Expo-nent zur Basis 10 ausgegeben werden ( das ist die wissenschaftliche Schreibweise ), wird die Ausgabeanwei-sung durch Parameter ergänzt, die eine Fließkomma-Notation ermöglichen. Das heißt, Sie müssen hinter dem Variablennamen, jeweils durch Doppelpunkte getrennt, die Gesamtzahl aller gewünschten Stellen - inclusive Dezimalpunkt und Vorzeichen - und die Nach-Stellen hinter dem Dezimalpunkt angeben. Bei der formatierten Ausgabe werden der Variablen Leerzeichen vorangestellt, wenn die Gesamtstellenzahl größer als die Stellen-zahl der Variablen ist. Damit wird ermöglicht, Werte für Tabellen dezimalpunktgenau am Bildschirm oder auf dem Drucker untereinander ausgeben zu lassen. Sehen Sie hier nun ein Beispiel mit Ergebnisausgabe auf dem Bildschirm für eine formatierte und eine nichtformatierte Ausgabe. Befehl Ergebnis nichtformatierte Ausgabe WriteLn ( Strom ); 1.3421645E-02 formatierte Ausgabe WriteLn ( ' Ibe = ', Strom:5:1, ' mA' ); Ibe = 13.4 mA

Die Eingabeanweisung Hier wird im Quelltext hinter dem Schlüsselwort Read oder ReadLn in Klammern der Variablenname angege-ben, in der die Eingabe gespeichert werden soll. Also einfach : ReadLn ( Laenge ); und schon wird die Eingabe über die Tastatur in der zuvor deklarierten Variablen mit dem Namen Laenge abgespeichert. Mehrfacheingaben in einem Quelltextbefehl sind zwar möglich, aber nicht zu empfehlen. Besonderheiten bei der Eingabe

• die Anweisung ReadLn; ohne folgende Klammer mit Variablenname wartet lediglich auf den Tasten-druck der RETURN - bzw. ENTER Taste.

• Reelwertige Zahlen werden mit Punkt statt mit Dezimalkomma eingegeben; also 27.12 statt 27,12 ! • sehr große oder sehr kleine Zahlen werden sinnvoller weise als Exponentialzahlen eingegeben, wobei

der Großbuchstabe E die Angabe der Basis 10 ersetzt. So wird z.B. statt 0.00000003 besser 3E-8 und statt 6200000 besser 6.2E6 eingegeben.

Tip : Durch Eingaben wie 999E32 oder 0.1E-32 lässt sich die Eingabe der beiden elektrotechnischen Grenzfälle Unendlich und Null simulieren, ohne eine -mathematisch nicht erlaubte- Division durch Null zu provozieren.

11.07.02

9-beispiel-eva

Programmiertechnik Klasse : Informationsblatt Name :

BEISPIELLÖSUNG EVA-PRINZIP



Entwicklung eines linearen Programms 1) Lastenheft ; Pflichtenheft : In Amerika wird die Temperatur nicht in Grad Celsius, sondern in Grad Fahrenheit gemessen. Es gilt : 0 °C ≡ 32 °F; 100 °C ≡ 212 °F Entwickeln Sie ein Programm, das nach Eingabe des Temperaturwertes in Grad Celsius den zugehörigen Wert in Grad Fahrenheit auf dem Bildschirm sauber geordnet und lesbar ausgibt. 2) Problemanalyse : a) Eingabevariable: T_Celsius ; Datentyp : kurze ganze Zahl, also SHORTINT; b) Ausgangsvariable T_Fahrenheit ; Datentyp : vermutlich reelwertig; also REAL c) Benötigt wird die Bildschirmbibliothek CRT ( cathode ray tube ) d) Algorithmus : Während die Temperatur in Celsius um 100 Grad steigt, steigt Sie in Fahrenheit um 180 Grad 212 °F - 32 °F = 180 °F ; d.h. das Verhältnis zwischen den Temperaturen beträgt 180/100 oder gekürzt 9/5. Außerdem ist die Temperatur in Fahrenheit um 32°F konstant höher. Daraus ergibt sich der Algorithmus zur Umrechnung : T_Fahrenheit = 9 °F/5 °C • T_Celsius °C + 32 °F 3) Programmstrukturierung a) Struktogramm b) Programmablaufplan

4) Codierung ohne Programmdokumentation PROGRAM Fahrenheit; USES CRT; VAR T_Celsius : SHORTINT; T_Fahrenheit : REAL; BEGIN ClrScr; WriteLn(´Umrechnungsprogramm Grad Celsius in Grad Fahrenheit´); Write (´Bitte geben Sie die Temperatur in Grad Celsius ein :´); ReadLn ( T_Celsius ); T_Fahrenheit := 9 / 5 * T_Celsius + 32; WriteLn(´Die Temperatur in Grad Fahrenheit beträgt : ´, T_Fahrenheit:6:2 ,´ °F´); ReadLn; END.

Start

Deklaration

Bildsch. löschen

AusgabeÜberschrift

EingabeT_Celsius

BerechnungT_Fahrenheit

AusgabeT_Fahrenheit

Bildschirmfixieren

Ende

Programm Fahrenheit

Deklaration

Beginn

Ende

Bildschirm löschen

Überschrift ausgebenEingabe des CelsiuswertesBerechnung des Fahrenheitswertes

Ausgabe des Fahrenheitswertes

Ausgabebildschirm fixieren

Michael

BEGIN

Michael

Umrechnungsprogramm

Michael

WriteLn(

Michael

Celsius

Michael

VAR

11.07.02

10-dokumentation

Programmiertechnik Klasse : Informationsblatt Name : DOKUMENTATION



10 Regeln für die Dokumentation:

Sie alle werden folgende Situation kennen lernen : Das Programm läuft, Codierfehler gibt es keine mehr und man ist fertig mit dem „Hacken“. Das Programm ist abgespeichert und man lehnt sich ruhig zurück. Zwar ist der Quelltext noch in einem chaotischen Zustand, aber was soll’s, das Problem ist ja gelöst. Wie der Lehrer mit dem Programm klarkommt ist sowieso unwichtig. Sein Problem ! Nach einigen Wochen aber benötigen Sie selbst Teile dieses Programms erneut. Zwar ist ihr altes Programm noch immer in chaotischem Zustand, aber kein Problem, es gibt ja Programmlistings über den Drucker, um den Überblick wieder zu bekommen. Der Programmablaufplan ist sowieso verschwunden und wenn nicht, dann weiß man nicht mehr zu welchem Programm er gehört. Darüber hinaus werden Sie sich fragen, welche Bedeu-tung die Variablen x, y und z damals hatten. Welche Taste war mit „ #69 “ gemeint ? Wieso ist an die Formel der Zusatz 2•π/180 angehängt worden ? Und so weiter ... Schließlich schreien Sie wieder nach dem Lehrer, der im hausgemachten Chaos zu retten versucht, was zu retten ist. Dies alles kostet Zeit, Papier und Nerven. Kurz und gut: Langsam aber sicher wächst das planlose Chaos Dies alles lässt sich vermeiden, wenn man sein Programm vernünftig dokumentiert. Schauen Sie sich deshalb das folgende Negativprogramm an. Obwohl es einfach ist, ist es dennoch schwer nachzuvollziehen.

program test1; const x=60; var y,z :real; begin write(´gesamt´); readln(y); z:=100*x/y; write (´1/100KM´); writeln(z:10:2); end.

1) Befehle für Pascal Kontrollstrukturen schreibt man ausschließlich in Großbuchstaben; ebenso wie die Schlüsselwörter für den Programmkopf und den Vereinbarungsteil. Auch Operatoren schreibt man komplett groß; z.B.: PROGRAM, IF .. THEN .. ELSE oder XOR .

2) Bei Standardfunktionen und Standardprozeduren wird nur der erste Buchstabe groß geschrieben. Ausnahme bilden die aus zwei eigenen Wörtern zusammengesetzten Ausdrücke, bei denen je-weils der Anfangsbuchstabe alleine groß geschrieben wird; z.B.: ArcTan, WriteLn, KeyPressed oder ReadLn.

3) Pro Zeile wird im Quelltext nur ein einziger Befehl notiert.

4) Konstanten und Variablen erhalten eindeutige Bezeichnungen, die entweder genormt sind oder aus denen die Bedeutung klar hervorgeht. z.B. ist „ T “ nicht die Zeit, sondern die Periodendauer in Sek.

5) Variablen und Konstanten werden im Quelltext mit Kommentaren versehen, aus denen z.B. die Einheiten und der Einheitenvorsatz deutlich werden. Kommentare stehen entweder zwischen ge-schweiften Klammen .... oder zwischen den kombinierten Zeichen (* .... *). Sie werden nicht mit kompiliert.

6) Jedes Programm erhält einen Programmkopf als Kommentar, aus dem die Daten zur Ort, Zeit, Version und Autor; sowie zur verwendeten Hard- und Software hervorgehen. Darüber hinaus erhält der Programmkopf eine kurze Programmbeschreibung mit evtl. Besonderheiten als Hinweis.

7) Zwischen den einzelnen Programmteilen sind Leerzeilen im Quelltext vorzusehen.

8) Eingeklammerte Programmteile, z.B. Schleifenkörper oder Programmteile zwischen BEGIN und END werden um zwei Spatien eingerückt. Erfolgt dort eine weitere Einklammerung, wird nochmals um zwei Spatien eingerückt und so weiter. Mit Beendigung der Klammer entfällt das Einrücken.

9) Vor jeder Dateneingabe wird eine Anfrage des Rechners ausgegeben. Programmausgaben erfol-gen in sinnvoller Art und Weise und nicht in Form von U = 1,3421645E-02, ohne Einheiten und ohne elektro-technische Notation, sondern in Form von : Uaus = 13,4 mV

10) Programme erhalten einen eindeutigen Namen, natürlich nach den Regeln von MS-DOS.

Nur wenn Sie sich an alle diese Regeln halten, nehmen Dozenten oder Zeitschriften Ihre Programme an. Sie ersparen sich auch viel Ärger in Datennetzen und bei Kommilitonen während des Studiums. Nach einiger Zeit des Eingewöhnens werden Sie sehen, dass dies ganz normal ist und auch einen Sinn hat.

11.07.02

11-übung-eva

Programmiertechnik Klasse : Informations- und Arbeitsblatt Name : ÜBUNGSAUFGABEN ZUM LINEAREN PROGRAMMABLAUF



Übungsaufgaben für lineare Programme

Bevor Sie beginnen, Ihre ersten Programme in Turbo-Pascal zu programmieren erinnern Sie sich bitte daran, dass ein strukturiertes Vorgehen das Wichtigste überhaupt ist. Programmierknechte, die später Ihre gedankliche Arbeit in einen Quelltext umsetzen gibt es auf dem Arbeitsmarkt genug. Wenn überhaupt, dann entwickeln Sie als Ingenieur später nur das Konzept und die Dokumentation. Beachten Sie also die Hinweise zur Programmentwicklung auf dem Blatt 4/25 ! Aufgabe 1: Ein Messwerk mit einem Innenwiderstand von 1500Ω hat einen Endausschlag von 1,5 V. Schreiben Sie ein Programm, das nach der Eingabe eines gewünschten Messbereichs den benötigten Vor-widerstand in kΩ ausgibt. Folgende Bildschirmdarstellung sei fürs erste vorgeschlagen : Meßbereichserweiterung =================== Geben Sie bitte den gewünschten Messbereich in Volt ein ? xxx Der erforderliche Vorwiderstand für das Instrument beträgt : yyyy.yy kΩ Aufgabe 2: Schreiben Sie zwei Programme, die Vektoren - z.B. aus der Elektrotechnik - umrechnen. a) Von der Polarform in die Rechteckform P ==> R b) von der Rechteckform in die Polarform R ==> P In der Elektrotechnik ist dies ein grundlegendes Rechenverfahren beim Umgang mit komplexen Zah-len in der Wechselstromtechnik. z.B. für die Impedanz Z = 100 Ω + j 230 Ω oder Z = |Z| + e jϕ

Die Ausgaben sollten in folgender Form auf dem Bildschirm dargestellt werden :

Vektor = xx.xx [ Einheit ] • e^ j yy.yy ° bzw. Vektor = xxx.xxx [ Einheit ] + j yyy.yyy [ Einheit ] Aufgabe 3: Das Volumen eines Gases ( 3000 cm3 = 3 l ) bei 20 °C und einem Druck von 998 hPa soll für die Normalbedingung ( 1013 hPa und 0 °C ) umgerechnet werden. Die Umrechnung kann mit der allge-meinen Gasformel, die den Zusammenhang zwischen Gasvolumen, Druck und Temperatur be-schreibt, berechnet werden. Aufgabe 4: Ein Programm soll Sie nach Vornamen, Namen, PLZ, Ort, Straße und Hausnummer fragen. Nach der hoffentlich geglückten Eingabe der 6 Daten, soll das Programm auf Anfrage [ j(a) oder y(es) ] Ihre Daten mitten auf dem Bildschirm in Form einer Visitenkarte geordnet wieder ausgeben. Aufgabe 5: Zerlegen Sie die Aufgaben 1 bis 3 in Prozeduren ( siehe dazu Blatt 12/25 ) . Aufgabe 6: Laden Sie ein Register mit der Binärzahl: 0101 0101(2) und schieben Sie alle Bits im Register um zwei Stellen nach links. Verknüpfen Sie das Ergebnis logisch UND mit der Maske 1100 000(2) und geben Sie an, welches Bit im Register zum Schluss noch gesetzt ist. Und denken Sie daran : Program testing can be used to show the presence of bugs, but never to show their absence ! Zitat nach E.W.DIJKSTRA

11.07.02

12-prozeduren

Programmiertechnik Klasse : Informationsblatt Name : PROZEDUREN ALS UNTERPROGRAMME



Prozeduren

Ein langes Programm kann sehr schnell unübersichtlich werden. Man fasst deshalb Teilprobleme zu Unterpro-grammen zusammen. Aus dem Hauptprogramm werden diese Unterprogramme dann entsprechend aufgerufen. Das bringt vor allem dann Vorteile, wenn ein Unterprogramm mehrfach genutzt werden kann. In Turbo-Pascal unterscheidet man zwei Arten von Unterprogrammen ( subroutines ). a) die Prozeduren ( PROCEDURE ) - sie bewirken etwas nur dadurch, dass sie aufgerufen werden Beispiel : ClrScr; GotoXY(x,y); Randomize; Delay(x) usw. b) die Funktionen ( FUNCTION ) - sie liefern bei ihrem Aufruf stets nur einen Wert an eine Variable Beispiel : y:= sin(x); y:= sqrt(x); y:= round(x); y:=int(x); usw.

Subroutinen sind aber in Turbo-Pascal nicht nur fest vorgegeben, wie die obigen Beispiele, sondern sie können von uns auch selbst erstellt werden. Das ist z.B. unbedingt notwendig, wenn man ständig im Hauptprogramm die gleiche Berechnung durchzuführen hat oder mathematische Funktionen wie z.B.: y:= n! (Fakultät); y:= arc-sin(x); y:= ab oder auch y:= log(x) benötigt, die in Turbo-Pascal nicht zur Verfügung stehen. Wenn man dann eine größere Anzahl von Prozeduren und Funktionen erstellt und gesammelt hat, kann man in einem späteren Arbeitsschritt diese Subroutinensammlung in einer eigenen UNIT zusammenfassen und im Deklarationsteil mit USES <Name>; aufrufen ( s.S.13/20 ). Alle Subroutinen sind dann stets verfügbar.

a) einfache parameterlose Prozeduren Unterprogramme müssen im Hauptprogramm zunächst deklariert werden. Das geschieht mit dem Schlüssel-wort PROCEDURE gefolgt vom selbst gewählten Namen des Unterprogramms und dem Semikolon. Der An-weisungsteil der Prozedur steht genau wie beim Hauptprogramm zwischen BEGIN und END; hier allerdings gefolgt von einem Semikolon ! PROCEDURE Eingabe; VAR .... BEGIN Anweisung 1; Anweisung ..; END;

Im Hauptprogramm wird das Unterprogramm nur mit seinem Prozedur-Namen – und evtl. mit Parameteranga-ben - aufgerufen ( hier: Eingabe; ). Das Schlüsselwort Procedure entfällt beim Aufruf der Subroutine.

b) Lokale und globale Variable in Prozeduren Prozeduren sind fast genau so aufgebaut wie Programme selbst. Sie können deshalb auch einen eigenen De-klarationsteil enthalten. Variable, die innerhalb der Prozedur deklariert worden sind, gelten nur innerhalb dieser Prozedur. Im übergeordneten Hauptprogramm sind sie unbekannt. Man nennt sie lokale Variable. Im Haupt-programm deklarierte Variable sind im ganzen Programm, also auch in den Unterprogrammen gültig. Werden sie im Unterprogramm verändert, so haben sie auch im Hauptprogramm geänderte Werte. Es können also un-erwünschte „Seiteneffekte“ entstehen. Man nennt solche Variablen globale Variable. Innerhalb einer Prozedur können im Vereinbarungsteil weitere ( Unter- ) Prozeduren definiert werden, die aber nur aus diesem Unterpro-gramm heraus aufgerufen werden können.

c) Prozeduren mit Wert-Parameterübergabe ( call by value ) Einer Prozedur können Werte übergeben werden. Dazu wird der Prozedurkopf um Namen und Datentypenbe-zeichnung der empfangenen Variablen ergänzt. Also beispielsweise: PROCEDURE Addiere ( x, y : Byte ); Beim Aufruf der Prozedur im Hauptprogramm müssen natürlich die Parameter mit übergeben werden, wobei darauf zu achten ist, dass die Datentypen der einzelnen Parameter auch übereinstimmen. z.B.: Addiere ( 2,4 ); Da Wert-Parameter nicht verändert werden können ( es gibt ja keinen Speicherplatz, der für sie reserviert ist ), ist eine Rückgabe des veränderten Wertes an das Hauptprogramm nicht möglich. d) Prozeduren mit Variablen-Parameterübergabe ( call by reference ) Benötigt man veränderte Wert-Parameter später noch im Hauptprogramm, so muss man Variablen-Parameter im Prozedurkopf vereinbaren. Sie werden durch ein vorangestelltes VAR im Prozedurkopf gekennzeichnet. Beispiel : PROCEDURE Addiere ( VAR X, Y : Integer); Beim Aufruf im Hauptprogramm dürfen hinter dem Prozedurnamen aber nur Variable - und keine Konstanten oder arithmetischen Ausdrücke - angegeben werden, da diese ja an die geänderten Parameter zurückgegeben werden. Beispiel : Addiere ( a,b );

11.07.02

13-funktionen

Programmiertechnik Klasse : Informationsblatt Name : FUNKTIONEN ALS UNTERPROGRAMME



Funktionen

Funktionen sind spezielle Prozeduren, die als Ergebnis genau einen einzigen Wert, den Funktions-wert, an das aufrufende Programm zurückliefern. Auch sie müssen im Deklarationsteil des Hauptpro-gramms vereinbart werden. Das Schlüsselwort lautet FUNCTION gefolgt von dem Namen und der formalen Parameterliste. Zusätzlich wird hinter einem Doppelpunkt immer ein Datentyp als Ergebnis-typ erwartet. Eine Funktion gehorcht daher folgender Syntax : FUNCTION < Name > (< Parameterliste> : < Datentyp > ) : < Ergebnistyp >; VAR ...; BEGIN .... < Anweisungen >; < Name > := < Berechnung der Funktion >; .... END; Auch bei Funktionen können Wert-Parameter und Variablen-Parameter übergeben werden. Allerdings ist die Verwendung von Variablen-Parametern in Funktionen wenig sinnvoll, da nun zusätzlich zum einzelnen Funktionswert noch weitere Variablen übergeben werden können, was dem eigentlichen Sinn der Funktion entgegensteht. Nutzen Sie in einem solchen Falle Prozeduren. Beispiel: Es soll eine Funktion mit dem Namen „Sinus“ geschrieben werden, die die Eingabe des Winkels im üblichen Gradmaß erlaubt und den berechneten Wert an die Variable y übergibt. PROGRAM Test_einer_Funktion; Programmkopf USES CRT; VAR X,Y : REAL; Deklarationsteil FUNCTION Sinus( Winkel : REAL ): REAL; BEGIN Sinus := Sin( Winkel * Pi / 180 ); END; BEGIN (* Hauptprogramm *) Anweisungsteil ClrScr; Write (´Bitte Winkel eingeben : ´); ReadLn(X); E ingabe Y := Sinus (X); V erarbeitung Write (´Der Sinus des Winkels ´, X:7:2,´ beträgt : ´, Y :7:5 ); A usgabe END. Der Vorteil von Funktionen gegenüber Prozeduren besteht darin, dass sie im Hauptprogramm wie eine Variable behandelt werden und nicht wie eine Prozedur als Anweisung. Deshalb können nur Funktionen direkt in allen Ausdrücken z.B. Ausgabeanweisungen aufgerufen werden, ohne den Aus-gabewert zuvor einer Variablen zuweisen zu müssen. Für das obige Beispiel wäre also auch folgende Ausgabeanweisung erlaubt : WriteLn(´Der Sinus des Winkels ´,X:7:2,´ beträgt : ´, Sinus(X):7:5 ); Ruft man Prozeduren oder Funktionen in ihrem eigenen Anweisungsteil selbst immer wieder auf, so nennt man eine solche Subroutine rekursiv. Aber Vorsicht, der Heap-Speicher kann überlaufen.

11.07.02

14-units

Programmiertechnik Klasse : Informationsblatt Name : UNITS



Hat man viele zusammengehörige Prozeduren und Funktionen gesammelt, die zum Beispiel die Maus unter Turbo-Pascal steuern, den Datenaustausch über die serielle Schnittstelle regeln oder auch selbstgebastelte, erweiterte mathematische Funktionen, so kann man diese Programmteile in UNITS zusammenfassen. Die Vorteile liegen auf der Hand :

- Prozeduren / Funktionen müssen nur einmal geschrieben werden - Programme werden kürzer und übersichtlicher - zu einem Thema gehörende Subroutinen werden geordnet zusammengefasst

Eine Unit besteht aus drei Teilen : 1) dem Interface ( der Schnittstelle ); 2) der Implementation ( d.h. dem tatsächlichen Programmkode ) und 3) der Initialisierung ( einer Art Hauptprogramm ). Die grundsätzliche Struktur der Unit ist weitgehend mit der eines Programms vergleichbar. Ihr Aufbau ist anschließend aufgeführt : UNIT < name >; Das Schlüsselwort UNIT ersetzt hier den Begriff PROGRAM INTERFACE der Interface-Teil wird als „öffentlicher“ Teil bezeichnet. Er enthält alle Namen der Konstan- ten, Standard-Units, Variablen, Funktionen und Prozeduren, die dem Hauptprogramm zu gänglich sein sollen. Damit sind diese Elemente global vereinbart. Funktionen und Proze- duren werden allerdings nur mit ihren vollständigen Kopfteilen aufgeführt. IMPLEMENTATION Der eigentliche Quellkode der bereits im Interface-Teil genannten Funktionen oder Proze- duren erfolgt erst hier. Hier werden auch die lokalen Konstanten, Datentypen und Varia- blen vereinbart, die nur innerhalb der Unit gelten. BEGIN (* INITIALISIERUNG *) bleibt meist leer, nur wenn beim Start des Programms bestimmte Einstellungen für diese Unit erforderlich sind, kann hier ein Anweisungsteil stehen; z.B. ein Reset. END.

Wird ein solches Unit-Programm mit dem Pascal Compiler übersetzt, so entsteht im gesetzten Pfad ( Menue OPTIONS; Schalter DIRECTORIES; EXE & TPU directory ) eine Objektkode - Datei mit der Extension: < Unitname > •TPU ( Turbo Pascal Unit ). Anschließend können Sie die Unit in Ihrem Pro-gramm mit der USES - Anweisung jederzeit aufnehmen. Aber das kennen Sie ja bereits von der Ver-wendung der Standard-Units her, die mit Turbo-Pascal bereits geliefert wurden; z.B.: USES CRT. Die anderen Standard Units heißen: SYSTEM, DOS, PRINTER, GRAPH, OVERLAY, TURBO3 und GRAPH3. Sie sind in der Datei Turbo.TPL ( Turbo Pascal Library ) zusammengefasst. Beispiel für eine Cursor-Unit ( mit Verwendung des Video-Interrupts 10hex ) UNIT Cursor; BEGIN regs.ax:=$0100;regs.cx:=$2607;intr($10,regs); INTERFACE END; USES DOS; PROCEDURE Cursor_an; VAR regs : REGISTERS; BEGIN PROCEDURE Cursor_weg; regs.ax:=$0100; regs.cx:= $0C0D;intr($10,regs); PROCEDURE Cursor_an; END; BEGIN IMPLEMENTATION Anweisungen entfallen PROCEDURE Cursor_weg; END. Mit dem Programm TPUMOVER.EXE ( im Pascal-Paket enthalten ) kann man seine eigenen Units in die Standard-Pascal-Library für Units ( TURBO.TPL ) fest mit aufnehmen bzw. wieder entfernen. Das heißt, man muss nicht mehr darauf achten, ob die eigene Unit im richtigen Pfad zur Verfügung steht.

11.07.02

15-schleifen

Programmiertechnik Klasse : Informationsblatt Name : WIEDERHOLUNGSSTRUKTUREN



Schleifen; ( engl. loops ) In allen Programmen vorher befassten wir uns mit linearen Algorithmen; das waren Anweisungen, die eine nach der anderen schrittweise ausgeführt wurden. Nun kommt es aber häufiger vor, dass eine oder mehrere Anweisungen wiederholt durchlaufen werden müssen, weil Sie z.B. eine Eingabe falsch ausgeführt haben und nun noch einmal einlesen müssen. Oder Sie wollen die gleiche Rechnung noch einmal ausführen; allerdings mit geänderten Zahlenwerten. Wie auch immer, Sie müssen im Programm zurückspringen an die Stelle im Programm, die erneut durchlaufen werden soll. Allerdings nur so lange, bis eine Anweisung die Wiederholung verbietet. In Pascal stehen Ihnen dazu drei Möglichkeiten der Schleifenprogrammierung zur Verfügung :

Ist die Anzahl der Schleifendurch-läufe bekannt, so nutzt man die zählergesteuerte Schleife. Dazu gehört, dass man zunächst eine Zählervariable oder auch Laufvari-able deklariert die mitzählt, wie oft die Schleife schon durchlaufen wur-de. Es versteht sich von selbst, dass der Datentyp dieser Variablen eine Integerzahl bzw. eine ordinale Größe sein muss. Ist der Endstand erreicht, bricht die Schleife ab.

Syntax der Anweisung : FOR <Laufvariable> := <Anfangswert> (DOWN)TO <Endwert> DO BEGIN < Anweisungen > ; END;

Im Gegensatz zu anderen Programmiersprachen ist es bei dieser Anweisung nicht möglich, die Schrittweite anzugeben. Man weicht dann auf die beiden anderen Schleifenanweisungen aus.

Schleife mit Endebedingung Schleife mit Anfangsbedingung REPEAT WHILE < Bedingung erfüllt > DO < Anweisungen > ; BEGIN UNTIL < Bedingung erfüllt > ; < Anweisungen > ; END;

Solange in beiden bedingungsgesteuerten Wiederholungen die Bedingung erfüllt, also wahr ist, wer-den die eingeklammerten Anweisungen wiederholt. Wird die Bedingung falsch, geht das Programm zum nächsten, der Schleife folgenden, Befehl über. Die eingeklammerten Anweisungen bezeichnet man auch als Schleifenkörper. Die graphische Darstellung der drei Schleifenkonstruktionen für das Struktogramm oder den PAP entnehmen Sie bitte dem Blatt 5/25. Im PAP müssen die bedingungsge-steuerten Schleifen durch Verzweigungen dargestellt werden. Zum Schluss noch eine Auswahl an Vergleichsoperatoren für die Bedingungsprüfung : = gleich < > ungleich > größer Keypressed < kleiner >= größer gleich <= kleiner gleich EoLn Durch logische Operatoren können auch mehrere Bedingungen gleichzeitig abgefragt werden, z.B. : (B1) AND (B2) (B1) OR (B2) (B1) XOR (B2)

Wiederholungsanweisungen

Anzahl der W iederholungen bekannt ?

ja nein

zählergesteuerte Schleife bedingungsgesteuerte Schleife

Abbruchbedingungam Ende der Schleifeam Anfang der Schleife

Abbruchbedingung

kopfgesteuerte Schleife ( pre check loop )

fußgesteuerte Schleife ( post check loop )

11.07.02

16-übungen-loops

Programmiertechnik Klasse : Informations- und Arbeitsblatt Name : ÜBUNGEN ZU WIEDERHOLUNGSSTRUKTUREN



Übungsaufgaben für Wiederholungsstrukturen Bevor Sie die einzelnen Aufgaben konkret angehen, denken Sie bitte daran, dass die strukturierte Vorgehensweise ( Seite 4/25 ) das vorrangige Lernziel darstellt. Gerade hier sind die Programm-ablaufpläne oder Struktogramme unbedingt erforderlich. Werden die Abbruchbedingungen vorher nicht genau geprüft, bleibt das Programm in der Wiederholungsschleife „hängen“ und kann nur mit Gewalt abgebrochen werden. Der Quelltext geht damit unweigerlich verloren. Aufgabe 1: a) Ein konstanter Widerstand von R = 330 Ω mit einer maximalen Leistung von P = 0,5 W wird an unterschiedlichen Spannungen U = 1 V bis 29 V in Schritten a´ 4 V betrieben. Ermitteln Sie für jeden Spannungswert den dazugehörigen Strom, und geben Sie die Werte tabellarisch geordnet auf dem Bildschirm aus. b) Ermitteln Sie zusätzlich jeweils auch den maximal zulässigen Strom durch den Widerstand. Geben Sie auch diese Werte mit Einheiten in der Tabelle mit aus. c) Zeichen Sie die Graphen sauber in ein beschriftetes Diagramm, und lesen Sie ab, welche Span-

nung Umax noch möglich ist, ohne den Widerstand zu zerstören. Welcher Strom IR fließt? Aufgabe 2: An eine Ersatzspannungsquelle Uo = 12 V mit konstantem Innenwiderstand Ri = 10 Ω wird ein passi-ver Zweipol angeschlossen. Leider ist der Widerstand des „Verbrauchers“ nicht konstant, sondern schwankt von 1 Ω bis 101 Ω ( wir beginnen erst bei 1 Ω, um im Programm die Division durch Null zu vermeiden ). Berechnen Sie den Strom I, die Klemmenspannung Uk und die am „Verbraucher“ abge-griffene Leistung Pab für die unterschiedlichen Belastungsfälle. Geben Sie die Werte I = f(RL), Uk = f(RL) und Pab = f(RL) tabellarisch am Bildschirm aus. Zeichen Sie in einem Diagramm sauber die Graphen, deren Werte Sie mit Ihrem Programm ermittelt haben. Was können Sie für Schlüsse ziehen, wenn es um die Leistungsaufnahme eines „Verbrauchers“ geht ? Welche Forderung stellen Sie an ein Netzteil, ein Ladegerät oder an eine Satellitenantenne ?

Aufgabe 3: Innerhalb eines Programms soll eine Zahl eingelesen werden, die nicht kleiner als 20 aber auch nicht größer als 100 sein darf. Bei Falscheingaben muss der Wert neu eingelesen werden; und zwar so-lange, bis der Wert im Gültigkeitsbereich liegt. Programmieren Sie ein Unterprogramm, das diese Anforderung an die Eingabe übernimmt. Entwickeln Sie selbst ein Hauptprogramm, um die Subrouti-ne zu kontrollieren.

Aufgabe 4: Über die parallele Schnittstelle des Rechners, soll eine Platine mit 8 LEDs ( light emitting diode ) an-gesteuert werden. Die Leuchtdioden sollen dabei wie ein Lauflicht aufleuchten. Zur Programmierung über die parallele Schnittstelle siehe Blatt 17/25). Wie werden die LEDs angeschlossen ?

Aufgabe 5: Ein Programm soll mitten auf dem Bildschirm in 10 Reihen und 10 Spalten das „Kleine Einmal-Eins“ in Form einer Tabelle ausgeben; so dass man sofort z.B. das Produkt von 7 * 6 ablesen kann.

Aufgabe 6: Ein Potentiometer von 100 Ω wird als Spannungsteiler eingesetzt. An seinen Schleifer werden nach-einander die Lastwiderstände 5 Ω, 45 Ω, 85 Ω und 125 Ω angeschlossen. Berechnen Sie für jeden Lastwiderstand die Ausgangsspannung Uaus, wenn der Schleifer in 10 Ω – Schritten verändert wird.

11.07.02

17-LPT

Programmiertechnik Klasse : Informationsblatt Name : DIE PARALLELE SCHNITTSTELLE LPT



Will man mit dem Computer reale Prozesse steuern oder überwachen, so erfordert dies zunächst einmal eine geeignete Verbindung zur Außenwelt. Ein Programm soll ja in der Lage sein, Informatio-nen von außen zu erfassen und Steuersignale an äußere Geräte weiterzugeben. Das erforderliche Tor zur Außenwelt wird durch Interfaces geöffnet. Für PCs nach dem Industriestandard lassen sich, über die ohnehin vorhandenen Schnittstellen, die serielle Schnittstelle ( RS232 ), die Druckerschnitt-stelle ( Centronics ) und der Joystick-Anschluss direkt als Interface nutzen. Damit erübrigt sich jede weitere Hardware. Die parallele Schnittstelle ( LPT1 oder LPT2 ) des PCs stellt insgesamt 17 digitale Leitungen zur Ver-fügung, die sich für den schnellen Datenaustausch mit Interface-Schaltungen nutzen lassen. Die Ein- und Ausgänge sind TTL-kompatible Leitungen und nicht vor Überlastung geschützt ! Regeln :

1) Interfaceschaltungen nur bei ausgeschaltetem PC anschließen ! 2) An die Eingänge dürfen nur Gleichspannungen zwischen 0 V und 5 V gelegt werden ! 3) Ausgänge des Ports niemals kurzschließen oder mit anderen Ausgängen verbinden ! 4) An die Kontakte der 25-poligen Sub-D-Stecker keine Fremdspannungen anlegen ! 5) Alle Ausgänge dürfen nur mit maximal 10 mA „belastet“ werden ! 6) Induktive Lasten ( Relais, Motor ... ) grundsätzlich nur mit Freilaufdiode schalten !

Der Datenaustausch über den parallelen Port erfolgt über drei 8-Bit-Register, die jeweils unter einer Basisadresse ( BA ) und den beiden folgenden Adressen zu erreichen sind. Für die einzelnen Schnittstellen gelten folgende Basisadressen : Schnittstelle 1: LPT1 ⇒ $378 oder 888 Schnittstelle 2: LPT2 ⇒ $278 oder 632

Das erste Register heißt Datenregister und ist unter der Basisadresse zu erreichen. Es stellt ( in der Regel ) einen zusammenhängenden 8-Bit Ausgabeport zur Verfügung, dessen positive Spannungs-pegel sich im Bereich von 3,5 V bis 5 V bewegen (TTL-Pegel). Der Pascal-Befehl für die Ausgabe eines Bytes n über das Datenregister lautet : Datenausgabe Port [ BA ] := n ;

Unter der Portadresse BA + 1 kann man das Byte des Statusregisters in eine Variable einlesen und auswerten. Diese Hilfsleitungen für den Drucker sind meist TTL-kompatibel, d.h. offene Eingänge erscheinen als High-Pegel. Das Lesen der Daten über das Statusregister mit gleichzeitiger Korrektur des invertierten Eingangs „ busy “und Ausblendung der unbenutzten Eingänge 20 bis 22 lautet :

Variable := (Port [ BA+1 ] XOR 128) AND 248;

Die Portadresse BA + 2 erlaubt den Zugriff auf das Steuer- oder Controlregister. Über die vier Steuerleitungen können Informationen ausgege-ben werden. Da es sich aber um Open-Kollektor Ausgänge handelt, können sie auch gelesen wer-den, wenn man die Anschlüsse über 3,3 kΩ Wi-derstände gegen +5 V legt. Beachten Sie bitte, dass drei der vier Leitungen invertiert verwendet werden. Diese Invertierung kann aber bereits bei der Ein- oder Ausgabe über BA+2 wie folgt korri-giert werden : Ausgabe: Port [Ba+2] := n XOR 11; Eingabe: Variable:=(Port[Ba+2]XOR 11)AND 15;

Das Bit 25 des Steuerregisters schaltet die Richtung des Datenflusses im Datenregister um, wenn die Schnittstelle bidirektional ist oder im ECP- oder EPP-Modus arbeitet (BIOS).

7 6 5 4 3 2 1 0

Datenregister Adresse : BA

Steuerregister Adresse: BA + 2

7 6 5 4 3 2 1 0

D0 .. D7 ausgeben

nur lesen

errorselectpaper emptyacknowledgebusy (invert iert)

Statusregister Adresse: BA + 1

7 6 5 4 3 2 1 0ausgeben( evtl. lesen )

strobe (invertiert)autofeed (invertiert) init / reset select-in (invertiert)

13.07.02

18-verzweigungen

Programmiertechnik Klasse : Informationsblatt Name : ENTSCHEIDUNGS- BZW. VERZWEIGUNGSSTRUKTUREN



Im täglichen Leben müssen wir ständig Entscheidungen treffen. Meist sind es WENN .. DANN Ent-scheidungen, die oft erhebliche Auswirkungen haben. Auch in Programmen können wir solche Ent-scheidungen treffen. Solche Programme enthalten dann mindestens eine Bedingung, die darüber entscheidet, in welcher Reihenfolge die Anweisungen abgearbeitet werden. In Turbo-Pascal werden dabei folgende Auswahlstrukturen unterschieden :

• Einfache Auswahl - einseitige Auswahl IF .. THEN .. Sie ist ein Sonderfall der zweiseitigen Auswahl, der sogenannten Alternative. - zweiseitige Auswahl ( Alternative ) IF .. THEN .. ELSE .. Die abgefragte Variable kann zwei Fälle abdecken. • Mehrfache Auswahl ( Fallstruktur ) CASE .. OF .. END; Die in der Bedingung abgefragte Variable kann beliebig viele Fälle annehmen.

Bedingung erfüllt

nein

ja

Anweisung 1

Anweisung 2

IF < Bedingung=true > THEN BEGIN < Anweisungen > END ;

Bedingung erfüllt

nein

ja

Anweisung 1

Anweisung 2

IF < Bedingung=true > THEN BEGIN < Anweisungen 1,2 > ENDELSE BEGIN < Anweisungen a,b> END ;

Anweisung a

Anweisung b

Ausdruck

Anweisung 1

Anweisung 2

Anweisung 3

Fall1

Fall2

Fall3

CASE < Variable > OF < Wert1 > : BEGIN <Anweisungen 1> END; < Wert2 > : BEGIN <Anweisungen 2> END; < Wert3 > : BEGIN <Anweisungen 3> END;END;

Die Verwendung der einzelnen Verzweigungsstrukturen können Sie den Ausschnitten der Pro-grammablaufpläne entnehmen. Ihre zeichnerische Darstellung für die Struktogramme finden Sie auf der Seite 5/25. Es gibt eigentlich nur wenige Punkte bei der Programmierung zu beachten : • Wenn nach einer Auswahl nur eine Anweisung alleine ausgeführt werden soll, kann man die Ein-

klammerung der Anweisung mit BEGIN und END entfallen lassen; man rückt sie dann etwas ein. • Vor ELSE darf bei der zweiseitigen Auswahl kein Semikolon stehen ( trotz END ), da der gesamte

Befehl an dieser Stelle noch nicht beendet ist. • Bei der Mehrfachauswahl kann die Variable nur ordinale ( abzählbare ) Datentypen aufnehmen,

d.h. der logische Vorgänger PRED( n ) oder Nachfolger SUCC( n ) muss bekannt sein. • Bei der Mehrfachauswahl kann deshalb die Variable auch aus „Characters“ bestehen. Sie

steht/stehen dann in Hochkommata. Beispiel : CASE Variable OF ´A , a´ : BEGIN ... • Innerhalb eines Verzweigungsteils sind weitere Verzweigungen möglich; führen aber zu

unübersichtlichen Programmen. Besser ist hier die Mehrfachauswahl geeignet.

11.07.02

19-übungen-verzw

Programmiertechnik Klasse : Informations- und Arbeitsblatt Name : ÜBUNGEN ZU VERZWEIGUNGSSTRUKTUREN



Übungsaufgaben Verzweigungsstrukturen :

- Formulieren Sie das Problem in einem ganzen Satz. - Deklarieren Sie die notwendigen Konstanten, Variablen und deren Datentypen. - Skizzieren Sie den PAP und/oder das zugehörige Struktogramm. - Erstellen Sie den Quelltext und entfernen Sie alle Syntaxfehler. - Prüfen Sie Ihr Programm auf logische Fehler ( Testläufe ). - Dokumentieren Sie Ihr Programm. - Entfernen Sie Rechtschreibfehler aus Bildschirmmeldungen, und sorgen Sie für eine übersicht- liche und sinnvolle Bildschirmdarstellung.

Aufgabe 1: Prüfen Sie eine einzugebende Zahl auf ihr Vorzeichen; lassen Sie einen entsprechenden Kommentar ausgeben. Bedenken Sie auch die Grenzfälle des Zahlenbereichs !

Aufgabe 2: Lesen Sie das Statusbyte der parallelen Schnittstelle LPT2 ein, und lassen Sie ein Programm mel-den, ob die Leitung Acknowledge „high“ oder „low“ -Pegel hatte ( siehe Blatt 16/20 ).

Aufgabe 3: Erweitern Sie Ihre linearen Programme, welche Vektoren umrechnen. Wahlweise von der Polarform in die Rechteckform ; oder von der Rechteckform in die Polarform. Die Wahl wird über ein Menue mit < P > und < R > gesteuert. Fehleingaben sollen zur Fehlermeldung führen; die Eingabe erfolgt dann erneut. Ihr Programm wird übersichtlicher, wenn Sie Ihre linearen Umrechnungsprogramme zunächst in Prozeduren verwandeln, die Sie im Hauptprogramm nur aufrufen müssen.

Aufgabe 4: Der Laststrom und die Ausgangsspannung eines linearen Spannungsteilers soll berechnet werden. Dabei sollen Sie über ein Menue zwischen den drei Fällen : a) Kurzschluss; b) Leerlauf und c) Be-lastung wählen können. Als Referenzspannung sei hier 50 V vorgegeben. Wählen Sie mit <1>, <2> oder <3> . R1 = 220 Ω; R2 = 330 Ω; RL = 180 Ω . Schreiben Sie das Programm einmal mit IF .. THEN .. ELSE und einmal mit CASE .. OF .. END.

Aufgabe 5: Ein Programm soll quadratische Gleichungen in der Form : ax2 + bx + c = 0 lösen können. Beachten Sie die Fälle, in denen die Diskriminante negativ oder gleich „Null“ wird !

Aufgabe 6: In den pascalinischen Sümpfen leben die vier Stämme der Asis, Belas, Cedis und Drudis. Forschun-gen haben ergeben, dass es vier Eigenschaften gibt, die eine Unterscheidung der Stämme erlauben : ein Bewohner der Sümpfe kann ( muss aber nicht ) manuseln, einen Knelt haben, löpsen und nopeln. Man weiß, dass nur die Asis einen Knelt haben und manuseln. Hat jemand keinen Knelt und nopelt, dann ist er gewiss ein Bela. Ein Bewohner mit Knelt, der nicht manuselt, ist ein Cedi, wenn er immer nopelt. Wer keinen Knelt hat und löpst, nie nopelt und stets manuselt, ist mit Bestimmtheit ein Cedi; würde er nicht manuseln, wäre er ein Drudi. Es ist geradezu typisch für Drudis, dass sie weder manu-seln noch nopeln, aber einen ordentlichen Knelt haben. Ganz enthaltsame Bewohner, die keinen Knelt haben, nicht löpsen und nicht nopeln, sind Drudis, wenn sie manuseln, und Cedis, wenn sie nicht manuseln. Ein Programm soll nun die vier Eigenschaften eines Sumpfbewohners erfragen ( Antwort J/N ) und eine Diagnose liefern, zu welchem Stamm dieser gehört. Eine geschachtelte bedingte Anweisung, die genau der vorgegebenen Beschreibung folgt, löst das Problem.

13.07.02

20-beispiel-1

Programmiertechnik Klasse : Informations- und Arbeitsblatt Name : BEISPIEL KOMBINIERTE KONTROLLSTRUKTUREN TEIL 1



Beispielaufgabe mit kombinierten Kontrollstrukturen: Zur Steuerung von Gleichstrom-Motoren sind Brückenschaltungen hervorragend geeignet. Man setzt die Gleichstrommotoren in deren Mitte und kann ohne großen Aufwand die Drehrichtungen ändern. Eine solche Schaltung, die zusätzlich vor späteren Softwarefehlern schützt, finden Sie in nachfolgender Skizze.

Die Transistoren T1, T3 ( PNP ) und T2, T4 ( NPN ) bilden die Brückenschaltung, in deren Mitte der Mo-tor sitzt. Die Dioden D1 bis D4 sind die Freilaufdio-den für die Motorspule. D5 und D6 verhindern, dass bei falscher Ansteuerung nicht die beiden Komple-metär-Transistoren der Brücke durchsteuern; so wird ein Kurzschluss zwischen Ground und Betriebs-spannung vermieden. Die beiden Eingangstransisto-ren T5 und T6 sind PNP - Transistoren und interpre-tieren offene Eingänge als logisch High. Angesteuert werden sie über die Eingänge Ue1 und Ue2 mit lo-gisch Low. Ue1 und Ue2 liegen am Datenregister der parallelen Schnittstelle auf den beiden niederwer-tigsten Bits ( Adressen : s.S. 17/25 ) .

Aufgabe : Schreiben Sie ein Pascal-Programm, das die Drehrichtung des Gleichstrommotors mit den Tasten < R > für Rechtslauf, < L > für Linkslauf und < S > für Stopp steuern kann. Der Motor soll im Programm mehrfach umge-schaltet werden können. Der Abbruch des Programms soll über die ESCAPE - Taste erfolgen.

Problemanalyse : Der Motor lauft im Rechtslauf, wenn Ue1 = high und Ue2 = low Pegel erhält. Steuerbyte : 0000 0001 = 1 dez. Der Motor lauft im Linkslauf, wenn Ue1 = low und Ue2 = high Pegel erhält. Steuerbyte : 0000 0010 = 2 dez. Der Motor steht, wenn Ue1 = high und Ue2 = high Pegel erhält. Steuerbyte : 0000 0011 = 3 dez. Die Escape-Taste ist im ASCII-Kode durch „ #27 “ definiert und kann über eine Variable eingelesen werden.

Programmentwurf :

S tart

D e klaration

B ild sch irmlö sch en

S teuerleitungenauf R eset

Ü berschrift undM enue ausgeben

A usw ah l einlesen

W ahl ?

R

L

S

S teuerbyte R echts-lauf ausgeben

S teuerbyte Links-lauf ausgeben

S teuerbyte S toppausgeben

E scap e ?

nein

S teu erleitun genau f R eset

E n d e

Programm Drehrichtungssteuerung

Deklaration

Beginn

Bildschirm löschen

Steuerleitungen für den Motor auf Stillstand setzen

Überschrift ausgeben

Menue zur Steuerung ausgeben

wiederhole bis die Escape Taste betätigt wurde

Ende

Schnittstellen Reset ( Motor Stillstand )

Auswahl einlesen

Ist die Auswahl =

LR SSteuerbyte "2" Steuerbyte "1" Steuerbyte "3"

Rechtslauf Linkslauf Stopp

T1 T3

+5V .. +12 V

D1 D3

M

D2 D4T2 T4

D5 D6

Ground

Ue1 Ue2

120 120

120 120

2k7 2k7 2k7 2k7

D1..D4 = 1N4001D5, D6 = 1N4148T1 , T3 = BD242T2 , T4 = BD241T5 , T6 = BD140

11.07.02

21-beispiel-2

Programmiertechnik Klasse : Informations- und Arbeitsblatt Name : BEISPIEL KOMBINIERTE KONTROLLSTRUKTUREN TEIL II



Quelltext (**********************************************************************) (* Programm : Drehrichtungs-Steuerung *) (* Software : COMPILER Turbo Pascal 7.0 unter MS-DOS 6.22 *) (* Hardware : Pentium 133 MHz, VGA-Karte *) (* Ort/Datum : Hans-Böckler-Schule, 48155 Münster 11.07.02 *) (**********************************************************************) Dieses Programm steuert die Drehrichtung eines Motors über die Leitungen Bit1 und Bit2 des Datenregisters der parallelen Schnitt- stelle LPT2. Der externe Motor sitzt in einer Brückenschaltung mit Transistoren PROGRAM Drehrichtungs_Steuerung; USES CRT; CONST LPT = 632; (* Adresse LPT2 *) Zeitkonst = 3000; (* 3000 ms = 3 s *) VAR Eingabe : Char; BEGIN (* Hauptprogramm *) ClrScr; Port[LPT]:= 3; (* Bit1= 1 ; Bit2= 1 *) GotoXY(1,3); TextColor(6); WriteLn ('Drehrichtungssteuerung eines Motors'); TextColor(7); WriteLn; WriteLn('Geben Sie bitte die gewünschte Steuerung an :'); WriteLn; WriteLn('Rechtslauf < R >'); WriteLn('Linkslauf < L >'); WriteLn('Stopp < S >'); Write ('Abbruch mit < ESC > ==> '); REPEAT Eingabe := ReadKey; CASE Eingabe OF 'R','r' : BEGIN Port[LPT] := 1; (* Bit1= 1 ; Bit2= 0 *) GotoXY(1,13); ClrEol; WriteLn('Der Motor läuft nun im Rechtslauf.'); GotoXY(33,11); END; 'L','l' : BEGIN Port[LPT] := 2; (* Bit1= 0 ; Bit2= 1 *) GotoXY(1,13); ClrEol; WriteLn('Der Motor läuft nun im Linkslauf.'); GotoXY(33,11); END; 'S','s' : BEGIN Port[LPT] := 3; (* Bit1= 1 ; Bit2= 1 *) GotoXY(1,13); ClrEol; WriteLn('Der Motor steht nun.'); GotoXY(33,11); END; END; UNTIL Eingabe = #27; (* ASCII Nr.27≡Escape*) ClrScr; GotoXY(20,10); Textcolor(18); Write('That`s all folks ....'); Port[LPT]:=3; (* Bit1= 1 ; Bit2= 1 *) END.

11.07.02

22-arrays

Programmiertechnik Klasse : Informationsblatt Name : ARRAYS / FELDER



Information : Bei vielen Problemstellungen wäre eine Lösung nur sehr schwer und umständlich zu programmieren, wenn nur die einfachen Datentypen CHAR, REAL, INTEGER usw. zur Verfügung stünden. Deshalb bieten viele Programmiersprachen die Möglichkeit, aus den einfachen Datentypen weitere Datenty-pen zusammenzusetzen. Man nennt solche Datentypen strukturierte Datentypen. Je nachdem wie die neuen Datenstrukturen gebildet werden, unterscheidet man in Pascal zwischen

• Feld : ARRAY ( Zusammenfassung mehrerer Elemente gleichen Datentyps ) • Menge : SET ( bestimmte Anzahl von Elementen eines ordinalen Datentyps ) • Satz : RECORD ( Zusammenfassung von Daten unterschiedlichen Datentyps ) • Datei : FILE ( Folge von Sätzen, die meist die Struktur eines Records haben )

Ziel : Hier soll zunächst nur der zusammengesetzte Datentyp ARRAY besprochen werden.

Ein ARRAY – oft auch Feldvariable genannt – können Sie sich wie ein Regal mit vielen Fächern vor-stellen. In jedem der Fächer kann ein Gegenstand gleichen Typs aufbewahrt werden. Dabei kann es vorkommen, dass die Fächer nicht nur nebeneinander, sondern in mehreren Reihen übereinander oder sogar zusätzlich noch hintereinander liegen. Wollen Sie nun jemanden beauftragen , einen Ge-genstand zu holen, so bitten Sie ihn beispielsweise, den Gegenstand aus dem linken Fach in der zweiten Reihe von oben zu entnehmen. Um also auf eine Variable in einem Feld zuzugreifen, nennen Sie lediglich die Lage ( den Index ) im Feld. Dieser Index muss deshalb als Variable vorab deklariert werden. Natürlich muss das Feld selbst auch im Deklarationsteil vereinbart werden. Allgemein gilt für die Felddeklaration folgende Syntax :

VAR < FeldBezeichner > : ARRAY [ < IndexAnfang > .. < IndexEnde > ] OF < Datentyp > ;

Da wir hier nur einen einzigen Index verwenden, spricht man von einem eindimensionalen Feld -ähnlich einer einzigen Reihe von nebeneinander gelegenen Schubladen im Regal. Nur .., die Schub-laden sind im Moment noch leer, denn die Felder wurden noch nicht gefüllt. Auf sie kann, durch einen in eckigen Klammern angegebenen Index, während der Laufzeit des Programms lesend oder schrei-bend zugegriffen werden.

Daten aus der Tabelle lesen Daten in die Tabelle schreiben Wert := FeldBezeichner [ Index ] ; FeldBezeichner [ Index ] := Wert ;

Sie können aber nicht nur ein dynamisches Array zur Laufzeit erzeugen, sondern bereits zur Ent-wurfszeit können die Einträge in eine Feldvariable erfolgen. Dazu muss das Array lediglich als typi-sierte Konstante deklariert werden, dem die Einträge (Items) sofort zugewiesen werden. Beispiel :

CONST Woche : ARRAY [ 1.. 7 ] OF STRING = (’Montag’, ’Dienstag’, ’Mittwoch’ , ... , ’Sonntag’);

Soll die Feldvariable außer Zeilen auch noch Spalten enthalten so spricht man von einem zweidimen-sionalen Feld, oft auch als Matrix oder Tabelle bezeichnet. Auch hier müssen die Elemente vom glei-chen Datentyp sein; lediglich ein zweiter Index muss vereinbart werden, um sowohl die Zeile als auch die Spalte richtig adressieren zu können. Auch dreidimensionale und noch höherdimensionale Felder sind möglich, sprengen jedoch schnell die Speichergrenzen und können jenseits der drei Dimensio-nen nur noch sehr schwer verstanden werden. Mit dem Compilerbefehl $R+ können sie eine Be-reichsüberprüfung einschalten, um zu verhindern, dass ein Zugriff über die Grenzen eines Feldes hinaus erfolgt. Die Deklaration und der Zugriff auf ein zweidimensionales Feld erfolgt wie im Beispiel:

Deklaration Zugriff VAR Bezeichner : ARRAY [n..m, x.. y] OF WORD; Wert : = Bezeichner [ Index1, Index2 ];

Ein mehrdimensionales Array kann auch anders deklariert werden; für welche Art Sie sich entschei-den bleibt Ihnen überlassen : VAR MyArray : ARRAY [ n..m ] OF ARRAY [ x..y ] OF DatenTyp;

11.07.02

23-records

Programmiertechnik Klasse : Informations- und Arbeitsblatt Name : RECORDS BZW. VERBUND

Hans- Böckler-Schule


Eine Vereinigung von Daten unterschiedlichen Typs wird als Datensatz bezeichnet. Pascal kennt zur Darstellung eines solchen Datensatzes den Datentyp Record - auch als Verbund bekannt, in dem sich viele unterschiedliche Datenfelder vereinen lassen. Im Gegensatz zum Array ( Feld ) können hier unterschiedliche Datentypen zu einer Einheit zusammengefasst werden. Die entstehenden Variablen nennt man deshalb Verbund- bzw. Recordvariable.

Beispiel : Bei der Auswertung von Lottozahlen, die in einer Tippgemeinschaft spielen, muss sichergestellt sein, dass die einzelnen Tippreihen, die aus 6 Zahlen zwischen 1 und 49 bestehen, dem einzelnen Spieler zugeordnet werden können. Zunächst initiiert man daher eine Variable Spieler und deklariert sie als Record :

VAR Spieler : Record Name : String[20]; Tippreihe : Array[1..6] OF Byte; End;

Der Zugriff auf die Einzeldaten im Record erfolgt über den Variablennamen und den Feldnamen, die durch einen Punkt, den sogenannten Qualifizierer, getrennt sind. Hier z. B.: WriteLn ( Spieler.Name );

Es muss also ständig der Verbundvariablen_Name und der Feld_Name angegeben werden, was mit viel Schreibarbeit verbunden ist. Deshalb gibt es in Pascal die Möglichkeit, die Schreibweise mittels der WITH-Anweisung abzukürzen und auf den Verbundvariablen_Namen zu verzichten.

In allgemeiner Form lautet die Anweisung :

WITH Verbundvariable DO Begin Anweisung_1; Anweisung_2; …; end;

Für unseren Fall gilt: WITH Spieler DO Begin WriteLn ( Name ); FOR n := 1 TO 6 DO Write ( Tippreihe [n] :6 ); end;

Da die Datensätze für alle Spieler der Tippgemeinschaft gleich sind, liegt es nahe, dass man die Spie-ler in einem eindimensionalen Feld ( Array ) zusammenfasst. Man bildet dafür eine zusammengesetz-te Datenstruktur das :

VAR Spielgemeinschaft : ARRAY [ 1 .. n ] OF Record Name : String[20]; Tippreihe : Array [ 1.. 6 ] OF Byte; End;

Der allgemeine Zugriff auf diese Datenstruktur erfolgt über Feldvariablen_Name[Index].Feld_Name

Aufgabe : Entwickeln Sie eine Musteranwendung für eine Tippgemeinschaft mit 5 Spielern. Per Zufallsgenerator sollen für alle 5 Spieler die Tippreihen gezogen werden.

Über ein Menue kann auf die Daten der Spieler zugegriffen werden.

Spieler 1

NameTippreihe

Spieler 2

NameTippreihe

Spieler 3

NameTippreihe

Spieler n

NameTippreihe

Array Spielergemeinschaft mit 1.. n Records

11.07.02

24-mengen

Programmiertechnik Klasse : Informations- und Arbeitsblatt Name : MENGEN ( SETS )



Information: Interessanterweise gehören Mengen zu den Pascal-Strukturen, die am wenigsten eingesetzt werden. Das mag daran liegen, dass die Unterstützung von Mengen nur in Pascal unterstützt wird und in den meisten Programmiersprachen nicht. Der Begriff Menge oder Set stammt aus der Mengenlehre und beschreibt eine Ansammlung von Daten des gleichen Typs, die als eine Einheit ( Teilmenge ) gese-hen werden. Der Basisdatentyp aus dem die (Teil-)Menge gebildet wird muss ordinal sein, d.h., sie müssen abzählbar sein. So sind z.B. alle Großbuchstaben eine Menge der ASCII-Zeichen oder alle Ziffern zwischen 1 und 9 eine Menge der Ganzzahlen bzw. wiederum eine Teilmenge der ASCII-Zeichen. Mengenwerte können nicht über die Tastatur eingegeben werden, sondern sie müssen per Anwei-sung gebildet werden. Die erste Möglichkeit besteht darin, die Elemente der Mengen zwischen ecki-gen Klammern anzugeben. Bei zusammenhängenden Bereichen genügt es das erste und letzte Ele-ment getrennt durch zwei Punkte anzugeben. Andere werden durch Kommata getrennt. Beispiele : [ ‘a‘ .. ‘z‘ ] oder [ ‘A‘, ‘E‘, ‘I‘, ‘O‘, ‘U‘ ] bzw. gemischt [ 0..9, 15,33,77 ] oder Leermenge [ ] Die zweite Möglichkeit ist die implizite Mengenverwendung. Als Beispiel möge die Benutzeroberfläche eines Programms in Form eines Menüs dienen. Die einzelnen Funktionen des Menüs können durch Tippen des Anfangsbuchstabens ausgelöst werden. Dabei dürfen natürlich nur ganz bestimmte Buchstaben eingegeben werden, anderenfalls soll die Eingabe wiederholt werden. Als zugelassene Buchstaben legen wir ( L)inks, (R)echts und (S)top sowie deren Kleinbuchstaben fest. VAR m:CHAR; .... Repeat m:= ReadKey; until m IN [ ‘L‘, ‘R‘, ‘S‘, ‘l‘, ‘r‘, ‘s‘ ]; ...

Mit Hilfe des logischen Operators „IN“ wird festgestellt, ob der Wert der Variablen m in der Menge enthalten ist. Das Ergebnis dieser Prüfung ist stets vom Typ Boolean, also-wahr (true) oder falsch (false). Alternative : ..NOT m IN ..

Mengen können natürlich auch explizit deklariert werden. Dazu dient die folgende Anweisung : VAR <name> : SET OF <mengendatentyp>; Dabei kann der Mengendatentyp ein einfacher Standarddatentyp, ein Teilbereichtstyp oder ein selbstdefinierter Typ sein.

Beispiel : VAR Buchstabe : SET OF CHAR; .... Buchstabe := [ ‘A‘ .. ‘Z‘ ];

Beachten Sie bitte, dass die Variablen vom Typ Menge nicht ein Datum aus der Menge besitzen, sondern immer die gesamte Menge. Deswegen können Variablen vom Typ SET OF auch nicht direkt auf dem Bildschirm mit Write bzw. WriteLn ausgegeben werden. Die Kardinalität (Anzahl der Elemen-te) in einer Menge kann unter Extended Pascal mit anzahl:= card ( menge); ermittelt werden. Die Anzahl der zugeordneten Elemente im SET darf 256 nicht überschreiten ! Auf Mengendatentypen können logische Operatoren angewendet werden, deren Operatoren, Ope-ranten und Resultate wiederum Mengen sind. Z.B.: Durchschnitt / Schnittmenge (M1 * M2 → ODER); Vereinigungsmenge ( M1 + M2 → UND ); Teilmenge ( M1 <= M2 ) usw. Aufgabe : Erstellen Sie ein Programm mit Hilfe von Mengen, dass aus einer Zahlenmenge von 256 alle geraden Zahlen, alle ungeraden Zahlen und alle Primzahlen isoliert und als Teilmengen anzeigt. Visualisieren Sie Ihren Programmentwurf mit Hilfe eines Struktogramms oder Programmablaufplans.

11.07.02

25-type

Programmiertechnik Klasse : Informationsblatt Name : EIGENE DATENTYPEN



Information: Die wichtigsten Standard-Datentypen von Turbo-Pascal wurden bereits behandelt. Natürlich gibt es noch mehr ( Pointer, Object, Text, File usw. ) aber hier soll nur vorgestellt werden, wie man mit Hilfe der TYPE-Vereinbarung im Deklarationsteil des Programms eigene Datentypen vereinbart und wozu das gut sein kann. Einschränkend muss natürlich darauf hingewiesen werden, dass neue Datentypen nur aus den von Pascal vordefinierten Datentypen, den daraus gebildeten Unterbereichen oder aus zusammengesetz-ten Pascal-Datentypen bestehen dürfen.

allgemeine Deklaration : TYPE TypName : Definition; Beispiel : TYPE TJahr : 1990..2060; 1) 1] Eine Variable vom Typ TJahr könnte demzufolge nur einen Wert zwischen 1990 und 2060 anneh-men

Um eine Verwechslung von neuen Datentypnamen mit Variablebezeichnern zu vermeiden, schlage ich vor, den neuen Datentypnamen ein „ T “ – für Typ – voranzustellen; also z.B. TJahr oder TFarbe;

Hat man es mit Mengen zu tun ( 24/25 ), so machen selbstdefinierte Datentypen schnell Sinn, wenn man die Übersichtlichkeit des Quelltextes steigern möchte. Als Beispiel soll hier die Liste aller Tage einer Woche dienen :

Datentypvereinbarung : TYPE TMyWeekDays = ( ’ Montag ’,’ Dienstag ’, .. ‚’ Sonntag ’ ); Variablendeklaration : VAR Today, Birthday : TMyWeekDays; Zuweisung im Hauptprogramm : Birthday := ’Mittwoch’;

Richtig wichtig werden eigene Datentypen aber immer dann, wenn man z.B. Records ( 23/25 ) als Parameter an Subroutinen übergeben muss. Innerhalb der Parameterliste erwarten die Unterpro-gramme ja nicht nur den Namen des formalen Parameters, sondern auch den dazugehörigen Daten-typ; und im Prozedur- bzw. Funktionskopf können Sie hier keinen neuen Record mehr definieren.

Problem : Angenommen, Sie haben aus einer Zahlenreihe alle Primzahlen isoliert und in eine vorab deklarierte Mengenvariable mit dem Namen PrimZahl übernommen. Diese Menge wollen Sie nun ausdrucken. Da wir aber nicht nur ein Datum in der Menge besitzen, sondern die gesamte Menge, können wir die Variable PrimZahl nicht direkt auf dem Bildschirm z.B. mit WriteLn(); ausgegeben. Was also tun ?

Wir definieren zunächst ein Unterpro-gramm, das uns den Inhalt der als Parameter übergebenen Menge bis zu einer festen Obergrenze ausgibt. Wie man sieht, ist für den formalen Pa-rameter der Menge im Prozedurkopf be-reits ein neuer Datentyp definiert worden.

PROCEDURE Ausgabe ( Menge : TZahlen ); VAR Z : Word; BEGIN FOR Z := 1 TO ObereGrenze DO IF Z IN Menge THEN Write(Z:3); END;

Im Deklarationsteil des Hauptprogramms muss vorab der neue Datentyp und die dazugehörige Variable deklariert werden.

CONST ObereGrenze = 200; TYPE TZahlen = SET OF 0 .. ObereGrenze; VAR PrimZahl : TZahlen;

Aufruf der Prozedur im Hauptprogramm Ausgabe ( PrimZahl );

In Pascal besteht auch die Möglichkeit, Prozeduren und Funktionen als Typen zu deklarieren. Nach der Vereinbarung z.B. eines solchen Prozedurtyps können dann zugehörige Prozedurvariablen ver-einbart werden. Einziges Problem : die Routinen, die solchen Prozedurvariablen zugewiesen werden, müssen vorab als FAR vereinbart werden. Das geschieht mit der Compilerdirektive $F+ . Beachten Sie, dass nur globale Routinen an die Prozedurvariablen übergeben werden können. Beispiel : TYPE TProzedurName = Procedure ( Parameter );

Documents

Einführung und erste Hilfe zur Programmiersprache Turbo ...m-frost/zip/Pascal-Reader.pdf · Hierunter fallen OBJEKTORIENTIERTE PROGRAMMIERSPRACHEN wie z.B. Java, Delphi, C++ oder