OWBasic Programmieren des PocketViewer

Transkript

1 OWBasic Programmieren des PocketViewer Wolfgang Ortmann Einleitung Die PocketViewer von Casio können mit eigenen Programmen erweitert werden. Dazu gibt es einen Entwickler-Kit, der die Erstellung von Programmen in C auf dem PC erlaubt. Diese Programme werden dann auf den PocketViewer übertragen. Die Erstellung von Programmen mit dem Entwickler-Kit in C ist jedoch an den PC gebunden und erfordert einiges Wissen in der C-Programmierung. Den Wunsch, einfach und direkt auf dem PocketViewer Programme entwickeln zu können erfüllt OWBasic. OWBasic-Programme werden auf dem PocketViewer als Memo in einem BASIC-Dialekt geschrieben und dann von OWBasic abgearbeitet. OWBasic ist ein Programm, welches zunächst mit dem PVM auf den PocketViewer zu laden ist. Damit erscheint im Menu ein neues Icon. Am besten installierst Du die Hilfedatei und den Referencer von CASIO gleich mit. Damit kannst Du die Hilfe zu den Befehlen auch auf dem PocketViewer lesen. Hello, World In vielen Büchern zur Programmierung in C findet man als erstes ein Programm-Beispiel, welches Hello, World'' ausgibt. Wir wollen es hier auch so halten. Programme für OWBasic werden als Text in Memos geschrieben. Klicke auf das Icon MEMO und wechsle dann in die Kategorie 5. Auf einem neuen PocketViewer mit der Einstellung auf deutsch'' heißt diese Kategorie Unbenannt 5''. Klicke auf Neu und wähle diese Kategorie aus. Gib nun folgenden Text ein:! Hello PRINT "Hello, world" Achte darauf, daß das Ausrufezeichen wirklich ganz am Anfang der ersten Zeile steht und nach einem Leerzeichen auf der gleichen Zeile "Hello" als Name des Programms. Die zweite Zeile ist das eigentliche Programm. Ich werde hier die Befehle und Schüsselwörter von OWBasic immer groß schreiben, damit man sie besser erkennt. Du mußt das nicht tun, "print" wäre genauso korrekt. Speichere das Memo ab und kehre zum Menü zurück. Jetzt ist es an der Zeit, OWBasic zu starten. Beim ersten Start erhältst Du eine Meldung, daß OWBasic keine Einstellungen findet und die Standardwerte verwendet. Dann wird das File-Menü angezeigt, welches auch das soeben geschriebene Programm "Hello" enthalten sollte. Klicke dieses an! Nach einem kurzen

2 Übersetzungsvorgang - hoffentlich ohne Fehlermeldung - wird eine kurze Statistik angezeigt. Bestätige durch Antippen und das Programm wird gestartet. Durch Antippen kannst Du OWBasic wieder schließen. Natürlich kannst Du gleich ein paar Varianten dieses Programmes ausprobieren. Wenn Du weitere Ausgaben mit PRINT anhängst, wird jedesmal einen neue Zeile ausgegeben. Sollen mehrere Ausgaben auf einer Zeile erscheinen, so schreibe sie in eine Printanweisung oder hänge an das Ende der ersten Printanweisung einfach ein Semikolon (';') an. Du kannst übrigens statt PRINT auch das Fragezeichen schreiben. Wir wollen das Programm etwas abwechslungsreicher gestalten, indem wir zunächst nach dem Namen des Benutzers fragen, um ihn persönlicher begrüßen zu können.! Hello 2 CLS PRINT "Wie heißt Du?" INPUT name$ PRINT "Hallo, ";name$ CLS löscht den Text-Bildschirm. Dann fragt uns das Programm nach dem Namen. Die Eingabe-Anweisung INPUT auf der zweiten Programm-Zeile wartet auf unsere Eingabe. Die Eingabe wird in der Variable name$ gespeichert. In der nachfolgenden Ausgabe mit PRINT wird dieser Wert verwendet, um den Benutzer anreden zu können. Variablen und Arithmetik Wie wir im zweiten Hello-Beispiel gesehen haben, können Werte in Variablen gespeichert werden. Variablen sind Speicherplätze, die einen Namen haben, wodurch wir sie im Programm benennen können. Variablen in OWBasic können verschiedene Arten von Werten aufnehmen: Zeichenketten (string), ganze Zahlen (integer), Gleitkomma-Zahlen (float) und logische Werte (boolean). Variablen für die unterschiedlichen Typen werden durch Anhängen eines Zeichens (Suffix) unterschieden: Type Bezeichnung Suffix Werte/Konstanten Ganze Zahl integer/int % 3107 Gleitkommazahl float # Zeichenkette string $ "ABC" Logisch boolean! TRUE, FALSE Am häufigsten werden die ganzen Zahlen benötigt. Im Vergleich zu den Gleitkomma-Zahlen brauchen sie viel weniger Platz und das Rechnen mit ihnen geht wesentlich schneller. Deshalb sollte ihnen im Zweifelsfall der Vorrang gegeben werden. OWBasic erleichtert dies zusätzlich, indem der Typ integer Vorzugstyp (Defaulttyp) ist. Das bedeutet, daß bei Variablen vom Typ integer der Suffix auch weggelassen werden kann. Mit numerischen Variablen und Konstanten (integer oder float) kann man Berechnungen so durchführen, wie man es aus der Mathematik gewohnt ist. Es existieren die Grundrechenarten '+', '-',

3 '*' und '/'. Bei der Rechnung mit ganzen Zahlen ist besonders auf die Division zu achten. Dividiert man durch eine Zahl, die kein Teiler des Dividenden ist, so erhält man kein gebrochenes Ergebnis, sondern die nächstkleinere ganze Zahl. Zum Beispiel liefert 7 / 3 das ganzzahlige Ergebnis 2. Bei dieser Division entsteht ein Rest, den man mit dem Operator '%' erhält. In diesem Fall ist der Rest 7 % 3 gleich 1. Will man dagegen die Division mit Gleitkommazahlen ausführen, so sollte man 7.0 / 3.0 schreiben. Das Ergebnis arithmetischer Operationen kann man direkt verwenden, z.b. mit PRINT ausgeben, oder man speichert das Ergebnis in einer Variablen. Diese Zuweisung wird in OWBasic geschrieben als c = a + b. In folgendem kleinen Programm wollen wir zu einem eingegebenen Radius den Umfang des Kreises berechnen:! Umfang PRINT "Umfangsberechnung" INPUT "Radius:",r# :! Radius eingeben pi#= :! Wert für PI festlegen u#=2*pi#*r# :! Umfang berechnen PRINT "Der Umfang ist ";u#:! Ergebnis ausgeben Hier haben wir Gleitkomma-Variablen verwendet, wie man am Suffix '#' erkennt. Die Zahl haben wir in einer Variablen abgelegt. Einen vordefinierten Wert für gibt es in OWBasic nicht. Der Rest des Programmes ist leicht verständlich. Wir können das Programm auch deshalb gut verstehen, weil wir auf jeder Zeile einen Kommentar dazu geschrieben haben. Kommentare sind Texte, die OWBasic ignoriert, die einem Leser des Programms aber helfen, es zu verstehen. Kommentare werden in OWBasic mit einem Ausrufezeichen eingeleitet. Alternativ kann das auch mit dem Schlüsselwort REM erfolgen. Kommentare verhalten sich wie eigene Anweisungen und müssen deshalb, wenn sie nach einer anderen Anweisung folgen, mittels Doppelpunkt ':' abgetrennt werden. Zusätzlich zu den genannten Operatoren gibt auch noch Funktionen. Die bekanntesten dürften die Winkelfunktionen sein, es gibt aber auch Funktionen für Potenzen und Wurzeln. Auch Funktionen verwenden ein Typkennzeichen. Standard ist auch hier der Typ integer. Das folgende Beispiel verwendet die Wurzelfunktion, um die Kantenlänge eines Quadrates mit gegebenem Flächeninhalt zu berechnen:! Quadrat PRINT "Berechnung der Kantenlänge" INPUT "Fläche", a# k#=sqr#(a#) :! Kantenlänge berechnen PRINT "Die Kantenlänge ist ";k# :! und ausgeben Kontrollstrukturen Nicht jedes Programm besteht nur aus einer geradlinig ablaufenden Folge von Anweisungen. Oft müssen Anweisungen mehrfach ausgeführt werden, oft hängt die Abarbeitung von Bedingungen ab.

4 Ein Problem, bei dem der Mathematiker Gauss schon als Schüler seine Genialität bewiesen hat, ist die Summation der Zahlen von 1 bis 100. Wir wollen hier mal auf Geistesblitze verzichten und unseren geduldigen PocketViewer dazu verwenden, diese Summe für uns "zu Fuß" auszurechnen. Dazu muß das Bilden der Summe für alle Zahlen von 1 bis 100 wiederholt werden, wobei der jeweilige Summand zum bisherigen Ergebnis addiert wird. Dies ist in der Informatik eine "Schleife mit fester Zahl von Durchläufen". summe=0 FOR summand=1 TO 100 summe=summe+summand PRINT summe Was passiert hier? Wir setzen die Summe summe zunächst auf Null, um dann alle Werte von 1 bis 100 zu addieren. Die Befehle in der von FOR.. TO bis reichenden Schleife werden 100 mal abgearbeitet. Der Summand summand -eine Integervariable - nimmt dabei die Werte von 1 bis 100 jeweils einmal an. Wollte man die Befehlsabarbeitung dieser Schleife einmal ausschreiben, so stünde da etwa summe=0 summe=summe+1 summe=summe+2... summe=summe+100 PRINT summe Wichtig bei FOR-Schleifen ist, daß die Zahl der Durchläufe durch die Schleife bereits beim Eintritt bei FOR.. feststeht. Natürlich dürfen als Grenzen statt der 1 und der 100 auch Variablen stehen. Diese Grenzen sowie die Laufvariable (hier: summand) sollten aber in der Schleife nicht geändert werden, denn das Verhalten ist in diesem Falle undefiniert. Entscheidungen der verschiedensten Art können in Programmabläufen eine Rolle spielen. Soll z.b. in einem Programm entschieden werden, wer von zwei Spielern gewonnen hat, so muß man die erreichten Wertungspunkte vergleichen. Die Entscheidung könnte zum Beispiel so aussehen: IF punkte1>punkte2 THEN PRINT "Spieler 1 hat gewonnen" ELSE PRINT "Spieler 2 hat gewonnen" ENDIF Was hier passiert, kann man (in englisch) fast fließend lesen: Wenn (IF) die Punktzahl 1 größer als die Punktzahl 2 ist, dann (THEN) wird ausgegeben, daß Spieler 1 gewonnen hat, sonst (ELSE) wird angezeigt, daß der Spieler 2 gewonnen hat. ENDIF beendet die IF-Anweisung und zeigt an, daß danach alle Anweisungen wieder normal ohne Bedingung ausgeführt werden. Nicht in jedem Fall sind zwei Alternativen notwendig, und der ELSE-Zweig kann entfallen.

5 IF temperatur>60 THEN PRINT "Vorsicht, heiß!" ENDIF Hier wird nur im Falle zu hoher Temperatur eine Warnung ausgegeben. Die Bedingungen für diese Entscheidungen sind boolesche Ausdrücke, also Ausdrücke, die entweder wahr (TRUE) oder falsch (FALSE) sind. In vielen Fällen handelt es sich dabei um Vergleiche, wie im obigen Beispiel punkte1>punkte2. Solche Ausdrücke können mit logischen Operatoren verknüpft werden. Der Test ob eine Variable a im Bereich von 0 bis 100 liegt, bedeutet ja, daß a größer oder gleich 0 ist und daß a kleiner oder gleich 100 ist. In Basic würde man so formulieren: IF a>=0 AND a<=100 THEN PRINT "A liegt im richtigen Bereich" ENDIF Leider lassen sich mit FOR-Schleifen und IF-Anweisungen nicht alle Fälle bearbeiten, die in einem Programm auftreten können können. Manchmal benötigt man Wiederholungen solange wie eine Bedingung erfüllt ist, oder solange bis eine Bedingung erfüllt ist. Eine solche Art Anweisung gibt es in OWBasic nicht. Mit Hilfe von IF-Anweisungen und dem Befehl GOTO kann man sich aber solche Schleifen ebenfalls konstruieren. Der Befehl GOTO veranlaßt die Fortsetzung der Abarbeitung an einem anderen Punkt im Programm. Dieser "andere Punkt" ist durch eine Marke gekennzeichnet. Eine Marke beginnt mit dem $-Zeichen und wird von einem Namen gefolgt. Marken stehen entweder allein für sich wie eine Anweisung oder vor anderen Anweisungen. a=50: b=9 $loop a=a-b IF a>=0 THEN GOTO loop ENDIF PRINT a In diesem Programm wird die Variable a um b vermindert. Die IF-Anweisung enthält einen Sprung zur Marke "$loop" für den Fall, daß a größer oder gleich Null ist. Damit wird die Subtraktion sooft wiederholt, bis der Wert von a kleiner als Null ist. Wenn in dem THEN-Zweig einer IF-Anweisung nichts außer einem Sprung steht, und kein ELSE-Zweig vorhanden ist, wie in diesem Beispiel, kann dies auch verkürzt geschrieben werden: a=50: b=9 $loop a=a-b IF a>=0 GOTO loop

6 PRINT a Zeichenketten Bereits in einem der ersten Beispielprogramme haben wir gesehen. daß Variablen auch Texte (Zeichenketten, Strings) aufnehmen können. Natürlich kann man mit Strings nicht die gleichen Operationen wie mit Zahlen ausführen. Die Addition von String mit dem Operator '+' bewirkt das Aneinanderfügen der beiden gegebenen Strings, PRINT "Pocket"+"Viewer" gibt den zusammengesetzten String PocketViewer aus. Funktionen mit Strings liefern Teilstrings, die Länge eines Strings und ähnliches. Der Zugriff auf die einzelnen Zeichen eines Strings ist mit eckigen Klammern möglich:! Doppelt hello$="string":! einen Teststring vorgeben last=len(hello$)-1:! Nummer des letzten Zeichens FOR i=0 TO last :! für alle Zeichen des Strings PRINT hello$[i];hello$[i]; :! Zeichen zweimal ausgeben Die einzelnen Zeichen des String (selbst Zeichenketten der Länge 1) werden hier jeweils zweimal ausgegeben, es erscheint ``SSttrriinngg''. Felder Nicht immer sind es einzelne Daten, die man speichern möchte. In einem Telefonverzeichnis zum Beispiel sind Namen und Telefonnummern für viele Teilnehmer verzeichnet. Datenstrukturen, die viele gleichartige Werte aufnehmen können, heißen Felder oder Arrays. Felder werden in BASIC mit der DIM-Anweisung angelegt. Diese hat in OWBasic die Form DIM a#[100],b[50],c$[200]; In einer DIM-Anweisung können beliebig viele Felder definiert werden. Es wird dazu zuerst der Name des Feldes angegeben. Zur Typkennzeichnung folgt ein Suffix, wenn nicht der Standardtyp integer verwendet werden soll. In eckigen Klammern folgt eine ganze Zahl als Konstante. Diese Zahl beschreibt den letzten zulässigen Index in einem Feld. Im Beispiel oben wird ein Gleitkomma-Feld mit Indizes von 0 bis 100, also insgesamt 101 Feldelementen, angelegt. Entsprechend ein Integer-Feld mit 51 Elementen und ein String-Feld mit 201 Elementen. Die Feldgröße ist in OWBasic konstant und kann später nicht mehr geändert werden. Will man die entspechenden Elemente des Feldes verwenden, so schreibt man den Namen des Feldes und danach in eckigen Klammern den Index des Feldelementes. Anhand eines Beispielprogrammes wird die Verwendung von Feldern deutlich. Es soll ein Quiz ausgewertet werden. Wir speichern in Feldern die Namen und die erreichten Punktzahlen.

7 ! Felder DIM name$[4],punkte[4] name$[0]="frank" : punkte[0]=13 name$[1]="klaus" : punkte[1]=8 name$[2]="helga" : punkte[2]=17 name$[3]="jana" : punkte[3]=11 name$[4]="daniel": punkte[4]=3 Die erreichten Punktzahlen haben wir uns zur Vereinfachung als Konstanten vorgegeben. Als erstes wollen wir die Ergebnisse der einzelnen Teilnehmer ausgeben. FOR i=0 TO 4 PRINT name$[i],punkte[i] PRINT Nun soll der Sieger ermittelt werden, also derjenige, der die meisten Punkte hat. Wir nehmen zunächst mal an, der erste wäre der Sieger. maxp=punkte[0]:! Maximale Punktzahl max =0 :! Nummer des Siegers Nun wollen wir sehen, ob einer der anderen mehr Punkte erzielt hat. FOR i=1 TO 4 IF punkte[i]>maxp THEN maxp=punkte[i] max=i ENDIF Nun können wir das Ergebnis ausgeben. PRINT "Sieger ist ";name$[max] PRINT " mit ";maxp;"punkten" Grafik Viele Anwendungen für den PocketViewer verwenden grafische Elemente. Mit OWBasic können auch derartige Programme geschrieben werden. Textmodus und grafischen Modus können in den meisten Fällen nicht gleichzeitig verwendet werden. Es gibt aber auch Prozeduren, die im grafischen Modus Texte darstellen können. CLS löscht den Textbildschirm. Dabei verbleibt ein Rahmen auf dem Bildschirm, der das Textfeld begrenzt. Für grafische Darstellungen kann mit ``CLS 2'' der gesamte Bildschirm gelöscht werden. Im folgenden Beipiel-Programm gehen wir schon einen Schritt weiter:

8 ! Grafik1 CLS 2 :! Bildschirm löschen DRAWSTRING "Hello", 5, 5 BOX 50, 80, 100, 150, 1 LINE 50, 80, 75, 30, 1 LINE 75, 30, 100, 80, 1 SHOW Das Löschen des Bildschirms kennen wir nun schon. DRAWSTRING zeichnet einen Text auf den Bildschirm. Dessen linke obere Ecke liegt bei den Koordinaten 5,5. Was bedeutet das? Wie auch in der Mathematik verläuft die x-achse horizontal, die y-achse vertikal. Allerdings zeigt die y-achse nach unten. Der Ursprung liegt in der linken oberen Ecke des Bildschirms und hat die Koordinaten (0,0). Die rechte untere Ecke hat die Koordinaten (159,159). Eine Box ist ein Rechteck, welches parallel zu den Achsen ausgerichtet ist. Die angegebenen Koordinaten beschreiben die linke obere Ecke des Rechtecks (50,80) und die rechte untere Ecke (100,150). Bei den Linien, die mittels LINE gezeichnet werden, beschreiben die Parameter die Koordinaten des Anfangs- und des Endpunktes. Der letzte Parameter von BOX und LINE ist die ``Farbe'' des Darstellung. Wichtig sind hier die Werte 0 und 1 für Weiß (oder Löschen) und Schwarz. Der Wert 4 steht für punktierte Linien, 5 für eine Invertierung jedes Pixels gegenüber dem vorigen Zustand. Eine Besonderheit bei der Grafik-Programmierung bildet die Prozedur SHOW. Alle grafischen Darstellungen werden zunächst nur intern aufgebaut. Die wirkliche Darstellung erfolgt erst nach Aufruf von SHOW. Das hat zwei Vorteile: Der Bildaufbau erfolgt insgesamt wesentlich schneller, da die zeitaufwendigen Operationen für die wirkliche Darstellung nur einmal pro Bild notwendig sind. Auch bei etwas länger dauerndem internen Bildaufbau erscheint das Bild mit einem Schlag, was in vielen Fällen angenehmer ist. Neben einfachen grafischen Primitiven ist auch das Setzen einzelner Pixel möglich. Mit PSET x,y,v wird das Pixel an der Stelle (x,y) mit dem Wert v beschrieben. Dabei bedeutet v=0 Schwarz und v=1 Weiß. Der Wert 5 steht für die Invertierung des Pixels.! Pixel CLS 2 FOR y=0 TO 159 FOR x=0 TO 159 v=((x+y)/16) AND 1; PSET x,y,v SHOW

9 Hier wird jedes Pixel auf den berechneten Wert gesetzt. (x+y)/16 ist zunächst eine normale Berechnung, AND 1 ist eine bitweise UND-Verknüpfung des berechneten Wertes mit 1. Die Wirkung ist die, daß die Werte auf 0 und 1 begrenzt werden. Nach jeder geschriebenen Zeile (FOR-Schleife für x) wird das dargestellte Bild mittels SHOW aktualisiert. Damit wird der zeilenweise Bildaufbau sichtbar. Als Icon werden kleine Grafiken bezeichnet, die in Menüs oder ähnlichem als Auswahl Verwendung finden. In OWBasic dürfen Icons aber auch so groß sein, daß sie den ganzen Bildschirm füllen. Sie können deshalb der Speicherung von Grafiken aller Art dienen. Icons werden in Integer-Feldern gespeichert. Die ersten zwei Elemente dieser Felder enthalten die Größe des Icons in X- und Y-Richtung, die darauffolgenden Elemente enthalten die Pixeldaten. Dabei werden jeweils 16 Pixel in einen Wert gepackt. Die folgenden Größenangaben bieten zunächst Anhaltspunkte für den Speicherbedarf eines Icons: X Y Feldgröße Menu-Icons Quick-Memos Volbild DRAWICON zeichnet ein Icon auf dem Bildschirm. Einzelne Pixel kann man in einem gespeicherten Icon mit SETICONPIX setzen und mit der Funktion ICONPIX() abfragen. Einen Teil des Bildschirminhaltes kann man mit GETICON abfragen und in einem Icon speichern. Mit RESIZEICON läßt sich die Größe ändern.! Icons DIM klein[65],gross[1025]! eine kleine Grafik zeichnen CLS 2 FOR y=0 TO 31 STEP 4 LINE 0,25,31,y,1 DRAWSTRING "ABC",5,5,3 SHOW! Icon vom Bildschirm holen! Icon der Größe 32*32 GETICON klein,0,0,31,31! An anderer Stelle zeichnen DRAWICON klein,80,80! Warten auf Klick WAITTOUCH! Icon invertieren FOR x=0 TO 31

10 FOR y=0 to 31! Pixel lesen c=iconpix(klein,x,y)! invertieren c=1-c! wieder schreiben SETICONPIX(klein,x,y)! dieses darstellen DRAWICON klein,80,80 SHOW WAITTOUCH! Icon vergrößern! neue Größe 128*128 RESIZEICON klein,gross,128,128 DRAWICON gross,15,15 SHOW Prozeduren Bisher haben wir in allen Programmen auf eingebaute Prozeduren von OWBasic zurückgegriffen. Oft gelangt man aber bei der Programmierung an Stellen, wo man zum wiederholten Male die gleiche Anweisungsfolge benötigte. Dies ist die Stelle, an der man das System erweitern möchte und selbst Prozeduren schreiben. Sehen wir uns ein Beispiel an!! Eingabe-Test1 PRINT "Bitte zwei ganze Zahlen eingeben!" $eingabe1 INPUT "Erste Zahl (0-9):",a IF a<0 OR a>9 GOTO eingabe1 $eingabe2 INPUT "Zweite Zahl (1-3):",b IF b<1 OR b>3 GOTO eingabe2 PRINT "Ihre Zahlen waren ";a;b Bei Eingaben ist es fast immer notwendig, sie auf die Einhaltung bestimmter Bedingungen zu testen. Hier soll jeweils ein bestimmter Bereich eingehalten werden. Die Eingabe und der nachfolgende Test muß zweimal programmiert werden. Es geht aber auch anders. Solche sich wiederholende Anweisungen kann man in einen Modul - eine Prozedur - packen und diese Prozedur so oft wie notwendig aufrufen. Wie könnte so etwas aussehen? PROC eingabe $eingabe1 INPUT "Erste Zahl (0-9):",a

11 IF a<0 OR a>9 GOTO eingabe1 ENDP Das Schlüsselwort PROC erklärt, daß wir hier eine Prozedur definieren wollen. Diese Definitionen müssen immer am Anfang eines Programmes stehen. Die Bezeichnung "eingabe" nach PROC ist der Name der Prozedur, die wir definieren. Danach folgen die auszuführenden Anweisungen und am Ende wird die Definition mit ENDP abgeschlossen. Das ist aber nur der erste Schritt. Wenn wir so verfahren würden, würde beim Aufruf von "eingabe" immer der gleiche Text ausgegeben, immer die gleiche Variable eingegeben und die gleichen Grenzwerte getestet werden. Wir brauchen also noch einen Mechanismus, um der Prozedur jeweils zu sagen, welcher Text, welche Variable und welche Grenzwerte zu verwenden sind. Dies sind Parameter. Bei der Definition kennen wir diese Werte noch nicht. Deshalb sind die Bezeichner, die wir dafür verwenden nur "formale Parameter". Wir schreiben die Definition entsprechend um: PROC eingabe prompt$,var a,amin,amax $eingabe1 INPUT prompt,a IF a<amin OR a>amax GOTO eingabe1 ENDP Die Parameter stehen nach dem Namen der Prozedur. Anhand des Suffix sehen wir, um welche Typen es sich handelt. prompt$ ist der auszugebende Text, a ist die einzugebende Variable, amin und amax sind der maximal und minimal zulässige Wert für a. Das Schlüsselwort VAR vor dem Parameter fällt noch ein wenig aus der Reihe. Was bedeutet das? Der Parameter a stellt im Unterschied zu den anderen eine Variable dar. Während es bei den anderen Parametern nur um einen Wert geht, den wir der Prozedur übergeben, stellt a die Variable dar, auf die das Ergebnis der Prozedur - die Eingabe - abzulegen ist. Jetzt können wir das ganze Programm neu formulieren. Der Aufruf von Eingabe erfolgt genau wie bei den eingebauten Prozeduren. Wir übergeben aktuelle Parameter, die die in dem aktuellen Aufruf zu verwendenden Werte und Variablen festlegen.! Eingabe-Test2 PROC eingabe prompt$,var a,amin,amax $eingabe1 INPUT prompt,a IF a<amin OR a>amax GOTO eingabe1 ENDP eingabe "Erste Zahl (0-9):",a,0,9 eingabe "Zweite Zahl (1-3):",b,1,3 PRINT "Ihre Zahlen waren ";a;b

12 Überzeugt? Klar, in dem sehr kleinen Beispielprogramm wären wir auch noch sehr gut ohne Prozeduren ausgekommen. Je größer das Programm wird, je öfter Prozeduren verwendet werden, umso mehr werden auch die Vorteile spürbar: Prozeduren sparen Quelltext: Eine Anweisungsfolge wird einmal aufgeschrieben und dann einfach mehrmals aufgerufen. Prozeduren sparen Speicherplatz für den Programmcode: Wie beim Quelltext wird auch im ausführbaren Programm die Befehlsfolge nur einmal erzeugt und danach nur noch jeweils erneut ausgeführt. Prozeduren strukturieren ein Programm: Wenn Anweisungsfolgen als Prozeduren geschrieben werden, erhalten sie ja auch einen Namen. Ist der Name sinnvoll gewählt, liest sich das Programm viel besser, weil man sofort sieht, was passiert. Ein weiterer Vorteil soll ganz zuletzt noch etwas ausführlicher erläutert werden: Prozeduren lassen sich wiederverwenden. Dies gilt natürlich für mein aktuelles Programm, wo ich eine Prozedur mehrfach aufrufen kann, aber es gilt auch für andere Basic-Programme. Dazu könnte man einfach die Definition der Prozedur aus einem alten in das neue Programm übernehmen. Aber es geht auch noch einfacher. Man kann solche Definitionen auch in eine eigenes Memo schreiben, das dann in allen Programmen verwendet wird. Diese INCLUDE-Memos haben als Kennung am Anfang nicht "! ", schließlich ist es kein Programm, sondern die beiden Zeichen "!*". Legen wir unsere Prozedur also so ab:!*eingabe! Wiederverwendbare Eingabe mit! Bereichstestung PROC eingabe prompt$,var a,amin,amax $eingabe1 INPUT prompt,a IF a<amin OR a>amax GOTO eingabe1 endp Unser Hauptprogramm ändert sich jetzt so:! Eingabe-Test3 INCLUDE eingabe eingabe "Erste Zahl (0-9):",a,0,9 eingabe "Zweite Zahl (1-3):",b,1,3 PRINT "Ihre Zahlen waren ";a;b Das Schlüsselwort INCLUDE gefolgt vom Namen unseres INCLUDE-Memos bewirkt, daß die Definition von "eingabe" an dieser Stelle in das aktuelle Programm aufgenommen wird. Danach können wir "eingabe" genauso benutzen wie in dem Programm Eingabe-Test2", wo sie direkt im gleichen Memo stand.

13 Dateien Die Daten des PocketViewer werden ähnlich wie Dateien gespeichert. Mit OWBasic ist es prinzipiell möglich, auf alle Dateien der verschiedenen Anwendungen zuzugreifen. Hier müssen wir uns jedoch auf einige wenige Beispiele beschränken. Memos, die auch zum Schreiben von Programmen für OWBasic verwendet werden, werden mit LOADMEMO oder LOADMEMONAME gelesen und SAVEMEMO geschrieben. Bei Memos handelt es sich um Texte, OWBasic organisiert diese in einem Feld von Strings.! Memo1 DIM m$[200] LOADMEMONAME m$, 5, "Memo1", "! ", zeilen FOR i=0 TO zeilen-1 PRINT m$[i] In diesem Beispiel liest das Programm sich selbst ein. Zunächst wird mit der DIM-Anweisung ein Feld mit 201 String angelegt. Die Zahl der Feldelemente muß mindestens gleich der Zahl der einzulesenden Zeilen sein. LOADMEMONAME liest ein Memo ein, von dem man den Namen kennt. Zunächst wird mit m$ das String-Feld zum Einlesen spezifiziert. 5 ist die Kategorie, in der das Memo zu suchen ist. "Memo1" ist der Name, "! " ist die Signatur. Die Signatur übernimmt die Funktion der Dateiendungen in anderen Systemen. Es kennzeichnet die Art der Datei. Jedes Basic-Programm beginnt mit "! ", seiner Signatur. Der Name sind die darauffolgenden Zeichen der ersten Zeile. Die Variable zeilen dient dazu, die Anzahl der wirklich gelesenen Zeilen zurückzugeben. In der nachfolgenden FOR-Schleife werden die gelesenen Zeile ausgegeben. Alternativ kann man alle Memos nacheinander lesen, indem man mit LOADMEMO arbeitet. LOADMEMO verwendet eine fortlaufende Numerierung der Memos in jeder Kategorie statt des Namens. Da diese Nummern sich jedoch ändern, wenn Memos hinzugefügt oder gelöscht werden, läßt sich dies im allgemeinen nur derart verwenden, daß man alle Memos angefangen beim ersten (mit der Nummer 0) einliest und vergleicht, ob das das richtige ist. Aber wir können Memos auch schreiben:! Make Hello DIM m$[1] m$[0]="! Hello" m$[1]="print "+CHR$(34)+"Hello, world"+chr$(34) SAVEMEMO m, 5 Hier wird ein Memo geschrieben, nämlich eines, welches den Text unseres allerersten Programmes enthält. Zunächst wieder die Definition eines Feldes, wobei wir uns hier auf 2 Elemente (= 2 Zeilen) beschränken. Danach legen wir unser Hello, world-programm in diesem Feld ab. Für die zweite Zeile benötigen wir einen kleinen Trick: In normalen Zeichenketten-Konstanten kann kein " enthalten sein, dieses wäre ja ein Begrenzer der Zeichenkette. Wir setzen deshalb die ganze Zeile zusammen aus Teilzeichenketten und dem Zeichen CHR$(34). CHR$(34) ist das Zeichen, welches mit dem Kode 34 kodiert wird, das ist das Zeichen. Die Zeichenkodes kleiner 128 entsprechen dem

14 ASCII-Code, Zeichen oberhalb 127 sind entsprechend dem spezifischen Zeichensatz des PocketViewer belegt. SAVEMEMO schließlich schreibt diese zwei Zeilen als Memo aus. 5 ist die Kategorie. Soll SAVEMEMO ein vorhandenes Memo überschreiben, so kann als weiterer Parameter die Nummer dieses Memos angegeben werde. Die spezielle Nummer -1 steht dann für ein neues Memo. Integer- und Gleitkommafelder lassen sich sogar noch komfortabler speichern. OWBasic legt diese Daten genauso wie seine Einstellungen in einer Datei mit dem Namen SHARED ab. Diese Datei nutzt OWBasic gemeinsam mit anderen Anwendungen. Durch die gemeinsame Nutzung wird die Grenze des PocketViewer von 15 möglichen Dateien nicht so schnell ausgeschöpft. Du solltest die Datei SHARED nicht löschen, wenn Du nicht ganz sicher bist, daß keine Anwendung diese noch braucht.! shared DIM a[9],b#[9] FOR i=0 TO 9 a[i]=i b#[i]=float(i) Wir legen testweise zwei Felder an: Ein Integer-Feld und ein Gleitkomma-Feld. SAVESHAREDINT "a",a SAVESHAREDFLOAT "b",b# CLEAR a: CLEARF b LOADSHAREDINT "a",a LOADSHAREDFLOAT "b",b# Jetzt haben wir beide Felder gespeichert. SAVESHAREDxxx gibt den Einträgen Namen wie bei Dateien. Dieser Name besteht aus zwei Teilen: Dem Rekordnamen und dem Anwendungsnamen. Der Rekordname ist der in den Anweisungen angegebene erste Parameter, hier a und b. Zusätzlich wird der Name der Anwendung, also des Basic-Programmes, verwendet. Das ist hier shared. Will man mit verschiedenen Programmen auf die gleichen Daten zugreifen, so kann man diesen Anwendungsnamen auch mit angeben. Im Beispielprogramm werden dann die beiden Felder gelöscht, das heißt mit 0 bzw. 0.0 belegt. Danach werden die Felddaten wieder eingelesen. Um uns zu überzeugen, daß alles auch wirklich wieder geladen wurde, geben wir die Werte aus. FOR i=0 TO 9 PRINT i,a[i],b#[i] REMOVESHARED "a" REMOVESHARED "b" Danach löschen wir die Rekords wieder, um den Speicher freizugeben. Letzte Worte

15 Das letzte Wort zu OWBasic - das ist mit Sicherheit noch nicht gesprochen. Dieses kurze Handbuch konnte selbstverständlich nicht alle Gesichtspunkte von OWBasic behandeln. Weitere Informationen findest Du in der Hilfe. Wenn Du den PVReferencer von Casio und die entsprechende OWBasic-Hilfe-Datei auf deinem PocketViewer installiert hast, kannst du direkt auf dem PocketViewer dort nachlesen. Die HTML-Version kannst Du von der OWBasic-Webseite herunterladen oder dort auch online lesen. Aber auch zu OWBasic selbst ist das letzte Wort noch nicht gesprochen. OWBasic wird sich im Laufe der Zeit weiter entwickeln. Neuere Versionen und Hinweise auf Veränderungen werden auf der OWBasic-Webseite veröffentlicht. Auch auf den Casio-PocketViewer-Seiten werden aktualisierte Versionen angeboten. Aber auch Du kannst zur Weiterentwicklung beitragen! Deine Ideen und Wünsche sind gefragt, auch Fehlermeldungen sind erwünscht. Nur bei entsprechender Rückmeldung können Fehler auch beseitigt werden. Inzwischen hat OWBasic eine Größe erreicht, die einen vollständigen Test durch einen Einzelnen nahezu unmöglich macht. Aber vielleicht kannst Du ja auch als C-Programmierer mit zur Entwicklung beitragen, indem Du Kode für weitere Prozeduren und Funktionen entwickelst. OWBasic-Homepage (deutsch) Mailadresse für alle Arten von Rückmeldungen zu OWBasic mailto:owbasic@pandora.inf.uni-jena.de Casio-PocketViewer-Seiten pocketviewer.de - Die Pocketviewer-Seite: Neben vielen anderen Informationen zum PocketViewer finden sich hier auch Foren zum PocketViewer allgemein und zur Programmierung.