pulsepwm.c

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

      case IDC_BTNCHGOK :
         
         SendDlgItemMessage(hDlg, IDC_CHGPERIOD, WM_GETTEXT, 13,
            (LPARAM)(LPSTR)szBuffer) ;         
		if(!InvalidStrToNum((const char *)szBuffer))
		{
			MessageBox(hDlg,"Period is not invalid number","Error",MB_OK);
			return TRUE;
		}
         
         gfGatePeriod = (float)atof(szBuffer);
         
         SendDlgItemMessage(hDlg, IDC_CHGHIPERIOD, WM_GETTEXT, 13,
            (LPARAM)(LPSTR)szBuffer) ;
 		if(!InvalidStrToNum((const char *)szBuffer))
		{
			MessageBox(hDlg,"Hi Period is not invalid number","Error",MB_OK);
			return TRUE;
		}

         gfUpCycle = (float)atof(szBuffer);

       
         // Set the new parameters
         ptCounterPWMSetting.Port  = gwChannel;
         ptCounterPWMSetting.Period   = gfGatePeriod;
         ptCounterPWMSetting.HiPeriod  = gfUpCycle;
         ptCounterPWMSetting.OutCount = gusOutCount;   //no use
         ptCounterPWMSetting.GateMode = gwGateMode;    //no use
         
         if((ErrCde = DRV_CounterPWMSetting(DriverHandle,
            (LPT_CounterPWMSetting)&ptCounterPWMSetting)) != 0)
         {
            DRV_GetErrorMessage(ErrCde,(LPSTR)szErrMsg);
            MessageBox(hDlg,(LPCSTR)szErrMsg, "Driver Message", MB_OK);
            return TRUE;
         }
         
         
         EndDialog(hDlg, 0);
         return TRUE;
         
         
      case IDC_BTNCHGCANCEL :
         EndDialog(hDlg, 0);
         return TRUE;
      }
      
      break;
   }
   
   return FALSE ;
}

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

    PURPOSE:  Processes messages

    MESSAGES:

        WM_CREATE     - create window
        WM_COMMAND    - application menu (About dialog box)
        WM_DESTROY    - destroy window
****************************************************************************/

long FTYPE MainWndProc
(
    HWND        hWnd,                          // window handle
    unsigned    message,                       // type of message
    WPARAM      wParam,                        // additional information
    LPARAM      lParam                         // additional information
)
{
    static  HANDLE  hInstance ;
    HMENU           hMenu;
    HDC             hdc;
    char            szBuffer[120];
    RECT            rect;

    switch (message)
    {
        case WM_CREATE:

            //
            // initialize Stop Menu
            //

            hMenu = GetMenu(hWnd);
            EnableMenuItem(hMenu, IDM_STOP, MF_BYCOMMAND | MF_GRAYED);
            EnableMenuItem(hMenu, IDM_CHGSET, MF_BYCOMMAND | MF_GRAYED);

            hInstance = ((LPCREATESTRUCT) lParam)->hInstance ;

            lpfnConfigDlgProc = MakeProcInstance (ConfigDlgProc, hInstance) ;
            lpfnChgSetDlgProc = MakeProcInstance (ChgSetDlgProc, hInstance);

            return 0 ;

        case WM_COMMAND:     /* message: from application menu */

            hMenu = GetMenu(hWnd);

            switch (LOWORD(wParam))
            {
                case IDM_SETTING :
                    DialogBox (hInstance, MAKEINTRESOURCE(IDD_SETTING),
                         hWnd, lpfnConfigDlgProc) ;
                    return 0;

                case IDM_STOP :

                    //
                    // counter reset
                    //

                    if ((ErrCde = DRV_CounterReset(DriverHandle,
                        (LPARAM)gwChannel)) != 0)
                    {
                        DRV_GetErrorMessage(ErrCde,(LPSTR)szErrMsg);
                        MessageBox(hWnd,(LPCSTR)szErrMsg, "Driver Message", MB_OK);
                    }

                    DRV_DeviceClose((LONG far *)&DriverHandle);

                    bRun = FALSE;

                    //
                    // reset menu item status
                    //
                    hdc = GetDC(hWnd);
                    GetClientRect(hWnd, &rect);
                    sprintf(szBuffer, "Pulse Output stop !            ");
                    DrawText(hdc, szBuffer, -1, &rect,
                        DT_SINGLELINE | DT_CENTER | DT_VCENTER);
                    ReleaseDC(hWnd, hdc);

                    EnableMenuItem(hMenu, IDM_STOP, MF_BYCOMMAND | MF_GRAYED);
                    EnableMenuItem(hMenu, IDM_CHGSET, MF_BYCOMMAND | MF_GRAYED);
                    EnableMenuItem(hMenu, IDM_START, MF_BYCOMMAND | MF_ENABLED);
                    EnableMenuItem(hMenu, IDM_SETTING, MF_ENABLED);
                    return 0;

                case IDM_CHGSET :
				   if(gusOutCount!=0)
				   {
					   MessageBox(hWnd,"Can't change setting in noncyclic mode!","Change Setting",MB_OK);  
					   return 0;
				   }
                   DialogBox (hInstance, MAKEINTRESOURCE(IDD_CHGSETTING),
                      hWnd, lpfnChgSetDlgProc) ;
                   return 0;

                case IDM_START :

                    //
                    // Open Device
                    //

                    if (gnNumOfSubdevices == 0)
                        ErrCde = DRV_DeviceOpen(
                            DeviceList[gwDevice].dwDeviceNum,
                                (LONG far *)&DriverHandle);
                    else
                        ErrCde = DRV_DeviceOpen(
                            SubDeviceList[gwSubDevice].dwDeviceNum,
                                (LONG far *)&DriverHandle);

                    if (ErrCde != SUCCESS)
                    {
                        strcpy(szErrMsg,"Device open error !");
                        MessageBox(hWnd,(LPCSTR)szErrMsg,"Device Open",MB_OK);
                        return 0;
                    }


                    //
                    // get number of counter channels
                    //

                    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;
                    }

                    // check number of counter channels
                    if (DevFeatures.usMaxTimerChl == 0)
                    {
                        MessageBox(hWnd,(LPCSTR)"No Counter Channel",
                            "Driver Message",MB_OK);
                        DRV_DeviceClose((LONG far *)&DriverHandle);
                        return 0;
                    }


                    //
                    // start counter
                    //

                    ptCounterPWMSetting.Port  = gwChannel;
                    ptCounterPWMSetting.Period   = gfGatePeriod;
                    ptCounterPWMSetting.HiPeriod  = gfUpCycle;
					ptCounterPWMSetting.OutCount = gusOutCount; 
                    ptCounterPWMSetting.GateMode = gwGateMode;

                    if((ErrCde = DRV_CounterPWMSetting(DriverHandle,
                         (LPT_CounterPWMSetting)&ptCounterPWMSetting)) != 0)
                    {
                       DRV_GetErrorMessage(ErrCde,(LPSTR)szErrMsg);
                       MessageBox(hWnd,(LPCSTR)szErrMsg, "Driver Message", MB_OK);
                       return TRUE;
                    }
				    
					     if( (ErrCde = DRV_CounterPWMEnable(DriverHandle,
                         (LPARAM)gwChannel)) != 0)
						  {
                        DRV_GetErrorMessage(ErrCde,(LPSTR)szErrMsg);
                        MessageBox(hWnd,(LPCSTR)szErrMsg, "Driver Message", MB_OK);
						  }

                    //
                    // enable Stop Menu item and disable the others
                    //

                    EnableMenuItem(hMenu, IDM_STOP, MF_BYCOMMAND | MF_ENABLED);
					EnableMenuItem(hMenu, IDM_CHGSET, MF_BYCOMMAND | MF_ENABLED);
                    EnableMenuItem(hMenu, IDM_START, MF_BYCOMMAND | MF_GRAYED);
                    EnableMenuItem(hMenu, IDM_SETTING,  MF_DISABLED);
                    bRun = TRUE;

                    //
                    // display
                    //

                    hdc = GetDC(hWnd);
                    GetClientRect(hWnd, &rect);
                    sprintf(szBuffer, "Pulse Output Running ...... ");
                    DrawText(hdc, szBuffer, -1, &rect,
                        DT_SINGLELINE | DT_CENTER | DT_VCENTER);
                    ReleaseDC(hWnd, hdc);

                    return 0;
            }
            return 0;

        case WM_DESTROY:
            if (bRun == TRUE)
            {
                // counter reset
                if( (ErrCde = DRV_CounterReset(DriverHandle,
                    (LPARAM)gwChannel)) != 0)
                {
                    DRV_GetErrorMessage(ErrCde,(LPSTR)szErrMsg);
                    MessageBox(hWnd,(LPCSTR)szErrMsg, "Driver Message", MB_OK);
                }

                DRV_DeviceClose((LONG far *)&DriverHandle);
            }
            PostQuitMessage(0);
            break;

        default:
            return (DefWindowProc(hWnd, message, wParam, lParam));
    }

    return ((LONG)NULL);
}

long  InvalidStrToNum(const char *nptr)
{
	    int l;  /*string length*/
        int c;              /* current char */
		char hasPoint=0,hasSign=0;
        char * current=(unsigned char *)nptr;
		

		if((l=strlen(nptr))==0) return 0;
		
		if(isspace(*current) && current-nptr<=l)
				current++;
		if(current-nptr>l)
			return 0;
        c = *current++;
        while (current-nptr<=l) 
		{
            if (c == '-' || c == '+') hasSign++; 
			if(c=='.') hasPoint++;
			if(!isdigit(c) && hasPoint >=(char)2 && hasSign>=(char)2)
				break;
			c=*current++;    /* get next char */
		}
        if(current-nptr<=l)
			return 0;
			
        return 1;   /*return true*/
}