The Limits of the Local Workbench

Developing a basic prototype requires significant engineering effort to perfect both the hardware and software layers. Developers typically start small to test their concepts in a highly controlled environment before committing to larger infrastructure investments. This gradual approach helps reduce early risks while proving that the core concept works as intended under controlled conditions.

For instance, you might begin by setting up an ESP32 async web server to host a local dashboard and monitor sensor readings on your own private Wi-Fi network. This approach is a brilliant, cost-effective way to understand the fundamentals of microcontroller communications, data parsing, and event handling without relying on external hosting fees or complex cloud subscriptions.

But as your project matures, localised builds frequently encounter severe data bottlenecks. Field testing of distributed smart systems (such as prototype environmental sensors or dynamic waste management monitors) often reveals high packet loss and significant latency when you rely entirely on on-premise hardware. To overcome these limitations, organisations often utilise professional cloud migration services to transition their early-stage local databases into scalable, enterprise-grade environments. Small local dashboards simply do not possess the processing limits, bandwidth, or storage capacity required for continuous commercial production and large-scale data logging.

Managing the IoT Data Explosion

The sheer volume of information generated by modern IoT networks is enormous. As connected devices continue to expand across industries, they generate vast amounts of telemetry that require scalable storage and processing capabilities. Whether sensors are tracking agricultural soil moisture, fleet vehicle GPS coordinates, or factory machine temperatures, continuous data collection quickly exceeds the capabilities of standalone development hardware or local servers.

Relying on independent local servers is no longer a viable long-term strategy for growing businesses or ambitious developers. According to a recent Forbes analysis on enterprise IT, true scalability requires organisations to transition away from hacked-together solutions and operate fleets of connected devices via integrated cloud systems that natively handle massive data ingestion. Attempting to manage this level of scale on isolated hardware introduces severe performance bottlenecks and significant security vulnerabilities that could compromise an entire network.

Bridging the Gap with Professional Infrastructure

Enterprise cloud networks have become essential for supporting scalable hardware deployments as organisations move away from isolated infrastructure toward unified cloud environments. Many businesses recognise that maintaining independent network infrastructure internally becomes increasingly complex as deployments grow. Adopting managed infrastructure reduces operational overhead by shifting maintenance responsibilities to specialised cloud platforms.

Navigating this transition requires careful architectural planning, especially as cloud platforms continue to evolve. Changes to major cloud services have demonstrated the importance of designing flexible infrastructure that can adapt when technologies or platforms are discontinued. To minimise disruption during these transitions, organisations increasingly rely on experienced technical partners to migrate MQTT brokers, sensor databases, and security credentials into resilient cloud environments.

Key Steps for Commercial Deployment

Scaling a network requires a fundamental shift in how telemetry is structured and managed. When moving from a benchtop prototype to a commercial release, engineering teams must implement several critical architectural changes to ensure long-term stability:

• Implementing Cloud Load Balancers: Routing sensor telemetry through enterprise-grade load balancers is essential to prevent packet loss and reduce latency across thousands of concurrent connections.
• Automated Security Patching: Managing manual updates across physical hardware gateways is impossible at scale. Cloud-based software solutions allow for seamless, automated security patches across vast geographic areas.

• Multi-Cloud Redundancy: Relying on a single server point creates a high risk of failure. Scalable enterprise environments ensure continuous MQTT bridge connectivity, keeping devices online even during regional hardware outages.
• Preparing for AI Workloads: Adopting advanced cloud networks natively supports the integration of machine learning tools. This capability turns raw sensor telemetry into actionable business intelligence without slowing down core network operations.

Preparing for the Future of Connectivity

Cloud adoption continues to accelerate across Australia, supporting innovation, business growth, and the expansion of the technology sector. Taking a project from a single microcontroller node to a commercial enterprise network is a significant technical leap. By recognising the limitations of local prototypes and investing in scalable cloud infrastructure early, developers and businesses alike can build resilient, future-ready networks capable of supporting the next generation of connected devices.

The post How to Scale IoT Networks from Local Prototypes to Enterprise Clouds appeared first on Microcontroller Tutorials.

The antenna connection is part of a carefully designed radio-frequency path. The antenna, connector, coaxial cable, PCB trace, matching components, and surrounding ground plane all affect how much of the ESP32's transmitted power is actually radiated.

In this tutorial, we will look at the safest ways of adding an external antenna to an ESP32. This includes choosing a module with a factory-installed U.FL connector, changing an antenna selection jumper, modifying an existing PCB, selecting the correct antenna, and positioning it inside the finished project.

Important: The antenna arrangement differs between ESP32 boards. Before moving or removing any component, find the schematic for your exact development board and inspect the RF section under magnification.

Why Add an External Antenna to an ESP32?

Most ESP32 development boards already contain a small meandered PCB antenna. For a board sitting openly on a desk, this antenna is often sufficient. Problems usually appear after the board is installed in the final product.

An external antenna may be useful when:

• The ESP32 is installed inside a metal enclosure.
• A battery, LCD, motor, relay, or large PCB is close to the built-in antenna.
• The device must communicate through several walls.
• The ESP32 is located near the edge of the access point's coverage.
• The product needs an antenna mounted outside its enclosure.
• The orientation of the built-in PCB antenna is unsuitable for the installation.
• A directional antenna is required for a fixed point-to-point link.

An external antenna does not automatically guarantee longer range. A badly positioned external antenna connected through a poor cable can perform worse than the original PCB antenna. The entire wireless link must be considered.

A simplified link budget can be written as:

$P_R = P_T + G_T + G_R - L_{path} - L_{cable} - L_{mismatch}$

Here, P_R is the received power, P_T is the transmitted power, G_T and G_R are antenna gains, and the remaining terms represent path, cable, and impedance mismatch losses.

This equation explains why installing a higher-gain antenna may not help when a long, lossy cable or an incorrectly modified RF trace introduces additional losses.

Understand Which Type of ESP32 Board You Have

The term “ESP32 board” can refer to the ESP32 chip, a shielded ESP32 module, or a complete development board. The antenna may be part of any one of these assemblies.

ESP32 Modules with External Antenna Connectors

Espressif sells several module families in separate PCB-antenna and external-antenna versions. Examples include:

The letter U commonly indicates an external-antenna connector in Espressif module names. However, this naming convention should not be assumed for every third-party board. Always verify the full module number printed on the metal shield.

A module such as the ESP32-WROOM-32UE does not contain the familiar meandered PCB antenna. Its RF output is routed directly to the small connector on the module. This is normally the easiest and most reliable option for adding an external antenna.

What Is a U.FL Connector?

U.FL is a miniature 50 Ω coaxial connector family made by Hirose. ESP32 sellers sometimes call the same connector an IPEX connector. More precisely, Espressif's first-generation external antenna connector is compatible with Hirose U.FL, I-PEX MHF I, and Amphenol AMC cable plugs.

These connectors are very small and should be handled carefully. The cable plug must be centered directly over the board receptacle and pressed vertically downward. When correctly connected, it should produce a small tactile click.

Do not press the connector at an angle. Doing so can bend the center contact or pull the receptacle away from the PCB.

Also be careful when ordering cables. I-PEX MHF I and MHF 4 are different connector families. An MHF 4 cable is smaller and should not be forced onto a first-generation U.FL or MHF I receptacle.

U.FL-to-SMA Pigtails

A common arrangement uses a short U.FL-to-SMA coaxial pigtail. The U.FL end connects to the ESP32 module, while the SMA end is mounted through the enclosure. A larger external whip antenna then screws onto the SMA connector.

This arrangement provides two advantages:

• The fragile U.FL connector remains protected inside the enclosure.
• The external antenna can be replaced without repeatedly disconnecting the U.FL plug.

Choose the SMA end carefully. SMA and reverse-polarity SMA connectors look similar but have different center contacts. Verify that the panel connector and antenna are compatible before ordering.

Method 1: Use an ESP32 Module with a Factory U.FL Connector

The best method is to begin with a board or module designed for an external antenna. Examples include development boards populated with an ESP32-WROOM-32UE, ESP32-S3-WROOM-1U, or ESP32-C3-WROOM-02U.

Parts Required

• ESP32 development board with an external-antenna module
• Compatible U.FL or MHF I cable assembly
• 2.4 GHz, 50 Ω antenna suitable for the module
• Optional U.FL-to-SMA bulkhead pigtail
• Plastic connector tool or fine nonmetallic tweezers

Connection Procedure

1. Disconnect USB power and any external power supply.
2. Confirm the connector type using the module datasheet.
3. Inspect the U.FL receptacle for contamination or damage.
4. Align the cable plug directly over the receptacle.
5. Press downward on the metal connector body rather than on the cable.
6. Route the cable so that it does not pull sideways on the connector.
7. Add strain relief to the cable several millimeters away from the receptacle.
8. Install the antenna before applying power.

Do not attach adhesive, epoxy, or hot glue directly over the connector until the connection has been tested. Strain relief should hold the cable to the main PCB without pulling on the RF receptacle.

Method 2: Move the ESP32 Antenna Selection Jumper

Some development boards contain both a PCB antenna and a U.FL-style connector. Only one path should normally be active. A small zero-ohm resistor or solder bridge connects the ESP32's RF feed to the selected antenna.

This arrangement is particularly common on some ESP32 camera boards and compact IoT development boards.

How the Three-Pad Selector Works

A typical selector contains three pads:

• The center pad is connected to the ESP32 RF output.
• One outside pad leads to the built-in PCB antenna.
• The other outside pad leads to the U.FL connector.

A zero-ohm resistor bridges the center pad to one of the two antenna paths. To select the external antenna, the resistor is removed from the PCB-antenna path and installed between the center pad and the connector path.

The arrangement is not identical on every board. The external path may be above, below, or beside the original jumper. Never assume that rotating the resistor by 90 degrees is correct without tracing the circuit.

Tools Required

• Fine-tip temperature-controlled soldering iron
• Fine soldering tweezers
• Flux
• Solder wick
• Magnification
• ESD-safe work surface
• Multimeter for checking shorts and continuity

Modification Procedure

1. Remove all power from the board.
2. Take a clear photograph of the original jumper position.
3. Identify the radio feed, PCB antenna route, and connector route from the schematic or PCB traces.
4. Apply a small amount of flux to the zero-ohm resistor.
5. Heat both ends evenly and lift the component with tweezers.
6. Clean the pads using solder wick if necessary.
7. Place the resistor between the RF feed pad and the external-connector pad.
8. Inspect the joint under magnification.
9. Check that the PCB antenna path is no longer connected.
10. Connect the external antenna before powering the ESP32.

A solder blob can sometimes be used instead of reinstalling the zero-ohm resistor, but it must not bridge all three pads. Connecting the PCB antenna and external antenna simultaneously creates an uncontrolled RF junction that can cause severe impedance mismatch.

A multimeter can identify an accidental short or open circuit, but it cannot prove that the RF path has a 50 Ω characteristic impedance at 2.4 GHz. Proper RF performance must be evaluated through signal, throughput, or network-analyzer testing.

Method 3: Add a Coaxial Connection to a Board Without U.FL

This is the most difficult method and should normally be used only for experimentation. If a standard ESP32-WROOM module already contains the PCB antenna, the RF path is part of the module itself. The carrier board does not usually provide a convenient antenna feed that can be modified.

For this type of board, replacing the complete module or development board with an external-antenna version is usually safer than cutting into the module's PCB antenna.

When a Direct PCB Modification Is Possible

A modification may be possible when:

• The RF feed trace is visible and accessible.
• The board contains an exposed matching network.
• The existing PCB antenna can be disconnected without disturbing the matching components.
• A nearby ground point is available for the coaxial shield.
• The modification is being performed on a prototype rather than a certified production product.

Why a Loose Wire Is Not Recommended

A common shortcut is to solder a random wire to the antenna feed. Although the wire may radiate some RF energy, it does not provide a controlled 50 Ω connection. The exposed section of wire, ground geometry, nearby objects, and solder joint all become part of the antenna.

The free-space wavelength at 2.4 GHz is approximately:

$\lambda = \frac{c}{f} \approx 125\text{ mm}$

A free-space quarter wavelength is therefore approximately:

$\frac{\lambda}{4} \approx 31\text{ mm}$

This does not mean that soldering a 31 mm wire to the ESP32 will produce a properly matched antenna. Practical antennas are affected by conductor width, ground plane dimensions, dielectric material, enclosure, loading, and nearby components.

Recommended Direct-Modification Approach

When a direct modification is unavoidable, use a short length of 50 Ω micro-coaxial cable rather than an unshielded wire.

1. Locate the antenna feed and matching network.
2. Determine which side of the series component is connected to the radio.
3. Remove the jumper or cut the trace leading to the built-in antenna.
4. Solder the coaxial cable's center conductor to the radio-side RF feed.
5. Solder the coaxial shield to ground immediately beside the feed point.
6. Keep the exposed center conductor extremely short.
7. Secure the cable to the PCB so movement does not pull on the RF pad.
8. Terminate the other end at a proper U.FL, SMA, or other 50 Ω connector.

The shield connection is as important as the center conductor. A long shield lead creates inductance and can make an otherwise short connection behave poorly at 2.4 GHz.

Do not scrape or cut the antenna trace while the board is powered. Avoid excessive heat because small RF pads can separate easily from the PCB.

Designing an External Antenna Connection on a Custom ESP32 PCB

If you are creating a custom ESP32 board, the RF connection should be designed into the PCB rather than added afterward.

The RF trace between the matching network and antenna connector should have a characteristic impedance of approximately 50 Ω. The correct trace width depends on:

• PCB dielectric thickness
• Copper thickness
• Dielectric constant
• Distance to the reference ground plane
• Whether the trace is microstrip or coplanar waveguide
• Spacing between the trace and surrounding ground copper

Because these values depend on the PCB manufacturer's stack-up, copying the RF trace width from another board does not guarantee the correct impedance.

RF Layout Guidelines

• Keep the RF trace as short as possible.
• Do not create branches or stubs in the antenna path.
• Keep the trace width consistent.
• Avoid routing the RF trace through vias.
• Maintain a continuous ground reference beneath the trace.
• Use ground vias along the sides of a coplanar RF trace.
• Keep crystals, high-speed clocks, USB lines, UART lines, and switching regulators away from the antenna section.
• Place the matching network close to the ESP32 RF output or antenna as directed by the reference design.
• Keep copper and signal traces away from the connector area where required by the connector footprint.
• Include a pi or CLC matching footprint even when the initial design uses zero-ohm or unpopulated components.

The matching network gives you a way to compensate for the final PCB, connector, enclosure, and antenna during RF testing. The correct matching values normally require a vector network analyzer or equivalent RF measurement setup.

Choosing the Correct ESP32 External Antenna

The antenna must match the radio, connector, installation, and certification requirements of the exact ESP32 module.

Frequency

Common ESP32, ESP32-C3, and ESP32-S3 modules operate their Wi-Fi and Bluetooth radios in the 2.4 GHz band. A 2.4 GHz Wi-Fi or Wi-Fi/Bluetooth antenna is therefore required for these modules.

Do not select an antenna only because it physically fits the connector. An antenna intended only for GPS, cellular, LoRa, or sub-GHz operation may have very poor performance at 2.4 GHz.

For newer ESP32 variants supporting additional radio bands, use an antenna specified for every band that the design will use.

Impedance

The antenna and cable should have a nominal impedance of 50 Ω. This matches the RF system used by the ESP32 module and standard Wi-Fi antenna assemblies.

Antenna Gain

Higher gain does not mean that the antenna generates additional power. It concentrates radiation in particular directions while reducing it in others.

For example, a vertical high-gain whip may provide more horizontal coverage but create weaker areas directly above or below the antenna. A low-gain antenna may produce a more useful radiation pattern for a device whose orientation changes.

Certification must also be considered. Some Espressif external-antenna module datasheets specify the antenna used during certification and recommend that replacement antenna gain not exceed that value. The ESP32-WROOM-32UE and ESP32-S3-WROOM-1U documentation, for example, specifies a 2.4 GHz, 50 Ω antenna and lists 2.33 dBi as the certification antenna's maximum gain.

That value should not automatically be applied to every ESP32 module. Check the datasheet and certification documents for your exact part number. Using a different antenna type or higher gain may require additional EMC or regulatory testing.

External Whip Antenna

A screw-on whip antenna is useful when the antenna can be mounted outside the enclosure. It is easy to replace and can be oriented after installation.

Adhesive FPC Antenna

An adhesive flexible antenna can be installed inside a plastic enclosure. It should be mounted according to the antenna manufacturer's instructions. Some flexible antennas are designed to operate against a specific ground plane, while others require clearance from metal.

Do not fold, cut, or sharply bend the active antenna section. The coaxial cable may usually be routed around the enclosure, but the radiating element should remain in its intended shape.

PCB Antenna

A separate PCB antenna can be connected through a coaxial cable and mounted away from the ESP32 board. As with an FPC antenna, the antenna's ground-plane and clearance requirements must be followed.

Directional Antenna

A patch, panel, or Yagi-style antenna may be useful for a fixed point-to-point connection. It must be aimed correctly and may not be suitable for devices that move or need coverage in several directions.

ESP32 Antenna Placement

Antenna placement is often more important than antenna gain. Moving an ordinary antenna away from metal and electrical noise can produce a greater improvement than replacing it with a higher-gain antenna in the same poor location.

Keep the Antenna Away from Metal

Metal close to an antenna can block radiation and change its resonant frequency. Avoid placing the antenna directly against:

• Metal enclosures
• Large batteries
• Heat sinks
• LCD frames
• Metal mounting plates
• Large connectors
• Shielding cans

When using a metal enclosure, mount the antenna outside through a bulkhead connector. The coaxial cable can pass through the wall while the antenna remains in free space.

Keep the Antenna Away from Noise Sources

Switching regulators, DC motors, relays, high-speed displays, USB circuits, memory buses, and digital clocks can introduce interference. Place the antenna and its cable away from these circuits whenever possible.

Do not route the antenna cable parallel to high-current motor or relay wiring. If the paths must cross, crossing at approximately 90 degrees is generally preferable to running them together.

Respect the PCB Antenna Keepout Area

When using an ESP32 module's built-in PCB antenna, place the antenna end at the edge of the carrier PCB. Allowing the antenna to extend beyond the edge is usually the preferred arrangement.

If the antenna cannot extend past the board, there should be no copper, traces, or components under or beside the active antenna region. Espressif recommends providing at least 15 mm of clearance around the PCB antenna inside the finished enclosure.

The exact keepout geometry should come from the hardware design guide for the selected module.

Consider Polarization

A straight whip antenna normally has linear polarization. For communication with a typical access point whose antennas are vertical, starting with the ESP32 antenna vertically oriented is reasonable.

Rotating one antenna by 90 degrees relative to the other can reduce the received signal. Reflections inside buildings may reduce or change this effect, so the final orientation should still be tested experimentally.

Do Not Coil the Cable Around the Antenna

Extra coaxial cable should be routed away from the radiating element. Do not wrap it tightly around the whip or place a coil directly behind an adhesive antenna. The cable shield and nearby conductive objects can alter the antenna pattern.

Test the Finished Enclosure

An antenna that performs well on an open workbench may behave differently after the enclosure, battery, display, and wiring are installed. Always evaluate the complete assembled product.

Testing the ESP32 Antenna Modification

Test the original antenna before making the modification so that you have a baseline. Use the same ESP32 board, access point, location, power supply, orientation, and firmware for both tests.

Useful measurements include:

• Average RSSI
• Packet loss
• Connection and reconnection time
• TCP or UDP throughput
• Maximum usable distance
• Performance through walls
• Performance at different antenna orientations

RSSI is measured in dBm. Values closer to zero represent a stronger received signal. Because RSSI changes with movement, reflections, and nearby people, compare averages rather than relying on one reading.

Arduino RSSI Test Sketch

The following sketch connects to an access point and prints individual RSSI readings followed by their average:

#include <WiFi.h>

const char *ssid = "YOUR_WIFI_SSID";
const char *password = "YOUR_WIFI_PASSWORD";

const int sampleCount = 20;
const unsigned long sampleDelayMs = 500;

void setup() {
  Serial.begin(115200);
  delay(1000);

  WiFi.mode(WIFI_STA);
  WiFi.begin(ssid, password);

  Serial.print("Connecting");

  unsigned long startTime = millis();

  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");

    if (millis() - startTime > 30000) {
      Serial.println("\nConnection timed out.");
      return;
    }
  }

  Serial.println("\nConnected.");
  Serial.print("IP address: ");
  Serial.println(WiFi.localIP());
  Serial.print("BSSID: ");
  Serial.println(WiFi.BSSIDstr());
}

void loop() {
  if (WiFi.status() != WL_CONNECTED) {
    Serial.println("Wi-Fi disconnected.");
    delay(2000);
    return;
  }

  long rssiTotal = 0;

  Serial.println("Collecting RSSI samples:");

  for (int i = 0; i < sampleCount; i++) {
    int32_t rssi = WiFi.RSSI();
    rssiTotal += rssi;

    Serial.print("Sample ");
    Serial.print(i + 1);
    Serial.print(": ");
    Serial.print(rssi);
    Serial.println(" dBm");

    delay(sampleDelayMs);
  }

  float averageRssi = (float)rssiTotal / sampleCount;

  Serial.print("Average RSSI: ");
  Serial.print(averageRssi, 1);
  Serial.println(" dBm\n");

  delay(3000);
}

Record several test runs with the original antenna and several more with the external antenna. Do not hold the board or antenna during one test and place it on a table during another. Your hand can affect the antenna and invalidate the comparison.

Use More Than RSSI

An improved RSSI reading does not always mean that the entire connection is better. Interference, packet retries, antenna pattern, and access-point behavior can affect actual data transfer.

For a more useful evaluation, transfer a large file or run a local TCP throughput test while monitoring packet loss and disconnections. Repeat the test in the location where the device will actually operate.

Troubleshooting an ESP32 External Antenna

The External Antenna Performs Worse

Check the following:

• The zero-ohm jumper may still select the PCB antenna.
• Both antenna paths may accidentally be connected.
• The U.FL plug may not be fully seated.
• The antenna may be designed for the wrong frequency.
• The antenna may be too close to metal.
• The coaxial cable may be damaged or excessively long.
• The antenna may have a null in the direction of the access point.
• The connector or RF pad may have been damaged during soldering.

Wi-Fi Works Only When the Board Is Close to the Router

This often indicates an open or badly mismatched antenna path. Inspect the selector resistor and U.FL connection. Confirm that the antenna is connected to the radio side of the matching network rather than to the isolated PCB-antenna side.

The Signal Changes When the Cable Is Touched

A large change when touching the cable can indicate that the cable shield is not properly grounded, the connector is loose, or an exposed section of conductor is acting as part of the antenna.

The U.FL Connector Detached from the PCB

Do not attempt to glue it back in place and expect the RF path to work. The center signal pad and surrounding ground pads must be electrically restored. If the pads have lifted, repair normally requires microscope-assisted micro-soldering and a careful RF connection.

The Board Resets While Transmitting

This problem is more likely related to the power supply than the antenna. Wi-Fi transmission produces short current peaks. Check the 3.3 V regulator, USB cable, supply wiring, and decoupling capacitors.

Frequently Asked Questions

Can I connect an antenna directly to an ESP32 GPIO?

No. The Wi-Fi and Bluetooth antenna uses the ESP32's RF output path, not a general-purpose input/output pin. Connecting an antenna to a GPIO will not improve radio range and may expose that GPIO to unwanted RF signals or static discharge.

Can I use the PCB antenna and external antenna at the same time?

Not by simply connecting both paths together. A passive split creates an impedance mismatch and divides transmitted power. A proper diversity or dual-antenna design requires an RF switch, matching network, and support from the selected ESP32 variant and firmware.

Can I solder an SMA connector directly to the board?

Only when the board has a correctly designed 50 Ω RF footprint and sufficient mechanical support. A full-size SMA connector is too large to hang from a small antenna feed pad. A short micro-coaxial pigtail connected to a panel-mounted SMA connector is usually safer.

Will a 9 dBi antenna give three times the ESP32 range?

Not necessarily. Gain is directional, cable loss reduces the improvement, and the other end of the connection must still receive and return data. Higher gain may also exceed the antenna conditions used for the module's regulatory certification.

Does the external antenna improve both Wi-Fi and Bluetooth?

On common ESP32 modules, Wi-Fi and Bluetooth share the 2.4 GHz RF path. A correctly selected external antenna can therefore affect both. The exact internal radio arrangement should still be confirmed in the datasheet for the selected ESP32 variant.

Can I operate an external-antenna ESP32 without an antenna?

Avoid intentionally transmitting for extended periods without an antenna. An open connector produces a severe impedance mismatch, greatly reduces communication performance, and may stress the RF output stage.

Is firmware configuration required after moving the antenna jumper?

Normally, no. A passive zero-ohm antenna selector changes the physical RF path and is not controlled by software. Boards using an electronic RF switch or antenna-diversity circuit may require GPIO or ESP-IDF configuration.

Summary

The safest way of adding an external antenna to an ESP32 is to use a module designed for it, such as an ESP32-WROOM-32UE or ESP32-S3-WROOM-1U. The factory connector preserves the module's controlled RF path and avoids cutting the built-in PCB antenna.

For boards containing both a PCB antenna and a U.FL connector, locate the antenna selector and move its zero-ohm jumper to the external path. Do not leave both antenna paths connected.

Directly modifying a PCB-antenna module is possible in some cases, but it requires isolating the existing antenna and attaching a properly grounded 50 Ω micro-coaxial cable. A loose wire is not a reliable substitute for a matched antenna connection.

Finally, pay close attention to placement. Keep the antenna away from metal, high-speed circuits, batteries, displays, and noisy wiring. Test the complete device in its final enclosure using RSSI, packet loss, and actual throughput rather than assuming that a larger antenna will automatically provide better range.

The post Adding an External Antenna to ESP32: U.FL, PCB Modifications, and Placement appeared first on Microcontroller Tutorials.

You may notice that the measured voltage is lower than expected, the first reading is different from the following readings, or one ADC channel appears to affect another. These symptoms are often blamed on analog input leakage current. Leakage is part of the problem, but the ESP32-S3's switched-capacitor ADC input also creates a temporary load whenever a conversion starts.

In this article, we will examine how ESP32-S3 analog input leakage affects high-impedance circuits and how to design an ADC input that produces stable and repeatable readings.

How the ESP32-S3 ADC Input Works

The ESP32-S3 contains two 12-bit successive-approximation ADC units. Together, they provide 20 analog input channels:

For most projects, ADC1 is the better choice. Espressif recommends ADC1, and ADC2 analog functions cannot be used normally while Wi-Fi is using the ADC2 peripheral.

A 12-bit conversion produces values from 0 to 4095. However, the raw result is not automatically equal to an exact voltage because the internal reference voltage varies from one chip to another. The ESP32-S3 reference is designed around 1.1 V, but its actual value can vary approximately from 1.0 V to 1.2 V. For this reason, calibrated voltage functions should be used whenever possible.

What Is Analog Input Leakage Current?

An ideal ADC input would have infinite resistance and draw no current from the measured circuit. A real microcontroller pin contains protection structures, switches, multiplexers, transistors, parasitic capacitance, and internal analog circuitry. Small currents can therefore flow into or out of the pin.

When the source resistance is low, this current produces almost no visible error. When the source resistance is hundreds of kilohms or several megohms, even a tiny current can create a measurable voltage drop.

The approximate DC error caused by leakage is:

$V_{error}=I_{leak}\times R_{source}$

For example, suppose an analog source has an equivalent resistance of 200 kΩ. The resulting errors would be:

The ESP32-S3 datasheet specifies a maximum high-level and low-level digital GPIO input current of 50 nA under its stated DC test conditions. However, this value should not be treated as a guaranteed ADC input leakage specification. The datasheet does not provide a separate worst-case analog leakage value covering ADC conversions, attenuation settings, temperature, board contamination, and all operating modes.

For a high-impedance design, it is safer to consider the 50 nA figure only as a pin-level reference. The complete ADC circuit should be tested across temperature and operating conditions, or isolated from the signal source using an analog buffer.

The ADC Is a Dynamic Load

Leakage current explains steady DC error, but it does not explain every problem seen with high-impedance inputs. The ESP32-S3 uses a successive-approximation ADC, which includes an internal sampling network.

At the beginning of a conversion, an internal switch briefly connects the selected GPIO to a sampling capacitor. The input source must provide enough charge for this capacitor to approach the input voltage during the available acquisition period.

A simplified settling relationship is:

$V_{error}=V_{step}e^{-\frac{t_{acq}}{R_{source}C_{sample}}}$

Here, Rsource is the source resistance, Csample is the effective internal sampling capacitance, and tacq is the acquisition time.

As the source resistance increases, the capacitor takes longer to charge. If the ADC starts its conversion before the voltage settles, the result can be lower or higher than the actual signal. This effect may appear even when the static leakage current is extremely small.

The internal attenuation network also changes the signal path. Consequently, source loading and conversion error may vary with the selected attenuation setting.

Why the First ADC Reading Can Be Wrong

The ADC input multiplexer connects several analog channels to the same converter. When software changes from one channel to another, the sampling network can retain a small amount of charge from the previous channel.

A low-impedance source quickly replaces this charge. A high-impedance source may require more time. The first reading can therefore be influenced by:

• The voltage previously measured on another ADC channel
• Residual charge in the sampling network
• The selected attenuation setting
• The external filter capacitor
• The time between channel selection and conversion

A common software solution is to perform one dummy conversion after changing channels and discard its result. This helps, but it does not replace proper analog input design.

High-Value Resistor Divider Example

Consider a circuit that measures a supply voltage of up to 15 V. To minimize battery drain, we use a 1 MΩ upper resistor and a 220 kΩ lower resistor.

The voltage presented to the ESP32-S3 is:

$V_{ADC}=V_{IN}\frac{R_{BOTTOM}}{R_{TOP}+R_{BOTTOM}}$

At 15 V:

$V_{ADC}=15\frac{220000}{1000000+220000}=2.705\text{ V}$

This keeps the input below the ESP32-S3 datasheet's 2.9 V effective calibrated range for the highest attenuation setting.

The divider current at 15 V is:

$I_{DIV}=\frac{15}{1000000+220000}=12.3\mu\text{A}$

The ADC does not see 1.22 MΩ as its source resistance. The Thevenin resistance at the divider output is:

$R_{TH}=R_{TOP}\parallel R_{BOTTOM}$

$R_{TH}=\frac{1000000\times220000}{1000000+220000}=180.3\text{ k}\Omega$

This is still a relatively high source impedance. An assumed leakage current of 100 nA would produce approximately:

$V_{error}=100\text{ nA}\times180.3\text{ k}\Omega=18.0\text{ mV}$

At the original 15 V input, the equivalent error is multiplied by the divider ratio:

$V_{IN_error}=18.0\text{ mV}\times\frac{1220000}{220000}\approx100\text{ mV}$

This calculation only estimates static leakage error. Sampling transients, resistor tolerance, ADC error, noise, temperature, and PCB leakage can add further error.

Adding a Capacitor to the ADC Input

Espressif recommends placing a 0.1 µF capacitor between the ADC pin and ground. The capacitor performs two useful functions:

• It filters high-frequency noise before it reaches the ADC.
• It acts as a local charge reservoir for the ADC sampling capacitor.

For the 1 MΩ and 220 kΩ divider, the approximate time constant with a 0.1 µF capacitor is:

$\tau=R_{TH}C$

$\tau=180.3\text{ k}\Omega\times0.1\mu\text{F}=18.0\text{ ms}$

A capacitor is normally considered nearly settled after about five time constants:

$t_{settle}\approx5\tau=90\text{ ms}$

If the divider is permanently connected, the capacitor remains charged and this delay is not usually needed before every measurement. If the divider is switched on only when a reading is required, the firmware should wait approximately 90 to 100 ms before sampling.

The capacitor and divider also create a low-pass filter. Its approximate cutoff frequency is:

$f_c=\frac{1}{2\pi R_{TH}C}$

$f_c=\frac{1}{2\pi(180.3\text{k}\Omega)(0.1\mu\text{F})}\approx8.8\text{ Hz}$

This is suitable for battery voltage, temperature, and other slowly changing signals. It may be too slow for audio, vibration, or fast control signals.

Method 1: Reduce the Divider Resistance

The simplest way to reduce loading error is to use lower resistor values. A 100 kΩ and 22 kΩ divider has the same ratio as the 1 MΩ and 220 kΩ divider, but its Thevenin resistance is only about 18 kΩ.

The lower-value divider consumes more current, but it is less affected by leakage, PCB contamination, and ADC sampling transients.

For mains-powered equipment, the additional current may not matter. For a battery-powered sensor that sleeps most of the time, a switched divider may provide a better compromise.

Method 2: Use a Switched Voltage Divider

A switched divider keeps the resistors disconnected while the ESP32-S3 is sleeping. The firmware enables the divider shortly before taking a measurement and disables it afterward.

A high-side P-channel MOSFET or a low-leakage analog load switch can be used to connect the upper resistor to the measured supply. After enabling the circuit, wait for the divider and filter capacitor to settle.

The switch itself must also be selected carefully. MOSFET off-state leakage, gate leakage, and contamination around the ADC node may become significant when using megohm resistors.

A low-side switch should generally be avoided for this application because it can leave the ADC pin connected to the measured voltage through the upper resistor while the lower resistor is disconnected. This can make the pin float, forward-bias protection structures, or create an unexpected current path.

Method 3: Buffer the Signal with an Op-Amp

For very high-impedance sensors, the best solution is usually a voltage follower.

The sensor or resistor network connects to the op-amp input, while the op-amp output drives the ESP32-S3 ADC. The op-amp presents a very high input resistance to the sensor and a low output resistance to the ADC.

Look for the following characteristics:

• Very low input bias current
• Operation from a 3.3 V supply
• Rail-to-rail input and output
• Input common-mode range that includes the measured signal
• Output swing that covers the required ADC voltage range
• Low offset voltage and low drift
• Stability when driving a capacitive load

A small resistor, typically between 100 Ω and 1 kΩ, can be placed between the op-amp output and the ADC capacitor. This resistor isolates the amplifier from the capacitor and can improve stability.

Some sensor types have an impedance so high that they should never be connected directly to a microcontroller ADC. In such cases, an amplifier designed for extremely low input bias current is required.

Method 4: Improve PCB Layout and Cleanliness

At megohm impedance levels, the PCB becomes part of the analog circuit. Flux residue, dust, moisture, solder mask contamination, and fingerprints can create leakage paths comparable to the signal current.

Use these layout practices:

• Keep the high-impedance trace short.
• Place the filter capacitor close to the ESP32-S3 pin.
• Keep the trace away from switching regulators, clocks, USB, and antenna circuitry.
• Avoid routing digital signals parallel to the ADC trace.
• Clean flux residue from the board.
• Use a ground plane around ordinary low-level analog traces.
• For extremely high impedance, consider a driven guard around the sensitive node.

Also make sure that internal pull-up and pull-down resistors are disabled on the ADC pin. These resistors are approximately tens of kilohms and will completely disturb a high-value divider.

Choosing the ADC Attenuation

The ESP32-S3 ADC supports several attenuation settings. Higher attenuation permits a larger voltage at the pin but usually produces more conversion error near the upper end of the range.

The Arduino API continues to use the name ADC_ATTEN_DB_11, while newer ESP-IDF documentation may describe the highest attenuation as 12 dB.

For best accuracy, do not design the divider so that the maximum expected voltage is exactly at the upper ADC limit. Leave margin for supply variation, resistor tolerance, transients, and calibration error.

Arduino ESP32-S3 ADC Example

The following sketch reads a high-value 1 MΩ and 220 kΩ divider connected to GPIO4. GPIO4 is an ADC1 pin on the ESP32-S3.

The circuit should include a 0.1 µF ceramic capacitor from GPIO4 to ground.

#include <Arduino.h>

const uint8_t ADC_PIN = 4;

const float R_TOP = 1000000.0f;
const float R_BOTTOM = 220000.0f;

const uint8_t SAMPLE_COUNT = 32;

uint32_t readAdcMillivolts()
{
    uint64_t total = 0;

    // Dummy conversion to help the ADC input settle.
    (void)analogRead(ADC_PIN);
    delayMicroseconds(500);

    for (uint8_t i = 0; i < SAMPLE_COUNT; i++)
    {
        total += analogReadMilliVolts(ADC_PIN);
        delayMicroseconds(500);
    }

    return (uint32_t)(total / SAMPLE_COUNT);
}

float readInputVoltage()
{
    const uint32_t adcMillivolts = readAdcMillivolts();
    const float adcVoltage = adcMillivolts / 1000.0f;

    return adcVoltage * (R_TOP + R_BOTTOM) / R_BOTTOM;
}

void setup()
{
    Serial.begin(115200);

    analogReadResolution(12);
    analogSetPinAttenuation(ADC_PIN, ADC_ATTEN_DB_11);

    delay(100);
}

void loop()
{
    const uint32_t adcMillivolts = readAdcMillivolts();
    const float inputVoltage =
        (adcMillivolts / 1000.0f) *
        (R_TOP + R_BOTTOM) / R_BOTTOM;

    Serial.printf(
        "ADC: %lu mV, Input: %.3f V\n",
        (unsigned long)adcMillivolts,
        inputVoltage
    );

    delay(1000);
}

The analogReadMilliVolts() function returns a calibrated voltage rather than an uncorrected raw ADC count. Averaging reduces random noise, while the dummy conversion helps after the input multiplexer or attenuation circuitry has changed state.

The code does not compensate for resistor tolerance, leakage, PCB contamination, or gain and offset error in the complete circuit. Final calibration should be performed using a trusted multimeter or voltage reference.

Two-Point Calibration

For better accuracy, apply two known input voltages and record the corresponding ESP32-S3 readings. The corrected voltage can then be represented as:

$V_{corrected}=mV_{measured}+b$

The gain is:

$m=\frac{V_{actual2}-V_{actual1}}{V_{measured2}-V_{measured1}}$

The offset is:

$b=V_{actual1}-mV_{measured1}$

Store the resulting gain and offset in flash or non-volatile storage. This calibration corrects consistent gain and offset errors, but it cannot fully correct unstable leakage, insufficient settling time, or temperature-dependent errors.

Sampling High-Impedance ADC Channels

Use the following sampling sequence when reading a high-impedance source:

1. Enable the divider or sensor power, when applicable.
2. Wait for the external RC network to settle.
3. Select the ADC channel and attenuation.
4. Perform one dummy conversion.
5. Take multiple calibrated readings.
6. Average or median-filter the samples.
7. Disable the measurement circuit when finished.

Do not sample faster than the source and filter network can settle. Increasing the sample rate does not improve a circuit whose source cannot recharge the ADC input between conversions.

If several ADC channels have very different voltages, consider reading each channel twice and discarding the first conversion. A buffer amplifier for each high-impedance channel provides a more reliable solution.

Wi-Fi and ADC Noise

ADC1 can be used while Wi-Fi is active, but wireless transmission causes rapidly changing current consumption. These current pulses can introduce noise into the power and ground networks.

For precision measurements:

• Use ADC1 instead of ADC2.
• Add proper supply decoupling near the ESP32-S3.
• Place the ADC capacitor close to the pin.
• Avoid taking critical readings during Wi-Fi transmission.
• Average several readings.
• Consider temporarily stopping wireless activity during calibration or precision sampling.

The ESP32-S3 datasheet's ADC characterization was performed with a 100 nF capacitor, a DC input signal, an ambient temperature of 25 °C, and Wi-Fi disabled. A real application may therefore show more noise than the published test results.

Common ESP32-S3 High-Impedance ADC Problems

ESP32-S3 High-Impedance ADC Design Checklist

• Prefer GPIO1 to GPIO10 on ADC1.
• Keep the maximum ADC voltage below the calibrated effective range.
• Add approximately 0.1 µF between the ADC pin and ground.
• Calculate the divider's Thevenin resistance.
• Estimate leakage error using the required voltage accuracy.
• Allow at least five external RC time constants after switching the circuit on.
• Discard the first reading after changing channels.
• Average multiple calibrated readings.
• Disable internal pull-up and pull-down resistors.
• Keep the ADC trace short and away from noisy signals.
• Clean the PCB when using megohm impedances.
• Use an op-amp buffer when the sensor impedance is very high.
• Calibrate the complete circuit, not only the ADC.

Conclusion

The ESP32-S3 ADC input should not be treated as an ideal infinite-resistance voltmeter. Static leakage current can create voltage error when the source impedance is high, while the ADC's internal sampling network can temporarily load the signal during each conversion.

A 0.1 µF capacitor at the ADC pin is an important starting point and is recommended by Espressif. However, the capacitor must be combined with adequate settling time, suitable divider values, ADC1 channel selection, averaging, careful PCB layout, and calibration.

For battery monitoring and other slowly changing signals, a high-value divider with a local capacitor may provide acceptable performance. For extremely high-impedance sensors or precision measurements, a low-bias-current op-amp buffer is the more reliable solution.

References

• Espressif ESP32-S3 Series Datasheet
• ESP32-S3 Hardware Design Guidelines
• Arduino-ESP32 ADC API
• ESP32-S3 ADC Calibration Driver

The post ESP32-S3 Analog Input Leakage Current: High-Impedance ADC Design appeared first on Microcontroller Tutorials.

There are users who also see the prompt when their login looks a bit different than usual or under certain trigger conditions. Still, there are a few legit ways you can lower the odds of seeing that prompt for Telegram登录短信费问题. If you want to know how, then this article is for you. 

Telegram Login Prompts: Reasons Why You’re Seeing Them

It seems like the login fee prompt is usually connected to specific instances. Telegram may charge a fee in certain regions. That’s where international SMS delivery is pricier. Also, the app security can request additional verification steps. This happens when the system senses a potentially risky sign-in action. 

The official explanation about the login fee prompt states that this is a one-time charge. If the user is using the same phone number and also the same device, or at least something close to the IP range, they can sign in to the same account again for a longer period after paying that $1 one time fee. There’s a chance that this could trigger again if you keep changing IPs or swapping devices.

How to Avoid Telegram Login Prompts

Not everyone gets the prompt. Instead, this depends on the account itself and how the login happens. Take these steps to avoid the telegram login prompts:

Use a different Telegram app (client)

One of the most suggested workarounds is to try another Telegram-compatible client. For Android, Telegram X is a good alternative. For iPhone users, try Nicegram. There's a good chance you will receive the login verification code without firing the SMS fee prompt. However, results are not guaranteed. 

Avoid Swapping Devices or Networks

Telegram’s security may be messed up if you keep changing your login setup. If you bounce between devices a lot, connect through various VPN servers, or your IP address changes frequently, it can increase the odds of extra verification steps. This can trigger the login fee prompt.

Enroll a Recovery Email

Once you’re logged in, add a recovery email address for your Telegram account. A confirmed email gives Telegram another way to verify it really is you the next time you try to log in. In many cases, email confirmation is frequently used instead of SMS. This can help you avoid the login verification fees.

Turn On Passkeys For Later Logins

Telegram also supports passkeys. This allows you passwordless sign-ins. It uses the security tools that you already have on your device. Passkeys can make future sign-ins easier while also reducing your reliance on SMS verification. 

Try Alternatives Before Paying the Fee

If the payment pop-up appears, it’s often smart to try the listed alternatives first before paying anything. Some users say the issue went away after switching clients or changing the way they log in, no payment needed. Also, there are claims that refunds might not be offered if you pay the fee but still can’t get the verification code. So, trying the free options first is a good way to prevent making the payment.

Conclusion

Even if the Telegram login fee doesn't affect everyone, it’s useful to understand why it appears so you can respond appropriately. Take note of the suggestions above. Instead of paying immediately, these tips might reduce the risk of incurring the SMS verification fee. Also, staying updated on Telegram’s newer login and security options can make account access feel easier.

The post Tips to Avoid the Telegram Login Prompt Fees appeared first on Microcontroller Tutorials.

Australia's digital advertising market has seen massive growth, reaching a record $4.9 billion in the first quarter of 2026 alone. Search advertising remains the dominant digital channel, accounting for roughly 44 percent of that expenditure. With total ad spend forecast to hit US$16.88 billion by the end of the year, there are massive scaling opportunities for tech startups that know how to manipulate marketing data. Today, local founders are treating their advertising budgets like software deployments, using application programming interfaces and automated data pipelines to effectively steer commercial algorithms.

Bridging the Gap Between Scraping and Advertising

Major platforms have largely removed manual bid controls as of 2026, transitioning entirely to AI-focused campaign types. As a result, programmatic automation has become essential for properly guiding algorithmic ad spend. However, automation algorithms are strictly dependent on pristine data.

Because official developer endpoints do not always return visual search layouts or localised competitor context, tech founders must actively scrape search engines to extract real-time placement data and AI Overview intelligence. Just as developers can engineer custom SEO tracking tools to monitor local ranking shifts, similar scraping principles can be adapted to fuel high-return paid search campaigns.

Extracting this ad intelligence comes with technical hurdles. Search engines have deployed aggressive bot mitigation tactics recently, meaning developers must utilise headless browsers, proxy rotation, and sophisticated stealth plugins to avoid IP bans while gathering their market research.

Architecting the Automated Campaign Pipeline

It is one thing to scrape data, but deploying it for commercial gain is another challenge entirely. Search marketing experts note that faulty web scraping or broken conversion tracking will actively misdirect machine learning budgets, wasting crucial startup capital.

Many founders prefer to build the initial data extraction infrastructure internally but rely on external specialists for the actual execution. For example, a tech startup might supply the raw backend infrastructure, but then partner with a specialised google ads agency Sydney to deploy that intelligence into highly optimised regional campaigns. This ensures the extracted data is properly formatted for commercial bidding algorithms.

When architecting an automated ad pipeline, developers should focus on several core technical upgrades:

• Transitioning legacy scripts to the V8 JavaScript engine, which enables significantly faster execution and the ability to write modern JavaScript for advanced bidding logic.
• Utilising robust frameworks like Playwright for web scraping. Playwright has largely overtaken Puppeteer for enterprise-grade scraping in 2026 due to its native support for isolated browser contexts across Python, Java, and .NET.
• Leveraging the updated Google Ads API monthly release cycle to access incremental automation features without breaking existing code.
• Integrating comprehensive performance metrics across Performance Max networks to give internal automation scripts richer conversion data.

The Financial Impact of Data-Driven Personalisation

The ultimate goal of connecting custom data extraction to an ad platform is operational efficiency. Manual campaign monitoring used to consume over 15 hours a week for marketing teams. By deploying API-based automation tools, tech startups can reduce that routine workload down to just two to three hours a week, freeing up time for product development.

Beyond saving time, granular data allows for automated triggers that speak directly to user behaviour at an individual level. According to McKinsey research, implementing data-driven personalisation at scale can reduce acquisition costs by up to 50 percent while improving overall marketing spend efficiency by 10 to 30 percent. Recent case studies from digital agencies mirror this, demonstrating that pairing granular feed data with automated bidding strategies can increase conversions by over 1,700 percent within a 90-day period.

For today's tech founder, mastering customer acquisition is less about traditional copywriting and more about building robust data feedback loops. By bridging the gap between sophisticated web scraping, modern APIs, and expert campaign management, hardware startups can ensure every advertising dollar works harder to capture local market share.

The post The Tech Founder's Guide to Automating Paid Search with APIs and Web Scraping appeared first on Microcontroller Tutorials.

With this tool, you can enter a PIC assembly instruction such as:

MOVLW 0x02

and see how the PIC16F84A fetches the instruction from program memory, places it into the instruction register, decodes the instruction bits, and routes the data through internal blocks such as the W register, RAM file registers, ALU, STATUS register, stack, program counter, and buses.

This is useful especially for beginners who are still trying to understand how PIC assembly instructions actually work.

Contents

• What the Instruction Trace Tool Does
• Why This Is Useful
• Opening the Tool
• Example 1: Tracing MOVLW 0x02
• Example 2: Tracing MOVWF 0x0C
• Example 3: Tracing CLRF 0x0C
• Using the Animate Button
• Understanding the Decoded Word
• Conclusion

What the Instruction Trace Tool Does

The PIC16F84A has only 35 instructions, which is one reason why it is a good microcontroller for beginners. However, each instruction still has its own binary format.

For example, MOVLW 0x02 is not stored inside program memory as text. The PIC does not see the letters M-O-V-L-W. Instead, the assembler converts it into a 14-bit instruction word:

11000000000010

The Instruction Trace tool shows this word visually. It also shows which bits represent the instruction opcode and which bits represent the operand.

For MOVLW 0x02, the lower 8 bits contain the literal value:

00000010

This is the value that will be loaded into the W register.

Why This Is Useful

When programming in assembly, you are working close to the hardware. A single instruction may affect the W register, file registers, program counter, stack, or STATUS flags.

For beginners, this can be confusing because the effect of an instruction is not always obvious just by reading the code.

The trace tool helps by showing:

• the fetched 14-bit instruction word
• the decoded opcode and operand fields
• the active internal blocks
• the data path used by the instruction
• the final value of W, file registers, STATUS flags, or PC
• the instruction cycle count
• the result of the instruction

Instead of only reading what an instruction does, you can now watch how the PIC processes it internally.

Opening the Tool

Go to:

https://picsimulator.com/instruction-trace.html

You will see an input field for the assembly instruction, state fields for initial register values, the internal PIC16F84A block diagram, and a decoded instruction word section.

To begin, type an instruction into the ASM command field.

Example 1: Tracing MOVLW 0x02

Enter this command:

MOVLW 0x02

MOVLW means “move literal to W”. The value

0x02

The tool shows the instruction word:

11000000000010

This is fetched from Flash Program Memory and moved into the Instruction Register.

The instruction is then decoded:

opcode = 110000
k      = 00000010

Here, k is the literal value. Since

00000010

After execution:

W = 0x02

In the block diagram, you should see the instruction move from program memory to the instruction register, then through the decode/control path, and finally to the W register.

Example 2: Tracing MOVWF 0x0C

Now enter:

MOVWF 0x0C

MOVWF means “move W to file register”.

Before running the trace, set the initial W value to something easy to see, for example:

Initial W = 0x35

The instruction tells the PIC to copy the contents of W into file register address

0x0C

After execution:

File register 0x0C = 0x35

This is a good instruction for learning how the W register and RAM file registers work together. The W register is not a normal RAM location, but many PIC instructions use it as the main working register.

Example 3: Tracing CLRF 0x0C

Next, enter:

CLRF 0x0C

CLRF means “clear file register”.

This instruction writes

0x00

After execution:

File register 0x0C = 0x00
STATUS.Z = 1

This is because the result of the operation is zero.

This is one of the important things to remember when writing PIC assembly: some instructions do more than just change a register. They may also affect STATUS flags, which can then affect later conditional instructions.

Using the Animate Button

The tool also includes an Animate button.

Clicking this button steps through the instruction flow automatically. This is useful if you want to follow the operation in order:

1. Program Counter points to the instruction address.
2. Flash Program Memory outputs the instruction word.
3. Instruction Register receives the 14-bit word.
4. Decode and Control separates the opcode and operand fields.
5. The required internal blocks become active.
6. The result is written to W, RAM, STATUS, PC, or another destination.

You can also use the step buttons to move through the trace manually.

Understanding the Decoded Word

At the bottom of the internal block diagram, the tool shows the decoded word.

This section is important because it connects assembly language with machine language.

For example:

MOVLW 0x02

becomes:

11000000000010

The first bits identify the instruction, while the remaining bits contain the literal value.

For file register instructions such as:

MOVWF 0x0C

the decoded word contains the file register address. This lets you see where the address bits are located inside the instruction.

For bit-oriented instructions, the decoded word also shows the selected bit number.

Conclusion

The PIC16F84A Instruction Trace tool is designed to make PIC assembly less mysterious. Instead of memorizing instructions only from a table, you can now see how each instruction travels through the internal parts of the microcontroller.

This is especially helpful when learning instructions like MOVLW, MOVWF, CLRF, bit tests, jumps, calls, and instructions that affect the STATUS register.

Try entering different PIC16F84A assembly commands and watch how the internal blocks respond. Once you understand the path of each instruction, writing and debugging PIC assembly becomes much easier.

The post Introducing the PIC16F84A Instruction Trace Tool appeared first on Microcontroller Tutorials.

Linked lists are common in general-purpose software, but using one in a microcontroller requires extra care. Dynamic memory allocation, memory fragmentation, pointer errors, and unpredictable execution time can all become important concerns when RAM is limited.

In this tutorial, I will explain how a linked list works, show how nodes are connected, and build a practical singly linked list in embedded C. You can also use the visualizer below to add, remove, and traverse nodes while watching the pointers change.

Interactive Linked List Visualizer

Use the controls below to add nodes, remove nodes, and move through the list. Each box represents one node. The arrow leaving a node represents its next pointer.

Pay particular attention to the first node, called the head, and to the final node whose next pointer is NULL.

#define LIST_MAX_NODES 6

typedef struct Node
{
    uint8_t value;
    struct Node *next;
} Node;

typedef struct
{
    Node *head;
    Node *tail;
    uint8_t count;
} LinkedList;

bool list_push_front(LinkedList *list, Node *node, uint8_t value)
{
    if (list->count >= LIST_MAX_NODES)
    {
        return false;
    }

    node->value = value;
    node->next = list->head;
    list->head = node;

    if (list->tail == NULL)
    {
        list->tail = node;
    }

    list->count++;
    return true;
}

bool list_push_back(LinkedList *list, Node *node, uint8_t value)
{
    if (list->count >= LIST_MAX_NODES)
    {
        return false;
    }

    node->value = value;
    node->next = NULL;

    if (list->tail != NULL)
    {
        list->tail->next = node;
    }
    else
    {
        list->head = node;
    }

    list->tail = node;
    list->count++;
    return true;
}

bool list_pop_front(LinkedList *list, uint8_t *value)
{
    Node *old_head;

    if (list->head == NULL)
    {
        return false;
    }

    old_head = list->head;
    *value = old_head->value;
    list->head = old_head->next;

    if (list->head == NULL)
    {
        list->tail = NULL;
    }

    list->count--;
    return true;
}

What Is a Linked List?

A linked list is a data structure made from individual elements called nodes. Each node normally contains two parts:

• The data stored by the node
• A pointer to another node

A basic singly linked-list node in C may look like this:

typedef struct Node
{
    uint8_t value;
    struct Node *next;
} Node;

The value member stores the actual information. The next member stores the address of the following node.

Suppose three nodes contain the values 10, 20, and 30. Their relationship can be represented as:

head
  |
  v
[10 | next] -> [20 | next] -> [30 | NULL]

The program starts at head, follows the first node’s next pointer, and continues until it reaches NULL.

The final node points to NULL because there is no node after it.

Linked List Versus Array

An array stores its elements next to one another in memory.

uint8_t values[4] = {10, 20, 30, 40};

The elements occupy consecutive positions:

Address:  0x2000  0x2001  0x2002  0x2003
Value:       10      20      30      40

This makes accessing a specific array element fast. The processor can calculate the address of values[2] directly.

Linked-list nodes may be located in different parts of memory:

Node 1 at 0x2000
Node 2 at 0x2140
Node 3 at 0x2088

The nodes remain connected because each one stores the address of the next node.

A linked list is useful when elements must frequently be inserted or removed without shifting the remaining data. An array is usually better when fast indexed access and compact memory usage are more important.

The Head Pointer

The head pointer identifies the first node in the list.

Node *head = NULL;

When head is NULL, the list is empty.

After adding a node:

Node first_node;

first_node.value = 10;
first_node.next = NULL;

head = &first_node;

The head now stores the address of first_node.

head -> [10 | NULL]

The head is not a node itself. It is a pointer that tells the program where the list begins.

How Linked-List Traversal Works

Unlike an array, a linked list cannot directly jump to an arbitrary element by index. The program must begin at the head and follow each next pointer.

void linked_list_print(const Node *head)
{
    const Node *current = head;

    while (current != NULL)
    {
        printf("%u\n", current->value);
        current = current->next;
    }
}

The temporary pointer current begins at the first node. After processing that node, it becomes the address stored in current->next.

The traversal ends when current becomes NULL.

For a list containing four nodes, reaching the final node may require following three pointers. This means finding an element becomes slower as the list grows.

Creating a Basic Singly Linked List

A singly linked list allows movement in one direction only. Each node points to the node after it.

We can begin with this data structure:

#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>

typedef struct Node
{
    uint8_t value;
    struct Node *next;
} Node;

typedef struct
{
    Node *head;
    uint16_t count;
} LinkedList;

The LinkedList structure stores:

• A pointer to the first node
• The number of nodes currently in the list

Initializing the List

void linked_list_init(LinkedList *list)
{
    list->head = NULL;
    list->count = 0U;
}

An initialized list contains no nodes, so the head is set to NULL.

Adding a Node at the Beginning

Adding a node at the beginning is one of the simplest linked-list operations.

Suppose the current list is:

head -> [20] -> [30] -> NULL

To insert a node containing 10:

1. Make the new node point to the current head.
2. Change the head so it points to the new node.

bool linked_list_push_front(
    LinkedList *list,
    Node *node,
    uint8_t value)
{
    if ((list == NULL) || (node == NULL))
    {
        return false;
    }

    node->value = value;
    node->next = list->head;

    list->head = node;
    list->count++;

    return true;
}

After the operation:

head -> [10] -> [20] -> [30] -> NULL

The existing nodes do not move in memory. Only two pointer values change.

Adding a Node at the End

Adding at the end requires finding the final node unless the list also stores a tail pointer.

bool linked_list_push_back(
    LinkedList *list,
    Node *node,
    uint8_t value)
{
    Node *current;

    if ((list == NULL) || (node == NULL))
    {
        return false;
    }

    node->value = value;
    node->next = NULL;

    if (list->head == NULL)
    {
        list->head = node;
        list->count++;
        return true;
    }

    current = list->head;

    while (current->next != NULL)
    {
        current = current->next;
    }

    current->next = node;
    list->count++;

    return true;
}

If the list is empty, the new node becomes the head. Otherwise, the function traverses the list until it finds the node whose next pointer is NULL.

This operation takes longer as the list grows. Storing a separate tail pointer can make insertion at the end much faster.

Removing the First Node

To remove the first node:

1. Save a pointer to the current head.
2. Move the head to the second node.
3. Disconnect the removed node.

Node *linked_list_pop_front(LinkedList *list)
{
    Node *removed;

    if ((list == NULL) || (list->head == NULL))
    {
        return NULL;
    }

    removed = list->head;
    list->head = removed->next;

    removed->next = NULL;
    list->count--;

    return removed;
}

If the original list is:

head -> [10] -> [20] -> [30] -> NULL

the result becomes:

head -> [20] -> [30] -> NULL

removed -> [10] -> NULL

The function returns the removed node so the application can reuse it or release it through the appropriate memory-management method.

Removing a Node by Value

Removing a node from the middle requires keeping track of both the current node and the node before it.

Node *linked_list_remove(
    LinkedList *list,
    uint8_t value)
{
    Node *current;
    Node *previous = NULL;

    if (list == NULL)
    {
        return NULL;
    }

    current = list->head;

    while (current != NULL)
    {
        if (current->value == value)
        {
            if (previous == NULL)
            {
                list->head = current->next;
            }
            else
            {
                previous->next = current->next;
            }

            current->next = NULL;
            list->count--;

            return current;
        }

        previous = current;
        current = current->next;
    }

    return NULL;
}

If the first node matches, the head changes. If a middle node matches, the previous node is connected directly to the node after the removed one.

For example:

Before:

[10] -> [20] -> [30] -> NULL

Remove 20:

[10] ---------> [30] -> NULL

Finding a Value

Node *linked_list_find(
    LinkedList *list,
    uint8_t value)
{
    Node *current;

    if (list == NULL)
    {
        return NULL;
    }

    current = list->head;

    while (current != NULL)
    {
        if (current->value == value)
        {
            return current;
        }

        current = current->next;
    }

    return NULL;
}

The function returns a pointer to the matching node or NULL when the value is not present.

Searching a linked list requires checking nodes one at a time. For large collections requiring frequent searches, another data structure may be more suitable.

Complete Dynamic Allocation Example

On a desktop computer, linked-list nodes are commonly created using dynamic allocation.

#include <stdbool.h>
#include <stdint.h>
#include <stdlib.h>

typedef struct Node
{
    uint8_t value;
    struct Node *next;
} Node;

typedef struct
{
    Node *head;
    uint16_t count;
} LinkedList;

bool linked_list_add(
    LinkedList *list,
    uint8_t value)
{
    Node *node;

    if (list == NULL)
    {
        return false;
    }

    node = malloc(sizeof(Node));

    if (node == NULL)
    {
        return false;
    }

    node->value = value;
    node->next = list->head;

    list->head = node;
    list->count++;

    return true;
}

bool linked_list_remove_first(
    LinkedList *list,
    uint8_t *value)
{
    Node *removed;

    if ((list == NULL) ||
        (list->head == NULL))
    {
        return false;
    }

    removed = list->head;
    list->head = removed->next;

    if (value != NULL)
    {
        *value = removed->value;
    }

    free(removed);
    list->count--;

    return true;
}

This code works, but using malloc() and free() may not be the best option for every embedded system.

Why Dynamic Allocation Can Be a Problem

Microcontrollers often have limited RAM and may need to operate continuously for months or years. Repeated allocation and release can divide the available heap into small separated areas.

This condition is called memory fragmentation.

Suppose a device has several free memory regions:

Free blocks: 16 bytes, 12 bytes, 20 bytes

The total free memory is 48 bytes, but an attempt to allocate one 32-byte block may fail because no individual free region is large enough.

Dynamic allocation can introduce other concerns:

• Allocation may fail at runtime.
• Execution time may be difficult to predict.
• Memory leaks can slowly consume the heap.
• Double-free errors can corrupt memory.
• Using freed nodes can cause unpredictable behavior.
• Debugging heap corruption on a microcontroller can be difficult.

Dynamic memory is not automatically forbidden in embedded software. It can be acceptable when allocation is controlled, occurs only during initialization, or runs on a system with enough memory and a suitable allocator.

However, a fixed node pool is often a safer choice for small microcontrollers and long-running firmware.

Using a Static Node Pool

A static pool reserves all possible nodes at compile time. The application takes nodes from the pool and returns them when they are no longer needed.

#define NODE_POOL_SIZE 8U

typedef struct Node
{
    uint8_t value;
    struct Node *next;
} Node;

typedef struct
{
    Node nodes[NODE_POOL_SIZE];
    Node *free_list;
} NodePool;

The pool can use a second linked list to track available nodes.

Initializing the Pool

void node_pool_init(NodePool *pool)
{
    uint8_t index;

    if (pool == NULL)
    {
        return;
    }

    for (index = 0U;
         index < NODE_POOL_SIZE - 1U;
         index++)
    {
        pool->nodes[index].next =
            &pool->nodes[index + 1U];
    }

    pool->nodes[NODE_POOL_SIZE - 1U].next =
        NULL;

    pool->free_list = &pool->nodes[0];
}

After initialization, every available node is connected through the pool’s free_list.

Allocating a Node from the Pool

Node *node_pool_allocate(NodePool *pool)
{
    Node *node;

    if ((pool == NULL) ||
        (pool->free_list == NULL))
    {
        return NULL;
    }

    node = pool->free_list;
    pool->free_list = node->next;

    node->next = NULL;

    return node;
}

The first available node is removed from the free list and returned to the caller.

Returning a Node to the Pool

void node_pool_release(
    NodePool *pool,
    Node *node)
{
    if ((pool == NULL) || (node == NULL))
    {
        return;
    }

    node->next = pool->free_list;
    pool->free_list = node;
}

The released node is placed back at the beginning of the free list.

This approach has several useful properties:

• The maximum memory usage is known at compile time.
• Allocation does not depend on the general-purpose heap.
• No external fragmentation occurs inside the pool.
• Allocation and release are fast and predictable.
• Pool exhaustion can be detected when no free nodes remain.

Complete Static Linked List Example

The following example combines a linked list with a fixed node pool.

#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>

#define NODE_POOL_SIZE 8U

typedef struct Node
{
    uint8_t value;
    struct Node *next;
} Node;

typedef struct
{
    Node *head;
    uint16_t count;
} LinkedList;

typedef struct
{
    Node nodes[NODE_POOL_SIZE];
    Node *free_list;
} NodePool;

void node_pool_init(NodePool *pool)
{
    uint8_t index;

    for (index = 0U;
         index < NODE_POOL_SIZE - 1U;
         index++)
    {
        pool->nodes[index].next =
            &pool->nodes[index + 1U];
    }

    pool->nodes[NODE_POOL_SIZE - 1U].next =
        NULL;

    pool->free_list = &pool->nodes[0];
}

Node *node_pool_allocate(NodePool *pool)
{
    Node *node;

    if (pool->free_list == NULL)
    {
        return NULL;
    }

    node = pool->free_list;
    pool->free_list = node->next;

    node->next = NULL;

    return node;
}

void node_pool_release(
    NodePool *pool,
    Node *node)
{
    node->next = pool->free_list;
    pool->free_list = node;
}

void linked_list_init(LinkedList *list)
{
    list->head = NULL;
    list->count = 0U;
}

bool linked_list_add(
    LinkedList *list,
    NodePool *pool,
    uint8_t value)
{
    Node *node;

    node = node_pool_allocate(pool);

    if (node == NULL)
    {
        return false;
    }

    node->value = value;
    node->next = list->head;

    list->head = node;
    list->count++;

    return true;
}

bool linked_list_remove_first(
    LinkedList *list,
    NodePool *pool,
    uint8_t *value)
{
    Node *removed;

    if (list->head == NULL)
    {
        return false;
    }

    removed = list->head;
    list->head = removed->next;

    if (value != NULL)
    {
        *value = removed->value;
    }

    list->count--;
    node_pool_release(pool, removed);

    return true;
}

The maximum number of active nodes is limited to NODE_POOL_SIZE. When all nodes are in use, linked_list_add() returns false.

This fixed limit is often desirable in embedded firmware because the system’s worst-case memory requirement is known before the program runs.

Example Application

LinkedList event_list;
NodePool event_pool;
uint8_t event_value;

int main(void)
{
    node_pool_init(&event_pool);
    linked_list_init(&event_list);

    linked_list_add(
        &event_list,
        &event_pool,
        10U);

    linked_list_add(
        &event_list,
        &event_pool,
        20U);

    linked_list_add(
        &event_list,
        &event_pool,
        30U);

    while (1)
    {
        if (linked_list_remove_first(
                &event_list,
                &event_pool,
                &event_value))
        {
            process_event(event_value);
        }

        run_other_tasks();
    }
}

Because nodes are added at the beginning, the values in this example are removed in reverse order: 30, 20, then 10.

This behavior is a stack, not a FIFO queue. To preserve insertion order, add new nodes at the end or store a tail pointer.

Linked List with Head and Tail Pointers

Adding a tail pointer makes it possible to insert at the end without traversing the entire list.

typedef struct
{
    Node *head;
    Node *tail;
    uint16_t count;
} LinkedList;

Appending a node then becomes:

bool linked_list_push_back(
    LinkedList *list,
    Node *node,
    uint8_t value)
{
    if ((list == NULL) || (node == NULL))
    {
        return false;
    }

    node->value = value;
    node->next = NULL;

    if (list->tail == NULL)
    {
        list->head = node;
        list->tail = node;
    }
    else
    {
        list->tail->next = node;
        list->tail = node;
    }

    list->count++;

    return true;
}

When removing the first node, remember to clear the tail when the final element is removed.

Node *linked_list_pop_front(
    LinkedList *list)
{
    Node *removed;

    if ((list == NULL) ||
        (list->head == NULL))
    {
        return NULL;
    }

    removed = list->head;
    list->head = removed->next;

    if (list->head == NULL)
    {
        list->tail = NULL;
    }

    removed->next = NULL;
    list->count--;

    return removed;
}

This head-and-tail arrangement can be used to build a FIFO event queue.

Where Linked Lists Are Used in Embedded Systems

Linked lists can be useful when the number or ordering of elements changes while the program is running.

Event Queues

Each node can represent an event waiting to be processed.

typedef struct Event
{
    uint16_t event_id;
    uint32_t timestamp;
    struct Event *next;
} Event;

Software Timers

Timer nodes may be sorted by expiration time. The application only needs to check the first timer to find the next event that will expire.

Network Packet Lists

Network stacks may connect packet buffers without copying all packet data into one large contiguous block.

Device and Driver Registration

Drivers, callbacks, or peripheral objects can be registered in a list during system initialization.

Memory Free Lists

A memory allocator can link unused blocks together. The static node pool shown earlier is itself an example of a free list.

RTOS Kernel Objects

Real-time operating systems commonly use linked lists internally for task scheduling, blocked-task lists, timer lists, and queues.

When a Linked List Is Not the Best Choice

A linked list is not automatically better because elements can be inserted and removed easily.

Consider using an array, ring buffer, or another fixed structure when:

• The maximum number of elements is known.
• Fast indexed access is required.
• Memory overhead must be minimized.
• Cache locality matters.
• The data is processed in strict FIFO order.
• Deterministic memory usage is a priority.

For UART bytes, a ring buffer is normally more appropriate than a linked list. Every linked-list node would require a pointer in addition to the byte itself, creating unnecessary memory overhead.

A linked list becomes more attractive when elements are larger, insertions occur at different positions, or nodes already exist as application objects.

Memory Overhead in a Linked List

Each node requires space for at least one pointer.

Consider this structure on a 32-bit microcontroller:

typedef struct Node
{
    uint8_t value;
    struct Node *next;
} Node;

The data uses only one byte, but the pointer requires four bytes. Alignment and padding may increase the total node size to eight bytes.

As a result, storing eight one-byte values may require approximately 64 bytes instead of eight bytes.

This is why linked lists are rarely a good choice for individual UART characters or tiny sensor readings.

They become more memory-efficient when each node contains a larger payload or when the node is embedded inside an existing object.

Intrusive Linked Lists

An intrusive linked list places the pointer directly inside the application object.

typedef struct Sensor
{
    uint8_t address;
    uint16_t sample_rate;
    struct Sensor *next;
} Sensor;

The sensor object itself becomes a list node. No separate wrapper node is required.

This approach is common in embedded systems because it avoids additional allocation and gives the programmer direct control over memory.

The tradeoff is that the object becomes coupled to the list. A single next pointer also allows the object to belong to only one such list at a time unless more link fields are added.

Linked Lists and Interrupts

Modifying a linked list from an interrupt while the main program also modifies it can corrupt the list.

Consider adding a node at the head:

node->next = list->head;
list->head = node;

This operation involves more than one memory access. If another execution context changes the list between those two statements, a node may be lost or connected incorrectly.

Depending on the system, shared-list operations may require:

• A short critical section
• Temporarily disabling the relevant interrupt
• An RTOS mutex
• An RTOS queue
• A carefully designed lock-free algorithm

Adding volatile to a pointer does not make the complete linked-list operation atomic.

For communication between a UART interrupt and a main loop, a single-producer, single-consumer ring buffer is normally simpler and safer than a shared linked list.

Common Linked-List Mistakes

Losing the Head Pointer

Changing the head before saving the old value may make the original node unreachable.

Forgetting to Update the Previous Node

When removing a middle node, the previous node must point to the removed node’s successor.

Dereferencing NULL

Always check whether a pointer is NULL before accessing its members.

if (current != NULL)
{
    value = current->value;
}

Using a Node After It Has Been Freed

A pointer does not automatically become invalid-looking after free(). It may still contain the old address even though that memory no longer belongs to the node.

free(node);
node = NULL;

Setting the local pointer to NULL can help prevent accidental reuse, although other copies of the same pointer must also be handled correctly.

Creating a Cycle Accidentally

If a node points to an earlier node instead of eventually reaching NULL, traversal may never terminate.

[10] -> [20] -> [30]
          ^         |
          |_________|

Returning a Node to the Pool Twice

Releasing the same node twice can corrupt the pool’s free list. The application must clearly define who owns each node.

Using Dynamic Allocation Without Handling Failure

Every allocation can fail. The return value of malloc() or a node-pool allocation function must be checked.

Singly Versus Doubly Linked Lists

A singly linked list stores only a pointer to the next node.

typedef struct Node
{
    uint8_t value;
    struct Node *next;
} Node;

A doubly linked list stores both next and previous pointers.

typedef struct Node
{
    uint8_t value;
    struct Node *next;
    struct Node *previous;
} Node;

A doubly linked list allows traversal in both directions and makes removal easier when the node address is already known. However, it requires another pointer in every node and more pointer updates during insertion and removal.

Frequently Asked Questions

Are linked lists commonly used in embedded systems?

Yes, especially in operating systems, protocol stacks, event systems, driver registration, and memory managers. However, small bare-metal applications often prefer fixed arrays or ring buffers because they use less memory and are easier to analyze.

Should I use malloc for an embedded linked list?

It depends on the project. Dynamic allocation may be acceptable during initialization or on larger systems. For small or safety-sensitive microcontrollers, a fixed node pool usually provides more predictable behavior.

Is a linked list faster than an array?

Not in every operation. Inserting at the head of a linked list is fast, but finding the tenth element requires following the previous nine nodes. Arrays provide much faster indexed access and usually better memory locality.

Can linked-list nodes store structures?

Yes. A node can store sensor records, messages, tasks, timers, network packets, or other application-specific data.

What happens when a static node pool is full?

The allocation function returns NULL. The application must decide whether to reject the new item, report an error, reuse an older node, or increase the configured pool size.

Can I use a linked list inside an interrupt?

It is possible, but shared access must be designed carefully. Pointer updates can be interrupted halfway through, so critical sections or another synchronization method may be required.

Should UART data use a linked list?

Usually not. A fixed ring buffer is more compact and efficient for a stream of bytes. A linked list may be useful when each received item is a larger variable-size message rather than an individual byte.

Conclusion

A linked list connects separate data objects using pointers. The head identifies the first node, each node points to the next one, and the final node points to NULL.

The main linked-list operations are:

• Adding a node
• Removing a node
• Traversing the list
• Searching for a value
• Returning unused nodes to their allocator or static pool

For embedded systems, the pointer logic is only part of the design. You must also consider RAM overhead, allocation failure, fragmentation, interrupt safety, and worst-case execution time.

The visualizer at the beginning of this tutorial shows the logical connections between nodes. In an actual microcontroller, those nodes may be stored at completely different memory addresses. The pointers are what preserve their order.

For small and predictable firmware, I recommend starting with a singly linked list backed by a fixed node pool. It keeps the flexibility of linked nodes while avoiding the uncertainty of repeated heap allocation.

The post Linked List Visualizer for Embedded Systems appeared first on Microcontroller Tutorials.

A ring buffer is also called a circular buffer. The memory itself is still an ordinary C array. What makes it circular is the way its indexes return to zero after reaching the final array element.

This tutorial explains how an embedded ring buffer works, how its head and tail pointers move, and how you can implement one in C. You can also use the interactive visualizer below to see each operation happen.

Interactive Embedded Ring Buffer Visualizer

Enter a character, decimal byte, or hexadecimal value and click Write Byte. The value is stored at the current head position. Click Read Byte to remove the oldest value from the tail position.

Watch what happens when either pointer reaches the final slot. Instead of moving outside the array, it wraps around to index zero.

#define BUFFER_SIZE 8

typedef struct
{
    uint8_t data[BUFFER_SIZE];
    volatile uint8_t head;
    volatile uint8_t tail;
    volatile uint8_t count;
} RingBuffer;

bool ring_buffer_write(RingBuffer *rb, uint8_t value)
{
    if (rb->count >= BUFFER_SIZE)
    {
        return false;
    }

    rb->data[rb->head] = value;
    rb->head = (rb->head + 1U) % BUFFER_SIZE;
    rb->count++;

    return true;
}

bool ring_buffer_read(RingBuffer *rb, uint8_t *value)
{
    if (rb->count == 0U)
    {
        return false;
    }

    *value = rb->data[rb->tail];
    rb->tail = (rb->tail + 1U) % BUFFER_SIZE;
    rb->count--;

    return true;
}

What Is a Ring Buffer in Embedded Systems?

A ring buffer is a first-in, first-out or FIFO data structure built using a fixed-size array. The first value written into the buffer is normally the first value read from it.

Consider this eight-byte array:

uint8_t buffer[8];

A normal queue implementation might remove the first value and then shift every remaining value toward index zero. That approach works, but repeatedly moving data wastes processor time.

A ring buffer does not shift its contents. Instead, it keeps track of two indexes:

• Head — the position where the next value will be written
• Tail — the position where the next value will be read

When a value is written, the head advances. When a value is read, the tail advances. The data remains in the same physical array slots until those slots are reused.

This makes ring-buffer writes and reads fast and predictable. Both operations normally take constant time because no existing elements have to be moved.

Why Ring Buffers Are Useful in Embedded Applications

Microcontrollers often deal with events that do not happen at exactly the same speed as the main application.

For example, a UART peripheral may receive a byte while the processor is:

• Updating a display
• Reading a sensor
• Writing data to flash memory
• Processing a communication packet
• Executing another part of the main loop

The UART receive interrupt should not perform a large amount of processing. It should normally retrieve the received byte quickly, store it somewhere safe, and then return.

A ring buffer provides that temporary storage:

UART peripheral → RX interrupt → Ring buffer → Main application

The interrupt acts as the producer because it adds bytes. The main application acts as the consumer because it removes and processes them.

The same idea can be used for:

• UART receive and transmit queues
• ADC sample storage
• Sensor-data collection
• Logging systems
• CAN and SPI message queues
• Audio samples
• Keyboard or keypad input
• Data moving between interrupt handlers and the main loop

How the Head Pointer Works

The head points to the array position where the next byte will be stored.

Suppose the head is initially at index zero:

head = 0;

Writing the character 'A' stores it in buffer[0]. The head then moves to index one.

buffer[head] = 'A';
head++;

If the next value is 'B', it is stored in buffer[1], after which the head moves to index two.

The head always identifies the next available write position. It does not normally point to the most recently written value.

How the Tail Pointer Works

The tail points to the oldest unread value.

If the tail is at index zero, reading from the buffer returns the value stored in buffer[0]. The tail then advances to index one.

value = buffer[tail];
tail++;

The contents do not need to be shifted after the read. The application simply considers that slot available again.

Some implementations clear a slot after reading it because doing so makes debugging and visualization easier. Clearing the slot is not normally required for the ring-buffer algorithm itself.

Pointer Wraparound

The circular behavior appears when a pointer reaches the end of the array.

For an eight-element buffer, the valid indexes are zero through seven. If the head is at index seven, its next position must be index zero.

This can be written using the modulo operator:

head = (head + 1U) % BUFFER_SIZE;

With BUFFER_SIZE equal to eight:

(7 + 1) % 8 = 0

The same operation is used for the tail:

tail = (tail + 1U) % BUFFER_SIZE;

No data is physically moved from the end of the array back to the beginning. Only the index wraps around.

Detecting an Empty or Full Ring Buffer

A ring buffer must be able to determine whether another read or write is allowed.

The interactive visualizer uses a count-based implementation. In addition to the head and tail, it stores the number of elements currently inside the buffer.

uint8_t head;
uint8_t tail;
uint8_t count;

The buffer is empty when:

count == 0

It is full when:

count == BUFFER_SIZE

This method allows every array element to be used. An eight-element array can hold eight values.

Another common method avoids the count variable and reserves one array slot. In that version:

• head == tail means the buffer is empty.
• The buffer is full when advancing the head would make it equal to the tail.

That approach is especially useful for a single-producer, single-consumer ring buffer because the producer can own the head while the consumer owns the tail. I will return to that version later in the tutorial.

Basic Count-Based Ring Buffer in C

The following implementation matches the behavior of the visualizer. It stores eight bytes and rejects new data when the buffer is full.

#include <stdbool.h>
#include <stdint.h>

#define BUFFER_SIZE 8U

typedef struct
{
    uint8_t data[BUFFER_SIZE];
    uint8_t head;
    uint8_t tail;
    uint8_t count;
} RingBuffer;

Initializing the Buffer

Initialization places both pointers at index zero and sets the stored count to zero.

void ring_buffer_init(RingBuffer *rb)
{
    rb->head = 0U;
    rb->tail = 0U;
    rb->count = 0U;
}

The actual data array does not have to be cleared because no slot is considered valid while the count is zero.

Writing a Byte

bool ring_buffer_write(RingBuffer *rb, uint8_t value)
{
    if (rb->count >= BUFFER_SIZE)
    {
        return false;
    }

    rb->data[rb->head] = value;
    rb->head = (rb->head + 1U) % BUFFER_SIZE;
    rb->count++;

    return true;
}

The function first checks whether the buffer is full. If space is available, the value is written at the head position. The head advances, and the element count increases.

The function returns false when no more data can be accepted. The caller can use this result to record an overflow, increment an error counter, or take another appropriate action.

Reading a Byte

bool ring_buffer_read(RingBuffer *rb, uint8_t *value)
{
    if (rb->count == 0U)
    {
        return false;
    }

    *value = rb->data[rb->tail];
    rb->tail = (rb->tail + 1U) % BUFFER_SIZE;
    rb->count--;

    return true;
}

The read function checks for an empty buffer before accessing the array. It returns the oldest byte, advances the tail, and decreases the count.

Checking the Current State

bool ring_buffer_is_empty(const RingBuffer *rb)
{
    return rb->count == 0U;
}

bool ring_buffer_is_full(const RingBuffer *rb)
{
    return rb->count == BUFFER_SIZE;
}

uint8_t ring_buffer_used(const RingBuffer *rb)
{
    return rb->count;
}

uint8_t ring_buffer_free(const RingBuffer *rb)
{
    return BUFFER_SIZE - rb->count;
}

A Simple Ring Buffer Example

Here is how the buffer can be used from a normal C program:

RingBuffer rx_buffer;
uint8_t received_byte;

int main(void)
{
    ring_buffer_init(&rx_buffer);

    ring_buffer_write(&rx_buffer, 'A');
    ring_buffer_write(&rx_buffer, 'B');
    ring_buffer_write(&rx_buffer, 'C');

    if (ring_buffer_read(&rx_buffer, &received_byte))
    {
        /* received_byte contains 'A' */
    }

    if (ring_buffer_read(&rx_buffer, &received_byte))
    {
        /* received_byte contains 'B' */
    }

    while (1)
    {
        /* Main application */
    }
}

Even if the head wraps around while more values are written, the tail continues to return them in FIFO order.

Using a Ring Buffer for UART Reception

A UART receive ring buffer is one of the most common embedded applications.

The general flow is:

1. The UART peripheral receives a byte.
2. The receive interrupt runs.
3. The interrupt reads the UART data register.
4. The byte is written into the ring buffer.
5. The interrupt returns.
6. The main loop later reads and processes the buffered byte.

A simplified interrupt handler might look like this:

void UART_RX_IRQHandler(void)
{
    uint8_t value = uart_read_data_register();

    if (!ring_buffer_write(&rx_buffer, value))
    {
        uart_rx_overflow = true;
    }
}

The main loop can process the data without waiting inside the interrupt:

int main(void)
{
    uint8_t value;

    ring_buffer_init(&rx_buffer);
    uart_init();

    while (1)
    {
        while (ring_buffer_read(&rx_buffer, &value))
        {
            process_received_byte(value);
        }

        run_other_application_tasks();
    }
}

This arrangement lets the interrupt capture incoming data quickly while the main application performs the more time-consuming work.

A Concurrency Warning About the Count Variable

The count-based implementation is easy to understand and works well for the visualizer. However, notice what happens in the UART example:

• The interrupt increases count.
• The main loop decreases count.

Both execution contexts modify the same variable. An interrupt occurring during a read-modify-write operation may produce a race condition, depending on the microcontroller, variable width, compiler, and generated instructions.

Adding volatile prevents the compiler from treating a shared variable as if it never changes unexpectedly. It does not automatically make an operation atomic, and it does not by itself solve every concurrency problem.

You can protect a count-based implementation with a short critical section. Another option is to use a single-producer, single-consumer design where the interrupt modifies only the head and the main loop modifies only the tail.

Single-Producer, Single-Consumer UART Ring Buffer

For a typical UART receive buffer, there is one producer and one consumer:

• The UART RX interrupt is the only code that changes the head.
• The main loop is the only code that changes the tail.

The implementation below reserves one array slot so that head == tail can unambiguously represent an empty buffer.

#include <stdbool.h>
#include <stdint.h>

#define UART_BUFFER_SIZE 16U
#define UART_BUFFER_MASK (UART_BUFFER_SIZE - 1U)

typedef struct
{
    uint8_t data[UART_BUFFER_SIZE];
    volatile uint16_t head;
    volatile uint16_t tail;
} UartRingBuffer;

Because the masking optimization is used here, UART_BUFFER_SIZE must be a power of two.

Writing from the UART Interrupt

bool uart_ring_buffer_write_isr(
    UartRingBuffer *rb,
    uint8_t value)
{
    uint16_t head = rb->head;
    uint16_t next =
        (head + 1U) & UART_BUFFER_MASK;

    if (next == rb->tail)
    {
        return false;
    }

    rb->data[head] = value;
    rb->head = next;

    return true;
}

Reading from the Main Loop

bool uart_ring_buffer_read(
    UartRingBuffer *rb,
    uint8_t *value)
{
    uint16_t tail = rb->tail;

    if (tail == rb->head)
    {
        return false;
    }

    *value = rb->data[tail];
    rb->tail =
        (tail + 1U) & UART_BUFFER_MASK;

    return true;
}

This arrangement avoids a shared count variable. The producer publishes a new head only after writing the byte, while the consumer advances the tail only after retrieving it.

You should still check the requirements of your specific architecture. Index reads and writes should be naturally aligned and atomic for the chosen index type. Systems with multiple cores, DMA, an RTOS, cache coherency concerns, or more than one producer or consumer may require memory barriers, critical sections, or an operating-system synchronization primitive.

Modulo Versus Bit Masking

The general wraparound operation uses modulo:

next = (index + 1U) % BUFFER_SIZE;

This works for any valid buffer size.

If the size is a power of two, the index can instead be wrapped using a mask:

next = (index + 1U) & (BUFFER_SIZE - 1U);

For example, valid indexes for a 16-byte buffer are zero through 15. The value BUFFER_SIZE - 1 is therefore 0x0F.

Modern compilers can often optimize a constant modulo operation automatically. I would therefore prioritize clear and correct code first, then inspect the generated code if performance is critical.

Ring Buffer Overflow and Underflow

Overflow

An overflow occurs when the producer attempts to write while no space is available.

The buffer can respond in different ways:

• Reject the new value
• Overwrite the oldest unread value
• Set an overflow flag
• Increment a lost-byte counter
• Apply flow control when the protocol supports it

The visualizer rejects the new byte because this makes the loss of data obvious. Whether that is the correct behavior in a real project depends on the application.

For a command interface, losing an old or new character may invalidate the entire command. For continuous sensor history, overwriting the oldest sample may be acceptable.

Underflow

An underflow occurs when the consumer attempts to read an empty buffer.

A well-designed read function should detect this before accessing the array. Returning a Boolean result is useful because every possible byte value, including zero, may be valid data.

uint8_t value;

if (ring_buffer_read(&rx_buffer, &value))
{
    process_received_byte(value);
}
else
{
    /* No data currently available */
}

Choosing the Ring Buffer Size

The correct buffer size depends on how quickly data arrives and how long the consumer may be unable to process it.

A useful starting estimate is:

$N_{\min} \ge R_{\text{bytes}}T_{\text{delay}} + M$

Where:

• N_min is the minimum number of required slots.
• R_bytes is the incoming data rate in bytes per second.
• T_delay is the longest expected consumer delay in seconds.
• M is an additional safety margin.

For example, an 8-N-1 UART connection at 115200 baud uses approximately ten transmitted bits for every data byte: one start bit, eight data bits, and one stop bit.

$R_{\text{bytes}} \approx \frac{115200}{10} = 11520\text{ bytes/s}$

If the main application can be delayed for 5 milliseconds:

$N_{\min} \ge 11520 \times 0.005 = 57.6\text{ bytes}$

A 64-byte buffer is the smallest convenient power-of-two choice, but it leaves almost no margin. A 128-byte buffer may be more appropriate if RAM permits and occasional longer delays are possible.

If the implementation reserves one slot, remember that a 64-element array stores only 63 bytes.

Ring Buffer Versus an Ordinary Linear Buffer

Common Ring Buffer Mistakes

Confusing the Head with the Last Written Position

In the implementation used here, the head is the next write position. After writing to index three, the head normally advances to index four.

Failing to Distinguish Full from Empty

If the head and tail can be equal in both states, another piece of information is required. Use a count, reserve one slot, or store a separate full flag.

Using an Index That Is Too Small

The index type must be able to represent every valid buffer position. An eight-bit index is sufficient for buffers up to 256 elements, but larger buffers require a wider type.

Assuming Volatile Makes Everything Thread-Safe

volatile affects compiler optimization. It does not automatically protect a multi-step update from interrupts, multiple tasks, or another processor core.

Doing Too Much Work Inside the Interrupt

The receive interrupt should normally store the byte and return. Packet parsing, command execution, display updates, and other longer operations are better handled outside the ISR.

Ignoring Overflow

Even a correctly implemented ring buffer can overflow. Always decide how the application should detect and respond to lost data.

Frequently Asked Questions

Is a ring buffer the same as a circular queue?

The terms are often used interchangeably. Both normally describe FIFO storage that reuses a fixed array by wrapping its indexes. Ring buffer is particularly common terminology in embedded systems, drivers, communications, and streaming applications.

Does a ring buffer dynamically allocate memory?

It does not have to. Embedded implementations usually use a statically allocated array so memory usage is known at compile time and no heap allocation is required.

Can a ring buffer store structures instead of bytes?

Yes. The array can contain sensor samples, CAN frames, event structures, pointers, or other fixed-size objects.

typedef struct
{
    uint32_t timestamp;
    int16_t temperature;
    uint16_t pressure;
} SensorSample;

SensorSample sample_buffer[16];

Should a full ring buffer reject or overwrite data?

It depends on the application. Communication buffers often reject new data and report an overflow. History buffers may intentionally overwrite the oldest entry so they always contain the most recent samples.

Can DMA use a ring buffer?

Yes, although the design becomes more hardware-specific. Many microcontrollers support circular DMA modes that repeatedly fill a memory region. The application must then track which portion of the region has been written and which portion has already been processed.

Can I use this implementation with an RTOS?

You can, but a ring buffer shared by multiple tasks may require a mutex, critical section, semaphore, or RTOS queue. A lock-free single-producer, single-consumer implementation should not automatically be treated as safe for multiple producers or consumers.

Conclusion

A ring buffer gives embedded applications an efficient way to temporarily store streaming data without shifting array elements or allocating more memory at runtime.

The basic idea is simple:

• The head identifies the next write position.
• The tail identifies the next read position.
• Both pointers return to zero after reaching the end.
• Writes must detect a full buffer.
• Reads must detect an empty buffer.

The count-based approach used by the visualizer is useful for learning because the full and empty conditions are easy to see. For a real UART interrupt and main-loop arrangement, a single-producer, single-consumer implementation with separate head and tail ownership can reduce shared-state problems.

Try filling the visualizer, reading a few bytes, and then writing more values. The most important moment is when the head crosses the final index and returns to zero while the unread values remain in the correct FIFO order. Once that behavior is clear, the C implementation becomes much easier to understand.

The post Ring Buffer Visualizer for Embedded Systems appeared first on Microcontroller Tutorials.

In this tutorial, we will build an ESP32-S3 AA battery power supply using two AA cells and an MT3608 boost converter. We will also add an optional battery-voltage monitor and use deep sleep to make the batteries last longer.

The short answer is that an ESP32-S3 can run from AA batteries, but the batteries should not normally be connected directly to the development board. The voltage must remain stable, and the power circuit must handle the short current bursts produced when the ESP32-S3 uses Wi-Fi or Bluetooth.

This tutorial assumes an ESP32-S3 development board similar to the Espressif ESP32-S3-DevKitC-1. Other ESP32-S3 boards may have different regulators, power LEDs, USB circuits, pin labels, and power-input arrangements. Check your board’s schematic before applying power through its 3V3 pin.

Can an ESP32-S3 Run on AA Batteries?

Yes. Two AA batteries can power an ESP32-S3 when used with a suitable voltage converter. The ESP32-S3 chip normally operates from a 3.3 V supply. Its acceptable supply range is approximately 3.0 V to 3.6 V. The power source must also handle the ESP32-S3’s brief current peaks when its radio begins transmitting.

A pair of alkaline AA batteries has a nominal voltage of:

$2 \times 1.5\text{ V} = 3.0\text{ V}$

At first glance, 3.0 V may appear close enough to the ESP32-S3’s operating voltage. The problem is that battery voltage does not remain fixed. A fresh alkaline cell may measure above 1.5 V without a load. Its voltage then gradually falls as the battery discharges. The terminal voltage can also drop suddenly when the ESP32-S3 draws a high-current pulse. Directly connecting two AA cells to the 3V3 pin may therefore work initially but become unreliable as the batteries discharge. The ESP32-S3 may reset when Wi-Fi starts, fail to boot, or stop operating long before the batteries are completely empty.

To avoid this problem, we will use an MT3608 boost converter adjusted to provide a regulated 3.3 V output.

What Is the MT3608?

The MT3608 is a small step-up or boost converter. A boost converter takes a lower DC voltage and raises it to a higher regulated voltage.

Common MT3608 breakout modules include:

• An MT3608 switching-regulator IC
• An inductor
• A Schottky diode
• Input and output capacitors
• A multi-turn adjustment potentiometer
• IN+, IN−, OUT+, and OUT− connection pads

The MT3608 IC has an input-voltage range of approximately 2 V to 24 V and an adjustable output. Its switching frequency is 1.2 MHz. For this project, the module raises the changing voltage from two AA cells to a regulated 3.3 V:

$V_{\text{BATTERY}} \longrightarrow \text{MT3608} \longrightarrow 3.3\text{ V}$

The MT3608 is inexpensive and widely available, which makes it practical for a prototype or hobby project.

The MT3608 Is Boost-Only

An important limitation is that the MT3608 can only raise voltage. It cannot reduce a voltage that is higher than the desired output. For example, an MT3608 should not be used to convert a three-cell alkaline battery pack from approximately 4.5 V down to 3.3 V. That would require a buck converter or buck-boost converter instead. Two alkaline or two NiMH AA cells remain below the desired 3.3 V output during normal use, so they are suitable for this circuit.

MT3608 Current Ratings

Many online listings describe an MT3608 module as a “2 A boost converter.” This does not necessarily mean that the module can continuously supply 2 A at its output under all conditions.

The available output current depends on:

• Input voltage
• Output voltage
• Converter efficiency
• Inductor rating
• Diode rating
• PCB layout
• Cooling
• Battery condition and internal resistance

At a low battery voltage, the converter must draw more current from the batteries than it delivers at its output.

Ignoring converter losses for a moment:

$V_{\text{IN}}I_{\text{IN}} \approx V_{\text{OUT}}I_{\text{OUT}}$

After including converter efficiency:

$I_{\text{IN}} = \frac{V_{\text{OUT}}I_{\text{OUT}}}{V_{\text{IN}}\eta}$

For example, supplying 500 mA at 3.3 V from a 2.0 V battery pack at 85% efficiency would require approximately:

$I_{\text{IN}} = \frac{3.3 \times 0.5}{2.0 \times 0.85}$

$I_{\text{IN}} \approx 0.97\text{ A}$

The ESP32-S3 will not continuously draw 500 mA in a typical sensor project, but the batteries and converter must tolerate its short radio-current peaks.

AA Battery Configurations for the MT3608

Here is what happens with common AA battery arrangements:

Two AA cells are therefore the most convenient arrangement for this MT3608 circuit.

Because the MT3608 requires approximately 2 V at its input, the converter will eventually stop operating when a two-cell pack falls to about 1 V per cell.

Required Components

For the basic ESP32-S3 AA battery circuit, you will need:

• ESP32-S3 development board
• MT3608 adjustable boost-converter module
• Two-cell AA battery holder
• Two matching AA batteries
• On/off switch
• 470 µF electrolytic capacitor rated for at least 6.3 V
• 0.1 µF ceramic capacitor
• Multimeter
• Jumper wires or soldered connections

For battery-voltage measurement, you will also need:

• Two 100 kΩ resistors
• One optional 0.1 µF capacitor

Use batteries of the same type, brand, capacity, and approximate age. Do not mix alkaline batteries with rechargeable batteries in the same holder.

Adjusting the MT3608 to 3.3 V

The MT3608 is an adjustable converter. It must be configured before it is connected to the ESP32-S3.

Do not connect the MT3608 output to the ESP32-S3 until you have measured and adjusted its output voltage. An incorrectly adjusted module can output a voltage high enough to damage the board.

Follow these steps:

1. Insert the two AA batteries into the holder.
2. Connect the battery holder’s positive wire to MT3608 IN+.
3. Connect the battery holder’s negative wire to MT3608 IN−.
4. Set your multimeter to DC voltage.
5. Measure between MT3608 OUT+ and OUT−.
6. Turn the adjustment potentiometer slowly while watching the multimeter.
7. Stop when the output reads approximately 3.30 V.
8. Disconnect the batteries before wiring the ESP32-S3.

The potentiometer on many MT3608 modules is multi-turn. It may require several rotations before the output voltage visibly changes. Do not assume that every module adjusts in the same direction. Watch the multimeter while turning the potentiometer.

ESP32-S3 AA Battery Wiring Diagram

After adjusting the MT3608 to 3.3 V, connect the complete circuit as follows:

Observe the polarity of the electrolytic capacitor:

• Capacitor positive lead to MT3608 OUT+
• Capacitor negative lead to ground

The 470 µF capacitor helps supply short bursts of current when the ESP32-S3 radio begins transmitting. The 0.1 µF ceramic capacitor helps suppress higher-frequency noise. Install the capacitors close to the ESP32-S3 power pins rather than close to the battery holder. Long wires add resistance and inductance, reducing the capacitors’ ability to support fast current pulses.

Why We Connect the MT3608 to the 3V3 Pin

Most ESP32-S3 development boards include an onboard regulator that converts USB or 5 V input to 3.3 V.

One option would be to adjust the MT3608 to 5 V and connect it to the board’s 5V input. However, the power would pass through two conversion stages:

$\text{AA batteries} \longrightarrow 5\text{ V boost} \longrightarrow 3.3\text{ V regulator}$

Each conversion stage wastes some energy.

By adjusting the MT3608 to 3.3 V and connecting it directly to the 3V3 pin, we bypass the development board’s onboard regulator:

$\text{AA batteries} \longrightarrow 3.3\text{ V boost} \longrightarrow \text{ESP32-S3}$

The disadvantage is that the board no longer has another regulator between the MT3608 and the ESP32-S3. The MT3608 output must therefore be adjusted accurately and checked before every major wiring change.

Important USB Power Warning

Disconnect the AA battery supply before connecting the ESP32-S3 to USB unless the board or external circuit includes proper power-source isolation.

Connecting USB power and an external 3.3 V supply at the same time may cause current to flow backward into one of the power sources.

A simple approach during development is:

1. Switch off or disconnect the AA battery holder.
2. Connect USB and upload the sketch.
3. Disconnect USB.
4. Reconnect or switch on the battery supply.

A more advanced design can use:

• Schottky-diode isolation
• An ideal-diode controller
• A load switch
• A power multiplexer
• A jumper that selects USB or battery power

Adding an ESP32-S3 Battery Voltage Monitor

The ESP32-S3 can measure the battery voltage using one of its ADC pins. The measurement must be taken from the battery side of the MT3608. Measuring the converter output would normally show approximately 3.3 V even as the batteries discharge.

For a two-cell AA pack, use the following voltage divider:

GPIO4 is an ADC-capable pin on the ESP32-S3 and corresponds to ADC1 channel 3.

The two equal resistors divide the battery voltage by two:

$V_{\text{ADC}} = V_{\text{BATTERY}} \times \frac{100\,\text{k}\Omega}{100\,\text{k}\Omega + 100\,\text{k}\Omega}$

Therefore:

$V_{\text{BATTERY}} = V_{\text{ADC}} \times 2$

A fresh two-cell alkaline pack measuring 3.2 V produces approximately:

$V_{\text{ADC}} = \frac{3.2}{2} = 1.6\text{ V}$

An optional 0.1 µF capacitor from GPIO4 to ground can reduce noise and help stabilize the ADC reading. This is especially useful because the two 100 kΩ resistors create a relatively high-impedance source for the ADC.

The resistor divider continuously draws a small current:

$I = \frac{3.0\text{ V}}{200\,\text{k}\Omega}$

$I = 15\,\mu\text{A}$

This is small compared with the consumption of a normal ESP32-S3 development board. However, it can become significant in a highly optimized low-power design. On a custom PCB, the voltage divider can be enabled only when a measurement is required by using a MOSFET or analog switch.

ESP32-S3 AA Battery and Deep-Sleep Code

The following Arduino sketch reads the AA battery-pack voltage and then places the ESP32-S3 into deep sleep for ten minutes.

#include <Arduino.h>

#define BATTERY_ADC_PIN       4
#define SLEEP_TIME_SECONDS    600

const float R1 = 100000.0;
const float R2 = 100000.0;

float readBatteryVoltage()
{
  const int numberOfSamples = 32;
  uint32_t totalMillivolts = 0;

  for (int i = 0; i < numberOfSamples; i++)
  {
    totalMillivolts += analogReadMilliVolts(BATTERY_ADC_PIN);
    delay(5);
  }

  float adcMillivolts =
      totalMillivolts / (float)numberOfSamples;

  float adcVoltage = adcMillivolts / 1000.0;

  // Reconstruct the original battery voltage.
  float batteryVoltage =
      adcVoltage * ((R1 + R2) / R2);

  return batteryVoltage;
}

void setup()
{
  Serial.begin(115200);
  delay(1000);

  analogReadResolution(12);
  analogSetPinAttenuation(BATTERY_ADC_PIN, ADC_11db);

  float batteryVoltage = readBatteryVoltage();

  Serial.print("AA battery pack voltage: ");
  Serial.print(batteryVoltage, 2);
  Serial.println(" V");

  /*
   * Read sensors or transmit data here.
   *
   * Keep this section as short as possible.
   * Wi-Fi, Bluetooth and sensors consume much
   * more current than deep sleep.
   */

  Serial.println("Entering deep sleep...");
  Serial.flush();

  esp_sleep_enable_timer_wakeup(
      (uint64_t)SLEEP_TIME_SECONDS * 1000000ULL
  );

  esp_deep_sleep_start();
}

void loop()
{
  // The ESP32-S3 restarts setup() after waking
  // from deep sleep.
}

The Arduino-ESP32 API provides analogReadMilliVolts(), which returns a calibrated voltage value rather than a raw ADC count.

The 11 dB attenuation setting increases the input range available to the ADC. The divided battery voltage should remain well below the ESP32-S3 ADC pin’s maximum level.

How the Deep-Sleep Code Works

The ESP32-S3 executes setup() after power-up and after every deep-sleep wake-up.

The program performs the following sequence:

1. Configures the ADC.
2. Reads the AA battery-pack voltage.
3. Performs the required sensor or communication task.
4. Configures a ten-minute wake-up timer.
5. Enters deep sleep.
6. Restarts when the timer expires.

The sleep duration is configured here:

#define SLEEP_TIME_SECONDS 600

For a five-minute interval, change it to:

#define SLEEP_TIME_SECONDS 300

For a one-hour interval:

#define SLEEP_TIME_SECONDS 3600

Deep sleep powers down the ESP32-S3 CPUs and most digital peripherals while retaining selected RTC circuitry. The ESP32-S3 chip itself can reach a deep-sleep current of only a few microamps under datasheet conditions. A complete development board will normally consume more because it may also contain:

• A voltage regulator
• USB-to-UART circuitry
• USB interface circuitry
• A power indicator LED
• An addressable RGB LED
• Flash memory
• PSRAM
• Pull-up resistors
• Other support components

The MT3608 module also consumes current while operating, even when the ESP32-S3 is asleep.

Is the MT3608 Good for Deep-Sleep Projects?

The MT3608 is suitable for learning, prototyping, and inexpensive battery-powered projects. However, it is not necessarily the best converter for an ultra-low-power sensor node.

The total sleep current includes:

• ESP32-S3 development-board sleep current
• MT3608 operating current
• Any indicator LED on the MT3608 module
• Battery-monitor divider current
• Sensor standby current
• Leakage through connected peripherals

Some generic MT3608 modules include an indicator LED that remains on continuously. Even a small LED current can become significant when the ESP32-S3 spends most of its time sleeping. For a project intended to run for many months or years, consider a boost converter designed specifically for low-quiescent-current operation.

The MT3608 remains useful for this tutorial because it is:

• Inexpensive
• Widely available
• Easy to adjust
• Easy to mount on a breadboard or prototype board
• Capable of supplying an ESP32-S3 when properly selected and tested

Estimating ESP32-S3 AA Battery Runtime

Battery runtime depends more on average current than on the highest current peak.

A basic runtime estimate is:

$\text{Runtime (hours)} = \frac{\text{Battery capacity (mAh)}}{\text{Average battery current (mA)}}$

Suppose the ESP32-S3:

• Draws 120 mA while awake
• Remains awake for five seconds
• Wakes every ten minutes
• Draws 0.3 mA from the 3.3 V rail while sleeping

Its average current on the regulated 3.3 V rail is approximately:

$I_{\text{AVG}} = 120\left(\frac{5}{600}\right) + 0.3\left(\frac{595}{600}\right)$

$I_{\text{AVG}} \approx 1.30\text{ mA}$

Assuming an average battery voltage of 2.4 V and an MT3608 efficiency of 85%:

$I_{\text{BATTERY}} = \frac{3.3 \times 1.30}{2.4 \times 0.85}$

$I_{\text{BATTERY}} \approx 2.1\text{ mA}$

Using a conservative usable battery capacity of 2000 mAh:

$\text{Runtime} = \frac{2000}{2.1}$

$\text{Runtime} \approx 953\text{ hours}$

This is approximately 40 days.

However, this simplified calculation does not include the MT3608 module’s own operating current. Suppose the converter module and its indicator LED draw an additional 1 mA from the battery pack:

$I_{\text{TOTAL}} = 2.1\text{ mA} + 1.0\text{ mA}$

$I_{\text{TOTAL}} = 3.1\text{ mA}$

The estimated runtime would then become:

$\text{Runtime} = \frac{2000}{3.1}$

$\text{Runtime} \approx 645\text{ hours}$

This is approximately 27 days.

This example shows why converter idle current matters in a deep-sleep project.

Actual runtime may be lower because of:

• MT3608 quiescent and indicator-LED current
• Battery internal resistance
• Low-temperature operation
• Wi-Fi connection time
• Sensor consumption
• Development-board LEDs
• Battery age
• Reduced alkaline capacity at higher discharge currents
• The MT3608’s approximately 2 V minimum input
• Conversion losses that change with load and battery voltage

The best approach is to measure the current of the complete circuit using the actual batteries, converter module, sensors, development board, and firmware.

Alkaline or Rechargeable AA Batteries?

Both alkaline and NiMH AA batteries can be used with the MT3608.

Alkaline AA Batteries

Alkaline batteries have a nominal voltage of 1.5 V per cell. Two cells produce a nominal 3.0 V, which the MT3608 can raise to 3.3 V. Alkaline cells are widely available and have a relatively low self-discharge rate. However, their voltage continuously falls during use, and their effective capacity decreases under heavier loads. The high current pulses produced by Wi-Fi may cause a larger temporary voltage drop when alkaline batteries are old, cold, or partially discharged.

NiMH Rechargeable AA Batteries

NiMH batteries typically have a nominal voltage of 1.2 V per cell. Two cells therefore provide approximately:

$2 \times 1.2\text{ V} = 2.4\text{ V}$

The MT3608 raises this to 3.3 V. NiMH batteries generally handle repeated high-current pulses better than ordinary alkaline batteries and can be recharged many times. For a frequently used wireless sensor, NiMH cells may be more economical. Low-self-discharge NiMH batteries are especially useful when the device spends long periods asleep.

Improving ESP32-S3 AA Battery Life

Use Deep Sleep

Do not leave the ESP32-S3 running continuously if it only needs to take a measurement every few minutes. Deep sleep normally provides a much larger improvement than simply reducing the CPU frequency while the chip remains awake.

Keep Wi-Fi Sessions Short

Connecting to Wi-Fi and transmitting data consume considerably more current than sleeping.

A battery-powered application should normally:

1. Wake up.
2. Read its sensors.
3. Connect to the network.
4. Transmit its data.
5. Disconnect or shut down the radio.
6. Return to deep sleep.

Remove or Disable Power LEDs

A power LED drawing even 1 mA becomes significant when the ESP32-S3 spends most of its time in deep sleep. Inspect both the ESP32-S3 board and the MT3608 module for always-on LEDs. Some boards allow the LED resistor to be removed. Others require cutting a trace. Only modify a board after inspecting its schematic and PCB connections.

Turn Sensors Off While Sleeping

Some sensors continue drawing current even while the ESP32-S3 is asleep. A load switch, P-channel MOSFET, or regulator-enable pin can disconnect sensor power before deep sleep.

Keep the Wires Short

Long, thin wires add resistance. A high current pulse can produce a temporary voltage drop across them:

$V_{\text{DROP}} = I \times R$

Keep the battery, MT3608, capacitor, and ESP32-S3 power connections short and secure.

Use a Low-Power Converter for Long Deployments

The MT3608 is useful for prototyping, but a low-quiescent-current fixed-output converter is a better choice when maximizing runtime is more important than minimizing component cost.

Move to a Custom PCB

Development boards are excellent for prototyping, but their USB interface, LEDs, regulator, and support circuitry are not always optimized for battery operation. A custom PCB using an ESP32-S3 module and a low-power converter can achieve much lower sleep current.

Troubleshooting the ESP32-S3 MT3608 Circuit

The ESP32-S3 Resets When Wi-Fi Starts

This is usually caused by the 3.3 V rail dropping during a radio-current burst.

Check the following:

• MT3608 output voltage under load
• Battery condition
• Battery-holder contacts
• Wire length and thickness
• Output-capacitor value and placement
• Solder joints
• MT3608 module quality

Place the 470 µF capacitor close to the ESP32-S3. Measure the 3.3 V rail while the ESP32-S3 starts Wi-Fi rather than measuring it only when the board is idle.

The MT3608 Output Does Not Change

The adjustment potentiometer may require many turns before the voltage changes. Continue turning it slowly while monitoring the output with a multimeter. Do not connect the ESP32-S3 while experimenting with the adjustment.

The MT3608 Cannot Reach 3.3 V

Measure the battery voltage at IN+ and IN−. The input may have fallen below the MT3608’s operating range, or the battery voltage may collapse when a load is connected.

Also inspect:

• Battery polarity
• Loose holder contacts
• Incorrect input/output wiring
• A damaged converter module
• An excessive load on the output

The Board Works with USB but Not with Batteries

Measure the following voltages:

1. Battery-pack voltage without a load
2. Battery-pack voltage with the ESP32-S3 connected
3. MT3608 input voltage
4. MT3608 output voltage
5. ESP32-S3 3V3-pin voltage during startup

A reading of 3.3 V with no load does not guarantee that the converter can maintain 3.3 V during startup or Wi-Fi transmission.

The Battery Reading Is Too High or Too Low

Verify the actual resistor values and voltage-divider wiring. The battery-positive connection must come from the battery side of the MT3608. The ADC pin must connect to the junction of the two resistors. Average several ADC samples and compare the result with a multimeter. A small calibration factor can be added after testing:

batteryVoltage *= 1.03;

Use a correction factor based on measurements from your own board and resistor divider.

The Deep-Sleep Current Is Still High

The ESP32-S3 chip may be sleeping correctly while the rest of the circuit continues drawing current.

Check:

• ESP32-S3 power LED
• MT3608 indicator LED
• USB-to-UART circuitry
• MT3608 operating current
• Sensor standby current
• Battery voltage divider
• External pull-up resistors
• Other connected modules

Measure current at the battery holder so that the reading includes the entire circuit rather than only the ESP32-S3 board.

Conclusion

Powering an ESP32-S3 with AA batteries is possible using a properly adjusted MT3608 boost converter. Two alkaline or two NiMH AA cells provide a suitable input for the MT3608. The module raises the changing battery voltage to a regulated 3.3 V that can be applied to the ESP32-S3 board’s 3V3 pin. Before connecting the development board, always use a multimeter to adjust the MT3608 output to 3.3 V. Add a large capacitor close to the ESP32-S3 to support Wi-Fi current bursts, and avoid connecting USB and external 3.3 V power simultaneously unless the sources are properly isolated.

The MT3608 is a practical and affordable choice for prototypes. However, its operating current and any onboard indicator LED can reduce the runtime of a deep-sleep project. Applications intended to operate for many months should use a converter specifically designed for low-quiescent-current battery operation. Battery life will ultimately depend on how long the ESP32-S3 remains awake. By reading sensors quickly, keeping Wi-Fi sessions short, turning off peripherals, and entering deep sleep between measurements, an ESP32-S3 AA battery project can operate for weeks or potentially months.

The post How to Power an ESP32-S3 with AA Batteries appeared first on Microcontroller Tutorials.

Why PCB Material Selection Matters

Substrate material affects nearly every aspect of board performance. Here's what changes when you switch materials:

A material that works perfectly for a Bluetooth IoT sensor may fail catastrophically in an automotive ECU exposed to 125°C underhood temperatures. Understanding the material properties and how they interact with your design constraints is critical to getting it right the first time.

Common PCB Material Types

FR-4

FR-4 is a woven fiberglass-reinforced epoxy laminate that accounts for over 90% of PCBs manufactured worldwide. It offers a strong balance of electrical insulation, mechanical strength, and cost-effectiveness.

FR-4 comes in several grades defined by glass transition temperature (Tg), which determines the temperature at which the material begins to soften and lose mechanical integrity.

Standard FR-4 is typically sufficient for most consumer electronics and general-purpose designs. High-Tg becomes necessary when boards undergo multiple lead-free reflow cycles or operate in elevated temperature environments.

When to use FR-4: General-purpose digital and analog designs, frequencies below 1–2 GHz, cost-sensitive projects, prototype runs.

When NOT to use FR-4: High-frequency RF (>2 GHz), extreme temperature environments, high-power thermal management, applications requiring tight Dk tolerance.

High-Frequency / RF Laminates

For designs operating above 1–2 GHz, FR-4's dielectric losses become unacceptable. High-frequency laminates use specialized resin systems and reinforcements to provide stable, low-loss electrical properties.

These materials cost 4× to 10× more than standard FR-4, so engineers often use hybrid stackups—RF laminates on signal layers and FR-4 for the rest—to balance performance and cost.

When to use RF laminates: Microwave and millimeter-wave circuits, high-speed digital (>10 Gbps), sensitive RF front-ends, impedance-critical designs.

Aluminum / Metal-Core PCB (MCPCB)

Aluminum PCBs use a thin dielectric layer bonded to an aluminum or copper base plate. The metal core conducts heat away from power components far more effectively than FR-4.

Typical thermal conductivity values:

Primary applications: High-power LED lighting, motor drivers, power converters, automotive headlamps, switch-mode power supplies.

The trade-off is that MCPCBs cannot support plated through-holes in the metal core area, which limits routing density and layer count to 1–2 layers typically.

Polyimide (Flex / Rigid-Flex)

Polyimide substrates offer exceptional thermal stability (Tg >300°C) and mechanical flexibility, making them the standard material for flexible and rigid-flex PCBs.

Polyimide is essential for applications requiring dynamic flexing, such as foldable devices, camera modules, and robotic joints. However, it absorbs significantly more moisture than FR-4, which must be accounted for in the assembly process—baking before reflow is mandatory.

Key Material Properties Explained

Understanding these properties is essential for making informed material selections.

Glass Transition Temperature (Tg)

Tg is the temperature at which the resin transitions from a rigid, glass-like state to a rubbery, softened state. Below Tg, the material maintains its mechanical and electrical integrity. Above Tg, the coefficient of thermal expansion increases dramatically (3–5×), which can stress plated through-holes and cause barrel cracking.

Rule of thumb: Select a material with Tg at least 25°C above your maximum operating and assembly temperatures.

Dielectric Constant (Dk) and Dissipation Factor (Df)

Dk determines signal propagation speed and impedance. A stable, consistent Dk across frequency and temperature is critical for high-speed and RF designs.

Df (also called loss tangent) measures how much signal energy is lost as heat in the dielectric. Lower Df means less signal attenuation.

Coefficient of Thermal Expansion (CTE)

CTE describes how much the material expands when heated. The Z-axis (through-thickness) CTE is the most critical value because via barrels are constrained in this direction.

High Z-axis CTE mismatch between the laminate and copper plating is a leading cause of via barrel cracks during thermal cycling and lead-free soldering.

Target values: Z-axis CTE below Tg should be 40–60 ppm/°C for standard FR-4. High-reliability materials target 30–50 ppm/°C.

UL 94 Flammability Rating

Most electronics require UL 94 V-0 rated materials, which self-extinguish within 10 seconds of flame removal. This is the standard for consumer, industrial, automotive, and medical applications.

Common Material Selection Mistakes

Over-specifying RF Materials

Using Rogers RO4350B for a 500 MHz digital design is like buying a racing bicycle for a trip to the grocery store. It works, but you're paying 4× more than necessary. FR-4 performs adequately below 1–2 GHz for most applications.

Fix: Always check whether your design actually needs tight Dk tolerance. If your highest frequency component runs at 200 MHz and you're not doing impedance-critical routing, standard FR-4 will work fine.

Ignoring CTE Mismatch in Hybrid Stackups

Combining FR-4 with Rogers or polyimide in the same stackup creates CTE mismatches that can cause delamination or via cracking during thermal cycling. Each material expands at a different rate, stressing the interfaces between layers.

Fix: Work with your fabricator to understand available hybrid material combinations and verified bonding schedules. Not all material combinations are reliable.

Neglecting Moisture Sensitivity

Polyimide absorbs up to 3% moisture, while FR-4 absorbs only 0.1%. If you specify polyimide for a flex section without accounting for moisture in your assembly process, you risk delamination during reflow soldering.

Fix: Specify pre-bake requirements for moisture-sensitive materials. IPC-J-STD-033 provides guidelines for handling moisture-sensitive components and substrates.

Specifying Unavailable Material Grades

Many exotic laminates have minimum order quantities at distributors or long lead times. If you specify a rare IPC-4101 slash sheet without checking availability, you may delay your project by weeks.

Fix: Discuss material availability with your circuit board fabrication partner early in the design phase. A fab with broad material sourcing experience and robust circuit board fabrication capabilities can suggest equivalent or similar materials that are in stock. For a comprehensive overview of available laminates, see our complete guide to PCB material selection.

Cost Comparison by Material Type

Material cost is typically 10–20% of total PCB fabrication cost, but the choice of substrate has a significant impact on overall board price.

Cost-saving tip: For mixed-material designs, use the expensive laminate only on the signal layers that require it. A 4-layer hybrid stackup with Rogers on the outer layers and FR-4 core can save 40–60% compared to an all-Rogers board.

Making the Right Choice

The right PCB material depends on your specific combination of electrical, thermal, mechanical, and cost requirements. Here's a quick summary of which material to choose based on your dominant design constraint:

Frequently Asked Questions

What is the most commonly used PCB material?

FR-4 is by far the most common PCB material, used in over 90% of all PCBs manufactured. It offers a good balance of electrical insulation, mechanical strength, and cost-effectiveness for frequencies below 1–2 GHz.

How do I choose between FR-4 and Rogers materials?

Choose FR-4 for general-purpose designs below 1–2 GHz, non-critical impedance control, and cost-sensitive projects. Choose Rogers or other RF laminates when your design operates above 2 GHz, requires tight Dk tolerance (±2% or better), or needs low loss tangent for signal integrity at high frequencies.

What does Tg mean in PCB materials?

Tg (glass transition temperature) is the temperature at which the PCB substrate begins to soften from a rigid, glass-like state to a rubbery state. Below Tg, the material maintains its mechanical and electrical properties. Above Tg, thermal expansion increases dramatically, which can stress plated through-holes.

Is high-Tg FR-4 always better than standard FR-4?

Not necessarily. High-Tg FR-4 costs 20–50% more than standard FR-4 and offers no advantage in designs that never experience elevated temperatures. Use high-Tg only when your board will undergo multiple lead-free reflow cycles or operate above 100°C continuously.

Can I use aluminum PCB for RF designs?

Aluminum MCPCBs are not suitable for RF or high-speed designs. The thick dielectric layer required for electrical isolation limits impedance control and introduces high losses at frequency. Aluminum-core boards are optimized for thermal management, not signal integrity.

What materials are used for flexible PCBs?

Polyimide (typically Kapton) is the standard material for flexible and rigid-flex PCBs. It offers excellent thermal stability (Tg >300°C) and mechanical flexibility. PET and PEN are used in low-cost consumer applications but cannot withstand soldering temperatures.

How do I verify my chosen material meets regulatory requirements?

Check the material's UL 94 flammability rating (V-0 is standard for most electronics), RoHS compliance status, and any industry-specific requirements (IATF 16949 for automotive, ISO 13485 for medical). Request the laminate manufacturer's certification data sheet from your fabricator.

What is a hybrid PCB stackup?

A hybrid stackup uses two or more different laminate materials in the same board. The most common example is Rogers RO4350B on the outer (RF) signal layers with FR-4 cores for the remaining layers. This approach balances high-frequency performance with cost control.

Conclusion

Selecting the right PCB material doesn't have to be overwhelming. Start with FR-4 for general-purpose designs, and only move to specialty materials when your specific requirements demand it—RF performance above 2 GHz, extreme temperatures, thermal management, or flex applications.

The post PCB Material Types and Selection: A Practical Guide for Design appeared first on Microcontroller Tutorials.