mit MenuetOS programmieren
1) Anwendungsprogrammierung
1a) Struktur einer Anwendung
1b) Assembler Beispiel
1c) einheitliche Systemfarben benutzen
1d) freie Fensterform
1e) Threads
1f) Real-Time Daten
1) ANWENDUNGSPROGRAMMIERUNG FÜR MENUET-OS
========================================
1a) Struktur einer Anwendung
===============================
Für Menuet zu programmieren ist so leicht, als wenn du als erstes
die Basisstruktur einer Anwendung lernst. An diesem Punkt nehme ich
an, dass du einige Erfahrungen in der Assemblersprache hast.
Die MenuetOS API (Application Programming Interface) ist ein einfach-zu-
lernender Funktionssatz mit praktisch keinem Hierarchichem Zugriff.
Das arbeiten einer Anwendung basiert auf Ereignissen.
Die Anwendung wird mit dem Ereignistyp und der entsprechenden Anwendungshandlung
beim OS registriert. Es gibt 3 Ereignistypen die eine Anwendung erwartet
Standard-Handles: Fenster neuzeichnen, Tastendruck und Buttondruck.
Flussdiagramm und Struktur einer Anwendung mit Standardereignissen:
;;;;;;;;;;;;;;;;;;;;;;;;;
; ;
; HEADER DATEN ;
; ;
;;;;;;;;;;;;;;;;;;;;;;;;;
START:
call draw_window
;;;;;;;;;;;;;;;;;;;;;;;;;
; ;
; WARTEN AUF EREIGNIS ; <--------------------------------------------------I
; ; I
;;;;;;;;;;;;;;;;;;;;;;;;; I
I I
;;;;;;;;;;;;;;;;;;;;;;;;; I
; ; neuzeichnen -> call draw_window -> I
; EREIGNISTYP AUSLESEN ; -> Taste -> read keypress -> process -> I
; ; Button -> read buttonpress -> process -> I
;;;;;;;;;;;;;;;;;;;;;;;;;
draw_window:
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; ;
;ZEICHNE STATISCHE FENSTERTEILE;
; ;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
ret
DATEN-BEREICH:
;;;;;;;;;;;;;;;;;;;;;;;;
; ;
; STATISCHE DATEN ;
; ;
;;;;;;;;;;;;;;;;;;;;;;;;
(Ende des Bildes)
1b) Assembler Beispiele
=======================
Eine stark kommentierte Realisierung der Assemblersprache von der oberen Struktur (1a).
Menuet Systemaufrufe werden mit dem 'int 0x40' Kommando mit der Funktions-
Nummer im Register eax und anderen Registern, wenn notwendig, ausgeführt.
Details von allen im moment Verfügbaren Systemaufrufen sind in der Sektion
(1g) Systemfunktionen.
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; ;
; BEISPIELANWENDUNG ;
; ;
; Compiliere mit FASM für Menuet ;
; ;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; Der Header
use32 ; Compiler um 32 Bit Instructions zu verwenden
org 0x0 ; Die Basisadresse des Codes, immer 0x0
db 'MENUET01' ; 8 Byte ID für Anwendung
dd 0x01 ; Header Version
dd START ; Start der Ausführung
dd I_END ; größe des Bildes
dd 0x100000 ; zu benutzende Speichermenge
; Du hast Zugriff auf den Speicher von 0x0 bis
; zu dem hier definierten Wert. Die Verlegung
; des Codes wird mit den Selektoren erledigt
; die vom OS gesetzt werden.
dd 0x7fff0 ; Stack-Position im Speicherbereich
dd 0x0 ; Parameter passiert Wert
; wenn der Wert was anderes als 0 ist, werden
; die möglichen Parameter beim Start gesendet.
dd 0x0 ; Reserviert für Icon
; Der Code-Bereich
START: ; Start der Ausführung
call draw_window ; zeichnen des Fensters
; Nachdem das Fenster gezeichnet ist, ist es praktisch eine Hauptschleife zu haben.
; Ereignisse werden von hier aus verteilt.
event_wait:
mov eax,10 ; Funktion 10 : warte auf Ereignis
int 0x40
; Ereignistyp wird in eax zurückgegeben
cmp eax,1 ; Ereignis Anfrage auf neuzeichnen?
je red ; Erkl.: Es gab Aktivitäten auf dem Bildschirm und
; teile der Anwendung müssen neu gezeichnet werden.
cmp eax,2 ; Ereignis Taste im Puffer ?
je key ; Erkl.: Benutzer hat eine Taste gedrückt während die
; Anwendung im Vordergrund war.
cmp eax,3 ; Ereignis Button im Puffer ?
je button ; Erkl.: Benutzer hat einen der
; Anwendungs-Buttons gedrückt.
jmp event_wait
; Der nächste Abschnitt liest die Ereignisse und verarbeitet die Daten.
red: ; Ereignishandler: neuzeichnen
call draw_window ; Wir rufen die window_draw Funktion auf und
jmp event_wait ; springen zurück zu event_wait
key: ; Ereignishandler: Tastendruck
mov eax,2 ; Die Taste wird in ah zurückgegeben. Die Taste muss
int 0x40 ; ausgelesen und von der Systemwarteschlange gelöscht werden.
jmp event_wait ; Lies die Taste aus, ignoriere es und springe zu
; event_wait.
button: ; Ereignishandler: Buttondruck
mov eax,17 ; Die Button-Nummerdie in window_draw definiert ist
int 0x40 ; wird in ah zurückgegeben.
cmp ah,1 ; Button ID=1 ?
jne noclose
mov eax,-1 ; Funktion -1 : schließe dieses Programm
int 0x40
noclose:
jmp event_wait ; Dies wird für ignorierte Ereignisse verwendet,
; nützlich für Entwicklung
; *************************************************
; ****** FENSTER-DEFINITIONEN UND ZEICHNEN ******
; *************************************************
;
; Die statischen Fensterteile werden in dieser Funktion gezeichnet. Auf die Fensterleinwand
; kann später von jedem teil des Codes (Threads) aus zugegriffen werden um z.B. Prozesse oder
; aufgenommene Daten anzuzeigen.
;
; Die statischen Teile *müssen* innerhalb der Funktionsnummer 12 platziert werden,
; ebx = 1 und ebx = 2.
draw_window:
mov eax,12 ; Funktion 12: dem OS mitteilen, dass Fenster gezeichnet werden soll
mov ebx,1 ; 1, zeichnen starten
int 0x40
; ZEICHNE FENSTER
mov eax,0 ; Funktion 0 : definiere und zeichne Fenster
mov ebx,100*65536+300 ; [x start] *65536 + [x gr��e]
mov ecx,100*65536+120 ; [y start] *65536 + [y gr��e]
mov edx,0x02ffffff ; Farbe des Arbeitsbereichs RRGGBB
; 0x02000000 = Fenstertyp 2
mov esi,0x808899ff ; Farbe der Titelleiste RRGGBB
; 0x80000000 = Farbverlauf
mov edi,0x008899ff ; Rahmenfarbe RRGGBB
int 0x40
; FENSTERBEZEICHNUNG
mov eax,4 ; Funktion 4 : schreibe Text zum Fenster
mov ebx,8*65536+8 ; [x start] *65536 + [y start]
mov ecx,0x00ddeeff ; Textfarbe RRGGBB
mov edx,labelt ; Zeiger auf Textanfang
mov esi,labellen-labelt ; Textlänge
int 0x40
; BUTTON SCHLIE�EN
mov eax,8 ; Funktion 8 : definiere und zeichne Button
mov ebx,(300-19)*65536+12 ; [x start] *65536 + [x größe]
mov ecx,5*65536+12 ; [y start] *65536 + [y größe]
mov edx,1 ; Button ID
mov esi,0x6677cc ; Buttonfarbe RRGGBB
int 0x40
mov ebx,25*65536+35 ; zeichne Info-Text mit der Funktion 4
mov ecx,0x224466
mov edx,text
mov esi,40
newline: ; Text vom DATENBEREICH
mov eax,4
int 0x40
add ebx,10
add edx,40
cmp [edx],byte 'x'
jne newline
mov eax,12 ; Funktion 12: dem OS über das Fensterzeichnen informieren
mov ebx,2 ; 2, Ende des zeichnens
int 0x40
ret
; *********************************************
; ************* DATENBEREICH ****************
; *********************************************
;
; Daten können frei mit dem Code jeden teils des Images vermischt werden.
; Nur die Header-Informationen wird am Anfang des Images benötigt.
text: db 'DIES IST EIN BEISPIELPROGRAMM, DASS DU '
db 'BENUTZEN KANNST, A:\EXAMPLE.ASM CODE IST KOMMENTIERT '
db 'UND KLAR. SYSTEMFUNKTIONEN SIND IN DER DATEI '
db 'SYSFUNCS.TXT UND KOMMANDOS IN CMD.TXT '
db 'x <- ENDMARKIERUNG, NICHT LÖSCHEN '
labelt: db 'BEISPIELANWENDUNG'
labellen:
I_END:
; Der Bereich nach I_END frei als Anwendungsspeicher zu benutzen,
; vermeide den Stack.
;
; Struktur des Anwendungsspeicher, aufgrund des benutzten Headers, 1MB.
;
; 0x00000 - Beginn des compilierten Images
; I_END - Ende des compilierten Images
;
; + Frei zur Nutzung in der Anwendung
;
; 0x7ff00 - Beginn des Stack-Bereichs
; 0x7fff0 - Ende des Stack-Bereichs - definiert im Header
;
; + Frei zur Nutzung in der Anwendung
;
; 0xFFFFF - Ende des frei nutzbaren Speichers - definiert im Header
;
; Die ganzen Bereiche können mit einer direkten Referenz innerhalb
; der Anwendung modifiziert werden.
; Zum Beispiel, mov [0x80000], Byte 1 bewegt ein Byte über den Stack-Bereich.
Menuet's Anwendungsstruktur ist nicht für die Assemblerprogrammierung
reserviert, der Header kann praktisch in jeder anderen Sprache erzeugt
werden. Jedenfalls ist das allgemeine Anwendungsprogrammierdesign für
32 Bit Assemblerprogrammierung vorgesehen. Die GUI ist extrem einfach
mit einer besonderen Assemblersprache zu Handlen.
1c) einheitliche Systemfarben benutzen
======================================
Während die vorigen Beispiele sich auf eine Basisanwendung konzentriert haben,
wird in dieser Sektion mehr Wert auf das aussehen des Fensters gelegt.
Du kannst einheitliche Desktopfarben benutzen die von einem Farbsetup definiert wurden.
Die neue Funktion in diesem Beispiel ist get_system_colours.
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; ;
; BEISPIEL EINHEITLICHE SYSTEMFARBEN ;
; ;
; Compiliert mit FASM für Menuet ;
; ;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; Der Header
use32 ; compiler um 32 Bit Instruktionen zu nutzen
org 0x0 ; Die Basisadresse für den Code, immer 0x0
db 'MENUET01' ; 8 Byte ID für Anwendung
dd 0x01 ; Header Version
dd START ; Start der Ausführung
dd I_END ; größe des Images
dd 0x100000 ; zu benutzende Speichermenge
; Du hast Zugriff auf den Speicher von 0x0 bis
; zu dem hier definierten Wert. Die Verlegung
; des Codes wird mit den Selektoren erledigt
; die vom OS gesetzt werden.
dd 0x7fff0 ; Stack-Position im Speicherbereich
dd 0x0 ; Parameter passiert Wert
; wenn der Wert was anderes als 0 ist, werden
; die möglichen Parameter beim Start gesendet.
dd 0x0 ; Reserviert für Icon
; Der Code-Bereich
window_size_X equ 300
window_size_Y equ 150
START: ; Ausführungsstart
call draw_window ; Fenster zeichnen
; Nachdem das Fenster gezeichnet ist, ist es praktisch eine Hauptschleife zu haben.
; Ereignisse werden von hier aus verteilt.
event_wait:
mov eax,10 ; Funktion 10 : auf ein Ereignis warten
int 0x40
; Ereignistyp wird in eax zurückgegeben
cmp eax,1 ; Ereignis Anfrage auf neuzeichnen?
je red ; Erkl.: Es gab Aktivitäten auf dem Bildschirm und
; teile der Anwendung müssen neu gezeichnet werden.
cmp eax,2 ; Ereignis Taste im Puffer ?
je key ; Erkl.: Benutzer hat eine Taste gedrückt während die
; Anwendung im Vordergrund war.
cmp eax,3 ; Ereignis Button im Puffer ?
je button ; Erkl.: Benutzer hat einen der
; Anwendungs-Buttons gedrückt.
jmp event_wait
; Der nächste Abschnitt liest die Ereignisse und verarbeitet die Daten.
red: ; Ereignishandler: neuzeichnen
call draw_window ; Wir rufen die window_draw Funktion auf und
jmp event_wait ; springen zurück zu event_wait
key: ; Ereignishandler: Tastendruck
mov eax,2 ; Die Taste wird in ah zurückgegeben. Die Taste muss
int 0x40 ; ausgelesen und von der Systemwarteschlange gelöscht werden.
jmp event_wait ; Lies die Taste aus, ignoriere es und springe zu
; event_wait.
button: ; Ereignishandler: Buttondruck
mov eax,17 ; Die Button-Nummerdie in window_draw definiert ist
int 0x40 ; wird in ah zur�ckgegeben.
cmp ah,1 ; Button ID=1 ?
jne noclose
mov eax,-1 ; Funktion -1 : schließe dieses Programm
int 0x40
noclose:
jmp event_wait ; Dies wird für ignorierte Ereignisse verwendet,
; nützlich für Entwicklung
get_system_colours:
pusha
mov eax,48 ; Funktionsnummer 48: Systemfarben
mov ebx,3 ; Unter-Funktionsnummer 3: ermitteln
mov ecx,app_colours ; Zeiger auf Rückkehrbereich
mov edx,10*4 ; Anzahl der zurückzugebenden Bytes
int 0x40
popa
ret
app_colours: ; SYSTEMFARB-TABELLE
w_frames dd 0x0 ; - Rahmen
w_grab dd 0x0 ; - GRAB-Bereich
w_grab_button dd 0x0 ; Grab-Bereich Button
w_grab_button_text dd 0x0 ; Grab-Bereich Buttontext
w_grab_text dd 0x0 ; Grab-Bereich Text
w_work dd 0x0 ; - Arbeitsbereich
w_work_button dd 0x0 ; Arbeitsbereich Button
w_work_button_text dd 0x0 ; Arbeitsbereich Buttontext
w_work_text dd 0x0 ; Arbeitsbereich Text
w_work_graph dd 0x0 ; Arbeitsbereich Grafiken
; *************************************************
; ****** FENSTER-DEFINITIONEN UND ZEICHNEN ******
; *************************************************
;
; Die statischen Fensterteile werden in dieser Funktion gezeichnet. Auf die Fensterleinwand
; kann später von jedem teil des Codes (Threads) aus zugegriffen werden um z.B. Prozesse oder
; aufgenommene Daten anzuzeigen.
;
; Die statischen Teile *müssen* innerhalb der Funktionsnummer 12 platziert werden,
; ebx = 1 und ebx = 2.
draw_window:
mov eax,12 ; Funktion 12: dem OS mitteilen, dass Fenster gezeichnet werden soll
mov ebx,1 ; 1, zeichnen starten
int 0x40
; ZEICHNE FENSTER
mov eax,0 ; Funktion 0 : definiere und zeichne Fenster
mov ebx,100*65536+300 ; [x start] *65536 + [x größe]
mov ecx,100*65536+120 ; [y start] *65536 + [y größe]
mov edx,0x02ffffff ; Farbe des Arbeitsbereichs RRGGBB
; 0x02000000 = Fenstertyp 2
mov esi,0x808899ff ; Farbe der Titelleiste RRGGBB
; 0x80000000 = Farbverlauf
mov edi,0x008899ff ; Rahmenfarbe RRGGBB
int 0x40
; FENSTERBEZEICHNUNG
mov eax,4 ; Funktion 4 : schreibe Text zum Fenster
mov ebx,8*65536+8 ; [x start] *65536 + [y start]
mov ecx,0x00ddeeff ; Textfarbe RRGGBB
mov edx,labelt ; Zeiger auf Textanfang
mov esi,labellen-labelt ; Textlänge
int 0x40
; BUTTON SCHLIEßEN
mov eax,8 ; Funktion 8 : definiere und zeichne Button
mov ebx,(300-19)*65536+12 ; [x start] *65536 + [x größe]
mov ecx,5*65536+12 ; [y start] *65536 + [y größe]
mov edx,1 ; Button ID
mov esi,0x6677cc ; Buttonfarbe RRGGBB
int 0x40
mov ebx,25*65536+35 ; zeichne Info-Text mit der Funktion 4
mov ecx,0x224466
mov edx,text
mov esi,40
newline: ; Text vom DATENBEREICH
mov eax,4
int 0x40
add ebx,10
add edx,40
cmp [edx],byte 'x'
jne newline
mov eax,12 ; Funktion 12: dem OS über das Fensterzeichnen informieren
mov ebx,2 ; 2, Ende des zeichnens
int 0x40
ret
; *********************************************
; ************* DATENBEREICH ****************
; *********************************************
;
; Daten können frei mit dem Code jeden teils des Images vermischt werden.
; Nur die Header-Informationen wird am Anfang des Images benötigt.
text: db 'DIES IST EIN BEISPIELPROGRAMM, DASS DU '
db 'BENUTZEN KANNST, A:\EXAMPLE.ASM CODE IST KOMMENTIERT '
db 'UND KLAR. SYSTEMFUNKTIONEN SIND IN DER DATEI '
db 'SYSFUNCS.TXT UND KOMMANDOS IN CMD.TXT '
db 'x <- ENDMARKIERUNG, NICHT LÖSCHEN '
labelt: db 'BEISPIELANWENDUNG'
labellen:
I_END:
1d) Freiform Fenster
====================
In diesem Beispiel konzentrieren wir uns auf die Gestaltung der Fenster vom Rechteck
über jede Form die der Programmierer wünscht. Die neue Funktion in diesem Beispiel
ist shape_window.
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; ;
; FREIFORM BEISPIELANWENDUNG ;
; ;
; Compiliert mit FASM für Menuet ;
; ;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; Der Header
use32 ; compiler um 32 Bit Instruktionen zu nutzen
org 0x0 ; Die Basisadresse für den Code, immer 0x0
db 'MENUET01' ; 8 Byte ID für Anwendung
dd 0x01 ; Header Version
dd START ; Start der Ausführung
dd I_END ; größe des Images
dd 0x100000 ; zu benutzende Speichermenge
; Du hast Zugriff auf den Speicher von 0x0 bis
; zu dem hier definierten Wert. Die Verlegung
; des Codes wird mit den Selektoren erledigt
; die vom OS gesetzt werden.
dd 0x7fff0 ; Stack-Position im Speicherbereich
dd 0x0 ; Parameter passiert Wert
; wenn der Wert was anderes als 0 ist, werden
; die möglichen Parameter beim Start gesendet.
dd 0x0 ; Reserviert für Icon
START: ; Ausführungsstart
call shape_window ; Funktion für die Gestaltung
call draw_window ; zuerst, zeichne das Fenster
still:
mov eax,10 ; hier auf Ereignisse warten
int 0x40
cmp eax,1 ; neuzeichnen Anfrage ?
je red
cmp eax,2 ; Taste im Puffer ?
je key
cmp eax,3 ; Button im Puffer ?
je button
jmp still
red: ; neuzeichnen
call draw_window
jmp still
key: ; Taste
mov eax,2 ; nur auslesen und ignorieren
int 0x40
jmp still
button: ; Button
mov eax,17 ; ID ermitteln
int 0x40
cmp ah,1 ; Button-ID=1 ?
jne noclose
mov eax,-1 ; schließe dieses Programm
int 0x40
noclose:
jmp still
shape_window:
pusha
mov eax,50 ; den Referenzbereich angeben
mov ebx,0
mov ecx,shape_reference
int 0x40
mov eax,50 ; die Skalierung angeben 32 x 32 -> 128 x 128
mov ebx,1 ; Dies musst du nicht angeben, Skalierung ist Standardmäßig 1:1
mov ecx,2 ; Sklalierung ist auf 2^ecx gesetzt
int 0x40
popa
ret
shape_reference: ; 32 x 32 ( window_size_X + 1 ) * ( window_size_Y + 1 )
db 0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0
db 0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0
db 0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0
db 0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0
db 0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0
db 0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0
db 0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0
db 0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0
db 0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0
db 0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0
db 0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0
db 0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0
db 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0
db 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0
db 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0
db 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0
db 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0
db 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0
db 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0
db 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0
db 0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0
db 0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0
db 0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0
db 0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0
db 0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0
db 0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0
db 0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0
db 0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0
db 0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0
db 0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0
db 0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0
db 0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0
; **********************************************
; ****** FENSTERDEFINITIONEN UND ZEICHNEN ******
; **********************************************
draw_window:
mov eax,12 ; Funktion 12: dem OS über Fensterzeichnen informieren
mov ebx,1 ; 1, zeichnen starten
int 0x40
; FENSTER ZEICHNEN
mov eax,0 ; Funktion 0: definiere und zeichne Fenster
mov ebx,100*65536 ; [x start] *65536 + [x größe]
mov ecx,100*65536 ; [y start] *65536 + [y größe]
mov bx,word [x_gr��e]
mov cx,word [y_gr��e]
mov edx,0x00cccc00 ; Farbe des Arbeitsbereichs RRGGBB,8->Farbverlauf
mov esi,0x00cccc00 ; Farbe der Titelleiste RRGGBB,8->Farbverlauf
mov edi,0x00cccc00 ; Rahmenfarbe RRGGBB
int 0x40
; SCHLIEßEN-BUTTON
mov eax,8 ; Funktion 8: definiere und zeichne Button
mov ebx,78*65536+12 ; [x start] *65536 + [x größe]
mov ecx,20*65536+12 ; [y start] *65536 + [y größe]
mov edx,1 ; Button-ID
mov esi,0x5599cc ; Buttonfarbe RRGGBB
int 0x40
mov eax,12 ; Funktion 12: dem OS über Fensterzeichnen informieren
mov ebx,2 ; 2, Ende des zeichnens
int 0x40
ret
; DATEN
x_size dd 127
y_size dd 127
I_END:
1e) Threads
===========
MenuetOS Assembler-Threading hat einige großartige vorteile gegenüber
Hochsprachen. Wenn du alle Variablen in Registern lässt, kannst du
soviele Threads im selben Code starten wie du möchtest, solange kein
Speicher berührt wird und nicht gespeichert werden muss. Die Register
werden in den Task-Switch Segmenten von MenuetOS gespeichert. Alles
was du tun musst, ist einen neuen Stack anzulegen.
Threads haben keinen unterschied mit dem Hauptprozess und benutzen
denselben Speicherbereich wie der Prozess der ihn gestartet hat. Sie
können ihre eigenen unabhängigen Fenster usw. haben. Beim beenden
der Anwendung, müssen alle Threads mit dem Standard-Systemaufruf
(eax = -1) beendet werden.
Die neue Funktion in diesem Beispiel ist create_thread.
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; ;
; THREAD BEISPIEL ;
; ;
; Compiliert mit FASM für Menuet ;
; ;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
use32
org 0x0
db 'MENUET01' ; 8 Byte ID
dd 0x01 ; Header Version
dd START ; Beginn des Codes
dd I_END ; größe des Images
dd 0x100000 ; Speicher für die Anwendung
dd 0x80000 ; esp
dd 0x0 , 0x0 ; I_Param , I_Icon
START: ; Beginn der Ausführung
call draw_window ; zuerst, zeichne das Fenster
event_wait:
mov eax,10 ; hier auf Ereignis warten
int 0x40
cmp eax,1 ; neuzeichnen Anfrage ?
je red
cmp eax,2 ; Taste im Puffer ?
je key
cmp eax,3 ; Button im Puffer ?
je button
jmp event_wait
red: ; neuzeichnen
call draw_window
jmp event_wait
key: ; Taste
mov eax,2 ; auslesen und ignorieren
int 0x40
jmp event_wait
button: ; Button
mov eax,17 ; ID ermitteln
int 0x40
cmp ah,1 ; Button-ID=1 ?
jne noclose
mov eax,-1 ; schließe dieses Programm (Thread)
int 0x40
noclose:
cmp ah,2 ; create_thread aufrufen
jne no_thread
call create_thread
jmp event_wait
no_thread:
jmp event_wait
; THREAD ERZEUGEN
;
; Alles was wir tun müssen, ist, die Thread-Einstiegsadresse mit der
; Funktion eax=51, ebx=1 in ecx und eine neue Stack-Position in edx
; anzugeben
create_thread:
cmp [thread_stack],0xf0000
jge no_new_thread
add [thread_stack],0x1000
mov eax,51 ; thread_create Systemaufruf
mov ebx,1
mov ecx,START
mov edx,[thread_stack]
int 0x40
no_new_thread:
ret
thread_stack dd 0x80000
; **********************************************
; ****** FENSTERDEFINITIONEN UND ZEICHNEN ******
; **********************************************
draw_window:
mov eax,12 ; Funktion 12: Das OS über das Fensterzeichnen informieren
mov ebx,1 ; 1, zeichnen starten
int 0x40
; FENSTER ZEICHNEN
mov eax,0 ; Funktion 0: definiere und zeichne Fenster
mov ebx,10*65536+300 ; [x start] *65536 + [x gr��e]
mov ecx,10*65536+140 ; [y start] *65536 + [y gr��e]
mov esi,[thread_stack]
sub esi,0x80000
shr esi,11
shl esi,16
add ebx,esi
add ecx,esi
mov edx,0x02ffffff ; Farbe des Arbeitsbereichs RRGGBB,8->Farbverlauf
mov esi,0x808899ff ; Farbe der Titelleiste RRGGBB,8->Farbverlauf
mov edi,0x008899ff ; Farbe des Rahmens RRGGBB
int 0x40
; FENSTERBEZEICHNUNG
mov eax,4 ; Funktion 4: schreibe Text zum Fenster
mov ebx,8*65536+8 ; [x start] *65536 + [y start]
mov ecx,0x00ddeeff ; Textfarbe RRGGBB
mov edx,labelt ; Zeiger auf Textanfang
mov esi,labellen-labelt ; Textlänge
int 0x40
; SCHLIEßEN-BUTTON
mov eax,8 ; Funktion 8: definiere und zeichne Button
mov ebx,(300-19)*65536+12 ; [x start] *65536 + [x größe]
mov ecx,5*65536+12 ; [y start] *65536 + [y größe]
mov edx,1 ; Button-ID
mov esi,0x6677cc ; Buttonfarbe RRGGBB
int 0x40
mov eax,8 ; NEUER THREAD-BUTTON
mov ebx,25*65536+128
mov ecx,88*65536+20
mov edx,2
mov esi,0x6677cc
int 0x40
mov ebx,25*65536+35 ; zeichne Infotext mit der Funktion 4
mov ecx,0x224466
mov edx,text
mov esi,40
newline:
mov eax,4
int 0x40
add ebx,10
add edx,40
cmp [edx],byte 'x'
jne newline
mov eax,12 ; Funktion 12: OS über Fensterzeichnen informieren
mov ebx,2 ; 2, Ende des zeichnens
int 0x40
ret
; DATEN-BEREICH
text:
db 'DIESES BEISPIEL ERZEUGT THREADS INDEM ES '
db 'DENSELBEN CODE MEHRMALS AUSFÜHRT. ALLES WAS '
db 'WIR BRAUCHEN IST EIN NEUER STACK FÜR JEDEN THREAD.'
db 'ALLE THREADS TEILEN SICH DENSELBEN SPEICHER. '
db ' '
db ' '
db ' NEUEN THREAD ERZEUGEN '
db 'x <- ENDMARKIERUNG, NICHT LÖSCHEN '
labelt:
db 'THREADBEISPIEL'
labellen:
I_END:
1f) Echtzeit-Daten
==================
Das folgende Beispiel konzentriert sich auf das Echtzeit Daten-holen und -verarbeiten.
Die Anwendung informiert das OS über alle Ports und Datentypen die an einem
bestimmten IRQ gelesen werden.
Schritte:
1) reserviere I/O Port-Bereich
2) reserviere IRQ
3) Programm-IRQ
4) Programm-EREIGNIS-Liste für den gewünschten IRQ
5) Laufzeit Verarbeitung der Daten
6) zurück zu den Standardereignissen - freier IRQ von der EREIGNIS-Liste
7) freier IRQ
8) freier Port-Bereich
9) beende Programm
Nachdem die IRQ's programmiert sind, hat die Anwendung ein neues Ereignis
für die Hauptereignisschleife, Nummer (IRQ+16).
Wenn die Anwendung dieses Ereignis empfängt, hat das OS die Daten für die
Anwendung aufgenommen um sie zu verarbeiten.
Die untere Tabelle zeigt die Hauptstruktur der zu verarbeitenden Echtzeit-Daten.
Die ganzen Schritte links vom (A) werden vom OS verarbeitet und die
Schritte rechts vom (A) sind von der Anwendung verarbeitet.
IRQ BESITZER => REC DATEN (A) SYS_EVENT => DATEN LESEN => PROZESS
0 TIMER SYS
1 TASTATUR SYS
2 frei ->
3 COM MAUS SYS/frei ?>
4 COM MAUS SYS/frei ?>
5 SOUND BL. SYS
6 DISKETTE SYS
7 frei ->
8 frei ->
9 frei ->
10 frei ->
11 frei ->
12 PS2 MAUS SYS/frei ?>
13 MATH PR. SYS
14 IDE SYS
15 IDE SYS
Ein Beispiel wie man Echtzeit-Daten verarbeitet:
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; ;
; ECHTZEIT-DATEN ;
; ;
; Compiliert mit FASM für Menuet ;
; ;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
use32
org 0x0
db 'MENUET00' ; 8 Byte ID
dd 56 ; benötigt OS
dd START ; Programm Start
dd I_END ; Programm Image größe
dd 0x100000 ; benötigte Speichermenge
; esp = 0x7FFF0
dd 0x00000000 ; reserviert=kein erweiterter Header
START: ; Beginn der Ausführung
call draw_window ; zuerst, zeichne das Fenster
call program_real_time_data ; Programmiere das OS um Echtzeit-Daten zu empfangen
call program_com_port ; Programmiere den COM-Port für ein spezifisches Gerät
event_wait:
mov eax,10 ; hier auf ein Ereignis warten
int 0x40
cmp eax,1 ; neuzeichnen Anfrage ?
je red
cmp eax,2 ; Taste im Puffer ?
je key
cmp eax,3 ; Button im Puffer ?
je button
cmp eax,16+4 ; RT: Neues Ereignis für die gewünschten IRQ-Daten (16+IRQ)
je read_rt
jmp event_wait
; Die nächste Sektion liest die Ereignisse und verarbeitet die Daten.
read_rt: ; RT Daten
mov eax,42 ; Funktion 42 gibt die Daten für IRQ 4 zur�ck
mov ebx,4 ;
int 0x40 ; OS gibt die aufgenommenen Daten zurück.
; eax restliche Anzahl an Bytes im Puffer
; bl Daten
; ecx 0 = erfolg, andere = keine Daten im Puffer
call process_data
jmp event_wait
red: ; neuzeichnen
call draw_window
jmp event_wait
key: ; Taste
mov eax,2 ; lesen und ignorieren
int 0x40
jmp event_wait
button: ; Button
mov eax,17 ; ID ermitteln
int 0x40
cmp ah,1 ; Button-ID=1 ?
jne noclose
call free_real_time_data
mov eax,-1 ; schließe dieses Programm
int 0x40
noclose:
jmp event_wait
program_real_time_data:
; holen der Echtzeit-Daten programmieren
;
; 1) reserviere I/O Port-Bereich
; 2) reserviere IRQ
; 3) Programmiere IRQ
; 4) Programmiere EREIGNIS-Liste für den gewünschten IRQ
;
pusha
mov eax,46 ; reserviere Ports 0x3f0 - 0x3ff
mov ebx,0
mov ecx,0x3f0
mov edx,0x3ff
int 0x40
mov eax,45 ; reserviere IRQ 4
mov ebx,0
mov ecx,4
int 0x40
mov eax,44 ; setze lese-Ports für IRQ 4
mov ebx,irqtable
mov ecx,4
int 0x40
mov eax,40 ; ermittle COM1 Daten mit IRQ 4
mov ebx,0000000000010000b shl 16 + 111b ; nachdem wir das neue Ereignis
; haben (16+4)
int 0x40
popa
ret
irqtable:
dd 0x3f8+0x01000000 ; 3f8 = Port zum lesen : 01 =Byte lesen, 02 =Wort lesen
dd 0x0 ; 0x0 = beendet lesen über IRQ Ereignis
dd 0x0
dd 0x0
dd 0x0
dd 0x0
dd 0x0
dd 0x0
dd 0x0
dd 0x0
dd 0x0
dd 0x0
dd 0x0
dd 0x0
dd 0x0
dd 0x0
free_real_time_data:
; genutzte Resourcen freigeben
;
; 1) Standardereignisse ermitteln
; 2) IRQ mit Funktion 45,1 freimachen
; 3) Port-Bereich mit Funktion 46,1 freimachen
;
pusha
mov eax,40 ; Standardereignisse - IRQ 4 Ereignisse deaktivieren
mov ebx,111b
int 0x40
mov eax,45 ; IRQ freigeben
mov ebx,1
mov ecx,4
int 0x40
mov eax,46 ; Ports 0x3f0-0x3ff freigeben
mov ebx,1
mov ecx,0x3f0
mov edx,0x3ff
int 0x40
popa
ret
; Die folgenden Funktionen sind zur Verarbeitung von Gerätespezifischen Daten.
process_data:
cmp ebx,80
jne nocd
mov eax,19
mov ebx,cdplayer
mov ecx,0
int 0x40
nocd:
push ebx
mov eax,[pos]
add eax,1
cmp eax,10*20+1
jb noeaxz
mov esi,text+10*4
mov edi,text
mov ecx,10*21*4
cld
rep movsb
mov eax,13
mov ebx,20*65536+260
mov ecx,22*65536+220
mov edx,[wcolor]
int 0x40
mov eax,10*19+1
noeaxz:
mov [pos],eax
pop ebx
and ebx,0xff
call draw_data
ret
draw_data:
pusha
xchg eax,ebx
mov ecx,10
shl ebx,2
mov esi,3
newnum:
xor edx,edx
div ecx
add edx,48
mov [ebx+text-1],dl
dec ebx
dec esi
jnz newnum
call draw_text
popa
ret
draw_text:
pusha
mov ebx,25*65536+35 ; zeichne den Info-Text mit Funktion 4
mov ecx,0xffffff
mov edx,text
mov esi,40
mov edi,20
newline:
mov eax,4
int 0x40
add ebx,10
add edx,40
dec edi
jne newline
popa
ret
program_com_port:
; Die folgende Sequenz programmiert den COM-Port für einen Infrarot-Empfänger
mov cx,0x3f3+8
mov bl,0x80
mov eax,43
int 0x40
mov cx,0x3f1+8
mov bl,0
mov eax,43
int 0x40
mov cx,0x3f0+8
mov bl,0x30 / 4
mov eax,43
int 0x40
mov cx,0x3f3+8
mov bl,3
mov eax,43
int 0x40
mov cx,0x3f4+8
mov bl,0xB
mov eax,43
int 0x40
mov cx,0x3f1+8
mov bl,1
mov eax,43
int 0x40
mov eax,5
mov ebx,100
int 0x40
mov cx,0x3f8
mov bl,'I'
mov eax,43
int 0x40
mov eax,5
mov ebx,10
int 0x40
mov cx,0x3f8
mov bl,'R'
mov eax,43
int 0x40
ret
; **********************************************
; ****** FENSTERDEFINITIONEN UND ZEICHNEN ******
; **********************************************
draw_window:
mov eax,12 ; Funktion 12: OS über das Fensterzeichnen informieren
mov ebx,1 ; 1, zeichnen beginnen
int 0x40
; FENSTER ZEICHNEN
mov eax,0 ; Funktion 0: definiere und zeichne Fenster
mov ebx,100*65536+300 ; [x start] *65536 + [x größe]
mov ecx,100*65536+250 ; [y start] *65536 + [y größe]
mov edx,[wcolor] ; Farbe des Arbeitsbereichs RRGGBB,8->Farbverlauf
mov esi,0x8099bbff ; Farbe der Titelleiste RRGGBB,8->Farbverlauf
mov edi,0x00ffffff ; Farbe des Rahmens RRGGBB
int 0x40
; FENSTERBEZEICHNUNG
mov eax,4 ; Funktion 4: schreibe Text zum Fenster
mov ebx,8*65536+8 ; [x start] *65536 + [y start]
mov ecx,0x00ffffff ; Textfarbe RRGGBB
mov edx,labelt ; Zeiger auf den Textanfang
mov esi,labellen-labelt ; Textlänge
int 0x40
; SCHLIEßEN-BUTTON
mov eax,8 ; Funktion 8: definiere und zeichne Button
mov ebx,(300-19)*65536+12 ; [x start] *65536 + [x größe]
mov ecx,5*65536+12 ; [y start] *65536 + [y größe]
mov edx,1 ; Button-ID
mov esi,0x5599cc ; Button-Farbe RRGGBB
int 0x40
call draw_text
mov eax,12
mov ebx,2
int 0x40
ret
; DATEN-BEREICH
wcolor dd 0x0
pos dd 0x0
cdplayer db 'CDPLAY '
labelt db 'INFRAROT-EMPFÄNGER FÜR IRMAN AN COM1'
labellen:
text:
I_END:
eof
The Assembly Language Programmers OS!