pip install pico-mqtt

import time
import machine
import pico_mqtt

# Set up the MQTT client
client = pico_mqtt.MQTT('pico', 'broker.hivemq.com')
client.connect()

# Set up the LED
led = machine.Pin(25, machine.Pin.OUT)

# Set up the loop
while True:
    # Blink the LED
    led.toggle()
    time.sleep(0.1)

    # Check for messages
    msg = client.get()
    if msg is not None:
        # Set the LED solid
        led.on()
        time.sleep(1.0)
        led.off()

import machine
import time
import umqtt.simple
import ubinascii

# Set up the LED and its initial state
led = machine.Pin(25, machine.Pin.OUT)
led.off()
led_state = False

# Set up the MQTT client
MQTT_BROKER = 'your_mqtt_broker_address'
MQTT_PORT = 1883
MQTT_CLIENT_ID = ubinascii.hexlify(machine.unique_id())
MQTT_TOPIC = b'your_mqtt_topic'
mqtt_client = umqtt.simple.MQTTClient(MQTT_CLIENT_ID, MQTT_BROKER)

def on_connect(client, userdata, flags, rc):
    print('Connected to MQTT broker with result code: {}'.format(rc))
    client.subscribe(MQTT_TOPIC)

def on_message(client, userdata, message):
    global led_state
    print('Received message: ', message.payload.decode())
    led_state = True

mqtt_client.set_callback(on_connect=on_connect, on_message=on_message)
mqtt_client.connect()

# Main loop
while True:
    led.value(not led.value())  # Toggle LED state
    time.sleep(0.1)  # Wait for 0.1 seconds

    if mqtt_client.check_msg() and led_state:
        led.on()
        time.sleep(1)
        led_state = False

pip install adafruit-circuitpython-digitalio adafruit-circuitpython-neopixel umqtt.simple

import asyncio
import digitalio
import network
import time
import umqtt.simple

# Set up the LED pin
LED_PIN = 25
led = digitalio.DigitalInOut(LED_PIN)
led.direction = digitalio.Direction.OUTPUT

# Set up the Wi-Fi connection
WIFI_SSID = "your_wifi_ssid"
WIFI_PASSWORD = "your_wifi_password"

async def connect_wifi():
    wlan = network.WLAN(network.STA_IF)
    wlan.active(True)
    if not wlan.isconnected():
        print("Connecting to Wi-Fi...")
        wlan.connect(WIFI_SSID, WIFI_PASSWORD)
        while not wlan.isconnected():
            pass
        print("Connected!")

# Set up the MQTT client
MQTT_BROKER = "your_mqtt_broker"
MQTT_PORT = 1883
MQTT_TOPIC = "your_topic"

async def on_message(client, topic, message):
    global led
    print(f"Received message: {message.decode()}")
    led.value = True
    await asyncio.sleep(1)
    led.value = False

async def mqtt_connect_and_subscribe():
    client = umqtt.simple.MQTTClient("pico_w")
    await client.connect(MQTT_BROKER, MQTT_PORT)
    await client.subscribe(MQTT_TOPIC)
    print(f"Subscribed to {MQTT_TOPIC}")
    client.set_callback(on_message)
    return client

async def main(mqtt_client):
    global led
    while True:
        led.value = not led.value
        await asyncio.sleep(0.5)
        await mqtt_client.check_msg()

async def run():
    await connect_wifi()
    mqtt_client = await mqtt_connect_and_subscribe()
    try:
        await main(mqtt_client)
    finally:
        await mqtt_client.disconnect()

if __name__ == "__main__":
    asyncio.run(run())

import machine
import time
import umqtt.simple

# Set up the LED
led = machine.Pin(25, machine.Pin.OUT)

# Set up MQTT parameters
MQTT_SERVER = "your_mqtt_server"
MQTT_PORT = 1883
MQTT_TOPIC = "your_topic"

def on_message(topic, message):
    global led
    print(f"Received message: {message.decode()}")
    led.on()
    time.sleep(1)
    led.off()

def connect_mqtt():
    global client_id, mqtt
    client_id = f"pico-w-{machine.unique_id()}"
    mqtt = umqtt.simple.MQTTClient(client_id, MQTT_SERVER, MQTT_PORT)
    mqtt.set_callback(on_message)
    mqtt.connect()
    print(f"Connected to MQTT broker: {MQTT_SERVER}")
    mqtt.subscribe(MQTT_TOPIC)

connect_mqtt()

try:
    while True:
        led.toggle()
        mqtt.check_msg()
        time.sleep(0.1)
except KeyboardInterrupt:
    pass
finally:
    led.off()
    mqtt.disconnect()
    print("Disconnected from MQTT broker")

pip install pico-mqtt

import machine
import time
from pico_mqtt import MQTTClient

# Set up the LED and MQTT client
led = machine.Pin(25, machine.Pin.OUT)  # LED connected to GPIO 25 (Pico W)
mqtt_client = MQTTClient("pico_w", "mqtt_broker_address", user="username", password="password")
mqtt_client.set_callback(mqtt_callback)
mqtt_client.connect()
mqtt_client.subscribe(b"your/mqtt/topic/#")

# MQTT message callback function
def mqtt_callback(topic, message):
    print(f"Received message '{message.decode()}' on topic '{topic.decode()}'")
    global led_state
    led_state = "solid"
    time.sleep(1)
    led_state = "blinking"

# Initial LED state
led_state = "blinking"

# Main loop
while True:
    if led_state == "blinking":
        led.toggle()
        time.sleep(0.1)
    elif led_state == "solid":
        led.on()
    mqtt_client.check_msg()