Beiträge von Markus

Markus · 29. März 2024

So das XMS test Programm läuft dann soweit erstmal.

es prüft ob ein XMS treiber vorhanden ist

Code

//prfen ob XMS-Treiber installiert
asm{
    mov ax,4300h;
    int 2fh;
    //al=80h (128) = Treiber OK
    mov XMScheck,al;
}
//INFO >>
print(1,2,8,"XMS treober aktiv (128 / 0x80 = OK) :");
print(40,2,7,XMScheck);

danach wird die Adresse vom XMS Handler erfragt

Code

//XMS Handler Adresse erfragen
asm{
    mov ax,4310h;
    int 2fh;
    //
    mov word ptr XMSvec,bx;
    mov word ptr XMSvec +2,es;
}
//INFO Adresse >>
print(1,3,8,"XMS Adresse                         :");
print(40,3,7,XMSvec);

Alles anzeigen

danach wird keine interupt mehr verwendet.

jetzt wird abgefragt wieviel speicher verfügbar ist und wie gross der grösste Block ist.

Code

//XMS freien speicher abfragen
    asm{
        mov ah    ,8;
        call XMSvec;        //anfordern
        mov XMSfree    ,dx;    //verfgbarer XMS in Kbytes
        mov XMSbblock    ,ax;    //gr”sster noch freier zusammenh„ngender XMS-Block
    }
//INFO Freier Speicher/Bl”cke
print(1,5,8,"XMS freier speicher");
print(21,5,7,XMSfree);
print(30,5,8,"XMS gr”sster Block");
print(49,5,7,XMSbblock);

Alles anzeigen

Ein Block von 1000kb wird reserviert und dem Block wird ein Handler zugewiesen.

Code

//XMS Allocate Memory
unsigned int kbytes=1000;//KB anfragen
asm{
    mov dx    ,kbytes;        //ben”tigte Gr”sse
    mov ah    ,9;
    call XMSvec;        //anfordern
    mov XMStest    ,ax;    //1=OK / 0=Fehler
    mov XMShandle    ,dx;    //zurckgegebener Handle fr den angefragten XMS-Speicher
    mov XMSfehler    ,bl;    //Fehlermeldung 160=kein speicher frei!
    }
//INFO Block reservieren
print(1,7,8,"XMS reservieren");

print(1,7,8,"XMS 1=OK/0=Fehler");
print(19,7,7,XMStest);
print(30,7,8,"XMS Fehlercode");
print(45,7,7,XMSfehler);
print(60,7,8,"XMS Handle");
print(71,7,7,XMShandle);
//
fehler(XMSfehler);
print(1,8,14,Fehler);

Alles anzeigen

danach kommt man in eine Schleife welche 2 funktionen hat.

1. Inhalt der Variable test1 in den reservierten XMS Block kopieren

2. Inhalt aus XMS Block kopieren nach Variable test2

Im Programm wird der Inhalt von Variable test1 / test2 oben nebeneinander angezeigt.

Code

//kopieren XMS > X
if (ch=='7'){

unsigned int XMSl_L=8;
unsigned int XMSl_H=0;

asm{
//L„nge gerade Zahl!!
    mov     ax,XMSl_L;
    mov     [si]       ,ax        ;
    mov     ax,XMSl_H;
    mov        2[si]       ,ax        ;
//QUELLE
    mov ax,XMShandle;
    mov word ptr  4[si],ax        ;
    mov word ptr  6[si],offset 0    ;
    mov word ptr  8[si],seg 0    ;
//ZIEL
    mov word ptr 10[si],0        ;
    mov word ptr 12[si],offset &test2;
    mov word ptr 14[si],seg &test2    ;
//Funktion / Aufruf
    mov ah,0Bh;
    call    XMSvec            ;

    mov XMStest,ax            ;//1=OK
    mov XMSfehler,bl         ;//Fehlermeldung 160=kein speicher frei!
}

fehler(XMSfehler);
print(1,12,14,"X > XMS");
print(9,12,12,XMSfehler);
print(30,12,14,"AX1=OK");
print(39,12,14,XMStest);
print(1,13,14,Fehler);
}










//kopieren X > XMS
if (ch=='6'){

unsigned int XMSl_L=8;
unsigned int XMSl_H=0;

asm{
//L„nge gerade Zahl!!
    mov     ax,XMSl_L        ;
    mov     [si]         ,ax        ;
    mov     ax,XMSl_H        ;
    mov        2[si]       ,ax        ;
//QUELLE
    mov word ptr  4[si],0        ;
    mov word ptr  6[si],offset &test1;
    mov word ptr  8[si],seg &test1    ;
//ZIEL
    mov ax,XMShandle
    mov word ptr 10[si],ax        ;
    mov word ptr 12[si],offset 0    ;
    mov word ptr 14[si],seg 0    ;
//Funktion / Aufruf
    mov ah,0Bh;
    call    XMSvec            ;

    mov XMStest,ax            ;//1=OK
    mov XMSfehler,bl         ;//Fehlermeldung 160=kein speicher frei!
}

fehler(XMSfehler);
print(1,12,14,"X > XMS");
print(9,12,12,XMSfehler);
print(30,12,14,"AX1=OK");
print(39,12,14,XMStest);
print(1,13,14,Fehler);
}

Alles anzeigen

beim beenden wird der Block wieder frei gegeben.

Code

//XMS Handle frei geben
if (XMShandle>0){
    asm{
        mov dx        ,XMShandle;//Handle welches frei gegeben werden soll
        mov ah        ,0Ah
        call XMSvec;
    }
//INFO Block freigeben
print(1,9,4,"XMS Handle frei gegeben");
print(25,9,12,XMSbblock);

...man kann blöcke kopieren obwohl keiner reserviert wurde... das kann etwas unschön enden, weil hier dann in Handle 0 geschrieben, das sind die ersten 1MB...

also darf funktion 7 nur verwendet werden wenn zuvor alles ohne Fehler durch lief.

hier nochmal das ganze.

C

#include <conio.h>
#include <stdlib.h>
#include <string.h>
#include <iostream.h>
#include <stdio.h>
#include <dos.h>


//-------------------------------------------------------------------------

char Fehler[36];


//Fehler Meldung Text zuweisen!
void fehler(unsigned char EC)
{

strcpy(Fehler,"");

if (EC==0x80) strcat(Fehler,"unbekannte Funktion                ");
if (EC==0x81) strcat(Fehler,"VDISK gefunden                     ");
if (EC==0x82) strcat(Fehler,"Gate A20 Fehlfunktion              ");
if (EC==0x8E) strcat(Fehler,"unbestimmter Fehler des Treibers   ");
if (EC==0x8F) strcat(Fehler,"Schwerer Fehler, Programm beenden!!");
if (EC==0x90) strcat(Fehler,"kein HMA verfügbar                 ");
if (EC==0x91) strcat(Fehler,"HMA belegt                         ");
if (EC==0x92) strcat(Fehler,"DX < /HMAMIN= @    DEVICE=HIMEM.SYS");
if (EC==0x93) strcat(Fehler,"HMA nicht vergeben                 ");
if (EC==0x94) strcat(Fehler,"A20 noch freigegeben               ");
if (EC==0xA0) strcat(Fehler,"XMS vollständig vergeben           ");
if (EC==0xA1) strcat(Fehler,"alle XMS Handles vergeben          ");
if (EC==0xA2) strcat(Fehler,"ungültige Handle                   ");
if (EC==0xA3) strcat(Fehler,"ungültige Handle bei Quelladresse  ");
if (EC==0xA4) strcat(Fehler,"ungültige Quelladresse (Offset)    ");
if (EC==0xA5) strcat(Fehler,"ungültige Handle bei Zieladresse   ");
if (EC==0xA6) strcat(Fehler,"ungültige Zieladresse (Offset)     ");
if (EC==0xA7) strcat(Fehler,"ungültige Länge                    ");
if (EC==0xA8) strcat(Fehler,"Kopierbereiche überlappen          ");
if (EC==0xA9) strcat(Fehler,"Parity-Fehler                      ");
if (EC==0xAA) strcat(Fehler,"Block nicht gesperrt               ");
if (EC==0xAB) strcat(Fehler,"Block gesperrt                     ");
if (EC==0xAC) strcat(Fehler,"zuviele Blocksperen                ");
if (EC==0xAD) strcat(Fehler,"Blocksperre fehlgeschlagen         ");
if (EC==0xB0) strcat(Fehler,"nur noch kleinere UMBs verfügbar   ");
if (EC==0xB1) strcat(Fehler,"kein UMB verfügbar                 ");
if (EC==0xB2) strcat(Fehler,"ungültiges UMB Segment             ");
}


//Print Funktion fr schreibfaule!
//-------------------------------------------------------------------------


void print(int XPx , int XPy,int XPc,long XPt)
{
gotoxy(XPx, XPy);
textcolor(XPc);
char MXct[33];
ltoa(XPt,MXct,10);
cprintf(MXct);
}


void print(int XPx , int XPy,int XPc,char XPt[80])
{
gotoxy(XPx, XPy);
textcolor(XPc);
cprintf(XPt);
}


//######################################################################################


unsigned char     XMScheck=0;    //XMS verfgbar (80h = OK)
char         XMSvec[4];    //Adresse XMS-Handler
unsigned int     XMStest=0;    //Antwort bei anfragen
unsigned char     XMSfehler=0;    //Ablage fr Fehler
unsigned int    XMShandle=0;    //XMS-Handle fr einen angeforderten Speicherblock

unsigned int     XMSfree=0;//XMS-Frei
unsigned int     XMSbblock=0;//gr”sster verfgbarer XMS Block an einem Stck


char    test1[8]="erste111";
char    test2[8]="zweite22";

unsigned char ch=0;



//######################################################################################








int main(void)

{



clrscr();





//prfen ob XMS-Treiber installiert
asm{
    mov ax,4300h;
    int 2fh;
    //al=80h (128) = Treiber OK
    mov XMScheck,al;
}
//INFO >>
print(1,2,8,"XMS treober aktiv (128 / 0x80 = OK) :");
print(40,2,7,XMScheck);





//XMS Handler Adresse erfragen
asm{
    mov ax,4310h;
    int 2fh;
    //
    mov word ptr XMSvec,bx;
    mov word ptr XMSvec +2,es;
}
//INFO Adresse >>
print(1,3,8,"XMS Adresse                         :");
print(40,3,7,XMSvec);





//XMS freien speicher abfragen
    asm{
        mov ah    ,8;
        call XMSvec;        //anfordern
        mov XMSfree    ,dx;    //verfgbarer XMS in Kbytes
        mov XMSbblock    ,ax;    //gr”sster noch freier zusammenh„ngender XMS-Block
    }
//INFO Freier Speicher/Bl”cke
print(1,5,8,"XMS freier speicher");
print(21,5,7,XMSfree);
print(30,5,8,"XMS gr”sster Block");
print(49,5,7,XMSbblock);












//XMS Allocate Memory
unsigned int kbytes=1000;//KB anfragen
asm{
    mov dx    ,kbytes;        //ben”tigte Gr”sse
    mov ah    ,9;
    call XMSvec;        //anfordern
    mov XMStest    ,ax;    //1=OK / 0=Fehler
    mov XMShandle    ,dx;    //zurckgegebener Handle fr den angefragten XMS-Speicher
    mov XMSfehler    ,bl;    //Fehlermeldung 160=kein speicher frei!
    }
//INFO Block reservieren
print(1,7,8,"XMS reservieren");

print(1,7,8,"XMS 1=OK/0=Fehler");
print(19,7,7,XMStest);
print(30,7,8,"XMS Fehlercode");
print(45,7,7,XMSfehler);
print(60,7,8,"XMS Handle");
print(71,7,7,XMShandle);
//
fehler(XMSfehler);
print(1,8,14,Fehler);












Anfang:
print(1,1,8,"XMS-TEST-004");
print(20,1,8,test1);
print(30,1,8,test2);

ch=getch();
if (ch==0) ch=getch()+128;











//kopieren XMS > X
if (ch=='7'){

unsigned int XMSl_L=8;
unsigned int XMSl_H=0;

asm{
//L„nge gerade Zahl!!
    mov     ax,XMSl_L;
    mov     [si]       ,ax        ;
    mov     ax,XMSl_H;
    mov        2[si]       ,ax        ;
//QUELLE
    mov ax,XMShandle;
    mov word ptr  4[si],ax        ;
    mov word ptr  6[si],offset 0    ;
    mov word ptr  8[si],seg 0    ;
//ZIEL
    mov word ptr 10[si],0        ;
    mov word ptr 12[si],offset &test2;
    mov word ptr 14[si],seg &test2    ;
//Funktion / Aufruf
    mov ah,0Bh;
    call    XMSvec            ;

    mov XMStest,ax            ;//1=OK
    mov XMSfehler,bl         ;//Fehlermeldung 160=kein speicher frei!
}

fehler(XMSfehler);
print(1,12,14,"X > XMS");
print(9,12,12,XMSfehler);
print(30,12,14,"AX1=OK");
print(39,12,14,XMStest);
print(1,13,14,Fehler);
}










//kopieren X > XMS
if (ch=='6'){

unsigned int XMSl_L=8;
unsigned int XMSl_H=0;

asm{
//L„nge gerade Zahl!!
    mov     ax,XMSl_L        ;
    mov     [si]         ,ax        ;
    mov     ax,XMSl_H        ;
    mov        2[si]       ,ax        ;
//QUELLE
    mov word ptr  4[si],0        ;
    mov word ptr  6[si],offset &test1;
    mov word ptr  8[si],seg &test1    ;
//ZIEL
    mov ax,XMShandle
    mov word ptr 10[si],ax        ;
    mov word ptr 12[si],offset 0    ;
    mov word ptr 14[si],seg 0    ;
//Funktion / Aufruf
    mov ah,0Bh;
    call    XMSvec            ;

    mov XMStest,ax            ;//1=OK
    mov XMSfehler,bl         ;//Fehlermeldung 160=kein speicher frei!
}

fehler(XMSfehler);
print(1,12,14,"X > XMS");
print(9,12,12,XMSfehler);
print(30,12,14,"AX1=OK");
print(39,12,14,XMStest);
print(1,13,14,Fehler);
}










if (ch!=27) goto Anfang;







//XMS Handle frei geben
if (XMShandle>0){
    asm{
        mov dx        ,XMShandle;//Handle welches frei gegeben werden soll
        mov ah        ,0Ah
        call XMSvec;
    }
//INFO Block freigeben
print(1,9,4,"XMS Handle frei gegeben");
print(25,9,12,XMSbblock);

if (XMShandle>0) XMShandle--;
}









clrscr();
print(1,1,7,"Beendet");
return 0;
}

Alles anzeigen

Markus · 28. März 2024

es macht noch nicht so ganz was es soll, die Rückmeldungen sind komisch. Bin aber jetzt auch zu verpennt um das fertig zu machen.

Markus · 28. März 2024

Hier diese Seite geht ganz gut auf das wesentliche ein. Ich denke das für die meisten Programme relevante wird erklärt.

Professionell programmieren – Computerartikel-Archiv

guru-home.dyndns.org

Bisher kann ich Speicher an einen Handler binden/reservieren, diesen wieder freigeben und schauen wieviel Speicher frei ist und wie grosß der größte Speicherblock an einem Stück ist.

@root ...denke auch 2x Dosbox ist am einfachsten auf dem neuen. Beim 386 werde ich einfach Borland beenden, wobei ich dort seltener den Compiler anwerfe.

Oder ich muss tricksen, Speicher reservieren, Compiler starten und welchen frei geben. Die Kiste hat 16MB Simms, eventuell funktioniert das auch.

Markus · 28. März 2024

von root kommt ja bald was zum Thema EMS, ich habe jetzt angefangen das Thema XMS ab zu arbeiten.

über einen Adress Call wird hier gearbeitet um im Speicher zu "basteln". Ich denke es sollte also schneller wie mit Interrupt arbeiten.

Muss ich aber noch alles auf dem 3er testen.

so habe angefangen ein Beispiel für XMS zu schreiben.

in der >Main< werden schon alle Funktionen zum arbeiten mit XMS behandelt.

Interessant hierbei, Borland C++ 3.1 reserviert sich den kompletten Speicher!!!!! Man muss also zur Ausführung den Compiler beenden und dann das Programm öffnen, ansonsten wird halt immer gemeckert das kein Speicher verfügbar ist.

Ist alles noch was Chaotisch da es nur ein Test ist.

Code

//prfen ob XMS-Treiber installiert
if (ch=='1'){
    asm{
        mov ax,4300h;
        int 2fh;
        //al=80h (128) = Treiber OK
        mov XMScheck,al;
    }
}





//XMS Handler Adresse erfragen
if (ch=='2'){
    asm{
//xmsvec dd ?
        mov ax,4310h;
        int 2fh;
        //
        mov word ptr XMSvec,bx;
        mov word ptr XMSvec +2,es;
    }
}





//XMS Allocate Memory "Handle reservieren"
if (ch=='3'){

unsigned int kbytes=10;//KB anfragen
    asm{
        mov dx    ,kbytes;        //ben”tigte Gr”sse
        mov ah    ,9;
        call XMSvec;        //anfordern
        mov XMStest    ,ax;    //1=OK / 0=Fehler

        mov XMShandle    ,dx;    //zurckgegebener Handle fr den angefragten XMS-Speicher

        mov XMSfehler    ,bl;    //Fehlermeldung 160=kein speicher frei!
    }
}


//XMS freien speicher abfragen
if (ch=='4'){
    asm{
        mov ah    ,8;
        call XMSvec;        //anfordern
        mov XMSfree    ,dx;    //verfgbarer XMS in Kbytes
        mov XMSbblock    ,ax;    //gr”sster noch freier zusammenh„ngender XMS-Block
    }
}



//XMS Handle frei geben
if (ch=='5'){
    asm{
        mov dx        ,XMShandle;//Handle welches frei gegeben werden soll
        mov ah        ,0Ah
        call XMSvec;
    }
}

Alles anzeigen

C

#include <conio.h>
#include <stdlib.h>
#include <string.h>
#include <iostream.h>
#include <stdio.h>
#include <dos.h>
//-------------------------------------------------------------------------






//-------------------------------------------------------------------------






void print(int XPx , int XPy,int XPc,long XPt)
{
gotoxy(XPx, XPy);
textcolor(XPc);
char MXct[33];
ltoa(XPt,MXct,10);
cprintf(MXct);
}


void print(int XPx , int XPy,int XPc,char XPt[80])
{
gotoxy(XPx, XPy);
textcolor(XPc);
cprintf(XPt);
}










char C_text[40];//Text (39 Zeichen!!!!)
unsigned char C_typ;//Text (39 Zeichen!!!!)
unsigned char C_ziel;//Text (39 Zeichen!!!!)
unsigned char C_id;//Text (39 Zeichen!!!!)





char Dia_text[64][16][40];//Text (39 Zeichen!!!!)
unsigned char Dia_typ[64][16];//Text (39 Zeichen!!!!)
unsigned char Dia_ziel[64][16];//Text (39 Zeichen!!!!)
unsigned char Dia_id[64][16];//Text (39 Zeichen!!!!)

unsigned char Bl=0;
unsigned char Ze=0;

unsigned char tabX;
unsigned char tabY=0;//Zeile darstellung

unsigned char ch=0;


unsigned char CuX=0;
unsigned char CuY=0;









void DATAreset(){

Ze=0;
Bl=0;

do{

    do{

    Dia_typ [Bl][Ze]=0;
    Dia_ziel[Bl][Ze]=0;
    Dia_id  [Bl][Ze]=0;
    strcpy (Dia_text[Bl][Ze],"");

        Ze++;
    } while(Ze<16);
Ze=0;
Bl++;
} while(Bl<64);

Bl=0;
Ze=0;

}

















//############################ MXprintc(x,y,Color,"Char-Array") #############################
int input(int MXx , int MXy,int MXcolor,char MXc[41],char MXmax){

unsigned char Zeichen;
unsigned char oZeichen;

unsigned char ch;

char MXc2[2]="  ";
MXc2[1]=0;
Zeichen=0;
oZeichen=0;
ch=0;

char MXpage=0;

print(MXx,MXy,MXcolor,MXc);
gotoxy(MXx+Zeichen,MXy);

do
{
//tasteneingabe >>>>>
if (kbhit() )
{


ch=getche();

    // Return > beenden
    if (ch==13) return(13);

    // Escape > beenden
    if (ch==27) return(27);

    // Zeichen Eingabe ASCII 32-175
    if (ch>=32 && ch<=175 &&  Zeichen<MXmax)
    {
    //Zeichen aufschieben>>>>>
    unsigned char MXinput=MXmax-1;
    do{
    MXc[MXinput]=MXc[MXinput-1];
    MXinput=MXinput-1; //=MXmax-1;
    }while (MXinput>Zeichen);
    //<<<<<

    MXc[Zeichen]=ch;
    Zeichen++;
    }

    // <-
    if (ch ==8 && Zeichen>0)
    {

    Zeichen=Zeichen-1;
    //Zeichen < nachrcken>>>>>
    unsigned char MXinput=Zeichen;
    do{
    MXc[MXinput]=MXc[MXinput+1];
    MXinput=MXinput+1; //=MXmax-1;
    }while (MXinput<MXmax);
    MXc[MXmax]=0;
    //<<<<<
    }

//Sonderzeichen folgt>>>>>
if (ch ==0)
{
    //Folgezeichen
    ch=getche();


    //Entf |<<
    if (ch ==83 && Zeichen<MXmax)
    {

    //Zeichen < nachrcken>>>>>
    unsigned char MXinput=Zeichen;
    do{
    MXc[MXinput]=MXc[MXinput+1];
    MXinput=MXinput+1; //=MXmax-1;
    }while (MXinput<MXmax);
    MXc[MXmax]=0;
    //<<<<<
    }

    //Cursor <
    if (ch =='K' && Zeichen>0)
    {
    Zeichen=Zeichen-1;
    }

    //Cursoe >
    if (ch =='M' && Zeichen<MXmax)
    {
    if (MXc[Zeichen]>0) Zeichen=Zeichen+1;
    }

    //springen Pos1
    if (ch ==71)
    {
    Zeichen=0;
    }

    //springen Ende text
    if (ch ==79)
    {
    do{
    Zeichen++; //=MXmax-1;
    }while (MXc[Zeichen]>0 && Zeichen<MXmax);
    }


}
//<<<<<

print(MXx,MXy,MXcolor,"                                         ");
print(MXx,MXy,MXcolor,MXc);
gotoxy(MXx+Zeichen,MXy);
if (Zeichen<MXmax+1)

{
//MXline((MXx<<2)+((Zeichen)<<3),MXy+8+MXpage+200,(MXx<<2)+((Zeichen)<<3)+6,MXy+8+MXpage+200,MXcolor);
}

if (oZeichen !=Zeichen && oZeichen < MXmax+1)
{
//MXline((MXx<<2)+((oZeichen)<<3),MXy+8+MXpage+200,(MXx<<2)+((oZeichen)<<3)+6,MXy+8+MXpage+200,MXcolor2);
}
oZeichen=Zeichen;
}

} while(ch != '13');
}
//<<<<<





















unsigned char     XMScheck=0;    //XMS verfgbar (80h = OK)
char         XMSvec[4];    //Adresse XMS-Handler
unsigned int     XMStest=0;    //Antwort bei anfragen
unsigned char     XMSfehler=0;    //Ablage fr Fehler
unsigned int    XMShandle=0;    //XMS-Handle fr einen angeforderten Speicherblock

unsigned int     XMSfree=0;//XMS-Frei
unsigned int     XMSbblock=0;//gr”sster verfgbarer XMS Block an einem Stck



//######################################################################################

int main(void)

{




Anfang:
clrscr();
CLSAnfang:

//prfen ob Treiber geladen
print(1,2,8,"1=XMS Prfen");
print(20,2,8,XMScheck);

//Handler erfragt
print(1,3,8,"2=XMS Handler");
print(20,3,8,XMSvec);


//Anfrage
print(1,4,8,"3=XMS Anfrage");
print(20,4,8,XMStest);
print(30,4,8,XMSfehler);
print(40,4,8,XMShandle);


//verfgbarer speicher
print(1,5,8,"4=XMS verfgbar");
print(20,5,8,XMSfree);
print(30,5,8,XMSbblock);


//verfgbarer speicher
print(1,5,8,"5=XMS Handle freigeben");






ch=getch();
if (ch==0) ch=getch()+128;


//prfen ob XMS-Treiber installiert
if (ch=='1'){
    asm{
        mov ax,4300h;
        int 2fh;
        //al=80h (128) = Treiber OK
        mov XMScheck,al;
    }
}





//XMS Handler Adresse erfragen
if (ch=='2'){
    asm{
//xmsvec dd ?
        mov ax,4310h;
        int 2fh;
        //
        mov word ptr XMSvec,bx;
        mov word ptr XMSvec +2,es;
    }
}





//XMS Allocate Memory "Handle reservieren"
if (ch=='3'){

unsigned int kbytes=10;//KB anfragen
    asm{
        mov dx    ,kbytes;        //ben”tigte Gr”sse
        mov ah    ,9;
        call XMSvec;        //anfordern
        mov XMStest    ,ax;    //1=OK / 0=Fehler

        mov XMShandle    ,dx;    //zurckgegebener Handle fr den angefragten XMS-Speicher

        mov XMSfehler    ,bl;    //Fehlermeldung 160=kein speicher frei!
    }
}


//XMS freien speicher abfragen
if (ch=='4'){
    asm{
        mov ah    ,8;
        call XMSvec;        //anfordern
        mov XMSfree    ,dx;    //verfgbarer XMS in Kbytes
        mov XMSbblock    ,ax;    //gr”sster noch freier zusammenh„ngender XMS-Block
    }
}



//XMS Handle frei geben
if (ch=='5'){
    asm{
        mov dx        ,XMShandle;//Handle welches frei gegeben werden soll
        mov ah        ,0Ah
        call XMSvec;
    }
}




//if (ch=='n'){
//gotoxy(1, 20);
//cin>>Dia_text[Bl][Ze];
//}





if (ch!=27) goto Anfang;


clrscr();
print(25,10,12,"Programm Beenden (ESC) (ENTER)?");

if (input(1,14,1,"",0)!=13) goto Anfang;

clrscr();
print(1,1,7,"Cu");


   return 0;
}

Alles anzeigen

Markus · 28. März 2024

Der Schiebeschalter ist der Umschalter Grafikkarte.

Das war der schnellste IBM bis zu den PS/2 Rechnern. CPU hatte 6MHZ war damit zwar etwas langsamer wie die letzte AT Board REV, aber der Ram ist schneller, der hat keine Waitstate wie beim AT.

Dadurch ist der Rechner schneller wie der AT.

Darüber hinaus ist das Board schon was kompakter und das erste IBM welches SIMM Sockel hat.

Ich vermute hier passen nur die Originalen IBM Simms rein, beide meiner Boards haben diese Bestückt. es handelt sich um 2x256KB Module.

Auf dem Board sind auch nochmal 128 KB Ausserhalb der Sockel, diese lassen sich wohl über Jumper deaktivieren.

Vermutlich falls es Konflikte mit Erweiterungskarten gibt, die AT Erweiterungskarten Adressieren ja ab 512KB und der XT286 hat 640kb!

Das ganze ist auf der Seite hier gut dokumentiert.

minuszerodegrees.net

[Blockierte Grafik: https://www.minuszerodegrees.net/5162/motherboard/5162_motherboard_ram_location.png]

Markus · 27. März 2024

Zitat von Stefan307

Markus original AT mit SIMM Modulen?! Sehe ich zum ersten mal...

Das ist das IBM XT 286 Board (5162), also schon etwas flotter wie der AT.

Markus · 27. März 2024

Mal ein etwas unkomplizierterer IBM wie die PS/2 Kisten.

Ich habe zwar einen kompletten funktionierenden, aber da die Dinger ja recht schwer zu bekommen sind konnte ich nicht nein zu einem ersatz Board sagen.

Wenn ich irgendwann meine 386 Spiel Engine fertig kriegen sollte, muss ich auch mal Programme für die alten IBM's machen. Man hat viel zu wenig Zeit.

Markus · 26. März 2024

neue 3D Karten.

1x klassiker Elsa TNT2 Pro.

1x Bansheeeee...konnte ich grad nur unter DOS kurz testen... der andere Testrechner hatte keinen AGP Slot frei.

1x Voodoo 1

lief im Testsystem relativ flott.

Mein Highscreen Minitower war der Testrechner für die Voodoo 1 unter DOS Tombraider 1... 30FPS ist ganz ok für einen 486 DX2-66

Leider haben alle Karten super laute Lüfter werde die wohl alle tauschen müssen... nur wogegen.

Markus · 26. März 2024

Respekt schaut aus wie neu!

Markus · 26. März 2024

Ein Laufwerk im 65SX würde mir reichen, da will irgendwie nichts drin funktionieren.

Markus · 25. März 2024

das sind ja ziemlich "moderne" 386 Boards, 386/486 gab es einige gemeinsame Chipsätze.

Das Board wird vermutlich auch die 486DLC's annehmen.

Markus · 23. März 2024

funktioniert die ISA USB eigentlich unter Windows 9x. habe das noch nie getestet.

Markus · 23. März 2024

auf der CD sind die Beispiele und eine 300MB Datei... die ist vermutlich gepackt und die Daten sind nur über ein Programm auf der CD zugänglich.

Ich werde das mal auf einem kleinen Rechner, mit CD installieren und dann mal schauen ob da noch was ist.

Wenn ich die CD hoch geladen habe gebe ich hier noch den Link durch.

weg über den Fluss suchen

....

Theke ... saufen ... !

Markus · 23. März 2024

...muss mich dann da mal registrieren, das nerft überall registrieren.

Markus · 23. März 2024

Zitat von Stefan307

Würde das evtl helfen? Dann blättere ich mal nach, ist aus diesem Buch.

PC intern >>>4<<< behandelt das Thema nicht mehr im Buch. Wenn das dort beschrieben wird wäre das nützlich.

(4 fehlte)

Markus · 23. März 2024

311mb wie schick ich dir das image jetzt?

Markus · 23. März 2024

was mich wundert ist das das Board mit Bios von 1993 noch einen Weitek Sockel hat, die waren typischerweise nur bei älteren Boards mit 1x Multi sinvoll. 1993 war DX2 und VLB schon verbreitet.

Markus · 23. März 2024

Zitat von mac-daniel

Zitat von Markus

Voodoo 3 finde ich nicht mehr so interessant, was eine Voodoo 3 braucht, läuft auch fast immer auf meiner TNT2 Pro oder Geforce.

Bei mir genau andersrum, V3 ist quasi identisch mit V2 SLI, man hat dann aber nur eine statt 3 Karten im System und auch einen super 2D Teil.

Sollte ja auch nicht abwertend der V3 gegenüber sein jetzt.

V1 V2 finde ich halt wegen der DOS Titel so interessant, waren damals halt die ersten verbreiteten Karten.

Neuere Spiele waren dann ja später alle Direct 3D / Open GL / Windows da gibt es schon massig verschiedene brauchbare Karten für.

Aber unter Dos war das halt noch was besonderes ...und eventuell kann ich ja irgendwann mal was drauf programmieren... wenn ich nicht zu blöd dafür bin.

habe auch noch eine "Nummer 9" hier, so aus interessa an frühen 3D Karten.

Markus · 23. März 2024

Ich arbeite momentan wieder was mehr mit Borland c++ 3.1, DOS war schon manchmal anstrengend damals. Heute da man es nur als Hobby betreibt sieht man es alles etwas gelassener und man kann ja auch einfach auf dem Rechner arbeiten der schnell genug ist für das was man vor hat.

Man versteht gleich viel mehr warum damals die Programme so waren wie sie waren und welche Systeme welche Schwachpunkte hatten.

....Leider hat man immer viel zu wenig Zeit um dran bleiben zu können.

Den 386DX als ersten 32Bit Prozessor fand ich immer sehr interessant.

Markus · 23. März 2024

Dann hat vermutlich der Vorbesitzer die ganzen Co Prozessoren ausgebaut und separat verkauft, weil sonst wären die ja nicht darauf beide eingestellt.

Wobei die Co Prozessoren bis zum 486 auch nur selten verwendet wurden.

Als Programmierer versucht man Berechnungen die den Co Prozessor verwenden möglichst zu umgehen, weil diese selbst mit Co Prozessor ziemlich viel Leistung fressen.

Beiträge von Markus

Mode X und EGA Parrallax

Mode X und EGA Parrallax

Mode X und EGA Parrallax

Mode X und EGA Parrallax

Ich habe folgende Retro Hardware bekommen Thread!

Ich habe folgende Retro Hardware bekommen Thread!

Ich habe folgende Retro Hardware bekommen Thread!

Ich habe folgende Retro Hardware bekommen Thread!

Was habt ihr heute so gebastelt?

Diskussion/Erforschung externe 5,25"-Diskettenlaufwerke

386DX-40 hängt sich auf

Kleine Fragen erfordern kleine Antworten! [Hardware]

Mode X und EGA Parrallax

S: CD Image von PC Intern 4.0 DEUTSCH

Mode X und EGA Parrallax

S: CD Image von PC Intern 4.0 DEUTSCH

486er streikt ab der 2. ISA Karte

Ich habe folgende Retro Hardware bekommen Thread!

386DX-40 hängt sich auf

386DX-40 hängt sich auf