communication.cpp

用于DSP下摄像机的图像抓取、图像处理和传输、以及与上位机TCP/IP通信的工程文件。基于Texas Instruments Code Composer Studio实现。

#include "Phocus1820BSP.h"
#include "CommonDef.h"
#include "Config.h"
#include "Protocal.h"
#include "Net.h"
#include "Sync.h"
#include <stdlib.h>
#include <string.h>
#include "Phocus1820IMG.h"

struct sockaddr_in CiLinkCommu::m_sockIPAddr = {0};
char Rs_Buffer[19] = {}; 

CiLinkCommu::~CiLinkCommu()
{	
	if(m_nMainSock != INVALID_SOCKET)
	{
		fdClose(m_nMainSock);
		m_nMainSock = INVALID_SOCKET;
	}
	if(m_nSlaveSock != INVALID_SOCKET)
	{
		fdClose(m_nSlaveSock);
		m_nSlaveSock = INVALID_SOCKET;
	}
	delete m_pProto;
}

CiLinkCommu::CiLinkCommu(int nCommuType, int nTimeOut, int nPort, char* pBuf, unsigned int unBufLen)
{
	m_nMainSock = INVALID_SOCKET;
	m_nSlaveSock = INVALID_SOCKET;
	m_nTimeout = nTimeOut;
	m_nPort = nPort;
	m_nCommuType = nCommuType;
	
	//Which protocal this communication use
	m_pProto = new CiLink(this, pBuf, unBufLen);
}

/*
int CiLinkCommu::Init()
{
	char broadcast = 1;
	
	if(m_nCommuType == COMMU_TCP)
	{
		m_nMainSock = socket(AF_INET, SOCK_STREAM, 0); 	   
    	if(m_nMainSock < 0 )
        	return -1;
        
    	bzero(&m_sockAddr, sizeof(struct sockaddr_in));
    	m_sockAddr.sin_family = AF_INET;
    	m_sockAddr.sin_len    = sizeof(m_sockAddr);
    	m_sockAddr.sin_port   = htons(m_nPort);
		m_sockAddr.sin_addr.s_addr = INADDR_ANY;
         
    	if (bind(m_nMainSock, (PSA)&m_sockAddr, sizeof(m_sockAddr)) < 0)
        	return -1;  
        
    	if (listen(m_nMainSock, 5) < 0)
        	return -1;	
        	
        return 0;
	}
	else if(m_nCommuType == COMMU_RAW)
	{
//		if(m_nMainSock == INVALID_SOCKET)
			m_nMainSock = socket(AF_INET, SOCK_RAW, IPPROTO_IP);

		setsockopt(m_nMainSock, SOL_SOCKET, SO_BROADCAST, (char*)&broadcast, sizeof(broadcast));
		m_sockAddr.sin_family = AF_INET;
		m_sockAddr.sin_len = sizeof(struct sockaddr);
		return 0;
	}
	else
		return -1;
}
*/

int CiLinkCommu::Init()
{
	char broadcast = 1;
	
	if(m_nCommuType == COMMU_TCP)
	{
		m_nMainSock = socket(AF_INET, SOCK_STREAM, 0); 	   
    	if(m_nMainSock < 0 )
        	return -1;
        
    	bzero(&m_sockAddr, sizeof(struct sockaddr_in));
    	m_sockAddr.sin_family = AF_INET;
    	m_sockAddr.sin_len    = sizeof(m_sockAddr);
    	m_sockAddr.sin_port   = htons(m_nPort);
		m_sockAddr.sin_addr.s_addr = INADDR_ANY;
         
    	if (bind(m_nMainSock, (PSA)&m_sockAddr, sizeof(m_sockAddr)) < 0)
        	return -1; 	
        	
        return 0;
	}
	else if(m_nCommuType == COMMU_RAW)
	{
//		if(m_nMainSock == INVALID_SOCKET)
			m_nMainSock = socket(AF_INET, SOCK_RAW, IPPROTO_IP);

		setsockopt(m_nMainSock, SOL_SOCKET, SO_BROADCAST, (char*)&broadcast, sizeof(broadcast));
		m_sockAddr.sin_family = AF_INET;
		m_sockAddr.sin_len = sizeof(struct sockaddr);
		return 0;
	}
	else
		return -1;
}


int CiLinkCommu::SendData(char * pBuffer,int nLen)
{	
    struct timeval timeout;  
	timeout.tv_sec  = m_nTimeout;
    timeout.tv_usec = 0; 
    if(m_nCommuType == COMMU_TCP)  
    { 
		setsockopt(m_nSlaveSock, SOL_SOCKET, SO_SNDTIMEO, &timeout, sizeof(timeout));
		if(send(m_nSlaveSock, pBuffer, nLen, 0) == -1)	
			return -1; 
		return 0;
	}	
	else if(m_nCommuType == COMMU_RAW)
	{	
   		//Net config use udp for sending the response packet, port is 5680
		m_nSlaveSock = socket(AF_INET, SOCK_DGRAM, 0);
		m_sockIPAddr.sin_port = 0x3016;//htons(5680);
	
		if(connect(m_nSlaveSock, (struct sockaddr *)&m_sockIPAddr, sizeof(m_sockIPAddr)) != -1)
		{
			if(sendto(m_nSlaveSock, pBuffer, nLen, 0, &m_sockIPAddr, sizeof(m_sockIPAddr)) > 0)
			{
				fdClose(m_nSlaveSock);
				return ENO;
			}
		}
		fdClose(m_nSlaveSock);		
		return -1;
	}
	else
		return -1;	
	
}

int CiLinkCommu::SendSync()
{
	//Sychronize every request packet
	char strSync[4] = {'U', 'N', 'I', 'C'};
	if(SendData(strSync, 4) != 0)
		return -1;
	return 0;
}

int CiLinkCommu::RecvSync()
{
	int state = 0;
	char c;
	struct timeval timeout;
	int rc = 1;
	
	//Sychronize every request packet
	while(1)
	{
		timeout.tv_sec  = 5;
    	timeout.tv_usec = 0;
		setsockopt(m_nSlaveSock, SOL_SOCKET, SO_RCVTIMEO, &timeout, sizeof(timeout));
		if((rc = recv(m_nSlaveSock, &c, 1, 0)) != 1)
		{
/*			switch (fdError())
			{
				case EBADF:
					break;
				case EINVAL:
					break;
				case ENOTCONN:
					break;
				case ENOTSOCK:
					break;
				case ETIMEDOUT:
					break;
				case EWOULDBLOCK:
					break;	
				default :
					rc = -1;
					break;	
			}*/
			return rc;
		}
		else
		{
			switch(c)
			{
				case 'U':
				{
					state = 1;
					break;
				}
				case 'N':
				{
					state = (state == 1) ? 2 : 0;
					break;	
				}
				case 'I':
				{
					state = (state == 2) ? 3 : 0;
					break;
				}
				case 'C':
				{
					state = (state == 3) ? 4 : 0;
					break;
				}				
			}		
		}		
		if(state == 4)
		{
			rc = 1;
			break;
		}
	}
	return rc;
}

int CiLinkCommu::ReceiveData(char* pBuffer, int nLen, int nTimeout)
{
	int remain = nLen;
	int cc = 0;
    struct timeval timeout;
	timeout.tv_sec = m_nTimeout;
    timeout.tv_usec = 0;
    
    if(m_nCommuType == COMMU_TCP)	
    {	
		setsockopt(m_nSlaveSock, SOL_SOCKET,SO_RCVTIMEO, &timeout, sizeof(timeout));			
	
		//Because of streaming service, we must receive repeated
		while(remain > 0)
		{
			cc = recv(m_nSlaveSock, pBuffer + nLen - remain, remain, 0); 
		
			if(cc <= 0)
				return -1;			
			remain -= cc;
		}
		
		return 0;
	}
	else if(m_nCommuType == COMMU_RAW)
	{
		int len = sizeof(struct sockaddr);
		if(recvfrom(m_nMainSock, pBuffer, nLen, 0, (struct sockaddr*)&m_sockIPAddr, &len) < 0)
			return  -1;	
		return 0;
	}
	else
		return -1;

}

void CiLinkCommu::DoCommu()
{
	m_pProto->ParseProcess(m_nCommuType);
	return;
}

int CiLinkCommu::SetProtocal(int nProtoType)
{
	return 0;
}

/*
extern "C" void NormCmdHandle()
{
    int size = 0;
    int rc;
	CiLinkCommu* pNormLink = NULL;
	
	fdOpenSession(TaskSelf());
	
	pNormLink = new CiLinkCommu(COMMU_TCP, 30, 5678, dataBuf, sizeof(dataBuf));	
	
	
	if(pNormLink == NULL)
		goto leave;
	
	if(pNormLink->Init() != 0)
		goto leave;
		
	g_nNetOK = 1;	

	//Change the server status	
	g_nNormStatus = 1;
	
	//if it is not the first time to initialize net stack, it mean net stack reboot,
	//this happened when there is a net config operation, so when net stack reboot completed,
	//we must post message to net cofig task

	size = sizeof(struct sockaddr_in);
	
	g_nNetStackStoped = 0;
	
	while(true) 	
	{    
    	printf("Port 5678 waiting for connection...\n");
    	 	
    	pNormLink->m_nSlaveSock = accept(pNormLink->m_nMainSock, (PSA)&(pNormLink->m_sockAddr), &size);
    	if(pNormLink->m_nSlaveSock > 0)
    	{
			printf("Port 5678: opened\n");		
							
//			while(true)
			while(g_nNetOK)
			{
				//Net stack will be stoped, so stop this task
				if(g_nNetStackStoped == 1)
				{
					printf("Net stack stoped\n");

					goto leave;
				}
				
				rc = pNormLink->RecvSync();
				if(rc == 1)
					pNormLink->DoCommu();
				else if(rc == 0)
					break;
			}

			printf("Port 5678: closed\n");

			fdClose(pNormLink->m_nSlaveSock);			
		}	
	}
	
leave:
	printf("Port 5678: closed\n");	

   	if(pNormLink != NULL)
   	{
   		delete pNormLink;

		printf("Memory free ok\n");	

   		pNormLink = NULL;
   	} 	   
	return ;	
}
*/

extern "C" void NormCmdHandle()
{
    int size = 0;
    int rc;
	CiLinkCommu* pNormLink = NULL;
	
	fdOpenSession(TaskSelf());
	
	pNormLink = new CiLinkCommu(COMMU_TCP, 3, 5678, dataBuf, sizeof(dataBuf));	
	
	if(pNormLink == NULL)
		goto leave;

	if(pNormLink->Init() != 0)
		goto leave;	

	//Change the server status	
	g_nNormStatus = 1;

	size = sizeof(struct sockaddr_in);
	
	g_nNetStackStoped = 0;
	
	while(true) 	
	{       
    	rc = listen(pNormLink->m_nMainSock, 1);
    	
    	#ifdef _DEBUG
//    	printf("Port 5678: wait for connnecting\n");
    	#endif
    	
    	pNormLink->m_nSlaveSock = accept(pNormLink->m_nMainSock, (PSA)&(pNormLink->m_sockAddr), &size);
    	
    	#ifdef _DEBUG
//    	printf("Port 5678: connnected\n");
    	#endif
    	
    	if(pNormLink->m_nSlaveSock != INVALID_SOCKET)
    	{
			rc = pNormLink->RecvSync();
			if(rc == 1)
				pNormLink->DoCommu();
//			else if(rc == 0)
//				break;			
		}
		#ifdef _DEBUG
//		printf("Port 5678: closed\n");
		#endif

		fdClose(pNormLink->m_nSlaveSock);
		pNormLink->m_nSlaveSock = INVALID_SOCKET;		
	}
	
leave:
	#ifdef _DEBUG
//	printf("Port 5678: closed\n");	
	#endif

   	if(pNormLink != NULL)
   	{
   		delete pNormLink;
   		
		#ifdef _DEBUG
//		printf("Memory free ok\n");	
		#endif

   		pNormLink = NULL;
   	} 	   
	return ;	
}

extern "C" void RS232Handle()
{
	char c;
	int timeout = -1;
	int nBaudrate;
	MBX_MESSAGE  rs_send; 
	static char rs_start = 0; 
	
	Phocus1820_rs232_open(O_RESET);	
	Phocus1820_read_rs232_info(&nBaudrate);	
	Phocus1820_rs232_set_baudrate(nBaudrate);
	
	while(1)
	{
		Phocus1820_rs232_read(&c, 1, &timeout);  
		{
			if((unsigned char)c == 0)
			{
				rs_start = 1;
			}			
			else if(((unsigned char)c > 0x14) && (rs_start))
			{   
				rs_start = 0;
				rs_send.nDataType = DATA_JPEG;
				rs_send.nCommand = 1;
				Rs_Buffer[0] = c;
				Rs_Buffer[1] = 1;				
				rs_send.pData = Rs_Buffer;
				rs_send.nDataLen = 2;					
				MBX_post(hMbxSoftTriger, &rs_send, 0);
								
			}
			
		}  
		
	}
}

extern "C" void RS485Handle()
{
	char c;
	int timeout = -1;
	int nBaudrate;
	MBX_MESSAGE rs_image, rs_send;
	static char rs_start = 0;
	
	Phocus1820_rs485_open(O_RESET);	

	Phocus1820_read_rs485_info(&nBaudrate);	
	Phocus1820_rs485_set_baudrate(nBaudrate);
	
	while(1)
	{
		Phocus1820_rs485_read(&c, 1, &timeout);  
		{
			if(!((unsigned char)c & (1<<7))) 
			{   
				if((!((unsigned char)c & 0x60)) && (!rs_start))//00
				{   
					rs_start = 1;					
					MBX_post(hMbxImageSerial, &rs_image, 0);
				} 
				else if(((unsigned char)c & 0x60) == 0x20) //01
				{
					
				} 
				else if(((unsigned char)c & 0x60) == 0x40) //10
				{ 
					Phocus1820_rs485_read(Rs_Buffer, 2, &timeout);
				}                                           
				else if((((unsigned char)c & 0x60) == 0x60) && rs_start) //11
				{	
					rs_start = 0;			
					Phocus1820_rs485_read(Rs_Buffer, 2, &timeout);
					Rs_Buffer[2] = 2;
					rs_send.nCommand = 1;
					rs_send.nDataType = DATA_JPEG;
					rs_send.pData = Rs_Buffer;
					rs_send.nDataLen = 3;
					MBX_post(hMbxSoftTriger, &rs_send, 0);
				}
			}
		}  		
	}			
}