#MicroPython
New! Art Matrix 🖼️

16,384 RGB pixels in a black aluminium frame, with 45(!) plugins you control from your phone: algorithmic art, retro screensavers, live info and loads more.

No coding needed (but it’s all MicroPython if you fancy it).

Out now 👉 shop.pimoroni.com/products/artmatrix
November 17, 2026 at 4:22 PM
Arduino recently supporting MicroPython is such a crazy thing
November 18, 2026 at 11:30 AM
If only you could run DOOM on your @pimoroni.com Tufty 2350 without losing MicroPython... 🤔
November 15, 2026 at 3:59 PM
The beginnings of youngest son’s bed side light. Using a @pimoroni.com plasma 2040 I had lying around #micropython

Just using one LED while I program.
November 15, 2026 at 8:13 PM
Pimoroni's Art Matrix is a smart display built from a pair of RGB LED matrices totaling an impressive 16,384 pixels, powered by a Raspberry Pi RP2350.
Pimoroni's MicroPython-Powered Art Matrix Puts an RP2350 in Conrol of 16,384 LEDs
Firmware comes with 45 plugins at launch, including browser-based drawing and dashboards with optional sensor data.
www.hackster.io
November 18, 2026 at 1:58 PM
31-39 tokens/s for Qwen3.5-9B on a base PS4 GPU, per the README, and the console runs the MicroPython it writes
November 15, 2026 at 7:42 PM
I've made this thing called ThingStudio. It's sort of the love child of Node-RED and MicroPython. Runs on most things that run MicroPython.
Fully local, no account, no cloud, no tracking. Apache 2.0. I could use some folks to give it a try so I can see the […]

[Original post on gts.minus1.com]
November 13, 2026 at 5:06 PM
Módulo de reconhecimento visual K210 com câmera de 2MP para inteligência artificial Aprendizagem profunda com…
🔥 DE R$356,43 | POR R$208,18

🛒 Compre aqui: https://botvaro.com/l/zMUOB4j5?src=bs

⭐⭐⭐⭐☆ 3,5
🏪 Vendido por AliExpress
🔥 42% OFF
Preço bom desse jeito não é sempre 👀

👉 lupagrupos.com
Módulo de reconhecimento visual K210 com câmera de 2MP para inteligência artificial Aprendizagem profunda com suporte para porta serial MicroPython
AliExpress · R$208,18
botvaro.com
November 18, 2026 at 5:15 PM
Anthropic added the whimsical idea of a Claude Buddy, an IOT device that acts as a status display for Claude Code.

I ported CodePuter's MicroPython to the M5Stack Core2 device so that it could act as a Claude Code Buddy.

#hardwarebuddy #anthropic #claudecode #m5stack

youtube.com/shorts/FR_GP...
Claude Hardware Buddy M5Stack Core 2 Claude Code Demo
YouTube video by Joe Freeman: Software Craft, Org Stuff, Tech Stuff
youtube.com
November 13, 2026 at 1:19 PM
Auf der Hinfahrt im ICE habe ich einen Tacho für mein rundes CrowPanel programmiert, um die Geschwindigkeit des Zuges anzuzeigen. Auf der Rückfahrt wollte ich mit demselben ESP32-Display etwas ganz anderes machen.
https://bit.ly/48InC5f
Ball Bouncer nachbauen – ein ESP32-Spiel mit MicroPython auf dem CrowPanel
Auf der Hinfahrt im ICE habe ich einen Tacho für mein rundes CrowPanel programmiert, um die Geschwindigkeit des Zuges anzuzeigen. Auf der Rückfahrt wollte ich
bit.ly
November 17, 2026 at 3:50 PM
Yahboom K210 Módulo de reconhecimento visual CanMv para inteligência artificial Aprendizagem profunda com suporte para…
💰 Por apenas R$330,51

🛒 Compre aqui: https://botvaro.com/l/p5IZqH?src=bs

⭐⭐⭐⭐⭐ 5,0
🏪 Vendido por AliExpress
🔥 0% OFF
Confira os detalhes clicando abaixo 🛍️

👉 lupagrupos.com
Yahboom K210 Módulo de reconhecimento visual CanMv para inteligência artificial Aprendizagem profunda com suporte para porta serial MicroPython
AliExpress · R$330,51
botvaro.com
November 16, 2026 at 4:10 AM
last year I wrote most of the code for this ephemeris that can track planets in real-time as well as fast-forward & rewind, calculated offline from JPL de440 data with corrections applied for my location. it's all in micropython on the clockwork picocalc.
November 17, 2026 at 3:11 PM
I've been trying out a 10.1 inch 800x1280 display with an #ESP32 P4 and using it's accelerated features with #micropython. The final scene is cheating because it uses a natmod.
November 9, 2026 at 11:43 AM
DIY project descriptions for building long range sensor networks with the M5Stack C6L LoRa+WiFi radio: www.hackster.io/etolocka/bui...
www.hackster.io/colonelpanic...
www.hackster.io/etolocka/our...
Cheap hardware and integrated visual/Micropython programming support.
November 8, 2026 at 3:14 PM
Show HN: ThingStudio, Node-RED style programming for microcontrollers
Discussion | hackernews | Author: mkarliner

#EmbeddedElectronics
Show HN: ThingStudio, Node-RED style programming for microcontrollers
Node-RED-style flows for ESP32, Pico, nRF52840 and STM32 boards, compiled to MicroPython and run on the board itself. Beta, open source, testers wanted.
thingstudio.net
November 11, 2026 at 2:22 PM
Módulo de reconhecimento visual K210 com câmera de 2MP para inteligência artificial Aprendizagem profunda com suporte…
💰 De R$339,90
🔥 por R$198,53 🔥

🛒 Compre aqui: https://botvaro.com/l/TPzb5Z6H?src=bs

⭐⭐⭐⭐☆ 3,5
🏪 Vendido por AliExpress
🔥 42% OFF
Essa vale muito a pena 😱

👉 lupagrupos.com
Módulo de reconhecimento visual K210 com câmera de 2MP para inteligência artificial Aprendizagem profunda com suporte para porta serial MicroPython
AliExpress · R$198,53
botvaro.com
November 11, 2026 at 2:54 PM
Morse Code on a Raspberry Pi Pico: Build a Hardware Keyer with MicroPython
# Morse Code on a Raspberry Pi Pico: Build a Hardware Keyer with MicroPython The Raspberry Pi Pico costs about the price of a coffee, runs Python, and has more than enough GPIO to key a transmitter, drive a buzzer, and decode what you send — all at the same time. If you have ever wanted a Morse practice station that is a real piece of hardware rather than a browser tab, this is the cheapest honest way to build one. In this article we will wire a straight key (or a push button) to a Pico, write a small MicroPython keyer, and end up with a device that beeps, flashes, and prints the text you keyed to your computer over USB. No radio licence is needed for any of this: nothing here transmits. It is a practice keyer, a decoder, and a surprisingly good way to learn how Morse timing actually works. ## What you need * A Raspberry Pi Pico (any Pico, including Pico W) with MicroPython installed * A momentary push button or a real straight key — a button is fine for learning * A passive buzzer (or a small speaker) and a 220 ohm resistor * A breadboard and a few jumper wires * A USB cable and Thonny (or any serial terminal) Total cost, excluding the Pico, is under two dollars. The wiring is deliberately minimal: one input pin for the key, one output pin for the buzzer, and the Pico's built-in LED as a visual sidetone. ## Wiring it up The circuit has three connections: * **Key input — GP14.** One side of the button goes to GP14, the other side to ground. We will enable the Pico's internal pull-up resistor, so the pin reads high when the key is up and low when it is pressed. * **Buzzer — GP15.** The buzzer's positive lead goes to GP15 through a 220 ohm resistor, the negative lead to ground. We drive it with PWM so we can pick a pleasant sidetone frequency. * **Visual sidetone — GP25.** This is the Pico's on-board LED, already wired for us. That is the whole circuit. If you are using a real straight key instead of a button, the wiring is identical: the key is just a switch that connects GP14 to ground when pressed. ## The timing rules, in code Morse timing is defined in units. At a given speed in words per minute (WPM), one unit lasts `1200 / WPM` milliseconds — the PARIS standard, the same rule every decoder uses. A dit is 1 unit, a dah is 3 units, the gap inside a character is 1 unit, the gap between characters is 3 units, and the gap between words is 7 units. At 15 WPM, one unit is 80 ms. That is fast enough to feel musical and slow enough to learn on, so we will use 15 WPM as the default. The decoder classifies a mark as a dit when it is shorter than 2 units and a dah when it is longer — the midpoint rule, which is forgiving of human unevenness. Here is the full keyer. Save it as `main.py` on the Pico so it runs on power-up: from machine import Pin, PWM import time WPM = 15 UNIT = 1200 // WPM # milliseconds per dit at this speed key = Pin(14, Pin.IN, Pin.PULL_UP) led = Pin(25, Pin.OUT) buzzer = PWM(Pin(15)) buzzer.freq(600) # a comfortable sidetone pitch buzzer.duty_u16(0) MORSE = { '.-': 'A', '-...': 'B', '-.-.': 'C', '-..': 'D', '.': 'E', '..-.': 'F', '--.': 'G', '....': 'H', '..': 'I', '.---': 'J', '-.-': 'K', '.-..': 'L', '--': 'M', '-.': 'N', '---': 'O', '.--.': 'P', '--.-': 'Q', '.-.': 'R', '...': 'S', '-': 'T', '..-': 'U', '...-': 'V', '.--': 'W', '-..-': 'X', '-.--': 'Y', '--..': 'Z', '.----': '1', '..---': '2', '...--': '3', '....-': '4', '.....': '5', '-....': '6', '--...': '7', '---..': '8', '----.': '9', '-----': '0', } def sidetone(on): buzzer.duty_u16(20000 if on else 0) led.value(1 if on else 0) def decode(symbols): return MORSE.get(symbols, '?') def main(): print("Pico keyer ready. Key at", WPM, "WPM.") symbols = '' while True: # Wait for the key to go down while key.value() == 1: time.sleep_ms(5) mark_start = time.ticks_ms() sidetone(True) # Wait for the key to come up while key.value() == 0: time.sleep_ms(5) mark_ms = time.ticks_diff(time.ticks_ms(), mark_start) sidetone(False) symbols += '.' if mark_ms < 2 * UNIT else '-' # Measure the gap after the mark gap_start = time.ticks_ms() while key.value() == 1: gap_ms = time.ticks_diff(time.ticks_ms(), gap_start) if gap_ms >= 7 * UNIT: # Word gap: flush the character, then a space print(decode(symbols), end='') print(' ', end='') symbols = '' break if gap_ms >= 3 * UNIT: # Character gap: flush the character print(decode(symbols), end='') symbols = '' break time.sleep_ms(5) main() Key what you like in Thonny's serial monitor and the decoded text appears as you send it. The two thresholds do all the work: marks are classified the moment the key comes up, and gaps are classified while you wait for the next press. ## Why polling works — and when to switch to interrupts The loop above polls the key every 5 ms. At 15 WPM a dit lasts 80 ms, so polling catches every press with at least 16 samples to spare, and the timing error is bounded by the 5 ms sleep — small enough that nobody's sending is that precise anyway. Polling is the right choice for a first version because the whole program fits in one readable loop. If you later want to send faster, or add a second paddle for iambic keying, switch the key input to an interrupt: def on_key_change(pin): now = time.ticks_ms() if pin.value() == 0: # key down: record the time, start the sidetone pass else: # key up: classify the mark from the elapsed time pass key.irq(trigger=Pin.IRQ_FALLING | Pin.IRQ_RISING, handler=on_key_change) Interrupts free the main loop to do other work — updating a display, logging to a file, or driving a second buzzer — while the timing stays exact. But do not start there. Get the polling version working first, then refactor; a keyer you can hear is worth more than an elegant one you have not finished. ## Adding a practice mode A keyer that only echoes what you send is half a practice tool. The other half is a trainer that sends to you. Add a simple practice mode that plays a random character every few seconds and waits for you to key it back: import random def play(symbols, unit=UNIT): for s in symbols: sidetone(True) time.sleep_ms(unit if s == '.' else 3 * unit) sidetone(False) time.sleep_ms(unit) def practice_round(): ch = random.choice(list(MORSE.values())) code = [k for k, v in MORSE.items() if v == ch][0] print("Listen...", end=' ') play(code) print("now key it back!") Call `practice_round()` in a loop and you have a trainer that costs nothing extra: the same buzzer, the same LED, the same key. Start with the letters E, T, I, M, A and N — the six shortest codes — and add a new letter only when you can copy the current set without thinking. This is the Koch method in miniature, and it works because it trains your ear before your memory. ## Five mistakes that make a Pico keyer feel broken 1. **No pull-up resistor.** If GP14 floats, the pin reads random noise and the keyer decodes phantom dits. The internal pull-up in the code above fixes this — but only if you actually pass `Pin.PULL_UP`. 2. **A buzzer with no resistor.** A passive buzzer straight across a GPIO pin can draw more current than the pin likes. The 220 ohm resistor costs nothing and protects the Pico. 3. **Debounce done wrong.** Mechanical keys bounce: one press looks like several short presses. The 5 ms polling loop smooths most of it, but if you see stray dits, add a 10–15 ms settle delay after each key-down edge before you start timing. 4. **Timing against the wrong clock.** Use `time.ticks_ms()` and `time.ticks_diff()`, never `time.time()`. The ticks functions handle the millisecond counter wrapping around; naive subtraction breaks after the counter overflows. 5. **A sidetone that is too loud or too quiet.** PWM duty of 20000 out of 65535 is a good middle ground. If the buzzer screams, lower the duty; if you can barely hear it, raise it. The frequency matters too — 600 Hz is comfortable for long sessions, while 800 Hz cuts through room noise better. ## What this teaches you that a browser app cannot A browser trainer hides the timing from you. A Pico keyer makes it physical: you feel the 80 ms dit in your fingertip, you hear the gap between characters as silence, and you discover quickly that your dahs are shorter than you think they are. That feedback loop — send, hear, see the decoded text, correct — is the fastest way to build the timing sense that separates a readable sender from a sloppy one. And the same code scales. Swap the button for a real key, swap the buzzer for an audio oscillator, add a small OLED display, and you have a field practice station that runs for days on a USB power bank. The decoder logic never changes: classify the mark, classify the gap, flush the character. Everything else is hardware you can add one piece at a time. ## Frequently asked questions **Do I need a real Morse key, or is a button enough?** A button is enough to learn on. A straight key feels better and teaches proper wrist motion, but the electronics and the code are identical either way. **Can the Pico key a real transmitter?** Yes, with an interface circuit — never connect a transmitter directly to a GPIO pin. A transistor or optocoupler between GP15 and the radio's key input is the standard approach, and it keeps your Pico safe from RF and voltage spikes. **Why 15 WPM and not slower?** Slower speeds feel easier but teach bad habits: at 5 WPM people count dits and dahs instead of hearing whole characters. Fifteen WPM is slow enough to learn on and fast enough that characters arrive as single sounds. **Can I save my practice sessions?** Yes — open the Pico's filesystem in Thonny and append decoded text to a file, or log it over USB serial from your computer. A week's worth of sessions fits in a few kilobytes. **What if my decoded text is full of question marks?** Your marks are landing near the 2-unit boundary, so the classifier is guessing. Slow down slightly, or lengthen your dahs deliberately for a few sessions until the rhythm settles. _Morse Zone (morsezone.com) is a free online Morse code translator with audio playback and learning tools — a handy reference for checking your Pico keyer's decoded output against known-good text._
dev.to
November 9, 2026 at 6:38 AM
Having fun with #MicroPython on an @seeedstudio.com reTerminal Sticky, in preparation for #PyConES2026 @es.pycon.org!
November 5, 2026 at 6:45 PM
I use both. It really depends what language you're most comfortable with.

You can use both with the Arduino IDE/C++

And both with MicroPython although I've never used the ESP32 Python environment. This is really Pi Pico territory.

Performance isn't an issue here so Python is fine.
November 7, 2026 at 10:58 AM
Implementing PWM with Raspberry Pi Pico using MicroPython

Today, we will Implement PWM with Raspberry Pi Pico using MicroPython, we will control the brightness of LEDs using pulse width…

https://www.theengineeringprojects.com/2022/05/implementing-pwm-with-raspberry-pi-pico-using-micropython.html
Implementing PWM with Raspberry Pi Pico using MicroPython
Today, we will Implement PWM with Raspberry Pi Pico using MicroPython, we will control the brightness of LEDs using pulse width modulation.
www.theengineeringprojects.com
November 6, 2026 at 6:08 AM