Hewlett-Packard an ST: „Bitte kommen!“ (Teil 2)

Teil 2: Datenaustausch zwischen dem Taschenrechner HP48SX und dem Atari ST

Der wissenschaftliche Taschenrechner HP48SX von Hewlett-Packard verfügt neben einer bidirektionalen optischen Schnittstelle auch über eine RS232-SchnittsteIle, über die er Daten mit dem Atari ST austauschen kann. Durch die Einhaltung des Kermit-Protokolls ist es sogar möglich, Befehle an den HP zu senden oder vom Atari aus Programme von ihm anzufordern. Der Aufbau eines geeigneten Schnittstellenkabels und die Vorgehensweise bei der Datenübertragung mittels eines DFÜ-Programms sollen hier beschrieben werden.

Warum wir den Datenaustausch nun doch über ein RS232-Kabel realisieren und nicht, wie im ersten Teil unseres Artikels angekündigt, über die optische Schnittstelle der HP, kann der Interessierte im Textkasten auf der nächsten Seite nachlesen. Jedenfalls bringt der Weg über das Kabel enorme Vorteile, denn zum Datenaustausch kann das komfortable Public-Domain-Programm UniTerm verwendet werden.

Der Aufbau des Kabels

Der HP48SX verfügt über einen vierpoligen Steckverbinder, an dem ein Datenein- und -ausgang nach RS232-Standard zur Verfügung stehen. Zum Anschluß des Taschenrechners an den Computer müssen nur drei Leitungen verbunden werden, und zwar entsprechend Tabelle 1 Eingang mit Ausgang, Ausgang mit Eingang und Masse mit Masse.

Ein kleines Problem stellt beim Aufbau des Kabels nur der Steckverbinder auf der Seite des Taschenrechners dar, der 4 Stifte im 2mm-Raster besitzt. Da metrische Steckverbinder noch schwer erhältlich sind, empfiehlt es sich, einen entsprechenden Steckverbinder selbst zu basteln.

Die Ausgangsbasis hierfür sind vier einzelne, gedrehte Sockel-Pins, die sich notfalls dadurch gewinnen lassen, daß man bei einer IC-Fassung mit gedrehten Pins die Plastikstege, die die einzelnen Pins Zusammenhalten, vorsichtig mit einem Seitenschneider zerstört. Ferner benötigt man noch eine einreihige Stiftleiste im 2,54mm-Raster, vier Stifte breit. Das Ziel ist nun, hieraus einen Adapter vom 2mm-Raster auf das 2,54mm-Raster zu bauen. Es empfiehlt sich, die Pins vorher an je zwei Seiten etwas mit einer Feile abzuflachen, um die Gefahr von Kurzschlüssen zu verringern.

Wer genug Löterfahrung besitzt, um den Taschenrechner dabei nicht anzuschmoren, der kann wie folgt Vorgehen: Man steckt die gedrehten Pins auf die Stifte des Steckverbinders im Taschenrechner, bringt die vierpolige Stiftleiste in Berührung mit den vier Pins und lötet die vier Pins an je einen Stift der Stiftleiste.

Wer sich das nicht zutraut, aber gut bohren kann, sollte folgenden Weg gehen: Man fertigt zunächst ein Kunststoffplättchen von 5mm * 12mm Größe, am besten aus einem Stück Epoxyd-Platine, natürlich ohne Kupferkaschierung. Dann bohrt man im 2mm-Abstand vier Löcher hinein, wobei der Bohrerdurchmesser dem Schaftdurchmesser der Pins entsprechen sollte, also ca. 1,5mm. Durch die Löcher steckt man die Pins und lötet wie oben beschrieben die vierpolige Stiftleiste an. Das Kunststoffplättchen gibt dem Steckadapter dabei Stabilität.

Wer weder löten noch bohren kann, sollte die Aufgabe besser einem Freund übertragen, anstatt seinen Rechner zu beschädigen.

Das eigentliche Verbindungskabel zwischen Taschenrechner und Atari ist nun leicht herzustellen. Auf der Atari-Seite benötigt man eine 25polige D-Sub-Buch-se mit Posthaube, auf der Seite das HP eine vierpolige Buchsenleiste, und mit einem dreiadrigen Kabel stellt man die oben beschriebenen Verbindungen her. Wer versucht, die Kabelenden direkt an die Stifte des Adapters zu löten, wird möglicherweise fluchen, weil dabei die mühsam angelöteten Pins auf der anderen Seite der Stiftleiste wieder abfallen, Lötzinn schmilzt nun mal schnell.

Aufbau des RS232-Kabels

HP48SX-Seite	Pin	Atari-Seite	Pin
Ausgang „send“	2	Eingang „RxD“	3
Eingang „receive"	3	Ausgang „TxD"	2
Masse	4	Masse	7

Tab. 1: Für das serielle Schnittstellenkabel müssen nur drei Verbindungen hergestellt werden.

Die ersten Schritte

Über das Kabel und den Adapter kann der Taschenrechner nun mit dem RS232-Port des Atari verbunden werden. Als DFÜ-Programm ist UniTerm ab Version V2.0e bestens geeignet, da es das Kermit-Protokoll einhält, das einen komfortablen Server-Host-Betrieb ermöglicht. UniTerm ist ein Public-Domain-Programm, und es ist auf der PD-Diskette 295 der ST-Computer-Sammlung erhältlich.

Bevor die eigentliche Übertragung beginnen kann, müssen Computer und Taschenrechner auf das gleiche Übertragungsformat eingestellt werden. Die Übertragung sollte bei 9600 Baud mit 8 Daten-Bits und 1 Stopp-Bit ohne Paritäts-Bit erfolgen. Beim HP48SX ist zur Einstellung der Parameter im I/O-Menü die Option SETUP zu wählen. Die einzustellenden Werte sind der Hardcopy des Displays (Abbildung 2) zu entnehmen.

Zu beachten ist, daß für die Datenübertragung mit 9600 Baud die ständige Anzeige der Uhr auszuschalten ist, da sonst laut HP-Handbuch Fehler auftreten können.

Vor der Übertragung von Daten muß am HP noch die Funktion SERVE im Menü I/O angewählt werden. Eine weitere Bedienung des Taschenrechners ist nach dieser Einstellung überflüssig, denn der Datentransfer kann allein vom Atari aus gesteuert werden.

Auch in UniTerm müssen zunächst die richtigen Parameter der RS232-Schnittstelle eingegeben werden, falls sie nicht bereits in einer Setup-Datei gespeichert worden sind.

Nach dem Start von UniTerm befindet man sich zunächst im Online-Modus. Mit der Taste HELP gelangt man in einen Setup-Bildschirm, von dem aus alle Einstellungen vorgenommen werden. In der Menüleiste gelangt man mit der Funktion Settings / RS232… oder der Taste V in das Menü RS232 setup; mit der Funktion Settings / File Transfer… oder der Taste K erreicht man das Menü Kermit setup. In diesen Menüs muß man die RS232-Parameter entsprechend den Abbildungen 3 und 4 einstellen. Die Parameter können mit File t Save Settings gespeichert werden. Anschließend kann man mit der linken Maustaste wieder in den Online-Modus gelangen.

Übertragung per Kabel statt Infrarot

Einige der „kleinen Brüder“ des HP48SX sind nur mit einem optischen Druckerausgang ausgestattet, der beim HP48SX auch vorhanden ist. Der Taschenrechner sendet dabei die zu druckenden Daten in Form von infraroten Lichtpulsen seriell an den Drucker HP82240, der von Hewlett-Packard angeboten wird.

In der ST-Computer, Ausgabe 3/91, hatten wir eine Schaltung für den Atari ST vorgestellt, die diese Lichtpulse empfangen konnte, so daß der Atari in der Lage war, die Druckerdaten auszuwerten und sie auf dem Bildschirm oder einem Drucker auszugeben und so den HP-Thermodrucker zu ersetzen.

Der HP48SX verfügt neben dem optischen Ausgang auch über einen Infrarot-Dateneingang. Somit ist es möglich, Programme von einem Rechner auf einen anderen zu übertragen. Man könnte also am Atari noch eine Infrarot-Sendediode anschließen, um so eine Möglichkeit für den bidirektionalen Datenaustausch zu schaffen. In unserem ersten Artikel hatten wir dies bereits angedeutet, und die Firma Hewlett-Packard war daraufhin so freundlich, uns einen HP48SX zur Verfügung zu stellen, so daß wir weiter experimentieren konnten.

Wie wir festgestellt haben, unterscheidet sich das Übertragungsformat für Programmdaten stark von dem für Druckerdaten. Druckerdaten werden vom HP48SX, genau wie bei seinen kleinen Brüdern, relativ langsam seriell an den Drucker gesendet, wobei keine Möglichkeit der Rückmeldung besteht. Beim Austausch von Programmdaten über die bidirektionale optische Schnittstelle des HP48SX hingegen wird ein Handshake durchgeführt. Es werden Prüfsummen mit übertragen, und wenn der Empfänger einen Fehler erkennt, teilt er dies dem Sender mit, damit dieser das fehlerhafte Datenpaket erneut senden kann. Diese Sicherheit erlaubt es, mit einer wesentlich höheren Übertragungsgeschwindigkeit zu arbeiten.

Die Schaltung für den optischen Datenempfang, die wir vorgestellt hatten, war auf den Empfang von Druckerdaten ausgelegt, und in diesem Übertragungsmodus können auch vom HP48SX problemlos Daten empfangen werden. Selbst Grafiken werden von der damals abgedruckten Empfangs-Software korrekt dargestellt, obwohl das Display des HP48SX eine andere Auflösung besitzt.

Ein Empfang von Programmdaten vom HP48SX hingegen ist mit der alten Hardware nicht möglich. Dies liegt an der Tiefpaß-Charakteristik der Schaltung, bedingt durch die recht geringe slew rate des Operationsverstärkers LM 324. Im Übertragungsmodus für Programme folgen die seriell gesendeten Bits so schnell aufeinander, daß die Schaltung sie nicht mehr unterscheiden kann. Für den Empfang von Druckerdaten ist dies hilfreich, da die Lichtpulse vom HP in diesem Modus mit einem 32kHz-Trägersignal moduliert sind, welches so herausgefiltert wird (wir hatten dies in unserem ersten Artikel verschwiegen), doch einen Empfang von Programmdaten macht diese Eigenschaft der alten Schaltung leider unmöglich.

Bedienung, bitte!

Hat man den HP in den Server-Modus geschaltet, kann man bei UniTerm im Online-Modus die Tasten Alternate+T drücken. Es erscheint die Dialogbox aus Abbildung 5, über die die Kermit-Funk-tionen bedient werden können. Vom HP werden folgende Funktionen unterstützt: Dir, Remote, Get, Put und Finish.

Dir: Directory. In die erscheinende Dialogbox ist kein Text einzugeben, sondern ein leeres RETURN. Danach wird der Inhalt des aktuellen Directories des HP auf dem Bildschirm des ST angezeigt. Zu jedem Eintrag werden zusätzlich der Typ, die Länge und eine Prüfsumme angezeigt.

Remote: Übermittlung von Befehlen. In die erscheinende Dialogbox kann man hier, durch Leerzeichen getrennt, Befehle eingeben, die vom HP nacheinander ausgeführt werden. Danach wird auf dem Bildschirm des ST der aktuelle Inhalt des Stacks angezeigt. Beispielsweise ist ein Wechsel des Directories durch Angabe des Verzeichnisnamens möglich oder das Löschen eines Objekts mit ‘objname’ PURGE.

Get: Holen einer Variablen. Der Inhalt der Variablen, deren Name einzugeben ist (Großschreibung beachten), wird aus dem HP gelesen und im aktuellen Directory des ST unter demselben Namen abgespeichert.

Put: Variable zum HP senden. Es erscheint eine Fileselectorbox. Die ausgewählte Datei wird zum HP gesendet und dort unter ihrem Namen als Objekt abgelegt.

Finish: Beendet den Server-Modus des HP. Zum Verlassen von UniTerm dient dann die Taste UNDO.

Bei der Funktion Put wird beim ersten Aufruf die Warnung Error: Host refused 8 bit quoting erscheinen, die einfach mit OK bestätigt werden kann. Es ist lediglich ein Hinweis, daß der HP diesen Modus nicht unterstützt und UniTerm deshalb bei der Übertragung auf dieses Feature verzichtet.

GROBVIEW.TTP

Der Objekttyp GROB (GRaphic OBject) auf dem HP umfaßt alle Arten von Grafiken beliebiger Abmessungen. Zum Teil sind sie so groß, daß sie nicht mehr auf das Display des HP48SX passen. Speziell bei längeren Formeln, die mit dem Equation Writer des HP dargestellt werden sollen, tritt dieser häßliche Effekt auf.

Das Programm GROBVIEW, das hier als C-Quelltext abgedruckt ist, dient dazu, Grafiken im HP-Format auf dem Bildschirm des ST anzuzeigen und sie als Grafik im 32000-Byte-Screen-Format zu speichern, w as eine Weiterbearbeitung mit anderen Programmen erlaubt.

Als Vorarbeit ist es nötig, die Grafik mit UniTerm vom HP zu lesen. Möchte man z. B. eine Formel aus dem Equation Writer auf den Atari übertragen, so ist zunächst der Inhalt des Displays mit STO in ein GROB umzuwandeln, das auf dem Stack als Graphic XGröße * YGröße erscheint.

Das Objekt muß nun unter einem Namen abgelegt werden, und mit UniTerm kann das GROB vom HP gelesen werden. Es wird dabei im aktuellen Directory des ST gespeichert.

Das Listing von GROBVIEW umfaßt das Hauptprogramm und eine Projektdatei für Turbo-C. Da das Programm jedoch keine speziellen Turbo-C-Funktionen aufruft, müßte es mit jedem Compiler übersetzbar sein, der den ANSI-Standard versteht.

Nach der Compilierung erhält man ein TTP-Programm, das vom Desktop aus gestartet werden kann. Als Kommandozeile gibt man den Dateinamen an, unter dem die anzuzeigende GROB-Datei zu finden ist. GROBVIEW zeigt diese Datei dann an und speichert sie nach Tastendruck im aktuellen Direktory unter dem Namen GROBFILE.BIT im 32000-Byte-Screen-Format ab.

Um das Programm möglichst kurz zu halten, schreibt GROBVIEW direkt in den Bildschirmspeicher und läuft deshalb nur in der hohen ST-Auflösung und nicht im Console-Fenster von Gemini.

Da nun die Möglichkeit des Datenaustauschs zwischen HP und ST besteht, wird sich vielleicht ein Engagierter finden, der einen Software-Pool organisiert. Aufgrund der geringen Länge der HP-Programme wäre wohl die Form einer Mailbox ideal.

Dirk Schwarzhans, Lukas Bauer

; -------------------------------------------
; GROBVIEW - Darstellung von HP-GROBs auf dem 
;  			 Bildschirm des Atari ST
;
; 	Projektdatei "GROBVIEW.PRJ" für Turbo-C 
; 	Lukas Bauer und Dirk Schwarzhans 
;  	(c) 1991 MAXON Computer
; -------------------------------------------
*.TTP  ;  Name des ausführbaren Programms
.C [-W-pia] ; Warnung "poss. inc. ass. " aus

=  				; Trennzeichen

TCSTART.O  		; Startcode

*  				; oberstes Fenster compilieren

TCSTDLIB.LIB  	;  Standard-Bibliothek
TCTOSLIB.LIB  	;  TOS-Bibliothek

/* -------------------------------------------- */
/* GROBVIEW - Darstellung von HP-GROBs auf dem  */
/*            Bildschirm des Atari ST           */
/*  		  C-Quelltext "GROBVIEW. C"         */
/*            (c) 1991 MAXON Computer           */
/*      Lukas Bauer und Dirk Schwarzhans        */
/* -------------------------------------------- */

#include <stdio h>
#include <tos.h>
#include <string h>

#defxne __VERSION__ "1.00"
#define FILENAME "GROBFILE.BIT"

typedef unsigned char uchar;

/* Funktionsprototypen */ 
int display(char *buffer, char *end); 
size_t read_file(char *fn, char **buffer); 
int reverse(int val);

/*---------------------------------------------*/
/* Übergabe an das TTP-Programm:               */
/* Filename der GROB-Datei                     */
/*                                             */
/* Programm nicht in Gemini-Console starten!   */
/*---------------------------------------------*/

int main(int argc, char *argv[])
{
    char *buffer; 
    size_t length;

    if (argc != 2)
    {
        puts("\033E\n\nGROBVIEW Programm zum An” 
             "zeigen von HP 48SX Grafikobjekten"); 
        puts("Version "__VERSION__","
             __DATE__"\n\r");
        puts("\r\nÜbergabeparameter \r\n"); 
        puts("GROBVIEW.TTP filename"); 
        return -1;
    }

    if (length = read_file(argv[1], &buffer)) 
        display(buffer, buffer + length);

    Mfree(buffer); 
    return 0;
}

/*----------------------------------------------*/
/* Reserviert Speicher und liest die Datei      */
/* '*fn' ein.                                   */
/*----------------------------------------------*/

size_t read_flie(char *fn, char **buffer)
{
    FILE *fp; 
    size_t length.

    if ((fp = fopen(fn, "rb")) == NULL)
    {
        puts("\n\rFehler beim Öffnen der Datei!"); 
        return 0;
    }

    fseek(fp, 0L, SEEK_END); 
    length = ftell(fp); 
    fseek(fp, 0L, SEEK_SET);

    *buffer = (char *)Malloc(length); 
    if (*buffer == NULL)
    {
        puts("\n\rNicht genügend Speicher zum Ein" 
             "lesen der Datei frei'"); 
             return 0;
    }
    if (fread(*buffer, sizeof(char), length, fp)!= length)
    {
        puts("\n\rFehler beim Lesen der Datei!"); 
        return -1;
    }
    fclose(fp);

    return length;
}

/*-----------------------------------------------*/
/* Zeigt die eingelesene GROB-Datei als          */
/* Grafik an (Nur hohe ST-Auflosung)             */
/*-----------------------------------------------*/

int display(char *buffer, char *end)
{
    char *work; 
    uchar *screen;
    int xs, ys, x, y, len, handle; 
    unsigned int val;

    screen = Physbase(); 
    puts("\033E\033f");

    work = buffer;
    while (memcmp(work, "GROB ", 5))
    {
        if (work >= end)
        {
            puts("\n\rDiese Datei enthalt keine gül"
                 "tigen Grafikdaten!"); 
            return -1;
        }
        work++;
    }
    if (sscanf(work + 5, "%d %d %n", &xs, &ys, &len) != 2)
    {
        puts("\n\rUngültiger 'GROB'-Befehl!"); 
        return -1;
    }

    work += 5 + len;

    if (xs % 8)
        xs += 8 - (xs % 8); 
    for (y = 0; y < ys; y++)
    {
        for (x = 0; x < xs; x += 8)
        (
            if (sscanf(work, "%2xd", &val) != 1)
            {
                puts("\n\rUngültiger GROB-Befehl!"); 
                return -1;
            }
            work += 2;
            val = reverse(val);
            *(screen + (x » 3) + y * 80) = val;
        }
    }

    Crawcin();

    if ((handle = Fcreate(FILENAME, 0)) >0)
    {
        Fwrite(handle, 32000, screen);
        Fclose(handle);
    }

    return 0;
}

/*-----------------------------------------------*/
/* Wandelt ein Byte aus der HP-Darstellung in    */ 
/* die Motorola-Form                             */
/* => Der HP48SX ist ein 4 Bit-Rechner !!!       */
/*-----------------------------------------------*/

int reverse (int val)
{
    static int bitpos[] = {3, 2, 1, 0,
                           7, 6, 5, 4};
    int nval, b; 

    nval = 0;
    for (b = 0; b <= 7; b++) 
        if (val & (1 « b))
            nval |= (1 « bitpos[b]);

    return nval;
}

---

---