Flux Blog

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!

Streamlining the CAD Librarian Workflow with Flux

This post provides a detailed overview of how CAD Librarians can leverage Flux’s key capabilities—AI Part Imports, Component Updates, Live Pricing, and JEP30 Export—each tailored to meet the specific demands of maintaining PCB libraries. For more in-depth guidance, links to relevant sections of our documentation are provided.

AI Part Import: Automate Data Extraction and Mapping

Traditionally, librarians must manually extract and input data from component datasheets, which is not only labor-intensive but also prone to human error. Flux automates this process with its AI-driven part import feature, allowing you to parse datasheets directly into your library.

• Automated Pin Mapping: Our AI engine scans the datasheet, identifies pin functions, and generates the necessary mapping. This eliminates the need for manual entry and dramatically reduces the risk of misconfigurations.
• Data Enrichment: Beyond simple pin mapping, Flux enriches the part data by automatically extracting additional metadata, such as temperature ratings, voltage tolerances, package information, and compliance standards. This enriched data is readily available to engineers, improving design accuracy and efficiency.
• Consistency: The AI ensures uniformity across the library, which is critical when working with high-density or complex components.

Learn how to do AI part imports in Flux.

Component Updates: Centralized Control for Library Management

Component lifecycle management is a major responsibility for CAD Librarians, as maintaining up-to-date libraries ensures that engineers are always working with the latest verified parts. With Flux, component updates are automatically managed, reducing manual effort and ensuring consistency across designs.

• Real-Time Notifications: Whenever a component in the library is updated, Flux sends real-time notifications to all projects using that part. This minimizes the risk of outdated or obsolete components creeping into active designs.
• Version Control: Each update is tracked with version control, enabling you to review changes, revert if necessary, or compare part versions. This ensures full traceability of modifications across all projects.
• Minimized Risk of Obsolescence: Updates include supplier-specific information, such as end-of-life notifications, enabling proactive management of critical components before they become unavailable.

For detailed technical information, please refer to our documentation on component updates.

Live Pricing Integration: Real-Time Data from Suppliers

Component procurement is not just about ensuring technical compatibility—it’s also about balancing cost and availability. Flux integrates directly with supplier databases to provide live pricing and stock levels, which are visible directly within the part data.

• Dynamic Pricing: Flux continuously fetches and updates pricing from a range of suppliers, ensuring that design teams are always working with the most up-to-date cost information.
• Availability Tracking: In the event that a part becomes unavailable or reaches end-of-life, Flux notifies you immediately, allowing for quick reassessment of alternatives without delaying the design process.
• Vendor Transparency: This feature gives engineers and librarians full visibility into vendor options, delivery timelines, and bulk pricing, empowering them to make data-driven decisions when selecting components.

Learn how Live Pricing works in more detail.

JEP30 Export: Ensuring Cross-Tool Compatibility

Flux's support for JEP30 export allows you to seamlessly integrate part data across multiple tools. The JEP30 format is widely accepted and enables you to transfer parts between different CAD platforms without losing data integrity.

• Format Consistency: When exporting parts, the JEP30 standard ensures that all metadata, pin mappings, and other configurations are preserved across different EDA tools, reducing the need for manual re-entry and preventing data loss.
• Interoperability: Whether you’re working within a multi-tool environment or collaborating with external teams using different CAD software, JEP30 export guarantees that your parts remain accessible and accurate, regardless of the platform.
• Time Savings: By leveraging this export capability, you can minimize repetitive manual tasks associated with re-entering part data into different tools, ultimately saving both time and reducing errors.

Here's a detailed guide on how to use the JEP30 Export feature.

The Flux Advantage for CAD Librarians

Flux offers a robust set of tools designed specifically to enhance your workflow as a CAD Librarian. By automating tasks like datasheet parsing and part updates, providing real-time supplier data, and ensuring compatibility across multiple platforms, Flux helps you streamline library management while reducing errors and ensuring design integrity.

For a more comprehensive look at Flux’s features, including how to integrate them into your workflow, check out our full documentation.

“Without Flux, it would have taken me months to master another tool. Flux made it possible to design my first board in just a few days, even while I was working a 9-to-5.”
‍– Michael van Niekerk, Co-Founder and Head of Technology, Agri-iO 

About Agri-iO 

‍Agri-iO is an agriculture-focused automation company that augments people's existing farming solutions with connected hardware and software. They aim to solve the problems faced by farmers who have unreliable GSM signals by automating pumps and monitoring water levels in remote areas. With Agri-iO’s solutions, anything on a farm can be automated and driven from one application, even when there's no Wi-Fi or LTE. 

Agri-iO’s Problem

Agri-iO’s Co-Founder and Head of Technology, Michael van Niekerk, has a technical background, but at the onset of the company, he had never designed a PCB. So, when it came time for the team to develop their first product, off-the-shelf (OTS) electronics were the obvious solution.

Agri-iO designed its original products using Pycom’s LoPy devices. These products included automating existing irrigation pivots, tank and dam control, and pump automation. These devices were selected because of their MicroPython-enabled ESP32 chipset and support for LoRa, Wi-Fi, and BLE connectivity. With electronics in hand, Agri-iO wrote its MicroPython code, and the team was off to the races. 

It wasn’t long before they started securing large contracts.

However, right before kicking off an important new project, Agri-iO discovered that Pycom was going out of business, and that meant their products were discontinued. Suddenly, Agri-iO was left without a hardware solution and a contract to fulfill.

“We were originally using Pycom's LoPy devices. But the company went bankrupt just before we got a big contract with Zambeef in Zambia, and we found ourselves left without a supply.”
‍– Michael van Niekerk, Co-Founder and Head of Technology, Agri-iO

A Path Forward Wasn’t Obvious

At first, Agri-iO’s approach was to find a replacement OTS solution, but they quickly found that the right solution was hard to come by. Most OTS products they encountered supported C++, not MicroPython, and porting the original code proved to be too timely and costly.

So that left them with one option: designing custom hardware. But this wasn’t as straightforward as it sounded.

For starters, Agri-iO had a two-man technical team. Neither Michael nor Stephan Geldenhuys (another co-founder) had ever designed a PCB before. With no support or experience, the team began exploring design tools to pursue their own custom hardware.

However, they found that the design tools on the market were far from perfect. Some tools proved too expensive for a small startup like Agri-iO to afford. Other free tools proved too cumbersome and difficult to learn in a reasonable time, and they were up against a serious time crunch.

“I considered KiCad and Altium Designer, but Altium was too expensive. KiCad was not easy to use, and we didn’t have time to get past that learning curve. Flux was a few steps ahead in terms of ease of use, so we went with Flux.” – Michael van Niekerk, Co-Founder and Head of Technology, Agri-iO 

The Flux Solution

In their research, Agri-iO came across Flux - and it quickly caught their eye. 

Flux’s free-to-use nature was the first big draw. The company had limited resources, and a thousand-dollar EDA license was not an option. What proved more important, however, was Flux’s ease of use. Not only was Flux browser-based and compatible with any computing platform, but its extensive library of resources made it possible for the team to hit the ground running.

Shortly after finding Flux, the Agri-iO team came across Flux’s design tutorial and project built around Raspberry Pi’s RP2040. Features and Rust support made the RP2040 the perfect microcontroller for Agri-iO’s needs. So, the team simply forked the Flux example project, and they instantly had a major jump start on their custom design.

From there, the team leveraged Copilot’s guidance to fill in the blanks. Copilot helped them by providing example designs, suggesting components and configurations, and answering questions about which pins connected where.

In only a couple of days, Agri-iO went from a blank slate and no experience to a manufacturable custom hardware solution. 

“I used Copilot to ask questions about which pins to connect and to get examples for specific designs. It suggested components and configurations. Copilot reduced the amount of review work needed, and overall, it was a wonderful experience.”
– Michael van Niekerk, Co-Founder and Head of Technology, Agri-iO

Results

Thanks to Flux, Agri-iO successfully fulfilled its existing contracts and has since deployed dozens of units globally. At the beginning of their journey, the Agri-iO team had never designed a single PCB. Today, they’ve designed four custom boards, each of which is deployed in the field and has a major impact on the agricultural industry.  

“Nothing was more satisfying than seeing our system working in the field, and we really have Flux to thank for it all. Now I can’t wait for our next batch of boards to arrive and to start shipping them out.” 
‍– Michael van Niekerk, Co-Founder and Head of Technology, Agri-iO 

Craftsmanship Matters

Steve Jobs once said “...there's just a tremendous amount of craftsmanship in between a great idea and a great product.” We agree wholeheartedly.

However, as PCB designers, it’s not always easy to demonstrate the thought and craftsmanship that went into your design. Other EEs might be able to appreciate your effort and understand the inner beauty of your work, but first, they’d need access to your design files and a compatible tool. Non-EEs may not understand the beautiful intricacies of your design, but they can appreciate a good layout and an aesthetically pleasant board.

In either case, we want to help you better demonstrate your craftsmanship. With automatic, realistic 3D renderings of your PCB, Flux is making this a reality.

Taking Pride in Your Work

Flux's new rendering capabilities automatically create the most realistic and beautiful representation of your design possible. No extra effort is needed to master rendering tools, and no experience is necessary. Now, anyone can effortlessly create stunning, dynamic, and professional 3D renders. And since Flux is browser-based and free to use, anyone can access your renders in real-time with just a link.

But why does this reality matter?

• Building an Impressive Portfolio: Whether you’re a student or a professional, a design portfolio is the best way to demonstrate your skills. And, where a design portfolio is all about putting your best foot forward, you need high-quality renderings that capture the beauty of your design.
• Present Your Work to Stakeholders: With just a link, stakeholders can access and view renders of your design directly in their browser. This helps you better convey your design, its unique points, and its value. And since Flux renders are dynamic, viewers can get a real, intuitive understanding of how your design works within a larger system.
• Enhancing Documentation: Realistic, high-quality visuals significantly enhance your team's documentation efforts. There will be no more dissonance between real-life boards and design files. Instead, realistic renders are used as part of the documentation process to align everyone and capture those real-world details.
• Save time: You don't need to spend hours mastering and jumping from tool to tool, with just one click you can share your work.

See how your projects look

We understand that craftsmanship matters, detail counts, and extend that thinking to how you present your work. Login to your account to see how your projects look with the new rendering engine. 🚀

With Flux, this dream is a reality. With Flux Copilot, you can leverage the power of AI to help you test and debug your circuit designs. Here are your steps and how AI can make this process easier.

Functional Testing and Challenges

Functional testing is the process of testing a mass-produced product to ensure that the high-level system functionality meets the design expectations. The goal is to ensure quality, but that’s not always straightforward.

As a functional testing team member, you’re often asked to develop test plans for products you have not designed and, therefore, have no experience with. Generally, you’re handed a set of design files and a product requirement document. Your task is to take that information and develop a thorough test plan to ensure the product meets all its requirements off the production line.  

Generally, the hardest part is becoming familiar enough with the product to develop a comprehensive test plan. Historically, that means dozens of hours spent poring over schematics and layout files. But now, with AI, Flux is changing that narrative entirely.

Generate Thorough Functional Test Plans With AI

With Flux Copilot, generating thorough functional test plans is a breeze. Here is what the process looks like

Step 1: Import Your Design

The process starts by importing your design files and product requirements document into Flux.  Flux is compatible with design files from all of the major EDA tools, including Altium, Cadence, and KiCAD, so you can use Flux without having to change your tools.

Or, if your design is already native to Flux, simply input your product requirements document to get started.

Step 2:  Develop a Plan

Next, you should ask Copilot to help you determine what tests need to be run to ensure proper functionality.

Some of the most important questions to address in a test plan include

• Under what conditions should I perform the test?
• What procedure should I follow during my test?
• What results should I expect?

Copilot helps your team answer all of these questions by developing comprehensive and robust test plans for your design. Simply prompt Copilot with a question like

@copilot Create a comprehensive hardware design test plan for this project for the areas outlined in the testing and validation section. The goal is to ensure all components and circuits function correctly and reliably under specified conditions. Follow the steps:
- Provide a brief summary of the design, including the main functions and critical components of the schematic.
- Detail the requirement of that particular area for the design to work.
- Outline and explain the specific tests needed (with exact tools required where applicable) to verify performance of the hardware design. including test condition and expected behavior.

Step 3: Analyze Design and Test Points

Once you have a test plan, want to ask Copilot to confirm that the current design is accordingly testable. That means ensuring all necessary signals have test points that can be probed in your testing efforts. You can ask Copilot something like

@copilot, clearly list if the right test points are present to fulfill this test plan.

Step 4: Collaborative Debugging

Flux not only streamlines the testing and debugging process but also enhances the way test engineers and designers collaborate on projects.

In the event that the correct test points are not available, you can then use Flux’s collaboration tools. Simply leave a comment in the project file notifying the design owner of what signals need test points. With this kind of in-tool collaboration, everyone on the team can see the correspondence and the Copilot responses that elicited the design update.

By integrating collaboration within the design tool, Flux ensures that all team members have real-time access to test data, design changes, and analytical insights. This seamless integration allows for immediate feedback loops and faster decision-making, which is crucial when addressing complex design challenges

Step 5: Needed Equipment

The final roadblock to fulfilling a testing plan is having the necessary equipment to carry it out. Testing plans often need accompanying testing rigs, which likely necessitate custom PCBs dedicated to these efforts.

Copilot can help by identifying what testing equipment might be necessary and then providing advice on designing that testing rig. Ask Copilot something like

@copilot, what other testing equipment is necessary to carry out this test plan?

If a custom PCB is required, Copilot can help with the process. Check out this design tutorial to learn more about creating custom PCBs with Copilot.

Saving Time and Money

With Flux Copilot, your team can more easily develop comprehensive and thorough test plans that help catch design errors early in the process. This means your team can spend less time correcting errors and less money on unnecessary design revisions. Ultimately, that translates to higher quality products and faster time to market. Want to experience using AI to generate functional test plans? Sign up for Flux today.