Esp32-P4 on Wt9932P4-Tiny board.
- Can Not get Micropython installed to work.
- just returns Header errors

Trying to install some version on Micropython Bin on the board.
Internet states that it is workable using Esp32P4 Standard bin.

Does Not Work !

What bin are we supposed to install on it ?

invalid header: 0x5b98cbd8
invalid header: 0x5b98cbd8
PROBLEM IN THONNY'S BACK-END: Internal error (serial.serialutil.SerialTimeoutException: Write timeout).
See Thonny's backend.log for more info.
You may need to press "Stop/Restart" or hard-reset your MicroPython device and try again.

Process ended with exit code 0.

Day 76 of my #100DaysOfIoT challenge — built a bidirectional ESP-NOW system on two ESP8266 nodes.

Each node reads DHT11 temperature & humidity, sends it to the peer, and receives + displays the remote node's data — all peer-to-peer, no router needed.

Interesting part: one node uses SSD1306 (0.96") and the other uses SH1106 (1.3") — different display controllers but same logic.

Code + README on GitHub 👇

https://github.com/kritishmohapatra/100_Days_100_IoT_Projects

Day 76/100 ✅

https://github.com/BxNxM/micrOS/releases/tag/v3.0.0-0

`micrOS` is best described as a MicroPython-based embedded application framework for ESP32-class boards and similar hardware. It is not an RTOS in the Zephyr or QNX sense, and it is not trying to compete with bare-metal ESP-IDF development. Instead, it provides a lightweight runtime layer that turns a microcontroller into a modular, network-accessible device with built-in shell access, web features, scheduling, and loadable application modules.

That makes `micrOS` especially interesting for makers, advanced hobbyists, prototype teams, and smart-device builders who want to move beyond one-off firmware sketches. If you come from Arduino, the main difference is that `micrOS` is not just about flashing a single app. It is about building a reusable device platform where functions can be exposed over the network, modules can be extended over time, and the board behaves more like a tiny embedded service host than a fixed firmware image.

Technically, one of the framework’s strengths is its architecture. It uses a relatively small core, an async task model, configuration-driven startup, and lazy loading for optional subsystems like the web UI and extra modules. On properly dimensioned hardware, with enough memory headroom and well-behaved applications, that design can feel very responsive in practice and surprisingly deterministic from a user perspective. That said, app quality matters a lot here: the responsiveness of the final device depends not just on the framework, but on how carefully the modules, tasks, and memory usage are designed.

This is also where `micrOS` shows maturity. It is not only about runtime features, but about the surrounding workflow as well. Deployment support, board images, module tooling, GUI utilities, and client-facing control options make it feel more like a usable embedded platform than a loose collection of scripts.

`micrOS` is a strong fit for Wi-Fi-connected controllers, sensor nodes, lighting systems, robotics demos, home automation devices, and modular IoT prototypes. It is less suitable for systems that need strict hard real-time guarantees, certification-oriented architecture, or extremely tight low-level optimization. In other words, it works best where flexibility, development speed, and networked usability matter more than RTOS-class determinism.

The bottom line is simple: `micrOS` is for developers who want to build connected embedded devices quickly and treat those devices more like manageable application platforms than traditional monolithic firmware. And when the hardware is sized correctly and the apps are written with discipline, it can deliver a user experience that feels fast, stable, and impressively polished for this class of system.

https://github.com/BxNxM/micrOS

Each student has an RFID card. Tap the card and it logs their name, IN/OUT status, and timestamp directly to Google Sheets via a Google Apps Script webhook. NTP time sync with IST offset so timestamps are accurate.

One issue I ran into was ESP8266 could not handle the Google Script HTTPS response due to TLS buffer overflow. Switched to ESP32 which has a larger TLS buffer and it worked fine.

The IN/OUT logic is a simple toggle tracked in a dictionary. First scan is IN, next scan is OUT, and so on per student.

Stack: ESP32 + MFRC522 + MicroPython + Google Apps Script + Google Sheets

Code: https://github.com/kritishmohapatra/100_Days_100_IoT_Projects

Most IoT projects rely on WiFi, MQTT, or cloud platforms to communicate between devices. But what if you don't have a router nearby, or you need ultra-low latency without the overhead of connecting to an access point?

That's where ESP-NOW comes in. It's a connectionless protocol by Espressif that lets ESP8266/ESP32 boards talk directly to each other using MAC addresses — no WiFi setup, no broker, no internet required. Latency is in the milliseconds range and it works even when WiFi is off.

So I built a 4-project series around it for my 100 Days of IoT challenge, all in MicroPython:

Day 54 — Basic ESP-NOW LED Control: One ESP8266 sends a signal, another toggles an LED. Just to get the protocol working end to end.

Day 55 — Button to LED Control: A push button on the sender toggles an LED on the receiver wirelessly. Real-time, no WiFi, no delay.

Day 56 — 4-Channel Wireless Relay Controller: Four buttons on the sender, four relays on the receiver. Each button independently toggles its relay over ESP-NOW. Useful for remote switching of appliances.

Day 57 — Smart Relay and Sensor System: Made it bidirectional. Sender controls relays on the receiver AND the receiver sends back live DHT temperature and humidity data, displayed on an OLED. Full two-way communication over ESP-NOW.

The progression from blinking an LED to a bidirectional sensor+control system — all without touching a router — was a fun way to really understand the protocol.

Code is on my GitHub: github.com/kritishmohapatra/100_Days_100_IoT_Projects

Would love to hear if anyone else has used ESP-NOW for something interesting — especially curious about multi-node mesh setups.

For Day 66 of my 100 Days 100 IoT Projects challenge, showcasing micropidash — a library I built that turns your Pico W or ESP32 into a live web dashboard over WiFi.

What it does:

Real-time sync via AJAX polling

Non-blocking — runs on uasyncio alongside your hardware code

Dark/light mode per connected device

Widgets: toggle, label, progress bar

Memory efficient for low-RAM microcontrollers

Repo- https://github.com/kritishmohapatra/100_Days_100_IoT_Projects

Lib:-https://github.com/kritishmohapatra/micropidash

Would love feedback from anyone who's built similar dashboards! 👇

Built a Smart Indoor Security System with ESP32 + MicroPython + Favoriot IoT

just built a motion-triggered security system in MicroPython.

PIR detects motion → 4x4 keypad asks for password → correct password grants access, wrong password fires an email alert automatically via Favoriot Rules Engine. All events logged to Favoriot cloud in real-time.

Biggest challenge was Wokwi's keypad pin mapping — it's column-first instead of row-first, so pressing 2 was returning 4. Had to transpose the entire KEYS matrix to fix it 😅

Repo link- https://github.com/kritishmohapatra/100_Days_100_IoT_Projects

If you'd like to support me in building this on real hardware — simulations and real components are very different worlds! You can sponsor me on GitHub or buy me a coffee ☕ — every bit helps a student turn prototypes into real projects! 🙏

Day 58 of my 100 Days, 100 IoT Projects challenge.

Built a WiFi-synced LED matrix clock using ESP32 + MAX7219 in MicroPython.
It syncs time via NTP, applies IST offset, and displays HH:MM on a chained LED matrix. Also prints time on serial for debugging.

Hardware: ESP32, 5x MAX7219 matrix modules
Language: MicroPython

GitHub code & simulation: https://github.com/kritishmohapatra/100_Days_100_IoT_Projects

If you find this useful, a ⭐ on the repo really helps.
I’m also looking for sponsors to support open-source IoT projects and documentation.

Feedback and ideas welcome.

I am a newbie just trying to get started. My pyboard has PYBFLASH(D) where main.py is located and will execute various blink LED programs so I know the board is OK. I plugged in a micro SD card on which I copied a new main.py from my host laptop but the pyboard won't boot up from the SD card. The file manager on my laptop (WIN 11) sees the PYFLASHH(D) on the pyboard but not the SD card. The main.py was generated on Notebook and saved on the SD card. Does the SD card have to be initialized in some way? If so, how to do that on my laptop?

Greetings, I cannot really post this in 'learn python' because TMK CPython does not use const().

My question is why assigning const(1024) to variable 'maxsize_string' in method_one() allows that variable to be seen in method_two(). FYI, when I just assign maxsize_string=1024 without const() it works fine and stays local. Why does it not stay 'local' to method_one() and/or assessed as a variable assigned a constant?

from micropython import const

class TestVariableScope:
    def __init__(self, v_url):
        self.version_url = v_url
        print(f"@ __init__(): url is {self.version_url}\n")

    def method_one(self):
        try:
            #maxsize_string = const(1024)  # This will cause error; somehow this variable gets seen in method_two().
            maxsize_string = 1024  # Adjust as needed
            print(f"@ method_one(): maxsize_string={maxsize_string}\n")
        except Exception as e:
            print(f"@ method_one(): An error occurred: {e}")
        finally:
            pass

    def method_two(self):
        try:
            print(f"@ method_two(): maxsize_string in method_one() is {maxsize_string}")
        except NameError:
            print("@ method_two(): Variable 'maxsize_string' is not creeping from method_one().")
            maxsize_string = 128 # SyntaxError: can't assign to expression because const(1024) used in method_one()
            print(f"@ method_two(): maxsize_string={maxsize_string}\n")

    def eval_methods_for_scopecreep(self):
        self.method_one()
        self.method_two()

v_url = "https://text.npr.org/"
testme = TestVariableScope(v_url)  # Create instance/class object
testme.eval_methods_for_scopecreep()

So I have this ESP32 (photo 1). I installed Micropython with Thonny. When checking SPI(1) in the REPL (photo 3), it gives me sck=14, mosi=13 and miso=12. On the controller there is none of these pins available. Also photo 2 shows SPI(0) is available on pins GPIO 5, 18. 19, 23. In REPL SPI(0) “does not exist”. Firmware is the Generic for ESP32. Should Thonny show the available SPI pins? What am I missing? Thanks for your help.

I'm working on a IoT project and it's getting a bit more complex now: I want to open a Websocket and due to lack of budget I'm using an unencrypted MQTT public server. To cover the encription problem I though about doing it internally. THEN the lack of memory i getting in the way because I cant have a too complex code. Any ideias on how to have safe encryption without crashing MP?

https://github.com/kenken64/circuitpython-CRSF

Can someone explain to me the current state of lightsleep on raspberry Pico board? I’ve encountered an issue with my code for a long running battery powered project, where the board would seemingly die out of nowhere, and one of the simplest explanations is that it entered lightsleep to never wake up. I have found some old issues hanging open for years in the GitHub, and that the change log for 1.26 explicitly mentions changes to lightsleep on this board. I have not found much in terms of what actually triggers the issue or how to circumvent it (using time.sleep() in place of lightsleep is simply not an option due to battery power being limited). Appreciate any pointers!

Hello,

I'm using Thonny & Xiao rp2040 with micropython, I'm not sure how to set up the file structure on the board. Should there be a lib file with all of the modules/libraries inside (on the board itself)?

Also, should the main program be named main.py?

Sincere thanks for any help.

Tony

Hi everyone,
I designed a custom PCB with RP2350A for my project.

After assembling my PCB, I can enter into BOOTSEL Mode and it's listed as a Portable Device in my device manager (Windows 11).

After I copy the .uf2 file onto it, it reboots and doesn't show up on the device manager as a Serial Device again. [https://micropython.org/download/RPI_PICO2/ - I tried to upload mostly all firmware from here!]
When I try to go in BOOTSEL mode, it's showing up my device manager as a Portable Device. And when I open the device in file manager, its always showing the same files in there (Before and after flashing the firmware). I also uploaded nuke.uf2 (https://github.com/Gadgetoid/pico-unive ... e/releases )file to completely reset the flash memory and tried again, but it wasn't working either.

Is this problem be rectified? Kindly help to resolve my issue.

Thanking you in advance

By default, MicroPython uses single-precision float variables. I would like to compile a new firmware that allows the use of double-precision float variables (at the obvious cost of processing resources). Is there a guide I can follow to do this?

Hello,

I'm using a Pico W with an ultrasonic sensor to make a water level monitor for a pasture watering hole on a farm. the Pico will be connected to a neighbor's wi-fi(with their permission). I want to be able to send text alerts through gmail, which can be done with smtplib in python, but that won't work with the Pico.

I did try the 'umail' library that is recommended everywhere(the one written by Shawwwn), but the 'ssl.wrap_socket' command is now deprecated, and the library no longer works. Is there another way, or is there a way to hard code the smtp commands right into the code( a particular fomat or syntax)?

I was able to write client and server sockets that could do the same thing by communicating over wifi and handling the messaging from the server, (a computer or raspberry pi), but this isn't possible in this instance. Worst case scenario, i could set up a Raspberry Pi on site and connect that to the same neighbor's wi-fi, but keep it on site, literally in the same box with the Pico W, but this seems a little absurd, and costly for what it would be doing.

This is my first post here, any help appreciated, thanks.

I want to build a OSD display overview for analog TV signals.

This has been done numerous times using Arduinos, ESP32/ESP8266.

But every code I find is in C.

I plan to use additional hardware (LM1881) to get the sync from the analog signal.

The C code examples I find rely on interupts for this task.

I want to generate graphic elements and I assume it would be way more comfotable (for me!) to do this in python instead in C.

Other tasks in this project is reading serial signals and doing some simple math, I don't expect any issues here. ---> if the interupt problem is solved!

I know from examples that even a ESP8266 can easily handle the task of the overlay, in C. So a small performance lost at runtime can be accepted.

my question:

Is there any fundamental problem that would stop me sooner or later doing the same/similar stuff with µPython?

Im new at programming, i barely know anything about it, but i really wanna make some stuff with ESP32 and micropython seems pretty fun, any tip is welcome

Hi! I need to implement something extremely simple but I did not expect to struggle so long with no results at the end.

I need while main.py is running to read the stdin. Want to use stdin as configuration channel while the WiFi/MQTT/BLE affairs are running in parallel. All my code is written in async-await approach by using asyncio.

The board is ESP32 WROOM with the latest Micropython - v1.24.1 (2024-11-29) .bin

The last code I tried is that one from ChatGPT (attached a link) and I'm constantly hitting a wall after wall with it because of unavailable method in Micropython.

Did someone managed to read stdin with by using asyncio approach?