addmabm.c

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

        // Insert Item
        lvItem.mask = LVIF_TEXT;
        lvItem.pszText = szBuff;
        dwPhyChan = gwStartChl;
		gwMaxLogChanNum = GetMaxLogChanNum(&Devconfig_AI,&DevFeatures);

        for(i = 0; i < min(gwNumChl,gwMaxLogChanNum); i++, dwPhyChan++)
        {
            if (dwPhyChan >= DevFeatures.usMaxAISiglChl)
            {
               dwPhyChan -= DevFeatures.usMaxAISiglChl;
            }
            lvItem.iItem = i;
            lvItem.iSubItem = 0;
            wsprintf(szBuff, "Chan %d", dwPhyChan);
            ListView_InsertItem(hGainListWnd, &lvItem);
            lvItem.iSubItem = 1;
            wsprintf(szBuff, "%s", DevFeatures.glGainList[gwGain[PhyChanToLogChan(&Devconfig_AI,dwPhyChan)]].szGainStr);
            ListView_SetItem(hGainListWnd, &lvItem);
            lvItem.iSubItem = 2;

            if (dwPhyChan < 32)
            {  // The physical channel number between 0 and 31
               
               if (Devconfig_AI.ulChanConfig & (1 << dwPhyChan))
               {
                  wsprintf(szBuff, "%s", "Differential");
                  if (dwPhyChan % 2 == 0)
                  {
                     dwPhyChan++;
                  }
                  wsprintf(szTmpBuff, "Chan %d,%d", dwPhyChan-1, dwPhyChan);
                  ListView_SetItemText(hGainListWnd,  i, 0, szTmpBuff);
               }
               else
               {
                  wsprintf(szBuff, "%s", "Single-Ended");
               }
            }
            else
            {  // The physical channel number between 32 and 63
               
               if (Devconfig_AI.ulChanConfigEx[0] & (1 << (dwPhyChan-32)))
               {
                  wsprintf(szBuff, "%s", "Differential");
                  if (dwPhyChan % 2 == 0)
                  {
                     dwPhyChan++;
                  }
                  wsprintf(szTmpBuff, "Chan %d,%d", dwPhyChan-1, dwPhyChan);
                  ListView_SetItemText(hGainListWnd,  i, 0, szTmpBuff);
               }
               else
               {
                  wsprintf(szBuff, "%s", "Single-Ended");
               }
            }

            ListView_SetItem(hGainListWnd, &lvItem);
        }

        // Step 6: Close device
        DRV_DeviceClose((LONG far *)&DriverHandle);

        return TRUE;

    case WM_COMMAND :
        switch (LOWORD(wParam))
        {
        case IDOK :
        case IDCANCEL :
            EndDialog(hDlg, 0);
            return TRUE;

        case IDC_CMB_GAIN :
            if (HIWORD(wParam) == CBN_CLOSEUP)
            {
                i = (int)SendDlgItemMessage(hDlg, LOWORD(wParam),
                    CB_GETCURSEL, 0, 0);
                if (i != CB_ERR)
                {
                    if (iPos>=0 && iPos<gwNumChl)
                    {
                        gwGain[(iPos+PhyChanToLogChan(&Devconfig_AI,gwStartChl)) % gwMaxLogChanNum] = i;
                        lvItem.mask = LVIF_TEXT;
                        lvItem.pszText = szBuff;
                        lvItem.iItem = iPos;
                        lvItem.iSubItem = 1;
                        wsprintf(szBuff, "%s", DevFeatures.glGainList[i].szGainStr);
                        ListView_SetItem(GetDlgItem(hDlg, IDC_LST_GAIN), &lvItem);
                    }
                }
            }
            return TRUE;
        }

        break;

    case WM_NOTIFY:
        switch (LOWORD(wParam))
        {
        case IDC_LST_GAIN :
            lpnmhdr = (LPNMHDR) lParam;
            if (lpnmhdr->code == NM_CLICK)
            {
                lpnmitem = (LPNMITEMACTIVATE) lParam;
                iPos = lpnmitem->iItem;
                if (iPos>=0 && iPos<gwNumChl)
                {
                    SendDlgItemMessage(hDlg, IDC_CMB_GAIN,
                        CB_SETCURSEL, gwGain[(iPos+PhyChanToLogChan(&Devconfig_AI,gwStartChl)) % gwMaxLogChanNum], 0);
                }
            }
            return TRUE;
        }
    }

    return FALSE;
}

/******************************************************************************
    FUNCTION: ConfigDlgProc(HWND, unsigned, WPARAM, LPARAM)

    PURPOSE:  Processes dialog box messages for configuration
******************************************************************************/

BOOL FTYPE ConfigDlgProc(hDlg, message, wParam, lParam)
HWND hDlg;                              /* window handle                   */
unsigned message;                       /* type of message                 */
WPARAM wParam;                          /* additional information          */
LPARAM lParam;                          /* additional information          */
{
    int     i;
    char    szBuffer[80];

    switch (message)
    {
    case WM_INITDIALOG :
       
        // Step 1: Select Device
        ErrCde = DRV_SelectDevice( hDlg, FALSE, &dwDeviceNum, szBuffer);
        if (ErrCde != SUCCESS)
        {
            DRV_GetErrorMessage(ErrCde,(LPSTR)szErrMsg);
            MessageBox(hWnd,(LPCSTR)szErrMsg,"Driver Message",MB_OK);
            return 0;
        }

        // Step 2: Open Device
        ErrCde = DRV_DeviceOpen(dwDeviceNum, (LONG *)&DriverHandle);
        if (ErrCde != SUCCESS)
        {
            DRV_GetErrorMessage(ErrCde,(LPSTR)szErrMsg);
            MessageBox(hWnd,(LPCSTR)szErrMsg,"Driver Message",MB_OK);
            return 0;
        }

        // Step 3: Get device features
        ptDevFeatures.buffer = (LPDEVFEATURES)&DevFeatures;
        ptDevFeatures.size = sizeof(DEVFEATURES);
        if ((ErrCde = DRV_DeviceGetFeatures(DriverHandle,
            (LPT_DeviceGetFeatures)&ptDevFeatures)) != SUCCESS)
        {
            DRV_GetErrorMessage(ErrCde,(LPSTR)szErrMsg);
            MessageBox(hWnd,(LPCSTR)szErrMsg,"Driver Message",MB_OK);
            DRV_DeviceClose((LONG far *)&DriverHandle);
            return 0;
        }

        // Step 4: Initialize Input Range List Combobox with device features
        if (DevFeatures.usNumGain != 0)
        {
            EnableWindow(GetDlgItem(hDlg, IDC_INPRANGE), TRUE);
            for (i = 0; i < (int)DevFeatures.usNumGain; i ++)
                SendDlgItemMessage(hDlg, IDC_INPRANGE, CB_ADDSTRING, 0,
                (LPARAM)((LPSTR)(DevFeatures.glGainList[i].szGainStr)));

            SendDlgItemMessage(hDlg, IDC_INPRANGE, CB_SELECTSTRING, (WPARAM)(-1),
                (LPARAM)((LPSTR)(DevFeatures.glGainList[gwGainCode].szGainStr)));
        }
        else
        {
            EnableWindow(GetDlgItem(hDlg, IDC_INPRANGE), FALSE);
            SendDlgItemMessage(hDlg, IDC_INPRANGE, CB_RESETCONTENT,
                0, (LPARAM)((LPSTR)0));
        }

        // Initialize Conversion Number
        ultoa(gulConvNum, szBuffer, 10);

        SendDlgItemMessage(hDlg, IDC_CONVERSION, EM_REPLACESEL, 0,
            (LPARAM)((LPSTR)szBuffer));

        // Initialize Pacer Rate
        ultoa(gdwPacerRate, szBuffer, 10);

        SendDlgItemMessage(hDlg, IDC_PACER, EM_REPLACESEL, 0,
            (LPARAM)((LPSTR)szBuffer));

        if (gwClockSrc)
            EnableWindow(GetDlgItem(hDlg, IDC_PACER), FALSE);
        else
            EnableWindow(GetDlgItem(hDlg, IDC_PACER), TRUE);

        // Initialize Start Channel
        itoa((int)gwStartChl, szBuffer, 10);

        SendDlgItemMessage(hDlg, IDC_ESTART, EM_REPLACESEL, 0,
            (LPARAM)((LPSTR)szBuffer));

        // Initialize Stop Channel
        itoa((int)gwNumChl, szBuffer, 10);

        SendDlgItemMessage(hDlg, IDC_ESTOP, EM_REPLACESEL, 0,
            (LPARAM)((LPSTR)szBuffer));

        // Initialize Delay Count
        itoa((int)gwDelayCnt, szBuffer, 10);

        SendDlgItemMessage(hDlg, IDC_DELAYCNT, EM_REPLACESEL, 0,
            (LPARAM)((LPSTR)szBuffer));

        // Initialize Event Count
        itoa((int)gulEventCount, szBuffer, 10);
        SendDlgItemMessage(hDlg, IDC_EVENTCOUNT, EM_REPLACESEL, 0,
            (LPARAM)((LPSTR)szBuffer));
       
        // Initialize Overrun time
        itoa((int)gulOverrunTime, szBuffer, 10);
        SendDlgItemMessage(hDlg, IDC_OVERRUNTIME, EM_REPLACESEL, 0,
            (LPARAM)((LPSTR)szBuffer));
        
        // Initialize Clock Source
        CheckRadioButton(hDlg, IDC_INTTRIG, IDC_EXTTRIG_1,
            IDC_INTTRIG + gwClockSrc);

        // Initialize trigger edge
        CheckRadioButton(hDlg, IDC_EDGERISE, IDC_EDGEFALL,
            (gwTrigEdge)?IDC_EDGEFALL:IDC_EDGERISE);

        // Initialize trigger source type
		  CheckRadioButton(hDlg, IDC_DIGTYPE, IDC_ANGTYPE_3,
            IDC_DIGTYPE + gwSRCType );

        if( gwTrigMode )
        {
           	EnableWindow(GetDlgItem(hDlg, IDC_DIGTYPE), TRUE);
			EnableWindow(GetDlgItem(hDlg, IDC_ANGTYPE_0), TRUE);
			EnableWindow(GetDlgItem(hDlg, IDC_ANGTYPE_1), TRUE);
			EnableWindow(GetDlgItem(hDlg, IDC_ANGTYPE_2), TRUE);
			EnableWindow(GetDlgItem(hDlg, IDC_ANGTYPE_3), TRUE);
            EnableWindow(GetDlgItem(hDlg, IDC_EDGERISE), TRUE);
			EnableWindow(GetDlgItem(hDlg, IDC_EDGEFALL), TRUE);
        }
        else
        {
            EnableWindow(GetDlgItem(hDlg, IDC_DIGTYPE), FALSE);
			EnableWindow(GetDlgItem(hDlg, IDC_ANGTYPE_0), FALSE);
			EnableWindow(GetDlgItem(hDlg, IDC_ANGTYPE_1), FALSE);
			EnableWindow(GetDlgItem(hDlg, IDC_ANGTYPE_2), FALSE);
			EnableWindow(GetDlgItem(hDlg, IDC_ANGTYPE_3), FALSE);
            EnableWindow(GetDlgItem(hDlg, IDC_EDGERISE), FALSE);
			EnableWindow(GetDlgItem(hDlg, IDC_EDGEFALL), FALSE);
        }
		  if ( 3==gwTrigMode )
        {
		    EnableWindow(GetDlgItem(hDlg,IDC_CYCLIC), FALSE);
            EnableWindow(GetDlgItem(hDlg,IDC_NONCYCLIC), FALSE);
        }
        else
        {
		    EnableWindow(GetDlgItem(hDlg,IDC_CYCLIC), TRUE);
            EnableWindow(GetDlgItem(hDlg,IDC_NONCYCLIC), TRUE);
        }

        EnableWindow(GetDlgItem(hDlg, IDC_TRIGSRC1), FALSE);
        EnableWindow(GetDlgItem(hDlg, IDC_TRIGSRC2), FALSE);
        
        // Initialize Trigger Voltage
        sprintf(szBuffer,"%6.3f" ,gwTrigVol);
        SendDlgItemMessage(hDlg, IDC_TRIGVOLTAGE, EM_REPLACESEL, 0,
            (LPARAM)((LPSTR)szBuffer));

		if(gwSRCType)
		{
			EnableWindow(GetDlgItem(hDlg, IDC_TRIGVOLTAGE), TRUE);
			EnableWindow(GetDlgItem(hDlg, IDC_TEXTVOL), TRUE);
			EnableWindow(GetDlgItem(hDlg, IDC_TEXTV), TRUE);
		}
		else
		{
			EnableWindow(GetDlgItem(hDlg, IDC_TRIGVOLTAGE), FALSE);
			EnableWindow(GetDlgItem(hDlg, IDC_TEXTVOL), FALSE);
			EnableWindow(GetDlgItem(hDlg, IDC_TEXTV), FALSE);
		}
        // Initialize Repeated Mode
        CheckRadioButton(hDlg, IDC_CYCLIC, IDC_NONCYCLIC,
            (gwCyclicMode)?IDC_CYCLIC:IDC_NONCYCLIC);

        // Initialize Trigger Mode
        CheckRadioButton(hDlg, IDC_PACERTRIG, IDC_ABOUTTRIG, (IDC_PACERTRIG + gwTrigMode));
		if((gwTrigMode == 2) || (gwTrigMode == 3))
			EnableWindow(GetDlgItem(hDlg,IDC_DELAYCNT), TRUE);
		else
			EnableWindow(GetDlgItem(hDlg,IDC_DELAYCNT), FALSE);

        // Initialize Trigger Source
        CheckRadioButton(hDlg, IDC_TRIGSRC1, IDC_TRIGSRC2,
            (gwExtTrig)?IDC_TRIGSRC2:IDC_TRIGSRC1);

        // Initialize Data Type
        CheckRadioButton(hDlg, IDC_DATAUSHORT, IDC_DATAFLOAT,
            (gwDataType)?IDC_DATAFLOAT:IDC_DATAUSHORT);

        // Initialize Message Flag
		if(gwEvtFlag)
			CheckDlgButton(hDlg,IDC_EnableEvent,TRUE);
		else
			CheckDlgButton(hDlg,IDC_EnableEvent,FALSE);
		
		
		

        SendDlgItemMessage(hDlg, IDC_CONVINT, EM_REPLACESEL, 0,
            (LPARAM)((LPSTR)szBuffer));

        // Initialize gain table option
        if (gwGainList)
        {
            CheckRadioButton(hDlg, IDC_OVERALLGAIN, IDC_GAINARRAY,
                IDC_GAINARRAY);
            EnableWindow(GetDlgItem(hDlg, IDC_INPRANGE), FALSE);
            EnableWindow(GetDlgItem(hDlg, IDC_GAINLIST), TRUE);
        }
        else
        {
            CheckRadioButton(hDlg, IDC_OVERALLGAIN, IDC_GAINARRAY,
                IDC_OVERALLGAIN);
            EnableWindow(GetDlgItem(hDlg, IDC_INPRANGE), TRUE);
            EnableWindow(GetDlgItem(hDlg, IDC_GAINLIST), FALSE);
        }

        // Ininialize event check box
		  EnableWindow(GetDlgItem(hDlg,(IDC_BUFFERCHANGE)),TRUE);
		  if( bBufferChange )
        {
		      CheckDlgButton(hDlg,(IDC_BUFFERCHANGE),TRUE);
        }
		  else
        {
		      CheckDlgButton(hDlg,(IDC_BUFFERCHANGE),FALSE);
        }

		  // EnableWindow(GetDlgItem(hDlg,(IDC_BUFFERCHANGE)),TRUE);
		  // Terminate
        if( bTerminate )
        {
		      CheckDlgButton(hDlg,(IDC_TERMINATE),TRUE);
        }
		  else