C
Ok leute, hier ist der Quellcode
Alle Funktionen, die nicht von MFC Objekten abgeleitet sind, stammen aus der alten Konsolenanwendung. Die sollten funktionieren.
// MchTrDlg.cpp : Implementierungsdatei
//
#include "stdafx.h"
#include "MchTr.h"
#include "MchTrDlg.h"
#include <windows.h>
#include <io.h>
#include <sys\stat.h>
#include <fcntl.h>
#include <stdio.h>
#include <objbase.h>
#include <initguid.h> //this file is necessary for GUID macros like in Guids.h
#include <mapidefs.h>
#include <Setupapi.h> //Win32 setup API header file, required library file is "Setupapi.lib"
//in VS: goto "Project/Settings", "Link" and
// insert filename "Setupapi.lib" in "Object/library modules"
#include <winioctl.h> //includes macro definitions for IOCTL operations
//this file must be included!!
#include "CeUsb2if.h" //CeUsb2 driver programming interface (structures, definitions and IOCTL codes)
#include "CeFirmware.h" //Definition of the firmware programming interface
#include "CeError.h" //Status code definitions for CeUSb2 interface
#include "Guids.h" //CeUsb2 device interface GUIDs are defined in this file
//#include "tcapture.h"
#include <winbase.h>
#include "Usbd.h" //Necessary to get interface information: GetIFInfo()
#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif
//classes and defines from tcapture.h
#define CAPTURE_NO_ERROR 0x00
#define CEUSB2_OPEN_FAILED 0x01
#define CEUSB2_IOCTL_OPERATION_FAILED 0x02
#define CEUSB2_FPGA_CONFIGURATION_FAILED 0x03
#define EXO_FILE_OPEN_FAILED 0x04
#define CEUSB2_RESET_FAILED 0x05
#define PIPE_RESET_FAILED 0x06
#define FILE_NOT_CREATED 0x07
#define PIPE_ABORT_FAILED 0x08
#define TESTMODE_ACTIVATE_FAILED 0x09
#define READ_STREAM_FAILED 0x0A
#define START_TRACER_FAILED 0x0B
#define WRITE_TO_DISK_FAILED 0x0C
#define MANUAL_ABORT 0x0D
//#define CAPTURE_EXO_FILE "tracer_testmode_off.exo"
//#define CAPTURE_EXO_FILE_TESTMODE "D:\\ftp\\MchTr_GUI\\Debug\\tracer_testmode_on.exo"
#define BLOCK_SIZE 1024
//Globals
char *ExoFile;
unsigned int CaptureFileSize;
unsigned int StartTriggerPoint;
unsigned int EndTriggerPoint;
bool overwrite=false;
bool start=false;
bool stop=false;
bool filter=false;
bool leave=false;
//End Globals
class TCapture : public CMchTrDlg
{
public:
TCapture();
// Destructor: closes connections to CEUSB2-board
~TCapture();
int capture(int total_time, char* file, int channel, int transfer_rate, int testmode);
bool OpenCeUsb2 (void);
DWORD OpenUsb2(GUID Guid, UINT DeviceIndex, HANDLE *DevHandle);
void CloseCeUsb2(HANDLE DevHandle);
bool ResetPipe(unsigned long pipe);
bool AbortPipe(unsigned long pipe);
bool InitFpga(void);
bool WriteFpgaBuffer(unsigned char *lBuffer, unsigned long Length);
int IsFpgaConfiguredCorrectly(void);
bool GpifAbort(void);
bool ReinitFw(void);
bool StartTracer(void);
bool Testmode(void);
int ReadExoFileBuffer(FILE *file_stream, unsigned char *Buffer, int Length);
int ConfigureFpga(int testm);
bool ResetFpga(void);
bool ReadData(unsigned char *lBuffer, unsigned long Length);
void error(int e);
protected:
int filehandle;
time_t start_time;
// handle to CEUSB2 device
HANDLE m_board_handle;
};
TCapture::TCapture()
{
}
int TCapture::capture(int total_time, char *capture_file, int chan, int transfer_rate, int testmode)
{
int RetCode;
int i=0, elapsed_time = 0;
unsigned char Databuffer[BLOCK_SIZE]; //for trace on all channels = 128kbit/s
unsigned char dummy1[BLOCK_SIZE/2]; //for trace on all channels with 64kbit/s
unsigned char dummy3[BLOCK_SIZE/128]; //for trace on specific channel with 64kbit/s
unsigned char dummy4[BLOCK_SIZE/64]; //for trace on specific channel with 128kbit/s
int tmp_chan=chan;
// time_t finish_time;
// double elapsed_time_, Speed = 0;
// Configure FPGA on CEUSB2 Board ****************************************
if ( (RetCode = ConfigureFpga (testmode)) != CAPTURE_NO_ERROR )
return RetCode;
// Open Handle to CEUSB2 Board *******************************************
if (!OpenCeUsb2 () )
{
CloseCeUsb2 (&m_board_handle) ;
return CEUSB2_OPEN_FAILED;
}
//Delete old capturefile before creating new empty file
_unlink(capture_file);
//Create new file
if ( (filehandle = _open( capture_file, _O_RDWR | _O_BINARY | _O_CREAT, _S_IWRITE )) == -1 )
return FILE_NOT_CREATED;
//Reset FPGA design
if (!ResetFpga () )
return CEUSB2_RESET_FAILED;
else
m_CaptureError+="FPGA reset successful\r\n";
//Abort GPIF waveform transition
if (!GpifAbort () )
perror("GPIF abort failed\n");
else
m_CaptureError+="GPIF aborted successfully\r\n";
// Reset pipe1 for ReadData()
if (!ResetPipe (1) )
return PIPE_RESET_FAILED;
else
m_CaptureError+="Pipe reset successful\r\n";
// Reinitialize Firmware
if (ReinitFw () )
m_CaptureError+="Firmware reinit successful\r\n";
time(&start_time);
// Write header information
_write( filehandle, &start_time, 4);
_write( filehandle, &chan, 1);
_write( filehandle, &total_time, 11);
//Reset FPGA design
if (!ResetFpga () )
return CEUSB2_RESET_FAILED;
// else
// printf("FPGA reset successful\n");
//Testmode or not
if ( testmode == 1 )
{
m_CaptureError+="*** Testmode activated! ***\r\n";
//Send start signal
if (!StartTracer () )
return START_TRACER_FAILED;
}
// time(&start_time);
//Starting capture process ***********************************************
if ( chan==0 )
{
if (transfer_rate==64)
{
MessageBox("0xff 64");
while (elapsed_time < total_time)
{
if( !ReadData(Databuffer, BLOCK_SIZE) )
return READ_STREAM_FAILED;
for (i=0; i<512; i++)
dummy1[i]=Databuffer[i*2];
if ( unsigned(_write( filehandle, dummy1, BLOCK_SIZE/2 )) != BLOCK_SIZE/2 )
return WRITE_TO_DISK_FAILED;
elapsed_time++;
}
}
else
{
MessageBox("0xff 128");
while (elapsed_time < total_time)
{
if( !ReadData(Databuffer, BLOCK_SIZE) )
return READ_STREAM_FAILED;
if ( unsigned(_write( filehandle, Databuffer, BLOCK_SIZE )) != BLOCK_SIZE )
return WRITE_TO_DISK_FAILED;
elapsed_time++;
}
}
}
else
{ // single-channel trace (Parameter -c set)
if (transfer_rate==64)
{
MessageBox("-c 64");
while (elapsed_time < total_time)
{
if( !ReadData(Databuffer, BLOCK_SIZE) )
return READ_STREAM_FAILED;
for (int i=0; i<BLOCK_SIZE/128; i++)
dummy3[i] = Databuffer[(128*i)+tmp_chan];
if ( unsigned(_write( filehandle, dummy3, BLOCK_SIZE/128 )) != BLOCK_SIZE/128 )
return WRITE_TO_DISK_FAILED;
elapsed_time++;
}
}
else
{
MessageBox("-c 64");
while (elapsed_time < total_time)
{
if( !ReadData(Databuffer, BLOCK_SIZE) )
return READ_STREAM_FAILED;
for (i=0; i<(BLOCK_SIZE/128); i++)
{
dummy4[i]=Databuffer[tmp_chan+i*128];
dummy4[++i]=Databuffer[tmp_chan+i*128+1];
}
//write sgl_channel in file
if ( unsigned(_write( filehandle, dummy4, BLOCK_SIZE/64 )) != BLOCK_SIZE/64 )
return WRITE_TO_DISK_FAILED;
/* //write all in alles.txt
if ( unsigned(_write( fh1, Databuffer, BLOCK_SIZE )) != BLOCK_SIZE )
return WRITE_TO_DISK_FAILED;
*/
elapsed_time++;
}
}
}
//calculate elapsed time and speed
/* time(&finish_time);
elapsed_time_ = difftime(finish_time, start_time);
printf("\nElapsed time while capturing %dKB: %2.2f seconds\n", (BLOCK_SIZE*total_frames)/1024, elapsed_time_);
Speed = (BLOCK_SIZE*total_frames)/(elapsed_time_*1024*1024);
printf("Speed: %2.4fMB/s", Speed);
*/
return CAPTURE_NO_ERROR;
}
TCapture::~TCapture()
{
// close files
_close( filehandle );
// CeUsb2-Close
CloseCeUsb2 (&m_board_handle) ;
}
//Initialize Fpga device for configuration.
//Returns TRUE if succeeds, otherwise returns FALSE
//
bool TCapture::InitFpga(void)
{
DWORD BytesReturned;
unsigned char DummyBuffer[1]; //0x00 if initialization successful, 0xAB if error
CEUSB2_VENDOR_REQUEST_CONTROL VenRequest; //vendor request control structure
//set up the FPGA initialization structure to initialize FPGA device for configuration
VenRequest.Request = CEUSB2_CMD_FPGA_INIT;
VenRequest.Direction = 1;
VenRequest.Value = 0;
VenRequest.Index = 0;
//call the driver
return DeviceIoControl(
m_board_handle, // handle to device
IOCTL_CEUSB2_VENDOR_REQUEST, // operation control code
&VenRequest, // input data buffer
sizeof(CEUSB2_VENDOR_REQUEST_CONTROL), // size of input data buffer
&DummyBuffer, // output data buffer
1, // size of output data buffer
&BytesReturned, // byte count
NULL // overlapped information
)!=0;
}
// Opens the CeUsb2 device with the given index and device interface GUID, and stores its handle in
// DevHandle pointer. This functions return 32 bit status code (0 = success).
//
DWORD TCapture::OpenUsb2(GUID Guid, UINT DeviceIndex, HANDLE *DevHandle)
{
DWORD dwStatus = 0; // return status
SP_INTERFACE_DEVICE_DATA DevInterfaceData;
PSP_INTERFACE_DEVICE_DETAIL_DATA pDevDetail = NULL;
SP_DEVINFO_DATA DevInfoData;
DWORD Size;
// open a device enumeration handle
HDEVINFO hDevInfo = SetupDiGetClassDevs(&Guid, NULL, NULL, DIGCF_PRESENT | DIGCF_INTERFACEDEVICE );
if (hDevInfo == INVALID_HANDLE_VALUE)
return GetLastError();
// find the device with DeviceIndex index
DevInterfaceData.cbSize = sizeof(SP_INTERFACE_DEVICE_DATA);
if(!SetupDiEnumDeviceInterfaces(hDevInfo, NULL, &Guid, DeviceIndex, &DevInterfaceData ))
{
dwStatus = GetLastError();
goto exit_open;
}
// first get the length of detailed information
SetupDiGetDeviceInterfaceDetail(hDevInfo, &DevInterfaceData, NULL, 0, &Size, NULL );
pDevDetail = (PSP_INTERFACE_DEVICE_DETAIL_DATA)malloc(Size);
pDevDetail->cbSize = sizeof(SP_INTERFACE_DEVICE_DETAIL_DATA);
DevInfoData.cbSize = sizeof(SP_DEVINFO_DATA);
// get device details
if(!SetupDiGetDeviceInterfaceDetail(hDevInfo, &DevInterfaceData, pDevDetail, Size, NULL, &DevInfoData))
{
dwStatus = GetLastError();
goto exit_open;
}
// open the device
*DevHandle = CreateFile(
pDevDetail->DevicePath, // name of the device
GENERIC_READ | GENERIC_WRITE, // access mode
0, // share mode
NULL, // security desc.
OPEN_EXISTING, // how to create
0, // file attributes
NULL // template file
);
if ( *DevHandle == INVALID_HANDLE_VALUE )
dwStatus = GetLastError();
exit_open:
if(pDevDetail)
{
free(pDevDetail);
pDevDetail = NULL;
}
SetupDiDestroyDeviceInfoList(hDevInfo); // destroy device information list
return dwStatus;
}
//Open handle to CEUSB2 device.
//
bool TCapture::OpenCeUsb2 (void)
{
__GUIDS_H__ //start macro
// open handle to the device
OpenUsb2(GUID_INTERFACE_CEUSB2, 0, &m_board_handle);
if ( m_board_handle == INVALID_HANDLE_VALUE )
{
//something wrong! There is not a device in the system
//with this link name
return FALSE;
}
return TRUE;
}
// CloseCeUsb2 function traverses the functionality of OpenCeUsb function, and closes (nullifies) the
// device handle stored during open device process.
//
void TCapture::CloseCeUsb2(HANDLE DevHandle)
{
if(!DevHandle)
{
CloseHandle(DevHandle);
DevHandle = NULL;
}
}
// Reset USB pipe, necessary to use it
//
bool TCapture::ResetPipe(unsigned long pipe)
{
DWORD BytesReturned;
bool Ret;
Ret = DeviceIoControl(
m_board_handle, // handle to device
IOCTL_CEUSB2_RESET_PIPE, // operation control code
&pipe, // input data buffer
sizeof(ULONG), // size of input data buffer
NULL, // output data buffer
0, // size of output data buffer
&BytesReturned, // byte count
NULL // overlapped information
)!=0;
return Ret;
}
// Abort USB pipe, might be implemented before reset pipe
//
bool TCapture::AbortPipe(unsigned long pipe)
{
DWORD BytesReturned;
bool Ret;
Ret = DeviceIoControl(
m_board_handle, // handle to device
IOCTL_CEUSB2_ABORT_PIPE, // operation control code
&pipe, // input data buffer
sizeof(ULONG), // size of input data buffer
NULL, // output data buffer
0, // size of output data buffer
&BytesReturned, // byte count
NULL // overlapped information
)!=0;
return Ret;
}
//Write a buffer of bytes to the Fpga.
//Returns TRUE if succeeds, otherwise returns FALSE
//
bool TCapture::WriteFpgaBuffer(unsigned char *lBuffer, unsigned long Length)
{
DWORD BytesReturned; //dummy
bool Ret;
ULONG pipe;
pipe = 0; //pipe 0 means: Type Bulk, Direction Out, Endpoint number 2
Ret = DeviceIoControl(
m_board_handle, // handle to device
IOCTL_CEUSB2_WRITE_BULK, // operation control code
&pipe, // input data buffer
sizeof(ULONG), // size of input data buffer
lBuffer, // output data buffer
Length, // size of output data buffer
&BytesReturned, // byte count
NULL // overlapped information
)!=0;
return Ret;
}
//Read Fpga's done status.
//Returns -1 if IOCTL call fails, 1 if Fpga is configured successfully and 0 if it
//could not be configured correctly.
//
int TCapture::IsFpgaConfiguredCorrectly(void)
{
DWORD BytesReturned;
unsigned char Result;
BOOL Ret;
CEUSB2_VENDOR_REQUEST_CONTROL VenRequest; //vendor request control structure
//set up the FPGA initialization structure to initialize FPGA device for configuration
VenRequest.Request = CEUSB2_CMD_FPGA_GET_STATUS;
VenRequest.Direction = 1;
VenRequest.Value = 0;
VenRequest.Index = 0;
//call the driver
Ret = DeviceIoControl(
m_board_handle, // handle to device
IOCTL_CEUSB2_VENDOR_REQUEST, // operation control code
&VenRequest, // input data buffer
sizeof(CEUSB2_VENDOR_REQUEST_CONTROL), // size of input data buffer
&Result, // output data buffer
sizeof(unsigned char), // size of output data buffer
&BytesReturned, // byte count
NULL // overlapped information
);
if ( !Ret )
{
return -1;
}
else
{
if (Result == 0)
return 1;
else
return 0;
}
}
//function that reads an exo file whose handle is passed with file_stream
//argument. Data read from the file is returned in Buffer argument. Length is
//max. number of bytes requested. It returns actual number of bytes read.
//
int TCapture::ReadExoFileBuffer(FILE *file_stream, unsigned char *Buffer, int Length)
{
int c;
int Index;
int type;
int i;
int len;
int addr;
int value;
unsigned char DummyBuffer[64];
// fill the buffer with data
if ( (c=getc(file_stream)) != -1)
{
Index = len = 0;
if (c != 'S')
{
return 0;
}
fscanf(file_stream,"%1d",&type);
switch (type)
{
case 8:
case 9:
break; //end
case 1: //S1 records
fscanf(file_stream,"%2x%4x",&len,&addr);
len-=3;
for (i=len;i>0;i--)
{
fscanf(file_stream,"%2x",&value);
Buffer[Index++]=value;
}
break;
case 2: //S2 records
fscanf(file_stream,"%2x%6x",&len,&addr);
len-=4;
for (i=0;i<len;i++)
{
fscanf(file_stream,"%2x",&value);
Buffer[Index++]=value;
}
break;
default:
break;
}
// get the rest fo the line
fgets((char*)DummyBuffer,Length,file_stream);
}
else
return 0;
return len;
}
//Configure Fpga
//
int TCapture::ConfigureFpga(int testm)
{
int BytesRead = 0;
unsigned char Buffer[64] = {0};
FILE *m_file_stream;
//open file-stream for FPGA conf.data
if( testm == 0)
{
if ( (m_file_stream = fopen (ExoFile, "rt" )) == NULL )
{
MessageBox("The ExoFile must have the same dir as the capture-file!","EXO_FILE_OPEN_FAILED",MB_ICONSTOP);
return EXO_FILE_OPEN_FAILED;
}
}
else
{
if ( (m_file_stream = fopen (ExoFile, "rt" )) == NULL )
{
MessageBox("The ExoFile must have the same dir as the capture-file","EXO_FILE_OPEN_FAILED",MB_ICONSTOP);
return EXO_FILE_OPEN_FAILED;
}
}
// rewind the file
rewind(m_file_stream);
// printf ("Exo-file opened\n");
//open handle to CEUSB2 board
if (!OpenCeUsb2 () )
{
m_CaptureError+="OpenCeUsb2 failed!\r\n";
return CEUSB2_OPEN_FAILED;
}
m_CaptureError+="CeUsb2 opened\r\n";
// Reset pipe0 for WriteFpga()
if (!ResetPipe(0))
return PIPE_RESET_FAILED;
if (!InitFpga () )
{
CloseCeUsb2 (&m_board_handle) ;
return CEUSB2_FPGA_CONFIGURATION_FAILED;
}
m_CaptureError+="FPGA initialized\r\n";
while((BytesRead = ReadExoFileBuffer(m_file_stream, Buffer, 64 )) != 0)
{
if ( !WriteFpgaBuffer(Buffer,BytesRead) )
break;
}
fclose( m_file_stream );
int FpgaStatus = IsFpgaConfiguredCorrectly();
CloseCeUsb2 (&m_board_handle) ;
if(FpgaStatus == -1)
return CEUSB2_IOCTL_OPERATION_FAILED;
else if(FpgaStatus == 0)
{
return CEUSB2_FPGA_CONFIGURATION_FAILED;
}
m_CaptureError+="FPGA configured successfully\r\n";
return CAPTURE_NO_ERROR;
}
//Reset FPGA design
//Returns TRUE if succeeds, otherwise returns FALSE
//
bool TCapture::ResetFpga(void)
{
DWORD BytesReturned;
CEUSB2_VENDOR_REQUEST_CONTROL VenRequest; //vendor request control structure
//set up the FPGA initialization structure to initialize FPGA device for configuration
VenRequest.Request = CEUSB2_CMD_FPGA_RESET;
VenRequest.Direction = 0;
VenRequest.Value = 0;
VenRequest.Index = 0;
//call the driver
return DeviceIoControl(
m_board_handle, // handle to device
IOCTL_CEUSB2_VENDOR_REQUEST, // operation control code
&VenRequest, // input data buffer
sizeof(CEUSB2_VENDOR_REQUEST_CONTROL), // size of input data buffer
NULL, // output data buffer
0, // size of output data buffer
&BytesReturned, // byte count
NULL // overlapped information
)!=0;
}
// Abort the current GPIF waveform transition
//
bool TCapture::GpifAbort(void)
{
DWORD BytesReturned;
CEUSB2_VENDOR_REQUEST_CONTROL VenRequest; //vendor request control structure
//set up the FPGA initialization structure to initialize FPGA device for configuration
VenRequest.Request = CEUSB2_CMD_GPIF_ABORT;
VenRequest.Direction = 0;
VenRequest.Value = 0;
VenRequest.Index = 0;
//call the driver
return DeviceIoControl(
m_board_handle, // handle to device
IOCTL_CEUSB2_VENDOR_REQUEST, // operation control code
&VenRequest, // input data buffer
sizeof(CEUSB2_VENDOR_REQUEST_CONTROL), // size of input data buffer
NULL, // output data buffer
0, // size of output data buffer
&BytesReturned, // byte count
NULL // overlapped information
)!=0;
}
// Reinitialize Firmware
//
bool TCapture::ReinitFw(void)
{
DWORD BytesReturned;
CEUSB2_VENDOR_REQUEST_CONTROL VenRequest; //vendor request control structure
//set up the FPGA initialization structure to initialize FPGA device for configuration
VenRequest.Request = CEUSB2_CMD_FW_REINIT;
VenRequest.Direction = 0;
VenRequest.Value = 0;
VenRequest.Index = 0;
//call the driver
return DeviceIoControl(
m_board_handle, // handle to device
IOCTL_CEUSB2_VENDOR_REQUEST, // operation control code
&VenRequest, // input data buffer
sizeof(CEUSB2_VENDOR_REQUEST_CONTROL), // size of input data buffer
NULL, // output data buffer
0, // size of output data buffer
&BytesReturned, // byte count
NULL // overlapped information
)!=0;
}
// Send startsignal to FPGA's internal bitgenerator
//
bool TCapture::StartTracer(void)
{
DWORD BytesReturned; //dummy
int startbyte;
CEUSB2_VENDOR_REQUEST_CONTROL VenRequest; //vendor request control structure
//set up the FPGA initialization structure to initialize FPGA device for configuration
VenRequest.Request = CEUSB2_CMD_GPIF_SINGLE_READ_WRITE;
VenRequest.Direction = 1;
VenRequest.Value = 0;
VenRequest.Index = 0;
//call the driver
return DeviceIoControl(
m_board_handle, // handle to device
IOCTL_CEUSB2_VENDOR_REQUEST, // operation control code
&VenRequest, // input data buffer
sizeof(CEUSB2_VENDOR_REQUEST_CONTROL), // size of input data buffer
&startbyte, // output data buffer
sizeof(int), // size of output data buffer
&BytesReturned, // byte count
NULL // overlapped information
)!=0;
}
// Read datastream on pipe1, write it to buffer
//
bool TCapture::ReadData(unsigned char *lBuffer, unsigned long Length)
{
DWORD BytesReturned; //dummy
bool Ret;
int error;
ULONG pipe = 1; //pipe 1 means: Type Bulk, Direction In, Endpoint number 6
Ret = DeviceIoControl(
m_board_handle, // handle to device
IOCTL_CEUSB2_READ_BULK, // operation control code
&pipe, // input data buffer
sizeof(ULONG), // size of input data buffer
lBuffer, // output data buffer
Length, // size of output data buffer
&BytesReturned, // byte count
NULL // overlapped information
)!=0;
error = GetLastError();
return Ret;
}
// Starts ConfigureFPGA, opens device, creates file, resets FPGA, aborts GPIF Settings,
// resets pipe, starts capturing and finally writes data to file
//
//////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
// CAboutDlg-Dialogfeld für Anwendungsbefehl "Info"
class CAboutDlg : public CDialog
{
public:
CAboutDlg();
// Dialogfelddaten
//{{AFX_DATA(CAboutDlg)
enum { IDD = IDD_ABOUTBOX };
CString m_Information;
//}}AFX_DATA
// Vom Klassenassistenten generierte Überladungen virtueller Funktionen
//{{AFX_VIRTUAL(CAboutDlg)
protected:
virtual void DoDataExchange(CDataExchange* pDX); // DDX/DDV-Unterstützung
//}}AFX_VIRTUAL
// Implementierung
protected:
//{{AFX_MSG(CAboutDlg)
//}}AFX_MSG
DECLARE_MESSAGE_MAP()
};
CAboutDlg::CAboutDlg() : CDialog(CAboutDlg::IDD)
{
}
void CAboutDlg::DoDataExchange(CDataExchange* pDX)
{
CDialog::DoDataExchange(pDX);
//{{AFX_DATA_MAP(CAboutDlg)
DDX_Text(pDX, IDC_EDIT1, m_Information);
//}}AFX_DATA_MAP
}
BEGIN_MESSAGE_MAP(CAboutDlg, CDialog)
//{{AFX_MSG_MAP(CAboutDlg)
// Keine Nachrichten-Handler
//}}AFX_MSG_MAP
END_MESSAGE_MAP()
/////////////////////////////////////////////////////////////////////////////
// CMchTrDlg Dialogfeld
CMchTrDlg::CMchTrDlg(CWnd* pParent /*=NULL*/)
: CDialog(CMchTrDlg::IDD, pParent)
{
//{{AFX_DATA_INIT(CMchTrDlg)
m_CaptureFilePath=_T("");
m_CaptureTime =0;
m_CaptureChannel = 0;
m_CaptureError = _T("");
m_Capture64k = FALSE;
m_Capture128k = FALSE;
m_CaptureSize = 0;
m_CaptureStartTrigger = 0;
m_CaptureEndTrigger = 0;
m_TriggerCondition = 0;
//}}AFX_DATA_INIT
// Beachten Sie, dass LoadIcon unter Win32 keinen nachfolgenden DestroyIcon-Aufruf benötigt
m_hIcon = AfxGetApp()->LoadIcon(IDR_MAINFRAME);
}
void CMchTrDlg::DoDataExchange(CDataExchange* pDX)
{
CDialog::DoDataExchange(pDX);
//{{AFX_DATA_MAP(CMchTrDlg)
DDX_Text(pDX, IDC_EDIT1,m_CaptureFilePath);
DDX_Text(pDX, IDC_EDIT2, m_CaptureTime);
DDX_Text(pDX, IDC_EDIT, m_CaptureSize);
DDX_CBIndex(pDX, IDC_COMBO1, m_CaptureChannel);
DDX_Text(pDX, IDC_EDIT3, m_CaptureError);
DDX_Check(pDX, IDC_CHECK1, m_Capture64k);
DDX_Check(pDX, IDC_CHECK2, m_Capture128k);
DDX_Text(pDX, IDC_EDIT_starttrigger, m_TriggerCondition);
//}}AFX_DATA_MAP
}
BEGIN_MESSAGE_MAP(CMchTrDlg, CDialog)
//{{AFX_MSG_MAP(CMchTrDlg)
ON_WM_SYSCOMMAND()
ON_WM_PAINT()
ON_WM_QUERYDRAGICON()
ON_BN_CLICKED(IDC_BUTTON2, OnCaptureSaveButton)
ON_BN_CLICKED(IDC_BUTTON_start, OnCaptureStartButton)
ON_BN_CLICKED(IDC_RADIO_filter, OnRADIOfilter)
ON_BN_CLICKED(IDC_RADIO_start, OnRADIOstart)
ON_BN_CLICKED(IDC_RADIO_stop, OnRADIOstop)
ON_BN_CLICKED(IDC_BUTTON_start2, OnCaptureStopButton)
//}}AFX_MSG_MAP
END_MESSAGE_MAP()
/////////////////////////////////////////////////////////////////////////////
// CMchTrDlg Nachrichten-Handler
BOOL CMchTrDlg::OnInitDialog()
{
CDialog::OnInitDialog();
// Hinzufügen des Menübefehls "Info..." zum Systemmenü.
// IDM_ABOUTBOX muss sich im Bereich der Systembefehle befinden.
ASSERT((IDM_ABOUTBOX & 0xFFF0) == IDM_ABOUTBOX);
ASSERT(IDM_ABOUTBOX < 0xF000);
CMenu* pSysMenu = GetSystemMenu(FALSE);
if (pSysMenu != NULL)
{
CString strAboutMenu;
strAboutMenu.LoadString(IDS_ABOUTBOX);
if (!strAboutMenu.IsEmpty())
{
pSysMenu->AppendMenu(MF_SEPARATOR);
pSysMenu->AppendMenu(MF_STRING, IDM_ABOUTBOX, strAboutMenu);
}
}
// Symbol für dieses Dialogfeld festlegen. Wird automatisch erledigt
// wenn das Hauptfenster der Anwendung kein Dialogfeld ist
SetIcon(m_hIcon, TRUE); // Großes Symbol verwenden
SetIcon(m_hIcon, FALSE); // Kleines Symbol verwenden
// ZU ERLEDIGEN: Hier zusätzliche Initialisierung einfügen
return TRUE; // Geben Sie TRUE zurück, außer ein Steuerelement soll den Fokus erhalten
}
void CMchTrDlg::OnSysCommand(UINT nID, LPARAM lParam)
{
if ((nID & 0xFFF0) == IDM_ABOUTBOX)
{
CAboutDlg dlgAbout;
dlgAbout.DoModal();
}
else
{
CDialog::OnSysCommand(nID, lParam);
}
}
// Wollen Sie Ihrem Dialogfeld eine Schaltfläche "Minimieren" hinzufügen, benötigen Sie
// den nachstehenden Code, um das Symbol zu zeichnen. Für MFC-Anwendungen, die das
// Dokument/Ansicht-Modell verwenden, wird dies automatisch für Sie erledigt.
void CMchTrDlg::OnPaint()
{
if (IsIconic())
{
CPaintDC dc(this); // Gerätekontext für Zeichnen
SendMessage(WM_ICONERASEBKGND, (WPARAM) dc.GetSafeHdc(), 0);
// Symbol in Client-Rechteck zentrieren
int cxIcon = GetSystemMetrics(SM_CXICON);
int cyIcon = GetSystemMetrics(SM_CYICON);
CRect rect;
GetClientRect(&rect);
int x = (rect.Width() - cxIcon + 1) / 2;
int y = (rect.Height() - cyIcon + 1) / 2;
// Symbol zeichnen
dc.DrawIcon(x, y, m_hIcon);
}
else
{
CDialog::OnPaint();
}
}
// Die Systemaufrufe fragen den Cursorform ab, die angezeigt werden soll, während der Benutzer
// das zum Symbol verkleinerte Fenster mit der Maus zieht.
HCURSOR CMchTrDlg::OnQueryDragIcon()
{
return (HCURSOR) m_hIcon;
}
void CMchTrDlg::OnCaptureSaveButton()
{
CFileDialog dlg(FALSE,NULL,NULL,NULL,"Textfiles txt|");
if ((dlg.DoModal())==IDOK)
m_CaptureFilePath=dlg.GetPathName();
UpdateData(FALSE);
}
/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
//////////////////////CAPTURE START//////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
void CMchTrDlg::OnCaptureStartButton()
{
UpdateData(TRUE); //Fields ---> Vars
m_CaptureError="";
UpdateData(FALSE);
TCapture* capture = new TCapture();
char *EXO_TEST_ON = "tracer_testmode_on.exo"; //FPGA-load has to have the same dir as the saved capture
char *EXO_TEST_OFF = "tracer_testmode_off.exo";
char *CaptureFile = new char[m_CaptureFilePath.GetLength()+1]; // CStrings to ANSI string
strcpy(CaptureFile,m_CaptureFilePath);
int c, ok=1, count=0, transfer_rate;
char buffer[8];
char buffer1[_MAX_PATH];
HMODULE hEXE;
hEXE = GetModuleHandle("MchTr.exe");
::GetModuleFileName (hEXE, buffer1, _MAX_PATH);
CString Path=buffer;
Path=(CString(buffer1).Left(CString(buffer1).ReverseFind('\\')+1));
//char d[8];
//sprintf(d,"%d",m_CaptureChannel);
//MessageBox(d);
if (strcmp(CaptureFile,"")==0 || !isalpha(CaptureFile[0]) || CaptureFile[1]!=':' || CaptureFile[2]!='\\' || !isgraph(CaptureFile[3]))
{ m_CaptureError += "Please enter a legal capture-file!\r\n"; ok=0; }
else
{
//combine the exopath
ExoFile = new char[strlen(Path)+1+strlen(EXO_TEST_ON)];
strcpy(ExoFile,Path);
strcat(ExoFile,EXO_TEST_ON);
}
//CaptureSize or CaptureTime selected
if (m_CaptureSize==0 && m_CaptureTime==0 || m_CaptureSize!=0 && m_CaptureTime!=0)
{
m_CaptureError+="Please enter Max.FileSize OR CaptureTime!\r\n";
ok=0;
}
//64k oder 128k -Kanal
if (m_Capture64k==FALSE && m_Capture128k==FALSE || m_Capture64k==TRUE && m_Capture128k==TRUE)
{
m_CaptureError+="Please select 64kbit/s OR 128kbit/s\r\n";
ok=0;
}
else
if (m_Capture64k==TRUE)
transfer_rate=64;
else
transfer_rate=128;
if (ok==1)
{
c = capture->capture( m_CaptureTime*1024, CaptureFile, m_CaptureChannel, transfer_rate, 0/*TESTMODE ON*/);
switch (c)
{
case CEUSB2_OPEN_FAILED : m_CaptureError +="Error 0x01: unable open connection to CeUsb2 board.\r\n"; break;
case CEUSB2_IOCTL_OPERATION_FAILED : m_CaptureError +="Error 0x02: unable to access CeUsb2 board.\r\n"; break;
case CEUSB2_FPGA_CONFIGURATION_FAILED : m_CaptureError +="Error 0x03: unable to configure FPGA on CeUsb2 board.\r\n"; break;
case CEUSB2_RESET_FAILED : m_CaptureError +="Error 0x05: unable to give reset signal.\r\n"; break;
case PIPE_RESET_FAILED : m_CaptureError +="Error 0x06: unable to reset pipe.\r\n"; break;
case PIPE_ABORT_FAILED : m_CaptureError +="Error 0x08: unable to abort pipe.\r\n"; break;
case EXO_FILE_OPEN_FAILED : m_CaptureError +="Error 0x04: unable to open FPGA-load.\r\n"; break;
case TESTMODE_ACTIVATE_FAILED: m_CaptureError +="Error 0x09: unable to activate testmode.\r\n"; break;
case FILE_NOT_CREATED : m_CaptureError +="Error 0x07: unable to create destination file.\r\n"; break;
case READ_STREAM_FAILED : m_CaptureError +="Error 0x0A: error reading from stream.\r\n"; break;
case START_TRACER_FAILED : m_CaptureError +="Error 0x0B: error giving start signal to internal bitgenerator.\r\n"; break;
case WRITE_TO_DISK_FAILED : m_CaptureError +="Error 0x0C: unable to write data to disk.\r\n"; break;
case CAPTURE_NO_ERROR : break;
case MANUAL_ABORT: m_CaptureError +="Error 0x0D: capture finished by manual abort.\r\n"; break;
default : sprintf(buffer,"%x",c); m_CaptureError+=buffer; m_CaptureError +=": unknown error occured.\r\n"; break;
}
delete capture;
delete ExoFile;
}
m_CaptureError+="... Capturing finished";
UpdateData(FALSE); //Variablen ---> Felder
//exit(0);
}
void CMchTrDlg::OnRADIOfilter()
{
filter=true;
start=false;
stop=false;
}
void CMchTrDlg::OnRADIOstart()
{
filter=false;
start=true;
stop=false;
}
void CMchTrDlg::OnRADIOstop()
{
filter=false;
start=false;
stop=true;
}
//manual abort the capture
void CMchTrDlg::OnCaptureStopButton()
{
leave=true;
}
Hoffe ihr könnt das lesen!
Danke im Voraus für eure Hilfe!
Chiao
