Flux Blog

HDI Challenges

Even for the most experienced engineers, high density interconnect designs remain difficult. Some typical challenges are:

• Using space efficiently while respecting manufacturing constraints,
• Avoiding misalignment, which could lead to poor connectivity, or even complete circuit failure,
• Avoiding congestion, which could lead to crosstalk and signal degradation.

Traditional EDA tools depend heavily on manual input for via placement. This makes density management primarily a function of hand-eye coordination. After placement, when you need to modify part of the design, you’ll quickly find yourself playing an unsolicited game of three-dimensional chess. Often, it’s easiest to simply wipe out the traces and vias, start over, and hope you won’t have to make another change to that part of your board.

After carefully laying everything out, the next big effort is to define and work through manufacturability, reliability, and cost considerations. In practice, this mountain of manual labor adds up. Designers are often forced to either compromise their design, risk overlooking mistakes, or delay their project.

Introducing Smart Vias

Smart Vias in Flux is an intelligent feature that automates the selection, placement, and configuration of vias during the PCB design process. This automation reduces the manual effort involved in via placement and significantly lowers the risk of misalignment and other common errors associated with traditional via management

If you’re routing a trace and need to connect across multiple layers, Flux will place a Smart Via that automatically populates with the best suited combination of vias (micro, blind, buried, or through-hole), in a stacked or staggered configuration, respecting your project settings. For example, you might only want to use microvias on outer layers and use through-hole vias for everything else. With Smart Vias, you can just start routing. When you switch from Top to Mid-Layer 1, a Smart Via will get you there. You can change your mind and go to Bottom and the Smart Via will dynamically reconfigure itself to support that connectivity.

Smart Vias are powered by Flux’s innovative Layout Rules. Rules allow you to set your preferences from a central place in the Stackup. They also allow for control of individual Smart Vias right down to the details, like the direction or spacing of a stagger. The result is a feature gets out of your way when you want and also lets you sweat the small stuff.

To make it even easier to get started, simply clone or fork any of these templates.

• PCBWay: 4-layer and 6-layer HDI stackup template
• VictoryPCB: 4-layer and 6-layer HDI stackup template
• Seeed Studio: 4-layer stackup template

Making HDI a Breeze

Overall, Smart Vias addresses many of the challenges inherent in high density interconnect design and offers notable benefits to the designer.

• Automated Via Management: Automates via selection and placement, saving designers significant time and effort by eliminating the need for tedious manual configurations.
• Error Reduction: Reduces the likelihood of design errors, such as misalignment or improper via selection, leading to fewer design revisions and faster time-to-market.
• Optimized Via Density: Ensures optimal via density, minimizing crosstalk and maintaining signal integrity.
• Thermal Integration: Proactively integrates with thermal management tools, preventing vias from contributing to overheating, thereby enhancing the durability and longevity of the final product.
• Enhanced Reliability: Increases the overall reliability and performance of the PCB, giving users confidence in the quality and robustness of their designs.
• Efficient Design Process: It streamlines the entire design process, enabling users to achieve more accurate and efficient results.

Get Started with Flux

We think this is a huge improvement over existing workflows and we’re excited for you to use it. Interested in experiencing the new Smart Via feature? Get started with a template today!

Let's dive in.

1. Improper Trace Width and Spacing

One of the most common mistakes in PCB design is not paying enough attention to trace width and spacing, especially in high-current or high-speed applications. If the trace is meant to carry high currents but it happens to be too narrow, it can result in thermal issues or even a failure of the circuit.

The width of your trace can be determined by things like; how much current it should carry without overheating or causing excessive voltage drops, Impedance control, and sensitivity of the signal running through it.

Flux makes routing high speed signals, such as USB data lines, easier by automatically performing coupled routing of the data lines (D+ and D-) and calculating the impedance of the pair based on the PCB stackup. This helps prevent reflections that can cause signal distortion, timing issues, and data corruption.

Flux Copilot can also help you calculate the appropriate trace width based on the current it needs to carry, while also considering the required impedance for high-speed signals. Just ask something like:

@copilot please recommend trace width for my VBUS.

Then copilot responses:

“For VBUS, typically a 5V supply in USB applications, let's assume a common scenario where you might anticipate a current of up to 1A. Using a temperature rise of 10°C, the general guideline for trace width on a 1 oz/ft² copper PCB is approximately 20-30 mils (0.5-0.8 mm) per amp of current.”

2. Overlooking Via Sizes

Vias are crucial for connecting different layers in a PCB, but choosing the wrong size or type can cause issues in both signal integrity and manufacturing. Blind, buried, and microvias are often used in high-density interconnect (HDI) boards, but these require careful consideration during design. For instance, microvias are perfect for compact designs, but if placed improperly, they can lead to poor layer transitions or increased inductance.

Flux let’s you set up your stackup where you add all the manufacturer capabilities. When you need some more advice on what stackup best suits your design, always feel free to ask copilot for some ideas, you could ask

@copilot in a table format recommend vias sizes that i can use for my VDD3V3, my USB, and the other signal buses?

Then here's the copilot response,

If you're routing a high-speed differential pair, such as USB or PCIe, through multiple layers, via stubs can cause signal reflections that degrade signal quality. A rule of thumb is to ensure via lengths are minimized, or even better, use back-drilling techniques to remove stubs, especially in high-frequency circuits.

Moreover, not all manufacturers support the same via sizes, so checking with your manufacturer early in the design process can avoid headaches later. Make sure to adhere to their capabilities, including the aspect ratio limits (via depth to diameter), to avoid costly redesigns e.g. 20:1 for PCBWay.

3. Ignoring Power and Ground Plane Layouts

The layout of power and ground planes is another common area where mistakes are made. These planes act as the backbone of your circuit's stability, so a poorly designed plane can introduce noise, increase EMI, and degrade power delivery.

By default, Flux starts you off with a solid, contiguous ground plane since it is critical for minimizing noise and providing a low-impedance return path for high-speed signals. It is advisable to avoid creating islands which can cause severe signal integrity.

Example:
Imagine routing a high-speed signal across a split ground plane. The signal may cross the gap, creating a longer return path, which increases inductance and can lead to signal distortion or timing errors in critical circuits like clocks or data buses.

Similarly, power planes should be wide enough to handle the current required by each section of the circuit. For designs with sensitive analog circuits, it’s often a good idea to have separate power planes or split planes for analog and digital sections to avoid cross-talk and noise coupling.

4. Neglecting Design for Manufacturability (DFM)

Designing with manufacturability in mind is essential to ensure that your board can be built without issues. It’s easy to forget that the design rules you use in your ECAD tool may not fully align with your manufacturer’s capabilities, and this can result in delays or additional costs.

Flux provides users with pre-configured templates which align with most of the popular manufacture (e.g. PCBWay, JLCPCB, AISLER, LION Circuits, SEEED Studio and many more) capabilities so that users don’t have to worry about manually configuring things like trace widths, keepout, and other parameters. A good general rule of thumb is to always start new project using Flux manufacturer design rule templates

There are numerous DFM tips but here are some common ones to consider;

• Don’t Place Parts Too Close to the Edge of the Board
  Many designers overlook the fact that most manufacturers require a certain clearance between the edge of the board and components. This clearance is needed for handling, tooling, and depaneling during assembly. If components like connectors or switches are too close to the edge, you risk damaging them during these processes.
• Take into Account Manufacturer Capabilities
  Every manufacturer has specific limitations regarding trace width, spacing, via sizes, and the number of layers they can handle. Sending a design that exceeds these capabilities will either increase costs or lead to a failed production run. For example, your HDI board with 0.1mm microvias might not be feasible for a manufacturer specializing in simpler designs.
• Too Closely Spaced Components
  Placing components too close together can lead to assembly issues, especially for automated pick-and-place machines. Components that are tightly packed can cause soldering problems like bridging, or they may not fit the soldering process at all. Always check for manufacturer’s minimum spacing requirements between components and account for heat sinks or thermal relief pads if necessary.

Using Flux manufacturer design rule templates will alert you when either of the manufacturer capabilities  are violated even before sending your files for manufacturing saving you time.

5. Improper Decoupling Capacitor Placement

Decoupling capacitors are used to filter out noise and provide a stable voltage to ICs, especially in digital circuits where rapid switching causes power fluctuations. However, placing these capacitors too far from the pins of the IC can render them ineffective. It is advisable to place these decoupling capacitors as close as possible to the IC without violating the minimum spacing a manufacturer can work with.

Example:
In a typical microcontroller design, you should place decoupling capacitors (such as 0.1µF and 1µF) as close as possible to the VCC and GND pins. Ideally, the capacitors should be placed on the same layer as the IC to reduce parasitic inductance and ensure faster response times. Failure to do so can cause power integrity issues, leading to glitches or resets in your circuit.

Additionally, use vias sparingly when routing decoupling capacitors. Each via adds inductance to the path, which reduces the capacitor's ability to suppress high-frequency noise.

Final thoughts

Before pressing that button to send your PCB design for manufacturing, it's worth taking a step back and performing a thorough review of your design. These design review steps can be quite a handful but what we have discussed above can be considered as the bare minimum. Flux manufacturer design rules makes it easy to ensure trace widths, appropriate via sizes, and manufacturer capabilities are considered when designing your board.

A thorough PCB design review can be a very daunting task, you might not be sure where to start or what checks to include in the review process. That is one of the reasons Flux’s AI lives in your project. You can use copilot to quickly check decoupling capacitors, power and grounding, ensuring compliance with industry standards, and even creating a stronger supply chain. To learn more about how you can use this tool, Sign up for Flux today.

Common Microcontroller Architecture

A typical microcontroller includes a processor, memory and Input/Output (I/O) peripherals on a single chip. Its components may be extended to include: Digital I/O, Analog I/O, Timers, Communication interfaces, Watchdog (a timer that is responsible for the detection of timed out or locked instruction).

A processor is a little chip present in the device that has the role of arranging the instructions and order the outputs. The manufacturer defines the integrated peripherals and the hardware capabilities.

STM32 Microcontroller Families Overview

STM32 microcontrollers are divided into several groups based on their target applications. Below is a quick overview to help you choose the right MCU series:

• High Performance (e.g., STM32F7, STM32H7): Optimized for processing-intensive tasks, such as graphics or audio processing.
• Mainstream (e.g., STM32F1, STM32G4): Ideal for general-purpose applications, balancing cost and performance.
• Ultra Low Power (e.g., STM32L4, STM32L5): Designed for battery-operated devices, focusing on efficiency.
• Wireless (e.g., STM32WB): Includes built-in Bluetooth and IEEE 802.15.4 wireless communication.

Which STM32 MCU to Select?

• STM32F0 (Mainstream)
  Based on the Arm Cortex-M0 processor, running up to 48 MHz. Optimized for low cost and designed to compete with 8-bit and 16-bit platforms.
• STM32F1 (Mainstream)
  Based on the Arm Cortex-M3 processor, with a maximum clock speed of 72 MHz. A general-purpose microcontroller, widely popular for hobby projects.
• STM32F2 (High Performance)
  Based on the Arm Cortex-M3 processor, with a clock speed of up to 120 MHz. Offers optimized performance for more demanding applications.
• STM32F3 (Mainstream)
  Based on the Arm Cortex-M4 processor, featuring FPU and DSP instructions, with a speed of up to 72 MHz. Ideal for mixed-signal applications.
• STM32F4 (High Performance)
  Based on the Arm Cortex-M4 processor with FPU and DSP instructions, running at up to 180 MHz. Known for high performance, frequently used in multimedia and industrial projects.
• STM32F7 (High Performance)
  Based on the Arm Cortex-M7 processor with FPU and DSP instructions, running at up to 216 MHz. Pin-to-pin compatible with the STM32F4 series, making it easy to upgrade designs.

{{insert-project-1-here}}

• STM32G0 (Mainstream)
  Based on the Arm Cortex-M0+ processor, with a speed of up to 64 MHz. Optimized for efficiency, competing with 8-bit and 16-bit microcontrollers.
• STM32G4 (Mainstream)
  Based on the Arm Cortex-M4 processor with FPU and DSP instructions, running at up to 170 MHz. This series is the successor of the STM32F3 and is ideal for mixed-signal applications.
• STM32H7 (High Performance)
  Based on the Arm Cortex-M7 processor, running at up to 480 MHz, with FPU and DSP instructions. Some models feature a second Arm Cortex-M4 co-processor, making them ideal for industrial automation and complex processing tasks.
• STM32L0 (Ultra Low Power)
  Based on the Arm Cortex-M0+ processor, running at up to 32 MHz. Optimized for low-power applications, such as wearables and battery-operated devices.
• STM32L1 (Ultra Low Power)
  Based on the Arm Cortex-M3 processor, with a speed of up to 32 MHz. Tailored for applications requiring both low power consumption and performance.
• STM32L4 (Ultra Low Power)
  Based on the Arm Cortex-M4 processor with FPU and DSP instructions, running at up to 80 MHz. Designed for ultra-low power use cases with better efficiency.
• STM32L4+ (Ultra Low Power)
  Based on the Arm Cortex-M4 processor with FPU and DSP instructions, with a clock speed of up to 120 MHz. Offers higher performance than the STM32L4 series while maintaining low power consumption.
• STM32L5 (Ultra Low Power)
  Based on the Arm Cortex-M33 processor, running at up to 110 MHz. Provides enhanced security features and is optimized for IoT and battery-powered applications.
• STM32WB (Wireless)
  Based on the Arm Cortex-M4 processor with FPU and DSP instructions, running at up to 64 MHz, alongside a second Arm Cortex-M0+ processor acting as a network processor. Supports Bluetooth 5 and IEEE 802.15.4 standards, making it ideal for wireless IoT solutions.

How to use STM32 MCU?

There are two ways to use an STM32 MCU which are:

• Develop and design your own board
• Using existing STMicroelectronics boards

{{insert-project-2-here}}

Essential STM32 Features for Development and Debugging

STM32 microcontrollers come equipped with several critical features that make development smoother, especially for embedded applications. Here are a few that stand out:

• USB OTG (On-The-Go)
  Many STM32 MCUs, especially in the STM32F4 and STM32H7 series, offer USB OTG functionality. This feature allows the microcontroller to act both as a USB host and a device, enabling easy communication with peripherals like flash drives, keyboards, or sensors. USB OTG makes STM32 ideal for applications like portable devices or data loggers.
• SWD (Serial Wire Debug)
  For debugging and programming, STM32 microcontrollers support SWD. This is a streamlined, two-wire alternative to traditional JTAG interfaces, making it more efficient while reducing pin usage. SWD allows developers to debug their code in real-time and monitor performance directly on the microcontroller.
• UART (Universal Asynchronous Receiver-Transmitter)
  UART communication is available across almost all STM32 MCUs, allowing serial communication between the microcontroller and external devices like sensors, computers, or displays. This feature is particularly useful for applications requiring simple, low-overhead data exchange, such as data logging or wireless modules.
• Debugging with STM32
  STM32 provides robust debugging options, supporting tools like ST-Link, which enables seamless flashing and debugging through SWD. Additionally, most development boards come with built-in debug interfaces, ensuring developers can quickly identify issues and optimize performance.

{{insert-project-3-here}}

Choosing the Perfect STM32 Development Board for Your Application

To get started with STM32, you’ll need a development board. Here are some of the top picks, whether you’re on a budget or seeking advanced features:

Nucleo Boards

• Perfect for beginners, featuring built-in ST-Link debugger.
• NUCLEO-F103RB – STM32F103 MCU with 128kB FLASH memory.

Discovery Kits

• Include additional sensors and displays for prototyping.
• STM32F407G-DISC1 – Ideal for multimedia projects with STM32F4.

Black Pill Board

• Affordable, compact, and widely available on platforms like AliExpress.
• Example: Black Pill with STM32F103C8T6 – Perfect for hobbyists looking for a cost-effective solution.

STM32 Software Tools and IDEs

Once you’ve chosen a development board, the next step is setting up the software. Below are some of the best free IDEs and tools to get started with STM32 programming:

• STM32CubeIDE:
  Official IDE by STMicroelectronics. Cross-platform and integrates seamlessly with STM32CubeMX for configuration.
• PlatformIO:
  A versatile development environment that supports multiple platforms, including STM32.
• STM32duino:
  For those familiar with Arduino, this environment brings the Arduino experience to STM32 boards.
• Keil MDK:
  Free for STM32G0, F0, and L0 series; an excellent option for smaller projects on Windows.

For IoT projects, consider Arm Mbed, a platform that supports cloud-based development and is optimized for low-power devices.

How to Get Started: A Step-by-Step Workflow

1. Setting Up Your Development Board

• Connect the board to your computer via USB.
• Install the STM32CubeIDE or your preferred IDE.
• Verify the connection using the built-in ST-Link debugger.

2. Configuring Your Project with STM32CubeMX

STM32CubeMX simplifies the configuration process by generating initialization code. You can:

• Select your microcontroller.
• Configure pins, clocks, and peripherals through a graphical interface.
• Generate C code, ready to use in STM32CubeIDE.

3. Write and Code Your First STM32 Program

Create a basic “blinky” program to blink an LED. This is a great way to ensure everything is set up correctly.‍‍

#include <stm32f1xx.h>
int main(void) {    
    HAL_Init();  // Initialize the HAL Library    
    __HAL_RCC_GPIOC_CLK_ENABLE();  // Enable GPIO Clock        
    GPIO_InitTypeDef GPIO_InitStruct = {0};    
    GPIO_InitStruct.Pin = GPIO_PIN_13;    
    GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;    
    GPIO_InitStruct.Pull = GPIO_NOPULL;    
    GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;    
    HAL_GPIO_Init(GPIOC, &GPIO_InitStruct);        
    while (1) {        
    HAL_GPIO_TogglePin(GPIOC, GPIO_PIN_13);        
    HAL_Delay(500);
 }
}

Key Specifications and STM32 Pricing Overview

Common Challenges and How to Overcome Them

• Problem: "The IDE doesn't recognize my board."
  Solution: Ensure drivers for the ST-Link debugger are installed. Check connections and firmware.
• Problem: "I don't know which STM32 series to use."
  Solution: Start with STM32F1 or F4 series if you're a beginner. These series have abundant resources online.

{{insert-mark-video}}

Where to Buy STM32 MCUs and Development Boards

You can find STM32 MCUs and development boards from trusted vendors, such as:

• Official STMicroelectronics website
• Mouser Electronics and Digi-Key
• AliExpress and Amazon for budget boards like the Black Pill

Why Choose STM32?

STM32 microcontrollers are an excellent choice for both beginners and advanced developers. They offer a wide range of features, low power consumption, and support for IoT, wireless communication, and industrial automation. With STM32Cube tools and free IDEs, you can build your projects faster and more efficiently.

Whether you’re working on a simple blinky LED project or a complex IoT solution, STM32 has the right series to fit your needs. Get your development board, set up your environment, and start building today!

FAQ About STM32 MCUs

Q: What is the best STM32 series for beginners?
A: The STM32F1 and STM32F4 series are great starting points, as they are well-documented and widely supported.

Q: Is STM32CubeIDE free?
A: Yes, STM32CubeIDE is free and available for Windows, macOS, and Linux.

Q: How much does an STM32 microcontroller cost?
A: Prices vary by series, with the STM32F1 starting around $2 and high-end STM32H7 costing up to $30.

Q: Is STM32 better than Arduino?
A: While Arduino is simpler and more beginner-friendly, STM32 offers more power, flexibility, and scalability. STM32 microcontrollers provide better performance with faster processing speeds, more peripherals, and lower power consumption, making them ideal for more advanced or professional projects. On the other hand, Arduino is great for quick prototyping and those new to microcontrollers.

Q: What are STM32 microcontrollers used for?
A: STM32 MCUs are used in a wide range of applications, including IoT devices, automotive systems, industrial automation, wearables, and smart home products. Their versatility makes them suitable for both high-performance tasks (like multimedia processing) and low-power applications (like battery-operated devices).

In this guide, we’ll walk through:

• GPIO functions and quirks
• Power pin usage
• Boot mode behavior
• Real-world IoT use cases
• Arduino IDE compatibility
• Recommended boards like the Wemos D1 Mini

📌 What Is the ESP8266?

The ESP8266 is a low-cost Wi-Fi microcontroller by Espressif. It enables wireless IoT projects without needing a separate Wi-Fi module. Popular boards like the NodeMCU and Wemos D1 Mini use it as their core.

The Core of the Matter - Understanding the ESP8266 Pinout

The ESP8266 microcontroller module features a total of 32 pins, each with a function that contributes to its remarkable utility. Here, we'll break down these key specifications to provide a clear understanding of its pinout:

1. Communication Interfaces: The ESP8266 supports a variety of communication protocols, including UART, SPI, and I2C, making it compatible with a wide range of sensors and devices.
2. Digital and Analog Pins: Out of the 32 pins, there are 17 GPIO (General-Purpose Input/Output) pins, which can be used for both digital input and output operations.
3. Voltage Range for Analog Inputs: If you're dealing with analog sensors, the ESP8266 has you covered with a voltage range of 0-1.0V for its single analog input pin, making it suitable for a variety of analog sensors.
4. Maximum Current Output: The ESP8266 pins can source or sink up to 12mA individually and up to 72mA in total, so it's important to plan your connections accordingly to avoid overloading.
5. Max Bitrate: When it comes to data transfer, the ESP8266 boasts an impressive maximum bitrate of up to 2 Mbps, ensuring speedy data exchange with other devices in your IoT ecosystem.

⚙️ ESP8266 Pinout Overview

The ESP8266 features 32 pins, but not all are usable for general I/O. Here’s a breakdown:

Communication Interfaces

• UART: GPIO1 (TX), GPIO3 (RX)
• SPI: GPIO12 (MISO), GPIO13 (MOSI), GPIO14 (SCLK), GPIO15 (CS)
• I2C (software): GPIO5 (SCL), GPIO4 (SDA)

What are the Power Pins of ESP8266?

You can power ESP8266 directly via the USB connector (standard USB = 5V) or the Vin pin (5V to 10V). The regulator provides a maximum of 500mA.

These are the power pins of this microcontroller board:

GPIO Number Doesn’t Match the Label on the Board Silkscreen?

It's essential to realize that the GPIO labeling on the ESP8266 does not correspond directly to the silkscreen markings on the board. For instance, the pin marked as D0 is actually GPIO16, while the one labeled D1 is in fact GPIO5.

The table below outlines the relationship between the silkscreen labels on the board and the actual GPIO numbers, detailing the most suitable pins for your projects and highlighting those that require careful handling.

Which GPIOs connected to the Flash Chip?

GPIO6 to GPIO11 are usually connected to the flash chip in ESP8266 boards. So, these pins are not recommended to use.

Which Pins are Used During Boot?

The ESP8266 can be prevented from booting if some pins are pulled LOW or HIGH. The following list shows the state of the following pins during BOOT:

Which GPIOs are the safest to use to operate coil relays?

• GPIO4
• GPIO5

{{insert-project-1-here}}

How Many Analog Inputs Does the ESP8266 Have?

ESP8266 only has one analog input, it's the ADC0 pin, usually labelled as A0 on the board.  If you're using the bare ESP8266 chip, the maximum input voltage range of this ADC0 is 0 to 1V, for development board like NodeMCU ESP8266 12-E, the voltage input range is 0 to 3.3V due to presence of internal voltage divider.

This ADC pin has a 10-bit resolution, which means you’ll get values between 0 and 1023.

Which GPIOs Can I Use for the I2C Interface?

Unlike other microcontrollers, the ESP8266 lacks dedicated hardware for I2C; however, I2C functionality can be implemented in software, allowing any GPIOs to be used for I2C purposes. Commonly, the following GPIOs are used as I2C pins:

• GPIO5: SCL
• GPIO4: SDA

#include <Wire.h>

// Initialize software I2C on ESP8266 using different pins
void setup() {
  Wire.begin(D2, D1); // D2 as SDA, D1 as SCL
}

void loop() {
  Wire.beginTransmission(0x3C); // Start I2C Transmission
  // ... send data or commands to an I2C device
  Wire.endTransmission(); // Stop I2C transmission
  delay(1000); // Wait for a second
}

ESP8266 SPI (Serial Peripheral Interface) Pins

The pins used as SPI in the ESP8266 are:

• GPIO14: SCLK
• GPIO15: CS
• ‍GPIO12: MISO‍
• GPIO13: MOSI

Can I Use Any GPIO as Interrupt Pins?

The ESP8266 supports interrupts in any GPIO, except GPIO16.

Harnessing the Versatility of GPIO Pins in a Practical IoT Project

The GPIO pins on the esp8266 are the backbone of its versatility, allowing you to connect various components to create a wide array of IoT applications. To illustrate their practical utility, let's consider a simple project: building a weather monitoring station.

1. GPIO0 - Connecting a Rain Sensor (digital input): By configuring the GPIO0 pin as a digital input, the microcontroller can detect when it's raining and log data accordingly. This information can be sent to a remote server, enabling users to access real-time rainfall data from their IoT device.
2. GPIO4 & GPIO5 - OLED Display (I2C communication): Esp8266 can be used to establish I2C (Inter-Integrated Circuit) communication for an OLED display. GPIO4 would be used as the SDA (data), while GPIO would be used as the SCL (clock). This display can provide users with real-time weather information in a user-friendly format.
3. GPIO1 - Connecting an Anemometer (digital input): By configuring the GPIO1 pin as a digital input, the esp8266 can record wind speed data.
4. ADC0 - Interfacing with a Light Sensor (analog input): A0 can be configured as an analog input for interfacing with a light sensor to provide ambient light conditions. It can then, for example, it can be used to trigger the OLED display's backlight when it gets dark.

And with the many additional pinouts, our weather monitoring station can always be improved--add a temperature sensor to GPIO2, or a humidity sensor to GPIO3!

{{insert-project-2-here}}

Compatibility with Arduino IDE

The esp8266 pinout is also perfect for developers who are already comfortable with the Arduino IDE, as they seamlessly integrate, making the esp8266 widely accessible.

Using the Arduino IDE with the esp8266 offers several benefits:

1. Familiar Environment: If you're already accustomed to the Arduino IDE, transitioning to the esp8266 becomes a breeze. You can leverage your existing knowledge and libraries to accelerate your IoT projects.
2. Large Community Support: The Arduino community is vast, and you can tap into a wealth of resources, tutorials, and forums to get help when needed.
3. Extensive Library Support: Arduino IDE compatibility means access to a vast library of pre-written code, which can significantly reduce development time.
4. Cross-Platform Compatibility: Develop on one platform and easily migrate your code to different boards, such as the esp32, without significant modifications.

Wemos D1 Mini - A Popular Esp8266 Development Board

When it comes to practical application, the Wemos D1 Mini, built around the esp8266, is a favorite among developers. Its compact size, affordability, and extensive support from the maker community have made it a go-to choice for IoT projects.

Here are some reasons why the Wemos D1 Mini is an excellent choice:

1. Compact Form Factor: The small size of the Wemos D1 Mini makes it ideal for projects with limited space requirements.
2. Easy to Use: The board comes with built-in USB-to-serial conversion, eliminating the need for external programmers.
3. Abundant Shields and Accessories: The Wemos ecosystem offers a wide range of shields and accessories, making it easy to expand your project's capabilities.
4. Built-in Wi-Fi: Just like the esp8266, the Wemos D1 Mini has built-in Wi-Fi support, making it an ideal choice for connected IoT applications.

In the evolving landscape of IoT, the esp8266 pinout is highly versatile. Its GPIO pins, compatibility with Arduino IDE, I2C capabilities, and integration into popular development boards like the Wemos D1 Mini provide a robust foundation for your IoT projects. However, if you're looking for something more, then check out its sibling, the esp32. The esp32 retains the flexibility of the esp8266 pinout while offering more processing power, built-in Bluetooth, and dual-core processing. This opens up new opportunities for more complex and feature-rich IoT applications.

Does ESP32 have digital pins?

Yes, the ESP32 has digital pins, also known as General Purpose Input/Output (GPIO) pins. These pins are used for digital input and output and can be configured as either inputs or outputs depending on the needs of the project. The ESP32 has a total of 36 GPIO pins that can be used for various purposes, including interfacing with sensors, controlling LEDs, and communicating with other devices.

ESP32 Pinout

• 18 Analog-to-Digital Converter (ADC) channels
• 3 SPI interfaces
• 3 UART interfaces
• 2 I2C interfaces
• 16 PWM output channels
• 2 Digital-to-Analog Converters (DAC)
• 2 I2S interfaces
• 10 Capacitive sensing GPIOs

NOTE: not all GPIOs are accessible in all development boards, but each specific GPIO works in the same way regardless of the development board you’re using. For ESP32 DEVKIT V1 board, GPIO6 to GPIO11 are connected to the integrated SPI flash and are not recommended for other uses.

Is ESP32 3.3 or 5V?

The ESP32 is a 3.3V device, which means that all of its input and output pins are designed to operate with a maximum voltage of 3.3 volts. Connecting the ESP32 to a voltage source greater than 3.3 volts can damage the device, so it's important to use level shifters or voltage dividers when interfacing with higher voltage devices.

It's also important to note that the power supply for the ESP32 should be 3.3V DC. Some development boards or modules may have built-in voltage regulators that can accept a higher input voltage (such as 5V) and regulate it down to 3.3V for the ESP32, but it's always best to check the specifications of the specific device you are using to ensure proper voltage supply.

What are GPIO in ESP32?

Input Only GPIO Pins

• GPIO 34
• GPIO 35
• GPIO 36
• GPIO 39

These pins don’t have internal pull-up or pull-down resistors. They can’t be used as outputs, so use these pins only as inputs:

ESP32 GPIO pins with internal pull (INPUT_PULLUP)

• GPIO14
• GPIO16
• GPIO17
• GPIO18
• GPIO19
• GPIO21
• GPIO22
• GPIO23

ESP32 GPIO pins WITHOUT internal pull

• GPIO13
• GPIO25
• GPIO26
• GPIO27
• GPIO32
• GPIO33

To utilize these pins in Arduino IDE,  and you want to make GPIO 22 as input and GPIO 23 as output:

pinMode(22,INPUT_PULLUP);
pinMode(23,OUTPUT);
digitalWrite(23,HIGH);

{{insert-project-1-here}}

What is pinMode()?

pinMode() configures the specified pin to behave either as an input (with or without an internal weak pull-up or pull-down resistor), or an output. It is possible to enable the internal pullup resistors with the mode INPUT_PULLUP. Additionally, the INPUT mode explicitly disables the internal pullups.

ESP32 Serial

There are three serial ports on the ESP32 known as U0UXD, U1UXD and U2UXD all work at 3.3V TTL Level. There are three hardware supported serial interfaces on the ESP32 known as UART0, UART1 and UART2. Like all peripherals, the pins for the UARTs can be logically mapped to any of the available pins on the ESP32. However, the UARTs can also have direct access which marginally improves performance. The pin mapping table for this hardware assistance is as follows.

ESP32 Strapping Pins

Strapping pins are used to put the ESP32 into bootloader or flashing mode. On most development boards with built-in USB to SERIAL, you don't need to worry about the state of these pins. The board itself puts the pins in the right state prior to flashing or when on boot mode.

Why some ESP32 pins are default HIGH during Boot?

Some GPIOs change their state to HIGH or output PWM signals at boot or reset. This means that if you have outputs connected to these GPIOs you may get unexpected results when the ESP32 resets or boots.

• GPIO 1
• GPIO 3
• GPIO 5
• GPIO 6 to GPIO 11 (connected to the ESP32 integrated SPI flash memory – not recommended to use).
• GPIO 14
• GPIO 15

NOTE: If you have peripherals connected to these pins, you may encounter issues with trying to upload new code, flashing the ESP32 with new firmware, or resetting the board, it may be because those peripherals are preventing the ESP32 from entering the right mode.

{{insert-nico-video}}

How many I2C pins ESP32 has?

The ESP32 has two I2C channels and any pin can be set as SDA or SCL. When using the ESP32 with the Arduino IDE, the default I2C pins are:

• GPIO 21 (SDA)
• GPIO 22 (SCL)

You can use the wire library to use other pins for I2C, you just need to call:

Wire.begin(SDA, SCL);

What are the SPI pins of ESP32?

These are the default pin mapping for SPI

GPIO 6 to GPIO 11 are exposed in some ESP32 development boards. However, these pins are connected to the integrated SPI flash on the ESP-WROOM-32 chip and are not recommended for other uses. So, don’t use these pins in your projects:

• GPIO 6 (SCK/CLK)
• GPIO 7 (SDO/SD0)
• GPIO 8 (SDI/SD1)
• GPIO 9 (SHD/SD2)
• GPIO 10 (SWP/SD3)
• GPIO 11 (CSC/CMD)

{{insert-project-2-here}}

Does ESP32 have Interrupts Pins?

Goodnews. All ESP32 GPIO pins are interrupt-capable (interrupts) pins. You can enable the interrupt functionality to any GPIO input pin using this function from the Arduino Core.

attachInterrupt(GPIO_pin, ISR, Event);

What is Enable pin (EN) on ESP32?

Enable (EN) is the 3.3V regulator’s enable pin. It’s pulled up, so connect to ground to disable the 3.3V regulator. This means that you can use this pin connected to a pushbutton to restart your ESP32, for example.

ESP32 Analog to Digital Converter ADC Input Pins

The ESP32 has built-in Analog to Digital Converters (ADC) that allow it to convert analog signals into digital values that can be processed by the digital circuits on the chip. The ESP32 has a total of 18 ADC channels, which can be used to read analog signals from various sensors, such as temperature sensors, light sensors, and other types of sensors that output analog signals.

The ESP32's ADC has a resolution of 12 bits, which means that it can measure the analog signal and convert it into a digital value between 0 and 4095. The ADC can also be configured to sample the analog signal at different rates and can be programmed to read multiple channels simultaneously.

The ESP32 has 18 x 12 bits ADC input channels (while the ESP8266 only has 1x 10 bits ADC). These are the GPIOs that can be used as ADC and respective channels: 

• ADC1_CH0 (GPIO 36)
• ADC1_CH1 (GPIO 37)
• ADC1_CH2 (GPIO 38)
• ADC1_CH3 (GPIO 39)
• ADC1_CH4 (GPIO 32)
• ADC1_CH5 (GPIO 33)
• ADC1_CH6 (GPIO 34)
• ADC1_CH7 (GPIO 35)
• ADC2_CH0 (GPIO 4)
• ADC2_CH1 (GPIO 0)
• ADC2_CH2 (GPIO 2)
• ADC2_CH3 (GPIO 15)
• ADC2_CH4 (GPIO 13)
• ADC2_CH5 (GPIO 12)
• ADC2_CH6 (GPIO 14)
• ADC2_CH7 (GPIO 27)
• ADC2_CH8 (GPIO 25)
• ADC2_CH9 (GPIO 26)

ESP32 Digital to Analog Converter DAC Input pins

There are 2 x 8 bits DAC channels on the ESP32 to convert digital signals into analog voltage signal outputs. These are the DAC channels:

• DAC1 (GPIO25)
• DAC2 (GPIO26)

ESP32 Capacitive Touch Sensor Sensitive GPIOs

The ESP32 has 10 capacitive touch GPIOs. These GPIOs can sense variations in anything that holds an electrical charge, like the human skin. So they can detect variations induced when touching the GPIOs with a finger.

These pins can be easily integrated into capacitive pads, and replace mechanical buttons. Additionally, the touch pins can also be used as a wake up source when the ESP32 is in deep sleep.

• T0 (GPIO 4)
• T1 (GPIO 0)
• T2 (GPIO 2)
• T3 (GPIO 15)
• T4 (GPIO 13)
• T5 (GPIO 12)
• T6 (GPIO 14)
• T7 (GPIO 27)
• T8 (GPIO 33)
• T9 (GPIO 32)

To use the ESP32 touch sensor in Arduino:

Reading the touch sensor is straightforward. You use the touchRead() function, that accepts as argument, the GPIO you want to read.

touchRead(GPIO);

This example arduino sketch reads the touch pin 0 and displays the results in the Serial Monitor.

// ESP32 Touch Test
// Just test touch pin - Touch0 is T0 which is on GPIO 4
void setup() {  
Serial.begin(115200);
// give me time to bring up serial monitor  
delay(1000); 
Serial.println("ESP32 Touch Test");
}

void loop() {  
// get value of Touch 0 pin = GPIO 4
Serial.println(touchRead(4));  
delay(1000);
}

{{insert-project-3-here}}

ESP32 RTC GPIOs

There is RTC GPIO support on the ESP32. The GPIOs routed to the RTC low-power subsystem can be used when the ESP32 is in deep sleep. These RTC GPIOs can be used to wake up the ESP32 from deep sleep when the Ultra Low Power (ULP) co-processor is running. The following GPIOs can be used as an external wake up source.

• RTC_GPIO0 (GPIO36)
• RTC_GPIO3 (GPIO39)
• RTC_GPIO4 (GPIO34)
• RTC_GPIO5 (GPIO35)
• RTC_GPIO6 (GPIO25)
• RTC_GPIO7 (GPIO26)
• RTC_GPIO8 (GPIO33)
• RTC_GPIO9 (GPIO32)
• RTC_GPIO10 (GPIO4)
• RTC_GPIO11 (GPIO0)
• RTC_GPIO12 (GPIO2)
• RTC_GPIO13 (GPIO15)
• RTC_GPIO14 (GPIO13)
• RTC_GPIO15 (GPIO12)
• RTC_GPIO16 (GPIO14)
• RTC_GPIO17 (GPIO27)

ESP32 PWM pins

The ESP32 pulse width modulation PWM controller has 16 independent channels that can configured to generate PWM signals with different configuration and properties that can be used for controlling the intensity of digital signals, such as LEDs and Motors. PWM is a technique that allows the duty cycle of a digital signal to be varied, which in turn changes the average voltage and current delivered to the load.

The PWM frequency can be set using the ledcSetup() and ledcAttachPin() functions, which allow you to configure the PWM frequency and attach the PWM pin to a specific output.

ledcSetup();
ledcAttachPin();

In addition to the 16 hardware PWM pins, the ESP32 also supports software-based PWM, which can be used to control additional PWM channels on any GPIO pin. The ESP32's software PWM uses a technique called bit-banging, which allows the duty cycle of a digital signal to be varied by software.

‍
Check out ESP32 Datasheet

This article highlights 10 of the most popular microcontrollers, based on their usage in embedded systems, memory architecture, and the community support they enjoy. Let’s dive in!

1. STM32F103C8T6

The STM32F103C8T6 is a versatile microcontroller with a 32-bit ARM Cortex-M3 core running at 72 MHz. It offers flash memory, non-volatile memory, and multiple peripherals like SPI, I²C, and CAN. Its performance makes it ideal for general-purpose embedded systems.

Key Features:

• CPU: ARM Cortex-M3 microprocessor, 72 MHz
• Memory: 128 KB flash memory, 20 KB SRAM
• Peripherals: SPI, I²C, CAN, USB, USART, ADC
• Timers: 7, including PWM support

Development Board:

2. ATmega328

The ATmega328P, a popular Atmel microcontroller, powers many Arduino boards like the Uno. It offers easy programming through the Arduino IDE and features EEPROM for non-volatile memory storage. This microcontroller is great for beginners and general-purpose applications.

Key Features:

• Architecture: 8-bit AVR microprocessor
• Clock Speed: 20 MHz
• Memory: 32 KB flash memory, 2 KB SRAM, 1 KB EEPROM
• Peripherals: UART, SPI, I²C, ADC

Development Boards:

• Arduino Uno, Nano, Pro Mini

3. PIC16F877A

The PIC16F877A is a Microchip microcontroller widely used for educational purposes. Its support for non-volatile memory and easy-to-use peripherals makes it an excellent choice for beginners.

Key Features:

• Memory: 14 KB flash memory, 368 bytes RAM, 256 bytes EEPROM
• Peripherals: UART, SPI, I²C, ADC
• Timers: 3, including timer counter
• Oscillator: External up to 20 MHz

Development Board:

• PIC Development Board

4. ATtiny85

The ATtiny85, another compact Atmel microcontroller, is ideal for small embedded systems. It supports SPI, I²C, and offers EEPROM for non-volatile memory.

Key Features:

• CPU: 8-bit AVR, 20 MHz
• Memory: 8 KB flash memory, 512 bytes SRAM, 512 bytes EEPROM
• Peripherals: SPI, I²C, ADC

Attiny85 ready-to-use module:

Development Boards:

• Digispark ATtiny85

5. MSP430G2452

The MSP430G2452 from Texas Instruments is known for low power operation, making it ideal for battery-powered embedded systems. It features essential peripherals and non-volatile memory.

Key Features:

• CPU: 16-bit RISC microprocessor
• Memory: 8 KB flash memory, 256 bytes SRAM
• Peripherals: SPI, I²C, ADC

Development Board:

• MSP-EXP430G2 LaunchPad

6. ESP8266

The ESP8266, a Microchip microcontroller, offers Wi-Fi connectivity and supports UART and SPI peripherals. It’s ideal for IoT projects and wireless applications.

Key Features:

• CPU: 32-bit RISC microprocessor, 80 MHz
• Memory: 80 KB RAM, 16 KB instruction RAM
• Peripherals: Wi-Fi, UART, SPI

Development Boards:

• NodeMCU, Wemos D1 Mini

7. ESP32

The ESP32 builds on the ESP8266 by adding dual-core processing and Bluetooth support. It is a powerful microcontroller for advanced embedded systems and general-purpose applications.

Key Features:

• CPU: Xtensa LX6 dual-core microprocessor, 240 MHz
• Memory: 520 KB SRAM
• Peripherals: Wi-Fi, Bluetooth, SPI, I²C, ADC

Explore ESP32 Featured Projects

Curious about what you can build with the powerful ESP32 microcontroller? From smart home devices to IoT-based monitoring systems, the possibilities are endless! Check out some incredible ESP32 featured projects created by the Flux community, and get inspired to build your own.

Development Boards:

• ESP32-DevKitC, HUZZAH32

8. ATmega32U4

The ATmega32U4, another Atmel microcontroller, supports USB connectivity. It’s commonly used in custom keyboards and other embedded systems requiring serial communication.

Key Features:

• CPU: 8-bit AVR microprocessor, 16 MHz
• Memory: 32 KB flash memory, 2.5 KB SRAM
• Peripherals: USB, UART, SPI, ADC

Development Boards:

• Arduino Leonardo, Teensy 2.0

9. STM8S103F3

The STM8S103F3 is a reliable 8-bit microcontroller for industrial automation. It offers robust peripherals for control systems.

Key Features:

• Memory: 8 KB flash memory, 1 KB RAM
• Peripherals: SPI, I²C, UART, ADC

Development Boards:

• STM8S103F3 P6 Board

10. NXP LPC1768

The LPC1768 is a high-performance microcontroller with advanced connectivity peripherals like Ethernet and USB. It is suitable for demanding embedded systems.

Key Features:

• CPU: ARM Cortex-M3 microprocessor, 100 MHz
• Memory: 512 KB flash memory, 64 KB SRAM
• Peripherals: Ethernet, USB, CAN

Development Boards:

• Mbed LPC1768, LPCXpresso Board

Choose the Right Microcontroller for Your Project

Every microcontroller listed here offers unique features for embedded systems. If you need low power operation, like the MSP430, or the wireless capability of the ESP32, there is a suitable MCU for every project. Choose wisely based on your project’s needs.

FAQs: Frequently Asked Questions

1. What is the meaning of MCUs?

MCUs (Microcontrollers) are compact integrated circuits that control specific functions in electronic devices. They contain a processor, memory, and input/output peripherals on a single chip, making them ideal for embedded systems, such as IoT devices, robots, and consumer electronics.

2. Which microcontroller is best for beginners?

The ATmega328 (Arduino Uno) is ideal due to its simplicity and community support.

3. What’s the difference between ESP8266 and ESP32?

The ESP32 offers dual-core processing, Bluetooth, and more advanced security features.

4. Which MCU is best for low power?

The MSP430 series is renowned for its ultra-low power consumption.

Design Smarter, Not Harder – Build Your PCB with Flux

Whether you’re experimenting with an ATmega328 for your first Arduino project or building a cutting-edge ESP32-based IoT device, designing a custom PCB will take your project to the next level. Flux makes it easy with an intuitive interface, smart design tools, and access to a huge component library. No matter your experience level, Flux helps you create PCBs quickly and efficiently, without the usual headaches.

Get started today—sign up for Flux and bring your ideas to life!