formmain.cpp

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

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

#include <vcl.h>
#pragma hdrstop

#include "FORMMAIN.h"
#include <stdio.h>
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
TfrmMain *frmMain;
//---------------------------------------------------------------------------
__fastcall TfrmMain::TfrmMain(TComponent* Owner)
        : TForm(Owner)
{
}
//---------------------------------------------------------------------------

/*************************************************************
 * Function: Handle the error code. If the input error code > 0,
 *           it means some error apperent.  This function can
 *           show the error message to a message box and stop
 *           this application.
 * Input:    The error code.
 * return:   none
 *************************************************************/
int DoesErr(long lErrCode)
{
    char szErrMsg[100];

    // Check the pressed error code
    if (lErrCode != 0)
    {
        DRV_GetErrorMessage(lErrCode, szErrMsg);
	Application->MessageBox(szErrMsg, "Error!!", MB_OK);
	return 1;
    }
    else
        return 0;
}

void __fastcall TfrmMain::FormCreate(TObject *Sender)
{
    btnSelectDeviceClick(Sender);
}
//---------------------------------------------------------------------------

void __fastcall TfrmMain::btnSelectDeviceClick(TObject *Sender)
{
    int i;

    DRV_SelectDevice(Handle, True, &lDeviceNum, szDescription);
    labDeviceName->Caption = szDescription;
    // Open device to get feature
    lErrCde = DRV_DeviceOpen(lDeviceNum, &lDeviceHandle);
    if ( DoesErr(lErrCde))
        return;

    ptDevGetFeatures.buffer = &ptDevFeatures;
    ptDevGetFeatures.size = sizeof(ptDevFeatures);

    lErrCde = DRV_DeviceGetFeatures(lDeviceHandle, &ptDevGetFeatures);
    if ( DoesErr(lErrCde))
    {
        DRV_DeviceClose(&lDeviceHandle);
        return;
    }

    MaxAOChannel = ptDevFeatures.usMaxAOChl;

    DRV_DeviceClose(&lDeviceHandle);

    if (chkSyncAOEnable->Checked)
    {
        optAsyncEnable0->Enabled = False;
	optAsyncEnable1->Enabled = False;
	optAsyncEnable2->Enabled = False;
	optAsyncEnable3->Enabled = False;
	optAsyncEnable4->Enabled = False;
	optAsyncEnable5->Enabled = False;
	optAsyncEnable6->Enabled = False;
	optAsyncEnable7->Enabled = False;

        for (i = 0; i <= 7; i++)
        {
            if (i < MaxAOChannel)
            {
                switch (i)
                {
                    case 0 : chkSyncEnable0->Enabled = True; break;
                    case 1 : chkSyncEnable1->Enabled = True; break;
                    case 2 : chkSyncEnable2->Enabled = True; break;
                    case 3 : chkSyncEnable3->Enabled = True; break;
                    case 4 : chkSyncEnable4->Enabled = True; break;
                    case 5 : chkSyncEnable5->Enabled = True; break;
                    case 6 : chkSyncEnable6->Enabled = True; break;
                    case 7 : chkSyncEnable7->Enabled = True; break;
                }
            }
            else
            {
                switch (i)
                {
                    case 0 : chkSyncEnable0->Enabled = False; break;
                    case 1 : chkSyncEnable1->Enabled = False; break;
                    case 2 : chkSyncEnable2->Enabled = False; break;
                    case 3 : chkSyncEnable3->Enabled = False; break;
                    case 4 : chkSyncEnable4->Enabled = False; break;
                    case 5 : chkSyncEnable5->Enabled = False; break;
                    case 6 : chkSyncEnable6->Enabled = False; break;
                    case 7 : chkSyncEnable7->Enabled = False; break;
                }
            }
        }
    }
    else
    {
        chkSyncEnable0->Enabled = False;
	chkSyncEnable1->Enabled = False;
	chkSyncEnable2->Enabled = False;
	chkSyncEnable3->Enabled = False;
	chkSyncEnable4->Enabled = False;
	chkSyncEnable5->Enabled = False;
	chkSyncEnable6->Enabled = False;
	chkSyncEnable7->Enabled = False;

        for (i = 0; i <= 7; i++)
        {
            if (i < MaxAOChannel)
            {
                switch (i)
                {
                    case 0 : optAsyncEnable0->Enabled = True; break;
                    case 1 : optAsyncEnable1->Enabled = True; break;
                    case 2 : optAsyncEnable2->Enabled = True; break;
                    case 3 : optAsyncEnable3->Enabled = True; break;
                    case 4 : optAsyncEnable4->Enabled = True; break;
                    case 5 : optAsyncEnable5->Enabled = True; break;
                    case 6 : optAsyncEnable6->Enabled = True; break;
                    case 7 : optAsyncEnable7->Enabled = True; break;
                }
            }
            else
            {
                switch (i)
                {
                    case 0 : optAsyncEnable0->Enabled = False; break;
                    case 1 : optAsyncEnable1->Enabled = False; break;
                    case 2 : optAsyncEnable2->Enabled = False; break;
                    case 3 : optAsyncEnable3->Enabled = False; break;
                    case 4 : optAsyncEnable4->Enabled = False; break;
                    case 5 : optAsyncEnable5->Enabled = False; break;
                    case 6 : optAsyncEnable6->Enabled = False; break;
                    case 7 : optAsyncEnable7->Enabled = False; break;
                }
            }
        }
    }
}
//---------------------------------------------------------------------------

void __fastcall TfrmMain::ScanTimerTimer(TObject *Sender)
{
    int i;
    bool s;
    char szErrMsg[100];

    if (chkSyncAOEnable->Checked)
    {
        for (i = 0; i <= MaxAOChannel; i++)
        {
      	    s = False;
            switch(i)
            {
                case 0 : if (chkSyncEnable0->Checked) s = True; break;
                case 1 : if (chkSyncEnable1->Checked) s = True; break;
                case 2 : if (chkSyncEnable2->Checked) s = True; break;
                case 3 : if (chkSyncEnable3->Checked) s = True; break;
                case 4 : if (chkSyncEnable4->Checked) s = True; break;
                case 5 : if (chkSyncEnable5->Checked) s = True; break;
                case 6 : if (chkSyncEnable6->Checked) s = True; break;
                case 7 : if (chkSyncEnable7->Checked) s = True; break;
            }
            if (s)
            {
                if (optVoltageOut->Checked)
                {
		    ptAOVoltageOut.chan = i;
		    ptAOVoltageOut.OutputValue = OutputValue[OutputIndex];
		    lErrCde = DRV_AOVoltageOut(lDeviceHandle, &ptAOVoltageOut);
                }
		else
                {
		    ptAOCurrentOut.chan = i;
		    ptAOCurrentOut.OutputValue = OutputValue[OutputIndex];
		    lErrCde = DRV_AOCurrentOut(lDeviceHandle, &ptAOCurrentOut);
                }
                if( lErrCde !=0)
                {
                    ScanTimer->Enabled=false;
                    DRV_GetErrorMessage(lErrCde, szErrMsg);
                    Application->MessageBox(szErrMsg, "Error!!", MB_OK);
		    cmdStopClick(NULL);
		    return;
                }
           }
        }
        lErrCde = DRV_WriteSyncAO(lDeviceHandle);
        if( lErrCde !=0)
        {
             ScanTimer->Enabled=false;
             DRV_GetErrorMessage(lErrCde, szErrMsg);
             Application->MessageBox(szErrMsg, "Error!!", MB_OK);
	     cmdStopClick(NULL);
	     return;
        }
    }
    else
    {
        for (i = 0; i < MaxAOChannel; i++)
        {
      	    s = False;
      	    switch (i)
            {
                case 0 : if (optAsyncEnable0->Checked) s = True; break;
                case 1 : if (optAsyncEnable1->Checked) s = True; break;
                case 2 : if (optAsyncEnable2->Checked) s = True; break;
      	        case 3 : if (optAsyncEnable3->Checked) s = True; break;
                case 4 : if (optAsyncEnable4->Checked) s = True; break;
                case 5 : if (optAsyncEnable5->Checked) s = True; break;
                case 6 : if (optAsyncEnable6->Checked) s = True; break;
                case 7 : if (optAsyncEnable7->Checked) s = True; break;
            }
            if (s)
            {
		if (optVoltageOut->Checked)
                {
		    ptAOVoltageOut.chan = i;
		    ptAOVoltageOut.OutputValue = OutputValue[OutputIndex];
		    lErrCde = DRV_AOVoltageOut(lDeviceHandle, &ptAOVoltageOut);
                }
		else
                {
                    ptAOCurrentOut.chan = i;
		    ptAOCurrentOut.OutputValue = OutputValue[OutputIndex];
		    lErrCde = DRV_AOCurrentOut(lDeviceHandle, &ptAOCurrentOut);
		}
                if( lErrCde !=0)
                {
                    ScanTimer->Enabled=false;
                    DRV_GetErrorMessage(lErrCde, szErrMsg);
                    Application->MessageBox(szErrMsg, "Error!!", MB_OK);
		    cmdStopClick(NULL);
		    return;
                }

            }
        }
    }
    editOutput->Text = Format("%.3f", ARRAYOFCONST((OutputValue[OutputIndex])));
    OutputIndex ++;
    if (OutputIndex > 3)
        OutputIndex = 0;
}
//---------------------------------------------------------------------------

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