Eingabe in PM und Dateisystem erstellen, wie?



  • Hallo ,

    hier eine eingabe fuer den ProtectedModus:

    Add eax, 4
    Add eax, ebx
    Sub eax, 23
    Push eax
    Mov eax, cr0
    Or eax, 1
    Mov cr0, eax
    Inc eax
    Dec eax
    Mul eax, 2
    Pop eax
    Add eax 23
    Sub eax, ebx
    Sub eax, 4
    Jmp cs:@pm ; wichtig damit wir alle adressen haben koennen
    

    @pm ist dann in deinem Code auf deinem dataisystem implementiert dahin musst du springen.

    zu deiner dataisystem frage ist halt so du musst unter linux deine aktuelle festplatte also die partition einfach mit einem dateisystem aufspielen dann kannst du da das os draufpacken



  • Danke, für deine Antwort, werde gleich mal deinen Code einfügen bei mir, natürlich mit der veränderung die ich brauche.
    Angenommen ich habe ein FAT32 Dateisystem auf der Festplatte auf der ich mein OS später haben werde. kann ich dann einfach mit den Interrupts für die Dateiverwaltung, das System verwalten oder muss ich mir doch ihrgendwelche Treiber schreibe.

    - IdeCMOS



  • Hallo ,,

    fuer eine Dateisystem brauchst DU immer eine Treiber also nicht fuer die FESTPLATTE! sondern WEGEN dem Dateisystem. Was heisst das?

    Du musst immer bedenken: Ein Dateisystem ist auch nur EINE Software! Dein KERNEL muss immer darauf achten MIT allen INTerrupts ALLE Dateien ABFRAGEN zu koennen. Du BRAUCHST also fat-x32 als Dateisystem und MUSST mit INTerrupts dann die EINZELNEN dateien zugreifen koennen. Das ist einfach. CODES kann ich dir auch geben MUSS icuh aber erst suchen.


  • Mod

    ich würde auch gerne FAT32 nehmen als Dateisystem, aber ich habe nur gesagt ich möchte einen Treiber dafür haben, weil ich mal gelesen habe das man dafür einen braucht. Ich weiß in Wirklichkeit garicht ob man dafür einen Treiber braucht.

    Klar benötigst Du einen Treiber für FAT12/16/32. das ist übrigens eine verflixt komplexe Sache. Im PrettyOS Code kannst Du dies bewundern.
    http://sourceforge.net/p/prettyos/code/HEAD/tree/trunk/Source/kernel/filesystem/fat.c
    Storage und Filesystem sollte man strikt auseinander halten.



  • Tschuldige die Späte Antwort. Henkes, wenn du im ersten Beitrag nachsiehst wirst du sehen, das ich mein komplettes OS in NASM schreiben will / muss. Ich werde gerade versuchen einfach die C- Codes in NASM zu übersetzten. Denn Code den ich gerade in NASM zurzeit Übersetze ist eben der Code von deiner Eingabe im PMode. Die andere Eingabe die hier steht funkt bei mir nicht. implementiere sie wahrscheinlich falsch. naja ,hab schon ein update gemacht und hoffe jetzt eben auf Antworten. dann kann nämlich vielleicht Herr Henkes NASM auch in sein Tutorial einbeziehen.

    - IdeCMOS


  • Mod

    NASM auch in sein Tutorial einbeziehen

    Es gibt in der Tat interessante OS in asm, aber das ist/war nie mein Ziel. Die Übersetzung von C in asm überlasse ich lieber dem Duo aus compiler und linker.
    Hier könntest Du mal schauen: http://code.google.com/p/tatos/ und http://code.google.com/p/tatos/downloads/list (ein interessantes und gut strukturiertes OS in Assembler, soweit ich mich erinnern kann, habe mir dort den usb code angeschaut)



  • Danke. Ich werde mir den Code mal zu gegebener Zeit anschauen, aber jetzt habe ich ferien und werde weg sein. Ich kann zwar hier noch chatten und am Os programmieren. aber nicht testen.

    - IdeCMOS



  • Hallo,

    eine Benutzereingabe anzufordern ist nicht sehr schwer.

    Hast du deinen PIC schon eingestellt das alles läuft, auch die Tastatur?
    Bei einem Tastendruck sollte deine ISR das Zeichen umwandeln und in einem Ringpuffer ablegen.

    Nun erstellst du eine Funktion die den Puffer solange abruft und die Zeichen
    ausgibt/schreibt bis ENTER gedrückt wurde.

    Ich habe bis jetzt auch alles mit NASM geschrieben und kann nun endlich
    das PE Format laden und ausführen. Seit einigen Tagen mache ich mit MASM weiter
    da dies wesentlich einfacher ist.

    Dir scheint noch viel zu fehlen am OS 😕

    Gruß, Nicky



  • Danke supernicky. Ja in der tat fehlt mir noch viel. Ich wäre dir sehr dankbar dafür wenn du mir mal deinen NASM code für die IRQ schicken könntest. bisher habe ich den keyboard- Treiber so weit:

    [BITS 32]
    [global kyb_dr]
    [extern PutStr_Ptr]
    
    FetchScancode
    in al, 0x60
    jmp FetchAndAnalyzeScancode.afterScancode
    
    Scanloop:
    in al, 0x64
    test al, 1
    je Scanloop
    jmp FetchScancode
    
    FetchAndAnalyzeScancode
    call Scanloop
    .afterScancode
    mov byte [scancode], al
    test byte [scancode], 0x80
    jne .if1
    mov byte [scancode], al
    cmp word [scancode], 0x1A
    je .if2
    cmp word [scancode], 0x36
    je .if2
    jmp .exit
    .if1:
    mov byte [scancode], al
    and word [scancode], 0x7F
    cmp word [scancode], 0x1A
    je .if12
    cmp word [scancode], 0x36
    je .if12
    .if12:
    mov byte [ShiftKeyDown], 0
    mov byte [scancode], al
    jmp FetchAndAnalyzeScancode
    .if2:
    mov byte [scancode], al
    mov byte [ShiftKeyDown], 1
    mov byte [scancode], al
    jmp FetchAndAnalyzeScancode
    .exit:
    jmp kyb_dr.afterRoutine
    
    kyb_dr:
    call FetchAndAnalyzeScancode
    .afterRoutine:
    mov bl, byte [scancode]
    mov bh, 0x00
    cmp byte [ShiftKeyDown], 1
    jne .KeyCode
    mov ax, word [asciiShift + bx]
    jmp .end
    .Keycode
    mov ax, word [asciiNonShift + bx]
    jmp .end
    .end:
    mov word [retchar], ax
    xor ax, ax
    mov es, ax
    mov ax, [retchar]
    call PutChr
    ret
    
    PutChr:
    mov edi, [PutStr_Ptr]
    test al, al
    jz .end
    mov ah, 0x07
    stosw
    jmp .end
    .end:
    mov [PutStr_Ptr], edi
    ret
    
    retchar db 0x00
    ShiftKeyDown db 0
    scancode db 0x00
    
    %include "kybdt.asm"
    

    und der funktioniert einigermaßen. Ich kann aus irgendeinem Grund keine Großbuchstaben ausgeben und die sonderzeichen werden auch nicht richtig gedruckt, da kommen manchmal mehrere zeichen raus(also nicht bei den buchstaben). Bei den Zahlen kommen immer auch noch buchstaben mit raus. z.b. bei der eins kommt 1n raus und bei der zwei 2m. ich musste die Tabelle in der das layout steht etwas ummodullieren. jetzt stehen halt alle zeichen in hex da. aber hier jetzt mal die Tabelle.

    %define MAXKEYBUFFER 64               ; max keyboard buffer
    
    ; Keymaps: US International
    
    ; Non-Shifted scancodes to ASCII:
    
    asciiNonShift:
      db 0x00
      db 0x1B
      db 0x31
      db 0x32
      db 0x33
      db 0x34
      db 0x35
      db 0x36
      db 0x37
      db 0x38
      db 0x39
      db 0x30
      db 0x5F
      db 0x3D
      db 0x08
      db 0x0B
      db 0x71
      db 0x77
      db 0x65
      db 0x72
      db 0x74
      db 0x7A
      db 0x75
      db 0x69
      db 0x6F
      db 0x70
      db 0x5B
      db 0x5D
      db 0x0A
      db 0x00
      db 0x61
      db 0x73
      db 0x64
      db 0x66
      db 0x67
      db 0x68
      db 0x6A
      db 0x6B
      db 0x6C
      db 0x3B
      db 0x27
      db 0x60
      db 0x00
      db 0x5C
      db 0x79
      db 0x78
      db 0x63
      db 0x76
      db 0x62
      db 0x6E
      db 0x6D
      db 0x2C
      db 0x2E
      db 0x2F
      db 0x00
      db 0x00
      db 0x00
      db 0x20
      db 0x00
      db 0x80
      db 0x81
      db 0x82
      db 0x83
      db 0x84
      db 0x85
      db 0x86
      db 0x87
      db 0x88
      db 0x89
      db 0x00
      db 0x00
      db 0x92
      db 0x97
      db 0x94
      db 0x2D
      db 0x96
      db 0x35
      db 0x99
      db 0x2B
      db 0x94
      db 0x98
      db 0x95
      db 0x90
      db 0x91
      db 0x00
      db 0x00
      db 0x00
      db 0x9A
      db 0x9B
    
    asciiShift:
      db 0X00
      db 0X1B
      db 0x21
      db 0x40
      db 0x23
      db 0x24
      db 0x25
      db 0x5E
      db 0x26
      db 0x2A
      db 0x28
      db 0x29
      db 0x5F
      db 0x2B
      db 0x08
      db 0x0B
      db 0x51
      db 0x57
      db 0x45
      db 0x52
      db 0x54
      db 0x5A
      db 0x55
      db 0x49
      db 0x4F
      db 0x50
      db 0x7B
      db 0x7D
      db 0x0A
      db 0x00
      db 0x41
      db 0x53
      db 0x44
      db 0x46
      db 0x47
      db 0x48
      db 0x4A
      db 0x4B
      db 0x4C
      db 0x3A
      db 0x22
      db 0x7E
      db 0x00
      db 0x7C
      db 0x59
      db 0x58
      db 0x43
      db 0x56
      db 0x42
      db 0x4E
      db 0x4D
      db 0x3C
      db 0x3E
      db 0x3F
      db 0x00
      db 0x00
      db 0x00
      db 0x20
      db 0x00
      db 0x80
      db 0x81
      db 0x82
      db 0x83
      db 0x84
      db 0x85
      db 0x86
      db 0x87
      db 0x88
      db 0x89
      db 0x00
      db 0x00
      db 0x92
      db 0x97
      db 0x94
      db 0x2D
      db 0x96
      db 0x35
      db 0x99
      db 0x2B
      db 0x93
      db 0x98
      db 0x95
      db 0x90
      db 0x91
      db 0x00
      db 0x00
      db 0x00
      db 0x8A
      db 0x8B
    


  • Hallo,

    ich nutze nur Kleinbuchstaben.
    Meine ISR für den IRQ 1 sieht so aus:

    IRQ_33:				;Tastatur Interrupt IRQ 1
    	pushad
    .einlesen:
    			xor eax, eax
    			;hier ist ein Zeichen im Tastaturpuffer
    			mov byte [getchar.tmp], al
    
    			in al, 0x60			;Zeichen einlesen
    			test al, 128d
    			jnz .ende				;Prüfen ob Bit 7 gesetzt ist
    
    			mov ebx, getchar.ascii_tabelle
    			xlat
    			mov byte [getchar.tmp], al
    .ende:			
    			mov al, 0x20
    			out 0x20, al
    	popad
    iret
    

    Bei einem Tastendruck wird obige ISR aufgerufen.
    Erstmal die Variable getchar.tmp löschen!
    In Zeile 8 wird der Scancode eingelesen. Zeile 9 testet nur ob die Taste losgelassen
    wurde, was mich aber erstmal nicht interessiert.
    Mit dem Befehl xlat hole ich mir das Asciizeichen aus der Tabelle und
    lege es in der Variablen ab.

    Wie man sieht ist mein Ringpuffer nur 1 Byte groß 🤡 (reicht aber)
    Der Buchstabe wird einfach in getchar.tmp gespeichert. Diese Variable liegt
    in der Prozedur getchar

    Meine Tabelle in der aus Scancode der Asciicode wird sieht so aus und liegt ebenfalls hinter der Prozedur getchar.tmp.

    getchar:
    		xor eax, eax
    		mov al, byte [.tmp]
    		or al, al
    		jz getchar
    		mov byte [.tmp], ah
    ret
    .tmp db 0,0
    .ascii_tabelle:
    db 0, 1, "1", "2", "3", "4", "5", "6", "7", "8", "9", "0", "?", "`", 14	;0 - 14
    db 15, "q", "w", "e", "r", "t", "z", "u", "i", "o", "p", "ü", "+", 13		;15 - 28
    db 29, "a", "s", "d", "f", "g", "h", "j", "k", "l", "ö", "ä",0, 42,"#"
    db "y", "x", "c", "v", "b", "n", "m", ",", ".", "-", 54, 55, 0," ", 58
    db 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 200, 73, 74, 201, 76
    db 202, 78, 79, 203, 81, 82, 83, 84, 85, "<", 87, 88, 89, 90, 91, 92, 93,
    db 94, 95, 96, 97, 98, 99, 100, 101, 102
    

    Wenn ich getchar aufrufe, wird geschaut ob in der Variablen .tmp
    ein Asciizeichen liegt, das ganze geschieht in einer Schleife sodaß es erst
    weiter geht wenn man die Tastaur betätigt.
    Sobald ein Zeichen vorhanden ist wird es nach AL geladen und die Variable wieder
    gelöscht.

    Nun kann man den Tastendruck auswerten.

    call getchar
    cmp al, "j"         ;j gedrückt
    je .ja
    cmp al, "n"         ;n gedrückt
    je .nein
    jmp .?
    

    Das ganze funktioniert auch sehr einfach mit Großbuchstaben.
    Dazu legst dur dir eine zweite Tabelle an z.B.

    shift_tabelle:
    db 0, 1, "!", 34, "§", "$", "%", "&", "/", "(", ")", "=", "?", "`", 14	;0 - 14
    db 15, "Q", "W", "E", "R", "T", "Z", "U", "I", "O", "P", "Ü", "*", 13	;15 - 28
    db 29, "A", "S", "D", "F", "G", "H", "J", "K", "L", "Ö", "Ä",0, 42,"'"
    db "Y", "X", "C", "V", "B", "N", "M", ";", ":", "_", 54, 55, 0," ", 58
    db 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 200, 73, 74, 201, 76
    db 202, 78, 79, 203, 81, 82, 83, 84, 85, ">", 87, 88, 89, 90, 91, 92, 93,
    db 94, 95, 96, 97, 98, 99, 100, 101, 102
    

    und baust noch ein Flag oder Statusbyte ein, was z.B. in Bit 0 vermerkt ob
    die Shift-Taste gedrückt oder losgelassen wurde.

    Das gleiche noch für die ALT-Taste:

    alt_tabelle:
    db 0, 0, "²", "³", 0, 0, 0, 0, "{", "[", "]", "}", "\",0, 0	;0 - 14
    db 0, "@", 0, "€", 0, 0, 0, 0, 0, 0, 0, 0, 0, 0	;15 - 28
    db 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,0, 0,0
    db "Y", "X", "C", "V", "B", "N", "µ", ";", ":", "_", 54, 55, 56, " ", 58
    db 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 200, 73, 74, 201, 76
    db 202, 78, 79, 203, 81, 82, 83, 84, 85, "|", 87, 88, 89, 90, 91, 92, 93,
    db 94, 95, 96, 97, 98, 99, 100, 101, 102
    

    Mit den ASCII Zeichen musst du mal ein bisschen probieren. Ü liegt vielleicht nicht
    auf der Ü-Taste aber dafür kannst du die Tabellen ja anpassen.

    Schreiben auf dem Schirm klappt tadellos.

    Um einen String einzulesen habe ich folgende Prozedur erstellt die mit
    zwei Parametern über den Stack aufgerufen wird:

    ;liest einen String ein bis zum Enter Zeichen (13)
    ;Param1 = Adresse wo der String abgelegt werden soll		+8
    ;Param2 = Adresse mit der Anzahl max. Zeichen			+12
    getstring:
    	push ebp
    		mov ebp, esp
    		sub esp, 0x20
    	pushad
    		mov edi, [ebp + 8]		;Stringablage nach EDI
    		xor ecx, ecx
    		mov [ebp - 4], ecx		;Zählervariable
    		mov [ebp - 8], ecx		;tmp Feld zum schreiben
    		mov esi, [ebp + 12]
    		mov ecx, [esi]			;Anzahl der max. Zeichen nach ECX
    		mov [ebp - 12], ecx		;Anzahl temporär zwischenspeichern
    		push dword [coursor]
    		pop dword [ebp - 16]	;Startpos des Coursor speichern!
    
    .einlesen:
    		call getchar			;Zeichen einlesen
    		cmp al, 13d		
    		je .ende				;Wenn Enter dann Ende
    		cmp al, 14d
    		je .back				;Wenn Back dann Sprung zu .back
    
    		mov byte [ebp - 8], al	;
    		stosb				;Schreibe zeichen
    	pushad
    		mov eax, ebp
    		sub eax, 8d
    		push dword eax
    		call print
    	popad
    		inc dword [ebp - 4]		;Zähler + 1
    		dec dword [ebp - 12]	;Zählervariable verringern - 1
    		jz .ende
    		jmp .einlesen
    
    .ende:	
    		xor al, al
    		stosb				;Leerzeichen am Ende des Strings setzen
    ;		mov ebx, [ebp + 12]
    ;		mov eax, [ebp - 4]
    ;		mov [ebx], eax			;geschriebene Zeichen nach Param2
    
    	popad
    		add esp, 0x20
    		mov eax, [ebp - 4]
    	pop ebp
    ret 8
    .back:
    	push eax
    	push ebx
    	push ecx
    		;schauen ob wir nicht am Beginn sind!
    		mov ecx, dword [coursor]
    		cmp ecx, dword [ebp - 16]
    		je .no_back
    		mov ebx, [coursor]
    		sub ebx, 2d
    		xor al, al
    		mov byte [ebx + 0xA0000], al
    		dec edi
    		mov byte [edi], al
    		mov [coursor], ebx
    		call setcoursor
    		dec dword [ebp - 4]		;Zähler - 1
    		inc dword [ebp - 12]		;
    .no_back:		
    	pop ecx
    	pop ebx
    	pop eax
    		jmp .einlesen
    

    Wenn du noch mehr brauchst, schick mir eine Mail.
    ichmachmit@unitybox.de

    Gruß, Nicky


Log in to reply