usbmain.cpp

用于和CH372 USB DEVICE CHIP 通讯,稍加修改可以上用于其他USB DEVICE, 使用WINDRIVER 编写

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

#include <vcl.h>
#pragma hdrstop

#include "USBMAIN.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma link "PERFGRAP"
#pragma resource "*.dfm"

#include"windrvr.h"
#include"dos.h"
#include "utils.h"
#include "wdu_lib.h"
#include "status_strings.h"
#include "usb_diag_lib.h"

#if defined(USB_DIAG_SAMPLE)

// TODO: change the following definitions to match your device.
#define DEFAULT_VENDOR_ID 0x1234
#define DEFAULT_PRODUCT_ID 0x5678
#define DEFAULT_LICENSE_STRING "12345abcde1234.license"

#else

// use in wizard's device-specific generated code
#define DEFAULT_VENDOR_ID         0x04FC
#define DEFAULT_PRODUCT_ID        0x0003
#define DEFAULT_LICENSE_STRING    "6C3CC2FF5629291736D037215760FFA056B8D612.tony"

#endif

#define USE_DEFAULT 0xffff
#define ATTACH_EVENT_TIMEOUT 3 // in seconds
#define TRANSFER_TIMEOUT 3000 // in msecs
#if !defined(TRACE)
#define TRACE printf
#endif
#if !defined(ERR)
#define ERR printf
#endif

typedef struct DEVICE_CONTEXT
{
    struct DEVICE_CONTEXT *pNext;
    WDU_DEVICE_HANDLE hDevice;
    DWORD dwVendorId;
    DWORD dwProductId;
    DWORD dwInterfaceNum;
    DWORD dwAlternateSetting;
} DEVICE_CONTEXT;

typedef struct DRIVER_CONTEXT
{
    HANDLE hEvent;
    HANDLE hMutex;
    DWORD dwDeviceCount;
    DEVICE_CONTEXT *deviceContextList;
    DEVICE_CONTEXT *pActiveDev;
    HANDLE hDeviceUnusedEvent;
} DRIVER_CONTEXT;

union PhoneNumber_FileLength{
unsigned char Number[4];
unsigned long length;
};

struct Command{
unsigned char Mode;
unsigned char Pattern;
unsigned char Update;
unsigned char nop1;
union PhoneNumber_FileLength L4;

unsigned char lengthc;
unsigned char lengths;
unsigned long lengthw;
unsigned long lengthr;
unsigned char wbuf[64];
unsigned char rbuf[64];
bool finish;
};

HANDLE Thread_Process;
bool Thread_Stop=false;
unsigned long  ProgramLength;
bool Fileflag=false;


DWORD dwError;
WORD wVendorId = 0;
WORD wProductId = 0;
WDU_DRIVER_HANDLE hDriver = 0;
DRIVER_CONTEXT DrvCtx;
WDU_MATCH_TABLE matchTable;
WDU_EVENT_TABLE eventTable;
WDU_DEVICE *pDevice;
WDU_PIPE_INFO *pPipes;
WDU_ALTERNATE_SETTING *pAltSet;

TUSBMajor *USBMajor;

struct Command Commands;
struct Command Status;
unsigned char critical=0;
bool attached;
unsigned char FileContent[64*1024+1];

DWORD SendCommand(struct Command * C,unsigned char *plength);
DWORD GetStatus(struct Command *S,unsigned char *plength);
DWORD WriteData(unsigned char * D,unsigned long *plength);
DWORD ReadData(unsigned char * D,unsigned long * plength);
void ShowMessagem(char * Cp);
void Send_Dial_Command(void);
void Send_Display_Command(void);
void Progressing(bool start);
void ProgramEEPROM(void);
void Get_Debug_Code(void);
unsigned char convert(unsigned char dcode);
void Record_Data(void);
void Read_Data0809de(void);
void Read_Data0809up(void);

DWORD SendCommand(struct Command * C,unsigned char * plength)
{BYTE  SetupPacket[8];
 DWORD  dwBytesTransferred;

 if(attached==true)
 {dwError = WDU_Transfer(DrvCtx.pActiveDev->hDevice,0x01,0, 0, (VOID *)C,
                8, &dwBytesTransferred, SetupPacket, TRANSFER_TIMEOUT);
  if (dwError)
    ShowMessagem("Write Command failed: error 7");
  else
    {
     *plength=0;
     ShowMessagem("Write Command ok");
    }
  }
  else
   dwError=0xff;

 return(dwError);
}

DWORD GetStatus(struct Command * S,unsigned char * plength)
{BYTE  SetupPacket[8];
 DWORD  dwBytesTransferred;
 if(attached==true)
 {
  dwError = WDU_Transfer(DrvCtx.pActiveDev->hDevice,0x81,1, 0, (PVOID *)S,
                8, &dwBytesTransferred, SetupPacket, TRANSFER_TIMEOUT);
  if (dwError)
    ShowMessagem("Get status failed: error 8");
  else
    {*plength=dwBytesTransferred;
     ShowMessagem("Get status ok");
    }
  }
  else
   dwError=0xff;
  return(dwError);
}

DWORD WriteData(unsigned char * D,unsigned long * plength)
{BYTE  SetupPacket[8];
 DWORD  dwBytesTransferred;
 if(attached==true)
 {dwError = WDU_Transfer(DrvCtx.pActiveDev->hDevice,0x02,0, 0, (PVOID *)D,
                *plength, &dwBytesTransferred, SetupPacket, TRANSFER_TIMEOUT);
  if (dwError)
    ShowMessagem("Write data failed: error 9");
  else
    {*plength=0;
     ShowMessagem("Write data ok");
    }
  }
  else
   dwError=0xff;
  return(dwError);
}

DWORD ReadData(unsigned char * D,unsigned long * plength)
{BYTE  SetupPacket[8];
 DWORD  dwBytesTransferred;
 if(attached==true)
 {dwError = WDU_Transfer(DrvCtx.pActiveDev->hDevice,0x82,1, 0, (PVOID *)D,
                *plength, &dwBytesTransferred, SetupPacket, TRANSFER_TIMEOUT);
  if (dwError)
    ShowMessagem("Read data failed: error 10");
  else
    {*plength= dwBytesTransferred;
     ShowMessagem("Read data ok");
    }
  }
  else
   dwError=0xff;

  return(dwError);
}


void Close_Process(void)
{
    if (!Thread_Process)
        return;

    Thread_Stop = TRUE; 
    ThreadWait(Thread_Process);
    Thread_Stop = NULL;

}

void DLLCALLCONV Process(void * p)
{
    static AnsiString f;

    for (;;)
    {if (Thread_Stop)
         break;
     if(!Commands.finish)
     {if(Commands.Mode==0x02)
       {Send_Dial_Command();//dial
        Commands.finish=true;
        Progressing(0);
       }
      else if(Commands.Mode==0x01&&Commands.Pattern==0x00)
       {Send_Display_Command();//Send data to display
        Commands.finish=true;
        Progressing(0);
       }
      else if(Commands.Mode==0x01&&Commands.Pattern==0x01)
       {Get_Debug_Code();//Get the debgu code
        Commands.finish=true;
        Progressing(0);
       }
      else if(Commands.Mode==0x03)
       {Read_Data0809de();//Get data from AD0809
        Commands.finish=true;
        Progressing(0);
       }
      else if(Commands.Mode==0x0)
       {if(Commands.Pattern==0x03)
         Record_Data();
        if(Commands.Pattern==0x01)
         Read_Data0809up();
    
        Commands.finish=true;
        Progressing(0);
       }
      else if(Commands.Mode==0x04)
       {//Program the EEPROM
        ProgramEEPROM();
        Commands.finish=true;
        Progressing(0);
       }
      else
      ;
     }
    }
}

void Creat_Process(void)
{  DWORD dwError;
   PVOID p=NULL;
    // start the running thread
    Thread_Stop = FALSE;

    dwError = ThreadStart(&Thread_Process, Process, p);
    if(dwError)
     ShowMessagem("Thread create fail !!!");
}


BOOL DLLCALLCONV DeviceAttach(WDU_DEVICE_HANDLE hDevice,
    WDU_DEVICE *pDeviceInfo, PVOID pUserData)
{
    int i,j;
    DRIVER_CONTEXT *pDrvCtx = (DRIVER_CONTEXT *)pUserData;
    DEVICE_CONTEXT *pDevCtx, **ppDevCtx;
    DWORD dwInterfaceNum = pDeviceInfo->pActiveInterface[0]->pActiveAltSetting->Descriptor.bInterfaceNumber;
    DWORD dwAlternateSetting = pDeviceInfo->pActiveInterface[0]->pActiveAltSetting->Descriptor.bAlternateSetting;

    // NOTE: To change the alternate setting, call WDU_SetInterface() here
    DWORD dwAttachError;

    // TODO: replace with the requested number:
    //dwAlternateSetting = %alternate_setting_number%; 

    dwAttachError = WDU_SetInterface(hDevice, dwInterfaceNum, dwAlternateSetting);
    if (dwAttachError)
    {
        ShowMessagem("DeviceAttach: WDU_SetInterface failed 6");

        return FALSE;
    }


    // Add our device to the device list
    pDevCtx = (DEVICE_CONTEXT *)malloc(sizeof(DEVICE_CONTEXT));
    if (!pDevCtx)
    {
        ShowMessagem("DeviceAttach: failed allocating memory");
        return FALSE;
    }
    BZERO(*pDevCtx);
    pDevCtx->hDevice = hDevice;
    pDevCtx->dwInterfaceNum = dwInterfaceNum;
    pDevCtx->dwVendorId = pDeviceInfo->Descriptor.idVendor;
    pDevCtx->dwProductId = pDeviceInfo->Descriptor.idProduct;
    pDevCtx->dwAlternateSetting = dwAlternateSetting;

    OsMutexLock(pDrvCtx->hMutex);
    for (ppDevCtx = &pDrvCtx->deviceContextList; *ppDevCtx; ppDevCtx = &((*ppDevCtx)->pNext));
    *ppDevCtx = pDevCtx;
    pDrvCtx->dwDeviceCount++;
    OsMutexUnlock(pDrvCtx->hMutex);
    
    ShowMessagem("Device Attached!!!!!");
    USBMajor->Scan->StartFrame=2;
    USBMajor->Scan->StopFrame=2;
    USBMajor->Scan->Active=true;

    OsEventSignal(pDrvCtx->hEvent);
    if (!DrvCtx.pActiveDev)
         DrvCtx.pActiveDev = DrvCtx.deviceContextList;

    Creat_Process();
    
    attached=true ;
    // Accept control over this device
    return TRUE;
}

void Progressing(bool start)
{  if(start==true)
    { USBMajor->Progress->StartFrame=2;
      USBMajor->Progress->StopFrame=4;
      USBMajor->Progress->Active=true;
    }
    else
    { USBMajor->Progress->StartFrame=2;
      USBMajor->Progress->StopFrame=2;
      USBMajor->Progress->Active=true;
    }
}

VOID DLLCALLCONV DeviceDetach(WDU_DEVICE_HANDLE hDevice, PVOID pUserData)
{   int j,i;
    DRIVER_CONTEXT *pDrvCtx = (DRIVER_CONTEXT *)pUserData;
    DEVICE_CONTEXT **pCur;
    DEVICE_CONTEXT *pTmpDev;
    BOOL bDetachActiveDev = FALSE;
    attached=false;
    OsMutexLock(pDrvCtx->hMutex);
    for (pCur = &pDrvCtx->deviceContextList;
        *pCur && (*pCur)->hDevice != hDevice;
        pCur = &((*pCur)->pNext));

    if (*pCur == pDrvCtx->pActiveDev)
    {
        bDetachActiveDev = TRUE;
        pDrvCtx->pActiveDev = NULL;
    }

    pTmpDev = *pCur;
    *pCur = pTmpDev->pNext;
    free(pTmpDev);

    pDrvCtx->dwDeviceCount--;
    OsMutexUnlock(pDrvCtx->hMutex);
    ShowMessagem("Device Detached!!!!!");
    USBMajor->Scan->StartFrame=2;
    USBMajor->Scan->StopFrame=8;
    USBMajor->Scan->Active=true;

    Close_Process();

    WDU_PutDeviceInfo(pDevice);
    if (bDetachActiveDev)
    {
     //  OsEventWait(pDrvCtx->hDeviceUnusedEvent, INFINITE);
    }
}

void ShowMessagem(char * Cp)
{USBMajor->Status->Text=Cp;
}

//---------------------------------------------------------------------------
__fastcall TUSBMajor::TUSBMajor(TComponent* Owner)
        : TForm(Owner)
{
}
//---------------------------------------------------------------------------

void Read_Data0809up(void)
{
 SendCommand(&Commands,&Commands.lengthc);
  if(!GetStatus(&Status,&Commands.lengths))
  {if(Status.Mode==Commands.Mode)
   {ShowMessagem("USB DISK Mode connection OK!!!");
   }
   else
    ShowMessagem("USB DISK Mode feedback error, connection fail!!!");
  }
  else
   ShowMessagem("USB DISK Mode connecting fial!!!");
}

void Read_Data0809de(void)
{unsigned char oldmode,oldpattern,temps1,temps2,temps3,temps4,temps5,temps6,temps7,temps8;
 unsigned long i,j,timer=0,originaltime;
 AnsiString FileName;
 int FileHandle;
 struct time temptime;

 oldmode=Commands.Mode;
 oldpattern=Commands.Pattern;
 gettime(&temptime);
 originaltime=temptime.ti_hour*360000+temptime.ti_min*6000+temptime.ti_sec*100+temptime.ti_hund;

 FileName="AD0809A.DAT";
 FileHandle = FileCreate(FileName);

 if(FileHandle<0)
   {ShowMessagem("File open fail!!!");
    Commands.finish=true;
    return;
   }
 USBMajor->Series1->Clear();
 USBMajor->Series2->Clear();
 USBMajor->Series3->Clear();
 USBMajor->Series4->Clear();
 USBMajor->Series5->Clear();
 USBMajor->Series6->Clear();
 USBMajor->Series7->Clear();
 USBMajor->Series8->Clear();