There's one important difference: the Arduino Uno R3 uses 5V logic, while the ESP32 uses 3.3V logic. Connect a 5V signal directly to an ESP32 GPIO pin, and you risk damaging the microcontroller. Go the other way, though, and a 3.3V signal might work perfectly well with the 5V Arduino.

Why is that?

The answer lies in logic voltage thresholds, which determine how a microcontroller interprets a digital signal. In this tutorial, we'll look at how 3.3V and 5V logic work and when you can connect devices directly. We'll also cover when you need a voltage divider, a buffer, or a logic level translator. Then we'll wire a simple circuit that lets a 5V Arduino Uno safely send digital signals to an ESP32.

What Are Logic Levels?

Microcontrollers communicate using binary signals: a digital pin represents either logic LOW (0) or logic HIGH (1). Ideally, LOW sits at 0V and HIGH sits at the logic supply voltage: about 5V in a 5V system or 3.3V in a 3.3V system.

In practice, a digital input doesn't need an exact voltage to recognize either state. The 5V Arduino Uno R3, for example, accepts voltages well below 5V as a valid HIGH. Likewise, a LOW doesn't have to be exactly 0V. Every digital input has two specifications that define these ranges:

• V_IH (Input HIGH Voltage): The minimum input voltage guaranteed to register as HIGH.
• V_IL (Input LOW Voltage): The maximum input voltage guaranteed to register as LOW.

Any voltage between these two limits falls into an undefined region. The microcontroller might read it as HIGH or LOW, and the result can change from one moment to the next. A signal that lingers there can also make a CMOS input draw extra current, because both transistors in its input stage partly conduct.

Some inputs, including the ATmega328P's standard I/O pins, pass the signal through a Schmitt trigger. A Schmitt trigger adds hysteresis: its rising threshold sits slightly above its falling threshold. As a result, small amounts of noise on a slow edge don't make the input toggle repeatedly.

Inputs are only half the story, though. Every digital output also has two specifications:

• V_OH (Output HIGH Voltage): The minimum voltage the output guarantees when driving HIGH.
• V_OL (Output LOW Voltage): The maximum voltage the output guarantees when driving LOW.

A connection works reliably when the sender's output levels land inside the receiver's guaranteed input ranges. The gap between them is called the noise margin, and each logic state has one:

$NM_H = V_{OH} - V_{IH}$

$NM_L = V_{IL} - V_{OL}$

A positive noise margin means the receiver should read the signal correctly, with some room left over for noise. A negative margin means the datasheets don't guarantee the connection, even if it seems to work on your bench.

Logic Voltage Thresholds of Arduino Uno and ESP32

To make these numbers concrete, let's compare the ATmega328P used by the Arduino Uno R3 with the ESP32. The table below lists the key parameters for each chip at its nominal supply voltage.

Note that the output values include test currents. Most logic connections draw far less current than these test conditions, so a real output typically sits much closer to its supply rail or ground. These values also apply only to these two microcontrollers. Other Arduino boards, ESP32 variants, and external devices may have different specifications.

Now look at the Arduino's 3.0V HIGH threshold. A 3.3V signal clears it, which explains why many 3.3V sensors work directly with 5V Arduino boards. We'll come back to why that isn't the whole story, but first, let's look at the more dangerous direction.

Can You Connect a 5V Signal Directly to a 3.3V Microcontroller?

For an ESP32, the answer is no. Its GPIO pins aren't 5V tolerant. Espressif limits input-pin voltage to VDD + 0.3V, which is 3.6V on a 3.3V supply.

That ceiling moves with the supply voltage. Espressif allows VDD anywhere from 3.0V to 3.6V, so on a board whose regulator runs at 3.0V, the limit drops to 3.3V. A 5V signal exceeds the limit anywhere in that range.

A common mistake is assuming the ESP32 can tolerate 5V because its development board has a 5V or VIN power input. But a power input and a GPIO pin are different things. Many ESP32 development boards include a voltage regulator that converts the external supply down to 3.3V for the microcontroller. That regulator protects the chip's supply, not its GPIO pins.

What Happens Inside the Pin?

Like most CMOS chips, the ESP32 protects its pins against electrostatic discharge (ESD). These protection structures typically behave like two diodes per pin. One runs from the pin up to the 3.3V supply rail, and the other runs from ground up to the pin.

During normal operation, both diodes stay reverse-biased and carry no current. Apply 5V to the pin, though, and the upper diode turns on once the pin rises about 0.6V above the rail. Current then flows from the 5V source into the chip's 3.3V supply:

With a direct wire, only the resistance of the source and wiring limits this current, so it can be large. Excess current can damage the diode or the pin. It can also lift the 3.3V rail, because most voltage regulators can source current but can't sink it. In the worst case, injected current can trigger latch-up, a parasitic short between the supply and ground that can destroy the chip.

Even if an ESP32 appears to work after receiving a 5V signal, that doesn't make the connection safe. Damage can build up gradually, and erratic behavior may only appear later. The same caution applies to other 3.3V microcontrollers, although individual tolerances vary.

Do You Need a Level Shifter for 3.3V to 5V Signals?

In the other direction, the answer is often no, but it's worth checking. A 3.3V output can't push a 5V input beyond its rating, so safety isn't the concern. The question is whether the receiver will reliably read the signal as HIGH.

This is where noise margins come in. For an ESP32 output driving an Arduino Uno input, the datasheet values give:

$NM_H = 2.64V - 3.0V = -0.36V$

$NM_L = 1.5V - 0.33V = 1.17V$

The LOW side has plenty of room. The HIGH side has a negative margin, so the datasheets don't guarantee that the Arduino will read the ESP32's HIGH.

That 2.64V minimum assumes the pin sources up to 40 mA, however. A logic input draws almost no current, so in practice, the ESP32's output usually sits close to 3.3V. That's why the link typically works on the bench.

Even then, a margin of about 0.3V is thin for a permanent design. A buffer that drives a full 5V removes the doubt, as we'll see in Method 3.

TTL vs. CMOS Input Levels

Not every 5V input uses the same thresholds, so the answer also depends on the receiving device. Older TTL logic, and modern parts with TTL-compatible inputs, recognize anything above 2.0V as HIGH and anything below 0.8V as LOW. A 3.3V output clears those levels easily.

Many 5V CMOS parts, on the other hand, scale their thresholds with the supply. A typical 5V CMOS input needs 0.7 × VCC, or 3.5V, to register a HIGH, which a 3.3V output can't reach. The ATmega328P sits between the two, at 0.6 × VCC.

Part names often hint at the input type. In the 74-series logic families, a "T" in the family name, as in HCT or AHCT, usually marks TTL-compatible inputs. When the receiver needs more than a 3.3V output can deliver, use a translator that actively drives the signal up to 5V.

Fortunately, there are several ways to connect different logic voltages safely, in either direction. We'll start with one-directional methods and then move on to bidirectional ones.

Method 1: Using a Resistor Voltage Divider

To send a signal from a 5V output to a 3.3V input, a resistor voltage divider is one of the simplest solutions. Two resistors in series split the input voltage, and the receiver reads the voltage at their junction:

The voltage at the junction between R1 and R2 is:

$V_{out} = \frac{V_{in} \times R_2}{R_1 + R_2}$

We don't need exactly 3.3V. A target of about 3.0V sits between the ESP32's 2.475V HIGH threshold and its 3.6V limit. A 2.2 kΩ and 3.3 kΩ pair gets us there:

• R1 = 2.2 kΩ
• R2 = 3.3 kΩ
• Vin = 5V

$V_{out} = \frac{5V \times 3.3\,k\Omega}{2.2\,k\Omega + 3.3\,k\Omega} = 3.0V$

When the Arduino output goes LOW, the divider output also falls to about 0V. With the output HIGH, the divider draws about 0.91 mA, a trivial load for an Arduino pin.

Checking the Worst Case

The 3.0V result assumes a perfect 5V supply and perfect resistors. Real parts vary, so it's worth checking how low and how high the junction voltage can go. Two variations matter most:

• Resistor tolerance: Common 5% resistors can sit anywhere within ±5% of their marked value.
• Supply voltage: USB ports typically supply 4.75V to 5.25V, and the Uno's input protection drops a little more. On a weak port or a long cable, the Uno's 5V rail can sag to around 4.5V.

The low corner pairs the lowest supply with R1 at its highest value and R2 at its lowest. The high corner does the opposite:

With 5% resistors, the low corner clears the ESP32's 2.475V threshold by only about 0.12V. That margin also assumes the ESP32 runs at exactly 3.3V. If its rail runs at 3.6V instead, V_IH rises to 2.7V, and the 5% low corner falls short.

Switching to 1% resistors widens the low-corner margin to about 0.2V at a 3.3V ESP32 supply. Both high corners also stay below 3.3V, so they remain within the ESP32's input limit even if its supply runs as low as 3.0V.

When Is a Voltage Divider Appropriate?

A divider works well for slow, one-directional digital signals, such as a status line, a button-state output, or a UART transmit line.

Its speed limit comes from capacitance. The ESP32's input pin, the breadboard, and the wiring all add capacitance at the junction. From the input's point of view, the divider acts like a single resistor equal to R1 and R2 in parallel, called the Thevenin resistance:

$R_{TH} = \frac{R_1 \times R_2}{R_1 + R_2} = \frac{2.2\,k\Omega \times 3.3\,k\Omega}{5.5\,k\Omega} = 1.32\,k\Omega$

That resistance and the junction capacitance form an RC circuit. Assuming about 15 pF of combined pin and breadboard capacitance, the time constant is:

$\tau = R_{TH} \times C = 1.32\,k\Omega \times 15\,pF \approx 20\,ns$

The 10%-to-90% rise time is about 2.2 time constants, or roughly 44 ns. For comparison, one bit at 115200 baud lasts about 8.7 µs, so the edges barely register. At a 10 MHz SPI clock, though, each half-cycle lasts only 50 ns, and the slow edge would consume most of it.

The resistor values set the trade-off. Smaller resistors give faster edges but draw more current from the 5V output. Larger ones, such as 22 kΩ and 33 kΩ, save current but make the edges ten times slower.

A divider also can't raise a 3.3V signal to 5V; it can only reduce voltage. For faster signals, or for the opposite direction, you'll need an active circuit.

Method 2: Using a 5V-Tolerant Buffer (5V to 3.3V)

When a 5V signal switches too fast for a divider, a logic buffer powered from 3.3V can take its place. Some 3.3V logic families have 5V-tolerant inputs, which accept up to 5.5V even when the chip runs from 3.3V. The 74LVC125A quad buffer, available from manufacturers including Texas Instruments and Nexperia, is a common example.

The buffer's inputs read the 5V signal, and its push-pull outputs drive a clean 0V-to-3.3V signal into the ESP32. Unlike a divider, the buffer doesn't rely on resistors to set its output level, so its edges stay sharp at much higher speeds. Like the divider, though, it only works in one direction, from 5V down to 3.3V.

Method 3: Using a 5V Logic Buffer (3.3V to 5V)

Method 3 mirrors Method 2. When a 5V device needs a full 5V HIGH from a 3.3V source, a buffer powered from 5V does the job. The 74AHCT125, for example, has TTL-compatible inputs that recognize 2V as HIGH, yet its outputs swing up to its 5V supply.

It also works in only one direction, from 3.3V to 5V, but it's simple, fast, and inexpensive. Many makers use it to drive 5V peripherals, such as addressable LED strips, from 3.3V microcontrollers.

Together, Methods 2 and 3 handle both directions with push-pull buffers, as long as each signal travels only one way. Bidirectional signals need a different approach.

Method 4: Using a MOSFET Logic Level Shifter

When a single line carries data in both directions, none of the methods so far will do. One of the most common solutions is a small module based on BSS138 N-channel MOSFETs. It translates signals either way without a direction-control pin.

How the BSS138 Circuit Works

Each channel uses one MOSFET and two pull-up resistors, one on each side. The MOSFET's gate connects to the low-voltage supply, its source to the low-voltage signal, and its drain to the high-voltage signal.

The circuit has three states:

• Neither side pulls LOW: The source sits at 3.3V, the same as the gate, so the MOSFET stays off. Each pull-up holds its own side at its own rail: 3.3V on the low side and 5V on the high side.
• The low-voltage device pulls LOW: The source drops to 0V, giving a 3.3V gate-source voltage. The MOSFET turns on and pulls the high-voltage side LOW too.
• The high-voltage device pulls LOW: The MOSFET's internal body diode conducts first, pulling the source down to about 0.6V. That raises the gate-source voltage enough to turn the MOSFET fully on, and the low side follows to near 0V.

When the device releases the line, the pull-ups bring both sides back to their rails, and the MOSFET switches off again. Because the circuit only ever pulls lines LOW, it particularly suits open-drain buses such as I2C.

These modules typically have four channels, with connections labeled:

• HV: Higher-voltage supply, commonly 5V
• LV: Lower-voltage supply, commonly 3.3V
• GND: Common ground
• HV1–HV4: High-voltage signal connections
• LV1–LV4: Low-voltage signal connections

Speed Limits of the BSS138 Module

The BSS138 module isn’t a universal solution, though. Every rising edge comes from a pull-up resistor charging the line’s capacitance, and many of these modules use 10 kΩ pull-ups. On the module pictured earlier, for example, the resistors carry the marking “01C”, the EIA-96 code for 10.0 kΩ. The I2C specification measures rise time between 30% and 70% of the supply voltage:

$t_r = 0.8473 \times R \times C$

With 10 kΩ pull-ups and a 50 pF bus, the rise time is about 424 ns. That fits within I2C Standard-mode's 1000 ns limit at 100 kHz. However, it exceeds Fast-mode's 300 ns limit at 400 kHz, so Fast-mode buses may need stronger, lower-value pull-ups.

Pull-ups also combine in parallel. If a sensor module already has its own 10 kΩ pull-ups, the effective resistance on that side drops to 5 kΩ. Stronger pull-ups speed up the edges, but they also increase the current each device must sink to pull the line LOW.

The same pull-up dependence makes the module a poor fit for fast push-pull signals, such as SPI clocks. A push-pull driver on the low side pulls the high side LOW through the MOSFET quickly. Its rising edge, however, still depends on the slow pull-up.

Method 5: Using a Dedicated Logic Level Translator IC

Where signal timing and reliability matter, a dedicated translator IC is often the better choice. The right part depends on the type of signal:

• TXS0108E (Texas Instruments): An eight-channel, auto-direction translator that supports both open-drain and push-pull signals within its specified operating conditions.
• PCA9306 (Texas Instruments): Designed specifically for bidirectional I2C and SMBus translation.
• SN74LVC8T245 (Texas Instruments): An eight-bit, dual-supply translator for push-pull signals. A single direction-control (DIR) pin sets all eight channels at once.
• SN74LVC1T45 (Texas Instruments): A single-bit, dual-supply translator with its own DIR pin, useful for a lone signal that travels the other way.

Choose a translator based on the signal type, not because a module is advertised as "3.3V to 5V compatible." A translator designed for I2C might not work reliably on a fast SPI bus, even though both carry the same HIGH and LOW levels.

Practical Notes on TXS0108E Modules

TXS0108E breakout boards are popular, but they come with a few requirements that often catch first-time users:

• Supply order: VCCA, the A-side supply, must not exceed VCCB, and it must not exceed 3.6V. Connect 3.3V to VCCA and 5V to VCCB, not the other way around.
• Output enable: The OE pin uses VCCA as its reference, and pulling it LOW puts every output in a high-impedance state. Drive OE HIGH, to 3.3V, to enable translation, and check whether your module already pulls it up or down.
• Look-alike parts: TXB0108 modules look almost identical but are intended for push-pull signals. They generally don't work reliably with I2C pull-up resistors.
• Loading: The TXS0108E uses edge accelerators that briefly boost each transition. Heavy capacitive loads or strong external pull-ups can confuse them, so keep the wiring short.

Practical Example: Sending a 5V Arduino Signal to an ESP32

Let's put the voltage divider to use. We'll connect an Arduino Uno R3 to an ESP32 development board. The Arduino will toggle a digital output every 500 milliseconds, and the ESP32 will read that signal.

Components Needed

• Arduino Uno R3
• ESP32 development board
• 2.2 kΩ resistor (1% tolerance recommended)
• 3.3 kΩ resistor (1% tolerance recommended)
• Breadboard
• Jumper wires
• USB cables
• Multimeter (recommended)
• Optional, for the return path: 74AHCT125 buffer, 0.1 µF capacitor, and 10 kΩ resistor

Choosing the Pins

We'll use digital pin 8 on the Arduino and GPIO18 on the ESP32. GPIO18 is a general-purpose pin with no special role during boot, which makes it a safe choice. When you adapt this circuit, avoid these ESP32 pins:

• Strapping pins (GPIO0, GPIO2, GPIO5, GPIO12, and GPIO15): The ESP32 samples these pins at reset to choose its boot mode and settings, so an external signal can change those settings. For example, a HIGH on GPIO12 at boot selects a 1.8V flash supply. That setting stops modules with 3.3V flash, such as the ESP32-WROOM-32, from booting.
• GPIO6 to GPIO11: On most modules, these pins connect to the internal SPI flash.

Wiring Diagram

Wire the divider between the two boards as follows:

The Arduino and ESP32 must share a common ground so they have the same voltage reference. Power each board through its own USB port, and don't connect their 5V and 3.3V rails together.

R2 also does a second job. While the Uno resets, its pins switch to high-impedance inputs, so D8 stops driving the divider. R2 then pulls GPIO18 to GND, and the ESP32 reads a clean LOW instead of a floating input.

Wire everything except the connection to GPIO18 for now. We'll check the divider output before it reaches the ESP32.

Arduino Code

Upload the following sketch to the Arduino Uno:

const int signalPin = 8;

void setup() {
  pinMode(signalPin, OUTPUT);
  digitalWrite(signalPin, LOW);
}

void loop() {
  digitalWrite(signalPin, HIGH);
  delay(500);

  digitalWrite(signalPin, LOW);
  delay(500);
}

Inside setup(), we configure pin 8 as an output. Then loop() alternates it between HIGH and LOW at half-second intervals.

When HIGH, D8 outputs close to 5V, and the divider delivers about 3.0V. When LOW, both sides measure close to 0V.

Checking the Divider with a Multimeter

Before connecting the divider to GPIO18, confirm its output voltage with a multimeter. A quick measurement catches wiring mistakes before 5V reaches the ESP32.

A toggling signal is hard to read on a multimeter, so first upload this short test sketch, which holds D8 HIGH:

void setup() {
  pinMode(8, OUTPUT);
  digitalWrite(8, HIGH);
}

void loop() {
}

Then measure between the junction of R1 and R2 and GND. The reading tells you whether the wiring is correct:

Once the reading is correct, re-upload the toggling sketch and connect the junction to GPIO18.

ESP32 Code

Next, upload this sketch to the ESP32 using the Arduino IDE. If you haven't set up the IDE for the ESP32 yet, install the "esp32" board package by Espressif through the Boards Manager. Then select your board; "ESP32 Dev Module" works for most DevKitC-style boards.

const int inputPin = 18;
int previousState = -1;

void setup() {
  Serial.begin(115200);
  pinMode(inputPin, INPUT);
}

void loop() {
  int currentState = digitalRead(inputPin);

  if (currentState != previousState) {
    Serial.print("Signal: ");

    if (currentState == HIGH) {
      Serial.println("HIGH");
    } else {
      Serial.println("LOW");
    }

    previousState = currentState;
  }

  delay(10);
}

Here, digitalRead() checks the voltage level at GPIO18 and returns HIGH or LOW. The sketch prints a message only when the input changes state, which makes the transitions easy to follow. The pin uses plain INPUT mode because R2 already acts as a pull-down.

With both boards running, open the Serial Monitor at 115200 baud. It should show:

Signal: HIGH
Signal: LOW
Signal: HIGH
Signal: LOW

The first line depends on which state the signal is in when the ESP32 starts.

Viewing the Signal on an Oscilloscope

If you have an oscilloscope, compare the waveforms before and after the divider. At this slow toggle rate, the two waveforms look nearly identical apart from their amplitudes. Zoom into a rising edge, though, and you can see the RC effect described in Method 1.

Keep in mind that the scope probe adds its own capacitance, typically around 10 pF for a 10× probe. The measured edge will therefore look slightly slower than the edge the ESP32 sees without the probe.

Going Further: Sending a Signal Back to the Arduino

So far, the example covers only the 5V-to-3.3V direction. To send a signal back, you could rely on the ESP32's output clearing the Uno's 3.0V threshold. For a guaranteed connection, though, add a 74AHCT125 buffer from Method 3 to the same breadboard:

The 10 kΩ resistor holds the buffer's input LOW while the ESP32 boots and GPIO19 floats.

Upload this sketch to the ESP32 to toggle GPIO19:

const int outputPin = 19;

void setup() {
  pinMode(outputPin, OUTPUT);
}

void loop() {
  digitalWrite(outputPin, HIGH);
  delay(500);

  digitalWrite(outputPin, LOW);
  delay(500);
}

Then upload this sketch to the Arduino to read D7:

const int inputPin = 7;
int previousState = -1;

void setup() {
  Serial.begin(9600);
  pinMode(inputPin, INPUT);
}

void loop() {
  int currentState = digitalRead(inputPin);

  if (currentState != previousState) {
    Serial.print("Signal: ");

    if (currentState == HIGH) {
      Serial.println("HIGH");
    } else {
      Serial.println("LOW");
    }

    previousState = currentState;
  }

  delay(10);
}

Open the Serial Monitor at 9600 baud, and you should see the same alternating HIGH and LOW messages. This time, the buffer drives D7 with a full 5V HIGH, so the connection no longer depends on the ESP32's output voltage.

Logic Level Shifting for UART, I2C, and SPI

So far, we've looked at single digital signals. The same principles apply to communication buses, but the right circuit depends on how each interface drives its lines.

UART: Consider Each Direction Separately

UART uses two signal lines, TX and RX, with each device's TX connected to the other's RX. Between an Arduino Uno R3 and an ESP32, that gives two paths with different needs:

The Arduino-to-ESP32 path always needs level shifting. The ESP32-to-Arduino path often works directly, subject to the noise-margin caveat above.

For the Arduino TX line, the rise-time estimate from Method 1 shows that a divider handles 115200 baud comfortably. At higher baud rates, or with long wires in a noisy environment, a buffer or translator becomes more important.

I2C: Watch the Pull-Up Resistors

I2C works differently. Its SDA and SCL lines are open-drain: devices pull the lines LOW, and pull-up resistors bring them HIGH. That makes the pull-up voltage critical.

Imagine connecting a 3.3V ESP32 to a sensor module powered by 5V. If the module's onboard pull-ups connect to 5V, SDA and SCL idle at 5V. That voltage reaches the ESP32's pins before any data is exchanged.

A bidirectional I2C translator, such as a BSS138 module or a PCA9306-based circuit, separates the two voltage domains. Its low-voltage side uses pull-ups to 3.3V, and its high-voltage side uses pull-ups to 5V. For Fast-mode I2C at 400 kHz, revisit the rise-time check from Method 4.

Direct 3.3V I2C is sometimes possible, provided every device's input thresholds, the pull-up voltage, and the pin ratings allow it. Check the module's actual schematic rather than relying on its advertised operating voltage.

For more on the protocol itself, see our I2C primer.

SPI: Speed and Direction Matter

SPI uses push-pull drivers for its clock and data lines and doesn't rely on pull-up resistors to create HIGH levels. That matters when choosing a level shifter. A BSS138 module might handle slow SPI signals, but its resistive rising edges distort faster ones.

Consider a 5V Arduino controlling a 3.3V SPI peripheral. SCK, MOSI, and chip select (CS) travel from the Arduino to the peripheral and need translating down. MISO travels the other way, so it needs its own path:

The SN74LVC8T245 uses a single DIR pin for all eight channels, so one chip can't carry MOSI and MISO in opposite directions. Tie its DIR pin for the outbound lines, and give MISO a separate translator, such as an SN74LVC1T45 or one channel of a 74AHCT125.

If other devices share the Arduino's MISO line, the MISO buffer must release the line when its peripheral isn't selected. With a 74AHCT125, connect the buffer's OE pin to the peripheral's active-low CS line. The buffer then drives MISO only while that peripheral is selected.

If you're new to SPI, see our SPI protocol tutorial.

Common Mistakes When Connecting 3.3V and 5V Devices

Most mixed-voltage problems trace back to a handful of recurring mistakes:

1. Assuming a 5V power input means 5V-tolerant GPIO: A development board can accept 5V through a regulator while its microcontroller runs at 3.3V. Always distinguish power-input ratings from GPIO limits.
2. Ignoring pull-up resistors already on sensor modules: Many I2C breakouts include onboard pull-ups tied to the module's supply voltage. Inspect the board before connecting it to a 3.3V microcontroller.
3. Forgetting the common ground: Two separately powered devices need a shared ground for direct, non-isolated logic signals. Without it, the receiver may see unpredictable voltages.
4. Using the same level shifter for every protocol: A BSS138 module suits I2C but not high-speed SPI. The right choice depends on signal direction, output type, speed, and capacitive loading.
5. Back-powering an unpowered device: If one board is powered and the other isn't, a HIGH signal can feed current into the unpowered chip through its protection diodes. For permanent designs where this can happen, choose a translator with powered-off isolation.
6. Enabling INPUT_PULLUP on the 5V side: The Uno's internal pull-ups connect to 5V. On a pin that receives an ESP32 signal, a pull-up can lift the line toward 5V whenever the ESP32's pin floats, such as during boot. Use plain INPUT mode instead.
7. Wiring signals to ESP32 strapping pins: An external signal on GPIO0, GPIO2, GPIO5, GPIO12, or GPIO15 can change how the ESP32 boots. Use general-purpose pins such as GPIO18 or GPIO19 instead.
8. Assuming a working circuit is electrically safe: A microcontroller might tolerate an incorrect connection for a while. That doesn't mean the voltage is within its specified limits.

How to Choose the Right Level Shifting Method

The decision comes down to three questions: Which device is transmitting? Which device is receiving? And what voltages can each pin safely produce or accept? The flow below walks through the common cases:

The table below summarizes the same choices by application:

Whichever method you choose, check both the HIGH and LOW noise margins and confirm that no pin sees more than its rated voltage.

Frequently Asked Questions

Here are answers to questions that often come up when mixing 3.3V and 5V devices.

Are ESP32 GPIO pins 5V tolerant?

No. Espressif limits the original ESP32's GPIO inputs to VDD + 0.3V, which is 3.6V on a 3.3V supply. Reduce or translate any 5V signal before it reaches an ESP32 GPIO.

Can I just use a series resistor instead of a divider?

A series resistor limits the current through the pin's protection diode, but it doesn't keep the pin within its rated voltage. Espressif doesn't specify a safe injection current for the ESP32, so a divider or buffer is the safer choice.

Does this apply to other ESP32 variants?

Generally, yes. Espressif's later chips, such as the ESP32-S2, also run 3.3V I/O and list a similar VDD + 0.3V input limit. Check the datasheet for your specific chip.

Can I connect a 3.3V sensor to an Arduino Uno?

Often, but not always. Check the sensor's output HIGH voltage against the Arduino's input thresholds. Also check whether any signal from the Arduino could expose the sensor to 5V.

Can a voltage divider convert 3.3V to 5V?

No. A resistor divider can only reduce voltage. To produce a 5V HIGH from a 3.3V signal, use a buffer or level translator.

Can I power a 3.3V sensor from an Arduino's 3.3V pin?

Only if the pin can supply enough current. The Arduino Uno R3's 3.3V pin is rated for 50 mA. Also remember that powering a sensor at 3.3V doesn't make its signal lines safe if they have pull-ups to 5V.

Do I always need a logic level converter for I2C?

No. If every device on the bus has compatible input thresholds and the pull-up voltage stays within every device's rating, a direct connection may be fine. For mixed 3.3V and 5V buses with incompatible requirements, a dedicated I2C level translator is the safer choice.

Conclusion

Connecting 3.3V and 5V devices isn't difficult once you understand that a digital HIGH doesn't have a universal voltage.

A 5V microcontroller may recognize a 3.3V signal as HIGH, depending on its input threshold and the sender's output voltage. In the opposite direction, a 5V output can exceed the safe input voltage of a 3.3V device such as the ESP32.

A resistor divider is often an inexpensive solution for simple one-directional signals, as long as you check its worst-case output. Faster one-way signals call for a buffer powered from the right supply, which keeps edges sharp. For bidirectional buses like I2C or mixed-direction interfaces like SPI, choose a translator designed for that signal type.

Most importantly, check the datasheet before connecting two different voltage domains. With the four threshold values and a quick noise-margin check, you can mix 3.3V and 5V parts confidently in any project.

References

• Arduino Uno Rev3 documentation and specifications
• Microchip ATmega328P product page (datasheet: "DC Characteristics" table)
• Espressif ESP32 Series Datasheet ("DC Characteristics (3.3 V, 25 °C)" table)
• NXP UM10204 I2C-bus Specification and User Manual
• Texas Instruments PCA9306 I2C Level Translator
• Texas Instruments TXS0108E Voltage Translator
• Texas Instruments SN74LVC8T245 Bus Transceiver
• Texas Instruments SN74LVC1T45 Single-Bit Transceiver
• Texas Instruments SN74LVC125A Buffer
• Texas Instruments SN74AHCT125 Buffer

The post 3.3V vs 5V Logic Levels: When Do You Need a Level Shifter? appeared first on Teach Me Microcontrollers!.

6 in 10 (62%) people did a DIY move. Almost 4 in 10 (38%) used a professional mover.

So when you ask what moving companies offer, you are really asking, “How much stress are they taking off my plate?” A clear moving company service list helps protect your money, your belongings, and, honestly, your nerves.

Essential Professional Moving Company Services for Every Move

Once you understand why the right mover matters, the next step is knowing what a reliable company should actually provide. At minimum, the basics should be clear, practical, and easy to compare.

If you want to compare verified packers and movers without calling five different companies, BookMyMove lets you review prices, check available services, and book online in one place.

Door-to-Door Residential Moving Services

For most people, the real test is a home move. Good residential moving services should cover packing, loading, transport, unloading, and unpacking.

The better crews also bring the right packing supplies, protect fragile pieces, and place boxes in the correct rooms. That may sound small now. But after a long moving day, you will be grateful when the kitchen boxes are actually in the kitchen.

Commercial Moving Company Services for Businesses

Business moves come with different pressures. You are not just moving desks; you are protecting time, data, equipment, and workflow. Strong commercial moving company services should include office furniture, IT equipment, files, records, and careful scheduling.

A professional business mover may offer evening or weekend moves to reduce downtime. They should also understand high-rise rules, shared office buildings, warehouses, and secure handling for sensitive documents.

Specialty Moving Solutions

Some items need more than muscle. Pianos, antiques, fine art, safes, and large equipment require special handling, proper tools, trained movers, and the right vehicle setup.

Before booking, ask about crating, padding, lifting equipment, and valuation coverage. Once you know your mover can handle the unusual items, you can look at the bigger picture.

Full Moving Company Service List: More Than Just Transport

A moving company is not just a truck and two people with dollies. Today, a complete moving company service list should explain what happens before, during, and after moving day.

Secure Packing and Unpacking Services

A lot of damage starts before anything reaches the truck. Poor packing is often the culprit. Ask whether the mover offers full-service packing, partial packing, or fragile-only packing.

Some companies also use reusable crates, recyclable packing materials, and digital inventories. Unpacking may be as simple as opening boxes, or it may include item placement and debris removal, depending on the package.

Furniture Disassembly and Assembly

Beds, sectionals, desks, and modular furniture can turn moving day into a puzzle. Professional movers should label hardware, wrap surfaces, and reassemble everything properly at the new location.

This is especially useful for smart home equipment, mounted screens, or complex office furniture. Nobody wants to end the day staring at extra screws and wondering where they came from.

Loading, Storage, and Protection Plans

After packing, the risk shifts to loading, transport, and unloading. Good movers use clean trucks, straps, padding, item checks, and tracking tools when available.

If your closing date, lease start, or office handover does not line up, storage can save you. Storage answers, “Where does everything go?” Protection plans answer, “What happens if something gets damaged?”

Modern Add-On Services Worth Asking About

Once the basics are covered, add-on services can make the move easier, clearer, and better timed.

The moving services market size was valued at USD 110.97 billion in 2025 and estimated to grow to reach USD 150.16 billion by 2031, at a CAGR of 5.17% during the forecast period (2026-2031).

Virtual Moving Consultations and Quotes

Accurate pricing starts with a good estimate. Many movers now offer video surveys, where you walk through your home on camera and show furniture, boxes, stairs, elevators, and anything bulky.

Some platforms offer quick online estimates too. Just do not skip the details. Parking restrictions, long carries, fragile items, and packing needs can all affect the final price.

Green Moving Options

Many customers now want a move that creates less waste. Ask about reusable bins, reduced plastic wrap, recycling help, and fuel-efficient vehicles.

Green moving should not mean weaker service. The goal is simple: fewer disposable supplies, less waste, and the same careful handling.

Relocation Planning, Pets, Vehicles, and International Moves

Large moves need coordination. A move coordinator, shared checklist, and clear timeline can keep your family, team, building manager, and mover on the same page.

For international moves, ask about customs paperwork, destination rules, and delivery windows. Pets and vehicles may require separate carriers, health documents, preparation steps, and tighter scheduling.

Red Flags and Quality Markers When Reviewing Service Lists

With so many services available, the danger is choosing a company that promises everything but explains very little. A trustworthy mover is clear, licensed where required, insured, and willing to put important terms in writing.

Warning Signs to Take Seriously

Watch out for vague estimates, large cash deposits, missing written inventories, or no physical business address. Pushy sales calls are another warning sign.

If the company will not explain extra fees for stairs, long carries, packing materials, parking problems, or delays, slow down. A cheap quote can become expensive fast.

Signs of a Reliable Mover

For interstate U.S. moves, look for FMCSA registration. ProMover status may also help when applicable. Verified insurance and recent reviews are useful too, especially when customers mention the same strengths repeatedly.

The service list should match your move. For example, commercial moving company services should mention IT handling, downtime planning, and secure records, not just “office moving.”

Booking and Getting More Value From Your Move

Once you know what to look for, booking becomes much easier. Still, the quality of your move depends on preparation and communication.

How to Book Smart With BookMyMove

Start with the basics: your moving date, pickup address, drop-off address, inventory, and any add-ons you want. Then compare verified movers, read the service details, and check whether packing, storage, or vehicle transport is included.

With verified partners, price comparisons, online booking, and support, BookMyMove helps you match your needs with the right service provider instead of guessing.

Moving Day Prep That Helps

Label boxes by room, keep valuables with you, and set aside medicines, chargers, keys, and important documents. Clear walkways before the crew arrives, and reserve parking if your building or street requires it.

After the move, ask about debris removal, basic setup, or move-in cleaning. Even the best residential moving services work better when the space is ready.

Final Thoughts on Choosing the Right Moving Services

The right mover should make your day feel organized, not chaotic.

Strong professional moving company services include clear pricing, careful packing, safe transport, storage options, and honest protection plans. Do not settle for vague promises and a truck.

Compare verified movers through BookMyMove, choose the services that fit your move, and give yourself a calmer start in your new place.

Common Questions About Professional Moving Company Services

What will professional movers not move?

Movers usually will not transport hazardous materials, open liquids, perishable food, live plants on some routes, firearms, propane tanks, or valuables like cash and jewelry. Ask for the restricted-items list before packing, because rules vary by company and location.

Are you supposed to empty dressers for movers?

Usually, yes, especially if the dresser is heavy, fragile, or going up or down stairs. Some movers allow light clothing to stay inside, but emptying drawers protects the furniture, reduces weight, and lowers the chance of damage.

Is unpacking always included, or is it an add-on?

Unpacking is often an add-on, not part of the base price. Some packages include basic placement, while others include full unpacking and debris removal. Always check the written moving company service list so there are no surprises later.

The post What Services Should You Expect From a Professional Moving Company? appeared first on Teach Me Microcontrollers!.

But here's what's changed in the last couple of years: the bar for "interesting ESP32 project" has moved. Running a small neural network on the chip — locally, without cloud round-trips — is no longer a demo trick. It's becoming a real product requirement. And the latest ESP32 variants were designed with exactly that in mind.

Why the ESP32 Family Keeps Evolving

The original ESP32 gave us dual-core processing, Wi-Fi, and Bluetooth in a package that cost less than a decent lunch. For most hobby projects, it's still more than enough.

But as makers started pushing into voice-controlled devices, camera-based smart sensors, and offline keyword detection, the limitations became clear:

• No hardware acceleration for math-heavy ML operations
• Limited USB support (you often needed a bridge chip)
• Camera interfacing was awkward and underpowered

Espressif addressed these gaps with the ESP32-S3, ESP32-S31, and newer variants. The S3, for instance, added SIMD vector instructions specifically for neural network inference, native USB OTG, and a proper camera interface. The S31 went further with a RISC-V core and Wi-Fi 6.

Understanding the full esp32 features across these variants matters when you're choosing a board for a project that goes beyond blinking an LED.

Where Edge AI Changes the Game

Consider a simple project: a smart doorbell that recognizes whether someone is at the door before sending a notification. With the original ESP32, you'd capture a frame, upload it to a cloud API, wait for the response, and hope your Wi-Fi holds up. Latency, privacy concerns, and dependency on internet connectivity — all problems.

With an ESP32-S3 running a lightweight model on-device, the inference happens in milliseconds on the board itself. No cloud needed. No data leaves your hardware. The project goes from "works if everything is perfect" to "works, period."

This is the same shift happening in commercial IoT products, and it's a shift you can experiment with on a $5 development board.

The Software Side: Don't Reinvent the Wheel

Hardware is only half the story. The other half is the software stack — the SDK, the cloud connectivity, the OTA update mechanism, the AI integration layer.

This is where many maker projects stall. You get the model running on the chip, and then you need to figure out:

• How to connect the device to a cloud dashboard
• How to push firmware updates without physically flashing each board
• How to integrate an LLM for conversational features
• How to handle device authentication and data encryption

That's the kind of infrastructure that's tedious to build from scratch but essential for anything beyond a weekend demo.

An open-source framework like TuyaOpen bundles these layers together — a cross-platform C/C++ SDK that works across ESP32, Raspberry Pi, and Tuya's own chips, plus cloud integration, multimodal AI support (ChatGPT, Gemini, Qwen, and others), and OTA update paths. It's designed so you can go from a working prototype to something shippable without rewriting your entire stack.

What to Try Next

If you want to start experimenting with AI on ESP32, here's a practical progression:

1. Start with a basic sensor project on your current ESP32 board — get comfortable with the Arduino framework and Wi-Fi connectivity
2. Move to an ESP32-S3 board and try running a TinyML model — Espressif's examples and the TuyaOpen SDK both have starter projects
3. Add a camera module and experiment with on-device image classification
4. Connect to a cloud AI service for features that need heavier processing — voice assistants, LLM-based responses
5. Build a complete product prototype with OTA updates, a mobile dashboard, and proper device security

The gap between "maker project" and "real product" is smaller than it used to be. The tools are better, the chips are more capable, and the open-source ecosystem has caught up. All you need is a board and a weekend to start.

The post From Blinking LEDs to Edge AI: How to Level Up Your ESP32 Projects appeared first on Teach Me Microcontrollers!.

That is where industrial automation makes a difference. Instead of asking an operator to start and stop every machine, a control system coordinates conveyors, adhesive pumps, valves, and presses. Sensors tell the controller what is happening on the line, while motor drives and pneumatic actuators carry out its commands.

These are the same basic ideas behind many small electronics projects, but the stakes change when the equipment handles large panels and powerful machinery. Let's look at how the manufacturing process works, then follow the signals that keep an automated sandwich panel production line moving.

Sponsored content: This article was prepared in collaboration with GlueStream.

Automation Coordinates the Main Stages of Sandwich Panel Manufacturing

A sandwich panel usually has two outer skins surrounding a lightweight core. Structural insulated panels (SIPs), for example, commonly pair oriented strand board (OSB) skins with expanded polystyrene (EPS) or another suitable insulating core. Other designs use metal, PVC, or fiberglass-reinforced skins. The materials vary, but the manufacturing challenge remains similar: each layer must reach the right position and form a dependable bond with its neighbors.

A production line divides that work into several stages. Material handling moves the components into place, adhesive equipment coats the required surfaces, and a press holds the assembly together while the bond develops. Automation links those stages so one machine does not interfere with the next.

Material Handling and Panel Positioning

Production starts with panels, boards, and insulation cores cut to the required dimensions. Operators may load them by hand, with lifting equipment, or through automated feeders. Once the materials reach the line, powered rollers or movable carriages carry them toward the assembly area. This removes much of the repeated lifting and pushing from the process.

However, moving a panel is only half the task. The line must also know where it is. A photoelectric sensor might detect the leading edge of a board, while a limit switch could confirm that a carriage has reached its stop. The controller uses these signals to stop a motor at the right moment or allow the next operation to begin. If the material never reaches the expected position, the machine should report a fault instead of continuing blindly.

Automated Adhesive Application

Once the material reaches the gluing station, the system must spread adhesive across the intended bonding surface. Uneven coverage can leave poorly bonded areas, while too much adhesive adds cost and may complicate handling. Manual application also becomes harder to repeat as panel sizes and production volumes increase.

An automatic applicator addresses this problem with a dosing pump and a controlled application head. The pump meters adhesive from a tank or drum, while the head distributes it through multiple outlets. Electric drives move the applicator or the panel, depending on the machine design. The controller coordinates that motion with dispensing so the equipment applies adhesive where the material actually sits. Some systems also switch nozzle groups on or off to match different panel widths.

Pressing, Curing, and Unloading

After adhesive application, workers or handling equipment assemble the skins and core into a stack. The line then moves the stack into a press. Here, the machine applies force across the panel to keep the layers in contact as the adhesive develops strength.

Pneumatic presses use compressed air to drive cylinders. Solenoid valves direct that air, and the control system starts and ends the pressing cycle according to the process settings. The correct pressure and pressing time depend on the adhesive, panel construction, and equipment design. Operators must follow the specified process rather than assume that every panel needs the same cycle.

Once the cycle finishes, the press releases the stack and the handling system transfers it toward unloading. The result is a repeated sequence of movement, dispensing, assembly, pressing, and transfer instead of a collection of unrelated manual steps.

Four Control Requirements for Automated Production Lines

Connecting these machines is not enough to make the line reliable. The controller must understand where materials and actuators are, decide what should happen next, and handle unexpected conditions. Four requirements shape that design.

Reliable Sensor Feedback

A controller cannot directly see a panel or feel the force of a press. It relies on electrical signals from sensors. Photoelectric sensors can detect incoming boards, proximity switches can indicate the position of a moving mechanism, and pressure transducers can report changes in an air system.

The signal type matters as much as the sensor itself. A digital input tells the controller whether a condition is true or false. An analog input provides a changing value, such as pressure. Engineers also need to account for dust, vibration, cable damage, and electrical interference. If a sensor gives a false reading, the controller may stop a good panel or attempt the wrong sequence.

Coordinated Motion and Process Sequencing

Industrial controllers, often programmable logic controllers (PLCs), turn sensor readings into actions. Instead of running every motor continuously, they move the line through defined operating states. For example, the controller may wait for a panel-position signal, stop the conveyor, enable the adhesive applicator, and then release the panel for transfer.

This sequence needs conditions between steps. The press should not accept another stack while its previous cycle is still running. Similarly, the conveyor should not move into a work area until the relevant mechanism has cleared it. These conditions, commonly called interlocks, prevent conflicting commands and make a complex line easier to diagnose.

Accurate Dosing and Actuator Control

The controller also needs to match actuator behavior to the process. A conveyor motor moves a panel, but an adhesive pump must deliver the required material at the same time. If panel travel speed changes without a corresponding dosing adjustment, the amount of adhesive per square meter can change too.

Variable-frequency drives help regulate compatible AC motors by controlling their operating frequency and voltage. In an adhesive station, drive control can adjust pump output to suit the required application rate. Pneumatic valves handle a different job: they open or close air paths to move cylinders or operate dispensing mechanisms. Each component serves a specific purpose, but the controller brings their actions together.

Machine Safety and Fault Detection

A stopped production line costs time, but an unsafe one can injure people. Presses create crush hazards, conveyors introduce pinch points, and pneumatic equipment can store energy even after a motor stops. Designers therefore need guards, appropriate emergency-stop functions, and safety-rated controls wherever the risk assessment requires them.

Ordinary PLC logic can report a missing sensor or an incomplete press cycle, but it should not replace a properly designed safety function. For example, an interlocked guard may need a safety circuit that prevents hazardous motion when someone opens it. During maintenance, workers must also isolate electrical and pneumatic energy according to the applicable procedures. Good diagnostics help technicians find faults; proper safeguards protect them while they do so.

GlueStream Equipment for Automated Sandwich Panel Manufacturing

The control principles above appear in real manufacturing equipment. GlueStream develops machinery for applying adhesives and assembling sandwich panels, with configurations that range from individual workstations to integrated lines. Its published designs provide a useful example of how mechanical equipment and electronic control fit together.

Automated Adhesive Application Systems

GlueStream's Sandwich panel equipment includes the SPL-10M adhesive-applying portal. Rather than relying on workers to spread adhesive over a large board, this machine uses a moving applicator and a metering system to cover the intended surface. The applicator can adjust its height to suit the material stack, while controlled valves help set the active application width.

The company describes a precision dosing pump that works with frequency converters to regulate adhesive delivery. For the relevant SPL-10M configuration, GlueStream states an application accuracy of ±5 g/m². That figure is a manufacturer specification, not an independent measurement, and actual results depend on the material and process setup. Still, it illustrates why manufacturers pay close attention to dosing control: even small variations matter across large bonding surfaces.

The equipment also addresses a problem specific to moisture-curing, one-component polyurethane (PUR) adhesives. Because moisture starts their curing reaction, adhesive left exposed inside a nozzle can harden and block it. GlueStream uses an automatically closing shutter tray with protective liquid to cover the nozzle area during stops. This small mechanism helps the applicator prepare for its next cycle without unnecessary cleaning or material loss.

Integrated Production Lines and Pneumatic Presses

An adhesive applicator solves only one part of the process. Panels still need to travel to assembly and pressing stations, and those machines must share a predictable sequence. GlueStream's ASPL-10M.2P Sandwich Panel Production Line shows how a manufacturer can connect the stages.

According to its product documentation, the ASPL-10M.2P combines an SPL-10M mobile adhesive portal, a motorized roller conveyor, an automatic distribution platform, two P-type pneumatic presses, a glue pump station, and a control cabinet. The conveyor and distribution platform transfer material through the line, while the presses hold assembled panels during the bonding stage. Operators still take part in the workflow, but the machines handle much of the repeated transport and processing.

This arrangement also shows why overall production speed depends on more than a fast adhesive head. A panel cannot leave the pressing stage before the process allows it, and an incoming stack needs a free destination. By coordinating these stations, the line can reduce unnecessary waiting and keep the equipment working in an orderly sequence. Actual output still depends on panel size, materials, adhesive requirements, staffing, and the selected machine configuration.

Remote Diagnostics and Production Flexibility

Even a well-designed line occasionally needs adjustment or troubleshooting. A position sensor may fail, a motor drive may report an error, or a dispensing parameter may need attention. Local diagnostic displays give operators a starting point, while remote support can help specialists investigate problems without immediately traveling to the factory.

GlueStream advertises remote-access modules and online technical support for its machinery. These features can make technical assistance more convenient, although customers should still control network access and define who may change machine settings. Remote connectivity does not replace on-site inspection, routine maintenance, or safety procedures.

Manufacturers also need to choose equipment that fits their process. The right arrangement depends on panel dimensions, adhesive chemistry, expected output, floor space, compressed-air capacity, and how much manual handling the operation can accommodate. Automation works best when engineers design around those practical limits instead of treating every production line as interchangeable.

Conclusion

An automated sandwich panel line may look very different from a microcontroller project on a workbench, but both rely on the same basic control loop. Sensors report what is happening, a controller chooses the next action, and electrical or pneumatic actuators carry it out. The difference lies in the scale of the machinery and the demands on reliability, timing, and safety.

In panel manufacturing, those controls help coordinate material positioning, adhesive application, pressing, and unloading. GlueStream's equipment shows how manufacturers can combine these functions into a working production system. For anyone studying electronics or embedded control, it is a practical reminder that understanding sensors, motor drives, and sequencing opens the door to much larger industrial applications.

References

• GlueStream — SPL-10M.1C.PUR Adhesive-Applying Portal
• GlueStream — ASPL-10M.2P Automatic SIP Panel Production Line
• OSHA — Machine Guarding: Guards and Interlocks
• OSHA — Additional Machine Safety Considerations

The post How Automation Works in a Modern Sandwich Panel Production Line appeared first on Teach Me Microcontrollers!.

Transitioning from Prototyping to Enterprise Deployment

While deploying a basic connected device, such as a NodeMCU IoT environment monitor, is often the first step in a hardware prototype, securing the data it transmits requires an enterprise-level approach. Engineers must recognise that the same features making these devices accessible for development also make them attractive targets for malicious actors.

When environmental sensors or industrial microcontrollers are connected to broader corporate networks, they become potential entry points for cybercriminals. Modern eCrime breakout times (the critical window from an attacker gaining initial access via an edge device to moving laterally across a network) have plummeted to just 29 minutes. If a vulnerability in an ESP32 or Raspberry Pi is exploited, attackers can pivot into centralised servers before network administrators even realise a breach is underway. The threat is not just theoretical. In late 2025, a massive distributed denial-of-service attack was launched by the Aisuru botnet, which successfully hijacked over 500,000 poorly secured edge devices globally to orchestrate severe network disruptions.

Why Edge Endpoints Demand Proactive Defence

Because microcontrollers often lack the memory and processing power to run traditional endpoint security agents, modern organisations must increasingly rely on dedicated Data breach readiness software to monitor their vast data landscapes and instantly detect anomalous activity. Implementing such solutions allows companies to identify unusual traffic patterns originating from seemingly innocuous hardware, thereby neutralising threats before they escalate into catastrophic network compromises.

The stakes for enterprise data ecosystems are incredibly high. A severe IoT data breach involving connected hardware from Mars Hydro recently exposed 2.7 billion records via an unsecured cloud database. This leak included Wi-Fi network credentials and device configurations that could grant attackers direct local network access. Similarly, the high-profile breach of internet-connected security cameras from Verkada serves as a foundational industry case study. It demonstrated exactly how compromising physical edge devices can directly expose highly sensitive internal operations. With approximately 98% of all IoT device traffic currently transmitted unencrypted, bad actors can easily intercept critical network commands and credentials if a single hardware endpoint is compromised.

Meeting New Australian Security Standards

In Australia, the regulatory landscape is rapidly shifting to enforce stronger hardware security at the manufacturing level. The Australian Signals Directorate reported a 20% increase in cybersecurity incidents during the 2025 to 2026 financial year, responding to over 1,500 major events. To combat this escalating threat, the Cyber Security (Security Standards for Smart Devices) Rules 2025 now legally mandate baseline cybersecurity requirements for most smart devices acquired in the country.

Under these new regulations, engineers must ensure their connected hardware adheres to three core rules:

• A strict ban on universal default passwords across all manufactured hardware to prevent trivial automated exploits.
• Mandatory vulnerability reporting mechanisms to allow independent researchers to disclose flaws securely and efficiently.
• Transparent minimum security update periods clearly communicated to buyers at the point of sale, ensuring long-term device integrity.

Furthermore, a government-backed Cybersecurity Labelling Scheme is being implemented across Australia. This initiative helps enterprise buyers easily compare device security before integrating third-party sensors into their networks. The Australian Cyber Security Centre actively advises developers to follow its IoT Secure-by-Design Guidance, which outlines 13 fundamental principles to secure edge technologies before they reach production. Adhering to these guidelines not only ensures compliance but also builds critical trust with enterprise clients who are increasingly wary of hardware vulnerabilities.

The Financial and Operational Stakes

The financial fallout from poorly secured IoT infrastructure can cripple an organisation. According to IBM's Cost of a Data Breach Report 2026, the global average cost of a data breach saw a 12% increase over the previous year. These costs reached record highs due to longer escalation times and advanced AI-enabled malware designed specifically to exploit fragmented edge networks.

This economic impact aligns with recent research indicating that IoT-targeted malware attacks surged by 124% year-over-year. Cybercriminals are increasingly weaponising connected edge networks for physical extortion, leading to a nearly 50% surge in targeted ransomware campaigns directed at industrial and operational technology sensors. As the lines between hardware engineering and enterprise IT continue to blur, developers must adopt secure architectures from the ground up. By implementing proper encryption libraries, disabling unnecessary debugging ports, and preparing robust incident response strategies, the hardware community can help prevent the next catastrophic network intrusion and safeguard the future of connected infrastructure.

The post Securing Networked Microcontrollers to Prevent Modern IoT Data Breaches appeared first on Teach Me Microcontrollers!.

Programming Microcontrollers via the Cloud

Thanks to recent advancements in browser technology, you no longer need to download heavy desktop clients to start coding. The implementation of the WebSerial API is a game-changing standard that allows your ChromeOS browser to directly read and write to connected USB serial devices. This successfully bypasses the need for complex local driver installations that often frustrate beginners, allowing you to focus entirely on learning the fundamentals of circuit logic and coding.

For early learners, the Arduino Web Editor processes all C++ code compilation securely in the cloud. This means even budget-friendly devices with limited RAM can effortlessly flash binaries down to connected boards. In addition to standard C++, Arduino recently expanded its cloud capabilities with a browser-based application for MicroPython. This allows users to program compatible microcontrollers directly over WebSerial without downloading native desktop clients, making project management incredibly seamless from a unified online dashboard. You can effortlessly switch between devices without losing any saved progress or code.

Enabling the Linux Development Environment

If you prefer coding locally or need to run full desktop-class Integrated Development Environments (IDEs), ChromeOS has a robust built-in solution. The native Linux environment, known as Crostini, operates using a custom virtual machine monitor optimised for tight security and low-latency performance. Because it is an integrated feature in the operating system, you can natively install and run Linux command-line tools and code editors without compromising your device's security. To get started, you can follow the official Google documentation to set up Linux on your Chromebook through the developer settings, which opens up a secure Debian terminal for your projects.

As of early 2024, ChromeOS introduced a seamless upgrade path for this container to Debian 12 (Bookworm). This ensures that hardware enthusiasts have access to the latest packages and modern graphical frameworks for their preferred coding setups. Your default Linux container, designated as 'penguin', will securely mount local files and let you run full desktop Linux applications natively. This means you can use industry-standard software like Visual Studio Code or the full Arduino IDE just as you would on a traditional desktop.

Steps to Configure Your Coding Workspace

Whether you are participating in local Australian STEM initiatives or just tinkering at home, setting up your device takes only a few minutes. Follow these fundamental steps to get your mobile workstation ready for embedded electronics:

• Update your operating system to ensure you have the latest browser features required for the WebSerial API.
• Enable the Linux development environment in your system settings to generate your secure container.
• Allocate sufficient disk space for your Linux partition (reserving at least 10GB is recommended for desktop IDEs).
• Download the Linux AppImage or install the official web application for your preferred microcontroller development platform.
• Connect your board via USB and approve the system prompt to share the serial port with your Linux container.

Next Steps for Your Electronics Journey

Australian organisations like the AustSTEM Foundation and award-winning educational groups such as STEM Punks are actively promoting early coding literacy by pairing low-cost laptops with educational microcontrollers. Major Australian electronics distributors, including Pakronics and Little Bird Electronics, now supply curriculum-aligned hardware bundles specifically tested for school-issued devices. You might even encounter unique, locally designed microcontrollers like the Kookaberry being used to teach digital concepts in classrooms across the country. These local resources make it easier than ever to find compatible parts.

Once your development environment is configured, the best way to test it is by diving into a practical, hands-on task. A brilliant starting point for any beginner is to follow a basic sensor wiring tutorial to build an IoT light detector with ESP32 hardware. Taking on a project like this will give you immediate experience with writing C++ code to read analogue values, proving just how capable your lightweight, battery-efficient workstation truly is. As you grow more comfortable with the ecosystem, you will quickly discover that ChromeOS is a highly productive platform for turning your electronic ideas into reality.

The post How to Set Up a ChromeOS Device for Microcontroller Development appeared first on Teach Me Microcontrollers!.

Elecrow's All-in-One ESP32-P4 Starter Kit turns those features into a learning platform. Elecrow integrates a 7-inch touchscreen, a 2-megapixel camera, audio hardware, and a common sensor board in one case. That lets you learn the software side without spending the first day wiring a display and several breakout modules.

We'll begin by identifying the kit, its board version, and its chip revision. Then we'll set up ESP-IDF, build a serial-output program, and control the onboard LED. We'll also explain what to expect from the display examples, how wireless expansion works, and which problems to check before blaming the firmware.

Disclosure: This article contains an affiliate link. We may earn a commission if you purchase through it, at no additional cost to you.

What's Inside the Elecrow ESP32-P4 Starter Kit?

Elecrow sells this kit as model SEE00804D. The package contains the assembled starter kit in a portable case and a USB Type-C cable. The common board carries 16 sensor and output modules on one PCB, and the lid holds the touchscreen. A 2 MP wide-angle camera and audio hardware extend the kit beyond the usual LED-and-sensor exercises.

The display has a resolution of 1024 × 600 pixels and connects to the P4 over a two-lane MIPI DSI bus. That gives you enough space for a multi-page interface with controls, status information, and charts. A large display also adds software work that a character LCD doesn't need: panel initialization, frame buffers, graphics rendering, and touch input all have to match the actual hardware.

Starter Kit Specifications

Elecrow's sources disagree on memory. Its GitHub README lists 16 MB of in-package PSRAM, while the launch specifications that CNX Software published name the ESP32-P4NRW32, which pairs the chip with 32 MB. The part number on your chip settles it: NRW16 indicates 16 MB of PSRAM, and NRW32 indicates 32 MB. With PSRAM enabled, the ESP-IDF boot log also reports the size it detects.

Onboard Sensors, Outputs, and Expansion

Elecrow routes the common board's connections in advance, which makes the basic exercises straightforward. Elecrow's pin list and course material identify these signals:

The board also carries an ultrasonic distance sensor, an LSM6DS3 accelerometer and gyroscope, a WS2814 RGBW LED, a microphone, and a speaker, and Elecrow's lessons cover each one. Confirm their pins against the board markings and schematic before you write your own code. Elecrow's ultrasonic lesson, for example, lists two different pin pairs in different places.

One hardware detail catches people out: the touch and Hall sensors share a toggle switch next to the wireless-module slot. Elecrow's lessons require the switch in its Hall/touch position before either sensor will work.

A useful ESP32-P4 detail: ESP-IDF assigns GPIO24 and GPIO25 to USB-JTAG by default, and reconfiguring either as an ordinary GPIO disables that debug function. Elecrow puts the PIR sensor and the servo on those pins, so check the ESP-IDF GPIO notes before you combine sensor code with USB-JTAG debugging.

How the ESP32-P4 Differs from the ESP32 and ESP32-S3

The familiar ESP32 suits connected control projects. The ESP32-S3 adds newer processing features and useful USB capabilities while keeping wireless connectivity on the chip. The ESP32-P4 takes another direction: it concentrates on local processing, graphics, cameras, and wired peripherals.

Elecrow specifies a 360 MHz HP processor for this kit. On May 8, 2026, Espressif announced ESP32-P4 chip revision v3.x, which raises the stable maximum clock to 400 MHz. The newer silicon also changes the ESP-IDF requirements, which we cover in the next section.

More important than the raw clock number is the work the chip can offload. The P4 includes an image signal processor (ISP), a pixel-processing accelerator (PPA), JPEG hardware, and an H.264 encoder. These blocks handle parts of camera and graphics processing so the application cores don't have to do every operation in software.

For example, a touchscreen dashboard benefits from dedicated display transfer and pixel handling. A camera application can use the camera interface and image-processing peripherals rather than routing the whole data path through general-purpose GPIO. That architecture, more than the higher CPU frequency, is the reason to consider the P4.

Check the Board Version and Chip Revision Before Loading Examples

Two revision numbers matter on this kit: Elecrow's board version and Espressif's chip revision. Check both before you open the supplied code.

Board version: V1.0 or V1.1

Look for the version marking on the PCB. Elecrow publishes separate course material for V1.0 and V1.1, and the two versions ship with different servos:

A continuous-rotation servo interprets control pulses as speed and direction commands. A positional servo interprets them as a requested angle. If you run the wrong example, the servo can move in confusing ways even though the PWM signal is valid.

The product that was sent to me is the V1.1 as shown on the lower right of the PCB:

Elecrow's repository currently publishes Eagle schematic files only for V1.0. On a V1.1 board, compare the pin labels against the V1.1 course material and the markings on the PCB.

Chip revision: v1.x or v3.x

Espressif's v3.x chip revision requires ESP-IDF v5.5.3 or later (or v6.0 or later), and you must rebuild firmware for it. Elecrow's setup guide uses ESP-IDF 5.4.2, which only suits v1.x chips.

Check the marking on the ESP32-P4 before you install a toolchain. Espressif adds an X suffix to v3.x part numbers, as in ESP32-P4NRW32X. If the board already runs ESP-IDF firmware, the bootloader also prints the chip revision near the top of the boot log. For a v3.x chip, install ESP-IDF v5.5.3 or later instead of 5.4.2, and expect to adapt Elecrow's examples to any API changes.

First Power-Up: Check the Factory Firmware

Power the kit through USB Type-C with the supplied cable; Elecrow specifies a 5 V input. Use a suitable USB power source or a computer port, and never apply 5 V directly to a GPIO or signal header.

The factory demonstration gives you a useful baseline. If the display, touch input, and other demonstrations work before you change the firmware, you'll have a reference point when something fails later. A feature missing from the factory menu doesn't prove a module is defective, though; the preloaded firmware may not exercise every peripheral.

Elecrow's repository includes factory_firmware and factory_sourcecode folders. Keep a copy of both, along with any flashing instructions, before you flash another application. You don't need to erase the flash first.

On the included OS, here's what I see when I go to settings > about:

This first check establishes what the hardware does before you make software changes. It isn't meant to prove every module works in one sitting.

Setting Up ESP-IDF for the ESP32-P4

Elecrow provides both Arduino and ESP-IDF learning material. We’ll use ESP-IDF because it gives direct access to the ESP32-P4 target, FreeRTOS, the peripheral drivers, and the configuration options that matter in later display and camera projects. We’ll run one of Elecrow’s lessons first to confirm the toolchain and USB connection, then create our own project.

Step 1: Install VS Code and ESP-IDF

Download Visual Studio Code, open Extensions, and install the Python extension followed by Espressif’s ESP-IDF extension. In the Command Palette, run ESP-IDF: Open ESP-IDF Installation Manager and follow the prompts.

Choose ESP-IDF 5.4.2 for a v1.x chip, the version Elecrow used to configure its lessons. For a v3.x chip, choose v5.5.3 or later. Install to a short path with no spaces, such as C:\esp, because ESP-IDF doesn’t support spaces in its paths or in project paths.

Step 2: Clone Elecrow’s Repository to a Short Path

Elecrow’s lessons nest deeply, and some file paths exceed Windows’ 260-character limit when the repository sits in a long folder. Enable long paths in Git, then clone into a short folder:

git config --global core.longpaths true
cd C:\esp
git clone https://github.com/Elecrow-RD/All-in-one-Starter-Kit-for-ESP32-P4-with-Common-Board-design.git elecrow-p4

Elecrow’s ESP-IDF lessons are in example\V1.0\idf-code and example\V1.1\idf-code, 20 lessons each. The two sets differ only in Lesson 8, the servo lesson.

Step 3: Open a Lesson as a Project

Each lesson folder contains a second folder with the same name, and that inner folder is the ESP-IDF project. In VS Code, choose File > Open Folder and select it:

C:\esp\elecrow-p4\example\V1.1\idf-code\1ESP32P4-dev-kits_gpio\ESP32P4-dev-kits_gpio

Don’t change the target. Elecrow includes a ready-made sdkconfig in each lesson that already selects esp32p4 and sets up the PSRAM, flash size, and partition table. Setting the target again regenerates that file and discards those settings.

Step 4: Connect USB1 and Select the Port

The kit has two USB-C ports. Connect the one labelled USB1, which feeds a CH340K USB-to-serial chip wired to the P4’s UART0. The other port, USB2, connects to the P4’s high-speed USB peripheral and isn’t used for flashing.

On Windows, the kit should appear under Device Manager > Ports (COM & LPT) as USB-SERIAL CH340K. If it appears as an unknown device instead, install WCH’s CH340 driver. In the ESP-IDF status bar, select that COM port and set the flash method to UART. The CH340’s control lines put the P4 into download mode automatically, so you don’t need to press any buttons.

Step 5: Build, Flash, and Monitor Lesson 1

Run ESP-IDF: Build your project, then ESP-IDF: Flash your project, then ESP-IDF: Monitor your device. The status bar has buttons for all three. The command-line equivalent in an ESP-IDF terminal is:

idf.py build
idf.py -p COMx flash monitor

Lessons that use the display, sensors, or camera download components from Espressif’s component registry on their first build, so keep the computer online. When Lesson 1 runs, the monitor prints Elecrow’s start-up messages and the green LED next to GPIO5 blinks every 500 ms.

Step 6: Create Your Own Project

With the toolchain and connection confirmed, create a project for our own code. Run ESP-IDF: New Project, set the target to esp32p4, save the project to a short path such as C:\esp\p4-hello, and start from the sample_project template. The template doesn’t enable PSRAM, which the serial and LED programs below don’t need. For display work, start from Elecrow’s lessons, which already have PSRAM configured.

Our First ESP32-P4 Program: Serial Output

Before initializing the 7-inch display, we’ll run a program with as few board-specific dependencies as possible. A counter printed to the serial monitor confirms that a project of our own builds, flashes, and runs. It also gives us somewhere to send diagnostic messages later.

Elecrow’s lessons ship with their own configuration and board drivers. For our code, we’ll start from a clean ESP-IDF project instead.

Create the project

In VS Code, open the Command Palette and run ESP-IDF: New Project. Then:

1. Choose the ESP-IDF version you installed earlier.
2. Choose the sample_project template from the ESP-IDF list, then click Create Project Using Template sample_project.
3. Name the project p4-hello and set the location to C:\esp. Avoid spaces in both, because ESP-IDF doesn’t support them in project paths.
4. Set the target to esp32p4. The board setting only matters for hardware debugging, so leave it on the generic ESP32-P4 entry.
5. Select the kit’s USB-SERIAL CH340K port.
6. Click Create Project, then Open Project.

If you prefer the command line, open an ESP-IDF terminal and run:

cd C:\esp
idf.py create-project p4-hello
cd p4-hello
idf.py set-target esp32p4

The template contains three files:

p4-hello\
├── CMakeLists.txt
└── main\
    ├── CMakeLists.txt
    └── main.c

The top-level CMakeLists.txt marks the folder as an ESP-IDF project. The main folder is the project’s application component, and its CMakeLists.txt registers main.c as a source file. Setting the target also creates sdkconfig, which stores the project’s configuration. Change it through ESP-IDF: SDK Configuration Editor (Menuconfig) rather than editing it by hand.

The default configuration works for this program as-is. It sends console output to UART0, which is the UART that the kit’s CH340K USB-to-serial chip connects to. One exception: if you’re using ESP-IDF 5.5 or later with a v1.x chip, open the configuration editor, search for REV_LESS_V3, enable it, and save. Newer ESP-IDF versions target v3.x chips by default.

Add the code

Open main\main.c and replace its contents with:

#include <stdio.h>
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"

void app_main(void)
{
    unsigned int counter = 0;

    while (1) {
        printf("Hello from ESP32-P4! Count: %u\n", counter++);
        vTaskDelay(pdMS_TO_TICKS(1000));
    }
}

You don’t need to change either CMakeLists.txt file. The template already lists main.c, and every ESP-IDF project includes the components that printf() and the FreeRTOS functions come from.

In ESP-IDF, app_main() is the application’s entry point. There is no Arduino-style setup() and loop() pair to implement. The ESP-IDF runtime initializes the system and then calls app_main() from a FreeRTOS task.

The printf() call sends the counter to the console. pdMS_TO_TICKS(1000) converts 1,000 milliseconds into FreeRTOS ticks, and vTaskDelay() blocks the current task for that many ticks instead of occupying the CPU with a busy-wait loop.

Build, flash, and monitor

Check that the ESP-IDF status bar shows esp32p4 as the target, the CH340K COM port, and UART as the flash method. Then build, flash, and open the monitor. The status bar has buttons for each step, or you can run them from an ESP-IDF terminal:

idf.py -p COMx flash monitor

After the boot messages, the monitor prints one line about once per second:

Hello from ESP32-P4! Count: 0
Hello from ESP32-P4! Count: 1
Hello from ESP32-P4! Count: 2
Hello from ESP32-P4! Count: 3

Press Ctrl+] to leave the monitor. If flashing reports success but the terminal stays blank, check the selected port and the cable before changing the application code.

Blinking the Onboard LED on GPIO5

Serial output tells us the firmware is running. The next step is to drive a real signal from the P4. Elecrow's first lesson drives LED5 from GPIO5, and its LED circuit sinks current into the pin. That makes the LED active-low: driving GPIO5 low turns the LED on, and driving it high turns it off.

This program toggles the LED with a 500 ms delay between transitions:

#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "driver/gpio.h"
#include "esp_err.h"

#define LED_GPIO GPIO_NUM_5
#define LED_ON 0   /* LED5 is active-low */
#define LED_OFF 1

void app_main(void)
{
    ESP_ERROR_CHECK(gpio_reset_pin(LED_GPIO));
    ESP_ERROR_CHECK(gpio_set_direction(LED_GPIO, GPIO_MODE_OUTPUT));

    while (1) {
        ESP_ERROR_CHECK(gpio_set_level(LED_GPIO, LED_ON));
        vTaskDelay(pdMS_TO_TICKS(500));

        ESP_ERROR_CHECK(gpio_set_level(LED_GPIO, LED_OFF));
        vTaskDelay(pdMS_TO_TICKS(500));
    }
}

The gpio_reset_pin() call returns GPIO5 to its default configuration, and gpio_set_direction() enables output mode. The LED_ON and LED_OFF macros hide the active-low polarity, so the loop reads the way the LED behaves. A full on-off cycle takes about one second.

An ESP-IDF template's main component links every component automatically, so this program builds without changes to the CMake files. If you prefer explicit dependencies, or move the LED code into its own component, declare the GPIO driver in that component's CMakeLists.txt:

idf_component_register(SRCS "main.c"
    INCLUDE_DIRS "."
    REQUIRES esp_driver_gpio)

If serial output works but the LED never changes, confirm that your board version uses GPIO5 for LED5 and check the project's configuration. A failed LED exercise doesn't mean the MCU or the flashing setup is defective.

Exploring the 7-Inch Touchscreen

The serial and LED examples barely exercise the P4's main strengths. The touchscreen is where the chip's dedicated multimedia interfaces start to matter.

A 1024 × 600 frame contains 614,400 pixels. At 16 bits per pixel, one uncompressed full-screen buffer needs 614,400 × 2 = 1,228,800 bytes, or about 1.17 MiB.

A second full-size buffer doubles that before the application allocates anything else, which is why the display configuration depends on PSRAM. Elecrow's display lesson places LVGL's buffers in PSRAM, and its first lesson enables PSRAM at 200 MHz in sdkconfig (that option appears once you make experimental features visible). The on-chip RAM alone isn't enough for a large graphics application.

Elecrow's display lesson drives the panel over a two-lane MIPI DSI bus with an EK79007 driver IC, and it supplies the board-specific setup for that combination. Start with Elecrow's example for your board version rather than writing your own initialization sequence. Use this order:

1. Open Elecrow's ESP-IDF course for your V1.0 or V1.1 kit.
2. Find the LCD project and read its component requirements before building.
3. Check the project's ESP-IDF version and its display and touch driver dependencies.
4. Build and flash the unchanged demonstration first.
5. Record whether the display renders correctly and whether touch coordinates respond as expected.

Elecrow's repository lists LVGL 8.3.3 as a dependency. LVGL is a practical next step for dashboards, menus, and interactive controls, but examples that depend on different major LVGL versions can produce API or build errors when mixed.

Running the supplied display example unchanged establishes a working hardware and driver combination before you start modifying the graphics code.

Wireless Connectivity and ESP32-C6 Expansion

Unlike the original ESP32 or the ESP32-S3, the ESP32-P4 has no Wi-Fi or Bluetooth radio of its own. A P4 application that needs wireless networking has to use another device to provide it.

Elecrow sells plug-in wireless modules for this slot, including an ESP32-C6 version. The module exposes UART transmit and receive pins along with a few GPIOs, so the P4 talks to it over a serial link: the C6 runs the radio, and the P4 handles the user interface, sensors, and application logic. Both chips need matching firmware, so plugging in the module doesn't enable networking by itself.

For a wired connection, the kit has a 100 Mbps Ethernet port. Ethernet suits an HMI panel that stays in one installation and benefits from a predictable network connection.

ESP32-C6 networking deserves its own interface description, driver setup, and connectivity test, so we'll cover it in a separate tutorial. The initial setup in this article doesn't need a wireless module.

Troubleshooting the ESP32-P4 Starter Kit

Most first-day problems with this kit come down to the cable, the toolchain version, or a board setting. Start with these checks.

The Computer Powers the Kit but Doesn't Detect It

Check the USB cable and the USB-C port first. A charge-only cable can supply 5 V without carrying data. Try a known data-capable cable and check Device Manager for a new COM port.

ESP-IDF Doesn't Recognize the esp32p4 Target

Check which ESP-IDF installation the terminal or VS Code extension is using. A toolchain set up for another chip family, or an older framework without P4 support, won't accept the target. For Elecrow's examples on a v1.x chip, use ESP-IDF 5.4.2.

New Firmware Flashes but Won't Boot

Check the chip revision. A v3.x chip needs ESP-IDF v5.5.3 or later and firmware rebuilt for that revision; firmware from ESP-IDF 5.4.2 doesn't support it.

Flashing Fails Even Though a Port Appears

Close other serial-monitor programs, verify the port selection, and retry. If automatic bootloader entry isn't working, follow the kit's download-mode procedure. A flashing failure is a separate problem from a compilation error, so read the last meaningful message in the build or flashing log before making changes.

The Serial Monitor Is Blank

A successful build doesn't guarantee that the firmware prints to the port you're monitoring. Check the project's console configuration, the selected port, the cable, and the reset behavior. Early boot messages tell you whether you're connected to the right channel.

The LED Doesn't Blink

Confirm GPIO5 for your board version. Remember that LED5 is active-low, so it lights when GPIO5 is low. If the serial counter still runs, the problem more likely concerns the pin, its configuration, or the LED circuit than basic CPU execution.

The Touch or Hall Sensor Doesn't Respond

Check the selector switch next to the wireless-module slot. Both sensors need it in the Hall/touch position.

The Display Goes Blank After the First Program

The serial and blink programs don't initialize the panel or touch controller, so a blank display after flashing them is expected. Load Elecrow's display example when you want to use the screen again.

The Servo Moves Continuously Instead of Holding an Angle

Check the board version. V1.0 kits ship with a continuous-rotation servo and V1.1 kits with a 180° positional servo. Use the matching Lesson 8 example before adjusting pulse widths.

Is the Elecrow ESP32-P4 Starter Kit Worth It?

The main advantage of the SEE00804D is convenience. Elecrow assembles the touchscreen, camera, audio hardware, and common sensor board for you. That suits a classroom, or a developer who wants to work on firmware and interface design without first wiring several peripherals.

There are tradeoffs. The P4 isn't the easiest choice if all you need is Wi-Fi and a few sensor inputs; a conventional ESP32 or ESP32-S3 may be simpler and less expensive. Wireless expansion takes extra hardware and firmware on a second chip. The fixed circuitry also gives you less freedom to move a sensor to another GPIO than a set of separate modules would.

The development environment is another consideration. A serial-output program is approachable, but graphics, cameras, PSRAM configuration, and multiple drivers take more work than the usual Arduino blink sketch. Elecrow's examples give you a starting point for that more advanced software.

We'd choose this kit for exploring touch interfaces, camera handling, and P4-specific peripherals. For a basic wireless temperature logger or relay controller, we'd choose a simpler board. The kit earns its price when you plan to use the display and multimedia features rather than treating them as extras.

Conclusion

The ESP32-P4 isn't a replacement for every ESP32 board. It's a different kind of microcontroller, intended for applications where local processing and rich interfaces matter more than an integrated radio.

Elecrow's starter kit gives you a practical way to learn that architecture. Start by identifying the board version and chip revision and saving the factory resources. Then set up the matching ESP-IDF version and confirm serial output and GPIO control. Once those basics work, run the display example before changing its drivers or writing a custom LVGL interface.

Future tutorials will explore the individual sensors, camera processing, and wireless expansion. The important first step is a development setup whose behavior you can reproduce and troubleshoot.

References

• Elecrow: All-in-One Starter Kit for ESP32-P4 (SEE00804D)
• Elecrow Wiki: Setup instructions and V1.0/V1.1 courses
• Elecrow: All-in-One Starter Kit for ESP32-P4 ESP-IDF user manual (PDF)
• Elecrow GitHub: Examples, pin definitions, and factory firmware
• Elecrow: Wireless module for CrowPanel Advanced series
• Espressif: ESP32-P4 SoC overview
• Espressif: ESP32-P4 v3.x upgrade announcement (May 2026)
• Espressif: ESP32-P4 Chip Revision v3.x User Guide
• Espressif: ESP-IDF GPIO driver reference for ESP32-P4
• CNX Software: ESP32-P4 learning and prototyping kit specifications

The post Elecrow ESP32-P4 Starter Kit: Setup & Getting Started Guide appeared first on Teach Me Microcontrollers!.

Here is how to decide what counts, set it up in Google Ads, GA4 and the Meta pixel, and test it in 30 minutes.

Key takeaways

• Count only actions that can become a job: a form sent, a call from the site, a booking, a chat. Never a page view.
• In Google Ads, set lead actions to Count: One and keep one Primary action per lead.
• Google Ads can import only GA4 events marked as key events.
• On the Meta pixel, use Lead for forms, Schedule for bookings and Contact for calls and chats.
• Booked jobs can go back to Google Ads up to 90 days after the click.

What should a local business count as a conversion?

A conversion is an action that can turn into paid work. For a local business that means four things: a form sent, a call placed from the website, a booking made and a chat started. Page views, button clicks and time on site are not conversions. They show interest, not a lead.

How to set up Google Ads conversion tracking

Google Ads Help gives two data sources for website conversions: the Google tag, or importing key events from Google Analytics. Imports can take 24 to 48 hours to appear. Then check four settings on each action:

• Primary or Secondary. Primary actions fill the Conversions column and drive bidding. Secondary ones only show in All conversions. If the tag and GA4 both track one form, make only one primary.
• Count: One. Google recommends One for leads and Every for sales.
• Conversion window. The default is 30 days, with a range of 1 to 90. Make it longer if people call back weeks after a click, as with roofs or legal cases.
• Calls from website. A phone snippet swaps your number for a Google forwarding number, only for visitors who clicked an ad. A call counts when it passes the minimum length you set. Set it just under your shortest real booking call.

GA4 key events, the Meta pixel and booking tools

In GA4, go to Admin, then Events under Data display, and click the star next to the event. For forms, a thank you page is the most reliable signal. Create an event with Create without code, base it on page_view and enter the thank you page address. A form submit event can fire on errors or double clicks.

On the Meta pixel, Meta's pixel reference describes Schedule as booking an appointment and Contact as reaching you by phone, SMS, email or chat. Use Lead for a sent form, one event per action.

If your booking tool runs on its own domain, set up cross domain measurement in GA4 under Data streams, Configure tag settings, Configure your domains. Google Analytics Help says both sites need the same tag ID. If the tool will not take your tag, count its confirmation emails by hand.

The step after: send booked jobs back

A lead is not a job. Say a salon gets 40 form leads in a month and 25 of them book. Google Ads sees 40 equal leads, so it bids just as hard for the 15 that went nowhere. Sending booked jobs back fixes that.

The simple version is a spreadsheet and a weekly upload. When jobs close across a CRM, a booking tool and the phone, a marketing attribution platform such as the one at observix.ai connects the ad accounts, website and CRM and sends verified conversions back to the ad platforms.

For the spreadsheet route, Google Ads Help on offline conversions says to save the click ID, the gclid, with each lead. Add a hidden gclid field to your form so it lands in your job list next to the name and phone. Auto tagging must be on, and you should wait 4 to 6 hours after creating the import action before the first upload. Jobs uploaded more than 90 days after the click are not accepted, so upload weekly.

How to test your tracking in 30 minutes

1. Connect Tag Assistant (5 minutes)

Go to tagassistant.google.com, click Add domain, enter your site and click Connect. Your site opens in a debug window, and Tag Assistant lists each tag as you click around.

2. Send a test form (5 minutes)

Fill in your own form with the name Test Lead. The conversion tag should fire once on the thank you page. If it fires twice, you are double counting.

3. Check the phone snippet (5 minutes)

You will see your normal number, because you did not come from an ad. Check instead that the snippet is on every page that shows your number, including the footer and the contact page.

4. Open Meta Test events (10 minutes)

Meta's developer docs place the tool at Events Manager, Data Sources, your pixel, Test Events. Open your site from there, send the form again, and check that a Lead event appears, not only PageView.

5. Clean up (5 minutes)

Delete every Test Lead from your job list, so it never gets uploaded as a booked job.

Common questions

Should page views count as conversions in Google Ads?

No. A page view is interest, not a lead. If it is primary, bidding will chase cheap visits, so set it to secondary or remove it.

Should I use the Google tag or import GA4 key events?

If GA4 already tracks your forms well, import them. Use the Google tag if you do not use GA4. Never make both primary for the same form.

What Meta pixel event should I use for a lead form?

Lead. Use Schedule for a booked appointment and Contact for a tap on your phone number or chat button.

Why do Google Ads and GA4 show different conversion numbers?

Google Ads counts only conversions that follow an ad interaction inside the window. GA4 counts visitors from every channel. Some gap is normal.

Pick one lead form today, make it the only primary action with Count: One, and run the 30 minute test. Once that number matches your inbox for two weeks, add calls, then bookings.

The post Website Conversion Tracking: How to Set It Up for a Local Business appeared first on Teach Me Microcontrollers!.

Case 1: The 4–20 mA current loop

The 4–20 mA loop is the workhorse of process instrumentation (pressure, temperature, level, flow) because current does not drop over long cable runs and a broken wire is detectable: 4 mA means "zero reading", 0 mA means "fault".

To read it with a microcontroller ADC, pass the loop current through a precision shunt resistor and measure the voltage:

A 250 Ω, 0.1% resistor converts the loop to a 1–5 V signal. Two practical notes:

• If your ADC is 3.3 V only, use a 165 Ω shunt instead (0.66–3.3 V) and scale in software.
• Most loop transmitters are powered from the loop (2-wire devices). Your interface must supply the 24 V loop power and respect the transmitter's minimum voltage after the shunt drop.

Case 2: PNP and NPN discrete outputs

Proximity, photoelectric and level sensors in 3-wire DC form switch either the positive rail (PNP, "sourcing") or ground (NPN, "sinking"):

• PNP output gives you ~24 V when active. Feed a microcontroller pin through a voltage divider (e.g. 10 kΩ / 2.2 kΩ) or, better in a noisy cabinet, an optocoupler.
• NPN output pulls the line to ground when active. Use a pull-up to your logic rail (with an optocoupler if you want isolation) and read it as active-low.

The mistake to avoid: connecting a 24 V sensor output "temporarily" to a 5 V-tolerant pin to see if it works. It works exactly once. A PC817 optocoupler, a series resistor sized for the sensor's output current, and a transistor output stage cost cents and make the interface boring — which is what you want.

Case 3: IO-Link, the digital upgrade

IO-Link (IEC 61131-9) runs over the same 3 wires as a standard sensor but adds a digital channel: the sensor reports its measured value plus diagnostics (device ID, temperature warnings, signal quality). From the microcontroller side you do not bit-bang it — you use an IO-Link master IC or a ready master module and talk to it over SPI or UART. Choose it when you are designing something new; for retrofits, the analogue and discrete interfaces above are what the installed base speaks.

A note on replacement parts

Prototypes and repairs run into one recurring problem: the sensor on the machine is discontinued, and its modern successor has a different output or connector. Before redesigning the interface, check whether the original model is still obtainable — industrial parts catalogues such as INDPRT list current and discontinued sensors by exact model number, which is how the installed base is actually identified. Match the designation character for character; on industrial labels the suffix usually encodes the output type (PNP versus NPN) or the connection style, and "almost the same model" is a different sensor.

Summary

• 4–20 mA → shunt resistor, measure voltage, treat 0 mA as a fault, not a reading.
• PNP/NPN → divide or opto-isolate down to logic level; never feed 24 V to a GPIO.
• IO-Link → use a master IC; it is a protocol, not a voltage.
• Replacements → identify by exact designation first, redesign second.

The post Interfacing Industrial Sensors With a Microcontroller: 4–20 mA, PNP/NPN and IO-Link Basics appeared first on Teach Me Microcontrollers!.

Announced on October 22, 2026, the Sigma 2 targets developers building autonomous robots, industrial equipment, computer vision systems, and private AI servers. It offers up to 180 TOPS of combined peak AI performance, 64GB of LPDDR5X memory, and multiple high-speed expansion interfaces.

Unlike a conventional mini-PC, the Sigma 2 also provides programmable GPIO through its onboard microcontroller. Developers can therefore run AI inference and interact with external electronics from the same board.

Intel Core Ultra X7 358H Powers Local AI Processing

At the center of the Sigma 2 is Intel's Core Ultra X7 358H processor. It has 16 CPU cores, consisting of four performance cores, eight efficiency cores, and four low-power efficiency cores, with a maximum clock speed of 4.8 GHz.

The processor also integrates an Intel Arc B390 GPU with 12 Xe-cores and an NPU dedicated to AI acceleration.

According to LattePanda, the three processing components provide the following peak INT8 performance:

These figures represent theoretical peak computing capability across the different processing units. They should not be interpreted as the performance available to a single AI model, since actual inference speed depends on the model, framework, memory usage, and execution hardware.

The Sigma 2 includes 64GB of dual-channel LPDDR5X-8533 memory, providing a theoretical bandwidth of 136.5 GB/s. Up to 59GB of system memory can be allocated to the integrated GPU.

This shared-memory architecture allows larger quantized models to run without requiring a separate graphics card with equivalent dedicated VRAM. LattePanda says the board can accommodate 35-billion-parameter-class mixture-of-experts (MoE) models, although real-world performance will depend on the selected model and quantization method.

For developers working with local language models, the additional memory capacity may be particularly useful when running AI agents, retrieval-augmented generation systems, or applications that need to process long conversations.

RP2350 Microcontroller Adds Hardware Control

One of the Sigma 2's more interesting features for embedded developers is its integrated RP2350 microcontroller.

While the Intel processor handles operating-system tasks and AI inference, the RP2350 can manage lower-level hardware operations independently. It provides GPIO interfaces for connecting sensors, switches, actuators, and other electronic components.

The microcontroller supports common embedded interfaces, including I2C, SPI, UART, and analog inputs. It also comes with MicroPython firmware preloaded, allowing developers to begin writing hardware-control applications without setting up a separate development environment.

Consider a vision-based sorting system. The Intel processor could run an object-detection model to identify items passing through a camera's field of view. The RP2350 could then read position sensors and control the actuators responsible for sorting those items.

Separating high-level computing from hardware control can also help prevent operating-system scheduling delays from affecting time-sensitive GPIO operations.

This combination makes the Sigma 2 more than a compact AI server. It provides a platform for projects that need substantial computing power alongside direct interaction with physical hardware.

High-Speed Networking and Expansion

The Sigma 2 provides several expansion options for developers who need additional storage, networking, or computing hardware.

It includes three M.2 M-Key slots for NVMe storage and compatible accelerator modules, plus an M.2 E-Key slot for wireless connectivity. The M-Key interfaces support PCIe 5.0 x2, PCIe 4.0 x4, and PCIe 4.0 x1, respectively.

An OCuLink connector exposes PCIe 4.0 x2 for external devices, while two Thunderbolt 4 ports provide additional high-speed connectivity. External graphics docks and AI accelerators can expand the system's capabilities, although developers should account for the bandwidth limits of each interface.

Networking is handled by two 10Gb Ethernet ports. These are useful for applications involving large datasets, network-attached storage, and high-bandwidth camera or sensor systems.

For conventional peripherals and displays, the board provides two USB 3.2 Gen 2 ports, two USB 2.0 ports, HDMI 2.1, DisplayPort 2.1 through USB-C, and an embedded DisplayPort interface.

It also includes an RS-232/485 header, making it suitable for integration with equipment that uses industrial serial communication.

The board measures 146 × 102 mm, allowing it to fit inside relatively compact enclosures despite its extensive connectivity.

Software Support and Local AI Development

The Sigma 2 supports Windows 11 and Ubuntu 24.04 LTS or later.

The available configuration includes a 1TB NVMe SSD with Ubuntu preinstalled. According to LattePanda, the supplied software environment also includes GPU and NPU drivers, OpenVINO Model Server, OpenClaw, and local AI models.

Developers can use AI frameworks such as Intel OpenVINO, Ollama, and llama.cpp to build applications that perform inference on the device.

For instance, OpenVINO provides acceleration options for supported models using Intel processing hardware. Ollama and llama.cpp provide other approaches to running language models locally.

Keeping inference on the device can reduce dependence on external cloud services, particularly in systems where internet connectivity is limited or data must remain within a local network.

However, developers still need to evaluate model compatibility, inference speed, and power consumption for their intended applications.

Applications Beyond AI Development

The Sigma 2's combination of computing performance and hardware interfaces makes it suitable for several types of embedded systems.

In autonomous robots, the board could handle camera processing, object recognition, and navigation calculations while the RP2350 manages sensor inputs and actuator-control signals.

For industrial monitoring, its dual 10Gb Ethernet connections and local AI processing capabilities could support equipment that collects large amounts of sensor data and analyzes it without sending everything to the cloud.

The same hardware could also serve as a private AI server for running language models, document-processing systems, or automation agents within a local network.

Developers building measurement instruments may find the combination of high-speed processing, serial interfaces, and GPIO useful when connecting custom electronics to data-processing software.

Of course, these capabilities come with higher cost and power requirements than a typical microcontroller board. The Sigma 2 is better suited to applications that genuinely need x86 computing performance, substantial memory, and local AI acceleration.

LattePanda Sigma 2 Pricing and Availability

The LattePanda Sigma 2 is available for pre-order at $2,599, with promotional pricing scheduled to continue through mid-November 2026. After the pre-sale period, the listed price will increase to $2,799.

The advertised configuration includes the Intel Core Ultra X7 358H processor, 64GB LPDDR5X RAM, and a 1TB NVMe SSD.

For system integration, developers should also consider power and thermal requirements. LattePanda specifies a 15–20V DC supply rated for at least 120W, or a compatible 20V USB-C Power Delivery supply rated for at least 100W. The specified operating temperature range is 0–40°C.

At this price, the Sigma 2 is clearly aimed at professional development, specialized computing, and embedded AI applications rather than entry-level electronics projects.

Its main advantage is the ability to combine local AI processing, extensive expansion, high-speed networking, and microcontroller-based hardware control on a single platform.

More information is available through the official LattePanda Sigma 2 product page and technical documentation.

The board can also be ordered through DFRobot's LattePanda Sigma 2 product listing.

Editor's note: This article is based on the manufacturer's launch information and published technical specifications. TeachMeMicro has not independently tested the Sigma 2 or verified its AI performance claims.

The post LattePanda Sigma 2 Launches with 180 TOPS AI Performance and RP2350 GPIO appeared first on Teach Me Microcontrollers!.