Raspberry Pi Pico W

If you want to bring the bigger Pi4 to the MQTT game:

https://mqttx.app/ https://github.com/emqx/MQTTX

sudo apt install -y mosquitto
sudo apt install -y mosquitto-clients

#sudo apt install python3-pip
sudo pip3 install paho-mqtt

sudo systemctl status mosquitto.service

In the absence of a direct configuration entry for the port, the port used by Mosquitto could be the default port (1883 for MQTT or 8883 for MQTT over TLS/SSL).

You can check which one is in used with:

netstat -tuln

https://www.youtube.com/watch?v=GQOqvvei5Do #also hivemq

Yes, you can temporarily allow anonymous clients to publish to a topic. However, this is not recommended for a production environment as it creates a significant security vulnerability. Anyone who can reach your server can then publish data to that topic.

This is primarily useful for initial testing and quick development to confirm that your Pico W’s code and network configuration are correct.

Here’s how to do it in EMQX:

1. Enable Anonymous Authentication By default, EMQX allows anonymous access. However, if you’ve previously configured a password-based authentication, you may have disabled it. You can check this in the EMQX dashboard.

2. Navigate to Access Control -> Authentication.

3. If you see an “anonymous” entry, ensure it is enabled.

4. If it’s not present or disabled, you may need to add or enable it, but in most default setups, it’s already there.

5. Configure Anonymous Authorization This is the most critical step. You need to create an Access Control List (ACL) rule that explicitly allows unauthenticated (anonymous) users to publish to your desired topic.

6. Navigate to Access Control -> Authorization.

7. Add a new rule.

8. Set the Type to All Users.

9. Enter the Topic Filter (e.g., house/living_room/sensor_data).

10. Set the Action to Publish.

11. Set the Permission to Allow.

12. Save the rule.

This rule will apply to any client that connects without a username and password. Now, your Pico W can connect to the broker using its IP address and port without needing to provide any credentials.

Again, please remember to set up proper authentication and authorization with specific users and passwords before you deploy your project for real-world use.

You don’t need to manually create a topic in EMQX.

Topics are created automatically the first time a client publishes a message to them. You just need to specify the topic name in your Pico W’s code.

How it Works

The MQTT broker operates on a publish-subscribe model. When a client (your Pico W) sends a message, it includes a topic in the message header.

The broker, upon receiving the message, checks if that topic already exists.

If it doesn’t, the broker creates it and then routes the message to any clients that are subscribed to that topic.

What You Need to Do

1. Define the Topic Name: In your Pico W’s code, simply decide on a logical and hierarchical topic name. Good examples are:
   • sensor/livingroom/temperature
   • device/picow_01/status
   • home/kitchen/light
2. Publish to the Topic: When your Pico W’s code publishes its first message, it will automatically create that topic on the EMQX broker.
3. Subscribe to the Topic: Any other client (e.g., another Pico W, a dashboard on your computer, or a smartphone app) that wants to receive that data will need to subscribe to the exact same topic name.

This dynamic topic creation is a key feature of MQTT that makes it flexible and easy to use.

This did not work:

#snap install mosquitto
choco install mosquitto

So I went and download it as in old school fashion: https://mosquitto.org/download/

And configure the new path variable:

For setting a Windows System Environment Variable, the variable name and value are distinct.

• The variable name you need to edit is Path. This is a system variable that tells Windows where to look for executable files.
• The variable value you need to add is the path to the Mosquitto installation folder: C:\Program Files\mosquitto.

When you add this value to the existing Path variable, you’re not changing its name. You are simply appending the Mosquitto directory to the list of folders Windows checks for commands.

So that this works:

mosquitto -h #I got mosquitto version 2.0.22

Adding the Language of IoT (MQTT) 🗣️

Being online is one thing, but how does your Pico W “talk” to your other devices? It needs a common language, and for IoT, that language is MQTT.

• What is MQTT? 🗣️ MQTT stands for Message Queuing Telemetry Transport. It’s a super lightweight and efficient protocol specifically designed for devices with limited power and bandwidth. Unlike a standard web request where one device talks directly to another, MQTT uses a “central hub” model.

  • The Broker (Server): This is the central hub. In your case, this is the EMQX server running on your Ubuntu machine. It’s the post office of your IoT system.
  • Clients (Publishers & Subscribers): These are the devices that want to send or receive data. Your Pico W is a client.

  A client publishes a message to a topic (like putting a letter in a specific mailbox), and any other client that has subscribed to that same topic receives the message. The clients never talk to each other directly; they only communicate with the broker.

• Installing the Library 📚 Your Pico W needs a special library to understand and speak MQTT. Your notes point out two ways to install them: upip and the newer mip.

  #install libraries for mqtt
  ##with mip
  mip.install("umqtt.robust")
  mip.install("umqtt.simple")

  The mip.install() commands download the necessary library files directly onto your Pico W’s flash memory. You’re installing two variants:

  • umqtt.simple: A very basic MQTT client.
  • umqtt.robust: A more powerful version that includes features like automatic re-connection if the Pico W loses its Wi-Fi signal. This is highly recommended for any real-world project.

Once these steps are completed, you’ve laid the groundwork.

Your Pico W is connected to the internet, and it has the tools to start sending and receiving data using the MQTT protocol. You are now ready to build the next part of your project: writing the code that actually publishes your sensor data!

#connect to wifi
import network   # handles connecting to WiFi
import urequests # handles making and servicing network requests

# Connect to network
wlan = network.WLAN(network.STA_IF)
wlan.active(True)

# Fill in your network name (ssid) and password here:
ssid = 'HUAWEI P30'
password = 'mokradupa68'
wlan.connect(ssid, password)

#install libraries for mqtt

##with upip
#upip.install("micropython-umqtt-robust")
#upip.install("micropython-umqtt-simple")

##with mip
#https://github.com/micropython/micropython-lib 
#https://github.com/micropython/micropython-lib/tree/master/micropython/umqtt.robust
mip.install("umqtt.robust")

#https://github.com/micropython/micropython-lib/tree/master/micropython/umqtt.simple
mip.install("umqtt.simple")

then the code https://github.com/donskytech/micropython-raspberry-pi-pico/tree/main/umqtt.simple

Both upip and mip are package managers for MicroPython.

The key difference is that mip is the new, recommended tool, while upip is the older, deprecated one. mip offers several advantages that make it a better choice for installing libraries on your Pico W.

The Old Way: upip

upip (MicroPython’s Package Installer) was the original tool for downloading and installing libraries from the web.

It worked by fetching the library files from a remote URL, such as micropython-lib, and placing them on your device.

Key Characteristics:

• Simpler Protocol: upip used a basic HTTP request to download packages.
• Deprecation: It’s no longer actively maintained. If you try to use it with newer MicroPython firmware versions, you may encounter errors or discover that it can’t find the necessary packages.
• No __init__.py files: The packages weren’t properly structured, which could cause issues with module imports.

The New Way: mip ✨

mip (MicroPython Installation Program) is the modern package manager. It was introduced to address the limitations of upip and provide a more robust and reliable way to manage libraries.

Key Characteristics:

• Improved Architecture: mip uses a better-designed protocol that ensures more stable installations.
• Package Source: It primarily fetches libraries from the MicroPython community library on GitHub, which hosts many pre-compiled, optimized packages.
• Dependency Handling: mip can automatically handle dependencies, meaning if a library requires another library to function, mip will install that too. upip could not do this.
• Standardized Installation: It ensures that packages are installed correctly, with all necessary files (__init__.py, etc.) properly placed for seamless imports.

In summary, mip is the modern, more reliable, and feature-rich way to install libraries on your Pico W, and upip is a legacy tool that you should avoid.

For a simple app to just monitor the internal temperature, the Flask application would be relatively simple.

You’d primarily need to set up the communication channels and a basic web page to display the data.

The Backend (Flask)

The Flask side of the application would be the “server” that receives the MQTT messages. You would:

1. Initialize the Flask app and an MQTT client.
2. Define an MQTT callback function that gets triggered whenever a new temperature message arrives from your Pico W.
3. Inside this callback, you would store the most recent temperature value and then broadcast it to any connected web clients using a library like Flask-SocketIO.

This backend script would be continuously running, listening for both MQTT data and requests from web browsers.

The Frontend (HTML/JavaScript)

The frontend is the simple web page that displays the data. You would create a single HTML file with:

1. A heading (e.g., “Pico W Temperature Monitor”).
2. A space (like a <div>) to display the temperature value.
3. A JavaScript script that connects to your Flask server via SocketIO.
4. Once connected, the script would listen for the temperature data broadcast from the server and update the content of the <div> with the new temperature value.

This setup is efficient because it avoids traditional page reloads. Instead, the server pushes new data to the browser as soon as it’s available, creating a real-time, dynamic display.

For recent Home Assistant versions, you configure the MQTT broker through the UI, not in the configuration.yaml file. The broker, port, username, and password options were deprecated for manual YAML configuration.

Here’s the correct two-step process to get everything running:

1. Configure the MQTT Broker in the UI:
   • Go to Settings > Devices & Services.
   • Click the "+ Add Integration" button.
   • Search for and select “MQTT”.
   • A pop-up will guide you to enter the broker’s IP address (192.168.1.11), port (1883), and any credentials you have set.

2. Add the Sensor Configuration to YAML:
   • After the broker is configured, you’ll add the sensor block to your configuration.yaml file. The part you provided is exactly what’s needed.
   • This tells Home Assistant to create a new entity (sensor.pico_w_temperature) that will listen for incoming data from the broker on the specified topic.

After you’ve done both of these steps and restarted Home Assistant, it will automatically connect to your EMQX broker and start listening for the temperature data.

1. Configure the MQTT Broker in the UI

First, you connect Home Assistant to your EMQX broker. This is done entirely through the UI and you should never add the mqtt: broker: details to your YAML file.

2. Add the Sensor Configuration in YAML

This is where you define the entities that listen for data. The error message you received happens when you try to use the old YAML format for the sensor. The correct, modern method is to define the sensor directly under the mqtt: key, like so: 3. Restart Home Assistant

After you save the configuration.yaml file with the correct code, you must restart Home Assistant to apply the changes.

The history integration relies on the recorder integration to actually save the data.

To fix this, you should explicitly enable the recorder in your configuration.yaml file.

How It Works HA to add the MQTT historical temperatura data plot:

1. Card Selection: You’ve correctly chosen the History Graph card. This card is perfect for visualizing time-series data like temperature readings.
2. Configuration: The card’s configuration panel allows you to customize the graph.
   • Title: You’ve given it a title, “Internal T,” which makes it easy to identify on your dashboard.
   • Hours to show: You’ve set the time range to 6 hours, which is good for viewing recent data trends.
   • Entities: This is the most crucial part. You’ve correctly selected Pico W Temperature from the list of available entities. This tells the card to get its data from the sensor you created using the MQTT integration.

Once you click Save, the card will be added to your dashboard and will start plotting the temperature data as it arrives from your Pico W. The “History integration disabled” message you see in the screenshot is a common temporary state; the graph will populate with data as soon as the integration begins collecting it.

Short Answer:

You cannot directly view or retrieve the code that’s already been uploaded to a microcontroller like the Pico W from the Arduino IDE.

Once code is uploaded, it’s compiled into machine code and stored in flash memory — not easily readable or reversible.

Why?

When you upload a sketch to the Pico W through Arduino IDE:

• The human-readable code (.ino) is compiled into a binary format (.uf2, .bin, or similar).
• This binary is uploaded to the Pico W.
• The microcontroller runs that compiled code, but it does not retain the original .ino sketch or any comments.

So, unless you have the original source code saved locally, there’s no official or easy way to recover it from the Pico.

✅ If you just want to know whether there is a sketch on it:

You can check that the board is running something:

• Open the Serial Monitor in Arduino IDE (Ctrl+Shift+M or use the magnifying glass icon).
• Set the correct baud rate (commonly 9600 or 115200).
• Press the reset button on the Pico W and see if anything is printed.

This only helps if the uploaded sketch sends serial output (like using Serial.println()).

🔄 If you want to start fresh:

You can always re-upload your own code. The old code will be overwritten.

Bonus: Using File System (for MicroPython users)

If you were using MicroPython instead of Arduino IDE, and your Pico W was running MicroPython firmware, you could:

• Access the file system using Thonny or rshell.
• Download the main.py or other files from the device.

But since you’re using Arduino IDE, that’s not applicable here.

In Summary:

This boot.py script would have been uploaded to the internal file system of the board.

Let’s break this down and help you check whether this code is still there and how to retrieve or edit it.

✅ Step-by-Step: Check if Your Script is Still on the Pico W

1. Install & Open Thonny

Thonny is the recommended editor for MicroPython on the Pico W.

• Download: https://thonny.org/

• Open Thonny and:

  • Go to Tools > Options > Interpreter

  • Select:

    • MicroPython (Raspberry Pi Pico)
    • The correct port (it often auto-detects)

⚠️ If Thonny says it can’t find the Pico, try holding the BOOTSEL button while plugging in the board, then reflash the MicroPython firmware.

💾 2. Browse the File System

Once connected:

• On the left side of Thonny, you should see:

  • Files on this computer
  • Files on Raspberry Pi Pico

If your script (boot.py) is still there, you’ll see it listed. Double-click to open and view it.

3. What If You Flashed Arduino Code?

If you uploaded an Arduino sketch to the Pico W, the MicroPython firmware would have been overwritten. That means:

• The script is gone.
• The Pico no longer runs MicroPython, so Thonny won’t detect it as a MicroPython device.

To get back to MicroPython:

• Re-flash the MicroPython firmware: This is MicroPython dragnDrop install!

  1. Unplug the Pico W.
  2. Hold the BOOTSEL button and plug it in.
  3. It appears as a USB drive.
  4. Download the .uf2 MicroPython firmware from here.
  5. Drag and drop the .uf2 file onto the Pico’s USB drive.
  6. It will reboot into MicroPython.

Now, you can reconnect using Thonny and upload scripts like boot.py again.

🔐 Bonus Tip: Hide Credentials in Production

Your current script hardcodes the Wi-Fi credentials — that’s fine for testing, but for more security:

• Store them in a separate secrets.py file.
• Or use environment variables if working with more complex setups.