counter1780.cpp

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

// File:        COUNTER.c
// Created:     09/17/2003
// Description: Demo program for event counting - pci1780


// Counter1780.cpp : Defines the entry point for the console application.
//


#include "stdafx.h"
#include <windows.h>
#include <windef.h>
#include <stdio.h>
#include <conio.h>
#include <stdlib.h>
#include "..\..\..\..\include\driver.h"

#define MAX_DEVICES 255
//for pass the parameter to thread
struct ThreadPara {
	long lDriverHandle;
	USHORT usChannel;
	USHORT usInitV;
};

//Thread function declare:

void UserThread(ThreadPara *);
void ErrorHandler(DWORD dwErrCde);
void ErrorStop(long*, DWORD);

//event handle
HANDLE hStopEvent = FALSE;

void main()
{
	DWORD  dwErrCde;
    ULONG  lDevNum;
    LONG   lDriverHandle;
	
    USHORT usChannel =0;      // input port          
	USHORT usMode = 256;      // counter mode
	USHORT usCountSrc = 1;    // count source
	USHORT usInitValue = 1;    // initial value
	USHORT usOutputMode = 0;   // output mode
	USHORT usCntEdge = 0;      // count edge
	USHORT usCntDir = 0;       // count direction
	USHORT usOutputEnable = 0; // output enable
	USHORT usGateSrc = 0;      // gate source
	USHORT usGatePl = 0;       // gate polarity
	HANDLE hReadThread;    // thread handle
    DWORD dwThreadID = 0;     
	BOOL bGateEnable = FALSE;
    DWORD dwBoardID;
    SHORT gnNumOfDevices;
    SHORT nOutEntries; 
    int i;
    PT_CounterConfig     ptCounterConfig;
    PT_CounterEventStart ptCounterEventStart;
    PT_DeviceGetFeatures ptDeviceGetFeatures;
    DEVFEATURES          devFeatures;
    DEVLIST              DeviceList[MAX_DEVICES];

	ThreadPara           ThPrameter;

		
	//Step 1: Display hardware and software settings for running this example
    printf("Before running this example, please\n");
    printf("use the device installation utility to add the device.\n");
	
    // Add type of PC Laboratory Card
    dwErrCde = DRV_DeviceGetList(&DeviceList[0], MAX_DEVICES, &nOutEntries);
    // Return the number of devices which you install in the system using
    // Device Installation
    dwErrCde = DRV_DeviceGetNumOfList(&gnNumOfDevices);
    printf("This is the installed device list:\n");
    for (i = 0; i < gnNumOfDevices; i++)
    {
       printf("  %3.3d %s\n",DeviceList[i].dwDeviceNum,DeviceList[i].szDeviceName);
    }


    //Step 2: Input parameters
    printf("\nPlease input parameters:");
    printf("\nDevice Number (check the device installation utility): ");
    scanf("%d", &lDevNum);	
    fflush(stdin);
    //Step 3: Device open
    dwErrCde = DRV_DeviceOpen(lDevNum, &lDriverHandle);
    if (dwErrCde != SUCCESS) {
       ErrorHandler(dwErrCde);
       printf("Program terminated!\n");
       printf("Press any key to exit....");
       getch();
       exit(1);
    }
    //Step 4: Get Device Features
    ptDeviceGetFeatures.buffer = &devFeatures;
    ptDeviceGetFeatures.size = sizeof(DEVFEATURES);
    dwErrCde = DRV_DeviceGetFeatures(lDriverHandle, &ptDeviceGetFeatures);
    if (dwErrCde != SUCCESS) {
       ErrorHandler(dwErrCde);
       printf("Program terminated!\n");
       printf("Press any key to exit....");
       getch();
       exit(1);
    }
    dwBoardID = devFeatures.dwBoardID;

	printf("\nPlease input channel:");
	scanf("%d", &usChannel);
   fflush(stdin);

	printf("\nPlease input counter Mode:");
	printf("\n0: A, 1: B, 2: C, 3: D");
	printf("\n4: E, 5: F, 6: G, 7: H");
	printf("\n8: I, 9: J, 10:K, 11:L");
	printf("\n12:O, 13:R, 14:U, 15:X");
	printf("\n:");
	scanf("%d", &usMode);
	fflush(stdin);
	while(usMode<0 || usMode >15){
		printf("the parameter is incorrect, please input again:");
	    scanf("%d", &usMode);
	    fflush(stdin);
	}
	switch(usMode) {
	case 6:
	case 7:
	case 8:
	case 9:
	case 10:
	case 11:
	case 14:
	case 15:
	printf ("**********************************************************\n");
	printf("This Mode can not show the counter value (0 always shown)\n\
and can only be checked by the TC output or TC interrupt.\n" );
	printf ("**********************************************************\n");
		break;
	default:
		break;
	}


	printf("\nPlease input count source:");
	printf("\n(0: OUT N-1, 1: CLK N, 2: CLK N-1, 3: FOUT0\n");
   if(dwBoardID != BD_PCM3780){
      printf("4: FOUT1, 5: FOUT2, 6: FOUT3, 7:GATE N-1)");
   }else{
      printf("4: FOUT1, 5: GATE N-1)");
   }

	printf("\n:");
	scanf("%d", &usCountSrc);
	fflush(stdin);
	while(usCountSrc<0 || usCountSrc>7){
	    printf("the parameter is incorrect, please input again:");
		scanf("%d", &usCountSrc);
		fflush(stdin);
	}
	
	printf("\nPlease input initial value(0<initial value<=65535):");
	scanf("%d", &usInitValue);
    fflush(stdin);
	
	printf("\nPlease input counting edge(0: rising, 1: falling):");
	scanf("%d", &usCntEdge);
	fflush(stdin);
	
	printf("\nPlease input counting direction(0: up, 1: down):");
	scanf("%d",&usCntDir);
	fflush(stdin);
	
	printf("\nEnable Output?(0: yes, 1: no):");
	scanf("%d", &usOutputEnable);
	fflush(stdin);

	if(0 == usOutputEnable){
		printf("\nPlease input output mode:\n 0: ACTIVE HIGH PULSE\n 1: ACTIVE LOW PULSE,\n 2: TC TPGGLED FROM LOW\n 3: TC TOGGLED FROM HIGH\n" );
		scanf("%d", &usOutputMode);
		fflush(stdin);
	}

	if (usMode!= 0 && usMode!=3 && usMode!=6 && usMode!=9) {
		bGateEnable = TRUE;
		printf("\nPlease input the Gate Source(0: OUT N-1, 1: GATE N, 2: GATE N-1):");
		scanf("%d", &usGateSrc);
		fflush(stdin);
		printf("\nPlease input the Gate polarity(0: High or Rising, 1: Low or Falling):");
		scanf("%d", &usGatePl);
		fflush(stdin);
	}

	
	//step 5 counter mode
    switch(usMode) {
	case 0:
		ptCounterConfig.usCountMode = MODE_A;
		break;
	case 1:
		ptCounterConfig.usCountMode = MODE_B;
		break;
	case 2:
		ptCounterConfig.usCountMode = MODE_C;
		break;
	case 3:
		ptCounterConfig.usCountMode = MODE_D;
		break;
	case 4:
		ptCounterConfig.usCountMode = MODE_E;
		break;
	case 5:
		ptCounterConfig.usCountMode = MODE_F;
		break;
	case 6:
		ptCounterConfig.usCountMode = MODE_G;
		break;
	case 7:
		ptCounterConfig.usCountMode = MODE_H;
		break;
	case 8:
		ptCounterConfig.usCountMode = MODE_I;
		break;
	case 9:
		ptCounterConfig.usCountMode = MODE_J;
		break;
	case 10:
		ptCounterConfig.usCountMode = MODE_K;
		break;
    case 11:
		ptCounterConfig.usCountMode = MODE_L;
		break;	 
	case 12:
		ptCounterConfig.usCountMode = MODE_O;
		break;
	case 13:
		ptCounterConfig.usCountMode = MODE_R;
		break;
	case 14:
		ptCounterConfig.usCountMode = MODE_U;
		break;
	case 15:
		ptCounterConfig.usCountMode = MODE_X;
		break;
	
	}

	//step 6 Gate source
	if(bGateEnable){
		switch(usGateSrc) {
		case 0:
			ptCounterConfig.usGateSrc = PA_MODE_GATE_SRC_OUT_N_M1;
			break;
		case 1:
			ptCounterConfig.usGateSrc = PA_MODE_GATE_SRC_GATE_N;
			break;
		case 2:
			ptCounterConfig.usGateSrc = PA_MODE_GATE_SRC_GATE_N_M1;
			break;
		}
		
		if(0 == usGatePl){
			ptCounterConfig.usGatePolarity = PA_MODE_GATE_POSITIVE;
		}else{
			ptCounterConfig.usGatePolarity = PA_MODE_GATE_NEGATIVE;
		}
		
	}else{
		ptCounterConfig.usGateSrc = PA_MODE_GATE_SRC_GATE_NO;
		ptCounterConfig.usGatePolarity = 0;
	}

	//step 7 output mode
	if (0 == usOutputEnable) {
		ptCounterConfig.usOutputEnable = PA_MODE_ENABLE_OUTPUT;
		switch(usOutputMode) {
		case 0:
			ptCounterConfig.usOutputMode = PA_MODE_ACT_HIGH_TC_PULSE;
			break;
		case 1:
			ptCounterConfig.usOutputMode = PA_MODE_ACT_LOW_TC_PULSE;
			break;
		case 2:
			ptCounterConfig.usOutputMode = PA_MODE_TC_TOGGLE_FROM_LOW;
			break;
		case 3:
			ptCounterConfig.usOutputMode = PA_MODE_TC_TOGGLE_FROM_HIGH;
			break;
		}
	}else{
		ptCounterConfig.usOutputEnable =PA_MODE_DISABLE_OUTPUT;
		ptCounterConfig.usOutputMode = 0;
	}

	//step 8 count source
	switch(usCountSrc) {
	case 0:
		ptCounterConfig.usClkSrc = PA_MODE_COUNT_SRC_OUT_N_M1;
		break;
	case 1:
		ptCounterConfig.usClkSrc = PA_MODE_COUNT_SRC_CLK_N;
		break;
	case 2:
		ptCounterConfig.usClkSrc = PA_MODE_COUNT_SRC_CLK_N_M1;
		break;
	case 3:
		ptCounterConfig.usClkSrc = PA_MODE_COUNT_SRC_FOUT_0;
		break;
	case 4:
		ptCounterConfig.usClkSrc = PA_MODE_COUNT_SRC_FOUT_1;
		break;
	case 5:
      if (dwBoardID != BD_PCM3780){
         ptCounterConfig.usClkSrc = PA_MODE_COUNT_SRC_FOUT_2;
      }else{
         ptCounterConfig.usClkSrc = PA_MODE_COUNT_SRC_GATE_N_M1;
      }
		break;
	case 6:
		ptCounterConfig.usClkSrc = PA_MODE_COUNT_SRC_FOUT_3;
		break;
	case 7:
		ptCounterConfig.usClkSrc = PA_MODE_COUNT_SRC_GATE_N_M1;
		break;
	}

	//step 9 other parameter
    if (0 == usCntDir) {
		ptCounterConfig.usCountDirect = PA_MODE_COUNT_UP;
    }else{
		ptCounterConfig.usCountDirect = PA_MODE_COUNT_DOWN;
	}
	ptCounterConfig.usInitValue = usInitValue;
	ptCounterConfig.usCounter = usChannel;
	if (0 == usCntEdge) {
		ptCounterConfig.usCountEdge = PA_MODE_COUNT_RISE_EDGE;
	}else{
		ptCounterConfig.usCountEdge = PA_MODE_COUNT_FALL_EDGE;
	}
	    

	//step 10 start counter
	if((dwErrCde = DRV_CounterConfig(lDriverHandle,
		(LPT_CounterConfig)&ptCounterConfig)) != SUCCESS)
	{
		ErrorStop(&lDriverHandle, dwErrCde);
		return;
	}

	ptCounterEventStart.counter = usChannel;
	if((dwErrCde = DRV_CounterEventStart(lDriverHandle,
		(LPT_CounterEventStart)&ptCounterEventStart)) != SUCCESS)
	{
		ErrorStop(&lDriverHandle, dwErrCde);
		return;
	}

	//step 11 start thread to read data
	ThPrameter.lDriverHandle = lDriverHandle;
	ThPrameter.usChannel     = usChannel;
	ThPrameter.usInitV         = usInitValue;
	hStopEvent = CreateEvent(NULL,TRUE,FALSE,NULL);
	hReadThread = CreateThread(NULL,0,(LPTHREAD_START_ROUTINE)UserThread,&ThPrameter,0,&dwThreadID);
	
	getch();

	SetEvent(hStopEvent);
	WaitForSingleObject(hReadThread,INFINITE);

	if( (dwErrCde = DRV_CounterReset(lDriverHandle,
		(LPARAM)usChannel)) != 0)
	{
         ErrorStop(&lDriverHandle, dwErrCde);
	}
	
	DRV_DeviceClose((LONG far *)&lDriverHandle);
	
	CloseHandle(hStopEvent);
	CloseHandle(hReadThread);
	printf("\n");
	getch();
	return;
}

/**********************************************************************
* Function: ErrorHandler
*           Show the error message for the corresponding error code
* input:    dwErrCde, IN, Error code
* return:   none
**********************************************************************/
void ErrorHandler(DWORD dwErrCde)
{
    char szErrMsg[180];
	
    DRV_GetErrorMessage(dwErrCde, szErrMsg);
    printf("\nError(%d): %s\n", dwErrCde & 0xffff, szErrMsg);
}//ErrorHandler

 /**********************************************************************
 * Function:   ErrorStop
 *             Release all resource and terminate program if error occurs 
 * Paramaters: pDrvHandle, IN/OUT, pointer to Driver handle
 *             dwErrCde, IN, Error code.
 * return:     none             
**********************************************************************/
void ErrorStop(long *pDrvHandle, DWORD dwErrCde)
{
    //Error message 
    ErrorHandler(dwErrCde);
    printf("Program terminated!\n");
    
    //Close device
    DRV_DeviceClose(pDrvHandle);
	
    printf("Press any key to exit....");
    getch();
    exit(1);
}//ErrorStop

void UserThread(ThreadPara *ThParameter)
{
	PT_CounterEventRead  ptCounterEventRead;
	USHORT gwOverflow;
	USHORT gdwReading;
	USHORT gdwOldRding = 0;
	DWORD  dwErrCde;
	
	gdwReading = ThParameter->usInitV;
	ptCounterEventRead.counter = ThParameter->usChannel;
	ptCounterEventRead.overflow = (USHORT far *)&gwOverflow;
	ptCounterEventRead.count = (ULONG far *)&gdwReading;

	while(WaitForSingleObject(hStopEvent,0) == WAIT_TIMEOUT){
		if ((dwErrCde = DRV_CounterEventRead(ThParameter->lDriverHandle,
			(LPT_CounterEventRead)&ptCounterEventRead)) != SUCCESS){
			ErrorStop(&(ThParameter->lDriverHandle), dwErrCde);
			return;
		}
		printf("\nthe count is:%d", gdwReading);
		Sleep(1000); //for display delay on purpose
	}


}