2021-12-19 老杨博客推荐\TCP像串口的多程编写的一个弱鸡版本类MQTT的TCP实现\字典值查键\微PYTHON与PYTHON的JSON区别\以及一个ESP32领导多个ESP8266组网模式

都说程序员最拿手的好戏是复制粘贴，对于这件事我也是深以为然，遇到问题先看看别人，有么有写好的，没有写好的看看类似的，实在不行继续百度群里问问，最后再自己操刀上吧，microPython作为小众的控制器编程模式热度逐步提高，但是普遍水平不高，大部分都是二把刀，三把刀的样子很是娱乐性质，那我先推一推老杨的博客，他算是整的比较系统的了，虽然GIT里边没啥注释，代码也写的比较生硬，好在内容很杂总能翻找一些资料，我个人比较喜欢写博客类似写日志的记录一些内容。因为工作多年了，都是PLC WEB 嵌入式 还有政工写材料 这么个工作来回交替，所以我就是为了讲给新学的甚至是几年后的自己听的，下面是老杨的博客跳转页面推荐~

老杨的推广连接

---

连接推广完毕了，下面先来个ESP32以及PC通用的像串口一样的TCP方法库，因为服务器与客户端都使用了线程模块所以8266是不能用这个库的。库里有我的一些修改，以及思路扩展。

先研究研究像串口一样使用TCP这个库：并写下自己的修改和注释

import socket
import _thread

#使用demo
# from mytcp import *
# ip='127.0.0.1'
# port = 8081
# server = mytcp_server(ip,port)
#
# client = mytcp_client(ip,port)
#
# #############
# client.write(b'\x01\x02')
# server.read(0)
#
# server.write(0,b'\x04\x06')
# client.read()
#
# server.name_addr  #获取已经连接ip与ID对应列表，当服务器主动断开时这个列表会更新，客户端断开掉线则这个列表不会更新，默认是不掉线的
#                    如果是服务器只拿数据的情况比如温度测量，我们不用关心谁连接过来，只要解析报文内容既可以知道。
#                    但如果服务器需要通信就必须知道对方是谁，尤其是客户端之间要互相中专通信时尤其如此，
#                   设计这个列表，为了把ID号与IP号进行一次对应。其实这只完成了一半，另一半需要在客户端发过
#                   来内容时送来{ip:设备名}再进行一次字典对应，因为局域网连接中IP是相对可靠的所以都是以IP为键再建立一个字典实现绑定
#                   这里，因涉及到业务逻辑，所以需要留到具体的业务时再实现，无法事先弄好。
#                   另外，因为是线程式的工作模式，需要主动轮询ID号来读取内容，这一点也需要确定哪些号有设备接入，所以这个玩意还真得有个
#
#业务模式： ##以下功能是业务扩展思路，并不是函数功能,因涉及到具体业务支持所以只作为提醒记录
#1、设备名》服务器： 服务器记录下设备名字，就可以了             【发出设备名，服务器名，信息】
#2、设备名》设备名： 服务器根据接收信息：                       【发出设备名 ， 接收设备名，  信息】，执行：解析目标设备名，查找Id号再把初始信息原封传过去
#3、服务器》设备名： 服务器根据设备名查找IP，再根据IP 找ID发送  【服务器名，接收设备名，信息】
#
#
# client.close()
# server.close(0)


class mytcp_core():
    def __init__(self,conn,uid):
        self.uid= int(uid)-1
        self.read_buf=b''
        self.conn = conn
        self.thread_flag = 1
        _thread.start_new_thread(self.read_thread,())
    def read(self):
        temp = self.read_buf
        self.read_buf=b''
        return temp

    def read_thread(self):
        while 1:
            if self.thread_flag==0:
                break
            try:
                ret = self.conn.recv(1024)
                # print(ret)
                self.read_buf += ret
            except:
                print("closed",self.uid)
                self.conn.close()
                break #退出
    def write(self,context): #bytes
        self.conn.send(context)
        print(len(context))

    def close(self):
        self.thread_flag =0
        self.conn.close()

class mytcp_client():
    def __init__(self,ip,port):
        self.conn = socket.socket()
        self.flag = 0 #运行状态
        try:
            self.conn.connect((ip,port))
            print("connected")
            self.tcp_core = mytcp_core(self.conn)
            self.flag = 1
        except:
            print("cannot connect")

    def read(self):
        if self.flag == 1:
            return self.tcp_core.read()
        else:
            print("cannot connected")
            return

    def write(self,context):
        if self.flag == 1:
            return self.tcp_core.write(context)
        else:
            print("cannot connected")
            return
    def close(self):
        self.tcp_core.close()
        return "OK"

class mytcp_server():
    def __init__(self,ip,port,listen_num=5):
        self.listenSocket = socket.socket()
        self.name_addr=dict()
        self.socks = []  # 放每个客户端的socket
        self.socks_tcp_core = []
        self.socks_addr = []  # addr list

        try:
            self.listenSocket.bind((ip,port))
            self.listenSocket.listen(listen_num)
            _thread.start_new_thread(self.listen_add,())
        except:
            print("cannot connect")

    # 添加连接
    def listen_add(self):
        print("listening...")
        while True:
            try:
                cli, addr =  self.listenSocket.accept()
                print("get "+(str)(len(self.socks))+":"+str(addr[0]))
                ##################################################当连接传入时：存入字典，以IP为主键，ID为值
                self.name_addr[str(addr[0])]=str(len(self.socks))
                ##################################################
                self.socks.append(cli)
                self.socks_addr.append(addr)
                self.socks_tcp_core.append(mytcp_core(cli,str(len(self.socks))))

            except:
                pass


    def read(self,id):
        try:
            return self.socks_tcp_core[id].read()
        except:
            return

    def write(self,id,context):
        try:
            return self.socks_tcp_core[id].write(context)
        except:
            return
    def close(self,id):
        try:
            self.socks_tcp_core[id].close()
            self.socks[id].close()
            for k,v in self.name_addr.items():# 展开字典
                if v == str(id):   #值等于要删除值时
                    del self.name_addr[k] #删除这个字典键值对
            return "OK"
        except:
            return
s=mytcp_server('192.168.3.190',9999)

下面是一个根据字典值查找键的内容，这里值必须是字典唯一的，不能多建一值，毕竟设备号和IP号在同一时间下都应该是唯一的。

            for k,v in self.字典.items():# 展开字典
                if v == 要找的值:   #值等于要查找的值=
                    del self.name_addr[k] #执行删除这个字典键值对

上面说了不支持8266 ，那8266怎么办，其实8266就更简单了，因为没有线程所以就是普通的TCP客户端拉手就行了。只能做客户端，但是作为8266其实就是适合当客户端，非要当服务端，那就老老实实的普通TCP建立吧。

import socket,time
s=socket.socket(socket.AF_INET,socket.SOCK_STREAM) 
s.connect(('192.168.3.190',9999)) #看清楚是两层括号 里边是IP ，端口
s.send(b'12312312')
ccc=s.recv(5)                  

ESP32 领一群8266，其实这个方案也是不错的，ESP32勉强可以胜任，带它10来个8266传感器继电器也能做一些功能了。下面就简单写一个设备到服务器，所有设备都提交数据到服务器的星型结构的例子，原则是能跑就行的。注释好不容易写的都留着。

下面是服务端了，这个服务器支持 [本机设备号，收取设备号，本机消息] 这么个格式，连接上以后按照这个格式发json就可以用了。

服务器端ESP32：写在前面，ESP32绝对能完成这个功能，但是性能在那摆着呢，当主控服务器稳定性肯定不怎么地，一般来说可以挂载至多5个线程连接，再多了可靠性下降可能也要无响应了，网络建立也可能会失败这是概率性事件。连接服务器的客户端可能会掉线也是概率性事件，这需要在客户端位置写好重连，客户端多次连续取出b’None’这个值就可以认为要求数据的设备离线了，写好判断即可，总之，功能可测试娱乐使用，日常生产环境如果开发人员持续在场可以使用，否则慎用。非得要用更推荐PC加路由器建立热点然后，传感器去连接这个热点的PC服务器，起码来说资源充足，连接相对稳定覆盖距离也大。以下ESP32代码是我多次测试修改的，所以功能呢相对PC版本要多一些，同时也测试出了不足，PC版本服务器参照ESP32这个逻辑改改就行。下面的PC服务器直接用的话需要补充两点：1、超时断开 2、设备定时清空数据筛出离线设备。这两个都在ESP32端写好了，还是建议修改使用，就修改JSON部分即可。

import socket
import _thread
import json

#使用demo
# from mytcp import *
# ip='127.0.0.1'
# port = 8081
# server = mytcp_server(ip,port)
#
# client = mytcp_client(ip,port)
#
# #############
# client.write(b'\x01\x02')
# server.read(0)
#
# server.write(0,b'\x04\x06')
# client.read()
#
# server.name_addr  #获取已经连接ip与ID对应列表，当服务器主动断开时这个列表会更新，客户端断开掉线则这个列表不会更新，默认是不掉线的
#                    如果是服务器只拿数据的情况比如温度测量，我们不用关心谁连接过来，只要解析报文内容既可以知道。
#                    但如果服务器需要通信就必须知道对方是谁，尤其是客户端之间要互相中专通信时尤其如此，
#                   设计这个列表，为了把ID号与IP号进行一次对应。其实这只完成了一半，另一半需要在客户端发过
#                   来内容时送来{ip:设备名}再进行一次字典对应，因为局域网连接中IP是相对可靠的所以都是以IP为键再建立一个字典实现绑定
#                   这里，因涉及到业务逻辑，所以需要留到具体的业务时再实现，无法事先弄好。
#                   另外，因为是线程式的工作模式，需要主动轮询ID号来读取内容，这一点也需要确定哪些号有设备接入，所以这个玩意还真得有个
#
#业务模式： ##以下功能是业务扩展思路，并不是函数功能,因涉及到具体业务支持所以只作为提醒记录
#1、设备名》服务器： 服务器记录下设备名字，就可以了             【发出设备名，服务器名，信息】
#2、设备名》设备名： 服务器根据接收信息：                       【发出设备名 ， 接收设备名，  信息】，执行：解析目标设备名，查找Id号再把初始信息原封传过去
#3、服务器》设备名： 服务器根据设备名查找IP，再根据IP 找ID发送  【服务器名，接收设备名，信息】
#
#
# client.close()
# server.close(0)


class mytcp_core():
    def __init__(self,conn):
        self.read_buf=b''
        self.conn = conn
        self.thread_flag = 1
        _thread.start_new_thread(self.read_thread,())
    def read(self):
        temp = self.read_buf
        self.read_buf=b''
        return temp

    def read_thread(self):
        while 1:
            if self.thread_flag==0:
                break
            try:
                time.sleep(0.5)  ####这个延时防止CPU耗尽######
                self.conn.settimeout(60)  #这个超时可以断开死连接，节省资源
                ret = self.conn.recv(1024)
                self.read_buf += ret 
            except:
                print("closed")
                self.conn.close()
                break #退出
    def write(self,context): #bytes
        self.conn.send(context)
        print(len(context))

    def close(self):
        self.thread_flag =0
        self.conn.close()

class mytcp_client():
    def __init__(self,ip,port):
        self.conn = socket.socket()
        self.flag = 0 #运行状态
        try:
            self.conn.connect((ip,port))
            print("connected")
            self.tcp_core = mytcp_core(self.conn)
            self.flag = 1
        except:
            print("cannot connect")

    def read(self):
        if self.flag == 1:
            return self.tcp_core.read()
        else:
            print("cannot connected")
            return

    def write(self,context):
        if self.flag == 1:
            return self.tcp_core.write(context)
        else:
            print("cannot connected")
            return
    def close(self):
        self.tcp_core.close()
        return "OK"

class mytcp_server():
    def __init__(self,ip,port,listen_num=5):
        self.listenSocket = socket.socket()
        self.name_addr=dict()
        self.socks = []  # 放每个客户端的socket
        self.socks_tcp_core = []
        self.socks_addr = []  # addr list

        try:
            self.listenSocket.bind((ip,port))
            self.listenSocket.listen(listen_num)
            _thread.start_new_thread(self.listen_add,())
        except:
            print("cannot connect")

    # 添加连接
    def listen_add(self):
        print("listening...")
        while True:
            try:
                cli, addr =  self.listenSocket.accept()
                print("get "+(str)(len(self.socks))+":"+str(addr[0]))
                ##################################################当连接传入时：存入字典，以IP为主键，ID为值
                self.name_addr[str(addr[0])]=str(len(self.socks))
                ##################################################
                self.socks.append(cli)
                self.socks_addr.append(addr)
                self.socks_tcp_core.append(mytcp_core(cli))

            except:
                pass


    def read(self,id):
        try:
            return self.socks_tcp_core[id].read()
        except:
            return

    def write(self,id,context):
        try:
            return self.socks_tcp_core[id].write(context)
        except:
            return
    def close(self,id):
        try:
            self.socks_tcp_core[id].close()
            self.socks[id].close()
            for k,v in self.name_addr.items():# 展开字典
                if v == str(id):   #值等于要删除值时
                    del self.name_addr[k] #删除这个字典键值对
            return "OK"
        except:
            return



from time import sleep
import time
import network,machine
from machine import Pin
time.sleep(5)

####################
# wifi类
####################
class Sta():
   wlan = None
   def __init__(self, wifi_ssid, wifi_pwd):
      self.wifi_ssid = wifi_ssid
      self.wifi_pwd = wifi_pwd

   def connect(self):
      network.WLAN(network.AP_IF).active(False) # disable access point
      self.wlan = network.WLAN(network.STA_IF)
      self.wlan.active(True)
      self.wlan.disconnect()
      if not self.wlan.isconnected(): 
        self.wlan.connect(self.wifi_ssid, self.wifi_pwd)

   def status(self):
      if self.wlan.isconnected():
        return self.wlan.ifconfig()
      else:
        return ()

   def wait(self):
      cnt = 40
      while cnt > 0:
         print("Waiting ..." )
         # con(self.wifi_ssid, self.wifi_pwd) # Connect to an WIFI_SSID
         if self.wlan.isconnected():
           print("Connected to %s" % self.wifi_ssid)
           print('network config:', self.wlan.ifconfig())
           cnt = 0
         else:
           sleep(5)
           cnt -= 5
      return
   def scan(self):
      return self.wlan.scan()   # Scan for available access points
   def CreatNetwork(self):
      cnt = 40
      ap_if = network.WLAN(network.AP_IF)#AP 模式
      ap_if.active(True)
      ap_if.config(essid=self.wifi_ssid,password=self.wifi_pwd,authmode=2)
      while cnt > 0:
         print("Waiting ..." )
         # con(self.wifi_ssid, self.wifi_pwd) # Connect to an WIFI_SSID
         if ap_if.ifconfig()[0]!='0.0.0.0':
           print("start  %s" % self.wifi_ssid)
           print('network config:',ap_if.ifconfig()[0])
           cnt = 0
           return ap_if.ifconfig()[0]
         else:
           sleep(5)
           cnt -= 5
if __name__=='__main__': #服务器逻辑入口
    #####联网调用
    #热点模式
    a=Sta('201king','13704677369')
    ip=a.CreatNetwork()
    port = 9999    #端口号
    #####设定服务器端口和IP，这个服务器没有自建热点，接入WIFI好测试，使用时可以自建热点更可靠。
    port = 9999    #端口号
    try:
        s=mytcp_server(ip,9999) #里边填写IP 和端口
    except:
        machine.reset()
    #用来放接收的内容
    addr_rec=dict()
    add=100
    while 1:
        add=add-1
        time.sleep(0.5)                        #延时，这个实际可以很小
        if add<=0:
            add=100                    #设备掉线检测延时计数器
            for k,v in addr_rec.items():
                addr_rec[k]=b'None'        #   把所有信息更改成b'None'值，连续几次取出None,则可以认为改数据提供设备离线。
        for k,v in s.name_addr.items():      # 读取连接数据，主要用来确定哪些ID被使用了，好去那个ID口执行读取操作
            try:##  因为使用了JSON  ，如果读个空二进制会报错，这里TRY一下
                rec_unpack=json.loads(s.read(int(v)))# 获取数据应该是一个列表类似【1，1，‘26.545’】  设备号，读取号，消息内容
                addr_rec[rec_unpack[0]]=rec_unpack[2]#获取到的数据存入字典，键是设备号，值是消息内容。			
                #  注意这里：
                s_data=addr_rec.get(rec_unpack[1])
                if s_data:
                    pass
                else:
                    s_data=b'None'
                s.write(int(v),s_data)#这里发送设备号所属的消息，接收的时候列表0号元素是设备号，1号元素是他要的数据给他就行，调试的时候注意字符串和二进制，不行就上个JSON，同时最好加个空值判断，返回个内容啥的，，平时更新这俩字典就可以设备间通信了。
                
                #print(k,v) #测试用
                print(addr_rec[rec_unpack[1]])#测试用
                #print(int(v),addr_rec[rec_unpack[1]].encode()) #测试用
            except:
                pass
#     client.write(b'\x01\x02')
#     server.read(0)
#     server.write(0,b'\x04\x06')
#     client.read()
#     client.close()
#     server.close(0)

8266客户端

import time ,json
from time import sleep
import time
import network,machine
from machine import Pin
time.sleep(5)

####################
# wifi类
####################
class Sta():
   WIFI_SSID = "201king" 
   WIFI_PWD = "13704677369"
   wlan = None
   def __init__(self, wifi_ssid='', wifi_pwd=''):
      network.WLAN(network.AP_IF).active(False) # disable access point
      self.wlan = network.WLAN(network.STA_IF)
      self.wlan.active(True)
      if wifi_ssid == '':
        self.wifi_ssid = Sta.WIFI_SSID
        self.wifi_pwd = Sta.WIFI_PWD 
      else:
        self.wifi_ssid = wifi_ssid
        self.wifi_pwd = wifi_pwd

   def connect(self, wifi_ssid='', wifi_pwd=''):
      if wifi_ssid != '':
        self.wifi_ssid = wifi_ssid
        self.wifi_pwd = wifi_pwd

      if not self.wlan.isconnected(): 
        self.wlan.connect(self.wifi_ssid, self.wifi_pwd)

   def status(self):
      if self.wlan.isconnected():
        return self.wlan.ifconfig()
      else:
        return ()

   def wait(self):
      cnt = 30
      while cnt > 0:
         print("Waiting ..." )
         # con(self.wifi_ssid, self.wifi_pwd) # Connect to an WIFI_SSID
         if self.wlan.isconnected():
           print("Connected to %s" % self.wifi_ssid)
           print('network config:', self.wlan.ifconfig())
           cnt = 0
         else:
           sleep(5)
           cnt -= 5
      return
   def scan(self):
      return self.wlan.scan()   # Scan for available access points


a=Sta()
a.connect()
a.wait()



import random
import socket,time,json
s=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
s.connect(('192.168.4.1',9999))
s.settimeout(8) #设计一个8秒超时，这地方有文章，留着用
def k(x):
  time.sleep(2)
  #s.send(json.dumps([1,1,'haha'])) #发送数据，JSON格式
  s.send(json.dumps(x))
  ccc=s.recv(20)
  return ccc
lost=0
while 1 :
    ccc=k([-1,1,'60%d'%random.getrandbits(3)])
    if ccc == b'None':
        lost+=1
        pass
    else:
        lost=0
        print(ccc)
    if lost>8:
        print('读取设备离线')

pc客户端：PC的JSON和MICROPTYON的JSON 略微不同，PC转完了是字符串形式需要进行一次编码。

import socket,time,json
s=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
s.connect(('192.168.3.38',9999))
s.settimeout(8) #如果没这个，去请求无效数据小心卡死哦，有这个超时就报错了
s.send(json.dumps([1,2,'123']).encode())
ccc=s.recv(100)

服务器，PC端的写法。（这里有注释，很大段，用来理解消息结构以及服务器逻辑）

import socket
import _thread
import json,time

#使用demo
# from mytcp import *
# ip='127.0.0.1'
# port = 8081
# server = mytcp_server(ip,port)
#
# client = mytcp_client(ip,port)
#
# #############
# client.write(b'\x01\x02')
# server.read(0)
#
# server.write(0,b'\x04\x06')
# client.read()
#
# server.name_addr  #获取已经连接ip与ID对应列表，当服务器主动断开时这个列表会更新，客户端断开掉线则这个列表不会更新，默认是不掉线的
#                    如果是服务器只拿数据的情况比如温度测量，我们不用关心谁连接过来，只要解析报文内容既可以知道。
#                    但如果服务器需要通信就必须知道对方是谁，尤其是客户端之间要互相中专通信时尤其如此，
#                   设计这个列表，为了把ID号与IP号进行一次对应。其实这只完成了一半，另一半需要在客户端发过
#                   来内容时送来{ip:设备名}再进行一次字典对应，因为局域网连接中IP是相对可靠的所以都是以IP为键再建立一个字典实现绑定
#                   这里，因涉及到业务逻辑，所以需要留到具体的业务时再实现，无法事先弄好。
#                   另外，因为是线程式的工作模式，需要主动轮询ID号来读取内容，这一点也需要确定哪些号有设备接入，所以这个玩意还真得有个
#
#业务模式： ##以下功能是业务扩展思路，并不是函数功能,因涉及到具体业务支持所以只作为提醒记录
#1、设备名》服务器： 服务器记录下设备名字，就可以了             【发出设备名，服务器名，信息】
#2、设备名》设备名： 服务器根据接收信息：                       【发出设备名 ， 接收设备名，  信息】，执行：解析目标设备名，查找Id号再把初始信息原封传过去
#3、服务器》设备名： 服务器根据设备名查找IP，再根据IP 找ID发送  【服务器名，接收设备名，信息】
#
#
# client.close()
# server.close(0)


class mytcp_core():
    def __init__(self,conn):
        self.read_buf=b''
        self.conn = conn
        self.thread_flag = 1
        _thread.start_new_thread(self.read_thread,())
    def read(self):
        temp = self.read_buf
        self.read_buf=b''
        return temp

    def read_thread(self):
        while 1:
            if self.thread_flag==0:
                break
            try:
            	time.sleep(0.1)  #这个延时防止云服务器CPU耗尽
                ret = self.conn.recv(1024)
                # print(ret)
                self.read_buf += ret
            except:
                print("closed")
                self.conn.close()
                break #退出
    def write(self,context): #bytes
        self.conn.send(context)
        print(len(context))

    def close(self):
        self.thread_flag =0
        self.conn.close()

class mytcp_client():
    def __init__(self,ip,port):
        self.conn = socket.socket()
        self.flag = 0 #运行状态
        try:
            self.conn.connect((ip,port))
            print("connected")
            self.tcp_core = mytcp_core(self.conn)
            self.flag = 1
        except:
            print("cannot connect")

    def read(self):
        if self.flag == 1:
            return self.tcp_core.read()
        else:
            print("cannot connected")
            return

    def write(self,context):
        if self.flag == 1:
            return self.tcp_core.write(context)
        else:
            print("cannot connected")
            return
    def close(self):
        self.tcp_core.close()
        return "OK"

class mytcp_server():
    def __init__(self,ip,port,listen_num=5):
        self.listenSocket = socket.socket()
        self.name_addr=dict()
        self.socks = []  # 放每个客户端的socket
        self.socks_tcp_core = []
        self.socks_addr = []  # addr list

        try:
            self.listenSocket.bind((ip,port))
            self.listenSocket.listen(listen_num)
            _thread.start_new_thread(self.listen_add,())
        except:
            print("cannot connect")

    # 添加连接
    def listen_add(self):
        print("listening...")
        while True:
            try:
                cli, addr =  self.listenSocket.accept()
                print("get "+(str)(len(self.socks))+":"+str(addr[0]))
                ##################################################当连接传入时：存入字典，以IP为主键，ID为值
                self.name_addr[str(addr[0])]=str(len(self.socks))
                ##################################################
                self.socks.append(cli)
                self.socks_addr.append(addr)
                self.socks_tcp_core.append(mytcp_core(cli))

            except:
                pass


    def read(self,id):
        try:
            return self.socks_tcp_core[id].read()
        except:
            return

    def write(self,id,context):
        try:
            return self.socks_tcp_core[id].write(context)
        except:
            return
    def close(self,id):
        try:
            self.socks_tcp_core[id].close()
            self.socks[id].close()
            for k,v in self.name_addr.items():# 展开字典
                if v == str(id):   #值等于要删除值时
                    del self.name_addr[k] #删除这个字典键值对
            return "OK"
        except:
            return




if __name__=='__main__': #服务器逻辑入口
    #####设定服务器端口和IP，这个服务器没有自建热点，接入WIFI好测试，使用时可以自建热点更可靠。
    port = 9999    #端口号
    s=mytcp_server('10.168.1.107',9999) #里边填写IP 和端口
    #字典用来放接收的内容
    addr_rec=dict()
    while 1:
        time.sleep(2)                        #延时，这个实际可以很小
        for k,v in s.name_addr.items():      # 读取连接数据，主要用来确定哪些ID被使用了，好去那个ID口执行读取操作
            try:                             ##  因为使用了JSON  ，如果读个空二进制会报错，这里TRY一下
                rec_unpack=json.loads(s.read(int(v)))# 获取数据应该是一个列表类似【1，1，‘26.545’】  本机设备号，需求数据设备号，本机发来消息内容
                addr_rec[rec_unpack[0]]=rec_unpack[2]#获取到的数据存入字典，键是设备号，值是消息内容。
                ##############################################
                ##   这里发送设备号所属的消息，接收的时候列表0号元素是设备号，这个号是设备自己传过来的是受信带来的消息传入0号元素的字典键值对中,1号元素是需求的信息，
                #，那么发回数据的时候就发送   addr_rec[rec_unpack[1]]   这个字典1号键的值，平时更新这俩字典就可以设备间通信了。
                #  白话逻辑：一个人说：【我是1，我要1的数据，我的数据是：你好  】，那么这个动作就是把 你好存到1中  并返回1号这个你好信息
                #   那么，另一个人说  ：[我是2，我要1的数据，我的数据是 空]  ，那么这个动作就是把空存到2中，并返回1号存好的你好这个信息
                #   所以，这个服务器只判断报文内容来确定身份和功能，这样其实就比较像MQTT那样的随来随用，要谁有谁的特点。
                #   下面是回传，因为这个是在PC上跑的所以，JSON格式需要编码才能传送。
                #
                ##############################################
                s.write(int(v),json.dumps(addr_rec[rec_unpack[1]]).encode())
                print(addr_rec,addr_rec[rec_unpack[1]].encode()) #测试用
                print(k,v) #测试用
                print(int(v),addr_rec[rec_unpack[1]].encode()) #测试用
            except:
                pass
#     client.write(b'\x01\x02')
#     server.read(0)
#     server.write(0,b'\x04\x06')
#     client.read()
#     client.close()
#     server.close(0)

写了这么多其实这个帖子写了2天左右，边写边改导致前后文主旨不一致，现在确实要写完了，那就先做个检讨吧，我有罪不该边写博客边调试。应该写完了直接出个成品再写博客，虽然开发过程的思路也是博客的一部分，但是对阅读者会造成困扰。下面说点正事，这个TCP下的弱鸡版本MQTT是根据老杨的像串口一样的TCP库这个东西，我突然冒出来的灵感改编而来，一个是修改了注册队列的机制，提高了多设备接入时设备轮询的效率，另外是，直接抛弃了IP ID 绑定的思路（其实我是写了的，后来觉得很累赘直接弃掉了），使用设备消息处理认证的方式构建通信逻辑，这样就接近MQTT的订阅形式了，这就像打电话，每个设备都有自己的电话号码，你发来信息就记录下你的号码和你的消息，你要哪个号码就把哪个号码上记录的消息发给你，都是时间片内单一的工作完成的。ESP32服务器我测试了下 ，可运行，今天部署到阿里云上一份，也当MQTT用几天，检验下这个玩意。虽然没有人家MQTT稳定可靠，但是这个轻啊，ESP32自己就能跑啊，自己开热点就能覆盖一个小区域，还能带着8266啥的干活，这不是也挺好嘛，起码是个多设备无线通信方式，遇到特定不能上物联网的环境，拿着个出来顶一顶其实也不是不错的~

补充一个内容：阿里云服务器在部署TCP时IP地址不能填写公网ip而是填写‘0.0.0.0’这个地址即可绑定到公网IP上

s=mytcp_server('0.0.0.0',9999) #里边填写IP 和端口

另外，云服务器是有工作基线的一般是20%以下，所以如果部署云要在线程里边弄个延时，防止CPU被耗尽,当然如果是ESP32这种单片机既然开了线程。。。这线程还不咋可靠，那就也给安排个延时比较稳妥。

    def read_thread(self):
        while 1:
            if self.thread_flag==0:
                break
            try:
            	time.sleep(0.1)  ####这个延时防止云服务器CPU耗尽######
                ret = self.conn.recv(1024)
                # print(ret)
                self.read_buf += ret
            except:
                print("closed")
                self.conn.close()
                break #退出