PCB Hotplate V3

Greetings everyone,

So here's "PCB Hotplate V3" which is the third version of my previously made PCB Hotplate project.

This project outperforms two previous hotplates in both electrical and mechanical aspects. It has two separate boards—the coil board and the driver board—that are joined together by 40mm-long PCB standoffs.

This project is powered by an XIAO ESP32 C3 MCU, which in turn controls an NPN BJT, which in turn controls an IRFZ44N Mosfet, which drives the coil.

About the project's heating element, the coil board, which has tracks arranged in an octagon arrangement on both its top and bottom sides, each coil has its own resistance, and when a specific voltage is applied, it heats up, making a DIY element constructed on the FR4 PCB.

The utilization of two separate boards is one of the project's best features. As the TG rating of FR4 is below 140 °C and we are heating the board above that temperature, the hotplate coils generally degrade and then become damaged after 10–15 cycles. Fortunately, replacing the damaged coil with a new one is simple and doesn't require making major changes to the driver board.

Let's explore the project's construction process.

Material Required

Following were the materials used in this build-

• Custom PCB- Provided by Seeed Studio (Both Boards)
• XIAO ESP32 C3 MCU
• AMS1117 5V
• 10uF 1206 CAP
• 1uF 1206 CAP
• 1K Ohms 1206 Resistor
• 10K Ohms 0805 Resistor
• RED LEDs 0603
• BLUE LED 0805
• DC Barrel Jack Horizontal
• 40mm Length M3 PCB Standoffs
• IRFZ44N Mosfet
• BC547 Transistor SOT23-3
• 12V 4A Power Source
• Multimeter with TEMP Probe

Previous Versions

Two versions of this PCB hotplate have previously been made. The first was the PCB Hotplate Mini edition, which had a compact form factor and was created specifically for soldering small PCBs. It featured two parts: the coil part, which comprised a 50mm by 50mm area, and the driver section, which was made up of an Attiny13A connected to an AO4406 Mosfet IC that powers the coil using voltage from a DC jack.

The idea was straightforward, and it worked for a while, but eventually I needed a much larger hotplate for reflowing larger boards, so I prepared Version 2, which was a slightly larger version with a larger coil section and a different microcontroller.

In Version 2, XIAO M0 was used, along with an OLED display for temperature display and a brand-new Buck converter for stepping down 12V to 5VC so that XIAO could function.

Version 3 was built with a separate coil section PCB that can be swapped out when the coil gets damaged due to overheating, keeping the driver intact. Version 2 was used for many months, but it had its limitations, including the degradation of coils due to excess heat. Because it contained many components, remaking the driver part was time-consuming.

Below are the links for previous Hotplate projects:

https://www.hackster.io/Arnov_Sharma_makes/pcb-hotplate-mini-edition-b9cf84

https://www.hackster.io/Arnov_Sharma_makes/pcb-hotplate-slightly-bigger-edition-6a8ed8

PCB Design

The PCB design of this project starts with the driver board schematic, which contains the MCU, which in our case is the XIAO ESP32 C3 Board, 8 LEDs connected to XIAO's GPIO pins, a Mosfet as switch setup that is driven by another FET, an input section consisting of a DC jack, a diode, and an LED, and the AMS1117 setup for stepping-down input voltage for XIAO to work.

Let's examine the mosfet arrangement used as a switch. Since the GPIO can only supply a maximum of 3.3V while the IRFZ44N's gate voltage ranges from 5 to 12V, the mosfet's gate won't be fully open, and it won't be able to drive the coil as efficiently. In order to do this, we place a smaller mosfet between the Z44N's VCC and gate. The gate of this tiny mosfet is controlled by 3.3 volts, which is ideal in this situation. Here, any N-channel mosfet will work, but the AO3400 mosfet is what we have.

To get the 12V from the DC Jack down to a reliable 5V so that XIAO could operate, an AMS1117 5V buck converter was used, followed by a 10uF and 1uF capacitor on the input and output sides, respectively.

The driver PCB, which measures 95mm x 95mm and comprises an XIAO on one side and a DC Jack on the other, a Mosfet added on the left side of the board, and a switch added on the right side, was created using the schematic.

After completing the driver PCB, we created the coil PCB, which has only two CON1 ports but the same board layout and mounting holes as the driver PCB.

XIAO ESP32 C3

The XIAO ESP32-C3 Dev Board is a microcontroller development board based on the ESP32-C3 chip, which is part of the ESP32 family of microcontrollers developed by Espressif Systems. Here's a breakdown of its key components and features:

ESP32-C3 Chip:

The ESP32-C3 is a highly integrated Wi-Fi and Bluetooth LE (Low Energy) chip. It features a single-core 32-bit RISC-V CPU, operating at up to 160 MHz. The chip also includes Wi-Fi connectivity (802.11 b/g/n), Bluetooth LE 5.0, and a wide range of peripherals, making it suitable for various IoT (Internet of Things) applications.

Development Board:

The XIAO ESP32-C3 Dev Board is designed to provide an easy and convenient platform for developing IoT projects and prototypes. It typically includes the following components:

• ESP32-C3 Chip: The central processing unit that runs your code and manages communication with other devices
• Memory: The board might include Flash memory for storing your program and data. The ESP32-C3 usually integrates flash memory directly on the chip.
• GPIO Pins: General Purpose Input/Output pins allow you to connect the board to other hardware components such as sensors, LEDs, or displays.
• USB Interface: Often, there's a USB interface for programming the board and for serial communication with a computer.
• Power Supply: A power input (usually micro USB) for supplying power to the board.
• Onboard LED: A built-in LED that you can use for basic visual feedback or debugging.

Features and capabilities:

• Wireless Connectivity: The ESP32-C3 chip supports Wi-Fi, allowing your projects to connect to local networks and the internet. It also supports Bluetooth Low Energy, enabling communication with other BLE devices.
• Low Power Consumption: The ESP32-C3 is designed for low-power operation, making it suitable for battery-powered applications.
• Rich Peripherals: The chip includes various interfaces such as UART, SPI, I2C, ADC (Analog-to-Digital Converter), and PWM (Pulse Width Modulation), providing versatility for connecting sensors and other external devices.
• Programming and Development: You can program the ESP32-C3 Dev Board using the Arduino IDE, PlatformIO, or other popular development environments. There are libraries and resources available to facilitate development.
• Community Support: Being part of the ESP32 family, the board benefits from a large and active community. This means ample resources, tutorials, and community support for developers.

Breadboard Version and CODE

Before beginning this project, we created a test board on a breadboard with eight tiny LEDs attached to D2 to D9 of the XIAO ESP32 S3 GPIO ports.

D0 is connected to a single 10mm LED, and D2 is pulled-down connected to D0 through a switch.

This configuration was created to test the code that will trigger the 10mm LED when a button is pressed. All eight of the tiny LEDs are triggered simultaneously and begin to run in a chaser pattern. After three seconds of long button presses, the entire setup is turned off.

The BJT will take the place of the 10mm LEDs, controlling the Mosfet to power the COIL Board. For the duration of the hotplate's operation, 8 LEDs will be running in the chaser pattern.

Let's take a look at the code:

int switchPin = D1;     //4         
int led1Pin = D0;        //0

int pinsCount=9;                        // declaring the integer variable pinsCount
int pins[] = {D2,D3,D4,D5,D6,D7,D8,D9};  

int val;                        
int val2;                       
int buttonState;                
int Mode ; //= 0;              

void setup() 
{
pinMode(switchPin, INPUT_PULLUP);    
pinMode(led1Pin, OUTPUT);

  pinMode(D9, OUTPUT);
  pinMode(D2, OUTPUT);
  pinMode(D3, OUTPUT);
  pinMode(D4, OUTPUT);
  pinMode(D5, OUTPUT);
  pinMode(D6, OUTPUT);
  pinMode(D7, OUTPUT);
  pinMode(D8, OUTPUT);


buttonState = digitalRead(switchPin); 
}

void loop(){
 
      val = digitalRead(switchPin);      // read input value and store it in val
      delay(10);                         // 10 milliseconds is a good amount of time
      val2 = digitalRead(switchPin);     // read the input again to check for bounces
      
      if (val == val2) {                 // make sure we got 2 consistant readings!
        if (val != buttonState) {          // the button state has changed!
          if (val == HIGH) {                // check if the button is pressed
            if (Mode == 0) {         
              Mode = 1;               
            } else {
                if (Mode == 1) {       
                Mode = 0;           
            } 
       }
      }
        buttonState = val;                 // save the new state in our variable
      }

      // Now do whatever the lightMode indicates
      if (Mode == 0) {                       // FLIP FLOP
        digitalWrite(led1Pin, LOW);
      }

      if (Mode == 1) {
        digitalWrite(led1Pin, HIGH);   //HIGH
   Chase();
      }
}
}

void Chase (void)
{
    for (int i=0; i<pinsCount; i=i+1){    // chasing right
    digitalWrite(pins[i], HIGH);         // switching the LED at index i on
    delay(100);                          // stopping the program for 100 milliseconds
    digitalWrite(pins[i], LOW);          // switching the LED at index i off
  }

}

Pin Assignments:

int switchPin = D1;     // Pin D1 is used for the switch
int led1Pin = D0;        // Pin D0 is used for the first LED
int pinsCount = 9;       // Number of LEDs to control
int pins[] = {D2, D3, D4, D5, D6, D7, D8, D9};  // Pins for the remaining 8 LEDs

The code uses digital pins D0 to D9 on an Arduino board for controlling LEDs and reading the state of a switch connected to pin D1.

Variables:

int val;
int val2;
int buttonState;
int Mode;  // Mode variable to toggle between different LED light patterns (0 or 1)

• val and val2 are variables to store the state of the switch.
• buttonState keeps track of the previous state of the switch.
• Mode is a variable that toggles between two states (0 and 1) representing different LED light patterns.

Setup:

void setup() {
    pinMode(switchPin, INPUT_PULLUP);  // Configuring switchPin as input with internal pull-up resistor
    pinMode(led1Pin, OUTPUT);          // Configuring led1Pin as output for the first LED
    // Configuring other pins as output for the remaining LEDs
    for (int i = 0; i < pinsCount; ++i) {
        pinMode(pins[i], OUTPUT);
    }
    buttonState = digitalRead(switchPin);  // Reading initial state of the switch
}

• The setup() function configures switchPin as an input with an internal pull-up resistor and led1Pin as an output. It also sets up the other pins in the pins array as outputs for controlling LEDs. buttonState is initialized with the initial state of the switch.

Loop:

void loop() {
    // ... (switch reading logic)
    if (Mode == 0) {
        digitalWrite(led1Pin, LOW);   // Turning off the first LED if Mode is 0
    }
    if (Mode == 1) {
        digitalWrite(led1Pin, HIGH);  // Turning on the first LED if Mode is 1
        Chase();  // Calling the Chase function to activate the chasing LED pattern
    }
}

• In the loop() function, the code reads the state of the switch. If the switch state changes (indicating a press), it toggles the Mode variable between 0 and 1. When Mode is 1, it turns on the first LED and activates the Chase() function, creating a chasing LED pattern.

Chase Function:

void Chase() {
    for (int i = 0; i < pinsCount; ++i) {
        digitalWrite(pins[i], HIGH);  // Turning on the current LED
        delay(100);                   // Delay for 100 milliseconds
        digitalWrite(pins[i], LOW);   // Turning off the current LED
    }
}

• The Chase() function is responsible for the chasing LED pattern. It iterates through the LEDs, turning them on one by one with a delay of 100 milliseconds, creating the chasing effect.

In summary, this code allows you to toggle between two modes using a switch. In mode 0, the first LED is turned off. In mode 1, the first LED is turned on, and the subsequent LEDs light up in a chasing pattern.

Seeed Fusion PCB Service

For this project, we are using two PCBs along with an XIAO ESP32 C3 DEV Board, which were provided by Seeed Studio.

The order was placed with a yellow solder mask and a white silkscreen for both the coil board and the driver board.

The quality was super good considering the rate, which was also pretty low.

Seeed Fusionoffers one-stop prototyping for PCB manufacture and PCB assembly, and as a result, they produce superior-quality PCBs and fast-turnkey PCBA within 7 working days.

Seeed Studio Fusion PCB Assembly Servicetakes care of the entire fabrication process, from PCB manufacturing, parts sourcing, assembly, and testing services, so you can be sure that they are getting a quality product.

After gauging market interest and verifying a working prototype, Seeed Propagate Service can help you bring the product to market with professional guidance and a strong network of connections.

PCB Assembly Process

• Using a solder paste dispensing syringe, we first apply solder paste to each component pad individually to begin the PCB assembly process.
• Next, we pick and place each component in its location using an ESD tweezer.
• Following pick and place, we lift the PCB and place it on the reflow hotplate, which increases the temperature of the PCB from below to the point at which solder paste begins to melt and components are soldered to their pads.
• The mosfet, connection, DC Jack, vertical switch, and diode were the next THT components we placed on the PCB.
• All the THT parts are soldered to their pads using a standard soldering iron.
• Using M2 nuts and bolts, we attach the mosfet to the PCB, connecting its heatpad to the opening on the bottom side to provide the mosfet with a small heating area. On the bottom side of the PCB, we have left an opening that is connected to the mosfet's drain.

The PCB is now complete.

Final Assembly

• We begin the assembly process by first adding silver copper wire to the coil board's terminal and attaching the copper wire to the driver board's CON2 port.
• To hold the two boards together, we next attach four M3 40mm-long PCB standoffs to the driver board and attach the coil board to the lower driver board using M3 screws.

The circuit is now assembled.

Testing Process

We use an external temperature meter with a K type probe that is mounted to the underside of the coil board using Kapton tape because this arrangement lacks an onboard temperature meter.

When the hotplate and 12V adaptor are connected, pressing the button will turn on the chasing LEDs, including the mosfet, and the temperature will slowly start to rise, confirming that the device is operating.

After a few minutes of waiting, the temperature that was obtained at the highest point was only 130 degrees C, which is insufficient to melt solder paste.

Problem

Let's take a closer look at what specifically caused the issue we ran into at this step.

A test board with solder paste and an SOIC8 IC added to it is first prepared.

Solder paste should melt and an IC should be connected to its pads when this board is placed on a hotplate, but this is not the case.

Our maximum temperature was 130 degrees Celsius, which was insufficient to properly melt the solder paste.

This problem is being caused by the COIL's resistance, which is 4.6 ohms; the previous Hotplate coil's resistance was 1.7 ohms, which is incredibly low.

We must modify the coil board and the resistance value in order to fix this issue because it is well known that, when the same voltage is applied, a lower resistance value will heat up more quickly and effectively than a higher resistance value.

Changing the number of coils and thickness with shape will fix this issue.

Using Old Hotplate's Coil

Coil Board functioned, but the low temperature readings indicated that the only item it could heat up—instead of the solder paste—was a coffee mug.

We use Version 2 Hotplate PCB with the most current driver board while reflowing PCBs, and we repeat the reflow test.

The best thing about this project is that we only need to remake the coil PCB, which will be incredibly easy to edit and replace. We get a maximum temperature of 210 °C, which is what we needed for reflow.

RESULT

We take a small PCB, apply solder paste to its pads, and then attach an SOIC8 IC to it before putting it on the coil region of the V2 PCB in order to adequately test the driver board with the temporary arrangement.

The setup was successful when the temperature quickly reached 210+ degrees C and solder paste melted. The driver portion is currently operational, and with the help of the previous PCB version, we may use this configuration for the upcoming several projects before changing the coil pcb. At this point, we simply need to change the coil layer and the project will be ready to use.

Conclusion and improvements

The coil PCB still needs to be edited, and the resistance of the existing coil PCB, which is 4.6 ohms, needs to be reduced to 1.5 ohms or less. As a result, a new PCB with thinner tracks and a shorter coil had to be created.

This project was a success because it demonstrates how simple it is to construct your own PCB hotplate. In the upcoming revision, the coil pcb will be changed to allow for a maximum temperature of 210+ Degree C.

Overall, I'm pretty happy with the result.

All the documents related to the project are attached. If you need any help regarding this project, DM me or leave a comment.

Special thanks to Seeed Fusion for providing PCBs for this project; do check them out if you need great PCB service for less cost.

Peace out, and I'll be back with a new project soon!