【网络通信】Wince 和 PC 通过USB 用Socket 进行通信

最新推荐文章于 2023-10-06 15:02:47 发布
最新推荐文章于 2023-10-06 15:02:47 发布
阅读量1.2k 收藏 1
点赞数

【网络通信】Wince 和 PC 通过USB 用Socket 进行通信

转注：未经验证，但可能有用

分类： 【网络通信】 2013-12-11 10:11 86人阅读 评论(1) 收藏 举报
网络 usb socket wince windows mobile

网上资料比较少或者说讲的不太详细，现在进行总结下，刚毕业没接触过WINce，不过和MFC差不多，现在进入正题



刚开始我的疑惑是Wince是如何和PC进行通信的，以及能在USB模式下进行socket通信，后来知道，当你将（要安装Windows Mobile 设备中心）USB把Wince和PC相连接的时候，我在想WInce的IP如何和PC的IP在一个网段，要知道connect socket要在一个网段的，后来知道Wince用USB连接后（我猜是有虚拟网卡）会给WINce默认一个192.168.55.101的IP， 255.255.255.0的子网掩码，以及192.168.55.100的网关（你可以在连接USB后用wince的command和ipconfig下），然后网上查找会给电脑一个192.168.55.100的IP，我在想那么多Wince，而我的需求是不能再界面上配置IP，那么多wince设备连接，IP是如何分配的。我需要在程序里写死，后来知道Wince的IP是固定的，这样就简单了。


好知道了IP和原理接下去是如何进行通信了，你会说，和还不一样，和MFC的Socket一样呗。我开始也是这么理解的，网上资料又少，绕了很多路，在Wince和PC用USB通信的情况下，Wince只能做客户端，PC只能做服务端（我反过来试了下没能成功），谷歌上写的也是如此，这样害我的工作一下子变麻烦了。


========================

下面先贴出Wince客户端的代码：

[cpp] view plain copy print ? 在CODE上查看代码片 派生到我的代码片
  1. WORD wVersionRequested;  
  2.     WSADATA wsaData;  
  3.     int err;  
  4.   
  5.     fd_set fdRead;  
  6.     timeval TimeOut;  
  7.     TimeOut.tv_sec=0;  
  8.     TimeOut.tv_usec=500;  
  9.   
  10.     int nNetTimeout = 500;  
  11.   
  12.     wVersionRequested = MAKEWORD( 1, 1 );  
  13.   
  14.     err = WSAStartup( wVersionRequested, &wsaData );  
  15.     if ( err != 0 ) {  
  16.         return 0;  
  17.     }  
  18.     //WinSock DLL 版本是否低于1.1   
  19.   
  20.     if ( LOBYTE( wsaData.wVersion ) != 1 ||  
  21.         HIBYTE( wsaData.wVersion ) != 1 ) {  
  22.             WSACleanup( );  
  23.             return 0;   
  24.     }  
  25.   
  26.   
  27.     SOCKET sockClient;  
  28.     int     nRet = 0;  
  29.     DWORD   dwErr = 0;  
  30.     byte    msg[1024];  
  31.     byte    recvData[255];  
  32.   
  33.     SOCKADDR_IN addrSrv;  
  34.     addrSrv.sin_addr.S_un.S_addr=inet_addr("192.168.55.100");  
  35.     addrSrv.sin_family=AF_INET;  
  36.     addrSrv.sin_port=htons(26023);  
  37.   
  38.     sockClient=socket(AF_INET,SOCK_STREAM,0);  
  39.   
  40.     while(true)  
  41.     {  
  42.         if(WAIT_OBJECT_0 == WaitForSingleObject(pDlg->m_hReadHandle, 500))  
  43.         {  
  44.             SetEvent(pDlg->m_hExitReadHandle);  
  45.             break;  
  46.         }  
  47.           
  48.         //向服务器发出连接请求   
  49.         nRet = connect(sockClient,(SOCKADDR*)&addrSrv,sizeof(SOCKADDR));  
  50.         if(SOCKET_ERROR == nRet)  
  51.         {  
  52.             //pDlg->GetDlgItem(IDC_STATIC_MSG)->SetWindowText(_T("USB连接失败，请检查数据线！"));   
  53.             //dwErr = WSAGetLastError();   
  54.             Sleep(1000);  
  55.             continue;  
  56.         }  
  57.   
  58.         int nLen = 0;  
  59.         ZeroMemory(&msg, sizeof(msg));  
  60.         pDlg->GetDlgItem(IDC_STATIC_MSG)->SetWindowText(_T("USB已连接。"));  
  61.   
  62.         while(true)  
  63.         {  
  64.             if(WAIT_OBJECT_0 == WaitForSingleObject(pDlg->m_hReadHandle, 500))  
  65.             {  
  66.                 SetEvent(pDlg->m_hExitReadHandle);  
  67.                 goto END;         
  68.             }  
  69.             int nRecvLen = 0;  
  70.             ZeroMemory(&recvData, sizeof(recvData));  
  71.   
  72. //          FD_ZERO(&fdRead);   
  73. //          FD_SET(sockClient,&fdRead);   
  74. //          int ret=::select(0,&fdRead,NULL,NULL,&TimeOut);   
  75. //          if (ret == 0)   
  76. //          {   
  77. //              closesocket(sockClient);   
  78. //              sockClient=socket(AF_INET,SOCK_STREAM,0);      
  79. //              break;   
  80. //    
  81. //          }   
  82.   
  83.             int backcon = setsockopt(sockClient,SOL_SOCKET, SO_RCVTIMEO,(char *)&nNetTimeout,sizeof(int));   
  84.   
  85.             nRecvLen = recv(sockClient,(char*)&recvData,sizeof(recvData),0);  
  86.   
  87.   
  88.             if (SOCKET_ERROR == nRecvLen)  
  89.             {  
  90.                 //pDlg->GetDlgItem(IDC_STATIC_MSG)->SetWindowText(_T("USB连接失败或无发行系统无初始化操作！"));   
  91.                 closesocket(sockClient);  
  92.                 sockClient=socket(AF_INET,SOCK_STREAM,0);  
  93.                 break;  
  94.             }  
  95.             if (nRecvLen == 0)  
  96.             {  
  97.   
  98.                 TRACE(L"Recv 0\n");  
  99.                 Sleep(50);  
  100.                 continue;  
  101.             }  
  102.   
  103.             if(/*SOCKET_ERROR != nRecvLen && */0 != nRecvLen)  
  104.             {  
  105.                 if(0 == nLen && 0x31 == recvData[0] )  
  106.                 {  
  107.                     memcpy(msg, recvData, nRecvLen);  
  108.                     nLen += nRecvLen;  
  109.                 }  
  110.                 else if(0 < nLen)  
  111.                 {  
  112.                     memcpy(msg + nLen, recvData, nRecvLen);  
  113.                     nLen += nRecvLen;  
  114.                 }  
  115.   
  116.   
  117.   
  118.                 if(0 < nLen )  
  119.                 {  
  120.                     //   
  121.                     int SInitLen = recvData[1] * 0x100 + recvData[2];  
  122.                     //   
  123.                     if (SInitLen == nLen)  
  124.                     {  
  125.   
  126.                         if(pDlg->AnalyseInitMsg(msg, nLen))  
  127.                         {  
  128.                             send(sockClient, "ok", 3, 0);  
  129.                             pDlg->GetDlgItem(IDC_STATIC_MSG)->SetWindowText(_T("初始化完成,正在返回！"));  
  130.                             Sleep(500);  
  131.                               
  132.                             pDlg->PostMessage(WM_INITSUCCESS, 0, 0);                                   
  133.                         }  
  134.                         else  
  135.                         {  
  136.                             send(sockClient, "error", 6, 0);  
  137.                             Sleep(500);  
  138.                             //pDlg->GetDlgItem(IDC_STATIC_USBINIT)->SetWindowText(_T("初始化失败，重新获得配置信息。"));   
  139.                             pDlg->GetDlgItem(IDC_STATIC_MSG)->SetWindowText(_T("初始化失败，重新获得配置信息。"));  
  140.   
  141.                         }  
  142.   
  143.                     }  
  144.                 }  
  145.   
  146.             }  
  147.   
  148.   
  149.         }  
  150.     }  
WORD wVersionRequested;
	WSADATA wsaData;
	int err;

	fd_set fdRead;
	timeval TimeOut;
	TimeOut.tv_sec=0;
	TimeOut.tv_usec=500;

	int nNetTimeout = 500;

	wVersionRequested = MAKEWORD( 1, 1 );

	err = WSAStartup( wVersionRequested, &wsaData );
	if ( err != 0 ) {
		return 0;
	}
	//WinSock DLL 版本是否低于1.1

	if ( LOBYTE( wsaData.wVersion ) != 1 ||
		HIBYTE( wsaData.wVersion ) != 1 ) {
			WSACleanup( );
			return 0; 
	}


	SOCKET sockClient;
	int		nRet = 0;
	DWORD	dwErr = 0;
	byte	msg[1024];
	byte	recvData[255];

	SOCKADDR_IN addrSrv;
	addrSrv.sin_addr.S_un.S_addr=inet_addr("192.168.55.100");
	addrSrv.sin_family=AF_INET;
	addrSrv.sin_port=htons(26023);

	sockClient=socket(AF_INET,SOCK_STREAM,0);

	while(true)
	{
		if(WAIT_OBJECT_0 == WaitForSingleObject(pDlg->m_hReadHandle, 500))
		{
			SetEvent(pDlg->m_hExitReadHandle);
			break;
		}
		
		//向服务器发出连接请求
		nRet = connect(sockClient,(SOCKADDR*)&addrSrv,sizeof(SOCKADDR));
		if(SOCKET_ERROR == nRet)
		{
			//pDlg->GetDlgItem(IDC_STATIC_MSG)->SetWindowText(_T("USB连接失败，请检查数据线！"));
			//dwErr = WSAGetLastError();
			Sleep(1000);
			continue;
		}

		int nLen = 0;
		ZeroMemory(&msg, sizeof(msg));
		pDlg->GetDlgItem(IDC_STATIC_MSG)->SetWindowText(_T("USB已连接。"));

		while(true)
		{
			if(WAIT_OBJECT_0 == WaitForSingleObject(pDlg->m_hReadHandle, 500))
			{
				SetEvent(pDlg->m_hExitReadHandle);
				goto END;		
			}
			int nRecvLen = 0;
			ZeroMemory(&recvData, sizeof(recvData));

// 			FD_ZERO(&fdRead);
// 			FD_SET(sockClient,&fdRead);
// 			int ret=::select(0,&fdRead,NULL,NULL,&TimeOut);
// 			if (ret == 0)
// 			{
// 				closesocket(sockClient);
// 				sockClient=socket(AF_INET,SOCK_STREAM,0);	
// 				break;
// 
// 			}

			int backcon = setsockopt(sockClient,SOL_SOCKET, SO_RCVTIMEO,(char *)&nNetTimeout,sizeof(int)); 

			nRecvLen = recv(sockClient,(char*)&recvData,sizeof(recvData),0);


			if (SOCKET_ERROR == nRecvLen)
			{
				//pDlg->GetDlgItem(IDC_STATIC_MSG)->SetWindowText(_T("USB连接失败或无发行系统无初始化操作！"));
				closesocket(sockClient);
				sockClient=socket(AF_INET,SOCK_STREAM,0);
				break;
			}
			if (nRecvLen == 0)
			{

				TRACE(L"Recv 0\n");
				Sleep(50);
				continue;
			}

			if(/*SOCKET_ERROR != nRecvLen && */0 != nRecvLen)
			{
				if(0 == nLen && 0x31 == recvData[0] )
				{
					memcpy(msg, recvData, nRecvLen);
					nLen += nRecvLen;
				}
				else if(0 < nLen)
				{
					memcpy(msg + nLen, recvData, nRecvLen);
					nLen += nRecvLen;
				}



				if(0 < nLen )
				{
					//
					int SInitLen = recvData[1] * 0x100 + recvData[2];
					//
					if (SInitLen == nLen)
					{

						if(pDlg->AnalyseInitMsg(msg, nLen))
						{
							send(sockClient, "ok", 3, 0);
							pDlg->GetDlgItem(IDC_STATIC_MSG)->SetWindowText(_T("初始化完成,正在返回！"));
							Sleep(500);
							
							pDlg->PostMessage(WM_INITSUCCESS, 0, 0);									
						}
						else
						{
							send(sockClient, "error", 6, 0);
							Sleep(500);
							//pDlg->GetDlgItem(IDC_STATIC_USBINIT)->SetWindowText(_T("初始化失败，重新获得配置信息。"));
							pDlg->GetDlgItem(IDC_STATIC_MSG)->SetWindowText(_T("初始化失败，重新获得配置信息。"));

						}

					}
				}

			}


		}
	}
[cpp] view plain copy print ? 在CODE上查看代码片 派生到我的代码片
  1. END:  
  2. <SPAN style="WHITE-SPACE: pre"> </SPAN>//关闭套接字   
  3. <SPAN style="WHITE-SPACE: pre"> </SPAN>closesocket(sockClient);  
  4. <SPAN style="WHITE-SPACE: pre"> </SPAN>WSACleanup();  
  5.   
  6.   
  7. <SPAN style="WHITE-SPACE: pre"> </SPAN>return 0;  
  8. }  
END:
	//关闭套接字
	closesocket(sockClient);
	WSACleanup();


	return 0;
}

这里你发现我设置的IP是192.168.55.100

而不是192.168.55.101的WinceIP ，为什么用100网关而不用101Wince的100，因为PC端会虚拟一个100的IP对应

在这里你会发现，当你连接USB后connect会成功，Socket默认是阻塞模式的，你会发现执行到recv的时候它却直接返回-1（当你起了服务端后，recv会死等，正常情况）；

原理这里的connect不是真正的连接成功了，所以这里recv后你还应该去做判断是否真的连接成功了，这里我开始用了select模式超时，依然无法判断是否真的连接成功。

所以我这里占时做的是如果recv-1；直接从新socket去connect，（这里不知道你会不会发现问题，当用户将USB连接后而没起服务端，这里你就会反复socket创建，但是socket线程池，即原先的socket好像是2分钟才回收，根本来不及回收，不会发现过一会后socket的返回值会很大（1,3,5,7......）如此增加，我在想最终肯定会超出上限奔溃，），有人可能会说那在recv失败后线sleep下啊。多等待让socket回收啊。可惜我的用户是国安的老年人，要在不小心掉了数据线后再次插上后马上重连（recv阻塞模式死等会很久），没办法，我只能另外起线程，判断用户多久一直没操作就关闭socket不在重新创建，操作的时候如何没connect上在创建socket。这里我也采用了超时recv，因为需求不能在recv死等太久。


当然由于没用过select和时间有限，那时候的思路是这样的，采用select超时模式，因为当服务端没起来。connect是假的connect，应该和（window设备中心的一个虚拟的连接上了），这时候判断recv返回-1的情况下是否超出了超时时间，没有超出超时时间，那说明直接返回的recv-1，是前面connect是假连接。


======================================下面是服务端


[cpp] view plain copy print ? 在CODE上查看代码片 派生到我的代码片
  1. static int nInitCount = 0;  
  2.     //加载套接字socket（插座）   
  3.     WORD wVersionRequested;                 //typedef unsigned short WORD;   
  4.     WSADATA wsaData;                        //结构体  typedef struct WSAData   WSADATA    。typedef WSADATA FAR *LPWSADATA;   
  5.     int nReg = 0;                           //错误函数的检测数值传递给nReg   
  6.     SOCKET sockSvr;                         //typedef _W64 unsigned int 、、SOCKET;     
  7.     SOCKADDR_IN addrSrv;  
  8.     int nErrCode = 0;  
  9.     int bExit = 0;  
  10.     unsigned long ul = -1;  
  11.   
  12.     struct timeval timeout={2,0};  
  13.     fd_set rfd;  
  14.     int nfds;  
  15.   
  16.     wVersionRequested = MAKEWORD(1, 1);     //请求.1版本socket   
  17.   
  18.     nReg = WSAStartup(wVersionRequested,&wsaData);//初始化   
  19.     if (0 != nReg)  
  20.     {  
  21.         printf("err code :%d",WSAGetLastError());  
  22.         return 0;  
  23.     }  
  24.     if (LOBYTE(wsaData.wVersion) != 1 || HIBYTE(wsaData.wVersion) != 1)  
  25.     {  
  26.         printf("VERSION DIFF");  
  27.         WSACleanup();  
  28.         return 0;  
  29.     }  
  30.   
  31.     sockSvr = socket(AF_INET, SOCK_STREAM, 0); //socket(IN int af,IN int type,IN int protocol); SOCK_STREAM（使用TCP协议而不是UDP）创建socket   
  32. //  nErrCode = ioctlsocket(sockSvr, FIONBIO, (unsigned long*)&ul);                 //设置套接字非阻塞模式   
  33. //  if (nErrCode == SOCKET_ERROR)   
  34. //  {   
  35. //      //设置套接字非阻塞模式，失败处理   
  36. //  }   
  37.     if (INVALID_SOCKET == sockSvr)             //判断sock是否创建成功   
  38.     {  
  39.         printf("err code :%d",WSAGetLastError());//获取错误类型函数WSAGetLastError()   
  40.         return 0;  
  41.     }  
  42.   
  43.     //设定内部接口   
  44.     addrSrv.sin_family = AF_INET;                                       //启动协议   
  45.     addrSrv.sin_addr.S_un.S_addr = htonl(INADDR_ANY);                   //绑定地址   
  46.     addrSrv.sin_port = htons(26023);                                        //绑定端口   
  47.   
  48.     nReg = bind(sockSvr, (SOCKADDR*)&addrSrv, sizeof(SOCKADDR));        //内部接口设定完成将整体绑定到服务器sockSvr   
  49.     if (SOCKET_ERROR == nReg)                                           //判断绑定是否成功   
  50.     {  
  51.         nErrCode = WSAGetLastError();  
  52.         if (nErrCode == WSAEADDRINUSE)                                   //如果端口被占用   
  53.         {  
  54.             //printf("err code :%d,port is already used ",nErrCode);   
  55.         }  
  56.         else  
  57.         {  
  58.   
  59.         }  
  60.             //printf("err code :%d",nErrCode);   
  61.         return 0;  
  62.     }  
  63.   
  64.     //监听，准备接收   
  65.     listen(sockSvr, 5);                                 //最多同时监听个sock   
  66.   
  67.     CString strMsg = _T("");  
  68.     while (TRUE)  
  69.     {  
  70.         if (WAIT_OBJECT_0 == WaitForSingleObject(dlg->m_hEventSocket,100))//结束押运箱   
  71.         {  
  72.             closesocket(sockSvr);                                                //关闭正在于客户端通信的服务端sock   
  73.             WSACleanup();//初始化关闭   
  74.             SetEvent(dlg->m_HEventExitSocket);  
  75.             return 0;  
  76.         }  
  77.         if (dlg->m_bUsbinitingTer)  
  78.         {  
  79.             if (nInitCount == 0)  
  80.             {  
  81.                 strMsg.Format(_T("正在初始化%s手持终端,请等待..."),dlg->m_strTerInitName);  
  82.                 dlg->m_pOutPutView->AddWarnInfo(strMsg,true);  
  83.             }  
  84.               
  85.             SOCKADDR_IN cliAddr;  
  86.             SOCKET cliSock = -1;  
  87.             int nlen = sizeof(SOCKADDR);  
  88.             char buf[1024] = {0};  
  89.   
  90.   
  91.             FD_ZERO(&rfd);  
  92.             FD_SET(sockSvr,&rfd);  
  93.             nfds = select(1,&rfd,(fd_set*) 0,(fd_set*) 0,&timeout);  
  94.   
  95.             if(nfds==0)  
  96.             {  
  97.                 strMsg.Format(_T("请检查手持终端编号是否正确匹配，USB数据线是否正确连接！"));  
  98.                 dlg->m_pOutPutView->AddWarnInfo(strMsg,false);  
  99.                 dlg->m_btn_UsbInitTer.EnableWindow(TRUE);  
  100.                 dlg->m_bUsbinitingTer=false;   
  101.                 continue;  
  102.             }                 
  103.             else if(nfds>0)  
  104.             {  
  105.                 FD_CLR(sockSvr,&rfd);  
  106.                 //accept socket   
  107.                 cliSock = accept(sockSvr, (SOCKADDR*)&cliAddr, &nlen);  等待客户端请求并重新定义一个对应此次链接的socket   
  108.   
  109.   
  110.                 if (WSAEINTR == cliSock)             //判断sock是否创建成功   
  111.                 {  
  112.                     //char recvBuf[100];   
  113.                     /*printf("err code :%d",WSAGetLastError());//获取错误类型函数WSAGetLastError()*/  
  114.                     //return 0;   
  115.                 }  
  116.                 //发送数据   
  117.                 send(cliSock,dlg->m_initterminalbase,dlg->m_TerInitlen,0);  
  118.                 char recvBuf[100];  
  119.                 memset(recvBuf, 0, 100);  
  120.                 Sleep(1000);  
  121.                 //接收数据   
  122.                 recv(cliSock,recvBuf,100,0);  
  123.                 //closesocket(cliSock);   
  124.                 CString back=_T("");  
  125.                 back=(CString)recvBuf;  
  126.   
  127.   
  128.                 if (back!=_T("ok"))  
  129.                 {  
  130.                     nInitCount++;  
  131.                     if (nInitCount == 6)  
  132.                     {  
  133.                         nInitCount = 0;  
  134.                         strMsg.Format(_T("手持终端%s初始化失败,请检查手持终端USB是否正确连接，编号是否匹配！"),dlg->m_strTerInitName);  
  135.                         dlg->m_pOutPutView->AddWarnInfo(strMsg,false);  
  136.                         dlg->m_btn_UsbInitTer.EnableWindow(TRUE);  
  137.                         dlg->m_bUsbinitingTer=false;   
  138.                         continue;  
  139.                     }  
  140.                     else  
  141.                     {  
  142.                         strMsg.Format(_T("手持终端%s初始化失败,正在继续，请等待！"),dlg->m_strTerInitName);  
  143.                         dlg->m_pOutPutView->AddWarnInfo(strMsg,false);  
  144.                         Sleep(1000);              
  145.   
  146.                     }  
  147.   
  148.                 }  
  149.                 else  
  150.                 {  
  151.                     nInitCount = 0;  
  152.                     strMsg.Format(_T("手持终端%s初始化成功！"),dlg->m_strTerInitName);  
  153.                     dlg->m_pOutPutView->AddWarnInfo(strMsg,true);  
  154.                     dlg->m_btn_UsbInitTer.EnableWindow(TRUE);  
  155.                     dlg->m_bUsbinitingTer=false;   
  156.                     continue;  
  157.                 }     
  158.   
  159.             }  
  160.             else  
  161.             {  
  162.                 break;  
  163.   
  164.             }  
  165.               
  166.         }  
  167.           
  168.   
  169.     }  
  170.   
  171.     closesocket(sockSvr);                                                //关闭正在于客户端通信的服务端sock   
  172.     WSACleanup();//初始化关闭   
  173.     return 0;  
  174.   
  175.   
  176. }  
static int nInitCount = 0;
	//加载套接字socket（插座）
	WORD wVersionRequested;					//typedef unsigned short WORD;
	WSADATA wsaData;						//结构体  typedef struct WSAData   WSADATA    。typedef WSADATA FAR *LPWSADATA;
	int nReg = 0;							//错误函数的检测数值传递给nReg
	SOCKET sockSvr;							//typedef _W64 unsigned int 、、SOCKET;  
	SOCKADDR_IN addrSrv;
	int nErrCode = 0;
	int bExit = 0;
	unsigned long ul = -1;

	struct timeval timeout={2,0};
	fd_set rfd;
	int nfds;

	wVersionRequested = MAKEWORD(1, 1);		//请求.1版本socket

	nReg = WSAStartup(wVersionRequested,&wsaData);//初始化
	if (0 != nReg)
	{
		printf("err code :%d",WSAGetLastError());
		return 0;
	}
	if (LOBYTE(wsaData.wVersion) != 1 || HIBYTE(wsaData.wVersion) != 1)
	{
		printf("VERSION DIFF");
		WSACleanup();
		return 0;
	}

	sockSvr = socket(AF_INET, SOCK_STREAM, 0); //socket(IN int af,IN int type,IN int protocol); SOCK_STREAM（使用TCP协议而不是UDP）创建socket
// 	nErrCode = ioctlsocket(sockSvr, FIONBIO, (unsigned long*)&ul);                 //设置套接字非阻塞模式
// 	if (nErrCode == SOCKET_ERROR)
// 	{
// 		//设置套接字非阻塞模式，失败处理
// 	}
	if (INVALID_SOCKET == sockSvr)             //判断sock是否创建成功
	{
		printf("err code :%d",WSAGetLastError());//获取错误类型函数WSAGetLastError()
		return 0;
	}

	//设定内部接口
	addrSrv.sin_family = AF_INET;										//启动协议
	addrSrv.sin_addr.S_un.S_addr = htonl(INADDR_ANY);					//绑定地址
	addrSrv.sin_port = htons(26023);										//绑定端口

	nReg = bind(sockSvr, (SOCKADDR*)&addrSrv, sizeof(SOCKADDR));		//内部接口设定完成将整体绑定到服务器sockSvr
	if (SOCKET_ERROR == nReg)                                           //判断绑定是否成功
	{
		nErrCode = WSAGetLastError();
		if (nErrCode == WSAEADDRINUSE)									 //如果端口被占用
		{
			//printf("err code :%d,port is already used ",nErrCode);
		}
		else
		{

		}
			//printf("err code :%d",nErrCode);
		return 0;
	}

	//监听，准备接收
	listen(sockSvr, 5);									//最多同时监听个sock

	CString strMsg = _T("");
	while (TRUE)
	{
		if (WAIT_OBJECT_0 == WaitForSingleObject(dlg->m_hEventSocket,100))//结束押运箱
		{
			closesocket(sockSvr);                                                //关闭正在于客户端通信的服务端sock
			WSACleanup();//初始化关闭
			SetEvent(dlg->m_HEventExitSocket);
			return 0;
		}
		if (dlg->m_bUsbinitingTer)
		{
			if (nInitCount == 0)
			{
				strMsg.Format(_T("正在初始化%s手持终端,请等待..."),dlg->m_strTerInitName);
				dlg->m_pOutPutView->AddWarnInfo(strMsg,true);
			}
			
			SOCKADDR_IN cliAddr;
			SOCKET cliSock = -1;
			int nlen = sizeof(SOCKADDR);
			char buf[1024] = {0};


			FD_ZERO(&rfd);
			FD_SET(sockSvr,&rfd);
			nfds = select(1,&rfd,(fd_set*) 0,(fd_set*) 0,&timeout);

			if(nfds==0)
			{
				strMsg.Format(_T("请检查手持终端编号是否正确匹配，USB数据线是否正确连接！"));
				dlg->m_pOutPutView->AddWarnInfo(strMsg,false);
				dlg->m_btn_UsbInitTer.EnableWindow(TRUE);
				dlg->m_bUsbinitingTer=false;	
				continue;
			}				
			else if(nfds>0)
			{
				FD_CLR(sockSvr,&rfd);
				//accept socket
				cliSock = accept(sockSvr, (SOCKADDR*)&cliAddr, &nlen);	等待客户端请求并重新定义一个对应此次链接的socket


				if (WSAEINTR == cliSock)             //判断sock是否创建成功
				{
					//char recvBuf[100];
					/*printf("err code :%d",WSAGetLastError());//获取错误类型函数WSAGetLastError()*/
					//return 0;
				}
				//发送数据
				send(cliSock,dlg->m_initterminalbase,dlg->m_TerInitlen,0);
				char recvBuf[100];
				memset(recvBuf, 0, 100);
				Sleep(1000);
				//接收数据
				recv(cliSock,recvBuf,100,0);
				//closesocket(cliSock);
				CString back=_T("");
				back=(CString)recvBuf;


				if (back!=_T("ok"))
				{
					nInitCount++;
					if (nInitCount == 6)
					{
						nInitCount = 0;
						strMsg.Format(_T("手持终端%s初始化失败,请检查手持终端USB是否正确连接，编号是否匹配！"),dlg->m_strTerInitName);
						dlg->m_pOutPutView->AddWarnInfo(strMsg,false);
						dlg->m_btn_UsbInitTer.EnableWindow(TRUE);
						dlg->m_bUsbinitingTer=false;	
						continue;
					}
					else
					{
						strMsg.Format(_T("手持终端%s初始化失败,正在继续，请等待！"),dlg->m_strTerInitName);
						dlg->m_pOutPutView->AddWarnInfo(strMsg,false);
						Sleep(1000);			

					}

				}
				else
				{
					nInitCount = 0;
					strMsg.Format(_T("手持终端%s初始化成功！"),dlg->m_strTerInitName);
					dlg->m_pOutPutView->AddWarnInfo(strMsg,true);
					dlg->m_btn_UsbInitTer.EnableWindow(TRUE);
					dlg->m_bUsbinitingTer=false;	
					continue;
				}	

			}
			else
			{
				break;

			}
			
		}
		

	}

	closesocket(sockSvr);                                                //关闭正在于客户端通信的服务端sock
	WSACleanup();//初始化关闭
	return 0;


}



这里我是当用户PC的服务端点击按钮后发送数据，accept是原本是阻塞模式，这里用select超时模式，
[cpp] view plain copy print ? 在CODE上查看代码片 派生到我的代码片
  1. dlg->m_bUsbinitingTer  
dlg->m_bUsbinitingTer
用来判断用户点击了按钮让其变为ture。
worldy
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
wince与Windows通过USB进行通讯，也支持WIFI
09-25
wince与Windows通过USB进行通讯， 也支持WIFI
PC客户端与Android服务端的Socket同步通信（USB）
热门推荐
吴家大少少的专栏
07-31 6万+
需求：     1.一个android端的service后台运行的程序，作为socket的服务器端;用于接收Pc client端发来的命令，来处理数据后，把结果发给PC client     2.PC端程序，作为socket的客户端，用于给android手机端发操作命令难点分析：     1.手机一定要有adb模式，即插上USB线时马上提示的对话框选adb。好多对手机的操作都可以用adb直接作。        不过，我发现LG GW880就没有，要去下载个     2.android默认手机端的IP为“12
Android端通过Usb建立Socket通讯（实时发送视频数据）
qq_35244415的博客
06-29 6044
Android端通过Usb建立Socket通讯（实时发送视频数据）1.创建出 ServerSocket serverSocket = new ServerSocket(端口10086);2.adnroid端保持等待客户端等待连接状态 Socket accept = serverSocket.accept();4.添加网络请求权限 <uses-permission and
Android中通过USB接口与和PC进行通讯的demo程序
IT熊的专栏
11-01 3862
有时候数据线也能当网线使用，本demo实现了使用USB数据线和PC进行sockect通讯的功能。
PC与Android通过USB连接进行Socket通信
Q540670228的博客
07-15 2501
3.PC这边的Client想要向AndroidServer发送消息，直接向如图4396端口发送即可，注意有人可能注意到为什么不直接让7744直接和5037相连即fowardtcpP1为何不填7744，由于adb是监听端口收到的消息，直接用此端口发消息到5037其是不知该如何转发的，这一层不能缺少。2.为PC和Android搭桥的过程就是图中adbforwardtcpP1tcpP2,其中P1为win/linux等下任一空闲端口号，P2为Android端Server的端口号。...
【网络通信】Wince 和 PC 通过USB 用Socket 进行通信
I am Leon - 产品
12-11 5099
网上资料比较少或者说讲的不太详细，现在进行总结下，刚毕业没接触过WINce，不过和MFC差不多，现在进入正题 刚开始我的疑惑是Wince是如何和PC进行通信的，以及能在USB模式下进行socket通信，后来知道，当你将（要安装Windows Mobile 设备中心）USB把Wince和PC相连接的时候，我在想WInce的IP如何和PC的IP在一个网段，要知道connect soc
关于在WINCE下与Windows下SOCKET通讯问题
RaymondAmos的技术专栏
05-27 2061
关于在WINCE下与Windows下SOCKET通讯问题在采用C/S模式开发应用程序时，当客户端采用EVC开发，运行平台为WINCE，运行设备为POCKET PC 2003，而服务器端采用VC开发，运行平台为 Windows ,二者进行SOCKET通讯时，首先必须解决的问题,POCKET PC 2003的
wince模拟器与PC进行串口通信设置步骤（附详细步骤图解）
xq830210的专栏
07-01 6193
wince模拟器与PC进行串口通信，说明设置步骤，并附详细步骤图解
创建socket项目提示端口号被使用的解决方法
XYY_2001的博客
10-06 408
创建socket数据报套接字udp项目时，服务端程序不恰当关闭后，再次启动会提示错误：Exception in thread "main" java.net.BindException: Address already in use: Cannot bind，显示地址已经被占用。在其中查找关键的UDP和9090 ，记录其中对应的pid为15656。点击pid排序，在其中查找对应的任务，点击结束任务即可。源代码中假设端口号port为9090。打开电脑的任务管理器，点击详细信息。
WINCE系统的Tcp通信
WQFAE01的博客
01-08 1982
TCP是一种面向连接的，可靠的，基于字节流的传输层通信协议。TCP的工作过程可以分为三个阶段： 一、连接的建立：创建服务器绑定IP跟端口，用于监听客户端发来的连接请求， 客户端向服务器发送连接请求 二、传输数据 ：在服务器跟客户端正常连接成功后，可以通过各自的套接字向对方发送数据 三、断开连接：在通信完成后可以通过关闭套接字断开双方的连
pc与android通过usb socket实现手机通信Demo
08-01
a.PC客户端与Android服务端的Socket同步通信（USB） b.操作步骤如下： ----------------------------------------------------------- 1.请将测试数据文件夹中的ucliulanqi.apk copy到c:\下进行测试 2. 将android代码导入到Eclipse中进行调试，或者直接运行里面的apk文件即可。 3.将pc端程序也导入到Eclipse中 运行main函数，执行=====》 输入4 。将复制pc电脑中的 c:\ucliulanqi.apk 到 android手机中的/mnt/sdcard/目录下 4.复制完毕后，请你查看 /mnt/sdcard/下查看 这个ucliulanqi.apk文件。 5.想复制其他文件，请在源码中进行文件夹名字的改动以及在apk中冶要进行调试。 6.综合这两个程序，我总结一下，很扯淡。。还不如用adb push c:\liulanqi.apk /mnt/sdcard/下更方便
wince版socket 通信
02-04
socket 通信(evc的版本),在evc的环境下调试成功
三星6410wince和pc的usb通信驱动
03-11
三星6410ARM11cpu与pc机的usb设备驱动。
通信与网络中的基于wince的网络音视频通信
11-03
　网络视频传输，首先把mini2440与USB摄像头连接在一起，通过USB摄像头捕捉图像（320 x 240，15fps），然后通过UDP协议发送至PC端，在PC屏幕上以15fps的速度显示。 　网络音频传输，首先在mini2440和PC上都插入...
PC机与WinCE进行通信 通过微软提供的TCP/IP协议
03-13
PC机与WinCE进行通信 通过微软提供的TCP/IP协议 PC Wince
客户端和服务端通讯框架Socket通信C# .NET
04-30
客户端和服务端通讯框架Socket通信C# .NET,可以用于客户端和服务端的点对点连接通信使用，仅供参考
多图表实现员工满意度调查数据分析python
04-22
员工满意度是指员工对于工作环境、待遇、职业发展和组织管理等方面的满意程度。它是衡量员工对工作的整体感受和情绪状态的重要指标。
2020届软件工程本科毕业生毕业设计项目.zip
04-22
2020届软件工程本科毕业生毕业设计项目
基于stm32平衡小车
最新发布
04-22
平衡小车 基于stm32 平衡小车 基于stm32 平衡小车 基于stm32
tq2440 wince 通用usb摄像头驱动
05-12
该驱动程序通过对摄像头所使用的USB接口进行底层控制，实现对摄像头的识别、连接和数据传输。在安装该驱动后，用户只需要将USB摄像头插入TQ2440开发板上的USB口，操作系统就可以自动识别摄像头并进行驱动程序的加载...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值