fert.cpp

cdma无线通信转发程序 用于电力调度数据的转发

#include "stdafx.h"   
#include "stdio.h"
#include "string.h"
#include "netrtu.h"
#include "mydata.h"
#include "dialproc.h"
#include "mainfrm.h"

#include <sys/types.h>
#include <sys/stat.h>

char			bsrvname[50];
int				dev_use_flag = TRUE;


HWND			main_win;
CWinThread		*id = NULL;
CWinThread		*id1 = NULL;
CWinThread		*id2 = NULL;
CWinThread		*id3 = NULL;
CWinThread      *id4 = NULL;

int				live_flag=TRUE;

extern CMainFrame * MainFrame;

//-----------------------------------------------------------------------
void SetAChanMode(DEVPARA * dev)
{
	DCB			 dcb;
	COMMPROP	 commprop;
	COMMTIMEOUTS timeouts;	

	GetCommProperties((HANDLE)dev->devId, &commprop);
	GetCommState((HANDLE)dev->devId, &dcb);
	switch(dev->Baud )
	{
	case 300:	dcb.BaudRate = CBR_300;		break;
	case 600:	dcb.BaudRate = CBR_600;		break;
	case 1200:	dcb.BaudRate = CBR_1200;	break;
	case 2400:	dcb.BaudRate = CBR_2400;	break;
	case 4800:	dcb.BaudRate = CBR_4800;	break;
	case 9600:	dcb.BaudRate = CBR_9600;	break;
	case 19200:	dcb.BaudRate = CBR_19200;	break;
	}
	
	dcb.ByteSize=dev->DataBit;//8位数据位

	if(dev->StopBit ==1) dcb.StopBits = 0;	//1;
	else dcb.StopBits =2;	//2
	if(dev->CheckBit==0) //无校验
	{
		dcb.fParity = 0;
		dcb.Parity = NOPARITY;
	}
	else
	{
		if(dev->CheckBit==1) {//奇校验
			dcb.fParity = 1;
			dcb.Parity = ODDPARITY;
		}
		else if(dev->CheckBit==2) {
			dcb.fParity = 1;
			dcb.Parity = EVENPARITY;
		}
	}
	SetCommState((HANDLE)dev->devId,&dcb);

	//set timeout
	GetCommTimeouts((HANDLE)dev->devId, &timeouts);
	memset(&timeouts, 0, sizeof(timeouts));
	timeouts.ReadIntervalTimeout=MAXDWORD;
	//timeouts.WriteTotalTimeoutMultiplier=120;
	SetCommTimeouts((HANDLE)dev->devId,&timeouts);
}

//------------------------------------------------------------------------
int OpenAChan(DEVPARA * dev)
{
	char	strCom[40];

	switch(dev->Type )
	{
	case  COM:
		sprintf(strCom, "\\\\.\\%s" ,dev->devName);
		dev->devId=(int)CreateFile(strCom, GENERIC_READ|GENERIC_WRITE, 0, NULL,OPEN_EXISTING,NULL,NULL);
		if(dev->devId>0) 
			SetAChanMode (dev);
			break;
		
	case TCPRTU:
		dev->devId = OpenPort(dev->devName);
		break;
	
	case	UDPRTU:
		dev->devId = udp_open(dev->devName);
		break;
	
	default:
		break;
	}	

	if(dev->devId<0) return 0;
    else return 1;
}
//------------------------------------------------------------------------
int CloseAChan(DEVPARA * dev)
{
	if (dev->devId <= (int)INVALID_HANDLE_VALUE)  return 0;


	switch(dev->Type)
	{
	case	COM:
		CloseHandle((HANDLE)dev->devId);
		break;
	
	case    TCPRTU:
		ClosePort((int)dev->devId );
		break;
	
	case	UDPRTU:
		udp_close((int)dev->devId);
		break;

	default:
		break;
	}

    dev->devId=(int)INVALID_HANDLE_VALUE;

    return 0;
}

//--------------------------------------------------------------------------
int CloseAllChan(void)
{
	int i;
	for(i=0; i<G_Channel.chan_num; i++)
	{
		CloseAChan(&G_Channel.chan_data[i].rchanpara);
		CloseAChan(&G_Channel.chan_data[i].tchanpara);

		G_Channel.chan_data[i].rchanpara.RecCnt = 0;
		G_Channel.chan_data[i].rchanpara.SendCnt = 0;

		G_Channel.chan_data[i].tchanpara.RecCnt = 0;
		G_Channel.chan_data[i].tchanpara.SendCnt = 0;
	}
	G_Channel.ropenflag = 0;
	return 0;
}
//------------------------------------------------------------------------
int OpenAllChan()
{
	int     i;

	for(i=0; i<G_Channel.chan_num; i++)
	{
		
		if(!lstrcmp(G_Channel.chan_data[i].rchanpara.devName,""))
		{
			continue;
		}
		OpenAChan(&G_Channel.chan_data[i].rchanpara);///创建串口

		if(!lstrcmp(G_Channel.chan_data[i].tchanpara.devName,""))
		{
			continue;
		}
		OpenAChan(&G_Channel.chan_data[i].tchanpara);///创建串口
	}

	G_Channel.ropenflag = 1;
	return 0;
}

//-----------------------------------------------------------------------------------
void reset(int)
{
	CloseAllChan();
	Sleep(200);
	OpenAllChan();
}


//------------------------------------------------------------------------------------
void Kill(int sig)
{
	live_flag=FALSE;
	printf("!!!!@@@@@@@@@@@ afert is killed. @@@@@@@@@\n");
}

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

void ReadAChan(int ChanNo,uchar flag)
{
	DWORD	nBytesRead;
	int		nBytes,ret;
	char	inbuff[512];
	RXBUF*	  rx;
	DEVPARA * dev;
	
	unsigned  long  dwError;
	COMSTAT	  comstat;

	if( flag ==RECCHAN) //rx
		dev= &G_Channel.chan_data[ChanNo].rchanpara;
	else dev = &G_Channel.chan_data[ChanNo].tchanpara;

	if(dev->devId <= (int)INVALID_HANDLE_VALUE) return;
	switch(dev->Type)
	{
	case	COM:
		ClearCommError((HANDLE)dev->devId, &dwError, &comstat);
		if (comstat.cbInQue>400) nBytes = 400;
		else nBytes = comstat.cbInQue;					
		ReadFile((HANDLE)dev->devId, inbuff, nBytes, &nBytesRead, NULL);		
		break;

	case    TCPRTU:
		ret = ReadPort(dev->devId, inbuff, 400);
		if(ret>=0) 
			nBytesRead=ret;
		else
		{
			nBytesRead=0;
		}
		break;

	case UDPRTU:
		ret = udp_read(ChanNo,dev->devId,inbuff,400,dev->devName);
		if(ret > 0)
			nBytesRead = ret;
		else
			nBytesRead =0;		
		break;

	default:
		break;
	}
		
	if (nBytesRead>0)
	{
		MainFrame->ShowDataToView(ChanNo,flag,1,inbuff,nBytesRead);
		if(flag == RECCHAN) G_Channel.chan_data[ChanNo].rchanpara.RecCnt += nBytesRead;
		else G_Channel.chan_data[ChanNo].tchanpara.RecCnt += nBytesRead;
		
		for (uint j=0;j<nBytesRead; j++)
		{
			if( flag == RECCHAN) //rx
			{
				rx= &G_Channel.chan_data[ChanNo].recrx ;
			}
			else 
			{
				rx= &G_Channel.chan_data[ChanNo].senrx ;
			}
			rx->buf[rx->tailP]=inbuff[j];
			rx->tailP = (rx->tailP+1)%RECLength;
		}
		return ;  
	}
	else
	{
		if( flag ==RECCHAN) //rx
		{
		    G_Channel.chan_data[ChanNo].recrxErrCnt += nBytesRead;
			if(G_Channel.chan_data[ChanNo].recrxErrCnt>=MAXRECERRNUM)
			{
				dev->resetf =1;
				G_Channel.chan_data[ChanNo].recrxErrCnt =0;
			}
		}	   
	}

	return ; 
}

void  WriteAChan(int ChanNo,uchar flag)
{
	unsigned long nActualWrite;
	char	outBuff[512],devName[24];
	TXBUF	*tx;
	int		cnt,	ret,nWrites;
	DEVPARA * dev;
	
	if( flag == RECCHAN) //rx
	{
		tx= &G_Channel.chan_data[ChanNo].rectx ;
		dev = &G_Channel.chan_data[ChanNo].rchanpara;
		strcpy(devName,dev->devName);
	}
	else 
	{
		tx= &G_Channel.chan_data[ChanNo].sentx ;
		dev = &G_Channel.chan_data[ChanNo].tchanpara;
		strcpy(devName,dev->devName);
	}
	//if(dev->devId <= (int)INVALID_HANDLE_VALUE) return;
	cnt =0;
	while(tx->tailP != tx->headP)
	{
		uchar val = tx->buf[tx->headP];
		outBuff[cnt] = val;
		tx->headP = (tx->headP + 1) % TRNLength;
		cnt++;
	}
	if (cnt == 0)	return ;

	if(flag==RECCHAN) G_Channel.chan_data[ChanNo].rchanpara.SendCnt += cnt;
	else G_Channel.chan_data[ChanNo].tchanpara.SendCnt += cnt;

	if (dev->Type==COM)
	{
		ret = WriteFile((HANDLE)dev->devId, outBuff, cnt, &nActualWrite,NULL);
		if(!ret) 
		{
			nActualWrite = 0;
		}
	}
	else if (dev->Type==TCPRTU)
	{
		nWrites = WritePort(dev->devId,outBuff,cnt);
		if(nWrites <= 0) {
			//dev->resetf = 1;
			nActualWrite = 0; 
		}
		else	{nActualWrite = nWrites; }
	}
	else if(dev->Type==UDPRTU)
	{
		nWrites = udp_write(ChanNo,dev->devId,outBuff,cnt,dev->devName );
		if(nWrites<0) {
			nActualWrite = 0; 
		}
		else
		{
			nActualWrite = nWrites; 		
		}
	}
	if(nActualWrite >0)	MainFrame->ShowDataToView(ChanNo,flag,0,outBuff,nActualWrite);
    else
	{
		dev->resetf=1;
	}
}

//-------------------------------------------------------------------
UINT openproc(void *arg)
{
    int			i,intCount=0;
    DEVPARA * dev;
    while (live_flag)