XProfan

XProfan X2
Win7 Home Premium, SP1, Core(TM)2 Duo E6750 @ 2.66GHz

cordial Regards!

where can because The DLL receive velvet Parameterdefinitionen?

the I on Parameterdefinition for _MPUSBOpen found have is:

dword,mem(64),mem(64),dword,dword: [...]

-

I faith You uses only mem(32)'er.

MPUSBOpen I get a "Zugriffsverletzung at Reading address...

In how far is these testimony ensured? I see the You 2x MPUSBOpen aufrufst -

make time vlt. behind each appeal a MessageBox.

09/10/11 ▲

Chregu
Mueller

does me sorrow, the were a little bit little indicated.
So I get already at first appeal of MPUSBOpen the two Zugriffsverletzungen:

thereafter fractures the program ex.
i'm I do not sure, where I which manner of variables use must. I give here time any founts on over The DLL, The I found have: [...]

here with Sprut have so did i my proposition nachgebaut: [...]

in the Download have so did i these File found, where The DDL on the präzisesten described is:

https://dl.XProfan.com/?annii/_mpusbapi.cpp.txt

Compile Mark Separation

/*********************************************************************
*
*                  MPUSBAPI Library Version 1.00
*
*********************************************************************
* FileName:        _mpusbapi.cpp
* Dependencies:    See #include section below.
* Compiler:        Borland C++ Builder 6
* Company:         Copyright (C) 2004 by Microchip Technology, Inc.
*
* Software License Agreement
*
* The software supplied herewith by Microchip Technology Incorporated
* (the “Company”) for its PICmicro® Microcontroller is intended and
* supplied to you, the Company’s customer, for use solely and
* exclusively on Microchip PICmicro Microcontroller products. The
* software is owned by the Company and/or its supplier, and is
* protected under applicable copyright laws. All rights are reserved.
* Any use in violation of the foregoing restrictions may subject the
* user to criminal sanctions under applicable laws, as well as to
* civil liability for the breach of the terms and conditions of this
* license.
*
* THIS SOFTWARE IS PROVIDED IN AN “AS IS” CONDITION. NO WARRANTIES,
* WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING, BUT NOT LIMITED
* TO, IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
* PARTICULAR PURPOSE APPLY TO THIS SOFTWARE. THE COMPANY SHALL NOT,
* IN ANY CIRCUMSTANCES, BE LIABLE FOR SPECIAL, INCIDENTAL OR
* CONSEQUENTIAL DAMAGES, FOR ANY REASON WHATSOEVER.
*
* Author               Date        Comment
*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
* Ross Fosler          9/2/04      Implemented MPUSBGetDeviceLink()
* Rawin Rojvanit       11/19/04    Original version 1.00 completed
********************************************************************/
#include <stdio.h>
#include <windows.h>
#include <string.h>
#include <setupapi.h>
#include <initguid.h>
#include <winioctl.h>
#include "ioctls.h"
#include "_mpusbapi.h"
#define MPUSBAPI_VERSION            0x00010000L
#define	MPUSB_DEV_NO_INFO           2
#define	MPUSB_DEV_INVALID_INST      3
#define	MPUSB_DEV_VIDPID_NOT_FOUND  4
#define MPUSB_DEV_NOT_ATTACHED      5
#pragma argsused
int WINAPI DllEntryPoint(HINSTANCE hinst, unsigned long reason, void* lpReserved)

{

    return 1;

}

///////////////////////////////////////////////////////////////////////////////
//	MPUSBGetDLLVersion : get mpusbapi.dll revision level
//
//	Input:
//		None
//	Output:
//		32-bit revision level MMMMmmmm
//
DWORD MPUSBGetDLLVersion(void)

{

    return MPUSBAPI_VERSION;

}//end MPUSBGetDLLVersion

///////////////////////////////////////////////////////////////////////////////
//	MPUSBIsVidPidEqual : Compares the pVID_PID string against the DeviceInstance
//  string retrieved from the registry using the DevicePath subkey.
//  This function should be called only from MPUSBGetDevicePath().
//
//  Note:
//  All Windows version has the DeviceClasses information stored in:
//  HKEY_LOCAL_MACHINE\\System\\CurrentControlSet\\Control\\DeviceClasses\\
//  {GUID_DEVINTERFACE_MCHPUSB}\\<DevicePath>
//  Win98SE,ME have different DevicePath string format from 2K,XP.
//  It does not contain vid&pid information in the DevicePath.
//  Thus necessitating the needs to check the DeviceInstance string in the
//  registry.
//
//	Note that "input" and "output" refer to the parameter designations in calls
//	to this function, which are the opposite of common sense from the
//	perspective of an application making the calls.
//
DWORD MPUSBIsVidPidEqual(PCHAR pDevicePath, PCHAR pVID_PID)

{

    DWORD dwResult = MPUSB_FAIL;
    char lszValue[255];
    char lpSubKey[512];
    HKEY hKey;
    LONG returnStatus;
    DWORD dwType=REG_SZ;
    DWORD dwSize=255;
    GUID guid = GUID_DEVINTERFACE_MCHPUSB;
    /* Modify DevicePath to use registry format */
    pDevicePath[0] ='#';
    pDevicePath[1] ='#';
    pDevicePath[3] ='#';
    /* Form SubKey */
    wsprintf(lpSubKey,
    "SYSTEM\\CURRENTCONTROLSET\\CONTROL\\DEVICECLASSES\\{%4.2x-%2.2x-%2.2x-%.2x%.2x-%.2x%.2x%.2x%.2x%.2x%.2x}\\%s",
    guid.Data1,guid.Data2,guid.Data3,guid.Data4[0],guid.Data4[1],guid.Data4[2],
    guid.Data4[3],guid.Data4[4],guid.Data4[5],guid.Data4[6],guid.Data4[7],pDevicePath);
    /* Open Key */
    returnStatus = RegOpenKeyEx(HKEY_LOCAL_MACHINE,
    lpSubKey,
    0L,
    KEY_ALL_ACCESS,
    &hKey);
    if(returnStatus == ERROR_SUCCESS)

    {

        returnStatus = RegQueryValueEx(hKey,
        "DeviceInstance",
        NULL,
        &dwType,
        (LPBYTE)&lszValue,
        &dwSize);
        if(returnStatus == ERROR_SUCCESS)

        {

            /*
            * The string info stored in 'DeviceInstance' is the same
            * across all Windows platforms: 98SE, ME, 2K, and XP.
            * Upper-case in 98SE,ME.
            * Converts all to lower-case anyway.
            */
            strlwr(lszValue);
            if(strstr(lszValue,pVID_PID) != NULL)

            {

                dwResult = MPUSB_SUCCESS;

            }

        }

    }

    RegCloseKey(hKey);
    /* Modify DevicePath to use the original format */
    pDevicePath[0] ='\\';
    pDevicePath[1] ='\\';
    pDevicePath[3] ='\\';
    return dwResult;

}//end

///////////////////////////////////////////////////////////////////////////////
//	MPUSBGetDeviceLink : Returns the path to device hardware with a given
//  instance number.
//
//	Note that "input" and "output" refer to the parameter designations in calls
//	to this function, which are the opposite of common sense from the
//	perspective of an application making the calls.
//
DWORD MPUSBGetDeviceLink(DWORD instance,// Input
PCHAR pVID_PID,// Input
PCHAR pPath,// Output
DWORD dwLen,// Input
PDWORD pLength)// Output

{

    if(pLength != NULL)*pLength = 0;// Initialization
    HDEVINFO info = SetupDiGetClassDevs((LPGUID)&GUID_DEVINTERFACE_MCHPUSB,
    NULL,
    NULL,
    DIGCF_PRESENT|DIGCF_DEVICEINTERFACE);
    if(info==INVALID_HANDLE_VALUE)

    {

        SetupDiDestroyDeviceInfoList(info);
        return MPUSB_DEV_NO_INFO;

    }// end if

    // Get interface data for the requested instance
    SP_DEVICE_INTERFACE_DATA intf_data;
    intf_data.cbSize = sizeof(SP_DEVICE_INTERFACE_DATA);
    if(!SetupDiEnumDeviceInterfaces(info,
    NULL,
    (LPGUID)&GUID_DEVINTERFACE_MCHPUSB,
    instance,
    &intf_data))

    {

        SetupDiDestroyDeviceInfoList(info);
        return MPUSB_DEV_INVALID_INST;

    }// end if

    // Get size of symbolic link
    DWORD ReqLen;
    SetupDiGetDeviceInterfaceDetail(info, &intf_data, NULL, 0, &ReqLen, NULL);
    PSP_DEVICE_INTERFACE_DETAIL_DATA intf_detail = \
    (PSP_DEVICE_INTERFACE_DETAIL_DATA)(new char[ReqLen]);
    if( intf_detail == NULL)

    {

        SetupDiDestroyDeviceInfoList(info);
        delete intf_detail;
        return MPUSB_DEV_NO_INFO;

    }// end if

    // Get symbolic link name
    intf_detail->cbSize = sizeof(SP_DEVICE_INTERFACE_DETAIL_DATA);
    // sizeof(SP_DEVICE_INTERFACE_DETAIL_DATA) should equals 5.
    // In C++ Builder, go to Project/Options/Advanced Compiler/Data Alignment
    // and select "byte" align.
    if(!SetupDiGetDeviceInterfaceDetail(info,
    &intf_data,
    intf_detail,
    ReqLen,
    NULL,
    NULL))

    {

        SetupDiDestroyDeviceInfoList(info);
        delete intf_detail;
        return MPUSB_DEV_NO_INFO;

    }// end if

    // Check for a valid VID&PID - if argument is not null)
    if(pVID_PID != NULL)

    {

        if(MPUSBIsVidPidEqual(intf_detail->DevicePath, pVID_PID) == NULL)

        {

            SetupDiDestroyDeviceInfoList(info);
            delete intf_detail;
            return MPUSB_DEV_VIDPID_NOT_FOUND;

        }// end if

    }// end if

    // Set the length of the path string
    if(pLength != NULL)
    *pLength = (DWORD)strlen(intf_detail->DevicePath);
    // Copy output string path to buffer pointed to by pPath
    if(pPath != NULL)

    {

        // Check that input buffer has enough room...
        // Use > not >= because strlen does not include null
        if(dwLen > strlen(intf_detail->DevicePath))
        strcpy(pPath, intf_detail->DevicePath);

    else

        {

            SetupDiDestroyDeviceInfoList(info);
            delete intf_detail;
            return MPUSB_FAIL;

        }// end if

    }// end if

    // Clean up
    SetupDiDestroyDeviceInfoList(info);
    delete intf_detail;
    return MPUSB_SUCCESS;

}// end MPUSBGetDeviceLink

///////////////////////////////////////////////////////////////////////////////
//	MPUSBGetDeviceCount : Returns the number of devices with matching VID & PID
//
//	Note that "input" and "output" refer to the parameter designations in calls
//	to this function, which are the opposite of common sense from the
//	perspective of an application making the calls.
//
DWORD MPUSBGetDeviceCount(PCHAR pVID_PID)

{

    DWORD count;// Number of USB device with matching VID & PID
    count = 0;// Initialization
    for(int i = 0; i < MAX_NUM_MPUSB_DEV; i++)

    {

        if(MPUSBGetDeviceLink(i,pVID_PID,NULL,NULL,NULL) == MPUSB_SUCCESS)
        count++;

    }//end for

    return count;

}//end MPUSBGetDeviceCount

///////////////////////////////////////////////////////////////////////////////
//	MPUSBOpen : Returns the handle to the endpoint pipe with matching VID & PID
//
//  All pipes are opened with the FILE_FLAG_OVERLAPPED attribute.
//  This allows MPUSBRead,MPUSBWrite, and MPUSBReadInt to have a time-out value.
//
//  Note: Time-out value has no meaning for Isochronous pipes.
//
//  instance - An instance number of the device to open.
//             Typical usage is to call MPUSBGetDeviceCount first to find out
//             how many instances there are.
//             It is important to understand that the driver is shared among
//             different devices. The number of devices returned by
//             MPUSBGetDeviceCount could be equal to or less than the number
//             of all the devices that are currently connected & using the
//             generic driver.
//
//             Example:
//             if there are 3 device with the following PID&VID connected:
//             Device Instance 0, VID 0x04d8, PID 0x0001
//             Device Instance 1, VID 0x04d8, PID 0x0002
//             Device Instance 2, VID 0x04d8, PID 0x0001
//
//             If the device of interest has VID = 0x04d8 and PID = 0x0002
//             Then MPUSBGetDeviceCount will only return '1'.
//             The calling function should have a mechanism that attempts
//             to call MPUSBOpen up to the absolute maximum of MAX_NUM_MPUSB_DEV
//             (MAX_NUM_MPUSB_DEV is defined in _mpusbapi.h).
//             It should also keep track of the number of successful calls
//             to MPUSBOpen(). Once the number of successes equals the
//             number returned by MPUSBGetDeviceCount, the attempts should
//             be aborted because there will no more devices with
//             a matching vid&pid left.
//
//  pVID_PID - A string containing the PID&VID value of the target device.
//             The format is "vid_xxxx&pid_yyyy". Where xxxx is the VID value
//             in hex and yyyy is the PID value in hex.
//             Example: If a device has the VID value of 0x04d8 and PID value
//                      of 0x000b, then the input string should be:
//                      "vid_04d8&pid_000b"
//
//  pEP      - A string of the endpoint number on the target endpoint to open.
//             The format is "\\MCHP_EPz". Where z is the endpoint number in
//             decimal.
//             Example: "\\MCHP_EP1"
//
//             This arguement can be NULL. A NULL value should be used to
//             create a handles for non-specific endpoint functions.
//             MPUSBRead, MPUSBWrite, MPUSBReadInt are endpoint specific
//             functions.
//             All others are not.
//             Non-specific endpoint functions will become available in the
//             next release of the DLL.
//
//             Note: To use MPUSBReadInt(), the format of pEP has to be
//                   "\\MCHP_EPz_ASYNC". This option is only available for
//                   an IN interrupt endpoint. A data pipe opened with the
//                   "_ASYNC" keyword would buffer the data at the interval
//                   specified in the endpoint descriptor upto the maximum of
//                   100 data sets. Any data received after the driver buffer
//                   is full will be ignored.
//                   The user application should call MPUSBReadInt() often
//                   enough so that the maximum limit of 100 is never reached.
//
//  dwDir    - Specifies the direction of the endpoint.
//             Use MP_READ for MPUSBRead, MPSUBReadInt
//             Use MP_WRITE for MPUSBWrite
//
//  dwReserved Future Use
//
//  Summary of transfer type usage:
//  ============================================================================
//  Transfer Type       Functions                       Time-Out Applicable?
//  ============================================================================
//  Interrupt - IN      MPUSBRead, MPUSBReadInt         Yes
//  Interrupt - OUT     MPUSBWrite                      Yes
//  Bulk - IN           MPUSBRead                       Yes
//  Bulk - OUT          MPUSBWrite                      Yes
//  Isochronous - IN    MPUSBRead                       No
//  Isochronous - OUT   MPUSBWrite                      No
//  ============================================================================
//
//	Note that "input" and "output" refer to the parameter designations in calls
//	to this function, which are the opposite of common sense from the
//	perspective of an application making the calls.
//
HANDLE MPUSBOpen(DWORD instance,// Input
PCHAR pVID_PID,// Input
PCHAR pEP,// Input
DWORD dwDir,// Input
DWORD dwReserved)// Input <Future Use>

{

    char path[MAX_PATH];
    DWORD dwReqLen;
    HANDLE handle;
    handle = INVALID_HANDLE_VALUE;
    // Check arguments first
    if((pVID_PID != NULL) && ((dwDir == MP_WRITE) || (dwDir == MP_READ)))

    {

        if(MPUSBGetDeviceLink(instance,pVID_PID,path,MAX_PATH,&dwReqLen)==\
        MPUSB_SUCCESS)

        {

            char path_io[MAX_PATH];
            strcpy(path_io,path);
            if(pEP != NULL) strcat(path_io,pEP);
            if(dwDir == MP_READ)

            {

                handle = CreateFile(path_io,
                GENERIC_READ,
                0,
                NULL,
                OPEN_EXISTING,
                FILE_ATTRIBUTE_NORMAL|FILE_FLAG_OVERLAPPED,
                NULL);

            }

        else

            {

                handle = CreateFile(path_io,
                GENERIC_WRITE,
                0,
                NULL,
                OPEN_EXISTING,
                FILE_ATTRIBUTE_NORMAL|FILE_FLAG_OVERLAPPED,
                NULL);

            }//end if

        }//end if

    }//end if

    return handle;

}//end MPUSBOpen(...)

///////////////////////////////////////////////////////////////////////////////
//	MPUSBGetDeviceDescriptor : Returns the Device Descriptor Data
//
//  **** INCOMPLETE ****
//
//	Note that "input" and "output" refer to the parameter designations in calls
//	to this function, which are the opposite of common sense from the
//	perspective of an application making the calls.
//
DWORD MPUSBGetDeviceDescriptor(HANDLE handle,// Input
PVOID pDevDsc,// Output
DWORD dwLen,// Input
PDWORD pLength)// Output

{

    GET_DESCRIPTOR_PARAMETER dscParam;
    if(pLength != NULL)*pLength = 0;
    //if(pDevDsc == NULL) return MPUSB_FAIL;
    dscParam.bType =  USB_DEVICE_DESCRIPTOR_TYPE;
    if(!DeviceIoControl(handle,
    IOCTL_MCHPUSB_GET_DESCRIPTOR,
    &dscParam,
    sizeof(GET_DESCRIPTOR_PARAMETER),
    pDevDsc,
    dwLen,
    pLength,
    NULL))

    {

        printf("Get dsc error: %d",GetLastError());
        return MPUSB_FAIL;

    }//end if

    return MPUSB_SUCCESS;

}// MPUSBGetDeviceDescriptor

//  **** INCOMPLETE ****
DWORD MPUSBGetConfigInfoSize(HANDLE handle)

{

    DWORD config_size;
    DWORD dwReqLen;
    DeviceIoControl(handle,
    IOCTL_MCHPUSB_GET_CONFIGURATION_INFO,
    NULL,
    0,
    &config_size,
    sizeof(DWORD),
    &dwReqLen,
    NULL);
    return config_size;

}//end MPUSBGetConfigInfoSize

//  **** INCOMPLETE ****
DWORD MPUSBGetConfigInfo(HANDLE handle,// Input
PVOID pData,// Output
DWORD dwLen)// Input

{

    DWORD dwReqLen;
    if(!DeviceIoControl(handle,
    IOCTL_MCHPUSB_GET_CONFIGURATION_INFO,
    NULL,
    0,
    pData,
    dwLen,
    &dwReqLen,
    NULL))

    {

        printf("Get config error: %d",GetLastError());
        return MPUSB_FAIL;

    }//end if

    return MPUSB_SUCCESS;

}//end MPUSBGetConfigInfo

//  **** INCOMPLETE ****
void MPUSBSendControl(void)

{

}

//  **** INCOMPLETE ****
void MPUSBGetControl(void)

{

}

///////////////////////////////////////////////////////////////////////////////
//	MPUSBRead :
//
//  handle  - Identifies the endpoint pipe to be read. The pipe handle must
//            have been created with MP_READ access attribute.
//
//  pData   - Points to the buffer that receives the data read from the pipe.
//
//  dwLen   - Specifies the number of bytes to be read from the pipe.
//
//  pLength - Points to the number of bytes read. MPUSBRead sets this value to
//            zero before doing any work or error checking.
//
//  dwMilliseconds
//          - Specifies the time-out interval, in milliseconds. The function
//            returns if the interval elapses, even if the operation is
//            incomplete. If dwMilliseconds is zero, the function tests the
//            data pipe and returns immediately. If dwMilliseconds is INFINITE,
//            the function's time-out interval never elapses.
//
//	Note that "input" and "output" refer to the parameter designations in calls
//	to this function, which are the opposite of common sense from the
//	perspective of an application making the calls.
//
DWORD MPUSBRead(HANDLE handle,// Input
PVOID pData,// Output
DWORD dwLen,// Input
PDWORD pLength,// Output
DWORD dwMilliseconds)// Input

{

    BOOL bResult;
    DWORD nBytesRead;
    OVERLAPPED gOverlapped;
    DWORD dwResult;
    dwResult = MPUSB_FAIL;
    // set up overlapped structure fields
    gOverlapped.Internal     = 0;
    gOverlapped.InternalHigh = 0;
    gOverlapped.Offset       = 0;
    gOverlapped.OffsetHigh   = 0;
    gOverlapped.hEvent       = CreateEvent(NULL, FALSE, FALSE, NULL);
    if(pLength != NULL)*pLength = 0;
    // attempt an asynchronous read operation
    bResult = ReadFile(handle,pData,dwLen,&nBytesRead,&gOverlapped);
    if(!bResult)

    {

        // deal with the error code
        switch (GetLastError())

        {

            case ERROR_HANDLE_EOF:

            {

                // we have reached the end of the file
                // during the call to ReadFile
                break;

            }

            case ERROR_IO_PENDING:

            {

                // asynchronous i/o is still in progress
                switch(WaitForSingleObject(gOverlapped.hEvent, dwMilliseconds))

                {

                    case WAIT_OBJECT_0:
                    // check on the results of the asynchronous read
                    // and update the nBytesRead...
                    bResult = GetOverlappedResult(handle, &gOverlapped,
                    &nBytesRead, FALSE);
                    if(!bResult)

                    {

                        printf("Error: %d", GetLastError());

                    }

                else

                    {

                        if(pLength != NULL)
                        *pLength = nBytesRead;
                        dwResult = MPUSB_SUCCESS;

                    }//end if else

                    break;
                    case WAIT_TIMEOUT:
                    CancelIo(handle);
                    break;
                    default:
                    CancelIo(handle);
                    break;

                }//end switch

            }//end case

            default:
            CancelIo(handle);
            break;

        }//end switch

    }

else

    {

        if(pLength != NULL)
        *pLength = nBytesRead;
        dwResult = MPUSB_SUCCESS;

    }//end if else

    ResetEvent(gOverlapped.hEvent);
    CloseHandle(gOverlapped.hEvent);
    return dwResult;

}//end MPUSBRead

///////////////////////////////////////////////////////////////////////////////
//	MPUSBWrite :
//
//  handle  - Identifies the endpoint pipe to be written to. The pipe handle
//            must have been created with MP_WRITE access attribute.
//
//  pData   - Points to the buffer containing the data to be written to the pipe.
//
//  dwLen   - Specifies the number of bytes to write to the pipe.
//
//  pLength - Points to the number of bytes written by this function call.
//            MPUSBWrite sets this value to zero before doing any work or
//            error checking.
//
//  dwMilliseconds
//          - Specifies the time-out interval, in milliseconds. The function
//            returns if the interval elapses, even if the operation is
//            incomplete. If dwMilliseconds is zero, the function tests the
//            data pipe and returns immediately. If dwMilliseconds is INFINITE,
//            the function's time-out interval never elapses.
//
//	Note that "input" and "output" refer to the parameter designations in calls
//	to this function, which are the opposite of common sense from the
//	perspective of an application making the calls.
//
DWORD MPUSBWrite(HANDLE handle,// Input
PVOID pData,// Input
DWORD dwLen,// Input
PDWORD pLength,// Output
DWORD dwMilliseconds)// Input

{

    BOOL bResult;
    DWORD nBytesWritten;
    OVERLAPPED gOverlapped;
    DWORD dwResult;
    dwResult = MPUSB_FAIL;
    // set up overlapped structure fields
    gOverlapped.Internal     = 0;
    gOverlapped.InternalHigh = 0;
    gOverlapped.Offset       = 0;
    gOverlapped.OffsetHigh   = 0;
    gOverlapped.hEvent       = CreateEvent(NULL, FALSE, FALSE, NULL);
    if(pLength != NULL)*pLength = 0;
    // attempt an asynchronous read operation
    bResult = WriteFile(handle,pData,dwLen,&nBytesWritten,&gOverlapped);
    if(!bResult)

    {

        // deal with the error code
        switch (GetLastError())

        {

            case ERROR_HANDLE_EOF:

            {

                // we have reached the end of the file
                // during the call to ReadFile
                break;

            }

            case ERROR_IO_PENDING:

            {

                // asynchronous i/o is still in progress
                switch(WaitForSingleObject(gOverlapped.hEvent, dwMilliseconds))

                {

                    case WAIT_OBJECT_0:
                    // check on the results of the asynchronous read
                    // and update the nBytesWritten...
                    bResult = GetOverlappedResult(handle, &gOverlapped,
                    &nBytesWritten, FALSE);
                    if(!bResult)

                    {

                        printf("Error: %d", GetLastError());

                    }

                else

                    {

                        if(pLength != NULL)
                        *pLength = nBytesWritten;
                        dwResult = MPUSB_SUCCESS;

                    }//end if else

                    break;
                    case WAIT_TIMEOUT:
                    CancelIo(handle);
                    break;
                    default:
                    CancelIo(handle);
                    break;

                }//end switch

            }//end case

            default:
            CancelIo(handle);
            break;

        }//end switch

    }

else

    {

        if(pLength != NULL)
        *pLength = nBytesWritten;
        dwResult = MPUSB_SUCCESS;

    }//end if else

    ResetEvent(gOverlapped.hEvent);
    CloseHandle(gOverlapped.hEvent);
    return dwResult;

}//end MPUSBWrite

///////////////////////////////////////////////////////////////////////////////
//	MPUSBReadInt :
//
//  handle  - Identifies the endpoint pipe to be read. The pipe handle must
//            have been created with MP_READ access attribute.
//
//  pData   - Points to the buffer that receives the data read from the pipe.
//
//  dwLen   - Specifies the number of bytes to be read from the pipe.
//
//  pLength - Points to the number of bytes read. MPUSBRead sets this value to
//            zero before doing any work or error checking.
//
//  dwMilliseconds
//          - Specifies the time-out interval, in milliseconds. The function
//            returns if the interval elapses, even if the operation is
//            incomplete. If dwMilliseconds is zero, the function tests the
//            data pipe and returns immediately. If dwMilliseconds is INFINITE,
//            the function's time-out interval never elapses.
//
//	Note that "input" and "output" refer to the parameter designations in calls
//	to this function, which are the opposite of common sense from the
//	perspective of an application making the calls.
//
DWORD MPUSBReadInt(HANDLE handle,// Input
PVOID pData,// Output
DWORD dwLen,// Input
PDWORD pLength,// Output
DWORD dwMilliseconds)// Input

{

    BOOL bResult;
    DWORD nBytesRead;
    OVERLAPPED gOverlapped;
    DWORD dwResult;
    dwResult = MPUSB_FAIL;
    // set up overlapped structure fields
    gOverlapped.Internal     = 0;
    gOverlapped.InternalHigh = 0;
    gOverlapped.Offset       = 0;
    gOverlapped.OffsetHigh   = 0;
    gOverlapped.hEvent       = CreateEvent(NULL, FALSE, FALSE, NULL);
    if(pLength != NULL)*pLength = 0;
    if(pData == NULL)

    {

        SetLastError(ERROR_NOACCESS);
        return dwResult;

    }//end if

    // attempt an asynchronous read operation
    bResult = DeviceIoControl(handle,
    IOCTL_MCHPUSB_WAIT_INTERRUPT,
    NULL,
    0,
    pData,
    dwLen,
    &nBytesRead,
    &gOverlapped);
    if(!bResult)

    {

        // deal with the error code
        switch (GetLastError())

        {

            case ERROR_HANDLE_EOF:

            {

                // we have reached the end of the file
                // during the call to ReadFile
                break;

            }

            case ERROR_IO_PENDING:

            {

                // asynchronous i/o is still in progress
                switch(WaitForSingleObject(gOverlapped.hEvent, dwMilliseconds))

                {

                    case WAIT_OBJECT_0:
                    // check on the results of the asynchronous read
                    // and update the nBytesRead...
                    bResult = GetOverlappedResult(handle, &gOverlapped,
                    &nBytesRead, FALSE);
                    if(!bResult)

                    {

                        printf("Error: %d", GetLastError());

                    }

                else

                    {

                        if(pLength != NULL)
                        *pLength = nBytesRead;
                        dwResult = MPUSB_SUCCESS;

                    }//end if else

                    break;
                    case WAIT_TIMEOUT:
                    CancelIo(handle);
                    break;
                    default:
                    CancelIo(handle);
                    break;

                }//end switch

            }//end case

            default:
            CancelIo(handle);
            break;

        }//end switch

    }

else

    {

        if(pLength != NULL)
        *pLength = nBytesRead;
        dwResult = MPUSB_SUCCESS;

    }//end if else

    ResetEvent(gOverlapped.hEvent);
    CloseHandle(gOverlapped.hEvent);
    return dwResult;

}//end MPUSBReadInt

///////////////////////////////////////////////////////////////////////////////
//	MPUSBClose : closes a given handle.
//
//	Note that "input" and "output" refer to the parameter designations in calls
//	to this function, which are the opposite of common sense from the
//	perspective of an application making the calls.
//
BOOL MPUSBClose(HANDLE handle)

{

    BOOL toReturn;
    toReturn

class=s2>= true; if(lever != INVALID_HANDLE_VALUE) toReturn = CloseHandle(lever); return toReturn; }//end MPUSBClose //---------------------------------------------------------------------------

and ausserdem:

https://dl.XProfan.com/?vmnii/dll.txt

Compile Mark Separation

* Seven basic functions are provided in this release:
- MPUSBGetDeviceCount
- MPUSBOpen
- MPUSBClose
- MPUSBRead
- MPUSBReadInt
- MPUSBWrite
- MPUSBGetDLLVersion
---------------------------------------------------------------------------------
MPUSBGetDLLVersion : get mpusbapi.dll review level
//	Input:
//		None
//	Output:
//		32-bit review level MMMMmmmm
MPUSBIsVidPidEqual : Compares the pVID_PID string against the DeviceInstance
string retrieved from the registry using the DevicePath subkey.
Diese function should be called only from MPUSBGetDevicePath().
MPUSBGetDeviceLink : Returns the path to device hardware with a given instance number.
MPUSBGetDeviceCount : Returns the number of devices with matching VID & PID
MPUSBOpen : Returns the lever to the endpoint pipe with matching VID & PID
MPUSBGetDeviceDescriptor : Returns the Device Descriptor Data
MPUSBRead :
//
//  lever  - Identifies the endpoint pipe to be read. The pipe lever must
//            have been created with MP_READ access attributes.
//
//  pData   - Points to the buffer that receives the data read from the pipe.
//
//  dwLen   - Specifies the number of bytes to be read from the pipe.
//
//  pLength - Points to the number of bytes read. MPUSBRead sets this value to
//            zero before doing any work or error checking.
//
//  dwMilliseconds
//          - Specifies the time-out interval, in milliseconds. The function
//            returns if the interval elapses, even if the operation is
//            incomplete. If dwMilliseconds is zero, the function tests the
//            data pipe and returns immediately. If dwMilliseconds is INFINITE,
//            the function's time-out interval never elapses.
MPUSBWrite :
//
//  lever  - Identifies the endpoint pipe to be written to. The pipe lever
//            must have been created with MP_WRITE access attributes.
//
//  pData   - Points to the buffer containing the data to be written to the pipe.
//
//  dwLen   - Specifies the number of bytes to write to the pipe.
//
//  pLength - Points to the number of bytes written by this function call.
//            MPUSBWrite sets this value to zero before doing any work or
//            error checking.
//
//  dwMilliseconds
//          - Specifies the time-out interval, in milliseconds. The function
//            returns if the interval elapses, even if the operation is
//            incomplete. If dwMilliseconds is zero, the function tests the
//            data pipe and returns immediately. If dwMilliseconds is INFINITE,
//            the function's time-out interval never elapses.
MPUSBReadInt :
//
//  lever  - Identifies the endpoint pipe to be read. The pipe lever must
//            have been created with MP_READ access attributes.
//
//  pData   - Points to the buffer that receives the data read from the pipe.
//
//  dwLen   - Specifies the number of bytes to be read from the pipe.
//
//  pLength - Points to the number of bytes read. MPUSBRead sets this value to
//            zero before doing any work or error checking.
//
//  dwMilliseconds
//          - Specifies the time-out interval, in milliseconds. The function
//            returns if the interval elapses, even if the operation is
//            incomplete. If dwMilliseconds is zero, the function tests the
//            data pipe and returns immediately. If dwMilliseconds is INFINITE,
//            the function's time-out interval never elapses.
MPUSBClose : closes a given lever.
-------------------------------------------------------------------------------------
//  Summary of transfer type usage:
//  ============================================================================
//  Transfer Type       Functions                       time-out Applicable?
//  ============================================================================
//  Interrupt - IN      MPUSBRead, MPUSBReadInt         yes
//  Interrupt - OUT     MPUSBWrite                      yes
//  Bulk - IN           MPUSBRead                       yes
//  Bulk - OUT          MPUSBWrite                      yes
//  Isochronous - IN    MPUSBRead                       No
//  Isochronous - OUT   MPUSBWrite                      No
//  ============================================================================
------------------------------------------------------------------------
extern "C" __declspec(dllexport)
DWORD MPUSBGetDLLVersion(void);
extern "C" __declspec(dllexport)
DWORD MPUSBGetDeviceCount(PCHAR pVID_PID);
extern "C" __declspec(dllexport)
HANDLE MPUSBOpen(DWORD instance,// Input
PCHAR pVID_PID,// Input
PCHAR pEP,// Input
DWORD dwDir,// Input
DWORD dwReserved);// Input <Future Use>
extern "C" __declspec(dllexport)
DWORD MPUSBRead(HANDLE lever,// Input
PVOID pData,// output
DWORD dwLen,// Input
PDWORD pLength,// output
DWORD dwMilliseconds);// Input
extern "C" __declspec(dllexport)
DWORD MPUSBWrite(HANDLE lever,// Input
PVOID pData,// Input
DWORD dwLen,// Input
PDWORD pLength,// output
DWORD dwMilliseconds);// Input
extern "C" __declspec(dllexport)
DWORD MPUSBReadInt(HANDLE lever,// Input
PVOID pData,// output
DWORD dwLen,// Input
PDWORD pLength,// output
DWORD dwMilliseconds);// Input
extern "C" __declspec(dllexport)
BOOL MPUSBClose(HANDLE lever);

Since I unfortunately weder Delphi yet C++ accurate know, would I glad, if someone over The Variablentyben bad could.

@iF: mean You with mem() a area or a 32/64bit Variable?
what corresponds to whom DWORD in Profan? Integer where only the first/last 16bit used go? what commit I the DLL? The Content the variables or whom Zeiger hereon?
I have already DLL's in Profan using, but these is very difficult.
greeting Chregu

awf2.gif

9 kB

Hochgeladen:

09/11/11

awf1.gif

9 kB

Hochgeladen:

09/11/11

_mpusbapi.cpp.txt

31 kB

Hochgeladen:

09/11/11

dll.txt

6 kB

Hochgeladen:

09/11/11

-

So one 64 byte great memory whom You simply with Dim or GlobalAlloc reservieren can.

your row:
Compile Mark Separation

Hi!

32-bit-XProfans Integer are as LongInts from nativer visibility of type Int32 -

solely with XProfan-Struc(turdefinitionen) means Int (%) one Word (16-bit).

You can with nativen 32-bit functions How such 32-bit-DLL-functions as well as with 32-bit-APIs fundamentally of it go out, that for each Parameter one Integer/ LongInt (means 32-bit DoubleWord) expects becomes.

The Parameterdefinition must one entnehmen for what the worth standing -

often becomes one entsprechender worth expects or sometimes even one Speicherhandle.

here stehts in the principle:
Compile Mark Separation

HANDLE MPUSBOpen(DWORD instance,// Input
PCHAR pVID_PID,// Input
PCHAR pEP,// Input
DWORD dwDir,// Input
DWORD dwReserved);// Input <Future Use>/pre>

PChar or. PChar8 is well so definiert:
Compile Mark Separation

Const
MAXSIZE           = 64;
MPUSB_FAIL        = 0;
MPUSB_SUCCESS     = 1;
MP_WRITE:DWORD    = 0;
MP_READ:DWORD     = 1;
MAX_NUM_MPUSB_DEV = 127;
type
DWORD  = LongInt;
PCHAR8 = array[0..MAXSIZE] of

a>;

MPUSBOpen(Selection&,vid_pid#,out_pipe#,MP_WRITE&,0)

sees for me moreover integrally coherent from except for the your memory well only 32 instead of 64 byte big are.

i'm with XProfan 8 now not sure whether it too necessary his could the You instead of MPUSBOpen(Selection&,vid_pid#,out_pipe#,MP_WRITE&,0) Perhaps sooner MPUSBOpen(Selection&,addr(vid_pid#),addr(out_pipe#),MP_WRITE&,0) write should.

slopes on your Strings The You into memory write to safety too one chr$(0) on or use The ESC-sequence \z -

The DLL expects this Stopzeichen presumably as Stringende.

XProfan X2
Win7 Home Premium, SP1, Core(TM)2 Duo E6750 @ 2.66GHz

XProfan X2
Win7 Home Premium, SP1, Core(TM)2 Duo E6750 @ 2.66GHz

Ah, I see strain nochwas...

The functions are well not for stdcall export...

XProfan 11 Helpfile

@Set("CallConv", s)

--------------------------------------------------------------------------------

Version: 11.0

s: String - Aufrufkonvention - "STDCALL" or "CDECL"

-

XProfan 8 knows means yet no set("CallConv"... -

müsstest The Parameter in very umgekehrter Order indicate -

means instead of function(1,2,3) simply function(3,2,1) -

hopefully Gibts there foreseeable with the Stack no Problems there You Yes thereby ESP zurücksetzen müsstest circa 4*Parameterzahl. ^^

If not functions then try it with XProfan 11 set("CallConv" -

if it so goes then could again back To XProfan 8 weg and then could one presumably directly with something Opcode nachhelfen.

Chregu
Mueller

i'm frantic, now have I everything ausprobiert. 64 Bytes reserved with DIM, as String and @Addr(), too without, in umgekehrter Order, any Kombinationen...
now do me The eyes and the head painful. must cook, my woman comes soon to dwell...

XProfan 8

XProfan X2
Win7 Home Premium, SP1, Core(TM)2 Duo E6750 @ 2.66GHz

Jo - How written - see my vorheriges Posting concerning "wohl not stdcall" -

Try please times obs with XProfan 11 + set("callconv" on cdecl functions.

Chregu
Mueller

OK, iF, thanks, now be I a step moreover.
Compile Mark Separation

MPUSBGetDeviceCount(vid_pid$)

functions! gives me The korrekte amount tools back (0 or 1).

and
Compile Mark Separation

myOutPipe&=MPUSBOpen(Selection&,vid_pid$,out_pipe#,MP_WRITE&,0)

gives no Error Message More. supply of course as Return a -1, I as error deute, because yet always something not is correct.
I suppose, THANDLE can I too as LongInt deklarieren?

in the obigen Codeschnipsel have I naturally already any Kombinationen Pixel/without @Addr(), Order, out_pipe# too as out_pipe$ probiert...

alas see straight, on [...]

is with eachone function "stdcall" erwähnt:
Compile Mark Separation

function _MPUSBOpen(instance:DWORD;pVID_PID:PCHAR8;
pEP:PCHAR8;dwDir:DWORD;dwReserved:DWORD):
THANDLE;stdcall;external'mpusbapi.dll';re>

greeting Chregu

Chregu
Mueller

I have now a sinnvollen Rückwert of MPUSBOpen() get: 172
I hope, this is no Another Error, under one Zeiger place I me larger ones number to, can but too only so one USB Pipe his.
tommorrow have I Time, and will be then The summary post, if everything goes.
good night people!
Chregu

it functions!
Compile Mark Separation

'Beispiel für die mpusbapi.dll
'für XProfan 11
'empfängt ein Wert aus dem ADC AN0
 $I mpusbapi.inc
Declare dllh&
Declare vid_pid$,out_pipe$,in_pipe$
Declare myInPipe&,myOutPipe&
Declare MP_WRITE&,MP_READ&
Declare SendData#,RecData#
Declare Selection&
Declare SentLength&,RecvLength&
Declare wert&
DIM SendData#,64
DIM RecData#,64
vid_pid$="vid_04d8&pid_ff0b"'für Sprut Gerät
out_pipe$="\MCHP_EP1"'ein Backslash!
in_pipe$="\MCHP_EP1"
MP_WRITE&=0
MP_READ&=1
Selection&=0
dllh&=@UseDLL("mpusbapi.dll")'DLL laden

IfNot dllh&

    @MessageBox ("DLL nicht geladen","Fehler",48)
    End

EndIf

myOutPipe&=MPUSBOpen(Selection&,addr(vid_pid$),addr(out_pipe$),MP_WRITE&,0)
myInPipe&=MPUSBOpen(Selection&,addr(vid_pid$),addr(in_pipe$),MP_READ&,0)
BYTE SendData#,0=$51'Subsystem ADC
BYTE SendData#,1=$01'initialisieren
BYTE SendData#,2=$04'AN0
BYTE SendData#,3=$00'Referenzspannung
MPUSBWrite(myOutPipe&,addr(SendData#),4,addr(SentLength&),1000)
MPUSBRead(myInPipe&,addr(RecData#),16,addr(RecvLength&),1000)
BYTE SendData#,0=$51'Subsystem ADC
BYTE SendData#,1=$02'nächste Messung
BYTE SendData#,2=$00'AN0
MPUSBWrite(myOutPipe&,addr(SendData#),3,addr(SentLength&),1000)
MPUSBRead(myInPipe&,addr(RecData#),16,addr(RecvLength&),1000)
BYTE SendData#,0=$51'Subsystem ADC
BYTE SendData#,1=$03'Spannung messen
MPUSBWrite(myOutPipe&,addr(SendData#),2,addr(SentLength&),1000)
MPUSBRead(myInPipe&,addr(RecData#),16,addr(RecvLength&),1000)
wert&=@BYTE(RecData#,3)*256+@BYTE(RecData#,2)
PRINT "Wert am AN0: ";
PRINT wert&
MPUSBClose(myOutPipe&)
MPUSBClose(myInPipe&)

IfNot dllh&

    FreeDLL dllh&

EndIf

WaitInput
ef='./../../references-fonction/XProfan/end/'>End

panoramic can I about say:
-with XProfan 8 functions not, only with XProfan 11
-set("CallConv",... is alike in welchem mode
-any Variabeln of type LongInt
-reaches and Strings with @addr() and 64 byte reservieren

thanks and greeting Chregu

09/12/11 ▲

XProfan X2
Win7 Home Premium, SP1, Core(TM)2 Duo E6750 @ 2.66GHz

means if this with XProfan 11 functions and no Errors in the code is then functions it too with XProfan 8.

I see the You Stringadressen by Addr commit -

the standing in the Widerspruch moreover the one 64 byte transfer ought to because one XProfan-String can thoroughly less than 64 byte memory in claim take and its address can even zero his.

rather always instead of this Strings Dim xyz#,64 - memory bring into action -

presumably works then too with XProfan 8.

09/13/11 ▲