#include "n:/henni/bell/lindner/wutils.h"
//#include <windows.h>
//#include <windowsx.h>
//#include <stdlib.h>
#include <stdio.h>
//#include <process.h>
#include "resource.h"
#include "adc2usb.h"
#include <winioctl.h>
#include "c:/cypress/usb/drivers/ezusbdrv/ezusbsys.h"
#pragma comment(linker,"/OPT:NOWIN98")
HWND MainWnd;
HWND hOutputBox;
BOOL StopTest;
TCHAR sDecimal[2]; // Dezimaltrennzeichen von Windows
UINT TimerId;
HANDLE Dev=INVALID_HANDLE_VALUE;
int DevNr;
int SinAmp,SinFreq;
#define EINPROZENT 327.67 // Multiplikator für Amplitude
#define EINHERTZ 2684.35 // Multiplikator für Frequenz
void OpenEzusb(void) {
char DevName[64];
KillTimer(MainWnd,TimerId);
if (Dev!=INVALID_HANDLE_VALUE) return;
// DevNr=1;
wsprintf(DevName,"\\\\.\\EZUSB-%d",DevNr);
Dev=CreateFile(DevName,
GENERIC_WRITE,FILE_SHARE_WRITE,
NULL,OPEN_EXISTING,0,NULL);
}
void WINAPI TimerProc(HWND Wnd, UINT Msg, UINT id, DWORD Time) {
if (KillTimer(0,TimerId)) TimerId=0;
if (CloseHandle(Dev)) Dev=INVALID_HANDLE_VALUE;
}
int Ioctl(int ControlCode,void* OBuf,int OLen,void* IBuf,int ILen) {
OpenEzusb();
if (Dev==INVALID_HANDLE_VALUE) return -2;
if (!DeviceIoControl(Dev,ControlCode,OBuf,OLen,IBuf,ILen,&ILen,NULL)) ILen=-1;
TimerId=SetTimer(0,0,1000,TimerProc);
return ILen;
}
/*
#define BYTES_PER_LINE 0x10
void DumpBuffer(PVOID pvBuffer, ULONG length) {
char temp[64],*p;
ULONG i,j;
MAINTAIN_OUTPUT_BOX(hOutputBox);
i=0;
while (length) {
j=length; if (j>BYTES_PER_LINE) j=BYTES_PER_LINE;
length-=j;
p=temp+wsprintf(temp,"%04X",i);
i+=j;
do {
p+=wsprintf(p," %02X",*((PUCHAR)pvBuffer)++);
}while (--j);
ListBox_AddString(hOutputBox,temp);
}
}
*/
ULONG GetIsoControl(HWND Wnd,ISO_TRANSFER_CONTROL*iso) {
iso->PipeNum= GetDlgItemInt(Wnd,IDC_ISO_PIPE,NULL,FALSE);
iso->PacketSize= GetDlgItemInt(Wnd,IDC_ISO_PACKET_SIZE,NULL,FALSE);
iso->PacketCount= GetDlgItemInt(Wnd,IDC_ISO_PACKETS,NULL,FALSE);
iso->FramesPerBuffer= GetDlgItemInt(Wnd,IDC_ISO_FRAMES_PER_BUFFER,NULL,FALSE);
iso->BufferCount= GetDlgItemInt(Wnd,IDC_ISO_BUFFER_COUNT,NULL,FALSE);
// automatisch abrunden, wenn Modulo-Bedingung nicht gegeben:
iso->PacketCount-=iso->PacketCount%(iso->FramesPerBuffer*iso->BufferCount);
// liefert Speicherbedarf für den Puffer zum Lesen
return iso->PacketCount*(sizeof(USBD_ISO_PACKET_DESCRIPTOR)+iso->PacketSize);
}
/*
typedef struct{
BYTE len,adrh,adrl,ctl,data[16],cs;
}IntelHexRecord,*PIntelHexRecord;
typedef union{
IntelHexRecord r;
BYTE a[21];
}IntelHexLine,*PIntelHexLine;
*/
void SetIfAlt(WORD if_alt) {
// SetInterface (und Alternative im High-Byte)
Ioctl(IOCTL_Ezusb_SETINTERFACE,&if_alt,sizeof(WORD),NULL,0);
}
typedef struct{
BYTE request,xxx;
WORD value,index,length;
BYTE direction,data;
}_vendor_request_in;
void SetRes(BYTE status) {
// <status>: 1=Reset, 0=laufen lassen
DWORD x=0xE600;
_vendor_request_in inbuf={0xA0,0,0xE600,0,1,0,status};
Ioctl(IOCTL_Ezusb_VENDOR_REQUEST,&inbuf,10,NULL,0);
}
void SetFr(DWORD fr) {
_vendor_request_in inbuf={0xF0,0,0,0,4,0,0};
Ioctl(IOCTL_Ezusb_VENDOR_REQUEST,&inbuf,10,&fr,4);
}
long WINAPI LoadFirmware(LPVOID unused) { // Thread!
// Lädt eine IIC-Datei (viel kürzer als eine HEX-Datei)
HANDLE f[2]; // Zwei langweilige Handles
PBYTE p;
BOOL ok=FALSE;
/*#pragma pack(1)
typedef struct{
BYTE sgn;
WORD vid,pid,rev;
BYTE ctl;
}THeader,*PHeader;
typedef struct{
WORD Len,Adr;
}TBlockHdr,*PBlockHdr;
#pragma pack()*/
f[0]=CreateFile(T("ADC2USB.IIC"),GENERIC_READ,FILE_SHARE_READ,NULL,
OPEN_EXISTING,FILE_FLAG_SEQUENTIAL_SCAN,0);
if (f[0]!=INVALID_HANDLE_VALUE) {
f[1]=CreateFileMapping(f[0],NULL,PAGE_READONLY,0,0,NULL);
if (f[1]) {
p=MapViewOfFile(f[1],FILE_MAP_READ,0,0,0);
if (!p) goto e3;
/************ Hier könnte auch eine geladene Resource stehen **********/
if (p[0]!=0xC2) goto e3;
if (*(PWORD)(p+1)!=0x04B4) goto e3;
if (*(PWORD)(p+3)!=0x8613) goto e3;
p+=8;
SetRes(1);
for (;;) {
WORD Len=MAKEWORD(p[1],p[0]);
WORD Adr=MAKEWORD(p[3],p[2]);
if (Adr==0xE600) break;
p+=4;
if (Ioctl(IOCTL_EZUSB_ANCHOR_DOWNLOAD,&Adr,sizeof(WORD),p,Len)<0) goto e3;
p+=Len;
}
ok=TRUE;
e3:
CloseHandle(f[1]);
}
CloseHandle(f[0]);
}
if (!ok) return 0;
SetRes(0);
TimerProc(0,0,0,0); // der Treiber MUSS entladen werden!
Sleep(3000);
SetIfAlt(0x0100);
return 0;
}
/*
void WINAPI SetInterface(WORD if_alt) {
HANDLE Dev=OpenEzusb();
if (!Dev) return;
SetIfAlt(Dev,if_alt);
CloseHandle(Dev);
}
void WINAPI SetReset(BYTE state) {
HANDLE Dev=OpenEzusb();
if (!Dev) return;
SetRes(Dev,state);
CloseHandle(Dev);
}
*/
void TestThread(HWND Wnd) {
// HANDLE hDevice;
ISO_TRANSFER_CONTROL IsoControl;
ULONG bytesToRead;
PUCHAR buffer;
ULONG pass = 0;
ULONG framesRead=0;
// ULONG framesShort=0;
ULONG BytesRead=0;
// Open the driver
// hDevice=OpenEzusb();
// if (!hDevice) return;
bytesToRead=GetIsoControl(Wnd,&IsoControl);
buffer=LocalAlloc(LMEM_FIXED,bytesToRead);
if (!buffer) {
ListBox_AddString(hOutputBox,"alloc Failed");
// CloseHandle(hDevice);
return;
}
while (!StopTest) {
int nBytes;
ULONG packetsRead,i;
PUCHAR ptr;
PUSBD_ISO_PACKET_DESCRIPTOR isoDesc;
nBytes=Ioctl(IOCTL_EZUSB_READ_ISO_BUFFER,&IsoControl,sizeof(IsoControl),
buffer,bytesToRead);
if (nBytes<0) {
ListBox_AddString(hOutputBox,"Read ISO Buffer Failed");
break;
}
packetsRead=nBytes/(sizeof(USBD_ISO_PACKET_DESCRIPTOR)+IsoControl.PacketSize);
ptr=buffer; // am Anfang sind die eigentlichen Daten
isoDesc=(PUSBD_ISO_PACKET_DESCRIPTOR)(buffer+(packetsRead*IsoControl.PacketSize));
// am Ende ist ein Feld aus ISO-Paket-Beschreibern
for (i=0;i<packetsRead;i++) {
BytesRead+=isoDesc[i].Length;
framesRead++;
if (!(framesRead%1000)) {
SetDlgItemInt(Wnd,IDC_FRAMES_READ,framesRead,FALSE);
SetDlgItemInt(Wnd,ADU0,*(PSHORT)(ptr+0),TRUE);
SetDlgItemInt(Wnd,ADU1,*(PSHORT)(ptr+2),TRUE);
SetDlgItemInt(Wnd,IDC_BYTES,(ULONG)(BytesRead/1000000),FALSE);
}
if (isoDesc[i].Length!=IsoControl.PacketSize) {
// framesShort++;
// SetDlgItemInt(Wnd,IDC_FRAMES_MISSED,framesShort,FALSE);
if (IsDlgButtonChecked(Wnd,IDC_CHECK1)) {
ListBox_AddString(hOutputBox,"Short Packet received");
}
}
ptr+=IsoControl.PacketSize;
}
}
// CloseHandle(hDevice);
LocalFree(buffer);
}
void SetDlgItemFloat(HWND Wnd, UINT id, float z, int nk) {
// Gleitkommazahl in Dialogelement setzen
TCHAR buf[32],*p;
_stprintf(buf,T("%.*G"),nk,z);
p=_tcschr(buf,T('.'));
if (p) *p=sDecimal[0];
SetDlgItemText(Wnd,id,buf);
}
void SetSinAmp(int NewAmp) {
if (SinAmp==NewAmp) return;
SinAmp=NewAmp;
SetDlgItemFloat(MainWnd,IDC_SinAmp,(float)((float)SinAmp/EINPROZENT),1);
// zu tun: Tabelle im Treiber neu berechnen
}
void SetSinFreq(int NewFreq) {
if (SinFreq==NewFreq) return;
SinFreq=NewFreq;
SetDlgItemFloat(MainWnd,IDC_SinAmp,(float)((float)SinFreq/EINHERTZ),3);
// zu tun: Treiber informieren
}
bool a2f(PCTSTR s, float*z) {
PTSTR p;
p=_tcschr((PTSTR)s,T(',')); // Ein Komma durch Punkt ersetzen
if (p) *p=T('.');
return _stscanf(s,T("%f"),z)==1?TRUE:FALSE;
}
bool GetDlgItemFloat(HWND Wnd, UINT id, float*z) {
// Gleitkommazahl (auch mit Komma statt Punkt) vom Dialogelement holen
TCHAR s[32];
GetDlgItemText(Wnd,id,s,elemof(s));
if (a2f(s,z)) return TRUE;
SetEditFocus(Wnd,id);
return FALSE;
}
#define WM_CONTINUEINIT (WM_USER+100)
BOOL CALLBACK MainDlgProc(HWND Wnd, UINT message, WPARAM wParam, LPARAM lParam) {
// HANDLE hDevice;
// char tempbuff[256];
// Get a handle to the output box
hOutputBox=GetDlgItem (Wnd, IDC_OUTPUT_BOX);
MAINTAIN_OUTPUT_BOX (hOutputBox);
switch (message) {
case WM_INITDIALOG: {
// Setup the std system font
MainWnd=Wnd;
SendMessage(hOutputBox,WM_SETFONT,(WPARAM)GetStockFont(SYSTEM_FIXED_FONT),
MAKELPARAM(TRUE,0));
// ListBox_AddString(hOutputBox,"EZ-USB Isostrm - built "__TIME__" "__DATE__);
// Setup the default symbolic name for the device driver
SetDlgItemInt(Wnd,IDC_DRIVER_NAME,0,FALSE);
SetDlgItemInt(Wnd,IDC_ISO_PIPE,0,FALSE);
SetDlgItemInt(Wnd,IDC_ISO_PACKETS,32,FALSE);
SetDlgItemInt(Wnd,IDC_ISO_PACKET_SIZE,512,FALSE);
SetDlgItemInt(Wnd,IDC_ISO_BUFFER_COUNT,4,FALSE);
SetDlgItemInt(Wnd,IDC_ISO_FRAMES_PER_BUFFER,8,FALSE);
SendMessage(Wnd,WM_WININICHANGE,0,0);
PostMessage(Wnd,WM_CONTINUEINIT,0,0);
}return TRUE;
case WM_CONTINUEINIT: {
HKEY key;
int val[3]; // Aussehen, links, oben
DWORD vlen,ThreadId;
if (!RegOpenKeyEx(HKCU,"Software\\h#s\\ADC2USB",0,KEY_READ,&key)) {
// Fensterposition wiederherstellen
vlen=sizeof(val);
if (!RegQueryValueEx(key,"WinPos",NULL,NULL,(LPBYTE)val,&vlen)) {
WINDOWPLACEMENT wp;
InitStruct(&wp,sizeof(wp));
GetWindowPlacement(Wnd,&wp);
wp.showCmd=val[0];
OffsetRect(&wp.rcNormalPosition,
val[1]-wp.rcNormalPosition.left,
val[2]-wp.rcNormalPosition.top);
MoveRectIntoFullScreen(&wp.rcNormalPosition);
SetWindowPlacement(Wnd,&wp);
}
// Ausgewählte Treiber-Nummer setzen
vlen=sizeof(int);
if (!RegQueryValueEx(key,"DevNr",NULL,NULL,(LPBYTE)&DevNr,&vlen)) {
SetDlgItemInt(Wnd,IDC_DevNr,DevNr,FALSE);
}
// Sinusgenerator: Frequenz und Amplitude setzen
vlen=sizeof(int);
if (!RegQueryValueEx(key,"SinAmp",NULL,NULL,(LPBYTE)&val,&vlen))
SetSinAmp(val[0]);
vlen=sizeof(int);
if (!RegQueryValueEx(key,"SinFreq",NULL,NULL,(LPBYTE)&val,&vlen))
SetSinFreq(val[0]);
// Analyse: Mittelungen setzen
RegCloseKey(key);
}
// Firmware laden (ohne Sinustabelle?)
CreateThread(NULL,0,LoadFirmware,NULL,0,&ThreadId);
}break;
case WM_WININICHANGE: {
GetProfileString(T("intl"),T("sDecimal"),T("."),sDecimal,elemof(sDecimal));
}return 0;
case WM_COMMAND: switch (LOWORD(wParam)) {
case ID_SAVESET: {
WINDOWPLACEMENT wp;
HKEY key;
int val[3]; // Aussehen, links, oben
if (RegCreateKeyEx(HKCU,"Software\\h#s\\ADC2USB",
0,NULL,0,KEY_WRITE,NULL,&key,NULL)) break;
InitStruct(&wp,sizeof(wp));
if (!GetWindowPlacement(Wnd,&wp)) break;
val[0]=wp.showCmd; // Problem: Kann gar nicht "minimiert" speichern!
val[1]=wp.rcNormalPosition.left;
val[2]=wp.rcNormalPosition.top;
RegSetValueEx(key,"WinPos",0,REG_BINARY,(LPBYTE)val,sizeof(val));
RegSetValueEx(key,"DevNr",0,REG_DWORD,(LPBYTE)DevNr,sizeof(DevNr));
RegCloseKey(key);
}break;
case ID_ABOUT:
MBox(Wnd,32,MB_ICONINFORMATION);
break;
case IDOK:
case IDCANCEL: {
// HANDLE Dev=OpenEzusb();
// if (Dev) {
SetIfAlt(0);
// CloseHandle(Dev);
// }
EndDialog(Wnd,wParam);
}break;
case IDC_CLEAR:
ListBox_ResetContent(hOutputBox);
break;
case IDC_START_ISO_STREAM: {
ISO_TRANSFER_CONTROL IsoControl;
// DWORD nBytes;
// Open the driver
// hDevice=OpenEzusb();
// if (!hDevice) break;
// reset the pipe
GetIsoControl(Wnd,&IsoControl);
if (Ioctl(IOCTL_Ezusb_RESETPIPE,
&IsoControl.PipeNum,sizeof(ULONG),//hin
NULL,0)<0) { //zurück (nichts)
ListBox_AddString(hOutputBox,"Pipe Reset Failed");
// CloseHandle(hDevice);
break;
}
// perform the ISO transfer
if (Ioctl(IOCTL_EZUSB_START_ISO_STREAM,
&IsoControl,sizeof(IsoControl), //hin
NULL,0)<0) { //zurück (nichts)
ListBox_AddString(hOutputBox,"ISO Transfer Failed");
// CloseHandle(hDevice);
break;
}
// CloseHandle(hDevice);
}break;
case IDC_STOP_ISO_STREAM: {
// DWORD nBytes;
// Open the driver
// hDevice=OpenEzusb();
// if (!hDevice) break;
if (Ioctl(IOCTL_EZUSB_STOP_ISO_STREAM,
NULL,0, //hin
NULL,0)<0) { //zurück
ListBox_AddString(hOutputBox,"ISO Transfer Failed");
// CloseHandle (hDevice);
break;
}
// CloseHandle (hDevice);
}break;
case IDC_DevNr: switch (GET_WM_COMMAND_CMD(wParam,lParam)) {
case EN_UPDATE: DevNr=GetDlgItemInt(Wnd,LOWORD(wParam),NULL,FALSE); break;
}break;
case IDC_SinAmp: switch (GET_WM_COMMAND_CMD(wParam,lParam)) {
case EN_UPDATE: {
float f;
if (GetDlgItemFloat(Wnd,LOWORD(wParam),&f)) SetSinAmp((int)(f*EINPROZENT));
}break;
}break;
case IDC_SinFreq: switch (GET_WM_COMMAND_CMD(wParam,lParam)) {
case EN_UPDATE: {
float f;
if (GetDlgItemFloat(Wnd,LOWORD(wParam),&f)) SetSinFreq((int)(f*EINHERTZ));
}break;
}break;
case IDC_START_READ_THREAD: {
DWORD ThreadId;
StopTest = FALSE;
CreateThread(NULL,0,(LPTHREAD_START_ROUTINE)TestThread,Wnd,0,&ThreadId);
}break;
case IDC_STOP_READ_THREAD:
StopTest = TRUE;
break;
/*
case IDC_READ_ISO_BUFFER: {
ISO_TRANSFER_CONTROL IsoControl;
DWORD nBytes;
ULONG bytesToRead;
BOOL bResult;
PUCHAR buffer;
ULONG packetsRead;
PUSBD_ISO_PACKET_DESCRIPTOR isoDesc;
ULONG i;
PUCHAR ptr;
// Open the driver
hDevice=iOpenDriver(Wnd);
if (!hDevice) break;
bytesToRead=GetIsoControl(Wnd,&IsoControl);
buffer=LocalAlloc(LMEM_FIXED,bytesToRead);
wsprintf(tempbuff,"requesting %d bytes",bytesToRead);
ListBox_AddString(hOutputBox,tempbuff);
if (!buffer) {
ListBox_AddString(hOutputBox,"alloc Failed");
break;
}
bResult=DeviceIoControl (hDevice,
IOCTL_EZUSB_READ_ISO_BUFFER,
&IsoControl,
sizeof(ISO_TRANSFER_CONTROL),
buffer,
bytesToRead,
&nBytes,
NULL);
if (!bResult) {
ListBox_AddString(hOutputBox,"ISO Read Failed");
LocalFree(buffer);
CloseHandle (hDevice);
break;
}
wsprintf(tempbuff, "transferred %d bytes",nBytes);
ListBox_AddString(hOutputBox,tempbuff);
packetsRead=nBytes/(IsoControl.PacketSize + sizeof(USBD_ISO_PACKET_DESCRIPTOR));
ptr = buffer;
isoDesc = (PUSBD_ISO_PACKET_DESCRIPTOR) (buffer + (packetsRead * IsoControl.PacketSize));
for (i=0;i<packetsRead;i++) {
wsprintf(tempbuff, "Packet %d length = %d status = %d val = %d",i,isoDesc[i].Length,isoDesc[i].Status,*ptr);
ListBox_AddString(hOutputBox,tempbuff);
ptr += IsoControl.PacketSize;
}
LocalFree(buffer);
CloseHandle (hDevice);
}break;
*/
}break;
}
return FALSE;
}
/*******************************
*WinMain: Windows Entry point *
********************************/
int _stdcall WinMain/*CRTStartup*/(HINSTANCE hInstance,
HINSTANCE hPrevInstance,LPSTR lpCmdLine,int nCmdShow) {
HInstance=GetModuleHandle(NULL);
return DialogBox(HInstance,MAKEINTRESOURCE(100),NULL,MainDlgProc);
}
| Detected encoding: ANSI (CP1252) | 4
|
|
|