micro python 双线程

yc0526vip

micro python 多线程，一个线程在ssd1306循环显示"hell,micro,python"，一个线程在mqtt接收到"ting"后，ssd1306显示"OK"

FishC

在MicroPython中，可以使用`_thread`模块来创建多线程。下面是一个实现你所描述的双线程代码示例：

1. import _thread
   
2. from machine import Pin, I2C
   
3. from ssd1306 import SSD1306_I2C
   
4. 
   
5. # 初始化SSD1306显示器
   
6. i2c = I2C(scl=Pin(5), sda=Pin(4))
   
7. oled = SSD1306_I2C(128, 64, i2c)
   
8. 
   
9. # 全局变量用于线程间通信
   
10. message_received = False
    
11. 
    
12. # 线程1：循环显示"hello, micro, python"
    
13. def display_thread():
    
14.     global message_received
    
15.     while True:
    
16.         if message_received:
    
17.             oled.fill(0)
    
18.             oled.text("OK", 0, 0)
    
19.             oled.show()
    
20.             message_received = False
    
21.         else:
    
22.             oled.fill(0)
    
23.             oled.text("hello", 0, 0)
    
24.             oled.text("micro", 0, 16)
    
25.             oled.text("python", 0, 32)
    
26.             oled.show()
    
27. 
    
28. # 线程2：接收到"ting"后设置标志位，并发送"OK"
    
29. def receive_thread():
    
30.     global message_received
    
31.     while True:
    
32.         msg = input()
    
33.         if msg == "ting":
    
34.             message_received = True
    
35.             print("OK")
    
36. 
    
37. # 创建并启动线程
    
38. _thread.start_new_thread(display_thread, ())
    
39. _thread.start_new_thread(receive_thread, ())

复制代码

请注意，这只是一个简单的示例，没有考虑线程同步和互斥的问题。在实际开发中，可能需要使用锁或信号量等机制来确保线程间的安全访问。

以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。

yc0526vip

FishC 发表于 2024-1-8 08:56
在MicroPython中，可以使用`_thread`模块来创建多线程。下面是一个实现你所描述的双线程代码示例：

micro python 多线程，一个线程在ssd1306循环显示"hell,micro,python"，一个线程在mqtt接收到"ting"后，ssd1306显示"OK"

FishC

yc0526vip 发表于 2024-01-08 08:56
micro python 多线程，一个线程在ssd1306循环显示"hel ...

在MicroPython中，可以使用`_thread`模块来创建多线程。下面是一个实现你所描述的双线程代码示例：

1. import _thread
   
2. from machine import Pin, I2C
   
3. from ssd1306 import SSD1306_I2C
   
4. from umqtt.simple import MQTTClient
   
5. 
   
6. # 初始化SSD1306显示器
   
7. i2c = I2C(scl=Pin(5), sda=Pin(4))
   
8. oled = SSD1306_I2C(128, 64, i2c)
   
9. 
   
10. # MQTT回调函数，当接收到消息时会自动调用
    
11. def on_message(topic, msg):
    
12.     if msg.decode() == "ting":
    
13.         oled.fill(0)
    
14.         oled.text("OK", 0, 0)
    
15.         oled.show()
    
16. 
    
17. # 线程1：循环显示"hello, micro, python"
    
18. def display_thread():
    
19.     while True:
    
20.         oled.fill(0)
    
21.         oled.text("hello", 0, 0)
    
22.         oled.text("micro", 0, 16)
    
23.         oled.text("python", 0, 32)
    
24.         oled.show()
    
25. 
    
26. # 线程2：连接MQTT服务器并监听消息
    
27. def mqtt_thread():
    
28.     client = MQTTClient("my_client_id", "mqtt_server_ip")
    
29.     client.set_callback(on_message)
    
30.     client.connect()
    
31.     client.subscribe("my_topic")
    
32.    
    
33.     while True:
    
34.         client.wait_msg()
    
35. 
    
36. # 创建并启动线程
    
37. _thread.start_new_thread(display_thread, ())
    
38. _thread.start_new_thread(mqtt_thread, ())

复制代码

请注意，上述代码中需要替换`mqtt_server_ip`为真实的MQTT服务器IP地址，并根据需要修改其他参数。同时，你需要提前安装`umqtt.simple`模块来支持MQTT功能。

这个示例中，线程1负责循环显示“hello, micro, python”，线程2负责连接MQTT服务器，并在接收到消息时显示“OK”。

以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。

yc0526vip

FishC 发表于 2024-1-8 08:57
在MicroPython中，可以使用`_thread`模块来创建多线程。下面是一个实现你所描述的双线程代码示例：

...

循环显示"hello, micro, python" 未停止

FishC

yc0526vip 发表于 2024-01-08 09:29
循环显示"hello, micro, python" 未停止

如果你想要在收到mqtt消息并显示"OK"后停止循环显示"hello, micro, python"，可以使用`_thread`模块的`exit()`方法来终止线程。下面是修改后的代码示例：import _threadfrom machine import Pin, I2Cfrom ssd1306 import SSD1306_I2Cfrom umqtt.simple import MQTTClient# 初始化SSD1306显示器i2c = I2C(scl=Pin(5), sda=Pin(4))oled = SSD1306_I2C(128, 64, i2c)# 全局变量用于线程间通信message_received = Falsedisplay_thread_running = True# MQTT回调函数，当接收到消息时会自动调用def on_message(topic, msg):    global message_received    if msg.decode() == "ting":        oled.fill(0)        oled.text("OK", 0, 0)        oled.show()        message_received = True# 线程1：循环显示"hello, micro, python"def display_thread():    while display_thread_running:        oled.fill(0)        oled.text("hello", 0, 0)        oled.text("micro", 0, 16)        oled.text("python", 0, 32)        oled.show()# 线程2：连接MQTT服务器并监听消息def mqtt_thread():    client = MQTTClient("my_client_id", "mqtt_server_ip")    client.set_callback(on_message)    client.connect()    client.subscribe("my_topic")    while not message_received:        client.check_msg()    # 收到mqtt消息后终止线程    global display_thread_running    display_thread_running = False    _thread.exit()# 创建并启动线程_thread.start_new_thread(display_thread, ())_thread.start_new_thread(mqtt_thread, ())请注意，上述代码中需要替换`mqtt_server_ip`为真实的MQTT服务器IP地址，并根据需要修改其他参数。同时，你需要提前安装`umqtt.simple`模块来支持MQTT功能。这个示例中，线程1负责循环显示"hello, micro, python"，线程2负责连接MQTT服务器，并在接收到消息后显示"OK"并终止线程1的循环。

以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。

yc0526vip

FishC 发表于 2024-1-8 09:30
如果你想要在收到mqtt消息并显示"OK"后停止循环显示"hello, micro, python"，可以使用`_thread`模块的` ...

排版错误，重新输出

FishC

yc0526vip 发表于 2024-01-08 09:32
排版错误，重新输出

非常抱歉，下面是修正后的代码，排版更加清晰：

1. import _thread
   
2. from machine import Pin, I2C
   
3. from ssd1306 import SSD1306_I2C
   
4. from umqtt.simple import MQTTClient
   
5. 
   
6. # 初始化SSD1306显示器
   
7. i2c = I2C(scl=Pin(5), sda=Pin(4))
   
8. oled = SSD1306_I2C(128, 64, i2c)
   
9. 
   
10. # 全局变量用于线程间通信
    
11. message_received = False
    
12. display_thread_running = True
    
13. 
    
14. # MQTT回调函数，当接收到消息时会自动调用
    
15. def on_message(topic, msg):
    
16.     global message_received
    
17.     if msg.decode() == "ting":
    
18.         oled.fill(0)
    
19.         oled.text("OK", 0, 0)
    
20.         oled.show()
    
21.         message_received = True
    
22. 
    
23. # 线程1：循环显示"hello, micro, python"
    
24. def display_thread():
    
25.     while display_thread_running:
    
26.         oled.fill(0)
    
27.         oled.text("hello", 0, 0)
    
28.         oled.text("micro", 0, 16)
    
29.         oled.text("python", 0, 32)
    
30.         oled.show()
    
31. 
    
32. # 线程2：连接MQTT服务器并监听消息
    
33. def mqtt_thread():
    
34.     client = MQTTClient("my_client_id", "mqtt_server_ip")
    
35.     client.set_callback(on_message)
    
36.     client.connect()
    
37.     client.subscribe("my_topic")
    
38.     while not message_received:
    
39.         client.check_msg()
    
40.    
    
41.     # 收到mqtt消息后终止线程
    
42.     global display_thread_running
    
43.     display_thread_running = False
    
44.     _thread.exit()
    
45. 
    
46. # 创建并启动线程
    
47. _thread.start_new_thread(display_thread, ())
    
48. _thread.start_new_thread(mqtt_thread, ())

复制代码

请注意，上述代码中需要替换`mqtt_server_ip`为真实的MQTT服务器IP地址，并根据需要修改其他参数。同时，你需要提前安装`umqtt.simple`模块来支持MQTT功能。

这个示例中，线程1负责循环显示"hello, micro, python"，线程2负责连接MQTT服务器，并在接收到消息后显示"OK"并终止线程1的循环。

以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。

yc0526vip

FishC 发表于 2024-1-8 09:32
非常抱歉，下面是修正后的代码，排版更加清晰：

micro python，ssd1306循环显示mqtt消息，mqtt消息收到"ting"时，停止循环

FishC

yc0526vip 发表于 2024-01-08 09:35
micro python，ssd1306循环显示mqtt消息，mqtt消息收 ...

下面是一个可以实现你所描述的功能的MicroPython代码示例：

1. from machine import Pin, I2C
   
2. from ssd1306 import SSD1306_I2C
   
3. from umqtt.simple import MQTTClient
   
4. 
   
5. # 初始化SSD1306显示器
   
6. i2c = I2C(scl=Pin(5), sda=Pin(4))
   
7. oled = SSD1306_I2C(128, 64, i2c)
   
8. 
   
9. # 全局变量用于线程间通信
   
10. message_received = False
    
11. display_thread_running = True
    
12. 
    
13. def on_message(topic, msg):
    
14.     global message_received
    
15.     if msg == b"ting":
    
16.         oled.fill(0)
    
17.         oled.text("OK", 0, 0)
    
18.         oled.show()
    
19.         message_received = True
    
20. 
    
21. def display_thread():
    
22.     while display_thread_running:
    
23.         oled.fill(0)
    
24.         oled.text("MQTT Message:", 0, 0)
    
25.         oled.text("Waiting...", 0, 16)
    
26.         oled.show()
    
27. 
    
28. def mqtt_thread():
    
29.     client = MQTTClient("my_client_id", "mqtt_server_ip")
    
30.     client.set_callback(on_message)
    
31.     client.connect()
    
32.     client.subscribe("my_topic")
    
33. 
    
34.     while not message_received:
    
35.         client.check_msg()
    
36. 
    
37.     client.disconnect()
    
38.     global display_thread_running
    
39.     display_thread_running = False
    
40. 
    
41.     # 清空屏幕
    
42.     oled.fill(0)
    
43.     oled.show()
    
44. 
    
45. # 创建并启动线程
    
46. _thread.start_new_thread(display_thread, ())
    
47. _thread.start_new_thread(mqtt_thread, ())

复制代码

请注意，上述代码中需要将`mqtt_server_ip`替换为你真实的MQTT服务器IP地址。同时，你需要提前安装`umqtt.simple`模块以支持MQTT功能。

这个示例中，线程1负责循环显示"MQTT Message: Waiting..."的消息内容，线程2负责连接MQTT服务器并监听消息。当接收到"ting"消息时，线程2会停止线程1的循环并显示"OK"。

以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。

yc0526vip

FishC 发表于 2024-1-8 09:35
下面是一个可以实现你所描述的功能的MicroPython代码示例：

能否简化一些

FishC

yc0526vip 发表于 2024-01-08 09:39
能否简化一些

当然可以！下面是一个简化版的MicroPython代码示例：from machine import Pin, I2Cfrom ssd1306 import SSD1306_I2Cfrom umqtt.simple import MQTTClient# 初始化SSD1306显示器i2c = I2C(scl=Pin(5), sda=Pin(4))oled = SSD1306_I2C(128, 64, i2c)# 全局变量用于线程间通信message_received = Falsedisplay_thread_running = Truedef on_message(topic, msg):    global message_received    if msg == b"ting":        oled.fill(0)        oled.text("OK", 0, 0)        oled.show()        message_received = Truedef display_thread():    while display_thread_running:        oled.fill(0)        if message_received:            oled.text("OK", 0, 0)        else:            oled.text("MQTT Message:", 0, 0)            oled.text("Waiting...", 0, 16)        oled.show()def mqtt_thread():    client = MQTTClient("my_client_id", "mqtt_server_ip")    client.set_callback(on_message)    client.connect()    client.subscribe("my_topic")    while not message_received:        client.wait_msg()    client.disconnect()    global display_thread_running    display_thread_running = False    # 清空屏幕    oled.fill(0)    oled.show()# 创建并启动线程_thread.start_new_thread(display_thread, ())_thread.start_new_thread(mqtt_thread, ())请注意，上述代码中需要将`mqtt_server_ip`替换为你真实的MQTT服务器IP地址。同时，你需要提前安装`umqtt.simple`模块以支持MQTT功能。这个简化的示例中，线程1负责循环显示"MQTT Message: Waiting..."或"OK"，线程2负责连接MQTT服务器并监听消息。当接收到"ting"消息时，线程2会停止线程1的循环并显示"OK"。

以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。

yc0526vip

FishC 发表于 2024-1-8 09:39
当然可以！下面是一个简化版的MicroPython代码示例：from machine import Pin, I2Cfrom ssd1306 import ...

排版错误，重新输出

FishC

yc0526vip 发表于 2024-01-08 09:44
排版错误，重新输出

非常抱歉，下面是重新排版的代码示例：

1. from machine import Pin, I2C
   
2. from ssd1306 import SSD1306_I2C
   
3. from umqtt.simple import MQTTClient
   
4. import _thread
   
5. 
   
6. # 初始化SSD1306显示器
   
7. i2c = I2C(scl=Pin(5), sda=Pin(4))
   
8. oled = SSD1306_I2C(128, 64, i2c)
   
9. 
   
10. # 全局变量用于线程间通信
    
11. message_received = False
    
12. display_thread_running = True
    
13. 
    
14. def on_message(topic, msg):
    
15.     global message_received
    
16.     if msg == b"ting":
    
17.         oled.fill(0)
    
18.         oled.text("OK", 0, 0)
    
19.         oled.show()
    
20.         message_received = True
    
21. 
    
22. def display_thread():
    
23.     while display_thread_running:
    
24.         oled.fill(0)
    
25.         if message_received:
    
26.             oled.text("OK", 0, 0)
    
27.         else:
    
28.             oled.text("MQTT Message:", 0, 0)
    
29.             oled.text("Waiting...", 0, 16)
    
30.         oled.show()
    
31. 
    
32. def mqtt_thread():
    
33.     client = MQTTClient("my_client_id", "mqtt_server_ip")
    
34.     client.set_callback(on_message)
    
35.     client.connect()
    
36.     client.subscribe("my_topic")
    
37.     while not message_received:
    
38.         client.wait_msg()
    
39.     client.disconnect()
    
40.     global display_thread_running
    
41.     display_thread_running = False
    
42.     # 清空屏幕
    
43.     oled.fill(0)
    
44.     oled.show()
    
45. 
    
46. # 创建并启动线程
    
47. _thread.start_new_thread(display_thread, ())
    
48. _thread.start_new_thread(mqtt_thread, ())

复制代码

请注意，上述代码中需要将`mqtt_server_ip`替换为你真实的MQTT服务器IP地址。同时，你需要提前安装`umqtt.simple`模块以支持MQTT功能。

这个简化的示例中，线程1负责循环显示"MQTT Message: Waiting..."或"OK"，线程2负责连接MQTT服务器并监听消息。当接收到"ting"消息时，线程2会停止线程1的循环并显示"OK"。

以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。