mainform.cpp

16 relay output channels and 16 isolated digital input channels LED indicators to show activated

    gulIntCounter = 0;
    gulBfChgCounter = 0;
    gulOverrunCounter = 0;

    while( bThreadloop )
    {
        ptCheckEvent.EventType = &usEventType;
        if ( gulOverrunTime==0 )
        {
            ptCheckEvent.Milliseconds = INFINITE;
        }
        else
        {
            ptCheckEvent.Milliseconds = gulOverrunTime;
        }


        if ((ErrCde = DRV_CheckEvent(DriverHandle,
            (LPT_CheckEvent)&ptCheckEvent)) != 0)
        {
           Application->MessageBox("Check Event Error !","Thread Message",MB_OK);
        }

        // Process interrupt event
        if (usEventType & ADS_EVT_INTERRUPT)
        {
            InterruptEvent();
        }

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

        // Process overrun event
        if (usEventType & ADS_EVT_OVERRUN)
        {
            OverrunEvent();
        }

        // Process terminate event
        if (usEventType & ADS_EVT_TERMINATED)
        {
            TerminateEvent();
            return;
        }
        frmDisplay->Canvas->Lock();
        sprintf( szCounter, "Interrupt Counter = %4d", gulIntCounter );
        frmDisplay->Canvas->TextOut(20, 40, szCounter );
        sprintf( szData, "Buffer change Counter = %4d", gulBfChgCounter );
        frmDisplay->Canvas->TextOut( 20, 60, szData );
        sprintf( szData, "Overrun Counter = %4d", gulOverrunCounter );
        frmDisplay->Canvas->TextOut( 20, 80, szData );
        frmDisplay->Canvas->Unlock();
   }

}




void __fastcall TfrmMain::radGainListClick(TObject *Sender)
{
   butGainList->Enabled = true;
   cmbGain->Enabled = false;
}
//---------------------------------------------------------------------------

void __fastcall TfrmMain::radOverallClick(TObject *Sender)
{
   butGainList->Enabled = false;
   cmbGain->Enabled = true;
     for(int i=0;i<64;i++)
       gwGain[i]=cmbGain->ItemIndex;

}
//---------------------------------------------------------------------------

void __fastcall TfrmMain::butGainListClick(TObject *Sender)
{
    usStartChan = cmbChannel->ItemIndex;
    usChanNum =  editScanNum->Text.ToInt();

    frmGainList->ShowModal();
}
//---------------------------------------------------------------------------


void TfrmMain::InterruptEvent()
{
   //TODO: Add your source code here
   gulIntCounter++;

}

void TfrmMain::BufChangeEvent()
{
    //TODO: Add your source code here
    int i;
    char szData[32];

   gulBfChgCounter++;
   gwCyclicCount = gulBfChgCounter/2;

   // Get DMA transfer status
   ptFAICheck.ActiveBuf = &gwActiveBuf;
   ptFAICheck.stopped   = &gwStopped;
   ptFAICheck.retrieved = &gulRetrieved;
   ptFAICheck.overrun   = &gwOverrun;
   ptFAICheck.HalfReady = &gwHalfReady;

   if ((ErrCde = DRV_FAICheck(DriverHandle,
       (LPT_FAICheck)&ptFAICheck)) != 0)
   {
       DRV_GetErrorMessage(ErrCde,(LPSTR)szErrMsg);
       Application->MessageBox((LPCSTR)szErrMsg,"Driver Message",MB_OK);
       DRV_FAIStop( DriverHandle );
       DRV_DeviceClose((LONG *)&DriverHandle );
       GlobalFree( hUserBuf ); 
       return ;
   }
 
    // When call DRV_FAITransfer( ), the overrun event flag will be cleaned,
    // otherwise, the application will receive overrun event continously.
    // Get real voltage of buffer from driver
    ptFAITransfer.ActiveBuf = 0;   // single buffer
    ptFAITransfer.DataType = gwDataType;

    if ( 2==gwHalfReady )
    {
       ptFAITransfer.start = gulConvNum / 2;
    }
    else
    {
       ptFAITransfer.start = 0;
    }

    if ( gulConvNum >= 20 )
    {
       ptFAITransfer.count = 10; // For demo, we only get few data
    }
    else
    {
       ptFAITransfer.count = 1;  // For demo, we only get few data
    }
    ptFAITransfer.overrun  = &gwOverrun;

    if ((ErrCde = DRV_FAITransfer(DriverHandle,
        (LPT_FAITransfer)&ptFAITransfer)) != 0)
    {
        DRV_GetErrorMessage(ErrCde,(LPSTR)szErrMsg);
        Application->MessageBox((LPCSTR)szErrMsg,"Thread Message",MB_OK);
        return ;
    }
    frmDisplay->Canvas->Lock();
    frmDisplay->Canvas->Font->Color = clBlue;
    for ( i=0; i<10; i++ )
    {
        if ( gwDataType )
        {
           sprintf( szData, "Buf[ %07d ]=%8.6f", i+ptFAITransfer.start,
              ((float*)ptFAITransfer.DataBuffer)[i] );
        }
        else
        {
           sprintf( szData, "Buf[ %07d ]=%   X", i+ptFAITransfer.start,
              ((USHORT *)ptFAITransfer.DataBuffer)[i] );                                 
        }
        frmDisplay->Canvas->TextOutA( 20, 120+ 20*i, szData );
    }
        frmDisplay->Canvas->Unlock();

}

void TfrmMain::OverrunEvent()
{
        //TODO: Add your source code here
    gulOverrunCounter++;
    DRV_ClearOverrun(  DriverHandle );
}

void TfrmMain::TerminateEvent()
{
        //TODO: Add your source code here
    char szData[40];

   // Get real voltage of buffer from driver
   ptFAITransfer.ActiveBuf = 0;   // single buffer
   ptFAITransfer.DataType = gwDataType;
   ptFAITransfer.start    = 0;
   ptFAITransfer.count    = gulConvNum;
   ptFAITransfer.overrun  = &gwOverrun;

   if ((ErrCde = DRV_FAITransfer(DriverHandle,
       (LPT_FAITransfer)&ptFAITransfer)) != 0)
   {
       DRV_GetErrorMessage(ErrCde,(LPSTR)szErrMsg);
       Application->MessageBox((LPCSTR)szErrMsg,"Thread Message",MB_OK);

   }

   // Display data
   frmDisplay->Show();
   frmDisplay->lstBuffer->Clear();
   frmDisplay->lstBuffer->Show();

    for ( int i=0; i<gwChlNum; i++ )
    {
        if ( gwDataType )
        {
           sprintf( szData, "buffer[ %d ] = %8.6f", i,
              ((float*)ptFAITransfer.DataBuffer)[i] );
        }
        else
        {
           sprintf( szData, "buffer[ %d ] = %X", i,
              ((USHORT *)ptFAITransfer.DataBuffer)[i] );
        }
        frmDisplay->lstBuffer->Items->Add(szData);
    }

   // Free buffer
   GlobalUnlock(hDisplayBuf);
   GlobalFree(hDisplayBuf);
   GlobalUnlock(hUserBuf);
   GlobalFree( hUserBuf);
   // Close driver
     ErrCde = DRV_DeviceClose((LONG far *)&DriverHandle);
    if (ErrCde != SUCCESS)
    {
        DRV_GetErrorMessage(ErrCde,(LPSTR)szErrMsg);
        Application->MessageBox((char *)szErrMsg, "Driver Message", MB_OK);
     }

    butStop->Enabled = false;
    butStart->Enabled = true;
    lstDevice->Enabled = true;
    editScanNum->Enabled = true;
    cmbGain->Enabled = true;
    cmbChannel->Enabled = true;
    butExit->Enabled  = true;
 

}
void __fastcall TfrmMain::radInternalClick(TObject *Sender)
{
        gwExtTrig=0;

}
//---------------------------------------------------------------------------

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

void __fastcall TfrmMain::radDelayClick(TObject *Sender)
{
   editDelayCount->Enabled=true;
   radFalling->Enabled = true;
   radRising->Enabled = true;
   radDigital->Enabled = true;
   radAI0->Enabled = true;
   radAI1->Enabled = true;
   radAI2->Enabled = true;
   radAI3->Enabled = true;
   radExternal->Checked=true;
   gwTrigMode=2;
   gwTrigEdge=1;
   radFalling->Checked = true;
   radCyclic->Enabled = true;
   radNonCyclic->Enabled = true;
}
//---------------------------------------------------------------------------

void __fastcall TfrmMain::radPostClick(TObject *Sender)
{
   editDelayCount->Enabled=false;
   radFalling->Enabled = true;
   radRising->Enabled = true;
    radDigital->Enabled = true;
   radAI0->Enabled = true;
   radAI1->Enabled = true;
   radAI2->Enabled = true;
   radAI3->Enabled = true;
   radExternal->Checked=true;
   gwTrigMode=1;
   gwTrigEdge=0;
   radRising->Checked = true;
   radCyclic->Enabled = true;
   radNonCyclic->Enabled = true;


}
//---------------------------------------------------------------------------

void __fastcall TfrmMain::radAboutClick(TObject *Sender)
{
   editDelayCount->Enabled=true;
   radFalling->Enabled = true;
   radRising->Enabled = true;
    radDigital->Enabled = true;
   radAI0->Enabled = true;
   radAI1->Enabled = true;
   radAI2->Enabled = true;
   radAI3->Enabled = true;
   radExternal->Checked=true;
   gwTrigMode=3;
   gwTrigEdge=0;
   radRising->Checked = true;
   radCyclic->Enabled = false;
   radNonCyclic->Enabled = false;
}

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

void __fastcall TfrmMain::radPacerClick(TObject *Sender)
{
   editDelayCount->Enabled=false;
   radFalling->Enabled = false;
   radRising->Enabled = false;
    radDigital->Enabled = false;
   radAI0->Enabled = false;
   radAI1->Enabled = false;
   radAI2->Enabled = false;
   radAI3->Enabled = false;
   radInternal->Checked = true;
   gwTrigMode=0;
   radCyclic->Enabled = true;
   radNonCyclic->Enabled = true;
}
//---------------------------------------------------------------------------

void __fastcall TfrmMain::radClockInternalClick(TObject *Sender)
{
    editPacerRate->Enabled = true;
    gwClockSrc = 0;
}
//---------------------------------------------------------------------------

void __fastcall TfrmMain::radClockExternal0Click(TObject *Sender)
{
     editPacerRate->Enabled = false;
     gwClockSrc = 1;
}
//---------------------------------------------------------------------------

void __fastcall TfrmMain::radClockExternal1Click(TObject *Sender)
{
     editPacerRate->Enabled = false;
     gwClockSrc =2;
}
//---------------------------------------------------------------------------

void __fastcall TfrmMain::radDigitalClick(TObject *Sender)
{
   editTrigVolt->Enabled = false;
   gwSRCType = 0;
}
//---------------------------------------------------------------------------

void __fastcall TfrmMain::radAI0Click(TObject *Sender)
{
   editTrigVolt->Enabled = true;
   gwSRCType = 1;
}
//---------------------------------------------------------------------------

void __fastcall TfrmMain::radAI1Click(TObject *Sender)
{
   editTrigVolt->Enabled = true;
   gwSRCType = 2;
}
//---------------------------------------------------------------------------

void __fastcall TfrmMain::radAI2Click(TObject *Sender)
{
   editTrigVolt->Enabled = true;
    gwSRCType = 3;
}
//---------------------------------------------------------------------------

void __fastcall TfrmMain::radAI3Click(TObject *Sender)
{
   editTrigVolt->Enabled = true;
    gwSRCType = 4;       
}
//---------------------------------------------------------------------------


void __fastcall TfrmMain::radRisingClick(TObject *Sender)
{
    gwTrigEdge=0;
        
}
//---------------------------------------------------------------------------

void __fastcall TfrmMain::radFallingClick(TObject *Sender)
{

   gwTrigEdge = 1;
}
//---------------------------------------------------------------------------

void __fastcall TfrmMain::radCyclicClick(TObject *Sender)
{
     gwCyclicMode = 1;

}
//---------------------------------------------------------------------------

void __fastcall TfrmMain::radNonCyclicClick(TObject *Sender)
{
     gwCyclicMode = 0;

}
//---------------------------------------------------------------------------

void __fastcall TfrmMain::radRawDataClick(TObject *Sender)
{
      gwDataType = 0;
        
}
//---------------------------------------------------------------------------

void __fastcall TfrmMain::radVoltageClick(TObject *Sender)
{
     gwDataType = 1;
}

void __fastcall TfrmMain::cmbGainChange(TObject *Sender)
{
   for(int i=0;i<64;i++)
     gwGain[i]= cmbGain->ItemIndex;
        
}
//---------------------------------------------------------------------------






void __fastcall TfrmMain::FormClose(TObject *Sender, TCloseAction &Action)
{
    if( butStop->Enabled )
        butStopClick(Sender);
}
//---------------------------------------------------------------------------