In this new episode of Build, Create & Learn – A Maker’s Journey, I take the next step into the world of Embedded Linux: writing, debugging, and cross-compiling my very first character driver.   After my initial “Hello Kernel” experiment, I wanted to go deeper — to understand how real drivers work, how they register with the kernel, and how data travels between user space and kernel space. Along the way, I learned the hard way how to debug without crashing the system, and how to cross-compile a kernel module from my Ubuntu machine to a Raspberry Pi.   This episode is about more than just code — it’s about exploring the invisible layers that make Linux so powerful, and why knowing what happens beneath the surface gives every maker a new kind of confidence.   Thanks for listening, and don’t forget to check out the companion article at https://herndlbauer.com/blog/a-makers-journey-podcast-episode-9/ — it includes the full source code and more details from my journey into the kernel.

In this season premiere of Build, Create & Learn – A Maker’s Journey, I begin a brand-new adventure: diving into Embedded Linux and Kernel Driver Development.   After years of working with microcontrollers and maker projects, I wanted to understand what really happens under the hood — how Linux talks to hardware, what lives inside the kernel, and why that matters for anyone building modern embedded systems.   I share how I set up a dedicated Linux environment, wrote my first “Hello Kernel” module, and what I learned along the way about the invisible bridge between user space and kernel space. It’s the start of a deeper exploration into the layers that make our devices tick — from bootloaders to drivers and everything in between.   Thanks for tuning in to this new season. Here’s to more building, creating, and learning — this time, inside the Linux kernel!

In this season finale of Build, Create & Learn – A Maker’s Journey, I look back on my FPV drone telemetry project and what it taught me. From frustrating SD card issues and wiring mishaps to the breakthrough of logging my first GPS data, this season has been a mix of struggles, pivots, and small wins. I also share behind-the-scenes insights about starting this podcast, balancing projects with a full-time job, and why documenting the journey helped me stay consistent. Finally, I tease what might be coming in Season 2 — new projects, new formats, and fresh challenges. Thanks for joining me on this first season. Here’s to more building, creating, and learning ahead!

This week on Build, Create & Learn – A Maker’s Journey, I took a big step forward: moving my drone telemetry logger off the breadboard and into a real enclosure. It wasn’t smooth sailing. Desoldering headers damaged some pads, wiring bugs kept piling up, and I spent hours chasing errors from the SD card, BME280, and GPS module. But after rerouting pins and rewriting code, I finally got the system logging properly again. The real payoff? A short car test drive that produced my first dataset — GPS coordinates, speed, and altitude — all saved to the SD card. I visualized the track in JupyterLabs with Folium and GPX Studio, and it was incredibly satisfying to see the results line up with reality. What you’ll hear in this episode: Why moving from breadboard to wires is never as easy as it looks The lessons I learned from desoldering headers and torn pads Debugging SD card, BME280, and GPS issues one by one Designing and 3D printing my first enclosure box Logging real data on a short test drive (instead of a flight) Visualizing GPS tracks and speed data in Jupyter Next steps: battery indicators, antennas, and the first drone flight This episode is about more than just wiring and code — it’s about perseverance, learning from mistakes, and celebrating the moment when raw numbers turn into meaningful data. 🎧 Listen now and let’s keep building, creating, and learning — together!

This week on Build, Create & Learn – A Maker’s Journey, I finally put the Adafruit Feather RP2040 and CircuitPython to the test — and the results were a huge step forward for my drone telemetry project.   After weeks of SD card frustration on STM32, I’m relieved to say: the new setup just works. From a simple blinky app to logging environmental data and GPS coordinates straight to a microSD card, I now have the first version of a working telemetry logger. And with my mechanical engineering hat back on, I’ve also started sketching and 3D printing ideas for the enclosure that will carry it into a real drone flight.   What you’ll hear in this episode: Setting up the Adafruit Feather RP2040 with CircuitPython Running the first “blinky” and rainbow LED examples Reading environmental data with the BME280 sensor Finally getting reliable SD card logging with sdcardio Adding GPS data to the logger with Adafruit’s GPS library Why I chose not to solder everything down yet — a maker’s choice Starting the design process for a flight-ready enclosure It’s the most complete version of the telemetry system so far, and it feels amazing to see the pieces finally coming together.   Companion blog article: https://herndlbauer.com/blog/a-makers-journey-podcast-episode-5/   🎧 Listen now and let’s keep building, creating, and learning – together!

This week on Build, Create & Learn – A Maker’s Journey, I hit a wall with my STM32 drone telemetry project. My GPS parser worked beautifully, but the SD card shield? Not so much. After days of debugging SPI conflicts, wiring quirks, and endless C/C++ frustration, I had to face a tough question: keep grinding, or pivot to a tool that actually fits my maker workflow?   In this episode, I share the full story of why I’m switching from STM32 and C to CircuitPython on the RP2040 for my drone telemetry logger. We’ll talk about NMEA strings (RMC & GGA), testing external GPS antennas, and the lessons I learned from failing at SD card logging. More importantly, I’ll reflect on the maker’s mindset: knowing when to push through and when to change tools so you can keep learning, building, and actually finish projects.   What you’ll hear in this episode: How I parsed GPS NMEA data (RMC & GGA) and added a motion filter Why my STM32 + SD card shield setup refused to cooperate The moment I realized C wasn’t helping me move forward Why CircuitPython + RP2040 is the better fit for my telemetry project My next steps: reconnecting sensors, logging to SD, and moving toward a flight-ready prototype Listen now and let's keep building, creating, and learning – together!

Ever wish you could ditch that annoying USB cable while working on your microcontrollers? In this episode, I share how I finally untethered my embedded development board using a Raspberry Pi – a real game-changer for my workflow! Then, we dive into the exciting world of GPS for my FPV drone telemetry system. Join me as I recount the struggles (C++ library headaches and mysterious scrambled data) and the triumphs of getting the MTK3339 GPS sensor talking to my STM32. You'll hear about the detective work to find the right pins, the debugging breakthroughs, and the sheer excitement of finally getting a solid satellite fix. It's an honest look at the real-world challenges and rewarding "aha!" moments of building complex systems. Tune in to hear the full story and what's next for our drone telemetry project! In this episode, you'll discover: My new wireless embedded programming setup The unexpected hurdles of integrating the MTK3339 GPS sensor My debugging journey to finally get clean NMEA data. The thrill of achieving a satellite fix and verifying my location A sneak peek at future plans for better accuracy and data logging. Listen now and let's keep building, creating, and learning – together!  

Welcome back to Build, Create & Learn — A Maker’s Journey! In this episode, I’m taking you along on my early adventures with embedded programming using the STM32 microcontroller. From that first blinking LED to the moment I finally got sensor data from the BME280, it’s been a ride full of bugs, head-scratching errors, and small wins that felt huge.   I’ll walk you through: How I got started with STM32 and why I chose it The common mistakes that slowed me down Wiring up and reading from the BME280 sensor What I’ve learned (and what I still don’t understand) If you’re curious about embedded development or just enjoy the learning journey behind the scenes, this one’s for you. Whether you’re a beginner or someone looking back at their first “blinky” project, I hope you find something relatable in the process. Check out the companion blog post for links, images, and the source code: herndlbauer.com

In this first episode of "Build, Create & Learn: A Maker's Journey", join Stefan as he dives into building a custom FPV drone telemetry system from scratch. From STM32 boards and LoRa radios to ‘what did I get myself into?’ moments — it’s an honest look at a maker’s journey: learning by doing, celebrating small wins, and proving you can build what you imaged. Let's start the journey together!