Logic Level Converter: Safely Connecting 3.3 V and 5 V Devices

A logic level converter is a small circuit that lets a board running on 3.3 V (ESP32, Raspberry Pi Pico, ESP8266) talk safely to a board or module running on 5 V (Arduino Uno, I2C LCD, HC-SR04, WS2812B). Connecting a 5 V output straight to a 3.3 V pin can damage the pin slowly or instantly; in the other direction, a 3.3 V signal sometimes isn't even seen as a "1" by a 5 V input. Knowing when you need a converter, and which one is enough, removes the mysterious faults in half of all mixed-voltage projects.

In this article you'll first see what the VIH and VIL thresholds mean and why ESP32 and Pico pins can't take 5 V. Then we'll look at three solutions with examples: one-way conversion with a two-resistor voltage divider, a bidirectional BSS138 MOSFET converter for I2C, and 74HCT chips for fast signals such as WS2812B or SPI. At the end there's a table showing which modules work directly at 3.3 V, plus a list of common mistakes.

What are 3.3 V and 5 V logic levels?

A digital pin only knows 0 and 1, but in the real world the voltage can be anything between 0 and the supply. That's why every chip's datasheet gives four thresholds. VIH (input HIGH) is the lowest voltage the input is guaranteed to read as 1. VIL (input LOW) is the highest voltage guaranteed to read as 0. The region in between is undefined: the chip may read either 0 or 1 there. On the output side, VOH is the lowest voltage the pin guarantees when driving HIGH, and VOL the highest voltage it guarantees when driving LOW. For two chips to talk reliably, the sender's VOH must sit safely above the receiver's VIH, and the sender's VOL safely below the receiver's VIL. You can see how gates make decisions with these thresholds in the logic gates article and try them in the logic gate tool.

Three important conclusions come out of the table. First, a 5 V Uno's HIGH output (4.2–5 V) clearly exceeds the ESP32's 3.6 V and the Pico's 3.8 V limit, so in that direction conversion is a must. Second, the ESP32's 3.3 V HIGH output usually clears the Uno's 3.0 V VIH threshold, but the lowest VOH the datasheet guarantees is 2.64 V; so the connection often works but sits at the edge as the wire gets longer or the pin gets loaded. Third, a 74HC chip powered from 5 V, an I2C expander with a 0.7 × VCC threshold such as the PCF8574, or a WS2812B LED won't reliably count anything below 3.5 V as HIGH; for these chips a 3.3 V signal really isn't enough. The 74HCT series has a VIH of 2.0 V, which is why it's one of the cleanest ways to turn 3.3 V into 5 V.

Why can't ESP32 and Pico pins take 5 V?

Every input pin on a 3.3 V chip has small protection diodes that connect the pin to the 3.3 V rail and to GND. They're designed to absorb very short pulses such as static discharge, not continuous current. When you apply 5 V to the pin, the upper diode conducts and current flows from the 5 V source into the 3.3 V rail. If the source's internal resistance is low, that current reaches tens of milliamps and destroys the diode and the circuitry around the pin by heating them. If the current is smaller, the pin doesn't die right away, but the chip wears out over time, and the 3.3 V rail can even be pushed up so the board starts powering itself through the pin: you unplug the power cable and the ESP32's LED keeps glowing dimly. The ESP32 datasheet gives a pin limit of supply + 0.3 V (about 3.6 V), and the RP2040's supply + 0.5 V (about 3.8 V). "I tried it once and it didn't break" doesn't mean the pin is 5 V tolerant.

What do you need in which case?

One-way conversion with a voltage divider (5 V → 3.3 V)

The simplest way to bring a 5 V output into a 3.3 V input is two resistors. The signal enters through the top resistor R1, the midpoint goes to the 3.3 V pin, and the bottom resistor R2 goes to GND. The output is Vout = 5 V × R2 / (R1 + R2); making R2 twice R1 brings 5 V down to 3.33 V. A divider only works one way: from the higher voltage to the lower, so it can't be used on bidirectional lines where the 3.3 V side has to answer. Its speed is limited too, because the divider's output resistance forms a small RC filter with the pin's capacitance and rounds off the signal edges. Use the voltage divider calculator to pick values, and the voltage divider article for the full explanation.

Example: UART between an Arduino Uno and an ESP32

In projects where the Uno reads the sensors and the ESP32 carries the data to the internet over Wi-Fi, the two boards talk over UART. Because the Uno's TX line outputs 5 V, it goes to the ESP32's RX pin through a 1 kΩ + 2 kΩ divider. The ESP32's 3.3 V TX line can go straight to the Uno's RX pin, since the Uno treats anything above 3.0 V as HIGH. To keep the Uno's USB serial port (D0, D1) free for the computer, the Uno side uses SoftwareSerial on D10 and D11; on the ESP32, the second hardware serial port Serial2 runs on GPIO 16 (RX) and 17 (TX). The GNDs of the two boards must be connected together.

1// Arduino Uno: SoftwareSerial ile ESP32'ye veri gönder / send data to the ESP32 with SoftwareSerial
2// Uno D11 (TX, 5 V) -> 1k -> ESP32 GPIO 16 ; GPIO 16 -> 2k -> GND
3// ESP32 GPIO 17 (TX, 3,3 V) -> Uno D10 (RX) doğrudan / directly ; GND <-> GND
4#include <SoftwareSerial.h>
5
6SoftwareSerial link(10, 11);   // RX, TX
7
8void setup() {
9  Serial.begin(9600);          // bilgisayar / computer
10  link.begin(9600);            // ESP32 hattı / ESP32 line
11}
12
13void loop() {
14  int raw = analogRead(A0);
15  link.print(F("A0="));
16  link.println(raw);           // ör. / e.g. "A0=512"
17
18  unsigned long start = millis();
19  while (millis() - start < 1000) {          // 1 sn cevap bekle / wait 1 s for a reply
20    if (link.available()) {
21      String reply = link.readStringUntil('\n');
22      Serial.print(F("ESP32: "));
23      Serial.println(reply);
24    }
25  }
26}

1// ESP32: Serial2 ile Uno'dan gelen satırları oku ve cevap ver / read lines from the Uno on Serial2 and reply
2const int RX2_PIN = 16;        // bölücünün orta noktası / divider midpoint
3const int TX2_PIN = 17;        // Uno D10'a doğrudan / straight to Uno D10
4
5void setup() {
6  Serial.begin(115200);
7  Serial2.begin(9600, SERIAL_8N1, RX2_PIN, TX2_PIN);
8}
9
10void loop() {
11  if (Serial2.available()) {
12    String line = Serial2.readStringUntil('\n');
13    line.trim();
14    Serial.print("Uno: ");
15    Serial.println(line);
16    Serial2.print("OK ");      // 3,3 V çıkış Uno için yeterli / 3.3 V output is enough for the Uno
17    Serial2.println(line.length());
18  }
19}

Before uploading, measure the divider's midpoint with a multimeter: with the Uno running and not sending anything, you should see about 3.3 V, because a UART line idles HIGH. If the Uno's Serial Monitor shows a line such as "ESP32: OK 6" every second, communication is working in both directions. At 9600 baud one bit lasts 104 µs, while the delay introduced by the 1 kΩ + 2 kΩ divider is in the nanosecond range, so speed isn't a concern at all.

Example: connecting an HC-SR04 to a Raspberry Pi Pico

The HC-SR04 only works reliably on 5 V. If you power the Pico from USB, connect the sensor's VCC to the Pico's VBUS pin (pin 40). The TRIG input picks up the Pico's 3.3 V pulse without trouble, so it goes straight to GP15. ECHO, however, returns a 5 V pulse; a 1 kΩ resistor goes between ECHO and GP14, and a 2 kΩ resistor between GP14 and GND. The code measures the length of the ECHO pulse in microseconds with time_pulse_us and converts it to distance using the speed of sound in air (about 343 m/s).

1# Raspberry Pi Pico + HC-SR04 (ECHO bölücüyle) / Raspberry Pi Pico + HC-SR04 (ECHO through a divider)
2# VCC -> VBUS (pin 40), GND -> GND, TRIG -> GP15, ECHO -> 1k -> GP14 -> 2k -> GND
3from machine import Pin, time_pulse_us
4import time
5
6trig = Pin(15, Pin.OUT)
7echo = Pin(14, Pin.IN)
8
9
10def distance_cm():
11    trig.value(0)
12    time.sleep_us(2)
13    trig.value(1)                      # 10 µs tetik darbesi / 10 µs trigger pulse
14    time.sleep_us(10)
15    trig.value(0)
16    t = time_pulse_us(echo, 1, 30000)  # en fazla 30 ms bekle / wait at most 30 ms
17    if t < 0:
18        return None                    # yankı yok / no echo
19    return t * 0.0343 / 2              # gidiş-dönüş / round trip
20
21
22while True:
23    d = distance_cm()
24    if d is None:
25        print("Olcum yok / No echo")
26    else:
27        print("Mesafe / Distance: {:.1f} cm".format(d))
28    time.sleep(0.5)

The BSS138 bidirectional level converter

Most of the small boards sold as "4-channel logic level converters" have one BSS138 N-channel MOSFET and two 10 kΩ pull-up resistors per channel. The circuit is extremely simple: the MOSFET's gate is tied to 3.3 V (LV), its source goes to the low-voltage side and its drain to the high-voltage side. Each side's own pull-up resistor pulls the line up to that side's supply. This arrangement is designed for open-drain lines such as I2C, which only ever pull the line to 0 and leave the 1 level to the pull-up resistors, and it works in both directions on its own; there's no direction pin telling it which side is talking.

1. Both sides idle: The MOSFET's gate and source are both at 3.3 V, the voltage between them is zero and the MOSFET is off. Each side is pulled HIGH by its own resistor: the LV side to 3.3 V, the HV side to 5 V.
2. The 3.3 V side pulls LOW: The source drops to 0 V; since the gate stays at 3.3 V, the gate-source voltage becomes 3.3 V and the MOSFET turns on. The HV side is pulled LOW through the MOSFET.
3. The 5 V side pulls LOW: The body diode inside the MOSFET conducts and pulls the source down to about 0.7 V. Once the gate-source voltage reaches about 2.6 V, the MOSFET switches fully on and the LV side goes fully LOW as well.

Example: connecting an ESP32 to a 5 V I2C LCD

16x2 character LCDs don't give enough contrast unless they're powered from 5 V, and the PCF8574 I2C backpack on the back pulls SDA and SCL up to 5 V with 4.7 kΩ resistors. On top of that, the PCF8574's VIH threshold is 0.7 × VCC, which is 3.5 V at 5 V; the ESP32's 3.3 V falls below it. So using a BSS138 converter between the I2C LCD and the ESP32 both protects the pins and makes communication reliable. Wire it like this: the ESP32's 3V3 pin to LV, its VIN pin (5 V from USB) to HV and to the LCD's VCC, all GNDs together; GPIO 21 to LV1 and HV1 to the LCD's SDA; GPIO 22 to LV2 and HV2 to the LCD's SCL. If the scanner code below finds the LCD (usually at 0x27 or 0x3F), the converter is working.

1// ESP32 I2C tarayıcı: BSS138 dönüştürücü üzerinden 5 V'luk cihazları bul
2// ESP32 I2C scanner: find 5 V devices through a BSS138 converter
3// GPIO 21 -> LV1 / HV1 -> SDA ; GPIO 22 -> LV2 / HV2 -> SCL ; 3V3 -> LV ; VIN (5 V) -> HV
4#include <Wire.h>
5
6const int SDA_PIN = 21;
7const int SCL_PIN = 22;
8
9void setup() {
10  Serial.begin(115200);
11  Wire.begin(SDA_PIN, SCL_PIN);
12  Wire.setClock(100000);       // 100 kHz, BSS138 için rahat hız / comfortable speed for the BSS138
13}
14
15void loop() {
16  int found = 0;
17  for (byte addr = 1; addr < 127; addr++) {
18    Wire.beginTransmission(addr);
19    if (Wire.endTransmission() == 0) {      // 0 = ACK, cihaz var / device present
20      Serial.printf("Cihaz / Device: 0x%02X\n", addr);
21      found++;
22    }
23  }
24  if (found == 0) Serial.println("Cihaz yok / No device found");
25  Serial.println("---");
26  delay(3000);
27}

74HCT chips: fast one-way signals

When a divider or a BSS138 is too slow, the professional solution is a buffer chip. The 74HCT series runs on 5 V but its input threshold is TTL-compatible (VIH = 2.0 V), so it easily sees the 3.3 V signal from an ESP32 or Pico as HIGH and outputs a full 5 V signal with sharp edges. The most common use is the data line of WS2812B strips: the ESP32 pin goes to the input of a 74AHCT125, and its output goes through a 330 Ω resistor to the strip's DIN; the 74AHCT125's OE (enable) pin is tied to GND. For the opposite direction, bringing a fast 5 V signal down to 3.3 V, you use a 74LVC125 or 74LVC245 powered from 3.3 V; the inputs of these chips tolerate up to 5.5 V regardless of their own supply.

Which modules work directly at 3.3 V?

The table below sums up whether the modules most often used in ESP32 and Pico projects can connect to a 3.3 V board without a converter. You can power the "Yes" modules from the 3V3 pin and wire their signal pins directly. Still, modules sold under the same name can come in different versions; check whether the board has a regulator or level shifter, and if you're unsure, measure the voltage on the signal pin with a multimeter while VCC is on.

Common mistakes and how to fix them

Logic level conversion may sound technical, but it comes down to three rules: always protect a line going from 5 V to 3.3 V, check the receiver's VIH threshold on a line going from 3.3 V to 5 V, and use a BSS138 on bidirectional lines such as I2C. With these rules you can comfortably combine an Arduino, an ESP32 and a Pico in the same project. In the BlueGrays app, every connection in the ESP32 and Raspberry Pi Pico projects is explained with pins that match the board's logic level and a step-by-step wiring diagram.