Hallo,
Ich programmier seit kurzem Assembler (oder versuche es!).
ich will ein kleine System schreiben und bin auf ein Problem gestoßen, bei dem mir niemand (Internet, Bücher, Programmierer) helfen konnte:

1. Wie funktioniert das mit den Interrupts?
Ich weiß, dass es eine Interruptschnittstelle im Prozessor gibt, auf die dieser reagiert.
Was macht jetzt der Computer? (springt er etwa an eine bestimmte Stelle?)

2.Kann mir jeman ein konkretes Beispiel über eine Bildschirmausgabe geben?

Vielen Dank im vorraus
Cpp-Freak

Zitat von Cpp-Freak

1. Wie funktioniert das mit den Interrupts?
Ich weiß, dass es eine Interruptschnittstelle im Prozessor gibt, auf die dieser reagiert.
Was macht jetzt der Computer? (springt er etwa an eine bestimmte Stelle?)

Auf Wikipedia ist eigentlich alles Wissenswerte zu Interrupts schön zusammengefasst.

Zitat von Cpp-Freak

2.Kann mir jeman ein konkretes Beispiel über eine Bildschirmausgabe geben?

Im Betriebssystem-Tutorial ist beschrieben, wie man eine Textausgabe umsetzt.

Grüße,
Matthias

Hallo,
danke für die schnelle Antwort.
das mit den Interrupts verstehe ich trotzdem noch nicht.
schaut denn der Prozessor selbstständig in der Boottabelle nach?

Cpp-Freak

Hallo,
Kann man Bildschirmausgaben auch ohne Softwareinterrupts ausführen?
Also direkt den Port ansprechen.

Cpp-Frek

Sorry für die diesmal späte Antwort, ich hab es wohl einfach übersehen.

Zitat von Cpp-Freak

das mit den Interrupts verstehe ich trotzdem noch nicht.
schaut denn der Prozessor selbstständig in der Boottabelle nach?

Was meinst du mit der „Boottabelle“? Meinst du vielleicht den Interruptvektor?

Zitat von Cpp-Freak

Kann man Bildschirmausgaben auch ohne Softwareinterrupts ausführen?
Also direkt den Port ansprechen.

Ja. Im Real Mode kannst du z.B. direkt in das Segment 0xB800 schreiben, auf welches (normalerweise) der Grafikkartenspeicher für den Textmodus gemappt ist.

Grüße,
Matthias

Hallo,
danke erstmal für die schnelle Antwort.

Ja. Im Real Mode kannst du z.B. direkt in das Segment 0xB800 schreiben, auf welches (normalerweise) der Grafikkartenspeicher für den Textmodus gemappt ist.

Mit welchem Befehl denn? Etwa mit 'OUT'?

Was meinst du mit der „Boottabelle“? Meinst du vielleicht den Interruptvektor?

Mit Boottabelle meine ich die Funktionen die (wohl schon) vom BIOS definirt wurden.


Cpp-Freak

Zitat von Cpp-Freak

Mit welchem Befehl denn? Etwa mit 'OUT'?

Nein. Mit OUT schreibt man doch in kein Speichersegment. Verwende z.B. STOSB oder MOVB.

Zitat von Cpp-Freak

Mit Boottabelle meine ich die Funktionen die (wohl schon) vom BIOS definirt wurden.

Die Funktionen des BIOS kann man (im Real Mode) über Software-Interrupts (INT-Instruktion) aufrufen. Der Prozessor schaut bei der Ausführung dieser Instruktion in der Interruptvektortabelle nach, wo im Speicher die Behandlungsroutine für diese Unterbrechung steht und setzt die Ausführung dort fort.

Grüße,
Matthias

Hallo,
und wie verwendet man MOVB bzw. STOSB ?
Tut mir leid das ich das jetzt frage, aber von dem Befehl hab ich noch nicht gehört.

Cpp-Freak

Zitat von Cpp-Freak

Hallo,
und wie verwendet man MOVB bzw. STOSB ?
Tut mir leid das ich das jetzt frage, aber von dem Befehl hab ich noch nicht gehört.

MOVB ist AT&T-Syntax, in Intel-Syntax ist das einfach nur ein MOV. Den Rest kannst du über rausfinden. Oder du besorgst dir ein gutes Buch zur Assembler-Programmierung. Wie man Werte im Speicher kopiert gehört nun wirklich zu den Grundlagen…

Grüße,
Matthias

Hallo,

MOVB ist AT&T-Syntax, in Intel-Syntax ist das einfach nur ein MOV

Ich programmier eigentlich nur Intel.
Aber was hat verschieben von Daten mit Bildschirmausgaben zu tun?
Greift etwa die Graphikkarte auf 0xB800 zu, um die Ausgabe zu machen?

Cpp-Freak

Zitat von Cpp-Freak

Aber was hat verschieben von Daten mit Bildschirmausgaben zu tun?
Greift etwa die Graphikkarte auf 0xB800 zu, um die Ausgabe zu machen?

Ja, so in der Art. Siehe http://en.wikipedia.org/wiki/VGA_com...Access_methods

Grüße,
Matthias

Ich kann dir jetzt zwar nicht spezifisch auf einen Intel-prozessor bezogen helfen, aber ich hab Assembler anhand des MSP430 von Texas Instruments erlernt. Das ist zwar ein Microcontroller und daher sind da schon einige Unterschiede aber die Grundstrukturen sind die gleichen.

Zu den Interrupts, da bist du dir ja nicht ganz sicher: und zwar gibt es eine Interruptvektortabelle, wo für jeden Port ein bzw. zwei Speicherbereiche reserviert sind. In diese Speicherbereiche schreibt man dann die Adresse der Funktion(auch Interrupt Service Routine -ISR - gennant) die aufgerufen werden soll. Wird ein Interrupt ausgelöst guckt der Prozessor in die Interruptvektortable wo die ISR ist und springt dahin. Nach erfolgreicher ausführung der ISR springt er an die Adresse zurück wo er war bevor er unterbrochen wurde. Das ist jetzt nur eine allgemeine Darstellung, zusätzlich gibt es noch so Faktoren wie Interrupt-Priorität, das z. B. ein Port eine höhere Interrupt-Priorität hat als der andere. Das würde bedeuten, wenn der Prozessor in einer ISR mit niedriger Prioriät ist kann diese durch einen Interrupt von höherer Prioriät unterbrochen werden, andersrum wäre es aber nicht so, da würde die ISR erst nach der anderen ausgeführt werden.

Wie gesagt, dass ist jetzt das Prinzip wie es auf einem Mikrocontroller läuft, ich vermute dass es auf einem Mikroprozessor ein bisschen anders funktioniert, auf einem MC muss ich meinen gesamten Speicher(Interruptvektortabelle, Stack Pointer, etc) komplett selber pflegen, ich denke mal dass es auf einem MP dynamschier sein wird.

Ich hab jetzt doch noch mal ne Frage:
wie kann man bei 32 bit Prozessoren diese Tabelle Manipulieren?
Cpp-Freak

Also, die interrupt vektortabelle kann nur im realmode angesprochen werden (in dem modus in dem du nach dem booten bist also 16bit code der auf einem 32 oder 64 bit prozessor ausgeführt wird) Im pmode kannst du keine ints ansprechen aber in VM86 wieder. mal angenommen du willst interrupt 21h definieren dann machst du folgendes:

Code :

1 2 3 4 5 6 7 8 9

mov ax,0 mov es,ax                   ;setze das extrasegment auf 0 cli                         ;schalte interrupts zur sicherheit aus mov word [es:4*21h],int_21h ;schiebe die offset adresse der funktion int_21h in die vektor tabelle mov word [es:4*21h+2],cs    ;schiebe das codesegment in die vektor tabelle mov ax,09000h                         mov ss,ax                   ;setzte Stack mov sp,100                  ;setzte Stack sti                         ;schalte interrupt rotine wieder ein

So wenn du jetzt int 21h aufrufst dann führt der pc die von dir programmierte funktion int_21h aus.
du kannst auch andere ints setzten indem du einfach das 21h in den eckigen klammern durch die hexadezimale intnummer ersetzt zb. 60h.

mov word [es:4*int nummer],funktion die beim aufrufen des ints ausgeführt werden soll
mov word [es:4*int nummer+2],cs

das ist das prinzip.

Hallo,
vielen Dank nochmal für eure Hilfe!
am Ende hab ich meinen Kernel doch zu was gebracht (siehe Augsburger Allgemeine)

Jetzt stehe ich vor neuen Problemen:

1. Ich brauch einen Diskettentreiber
Da mein Programm immer größer und größer wird, reicht der Platz im Bootsektor nicht mehr aus. Also würd ich gerne Variablen, die sehr lange sind, von der Diskette laden.

2. Überlege ich mir, ob ich den Kernel in C++ weiterprogrammiere, da ich komplizierte Befehle zum steuern des Kernels verwenden werde. (irgendjemand hat das hier schon mal hingekriegt) Würde mir das jemand raten, oder soll ich eher bei Assembler bleiben?

3. Ich habe irgendwie keinen Stack
ich verwende zwar Interrrupts und call-Aufrufe, habe aber keinen Stack definiert.
Kann mir mal jemand sagen, wie ich das mache?

Grüße,
Cpp-Freak