2007 vs 2026: A PIC IR Receiver, Built with AI

A few weeks ago, during a visit from Microchip, we were shown the different microcontroller options Microchip currently offers. In my case, I hadn't integrated a PIC into a design in many years, having preferred other microcontroller families instead — but after seeing the direction they've taken, I decided to give current PICs a try.

In this blog post we'll look at the tools available today to get started with PIC microcontrollers, and we'll compare that with what it was like to start with them 20 years ago — by repeating a project I did with a PIC back in 2007: an infrared receiver to read a remote control.

The 2000s.

In Spain, I'd say PIC microcontrollers were by far the most widely used in the 2000s — Microchip's sales team did a great job back then. In schools, if you were lucky enough to see a microcontroller at all, it was almost certainly going to be an 8-bit PIC. Others of us had to settle for seeing microprocessors like the Motorola 68000 and trying to learn about microcontrollers with the scarce resources available at the time.

The usual way to learn back then was: manufacturer documentation, application notes, specialized internet forums where you could ask and answer questions, and if you were lucky, a good book. If you wanted to learn, it meant many hours of searching online, reading, and trial and error on your own. There wasn't the endless supply of resources we have now — YouTube channels, code repositories, AI, and the many learning platforms offering all kinds of courses.

A fantastic book about 8-bit PIC microcontrollers was "Microcontrolador PIC16F84: Desarrollo de proyectos" ("PIC16F84 Microcontroller: Project Development"), published by Ra-Ma in 2004 — the book many of us used to take our first steps into the world of microcontrollers.

A first electronics prototype with a microcontroller, before the era of Arduino, STM32 Nucleo boards, ESP32s and so on,cheap Chinese PCBs, and the countless evaluation/prototyping boards and plug-in modules available today, usually looked like this:

There were also the typical microcontroller evaluation boards back then, but they were expensive and fairly limited when it came to adapting them to any given project, so it was common to build a quick prototype like the one shown above, or to make it on a single-sided PCB using UV exposure and acid etching.

I'm leaving a link to the 2007 infrared receiver project shown in the image above, recovered from an old hard drive — the one we're going to replicate in this post using current Microchip PICs and tools.

To do something as simple as this: press the "+" button on a JVC remote control, have the PIC microcontroller receive the value "197" and "120" that this remote sends when that button is pressed, and display it on an LCD screen — well, you could easily spend several weeks on it if it was the first time you'd ever used a microcontroller and had no prior experience.

Learning how the microcontroller worked, its architecture, its assembly language (Microchip's C compiler wasn't free at the time), reading datasheets and application notes to integrate the hardware, asking questions on specialized forums whenever you got stuck and couldn't find the answer (and there was always someone experienced willing to help beginners). Sometimes you'd even shed a tear of joy, after days and days, when you finally got the project working the way you wanted.

It has nothing to do with the time — or the effort — it took now to replicate the project: getting a PIC microcontroller we'd never seen or used before, connected to an IR receiver, to display the values "197" and "120" on an LCD when we press the "+" button on that same JVC remote (which I still have).

Thanks to AI, we've gone from needing weeks of learning and testing to complete this exercise, to just a few hours in a single afternoon — without having to build, search for, or read absolutely anything. You no longer shed a tear of joy when you get it working… Though if it doesn't work on the first try, you can at least complain to the AI!!!

My relationship with PICs didn't last more than a year or two, until I started using Atmel microcontrollers, with their free C compiler and — to my taste — better architecture, and for a long time now it's mostly been ARM and ESP32.

PIC Microcontrollers in 2026.

Hardware.

If we want to evaluate Microchip's current microcontrollers, a good option is to use the evaluation boards within their "Curiosity Nano Development Platform."

Curiosity Nano boards are small boards that pack in: a microcontroller, a USB connector with the debugger needed to program and debug that microcontroller right on the board itself, an LED, a push-button, and the microcontroller's pins broken out through headers — all for under 10 euros. There are different versions of these boards for many of Microchip's microcontroller families.

For this post we're using a PIC32CM PL10 Curiosity Nano board. It's built around a PIC32CM6408PL10048, an Arm Cortex-M0+ launched in early 2026, with 64KB of Flash and 8KB of RAM (we had 368 bytes of RAM on the microcontroller used back in 2007).

This board could be used entirely on its own to evaluate the PIC — the pin headers press-fit into place (no soldering required), and you could wire it up to whatever electronics you want, either by making a small PCB or using prototyping boards.

An even better option for evaluating the microcontroller is to get a Curiosity Nano Explorer, which lets you plug the aforementioned Curiosity Nano boards into it, connecting them to the various circuits the Explorer carries — and it can also be extended with dozens of add-on modules that provide new functionality.

The Curiosity Nano Explorer already includes an LCD, so all we need to add is an IR receiver, which we connect to two power pins on the Nano Explorer and wire up to one pin of the microcontroller — and that's everything needed to reproduce the infrared remote receiver project.

Development Environment.

To develop the microcontroller's firmware we're going to use VS Code plus Microchip's extensions: MPLAB and MPLAB AI Coding Assistant (I'll use Claude instead).

The fact that Microchip, like other manufacturers, has bet on VS Code to program its microcontrollers is a smart move. We install Microchip's extensions in VS Code along with the XC32 compiler, and within a few minutes we have everything we need to work with PIC microcontrollers, in an environment we're already used to.

Application note AN6368 covers everything needed to create a first application for the PIC in VS Code — it's the only documentation I had to consult at all (everything else, the AI handled).

Once the project is created, the environment looks like the image below (click to enlarge), with four distinct zones:

Zone 1 in the image. Device Resources: this is where we add the peripheral libraries of the microcontroller we're going to use to the project. If we need the RTC to keep track of time, we find it here and add it to the project with a single click.

Zone 2 in the image. Graphical peripheral configurator: adding a peripheral, or selecting one, opens its visual configurator. In the image you can see the RTC one with its options — we select the settings we need, hit "Generate, " and the peripheral's initialization code is generated automatically.

Zone 3 in the image. Automatically generated code: this is where all the files that Microchip's extensions generate after hitting "Generate" show up — the peripheral libraries for each configured peripheral (RTC, SERCOM, EIC, TC0…). This isn't code we write by hand: it's generated by the extension based on what we selected in the graphical configurator.

Zone 4 in the image. Our application code: this is where we add the.c and.h files that we write ourselves. This is the part of the project that's actually ours — the application code that calls into the libraries generated in Zone 3.

There are also other graphical configuration windows common to all microcontrollers, such as the pin configurator, the clock tree, the interrupt controller, and so on — which likewise let us configure things graphically and generate the necessary code based on our selections.

At this point you might say: but to build a project with a microcontroller, don't I need to know electronics, how a microcontroller works, which peripherals I need, and what each one does and how it works? And the answer is NO — we tell the AI what hardware we have and what we want to do, and it tells us what to use, how to configure it, and generates the necessary code, guiding us through every step of the process.

The AI-assisted workflow to replicate the 2007 IR receiver project would go like this:

• Give the AI context: we explain what hardware we have (EV58G97A + EV10P22A boards), that we're using VS Code with Microchip's extensions, and we ask for the first exercise — blinking the board's LED, the "Hello, World!" of microcontrollers, to verify the environment works.
• The AI guides us step by step: it tells us which zone of the graphical configurator to go to, which pin to configure as an output, what to name it, which options to check, and gives us the main.c code. We compile, flash it, and watch the LED blink.
• We add the LCD and temperature sensor: we ask the AI that we want to show text on the Explorer's LCD and the temperature from the sensor also included on the board. The AI tells us which libraries to add in Zone 1, which options to check in the configurator (Zone 2), and once the code is generated (Zone 3), asks us to copy it over so it knows exactly which functions to call. The AI creates the.c and.h files that we add in Zone 4. We compile, flash it, and see "Hello World!" and the temperature on the LCD.
• We add the IR receiver: we tell the AI we've connected a TSOP38238 to pin PA02 on the board, and that we want to replicate this 2007 project. The AI tells us which peripherals to add, how to configure them, and generates the IR driver code with its.c and.h files, plus modifies main.c. We compile, flash it, press the "+" button on the JVC remote, and the values 197 and 120 — sent by the remote when that button is pressed — show up on the LCD. Our IR receiver project is now working.

Finally, to wrap up the project, we can just tell the AI: generate a PDF documenting all the code you wrote, with a short explanation for each file —PDF with the project's source code, so everything is fully documented.

The cost of the two Microchip evaluation boards plus the IR receiver came to under 100 euros — and with them we can evaluate many of the characteristics of Microchip's various microcontrollers, in a professional, free development environment. Much cheaper than the time we had to invest back in 2007 building prototypes.

And in a few hours, on a single afternoon, anyone with no background in microcontrollers, programming, or electronics can put together a simple project like the one shown here, just by asking an AI and following its instructions — practically all the code it generated compiled correctly on the first try, with no errors.

Isn't that incredible?

Conclusions.

In this blog post we replicated a project originally done in 2007 with PIC microcontrollers, using today's development tools.

To build a project as simple as the IR remote one, back in the 2000s a person facing a microcontroller for the first time, with no prior knowledge, would need weeks — reading and learning how the microcontroller works, testing and figuring out how the various electronic components behave, building prototypes, writing code, asking questions, searching, fixing errors, and so on. Often all of it on their own. By the end of that process, they would have gained real knowledge and skills for tackling an electronics project.

Today, that same person could do the same thing in just a few hours, completing the project without needing any more knowledge than knowing how to ask an AI the right questions and follow its guidance.

These are obviously very different scenarios — in one we learn and do, in the other we only do. But for someone who wants to learn and build things today, the tools and resources available are incredible. In this example, having an AI at your disposal to help you search, reason, and create is worth quite a bit more than the roughly 18 euros a month a Claude subscription costs. And not using it would cost you far more, in time.

Having done this test — having never used an AI to write code before (my job today is 100% electronics and 0% firmware) — a question that used to come up years ago comes to mind:

"Which is better: programming in assembly or in C?" — and the answer people always gave was that C compilers would generate better assembly code than the vast majority of programmers writing assembly by hand.

That question could now become: "Which is better — a person writing code, or letting an AI write the code according to an expert's guidance? Can an AI generate better code than the vast majority of programmers?" My gut feeling (far from being an expert) is yes — the same way the C compiler won.

As for PIC microcontrollers, in this post we've only looked at their VS Code development environment and their evaluation boards — all of it working smoothly, without any issues. The fact that PIC has added Arm to its 32-bit lineup (beyond the ATSAM parts), and is betting on VS Code for its development environment, strikes me as a smart move — and I think it's worth spending time getting to know them, learning by reading documentation, building projects, and leaning on AI for troubleshooting, fixing errors, and speeding up research and lookups.

If you've made it this far (and you're not an AI), thanks for reading :).

This is an English translation of the original Spanish post, translated by AI.