Home

Über Vimage

Vimage kennenlernen

Einsteiger-Tutorial

Vimage Praxis

Grundlagenwissen

Alle Tutorials

Technologien

Hintergrundwissen

• RTA
•• Was ist RTA?
•• Wie RTA funktioniert
•• Die RTA-Entwicklungsumgebung kennenlernen
•• Mit RTA-Programmierung beginnen
•• Einen Kartennetzentwurf berechnen
•• Einen Kartennetzentwurf programmieren

Informationen

Zentrale Download-Seite

Vimage erwerben

Vimage Leerseite

Impressum und Datenschutzerklärung

Anhang

Vimage Special

Wie RTA funktioniert

Ein Blick hinter die Kulissen

Compiler und Assembler sind für die meisten Menschen unbegreifliche Wundersachen. Dabei ist das alles im Fall des RT-Assemblers RTA ganz einfach.

Assemblerzeit und Laufzeit

Zunächst wird das Programm, bevor es gestartet wird, in einen internen Code übersetzt oder „assembliert“. Hierbei liest ein Unterprogramm - der RT-Assembler - das Quellprogramm ein und übersetzt es in einen internen Code. Dieser erste Lebenszyklus des Programmes heißt Assemblerzeit. Die Assemblerzeit dauert nur Sekundebruchteile und erfolgt im Fall von RTA bei Aufruf unmittelbar vor dem Programmstart („just in time“). Aus diesem Grund wird das Assemblieren vom Anwender kaum bemerkt.

Der vom Assembler erzeugte interne Code besteht im Wesentlichen aus zwei Tabellen, der Symboltabelle und der Codetabelle.

Anschließend kommt dieser nun zur eigentlichen Abarbeitung. Hierfür werden die beiden Tabellen an ein zweites Unterprogramm übergeben - den RT-Prozessor. Diesser arbeitet nun den programmierten Algorithmus ab, wobei Eingaben angefordert, Berechnungen ausgeführt die Ergebnisse ausgegeben werden. Das Programm „läuft auf der Maschine.“ Daher heißt dieser Lebenszyklus des Programmes auch Laufzeit.

Das Quellprogramm

Wir demonstrieren die Funktionsweise von RTA an dem kleinen Quellprogramm test_tst0_demo_mittelwert.rta.

;
; test_tst0_demo_mittelwert.rta
; =============================
;
; Demoprogramm. Berechnung des Mittelwertes zweier Zahlen.
;
        _name   Mittelwertberechnung
        _var    z1                      ; Variable z1 deklarieren
        _var    z2                      ; Variable z2 deklarieren
        _var    m                       ; Variable für Mittelwert dekl.
        input   z1      Erste~Zahl      ; Erste Zahl abfragen
        input   z2      Zweite~Zahl     ; Zweie Zahl abfragen
        mov     m       z1              ; z1 nach m transportieren
        add     m       z2              ; z2 zu m addieren
        div     m       2               ; Division durch 2
        output  m       Mittelwert      ; Mittelwert ausgeben
        exit                            ; Abarbeitung beenden
        _end                            ; Das ist die letzte Zeile
Das Quellprogramm trägt den Programmnamen „Mittelwertberechnung“. Es gibt drei Variablen z1, z2 und m. Das Programm führt eine Mittelwertberechnung nach der Formel m=(z1+z2)/2 aus.

Das Quellprogramm wird nun vom RT-Assembler gelesen und alle Symbole werden in eine Symboltabelle eingetragen. Dann liest der Assembler das Programm in einem zweiten Durchlauf noch einmal und nun werden alle Befehle in die Codetabelle eingetragen ...


Die Symboltabelle

Die Symboltabelle hat zwei Spalten, Symbolname (NAME) und Symbolwert (VALUE). Die Zeilennummer heißt Symboladresse.

Auf den Adressen 0 bis 35 trägt der Assembler immer sog. vordefinierte Symbole ein. Adresse 0 erhält z. B. das Leersymbol „.“. Dessen Wert ist immer Null. Auf Adresse 2 ist ein vordefinierte Symbol „pi“ zu erkennen, das vom Assembler mit dem Wert 3,14... gefüllt wurde. Vielleicht ganz nützlich.

(Anmerkung: Die erste Spalte mit der Symboladresse (ADDR) ist nicht Bestandteil der Symboltabelle. Sie dient hier nur der Erläuterung.)

----------------------------------------------------------------
ADDR   NAME                     VALUE
----------------------------------------------------------------
000000 .                        0
000001 ..                       7
000002 pi                       3.14159265358979
000003 pi/2                     1.5707963267949
000004 pi/4                     0.785398163397448
000005 e                        2.71828182845906
000006 ®                        6371004.2029572
000007 ®f                       0
000008 °(                       1.74532925199433E-02
000009 (°                       57.2957795130824
000010 eps                      1E-99
000011 max                      9.999999999999E+99
000012 r0                       0
000013 r1                       0
000014 r2                       0
000015 r3                       0
000016 r4                       0
000017 r5                       0
000018 r6                       0
000019 r7                       0
000020                          0
000021 x                        0
000022 y                        0
000023 z                        0
000024 x'                       0
000025 y'                       0
000026 z'                       0
000027 Rx                       6371004.2029572
000028 Ry                       6371004.2029572
000029 Rx'                      6371004.2029572
000030 Ry'                      6371004.2029572
000031 Cx                       0
000032 Cy                       0
000033 Cx'                      0
000034 Cy'                      0
000035                          0
000036 z1                       0
000037 z2                       6
000038 m                        3
000039 Erste~Zahl               0
000040 Zweite~Zahl              0
000041 2                        2
000042 Mittelwert               0
------------------------------------------------------------------

Ab Adresse 36 folgen die quellprogrammeigenen Symbole. Dies sind z1 auf Adresse 36, z2 auf Adresse 37 und m auf Adresse 38. Eine RTA-Spezialität ist in Symbol Nr. 41 zu erkennen. Das Symbol trägt sowohl Namen „2“ als auch den Wert „2“: Der RT-Assembler prüft Symbolnamen, ob diese Zahlen sind und trägt dann den Zahlenwert als Symbolwert ein. So erhalten Zahlen in RTA ihren Wert.


Die Codetabelle

Im 2. Assemblerdurchlauf wird eine Codetabelle gefüllt. Diese hat 4 Spalten. In die Befehlsspalte (INSTR) kommt der Befehlscode und in die 3 Adresspalten (ADDR1/2/3) die Adressen der 3 Operanden des Befehls. Nicht angegebene Operanden werden zum Leersymbol assembliert. In der Spalte LINE steht die Tabellenzeile. Das ist zugleich die Codeadresse. Das ist alles.

(Anmerkung: Die Spalten LINE, SYMBOL1/2/3 und VALUE1/2/3 sind nicht Bestandteil der Codetabelle, sondern hier nur zur Erläuterung aufgeführt.)

------------------------------------------------------------------------------------
LINE INSTR  SYMBOL1  SYMBOL2  SYMBOL3  ADDR1  ADDR2  ADDR3   VALUE1  VALUE2  VALUE3
------------------------------------------------------------------------------------
0000 init   .        .        .        000000 000000 000000       0       0       0
0001 input  z1       Erste~Za .        000036 000039 000000       0       0       0
0002 input  z2       Zweite~Z .        000037 000040 000000       6       0       0
0003 mov    m        z1       .        000038 000036 000000       3       0       0
0004 add    m        z2       .        000038 000037 000000       3       6       0
0005 div    m        2        .        000038 000041 000000       3       2       0
0006 output m        Mittelwe .        000038 000042 000000       3       0       0
0007 exit   .        .        .        000000 000000 000000       0       0       0
------------------------------------------------------------------------------------

Nachdem der RT-Assembler das Quellprogramm zu Symboltabelle und Codetabelle übersetzt hat, beendet er seine Arbeit. Die „Assemblerzeit“ als eine erste Lebenszeit des Programmes im Computer ist zu Ende.


Auf der Maschine

Nach dem Assemblieren kommt das Abarbeiten. Die Symboltabelle und die Codetabelle werden dem RT-Prozessor übergeben. Nun beginnt die Abarbeitung - das eigentliche Leben des Programmes, die „Laufzeit“ auf der Maschine. Wenn man die Codetabelle durchsieht, wird folgende Funktionsweise des Programmes erkennbar:

  1. Der erste Befehl (den init kann man ignorieren) ist der input-Befehl auf Codeadresse 1. Dieser fragt mit dem Text des Symbolnamen 39 („Erste Zahl“) eine Zahl im Dialog ab. Diese wird dann auf Adresse 36, also Symbol z1 abgespeichert.
  2. Der input-Befehl auf Codeadresse 2 fragt mit dem Text des Symbolnamen 40 („Zweite Zahl“) eine Zahl ab und speichert diese auf Adresse 37, also Symbol z2.
  3. Es folgt ein Transportbefehl (mov), der den Symbolwert von Adresse 36 (z1) auf Adresse 38 (m) schafft.
  4. Ein add addiert den Symbolwert von 37 (z2) auf Symbolwert 38 (m). Der Symbolwert m wird damit zur Summe von z1 und z2.
  5. Nun dividiert ein div den Symbolwert von 38, also m, durch den auf Adresse 41 stehenden Symbolwert. Dies ist die zum Symbolnamen „2“ gehörige 2. Damit ist der Mittelwert auf m fertig gerechnet.
  6. Der output-Befehl auf Codeadresse 6 zeigt das Ergebnis m an. Dabei wird als Dialogtext der Symbolnamen von Adresse 42 hingefügt: „Mittelwert“.
  7. Ein exit-Befehl auf Codeadresse 7 beendet das Programm.

So funktioniert RTA.

Zum Seitenanfang