Display Room Temperature on LCD with Arduino Uno and Rust

2026-08-28T00:00:00+00:00

Room Temperature in Arduino Uno With Rust</figcaption> </figure>

This is the next experiment I did with the Arduino Uno and Embedded Rust. In the last post, I showed you how to use the Arduino Uno with Rust</a> and how to check the final firmware size. The firmware size for the LED blinking program was just 262 bytes.

This time, we will create a project where we display the room temperature on an HD44780 LCD using an NTC thermistor.

</div>

TIP I will not go into detail about how a thermistor works or what a voltage divider is in this post. If you are not familiar with these concepts, you can check out the thermistor chapters in either Pico Book</a> or the ESP32 book</a>. The Books are available for free. </div> </div>
A thermistor is a resistor whose resistance changes with temperature. We are using an NTC thermistor, whose resistance decreases as the temperature increases. By measuring this change in resistance, we can calculate the temperature.

NTC thermistor</li>
10 kΩ resistor</li>
16x2 HD44780 LCD with I2C interface</li>
Breadboard</li>
Jumper wires</li> </ul>
</a> Hardware Setup</h2>
We will connect the NTC thermistor and a 10 kΩ</code> resistor as a voltage divider. The output of the voltage divider is connected to the Arduino Uno’s A1</code> analog pin.
The 16x2 HD44780 LCD is connected through I2C. The SDA</code> and SCL</code> lines are connected to A4</code> and A5</code>, respectively.
The complete hardware setup is shown below:
</a> Arduino Uno thermistor and I2C LCD circuit</figcaption> </figure> The Arduino Uno provides 5 V</code> power to both the thermistor circuit and the LCD. The Rust program will read the voltage divider through the ADC, calculate the temperature, and display it on the LCD. Thermistor Circuit From</th> Wire</th> To</th> </tr> </thead> Arduino Uno 5V</td> </div> </div> </div> </td> 10 kΩ Resistor</td> </tr> NTC Thermistor</td> </div> </div> </div> </td> Arduino Uno GND</td> </tr> 10 kΩ Resistor</td> </div> </div> </div> </td> NTC Thermistor</td> </tr> Junction between resistor and thermistor</td> </div> </div> </div> </td> Arduino Uno A1</td> </tr> </tbody> </table> The junction between the resistor and thermistor is connected to the Arduino Uno’s A1 pin, allowing us to measure the voltage from the voltage divider. LCD Circuit From</th> Wire</th> To</th> </tr> </thead> Arduino Uno 5V</td> </div> </div> </div> </td> LCD VCC</td> </tr> Arduino Uno GND</td> </div> </div> </div> </td> LCD GND</td> </tr> Arduino Uno A4 (SDA)</td> </div> </div> </div> </td> LCD SDA</td> </tr> Arduino Uno A5 (SCL)</td> </div> </div> </div> </td> LCD SCL</td> </tr> </tbody> </table> </a> From ADC Reading to Temperature</h2> What we read from the ADC is a digital value representing the voltage at the junction of the resistor and thermistor. We need to convert this value into temperature. First, we calculate the thermistor’s resistance from the ADC reading. We can then use that resistance to calculate the temperature. For our voltage divider, we can calculate the thermistor resistance using: $$ R_T = R_1 \frac{ADC}{ADC_{max} - ADC} $$ where: $R_T$ is the thermistor resistance.</li> $R_1$ is the fixed resistor resistance (10 kΩ</code>).</li> $ADC$ is the value read from the ADC.</li> $ADC_{max}$ is the maximum ADC value (1023</code> for the Arduino Uno).</li> </ul> Once we have the thermistor resistance, we can calculate the temperature using the Beta equation: $$ T = \frac{1}{\frac{1}{T_0} + \frac{1}{B}\ln\left(\frac{R_T}{R_0}\right)} $$ The formula uses the thermistor’s current resistance ($R_T$), its reference resistance ($R_0$) at a reference temperature ($T_0$), and its Beta coefficient ($B$). Manufacturers usually provide these values. For our thermistor, $R_0 = 10 kΩ$ at $T_0 = 25°C$, and $B = 3950$. We calculate $R_T$ from the ADC reading. </a> Project Setup</h2> We will use the same avr-hal</code> project template that we used in the previous Arduino Uno project. Run the following command: cargo generate --git https://github.com/Rahix/avr-hal-template.git</code></pre> The template will ask a few questions. Select Arduino Uno as the board and enter a name for your project. I will use room-temperature</code> as the project name. </a> Crates</h2> Add the following crates to Cargo.toml</code>: hd44780-driver = "0.4.0" libm = "0.2.16"</code></pre> There are several Rust crates for communicating with an HD44780 LCD. I will use hd44780-driver</code>. If you want custom character support, you can use a crate such as liquid_crystal</code>. We will need the natural logarithm (log</code>) as part of the temperature calculation formula, so we use libm</code> for this calculation in our no_std</code> project. We will also use heapless</code> to format the temperature value as text before sending it to the LCD: heapless = "0.9.3"</code></pre> We can reduce the firmware size by avoiding the use of heapless</code> with a different approach. However, we will first use heapless</code> to keep the code simple and then optimize it later. </a> Converting ADC Reading to Temperature</h2> Let’s convert the formulas into Rust functions and define the corresponding constants. These functions should be obvious, so we will not go into detail about them. const fn kelvin_to_celsius(kelvin: f64) -> f64 { kelvin - 273.15 } const fn celsius_to_kelvin(celsius: f64) -> f64 { celsius + 273.15 } const B_VALUE: f64 = 3950.0; const REF_TEMP: f64 = 25.0; // Reference temperature 25°C const REF_RES: f64 = 10_000.0; // Thermistor resistance at the Reference Temperature(25°C) const REF_TEMP_K: f64 = celsius_to_kelvin(REF_TEMP); const R1_RES: f64 = REF_RES; // 10_000.0 ohms const ADC_MAX: f64 = 1023.0; // 1023 for 10-bit ADC fn adc_to_resistance(adc_value: f64) -> f64 { let x: f64 = adc_value / (ADC_MAX - adc_value); R1_RES * x } // B Equation to convert resistance to temperature fn calculate_temperature(current_res: f64, b_val: f64) -> f64 { let ln_value = libm::log(current_res / REF_RES); // Use libm for `no_std` let inv_t = (1.0 / REF_TEMP_K) + ((1.0 / b_val) * ln_value); 1.0 / inv_t }</code></pre></a> Setting Up the ADC</h2> Let’s set up the ADC to read the thermistor connected to A1</code>. let mut adc = arduino_hal::Adc::new(dp.ADC, Default::default()); let a1 = pins.a1.into_analog_input(&mut adc);</code></pre></a> Setting Up the LCD</h2> Next, let’s set up the I2C interface and initialize the LCD. let i2c = arduino_hal::I2c::new( dp.TWI, pins.a4.into_pull_up_input(), pins.a5.into_pull_up_input(), 50000, ); let mut text: String<32> = String::new(); let mut delay = Delay::new(); let i2c_address = 0x27; let Ok(mut lcd) = HD44780::new_i2c( i2c, i2c_address, &mut delay, ) else { panic!("failed to initialize display"); };</code></pre></a> Reading and Displaying the Temperature</h2> In the main loop, we will read the ADC value and calculate the temperature from it. Since avr-hal</code> does not support formatting floating-point values, we split the temperature into whole and fractional parts as i32</code> values. With the help of heapless</code>, we format these values into a string and finally send the text to the LCD. let mut text: String<32> = String::new(); let mut delay = Delay::new(); loop { let adc_value = a1.analog_read(&mut adc); let current_res = adc_to_resistance(adc_value as f64); let temperature_kelvin = calculate_temperature(current_res, B_VALUE); let temperature_celsius = kelvin_to_celsius(temperature_kelvin); // Clear the Heapless string text.clear(); // Unshift display and set cursor to 0 lcd.reset(&mut delay).unwrap(); // Clear existing characters lcd.clear(&mut delay).unwrap(); let whole = temperature_celsius as i32; let frac = ((temperature_celsius.abs() * 100.0) as i32) % 100; write!(&mut text, "{}.", whole).unwrap(); if frac < 10 { write!(&mut text, "0").unwrap(); } write!(&mut text, "{}", frac).unwrap(); lcd.write_str("Temp: ", &mut delay).unwrap(); lcd.write_str(text.as_str(), &mut delay).unwrap(); lcd.write_byte(0xDF, &mut delay).unwrap(); // Degree symbol ° lcd.write_char('C', &mut delay).unwrap(); arduino_hal::delay_ms(5000); }</code></pre></a> Alternative: Avoiding heapless</code></h2> We can also format the temperature without using heapless</code>, which helps reduce the firmware size. Instead of converting the temperature into a string, we can write each digit directly to the LCD. let temp_abs = temperature_celsius.abs(); let whole = temp_abs as u8; let frac = ((temp_abs * 100.0) as i32) % 100; // Logic to send temperature value without heapless lcd.write_str("Temp: ", &mut delay).unwrap(); if temperature_celsius.is_sign_negative() { lcd.write_str("-", &mut delay).unwrap(); } lcd.write_byte((whole / 10) + b'0', &mut delay).unwrap(); lcd.write_byte((whole % 10) + b'0', &mut delay).unwrap(); lcd.write_char('.', &mut delay).unwrap(); lcd.write_byte((frac / 10) as u8 + b'0', &mut delay).unwrap(); lcd.write_byte((frac % 10) as u8 + b'0', &mut delay).unwrap(); lcd.write_byte(0xDF, &mut delay).unwrap(); // Degree symbol ° lcd.write_char('C', &mut delay).unwrap();</code></pre></a> Firmware Size</h2> Let’s check the firmware size using the heapless</code> version: text data bss dec hex filename 23984 260 1 24245 5eb5 room-temperature.elf</code></pre> Now, let’s remove heapless and use the alternative approach we discussed earlier: text data bss dec hex filename 20784 30 1 20815 514f room-temperature.elf</code></pre> By avoiding heapless, the firmware size decreases from 24,245 bytes to 20,815 bytes, saving 3,430 bytes. This was a quick win in terms of firmware size. I did not want to spend too much time on further optimization and overcomplicate this article, so i will stop here. </a> The Full code</h2> #![no_std] #![no_main] use arduino_hal::prelude::*; use arduino_hal::Delay; use core::fmt::Write; use heapless::String; use panic_halt as _; // HD44780 Driver use hd44780_driver::HD44780; const fn kelvin_to_celsius(kelvin: f64) -> f64 { kelvin - 273.15 } const fn celsius_to_kelvin(celsius: f64) -> f64 { celsius + 273.15 } const B_VALUE: f64 = 3950.0; const REF_TEMP: f64 = 25.0; // Reference temperature 25°C const REF_RES: f64 = 10_000.0; // Thermistor resistance at the Reference Temperature(25°C) const REF_TEMP_K: f64 = celsius_to_kelvin(REF_TEMP); const R1_RES: f64 = REF_RES; // 10_000.0 ohms const ADC_MAX: f64 = 1023.0; // 1023 for 10-bit ADC fn adc_to_resistance(adc_value: f64) -> f64 { let x: f64 = adc_value / (ADC_MAX - adc_value); R1_RES * x } // B Equation to convert resistance to temperature fn calculate_temperature(current_res: f64, b_val: f64) -> f64 { let ln_value = libm::log(current_res / REF_RES); // Use libm for `no_std` let inv_t = (1.0 / REF_TEMP_K) + ((1.0 / b_val) * ln_value); 1.0 / inv_t } #[arduino_hal::entry] fn main() -> ! { let dp = arduino_hal::Peripherals::take().unwrap(); let pins = arduino_hal::pins!(dp); let mut serial = arduino_hal::default_serial!(dp, pins, 57600); let mut adc = arduino_hal::Adc::new(dp.ADC, Default::default()); let a1 = pins.a1.into_analog_input(&mut adc); let i2c = arduino_hal::I2c::new( dp.TWI, pins.a4.into_pull_up_input(), pins.a5.into_pull_up_input(), 50000, ); let mut text: String<32> = String::new(); let mut delay = Delay::new(); let i2c_address = 0x27; let Ok(mut lcd) = HD44780::new_i2c(i2c, i2c_address, &mut delay) else { panic!("failed to initialize display"); }; lcd.set_cursor_visibility(hd44780_driver::Cursor::Invisible, &mut delay) .unwrap(); lcd.set_cursor_blink(hd44780_driver::CursorBlink::Off, &mut delay) .unwrap(); loop { let adc_value = a1.analog_read(&mut adc); ufmt::uwriteln!(&mut serial, "ADC: {}", adc_value).unwrap_infallible(); let current_res = adc_to_resistance(adc_value as f64); let temperature_kelvin = calculate_temperature(current_res, B_VALUE); let temperature_celsius = kelvin_to_celsius(temperature_kelvin); // Clear the Heapless string text.clear(); // Unshift display and set cursor to 0 lcd.reset(&mut delay).unwrap(); // Clear existing characters lcd.clear(&mut delay).unwrap(); let whole = temperature_celsius as i32; let frac = ((temperature_celsius.abs() * 100.0) as i32) % 100; // Alternative: Avoiding Heapless // let temp_abs = temperature_celsius.abs(); // let whole = temp_abs as u8; // let frac = ((temp_abs * 100.0) as i32) % 100; ufmt::uwrite!(&mut serial, "Temperature: {}.", whole).unwrap_infallible(); write!(&mut text, "{}.", whole).unwrap(); if frac < 10 { ufmt::uwrite!(&mut serial, "0").unwrap_infallible(); write!(&mut text, "0").unwrap(); } write!(&mut text, "{}", frac).unwrap(); ufmt::uwriteln!(&mut serial, "{} °C", frac).unwrap_infallible(); lcd.write_str("Temp: ", &mut delay).unwrap(); lcd.write_str(text.as_str(), &mut delay).unwrap(); lcd.write_byte(0xDF, &mut delay).unwrap(); // Degree symbol ° lcd.write_char('C', &mut delay).unwrap(); // Alternative: Avoiding Heapless // Logic to send temperature value without heapless // lcd.write_str("Temp: ", &mut delay).unwrap(); // if temperature_celsius.is_sign_negative() { // lcd.write_str("-", &mut delay).unwrap(); // } // // lcd.write_byte((whole / 10) + b'0', &mut delay).unwrap(); // lcd.write_byte((whole % 10) + b'0', &mut delay).unwrap(); // lcd.write_char('.', &mut delay).unwrap(); // lcd.write_byte((frac / 10) as u8 + b'0', &mut delay) // .unwrap(); // lcd.write_byte((frac % 10) as u8 + b'0', &mut delay) // .unwrap(); // // lcd.write_byte(0xDF, &mut delay).unwrap(); // Degree symbol ° // lcd.write_char('C', &mut delay).unwrap(); arduino_hal::delay_ms(5000); } }</code></pre></a> Final Thoughts</h2> Another Arduino Uno experiment is done. This time, we went a little beyond blinking an LED and built a simple room temperature monitor with a thermistor and I2C LCD. You can find the complete source code for this experiment on GitHub</a>. You can navigate to the room-temperature</code> folder to find the code for this project. Can I Use Rust with Arduino Uno? Getting Started with Embedded Rust 2026-08-15T00:00:00+00:00 Arduino Uno compatible board</figcaption> </figure> Embedded Rust keeps getting more mature, and most people use boards like the ESP32, Raspberry Pi Pico or STM32 with Rust. At least, those are the boards I have used most for Embedded Rust. But what if you already have an Arduino Uno? Can you use Rust with it? The answer is YES. The Arduino Uno uses the ATmega328P, an 8-bit AVR RISC microcontroller with 32 KB of flash memory, 2 KB of SRAM, and 23 general-purpose I/O pins. With such limited resources, you might wonder if a Rust program can actually fit on the board. This question sometimes comes up on social media. Some people see the large binary size of Rust programs on desktop and assume Rust will also be too large for microcontrollers. But Embedded Rust has a different side. With no_std</code>, we can write programs without the standard library and target small microcontrollers directly. So instead of guessing, let’s try it on the Arduino Uno and see how much space our Rust program actually needs. By the way, I didn’t have an Arduino Uno before this, and I had never coded with the Arduino IDE either. I just bought one (a cheap clone) to experiment with Rust :) </div> TIP Don’t judge Embedded Rust based only on the Arduino Uno experience. The AVR platform and avr-hal have their own limitations, and the experience can be quite different on other microcontrollers. For example, I like Embassy, which makes it easier to work across different boards and use async programming. </div> </div> </a> AVR HAL</h2> For programming the Arduino Uno with Rust, we will use avr-hal</code></a>. It is a Hardware Abstraction Layer for AVR microcontrollers and boards such as the Arduino Uno. For the Arduino Uno specifically, we will use arduino-hal</code>. It is a batteries-included HAL for Arduino and similar boards. It is designed to abstract away the differences between boards as much as possible, so we can use a consistent API when working with different Arduino boards. </a> Development Setup</h2> I am using an Ubuntu-based Linux distribution. For other operating systems, or if these steps change in the future, refer to the avr-hal</code> repository</a> for the latest setup instructions. First, install the AVR development tools and the required system packages: sudo apt install avr-libc gcc-avr pkg-config avrdude libudev-dev build-essential</code></pre> We also need ravedude</code></a>, a CLI utility that makes Rust development for AVR microcontrollers easier. It wraps avrdude</code> for flashing and also provides access to the board’s serial console, similar to the Arduino IDE. cargo +stable install ravedude</code></pre> Finally, install cargo-generate</code></a>. It is a Cargo subcommand that allows us to create a new Rust project from an template. We will use it to create our Arduino Uno project from the avr-hal</code> template: cargo install cargo-generate</code></pre> The avr-hal</code> project currently uses the Rust nightly toolchain. Don’t worry about setting this up manually. The project template that we are going to use includes the required configuration, so we can simply use the template and let it take care of the Rust toolchain for us. With the required tools installed, we are ready to create our first Rust project for the Arduino Uno. </a> Creating the Project</h2> The avr-hal</code> project provides a template that sets up the required configuration for our Arduino Uno project. Run the following command: cargo generate --git https://github.com/Rahix/avr-hal-template.git</code></pre> The template will ask a few questions. Select Arduino Uno as the board and enter a name for your project. I will use “hello-blinky” as the project name. Once the project is created, move into it: # cd your-project-name cd hello-blinky</code></pre></a> Our First Rust Program</h2> The project template already gives us a simple LED blink program in src/main.rs</code>. We don’t need to change anything for now. #![no_std] #![no_main] use panic_halt as _; #[arduino_hal::entry] fn main() -> ! { let dp = arduino_hal::Peripherals::take().unwrap(); let pins = arduino_hal::pins!(dp); /* * For examples (and inspiration), head to * * https://github.com/Rahix/avr-hal/tree/main/examples * * NOTE: Not all examples were ported to all boards! There is a good chance though, that code * for a different board can be adapted for yours. The Arduino Uno currently has the most * examples available. */ let mut led = pins.d13.into_output(); loop { led.toggle(); arduino_hal::delay_ms(1000); } }</code></pre> The Arduino Uno has an onboard LED connected to pin 13. The program configures the pin 13 as an output and toggles it every second, making the LED blink. </a> Running the Project</h2> Let’s build and upload the program to the Arduino Uno: cargo run</code></pre> If ravedude</code> cannot automatically detect the serial port, we can find it manually. On Linux, run: ls /dev/ttyUSB* /dev/ttyACM*</code></pre> For my Arduino Uno clone, this shows /dev/ttyUSB0</code>. Your port may be different. Pass the detected port to ravedude</code> using the -P</code> option: cargo run -- -P "/dev/ttyUSB0"</code></pre> After the program is uploaded, the onboard LED should start blinking. </a> How Big Is the Rust Program?</h2> Now, let’s see how much space our Rust program actually uses. If we look at the generated files: ls -lh ./target/avr-none/debug/</code></pre> We can see that hello-blinky.elf</code> is around 70 KB: -rwxrwxr-x 2 user user 70K hello-blinky.elf</code></pre> At first, this looks like it would not fit into the Arduino Uno’s 32 KB flash memory. But the ELF file also contains debugging information and other data used during development, so it is not the actual firmware size. We can use the avr-size</code> command to check how much flash and SRAM our program uses: avr-size -C --mcu=atmega328p target/avr-none/debug/hello-blinky.elf</code></pre> For our program: AVR Memory Usage ---------------- Device: atmega328p Program: 262 bytes (0.8% Full) (.text + .data + .bootloader) Data: 1 bytes (0.0% Full) (.data + .bss + .noinit)</code></pre> So our program uses only 262 bytes of flash out of the Arduino Uno’s 32 KB. The 70 KB ELF file is not the actual firmware size. In Embedded Rust, cargo size</code> is also commonly used to check the size of a program. We can install the required LLVM tools with: rustup component add llvm-tools</code></pre> Then: cargo size</code></pre> text data bss dec hex filename 262 0 1 263 107 hello-blinky.elf</code></pre> The release mode build can help reduce the firmware size. You can build it with cargo build --release</code> (or run it with cargo run --release</code>). However, for this program, it didn’t make much difference. </a> More Examples</h2> The avr-hal</code> project has a collection of examples showing how to work with different peripherals and features. There is a separate set of examples for the Arduino Uno. You can find them in the avr-hal</code> examples</a> directory. </a> Final Thoughts</h2> So, can you use Rust with an Arduino Uno? Yes. We just did it, and our first Rust program used only 262 bytes of flash. The avr-hal</code> project does not seem to have much recent development activity, and it currently uses the nightly-2025-04-27</code> Rust toolchain. The project template uses the same nightly version. Because of this, tools such as Rust Analyzer can complain about the old toolchain, which makes development a little harder. I have only tried a simple blinky so far, so I still need to build some real applications and see how the experience goes. I bought the Uno mainly to experiment with Rust. Once again, if you want to see the better side of Embedded Rust, try the ESP32 family, Raspberry Pi Pico, or STM32. You should also explore the Embassy framework</a>. Embassy is an async runtime for embedded systems, using Rust’s async and await features.

impl Blog for Rust - avr-hal

Display Room Temperature on LCD with Arduino Uno and Rust

Can I Use Rust with Arduino Uno? Getting Started with Embedded Rust