main.cpp

来自「16 relay output channels and 16 isolated」· C++ 代码 · 共 630 行 · 第 1/2 页

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

#include <vcl.h>
#pragma hdrstop

#include "Main.h"
#include <math.h>
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"

TFrmMain *FrmMain;

int ErrCde;                     // Return error code
char szErrMsg[80];              // Use for MESSAGEBOX function
LONG DriverHandle = (LONG)NULL; // driver handle
ULONG dwDeviceNum;              // Device number
char szBuffer[40];              // Temperatory buffer
BOOL bRunTimer = FALSE;
PT_FAOScale ptFAOScale;         // FAOScale table
USHORT far * lpBuf[4] = {NULL,NULL,NULL,NULL};
FLOAT far * lpVoltageBuf[4] = {NULL,NULL,NULL,NULL};
HGLOBAL hBuf[4], hVoltageBuf[4];
USHORT far * lpCommonBuf;
HGLOBAL	hCommonBuf;
HANDLE hThreadHandle;
DWORD dwThreadID;
BOOL bThreadloop = FALSE;
BOOL bThreadflag = FALSE;     
char szDescript[100];           // Description device
USHORT gwSelectDevice = FALSE;  // have never selected "Select Device" button
DWORD gdwPacerRate = 10000;     // pacer rate
ULONG gulConvNum = 2048;        // conversion number
ULONG gwWaveFormCount = 30;     // waveform count
USHORT gwExtTrig = 0;           // external or internal trigger
USHORT gwEvtFlag = 1;           // event enable(0)

void SetRealBuffer(float far *lpBuf, long num, LPSWAVE lpWave)
{
    int i, r, half;
    float slope;

    switch (lpWave->wWaveform)
    {
        case WAVE_SINE:
            for (i = 0; i < num; i ++)
            {
                *(lpBuf+i) = (float)(lpWave->fMagnitude
                           * sin(6.2831853*(double)i/(double)lpWave->wPeriod)
                           + lpWave->fOffset);
            }
            break;
        case WAVE_TRIANGLE:
            slope = lpWave->fMagnitude * 4.0f / (float)lpWave->wPeriod;
            for (i = 0; i < num; i ++)
            {
                r = i % lpWave->wPeriod;
                half = (int)((float)lpWave->wPeriod / 2.0f);
                if (r <= half)
                    *(lpBuf + i) = slope * r - lpWave->fMagnitude
                                 + lpWave->fOffset;
                else
                    *(lpBuf + i) = slope * (lpWave->wPeriod - r)
                                 - lpWave->fMagnitude + lpWave->fOffset;
            }
            break;
        case WAVE_SQUARE:
            for (i = 0; i < num; i ++)
            {
                r = i % lpWave->wPeriod;
                half = (int)((float)lpWave->wPeriod / 2.0f);
                if (r <= half)
                    *(lpBuf + i) = lpWave->fOffset - lpWave->fMagnitude;
                else
                    *(lpBuf + i) = lpWave->fOffset + lpWave->fMagnitude;
            }
            break;
        case SINE_TRIANGLE:
        {
            ULONG x;
	    double y;

            slope = lpWave->fMagnitude * 4.0f / (float)lpWave->wPeriod;
            for (i = 0; i < num; i ++)
	    {
		if ( i%2)
		{
		    modf(((double)i/2.0),(double *)&y);
		    y = y + 1;
                    r = ((USHORT)y) % lpWave->wPeriod;
                    half = (int)((float)lpWave->wPeriod / 2.0f);
                    if (r <= half)
                        *(lpBuf + i) = slope * r - lpWave->fMagnitude
                                     + lpWave->fOffset;
                    else
                        *(lpBuf + i) = slope * (lpWave->wPeriod - r)
                                     - lpWave->fMagnitude + lpWave->fOffset;
                }
		else
		{
		    x = i/2;
		    *(lpBuf+i) = (float)(lpWave->fMagnitude
                               * sin(6.28318*(double)x/(double)lpWave->wPeriod)
                               + lpWave->fOffset);
                }
            }
            break;
        }
    }
}

void SetMultiToOneBuffer(USHORT usEnabledChannel, int count)
{
    int i,TotalCount;

    TotalCount=0;

    for (i = 0; i < count; i ++)
    {
    	if(usEnabledChannel & ADV_CHANNEL0)
    	{
            ((USHORT far *)lpCommonBuf)[TotalCount] =
	    	((USHORT)((USHORT far *) lpBuf[0])[i]) & 0x0fff;
	    TotalCount++;
        }
	if(usEnabledChannel & ADV_CHANNEL1)
        {
	    ((USHORT far *)lpCommonBuf)[TotalCount] =
	    	((USHORT)((USHORT far *) lpBuf[1])[i] | ( 0x01 << 12)) & 0x3fff;
	    TotalCount++;
	}
	if(usEnabledChannel & ADV_CHANNEL2)
	{
	    ((USHORT far *)lpCommonBuf)[TotalCount] =
	    	((USHORT)((USHORT far *) lpBuf[2])[i] | ( 0x02 << 12)) & 0x3fff;
	    TotalCount++;
	}
	if(usEnabledChannel & ADV_CHANNEL3)
	{
	    ((USHORT far *)lpCommonBuf)[TotalCount] =
	        ((USHORT)((USHORT far *) lpBuf[3])[i] | ( 0x03 << 12)) & 0x3fff;
            TotalCount++;
	}
    }
}

void MyFreeBuffer()
{
    int i;

    for(i=0; i<4; i++)
    {
        if(hBuf[i])
       	{
	    GlobalFree(hBuf[i]);
	    hBuf[i] = NULL;
	}
	if(hVoltageBuf[i])
	{
	    GlobalFree(hVoltageBuf[i]);
	    hVoltageBuf[i] = NULL;
	}
    }
}

void adInterruptEvent()
{
    return;
}

void adBufChangeEvent()
{
    return;
}

void adOverrunEvent()
{
    return;
}

void adTerminateEvent()
{
    bThreadloop = FALSE;

    // Disable stop button
    FrmMain->Stop->Enabled = FALSE;

    return;
}

void UserThread()
{
    USHORT usEventType;
    PT_CheckEvent ptCheckEvent;   // Check event

    while(bThreadloop)
    {
        // Check message
        ptCheckEvent.EventType = &usEventType;
        ptCheckEvent.Milliseconds = 100;

       	bThreadflag = TRUE;
        DRV_CheckEvent(DriverHandle, (LPT_CheckEvent)&ptCheckEvent);

        // Process interrupt event
        if (usEventType & ADS_EVT_INTERRUPT)
            adInterruptEvent();

        // Process buffer change event
        if (usEventType & ADS_EVT_BUFCHANGE)
            adBufChangeEvent();

        // Process overrun event
        if (usEventType & ADS_EVT_OVERRUN)
            adOverrunEvent();

        // Process terminate event
        if (usEventType == ADS_EVT_TERMINATED)
            adTerminateEvent();

        bThreadflag = FALSE;
    }
}

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

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

void __fastcall TFrmMain::WaveformClick(TObject *Sender)
{
    Application->CreateForm(__classid(TFrmWave), &FrmWave);
    FrmWave->Show();        
}
//---------------------------------------------------------------------------

void __fastcall TFrmMain::FormClose(TObject *Sender, TCloseAction &Action)
{
    MyFreeBuffer();
}
//---------------------------------------------------------------------------

void __fastcall TFrmMain::RunClick(TObject *Sender)
{
    int i;
    PT_EnableEvent ptEnableEvent;             // Enable event
    PT_FAOWaveFormStart ptFAOWaveFormStart;   // FAODMAStart table
    
    // Step 1: Device open
    ErrCde = DRV_DeviceOpen(dwDeviceNum, (LONG far *)&DriverHandle);
    if (ErrCde != SUCCESS)
    {
        DRV_GetErrorMessage(ErrCde, szErrMsg);
        MessageBox(Handle, szErrMsg, "Device Open", MB_OK);
        return;
    }

    // Step 2: Allocate buffer and set data to buffer
    // Process 4 channel
    usChannelCount = 0;    // reset channel count
    usEnabledChannel = 0;
    for(i=0; i<4; i++)
    {
    	// Allocate memory used by driver
	if((hBuf[i]=(USHORT far *)GlobalAlloc(GPTR,
	    sizeof(USHORT) * gulConvNum)) == 0)
	{
	    MessageBox(Handle, "Not enough memory for buffer", "High Speed", MB_OK);
            DRV_DeviceClose((LONG far *)&DriverHandle);
            return;
        }

	// Allocate memory for real voltage
	if((hVoltageBuf[i]=(FLOAT far *)GlobalAlloc(GPTR,
            sizeof(FLOAT) * gulConvNum)) == 0)
	{
	    MessageBox(Handle, "Not enough memory for buffer", "High Speed", MB_OK);
            DRV_DeviceClose((LONG far *)&DriverHandle);
	    return;
        }

	lpBuf[i] = (USHORT far *)hBuf[i];
	lpVoltageBuf[i] = (FLOAT far  *)hVoltageBuf[i];

	switch(i)
	{
	    case 0 :
	        if(sWaveCh0.wWaveform != 4)  // 4 --> No Waveform
		{
		    usEnabledChannel |= ADV_CHANNEL0;
		    // set real voltage to hVoltageBuf
		    SetRealBuffer(lpVoltageBuf[0], gulConvNum, &sWaveCh0);
		    usChannelCount++;
		}
		else
		    continue;

                break;
	    case 1 :
		if(sWaveCh1.wWaveform != 4)
		{
		    usEnabledChannel |= ADV_CHANNEL1;
		    SetRealBuffer(lpVoltageBuf[1], gulConvNum, &sWaveCh1);
		    usChannelCount++;
                }
		else
		    continue;

                break;
	    case 2 :
		if(sWaveCh2.wWaveform != 4)
		{