main.cpp

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

		    usEnabledChannel |= ADV_CHANNEL2;
		    SetRealBuffer(lpVoltageBuf[2], gulConvNum, &sWaveCh2);
		    usChannelCount++;
		}
		else
		    continue;

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

		break;
        }

	// call FAOScale for transfer voltage to binary data
	ptFAOScale.VoltArray = lpVoltageBuf[i];
	ptFAOScale.BinArray  = lpBuf[i];
	ptFAOScale.chan      = i;
	ptFAOScale.count     = gulConvNum;
	if ((ErrCde = DRV_FAOScale(DriverHandle, (LPT_FAOScale)&ptFAOScale)) != 0)
        {
	    DRV_GetErrorMessage(ErrCde, szErrMsg);
	    MessageBox(Handle, szErrMsg, "Driver Message", MB_OK);
            MyFreeBuffer();
	    DRV_DeviceClose((LONG far *)&DriverHandle);
	    return;
	}
    }

    // Allocate memory for common buffer of 4 channel
    if((hCommonBuf=(USHORT far *)GlobalAlloc(GHND, 
        sizeof(USHORT) * gulConvNum * usChannelCount)) == 0)
    {
	MessageBox(Handle, "Not enough memory for buffer", "High Speed", MB_OK);
        MyFreeBuffer();
	DRV_DeviceClose((LONG far *)&DriverHandle);
	return;
    }

    // Lock down buffer
    if((lpCommonBuf = (USHORT far *)GlobalLock(hCommonBuf)) == 0)
    {
    	MessageBox(Handle, "Not enough memory for buffer ", "High Speed", MB_OK);
        MyFreeBuffer();
	GlobalFree(hCommonBuf);
	DRV_DeviceClose((LONG far *)&DriverHandle);
	return;
    }

    // set 4 buffer to 1 common buffer
    SetMultiToOneBuffer(usEnabledChannel,gulConvNum);

    // Step 3: Enable event feature
    ptEnableEvent.EventType = ADS_EVT_INTERRUPT  |
                              ADS_EVT_BUFCHANGE  |
                              ADS_EVT_TERMINATED |
                              ADS_EVT_OVERRUN;
    ptEnableEvent.Enabled = gwEvtFlag;
    ptEnableEvent.Count   = 1;
    if ((ErrCde = DRV_EnableEvent(DriverHandle,
        (LPT_EnableEvent)&ptEnableEvent)) != 0)
    {
        DRV_GetErrorMessage(ErrCde,(LPSTR)szErrMsg);
        MessageBox(Handle, szErrMsg, "Driver Message", MB_OK);
        MyFreeBuffer(); 
	DRV_DeviceClose((LONG far *)&DriverHandle);
        return;
    }

    // Step 4: call FAOWaveFormStart for start action
    // Default setting - 
    // conversion number = 2048 * 4
    // Enabled Channel = 0,1,2,3
    // pacer rate = 1000 Hz
    // output waveform number = 30

    ptFAOWaveFormStart.TrigSrc    = gwExtTrig;			// triggering
    ptFAOWaveFormStart.SampleRate = gdwPacerRate;		// pacer rate = 1K
    ptFAOWaveFormStart.Count      = gulConvNum * usChannelCount;// DA conversion number
    ptFAOWaveFormStart.WaveCount  = gwWaveFormCount;		// Waveform number
    ptFAOWaveFormStart.Buffer     = (USHORT far *)lpCommonBuf;  // analog output data
    ptFAOWaveFormStart.EnabledChannel     = usEnabledChannel;   // which channel

    if ((ErrCde = DRV_FAOWaveFormStart(DriverHandle,
        (LPT_FAOWaveFormStart)&ptFAOWaveFormStart)) != 0)
    {
        DRV_GetErrorMessage(ErrCde,(LPSTR)szErrMsg);
        MessageBox(Handle, szErrMsg, "Driver Message", MB_OK);
        MyFreeBuffer();
	GlobalUnlock(hCommonBuf);
	GlobalFree(hCommonBuf);
	DRV_DeviceClose((LONG far *)&DriverHandle);
        return;
    }

    // if event feature is enabled , then create one thread.
    if (gwEvtFlag)
    {
        hThreadHandle = CreateThread(0, 0, (LPTHREAD_START_ROUTINE) UserThread,
            0, 0, (LPDWORD)&dwThreadID);
	bThreadloop = TRUE;
    }

    Run->Enabled = FALSE;
    Stop->Enabled = TRUE;     // Enable stop buttons

    // if event feature is enabled 
    // Start up timer
    //
    if (gwEvtFlag)
    {
        Tmr->Enabled = TRUE;
	bRunTimer = TRUE;
    }        
}
//---------------------------------------------------------------------------

void __fastcall TFrmMain::StopClick(TObject *Sender)
{
    //  Stop D/A conversion
    if ((ErrCde = DRV_FAOTerminate(DriverHandle)) != 0)
    {
        DRV_GetErrorMessage(ErrCde, szErrMsg);
        MessageBox(Handle, szErrMsg, "Driver Message", MB_OK);
        MyFreeBuffer();
	GlobalUnlock(hCommonBuf);
	GlobalFree(hCommonBuf);
	DRV_DeviceClose((LONG far *)&DriverHandle);
        return;
    }
}
//---------------------------------------------------------------------------

void __fastcall TFrmMain::TmrTimer(TObject *Sender)
{
    PT_FAOCheck ptFAOCheck;
    USHORT gwActiveBuf = 0;     // return by FAOCheck
    USHORT gwStopped   = 0;     // return by FAOCheck
    ULONG  ulCurrentCount = 0;  // return by FAOCheck
    USHORT gwOverrun   = 0;     // return by FAOCheck
    USHORT gwHalfReady = 0;     // return by FAOCheck
    USHORT gwUnderrun  = 0;
    ULONG  gwTransfered = 0;

    // Get transfer status
    ptFAOCheck.ActiveBuf    = &gwActiveBuf;
    ptFAOCheck.stopped      = &gwStopped;
    ptFAOCheck.CurrentCount = &ulCurrentCount;
    ptFAOCheck.overrun      = &gwOverrun;
    ptFAOCheck.HalfReady    = &gwHalfReady;
   // ptFAOCheck.Underrun     = &gwUnderrun;
    //ptFAOCheck.Transfered   = &gwTransfered;

    if ((ErrCde = DRV_FAOCheck(DriverHandle,(LPT_FAOCheck)&ptFAOCheck)) != 0)
    {
    	DRV_GetErrorMessage(ErrCde, szErrMsg);
	MessageBox(Handle, szErrMsg, "Driver Message", MB_OK);
	MyFreeBuffer();
	GlobalUnlock(hCommonBuf);
	GlobalFree(hCommonBuf);
	DRV_DeviceClose((LONG far *)&DriverHandle);
	return;
    }

    // Display Data
    WaveCountText->Text = ulCurrentCount;

    // if thread finish run stop instruction
    if(!bThreadloop)
    {
        // if stop button then exit A/O ;
        if (gwStopped) {
          // Step 1: Free buffer
          MyFreeBuffer();
          GlobalUnlock(hCommonBuf);
          GlobalFree(hCommonBuf);

          // Step 2: Close driver
          DRV_DeviceClose((LONG far *)&DriverHandle);

          // Stop Timer
          if(bRunTimer)
          {
              Tmr->Enabled = FALSE;
              bRunTimer = FALSE;
          }

          Run->Enabled = TRUE;
          CloseHandle(hThreadHandle);
        }
    }
}
//---------------------------------------------------------------------------

void __fastcall TFrmMain::FormCreate(TObject *Sender)
{
    if (!gwSelectDevice)
    {
        // Select Device
        ErrCde = DRV_SelectDevice(Handle, FALSE, &dwDeviceNum, szDescript);
        if (ErrCde != SUCCESS)
        {
            DRV_GetErrorMessage(ErrCde, szErrMsg);
            MessageBox(Handle, szErrMsg, "Driver Message", MB_OK);
            return;
        }

        gwSelectDevice = TRUE;
        FrmMain->Run->Enabled = TRUE;
    }

    // Show device description to Button text
    DevSel->Caption = szDescript;

    // Initialize Conversion Number
    ltoa(gulConvNum, szBuffer, 10);
    Conv->Text = szBuffer;

    // Initialize Pacer Rate
    ltoa(gdwPacerRate, szBuffer, 10);
    Pacer->Text = szBuffer;

    // Initialize wave form count
    if(gwWaveFormCount == INFINITE) 
        strcpy(szBuffer,"INFINITE");
    else
    	ltoa(gwWaveFormCount, szBuffer, 10);
    WaveCount->Text = szBuffer;

    // Initialize Triggering
    if(gwExtTrig)
        ExtTrig->Checked = True;
    else
        IntTrig->Checked = True;

    // Initialize Message Flag
    if(gwEvtFlag)
        EvtEnable->Checked = True;
    else
        EvtDisable->Checked = True;        
}
//---------------------------------------------------------------------------

void __fastcall TFrmMain::DevSelClick(TObject *Sender)
{
    // Select Device
    ErrCde = DRV_SelectDevice(Handle, FALSE, &dwDeviceNum, szDescript);
    if (ErrCde != SUCCESS)
    {
        DRV_GetErrorMessage(ErrCde,szErrMsg);
        MessageBox(Handle, szErrMsg, "Driver Message", MB_OK);
        return;
    }

    // Show device description to Button text
    DevSel->Caption = szDescript;        
}
//---------------------------------------------------------------------------

void __fastcall TFrmMain::PacerChange(TObject *Sender)
{
    strcpy(szBuffer, Pacer->Text.c_str());
    gdwPacerRate = atol(szBuffer);        
}
//---------------------------------------------------------------------------

void __fastcall TFrmMain::ConvChange(TObject *Sender)
{
    strcpy(szBuffer, Conv->Text.c_str());
    gulConvNum = atol(szBuffer);
}
//---------------------------------------------------------------------------

void __fastcall TFrmMain::WaveCountChange(TObject *Sender)
{
    strcpy(szBuffer, WaveCount->Text.c_str());
    if(!strcmp(szBuffer,"INFINITE"))
        gwWaveFormCount = INFINITE;
    else
        gwWaveFormCount = atol(szBuffer);        
}
//---------------------------------------------------------------------------

void __fastcall TFrmMain::IntTrigClick(TObject *Sender)
{
    gwExtTrig = 0;        
}
//---------------------------------------------------------------------------

void __fastcall TFrmMain::ExtTrigClick(TObject *Sender)
{
    gwExtTrig = 1;        
}
//---------------------------------------------------------------------------

void __fastcall TFrmMain::EvtEnableClick(TObject *Sender)
{
    gwEvtFlag = 1;        
}
//---------------------------------------------------------------------------

void __fastcall TFrmMain::EvtDisableClick(TObject *Sender)
{
    gwEvtFlag = 0;        
}
//---------------------------------------------------------------------------