How to code Arduino and ESP32 with AI?

A Guide to Coding Arduino and ESP32 with Artificial Intelligence

March 1, 2024 by Alessandro Colucci
AI and Arduino Image



In the ever-evolving landscape of technology, the convergence of Arduino/ESP32 and Artificial Intelligence (AI) has opened up a realm of possibilities for innovative projects. This integration marks a transformative leap in embedded systems and IoT development, where the adaptability of Arduino meets the analytical prowess of AI.

Arduino enthusiasts and developers alike find themselves at the intersection of creativity and intelligence, unlocking new dimensions for crafting smart and responsive devices. This article explores the journey of coding Arduino with AI, starting with the fundamentals of automatic code generation.


Automatic Code Generation Overview


Automatic code generation is a process in software development where source code or software artifacts are produced automatically through the use of tools, frameworks, or techniques, rather than being manually written by a developer. This approach aims to streamline the development process, enhance productivity, and reduce the likelihood of human errors.

In automatic code generation, developers typically provide high-level specifications or models, and a specialized tool interprets these specifications to generate the corresponding low-level source code. This can include generating code snippets, entire functions, or even complete applications based on predefined patterns or templates.

Several methods and tools are employed in automatic code generation, ranging from simple code templates in Integrated Development Environments (IDEs) to more advanced techniques like model-driven development (MDD) tools, domain-specific languages (DSLs), and code generators.

For embedded systems development, there are several tools and frameworks that support automatic code generation. These tools help streamline the development process and address the challenges associated with programming microcontrollers and other embedded devices. Here are some notable tools used for automatic code generation in the realm of embedded systems:


  1.  MATLAB Simulink:

    • Description: modeling and simulation tool widely used in the development of embedded systems. It supports automatic code generation for various hardware platforms.

    • Key Features: Model-based design, support for hardware-in-the-loop (HIL) testing, and automatic code generation for microcontrollers.

  2. Embedded Coder (MATLAB):

    • Description: An extension of MATLAB Simulink, Embedded Coder generates optimized C and C++ code from Simulink models for embedded systems.

    • Key Features: Code generation for various microcontrollers, support for custom code integration, and compliance with industry standards.

  3. STM32CubeMX:

    • Description: graphical software configuration tool that generates initialization code for STM32 microcontrollers.

    • Key Features: Pinout configuration, peripheral initialization code generation, and integration with popular IDEs like Keil and IAR.

  4. Keil MDK (Microcontroller Development Kit):

    • Description: complete software development environment for ARM Cortex-M microcontrollers. It includes the μVision IDE and supports automatic code generation.

    • Key Features: Integrated development environment, automatic code generation for ARM Cortex-M devices, and support for various debugging tools.

  5. Autosar Builder:

    • Description: tool for generating Autosar-compliant code for automotive embedded systems.

    • Key Features: Automatic generation of Autosar software components, configuration of communication stacks, and integration with Autosar-compliant platforms.

  6. Code Composer Studio (CCS):

    • Description: integrated development environment for Texas Instruments embedded processors. It supports automatic code generation.

    • Key Features: Code development for TI microcontrollers, debugging tools, and integration with hardware development kits.

  7. LabVIEW:

    • Description: graphical programming environment often used for test and measurement, but it also supports embedded systems development.

    • Key Features: Graphical programming, support for real-time systems, and code generation for various hardware targets.


Pros and Cons of Manual vs Automatic Coding


In the realm of software development, the choice between manual coding and automatic coding is a pivotal decision that shapes the development process. Each approach comes with its own set of advantages and challenges, influencing how developers create, maintain, and evolve software solutions. 

Manual coding, often regarded as the traditional approach, involves the meticulous crafting of code by developers. Every line is a product of human intellect, reflecting an intimate understanding of the programming language and the project's intricacies.

Automatic coding, driven by advancements in tools and frameworks, represents a paradigm shift in software development. The table below explores the emergence of automatic coding and its transformative impact on the development process respect to manual coding.


Manual Coding Automatic Coding
Precision and Control Time-Consuming Nature Time Efficiency Maintenance Challenges
In-depth Learning Experience Error-Prone Consistency Limited Flexibility
Tailored Solutions Limited Scalability Error Reduction Debugging Complexity


Striking the Balance


While each approach has its strengths and weaknesses, the optimal solution often lies in striking a balance between manual and automatic coding. Combining the precision of manual craftsmanship with the efficiency offered by automation allows developers to navigate the complexities of software development effectively.


AI as the Game Changer in Code Generation


Artificial Intelligence (AI) emerges as a transformative force, significantly altering the game compared to traditional automatic code generation tools.


  1. Learning and Adaptability: AI dynamically learns, analyzes data, and adapts code generation strategies to stay current with coding standards.

  2. Contextual Awareness: AI understands project context, generating code aligned with specifications, requirements, and component relationships.

  3. Real-time Suggestions: AI provides real-time, context-aware suggestions, enhancing productivity with adaptive code snippets during coding.

  4. NLP Integration: Natural Language Processing (NLP) makes the coding process intuitive and collaborative through user-friendly communication.

  5. Predictive Coding Efficiency: AI anticipates developers needs, streamlining the coding process with smart suggestions based on patterns and project context.

  6. Adaptability to Ambiguity: AI handles ambiguous requirements, ensuring robust solutions in dynamic coding environments.

  7. Tailoring Solutions: AI-powered tools can be customized for specific project needs, generating code closely aligned with unique requirements.

  8. Collaborative Human-AI Interaction: AI collaborates with human developers, automating routine tasks and allowing focus on higher-level creative aspects of coding.


Use of Generative AI in Code Generation


Generative AI is a type of artificial intelligence that can make new things like pictures or text, rather than just recognizing existing ones. It's like a creative AI that comes up with new stuff.

Generative AI, as exemplified by models like ChatGPT and Gemini, brings forth several compelling benefits in the context of code generation, particularly for platforms like Arduino and ESP32.


Providing Information for Arduino and ESP32 Code Generation


To harness the power of generative AI for Arduino and ESP32 code generation, developers can follow these steps:

1. Clearly Define Project Requirements:
  • Express the project goals, functionalities, and requirements in clear and concise natural language. Clearly specify the desired behavior of the Arduino or ESP32 code.
2. Provide Context and Constraints:
  • Offer relevant context, such as hardware configurations, sensor inputs, or desired outputs. Include any constraints or limitations that should be considered in the generated code.
3. Specify Programming Paradigms:
  • Communicate the preferred programming paradigms, styles, or specific libraries that should be used in the generated code. This helps in aligning the generated code with the developer's coding preferences.
4. Iterative Interaction:
  • Engage in an iterative conversation with the generative AI model. Seek clarifications, refine instructions, and gradually build the code in a step-by-step manner. This interactive approach ensures that the generated code aligns closely with the developer's intent.
5. Review and Validate:
  • While generative AI models aim to provide accurate and relevant code, it's crucial for developers to review and validate the generated snippets. Ensure that the code meets project requirements, adheres to best practices, and functions as intended.

By incorporating these steps, developers can leverage generative AI models like ChatGPT and Gemini to streamline the code generation process for Arduino and ESP32 projects, making it more accessible, efficient, and collaborative.


Examples to generate good or bad codes


Generating Good Codes


Example 1: Temperature Logging System


Well-Structured Requirement: "Develop Arduino code for a temperature logging system. Use a DS18B20 sensor to measure temperature every 15 minutes. Display the current temperature on an OLED screen and store the temperature data, along with timestamps, onto an SD card in CSV format."

Explanation: This requirement is clear, specific, and detailed. It outlines the components, the measurement frequency, the display method, and the data storage format. The generative AI model can easily understand and generate precise code for this task.

#include <Wire.h> 

#include <Adafruit_SSD1306.h>
#include <OneWire.h>
#include <DallasTemperature.h>
#include <SD.h>
#include <RTClib.h> // Pin configuration #define ONE_WIRE_BUS 2 // Pin for DS18B20 sensor #define OLED_RESET -1 // Reset pin for OLED display #define SD_CS_PIN 4 // Chip select pin for SD card module // Initialize DS18B20 OneWire oneWire(ONE_WIRE_BUS); DallasTemperature sensors(&oneWire); // Initialize OLED display Adafruit_SSD1306 display(OLED_RESET); // Initialize RTC (Real-Time Clock) - You may need to adjust this depending on your RTC module RTC_DS3231 rtc; // File for storing temperature data File dataFile; void setup() { Serial.begin(9600); // Initialize DS18B20 sensor sensors.begin(); // Initialize OLED display if(!display.begin(SSD1306_I2C_ADDRESS, OLED_RESET)) { Serial.println(F("SSD1306 allocation failed")); for(;;); } display.display(); // Initialize SD card if(!SD.begin(SD_CS_PIN)) { Serial.println(F("SD card initialization failed!")); for(;;); } // Initialize RTC if(!rtc.begin()) { Serial.println(F("Couldn't find RTC")); for(;;); } // Check if the RTC lost power and if so, set the time if(rtc.lostPower()) { Serial.println(F("RTC lost power, let's set the time!")); rtc.adjust(DateTime(F(__DATE__), F(__TIME__))); } } void loop() { // Measure temperature sensors.requestTemperatures(); float temperature = sensors.getTempCByIndex(0); // Get current time from RTC DateTime now =; // Display temperature on OLED display.clearDisplay(); display.setTextSize(1); display.setTextColor(SSD1306_WHITE); display.setCursor(0,0); display.print(F("Temperature: ")); display.println(temperature); display.display(); // Log temperature data to SD card logTemperature(now, temperature); // Wait for 15 minutes delay(15 * 60 * 1000); } void logTemperature(DateTime timestamp, float temperature) { // Open the data file in append mode dataFile ="temperature_log.csv", FILE_WRITE); // If the file is available, write to it if (dataFile) { dataFile.print(timestamp.year(), DEC); dataFile.print(F("/")); dataFile.print(timestamp.month(), DEC); dataFile.print(F("/")); dataFile.print(, DEC); dataFile.print(F(" ")); dataFile.print(timestamp.hour(), DEC); dataFile.print(F(":")); dataFile.print(timestamp.minute(), DEC); dataFile.print(F(":")); dataFile.print(timestamp.second(), DEC); dataFile.print(F(",")); dataFile.println(temperature); // Close the file dataFile.close(); } else { Serial.println(F("Error opening temperature_log.csv")); } }


Example 2: PWM-Controlled LED


Well-Defined Requirement: "Generate ESP32 code for a PWM-controlled LED. The LED brightness should be adjustable using a potentiometer. Additionally, implement a push-button functionality to toggle the LED on and off."

Explanation: This requirement provides a clear objective, specifying the hardware components involved and the expected functionalities. It guides the generative AI model in creating code for a task with defined inputs, outputs, and user interactions.

#include <Arduino.h>

const int ledPin = 5;      // PWM-capable pin for LED
const int potPin = 34;     // Analog pin for potentiometer
const int buttonPin = 18;  // GPIO pin for push-button

int potValue = 0;
int ledBrightness = 0;
bool ledState = false;
bool buttonState = false;
bool lastButtonState = false;
unsigned long lastDebounceTime = 0;
unsigned long debounceDelay = 50;

void setup() {
  pinMode(ledPin, OUTPUT);
  pinMode(buttonPin, INPUT_PULLUP);

void loop() {
  // Read potentiometer value and map it to LED brightness (0-255)
  potValue = analogRead(potPin);
  ledBrightness = map(potValue, 0, 4095, 0, 255);
  analogWrite(ledPin, ledBrightness);

  // Read the state of the push-button and debounce it
  int reading = digitalRead(buttonPin);
  if (reading != lastButtonState) {
    lastDebounceTime = millis();

  if ((millis() - lastDebounceTime) > debounceDelay) {
    if (reading != buttonState) {
      buttonState = reading;

      // Toggle LED state when the button is pressed
      if (buttonState == LOW) {
        ledState = !ledState;
        digitalWrite(ledPin, ledState ? HIGH : LOW);

  lastButtonState = reading;


Generating Bad Codes


Example 1: Vague Home Automation


Poorly-Defined Requirement: "Write Arduino code for a home automation project."

Explanation: This requirement lacks specificity and clarity. It doesn't specify the devices involved, the desired actions, or any specific functionalities. The generative AI model may struggle to provide meaningful code without clear guidance on the project's scope.

#include <SoftwareSerial.h>

SoftwareSerial bluetooth(10, 11);  // RX, TX pins for Bluetooth module

#define RELAY_1 2  // Relay 1 control pin
#define RELAY_2 3  // Relay 2 control pin

void setup() {

  pinMode(RELAY_1, OUTPUT);
  pinMode(RELAY_2, OUTPUT);

  // Initialize relays to OFF state
  digitalWrite(RELAY_1, LOW);
  digitalWrite(RELAY_2, LOW);

void loop() {
  if (bluetooth.available() > 0) {
    char command =;

    // Toggle Relay 1
    if (command == '1') {
      digitalWrite(RELAY_1, !digitalRead(RELAY_1));

    // Toggle Relay 2
    else if (command == '2') {
      digitalWrite(RELAY_2, !digitalRead(RELAY_2));


Example 2: Ambiguous Sensor Project


Inadequate Requirement: "Develop ESP32 code for a sensor project."

Explanation: This requirement is overly broad and does not specify the type of sensor, the desired measurements, or any particular actions to be taken. Without more details, the generative AI model may generate code that does not align with the user's intended project.

#include <DHT.h>

#define DHT_PIN 2    // Replace with the actual pin your sensor is connected to
#define DHT_TYPE DHT22


void setup() {

void loop() {
  delay(2000);  // Delay for 2 seconds, adjust as needed

  float temperature = dht.readTemperature();
  float humidity = dht.readHumidity();

  Serial.print("Temperature: ");
  Serial.print(" °C\t");

  Serial.print("Humidity: ");
  Serial.println(" %");




Effective communication of requirements is crucial for generating good codes using AI models. Well-structured, clear, and specific instructions yield precise and purposeful code.

Conversely, vague or ambiguous requirements can lead to poorly generated code that may not meet the intended project goals.

Understanding the importance of providing detailed information is key to leveraging the full potential of generative AI in code generation.


Chat with us on WhatsApp