Themen

21

Lowlevel-Coding / Frage zu Multitasking

« am: 12. October 2005, 22:06 »

Ich hab versucht Multitasking in mein OS einzubauen, aber das hat bis jetzt noch nicht richtig Funktioniert. Deswegen habe ich eine Frage zum starten des Multitasking Vorgang. Dazu habe ich gelesen dieses man dies mit diesem Befehl

Code: [Auswählen]

ltr [Adresse] macht. (Oder geht es ganz Anders?)
Im Protected Mode Tutorial von TeeJay ist dazu dieses Register aufgelistet, welche Inhalte ich nicht ganz verstehe.Und das Ziel der Adresse sein soll.

TR (Bits)
---------------------------------------------------------------
|    Selektor 15-0    |     Deskriptor 8 Byte (Versteck)      |
---------------------------------------------------------------

Meine Fragen dazu sind:
Welcher Selektor ist gemeint? (Vom TSS-Deskriptor oder ein anderen?)
Was ist mit „Deskriptor 8 Byte (Versteck)“ gemeint? Die Adresse von einem Deskriptor und von welchem Deskriptor? (Von einem TSS-Deskriptor)

22

OS-Design / Tastatur druck erzeugt kein Interrupt

« am: 19. August 2005, 20:56 »

Ich hab den PIC umprogrammiert und IDT + GDT eingerichtet.
Funktioniert soweit auch. Aber jetzt möchte ich natürlich kleine Treiber für ein paar Hardware Komponenten programmieren. Und hab gelesen, dass der PIC dafür zuständig ist die Hardware ständig zu überprüfen und bei einer positiven Überprüfung ein Interrup auszulösen. Doch wenn ich in einer Endlosschleife (in der zurzeit noch nichts steht) bin und eine Taste drück wird kein Innterrupt ausgelöst.
Muss noch etwas gemacht werden, dass ich nicht weiß? Oder hab ich den PIC falsch umprogrammiert? (hab in umprogrammiert auf Int 32 –Int 47)  

PS. Was hat es mit dem IRQ 0 (System Zeit Interrup bei mit Int 32) auf sich, wir of wird er aufgerufen und muss ich noch was zu programmieren (Zur Zeit ist fast nicht bei Int 32 da) sprich System Zeit Uhr oder so etwas?  

Code: [Auswählen]

mov al, 00010001b ;Das ICW in AL schreiben
out 0x20, al ;ICW an PIC1 senden
out 0xA0, al ;ICW an PIC2 senden

mov al, 0x20 ;AL auf 32 setzen
out 0x21, al ;ICW2 an ersten PIC senden
mov al, 0x28 ;AL auf 40 setzen
out 0xA1, al ;ICW2 an zweiten PIC senden

mov al, 00000100b ;Die IRQ2 Leitung auf 1 setzen
out 0x21, al ;An den Master-PIC senden
mov al, 2 ;Hier nun die NUMMER der IRQ-Leitung angeben
out 0xA1, al ;An den Slave-PIC senden

mov al, 00000001b ;Die Bits wie oben beschrieben setzen
out 0x21, al ;ICW4 an Master-PIC senden
out 0xA1, al ;ICW4 an Slave-PIC senden

mov al, 0x20 ;EOI-Wert in AL ablegen
out 0x20, al ;EOI an Master-PIC senden

mov al, 0x20 ;EOI-Wert in AL ablegen
out 0xA0, al ;EOI an Slave-PIC senden
out 0x20, al ;EOI an Master-PIC senden
Code vor dem Sprung zum PMode.

23

Lowlevel-Coding / Problem beim Zurückspringen vom Interrupt.

« am: 07. August 2005, 16:12 »

Problem beim Zurückspringen vom Interrupt.

Ich habe für den ProtectMode die GDT und IDT programmiert und eingerichtet. Zusätzlich  habe ich den PIC umprogrammiert (auf 32 bis 47). Jedoch, wenn ein Interrupt aufgerufen wird und zurückgesprungen wird, wird Exception 13 ausgelöst. Mit welchem Befehl wird von einem Interrupt zurückgesprungen, bisher mache ich es mit Irtd benutzt. Was ist daran falsch?

Ps. Ist es richtig, dass der System Timer Interrupt selbstständig vom System(PIC) ausgeführt wird? (Hier Int 32)


Aufbau von einem Interrupt (bei mir)

Code: [Auswählen]

Interrupt_x:
Pushad
Cli
… ;Anweisungen
…
Sti
Popad
Irtd

24

Lowlevel-Coding / Problem mit der IDT

« am: 01. July 2005, 21:27 »

Ich habe für den ProtectMode ein Kernel programmier nur notwendige Sachen (GDT). Dann habe ich es mit der IDT erweitert jedoch stürzt der Rechner nun immer ab, und ich weiß nicht, was am Code falsch ist, jedoch muss die IDT falsch sein, weil ohne sie funktioniert alles. Ich hab zwar die Exceptions noch nicht richtig behandelt aber trotzdem müsste der Code funktionier, weil keine Exceptions ausgelöst werden. Zu den Exceptions noch ein paar Fragen, welche Exceptions muss man den jetzt programmieren und was bedeutet das, wenn sie Exceptions reserviert sind wie 20 – 31 habe ich das so richtig gemacht?

Code: [Auswählen]

[BITS 16] ;16 Bit Code erstellen
jmp start ;GDT überspringen

sCODE equ 1000b
%macro makeIDT 3
dw %1
dw %2
db 0
db %3
dw 0
%endmacro

NULL_Desc:
dd 0
dd 0

CODE_Desc:
dw 0xFFFF ;Segmentgröße Byte 0/1
dw 0 ;Segmentbasisadresse Byte 0/1
db 0 ;Segmentbasisadresse Byte 2
db 10011010b ;Zugriffsberechtigungen
db 11001111b ;Zusatz + Segmentgröße Bits 16 - 19
db 0 ;Segmentbasisadresse Byte 3


DATA_Desc:
dw 0xFFFF
dw 0
db 0
db 0x92
db 0xCF
db 0

dk3:
dw 0x1F40
dw 0x8000
db 0xB
db 10110010b
dw 0

gdt:
Limit    dw 0   ;Größe der GDT (wird später eingetragen)
Base dd 0 ;Adresse der GDT (wird später eingetragen)

;******************************

idts:
makeIDT IRQ_00 ,sCODE, 10001110b
makeIDT IRQ_01, sCODE, 10001110b
makeIDT IRQ_02, sCODE, 10001110b
makeIDT IRQ_03, sCODE, 10001110b
makeIDT IRQ_04, sCODE, 10001110b
makeIDT IRQ_05, sCODE, 10001110b
makeIDT IRQ_06, sCODE, 10001110b
makeIDT IRQ_07, sCODE, 10001110b
makeIDT IRQ_08, sCODE, 10001110b
makeIDT IRQ_09, sCODE, 10001110b
makeIDT IRQ_10, sCODE, 10001110b
makeIDT IRQ_11, sCODE, 10001110b
makeIDT IRQ_12, sCODE, 10001110b
makeIDT IRQ_13, sCODE, 10001110b
makeIDT IRQ_14, sCODE, 10001110b
makeIDT IRQ_15, sCODE, 10001110b
makeIDT IRQ_16, sCODE, 10001110b
makeIDT IRQ_17, sCODE, 10001110b
makeIDT IRQ_18, sCODE, 10001110b
makeIDT IRQ_19, sCODE, 10001110b
makeIDT IRQ_20, sCODE, 10001110b
makeIDT IRQ_21, sCODE, 10001110b
makeIDT IRQ_22, sCODE, 10001110b
makeIDT IRQ_23, sCODE, 10001110b
makeIDT IRQ_24, sCODE, 10001110b
makeIDT IRQ_25, sCODE, 10001110b
makeIDT IRQ_26, sCODE, 10001110b
makeIDT IRQ_27, sCODE, 10001110b
makeIDT IRQ_28, sCODE, 10001110b
makeIDT IRQ_29, sCODE, 10001110b
makeIDT IRQ_30, sCODE, 10001110b
makeIDT IRQ_31, sCODE, 10001110b
makeIDT IRQ_32, sCODE, 10001110b




idt:
Limiti dw 0 ;Größe der IDT (wird später eingetragen)
Basei dd 0 ;Adresse der IDT (wird später eingetragen)

;*******************************************
start:
mov ax,3
int 0x10

cli ;Interrupts ausschalten

 mov eax, cs ;EAX auf derzeitiges Codesegment setzen
    mov ds, ax   ;DS auf Codesegment setzen

shl eax, 4 ;EAX mit 16 multiplizieren (Lineare Adresse
;des Codesegments errechnen)
mov [CODE_Desc+2], ax ;Lineare Adresse des Codesegmentesals
mov   [DATA_Desc+2], ax    ;Startadresse des Code- und  ;Datendeskriptors
    shr eax, 16       ;eintragen
mov [CODE_Desc+4], al
mov [DATA_Desc+4], al

 mov eax, cs ;Startadresse der GDT errechnen
shl eax, 4
add eax, NULL_Desc

 mov [Base], eax ;Startadresse der GDT eintragen
mov [Limit], WORD gdt - NULL_Desc -1 ;Größe der GDT errechnen und eintragen

lgdt    [gdt]   ;GDT laden

;*************************************************+

mov [Limiti], word idt - idts -1


mov eax, cs ;Startadresse der GDT errechnen
shl eax, 4
add eax, idts
mov [Basei], eax


mov si, idts
mov ecx, 33
idv:
xor edx,edx
mov dx, [si]
cmp dx, 0
je son
add edx, eax
mov [si], dx
add si, 6
shr edx, 16
mov [si], dx
inc si
inc si
loop idv
jmp schl
son:
add si, 8
loop idv
schl:


lidt [idt]

;*****************************************************************
mov eax, cr0 ;In den Protected Mode schalten,
or eax, 1 ;indem Bit 0 des CR0 Registers auf 1
    mov cr0, eax   ;gesetzt wird

db 0xea ;FAR-JUMP zum Codesegment
dw PMODE
dw 0x8


[BITS 32] ;32 Bit Code erstellen

PMODE:
mov WORD [CODE_Desc+2], 0 ;Code Segmentstartaddresse auf 0 setzen
mov WORD [DATA_Desc+2], 0 ;Daten Segmentstartadresse auf 0 setzen
mov BYTE [CODE_Desc+4], 0 ;Code Segmentstartaddresse auf 0 setzen
mov BYTE [DATA_Desc+4], 0 ;Daten Segmentstartadresse auf 0 setzen

mov eax, 2 ;Selektor für das Datensegment erstellen
shl eax, 3

mov ds, ax ;Daten- Stack- und Extrasegment mit
mov ss, ax ;Datensegmentdeskriptor laden
mov es, ax
mov eax, 0 ;FS und GS mit Null-Deskriptor laden
mov fs, ax
mov gs, ax
mov esp, 0x1FFFFF ;Stack auf unterhalb der 2 MB Grenze setzen

jmp 0x8:0x10000 + PMODE2 ;Sprung in das "neue" Codesegment

PMODE2:
jmp END ;Zum Ende Springen

;*********************************************



IRQ_00:
xor al, al
jmp irqA

IRQ_01:
mov al, 1
jmp irqA

IRQ_02:
mov al, 2
jmp irqA

IRQ_03:
mov al, 3
jmp irqA

IRQ_04:
mov al, 4
jmp irqA

IRQ_05:
mov al, 5
jmp irqA

IRQ_06:
mov al, 6
jmp irqA

IRQ_07:
mov al, 7
jmp irqA

IRQ_08:
mov al, 8
jmp irqA

IRQ_09:
mov al, 9
jmp irqA

IRQ_10:
mov al, 10
jmp irqA

IRQ_11:
mov al, 11
jmp irqA

IRQ_12:
mov al, 12
jmp irqA

IRQ_13:
mov al, 13
jmp irqA

IRQ_14:
mov al, 14
jmp irqA

IRQ_15:
mov al, 15
jmp irqA

IRQ_16:
mov al, 16
jmp irqA

IRQ_17:
mov al, 17
jmp irqA

IRQ_18:
mov al, 18
jmp irqA

IRQ_19:
mov al, 19
jmp irqA

IRQ_20:
mov al, 20
jmp irqA

IRQ_21:
mov al, 21
jmp irqA

IRQ_22:
mov al, 22
jmp irqA

IRQ_23:
mov al, 23
jmp irqA

IRQ_24:
mov al, 24
jmp irqA

IRQ_25:
mov al, 25
jmp irqA

;*

IRQ_26:
mov ax, 256
jmp irqA


;*

IRQ_27:
mov al, 27
jmp irqA

IRQ_28:
mov al, 28
jmp irqA

IRQ_29:
mov al, 29
jmp irqA

IRQ_30:
mov al, 30
jmp irqA

IRQ_31:
mov al, 31
jmp irqA

IRQ_32:
xor si, si
mov ax,3
shl eax, 3
mov ds, ax
mov cl, 'h'
mov [si],cl
inc si
inc si
mov cl, 'a'
mov [si],cl
inc si
inc si
mov cl, 'l'
mov [si],cl
inc si
inc si
mov cl, 'l'
mov [si],cl
inc si
inc si
mov cl, 'o'
mov [si],cl
inc si
inc si
xor ecx, ecx
not ecx
zz:
loop zz
h:
jmp h

irqA:
xor si, si
mov cl, al
mov ax,3
shl eax, 3
mov ds, ax

mov al, cl
mov ch, '0'
aam
add ah, ch
mov [si],ah
mov cl, al
xor eax, eax
mov al, ah
mov bl, 10
mul bl
sub al, cl
add al, ch
inc si
inc si
mov [si],al
zui:
jmp zui

;************************************************


END:
xor si, si
mov ax,3
shl eax, 3
mov ds, ax
xor esi, esi
mov ax, 3
shl eax, 3
mov ds, ax
mov cl, 'a'
mov byte [esi],48
inc esi
inc esi
mov [esi],cl
;mov ax, 0x1000
;mov es, ax
mov ax, 0x1000
mov ds, ax
g:
jmp g

25

OS-Design / Fragen zum PMode und IDT

« am: 08. June 2005, 10:35 »

Ich hab noch ein paar Fragen zum ProtectMode einmal gibt es Speicheradressen, die reserviert sind (mit Ausnahme vom Videospeicher und dem Stack), wie im RealMode z. B. die Interrupt verctor tabel. Und jetzt noch eine Frage zu der IDT. Mann muss doch eine Routine Programmieren für die Exceptions 0-19. 20 - 31  sind doch reserviert also Nullen eintragen.
Und ein Int 32 Programmiert. Jetzt darf man doch "sti" machen und Int 32 aufrufen, nur bleibt er hängen und ich weiß nicht warum.

So sehen wichtige abschnitte meines Codes aus

Code: [Auswählen]

sCODE equ 1000b
%macro makeIDT 3
                dw %1
                dw %2
                db 0
                db %3
                dw 0
    %endmacro

Code: [Auswählen]

idts:
makeIDT IRQ_00, sCODE, 10001110b
                makeIDT IRQ_01, sCODE, 10001110b
                makeIDT IRQ_02, sCODE, 10001110b
                makeIDT IRQ_03, sCODE, 10001110b
                makeIDT IRQ_04, sCODE, 10001110b
                makeIDT IRQ_05, sCODE, 10001110b
                makeIDT IRQ_06, sCODE, 10001110b
                makeIDT IRQ_07, sCODE, 10001110b
                makeIDT IRQ_08, sCODE, 10001110b
                makeIDT IRQ_09, sCODE, 10001110b
                makeIDT IRQ_10, sCODE, 10001110b
                makeIDT IRQ_11, sCODE, 10001110b
                makeIDT IRQ_12, sCODE, 10001110b
                makeIDT IRQ_13, sCODE, 10001110b
                makeIDT IRQ_14, sCODE, 10001110b
                makeIDT 0,0,0
                makeIDT IRQ_16, sCODE, 10001110b
                makeIDT IRQ_17, sCODE, 10001110b
                makeIDT IRQ_18, sCODE, 10001110b
                makeIDT IRQ_19, sCODE, 10001110b
                makeIDT 0,0,0
                makeIDT 0,0,0
                makeIDT 0,0,0
                makeIDT 0,0,0
                makeIDT 0,0,0
                makeIDT 0,0,0
                makeIDT 0,0,0
                makeIDT 0,0,0
                makeIDT 0,0,0
                makeIDT 0,0,0
                makeIDT 0,0,0
                makeIDT 0,0,0
                makeIDT IRQ_32, sCODE, 10001110b




idt:
Limiti dw 0
Basei dd 0


Code: [Auswählen]

mov eax, cs ;Startadresse der IDT errechnen
shl eax, 4
add eax, idts
mov [Basei], eax


mov [Limiti], word idt - idts -1
lldt [idt]


Code: [Auswählen]


IRQ_00:
xor al, al
jmp irqA

IRQ_01:
mov al, 1
jmp irqA

IRQ_02:
mov al, 2
jmp irqA

IRQ_03:
mov al, 3
jmp irqA

IRQ_04:
mov al, 4
jmp irqA

IRQ_05:
mov al, 5
jmp irqA

IRQ_06:
mov al, 6
jmp irqA

IRQ_07:
mov al, 7
jmp irqA

IRQ_08:
mov al, 8
jmp irqA

IRQ_09:
mov al, 9
jmp irqA

IRQ_10:
mov al, 10
jmp irqA

IRQ_11:
mov al, 11
jmp irqA

IRQ_12:
mov al, 12
jmp irqA

IRQ_13:
mov al, 13
jmp irqA

IRQ_14:
mov al, 14
jmp irqA

IRQ_16:
mov al, 16
jmp irqA

IRQ_17:
mov al, 17
jmp irqA

IRQ_18:
mov al, 18
jmp irqA

IRQ_19:
mov al, 19
jmp irqA

IRQ_32:
xor si, si
mov ax,3
shl eax, 3
mov ds, ax
mov cl, 'h'
mov [si],cl
inc si
inc si
mov cl, 'a'
mov [si],cl
inc si
inc si
mov cl, 'l'
mov [si],cl
inc si
inc si
mov cl, 'l'
mov [si],cl
inc si
inc si
mov cl, 'o'
mov [si],cl
inc si
inc si
h:
xor si, si
jmp h

irqA:
xor si, si
mov cl, al
mov ax,3
shl eax, 3
mov ds, ax
mov [si],cl
jmp irqA


(Der Selektor DS zeigt auf einen Video Deskreptator)

Und dann rufe ich Int 32 auf und nur der Cursor blinkt.

26

Lowlevel-Coding / Tastatur LEDs

« am: 27. May 2005, 15:18 »

Ich habe einen „kleinen“ Tastaturtreiber geschrieben, in dem ich Tastendrücke verarbeiten kann. Nun wollte ich die LEDs programmieren jedoch funktionier das irgendwie nicht.

Code: [Auswählen]

jmp anf
;;;;;;;;;;;;;;;;
TaSt db 2 ;Num LED ist standartmäßig eingeschaltet

anf:
mov dx, 0x64
in al, dx
and al, 1    
cmp al, 0
je anf
mov dx, 0x60
in al, dx
cmp al, 0xC5
je num
jmp anf

num:
mov dx, 0x64
in al, dx
and al, 1
cmp al, 0
jne anf

mov cx, 0x200
warte2:       ;augenblick waren
loop warte2

mov dx, 0x60
mov al, 0xED
out dx, al
mov al, [TaSt]

mov cx, 0x200
warte1:      ;augenblick waren
loop warte1

xor al, 0x2 ;Num LED setzen oder nicht setzen
out dx, al  
mov [TaSt], al


mov cl, '0'
mov si, 8
add cl, al
mov [si],cl  ;gucken ob er bis hier gekommen ist
in al, dx
jmp anf


Vorher wird in den ProtectMode geschaltet.
Der Selektor Ds zeigt auf einen Videodeskriptor.


Nach dem Ausführen passier folgendes:
Nach dem ich die "Num" Taste gerückt habe dauert es ein bisschen. (Warum weiß ich nicht, bei den nächsten drücken auf die Num Taste dauert es fast keine Zeit vielleicht 1ms oder so)
Auf dem Bildschirm erscheint nun ein R und eine Zeile Darunter und mehrere Spalten rechts ein (") Anführungszeichen obwohl statt ein R eine null da sein sollte und das LED leuchtet weiter nachdem ich die Num Taste noch mal drücke steht ein P statt einem R und kein (") und bei dem ED regt sich nichts. Warum funktioniert dieser Code nicht?

27

Lowlevel-Coding / Tastaturtreiber

« am: 16. May 2005, 15:17 »

Ich wollte ein Treiber für die Tastatur, anhand der Ports, programmieren. So hab ich herausgefunden, dass Port 60h für die Scanncodes da sind und, dass man diesen Port nur auslesen soll, wenn Bit 1 des Portes 64h eins ist. Aber wenn ich dieses überprüfe, wird nur eine 0 herausgegeben obwohl ich eine Taste gedrückt habe. Dasselbe passiert beim auslesen vor Port 60h mit Ausnahme, dass 0 und 255 zurückgegeben wird.

So sieht in etwa mein Code aus.

Code: [Auswählen]

mov ax, 3
int 10h
mov ax, 0xb800
mov ds, ax
xor si, si ;si null setzen
anf:
mov dx, 0x64
in al, dx
and al, 2
cmp al, 0
je anf
mov dx, 0x60
in al, dx
cmp al, 0x1E ;Scancode für 'A'
jne anf
mov cl, 'a'
mov [si], cl
inc si
inc si
cmp si, 4000
jne anf
xor si, si
jmp anf
Worin legt das Problem?  

28

Lowlevel-Coding / Problem mit Protect Mode

« am: 13. May 2005, 17:51 »

Ich hab mich mit dem Protect Mode schon etwas länger theoretisch befasst aber was ich Programmier habe funktioniert nicht. So habe ich das Tutorial, welches auf dieser Seite zu lesen ist, etwas Modifiziert,  aber das funktioniert auch nicht. Es ist nur ein blinkender Curser zu sehen.

Hier die Modifizierungen:

Ein weiterer Diskriptator für den Videospeicher:

Code: [Auswählen]

dk3:
dw 0x1F40
dw 8000
db 0xB
db 10110010b
dw 0

für den Video Modus:

Code: [Auswählen]

start:
mov ax,3
int 0x10

cli

und dieser Code um „hallo“ auszugeben:

Code: [Auswählen]

END:
mov ax, 3
shl eax, 3
mov ds, ax
xor si,si
mov al, 'h'
mov [si],al
inc si
mov al, 7
mov [si],al
inc si
mov al, 'a'
mov [si],al
inc si
inc si
mov al, 'l'
mov [si],al
inc si
inc si
mov [si],al
inc si
inc si
mov al, 'o'
mov [si],al
inc si
inc si
h:
xor ax,ax
jmp h

Warum funktionier diese Modifizierung nicht?

29

Lowlevel-Coding / Maus Treiber

« am: 25. January 2005, 15:34 »

Da man bei einem OS ohne Dos Unterstützung die Ints 21h wie 33h der Maus Interrupt, nicht benutzen kann muss man diese selbst Programmieren. (Ich spiele dabei auf Int 33h an).
Jetzt zu meiner Frage: Wie mache ich dass.
Ich weiß, dass man mit dem Befehl In arbeiten muss, aber mit welcher Port Adresse.
Kann mir da irgend wehr weiter helfen?

30

Lowlevel-Coding / fragen zur FAT12 und zu Dos Inerrupt.

« am: 06. October 2004, 16:27 »

Zu erst einmal eine Frage in Bezug auf die Dos Inerrupts. Bedeuten die Dos Inerrupts dass diese Inerrupts Dos brauchen oder was bedeuten sie? Und jetzt eine Frage zu einem Dos Inerrupt nämlich 39h (mit dem man Unterverzeichnisse erstellen kann). Was bedeutet Adresse ASCII Pfadname bedeutet es "A:\Test\" um Test zu erstellen oder was bedeutet es. (Im Klartext wie erstelle ich einen Unterordner) und mit welcher Datei kann ich Dateien erstellen z. B. eine txt Datei.


Und jetzt noch eine Frage zum Fat12 Dateisystem

Zum Testen habe ich auf eine Formatierte Diskette mit Label Beschriftung "Hauke". Ich habe auf der Diskette eine 860 Byte große txt Datei gespeichert mit Name "Super Text.txt". In der FAT Tabelle steht dann das aus dem ich nicht schlau werde. Erst einmal sind hier 4 einträge obwohl doch nur 2 sein dürften und die anderen Werte ergeben für mich irgendwie keinen Sinn.


F0 FF FF 03 F0 FF 00   (Adresse 0200h oder 1400h)


Und dann noch zum Root Directory.
Warum sind hir 4 Einträge. Der erste Eintrag ist doch der "Haupt Order" also "A:\" und der letzte Eintrag ist doch für die txt Datei was dazwischen ist weiß ich nicht was das bedeuten soll. Hängt es vielleicht mit der Länge des Dateinamen zusammen?


(In Hex) (Adresse 2600h)
48 41 55 4B 45 20 20 20  20 20 20 08 00 00 00 00
00 00 00 00 00 00 2A 6A 46 31 00 00 00 00 00 00
42 74 00 00 00 FF FF FF FF FF FF 0F 00 67 FF FF
FF FF FF FF FF FF FF FF FF FF 00 00 FF FF FF FF
01 53 00 75 00 70 00 65 00 72 00 0F 00 67 20 00
54 00 65 00 78 00 74 00 2E 00 00 00 74 00 78 00
53 55 50 45 52 54 7E 31 54 58 54 20 00 9D 42 6B
46 31 46 31 00 00 2F 6B 46 31 02 00 5C 03 00 00

(In ASII nicht komplett)
HAUKE      

Bt
ÿÿÿÿÿÿÿÿÿÿ

S
T
SUPERT~1TXT
F1F1