[Diaoye aprende a programar] Socket del módulo incorporado del manual de MicroPython: comunicación de socket

MicroPython es una versión ligera del intérprete diseñada para ejecutar el lenguaje de programación Python 3 en sistemas integrados. En comparación con Python normal, el intérprete de MicroPython es pequeño (solo alrededor de 100 KB) y se compila en un archivo ejecutable binario para su ejecución, lo que resulta en una mayor eficiencia de ejecución. Utiliza un mecanismo de recolección de basura liviano y elimina la mayor parte de la biblioteca estándar de Python para adaptarse a microcontroladores con recursos limitados.

Las características principales de MicroPython incluyen:
1. La sintaxis y las funciones son compatibles con Python estándar, lo que facilita su aprendizaje y uso. Admite la mayoría de la sintaxis principal de Python.
2. Acceda y controle directamente el hardware, controle GPIO, I2C, SPI, etc. como Arduino.
3. Potente sistema de módulos, que proporciona sistema de archivos, red, interfaz gráfica y otras funciones.
4. Admite compilación cruzada para generar código nativo eficiente, que es entre 10 y 100 veces más rápido que el intérprete.
5. La cantidad de código es pequeña y el uso de memoria es pequeño, adecuado para ejecutarse en MCU y placas de desarrollo con poca memoria.
6. Licencia de código abierto, de uso gratuito. El entorno interactivo de Shell proporciona comodidad para el desarrollo y las pruebas.
7. El controlador de E/S incorporado admite una gran cantidad de plataformas de microcontroladores, como ESP8266, ESP32, STM32, micro:bit, placa de control y PyBoard, etc. Hay una comunidad activa.

Los escenarios de aplicación de MicroPython incluyen:
1. Crear rápidamente prototipos e interacciones de usuario para productos integrados.
2. Realice algunos pequeños proyectos de hardware programables.
3. Como herramienta educativa, ayuda a los principiantes a aprender programación en Python e IoT.
4. Cree firmware para dispositivos inteligentes para lograr control avanzado y conectividad en la nube.
5. Diversas aplicaciones de microcontroladores como Internet de las cosas, inteligencia integrada, robots, etc.

Cosas a tener en cuenta al utilizar MicroPython:
1. La memoria y el espacio Flash son limitados.
2. La eficiencia de explicación y ejecución no es tan buena como la del lenguaje C.
3. Algunas funciones de la biblioteca son diferentes a las de la versión estándar.
4. Optimice la sintaxis de la plataforma y corrija las diferencias con el Python estándar.
5. Uso razonable de los recursos de memoria para evitar la asignación frecuente de grandes bloques de memoria.
6. Utilice código nativo para mejorar el rendimiento de partes clave de la velocidad.
7. Utilice adecuadamente la abstracción para encapsular las operaciones de hardware subyacentes.

En términos generales, MicroPython lleva Python al campo de los microcontroladores, lo cual es una innovación importante que no solo reduce el umbral de programación sino que también proporciona buenas capacidades de control de hardware. Es muy adecuado para el desarrollo de diversos Internet de las cosas y hardware inteligente.

El socket del módulo integrado de MicroPython es un módulo que se utiliza para implementar operaciones de socket simples y se puede utilizar para realizar coincidencias de patrones, reemplazo, división y otras operaciones en cadenas. Sus principales características son:

1. Puede utilizar el método socket() para crear un nuevo objeto socket, especificando su familia de direcciones, tipo de socket y número de protocolo.
2. Puede usar el método connect() para conectarse a una dirección remota, o usar los métodos bind() y listening() para escuchar solicitudes de conexión en una dirección local.
3. Puede utilizar el método aceptar() para aceptar una solicitud de conexión y devolver un nuevo objeto de socket y dirección de cliente.
4. Puede enviar y recibir datos en un socket usando los métodos send() y recv(), o enviar y recibir datos en un socket sin conexión usando los métodos sendto() y recvfrom().
5. Puede utilizar el método close() para cerrar un socket y liberar sus recursos.
6. Puede utilizar los métodos setsockopt() y getsockopt() para configurar y obtener opciones de socket, como tiempo de espera, tamaño de búfer, etc.
7. Puede usar el método getaddrinfo() para convertir un nombre de host y un número de puerto en una lista de información de direcciones, o usar el método gethostbyname() para convertir un nombre de host en una dirección IP.

Los escenarios de aplicación del módulo de socket incluyen:

1. Se utiliza para comunicar o controlar diferentes servicios o dispositivos de red, como servidores web, servidores FTP, servidores SMTP, clientes MQTT, etc.
2. Se utiliza para implementar algunas funciones o aplicaciones relacionadas con la red, como desarrollo web, llamadas API, transmisión de datos, control remoto, etc.
3. Se utiliza para aprender o enseñar algunos conocimientos o habilidades relacionados con la red, como protocolos de red, seguridad de red, Internet de las cosas, etc.

Las notas sobre el módulo de enchufe incluyen:

1. El módulo de socket implementa un subconjunto del módulo CPython 12 y solo admite la dirección IPv4 12, por lo que no es totalmente compatible con las funciones y el rendimiento de CPython.
2. El módulo de socket depende del hardware y los recursos de la red132 en la placa específica. Diferentes placas MicroPython pueden tener diferentes funciones disponibles y rangos de parámetros132. Debe verificar los documentos específicos para determinar las funciones admitidas y los métodos de uso.
3. El módulo de enchufe proporciona acceso y control directo y sin restricciones de las comunicaciones de la red. El uso inadecuado puede causar fallas, bloqueos, fallas y, en casos extremos, daños al hardware del dispositivo. Tenga cuidado y siga las normas y directrices pertinentes.

Los siguientes son varios ejemplos de aplicaciones prácticas del socket del módulo integrado de MicroPython:

Caso 1: crear un cliente TCP utilizando el módulo de socket

# 导入socket模块
import socket

# 创建一个TCP套接字
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

# 连接到百度服务器
s.connect(('www.baidu.com', 80))

# 发送HTTP请求
s.send(b'GET / HTTP/1.0\r\nHost: www.baidu.com\r\n\r\n')

# 接收HTTP响应
response = s.recv(4096)

# 打印响应内容
print(response)

# 关闭套接字
s.close()

Caso 2: crear un servidor UDP utilizando el módulo de socket

# 导入socket模块
import socket

# 创建一个UDP套接字
s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)

# 绑定到本地地址和端口
s.bind(('0.0.0.0', 8888))

# 循环处理客户端消息
while True:
    # 接收客户端消息和地址
    data, addr = s.recvfrom(1024)
    # 打印消息和地址
    print(data, addr)
    # 向客户端回复消息
    s.sendto(b'Hello, ' + data, addr)

Caso 3: crear un servidor web utilizando el módulo de socket

# 导入socket模块
import socket

# 创建一个TCP套接字
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

# 设置套接字选项，允许重用地址
s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)

# 绑定到本地地址和端口
s.bind(('0.0.0.0', 80))

# 开始监听连接请求
s.listen(5)

# 循环处理客户端连接
while True:
    # 接受一个客户端连接，并返回一个新的套接字和地址
    conn, addr = s.accept()
    # 接收客户端请求
    request = conn.recv(1024)
    # 打印请求内容
    print(request)
    # 构造响应内容
    response = b'HTTP/1.0 200 OK\r\nContent-Type: text/html\r\n\r\nHello, MicroPython!'
    # 发送响应内容
    conn.send(response)
    # 关闭连接
    conn.close()

Caso 4: Crear un servidor TCP:

import socket

# 创建TCP服务器套接字
server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

# 绑定服务器地址和端口
server_address = ('localhost', 8000)
server_socket.bind(server_address)

# 开始监听客户端连接
server_socket.listen(1)
print("Server is listening for connections...")

# 接受客户端连接
client_socket, client_address = server_socket.accept()
print("Connected to client:", client_address)

# 接收客户端数据
data = client_socket.recv(1024)
print("Received data:", data)

# 关闭连接
client_socket.close()
server_socket.close()

En este ejemplo, creamos un servidor TCP usando el módulo de socket. Creamos un socket TCP y luego vinculamos la dirección y el puerto del servidor. A continuación, comenzamos a escuchar las conexiones del cliente y aceptamos conexiones cuando un cliente se conecta. Una vez establecida la conexión, recibimos los datos enviados por el cliente y los imprimimos. Finalmente cerramos la conexión y el socket del servidor.

Caso 5: Crear cliente TCP:

import socket

# 创建TCP客户端套接字
client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

# 连接服务器
server_address = ('localhost', 8000)
client_socket.connect(server_address)
print("Connected to server:", server_address)

# 发送数据给服务器
data = "Hello, server!"
client_socket.send(data.encode())

# 关闭连接
client_socket.close()

En este ejemplo, creamos un cliente TCP usando el módulo de socket. Creamos un socket TCP y luego nos conectamos a la dirección y el puerto del servidor. Una vez establecida la conexión, enviamos los datos al servidor. Aquí enviamos la cadena "¡Hola, servidor!", que debe codificarse en un formato de flujo de bytes. Finalmente cerramos la conexión.

Caso 6: Crear servidor y cliente UDP:

import socket

# 创建UDP套接字
udp_socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)

# 绑定服务器地址和端口
server_address = ('localhost', 9000)
udp_socket.bind(server_address)
print("Server is listening for messages...")

# 接收客户端消息
data, client_address = udp_socket.recvfrom(1024)
print("Received message:", data)

# 发送响应给客户端
response = "Hello, client!"
udp_socket.sendto(response.encode(), client_address)

# 关闭套接字
udp_socket.close()

En este ejemplo, creamos un servidor y un cliente UDP utilizando el módulo de socket. Primero, creamos un socket UDP y vinculamos la dirección y el puerto del servidor. Luego, el servidor comienza a escuchar los mensajes y los imprime cuando los recibe. A continuación, el servidor envía un mensaje de respuesta al cliente. Finalmente cerramos el enchufe. Estos ejemplos de aplicaciones prácticas demuestran la funcionalidad del uso del módulo de socket integrado de MicroPython. Al utilizar el módulo de socket, puede crear servidores y clientes TCP, así como crear servidores y clientes UDP. Estas funciones son muy útiles en escenarios como comunicación de red y transmisión de datos.

Caso 7: Crear cliente TCP

import socket

# 创建 TCP 客户端
client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

# 连接服务器
server_address = ('192.168.0.100', 8000)
client_socket.connect(server_address)

# 发送数据
data = b'Hello, server!'
client_socket.sendall(data)

# 接收响应
response = client_socket.recv(1024)
print("服务器响应：", response.decode())

# 关闭客户端套接字
client_socket.close()

En este ejemplo, importamos el módulo de socket y lo usamos para crear un cliente TCP. Primero usamos la función socket.socket() para crear un objeto socket y especificamos la familia de direcciones como socket.AF_INET y el protocolo de transmisión como socket.SOCK_STREAM, que es TCP. Luego usamos la función connect() para conectarnos a la dirección del servidor dirección_servidor. A continuación, utilizamos la función sendall() para enviar datos al servidor. Usamos la función recv() para recibir los datos de respuesta del servidor e imprimirlos. Finalmente, cerramos el socket del cliente.

Caso 8: Crear servidor TCP

import socket

# 创建 TCP 服务器
server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

# 绑定地址和端口
server_address = ('', 8000)
server_socket.bind(server_address)

# 监听连接
server_socket.listen(1)
print("服务器正在监听端口 8000...")

# 接受连接
client_socket, client_address = server_socket.accept()
print("客户端连接成功：", client_address)

# 接收数据
data = client_socket.recv(1024)
print("客户端发送的数据：", data.decode())

# 发送响应
response = b'Hello, client!'
client_socket.sendall(response)

# 关闭客户端套接字
client_socket.close()

# 关闭服务器套接字
server_socket.close()

En este ejemplo, importamos el módulo de socket y lo usamos para crear un servidor TCP. Primero usamos la función socket.socket() para crear un objeto socket y especificamos la familia de direcciones como socket.AF_INET y el protocolo de transmisión como socket.SOCK_STREAM, que es TCP. Luego usamos la función bind() para vincular la dirección y el puerto del servidor al socket. A continuación, usamos la función listening() para escuchar las conexiones e imprimir el puerto en el que está escuchando el servidor. Luego, usamos la función aceptar() para aceptar la conexión del cliente e imprimir la dirección del cliente. Usamos la función recv() para recibir los datos enviados por el cliente e imprimirlos. Finalmente, usamos la función sendall() para enviar los datos de respuesta al cliente. Finalmente cerramos el socket del cliente y el socket del servidor.

Caso 9: Crear cliente UDP

import socket

# 创建 UDP 客户端
client_socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)

# 发送数据
server_address = ('192.168.0.100', 9000)
data = b'Hello, server!'
client_socket.sendto(data, server_address)

# 接收响应
response, server_address = client_socket.recvfrom(1024)
print("服务器响应：", response.decode())

# 关闭客户端套接字
client_socket.close()

En este ejemplo, importamos el módulo de socket y lo usamos para crear un cliente UDP. Primero usamos la función socket.socket() para crear un objeto socket y especificamos la familia de direcciones como socket.AF_INET y el protocolo de transmisión como socket.SOCK_DGRAM, que es UDP. Luego usamos la función sendto() para enviar los datos a la dirección del servidor server_address. Usamos la función recvfrom() para recibir los datos de respuesta del servidor e imprimirlos. Finalmente, cerramos el socket del cliente.

Estos ejemplos muestran el uso práctico del módulo de socket en MicroPython. El módulo de socket proporciona soporte para la programación de sockets.