AI tools and technologies can seem far removed from embedded systems and IoT edge device developers. After all, many AI tools today are used for search engines, writing blogs, and improving marketing. Yes, some code tools are out there, but they seem to be focused on developers working with cloud, web, or mobile applications. Do any of these AI tools address what embedded systems developers need? Yes! In this post, we will briefly discuss 5 AI tools for embedded systems developers and how they can help you improve your software development workflows.  

1. ChatPDF

Finding information in a datasheet for a microcontroller or some external chip can often be challenging. If you were to examine a modern datasheet for a microcontroller, you’d find thousands of pages of technical details. You can search a PDF, but sometimes the result is cumbersome and comes up empty. An exciting AI tool to assist you is ChatPDF.

ChatPDF allows you to upload a PDF document, which is then analyzed by their AI. The PDF is loaded along with a chat session. You can then ask questions about the PDF. The responses will often provide you with information and a link to where the data can be found. I like that feature because you can’t trust what an AI tells you today, so you need to be able to verify it.

To briefly demonstrate its capabilities, I uploaded the Microchip SAM-D5x-E5x Family datasheet to it. After a dozen seconds, I asked the AI, “What sleep modes are available for this part?”. Unfortunately, the response was not a list of available sleep modes, but the answer included a link to the table with the list.

The tool is sophisticated enough to feed it a datasheet and ask it to write a driver or list all the serial registers. However, it can pick out important details that you might otherwise miss. So, if its capabilities are limited, why try it? Besides helping you summarize and find snippets of data, you’ll also gain experience leveraging AI tools and technologies. These tools will one day drive most of our software development workflows, so it’s best to get comfortable with them now.

ChatGPT from OpenAI

ChatGPT is probably the most well-known generative AI model today. I like to consider it the junk drawer of AI because it’s trained to do many things. You’ve probably played around with it, so you know you can create a chat and use it to refine the model further. For example, if you wanted to create a new GPIO HAL interface, you might enter a prompt like the following:

The above prompt is a bit light on details, but the tool will generate a prototype that can get you to your end goal quicker with additional prompts or some manual adjustments. The first pass output from the above prompt can be seen below:

#ifndef GPIO_HAL_H

#define GPIO_HAL_H

#include <stdint.h>

// GPIO mode enumeration

typedef enum {

    GPIO_MODE_INPUT,

    GPIO_MODE_OUTPUT

} GPIO_Mode;

// GPIO pin structure

typedef struct {

    uint8_t port;  // GPIO port number (0 to n-1)

    uint8_t pin;   // GPIO pin number (0 to 31)

} GPIO_Pin;

// Initialize the GPIO peripheral

void GPIO_Init(void);

// Configure a GPIO pin mode

void GPIO_SetPinMode(GPIO_Pin pin, GPIO_Mode mode);

// Set the output state of a GPIO pin

void GPIO_SetPinState(GPIO_Pin pin, uint8_t state);

// Read the input state of a GPIO pin

uint8_t GPIO_ReadPinState(GPIO_Pin pin);

#endif /* GPIO_HAL_H */

ChatGPT can generate code, optimize your build system, develop a HAL or API, and debug code. The real caveat is to be careful not to release anything that could be confidential. The AI makers are reviewing and looking at the chats, so you don’t want to release company confidential information. However, it can be an excellent tool for general software activities.

Github CoPilot

Github CoPilot is an AI tool that will help developers with code suggestions. It’s inexpensive at around $20 USD per month. As you write code in Visual Studio Code, CoPilot will use the surrounding code to make suggestions that you can then accept and autocomplete. For example, if you are writing an interface, it may catch on and then suggest additional functions. Or it may see that you are writing an averaging function, and it will suggest code that it thinks will do that. It’s not always right, but I have seen it offer suggestions I had overlooked or hadn’t thought to add.

You can think of CoPilot as an AI pair programmer. Even writing a comment in the code can result in the AI writing the code! For example, if I write the following statement in a module:

// Sum two parameters are passed into the function

I get the following:

The gray text is CoPilot taking my comment and generating the code it thinks I might want. I can accept it by hitting a tab. This is a straightforward example, but it can generate far more complex code and seems to be learned based on the additional changes you make. Keep in mind you should carefully check what it creates. I have seen it try to create the same thing twice or offer poor suggestions that I must ignore. Overall, though, I’ve it worth the monthly fee.

Github CoPilot Labs

Another AI tool for embedded developers that I’ve found quite exciting and builds upon Github CoPilot is Github CoPilot Labs. Github CoPilot Labs is a VS Code extension for experimental applications of GitHub Copilot. For example, if you look at the image below, you can see that I’ve highlighted some code in a C++ application I wrote, and I’m getting an explanation of that code.

There are some excellent ideas in the interface that I’m looking forward to becoming more mainstream. For example, let’s say you are designing a digital filter and have designed and tested it in Python. Now, you have to translate that code into C or C++. Instead, you could use Copilot Labs to ask Copilot to convert the code into C! Or C++, Rust, or whatever language you are interested in!

Some experimental features exist for writing code by voice, creating documentation, cleaning the code, fixing bugs, and more! I look at this AI tool for embedded software developers to experiment and see where software development is going. The only problem with Copilot Labs is that it’s experimental, so they sometimes break things. You also need a Github Copilot license. I haven’t found this to be a showstopper for me.

AgentGPT

AgentGPT is one of those fascinating tools and perhaps the most scary. AgentGPT aims to create automated AI agents that you can give a goal. Once the goal is given, the agent will determine all the steps necessary to achieve it and then go through the process of achieving it! You can see below the agent running when I asked it to generate a Dockerfile for an Arm Cortex-M4 build system.

Pretty cool! The biggest problem that I’ve come up against with it is that you can only have it process five tasks before it quits running. That means you can only ask it for simple things before it reaches its limit. Of course, those limits can be raised to 25 runs if you’re willing to pay $40 per month.

Conclusions

AI tools for embedded systems developers do exist. They are hiding in other tools that can generate programs. The technologies that exist today aren’t foolproof and generate erroneous outputs; However, they also hold a lot of potential. If you understand the tools, their strengths, and weaknesses, you can leverage them to automate code writing and debugging activities to help you write more robust code faster. Hold on because, in the next few years, the industry will change so quickly it’ll be hardly recognized a decade from now.  

To learn more about AI Tools for embedded software, check out my other posts about Artificial Intelligence here.