Socket通信

概要
TCP服务端和客户端通信示例
- ESP32 TCP服务端
- PC TCP客户端
usocket模块 API文档
常量
socket 类
- 方法

概要

socket 几乎是整个网络通信的基础，本文为大家讲解 Waffle Micro 中的 Socket 模块。

什么是socket

Socket是应用层与TCP/IP协议族通信的中间软件抽象层，它是一组接口。在设计模式中，Socket其实就是一个门面模式，它把复杂的TCP/IP协议族隐藏在Socket接口后面，对用户来说，一组简单的接口就是全部，让Socket去组织数据，以符合指定的协议.

socket已经封装好了tcp/udp协议，只需要遵循socket的规定去编程，写出的程序自然就是遵循tcp/udp标准的。

什么是TCP/IP、UDP？

TCP/IP（Transmission Control Protocol/Internet Protocol）即传输控制协议/网间协议，是一个工业标准的协议集，它是为广域网（WANs）设计的。 UDP（User Data Protocol，用户数据报协议）是与TCP相对应的协议。它是属于TCP/IP协议族中的一种。

套接字主要类型

1.流套接字(SOCK_STREAM)

流套接字用于提供面向连接、可靠的数据传输服务。该服务将保证数据能够实现无差错、无重复送，并按顺序接收。流套接字之所以能够实现可靠的数据服务，原因在于其使用了传输控制协议，即TCP(The Transmission Control Protocol)协议。

2.数据报套接字(SOCK_DGRAM)

数据报套接字提供一种无连接的服务。该服务并不能保证数据传输的可靠性,数据有可能在传输过程中丢失或出现数据重复，且无法保证顺序地接收到数据。数据报套接字使用UDP( User DatagramProtocol)协议进行数据的传输。由于数据报套接字不能保证数据传输的可靠性，对于有可能出现的数据丢失情况，需要在程序中做相应的处理。

3.原始套接字(SOCK_RAW)

原始套接字与标准套接字(标准套接字指的是前面介绍的流套接字和数据报套接字)的区别在于：原始套接字可以读写内核没有处理的IP数据包，而流套接字只能读取TCP协议的数据，数据报套接字只能读取UDP协议的数据。因此，如果要访问其他协议发送的数据必须使用原始套接

套接字实现TCP/UDP通信过程

套接字实现TCP通信的工作流程

先从服务器端说起。服务器端先初始化Socket，然后与端口绑定(bind)，对端口进行监听(listen)，调用accept阻塞，等待客户端连接。在这时如果有个客户端初始化一个Socket，然后连接服务器(connect)，如果连接成功，这时客户端与服务器端的连接就建立了。客户端发送数据请求，服务器端接收请求并处理请求，然后把回应数据发送给客户端，客户端读取数据，最后关闭连接，一次交互结束

套接字实现UDP通信的工作流程

TCP是建立可靠连接，并且通信双方都可以以流的形式发送数据。相对TCP， UDP则是面向无连接的协议。使用UDP协议时，不需要建立连接，只需要知道对方的IP地址和端口号，就可以直接发数据包。但是，能不能到达就不知道了。

和TCP类似，使用UDP的通信双方也分为客户端和服务器，服务器首先需要绑定端口。但不需要监听客户端的连接，通过recvfrom()接收客户端数据，客户端使用UDP时，首先仍然创建基于UDP的Socket，然后，不需要调用 connect() ，直接通过 sendto() 给服务器发数据。

图片描述

TCP服务端和客户端通信示例

确保你的 Waffle Micro 和你的 PC 在同一局域网内。

在接下来的示例中，我们以 Waffle Micro 建立 TCP 服务端，在 PC 上编写脚本创建 TCP 客户端，与服务器进行通信。

ESP32 TCP服务端

import socket
import network

port = 10000  #端口号
listenSocket = None  #套接字

try:
    wifi = network.WLAN(network.STA_IF) #创建一个网络接口
    wifi.active(True)#激活网络接口
    wifi.disconnect()#中断之前连接的wifi
    wifi.connect('wifi名称','wifi密码')
    #输入账号密码连接网络
    while(wifi.ifconfig()[0]=='0.0.0.0'):
    	time.sleep(1)
	print(wifi.ifconfig())
    ip = wifi.ifconfig()[0][0]   #获取IP地址
    listenSocket = socket.socket()   #创建套接字
    listenSocket.bind((ip, port))   #绑定地址和端口号
    listenSocket.listen(1)   #监听套接字, 最多允许一个连接
    listenSocket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)   #设置套接字
    print ('tcp waiting...')

    while True:
        print("accepting.....")
        conn, addr = listenSocket.accept()   #接收连接请求，返回收发数据的套接字对象和客户端地址
        print(addr, "connected")

        while True:
            data = conn.recv(1024)   #接收数据（1024字节大小）
            if(len(data) == 0):   #判断客户端是否断开连接
                print("close socket")
                conn.close()   #关闭套接字
                break
            print(data)
            ret = conn.send(data)   #发送数据
except:
    if(listenSocket):   #判断套接字是否为空
        listenSocket.close()   #关闭套接字

PC TCP客户端

import socket               # 导入 socket 模块

s = socket.socket()         # 创建 socket 对象
host = 'waffle ip地址'      # waffle的ip地址，从ifconfig那个输出中可以看到
port = 10000                # 设置端口号

s.connect((host, port))

if __name__ == '__main__':
    while True:
        msg = raw_input('>>> ')
        s.send(msg)

usocket模块 API文档

此模块提供对 BSD 套接字接口的访问。

Socket address format(s)

创建套接字序列

socket.getaddrinfo(host, port)

函数说明：将主机域名（host）和端口（port）转换为用于创建套接字的5元组序列。元组列表的结构如下:

(family, type, proto, canonname, sockaddr)

family:地址簇，可为0（IPv4）或2（IPv6）
type:套接字类型，可为1（TCP流）或2（UDP数据报）
proto:IP协议号，可为0、6（TCP协议）、17（UDP协议）
canoname:套接字域名
sockaddr:套接字地址，包含域名和端口号

usocket 模块的本机 socket 地址格式是 getaddrinfo 函数返回的不透明数据类型，必须使用它解析文本地址（包括数字地址）：

sockaddr = usocket.getaddrinfo('www.micropython.org', 80)[0][-1]
# 即使对于数字地址，也必须使用 getaddrinfo()
sockaddr = usocket.getaddrinfo('127.0.0.1', 80)[0][-1]
# 现在你可以使用这个地址了
sock.connect(addr)

使用 getaddrinfo 函数是处理地址的最有效（无论是在内存还是处理能力方面）和可移植的方式。

使用元组指定地址的方式，如下所述。请注意，根据 MicroPython 端口的不同，socket 模块可以内置或需要从 “MicroPython lib” 安装（与 MicroPython Unix 端口的情况相同），有些端口仍然只接受元组格式的数字地址，并且需要使用 getaddrinfo 函数解析域名。

总结：

编写轻量级应用程序时，请始终使用 getaddrinfo 函数。
如果您的端口支持，下面描述的元组地址可以用作快速破解和交互使用的快捷方式。

socket 模块的元组地址格式：

IPv4: （IPv4_地址，端口），其中 IPv4_地址 是一个带有点符号数字 IPv4 地址的字符串，例如，"8.8.8.8"，port 是一个介于 1-65535 之间的整数端口号。注意：域名不被接受为 ipv4_地址 ，应首先使用 usocket.getaddrinfo() 解析它们。
IPv6:（IPv6_地址、端口、flowinfo、scopeid），其中 IPv6_地址 是一个带有冒号符号数字 IPv6地址的字符串，例如 2001:db8:：1，port 是范围为 1-65535 的整数端口号 flowinfo 必须为 0scopeid 是链接本地地址的接口作用域标识符。注意：域名不被接受为 ipv6_地址 ，应首先使用 usocket.getaddrinfo() 解析它们。IPv6 支持的可用性取决于 MicroPython 端口。

`usocket.socket(af=AF_INET, type=SOCK_STREAM, proto=IPPROTO_TCP, /)`

函数说明：创建套接字。

af：地址
type：类型
proto：协议号

**注意：一般不指定proto参数，因为有些Micropython固件提供默认参数。 ** 示例：

>>> import usocket as socket
>>> s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)#创建socket对象
>>> print(s)
<socket>

使用给定的地址族、socket 类型和协议号创建新 socket。请注意，在大多数情况下不需要指定 proto （也不建议这样做，因为某些 MicroPython 端口可能会省略IPPROTO\*常量）。相反，type 参数将自动选择所需的协议：

# Create STREAM TCP socket
socket(AF_INET, SOCK_STREAM)
# Create DGRAM UDP socket
socket(AF_INET, SOCK_DGRAM)

socket.socket 详解

使用import usocket as socket导入socket模块

再使用TAB 按键来查看socket.socket.中所包含的内容：

>>> import usocket as socket
>>> socket.socket
close           read            readinto        readline
send            write           __del__         accept
bind            connect         fileno          listen
makefile        recv            recvfrom        sendall
sendto          setblocking     setsockopt      settimeout

`usocket.getaddrinfo(host, port, af=0, type=0, proto=0, flags=0, /)`

将主机/端口参数转换为 5 元组序列，其中包含创建连接到该服务的套接字所需的所有参数。参数 af 、type 和 proto （与 socket（） 函数的含义相同）可用于筛选返回的地址类型。如果未指定参数或为零，则可以返回所有地址组合（需要在用户端进行筛选）。

生成的5元组列表具有以下结构：

(family, type, proto, canonname, sockaddr)

以下示例显示如何连接到给定 url：

s = usocket.socket()
# 这假设如果未指定“type”，将返回 SOCK_STREAM 的地址，这可能不是真的
s.connect(usocket.getaddrinfo('www.micropython.org', 80)[0][-1])

建议使用过滤参数：

s = usocket.socket()
# 保证返回一个地址，可以连接到该地址进行流操作。
s.connect(usocket.getaddrinfo('www.micropython.org', 80, 0, SOCK_STREAM)[0][-1])

`usocket.inet_ntop(af, bin_addr)`

将给定地址族 af 的二进制网络地址 bin_addr 转换为文本表示：

>>> usocket.inet_ntop(usocket.AF_INET, b"\x7f\0\0\1")
'127.0.0.1'

`usocket.inet_pton(af, txt_addr)`

将给定地址族 af 的文本网络地址 txt_addr 转换为二进制表示：

>>> usocket.inet_pton(usocket.AF_INET, "1.2.3.4")
b'\x01\x02\x03\x04'

常量

`usocket.AF_INET`

`usocket.AF_INET6`

地址族类型。可用性取决于特定的 MicroPython 端口。

`usocket.SOCK_STREAM`

`usocket.SOCK_DGRAM`

Socket 类型。

`usocket.IPPROTO_UDP`

`usocket.IPPROTO_TCP`

IP 协议编号。可用性取决于特定的 MicroPython 端口。注意，您不需要在调用 usocket.socket() 时指定这些，因为 SOCK_STREAM 套接字类型会自动选择 IPPROTO_TCP 和 SOCK_DGRAM-IPPROTO_UDP。因此，这些常量的唯一实际用途是作为 setsockopt() 的参数。

`usocket.SOL_*`

Socket 选项级别（setsockopt() 的参数）。确切的库存取决于MicroPython端口。

`usocket.IPPROTO_SEC`

创建 SSL-compatible Socket 的特殊协议值。

socket 类

方法

`socket.close()`

标记 Socket 已关闭并释放所有资源。一旦发生这种情况，以后对 Socket 对象的所有操作都将失败。如果协议支持，远程端将接收 EOF 指示。

Socket 在被垃圾收集时会自动关闭，但建议在使用完套接字后立即显式关闭它们。

函数说明：关闭套接字。

示例：

import usocket as socket
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)#创建socket对象
s.close()#关闭套接字

`socket.bind(address)`

将 Socket 绑定到地址。套接字不能已经绑定。

函数说明：以列表或元组的方式绑定地址和端口号。

address：一个包含地址和端口号的列表或元组

示例：

>>> import usocket as socket
>>> s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)#创建socket对象
>>> addr=('0.0.0.0',5000)
>>> s.bind(addr)#绑定目标地址和端口号

`socket.listen([backlog])`

允许服务器接受连接。如果指定了 backlog，则必须至少为 0 （如果较低，则设置为 0 ）；并指定系统在拒绝新连接之前允许的未接受连接数。如果未指定，则选择默认的合理值。

函数说明：监听套接字，使服务器能够接收连接，绑定后才可监听。

backlog：接受套接字的最大个数，至少为0，如果没有指定，则默认一个合理值

示例：

>>> import usocket as socket
>>> s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)#创建socket对象
>>> addr=('0.0.0.0',5000)
>>> s.bind(addr)#绑定本机地址和端口号
>>> s.listen(5)#设置最大连接数为5，超过后排队

`socket.accept()`

接受连接。Socket 必须绑定到地址并侦听连接。返回值是一对（conn，address），其中 conn 是一个新的 Socket 对象，可用于在连接上发送和接收数据，address是绑定到连接另一端的套接字的地址。

函数说明：接收连接请求，绑定端口并监听后才可以接受客户端连接请求。

conn：新的套接字对象，可以用来收发消息
address：连接到服务器的客户端地址

示例：

>>> import usocket as socket
>>> s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)#创建socket对象
>>> addr=('0.0.0.0',5000)
>>> s.bind(addr)#绑定本机地址和端口号
>>> s.listen(5)#设置最大连接数为5，超过后排队
>>> conn,addr=s.accept()#接收TCP客户端连接

`socket.connect(address)`

连接到位于 address 的远程 Socket。

函数说明：接收连接请求。

address：服务器地址和端口号的元组或列表

示例：

>>> import usocket as socket
>>> s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)#创建socket对象
>>> addr=('192.168.50.66',5000)
>>> s.connect(addr)#接收连接请求

`socket.send(bytes)`

将数据发送到 Socket 。Socket 必须连接到远程 Socket。返回发送的字节数，该字节数可能小于数据长度（“short write”）。

函数说明：发送数据，并返回发送的字节数。

用接收 TCP 客户端连接时新的套接字对象 conn 发送数据

bytes：bytes类型数据

示例：

import usocket as socket
s=socket.socket(socket.AF_INET, socket.SOCK_STREAM)##创建socket对象
addr=('0.0.0.0',5000)
s.bind(addr)#绑定本机地址和端口号
s.listen(5)#设置最大连接数为5，超过后排队
conn,addr=s.accept()#接收TCP客户端连接
msg="hello BlackWalnut Labs, I am TCP Client"
conn.send(str(msg,'utf-8'))#将数据编码成utf-8格式发送出去

`socket.sendall(bytes)`

将所有数据发送到 Socket。Socket 必须连接到远程 Socket 。与 send() 不同，此方法将通过连续发送数据块来尝试发送所有数据。

此方法在非阻塞 Socket 上的行为未定义。因此，在 MicroPython 上，建议改用 write() 方法，该方法对于阻塞 Socket 具有相同的“无短写”策略，并将返回在非阻塞Socket 上发送的字节数。

函数说明：与 send() 函数类似，区别是 sendall() 函数该方法会通过连续发送尽量发送所有数据。

bytes：bytes类型数据

示例：

import usocket as socket
s=socket.socket(socket.AF_INET, socket.SOCK_STREAM)##创建socket对象
addr=('0.0.0.0',5000)
s.bind(addr)#绑定本机地址和端口号
s.listen(5)#设置最大连接数为5，超过后排队
conn,addr=s.accept()#接收TCP客户端连接
msg="hello BlackWalnut Labs, I am TCP Client"
conn.sendall(str(msg,'utf-8')#将数据编码成utf-8格式发送出去

`socket.recv(bufsize)`

从 Socket 接收数据。返回值是一个字节对象，表示接收到的数据。一次接收的最大数据量由 bufsize 指定。

函数说明：接收数据，返回接收到的数据对象。

bufsize：指定一次接收的最大数据量

示例：

s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)#创建socket对象
addr=('192.168.50.66',5000)
s.connect(addr)#客户端接收连接请求
data=s.recv(1024)
print(str(data,'utf8'))#将数据解码成utf-8格式接收

`socket.sendto(bytes, address)`

将数据发送到 Socket 。Socket 不应连接到远程 Socket，因为目标 Socket 由地址指定。

函数说明：与 send() 函数类似，发送数据，目标由 address 决定，用于 UDP 通信，返回发送的数据大小。

bytes：bytes类型数据
address：目标地址和端口号的元组

示例：

import usocket as socket
s = socket.socket(socket.AF_INET,socket.SOCK_DGRAM)#创建UDP数据报类型的socket对象
addr=('192.168.50.66',5000)#目标地址和端口号的元组
send_data='hello，i am cilent'#数据
s.sendto(send_data,addr)##将数据编码成utf-8格式发送出去，用于UDP通信

`socket.recvfrom(bufsize)`

从 Socket 接收数据。返回值是一对 （字节，地址），其中字节是表示接收到的数据的字节对象，地址是发送数据的套接字的地址。

函数说明：接收数据，用于UDP通信，并返回接收到的数据对象和对象的地址。

bufsize：指定一次接收的最大数据量

示例：

import usocket as socket
s = socket.socket(socket.AF_INET,socket.SOCK_DGRAM)#创建UDP数据报类型的socket对象
addr=('192.168.50.66',5000)#目标地址和端口号的元组
send_data='hello，i am cilent'#数据
s.sendto(send_data,addr)##将数据编码成utf-8格式发送出去，用于UDP通信
data,address=s.recvfrom(1024)#接收数据，用于UDP通信
print(str(data,'utf-8'))#将数据解码成'utf-8'格式打印

`socket.setsockopt(level, optname, value)`

设置给定 Socket 选项的值。所需的符号常量在套接字模块（SO_* etc.）中定义。value 可以是表示缓冲区的整数或类似字节的对象。

函数说明：根据选项值设置套接字。

level：套接字选项级别，可为socket.SOL_SOCKET
optname：套接字的选项，可为socket.SOCK_STREAM 、 socket.SOCK_DGRAM 、 socket.SOCK_RAW 或 socket.SO_REUSEADDR。
value：可以是一个整数，也可以是一个表示缓冲区的bytes类对象。

示例：

>>> import usocket as socket
>>> s=socket.socket(socket.AF_INET, socket.SOCK_STREAM)##创建socket对象
>>> s.setsockopt(socket.SOL_SOCKET, socket.SOCK_RAW, 1)#设置套接字为原始套接字

`socket.settimeout(value)`

Note: 并非每个端口都支持此方法，请参见下文。

设置阻止 Socket 操作的超时。value 参数可以是表示秒（seconds）的非负浮点数，也可以是 None。如果给定了非零值，则如果超时时间值在操作完成之前已过，则后续套接字操作将引发 OSError 异常。如果给定零，则将套接字置于非阻塞模式。如果未给出任何值，则将套接字置于阻塞模式。

并非每个 MicroPython 端口都支持这种方法。一个更具可移植性和通用性的解决方案是使用 uselect.poll 对象。这允许同时等待多个对象（不仅在套接字上，而且在支持轮询的通用 stream 对象上）。例子：

# Instead of:
s.settimeout(1.0)  # time in seconds
s.read(10)  # may timeout

# Use:
poller = uselect.poll()
poller.register(s, uselect.POLLIN)
res = poller.poll(1000)  # time in milliseconds
if not res:
    # s 仍未准备好输入，即操作超时

`socket.setblocking(flag)`

设置 Socket 的阻塞或非阻塞模式：如果标志为false，则将套接字设置为非阻塞模式，否则设置为阻塞模式。

此方法是某些 settimeout() 调用的简写：

sock.setblocking(True) 相当于 sock.settimeout(None)
sock.setblocking(False) 相当于 sock.settimeout(0)

函数说明：设置socket的阻塞或非阻塞模式：若标记为false，则将该socket设置为非阻塞模式，而非阻塞模式。

示例：

import usocket as socket
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)#创建TCP数据报的socket对象
s.setblocking(True)#将socket对象设置成阻塞模式

`socket.makefile(mode='rb', buffering=0, /)`

返回与 Socket 关联的文件对象。返回的确切类型取决于 makefile（）的参数。支持仅限于二进制模式（“rb”、“wb”和“rwb”）。

函数说明：返回一个与socket相关联的文件对象。具体的返回类型取决于给定makefile()的参数。

mode:支持的模式，仅限于二进制模式'rb'或'wb'

buffering:缓冲，可为0（输出原始数据），None（buffering为-1），负数（buffering 为默认缓冲大小）

socket须为阻塞模式；允许超时存在，但若出现超时，文件对象的内部缓冲区可能会以不一致状态结束。

示例：

import usocket as socket
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)#创建TCP数据报的socket对象
s.settimeout(10.0)#设置超时时间为10s
print(s.makefile('rb',0))#只读形式的socket相关联对象
<socket>

`socket.socket.fileno()`

函数说明：返回套接字的文件描述。

示例：

import usocket as socket
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)#创建TCP数据报的socket对象
print(s.fileno())#打印套接字文件描述符号
#388

`socket.read([size])`

从 Socket 读取最大大小的字节。返回一个字节对象。如果未给出 size ，则读取 Socket 中的所有可用数据，直到 EOF；因此，在 Socket 关闭之前，该方法不会返回。此函数尝试按请求读取尽可能多的数据（无“short read”）。但这在非阻塞 Socket 中可能不可能实现，然后返回的数据会更少。

函数说明：从 socket 中读取 size 字节。返回一个字节对象。若未给定 size ，则按照类似 socket.readall() 的模式运行

示例：

import usocket as socket
s=socket.socket(socket.AF_INET, socket.SOCK_STREAM)##创建socket对象
addr=('0.0.0.0',5000)
s.bind(addr)#绑定本机地址和端口号
s.listen(5)#设置最大连接数为5，超过后排队
conn,addr=s.accept()#接收TCP客户端连接
data=conn.read(1024)#读取1024字节数据
print(str(data, 'utf8'), end='')#以utf8格式打印出

`socket.readinto(buf[, nbytes])`

将字节读入 buf 。如果指定了 nbytes ，则最多读取这么多字节。否则，最多读取 len（buf） 字节。正如 read()，此方法遵循 “no short reads” 策略。

返回值：读取并存储到buf中的字节数。

函数说明：将字节读取入缓冲区。若指定 nbytes ，则最多读取该数量的字节。否则，最多读取 len(buf) 数量的字节

示例：

import usocket as socket
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)#创建socket对象
addr=('0.0.0.0',5000)
s.bind(addr)#绑定本机地址和端口号
s.listen(5)#设置最大连接数为5，超过后排队
conn,addr=s.accept()#接收TCP客户端连接
buf=bytearray(8)
data=conn.readinto(buf,1024)#读取1024字节数据
print(str(data))#以utf8格式打印出

`socket.readline()`

读一行，以换行符结尾。

返回值：读取的行。

函数说明：接收一行数据，遇换行符结束，并返回接收数据的对象。

示例：

import usocket as socket
s=socket.socket(socket.AF_INET, socket.SOCK_STREAM)##创建socket对象
addr=('0.0.0.0',5000)
s.bind(addr)#绑定本机地址和端口号
s.listen(5)#设置最大连接数为5，超过后排队
conn,addr=s.accept()#接收TCP客户端连接
data=conn.readline()#读取一行数据
print(str(data), end='')#以utf8格式打印出

`socket.write(buf)`

将字节缓冲区写入 Socket 。此函数将尝试将所有数据写入 Socket （无 “short writes”）。但对于非阻塞 Socket ，这可能是不可能的，返回的值将小于 buf 的长度。

返回值：写入的字节数。

函数说明：将字节类型数据写入套接字，并返回写入数据的大小。

示例：

import usocket as socket
s=socket.socket(socket.AF_INET, socket.SOCK_STREAM)##创建socket对象
addr=('0.0.0.0',5000)
s.bind(addr)#绑定本机地址和端口号
s.listen(5)#设置最大连接数为5，超过后排队
conn,addr=s.accept()#接收TCP客户端连接
msg="hello BlackWalnut Labs, I am TCP Client"
print(conn.write(msg))

示例

TCP服务端和客户端通信

waffle micro做TCP服务端

服务端要做的事有这些：

Step 1：创建ServerSocket对象，绑定监听的端口

Step 2：调用accept()方法监听客户端的请求

Step 3：连接建立后，通过输入流读取客户端发送的请求信息

Step 4：通过输出流向客户端发送响应信息

Step 5：关闭相关资源

import network
import usocket as socket

wl = network.WLAN()#创建WLAN对象
wl.active(1)#激活WLAN
wl.connect('Noah-BlackWalnut','123abc456d',security=network.AUTH_PSK)#连接网络

s=socket.socket(socket.AF_INET, socket.SOCK_STREAM)##创建socket对象
addr=('0.0.0.0',5000)#目标地址
s.bind(addr)#绑定本机地址和端口号
s.listen(5)#设置最大连接数为5，超过后排队
while True:
    conn,addr=s.accept()#接收TCP客户端连接
    msg=input()#发送数据为输入数据
    conn.send(str(msg,'utf-8'))#将数据编码成utf-8格式发送出去
s.close()

TCP客户端

waffle micro做TCP客户端

客户端要做的事有这些：

Step 1：创建Socket对象，指明需要链接的服务器的地址和端号

Step 2：链接建立后，通过输出流向服务器发送请求信息

Step 3：通过输出流获取服务器响应的信息

Step 4：关闭相关资源

import network
import usocket as socket

wl = network.WLAN()#创建WLAN对象
wl.active(1)#激活WLAN
wl.connect('Noah-BlackWalnut','123abc456d',security=network.AUTH_PSK)#连接网络

s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)#创建socket对象
addr=("192.168.50.66",5000)#waffle micro地址
s.connect(addr)#客户端接收连接请求
data=s.recv(1024)#客户端接收数据
print(str(data,'utf8'))#将数据解码成utf-8格式接收
s.close()

先点击run运行服务端，输入任意发送数据，再点击run运行客户端，可以看到服务器发送数据已被客户端接收并打印在显示台。

UDP服务端和客户端通信

waffle micro做UDP服务端

服务端要做的事有这些：

Step 1：创建ServerSocket对象

Step 2：调用recvfrom()方法接收客户端的发送的数据

Step 3：通过sendto()方法向客户端发送数据

Step 4：关闭相关资源

import network
import usocket as socket

wl = network.WLAN()#创建WLAN对象
wl.active(1)#激活WLAN
wl.connect('Noah-BlackWalnut','123abc456d',security=network.AUTH_PSK)#连接网络

s = socket.socket(socket.AF_INET，socket.SOCK_DGRAM)#创建UDP数据报类型的socket对象
addr=('0.0.0.0',5000)#目标地址和端口号的元组
s.bind(addr)#绑定目标地址和端口号
while True:
    data,address=s.recvfrom(1024)#接收客户端发出数据
    print(str(data,'utf8'),end='')#将接收数据解码成utf-8格式打印出来
    send_data='hello，i am server'#数据
    s.sendto(send_data,address)#将数据编码成utf-8格式发送到客户端，用于UDP通信
s.close()#关闭socket

UDP客户端

客户端要做的事有这些：

Step 1：创建Socket对象，指明需要链接的服务器的地址和端号

Step 2：通过sendto()方法向客户端发送数据

Step 3：调用recvfrom()方法接收服务端的发送的数据

Step 4：关闭相关资源

import network
import usocket as socket

wl = network.WLAN()#创建WLAN对象
wl.active(1)#激活WLAN
wl.connect('Noah-BlackWalnut','123abc456d',security=network.AUTH_PSK)#连接网络

s = socket.socket(socket.AF_INET,socket.SOCK_DGRAM)
add=("192.168.50.66",5000)
while True:
    send_data='hello，i am cilent'#数据
    s.sendto(send_data,addr)#将数据编码成utf-8格式发送到服务端，用于UDP通信
    data,address=s.recvfrom(1024)#接收服务端发送数据，用于UDP通信
    print(str(data,'utf8'), end='')#将数据编码成utf-8格式发送到客户端，用于UDP通信
s.close()#关闭socket

先点击run运行服务端，输入任意发送数据，再点击run运行客户端，可以看到服务器发送数据已被客户端接收并打印在显示台，客户端发送数据也被显示在服务器显示台。

黑胡桃实验室 BlackWalnut Labs. / Waffle MicroV1 Python API Doc .gitee-modal { width: 500px !important; }

Socket通信

概要

什么是socket

什么是TCP/IP、UDP？

套接字主要类型

套接字实现TCP/UDP通信过程

TCP服务端和客户端通信示例

ESP32 TCP服务端

PC TCP客户端

usocket模块 API文档

Socket address format(s)

创建套接字序列

usocket.socket(af=AF_INET, type=SOCK_STREAM, proto=IPPROTO_TCP, /)

socket.socket 详解

usocket.getaddrinfo(host, port, af=0, type=0, proto=0, flags=0, /)

usocket.inet_ntop(af, bin_addr)

usocket.inet_pton(af, txt_addr)

常量

usocket.AF_INET

usocket.AF_INET6

usocket.SOCK_STREAM

usocket.SOCK_DGRAM

usocket.IPPROTO_UDP

usocket.IPPROTO_TCP

usocket.SOL_*

usocket.IPPROTO_SEC

socket 类

方法

socket.close()

socket.bind(address)

socket.listen([backlog])

socket.accept()

socket.connect(address)

socket.send(bytes)

socket.sendall(bytes)

socket.recv(bufsize)

socket.sendto(bytes, address)

socket.recvfrom(bufsize)

socket.setsockopt(level, optname, value)

socket.settimeout(value)

socket.setblocking(flag)

socket.makefile(mode='rb', buffering=0, /)

socket.socket.fileno()

socket.read([size])

socket.readinto(buf[, nbytes])

socket.readline()

socket.write(buf)

示例

简介

发行版

贡献者

近期动态

搜索帮助

黑胡桃实验室 BlackWalnut Labs. / Waffle MicroV1 Python API Doc