SMT hotplate

I used to process SMT boards by cooking them in a large, heavy frying pan. This worked reasonably well, but the results were sometimes a bit erratic.

A friend gave me a hotplate that he had bought on AliBaba, and couldn't find a use for. I tried using it to process SMT boards, but it uses an PTC element to regulate the temperature, and it got too hot (250C).

After some research, I found that there is a standard temperature profile for SMT reflow ovens: I decided to make a controller that can produce this profile using my hotplate. I would only ever need one controller, so it made sense to use standard parts where possible. These included:

HLK-PM01 mains to 5V
MAX31865 Pt100 interface
ESP-12F

The controller would accept a mains input, both to power the HLK-PM01 module and to feed through a relay to the hotplate. The MAX31865 module measures the resistance of a Pt100 sensor, and passes the information via an SPI interface to an ESP-12 module. Software on the ESP-12 would control the hotplate relay, and also present a web interface to monitor and control progress. Switching mains voltages, and indeed switching a relay, can produce nasty voltage spikes, so I used lots of decoupling capacitors. Here is the circuit diagram:

Pt100 is a good choice for this temperature range, and it is possible to buy encapsulated sensors which should give stable readings in long-term use. Because I was interested in the temperature on the top surface of the PCB, I attached a Pt100 sensor to a PCB using high-temperature silicone sealant: this seemed to give a reasonably accurate temperature reading, compared to an Infra Red thermometer. For maximum accuracy, you should use four wire Pt100 sensors- two wires to provide the sense current, and two more to measure the voltage across the sensor element. This approach eliminates errors due to the voltage drop in the sense current wires. This controller doesn't need particularly high accuracy, so a two wire sensor is adequate.

In a real product, I would have used sockets for the cables in and out, but this is a one-off, so I just used IP65 cable glands: these provide a reasonably secure physical connection. The finished controller looks like this, with the esp-12 on the other side of the board:

I used the Arduino IDE to test the interfaces, then used the ESP SDK to build the complete system.

I wanted to have the possibility of using different temperature profiles: I thought of making a web page to edit the profiles, but decided to simply use structures within the C program- one for each temperature cycle. Controlling the temperature proved to be quite tricky. It took about 20 seconds after turning the relay on before any change in surface temperature occurred. It was therefore necessary to implement a kind of PID controller to track the profile. This is the controller routine:

#include "driver/gpio.h"

#include "heater.h"
#include "app_config.h"
#include "max31865.h"
#include "timer.h"
#define LOGTAG "heater"
#include "log.h"

#define RELAY_PIN 5

CYCLE standard_cycle = {
    "Standard",
    8,
    {
    {60, 50},
    {60, 100},
    {90, 150},
    {60, 150},
    {60, 200},
    {60, 200},
    {60, 240},
    {90, 30},
}
};

CYCLE bigcomp_cycle = {
    "Big components",
    8,
    {
    {60, 50},
    {60, 100},
    {90, 150},
    {60, 150},
    {60, 200},
    {120, 200},
    {60, 240},
    {90, 30},
}
};

CYCLE desolder_cycle = {
    "Desolder",
    7,
    {
    {30, 50},
    {30, 100},
    {60, 200},
    {30, 220},
    {360, 220},
    {60, 150},
    {90, 30},
}
};

CYCLE scrap_cycle = {
    "Scrap",
    4,
    {
    {30, 100},
    {30, 200},
    {30, 240},
    {3600, 240},
}
};

CYCLE * cycles [] = {&standard_cycle, &bigcomp_cycle, &desolder_cycle, &scrap_cycle};
int no_of_cycles = sizeof (cycles)/ sizeof (cycles [0]);

int16_t target [MAX_CYCLE_SECONDS];
int16_t actual [MAX_CYCLE_SECONDS];
uint16_t elapsed_seconds = 0;
uint16_t total_seconds;
int16_t temperature;
int16_t predicted;
int16_t pred_tgt;
bool running = false;
bool relay;

extern APP_CONFIG app_config;

// ---------------------------------------------------------------------

static void create_target (CYCLE *cycle) {

uint16_t start_second = 0;
  int16_t start_temp = temperature;
  predicted = 0;
  
  for (int s = 0; s < cycle->no_of_steps; s++) {
    STEP * sp = &cycle->steps [s];
    for (int i = 0; i < sp->duration; i++) {
      target [start_second + i] = start_temp + (i * (sp->end_temp * 10 - start_temp)) / sp->duration;
    }
    start_second += sp->duration;
    start_temp = sp->end_temp * 10;
  } 
  total_seconds = start_second;
}

static void init_relay (void) {
      //Set up the GPIO lines
    gpio_config_t io_conf;

io_conf.intr_type = GPIO_INTR_DISABLE;
    io_conf.pull_down_en = 0;
    io_conf.pull_up_en = GPIO_PULLUP_DISABLE;
    io_conf.pin_bit_mask = (1UL << RELAY_PIN);
    io_conf.mode = GPIO_MODE_OUTPUT;
    gpio_config(&io_conf);

gpio_set_level (RELAY_PIN, 0);

}

// ---------------------------------------------------------------------
static void heater_task (void *arg) {
    uint16_t prev_s = 0;

init_relay ();

max31865_initialise ();

while (true) {

if (time_s () != prev_s) {
            prev_s = time_s ();

if (running) {
                elapsed_seconds++;

temperature = max31865_get_temp () * 10.0;

if (predicted == 0)
                    predicted = temperature;

if (elapsed_seconds < total_seconds) {
                    actual [elapsed_seconds] = temperature;
                }

if ((running) && (elapsed_seconds + app_config.latency < total_seconds)) {
                    if (relay) {
                        predicted += app_config.rise_per_second;
                        // reduce predicted rise by 10 at 200C
                        predicted -= (temperature * temperature) / (2000 * 200);
                    }
                
                    predicted -= temperature / app_config.cooling_divider;
                    
                    int delta = temperature - target [elapsed_seconds];
                    int squared = delta * delta;
                    if (delta < 0) {
                         squared = -squared;
                    }
                    delta += squared / 50;     
                    pred_tgt =  target [elapsed_seconds + app_config.latency]; 
                    relay = predicted + delta < pred_tgt;
                    LOGIF ("secs %d act %d tgt %d pred %d, delta %d pred_tgt %d relay %d", elapsed_seconds, temperature, target [elapsed_seconds], 
                                        predicted, delta, pred_tgt, relay);
                }
                else
                    relay = false;

gpio_set_level (RELAY_PIN, relay);

if (elapsed_seconds == total_seconds)
                    running = false;

delay_ms (10);
            }
            else {
                temperature = max31865_get_temp () * 10.0;
                LOGIF ("act %d", temperature);
                delay_ms (100);
            }
        }
    }
           
}

// -------------------------------------------------------------------
void heater_start_cycle (CYCLE * cycle) {
    create_target (cycle);
    elapsed_seconds = 0;
    running = true;
}

// -------------------------------------------------------------------

void heater_initialise (void) {
    xTaskCreate(heater_task, "heater", 4096, NULL, 8, NULL);
}

The hotplate works well for most PCBs but, because all the heat comes from below, it does not work very well with large components like inductors or electrolytic capacitors. It is usually necessary to use a soldering iron on these components afterwards.