Python GPIO+MQTT控制LED转向灯故障：全局布尔变量无法停止闪烁

你完全找对了方向——问题就出在MQTT的on_message回调被阻塞上！Paho MQTT的消息处理是单线程的：当loop_forever()运行时，所有的消息回调都在同一个线程里执行。你在处理on指令时，直接在on_message里写了while left_blinker_status:这种无限循环，这会把整个MQTT消息处理线程卡死，后续的'off'消息根本没机会被处理，LED自然停不下来。

修复思路 #

要解决这个问题，核心是把阻塞性的闪烁逻辑从MQTT回调中剥离出来，放到独立线程中运行，让on_message只负责更新状态变量和控制线程的启停，而不是自己去执行循环。具体来说：

• 每个转向灯的闪烁对应一个独立线程，避免左右转向灯互相干扰
• 用全局变量控制线程的运行状态，线程自身循环检查状态变量来决定是否继续
• on_message回调只做状态更新和线程的启动/停止操作，快速退出不阻塞

修改后的完整代码 #

import time
from neopixel import *
from threading import Thread
import paho.mqtt.client as mqtt

mqtt_client = None

# LED strip configuration:
LED_COUNT_LEFT = 150  # Number of LED pixels on the left strip.
LED_COUNT_RIGHT = 1  # Number of LED pixels on the right strip.
LED_FREQ_HZ = 800000  # LED signal frequency in hertz (usually 800khz)
LED_DMA = 10  # DMA channel to use for generating signal (try 10)
LED_BRIGHTNESS = 255  # Set to 0 for darkest and 255 for brightest
LED_INVERT = False  # True to invert the signal (when using NPN transistor level shift)
LED_CHANNEL_LEFT = 0  # set to '1' for GPIOs 13, 19, 41, 45 or 53
LED_CHANNEL_RIGHT = 1

# NOTE: The WS2812B strip has red and green inverted, so red is actually (0, 255, 0) and green is (255, 0, 0)
left_blinker_status = False
right_blinker_status = False
# 新增线程对象变量，用于跟踪闪烁线程
left_blinker_thread = None
right_blinker_thread = None

# Create NeoPixel object with appropriate configuration.
# GPIO 18 is pin 12
left_strip = Adafruit_NeoPixel(LED_COUNT_LEFT, 18, LED_FREQ_HZ, LED_DMA, LED_INVERT, LED_BRIGHTNESS, LED_CHANNEL_LEFT)
# GPIO 13 is pin 33
right_strip = Adafruit_NeoPixel(LED_COUNT_RIGHT, 13, LED_FREQ_HZ, LED_DMA, LED_INVERT, LED_BRIGHTNESS, LED_CHANNEL_RIGHT)

# Intialize the library (must be called once before other functions).
left_strip.begin()
right_strip.begin()

# 闪烁线程的核心逻辑：循环检查状态变量，控制LED闪烁
def blinker_thread(strip, status_getter):
    while status_getter():  # 用函数引用获取最新状态，避免变量捕获问题
        solidColor(strip, Color(65, 100, 0))
        time.sleep(0.5)
        solidColor(strip, Color(0, 0, 0))
        time.sleep(0.5)
    # 状态变为False后，恢复LED默认颜色
    solidColor(strip, Color(255, 255, 255))

# MQTT functions
def start_mqtt():
    global mqtt_client
    try:
        system_id = 'Kawasaki Ninja'
        mqtt_client = mqtt.Client(client_id=system_id)
        mqtt_client.disable_logger()
        # Assign callback functions
        mqtt_client.on_connect = on_connect
        mqtt_client.on_message = on_message
        mqtt_client.connect(host='192.168.1.23')
        # Blocking call that processes network traffic, dispatches callbacks and
        # handles reconnecting.
        mqtt_client.loop_forever()
    except Exception as ex:
        print('Exception in start_mqtt()! exception: {}'.format(ex))
        raise

# The callback for when the client receives a CONNACK response from the server.
def on_connect(client, userdata, flags, rc):
    print('Connected with result code ' + str(rc))
    # Subscribing in on_connect() - if we lose connection and
    # reconnect then subscriptions will be renewed.
    client.subscribe('ninja/#')  # The hash sign is wild-card

# The callback for when a PUBLISH message is received from the server.
def on_message(client, userdata, msg):
    global left_blinker_status, right_blinker_status
    global left_blinker_thread, right_blinker_thread
    print('{} {}'.format(msg.topic, str(msg.payload)))
    # Handle the brake topic
    if msg.topic == 'ninja/brake':
        if msg.payload == 'on':
            # BRAKE ON
            if not left_blinker_status:
                solidColor(left_strip, Color(0, 255, 0))
            if not right_blinker_status:
                solidColor(right_strip, Color(0, 255, 0))
        elif msg.payload == 'off':
            # BRAKE OFF
            if not left_blinker_status:
                solidColor(left_strip, Color(255, 255, 255))
            if not right_blinker_status:
                solidColor(right_strip, Color(255, 255, 255))
    # Handle the left turn signal topic
    elif msg.topic == 'ninja/left_turn_signal':
        # Left turn signal on
        if msg.payload == 'on':
            left_blinker_status = True
            # 如果线程未启动，启动新的闪烁线程
            if not (left_blinker_thread and left_blinker_thread.is_alive()):
                # 用lambda包装状态变量的获取，确保线程能拿到最新值
                left_blinker_thread = Thread(target=blinker_thread, args=(left_strip, lambda: left_blinker_status))
                left_blinker_thread.daemon = True  # 设置为守护线程，程序退出时自动终止
                left_blinker_thread.start()
        # Left turn signal off
        elif msg.payload == 'off':
            left_blinker_status = False
            # 不需要手动join线程，因为线程会自己检查状态并退出
    # Handle the right turn signal topic
    elif msg.topic == 'ninja/right_turn_signal':
        # Right turn signal on
        if msg.payload == 'on':
            right_blinker_status = True
            if not (right_blinker_thread and right_blinker_thread.is_alive()):
                right_blinker_thread = Thread(target=blinker_thread, args=(right_strip, lambda: right_blinker_status))
                right_blinker_thread.daemon = True
                right_blinker_thread.start()
        # Right turn signal off
        elif msg.payload == "off":
            right_blinker_status = False
    # Handle the party time topic
    elif msg.topic == 'ninja/party_time':
        # Party on
        if msg.payload == 'on':
            colorWipe(left_strip, Color(0, 255, 0))  # Red
        elif msg.payload == 'white':
            solidColor(left_strip, Color(255, 255, 255))
        elif msg.payload == 'wipe':
            colorWipe(left_strip, Color(0, 255, 0))  # Red
        elif msg.payload == 'off':
            solidColor(left_strip, Color(0, 0, 0))

# Neopixel functions
# Define functions which animate LEDs in various ways.
def colorWipe(strip, color, wait_ms=50):
    """Wipe color across display a pixel at a time."""
    for i in range(strip.numPixels()):
        strip.setPixelColor(i, color)
        strip.show()
        time.sleep(wait_ms / 1000.0)

def solidColor(strip, color):
    for i in range(strip.numPixels()):
        strip.setPixelColor(i, color)
    strip.show()

try:
    # 启动MQTT线程
    mqtt_thread = Thread(target=start_mqtt, args=())
    mqtt_thread.daemon = True  # 修正：之前的isDaemon()是获取状态，要设置用daemon=True
    mqtt_thread.start()
    # 主线程保持运行，避免程序退出
    while True:
        time.sleep(1)
except KeyboardInterrupt:
    # 退出时重置所有LED
    solidColor(left_strip, Color(0,0,0))
    solidColor(right_strip, Color(0,0,0))
    exit()

关键修改点说明 #

1. 剥离阻塞逻辑：把原来on_message里的闪烁循环移到独立的blinker_thread函数中，线程通过检查状态变量决定是否继续运行。
2. 线程管理：新增left_blinker_thread和right_blinker_thread变量跟踪线程状态，避免重复启动线程。
3. 状态变量传递：用lambda函数包装状态变量的获取，确保线程每次循环都能拿到最新的状态值（而不是线程启动时的旧值）。
4. 守护线程设置：所有工作线程都设置为守护线程，这样当主线程退出时，这些线程会自动终止，避免资源泄漏。
5. 修复MQTT线程启动：原来的mqtt_thread.isDaemon()只是获取守护状态，改为mqtt_thread.daemon = True来设置守护属性，同时主线程增加while True: time.sleep(1)保持运行。

额外建议 #

• 如果后续需要处理更复杂的状态（比如多个线程修改同一个变量），可以用threading.Lock来保证线程安全，避免竞态条件。
• 可以考虑用mqtt_client.loop_start()代替loop_forever()，这样不需要手动创建MQTT线程，Paho会自动在后台启动线程处理消息。

内容的提问来源于stack exchange，提问作者spickles