目录

前言：

准备工作：

初级服务器端编写：

中级服务器端编写+客户端收数据函数实现：

数据包格式v1.0

客户端收数据函数V1.0

客户端分析1.0

    本地测试：成功！

     两台主机测试1.0：失败,视频解析失败，直接花屏了！

问题分析：

问题解决：

数据包格式V2.0

客户端接受数据函数V2.0

客户端更新分析2.0：

两主机测试2.0：失败，怎么这么卡？

问题分析：

问题解决：

数据包格式V3.0

客户端接受数据函数V3.0

客户端更新分析3.0：

两主机测试3.0：

两主机测试4.0

成功!     

前言：

        最近看到智能车的上位机，觉得很酷，恰好自己最近也在学习socket，tcp协议，打算也写一款这样的上位机系统来检验一下自己,此外,本文也涉及到了ros相关知识。当然，这个项目在编写过程中也遇到了不少bug，当然也包括tcp协议中的经典问题：半包和粘包，以及其他小的bug，在这里，我会详细的列出每个bug的原因以及解决办法，以及自己每步代码的用意，目的就是能让小白也能看的懂！

上位机介绍:

这个上位机的ui界面(前端)是用pyqt编写,后端用python,这是一个 客户端.可以通过socket实时订阅图像,小车参数,同时可以 发送文本数据,位置数据,速度数据.其中有关小车数据的收发涉及到 ros的相关知识,本文主讲的 是socket,对pyqt和ros介绍较少,同时,本次的服务端和客户端只给出了核心函数的实现,没有完整代码.

准备工作：

相信大家能进来这篇博客，想必已经配置好了自己的python，ros，opencv，pyqt环境，(没有ros环境也不要紧，核心不在这)，

初级服务器端编写：

要在python环境下编写socket,socket模块是必不可少的，这里我们使用类的方式来进行编写，代码如下：

import socket class server(QObject):         def __init__(self):         self.connect_server()      def connect_server(self):         self.ser_soc = socket.socket(socket.AF_INET,socket.SOCK_STREAM)         self.ser_soc.bind(("127.0.0.1",8899))         self.ser_soc.listen(5)         print("服务器监听中")         self.socketvalue, addr= self.ser_soc.accept()         print("连接到客户端",addr)         while True:                         data = self.socketvalue.recv(1024)             if data == b"exit":                 print("客户端断开连接,在时间",time.time())                 break         self.ser_soc.close()          self.socketvalue.close() if __name__ == "__main__":     ser = server()

代码解释：

1. socket.socket(socket.AF_INET,socket.SOCK_STREAM)，创建一个服务器对象ser_soc，socket.AF_INET,指的是使用IPV4.socket.SOCK_STREAM,表示使用tcp的流式传输协议。
2. bind(("127.0.0.1",8899)),服务器绑定ip和端口，这里使用本地调试，“127.0.0.1”
3. ser_soc.listen(5)，设置服务器开始监听，参数5代表多少个客户端。
4. socketvalue, addr= self.ser_soc.accept()，服务器开始监听后，会使得程序阻塞，直到有新的客户端连接。连接成功后，会返回一个用于通信的套接字对象socketvalue和一个连接的客户端的地址addr。
5. data = self.socketvalue.recv(1024，其中的while循环创建的data是从客户端接收的数据，为字节(bytes)，这里调用了recv函数，其中参数1024指的是接收的最大字节数。
6. if data == b"exit":这里指的是若数据data解码后为exit的花，说明客户端断开，跳出循环，关闭套接字和服务器（下方的两个close方法）。(这里对b“exit”为什么是b“”，b"指的是加了后就会将引号的内容转为字节bytes。）
7. __init__函数中的connect_server()，在构造函数中调用connect_server()使得服务器运行。
8. 主函数得到新建类对象，则会调用构造函数。
9. 到这一个简单的服务器（收数据）就搭建完成。

服务器端编写+客户端收数据函数实现：

• 需求分析：我们的目的是将智能车的参数数据与摄像头的视频数据通过socket传输给客户端，
  •  那么就必须有
    1. 向客户端发数据的方法
    2. 由于数据是两种不同的格式，一种是智能车的参数（包括速度，里程计等）是固定的字节长度，另一种是视频数据（字节长度是不定的）。如果我们想一次发送两种数据的话，就必须设置一个协议，说白了就是数据包的格式。
• 根据需求，我更新了服务端程序：

• import threading import socket import cv2 import numpy as np class carinfo:     linear_x = 3.0     angular_z = 3.0     odom_x = 1.0     odom_y = 2.0     odom_z = 2.0     odom_w = 2.0     yaw = 2      def encode(self):         return struct.pack('fffffff',self.linear_x,self.angular_z,self.odom_x,self.odom_y,self.odom_z,self.odom_w                            ,self.yaw                            ) class server(QObject):         def __init__(self):         cap = cv2.VideoCapture(0)         self.flag =True         car = carinfo()         self.connect_server()      def connect_server(self):         self.ser_soc = socket.socket(socket.AF_INET,socket.SOCK_STREAM)         self.ser_soc.bind(("127.0.0.1",8899))         self.ser_soc.listen(5)         print("服务器监听中")         self.socketvalue, addr= self.ser_soc.accept()         self.socketvalue.settimeout(300) #设置超时时间5min         print("连接到客户端",addr)         while True:                         data = self.socketvalue.recv(1024)             if data[0] == 0xCC:                 self.video_th = threading.Thread(target=self.send_fream)                  self.video_th.start()             elsf data == b"exit":                 print("客户端断开连接,在时间",time.time())                 break        self.flag == False     def send_fream(self):         while self.flag == True:             try:                 rat, fream = self.cap.read() #获取摄像头数据到变量fream                 fream =  cv2.resize(fream,(380,250)) #设定图像大小                 info = cv2.imencode('.jpg',fream)[1] #视频帧编码                 self.video_data = py.array(info).tobytes()#转换成字节                 car_info = self.car.encode() #小车数据编码                 #数据包格式                 # 0x55aa  + 小车参数  +    视频      + 0x55cc                 #  4bytes +  28bytes + 不定长bytes  + 4bytes                 valuedata = (0x55aa).to_bytes(2,"little")+self.car.encode()+self.video_data                   self.socketvalue.sendall(valuedata)             except:                 break         self.ser_soc.close()          self.socketvalue.close()         self.cap.release()         cv2.destroyAllWindows if __name__ == "__main__":     ser = server()

  根据上次服务端程序，列出更新的代码解释：

1.   self.video_th = threading.Thread(target=self.send_fream)
      self.video_th.start() 

   ---

   当data[0] == 0xcc  也就是当数据包的第1个字节为0xcc(索引从0开始)时，启动一个新的线程video_th调用函数send_fream。创建一个新的线程的目的是因为我们的发数据是一直在发的，是个循环，如果不启用新的线程的话，就会导致我们的 主线程阻塞，从代码中可以看到主线程中还有一个while负责接收客户端的数据，那么这里就会阻塞，从而导致程序无响应。其中target=self.send_fream指的是线程启用的函数，使用start方法即可启动线程，当send_fream函数执行完成后，线程自动结束（温馨提示使用线程，请import  threading）

2. self.socketvalue.settimeout(300)：这里是设置超时时间，指的是如果客户端一直没有发来数据的话，超过设置的时间就或timeout，大家可以根据需要设置，单位是秒，这里我用了5分钟。

3. 在构造函数中加入cap = cv2.VideoCapture(0)获取摄像头。其中send_fream函数中摄像头编码相关的代码注释我已经写道了每行代码之后（由于自己opencv的知识欠缺 ，在这就给大家 简单解释了，实在抱歉）（温馨提示使用opencv，请iimport cv2，import numpy）
4. 新建了一个类 叫carinfo，并且在server类的构造函数中实例化类对象到car，这个类是用于存入小车的参数的，一共7个，我这写的是速度，里程计 ，和偏航角。接下来就是一个成员函数encode()，根据字面意思大家应该也猜出来是对小车数据进行编码，没错，这里 用到了python中的struct模块，该模块是用于将数据封装成二进制，调用其中的pack方法 将数据转换为字节类型，用于tcp字节传输。

   struct.pack('fffffff',self.linear_x,self.angular_z,self.odom_x,self.odom_y,self.odom_z,self.odom_w                            ,self.yaw                            )

    
   • struct.pack函数解释：第一个参数'ffffff' 是一个格式字符串，表示要打包的数据类型和顺序，这里我用的全是f，因为每个数据都是float，一个占4字节，一共是4x7=28字节。
     • H 表示无符号短整数（2字节）f 表示单精度浮点数（4字节）B 表示无符号字符（1字节）
   • 第二个参数是打包的数据，自己写了7个f，所以有7个数据。

5. self.flag =False：这里的flag作为send_fream函数while循环的条件，初始值为true(在构造函数中写到)，同时connect_cserver函数的循环在客户端断开时break，如下，然后就flag=false

   elsf data == b"exit":     print("客户端断开连接,在时间",time.time())     break

   这时在客户端断开时，由于标志位为 假的，服务器也不再发数据。并且在send_fream的循环退出后，进行服务器，套接字的close，摄像头的释放。

6. 上面提出的向客户端发送数据的方法为  self.socketvalue.sendall(valuedata)，sendall函数为发送数据的方法，参数为数据包。

7. 接下来就是核心了，数据包格式，这里我会按照 当时我的步骤来进行，简单来说就是由简到繁琐，由有bug到无bug的方式进行，目地是为了还原我当时的思路，方便大家理解。

   数据包格式v1.0

   •  (0x55aa).to_bytes(2,"little")，将0x55aa转为长度为2的字节，并且是小端存储，小端表示数据的低位字节在前，高位字节在后。
   • 采用：包头(2字节)+小车参数(4x7=28字节)+视频参数(字节长度不定)

   • valuedata = (0x55aa).to_bytes(2,"little")+self.car.encode()+self.video_data  

客户端收数据函数V1.0

    #接收缓冲区数据    def recv(self):         while self.flag == True:             data = self.client_socket.recv(88888) #收到数据，字节长度最大888888                          length = len(data)#数据长度             video_length = length - 30 #视频字节长度             if data == b"exit": #收到服务器断开消息，break                 self.show_data.emit(time.time(),":服务器断开连接")                 break                              if data[0:2] == 0x55aa.to_bytes(2,"little"):  #判断包头                 dataval = struct.unpack('fffffff',data[2:30]) #除去包头后的28位字节为小车参数                 self.show_carinfo.emit(dataval) #发送信号到主线程显示                 self.vdieo_value = data[30:30+video_length] #小车参数后的字节开始数video_length个字节为图像数据                 nparry = np.frombuffer(self.vdieo_value,dtype="uint8")                 fream = cv2.imdecode(nparry,cv2.IMREAD_COLOR) #视频帧解码                 self.show_vdieo.emit(fream) #将视频帧发送主线程显示         

• 客户端分析1.0

• video_length = length - 30：由于视频参数不固定，但是我们可以简介的求出其长度，即总包长度-包头字节长-小车字节长=视频字节长，将他存入变量video_length中(减30的原因是：2+28=30)。接下来data[0:2]是使用了切片操作符 []，我个人觉得这种方法在截取字节段上面很好用，0:2意思是从data索引0位置处的值往后数两个值进行拼接（包括0处的值），也就是索引0，1的值的拼接。

• dataval = struct.unpack('fffffff',data[2:30])：这里是解包，在服务端我们用的是struct的pack方法，在客户端则用 unpack方法并且必须用同样的‘fffffff’解开，解的是data[2:30]除去包头2个字节，在数28个字节，这里注意是索引，因此是28+2=30。

• self.vdieo_value = data[30:30+video_length]：同理，小车参数后video_length为视频参数。其实这里可以直接写成data[30:]表示索引30以后的所有，因为视频参数后没有其他数据。

• self.show_carinfo.emit(dataval)和self.show_vdieo.emit(fream)指的是将数据通过pyqt信号和槽发送主线程的ui上显示

    本地测试：成功！

     两台主机测试1.0：失败,视频解析失败，直接花屏了！

问题分析：

这里说句实话我也有点懵，本地调试就行 ，两主机就寄了，因此，就在服务器端send_fream函数加入以下代码

 print(len(valuedata))      break

即打印发送端数据包长度，打印一次就break掉。如下显示32671
同样的方法，在客户端收数据的recv函数加入

print(length)

输出为：

很明显，我只发送了一次数据，长度为32671，正确的话客户端也应打印32671，但是他却打印了好几次，服务器发送的数据被客户端分成几次接收，很明显，这是半包了。

咱们来验证一下：

将客户端收到的字节数相加，这里帮大家算了，结果正好和服务器短发的数据长度32671相等，这就更加的证明数据 被半包了！

问题解决：

根据数据被半包，我们指导tcp是流式传输协议，没有边界，所以我们应该在数据包中添加边界，使得客户端的在读取数据的时候有边界参考，那么我就在包中加入数据总长。根据这个思路，我更新了数据报格式。

数据包格式V2.0

valuedata = (0x55aa).to_bytes(2,"little")+(len(car_info+self.video_data)+2+4).to_bytes(4,"little")+self.car.encode()+self.video_data

相比v1.0多了(len(car_info+self.video_data)+2+2+4).to_bytes(4,"little")将小车参数和视频参数相加的总长，再加上2+4，指的是包头(2字节)+总长(4字节)

客户端接受数据函数V2.0

    def recv(self):         while self.flag == True:             data = self.client_socket.recv(88888) #收到数据，字节长度最大888888             #收到服务器断开消息，break             length = len(data)             print(length)             video_length = length - 34             if data == b"exit":                  self.show_data.emit(time.time(),":服务器断开连接")                 break                              if data[0:2] == 0x55aa.to_bytes(2,"little"): #判断包头                     print("pppppppppppppppppp")                     if data[2:6] == len(data).to_bytes(4,"little"): #判断数据总长是否正确                         print("-------")                         dataval = struct.unpack('fffffff',data[6:34]) #除去包头后的28位字节为小车参数                         self.show_carinfo.emit(dataval) #发送信号到主线程显示                         self.vdieo_value = data[34:34+video_length] #小车参数后的字节开始数video_length个字节为图像数据                         nparry = np.frombuffer(self.vdieo_value,dtype="uint8")                         fream = cv2.imdecode(nparry,cv2.IMREAD_COLOR) #视频帧解码                          if fream is not None:                             self.show_vdieo.emit(fream) #将视频帧发送主线程显示

客户端更新分析2.0：

if data[2:6] == len(data).to_bytes(4,"little"):判断是否为数据总长，是的话说明数据正确。因为从索引2再数4个字节为数据包总长。

两主机测试2.0：失败，怎么这么卡？

问题分析：

同过之前的检验方法，在一些判断语句下打印一些明显字符，判断有没有 进入判断比如我的是“ppppp”，“------”等。发现打印“-----”很少，通过 print(length)发现，每次卡出画面的时候，就打印一次“----”，而且此时的length与服务器端的length相等，说明我只截取到了在服务器端发送整条数据，我客户端也刚刚好一次就全部收到了数据，那么此时画面是正常的，但是没有一次受到的话，画面就卡在了上一次正常一次收到的数据的画面。这种一次就收到整条数据(不出现半包)我认为是随机的。（卡的过程中客户端由于半包收到的是被分割的数据）

问题解决：

我需要添加一个包尾，在没有到包尾是就将数据累加，这样就可以了。

数据包格式V3.0

valuedata = (0x55aa).to_bytes(2,"little")+(len(car_info+self.video_data)+2+2+4).to_bytes(4,"little")+self.car.encode()+self.video_data+(0x55cc).to_bytes(2,"little")

相比v2.0多了包尾0x55cc。设不定长的视频数据长度为n,那么计算以下就得到数据包总长为：2+4+28+n+2=36+n

数据格式变了，客户端的读数据函数理应改变。

客户端接受数据函数V3.0

    def recv(self):         while self.flag == True:             data = self.client_socket.recv(88888) #收到数据，字节长度最大888888             #收到服务器断开消息，break             length = len(data)             video_length = length - 36             if data == b"exit":                  self.show_data.emit(time.time(),":服务器断开连接")                 break                              if data[0:2] == 0x55aa.to_bytes(2,"little") or self.tcp_flag: #判断包头                 self.tcp_flag = True #第一次发送完整数据标志位                 if data[-2:] == 0x55cc.to_bytes(2,"little"): #判断包尾                     self.aimdata = data + self.tempdata  #将最后一次接收到的数据加上                     longth = len(self.aimdata) #打印数据总长                     video_length = longth- 36 #计算视频字节大小                     # print(len(self.aimdata))                     self.tcp_flag = False # 第一次发送完了完整数据后，标志位置0                     if self.aimdata[2:6] == len(self.aimdata).to_bytes(4,"little"): #判断数据总长是否正确                         dataval = struct.unpack('fffffff',self.aimdata[6:34]) #除去包头后的28位字节为小车参数                         self.show_carinfo.emit(dataval) #发送信号到主线程显示                         self.vdieo_value = self.aimdata[34:34+video_length] #小车参数后的字节开始数video_length个字节为图像数据                         nparry = np.frombuffer(self.vdieo_value,dtype="uint8")                         fream = cv2.imdecode(nparry,cv2.IMREAD_COLOR) #视频帧解码                          if fream is not None:                             self.show_vdieo.emit(fream) #将视频帧发送主线程显示                     #第一次数据接收完成后字节段清空                     self.tempdata = b''                     self.aimdata = b''                 else:                     self.tempdata += data #半包现象解决核心，没有到包尾就将字节拼接  

客户端更新分析3.0：

这里要说的就比较多了，不过没关系，一步一步来。

根据之前的分析，一条数据被分成多份，在这里做个假设，加入数据被分成6份，那么第一份数据肯定是包含包头0x55aa，同理，最后一条数据肯定是包含包尾0x55cc。

1：tcp_flag：因此我引入了一个bool变量tcp_flag,初始值为假，这样我不管你把数据分成几份，第一份肯定包含包头，此时tcp_flag被置为真，因为第二份数据不再含有包头，所以if中的第一个条件失效，但此时我 or 了一下tcp_flag 有效了，可以接受第一次发数据中的不含包头的那几份数据了，这就是tcp_flag的意义所在。

2：data[-2:] == 0x55cc.to_bytes(2,"little") 这里的data[-2:]指的倒着数2个字节，即判断包尾，如果在这里if条件符合了，说明我整个数据接受完成了，因为数据格式V2.0最后就是包尾巴0x55cc嘛。

3.else:
     self.tempdata += data：这是核心了，当没有到包尾的时候，说明整条数据我还没有接受完，我就将每次的数据拼接到tempdata中不就行了。

4：self.aimdata = data + self.tempdata，识别到包尾别忘了还要加上含有包尾的那一份数据。

5：self.tcp_flag = False ，置为假，表示整条数据接受完毕，你这个条件没用了，该是否为包头这个条件闪亮登场了，即用于下一条数据的到来。

6：  if self.aimdata[2:6] == len(self.aimdata).to_bytes(4,"little")最后再次判断包长是否想等，满足这几个条件之后，数据格式应该对了。

7： self.tempdata = b'' self.aimdata = b'',每次接受完整条数据，一定要清空这两个，不然数据长会越来越大。

两主机测试3.0：

本以为要成功了，可是又失败了，我太难了，呜呜呜呜.....

画面直接为空，啥都没有。

经过数据比对后发现第一次的数据好大，但是往后的数据就相同了，这就是出现粘包了，由于有数据长度的判断，所以没有显示画面。但是经过我的测试,只有在前几次数据发生粘包,堆到一块,但是后面的就没有再粘,数据都是正常的,就没有再管它.

经过打印二进制数据发现，浏览这些字节发现(看的我眼花缭乱)，包头包尾居然连在一起，

原来是 self.aimdata = data + self.tempdata ，这两个加反了，好低级的错误，换一下位置 self.aimdata = self.tempdata +data 就好了。

两主机测试4.0

成功!  

这里没用两个主机测试，使用本地

下面这是通过网络发送目标点，ros端仿真小车移动目标点。（里程计和速度都会随之更新，偏航角没有发布，所以没有更新）

最后

相信能看到这里的同学对socket有了一定的了解，本文只给了服务端和客户端的核心代码，没有给全部，里面还有pyqt和 ros的相关代码，如果有同学想要了解这方面的代码，可在评论中讨论，如果需要的多的话，我可以在下一片博客中写到。此外，我本人也是初学者，可能有些地方理解不到位，如果有大佬发现上述的内容有误，欢迎 在评论或者私信指正。然后，如果大家觉得我写的还行，对你有帮助的话，可以留下你宝贵的点赞和关注吗，你们的支持对我真的很重要，求求了！