DEV Community: Vaishnav-sabari-girish

Embedded Rust on the ESP32 : Sensor Integration : DHT22 (Temperature and Humidity Sensor)

Vaishnav-sabari-girish — Mon, 28 Jul 2025 13:57:55 +0000

In my previous blog, we interfaced a button.

We shall now get started with interfacing a few sensors. This blog will walk you through interfacing the DHT22 temperature and Humidity Sensor.

Getting Started

Let us create our new project

esp-generate --chip=esp32 dht22_sensor

Open src/bin/main.rs and type the below code

#![no_std]
#![no_main]
#![deny(
    clippy::mem_forget,
    reason = "mem::forget is generally not safe to do with esp_hal types, especially those \
    holding buffers for the duration of a data transfer."
)]

use esp_backtrace as _;
use esp_hal::{
    clock::CpuClock,
    delay::Delay,
    gpio::{DriveMode, Output, OutputConfig, Pull},
    main, 
};
use esp_println::println;
use embedded_dht_rs::dht22;
esp_bootloader_esp_idf::esp_app_desc!();

#[main]
fn main() -> ! {
    let config = esp_hal::Config::default().with_cpu_clock(CpuClock::max());
    let peripherals = esp_hal::init(config);

    let od_config = OutputConfig::default()
        .with_drive_mode(DriveMode::OpenDrain)
        .with_pull(Pull::None);

    let od_for_dht22 = Output::new(
            peripherals.GPIO4, esp_hal::gpio::Level::High, od_config
        )
        .into_flex();

    od_for_dht22.peripheral_input();


    let delay = Delay::new();

    let mut dht22 = dht22::Dht22::new(od_for_dht22, delay);

    loop {
        delay.delay_millis(2000);

        println!("");

        match dht22.read() {
            Ok(sensor_reading) => println!(
                "DHT22 Sensor - Temperature: {} C , Humidity: {} %",
                sensor_reading.temperature,
                sensor_reading.humidity
            ),
            Err(error) => println!("An error occurred while trying to read the sensor"),
        }

        println!("_____________________________________________________");
    }
}

Output GIF

Into the code : Line-by-line explanation

#![no_std]

Disables the Rust standard library for embedded programming.

#![no_main]

Replaces the default main entry point with a custom embedded one.

#![deny(
    clippy::mem_forget,
    reason = "mem::forget is generally not safe to do with esp_hal types, especially those \
    holding buffers for the duration of a data transfer."
)]

Prevents the use of mem::forget as it can cause unsafe behavior in this context.

use esp_backtrace as _;

Enables backtrace support on panic (if supported by target). as _ suppresses warnings.

use esp_hal::{
    clock::CpuClock,
    delay::Delay,
    gpio::{DriveMode, Output, OutputConfig, Pull},
    main,
};

Imports required ESP HAL modules:
- Clock configuration
- Delay handling
- GPIO configuration (including open-drain and pull options)
- main macro

use esp_println::println;

Enables UART-based printing to a terminal.

use embedded_dht_rs::dht22;

Imports DHT22 support from the embedded_dht_rs crate.

esp_bootloader_esp_idf::esp_app_desc!();

Embeds metadata about the application (like name, version).

#[main]
fn main() -> ! {

Entry point of the embedded program that never returns (-> !).

    let config = esp_hal::Config::default().with_cpu_clock(CpuClock::max());

Configures system with maximum CPU clock speed.

    let peripherals = esp_hal::init(config);

Initializes the HAL and returns access to hardware peripherals.

    let od_config = OutputConfig::default()
        .with_drive_mode(DriveMode::OpenDrain)
        .with_pull(Pull::None);

Sets up GPIO pin as Open-Drain with no internal pull-up/down. This is essential for DHT22 communication.

    let od_for_dht22 = Output::new(
            peripherals.GPIO4, esp_hal::gpio::Level::High, od_config
        )
        .into_flex();

Initializes GPIO4 with the config above and converts it to a flexible IO pin (Flex), which allows bidirectional control.

    od_for_dht22.peripheral_input();

Enables input mode for this flexible pin — DHT22 is bidirectional, so the pin needs to receive data too.

    let delay = Delay::new();

Creates a delay instance for timing control.

    let mut dht22 = dht22::Dht22::new(od_for_dht22, delay);

Initializes the DHT22 driver with the GPIO and delay.

    loop {

Begins infinite polling loop.

        delay.delay_millis(2000);

Waits 2 seconds between each sensor read (recommended minimum delay for DHT22).

        println!("");

Prints a blank line for readability.

        match dht22.read() {

Tries to read temperature and humidity from the sensor.

            Ok(sensor_reading) => println!(
                "DHT22 Sensor - Temperature: {} C , Humidity: {} %",
                sensor_reading.temperature,
                sensor_reading.humidity
            ),

If read is successful, prints temperature and humidity.

            Err(error) => println!("An error occurred while trying to read the sensor"),

If read fails, prints a basic error message (you can expand this with {:?} for debugging).

        println!("_____________________________________________________");

Prints a separator line to visually break up readings.

}
}

Closes loop and function.

Summary:

This ESP32 firmware reads data from a DHT22 sensor connected to GPIO4 and prints temperature and humidity to the serial console every 2 seconds. It uses open-drain GPIO configuration and the embedded_dht_rs crate for protocol handling.

Thank You

Important Links

Embedded Rust on the ESP32 : Interfacing Button with ESP32

Vaishnav-sabari-girish — Wed, 16 Jul 2025 17:29:42 +0000

In my previous blog, we blinked an LED.

Now, we shall interface a button (inbuilt Flash Button), which is connected to GPOI0 to read button presses.

Getting Started

Let us create our new project

esp-generate --chip=esp32 button_press

Open src/bin/main.rs file and type the below code

#![no_std]
#![no_main]
#![deny(
    clippy::mem_forget,
    reason = "mem::forget is generally not safe to do with esp_hal types, especially those \
    holding buffers for the duration of a data transfer."
)]

use esp_backtrace as _;
use esp_hal::{
    delay::Delay,
    gpio::Level,
    gpio::{Input, InputConfig},
    gpio::{Output, OutputConfig},
    main
};
use esp_println::println;
esp_bootloader_esp_idf::esp_app_desc!();

#[main]
fn main() -> ! {
    let peripherals = esp_hal::init(esp_hal::Config::default());
    let mut led = Output::new(peripherals.GPIO2, Level::Low, OutputConfig::default());
    let button = Input::new(peripherals.GPIO0, InputConfig::default());
    let delay = Delay::new();

    loop {
        if button.is_low() {
            led.set_high();
            println!("Button Pressed");
            delay.delay_millis(50);

        }
        else {
            led.set_low();
        }
    }
}

Into the Code : Line-by-line explanation

#![no_std]

Removes the standard library to suit bare-metal embedded systems.

#![no_main]

Disables Rust's default entry point, enabling use of a custom embedded main function.

#![deny(
    clippy::mem_forget,
    reason = "mem::forget is generally not safe to do with esp_hal types, especially those \
    holding buffers for the duration of a data transfer."
)]

Prevents using mem::forget, which can cause resource leaks with peripherals like GPIOs.

use esp_backtrace as _;

Provides support for backtraces during panics, aiding debugging.

use esp_hal::{
    delay::Delay,
    gpio::Level,
    gpio::{Input, InputConfig},
    gpio::{Output, OutputConfig},
    main,
};

Brings in delay functionality, GPIO level enums, input/output pin types, and the custom entry macro.

use esp_println::println;

Enables logging via println!, useful for debugging over serial.

esp_bootloader_esp_idf::esp_app_desc!();

Embeds metadata (app version, timestamp, etc.) into the firmware.

#[main]
fn main() -> ! {

Entry point of the application. Uses -> ! since it loops forever.

    let peripherals = esp_hal::init(esp_hal::Config::default());

Initializes peripherals using default configuration.

    let mut led = Output::new(peripherals.GPIO2, Level::Low, OutputConfig::default());

Configures GPIO2 as an output pin, initially set to Low (LED off).

    let button = Input::new(peripherals.GPIO0, InputConfig::default());

Configures GPIO0 as an input pin (for reading a button's state).

    let delay = Delay::new();

Initializes a delay instance for blocking waits.

    loop {

Begins an infinite loop to continuously check the button and control the LED.

        if button.is_low() {

Checks if the button is pressed (logic Low, assuming pull-up setup).

            led.set_high();

Turns the LED on.

            println!("Button Pressed");

Logs button press to serial console.

            delay.delay_millis(50);

Adds a small delay for button debounce.

        }
        else {
            led.set_low();
        }

If the button is not pressed, turns the LED off.

}
}

Outputs

Terminal Output

Hardware Output

Important Links

Embedded Rust on the ESP32 : Blinking an LED

Vaishnav-sabari-girish — Mon, 14 Jul 2025 17:25:21 +0000

In my previous blog, we coded our first Embedded Rust application which prints Hello World, now we will start a new application that is LED Blinking.
LED blinking in hardware is what Hello World is to software i.e it is the starting point of anyone who plans on starting microcontroller programming.

LED blinking gives you a basic idea of how to select which pin to toggle, make it an input or an output and how to set the pin as HIGH or LOW.

In this blog, we will be learning how to blink an LED in 2 ways :

[Setting HIGH and LOW separately]
[Toggling the LED]

Getting Started

Let us create a new project

esp-generate --chip=esp32 blinky

Refer the previous blog , for the steps.

NOTE
The above link takes you directly to the section in the previous blog where steps are outlined

These steps are common for all projects.

After the project has been created, let us get into the programming aspect.

Open the src/bin/main.rs file in the project.

Code 1 - Mentioning the Level of the Pin separately.

In this code, the Logic Level of the LED pin is mentioned explicitly as HIGH or LOW.

Here's the full code

#![no_std]
#![no_main]
#![deny(
    clippy::mem_forget,
    reason = "mem::forget is generally not safe to do with esp_hal types, especially those \
    holding buffers for the duration of a data transfer."
)]

use esp_backtrace as _;
use esp_hal::{
    delay::Delay,
    gpio::{Level, Output, OutputConfig},
    main,
};

use esp_println::println;
esp_bootloader_esp_idf::esp_app_desc!();

#[main]
fn main() -> ! {
    let peripherals = esp_hal::init(esp_hal::Config::default());

    println!("Hello World");

    let mut led = Output::new(peripherals.GPIO2, Level::Low, OutputConfig::default());
    let delay = Delay::new();

    loop {
        led.set_high();
        println!("LED HIGH");
        delay.delay_millis(1000);
        led.set_low();
        println!("LED LOW");
        delay.delay_millis(1000);
    }
}

Into the code : A line-by-line explanation

#![no_std]

This disables Rust's standard library, which is required in embedded environments where there is no OS.

#![no_main]

Tells the Rust compiler that this binary has no standard entry point (main from std) and instead uses a custom entry point, suitable for embedded.

#![deny(
    clippy::mem_forget,
    reason = "mem::forget is generally not safe to do with esp_hal types, especially those \
    holding buffers for the duration of a data transfer."
)]

This directive disallows the use of mem::forget, which can lead to memory/resource leaks when dealing with HAL (Hardware Abstraction Layer) resources like GPIOs or DMA.

use esp_backtrace as _;

This macro provides backtraces on panic, helping with debugging crashes.

use esp_hal::{
    delay::Delay,
    gpio::{Level, Output, OutputConfig},
    main,
};

Brings in essential traits and modules from the esp_hal crate:
- Delay: For implementing delay operations.
- gpio::{Level, Output, OutputConfig}: For configuring and using GPIO pins.
- main: Used to mark the entry point.

use esp_println::println;

Provides the println! macro, which sends debug messages to a serial console.

esp_bootloader_esp_idf::esp_app_desc!();

Macro that embeds application metadata like version, build date, etc., into the firmware binary.

#[main]
fn main() -> ! {

Defines the custom entry point of the application, marked with #[main] for esp_hal. The -> ! return type means this function never returns (infinite loop or system reset).

    let peripherals = esp_hal::init(esp_hal::Config::default());

Initializes the HAL with default configuration and gets access to hardware peripherals like GPIO.

    println!("Hello World");

Prints "Hello World" over serial (for debugging).

    let mut led = Output::new(peripherals.GPIO2, Level::Low, OutputConfig::default());

Configures GPIO2 as a digital output with default settings and initial level Low. Output::new() takes the pin, initial logic level, and an optional output config.

    let delay = Delay::new();

Initializes the delay timer used for timing operations like delay_millis().

    loop {

Infinite loop to blink the LED repeatedly.

        led.set_high();

Sets the GPIO2 pin to logic high (turns LED on).

        println!("LED HIGH");

Logs the LED state to the serial console.

        delay.delay_millis(1000);

Waits for 1000 milliseconds (1 second).

        led.set_low();

Sets the GPIO2 pin to logic low (turns LED off).

        println!("LED LOW");

Logs the LED state to the serial console.

        delay.delay_millis(1000);

Waits for another second before repeating.

}
}

Code 2 - Toggling the pin without mentioning it's level.

In this code, we directly toggle the pin instead of mentioning it's logic level. This reduces the lines of code.

#![no_std]
#![no_main]
#![deny(
    clippy::mem_forget,
    reason = "mem::forget is generally not safe to do with esp_hal types, especially those \
    holding buffers for the duration of a data transfer."
)]

use esp_backtrace as _;
use esp_hal::{
    delay::Delay,
    gpio::{Level, Output, OutputConfig},
    main
};
use esp_println::println;

esp_bootloader_esp_idf::esp_app_desc!();

#[main]
fn main() -> ! {
    let peripherals = esp_hal::init(esp_hal::Config::default());

    println!("Hello World");

    let mut led = Output::new(peripherals.GPIO2, Level::Low, OutputConfig::default());
    let delay = Delay::new();

    loop {
        led.toggle();
        println!("LED TOGGLED");
        delay.delay_millis(2000);
    }
}

Into the code : Line-by-line explanation

#![no_std]

Disables the standard Rust library, which isn't available in embedded systems.

#![no_main]

Replaces the standard main entry point with a custom one suitable for bare-metal applications.

#![deny(
    clippy::mem_forget,
    reason = "mem::forget is generally not safe to do with esp_hal types, especially those \
    holding buffers for the duration of a data transfer."
)]

Forbids use of mem::forget, which can cause resource leaks in hardware abstractions.

use esp_backtrace as _;

Enables backtrace functionality for debugging panics in embedded context.

use esp_hal::{
    delay::Delay,
    gpio::{Level, Output, OutputConfig},
    main,
};

Imports delay functionality, GPIO control types, and the custom main macro.

use esp_println::println;

Allows the use of println! for serial output, typically for debugging.

esp_bootloader_esp_idf::esp_app_desc!();

Embeds application metadata into the binary (e.g., version, date, etc.).

#[main]
fn main() -> ! {

Marks this as the custom entry point with an infinite loop (-> !).

    let peripherals = esp_hal::init(esp_hal::Config::default());

Initializes hardware abstraction and retrieves access to peripherals (GPIO, timers, etc).

    println!("Hello World");

Sends a "Hello World" message over serial for initial confirmation/debug.

    let mut led = Output::new(peripherals.GPIO2, Level::Low, OutputConfig::default());

Initializes GPIO2 as a push-pull output pin, starting in a Low state.

    let delay = Delay::new();

Creates a delay instance for blocking delay operations.

    loop {

Starts an infinite loop for repeated toggling of the LED.

        led.toggle();

Toggles the LED pin state (High <-> Low) each cycle.

        println!("LED TOGGLED");

Logs that the LED state was toggled.

        delay.delay_millis(2000);

Waits for 2000 milliseconds (2 seconds) before toggling again.

}
}

Now let's run

cargo run --release

to get the output.

Outputs

Code 1 outputs

Terminal Output

Hardware output

Code 2 outputs

Terminal output

Hardware Output

Important Links

Thank You

Embedded Rust on the ESP-32 : Hello World

Vaishnav-sabari-girish — Mon, 14 Jul 2025 08:56:06 +0000

In my previous blog link, I wrote about getting started with Embedded Rust on the ESP-32.
In this blog we will now create our first Embedded Rust application.
We will be creating the famous "Hello World" application.

Installing the necessary tools - Part 2

Install esp-generate. This generates the template for an Embedded Rust application for ESP32.

cargo install esp-generate

Setting Up

Assuming that you have installed all the required tools as told in the previous blog and above, we can start with using a template to create a project (This make things really easy). You can build from scratch too, but , only if you have enough technical knowledge and debugging expertise.

Navigate to the directory where you want to save you project (Say Desktop) using the command cd Desktop.
Create the project using the esp-generate function as follows :

esp-generate --chip=esp32 <project_name>

The --chip parameter depends on the ESP32 module being used. I personally am using the ESP32-WROOM module so it's esp32 for me. Refer the documentation for more chips.
Make sure you do not forget to follow the steps here
After creating the project, you will now get a directory of the below structure :

.
├── .cargo
│   └── config.toml
├── .gitignore
├── build.rs
├── Cargo.lock
├── Cargo.toml
├── rust-toolchain.toml
├── src
│   ├── bin
│   │   └── main.rs
│   └── lib.rs
└── tests
    └── hello_test.rs

Before going further, let us see what these files are for

build.rs

Sets the linker script arguments based on the template options.

.cargo/config.toml

The Cargo configuration. This defines a few options to correctly build the project. Contains the custom runner command for espflash or probe-rs. For example, runner = "espflash flash --monitor" - this means you can just use cargo run to flash and monitor your code

Cargo.toml

The usual Cargo manifest declares some meta-data and dependencies of the project

.gitignore

Tells git which folders and files to ignore

rust-toolchain.toml

Defines which Rust toolchain to use. The toolchain will be nightly or esp depending on your target

src/bin/main.rs

The main source file of the newly created project.

src/lib.rs

This tells the Rust compiler that this code doesn't use libstd.

The `Hello World` Embedded Rust Program

Creating the project

When you run the command

esp-generate --chip=esp32 hello_world

You will get a TUI interface for more settings.
To select a feature, press →. As shown in the below GIF.

Make sure you choose the ones selected on the GIF only i.e only the Enable Unstable HAL features and Use esp-backtrace as panic handler which is inside Flashing, Logging and Debugging.

Writing the code

Now, in the src/bin/main.rs file inside the project directory, write the below code :

#![no_std]
#![no_main]

use esp_backtrace as _;
use esp_hal::{
    clock::CpuClock,
    delay::Delay, 
    main
};
use esp_println::println;
esp_bootloader_esp_idf::esp_app_desc!();


#[main]
fn main() -> ! {
    let config = esp_hal::Config::default().with_cpu_clock(CpuClock::max());
    let _peripherals = esp_hal::init(config);
    let delay = Delay::new();
    loop {
        println!("Hello World");
        delay.delay_millis(500);
    }
}

This code prints Hello World after every 500 milliseconds or 1/2 a second.

To run and flash this code , type

cargo run --release

This will compile and flash the code to the ESP32.

Here's the output

Into the Code : A line-by-line explanation

Line-by-Line Explanation: ESP32 "Hello World" in Embedded Rust

#![no_std]

This disables the Rust standard library. In embedded systems, the standard library is often unavailable or unnecessary due to hardware constraints.

#![no_main]

This tells the Rust compiler not to use the default entry point (main from the std lib). Instead, we define our own entry point suitable for embedded devices.

use esp_backtrace as _;

This pulls in the esp_backtrace crate to provide panic handlers and backtraces (when supported), which are essential for debugging embedded systems. The as _ suppresses the unused import warning.

use esp_hal::{
    clock::CpuClock,
    delay::Delay, 
    main
};

Imports:
- CpuClock: lets you configure the CPU clock speed.
- Delay: for inserting delays into your program.
- main: an attribute macro that marks the main function as the program's entry point.

use esp_println::println;

This brings in println! macro functionality, which outputs to UART so we can see debug output from the ESP32.

esp_bootloader_esp_idf::esp_app_desc!();

This macro embeds metadata from the esp-idf build into the binary (like project name, version, etc.). It’s optional but helpful for diagnostics and logging.

#[main]

The #[main] macro from esp_hal designates the following function as the program’s entry point.

fn main() -> ! {

Defines the entry point of the application. The -> ! return type indicates it never returns (infinite loop).

    let config = esp_hal::Config::default().with_cpu_clock(CpuClock::max());

Creates a default configuration and sets the CPU clock to the maximum supported frequency.

    let _peripherals = esp_hal::init(config);

Initializes the ESP32 HAL with the provided configuration and takes ownership of the device’s peripherals.

    let delay = Delay::new();

Instantiates a delay object used to insert blocking delays into the code.

    loop {

Infinite loop to run your logic continuously (typical in embedded firmware).

        println!("Hello World");

Sends the string "Hello World" to the serial output using UART.

        delay.delay_millis(500);

Inserts a 500 ms delay between messages.

}
}

Closes the loop and main function.

Important Links

Thank You

Embedded Rust on the ESP32 : Getting started - Setup

Vaishnav-sabari-girish — Mon, 14 Jul 2025 07:10:19 +0000

What are Embedded Systems ?

Embedded systems are tiny computers built into devices to perform specific tasks. Unlike general-purpose computers, they are designed for control, automation, and real-time operations. You'll find them in everything from smartwatches to washing machines.

What is ESP32 ?

The ESP32 is a low-cost, low-power microcontroller with built-in Wi-Fi and Bluetooth, developed by Espressif Systems. It's widely used in IoT projects due to its rich set of peripherals, dual-core processor, and community support. Perfect for smart devices, sensors, and wireless applications.

What is Rust ?

Rust is a systems programming language focused on safety, speed, and concurrency. It’s known for preventing common bugs at compile time without needing a garbage collector.

Features of Rust

Memory Safety : Eliminates NULL pointer and buffer overflows due to it's ownership and lifetimes features.
Zero-cost abstraction : High-level code with low-level performance.
Concurrency : Fearless Multithreading without Race conditions.
Modern Tooling : cargo makes it easier for project management and installing Rust tools. cargo is for Rust what pip and uv are for Python.
Cross-platform support : From Bare-metal Linux to WebAssembly.

Why use Rust for Embedded Systems ?

Rust offers the performance of C/C++ with memory safety guarantees, making it ideal for low-level, resource-constrained environments. Its strong compile-time checks prevent many common embedded bugs early in development. With growing ecosystem support (like esp-hal), Rust is becoming a powerful and ergonomic choice for writing safe, efficient firmware for microcontrollers like the ESP32.

Setting up the Environment

This blog assumes that :

You are using a Linux Distribution (Like Ubuntu, Fedora , Debian or Arch).
You have installed Rust. If not install it by following the instruction here
You are familiar with using the Terminal.

Hardware

ESP32-WROOM

For future blogs, the following sensors are required :

HC-SR04 Ultrasonic Sensor

DHT22 Temperature and Humidity Sensor:

Touch Sensor :

Installing the tool chain

ESP32 doesn't have enough power to run a full OS based program, so we will be using the no_std library for Embedded Programming.

Install the following tool chains

Installing espup . This is a tool that simplifies installing and maintaining the components required to develop Rust applications for the Xtensia and RISC-V architectures. (Make sure that cargo is in your PATH).

cargo install espup

Installing the necessary tool-chains

espup install

Now a file named export-esp.sh will be created in your $HOME directory. Add it's contents to your ~/.bashrc or ~/.zshrc using the following command

cat $HOME/export-esp.sh >> ~/.bashrc

The export-esp.sh file consists of all the environment variables required to run the Rust Code.

You are now ready to write Embedded Rust Code

Find the other blogs here

Hello World
LED Blinking
Button interfacing
Sensor Integration
1. DHT22 Temperature and Humidity Sensor
2. [Ultrasonic Sensor]
3. [Touch Sensor]

Miscellaneous Links

Streamlining Arduino Development: Introducing Arduino-cli-interactive

Vaishnav-sabari-girish — Sun, 06 Apr 2025 14:17:52 +0000

Arduino has always been a cornerstone for me as a hobbyist and developer, offering an accessible way to dive into embedded systems. But as a Linux user, I’ve often found the traditional Arduino IDE more frustrating than inspiring— wrestling with permissions and setup hurdles was a constant battle. When the Arduino team released arduino-cli, I saw a glimmer of hope: a lightweight, command-line alternative that fit my terminal-centric workflow. Yet, its reliance on memorizing Fully Qualified Board Names (FQBNs) like arduino:avr:uno felt like a step backward for beginners and even slowed me down. That’s why I created Arduino-cli-interactive (ACI)—a Bash script that wraps arduino-cli in a Text User Interface (TUI), bringing the ease of the IDE into the terminal with menus and option selectors. It’s been a game-changer for me, and I hope it can be for you too.

The Problem: My Linux Struggle

I love Linux for its flexibility, but setting up the Arduino IDE on it was a nightmare. Permissions issues turned a simple install into a troubleshooting marathon, and the GUI never quite meshed with my preference for the terminal. When I discovered arduino-cli, I was thrilled—it stripped away the bloat and let me script my workflow. But then I hit a snag: typing out exact FQBNs and commands every time was tedious. I’d forget a board identifier or mistype a port, and my momentum would grind to a halt. I knew I wasn’t alone—beginners especially would find this unforgiving. I wanted a solution that kept arduino-cli’s power but made it intuitive, so I set out to build one.
Creating Arduino-cli-interactive (ACI)

That’s how Arduino-cli-interactive, or ACI, was born. I built it as an open-source Bash script (check it out on GitHub), designing a TUI that feels like the Arduino IDE but lives in the terminal. With ACI, I don’t have to memorize board names or wrestle with long commands anymore. Instead, I launch it and get a clean menu: I pick my board from a list, select a port, and upload my sketch—all with a few keystrokes.

I chose Bash for a reason. It’s everywhere on Linux, so ACI runs on any system without extra setup—no dependencies, no fuss. It’s lightweight, leveraging the terminal’s built-in tools, and lets me iterate quickly. Writing a TUI in Bash wasn’t just practical; it was a fun challenge that kept the project true to the hacker spirit I love about Arduino. The result? A tool that’s as simple as it is powerful.

How It Works for Me

ACI is my bridge to arduino-cli. When I run it, I see an interactive menu. If I need to pick a board, I scroll through a list—no more guessing FQBNs. Setting a port? ACI scans and shows me what’s connected. From there, I can compile my code, upload it, or tweak settings, all without leaving the terminal. For instance, instead of typing arduino-cli upload -p /dev/ttyUSB0 -b arduino:avr:uno sketch.ino, I just navigate the menu, hit my choices, and watch the Bash script do the rest. It’s fast, it’s clean, and it gets my code running in seconds.

For example here's how selecting a board looks like :

Why It’s a Big Deal to Me

ACI has transformed how I work with Arduino. As someone who’s taught beginners, I see how it flattens the learning curve—newbies can focus on blinking LEDs instead of decoding commands. For me, it’s a time-saver; I iterate faster without breaking my flow. And since it’s Bash-based, it’s a perfect fit for Linux, dodging the IDE’s quirks while staying lean and mean. On GitHub, I wrote, “No need to remember board names or type long commands. Just pick options, navigate with buttons, and upload your code hassle-free.” That’s the freedom I wanted, and it’s what I’ve built.

My Journey and What’s Next

Building ACI wasn’t always smooth sailing. Crafting a TUI in Bash meant getting creative with loops and prompts to make it feel responsive. My goal was to keep it intuitive while tapping into arduino-cli’s full potential, and I’m proud of where it’s landed. Seeing it recognized in communities like Terminaltrove has been a thrill—it’s proof this little script solves a real need.

I’m not done yet, though. I’m thinking about porting it for windows too (using either Rust or Python). I’d love your ideas too—ACI is open-source, and I’m excited to see where the community takes it. If you’re a Bash tinkerer like me, dive in and contribute!

Whether you’re a Linux die hard like me, a beginner just starting out, or a pro chasing efficiency, I invite you to try it. Head to GitHub, give it a spin, and let me know what you think. In the maker space, every tweak matters—and I can’t wait to hear how ACI fits into your story.

Important Links

Keyoxide Proof

Vaishnav-sabari-girish — Mon, 03 Feb 2025 06:08:25 +0000

aspe:keyoxide.org:UGMJ6VGDFJEOVHF27DC7JD6WMQ

DEV Community: Vaishnav-sabari-girish

Embedded Rust on the ESP32 : Sensor Integration : DHT22 (Temperature and Humidity Sensor)

Getting Started

Output GIF

Into the code : Line-by-line explanation

Summary:

Important Links

Embedded Rust on the ESP32 : Interfacing Button with ESP32

Getting Started

Into the Code : Line-by-line explanation

Outputs

Terminal Output

Hardware Output

Important Links

Embedded Rust on the ESP32 : Blinking an LED

Getting Started

Code 1 - Mentioning the Level of the Pin separately.

Into the code : A line-by-line explanation

Code 2 - Toggling the pin without mentioning it's level.

Into the code : Line-by-line explanation

Outputs

Code 1 outputs

Terminal Output

Hardware output

Code 2 outputs

Terminal output

Hardware Output

Important Links

Embedded Rust on the ESP-32 : Hello World

Installing the necessary tools - Part 2

Setting Up

The Hello World Embedded Rust Program

Creating the project

Writing the code

Into the Code : A line-by-line explanation

Line-by-Line Explanation: ESP32 "Hello World" in Embedded Rust

Important Links

Embedded Rust on the ESP32 : Getting started - Setup

What are Embedded Systems ?

What is ESP32 ?

What is Rust ?

Features of Rust

Why use Rust for Embedded Systems ?

Setting up the Environment

Hardware

Installing the tool chain

Miscellaneous Links

Streamlining Arduino Development: Introducing Arduino-cli-interactive

The Problem: My Linux Struggle

How It Works for Me

Why It’s a Big Deal to Me

My Journey and What’s Next

Important Links

Keyoxide Proof

The `Hello World` Embedded Rust Program