[VC++] LPT1 poort adres uit register halen.

[Verwijderd]

Ik ben bezig om een programma te maken om een printer aan te sturen in Visual C++. Nu wil ik het adres van de LPT1 poort opvragen uit het register (of uit de bois).

Kan dit?
En hoe moet dit? (Of waar kan het adres vinden)

[Verwijderd]

Op donderdag 28 februari 2002 09:37 schreef bmx_grover het volgende:
Kan dit?

Natuurlijk kan dat, maar waarom zou je het willen? direct hardware aansturen wordt zowiezo al niet gewaardeerd onder windows(NT) kan je niet gewoon beter een printerdriver schrijven met behulp van de ddk?

En hoe moet dit? (Of waar kan het adres vinden)

Uit Jan's Parallel Port FAQ:

code:

#define TEST_WINDOWS_NT (!(GetVersion() & 0x80000000))

int GetParallelControllerKey(char *parKey)
{
    HKEY hKey;
    char myData[255];
    LONG res;
    DWORD mySize;
    FILETIME ftLastWriteTime;
    
    if (NULL==parKey)
        return(-1);
    
    *parKey=0;
    
    char myKey[255];
    sprintf(myKey,"HARDWARE\\DESCRIPTION\\System");
    
    res = RegOpenKeyEx(HKEY_LOCAL_MACHINE,myKey, 0, KEY_READ, &hKey);
    
    if (res!=ERROR_SUCCESS)
        return(-1);
    
    DWORD dwIndex1;
    char myKey1[255];
    for (dwIndex1=0;dwIndex1<=10;dwIndex1++)
    {
        mySize=sizeof(myData);
        res = 
            RegEnumKeyEx(hKey,dwIndex1,myData,&mySize,NULL,NULL,NULL,&ftLastWriteTime);
        
        if (res==ERROR_SUCCESS) // ERROR_SUCCESS 1
        {
            strcpy(myKey1,myKey);
            strcat(myKey1,"\\");
            strcat(myKey1,myData);
            
            HKEY hKey1;
            res = RegOpenKeyEx(HKEY_LOCAL_MACHINE,myKey1, 0, KEY_READ, 
                &hKey1);
            
            if (res!=ERROR_SUCCESS)
                return(-1);
            
            DWORD dwIndex2;
            char myKey2[255];
            for (dwIndex2=0;dwIndex2<=10;dwIndex2++)
            {
                mySize=sizeof(myData);
                res = 
                    RegEnumKeyEx(hKey1,dwIndex2,myData,&mySize,NULL,NULL,NULL,&ftLastWriteTime);
                
                if (res==ERROR_SUCCESS) // ERROR_SUCCESS 2
                {
                    strcpy(myKey2,myKey1);
                    strcat(myKey2,"\\");
                    strcat(myKey2,myData);
                    
                    HKEY hKey2;
                    res = 
                        RegOpenKeyEx(HKEY_LOCAL_MACHINE,myKey2, 0, KEY_READ, &hKey2);
                    
                    if (res!=ERROR_SUCCESS)
                        return(-1);
                    
                    DWORD dwIndex3;
                    for (dwIndex3=0;dwIndex3<=10;dwIndex3++)
                    {
                        mySize=sizeof(myData);
                        res = 
                            RegEnumKeyEx(hKey2,dwIndex3,myData,&mySize,NULL,NULL,NULL,&ftLastWriteTime);
                        
                        if (res==ERROR_SUCCESS) // ERROR_SUCCESS 3
                        {
                            if 
                                (0==strcmp(myData,"ParallelController") )
                            {
                                
                                strcpy(parKey,myKey2);
                                
                                strcat(parKey,"\\");
                                
                                strcat(parKey,myData);
                                return(0);
                            }
                        } // ERROR_SUCCESS 3
                        
                    } // for (dwIndex3
                    
                } // // ERROR_SUCCESS 2
                
            } // for (dwIndex2
            
        } // ERROR_SUCCESS 1
        
    } // for (dwIndex1
    
    return(-1);
} //GetParallelControllerKey 


int GetAddressLptPortInTheRegistry(int myPort)
{
    HKEY phkResult;
    char myKey[255];
    char myData[255];
    LONG res;
    DWORD mySize;
    DWORD myType;
    
    res=GetParallelControllerKey(myKey);
    if (res < 0)
        return(-1);
    
    sprintf(myData,"%s\\%d",myKey,myPort-1);
    
    res = RegOpenKeyEx(HKEY_LOCAL_MACHINE,myData, 0, KEY_READ, 
        &phkResult);
    if (res != ERROR_SUCCESS)
        return(-1);
    
    mySize=sizeof(myData);
    myType=REG_BINARY;
    
    res=RegQueryValueEx(
        phkResult, // handle to key to query
        "Configuration Data", // address of name of value to query
        NULL, // reserved
        &myType, // address of buffer for value type
        (unsigned char *)myData, // address of data buffer
        &mySize // address of data buffer size
        );
    if (res != ERROR_SUCCESS)
        return(-1);
    
    //printf("config data port %d 0x14 = 0x%02X 0x15 = 0x%02X\n",myPort,myData[0x14],myData[0x15]);
    return(myData[0x14] | myData[0x15]<<8 );
}

typedef BOOL (CALLBACK * PROCTYPE_Toolhelp32ReadProcessMemory)
( DWORD , LPCVOID, LPVOID, DWORD ,LPDWORD);

int GetAddressLptPortInTheMemory(int myPort)
{
    HINSTANCE hDLL=NULL; // Handle to DLL
    PROCTYPE_Toolhelp32ReadProcessMemory myProcPointer=NULL;
    
    hDLL = LoadLibrary("kernel32");
    if (hDLL==NULL)
        return(-1);
    
    myProcPointer=(PROCTYPE_Toolhelp32ReadProcessMemory)GetProcAddress(hDLL,"Toolhelp32ReadProcessMemory");
    if (myProcPointer==NULL) /*handle the error*/
    { 
        FreeLibrary(hDLL); 
        return -1;
    }
    
    int portAddresses[]={0,0,0,0,0};
    BOOL rtn=0;
    DWORD cbLen=0;
    //rtn = Toolhelp32ReadProcessMemory 
    rtn = myProcPointer
        (0,
        (LPCVOID *) 0x408,
        portAddresses,
        8,
        NULL) ;
    
    FreeLibrary(hDLL); 
    
    if (rtn==0)
        return(-1);
    
    if (portAddresses[myPort-1]<=0)
        return(-1);
    
    if (portAddresses[myPort-1]>=0x1000)
        return(-1);
    
    return(portAddresses[myPort-1]);
}

int GetAddressLptPort(int myPort)
{
    if(myPort<1)
        return(-1);
    
    if(myPort>3)
        return(-1);
    
    if (TEST_WINDOWS_NT)
        return(GetAddressLptPortInTheRegistry(myPort));
    else
        return(GetAddressLptPortInTheMemory(myPort));
}

[Verwijderd]

Op donderdag 28 februari 2002 10:11 schreef Yarvieh het volgende:
Natuurlijk kan dat, maar waarom zou je het willen? direct hardware aansturen wordt zowiezo al niet gewaardeerd onder windows(NT) kan je niet gewoon beter een printerdriver schrijven met behulp van de ddk?

Dit wil ik omdat ik een applicatie maak die op een Matrix printer bepaalde acties wegscrijft. En als de applicatie zou crashen of zo, dan is de actie wel weg geschreven.

Bedankt voor de code.

[farlane]

Kun je niet beter de standaard LPT driver gebruiken en met CreateFile/Write informatie versturen?

Waarom wil je de IO op die manier direct benaderen? (Onder Win2k gaat dit iig niet meer werken namelijk)

[Verwijderd]

Ik wil dus niet hele pagina's printen maar telkens 1 regel, en volgens mij gaat het zo op een simple manier.

En wat ik geimplementeerd heb dat draaid ook onder W2K.

[Verwijderd]

De bovenstaande code werkt perfect onder windows NT 2000 en windows XP.
Maar ik krijg het niet aan de praat onder windows98SE.
In de functie "GetAddressLptPortInTheMemory" gaat hij bij de laatste if er uit.

Iemand die dit wel werkend heeft gekregen onder Windows 9x?

[Verwijderd]

Ik ben er al uit, ik wou het jullie even laten weten!

In de geheugen staat op adres 0x408 het adres van LPT1 op 0x40A staat LPT2, etc.
Van 0x408 naar 0x40A is 2 bytes.

code:

int portAddresses[]={0,0,0,0,0};

In het voorbeeld werden de waarden uit het geheugen in een int opgeslagen (4 bytes), als je nu dus een short int (of een WORD) gebruikt dan gaat het dus wel goed.

[farlane]

Op donderdag 28 februari 2002 22:12 schreef bmx_grover het volgende:
Ik wil dus niet hele pagina's printen maar telkens 1 regel, en volgens mij gaat het zo op een simple manier.

En wat ik geimplementeerd heb dat draaid ook onder W2K.

Een regel printen kan ook met een simpele string + cr + lf.

Als je inp/outp en kornuiten gebruikt gaat het echt niet werken, misschien als je een dosprog bent, maar niet als win32 app.

[Verwijderd]

De regel werdt niet direct geprint omdat buffering aan stond in windows NT.
Zo gauw als de buffer vol is dan word de regel wel geprint en ja ik doe dat met fprintf.

inp/outp dat werk niet onder NT/2000/XP dat weet ik wel, maar ik heb een kernel driver gevonden, waarmee het wel mogelijk is.