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

#include "stdafx.h"
#include "HSDAQ.h"
#include <stdio.h>
#include <conio.h>
//#include "timeData.h"

#define NEW2D(H, W, TYPE) (TYPE **)new2d(H, W, sizeof(TYPE))
void* new2d(int h, int w, int size)
{
    register int i;
    void **p;

    p = (void**)new char[h*sizeof(void*) + h*w*size];
	memset(p,0x0,h*sizeof(void*) + h*w*size);
    for(i = 0; i < h; i++)
    {
        p[i] = ((char *)(p + h)) + i*w*size; 
    }
//	memset(p,0x0,h*w*size);

	return p;
}
void printInProcess(unsigned long errorcnt)
{
	static unsigned long temp=0;
	static int intc=0;
	if(!temp)
		temp=errorcnt;
	
	
	if(temp==errorcnt) //no error increased
	{
		switch(intc%4)
		{
			case 0:
			default:
				printf("-\r");
				break;
			case 1:
				printf("*\r");
				break;				
			case 2:
				printf("+\r");
				break;	
			case 3:
				printf("/\r");
				break;
		}
		intc++;
	}
	else
		intc=0;
	temp=errorcnt;	
}
int _tmain(int argc, _TCHAR* argv[])
{
	HANDLE hHS;
	char IPadd[64]="\0";
	char sdk_version[16]={0};
	char fw_version[32]={0};

	bool ret= false;
	short chCnt=8;
	short  useGain=0;


	short extriggMode=0;
	bool continuousMode=false;
	long continuousTimeout=0;
	unsigned long targetCnt=0;
	long sampleRate=0;

	//unsigned long totalRead=0,totalReceived=0;
	short DataTransMethod=0;
	short AutoRun=0;


	if(argc>1)
	{
		wprintf(TEXT("%s\r\n"),argv[1]);
   
		//int   nLen   =   wcslen(argv[1])+1;    
		WideCharToMultiByte(CP_ACP,   0,   argv[1],   -1,   IPadd,  64,   NULL,   NULL);
		printf("program start %s\r\n",IPadd);
	}
	else
	{
		printf("error argument\r\n");
		return 0;
	}
	
	char tmp[128]={0};
	sprintf(tmp,"%s,9999,10010",IPadd);
	//Step 2: Create a TCP connection with ET-7H16
	hHS = HS_Device_Create(tmp);

	Sleep(10);
	if(hHS!=NULL)
	{
		printf("ET-7H16 Synchronous Input Scan Testing [continue mode & Software trigger]\r\n");
		HS_GetSDKVersion(sdk_version);
		printf("HSDAQ SDK Ver=%s\r\n",sdk_version);

		HS_GetFirmwareVersion(hHS,fw_version);
		printf("ET7H16 Firmware Ver=%s\r\n",fw_version);
		
		HS_GetHWFirmwareVersion(hHS,fw_version);
		printf("ET7H16 FPGA Firmware Ver=%s\r\n",fw_version);
	

		//In synchronous Input DAQ, it must be software trigger, continue mode , sampling rate <=5K Hz
		extriggMode=0;
		targetCnt=0;
		sampleRate=2000; 
		ret=HS_SetAIScanParam(hHS, chCnt, useGain, extriggMode, sampleRate, targetCnt, DataTransMethod,AutoRun);
		//Step 2: SetScanParam sets chCnt, useGain, triggerMode, sampleRate, targetCnt to ET7H16
		if(ret==false)
		{
			printf("Error code 0x%x\r\n",HS_GetLastError());
		}
		//printf("HS_SetAIScanParam\r\n");

		HS_GetAIScanParam(hHS, &chCnt, &useGain, &extriggMode, &sampleRate, &targetCnt,&DataTransMethod,&AutoRun); 
		//Step 3: GetScanParam getsx chCnt, useGain, triggerMode, sampleRate, targetCnt to check with ET7H16
		printf("ET-7H16 first Scan parameters chCnt %d, useGain %d, triggMode %d, sampleRate %ld, targetCnt %lu \n", chCnt, useGain, extriggMode, sampleRate, targetCnt);		
		
		//Step 4: Set counter configuration
		DWORD dwCNTmode=CNT_DISABLE;//CNT_ENABLE;
		DWORD dwCNTInitValue=0;
		HS_SetCounterConfig(hHS,0,dwCNTmode,dwCNTInitValue,0);
		Sleep(10);
		printf("HS_SetCounterConfig \r\n");
		//Step 5: Read counter configuration
		HS_GetCounterConfig(hHS,0,&dwCNTmode,&dwCNTInitValue, NULL);
		printf("Counter parameters: Channel:%d, mode %d, Init value %d\r\n", 0, dwCNTmode, dwCNTInitValue);		

		unsigned long totalRecv=0;
#if 1
		int SyInTypeNum=2;
		int SyncInheader=1;//index
		int AcutArryAcount=0;
		int options=0;
		WORD SyInChTypeArray[2]={SYNC_IN_AI_HEX,SYNC_IN_DWORD_CNT};
		WORD SyInChNumArray[2]={chCnt,1};
		//Step 6: HS_SetSyncInScanParam sets the synchronous configuration (header,input type and input number for synchronous ethernet frame)
		ret=HS_SetSyncInScanParam(hHS,SyncInheader,SyInChNumArray,SyInChTypeArray,SyInTypeNum,SYNC_ENABE,0);
		if(ret==false)
		{
			printf("Error code 0x%x\r\n",HS_GetLastError());
		}	
		//memset(SyInChTypeArray,0,sizeof(SyInChTypeArray));
		//memset(SyInChNumArray,0,sizeof(SyInChNumArray));
		
		HS_GetSyncInScanParam(hHS,(DWORD *)&SyncInheader,SyInChNumArray,SyInChTypeArray,SyInTypeNum,(WORD *)&AcutArryAcount,(DWORD *)&options,NULL);
		printf("Synchronous parameters header type:%d, AcutalArryAcount:%d, options:%d \n", SyncInheader, AcutArryAcount, options);	

		int i;
		for(i=0;i<AcutArryAcount;i++)
			printf("%d Input channel number:%d type:%d \n", i, SyInChNumArray[i], SyInChTypeArray[i]);	
		Sleep(10);

		//Step 6: Start AI Scan
		HS_ClearSyncInBuffer(hHS);
		ret=HS_StartAIScan(hHS);
		if(ret==false)
		{
			printf("Error code 0x%x\r\n",HS_GetLastError());
		}

		HS_GetCounterConfig(hHS,0,&dwCNTmode,&dwCNTInitValue, NULL);
		printf("Counter parameters 2: Channel:%d, mode %d, Init value %d\r\n", 0, dwCNTmode, dwCNTInitValue);	

		WORD BufferStatus=0;
		#define BUFFERSIZE 1000
		//float fdataBuffer[BUFFERSIZE];
		//WORD dataBuffer[BUFFERSIZE];
		unsigned long ulFramelength=0;
		//unsigned int remChannel=0;

		unsigned long CH1checkerror=0;
		unsigned long CNTcheckerror=0;
		unsigned long otherCHcheckerror=0;
		bool quit=false;

		//Step 7: while loop to get total received frame data count from PET-7H16
		while(quit==false)
		{			

			//ret=HS_GetAIBufferStatus(hHS,&BufferStatus,&ulleng);
			ret=HS_GetSyncInBufferStatus(hHS,&BufferStatus,&ulFramelength);
			if(ret==false)
			{
				printf("Error code 0x%x\r\n",HS_GetLastError());
			}
			else
			{				
				if(BufferStatus>=2) //AI buffer overflow
				{
					if(BufferStatus>>1 & 0x1)
						printf("AI buffer overflow\r\n");	
					else if(BufferStatus>>2 & 0x1)
						printf("AI scan stop\r\n");
					else
						printf("other error\r\n");
					break; 
				}
				if(ulFramelength)
				{
					//printf("Frame length =%d\r\n",ulFramelength);
					unsigned long size=ulFramelength;
					unsigned long temp=0;
					unsigned long readsize=0;	
					DWORD *dwheaderbuf=NULL;
					DAQ_TIME *dtheaderbuf=NULL;
					//void *vheaderpointer=NULL;

					DWORD *wAIbuffer=NULL;
					DWORD *wDICNTbuffer=NULL;
					DWORD *wCNTbuffer=NULL;
	
					switch(SyncInheader) //dcalare header array
					{
						case 0:
						default:							
							break;
						case 1:							
							dwheaderbuf=new DWORD[ulFramelength];
							//vheaderpointer=dwheaderbuf;
							break;
						case 2:	
							dtheaderbuf=new DAQ_TIME[ulFramelength];
							//vheaderpointer=dtheaderbuf;
							break;
					}
					int i;
					for(i=0;i<SyInTypeNum;i++)
					{
						switch(SyInChTypeArray[i])
						{
							case SYNC_IN_AI:  //2bytes (Hex to float)	
							case SYNC_IN_AI_HEX: //2bytes
								//wAIbuffer=NEW2D(ulFramelength, SyInChNumArray[i], DWORD);
								temp=ulFramelength*SyInChNumArray[i];
								wAIbuffer=new DWORD[temp];
								memset(wAIbuffer,0x0,sizeof(DWORD)*temp);
//								vAIbuffpointer=(void **)wAIbuffer;
								break;
							case SYNC_IN_DWORD_DI_CNT: //4bytes
								//wDICNTbuffer=NEW2D(ulFramelength, SyInChNumArray[i], DWORD);
								temp=ulFramelength*SyInChNumArray[i];
								wDICNTbuffer=new DWORD[temp];
								memset(wDICNTbuffer,0x0,sizeof(DWORD)*temp);
								//vDICNTbuffpointer=(void **)wDICNTbuffer;
								break;
							case SYNC_IN_DWORD_CNT:  //4bytes
								//wCNTbuffer=NEW2D(ulFramelength, SyInChNumArray[i], DWORD);
								temp=ulFramelength*SyInChNumArray[i];
								wCNTbuffer=new DWORD[temp];
								memset(wCNTbuffer,0x0,sizeof(DWORD)*temp);
								//vCNTbuffpointer=(void **)wCNTbuffer;
								break;
							default:								
								break;
						}							
					}
					
					{
					//	if(size>BUFFERSIZE)
					//		size=BUFFERSIZE;
		
						//readsize=HS_GetAIBufferHex(hHS,dataBuffer,size);	
//						HS_ClearSyncInBuffer(hHS);
						//readsize=HS_GetSyncInBuffer(hHS,vheaderpointer,vAIbuffpointer,NULL,NULL,vDICNTbuffpointer,vCNTbuffpointer,NULL,NULL,ulFramelength);
						readsize=HS_GetSyncInBufferLV(hHS,dwheaderbuf,wAIbuffer,NULL,NULL,wDICNTbuffer,wCNTbuffer,NULL,NULL,ulFramelength);

						if(readsize)
						{									
							int i=0;
							int j=0;
							int k=0;
							DWORD dwtemp=0;
							DWORD dwCNTtemp=0;
	
							for(k=0;k<ulFramelength;k++) //read all frame data
							{
								switch(SyncInheader) //read header 
								{
									case 0:
									default:							
										break;
									case 1:						
										//printf("Head:%X ",dwheaderbuf[k]);
										if(!dwtemp)
											dwtemp=dwheaderbuf[k];
										else
										{
											if(dwheaderbuf[k]-dwtemp>1)
											{
												otherCHcheckerror++;
												printf("header index error %lu, [%lu, %lu]\r\n",otherCHcheckerror,dwtemp,dwheaderbuf[k]);
												//quit=true;	
												//goto _quit;
											}
											dwtemp=dwheaderbuf[k];
										}
										break;
									case 2:	
										printf("Head:%d %d:%d:%d:%d ",dtheaderbuf[k].day,dtheaderbuf[k].hour,dtheaderbuf[k].minute,dtheaderbuf[k].sec,dtheaderbuf[k].msec);
										break;
								}
								//printf("[%lu]H:%lu\r\n",totalRecv+k, dwheaderbuf[k]);
								int arrayind=0;
								for(i=0;i<SyInTypeNum;i++) //read the array data of each input type on a frame data
								{
									switch(SyInChTypeArray[i]) //read input data 
									{
										case SYNC_IN_AI:  //2bytes (Hex to float)	
										case SYNC_IN_AI_HEX: //2bytes	
											//printf("AI:");
											for(j=0;j<SyInChNumArray[i];j++)
											{
											//	printf("%02X ",wAIbuffer[k][j]);
												//if(wAIbuffer[k][1]>0x1C00 || wAIbuffer[k][1]<0x1a00)
												arrayind=k*SyInChNumArray[i]+1;
												if(wAIbuffer[arrayind]>0x1C00 || wAIbuffer[arrayind]<0x1a00)
												{
													CH1checkerror++;
													printf("CH1 error %lu, 0x%X\r\n",CH1checkerror,wAIbuffer[arrayind]);
													printf("CH0:0x%x CH2:0x%x CH3:0x%x CH4:0x%x CH5:0x%x\r\n",wAIbuffer[k*SyInChNumArray[i]],wAIbuffer[arrayind+1],wAIbuffer[arrayind+2],wAIbuffer[arrayind+3],wAIbuffer[arrayind+4]);
													printf("Framelength=%lu ,header=0x%08lX",ulFramelength,dwheaderbuf[k]);
													//quit=true;	
													//goto _quit;
												}
											}
											break;
										case SYNC_IN_DWORD_DI_CNT: //4bytes
											/*printf("DI_CNT:");
											for(j=0;j<SyInChNumArray[i];j++)
												printf("%0lu ",wDICNTbuffer[k][j]);*/
											break;
										case SYNC_IN_DWORD_CNT:  //4bytes
											/*printf("CNT:");
											for(j=0;j<SyInChNumArray[i];j++)
												printf("%0lu ",wCNTbuffer[k][j]);*/
											arrayind=k*SyInChNumArray[i];
											if(!dwCNTtemp)
												dwCNTtemp=wCNTbuffer[arrayind];
											else
											{
												printf("[0x%08lX]",wCNTbuffer[arrayind]);
												/*if(wCNTbuffer[arrayind]-dwCNTtemp!=1 && wCNTbuffer[arrayind]-dwCNTtemp!=0)
												{
													CNTcheckerror++;
													printf("H:%lu CNT error %lu, [%lu, %lu]\r\n",dwheaderbuf[k],CNTcheckerror,dwCNTtemp,wCNTbuffer[arrayind]);
													//quit=true;	
													//goto _quit;
												}*/
												dwCNTtemp=wCNTbuffer[arrayind];
											}
											//printf("%lu ", wCNTbuffer[k][0]);
											break;
										default:
											break;
									}

								}
								//printf(".");//\r\n");
								printInProcess(CNTcheckerror);
								//remChannel++;
							}

						}
						else
							printf("Err:0x%X\r\n",HS_GetLastError());
							//printf("x");

					}
_quit:
					//free array
					if(dwheaderbuf!=NULL)
						delete [] dwheaderbuf;
					if(wAIbuffer!=NULL)
						delete [] wAIbuffer;
					if(wDICNTbuffer!=NULL)
						delete [] wDICNTbuffer;
					if(wCNTbuffer!=NULL)
						delete [] wCNTbuffer;
					
					totalRecv=totalRecv+readsize;
					//if(totalRecv>=300)
					//		break;
				}
			}
			if(targetCnt && totalRecv>=targetCnt) //targetCnt >0 : N sample mode, 0: continue mode
			{
				break;
			}

			//continue mode 
			if(_kbhit())
			{
				Sleep(1);
				if(_getch()=='q' || _getch()=='Q')
					break;
			}						
		}
#endif
		//Step8: Stop AI Scan
		HS_StopAIScan(hHS);

		printf("Sync Input total frame number: %lu\n", totalRecv);
		printf("end\r\n");

		HS_Device_Release(hHS);
	}
	else
	{
		printf("Error code 0x%x\r\n",HS_GetLastError());
	}
	return 0;

}